Try to fix build on OS X.
[libdcp.git] / src / mono_picture_asset.cc
index c446408d2a502c4fe61ad2e826cd3dabf07523c0..27d879498c055c5b820a4e80c8ee299b65a393a5 100644 (file)
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2012-2013 Carl Hetherington <cth@carlh.net>
+    Copyright (C) 2012-2014 Carl Hetherington <cth@carlh.net>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
 #include "AS_DCP.h"
 #include "KM_fileio.h"
 #include "exceptions.h"
+#include "dcp_assert.h"
 #include "mono_picture_frame.h"
+#include "compose.hpp"
 
 using std::string;
 using std::vector;
+using std::list;
+using std::pair;
 using boost::shared_ptr;
 using boost::dynamic_pointer_cast;
-using boost::lexical_cast;
-using namespace libdcp;
+using namespace dcp;
 
-MonoPictureAsset::MonoPictureAsset (boost::filesystem::path directory, boost::filesystem::path mxf_name)
-       : PictureAsset (directory, mxf_name)
-{
-
-}
-
-void
-MonoPictureAsset::create (vector<boost::filesystem::path> const & files)
-{
-       create (boost::bind (&MonoPictureAsset::path_from_list, this, _1, files));
-}
-
-void
-MonoPictureAsset::create (boost::function<boost::filesystem::path (int)> get_path)
-{
-       ASDCP::JP2K::CodestreamParser j2k_parser;
-       ASDCP::JP2K::FrameBuffer frame_buffer (4 * Kumu::Megabyte);
-       Kumu::Result_t r = j2k_parser.OpenReadFrame (get_path(0).string().c_str(), frame_buffer);
-       if (ASDCP_FAILURE (r)) {
-               boost::throw_exception (FileError ("could not open JPEG2000 file for reading", get_path(0), r));
-       }
-       
-       ASDCP::JP2K::PictureDescriptor picture_desc;
-       j2k_parser.FillPictureDescriptor (picture_desc);
-       picture_desc.EditRate = ASDCP::Rational (_edit_rate, 1);
-       
-       ASDCP::WriterInfo writer_info;
-       fill_writer_info (&writer_info, _uuid, _metadata);
-       
-       ASDCP::JP2K::MXFWriter mxf_writer;
-       r = mxf_writer.OpenWrite (path().string().c_str(), writer_info, picture_desc, 16384, false);
-       if (ASDCP_FAILURE (r)) {
-               boost::throw_exception (MXFFileError ("could not open MXF file for writing", path().string(), r));
-       }
-
-       for (int i = 0; i < _intrinsic_duration; ++i) {
-
-               boost::filesystem::path const path = get_path (i);
-
-               Kumu::Result_t r = j2k_parser.OpenReadFrame (path.string().c_str(), frame_buffer);
-               if (ASDCP_FAILURE (r)) {
-                       boost::throw_exception (FileError ("could not open JPEG2000 file for reading", path, r));
-               }
-
-               r = mxf_writer.WriteFrame (frame_buffer, _encryption_context, 0);
-               if (ASDCP_FAILURE (r)) {
-                       boost::throw_exception (MXFFileError ("error in writing video MXF", this->path().string(), r));
-               }
-
-               if (_progress) {
-                       (*_progress) (0.5 * float (i) / _intrinsic_duration);
-               }
-       }
-       
-       r = mxf_writer.Finalize();
-       if (ASDCP_FAILURE (r)) {
-               boost::throw_exception (MXFFileError ("error in finalising video MXF", path().string(), r));
-       }
-}
-
-void
-MonoPictureAsset::read ()
+MonoPictureAsset::MonoPictureAsset (boost::filesystem::path file)
+       : PictureAsset (file)
 {
        ASDCP::JP2K::MXFReader reader;
-       Kumu::Result_t r = reader.OpenRead (path().string().c_str());
+       Kumu::Result_t r = reader.OpenRead (file.string().c_str());
        if (ASDCP_FAILURE (r)) {
-               boost::throw_exception (MXFFileError ("could not open MXF file for reading", path().string(), r));
+               boost::throw_exception (MXFFileError ("could not open MXF file for reading", file.string(), r));
        }
-       
+
        ASDCP::JP2K::PictureDescriptor desc;
        if (ASDCP_FAILURE (reader.FillPictureDescriptor (desc))) {
                boost::throw_exception (DCPReadError ("could not read video MXF information"));
        }
 
-       _size.width = desc.StoredWidth;
-       _size.height = desc.StoredHeight;
-       _edit_rate = desc.EditRate.Numerator;
-       assert (desc.EditRate.Denominator == 1);
-       _intrinsic_duration = desc.ContainerDuration;
+       read_picture_descriptor (desc);
+
+       ASDCP::WriterInfo info;
+       if (ASDCP_FAILURE (reader.FillWriterInfo (info))) {
+               boost::throw_exception (DCPReadError ("could not read video MXF information"));
+       }
+
+       _id = read_writer_info (info);
 }
 
-boost::filesystem::path
-MonoPictureAsset::path_from_list (int f, vector<boost::filesystem::path> const & files) const
+MonoPictureAsset::MonoPictureAsset (Fraction edit_rate)
+       : PictureAsset (edit_rate)
 {
-       return files[f];
+
 }
 
 shared_ptr<const MonoPictureFrame>
 MonoPictureAsset::get_frame (int n) const
 {
-       return shared_ptr<const MonoPictureFrame> (new MonoPictureFrame (path(), n, _decryption_context));
+       return shared_ptr<const MonoPictureFrame> (new MonoPictureFrame (_file, n, _decryption_context));
+}
+
+static void
+storing_note_handler (list<pair<NoteType, string> >& notes, NoteType t, string s)
+{
+       notes.push_back (make_pair (t, s));
 }
 
 bool
-MonoPictureAsset::equals (shared_ptr<const Asset> other, EqualityOptions opt, boost::function<void (NoteType, string)> note) const
+MonoPictureAsset::equals (shared_ptr<const Asset> other, EqualityOptions opt, NoteHandler note) const
 {
-       if (!MXFAsset::equals (other, opt, note)) {
+       if (!dynamic_pointer_cast<const MonoPictureAsset> (other)) {
                return false;
        }
 
        ASDCP::JP2K::MXFReader reader_A;
-       Kumu::Result_t r = reader_A.OpenRead (path().string().c_str());
+       Kumu::Result_t r = reader_A.OpenRead (_file.string().c_str());
        if (ASDCP_FAILURE (r)) {
-               boost::throw_exception (MXFFileError ("could not open MXF file for reading", path().string(), r));
+               boost::throw_exception (MXFFileError ("could not open MXF file for reading", _file.string(), r));
        }
-       
+
        ASDCP::JP2K::MXFReader reader_B;
-       r = reader_B.OpenRead (other->path().string().c_str());
+       r = reader_B.OpenRead (other->file().string().c_str());
        if (ASDCP_FAILURE (r)) {
-               boost::throw_exception (MXFFileError ("could not open MXF file for reading", path().string(), r));
+               boost::throw_exception (MXFFileError ("could not open MXF file for reading", other->file().string(), r));
        }
-       
+
        ASDCP::JP2K::PictureDescriptor desc_A;
        if (ASDCP_FAILURE (reader_A.FillPictureDescriptor (desc_A))) {
                boost::throw_exception (DCPReadError ("could not read video MXF information"));
@@ -151,40 +103,55 @@ MonoPictureAsset::equals (shared_ptr<const Asset> other, EqualityOptions opt, bo
        if (ASDCP_FAILURE (reader_B.FillPictureDescriptor (desc_B))) {
                boost::throw_exception (DCPReadError ("could not read video MXF information"));
        }
-       
+
        if (!descriptor_equals (desc_A, desc_B, note)) {
                return false;
        }
 
        shared_ptr<const MonoPictureAsset> other_picture = dynamic_pointer_cast<const MonoPictureAsset> (other);
-       assert (other_picture);
+       DCP_ASSERT (other_picture);
+
+       bool result = true;
 
+#pragma omp parallel for
        for (int i = 0; i < _intrinsic_duration; ++i) {
                if (i >= other_picture->intrinsic_duration()) {
-                       return false;
+                       result = false;
                }
-               
-               note (PROGRESS, "Comparing video frame " + lexical_cast<string> (i) + " of " + lexical_cast<string> (_intrinsic_duration));
-               shared_ptr<const MonoPictureFrame> frame_A = get_frame (i);
-               shared_ptr<const MonoPictureFrame> frame_B = other_picture->get_frame (i);
-               
-               if (!frame_buffer_equals (
-                           i, opt, note,
-                           frame_A->j2k_data(), frame_A->j2k_size(),
-                           frame_B->j2k_data(), frame_B->j2k_size()
-                           )) {
-                       return false;
+
+               if (result || opt.keep_going) {
+
+#pragma omp critical
+                       note (DCP_PROGRESS, String::compose ("Comparing video frame %1 of %2", i, _intrinsic_duration));
+
+                       shared_ptr<const MonoPictureFrame> frame_A = get_frame (i);
+                       shared_ptr<const MonoPictureFrame> frame_B = other_picture->get_frame (i);
+
+                       list<pair<NoteType, string> > notes;
+
+                       if (!frame_buffer_equals (
+                                   i, opt, bind (&storing_note_handler, notes, _1, _2),
+                                   frame_A->j2k_data(), frame_A->j2k_size(),
+                                   frame_B->j2k_data(), frame_B->j2k_size()
+                                   )) {
+                               result = false;
+                       }
+
+#pragma omp critical
+                       for (list<pair<NoteType, string> >::const_iterator i = notes.begin(); i != notes.end(); ++i) {
+                               note (i->first, i->second);
+                       }
                }
        }
 
-       return true;
+       return result;
 }
 
 shared_ptr<PictureAssetWriter>
-MonoPictureAsset::start_write (bool overwrite)
+MonoPictureAsset::start_write (boost::filesystem::path file, Standard standard, bool overwrite)
 {
        /* XXX: can't we use shared_ptr here? */
-       return shared_ptr<MonoPictureAssetWriter> (new MonoPictureAssetWriter (this, overwrite));
+       return shared_ptr<MonoPictureAssetWriter> (new MonoPictureAssetWriter (this, file, standard, overwrite));
 }
 
 string
@@ -192,9 +159,3 @@ MonoPictureAsset::cpl_node_name () const
 {
        return "MainPicture";
 }
-
-int
-MonoPictureAsset::edit_rate_factor () const
-{
-       return 1;
-}