X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Fdcp.cc;h=3b267090580e2b1b97bd0e6dadc9e43ebb5c2f77;hb=e702623781c8d5853b79a29ca8c5f495d0ade3d1;hp=f99d3433053cef6fe9448292d04c74d4b0b7ca08;hpb=04def4c193777d7a6cbd306d0a3ba3944335e444;p=libdcp.git

diff --git a/src/dcp.cc b/src/dcp.cc
index f99d3433..3b267090 100644
--- a/src/dcp.cc
+++ b/src/dcp.cc
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2012-2015 Carl Hetherington <cth@carlh.net>
+    Copyright (C) 2012-2021 Carl Hetherington <cth@carlh.net>
 
     This file is part of libdcp.
 
@@ -31,59 +31,70 @@
     files in the program, then also delete it here.
 */
 
+
 /** @file  src/dcp.cc
- *  @brief DCP class.
+ *  @brief DCP class
  */
 
-#include "raw_convert.h"
-#include "dcp.h"
-#include "sound_asset.h"
-#include "picture_asset.h"
-#include "interop_subtitle_asset.h"
-#include "smpte_subtitle_asset.h"
-#include "mono_picture_asset.h"
-#include "stereo_picture_asset.h"
-#include "reel_subtitle_asset.h"
-#include "util.h"
-#include "metadata.h"
-#include "exceptions.h"
-#include "cpl.h"
+
+#include "asset_factory.h"
+#include "atmos_asset.h"
 #include "certificate_chain.h"
 #include "compose.hpp"
+#include "cpl.h"
+#include "dcp.h"
+#include "dcp_assert.h"
 #include "decrypted_kdm.h"
 #include "decrypted_kdm_key.h"
-#include "dcp_assert.h"
-#include "reel_asset.h"
+#include "exceptions.h"
 #include "font_asset.h"
+#include "interop_subtitle_asset.h"
+#include "metadata.h"
+#include "mono_picture_asset.h"
+#include "picture_asset.h"
+#include "pkl.h"
+#include "raw_convert.h"
+#include "reel_asset.h"
+#include "reel_subtitle_asset.h"
+#include "smpte_subtitle_asset.h"
+#include "sound_asset.h"
+#include "stereo_picture_asset.h"
+#include "util.h"
+#include "verify.h"
+#include "warnings.h"
+LIBDCP_DISABLE_WARNINGS
 #include <asdcp/AS_DCP.h>
+LIBDCP_ENABLE_WARNINGS
 #include <xmlsec/xmldsig.h>
 #include <xmlsec/app.h>
+LIBDCP_DISABLE_WARNINGS
 #include <libxml++/libxml++.h>
-#include <boost/filesystem.hpp>
+LIBDCP_ENABLE_WARNINGS
 #include <boost/algorithm/string.hpp>
-#include <boost/foreach.hpp>
+#include <boost/filesystem.hpp>
+#include <numeric>
 
-using std::string;
-using std::list;
-using std::vector;
+
+using std::cerr;
 using std::cout;
+using std::dynamic_pointer_cast;
+using std::exception;
+using std::list;
 using std::make_pair;
+using std::make_shared;
 using std::map;
-using std::cout;
-using std::cerr;
-using std::exception;
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::string;
+using std::vector;
 using boost::algorithm::starts_with;
+using boost::optional;
 using namespace dcp;
 
-static string const assetmap_interop_ns = "http://www.digicine.com/PROTO-ASDCP-AM-20040311#";
-static string const assetmap_smpte_ns   = "http://www.smpte-ra.org/schemas/429-9/2007/AM";
-static string const pkl_interop_ns      = "http://www.digicine.com/PROTO-ASDCP-PKL-20040311#";
-static string const pkl_smpte_ns        = "http://www.smpte-ra.org/schemas/429-8/2007/PKL";
-static string const volindex_interop_ns = "http://www.digicine.com/PROTO-ASDCP-AM-20040311#";
+
+static string const volindex_interop_ns = "http://www.digicine.com/PROTO-ASDCP-VL-20040311#";
 static string const volindex_smpte_ns   = "http://www.smpte-ra.org/schemas/429-9/2007/AM";
 
+
 DCP::DCP (boost::filesystem::path directory)
 	: _directory (directory)
 {
@@ -94,171 +105,252 @@ DCP::DCP (boost::filesystem::path directory)
 	_directory = boost::filesystem::canonical (_directory);
 }
 
-/** Call this instead of throwing an exception if the error can be tolerated */
-template<class T> void
-survivable_error (bool keep_going, dcp::DCP::ReadErrors* errors, T const & e)
+
+DCP::DCP(DCP&& other)
+	: _directory(std::move(other._directory))
+	, _cpls(std::move(other._cpls))
+	, _pkls(std::move(other._pkls))
+	, _asset_map(std::move(other._asset_map))
+	, _new_issuer(std::move(other._new_issuer))
+	, _new_creator(std::move(other._new_creator))
+	, _new_issue_date(std::move(other._new_issue_date))
+	, _new_annotation_text(std::move(other._new_annotation_text))
 {
-	if (keep_going) {
-		if (errors) {
-			errors->push_back (shared_ptr<T> (new T (e)));
-		}
-	} else {
-		throw e;
-	}
+
+}
+
+
+DCP&
+DCP::operator=(DCP&& other)
+{
+	_directory = std::move(other._directory);
+	_cpls = std::move(other._cpls);
+	_pkls = std::move(other._pkls);
+	_asset_map = std::move(other._asset_map);
+	_new_issuer = std::move(other._new_issuer);
+	_new_creator = std::move(other._new_creator);
+	_new_issue_date = std::move(other._new_issue_date);
+	_new_annotation_text = std::move(other._new_annotation_text);
+	return *this;
 }
 
+
 void
-DCP::read (bool keep_going, ReadErrors* errors, bool ignore_incorrect_picture_mxf_type)
+DCP::read (vector<dcp::VerificationNote>* notes, bool ignore_incorrect_picture_mxf_type)
 {
-	/* Read the ASSETMAP */
+	/* Read the ASSETMAP and PKL */
 
-	boost::filesystem::path asset_map_file;
-	if (boost::filesystem::exists (_directory / "ASSETMAP")) {
-		asset_map_file = _directory / "ASSETMAP";
-	} else if (boost::filesystem::exists (_directory / "ASSETMAP.xml")) {
-		asset_map_file = _directory / "ASSETMAP.xml";
+	boost::filesystem::path asset_map_path;
+	if (boost::filesystem::exists(_directory / "ASSETMAP")) {
+		asset_map_path = _directory / "ASSETMAP";
+	} else if (boost::filesystem::exists(_directory / "ASSETMAP.xml")) {
+		asset_map_path = _directory / "ASSETMAP.xml";
 	} else {
-		boost::throw_exception (DCPReadError (String::compose ("could not find AssetMap file in `%1'", _directory.string())));
+		boost::throw_exception(MissingAssetmapError(_directory));
 	}
 
-	cxml::Document asset_map ("AssetMap");
+	_asset_map = AssetMap(asset_map_path);
+	auto const pkl_paths = _asset_map->pkl_paths();
+	auto const standard = _asset_map->standard();
 
-	asset_map.read_file (asset_map_file);
-	if (asset_map.namespace_uri() == assetmap_interop_ns) {
-		_standard = INTEROP;
-	} else if (asset_map.namespace_uri() == assetmap_smpte_ns) {
-		_standard = SMPTE;
-	} else {
-		boost::throw_exception (XMLError ("Unrecognised Assetmap namespace " + asset_map.namespace_uri()));
+	if (pkl_paths.empty()) {
+		boost::throw_exception (XMLError ("No packing lists found in asset map"));
 	}
 
-	list<shared_ptr<cxml::Node> > asset_nodes = asset_map.node_child("AssetList")->node_children ("Asset");
-	map<string, boost::filesystem::path> paths;
-	BOOST_FOREACH (shared_ptr<cxml::Node> i, asset_nodes) {
-		if (i->node_child("ChunkList")->node_children("Chunk").size() != 1) {
-			boost::throw_exception (XMLError ("unsupported asset chunk count"));
-		}
-		string p = i->node_child("ChunkList")->node_child("Chunk")->string_child ("Path");
-		if (starts_with (p, "file://")) {
-			p = p.substr (7);
-		}
-		paths.insert (make_pair (remove_urn_uuid (i->string_child ("Id")), p));
+	for (auto i: pkl_paths) {
+		_pkls.push_back(make_shared<PKL>(i));
 	}
 
-	/* Read all the assets from the asset map */
-	/* XXX: I think we should be looking at the PKL here to decide type, not
-	   the extension of the file.
-	*/
+	/* Now we have:
+	     paths - map of files in the DCP that are not PKLs; key is ID, value is path.
+	     _pkls - PKL objects for each PKL.
+
+	   Read all the assets from the asset map.
+	 */
 
-	/* Make a list of non-CPL assets so that we can resolve the references
+	/* Make a list of non-CPL/PKL assets so that we can resolve the references
 	   from the CPLs.
 	*/
-	list<shared_ptr<Asset> > other_assets;
+	vector<shared_ptr<Asset>> other_assets;
 
-	for (map<string, boost::filesystem::path>::const_iterator i = paths.begin(); i != paths.end(); ++i) {
-		boost::filesystem::path path = _directory / i->second;
+	auto ids_and_paths = _asset_map->asset_ids_and_paths();
+	for (auto id_and_path: ids_and_paths) {
+		auto const id = id_and_path.first;
+		auto const path = id_and_path.second;
+
+		if (path == _directory) {
+			/* I can't see how this is valid, but it's
+			   been seen in the wild with a DCP that
+			   claims to come from ClipsterDCI 5.10.0.5.
+			*/
+			if (notes) {
+				notes->push_back ({VerificationNote::Type::WARNING, VerificationNote::Code::EMPTY_ASSET_PATH});
+			}
+			continue;
+		}
+
+		if (!boost::filesystem::exists(path)) {
+			if (notes) {
+				notes->push_back ({VerificationNote::Type::ERROR, VerificationNote::Code::MISSING_ASSET, path});
+			}
+			continue;
+		}
+
+		/* Find the <Type> for this asset from the PKL that contains the asset */
+		optional<string> pkl_type;
+		for (auto j: _pkls) {
+			pkl_type = j->type(id);
+			if (pkl_type) {
+				break;
+			}
+		}
 
-		if (!boost::filesystem::exists (path)) {
-			survivable_error (keep_going, errors, MissingAssetError (path));
+		if (!pkl_type) {
+			/* This asset is in the ASSETMAP but not mentioned in any PKL so we don't
+			 * need to worry about it.
+			 */
 			continue;
 		}
 
-		if (boost::filesystem::extension (path) == ".xml") {
-			xmlpp::DomParser* p = new xmlpp::DomParser;
+		auto remove_parameters = [](string const& n) {
+			return n.substr(0, n.find(";"));
+		};
+
+		/* Remove any optional parameters (after ;) */
+		pkl_type = pkl_type->substr(0, pkl_type->find(";"));
+
+		if (
+			pkl_type == remove_parameters(CPL::static_pkl_type(standard)) ||
+			pkl_type == remove_parameters(InteropSubtitleAsset::static_pkl_type(standard))) {
+			auto p = new xmlpp::DomParser;
 			try {
 				p->parse_file (path.string());
 			} catch (std::exception& e) {
 				delete p;
-				continue;
+				throw ReadError(String::compose("XML error in %1", path.string()), e.what());
 			}
 
-			string const root = p->get_document()->get_root_node()->get_name ();
+			auto const root = p->get_document()->get_root_node()->get_name();
 			delete p;
 
 			if (root == "CompositionPlaylist") {
-				shared_ptr<CPL> cpl (new CPL (path));
-				if (_standard && cpl->standard() && cpl->standard().get() != _standard.get()) {
-					survivable_error (keep_going, errors, MismatchedStandardError ());
+				auto cpl = make_shared<CPL>(path);
+				if (cpl->standard() != standard && notes) {
+					notes->push_back ({VerificationNote::Type::ERROR, VerificationNote::Code::MISMATCHED_STANDARD});
 				}
 				_cpls.push_back (cpl);
 			} else if (root == "DCSubtitle") {
-				if (_standard && _standard.get() == SMPTE) {
-					survivable_error (keep_going, errors, MismatchedStandardError ());
+				if (standard == Standard::SMPTE && notes) {
+					notes->push_back (VerificationNote(VerificationNote::Type::ERROR, VerificationNote::Code::MISMATCHED_STANDARD));
 				}
-				other_assets.push_back (shared_ptr<InteropSubtitleAsset> (new InteropSubtitleAsset (path)));
+				other_assets.push_back (make_shared<InteropSubtitleAsset>(path));
 			}
-		} else if (boost::filesystem::extension (path) == ".mxf") {
-
-			/* XXX: asdcplib does not appear to support discovery of read MXFs standard
-			   (Interop / SMPTE)
-			*/
+		} else if (
+			*pkl_type == remove_parameters(PictureAsset::static_pkl_type(standard)) ||
+			*pkl_type == remove_parameters(SoundAsset::static_pkl_type(standard)) ||
+			*pkl_type == remove_parameters(AtmosAsset::static_pkl_type(standard)) ||
+			*pkl_type == remove_parameters(SMPTESubtitleAsset::static_pkl_type(standard))
+			) {
+
+			bool found_threed_marked_as_twod = false;
+			auto asset = asset_factory(path, ignore_incorrect_picture_mxf_type, &found_threed_marked_as_twod);
+			if (asset->id() != id) {
+				notes->push_back(VerificationNote(VerificationNote::Type::ERROR, VerificationNote::Code::MISMATCHED_ASSET_MAP_ID).set_id(id).set_other_id(asset->id()));
+			}
+			other_assets.push_back(asset);
+			if (found_threed_marked_as_twod && notes) {
+				notes->push_back ({VerificationNote::Type::WARNING, VerificationNote::Code::THREED_ASSET_MARKED_AS_TWOD, path});
+			}
+		} else if (*pkl_type == remove_parameters(FontAsset::static_pkl_type(standard))) {
+			other_assets.push_back(make_shared<FontAsset>(id, path));
+		} else if (*pkl_type == "image/png") {
+			/* It's an Interop PNG subtitle; let it go */
+		} else {
+			throw ReadError (String::compose("Unknown asset type %1 in PKL", *pkl_type));
+		}
+	}
 
-			ASDCP::EssenceType_t type;
-			if (ASDCP::EssenceType (path.string().c_str(), type) != ASDCP::RESULT_OK) {
-				throw DCPReadError ("Could not find essence type");
+	/* Set hashes for assets where we have an idea of what the hash should be in either a CPL or PKL.
+	 * This means that when the hash is later read from these objects the result will be the one that
+	 * it should be, rather the one that it currently is.  This should prevent errors being concealed
+	 * when an asset is corrupted - the hash from the CPL/PKL will disagree with the actual hash of the
+	 * file, revealing the problem.
+	 */
+
+	auto hash_from_pkl = [this](string id) -> optional<string> {
+		for (auto pkl: _pkls) {
+			if (auto pkl_hash = pkl->hash(id)) {
+				return pkl_hash;
 			}
-			switch (type) {
-				case ASDCP::ESS_UNKNOWN:
-				case ASDCP::ESS_MPEG2_VES:
-					throw DCPReadError ("MPEG2 video essences are not supported");
-				case ASDCP::ESS_JPEG_2000:
-					try {
-						other_assets.push_back (shared_ptr<MonoPictureAsset> (new MonoPictureAsset (path)));
-					} catch (dcp::MXFFileError& e) {
-						if (ignore_incorrect_picture_mxf_type && e.number() == ASDCP::RESULT_SFORMAT) {
-							/* Tried to load it as mono but the error says it's stereo; try that instead */
-							other_assets.push_back (shared_ptr<StereoPictureAsset> (new StereoPictureAsset (path)));
-						} else {
-							throw;
-						}
-					}
-					break;
-				case ASDCP::ESS_PCM_24b_48k:
-				case ASDCP::ESS_PCM_24b_96k:
-					other_assets.push_back (shared_ptr<SoundAsset> (new SoundAsset (path)));
-					break;
-				case ASDCP::ESS_JPEG_2000_S:
-					other_assets.push_back (shared_ptr<StereoPictureAsset> (new StereoPictureAsset (path)));
-					break;
-				case ASDCP::ESS_TIMED_TEXT:
-					other_assets.push_back (shared_ptr<SMPTESubtitleAsset> (new SMPTESubtitleAsset (path)));
-					break;
-				default:
-					throw DCPReadError ("Unknown MXF essence type");
+		}
+
+		return {};
+	};
+
+	auto hash_from_cpl_or_pkl = [this, &hash_from_pkl](string id) -> optional<string> {
+		for (auto cpl: cpls()) {
+			for (auto reel_file_asset: cpl->reel_file_assets()) {
+				if (reel_file_asset->asset_ref().id() == id && reel_file_asset->hash()) {
+					return reel_file_asset->hash();
+				}
 			}
-		} else if (boost::filesystem::extension (path) == ".ttf") {
-			other_assets.push_back (shared_ptr<FontAsset> (new FontAsset (i->first, path)));
+		}
+
+		return hash_from_pkl(id);
+	};
+
+	for (auto asset: other_assets) {
+		if (auto hash = hash_from_cpl_or_pkl(asset->id())) {
+			asset->set_hash(*hash);
+		}
+	}
+
+	for (auto cpl: cpls()) {
+		if (auto hash = hash_from_pkl(cpl->id())) {
+			cpl->set_hash(*hash);
 		}
 	}
 
-	BOOST_FOREACH (shared_ptr<CPL> i, cpls ()) {
-		i->resolve_refs (other_assets);
+	/* Resolve references */
+	resolve_refs (other_assets);
+
+	/* While we've got the ASSETMAP lets look and see if this DCP refers to things that are not in its ASSETMAP */
+	if (notes) {
+		for (auto i: cpls()) {
+			for (auto j: i->reel_file_assets()) {
+				if (!j->asset_ref().resolved() && ids_and_paths.find(j->asset_ref().id()) == ids_and_paths.end()) {
+					notes->push_back (VerificationNote(VerificationNote::Type::WARNING, VerificationNote::Code::EXTERNAL_ASSET, j->asset_ref().id()));
+				}
+			}
+		}
 	}
 }
 
+
 void
-DCP::resolve_refs (list<shared_ptr<Asset> > assets)
+DCP::resolve_refs (vector<shared_ptr<Asset>> assets)
 {
-	BOOST_FOREACH (shared_ptr<CPL> i, cpls ()) {
+	for (auto i: cpls()) {
 		i->resolve_refs (assets);
 	}
 }
 
+
 bool
 DCP::equals (DCP const & other, EqualityOptions opt, NoteHandler note) const
 {
-	list<shared_ptr<CPL> > a = cpls ();
-	list<shared_ptr<CPL> > b = other.cpls ();
+	auto a = cpls ();
+	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;
 	}
 
 	bool r = true;
 
-	BOOST_FOREACH (shared_ptr<CPL> i, a) {
-		list<shared_ptr<CPL> >::const_iterator j = b.begin ();
+	for (auto i: a) {
+		auto j = b.begin();
 		while (j != b.end() && !(*j)->equals (i, opt, note)) {
 			++j;
 		}
@@ -271,17 +363,19 @@ DCP::equals (DCP const & other, EqualityOptions opt, NoteHandler note) const
 	return r;
 }
 
+
 void
-DCP::add (boost::shared_ptr<CPL> cpl)
+DCP::add (shared_ptr<CPL> cpl)
 {
 	_cpls.push_back (cpl);
 }
 
+
 bool
-DCP::encrypted () const
+DCP::any_encrypted () const
 {
-	BOOST_FOREACH (shared_ptr<CPL> i, cpls ()) {
-		if (i->encrypted ()) {
+	for (auto i: cpls()) {
+		if (i->any_encrypted()) {
 			return true;
 		}
 	}
@@ -289,74 +383,44 @@ DCP::encrypted () const
 	return false;
 }
 
-void
-DCP::add (DecryptedKDM const & kdm)
-{
-	list<DecryptedKDMKey> keys = kdm.keys ();
 
-	BOOST_FOREACH (shared_ptr<CPL> i, cpls ()) {
-		BOOST_FOREACH (DecryptedKDMKey const & j, kdm.keys ()) {
-			if (j.cpl_id() == i->id()) {
-				i->add (kdm);
-			}
-		}
-	}
-}
-
-/** @return full pathname of PKL file that was written */
-boost::filesystem::path
-DCP::write_pkl (string file, Standard standard, string pkl_uuid, XMLMetadata metadata, shared_ptr<const CertificateChain> signer) const
+bool
+DCP::all_encrypted () const
 {
-	boost::filesystem::path p = _directory;
-	p /= file;
-
-	xmlpp::Document doc;
-	xmlpp::Element* pkl;
-	if (standard == INTEROP) {
-		pkl = doc.create_root_node("PackingList", pkl_interop_ns);
-	} else {
-		pkl = doc.create_root_node("PackingList", pkl_smpte_ns);
-	}
-
-	if (signer) {
-		pkl->set_namespace_declaration ("http://www.w3.org/2000/09/xmldsig#", "dsig");
+	for (auto i: cpls()) {
+		if (!i->all_encrypted()) {
+			return false;
+		}
 	}
 
-	pkl->add_child("Id")->add_child_text ("urn:uuid:" + pkl_uuid);
-
-	/* XXX: this is a bit of a hack */
-	DCP_ASSERT (cpls().size() > 0);
-	pkl->add_child("AnnotationText")->add_child_text (cpls().front()->annotation_text ());
-
-	pkl->add_child("IssueDate")->add_child_text (metadata.issue_date);
-	pkl->add_child("Issuer")->add_child_text (metadata.issuer);
-	pkl->add_child("Creator")->add_child_text (metadata.creator);
+	return true;
+}
 
-	xmlpp::Element* asset_list = pkl->add_child("AssetList");
-	BOOST_FOREACH (shared_ptr<Asset> i, assets ()) {
-		i->write_to_pkl (asset_list, _directory, standard);
-	}
 
-	if (signer) {
-		signer->sign (pkl, standard);
+void
+DCP::add (DecryptedKDM const & kdm)
+{
+	auto keys = kdm.keys();
+	for (auto cpl: cpls()) {
+		if (std::any_of(keys.begin(), keys.end(), [cpl](DecryptedKDMKey const& key) { return key.cpl_id() == cpl->id(); })) {
+			cpl->add (kdm);
+		}
 	}
-
-	doc.write_to_file (p.string (), "UTF-8");
-	return p.string ();
 }
 
+
 /** Write the VOLINDEX file.
  *  @param standard DCP standard to use (INTEROP or SMPTE)
  */
 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:
@@ -367,10 +431,10 @@ DCP::write_volindex (Standard standard) const
 	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:
@@ -378,127 +442,110 @@ DCP::write_volindex (Standard standard) const
 	}
 
 	root->add_child("Index")->add_child_text ("1");
-	doc.write_to_file (p.string (), "UTF-8");
+	doc.write_to_file_formatted (p.string (), "UTF-8");
 }
 
+
 void
-DCP::write_assetmap (Standard standard, string pkl_uuid, boost::filesystem::path pkl_path, XMLMetadata metadata) const
+DCP::write_xml(shared_ptr<const CertificateChain> signer, bool include_mca_subdescriptors, NameFormat name_format)
 {
-	boost::filesystem::path p = _directory;
-
-	switch (standard) {
-	case INTEROP:
-		p /= "ASSETMAP";
-		break;
-	case SMPTE:
-		p /= "ASSETMAP.xml";
-		break;
-	default:
-		DCP_ASSERT (false);
+	if (_cpls.empty()) {
+		throw MiscError ("Cannot write DCP with no CPLs.");
 	}
 
-	xmlpp::Document doc;
-	xmlpp::Element* root;
+	auto standard = std::accumulate (
+		std::next(_cpls.begin()), _cpls.end(), _cpls[0]->standard(),
+		[](Standard s, shared_ptr<CPL> c) {
+			if (s != c->standard()) {
+				throw MiscError ("Cannot make DCP with mixed Interop and SMPTE CPLs.");
+			}
+			return s;
+		}
+		);
 
-	switch (standard) {
-	case INTEROP:
-		root = doc.create_root_node ("AssetMap", assetmap_interop_ns);
-		break;
-	case SMPTE:
-		root = doc.create_root_node ("AssetMap", assetmap_smpte_ns);
-		break;
-	default:
-		DCP_ASSERT (false);
+	for (auto i: cpls()) {
+		NameFormat::Map values;
+		values['t'] = "cpl";
+		i->write_xml(_directory / (name_format.get(values, "_" + i->id() + ".xml")), signer, include_mca_subdescriptors);
 	}
 
-	root->add_child("Id")->add_child_text ("urn:uuid:" + make_uuid());
-	root->add_child("AnnotationText")->add_child_text ("Created by " + metadata.creator);
-
-	switch (standard) {
-	case INTEROP:
-		root->add_child("VolumeCount")->add_child_text ("1");
-		root->add_child("IssueDate")->add_child_text (metadata.issue_date);
-		root->add_child("Issuer")->add_child_text (metadata.issuer);
-		root->add_child("Creator")->add_child_text (metadata.creator);
-		break;
-	case SMPTE:
-		root->add_child("Creator")->add_child_text (metadata.creator);
-		root->add_child("VolumeCount")->add_child_text ("1");
-		root->add_child("IssueDate")->add_child_text (metadata.issue_date);
-		root->add_child("Issuer")->add_child_text (metadata.issuer);
-		break;
-	default:
-		DCP_ASSERT (false);
+	if (_pkls.empty()) {
+		_pkls.push_back(
+			make_shared<PKL>(
+				standard,
+				_new_annotation_text.get_value_or(String::compose("Created by libdcp %1", dcp::version)),
+				_new_issue_date.get_value_or(LocalTime().as_string()),
+				_new_issuer.get_value_or(String::compose("libdcp %1", dcp::version)),
+				_new_creator.get_value_or(String::compose("libdcp %1", dcp::version))
+				)
+			);
 	}
 
-	xmlpp::Node* asset_list = root->add_child ("AssetList");
-
-	xmlpp::Node* asset = asset_list->add_child ("Asset");
-	asset->add_child("Id")->add_child_text ("urn:uuid:" + pkl_uuid);
-	asset->add_child("PackingList")->add_child_text ("true");
-	xmlpp::Node* chunk_list = asset->add_child ("ChunkList");
-	xmlpp::Node* chunk = chunk_list->add_child ("Chunk");
-	chunk->add_child("Path")->add_child_text (pkl_path.filename().string());
-	chunk->add_child("VolumeIndex")->add_child_text ("1");
-	chunk->add_child("Offset")->add_child_text ("0");
-	chunk->add_child("Length")->add_child_text (raw_convert<string> (boost::filesystem::file_size (pkl_path)));
+	auto pkl = _pkls.front();
 
-	BOOST_FOREACH (shared_ptr<Asset> i, assets ()) {
-		i->write_to_assetmap (asset_list, _directory);
+	/* The assets may have changed since we read the PKL, so re-add them */
+	pkl->clear_assets();
+	for (auto asset: assets()) {
+		asset->add_to_pkl(pkl, _directory);
 	}
 
-	/* This must not be the _formatted version otherwise signature digests will be wrong */
-	doc.write_to_file (p.string (), "UTF-8");
-}
+	NameFormat::Map values;
+	values['t'] = "pkl";
+	auto pkl_path = _directory / name_format.get(values, "_" + pkl->id() + ".xml");
+	pkl->write_xml (pkl_path, signer);
+
+	if (!_asset_map) {
+		_asset_map = AssetMap(
+			standard,
+			_new_annotation_text.get_value_or(String::compose("Created by libdcp %1", dcp::version)),
+			_new_issue_date.get_value_or(LocalTime().as_string()),
+			_new_issuer.get_value_or(String::compose("libdcp %1", dcp::version)),
+			_new_creator.get_value_or(String::compose("libdcp %1", dcp::version))
+			);
+	}
 
-/** Write all the XML files for this DCP.
- *  @param standand INTEROP or SMPTE.
- *  @param metadata Metadata to use for PKL and asset map files.
- *  @param signer Signer to use, or 0.
- */
-void
-DCP::write_xml (
-	Standard standard,
-	XMLMetadata metadata,
-	shared_ptr<const CertificateChain> signer,
-	NameFormat name_format
-	)
-{
-	BOOST_FOREACH (shared_ptr<CPL> i, cpls ()) {
-		NameFormat::Map values;
-		values['t'] = "cpl";
-		i->write_xml (_directory / (name_format.get(values, "_" + i->id() + ".xml")), standard, signer);
+	/* The assets may have changed since we read the asset map, so re-add them */
+	_asset_map->clear_assets();
+	_asset_map->add_asset(pkl->id(), pkl_path, true);
+	for (auto asset: assets()) {
+		asset->add_to_assetmap(*_asset_map, _directory);
 	}
 
-	string const pkl_uuid = make_uuid ();
-	NameFormat::Map values;
-	values['t'] = "pkl";
-	boost::filesystem::path const pkl_path = write_pkl (name_format.get(values, "_" + pkl_uuid + ".xml"), standard, pkl_uuid, metadata, signer);
+	_asset_map->write_xml(
+		_directory / (standard == Standard::INTEROP ? "ASSETMAP" : "ASSETMAP.xml")
+		);
 
 	write_volindex (standard);
-	write_assetmap (standard, pkl_uuid, pkl_path, metadata);
 }
 
-list<shared_ptr<CPL> >
+
+vector<shared_ptr<CPL>>
 DCP::cpls () const
 {
 	return _cpls;
 }
 
-/** @return All assets (including CPLs) */
-list<shared_ptr<Asset> >
-DCP::assets () const
+
+vector<shared_ptr<Asset>>
+DCP::assets (bool ignore_unresolved) const
 {
-	list<shared_ptr<Asset> > assets;
-	BOOST_FOREACH (shared_ptr<CPL> i, cpls ()) {
+	vector<shared_ptr<Asset>> assets;
+	for (auto i: cpls()) {
 		assets.push_back (i);
-		BOOST_FOREACH (shared_ptr<const ReelAsset> j, i->reel_assets ()) {
-			shared_ptr<Asset> o = j->asset_ref().asset ();
-			assets.push_back (o);
-			/* More Interop special-casing */
-			shared_ptr<InteropSubtitleAsset> sub = dynamic_pointer_cast<InteropSubtitleAsset> (o);
-			if (sub) {
-				sub->add_font_assets (assets);
+		for (auto j: i->reel_file_assets()) {
+			if (ignore_unresolved && !j->asset_ref().resolved()) {
+				continue;
+			}
+
+			auto const id = j->asset_ref().id();
+			if (std::find_if(assets.begin(), assets.end(), [id](shared_ptr<Asset> asset) { return asset->id() == id; }) == assets.end()) {
+				auto o = j->asset_ref().asset();
+				assets.push_back (o);
+				/* More Interop special-casing */
+				auto sub = dynamic_pointer_cast<InteropSubtitleAsset>(o);
+				if (sub) {
+					add_to_container(assets, sub->font_assets());
+				}
 			}
 		}
 	}
@@ -506,15 +553,69 @@ DCP::assets () const
 	return assets;
 }
 
+
 /** Given a list of files that make up 1 or more DCPs, return the DCP directories */
 vector<boost::filesystem::path>
 DCP::directories_from_files (vector<boost::filesystem::path> files)
 {
 	vector<boost::filesystem::path> d;
-	BOOST_FOREACH (boost::filesystem::path i, files) {
+	for (auto i: files) {
 		if (i.filename() == "ASSETMAP" || i.filename() == "ASSETMAP.xml") {
 			d.push_back (i.parent_path ());
 		}
 	}
 	return d;
 }
+
+
+void
+DCP::set_issuer(string issuer)
+{
+	for (auto pkl: _pkls) {
+		pkl->set_issuer(issuer);
+	}
+	if (_asset_map) {
+		_asset_map->set_issuer(issuer);
+	}
+	_new_issuer = issuer;
+}
+
+
+void
+DCP::set_creator(string creator)
+{
+	for (auto pkl: _pkls) {
+		pkl->set_creator(creator);
+	}
+	if (_asset_map) {
+		_asset_map->set_creator(creator);
+	}
+	_new_creator = creator;
+}
+
+
+void
+DCP::set_issue_date(string issue_date)
+{
+	for (auto pkl: _pkls) {
+		pkl->set_issue_date(issue_date);
+	}
+	if (_asset_map) {
+		_asset_map->set_issue_date(issue_date);
+	}
+	_new_issue_date = issue_date;
+}
+
+
+void
+DCP::set_annotation_text(string annotation_text)
+{
+	for (auto pkl: _pkls) {
+		pkl->set_annotation_text(annotation_text);
+	}
+	if (_asset_map) {
+		_asset_map->set_annotation_text(annotation_text);
+	}
+	_new_annotation_text = annotation_text;
+}
+