oi

[asdcplib.git] / src / KLV.h

diff --git a/src/KLV.h b/src/KLV.h
index 9eb230b6d91c663285158ecfa7ae6c65a65d4cd6..1a5c298bdbc9baa33ad820390bb9fdb214832349 100755 (executable)
--- a/src/KLV.h
+++ b/src/KLV.h
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2005-2006, John Hurst
+Copyright (c) 2005-2009, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -32,9 +32,11 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #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
@@ -44,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
   {
@@ -66,21 +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 Unarchive(ASDCP::MemIOReader& Reader) = 0;
-      virtual bool     HasValue() const = 0;
-      virtual Result_t Archive(ASDCP::MemIOWriter& Writer) const = 0;
+      UL() {}
+      UL(const UL& rhs) : Kumu::Identifier<SMPTE_UL_LENGTH>(rhs) {}
+      UL(const byte_t* value) : Kumu::Identifier<SMPTE_UL_LENGTH>(value) {}
+      virtual ~UL() {}
+
+      const char* EncodeString(char* str_buf, ui32_t buf_len) const;
     };
-} // namespace ASDCP
 
-#include "Identifier.h"
+  // UMID
+  class UMID : public Kumu::Identifier<SMPTE_UMID_LENGTH>
+    {
+    public:
+      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);
 
-namespace ASDCP
-{
   //
   struct MDDEntry
   {
@@ -91,31 +135,46 @@ namespace ASDCP
   };
 
   //
-  class Dict
+  class Dictionary
     {
     public:
-      static const MDDEntry* FindUL(const byte_t*);
+#if 0
       static const MDDEntry* FindName(const char*);
       static const MDDEntry& Type(MDD_t type_id);
       static bool            Replace(const MDDEntry& Entry);
       static void            Restore(const byte_t* ul);
       static void            RestoreAll();
-
-      inline static const byte_t* ul(MDD_t type_id) {
-       return Type(type_id).ul;
-      }
+#endif
 
     private:
-      Dict* m_Dict;
-      ASDCP_NO_COPY_CONSTRUCT(Dict);
+      std::map<ASDCP::UL, ui32_t> m_md_lookup;
+      MDDEntry m_MDD_Table[ASDCP::MDD_Table_size];
+
+      ASDCP_NO_COPY_CONSTRUCT(Dictionary);
 
-    protected:
-      Dict();
 
     public:
-      ~Dict();
+      Dictionary();
+      ~Dictionary();
+
+      bool AddEntry(const MDDEntry& Entry, 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
     {
@@ -147,9 +206,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);
     };
 
   //
@@ -164,9 +223,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