Fix mis-alignment of copied AlignedImages; add some asserts; some docs.
[dcpomatic.git] / src / lib / util.cc
index 3f48d696bbe217aabef7ae7f33b3eeaabe6a3384..29ba91f7c5f7e43155534b8a8c2f1afba3979425 100644 (file)
@@ -35,6 +35,9 @@
 #include <boost/algorithm/string.hpp>
 #include <boost/bind.hpp>
 #include <boost/lambda/lambda.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/thread.hpp>
+#include <boost/filesystem.hpp>
 #include <openjpeg.h>
 #include <openssl/md5.h>
 #include <magick/MagickCore.h>
@@ -55,19 +58,16 @@ extern "C" {
 #include "dcp_content_type.h"
 #include "filter.h"
 #include "screen.h"
-#include "film_state.h"
 #include "sound_processor.h"
 #ifndef DVDOMATIC_DISABLE_PLAYER
 #include "player_manager.h"
 #endif
 
-#ifdef DEBUG_HASH
-#include <mhash.h>
-#endif
-
 using namespace std;
 using namespace boost;
 
+thread::id ui_thread;
+
 /** Convert some number of seconds to a string representation
  *  in hours, minutes and seconds.
  *
@@ -192,37 +192,6 @@ stacktrace (ostream& out, int levels)
 }
 #endif
 
-/** @param s Sample format.
- *  @return String representation.
- */
-string
-audio_sample_format_to_string (AVSampleFormat s)
-{
-       /* Our sample format handling is not exactly complete */
-       
-       switch (s) {
-       case AV_SAMPLE_FMT_S16:
-               return "S16";
-       default:
-               break;
-       }
-
-       return "Unknown";
-}
-
-/** @param s String representation of a sample format, as returned from audio_sample_format_to_string().
- *  @return Sample format.
- */
-AVSampleFormat
-audio_sample_format_from_string (string s)
-{
-       if (s == "S16") {
-               return AV_SAMPLE_FMT_S16;
-       }
-
-       return AV_SAMPLE_FMT_NONE;
-}
-
 /** @return Version of vobcopy that is on the path (and hence that we will use) */
 static string
 vobcopy_version ()
@@ -299,7 +268,9 @@ sigchld_handler (int, siginfo_t* info, void *)
 }
 #endif
 
-/** Call the required functions to set up DVD-o-matic's static arrays, etc. */
+/** Call the required functions to set up DVD-o-matic's static arrays, etc.
+ *  Must be called from the UI thread, if there is one.
+ */
 void
 dvdomatic_setup ()
 {
@@ -309,6 +280,8 @@ dvdomatic_setup ()
        Filter::setup_filters ();
        SoundProcessor::setup_sound_processors ();
 
+       ui_thread = this_thread::get_id ();
+
 #ifdef DVDOMATIC_POSIX 
        struct sigaction sa;
        sa.sa_flags = SA_SIGINFO;
@@ -347,28 +320,26 @@ split_at_spaces_considering_quotes (string s)
        return out;
 }
 
-#ifdef DEBUG_HASH
-void
-md5_data (string title, void const * data, int size)
+string
+md5_digest (void const * data, int size)
 {
-       MHASH ht = mhash_init (MHASH_MD5);
-       if (ht == MHASH_FAILED) {
-               throw EncodeError ("could not create hash thread");
-       }
-
-       mhash (ht, data, size);
-       
-       uint8_t hash[16];
-       mhash_deinit (ht, hash);
+       MD5_CTX md5_context;
+       MD5_Init (&md5_context);
+       MD5_Update (&md5_context, data, size);
+       unsigned char digest[MD5_DIGEST_LENGTH];
+       MD5_Final (digest, &md5_context);
        
-       printf ("%s [%d]: ", title.c_str (), size);
-       for (int i = 0; i < int (mhash_get_block_size (MHASH_MD5)); ++i) {
-               printf ("%.2x", hash[i]);
+       stringstream s;
+       for (int i = 0; i < MD5_DIGEST_LENGTH; ++i) {
+               s << hex << setfill('0') << setw(2) << ((int) digest[i]);
        }
-       printf ("\n");
+
+       return s.str ();
 }
-#endif
 
+/** @param file File name.
+ *  @return MD5 digest of file's contents.
+ */
 string
 md5_digest (string file)
 {
@@ -404,6 +375,27 @@ md5_digest (string file)
        return s.str ();
 }
 
+DCPFrameRate
+dcp_frame_rate (float fps)
+{
+       DCPFrameRate dfr;
+
+       dfr.run_fast = (fps != rint (fps));
+       dfr.frames_per_second = rint (fps);
+       dfr.skip = 1;
+
+       /* XXX: somewhat arbitrary */
+       if (fps == 50) {
+               dfr.frames_per_second = 25;
+               dfr.skip = 2;
+       }
+
+       return dfr;
+}
+
+/** @param An arbitrary sampling rate.
+ *  @return The appropriate DCP-approved sampling rate (48kHz or 96kHz).
+ */
 int
 dcp_audio_sample_rate (int fs)
 {
@@ -414,6 +406,11 @@ dcp_audio_sample_rate (int fs)
        return 96000;
 }
 
+bool operator== (Size const & a, Size const & b)
+{
+       return (a.width == b.width && a.height == b.height);
+}
+
 bool operator== (Crop const & a, Crop const & b)
 {
        return (a.left == b.left && a.right == b.right && a.top == b.top && a.bottom == b.bottom);
@@ -424,6 +421,9 @@ bool operator!= (Crop const & a, Crop const & b)
        return !(a == b);
 }
 
+/** @param index Colour LUT index.
+ *  @return Human-readable name.
+ */
 string
 colour_lut_index_to_name (int index)
 {
@@ -438,9 +438,9 @@ colour_lut_index_to_name (int index)
        return "";
 }
 
-DeadlineWrapper::DeadlineWrapper (asio::io_service& io_service)
-       : _io_service (io_service)
-       , _deadline (io_service)
+Socket::Socket ()
+       : _deadline (_io_service)
+       , _socket (_io_service)
        , _buffer_data (0)
 {
        _deadline.expires_at (posix_time::pos_infin);
@@ -448,49 +448,46 @@ DeadlineWrapper::DeadlineWrapper (asio::io_service& io_service)
 }
 
 void
-DeadlineWrapper::set_socket (shared_ptr<asio::ip::tcp::socket> socket)
-{
-       _socket = socket;
-}
-
-void
-DeadlineWrapper::check ()
+Socket::check ()
 {
        if (_deadline.expires_at() <= asio::deadline_timer::traits_type::now ()) {
-               if (_socket) {
-                       _socket->close ();
-               }
+               _socket.close ();
                _deadline.expires_at (posix_time::pos_infin);
        }
 
-       _deadline.async_wait (boost::bind (&DeadlineWrapper::check, this));
+       _deadline.async_wait (boost::bind (&Socket::check, this));
 }
 
+/** Blocking connect with timeout.
+ *  @param endpoint End-point to connect to.
+ *  @param timeout Time-out in seconds.
+ */
 void
-DeadlineWrapper::connect (asio::ip::basic_resolver_entry<asio::ip::tcp> const & endpoint, int timeout)
+Socket::connect (asio::ip::basic_resolver_entry<asio::ip::tcp> const & endpoint, int timeout)
 {
-       assert (_socket);
-       
        system::error_code ec = asio::error::would_block;
-       _socket->async_connect (endpoint, lambda::var(ec) = lambda::_1);
+       _socket.async_connect (endpoint, lambda::var(ec) = lambda::_1);
        do {
                _io_service.run_one();
        } while (ec == asio::error::would_block);
 
-       if (ec || !_socket->is_open ()) {
+       if (ec || !_socket.is_open ()) {
                throw NetworkError ("connect timed out");
        }
 }
 
+/** Blocking write with timeout.
+ *  @param data Buffer to write.
+ *  @param size Number of bytes to write.
+ *  @param timeout Time-out, in seconds.
+ */
 void
-DeadlineWrapper::write (uint8_t const * data, int size, int timeout)
+Socket::write (uint8_t const * data, int size, int timeout)
 {
-       assert (_socket);
-
        _deadline.expires_from_now (posix_time::seconds (timeout));
        system::error_code ec = asio::error::would_block;
 
-       asio::async_write (*_socket, asio::buffer (data, size), lambda::var(ec) = lambda::_1);
+       asio::async_write (_socket, asio::buffer (data, size), lambda::var(ec) = lambda::_1);
        do {
                _io_service.run_one ();
        } while (ec == asio::error::would_block);
@@ -500,17 +497,20 @@ DeadlineWrapper::write (uint8_t const * data, int size, int timeout)
        }
 }
 
+/** Blocking read with timeout.
+ *  @param data Buffer to read to.
+ *  @param size Number of bytes to read.
+ *  @param timeout Time-out, in seconds.
+ */
 int
-DeadlineWrapper::read (uint8_t* data, int size, int timeout)
+Socket::read (uint8_t* data, int size, int timeout)
 {
-       assert (_socket);
-
        _deadline.expires_from_now (posix_time::seconds (timeout));
        system::error_code ec = asio::error::would_block;
 
        int amount_read = 0;
 
-       _socket->async_read_some (
+       _socket.async_read_some (
                asio::buffer (data, size),
                (lambda::var(ec) = lambda::_1, lambda::var(amount_read) = lambda::_2)
                );
@@ -531,7 +531,7 @@ DeadlineWrapper::read (uint8_t* data, int size, int timeout)
  *  @param size Amount of data to consume, in bytes.
  */
 void
-DeadlineWrapper::consume (int size)
+Socket::consume (int size)
 {
        assert (_buffer_data >= size);
        
@@ -548,7 +548,7 @@ DeadlineWrapper::consume (int size)
  *  @param size Number of bytes to read.
  */
 void
-DeadlineWrapper::read_definite_and_consume (uint8_t* data, int size, int timeout)
+Socket::read_definite_and_consume (uint8_t* data, int size, int timeout)
 {
        int const from_buffer = min (_buffer_data, size);
        if (from_buffer > 0) {
@@ -577,7 +577,7 @@ DeadlineWrapper::read_definite_and_consume (uint8_t* data, int size, int timeout
  *  @param size Maximum amount of data to read.
  */
 void
-DeadlineWrapper::read_indefinite (uint8_t* data, int size, int timeout)
+Socket::read_indefinite (uint8_t* data, int size, int timeout)
 {
        assert (size < int (sizeof (_buffer)));
 
@@ -600,3 +600,296 @@ DeadlineWrapper::read_indefinite (uint8_t* data, int size, int timeout)
        assert (size >= _buffer_data);
        memcpy (data, _buffer, size);
 }
+
+Rect
+Rect::intersection (Rect const & other) const
+{
+       int const tx = max (x, other.x);
+       int const ty = max (y, other.y);
+       
+       return Rect (
+               tx, ty,
+               min (x + width, other.x + other.width) - tx,
+               min (y + height, other.y + other.height) - ty
+               );
+}
+
+/** Round a number up to the nearest multiple of another number.
+ *  @param a Number to round.
+ *  @param t Multiple to round to.
+ *  @return Rounded number.
+ */
+
+int
+stride_round_up (int c, int const * stride, int t)
+{
+       int const a = stride[c] + (t - 1);
+       return a - (a % t);
+}
+
+int
+stride_lookup (int c, int const * stride)
+{
+       return stride[c];
+}
+
+/** Read a sequence of key / value pairs from a text stream;
+ *  the keys are the first words on the line, and the values are
+ *  the remainder of the line following the key.  Lines beginning
+ *  with # are ignored.
+ *  @param s Stream to read.
+ *  @return key/value pairs.
+ */
+multimap<string, string>
+read_key_value (istream &s) 
+{
+       multimap<string, string> kv;
+       
+       string line;
+       while (getline (s, line)) {
+               if (line.empty ()) {
+                       continue;
+               }
+
+               if (line[0] == '#') {
+                       continue;
+               }
+
+               if (line[line.size() - 1] == '\r') {
+                       line = line.substr (0, line.size() - 1);
+               }
+
+               size_t const s = line.find (' ');
+               if (s == string::npos) {
+                       continue;
+               }
+
+               kv.insert (make_pair (line.substr (0, s), line.substr (s + 1)));
+       }
+
+       return kv;
+}
+
+string
+get_required_string (multimap<string, string> const & kv, string k)
+{
+       if (kv.count (k) > 1) {
+               throw StringError ("unexpected multiple keys in key-value set");
+       }
+
+       multimap<string, string>::const_iterator i = kv.find (k);
+       
+       if (i == kv.end ()) {
+               throw StringError (String::compose ("missing key %1 in key-value set", k));
+       }
+
+       return i->second;
+}
+
+int
+get_required_int (multimap<string, string> const & kv, string k)
+{
+       string const v = get_required_string (kv, k);
+       return lexical_cast<int> (v);
+}
+
+float
+get_required_float (multimap<string, string> const & kv, string k)
+{
+       string const v = get_required_string (kv, k);
+       return lexical_cast<float> (v);
+}
+
+string
+get_optional_string (multimap<string, string> const & kv, string k)
+{
+       if (kv.count (k) > 1) {
+               throw StringError ("unexpected multiple keys in key-value set");
+       }
+
+       multimap<string, string>::const_iterator i = kv.find (k);
+       if (i == kv.end ()) {
+               return "";
+       }
+
+       return i->second;
+}
+
+int
+get_optional_int (multimap<string, string> const & kv, string k)
+{
+       if (kv.count (k) > 1) {
+               throw StringError ("unexpected multiple keys in key-value set");
+       }
+
+       multimap<string, string>::const_iterator i = kv.find (k);
+       if (i == kv.end ()) {
+               return 0;
+       }
+
+       return lexical_cast<int> (i->second);
+}
+
+/** Construct an AudioBuffers.  Audio data is undefined after this constructor.
+ *  @param channels Number of channels.
+ *  @param frames Number of frames to reserve space for.
+ */
+AudioBuffers::AudioBuffers (int channels, int frames)
+       : _channels (channels)
+       , _frames (frames)
+       , _allocated_frames (frames)
+{
+       _data = new float*[_channels];
+       for (int i = 0; i < _channels; ++i) {
+               _data[i] = new float[frames];
+       }
+}
+
+/** Copy constructor.
+ *  @param other Other AudioBuffers; data is copied.
+ */
+AudioBuffers::AudioBuffers (AudioBuffers const & other)
+       : _channels (other._channels)
+       , _frames (other._frames)
+       , _allocated_frames (other._frames)
+{
+       _data = new float*[_channels];
+       for (int i = 0; i < _channels; ++i) {
+               _data[i] = new float[_frames];
+               memcpy (_data[i], other._data[i], _frames * sizeof (float));
+       }
+}
+
+AudioBuffers::~AudioBuffers ()
+{
+       for (int i = 0; i < _channels; ++i) {
+               delete[] _data[i];
+       }
+
+       delete[] _data;
+}
+
+/** @param c Channel index.
+ *  @return Buffer for this channel.
+ */
+float*
+AudioBuffers::data (int c) const
+{
+       assert (c >= 0 && c < _channels);
+       return _data[c];
+}
+
+/** Set the number of frames that these AudioBuffers will report themselves
+ *  as having.
+ *  @param f Frames; must be less than or equal to the number of allocated frames.
+ */
+void
+AudioBuffers::set_frames (int f)
+{
+       assert (f <= _allocated_frames);
+       _frames = f;
+}
+
+/** Make all samples on all channels silent */
+void
+AudioBuffers::make_silent ()
+{
+       for (int i = 0; i < _channels; ++i) {
+               make_silent (i);
+       }
+}
+
+/** Make all samples on a given channel silent.
+ *  @param c Channel.
+ */
+void
+AudioBuffers::make_silent (int c)
+{
+       assert (c >= 0 && c < _channels);
+       
+       for (int i = 0; i < _frames; ++i) {
+               _data[c][i] = 0;
+       }
+}
+
+/** Copy data from another AudioBuffers to this one.  All channels are copied.
+ *  @param from AudioBuffers to copy from; must have the same number of channels as this.
+ *  @param frames_to_copy Number of frames to copy.
+ *  @param read_offset Offset to read from in `from'.
+ *  @param write_offset Offset to write to in `to'.
+ */
+void
+AudioBuffers::copy_from (AudioBuffers* from, int frames_to_copy, int read_offset, int write_offset)
+{
+       assert (from->channels() == channels());
+
+       assert (from);
+       assert (read_offset >= 0 && (read_offset + frames_to_copy) <= from->_allocated_frames);
+       assert (write_offset >= 0 && (write_offset + frames_to_copy) <= _allocated_frames);
+
+       for (int i = 0; i < _channels; ++i) {
+               memcpy (_data[i] + write_offset, from->_data[i] + read_offset, frames_to_copy * sizeof(float));
+       }
+}
+
+/** Move audio data around.
+ *  @param from Offset to move from.
+ *  @param to Offset to move to.
+ *  @param frames Number of frames to move.
+ */
+    
+void
+AudioBuffers::move (int from, int to, int frames)
+{
+       if (frames == 0) {
+               return;
+       }
+       
+       assert (from >= 0);
+       assert (from < _frames);
+       assert (to >= 0);
+       assert (to < _frames);
+       assert (frames > 0);
+       assert (frames <= _frames);
+       assert ((from + frames) <= _frames);
+       assert ((to + frames) <= _frames);
+       
+       for (int i = 0; i < _channels; ++i) {
+               memmove (_data[i] + to, _data[i] + from, frames * sizeof(float));
+       }
+}
+
+/** Trip an assert if the caller is not in the UI thread */
+void
+ensure_ui_thread ()
+{
+       assert (this_thread::get_id() == ui_thread);
+}
+
+/** @param v Source video frame.
+ *  @param audio_sample_rate Source audio sample rate.
+ *  @param frames_per_second Number of video frames per second.
+ *  @return Equivalent number of audio frames for `v'.
+ */
+int64_t
+video_frames_to_audio_frames (SourceFrame v, float audio_sample_rate, float frames_per_second)
+{
+       return ((int64_t) v * audio_sample_rate / frames_per_second);
+}
+
+/** @param f Filename.
+ *  @return true if this file is a still image, false if it is something else.
+ */
+bool
+still_image_file (string f)
+{
+#if BOOST_FILESYSTEM_VERSION == 3
+       string ext = boost::filesystem::path(f).extension().string();
+#else
+       string ext = boost::filesystem::path(f).extension();
+#endif
+
+       transform (ext.begin(), ext.end(), ext.begin(), ::tolower);
+       
+       return (ext == ".tif" || ext == ".tiff" || ext == ".jpg" || ext == ".jpeg" || ext == ".png");
+}