Commit for release to 1.5.29.

[asdcplib.git] / src / KLV.h

diff --git a/src/KLV.h b/src/KLV.h
index 587bbe8315a79b3c465ddd8964b82a5d985e6535..68d5a3cf7b5c36a98e9c427b7f3f37f1927f6711 100755 (executable)
--- a/src/KLV.h
+++ b/src/KLV.h
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2005, John Hurst
+Copyright (c) 2005-2009, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -24,13 +24,20 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
-
+/*! \file    KLV.h
+  \version $Id$
+  \brief   KLV objects
+*/
 
 #ifndef _KLV_H_
 #define _KLV_H_
 
-#include <FileIO.h>
-#include <MemIO.h>
+#include <KM_fileio.h>
+#include <KM_memio.h>
+#include "AS_DCP.h"
+#include "MDD.h"
+#include <map>
+
 
 namespace ASDCP
 {
@@ -39,9 +46,35 @@ namespace ASDCP
   const ui32_t SMPTE_UL_LENGTH = 16;
   const ui32_t SMPTE_UMID_LENGTH = 32;
   const byte_t SMPTE_UL_START[4] = { 0x06, 0x0e, 0x2b, 0x34 };
+
+#ifndef MAX_KLV_PACKET_LENGTH
   const ui32_t MAX_KLV_PACKET_LENGTH = 1024*1024*64;
+#endif
 
   const ui32_t IdentBufferLen = 128;
+  const ui32_t IntBufferLen = 64;
+
+inline const char* i64sz(i64_t i, char* buf)
+{ 
+  assert(buf);
+#ifdef WIN32
+  snprintf(buf, IntBufferLen, "%I64d", i);
+#else
+  snprintf(buf, IntBufferLen, "%lld", i);
+#endif
+  return buf;
+}
+
+inline const char* ui64sz(ui64_t i, char* buf)
+{ 
+  assert(buf);
+#ifdef WIN32
+  snprintf(buf, IntBufferLen, "%I64u", i);
+#else
+  snprintf(buf, IntBufferLen, "%llu", i);
+#endif
+  return buf;
+}
 
   struct TagValue
   {
@@ -61,30 +94,37 @@ namespace ASDCP
     }
   };
 
-  //
-  class IArchive
+  using Kumu::UUID;
+
+  // Universal Label
+  class UL : public Kumu::Identifier<SMPTE_UL_LENGTH>
     {
     public:
-      virtual ~IArchive() {}
-      virtual Result_t ReadFrom(ASDCP::MemIOReader& Reader) = 0;
-      virtual Result_t WriteTo(ASDCP::MemIOWriter& Writer) = 0;
-    };
-} // namespace ASDCP
+      UL() {}
+      UL(const UL& rhs) : Kumu::Identifier<SMPTE_UL_LENGTH>(rhs) {}
+      UL(const byte_t* value) : Kumu::Identifier<SMPTE_UL_LENGTH>(value) {}
+      virtual ~UL() {}
 
-#include "Identifier.h"
+      const char* EncodeString(char* str_buf, ui32_t buf_len) const;
+    };
 
-namespace ASDCP
-{
-  //
-  class IPrimerLookup
+  // UMID
+  class UMID : public Kumu::Identifier<SMPTE_UMID_LENGTH>
     {
     public:
-      virtual ~IPrimerLookup() {}
-      virtual void     ClearTagList() = 0;
-      virtual Result_t InsertTag(const ASDCP::UL& Key, ASDCP::TagValue& Tag) = 0;
-      virtual Result_t TagForKey(const ASDCP::UL& Key, ASDCP::TagValue& Tag) = 0;
+      UMID() {}
+      UMID(const UMID& rhs) : Kumu::Identifier<SMPTE_UMID_LENGTH>(rhs) {}
+      UMID(const byte_t* value) : Kumu::Identifier<SMPTE_UMID_LENGTH>(value) {}
+      virtual ~UMID() {}
+
+      void MakeUMID(int Type);
+      void MakeUMID(int Type, const UUID& ID);
+      const char* EncodeString(char* str_buf, ui32_t buf_len) const;
     };
 
+  const byte_t nil_UMID[SMPTE_UMID_LENGTH] = {0};
+  const UMID NilUMID(nil_UMID);
+
   //
   struct MDDEntry
   {
@@ -92,11 +132,55 @@ namespace ASDCP
     TagValue      tag;
     bool          optional;
     const char*   name;
-    const char*   detail;
   };
 
+  const MDDEntry& MXFInterop_OPAtom_Entry();
+  const MDDEntry& SMPTE_390_OPAtom_Entry();
+
   //
-  const MDDEntry* GetMDDEntry(const byte_t*);
+  class Dictionary
+    {
+      std::map<ASDCP::UL, ui32_t> m_md_lookup;
+      std::map<ui32_t, ASDCP::UL> m_md_rev_lookup;
+      MDDEntry m_MDD_Table[(ui32_t)ASDCP::MDD_Max];
+
+      ASDCP_NO_COPY_CONSTRUCT(Dictionary);
+
+    public:
+      Dictionary();
+      ~Dictionary();
+
+      bool operator==(const Dictionary& rhs) const { return this == &rhs; }
+
+      void Init();
+      bool AddEntry(const MDDEntry& Entry, ui32_t index);
+      bool DeleteEntry(ui32_t index);
+
+      const MDDEntry* FindUL(const byte_t*) const;
+      const MDDEntry& Type(MDD_t type_id) const;
+
+      inline const byte_t* ul(MDD_t type_id) const {
+       return Type(type_id).ul;
+      }
+
+      void Dump(FILE* = 0) const;
+    };
+
+
+  const Dictionary& DefaultSMPTEDict();
+  const Dictionary& DefaultInteropDict();
+  const Dictionary& DefaultCompositeDict();
+
+
+  //
+  class IPrimerLookup
+    {
+    public:
+      virtual ~IPrimerLookup() {}
+      virtual void     ClearTagList() = 0;
+      virtual Result_t InsertTag(const MDDEntry& Entry, ASDCP::TagValue& Tag) = 0;
+      virtual Result_t TagForKey(const ASDCP::UL& Key, ASDCP::TagValue& Tag) = 0;
+    };
 
   //
   class KLVPacket
@@ -119,9 +203,9 @@ namespace ASDCP
 
       virtual bool     HasUL(const byte_t*);
       virtual Result_t InitFromBuffer(const byte_t*, ui32_t);
-      virtual Result_t InitFromBuffer(const byte_t*, ui32_t, const byte_t* label);
-      virtual Result_t WriteKLToBuffer(ASDCP::FrameBuffer&, const byte_t* label, ui32_t length);
-      virtual void     Dump(FILE*, bool);
+      virtual Result_t InitFromBuffer(const byte_t*, ui32_t, const UL& label);
+      virtual Result_t WriteKLToBuffer(ASDCP::FrameBuffer&, const UL& label, ui32_t length);
+      virtual void     Dump(FILE*, const Dictionary& Dict, bool show_value);
     };
 
   //
@@ -136,9 +220,9 @@ namespace ASDCP
       KLVFilePacket() {}
       virtual ~KLVFilePacket() {}
 
-      virtual Result_t InitFromFile(const FileReader&);
-      virtual Result_t InitFromFile(const FileReader&, const byte_t* label);
-      virtual Result_t WriteKLToFile(FileWriter& Writer, const byte_t* label, ui32_t length);
+      virtual Result_t InitFromFile(const Kumu::FileReader&);
+      virtual Result_t InitFromFile(const Kumu::FileReader&, const UL& label);
+      virtual Result_t WriteKLToFile(Kumu::FileWriter& Writer, const UL& label, ui32_t length);
     };
 
 } // namespace ASDCP