per second.
*/
- std::shared_ptr<dcp::MonoPictureAsset> picture_asset (new dcp::MonoPictureAsset (dcp::Fraction (24, 1), dcp::SMPTE));
+ auto picture_asset = std::make_shared<dcp::MonoPictureAsset>(dcp::Fraction (24, 1), dcp::Standard::SMPTE);
/* Start off a write to it */
- std::shared_ptr<dcp::PictureAssetWriter> picture_writer = picture_asset->start_write ("DCP/picture.mxf", false);
+ auto picture_writer = picture_asset->start_write("DCP/picture.mxf", false);
/* Write 24 frames of the same JPEG2000 file */
- dcp::ArrayData picture ("examples/help.j2c");
+ dcp::ArrayData picture("examples/help.j2c");
for (int i = 0; i < 24; ++i) {
picture_writer->write (picture.data(), picture.size());
}
/* And finish off */
- picture_writer->finalize ();
+ picture_writer->finalize();
/* Now create a sound MXF. As before, create an object and a writer.
When creating the object we specify the sampling rate (48kHz) and the number of channels (2).
*/
- std::shared_ptr<dcp::SoundAsset> sound_asset (new dcp::SoundAsset(dcp::Fraction(24, 1), 48000, 2, dcp::LanguageTag("en-GB"), dcp::SMPTE));
+ auto sound_asset = std::make_shared<dcp::SoundAsset>(dcp::Fraction(24, 1), 48000, 2, dcp::LanguageTag("en-GB"), dcp::Standard::SMPTE);
/* Here we must also say which of our channels will have "real" sound data in them */
std::vector<dcp::Channel> active_channels;
- active_channels.push_back (dcp::LEFT);
- active_channels.push_back (dcp::RIGHT);
- std::shared_ptr<dcp::SoundAssetWriter> sound_writer = sound_asset->start_write ("DCP/sound.mxf", active_channels);
+ active_channels.push_back(dcp::Channel::LEFT);
+ active_channels.push_back(dcp::Channel::RIGHT);
+ auto sound_writer = sound_asset->start_write("DCP/sound.mxf", active_channels);
/* Write some sine waves */
float* audio[2];
/* Add picture and sound to it. The zeros are the `entry points', i.e. the first
(video) frame from the assets that the reel should play.
*/
- reel->add (std::shared_ptr<dcp::ReelPictureAsset> (new dcp::ReelMonoPictureAsset (picture_asset, 0)));
- reel->add (std::shared_ptr<dcp::ReelSoundAsset> (new dcp::ReelSoundAsset (sound_asset, 0)));
+ reel->add (std::make_shared<dcp::ReelMonoPictureAsset>(picture_asset, 0));
+ reel->add (std::make_shared<dcp::ReelSoundAsset>(sound_asset, 0));
/* Make a CPL with this reel */
- std::shared_ptr<dcp::CPL> cpl (new dcp::CPL ("My film", dcp::FEATURE));
+ auto cpl = std::make_shared<dcp::CPL>("My film", dcp::ContentKind::FEATURE);
cpl->add (reel);
/* Write the DCP */
dcp::DCP dcp ("DCP");
dcp.add (cpl);
- dcp.write_xml (dcp::SMPTE);
+ dcp.write_xml (dcp::Standard::SMPTE);
return 0;
}
Asset::equals (std::shared_ptr<const Asset> other, EqualityOptions, NoteHandler note) const
{
if (_hash != other->_hash) {
- note (DCP_ERROR, "Asset: hashes differ");
+ note (NoteType::ERROR, "Asset: hashes differ");
return false;
}
using std::string;
using std::shared_ptr;
+using std::make_shared;
using namespace dcp;
AtmosAsset::AtmosAsset (Fraction edit_rate, int first_frame, int max_channel_count, int max_object_count, int atmos_version)
- : MXF (SMPTE)
+ : MXF (Standard::SMPTE)
, _edit_rate (edit_rate)
, _intrinsic_duration (0)
, _first_frame (first_frame)
AtmosAsset::AtmosAsset (boost::filesystem::path file)
: Asset (file)
- , MXF (SMPTE)
+ , MXF (Standard::SMPTE)
{
ASDCP::ATMOS::MXFReader reader;
Kumu::Result_t r = reader.OpenRead (file.string().c_str());
shared_ptr<AtmosAssetReader>
AtmosAsset::start_read () const
{
- return shared_ptr<AtmosAssetReader> (new AtmosAssetReader (this, key(), SMPTE));
+ return make_shared<AtmosAssetReader>(this, key(), Standard::SMPTE);
}
shared_ptr<AtmosAssetWriter>
xmlpp::Element* signed_info = signature->add_child ("SignedInfo", "dsig");
signed_info->add_child("CanonicalizationMethod", "dsig")->set_attribute ("Algorithm", "http://www.w3.org/TR/2001/REC-xml-c14n-20010315");
- if (standard == INTEROP) {
+ if (standard == Standard::INTEROP) {
signed_info->add_child("SignatureMethod", "dsig")->set_attribute("Algorithm", "http://www.w3.org/2000/09/xmldsig#rsa-sha1");
} else {
signed_info->add_child("SignatureMethod", "dsig")->set_attribute("Algorithm", "http://www.w3.org/2001/04/xmldsig-more#rsa-sha256");
/** Construct a CPL object from a XML file */
CPL::CPL (boost::filesystem::path file)
: Asset (file)
- , _content_kind (FEATURE)
+ , _content_kind (ContentKind::FEATURE)
{
cxml::Document f ("CompositionPlaylist");
f.read_file (file);
if (f.namespace_uri() == cpl_interop_ns) {
- _standard = INTEROP;
+ _standard = Standard::INTEROP;
} else if (f.namespace_uri() == cpl_smpte_ns) {
- _standard = SMPTE;
+ _standard = Standard::SMPTE;
} else {
boost::throw_exception (XMLError ("Unrecognised CPL namespace " + f.namespace_uri()));
}
)
);
content_version->done ();
- } else if (_standard == SMPTE) {
+ } else if (_standard == Standard::SMPTE) {
/* ContentVersion is required in SMPTE */
throw XMLError ("Missing ContentVersion tag in CPL");
}
{
xmlpp::Document doc;
xmlpp::Element* root;
- if (standard == INTEROP) {
+ if (standard == Standard::INTEROP) {
root = doc.create_root_node ("CompositionPlaylist", cpl_interop_ns);
} else {
root = doc.create_root_node ("CompositionPlaylist", cpl_smpte_ns);
bool first = true;
for (auto i: _reels) {
auto asset_list = i->write_to_cpl (reel_list, standard);
- if (first && standard == dcp::SMPTE) {
+ if (first && standard == Standard::SMPTE) {
maybe_write_composition_metadata_asset (asset_list);
first = false;
}
if (_annotation_text != other_cpl->_annotation_text && !opt.cpl_annotation_texts_can_differ) {
string const s = "CPL: annotation texts differ: " + _annotation_text.get_value_or("") + " vs " + other_cpl->_annotation_text.get_value_or("") + "\n";
- note (DCP_ERROR, s);
+ note (NoteType::ERROR, s);
return false;
}
if (_content_kind != other_cpl->_content_kind) {
- note (DCP_ERROR, "CPL: content kinds differ");
+ note (NoteType::ERROR, "CPL: content kinds differ");
return false;
}
if (_reels.size() != other_cpl->_reels.size()) {
- note (DCP_ERROR, String::compose ("CPL: reel counts differ (%1 vs %2)", _reels.size(), other_cpl->_reels.size()));
+ note (NoteType::ERROR, String::compose ("CPL: reel counts differ (%1 vs %2)", _reels.size(), other_cpl->_reels.size()));
return false;
}
CPL::static_pkl_type (Standard standard)
{
switch (standard) {
- case INTEROP:
+ case Standard::INTEROP:
return "text/xml;asdcpKind=CPL";
- case SMPTE:
+ case Standard::SMPTE:
return "text/xml";
default:
DCP_ASSERT (false);
_hmac = new ASDCP::HMACContext;
ASDCP::LabelSet_t type;
- if (standard == INTEROP) {
+ if (standard == Standard::INTEROP) {
type = ASDCP::LS_MXF_INTEROP;
} else {
type = ASDCP::LS_MXF_SMPTE;
asset_map.read_file (_asset_map.get());
if (asset_map.namespace_uri() == assetmap_interop_ns) {
- _standard = INTEROP;
+ _standard = Standard::INTEROP;
} else if (asset_map.namespace_uri() == assetmap_smpte_ns) {
- _standard = SMPTE;
+ _standard = Standard::SMPTE;
} else {
boost::throw_exception (XMLError ("Unrecognised Assetmap namespace " + asset_map.namespace_uri()));
}
p = p.substr (7);
}
switch (*_standard) {
- case INTEROP:
+ case Standard::INTEROP:
if (i->optional_node_child("PackingList")) {
pkl_paths.push_back (p);
} else {
paths.insert (make_pair (remove_urn_uuid (i->string_child ("Id")), p));
}
break;
- case SMPTE:
+ case Standard::SMPTE:
{
auto pkl_bool = i->optional_string_child("PackingList");
if (pkl_bool && *pkl_bool == "true") {
}
_cpls.push_back (cpl);
} else if (root == "DCSubtitle") {
- if (_standard && _standard.get() == SMPTE && notes) {
+ if (_standard && _standard.get() == Standard::SMPTE && notes) {
notes->push_back (VerificationNote(VerificationNote::VERIFY_ERROR, VerificationNote::MISMATCHED_STANDARD));
}
other_assets.push_back (make_shared<InteropSubtitleAsset>(path));
auto b = other.cpls ();
if (a.size() != b.size()) {
- note (DCP_ERROR, String::compose ("CPL counts differ: %1 vs %2", a.size(), b.size()));
+ note (NoteType::ERROR, String::compose ("CPL counts differ: %1 vs %2", a.size(), b.size()));
return false;
}
void
DCP::write_volindex (Standard standard) const
{
- boost::filesystem::path p = _directory;
+ auto p = _directory;
switch (standard) {
- case INTEROP:
+ case Standard::INTEROP:
p /= "VOLINDEX";
break;
- case SMPTE:
+ case Standard::SMPTE:
p /= "VOLINDEX.xml";
break;
default:
xmlpp::Element* root;
switch (standard) {
- case INTEROP:
+ case Standard::INTEROP:
root = doc.create_root_node ("VolumeIndex", volindex_interop_ns);
break;
- case SMPTE:
+ case Standard::SMPTE:
root = doc.create_root_node ("VolumeIndex", volindex_smpte_ns);
break;
default:
auto p = _directory;
switch (standard) {
- case INTEROP:
+ case Standard::INTEROP:
p /= "ASSETMAP";
break;
- case SMPTE:
+ case Standard::SMPTE:
p /= "ASSETMAP.xml";
break;
default:
xmlpp::Element* root;
switch (standard) {
- case INTEROP:
+ case Standard::INTEROP:
root = doc.create_root_node ("AssetMap", assetmap_interop_ns);
break;
- case SMPTE:
+ case Standard::SMPTE:
root = doc.create_root_node ("AssetMap", assetmap_smpte_ns);
break;
default:
root->add_child("AnnotationText")->add_child_text (annotation_text);
switch (standard) {
- case INTEROP:
+ case Standard::INTEROP:
root->add_child("VolumeCount")->add_child_text ("1");
root->add_child("IssueDate")->add_child_text (issue_date);
root->add_child("Issuer")->add_child_text (issuer);
root->add_child("Creator")->add_child_text (creator);
break;
- case SMPTE:
+ case Standard::SMPTE:
root->add_child("Creator")->add_child_text (creator);
root->add_child("VolumeCount")->add_child_text ("1");
root->add_child("IssueDate")->add_child_text (issue_date);
{
char buffer[64];
- if (standard == SMPTE) {
+ if (standard == Standard::SMPTE) {
snprintf (buffer, sizeof(buffer), "%02d:%02d:%02d:%02d", h, m, s, e);
} else {
snprintf (buffer, sizeof(buffer), "%02d:%02d:%02d:%03d", h, m, s, e);
/* 93 is not-valid-after (a string) [25 bytes] */
p += 25;
/* 118 is the key [ASDCP::KeyLen bytes] */
- add_key (optional<string>(), key_id, Key (p), cpl_id, INTEROP);
+ add_key (optional<string>(), key_id, Key(p), cpl_id, Standard::INTEROP);
break;
}
case 138:
/* 97 is not-valid-after (a string) [25 bytes] */
p += 25;
/* 112 is the key [ASDCP::KeyLen bytes] */
- add_key (key_type, key_id, Key (p), cpl_id, SMPTE);
+ add_key (key_type, key_id, Key(p), cpl_id, Standard::SMPTE);
break;
}
default:
, _issue_date (issue_date)
{
for (map<shared_ptr<const ReelMXF>, Key>::const_iterator i = keys.begin(); i != keys.end(); ++i) {
- add_key (i->first->key_type(), i->first->key_id().get(), i->second, cpl_id, SMPTE);
+ add_key (i->first->key_type(), i->first->key_id().get(), i->second, cpl_id, Standard::SMPTE);
}
}
{
/* Create DecryptedKDMKey objects for each encryptable asset */
bool did_one = false;
- BOOST_FOREACH(shared_ptr<const ReelMXF> i, cpl->reel_mxfs()) {
+ for (auto i: cpl->reel_mxfs()) {
if (i->key_id()) {
- add_key (i->key_type(), i->key_id().get(), key, cpl->id(), SMPTE);
+ add_key (i->key_type(), i->key_id().get(), key, cpl->id(), Standard::SMPTE);
did_one = true;
}
}
kre.recipient.x509_issuer_serial.x509_serial_number = recipient.serial ();
kre.recipient.x509_subject_name = recipient.subject ();
kre.composition_playlist_id = cpl_id;
- if (formulation == DCI_ANY || formulation == DCI_SPECIFIC) {
+ if (formulation == Formulation::DCI_ANY || formulation == Formulation::DCI_SPECIFIC) {
kre.content_authenticator = signer->leaf().thumbprint ();
}
kre.content_title_text = content_title_text;
kre.disable_forensic_marking_picture = disable_forensic_marking_picture;
kre.disable_forensic_marking_audio = disable_forensic_marking_audio;
- if (formulation != MODIFIED_TRANSITIONAL_TEST) {
+ if (formulation != Formulation::MODIFIED_TRANSITIONAL_TEST) {
kre.authorized_device_info = data::AuthorizedDeviceInfo ();
kre.authorized_device_info->device_list_identifier = make_uuid ();
auto n = recipient.subject_common_name ();
}
kre.authorized_device_info->device_list_description = n;
- if (formulation == MODIFIED_TRANSITIONAL_1 || formulation == DCI_ANY) {
+ if (formulation == Formulation::MODIFIED_TRANSITIONAL_1 || formulation == Formulation::DCI_ANY) {
/* Use the "assume trust" thumbprint */
kre.authorized_device_info->certificate_thumbprints.push_back ("2jmj7l5rSw0yVb/vlWAYkK/YBwk=");
- } else if (formulation == MULTIPLE_MODIFIED_TRANSITIONAL_1 || formulation == DCI_SPECIFIC) {
+ } else if (formulation == Formulation::MULTIPLE_MODIFIED_TRANSITIONAL_1 || formulation == Formulation::DCI_SPECIFIC) {
if (trusted_devices.empty ()) {
/* Fall back on the "assume trust" thumbprint so we
can generate "modified-transitional-1" KDMs
for (xmlpp::Node::NodeList::const_iterator i = c.begin(); i != c.end(); ++i) {
xmlpp::Element const * e = dynamic_cast<xmlpp::Element const *> (*i);
if (e && (e->get_name() == "Font" || e->get_name() == "Subtitle")) {
- parse_subtitles (e, ps, optional<int>(), INTEROP);
+ parse_subtitles (e, ps, optional<int>(), Standard::INTEROP);
}
}
load_font->set_attribute ("URI", i->uri);
}
- subtitles_as_xml (root, 250, INTEROP);
+ subtitles_as_xml (root, 250, Standard::INTEROP);
return doc.write_to_string ("UTF-8");
}
while (i != _load_font_nodes.end ()) {
if (j == other->_load_font_nodes.end ()) {
- note (DCP_ERROR, "<LoadFont> nodes differ");
+ note (NoteType::ERROR, "<LoadFont> nodes differ");
return false;
}
if (**i != **j) {
- note (DCP_ERROR, "<LoadFont> nodes differ");
+ note (NoteType::ERROR, "<LoadFont> nodes differ");
return false;
}
}
if (_movie_title != other->_movie_title) {
- note (DCP_ERROR, "Subtitle movie titles differ");
+ note (NoteType::ERROR, "Subtitle movie titles differ");
return false;
}
#pragma omp critical
#endif
{
- note (DCP_PROGRESS, String::compose ("Compared video frame %1 of %2", i, _intrinsic_duration));
+ note (NoteType::PROGRESS, String::compose("Compared video frame %1 of %2", i, _intrinsic_duration));
for (list<pair<NoteType, string> >::const_iterator i = notes.begin(); i != notes.end(); ++i) {
note (i->first, i->second);
}
writer_info->ProductName = _metadata.product_name;
DCP_ASSERT (_standard);
- if (_standard == INTEROP) {
+ if (_standard == Standard::INTEROP) {
writer_info->LabelSetType = ASDCP::LS_MXF_INTEROP;
} else {
writer_info->LabelSetType = ASDCP::LS_MXF_SMPTE;
switch (info.LabelSetType) {
case ASDCP::LS_MXF_INTEROP:
- _standard = INTEROP;
+ _standard = Standard::INTEROP;
break;
case ASDCP::LS_MXF_SMPTE:
- _standard = SMPTE;
+ _standard = Standard::SMPTE;
break;
default:
throw ReadError ("Unrecognised label set type in MXF");
// a.QuantizationDefault != b.QuantizationDefault
) {
- note (DCP_ERROR, "video MXF picture descriptors differ");
+ note (NoteType::ERROR, "video MXF picture descriptors differ");
return false;
}
if (a.ContainerDuration != b.ContainerDuration) {
- note (DCP_ERROR, "video container durations differ");
+ note (NoteType::ERROR, "video container durations differ");
}
// for (unsigned int j = 0; j < ASDCP::JP2K::MaxComponents; ++j) {
) const
{
if (size_A == size_B && memcmp (data_A, data_B, size_A) == 0) {
- note (DCP_NOTE, "J2K identical");
+ note (NoteType::NOTE, "J2K identical");
/* Easy result; the J2K data is identical */
return true;
}
for (int c = 0; c < 3; ++c) {
if (image_A->size() != image_B->size()) {
- note (DCP_ERROR, String::compose ("image sizes for frame %1 differ", frame));
+ note (NoteType::ERROR, String::compose ("image sizes for frame %1 differ", frame));
return false;
}
double const std_dev = sqrt (double (total_squared_deviation) / abs_diffs.size());
- note (DCP_NOTE, String::compose ("mean difference %1 deviation %2", mean, std_dev));
+ note (NoteType::NOTE, String::compose("mean difference %1 deviation %2", mean, std_dev));
if (mean > opt.max_mean_pixel_error) {
note (
- DCP_ERROR,
+ NoteType::ERROR,
String::compose ("mean %1 out of range %2 in frame %3", mean, opt.max_mean_pixel_error, frame)
);
if (std_dev > opt.max_std_dev_pixel_error) {
note (
- DCP_ERROR,
+ NoteType::ERROR,
String::compose ("standard deviation %1 out of range %2 in frame %3", std_dev, opt.max_std_dev_pixel_error, frame)
);
PictureAsset::static_pkl_type (Standard standard)
{
switch (standard) {
- case INTEROP:
+ case Standard::INTEROP:
return "application/x-smpte-mxf;asdcpKind=Picture";
- case SMPTE:
+ case Standard::SMPTE:
return "application/mxf";
default:
DCP_ASSERT (false);
pkl.read_file (file);
if (pkl.namespace_uri() == pkl_interop_ns) {
- _standard = INTEROP;
+ _standard = Standard::INTEROP;
} else if (pkl.namespace_uri() == pkl_smpte_ns) {
- _standard = SMPTE;
+ _standard = Standard::SMPTE;
} else {
boost::throw_exception (XMLError ("Unrecognised packing list namesapce " + pkl.namespace_uri()));
}
{
xmlpp::Document doc;
xmlpp::Element* pkl;
- if (_standard == INTEROP) {
+ if (_standard == Standard::INTEROP) {
pkl = doc.create_root_node("PackingList", pkl_interop_ns);
} else {
pkl = doc.create_root_node("PackingList", pkl_smpte_ns);
Reel::equals (std::shared_ptr<const Reel> other, EqualityOptions opt, NoteHandler note) const
{
if ((_main_picture && !other->_main_picture) || (!_main_picture && other->_main_picture)) {
- note (DCP_ERROR, "Reel: picture assets differ");
+ note (NoteType::ERROR, "Reel: picture assets differ");
return false;
}
}
if ((_main_sound && !other->_main_sound) || (!_main_sound && other->_main_sound)) {
- note (DCP_ERROR, "Reel: sound assets differ");
+ note (NoteType::ERROR, "Reel: sound assets differ");
return false;
}
}
if ((_main_subtitle && !other->_main_subtitle) || (!_main_subtitle && other->_main_subtitle)) {
- note (DCP_ERROR, "Reel: subtitle assets differ");
+ note (NoteType::ERROR, "Reel: subtitle assets differ");
return false;
}
}
if ((_main_markers && !other->_main_markers) || (!_main_markers && other->_main_markers)) {
- note (DCP_ERROR, "Reel: one has markers and the other does not");
+ note (NoteType::ERROR, "Reel: one has markers and the other does not");
return false;
}
if (_main_markers && !_main_markers->equals(other->_main_markers, opt, note)) {
- note (DCP_ERROR, "Reel: marker assets differ");
+ note (NoteType::ERROR, "Reel: marker assets differ");
return false;
}
}
if ((_atmos && !other->_atmos) || (!_atmos && other->_atmos)) {
- note (DCP_ERROR, "Reel: atmos assets differ");
+ note (NoteType::ERROR, "Reel: atmos assets differ");
return false;
}
if (_annotation_text != other->_annotation_text) {
string const s = "Reel: annotation texts differ (" + _annotation_text + " vs " + other->_annotation_text + ")\n";
if (!opt.reel_annotation_texts_can_differ) {
- note (DCP_ERROR, s);
+ note (NoteType::ERROR, s);
return false;
} else {
- note (DCP_NOTE, s);
+ note (NoteType::NOTE, s);
}
}
if (_edit_rate != other->_edit_rate) {
- note (DCP_ERROR, "Reel: edit rates differ");
+ note (NoteType::ERROR, "Reel: edit rates differ");
return false;
}
if (_intrinsic_duration != other->_intrinsic_duration) {
- note (DCP_ERROR, String::compose ("Reel: intrinsic durations differ (%1 vs %2)", _intrinsic_duration, other->_intrinsic_duration));
+ note (NoteType::ERROR, String::compose ("Reel: intrinsic durations differ (%1 vs %2)", _intrinsic_duration, other->_intrinsic_duration));
return false;
}
if (_entry_point != other->_entry_point) {
- note (DCP_ERROR, "Reel: entry points differ");
+ note (NoteType::ERROR, "Reel: entry points differ");
return false;
}
if (_duration != other->_duration) {
- note (DCP_ERROR, "Reel: durations differ");
+ note (NoteType::ERROR, "Reel: durations differ");
return false;
}
ReelClosedCaptionAsset::cpl_node_name (Standard standard) const
{
switch (standard) {
- case INTEROP:
+ case Standard::INTEROP:
return "cc-cpl:MainClosedCaption";
- case SMPTE:
+ case Standard::SMPTE:
return "tt:ClosedCaption";
}
ReelClosedCaptionAsset::cpl_node_namespace (Standard standard) const
{
switch (standard) {
- case INTEROP:
+ case Standard::INTEROP:
return make_pair ("http://www.digicine.com/PROTO-ASDCP-CC-CPL-20070926#", "cc-cpl");
- case SMPTE:
+ case Standard::SMPTE:
return make_pair ("http://www.smpte-ra.org/schemas/429-12/2008/TT", "tt");
}
{
if (_hash != other->_hash) {
if (!opt.reel_hashes_can_differ) {
- note (DCP_ERROR, "Reel: hashes differ");
+ note (NoteType::ERROR, "Reel: hashes differ");
return false;
} else {
- note (DCP_NOTE, "Reel: hashes differ");
+ note (NoteType::NOTE, "Reel: hashes differ");
}
}
xmlpp::Node* asset = write_to_cpl_asset (node, standard, hash());
asset->add_child("FrameRate")->add_child_text(String::compose("%1 %2", _frame_rate.numerator, _frame_rate.denominator));
- if (standard == INTEROP) {
+ if (standard == Standard::INTEROP) {
/* Allowed values for this tag from the standard */
float allowed[] = { 1.33, 1.66, 1.77, 1.85, 2.00, 2.39 };
}
if (_frame_rate != rpa->_frame_rate) {
- note (DCP_ERROR, "frame rates differ in reel");
+ note (NoteType::ERROR, "frame rates differ in reel");
return false;
}
if (_screen_aspect_ratio != rpa->_screen_aspect_ratio) {
- note (DCP_ERROR, "screen aspect ratios differ in reel");
+ note (NoteType::ERROR, "screen aspect ratios differ in reel");
return false;
}
ReelStereoPictureAsset::cpl_node_attribute (Standard standard) const
{
switch (standard) {
- case INTEROP:
+ case Standard::INTEROP:
return make_pair ("xmlns:msp-cpl", "http://www.digicine.com/schemas/437-Y/2007/Main-Stereo-Picture-CPL");
- case SMPTE:
+ case Standard::SMPTE:
return make_pair ("xmlns:msp-cpl", "http://www.smpte-ra.org/schemas/429-10/2008/Main-Stereo-Picture-CPL");
}
if (cx < 0 || cx > 4095) {
if (note) {
- note.get() (DCP_NOTE, String::compose ("XYZ value %1 out of range", cx));
+ note.get()(NoteType::NOTE, String::compose("XYZ value %1 out of range", cx));
}
cx = max (min (cx, 4095), 0);
}
if (cy < 0 || cy > 4095) {
if (note) {
- note.get() (DCP_NOTE, String::compose ("XYZ value %1 out of range", cy));
+ note.get()(NoteType::NOTE, String::compose("XYZ value %1 out of range", cy));
}
cy = max (min (cy, 4095), 0);
}
if (cz < 0 || cz > 4095) {
if (note) {
- note.get() (DCP_NOTE, String::compose ("XYZ value %1 out of range", cz));
+ note.get()(NoteType::NOTE, String::compose("XYZ value %1 out of range", cz));
}
cz = max (min (cz, 4095), 0);
}
}
if (clamped && note) {
- note.get() (DCP_NOTE, String::compose ("%1 XYZ value(s) clamped", clamped));
+ note.get()(NoteType::NOTE, String::compose("%1 XYZ value(s) clamped", clamped));
}
return xyz;
using std::vector;
using std::map;
using std::shared_ptr;
+using std::dynamic_pointer_cast;
+using std::make_shared;
using boost::split;
using boost::is_any_of;
using boost::shared_array;
-using std::dynamic_pointer_cast;
using boost::optional;
using boost::starts_with;
using namespace dcp;
static string const subtitle_smpte_ns = "http://www.smpte-ra.org/schemas/428-7/2010/DCST";
SMPTESubtitleAsset::SMPTESubtitleAsset ()
- : MXF (SMPTE)
+ : MXF (Standard::SMPTE)
, _intrinsic_duration (0)
, _edit_rate (24, 1)
, _time_code_rate (24)
reader->ReadTimedTextResource (_raw_xml);
xml->read_string (_raw_xml);
parse_xml (xml);
- read_mxf_descriptor (reader, shared_ptr<DecryptionContext> (new DecryptionContext (optional<Key>(), SMPTE)));
+ read_mxf_descriptor (reader, shared_ptr<DecryptionContext> (new DecryptionContext (optional<Key>(), Standard::SMPTE)));
}
} else {
/* Plain XML */
}
}
}
- _standard = dcp::SMPTE;
+ _standard = Standard::SMPTE;
}
/* Check that all required image data have been found */
for (xmlpp::Node::NodeList::const_iterator i = c.begin(); i != c.end(); ++i) {
xmlpp::Element const * e = dynamic_cast<xmlpp::Element const *> (*i);
if (e && e->get_name() == "SubtitleList") {
- parse_subtitles (e, ps, _time_code_rate, SMPTE);
+ parse_subtitles (e, ps, _time_code_rate, Standard::SMPTE);
}
}
);
}
- shared_ptr<DecryptionContext> dec (new DecryptionContext (key, SMPTE));
+ auto dec = make_shared<DecryptionContext>(key, Standard::SMPTE);
reader->ReadTimedTextResource (_raw_xml, dec->context(), dec->hmac());
shared_ptr<cxml::Document> xml (new cxml::Document ("SubtitleReel"));
xml->read_string (_raw_xml);
root->add_child("EditRate", "dcst")->add_child_text (_edit_rate.as_string ());
root->add_child("TimeCodeRate", "dcst")->add_child_text (raw_convert<string> (_time_code_rate));
if (_start_time) {
- root->add_child("StartTime", "dcst")->add_child_text (_start_time.get().as_string (SMPTE));
+ root->add_child("StartTime", "dcst")->add_child_text(_start_time.get().as_string(Standard::SMPTE));
}
BOOST_FOREACH (shared_ptr<SMPTELoadFontNode> i, _load_font_nodes) {
load_font->set_attribute ("ID", i->id);
}
- subtitles_as_xml (root->add_child ("SubtitleList", "dcst"), _time_code_rate, SMPTE);
+ subtitles_as_xml (root->add_child("SubtitleList", "dcst"), _time_code_rate, Standard::SMPTE);
return doc.write_to_string ("UTF-8");
}
void
SMPTESubtitleAsset::write (boost::filesystem::path p) const
{
- EncryptionContext enc (key(), SMPTE);
+ EncryptionContext enc (key(), Standard::SMPTE);
ASDCP::WriterInfo writer_info;
fill_writer_info (&writer_info, _id);
shared_ptr<const SMPTESubtitleAsset> other = dynamic_pointer_cast<const SMPTESubtitleAsset> (other_asset);
if (!other) {
- note (DCP_ERROR, "Subtitles are in different standards");
+ note (NoteType::ERROR, "Subtitles are in different standards");
return false;
}
while (i != _load_font_nodes.end ()) {
if (j == other->_load_font_nodes.end ()) {
- note (DCP_ERROR, "<LoadFont> nodes differ");
+ note (NoteType::ERROR, "<LoadFont> nodes differ");
return false;
}
if ((*i)->id != (*j)->id) {
- note (DCP_ERROR, "<LoadFont> nodes differ");
+ note (NoteType::ERROR, "<LoadFont> nodes differ");
return false;
}
}
if (_content_title_text != other->_content_title_text) {
- note (DCP_ERROR, "Subtitle content title texts differ");
+ note (NoteType::ERROR, "Subtitle content title texts differ");
return false;
}
if (_language != other->_language) {
- note (DCP_ERROR, String::compose("Subtitle languages differ (`%1' vs `%2')", _language.get_value_or("[none]"), other->_language.get_value_or("[none]")));
+ note (NoteType::ERROR, String::compose("Subtitle languages differ (`%1' vs `%2')", _language.get_value_or("[none]"), other->_language.get_value_or("[none]")));
return false;
}
if (_annotation_text != other->_annotation_text) {
- note (DCP_ERROR, "Subtitle annotation texts differ");
+ note (NoteType::ERROR, "Subtitle annotation texts differ");
return false;
}
if (_issue_date != other->_issue_date) {
if (options.issue_dates_can_differ) {
- note (DCP_NOTE, "Subtitle issue dates differ");
+ note (NoteType::NOTE, "Subtitle issue dates differ");
} else {
- note (DCP_ERROR, "Subtitle issue dates differ");
+ note (NoteType::ERROR, "Subtitle issue dates differ");
return false;
}
}
if (_reel_number != other->_reel_number) {
- note (DCP_ERROR, "Subtitle reel numbers differ");
+ note (NoteType::ERROR, "Subtitle reel numbers differ");
return false;
}
if (_edit_rate != other->_edit_rate) {
- note (DCP_ERROR, "Subtitle edit rates differ");
+ note (NoteType::ERROR, "Subtitle edit rates differ");
return false;
}
if (_time_code_rate != other->_time_code_rate) {
- note (DCP_ERROR, "Subtitle time code rates differ");
+ note (NoteType::ERROR, "Subtitle time code rates differ");
return false;
}
if (_start_time != other->_start_time) {
- note (DCP_ERROR, "Subtitle start times differ");
+ note (NoteType::ERROR, "Subtitle start times differ");
return false;
}
if (desc_A.EditRate != desc_B.EditRate) {
note (
- DCP_ERROR,
+ NoteType::ERROR,
String::compose (
"audio edit rates differ: %1/%2 cf %3/%4",
desc_A.EditRate.Numerator, desc_A.EditRate.Denominator, desc_B.EditRate.Numerator, desc_B.EditRate.Denominator
return false;
} else if (desc_A.AudioSamplingRate != desc_B.AudioSamplingRate) {
note (
- DCP_ERROR,
+ NoteType::ERROR,
String::compose (
"audio sampling rates differ: %1 cf %2",
desc_A.AudioSamplingRate.Numerator, desc_A.AudioSamplingRate.Denominator,
);
return false;
} else if (desc_A.Locked != desc_B.Locked) {
- note (DCP_ERROR, String::compose ("audio locked flags differ: %1 cf %2", desc_A.Locked, desc_B.Locked));
+ note (NoteType::ERROR, String::compose ("audio locked flags differ: %1 cf %2", desc_A.Locked, desc_B.Locked));
return false;
} else if (desc_A.ChannelCount != desc_B.ChannelCount) {
- note (DCP_ERROR, String::compose ("audio channel counts differ: %1 cf %2", desc_A.ChannelCount, desc_B.ChannelCount));
+ note (NoteType::ERROR, String::compose ("audio channel counts differ: %1 cf %2", desc_A.ChannelCount, desc_B.ChannelCount));
return false;
} else if (desc_A.QuantizationBits != desc_B.QuantizationBits) {
- note (DCP_ERROR, String::compose ("audio bits per sample differ: %1 cf %2", desc_A.QuantizationBits, desc_B.QuantizationBits));
+ note (NoteType::ERROR, String::compose ("audio bits per sample differ: %1 cf %2", desc_A.QuantizationBits, desc_B.QuantizationBits));
return false;
} else if (desc_A.BlockAlign != desc_B.BlockAlign) {
- note (DCP_ERROR, String::compose ("audio bytes per sample differ: %1 cf %2", desc_A.BlockAlign, desc_B.BlockAlign));
+ note (NoteType::ERROR, String::compose ("audio bytes per sample differ: %1 cf %2", desc_A.BlockAlign, desc_B.BlockAlign));
return false;
} else if (desc_A.AvgBps != desc_B.AvgBps) {
- note (DCP_ERROR, String::compose ("audio average bps differ: %1 cf %2", desc_A.AvgBps, desc_B.AvgBps));
+ note (NoteType::ERROR, String::compose ("audio average bps differ: %1 cf %2", desc_A.AvgBps, desc_B.AvgBps));
return false;
} else if (desc_A.LinkedTrackID != desc_B.LinkedTrackID) {
- note (DCP_ERROR, String::compose ("audio linked track IDs differ: %1 cf %2", desc_A.LinkedTrackID, desc_B.LinkedTrackID));
+ note (NoteType::ERROR, String::compose ("audio linked track IDs differ: %1 cf %2", desc_A.LinkedTrackID, desc_B.LinkedTrackID));
return false;
} else if (desc_A.ContainerDuration != desc_B.ContainerDuration) {
- note (DCP_ERROR, String::compose ("audio container durations differ: %1 cf %2", desc_A.ContainerDuration, desc_B.ContainerDuration));
+ note (NoteType::ERROR, String::compose ("audio container durations differ: %1 cf %2", desc_A.ContainerDuration, desc_B.ContainerDuration));
return false;
} else if (desc_A.ChannelFormat != desc_B.ChannelFormat) {
/* XXX */
shared_ptr<const SoundFrame> frame_B = other_reader->get_frame (i);
if (frame_A->size() != frame_B->size()) {
- note (DCP_ERROR, String::compose ("sizes of audio data for frame %1 differ", i));
+ note (NoteType::ERROR, String::compose ("sizes of audio data for frame %1 differ", i));
return false;
}
for (int channel = 0; channel < frame_A->channels(); ++channel) {
int32_t const d = abs(frame_A->get(channel, sample) - frame_B->get(channel, sample));
if (d > opt.max_audio_sample_error) {
- note (DCP_ERROR, String::compose ("PCM data difference of %1", d));
+ note (NoteType::ERROR, String::compose ("PCM data difference of %1", d));
return false;
}
}
SoundAsset::static_pkl_type (Standard standard)
{
switch (standard) {
- case INTEROP:
+ case Standard::INTEROP:
return "application/x-smpte-mxf;asdcpKind=Sound";
- case SMPTE:
+ case Standard::SMPTE:
return "application/mxf";
default:
DCP_ASSERT (false);
, _active_channels (active_channels)
{
DCP_ASSERT (!_sync || _asset->channels() >= 14);
- DCP_ASSERT (!_sync || _asset->standard() == SMPTE);
+ DCP_ASSERT (!_sync || _asset->standard() == Standard::SMPTE);
/* Derived from ASDCP::Wav::SimpleWaveHeader::FillADesc */
_state->desc.EditRate = ASDCP::Rational (_asset->edit_rate().numerator, _asset->edit_rate().denominator);
_state->desc.BlockAlign = 3 * _asset->channels();
_state->desc.AvgBps = _asset->sampling_rate() * _state->desc.BlockAlign;
_state->desc.LinkedTrackID = 0;
- if (asset->standard() == INTEROP) {
+ if (asset->standard() == Standard::INTEROP) {
_state->desc.ChannelFormat = ASDCP::PCM::CF_NONE;
} else {
/* Just use WTF ("wild track format") for SMPTE for now; searches suggest that this
boost::throw_exception (FileError ("could not open audio MXF for writing", _file.string(), r));
}
- if (_asset->standard() == dcp::SMPTE && !_active_channels.empty()) {
+ if (_asset->standard() == Standard::SMPTE && !_active_channels.empty()) {
ASDCP::MXF::WaveAudioDescriptor* essence_descriptor = 0;
_state->mxf_writer.OP1aHeader().GetMDObjectByType(
GenRandomValue (soundfield->MCALinkID);
soundfield->RFC5646SpokenLanguage = _asset->language();
- const MCASoundField field = _asset->channels() > 10 ? SEVEN_POINT_ONE : FIVE_POINT_ONE;
+ const MCASoundField field = _asset->channels() > 10 ? MCASoundField::SEVEN_POINT_ONE : MCASoundField::FIVE_POINT_ONE;
- if (field == SEVEN_POINT_ONE) {
+ if (field == MCASoundField::SEVEN_POINT_ONE) {
soundfield->MCATagSymbol = "sg71";
soundfield->MCATagName = "7.1DS";
soundfield->MCALabelDictionaryID = asdcp_smpte_dict->ul(ASDCP::MDD_DCAudioSoundfield_71);
/* If there was a problem reading the frame data we'll just assume
the two frames are not equal.
*/
- note (DCP_ERROR, e.what ());
+ note (NoteType::ERROR, e.what ());
return false;
}
StereoPictureAssetWriter::StereoPictureAssetWriter (PictureAsset* mxf, boost::filesystem::path file, bool overwrite)
: PictureAssetWriter (mxf, file, overwrite)
, _state (new StereoPictureAssetWriter::ASDCPState)
- , _next_eye (EYE_LEFT)
+ , _next_eye (Eye::LEFT)
{
}
string hash;
Kumu::Result_t r = _state->mxf_writer.WriteFrame (
_state->frame_buffer,
- _next_eye == EYE_LEFT ? ASDCP::JP2K::SP_LEFT : ASDCP::JP2K::SP_RIGHT,
+ _next_eye == Eye::LEFT ? ASDCP::JP2K::SP_LEFT : ASDCP::JP2K::SP_RIGHT,
_crypto_context->context(),
_crypto_context->hmac(),
&hash
boost::throw_exception (MXFFileError ("error in writing video MXF", _file.string(), r));
}
- _next_eye = _next_eye == EYE_LEFT ? EYE_RIGHT : EYE_LEFT;
+ _next_eye = _next_eye == Eye::LEFT ? Eye::RIGHT : Eye::LEFT;
- if (_next_eye == EYE_LEFT) {
+ if (_next_eye == Eye::LEFT) {
++_frames_written;
}
DCP_ASSERT (_started);
DCP_ASSERT (!_finalized);
- Kumu::Result_t r = _state->mxf_writer.FakeWriteFrame (size, _next_eye == EYE_LEFT ? ASDCP::JP2K::SP_LEFT : ASDCP::JP2K::SP_RIGHT);
+ Kumu::Result_t r = _state->mxf_writer.FakeWriteFrame (size, _next_eye == Eye::LEFT ? ASDCP::JP2K::SP_LEFT : ASDCP::JP2K::SP_RIGHT);
if (ASDCP_FAILURE (r)) {
boost::throw_exception (MXFFileError ("error in writing video MXF", _file.string(), r));
}
- _next_eye = _next_eye == EYE_LEFT ? EYE_RIGHT : EYE_LEFT;
- if (_next_eye == EYE_LEFT) {
+ _next_eye = _next_eye == Eye::LEFT ? Eye::RIGHT : Eye::LEFT;
+ if (_next_eye == Eye::LEFT) {
++_frames_written;
}
}
/*
- Copyright (C) 2012-2014 Carl Hetherington <cth@carlh.net>
+ Copyright (C) 2012-2021 Carl Hetherington <cth@carlh.net>
This file is part of libdcp.
using std::string;
using std::shared_ptr;
+using std::make_shared;
using namespace dcp;
ASDCP::JP2K::FrameBuffer &
StereoPictureFrame::Part::mono () const
{
- return _eye == EYE_LEFT ? _buffer->Left : _buffer->Right;
+ return _eye == Eye::LEFT ? _buffer->Left : _buffer->Right;
}
StereoPictureFrame::xyz_image (Eye eye, int reduce) const
{
switch (eye) {
- case EYE_LEFT:
+ case Eye::LEFT:
return decompress_j2k (const_cast<uint8_t*> (_buffer->Left.RoData()), _buffer->Left.Size(), reduce);
- case EYE_RIGHT:
+ case Eye::RIGHT:
return decompress_j2k (const_cast<uint8_t*> (_buffer->Right.RoData()), _buffer->Right.Size(), reduce);
}
shared_ptr<StereoPictureFrame::Part>
StereoPictureFrame::right () const
{
- return shared_ptr<Part>(new Part(_buffer, EYE_RIGHT));
+ return make_shared<Part>(_buffer, Eye::RIGHT);
}
shared_ptr<StereoPictureFrame::Part>
StereoPictureFrame::left () const
{
- return shared_ptr<Part>(new Part(_buffer, EYE_LEFT));
+ return make_shared<Part>(_buffer, Eye::LEFT);
}
class Part : public Data
{
public:
+ Part (std::shared_ptr<ASDCP::JP2K::SFrameBuffer> buffer, Eye eye);
+
uint8_t const * data () const;
uint8_t * data ();
int size () const;
private:
friend class StereoPictureFrame;
- Part (std::shared_ptr<ASDCP::JP2K::SFrameBuffer> buffer, Eye eye);
ASDCP::JP2K::FrameBuffer& mono () const;
std::shared_ptr<ASDCP::JP2K::SFrameBuffer> _buffer;
{
ParseState ps;
- if (standard == INTEROP) {
+ if (standard == Standard::INTEROP) {
ps.font_id = optional_string_attribute (node, "Id");
} else {
ps.font_id = optional_string_attribute (node, "ID");
ps.aspect_adjust = optional_number_attribute<float> (node, "AspectAdjust");
ps.italic = optional_bool_attribute (node, "Italic");
ps.bold = optional_string_attribute(node, "Weight").get_value_or("normal") == "bold";
- if (standard == INTEROP) {
+ if (standard == Standard::INTEROP) {
ps.underline = optional_bool_attribute (node, "Underlined");
} else {
ps.underline = optional_bool_attribute (node, "Underline");
ps.in.get(),
ps.out.get(),
ps.h_position.get_value_or(0),
- ps.h_align.get_value_or(HALIGN_CENTER),
+ ps.h_align.get_value_or(HAlign::CENTER),
ps.v_position.get_value_or(0),
- ps.v_align.get_value_or(VALIGN_CENTER),
- ps.direction.get_value_or (DIRECTION_LTR),
+ ps.v_align.get_value_or(VAlign::CENTER),
+ ps.direction.get_value_or (Direction::LTR),
text,
- ps.effect.get_value_or (NONE),
+ ps.effect.get_value_or (Effect::NONE),
ps.effect_colour.get_value_or (dcp::Colour (0, 0, 0)),
ps.fade_up_time.get_value_or(Time()),
ps.fade_down_time.get_value_or(Time())
shared_ptr<Subtitle> (
new SubtitleImage (
ArrayData (),
- standard == INTEROP ? text.substr(0, text.size() - 4) : text,
+ standard == Standard::INTEROP ? text.substr(0, text.size() - 4) : text,
ps.in.get(),
ps.out.get(),
ps.h_position.get_value_or(0),
- ps.h_align.get_value_or(HALIGN_CENTER),
+ ps.h_align.get_value_or(HAlign::CENTER),
ps.v_position.get_value_or(0),
- ps.v_align.get_value_or(VALIGN_CENTER),
+ ps.v_align.get_value_or(VAlign::CENTER),
ps.fade_up_time.get_value_or(Time()),
ps.fade_down_time.get_value_or(Time())
)
}
if (_subtitles.size() != other->_subtitles.size()) {
- note (DCP_ERROR, String::compose("different number of subtitles: %1 vs %2", _subtitles.size(), other->_subtitles.size()));
+ note (NoteType::ERROR, String::compose("different number of subtitles: %1 vs %2", _subtitles.size(), other->_subtitles.size()));
return false;
}
shared_ptr<SubtitleImage> image_j = dynamic_pointer_cast<SubtitleImage> (*j);
if ((string_i && !string_j) || (image_i && !image_j)) {
- note (DCP_ERROR, "subtitles differ: string vs. image");
+ note (NoteType::ERROR, "subtitles differ: string vs. image");
return false;
}
if (string_i && *string_i != *string_j) {
- note (DCP_ERROR, String::compose("subtitles differ in text or metadata: %1 vs %2", string_i->text(), string_j->text()));
+ note (NoteType::ERROR, String::compose("subtitles differ in text or metadata: %1 vs %2", string_i->text(), string_j->text()));
return false;
}
string
order::Context::xmlns () const
{
- return standard == SMPTE ? "dcst" : "";
+ return standard == Standard::SMPTE ? "dcst" : "";
}
order::Font::Font (shared_ptr<SubtitleString> s, Standard standard)
{
if (s->font()) {
- if (standard == SMPTE) {
+ if (standard == Standard::SMPTE) {
_values["ID"] = s->font().get ();
} else {
_values["Id"] = s->font().get ();
_values["Effect"] = effect_to_string (s->effect());
_values["EffectColor"] = s->effect_colour().to_argb_string();
_values["Script"] = "normal";
- if (standard == SMPTE) {
+ if (standard == Standard::SMPTE) {
_values["Underline"] = s->underline() ? "yes" : "no";
} else {
_values["Underlined"] = s->underline() ? "yes" : "no";
static void
position_align (xmlpp::Element* e, order::Context& context, HAlign h_align, float h_position, VAlign v_align, float v_position)
{
- if (h_align != HALIGN_CENTER) {
- if (context.standard == SMPTE) {
+ if (h_align != HAlign::CENTER) {
+ if (context.standard == Standard::SMPTE) {
e->set_attribute ("Halign", halign_to_string (h_align));
} else {
e->set_attribute ("HAlign", halign_to_string (h_align));
}
if (fabs(h_position) > ALIGN_EPSILON) {
- if (context.standard == SMPTE) {
+ if (context.standard == Standard::SMPTE) {
e->set_attribute ("Hposition", raw_convert<string> (h_position * 100, 6));
} else {
e->set_attribute ("HPosition", raw_convert<string> (h_position * 100, 6));
}
}
- if (context.standard == SMPTE) {
+ if (context.standard == Standard::SMPTE) {
e->set_attribute ("Valign", valign_to_string (v_align));
} else {
e->set_attribute ("VAlign", valign_to_string (v_align));
}
if (fabs(v_position) > ALIGN_EPSILON) {
- if (context.standard == SMPTE) {
+ if (context.standard == Standard::SMPTE) {
e->set_attribute ("Vposition", raw_convert<string> (v_position * 100, 6));
} else {
e->set_attribute ("VPosition", raw_convert<string> (v_position * 100, 6));
}
} else {
- if (context.standard == SMPTE) {
+ if (context.standard == Standard::SMPTE) {
e->set_attribute ("Vposition", "0");
} else {
e->set_attribute ("VPosition", "0");
/* Interop only supports "horizontal" or "vertical" for direction, so only write this
for SMPTE.
*/
- if (_direction != DIRECTION_LTR && context.standard == SMPTE) {
+ if (_direction != Direction::LTR && context.standard == Standard::SMPTE) {
e->set_attribute ("Direction", direction_to_string (_direction));
}
e->set_attribute ("SpotNumber", raw_convert<string> (context.spot_number++));
e->set_attribute ("TimeIn", _in.rebase(context.time_code_rate).as_string(context.standard));
e->set_attribute ("TimeOut", _out.rebase(context.time_code_rate).as_string(context.standard));
- if (context.standard == SMPTE) {
+ if (context.standard == Standard::SMPTE) {
e->set_attribute ("FadeUpTime", _fade_up.rebase(context.time_code_rate).as_string(context.standard));
e->set_attribute ("FadeDownTime", _fade_down.rebase(context.time_code_rate).as_string(context.standard));
} else {
xmlpp::Element* e = parent->add_child ("Image", context.xmlns());
position_align (e, context, _h_align, _h_position, _v_align, _v_position);
- if (context.standard == SMPTE) {
+ if (context.standard == Standard::SMPTE) {
e->add_child_text (_id);
} else {
e->add_child_text (_id + ".png");
SubtitleImage::equals (shared_ptr<SubtitleImage> other, EqualityOptions options, NoteHandler note)
{
if (png_image() != other->png_image()) {
- note (DCP_ERROR, "subtitle image PNG data differs");
+ note (NoteType::ERROR, "subtitle image PNG data differs");
if (options.export_differing_subtitles) {
string const base = "dcpdiff_subtitle_";
if (boost::filesystem::exists(base + "A.png")) {
- note (DCP_ERROR, "could not export subtitle as " + base + "A.png already exists");
+ note (NoteType::ERROR, "could not export subtitle as " + base + "A.png already exists");
} else {
png_image().write(base + "A.png");
}
if (boost::filesystem::exists(base + "B.png")) {
- note (DCP_ERROR, "could not export subtitle as " + base + "B.png already exists");
+ note (NoteType::ERROR, "could not export subtitle as " + base + "B.png already exists");
} else {
other->png_image().write(base + "B.png");
}
}
if (in() != other->in()) {
- note (DCP_ERROR, "subtitle in times differ");
+ note (NoteType::ERROR, "subtitle in times differ");
return false;
}
if (out() != other->out()) {
- note (DCP_ERROR, "subtitle out times differ");
+ note (NoteType::ERROR, "subtitle out times differ");
return false;
}
if (h_position() != other->h_position()) {
- note (DCP_ERROR, "subtitle horizontal positions differ");
+ note (NoteType::ERROR, "subtitle horizontal positions differ");
return false;
}
if (h_align() != other->h_align()) {
- note (DCP_ERROR, "subtitle horizontal alignments differ");
+ note (NoteType::ERROR, "subtitle horizontal alignments differ");
return false;
}
if (v_position() != other->v_position()) {
- note (DCP_ERROR, "subtitle vertical positions differ");
+ note (NoteType::ERROR, "subtitle vertical positions differ");
return false;
}
if (v_align() != other->v_align()) {
- note (DCP_ERROR, "subtitle vertical alignments differ");
+ note (NoteType::ERROR, "subtitle vertical alignments differ");
return false;
}
if (fade_up_time() != other->fade_up_time()) {
- note (DCP_ERROR, "subtitle fade-up times differ");
+ note (NoteType::ERROR, "subtitle fade-up times differ");
return false;
}
if (fade_down_time() != other->fade_down_time()) {
- note (DCP_ERROR, "subtitle fade-down times differ");
+ note (NoteType::ERROR, "subtitle fade-down times differ");
return false;
}
dcp::effect_to_string (Effect e)
{
switch (e) {
- case NONE:
+ case Effect::NONE:
return "none";
- case BORDER:
+ case Effect::BORDER:
return "border";
- case SHADOW:
+ case Effect::SHADOW:
return "shadow";
}
dcp::string_to_effect (string s)
{
if (s == "none") {
- return NONE;
+ return Effect::NONE;
} else if (s == "border") {
- return BORDER;
+ return Effect::BORDER;
} else if (s == "shadow") {
- return SHADOW;
+ return Effect::SHADOW;
}
boost::throw_exception (ReadError ("unknown subtitle effect type"));
}
+
+std::ostream&
+dcp::operator<< (std::ostream& s, Effect e)
+{
+ s << effect_to_string(e);
+ return s;
+}
+
+
string
dcp::halign_to_string (HAlign h)
{
switch (h) {
- case HALIGN_LEFT:
+ case HAlign::LEFT:
return "left";
- case HALIGN_CENTER:
+ case HAlign::CENTER:
return "center";
- case HALIGN_RIGHT:
+ case HAlign::RIGHT:
return "right";
}
dcp::string_to_halign (string s)
{
if (s == "left") {
- return HALIGN_LEFT;
+ return HAlign::LEFT;
} else if (s == "center") {
- return HALIGN_CENTER;
+ return HAlign::CENTER;
} else if (s == "right") {
- return HALIGN_RIGHT;
+ return HAlign::RIGHT;
}
boost::throw_exception (ReadError ("unknown subtitle halign type"));
dcp::valign_to_string (VAlign v)
{
switch (v) {
- case VALIGN_TOP:
+ case VAlign::TOP:
return "top";
- case VALIGN_CENTER:
+ case VAlign::CENTER:
return "center";
- case VALIGN_BOTTOM:
+ case VAlign::BOTTOM:
return "bottom";
}
dcp::string_to_valign (string s)
{
if (s == "top") {
- return VALIGN_TOP;
+ return VAlign::TOP;
} else if (s == "center") {
- return VALIGN_CENTER;
+ return VAlign::CENTER;
} else if (s == "bottom") {
- return VALIGN_BOTTOM;
+ return VAlign::BOTTOM;
}
boost::throw_exception (ReadError ("unknown subtitle valign type"));
dcp::direction_to_string (Direction v)
{
switch (v) {
- case DIRECTION_LTR:
+ case Direction::LTR:
return "ltr";
- case DIRECTION_RTL:
+ case Direction::RTL:
return "rtl";
- case DIRECTION_TTB:
+ case Direction::TTB:
return "ttb";
- case DIRECTION_BTT:
+ case Direction::BTT:
return "btt";
}
dcp::string_to_direction (string s)
{
if (s == "ltr" || s == "horizontal") {
- return DIRECTION_LTR;
+ return Direction::LTR;
} else if (s == "rtl") {
- return DIRECTION_RTL;
+ return Direction::RTL;
} else if (s == "ttb" || s == "vertical") {
- return DIRECTION_TTB;
+ return Direction::TTB;
} else if (s == "btt") {
- return DIRECTION_BTT;
+ return Direction::BTT;
}
boost::throw_exception (ReadError ("unknown subtitle direction type"));
dcp::content_kind_to_string (ContentKind kind)
{
switch (kind) {
- case FEATURE:
+ case ContentKind::FEATURE:
return "feature";
- case SHORT:
+ case ContentKind::SHORT:
return "short";
- case TRAILER:
+ case ContentKind::TRAILER:
return "trailer";
- case TEST:
+ case ContentKind::TEST:
return "test";
- case TRANSITIONAL:
+ case ContentKind::TRANSITIONAL:
return "transitional";
- case RATING:
+ case ContentKind::RATING:
return "rating";
- case TEASER:
+ case ContentKind::TEASER:
return "teaser";
- case POLICY:
+ case ContentKind::POLICY:
return "policy";
- case PUBLIC_SERVICE_ANNOUNCEMENT:
+ case ContentKind::PUBLIC_SERVICE_ANNOUNCEMENT:
return "psa";
- case ADVERTISEMENT:
+ case ContentKind::ADVERTISEMENT:
return "advertisement";
- case EPISODE:
+ case ContentKind::EPISODE:
return "episode";
- case PROMO:
+ case ContentKind::PROMO:
return "promo";
}
transform (kind.begin(), kind.end(), kind.begin(), ::tolower);
if (kind == "feature") {
- return FEATURE;
+ return ContentKind::FEATURE;
} else if (kind == "short") {
- return SHORT;
+ return ContentKind::SHORT;
} else if (kind == "trailer") {
- return TRAILER;
+ return ContentKind::TRAILER;
} else if (kind == "test") {
- return TEST;
+ return ContentKind::TEST;
} else if (kind == "transitional") {
- return TRANSITIONAL;
+ return ContentKind::TRANSITIONAL;
} else if (kind == "rating") {
- return RATING;
+ return ContentKind::RATING;
} else if (kind == "teaser") {
- return TEASER;
+ return ContentKind::TEASER;
} else if (kind == "policy") {
- return POLICY;
+ return ContentKind::POLICY;
} else if (kind == "psa") {
- return PUBLIC_SERVICE_ANNOUNCEMENT;
+ return ContentKind::PUBLIC_SERVICE_ANNOUNCEMENT;
} else if (kind == "advertisement") {
- return ADVERTISEMENT;
+ return ContentKind::ADVERTISEMENT;
} else if (kind == "episode") {
- return EPISODE;
+ return ContentKind::EPISODE;
} else if (kind == "promo") {
- return PROMO;
+ return ContentKind::PROMO;
}
throw BadContentKindError (kind);
}
+
+ostream&
+dcp::operator<< (ostream& s, ContentKind c)
+{
+ s << content_kind_to_string(c);
+ return s;
+}
+
+
string
dcp::marker_to_string (dcp::Marker m)
{
Luminance::unit_to_string (Unit u)
{
switch (u) {
- case CANDELA_PER_SQUARE_METRE:
+ case Unit::CANDELA_PER_SQUARE_METRE:
return "candela-per-square-metre";
- case FOOT_LAMBERT:
+ case Unit::FOOT_LAMBERT:
return "foot-lambert";
default:
DCP_ASSERT (false);
}
if (parts[0] == "51") {
- _field = FIVE_POINT_ONE;
+ _field = MCASoundField::FIVE_POINT_ONE;
} else if (parts[0] == "71") {
- _field = SEVEN_POINT_ONE;
+ _field = MCASoundField::SEVEN_POINT_ONE;
} else {
throw MainSoundConfigurationError (s);
}
MainSoundConfiguration::to_string () const
{
string c;
- if (_field == FIVE_POINT_ONE) {
+ if (_field == MCASoundField::FIVE_POINT_ONE) {
c = "51/";
} else {
c = "71/";
}
- BOOST_FOREACH (optional<Channel> i, _channels) {
+ for (auto i: _channels) {
if (!i) {
c += "-,";
} else {
dcp::status_to_string (Status s)
{
switch (s) {
- case FINAL:
+ case Status::FINAL:
return "final";
- case TEMP:
+ case Status::TEMP:
return "temp";
- case PRE:
+ case Status::PRE:
return "pre";
default:
DCP_ASSERT (false);
dcp::string_to_status (string s)
{
if (s == "final") {
- return FINAL;
+ return Status::FINAL;
} else if (s == "temp") {
- return TEMP;
+ return Status::TEMP;
} else if (s == "pre") {
- return PRE;
+ return Status::PRE;
}
DCP_ASSERT (false);
}
+ostream&
+dcp::operator<<(ostream& s, Status t)
+{
+ s << status_to_string(t);
+ return s;
+}
+
+
+ostream&
+dcp::operator<<(ostream& s, dcp::Channel c)
+{
+ switch (c) {
+ case Channel::LEFT:
+ s << "left(0)";
+ break;
+ case Channel::RIGHT:
+ s << "right(1)";
+ break;
+ case Channel::CENTRE:
+ s << "centre(2)";
+ break;
+ case Channel::LFE:
+ s << "lfe(3)";
+ break;
+ case Channel::LS:
+ s << "ls(4)";
+ break;
+ case Channel::RS:
+ s << "rs(5)";
+ break;
+ case Channel::HI:
+ s << "hi(6)";
+ break;
+ case Channel::VI:
+ s << "vi(7)";
+ break;
+ case Channel::BSL:
+ s << "bsl(10)";
+ break;
+ case Channel::BSR:
+ s << "bsr(11)";
+ break;
+ case Channel::MOTION_DATA:
+ s << "motion_data(12)";
+ break;
+ case Channel::SYNC_SIGNAL:
+ s << "sync_signal(13)";
+ break;
+ case Channel::SIGN_LANGUAGE:
+ s << "sign_language(14)";
+ break;
+ case Channel::CHANNEL_COUNT:
+ s << "(16)";
+ break;
+ }
+ return s;
+}
+
+
Channel
dcp::mca_id_to_channel (string id)
{
if (id == "L") {
- return LEFT;
+ return Channel::LEFT;
} else if (id == "R") {
- return RIGHT;
+ return Channel::RIGHT;
} else if (id == "C") {
- return CENTRE;
+ return Channel::CENTRE;
} else if (id == "LFE") {
- return LFE;
+ return Channel::LFE;
} else if (id == "Ls" || id == "Lss") {
- return LS;
+ return Channel::LS;
} else if (id == "Rs" || id == "Rss") {
- return RS;
+ return Channel::RS;
} else if (id == "HI") {
- return HI;
+ return Channel::HI;
} else if (id == "VIN") {
- return VI;
+ return Channel::VI;
} else if (id == "Lrs") {
- return BSL;
+ return Channel::BSL;
} else if (id == "Rrs") {
- return BSR;
+ return Channel::BSR;
} else if (id == "DBOX") {
- return MOTION_DATA;
+ return Channel::MOTION_DATA;
} else if (id == "FSKSync") {
- return SYNC_SIGNAL;
+ return Channel::SYNC_SIGNAL;
} else if (id == "SLVS") {
- return SIGN_LANGUAGE;
+ return Channel::SIGN_LANGUAGE;
}
throw UnknownChannelIdError (id);
dcp::channel_to_mca_id (Channel c, MCASoundField field)
{
switch (c) {
- case LEFT:
+ case Channel::LEFT:
return "L";
- case RIGHT:
+ case Channel::RIGHT:
return "R";
- case CENTRE:
+ case Channel::CENTRE:
return "C";
- case LFE:
+ case Channel::LFE:
return "LFE";
- case LS:
- return field == FIVE_POINT_ONE ? "Ls" : "Lss";
- case RS:
- return field == FIVE_POINT_ONE ? "Rs" : "Rss";
- case HI:
+ case Channel::LS:
+ return field == MCASoundField::FIVE_POINT_ONE ? "Ls" : "Lss";
+ case Channel::RS:
+ return field == MCASoundField::FIVE_POINT_ONE ? "Rs" : "Rss";
+ case Channel::HI:
return "HI";
- case VI:
+ case Channel::VI:
return "VIN";
- case BSL:
+ case Channel::BSL:
return "Lrs";
- case BSR:
+ case Channel::BSR:
return "Rrs";
- case MOTION_DATA:
+ case Channel::MOTION_DATA:
return "DBOX";
- case SYNC_SIGNAL:
+ case Channel::SYNC_SIGNAL:
return "FSKSync";
- case SIGN_LANGUAGE:
+ case Channel::SIGN_LANGUAGE:
return "SLVS";
default:
break;
dcp::channel_to_mca_name (Channel c, MCASoundField field)
{
switch (c) {
- case LEFT:
+ case Channel::LEFT:
return "Left";
- case RIGHT:
+ case Channel::RIGHT:
return "Right";
- case CENTRE:
+ case Channel::CENTRE:
return "Center";
- case LFE:
+ case Channel::LFE:
return "LFE";
- case LS:
- return field == FIVE_POINT_ONE ? "Left Surround" : "Left Side Surround";
- case RS:
- return field == FIVE_POINT_ONE ? "Right Surround" : "Right Side Surround";
- case HI:
+ case Channel::LS:
+ return field == MCASoundField::FIVE_POINT_ONE ? "Left Surround" : "Left Side Surround";
+ case Channel::RS:
+ return field == MCASoundField::FIVE_POINT_ONE ? "Right Surround" : "Right Side Surround";
+ case Channel::HI:
return "Hearing Impaired";
- case VI:
+ case Channel::VI:
return "Visually Impaired-Narrative";
- case BSL:
+ case Channel::BSL:
return "Left Rear Surround";
- case BSR:
+ case Channel::BSR:
return "Right Rear Surround";
- case MOTION_DATA:
+ case Channel::MOTION_DATA:
return "D-BOX Motion Code Primary Stream";
- case SYNC_SIGNAL:
+ case Channel::SYNC_SIGNAL:
return "FSK Sync";
- case SIGN_LANGUAGE:
+ case Channel::SIGN_LANGUAGE:
return "Sign Language Video Stream";
default:
break;
};
switch (c) {
- case LEFT:
+ case Channel::LEFT:
return dict->ul(ASDCP::MDD_DCAudioChannel_L);
- case RIGHT:
+ case Channel::RIGHT:
return dict->ul(ASDCP::MDD_DCAudioChannel_R);
- case CENTRE:
+ case Channel::CENTRE:
return dict->ul(ASDCP::MDD_DCAudioChannel_C);
- case LFE:
+ case Channel::LFE:
return dict->ul(ASDCP::MDD_DCAudioChannel_LFE);
- case LS:
- return dict->ul(field == FIVE_POINT_ONE ? ASDCP::MDD_DCAudioChannel_Ls : ASDCP::MDD_DCAudioChannel_Lss);
- case RS:
- return dict->ul(field == FIVE_POINT_ONE ? ASDCP::MDD_DCAudioChannel_Rs : ASDCP::MDD_DCAudioChannel_Rss);
- case HI:
+ case Channel::LS:
+ return dict->ul(field == MCASoundField::FIVE_POINT_ONE ? ASDCP::MDD_DCAudioChannel_Ls : ASDCP::MDD_DCAudioChannel_Lss);
+ case Channel::RS:
+ return dict->ul(field == MCASoundField::FIVE_POINT_ONE ? ASDCP::MDD_DCAudioChannel_Rs : ASDCP::MDD_DCAudioChannel_Rss);
+ case Channel::HI:
return dict->ul(ASDCP::MDD_DCAudioChannel_HI);
- case VI:
+ case Channel::VI:
return dict->ul(ASDCP::MDD_DCAudioChannel_VIN);
- case BSL:
+ case Channel::BSL:
return dict->ul(ASDCP::MDD_DCAudioChannel_Lrs);
- case BSR:
+ case Channel::BSR:
return dict->ul(ASDCP::MDD_DCAudioChannel_Rrs);
- case MOTION_DATA:
+ case Channel::MOTION_DATA:
return dict->ul(ASDCP::MDD_DBOXMotionCodePrimaryStream);
- case SYNC_SIGNAL:
+ case Channel::SYNC_SIGNAL:
return ASDCP::UL(sync_signal);
- case SIGN_LANGUAGE:
+ case Channel::SIGN_LANGUAGE:
return ASDCP::UL(sign_language);
default:
break;
vector<dcp::Channel>
dcp::used_audio_channels ()
{
- vector<dcp::Channel> c;
- c.push_back (LEFT);
- c.push_back (RIGHT);
- c.push_back (CENTRE);
- c.push_back (LFE);
- c.push_back (LS);
- c.push_back (RS);
- c.push_back (HI);
- c.push_back (VI);
- c.push_back (BSL);
- c.push_back (BSR);
- c.push_back (MOTION_DATA);
- c.push_back (SYNC_SIGNAL);
- c.push_back (SIGN_LANGUAGE);
+ vector<Channel> c;
+ c.push_back (Channel::LEFT);
+ c.push_back (Channel::RIGHT);
+ c.push_back (Channel::CENTRE);
+ c.push_back (Channel::LFE);
+ c.push_back (Channel::LS);
+ c.push_back (Channel::RS);
+ c.push_back (Channel::HI);
+ c.push_back (Channel::VI);
+ c.push_back (Channel::BSL);
+ c.push_back (Channel::BSR);
+ c.push_back (Channel::MOTION_DATA);
+ c.push_back (Channel::SYNC_SIGNAL);
+ c.push_back (Channel::SIGN_LANGUAGE);
return c;
}
+
+ostream&
+dcp::operator<< (ostream& s, NoteType t)
+{
+ switch (t) {
+ case NoteType::PROGRESS:
+ s << "progress";
+ break;
+ case NoteType::ERROR:
+ s << "error";
+ break;
+ case NoteType::NOTE:
+ s << "note";
+ break;
+ }
+ return s;
+}
+
+
+ostream&
+dcp::operator<< (ostream& s, MCASoundField f)
+{
+ switch (f) {
+ case MCASoundField::FIVE_POINT_ONE:
+ s << "5.1";
+ break;
+ case MCASoundField::SEVEN_POINT_ONE:
+ s << "7.1";
+ break;
+ }
+ return s;
+}
+
+
+ostream&
+dcp::operator<< (ostream& s, Standard t)
+{
+ switch (t) {
+ case Standard::INTEROP:
+ s << "interop";
+ break;
+ case Standard::SMPTE:
+ s << "smpte";
+ break;
+ }
+ return s;
+}
extern std::ostream& operator<< (std::ostream& s, Size const & a);
/** Identifier for a sound channel */
-enum Channel {
+enum class Channel {
LEFT = 0, ///< left
RIGHT = 1, ///< right
CENTRE = 2, ///< centre
};
std::vector<dcp::Channel> used_audio_channels ();
+std::ostream& operator<< (std::ostream& s, Channel c);
-enum MCASoundField
+enum class MCASoundField
{
FIVE_POINT_ONE,
SEVEN_POINT_ONE
extern Channel mca_id_to_channel (std::string);
extern std::string channel_to_mca_name (Channel c, MCASoundField field);
extern ASDCP::UL channel_to_mca_universal_label (Channel c, MCASoundField field, ASDCP::Dictionary const* dict);
+std::ostream& operator<< (std::ostream& s, MCASoundField f);
-enum ContentKind
+enum class ContentKind
{
FEATURE,
SHORT,
extern std::string content_kind_to_string (ContentKind kind);
extern ContentKind content_kind_from_string (std::string kind);
+std::ostream& operator<<(std::ostream& s, ContentKind c);
-enum Effect
+enum class Effect
{
NONE,
BORDER,
extern std::string effect_to_string (Effect e);
extern Effect string_to_effect (std::string s);
+std::ostream& operator<< (std::ostream& s, Effect e);
-enum HAlign
+enum class HAlign
{
- HALIGN_LEFT, ///< horizontal position is distance from left of screen to left of subtitle
- HALIGN_CENTER, ///< horizontal position is distance from centre of screen to centre of subtitle
- HALIGN_RIGHT, ///< horizontal position is distance from right of screen to right of subtitle
+ LEFT, ///< horizontal position is distance from left of screen to left of subtitle
+ CENTER, ///< horizontal position is distance from centre of screen to centre of subtitle
+ RIGHT, ///< horizontal position is distance from right of screen to right of subtitle
};
extern std::string halign_to_string (HAlign a);
extern HAlign string_to_halign (std::string s);
-enum VAlign
+enum class VAlign
{
- VALIGN_TOP, ///< vertical position is distance from top of screen to top of subtitle
- VALIGN_CENTER, ///< vertical position is distance from centre of screen to centre of subtitle
- VALIGN_BOTTOM ///< vertical position is distance from bottom of screen to bottom of subtitle
+ TOP, ///< vertical position is distance from top of screen to top of subtitle
+ CENTER, ///< vertical position is distance from centre of screen to centre of subtitle
+ BOTTOM ///< vertical position is distance from bottom of screen to bottom of subtitle
};
extern std::string valign_to_string (VAlign a);
extern VAlign string_to_valign (std::string s);
/** Direction for subtitle test */
-enum Direction
+enum class Direction
{
- DIRECTION_LTR, ///< left-to-right
- DIRECTION_RTL, ///< right-to-left
- DIRECTION_TTB, ///< top-to-bottom
- DIRECTION_BTT ///< bottom-to-top
+ LTR, ///< left-to-right
+ RTL, ///< right-to-left
+ TTB, ///< top-to-bottom
+ BTT ///< bottom-to-top
};
extern std::string direction_to_string (Direction a);
extern Direction string_to_direction (std::string s);
-enum Eye
+enum class Eye
{
- EYE_LEFT,
- EYE_RIGHT
+ LEFT,
+ RIGHT
};
/** @class Fraction
/* I've been unable to make mingw happy with ERROR as a symbol, so
I'm using a DCP_ prefix here.
*/
-enum NoteType {
- DCP_PROGRESS,
- DCP_ERROR,
- DCP_NOTE
+enum class NoteType {
+ PROGRESS,
+ ERROR,
+ NOTE
};
-enum Standard {
+std::ostream& operator<< (std::ostream& s, NoteType t);
+
+enum class Standard {
INTEROP,
SMPTE
};
-enum Formulation {
+std::ostream& operator<< (std::ostream& s, Standard t);
+
+enum class Formulation {
MODIFIED_TRANSITIONAL_1,
MULTIPLE_MODIFIED_TRANSITIONAL_1,
DCI_ANY,
extern std::ostream& operator<< (std::ostream& s, Rating const & r);
-enum Status
+enum class Status
{
FINAL, ///< final version
TEMP, ///< temporary version (picture/sound unfinished)
extern std::string status_to_string (Status s);
extern Status string_to_status (std::string s);
+std::ostream& operator<< (std::ostream& s, Status t);
class ContentVersion
class Luminance
{
public:
- enum Unit {
+ enum class Unit {
CANDELA_PER_SQUARE_METRE,
FOOT_LAMBERT
};
auto position = [](shared_ptr<const SubtitleString> sub) {
switch (sub->v_align()) {
- case VALIGN_TOP:
+ case VAlign::TOP:
return lrintf(sub->v_position() * 100);
- case VALIGN_CENTER:
+ case VAlign::CENTER:
return lrintf((0.5f + sub->v_position()) * 100);
- case VALIGN_BOTTOM:
+ case VAlign::BOTTOM:
return lrintf((1.0f - sub->v_position()) * 100);
}
notes.push_back ({VerificationNote::VERIFY_ERROR, VerificationNote::FAILED_READ, string(e.what())});
}
- if (dcp->standard() != SMPTE) {
+ if (dcp->standard() != Standard::SMPTE) {
notes.push_back ({VerificationNote::VERIFY_BV21_ERROR, VerificationNote::INVALID_STANDARD});
}
}
}
- if (dcp->standard() == SMPTE) {
+ if (dcp->standard() == Standard::SMPTE) {
if (!cpl->annotation_text()) {
notes.push_back ({VerificationNote::VERIFY_BV21_ERROR, VerificationNote::MISSING_CPL_ANNOTATION_TEXT, cpl->id(), cpl->file().get()});
} else if (cpl->annotation_text().get() != cpl->content_title_text()) {
}
}
- if (dcp->standard() == SMPTE) {
+ if (dcp->standard() == Standard::SMPTE) {
boost::optional<int64_t> duration;
for (auto i: reel->assets()) {
if (!duration) {
most_closed_captions = std::max (most_closed_captions, reel->closed_captions().size());
}
- if (dcp->standard() == SMPTE) {
+ if (dcp->standard() == Standard::SMPTE) {
if (have_main_subtitle && have_no_main_subtitle) {
notes.push_back ({VerificationNote::VERIFY_BV21_ERROR, VerificationNote::MISSING_MAIN_SUBTITLE_FROM_SOME_REELS});
notes.push_back ({VerificationNote::VERIFY_BV21_ERROR, VerificationNote::MISMATCHED_CLOSED_CAPTION_ASSET_COUNTS});
}
- if (cpl->content_kind() == FEATURE) {
+ if (cpl->content_kind() == ContentKind::FEATURE) {
if (markers_seen.find(Marker::FFEC) == markers_seen.end()) {
notes.push_back ({VerificationNote::VERIFY_BV21_ERROR, VerificationNote::MISSING_FFEC_IN_FEATURE});
}
boost::filesystem::path const out = "build/test/combine_two_dcps_with_same_asset_filenames_test";
shared_ptr<dcp::DCP> second = make_simple ("build/test/combine_input2");
- second->write_xml (dcp::SMPTE);
+ second->write_xml (dcp::Standard::SMPTE);
remove_all (out);
vector<path> inputs;
boost::filesystem::path const out = "build/test/combine_two_dcps_with_interop_subs_test";
shared_ptr<dcp::DCP> first = make_simple_with_interop_subs ("build/test/combine_input1");
- first->write_xml (dcp::INTEROP);
+ first->write_xml (dcp::Standard::INTEROP);
shared_ptr<dcp::DCP> second = make_simple_with_interop_subs ("build/test/combine_input2");
- second->write_xml (dcp::INTEROP);
+ second->write_xml (dcp::Standard::INTEROP);
remove_all (out);
vector<path> inputs;
boost::filesystem::path const out = "build/test/combine_two_dcps_with_smpte_subs_test";
shared_ptr<dcp::DCP> first = make_simple_with_smpte_subs ("build/test/combine_input1");
- first->write_xml (dcp::SMPTE);
+ first->write_xml (dcp::Standard::SMPTE);
shared_ptr<dcp::DCP> second = make_simple_with_smpte_subs ("build/test/combine_input2");
- second->write_xml (dcp::SMPTE);
+ second->write_xml (dcp::Standard::SMPTE);
remove_all (out);
vector<path> inputs;
boost::filesystem::path const out = "build/test/combine_two_dcps_with_interop_ccaps_test";
shared_ptr<dcp::DCP> first = make_simple_with_interop_ccaps ("build/test/combine_input1");
- first->write_xml (dcp::INTEROP);
+ first->write_xml (dcp::Standard::INTEROP);
shared_ptr<dcp::DCP> second = make_simple_with_interop_ccaps ("build/test/combine_input2");
- second->write_xml (dcp::INTEROP);
+ second->write_xml (dcp::Standard::INTEROP);
remove_all (out);
vector<path> inputs;
boost::filesystem::path const out = "build/test/combine_two_dcps_with_interop_ccaps_test";
shared_ptr<dcp::DCP> first = make_simple_with_smpte_ccaps ("build/test/combine_input1");
- first->write_xml (dcp::SMPTE);
+ first->write_xml (dcp::Standard::SMPTE);
shared_ptr<dcp::DCP> second = make_simple_with_smpte_ccaps ("build/test/combine_input2");
- second->write_xml (dcp::SMPTE);
+ second->write_xml (dcp::Standard::SMPTE);
remove_all (out);
vector<path> inputs;
boost::filesystem::path const out = "build/test/combine_two_multi_reel_dcps";
shared_ptr<dcp::DCP> first = make_simple ("build/test/combine_input1", 4);
- first->write_xml (dcp::SMPTE);
+ first->write_xml (dcp::Standard::SMPTE);
shared_ptr<dcp::DCP> second = make_simple ("build/test/combine_input2", 4);
- second->write_xml (dcp::SMPTE);
+ second->write_xml (dcp::Standard::SMPTE);
remove_all (out);
vector<path> inputs;
boost::filesystem::path const out = "build/test/combine_two_dcps_with_shared_asset";
shared_ptr<dcp::DCP> first = make_simple ("build/test/combine_input1", 1);
- first->write_xml (dcp::SMPTE);
+ first->write_xml (dcp::Standard::SMPTE);
remove_all ("build/test/combine_input2");
shared_ptr<dcp::DCP> second(new dcp::DCP("build/test/combine_input2"));
mxf_meta.company_name = "OpenDCP";
mxf_meta.product_version = "0.0.25";
- shared_ptr<dcp::CPL> cpl (new dcp::CPL("A Test DCP", dcp::TRAILER));
+ auto cpl = make_shared<dcp::CPL>("A Test DCP", dcp::ContentKind::TRAILER);
cpl->set_content_version (
dcp::ContentVersion("urn:uuid:75ac29aa-42ac-1234-ecae-49251abefd11","content-version-label-text")
);
cpl->set_main_picture_active_area (dcp::Size(1440, 1080));
cpl->set_version_number(1);
- shared_ptr<dcp::ReelMonoPictureAsset> pic(new dcp::ReelMonoPictureAsset(simple_picture("build/test/combine_input2", ""), 0));
- shared_ptr<dcp::ReelSoundAsset> sound(new dcp::ReelSoundAsset(first->cpls().front()->reels().front()->main_sound()->asset(), 0));
+ auto pic = make_shared<dcp::ReelMonoPictureAsset>(simple_picture("build/test/combine_input2", ""), 0);
+ auto sound = make_shared<dcp::ReelSoundAsset>(first->cpls().front()->reels().front()->main_sound()->asset(), 0);
auto reel = make_shared<dcp::Reel>(pic, sound);
reel->add (simple_markers());
cpl->add (reel);
second->add (cpl);
- second->write_xml (dcp::SMPTE);
+ second->write_xml (dcp::Standard::SMPTE);
remove_all (out);
vector<path> inputs;
BOOST_AUTO_TEST_CASE (cpl_metadata_bad_values_test)
{
- dcp::CPL cpl("", dcp::FEATURE);
+ dcp::CPL cpl("", dcp::ContentKind::FEATURE);
BOOST_CHECK_THROW (cpl.set_version_number(-1), dcp::BadSettingError);
vector<dcp::ContentVersion> cv;
dcp::MainSoundConfiguration msc("51/L,R,C,LFE,-,-");
BOOST_CHECK_EQUAL (msc.to_string(), "51/L,R,C,LFE,-,-");
BOOST_CHECK_EQUAL (msc.channels(), 6);
- BOOST_CHECK_EQUAL (msc.field(), dcp::FIVE_POINT_ONE);
- BOOST_CHECK_EQUAL (msc.mapping(0).get(), dcp::LEFT);
- BOOST_CHECK_EQUAL (msc.mapping(1).get(), dcp::RIGHT);
- BOOST_CHECK_EQUAL (msc.mapping(2).get(), dcp::CENTRE);
- BOOST_CHECK_EQUAL (msc.mapping(3).get(), dcp::LFE);
+ BOOST_CHECK_EQUAL (msc.field(), dcp::MCASoundField::FIVE_POINT_ONE);
+ BOOST_CHECK_EQUAL (msc.mapping(0).get(), dcp::Channel::LEFT);
+ BOOST_CHECK_EQUAL (msc.mapping(1).get(), dcp::Channel::RIGHT);
+ BOOST_CHECK_EQUAL (msc.mapping(2).get(), dcp::Channel::CENTRE);
+ BOOST_CHECK_EQUAL (msc.mapping(3).get(), dcp::Channel::LFE);
BOOST_CHECK (!msc.mapping(4));
BOOST_CHECK (!msc.mapping(5));
}
dcp::MainSoundConfiguration msc("71/L,R,C,LFE,-,-");
BOOST_CHECK_EQUAL (msc.to_string(), "71/L,R,C,LFE,-,-");
BOOST_CHECK_EQUAL (msc.channels(), 6);
- BOOST_CHECK_EQUAL (msc.field(), dcp::SEVEN_POINT_ONE);
- BOOST_CHECK_EQUAL (msc.mapping(0).get(), dcp::LEFT);
- BOOST_CHECK_EQUAL (msc.mapping(1).get(), dcp::RIGHT);
- BOOST_CHECK_EQUAL (msc.mapping(2).get(), dcp::CENTRE);
- BOOST_CHECK_EQUAL (msc.mapping(3).get(), dcp::LFE);
+ BOOST_CHECK_EQUAL (msc.field(), dcp::MCASoundField::SEVEN_POINT_ONE);
+ BOOST_CHECK_EQUAL (msc.mapping(0).get(), dcp::Channel::LEFT);
+ BOOST_CHECK_EQUAL (msc.mapping(1).get(), dcp::Channel::RIGHT);
+ BOOST_CHECK_EQUAL (msc.mapping(2).get(), dcp::Channel::CENTRE);
+ BOOST_CHECK_EQUAL (msc.mapping(3).get(), dcp::Channel::LFE);
BOOST_CHECK (!msc.mapping(4));
BOOST_CHECK (!msc.mapping(5));
}
dcp::MainSoundConfiguration msc("71/L,-,C,LFE,Lss,Rss");
BOOST_CHECK_EQUAL (msc.to_string(), "71/L,-,C,LFE,Lss,Rss");
BOOST_CHECK_EQUAL (msc.channels(), 6);
- BOOST_CHECK_EQUAL (msc.field(), dcp::SEVEN_POINT_ONE);
- BOOST_CHECK_EQUAL (msc.mapping(0).get(), dcp::LEFT);
+ BOOST_CHECK_EQUAL (msc.field(), dcp::MCASoundField::SEVEN_POINT_ONE);
+ BOOST_CHECK_EQUAL (msc.mapping(0).get(), dcp::Channel::LEFT);
BOOST_CHECK (!msc.mapping(1));
- BOOST_CHECK_EQUAL (msc.mapping(2).get(), dcp::CENTRE);
- BOOST_CHECK_EQUAL (msc.mapping(3).get(), dcp::LFE);
- BOOST_CHECK_EQUAL (msc.mapping(4).get(), dcp::LS);
- BOOST_CHECK_EQUAL (msc.mapping(5).get(), dcp::RS);
+ BOOST_CHECK_EQUAL (msc.mapping(2).get(), dcp::Channel::CENTRE);
+ BOOST_CHECK_EQUAL (msc.mapping(3).get(), dcp::Channel::LFE);
+ BOOST_CHECK_EQUAL (msc.mapping(4).get(), dcp::Channel::LS);
+ BOOST_CHECK_EQUAL (msc.mapping(5).get(), dcp::Channel::RS);
}
dcp::MainSoundConfiguration msc("71/L,-,C,LFE,Lss,Rss,-,-,-,-,-,-,-,-,-");
BOOST_CHECK_EQUAL (msc.to_string(), "71/L,-,C,LFE,Lss,Rss,-,-,-,-,-,-,-,-,-");
BOOST_CHECK_EQUAL (msc.channels(), 15);
- BOOST_CHECK_EQUAL (msc.field(), dcp::SEVEN_POINT_ONE);
- BOOST_CHECK_EQUAL (msc.mapping(0).get(), dcp::LEFT);
+ BOOST_CHECK_EQUAL (msc.field(), dcp::MCASoundField::SEVEN_POINT_ONE);
+ BOOST_CHECK_EQUAL (msc.mapping(0).get(), dcp::Channel::LEFT);
BOOST_CHECK (!msc.mapping(1));
- BOOST_CHECK_EQUAL (msc.mapping(2).get(), dcp::CENTRE);
- BOOST_CHECK_EQUAL (msc.mapping(3).get(), dcp::LFE);
- BOOST_CHECK_EQUAL (msc.mapping(4).get(), dcp::LS);
- BOOST_CHECK_EQUAL (msc.mapping(5).get(), dcp::RS);
+ BOOST_CHECK_EQUAL (msc.mapping(2).get(), dcp::Channel::CENTRE);
+ BOOST_CHECK_EQUAL (msc.mapping(3).get(), dcp::Channel::LFE);
+ BOOST_CHECK_EQUAL (msc.mapping(4).get(), dcp::Channel::LS);
+ BOOST_CHECK_EQUAL (msc.mapping(5).get(), dcp::Channel::RS);
for (int i = 6; i < 15; ++i) {
BOOST_CHECK (!msc.mapping(i));
}
dcp::MainSoundConfiguration msc("71/L,-,C,LFE,Lss,Rss,HI,VIN,-,-,Lrs,Rrs,DBOX,FSKSync,SLVS");
BOOST_CHECK_EQUAL (msc.to_string(), "71/L,-,C,LFE,Lss,Rss,HI,VIN,-,-,Lrs,Rrs,DBOX,FSKSync,SLVS");
BOOST_CHECK_EQUAL (msc.channels(), 15);
- BOOST_CHECK_EQUAL (msc.field(), dcp::SEVEN_POINT_ONE);
- BOOST_CHECK_EQUAL (msc.mapping(0).get(), dcp::LEFT);
+ BOOST_CHECK_EQUAL (msc.field(), dcp::MCASoundField::SEVEN_POINT_ONE);
+ BOOST_CHECK_EQUAL (msc.mapping(0).get(), dcp::Channel::LEFT);
BOOST_CHECK (!msc.mapping(1));
- BOOST_CHECK_EQUAL (msc.mapping(2).get(), dcp::CENTRE);
- BOOST_CHECK_EQUAL (msc.mapping(3).get(), dcp::LFE);
- BOOST_CHECK_EQUAL (msc.mapping(4).get(), dcp::LS);
- BOOST_CHECK_EQUAL (msc.mapping(5).get(), dcp::RS);
- BOOST_CHECK_EQUAL (msc.mapping(6).get(), dcp::HI);
- BOOST_CHECK_EQUAL (msc.mapping(7).get(), dcp::VI);
+ BOOST_CHECK_EQUAL (msc.mapping(2).get(), dcp::Channel::CENTRE);
+ BOOST_CHECK_EQUAL (msc.mapping(3).get(), dcp::Channel::LFE);
+ BOOST_CHECK_EQUAL (msc.mapping(4).get(), dcp::Channel::LS);
+ BOOST_CHECK_EQUAL (msc.mapping(5).get(), dcp::Channel::RS);
+ BOOST_CHECK_EQUAL (msc.mapping(6).get(), dcp::Channel::HI);
+ BOOST_CHECK_EQUAL (msc.mapping(7).get(), dcp::Channel::VI);
BOOST_CHECK (!msc.mapping(8));
BOOST_CHECK (!msc.mapping(9));
- BOOST_CHECK_EQUAL (msc.mapping(10).get(), dcp::BSL);
- BOOST_CHECK_EQUAL (msc.mapping(11).get(), dcp::BSR);
- BOOST_CHECK_EQUAL (msc.mapping(12).get(), dcp::MOTION_DATA);
- BOOST_CHECK_EQUAL (msc.mapping(13).get(), dcp::SYNC_SIGNAL);
- BOOST_CHECK_EQUAL (msc.mapping(14).get(), dcp::SIGN_LANGUAGE);
+ BOOST_CHECK_EQUAL (msc.mapping(10).get(), dcp::Channel::BSL);
+ BOOST_CHECK_EQUAL (msc.mapping(11).get(), dcp::Channel::BSR);
+ BOOST_CHECK_EQUAL (msc.mapping(12).get(), dcp::Channel::MOTION_DATA);
+ BOOST_CHECK_EQUAL (msc.mapping(13).get(), dcp::Channel::SYNC_SIGNAL);
+ BOOST_CHECK_EQUAL (msc.mapping(14).get(), dcp::Channel::SIGN_LANGUAGE);
}
BOOST_AUTO_TEST_CASE (luminance_test1)
{
- BOOST_CHECK_NO_THROW (dcp::Luminance(4, dcp::Luminance::CANDELA_PER_SQUARE_METRE));
- BOOST_CHECK_THROW (dcp::Luminance(-4, dcp::Luminance::CANDELA_PER_SQUARE_METRE), dcp::MiscError);
+ BOOST_CHECK_NO_THROW (dcp::Luminance(4, dcp::Luminance::Unit::CANDELA_PER_SQUARE_METRE));
+ BOOST_CHECK_THROW (dcp::Luminance(-4, dcp::Luminance::Unit::CANDELA_PER_SQUARE_METRE), dcp::MiscError);
}
);
dcp::Luminance lum (doc);
- BOOST_CHECK (lum.unit() == dcp::Luminance::CANDELA_PER_SQUARE_METRE);
+ BOOST_CHECK (lum.unit() == dcp::Luminance::Unit::CANDELA_PER_SQUARE_METRE);
BOOST_CHECK_CLOSE (lum.value(), 4.5, 0.1);
}
/* We tolerate out-of-range values when reading from XML */
dcp::Luminance lum (doc);
- BOOST_CHECK (lum.unit() == dcp::Luminance::CANDELA_PER_SQUARE_METRE);
+ BOOST_CHECK (lum.unit() == dcp::Luminance::Unit::CANDELA_PER_SQUARE_METRE);
BOOST_CHECK_CLOSE (lum.value(), -4.5, 0.1);
}
BOOST_CHECK (cpl.full_content_title_text_language().get() == "de");
BOOST_CHECK (cpl.release_territory().get() == "ES");
BOOST_CHECK_EQUAL (cpl.version_number().get(), 2);
- BOOST_CHECK_EQUAL (cpl.status().get(), dcp::FINAL);
+ BOOST_CHECK_EQUAL (cpl.status().get(), dcp::Status::FINAL);
BOOST_CHECK_EQUAL (cpl.chain().get(), "the-chain");
BOOST_CHECK_EQUAL (cpl.distributor().get(), "the-distributor");
BOOST_CHECK_EQUAL (cpl.facility().get(), "the-facility");
- BOOST_CHECK (cpl.luminance() == dcp::Luminance(4.5, dcp::Luminance::FOOT_LAMBERT));
+ BOOST_CHECK (cpl.luminance() == dcp::Luminance(4.5, dcp::Luminance::Unit::FOOT_LAMBERT));
dcp::MainSoundConfiguration msc(cpl.main_sound_configuration().get());
- BOOST_CHECK_EQUAL (msc.mapping(0).get(), dcp::LEFT);
- BOOST_CHECK_EQUAL (msc.mapping(1).get(), dcp::RIGHT);
- BOOST_CHECK_EQUAL (msc.mapping(2).get(), dcp::CENTRE);
- BOOST_CHECK_EQUAL (msc.mapping(3).get(), dcp::LFE);
+ BOOST_CHECK_EQUAL (msc.mapping(0).get(), dcp::Channel::LEFT);
+ BOOST_CHECK_EQUAL (msc.mapping(1).get(), dcp::Channel::RIGHT);
+ BOOST_CHECK_EQUAL (msc.mapping(2).get(), dcp::Channel::CENTRE);
+ BOOST_CHECK_EQUAL (msc.mapping(3).get(), dcp::Channel::LFE);
BOOST_CHECK (!msc.mapping(4));
BOOST_CHECK (!msc.mapping(5));
BOOST_CHECK (!msc.mapping(6));
BOOST_CHECK (!msc.mapping(10));
BOOST_CHECK (!msc.mapping(11));
BOOST_CHECK (!msc.mapping(12));
- BOOST_CHECK_EQUAL (msc.mapping(13).get(), dcp::SYNC_SIGNAL);
+ BOOST_CHECK_EQUAL (msc.mapping(13).get(), dcp::Channel::SYNC_SIGNAL);
BOOST_CHECK_EQUAL (cpl.main_sound_sample_rate().get(), 48000);
BOOST_CHECK (cpl.main_picture_stored_area().get() == dcp::Size(1998, 1080));
{
RNGFixer fix;
- dcp::CPL cpl("", dcp::FEATURE);
+ dcp::CPL cpl("", dcp::ContentKind::FEATURE);
cpl.set_issue_date ("2020-08-28T13:35:06+02:00");
vector<dcp::ContentVersion> cv;
cpl.set_full_content_title_text_language (dcp::LanguageTag("de"));
cpl.set_release_territory (dcp::LanguageTag::RegionSubtag("ES"));
cpl.set_version_number (2);
- cpl.set_status (dcp::FINAL);
+ cpl.set_status (dcp::Status::FINAL);
cpl.set_chain ("the-chain");
cpl.set_distributor ("the-distributor");
cpl.set_facility ("the-facility");
- cpl.set_luminance (dcp::Luminance(4.5, dcp::Luminance::FOOT_LAMBERT));
+ cpl.set_luminance (dcp::Luminance(4.5, dcp::Luminance::Unit::FOOT_LAMBERT));
cpl.set_issuer ("libdcp1.6.4devel");
cpl.set_creator ("libdcp1.6.4devel");
- dcp::MainSoundConfiguration msc(dcp::SEVEN_POINT_ONE, 16);
- msc.set_mapping (0, dcp::LEFT);
- msc.set_mapping (1, dcp::RIGHT);
- msc.set_mapping (2, dcp::CENTRE);
- msc.set_mapping (3, dcp::LFE);
- msc.set_mapping (13, dcp::SYNC_SIGNAL);
+ dcp::MainSoundConfiguration msc(dcp::MCASoundField::SEVEN_POINT_ONE, 16);
+ msc.set_mapping (0, dcp::Channel::LEFT);
+ msc.set_mapping (1, dcp::Channel::RIGHT);
+ msc.set_mapping (2, dcp::Channel::CENTRE);
+ msc.set_mapping (3, dcp::Channel::LFE);
+ msc.set_mapping (13, dcp::Channel::SYNC_SIGNAL);
cpl.set_main_sound_configuration (msc.to_string());
cpl.set_main_sound_sample_rate (48000);
lt.push_back(dcp::LanguageTag("fr-ZA"));
cpl.set_additional_subtitle_languages (lt);
- cpl.write_xml ("build/test/cpl_metadata_write_test1.xml", dcp::SMPTE, shared_ptr<dcp::CertificateChain>());
+ cpl.write_xml ("build/test/cpl_metadata_write_test1.xml", dcp::Standard::SMPTE, shared_ptr<dcp::CertificateChain>());
check_xml (
dcp::file_to_string("test/ref/cpl_metadata_test1.xml"),
dcp::file_to_string("build/test/cpl_metadata_write_test1.xml"),
BOOST_AUTO_TEST_CASE (cpl_metadata_roundtrip_test_1)
{
dcp::CPL cpl ("test/ref/cpl_metadata_test1.xml");
- cpl.write_xml ("build/test/cpl_metadata_roundtrip_test1.xml", dcp::SMPTE, shared_ptr<dcp::CertificateChain>());
+ cpl.write_xml ("build/test/cpl_metadata_roundtrip_test1.xml", dcp::Standard::SMPTE, shared_ptr<dcp::CertificateChain>());
vector<string> ignore;
ignore.push_back ("Id");
check_xml (
{
RNGFixer fix;
- dcp::CPL cpl("", dcp::FEATURE);
+ dcp::CPL cpl("", dcp::ContentKind::FEATURE);
cpl.set_issue_date ("2020-08-28T13:35:06+02:00");
cpl.set_content_version (dcp::ContentVersion("id", "version"));
cpl.set_issuer ("libdcp1.6.4devel");
cpl.set_creator ("libdcp1.6.4devel");
- dcp::MainSoundConfiguration msc(dcp::SEVEN_POINT_ONE, 16);
- msc.set_mapping (0, dcp::LEFT);
- msc.set_mapping (1, dcp::RIGHT);
- msc.set_mapping (2, dcp::CENTRE);
- msc.set_mapping (3, dcp::LFE);
- msc.set_mapping (13, dcp::SYNC_SIGNAL);
+ dcp::MainSoundConfiguration msc(dcp::MCASoundField::SEVEN_POINT_ONE, 16);
+ msc.set_mapping (0, dcp::Channel::LEFT);
+ msc.set_mapping (1, dcp::Channel::RIGHT);
+ msc.set_mapping (2, dcp::Channel::CENTRE);
+ msc.set_mapping (3, dcp::Channel::LFE);
+ msc.set_mapping (13, dcp::Channel::SYNC_SIGNAL);
cpl.set_main_sound_configuration (msc.to_string());
cpl.set_main_sound_sample_rate (48000);
reel->add (black_picture_asset("build/test/cpl_metadata_write_test1"));
cpl.add (reel);
- cpl.write_xml ("build/test/cpl_metadata_write_test2.xml", dcp::SMPTE, shared_ptr<dcp::CertificateChain>());
+ cpl.write_xml ("build/test/cpl_metadata_write_test2.xml", dcp::Standard::SMPTE, shared_ptr<dcp::CertificateChain>());
check_xml (
dcp::file_to_string("test/ref/cpl_metadata_test2.xml"),
dcp::file_to_string("build/test/cpl_metadata_write_test2.xml"),
BOOST_CHECK (!cpl.luminance());
dcp::MainSoundConfiguration msc(cpl.main_sound_configuration().get());
- BOOST_CHECK_EQUAL (msc.mapping(0).get(), dcp::LEFT);
- BOOST_CHECK_EQUAL (msc.mapping(1).get(), dcp::RIGHT);
- BOOST_CHECK_EQUAL (msc.mapping(2).get(), dcp::CENTRE);
- BOOST_CHECK_EQUAL (msc.mapping(3).get(), dcp::LFE);
+ BOOST_CHECK_EQUAL (msc.mapping(0).get(), dcp::Channel::LEFT);
+ BOOST_CHECK_EQUAL (msc.mapping(1).get(), dcp::Channel::RIGHT);
+ BOOST_CHECK_EQUAL (msc.mapping(2).get(), dcp::Channel::CENTRE);
+ BOOST_CHECK_EQUAL (msc.mapping(3).get(), dcp::Channel::LFE);
BOOST_CHECK (!msc.mapping(4));
BOOST_CHECK (!msc.mapping(5));
BOOST_CHECK (!msc.mapping(6));
BOOST_CHECK (!msc.mapping(10));
BOOST_CHECK (!msc.mapping(11));
BOOST_CHECK (!msc.mapping(12));
- BOOST_CHECK_EQUAL (msc.mapping(13).get(), dcp::SYNC_SIGNAL);
+ BOOST_CHECK_EQUAL (msc.mapping(13).get(), dcp::Channel::SYNC_SIGNAL);
BOOST_CHECK_EQUAL (cpl.main_sound_sample_rate().get(), 48000);
BOOST_CHECK (cpl.main_picture_stored_area().get() == dcp::Size(1998, 1080));
BOOST_AUTO_TEST_CASE (cpl_metadata_roundtrip_test_2)
{
dcp::CPL cpl ("test/ref/cpl_metadata_test2.xml");
- cpl.write_xml ("build/test/cpl_metadata_roundtrip_test2.xml", dcp::SMPTE, shared_ptr<dcp::CertificateChain>());
+ cpl.write_xml ("build/test/cpl_metadata_roundtrip_test2.xml", dcp::Standard::SMPTE, shared_ptr<dcp::CertificateChain>());
vector<string> ignore;
ignore.push_back ("Id");
check_xml (
BOOST_AUTO_TEST_CASE (cpl_ratings)
{
- dcp::CPL cpl ("annotation", dcp::FEATURE);
+ dcp::CPL cpl ("annotation", dcp::ContentKind::FEATURE);
vector<dcp::Rating> ratings;
ratings.push_back (dcp::Rating("http://www.mpaa.org/2003-ratings", "PG-13"));
shared_ptr<dcp::Reel> reel(new dcp::Reel());
cpl.add (reel);
- cpl.write_xml ("build/test/cpl_ratings.xml", dcp::SMPTE, std::shared_ptr<dcp::CertificateChain>());
+ cpl.write_xml ("build/test/cpl_ratings.xml", dcp::Standard::SMPTE, {});
vector<string> ignore;
ignore.push_back ("Id");
);
dcp::CPL cpl2 ("build/test/cpl_ratings.xml");
- vector<dcp::Rating> ratings2 = cpl2.ratings ();
+ auto ratings2 = cpl2.ratings ();
BOOST_TEST(ratings == ratings2);
}
/*
- Copyright (C) 2014-2019 Carl Hetherington <cth@carlh.net>
+ Copyright (C) 2014-2021 Carl Hetherington <cth@carlh.net>
This file is part of libdcp.
using std::string;
using std::shared_ptr;
+using std::make_shared;
static void
check (shared_ptr<dcp::ReelMonoPictureAsset> pa, dcp::Fraction far, string sar)
pa->set_screen_aspect_ratio (far);
xmlpp::Document doc;
xmlpp::Element* el = doc.create_root_node ("Test");
- pa->write_to_cpl (el, dcp::INTEROP);
+ pa->write_to_cpl (el, dcp::Standard::INTEROP);
cxml::Node node (el);
BOOST_CHECK_EQUAL (node.node_child("MainPicture")->string_child ("ScreenAspectRatio"), sar);
*/
BOOST_AUTO_TEST_CASE (cpl_sar)
{
- shared_ptr<dcp::ReelMonoPictureAsset> pa (
- new dcp::ReelMonoPictureAsset (
- shared_ptr<dcp::MonoPictureAsset> (new dcp::MonoPictureAsset ("test/ref/DCP/dcp_test1/video.mxf")),
- 0
- )
+ auto pa = make_shared<dcp::ReelMonoPictureAsset>(
+ make_shared<dcp::MonoPictureAsset>("test/ref/DCP/dcp_test1/video.mxf"), 0
);
/* Easy ones */
using std::string;
using std::shared_ptr;
using std::dynamic_pointer_cast;
+using std::make_shared;
using boost::shared_array;
/** Create a DCP with interop subtitles and check that the font is written and read back correctly */
subs->write (directory / "frobozz.xml");
check_file ("test/data/dummy.ttf", "build/test/interop_dcp_font_test/font_0.ttf");
- shared_ptr<dcp::Reel> reel (new dcp::Reel ());
- reel->add (shared_ptr<dcp::ReelAsset> (new dcp::ReelSubtitleAsset (subs, dcp::Fraction (24, 1), 24, 0)));
+ auto reel = make_shared<dcp::Reel>();
+ reel->add (make_shared<dcp::ReelSubtitleAsset>(subs, dcp::Fraction (24, 1), 24, 0));
- shared_ptr<dcp::CPL> cpl (new dcp::CPL ("", dcp::TRAILER));
+ auto cpl = make_shared<dcp::CPL>("", dcp::ContentKind::TRAILER);
cpl->add (reel);
dcp.add (cpl);
- dcp.write_xml (dcp::INTEROP);
+ dcp.write_xml (dcp::Standard::INTEROP);
dcp::DCP dcp2 (directory);
dcp2.read ();
- shared_ptr<dcp::SubtitleAsset> subs2 = dynamic_pointer_cast<dcp::SubtitleAsset> (
- dcp2.cpls().front()->reels().front()->main_subtitle()->asset_ref().asset()
+ auto subs2 = dynamic_pointer_cast<dcp::SubtitleAsset> (
+ dcp2.cpls()[0]->reels()[0]->main_subtitle()->asset_ref().asset()
);
BOOST_REQUIRE (subs2);
BOOST_REQUIRE_EQUAL (subs2->_fonts.size(), 1);
- boost::uintmax_t const size = boost::filesystem::file_size ("test/data/dummy.ttf");
- FILE* f = dcp::fopen_boost ("test/data/dummy.ttf", "rb");
+ auto const size = boost::filesystem::file_size ("test/data/dummy.ttf");
+ auto f = dcp::fopen_boost ("test/data/dummy.ttf", "rb");
BOOST_REQUIRE (f);
shared_array<uint8_t> ref (new uint8_t[size]);
fread (ref.get(), 1, size, f);
boost::filesystem::path directory = "build/test/smpte_dcp_font_test";
dcp::DCP dcp (directory);
- shared_ptr<dcp::SMPTESubtitleAsset> subs (new dcp::SMPTESubtitleAsset ());
+ auto subs = make_shared<dcp::SMPTESubtitleAsset>();
subs->add_font ("theFontId", dcp::ArrayData("test/data/dummy.ttf"));
subs->write (directory / "frobozz.mxf");
- shared_ptr<dcp::Reel> reel (new dcp::Reel ());
- reel->add (shared_ptr<dcp::ReelAsset> (new dcp::ReelSubtitleAsset (subs, dcp::Fraction (24, 1), 24, 0)));
+ auto reel = make_shared<dcp::Reel>();
+ reel->add (make_shared<dcp::ReelSubtitleAsset>(subs, dcp::Fraction (24, 1), 24, 0));
- shared_ptr<dcp::CPL> cpl (new dcp::CPL ("", dcp::TRAILER));
+ auto cpl = make_shared<dcp::CPL>("", dcp::ContentKind::TRAILER);
cpl->add (reel);
dcp.add (cpl);
- dcp.write_xml (dcp::SMPTE);
+ dcp.write_xml (dcp::Standard::SMPTE);
dcp::DCP dcp2 (directory);
dcp2.read ();
- shared_ptr<dcp::SubtitleAsset> subs2 = dynamic_pointer_cast<dcp::SubtitleAsset> (
+ auto subs2 = dynamic_pointer_cast<dcp::SubtitleAsset> (
dcp2.cpls().front()->reels().front()->main_subtitle()->asset_ref().asset()
);
BOOST_REQUIRE (subs2);
BOOST_REQUIRE_EQUAL (subs2->_fonts.size(), 1);
- boost::uintmax_t const size = boost::filesystem::file_size ("test/data/dummy.ttf");
- FILE* f = dcp::fopen_boost ("test/data/dummy.ttf", "rb");
+ auto const size = boost::filesystem::file_size ("test/data/dummy.ttf");
+ auto f = dcp::fopen_boost ("test/data/dummy.ttf", "rb");
BOOST_REQUIRE (f);
shared_array<uint8_t> ref (new uint8_t[size]);
fread (ref.get(), 1, size, f);
RNGFixer fixer;
make_simple("build/test/DCP/dcp_test1")->write_xml(
- dcp::SMPTE, "OpenDCP 0.0.25", "OpenDCP 0.0.25", "2012-07-17T04:45:18+00:00", "A Test DCP"
+ dcp::Standard::SMPTE, "OpenDCP 0.0.25", "OpenDCP 0.0.25", "2012-07-17T04:45:18+00:00", "A Test DCP"
);
/* build/test/DCP/dcp_test1 is checked against test/ref/DCP/dcp_test1 by run/tests */
boost::filesystem::remove_all ("build/test/DCP/dcp_test2");
boost::filesystem::create_directories ("build/test/DCP/dcp_test2");
dcp::DCP d ("build/test/DCP/dcp_test2");
- shared_ptr<dcp::CPL> cpl (new dcp::CPL ("A Test DCP", dcp::FEATURE));
+ auto cpl = make_shared<dcp::CPL>("A Test DCP", dcp::ContentKind::FEATURE);
cpl->set_content_version (
dcp::ContentVersion("urn:uri:81fb54df-e1bf-4647-8788-ea7ba154375b_2012-07-17T04:45:18+00:00", "81fb54df-e1bf-4647-8788-ea7ba154375b_2012-07-17T04:45:18+00:00")
);
cpl->set_issue_date ("2012-07-17T04:45:18+00:00");
cpl->set_annotation_text ("A Test DCP");
- shared_ptr<dcp::StereoPictureAsset> mp (new dcp::StereoPictureAsset (dcp::Fraction (24, 1), dcp::SMPTE));
+ shared_ptr<dcp::StereoPictureAsset> mp (new dcp::StereoPictureAsset (dcp::Fraction (24, 1), dcp::Standard::SMPTE));
mp->set_metadata (mxf_meta);
shared_ptr<dcp::PictureAssetWriter> picture_writer = mp->start_write ("build/test/DCP/dcp_test2/video.mxf", false);
dcp::ArrayData j2c ("test/data/flat_red.j2c");
}
picture_writer->finalize ();
- shared_ptr<dcp::SoundAsset> ms (new dcp::SoundAsset(dcp::Fraction(24, 1), 48000, 1, dcp::LanguageTag("en-GB"), dcp::SMPTE));
+ shared_ptr<dcp::SoundAsset> ms (new dcp::SoundAsset(dcp::Fraction(24, 1), 48000, 1, dcp::LanguageTag("en-GB"), dcp::Standard::SMPTE));
ms->set_metadata (mxf_meta);
shared_ptr<dcp::SoundAssetWriter> sound_writer = ms->start_write ("build/test/DCP/dcp_test2/audio.mxf", vector<dcp::Channel>());
sound_writer->finalize ();
- cpl->add (shared_ptr<dcp::Reel> (
- new dcp::Reel (
- shared_ptr<dcp::ReelStereoPictureAsset> (new dcp::ReelStereoPictureAsset (mp, 0)),
- shared_ptr<dcp::ReelSoundAsset> (new dcp::ReelSoundAsset (ms, 0))
- )
+ cpl->add (make_shared<dcp::Reel>(
+ make_shared<dcp::ReelStereoPictureAsset>(mp, 0),
+ make_shared<dcp::ReelSoundAsset>(ms, 0)
));
d.add (cpl);
- d.write_xml (dcp::SMPTE, "OpenDCP 0.0.25", "OpenDCP 0.0.25", "2012-07-17T04:45:18+00:00", "Created by libdcp");
+ d.write_xml (dcp::Standard::SMPTE, "OpenDCP 0.0.25", "OpenDCP 0.0.25", "2012-07-17T04:45:18+00:00", "Created by libdcp");
/* build/test/DCP/dcp_test2 is checked against test/ref/DCP/dcp_test2 by run/tests */
}
reel->add(make_shared<dcp::ReelMonoPictureAsset>(make_shared<dcp::MonoPictureAsset>(path("build") / "test" / name / picture), 0));
auto reader = A_sound->asset()->start_read();
- auto sound = make_shared<dcp::SoundAsset>(A_sound->asset()->edit_rate(), A_sound->asset()->sampling_rate(), A_sound->asset()->channels(), dcp::LanguageTag("en-US"), dcp::SMPTE);
+ auto sound = make_shared<dcp::SoundAsset>(A_sound->asset()->edit_rate(), A_sound->asset()->sampling_rate(), A_sound->asset()->channels(), dcp::LanguageTag("en-US"), dcp::Standard::SMPTE);
auto writer = sound->start_write(path("build") / "test" / name / "pcm_8246f87f-e1df-4c42-a290-f3b3069ff021.mxf", {});
bool need_to_modify = modify;
reel->add(make_shared<dcp::ReelSoundAsset>(sound, 0));
reel->add(simple_markers());
- auto cpl = make_shared<dcp::CPL>("A Test DCP", dcp::TRAILER);
+ auto cpl = make_shared<dcp::CPL>("A Test DCP", dcp::ContentKind::TRAILER);
cpl->add (reel);
B.add (cpl);
- B.write_xml (dcp::SMPTE);
+ B.write_xml (dcp::Standard::SMPTE);
dcp::EqualityOptions eq;
eq.reel_hashes_can_differ = true;
boost::filesystem::remove_all ("build/test/DCP/dcp_test5");
boost::filesystem::create_directories ("build/test/DCP/dcp_test5");
dcp::DCP d ("build/test/DCP/dcp_test5");
- shared_ptr<dcp::CPL> cpl (new dcp::CPL ("A Test DCP", dcp::FEATURE));
+ auto cpl = make_shared<dcp::CPL>("A Test DCP", dcp::ContentKind::FEATURE);
cpl->set_content_version (
dcp::ContentVersion("urn:uri:81fb54df-e1bf-4647-8788-ea7ba154375b_2012-07-17T04:45:18+00:00", "81fb54df-e1bf-4647-8788-ea7ba154375b_2012-07-17T04:45:18+00:00")
);
cpl->set_issue_date ("2012-07-17T04:45:18+00:00");
cpl->set_annotation_text ("A Test DCP");
- shared_ptr<dcp::MonoPictureAsset> mp (new dcp::MonoPictureAsset (dcp::Fraction (24, 1), dcp::SMPTE));
+ auto mp = make_shared<dcp::MonoPictureAsset>(dcp::Fraction (24, 1), dcp::Standard::SMPTE);
mp->set_metadata (mxf_meta);
shared_ptr<dcp::PictureAssetWriter> picture_writer = mp->start_write ("build/test/DCP/dcp_test5/video.mxf", false);
dcp::ArrayData j2c ("test/data/flat_red.j2c");
}
picture_writer->finalize ();
- shared_ptr<dcp::SoundAsset> ms (new dcp::SoundAsset(dcp::Fraction(24, 1), 48000, 1, dcp::LanguageTag("en-GB"), dcp::SMPTE));
+ auto ms = make_shared<dcp::SoundAsset>(dcp::Fraction(24, 1), 48000, 1, dcp::LanguageTag("en-GB"), dcp::Standard::SMPTE);
ms->set_metadata (mxf_meta);
shared_ptr<dcp::SoundAssetWriter> sound_writer = ms->start_write ("build/test/DCP/dcp_test5/audio.mxf", vector<dcp::Channel>());
d.add (cpl);
- d.write_xml (dcp::SMPTE, "OpenDCP 0.0.25", "OpenDCP 0.0.25", "2012-07-17T04:45:18+00:00", "Created by libdcp");
+ d.write_xml (dcp::Standard::SMPTE, "OpenDCP 0.0.25", "OpenDCP 0.0.25", "2012-07-17T04:45:18+00:00", "Created by libdcp");
/* build/test/DCP/dcp_test5 is checked against test/ref/DCP/dcp_test5 by run/tests */
}
RNGFixer fix;
make_simple("build/test/DCP/dcp_test7")->write_xml(
- dcp::INTEROP, "OpenDCP 0.0.25", "OpenDCP 0.0.25", "2012-07-17T04:45:18+00:00", "Created by libdcp"
+ dcp::Standard::INTEROP, "OpenDCP 0.0.25", "OpenDCP 0.0.25", "2012-07-17T04:45:18+00:00", "Created by libdcp"
);
/* build/test/DCP/dcp_test7 is checked against test/ref/DCP/dcp_test7 by run/tests */
BOOST_CHECK_EQUAL (t.s, 34);
BOOST_CHECK_EQUAL (t.m, 18);
BOOST_CHECK_EQUAL (t.h, 11);
- BOOST_CHECK_EQUAL (t.as_string(dcp::INTEROP), "11:18:34:073");
+ BOOST_CHECK_EQUAL (t.as_string(dcp::Standard::INTEROP), "11:18:34:073");
/* Use a tcr of 24 so that the editable event is a frame */
dcp::Time a (3, 2, 3, 4, 24);
BOOST_CHECK_EQUAL (r.m, 58);
BOOST_CHECK_EQUAL (r.s, 58);
BOOST_CHECK_EQUAL (r.e, 23);
- BOOST_CHECK_EQUAL (r.as_string(dcp::INTEROP), "00:58:58:023");
+ BOOST_CHECK_EQUAL (r.as_string(dcp::Standard::INTEROP), "00:58:58:023");
/* Different tcr (25) */
a = dcp::Time (1, 58, 56, 2, 25);
BOOST_CHECK_EQUAL (r.m, 6);
BOOST_CHECK_EQUAL (r.s, 8);
BOOST_CHECK_EQUAL (r.e, 3);
- BOOST_CHECK_EQUAL (r.as_string(dcp::INTEROP), "03:06:08:003");
- BOOST_CHECK_EQUAL (r.as_string(dcp::SMPTE), "03:06:08:03");
+ BOOST_CHECK_EQUAL (r.as_string(dcp::Standard::INTEROP), "03:06:08:003");
+ BOOST_CHECK_EQUAL (r.as_string(dcp::Standard::SMPTE), "03:06:08:03");
/* Another arbitrary tcr (30) */
a = dcp::Time (24, 12, 6, 3, 30);
/** Very simple tests of Effect-related stuff */
BOOST_AUTO_TEST_CASE (effect_test)
{
- BOOST_CHECK_EQUAL (dcp::effect_to_string (dcp::NONE), "none");
- BOOST_CHECK_EQUAL (dcp::effect_to_string (dcp::BORDER), "border");
- BOOST_CHECK_EQUAL (dcp::effect_to_string (dcp::SHADOW), "shadow");
+ BOOST_CHECK_EQUAL (dcp::effect_to_string(dcp::Effect::NONE), "none");
+ BOOST_CHECK_EQUAL (dcp::effect_to_string(dcp::Effect::BORDER), "border");
+ BOOST_CHECK_EQUAL (dcp::effect_to_string(dcp::Effect::SHADOW), "shadow");
- BOOST_CHECK_THROW (dcp::effect_to_string ((dcp::Effect) 42), dcp::MiscError);
+ BOOST_CHECK_THROW (dcp::effect_to_string((dcp::Effect) 42), dcp::MiscError);
- BOOST_CHECK_EQUAL (dcp::string_to_effect ("none"), dcp::NONE);
- BOOST_CHECK_EQUAL (dcp::string_to_effect ("border"), dcp::BORDER);
- BOOST_CHECK_EQUAL (dcp::string_to_effect ("shadow"), dcp::SHADOW);
- BOOST_CHECK_THROW (dcp::string_to_effect ("fish"), dcp::ReadError);
+ BOOST_CHECK_EQUAL (dcp::string_to_effect("none"), dcp::Effect::NONE);
+ BOOST_CHECK_EQUAL (dcp::string_to_effect("border"), dcp::Effect::BORDER);
+ BOOST_CHECK_EQUAL (dcp::string_to_effect("shadow"), dcp::Effect::SHADOW);
+ BOOST_CHECK_THROW (dcp::string_to_effect("fish"), dcp::ReadError);
}
signer->add (dcp::Certificate (dcp::file_to_string ("test/ref/crypt/leaf.signed.pem")));
signer->set_key (dcp::file_to_string ("test/ref/crypt/leaf.key"));
- shared_ptr<dcp::CPL> cpl (new dcp::CPL ("A Test DCP", dcp::FEATURE));
+ shared_ptr<dcp::CPL> cpl (new dcp::CPL ("A Test DCP", dcp::ContentKind::FEATURE));
dcp::Key key;
- shared_ptr<dcp::MonoPictureAsset> mp (new dcp::MonoPictureAsset (dcp::Fraction (24, 1), dcp::SMPTE));
+ shared_ptr<dcp::MonoPictureAsset> mp (new dcp::MonoPictureAsset (dcp::Fraction (24, 1), dcp::Standard::SMPTE));
mp->set_metadata (mxf_metadata);
mp->set_key (key);
}
writer->finalize ();
- shared_ptr<dcp::SoundAsset> ms (new dcp::SoundAsset (dcp::Fraction (24, 1), 48000, 1, dcp::LanguageTag("en-GB"), dcp::SMPTE));
+ shared_ptr<dcp::SoundAsset> ms (new dcp::SoundAsset (dcp::Fraction (24, 1), 48000, 1, dcp::LanguageTag("en-GB"), dcp::Standard::SMPTE));
ms->set_metadata (mxf_metadata);
ms->set_key (key);
shared_ptr<dcp::SoundAssetWriter> sound_writer = ms->start_write ("build/test/DCP/encryption_test/audio.mxf", vector<dcp::Channel>());
d.add (cpl);
- d.write_xml (dcp::SMPTE, "OpenDCP 0.0.25", "OpenDCP 0.0.25", "2012-07-17T04:45:18+00:00", "Created by libdcp", signer);
+ d.write_xml (dcp::Standard::SMPTE, "OpenDCP 0.0.25", "OpenDCP 0.0.25", "2012-07-17T04:45:18+00:00", "Created by libdcp", signer);
dcp::DecryptedKDM kdm (
cpl,
"2012-07-17T04:45:18+00:00"
);
- kdm.encrypt (signer, signer->leaf(), vector<string>(), dcp::MODIFIED_TRANSITIONAL_1, true, 0).as_xml ("build/test/encryption_test.kdm.xml");
+ kdm.encrypt (signer, signer->leaf(), vector<string>(), dcp::Formulation::MODIFIED_TRANSITIONAL_1, true, 0).as_xml("build/test/encryption_test.kdm.xml");
int r = system (
"xmllint --path schema --nonet --noout --schema schema/SMPTE-430-1-2006-Amd-1-2009-KDM.xsd build/test/encryption_test.kdm.xml "
using std::string;
using std::shared_ptr;
+using std::make_shared;
static void
check (unsigned int* seed, shared_ptr<dcp::PictureAssetWriter> writer, string hash)
/** Test the hashing of data written to JPEG2000 MXFs with some random inputs */
BOOST_AUTO_TEST_CASE (frame_info_hash_test)
{
- shared_ptr<dcp::MonoPictureAsset> mp (new dcp::MonoPictureAsset (dcp::Fraction (24, 1), dcp::SMPTE));
- shared_ptr<dcp::PictureAssetWriter> writer = mp->start_write ("build/test/frame_info_hash_test.mxf", false);
+ auto mp = make_shared<dcp::MonoPictureAsset>(dcp::Fraction (24, 1), dcp::Standard::SMPTE);
+ auto writer = mp->start_write ("build/test/frame_info_hash_test.mxf", false);
unsigned int seed = 42;
signer->set_key(dcp::file_to_string("test/data/private.key"));
dcp::EncryptedKDM kdm = decrypted.encrypt (
- signer, signer->leaf(), vector<string>(), dcp::MODIFIED_TRANSITIONAL_1, picture, audio
+ signer, signer->leaf(), vector<string>(), dcp::Formulation::MODIFIED_TRANSITIONAL_1, picture, audio
);
/* Check that we can pass this through correctly */
auto signer = make_shared<dcp::CertificateChain>(dcp::file_to_string("test/data/certificate_chain"));
signer->set_key(dcp::file_to_string("test/data/private.key"));
- auto asset = make_shared<dcp::MonoPictureAsset>(dcp::Fraction(24, 1), dcp::SMPTE);
+ auto asset = make_shared<dcp::MonoPictureAsset>(dcp::Fraction(24, 1), dcp::Standard::SMPTE);
asset->set_key (dcp::Key());
auto writer = asset->start_write ("build/test/validity_period_test1.mxf", false);
dcp::ArrayData frame ("test/data/flat_red.j2c");
writer->write (frame.data(), frame.size());
auto reel = make_shared<dcp::Reel>();
reel->add(make_shared<dcp::ReelMonoPictureAsset>(asset, 0));
- auto cpl = make_shared<dcp::CPL>("test", dcp::FEATURE);
+ auto cpl = make_shared<dcp::CPL>("test", dcp::ContentKind::FEATURE);
cpl->add(reel);
/* This certificate_chain is valid from 26/12/2012 to 24/12/2022 */
BOOST_CHECK_NO_THROW(
dcp::DecryptedKDM(
cpl, dcp::Key(dcp::file_to_string("test/data/private.key")), dcp::LocalTime("2015-01-01T00:00:00"), dcp::LocalTime("2017-07-31T00:00:00"), "", "", ""
- ).encrypt(signer, signer->leaf(), vector<string>(), dcp::MODIFIED_TRANSITIONAL_1, true, optional<int>())
+ ).encrypt(signer, signer->leaf(), vector<string>(), dcp::Formulation::MODIFIED_TRANSITIONAL_1, true, optional<int>())
);
/* Starts too early */
BOOST_CHECK_THROW(
dcp::DecryptedKDM(
cpl, dcp::Key(dcp::file_to_string("test/data/private.key")), dcp::LocalTime("1981-01-01T00:00:00"), dcp::LocalTime("2017-07-31T00:00:00"), "", "", ""
- ).encrypt(signer, signer->leaf(), vector<string>(), dcp::MODIFIED_TRANSITIONAL_1, true, optional<int>()),
+ ).encrypt(signer, signer->leaf(), vector<string>(), dcp::Formulation::MODIFIED_TRANSITIONAL_1, true, optional<int>()),
dcp::BadKDMDateError
);
BOOST_CHECK_THROW(
dcp::DecryptedKDM(
cpl, dcp::Key(dcp::file_to_string("test/data/private.key")), dcp::LocalTime("2015-01-01T00:00:00"), dcp::LocalTime("2035-07-31T00:00:00"), "", "", ""
- ).encrypt(signer, signer->leaf(), vector<string>(), dcp::MODIFIED_TRANSITIONAL_1, true, optional<int>()),
+ ).encrypt(signer, signer->leaf(), vector<string>(), dcp::Formulation::MODIFIED_TRANSITIONAL_1, true, optional<int>()),
dcp::BadKDMDateError
);
BOOST_CHECK_THROW(
dcp::DecryptedKDM(
cpl, dcp::Key(dcp::file_to_string("test/data/private.key")), dcp::LocalTime("1981-01-01T00:00:00"), dcp::LocalTime("2035-07-31T00:00:00"), "", "", ""
- ).encrypt(signer, signer->leaf(), vector<string>(), dcp::MODIFIED_TRANSITIONAL_1, true, optional<int>()),
+ ).encrypt(signer, signer->leaf(), vector<string>(), dcp::Formulation::MODIFIED_TRANSITIONAL_1, true, optional<int>()),
dcp::BadKDMDateError
);
}
BOOST_AUTO_TEST_CASE (markers_write_test)
{
- dcp::CPL cpl("Markers test", dcp::TEST);
+ dcp::CPL cpl("Markers test", dcp::ContentKind::TEST);
auto asset = make_shared<dcp::ReelMarkersAsset>(dcp::Fraction(24, 1), 432000, 0);
asset->set (dcp::Marker::FFOC, dcp::Time(1, 1, 9, 16, 24));
cpl.add (reel);
- cpl.write_xml ("build/test/markers_test.xml", dcp::SMPTE, shared_ptr<dcp::CertificateChain>());
+ cpl.write_xml ("build/test/markers_test.xml", dcp::Standard::SMPTE, {});
}
static void
reel->add (black_picture_asset(dcp::String::compose("build/test/parse_mca_descriptors_from_mxf_test%1", i), 24));
reel->add (reel_sound_asset);
- dcp::CPL cpl("", dcp::FEATURE);
+ dcp::CPL cpl("", dcp::ContentKind::FEATURE);
cpl.add (reel);
cpl.set_main_sound_configuration("51/L,R,C,LFE,Ls,Rs");
cpl.set_main_sound_sample_rate(48000);
cpl.set_main_picture_stored_area(dcp::Size(1998, 1080));
cpl.set_main_picture_active_area(dcp::Size(1998, 1080));
- cpl.write_xml (dcp::String::compose("build/test/parse_mca_descriptors_from_mxf_test%1/cpl.xml", i), dcp::SMPTE, shared_ptr<dcp::CertificateChain>());
+ cpl.write_xml (dcp::String::compose("build/test/parse_mca_descriptors_from_mxf_test%1/cpl.xml", i), dcp::Standard::SMPTE, shared_ptr<dcp::CertificateChain>());
cxml::Document ref("CompositionPlaylist", private_test / dcp::String::compose("51_sound_with_mca_%1.cpl", i));
cxml::Document check("CompositionPlaylist", dcp::String::compose("build/test/parse_mca_descriptors_from_mxf_test%1/cpl.xml", i));
/** Reproduce the MCA tags from one of the example files using libdcp */
BOOST_AUTO_TEST_CASE (write_mca_descriptors_to_mxf_test)
{
- shared_ptr<dcp::SoundAsset> sound_asset(new dcp::SoundAsset(dcp::Fraction(24, 1), 48000, 6, dcp::LanguageTag("en-US"), dcp::SMPTE));
+ shared_ptr<dcp::SoundAsset> sound_asset(new dcp::SoundAsset(dcp::Fraction(24, 1), 48000, 6, dcp::LanguageTag("en-US"), dcp::Standard::SMPTE));
vector<dcp::Channel> channels;
- channels.push_back (dcp::LEFT);
- channels.push_back (dcp::RIGHT);
- channels.push_back (dcp::CENTRE);
- channels.push_back (dcp::LFE);
- channels.push_back (dcp::LS);
- channels.push_back (dcp::RS);
+ channels.push_back (dcp::Channel::LEFT);
+ channels.push_back (dcp::Channel::RIGHT);
+ channels.push_back (dcp::Channel::CENTRE);
+ channels.push_back (dcp::Channel::LFE);
+ channels.push_back (dcp::Channel::LS);
+ channels.push_back (dcp::Channel::RS);
shared_ptr<dcp::SoundAssetWriter> writer = sound_asset->start_write("build/test/write_mca_descriptors_to_mxf_test.mxf", channels);
float* samples[6];
reel->add (black_picture_asset("build/test/write_mca_descriptors_to_mxf_test", 24));
reel->add (reel_sound_asset);
- dcp::CPL cpl("", dcp::FEATURE);
+ dcp::CPL cpl("", dcp::ContentKind::FEATURE);
cpl.add (reel);
cpl.set_main_sound_configuration("51/L,R,C,LFE,Ls,Rs");
cpl.set_main_sound_sample_rate(48000);
cpl.set_main_picture_stored_area(dcp::Size(1998, 1080));
cpl.set_main_picture_active_area(dcp::Size(1998, 1080));
- cpl.write_xml ("build/test/write_mca_descriptors_to_mxf_test/cpl.xml", dcp::SMPTE, shared_ptr<dcp::CertificateChain>());
+ cpl.write_xml ("build/test/write_mca_descriptors_to_mxf_test/cpl.xml", dcp::Standard::SMPTE, shared_ptr<dcp::CertificateChain>());
cxml::Document ref("CompositionPlaylist", private_test / "51_sound_with_mca_1.cpl");
cxml::Document check("CompositionPlaylist", "build/test/write_mca_descriptors_to_mxf_test/cpl.xml");
BOOST_REQUIRE (cpls[0]->annotation_text());
BOOST_CHECK_EQUAL (cpls[0]->annotation_text().get(), "A Test DCP");
- BOOST_CHECK_EQUAL (cpls[0]->content_kind(), dcp::TRAILER);
+ BOOST_CHECK_EQUAL (cpls[0]->content_kind(), dcp::ContentKind::TRAILER);
BOOST_REQUIRE (d.standard());
- BOOST_CHECK_EQUAL (d.standard(), dcp::SMPTE);
+ BOOST_CHECK_EQUAL (d.standard(), dcp::Standard::SMPTE);
}
/** Read an Interop DCP that is in git and make sure that basic stuff is read in correctly */
BOOST_REQUIRE (cpls[0]->annotation_text());
BOOST_CHECK_EQUAL (cpls[0]->annotation_text().get(), "Test_FTR-1_F-119_10_2K_20160524_IOP_OV");
- BOOST_CHECK_EQUAL (cpls[0]->content_kind(), dcp::FEATURE);
+ BOOST_CHECK_EQUAL (cpls[0]->content_kind(), dcp::ContentKind::FEATURE);
BOOST_REQUIRE (d.standard());
- BOOST_CHECK_EQUAL (d.standard(), dcp::INTEROP);
+ BOOST_CHECK_EQUAL (d.standard(), dcp::Standard::INTEROP);
}
dcp::Time (0, 0, 5, 198, 250),
dcp::Time (0, 0, 7, 115, 250),
0,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.15,
- dcp::VALIGN_BOTTOM,
- dcp::DIRECTION_LTR,
+ dcp::VAlign::BOTTOM,
+ dcp::Direction::LTR,
"My jacket was Idi Amin's",
- dcp::BORDER,
+ dcp::Effect::BORDER,
dcp::Colour (0, 0, 0),
dcp::Time (0, 0, 0, 1, 250),
dcp::Time (0, 0, 0, 1, 250)
dcp::Time (0, 0, 7, 177, 250),
dcp::Time (0, 0, 11, 31, 250),
0,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.21,
- dcp::VALIGN_BOTTOM,
- dcp::DIRECTION_LTR,
+ dcp::VAlign::BOTTOM,
+ dcp::Direction::LTR,
"My corset was H.M. The Queen's",
- dcp::BORDER,
+ dcp::Effect::BORDER,
dcp::Colour (0, 0, 0),
dcp::Time (0, 0, 0, 1, 250),
dcp::Time (0, 0, 0, 1, 250)
dcp::Time (0, 0, 7, 177, 250),
dcp::Time (0, 0, 11, 31, 250),
0,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.15,
- dcp::VALIGN_BOTTOM,
- dcp::DIRECTION_LTR,
+ dcp::VAlign::BOTTOM,
+ dcp::Direction::LTR,
"My large wonderbra",
- dcp::BORDER,
+ dcp::Effect::BORDER,
dcp::Colour (0, 0, 0),
dcp::Time (0, 0, 0, 1, 250),
dcp::Time (0, 0, 0, 1, 250)
dcp::Time (0, 0, 11, 94, 250),
dcp::Time (0, 0, 13, 63, 250),
0,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.15,
- dcp::VALIGN_BOTTOM,
- dcp::DIRECTION_LTR,
+ dcp::VAlign::BOTTOM,
+ dcp::Direction::LTR,
"Once belonged to the Shah",
- dcp::BORDER,
+ dcp::Effect::BORDER,
dcp::Colour (0, 0, 0),
dcp::Time (0, 0, 0, 1, 250),
dcp::Time (0, 0, 0, 1, 250)
dcp::Time (0, 0, 13, 104, 250),
dcp::Time (0, 0, 15, 177, 250),
0,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.15,
- dcp::VALIGN_BOTTOM,
- dcp::DIRECTION_LTR,
+ dcp::VAlign::BOTTOM,
+ dcp::Direction::LTR,
"And these are Roy Hattersley's jeans",
- dcp::BORDER,
+ dcp::Effect::BORDER,
dcp::Colour (0, 0, 0),
dcp::Time (0, 0, 0, 1, 250),
dcp::Time (0, 0, 0, 1, 250)
dcp::Time (0, 0, 41, 62, 250),
dcp::Time (0, 0, 43, 52, 250),
0,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.89,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_LTR,
+ dcp::VAlign::TOP,
+ dcp::Direction::LTR,
"At afternoon tea with John Peel",
- dcp::BORDER,
+ dcp::Effect::BORDER,
dcp::Colour (0, 0, 0),
dcp::Time (0, 0, 0, 0, 250),
dcp::Time (0, 0, 0, 0, 250)
dcp::Time (0, 0, 41, 62, 250),
dcp::Time (0, 0, 43, 52, 250),
0,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.95,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_LTR,
+ dcp::VAlign::TOP,
+ dcp::Direction::LTR,
"I enquired if his accent was real",
- dcp::BORDER,
+ dcp::Effect::BORDER,
dcp::Colour (0, 0, 0),
dcp::Time (0, 0, 0, 0, 250),
dcp::Time (0, 0, 0, 0, 250)
dcp::Time (0, 0, 50, 42, 250),
dcp::Time (0, 0, 52, 21, 250),
0,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.89,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_LTR,
+ dcp::VAlign::TOP,
+ dcp::Direction::LTR,
"He said \"out of the house",
- dcp::BORDER,
+ dcp::Effect::BORDER,
dcp::Colour (0, 0, 0),
dcp::Time (0, 0, 0, 0, 250),
dcp::Time (0, 0, 0, 0, 250)
dcp::Time (0, 0, 50, 42, 250),
dcp::Time (0, 0, 52, 21, 250),
0,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.95,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_LTR,
+ dcp::VAlign::TOP,
+ dcp::Direction::LTR,
"I'm incredibly scouse",
- dcp::BORDER,
+ dcp::Effect::BORDER,
dcp::Colour (0, 0, 0),
dcp::Time (0, 0, 0, 0, 250),
dcp::Time (0, 0, 0, 0, 250)
BOOST_REQUIRE_EQUAL (s.size(), 2);
BOOST_REQUIRE (dynamic_pointer_cast<const dcp::SubtitleString>(s.front()));
BOOST_CHECK_EQUAL (*dynamic_pointer_cast<const dcp::SubtitleString>(s.front()), dcp::SubtitleString (
- string ("theFont"),
+ string("theFont"),
true,
false,
false,
- dcp::Colour (255, 255, 255),
+ dcp::Colour(255, 255, 255),
42,
1.0,
- dcp::Time (0, 1, 2, 208, 250),
- dcp::Time (0, 1, 4, 10, 250),
+ dcp::Time(0, 1, 2, 208, 250),
+ dcp::Time(0, 1, 4, 10, 250),
0,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.89,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_LTR,
+ dcp::VAlign::TOP,
+ dcp::Direction::LTR,
"At home it depends how I feel.\"",
- dcp::BORDER,
- dcp::Colour (0, 0, 0),
- dcp::Time (0, 0, 0, 0, 250),
- dcp::Time (0, 0, 0, 0, 250)
+ dcp::Effect::BORDER,
+ dcp::Colour(0, 0, 0),
+ dcp::Time(0, 0, 0, 0, 250),
+ dcp::Time(0, 0, 0, 0, 250)
));
BOOST_REQUIRE (dynamic_pointer_cast<const dcp::SubtitleString>(s.back()));
BOOST_CHECK_EQUAL (*dynamic_pointer_cast<const dcp::SubtitleString>(s.back()), dcp::SubtitleString (
true,
false,
false,
- dcp::Colour (255, 255, 255),
+ dcp::Colour(255, 255, 255),
42,
1.0,
- dcp::Time (0, 1, 2, 208, 250),
- dcp::Time (0, 1, 4, 10, 250),
+ dcp::Time(0, 1, 2, 208, 250),
+ dcp::Time(0, 1, 4, 10, 250),
0,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.95,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_LTR,
+ dcp::VAlign::TOP,
+ dcp::Direction::LTR,
"I spent a long weekend in Brighton",
- dcp::BORDER,
- dcp::Colour (0, 0, 0),
- dcp::Time (0, 0, 0, 0, 250),
- dcp::Time (0, 0, 0, 0, 250)
+ dcp::Effect::BORDER,
+ dcp::Colour(0, 0, 0),
+ dcp::Time(0, 0, 0, 0, 250),
+ dcp::Time(0, 0, 0, 0, 250)
));
s = subs.subtitles_during (dcp::Time (0, 1, 15, 50, 250), dcp::Time (0, 1, 15, 51, 250), false);
true,
false,
false,
- dcp::Colour (255, 255, 255),
+ dcp::Colour(255, 255, 255),
42,
1.0,
- dcp::Time (0, 1, 15, 42, 250),
- dcp::Time (0, 1, 16, 42, 250),
+ dcp::Time(0, 1, 15, 42, 250),
+ dcp::Time(0, 1, 16, 42, 250),
0,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.89,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_RTL,
+ dcp::VAlign::TOP,
+ dcp::Direction::RTL,
"With the legendary Miss Enid Blyton",
- dcp::BORDER,
- dcp::Colour (0, 0, 0),
- dcp::Time (0, 0, 0, 0, 250),
- dcp::Time (0, 0, 0, 0, 250)
+ dcp::Effect::BORDER,
+ dcp::Colour(0, 0, 0),
+ dcp::Time(0, 0, 0, 0, 250),
+ dcp::Time(0, 0, 0, 0, 250)
));
BOOST_REQUIRE (dynamic_pointer_cast<const dcp::SubtitleString>(s.back()));
BOOST_CHECK_EQUAL (*dynamic_pointer_cast<const dcp::SubtitleString>(s.back()), dcp::SubtitleString (
true,
false,
false,
- dcp::Colour (255, 255, 255),
+ dcp::Colour(255, 255, 255),
42,
1.0,
- dcp::Time (0, 1, 15, 42, 250),
- dcp::Time (0, 1, 16, 42, 250),
+ dcp::Time(0, 1, 15, 42, 250),
+ dcp::Time(0, 1, 16, 42, 250),
0,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.95,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_TTB,
+ dcp::VAlign::TOP,
+ dcp::Direction::TTB,
"She said \"you be Noddy",
- dcp::BORDER,
- dcp::Colour (0, 0, 0),
- dcp::Time (0, 0, 0, 0, 250),
- dcp::Time (0, 0, 0, 0, 250)
+ dcp::Effect::BORDER,
+ dcp::Colour(0, 0, 0),
+ dcp::Time(0, 0, 0, 0, 250),
+ dcp::Time(0, 0, 0, 0, 250)
));
s = subs.subtitles_during (dcp::Time (0, 1, 27, 200, 250), dcp::Time (0, 1, 27, 201, 250), false);
true,
false,
false,
- dcp::Colour (255, 255, 255),
+ dcp::Colour(255, 255, 255),
42,
1.0,
- dcp::Time (0, 1, 27, 115, 250),
- dcp::Time (0, 1, 28, 208, 250),
+ dcp::Time(0, 1, 27, 115, 250),
+ dcp::Time(0, 1, 28, 208, 250),
0,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.89,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_BTT,
+ dcp::VAlign::TOP,
+ dcp::Direction::BTT,
"That curious creature the Sphinx",
- dcp::BORDER,
- dcp::Colour (0, 0, 0),
- dcp::Time (0, 0, 0, 0, 250),
- dcp::Time (0, 0, 0, 0, 250)
+ dcp::Effect::BORDER,
+ dcp::Colour(0, 0, 0),
+ dcp::Time(0, 0, 0, 0, 250),
+ dcp::Time(0, 0, 0, 0, 250)
));
BOOST_REQUIRE (dynamic_pointer_cast<const dcp::SubtitleString>(s.back()));
BOOST_CHECK_EQUAL (*dynamic_pointer_cast<const dcp::SubtitleString>(s.back()), dcp::SubtitleString (
true,
false,
false,
- dcp::Colour (255, 255, 255),
+ dcp::Colour(255, 255, 255),
42,
1.0,
- dcp::Time (0, 1, 27, 115, 250),
- dcp::Time (0, 1, 28, 208, 250),
+ dcp::Time(0, 1, 27, 115, 250),
+ dcp::Time(0, 1, 28, 208, 250),
0,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.95,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_LTR,
+ dcp::VAlign::TOP,
+ dcp::Direction::LTR,
"Is smarter than anyone thinks",
- dcp::BORDER,
- dcp::Colour (0, 0, 0),
- dcp::Time (0, 0, 0, 0, 250),
- dcp::Time (0, 0, 0, 0, 250)
+ dcp::Effect::BORDER,
+ dcp::Colour(0, 0, 0),
+ dcp::Time(0, 0, 0, 0, 250),
+ dcp::Time(0, 0, 0, 0, 250)
));
s = subs.subtitles_during (dcp::Time (0, 1, 42, 300, 250), dcp::Time (0, 1, 42, 301, 250), false);
dcp::Time (0, 1, 42, 229, 250),
dcp::Time (0, 1, 45, 62, 250),
0,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.89,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_LTR,
+ dcp::VAlign::TOP,
+ dcp::Direction::LTR,
"It sits there and smirks",
- dcp::BORDER,
- dcp::Colour (0, 0, 0),
- dcp::Time (0, 0, 0, 0, 250),
- dcp::Time (0, 0, 0, 0, 250)
+ dcp::Effect::BORDER,
+ dcp::Colour(0, 0, 0),
+ dcp::Time(0, 0, 0, 0, 250),
+ dcp::Time(0, 0, 0, 0, 250)
));
BOOST_REQUIRE (dynamic_pointer_cast<const dcp::SubtitleString>(s.back()));
BOOST_CHECK_EQUAL (*dynamic_pointer_cast<const dcp::SubtitleString>(s.back()), dcp::SubtitleString (
dcp::Time (0, 1, 42, 229, 250),
dcp::Time (0, 1, 45, 62, 250),
0,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.95,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_LTR,
+ dcp::VAlign::TOP,
+ dcp::Direction::LTR,
"And you don't think it works",
- dcp::BORDER,
- dcp::Colour (0, 0, 0),
- dcp::Time (0, 0, 0, 0, 250),
- dcp::Time (0, 0, 0, 0, 250)
+ dcp::Effect::BORDER,
+ dcp::Colour(0, 0, 0),
+ dcp::Time(0, 0, 0, 0, 250),
+ dcp::Time(0, 0, 0, 0, 250)
));
s = subs.subtitles_during (dcp::Time (0, 1, 45, 200, 250), dcp::Time (0, 1, 45, 201, 250), false);
BOOST_REQUIRE_EQUAL (s.size(), 2);
BOOST_REQUIRE (dynamic_pointer_cast<const dcp::SubtitleString>(s.front()));
BOOST_CHECK_EQUAL (*dynamic_pointer_cast<const dcp::SubtitleString>(s.front()), dcp::SubtitleString (
- string ("theFont"),
+ string("theFont"),
false,
false,
false,
- dcp::Colour (255, 255, 255),
+ dcp::Colour(255, 255, 255),
42,
1.0,
- dcp::Time (0, 1, 45, 146, 250),
- dcp::Time (0, 1, 47, 94, 250),
+ dcp::Time(0, 1, 45, 146, 250),
+ dcp::Time(0, 1, 47, 94, 250),
0,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.89,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_LTR,
+ dcp::VAlign::TOP,
+ dcp::Direction::LTR,
"Then when you're not looking, it winks.",
- dcp::BORDER,
- dcp::Colour (0, 0, 0),
- dcp::Time (0, 0, 0, 0, 250),
- dcp::Time (0, 0, 0, 0, 250)
+ dcp::Effect::BORDER,
+ dcp::Colour(0, 0, 0),
+ dcp::Time(0, 0, 0, 0, 250),
+ dcp::Time(0, 0, 0, 0, 250)
));
BOOST_REQUIRE (dynamic_pointer_cast<const dcp::SubtitleString>(s.back()));
BOOST_CHECK_EQUAL (*dynamic_pointer_cast<const dcp::SubtitleString>(s.back()), dcp::SubtitleString (
dcp::Time (0, 1, 45, 146, 250),
dcp::Time (0, 1, 47, 94, 250),
0,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.95,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_LTR,
+ dcp::VAlign::TOP,
+ dcp::Direction::LTR,
"When it snows you will find Sister Sledge",
- dcp::BORDER,
- dcp::Colour (0, 0, 0),
- dcp::Time (0, 0, 0, 0, 250),
- dcp::Time (0, 0, 0, 0, 250)
+ dcp::Effect::BORDER,
+ dcp::Colour(0, 0, 0),
+ dcp::Time(0, 0, 0, 0, 250),
+ dcp::Time(0, 0, 0, 0, 250)
));
s = subs.subtitles_during (dcp::Time (0, 1, 47, 249, 250), dcp::Time (0, 1, 47, 250, 250), false);
false,
false,
false,
- dcp::Colour (255, 255, 255),
+ dcp::Colour(255, 255, 255),
42,
1.0,
- dcp::Time (0, 1, 47, 146, 250),
- dcp::Time (0, 1, 48, 167, 250),
+ dcp::Time(0, 1, 47, 146, 250),
+ dcp::Time(0, 1, 48, 167, 250),
0,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.89,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_LTR,
+ dcp::VAlign::TOP,
+ dcp::Direction::LTR,
"Out mooning, at night, on the ledge",
- dcp::BORDER,
- dcp::Colour (0, 0, 0),
- dcp::Time (0, 0, 0, 0, 250),
- dcp::Time (0, 0, 0, 0, 250)
+ dcp::Effect::BORDER,
+ dcp::Colour(0, 0, 0),
+ dcp::Time(0, 0, 0, 0, 250),
+ dcp::Time(0, 0, 0, 0, 250)
));
BOOST_REQUIRE (dynamic_pointer_cast<const dcp::SubtitleString>(s.back()));
BOOST_CHECK_EQUAL (*dynamic_pointer_cast<const dcp::SubtitleString>(s.back()), dcp::SubtitleString (
false,
false,
false,
- dcp::Colour (255, 255, 255),
+ dcp::Colour(255, 255, 255),
42,
1.0,
- dcp::Time (0, 1, 47, 146, 250),
- dcp::Time (0, 1, 48, 167, 250),
+ dcp::Time(0, 1, 47, 146, 250),
+ dcp::Time(0, 1, 48, 167, 250),
0,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.95,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_LTR,
+ dcp::VAlign::TOP,
+ dcp::Direction::LTR,
"One storey down",
- dcp::BORDER,
- dcp::Colour (0, 0, 0),
- dcp::Time (0, 0, 0, 0, 250),
- dcp::Time (0, 0, 0, 0, 250)
+ dcp::Effect::BORDER,
+ dcp::Colour(0, 0, 0),
+ dcp::Time(0, 0, 0, 0, 250),
+ dcp::Time(0, 0, 0, 0, 250)
));
s = subs.subtitles_during (dcp::Time (0, 2, 6, 210, 250), dcp::Time (0, 2, 6, 211, 250), false);
dcp::Time (0, 2, 5, 208, 250),
dcp::Time (0, 2, 7, 31, 250),
0,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.89,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_LTR,
+ dcp::VAlign::TOP,
+ dcp::Direction::LTR,
"HELLO",
- dcp::BORDER,
- dcp::Colour (0, 0, 0),
- dcp::Time (0, 0, 0, 0, 250),
- dcp::Time (0, 0, 0, 0, 250)
+ dcp::Effect::BORDER,
+ dcp::Colour(0, 0, 0),
+ dcp::Time(0, 0, 0, 0, 250),
+ dcp::Time(0, 0, 0, 0, 250)
));
BOOST_REQUIRE (dynamic_pointer_cast<const dcp::SubtitleString>(s.back()));
BOOST_CHECK_EQUAL (*dynamic_pointer_cast<const dcp::SubtitleString>(s.back()), dcp::SubtitleString (
true,
false,
false,
- dcp::Colour (255, 255, 255),
+ dcp::Colour(255, 255, 255),
42,
1.0,
- dcp::Time (0, 2, 5, 208, 250),
- dcp::Time (0, 2, 7, 31, 250),
+ dcp::Time(0, 2, 5, 208, 250),
+ dcp::Time(0, 2, 7, 31, 250),
0,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.95,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_LTR,
+ dcp::VAlign::TOP,
+ dcp::Direction::LTR,
"WORLD",
- dcp::BORDER,
- dcp::Colour (0, 0, 0),
- dcp::Time (0, 0, 0, 0, 250),
- dcp::Time (0, 0, 0, 0, 250)
+ dcp::Effect::BORDER,
+ dcp::Colour(0, 0, 0),
+ dcp::Time(0, 0, 0, 0, 250),
+ dcp::Time(0, 0, 0, 0, 250)
));
}
using std::string;
using std::shared_ptr;
+using std::make_shared;
/** Check that recovery from a partially-written MXF works */
BOOST_AUTO_TEST_CASE (recovery)
boost::filesystem::remove_all ("build/test/baz");
boost::filesystem::create_directories ("build/test/baz");
- shared_ptr<dcp::MonoPictureAsset> mp (new dcp::MonoPictureAsset (dcp::Fraction (24, 1), dcp::SMPTE));
+ shared_ptr<dcp::MonoPictureAsset> mp (new dcp::MonoPictureAsset (dcp::Fraction (24, 1), dcp::Standard::SMPTE));
shared_ptr<dcp::PictureAssetWriter> writer = mp->start_write ("build/test/baz/video1.mxf", false);
int written_size = 0;
Kumu::ResetTestRNG ();
#endif
- mp.reset (new dcp::MonoPictureAsset (dcp::Fraction (24, 1), dcp::SMPTE));
+ mp = make_shared<dcp::MonoPictureAsset>(dcp::Fraction (24, 1), dcp::Standard::SMPTE);
writer = mp->start_write ("build/test/baz/video2.mxf", true);
writer->write (data.data(), data.size());
using std::string;
using std::cout;
using std::shared_ptr;
+using std::make_shared;
using boost::optional;
using boost::scoped_array;
}
}
- shared_ptr<dcp::OpenJPEGImage> xyz = dcp::rgb_to_xyz (rgb.get(), size, size.width * 6, dcp::ColourConversion::srgb_to_xyz ());
+ auto xyz = dcp::rgb_to_xyz (rgb.get(), size, size.width * 6, dcp::ColourConversion::srgb_to_xyz());
for (int y = 0; y < size.height; ++y) {
uint16_t* p = reinterpret_cast<uint16_t*> (rgb.get() + y * size.width * 6);
static void
note_handler (dcp::NoteType n, string s)
{
- BOOST_REQUIRE_EQUAL (n, dcp::DCP_NOTE);
+ BOOST_REQUIRE_EQUAL (n, dcp::NoteType::NOTE);
notes.push_back (s);
}
/** Check that xyz_to_rgb clamps XYZ values correctly */
BOOST_AUTO_TEST_CASE (xyz_rgb_range_test)
{
- shared_ptr<dcp::OpenJPEGImage> xyz (new dcp::OpenJPEGImage (dcp::Size (2, 2)));
+ auto xyz = make_shared<dcp::OpenJPEGImage>(dcp::Size(2, 2));
xyz->data(0)[0] = -4;
xyz->data(0)[1] = 6901;
/* The 6 out-of-range samples should have been noted */
BOOST_REQUIRE_EQUAL (notes.size(), 6);
- list<string>::const_iterator i = notes.begin ();
+ auto i = notes.begin ();
BOOST_REQUIRE_EQUAL (*i++, "XYZ value -4 out of range");
BOOST_REQUIRE_EQUAL (*i++, "XYZ value -4 out of range");
BOOST_REQUIRE_EQUAL (*i++, "XYZ value -4 out of range");
as inputs at the extremes (0 and 4095).
*/
- uint16_t* buffer = reinterpret_cast<uint16_t*> (rgb.get ());
+ auto buffer = reinterpret_cast<uint16_t*> (rgb.get ());
BOOST_REQUIRE_EQUAL (buffer[0 * 3 + 0], buffer[2 * 3 + 1]);
BOOST_REQUIRE_EQUAL (buffer[0 * 3 + 1], buffer[2 * 3 + 1]);
BOOST_REQUIRE_EQUAL (buffer[0 * 3 + 2], buffer[2 * 3 + 2]);
boost::filesystem::path work_dir = "build/test/round_trip_test";
boost::filesystem::create_directory (work_dir);
- shared_ptr<dcp::MonoPictureAsset> asset_A (new dcp::MonoPictureAsset (dcp::Fraction (24, 1), dcp::SMPTE));
+ shared_ptr<dcp::MonoPictureAsset> asset_A (new dcp::MonoPictureAsset (dcp::Fraction (24, 1), dcp::Standard::SMPTE));
shared_ptr<dcp::PictureAssetWriter> writer = asset_A->start_write (work_dir / "video.mxf", false);
dcp::ArrayData j2c ("test/data/flat_red.j2c");
for (int i = 0; i < 24; ++i) {
asset_A->set_key (key);
- shared_ptr<dcp::CPL> cpl (new dcp::CPL ("A Test DCP", dcp::FEATURE));
+ shared_ptr<dcp::CPL> cpl (new dcp::CPL ("A Test DCP", dcp::ContentKind::FEATURE));
shared_ptr<dcp::Reel> reel (new dcp::Reel ());
reel->add (shared_ptr<dcp::ReelMonoPictureAsset> (new dcp::ReelMonoPictureAsset (asset_A, 0)));
cpl->add (reel);
boost::filesystem::path const kdm_file = work_dir / "kdm.xml";
- kdm_A.encrypt(signer, signer->leaf(), vector<string>(), dcp::MODIFIED_TRANSITIONAL_1, true, 0).as_xml (kdm_file);
+ kdm_A.encrypt(signer, signer->leaf(), vector<string>(), dcp::Formulation::MODIFIED_TRANSITIONAL_1, true, 0).as_xml (kdm_file);
/* Reload the KDM, using our private key to decrypt it */
dcp::DecryptedKDM kdm_B (dcp::EncryptedKDM (dcp::file_to_string (kdm_file)), signer->key().get ());
/*
- Copyright (C) 2018 Carl Hetherington <cth@carlh.net>
+ Copyright (C) 2018-2021 Carl Hetherington <cth@carlh.net>
This file is part of libdcp.
#include <boost/test/unit_test.hpp>
#include "smpte_subtitle_asset.h"
+using std::make_shared;
using std::string;
-using boost::optional;
using std::shared_ptr;
+using boost::optional;
BOOST_AUTO_TEST_CASE (smpte_subtitle_id_test)
{
dcp::SMPTESubtitleAsset subs;
subs.add(
- shared_ptr<dcp::Subtitle> (
- new dcp::SubtitleString(
- optional<string>(),
- false, false, false,
- dcp::Colour(),
- 64,
- 1,
- dcp::Time(0, 1, 2, 3, 24),
- dcp::Time(0, 2, 2, 3, 24),
- 0.5,
- dcp::HALIGN_CENTER,
- 0.5,
- dcp::VALIGN_CENTER,
- dcp::DIRECTION_LTR,
- "Hello",
- dcp::NONE,
- dcp::Colour(),
- dcp::Time(0, 0, 0, 0, 24),
- dcp::Time(0, 0, 0, 0, 24)
- )
+ make_shared<dcp::SubtitleString>(
+ optional<string>(),
+ false, false, false,
+ dcp::Colour(),
+ 64,
+ 1,
+ dcp::Time(0, 1, 2, 3, 24),
+ dcp::Time(0, 2, 2, 3, 24),
+ 0.5,
+ dcp::HAlign::CENTER,
+ 0.5,
+ dcp::VAlign::CENTER,
+ dcp::Direction::LTR,
+ "Hello",
+ dcp::Effect::NONE,
+ dcp::Colour(),
+ dcp::Time(0, 0, 0, 0, 24),
+ dcp::Time(0, 0, 0, 0, 24)
)
);
subs.write("build/test/smpte_subtitle_id_test.mxf");
{
/* Make a MXF with the same ID as atmos_pcm.mxf and write a frame of random stuff */
int const channels = 14;
- dcp::SoundAsset asset (dcp::Fraction(24, 1), 48000, channels, dcp::LanguageTag("en-GB"), dcp::SMPTE);
+ dcp::SoundAsset asset (dcp::Fraction(24, 1), 48000, channels, dcp::LanguageTag("en-GB"), dcp::Standard::SMPTE);
asset._id = "e004046e09234f90a4ae4355e7e83506";
boost::system::error_code ec;
boost::filesystem::remove ("build/test/foo.mxf", ec);
mxf_meta.product_name = "OpenDCP";
mxf_meta.product_version = "0.0.25";
- shared_ptr<dcp::MonoPictureAsset> mp (new dcp::MonoPictureAsset (dcp::Fraction (24, 1), dcp::SMPTE));
+ shared_ptr<dcp::MonoPictureAsset> mp (new dcp::MonoPictureAsset (dcp::Fraction (24, 1), dcp::Standard::SMPTE));
mp->set_metadata (mxf_meta);
shared_ptr<dcp::PictureAssetWriter> picture_writer = mp->start_write (path / dcp::String::compose("video%1.mxf", suffix), false);
dcp::ArrayData j2c ("test/data/flat_red.j2c");
int const channels = 6;
/* Set a valid language, then overwrite it, so that the language parameter can be badly formed */
- shared_ptr<dcp::SoundAsset> ms (new dcp::SoundAsset(dcp::Fraction(24, 1), sample_rate, channels, dcp::LanguageTag("en-US"), dcp::SMPTE));
+ shared_ptr<dcp::SoundAsset> ms (new dcp::SoundAsset(dcp::Fraction(24, 1), sample_rate, channels, dcp::LanguageTag("en-US"), dcp::Standard::SMPTE));
ms->_language = language;
ms->set_metadata (mxf_meta);
vector<dcp::Channel> active_channels;
- active_channels.push_back (dcp::LEFT);
+ active_channels.push_back (dcp::Channel::LEFT);
shared_ptr<dcp::SoundAssetWriter> sound_writer = ms->start_write (path / dcp::String::compose("audio%1.mxf", suffix), active_channels);
int const samples_per_frame = sample_rate / 24;
boost::filesystem::remove_all (path);
boost::filesystem::create_directories (path);
- shared_ptr<dcp::DCP> d (new dcp::DCP (path));
- shared_ptr<dcp::CPL> cpl (new dcp::CPL ("A Test DCP", dcp::TRAILER));
+ auto d = make_shared<dcp::DCP>(path);
+ auto cpl = make_shared<dcp::CPL>("A Test DCP", dcp::ContentKind::TRAILER);
cpl->set_annotation_text ("A Test DCP");
cpl->set_issuer ("OpenDCP 0.0.25");
cpl->set_creator ("OpenDCP 0.0.25");
shared_ptr<dcp::Subtitle>
simple_subtitle ()
{
- return shared_ptr<dcp::Subtitle>(
- new dcp::SubtitleString(
- optional<string>(),
- false,
- false,
- false,
- dcp::Colour(255, 255, 255),
- 42,
- 1,
- dcp::Time(0, 0, 4, 0, 24),
- dcp::Time(0, 0, 8, 0, 24),
- 0.5,
- dcp::HALIGN_CENTER,
- 0.8,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_LTR,
- "Hello world",
- dcp::NONE,
- dcp::Colour(255, 255, 255),
- dcp::Time(),
- dcp::Time()
- )
+ return make_shared<dcp::SubtitleString>(
+ optional<string>(),
+ false,
+ false,
+ false,
+ dcp::Colour(255, 255, 255),
+ 42,
+ 1,
+ dcp::Time(0, 0, 4, 0, 24),
+ dcp::Time(0, 0, 8, 0, 24),
+ 0.5,
+ dcp::HAlign::CENTER,
+ 0.8,
+ dcp::VAlign::TOP,
+ dcp::Direction::LTR,
+ "Hello world",
+ dcp::Effect::NONE,
+ dcp::Colour(255, 255, 255),
+ dcp::Time(),
+ dcp::Time()
);
}
dcp::ArrayData frame = dcp::compress_j2k (image, 100000000, 24, false, false);
BOOST_REQUIRE (frame.size() < 230000000 / (24 * 8));
- shared_ptr<dcp::MonoPictureAsset> asset(new dcp::MonoPictureAsset(dcp::Fraction(24, 1), dcp::SMPTE));
+ auto asset = make_shared<dcp::MonoPictureAsset>(dcp::Fraction(24, 1), dcp::Standard::SMPTE);
asset->set_metadata (dcp::MXFMetadata("libdcp", "libdcp", "1.6.4devel"));
boost::filesystem::create_directories (dir);
shared_ptr<dcp::PictureAssetWriter> writer = asset->start_write (dir / "pic.mxf", true);
/** Test dcp::content_kind_from_string */
BOOST_AUTO_TEST_CASE (content_kind_test)
{
- BOOST_CHECK_EQUAL (dcp::content_kind_from_string ("feature"), dcp::FEATURE);
- BOOST_CHECK_EQUAL (dcp::content_kind_from_string ("Feature"), dcp::FEATURE);
- BOOST_CHECK_EQUAL (dcp::content_kind_from_string ("FeaturE"), dcp::FEATURE);
- BOOST_CHECK_EQUAL (dcp::content_kind_from_string ("Short"), dcp::SHORT);
- BOOST_CHECK_EQUAL (dcp::content_kind_from_string ("trailer"), dcp::TRAILER);
- BOOST_CHECK_EQUAL (dcp::content_kind_from_string ("test"), dcp::TEST);
- BOOST_CHECK_EQUAL (dcp::content_kind_from_string ("transitional"), dcp::TRANSITIONAL);
- BOOST_CHECK_EQUAL (dcp::content_kind_from_string ("rating"), dcp::RATING);
- BOOST_CHECK_EQUAL (dcp::content_kind_from_string ("teaser"), dcp::TEASER);
- BOOST_CHECK_EQUAL (dcp::content_kind_from_string ("policy"), dcp::POLICY);
- BOOST_CHECK_EQUAL (dcp::content_kind_from_string ("psa"), dcp::PUBLIC_SERVICE_ANNOUNCEMENT);
- BOOST_CHECK_EQUAL (dcp::content_kind_from_string ("advertisement"), dcp::ADVERTISEMENT);
+ BOOST_CHECK_EQUAL (dcp::content_kind_from_string ("feature"), dcp::ContentKind::FEATURE);
+ BOOST_CHECK_EQUAL (dcp::content_kind_from_string ("Feature"), dcp::ContentKind::FEATURE);
+ BOOST_CHECK_EQUAL (dcp::content_kind_from_string ("FeaturE"), dcp::ContentKind::FEATURE);
+ BOOST_CHECK_EQUAL (dcp::content_kind_from_string ("Short"), dcp::ContentKind::SHORT);
+ BOOST_CHECK_EQUAL (dcp::content_kind_from_string ("trailer"), dcp::ContentKind::TRAILER);
+ BOOST_CHECK_EQUAL (dcp::content_kind_from_string ("test"), dcp::ContentKind::TEST);
+ BOOST_CHECK_EQUAL (dcp::content_kind_from_string ("transitional"), dcp::ContentKind::TRANSITIONAL);
+ BOOST_CHECK_EQUAL (dcp::content_kind_from_string ("rating"), dcp::ContentKind::RATING);
+ BOOST_CHECK_EQUAL (dcp::content_kind_from_string ("teaser"), dcp::ContentKind::TEASER);
+ BOOST_CHECK_EQUAL (dcp::content_kind_from_string ("policy"), dcp::ContentKind::POLICY);
+ BOOST_CHECK_EQUAL (dcp::content_kind_from_string ("psa"), dcp::ContentKind::PUBLIC_SERVICE_ANNOUNCEMENT);
+ BOOST_CHECK_EQUAL (dcp::content_kind_from_string ("advertisement"), dcp::ContentKind::ADVERTISEMENT);
}
/** Test dcp::relative_to_root */
static
shared_ptr<dcp::CPL>
-write_dcp_with_single_asset (path dir, shared_ptr<dcp::ReelAsset> reel_asset, dcp::Standard standard = dcp::SMPTE)
+write_dcp_with_single_asset (path dir, shared_ptr<dcp::ReelAsset> reel_asset, dcp::Standard standard = dcp::Standard::SMPTE)
{
auto reel = make_shared<dcp::Reel>();
reel->add (reel_asset);
reel->add (simple_markers());
- auto cpl = make_shared<dcp::CPL>("hello", dcp::TRAILER);
+ auto cpl = make_shared<dcp::CPL>("hello", dcp::ContentKind::TRAILER);
cpl->add (reel);
auto dcp = make_shared<dcp::DCP>(dir);
dcp->add (cpl);
shared_ptr<dcp::CPL>
dcp_from_frame (dcp::ArrayData const& frame, path dir)
{
- auto asset = make_shared<dcp::MonoPictureAsset>(dcp::Fraction(24, 1), dcp::SMPTE);
+ auto asset = make_shared<dcp::MonoPictureAsset>(dcp::Fraction(24, 1), dcp::Standard::SMPTE);
create_directories (dir);
auto writer = asset->start_write (dir / "pic.mxf", true);
for (int i = 0; i < 24; ++i) {
copy_file ("test/data/subs1.xml", dir / "subs.xml");
auto asset = make_shared<dcp::InteropSubtitleAsset>(dir / "subs.xml");
auto reel_asset = make_shared<dcp::ReelSubtitleAsset>(asset, dcp::Fraction(24, 1), 16 * 24, 0);
- write_dcp_with_single_asset (dir, reel_asset, dcp::INTEROP);
+ write_dcp_with_single_asset (dir, reel_asset, dcp::Standard::INTEROP);
check_verify_result ({dir}, {{ dcp::VerificationNote::VERIFY_BV21_ERROR, dcp::VerificationNote::INVALID_STANDARD }});
}
copy_file ("test/data/subs1.xml", dir / "subs.xml");
auto asset = make_shared<dcp::InteropSubtitleAsset>(dir / "subs.xml");
auto reel_asset = make_shared<dcp::ReelSubtitleAsset>(asset, dcp::Fraction(24, 1), 16 * 24, 0);
- write_dcp_with_single_asset (dir, reel_asset, dcp::INTEROP);
+ write_dcp_with_single_asset (dir, reel_asset, dcp::Standard::INTEROP);
{
Editor e (dir / "subs.xml");
reel->add (make_shared<dcp::ReelMonoPictureAsset>(simple_picture(dir, "", 16 * 24), 0));
reel->add (simple_markers(16 * 24));
- auto cpl = make_shared<dcp::CPL>("hello", dcp::TRAILER);
+ auto cpl = make_shared<dcp::CPL>("hello", dcp::ContentKind::TRAILER);
cpl->add (reel);
cpl->set_main_sound_configuration ("L,C,R,Lfe,-,-");
cpl->set_main_sound_sample_rate (48000);
dcp::DCP dcp (dir);
dcp.add (cpl);
dcp.write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
auto reel = make_shared<dcp::Reel>();
reel->add (black_picture_asset(dir));
- auto cpl = make_shared<dcp::CPL>("hello", dcp::TRAILER);
+ auto cpl = make_shared<dcp::CPL>("hello", dcp::ContentKind::TRAILER);
cpl->add (reel);
cpl->set_main_sound_configuration ("L,C,R,Lfe,-,-");
cpl->set_main_sound_sample_rate (48000);
dcp::DCP dcp (dir);
dcp.add (cpl);
dcp.write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
auto reel = make_shared<dcp::Reel>();
reel->add (black_picture_asset(dir));
- auto cpl = make_shared<dcp::CPL>("hello", dcp::TRAILER);
+ auto cpl = make_shared<dcp::CPL>("hello", dcp::ContentKind::TRAILER);
cpl->add (reel);
cpl->set_main_sound_configuration ("L,C,R,Lfe,-,-");
cpl->set_main_sound_sample_rate (48000);
dcp::DCP dcp (dir);
dcp.add (cpl);
dcp.write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
reel->add (reel_sound);
reel->add (simple_markers());
- auto cpl = make_shared<dcp::CPL>("hello", dcp::TRAILER);
+ auto cpl = make_shared<dcp::CPL>("hello", dcp::ContentKind::TRAILER);
cpl->add (reel);
cpl->_additional_subtitle_languages.push_back("this-is-wrong");
cpl->_additional_subtitle_languages.push_back("andso-is-this");
auto dcp = make_shared<dcp::DCP>(dir);
dcp->add (cpl);
dcp->write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
shared_ptr<dcp::PictureAsset> mp;
if (three_d) {
- mp = make_shared<dcp::StereoPictureAsset>(dcp::Fraction(frame_rate, 1), dcp::SMPTE);
+ mp = make_shared<dcp::StereoPictureAsset>(dcp::Fraction(frame_rate, 1), dcp::Standard::SMPTE);
} else {
- mp = make_shared<dcp::MonoPictureAsset>(dcp::Fraction(frame_rate, 1), dcp::SMPTE);
+ mp = make_shared<dcp::MonoPictureAsset>(dcp::Fraction(frame_rate, 1), dcp::Standard::SMPTE);
}
auto picture_writer = mp->start_write (dcp_path / "video.mxf", false);
picture_writer->finalize ();
auto d = make_shared<dcp::DCP>(dcp_path);
- auto cpl = make_shared<dcp::CPL>("A Test DCP", dcp::TRAILER);
+ auto cpl = make_shared<dcp::CPL>("A Test DCP", dcp::ContentKind::TRAILER);
cpl->set_annotation_text ("A Test DCP");
cpl->set_issue_date ("2012-07-17T04:45:18+00:00");
cpl->set_main_sound_configuration ("L,C,R,Lfe,-,-");
d->add (cpl);
d->write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
dcp::Time(start_frame, 24, 24),
dcp::Time(end_frame, 24, 24),
0,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
v_position,
- dcp::VALIGN_CENTER,
- dcp::DIRECTION_LTR,
+ dcp::VAlign::CENTER,
+ dcp::Direction::LTR,
text,
- dcp::NONE,
+ dcp::Effect::NONE,
dcp::Colour(),
dcp::Time(),
dcp::Time()
auto reel_subs = make_shared<dcp::ReelSubtitleAsset>(subs, dcp::Fraction(24, 1), 240, 0);
dcp->cpls().front()->reels().front()->add(reel_subs);
dcp->write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
}
dcp->write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
auto reel_subs = make_shared<dcp::ReelSubtitleAsset>(subs, dcp::Fraction(24, 1), 240, 0);
dcp->cpls().front()->reels().front()->add(reel_subs);
dcp->write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
auto reel_subs = make_shared<dcp::ReelSubtitleAsset>(subs, dcp::Fraction(24, 1), 240, 0);
dcp->cpls().front()->reels().front()->add(reel_subs);
dcp->write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
markers2->set (dcp::Marker::LFOC, dcp::Time(16 * 24 - 1, 24, 24));
reel2->add (markers2);
- auto cpl = make_shared<dcp::CPL>("hello", dcp::TRAILER);
+ auto cpl = make_shared<dcp::CPL>("hello", dcp::ContentKind::TRAILER);
cpl->add (reel1);
cpl->add (reel2);
auto dcp = make_shared<dcp::DCP>(dir);
dcp->add (cpl);
dcp->write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
auto reel_sound = make_shared<dcp::ReelSoundAsset>(sound, 0);
reel->add (reel_sound);
reel->add (simple_markers());
- auto cpl = make_shared<dcp::CPL>("hello", dcp::TRAILER);
+ auto cpl = make_shared<dcp::CPL>("hello", dcp::ContentKind::TRAILER);
cpl->add (reel);
auto dcp = make_shared<dcp::DCP>(dir);
dcp->add (cpl);
dcp->write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
path const dir("build/test/verify_missing_cpl_annotation_text");
auto dcp = make_simple (dir);
dcp->write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
path const dir("build/test/verify_mismatched_cpl_annotation_text");
auto dcp = make_simple (dir);
dcp->write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
path const dir("build/test/verify_mismatched_asset_duration");
prepare_directory (dir);
shared_ptr<dcp::DCP> dcp (new dcp::DCP(dir));
- shared_ptr<dcp::CPL> cpl (new dcp::CPL("A Test DCP", dcp::TRAILER));
+ shared_ptr<dcp::CPL> cpl (new dcp::CPL("A Test DCP", dcp::ContentKind::TRAILER));
shared_ptr<dcp::MonoPictureAsset> mp = simple_picture (dir, "", 24);
shared_ptr<dcp::SoundAsset> ms = simple_sound (dir, "", dcp::MXFMetadata(), "en-US", 25);
dcp->add (cpl);
dcp->write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
{
prepare_directory (dir);
auto dcp = make_shared<dcp::DCP>(dir);
- auto cpl = make_shared<dcp::CPL>("A Test DCP", dcp::TRAILER);
+ auto cpl = make_shared<dcp::CPL>("A Test DCP", dcp::ContentKind::TRAILER);
auto subs = make_shared<dcp::SMPTESubtitleAsset>();
subs->set_language (dcp::LanguageTag("de-DE"));
dcp->add (cpl);
dcp->write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
{
prepare_directory (dir);
auto dcp = make_shared<dcp::DCP>(dir);
- auto cpl = make_shared<dcp::CPL>("A Test DCP", dcp::TRAILER);
+ auto cpl = make_shared<dcp::CPL>("A Test DCP", dcp::ContentKind::TRAILER);
auto subs = make_shared<dcp::SMPTESubtitleAsset>();
subs->set_language (dcp::LanguageTag("de-DE"));
dcp->add (cpl);
dcp->write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
{
prepare_directory (dir);
auto dcp = make_shared<dcp::DCP>(dir);
- auto cpl = make_shared<dcp::CPL>("A Test DCP", dcp::TRAILER);
+ auto cpl = make_shared<dcp::CPL>("A Test DCP", dcp::ContentKind::TRAILER);
auto subs = make_shared<dcp::SMPTESubtitleAsset>();
subs->set_language (dcp::LanguageTag("de-DE"));
dcp->add (cpl);
dcp->write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
path const dir("build/test/verify_missing_hash");
auto dcp = make_simple (dir);
dcp->write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
)
{
auto dcp = make_simple (dir);
- dcp->cpls()[0]->set_content_kind (dcp::FEATURE);
+ dcp->cpls()[0]->set_content_kind (dcp::ContentKind::FEATURE);
auto markers_asset = make_shared<dcp::ReelMarkersAsset>(dcp::Fraction(24, 1), 24, 0);
for (auto const& i: markers) {
markers_asset->set (i.first, i.second);
}
dcp->cpls()[0]->reels()[0]->add(markers_asset);
dcp->write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
auto cpl = dcp->cpls()[0];
cpl->unset_version_number();
dcp->write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
path dir = "build/test/verify_missing_extension_metadata1";
auto dcp = make_simple (dir);
dcp->write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
path dir = "build/test/verify_missing_extension_metadata2";
auto dcp = make_simple (dir);
dcp->write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
path dir = "build/test/verify_invalid_xml_cpl_extension_metadata3";
auto dcp = make_simple (dir);
dcp->write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
path dir = "build/test/verify_invalid_extension_metadata1";
auto dcp = make_simple (dir);
dcp->write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
path dir = "build/test/verify_invalid_extension_metadata2";
auto dcp = make_simple (dir);
dcp->write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
path dir = "build/test/verify_invalid_xml_cpl_extension_metadata6";
auto dcp = make_simple (dir);
dcp->write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
path dir = "build/test/verify_invalid_xml_cpl_extension_metadata7";
auto dcp = make_simple (dir);
dcp->write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
path dir = "build/test/verify_invalid_xml_cpl_extension_metadata8";
auto dcp = make_simple (dir);
dcp->write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
path dir = "build/test/verify_invalid_xml_cpl_extension_metadata9";
auto dcp = make_simple (dir);
dcp->write_xml (
- dcp::SMPTE,
+ dcp::Standard::SMPTE,
dcp::String::compose("libdcp %1", dcp::version),
dcp::String::compose("libdcp %1", dcp::version),
dcp::LocalTime().as_string(),
signer->add (dcp::Certificate(dcp::file_to_string("test/ref/crypt/leaf.signed.pem")));
signer->set_key (dcp::file_to_string("test/ref/crypt/leaf.key"));
- auto cpl = make_shared<dcp::CPL>("A Test DCP", dcp::TRAILER);
+ auto cpl = make_shared<dcp::CPL>("A Test DCP", dcp::ContentKind::TRAILER);
dcp::Key key;
- auto mp = make_shared<dcp::MonoPictureAsset>(dcp::Fraction (24, 1), dcp::SMPTE);
+ auto mp = make_shared<dcp::MonoPictureAsset>(dcp::Fraction (24, 1), dcp::Standard::SMPTE);
mp->set_key (key);
auto writer = mp->start_write (dir / "video.mxf", false);
d.add (cpl);
- d.write_xml (dcp::SMPTE, "OpenDCP 0.0.25", "OpenDCP 0.0.25", "2012-07-17T04:45:18+00:00", "A Test DCP", signer);
+ d.write_xml (dcp::Standard::SMPTE, "OpenDCP 0.0.25", "OpenDCP 0.0.25", "2012-07-17T04:45:18+00:00", "A Test DCP", signer);
check_verify_result ({dir}, {{dcp::VerificationNote::VERIFY_BV21_ERROR, dcp::VerificationNote::PARTIALLY_ENCRYPTED}});
}
/*
- Copyright (C) 2015-2019 Carl Hetherington <cth@carlh.net>
+ Copyright (C) 2015-2021 Carl Hetherington <cth@carlh.net>
This file is part of libdcp.
using std::string;
using std::shared_ptr;
using std::vector;
+using std::make_shared;
using boost::optional;
/** Test dcp::order::Font::take_intersection */
/** Test dcp::order::Subtitle::pull_fonts */
BOOST_AUTO_TEST_CASE (pull_fonts_test1)
{
- shared_ptr<dcp::order::Part> root (new dcp::order::Part (shared_ptr<dcp::order::Part> ()));
- shared_ptr<dcp::order::Subtitle> sub1 (new dcp::order::Subtitle (root, dcp::Time(), dcp::Time(), dcp::Time(), dcp::Time()));
+ auto root = make_shared<dcp::order::Part>(shared_ptr<dcp::order::Part>());
+ auto sub1 = make_shared<dcp::order::Subtitle>(root, dcp::Time(), dcp::Time(), dcp::Time(), dcp::Time());
root->children.push_back (sub1);
- shared_ptr<dcp::order::Text> text1 (new dcp::order::Text (sub1, dcp::HALIGN_CENTER, 0, dcp::VALIGN_TOP, 0, dcp::DIRECTION_LTR));
+ auto text1 = make_shared<dcp::order::Text>(sub1, dcp::HAlign::CENTER, 0, dcp::VAlign::TOP, 0, dcp::Direction::LTR);
sub1->children.push_back (text1);
text1->font._values["font"] = "Inconsolata";
text1->font._values["size"] = "42";
shared_ptr<dcp::order::Part> root (new dcp::order::Part (shared_ptr<dcp::order::Part> ()));
shared_ptr<dcp::order::Subtitle> sub1 (new dcp::order::Subtitle (root, dcp::Time(), dcp::Time(), dcp::Time(), dcp::Time()));
root->children.push_back (sub1);
- shared_ptr<dcp::order::Text> text1 (new dcp::order::Text (sub1, dcp::HALIGN_CENTER, 0, dcp::VALIGN_TOP, 0, dcp::DIRECTION_LTR));
+ shared_ptr<dcp::order::Text> text1 (new dcp::order::Text (sub1, dcp::HAlign::CENTER, 0, dcp::VAlign::TOP, 0, dcp::Direction::LTR));
sub1->children.push_back (text1);
text1->font._values["font"] = "Inconsolata";
text1->font._values["size"] = "42";
- shared_ptr<dcp::order::Text> text2 (new dcp::order::Text (sub1, dcp::HALIGN_CENTER, 0, dcp::VALIGN_TOP, 0, dcp::DIRECTION_LTR));
+ shared_ptr<dcp::order::Text> text2 (new dcp::order::Text (sub1, dcp::HAlign::CENTER, 0, dcp::VAlign::TOP, 0, dcp::Direction::LTR));
sub1->children.push_back (text2);
text2->font._values["font"] = "Inconsolata";
text2->font._values["size"] = "48";
shared_ptr<dcp::order::Part> root (new dcp::order::Part (shared_ptr<dcp::order::Part> ()));
shared_ptr<dcp::order::Subtitle> sub1 (new dcp::order::Subtitle (root, dcp::Time(), dcp::Time(), dcp::Time(), dcp::Time()));
root->children.push_back (sub1);
- shared_ptr<dcp::order::Text> text1 (new dcp::order::Text (sub1, dcp::HALIGN_CENTER, 0, dcp::VALIGN_TOP, 0, dcp::DIRECTION_LTR));
+ shared_ptr<dcp::order::Text> text1 (new dcp::order::Text (sub1, dcp::HAlign::CENTER, 0, dcp::VAlign::TOP, 0, dcp::Direction::LTR));
sub1->children.push_back (text1);
dcp::order::Font font;
font._values["font"] = "Inconsolata";
dcp::Time (0, 4, 9, 22, 24),
dcp::Time (0, 4, 11, 22, 24),
0,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.8,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_LTR,
+ dcp::VAlign::TOP,
+ dcp::Direction::LTR,
"Hello world",
- dcp::NONE,
+ dcp::Effect::NONE,
dcp::Colour (0, 0, 0),
dcp::Time (0, 0, 0, 0, 24),
dcp::Time (0, 0, 0, 0, 24)
dcp::Time (5, 41, 0, 21, 24),
dcp::Time (6, 12, 15, 21, 24),
0,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.4,
- dcp::VALIGN_BOTTOM,
- dcp::DIRECTION_LTR,
+ dcp::VAlign::BOTTOM,
+ dcp::Direction::LTR,
"What's going on",
- dcp::BORDER,
+ dcp::Effect::BORDER,
dcp::Colour (1, 2, 3),
dcp::Time (1, 2, 3, 4, 24),
dcp::Time (5, 6, 7, 8, 24)
dcp::Time (0, 4, 9, 22, 24),
dcp::Time (0, 4, 11, 22, 24),
-0.2,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.8,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_LTR,
+ dcp::VAlign::TOP,
+ dcp::Direction::LTR,
"Hello world",
- dcp::NONE,
+ dcp::Effect::NONE,
dcp::Colour (0, 0, 0),
dcp::Time (0, 0, 0, 0, 24),
dcp::Time (0, 0, 0, 0, 24)
dcp::Time (5, 41, 0, 21, 24),
dcp::Time (6, 12, 15, 21, 24),
-0.2,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.4,
- dcp::VALIGN_BOTTOM,
- dcp::DIRECTION_LTR,
+ dcp::VAlign::BOTTOM,
+ dcp::Direction::LTR,
"What's going on",
- dcp::BORDER,
+ dcp::Effect::BORDER,
dcp::Colour (1, 2, 3),
dcp::Time (1, 2, 3, 4, 24),
dcp::Time (5, 6, 7, 8, 24)
dcp::Time (0, 4, 9, 22, 24),
dcp::Time (0, 4, 11, 22, 24),
0,
- dcp::HALIGN_CENTER,
+ dcp::HAlign::CENTER,
0.8,
- dcp::VALIGN_TOP,
+ dcp::VAlign::TOP,
dcp::Time (0, 0, 0, 0, 24),
dcp::Time (0, 0, 0, 0, 24)
)
string const creator = "libdcp";
string const annotation_text = "Created by libdcp";
- shared_ptr<dcp::CPL> cpl (new dcp::CPL ("My film", dcp::FEATURE));
+ auto cpl = make_shared<dcp::CPL>("My film", dcp::ContentKind::FEATURE);
cpl->add (reel);
cpl->set_issuer (issuer);
cpl->set_creator (creator);
cpl->set_issue_date (issue_date);
cpl->set_annotation_text (annotation_text);
- optional<dcp::ContentVersion> cv = cpl->content_version();
+ auto cv = cpl->content_version();
BOOST_REQUIRE (cv);
cv->label_text = "foo";
cpl->set_content_version (*cv);
dcp::DCP dcp ("build/test/write_interop_subtitle_test3");
dcp.add (cpl);
- dcp.write_xml (dcp::INTEROP, issuer, creator, issue_date, annotation_text);
+ dcp.write_xml (dcp::Standard::INTEROP, issuer, creator, issue_date, annotation_text);
check_xml (
dcp::file_to_string("test/ref/write_interop_subtitle_test3/subs.xml"),
c.set_issue_date (dcp::LocalTime ("2016-04-01T03:52:00+00:00"));
c.add (
- shared_ptr<dcp::Subtitle> (
- new dcp::SubtitleString (
- string ("Frutiger"),
- false,
- false,
- false,
- dcp::Colour (255, 255, 255),
- 48,
- 1.0,
- dcp::Time (0, 4, 9, 22, 24),
- dcp::Time (0, 4, 11, 22, 24),
- 0,
- dcp::HALIGN_CENTER,
- 0.8,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_LTR,
- "Hello world",
- dcp::NONE,
- dcp::Colour (0, 0, 0),
- dcp::Time (0, 0, 0, 0, 24),
- dcp::Time (0, 0, 0, 0, 24)
- )
+ make_shared<dcp::SubtitleString> (
+ string ("Frutiger"),
+ false,
+ false,
+ false,
+ dcp::Colour (255, 255, 255),
+ 48,
+ 1.0,
+ dcp::Time (0, 4, 9, 22, 24),
+ dcp::Time (0, 4, 11, 22, 24),
+ 0,
+ dcp::HAlign::CENTER,
+ 0.8,
+ dcp::VAlign::TOP,
+ dcp::Direction::LTR,
+ "Hello world",
+ dcp::Effect::NONE,
+ dcp::Colour (0, 0, 0),
+ dcp::Time (0, 0, 0, 0, 24),
+ dcp::Time (0, 0, 0, 0, 24)
)
);
c.add (
- shared_ptr<dcp::Subtitle> (
- new dcp::SubtitleString (
- boost::optional<string> (),
- true,
- true,
- true,
- dcp::Colour (128, 0, 64),
- 91,
- 1.0,
- dcp::Time (5, 41, 0, 21, 24),
- dcp::Time (6, 12, 15, 21, 24),
- 0,
- dcp::HALIGN_CENTER,
- 0.4,
- dcp::VALIGN_BOTTOM,
- dcp::DIRECTION_RTL,
- "What's going on",
- dcp::BORDER,
- dcp::Colour (1, 2, 3),
- dcp::Time (1, 2, 3, 4, 24),
- dcp::Time (5, 6, 7, 8, 24)
- )
+ make_shared<dcp::SubtitleString>(
+ boost::optional<string> (),
+ true,
+ true,
+ true,
+ dcp::Colour (128, 0, 64),
+ 91,
+ 1.0,
+ dcp::Time (5, 41, 0, 21, 24),
+ dcp::Time (6, 12, 15, 21, 24),
+ 0,
+ dcp::HAlign::CENTER,
+ 0.4,
+ dcp::VAlign::BOTTOM,
+ dcp::Direction::RTL,
+ "What's going on",
+ dcp::Effect::BORDER,
+ dcp::Colour (1, 2, 3),
+ dcp::Time (1, 2, 3, 4, 24),
+ dcp::Time (5, 6, 7, 8, 24)
)
);
c.set_issue_date (dcp::LocalTime ("2016-04-01T03:52:00+00:00"));
c.add (
- shared_ptr<dcp::Subtitle> (
- new dcp::SubtitleString (
- string ("Arial"),
- false,
- false,
- false,
- dcp::Colour (255, 255, 255),
- 48,
- 1.0,
- dcp::Time (0, 0, 1, 0, 24),
- dcp::Time (0, 0, 9, 0, 24),
- 0,
- dcp::HALIGN_CENTER,
- 0.8,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_LTR,
- "Testing is ",
- dcp::NONE,
- dcp::Colour (0, 0, 0),
- dcp::Time (0, 0, 0, 0, 24),
- dcp::Time (0, 0, 0, 0, 24)
- )
+ make_shared<dcp::SubtitleString>(
+ string ("Arial"),
+ false,
+ false,
+ false,
+ dcp::Colour (255, 255, 255),
+ 48,
+ 1.0,
+ dcp::Time (0, 0, 1, 0, 24),
+ dcp::Time (0, 0, 9, 0, 24),
+ 0,
+ dcp::HAlign::CENTER,
+ 0.8,
+ dcp::VAlign::TOP,
+ dcp::Direction::LTR,
+ "Testing is ",
+ dcp::Effect::NONE,
+ dcp::Colour (0, 0, 0),
+ dcp::Time (0, 0, 0, 0, 24),
+ dcp::Time (0, 0, 0, 0, 24)
)
);
c.add (
- shared_ptr<dcp::Subtitle> (
- new dcp::SubtitleString (
- string ("Arial"),
- true,
- false,
- false,
- dcp::Colour (255, 255, 255),
- 48,
- 1.0,
- dcp::Time (0, 0, 1, 0, 24),
- dcp::Time (0, 0, 9, 0, 24),
- 0,
- dcp::HALIGN_CENTER,
- 0.8,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_LTR,
- "really",
- dcp::NONE,
- dcp::Colour (0, 0, 0),
- dcp::Time (0, 0, 0, 0, 24),
- dcp::Time (0, 0, 0, 0, 24)
- )
+ make_shared<dcp::SubtitleString>(
+ string ("Arial"),
+ true,
+ false,
+ false,
+ dcp::Colour (255, 255, 255),
+ 48,
+ 1.0,
+ dcp::Time (0, 0, 1, 0, 24),
+ dcp::Time (0, 0, 9, 0, 24),
+ 0,
+ dcp::HAlign::CENTER,
+ 0.8,
+ dcp::VAlign::TOP,
+ dcp::Direction::LTR,
+ "really",
+ dcp::Effect::NONE,
+ dcp::Colour (0, 0, 0),
+ dcp::Time (0, 0, 0, 0, 24),
+ dcp::Time (0, 0, 0, 0, 24)
)
);
c.add (
- shared_ptr<dcp::Subtitle> (
- new dcp::SubtitleString (
- string ("Arial"),
- false,
- false,
- false,
- dcp::Colour (255, 255, 255),
- 48,
- 1.0,
- dcp::Time (0, 0, 1, 0, 24),
- dcp::Time (0, 0, 9, 0, 24),
- 0,
- dcp::HALIGN_CENTER,
- 0.8,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_LTR,
- " fun",
- dcp::NONE,
- dcp::Colour (0, 0, 0),
- dcp::Time (0, 0, 0, 0, 24),
- dcp::Time (0, 0, 0, 0, 24)
- )
+ make_shared<dcp::SubtitleString>(
+ string ("Arial"),
+ false,
+ false,
+ false,
+ dcp::Colour (255, 255, 255),
+ 48,
+ 1.0,
+ dcp::Time (0, 0, 1, 0, 24),
+ dcp::Time (0, 0, 9, 0, 24),
+ 0,
+ dcp::HAlign::CENTER,
+ 0.8,
+ dcp::VAlign::TOP,
+ dcp::Direction::LTR,
+ " fun",
+ dcp::Effect::NONE,
+ dcp::Colour (0, 0, 0),
+ dcp::Time (0, 0, 0, 0, 24),
+ dcp::Time (0, 0, 0, 0, 24)
)
);
c.add (
- shared_ptr<dcp::Subtitle> (
- new dcp::SubtitleString (
- string ("Arial"),
- false,
- false,
- false,
- dcp::Colour (255, 255, 255),
- 48,
- 1.0,
- dcp::Time (0, 0, 1, 0, 24),
- dcp::Time (0, 0, 9, 0, 24),
- 0,
- dcp::HALIGN_CENTER,
- 0.9,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_LTR,
- "This is the ",
- dcp::NONE,
- dcp::Colour (0, 0, 0),
- dcp::Time (0, 0, 0, 0, 24),
- dcp::Time (0, 0, 0, 0, 24)
- )
+ make_shared<dcp::SubtitleString>(
+ string ("Arial"),
+ false,
+ false,
+ false,
+ dcp::Colour (255, 255, 255),
+ 48,
+ 1.0,
+ dcp::Time (0, 0, 1, 0, 24),
+ dcp::Time (0, 0, 9, 0, 24),
+ 0,
+ dcp::HAlign::CENTER,
+ 0.9,
+ dcp::VAlign::TOP,
+ dcp::Direction::LTR,
+ "This is the ",
+ dcp::Effect::NONE,
+ dcp::Colour (0, 0, 0),
+ dcp::Time (0, 0, 0, 0, 24),
+ dcp::Time (0, 0, 0, 0, 24)
)
);
c.add (
- shared_ptr<dcp::Subtitle> (
- new dcp::SubtitleString (
- string ("Arial"),
- true,
- false,
- false,
- dcp::Colour (255, 255, 255),
- 48,
- 1.0,
- dcp::Time (0, 0, 1, 0, 24),
- dcp::Time (0, 0, 9, 0, 24),
- 0,
- dcp::HALIGN_CENTER,
- 0.9,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_LTR,
- "second",
- dcp::NONE,
- dcp::Colour (0, 0, 0),
- dcp::Time (0, 0, 0, 0, 24),
- dcp::Time (0, 0, 0, 0, 24)
- )
+ make_shared<dcp::SubtitleString>(
+ string ("Arial"),
+ true,
+ false,
+ false,
+ dcp::Colour (255, 255, 255),
+ 48,
+ 1.0,
+ dcp::Time (0, 0, 1, 0, 24),
+ dcp::Time (0, 0, 9, 0, 24),
+ 0,
+ dcp::HAlign::CENTER,
+ 0.9,
+ dcp::VAlign::TOP,
+ dcp::Direction::LTR,
+ "second",
+ dcp::Effect::NONE,
+ dcp::Colour (0, 0, 0),
+ dcp::Time (0, 0, 0, 0, 24),
+ dcp::Time (0, 0, 0, 0, 24)
)
);
c.add (
- shared_ptr<dcp::Subtitle> (
- new dcp::SubtitleString (
- string ("Arial"),
- false,
- false,
- false,
- dcp::Colour (255, 255, 255),
- 48,
- 1.0,
- dcp::Time (0, 0, 1, 0, 24),
- dcp::Time (0, 0, 9, 0, 24),
- 0,
- dcp::HALIGN_CENTER,
- 0.9,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_LTR,
- " line",
- dcp::NONE,
- dcp::Colour (0, 0, 0),
- dcp::Time (0, 0, 0, 0, 24),
- dcp::Time (0, 0, 0, 0, 24)
- )
+ make_shared<dcp::SubtitleString>(
+ string ("Arial"),
+ false,
+ false,
+ false,
+ dcp::Colour (255, 255, 255),
+ 48,
+ 1.0,
+ dcp::Time (0, 0, 1, 0, 24),
+ dcp::Time (0, 0, 9, 0, 24),
+ 0,
+ dcp::HAlign::CENTER,
+ 0.9,
+ dcp::VAlign::TOP,
+ dcp::Direction::LTR,
+ " line",
+ dcp::Effect::NONE,
+ dcp::Colour (0, 0, 0),
+ dcp::Time (0, 0, 0, 0, 24),
+ dcp::Time (0, 0, 0, 0, 24)
)
);
c._xml_id = "a6c58cff-3e1e-4b38-acec-a42224475ef6";
check_xml (
- c.xml_as_string (),
+ c.xml_as_string(),
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
"<dcst:SubtitleReel xmlns:dcst=\"http://www.smpte-ra.org/schemas/428-7/2010/DCST\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
"<dcst:Id>urn:uuid:a6c58cff-3e1e-4b38-acec-a42224475ef6</dcst:Id>"
c.set_content_title_text ("Test");
c.add (
- shared_ptr<dcp::Subtitle> (
- new dcp::SubtitleImage (
- dcp::ArrayData ("test/data/sub.png"),
- dcp::Time (0, 4, 9, 22, 24),
- dcp::Time (0, 4, 11, 22, 24),
- 0,
- dcp::HALIGN_CENTER,
- 0.8,
- dcp::VALIGN_TOP,
- dcp::Time (0, 0, 0, 0, 24),
- dcp::Time (0, 0, 0, 0, 24)
- )
+ make_shared<dcp::SubtitleImage>(
+ dcp::ArrayData ("test/data/sub.png"),
+ dcp::Time (0, 4, 9, 22, 24),
+ dcp::Time (0, 4, 11, 22, 24),
+ 0,
+ dcp::HAlign::CENTER,
+ 0.8,
+ dcp::VAlign::TOP,
+ dcp::Time (0, 0, 0, 0, 24),
+ dcp::Time (0, 0, 0, 0, 24)
)
- );
+ );
c._id = "a6c58cff-3e1e-4b38-acec-a42224475ef6";
void
note (NoteType t, string n)
{
- if (t == DCP_ERROR || verbose) {
+ if (t == NoteType::ERROR || verbose) {
cout << " " << n << "\n";
cout.flush ();
}
OUTPUT_PICTURE(
" duration %1 (%2) intrinsic %3",
*mp->duration(),
- dcp::Time(*mp->duration(), mp->frame_rate().as_float(), mp->frame_rate().as_float()).as_string(dcp::SMPTE),
+ dcp::Time(*mp->duration(), mp->frame_rate().as_float(), mp->frame_rate().as_float()).as_string(dcp::Standard::SMPTE),
mp->intrinsic_duration()
);
} else {
}
}
- OUTPUT_TOTAL_TIME("Total: %1\n", total_time.as_string(dcp::SMPTE));
+ OUTPUT_TOTAL_TIME("Total: %1\n", total_time.as_string(dcp::Standard::SMPTE));
return 0;
}
BOOST_FOREACH (dcp::DecryptedKDMKey i, dec_kdm.keys ()) {
cout << "\n";
cout << "\tID: " << i.id() << "\n";
- cout << "\tStandard: " << (i.standard() == dcp::SMPTE ? "SMPTE" : "Interop") << "\n";
+ cout << "\tStandard: " << (i.standard() == dcp::Standard::SMPTE ? "SMPTE" : "Interop") << "\n";
cout << "\tCPL ID: " << i.cpl_id() << "\n";
if (i.type()) {
cout << "\tType: " << i.type().get() << "\n";
dcp::DCP fixed (*output);
fixed.add (cpl);
fixed.resolve_refs (assets);
- fixed.write_xml (dcp::INTEROP);
+ fixed.write_xml (dcp::Standard::INTEROP);
cout << "Fixed XML files written to " << output->string() << "\n";
}
projects / libdcp.git / commitdiff