Apply FFmpeg palette fix to examination too; fix build with old FFmpeg.

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

diff --git a/src/lib/util.cc b/src/lib/util.cc
index 3b6be6dcc227625d28574da53b3af4419d893d28..bbb44436713281d5a3a88ee0bec5a265bd2e6efa 100644 (file)
--- a/src/lib/util.cc
+++ b/src/lib/util.cc
@@ -473,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]));
@@ -493,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]));
@@ -779,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)
@@ -793,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;
                }
        }
 
@@ -949,12 +963,11 @@ emit_subtitle_image (ContentTimePeriod period, dcp::SubtitleImage sub, dcp::Size
 bool
 show_jobs_on_console (bool progress)
 {
-       bool should_stop = false;
        bool first = true;
        bool error = false;
-       while (!should_stop) {
+       while (true) {
 
-               dcpomatic_sleep (5);
+               dcpomatic_sleep_seconds (5);
 
                list<shared_ptr<Job> > jobs = JobManager::instance()->get();
 
@@ -967,9 +980,6 @@ show_jobs_on_console (bool progress)
 
                first = false;
 
-               int unfinished = 0;
-               int finished_in_error = 0;
-
                BOOST_FOREACH (shared_ptr<Job> i, jobs) {
                        if (progress) {
                                cout << i->name();
@@ -985,31 +995,78 @@ show_jobs_on_console (bool progress)
                                }
                        }
 
-                       if (!i->finished ()) {
-                               ++unfinished;
-                       }
-
-                       if (i->finished_in_error ()) {
-                               ++finished_in_error;
-                               error = true;
-                       }
-
-                       if (!progress && i->finished_in_error ()) {
+                       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 (unfinished == 0 || finished_in_error != 0) {
-                       should_stop = 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 */