files in the program, then also delete it here.
*/
+
+/** @file src/cpl.cc
+ * @brief CPL class
+ */
+
+
+#include "certificate_chain.h"
+#include "compose.hpp"
#include "cpl.h"
-#include "util.h"
-#include "reel.h"
+#include "dcp_assert.h"
+#include "local_time.h"
#include "metadata.h"
-#include "certificate_chain.h"
-#include "xml.h"
+#include "raw_convert.h"
+#include "reel.h"
+#include "reel_atmos_asset.h"
+#include "reel_closed_caption_asset.h"
#include "reel_picture_asset.h"
#include "reel_sound_asset.h"
#include "reel_subtitle_asset.h"
-#include "reel_closed_caption_asset.h"
-#include "reel_atmos_asset.h"
-#include "local_time.h"
-#include "dcp_assert.h"
-#include "compose.hpp"
-#include "raw_convert.h"
+#include "util.h"
+#include "warnings.h"
+#include "xml.h"
+LIBDCP_DISABLE_WARNINGS
#include <asdcp/Metadata.h>
+LIBDCP_ENABLE_WARNINGS
#include <libxml/parser.h>
+LIBDCP_DISABLE_WARNINGS
#include <libxml++/libxml++.h>
+LIBDCP_ENABLE_WARNINGS
#include <boost/algorithm/string.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::vector;
using std::shared_ptr;
+using std::string;
+using std::vector;
using boost::optional;
-using std::dynamic_pointer_cast;
using namespace dcp;
static string const smpte_335_ns = "http://www.smpte-ra.org/reg/335/2012";
-CPL::CPL (string annotation_text, ContentKind content_kind)
+CPL::CPL (string annotation_text, ContentKind content_kind, Standard standard)
/* default _content_title_text to annotation_text */
: _issuer ("libdcp" LIBDCP_VERSION)
, _creator ("libdcp" LIBDCP_VERSION)
, _annotation_text (annotation_text)
, _content_title_text (annotation_text)
, _content_kind (content_kind)
+ , _standard (standard)
{
ContentVersion cv;
cv.label_text = cv.id + LocalTime().as_string();
_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_title_text = f.string_child ("ContentTitleText");
- _content_kind = content_kind_from_string (f.string_child ("ContentKind"));
+ auto content_kind = f.node_child("ContentKind");
+ _content_kind = ContentKind(content_kind->content(), content_kind->optional_string_attribute("scope"));
shared_ptr<cxml::Node> content_version = f.optional_node_child ("ContentVersion");
if (content_version) {
/* XXX: SMPTE should insist that Id is present */
)
);
content_version->done ();
- } else if (_standard == SMPTE) {
+ } else if (_standard == Standard::SMPTE) {
/* ContentVersion is required in SMPTE */
throw XMLError ("Missing ContentVersion tag in CPL");
}
auto rating_list = f.node_child ("RatingList");
- if (rating_list) {
- for (auto i: rating_list->node_children("Rating")) {
- _ratings.push_back (Rating(i));
- }
+ for (auto i: rating_list->node_children("Rating")) {
+ _ratings.push_back (Rating(i));
+ }
+
+ for (auto i: f.node_child("ReelList")->node_children("Reel")) {
+ _reels.push_back (make_shared<Reel>(i, _standard));
}
- _reels = type_grand_children<Reel> (f, "ReelList", "Reel");
auto reel_list = f.node_child ("ReelList");
- if (reel_list) {
- auto reels = reel_list->node_children("Reel");
- if (!reels.empty()) {
- auto asset_list = reels.front()->node_child("AssetList");
- auto metadata = asset_list->optional_node_child("CompositionMetadataAsset");
- if (metadata) {
- read_composition_metadata_asset (metadata);
- }
+ auto reels = reel_list->node_children("Reel");
+ if (!reels.empty()) {
+ auto asset_list = reels.front()->node_child("AssetList");
+ auto metadata = asset_list->optional_node_child("CompositionMetadataAsset");
+ if (metadata) {
+ read_composition_metadata_asset (metadata);
+ _read_composition_metadata = true;
}
}
-
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 (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
+CPL::set (std::vector<std::shared_ptr<Reel>> reels)
+{
+ _reels = reels;
+}
+
+
+void
+CPL::write_xml (boost::filesystem::path file, 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));
+ auto content_kind = root->add_child("ContentKind");
+ content_kind->add_child_text(_content_kind.name());
+ if (_content_kind.scope()) {
+ content_kind->set_attribute("scope", *_content_kind.scope());
+ }
if (_content_versions.empty()) {
ContentVersion cv;
cv.as_xml (root);
bool first = true;
for (auto i: _reels) {
- auto asset_list = i->write_to_cpl (reel_list, standard);
- if (first && standard == dcp::SMPTE) {
+ auto asset_list = i->write_to_cpl (reel_list, _standard);
+ if (first && _standard == Standard::SMPTE) {
maybe_write_composition_metadata_asset (asset_list);
first = false;
}
indent (root, 0);
if (signer) {
- signer->sign (root, standard);
+ signer->sign (root, _standard);
}
doc.write_to_file_formatted (file.string(), "UTF-8");
void
CPL::read_composition_metadata_asset (cxml::ConstNodePtr node)
{
- auto fctt = node->node_child("FullContentTitleText");
- _full_content_title_text = fctt->content();
- _full_content_title_text_language = fctt->optional_string_attribute("language");
+ _cpl_metadata_id = remove_urn_uuid(node->string_child("Id"));
+
+ /* FullContentTitleText is compulsory but in DoM #2295 we saw a commercial tool which
+ * apparently didn't include it, so as usual we have to be defensive.
+ */
+ if (auto fctt = node->optional_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");
+ }
auto vn = node->optional_node_child("VersionNumber");
if (vn) {
/* 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<string> lang = sub->language();
+ auto lang = sub->language();
if (lang && lang == sll_split[0]) {
first = 1;
}
_additional_subtitle_languages.push_back (sll_split[i]);
}
}
+
+ auto eml = node->optional_node_child ("ExtensionMetadataList");
+ if (eml) {
+ for (auto i: eml->node_children("ExtensionMetadata")) {
+ auto name = i->optional_string_child("Name");
+ if (name && *name == "Sign Language Video") {
+ auto property_list = i->node_child("PropertyList");
+ for (auto j: property_list->node_children("Property")) {
+ auto name = j->optional_string_child("Name");
+ auto value = j->optional_string_child("Value");
+ if (name && value && *name == "Language Tag") {
+ _sign_language_video_language = *value;
+ }
+ }
+ }
+ }
+ }
}
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());
+ meta->add_child("Id")->add_child_text("urn:uuid:" + _cpl_metadata_id);
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()));
auto fctt = meta->add_child("FullContentTitleText", "meta");
- if (_full_content_title_text) {
+ if (_full_content_title_text && !_full_content_title_text->empty()) {
fctt->add_child_text (*_full_content_title_text);
}
if (_full_content_title_text_language) {
meta->add_child("MainSubtitleLanguageList", "meta")->add_child_text(lang);
}
+ auto metadata_list = meta->add_child("ExtensionMetadataList", "meta");
+
+ auto add_extension_metadata = [metadata_list](string scope, string name, string property_name, string property_value) {
+ auto extension = metadata_list->add_child("ExtensionMetadata", "meta");
+ extension->set_attribute("scope", scope);
+ extension->add_child("Name", "meta")->add_child_text(name);
+ auto property = extension->add_child("PropertyList", "meta")->add_child("Property", "meta");
+ property->add_child("Name", "meta")->add_child_text(property_name);
+ property->add_child("Value", "meta")->add_child_text(property_value);
+ };
+
/* 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");
+ add_extension_metadata ("http://isdcf.com/ns/cplmd/app", "Application", "DCP Constraints Profile", "SMPTE-RDD-52:2020-Bv2.1");
+
+ if (_sign_language_video_language) {
+ add_extension_metadata ("http://isdcf.com/2017/10/SignLanguageVideo", "Sign Language Video", "Language Tag", *_sign_language_video_language);
+ }
if (_reels.front()->main_sound()) {
auto asset = _reels.front()->main_sound()->asset();
for (auto i: channels) {
auto channel = reinterpret_cast<ASDCP::MXF::AudioChannelLabelSubDescriptor*>(i);
+ if (static_cast<int>(channel->MCAChannelID) > asset->channels()) {
+ continue;
+ }
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));
}
-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;
-
- for (auto 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());
}
for (auto j: i->closed_captions()) {
- c.push_back (j);
+ assets.push_back (j);
}
if (i->atmos ()) {
- c.push_back (i->atmos());
+ assets.push_back (i->atmos());
}
}
-
- return c;
}
-list<shared_ptr<const ReelMXF>>
-CPL::reel_mxfs () const
+
+vector<shared_ptr<ReelFileAsset>>
+CPL::reel_file_assets ()
{
- list<shared_ptr<const ReelMXF>> c;
+ vector<shared_ptr<ReelFileAsset>> c;
+ add_file_assets (c, _reels);
+ return c;
+}
- for (auto i: _reels) {
- if (i->main_picture ()) {
- c.push_back (i->main_picture());
- }
- if (i->main_sound ()) {
- c.push_back (i->main_sound());
- }
- if (i->main_subtitle ()) {
- c.push_back (i->main_subtitle());
- }
- for (auto j: i->closed_captions()) {
- c.push_back (j);
- }
- if (i->atmos ()) {
- c.push_back (i->atmos());
- }
- }
+vector<shared_ptr<const ReelFileAsset>>
+CPL::reel_file_assets () const
+{
+ vector<shared_ptr<const ReelFileAsset>> c;
+ add_file_assets (c, _reels);
return c;
}
+
bool
CPL::equals (shared_ptr<const Asset> other, EqualityOptions opt, NoteHandler note) const
{
}
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;
}
return true;
}
-/** @return true if we have any encrypted content */
+
bool
-CPL::encrypted () const
+CPL::any_encrypted () const
{
for (auto i: _reels) {
- if (i->encrypted ()) {
+ 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)
{
}
void
-CPL::resolve_refs (list<shared_ptr<Asset>> assets)
+CPL::resolve_refs (vector<shared_ptr<Asset>> assets)
{
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);
}
+void
+CPL::unset_version_number ()
+{
+ _version_number = boost::none;
+}
+
+
void
CPL::set_content_versions (vector<ContentVersion> v)
{
- set<string> ids;
+ std::set<string> ids;
for (auto i: v) {
if (!ids.insert(i.id).second) {
throw DuplicateIdError ("Duplicate ID in ContentVersion list");
_additional_subtitle_languages.push_back (i.to_string());
}
}
+
+
+void
+CPL::set_main_picture_active_area(dcp::Size area)
+{
+ if (area.width % 2) {
+ throw BadSettingError("Main picture active area width is not a multiple of 2");
+ }
+
+ if (area.height % 2) {
+ throw BadSettingError("Main picture active area height is not a multiple of 2");
+ }
+
+ _main_picture_active_area = area;
+}
+