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_closed_caption_asset.h"
  44 #include "reel_atmos_asset.h"
  45 #include "local_time.h"
  46 #include "dcp_assert.h"
  47 #include "compose.hpp"
  48 #include <libxml/parser.h>
  49 #include <libxml++/libxml++.h>
  50 #include <boost/foreach.hpp>
  51
  52 using std::string;
  53 using std::list;
  54 using std::pair;
  55 using std::make_pair;
  56 using std::cout;
  57 using boost::shared_ptr;
  58 using boost::optional;
  59 using boost::dynamic_pointer_cast;
  60 using namespace dcp;
  61
  62 static string const cpl_interop_ns = "http://www.digicine.com/PROTO-ASDCP-CPL-20040511#";
  63 static string const cpl_smpte_ns   = "http://www.smpte-ra.org/schemas/429-7/2006/CPL";
  64
  65 CPL::CPL (string annotation_text, ContentKind content_kind)
  66         /* default _content_title_text to annotation_text */
  67         : _content_title_text (annotation_text)
  68         , _content_kind (content_kind)
  69         , _content_version_id ("urn:uuid:" + make_uuid ())
  70 {
  71         _metadata.annotation_text = annotation_text;
  72         /* default _content_version_id to a random ID and _content_version_label to
  73            a random ID and the current time.
  74         */
  75         _content_version_id = "urn:uuid:" + make_uuid();
  76         _content_version_label_text = _content_version_id + LocalTime().as_string ();
  77 }
  78
  79 /** Construct a CPL object from a XML file */
  80 CPL::CPL (boost::filesystem::path file)
  81         : Asset (file)
  82         , _content_kind (FEATURE)
  83 {
  84         cxml::Document f ("CompositionPlaylist");
  85         f.read_file (file);
  86
  87         if (f.namespace_uri() == cpl_interop_ns) {
  88                 _standard = INTEROP;
  89         } else if (f.namespace_uri() == cpl_smpte_ns) {
  90                 _standard = SMPTE;
  91         } else {
  92                 boost::throw_exception (XMLError ("Unrecognised CPL namespace " + f.namespace_uri()));
  93         }
  94
  95         _id = remove_urn_uuid (f.string_child ("Id"));
  96         _metadata.annotation_text = f.optional_string_child ("AnnotationText").get_value_or ("");
  97         _metadata.issuer = f.optional_string_child ("Issuer").get_value_or ("");
  98         _metadata.creator = f.optional_string_child ("Creator").get_value_or ("");
  99         _metadata.issue_date = f.string_child ("IssueDate");
 100         _content_title_text = f.string_child ("ContentTitleText");
 101         _content_kind = content_kind_from_string (f.string_child ("ContentKind"));
 102         shared_ptr<cxml::Node> content_version = f.optional_node_child ("ContentVersion");
 103         if (content_version) {
 104                 _content_version_id = content_version->optional_string_child ("Id").get_value_or ("");
 105                 _content_version_label_text = content_version->string_child ("LabelText");
 106                 content_version->done ();
 107         }
 108         f.ignore_child ("RatingList");
 109         _reels = type_grand_children<Reel> (f, "ReelList", "Reel");
 110
 111         f.ignore_child ("Issuer");
 112         f.ignore_child ("Signer");
 113         f.ignore_child ("Signature");
 114
 115         f.done ();
 116 }
 117
 118 /** Add a reel to this CPL.
 119  *  @param reel Reel to add.
 120  */
 121 void
 122 CPL::add (boost::shared_ptr<Reel> reel)
 123 {
 124         _reels.push_back (reel);
 125 }
 126
 127 /** Write an CompositonPlaylist XML file.
 128  *  @param file Filename to write.
 129  *  @param standard INTEROP or SMPTE.
 130  *  @param signer Signer to sign the CPL, or 0 to add no signature.
 131  */
 132 void
 133 CPL::write_xml (boost::filesystem::path file, Standard standard, shared_ptr<const CertificateChain> signer) const
 134 {
 135         xmlpp::Document doc;
 136         xmlpp::Element* root;
 137         if (standard == INTEROP) {
 138                 root = doc.create_root_node ("CompositionPlaylist", cpl_interop_ns);
 139         } else {
 140                 root = doc.create_root_node ("CompositionPlaylist", cpl_smpte_ns);
 141         }
 142
 143         root->add_child("Id")->add_child_text ("urn:uuid:" + _id);
 144         root->add_child("AnnotationText")->add_child_text (_metadata.annotation_text);
 145         root->add_child("IssueDate")->add_child_text (_metadata.issue_date);
 146         root->add_child("Issuer")->add_child_text (_metadata.issuer);
 147         root->add_child("Creator")->add_child_text (_metadata.creator);
 148         root->add_child("ContentTitleText")->add_child_text (_content_title_text);
 149         root->add_child("ContentKind")->add_child_text (content_kind_to_string (_content_kind));
 150         {
 151                 xmlpp::Node* cv = root->add_child ("ContentVersion");
 152                 cv->add_child ("Id")->add_child_text (_content_version_id);
 153                 cv->add_child ("LabelText")->add_child_text (_content_version_label_text);
 154         }
 155         root->add_child("RatingList");
 156
 157         xmlpp::Element* reel_list = root->add_child ("ReelList");
 158
 159         BOOST_FOREACH (shared_ptr<Reel> i, _reels) {
 160                 i->write_to_cpl (reel_list, standard);
 161         }
 162
 163         if (signer) {
 164                 signer->sign (root, standard);
 165         }
 166
 167         /* This must not be the _formatted version otherwise signature digests will be wrong */
 168         doc.write_to_file (file.string (), "UTF-8");
 169
 170         set_file (file);
 171 }
 172
 173 list<shared_ptr<const ReelAsset> >
 174 CPL::reel_assets () const
 175 {
 176         list<shared_ptr<const ReelAsset> > c;
 177
 178         BOOST_FOREACH (shared_ptr<Reel> i, _reels) {
 179                 if (i->main_picture ()) {
 180                         c.push_back (i->main_picture());
 181                 }
 182                 if (i->main_sound ()) {
 183                         c.push_back (i->main_sound());
 184                 }
 185                 if (i->main_subtitle ()) {
 186                         c.push_back (i->main_subtitle());
 187                 }
 188                 if (i->closed_caption ()) {
 189                         c.push_back (i->closed_caption());
 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 }