/*
- 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 "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>
, _video_frame_rate (24)
, _audio_channels (6)
, _three_d (false)
- , _sequence_video (true)
+ , _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)
{
_log.reset (new NullLog);
}
- _playlist->set_sequence_video (_sequence_video);
+ _playlist->set_sequence (_sequence);
}
Film::~Film ()
MD5Digester 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 ());
}
}
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");
}
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;
} 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"));
_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) */
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
if (dcp_content_type() && dcp_content_type()->libdcp_kind() != dcp::TRAILER) {
Ratio const * content_ratio = 0;
BOOST_FOREACH (shared_ptr<Content> i, content ()) {
- shared_ptr<VideoContent> vc = dynamic_pointer_cast<VideoContent> (i);
- if (vc) {
+ 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;
}
d << "_" << dm.audio_language;
if (!dm.subtitle_language.empty()) {
- bool burnt_in = false;
+ bool burnt_in = true;
BOOST_FOREACH (shared_ptr<Content> i, content ()) {
- shared_ptr<SubtitleContent> sc = dynamic_pointer_cast<SubtitleContent> (i);
- if (!sc) {
+ if (!i->subtitle) {
continue;
}
- if (sc->use_subtitles() && sc->burn_subtitles()) {
- burnt_in = true;
+ if (i->subtitle->use() && !i->subtitle->burn()) {
+ burnt_in = false;
}
}
string language = dm.subtitle_language;
- if (burnt_in) {
+ if (burnt_in && language != "XX") {
transform (language.begin(), language.end(), language.begin(), ::tolower);
} else {
transform (language.begin(), language.end(), language.begin(), ::toupper);
}
}
- /* 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;
- BOOST_FOREACH (shared_ptr<Content> i, content ()) {
- 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;
}
}
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;
}
add_content (content);
- if (Config::instance()->automatic_audio_analysis ()) {
+ if (Config::instance()->automatic_audio_analysis() && content->audio) {
shared_ptr<Playlist> playlist (new Playlist);
playlist->add (content);
boost::signals2::connection 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);
int
Film::best_video_frame_rate () const
{
- return _playlist->best_dcp_frame_rate ();
+ return _playlist->best_video_frame_rate ();
}
FrameRateChange
{
_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);
}
Film::audio_frame_rate () const
{
BOOST_FOREACH (shared_ptr<Content> i, content ()) {
- shared_ptr<AudioContent> a = dynamic_pointer_cast<AudioContent> (i);
- if (a && a->has_rate_above_48k ()) {
+ if (i->audio && i->audio->has_rate_above_48k ()) {
return 96000;
}
}
}
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 recipient,
}
return dcp::DecryptedKDM (
- cpl, key(), from, until, "DCP-o-matic", cpl->content_title_text(), dcp::LocalTime().as_string()
+ cpl, key(), from, until, cpl->content_title_text(), cpl->content_title_text(), dcp::LocalTime().as_string()
).encrypt (signer, recipient, trusted_devices, formulation);
}
+/** @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
{
BOOST_FOREACH (shared_ptr<Screen> i, screens) {
if (i->recipient) {
- kdms.push_back (ScreenKDM (i, make_kdm (i->recipient.get(), i->trusted_devices, dcp, from, until, formulation)));
+ 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));
}
}
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 ());
}
}
case REELTYPE_BY_VIDEO_CONTENT:
{
optional<DCPTime> last_split;
- shared_ptr<VideoContent> last_video;
+ shared_ptr<Content> last_video;
ContentList cl = content ();
BOOST_FOREACH (shared_ptr<Content> c, content ()) {
- shared_ptr<VideoContent> v = dynamic_pointer_cast<VideoContent> (c);
- if (v) {
- BOOST_FOREACH (DCPTime t, v->reel_split_points()) {
+ 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 = v;
+ last_video = c;
}
}
projects / dcpomatic.git / blobdiff