Add and use dB/linear conversion functions.

[dcpomatic.git] / src / lib / util.cc

diff --git a/src/lib/util.cc b/src/lib/util.cc
index c2089146431614bda8957b4b26e74434653f6414..e4f552c4d7c46177414b1db0e40352847f7bf705 100644 (file)
--- a/src/lib/util.cc
+++ b/src/lib/util.cc
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2012-2019 Carl Hetherington <cth@carlh.net>
+    Copyright (C) 2012-2020 Carl Hetherington <cth@carlh.net>
 
     This file is part of DCP-o-matic.
 
@@ -44,6 +44,7 @@
 #include "ffmpeg_image_proxy.h"
 #include "image.h"
 #include "text_decoder.h"
+#include "job_manager.h"
 #include <dcp/locale_convert.h>
 #include <dcp/util.h>
 #include <dcp/raw_convert.h>
@@ -106,6 +107,7 @@ using boost::scoped_array;
 using dcp::Size;
 using dcp::raw_convert;
 using dcp::locale_convert;
+using namespace dcpomatic;
 
 /** Path to our executable, required by the stacktrace stuff and filled
  *  in during App::onInit().
@@ -379,7 +381,7 @@ dcpomatic_setup ()
        Pango::init ();
        dcp::init ();
 
-#ifdef DCPOMATIC_WINDOWS
+#if defined(DCPOMATIC_WINDOWS) || defined(DCPOMATIC_OSX)
        /* Render something to fontconfig to create its cache */
        list<StringText> subs;
        dcp::SubtitleString ss(
@@ -471,7 +473,7 @@ digest_head_tail (vector<boost::filesystem::path> files, boost::uintmax_t size)
        while (i < int64_t (files.size()) && to_do > 0) {
                FILE* f = fopen_boost (files[i], "rb");
                if (!f) {
-                       throw OpenFileError (files[i].string(), errno, true);
+                       throw OpenFileError (files[i].string(), errno, OpenFileError::READ);
                }
 
                boost::uintmax_t this_time = min (to_do, boost::filesystem::file_size (files[i]));
@@ -491,7 +493,7 @@ digest_head_tail (vector<boost::filesystem::path> files, boost::uintmax_t size)
        while (i >= 0 && to_do > 0) {
                FILE* f = fopen_boost (files[i], "rb");
                if (!f) {
-                       throw OpenFileError (files[i].string(), errno, true);
+                       throw OpenFileError (files[i].string(), errno, OpenFileError::READ);
                }
 
                boost::uintmax_t this_time = min (to_do, boost::filesystem::file_size (files[i]));
@@ -777,7 +779,7 @@ careful_string_filter (string s)
 
 /** @param mapped List of mapped audio channels from a Film.
  *  @param channels Total number of channels in the Film.
- *  @return First: number of non-LFE channels, second: number of LFE channels.
+ *  @return First: number of non-LFE soundtrack channels (L/R/C/Ls/Rs/Lc/Rc/Bsl/Bsr), second: number of LFE channels.
  */
 pair<int, int>
 audio_channel_types (list<int> mapped, int channels)
@@ -791,10 +793,24 @@ audio_channel_types (list<int> mapped, int channels)
                        continue;
                }
 
-               if (static_cast<dcp::Channel> (i) == dcp::LFE) {
+               switch (static_cast<dcp::Channel>(i)) {
+               case dcp::LFE:
                        ++lfe;
-               } else {
+                       break;
+               case dcp::LEFT:
+               case dcp::RIGHT:
+               case dcp::CENTRE:
+               case dcp::LS:
+               case dcp::RS:
+               case dcp::LC:
+               case dcp::RC:
+               case dcp::BSL:
+               case dcp::BSR:
                        ++non_lfe;
+                       break;
+               case dcp::HI:
+               case dcp::VI:
+                       break;
                }
        }
 
@@ -944,6 +960,113 @@ emit_subtitle_image (ContentTimePeriod period, dcp::SubtitleImage sub, dcp::Size
        decoder->emit_bitmap (period, image, rect);
 }
 
+bool
+show_jobs_on_console (bool progress)
+{
+       bool first = true;
+       bool error = false;
+       while (true) {
+
+               dcpomatic_sleep_seconds (5);
+
+               list<shared_ptr<Job> > jobs = JobManager::instance()->get();
+
+               if (!first && progress) {
+                       for (size_t i = 0; i < jobs.size(); ++i) {
+                               cout << "\033[1A\033[2K";
+                       }
+                       cout.flush ();
+               }
+
+               first = false;
+
+               BOOST_FOREACH (shared_ptr<Job> i, jobs) {
+                       if (progress) {
+                               cout << i->name();
+                               if (!i->sub_name().empty()) {
+                                       cout << "; " << i->sub_name();
+                               }
+                               cout << ": ";
+
+                               if (i->progress ()) {
+                                       cout << i->status() << "                            \n";
+                               } else {
+                                       cout << ": Running           \n";
+                               }
+                       }
+
+                       if (!progress && i->finished_in_error()) {
+                               /* We won't see this error if we haven't been showing progress,
+                                  so show it now.
+                               */
+                               cout << i->status() << "\n";
+                       }
+
+                       if (i->finished_in_error()) {
+                               error = true;
+                       }
+               }
+
+               if (!JobManager::instance()->work_to_do()) {
+                       break;
+               }
+       }
+
+       return error;
+}
+
+/** XXX: could use mmap? */
+void
+copy_in_bits (boost::filesystem::path from, boost::filesystem::path to, boost::function<void (float)> progress)
+{
+       FILE* f = fopen_boost (from, "rb");
+       if (!f) {
+               throw OpenFileError (from, errno, OpenFileError::READ);
+       }
+       FILE* t = fopen_boost (to, "wb");
+       if (!t) {
+               fclose (f);
+               throw OpenFileError (to, errno, OpenFileError::WRITE);
+       }
+
+       /* on the order of a second's worth of copying */
+       boost::uintmax_t const chunk = 20 * 1024 * 1024;
+
+       uint8_t* buffer = static_cast<uint8_t*> (malloc(chunk));
+       if (!buffer) {
+               throw std::bad_alloc ();
+       }
+
+       boost::uintmax_t const total = boost::filesystem::file_size (from);
+       boost::uintmax_t remaining = total;
+
+       while (remaining) {
+               boost::uintmax_t this_time = min (chunk, remaining);
+               size_t N = fread (buffer, 1, chunk, f);
+               if (N < this_time) {
+                       fclose (f);
+                       fclose (t);
+                       free (buffer);
+                       throw ReadFileError (from, errno);
+               }
+
+               N = fwrite (buffer, 1, this_time, t);
+               if (N < this_time) {
+                       fclose (f);
+                       fclose (t);
+                       free (buffer);
+                       throw WriteFileError (to, errno);
+               }
+
+               progress (1 - float(remaining) / total);
+               remaining -= this_time;
+       }
+
+       fclose (f);
+       fclose (t);
+       free (buffer);
+}
+
 #ifdef DCPOMATIC_VARIANT_SWAROOP
 
 /* Make up a key from the machine UUID */
@@ -1048,3 +1171,16 @@ write_swaroop_chain (shared_ptr<const dcp::CertificateChain> chain, boost::files
 }
 
 #endif
+
+double
+db_to_linear (double db)
+{
+       return pow(10, db / 20);
+}
+
+double
+linear_to_db (double linear)
+{
+       return 20 * log10(linear);
+}
+