X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Fmxf.cc;h=1154b80df6fedad1001a5d704dbe89d168a2f976;hb=dd672d926e3b88cbe42b0778fda397d9e858b592;hp=dd4d2efcbb1b87c57636674c186650a82bd38f12;hpb=2f0e6ee9d883abbbc31aca0d1cc80e89eb9b0af2;p=libdcp.git diff --git a/src/mxf.cc b/src/mxf.cc index dd4d2efc..1154b80d 100644 --- a/src/mxf.cc +++ b/src/mxf.cc @@ -1,167 +1,148 @@ /* - Copyright (C) 2012-2014 Carl Hetherington + Copyright (C) 2012-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/asset.cc - * @brief Parent class for assets of DCPs made up of MXF files. + +/** @file src/mxf.cc + * @brief MXF class */ + #include "raw_convert.h" -#include "AS_DCP.h" -#include "KM_prng.h" -#include "KM_util.h" #include "mxf.h" #include "util.h" #include "metadata.h" #include "exceptions.h" +#include "dcp_assert.h" #include "compose.hpp" +#include +#include +#include #include #include #include + using std::string; +using std::cout; using std::list; using std::pair; -using boost::shared_ptr; -using boost::dynamic_pointer_cast; +using std::shared_ptr; +using std::dynamic_pointer_cast; using namespace dcp; -MXF::MXF (Fraction edit_rate) - : Content (edit_rate) - , _encryption_context (0) - , _decryption_context (0) -{ +MXF::MXF () + : _context_id (make_uuid ()) +{ + /* Subclasses can create MXFs with unspecified _standard but are expected to fill + _standard in once the MXF is read. + */ } -MXF::MXF (boost::filesystem::path file) - : Content (file) - , _encryption_context (0) - , _decryption_context (0) + +MXF::MXF (Standard standard) + : _context_id (make_uuid ()) + , _standard (standard) { } -MXF::~MXF () -{ - delete _encryption_context; - delete _decryption_context; -} void -MXF::fill_writer_info (ASDCP::WriterInfo* writer_info, Standard standard) +MXF::fill_writer_info (ASDCP::WriterInfo* writer_info, string id) const { writer_info->ProductVersion = _metadata.product_version; writer_info->CompanyName = _metadata.company_name; - writer_info->ProductName = _metadata.product_name.c_str(); + writer_info->ProductName = _metadata.product_name; - if (standard == INTEROP) { + DCP_ASSERT (_standard); + if (_standard == Standard::INTEROP) { writer_info->LabelSetType = ASDCP::LS_MXF_INTEROP; } else { writer_info->LabelSetType = ASDCP::LS_MXF_SMPTE; } unsigned int c; - Kumu::hex2bin (_id.c_str(), writer_info->AssetUUID, Kumu::UUID_Length, &c); - assert (c == Kumu::UUID_Length); + Kumu::hex2bin (id.c_str(), writer_info->AssetUUID, Kumu::UUID_Length, &c); + DCP_ASSERT (c == Kumu::UUID_Length); + + writer_info->UsesHMAC = true; - if (_key) { - Kumu::GenRandomUUID (writer_info->ContextID); + if (_key_id) { + Kumu::hex2bin (_context_id.c_str(), writer_info->ContextID, Kumu::UUID_Length, &c); writer_info->EncryptedEssence = true; unsigned int c; - Kumu::hex2bin (_key_id.c_str(), writer_info->CryptographicKeyID, Kumu::UUID_Length, &c); - assert (c == Kumu::UUID_Length); + Kumu::hex2bin (_key_id.get().c_str(), writer_info->CryptographicKeyID, Kumu::UUID_Length, &c); + DCP_ASSERT (c == Kumu::UUID_Length); } } -bool -MXF::equals (shared_ptr other, EqualityOptions opt, boost::function note) const -{ - if (!Content::equals (other, opt, note)) { - return false; - } - - shared_ptr other_mxf = dynamic_pointer_cast (other); - if (!other_mxf) { - note (ERROR, "comparing an MXF asset with a non-MXF asset"); - return false; - } - - if (_file != other_mxf->file ()) { - note (ERROR, "MXF names differ"); - if (!opt.mxf_names_can_differ) { - return false; - } - } - - return true; -} -/** Set the (private) key that will be used to encrypt or decrypt this MXF's content. - * This is the top-secret key that is distributed (itself encrypted) to cinemas - * via Key Delivery Messages (KDMs). - * @param key Key to use. - */ void MXF::set_key (Key key) { _key = key; - if (_key_id.empty ()) { + if (!_key_id) { /* No key ID so far; we now need one */ _key_id = make_uuid (); } - - _decryption_context = new ASDCP::AESDecContext; - if (ASDCP_FAILURE (_decryption_context->InitKey (_key->value ()))) { - throw MiscError ("could not set up decryption context"); - } - - _encryption_context = new ASDCP::AESEncContext; - if (ASDCP_FAILURE (_encryption_context->InitKey (_key->value ()))) { - throw MiscError ("could not set up encryption context"); - } - - uint8_t cbc_buffer[ASDCP::CBC_BLOCK_SIZE]; - - Kumu::FortunaRNG rng; - if (ASDCP_FAILURE (_encryption_context->SetIVec (rng.FillRandom (cbc_buffer, ASDCP::CBC_BLOCK_SIZE)))) { - throw MiscError ("could not set up CBC initialization vector"); - } } -void + +string MXF::read_writer_info (ASDCP::WriterInfo const & info) { char buffer[64]; - Kumu::bin2UUIDhex (info.AssetUUID, ASDCP::UUIDlen, buffer, sizeof (buffer)); - _id = buffer; -} -string -MXF::pkl_type (Standard standard) const -{ - switch (standard) { - case INTEROP: - return String::compose ("application/x-smpte-mxf;asdcpKind=%1", asdcp_kind ()); - case SMPTE: - return "application/mxf"; + if (info.EncryptedEssence) { + Kumu::bin2UUIDhex (info.CryptographicKeyID, ASDCP::UUIDlen, buffer, sizeof (buffer)); + _key_id = buffer; + } + + switch (info.LabelSetType) { + case ASDCP::LS_MXF_INTEROP: + _standard = Standard::INTEROP; + break; + case ASDCP::LS_MXF_SMPTE: + _standard = Standard::SMPTE; + break; default: - assert (false); + throw ReadError ("Unrecognised label set type in MXF"); } + + _metadata.read (info); + + Kumu::bin2UUIDhex (info.AssetUUID, ASDCP::UUIDlen, buffer, sizeof (buffer)); + return buffer; }