Merge branch 'master' of ssh://carlh.dyndns.org/home/carl/git/libdcp
[libdcp.git] / src / picture_asset.cc
index c989539b0ffdbab2d4bfb9c79ac0f944c5096ce0..3a0383feab54727ae7c0efc7125807ffd42fc9ab 100644 (file)
 
 */
 
+/** @file  src/picture_asset.cc
+ *  @brief An asset made up of JPEG2000 files
+ */
+
 #include <list>
 #include <stdexcept>
 #include <iostream>
 #include <sstream>
 #include <boost/filesystem.hpp>
+#include <boost/lexical_cast.hpp>
+#include <openjpeg.h>
+#include <libxml++/nodes/element.h>
 #include "AS_DCP.h"
 #include "KM_fileio.h"
 #include "picture_asset.h"
 #include "util.h"
+#include "exceptions.h"
+#include "xyz_frame.h"
+#include "picture_asset_writer.h"
 
-using namespace std;
-using namespace boost;
+using std::string;
+using std::ostream;
+using std::list;
+using std::vector;
+using std::max;
+using std::stringstream;
+using std::pair;
+using std::make_pair;
+using std::istream;
+using std::cout;
+using boost::shared_ptr;
+using boost::dynamic_pointer_cast;
+using boost::lexical_cast;
 using namespace libdcp;
 
-/** Construct a PictureAsset, generating the MXF from the JPEG2000 files.
- *  This may take some time; progress is indicated by emission of the Progress signal.
- *  @param files Pathnames of JPEG2000 files, in frame order.
- *  @param p Pathname of MXF file to create.
- *  @param fps Frames per second.
- *  @param len Length in frames.
- *  @param w Width of images in pixels.
- *  @param h Height of images in pixels.
- */
+PictureAsset::PictureAsset (boost::filesystem::path directory, boost::filesystem::path mxf_name)
+       : MXFAsset (directory, mxf_name)
+{
+
+}
 
-PictureAsset::PictureAsset (list<string> const & files, string p, sigc::signal1<void, float>* progress, int fps, int len, int w, int h)
-       : Asset (p, progress, fps, len)
-       , _width (w)
-       , _height (h)
+void
+PictureAsset::write_to_cpl (xmlpp::Element* node, bool interop) const
 {
-       ASDCP::JP2K::CodestreamParser j2k_parser;
-       ASDCP::JP2K::FrameBuffer frame_buffer (4 * Kumu::Megabyte);
-       if (ASDCP_FAILURE (j2k_parser.OpenReadFrame (files.front().c_str(), frame_buffer))) {
-               stringstream s;
-               s << "could not open " << files.front() << " for reading";
-               throw runtime_error (s.str());
+       MXFAsset::write_to_cpl (node, interop);
+       
+       xmlpp::Node::NodeList c = node->get_children ();
+       xmlpp::Node::NodeList::iterator i = c.begin();
+       while (i != c.end() && (*i)->get_name() != cpl_node_name ()) {
+               ++i;
+       }
+
+       assert (i != c.end ());
+
+       (*i)->add_child ("FrameRate")->add_child_text (lexical_cast<string> (_edit_rate * edit_rate_factor ()) + " 1");
+       if (interop) {
+               (*i)->add_child ("ScreenAspectRatio")->add_child_text (lexical_cast<string> (float (_size.width) / _size.height));
+       } else {
+               (*i)->add_child ("ScreenAspectRatio")->add_child_text (lexical_cast<string> (_size.width) + " " + lexical_cast<string> (_size.height));
+       }
+}
+
+bool
+PictureAsset::descriptor_equals (
+       ASDCP::JP2K::PictureDescriptor const & a, ASDCP::JP2K::PictureDescriptor const & b, boost::function<void (NoteType, string)> note
+       ) const
+{
+       if (
+               a.EditRate != b.EditRate ||
+               a.SampleRate != b.SampleRate ||
+               a.StoredWidth != b.StoredWidth ||
+               a.StoredHeight != b.StoredHeight ||
+               a.AspectRatio != b.AspectRatio ||
+               a.Rsize != b.Rsize ||
+               a.Xsize != b.Xsize ||
+               a.Ysize != b.Ysize ||
+               a.XOsize != b.XOsize ||
+               a.YOsize != b.YOsize ||
+               a.XTsize != b.XTsize ||
+               a.YTsize != b.YTsize ||
+               a.XTOsize != b.XTOsize ||
+               a.YTOsize != b.YTOsize ||
+               a.Csize != b.Csize
+//             a.CodingStyleDefault != b.CodingStyleDefault ||
+//             a.QuantizationDefault != b.QuantizationDefault
+               ) {
+               
+               note (ERROR, "video MXF picture descriptors differ");
+               return false;
+       }
+
+       if (a.ContainerDuration != b.ContainerDuration) {
+               note (ERROR, "video container durations differ");
        }
        
-       ASDCP::JP2K::PictureDescriptor picture_desc;
-       j2k_parser.FillPictureDescriptor (picture_desc);
-       picture_desc.EditRate = ASDCP::Rational (_fps, 1);
+//             for (unsigned int j = 0; j < ASDCP::JP2K::MaxComponents; ++j) {
+//                     if (a.ImageComponents[j] != b.ImageComponents[j]) {
+//                             notes.pack_start ("video MXF picture descriptors differ");
+//                     }
+//             }
+
+       return true;
+}
+
+bool
+PictureAsset::frame_buffer_equals (
+       int frame, EqualityOptions opt, boost::function<void (NoteType, string)> note,
+       uint8_t const * data_A, unsigned int size_A, uint8_t const * data_B, unsigned int size_B
+       ) const
+{
+       if (size_A == size_B && memcmp (data_A, data_B, size_A) == 0) {
+               note (NOTE, "J2K identical");
+               /* Easy result; the J2K data is identical */
+               return true;
+       }
+               
+       /* Decompress the images to bitmaps */
+       shared_ptr<XYZFrame> image_A = decompress_j2k (const_cast<uint8_t*> (data_A), size_A, 0);
+       shared_ptr<XYZFrame> image_B = decompress_j2k (const_cast<uint8_t*> (data_B), size_B, 0);
        
-       ASDCP::WriterInfo writer_info;
-       fill_writer_info (&writer_info);
+       /* Compare them */
        
-       ASDCP::JP2K::MXFWriter mxf_writer;
-       if (ASDCP_FAILURE (mxf_writer.OpenWrite (_mxf_path.c_str(), writer_info, picture_desc))) {
-               throw runtime_error ("could not open MXF for writing");
-       }
-
-       int j = 0;
-       for (list<string>::const_iterator i = files.begin(); i != files.end(); ++i) {
-               if (ASDCP_FAILURE (j2k_parser.OpenReadFrame (i->c_str(), frame_buffer))) {
-                       stringstream s;
-                       s << "could not open " << *i << " for reading";
-                       throw runtime_error (s.str());
+       vector<int> abs_diffs (image_A->size().width * image_A->size().height * 3);
+       int d = 0;
+       int max_diff = 0;
+       
+       for (int c = 0; c < 3; ++c) {
+               
+               if (image_A->size() != image_B->size()) {
+                       note (ERROR, "image sizes for frame " + lexical_cast<string>(frame) + " differ");
+                       return false;
                }
-
-               /* XXX: passing 0 to WriteFrame ok? */
-               if (ASDCP_FAILURE (mxf_writer.WriteFrame (frame_buffer, 0, 0))) {
-                       throw runtime_error ("error in writing video MXF");
+               
+               int const pixels = image_A->size().width * image_A->size().height;
+               for (int j = 0; j < pixels; ++j) {
+                       int const t = abs (image_A->data(c)[j] - image_B->data(c)[j]);
+                       abs_diffs[d++] = t;
+                       max_diff = max (max_diff, t);
                }
+       }
                
-               ++j;
-               (*_progress) (0.5 * float (j) / files.size ());
+       uint64_t total = 0;
+       for (vector<int>::iterator j = abs_diffs.begin(); j != abs_diffs.end(); ++j) {
+               total += *j;
+       }
+       
+       double const mean = double (total) / abs_diffs.size ();
+       
+       uint64_t total_squared_deviation = 0;
+       for (vector<int>::iterator j = abs_diffs.begin(); j != abs_diffs.end(); ++j) {
+               total_squared_deviation += pow (*j - mean, 2);
        }
        
-       if (ASDCP_FAILURE (mxf_writer.Finalize())) {
-               throw runtime_error ("error in finalising video MXF");
+       double const std_dev = sqrt (double (total_squared_deviation) / abs_diffs.size());
+       
+       note (NOTE, "mean difference " + lexical_cast<string> (mean) + ", deviation " + lexical_cast<string> (std_dev));
+       
+       if (mean > opt.max_mean_pixel_error) {
+               note (
+                       ERROR,
+                       "mean " + lexical_cast<string>(mean) +
+                       " out of range " + lexical_cast<string>(opt.max_mean_pixel_error) +
+                       " in frame " + lexical_cast<string>(frame)
+                       );
+               
+               return false;
+       }
+
+       if (std_dev > opt.max_std_dev_pixel_error) {
+               note (
+                       ERROR,
+                       "standard deviation " + lexical_cast<string>(std_dev) +
+                       " out of range " + lexical_cast<string>(opt.max_std_dev_pixel_error) +
+                       " in frame " + lexical_cast<string>(frame)
+                       );
+               
+               return false;
        }
 
-       _digest = make_digest (_mxf_path, _progress);
+       return true;
 }
 
-/** Write details of this asset to a CPL stream.
- *  @param s Stream.
- */
-void
-PictureAsset::write_to_cpl (ostream& s) const
+string
+PictureAsset::key_type () const
 {
-       s << "        <MainPicture>\n"
-         << "          <Id>urn:uuid:" << _uuid << "</Id>\n"
-         << "          <AnnotationText>" << filesystem::path(_mxf_path).filename() << "</AnnotationText>\n"
-         << "          <EditRate>" << _fps << " 1</EditRate>\n"
-         << "          <IntrinsicDuration>" << _length << "</IntrinsicDuration>\n"
-         << "          <EntryPoint>0</EntryPoint>\n"
-         << "          <Duration>" << _length << "</Duration>\n"
-         << "          <FrameRate>" << _fps << " 1</FrameRate>\n"
-         << "          <ScreenAspectRatio>" << _width << " " << _height << "</ScreenAspectRatio>\n"
-         << "        </MainPicture>\n";
+       return "MDIK";
 }
+
+
+