Put xmlns:dsig on Signer and Signature rather than on the whole
[libdcp.git] / src / dcp.cc
index c92a14b883b1e2e6e36a37029cc75346d583b878..e56547e3dc2e7d265161bbf03abb2fbe1883acce 100644 (file)
@@ -1,20 +1,34 @@
 /*
-    Copyright (C) 2012-2014 Carl Hetherington <cth@carlh.net>
+    Copyright (C) 2012-2015 Carl Hetherington <cth@carlh.net>
 
-    This program is free software; you can redistribute it and/or modify
+    This file is part of libdcp.
+
+    libdcp is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
-    This program is distributed in the hope that it will be useful,
+    libdcp is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
+    along with libdcp.  If not, see <http://www.gnu.org/licenses/>.
+
+    In addition, as a special exception, the copyright holders give
+    permission to link the code of portions of this program with the
+    OpenSSL library under certain conditions as described in each
+    individual source file, and distribute linked combinations
+    including the two.
+
+    You must obey the GNU General Public License in all respects
+    for all of the code used other than OpenSSL.  If you modify
+    file(s) with this exception, you may extend this exception to your
+    version of the file(s), but you are not obligated to do so.  If you
+    do not wish to do so, delete this exception statement from your
+    version.  If you delete this exception statement from all source
+    files in the program, then also delete it here.
 */
 
 /** @file  src/dcp.cc
 
 #include "raw_convert.h"
 #include "dcp.h"
-#include "sound_mxf.h"
-#include "picture_mxf.h"
-#include "subtitle_content.h"
-#include "mono_picture_mxf.h"
-#include "stereo_picture_mxf.h"
+#include "sound_asset.h"
+#include "atmos_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 "reel.h"
 #include "cpl.h"
-#include "signer.h"
+#include "certificate_chain.h"
 #include "compose.hpp"
-#include "AS_DCP.h"
 #include "decrypted_kdm.h"
 #include "decrypted_kdm_key.h"
+#include "dcp_assert.h"
+#include "reel_asset.h"
+#include "font_asset.h"
+#include <asdcp/AS_DCP.h>
 #include <xmlsec/xmldsig.h>
 #include <xmlsec/app.h>
 #include <libxml++/libxml++.h>
 #include <boost/filesystem.hpp>
 #include <boost/algorithm/string.hpp>
-#include <sstream>
-#include <iomanip>
-#include <cassert>
-#include <iostream>
+#include <boost/foreach.hpp>
 
 using std::string;
 using std::list;
-using std::stringstream;
-using std::ostream;
+using std::vector;
+using std::cout;
 using std::make_pair;
 using std::map;
-using std::cout;
+using std::cerr;
 using std::exception;
 using boost::shared_ptr;
+using boost::dynamic_pointer_cast;
 using boost::algorithm::starts_with;
 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-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)
 {
        if (!boost::filesystem::exists (directory)) {
                boost::filesystem::create_directories (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)
 {
@@ -83,35 +108,53 @@ survivable_error (bool keep_going, dcp::DCP::ReadErrors* errors, T const & e)
 }
 
 void
-DCP::read (bool keep_going, ReadErrors* errors)
+DCP::read (bool keep_going, ReadErrors* errors, bool ignore_incorrect_picture_mxf_type)
 {
        /* Read the ASSETMAP */
-       
+
        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";
        } else {
-               boost::throw_exception (DCPReadError (String::compose ("could not find AssetMap file `%1'", asset_map_file.string())));
+               boost::throw_exception (DCPReadError (String::compose ("could not find AssetMap file in `%1'", _directory.string())));
        }
 
        cxml::Document asset_map ("AssetMap");
+
        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()));
+       }
+
        list<shared_ptr<cxml::Node> > asset_nodes = asset_map.node_child("AssetList")->node_children ("Asset");
        map<string, boost::filesystem::path> paths;
-       for (list<shared_ptr<cxml::Node> >::const_iterator i = asset_nodes.begin(); i != asset_nodes.end(); ++i) {
-               if ((*i)->node_child("ChunkList")->node_children("Chunk").size() != 1) {
+       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");
+               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 ((*i)->string_child ("Id"), p));
+               paths.insert (make_pair (remove_urn_uuid (i->string_child ("Id")), p));
        }
 
        /* 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.
+       */
+
+       /* Make a list of non-CPL assets so that we can resolve the references
+          from the CPLs.
+       */
+       list<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;
 
@@ -119,25 +162,37 @@ DCP::read (bool keep_going, ReadErrors* errors)
                        survivable_error (keep_going, errors, MissingAssetError (path));
                        continue;
                }
-               
-               if (boost::algorithm::ends_with (path.string(), ".xml")) {
+
+               if (boost::filesystem::extension (path) == ".xml") {
                        xmlpp::DomParser* p = new xmlpp::DomParser;
                        try {
                                p->parse_file (path.string());
                        } catch (std::exception& e) {
                                delete p;
-                               continue;
+                               throw DCPReadError(String::compose("XML error in %1", path.string()), e.what());
                        }
-                       
+
                        string const root = p->get_document()->get_root_node()->get_name ();
                        delete p;
-                       
+
                        if (root == "CompositionPlaylist") {
-                               _assets.push_back (shared_ptr<CPL> (new CPL (path)));
+                               shared_ptr<CPL> cpl (new CPL (path));
+                               if (_standard && cpl->standard() && cpl->standard().get() != _standard.get()) {
+                                       survivable_error (keep_going, errors, MismatchedStandardError ());
+                               }
+                               _cpls.push_back (cpl);
                        } else if (root == "DCSubtitle") {
-                               _assets.push_back (shared_ptr<SubtitleContent> (new SubtitleContent (path, false)));
+                               if (_standard && _standard.get() == SMPTE) {
+                                       survivable_error (keep_going, errors, MismatchedStandardError ());
+                               }
+                               other_assets.push_back (shared_ptr<InteropSubtitleAsset> (new InteropSubtitleAsset (path)));
                        }
-               } else if (boost::algorithm::ends_with (path.string(), ".mxf")) {
+               } else if (boost::filesystem::extension (path) == ".mxf") {
+
+                       /* XXX: asdcplib does not appear to support discovery of read MXFs standard
+                          (Interop / SMPTE)
+                       */
+
                        ASDCP::EssenceType_t type;
                        if (ASDCP::EssenceType (path.string().c_str(), type) != ASDCP::RESULT_OK) {
                                throw DCPReadError ("Could not find essence type");
@@ -147,64 +202,89 @@ DCP::read (bool keep_going, ReadErrors* errors)
                                case ASDCP::ESS_MPEG2_VES:
                                        throw DCPReadError ("MPEG2 video essences are not supported");
                                case ASDCP::ESS_JPEG_2000:
-                                       _assets.push_back (shared_ptr<MonoPictureMXF> (new MonoPictureMXF (path)));
+                                       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:
-                                       _assets.push_back (shared_ptr<SoundMXF> (new SoundMXF (path)));
+                                       other_assets.push_back (shared_ptr<SoundAsset> (new SoundAsset (path)));
                                        break;
                                case ASDCP::ESS_JPEG_2000_S:
-                                       _assets.push_back (shared_ptr<StereoPictureMXF> (new StereoPictureMXF (path)));
+                                       other_assets.push_back (shared_ptr<StereoPictureAsset> (new StereoPictureAsset (path)));
                                        break;
                                case ASDCP::ESS_TIMED_TEXT:
-                                       _assets.push_back (shared_ptr<SubtitleContent> (new SubtitleContent (path, true)));
+                                       other_assets.push_back (shared_ptr<SMPTESubtitleAsset> (new SMPTESubtitleAsset (path)));
+                                       break;
+                               case ASDCP::ESS_DCDATA_DOLBY_ATMOS:
+                                       other_assets.push_back (shared_ptr<AtmosAsset> (new AtmosAsset (path)));
                                        break;
                                default:
-                                       throw DCPReadError ("Unknown MXF essence type");
-                               }
+                                       throw DCPReadError (String::compose ("Unknown MXF essence type %1 in %2", int(type), path.string()));
+                       }
+               } else if (boost::filesystem::extension (path) == ".ttf") {
+                       other_assets.push_back (shared_ptr<FontAsset> (new FontAsset (i->first, path)));
                }
        }
 
-       list<shared_ptr<CPL> > cpl = cpls ();
-       for (list<shared_ptr<CPL> >::const_iterator i = cpl.begin(); i != cpl.end(); ++i) {
-               (*i)->resolve_refs (list_of_type<Asset, Object> (assets ()));
+       BOOST_FOREACH (shared_ptr<CPL> i, cpls ()) {
+               i->resolve_refs (other_assets);
+       }
+}
+
+void
+DCP::resolve_refs (list<shared_ptr<Asset> > assets)
+{
+       BOOST_FOREACH (shared_ptr<CPL> i, cpls ()) {
+               i->resolve_refs (assets);
        }
 }
 
 bool
-DCP::equals (DCP const & other, EqualityOptions opt, boost::function<void (NoteType, string)> note) const
+DCP::equals (DCP const & other, EqualityOptions opt, NoteHandler note) const
 {
-       if (_assets.size() != other._assets.size()) {
-               note (DCP_ERROR, String::compose ("Asset counts differ: %1 vs %2", _assets.size(), other._assets.size()));
+       list<shared_ptr<CPL> > a = cpls ();
+       list<shared_ptr<CPL> > b = other.cpls ();
+
+       if (a.size() != b.size()) {
+               note (DCP_ERROR, String::compose ("CPL counts differ: %1 vs %2", a.size(), b.size()));
                return false;
        }
 
-       list<shared_ptr<Asset> >::const_iterator a = _assets.begin ();
-       list<shared_ptr<Asset> >::const_iterator b = other._assets.begin ();
+       bool r = true;
+
+       BOOST_FOREACH (shared_ptr<CPL> i, a) {
+               list<shared_ptr<CPL> >::const_iterator j = b.begin ();
+               while (j != b.end() && !(*j)->equals (i, opt, note)) {
+                       ++j;
+               }
 
-       while (a != _assets.end ()) {
-               if (!(*a)->equals (*b, opt, note)) {
-                       return false;
+               if (j == b.end ()) {
+                       r = false;
                }
-               ++a;
-               ++b;
        }
 
-       return true;
+       return r;
 }
 
 void
-DCP::add (boost::shared_ptr<Asset> asset)
+DCP::add (boost::shared_ptr<CPL> cpl)
 {
-       _assets.push_back (asset);
+       _cpls.push_back (cpl);
 }
 
 bool
 DCP::encrypted () const
 {
-       list<shared_ptr<CPL> > cpl = cpls ();
-       for (list<shared_ptr<CPL> >::const_iterator i = cpl.begin(); i != cpl.end(); ++i) {
-               if ((*i)->encrypted ()) {
+       BOOST_FOREACH (shared_ptr<CPL> i, cpls ()) {
+               if (i->encrypted ()) {
                        return true;
                }
        }
@@ -216,56 +296,46 @@ void
 DCP::add (DecryptedKDM const & kdm)
 {
        list<DecryptedKDMKey> keys = kdm.keys ();
-       list<shared_ptr<CPL> > cpl = cpls ();
-       
-       for (list<shared_ptr<CPL> >::iterator i = cpl.begin(); i != cpl.end(); ++i) {
-               for (list<DecryptedKDMKey>::iterator j = keys.begin(); j != keys.end(); ++j) {
-                       if (j->cpl_id() == (*i)->id()) {
-                               (*i)->add (kdm);
-                       }                               
+
+       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 (Standard standard, string pkl_uuid, XMLMetadata metadata, shared_ptr<const Signer> signer) const
+DCP::write_pkl (string file, Standard standard, string pkl_uuid, XMLMetadata metadata, shared_ptr<const CertificateChain> signer) const
 {
        boost::filesystem::path p = _directory;
-       stringstream s;
-       s << pkl_uuid << "_pkl.xml";
-       p /= s.str();
+       p /= file;
 
        xmlpp::Document doc;
        xmlpp::Element* pkl;
        if (standard == INTEROP) {
-               pkl = doc.create_root_node("PackingList", "http://www.digicine.com/PROTO-ASDCP-PKL-20040311#");
+               pkl = doc.create_root_node("PackingList", pkl_interop_ns);
        } else {
-               pkl = doc.create_root_node("PackingList", "http://www.smpte-ra.org/schemas/429-8/2007/PKL");
-       }
-       
-       if (signer) {
-               pkl->set_namespace_declaration ("http://www.w3.org/2000/09/xmldsig#", "dsig");
+               pkl = doc.create_root_node("PackingList", pkl_smpte_ns);
        }
 
        pkl->add_child("Id")->add_child_text ("urn:uuid:" + pkl_uuid);
-
-       /* XXX: this is a bit of a hack */
-       assert (cpls().size() > 0);
-       pkl->add_child("AnnotationText")->add_child_text (cpls().front()->annotation_text ());
-       
+       pkl->add_child("AnnotationText")->add_child_text (metadata.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);
 
        xmlpp::Element* asset_list = pkl->add_child("AssetList");
-       for (list<shared_ptr<Asset> >::const_iterator i = _assets.begin(); i != _assets.end(); ++i) {
-               (*i)->write_to_pkl (asset_list, standard);
+       BOOST_FOREACH (shared_ptr<Asset> i, assets ()) {
+               i->write_to_pkl (asset_list, _directory, standard);
        }
 
        if (signer) {
                signer->sign (pkl, standard);
        }
-               
+
        doc.write_to_file (p.string (), "UTF-8");
        return p.string ();
 }
@@ -285,7 +355,7 @@ DCP::write_volindex (Standard standard) const
                p /= "VOLINDEX.xml";
                break;
        default:
-               assert (false);
+               DCP_ASSERT (false);
        }
 
        xmlpp::Document doc;
@@ -293,24 +363,24 @@ DCP::write_volindex (Standard standard) const
 
        switch (standard) {
        case INTEROP:
-               root = doc.create_root_node ("VolumeIndex", "http://www.digicine.com/PROTO-ASDCP-AM-20040311#");
+               root = doc.create_root_node ("VolumeIndex", volindex_interop_ns);
                break;
        case SMPTE:
-               root = doc.create_root_node ("VolumeIndex", "http://www.smpte-ra.org/schemas/429-9/2007/AM");
+               root = doc.create_root_node ("VolumeIndex", volindex_smpte_ns);
                break;
        default:
-               assert (false);
+               DCP_ASSERT (false);
        }
-       
+
        root->add_child("Index")->add_child_text ("1");
        doc.write_to_file (p.string (), "UTF-8");
 }
 
 void
-DCP::write_assetmap (Standard standard, string pkl_uuid, int pkl_length, XMLMetadata metadata) const
+DCP::write_assetmap (Standard standard, string pkl_uuid, boost::filesystem::path pkl_path, XMLMetadata metadata) const
 {
        boost::filesystem::path p = _directory;
-       
+
        switch (standard) {
        case INTEROP:
                p /= "ASSETMAP";
@@ -319,7 +389,7 @@ DCP::write_assetmap (Standard standard, string pkl_uuid, int pkl_length, XMLMeta
                p /= "ASSETMAP.xml";
                break;
        default:
-               assert (false);
+               DCP_ASSERT (false);
        }
 
        xmlpp::Document doc;
@@ -327,17 +397,17 @@ DCP::write_assetmap (Standard standard, string pkl_uuid, int pkl_length, XMLMeta
 
        switch (standard) {
        case INTEROP:
-               root = doc.create_root_node ("AssetMap", "http://www.digicine.com/PROTO-ASDCP-AM-20040311#");
+               root = doc.create_root_node ("AssetMap", assetmap_interop_ns);
                break;
        case SMPTE:
-               root = doc.create_root_node ("AssetMap", "http://www.smpte-ra.org/schemas/429-9/2007/AM");
+               root = doc.create_root_node ("AssetMap", assetmap_smpte_ns);
                break;
        default:
-               assert (false);
+               DCP_ASSERT (false);
        }
 
        root->add_child("Id")->add_child_text ("urn:uuid:" + make_uuid());
-       root->add_child("AnnotationText")->add_child_text ("Created by " + metadata.creator);
+       root->add_child("AnnotationText")->add_child_text (metadata.annotation_text);
 
        switch (standard) {
        case INTEROP:
@@ -353,9 +423,9 @@ DCP::write_assetmap (Standard standard, string pkl_uuid, int pkl_length, XMLMeta
                root->add_child("Issuer")->add_child_text (metadata.issuer);
                break;
        default:
-               assert (false);
+               DCP_ASSERT (false);
        }
-               
+
        xmlpp::Node* asset_list = root->add_child ("AssetList");
 
        xmlpp::Node* asset = asset_list->add_child ("Asset");
@@ -363,13 +433,13 @@ DCP::write_assetmap (Standard standard, string pkl_uuid, int pkl_length, XMLMeta
        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_uuid + "_pkl.xml");
+       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> (pkl_length));
-       
-       for (list<shared_ptr<Asset> >::const_iterator i = _assets.begin(); i != _assets.end(); ++i) {
-               (*i)->write_to_assetmap (asset_list, _directory);
+       chunk->add_child("Length")->add_child_text (raw_convert<string> (boost::filesystem::file_size (pkl_path)));
+
+       BOOST_FOREACH (shared_ptr<Asset> i, assets ()) {
+               i->write_to_assetmap (asset_list, _directory);
        }
 
        /* This must not be the _formatted version otherwise signature digests will be wrong */
@@ -385,24 +455,67 @@ void
 DCP::write_xml (
        Standard standard,
        XMLMetadata metadata,
-       shared_ptr<const Signer> signer
+       shared_ptr<const CertificateChain> signer,
+       NameFormat name_format
        )
 {
-       list<shared_ptr<CPL> > cpl = cpls ();
-       for (list<shared_ptr<CPL> >::const_iterator i = cpl.begin(); i != cpl.end(); ++i) {
-               string const filename = (*i)->id() + "_cpl.xml";
-               (*i)->write_xml (_directory / filename, standard, signer);
+       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);
        }
 
        string const pkl_uuid = make_uuid ();
-       boost::filesystem::path const pkl_path = write_pkl (standard, pkl_uuid, metadata, signer);
-       
+       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);
+
        write_volindex (standard);
-       write_assetmap (standard, pkl_uuid, boost::filesystem::file_size (pkl_path), metadata);
+       write_assetmap (standard, pkl_uuid, pkl_path, metadata);
 }
 
 list<shared_ptr<CPL> >
 DCP::cpls () const
 {
-       return list_of_type<Asset, CPL> (_assets);
+       return _cpls;
+}
+
+/** @param ignore_unresolved true to silently ignore unresolved assets, otherwise
+ *  an exception is thrown if they are found.
+ *  @return All assets (including CPLs).
+ */
+list<shared_ptr<Asset> >
+DCP::assets (bool ignore_unresolved) const
+{
+       list<shared_ptr<Asset> > assets;
+       BOOST_FOREACH (shared_ptr<CPL> i, cpls ()) {
+               assets.push_back (i);
+               BOOST_FOREACH (shared_ptr<const ReelAsset> j, i->reel_assets ()) {
+                       if (ignore_unresolved && !j->asset_ref().resolved()) {
+                               continue;
+                       }
+                       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);
+                       }
+               }
+       }
+
+       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) {
+               if (i.filename() == "ASSETMAP" || i.filename() == "ASSETMAP.xml") {
+                       d.push_back (i.parent_path ());
+               }
+       }
+       return d;
 }