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++/libxml++.h>
#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_version->done ();
- } else if (_standard == SMPTE) {
+ } else if (_standard == Standard::SMPTE) {
/* ContentVersion is required in SMPTE */
throw XMLError ("Missing ContentVersion tag in CPL");
}
_ratings.push_back (Rating(i));
}
}
- _reels = type_grand_children<Reel> (f, "ReelList", "Reel");
+
+ 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) {
}
}
-
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::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);
auto reel_list = root->add_child ("ReelList");
+ if (_reels.empty()) {
+ throw NoReelsError ();
+ }
+
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");
_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;
}
}
-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)
{
projects / libdcp.git / blobdiff