Replace hack with use of generic_string from boost::filesystem.

[libdcp.git] / src / mxf.cc

diff --git a/src/mxf.cc b/src/mxf.cc
index f4d4a49090da6e6558ba0e60e29a195f86d3f131..260e270efc6df6d2dea8895bcf92e9ea43cdd899 100644 (file)
--- a/src/mxf.cc
+++ b/src/mxf.cc
@@ -29,44 +29,33 @@
 #include "util.h"
 #include "metadata.h"
 #include "exceptions.h"
+#include "dcp_assert.h"
 #include "compose.hpp"
 #include <libxml++/nodes/element.h>
 #include <boost/filesystem.hpp>
 #include <iostream>
 
 using std::string;
+using std::cout;
 using std::list;
 using std::pair;
 using boost::shared_ptr;
 using boost::dynamic_pointer_cast;
 using namespace dcp;
 
-MXF::MXF (Fraction edit_rate)
-       : _edit_rate (edit_rate)
-       , _intrinsic_duration (0)
-       , _encryption_context (0)
-       , _decryption_context (0)
+MXF::MXF ()
+       : _decryption_context (0)
 {
-       /* _intrinsic_duration must be set up up by a subclass */
-}
 
-MXF::MXF (boost::filesystem::path file)
-       : Content (file)
-       , _intrinsic_duration (0)
-       , _encryption_context (0)
-       , _decryption_context (0)
-{
-       /* _edit_rate and _intrinsic_duration must be set up up by a subclass */
 }
 
 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, Standard standard) const
 {
        writer_info->ProductVersion = _metadata.product_version;
        writer_info->CompanyName = _metadata.company_name;
@@ -78,52 +67,21 @@ MXF::fill_writer_info (ASDCP::WriterInfo* writer_info, Standard standard)
                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) {
+       writer_info->UsesHMAC = true;
+
+       if (_key_id) {
                Kumu::GenRandomUUID (writer_info->ContextID);
                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<const Asset> other, EqualityOptions opt, boost::function<void (NoteType, string)> note) const
-{
-       if (!Content::equals (other, opt, note)) {
-               return false;
-       }
-       
-       shared_ptr<const MXF> other_mxf = dynamic_pointer_cast<const MXF> (other);
-       if (!other_mxf) {
-               note (DCP_ERROR, "comparing an MXF asset with a non-MXF asset");
-               return false;
-       }
-       
-       if (_edit_rate != other_mxf->_edit_rate) {
-               note (DCP_ERROR, "content edit rates differ");
-               return false;
-       }
-       
-       if (_intrinsic_duration != other_mxf->_intrinsic_duration) {
-               note (DCP_ERROR, "asset intrinsic durations differ");
-               return false;
-       }
-
-       if (_file != other_mxf->file ()) {
-               note (DCP_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).
@@ -134,46 +92,29 @@ 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";
-       default:
-               assert (false);
+       if (info.EncryptedEssence) {
+               Kumu::bin2UUIDhex (info.CryptographicKeyID, ASDCP::UUIDlen, buffer, sizeof (buffer));
+               _key_id = buffer;
        }
+
+       _metadata.read (info);
+
+       Kumu::bin2UUIDhex (info.AssetUUID, ASDCP::UUIDlen, buffer, sizeof (buffer));
+       return buffer;
 }