added ACES (2067-50) descriptors

diff --git a/src/MDD.cpp b/src/MDD.cpp
index 1b4984f8ae63eb1697c7c898836263dd8fd19d60..de7140173c6bf88eb08d5660391bb5ed114183cd 100644 (file)
--- a/src/MDD.cpp
+++ b/src/MDD.cpp
@@ -1461,6 +1461,74 @@ static const ASDCP::MDDEntry s_MDD_Table[] = {
        0x04, 0x01, 0x01, 0x01, 0x03, 0x01, 0x00, 0x00 },
      {0}, false, "ColorPrimaries_SMPTE170M" },
 
+   // ACES ST 2067-50
+   { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 470
+       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x79, 0x00 },
+     {0}, false, "ACESPictureSubDescriptor" },
+   { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0e, // 471
+       0x04, 0x01, 0x06, 0x0a, 0x01, 0x00, 0x00, 0x00 },
+     {0}, false, "ACESPictureSubDescriptor_ACESAuthoringInformation" },
+   { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0e, // 472
+       0x04, 0x01, 0x06, 0x0a, 0x02, 0x00, 0x00, 0x00 },
+     {0}, false, "ACESPictureSubDescriptor_ACESMasteringDisplayPrimaries" },
+   { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0e, // 473
+       0x04, 0x01, 0x06, 0x0a, 0x03, 0x00, 0x00, 0x00 },
+     {0}, false, "ACESPictureSubDescriptor_ACESMasteringDisplayWhitePointChromaticity" },
+   { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0e, // 474
+       0x04, 0x01, 0x06, 0x0a, 0x04, 0x00, 0x00, 0x00 },
+     {0}, false, "ACESPictureSubDescriptor_ACESMasteringDisplayMaximumLuminance" },
+   { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0e, // 475
+       0x04, 0x01, 0x06, 0x0a, 0x05, 0x00, 0x00, 0x00 },
+     {0}, false, "ACESPictureSubDescriptor_ACESMasteringDisplayMinimumLuminance" },
+   { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 476
+       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x7a, 0x00 },
+     {0}, false, "TargetFrameSubDescriptor" },
+   { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0e, // 477
+       0x04, 0x01, 0x06, 0x09, 0x01, 0x00, 0x00, 0x00 },
+     {0}, false, "TargetFrameSubDescriptor_TargetFrameAncillaryResourceID" },
+   { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0e, // 478
+       0x04, 0x01, 0x06, 0x09, 0x02, 0x00, 0x00, 0x00 },
+     {0}, false, "TargetFrameSubDescriptor_MediaType" },
+   { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0e, // 479
+       0x04, 0x01, 0x06, 0x09, 0x03, 0x00, 0x00, 0x00 },
+     {0}, false, "TargetFrameSubDescriptor_TargetFrameIndex" },
+   { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0e, // 480
+       0x04, 0x01, 0x06, 0x09, 0x04, 0x00, 0x00, 0x00 },
+     {0}, false, "TargetFrameSubDescriptor_TargetFrameTransferCharacteristic" },
+   { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0e, // 481
+       0x04, 0x01, 0x06, 0x09, 0x05, 0x00, 0x00, 0x00 },
+     {0}, false, "TargetFrameSubDescriptor_TargetFrameColorPrimaries" },
+   { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0e, // 482
+       0x04, 0x01, 0x06, 0x09, 0x06, 0x00, 0x00, 0x00 },
+     {0}, false, "TargetFrameSubDescriptor_TargetFrameComponentMaxRef" },
+   { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0e, // 483
+       0x04, 0x01, 0x06, 0x09, 0x07, 0x00, 0x00, 0x00 },
+     {0}, false, "TargetFrameSubDescriptor_TargetFrameComponentMinRef" },
+   { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0e, // 484
+       0x04, 0x01, 0x06, 0x09, 0x08, 0x00, 0x00, 0x00 },
+     {0}, false, "TargetFrameSubDescriptor_TargetFrameEssenceStreamID" },
+   { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0e, // 485
+       0x04, 0x01, 0x06, 0x09, 0x09, 0x00, 0x00, 0x00 },
+     {0}, false, "TargetFrameSubDescriptor_ACESPictureSubDescriptorInstanceID" },
+   { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0e, // 486
+       0x04, 0x01, 0x06, 0x09, 0x0a, 0x00, 0x00, 0x00 },
+     {0}, false, "TargetFrameSubDescriptor_TargetFrameViewingEnvironment" },
+   { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x0d, // 487
+       0x04, 0x01, 0x01, 0x01, 0x01, 0x0c, 0x00, 0x00 },
+     {0}, false, "TransferCharacteristic_Gamma_2_6" },
+   { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x0d, // 488
+       0x04, 0x01, 0x01, 0x01, 0x01, 0x0d, 0x00, 0x00 },
+     {0}, false, "TransferCharacteristic_sRGB" },
+   { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x0d, // 489
+       0x04, 0x10, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00 },
+     {0}, false, "TheatricalViewingEnvironment" },
+   { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x0d, // 490
+       0x04, 0x10, 0x01, 0x01, 0x01, 0x02, 0x00, 0x00 },
+     {0}, false, "HDTVReferenceViewingEnvironment" },
+   { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x0d, // 491
+       0x04, 0x10, 0x01, 0x01, 0x01, 0x03, 0x00, 0x00 },
+     {0}, false, "HDRReferenceViewingEnvironment" },
+   
    { {0}, {0}, false, 0 }
  };
 

diff --git a/src/MDD.h b/src/MDD.h
index 06fc968ddc018a5c9a07380abde4c9d297b16bac..667cf50a6eb425c158b61a90851aa8f64a576268 100755 (executable)
--- a/src/MDD.h
+++ b/src/MDD.h
@@ -505,6 +505,29 @@ namespace ASDCP {
        MDD_PIMFDynamicMetadataDescriptor_GlobalPayloadSID, // 467
        MDD_ColorPrimaries_ITU470_PAL, // 468
        MDD_ColorPrimaries_SMPTE170M, // 469
+       MDD_ACESPictureSubDescriptor, //  470
+       MDD_ACESPictureSubDescriptor_ACESAuthoringInformation, //  471
+       MDD_ACESPictureSubDescriptor_ACESMasteringDisplayPrimaries, // 472
+       MDD_ACESPictureSubDescriptor_ACESMasteringDisplayWhitePointChromaticity, // 473
+       MDD_ACESPictureSubDescriptor_ACESMasteringDisplayMaximumLuminance, // 474
+       MDD_ACESPictureSubDescriptor_ACESMasteringDisplayMinimumLuminance, // 475
+       MDD_TargetFrameSubDescriptor, //  476
+       MDD_TargetFrameSubDescriptor_TargetFrameAncillaryResourceID, // 477
+       MDD_TargetFrameSubDescriptor_MediaType, // 478
+       MDD_TargetFrameSubDescriptor_TargetFrameIndex, // 479
+       MDD_TargetFrameSubDescriptor_TargetFrameTransferCharacteristic, // 480
+       MDD_TargetFrameSubDescriptor_TargetFrameColorPrimaries, // 481
+       MDD_TargetFrameSubDescriptor_TargetFrameComponentMaxRef, // 482
+       MDD_TargetFrameSubDescriptor_TargetFrameComponentMinRef, // 483
+       MDD_TargetFrameSubDescriptor_TargetFrameEssenceStreamID, // 484
+       MDD_TargetFrameSubDescriptor_ACESPictureSubDescriptorInstanceID, // 485
+       MDD_TargetFrameSubDescriptor_TargetFrameViewingEnvironment, // 486
+       MDD_TransferCharacteristic_Gamma_2_6, // 487
+       MDD_TransferCharacteristic_sRGB, // 488
+       MDD_TheatricalViewingEnvironment, // 489
+       MDD_HDTVReferenceViewingEnvironment, // 490
+       MDD_HDRReferenceViewingEnvironment, // 491
+
         MDD_Max
     }; // enum MDD_t
 

diff --git a/src/Metadata.cpp b/src/Metadata.cpp
index b32ff4270a3fb0121815351ae087f664d11bf2ff..4a0db5ae44f13abdba1efbb4eebd0d61b29173b3 100755 (executable)
--- a/src/Metadata.cpp
+++ b/src/Metadata.cpp
@@ -77,6 +77,8 @@ static InterchangeObject* GroupOfSoundfieldGroupsLabelSubDescriptor_Factory(cons
 static InterchangeObject* DCDataDescriptor_Factory(const Dictionary*& Dict) { return new DCDataDescriptor(Dict); }
 static InterchangeObject* PrivateDCDataDescriptor_Factory(const Dictionary*& Dict) { return new PrivateDCDataDescriptor(Dict); }
 static InterchangeObject* DolbyAtmosSubDescriptor_Factory(const Dictionary*& Dict) { return new DolbyAtmosSubDescriptor(Dict); }
+static InterchangeObject* ACESPictureSubDescriptor_Factory(const Dictionary*& Dict) { return new ACESPictureSubDescriptor(Dict); }
+static InterchangeObject* TargetFrameSubDescriptor_Factory(const Dictionary*& Dict) { return new TargetFrameSubDescriptor(Dict); }
 static InterchangeObject* PHDRMetadataTrackSubDescriptor_Factory(const Dictionary*& Dict) { return new PHDRMetadataTrackSubDescriptor(Dict); }
 static InterchangeObject* PIMFDynamicMetadataDescriptor_Factory(const Dictionary*& Dict) { return new PIMFDynamicMetadataDescriptor(Dict); }
 
@@ -122,6 +124,8 @@ ASDCP::MXF::Metadata_InitTypes(const Dictionary*& Dict)
   SetObjectFactory(Dict->ul(MDD_DCDataDescriptor), DCDataDescriptor_Factory);
   SetObjectFactory(Dict->ul(MDD_PrivateDCDataDescriptor), PrivateDCDataDescriptor_Factory);
   SetObjectFactory(Dict->ul(MDD_DolbyAtmosSubDescriptor), DolbyAtmosSubDescriptor_Factory);
+  SetObjectFactory(Dict->ul(MDD_ACESPictureSubDescriptor), ACESPictureSubDescriptor_Factory);
+  SetObjectFactory(Dict->ul(MDD_TargetFrameSubDescriptor), TargetFrameSubDescriptor_Factory);
   SetObjectFactory(Dict->ul(MDD_PHDRMetadataTrackSubDescriptor), PHDRMetadataTrackSubDescriptor_Factory);
   SetObjectFactory(Dict->ul(MDD_PIMFDynamicMetadataDescriptor), PIMFDynamicMetadataDescriptor_Factory);
 }
@@ -3887,6 +3891,243 @@ DolbyAtmosSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
+//------------------------------------------------------------------------------------------
+// ACESPictureSubDescriptor
+
+//
+
+ACESPictureSubDescriptor::ACESPictureSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_ACESPictureSubDescriptor);
+}
+
+ACESPictureSubDescriptor::ACESPictureSubDescriptor(const ACESPictureSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_ACESPictureSubDescriptor);
+  Copy(rhs);
+}
+
+
+//
+ASDCP::Result_t
+ACESPictureSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
+{
+  assert(m_Dict);
+  Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) {
+    result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(ACESPictureSubDescriptor, ACESAuthoringInformation));
+    ACESAuthoringInformation.set_has_value( result == RESULT_OK );
+  }
+  if ( ASDCP_SUCCESS(result) ) {
+    result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayPrimaries));
+    ACESMasteringDisplayPrimaries.set_has_value( result == RESULT_OK );
+  }
+  if ( ASDCP_SUCCESS(result) ) {
+    result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayWhitePointChromaticity));
+    ACESMasteringDisplayWhitePointChromaticity.set_has_value( result == RESULT_OK );
+  }
+  if ( ASDCP_SUCCESS(result) ) { 
+    result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayMaximumLuminance));
+    ACESMasteringDisplayMaximumLuminance.set_has_value( result == RESULT_OK );
+  }
+  if ( ASDCP_SUCCESS(result) ) { 
+    result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayMinimumLuminance));
+    ACESMasteringDisplayMinimumLuminance.set_has_value( result == RESULT_OK );
+  }
+  return result;
+}
+
+//
+ASDCP::Result_t
+ACESPictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
+{
+  assert(m_Dict);
+  Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result)  && ! ACESAuthoringInformation.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(ACESPictureSubDescriptor, ACESAuthoringInformation));
+  if ( ASDCP_SUCCESS(result)  && ! ACESMasteringDisplayPrimaries.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayPrimaries));
+  if ( ASDCP_SUCCESS(result)  && ! ACESMasteringDisplayWhitePointChromaticity.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayWhitePointChromaticity));
+  if ( ASDCP_SUCCESS(result)  && ! ACESMasteringDisplayMaximumLuminance.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayMaximumLuminance));
+  if ( ASDCP_SUCCESS(result)  && ! ACESMasteringDisplayMinimumLuminance.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayMinimumLuminance));
+  return result;
+}
+
+//
+void
+ACESPictureSubDescriptor::Copy(const ACESPictureSubDescriptor& rhs)
+{
+  InterchangeObject::Copy(rhs);
+  ACESAuthoringInformation = rhs.ACESAuthoringInformation;
+  ACESMasteringDisplayPrimaries = rhs.ACESMasteringDisplayPrimaries;
+  ACESMasteringDisplayWhitePointChromaticity = rhs.ACESMasteringDisplayWhitePointChromaticity;
+  ACESMasteringDisplayMaximumLuminance = rhs.ACESMasteringDisplayMaximumLuminance;
+  ACESMasteringDisplayMinimumLuminance = rhs.ACESMasteringDisplayMinimumLuminance;
+}
+
+//
+void
+ACESPictureSubDescriptor::Dump(FILE* stream)
+{
+  char identbuf[IdentBufferLen];
+  *identbuf = 0;
+
+  if ( stream == 0 )
+    stream = stderr;
+
+  InterchangeObject::Dump(stream);
+  if ( ! ACESAuthoringInformation.empty() ) {
+    fprintf(stream, "  %22s = %s\n",  "ACESAuthoringInformation", ACESAuthoringInformation.get().EncodeString(identbuf, IdentBufferLen));
+  }
+  if ( ! ACESMasteringDisplayPrimaries.empty() ) {
+    fprintf(stream, "  %22s = %s\n",  "ACESMasteringDisplayPrimaries", ACESMasteringDisplayPrimaries.get().EncodeString(identbuf, IdentBufferLen));
+  }
+  if ( ! ACESMasteringDisplayWhitePointChromaticity.empty() ) {
+    fprintf(stream, "  %22s = %s\n",  "ACESMasteringDisplayWhitePointChromaticity", ACESMasteringDisplayWhitePointChromaticity.get().EncodeString(identbuf, IdentBufferLen));
+  }
+  if ( ! ACESMasteringDisplayMaximumLuminance.empty() ) {
+    fprintf(stream, "  %22s = %d\n",  "ACESMasteringDisplayMaximumLuminance", ACESMasteringDisplayMaximumLuminance.get());
+  }
+  if ( ! ACESMasteringDisplayMinimumLuminance.empty() ) {
+    fprintf(stream, "  %22s = %d\n",  "ACESMasteringDisplayMinimumLuminance", ACESMasteringDisplayMinimumLuminance.get());
+  }
+}
+
+//
+ASDCP::Result_t
+ACESPictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
+{
+  return InterchangeObject::InitFromBuffer(p, l);
+}
+
+//
+ASDCP::Result_t
+ACESPictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
+{
+  return InterchangeObject::WriteToBuffer(Buffer);
+}
+
+//------------------------------------------------------------------------------------------
+// TargetFrameSubDescriptor
+
+//
+
+TargetFrameSubDescriptor::TargetFrameSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), TargetFrameIndex(0), TargetFrameComponentMaxRef(0), TargetFrameComponentMinRef(0), TargetFrameEssenceStreamID(0)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_TargetFrameSubDescriptor);
+}
+
+TargetFrameSubDescriptor::TargetFrameSubDescriptor(const TargetFrameSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_TargetFrameSubDescriptor);
+  Copy(rhs);
+}
+
+
+//
+ASDCP::Result_t
+TargetFrameSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
+{
+  assert(m_Dict);
+  Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameAncillaryResourceID));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TargetFrameSubDescriptor, MediaType));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameIndex));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameTransferCharacteristic));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameColorPrimaries));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameComponentMaxRef));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameComponentMinRef));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameEssenceStreamID));
+  if ( ASDCP_SUCCESS(result) ) {
+    result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(TargetFrameSubDescriptor, ACESPictureSubDescriptorInstanceID));
+    ACESPictureSubDescriptorInstanceID.set_has_value( result == RESULT_OK );
+  }
+  if ( ASDCP_SUCCESS(result) ) {
+    result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(TargetFrameSubDescriptor, TargetFrameViewingEnvironment));
+    TargetFrameViewingEnvironment.set_has_value( result == RESULT_OK );
+  }
+  return result;
+}
+
+//
+ASDCP::Result_t
+TargetFrameSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
+{
+  assert(m_Dict);
+  Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameAncillaryResourceID));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, MediaType));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameIndex));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameTransferCharacteristic));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameColorPrimaries));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameComponentMaxRef));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameComponentMinRef));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameEssenceStreamID));
+  if ( ASDCP_SUCCESS(result)  && ! ACESPictureSubDescriptorInstanceID.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(TargetFrameSubDescriptor, ACESPictureSubDescriptorInstanceID));
+  if ( ASDCP_SUCCESS(result)  && ! TargetFrameViewingEnvironment.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(TargetFrameSubDescriptor, TargetFrameViewingEnvironment));
+  return result;
+}
+
+//
+void
+TargetFrameSubDescriptor::Copy(const TargetFrameSubDescriptor& rhs)
+{
+  InterchangeObject::Copy(rhs);
+  TargetFrameAncillaryResourceID = rhs.TargetFrameAncillaryResourceID;
+  MediaType = rhs.MediaType;
+  TargetFrameIndex = rhs.TargetFrameIndex;
+  TargetFrameTransferCharacteristic = rhs.TargetFrameTransferCharacteristic;
+  TargetFrameColorPrimaries = rhs.TargetFrameColorPrimaries;
+  TargetFrameComponentMaxRef = rhs.TargetFrameComponentMaxRef;
+  TargetFrameComponentMinRef = rhs.TargetFrameComponentMinRef;
+  TargetFrameEssenceStreamID = rhs.TargetFrameEssenceStreamID;
+  ACESPictureSubDescriptorInstanceID = rhs.ACESPictureSubDescriptorInstanceID;
+  TargetFrameViewingEnvironment = rhs.TargetFrameViewingEnvironment;
+}
+
+//
+void
+TargetFrameSubDescriptor::Dump(FILE* stream)
+{
+  char identbuf[IdentBufferLen];
+  *identbuf = 0;
+
+  if ( stream == 0 )
+    stream = stderr;
+
+  InterchangeObject::Dump(stream);
+  fprintf(stream, "  %22s = %s\n",  "TargetFrameAncillaryResourceID", TargetFrameAncillaryResourceID.EncodeString(identbuf, IdentBufferLen));
+  fprintf(stream, "  %22s = %s\n",  "MediaType", MediaType.EncodeString(identbuf, IdentBufferLen));
+  fprintf(stream, "  %22s = %s\n",  "TargetFrameIndex", i64sz(TargetFrameIndex, identbuf));
+  fprintf(stream, "  %22s = %s\n",  "TargetFrameTransferCharacteristic", TargetFrameTransferCharacteristic.EncodeString(identbuf, IdentBufferLen));
+  fprintf(stream, "  %22s = %s\n",  "TargetFrameColorPrimaries", TargetFrameColorPrimaries.EncodeString(identbuf, IdentBufferLen));
+  fprintf(stream, "  %22s = %d\n",  "TargetFrameComponentMaxRef", TargetFrameComponentMaxRef);
+  fprintf(stream, "  %22s = %d\n",  "TargetFrameComponentMinRef", TargetFrameComponentMinRef);
+  fprintf(stream, "  %22s = %d\n",  "TargetFrameEssenceStreamID", TargetFrameEssenceStreamID);
+  if ( ! ACESPictureSubDescriptorInstanceID.empty() ) {
+    fprintf(stream, "  %22s = %s\n",  "ACESPictureSubDescriptorInstanceID", ACESPictureSubDescriptorInstanceID.get().EncodeString(identbuf, IdentBufferLen));
+  }
+  if ( ! TargetFrameViewingEnvironment.empty() ) {
+    fprintf(stream, "  %22s = %s\n",  "TargetFrameViewingEnvironment", TargetFrameViewingEnvironment.get().EncodeString(identbuf, IdentBufferLen));
+  }
+}
+
+//
+ASDCP::Result_t
+TargetFrameSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
+{
+  return InterchangeObject::InitFromBuffer(p, l);
+}
+
+//
+ASDCP::Result_t
+TargetFrameSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
+{
+  return InterchangeObject::WriteToBuffer(Buffer);
+}
+
 //------------------------------------------------------------------------------------------
 // PHDRMetadataTrackSubDescriptor
 

diff --git a/src/Metadata.h b/src/Metadata.h
index 549c918064f567d2c4dbb084f727e1c6e3e4ccd0..b6cfb62f3729457ea504ff40d7540744af561c5c 100755 (executable)
--- a/src/Metadata.h
+++ b/src/Metadata.h
@@ -1043,6 +1043,65 @@ namespace ASDCP
       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
        };
 
+      //
+      class ACESPictureSubDescriptor : public InterchangeObject
+       {
+         ACESPictureSubDescriptor();
+
+       public:
+         const Dictionary*& m_Dict;
+          optional_property<UTF16String > ACESAuthoringInformation;
+          optional_property<ThreeColorPrimaries > ACESMasteringDisplayPrimaries;
+          optional_property<ColorPrimary > ACESMasteringDisplayWhitePointChromaticity;
+          optional_property<ui32_t > ACESMasteringDisplayMaximumLuminance;
+          optional_property<ui32_t > ACESMasteringDisplayMinimumLuminance;
+
+      ACESPictureSubDescriptor(const Dictionary*& d);
+      ACESPictureSubDescriptor(const ACESPictureSubDescriptor& rhs);
+      virtual ~ACESPictureSubDescriptor() {}
+
+      const ACESPictureSubDescriptor& operator=(const ACESPictureSubDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const ACESPictureSubDescriptor& rhs);
+      virtual const char* HasName() { return "ACESPictureSubDescriptor"; }
+      virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
+      virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
+      virtual void     Dump(FILE* = 0);
+      virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
+      virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
+       };
+
+      //
+      class TargetFrameSubDescriptor : public InterchangeObject
+       {
+         TargetFrameSubDescriptor();
+
+       public:
+         const Dictionary*& m_Dict;
+          UUID TargetFrameAncillaryResourceID;
+          UTF16String MediaType;
+          ui64_t TargetFrameIndex;
+          UL TargetFrameTransferCharacteristic;
+          UL TargetFrameColorPrimaries;
+          ui32_t TargetFrameComponentMaxRef;
+          ui32_t TargetFrameComponentMinRef;
+          ui32_t TargetFrameEssenceStreamID;
+          optional_property<UUID > ACESPictureSubDescriptorInstanceID;
+          optional_property<UL > TargetFrameViewingEnvironment;
+
+      TargetFrameSubDescriptor(const Dictionary*& d);
+      TargetFrameSubDescriptor(const TargetFrameSubDescriptor& rhs);
+      virtual ~TargetFrameSubDescriptor() {}
+
+      const TargetFrameSubDescriptor& operator=(const TargetFrameSubDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const TargetFrameSubDescriptor& rhs);
+      virtual const char* HasName() { return "TargetFrameSubDescriptor"; }
+      virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
+      virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
+      virtual void     Dump(FILE* = 0);
+      virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
+      virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
+       };
+
       //
       class PHDRMetadataTrackSubDescriptor : public InterchangeObject
        {