X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Fwriter.cc;h=a444efad899edac9dbb5aadd5af2a12b71891be2;hb=f98c4cdec82fc2fbdcc4ca19748d09b0ea0556b4;hp=a434db0ec2f39997475f81c0beb9b79763921609;hpb=3886847e2dafdaec4ad780dac606802356beb31d;p=dcpomatic.git

diff --git a/src/lib/writer.cc b/src/lib/writer.cc
index a434db0ec..4f93373f7 100644
--- a/src/lib/writer.cc
+++ b/src/lib/writer.cc
@@ -17,61 +17,155 @@
 
 */
 
+#include <fstream>
+#include <cerrno>
 #include <libdcp/picture_asset.h>
 #include <libdcp/sound_asset.h>
+#include <libdcp/picture_frame.h>
 #include <libdcp/reel.h>
+#include <libdcp/dcp.h>
+#include <libdcp/cpl.h>
 #include "writer.h"
 #include "compose.hpp"
 #include "film.h"
-#include "format.h"
+#include "ratio.h"
 #include "log.h"
 #include "dcp_video_frame.h"
+#include "dcp_content_type.h"
+#include "player.h"
+#include "audio_mapping.h"
+#include "config.h"
+#include "job.h"
+
+#include "i18n.h"
 
 using std::make_pair;
 using std::pair;
+using std::string;
+using std::ifstream;
+using std::list;
+using std::cout;
 using boost::shared_ptr;
 
-unsigned int const Writer::_maximum_frames_in_memory = 8;
+int const Writer::_maximum_frames_in_memory = 8;
 
-Writer::Writer (shared_ptr<Film> f)
+Writer::Writer (shared_ptr<const Film> f, shared_ptr<Job> j)
 	: _film (f)
+	, _job (j)
+	, _first_nonexistant_frame (0)
 	, _thread (0)
 	, _finish (false)
+	, _queued_full_in_memory (0)
 	, _last_written_frame (-1)
+	, _last_written_eyes (EYES_RIGHT)
+	, _full_written (0)
+	, _fake_written (0)
+	, _repeat_written (0)
+	, _pushed_to_disk (0)
 {
-	_picture_asset.reset (
-		new libdcp::MonoPictureAsset (
-			_film->dir (_film->dcp_name()),
-			"video.mxf",
-			DCPFrameRate (_film->frames_per_second()).frames_per_second,
-			_film->format()->dcp_size()
-			)
-		);
+	/* Remove any old DCP */
+	boost::filesystem::remove_all (_film->dir (_film->dcp_name ()));
 	
-	_picture_asset_writer = _picture_asset->start_write ();
-
-	if (_film->audio_channels() > 0) {
-		_sound_asset.reset (
-			new libdcp::SoundAsset (
-				_film->dir (_film->dcp_name()),
-				"audio.mxf",
-				DCPFrameRate (_film->frames_per_second()).frames_per_second,
-				_film->audio_channels(),
-				dcp_audio_sample_rate (_film->audio_stream()->sample_rate())
+	check_existing_picture_mxf ();
+	
+	/* Create our picture asset in a subdirectory, named according to those
+	   film's parameters which affect the video output.  We will hard-link
+	   it into the DCP later.
+	*/
+
+	if (_film->three_d ()) {
+		_picture_asset.reset (
+			new libdcp::StereoPictureAsset (
+				_film->internal_video_mxf_dir (),
+				_film->internal_video_mxf_filename (),
+				_film->video_frame_rate (),
+				_film->container()->size (_film->full_frame ()),
+				_film->encrypted ()
+				)
+			);
+		
+	} else {
+		_picture_asset.reset (
+			new libdcp::MonoPictureAsset (
+				_film->internal_video_mxf_dir (),
+				_film->internal_video_mxf_filename (),
+				_film->video_frame_rate (),
+				_film->container()->size (_film->full_frame ()),
+				_film->encrypted ()
 				)
 			);
 
-		_sound_asset_writer = _sound_asset->start_write ();
 	}
+
+	_picture_asset_writer = _picture_asset->start_write (_first_nonexistant_frame > 0, _film->interop ());
 	
+	_sound_asset.reset (
+		new libdcp::SoundAsset (
+			_film->dir (_film->dcp_name()),
+			_film->audio_mxf_filename (),
+			_film->video_frame_rate (),
+			_film->audio_channels (),
+			_film->audio_frame_rate (),
+			_film->encrypted ()
+			)
+		);
+	
+	_sound_asset_writer = _sound_asset->start_write (_film->interop ());
+
 	_thread = new boost::thread (boost::bind (&Writer::thread, this));
+
+	_job->descend (0.9);
 }
 
 void
-Writer::write (shared_ptr<const EncodedData> encoded, int frame)
+Writer::write (shared_ptr<const EncodedData> encoded, int frame, Eyes eyes)
 {
 	boost::mutex::scoped_lock lock (_mutex);
-	_queue.push_back (make_pair (encoded, frame));
+
+	QueueItem qi;
+	qi.type = QueueItem::FULL;
+	qi.encoded = encoded;
+	qi.frame = frame;
+
+	if (_film->three_d() && eyes == EYES_BOTH) {
+		/* 2D material in a 3D DCP; fake the 3D */
+		qi.eyes = EYES_LEFT;
+		_queue.push_back (qi);
+		++_queued_full_in_memory;
+		qi.eyes = EYES_RIGHT;
+		_queue.push_back (qi);
+		++_queued_full_in_memory;
+	} else {
+		qi.eyes = eyes;
+		_queue.push_back (qi);
+		++_queued_full_in_memory;
+	}
+	
+	_condition.notify_all ();
+}
+
+void
+Writer::fake_write (int frame, Eyes eyes)
+{
+	boost::mutex::scoped_lock lock (_mutex);
+
+	ifstream ifi (_film->info_path (frame, eyes).c_str());
+	libdcp::FrameInfo info (ifi);
+	
+	QueueItem qi;
+	qi.type = QueueItem::FAKE;
+	qi.size = info.size;
+	qi.frame = frame;
+	if (_film->three_d() && eyes == EYES_BOTH) {
+		qi.eyes = EYES_LEFT;
+		_queue.push_back (qi);
+		qi.eyes = EYES_RIGHT;
+		_queue.push_back (qi);
+	} else {
+		qi.eyes = eyes;
+		_queue.push_back (qi);
+	}
+
 	_condition.notify_all ();
 }
 
@@ -82,99 +176,150 @@ Writer::write (shared_ptr<const AudioBuffers> audio)
 	_sound_asset_writer->write (audio->data(), audio->frames());
 }
 
-struct QueueSorter
+/** This must be called from Writer::thread() with an appropriate lock held,
+ *  and with _queue sorted.
+ */
+bool
+Writer::have_sequenced_image_at_queue_head () const
 {
-	bool operator() (pair<shared_ptr<const EncodedData>, int> const & a, pair<shared_ptr<const EncodedData>, int> const & b) {
-		return a.second < b.second;
+	if (_queue.empty ()) {
+		return false;
+	}
+
+	/* The queue should contain only EYES_LEFT/EYES_RIGHT pairs or EYES_BOTH */
+
+	if (_queue.front().eyes == EYES_BOTH) {
+		/* 2D */
+		return _queue.front().frame == (_last_written_frame + 1);
+	}
+
+	/* 3D */
+
+	if (_last_written_eyes == EYES_LEFT && _queue.front().frame == _last_written_frame && _queue.front().eyes == EYES_RIGHT) {
+		return true;
+	}
+
+	if (_last_written_eyes == EYES_RIGHT && _queue.front().frame == (_last_written_frame + 1) && _queue.front().eyes == EYES_LEFT) {
+		return true;
 	}
-};
+
+	return false;
+}
 
 void
 Writer::thread ()
+try
 {
 	while (1)
 	{
 		boost::mutex::scoped_lock lock (_mutex);
 
 		while (1) {
-			if (_finish ||
-			    _queue.size() > _maximum_frames_in_memory ||
-			    (!_queue.empty() && _queue.front().second == (_last_written_frame + 1))) {
-				    
-				    break;
-			    }
-
-			    TIMING ("writer sleeps with a queue of %1; %2 pending", _queue.size(), _pending.size());
-			    _condition.wait (lock);
-			    TIMING ("writer wakes with a queue of %1", _queue.size());
-
-			    _queue.sort (QueueSorter ());
+			
+			_queue.sort ();
+			
+			if (_finish || _queued_full_in_memory > _maximum_frames_in_memory || have_sequenced_image_at_queue_head ()) {
+				break;
+			}
+
+			TIMING (N_("writer sleeps with a queue of %1"), _queue.size());
+			_condition.wait (lock);
+			TIMING (N_("writer wakes with a queue of %1"), _queue.size());
 		}
 
-		if (_finish && _queue.empty() && _pending.empty()) {
+		if (_finish && _queue.empty()) {
 			return;
 		}
 
 		/* Write any frames that we can write; i.e. those that are in sequence */
-		while (!_queue.empty() && _queue.front().second == (_last_written_frame + 1)) {
-			pair<boost::shared_ptr<const EncodedData>, int> encoded = _queue.front ();
+		while (have_sequenced_image_at_queue_head ()) {
+			QueueItem qi = _queue.front ();
 			_queue.pop_front ();
+			if (qi.type == QueueItem::FULL && qi.encoded) {
+				--_queued_full_in_memory;
+			}
 
 			lock.unlock ();
-			_film->log()->log (String::compose ("Writer writes %1 to MXF", encoded.second));
-			if (encoded.first) {
-				_picture_asset_writer->write (encoded.first->data(), encoded.first->size());
-				encoded.first->write_hash (_film, encoded.second);
-				_last_written = encoded.first;
-			} else {
-				_picture_asset_writer->write (_last_written->data(), _last_written->size());
-				_last_written->write_hash (_film, encoded.second);
+			switch (qi.type) {
+			case QueueItem::FULL:
+			{
+				_film->log()->log (String::compose (N_("Writer FULL-writes %1 to MXF"), qi.frame));
+				if (!qi.encoded) {
+					qi.encoded.reset (new EncodedData (_film->j2c_path (qi.frame, qi.eyes, false)));
+				}
+
+				libdcp::FrameInfo fin = _picture_asset_writer->write (qi.encoded->data(), qi.encoded->size());
+				qi.encoded->write_info (_film, qi.frame, qi.eyes, fin);
+				_last_written[qi.eyes] = qi.encoded;
+				++_full_written;
+				break;
+			}
+			case QueueItem::FAKE:
+				_film->log()->log (String::compose (N_("Writer FAKE-writes %1 to MXF"), qi.frame));
+				_picture_asset_writer->fake_write (qi.size);
+				_last_written[qi.eyes].reset ();
+				++_fake_written;
+				break;
+			case QueueItem::REPEAT:
+			{
+				_film->log()->log (String::compose (N_("Writer REPEAT-writes %1 to MXF"), qi.frame));
+				libdcp::FrameInfo fin = _picture_asset_writer->write (
+					_last_written[qi.eyes]->data(),
+					_last_written[qi.eyes]->size()
+					);
+				
+				_last_written[qi.eyes]->write_info (_film, qi.frame, qi.eyes, fin);
+				++_repeat_written;
+				break;
+			}
 			}
 			lock.lock ();
 
-			++_last_written_frame;
+			_last_written_frame = qi.frame;
+			_last_written_eyes = qi.eyes;
+			
+			if (_film->length()) {
+				_job->set_progress (
+					float (_full_written + _fake_written + _repeat_written) / _film->time_to_video_frames (_film->length())
+					);
+			}
 		}
 
-		while (_queue.size() > _maximum_frames_in_memory) {
+		while (_queued_full_in_memory > _maximum_frames_in_memory) {
 			/* Too many frames in memory which can't yet be written to the stream.
-			   Put some to disk.
+			   Write some FULL frames to disk.
 			*/
 
-			pair<boost::shared_ptr<const EncodedData>, int> encoded = _queue.back ();
-			_queue.pop_back ();
-			if (!encoded.first) {
-				/* This is a `repeat-last' frame, so no need to write it to disk */
-				continue;
+			/* Find one */
+			list<QueueItem>::reverse_iterator i = _queue.rbegin ();
+			while (i != _queue.rend() && (i->type != QueueItem::FULL || !i->encoded)) {
+				++i;
 			}
 
-			lock.unlock ();
-			_film->log()->log (String::compose ("Writer full (awaiting %1); pushes %2 to disk", _last_written_frame + 1, encoded.second));
-			encoded.first->write (_film, encoded.second);
-			lock.lock ();
-
-			_pending.push_back (encoded.second);
-		}
-
-		while (_queue.size() < _maximum_frames_in_memory && !_pending.empty()) {
-			/* We have some space in memory.  Fetch some frames back off disk. */
-
-			_pending.sort ();
-			int const fetch = _pending.front ();
+			assert (i != _queue.rend());
+			QueueItem qi = *i;
 
+			++_pushed_to_disk;
+			
 			lock.unlock ();
-			_film->log()->log (String::compose ("Writer pulls %1 back from disk", fetch));
-			shared_ptr<const EncodedData> encoded;
-			if (boost::filesystem::exists (_film->frame_out_path (fetch, false))) {
-				/* It's an actual frame (not a repeat-last); load it in */
-				encoded.reset (new EncodedData (_film->frame_out_path (fetch, false)));
-			}
-			lock.lock ();
 
-			_queue.push_back (make_pair (encoded, fetch));
-			_pending.remove (fetch);
+			_film->log()->log (
+				String::compose (
+					"Writer full (awaiting %1 [last eye was %2]); pushes %3 to disk",
+					_last_written_frame + 1,
+					_last_written_eyes, qi.frame)
+				);
+			
+			qi.encoded->write (_film, qi.frame, qi.eyes);
+			lock.lock ();
+			qi.encoded.reset ();
+			--_queued_full_in_memory;
 		}
 	}
-
+}
+catch (...)
+{
+	store_current ();
 }
 
 void
@@ -190,33 +335,54 @@ Writer::finish ()
 	lock.unlock ();
 
 	_thread->join ();
+	if (thrown ()) {
+		rethrow ();
+	}
+	
 	delete _thread;
 	_thread = 0;
 
 	_picture_asset_writer->finalize ();
+	_sound_asset_writer->finalize ();
+	
+	int const frames = _last_written_frame + 1;
 
-	if (_sound_asset_writer) {
-		_sound_asset_writer->finalize ();
-	}
+	_picture_asset->set_duration (frames);
 
-	int const frames = _last_written_frame + 1;
-	int const duration = frames - _film->trim_start() - _film->trim_end();
-	
-	_film->set_dcp_intrinsic_duration (frames);
-	
-	_picture_asset->set_entry_point (_film->trim_start ());
-	_picture_asset->set_duration (duration);
+	/* Hard-link the video MXF into the DCP */
 
-	if (_sound_asset) {
-		_sound_asset->set_entry_point (_film->trim_start ());
-		_sound_asset->set_duration (duration);
+	boost::filesystem::path from;
+	from /= _film->internal_video_mxf_dir();
+	from /= _film->internal_video_mxf_filename();
+	
+	boost::filesystem::path to;
+	to /= _film->dir (_film->dcp_name());
+	to /= _film->video_mxf_filename ();
+
+	boost::system::error_code ec;
+	boost::filesystem::create_hard_link (from, to, ec);
+	if (ec) {
+		/* hard link failed; copy instead */
+		boost::filesystem::copy_file (from, to);
+		_film->log()->log ("Hard-link failed; fell back to copying");
 	}
+
+	/* And update the asset */
+
+	_picture_asset->set_directory (_film->dir (_film->dcp_name ()));
+	_picture_asset->set_file_name (_film->video_mxf_filename ());
+	_sound_asset->set_duration (frames);
 	
 	libdcp::DCP dcp (_film->dir (_film->dcp_name()));
-	DCPFrameRate dfr (_film->frames_per_second ());
 
 	shared_ptr<libdcp::CPL> cpl (
-		new libdcp::CPL (_film->dir (_film->dcp_name()), _film->dcp_name(), _film->dcp_content_type()->libdcp_kind (), frames, dfr.frames_per_second)
+		new libdcp::CPL (
+			_film->dir (_film->dcp_name()),
+			_film->dcp_name(),
+			_film->dcp_content_type()->libdcp_kind (),
+			frames,
+			_film->video_frame_rate ()
+			)
 		);
 	
 	dcp.add_cpl (cpl);
@@ -228,13 +394,135 @@ Writer::finish ()
 							 )
 			       ));
 
-	dcp.write_xml ();
+	/* Compute the digests for the assets now so that we can keep track of progress.
+	   We did _job->descend (0.9) in our constructor */
+	_job->ascend ();
+
+	_job->descend (0.1);
+	_picture_asset->compute_digest (boost::bind (&Job::set_progress, _job.get(), _1));
+	_job->ascend ();
+
+	_job->descend (0.1);
+	_sound_asset->compute_digest (boost::bind (&Job::set_progress, _job.get(), _1));
+	_job->ascend ();
+
+	libdcp::XMLMetadata meta = Config::instance()->dcp_metadata ();
+	meta.set_issue_date_now ();
+	dcp.write_xml (_film->interop (), meta);
+
+	_film->log()->log (String::compose (N_("Wrote %1 FULL, %2 FAKE, %3 REPEAT; %4 pushed to disk"), _full_written, _fake_written, _repeat_written, _pushed_to_disk));
 }
 
 /** Tell the writer that frame `f' should be a repeat of the frame before it */
 void
-Writer::repeat (int f)
+Writer::repeat (int f, Eyes e)
 {
 	boost::mutex::scoped_lock lock (_mutex);
-	_queue.push_back (make_pair (shared_ptr<const EncodedData> (), f));
+
+	QueueItem qi;
+	qi.type = QueueItem::REPEAT;
+	qi.frame = f;
+	if (_film->three_d() && e == EYES_BOTH) {
+		qi.eyes = EYES_LEFT;
+		_queue.push_back (qi);
+		qi.eyes = EYES_RIGHT;
+		_queue.push_back (qi);
+	} else {
+		qi.eyes = e;
+		_queue.push_back (qi);
+	}
+
+	_condition.notify_all ();
+}
+
+bool
+Writer::check_existing_picture_mxf_frame (FILE* mxf, int f, Eyes eyes)
+{
+	/* Read the frame info as written */
+	ifstream ifi (_film->info_path (f, eyes).c_str());
+	libdcp::FrameInfo info (ifi);
+	if (info.size == 0) {
+		_film->log()->log (String::compose ("Existing frame %1 has no info file", f));
+		return false;
+	}
+	
+	/* Read the data from the MXF and hash it */
+	fseek (mxf, info.offset, SEEK_SET);
+	EncodedData data (info.size);
+	size_t const read = fread (data.data(), 1, data.size(), mxf);
+	if (read != static_cast<size_t> (data.size ())) {
+		_film->log()->log (String::compose ("Existing frame %1 is incomplete", f));
+		return false;
+	}
+	
+	string const existing_hash = md5_digest (data.data(), data.size());
+	if (existing_hash != info.hash) {
+		_film->log()->log (String::compose ("Existing frame %1 failed hash check", f));
+		return false;
+	}
+
+	return true;
+}
+
+void
+Writer::check_existing_picture_mxf ()
+{
+	/* Try to open the existing MXF */
+	boost::filesystem::path p;
+	p /= _film->internal_video_mxf_dir ();
+	p /= _film->internal_video_mxf_filename ();
+	FILE* mxf = fopen (p.string().c_str(), "rb");
+	if (!mxf) {
+		_film->log()->log (String::compose ("Could not open existing MXF at %1 (errno=%2)", p.string(), errno));
+		return;
+	}
+
+	while (1) {
+
+		if (_film->three_d ()) {
+			if (!check_existing_picture_mxf_frame (mxf, _first_nonexistant_frame, EYES_LEFT)) {
+				break;
+			}
+			if (!check_existing_picture_mxf_frame (mxf, _first_nonexistant_frame, EYES_RIGHT)) {
+				break;
+			}
+		} else {
+			if (!check_existing_picture_mxf_frame (mxf, _first_nonexistant_frame, EYES_BOTH)) {
+				break;
+			}
+		}
+
+		_film->log()->log (String::compose ("Have existing frame %1", _first_nonexistant_frame));
+		++_first_nonexistant_frame;
+	}
+
+	fclose (mxf);
+}
+
+/** @param frame Frame index.
+ *  @return true if we can fake-write this frame.
+ */
+bool
+Writer::can_fake_write (int frame) const
+{
+	/* We have to do a proper write of the first frame so that we can set up the JPEG2000
+	   parameters in the MXF writer.
+	*/
+	return (frame != 0 && frame < _first_nonexistant_frame);
+}
+
+bool
+operator< (QueueItem const & a, QueueItem const & b)
+{
+	if (a.frame != b.frame) {
+		return a.frame < b.frame;
+	}
+
+	return static_cast<int> (a.eyes) < static_cast<int> (b.eyes);
+}
+
+bool
+operator== (QueueItem const & a, QueueItem const & b)
+{
+	return a.frame == b.frame && a.eyes == b.eyes;
 }