#include "ab_transcode_job.h"
#include "transcode_job.h"
#include "scp_dcp_job.h"
-#include "make_dcp_job.h"
#include "log.h"
#include "options.h"
#include "exceptions.h"
#include "scaler.h"
#include "decoder_factory.h"
#include "config.h"
-#include "check_hashes_job.h"
#include "version.h"
#include "ui_signaller.h"
#include "video_decoder.h"
using boost::ends_with;
using boost::starts_with;
using boost::optional;
+using libdcp::Size;
int const Film::state_version = 2;
, _scaler (o._scaler)
, _trim_start (o._trim_start)
, _trim_end (o._trim_end)
- , _reel_size (o._reel_size)
, _dcp_ab (o._dcp_ab)
, _content_audio_stream (o._content_audio_stream)
, _external_audio (o._external_audio)
, _package_type (o._package_type)
, _size (o._size)
, _length (o._length)
+ , _dcp_intrinsic_duration (o._dcp_intrinsic_duration)
, _content_digest (o._content_digest)
, _content_audio_streams (o._content_audio_streams)
, _external_audio_stream (o._external_audio_stream)
{
delete _log;
}
-
-/** @return The path to the directory to write JPEG2000 files to */
+
string
-Film::j2k_dir () const
+Film::video_state_identifier () const
{
- assert (format());
-
- boost::filesystem::path p;
-
- /* Start with j2c */
- p /= "j2c";
+ assert (format ());
pair<string, string> f = Filter::ffmpeg_strings (filters());
- /* Write stuff to specify the filter / post-processing settings that are in use,
- so that we don't get confused about J2K files generated using different
- settings.
- */
stringstream s;
s << format()->id()
<< "_" << content_digest()
<< "_" << j2k_bandwidth()
<< "_" << boost::lexical_cast<int> (colour_lut());
- p /= s.str ();
-
- /* Similarly for the A/B case */
if (dcp_ab()) {
- stringstream s;
pair<string, string> fa = Filter::ffmpeg_strings (Config::instance()->reference_filters());
s << "ab_" << Config::instance()->reference_scaler()->id() << "_" << fa.first << "_" << fa.second;
- p /= s.str ();
}
-
+
+ return s.str ();
+}
+
+/** @return The path to the directory to write video frame hash files to */
+string
+Film::hash_dir () const
+{
+ boost::filesystem::path p;
+ p /= "hash";
+ p /= video_state_identifier ();
return dir (p.string());
}
+string
+Film::video_mxf_path () const
+{
+ boost::filesystem::path p;
+ p /= "video";
+ p /= video_state_identifier ();
+ return file (p.string());
+}
+
/** Add suitable Jobs to the JobManager to create a DCP for this Film.
* @param true to transcode, false to use the WAV and J2K files that are already there.
*/
r = JobManager::instance()->add (shared_ptr<Job> (new TranscodeJob (shared_from_this(), od, shared_ptr<Job> ())));
}
}
-
- r = JobManager::instance()->add (shared_ptr<Job> (new CheckHashesJob (shared_from_this(), od, r)));
- JobManager::instance()->add (shared_ptr<Job> (new MakeDCPJob (shared_from_this(), r)));
}
/** Start a job to examine our content file */
}
int N = 0;
- for (boost::filesystem::directory_iterator i = boost::filesystem::directory_iterator (j2k_dir ()); i != boost::filesystem::directory_iterator(); ++i) {
+ for (boost::filesystem::directory_iterator i = boost::filesystem::directory_iterator (hash_dir ()); i != boost::filesystem::directory_iterator(); ++i) {
++N;
boost::this_thread::interruption_point ();
}
f << "scaler " << _scaler->id () << "\n";
f << "trim_start " << _trim_start << "\n";
f << "trim_end " << _trim_end << "\n";
- if (_reel_size) {
- f << "reel_size " << _reel_size.get() << "\n";
- }
f << "dcp_ab " << (_dcp_ab ? "1" : "0") << "\n";
if (_content_audio_stream) {
f << "selected_content_audio_stream " << _content_audio_stream->to_string() << "\n";
f << "width " << _size.width << "\n";
f << "height " << _size.height << "\n";
f << "length " << _length.get_value_or(0) << "\n";
+ f << "dcp_intrinsic_duration " << _dcp_intrinsic_duration.get_value_or(0) << "\n";
f << "content_digest " << _content_digest << "\n";
for (vector<shared_ptr<AudioStream> >::const_iterator i = _content_audio_streams.begin(); i != _content_audio_streams.end(); ++i) {
_trim_start = atoi (v.c_str ());
} else if ( ((!version || version < 2) && k == "trim_end") || k == "trim_end") {
_trim_end = atoi (v.c_str ());
- } else if (k == "reel_size") {
- _reel_size = boost::lexical_cast<uint64_t> (v);
} else if (k == "dcp_ab") {
_dcp_ab = (v == "1");
} else if (k == "selected_content_audio_stream" || (!version && k == "selected_audio_stream")) {
if (vv) {
_length = vv;
}
+ } else if (k == "dcp_intrinsic_duration") {
+ int const vv = atoi (v.c_str ());
+ if (vv) {
+ _dcp_intrinsic_duration = vv;
+ }
} else if (k == "content_digest") {
_content_digest = v;
} else if (k == "content_audio_stream" || (!version && k == "audio_stream")) {
_dirty = false;
}
-Size
-Film::cropped_size (Size s) const
+libdcp::Size
+Film::cropped_size (libdcp::Size s) const
{
boost::mutex::scoped_lock lm (_state_mutex);
s.width -= _crop.left + _crop.right;
return rint (t);
}
-boost::optional<int>
-Film::dcp_length () const
+int
+Film::still_duration_in_frames () const
{
- if (content_type() == STILL) {
- return _still_duration * frames_per_second();
- }
-
- if (!length()) {
- return boost::optional<int> ();
- }
-
- return length().get() - trim_start() - trim_end();
+ return still_duration() * frames_per_second();
}
/** @return a DCI-compliant name for a DCP of this film */
signal_changed (TRIM_END);
}
-void
-Film::set_reel_size (uint64_t s)
-{
- {
- boost::mutex::scoped_lock lm (_state_mutex);
- _reel_size = s;
- }
- signal_changed (REEL_SIZE);
-}
-
-void
-Film::unset_reel_size ()
-{
- {
- boost::mutex::scoped_lock lm (_state_mutex);
- _reel_size = boost::optional<uint64_t> ();
- }
- signal_changed (REEL_SIZE);
-}
-
void
Film::set_dcp_ab (bool a)
{
}
void
-Film::set_size (Size s)
+Film::set_size (libdcp::Size s)
{
{
boost::mutex::scoped_lock lm (_state_mutex);
_length = boost::none;
}
signal_changed (LENGTH);
-}
+}
+
+void
+Film::set_dcp_intrinsic_duration (int d)
+{
+ {
+ boost::mutex::scoped_lock lm (_state_mutex);
+ _dcp_intrinsic_duration = d;
+ }
+ signal_changed (DCP_INTRINSIC_DURATION);
+}
void
Film::set_content_digest (string d)
return _external_audio_stream;
}
-/** @param f Source frame index.
- * @param t true to return a temporary file path, otherwise a permanent one.
- * @return The path to write this video frame to.
- */
string
-Film::frame_out_path (SourceFrame f, bool t) const
+Film::hash_path (int f) const
{
+ boost::filesystem::path p;
+ p /= hash_dir ();
+
stringstream s;
- s << j2k_dir() << "/";
s.width (8);
- s << std::setfill('0') << f << ".j2c";
-
- if (t) {
- s << ".tmp";
- }
+ s << setfill('0') << f << ".md5";
- return s.str ();
+ p /= s.str();
+ return p.string ();
}
string
-Film::hash_out_path (SourceFrame f, bool t) const
+Film::j2c_path (int f, bool t) const
{
- return frame_out_path (f, t) + ".md5";
-}
+ boost::filesystem::path p;
+ p /= "j2c";
+ p /= video_state_identifier ();
-/** @param c Audio channel index.
- * @param t true to return a temporary file path, otherwise a permanent one.
- * @return The path to write this audio file to.
- */
-string
-Film::multichannel_audio_out_path (int c, bool t) const
-{
stringstream s;
- s << dir ("wavs") << "/" << (c + 1) << ".wav";
+ s.width (8);
+ s << setfill('0') << f << ".j2c";
+
if (t) {
s << ".tmp";
}
-
- return s.str ();
-}
-boost::optional<pair<SourceFrame, SourceFrame> >
-Film::video_range () const
-{
- if (!dcp_length()) {
- return boost::optional<pair<SourceFrame, SourceFrame> > ();
- }
-
- return make_pair (trim_start(), trim_start() + dcp_length().get());
+ p /= s.str();
+ return p.string ();
}
-boost::optional<pair<int64_t, int64_t> >
-Film::audio_range () const
-{
- boost::optional<pair<SourceFrame, SourceFrame> > vr = video_range ();
- if (!vr || !audio_stream()) {
- return boost::optional<pair<int64_t, int64_t> > ();
- }
- DCPFrameRate dfr (frames_per_second ());
- return make_pair (
-
- video_frames_to_audio_frames (
- vr.get().first,
- dcp_audio_sample_rate (audio_stream()->sample_rate()),
- dfr.frames_per_second
- ),
-
- video_frames_to_audio_frames (
- vr.get().second,
- dcp_audio_sample_rate (audio_stream()->sample_rate()),
- dfr.frames_per_second
- )
- );
-}
projects / dcpomatic.git / blobdiff