X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2FMXF.h;h=cda4408fa0f6aa3e421836fcd0aa8df55f74b4bd;hb=5584493c50cfa0541398527741253a0db8cdbf18;hp=6a9b14d47dca824db2cd5aa00242bcc614c30e15;hpb=4564a68b8a586b49715f39fb84271db61fc109b7;p=asdcplib.git

diff --git a/src/MXF.h b/src/MXF.h
index 6a9b14d..cda4408 100755
--- a/src/MXF.h
+++ b/src/MXF.h
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2005-2006, John Hurst
+Copyright (c) 2005-2013, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -33,6 +33,7 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define _MXF_H_
 
 #include "MXFTypes.h"
+#include <algorithm>
 
 namespace ASDCP
 {
@@ -40,14 +41,16 @@ namespace ASDCP
     {
       class InterchangeObject;
 
+      const ui32_t kl_length = ASDCP::SMPTE_UL_LENGTH + ASDCP::MXF_BER_LENGTH;
+
       //
-      typedef ASDCP::MXF::InterchangeObject* (*MXFObjectFactory_t)();
+      typedef ASDCP::MXF::InterchangeObject* (*MXFObjectFactory_t)(const Dictionary*&);
 
       //
       void SetObjectFactory(UL label, MXFObjectFactory_t factory);
 
       //
-      InterchangeObject* CreateObject(const byte_t* label);
+      InterchangeObject* CreateObject(const Dictionary*& Dict, const UL& label);
 
 
       // seek an open file handle to the start of the RIP KLV packet
@@ -57,6 +60,7 @@ namespace ASDCP
       class RIP : public ASDCP::KLVFilePacket
 	{
 	  ASDCP_NO_COPY_CONSTRUCT(RIP);
+	  RIP();
 
 	public:
 	  //
@@ -94,9 +98,10 @@ namespace ASDCP
 	      }
 	    };
 
+	  const Dictionary*& m_Dict;
 	  Array<Pair> PairArray;
 
-	  RIP() {}
+	RIP(const Dictionary*& d) : m_Dict(d) {}
 	  virtual ~RIP() {}
 	  virtual Result_t InitFromFile(const Kumu::FileReader& Reader);
 	  virtual Result_t WriteToFile(Kumu::FileWriter& Writer);
@@ -109,12 +114,27 @@ namespace ASDCP
       class Partition : public ASDCP::KLVFilePacket
 	{
 	  ASDCP_NO_COPY_CONSTRUCT(Partition);
+	  Partition();
 
 	protected:
-	  class h__PacketList;
-	  mem_ptr<h__PacketList> m_PacketList;
+	  class PacketList
+	  {
+	  public:
+	    std::list<InterchangeObject*> m_List;
+	    std::map<UUID, InterchangeObject*> m_Map;
+
+	    ~PacketList();
+	    void AddPacket(InterchangeObject* ThePacket); // takes ownership
+	    Result_t GetMDObjectByID(const UUID& ObjectID, InterchangeObject** Object);
+	    Result_t GetMDObjectByType(const byte_t* ObjectID, InterchangeObject** Object);
+	    Result_t GetMDObjectsByType(const byte_t* ObjectID, std::list<InterchangeObject*>& ObjectList);
+	  };
+
+	  mem_ptr<PacketList> m_PacketList;
 
 	public:
+	  const Dictionary*& m_Dict;
+
 	  ui16_t    MajorVersion;
 	  ui16_t    MinorVersion;
 	  ui32_t    KAGSize;
@@ -129,10 +149,11 @@ namespace ASDCP
 	  UL        OperationalPattern;
 	  Batch<UL> EssenceContainers;
 
-	  Partition();
+	  Partition(const Dictionary*&);
 	  virtual ~Partition();
-	  virtual void     AddChildObject(InterchangeObject*);
+	  virtual void     AddChildObject(InterchangeObject*); // takes ownership
 	  virtual Result_t InitFromFile(const Kumu::FileReader& Reader);
+	  virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 	  virtual Result_t WriteToFile(Kumu::FileWriter& Writer, UL& PartitionLabel);
 	  virtual ui32_t   ArchiveSize(); // returns the size of the archived structure
 	  virtual void     Dump(FILE* = 0);
@@ -146,6 +167,7 @@ namespace ASDCP
 	  mem_ptr<h__PrimerLookup> m_Lookup;
 	  ui8_t   m_LocalTag;
 	  ASDCP_NO_COPY_CONSTRUCT(Primer);
+	  Primer();
 
 	public:
 	  //
@@ -155,6 +177,9 @@ namespace ASDCP
 	      TagValue    Tag;
 	      ASDCP::UL   UL;
 
+	      LocalTagEntry() { Tag.a = Tag.b = 0; }
+	    LocalTagEntry(const TagValue& tag, ASDCP::UL& ul) : Tag(tag), UL(ul) {}
+
 	      inline const char* EncodeString(char* str_buf, ui32_t buf_len) const {
 		snprintf(str_buf, buf_len, "%02x %02x: ", Tag.a, Tag.b);
 		UL.EncodeString(str_buf + strlen(str_buf), buf_len - strlen(str_buf));
@@ -178,8 +203,9 @@ namespace ASDCP
 	    };
 
 	  Batch<LocalTagEntry> LocalTagEntryBatch;
+	  const Dictionary*& m_Dict;
 
-	  Primer();
+	  Primer(const Dictionary*&);
 	  virtual ~Primer();
 
 	  virtual void     ClearTagList();
@@ -196,16 +222,18 @@ namespace ASDCP
       //
       class InterchangeObject : public ASDCP::KLVPacket
 	{
-	protected:
-	  const MDDEntry* m_Typeinfo;
+	  InterchangeObject();
 
 	public:
+	  const Dictionary*& m_Dict;
 	  IPrimerLookup* m_Lookup;
 	  UUID           InstanceUID;
 	  UUID           GenerationUID;
 
-	  InterchangeObject() : m_Typeinfo(0), m_Lookup(0) {}
+	InterchangeObject(const Dictionary*& d) : m_Dict(d), m_Lookup(0) {}
 	  virtual ~InterchangeObject() {}
+
+	  virtual void Copy(const InterchangeObject& rhs);
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 	  virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 	  virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -215,14 +243,18 @@ namespace ASDCP
 	  virtual void     Dump(FILE* stream = 0);
 	};
 
+      //
+      typedef std::list<InterchangeObject*> InterchangeObject_list_t;
+
       //
       class Preface : public InterchangeObject
 	{
 	  ASDCP_NO_COPY_CONSTRUCT(Preface);
+	  Preface();
 
 	public:
-	  UUID         GenerationUID;
-	  Timestamp    LastModifiedDate;
+	  const Dictionary*& m_Dict;
+	  Kumu::Timestamp    LastModifiedDate;
 	  ui16_t       Version;
 	  ui32_t       ObjectModelVersion;
 	  UUID         PrimaryPackage;
@@ -232,8 +264,10 @@ namespace ASDCP
 	  Batch<UL>    EssenceContainers;
 	  Batch<UL>    DMSchemes;
 
-	  Preface() : Version(258), ObjectModelVersion(0) {}
+	  Preface(const Dictionary*& d);
 	  virtual ~Preface() {}
+
+	  virtual void Copy(const Preface& rhs);
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 	  virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 	  virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -258,6 +292,7 @@ namespace ASDCP
 	      ui32_t  ElementData;
 
 	      DeltaEntry() : PosTableIndex(-1), Slice(0), ElementData(0) {}
+	      DeltaEntry(i8_t pos, ui8_t slice, ui32_t data) : PosTableIndex(pos), Slice(slice), ElementData(data) {}
 	      inline bool HasValue() const { return true; }
 	      ui32_t      ArchiveLength() const { return sizeof(ui32_t) + 2; }
 	      bool        Unarchive(Kumu::MemIOReader* Reader);
@@ -279,7 +314,9 @@ namespace ASDCP
 	      //	      std::list<ui32_t>  SliceOffset;
 	      //	      Array<Rational>    PosTable;
 
-	      IndexEntry() : TemporalOffset(0), KeyFrameOffset(0), Flags(0), StreamOffset() {}
+	      IndexEntry() : TemporalOffset(0), KeyFrameOffset(0), Flags(0), StreamOffset(0) {}
+	      IndexEntry(i8_t t_ofst, i8_t k_ofst, ui8_t flags, ui64_t s_ofst) :
+	            TemporalOffset(t_ofst), KeyFrameOffset(k_ofst), Flags(flags), StreamOffset(s_ofst) {}
 	      inline bool HasValue() const { return true; }
 	      ui32_t      ArchiveLength() const { return sizeof(ui64_t) + 3; };
 	      bool        Unarchive(Kumu::MemIOReader* Reader);
@@ -287,6 +324,10 @@ namespace ASDCP
 	      const char* EncodeString(char* str_buf, ui32_t buf_len) const;
 	    };
 
+	  const Dictionary*& m_Dict;
+	  ui64_t  RtFileOffset; // not part of the MXF structure: used to manage runtime index access 
+	  ui64_t  RtEntryOffset;
+
 	  Rational    IndexEditRate;
 	  ui64_t      IndexStartPosition;
 	  ui64_t      IndexDuration;
@@ -298,8 +339,10 @@ namespace ASDCP
 	  Batch<DeltaEntry> DeltaEntryArray;
 	  Batch<IndexEntry> IndexEntryArray;
 
-	  IndexTableSegment();
+	  IndexTableSegment(const Dictionary*&);
 	  virtual ~IndexTableSegment();
+
+	  virtual void Copy(const IndexTableSegment& rhs);
 	  virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 	  virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 	  virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -313,20 +356,22 @@ namespace ASDCP
       class SourcePackage;
 
       //
-      class OPAtomHeader : public Partition
+      class OP1aHeader : public Partition
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(OPAtomHeader);
+	  Kumu::ByteString m_HeaderData;
+	  ASDCP_NO_COPY_CONSTRUCT(OP1aHeader);
+	  OP1aHeader();
 
 	public:
-	  ASDCP::MXF::RIP     m_RIP;
+	  const Dictionary*&  m_Dict;
 	  ASDCP::MXF::Primer  m_Primer;
 	  Preface*            m_Preface;
-	  ASDCP::FrameBuffer  m_Buffer;
-	  bool                m_HasRIP;
 
-	  OPAtomHeader();
-	  virtual ~OPAtomHeader();
+	  OP1aHeader(const Dictionary*&);
+	  virtual ~OP1aHeader();
 	  virtual Result_t InitFromFile(const Kumu::FileReader& Reader);
+	  virtual Result_t InitFromPartitionBuffer(const byte_t* p, ui32_t l);
+	  virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 	  virtual Result_t WriteToFile(Kumu::FileWriter& Writer, ui32_t HeaderLength = 16384);
 	  virtual void     Dump(FILE* = 0);
 	  virtual Result_t GetMDObjectByID(const UUID&, InterchangeObject** = 0);
@@ -339,29 +384,88 @@ namespace ASDCP
       //
       class OPAtomIndexFooter : public Partition
 	{
+	  Kumu::ByteString    m_FooterData;
 	  IndexTableSegment*  m_CurrentSegment;
-	  ASDCP::FrameBuffer  m_Buffer;
 	  ui32_t              m_BytesPerEditUnit;
 	  Rational            m_EditRate;
 	  ui32_t              m_BodySID;
+
 	  ASDCP_NO_COPY_CONSTRUCT(OPAtomIndexFooter);
+	  OPAtomIndexFooter();
 
 	public:
+	  const Dictionary*&   m_Dict;
 	  Kumu::fpos_t        m_ECOffset;
 	  IPrimerLookup*      m_Lookup;
 	 
-	  OPAtomIndexFooter();
+	  OPAtomIndexFooter(const Dictionary*&);
 	  virtual ~OPAtomIndexFooter();
 	  virtual Result_t InitFromFile(const Kumu::FileReader& Reader);
+	  virtual Result_t InitFromPartitionBuffer(const byte_t* p, ui32_t l);
+	  virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 	  virtual Result_t WriteToFile(Kumu::FileWriter& Writer, ui64_t duration);
 	  virtual void     Dump(FILE* = 0);
 
+	  virtual Result_t GetMDObjectByID(const UUID&, InterchangeObject** = 0);
+	  virtual Result_t GetMDObjectByType(const byte_t*, InterchangeObject** = 0);
+	  virtual Result_t GetMDObjectsByType(const byte_t* ObjectID, std::list<InterchangeObject*>& ObjectList);
+
 	  virtual Result_t Lookup(ui32_t frame_num, IndexTableSegment::IndexEntry&) const;
 	  virtual void     PushIndexEntry(const IndexTableSegment::IndexEntry&);
 	  virtual void     SetIndexParamsCBR(IPrimerLookup* lookup, ui32_t size, const Rational& Rate);
 	  virtual void     SetIndexParamsVBR(IPrimerLookup* lookup, const Rational& Rate, Kumu::fpos_t offset);
 	};
 
+      //---------------------------------------------------------------------------------
+      //
+
+      //
+      inline std::string to_lower(std::string str) {
+	std::transform(str.begin(), str.end(), str.begin(), ::tolower);
+	return str;
+      }
+
+      // ignore case when searching for audio labels
+      struct ci_comp
+      {
+	inline bool operator()(const std::string& a, const std::string& b) const {
+	  return to_lower(a) < to_lower(b);
+	}
+      };
+
+      typedef std::map<const std::string, const UL, ci_comp> mca_label_map_t;
+      bool decode_mca_string(const std::string& s, const mca_label_map_t& labels, const Dictionary& dict, const std::string& language, InterchangeObject_list_t&, ui32_t&);
+
+      //
+      class ASDCP_MCAConfigParser : public InterchangeObject_list_t
+	{
+	  KM_NO_COPY_CONSTRUCT(ASDCP_MCAConfigParser);
+	  ASDCP_MCAConfigParser();
+
+	protected:
+	  mca_label_map_t m_LabelMap;
+	  ui32_t m_ChannelCount;
+	  const Dictionary*& m_Dict;
+
+	  
+	public:
+	  ASDCP_MCAConfigParser(const Dictionary*&);
+	  bool DecodeString(const std::string& s, const std::string& language = "en");
+
+	  // Valid only after a successful call to DecodeString
+	  ui32_t ChannelCount() const;
+	};
+
+      //
+      class AS02_MCAConfigParser : public ASDCP_MCAConfigParser
+	{
+	  KM_NO_COPY_CONSTRUCT(AS02_MCAConfigParser);
+	  AS02_MCAConfigParser();
+	  
+	public:
+	  AS02_MCAConfigParser(const Dictionary*&);
+	};
+
     } // namespace MXF
 } // namespace ASDCP