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         if (signer) {
 168                 signer->sign (root, standard);
 169         }
 170
 171         doc.write_to_file_formatted (file.string(), "UTF-8");
 172
 173         set_file (file);
 174 }
 175
 176 list<shared_ptr<ReelAsset> >
 177 CPL::reel_assets ()
 178 {
 179         list<shared_ptr<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                 BOOST_FOREACH (shared_ptr<ReelClosedCaptionAsset> j, i->closed_captions()) {
 192                         c.push_back (j);
 193                 }
 194                 if (i->atmos ()) {
 195                         c.push_back (i->atmos());
 196                 }
 197         }
 198
 199         return c;
 200 }
 201
 202 list<shared_ptr<const ReelAsset> >
 203 CPL::reel_assets () const
 204 {
 205         list<shared_ptr<const ReelAsset> > c;
 206
 207         BOOST_FOREACH (shared_ptr<Reel> i, _reels) {
 208                 if (i->main_picture ()) {
 209                         c.push_back (i->main_picture());
 210                 }
 211                 if (i->main_sound ()) {
 212                         c.push_back (i->main_sound());
 213                 }
 214                 if (i->main_subtitle ()) {
 215                         c.push_back (i->main_subtitle());
 216                 }
 217                 BOOST_FOREACH (shared_ptr<ReelClosedCaptionAsset> j, i->closed_captions()) {
 218                         c.push_back (j);
 219                 }
 220                 if (i->atmos ()) {
 221                         c.push_back (i->atmos());
 222                 }
 223         }
 224
 225         return c;
 226 }
 227
 228 bool
 229 CPL::equals (shared_ptr<const Asset> other, EqualityOptions opt, NoteHandler note) const
 230 {
 231         shared_ptr<const CPL> other_cpl = dynamic_pointer_cast<const CPL> (other);
 232         if (!other_cpl) {
 233                 return false;
 234         }
 235
 236         if (_metadata.annotation_text != other_cpl->_metadata.annotation_text && !opt.cpl_annotation_texts_can_differ) {
 237                 string const s = "CPL: annotation texts differ: " + _metadata.annotation_text + " vs " + other_cpl->_metadata.annotation_text + "\n";
 238                 note (DCP_ERROR, s);
 239                 return false;
 240         }
 241
 242         if (_content_kind != other_cpl->_content_kind) {
 243                 note (DCP_ERROR, "CPL: content kinds differ");
 244                 return false;
 245         }
 246
 247         if (_reels.size() != other_cpl->_reels.size()) {
 248                 note (DCP_ERROR, String::compose ("CPL: reel counts differ (%1 vs %2)", _reels.size(), other_cpl->_reels.size()));
 249                 return false;
 250         }
 251
 252         list<shared_ptr<Reel> >::const_iterator a = _reels.begin ();
 253         list<shared_ptr<Reel> >::const_iterator b = other_cpl->_reels.begin ();
 254
 255         while (a != _reels.end ()) {
 256                 if (!(*a)->equals (*b, opt, note)) {
 257                         return false;
 258                 }
 259                 ++a;
 260                 ++b;
 261         }
 262
 263         return true;
 264 }
 265
 266 /** @return true if we have any encrypted content */
 267 bool
 268 CPL::encrypted () const
 269 {
 270         BOOST_FOREACH (shared_ptr<Reel> i, _reels) {
 271                 if (i->encrypted ()) {
 272                         return true;
 273                 }
 274         }
 275
 276         return false;
 277 }
 278
 279 /** Add a KDM to this CPL.  If the KDM is for any of this CPLs assets it will be used
 280  *  to decrypt those assets.
 281  *  @param kdm KDM.
 282  */
 283 void
 284 CPL::add (DecryptedKDM const & kdm)
 285 {
 286         BOOST_FOREACH (shared_ptr<Reel> i, _reels) {
 287                 i->add (kdm);
 288         }
 289 }
 290
 291 void
 292 CPL::resolve_refs (list<shared_ptr<Asset> > assets)
 293 {
 294         BOOST_FOREACH (shared_ptr<Reel> i, _reels) {
 295                 i->resolve_refs (assets);
 296         }
 297 }
 298
 299 string
 300 CPL::pkl_type (Standard standard) const
 301 {
 302         return static_pkl_type (standard);
 303 }
 304
 305 string
 306 CPL::static_pkl_type (Standard standard)
 307 {
 308         switch (standard) {
 309         case INTEROP:
 310                 return "text/xml;asdcpKind=CPL";
 311         case SMPTE:
 312                 return "text/xml";
 313         default:
 314                 DCP_ASSERT (false);
 315         }
 316 }
 317
 318 int64_t
 319 CPL::duration () const
 320 {
 321         int64_t d = 0;
 322         BOOST_FOREACH (shared_ptr<Reel> i, _reels) {
 323                 d += i->duration ();
 324         }
 325         return d;
 326 }