X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Fwriter.cc;h=e8a4ac10b4f2192b43140b662aee72ad95d21e7e;hb=ff96cc9c9e33fbe9dea02ea2d397144f9c9ac8c9;hp=dd2e98eeed5e0b33e484773fea63890a95e4aaa9;hpb=bbb2a4b7ccec953900d13e7bcdad229028bc7795;p=dcpomatic.git

diff --git a/src/lib/writer.cc b/src/lib/writer.cc
index dd2e98eee..e8a4ac10b 100644
--- a/src/lib/writer.cc
+++ b/src/lib/writer.cc
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2012-2014 Carl Hetherington <cth@carlh.net>
+    Copyright (C) 2012-2015 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
@@ -17,34 +17,47 @@
 
 */
 
-#include <fstream>
-#include <cerrno>
-#include <libdcp/mono_picture_asset.h>
-#include <libdcp/stereo_picture_asset.h>
-#include <libdcp/sound_asset.h>
-#include <libdcp/reel.h>
-#include <libdcp/dcp.h>
-#include <libdcp/cpl.h>
 #include "writer.h"
 #include "compose.hpp"
 #include "film.h"
 #include "ratio.h"
 #include "log.h"
-#include "dcp_video_frame.h"
+#include "dcp_video.h"
 #include "dcp_content_type.h"
-#include "player.h"
 #include "audio_mapping.h"
 #include "config.h"
 #include "job.h"
 #include "cross.h"
+#include "audio_buffers.h"
 #include "md5_digester.h"
+#include "encoded_data.h"
 #include "version.h"
+#include "font.h"
+#include <dcp/mono_picture_mxf.h>
+#include <dcp/stereo_picture_mxf.h>
+#include <dcp/sound_mxf.h>
+#include <dcp/sound_mxf_writer.h>
+#include <dcp/reel.h>
+#include <dcp/reel_mono_picture_asset.h>
+#include <dcp/reel_stereo_picture_asset.h>
+#include <dcp/reel_sound_asset.h>
+#include <dcp/reel_subtitle_asset.h>
+#include <dcp/dcp.h>
+#include <dcp/cpl.h>
+#include <dcp/signer.h>
+#include <dcp/interop_subtitle_content.h>
+#include <fstream>
+#include <cerrno>
 
 #include "i18n.h"
 
 #define LOG_GENERAL(...) _film->log()->log (String::compose (__VA_ARGS__), Log::TYPE_GENERAL);
 #define LOG_TIMING(...) _film->log()->microsecond_log (String::compose (__VA_ARGS__), Log::TYPE_TIMING);
 #define LOG_WARNING_NC(...) _film->log()->log (__VA_ARGS__, Log::TYPE_WARNING);
+#define LOG_WARNING(...) _film->log()->log (String::compose (__VA_ARGS__), Log::TYPE_WARNING);
+#define LOG_ERROR(...) _film->log()->log (String::compose (__VA_ARGS__), Log::TYPE_ERROR);
+#define LOG_DEBUG(...) _film->log()->log (String::compose (__VA_ARGS__), Log::TYPE_DEBUG);
+#define LOG_DEBUG_NC(...) _film->log()->log (__VA_ARGS__, Log::TYPE_DEBUG);
 
 /* OS X strikes again */
 #undef set_key
@@ -56,6 +69,7 @@ using std::list;
 using std::cout;
 using boost::shared_ptr;
 using boost::weak_ptr;
+using boost::dynamic_pointer_cast;
 
 int const Writer::_maximum_frames_in_memory = Config::instance()->num_local_encoding_threads() + 4;
 
@@ -70,14 +84,13 @@ Writer::Writer (shared_ptr<const Film> f, weak_ptr<Job> j)
 	, _last_written_eyes (EYES_RIGHT)
 	, _full_written (0)
 	, _fake_written (0)
-	, _repeat_written (0)
 	, _pushed_to_disk (0)
 {
 	/* Remove any old DCP */
 	boost::filesystem::remove_all (_film->dir (_film->dcp_name ()));
 
 	shared_ptr<Job> job = _job.lock ();
-	assert (job);
+	DCPOMATIC_ASSERT (job);
 
 	job->sub (_("Checking existing image data"));
 	check_existing_picture_mxf ();
@@ -88,36 +101,39 @@ Writer::Writer (shared_ptr<const Film> f, weak_ptr<Job> j)
 	*/
 
 	if (_film->three_d ()) {
-		_picture_asset.reset (new libdcp::StereoPictureAsset (_film->internal_video_mxf_dir (), _film->internal_video_mxf_filename ()));
+		_picture_mxf.reset (new dcp::StereoPictureMXF (dcp::Fraction (_film->video_frame_rate (), 1)));
 	} else {
-		_picture_asset.reset (new libdcp::MonoPictureAsset (_film->internal_video_mxf_dir (), _film->internal_video_mxf_filename ()));
+		_picture_mxf.reset (new dcp::MonoPictureMXF (dcp::Fraction (_film->video_frame_rate (), 1)));
 	}
 
-	_picture_asset->set_edit_rate (_film->video_frame_rate ());
-	_picture_asset->set_size (_film->frame_size ());
-	_picture_asset->set_interop (_film->interop ());
+	_picture_mxf->set_size (_film->frame_size ());
 
 	if (_film->encrypted ()) {
-		_picture_asset->set_key (_film->key ());
+		_picture_mxf->set_key (_film->key ());
 	}
 	
-	_picture_asset_writer = _picture_asset->start_write (_first_nonexistant_frame > 0);
+	_picture_mxf_writer = _picture_mxf->start_write (
+		_film->internal_video_mxf_dir() / _film->internal_video_mxf_filename(),
+		_film->interop() ? dcp::INTEROP : dcp::SMPTE,
+		_first_nonexistant_frame > 0
+		);
 
 	if (_film->audio_channels ()) {
-		_sound_asset.reset (new libdcp::SoundAsset (_film->directory (), _film->audio_mxf_filename ()));
-		_sound_asset->set_edit_rate (_film->video_frame_rate ());
-		_sound_asset->set_channels (_film->audio_channels ());
-		_sound_asset->set_sampling_rate (_film->audio_frame_rate ());
-		_sound_asset->set_interop (_film->interop ());
+		_sound_mxf.reset (new dcp::SoundMXF (dcp::Fraction (_film->video_frame_rate(), 1), _film->audio_frame_rate (), _film->audio_channels ()));
 
 		if (_film->encrypted ()) {
-			_sound_asset->set_key (_film->key ());
+			_sound_mxf->set_key (_film->key ());
 		}
-		
-		/* Write the sound asset into the film directory so that we leave the creation
+	
+		/* Write the sound MXF into the film directory so that we leave the creation
 		   of the DCP directory until the last minute.
 		*/
-		_sound_asset_writer = _sound_asset->start_write ();
+		_sound_mxf_writer = _sound_mxf->start_write (_film->directory() / _film->audio_mxf_filename(), _film->interop() ? dcp::INTEROP : dcp::SMPTE);
+	}
+
+	/* Check that the signer is OK if we need one */
+	if (_film->is_signed() && !Config::instance()->signer()->valid ()) {
+		throw InvalidSignerError ();
 	}
 
 	_thread = new boost::thread (boost::bind (&Writer::thread, this));
@@ -173,9 +189,12 @@ Writer::fake_write (int frame, Eyes eyes)
 		_full_condition.wait (lock);
 	}
 	
-	FILE* ifi = fopen_boost (_film->info_path (frame, eyes), "r");
-	libdcp::FrameInfo info (ifi);
-	fclose (ifi);
+	FILE* file = fopen_boost (_film->info_file (), "rb");
+	if (!file) {
+		throw ReadFileError (_film->info_file ());
+	}
+	dcp::FrameInfo info = read_frame_info (file, frame, eyes);
+	fclose (file);
 	
 	QueueItem qi;
 	qi.type = QueueItem::FAKE;
@@ -199,8 +218,8 @@ Writer::fake_write (int frame, Eyes eyes)
 void
 Writer::write (shared_ptr<const AudioBuffers> audio)
 {
-	if (_sound_asset) {
-		_sound_asset_writer->write (audio->data(), audio->frames());
+	if (_sound_mxf_writer) {
+		_sound_mxf_writer->write (audio->data(), audio->frames());
 	}
 }
 
@@ -242,6 +261,9 @@ try
 	{
 		boost::mutex::scoped_lock lock (_mutex);
 
+		/* This is for debugging only */
+		bool done_something = false;
+
 		while (true) {
 			
 			if (_finish || _queued_full_in_memory > _maximum_frames_in_memory || have_sequenced_image_at_queue_head ()) {
@@ -259,8 +281,30 @@ try
 			return;
 		}
 
+		/* We stop here if we have been asked to finish, and if either the queue
+		   is empty or we do not have a sequenced image at its head (if this is the
+		   case we will never terminate as no new frames will be sent once
+		   _finish is true).
+		*/
+		if (_finish && (!have_sequenced_image_at_queue_head() || _queue.empty())) {
+			done_something = true;
+			/* (Hopefully temporarily) log anything that was not written */
+			if (!_queue.empty() && !have_sequenced_image_at_queue_head()) {
+				LOG_WARNING (N_("Finishing writer with a left-over queue of %1:"), _queue.size());
+				for (list<QueueItem>::const_iterator i = _queue.begin(); i != _queue.end(); ++i) {
+					if (i->type == QueueItem::FULL) {
+						LOG_WARNING (N_("- type FULL, frame %1, eyes %2"), i->frame, i->eyes);
+					} else {
+						LOG_WARNING (N_("- type FAKE, size %1, frame %2, eyes %3"), i->size, i->frame, i->eyes);
+					}						
+				}
+				LOG_WARNING (N_("Last written frame %1, last written eyes %2"), _last_written_frame, _last_written_eyes);
+			}
+			return;
+		}
 		/* Write any frames that we can write; i.e. those that are in sequence. */
 		while (have_sequenced_image_at_queue_head ()) {
+			done_something = true;
 			QueueItem qi = _queue.front ();
 			_queue.pop_front ();
 			if (qi.type == QueueItem::FULL && qi.encoded) {
@@ -276,7 +320,7 @@ try
 					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());
+				dcp::FrameInfo fin = _picture_mxf_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;
@@ -284,43 +328,32 @@ try
 			}
 			case QueueItem::FAKE:
 				LOG_GENERAL (N_("Writer FAKE-writes %1 to MXF"), qi.frame);
-				_picture_asset_writer->fake_write (qi.size);
+				_picture_mxf_writer->fake_write (qi.size);
 				_last_written[qi.eyes].reset ();
 				++_fake_written;
 				break;
-			case QueueItem::REPEAT:
-			{
-				LOG_GENERAL (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 = qi.frame;
 			_last_written_eyes = qi.eyes;
 			
-			if (_film->length()) {
-				shared_ptr<Job> job = _job.lock ();
-				assert (job);
-				int total = _film->time_to_video_frames (_film->length ());
-				if (_film->three_d ()) {
-					/* _full_written and so on are incremented for each eye, so we need to double the total
-					   frames to get the correct progress.
-					*/
-					total *= 2;
-				}
-				job->set_progress (float (_full_written + _fake_written + _repeat_written) / total);
+			shared_ptr<Job> job = _job.lock ();
+			DCPOMATIC_ASSERT (job);
+			int64_t total = _film->length().frames (_film->video_frame_rate ());
+			if (_film->three_d ()) {
+				/* _full_written and so on are incremented for each eye, so we need to double the total
+				   frames to get the correct progress.
+				*/
+				total *= 2;
+			}
+			if (total) {
+				job->set_progress (float (_full_written + _fake_written) / total);
 			}
 		}
 
 		while (_queued_full_in_memory > _maximum_frames_in_memory) {
+			done_something = true;
 			/* Too many frames in memory which can't yet be written to the stream.
 			   Write some FULL frames to disk.
 			*/
@@ -332,7 +365,7 @@ try
 				++i;
 			}
 
-			assert (i != _queue.rend());
+			DCPOMATIC_ASSERT (i != _queue.rend());
 			QueueItem qi = *i;
 
 			++_pushed_to_disk;
@@ -351,6 +384,14 @@ try
 			--_queued_full_in_memory;
 		}
 
+		if (!done_something) {
+			LOG_DEBUG_NC ("Writer loop ran without doing anything");
+			LOG_DEBUG ("_queued_full_in_memory=%1", _queued_full_in_memory);
+			LOG_DEBUG ("_queue_size=%1", _queue.size ());
+			LOG_DEBUG ("_finish=%1", _finish);
+			LOG_DEBUG ("_last_written_frame=%1", _last_written_frame);
+		}
+
 		/* The queue has probably just gone down a bit; notify anything wait()ing on _full_condition */
 		_full_condition.notify_all ();
 	}
@@ -391,15 +432,11 @@ Writer::finish ()
 	
 	terminate_thread (true);
 
-	_picture_asset_writer->finalize ();
-	if (_sound_asset_writer) {
-		_sound_asset_writer->finalize ();
+	_picture_mxf_writer->finalize ();
+	if (_sound_mxf_writer) {
+		_sound_mxf_writer->finalize ();
 	}
 	
-	int const frames = _last_written_frame + 1;
-
-	_picture_asset->set_duration (frames);
-
 	/* Hard-link the video MXF into the DCP */
 	boost::filesystem::path video_from;
 	video_from /= _film->internal_video_mxf_dir();
@@ -412,19 +449,19 @@ Writer::finish ()
 	boost::system::error_code ec;
 	boost::filesystem::create_hard_link (video_from, video_to, ec);
 	if (ec) {
-		/* hard link failed; copy instead */
-		boost::filesystem::copy_file (video_from, video_to);
-		LOG_WARNING_NC ("Hard-link failed; fell back to copying");
+		LOG_WARNING_NC ("Hard-link failed; copying instead");
+		boost::filesystem::copy_file (video_from, video_to, ec);
+		if (ec) {
+			LOG_ERROR ("Failed to copy video file from %1 to %2 (%3)", video_from.string(), video_to.string(), ec.message ());
+			throw FileError (ec.message(), video_from);
+		}
 	}
 
-	/* And update the asset */
-
-	_picture_asset->set_directory (_film->dir (_film->dcp_name ()));
-	_picture_asset->set_file_name (_film->video_mxf_filename ());
+	_picture_mxf->set_file (video_to);
 
 	/* Move the audio MXF into the DCP */
 
-	if (_sound_asset) {
+	if (_sound_mxf) {
 		boost::filesystem::path audio_to;
 		audio_to /= _film->dir (_film->dcp_name ());
 		audio_to /= _film->audio_mxf_filename ();
@@ -435,94 +472,100 @@ Writer::finish ()
 				String::compose (_("could not move audio MXF into the DCP (%1)"), ec.value ()), _film->file (_film->audio_mxf_filename ())
 				);
 		}
-		
-		_sound_asset->set_directory (_film->dir (_film->dcp_name ()));
-		_sound_asset->set_duration (frames);
+
+		_sound_mxf->set_file (audio_to);
 	}
-	
-	libdcp::DCP dcp (_film->dir (_film->dcp_name()));
 
-	shared_ptr<libdcp::CPL> cpl (
-		new libdcp::CPL (
-			_film->dir (_film->dcp_name()),
+	dcp::DCP dcp (_film->dir (_film->dcp_name()));
+
+	shared_ptr<dcp::CPL> cpl (
+		new dcp::CPL (
 			_film->dcp_name(),
-			_film->dcp_content_type()->libdcp_kind (),
-			frames,
-			_film->video_frame_rate ()
+			_film->dcp_content_type()->libdcp_kind ()
 			)
 		);
 	
-	dcp.add_cpl (cpl);
+	dcp.add (cpl);
 
-	cpl->add_reel (shared_ptr<libdcp::Reel> (new libdcp::Reel (
-							 _picture_asset,
-							 _sound_asset,
-							 shared_ptr<libdcp::SubtitleAsset> ()
-							 )
-			       ));
+	shared_ptr<dcp::Reel> reel (new dcp::Reel ());
+
+	shared_ptr<dcp::MonoPictureMXF> mono = dynamic_pointer_cast<dcp::MonoPictureMXF> (_picture_mxf);
+	if (mono) {
+		reel->add (shared_ptr<dcp::ReelPictureAsset> (new dcp::ReelMonoPictureAsset (mono, 0)));
+		dcp.add (mono);
+	}
+
+	shared_ptr<dcp::StereoPictureMXF> stereo = dynamic_pointer_cast<dcp::StereoPictureMXF> (_picture_mxf);
+	if (stereo) {
+		reel->add (shared_ptr<dcp::ReelPictureAsset> (new dcp::ReelStereoPictureAsset (stereo, 0)));
+		dcp.add (stereo);
+	}
+
+	if (_sound_mxf) {
+		reel->add (shared_ptr<dcp::ReelSoundAsset> (new dcp::ReelSoundAsset (_sound_mxf, 0)));
+		dcp.add (_sound_mxf);
+	}
+
+	if (_subtitle_content) {
+		_subtitle_content->write_xml (_film->dir (_film->dcp_name ()) / _film->subtitle_xml_filename ());
+		reel->add (shared_ptr<dcp::ReelSubtitleAsset> (
+				   new dcp::ReelSubtitleAsset (
+					   _subtitle_content,
+					   dcp::Fraction (_film->video_frame_rate(), 1),
+					   _picture_mxf->intrinsic_duration (),
+					   0
+					   )
+				   ));
+		
+		dcp.add (_subtitle_content);
+	}
+	
+	cpl->add (reel);
 
 	shared_ptr<Job> job = _job.lock ();
-	assert (job);
+	DCPOMATIC_ASSERT (job);
 
 	job->sub (_("Computing image digest"));
-	_picture_asset->compute_digest (boost::bind (&Job::set_progress, job.get(), _1, false));
+	_picture_mxf->hash (boost::bind (&Job::set_progress, job.get(), _1, false));
 
-	if (_sound_asset) {
+	if (_sound_mxf) {
 		job->sub (_("Computing audio digest"));
-		_sound_asset->compute_digest (boost::bind (&Job::set_progress, job.get(), _1, false));
+		_sound_mxf->hash (boost::bind (&Job::set_progress, job.get(), _1, false));
 	}
 
-	libdcp::XMLMetadata meta;
+	dcp::XMLMetadata meta;
 	meta.issuer = Config::instance()->dcp_issuer ();
 	meta.creator = String::compose ("DCP-o-matic %1 %2", dcpomatic_version, dcpomatic_git_commit);
 	meta.set_issue_date_now ();
-	dcp.write_xml (_film->interop (), meta, _film->is_signed() ? make_signer () : shared_ptr<const libdcp::Signer> ());
-
-	LOG_GENERAL (
-		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, Eyes e)
-{
-	boost::mutex::scoped_lock lock (_mutex);
-
-	while (_queued_full_in_memory > _maximum_frames_in_memory) {
-		/* The queue is too big; wait until that is sorted out */
-		_full_condition.wait (lock);
-	}
-	
-	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);
+	shared_ptr<const dcp::Signer> signer;
+	if (_film->is_signed ()) {
+		signer = Config::instance()->signer ();
+		/* We did check earlier, but check again here to be on the safe side */
+		if (!signer->valid ()) {
+			throw InvalidSignerError ();
+		}
 	}
 
-	/* Now there's something to do: wake anything wait()ing on _empty_condition */
-	_empty_condition.notify_all ();
+	dcp.write_xml (_film->interop () ? dcp::INTEROP : dcp::SMPTE, meta, signer);
+
+	LOG_GENERAL (
+		N_("Wrote %1 FULL, %2 FAKE, %3 pushed to disk"), _full_written, _fake_written, _pushed_to_disk
+		);
 }
 
 bool
 Writer::check_existing_picture_mxf_frame (FILE* mxf, int f, Eyes eyes)
 {
 	/* Read the frame info as written */
-	FILE* ifi = fopen_boost (_film->info_path (f, eyes), "r");
-	if (!ifi) {
+	FILE* file = fopen_boost (_film->info_file (), "rb");
+	if (!file) {
 		LOG_GENERAL ("Existing frame %1 has no info file", f);
 		return false;
 	}
 	
-	libdcp::FrameInfo info (ifi);
-	fclose (ifi);
+	dcp::FrameInfo info = read_frame_info (file, f, eyes);
+	fclose (file);
 	if (info.size == 0) {
 		LOG_GENERAL ("Existing frame %1 has no info file", f);
 		return false;
@@ -560,19 +603,12 @@ Writer::check_existing_picture_mxf ()
 		return;
 	}
 
-	int N = 0;
-	for (boost::filesystem::directory_iterator i (_film->info_dir ()); i != boost::filesystem::directory_iterator (); ++i) {
-		++N;
-	}
-
 	while (true) {
 
 		shared_ptr<Job> job = _job.lock ();
-		assert (job);
+		DCPOMATIC_ASSERT (job);
 
-		if (N > 0) {
-			job->set_progress (float (_first_nonexistant_frame) / N);
-		}
+		job->set_progress_unknown ();
 
 		if (_film->three_d ()) {
 			if (!check_existing_picture_mxf_frame (mxf, _first_nonexistant_frame, EYES_LEFT)) {
@@ -606,6 +642,39 @@ Writer::can_fake_write (int frame) const
 	return (frame != 0 && frame < _first_nonexistant_frame);
 }
 
+void
+Writer::write (PlayerSubtitles subs)
+{
+	if (subs.text.empty ()) {
+		return;
+	}
+
+	if (!_subtitle_content) {
+		_subtitle_content.reset (new dcp::InteropSubtitleContent (_film->name(), _film->subtitle_language ()));
+	}
+	
+	for (list<dcp::SubtitleString>::const_iterator i = subs.text.begin(); i != subs.text.end(); ++i) {
+		_subtitle_content->add (*i);
+	}
+}
+
+void
+Writer::write (list<shared_ptr<Font> > fonts)
+{
+	if (fonts.empty ()) {
+		return;
+	}
+	
+	if (!_subtitle_content) {
+		_subtitle_content.reset (new dcp::InteropSubtitleContent (_film->name(), _film->subtitle_language ()));
+	}
+	
+	for (list<shared_ptr<Font> >::const_iterator i = fonts.begin(); i != fonts.end(); ++i) {
+		/* XXX: this LiberationSans-Regular needs to be a path to a DCP-o-matic-distributed copy */
+		_subtitle_content->add_font ((*i)->id, (*i)->file.get_value_or ("LiberationSans-Regular.ttf").leaf().string ());
+	}
+}
+
 bool
 operator< (QueueItem const & a, QueueItem const & b)
 {