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         /** @return the type of the content, used by media servers
 139          *  to categorise things (e.g. feature, trailer, etc.)
 140          */
 141         ContentKind content_kind () const {
 142                 return _content_kind;
 143         }
 144
 145         boost::optional<ContentVersion> content_version () const;
 146
 147         std::vector<ContentVersion> content_versions () const {
 148                 return _content_versions;
 149         }
 150
 151         void set_content_version (ContentVersion v) {
 152                 _content_versions.clear ();
 153                 _content_versions.push_back (v);
 154         }
 155
 156         void set_content_versions (std::vector<ContentVersion> v);
 157
 158         std::vector<Rating> ratings () const {
 159                 return _ratings;
 160         }
 161
 162         void set_ratings (std::vector<Rating> r) {
 163                 _ratings = r;
 164         }
 165
 166         boost::optional<std::string> full_content_title_text () const {
 167                 return _full_content_title_text;
 168         }
 169
 170         void set_full_content_title_text (std::string t) {
 171                 _full_content_title_text = t;
 172         }
 173
 174         boost::optional<std::string> full_content_title_text_language () const {
 175                 return _full_content_title_text_language;
 176         }
 177
 178         void set_full_content_title_text_language (dcp::LanguageTag l) {
 179                 _full_content_title_text_language = l.to_string();
 180         }
 181
 182         boost::optional<std::string> release_territory () const {
 183                 return _release_territory;
 184         }
 185
 186         void set_release_territory (dcp::LanguageTag::RegionSubtag t) {
 187                 _release_territory = t.subtag();
 188         }
 189
 190         boost::optional<std::string> release_territory_scope () const {
 191                 return _release_territory_scope;
 192         }
 193
 194         boost::optional<int> version_number () const {
 195                 return _version_number;
 196         }
 197
 198         void set_version_number (int v);
 199
 200         boost::optional<Status> status () const {
 201                 return _status;
 202         }
 203
 204         void set_status (Status s) {
 205                 _status = s;
 206         }
 207
 208         boost::optional<std::string> chain () const {
 209                 return _chain;
 210         }
 211
 212         void set_chain (std::string c) {
 213                 _chain = c;
 214         }
 215
 216         boost::optional<std::string> distributor () const {
 217                 return _distributor;
 218         }
 219
 220         void set_distributor (std::string d) {
 221                 _distributor = d;
 222         }
 223
 224         boost::optional<std::string> facility () const {
 225                 return _facility;
 226         }
 227
 228         void set_facility (std::string f) {
 229                 _facility = f;
 230         }
 231
 232         boost::optional<Luminance> luminance () const {
 233                 return _luminance;
 234         }
 235
 236         void set_luminance (Luminance l) {
 237                 _luminance = l;
 238         }
 239
 240         boost::optional<std::string> main_sound_configuration () const {
 241                 return _main_sound_configuration;
 242         }
 243
 244         void set_main_sound_configuration (std::string c) {
 245                 _main_sound_configuration = c;
 246         }
 247
 248         boost::optional<int> main_sound_sample_rate () const {
 249                 return _main_sound_sample_rate;
 250         }
 251
 252         void set_main_sound_sample_rate (int r) {
 253                 _main_sound_sample_rate = r;
 254         }
 255
 256         boost::optional<dcp::Size> main_picture_stored_area () const {
 257                 return _main_picture_stored_area;
 258         }
 259
 260         void set_main_picture_stored_area (dcp::Size s) {
 261                 _main_picture_stored_area = s;
 262         }
 263
 264         boost::optional<dcp::Size> main_picture_active_area () const {
 265                 return _main_picture_active_area;
 266         }
 267
 268         void set_main_picture_active_area (dcp::Size s) {
 269                 _main_picture_active_area = s;
 270         }
 271
 272         std::vector<std::string> additional_subtitle_languages () const {
 273                 return _additional_subtitle_languages;
 274         }
 275
 276         void set_additional_subtitle_languages (std::vector<dcp::LanguageTag> const& lang);
 277
 278         boost::optional<Standard> standard () const {
 279                 return _standard;
 280         }
 281
 282         static std::string static_pkl_type (Standard standard);
 283
 284 protected:
 285         /** @return type string for PKLs for this asset */
 286         std::string pkl_type (Standard standard) const;
 287
 288 private:
 289         friend struct ::verify_various_invalid_languages;
 290
 291         void maybe_write_composition_metadata_asset (xmlpp::Element* node) const;
 292         void read_composition_metadata_asset (cxml::ConstNodePtr node);
 293
 294         std::string _issuer;
 295         std::string _creator;
 296         std::string _issue_date;
 297         boost::optional<std::string> _annotation_text;
 298         std::string _content_title_text;            ///< &lt;ContentTitleText&gt;
 299         ContentKind _content_kind;                  ///< &lt;ContentKind&gt;
 300         std::vector<ContentVersion> _content_versions;
 301         std::vector<Rating> _ratings;
 302         /** Human-readable name of the composition, without any metadata (i.e. no -FTR-EN-XX- etc.) */
 303         boost::optional<std::string> _full_content_title_text;
 304         boost::optional<std::string> _full_content_title_text_language;
 305         /** This is stored and returned as a string so that we can tolerate non-RFC-5646 strings,
 306          *  but must be set as a dcp::LanguageTag to try to ensure that we create compliant output.
 307          */
 308         boost::optional<std::string> _release_territory;
 309         boost::optional<std::string> _release_territory_scope;
 310         boost::optional<int> _version_number;
 311         boost::optional<Status> _status;
 312         boost::optional<std::string> _chain;
 313         boost::optional<std::string> _distributor;
 314         boost::optional<std::string> _facility;
 315         boost::optional<Luminance> _luminance;
 316         boost::optional<std::string> _main_sound_configuration;
 317         boost::optional<int> _main_sound_sample_rate;
 318         boost::optional<dcp::Size> _main_picture_stored_area;
 319         boost::optional<dcp::Size> _main_picture_active_area;
 320         /* See note for _release_territory above */
 321         std::vector<std::string> _additional_subtitle_languages;
 322
 323         std::vector<std::shared_ptr<Reel>> _reels;
 324
 325         /** Standard of CPL that was read in */
 326         boost::optional<Standard> _standard;
 327 };
 328
 329
 330 }
 331
 332
 333 #endif