X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Fmxf.cc;h=512da8441a77afcfe14779c92f2ec48b783bb628;hb=62f9fadc0424dfab6debcc342a210b33c5e189e6;hp=200bc843b9d207c99078f368185734def45c9490;hpb=00e9647a9ede540f2d567c19025278c25a87c830;p=libdcp.git diff --git a/src/mxf.cc b/src/mxf.cc index 200bc843..512da844 100644 --- a/src/mxf.cc +++ b/src/mxf.cc @@ -1,117 +1,104 @@ /* Copyright (C) 2012-2014 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. */ -#include "AS_DCP.h" -#include "KM_prng.h" -#include "KM_util.h" +#include "raw_convert.h" #include "mxf.h" #include "util.h" #include "metadata.h" #include "exceptions.h" -#include "kdm.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::lexical_cast; using boost::dynamic_pointer_cast; using namespace dcp; -MXF::MXF (Fraction edit_rate) - : Content (edit_rate) - , _progress (0) - , _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) - , _progress (0) - , _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 == 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); - if (_key) { - Kumu::GenRandomUUID (writer_info->ContextID); + writer_info->UsesHMAC = true; + + 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); - } -} - -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; + Kumu::hex2bin (_key_id.get().c_str(), writer_info->CryptographicKeyID, Kumu::UUID_Length, &c); + DCP_ASSERT (c == Kumu::UUID_Length); } - - 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. @@ -124,33 +111,35 @@ 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, 16, buffer, 64); - _id = buffer; + + if (info.EncryptedEssence) { + Kumu::bin2UUIDhex (info.CryptographicKeyID, ASDCP::UUIDlen, buffer, sizeof (buffer)); + _key_id = buffer; + } + + switch (info.LabelSetType) { + case ASDCP::LS_MXF_INTEROP: + _standard = INTEROP; + break; + case ASDCP::LS_MXF_SMPTE: + _standard = SMPTE; + break; + default: + throw ReadError ("Unrecognised label set type in MXF"); + } + + _metadata.read (info); + + Kumu::bin2UUIDhex (info.AssetUUID, ASDCP::UUIDlen, buffer, sizeof (buffer)); + return buffer; }