#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::ArrayData;
using dcp::Data;
using dcp::raw_convert;
using namespace dcpomatic;
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());
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;
}
void
-ReelWriter::write (optional<Data> encoded, Frame frame, Eyes eyes)
+ReelWriter::write (shared_ptr<const Data> encoded, Frame frame, Eyes eyes)
{
if (!_picture_asset_writer) {
/* We're not writing any data */
return;
}
- dcp::FrameInfo fin = _picture_asset_writer->write (encoded->data().get (), encoded->size());
+ dcp::FrameInfo fin = _picture_asset_writer->write (encoded->data(), encoded->size());
write_frame_info (frame, eyes, fin);
_last_written[eyes] = encoded;
}
+
+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 (int size)
{
}
dcp::FrameInfo fin = _picture_asset_writer->write (
- _last_written[eyes]->data().get(),
+ _last_written[eyes]->data(),
_last_written[eyes]->size()
);
write_frame_info (frame, eyes, fin);
_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)) {
}
reel->add (reel_sound_asset);
- maybe_add_text<dcp::ReelSubtitleAsset> (_subtitle_asset, reel_picture_asset->actual_duration(), reel, refs, fonts, _film, _period);
+ shared_ptr<dcp::ReelSubtitleAsset> subtitle = maybe_add_text<dcp::ReelSubtitleAsset> (_subtitle_asset, reel_picture_asset->actual_duration(), reel, refs, fonts, _film, _period);
+ if (subtitle && !_film->subtitle_languages().empty()) {
+ subtitle->set_language (_film->subtitle_languages().front());
+ }
+
for (map<DCPTextTrack, shared_ptr<dcp::SubtitleAsset> >::const_iterator i = _closed_caption_assets.begin(); i != _closed_caption_assets.end(); ++i) {
shared_ptr<dcp::ReelClosedCaptionAsset> a = maybe_add_text<dcp::ReelClosedCaptionAsset> (
i->second, reel_picture_asset->actual_duration(), reel, refs, fonts, _film, _period
);
- a->set_annotation_text (i->first.name);
- a->set_language (i->first.language);
+ if (a) {
+ a->set_annotation_text (i->first.name);
+ a->set_language (dcp::LanguageTag(i->first.language));
+ }
}
- map<dcp::Marker, DCPTime> markers = _film->markers ();
- map<dcp::Marker, DCPTime> reel_markers;
- for (map<dcp::Marker, DCPTime>::const_iterator i = markers.begin(); i != markers.end(); ++i) {
+ Film::Markers markers = _film->markers ();
+ _film->add_ffoc_lfoc (markers);
+ Film::Markers reel_markers;
+ for (Film::Markers::const_iterator i = markers.begin(); i != markers.end(); ++i) {
if (_period.contains(i->second)) {
reel_markers[i->first] = i->second;
}
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
}
if (!asset) {
- string lang = _film->subtitle_language ();
+ vector<dcp::LanguageTag> lang = _film->subtitle_languages ();
if (_film->interop ()) {
shared_ptr<dcp::InteropSubtitleAsset> s (new dcp::InteropSubtitleAsset ());
s->set_movie_title (_film->name ());
if (type == TEXT_OPEN_SUBTITLE) {
- s->set_language (lang.empty() ? "Unknown" : lang);
+ s->set_language (lang.empty() ? "Unknown" : lang.front().to_string());
} else {
s->set_language (track->language);
}
s->set_content_title_text (_film->name ());
s->set_metadata (mxf_metadata());
if (type == TEXT_OPEN_SUBTITLE && !lang.empty()) {
- s->set_language (lang);
+ s->set_language (lang.front());
} else {
- s->set_language (track->language);
+ s->set_language (dcp::LanguageTag(track->language));
}
s->set_edit_rate (dcp::Fraction (_film->video_frame_rate (), 1));
s->set_reel_number (_reel_index + 1);
/* Read the data from the asset and hash it */
dcpomatic_fseek (asset_file, info.offset, SEEK_SET);
- Data data (info.size);
- size_t const read = fread (data.data().get(), 1, data.size(), asset_file);
+ ArrayData data (info.size);
+ size_t const read = fread (data.data(), 1, data.size(), asset_file);
LOG_GENERAL ("Read %1 bytes of asset data; wanted %2", read, info.size);
if (read != static_cast<size_t> (data.size ())) {
LOG_GENERAL ("Existing frame %1 is incomplete", frame);
ok = false;
} else {
Digester digester;
- digester.add (data.data().get(), data.size());
+ digester.add (data.data(), data.size());
LOG_GENERAL ("Hash %1 vs %2", digester.get(), info.hash);
if (digester.get() != info.hash) {
LOG_GENERAL ("Existing frame %1 failed hash check", frame);
projects / dcpomatic.git / blobdiff