src/cpl.h

   1 /*
   2     Copyright (C) 2014-2021 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
  35 /** @file  src/cpl.h
  36  *  @brief CPL class.
  37  */
  38
  39
  40 #ifndef LIBDCP_CPL_H
  41 #define LIBDCP_CPL_H
  42
  43
  44 #include "asset.h"
  45 #include "certificate.h"
  46 #include "key.h"
  47 #include "language_tag.h"
  48 #include "types.h"
  49 #include <boost/filesystem.hpp>
  50 #include <boost/function.hpp>
  51 #include <boost/optional.hpp>
  52 #include <memory>
  53 #include <vector>
  54
  55
  56 struct verify_various_invalid_languages;
  57
  58
  59 namespace dcp {
  60
  61
  62 class ReelMXF;
  63 class Reel;
  64 class MXFMetadata;
  65 class CertificateChain;
  66 class DecryptedKDM;
  67
  68
  69 /** @class CPL
  70  *  @brief A Composition Playlist.
  71  */
  72 class CPL : public Asset
  73 {
  74 public:
  75         CPL (std::string annotation_text, ContentKind content_kind);
  76         explicit CPL (boost::filesystem::path file);
  77
  78         bool equals (
  79                 std::shared_ptr<const Asset> other,
  80                 EqualityOptions options,
  81                 NoteHandler note
  82                 ) const;
  83
  84         void add (std::shared_ptr<Reel> reel);
  85         void add (DecryptedKDM const &);
  86
  87         /** @return the reels in this CPL */
  88         std::vector<std::shared_ptr<Reel>> reels () const {
  89                 return _reels;
  90         }
  91
  92         /** @return the ReelMXFs in this CPL in all reels */
  93         std::vector<std::shared_ptr<const ReelMXF>> reel_mxfs () const;
  94         std::vector<std::shared_ptr<ReelMXF>> reel_mxfs ();
  95
  96         bool encrypted () const;
  97
  98         void write_xml (
  99                 boost::filesystem::path file,
 100                 Standard standard,
 101                 std::shared_ptr<const CertificateChain>
 102                 ) const;
 103
 104         void resolve_refs (std::vector<std::shared_ptr<Asset>>);
 105
 106         int64_t duration () const;
 107
 108         void set_issuer (std::string issuer) {
 109                 _issuer = issuer;
 110         }
 111
 112         void set_creator (std::string creator) {
 113                 _creator = creator;
 114         }
 115
 116         void set_issue_date (std::string issue_date) {
 117                 _issue_date = issue_date;
 118         }
 119
 120         /** @return contents of the &lt;AnnotationText&gt; node, if present */
 121         boost::optional<std::string> annotation_text () const {
 122                 return _annotation_text;
 123         }
 124
 125         void set_annotation_text (std::string at) {
 126                 _annotation_text = at;
 127         }
 128
 129         /** @return contents of the &lt;ContentTitleText&gt; node */
 130         std::string content_title_text () const {
 131                 return _content_title_text;
 132         }
 133
 134         void set_content_title_text (std::string ct) {
 135                 _content_title_text = ct;
 136         }
 137
 138         void set_content_kind (dcp::ContentKind k) {
 139                 _content_kind = k;
 140         }
 141
 142         /** @return the type of the content, used by media servers
 143          *  to categorise things (e.g. feature, trailer, etc.)
 144          */
 145         ContentKind content_kind () const {
 146                 return _content_kind;
 147         }
 148
 149         boost::optional<ContentVersion> content_version () const;
 150
 151         std::vector<ContentVersion> content_versions () const {
 152                 return _content_versions;
 153         }
 154
 155         void set_content_version (ContentVersion v) {
 156                 _content_versions.clear ();
 157                 _content_versions.push_back (v);
 158         }
 159
 160         void set_content_versions (std::vector<ContentVersion> v);
 161
 162         std::vector<Rating> ratings () const {
 163                 return _ratings;
 164         }
 165
 166         void set_ratings (std::vector<Rating> r) {
 167                 _ratings = r;
 168         }
 169
 170         boost::optional<std::string> full_content_title_text () const {
 171                 return _full_content_title_text;
 172         }
 173
 174         void set_full_content_title_text (std::string t) {
 175                 _full_content_title_text = t;
 176         }
 177
 178         boost::optional<std::string> full_content_title_text_language () const {
 179                 return _full_content_title_text_language;
 180         }
 181
 182         void set_full_content_title_text_language (dcp::LanguageTag l) {
 183                 _full_content_title_text_language = l.to_string();
 184         }
 185
 186         boost::optional<std::string> release_territory () const {
 187                 return _release_territory;
 188         }
 189
 190         void set_release_territory (dcp::LanguageTag::RegionSubtag t) {
 191                 _release_territory = t.subtag();
 192         }
 193
 194         boost::optional<std::string> release_territory_scope () const {
 195                 return _release_territory_scope;
 196         }
 197
 198         boost::optional<int> version_number () const {
 199                 return _version_number;
 200         }
 201
 202         void set_version_number (int v);
 203
 204         boost::optional<Status> status () const {
 205                 return _status;
 206         }
 207
 208         void set_status (Status s) {
 209                 _status = s;
 210         }
 211
 212         boost::optional<std::string> chain () const {
 213                 return _chain;
 214         }
 215
 216         void set_chain (std::string c) {
 217                 _chain = c;
 218         }
 219
 220         boost::optional<std::string> distributor () const {
 221                 return _distributor;
 222         }
 223
 224         void set_distributor (std::string d) {
 225                 _distributor = d;
 226         }
 227
 228         boost::optional<std::string> facility () const {
 229                 return _facility;
 230         }
 231
 232         void set_facility (std::string f) {
 233                 _facility = f;
 234         }
 235
 236         boost::optional<Luminance> luminance () const {
 237                 return _luminance;
 238         }
 239
 240         void set_luminance (Luminance l) {
 241                 _luminance = l;
 242         }
 243
 244         boost::optional<std::string> main_sound_configuration () const {
 245                 return _main_sound_configuration;
 246         }
 247
 248         void set_main_sound_configuration (std::string c) {
 249                 _main_sound_configuration = c;
 250         }
 251
 252         boost::optional<int> main_sound_sample_rate () const {
 253                 return _main_sound_sample_rate;
 254         }
 255
 256         void set_main_sound_sample_rate (int r) {
 257                 _main_sound_sample_rate = r;
 258         }
 259
 260         boost::optional<dcp::Size> main_picture_stored_area () const {
 261                 return _main_picture_stored_area;
 262         }
 263
 264         void set_main_picture_stored_area (dcp::Size s) {
 265                 _main_picture_stored_area = s;
 266         }
 267
 268         boost::optional<dcp::Size> main_picture_active_area () const {
 269                 return _main_picture_active_area;
 270         }
 271
 272         void set_main_picture_active_area (dcp::Size s) {
 273                 _main_picture_active_area = s;
 274         }
 275
 276         std::vector<std::string> additional_subtitle_languages () const {
 277                 return _additional_subtitle_languages;
 278         }
 279
 280         void set_additional_subtitle_languages (std::vector<dcp::LanguageTag> const& lang);
 281
 282         boost::optional<Standard> standard () const {
 283                 return _standard;
 284         }
 285
 286         static std::string static_pkl_type (Standard standard);
 287
 288 protected:
 289         /** @return type string for PKLs for this asset */
 290         std::string pkl_type (Standard standard) const;
 291
 292 private:
 293         friend struct ::verify_various_invalid_languages;
 294
 295         void maybe_write_composition_metadata_asset (xmlpp::Element* node) const;
 296         void read_composition_metadata_asset (cxml::ConstNodePtr node);
 297
 298         std::string _issuer;
 299         std::string _creator;
 300         std::string _issue_date;
 301         boost::optional<std::string> _annotation_text;
 302         std::string _content_title_text;            ///< &lt;ContentTitleText&gt;
 303         ContentKind _content_kind;                  ///< &lt;ContentKind&gt;
 304         std::vector<ContentVersion> _content_versions;
 305         std::vector<Rating> _ratings;
 306         /** Human-readable name of the composition, without any metadata (i.e. no -FTR-EN-XX- etc.) */
 307         boost::optional<std::string> _full_content_title_text;
 308         boost::optional<std::string> _full_content_title_text_language;
 309         /** This is stored and returned as a string so that we can tolerate non-RFC-5646 strings,
 310          *  but must be set as a dcp::LanguageTag to try to ensure that we create compliant output.
 311          */
 312         boost::optional<std::string> _release_territory;
 313         boost::optional<std::string> _release_territory_scope;
 314         boost::optional<int> _version_number;
 315         boost::optional<Status> _status;
 316         boost::optional<std::string> _chain;
 317         boost::optional<std::string> _distributor;
 318         boost::optional<std::string> _facility;
 319         boost::optional<Luminance> _luminance;
 320         boost::optional<std::string> _main_sound_configuration;
 321         boost::optional<int> _main_sound_sample_rate;
 322         boost::optional<dcp::Size> _main_picture_stored_area;
 323         boost::optional<dcp::Size> _main_picture_active_area;
 324         /* See note for _release_territory above */
 325         std::vector<std::string> _additional_subtitle_languages;
 326
 327         std::vector<std::shared_ptr<Reel>> _reels;
 328
 329         /** Standard of CPL that was read in */
 330         boost::optional<Standard> _standard;
 331 };
 332
 333
 334 }
 335
 336
 337 #endif