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 {
  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         string const uuid = make_uuid();
  75         _content_version_id = "urn:uuid:" + uuid;
  76         _content_version_label_text = uuid + 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         if (signer) {
 144                 root->set_namespace_declaration ("http://www.w3.org/2000/09/xmldsig#", "dsig");
 145         }
 146
 147         root->add_child("Id")->add_child_text ("urn:uuid:" + _id);
 148         root->add_child("AnnotationText")->add_child_text (_metadata.annotation_text);
 149         root->add_child("IssueDate")->add_child_text (_metadata.issue_date);
 150         root->add_child("Issuer")->add_child_text (_metadata.issuer);
 151         root->add_child("Creator")->add_child_text (_metadata.creator);
 152         root->add_child("ContentTitleText")->add_child_text (_content_title_text);
 153         root->add_child("ContentKind")->add_child_text (content_kind_to_string (_content_kind));
 154         {
 155                 xmlpp::Node* cv = root->add_child ("ContentVersion");
 156                 cv->add_child ("Id")->add_child_text (_content_version_id);
 157                 cv->add_child ("LabelText")->add_child_text (_content_version_label_text);
 158         }
 159         root->add_child("RatingList");
 160
 161         xmlpp::Element* reel_list = root->add_child ("ReelList");
 162
 163         BOOST_FOREACH (shared_ptr<Reel> i, _reels) {
 164                 i->write_to_cpl (reel_list, standard);
 165         }
 166
 167         indent (root, 0);
 168
 169         if (signer) {
 170                 signer->sign (root, standard);
 171         }
 172
 173         doc.write_to_file_formatted (file.string(), "UTF-8");
 174
 175         set_file (file);
 176 }
 177
 178 list<shared_ptr<ReelMXF> >
 179 CPL::reel_mxfs ()
 180 {
 181         list<shared_ptr<ReelMXF> > c;
 182
 183         BOOST_FOREACH (shared_ptr<Reel> i, _reels) {
 184                 if (i->main_picture ()) {
 185                         c.push_back (i->main_picture());
 186                 }
 187                 if (i->main_sound ()) {
 188                         c.push_back (i->main_sound());
 189                 }
 190                 if (i->main_subtitle ()) {
 191                         c.push_back (i->main_subtitle());
 192                 }
 193                 BOOST_FOREACH (shared_ptr<ReelClosedCaptionAsset> j, i->closed_captions()) {
 194                         c.push_back (j);
 195                 }
 196                 if (i->atmos ()) {
 197                         c.push_back (i->atmos());
 198                 }
 199         }
 200
 201         return c;
 202 }
 203
 204 list<shared_ptr<const ReelMXF> >
 205 CPL::reel_mxfs () const
 206 {
 207         list<shared_ptr<const ReelMXF> > c;
 208
 209         BOOST_FOREACH (shared_ptr<Reel> i, _reels) {
 210                 if (i->main_picture ()) {
 211                         c.push_back (i->main_picture());
 212                 }
 213                 if (i->main_sound ()) {
 214                         c.push_back (i->main_sound());
 215                 }
 216                 if (i->main_subtitle ()) {
 217                         c.push_back (i->main_subtitle());
 218                 }
 219                 BOOST_FOREACH (shared_ptr<ReelClosedCaptionAsset> j, i->closed_captions()) {
 220                         c.push_back (j);
 221                 }
 222                 if (i->atmos ()) {
 223                         c.push_back (i->atmos());
 224                 }
 225         }
 226
 227         return c;
 228 }
 229
 230 bool
 231 CPL::equals (shared_ptr<const Asset> other, EqualityOptions opt, NoteHandler note) const
 232 {
 233         shared_ptr<const CPL> other_cpl = dynamic_pointer_cast<const CPL> (other);
 234         if (!other_cpl) {
 235                 return false;
 236         }
 237
 238         if (_metadata.annotation_text != other_cpl->_metadata.annotation_text && !opt.cpl_annotation_texts_can_differ) {
 239                 string const s = "CPL: annotation texts differ: " + _metadata.annotation_text + " vs " + other_cpl->_metadata.annotation_text + "\n";
 240                 note (DCP_ERROR, s);
 241                 return false;
 242         }
 243
 244         if (_content_kind != other_cpl->_content_kind) {
 245                 note (DCP_ERROR, "CPL: content kinds differ");
 246                 return false;
 247         }
 248
 249         if (_reels.size() != other_cpl->_reels.size()) {
 250                 note (DCP_ERROR, String::compose ("CPL: reel counts differ (%1 vs %2)", _reels.size(), other_cpl->_reels.size()));
 251                 return false;
 252         }
 253
 254         list<shared_ptr<Reel> >::const_iterator a = _reels.begin ();
 255         list<shared_ptr<Reel> >::const_iterator b = other_cpl->_reels.begin ();
 256
 257         while (a != _reels.end ()) {
 258                 if (!(*a)->equals (*b, opt, note)) {
 259                         return false;
 260                 }
 261                 ++a;
 262                 ++b;
 263         }
 264
 265         return true;
 266 }
 267
 268 /** @return true if we have any encrypted content */
 269 bool
 270 CPL::encrypted () const
 271 {
 272         BOOST_FOREACH (shared_ptr<Reel> i, _reels) {
 273                 if (i->encrypted ()) {
 274                         return true;
 275                 }
 276         }
 277
 278         return false;
 279 }
 280
 281 /** Add a KDM to this CPL.  If the KDM is for any of this CPLs assets it will be used
 282  *  to decrypt those assets.
 283  *  @param kdm KDM.
 284  */
 285 void
 286 CPL::add (DecryptedKDM const & kdm)
 287 {
 288         BOOST_FOREACH (shared_ptr<Reel> i, _reels) {
 289                 i->add (kdm);
 290         }
 291 }
 292
 293 void
 294 CPL::resolve_refs (list<shared_ptr<Asset> > assets)
 295 {
 296         BOOST_FOREACH (shared_ptr<Reel> i, _reels) {
 297                 i->resolve_refs (assets);
 298         }
 299 }
 300
 301 string
 302 CPL::pkl_type (Standard standard) const
 303 {
 304         return static_pkl_type (standard);
 305 }
 306
 307 string
 308 CPL::static_pkl_type (Standard standard)
 309 {
 310         switch (standard) {
 311         case INTEROP:
 312                 return "text/xml;asdcpKind=CPL";
 313         case SMPTE:
 314                 return "text/xml";
 315         default:
 316                 DCP_ASSERT (false);
 317         }
 318 }
 319
 320 int64_t
 321 CPL::duration () const
 322 {
 323         int64_t d = 0;
 324         BOOST_FOREACH (shared_ptr<Reel> i, _reels) {
 325                 d += i->duration ();
 326         }
 327         return d;
 328 }