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