projects / asdcplib.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
FIPS 186-2 fixes
[asdcplib.git] / src / MXF.cpp
diff --git a/src/MXF.cpp b/src/MXF.cpp
index bf8b0491774947cb0dade00854e72462a4d924ac..952de7e7e3360fd1a54e249fadd224e923e0a84e 100755 (executable)
--- a/src/MXF.cpp
+++ b/src/MXF.cpp
@@ -113,7 +113,8 @@ ASDCP::MXF::RIP::GetPairBySID(ui32_t SID, Pair& outPair) const
 ASDCP::Result_t
 ASDCP::MXF::RIP::InitFromFile(const Kumu::FileReader& Reader)
 {
-  Result_t result = KLVFilePacket::InitFromFile(Reader, m_Dict.ul(MDD_RandomIndexMetadata));
+  assert(m_Dict);
+  Result_t result = KLVFilePacket::InitFromFile(Reader, m_Dict->ul(MDD_RandomIndexMetadata));
 
   if ( ASDCP_SUCCESS(result) )
     {
@@ -131,12 +132,13 @@ ASDCP::MXF::RIP::InitFromFile(const Kumu::FileReader& Reader)
 ASDCP::Result_t
 ASDCP::MXF::RIP::WriteToFile(Kumu::FileWriter& Writer)
 {
+  assert(m_Dict);
   ASDCP::FrameBuffer Buffer;
   ui32_t RIPSize = ( PairArray.size() * (sizeof(ui32_t) + sizeof(ui64_t)) ) + 4;
   Result_t result = Buffer.Capacity(RIPSize);
 
   if ( ASDCP_SUCCESS(result) )
-    result = WriteKLToFile(Writer, m_Dict.ul(MDD_RandomIndexMetadata), RIPSize);
+    result = WriteKLToFile(Writer, m_Dict->ul(MDD_RandomIndexMetadata), RIPSize);
 
   if ( ASDCP_SUCCESS(result) )
     {
@@ -164,7 +166,7 @@ ASDCP::MXF::RIP::Dump(FILE* stream)
   if ( stream == 0 )
     stream = stderr;
 
-  KLVFilePacket::Dump(stream, m_Dict, false);
+  KLVFilePacket::Dump(stream, *m_Dict, false);
   PairArray.Dump(stream, false);
 }
 
@@ -251,7 +253,7 @@ public:
 //
 
 
-ASDCP::MXF::Partition::Partition(const Dictionary& d) :
+ASDCP::MXF::Partition::Partition(const Dictionary*& d) :
   m_Dict(d),
   MajorVersion(1), MinorVersion(2),
   KAGSize(1), ThisPartition(0), PreviousPartition(0),
@@ -384,7 +386,7 @@ ASDCP::MXF::Partition::Dump(FILE* stream)
   if ( stream == 0 )
     stream = stderr;
 
-  KLVFilePacket::Dump(stream, m_Dict, false);
+  KLVFilePacket::Dump(stream, *m_Dict, false);
   fprintf(stream, "  MajorVersion       = %hu\n", MajorVersion);
   fprintf(stream, "  MinorVersion       = %hu\n", MinorVersion);
   fprintf(stream, "  KAGSize            = %u\n",  KAGSize);
@@ -418,7 +420,7 @@ public:
 
 
 //
-ASDCP::MXF::Primer::Primer(const Dictionary& d) : m_LocalTag(0xff), m_Dict(d) {}
+ASDCP::MXF::Primer::Primer(const Dictionary*& d) : m_LocalTag(0xff), m_Dict(d) {}
 
 //
 ASDCP::MXF::Primer::~Primer() {}
@@ -435,7 +437,8 @@ ASDCP::MXF::Primer::ClearTagList()
 ASDCP::Result_t
 ASDCP::MXF::Primer::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  Result_t result = KLVPacket::InitFromBuffer(p, l, m_Dict.ul(MDD_Primer));
+  assert(m_Dict);
+  Result_t result = KLVPacket::InitFromBuffer(p, l, m_Dict->ul(MDD_Primer));
 
   if ( ASDCP_SUCCESS(result) )
     {
@@ -475,6 +478,7 @@ ASDCP::MXF::Primer::WriteToFile(Kumu::FileWriter& Writer)
 ASDCP::Result_t
 ASDCP::MXF::Primer::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
+  assert(m_Dict);
   ASDCP::FrameBuffer LocalTagBuffer;
   Kumu::MemIOWriter MemWRT(Buffer.Data() + kl_length, Buffer.Capacity() - kl_length);
   Result_t result = LocalTagEntryBatch.Archive(&MemWRT) ? RESULT_OK : RESULT_KLV_CODING;
@@ -482,7 +486,7 @@ ASDCP::MXF::Primer::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
   if ( ASDCP_SUCCESS(result) )
     {
       ui32_t packet_length = MemWRT.Length();
-      result = WriteKLToBuffer(Buffer, m_Dict.ul(MDD_Primer), packet_length);
+      result = WriteKLToBuffer(Buffer, m_Dict->ul(MDD_Primer), packet_length);
 
       if ( ASDCP_SUCCESS(result) )
        Buffer.Size(Buffer.Size() + packet_length);
@@ -551,12 +555,13 @@ ASDCP::MXF::Primer::TagForKey(const ASDCP::UL& Key, ASDCP::TagValue& Tag)
 void
 ASDCP::MXF::Primer::Dump(FILE* stream)
 {
+  assert(m_Dict);
   char identbuf[IdentBufferLen];
 
   if ( stream == 0 )
     stream = stderr;
 
-  KLVPacket::Dump(stream, m_Dict, false);
+  KLVPacket::Dump(stream, *m_Dict, false);
   fprintf(stream, "Primer: %u %s\n",
          (ui32_t)LocalTagEntryBatch.size(),
          ( LocalTagEntryBatch.size() == 1 ? "entry" : "entries" ));
@@ -564,7 +569,7 @@ ASDCP::MXF::Primer::Dump(FILE* stream)
   Batch<LocalTagEntry>::iterator i = LocalTagEntryBatch.begin();
   for ( ; i != LocalTagEntryBatch.end(); i++ )
     {
-      const MDDEntry* Entry = m_Dict.FindUL((*i).UL.Value());
+      const MDDEntry* Entry = m_Dict->FindUL((*i).UL.Value());
       fprintf(stream, "  %s %s\n", (*i).EncodeString(identbuf, IdentBufferLen), (Entry ? Entry->name : "Unknown"));
     }
 }
@@ -611,7 +616,8 @@ ASDCP::MXF::Preface::WriteToTLVSet(TLVWriter& TLVSet)
 ASDCP::Result_t
 ASDCP::MXF::Preface::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_Preface);
+  assert(m_Dict);
+  m_Typeinfo = &(m_Dict->Type(MDD_Preface));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -619,7 +625,8 @@ ASDCP::MXF::Preface::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 ASDCP::MXF::Preface::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_Preface);
+  assert(m_Dict);
+  m_Typeinfo = &(m_Dict->Type(MDD_Preface));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -647,7 +654,7 @@ ASDCP::MXF::Preface::Dump(FILE* stream)
 //------------------------------------------------------------------------------------------
 //
 
-ASDCP::MXF::OPAtomHeader::OPAtomHeader(const Dictionary& d) : Partition(d), m_Dict(d), m_RIP(d), m_Primer(d), m_Preface(0), m_HasRIP(false) {}
+ASDCP::MXF::OPAtomHeader::OPAtomHeader(const Dictionary*& d) : Partition(d), m_Dict(d), m_RIP(d), m_Primer(d), m_Preface(0), m_HasRIP(false) {}
 ASDCP::MXF::OPAtomHeader::~OPAtomHeader() {}
 
 //
@@ -702,15 +709,27 @@ ASDCP::MXF::OPAtomHeader::InitFromFile(const Kumu::FileReader& Reader)
     return result;
 
   // is it really OP-Atom?
-  UL OPAtomUL(m_Dict.ul(MDD_OPAtom));
-  UL InteropOPAtomUL(m_Dict.ul(MDD_MXFInterop_OPAtom));
+  assert(m_Dict);
+  UL OPAtomUL(SMPTE_390_OPAtom_Entry().ul);
+  UL InteropOPAtomUL(MXFInterop_OPAtom_Entry().ul);
 
-  if ( ! ( OperationalPattern == OPAtomUL  || OperationalPattern == InteropOPAtomUL ) )
+  if ( OperationalPattern == OPAtomUL ) // SMPTE
+    {
+      if ( m_Dict == &DefaultCompositeDict() )
+       m_Dict = &DefaultSMPTEDict();
+    }
+  else if ( OperationalPattern == InteropOPAtomUL ) // Interop
+    {
+      if ( m_Dict == &DefaultCompositeDict() )
+       m_Dict = &DefaultInteropDict();
+    }
+  else
     {
       char strbuf[IdentBufferLen];
-      const MDDEntry* Entry = m_Dict.FindUL(OperationalPattern.Value());
+      const MDDEntry* Entry = m_Dict->FindUL(OperationalPattern.Value());
       if ( Entry == 0 )
-       DefaultLogSink().Warn("Operational pattern is not OP-Atom: %s\n", OperationalPattern.EncodeString(strbuf, IdentBufferLen));
+       DefaultLogSink().Warn("Operational pattern is not OP-Atom: %s\n",
+                             OperationalPattern.EncodeString(strbuf, IdentBufferLen));
       else
        DefaultLogSink().Warn("Operational pattern is not OP-Atom: %s\n", Entry->name);
     }
@@ -766,6 +785,7 @@ ASDCP::MXF::OPAtomHeader::InitFromPartitionBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 ASDCP::MXF::OPAtomHeader::InitFromBuffer(const byte_t* p, ui32_t l)
 {
+  assert(m_Dict);
   Result_t result = RESULT_OK;
   const byte_t* end_p = p + l;
 
@@ -783,11 +803,11 @@ ASDCP::MXF::OPAtomHeader::InitFromBuffer(const byte_t* p, ui32_t l)
 
       if ( ASDCP_SUCCESS(result) )
        {
-         if ( object->IsA(m_Dict.ul(MDD_KLVFill)) )
+         if ( object->IsA(m_Dict->ul(MDD_KLVFill)) )
            {
              delete object;
            }
-         else if ( object->IsA(m_Dict.ul(MDD_Primer)) )
+         else if ( object->IsA(m_Dict->ul(MDD_Primer)) ) // TODO: only one primer should be found
            {
              delete object;
              result = m_Primer.InitFromBuffer(redo_p, end_p - redo_p);
@@ -796,7 +816,7 @@ ASDCP::MXF::OPAtomHeader::InitFromBuffer(const byte_t* p, ui32_t l)
            {
              m_PacketList->AddPacket(object);
 
-             if ( object->IsA(m_Dict.ul(MDD_Preface)) && m_Preface == 0 )
+             if ( object->IsA(m_Dict->ul(MDD_Preface)) && m_Preface == 0 )
                m_Preface = (Preface*)object;
            }
        }
@@ -864,6 +884,7 @@ ASDCP::MXF::OPAtomHeader::GetSourcePackage()
 ASDCP::Result_t
 ASDCP::MXF::OPAtomHeader::WriteToFile(Kumu::FileWriter& Writer, ui32_t HeaderSize)
 {
+  assert(m_Dict);
   if ( m_Preface == 0 )
     return RESULT_STATE;
 
@@ -894,7 +915,7 @@ ASDCP::MXF::OPAtomHeader::WriteToFile(Kumu::FileWriter& Writer, ui32_t HeaderSiz
 
   if ( ASDCP_SUCCESS(result) )
     {
-      UL TmpUL(m_Dict.ul(MDD_ClosedCompleteHeader));
+      UL TmpUL(m_Dict->ul(MDD_ClosedCompleteHeader));
       result = Partition::WriteToFile(Writer, TmpUL);
     }
 
@@ -932,7 +953,7 @@ ASDCP::MXF::OPAtomHeader::WriteToFile(Kumu::FileWriter& Writer, ui32_t HeaderSiz
        }
 
       klv_fill_length -= kl_length;
-      result = WriteKLToFile(Writer, m_Dict.ul(MDD_KLVFill), klv_fill_length);
+      result = WriteKLToFile(Writer, m_Dict->ul(MDD_KLVFill), klv_fill_length);
 
       if ( ASDCP_SUCCESS(result) )
        result = NilBuf.Capacity(klv_fill_length);
@@ -970,7 +991,7 @@ ASDCP::MXF::OPAtomHeader::Dump(FILE* stream)
 //------------------------------------------------------------------------------------------
 //
 
-ASDCP::MXF::OPAtomIndexFooter::OPAtomIndexFooter(const Dictionary& d) :
+ASDCP::MXF::OPAtomIndexFooter::OPAtomIndexFooter(const Dictionary*& d) :
   Partition(d), m_Dict(d),
   m_CurrentSegment(0), m_BytesPerEditUnit(0), m_BodySID(0),
   m_ECOffset(0), m_Lookup(0)
@@ -1068,6 +1089,7 @@ ASDCP::MXF::OPAtomIndexFooter::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 ASDCP::MXF::OPAtomIndexFooter::WriteToFile(Kumu::FileWriter& Writer, ui64_t duration)
 {
+  assert(m_Dict);
   ASDCP::FrameBuffer FooterBuffer;
   ui32_t   footer_size = m_PacketList->m_List.size() * MaxIndexSegmentSize; // segment-count * max-segment-size
   Result_t result = FooterBuffer.Capacity(footer_size); 
@@ -1109,7 +1131,7 @@ ASDCP::MXF::OPAtomIndexFooter::WriteToFile(Kumu::FileWriter& Writer, ui64_t dura
   if ( ASDCP_SUCCESS(result) )
     {
       IndexByteCount = FooterBuffer.Size();
-      UL FooterUL(m_Dict.ul(MDD_CompleteFooter));
+      UL FooterUL(m_Dict->ul(MDD_CompleteFooter));
       result = Partition::WriteToFile(Writer, FooterUL);
     }
 
@@ -1313,7 +1335,7 @@ ASDCP::MXF::InterchangeObject::Dump(FILE* stream)
   char identbuf[IdentBufferLen];
 
   fputc('\n', stream);
-  KLVPacket::Dump(stream, m_Dict, false);
+  KLVPacket::Dump(stream, *m_Dict, false);
   fprintf(stream, "             InstanceUID = %s\n",  InstanceUID.EncodeHex(identbuf, IdentBufferLen));
   fprintf(stream, "           GenerationUID = %s\n",  GenerationUID.EncodeHex(identbuf, IdentBufferLen));
 }
@@ -1380,11 +1402,8 @@ ASDCP::MXF::SetObjectFactory(ASDCP::UL label, ASDCP::MXF::MXFObjectFactory_t fac
 
 //
 ASDCP::MXF::InterchangeObject*
-ASDCP::MXF::CreateObject(const Dictionary& Dict, const UL& label)
+ASDCP::MXF::CreateObject(const Dictionary*& Dict, const UL& label)
 {
-  if ( label == 0 )
-    return 0;
-
   if ( ! s_TypesInit )
     {
       Kumu::AutoMutex BlockLock(s_InitLock);
@@ -1396,7 +1415,7 @@ ASDCP::MXF::CreateObject(const Dictionary& Dict, const UL& label)
        }
     }
 
-  FLi_t i = s_FactoryList.find(label);
+  FLi_t i = s_FactoryList.find(label.Value());
 
   if ( i == s_FactoryList.end() )
     return new InterchangeObject(Dict);
Unnamed repository; edit this file 'description' to name the repository.