X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Fcpl.h;h=824faaa132217756054a8d5fad66aefe76b985c1;hb=HEAD;hp=7716464d960fc2e6b045cad0df57284c9b963fd1;hpb=0f09e4f7335fb125273aa3d1dc397797a2eba1dd;p=libdcp.git diff --git a/src/cpl.h b/src/cpl.h index 7716464d..824faaa1 100644 --- a/src/cpl.h +++ b/src/cpl.h @@ -1,86 +1,185 @@ /* - Copyright (C) 2014 Carl Hetherington + Copyright (C) 2014-2021 Carl Hetherington - This program is free software; you -can redistribute it and/or modify + This file is part of libdcp. + + libdcp is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. - This program is distributed in the hope that it will be useful, + libdcp is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + along with libdcp. If not, see . + + In addition, as a special exception, the copyright holders give + permission to link the code of portions of this program with the + OpenSSL library under certain conditions as described in each + individual source file, and distribute linked combinations + including the two. + You must obey the GNU General Public License in all respects + for all of the code used other than OpenSSL. If you modify + file(s) with this exception, you may extend this exception to your + version of the file(s), but you are not obligated to do so. If you + do not wish to do so, delete this exception statement from your + version. If you delete this exception statement from all source + files in the program, then also delete it here. */ + /** @file src/cpl.h - * @brief CPL class. + * @brief CPL class */ + #ifndef LIBDCP_CPL_H #define LIBDCP_CPL_H -#include "types.h" + +#include "asset.h" #include "certificate.h" +#include "content_kind.h" #include "key.h" -#include "asset.h" -#include "metadata.h" -#include -#include +#include "language_tag.h" +#include "rating.h" +#include "verify.h" +#include #include #include -#include -#include +#include +#include + + +struct verify_invalid_language3; + namespace dcp { -class ReelAsset; -class Reel; -class XMLMetadata; -class MXFMetadata; -class Signer; + +class CertificateChain; class DecryptedKDM; +class MXFMetadata; +class Reel; +class ReelFileAsset; +class SoundAsset; + /** @class CPL - * @brief A Composition Playlist. + * @brief A Composition Playlist + * + * A CPL contains some metadata and a list of Reel objects, each of which may contain picture, sound and other assets + * such as subtitles and closed captions. + * + * After creating a CPL you can add Reel objects with add(), and write an XML file describing the CPL with + * write_xml(). */ class CPL : public Asset { public: - CPL (std::string annotation_text, ContentKind content_kind); - CPL (boost::filesystem::path file); + CPL (std::string annotation_text, ContentKind content_kind, Standard standard); + + /** Construct a CPL object from a XML file. + * If notes is not null, non-fatal errors will be added. + * Exceptions will be thrown on non-recoverable errors. + */ + explicit CPL(boost::filesystem::path file, std::vector* notes = nullptr); bool equals ( - boost::shared_ptr other, - EqualityOptions options, + std::shared_ptr other, + EqualityOptions const& options, NoteHandler note - ) const; + ) const override; + + /** Add a reel to this CPL + * @param reel Reel to add + */ + void add (std::shared_ptr reel); - void add (boost::shared_ptr reel); + void set (std::vector> reels); + + /** Add a KDM to this CPL. If the KDM is for any of this CPLs assets it will be used + * to decrypt those assets. + * @param kdm KDM. + */ void add (DecryptedKDM const &); - /** @return contents of the <AnnotationText> node */ - std::string annotation_text () const { + /** @return the reels in this CPL */ + std::vector> reels () const { + return _reels; + } + + /** @return the ReelFileAssets in this CPL in all reels */ + std::vector> reel_file_assets () const; + std::vector> reel_file_assets (); + + /** @return true if we have any encrypted content */ + bool any_encrypted () const; + + /** @return true if we have all our encryptable content is encrypted */ + bool all_encrypted () const; + + /** Write a CompositionPlaylist XML file + * + * @param file Filename to write + * @param signer Signer to sign the CPL, or 0 to add no signature + * @param include_mca_subdescriptors true to add a MCASubDescriptors tag to metadata, + * false to omit it. + */ + void write_xml ( + boost::filesystem::path file, + std::shared_ptr, + bool include_mca_subdescriptors = true + ) const; + + void resolve_refs (std::vector>); + + int64_t duration () const; + + std::string issuer () const { + return _issuer; + } + + void set_issuer (std::string issuer) { + _issuer = issuer; + } + + std::string creator () const { + return _creator; + } + + void set_creator (std::string creator) { + _creator = creator; + } + + void set_issue_date (std::string issue_date) { + _issue_date = issue_date; + } + + /** @return contents of the <AnnotationText> node, if present */ + boost::optional annotation_text () const { return _annotation_text; } + void set_annotation_text (std::string at) { + _annotation_text = at; + } + /** @return contents of the <ContentTitleText> node */ std::string content_title_text () const { return _content_title_text; } - /** @return contents of the <Id> node within <ContentVersion> */ - void set_content_version_id (std::string id) { - _content_version_id = id; + void set_content_title_text (std::string ct) { + _content_title_text = ct; } - /** @return contents of the <LabelText> node within <ContentVersion> */ - void set_content_version_label_text (std::string text) { - _content_version_label_text = text; + void set_content_kind (dcp::ContentKind k) { + _content_kind = k; } /** @return the type of the content, used by media servers @@ -90,46 +189,223 @@ public: return _content_kind; } - /** @return the reels in this CPL */ - std::list > reels () const { - return _reels; + boost::optional content_version () const; + + std::vector content_versions () const { + return _content_versions; } - /** @return the ReelAssets in this CPL in all reels. - */ - std::list > reel_assets () const; + void set_content_version (ContentVersion v) { + _content_versions.clear (); + _content_versions.push_back (v); + } - bool encrypted () const; + void set_content_versions (std::vector v); - void set_metadata (XMLMetadata m) { - _metadata = m; + std::vector ratings () const { + return _ratings; } - void write_xml ( - boost::filesystem::path file, - Standard standard, - boost::shared_ptr - ) const; + void set_ratings (std::vector r) { + _ratings = r; + } + + boost::optional full_content_title_text () const { + return _full_content_title_text; + } + + void set_full_content_title_text (std::string t) { + _full_content_title_text = t; + } + + boost::optional full_content_title_text_language () const { + return _full_content_title_text_language; + } + + void set_full_content_title_text_language (dcp::LanguageTag l) { + _full_content_title_text_language = l.to_string(); + } + + boost::optional release_territory () const { + return _release_territory; + } + + void set_release_territory (dcp::LanguageTag::RegionSubtag t) { + _release_territory = t.subtag(); + } + + boost::optional release_territory_scope () const { + return _release_territory_scope; + } + + boost::optional version_number () const { + return _version_number; + } + + void set_version_number (int v); + + void unset_version_number (); - void resolve_refs (std::list >); + boost::optional status () const { + return _status; + } + + void set_status (Status s) { + _status = s; + } + + boost::optional chain () const { + return _chain; + } + + void set_chain (std::string c) { + _chain = c; + } + + boost::optional distributor () const { + return _distributor; + } + + void set_distributor (std::string d) { + _distributor = d; + } + + boost::optional facility () const { + return _facility; + } + + void set_facility (std::string f) { + _facility = f; + } + + boost::optional luminance () const { + return _luminance; + } + + void set_luminance (Luminance l) { + _luminance = l; + } + + boost::optional main_sound_configuration () const { + return _main_sound_configuration; + } + + void set_main_sound_configuration(dcp::MainSoundConfiguration c) { + _main_sound_configuration = c; + } + + boost::optional main_sound_sample_rate () const { + return _main_sound_sample_rate; + } + + void set_main_sound_sample_rate (int r) { + _main_sound_sample_rate = r; + } + + boost::optional main_picture_stored_area () const { + return _main_picture_stored_area; + } + + void set_main_picture_stored_area (dcp::Size s) { + _main_picture_stored_area = s; + } + + boost::optional main_picture_active_area () const { + return _main_picture_active_area; + } + + void set_main_picture_active_area(dcp::Size area); + + std::vector additional_subtitle_languages () const { + return _additional_subtitle_languages; + } + + void set_additional_subtitle_languages (std::vector const& lang); + + void set_sign_language_video_language (dcp::LanguageTag lang) { + _sign_language_video_language = lang.to_string(); + } + + boost::optional sign_language_video_language () const { + return _sign_language_video_language; + } + + void set_dolby_edr_image_transfer_function(std::string function) { + _dolby_edr_image_transfer_function = function; + } + + boost::optional dolby_edr_image_transfer_function() const { + return _dolby_edr_image_transfer_function; + } + + Standard standard () const { + return _standard; + } + + /** @return true iff this CPL was read from a file and it contained + * a CompositionMetadataAsset node. + */ + bool read_composition_metadata() const { + return _read_composition_metadata; + } + + static std::string static_pkl_type (Standard standard); protected: /** @return type string for PKLs for this asset */ - std::string pkl_type (Standard standard) const; + std::string pkl_type (Standard standard) const override; private: - std::string _annotation_text; ///< <AnnotationText> - /** <Issuer>, <Creator> and <IssueDate>. These are grouped - * because they occur together in a few places. - */ - XMLMetadata _metadata; + friend struct ::verify_invalid_language3; + + void maybe_write_composition_metadata_asset(xmlpp::Element* node, bool include_mca_subdescriptors) const; + void read_composition_metadata_asset (cxml::ConstNodePtr node); + void write_mca_subdescriptors(xmlpp::Element* parent, std::shared_ptr asset) const; + + std::string _issuer; + std::string _creator; + std::string _issue_date; + boost::optional _annotation_text; std::string _content_title_text; ///< <ContentTitleText> ContentKind _content_kind; ///< <ContentKind> - std::string _content_version_id; ///< <Id> in <ContentVersion> - std::string _content_version_label_text; ///< <LabelText> in <ContentVersion> - std::list > _reels; + std::vector _content_versions; + std::vector _ratings; + /** ID for CompositionMetadataAsset tag; either a random one, ready for writing a new tag, + * or the one read in from the existing CPL. + */ + std::string _cpl_metadata_id = make_uuid(); + /** Human-readable name of the composition, without any metadata (i.e. no -FTR-EN-XX- etc.) */ + boost::optional _full_content_title_text; + boost::optional _full_content_title_text_language; + /** This is stored and returned as a string so that we can tolerate non-RFC-5646 strings, + * but must be set as a dcp::LanguageTag to try to ensure that we create compliant output. + */ + boost::optional _release_territory; + boost::optional _release_territory_scope; + boost::optional _version_number; + boost::optional _status; + boost::optional _chain; + boost::optional _distributor; + boost::optional _facility; + boost::optional _luminance; + boost::optional _main_sound_configuration; + boost::optional _main_sound_sample_rate; + boost::optional _main_picture_stored_area; + boost::optional _main_picture_active_area; + /* See note for _release_territory above */ + std::vector _additional_subtitle_languages; + boost::optional _sign_language_video_language; + boost::optional _dolby_edr_image_transfer_function; + bool _read_composition_metadata = false; + + std::vector> _reels; + + /** Standard of CPL that was read in */ + Standard _standard; }; + } + #endif