X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Fpicture_asset.cc;h=f3d523963abec33620447b14e51aa1b5b93dcae3;hb=2489080f9a5d2891da0fc313b2c0ac1450a630ad;hp=c989539b0ffdbab2d4bfb9c79ac0f944c5096ce0;hpb=4709b2fe88040f3678560997726f3a209eacc660;p=libdcp.git

diff --git a/src/picture_asset.cc b/src/picture_asset.cc
index c989539b..f3d52396 100644
--- a/src/picture_asset.cc
+++ b/src/picture_asset.cc
@@ -17,41 +17,174 @@
 
 */
 
+/** @file  src/picture_asset.cc
+ *  @brief An asset made up of JPEG2000 files
+ */
+
 #include <list>
 #include <stdexcept>
 #include <iostream>
 #include <sstream>
+#include <fstream>
 #include <boost/filesystem.hpp>
+#include <boost/lexical_cast.hpp>
+#include <openjpeg.h>
 #include "AS_DCP.h"
 #include "KM_fileio.h"
 #include "picture_asset.h"
 #include "util.h"
+#include "exceptions.h"
+#include "picture_frame.h"
 
-using namespace std;
-using namespace boost;
+using std::string;
+using std::ostream;
+using std::list;
+using std::vector;
+using std::max;
+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 (string directory, string mxf_name, boost::signals2::signal<void (float)>* progress, int fps, int intrinsic_duration, Size size)
+	: MXFAsset (directory, mxf_name, progress, fps, intrinsic_duration)
+	, _size (size)
+{
+
+}
+
+void
+PictureAsset::write_to_cpl (ostream& s) const
+{
+	s << "        <MainPicture>\n"
+	  << "          <Id>urn:uuid:" << _uuid << "</Id>\n"
+	  << "          <AnnotationText>" << _file_name << "</AnnotationText>\n"
+	  << "          <EditRate>" << _fps << " 1</EditRate>\n"
+	  << "          <IntrinsicDuration>" << _intrinsic_duration << "</IntrinsicDuration>\n"
+	  << "          <EntryPoint>" << _entry_point << "</EntryPoint>\n"
+	  << "          <Duration>" << _duration << "</Duration>\n"
+	  << "          <FrameRate>" << _fps << " 1</FrameRate>\n"
+	  << "          <ScreenAspectRatio>" << _size.width << " " << _size.height << "</ScreenAspectRatio>\n"
+	  << "        </MainPicture>\n";
+}
+
+bool
+PictureAsset::equals (shared_ptr<const Asset> other, EqualityOptions opt, list<string>& notes) const
+{
+	if (!MXFAsset::equals (other, opt, notes)) {
+		return false;
+	}
+		     
+	ASDCP::JP2K::MXFReader reader_A;
+	if (ASDCP_FAILURE (reader_A.OpenRead (path().string().c_str()))) {
+		throw MXFFileError ("could not open MXF file for reading", path().string());
+	}
+	
+	ASDCP::JP2K::MXFReader reader_B;
+	if (ASDCP_FAILURE (reader_B.OpenRead (other->path().string().c_str()))) {
+		throw MXFFileError ("could not open MXF file for reading", path().string());
+	}
+	
+	ASDCP::JP2K::PictureDescriptor desc_A;
+	if (ASDCP_FAILURE (reader_A.FillPictureDescriptor (desc_A))) {
+		throw DCPReadError ("could not read video MXF information");
+	}
+	ASDCP::JP2K::PictureDescriptor desc_B;
+	if (ASDCP_FAILURE (reader_B.FillPictureDescriptor (desc_B))) {
+		throw DCPReadError ("could not read video MXF information");
+	}
+	
+	if (
+		desc_A.EditRate != desc_B.EditRate ||
+		desc_A.ContainerDuration != desc_B.ContainerDuration ||
+		desc_A.SampleRate != desc_B.SampleRate ||
+		desc_A.StoredWidth != desc_B.StoredWidth ||
+		desc_A.StoredHeight != desc_B.StoredHeight ||
+		desc_A.AspectRatio != desc_B.AspectRatio ||
+		desc_A.Rsize != desc_B.Rsize ||
+		desc_A.Xsize != desc_B.Xsize ||
+		desc_A.Ysize != desc_B.Ysize ||
+		desc_A.XOsize != desc_B.XOsize ||
+		desc_A.YOsize != desc_B.YOsize ||
+		desc_A.XTsize != desc_B.XTsize ||
+		desc_A.YTsize != desc_B.YTsize ||
+		desc_A.XTOsize != desc_B.XTOsize ||
+		desc_A.YTOsize != desc_B.YTOsize ||
+		desc_A.Csize != desc_B.Csize
+//		desc_A.CodingStyleDefault != desc_B.CodingStyleDefault ||
+//		desc_A.QuantizationDefault != desc_B.QuantizationDefault
+		) {
+		
+		notes.push_back ("video MXF picture descriptors differ");
+		return false;
+	}
+
+//		for (unsigned int j = 0; j < ASDCP::JP2K::MaxComponents; ++j) {
+//			if (desc_A.ImageComponents[j] != desc_B.ImageComponents[j]) {
+//				notes.pack_start ("video MXF picture descriptors differ");
+//			}
+//		}
+
+	return true;
+}
+
+
+MonoPictureAsset::MonoPictureAsset (
+	boost::function<string (int)> get_path,
+	string directory,
+	string mxf_name,
+	boost::signals2::signal<void (float)>* progress,
+	int fps,
+	int intrinsic_duration,
+	Size size)
+	: PictureAsset (directory, mxf_name, progress, fps, intrinsic_duration, size)
+{
+	construct (get_path);
+}
+
+MonoPictureAsset::MonoPictureAsset (
+	vector<string> const & files,
+	string directory,
+	string mxf_name,
+	boost::signals2::signal<void (float)>* progress,
+	int fps,
+	int intrinsic_duration,
+	Size size)
+	: PictureAsset (directory, mxf_name, progress, fps, intrinsic_duration, size)
+{
+	construct (boost::bind (&MonoPictureAsset::path_from_list, this, _1, files));
+}
 
-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)
+MonoPictureAsset::MonoPictureAsset (string directory, string mxf_name, int fps, Size size)
+	: PictureAsset (directory, mxf_name, 0, fps, 0, size)
+{
+
+}
+
+MonoPictureAsset::MonoPictureAsset (string directory, string mxf_name, int fps, int intrinsic_duration)
+	: PictureAsset (directory, mxf_name, 0, fps, intrinsic_duration, Size (0, 0))
+{
+	ASDCP::JP2K::MXFReader reader;
+	if (ASDCP_FAILURE (reader.OpenRead (path().string().c_str()))) {
+		throw MXFFileError ("could not open MXF file for reading", path().string());
+	}
+	
+	ASDCP::JP2K::PictureDescriptor desc;
+	if (ASDCP_FAILURE (reader.FillPictureDescriptor (desc))) {
+		throw DCPReadError ("could not read video MXF information");
+	}
+
+	_size.width = desc.StoredWidth;
+	_size.height = desc.StoredHeight;
+}
+
+void
+MonoPictureAsset::construct (boost::function<string (int)> get_path)
 {
 	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());
+	if (ASDCP_FAILURE (j2k_parser.OpenReadFrame (get_path(0).c_str(), frame_buffer))) {
+		throw FileError ("could not open JPEG2000 file for reading", get_path (0));
 	}
 	
 	ASDCP::JP2K::PictureDescriptor picture_desc;
@@ -59,51 +192,251 @@ PictureAsset::PictureAsset (list<string> const & files, string p, sigc::signal1<
 	picture_desc.EditRate = ASDCP::Rational (_fps, 1);
 	
 	ASDCP::WriterInfo writer_info;
-	fill_writer_info (&writer_info);
+	fill_writer_info (&writer_info, _uuid);
 	
 	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");
+	if (ASDCP_FAILURE (mxf_writer.OpenWrite (path().string().c_str(), writer_info, picture_desc))) {
+		throw MXFFileError ("could not open MXF file for writing", path().string());
 	}
 
-	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());
+	for (int i = 0; i < _intrinsic_duration; ++i) {
+
+		string const path = get_path (i);
+
+		if (ASDCP_FAILURE (j2k_parser.OpenReadFrame (path.c_str(), frame_buffer))) {
+			throw FileError ("could not open JPEG2000 file for reading", path);
 		}
 
 		/* XXX: passing 0 to WriteFrame ok? */
 		if (ASDCP_FAILURE (mxf_writer.WriteFrame (frame_buffer, 0, 0))) {
-			throw runtime_error ("error in writing video MXF");
+			throw MiscError ("error in writing video MXF");
+		}
+
+		if (_progress) {
+			(*_progress) (0.5 * float (i) / _intrinsic_duration);
 		}
-		
-		++j;
-		(*_progress) (0.5 * float (j) / files.size ());
 	}
 	
 	if (ASDCP_FAILURE (mxf_writer.Finalize())) {
-		throw runtime_error ("error in finalising video MXF");
+		throw MiscError ("error in finalising video MXF");
+	}
+}
+
+string
+MonoPictureAsset::path_from_list (int f, vector<string> const & files) const
+{
+	return files[f];
+}
+
+shared_ptr<const MonoPictureFrame>
+MonoPictureAsset::get_frame (int n) const
+{
+	return shared_ptr<const MonoPictureFrame> (new MonoPictureFrame (path().string(), n + _entry_point));
+}
+
+
+bool
+MonoPictureAsset::equals (shared_ptr<const Asset> other, EqualityOptions opt, list<string>& notes) const
+{
+	if (!PictureAsset::equals (other, opt, notes)) {
+		return false;
 	}
 
-	_digest = make_digest (_mxf_path, _progress);
+	shared_ptr<const MonoPictureAsset> other_picture = dynamic_pointer_cast<const MonoPictureAsset> (other);
+	assert (other_picture);
+
+	for (int i = 0; i < _intrinsic_duration; ++i) {
+		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, notes,
+			    frame_A->j2k_frame()->RoData(), frame_A->j2k_frame()->Size(),
+			    frame_B->j2k_frame()->RoData(), frame_B->j2k_frame()->Size()
+			    )) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+bool
+StereoPictureAsset::equals (shared_ptr<const Asset> other, EqualityOptions opt, list<string>& notes) const
+{
+	if (!PictureAsset::equals (other, opt, notes)) {
+		return false;
+	}
+	
+	shared_ptr<const StereoPictureAsset> other_picture = dynamic_pointer_cast<const StereoPictureAsset> (other);
+	assert (other_picture);
+
+	for (int i = 0; i < _intrinsic_duration; ++i) {
+		shared_ptr<const StereoPictureFrame> frame_A = get_frame (i);
+		shared_ptr<const StereoPictureFrame> frame_B = other_picture->get_frame (i);
+		
+		if (!frame_buffer_equals (
+			    i, opt, notes,
+			    frame_A->j2k_frame()->Left.RoData(), frame_A->j2k_frame()->Left.Size(),
+			    frame_B->j2k_frame()->Left.RoData(), frame_B->j2k_frame()->Left.Size()
+			    )) {
+			return false;
+		}
+		
+		if (!frame_buffer_equals (
+			    i, opt, notes,
+			    frame_A->j2k_frame()->Right.RoData(), frame_A->j2k_frame()->Right.Size(),
+			    frame_B->j2k_frame()->Right.RoData(), frame_B->j2k_frame()->Right.Size()
+			    )) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+bool
+PictureAsset::frame_buffer_equals (
+	int frame, EqualityOptions opt, list<string>& notes, 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) {
+		/* Easy result; the J2K data is identical */
+		return true;
+	}
+		
+	/* Decompress the images to bitmaps */
+	opj_image_t* image_A = decompress_j2k (const_cast<uint8_t*> (data_A), size_A, 0);
+	opj_image_t* image_B = decompress_j2k (const_cast<uint8_t*> (data_B), size_B, 0);
+	
+	/* Compare them */
+	
+	if (image_A->numcomps != image_B->numcomps) {
+		notes.push_back ("image component counts for frame " + lexical_cast<string>(frame) + " differ");
+		return false;
+	}
+	
+	vector<int> abs_diffs (image_A->comps[0].w * image_A->comps[0].h * image_A->numcomps);
+	int d = 0;
+	int max_diff = 0;
+	
+	for (int c = 0; c < image_A->numcomps; ++c) {
+		
+		if (image_A->comps[c].w != image_B->comps[c].w || image_A->comps[c].h != image_B->comps[c].h) {
+			notes.push_back ("image sizes for frame " + lexical_cast<string>(frame) + " differ");
+			return false;
+		}
+		
+		int const pixels = image_A->comps[c].w * image_A->comps[c].h;
+		for (int j = 0; j < pixels; ++j) {
+			int const t = abs (image_A->comps[c].data[j] - image_B->comps[c].data[j]);
+			abs_diffs[d++] = t;
+			max_diff = max (max_diff, t);
+		}
+	}
+		
+	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);
+	}
+	
+	double const std_dev = sqrt (double (total_squared_deviation) / abs_diffs.size());
+	
+	if (mean > opt.max_mean_pixel_error || std_dev > opt.max_std_dev_pixel_error) {
+		notes.push_back ("mean or standard deviation out of range for " + lexical_cast<string>(frame));
+		return false;
+	}
+	
+	opj_image_destroy (image_A);
+	opj_image_destroy (image_B);
+
+	return true;
+}
+
+
+StereoPictureAsset::StereoPictureAsset (string directory, string mxf_name, int fps, int intrinsic_duration)
+	: PictureAsset (directory, mxf_name, 0, fps, intrinsic_duration, Size (0, 0))
+{
+	ASDCP::JP2K::MXFSReader reader;
+	if (ASDCP_FAILURE (reader.OpenRead (path().string().c_str()))) {
+		throw MXFFileError ("could not open MXF file for reading", path().string());
+	}
+	
+	ASDCP::JP2K::PictureDescriptor desc;
+	if (ASDCP_FAILURE (reader.FillPictureDescriptor (desc))) {
+		throw DCPReadError ("could not read video MXF information");
+	}
+
+	_size.width = desc.StoredWidth;
+	_size.height = desc.StoredHeight;
+}
+
+shared_ptr<const StereoPictureFrame>
+StereoPictureAsset::get_frame (int n) const
+{
+	return shared_ptr<const StereoPictureFrame> (new StereoPictureFrame (path().string(), n + _entry_point));
+}
+
+shared_ptr<MonoPictureAssetWriter>
+MonoPictureAsset::start_write ()
+{
+	/* XXX: can't we use a shared_ptr here? */
+	return shared_ptr<MonoPictureAssetWriter> (new MonoPictureAssetWriter (this));
+}
+
+MonoPictureAssetWriter::MonoPictureAssetWriter (MonoPictureAsset* a)
+	: _frame_buffer (4 * Kumu::Megabyte)
+	, _asset (a)
+	, _frames_written (0)
+	, _finalized (false)
+{
+
 }
 
-/** Write details of this asset to a CPL stream.
- *  @param s Stream.
- */
 void
-PictureAsset::write_to_cpl (ostream& s) const
+MonoPictureAssetWriter::write (uint8_t* data, int size)
 {
-	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";
+	if (ASDCP_FAILURE (_j2k_parser.OpenReadFrame (data, size, _frame_buffer))) {
+		throw MiscError ("could not parse J2K frame");
+	}
+
+	if (_frames_written == 0) {
+		_j2k_parser.FillPictureDescriptor (_picture_descriptor);
+		_picture_descriptor.EditRate = ASDCP::Rational (_asset->frames_per_second(), 1);
+	
+		MXFAsset::fill_writer_info (&_writer_info, _asset->uuid());
+		
+		if (ASDCP_FAILURE (_mxf_writer.OpenWrite (_asset->path().c_str(), _writer_info, _picture_descriptor))) {
+			throw MXFFileError ("could not open MXF file for writing", _asset->path().string());
+		}
+	}
+
+	if (ASDCP_FAILURE (_mxf_writer.WriteFrame (_frame_buffer, 0, 0))) {
+		throw MiscError ("error in writing video MXF");
+	}
+
+	_frames_written++;
+}
+
+void
+MonoPictureAssetWriter::finalize ()
+{
+	if (ASDCP_FAILURE (_mxf_writer.Finalize())) {
+		throw MiscError ("error in finalizing video MXF");
+	}
+
+	_finalized = true;
+	_asset->set_intrinsic_duration (_frames_written);
+}
+
+MonoPictureAssetWriter::~MonoPictureAssetWriter ()
+{
+	assert (_finalized);
 }