X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=src%2FMetadata.h;h=72ca7a55ff1e37291684318ee122a07a4259924c;hb=20c2f749a4593c418259bcf8b5f6f0775b70d910;hp=55f06d4c24ae459c0b25252a4f42903438f29986;hpb=02915821cfb49cb6851086f5d991cee58328102b;p=asdcplib.git

diff --git a/src/Metadata.h b/src/Metadata.h
index 55f06d4..72ca7a5 100755
--- a/src/Metadata.h
+++ b/src/Metadata.h
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2005-2015, John Hurst
+Copyright (c) 2005-2017, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -422,6 +422,8 @@ namespace ASDCP
           ui32_t QuantizationBits;
           optional_property<ui8_t > DialNorm;
           UL SoundEssenceCoding;
+          optional_property<ui8_t > ReferenceAudioAlignmentLevel;
+          optional_property<Rational > ReferenceImageEditRate;
 
       GenericSoundEssenceDescriptor(const Dictionary*& d);
       GenericSoundEssenceDescriptor(const GenericSoundEssenceDescriptor& rhs);
@@ -448,8 +450,6 @@ namespace ASDCP
           optional_property<ui8_t > SequenceOffset;
           ui32_t AvgBps;
           optional_property<UL > ChannelAssignment;
-          optional_property<Rational > ReferenceImageEditRate;
-          optional_property<ui8_t > ReferenceAudioAlignmentLevel;
 
       WaveAudioDescriptor(const Dictionary*& d);
       WaveAudioDescriptor(const WaveAudioDescriptor& rhs);
@@ -502,6 +502,11 @@ namespace ASDCP
           optional_property<ui32_t > ActiveHeight;
           optional_property<ui32_t > ActiveXOffset;
           optional_property<ui32_t > ActiveYOffset;
+          optional_property<LineMapPair > VideoLineMap;
+          optional_property<ThreeColorPrimaries > MasteringDisplayPrimaries;
+          optional_property<ColorPrimary > MasteringDisplayWhitePointChromaticity;
+          optional_property<ui32_t > MasteringDisplayMaximumLuminance;
+          optional_property<ui32_t > MasteringDisplayMinimumLuminance;
 
       GenericPictureEssenceDescriptor(const Dictionary*& d);
       GenericPictureEssenceDescriptor(const GenericPictureEssenceDescriptor& rhs);
@@ -529,6 +534,7 @@ namespace ASDCP
           optional_property<ui32_t > AlphaMinRef;
           optional_property<ui32_t > AlphaMaxRef;
           optional_property<ui8_t > ScanningDirection;
+          RGBALayout PixelLayout;
 
       RGBAEssenceDescriptor(const Dictionary*& d);
       RGBAEssenceDescriptor(const RGBAEssenceDescriptor& rhs);
@@ -565,6 +571,9 @@ namespace ASDCP
           optional_property<Raw > CodingStyleDefault;
           optional_property<Raw > QuantizationDefault;
           optional_property<RGBALayout > J2CLayout;
+          optional_property<J2KExtendedCapabilities > J2KExtendedCapabilities;
+          optional_property<Array<Kumu::ArchivableUi16> > J2KProfile;
+          optional_property<ui16_t > J2KCorrespondingProfile;
 
       JPEG2000PictureSubDescriptor(const Dictionary*& d);
       JPEG2000PictureSubDescriptor(const JPEG2000PictureSubDescriptor& rhs);
@@ -652,9 +661,9 @@ namespace ASDCP
 	public:
 	  const Dictionary*& m_Dict;
           UL DataDefinition;
-          ui64_t EventStartPosition;
-          ui64_t Duration;
-          UTF16String EventComment;
+          optional_property<ui64_t > Duration;
+          optional_property<ui64_t > EventStartPosition;
+          optional_property<UTF16String > EventComment;
           UUID DMFramework;
 
       DMSegment(const Dictionary*& d);
@@ -721,6 +730,52 @@ namespace ASDCP
       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 	};
 
+      //
+      class DescriptiveFramework : public InterchangeObject
+	{
+	  DescriptiveFramework();
+
+	public:
+	  const Dictionary*& m_Dict;
+          optional_property<UUID > LinkedDescriptiveFrameworkPlugInId;
+
+      DescriptiveFramework(const Dictionary*& d);
+      DescriptiveFramework(const DescriptiveFramework& rhs);
+      virtual ~DescriptiveFramework() {}
+
+      const DescriptiveFramework& operator=(const DescriptiveFramework& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const DescriptiveFramework& rhs);
+      virtual const char* HasName() { return "DescriptiveFramework"; }
+      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 DescriptiveObject : public InterchangeObject
+	{
+	  DescriptiveObject();
+
+	public:
+	  const Dictionary*& m_Dict;
+          optional_property<UUID > LinkedDescriptiveObjectPlugInId;
+
+      DescriptiveObject(const Dictionary*& d);
+      DescriptiveObject(const DescriptiveObject& rhs);
+      virtual ~DescriptiveObject() {}
+
+      const DescriptiveObject& operator=(const DescriptiveObject& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const DescriptiveObject& rhs);
+      virtual const char* HasName() { return "DescriptiveObject"; }
+      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 GenericDataEssenceDescriptor : public FileDescriptor
 	{
@@ -875,6 +930,14 @@ namespace ASDCP
           optional_property<UTF16String > MCATagName;
           optional_property<ui32_t > MCAChannelID;
           optional_property<ISO8String > RFC5646SpokenLanguage;
+          optional_property<UTF16String > MCATitle;
+          optional_property<UTF16String > MCATitleVersion;
+          optional_property<UTF16String > MCATitleSubVersion;
+          optional_property<UTF16String > MCAEpisode;
+          optional_property<UTF16String > MCAPartitionKind;
+          optional_property<UTF16String > MCAPartitionNumber;
+          optional_property<UTF16String > MCAAudioContentKind;
+          optional_property<UTF16String > MCAAudioElementKind;
 
       MCALabelSubDescriptor(const Dictionary*& d);
       MCALabelSubDescriptor(const MCALabelSubDescriptor& rhs);
@@ -980,6 +1043,28 @@ namespace ASDCP
       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 	};
 
+      //
+      class PrivateDCDataDescriptor : public GenericDataEssenceDescriptor
+	{
+	  PrivateDCDataDescriptor();
+
+	public:
+	  const Dictionary*& m_Dict;
+
+      PrivateDCDataDescriptor(const Dictionary*& d);
+      PrivateDCDataDescriptor(const PrivateDCDataDescriptor& rhs);
+      virtual ~PrivateDCDataDescriptor() {}
+
+      const PrivateDCDataDescriptor& operator=(const PrivateDCDataDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const PrivateDCDataDescriptor& rhs);
+      virtual const char* HasName() { return "PrivateDCDataDescriptor"; }
+      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 DolbyAtmosSubDescriptor : public InterchangeObject
 	{
@@ -1007,6 +1092,160 @@ 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 TextBasedDMFramework : public DescriptiveFramework
+	{
+	  TextBasedDMFramework();
+
+	public:
+	  const Dictionary*& m_Dict;
+          optional_property<UUID > ObjectRef;
+
+      TextBasedDMFramework(const Dictionary*& d);
+      TextBasedDMFramework(const TextBasedDMFramework& rhs);
+      virtual ~TextBasedDMFramework() {}
+
+      const TextBasedDMFramework& operator=(const TextBasedDMFramework& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const TextBasedDMFramework& rhs);
+      virtual const char* HasName() { return "TextBasedDMFramework"; }
+      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 TextBasedObject : public DescriptiveObject
+	{
+	  TextBasedObject();
+
+	public:
+	  const Dictionary*& m_Dict;
+          UL PayloadSchemeID;
+          UTF16String TextMIMEMediaType;
+          UTF16String RFC5646TextLanguageCode;
+          optional_property<UTF16String > TextDataDescription;
+
+      TextBasedObject(const Dictionary*& d);
+      TextBasedObject(const TextBasedObject& rhs);
+      virtual ~TextBasedObject() {}
+
+      const TextBasedObject& operator=(const TextBasedObject& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const TextBasedObject& rhs);
+      virtual const char* HasName() { return "TextBasedObject"; }
+      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 GenericStreamTextBasedSet : public TextBasedObject
+	{
+	  GenericStreamTextBasedSet();
+
+	public:
+	  const Dictionary*& m_Dict;
+          ui32_t GenericStreamSID;
+
+      GenericStreamTextBasedSet(const Dictionary*& d);
+      GenericStreamTextBasedSet(const GenericStreamTextBasedSet& rhs);
+      virtual ~GenericStreamTextBasedSet() {}
+
+      const GenericStreamTextBasedSet& operator=(const GenericStreamTextBasedSet& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const GenericStreamTextBasedSet& rhs);
+      virtual const char* HasName() { return "GenericStreamTextBasedSet"; }
+      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 ISXDDataEssenceDescriptor : public GenericDataEssenceDescriptor
+	{
+	  ISXDDataEssenceDescriptor();
+
+	public:
+	  const Dictionary*& m_Dict;
+          ISO8String NamespaceURI;
+
+      ISXDDataEssenceDescriptor(const Dictionary*& d);
+      ISXDDataEssenceDescriptor(const ISXDDataEssenceDescriptor& rhs);
+      virtual ~ISXDDataEssenceDescriptor() {}
+
+      const ISXDDataEssenceDescriptor& operator=(const ISXDDataEssenceDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const ISXDDataEssenceDescriptor& rhs);
+      virtual const char* HasName() { return "ISXDDataEssenceDescriptor"; }
+      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
 	{
@@ -1032,6 +1271,29 @@ namespace ASDCP
       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 	};
 
+      //
+      class PIMFDynamicMetadataDescriptor : public GenericDataEssenceDescriptor
+	{
+	  PIMFDynamicMetadataDescriptor();
+
+	public:
+	  const Dictionary*& m_Dict;
+          ui32_t GlobalPayloadSID;
+
+      PIMFDynamicMetadataDescriptor(const Dictionary*& d);
+      PIMFDynamicMetadataDescriptor(const PIMFDynamicMetadataDescriptor& rhs);
+      virtual ~PIMFDynamicMetadataDescriptor() {}
+
+      const PIMFDynamicMetadataDescriptor& operator=(const PIMFDynamicMetadataDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const PIMFDynamicMetadataDescriptor& rhs);
+      virtual const char* HasName() { return "PIMFDynamicMetadataDescriptor"; }
+      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&);
+	};
+
     } // namespace MXF
 } // namespace ASDCP