/*
-Copyright (c) 2005-2006, John Hurst
+Copyright (c) 2005-2012, John Hurst
All rights reserved.
Redistribution and use in source and binary forms, with or without
\brief MXF metadata objects
*/
-#ifndef _METADATA_H_
-#define _METADATA_H_
+#ifndef _Metadata_H_
+#define _Metadata_H_
#include "MXF.h"
{
namespace MXF
{
+ void Metadata_InitTypes(const Dictionary*& Dict);
+
//
//
class Identification : public InterchangeObject
{
- ASDCP_NO_COPY_CONSTRUCT(Identification);
+ Identification();
public:
+ const Dictionary*& m_Dict;
UUID ThisGenerationUID;
UTF16String CompanyName;
UTF16String ProductName;
VersionType ProductVersion;
UTF16String VersionString;
UUID ProductUID;
- Timestamp ModificationDate;
+ Kumu::Timestamp ModificationDate;
VersionType ToolkitVersion;
- UTF16String Platform;
-
- Identification() {}
- virtual ~Identification() {}
- virtual const char* HasName() { return "Identification"; }
- 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&);
+ optional_property<UTF16String> Platform;
+
+ Identification(const Dictionary*& d);
+ Identification(const Identification& rhs);
+ virtual ~Identification() {}
+
+ const Identification& operator=(const Identification& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const Identification& rhs);
+ virtual const char* HasName() { return "Identification"; }
+ 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 ContentStorage : public InterchangeObject
{
- ASDCP_NO_COPY_CONSTRUCT(ContentStorage);
+ ContentStorage();
public:
+ const Dictionary*& m_Dict;
Batch<UUID> Packages;
Batch<UUID> EssenceContainerData;
- ContentStorage() {}
- virtual ~ContentStorage() {}
- virtual const char* HasName() { return "ContentStorage"; }
- 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&);
+ ContentStorage(const Dictionary*& d);
+ ContentStorage(const ContentStorage& rhs);
+ virtual ~ContentStorage() {}
+
+ const ContentStorage& operator=(const ContentStorage& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const ContentStorage& rhs);
+ virtual const char* HasName() { return "ContentStorage"; }
+ 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 EssenceContainerData : public InterchangeObject
{
- ASDCP_NO_COPY_CONSTRUCT(EssenceContainerData);
+ EssenceContainerData();
public:
+ const Dictionary*& m_Dict;
UMID LinkedPackageUID;
- ui32_t IndexSID;
+ optional_property<ui32_t> IndexSID;
ui32_t BodySID;
- EssenceContainerData() : IndexSID(0), BodySID(0) {}
- virtual ~EssenceContainerData() {}
- virtual const char* HasName() { return "EssenceContainerData"; }
- 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&);
+ EssenceContainerData(const Dictionary*& d);
+ EssenceContainerData(const EssenceContainerData& rhs);
+ virtual ~EssenceContainerData() {}
+
+ const EssenceContainerData& operator=(const EssenceContainerData& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const EssenceContainerData& rhs);
+ virtual const char* HasName() { return "EssenceContainerData"; }
+ 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 GenericPackage : public InterchangeObject
{
- ASDCP_NO_COPY_CONSTRUCT(GenericPackage);
+ GenericPackage();
public:
+ const Dictionary*& m_Dict;
UMID PackageUID;
- UTF16String Name;
- Timestamp PackageCreationDate;
- Timestamp PackageModifiedDate;
+ optional_property<UTF16String> Name;
+ Kumu::Timestamp PackageCreationDate;
+ Kumu::Timestamp PackageModifiedDate;
Batch<UUID> Tracks;
- GenericPackage() {}
- virtual ~GenericPackage() {}
- virtual const char* HasName() { return "GenericPackage"; }
- virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
- virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
- virtual void Dump(FILE* = 0);
+ GenericPackage(const Dictionary*& d);
+ GenericPackage(const GenericPackage& rhs);
+ virtual ~GenericPackage() {}
+
+ const GenericPackage& operator=(const GenericPackage& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const GenericPackage& rhs);
+ virtual const char* HasName() { return "GenericPackage"; }
+ virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
+ virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
+ virtual void Dump(FILE* = 0);
};
//
class MaterialPackage : public GenericPackage
{
- ASDCP_NO_COPY_CONSTRUCT(MaterialPackage);
+ MaterialPackage();
public:
-
- MaterialPackage() {}
- virtual ~MaterialPackage() {}
- virtual const char* HasName() { return "MaterialPackage"; }
- 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&);
+ const Dictionary*& m_Dict;
+ optional_property<UUID> PackageMarker;
+
+ MaterialPackage(const Dictionary*& d);
+ MaterialPackage(const MaterialPackage& rhs);
+ virtual ~MaterialPackage() {}
+
+ const MaterialPackage& operator=(const MaterialPackage& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const MaterialPackage& rhs);
+ virtual const char* HasName() { return "MaterialPackage"; }
+ 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 SourcePackage : public GenericPackage
{
- ASDCP_NO_COPY_CONSTRUCT(SourcePackage);
+ SourcePackage();
public:
+ const Dictionary*& m_Dict;
UUID Descriptor;
- SourcePackage() {}
- virtual ~SourcePackage() {}
- virtual const char* HasName() { return "SourcePackage"; }
- 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&);
+ SourcePackage(const Dictionary*& d);
+ SourcePackage(const SourcePackage& rhs);
+ virtual ~SourcePackage() {}
+
+ const SourcePackage& operator=(const SourcePackage& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const SourcePackage& rhs);
+ virtual const char* HasName() { return "SourcePackage"; }
+ 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 GenericTrack : public InterchangeObject
{
- ASDCP_NO_COPY_CONSTRUCT(GenericTrack);
+ GenericTrack();
public:
+ const Dictionary*& m_Dict;
ui32_t TrackID;
ui32_t TrackNumber;
- UTF16String TrackName;
- UUID Sequence;
-
- GenericTrack() : TrackID(0), TrackNumber(0) {}
- virtual ~GenericTrack() {}
- virtual const char* HasName() { return "GenericTrack"; }
- virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
- virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
- virtual void Dump(FILE* = 0);
+ optional_property<UTF16String> TrackName;
+ optional_property<UUID> Sequence;
+
+ GenericTrack(const Dictionary*& d);
+ GenericTrack(const GenericTrack& rhs);
+ virtual ~GenericTrack() {}
+
+ const GenericTrack& operator=(const GenericTrack& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const GenericTrack& rhs);
+ virtual const char* HasName() { return "GenericTrack"; }
+ virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
+ virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
+ virtual void Dump(FILE* = 0);
};
//
class StaticTrack : public GenericTrack
{
- ASDCP_NO_COPY_CONSTRUCT(StaticTrack);
+ StaticTrack();
public:
-
- StaticTrack() {}
- virtual ~StaticTrack() {}
- virtual const char* HasName() { return "StaticTrack"; }
- 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&);
+ const Dictionary*& m_Dict;
+
+ StaticTrack(const Dictionary*& d);
+ StaticTrack(const StaticTrack& rhs);
+ virtual ~StaticTrack() {}
+
+ const StaticTrack& operator=(const StaticTrack& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const StaticTrack& rhs);
+ virtual const char* HasName() { return "StaticTrack"; }
+ 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 Track : public GenericTrack
{
- ASDCP_NO_COPY_CONSTRUCT(Track);
+ Track();
public:
+ const Dictionary*& m_Dict;
Rational EditRate;
ui64_t Origin;
- Track() : Origin(0) {}
- virtual ~Track() {}
- virtual const char* HasName() { return "Track"; }
- 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&);
+ Track(const Dictionary*& d);
+ Track(const Track& rhs);
+ virtual ~Track() {}
+
+ const Track& operator=(const Track& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const Track& rhs);
+ virtual const char* HasName() { return "Track"; }
+ 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 StructuralComponent : public InterchangeObject
{
- ASDCP_NO_COPY_CONSTRUCT(StructuralComponent);
+ StructuralComponent();
public:
+ const Dictionary*& m_Dict;
UL DataDefinition;
- ui64_t Duration;
-
- StructuralComponent() : Duration(0) {}
- virtual ~StructuralComponent() {}
- virtual const char* HasName() { return "StructuralComponent"; }
- virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
- virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
- virtual void Dump(FILE* = 0);
+ optional_property<ui64_t> Duration;
+
+ StructuralComponent(const Dictionary*& d);
+ StructuralComponent(const StructuralComponent& rhs);
+ virtual ~StructuralComponent() {}
+
+ const StructuralComponent& operator=(const StructuralComponent& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const StructuralComponent& rhs);
+ virtual const char* HasName() { return "StructuralComponent"; }
+ virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
+ virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
+ virtual void Dump(FILE* = 0);
};
//
class Sequence : public StructuralComponent
{
- ASDCP_NO_COPY_CONSTRUCT(Sequence);
+ Sequence();
public:
+ const Dictionary*& m_Dict;
Batch<UUID> StructuralComponents;
- Sequence() {}
- virtual ~Sequence() {}
- virtual const char* HasName() { return "Sequence"; }
- 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&);
+ Sequence(const Dictionary*& d);
+ Sequence(const Sequence& rhs);
+ virtual ~Sequence() {}
+
+ const Sequence& operator=(const Sequence& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const Sequence& rhs);
+ virtual const char* HasName() { return "Sequence"; }
+ 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 SourceClip : public StructuralComponent
{
- ASDCP_NO_COPY_CONSTRUCT(SourceClip);
+ SourceClip();
public:
+ const Dictionary*& m_Dict;
ui64_t StartPosition;
UMID SourcePackageID;
ui32_t SourceTrackID;
- SourceClip() : StartPosition(0), SourceTrackID(0) {}
- virtual ~SourceClip() {}
- virtual const char* HasName() { return "SourceClip"; }
- 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&);
+ SourceClip(const Dictionary*& d);
+ SourceClip(const SourceClip& rhs);
+ virtual ~SourceClip() {}
+
+ const SourceClip& operator=(const SourceClip& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const SourceClip& rhs);
+ virtual const char* HasName() { return "SourceClip"; }
+ 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 TimecodeComponent : public StructuralComponent
{
- ASDCP_NO_COPY_CONSTRUCT(TimecodeComponent);
+ TimecodeComponent();
public:
+ const Dictionary*& m_Dict;
ui16_t RoundedTimecodeBase;
ui64_t StartTimecode;
ui8_t DropFrame;
- TimecodeComponent() : RoundedTimecodeBase(0), StartTimecode(0), DropFrame(0) {}
- virtual ~TimecodeComponent() {}
- virtual const char* HasName() { return "TimecodeComponent"; }
- 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&);
+ TimecodeComponent(const Dictionary*& d);
+ TimecodeComponent(const TimecodeComponent& rhs);
+ virtual ~TimecodeComponent() {}
+
+ const TimecodeComponent& operator=(const TimecodeComponent& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const TimecodeComponent& rhs);
+ virtual const char* HasName() { return "TimecodeComponent"; }
+ 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 GenericDescriptor : public InterchangeObject
{
- ASDCP_NO_COPY_CONSTRUCT(GenericDescriptor);
+ GenericDescriptor();
public:
+ const Dictionary*& m_Dict;
Batch<UUID> Locators;
Batch<UUID> SubDescriptors;
- GenericDescriptor() {}
- virtual ~GenericDescriptor() {}
- virtual const char* HasName() { return "GenericDescriptor"; }
- virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
- virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
- virtual void Dump(FILE* = 0);
+ GenericDescriptor(const Dictionary*& d);
+ GenericDescriptor(const GenericDescriptor& rhs);
+ virtual ~GenericDescriptor() {}
+
+ const GenericDescriptor& operator=(const GenericDescriptor& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const GenericDescriptor& rhs);
+ virtual const char* HasName() { return "GenericDescriptor"; }
+ virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
+ virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
+ virtual void Dump(FILE* = 0);
};
//
class FileDescriptor : public GenericDescriptor
{
- ASDCP_NO_COPY_CONSTRUCT(FileDescriptor);
+ FileDescriptor();
public:
- ui32_t LinkedTrackID;
+ const Dictionary*& m_Dict;
+ optional_property<ui32_t> LinkedTrackID;
Rational SampleRate;
- ui64_t ContainerDuration;
+ optional_property<ui64_t> ContainerDuration;
UL EssenceContainer;
- UL Codec;
-
- FileDescriptor() : LinkedTrackID(0), ContainerDuration(0) {}
- virtual ~FileDescriptor() {}
- virtual const char* HasName() { return "FileDescriptor"; }
- 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&);
+ optional_property<UL> Codec;
+
+ FileDescriptor(const Dictionary*& d);
+ FileDescriptor(const FileDescriptor& rhs);
+ virtual ~FileDescriptor() {}
+
+ const FileDescriptor& operator=(const FileDescriptor& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const FileDescriptor& rhs);
+ virtual const char* HasName() { return "FileDescriptor"; }
+ 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 GenericSoundEssenceDescriptor : public FileDescriptor
{
- ASDCP_NO_COPY_CONSTRUCT(GenericSoundEssenceDescriptor);
+ GenericSoundEssenceDescriptor();
public:
+ const Dictionary*& m_Dict;
Rational AudioSamplingRate;
ui8_t Locked;
- ui8_t AudioRefLevel;
+ optional_property<ui8_t> AudioRefLevel;
+ optional_property<ui8_t> ElectroSpatialFormulation;
ui32_t ChannelCount;
ui32_t QuantizationBits;
- ui8_t DialNorm;
-
- GenericSoundEssenceDescriptor() : Locked(0), AudioRefLevel(0), ChannelCount(0), QuantizationBits(0), DialNorm(0) {}
- virtual ~GenericSoundEssenceDescriptor() {}
- virtual const char* HasName() { return "GenericSoundEssenceDescriptor"; }
- 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&);
+ optional_property<ui8_t> DialNorm;
+ UL SoundEssenceCoding;
+
+ GenericSoundEssenceDescriptor(const Dictionary*& d);
+ GenericSoundEssenceDescriptor(const GenericSoundEssenceDescriptor& rhs);
+ virtual ~GenericSoundEssenceDescriptor() {}
+
+ const GenericSoundEssenceDescriptor& operator=(const GenericSoundEssenceDescriptor& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const GenericSoundEssenceDescriptor& rhs);
+ virtual const char* HasName() { return "GenericSoundEssenceDescriptor"; }
+ 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 WaveAudioDescriptor : public GenericSoundEssenceDescriptor
{
- ASDCP_NO_COPY_CONSTRUCT(WaveAudioDescriptor);
+ WaveAudioDescriptor();
public:
+ const Dictionary*& m_Dict;
ui16_t BlockAlign;
- ui8_t SequenceOffset;
+ optional_property<ui8_t> SequenceOffset;
ui32_t AvgBps;
-
- WaveAudioDescriptor() : BlockAlign(0), SequenceOffset(0), AvgBps(0) {}
- virtual ~WaveAudioDescriptor() {}
- virtual const char* HasName() { return "WaveAudioDescriptor"; }
- 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&);
+ optional_property<UL> ChannelAssignment;
+ optional_property<Rational> ReferenceImageEditRate;
+ optional_property<ui8_t> ReferenceAudioAlignmentLevel;
+
+ WaveAudioDescriptor(const Dictionary*& d);
+ WaveAudioDescriptor(const WaveAudioDescriptor& rhs);
+ virtual ~WaveAudioDescriptor() {}
+
+ const WaveAudioDescriptor& operator=(const WaveAudioDescriptor& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const WaveAudioDescriptor& rhs);
+ virtual const char* HasName() { return "WaveAudioDescriptor"; }
+ 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 GenericPictureEssenceDescriptor : public FileDescriptor
{
- ASDCP_NO_COPY_CONSTRUCT(GenericPictureEssenceDescriptor);
+ GenericPictureEssenceDescriptor();
public:
+ const Dictionary*& m_Dict;
+ optional_property<ui8_t> SignalStandard;
ui8_t FrameLayout;
ui32_t StoredWidth;
ui32_t StoredHeight;
+ optional_property<ui32_t> StoredF2Offset;
+ optional_property<ui32_t> SampledWidth;
+ optional_property<ui32_t> SampledHeight;
+ optional_property<ui32_t> SampledXOffset;
+ optional_property<ui32_t> SampledYOffset;
+ optional_property<ui32_t> DisplayHeight;
+ optional_property<ui32_t> DisplayWidth;
+ optional_property<ui32_t> DisplayXOffset;
+ optional_property<ui32_t> DisplayYOffset;
+ optional_property<ui32_t> DisplayF2Offset;
Rational AspectRatio;
-
- GenericPictureEssenceDescriptor() : FrameLayout(0), StoredWidth(0), StoredHeight(0) {}
- virtual ~GenericPictureEssenceDescriptor() {}
- virtual const char* HasName() { return "GenericPictureEssenceDescriptor"; }
- 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&);
+ optional_property<ui8_t> ActiveFormatDescriptor;
+ optional_property<ui8_t> AlphaTransparency;
+ optional_property<UL> TransferCharacteristic;
+ optional_property<ui32_t> ImageAlignmentOffset;
+ optional_property<ui32_t> ImageStartOffset;
+ optional_property<ui32_t> ImageEndOffset;
+ optional_property<ui8_t> FieldDominance;
+ UL PictureEssenceCoding;
+ optional_property<UL> CodingEquations;
+ optional_property<UL> ColorPrimaries;
+ Batch<UL> AlternativeCenterCuts;
+ optional_property<ui32_t> ActiveWidth;
+ optional_property<ui32_t> ActiveHeight;
+ optional_property<ui32_t> ActiveXOffset;
+ optional_property<ui32_t> ActiveYOffset;
+
+ GenericPictureEssenceDescriptor(const Dictionary*& d);
+ GenericPictureEssenceDescriptor(const GenericPictureEssenceDescriptor& rhs);
+ virtual ~GenericPictureEssenceDescriptor() {}
+
+ const GenericPictureEssenceDescriptor& operator=(const GenericPictureEssenceDescriptor& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const GenericPictureEssenceDescriptor& rhs);
+ virtual const char* HasName() { return "GenericPictureEssenceDescriptor"; }
+ 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 RGBAEssenceDescriptor : public GenericPictureEssenceDescriptor
{
- ASDCP_NO_COPY_CONSTRUCT(RGBAEssenceDescriptor);
+ RGBAEssenceDescriptor();
public:
- ui32_t ComponentMaxRef;
- ui32_t ComponentMinRef;
- RGBLayout PixelLayout;
-
- RGBAEssenceDescriptor() : ComponentMaxRef(0), ComponentMinRef(0) {}
- virtual ~RGBAEssenceDescriptor() {}
- virtual const char* HasName() { return "RGBAEssenceDescriptor"; }
- 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&);
+ const Dictionary*& m_Dict;
+ optional_property<ui32_t> ComponentMaxRef;
+ optional_property<ui32_t> ComponentMinRef;
+ optional_property<ui32_t> AlphaMinRef;
+ optional_property<ui32_t> AlphaMaxRef;
+ optional_property<ui8_t> ScanningDirection;
+
+ RGBAEssenceDescriptor(const Dictionary*& d);
+ RGBAEssenceDescriptor(const RGBAEssenceDescriptor& rhs);
+ virtual ~RGBAEssenceDescriptor() {}
+
+ const RGBAEssenceDescriptor& operator=(const RGBAEssenceDescriptor& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const RGBAEssenceDescriptor& rhs);
+ virtual const char* HasName() { return "RGBAEssenceDescriptor"; }
+ 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 JPEG2000PictureSubDescriptor : public InterchangeObject
{
- ASDCP_NO_COPY_CONSTRUCT(JPEG2000PictureSubDescriptor);
+ JPEG2000PictureSubDescriptor();
public:
+ const Dictionary*& m_Dict;
ui16_t Rsize;
ui32_t Xsize;
ui32_t Ysize;
ui32_t XTOsize;
ui32_t YTOsize;
ui16_t Csize;
- Raw PictureComponentSizing;
- Raw CodingStyleDefault;
- Raw QuantizationDefault;
-
- JPEG2000PictureSubDescriptor() : Rsize(0), Xsize(0), Ysize(0), XOsize(0), YOsize(0), XTsize(0), YTsize(0), XTOsize(0), YTOsize(0), Csize(0) {}
- virtual ~JPEG2000PictureSubDescriptor() {}
- virtual const char* HasName() { return "JPEG2000PictureSubDescriptor"; }
- 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&);
+ optional_property<Raw> PictureComponentSizing;
+ optional_property<Raw> CodingStyleDefault;
+ optional_property<Raw> QuantizationDefault;
+
+ JPEG2000PictureSubDescriptor(const Dictionary*& d);
+ JPEG2000PictureSubDescriptor(const JPEG2000PictureSubDescriptor& rhs);
+ virtual ~JPEG2000PictureSubDescriptor() {}
+
+ const JPEG2000PictureSubDescriptor& operator=(const JPEG2000PictureSubDescriptor& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const JPEG2000PictureSubDescriptor& rhs);
+ virtual const char* HasName() { return "JPEG2000PictureSubDescriptor"; }
+ 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 CDCIEssenceDescriptor : public GenericPictureEssenceDescriptor
{
- ASDCP_NO_COPY_CONSTRUCT(CDCIEssenceDescriptor);
+ CDCIEssenceDescriptor();
public:
+ const Dictionary*& m_Dict;
ui32_t ComponentDepth;
ui32_t HorizontalSubsampling;
- ui32_t VerticalSubsampling;
- ui8_t ColorSiting;
-
- CDCIEssenceDescriptor() : ComponentDepth(0), HorizontalSubsampling(0), VerticalSubsampling(0), ColorSiting(0) {}
- virtual ~CDCIEssenceDescriptor() {}
- virtual const char* HasName() { return "CDCIEssenceDescriptor"; }
- 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&);
+ optional_property<ui32_t> VerticalSubsampling;
+ optional_property<ui8_t> ColorSiting;
+ optional_property<ui8_t> ReversedByteOrder;
+ optional_property<ui16_t> PaddingBits;
+ optional_property<ui32_t> AlphaSampleDepth;
+ optional_property<ui32_t> BlackRefLevel;
+ optional_property<ui32_t> WhiteReflevel;
+ optional_property<ui32_t> ColorRange;
+
+ CDCIEssenceDescriptor(const Dictionary*& d);
+ CDCIEssenceDescriptor(const CDCIEssenceDescriptor& rhs);
+ virtual ~CDCIEssenceDescriptor() {}
+
+ const CDCIEssenceDescriptor& operator=(const CDCIEssenceDescriptor& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const CDCIEssenceDescriptor& rhs);
+ virtual const char* HasName() { return "CDCIEssenceDescriptor"; }
+ 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 MPEG2VideoDescriptor : public CDCIEssenceDescriptor
{
- ASDCP_NO_COPY_CONSTRUCT(MPEG2VideoDescriptor);
+ MPEG2VideoDescriptor();
public:
- ui8_t CodedContentType;
- ui8_t LowDelay;
- ui32_t BitRate;
- ui8_t ProfileAndLevel;
-
- MPEG2VideoDescriptor() : CodedContentType(0), LowDelay(0), BitRate(0), ProfileAndLevel(0) {}
- virtual ~MPEG2VideoDescriptor() {}
- virtual const char* HasName() { return "MPEG2VideoDescriptor"; }
- 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&);
+ const Dictionary*& m_Dict;
+ optional_property<ui8_t> SingleSequence;
+ optional_property<ui8_t> ConstantBFrames;
+ optional_property<ui8_t> CodedContentType;
+ optional_property<ui8_t> LowDelay;
+ optional_property<ui8_t> ClosedGOP;
+ optional_property<ui8_t> IdenticalGOP;
+ optional_property<ui8_t> MaxGOP;
+ optional_property<ui8_t> BPictureCount;
+ optional_property<ui32_t> BitRate;
+ optional_property<ui8_t> ProfileAndLevel;
+
+ MPEG2VideoDescriptor(const Dictionary*& d);
+ MPEG2VideoDescriptor(const MPEG2VideoDescriptor& rhs);
+ virtual ~MPEG2VideoDescriptor() {}
+
+ const MPEG2VideoDescriptor& operator=(const MPEG2VideoDescriptor& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const MPEG2VideoDescriptor& rhs);
+ virtual const char* HasName() { return "MPEG2VideoDescriptor"; }
+ 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 DMSegment : public InterchangeObject
{
- ASDCP_NO_COPY_CONSTRUCT(DMSegment);
+ DMSegment();
public:
+ const Dictionary*& m_Dict;
+ UL DataDefinition;
ui64_t EventStartPosition;
+ ui64_t Duration;
UTF16String EventComment;
UUID DMFramework;
- DMSegment() : EventStartPosition(0) {}
- virtual ~DMSegment() {}
- virtual const char* HasName() { return "DMSegment"; }
- 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&);
+ DMSegment(const Dictionary*& d);
+ DMSegment(const DMSegment& rhs);
+ virtual ~DMSegment() {}
+
+ const DMSegment& operator=(const DMSegment& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const DMSegment& rhs);
+ virtual const char* HasName() { return "DMSegment"; }
+ 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 CryptographicFramework : public InterchangeObject
{
- ASDCP_NO_COPY_CONSTRUCT(CryptographicFramework);
+ CryptographicFramework();
public:
+ const Dictionary*& m_Dict;
UUID ContextSR;
- CryptographicFramework() {}
- virtual ~CryptographicFramework() {}
- virtual const char* HasName() { return "CryptographicFramework"; }
- 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&);
+ CryptographicFramework(const Dictionary*& d);
+ CryptographicFramework(const CryptographicFramework& rhs);
+ virtual ~CryptographicFramework() {}
+
+ const CryptographicFramework& operator=(const CryptographicFramework& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const CryptographicFramework& rhs);
+ virtual const char* HasName() { return "CryptographicFramework"; }
+ 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 CryptographicContext : public InterchangeObject
{
- ASDCP_NO_COPY_CONSTRUCT(CryptographicContext);
+ CryptographicContext();
public:
+ const Dictionary*& m_Dict;
UUID ContextID;
UL SourceEssenceContainer;
UL CipherAlgorithm;
UL MICAlgorithm;
UUID CryptographicKeyID;
- CryptographicContext() {}
- virtual ~CryptographicContext() {}
- virtual const char* HasName() { return "CryptographicContext"; }
- 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&);
+ CryptographicContext(const Dictionary*& d);
+ CryptographicContext(const CryptographicContext& rhs);
+ virtual ~CryptographicContext() {}
+
+ const CryptographicContext& operator=(const CryptographicContext& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const CryptographicContext& rhs);
+ virtual const char* HasName() { return "CryptographicContext"; }
+ 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
+ {
+ GenericDataEssenceDescriptor();
+
+ public:
+ const Dictionary*& m_Dict;
+ UL DataEssenceCoding;
+
+ GenericDataEssenceDescriptor(const Dictionary*& d);
+ GenericDataEssenceDescriptor(const GenericDataEssenceDescriptor& rhs);
+ virtual ~GenericDataEssenceDescriptor() {}
+
+ const GenericDataEssenceDescriptor& operator=(const GenericDataEssenceDescriptor& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const GenericDataEssenceDescriptor& rhs);
+ virtual const char* HasName() { return "GenericDataEssenceDescriptor"; }
+ 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 TimedTextDescriptor : public GenericDataEssenceDescriptor
+ {
+ TimedTextDescriptor();
+
+ public:
+ const Dictionary*& m_Dict;
+ UUID ResourceID;
+ UTF16String UCSEncoding;
+ UTF16String NamespaceURI;
+ optional_property<UTF16String> RFC5646LanguageTagList;
+
+ TimedTextDescriptor(const Dictionary*& d);
+ TimedTextDescriptor(const TimedTextDescriptor& rhs);
+ virtual ~TimedTextDescriptor() {}
+
+ const TimedTextDescriptor& operator=(const TimedTextDescriptor& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const TimedTextDescriptor& rhs);
+ virtual const char* HasName() { return "TimedTextDescriptor"; }
+ 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 TimedTextResourceSubDescriptor : public InterchangeObject
+ {
+ TimedTextResourceSubDescriptor();
+
+ public:
+ const Dictionary*& m_Dict;
+ UUID AncillaryResourceID;
+ UTF16String MIMEMediaType;
+ ui32_t EssenceStreamID;
+
+ TimedTextResourceSubDescriptor(const Dictionary*& d);
+ TimedTextResourceSubDescriptor(const TimedTextResourceSubDescriptor& rhs);
+ virtual ~TimedTextResourceSubDescriptor() {}
+
+ const TimedTextResourceSubDescriptor& operator=(const TimedTextResourceSubDescriptor& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const TimedTextResourceSubDescriptor& rhs);
+ virtual const char* HasName() { return "TimedTextResourceSubDescriptor"; }
+ 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 StereoscopicPictureSubDescriptor : public InterchangeObject
+ {
+ StereoscopicPictureSubDescriptor();
+
+ public:
+ const Dictionary*& m_Dict;
+
+ StereoscopicPictureSubDescriptor(const Dictionary*& d);
+ StereoscopicPictureSubDescriptor(const StereoscopicPictureSubDescriptor& rhs);
+ virtual ~StereoscopicPictureSubDescriptor() {}
+
+ const StereoscopicPictureSubDescriptor& operator=(const StereoscopicPictureSubDescriptor& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const StereoscopicPictureSubDescriptor& rhs);
+ virtual const char* HasName() { return "StereoscopicPictureSubDescriptor"; }
+ 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 NetworkLocator : public InterchangeObject
+ {
+ NetworkLocator();
+
+ public:
+ const Dictionary*& m_Dict;
+ UTF16String URLString;
+
+ NetworkLocator(const Dictionary*& d);
+ NetworkLocator(const NetworkLocator& rhs);
+ virtual ~NetworkLocator() {}
+
+ const NetworkLocator& operator=(const NetworkLocator& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const NetworkLocator& rhs);
+ virtual const char* HasName() { return "NetworkLocator"; }
+ 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 MCALabelSubDescriptor : public InterchangeObject
+ {
+ MCALabelSubDescriptor();
+
+ public:
+ const Dictionary*& m_Dict;
+ UL MCALabelDictionaryID;
+ UUID MCALinkID;
+ UTF16String MCATagSymbol;
+ optional_property<UTF16String> MCATagName;
+ optional_property<ui32_t> MCAChannelID;
+ optional_property<ISO8String> RFC5646SpokenLanguage;
+
+ MCALabelSubDescriptor(const Dictionary*& d);
+ MCALabelSubDescriptor(const MCALabelSubDescriptor& rhs);
+ virtual ~MCALabelSubDescriptor() {}
+
+ const MCALabelSubDescriptor& operator=(const MCALabelSubDescriptor& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const MCALabelSubDescriptor& rhs);
+ virtual const char* HasName() { return "MCALabelSubDescriptor"; }
+ 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 AudioChannelLabelSubDescriptor : public MCALabelSubDescriptor
+ {
+ AudioChannelLabelSubDescriptor();
+
+ public:
+ const Dictionary*& m_Dict;
+ UUID SoundfieldGroupLinkID;
+
+ AudioChannelLabelSubDescriptor(const Dictionary*& d);
+ AudioChannelLabelSubDescriptor(const AudioChannelLabelSubDescriptor& rhs);
+ virtual ~AudioChannelLabelSubDescriptor() {}
+
+ const AudioChannelLabelSubDescriptor& operator=(const AudioChannelLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const AudioChannelLabelSubDescriptor& rhs);
+ virtual const char* HasName() { return "AudioChannelLabelSubDescriptor"; }
+ 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 SoundfieldGroupLabelSubDescriptor : public MCALabelSubDescriptor
+ {
+ SoundfieldGroupLabelSubDescriptor();
+
+ public:
+ const Dictionary*& m_Dict;
+ Array<UUID> GroupOfSoundfieldGroupsLinkID;
+
+ SoundfieldGroupLabelSubDescriptor(const Dictionary*& d);
+ SoundfieldGroupLabelSubDescriptor(const SoundfieldGroupLabelSubDescriptor& rhs);
+ virtual ~SoundfieldGroupLabelSubDescriptor() {}
+
+ const SoundfieldGroupLabelSubDescriptor& operator=(const SoundfieldGroupLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const SoundfieldGroupLabelSubDescriptor& rhs);
+ virtual const char* HasName() { return "SoundfieldGroupLabelSubDescriptor"; }
+ 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 GroupOfSoundfieldGroupsLabelSubDescriptor : public MCALabelSubDescriptor
+ {
+ GroupOfSoundfieldGroupsLabelSubDescriptor();
+
+ public:
+ const Dictionary*& m_Dict;
+
+ GroupOfSoundfieldGroupsLabelSubDescriptor(const Dictionary*& d);
+ GroupOfSoundfieldGroupsLabelSubDescriptor(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs);
+ virtual ~GroupOfSoundfieldGroupsLabelSubDescriptor() {}
+
+ const GroupOfSoundfieldGroupsLabelSubDescriptor& operator=(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs);
+ virtual const char* HasName() { return "GroupOfSoundfieldGroupsLabelSubDescriptor"; }
+ 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 DCDataDescriptor : public GenericDataEssenceDescriptor
+ {
+ DCDataDescriptor();
+
+ public:
+ const Dictionary*& m_Dict;
+
+ DCDataDescriptor(const Dictionary*& d);
+ DCDataDescriptor(const DCDataDescriptor& rhs);
+ virtual ~DCDataDescriptor() {}
+
+ const DCDataDescriptor& operator=(const DCDataDescriptor& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const DCDataDescriptor& rhs);
+ virtual const char* HasName() { return "DCDataDescriptor"; }
+ 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
+ {
+ DolbyAtmosSubDescriptor();
+
+ public:
+ const Dictionary*& m_Dict;
+ UUID AtmosID;
+ ui32_t FirstFrame;
+ ui16_t MaxChannelCount;
+ ui16_t MaxObjectCount;
+ ui8_t AtmosVersion;
+
+ DolbyAtmosSubDescriptor(const Dictionary*& d);
+ DolbyAtmosSubDescriptor(const DolbyAtmosSubDescriptor& rhs);
+ virtual ~DolbyAtmosSubDescriptor() {}
+
+ const DolbyAtmosSubDescriptor& operator=(const DolbyAtmosSubDescriptor& rhs) { Copy(rhs); return *this; }
+ virtual void Copy(const DolbyAtmosSubDescriptor& rhs);
+ virtual const char* HasName() { return "DolbyAtmosSubDescriptor"; }
+ 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
-#endif // _METADATA_H_
+#endif // _Metadata_H_
//
// end Metadata.h