/*
- Copyright (C) 2012-2019 Carl Hetherington <cth@carlh.net>
+ Copyright (C) 2012-2020 Carl Hetherington <cth@carlh.net>
This file is part of DCP-o-matic.
#include "digester.h"
#include "font.h"
#include "compose.hpp"
+#include "config.h"
#include "audio_buffers.h"
#include "image.h"
+#include <dcp/atmos_asset.h>
+#include <dcp/atmos_asset_writer.h>
#include <dcp/mono_picture_asset.h>
#include <dcp/stereo_picture_asset.h>
#include <dcp/sound_asset.h>
#include <dcp/sound_asset_writer.h>
#include <dcp/reel.h>
+#include <dcp/reel_atmos_asset.h>
#include <dcp/reel_mono_picture_asset.h>
#include <dcp/reel_stereo_picture_asset.h>
#include <dcp/reel_sound_asset.h>
using std::cout;
using std::exception;
using std::map;
+using std::vector;
using boost::shared_ptr;
using boost::optional;
using boost::dynamic_pointer_cast;
+#if BOOST_VERSION >= 106100
+using namespace boost::placeholders;
+#endif
using dcp::Data;
using dcp::raw_convert;
using namespace dcpomatic;
int const ReelWriter::_info_size = 48;
+static dcp::MXFMetadata
+mxf_metadata ()
+{
+ dcp::MXFMetadata meta;
+ Config* config = Config::instance();
+ if (!config->dcp_company_name().empty()) {
+ meta.company_name = config->dcp_company_name ();
+ }
+ if (!config->dcp_product_name().empty()) {
+ meta.product_name = config->dcp_product_name ();
+ }
+ if (!config->dcp_product_version().empty()) {
+ meta.product_version = config->dcp_product_version ();
+ }
+ return meta;
+}
+
/** @param job Related job, or 0 */
ReelWriter::ReelWriter (
shared_ptr<const Film> film, DCPTimePeriod period, shared_ptr<Job> job, int reel_index, int reel_count, optional<string> content_summary
)
: _film (film)
, _period (period)
- , _last_written_video_frame (-1)
- , _last_written_eyes (EYES_RIGHT)
, _reel_index (reel_index)
, _reel_count (reel_count)
, _content_summary (content_summary)
}
_picture_asset->set_size (_film->frame_size());
+ _picture_asset->set_metadata (mxf_metadata());
if (_film->encrypted ()) {
_picture_asset->set_key (_film->key());
if (_film->audio_channels ()) {
_sound_asset.reset (
- new dcp::SoundAsset (dcp::Fraction (_film->video_frame_rate(), 1), _film->audio_frame_rate (), _film->audio_channels (), standard)
+ new dcp::SoundAsset (dcp::Fraction(_film->video_frame_rate(), 1), _film->audio_frame_rate(), _film->audio_channels(), _film->audio_language(), standard)
);
+ _sound_asset->set_metadata (mxf_metadata());
+
if (_film->encrypted ()) {
_sound_asset->set_key (_film->key ());
}
DCPOMATIC_ASSERT (_film->directory());
+ vector<dcp::Channel> active;
+ BOOST_FOREACH (int i, _film->mapped_audio_channels()) {
+ active.push_back (static_cast<dcp::Channel>(i));
+ }
+
/* Write the sound asset 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 (
- _film->directory().get() / audio_asset_filename (_sound_asset, _reel_index, _reel_count, _content_summary)
+ _film->directory().get() / audio_asset_filename (_sound_asset, _reel_index, _reel_count, _content_summary),
+ active,
+ _film->contains_atmos_content()
);
}
}
try {
info_file = _film->info_file_handle (_period, true);
- } catch (OpenFileError) {
+ } catch (OpenFileError &) {
LOG_GENERAL_NC ("Could not open film info file");
fclose (asset_file);
return 0;
dcp::FrameInfo fin = _picture_asset_writer->write (encoded->data().get (), encoded->size());
write_frame_info (frame, eyes, fin);
_last_written[eyes] = encoded;
- _last_written_video_frame = frame;
- _last_written_eyes = eyes;
}
+
+void
+ReelWriter::write (shared_ptr<const dcp::AtmosFrame> atmos, AtmosMetadata metadata)
+{
+ if (!_atmos_asset) {
+ _atmos_asset = metadata.create (dcp::Fraction(_film->video_frame_rate(), 1));
+ if (_film->encrypted()) {
+ _atmos_asset->set_key(_film->key());
+ }
+ _atmos_asset_writer = _atmos_asset->start_write (
+ _film->directory().get() / atmos_asset_filename (_atmos_asset, _reel_index, _reel_count, _content_summary)
+ );
+ }
+ _atmos_asset_writer->write (atmos);
+}
+
+
void
-ReelWriter::fake_write (Frame frame, Eyes eyes, int size)
+ReelWriter::fake_write (int size)
{
if (!_picture_asset_writer) {
/* We're not writing any data */
}
_picture_asset_writer->fake_write (size);
- _last_written_video_frame = frame;
- _last_written_eyes = eyes;
}
void
_last_written[eyes]->size()
);
write_frame_info (frame, eyes, fin);
- _last_written_video_frame = frame;
- _last_written_eyes = eyes;
}
void
_sound_asset->set_file (audio_to);
}
+
+ if (_atmos_asset) {
+ _atmos_asset_writer->finalize ();
+ boost::filesystem::path atmos_to;
+ atmos_to /= _film->dir (_film->dcp_name());
+ string const aaf = atmos_asset_filename (_atmos_asset, _reel_index, _reel_count, _content_summary);
+ atmos_to /= aaf;
+
+ boost::system::error_code ec;
+ boost::filesystem::rename (_film->file(aaf), atmos_to, ec);
+ if (ec) {
+ throw FileError (
+ String::compose (_("could not move atmos asset into the DCP (%1)"), ec.value ()), aaf
+ );
+ }
+
+ _atmos_asset->set_file (atmos_to);
+ }
}
template <class T>
shared_ptr<T> reel_asset;
if (asset) {
- boost::filesystem::path liberation_normal;
- try {
- liberation_normal = shared_path() / "LiberationSans-Regular.ttf";
- if (!boost::filesystem::exists (liberation_normal)) {
- /* Hack for unit tests */
- liberation_normal = shared_path() / "fonts" / "LiberationSans-Regular.ttf";
- }
- } catch (boost::filesystem::filesystem_error& e) {
-
- }
-
- if (!boost::filesystem::exists(liberation_normal)) {
- liberation_normal = "/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf";
- }
-
/* Add the font to the subtitle content */
BOOST_FOREACH (shared_ptr<Font> j, fonts) {
- asset->add_font (j->id(), j->file().get_value_or(liberation_normal));
+ asset->add_font (j->id(), j->file().get_value_or(default_font_file()));
}
if (dynamic_pointer_cast<dcp::InteropSubtitleAsset> (asset)) {
/* We have made a sound asset of our own. Put it into the reel */
reel_sound_asset.reset (new dcp::ReelSoundAsset (_sound_asset, 0));
} else {
+ LOG_GENERAL ("no sound asset of our own; look through %1", refs.size());
/* We don't have a sound asset of our own; hopefully we have one to reference */
BOOST_FOREACH (ReferencedReelAsset j, refs) {
shared_ptr<dcp::ReelSoundAsset> k = dynamic_pointer_cast<dcp::ReelSoundAsset> (j.asset);
+ if (k) {
+ LOG_GENERAL ("candidate sound asset period is %1-%2", j.period.from.get(), j.period.to.get());
+ }
if (k && j.period == _period) {
reel_sound_asset = k;
/* If we have a hash for this asset in the CPL, assume that it is correct */
reel->add (ma);
}
+ if (_atmos_asset) {
+ reel->add (shared_ptr<dcp::ReelAtmosAsset>(new dcp::ReelAtmosAsset(_atmos_asset, 0)));
+ }
+
return reel;
}
if (_sound_asset) {
_sound_asset->hash (set_progress);
}
+
+ if (_atmos_asset) {
+ _atmos_asset->hash (set_progress);
+ }
}
Frame
} else {
shared_ptr<dcp::SMPTESubtitleAsset> s (new dcp::SMPTESubtitleAsset ());
s->set_content_title_text (_film->name ());
+ s->set_metadata (mxf_metadata());
if (type == TEXT_OPEN_SUBTITLE && !lang.empty()) {
s->set_language (lang);
} else {