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