src/cpl.cc

   1 /*
   2     Copyright (C) 2012-2016 Carl Hetherington <cth@carlh.net>
   3
   4     This file is part of libdcp.
   5
   6     libdcp is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     libdcp is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with libdcp.  If not, see <http://www.gnu.org/licenses/>.
  18
  19     In addition, as a special exception, the copyright holders give
  20     permission to link the code of portions of this program with the
  21     OpenSSL library under certain conditions as described in each
  22     individual source file, and distribute linked combinations
  23     including the two.
  24
  25     You must obey the GNU General Public License in all respects
  26     for all of the code used other than OpenSSL.  If you modify
  27     file(s) with this exception, you may extend this exception to your
  28     version of the file(s), but you are not obligated to do so.  If you
  29     do not wish to do so, delete this exception statement from your
  30     version.  If you delete this exception statement from all source
  31     files in the program, then also delete it here.
  32 */
  33
  34 #include "cpl.h"
  35 #include "util.h"
  36 #include "reel.h"
  37 #include "metadata.h"
  38 #include "certificate_chain.h"
  39 #include "xml.h"
  40 #include "reel_picture_asset.h"
  41 #include "reel_sound_asset.h"
  42 #include "reel_subtitle_asset.h"
  43 #include "reel_atmos_asset.h"
  44 #include "local_time.h"
  45 #include "dcp_assert.h"
  46 #include "compose.hpp"
  47 #include <libxml/parser.h>
  48 #include <libxml++/libxml++.h>
  49 #include <boost/foreach.hpp>
  50
  51 using std::string;
  52 using std::list;
  53 using std::pair;
  54 using std::make_pair;
  55 using std::cout;
  56 using boost::shared_ptr;
  57 using boost::optional;
  58 using boost::dynamic_pointer_cast;
  59 using namespace dcp;
  60
  61 static string const cpl_interop_ns = "http://www.digicine.com/PROTO-ASDCP-CPL-20040511#";
  62 static string const cpl_smpte_ns   = "http://www.smpte-ra.org/schemas/429-7/2006/CPL";
  63
  64 CPL::CPL (string annotation_text, ContentKind content_kind)
  65         /* default _content_title_text to annotation_text */
  66         : _content_title_text (annotation_text)
  67         , _content_kind (content_kind)
  68         , _content_version_id ("urn:uuid:" + make_uuid ())
  69 {
  70         _metadata.annotation_text = annotation_text;
  71         /* default _content_version_id to a random ID and _content_version_label to
  72            a random ID and the current time.
  73         */
  74         _content_version_id = "urn:uuid:" + make_uuid();
  75         _content_version_label_text = _content_version_id + LocalTime().as_string ();
  76 }
  77
  78 /** Construct a CPL object from a XML file */
  79 CPL::CPL (boost::filesystem::path file)
  80         : Asset (file)
  81         , _content_kind (FEATURE)
  82 {
  83         cxml::Document f ("CompositionPlaylist");
  84         f.read_file (file);
  85
  86         if (f.namespace_uri() == cpl_interop_ns) {
  87                 _standard = INTEROP;
  88         } else if (f.namespace_uri() == cpl_smpte_ns) {
  89                 _standard = SMPTE;
  90         } else {
  91                 boost::throw_exception (XMLError ("Unrecognised CPL namespace " + f.namespace_uri()));
  92         }
  93
  94         _id = remove_urn_uuid (f.string_child ("Id"));
  95         _metadata.annotation_text = f.optional_string_child ("AnnotationText").get_value_or ("");
  96         _metadata.issuer = f.optional_string_child ("Issuer").get_value_or ("");
  97         _metadata.creator = f.optional_string_child ("Creator").get_value_or ("");
  98         _metadata.issue_date = f.string_child ("IssueDate");
  99         _content_title_text = f.string_child ("ContentTitleText");
 100         _content_kind = content_kind_from_string (f.string_child ("ContentKind"));
 101         shared_ptr<cxml::Node> content_version = f.optional_node_child ("ContentVersion");
 102         if (content_version) {
 103                 _content_version_id = content_version->optional_string_child ("Id").get_value_or ("");
 104                 _content_version_label_text = content_version->string_child ("LabelText");
 105                 content_version->done ();
 106         }
 107         f.ignore_child ("RatingList");
 108         _reels = type_grand_children<Reel> (f, "ReelList", "Reel");
 109
 110         f.ignore_child ("Issuer");
 111         f.ignore_child ("Signer");
 112         f.ignore_child ("Signature");
 113
 114         f.done ();
 115 }
 116
 117 /** Add a reel to this CPL.
 118  *  @param reel Reel to add.
 119  */
 120 void
 121 CPL::add (boost::shared_ptr<Reel> reel)
 122 {
 123         _reels.push_back (reel);
 124 }
 125
 126 /** Write an CompositonPlaylist XML file.
 127  *  @param file Filename to write.
 128  *  @param standard INTEROP or SMPTE.
 129  *  @param signer Signer to sign the CPL, or 0 to add no signature.
 130  */
 131 void
 132 CPL::write_xml (boost::filesystem::path file, Standard standard, shared_ptr<const CertificateChain> signer) const
 133 {
 134         xmlpp::Document doc;
 135         xmlpp::Element* root;
 136         if (standard == INTEROP) {
 137                 root = doc.create_root_node ("CompositionPlaylist", cpl_interop_ns);
 138         } else {
 139                 root = doc.create_root_node ("CompositionPlaylist", cpl_smpte_ns);
 140         }
 141
 142         if (signer) {
 143                 root->set_namespace_declaration ("http://www.w3.org/2000/09/xmldsig#", "dsig");
 144         }
 145
 146         root->add_child("Id")->add_child_text ("urn:uuid:" + _id);
 147         root->add_child("AnnotationText")->add_child_text (_metadata.annotation_text);
 148         root->add_child("IssueDate")->add_child_text (_metadata.issue_date);
 149         root->add_child("Issuer")->add_child_text (_metadata.issuer);
 150         root->add_child("Creator")->add_child_text (_metadata.creator);
 151         root->add_child("ContentTitleText")->add_child_text (_content_title_text);
 152         root->add_child("ContentKind")->add_child_text (content_kind_to_string (_content_kind));
 153         {
 154                 xmlpp::Node* cv = root->add_child ("ContentVersion");
 155                 cv->add_child ("Id")->add_child_text (_content_version_id);
 156                 cv->add_child ("LabelText")->add_child_text (_content_version_label_text);
 157         }
 158         root->add_child("RatingList");
 159
 160         xmlpp::Element* reel_list = root->add_child ("ReelList");
 161
 162         BOOST_FOREACH (shared_ptr<Reel> i, _reels) {
 163                 i->write_to_cpl (reel_list, standard);
 164         }
 165
 166         if (signer) {
 167                 signer->sign (root, standard);
 168         }
 169
 170         /* This must not be the _formatted version otherwise signature digests will be wrong */
 171         doc.write_to_file (file.string (), "UTF-8");
 172
 173         set_file (file);
 174 }
 175
 176 list<shared_ptr<const ReelAsset> >
 177 CPL::reel_assets () const
 178 {
 179         list<shared_ptr<const ReelAsset> > c;
 180
 181         BOOST_FOREACH (shared_ptr<Reel> i, _reels) {
 182                 if (i->main_picture ()) {
 183                         c.push_back (i->main_picture());
 184                 }
 185                 if (i->main_sound ()) {
 186                         c.push_back (i->main_sound());
 187                 }
 188                 if (i->main_subtitle ()) {
 189                         c.push_back (i->main_subtitle());
 190                 }
 191                 if (i->atmos ()) {
 192                         c.push_back (i->atmos());
 193                 }
 194         }
 195
 196         return c;
 197 }
 198
 199 bool
 200 CPL::equals (shared_ptr<const Asset> other, EqualityOptions opt, NoteHandler note) const
 201 {
 202         shared_ptr<const CPL> other_cpl = dynamic_pointer_cast<const CPL> (other);
 203         if (!other_cpl) {
 204                 return false;
 205         }
 206
 207         if (_metadata.annotation_text != other_cpl->_metadata.annotation_text && !opt.cpl_annotation_texts_can_differ) {
 208                 string const s = "CPL: annotation texts differ: " + _metadata.annotation_text + " vs " + other_cpl->_metadata.annotation_text + "\n";
 209                 note (DCP_ERROR, s);
 210                 return false;
 211         }
 212
 213         if (_content_kind != other_cpl->_content_kind) {
 214                 note (DCP_ERROR, "CPL: content kinds differ");
 215                 return false;
 216         }
 217
 218         if (_reels.size() != other_cpl->_reels.size()) {
 219                 note (DCP_ERROR, String::compose ("CPL: reel counts differ (%1 vs %2)", _reels.size(), other_cpl->_reels.size()));
 220                 return false;
 221         }
 222
 223         list<shared_ptr<Reel> >::const_iterator a = _reels.begin ();
 224         list<shared_ptr<Reel> >::const_iterator b = other_cpl->_reels.begin ();
 225
 226         while (a != _reels.end ()) {
 227                 if (!(*a)->equals (*b, opt, note)) {
 228                         return false;
 229                 }
 230                 ++a;
 231                 ++b;
 232         }
 233
 234         return true;
 235 }
 236
 237 /** @return true if we have any encrypted content */
 238 bool
 239 CPL::encrypted () const
 240 {
 241         BOOST_FOREACH (shared_ptr<Reel> i, _reels) {
 242                 if (i->encrypted ()) {
 243                         return true;
 244                 }
 245         }
 246
 247         return false;
 248 }
 249
 250 /** Add a KDM to this CPL.  If the KDM is for any of this CPLs assets it will be used
 251  *  to decrypt those assets.
 252  *  @param kdm KDM.
 253  */
 254 void
 255 CPL::add (DecryptedKDM const & kdm)
 256 {
 257         BOOST_FOREACH (shared_ptr<Reel> i, _reels) {
 258                 i->add (kdm);
 259         }
 260 }
 261
 262 void
 263 CPL::resolve_refs (list<shared_ptr<Asset> > assets)
 264 {
 265         BOOST_FOREACH (shared_ptr<Reel> i, _reels) {
 266                 i->resolve_refs (assets);
 267         }
 268 }
 269
 270 string
 271 CPL::pkl_type (Standard standard) const
 272 {
 273         switch (standard) {
 274         case INTEROP:
 275                 return "text/xml;asdcpKind=CPL";
 276         case SMPTE:
 277                 return "text/xml";
 278         default:
 279                 DCP_ASSERT (false);
 280         }
 281 }
 282
 283 int64_t
 284 CPL::duration () const
 285 {
 286         int64_t d = 0;
 287         BOOST_FOREACH (shared_ptr<Reel> i, _reels) {
 288                 d += i->duration ();
 289         }
 290         return d;
 291 }