/*
- 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
it under the terms of the GNU General Public License as published by
#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>
*
* 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
*/
-int const Film::current_state_version = 32;
+int const Film::current_state_version = 33;
/** Construct a Film object in a given directory.
*
, _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)
{
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 ()
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());
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) */
if (!dm.audio_language.empty ()) {
d << "_" << dm.audio_language;
if (!dm.subtitle_language.empty()) {
- d << "-" << dm.subtitle_language;
+
+ bool burnt_in = false;
+ BOOST_FOREACH (shared_ptr<Content> i, content ()) {
+ shared_ptr<SubtitleContent> sc = dynamic_pointer_cast<SubtitleContent> (i);
+ if (!sc) {
+ continue;
+ }
+
+ if (sc->use_subtitles() && sc->burn_subtitles()) {
+ burnt_in = true;
+ }
+ }
+
+ string language = dm.subtitle_language;
+ if (burnt_in) {
+ transform (language.begin(), language.end(), language.begin(), ::tolower);
+ } else {
+ transform (language.begin(), language.end(), language.begin(), ::toupper);
+ }
+
+ d << "-" << language;
} else {
d << "-XX";
}
signal_changed (REEL_TYPE);
}
+/** @param r Desired reel length in bytes */
void
Film::set_reel_length (int64_t 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)
{
set_video_frame_rate (_playlist->best_dcp_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";
}
}
add_content (content);
- if (Config::instance()->automatic_audio_analysis ()) {
+ if (Config::instance()->automatic_audio_analysis() && dynamic_pointer_cast<AudioContent> (content)) {
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 */
+ /* Add {video,subtitle} content after any existing {video,subtitle} content */
if (dynamic_pointer_cast<VideoContent> (c)) {
c->set_position (_playlist->video_end ());
+ } else if (dynamic_pointer_cast<SubtitleContent> (c)) {
+ c->set_position (_playlist->subtitle_end ());
}
_playlist->add (c);
signal_changed (NAME);
}
+void
+Film::playlist_order_changed ()
+{
+ signal_changed (CONTENT_ORDER);
+}
+
int
Film::audio_frame_rate () const
{
}
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,
return dcp::DecryptedKDM (
cpl, key(), from, until, "DCP-o-matic", cpl->content_title_text(), dcp::LocalTime().as_string()
- ).encrypt (signer, target, formulation);
+ ).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
{
list<ScreenKDM> kdms;
BOOST_FOREACH (shared_ptr<Screen> i, screens) {
- if (i->certificate) {
- kdms.push_back (ScreenKDM (i, make_kdm (i->certificate.get(), dcp, from, until, formulation)));
+ 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.
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 ());
}
Film::reels () const
{
list<DCPTimePeriod> p;
- DCPTime const len = length ();
+ DCPTime const len = length().round_up (video_frame_rate ());
switch (reel_type ()) {
case REELTYPE_SINGLE:
projects / dcpomatic.git / blobdiff