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<int> version_number () const {
 191                 return _version_number;
 192         }
 193
 194         void set_version_number (int v);
 195
 196         boost::optional<Status> status () const {
 197                 return _status;
 198         }
 199
 200         void set_status (Status s) {
 201                 _status = s;
 202         }
 203
 204         boost::optional<std::string> chain () const {
 205                 return _chain;
 206         }
 207
 208         void set_chain (std::string c) {
 209                 _chain = c;
 210         }
 211
 212         boost::optional<std::string> distributor () const {
 213                 return _distributor;
 214         }
 215
 216         void set_distributor (std::string d) {
 217                 _distributor = d;
 218         }
 219
 220         boost::optional<std::string> facility () const {
 221                 return _facility;
 222         }
 223
 224         void set_facility (std::string f) {
 225                 _facility = f;
 226         }
 227
 228         boost::optional<Luminance> luminance () const {
 229                 return _luminance;
 230         }
 231
 232         void set_luminance (Luminance l) {
 233                 _luminance = l;
 234         }
 235
 236         boost::optional<std::string> main_sound_configuration () const {
 237                 return _main_sound_configuration;
 238         }
 239
 240         void set_main_sound_configuration (std::string c) {
 241                 _main_sound_configuration = c;
 242         }
 243
 244         boost::optional<int> main_sound_sample_rate () const {
 245                 return _main_sound_sample_rate;
 246         }
 247
 248         void set_main_sound_sample_rate (int r) {
 249                 _main_sound_sample_rate = r;
 250         }
 251
 252         boost::optional<dcp::Size> main_picture_stored_area () const {
 253                 return _main_picture_stored_area;
 254         }
 255
 256         void set_main_picture_stored_area (dcp::Size s) {
 257                 _main_picture_stored_area = s;
 258         }
 259
 260         boost::optional<dcp::Size> main_picture_active_area () const {
 261                 return _main_picture_active_area;
 262         }
 263
 264         void set_main_picture_active_area (dcp::Size s) {
 265                 _main_picture_active_area = s;
 266         }
 267
 268         std::vector<std::string> additional_subtitle_languages () const {
 269                 return _additional_subtitle_languages;
 270         }
 271
 272         void set_additional_subtitle_languages (std::vector<dcp::LanguageTag> const& lang);
 273
 274         boost::optional<Standard> standard () const {
 275                 return _standard;
 276         }
 277
 278         static std::string static_pkl_type (Standard standard);
 279
 280 protected:
 281         /** @return type string for PKLs for this asset */
 282         std::string pkl_type (Standard standard) const;
 283
 284 private:
 285         friend struct ::verify_various_invalid_languages;
 286
 287         void maybe_write_composition_metadata_asset (xmlpp::Element* node) const;
 288         void read_composition_metadata_asset (cxml::ConstNodePtr node);
 289
 290         std::string _issuer;
 291         std::string _creator;
 292         std::string _issue_date;
 293         boost::optional<std::string> _annotation_text;
 294         std::string _content_title_text;            ///< &lt;ContentTitleText&gt;
 295         ContentKind _content_kind;                  ///< &lt;ContentKind&gt;
 296         std::vector<ContentVersion> _content_versions;
 297         std::vector<Rating> _ratings;
 298         /** Human-readable name of the composition, without any metadata (i.e. no -FTR-EN-XX- etc.) */
 299         boost::optional<std::string> _full_content_title_text;
 300         boost::optional<std::string> _full_content_title_text_language;
 301         /** This is stored and returned as a string so that we can tolerate non-RFC-5646 strings,
 302          *  but must be set as a dcp::LanguageTag to try to ensure that we create compliant output.
 303          */
 304         boost::optional<std::string> _release_territory;
 305         boost::optional<int> _version_number;
 306         boost::optional<Status> _status;
 307         boost::optional<std::string> _chain;
 308         boost::optional<std::string> _distributor;
 309         boost::optional<std::string> _facility;
 310         boost::optional<Luminance> _luminance;
 311         boost::optional<std::string> _main_sound_configuration;
 312         boost::optional<int> _main_sound_sample_rate;
 313         boost::optional<dcp::Size> _main_picture_stored_area;
 314         boost::optional<dcp::Size> _main_picture_active_area;
 315         /* See note for _release_territory above */
 316         std::vector<std::string> _additional_subtitle_languages;
 317
 318         std::vector<std::shared_ptr<Reel>> _reels;
 319
 320         /** Standard of CPL that was read in */
 321         boost::optional<Standard> _standard;
 322 };
 323
 324
 325 }
 326
 327
 328 #endif