/*
- Copyright (C) 2012-2015 Carl Hetherington <cth@carlh.net>
+ Copyright (C) 2012-2016 Carl Hetherington <cth@carlh.net>
- This program is free software; you can redistribute it and/or modify
+ This file is part of DCP-o-matic.
+
+ DCP-o-matic is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
- This program is distributed in the hope that it will be useful,
+ DCP-o-matic is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ along with DCP-o-matic. If not, see <http://www.gnu.org/licenses/>.
*/
#include "job_manager.h"
#include "transcode_job.h"
#include "upload_job.h"
-#include "log.h"
+#include "null_log.h"
+#include "file_log.h"
#include "exceptions.h"
#include "examine_content_job.h"
#include "config.h"
#include "playlist.h"
-#include "player.h"
#include "dcp_content_type.h"
#include "ratio.h"
#include "cross.h"
-#include "cinema.h"
#include "safe_stringstream.h"
#include "environment_info.h"
#include "raw_convert.h"
#include "audio_processor.h"
-#include "md5_digester.h"
+#include "digester.h"
+#include "compose.hpp"
+#include "screen.h"
+#include "audio_content.h"
+#include "video_content.h"
+#include "subtitle_content.h"
+#include "ffmpeg_content.h"
+#include "dcp_content.h"
+#include "screen_kdm.h"
+#include "cinema.h"
#include <libcxml/cxml.h>
#include <dcp/cpl.h>
#include <dcp/certificate_chain.h>
#include <libxml++/libxml++.h>
#include <boost/filesystem.hpp>
#include <boost/algorithm/string.hpp>
-#include <boost/lexical_cast.hpp>
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
+#include <boost/regex.hpp>
#include <unistd.h>
#include <stdexcept>
#include <iostream>
#include <algorithm>
-#include <fstream>
#include <cstdlib>
#include <iomanip>
#include <set>
#include "i18n.h"
using std::string;
-using std::multimap;
using std::pair;
-using std::map;
using std::vector;
using std::setfill;
using std::min;
using std::max;
using std::make_pair;
-using std::endl;
using std::cout;
using std::list;
using std::set;
+using std::runtime_error;
using boost::shared_ptr;
using boost::weak_ptr;
using boost::dynamic_pointer_cast;
-using boost::to_upper_copy;
-using boost::ends_with;
-using boost::starts_with;
using boost::optional;
using boost::is_any_of;
-using dcp::Size;
-using dcp::CertificateChain;
+using boost::make_shared;
-#define LOG_GENERAL(...) log()->log (String::compose (__VA_ARGS__), Log::TYPE_GENERAL);
-#define LOG_GENERAL_NC(...) log()->log (__VA_ARGS__, Log::TYPE_GENERAL);
+#define LOG_GENERAL(...) log()->log (String::compose (__VA_ARGS__), LogEntry::TYPE_GENERAL);
+#define LOG_GENERAL_NC(...) log()->log (__VA_ARGS__, LogEntry::TYPE_GENERAL);
/* 5 -> 6
* AudioMapping XML changed.
*
* Bumped to 32 for 2.0 branch; some times are expressed in Times rather
* than frames now.
+ *
+ * 32 -> 33
+ * Changed <Period> to <Subtitle> in FFmpegSubtitleStream
+ * 33 -> 34
+ * Content only contains audio/subtitle-related tags if those things
+ * are present.
+ * 34 -> 35
+ * VideoFrameType in VideoContent is a string rather than an integer.
*/
-int const Film::current_state_version = 32;
+int const Film::current_state_version = 35;
/** Construct a Film object in a given directory.
*
, _j2k_bandwidth (Config::instance()->default_j2k_bandwidth ())
, _isdcf_metadata (Config::instance()->default_isdcf_metadata ())
, _video_frame_rate (24)
- , _audio_channels (6)
+ , _audio_channels (Config::instance()->default_dcp_audio_channels ())
, _three_d (false)
- , _sequence_video (true)
- , _interop (false)
+ , _sequence (true)
+ , _interop (Config::instance()->default_interop ())
, _audio_processor (0)
+ , _reel_type (REELTYPE_SINGLE)
+ , _reel_length (2000000000)
+ , _upload_after_make_dcp (false)
, _state_version (current_state_version)
, _dirty (false)
{
set_isdcf_date_today ();
_playlist_changed_connection = _playlist->Changed.connect (bind (&Film::playlist_changed, this));
+ _playlist_order_changed_connection = _playlist->OrderChanged.connect (bind (&Film::playlist_order_changed, this));
_playlist_content_changed_connection = _playlist->ContentChanged.connect (bind (&Film::playlist_content_changed, this, _1, _2, _3));
/* Make state.directory a complete path without ..s (where possible)
(Code swiped from Adam Bowen on stackoverflow)
+ XXX: couldn't/shouldn't this just be boost::filesystem::canonical?
*/
boost::filesystem::path p (boost::filesystem::system_complete (dir));
_log.reset (new NullLog);
}
- _playlist->set_sequence_video (_sequence_video);
+ _playlist->set_sequence (_sequence);
}
Film::~Film ()
{
- for (list<boost::signals2::connection>::const_iterator i = _job_connections.begin(); i != _job_connections.end(); ++i) {
- i->disconnect ();
+ BOOST_FOREACH (boost::signals2::connection& i, _job_connections) {
+ i.disconnect ();
+ }
+
+ BOOST_FOREACH (boost::signals2::connection& i, _audio_analysis_connections) {
+ i.disconnect ();
}
}
/** @return The file to write video frame info to */
boost::filesystem::path
-Film::info_file () const
+Film::info_file (DCPTimePeriod period) const
{
boost::filesystem::path p;
p /= "info";
- p /= video_identifier ();
+ p /= video_identifier () + "_" + raw_convert<string> (period.from.get()) + "_" + raw_convert<string> (period.to.get());
return file (p);
}
}
boost::filesystem::path
-Film::internal_video_asset_filename () const
+Film::internal_video_asset_filename (DCPTimePeriod p) const
{
- return video_identifier() + ".mxf";
+ return video_identifier() + "_" + raw_convert<string> (p.from.get()) + "_" + raw_convert<string> (p.to.get()) + ".mxf";
}
boost::filesystem::path
{
boost::filesystem::path p = dir ("analysis");
- MD5Digester digester;
+ Digester digester;
BOOST_FOREACH (shared_ptr<Content> i, playlist->content ()) {
- shared_ptr<AudioContent> ac = dynamic_pointer_cast<AudioContent> (i);
- if (!ac) {
+ if (!i->audio) {
continue;
}
- digester.add (ac->digest ());
- digester.add (ac->audio_mapping().digest ());
+ digester.add (i->digest ());
+ digester.add (i->audio->mapping().digest ());
if (playlist->content().size() != 1) {
/* Analyses should be considered equal regardless of gain
if they were made from just one piece of content. This
analysis at the plotting stage rather than having to
recompute it.
*/
- digester.add (ac->audio_gain ());
+ digester.add (i->audio->gain ());
}
}
set_isdcf_date_today ();
- environment_info (log ());
+ BOOST_FOREACH (string i, environment_info ()) {
+ LOG_GENERAL_NC (i);
+ }
BOOST_FOREACH (shared_ptr<const Content> i, content ()) {
LOG_GENERAL ("Content: %1", i->technical_summary());
}
LOG_GENERAL ("DCP video rate %1 fps", video_frame_rate());
- LOG_GENERAL ("%1 threads", Config::instance()->num_local_encoding_threads());
+ if (Config::instance()->only_servers_encode ()) {
+ LOG_GENERAL_NC ("0 threads: ONLY SERVERS SET TO ENCODE");
+ } else {
+ LOG_GENERAL ("%1 threads", Config::instance()->num_local_encoding_threads());
+ }
LOG_GENERAL ("J2K bandwidth %1", j2k_bandwidth());
if (container() == 0) {
}
if (content().empty()) {
- throw StringError (_("You must add some content to the DCP before creating it"));
+ throw runtime_error (_("You must add some content to the DCP before creating it"));
}
if (dcp_content_type() == 0) {
throw MissingSettingError (_("name"));
}
- JobManager::instance()->add (shared_ptr<Job> (new TranscodeJob (shared_from_this())));
+ JobManager::instance()->add (make_shared<TranscodeJob> (shared_from_this()));
}
/** Start a job to send our DCP to the configured TMS */
void
Film::send_dcp_to_tms ()
{
- shared_ptr<Job> j (new UploadJob (shared_from_this()));
+ shared_ptr<Job> j = make_shared<UploadJob> (shared_from_this());
JobManager::instance()->add (j);
}
shared_ptr<xmlpp::Document>
Film::metadata () const
{
- shared_ptr<xmlpp::Document> doc (new xmlpp::Document);
+ shared_ptr<xmlpp::Document> doc = make_shared<xmlpp::Document> ();
xmlpp::Element* root = doc->create_root_node ("Metadata");
root->add_child("Version")->add_child_text (raw_convert<string> (current_state_version));
root->add_child("ISDCFDate")->add_child_text (boost::gregorian::to_iso_string (_isdcf_date));
root->add_child("AudioChannels")->add_child_text (raw_convert<string> (_audio_channels));
root->add_child("ThreeD")->add_child_text (_three_d ? "1" : "0");
- root->add_child("SequenceVideo")->add_child_text (_sequence_video ? "1" : "0");
+ root->add_child("Sequence")->add_child_text (_sequence ? "1" : "0");
root->add_child("Interop")->add_child_text (_interop ? "1" : "0");
root->add_child("Signed")->add_child_text (_signed ? "1" : "0");
root->add_child("Encrypted")->add_child_text (_encrypted ? "1" : "0");
if (_audio_processor) {
root->add_child("AudioProcessor")->add_child_text (_audio_processor->id ());
}
+ root->add_child("ReelType")->add_child_text (raw_convert<string> (_reel_type));
+ root->add_child("ReelLength")->add_child_text (raw_convert<string> (_reel_length));
+ root->add_child("UploadAfterMakeDCP")->add_child_text (_upload_after_make_dcp ? "1" : "0");
_playlist->as_xml (root->add_child ("Playlist"));
return doc;
Film::read_metadata ()
{
if (boost::filesystem::exists (file ("metadata")) && !boost::filesystem::exists (file ("metadata.xml"))) {
- throw StringError (_("This film was created with an older version of DCP-o-matic, and unfortunately it cannot be loaded into this version. You will need to create a new Film, re-add your content and set it up again. Sorry!"));
+ throw runtime_error (_("This film was created with an older version of DCP-o-matic, and unfortunately it cannot be loaded into this version. You will need to create a new Film, re-add your content and set it up again. Sorry!"));
}
cxml::Document f ("Metadata");
_state_version = f.number_child<int> ("Version");
if (_state_version > current_state_version) {
- throw StringError (_("This film was created with a newer version of DCP-o-matic, and it cannot be loaded into this version. Sorry!"));
+ throw runtime_error (_("This film was created with a newer version of DCP-o-matic, and it cannot be loaded into this version. Sorry!"));
}
_name = f.string_child ("Name");
} else if ((_audio_channels % 2) == 1) {
_audio_channels++;
}
- _sequence_video = f.bool_child ("SequenceVideo");
+
+ if (f.optional_bool_child("SequenceVideo")) {
+ _sequence = f.bool_child("SequenceVideo");
+ } else {
+ _sequence = f.bool_child("Sequence");
+ }
+
_three_d = f.bool_child ("ThreeD");
_interop = f.bool_child ("Interop");
_key = dcp::Key (f.string_child ("Key"));
_audio_processor = 0;
}
+ _reel_type = static_cast<ReelType> (f.optional_number_child<int>("ReelType").get_value_or (static_cast<int>(REELTYPE_SINGLE)));
+ _reel_length = f.optional_number_child<int64_t>("ReelLength").get_value_or (2000000000);
+ _upload_after_make_dcp = f.optional_bool_child("UploadAfterMakeDCP").get_value_or (false);
+
list<string> notes;
/* This method is the only one that can return notes (so far) */
_playlist->set_from_xml (shared_from_this(), f.node_child ("Playlist"), _state_version, notes);
return p;
}
+list<int>
+Film::mapped_audio_channels () const
+{
+ list<int> mapped;
+
+ if (audio_processor ()) {
+ /* Processors are mapped 1:1 to DCP outputs so we can work out mappings from there */
+ for (int i = 0; i < audio_processor()->out_channels(); ++i) {
+ mapped.push_back (i);
+ }
+ } else {
+ BOOST_FOREACH (shared_ptr<Content> i, content ()) {
+ if (i->audio) {
+ list<int> c = i->audio->mapping().mapped_output_channels ();
+ copy (c.begin(), c.end(), back_inserter (mapped));
+ }
+ }
+
+ mapped.sort ();
+ mapped.unique ();
+ }
+
+ return mapped;
+}
+
/** @return a ISDCF-compliant name for a DCP of this film */
string
Film::isdcf_name (bool if_created_now) const
d << "_" << container()->isdcf_name();
}
- ContentList cl = content ();
-
/* XXX: this uses the first bit of content only */
/* The standard says we don't do this for trailers, for some strange reason */
if (dcp_content_type() && dcp_content_type()->libdcp_kind() != dcp::TRAILER) {
Ratio const * content_ratio = 0;
- for (ContentList::iterator i = cl.begin(); i != cl.end(); ++i) {
- shared_ptr<VideoContent> vc = dynamic_pointer_cast<VideoContent> (*i);
- if (vc) {
+ BOOST_FOREACH (shared_ptr<Content> i, content ()) {
+ if (i->video) {
/* Here's the first piece of video content */
- if (vc->scale().ratio ()) {
- content_ratio = vc->scale().ratio ();
+ if (i->video->scale().ratio ()) {
+ content_ratio = i->video->scale().ratio ();
} else {
- content_ratio = Ratio::from_ratio (vc->video_size().ratio ());
+ content_ratio = Ratio::from_ratio (i->video->size().ratio ());
}
break;
}
if (!dm.audio_language.empty ()) {
d << "_" << dm.audio_language;
if (!dm.subtitle_language.empty()) {
- d << "-" << dm.subtitle_language;
+
+ bool burnt_in = true;
+ BOOST_FOREACH (shared_ptr<Content> i, content ()) {
+ if (!i->subtitle) {
+ continue;
+ }
+
+ if (i->subtitle->use() && !i->subtitle->burn()) {
+ burnt_in = false;
+ }
+ }
+
+ string language = dm.subtitle_language;
+ if (burnt_in && language != "XX") {
+ transform (language.begin(), language.end(), language.begin(), ::tolower);
+ } else {
+ transform (language.begin(), language.end(), language.begin(), ::toupper);
+ }
+
+ d << "-" << language;
} else {
d << "-XX";
}
}
}
- /* Find all mapped channels */
+ /* Count mapped audio channels */
int non_lfe = 0;
int lfe = 0;
- if (audio_processor ()) {
- /* Processors are mapped 1:1 to DCP outputs so we can guess the number of LFE/
- non-LFE from the channel counts.
- */
- non_lfe = audio_processor()->out_channels ();
- if (non_lfe >= 4) {
- --non_lfe;
- ++lfe;
- }
- } else {
- list<int> mapped;
- for (ContentList::const_iterator i = cl.begin(); i != cl.end(); ++i) {
- shared_ptr<const AudioContent> ac = dynamic_pointer_cast<const AudioContent> (*i);
- if (ac) {
- list<int> c = ac->audio_mapping().mapped_output_channels ();
- copy (c.begin(), c.end(), back_inserter (mapped));
- }
+ BOOST_FOREACH (int i, mapped_audio_channels ()) {
+ if (i >= audio_channels()) {
+ /* This channel is mapped but is not included in the DCP */
+ continue;
}
- mapped.sort ();
- mapped.unique ();
-
- /* Count them */
-
- for (list<int>::const_iterator i = mapped.begin(); i != mapped.end(); ++i) {
- if (*i >= audio_channels()) {
- /* This channel is mapped but is not included in the DCP */
- continue;
- }
-
- if (static_cast<dcp::Channel> (*i) == dcp::LFE) {
- ++lfe;
- } else {
- ++non_lfe;
- }
+ if (static_cast<dcp::Channel> (i) == dcp::LFE) {
+ ++lfe;
+ } else {
+ ++non_lfe;
}
}
d << "-3D";
}
- if (!dm.package_type.empty ()) {
- d << "_" << dm.package_type;
+ bool vf = false;
+ BOOST_FOREACH (shared_ptr<Content> i, content ()) {
+ shared_ptr<const DCPContent> dc = dynamic_pointer_cast<const DCPContent> (i);
+ if (dc && (dc->reference_video() || dc->reference_audio() || dc->reference_subtitle())) {
+ vf = true;
+ }
+ }
+
+ if (vf) {
+ d << "_VF";
+ } else {
+ d << "_OV";
}
return d.str ();
signal_changed (AUDIO_CHANNELS);
}
+void
+Film::set_reel_type (ReelType t)
+{
+ _reel_type = t;
+ signal_changed (REEL_TYPE);
+}
+
+/** @param r Desired reel length in bytes */
+void
+Film::set_reel_length (int64_t r)
+{
+ _reel_length = r;
+ signal_changed (REEL_LENGTH);
+}
+
+void
+Film::set_upload_after_make_dcp (bool u)
+{
+ _upload_after_make_dcp = u;
+ signal_changed (UPLOAD_AFTER_MAKE_DCP);
+}
+
void
Film::signal_changed (Property p)
{
switch (p) {
case Film::CONTENT:
- set_video_frame_rate (_playlist->best_dcp_frame_rate ());
+ set_video_frame_rate (_playlist->best_video_frame_rate ());
break;
case Film::VIDEO_FRAME_RATE:
- case Film::SEQUENCE_VIDEO:
- _playlist->maybe_sequence_video ();
+ case Film::SEQUENCE:
+ _playlist->maybe_sequence ();
break;
default:
break;
}
boost::filesystem::path
-Film::j2c_path (int f, Eyes e, bool t) const
+Film::j2c_path (int reel, Frame frame, Eyes eyes, bool tmp) const
{
boost::filesystem::path p;
p /= "j2c";
SafeStringStream s;
s.width (8);
- s << setfill('0') << f;
+ s << setfill('0') << reel << "_" << frame;
- if (e == EYES_LEFT) {
+ if (eyes == EYES_LEFT) {
s << ".L";
- } else if (e == EYES_RIGHT) {
+ } else if (eyes == EYES_RIGHT) {
s << ".R";
}
s << ".j2c";
- if (t) {
+ if (tmp) {
s << ".tmp";
}
void
Film::examine_content (shared_ptr<Content> c)
{
- shared_ptr<Job> j (new ExamineContentJob (shared_from_this(), c));
+ shared_ptr<Job> j = make_shared<ExamineContentJob> (shared_from_this(), c);
JobManager::instance()->add (j);
}
void
Film::examine_and_add_content (shared_ptr<Content> c)
{
- if (dynamic_pointer_cast<FFmpegContent> (c)) {
+ if (dynamic_pointer_cast<FFmpegContent> (c) && !_directory.empty ()) {
run_ffprobe (c->path(0), file ("ffprobe.log"), _log);
}
- shared_ptr<Job> j (new ExamineContentJob (shared_from_this(), c));
+ shared_ptr<Job> j = make_shared<ExamineContentJob> (shared_from_this(), c);
_job_connections.push_back (
- j->Finished.connect (bind (&Film::maybe_add_content, this, boost::weak_ptr<Job> (j), boost::weak_ptr<Content> (c)))
+ j->Finished.connect (bind (&Film::maybe_add_content, this, weak_ptr<Job> (j), weak_ptr<Content> (c)))
);
JobManager::instance()->add (j);
}
shared_ptr<Content> content = c.lock ();
- if (content) {
- add_content (content);
+ if (!content) {
+ return;
+ }
+
+ add_content (content);
+ if (Config::instance()->automatic_audio_analysis() && content->audio) {
+ shared_ptr<Playlist> playlist = make_shared<Playlist> ();
+ playlist->add (content);
+ boost::signals2::connection c;
+ JobManager::instance()->analyse_audio (
+ shared_from_this (), playlist, c, bind (&Film::audio_analysis_finished, this)
+ );
+ _audio_analysis_connections.push_back (c);
}
}
void
Film::add_content (shared_ptr<Content> c)
{
- /* Add video content after any existing content */
- if (dynamic_pointer_cast<VideoContent> (c)) {
+ /* Add {video,subtitle} content after any existing {video,subtitle} content */
+ if (c->video) {
c->set_position (_playlist->video_end ());
+ } else if (c->subtitle) {
+ c->set_position (_playlist->subtitle_end ());
}
_playlist->add (c);
_playlist->move_later (c);
}
+/** @return length of the film from time 0 to the last thing on the playlist */
DCPTime
Film::length () const
{
int
Film::best_video_frame_rate () const
{
- return _playlist->best_dcp_frame_rate ();
+ return _playlist->best_video_frame_rate ();
}
FrameRateChange
}
void
-Film::playlist_content_changed (boost::weak_ptr<Content> c, int p, bool frequent)
+Film::playlist_content_changed (weak_ptr<Content> c, int p, bool frequent)
{
_dirty = true;
- if (p == VideoContentProperty::VIDEO_FRAME_RATE) {
- set_video_frame_rate (_playlist->best_dcp_frame_rate ());
- } else if (p == AudioContentProperty::AUDIO_STREAMS) {
+ if (p == ContentProperty::VIDEO_FRAME_RATE) {
+ set_video_frame_rate (_playlist->best_video_frame_rate ());
+ } else if (p == AudioContentProperty::STREAMS) {
signal_changed (NAME);
}
signal_changed (NAME);
}
+void
+Film::playlist_order_changed ()
+{
+ signal_changed (CONTENT_ORDER);
+}
+
int
Film::audio_frame_rate () const
{
- /* XXX */
+ BOOST_FOREACH (shared_ptr<Content> i, content ()) {
+ if (i->audio && i->audio->has_rate_above_48k ()) {
+ return 96000;
+ }
+ }
+
return 48000;
}
void
-Film::set_sequence_video (bool s)
+Film::set_sequence (bool s)
{
- _sequence_video = s;
- _playlist->set_sequence_video (s);
- signal_changed (SEQUENCE_VIDEO);
+ _sequence = s;
+ _playlist->set_sequence (s);
+ signal_changed (SEQUENCE);
}
/** @return Size of the largest possible image in whatever resolution we are using */
return fit_ratio_within (container()->ratio(), full_frame ());
}
+/** @param from KDM from time expressed as a local time with an offset from UTC
+ * @param to KDM to time expressed as a local time with an offset from UTC
+ */
dcp::EncryptedKDM
Film::make_kdm (
- dcp::Certificate target,
+ dcp::Certificate recipient,
+ vector<dcp::Certificate> trusted_devices,
boost::filesystem::path cpl_file,
dcp::LocalTime from,
dcp::LocalTime until,
dcp::Formulation formulation
) const
{
- shared_ptr<const dcp::CPL> cpl (new dcp::CPL (cpl_file));
+ shared_ptr<const dcp::CPL> cpl = make_shared<dcp::CPL> (cpl_file);
shared_ptr<const dcp::CertificateChain> signer = Config::instance()->signer_chain ();
if (!signer->valid ()) {
throw InvalidSignerError ();
}
return dcp::DecryptedKDM (
- cpl, key(), from, until, "DCP-o-matic", cpl->content_title_text(), dcp::LocalTime().as_string()
- ).encrypt (signer, target, formulation);
+ cpl, key(), from, until, cpl->content_title_text(), cpl->content_title_text(), dcp::LocalTime().as_string()
+ ).encrypt (signer, recipient, trusted_devices, formulation);
}
-list<dcp::EncryptedKDM>
+/** @param from KDM from time expressed as a local time in the time zone of the Screen's Cinema.
+ * @param to KDM to time expressed as a local time in the time zone of the Screen's Cinema.
+ */
+list<ScreenKDM>
Film::make_kdms (
list<shared_ptr<Screen> > screens,
boost::filesystem::path dcp,
- dcp::LocalTime from,
- dcp::LocalTime until,
+ boost::posix_time::ptime from,
+ boost::posix_time::ptime until,
dcp::Formulation formulation
) const
{
- list<dcp::EncryptedKDM> kdms;
-
- for (list<shared_ptr<Screen> >::iterator i = screens.begin(); i != screens.end(); ++i) {
- if ((*i)->certificate) {
- kdms.push_back (make_kdm ((*i)->certificate.get(), dcp, from, until, formulation));
+ list<ScreenKDM> kdms;
+
+ BOOST_FOREACH (shared_ptr<Screen> i, screens) {
+ if (i->recipient) {
+ dcp::EncryptedKDM const kdm = make_kdm (
+ i->recipient.get(),
+ i->trusted_devices,
+ dcp,
+ dcp::LocalTime (from, i->cinema->utc_offset_hour(), i->cinema->utc_offset_minute()),
+ dcp::LocalTime (until, i->cinema->utc_offset_hour(), i->cinema->utc_offset_minute()),
+ formulation
+ );
+
+ kdms.push_back (ScreenKDM (i, kdm));
}
}
uint64_t
Film::required_disk_space () const
{
- return uint64_t (j2k_bandwidth() / 8) * length().seconds();
+ return _playlist->required_disk_space (j2k_bandwidth(), audio_channels(), audio_frame_rate());
}
/** This method checks the disk that the Film is on and tries to decide whether or not
* there will be enough space to make a DCP for it. If so, true is returned; if not,
- * false is returned and required and availabe are filled in with the amount of disk space
+ * false is returned and required and available are filled in with the amount of disk space
* required and available respectively (in Gb).
*
* Note: the decision made by this method isn't, of course, 100% reliable.
ContentList cl = content ();
BOOST_FOREACH (shared_ptr<Content>& c, cl) {
- shared_ptr<SubtitleContent> sc = dynamic_pointer_cast<SubtitleContent> (c);
- if (sc) {
- languages.insert (sc->subtitle_language ());
+ if (c->subtitle) {
+ languages.insert (c->subtitle->language ());
}
}
/** Change the gains of the supplied AudioMapping to make it a default
* for this film. The defaults are guessed based on what processor (if any)
- * is in use and the number of input channels.
+ * is in use, the number of input channels and any filename supplied.
*/
void
-Film::make_audio_mapping_default (AudioMapping& mapping) const
+Film::make_audio_mapping_default (AudioMapping& mapping, optional<boost::filesystem::path> filename) const
{
+ static string const regex[] = {
+ ".*[\\._-]L[\\._-].*",
+ ".*[\\._-]R[\\._-].*",
+ ".*[\\._-]C[\\._-].*",
+ ".*[\\._-]Lfe[\\._-].*",
+ ".*[\\._-]Ls[\\._-].*",
+ ".*[\\._-]Rs[\\._-].*"
+ };
+
+ static int const regexes = sizeof(regex) / sizeof(*regex);
+
if (audio_processor ()) {
audio_processor()->make_audio_mapping_default (mapping);
} else {
mapping.make_zero ();
if (mapping.input_channels() == 1) {
- /* Mono -> Centre */
- mapping.set (0, static_cast<int> (dcp::CENTRE), 1);
+ bool guessed = false;
+
+ /* See if we can guess where this stream should go */
+ if (filename) {
+ for (int i = 0; i < regexes; ++i) {
+ boost::regex e (regex[i], boost::regex::icase);
+ if (boost::regex_match (filename->string(), e) && i < mapping.output_channels()) {
+ mapping.set (0, i, 1);
+ guessed = true;
+ }
+ }
+ }
+
+ if (!guessed) {
+ /* If we have no idea, just put it on centre */
+ mapping.set (0, static_cast<int> (dcp::CENTRE), 1);
+ }
} else {
/* 1:1 mapping */
for (int i = 0; i < min (mapping.input_channels(), mapping.output_channels()); ++i) {
return audio_processor()->input_names ();
}
+ DCPOMATIC_ASSERT (MAX_DCP_AUDIO_CHANNELS == 16);
+
vector<string> n;
n.push_back (_("L"));
n.push_back (_("R"));
n.push_back (_("Rc"));
n.push_back (_("BsL"));
n.push_back (_("BsR"));
+ n.push_back (_("DBP"));
+ n.push_back (_("DBS"));
+ n.push_back ("");
+ n.push_back ("");
return vector<string> (n.begin(), n.begin() + audio_channels ());
}
{
_playlist->remove (c);
}
+
+void
+Film::audio_analysis_finished ()
+{
+ /* XXX */
+}
+
+list<DCPTimePeriod>
+Film::reels () const
+{
+ list<DCPTimePeriod> p;
+ DCPTime const len = length().round_up (video_frame_rate ());
+
+ switch (reel_type ()) {
+ case REELTYPE_SINGLE:
+ p.push_back (DCPTimePeriod (DCPTime (), len));
+ break;
+ case REELTYPE_BY_VIDEO_CONTENT:
+ {
+ optional<DCPTime> last_split;
+ shared_ptr<Content> last_video;
+ ContentList cl = content ();
+ BOOST_FOREACH (shared_ptr<Content> c, content ()) {
+ if (c->video) {
+ BOOST_FOREACH (DCPTime t, c->reel_split_points()) {
+ if (last_split) {
+ p.push_back (DCPTimePeriod (last_split.get(), t));
+ }
+ last_split = t;
+ }
+ last_video = c;
+ }
+ }
+
+ DCPTime video_end = last_video ? last_video->end() : DCPTime(0);
+ if (last_split) {
+ /* Definitely go from the last split to the end of the video content */
+ p.push_back (DCPTimePeriod (last_split.get(), video_end));
+ }
+
+ if (video_end < len) {
+ /* And maybe go after that as well if there is any non-video hanging over the end */
+ p.push_back (DCPTimePeriod (video_end, len));
+ }
+ break;
+ }
+ case REELTYPE_BY_LENGTH:
+ {
+ DCPTime current;
+ /* Integer-divide reel length by the size of one frame to give the number of frames per reel */
+ Frame const reel_in_frames = _reel_length / ((j2k_bandwidth() / video_frame_rate()) / 8);
+ while (current < len) {
+ DCPTime end = min (len, current + DCPTime::from_frames (reel_in_frames, video_frame_rate ()));
+ p.push_back (DCPTimePeriod (current, end));
+ current = end;
+ }
+ break;
+ }
+ }
+
+ return p;
+}