/*
- Copyright (C) 2012-2018 Carl Hetherington <cth@carlh.net>
+ Copyright (C) 2012-2021 Carl Hetherington <cth@carlh.net>
This file is part of libdcp.
files in the program, then also delete it here.
*/
+
+/** @file src/cpl.cc
+ * @brief CPL class
+ */
+
+
#include "cpl.h"
#include "util.h"
#include "reel.h"
#include <libxml/parser.h>
#include <libxml++/libxml++.h>
#include <boost/algorithm/string.hpp>
-#include <boost/foreach.hpp>
-using std::string;
+
+using std::cout;
+using std::dynamic_pointer_cast;
using std::list;
-using std::pair;
using std::make_pair;
-using std::cout;
+using std::make_shared;
+using std::pair;
using std::set;
+using std::shared_ptr;
+using std::string;
using std::vector;
-using boost::shared_ptr;
using boost::optional;
-using boost::dynamic_pointer_cast;
using namespace dcp;
static string const smpte_395_ns = "http://www.smpte-ra.org/reg/395/2014/13/1/aaf";
static string const smpte_335_ns = "http://www.smpte-ra.org/reg/335/2012";
+
CPL::CPL (string annotation_text, ContentKind content_kind)
/* default _content_title_text to annotation_text */
: _issuer ("libdcp" LIBDCP_VERSION)
_content_versions.push_back (cv);
}
-/** 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()));
}
_id = remove_urn_uuid (f.string_child ("Id"));
- _annotation_text = f.optional_string_child("AnnotationText").get_value_or("");
+ _annotation_text = f.optional_string_child("AnnotationText");
_issuer = f.optional_string_child("Issuer").get_value_or("");
_creator = f.optional_string_child("Creator").get_value_or("");
_issue_date = f.string_child ("IssueDate");
)
);
content_version->done ();
- } else if (_standard == SMPTE) {
+ } else if (_standard == Standard::SMPTE) {
/* ContentVersion is required in SMPTE */
throw XMLError ("Missing ContentVersion tag in CPL");
}
- cxml::ConstNodePtr rating_list = f.node_child ("RatingList");
+ auto rating_list = f.node_child ("RatingList");
if (rating_list) {
- BOOST_FOREACH (cxml::ConstNodePtr i, rating_list->node_children("Rating")) {
+ for (auto i: rating_list->node_children("Rating")) {
_ratings.push_back (Rating(i));
}
}
- _reels = type_grand_children<Reel> (f, "ReelList", "Reel");
- cxml::ConstNodePtr reel_list = f.node_child ("ReelList");
+ for (auto i: f.node_child("ReelList")->node_children("Reel")) {
+ _reels.push_back (make_shared<Reel>(i, *_standard));
+ }
+
+ auto reel_list = f.node_child ("ReelList");
if (reel_list) {
- list<cxml::NodePtr> reels = reel_list->node_children("Reel");
+ auto reels = reel_list->node_children("Reel");
if (!reels.empty()) {
- cxml::ConstNodePtr asset_list = reels.front()->node_child("AssetList");
- cxml::ConstNodePtr metadata = asset_list->optional_node_child("CompositionMetadataAsset");
+ auto asset_list = reels.front()->node_child("AssetList");
+ auto metadata = asset_list->optional_node_child("CompositionMetadataAsset");
if (metadata) {
read_composition_metadata_asset (metadata);
}
}
}
-
f.ignore_child ("Issuer");
f.ignore_child ("Signer");
f.ignore_child ("Signature");
f.done ();
}
-/** Add a reel to this CPL.
- * @param reel Reel to add.
- */
+
void
-CPL::add (boost::shared_ptr<Reel> reel)
+CPL::add (std::shared_ptr<Reel> reel)
{
_reels.push_back (reel);
}
-/** Write an CompositonPlaylist XML file.
- *
- * @param file Filename to write.
- * @param standard INTEROP or SMPTE.
- * @param signer Signer to sign the CPL, or 0 to add no signature.
- */
+
void
CPL::write_xml (boost::filesystem::path file, Standard standard, shared_ptr<const CertificateChain> signer) const
{
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);
}
root->add_child("Id")->add_child_text ("urn:uuid:" + _id);
- root->add_child("AnnotationText")->add_child_text (_annotation_text);
+ if (_annotation_text) {
+ root->add_child("AnnotationText")->add_child_text (*_annotation_text);
+ }
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);
root->add_child("ContentTitleText")->add_child_text (_content_title_text);
root->add_child("ContentKind")->add_child_text (content_kind_to_string (_content_kind));
- DCP_ASSERT (!_content_versions.empty());
- _content_versions[0].as_xml (root);
+ if (_content_versions.empty()) {
+ ContentVersion cv;
+ cv.as_xml (root);
+ } else {
+ _content_versions[0].as_xml (root);
+ }
- xmlpp::Element* rating_list = root->add_child("RatingList");
- BOOST_FOREACH (Rating i, _ratings) {
+ auto rating_list = root->add_child("RatingList");
+ for (auto i: _ratings) {
i.as_xml (rating_list->add_child("Rating"));
}
- xmlpp::Element* reel_list = root->add_child ("ReelList");
+ auto reel_list = root->add_child ("ReelList");
+
+ if (_reels.empty()) {
+ throw NoReelsError ();
+ }
bool first = true;
- BOOST_FOREACH (shared_ptr<Reel> i, _reels) {
- xmlpp::Element* asset_list = i->write_to_cpl (reel_list, standard);
- if (first && standard == dcp::SMPTE) {
+ for (auto i: _reels) {
+ auto asset_list = i->write_to_cpl (reel_list, standard);
+ if (first && standard == Standard::SMPTE) {
maybe_write_composition_metadata_asset (asset_list);
first = false;
}
void
CPL::read_composition_metadata_asset (cxml::ConstNodePtr node)
{
- cxml::ConstNodePtr fctt = node->node_child("FullContentTitleText");
+ auto fctt = node->node_child("FullContentTitleText");
_full_content_title_text = fctt->content();
_full_content_title_text_language = fctt->optional_string_attribute("language");
_release_territory = node->optional_string_child("ReleaseTerritory");
+ if (_release_territory) {
+ _release_territory_scope = node->node_child("ReleaseTerritory")->optional_string_attribute("scope");
+ }
- cxml::ConstNodePtr vn = node->optional_node_child("VersionNumber");
+ auto vn = node->optional_node_child("VersionNumber");
if (vn) {
_version_number = raw_convert<int>(vn->content());
/* I decided to check for this number being non-negative on being set, and in the verifier, but not here */
- optional<string> vn_status = vn->optional_string_attribute("status");
+ auto vn_status = vn->optional_string_attribute("status");
if (vn_status) {
_status = string_to_status (*vn_status);
}
_distributor = node->optional_string_child("Distributor");
_facility = node->optional_string_child("Facility");
- cxml::ConstNodePtr acv = node->optional_node_child("AlternateContentVersionList");
+ auto acv = node->optional_node_child("AlternateContentVersionList");
if (acv) {
- BOOST_FOREACH (cxml::ConstNodePtr i, acv->node_children("ContentVersion")) {
+ for (auto i: acv->node_children("ContentVersion")) {
_content_versions.push_back (ContentVersion(i));
}
}
- cxml::ConstNodePtr lum = node->optional_node_child("Luminance");
+ auto lum = node->optional_node_child("Luminance");
if (lum) {
_luminance = Luminance (lum);
}
_main_sound_configuration = node->optional_string_child("MainSoundConfiguration");
- optional<string> sr = node->optional_string_child("MainSoundSampleRate");
+ auto sr = node->optional_string_child("MainSoundSampleRate");
if (sr) {
vector<string> sr_bits;
boost::split (sr_bits, *sr, boost::is_any_of(" "));
node->node_child("MainPictureActiveArea")->number_child<int>("Height")
);
- optional<string> sll = node->optional_string_child("MainSubtitleLanguageList");
+ auto sll = node->optional_string_child("MainSubtitleLanguageList");
if (sll) {
vector<string> sll_split;
boost::split (sll_split, *sll, boost::is_any_of(" "));
/* If the first language on SubtitleLanguageList is the same as the language of the first subtitle we'll ignore it */
size_t first = 0;
if (!_reels.empty()) {
- shared_ptr<dcp::ReelSubtitleAsset> sub = _reels.front()->main_subtitle();
+ auto sub = _reels.front()->main_subtitle();
if (sub) {
- optional<dcp::LanguageTag> lang = sub->language();
- if (lang && lang->to_string() == sll_split[0]) {
+ auto lang = sub->language();
+ if (lang && lang == sll_split[0]) {
first = 1;
}
}
}
- for (size_t i = first; i < sll_split.size(); ++i) {
+ for (auto i = first; i < sll_split.size(); ++i) {
_additional_subtitle_languages.push_back (sll_split[i]);
}
}
return;
}
- xmlpp::Element* meta = node->add_child("meta:CompositionMetadataAsset");
+ auto meta = node->add_child("meta:CompositionMetadataAsset");
meta->set_namespace_declaration (cpl_metadata_ns, "meta");
meta->add_child("Id")->add_child_text("urn:uuid:" + make_uuid());
- shared_ptr<dcp::ReelPictureAsset> mp = _reels.front()->main_picture();
+ auto mp = _reels.front()->main_picture();
meta->add_child("EditRate")->add_child_text(mp->edit_rate().as_string());
meta->add_child("IntrinsicDuration")->add_child_text(raw_convert<string>(mp->intrinsic_duration()));
- xmlpp::Element* fctt = meta->add_child("FullContentTitleText", "meta");
+ auto fctt = meta->add_child("FullContentTitleText", "meta");
if (_full_content_title_text) {
fctt->add_child_text (*_full_content_title_text);
}
meta->add_child("MainSoundConfiguration", "meta")->add_child_text(*_main_sound_configuration);
meta->add_child("MainSoundSampleRate", "meta")->add_child_text(raw_convert<string>(*_main_sound_sample_rate) + " 1");
- xmlpp::Element* stored = meta->add_child("MainPictureStoredArea", "meta");
+ auto stored = meta->add_child("MainPictureStoredArea", "meta");
stored->add_child("Width", "meta")->add_child_text(raw_convert<string>(_main_picture_stored_area->width));
stored->add_child("Height", "meta")->add_child_text(raw_convert<string>(_main_picture_stored_area->height));
- xmlpp::Element* active = meta->add_child("MainPictureActiveArea", "meta");
+ auto active = meta->add_child("MainPictureActiveArea", "meta");
active->add_child("Width", "meta")->add_child_text(raw_convert<string>(_main_picture_active_area->width));
active->add_child("Height", "meta")->add_child_text(raw_convert<string>(_main_picture_active_area->height));
- optional<dcp::LanguageTag> first_subtitle_language;
- BOOST_FOREACH (shared_ptr<const Reel> i, _reels) {
+ optional<string> first_subtitle_language;
+ for (auto i: _reels) {
if (i->main_subtitle()) {
first_subtitle_language = i->main_subtitle()->language();
if (first_subtitle_language) {
if (first_subtitle_language || !_additional_subtitle_languages.empty()) {
string lang;
if (first_subtitle_language) {
- lang = first_subtitle_language->to_string();
+ lang = *first_subtitle_language;
}
- BOOST_FOREACH (dcp::LanguageTag const& i, _additional_subtitle_languages) {
+ for (auto const& i: _additional_subtitle_languages) {
if (!lang.empty()) {
lang += " ";
}
- lang += i.to_string();
+ lang += i;
}
- meta->add_child("MainSubtitleLanguageList")->add_child_text(lang);
+ meta->add_child("MainSubtitleLanguageList", "meta")->add_child_text(lang);
}
+ /* SMPTE Bv2.1 8.6.3 */
+ auto extension = meta->add_child("ExtensionMetadataList", "meta")->add_child("ExtensionMetadata", "meta");
+ extension->set_attribute("scope", "http://isdcf.com/ns/cplmd/app");
+ extension->add_child("Name", "meta")->add_child_text("Application");
+ auto property = extension->add_child("PropertyList", "meta")->add_child("Property", "meta");
+ property->add_child("Name", "meta")->add_child_text("DCP Constraints Profile");
+ property->add_child("Value", "meta")->add_child_text("SMPTE-RDD-52:2020-Bv2.1");
+
if (_reels.front()->main_sound()) {
- shared_ptr<const SoundAsset> asset = _reels.front()->main_sound()->asset();
+ auto asset = _reels.front()->main_sound()->asset();
if (asset) {
- shared_ptr<SoundAssetReader> reader = asset->start_read ();
+ auto reader = asset->start_read ();
ASDCP::MXF::SoundfieldGroupLabelSubDescriptor* soundfield;
ASDCP::Result_t r = reader->reader()->OP1aHeader().GetMDObjectByType(
- ASDCP::DefaultSMPTEDict().ul(ASDCP::MDD_SoundfieldGroupLabelSubDescriptor),
+ asdcp_smpte_dict->ul(ASDCP::MDD_SoundfieldGroupLabelSubDescriptor),
reinterpret_cast<ASDCP::MXF::InterchangeObject**>(&soundfield)
);
if (KM_SUCCESS(r)) {
- xmlpp::Element* mca_subs = meta->add_child("mca:MCASubDescriptors");
+ auto mca_subs = meta->add_child("mca:MCASubDescriptors");
mca_subs->set_namespace_declaration (mca_sub_descriptors_ns, "mca");
mca_subs->set_namespace_declaration (smpte_395_ns, "r0");
mca_subs->set_namespace_declaration (smpte_335_ns, "r1");
- xmlpp::Element* sf = mca_subs->add_child("SoundfieldGroupLabelSubDescriptor", "r0");
+ auto sf = mca_subs->add_child("SoundfieldGroupLabelSubDescriptor", "r0");
char buffer[64];
soundfield->InstanceUID.EncodeString(buffer, sizeof(buffer));
sf->add_child("InstanceID", "r1")->add_child_text("urn:uuid:" + string(buffer));
}
list<ASDCP::MXF::InterchangeObject*> channels;
- ASDCP::Result_t r = reader->reader()->OP1aHeader().GetMDObjectsByType(
- ASDCP::DefaultSMPTEDict().ul(ASDCP::MDD_AudioChannelLabelSubDescriptor),
+ auto r = reader->reader()->OP1aHeader().GetMDObjectsByType(
+ asdcp_smpte_dict->ul(ASDCP::MDD_AudioChannelLabelSubDescriptor),
channels
);
- BOOST_FOREACH (ASDCP::MXF::InterchangeObject* i, channels) {
-
ASDCP::MXF::AudioChannelLabelSubDescriptor* channel = reinterpret_cast<ASDCP::MXF::AudioChannelLabelSubDescriptor*>(i);
- xmlpp::Element* ch = mca_subs->add_child("AudioChannelLabelSubDescriptor", "r0");
+ for (auto i: channels) {
+
auto channel = reinterpret_cast<ASDCP::MXF::AudioChannelLabelSubDescriptor*>(i);
+ auto ch = mca_subs->add_child("AudioChannelLabelSubDescriptor", "r0");
channel->InstanceUID.EncodeString(buffer, sizeof(buffer));
ch->add_child("InstanceID", "r1")->add_child_text("urn:uuid:" + string(buffer));
channel->MCALabelDictionaryID.EncodeString(buffer, sizeof(buffer));
}
-list<shared_ptr<ReelMXF> >
-CPL::reel_mxfs ()
+template <class T>
+void
+add_file_assets (vector<shared_ptr<T>>& assets, vector<shared_ptr<Reel>> reels)
{
- list<shared_ptr<ReelMXF> > c;
-
- BOOST_FOREACH (shared_ptr<Reel> i, _reels) {
+ for (auto i: reels) {
if (i->main_picture ()) {
- c.push_back (i->main_picture());
+ assets.push_back (i->main_picture());
}
if (i->main_sound ()) {
- c.push_back (i->main_sound());
+ assets.push_back (i->main_sound());
}
if (i->main_subtitle ()) {
- c.push_back (i->main_subtitle());
+ assets.push_back (i->main_subtitle());
}
- BOOST_FOREACH (shared_ptr<ReelClosedCaptionAsset> j, i->closed_captions()) {
- c.push_back (j);
+ for (auto j: i->closed_captions()) {
+ assets.push_back (j);
}
if (i->atmos ()) {
- c.push_back (i->atmos());
+ assets.push_back (i->atmos());
}
}
+}
+
+vector<shared_ptr<ReelFileAsset>>
+CPL::reel_file_assets ()
+{
+ vector<shared_ptr<ReelFileAsset>> c;
+ add_file_assets (c, _reels);
return c;
}
-list<shared_ptr<const ReelMXF> >
-CPL::reel_mxfs () const
+
+vector<shared_ptr<const ReelFileAsset>>
+CPL::reel_file_assets () const
{
- list<shared_ptr<const ReelMXF> > c;
+ vector<shared_ptr<const ReelFileAsset>> c;
+ add_file_assets (c, _reels);
+ return c;
+}
+
- BOOST_FOREACH (shared_ptr<Reel> i, _reels) {
+template <class T>
+void
+add_encryptable_assets (vector<shared_ptr<T>>& assets, vector<shared_ptr<Reel>> reels)
+{
+ for (auto i: reels) {
if (i->main_picture ()) {
- c.push_back (i->main_picture());
+ assets.push_back (i->main_picture());
}
if (i->main_sound ()) {
- c.push_back (i->main_sound());
+ assets.push_back (i->main_sound());
}
if (i->main_subtitle ()) {
- c.push_back (i->main_subtitle());
+ if (auto enc = dynamic_pointer_cast<ReelEncryptableAsset>(i->main_subtitle())) {
+ assets.push_back (enc);
+ }
}
- BOOST_FOREACH (shared_ptr<ReelClosedCaptionAsset> j, i->closed_captions()) {
- c.push_back (j);
+ for (auto j: i->closed_captions()) {
+ assets.push_back (j);
}
if (i->atmos ()) {
- c.push_back (i->atmos());
+ assets.push_back (i->atmos());
}
}
+}
+
+vector<shared_ptr<ReelEncryptableAsset>>
+CPL::reel_encryptable_assets ()
+{
+ vector<shared_ptr<ReelEncryptableAsset>> c;
+ add_encryptable_assets (c, _reels);
return c;
}
+
+vector<shared_ptr<const ReelEncryptableAsset>>
+CPL::reel_encryptable_assets () const
+{
+ vector<shared_ptr<const ReelEncryptableAsset>> c;
+ add_encryptable_assets (c, _reels);
+ return c;
+}
+
+
bool
CPL::equals (shared_ptr<const Asset> other, EqualityOptions opt, NoteHandler note) const
{
- shared_ptr<const CPL> other_cpl = dynamic_pointer_cast<const CPL> (other);
+ auto other_cpl = dynamic_pointer_cast<const CPL>(other);
if (!other_cpl) {
return false;
}
if (_annotation_text != other_cpl->_annotation_text && !opt.cpl_annotation_texts_can_differ) {
- string const s = "CPL: annotation texts differ: " + _annotation_text + " vs " + other_cpl->_annotation_text + "\n";
- note (DCP_ERROR, s);
+ string const s = "CPL: annotation texts differ: " + _annotation_text.get_value_or("") + " vs " + other_cpl->_annotation_text.get_value_or("") + "\n";
+ 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;
}
- list<shared_ptr<Reel> >::const_iterator a = _reels.begin ();
- list<shared_ptr<Reel> >::const_iterator b = other_cpl->_reels.begin ();
+ auto a = _reels.begin();
+ auto b = other_cpl->_reels.begin();
while (a != _reels.end ()) {
if (!(*a)->equals (*b, opt, note)) {
return true;
}
-/** @return true if we have any encrypted content */
+
bool
-CPL::encrypted () const
+CPL::any_encrypted () const
{
- BOOST_FOREACH (shared_ptr<Reel> i, _reels) {
- if (i->encrypted ()) {
+ for (auto i: _reels) {
+ if (i->any_encrypted()) {
return true;
}
}
return false;
}
-/** Add a KDM to this CPL. If the KDM is for any of this CPLs assets it will be used
- * to decrypt those assets.
- * @param kdm KDM.
- */
+
+bool
+CPL::all_encrypted () const
+{
+ for (auto i: _reels) {
+ if (!i->all_encrypted()) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+
void
CPL::add (DecryptedKDM const & kdm)
{
- BOOST_FOREACH (shared_ptr<Reel> i, _reels) {
+ for (auto i: _reels) {
i->add (kdm);
}
}
void
-CPL::resolve_refs (list<shared_ptr<Asset> > assets)
+CPL::resolve_refs (vector<shared_ptr<Asset>> assets)
{
- BOOST_FOREACH (shared_ptr<Reel> i, _reels) {
+ for (auto i: _reels) {
i->resolve_refs (assets);
}
}
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);
CPL::duration () const
{
int64_t d = 0;
- BOOST_FOREACH (shared_ptr<Reel> i, _reels) {
+ for (auto i: _reels) {
d += i->duration ();
}
return d;
}
+void
+CPL::unset_version_number ()
+{
+ _version_number = boost::none;
+}
+
+
void
CPL::set_content_versions (vector<ContentVersion> v)
{
set<string> ids;
- BOOST_FOREACH (ContentVersion i, v) {
+ for (auto i: v) {
if (!ids.insert(i.id).second) {
throw DuplicateIdError ("Duplicate ID in ContentVersion list");
}
}
-ContentVersion
+optional<ContentVersion>
CPL::content_version () const
{
- DCP_ASSERT (!_content_versions.empty());
+ if (_content_versions.empty()) {
+ return optional<ContentVersion>();
+ }
+
return _content_versions[0];
}
CPL::set_additional_subtitle_languages (vector<dcp::LanguageTag> const& langs)
{
_additional_subtitle_languages.clear ();
- BOOST_FOREACH (dcp::LanguageTag const& i, langs) {
+ for (auto const& i: langs) {
_additional_subtitle_languages.push_back (i.to_string());
}
}
projects / libdcp.git / blobdiff