X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Freel.cc;h=163164875555f18ef5be5948585e16ffaa224025;hb=6c37cc1979b2a01205a888c4c98f3334685ee8dd;hp=d8703dd02e5eb62da8fb4c45bb8d6e2395bf186d;hpb=84d778a7a2816dc653ec4495d565a8a869b7a40c;p=libdcp.git diff --git a/src/reel.cc b/src/reel.cc index d8703dd0..16316487 100644 --- a/src/reel.cc +++ b/src/reel.cc @@ -1,82 +1,413 @@ /* - Copyright (C) 2012 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. */ -#include + #include "reel.h" #include "util.h" #include "picture_asset.h" +#include "mono_picture_asset.h" +#include "stereo_picture_asset.h" #include "sound_asset.h" #include "subtitle_asset.h" +#include "reel_mono_picture_asset.h" +#include "reel_stereo_picture_asset.h" +#include "reel_sound_asset.h" +#include "reel_subtitle_asset.h" +#include "reel_markers_asset.h" +#include "decrypted_kdm_key.h" +#include "decrypted_kdm.h" +#include "interop_subtitle_asset.h" +#include "smpte_subtitle_asset.h" +#include "reel_atmos_asset.h" +#include "reel_closed_caption_asset.h" +#include +#include -using namespace std; -using namespace libdcp; -void -Reel::write_to_cpl (xmlpp::Node* parent) const +using std::string; +using std::cout; +using std::min; +using std::make_shared; +using std::shared_ptr; +using std::dynamic_pointer_cast; +using std::vector; +using namespace dcp; + + +Reel::Reel (std::shared_ptr node) + : Object (remove_urn_uuid (node->string_child ("Id"))) { - xmlpp::Element* reel = parent->add_child("Reel"); - reel->add_child("Id")->add_child_text("urn:uuid:" + make_uuid()); - xmlpp::Element* asset_list = reel->add_child("AssetList"); + auto asset_list = node->node_child ("AssetList"); - if (_main_picture) { - _main_picture->write_to_cpl (asset_list); + auto main_picture = asset_list->optional_node_child ("MainPicture"); + if (main_picture) { + _main_picture = make_shared(main_picture); + } + + auto main_stereoscopic_picture = asset_list->optional_node_child ("MainStereoscopicPicture"); + if (main_stereoscopic_picture) { + _main_picture = make_shared(main_stereoscopic_picture); + } + + auto main_sound = asset_list->optional_node_child ("MainSound"); + if (main_sound) { + _main_sound = make_shared(main_sound); + } + + auto main_subtitle = asset_list->optional_node_child ("MainSubtitle"); + if (main_subtitle) { + _main_subtitle = make_shared(main_subtitle); + } + + auto main_markers = asset_list->optional_node_child ("MainMarkers"); + if (main_markers) { + _main_markers = make_shared(main_markers); + } + + /* XXX: it's not ideal that we silently tolerate Interop or SMPTE nodes here */ + /* XXX: not sure if Interop supports multiple closed captions */ + auto closed_captions = asset_list->node_children ("MainClosedCaption"); + if (closed_captions.empty()) { + closed_captions = asset_list->node_children ("ClosedCaption"); + } + for (auto i: closed_captions) { + _closed_captions.push_back (make_shared(i)); + } + + auto atmos = asset_list->optional_node_child ("AuxData"); + if (atmos) { + _atmos = make_shared(atmos); + } + + node->ignore_child ("AnnotationText"); + node->done (); +} + + +xmlpp::Element * +Reel::write_to_cpl (xmlpp::Element* node, Standard standard) const +{ + auto reel = node->add_child ("Reel"); + reel->add_child("Id")->add_child_text("urn:uuid:" + _id); + xmlpp::Element* asset_list = reel->add_child ("AssetList"); + + if (_main_markers) { + _main_markers->write_to_cpl (asset_list, standard); + } + + if (_main_picture && dynamic_pointer_cast (_main_picture)) { + /* Mono pictures come before other stuff... */ + _main_picture->write_to_cpl (asset_list, standard); } if (_main_sound) { - _main_sound->write_to_cpl (asset_list); + _main_sound->write_to_cpl (asset_list, standard); } if (_main_subtitle) { - _main_subtitle->write_to_cpl (asset_list); + _main_subtitle->write_to_cpl (asset_list, standard); + } + + for (auto i: _closed_captions) { + i->write_to_cpl (asset_list, standard); } + + if (_main_picture && dynamic_pointer_cast (_main_picture)) { + /* ... but stereo pictures must come after */ + _main_picture->write_to_cpl (asset_list, standard); + } + + if (_atmos) { + _atmos->write_to_cpl (asset_list, standard); + } + + return asset_list; } - + + bool -Reel::equals (boost::shared_ptr other, EqualityOptions opt, list& notes) const +Reel::equals (std::shared_ptr other, EqualityOptions opt, NoteHandler note) const { if ((_main_picture && !other->_main_picture) || (!_main_picture && other->_main_picture)) { - notes.push_back ("reel has different assets"); + note (NoteType::ERROR, "Reel: picture assets differ"); return false; } - - if (_main_picture && !_main_picture->equals (other->_main_picture, opt, notes)) { + + if (_main_picture && !_main_picture->equals (other->_main_picture, opt, note)) { return false; } if ((_main_sound && !other->_main_sound) || (!_main_sound && other->_main_sound)) { - notes.push_back ("reel has different assets"); + note (NoteType::ERROR, "Reel: sound assets differ"); return false; } - - if (_main_sound && !_main_sound->equals (other->_main_sound, opt, notes)) { + + if (_main_sound && !_main_sound->equals (other->_main_sound, opt, note)) { return false; } if ((_main_subtitle && !other->_main_subtitle) || (!_main_subtitle && other->_main_subtitle)) { - notes.push_back ("reel has different assets"); + note (NoteType::ERROR, "Reel: subtitle assets differ"); return false; } - - if (_main_subtitle && !_main_subtitle->equals (other->_main_subtitle, opt, notes)) { + + if (_main_subtitle && !_main_subtitle->equals (other->_main_subtitle, opt, note)) { + return false; + } + + if ((_main_markers && !other->_main_markers) || (!_main_markers && other->_main_markers)) { + note (NoteType::ERROR, "Reel: one has markers and the other does not"); + return false; + } + + if (_main_markers && !_main_markers->equals(other->_main_markers, opt, note)) { + note (NoteType::ERROR, "Reel: marker assets differ"); + return false; + } + + if (_closed_captions.size() != other->_closed_captions.size()) { + return false; + } + + auto i = _closed_captions.begin(); + auto j = other->_closed_captions.begin(); + while (i != _closed_captions.end()) { + if (!(*i)->equals(*j, opt, note)) { + return false; + } + ++i; + ++j; + } + + if ((_atmos && !other->_atmos) || (!_atmos && other->_atmos)) { + note (NoteType::ERROR, "Reel: atmos assets differ"); + return false; + } + + if (_atmos && !_atmos->equals (other->_atmos, opt, note)) { return false; } return true; } + +bool +Reel::any_encrypted () const +{ + auto ecc = false; + for (auto i: _closed_captions) { + if (i->encrypted()) { + ecc = true; + } + } + + return ( + (_main_picture && _main_picture->encrypted()) || + (_main_sound && _main_sound->encrypted()) || + (_main_subtitle && _main_subtitle->encrypted()) || + ecc || + (_atmos && _atmos->encrypted()) + ); +} + + +bool +Reel::all_encrypted () const +{ + auto ecc = true; + for (auto i: _closed_captions) { + if (!i->encrypted()) { + ecc = false; + } + } + + return ( + (!_main_picture || _main_picture->encrypted()) && + (!_main_sound || _main_sound->encrypted()) && + (!_main_subtitle || _main_subtitle->encrypted()) && + ecc && + (!_atmos || _atmos->encrypted()) + ); +} + + +void +Reel::add (DecryptedKDM const & kdm) +{ + auto keys = kdm.keys (); + + for (auto const& i: keys) { + if (_main_picture && i.id() == _main_picture->key_id()) { + _main_picture->asset()->set_key (i.key()); + } + if (_main_sound && i.id() == _main_sound->key_id()) { + _main_sound->asset()->set_key (i.key()); + } + if (_main_subtitle && i.id() == _main_subtitle->key_id()) { + shared_ptr s = dynamic_pointer_cast (_main_subtitle->asset()); + if (s) { + s->set_key (i.key()); + } + } + for (auto j: _closed_captions) { + if (i.id() == j->key_id()) { + auto s = dynamic_pointer_cast (j->asset()); + if (s) { + s->set_key (i.key()); + } + } + } + if (_atmos && i.id() == _atmos->key_id()) { + _atmos->asset()->set_key (i.key()); + } + } +} + + +void +Reel::add (shared_ptr asset) +{ + auto p = dynamic_pointer_cast (asset); + auto so = dynamic_pointer_cast (asset); + auto su = dynamic_pointer_cast (asset); + auto m = dynamic_pointer_cast (asset); + auto c = dynamic_pointer_cast (asset); + auto a = dynamic_pointer_cast (asset); + if (p) { + _main_picture = p; + } else if (so) { + _main_sound = so; + } else if (su) { + _main_subtitle = su; + } else if (m) { + _main_markers = m; + } else if (c) { + _closed_captions.push_back (c); + } else if (a) { + _atmos = a; + } +} + + +vector> +Reel::assets () const +{ + vector> a; + if (_main_picture) { + a.push_back (_main_picture); + } + if (_main_sound) { + a.push_back (_main_sound); + } + if (_main_subtitle) { + a.push_back (_main_subtitle); + } + std::copy (_closed_captions.begin(), _closed_captions.end(), back_inserter(a)); + if (_atmos) { + a.push_back (_atmos); + } + return a; +} + + +void +Reel::resolve_refs (vector> assets) +{ + if (_main_picture) { + _main_picture->asset_ref().resolve(assets); + } + + if (_main_sound) { + _main_sound->asset_ref().resolve(assets); + } + + if (_main_subtitle) { + _main_subtitle->asset_ref().resolve(assets); + + /* Interop subtitle handling is all special cases */ + if (_main_subtitle->asset_ref().resolved()) { + auto iop = dynamic_pointer_cast (_main_subtitle->asset_ref().asset()); + if (iop) { + iop->resolve_fonts (assets); + } + } + } + + for (auto i: _closed_captions) { + i->asset_ref().resolve(assets); + + /* Interop subtitle handling is all special cases */ + if (i->asset_ref().resolved()) { + auto iop = dynamic_pointer_cast (i->asset_ref().asset()); + if (iop) { + iop->resolve_fonts (assets); + } + } + } + + if (_atmos) { + _atmos->asset_ref().resolve (assets); + } +} + + +int64_t +Reel::duration () const +{ + if (_main_picture) { + return _main_picture->actual_duration(); + } + + int64_t d = INT64_MAX; + + if (_main_sound) { + d = min (d, _main_sound->actual_duration()); + } + if (_main_subtitle) { + d = min (d, _main_subtitle->actual_duration()); + } + if (_main_markers) { + d = min (d, _main_markers->actual_duration()); + } + for (auto i: _closed_captions) { + d = min (d, i->actual_duration()); + } + if (_atmos) { + d = min (d, _atmos->actual_duration()); + } + + DCP_ASSERT (d < INT64_MAX); + + return d; +}