code-generated metadata!

1 files changed, 574 insertions, 257 deletions

diff --git a/src/Metadata.cpp b/src/Metadata.cpp
index 1335803..b1a11c2 100755
--- a/src/Metadata.cpp
+++ b/src/Metadata.cpp
@@ -35,11 +35,29 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <hex_utils.h>
 
 
+
 //------------------------------------------------------------------------------------------
 //
 
 //
 ASDCP::Result_t
+ASDCP::MXF::Identification::InitFromTLVSet(TLVReader& TLVSet)
+{
+  Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ThisGenerationUID));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, CompanyName));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ProductName));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(Identification, ProductVersion));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, VersionString));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ProductUID));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ModificationDate));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(Identification, ToolkitVersion));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, Platform));
+  return result;
+}
+
+//
+ASDCP::Result_t
 ASDCP::MXF::Identification::InitFromBuffer(const byte_t* p, ui32_t l)
 {
   ASDCP_TEST_NULL(p);
@@ -49,22 +67,13 @@ ASDCP::MXF::Identification::InitFromBuffer(const byte_t* p, ui32_t l)
   if ( ASDCP_SUCCESS(result) )
     {
       TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
-
-      result = MemRDR.ReadObject(OBJ_READ_ARGS(InterchangeObject, InstanceUID));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(Identification, ThisGenerationUID));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(Identification, CompanyName));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(Identification, ProductName));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi16(OBJ_READ_ARGS(Identification, ProductVersion));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(Identification, VersionString));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(Identification, ProductUID));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(Identification, ModificationDate));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi16(OBJ_READ_ARGS(Identification, ToolkitVersion));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(Identification, Platform));
+      result = InitFromTLVSet(MemRDR);
     }
 
   return result;
 }
 
+
 //
 ASDCP::Result_t
 ASDCP::MXF::Identification::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
@@ -77,48 +86,47 @@ ASDCP::MXF::Identification::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 void
 ASDCP::MXF::Identification::Dump(FILE* stream)
 {
-  char identbuf[IdentBufferLen];
+//  char identbuf[IdentBufferLen];
 
   if ( stream == 0 )
     stream = stderr;
 
-  KLVPacket::Dump(stream, false);
-  fprintf(stream, "  InstanceUID        = %s\n",  InstanceUID.ToString(identbuf));
-  fprintf(stream, "  ThisGenerationUID  = %s\n",  ThisGenerationUID.ToString(identbuf));
-  fprintf(stream, "  CompanyName        = %s\n",  CompanyName.ToString(identbuf));
-  fprintf(stream, "  ProductName        = %s\n",  ProductName.ToString(identbuf));
-  fprintf(stream, "  ProductVersion     = %hu\n", ProductVersion);
-  fprintf(stream, "  VersionString      = %s\n",  VersionString.ToString(identbuf));
-  fprintf(stream, "  ProductUID         = %s\n",  ProductUID.ToString(identbuf));
-  fprintf(stream, "  ModificationDate   = %s\n",  ModificationDate.ToString(identbuf));
-  fprintf(stream, "  ToolkitVersion     = %hu\n", ToolkitVersion);
-  fprintf(stream, "  Platform           = %s\n",  Platform.ToString(identbuf));
-
+  InterchangeObject::Dump(stream);
   fputs("==========================================================================\n", stream);
 }
 
+
 //------------------------------------------------------------------------------------------
 //
 
 //
 ASDCP::Result_t
+ASDCP::MXF::ContentStorage::InitFromTLVSet(TLVReader& TLVSet)
+{
+  Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(ContentStorage, Packages));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(ContentStorage, EssenceContainerData));
+  return result;
+}
+
+//
+ASDCP::Result_t
 ASDCP::MXF::ContentStorage::InitFromBuffer(const byte_t* p, ui32_t l)
 {
+  ASDCP_TEST_NULL(p);
+
   Result_t result = KLVPacket::InitFromBuffer(p, l, s_MDD_Table[MDDindex_ContentStorage].ul);
 
   if ( ASDCP_SUCCESS(result) )
     {
       TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
-
-      result = MemRDR.ReadObject(OBJ_READ_ARGS(InterchangeObject, InstanceUID));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenerationInterchangeObject, GenerationUID));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(ContentStorage, Packages));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(ContentStorage, EssenceContainerData));
+      result = InitFromTLVSet(MemRDR);
     }
 
   return result;
 }
 
+
 //
 ASDCP::Result_t
 ASDCP::MXF::ContentStorage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
@@ -126,91 +134,67 @@ ASDCP::MXF::ContentStorage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
   return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_ContentStorage].ul, 0);
 }
 
+
 //
 void
 ASDCP::MXF::ContentStorage::Dump(FILE* stream)
 {
-  char identbuf[IdentBufferLen];
+//  char identbuf[IdentBufferLen];
 
   if ( stream == 0 )
     stream = stderr;
 
-  KLVPacket::Dump(stream, false);
-  fprintf(stream, "  InstanceUID        = %s\n",  InstanceUID.ToString(identbuf));
-  fprintf(stream, "  GenerationUID      = %s\n",  GenerationUID.ToString(identbuf));
-  fprintf(stream, "  Packages:\n");  Packages.Dump(stream);
-  fprintf(stream, "  EssenceContainerData:\n");  EssenceContainerData.Dump(stream);
-
+  InterchangeObject::Dump(stream);
   fputs("==========================================================================\n", stream);
 }
 
+
 //------------------------------------------------------------------------------------------
 //
 
 //
 ASDCP::Result_t
-ASDCP::MXF::GenericPackage::InitFromBuffer(const byte_t* p, ui32_t l)
+ASDCP::MXF::GenericPackage::InitFromTLVSet(TLVReader& TLVSet)
 {
-  TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
-
-  Result_t result = MemRDR.ReadObject(OBJ_READ_ARGS(InterchangeObject, InstanceUID));
-  //      result = MemRDR.ReadObject(OBJ_READ_ARGS(InterchangeObject, InstanceUID));
-  if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenerationInterchangeObject, GenerationUID));
-  if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenericPackage, PackageUID));
-  if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenericPackage, Name));
-  if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenericPackage, PackageCreationDate));
-  if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenericPackage, PackageModifiedDate));
-  if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenericPackage, Tracks));
-
+  Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, PackageUID));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, Name));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, PackageCreationDate));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, PackageModifiedDate));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, Tracks));
   return result;
 }
 
+
+//------------------------------------------------------------------------------------------
 //
-ASDCP::Result_t
-ASDCP::MXF::GenericPackage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
-{
-  return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_DefaultObject].ul, 0);
-}
 
 //
-void
-ASDCP::MXF::GenericPackage::Dump(FILE* stream)
+ASDCP::Result_t
+ASDCP::MXF::MaterialPackage::InitFromTLVSet(TLVReader& TLVSet)
 {
-  char identbuf[IdentBufferLen];
-
-  if ( stream == 0 )
-    stream = stderr;
-
-  KLVPacket::Dump(stream, false);
-  fprintf(stream, "  InstanceUID        = %s\n", InstanceUID.ToString(identbuf));
-  fprintf(stream, "  GenerationUID      = %s\n", GenerationUID.ToString(identbuf));
-  fprintf(stream, "  PackageUID         = %s\n", PackageUID.ToString(identbuf));
-  fprintf(stream, "  Name               = %s\n", Name.ToString(identbuf));
-  fprintf(stream, "  PackageCreationDate= %s\n", PackageCreationDate.ToString(identbuf));
-  fprintf(stream, "  PackageModifiedDate= %s\n", PackageModifiedDate.ToString(identbuf));
-  fprintf(stream, "  Tracks:\n");  Tracks.Dump(stream);
-
-  fputs("==========================================================================\n", stream);
+  Result_t result = GenericPackage::InitFromTLVSet(TLVSet);
+  return result;
 }
 
-
-//------------------------------------------------------------------------------------------
-//
-
 //
 ASDCP::Result_t
 ASDCP::MXF::MaterialPackage::InitFromBuffer(const byte_t* p, ui32_t l)
 {
+  ASDCP_TEST_NULL(p);
+
   Result_t result = KLVPacket::InitFromBuffer(p, l, s_MDD_Table[MDDindex_MaterialPackage].ul);
 
   if ( ASDCP_SUCCESS(result) )
     {
-      return GenericPackage::InitFromBuffer(p, l);
+      TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
+      result = InitFromTLVSet(MemRDR);
     }
 
   return result;
 }
 
+
 //
 ASDCP::Result_t
 ASDCP::MXF::MaterialPackage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
@@ -218,11 +202,18 @@ ASDCP::MXF::MaterialPackage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
   return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_MaterialPackage].ul, 0);
 }
 
+
 //
 void
 ASDCP::MXF::MaterialPackage::Dump(FILE* stream)
 {
+//  char identbuf[IdentBufferLen];
+
+  if ( stream == 0 )
+    stream = stderr;
+
   GenericPackage::Dump(stream);
+  fputs("==========================================================================\n", stream);
 }
 
 
@@ -231,18 +222,30 @@ ASDCP::MXF::MaterialPackage::Dump(FILE* stream)
 
 //
 ASDCP::Result_t
+ASDCP::MXF::SourcePackage::InitFromTLVSet(TLVReader& TLVSet)
+{
+  Result_t result = GenericPackage::InitFromTLVSet(TLVSet);
+  return result;
+}
+
+//
+ASDCP::Result_t
 ASDCP::MXF::SourcePackage::InitFromBuffer(const byte_t* p, ui32_t l)
 {
+  ASDCP_TEST_NULL(p);
+
   Result_t result = KLVPacket::InitFromBuffer(p, l, s_MDD_Table[MDDindex_SourcePackage].ul);
 
   if ( ASDCP_SUCCESS(result) )
     {
-      return GenericPackage::InitFromBuffer(p, l);
+      TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
+      result = InitFromTLVSet(MemRDR);
     }
 
   return result;
 }
 
+
 //
 ASDCP::Result_t
 ASDCP::MXF::SourcePackage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
@@ -250,18 +253,52 @@ ASDCP::MXF::SourcePackage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
   return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_SourcePackage].ul, 0);
 }
 
+
 //
 void
 ASDCP::MXF::SourcePackage::Dump(FILE* stream)
 {
+//  char identbuf[IdentBufferLen];
+
+  if ( stream == 0 )
+    stream = stderr;
+
   GenericPackage::Dump(stream);
+  fputs("==========================================================================\n", stream);
+}
+
+
+//------------------------------------------------------------------------------------------
+//
+
+//
+ASDCP::Result_t
+ASDCP::MXF::GenericTrack::InitFromTLVSet(TLVReader& TLVSet)
+{
+  Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericTrack, TrackID));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericTrack, TrackNumber));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericTrack, TrackName));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericTrack, Sequence));
+  return result;
 }
 
+
 //------------------------------------------------------------------------------------------
 //
 
 //
 ASDCP::Result_t
+ASDCP::MXF::Track::InitFromTLVSet(TLVReader& TLVSet)
+{
+  Result_t result = GenericTrack::InitFromTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Track, EditRate));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(Track, Origin));
+  return result;
+}
+
+//
+ASDCP::Result_t
 ASDCP::MXF::Track::InitFromBuffer(const byte_t* p, ui32_t l)
 {
   ASDCP_TEST_NULL(p);
@@ -271,20 +308,13 @@ ASDCP::MXF::Track::InitFromBuffer(const byte_t* p, ui32_t l)
   if ( ASDCP_SUCCESS(result) )
     {
       TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
-
-      result = MemRDR.ReadObject(OBJ_READ_ARGS(InterchangeObject, InstanceUID));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenerationInterchangeObject, GenerationUID));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(GenericTrack, TrackID));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(GenericTrack, TrackNumber));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenericTrack, TrackName));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenericTrack, Sequence));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(Track, EditRate));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi64(OBJ_READ_ARGS(Track, Origin));
+      result = InitFromTLVSet(MemRDR);
     }
 
   return result;
 }
 
+
 //
 ASDCP::Result_t
 ASDCP::MXF::Track::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
@@ -292,33 +322,49 @@ ASDCP::MXF::Track::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
   return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_Track].ul, 0);
 }
 
+
 //
 void
 ASDCP::MXF::Track::Dump(FILE* stream)
 {
-  char identbuf[IdentBufferLen];
+//  char identbuf[IdentBufferLen];
 
   if ( stream == 0 )
     stream = stderr;
 
-  KLVPacket::Dump(stream, false);
-  fprintf(stream, "  InstanceUID        = %s\n",  InstanceUID.ToString(identbuf));
-  fprintf(stream, "  GenerationUID      = %s\n",  GenerationUID.ToString(identbuf));
-  fprintf(stream, "  TrackID            = %lu\n", TrackID);
-  fprintf(stream, "  TrackNumber        = %lu\n", TrackNumber);
-  fprintf(stream, "  TrackName          = %s\n",  TrackName.ToString(identbuf));
-  fprintf(stream, "  Sequence           = %s\n",  Sequence.ToString(identbuf));
-  fprintf(stream, "  EditRate           = %s\n",  EditRate.ToString(identbuf));
-  fprintf(stream, "  Origin             = %s\n",  i64sz(Origin, identbuf));
-
+  GenericTrack::Dump(stream);
   fputs("==========================================================================\n", stream);
 }
 
+
 //------------------------------------------------------------------------------------------
 //
 
 //
 ASDCP::Result_t
+ASDCP::MXF::StructuralComponent::InitFromTLVSet(TLVReader& TLVSet)
+{
+  Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(StructuralComponent, DataDefinition));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(StructuralComponent, Duration));
+  return result;
+}
+
+
+//------------------------------------------------------------------------------------------
+//
+
+//
+ASDCP::Result_t
+ASDCP::MXF::Sequence::InitFromTLVSet(TLVReader& TLVSet)
+{
+  Result_t result = StructuralComponent::InitFromTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Sequence, StructuralComponents));
+  return result;
+}
+
+//
+ASDCP::Result_t
 ASDCP::MXF::Sequence::InitFromBuffer(const byte_t* p, ui32_t l)
 {
   ASDCP_TEST_NULL(p);
@@ -328,17 +374,13 @@ ASDCP::MXF::Sequence::InitFromBuffer(const byte_t* p, ui32_t l)
   if ( ASDCP_SUCCESS(result) )
     {
       TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
-
-      result = MemRDR.ReadObject(OBJ_READ_ARGS(InterchangeObject, InstanceUID));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenerationInterchangeObject, GenerationUID));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(StructuralComponent, DataDefinition));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi64(OBJ_READ_ARGS(StructuralComponent, Duration));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(Sequence, StructuralComponents));
+      result = InitFromTLVSet(MemRDR);
     }
 
   return result;
 }
 
+
 //
 ASDCP::Result_t
 ASDCP::MXF::Sequence::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
@@ -346,33 +388,37 @@ ASDCP::MXF::Sequence::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
   return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_Sequence].ul, 0);
 }
 
+
 //
 void
 ASDCP::MXF::Sequence::Dump(FILE* stream)
 {
-  char identbuf[IdentBufferLen];
+//  char identbuf[IdentBufferLen];
 
   if ( stream == 0 )
     stream = stderr;
 
-  const MDDEntry* Entry = GetMDDEntry(DataDefinition.Data());
-
-  KLVPacket::Dump(stream, false);
-  fprintf(stream, "  InstanceUID        = %s\n", InstanceUID.ToString(identbuf));
-  fprintf(stream, "  DataDefinition     = %s (%s)\n", DataDefinition.ToString(identbuf), (Entry ? Entry->name : "Unknown"));
-  fprintf(stream, "  Duration           = %s\n", ui64sz(Duration, identbuf));
-  fprintf(stream, "  StructuralComponents:\n");  StructuralComponents.Dump(stream);
-
+  StructuralComponent::Dump(stream);
   fputs("==========================================================================\n", stream);
 }
 
 
-
 //------------------------------------------------------------------------------------------
 //
 
 //
 ASDCP::Result_t
+ASDCP::MXF::SourceClip::InitFromTLVSet(TLVReader& TLVSet)
+{
+  Result_t result = StructuralComponent::InitFromTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(SourceClip, StartPosition));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(SourceClip, SourcePackageID));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(SourceClip, SourceTrackID));
+  return result;
+}
+
+//
+ASDCP::Result_t
 ASDCP::MXF::SourceClip::InitFromBuffer(const byte_t* p, ui32_t l)
 {
   ASDCP_TEST_NULL(p);
@@ -382,19 +428,13 @@ ASDCP::MXF::SourceClip::InitFromBuffer(const byte_t* p, ui32_t l)
   if ( ASDCP_SUCCESS(result) )
     {
       TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
-
-      result = MemRDR.ReadObject(OBJ_READ_ARGS(InterchangeObject, InstanceUID));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenerationInterchangeObject, GenerationUID));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(StructuralComponent, DataDefinition));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi64(OBJ_READ_ARGS(SourceClip, StartPosition));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi64(OBJ_READ_ARGS(StructuralComponent, Duration));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(SourceClip, SourcePackageID));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(SourceClip, SourceTrackID));
+      result = InitFromTLVSet(MemRDR);
     }
 
   return result;
 }
 
+
 //
 ASDCP::Result_t
 ASDCP::MXF::SourceClip::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
@@ -402,22 +442,17 @@ ASDCP::MXF::SourceClip::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
   return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_SourceClip].ul, 0);
 }
 
+
 //
 void
 ASDCP::MXF::SourceClip::Dump(FILE* stream)
 {
-  char identbuf[IdentBufferLen];
+//  char identbuf[IdentBufferLen];
 
   if ( stream == 0 )
     stream = stderr;
 
-  KLVPacket::Dump(stream, false);
-  fprintf(stream, "  InstanceUID        = %s\n", InstanceUID.ToString(identbuf));
-  fprintf(stream, "  DataDefinition     = %s\n", DataDefinition.ToString(identbuf));
-  fprintf(stream, "  StartPosition      = %s\n", ui64sz(StartPosition, identbuf));
-  fprintf(stream, "  SourcePackageID    = %s\n", SourcePackageID.ToString(identbuf));
-  fprintf(stream, "  SourcePackageID    = %u\n", SourceTrackID);
-
+  StructuralComponent::Dump(stream);
   fputs("==========================================================================\n", stream);
 }
 
@@ -427,6 +462,17 @@ ASDCP::MXF::SourceClip::Dump(FILE* stream)
 
 //
 ASDCP::Result_t
+ASDCP::MXF::TimecodeComponent::InitFromTLVSet(TLVReader& TLVSet)
+{
+  Result_t result = StructuralComponent::InitFromTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(TimecodeComponent, RoundedTimecodeBase));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(TimecodeComponent, StartTimecode));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(TimecodeComponent, DropFrame));
+  return result;
+}
+
+//
+ASDCP::Result_t
 ASDCP::MXF::TimecodeComponent::InitFromBuffer(const byte_t* p, ui32_t l)
 {
   ASDCP_TEST_NULL(p);
@@ -436,19 +482,13 @@ ASDCP::MXF::TimecodeComponent::InitFromBuffer(const byte_t* p, ui32_t l)
   if ( ASDCP_SUCCESS(result) )
     {
       TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
-
-      result = MemRDR.ReadObject(OBJ_READ_ARGS(InterchangeObject, InstanceUID));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenerationInterchangeObject, GenerationUID));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(StructuralComponent, DataDefinition));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi64(OBJ_READ_ARGS(StructuralComponent, Duration));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi16(OBJ_READ_ARGS(TimecodeComponent, RoundedTimecodeBase));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi64(OBJ_READ_ARGS(TimecodeComponent, StartTimecode));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi8(OBJ_READ_ARGS(TimecodeComponent, DropFrame));
+      result = InitFromTLVSet(MemRDR);
     }
 
   return result;
 }
 
+
 //
 ASDCP::Result_t
 ASDCP::MXF::TimecodeComponent::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
@@ -456,82 +496,87 @@ ASDCP::MXF::TimecodeComponent::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
   return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_TimecodeComponent].ul, 0);
 }
 
+
 //
 void
 ASDCP::MXF::TimecodeComponent::Dump(FILE* stream)
 {
-  char identbuf[IdentBufferLen];
+//  char identbuf[IdentBufferLen];
 
   if ( stream == 0 )
     stream = stderr;
 
-  KLVPacket::Dump(stream, false);
-  fprintf(stream, "  InstanceUID        = %s\n", InstanceUID.ToString(identbuf));
-  fprintf(stream, "  DataDefinition     = %s\n", DataDefinition.ToString(identbuf));
-  fprintf(stream, "  Duration           = %s\n", ui64sz(Duration, identbuf));
-  fprintf(stream, "  RoundedTimecodeBase= %u\n", RoundedTimecodeBase);
-  fprintf(stream, "  StartTimecode      = %s\n", ui64sz(StartTimecode, identbuf));
-  fprintf(stream, "  DropFrame          = %d\n", DropFrame);
-
+  StructuralComponent::Dump(stream);
   fputs("==========================================================================\n", stream);
 }
 
+
 //------------------------------------------------------------------------------------------
 //
 
 //
 ASDCP::Result_t
-ASDCP::MXF::WaveAudioDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
+ASDCP::MXF::GenericDescriptor::InitFromTLVSet(TLVReader& TLVSet)
+{
+  Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericDescriptor, Locators));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericDescriptor, SubDescriptors));
+  return result;
+}
+
+
+//------------------------------------------------------------------------------------------
+//
+
+//
+ASDCP::Result_t
+ASDCP::MXF::FileDescriptor::InitFromTLVSet(TLVReader& TLVSet)
+{
+  Result_t result = GenericDescriptor::InitFromTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(FileDescriptor, LinkedTrackID));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(FileDescriptor, SampleRate));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(FileDescriptor, ContainerDuration));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(FileDescriptor, EssenceContainer));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(FileDescriptor, Codec));
+  return result;
+}
+
+//
+ASDCP::Result_t
+ASDCP::MXF::FileDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
   ASDCP_TEST_NULL(p);
 
-  Result_t result = KLVPacket::InitFromBuffer(p, l, s_MDD_Table[MDDindex_WaveAudioDescriptor].ul);
+  Result_t result = KLVPacket::InitFromBuffer(p, l, s_MDD_Table[MDDindex_FileDescriptor].ul);
 
   if ( ASDCP_SUCCESS(result) )
     {
       TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
-      MXF::Rational TmpRat;
-
-      //InterchangeObject_InstanceUID
-      result = MemRDR.ReadObject(OBJ_READ_ARGS(InterchangeObject, InstanceUID));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenerationInterchangeObject, GenerationUID));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(FileDescriptor, SampleRate));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi64(OBJ_READ_ARGS(FileDescriptor, ContainerDuration));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(FileDescriptor, LinkedTrackID));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(FileDescriptor, EssenceContainer));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, AudioSamplingRate));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi8(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, Locked));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, ChannelCount));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, QuantizationBits));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi16(OBJ_READ_ARGS(WaveAudioDescriptor, BlockAlign));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(WaveAudioDescriptor, AvgBps));
+      result = InitFromTLVSet(MemRDR);
     }
 
   return result;
 }
 
+
 //
 ASDCP::Result_t
-ASDCP::MXF::WaveAudioDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
+ASDCP::MXF::FileDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_WaveAudioDescriptor].ul, 0);
+  return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_FileDescriptor].ul, 0);
 }
 
+
 //
 void
-ASDCP::MXF::WaveAudioDescriptor::Dump(FILE* stream)
+ASDCP::MXF::FileDescriptor::Dump(FILE* stream)
 {
-  char identbuf[IdentBufferLen];
+//  char identbuf[IdentBufferLen];
 
   if ( stream == 0 )
     stream = stderr;
 
-  KLVPacket::Dump(stream, false);
-  fprintf(stream, "          InstanceUID: %s\n",  InstanceUID.ToString(identbuf));
-  fprintf(stream, "        LinkedTrackID: %lu\n", LinkedTrackID);
-  fprintf(stream, "     EssenceContainer: %s\n",  EssenceContainer.ToString(identbuf));
-  fprintf(stream, "...\n");
-
+  GenericDescriptor::Dump(stream);
   fputs("==========================================================================\n", stream);
 }
 
@@ -541,161 +586,419 @@ ASDCP::MXF::WaveAudioDescriptor::Dump(FILE* stream)
 
 //
 ASDCP::Result_t
-ASDCP::MXF::MPEG2VideoDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
+ASDCP::MXF::GenericSoundEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
+{
+  Result_t result = FileDescriptor::InitFromTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, AudioSamplingRate));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, Locked));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, AudioRefLevel));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, ElectroSpatialFormulation));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, ChannelCount));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, QuantizationBits));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, DialNorm));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, SoundEssenceCompression));
+  return result;
+}
+
+//
+ASDCP::Result_t
+ASDCP::MXF::GenericSoundEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
   ASDCP_TEST_NULL(p);
 
-  Result_t result = KLVPacket::InitFromBuffer(p, l, s_MDD_Table[MDDindex_MPEG2VideoDescriptor].ul);
+  Result_t result = KLVPacket::InitFromBuffer(p, l, s_MDD_Table[MDDindex_GenericSoundEssenceDescriptor].ul);
 
   if ( ASDCP_SUCCESS(result) )
     {
       TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
-      MXF::Rational TmpRat;
-      ui8_t tmp_delay;
-
-      //InterchangeObject_InstanceUID
-      result = MemRDR.ReadObject(OBJ_READ_ARGS(InterchangeObject, InstanceUID));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS_R(FileDescriptor, SampleRate, TmpRat));
-      SampleRate = TmpRat;
-      ui64_t tmpDuration = 0;
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi64(OBJ_READ_ARGS_R(FileDescriptor, ContainerDuration, tmpDuration));
-      ContainerDuration = tmpDuration;
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(FileDescriptor, LinkedTrackID));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(FileDescriptor, EssenceContainer));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS_R(GenericPictureEssenceDescriptor, AspectRatio, TmpRat));
-      AspectRatio = TmpRat;
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi8(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, FrameLayout));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, StoredWidth));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, StoredHeight));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, ComponentDepth));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, HorizontalSubsampling));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, VerticalSubsampling));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi8(OBJ_READ_ARGS(CDCIEssenceDescriptor, ColorSiting));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi8(OBJ_READ_ARGS(MPEG2VideoDescriptor,  CodedContentType));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(MPEG2VideoDescriptor,  BitRate));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi8(OBJ_READ_ARGS(MPEG2VideoDescriptor,  ProfileAndLevel));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi8(OBJ_READ_ARGS_R(MPEG2VideoDescriptor,  LowDelay, tmp_delay));
-      LowDelay = (tmp_delay > 0);
+      result = InitFromTLVSet(MemRDR);
     }
 
   return result;
 }
 
+
 //
 ASDCP::Result_t
-ASDCP::MXF::MPEG2VideoDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
+ASDCP::MXF::GenericSoundEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_MPEG2VideoDescriptor].ul, 0);
+  return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_GenericSoundEssenceDescriptor].ul, 0);
 }
 
+
 //
 void
-ASDCP::MXF::MPEG2VideoDescriptor::Dump(FILE* stream)
+ASDCP::MXF::GenericSoundEssenceDescriptor::Dump(FILE* stream)
 {
-  char identbuf[IdentBufferLen];
+//  char identbuf[IdentBufferLen];
 
   if ( stream == 0 )
     stream = stderr;
 
-  KLVPacket::Dump(stream, false);
-  fprintf(stream, "          InstanceUID: %s\n",  InstanceUID.ToString(identbuf));
-  fprintf(stream, "        LinkedTrackID: %lu\n", LinkedTrackID);
-  fprintf(stream, "     EssenceContainer: %s\n",  EssenceContainer.ToString(identbuf));
-  ASDCP::MPEG2::VideoDescriptorDump(*this, stream);
-
+  FileDescriptor::Dump(stream);
   fputs("==========================================================================\n", stream);
 }
 
+
 //------------------------------------------------------------------------------------------
 //
 
 //
 ASDCP::Result_t
-ASDCP::MXF::FileDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
+ASDCP::MXF::WaveAudioDescriptor::InitFromTLVSet(TLVReader& TLVSet)
+{
+  Result_t result = GenericSoundEssenceDescriptor::InitFromTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(WaveAudioDescriptor, BlockAlign));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(WaveAudioDescriptor, SequenceOffset));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(WaveAudioDescriptor, AvgBps));
+  return result;
+}
+
+//
+ASDCP::Result_t
+ASDCP::MXF::WaveAudioDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
   ASDCP_TEST_NULL(p);
 
-  Result_t result = KLVPacket::InitFromBuffer(p, l); // any of a variety of ULs, really
+  Result_t result = KLVPacket::InitFromBuffer(p, l, s_MDD_Table[MDDindex_WaveAudioDescriptor].ul);
 
   if ( ASDCP_SUCCESS(result) )
     {
       TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
-
-      result = MemRDR.ReadObject(OBJ_READ_ARGS(InterchangeObject, InstanceUID));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenerationInterchangeObject, GenerationUID));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenericDescriptor, Locators));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenericDescriptor, SubDescriptors));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(FileDescriptor, LinkedTrackID));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(FileDescriptor, SampleRate));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi64(OBJ_READ_ARGS(FileDescriptor, ContainerDuration));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(FileDescriptor, EssenceContainer));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(FileDescriptor, Codec));
+      result = InitFromTLVSet(MemRDR);
     }
 
   return result;
 }
 
+
 //
 ASDCP::Result_t
-ASDCP::MXF::FileDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
+ASDCP::MXF::WaveAudioDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_FileDescriptor].ul, 0);
+  return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_WaveAudioDescriptor].ul, 0);
 }
 
+
 //
 void
-ASDCP::MXF::FileDescriptor::Dump(FILE* stream)
+ASDCP::MXF::WaveAudioDescriptor::Dump(FILE* stream)
 {
-  char identbuf[IdentBufferLen];
+//  char identbuf[IdentBufferLen];
 
   if ( stream == 0 )
     stream = stderr;
 
-  KLVPacket::Dump(stream, false);
-  fprintf(stream, "          InstanceUID: %s\n",  InstanceUID.ToString(identbuf));
-  fprintf(stream, "        GenerationUID: %lu\n", GenerationUID.ToString(identbuf));
-  fprintf(stream, "        LinkedTrackID: %lu\n", LinkedTrackID);
-  fprintf(stream, "     EssenceContainer: %s\n",  EssenceContainer.ToString(identbuf));
-  fprintf(stream, "...\n");
-
+  GenericSoundEssenceDescriptor::Dump(stream);
   fputs("==========================================================================\n", stream);
 }
 
+
 //------------------------------------------------------------------------------------------
 //
 
 //
 ASDCP::Result_t
+ASDCP::MXF::GenericPictureEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
+{
+  Result_t result = FileDescriptor::InitFromTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, FrameLayout));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, StoredWidth));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, StoredHeight));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, DisplayWidth));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, DisplayHeight));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, AspectRatio));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, Gamma));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, PictureEssenceCoding));
+  return result;
+}
+
+//
+ASDCP::Result_t
+ASDCP::MXF::GenericPictureEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
+{
+  ASDCP_TEST_NULL(p);
+
+  Result_t result = KLVPacket::InitFromBuffer(p, l, s_MDD_Table[MDDindex_GenericPictureEssenceDescriptor].ul);
+
+  if ( ASDCP_SUCCESS(result) )
+    {
+      TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
+      result = InitFromTLVSet(MemRDR);
+    }
+
+  return result;
+}
+
+
+//
+ASDCP::Result_t
 ASDCP::MXF::GenericPictureEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
   return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_GenericPictureEssenceDescriptor].ul, 0);
 }
 
+
+//
+void
+ASDCP::MXF::GenericPictureEssenceDescriptor::Dump(FILE* stream)
+{
+//  char identbuf[IdentBufferLen];
+
+  if ( stream == 0 )
+    stream = stderr;
+
+  FileDescriptor::Dump(stream);
+  fputs("==========================================================================\n", stream);
+}
+
+
 //------------------------------------------------------------------------------------------
 //
 
 //
 ASDCP::Result_t
+ASDCP::MXF::RGBAEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
+{
+  Result_t result = GenericPictureEssenceDescriptor::InitFromTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(RGBAEssenceDescriptor, ComponentMaxRef));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(RGBAEssenceDescriptor, ComponentMinRef));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(RGBAEssenceDescriptor, PixelLayout));
+  return result;
+}
+
+//
+ASDCP::Result_t
+ASDCP::MXF::RGBAEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
+{
+  ASDCP_TEST_NULL(p);
+
+  Result_t result = KLVPacket::InitFromBuffer(p, l, s_MDD_Table[MDDindex_RGBAEssenceDescriptor].ul);
+
+  if ( ASDCP_SUCCESS(result) )
+    {
+      TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
+      result = InitFromTLVSet(MemRDR);
+    }
+
+  return result;
+}
+
+
+//
+ASDCP::Result_t
 ASDCP::MXF::RGBAEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
   return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_RGBAEssenceDescriptor].ul, 0);
 }
 
+
+//
+void
+ASDCP::MXF::RGBAEssenceDescriptor::Dump(FILE* stream)
+{
+//  char identbuf[IdentBufferLen];
+
+  if ( stream == 0 )
+    stream = stderr;
+
+  GenericPictureEssenceDescriptor::Dump(stream);
+  fputs("==========================================================================\n", stream);
+}
+
+
 //------------------------------------------------------------------------------------------
 //
 
 //
 ASDCP::Result_t
+ASDCP::MXF::JPEG2000PictureSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
+{
+  Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Rsize));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Xsize));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Ysize));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XOsize));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YOsize));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XTsize));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YTsize));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XTOsize));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YTOsize));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Csize));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, PictureComponentSizing));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, CodingStyleDefault));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, QuantizationDefault));
+  return result;
+}
+
+//
+ASDCP::Result_t
+ASDCP::MXF::JPEG2000PictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
+{
+  ASDCP_TEST_NULL(p);
+
+  Result_t result = KLVPacket::InitFromBuffer(p, l, s_MDD_Table[MDDindex_JPEG2000PictureSubDescriptor].ul);
+
+  if ( ASDCP_SUCCESS(result) )
+    {
+      TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
+      result = InitFromTLVSet(MemRDR);
+    }
+
+  return result;
+}
+
+
+//
+ASDCP::Result_t
 ASDCP::MXF::JPEG2000PictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
   return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_JPEG2000PictureSubDescriptor].ul, 0);
 }
 
+
+//
+void
+ASDCP::MXF::JPEG2000PictureSubDescriptor::Dump(FILE* stream)
+{
+//  char identbuf[IdentBufferLen];
+
+  if ( stream == 0 )
+    stream = stderr;
+
+  InterchangeObject::Dump(stream);
+  fputs("==========================================================================\n", stream);
+}
+
+
 //------------------------------------------------------------------------------------------
 //
 
 //
 ASDCP::Result_t
+ASDCP::MXF::CDCIEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
+{
+  Result_t result = GenericPictureEssenceDescriptor::InitFromTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, ComponentDepth));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, HorizontalSubsampling));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, VerticalSubsampling));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(CDCIEssenceDescriptor, ColorSiting));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(CDCIEssenceDescriptor, ReversedByteOrder));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, BlackRefLevel));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, WhiteReflevel));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, ColorRange));
+  return result;
+}
+
+//
+ASDCP::Result_t
+ASDCP::MXF::CDCIEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
+{
+  ASDCP_TEST_NULL(p);
+
+  Result_t result = KLVPacket::InitFromBuffer(p, l, s_MDD_Table[MDDindex_CDCIEssenceDescriptor].ul);
+
+  if ( ASDCP_SUCCESS(result) )
+    {
+      TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
+      result = InitFromTLVSet(MemRDR);
+    }
+
+  return result;
+}
+
+
+//
+ASDCP::Result_t
+ASDCP::MXF::CDCIEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
+{
+  return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_CDCIEssenceDescriptor].ul, 0);
+}
+
+
+//
+void
+ASDCP::MXF::CDCIEssenceDescriptor::Dump(FILE* stream)
+{
+//  char identbuf[IdentBufferLen];
+
+  if ( stream == 0 )
+    stream = stderr;
+
+  GenericPictureEssenceDescriptor::Dump(stream);
+  fputs("==========================================================================\n", stream);
+}
+
+
+//------------------------------------------------------------------------------------------
+//
+
+//
+ASDCP::Result_t
+ASDCP::MXF::MPEG2VideoDescriptor::InitFromTLVSet(TLVReader& TLVSet)
+{
+  Result_t result = CDCIEssenceDescriptor::InitFromTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(MPEG2VideoDescriptor, CodedContentType));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(MPEG2VideoDescriptor, LowDelay));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(MPEG2VideoDescriptor, BitRate));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(MPEG2VideoDescriptor, ProfileAndLevel));
+  return result;
+}
+
+//
+ASDCP::Result_t
+ASDCP::MXF::MPEG2VideoDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
+{
+  ASDCP_TEST_NULL(p);
+
+  Result_t result = KLVPacket::InitFromBuffer(p, l, s_MDD_Table[MDDindex_MPEG2VideoDescriptor].ul);
+
+  if ( ASDCP_SUCCESS(result) )
+    {
+      TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
+      result = InitFromTLVSet(MemRDR);
+    }
+
+  return result;
+}
+
+
+//
+ASDCP::Result_t
+ASDCP::MXF::MPEG2VideoDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
+{
+  return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_MPEG2VideoDescriptor].ul, 0);
+}
+
+
+//
+void
+ASDCP::MXF::MPEG2VideoDescriptor::Dump(FILE* stream)
+{
+//  char identbuf[IdentBufferLen];
+
+  if ( stream == 0 )
+    stream = stderr;
+
+  CDCIEssenceDescriptor::Dump(stream);
+  fputs("==========================================================================\n", stream);
+}
+
+
+//------------------------------------------------------------------------------------------
+//
+
+//
+ASDCP::Result_t
+ASDCP::MXF::CryptographicFramework::InitFromTLVSet(TLVReader& TLVSet)
+{
+  Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicFramework, ContextSR));
+  return result;
+}
+
+//
+ASDCP::Result_t
 ASDCP::MXF::CryptographicFramework::InitFromBuffer(const byte_t* p, ui32_t l)
 {
   ASDCP_TEST_NULL(p);
@@ -705,27 +1008,31 @@ ASDCP::MXF::CryptographicFramework::InitFromBuffer(const byte_t* p, ui32_t l)
   if ( ASDCP_SUCCESS(result) )
     {
       TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
-
-      result = MemRDR.ReadObject(OBJ_READ_ARGS(InterchangeObject, InstanceUID));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(CryptographicFramework, ContextSR));
+      result = InitFromTLVSet(MemRDR);
     }
 
   return result;
 }
 
+
+//
+ASDCP::Result_t
+ASDCP::MXF::CryptographicFramework::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
+{
+  return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_CryptographicFramework].ul, 0);
+}
+
+
 //
 void
 ASDCP::MXF::CryptographicFramework::Dump(FILE* stream)
 {
-  char identbuf[IdentBufferLen];
+//  char identbuf[IdentBufferLen];
 
   if ( stream == 0 )
     stream = stderr;
 
-  KLVPacket::Dump(stream, false);
-  fprintf(stream, "  InstanceUID        = %s\n", InstanceUID.ToString(identbuf));
-  fprintf(stream, "  ContextSR          = %s\n", ContextSR.ToString(identbuf));
-
+  InterchangeObject::Dump(stream);
   fputs("==========================================================================\n", stream);
 }
 
@@ -735,6 +1042,19 @@ ASDCP::MXF::CryptographicFramework::Dump(FILE* stream)
 
 //
 ASDCP::Result_t
+ASDCP::MXF::CryptographicContext::InitFromTLVSet(TLVReader& TLVSet)
+{
+  Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, ContextID));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, SourceEssenceContainer));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, CipherAlgorithm));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, MICAlgorithm));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, CryptographicKeyID));
+  return result;
+}
+
+//
+ASDCP::Result_t
 ASDCP::MXF::CryptographicContext::InitFromBuffer(const byte_t* p, ui32_t l)
 {
   ASDCP_TEST_NULL(p);
@@ -744,38 +1064,35 @@ ASDCP::MXF::CryptographicContext::InitFromBuffer(const byte_t* p, ui32_t l)
   if ( ASDCP_SUCCESS(result) )
     {
       TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
-
-      result = MemRDR.ReadObject(OBJ_READ_ARGS(InterchangeObject, InstanceUID));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(CryptographicContext, ContextID));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(CryptographicContext, SourceEssenceContainer));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(CryptographicContext, CipherAlgorithm));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(CryptographicContext, MICAlgorithm));
-      if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(CryptographicContext, CryptographicKeyID));
+      result = InitFromTLVSet(MemRDR);
     }
 
   return result;
 }
 
+
+//
+ASDCP::Result_t
+ASDCP::MXF::CryptographicContext::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
+{
+  return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_CryptographicContext].ul, 0);
+}
+
+
 //
 void
 ASDCP::MXF::CryptographicContext::Dump(FILE* stream)
 {
-  char identbuf[IdentBufferLen];
+//  char identbuf[IdentBufferLen];
 
   if ( stream == 0 )
     stream = stderr;
 
-  KLVPacket::Dump(stream, false);
-  fprintf(stream, "  InstanceUID        = %s\n", InstanceUID.ToString(identbuf));
-  fprintf(stream, "  ContextID          = %s\n", ContextID.ToString(identbuf));
-  fprintf(stream, "  SourceEssenceCnt   = %s\n", SourceEssenceContainer.ToString(identbuf));
-  fprintf(stream, "  CipherAlgorithm    = %s\n", CipherAlgorithm.ToString(identbuf));
-  fprintf(stream, "  MICAlgorithm       = %s\n", MICAlgorithm.ToString(identbuf));
-  fprintf(stream, "  CryptographicKeyID = %s\n", CryptographicKeyID.ToString(identbuf));
-
+  InterchangeObject::Dump(stream);
   fputs("==========================================================================\n", stream);
 }
 
+
 //
 // end MXF.cpp
 //