2 Copyright (c) 2005-2017, John Hurst
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions
8 1. Redistributions of source code must retain the above copyright
9 notice, this list of conditions and the following disclaimer.
10 2. Redistributions in binary form must reproduce the above copyright
11 notice, this list of conditions and the following disclaimer in the
12 documentation and/or other materials provided with the distribution.
13 3. The name of the author may not be used to endorse or promote products
14 derived from this software without specific prior written permission.
16 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 /*! \file Metadata.cpp
29 \brief AS-DCP library, MXF Metadata Sets implementation
36 using namespace ASDCP;
37 using namespace ASDCP::MXF;
39 const ui32_t kl_length = ASDCP::SMPTE_UL_LENGTH + ASDCP::MXF_BER_LENGTH;
41 //------------------------------------------------------------------------------------------
43 static InterchangeObject* Preface_Factory(const Dictionary*& Dict) { return new Preface(Dict); }
44 static InterchangeObject* IndexTableSegment_Factory(const Dictionary*& Dict) { return new IndexTableSegment(Dict); }
46 static InterchangeObject* Identification_Factory(const Dictionary*& Dict) { return new Identification(Dict); }
47 static InterchangeObject* ContentStorage_Factory(const Dictionary*& Dict) { return new ContentStorage(Dict); }
48 static InterchangeObject* EssenceContainerData_Factory(const Dictionary*& Dict) { return new EssenceContainerData(Dict); }
49 static InterchangeObject* MaterialPackage_Factory(const Dictionary*& Dict) { return new MaterialPackage(Dict); }
50 static InterchangeObject* SourcePackage_Factory(const Dictionary*& Dict) { return new SourcePackage(Dict); }
51 static InterchangeObject* StaticTrack_Factory(const Dictionary*& Dict) { return new StaticTrack(Dict); }
52 static InterchangeObject* Track_Factory(const Dictionary*& Dict) { return new Track(Dict); }
53 static InterchangeObject* Sequence_Factory(const Dictionary*& Dict) { return new Sequence(Dict); }
54 static InterchangeObject* SourceClip_Factory(const Dictionary*& Dict) { return new SourceClip(Dict); }
55 static InterchangeObject* TimecodeComponent_Factory(const Dictionary*& Dict) { return new TimecodeComponent(Dict); }
56 static InterchangeObject* FileDescriptor_Factory(const Dictionary*& Dict) { return new FileDescriptor(Dict); }
57 static InterchangeObject* GenericSoundEssenceDescriptor_Factory(const Dictionary*& Dict) { return new GenericSoundEssenceDescriptor(Dict); }
58 static InterchangeObject* WaveAudioDescriptor_Factory(const Dictionary*& Dict) { return new WaveAudioDescriptor(Dict); }
59 static InterchangeObject* GenericPictureEssenceDescriptor_Factory(const Dictionary*& Dict) { return new GenericPictureEssenceDescriptor(Dict); }
60 static InterchangeObject* RGBAEssenceDescriptor_Factory(const Dictionary*& Dict) { return new RGBAEssenceDescriptor(Dict); }
61 static InterchangeObject* JPEG2000PictureSubDescriptor_Factory(const Dictionary*& Dict) { return new JPEG2000PictureSubDescriptor(Dict); }
62 static InterchangeObject* CDCIEssenceDescriptor_Factory(const Dictionary*& Dict) { return new CDCIEssenceDescriptor(Dict); }
63 static InterchangeObject* MPEG2VideoDescriptor_Factory(const Dictionary*& Dict) { return new MPEG2VideoDescriptor(Dict); }
64 static InterchangeObject* DMSegment_Factory(const Dictionary*& Dict) { return new DMSegment(Dict); }
65 static InterchangeObject* CryptographicFramework_Factory(const Dictionary*& Dict) { return new CryptographicFramework(Dict); }
66 static InterchangeObject* CryptographicContext_Factory(const Dictionary*& Dict) { return new CryptographicContext(Dict); }
67 static InterchangeObject* DescriptiveFramework_Factory(const Dictionary*& Dict) { return new DescriptiveFramework(Dict); }
68 static InterchangeObject* DescriptiveObject_Factory(const Dictionary*& Dict) { return new DescriptiveObject(Dict); }
69 static InterchangeObject* GenericDataEssenceDescriptor_Factory(const Dictionary*& Dict) { return new GenericDataEssenceDescriptor(Dict); }
70 static InterchangeObject* TimedTextDescriptor_Factory(const Dictionary*& Dict) { return new TimedTextDescriptor(Dict); }
71 static InterchangeObject* TimedTextResourceSubDescriptor_Factory(const Dictionary*& Dict) { return new TimedTextResourceSubDescriptor(Dict); }
72 static InterchangeObject* StereoscopicPictureSubDescriptor_Factory(const Dictionary*& Dict) { return new StereoscopicPictureSubDescriptor(Dict); }
73 static InterchangeObject* ContainerConstraintsSubDescriptor_Factory(const Dictionary*& Dict) { return new ContainerConstraintsSubDescriptor(Dict); }
74 static InterchangeObject* NetworkLocator_Factory(const Dictionary*& Dict) { return new NetworkLocator(Dict); }
75 static InterchangeObject* MCALabelSubDescriptor_Factory(const Dictionary*& Dict) { return new MCALabelSubDescriptor(Dict); }
76 static InterchangeObject* AudioChannelLabelSubDescriptor_Factory(const Dictionary*& Dict) { return new AudioChannelLabelSubDescriptor(Dict); }
77 static InterchangeObject* SoundfieldGroupLabelSubDescriptor_Factory(const Dictionary*& Dict) { return new SoundfieldGroupLabelSubDescriptor(Dict); }
78 static InterchangeObject* GroupOfSoundfieldGroupsLabelSubDescriptor_Factory(const Dictionary*& Dict) { return new GroupOfSoundfieldGroupsLabelSubDescriptor(Dict); }
79 static InterchangeObject* DCDataDescriptor_Factory(const Dictionary*& Dict) { return new DCDataDescriptor(Dict); }
80 static InterchangeObject* PrivateDCDataDescriptor_Factory(const Dictionary*& Dict) { return new PrivateDCDataDescriptor(Dict); }
81 static InterchangeObject* DolbyAtmosSubDescriptor_Factory(const Dictionary*& Dict) { return new DolbyAtmosSubDescriptor(Dict); }
82 static InterchangeObject* ACESPictureSubDescriptor_Factory(const Dictionary*& Dict) { return new ACESPictureSubDescriptor(Dict); }
83 static InterchangeObject* TargetFrameSubDescriptor_Factory(const Dictionary*& Dict) { return new TargetFrameSubDescriptor(Dict); }
84 static InterchangeObject* TextBasedDMFramework_Factory(const Dictionary*& Dict) { return new TextBasedDMFramework(Dict); }
85 static InterchangeObject* TextBasedObject_Factory(const Dictionary*& Dict) { return new TextBasedObject(Dict); }
86 static InterchangeObject* GenericStreamTextBasedSet_Factory(const Dictionary*& Dict) { return new GenericStreamTextBasedSet(Dict); }
87 static InterchangeObject* ISXDDataEssenceDescriptor_Factory(const Dictionary*& Dict) { return new ISXDDataEssenceDescriptor(Dict); }
88 static InterchangeObject* PHDRMetadataTrackSubDescriptor_Factory(const Dictionary*& Dict) { return new PHDRMetadataTrackSubDescriptor(Dict); }
89 static InterchangeObject* PIMFDynamicMetadataDescriptor_Factory(const Dictionary*& Dict) { return new PIMFDynamicMetadataDescriptor(Dict); }
93 ASDCP::MXF::Metadata_InitTypes(const Dictionary*& Dict)
96 SetObjectFactory(Dict->ul(MDD_Preface), Preface_Factory);
97 SetObjectFactory(Dict->ul(MDD_IndexTableSegment), IndexTableSegment_Factory);
99 SetObjectFactory(Dict->ul(MDD_Identification), Identification_Factory);
100 SetObjectFactory(Dict->ul(MDD_ContentStorage), ContentStorage_Factory);
101 SetObjectFactory(Dict->ul(MDD_EssenceContainerData), EssenceContainerData_Factory);
102 SetObjectFactory(Dict->ul(MDD_MaterialPackage), MaterialPackage_Factory);
103 SetObjectFactory(Dict->ul(MDD_SourcePackage), SourcePackage_Factory);
104 SetObjectFactory(Dict->ul(MDD_StaticTrack), StaticTrack_Factory);
105 SetObjectFactory(Dict->ul(MDD_Track), Track_Factory);
106 SetObjectFactory(Dict->ul(MDD_Sequence), Sequence_Factory);
107 SetObjectFactory(Dict->ul(MDD_SourceClip), SourceClip_Factory);
108 SetObjectFactory(Dict->ul(MDD_TimecodeComponent), TimecodeComponent_Factory);
109 SetObjectFactory(Dict->ul(MDD_FileDescriptor), FileDescriptor_Factory);
110 SetObjectFactory(Dict->ul(MDD_GenericSoundEssenceDescriptor), GenericSoundEssenceDescriptor_Factory);
111 SetObjectFactory(Dict->ul(MDD_WaveAudioDescriptor), WaveAudioDescriptor_Factory);
112 SetObjectFactory(Dict->ul(MDD_GenericPictureEssenceDescriptor), GenericPictureEssenceDescriptor_Factory);
113 SetObjectFactory(Dict->ul(MDD_RGBAEssenceDescriptor), RGBAEssenceDescriptor_Factory);
114 SetObjectFactory(Dict->ul(MDD_JPEG2000PictureSubDescriptor), JPEG2000PictureSubDescriptor_Factory);
115 SetObjectFactory(Dict->ul(MDD_CDCIEssenceDescriptor), CDCIEssenceDescriptor_Factory);
116 SetObjectFactory(Dict->ul(MDD_MPEG2VideoDescriptor), MPEG2VideoDescriptor_Factory);
117 SetObjectFactory(Dict->ul(MDD_DMSegment), DMSegment_Factory);
118 SetObjectFactory(Dict->ul(MDD_CryptographicFramework), CryptographicFramework_Factory);
119 SetObjectFactory(Dict->ul(MDD_CryptographicContext), CryptographicContext_Factory);
120 SetObjectFactory(Dict->ul(MDD_DescriptiveFramework), DescriptiveFramework_Factory);
121 SetObjectFactory(Dict->ul(MDD_DescriptiveObject), DescriptiveObject_Factory);
122 SetObjectFactory(Dict->ul(MDD_GenericDataEssenceDescriptor), GenericDataEssenceDescriptor_Factory);
123 SetObjectFactory(Dict->ul(MDD_TimedTextDescriptor), TimedTextDescriptor_Factory);
124 SetObjectFactory(Dict->ul(MDD_TimedTextResourceSubDescriptor), TimedTextResourceSubDescriptor_Factory);
125 SetObjectFactory(Dict->ul(MDD_StereoscopicPictureSubDescriptor), StereoscopicPictureSubDescriptor_Factory);
126 SetObjectFactory(Dict->ul(MDD_ContainerConstraintsSubDescriptor), ContainerConstraintsSubDescriptor_Factory);
127 SetObjectFactory(Dict->ul(MDD_NetworkLocator), NetworkLocator_Factory);
128 SetObjectFactory(Dict->ul(MDD_MCALabelSubDescriptor), MCALabelSubDescriptor_Factory);
129 SetObjectFactory(Dict->ul(MDD_AudioChannelLabelSubDescriptor), AudioChannelLabelSubDescriptor_Factory);
130 SetObjectFactory(Dict->ul(MDD_SoundfieldGroupLabelSubDescriptor), SoundfieldGroupLabelSubDescriptor_Factory);
131 SetObjectFactory(Dict->ul(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor), GroupOfSoundfieldGroupsLabelSubDescriptor_Factory);
132 SetObjectFactory(Dict->ul(MDD_DCDataDescriptor), DCDataDescriptor_Factory);
133 SetObjectFactory(Dict->ul(MDD_PrivateDCDataDescriptor), PrivateDCDataDescriptor_Factory);
134 SetObjectFactory(Dict->ul(MDD_DolbyAtmosSubDescriptor), DolbyAtmosSubDescriptor_Factory);
135 SetObjectFactory(Dict->ul(MDD_ACESPictureSubDescriptor), ACESPictureSubDescriptor_Factory);
136 SetObjectFactory(Dict->ul(MDD_TargetFrameSubDescriptor), TargetFrameSubDescriptor_Factory);
137 SetObjectFactory(Dict->ul(MDD_TextBasedDMFramework), TextBasedDMFramework_Factory);
138 SetObjectFactory(Dict->ul(MDD_TextBasedObject), TextBasedObject_Factory);
139 SetObjectFactory(Dict->ul(MDD_GenericStreamTextBasedSet), GenericStreamTextBasedSet_Factory);
140 SetObjectFactory(Dict->ul(MDD_ISXDDataEssenceDescriptor), ISXDDataEssenceDescriptor_Factory);
141 SetObjectFactory(Dict->ul(MDD_PHDRMetadataTrackSubDescriptor), PHDRMetadataTrackSubDescriptor_Factory);
142 SetObjectFactory(Dict->ul(MDD_PIMFDynamicMetadataDescriptor), PIMFDynamicMetadataDescriptor_Factory);
145 //------------------------------------------------------------------------------------------
150 //------------------------------------------------------------------------------------------
155 Identification::Identification(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
158 m_UL = m_Dict->ul(MDD_Identification);
161 Identification::Identification(const Identification& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
164 m_UL = m_Dict->ul(MDD_Identification);
171 Identification::InitFromTLVSet(TLVReader& TLVSet)
174 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
175 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ThisGenerationUID));
176 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, CompanyName));
177 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ProductName));
178 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ProductVersion));
179 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, VersionString));
180 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ProductUID));
181 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ModificationDate));
182 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ToolkitVersion));
183 if ( ASDCP_SUCCESS(result) ) {
184 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(Identification, Platform));
185 Platform.set_has_value( result == RESULT_OK );
192 Identification::WriteToTLVSet(TLVWriter& TLVSet)
195 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
196 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ThisGenerationUID));
197 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, CompanyName));
198 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ProductName));
199 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ProductVersion));
200 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, VersionString));
201 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ProductUID));
202 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ModificationDate));
203 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ToolkitVersion));
204 if ( ASDCP_SUCCESS(result) && ! Platform.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(Identification, Platform));
210 Identification::Copy(const Identification& rhs)
212 InterchangeObject::Copy(rhs);
213 ThisGenerationUID = rhs.ThisGenerationUID;
214 CompanyName = rhs.CompanyName;
215 ProductName = rhs.ProductName;
216 ProductVersion = rhs.ProductVersion;
217 VersionString = rhs.VersionString;
218 ProductUID = rhs.ProductUID;
219 ModificationDate = rhs.ModificationDate;
220 ToolkitVersion = rhs.ToolkitVersion;
221 Platform = rhs.Platform;
226 Identification::Dump(FILE* stream)
228 char identbuf[IdentBufferLen];
234 InterchangeObject::Dump(stream);
235 fprintf(stream, " %22s = %s\n", "ThisGenerationUID", ThisGenerationUID.EncodeString(identbuf, IdentBufferLen));
236 fprintf(stream, " %22s = %s\n", "CompanyName", CompanyName.EncodeString(identbuf, IdentBufferLen));
237 fprintf(stream, " %22s = %s\n", "ProductName", ProductName.EncodeString(identbuf, IdentBufferLen));
238 fprintf(stream, " %22s = %s\n", "ProductVersion", ProductVersion.EncodeString(identbuf, IdentBufferLen));
239 fprintf(stream, " %22s = %s\n", "VersionString", VersionString.EncodeString(identbuf, IdentBufferLen));
240 fprintf(stream, " %22s = %s\n", "ProductUID", ProductUID.EncodeString(identbuf, IdentBufferLen));
241 fprintf(stream, " %22s = %s\n", "ModificationDate", ModificationDate.EncodeString(identbuf, IdentBufferLen));
242 fprintf(stream, " %22s = %s\n", "ToolkitVersion", ToolkitVersion.EncodeString(identbuf, IdentBufferLen));
243 if ( ! Platform.empty() ) {
244 fprintf(stream, " %22s = %s\n", "Platform", Platform.get().EncodeString(identbuf, IdentBufferLen));
250 Identification::InitFromBuffer(const byte_t* p, ui32_t l)
252 return InterchangeObject::InitFromBuffer(p, l);
257 Identification::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
259 return InterchangeObject::WriteToBuffer(Buffer);
262 //------------------------------------------------------------------------------------------
267 ContentStorage::ContentStorage(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
270 m_UL = m_Dict->ul(MDD_ContentStorage);
273 ContentStorage::ContentStorage(const ContentStorage& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
276 m_UL = m_Dict->ul(MDD_ContentStorage);
283 ContentStorage::InitFromTLVSet(TLVReader& TLVSet)
286 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
287 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(ContentStorage, Packages));
288 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(ContentStorage, EssenceContainerData));
294 ContentStorage::WriteToTLVSet(TLVWriter& TLVSet)
297 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
298 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(ContentStorage, Packages));
299 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(ContentStorage, EssenceContainerData));
305 ContentStorage::Copy(const ContentStorage& rhs)
307 InterchangeObject::Copy(rhs);
308 Packages = rhs.Packages;
309 EssenceContainerData = rhs.EssenceContainerData;
314 ContentStorage::Dump(FILE* stream)
316 char identbuf[IdentBufferLen];
322 InterchangeObject::Dump(stream);
323 fprintf(stream, " %22s:\n", "Packages");
324 Packages.Dump(stream);
325 fprintf(stream, " %22s:\n", "EssenceContainerData");
326 EssenceContainerData.Dump(stream);
331 ContentStorage::InitFromBuffer(const byte_t* p, ui32_t l)
333 return InterchangeObject::InitFromBuffer(p, l);
338 ContentStorage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
340 return InterchangeObject::WriteToBuffer(Buffer);
343 //------------------------------------------------------------------------------------------
344 // EssenceContainerData
348 EssenceContainerData::EssenceContainerData(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), BodySID(0)
351 m_UL = m_Dict->ul(MDD_EssenceContainerData);
354 EssenceContainerData::EssenceContainerData(const EssenceContainerData& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
357 m_UL = m_Dict->ul(MDD_EssenceContainerData);
364 EssenceContainerData::InitFromTLVSet(TLVReader& TLVSet)
367 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
368 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(EssenceContainerData, LinkedPackageUID));
369 if ( ASDCP_SUCCESS(result) ) {
370 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(EssenceContainerData, IndexSID));
371 IndexSID.set_has_value( result == RESULT_OK );
373 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(EssenceContainerData, BodySID));
379 EssenceContainerData::WriteToTLVSet(TLVWriter& TLVSet)
382 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
383 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(EssenceContainerData, LinkedPackageUID));
384 if ( ASDCP_SUCCESS(result) && ! IndexSID.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(EssenceContainerData, IndexSID));
385 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(EssenceContainerData, BodySID));
391 EssenceContainerData::Copy(const EssenceContainerData& rhs)
393 InterchangeObject::Copy(rhs);
394 LinkedPackageUID = rhs.LinkedPackageUID;
395 IndexSID = rhs.IndexSID;
396 BodySID = rhs.BodySID;
401 EssenceContainerData::Dump(FILE* stream)
403 char identbuf[IdentBufferLen];
409 InterchangeObject::Dump(stream);
410 fprintf(stream, " %22s = %s\n", "LinkedPackageUID", LinkedPackageUID.EncodeString(identbuf, IdentBufferLen));
411 if ( ! IndexSID.empty() ) {
412 fprintf(stream, " %22s = %d\n", "IndexSID", IndexSID.get());
414 fprintf(stream, " %22s = %d\n", "BodySID", BodySID);
419 EssenceContainerData::InitFromBuffer(const byte_t* p, ui32_t l)
421 return InterchangeObject::InitFromBuffer(p, l);
426 EssenceContainerData::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
428 return InterchangeObject::WriteToBuffer(Buffer);
431 //------------------------------------------------------------------------------------------
435 GenericPackage::GenericPackage(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
437 GenericPackage::GenericPackage(const GenericPackage& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
445 GenericPackage::InitFromTLVSet(TLVReader& TLVSet)
448 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
449 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, PackageUID));
450 if ( ASDCP_SUCCESS(result) ) {
451 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPackage, Name));
452 Name.set_has_value( result == RESULT_OK );
454 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, PackageCreationDate));
455 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, PackageModifiedDate));
456 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, Tracks));
462 GenericPackage::WriteToTLVSet(TLVWriter& TLVSet)
465 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
466 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPackage, PackageUID));
467 if ( ASDCP_SUCCESS(result) && ! Name.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPackage, Name));
468 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPackage, PackageCreationDate));
469 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPackage, PackageModifiedDate));
470 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPackage, Tracks));
476 GenericPackage::Copy(const GenericPackage& rhs)
478 InterchangeObject::Copy(rhs);
479 PackageUID = rhs.PackageUID;
481 PackageCreationDate = rhs.PackageCreationDate;
482 PackageModifiedDate = rhs.PackageModifiedDate;
488 GenericPackage::Dump(FILE* stream)
490 char identbuf[IdentBufferLen];
496 InterchangeObject::Dump(stream);
497 fprintf(stream, " %22s = %s\n", "PackageUID", PackageUID.EncodeString(identbuf, IdentBufferLen));
498 if ( ! Name.empty() ) {
499 fprintf(stream, " %22s = %s\n", "Name", Name.get().EncodeString(identbuf, IdentBufferLen));
501 fprintf(stream, " %22s = %s\n", "PackageCreationDate", PackageCreationDate.EncodeString(identbuf, IdentBufferLen));
502 fprintf(stream, " %22s = %s\n", "PackageModifiedDate", PackageModifiedDate.EncodeString(identbuf, IdentBufferLen));
503 fprintf(stream, " %22s:\n", "Tracks");
508 //------------------------------------------------------------------------------------------
513 MaterialPackage::MaterialPackage(const Dictionary*& d) : GenericPackage(d), m_Dict(d)
516 m_UL = m_Dict->ul(MDD_MaterialPackage);
519 MaterialPackage::MaterialPackage(const MaterialPackage& rhs) : GenericPackage(rhs.m_Dict), m_Dict(rhs.m_Dict)
522 m_UL = m_Dict->ul(MDD_MaterialPackage);
529 MaterialPackage::InitFromTLVSet(TLVReader& TLVSet)
532 Result_t result = GenericPackage::InitFromTLVSet(TLVSet);
533 if ( ASDCP_SUCCESS(result) ) {
534 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MaterialPackage, PackageMarker));
535 PackageMarker.set_has_value( result == RESULT_OK );
542 MaterialPackage::WriteToTLVSet(TLVWriter& TLVSet)
545 Result_t result = GenericPackage::WriteToTLVSet(TLVSet);
546 if ( ASDCP_SUCCESS(result) && ! PackageMarker.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MaterialPackage, PackageMarker));
552 MaterialPackage::Copy(const MaterialPackage& rhs)
554 GenericPackage::Copy(rhs);
555 PackageMarker = rhs.PackageMarker;
560 MaterialPackage::Dump(FILE* stream)
562 char identbuf[IdentBufferLen];
568 GenericPackage::Dump(stream);
569 if ( ! PackageMarker.empty() ) {
570 fprintf(stream, " %22s = %s\n", "PackageMarker", PackageMarker.get().EncodeString(identbuf, IdentBufferLen));
576 MaterialPackage::InitFromBuffer(const byte_t* p, ui32_t l)
578 return InterchangeObject::InitFromBuffer(p, l);
583 MaterialPackage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
585 return InterchangeObject::WriteToBuffer(Buffer);
588 //------------------------------------------------------------------------------------------
593 SourcePackage::SourcePackage(const Dictionary*& d) : GenericPackage(d), m_Dict(d)
596 m_UL = m_Dict->ul(MDD_SourcePackage);
599 SourcePackage::SourcePackage(const SourcePackage& rhs) : GenericPackage(rhs.m_Dict), m_Dict(rhs.m_Dict)
602 m_UL = m_Dict->ul(MDD_SourcePackage);
609 SourcePackage::InitFromTLVSet(TLVReader& TLVSet)
612 Result_t result = GenericPackage::InitFromTLVSet(TLVSet);
613 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(SourcePackage, Descriptor));
619 SourcePackage::WriteToTLVSet(TLVWriter& TLVSet)
622 Result_t result = GenericPackage::WriteToTLVSet(TLVSet);
623 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(SourcePackage, Descriptor));
629 SourcePackage::Copy(const SourcePackage& rhs)
631 GenericPackage::Copy(rhs);
632 Descriptor = rhs.Descriptor;
637 SourcePackage::Dump(FILE* stream)
639 char identbuf[IdentBufferLen];
645 GenericPackage::Dump(stream);
646 fprintf(stream, " %22s = %s\n", "Descriptor", Descriptor.EncodeString(identbuf, IdentBufferLen));
651 SourcePackage::InitFromBuffer(const byte_t* p, ui32_t l)
653 return InterchangeObject::InitFromBuffer(p, l);
658 SourcePackage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
660 return InterchangeObject::WriteToBuffer(Buffer);
663 //------------------------------------------------------------------------------------------
667 GenericTrack::GenericTrack(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), TrackID(0), TrackNumber(0) {}
669 GenericTrack::GenericTrack(const GenericTrack& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
677 GenericTrack::InitFromTLVSet(TLVReader& TLVSet)
680 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
681 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericTrack, TrackID));
682 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericTrack, TrackNumber));
683 if ( ASDCP_SUCCESS(result) ) {
684 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericTrack, TrackName));
685 TrackName.set_has_value( result == RESULT_OK );
687 if ( ASDCP_SUCCESS(result) ) {
688 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericTrack, Sequence));
689 Sequence.set_has_value( result == RESULT_OK );
696 GenericTrack::WriteToTLVSet(TLVWriter& TLVSet)
699 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
700 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericTrack, TrackID));
701 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericTrack, TrackNumber));
702 if ( ASDCP_SUCCESS(result) && ! TrackName.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericTrack, TrackName));
703 if ( ASDCP_SUCCESS(result) && ! Sequence.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericTrack, Sequence));
709 GenericTrack::Copy(const GenericTrack& rhs)
711 InterchangeObject::Copy(rhs);
712 TrackID = rhs.TrackID;
713 TrackNumber = rhs.TrackNumber;
714 TrackName = rhs.TrackName;
715 Sequence = rhs.Sequence;
720 GenericTrack::Dump(FILE* stream)
722 char identbuf[IdentBufferLen];
728 InterchangeObject::Dump(stream);
729 fprintf(stream, " %22s = %d\n", "TrackID", TrackID);
730 fprintf(stream, " %22s = %d\n", "TrackNumber", TrackNumber);
731 if ( ! TrackName.empty() ) {
732 fprintf(stream, " %22s = %s\n", "TrackName", TrackName.get().EncodeString(identbuf, IdentBufferLen));
734 if ( ! Sequence.empty() ) {
735 fprintf(stream, " %22s = %s\n", "Sequence", Sequence.get().EncodeString(identbuf, IdentBufferLen));
740 //------------------------------------------------------------------------------------------
745 StaticTrack::StaticTrack(const Dictionary*& d) : GenericTrack(d), m_Dict(d)
748 m_UL = m_Dict->ul(MDD_StaticTrack);
751 StaticTrack::StaticTrack(const StaticTrack& rhs) : GenericTrack(rhs.m_Dict), m_Dict(rhs.m_Dict)
754 m_UL = m_Dict->ul(MDD_StaticTrack);
761 StaticTrack::InitFromTLVSet(TLVReader& TLVSet)
764 Result_t result = GenericTrack::InitFromTLVSet(TLVSet);
770 StaticTrack::WriteToTLVSet(TLVWriter& TLVSet)
773 Result_t result = GenericTrack::WriteToTLVSet(TLVSet);
779 StaticTrack::Copy(const StaticTrack& rhs)
781 GenericTrack::Copy(rhs);
786 StaticTrack::Dump(FILE* stream)
788 char identbuf[IdentBufferLen];
794 GenericTrack::Dump(stream);
799 StaticTrack::InitFromBuffer(const byte_t* p, ui32_t l)
801 return InterchangeObject::InitFromBuffer(p, l);
806 StaticTrack::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
808 return InterchangeObject::WriteToBuffer(Buffer);
811 //------------------------------------------------------------------------------------------
816 Track::Track(const Dictionary*& d) : GenericTrack(d), m_Dict(d), Origin(0)
819 m_UL = m_Dict->ul(MDD_Track);
822 Track::Track(const Track& rhs) : GenericTrack(rhs.m_Dict), m_Dict(rhs.m_Dict)
825 m_UL = m_Dict->ul(MDD_Track);
832 Track::InitFromTLVSet(TLVReader& TLVSet)
835 Result_t result = GenericTrack::InitFromTLVSet(TLVSet);
836 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Track, EditRate));
837 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(Track, Origin));
843 Track::WriteToTLVSet(TLVWriter& TLVSet)
846 Result_t result = GenericTrack::WriteToTLVSet(TLVSet);
847 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Track, EditRate));
848 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(Track, Origin));
854 Track::Copy(const Track& rhs)
856 GenericTrack::Copy(rhs);
857 EditRate = rhs.EditRate;
863 Track::Dump(FILE* stream)
865 char identbuf[IdentBufferLen];
871 GenericTrack::Dump(stream);
872 fprintf(stream, " %22s = %s\n", "EditRate", EditRate.EncodeString(identbuf, IdentBufferLen));
873 fprintf(stream, " %22s = %s\n", "Origin", i64sz(Origin, identbuf));
878 Track::InitFromBuffer(const byte_t* p, ui32_t l)
880 return InterchangeObject::InitFromBuffer(p, l);
885 Track::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
887 return InterchangeObject::WriteToBuffer(Buffer);
890 //------------------------------------------------------------------------------------------
891 // StructuralComponent
894 StructuralComponent::StructuralComponent(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
896 StructuralComponent::StructuralComponent(const StructuralComponent& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
904 StructuralComponent::InitFromTLVSet(TLVReader& TLVSet)
907 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
908 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(StructuralComponent, DataDefinition));
909 if ( ASDCP_SUCCESS(result) ) {
910 result = TLVSet.ReadUi64(OBJ_READ_ARGS_OPT(StructuralComponent, Duration));
911 Duration.set_has_value( result == RESULT_OK );
918 StructuralComponent::WriteToTLVSet(TLVWriter& TLVSet)
921 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
922 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(StructuralComponent, DataDefinition));
923 if ( ASDCP_SUCCESS(result) && ! Duration.empty() ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS_OPT(StructuralComponent, Duration));
929 StructuralComponent::Copy(const StructuralComponent& rhs)
931 InterchangeObject::Copy(rhs);
932 DataDefinition = rhs.DataDefinition;
933 Duration = rhs.Duration;
938 StructuralComponent::Dump(FILE* stream)
940 char identbuf[IdentBufferLen];
946 InterchangeObject::Dump(stream);
947 fprintf(stream, " %22s = %s\n", "DataDefinition", DataDefinition.EncodeString(identbuf, IdentBufferLen));
948 if ( ! Duration.empty() ) {
949 fprintf(stream, " %22s = %s\n", "Duration", i64sz(Duration.get(), identbuf));
954 //------------------------------------------------------------------------------------------
959 Sequence::Sequence(const Dictionary*& d) : StructuralComponent(d), m_Dict(d)
962 m_UL = m_Dict->ul(MDD_Sequence);
965 Sequence::Sequence(const Sequence& rhs) : StructuralComponent(rhs.m_Dict), m_Dict(rhs.m_Dict)
968 m_UL = m_Dict->ul(MDD_Sequence);
975 Sequence::InitFromTLVSet(TLVReader& TLVSet)
978 Result_t result = StructuralComponent::InitFromTLVSet(TLVSet);
979 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Sequence, StructuralComponents));
985 Sequence::WriteToTLVSet(TLVWriter& TLVSet)
988 Result_t result = StructuralComponent::WriteToTLVSet(TLVSet);
989 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Sequence, StructuralComponents));
995 Sequence::Copy(const Sequence& rhs)
997 StructuralComponent::Copy(rhs);
998 StructuralComponents = rhs.StructuralComponents;
1003 Sequence::Dump(FILE* stream)
1005 char identbuf[IdentBufferLen];
1011 StructuralComponent::Dump(stream);
1012 fprintf(stream, " %22s:\n", "StructuralComponents");
1013 StructuralComponents.Dump(stream);
1018 Sequence::InitFromBuffer(const byte_t* p, ui32_t l)
1020 return InterchangeObject::InitFromBuffer(p, l);
1025 Sequence::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1027 return InterchangeObject::WriteToBuffer(Buffer);
1030 //------------------------------------------------------------------------------------------
1035 SourceClip::SourceClip(const Dictionary*& d) : StructuralComponent(d), m_Dict(d), StartPosition(0), SourceTrackID(0)
1038 m_UL = m_Dict->ul(MDD_SourceClip);
1041 SourceClip::SourceClip(const SourceClip& rhs) : StructuralComponent(rhs.m_Dict), m_Dict(rhs.m_Dict)
1044 m_UL = m_Dict->ul(MDD_SourceClip);
1051 SourceClip::InitFromTLVSet(TLVReader& TLVSet)
1054 Result_t result = StructuralComponent::InitFromTLVSet(TLVSet);
1055 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(SourceClip, StartPosition));
1056 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(SourceClip, SourcePackageID));
1057 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(SourceClip, SourceTrackID));
1063 SourceClip::WriteToTLVSet(TLVWriter& TLVSet)
1066 Result_t result = StructuralComponent::WriteToTLVSet(TLVSet);
1067 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(SourceClip, StartPosition));
1068 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(SourceClip, SourcePackageID));
1069 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(SourceClip, SourceTrackID));
1075 SourceClip::Copy(const SourceClip& rhs)
1077 StructuralComponent::Copy(rhs);
1078 StartPosition = rhs.StartPosition;
1079 SourcePackageID = rhs.SourcePackageID;
1080 SourceTrackID = rhs.SourceTrackID;
1085 SourceClip::Dump(FILE* stream)
1087 char identbuf[IdentBufferLen];
1093 StructuralComponent::Dump(stream);
1094 fprintf(stream, " %22s = %s\n", "StartPosition", i64sz(StartPosition, identbuf));
1095 fprintf(stream, " %22s = %s\n", "SourcePackageID", SourcePackageID.EncodeString(identbuf, IdentBufferLen));
1096 fprintf(stream, " %22s = %d\n", "SourceTrackID", SourceTrackID);
1101 SourceClip::InitFromBuffer(const byte_t* p, ui32_t l)
1103 return InterchangeObject::InitFromBuffer(p, l);
1108 SourceClip::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1110 return InterchangeObject::WriteToBuffer(Buffer);
1113 //------------------------------------------------------------------------------------------
1114 // TimecodeComponent
1118 TimecodeComponent::TimecodeComponent(const Dictionary*& d) : StructuralComponent(d), m_Dict(d), RoundedTimecodeBase(0), StartTimecode(0), DropFrame(0)
1121 m_UL = m_Dict->ul(MDD_TimecodeComponent);
1124 TimecodeComponent::TimecodeComponent(const TimecodeComponent& rhs) : StructuralComponent(rhs.m_Dict), m_Dict(rhs.m_Dict)
1127 m_UL = m_Dict->ul(MDD_TimecodeComponent);
1134 TimecodeComponent::InitFromTLVSet(TLVReader& TLVSet)
1137 Result_t result = StructuralComponent::InitFromTLVSet(TLVSet);
1138 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(TimecodeComponent, RoundedTimecodeBase));
1139 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(TimecodeComponent, StartTimecode));
1140 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(TimecodeComponent, DropFrame));
1146 TimecodeComponent::WriteToTLVSet(TLVWriter& TLVSet)
1149 Result_t result = StructuralComponent::WriteToTLVSet(TLVSet);
1150 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(TimecodeComponent, RoundedTimecodeBase));
1151 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(TimecodeComponent, StartTimecode));
1152 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(TimecodeComponent, DropFrame));
1158 TimecodeComponent::Copy(const TimecodeComponent& rhs)
1160 StructuralComponent::Copy(rhs);
1161 RoundedTimecodeBase = rhs.RoundedTimecodeBase;
1162 StartTimecode = rhs.StartTimecode;
1163 DropFrame = rhs.DropFrame;
1168 TimecodeComponent::Dump(FILE* stream)
1170 char identbuf[IdentBufferLen];
1176 StructuralComponent::Dump(stream);
1177 fprintf(stream, " %22s = %d\n", "RoundedTimecodeBase", RoundedTimecodeBase);
1178 fprintf(stream, " %22s = %s\n", "StartTimecode", i64sz(StartTimecode, identbuf));
1179 fprintf(stream, " %22s = %d\n", "DropFrame", DropFrame);
1184 TimecodeComponent::InitFromBuffer(const byte_t* p, ui32_t l)
1186 return InterchangeObject::InitFromBuffer(p, l);
1191 TimecodeComponent::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1193 return InterchangeObject::WriteToBuffer(Buffer);
1196 //------------------------------------------------------------------------------------------
1197 // GenericDescriptor
1200 GenericDescriptor::GenericDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
1202 GenericDescriptor::GenericDescriptor(const GenericDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
1210 GenericDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1213 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
1214 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericDescriptor, Locators));
1215 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericDescriptor, SubDescriptors));
1221 GenericDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1224 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
1225 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericDescriptor, Locators));
1226 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericDescriptor, SubDescriptors));
1232 GenericDescriptor::Copy(const GenericDescriptor& rhs)
1234 InterchangeObject::Copy(rhs);
1235 Locators = rhs.Locators;
1236 SubDescriptors = rhs.SubDescriptors;
1241 GenericDescriptor::Dump(FILE* stream)
1243 char identbuf[IdentBufferLen];
1249 InterchangeObject::Dump(stream);
1250 fprintf(stream, " %22s:\n", "Locators");
1251 Locators.Dump(stream);
1252 fprintf(stream, " %22s:\n", "SubDescriptors");
1253 SubDescriptors.Dump(stream);
1257 //------------------------------------------------------------------------------------------
1262 FileDescriptor::FileDescriptor(const Dictionary*& d) : GenericDescriptor(d), m_Dict(d)
1265 m_UL = m_Dict->ul(MDD_FileDescriptor);
1268 FileDescriptor::FileDescriptor(const FileDescriptor& rhs) : GenericDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1271 m_UL = m_Dict->ul(MDD_FileDescriptor);
1278 FileDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1281 Result_t result = GenericDescriptor::InitFromTLVSet(TLVSet);
1282 if ( ASDCP_SUCCESS(result) ) {
1283 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(FileDescriptor, LinkedTrackID));
1284 LinkedTrackID.set_has_value( result == RESULT_OK );
1286 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(FileDescriptor, SampleRate));
1287 if ( ASDCP_SUCCESS(result) ) {
1288 result = TLVSet.ReadUi64(OBJ_READ_ARGS_OPT(FileDescriptor, ContainerDuration));
1289 ContainerDuration.set_has_value( result == RESULT_OK );
1291 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(FileDescriptor, EssenceContainer));
1292 if ( ASDCP_SUCCESS(result) ) {
1293 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(FileDescriptor, Codec));
1294 Codec.set_has_value( result == RESULT_OK );
1301 FileDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1304 Result_t result = GenericDescriptor::WriteToTLVSet(TLVSet);
1305 if ( ASDCP_SUCCESS(result) && ! LinkedTrackID.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(FileDescriptor, LinkedTrackID));
1306 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(FileDescriptor, SampleRate));
1307 if ( ASDCP_SUCCESS(result) && ! ContainerDuration.empty() ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS_OPT(FileDescriptor, ContainerDuration));
1308 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(FileDescriptor, EssenceContainer));
1309 if ( ASDCP_SUCCESS(result) && ! Codec.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(FileDescriptor, Codec));
1315 FileDescriptor::Copy(const FileDescriptor& rhs)
1317 GenericDescriptor::Copy(rhs);
1318 LinkedTrackID = rhs.LinkedTrackID;
1319 SampleRate = rhs.SampleRate;
1320 ContainerDuration = rhs.ContainerDuration;
1321 EssenceContainer = rhs.EssenceContainer;
1327 FileDescriptor::Dump(FILE* stream)
1329 char identbuf[IdentBufferLen];
1335 GenericDescriptor::Dump(stream);
1336 if ( ! LinkedTrackID.empty() ) {
1337 fprintf(stream, " %22s = %d\n", "LinkedTrackID", LinkedTrackID.get());
1339 fprintf(stream, " %22s = %s\n", "SampleRate", SampleRate.EncodeString(identbuf, IdentBufferLen));
1340 if ( ! ContainerDuration.empty() ) {
1341 fprintf(stream, " %22s = %s\n", "ContainerDuration", i64sz(ContainerDuration.get(), identbuf));
1343 fprintf(stream, " %22s = %s\n", "EssenceContainer", EssenceContainer.EncodeString(identbuf, IdentBufferLen));
1344 if ( ! Codec.empty() ) {
1345 fprintf(stream, " %22s = %s\n", "Codec", Codec.get().EncodeString(identbuf, IdentBufferLen));
1351 FileDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1353 return InterchangeObject::InitFromBuffer(p, l);
1358 FileDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1360 return InterchangeObject::WriteToBuffer(Buffer);
1363 //------------------------------------------------------------------------------------------
1364 // GenericSoundEssenceDescriptor
1368 GenericSoundEssenceDescriptor::GenericSoundEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d), Locked(0), ChannelCount(0), QuantizationBits(0)
1371 m_UL = m_Dict->ul(MDD_GenericSoundEssenceDescriptor);
1374 GenericSoundEssenceDescriptor::GenericSoundEssenceDescriptor(const GenericSoundEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1377 m_UL = m_Dict->ul(MDD_GenericSoundEssenceDescriptor);
1384 GenericSoundEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1387 Result_t result = FileDescriptor::InitFromTLVSet(TLVSet);
1388 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, AudioSamplingRate));
1389 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, Locked));
1390 if ( ASDCP_SUCCESS(result) ) {
1391 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(GenericSoundEssenceDescriptor, AudioRefLevel));
1392 AudioRefLevel.set_has_value( result == RESULT_OK );
1394 if ( ASDCP_SUCCESS(result) ) {
1395 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(GenericSoundEssenceDescriptor, ElectroSpatialFormulation));
1396 ElectroSpatialFormulation.set_has_value( result == RESULT_OK );
1398 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, ChannelCount));
1399 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, QuantizationBits));
1400 if ( ASDCP_SUCCESS(result) ) {
1401 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(GenericSoundEssenceDescriptor, DialNorm));
1402 DialNorm.set_has_value( result == RESULT_OK );
1404 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, SoundEssenceCoding));
1405 if ( ASDCP_SUCCESS(result) ) {
1406 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(GenericSoundEssenceDescriptor, ReferenceAudioAlignmentLevel));
1407 ReferenceAudioAlignmentLevel.set_has_value( result == RESULT_OK );
1409 if ( ASDCP_SUCCESS(result) ) {
1410 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericSoundEssenceDescriptor, ReferenceImageEditRate));
1411 ReferenceImageEditRate.set_has_value( result == RESULT_OK );
1418 GenericSoundEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1421 Result_t result = FileDescriptor::WriteToTLVSet(TLVSet);
1422 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, AudioSamplingRate));
1423 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, Locked));
1424 if ( ASDCP_SUCCESS(result) && ! AudioRefLevel.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericSoundEssenceDescriptor, AudioRefLevel));
1425 if ( ASDCP_SUCCESS(result) && ! ElectroSpatialFormulation.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericSoundEssenceDescriptor, ElectroSpatialFormulation));
1426 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, ChannelCount));
1427 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, QuantizationBits));
1428 if ( ASDCP_SUCCESS(result) && ! DialNorm.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericSoundEssenceDescriptor, DialNorm));
1429 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, SoundEssenceCoding));
1430 if ( ASDCP_SUCCESS(result) && ! ReferenceAudioAlignmentLevel.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericSoundEssenceDescriptor, ReferenceAudioAlignmentLevel));
1431 if ( ASDCP_SUCCESS(result) && ! ReferenceImageEditRate.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericSoundEssenceDescriptor, ReferenceImageEditRate));
1437 GenericSoundEssenceDescriptor::Copy(const GenericSoundEssenceDescriptor& rhs)
1439 FileDescriptor::Copy(rhs);
1440 AudioSamplingRate = rhs.AudioSamplingRate;
1441 Locked = rhs.Locked;
1442 AudioRefLevel = rhs.AudioRefLevel;
1443 ElectroSpatialFormulation = rhs.ElectroSpatialFormulation;
1444 ChannelCount = rhs.ChannelCount;
1445 QuantizationBits = rhs.QuantizationBits;
1446 DialNorm = rhs.DialNorm;
1447 SoundEssenceCoding = rhs.SoundEssenceCoding;
1448 ReferenceAudioAlignmentLevel = rhs.ReferenceAudioAlignmentLevel;
1449 ReferenceImageEditRate = rhs.ReferenceImageEditRate;
1454 GenericSoundEssenceDescriptor::Dump(FILE* stream)
1456 char identbuf[IdentBufferLen];
1462 FileDescriptor::Dump(stream);
1463 fprintf(stream, " %22s = %s\n", "AudioSamplingRate", AudioSamplingRate.EncodeString(identbuf, IdentBufferLen));
1464 fprintf(stream, " %22s = %d\n", "Locked", Locked);
1465 if ( ! AudioRefLevel.empty() ) {
1466 fprintf(stream, " %22s = %d\n", "AudioRefLevel", AudioRefLevel.get());
1468 if ( ! ElectroSpatialFormulation.empty() ) {
1469 fprintf(stream, " %22s = %d\n", "ElectroSpatialFormulation", ElectroSpatialFormulation.get());
1471 fprintf(stream, " %22s = %d\n", "ChannelCount", ChannelCount);
1472 fprintf(stream, " %22s = %d\n", "QuantizationBits", QuantizationBits);
1473 if ( ! DialNorm.empty() ) {
1474 fprintf(stream, " %22s = %d\n", "DialNorm", DialNorm.get());
1476 fprintf(stream, " %22s = %s\n", "SoundEssenceCoding", SoundEssenceCoding.EncodeString(identbuf, IdentBufferLen));
1477 if ( ! ReferenceAudioAlignmentLevel.empty() ) {
1478 fprintf(stream, " %22s = %d\n", "ReferenceAudioAlignmentLevel", ReferenceAudioAlignmentLevel.get());
1480 if ( ! ReferenceImageEditRate.empty() ) {
1481 fprintf(stream, " %22s = %s\n", "ReferenceImageEditRate", ReferenceImageEditRate.get().EncodeString(identbuf, IdentBufferLen));
1487 GenericSoundEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1489 return InterchangeObject::InitFromBuffer(p, l);
1494 GenericSoundEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1496 return InterchangeObject::WriteToBuffer(Buffer);
1499 //------------------------------------------------------------------------------------------
1500 // WaveAudioDescriptor
1504 WaveAudioDescriptor::WaveAudioDescriptor(const Dictionary*& d) : GenericSoundEssenceDescriptor(d), m_Dict(d), BlockAlign(0), AvgBps(0)
1507 m_UL = m_Dict->ul(MDD_WaveAudioDescriptor);
1510 WaveAudioDescriptor::WaveAudioDescriptor(const WaveAudioDescriptor& rhs) : GenericSoundEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1513 m_UL = m_Dict->ul(MDD_WaveAudioDescriptor);
1520 WaveAudioDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1523 Result_t result = GenericSoundEssenceDescriptor::InitFromTLVSet(TLVSet);
1524 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(WaveAudioDescriptor, BlockAlign));
1525 if ( ASDCP_SUCCESS(result) ) {
1526 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(WaveAudioDescriptor, SequenceOffset));
1527 SequenceOffset.set_has_value( result == RESULT_OK );
1529 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(WaveAudioDescriptor, AvgBps));
1530 if ( ASDCP_SUCCESS(result) ) {
1531 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(WaveAudioDescriptor, ChannelAssignment));
1532 ChannelAssignment.set_has_value( result == RESULT_OK );
1539 WaveAudioDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1542 Result_t result = GenericSoundEssenceDescriptor::WriteToTLVSet(TLVSet);
1543 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(WaveAudioDescriptor, BlockAlign));
1544 if ( ASDCP_SUCCESS(result) && ! SequenceOffset.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(WaveAudioDescriptor, SequenceOffset));
1545 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(WaveAudioDescriptor, AvgBps));
1546 if ( ASDCP_SUCCESS(result) && ! ChannelAssignment.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(WaveAudioDescriptor, ChannelAssignment));
1552 WaveAudioDescriptor::Copy(const WaveAudioDescriptor& rhs)
1554 GenericSoundEssenceDescriptor::Copy(rhs);
1555 BlockAlign = rhs.BlockAlign;
1556 SequenceOffset = rhs.SequenceOffset;
1557 AvgBps = rhs.AvgBps;
1558 ChannelAssignment = rhs.ChannelAssignment;
1563 WaveAudioDescriptor::Dump(FILE* stream)
1565 char identbuf[IdentBufferLen];
1571 GenericSoundEssenceDescriptor::Dump(stream);
1572 fprintf(stream, " %22s = %d\n", "BlockAlign", BlockAlign);
1573 if ( ! SequenceOffset.empty() ) {
1574 fprintf(stream, " %22s = %d\n", "SequenceOffset", SequenceOffset.get());
1576 fprintf(stream, " %22s = %d\n", "AvgBps", AvgBps);
1577 if ( ! ChannelAssignment.empty() ) {
1578 fprintf(stream, " %22s = %s\n", "ChannelAssignment", ChannelAssignment.get().EncodeString(identbuf, IdentBufferLen));
1584 WaveAudioDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1586 return InterchangeObject::InitFromBuffer(p, l);
1591 WaveAudioDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1593 return InterchangeObject::WriteToBuffer(Buffer);
1596 //------------------------------------------------------------------------------------------
1597 // GenericPictureEssenceDescriptor
1601 GenericPictureEssenceDescriptor::GenericPictureEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d), FrameLayout(0), StoredWidth(0), StoredHeight(0)
1604 m_UL = m_Dict->ul(MDD_GenericPictureEssenceDescriptor);
1607 GenericPictureEssenceDescriptor::GenericPictureEssenceDescriptor(const GenericPictureEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1610 m_UL = m_Dict->ul(MDD_GenericPictureEssenceDescriptor);
1617 GenericPictureEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1620 Result_t result = FileDescriptor::InitFromTLVSet(TLVSet);
1621 if ( ASDCP_SUCCESS(result) ) {
1622 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, SignalStandard));
1623 SignalStandard.set_has_value( result == RESULT_OK );
1625 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, FrameLayout));
1626 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, StoredWidth));
1627 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, StoredHeight));
1628 if ( ASDCP_SUCCESS(result) ) {
1629 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, StoredF2Offset));
1630 StoredF2Offset.set_has_value( result == RESULT_OK );
1632 if ( ASDCP_SUCCESS(result) ) {
1633 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, SampledWidth));
1634 SampledWidth.set_has_value( result == RESULT_OK );
1636 if ( ASDCP_SUCCESS(result) ) {
1637 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, SampledHeight));
1638 SampledHeight.set_has_value( result == RESULT_OK );
1640 if ( ASDCP_SUCCESS(result) ) {
1641 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, SampledXOffset));
1642 SampledXOffset.set_has_value( result == RESULT_OK );
1644 if ( ASDCP_SUCCESS(result) ) {
1645 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, SampledYOffset));
1646 SampledYOffset.set_has_value( result == RESULT_OK );
1648 if ( ASDCP_SUCCESS(result) ) {
1649 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayHeight));
1650 DisplayHeight.set_has_value( result == RESULT_OK );
1652 if ( ASDCP_SUCCESS(result) ) {
1653 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayWidth));
1654 DisplayWidth.set_has_value( result == RESULT_OK );
1656 if ( ASDCP_SUCCESS(result) ) {
1657 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayXOffset));
1658 DisplayXOffset.set_has_value( result == RESULT_OK );
1660 if ( ASDCP_SUCCESS(result) ) {
1661 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayYOffset));
1662 DisplayYOffset.set_has_value( result == RESULT_OK );
1664 if ( ASDCP_SUCCESS(result) ) {
1665 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayF2Offset));
1666 DisplayF2Offset.set_has_value( result == RESULT_OK );
1668 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, AspectRatio));
1669 if ( ASDCP_SUCCESS(result) ) {
1670 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveFormatDescriptor));
1671 ActiveFormatDescriptor.set_has_value( result == RESULT_OK );
1673 if ( ASDCP_SUCCESS(result) ) {
1674 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, AlphaTransparency));
1675 AlphaTransparency.set_has_value( result == RESULT_OK );
1677 if ( ASDCP_SUCCESS(result) ) {
1678 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, TransferCharacteristic));
1679 TransferCharacteristic.set_has_value( result == RESULT_OK );
1681 if ( ASDCP_SUCCESS(result) ) {
1682 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ImageAlignmentOffset));
1683 ImageAlignmentOffset.set_has_value( result == RESULT_OK );
1685 if ( ASDCP_SUCCESS(result) ) {
1686 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ImageStartOffset));
1687 ImageStartOffset.set_has_value( result == RESULT_OK );
1689 if ( ASDCP_SUCCESS(result) ) {
1690 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ImageEndOffset));
1691 ImageEndOffset.set_has_value( result == RESULT_OK );
1693 if ( ASDCP_SUCCESS(result) ) {
1694 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, FieldDominance));
1695 FieldDominance.set_has_value( result == RESULT_OK );
1697 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, PictureEssenceCoding));
1698 if ( ASDCP_SUCCESS(result) ) {
1699 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, CodingEquations));
1700 CodingEquations.set_has_value( result == RESULT_OK );
1702 if ( ASDCP_SUCCESS(result) ) {
1703 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ColorPrimaries));
1704 ColorPrimaries.set_has_value( result == RESULT_OK );
1706 if ( ASDCP_SUCCESS(result) ) {
1707 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, AlternativeCenterCuts));
1709 if ( ASDCP_SUCCESS(result) ) {
1710 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveWidth));
1711 ActiveWidth.set_has_value( result == RESULT_OK );
1713 if ( ASDCP_SUCCESS(result) ) {
1714 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveHeight));
1715 ActiveHeight.set_has_value( result == RESULT_OK );
1717 if ( ASDCP_SUCCESS(result) ) {
1718 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveXOffset));
1719 ActiveXOffset.set_has_value( result == RESULT_OK );
1721 if ( ASDCP_SUCCESS(result) ) {
1722 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveYOffset));
1723 ActiveYOffset.set_has_value( result == RESULT_OK );
1725 if ( ASDCP_SUCCESS(result) ) {
1726 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, VideoLineMap));
1727 VideoLineMap.set_has_value( result == RESULT_OK );
1729 if ( ASDCP_SUCCESS(result) ) {
1730 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, MasteringDisplayPrimaries));
1731 MasteringDisplayPrimaries.set_has_value( result == RESULT_OK );
1733 if ( ASDCP_SUCCESS(result) ) {
1734 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, MasteringDisplayWhitePointChromaticity));
1735 MasteringDisplayWhitePointChromaticity.set_has_value( result == RESULT_OK );
1737 if ( ASDCP_SUCCESS(result) ) {
1738 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, MasteringDisplayMaximumLuminance));
1739 MasteringDisplayMaximumLuminance.set_has_value( result == RESULT_OK );
1741 if ( ASDCP_SUCCESS(result) ) {
1742 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, MasteringDisplayMinimumLuminance));
1743 MasteringDisplayMinimumLuminance.set_has_value( result == RESULT_OK );
1750 GenericPictureEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1753 Result_t result = FileDescriptor::WriteToTLVSet(TLVSet);
1754 if ( ASDCP_SUCCESS(result) && ! SignalStandard.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, SignalStandard));
1755 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, FrameLayout));
1756 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, StoredWidth));
1757 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, StoredHeight));
1758 if ( ASDCP_SUCCESS(result) && ! StoredF2Offset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, StoredF2Offset));
1759 if ( ASDCP_SUCCESS(result) && ! SampledWidth.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, SampledWidth));
1760 if ( ASDCP_SUCCESS(result) && ! SampledHeight.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, SampledHeight));
1761 if ( ASDCP_SUCCESS(result) && ! SampledXOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, SampledXOffset));
1762 if ( ASDCP_SUCCESS(result) && ! SampledYOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, SampledYOffset));
1763 if ( ASDCP_SUCCESS(result) && ! DisplayHeight.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayHeight));
1764 if ( ASDCP_SUCCESS(result) && ! DisplayWidth.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayWidth));
1765 if ( ASDCP_SUCCESS(result) && ! DisplayXOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayXOffset));
1766 if ( ASDCP_SUCCESS(result) && ! DisplayYOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayYOffset));
1767 if ( ASDCP_SUCCESS(result) && ! DisplayF2Offset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayF2Offset));
1768 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, AspectRatio));
1769 if ( ASDCP_SUCCESS(result) && ! ActiveFormatDescriptor.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveFormatDescriptor));
1770 if ( ASDCP_SUCCESS(result) && ! AlphaTransparency.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, AlphaTransparency));
1771 if ( ASDCP_SUCCESS(result) && ! TransferCharacteristic.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, TransferCharacteristic));
1772 if ( ASDCP_SUCCESS(result) && ! ImageAlignmentOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ImageAlignmentOffset));
1773 if ( ASDCP_SUCCESS(result) && ! ImageStartOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ImageStartOffset));
1774 if ( ASDCP_SUCCESS(result) && ! ImageEndOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ImageEndOffset));
1775 if ( ASDCP_SUCCESS(result) && ! FieldDominance.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, FieldDominance));
1776 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, PictureEssenceCoding));
1777 if ( ASDCP_SUCCESS(result) && ! CodingEquations.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, CodingEquations));
1778 if ( ASDCP_SUCCESS(result) && ! ColorPrimaries.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ColorPrimaries));
1779 if ( ASDCP_SUCCESS(result) && ! AlternativeCenterCuts.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, AlternativeCenterCuts));
1780 if ( ASDCP_SUCCESS(result) && ! ActiveWidth.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveWidth));
1781 if ( ASDCP_SUCCESS(result) && ! ActiveHeight.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveHeight));
1782 if ( ASDCP_SUCCESS(result) && ! ActiveXOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveXOffset));
1783 if ( ASDCP_SUCCESS(result) && ! ActiveYOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveYOffset));
1784 if ( ASDCP_SUCCESS(result) && ! VideoLineMap.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, VideoLineMap));
1785 if ( ASDCP_SUCCESS(result) && ! MasteringDisplayPrimaries.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, MasteringDisplayPrimaries));
1786 if ( ASDCP_SUCCESS(result) && ! MasteringDisplayWhitePointChromaticity.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, MasteringDisplayWhitePointChromaticity));
1787 if ( ASDCP_SUCCESS(result) && ! MasteringDisplayMaximumLuminance.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, MasteringDisplayMaximumLuminance));
1788 if ( ASDCP_SUCCESS(result) && ! MasteringDisplayMinimumLuminance.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, MasteringDisplayMinimumLuminance));
1794 GenericPictureEssenceDescriptor::Copy(const GenericPictureEssenceDescriptor& rhs)
1796 FileDescriptor::Copy(rhs);
1797 SignalStandard = rhs.SignalStandard;
1798 FrameLayout = rhs.FrameLayout;
1799 StoredWidth = rhs.StoredWidth;
1800 StoredHeight = rhs.StoredHeight;
1801 StoredF2Offset = rhs.StoredF2Offset;
1802 SampledWidth = rhs.SampledWidth;
1803 SampledHeight = rhs.SampledHeight;
1804 SampledXOffset = rhs.SampledXOffset;
1805 SampledYOffset = rhs.SampledYOffset;
1806 DisplayHeight = rhs.DisplayHeight;
1807 DisplayWidth = rhs.DisplayWidth;
1808 DisplayXOffset = rhs.DisplayXOffset;
1809 DisplayYOffset = rhs.DisplayYOffset;
1810 DisplayF2Offset = rhs.DisplayF2Offset;
1811 AspectRatio = rhs.AspectRatio;
1812 ActiveFormatDescriptor = rhs.ActiveFormatDescriptor;
1813 AlphaTransparency = rhs.AlphaTransparency;
1814 TransferCharacteristic = rhs.TransferCharacteristic;
1815 ImageAlignmentOffset = rhs.ImageAlignmentOffset;
1816 ImageStartOffset = rhs.ImageStartOffset;
1817 ImageEndOffset = rhs.ImageEndOffset;
1818 FieldDominance = rhs.FieldDominance;
1819 PictureEssenceCoding = rhs.PictureEssenceCoding;
1820 CodingEquations = rhs.CodingEquations;
1821 ColorPrimaries = rhs.ColorPrimaries;
1822 AlternativeCenterCuts = rhs.AlternativeCenterCuts;
1823 ActiveWidth = rhs.ActiveWidth;
1824 ActiveHeight = rhs.ActiveHeight;
1825 ActiveXOffset = rhs.ActiveXOffset;
1826 ActiveYOffset = rhs.ActiveYOffset;
1827 VideoLineMap = rhs.VideoLineMap;
1828 MasteringDisplayPrimaries = rhs.MasteringDisplayPrimaries;
1829 MasteringDisplayWhitePointChromaticity = rhs.MasteringDisplayWhitePointChromaticity;
1830 MasteringDisplayMaximumLuminance = rhs.MasteringDisplayMaximumLuminance;
1831 MasteringDisplayMinimumLuminance = rhs.MasteringDisplayMinimumLuminance;
1836 GenericPictureEssenceDescriptor::Dump(FILE* stream)
1838 char identbuf[IdentBufferLen];
1844 FileDescriptor::Dump(stream);
1845 if ( ! SignalStandard.empty() ) {
1846 fprintf(stream, " %22s = %d\n", "SignalStandard", SignalStandard.get());
1848 fprintf(stream, " %22s = %d\n", "FrameLayout", FrameLayout);
1849 fprintf(stream, " %22s = %d\n", "StoredWidth", StoredWidth);
1850 fprintf(stream, " %22s = %d\n", "StoredHeight", StoredHeight);
1851 if ( ! StoredF2Offset.empty() ) {
1852 fprintf(stream, " %22s = %d\n", "StoredF2Offset", StoredF2Offset.get());
1854 if ( ! SampledWidth.empty() ) {
1855 fprintf(stream, " %22s = %d\n", "SampledWidth", SampledWidth.get());
1857 if ( ! SampledHeight.empty() ) {
1858 fprintf(stream, " %22s = %d\n", "SampledHeight", SampledHeight.get());
1860 if ( ! SampledXOffset.empty() ) {
1861 fprintf(stream, " %22s = %d\n", "SampledXOffset", SampledXOffset.get());
1863 if ( ! SampledYOffset.empty() ) {
1864 fprintf(stream, " %22s = %d\n", "SampledYOffset", SampledYOffset.get());
1866 if ( ! DisplayHeight.empty() ) {
1867 fprintf(stream, " %22s = %d\n", "DisplayHeight", DisplayHeight.get());
1869 if ( ! DisplayWidth.empty() ) {
1870 fprintf(stream, " %22s = %d\n", "DisplayWidth", DisplayWidth.get());
1872 if ( ! DisplayXOffset.empty() ) {
1873 fprintf(stream, " %22s = %d\n", "DisplayXOffset", DisplayXOffset.get());
1875 if ( ! DisplayYOffset.empty() ) {
1876 fprintf(stream, " %22s = %d\n", "DisplayYOffset", DisplayYOffset.get());
1878 if ( ! DisplayF2Offset.empty() ) {
1879 fprintf(stream, " %22s = %d\n", "DisplayF2Offset", DisplayF2Offset.get());
1881 fprintf(stream, " %22s = %s\n", "AspectRatio", AspectRatio.EncodeString(identbuf, IdentBufferLen));
1882 if ( ! ActiveFormatDescriptor.empty() ) {
1883 fprintf(stream, " %22s = %d\n", "ActiveFormatDescriptor", ActiveFormatDescriptor.get());
1885 if ( ! AlphaTransparency.empty() ) {
1886 fprintf(stream, " %22s = %d\n", "AlphaTransparency", AlphaTransparency.get());
1888 if ( ! TransferCharacteristic.empty() ) {
1889 fprintf(stream, " %22s = %s\n", "TransferCharacteristic", TransferCharacteristic.get().EncodeString(identbuf, IdentBufferLen));
1891 if ( ! ImageAlignmentOffset.empty() ) {
1892 fprintf(stream, " %22s = %d\n", "ImageAlignmentOffset", ImageAlignmentOffset.get());
1894 if ( ! ImageStartOffset.empty() ) {
1895 fprintf(stream, " %22s = %d\n", "ImageStartOffset", ImageStartOffset.get());
1897 if ( ! ImageEndOffset.empty() ) {
1898 fprintf(stream, " %22s = %d\n", "ImageEndOffset", ImageEndOffset.get());
1900 if ( ! FieldDominance.empty() ) {
1901 fprintf(stream, " %22s = %d\n", "FieldDominance", FieldDominance.get());
1903 fprintf(stream, " %22s = %s\n", "PictureEssenceCoding", PictureEssenceCoding.EncodeString(identbuf, IdentBufferLen));
1904 if ( ! CodingEquations.empty() ) {
1905 fprintf(stream, " %22s = %s\n", "CodingEquations", CodingEquations.get().EncodeString(identbuf, IdentBufferLen));
1907 if ( ! ColorPrimaries.empty() ) {
1908 fprintf(stream, " %22s = %s\n", "ColorPrimaries", ColorPrimaries.get().EncodeString(identbuf, IdentBufferLen));
1910 if ( ! AlternativeCenterCuts.empty() ) {
1911 fprintf(stream, " %22s:\n", "AlternativeCenterCuts");
1912 AlternativeCenterCuts.get().Dump(stream);
1914 if ( ! ActiveWidth.empty() ) {
1915 fprintf(stream, " %22s = %d\n", "ActiveWidth", ActiveWidth.get());
1917 if ( ! ActiveHeight.empty() ) {
1918 fprintf(stream, " %22s = %d\n", "ActiveHeight", ActiveHeight.get());
1920 if ( ! ActiveXOffset.empty() ) {
1921 fprintf(stream, " %22s = %d\n", "ActiveXOffset", ActiveXOffset.get());
1923 if ( ! ActiveYOffset.empty() ) {
1924 fprintf(stream, " %22s = %d\n", "ActiveYOffset", ActiveYOffset.get());
1926 if ( ! VideoLineMap.empty() ) {
1927 fprintf(stream, " %22s = %s\n", "VideoLineMap", VideoLineMap.get().EncodeString(identbuf, IdentBufferLen));
1929 if ( ! MasteringDisplayPrimaries.empty() ) {
1930 fprintf(stream, " %22s = %s\n", "MasteringDisplayPrimaries", MasteringDisplayPrimaries.get().EncodeString(identbuf, IdentBufferLen));
1932 if ( ! MasteringDisplayWhitePointChromaticity.empty() ) {
1933 fprintf(stream, " %22s = %s\n", "MasteringDisplayWhitePointChromaticity", MasteringDisplayWhitePointChromaticity.get().EncodeString(identbuf, IdentBufferLen));
1935 if ( ! MasteringDisplayMaximumLuminance.empty() ) {
1936 fprintf(stream, " %22s = %d\n", "MasteringDisplayMaximumLuminance", MasteringDisplayMaximumLuminance.get());
1938 if ( ! MasteringDisplayMinimumLuminance.empty() ) {
1939 fprintf(stream, " %22s = %d\n", "MasteringDisplayMinimumLuminance", MasteringDisplayMinimumLuminance.get());
1945 GenericPictureEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1947 return InterchangeObject::InitFromBuffer(p, l);
1952 GenericPictureEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1954 return InterchangeObject::WriteToBuffer(Buffer);
1957 //------------------------------------------------------------------------------------------
1958 // RGBAEssenceDescriptor
1962 RGBAEssenceDescriptor::RGBAEssenceDescriptor(const Dictionary*& d) : GenericPictureEssenceDescriptor(d), m_Dict(d)
1965 m_UL = m_Dict->ul(MDD_RGBAEssenceDescriptor);
1968 RGBAEssenceDescriptor::RGBAEssenceDescriptor(const RGBAEssenceDescriptor& rhs) : GenericPictureEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1971 m_UL = m_Dict->ul(MDD_RGBAEssenceDescriptor);
1978 RGBAEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1981 Result_t result = GenericPictureEssenceDescriptor::InitFromTLVSet(TLVSet);
1982 if ( ASDCP_SUCCESS(result) ) {
1983 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(RGBAEssenceDescriptor, ComponentMaxRef));
1984 ComponentMaxRef.set_has_value( result == RESULT_OK );
1986 if ( ASDCP_SUCCESS(result) ) {
1987 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(RGBAEssenceDescriptor, ComponentMinRef));
1988 ComponentMinRef.set_has_value( result == RESULT_OK );
1990 if ( ASDCP_SUCCESS(result) ) {
1991 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(RGBAEssenceDescriptor, AlphaMinRef));
1992 AlphaMinRef.set_has_value( result == RESULT_OK );
1994 if ( ASDCP_SUCCESS(result) ) {
1995 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(RGBAEssenceDescriptor, AlphaMaxRef));
1996 AlphaMaxRef.set_has_value( result == RESULT_OK );
1998 if ( ASDCP_SUCCESS(result) ) {
1999 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(RGBAEssenceDescriptor, ScanningDirection));
2000 ScanningDirection.set_has_value( result == RESULT_OK );
2002 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(RGBAEssenceDescriptor, PixelLayout));
2008 RGBAEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2011 Result_t result = GenericPictureEssenceDescriptor::WriteToTLVSet(TLVSet);
2012 if ( ASDCP_SUCCESS(result) && ! ComponentMaxRef.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(RGBAEssenceDescriptor, ComponentMaxRef));
2013 if ( ASDCP_SUCCESS(result) && ! ComponentMinRef.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(RGBAEssenceDescriptor, ComponentMinRef));
2014 if ( ASDCP_SUCCESS(result) && ! AlphaMinRef.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(RGBAEssenceDescriptor, AlphaMinRef));
2015 if ( ASDCP_SUCCESS(result) && ! AlphaMaxRef.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(RGBAEssenceDescriptor, AlphaMaxRef));
2016 if ( ASDCP_SUCCESS(result) && ! ScanningDirection.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(RGBAEssenceDescriptor, ScanningDirection));
2017 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(RGBAEssenceDescriptor, PixelLayout));
2023 RGBAEssenceDescriptor::Copy(const RGBAEssenceDescriptor& rhs)
2025 GenericPictureEssenceDescriptor::Copy(rhs);
2026 ComponentMaxRef = rhs.ComponentMaxRef;
2027 ComponentMinRef = rhs.ComponentMinRef;
2028 AlphaMinRef = rhs.AlphaMinRef;
2029 AlphaMaxRef = rhs.AlphaMaxRef;
2030 ScanningDirection = rhs.ScanningDirection;
2031 PixelLayout = rhs.PixelLayout;
2036 RGBAEssenceDescriptor::Dump(FILE* stream)
2038 char identbuf[IdentBufferLen];
2044 GenericPictureEssenceDescriptor::Dump(stream);
2045 if ( ! ComponentMaxRef.empty() ) {
2046 fprintf(stream, " %22s = %d\n", "ComponentMaxRef", ComponentMaxRef.get());
2048 if ( ! ComponentMinRef.empty() ) {
2049 fprintf(stream, " %22s = %d\n", "ComponentMinRef", ComponentMinRef.get());
2051 if ( ! AlphaMinRef.empty() ) {
2052 fprintf(stream, " %22s = %d\n", "AlphaMinRef", AlphaMinRef.get());
2054 if ( ! AlphaMaxRef.empty() ) {
2055 fprintf(stream, " %22s = %d\n", "AlphaMaxRef", AlphaMaxRef.get());
2057 if ( ! ScanningDirection.empty() ) {
2058 fprintf(stream, " %22s = %d\n", "ScanningDirection", ScanningDirection.get());
2060 fprintf(stream, " %22s = %s\n", "PixelLayout", PixelLayout.EncodeString(identbuf, IdentBufferLen));
2065 RGBAEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2067 return InterchangeObject::InitFromBuffer(p, l);
2072 RGBAEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2074 return InterchangeObject::WriteToBuffer(Buffer);
2077 //------------------------------------------------------------------------------------------
2078 // JPEG2000PictureSubDescriptor
2082 JPEG2000PictureSubDescriptor::JPEG2000PictureSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), Rsize(0), Xsize(0), Ysize(0), XOsize(0), YOsize(0), XTsize(0), YTsize(0), XTOsize(0), YTOsize(0), Csize(0)
2085 m_UL = m_Dict->ul(MDD_JPEG2000PictureSubDescriptor);
2088 JPEG2000PictureSubDescriptor::JPEG2000PictureSubDescriptor(const JPEG2000PictureSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2091 m_UL = m_Dict->ul(MDD_JPEG2000PictureSubDescriptor);
2098 JPEG2000PictureSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2101 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2102 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Rsize));
2103 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Xsize));
2104 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Ysize));
2105 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XOsize));
2106 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YOsize));
2107 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XTsize));
2108 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YTsize));
2109 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XTOsize));
2110 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YTOsize));
2111 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Csize));
2112 if ( ASDCP_SUCCESS(result) ) {
2113 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(JPEG2000PictureSubDescriptor, PictureComponentSizing));
2114 PictureComponentSizing.set_has_value( result == RESULT_OK );
2116 if ( ASDCP_SUCCESS(result) ) {
2117 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(JPEG2000PictureSubDescriptor, CodingStyleDefault));
2118 CodingStyleDefault.set_has_value( result == RESULT_OK );
2120 if ( ASDCP_SUCCESS(result) ) {
2121 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(JPEG2000PictureSubDescriptor, QuantizationDefault));
2122 QuantizationDefault.set_has_value( result == RESULT_OK );
2124 if ( ASDCP_SUCCESS(result) ) {
2125 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(JPEG2000PictureSubDescriptor, J2CLayout));
2126 J2CLayout.set_has_value( result == RESULT_OK );
2128 if ( ASDCP_SUCCESS(result) ) {
2129 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(JPEG2000PictureSubDescriptor, J2KExtendedCapabilities));
2130 J2KExtendedCapabilities.set_has_value( result == RESULT_OK );
2132 if ( ASDCP_SUCCESS(result) ) {
2133 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(JPEG2000PictureSubDescriptor, J2KProfile));
2134 J2KProfile.set_has_value( result == RESULT_OK );
2136 if ( ASDCP_SUCCESS(result) ) {
2137 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(JPEG2000PictureSubDescriptor, J2KCorrespondingProfile));
2138 J2KCorrespondingProfile.set_has_value( result == RESULT_OK );
2145 JPEG2000PictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2148 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2149 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Rsize));
2150 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Xsize));
2151 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Ysize));
2152 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XOsize));
2153 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YOsize));
2154 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XTsize));
2155 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YTsize));
2156 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XTOsize));
2157 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YTOsize));
2158 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Csize));
2159 if ( ASDCP_SUCCESS(result) && ! PictureComponentSizing.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(JPEG2000PictureSubDescriptor, PictureComponentSizing));
2160 if ( ASDCP_SUCCESS(result) && ! CodingStyleDefault.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(JPEG2000PictureSubDescriptor, CodingStyleDefault));
2161 if ( ASDCP_SUCCESS(result) && ! QuantizationDefault.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(JPEG2000PictureSubDescriptor, QuantizationDefault));
2162 if ( ASDCP_SUCCESS(result) && ! J2CLayout.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(JPEG2000PictureSubDescriptor, J2CLayout));
2163 if ( ASDCP_SUCCESS(result) && ! J2KExtendedCapabilities.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(JPEG2000PictureSubDescriptor, J2KExtendedCapabilities));
2164 if ( ASDCP_SUCCESS(result) && ! J2KProfile.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(JPEG2000PictureSubDescriptor, J2KProfile));
2165 if ( ASDCP_SUCCESS(result) && ! J2KCorrespondingProfile.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(JPEG2000PictureSubDescriptor, J2KCorrespondingProfile));
2171 JPEG2000PictureSubDescriptor::Copy(const JPEG2000PictureSubDescriptor& rhs)
2173 InterchangeObject::Copy(rhs);
2177 XOsize = rhs.XOsize;
2178 YOsize = rhs.YOsize;
2179 XTsize = rhs.XTsize;
2180 YTsize = rhs.YTsize;
2181 XTOsize = rhs.XTOsize;
2182 YTOsize = rhs.YTOsize;
2184 PictureComponentSizing = rhs.PictureComponentSizing;
2185 CodingStyleDefault = rhs.CodingStyleDefault;
2186 QuantizationDefault = rhs.QuantizationDefault;
2187 J2CLayout = rhs.J2CLayout;
2188 J2KExtendedCapabilities = rhs.J2KExtendedCapabilities;
2189 J2KProfile = rhs.J2KProfile;
2190 J2KCorrespondingProfile = rhs.J2KCorrespondingProfile;
2195 JPEG2000PictureSubDescriptor::Dump(FILE* stream)
2197 char identbuf[IdentBufferLen];
2203 InterchangeObject::Dump(stream);
2204 fprintf(stream, " %22s = %d\n", "Rsize", Rsize);
2205 fprintf(stream, " %22s = %d\n", "Xsize", Xsize);
2206 fprintf(stream, " %22s = %d\n", "Ysize", Ysize);
2207 fprintf(stream, " %22s = %d\n", "XOsize", XOsize);
2208 fprintf(stream, " %22s = %d\n", "YOsize", YOsize);
2209 fprintf(stream, " %22s = %d\n", "XTsize", XTsize);
2210 fprintf(stream, " %22s = %d\n", "YTsize", YTsize);
2211 fprintf(stream, " %22s = %d\n", "XTOsize", XTOsize);
2212 fprintf(stream, " %22s = %d\n", "YTOsize", YTOsize);
2213 fprintf(stream, " %22s = %d\n", "Csize", Csize);
2214 if ( ! PictureComponentSizing.empty() ) {
2215 fprintf(stream, " %22s = %s\n", "PictureComponentSizing", PictureComponentSizing.get().EncodeString(identbuf, IdentBufferLen));
2217 if ( ! CodingStyleDefault.empty() ) {
2218 fprintf(stream, " %22s = %s\n", "CodingStyleDefault", CodingStyleDefault.get().EncodeString(identbuf, IdentBufferLen));
2220 if ( ! QuantizationDefault.empty() ) {
2221 fprintf(stream, " %22s = %s\n", "QuantizationDefault", QuantizationDefault.get().EncodeString(identbuf, IdentBufferLen));
2223 if ( ! J2CLayout.empty() ) {
2224 fprintf(stream, " %22s = %s\n", "J2CLayout", J2CLayout.get().EncodeString(identbuf, IdentBufferLen));
2226 if ( ! J2KExtendedCapabilities.empty() ) {
2227 fprintf(stream, " %22s = %s\n", "J2KExtendedCapabilities", J2KExtendedCapabilities.get().EncodeString(identbuf, IdentBufferLen));
2229 if ( ! J2KProfile.empty() ) {
2230 fprintf(stream, " %22s:\n", "J2KProfile");
2231 J2KProfile.get().Dump(stream);
2233 if ( ! J2KCorrespondingProfile.empty() ) {
2234 fprintf(stream, " %22s:\n", "J2KCorrespondingProfile");
2235 J2KCorrespondingProfile.get().Dump(stream);
2241 JPEG2000PictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2243 return InterchangeObject::InitFromBuffer(p, l);
2248 JPEG2000PictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2250 return InterchangeObject::WriteToBuffer(Buffer);
2253 //------------------------------------------------------------------------------------------
2254 // CDCIEssenceDescriptor
2258 CDCIEssenceDescriptor::CDCIEssenceDescriptor(const Dictionary*& d) : GenericPictureEssenceDescriptor(d), m_Dict(d), ComponentDepth(0), HorizontalSubsampling(0)
2261 m_UL = m_Dict->ul(MDD_CDCIEssenceDescriptor);
2264 CDCIEssenceDescriptor::CDCIEssenceDescriptor(const CDCIEssenceDescriptor& rhs) : GenericPictureEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2267 m_UL = m_Dict->ul(MDD_CDCIEssenceDescriptor);
2274 CDCIEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2277 Result_t result = GenericPictureEssenceDescriptor::InitFromTLVSet(TLVSet);
2278 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, ComponentDepth));
2279 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, HorizontalSubsampling));
2280 if ( ASDCP_SUCCESS(result) ) {
2281 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, VerticalSubsampling));
2282 VerticalSubsampling.set_has_value( result == RESULT_OK );
2284 if ( ASDCP_SUCCESS(result) ) {
2285 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, ColorSiting));
2286 ColorSiting.set_has_value( result == RESULT_OK );
2288 if ( ASDCP_SUCCESS(result) ) {
2289 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, ReversedByteOrder));
2290 ReversedByteOrder.set_has_value( result == RESULT_OK );
2292 if ( ASDCP_SUCCESS(result) ) {
2293 result = TLVSet.ReadUi16(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, PaddingBits));
2294 PaddingBits.set_has_value( result == RESULT_OK );
2296 if ( ASDCP_SUCCESS(result) ) {
2297 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, AlphaSampleDepth));
2298 AlphaSampleDepth.set_has_value( result == RESULT_OK );
2300 if ( ASDCP_SUCCESS(result) ) {
2301 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, BlackRefLevel));
2302 BlackRefLevel.set_has_value( result == RESULT_OK );
2304 if ( ASDCP_SUCCESS(result) ) {
2305 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, WhiteReflevel));
2306 WhiteReflevel.set_has_value( result == RESULT_OK );
2308 if ( ASDCP_SUCCESS(result) ) {
2309 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, ColorRange));
2310 ColorRange.set_has_value( result == RESULT_OK );
2317 CDCIEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2320 Result_t result = GenericPictureEssenceDescriptor::WriteToTLVSet(TLVSet);
2321 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, ComponentDepth));
2322 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, HorizontalSubsampling));
2323 if ( ASDCP_SUCCESS(result) && ! VerticalSubsampling.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, VerticalSubsampling));
2324 if ( ASDCP_SUCCESS(result) && ! ColorSiting.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, ColorSiting));
2325 if ( ASDCP_SUCCESS(result) && ! ReversedByteOrder.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, ReversedByteOrder));
2326 if ( ASDCP_SUCCESS(result) && ! PaddingBits.empty() ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, PaddingBits));
2327 if ( ASDCP_SUCCESS(result) && ! AlphaSampleDepth.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, AlphaSampleDepth));
2328 if ( ASDCP_SUCCESS(result) && ! BlackRefLevel.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, BlackRefLevel));
2329 if ( ASDCP_SUCCESS(result) && ! WhiteReflevel.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, WhiteReflevel));
2330 if ( ASDCP_SUCCESS(result) && ! ColorRange.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, ColorRange));
2336 CDCIEssenceDescriptor::Copy(const CDCIEssenceDescriptor& rhs)
2338 GenericPictureEssenceDescriptor::Copy(rhs);
2339 ComponentDepth = rhs.ComponentDepth;
2340 HorizontalSubsampling = rhs.HorizontalSubsampling;
2341 VerticalSubsampling = rhs.VerticalSubsampling;
2342 ColorSiting = rhs.ColorSiting;
2343 ReversedByteOrder = rhs.ReversedByteOrder;
2344 PaddingBits = rhs.PaddingBits;
2345 AlphaSampleDepth = rhs.AlphaSampleDepth;
2346 BlackRefLevel = rhs.BlackRefLevel;
2347 WhiteReflevel = rhs.WhiteReflevel;
2348 ColorRange = rhs.ColorRange;
2353 CDCIEssenceDescriptor::Dump(FILE* stream)
2355 char identbuf[IdentBufferLen];
2361 GenericPictureEssenceDescriptor::Dump(stream);
2362 fprintf(stream, " %22s = %d\n", "ComponentDepth", ComponentDepth);
2363 fprintf(stream, " %22s = %d\n", "HorizontalSubsampling", HorizontalSubsampling);
2364 if ( ! VerticalSubsampling.empty() ) {
2365 fprintf(stream, " %22s = %d\n", "VerticalSubsampling", VerticalSubsampling.get());
2367 if ( ! ColorSiting.empty() ) {
2368 fprintf(stream, " %22s = %d\n", "ColorSiting", ColorSiting.get());
2370 if ( ! ReversedByteOrder.empty() ) {
2371 fprintf(stream, " %22s = %d\n", "ReversedByteOrder", ReversedByteOrder.get());
2373 if ( ! PaddingBits.empty() ) {
2374 fprintf(stream, " %22s = %d\n", "PaddingBits", PaddingBits.get());
2376 if ( ! AlphaSampleDepth.empty() ) {
2377 fprintf(stream, " %22s = %d\n", "AlphaSampleDepth", AlphaSampleDepth.get());
2379 if ( ! BlackRefLevel.empty() ) {
2380 fprintf(stream, " %22s = %d\n", "BlackRefLevel", BlackRefLevel.get());
2382 if ( ! WhiteReflevel.empty() ) {
2383 fprintf(stream, " %22s = %d\n", "WhiteReflevel", WhiteReflevel.get());
2385 if ( ! ColorRange.empty() ) {
2386 fprintf(stream, " %22s = %d\n", "ColorRange", ColorRange.get());
2392 CDCIEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2394 return InterchangeObject::InitFromBuffer(p, l);
2399 CDCIEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2401 return InterchangeObject::WriteToBuffer(Buffer);
2404 //------------------------------------------------------------------------------------------
2405 // MPEG2VideoDescriptor
2409 MPEG2VideoDescriptor::MPEG2VideoDescriptor(const Dictionary*& d) : CDCIEssenceDescriptor(d), m_Dict(d)
2412 m_UL = m_Dict->ul(MDD_MPEG2VideoDescriptor);
2415 MPEG2VideoDescriptor::MPEG2VideoDescriptor(const MPEG2VideoDescriptor& rhs) : CDCIEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2418 m_UL = m_Dict->ul(MDD_MPEG2VideoDescriptor);
2425 MPEG2VideoDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2428 Result_t result = CDCIEssenceDescriptor::InitFromTLVSet(TLVSet);
2429 if ( ASDCP_SUCCESS(result) ) {
2430 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, SingleSequence));
2431 SingleSequence.set_has_value( result == RESULT_OK );
2433 if ( ASDCP_SUCCESS(result) ) {
2434 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, ConstantBFrames));
2435 ConstantBFrames.set_has_value( result == RESULT_OK );
2437 if ( ASDCP_SUCCESS(result) ) {
2438 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, CodedContentType));
2439 CodedContentType.set_has_value( result == RESULT_OK );
2441 if ( ASDCP_SUCCESS(result) ) {
2442 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, LowDelay));
2443 LowDelay.set_has_value( result == RESULT_OK );
2445 if ( ASDCP_SUCCESS(result) ) {
2446 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, ClosedGOP));
2447 ClosedGOP.set_has_value( result == RESULT_OK );
2449 if ( ASDCP_SUCCESS(result) ) {
2450 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, IdenticalGOP));
2451 IdenticalGOP.set_has_value( result == RESULT_OK );
2453 if ( ASDCP_SUCCESS(result) ) {
2454 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, MaxGOP));
2455 MaxGOP.set_has_value( result == RESULT_OK );
2457 if ( ASDCP_SUCCESS(result) ) {
2458 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, BPictureCount));
2459 BPictureCount.set_has_value( result == RESULT_OK );
2461 if ( ASDCP_SUCCESS(result) ) {
2462 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, BitRate));
2463 BitRate.set_has_value( result == RESULT_OK );
2465 if ( ASDCP_SUCCESS(result) ) {
2466 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, ProfileAndLevel));
2467 ProfileAndLevel.set_has_value( result == RESULT_OK );
2474 MPEG2VideoDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2477 Result_t result = CDCIEssenceDescriptor::WriteToTLVSet(TLVSet);
2478 if ( ASDCP_SUCCESS(result) && ! SingleSequence.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, SingleSequence));
2479 if ( ASDCP_SUCCESS(result) && ! ConstantBFrames.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, ConstantBFrames));
2480 if ( ASDCP_SUCCESS(result) && ! CodedContentType.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, CodedContentType));
2481 if ( ASDCP_SUCCESS(result) && ! LowDelay.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, LowDelay));
2482 if ( ASDCP_SUCCESS(result) && ! ClosedGOP.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, ClosedGOP));
2483 if ( ASDCP_SUCCESS(result) && ! IdenticalGOP.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, IdenticalGOP));
2484 if ( ASDCP_SUCCESS(result) && ! MaxGOP.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, MaxGOP));
2485 if ( ASDCP_SUCCESS(result) && ! BPictureCount.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, BPictureCount));
2486 if ( ASDCP_SUCCESS(result) && ! BitRate.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, BitRate));
2487 if ( ASDCP_SUCCESS(result) && ! ProfileAndLevel.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, ProfileAndLevel));
2493 MPEG2VideoDescriptor::Copy(const MPEG2VideoDescriptor& rhs)
2495 CDCIEssenceDescriptor::Copy(rhs);
2496 SingleSequence = rhs.SingleSequence;
2497 ConstantBFrames = rhs.ConstantBFrames;
2498 CodedContentType = rhs.CodedContentType;
2499 LowDelay = rhs.LowDelay;
2500 ClosedGOP = rhs.ClosedGOP;
2501 IdenticalGOP = rhs.IdenticalGOP;
2502 MaxGOP = rhs.MaxGOP;
2503 BPictureCount = rhs.BPictureCount;
2504 BitRate = rhs.BitRate;
2505 ProfileAndLevel = rhs.ProfileAndLevel;
2510 MPEG2VideoDescriptor::Dump(FILE* stream)
2512 char identbuf[IdentBufferLen];
2518 CDCIEssenceDescriptor::Dump(stream);
2519 if ( ! SingleSequence.empty() ) {
2520 fprintf(stream, " %22s = %d\n", "SingleSequence", SingleSequence.get());
2522 if ( ! ConstantBFrames.empty() ) {
2523 fprintf(stream, " %22s = %d\n", "ConstantBFrames", ConstantBFrames.get());
2525 if ( ! CodedContentType.empty() ) {
2526 fprintf(stream, " %22s = %d\n", "CodedContentType", CodedContentType.get());
2528 if ( ! LowDelay.empty() ) {
2529 fprintf(stream, " %22s = %d\n", "LowDelay", LowDelay.get());
2531 if ( ! ClosedGOP.empty() ) {
2532 fprintf(stream, " %22s = %d\n", "ClosedGOP", ClosedGOP.get());
2534 if ( ! IdenticalGOP.empty() ) {
2535 fprintf(stream, " %22s = %d\n", "IdenticalGOP", IdenticalGOP.get());
2537 if ( ! MaxGOP.empty() ) {
2538 fprintf(stream, " %22s = %d\n", "MaxGOP", MaxGOP.get());
2540 if ( ! BPictureCount.empty() ) {
2541 fprintf(stream, " %22s = %d\n", "BPictureCount", BPictureCount.get());
2543 if ( ! BitRate.empty() ) {
2544 fprintf(stream, " %22s = %d\n", "BitRate", BitRate.get());
2546 if ( ! ProfileAndLevel.empty() ) {
2547 fprintf(stream, " %22s = %d\n", "ProfileAndLevel", ProfileAndLevel.get());
2553 MPEG2VideoDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2555 return InterchangeObject::InitFromBuffer(p, l);
2560 MPEG2VideoDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2562 return InterchangeObject::WriteToBuffer(Buffer);
2565 //------------------------------------------------------------------------------------------
2570 DMSegment::DMSegment(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2573 m_UL = m_Dict->ul(MDD_DMSegment);
2576 DMSegment::DMSegment(const DMSegment& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2579 m_UL = m_Dict->ul(MDD_DMSegment);
2586 DMSegment::InitFromTLVSet(TLVReader& TLVSet)
2589 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2590 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, DataDefinition));
2591 if ( ASDCP_SUCCESS(result) ) {
2592 result = TLVSet.ReadUi64(OBJ_READ_ARGS_OPT(DMSegment, Duration));
2593 Duration.set_has_value( result == RESULT_OK );
2595 if ( ASDCP_SUCCESS(result) ) {
2596 result = TLVSet.ReadUi64(OBJ_READ_ARGS_OPT(DMSegment, EventStartPosition));
2597 EventStartPosition.set_has_value( result == RESULT_OK );
2599 if ( ASDCP_SUCCESS(result) ) {
2600 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(DMSegment, EventComment));
2601 EventComment.set_has_value( result == RESULT_OK );
2603 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, DMFramework));
2609 DMSegment::WriteToTLVSet(TLVWriter& TLVSet)
2612 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2613 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, DataDefinition));
2614 if ( ASDCP_SUCCESS(result) && ! Duration.empty() ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS_OPT(DMSegment, Duration));
2615 if ( ASDCP_SUCCESS(result) && ! EventStartPosition.empty() ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS_OPT(DMSegment, EventStartPosition));
2616 if ( ASDCP_SUCCESS(result) && ! EventComment.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(DMSegment, EventComment));
2617 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, DMFramework));
2623 DMSegment::Copy(const DMSegment& rhs)
2625 InterchangeObject::Copy(rhs);
2626 DataDefinition = rhs.DataDefinition;
2627 Duration = rhs.Duration;
2628 EventStartPosition = rhs.EventStartPosition;
2629 EventComment = rhs.EventComment;
2630 DMFramework = rhs.DMFramework;
2635 DMSegment::Dump(FILE* stream)
2637 char identbuf[IdentBufferLen];
2643 InterchangeObject::Dump(stream);
2644 fprintf(stream, " %22s = %s\n", "DataDefinition", DataDefinition.EncodeString(identbuf, IdentBufferLen));
2645 if ( ! Duration.empty() ) {
2646 fprintf(stream, " %22s = %s\n", "Duration", i64sz(Duration.get(), identbuf));
2648 if ( ! EventStartPosition.empty() ) {
2649 fprintf(stream, " %22s = %s\n", "EventStartPosition", i64sz(EventStartPosition.get(), identbuf));
2651 if ( ! EventComment.empty() ) {
2652 fprintf(stream, " %22s = %s\n", "EventComment", EventComment.get().EncodeString(identbuf, IdentBufferLen));
2654 fprintf(stream, " %22s = %s\n", "DMFramework", DMFramework.EncodeString(identbuf, IdentBufferLen));
2659 DMSegment::InitFromBuffer(const byte_t* p, ui32_t l)
2661 return InterchangeObject::InitFromBuffer(p, l);
2666 DMSegment::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2668 return InterchangeObject::WriteToBuffer(Buffer);
2671 //------------------------------------------------------------------------------------------
2672 // CryptographicFramework
2676 CryptographicFramework::CryptographicFramework(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2679 m_UL = m_Dict->ul(MDD_CryptographicFramework);
2682 CryptographicFramework::CryptographicFramework(const CryptographicFramework& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2685 m_UL = m_Dict->ul(MDD_CryptographicFramework);
2692 CryptographicFramework::InitFromTLVSet(TLVReader& TLVSet)
2695 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2696 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicFramework, ContextSR));
2702 CryptographicFramework::WriteToTLVSet(TLVWriter& TLVSet)
2705 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2706 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicFramework, ContextSR));
2712 CryptographicFramework::Copy(const CryptographicFramework& rhs)
2714 InterchangeObject::Copy(rhs);
2715 ContextSR = rhs.ContextSR;
2720 CryptographicFramework::Dump(FILE* stream)
2722 char identbuf[IdentBufferLen];
2728 InterchangeObject::Dump(stream);
2729 fprintf(stream, " %22s = %s\n", "ContextSR", ContextSR.EncodeString(identbuf, IdentBufferLen));
2734 CryptographicFramework::InitFromBuffer(const byte_t* p, ui32_t l)
2736 return InterchangeObject::InitFromBuffer(p, l);
2741 CryptographicFramework::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2743 return InterchangeObject::WriteToBuffer(Buffer);
2746 //------------------------------------------------------------------------------------------
2747 // CryptographicContext
2751 CryptographicContext::CryptographicContext(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2754 m_UL = m_Dict->ul(MDD_CryptographicContext);
2757 CryptographicContext::CryptographicContext(const CryptographicContext& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2760 m_UL = m_Dict->ul(MDD_CryptographicContext);
2767 CryptographicContext::InitFromTLVSet(TLVReader& TLVSet)
2770 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2771 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, ContextID));
2772 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, SourceEssenceContainer));
2773 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, CipherAlgorithm));
2774 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, MICAlgorithm));
2775 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, CryptographicKeyID));
2781 CryptographicContext::WriteToTLVSet(TLVWriter& TLVSet)
2784 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2785 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, ContextID));
2786 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, SourceEssenceContainer));
2787 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, CipherAlgorithm));
2788 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, MICAlgorithm));
2789 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, CryptographicKeyID));
2795 CryptographicContext::Copy(const CryptographicContext& rhs)
2797 InterchangeObject::Copy(rhs);
2798 ContextID = rhs.ContextID;
2799 SourceEssenceContainer = rhs.SourceEssenceContainer;
2800 CipherAlgorithm = rhs.CipherAlgorithm;
2801 MICAlgorithm = rhs.MICAlgorithm;
2802 CryptographicKeyID = rhs.CryptographicKeyID;
2807 CryptographicContext::Dump(FILE* stream)
2809 char identbuf[IdentBufferLen];
2815 InterchangeObject::Dump(stream);
2816 fprintf(stream, " %22s = %s\n", "ContextID", ContextID.EncodeString(identbuf, IdentBufferLen));
2817 fprintf(stream, " %22s = %s\n", "SourceEssenceContainer", SourceEssenceContainer.EncodeString(identbuf, IdentBufferLen));
2818 fprintf(stream, " %22s = %s\n", "CipherAlgorithm", CipherAlgorithm.EncodeString(identbuf, IdentBufferLen));
2819 fprintf(stream, " %22s = %s\n", "MICAlgorithm", MICAlgorithm.EncodeString(identbuf, IdentBufferLen));
2820 fprintf(stream, " %22s = %s\n", "CryptographicKeyID", CryptographicKeyID.EncodeString(identbuf, IdentBufferLen));
2825 CryptographicContext::InitFromBuffer(const byte_t* p, ui32_t l)
2827 return InterchangeObject::InitFromBuffer(p, l);
2832 CryptographicContext::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2834 return InterchangeObject::WriteToBuffer(Buffer);
2837 //------------------------------------------------------------------------------------------
2838 // DescriptiveFramework
2842 DescriptiveFramework::DescriptiveFramework(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2845 m_UL = m_Dict->ul(MDD_DescriptiveFramework);
2848 DescriptiveFramework::DescriptiveFramework(const DescriptiveFramework& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2851 m_UL = m_Dict->ul(MDD_DescriptiveFramework);
2858 DescriptiveFramework::InitFromTLVSet(TLVReader& TLVSet)
2861 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2862 if ( ASDCP_SUCCESS(result) ) {
2863 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(DescriptiveFramework, LinkedDescriptiveFrameworkPlugInId));
2864 LinkedDescriptiveFrameworkPlugInId.set_has_value( result == RESULT_OK );
2871 DescriptiveFramework::WriteToTLVSet(TLVWriter& TLVSet)
2874 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2875 if ( ASDCP_SUCCESS(result) && ! LinkedDescriptiveFrameworkPlugInId.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(DescriptiveFramework, LinkedDescriptiveFrameworkPlugInId));
2881 DescriptiveFramework::Copy(const DescriptiveFramework& rhs)
2883 InterchangeObject::Copy(rhs);
2884 LinkedDescriptiveFrameworkPlugInId = rhs.LinkedDescriptiveFrameworkPlugInId;
2889 DescriptiveFramework::Dump(FILE* stream)
2891 char identbuf[IdentBufferLen];
2897 InterchangeObject::Dump(stream);
2898 if ( ! LinkedDescriptiveFrameworkPlugInId.empty() ) {
2899 fprintf(stream, " %22s = %s\n", "LinkedDescriptiveFrameworkPlugInId", LinkedDescriptiveFrameworkPlugInId.get().EncodeString(identbuf, IdentBufferLen));
2905 DescriptiveFramework::InitFromBuffer(const byte_t* p, ui32_t l)
2907 return InterchangeObject::InitFromBuffer(p, l);
2912 DescriptiveFramework::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2914 return InterchangeObject::WriteToBuffer(Buffer);
2917 //------------------------------------------------------------------------------------------
2918 // DescriptiveObject
2922 DescriptiveObject::DescriptiveObject(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2925 m_UL = m_Dict->ul(MDD_DescriptiveObject);
2928 DescriptiveObject::DescriptiveObject(const DescriptiveObject& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2931 m_UL = m_Dict->ul(MDD_DescriptiveObject);
2938 DescriptiveObject::InitFromTLVSet(TLVReader& TLVSet)
2941 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2942 if ( ASDCP_SUCCESS(result) ) {
2943 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(DescriptiveObject, LinkedDescriptiveObjectPlugInId));
2944 LinkedDescriptiveObjectPlugInId.set_has_value( result == RESULT_OK );
2951 DescriptiveObject::WriteToTLVSet(TLVWriter& TLVSet)
2954 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2955 if ( ASDCP_SUCCESS(result) && ! LinkedDescriptiveObjectPlugInId.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(DescriptiveObject, LinkedDescriptiveObjectPlugInId));
2961 DescriptiveObject::Copy(const DescriptiveObject& rhs)
2963 InterchangeObject::Copy(rhs);
2964 LinkedDescriptiveObjectPlugInId = rhs.LinkedDescriptiveObjectPlugInId;
2969 DescriptiveObject::Dump(FILE* stream)
2971 char identbuf[IdentBufferLen];
2977 InterchangeObject::Dump(stream);
2978 if ( ! LinkedDescriptiveObjectPlugInId.empty() ) {
2979 fprintf(stream, " %22s = %s\n", "LinkedDescriptiveObjectPlugInId", LinkedDescriptiveObjectPlugInId.get().EncodeString(identbuf, IdentBufferLen));
2985 DescriptiveObject::InitFromBuffer(const byte_t* p, ui32_t l)
2987 return InterchangeObject::InitFromBuffer(p, l);
2992 DescriptiveObject::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2994 return InterchangeObject::WriteToBuffer(Buffer);
2997 //------------------------------------------------------------------------------------------
2998 // GenericDataEssenceDescriptor
3002 GenericDataEssenceDescriptor::GenericDataEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d)
3005 m_UL = m_Dict->ul(MDD_GenericDataEssenceDescriptor);
3008 GenericDataEssenceDescriptor::GenericDataEssenceDescriptor(const GenericDataEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3011 m_UL = m_Dict->ul(MDD_GenericDataEssenceDescriptor);
3018 GenericDataEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3021 Result_t result = FileDescriptor::InitFromTLVSet(TLVSet);
3022 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericDataEssenceDescriptor, DataEssenceCoding));
3028 GenericDataEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3031 Result_t result = FileDescriptor::WriteToTLVSet(TLVSet);
3032 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericDataEssenceDescriptor, DataEssenceCoding));
3038 GenericDataEssenceDescriptor::Copy(const GenericDataEssenceDescriptor& rhs)
3040 FileDescriptor::Copy(rhs);
3041 DataEssenceCoding = rhs.DataEssenceCoding;
3046 GenericDataEssenceDescriptor::Dump(FILE* stream)
3048 char identbuf[IdentBufferLen];
3054 FileDescriptor::Dump(stream);
3055 fprintf(stream, " %22s = %s\n", "DataEssenceCoding", DataEssenceCoding.EncodeString(identbuf, IdentBufferLen));
3060 GenericDataEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3062 return InterchangeObject::InitFromBuffer(p, l);
3067 GenericDataEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3069 return InterchangeObject::WriteToBuffer(Buffer);
3072 //------------------------------------------------------------------------------------------
3073 // TimedTextDescriptor
3077 TimedTextDescriptor::TimedTextDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d)
3080 m_UL = m_Dict->ul(MDD_TimedTextDescriptor);
3083 TimedTextDescriptor::TimedTextDescriptor(const TimedTextDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3086 m_UL = m_Dict->ul(MDD_TimedTextDescriptor);
3093 TimedTextDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3096 Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
3097 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextDescriptor, ResourceID));
3098 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextDescriptor, UCSEncoding));
3099 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextDescriptor, NamespaceURI));
3100 if ( ASDCP_SUCCESS(result) ) {
3101 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(TimedTextDescriptor, RFC5646LanguageTagList));
3102 RFC5646LanguageTagList.set_has_value( result == RESULT_OK );
3109 TimedTextDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3112 Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
3113 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextDescriptor, ResourceID));
3114 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextDescriptor, UCSEncoding));
3115 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextDescriptor, NamespaceURI));
3116 if ( ASDCP_SUCCESS(result) && ! RFC5646LanguageTagList.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(TimedTextDescriptor, RFC5646LanguageTagList));
3122 TimedTextDescriptor::Copy(const TimedTextDescriptor& rhs)
3124 GenericDataEssenceDescriptor::Copy(rhs);
3125 ResourceID = rhs.ResourceID;
3126 UCSEncoding = rhs.UCSEncoding;
3127 NamespaceURI = rhs.NamespaceURI;
3128 RFC5646LanguageTagList = rhs.RFC5646LanguageTagList;
3133 TimedTextDescriptor::Dump(FILE* stream)
3135 char identbuf[IdentBufferLen];
3141 GenericDataEssenceDescriptor::Dump(stream);
3142 fprintf(stream, " %22s = %s\n", "ResourceID", ResourceID.EncodeString(identbuf, IdentBufferLen));
3143 fprintf(stream, " %22s = %s\n", "UCSEncoding", UCSEncoding.EncodeString(identbuf, IdentBufferLen));
3144 fprintf(stream, " %22s = %s\n", "NamespaceURI", NamespaceURI.EncodeString(identbuf, IdentBufferLen));
3145 if ( ! RFC5646LanguageTagList.empty() ) {
3146 fprintf(stream, " %22s = %s\n", "RFC5646LanguageTagList", RFC5646LanguageTagList.get().EncodeString(identbuf, IdentBufferLen));
3152 TimedTextDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3154 return InterchangeObject::InitFromBuffer(p, l);
3159 TimedTextDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3161 return InterchangeObject::WriteToBuffer(Buffer);
3164 //------------------------------------------------------------------------------------------
3165 // TimedTextResourceSubDescriptor
3169 TimedTextResourceSubDescriptor::TimedTextResourceSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), EssenceStreamID(0)
3172 m_UL = m_Dict->ul(MDD_TimedTextResourceSubDescriptor);
3175 TimedTextResourceSubDescriptor::TimedTextResourceSubDescriptor(const TimedTextResourceSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3178 m_UL = m_Dict->ul(MDD_TimedTextResourceSubDescriptor);
3185 TimedTextResourceSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3188 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3189 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextResourceSubDescriptor, AncillaryResourceID));
3190 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextResourceSubDescriptor, MIMEMediaType));
3191 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(TimedTextResourceSubDescriptor, EssenceStreamID));
3197 TimedTextResourceSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3200 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3201 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextResourceSubDescriptor, AncillaryResourceID));
3202 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextResourceSubDescriptor, MIMEMediaType));
3203 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(TimedTextResourceSubDescriptor, EssenceStreamID));
3209 TimedTextResourceSubDescriptor::Copy(const TimedTextResourceSubDescriptor& rhs)
3211 InterchangeObject::Copy(rhs);
3212 AncillaryResourceID = rhs.AncillaryResourceID;
3213 MIMEMediaType = rhs.MIMEMediaType;
3214 EssenceStreamID = rhs.EssenceStreamID;
3219 TimedTextResourceSubDescriptor::Dump(FILE* stream)
3221 char identbuf[IdentBufferLen];
3227 InterchangeObject::Dump(stream);
3228 fprintf(stream, " %22s = %s\n", "AncillaryResourceID", AncillaryResourceID.EncodeString(identbuf, IdentBufferLen));
3229 fprintf(stream, " %22s = %s\n", "MIMEMediaType", MIMEMediaType.EncodeString(identbuf, IdentBufferLen));
3230 fprintf(stream, " %22s = %d\n", "EssenceStreamID", EssenceStreamID);
3235 TimedTextResourceSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3237 return InterchangeObject::InitFromBuffer(p, l);
3242 TimedTextResourceSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3244 return InterchangeObject::WriteToBuffer(Buffer);
3247 //------------------------------------------------------------------------------------------
3248 // StereoscopicPictureSubDescriptor
3252 StereoscopicPictureSubDescriptor::StereoscopicPictureSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
3255 m_UL = m_Dict->ul(MDD_StereoscopicPictureSubDescriptor);
3258 StereoscopicPictureSubDescriptor::StereoscopicPictureSubDescriptor(const StereoscopicPictureSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3261 m_UL = m_Dict->ul(MDD_StereoscopicPictureSubDescriptor);
3268 StereoscopicPictureSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3271 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3277 StereoscopicPictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3280 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3286 StereoscopicPictureSubDescriptor::Copy(const StereoscopicPictureSubDescriptor& rhs)
3288 InterchangeObject::Copy(rhs);
3293 StereoscopicPictureSubDescriptor::Dump(FILE* stream)
3295 char identbuf[IdentBufferLen];
3301 InterchangeObject::Dump(stream);
3306 StereoscopicPictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3308 return InterchangeObject::InitFromBuffer(p, l);
3313 StereoscopicPictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3315 return InterchangeObject::WriteToBuffer(Buffer);
3318 //------------------------------------------------------------------------------------------
3319 // ContainerConstraintsSubDescriptor
3323 ContainerConstraintsSubDescriptor::ContainerConstraintsSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
3326 m_UL = m_Dict->ul(MDD_ContainerConstraintsSubDescriptor);
3329 ContainerConstraintsSubDescriptor::ContainerConstraintsSubDescriptor(const ContainerConstraintsSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3332 m_UL = m_Dict->ul(MDD_ContainerConstraintsSubDescriptor);
3339 ContainerConstraintsSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3342 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3348 ContainerConstraintsSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3351 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3357 ContainerConstraintsSubDescriptor::Copy(const ContainerConstraintsSubDescriptor& rhs)
3359 InterchangeObject::Copy(rhs);
3364 ContainerConstraintsSubDescriptor::Dump(FILE* stream)
3366 char identbuf[IdentBufferLen];
3372 InterchangeObject::Dump(stream);
3377 ContainerConstraintsSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3379 return InterchangeObject::InitFromBuffer(p, l);
3384 ContainerConstraintsSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3386 return InterchangeObject::WriteToBuffer(Buffer);
3389 //------------------------------------------------------------------------------------------
3394 NetworkLocator::NetworkLocator(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
3397 m_UL = m_Dict->ul(MDD_NetworkLocator);
3400 NetworkLocator::NetworkLocator(const NetworkLocator& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3403 m_UL = m_Dict->ul(MDD_NetworkLocator);
3410 NetworkLocator::InitFromTLVSet(TLVReader& TLVSet)
3413 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3414 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(NetworkLocator, URLString));
3420 NetworkLocator::WriteToTLVSet(TLVWriter& TLVSet)
3423 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3424 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(NetworkLocator, URLString));
3430 NetworkLocator::Copy(const NetworkLocator& rhs)
3432 InterchangeObject::Copy(rhs);
3433 URLString = rhs.URLString;
3438 NetworkLocator::Dump(FILE* stream)
3440 char identbuf[IdentBufferLen];
3446 InterchangeObject::Dump(stream);
3447 fprintf(stream, " %22s = %s\n", "URLString", URLString.EncodeString(identbuf, IdentBufferLen));
3452 NetworkLocator::InitFromBuffer(const byte_t* p, ui32_t l)
3454 return InterchangeObject::InitFromBuffer(p, l);
3459 NetworkLocator::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3461 return InterchangeObject::WriteToBuffer(Buffer);
3464 //------------------------------------------------------------------------------------------
3465 // MCALabelSubDescriptor
3469 MCALabelSubDescriptor::MCALabelSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
3472 m_UL = m_Dict->ul(MDD_MCALabelSubDescriptor);
3475 MCALabelSubDescriptor::MCALabelSubDescriptor(const MCALabelSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3478 m_UL = m_Dict->ul(MDD_MCALabelSubDescriptor);
3485 MCALabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3488 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3489 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCALabelDictionaryID));
3490 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCALinkID));
3491 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCATagSymbol));
3492 if ( ASDCP_SUCCESS(result) ) {
3493 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCATagName));
3494 MCATagName.set_has_value( result == RESULT_OK );
3496 if ( ASDCP_SUCCESS(result) ) {
3497 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCAChannelID));
3498 MCAChannelID.set_has_value( result == RESULT_OK );
3500 if ( ASDCP_SUCCESS(result) ) {
3501 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, RFC5646SpokenLanguage));
3502 RFC5646SpokenLanguage.set_has_value( result == RESULT_OK );
3504 if ( ASDCP_SUCCESS(result) ) {
3505 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCATitle));
3506 MCATitle.set_has_value( result == RESULT_OK );
3508 if ( ASDCP_SUCCESS(result) ) {
3509 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCATitleVersion));
3510 MCATitleVersion.set_has_value( result == RESULT_OK );
3512 if ( ASDCP_SUCCESS(result) ) {
3513 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCATitleSubVersion));
3514 MCATitleSubVersion.set_has_value( result == RESULT_OK );
3516 if ( ASDCP_SUCCESS(result) ) {
3517 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCAEpisode));
3518 MCAEpisode.set_has_value( result == RESULT_OK );
3520 if ( ASDCP_SUCCESS(result) ) {
3521 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCAPartitionKind));
3522 MCAPartitionKind.set_has_value( result == RESULT_OK );
3524 if ( ASDCP_SUCCESS(result) ) {
3525 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCAPartitionNumber));
3526 MCAPartitionNumber.set_has_value( result == RESULT_OK );
3528 if ( ASDCP_SUCCESS(result) ) {
3529 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCAAudioContentKind));
3530 MCAAudioContentKind.set_has_value( result == RESULT_OK );
3532 if ( ASDCP_SUCCESS(result) ) {
3533 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCAAudioElementKind));
3534 MCAAudioElementKind.set_has_value( result == RESULT_OK );
3541 MCALabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3544 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3545 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCALabelDictionaryID));
3546 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCALinkID));
3547 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCATagSymbol));
3548 if ( ASDCP_SUCCESS(result) && ! MCATagName.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCATagName));
3549 if ( ASDCP_SUCCESS(result) && ! MCAChannelID.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCAChannelID));
3550 if ( ASDCP_SUCCESS(result) && ! RFC5646SpokenLanguage.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, RFC5646SpokenLanguage));
3551 if ( ASDCP_SUCCESS(result) && ! MCATitle.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCATitle));
3552 if ( ASDCP_SUCCESS(result) && ! MCATitleVersion.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCATitleVersion));
3553 if ( ASDCP_SUCCESS(result) && ! MCATitleSubVersion.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCATitleSubVersion));
3554 if ( ASDCP_SUCCESS(result) && ! MCAEpisode.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCAEpisode));
3555 if ( ASDCP_SUCCESS(result) && ! MCAPartitionKind.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCAPartitionKind));
3556 if ( ASDCP_SUCCESS(result) && ! MCAPartitionNumber.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCAPartitionNumber));
3557 if ( ASDCP_SUCCESS(result) && ! MCAAudioContentKind.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCAAudioContentKind));
3558 if ( ASDCP_SUCCESS(result) && ! MCAAudioElementKind.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCAAudioElementKind));
3564 MCALabelSubDescriptor::Copy(const MCALabelSubDescriptor& rhs)
3566 InterchangeObject::Copy(rhs);
3567 MCALabelDictionaryID = rhs.MCALabelDictionaryID;
3568 MCALinkID = rhs.MCALinkID;
3569 MCATagSymbol = rhs.MCATagSymbol;
3570 MCATagName = rhs.MCATagName;
3571 MCAChannelID = rhs.MCAChannelID;
3572 RFC5646SpokenLanguage = rhs.RFC5646SpokenLanguage;
3573 MCATitle = rhs.MCATitle;
3574 MCATitleVersion = rhs.MCATitleVersion;
3575 MCATitleSubVersion = rhs.MCATitleSubVersion;
3576 MCAEpisode = rhs.MCAEpisode;
3577 MCAPartitionKind = rhs.MCAPartitionKind;
3578 MCAPartitionNumber = rhs.MCAPartitionNumber;
3579 MCAAudioContentKind = rhs.MCAAudioContentKind;
3580 MCAAudioElementKind = rhs.MCAAudioElementKind;
3585 MCALabelSubDescriptor::Dump(FILE* stream)
3587 char identbuf[IdentBufferLen];
3593 InterchangeObject::Dump(stream);
3594 fprintf(stream, " %22s = %s\n", "MCALabelDictionaryID", MCALabelDictionaryID.EncodeString(identbuf, IdentBufferLen));
3595 fprintf(stream, " %22s = %s\n", "MCALinkID", MCALinkID.EncodeString(identbuf, IdentBufferLen));
3596 fprintf(stream, " %22s = %s\n", "MCATagSymbol", MCATagSymbol.EncodeString(identbuf, IdentBufferLen));
3597 if ( ! MCATagName.empty() ) {
3598 fprintf(stream, " %22s = %s\n", "MCATagName", MCATagName.get().EncodeString(identbuf, IdentBufferLen));
3600 if ( ! MCAChannelID.empty() ) {
3601 fprintf(stream, " %22s = %d\n", "MCAChannelID", MCAChannelID.get());
3603 if ( ! RFC5646SpokenLanguage.empty() ) {
3604 fprintf(stream, " %22s = %s\n", "RFC5646SpokenLanguage", RFC5646SpokenLanguage.get().EncodeString(identbuf, IdentBufferLen));
3606 if ( ! MCATitle.empty() ) {
3607 fprintf(stream, " %22s = %s\n", "MCATitle", MCATitle.get().EncodeString(identbuf, IdentBufferLen));
3609 if ( ! MCATitleVersion.empty() ) {
3610 fprintf(stream, " %22s = %s\n", "MCATitleVersion", MCATitleVersion.get().EncodeString(identbuf, IdentBufferLen));
3612 if ( ! MCATitleSubVersion.empty() ) {
3613 fprintf(stream, " %22s = %s\n", "MCATitleSubVersion", MCATitleSubVersion.get().EncodeString(identbuf, IdentBufferLen));
3615 if ( ! MCAEpisode.empty() ) {
3616 fprintf(stream, " %22s = %s\n", "MCAEpisode", MCAEpisode.get().EncodeString(identbuf, IdentBufferLen));
3618 if ( ! MCAPartitionKind.empty() ) {
3619 fprintf(stream, " %22s = %s\n", "MCAPartitionKind", MCAPartitionKind.get().EncodeString(identbuf, IdentBufferLen));
3621 if ( ! MCAPartitionNumber.empty() ) {
3622 fprintf(stream, " %22s = %s\n", "MCAPartitionNumber", MCAPartitionNumber.get().EncodeString(identbuf, IdentBufferLen));
3624 if ( ! MCAAudioContentKind.empty() ) {
3625 fprintf(stream, " %22s = %s\n", "MCAAudioContentKind", MCAAudioContentKind.get().EncodeString(identbuf, IdentBufferLen));
3627 if ( ! MCAAudioElementKind.empty() ) {
3628 fprintf(stream, " %22s = %s\n", "MCAAudioElementKind", MCAAudioElementKind.get().EncodeString(identbuf, IdentBufferLen));
3634 MCALabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3636 return InterchangeObject::InitFromBuffer(p, l);
3641 MCALabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3643 return InterchangeObject::WriteToBuffer(Buffer);
3646 //------------------------------------------------------------------------------------------
3647 // AudioChannelLabelSubDescriptor
3651 AudioChannelLabelSubDescriptor::AudioChannelLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d)
3654 m_UL = m_Dict->ul(MDD_AudioChannelLabelSubDescriptor);
3657 AudioChannelLabelSubDescriptor::AudioChannelLabelSubDescriptor(const AudioChannelLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3660 m_UL = m_Dict->ul(MDD_AudioChannelLabelSubDescriptor);
3667 AudioChannelLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3670 Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet);
3671 if ( ASDCP_SUCCESS(result) ) {
3672 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(AudioChannelLabelSubDescriptor, SoundfieldGroupLinkID));
3673 SoundfieldGroupLinkID.set_has_value( result == RESULT_OK );
3680 AudioChannelLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3683 Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet);
3684 if ( ASDCP_SUCCESS(result) && ! SoundfieldGroupLinkID.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(AudioChannelLabelSubDescriptor, SoundfieldGroupLinkID));
3690 AudioChannelLabelSubDescriptor::Copy(const AudioChannelLabelSubDescriptor& rhs)
3692 MCALabelSubDescriptor::Copy(rhs);
3693 SoundfieldGroupLinkID = rhs.SoundfieldGroupLinkID;
3698 AudioChannelLabelSubDescriptor::Dump(FILE* stream)
3700 char identbuf[IdentBufferLen];
3706 MCALabelSubDescriptor::Dump(stream);
3707 if ( ! SoundfieldGroupLinkID.empty() ) {
3708 fprintf(stream, " %22s = %s\n", "SoundfieldGroupLinkID", SoundfieldGroupLinkID.get().EncodeString(identbuf, IdentBufferLen));
3714 AudioChannelLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3716 return InterchangeObject::InitFromBuffer(p, l);
3721 AudioChannelLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3723 return InterchangeObject::WriteToBuffer(Buffer);
3726 //------------------------------------------------------------------------------------------
3727 // SoundfieldGroupLabelSubDescriptor
3731 SoundfieldGroupLabelSubDescriptor::SoundfieldGroupLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d)
3734 m_UL = m_Dict->ul(MDD_SoundfieldGroupLabelSubDescriptor);
3737 SoundfieldGroupLabelSubDescriptor::SoundfieldGroupLabelSubDescriptor(const SoundfieldGroupLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3740 m_UL = m_Dict->ul(MDD_SoundfieldGroupLabelSubDescriptor);
3747 SoundfieldGroupLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3750 Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet);
3751 if ( ASDCP_SUCCESS(result) ) {
3752 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(SoundfieldGroupLabelSubDescriptor, GroupOfSoundfieldGroupsLinkID));
3759 SoundfieldGroupLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3762 Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet);
3763 if ( ASDCP_SUCCESS(result) && ! GroupOfSoundfieldGroupsLinkID.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(SoundfieldGroupLabelSubDescriptor, GroupOfSoundfieldGroupsLinkID));
3769 SoundfieldGroupLabelSubDescriptor::Copy(const SoundfieldGroupLabelSubDescriptor& rhs)
3771 MCALabelSubDescriptor::Copy(rhs);
3772 GroupOfSoundfieldGroupsLinkID = rhs.GroupOfSoundfieldGroupsLinkID;
3777 SoundfieldGroupLabelSubDescriptor::Dump(FILE* stream)
3779 char identbuf[IdentBufferLen];
3785 MCALabelSubDescriptor::Dump(stream);
3786 if ( ! GroupOfSoundfieldGroupsLinkID.empty() ) {
3787 fprintf(stream, " %22s:\n", "GroupOfSoundfieldGroupsLinkID");
3788 GroupOfSoundfieldGroupsLinkID.get().Dump(stream);
3794 SoundfieldGroupLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3796 return InterchangeObject::InitFromBuffer(p, l);
3801 SoundfieldGroupLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3803 return InterchangeObject::WriteToBuffer(Buffer);
3806 //------------------------------------------------------------------------------------------
3807 // GroupOfSoundfieldGroupsLabelSubDescriptor
3811 GroupOfSoundfieldGroupsLabelSubDescriptor::GroupOfSoundfieldGroupsLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d)
3814 m_UL = m_Dict->ul(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor);
3817 GroupOfSoundfieldGroupsLabelSubDescriptor::GroupOfSoundfieldGroupsLabelSubDescriptor(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3820 m_UL = m_Dict->ul(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor);
3827 GroupOfSoundfieldGroupsLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3830 Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet);
3836 GroupOfSoundfieldGroupsLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3839 Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet);
3845 GroupOfSoundfieldGroupsLabelSubDescriptor::Copy(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs)
3847 MCALabelSubDescriptor::Copy(rhs);
3852 GroupOfSoundfieldGroupsLabelSubDescriptor::Dump(FILE* stream)
3854 char identbuf[IdentBufferLen];
3860 MCALabelSubDescriptor::Dump(stream);
3865 GroupOfSoundfieldGroupsLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3867 return InterchangeObject::InitFromBuffer(p, l);
3872 GroupOfSoundfieldGroupsLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3874 return InterchangeObject::WriteToBuffer(Buffer);
3877 //------------------------------------------------------------------------------------------
3882 DCDataDescriptor::DCDataDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d)
3885 m_UL = m_Dict->ul(MDD_DCDataDescriptor);
3888 DCDataDescriptor::DCDataDescriptor(const DCDataDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3891 m_UL = m_Dict->ul(MDD_DCDataDescriptor);
3898 DCDataDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3901 Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
3907 DCDataDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3910 Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
3916 DCDataDescriptor::Copy(const DCDataDescriptor& rhs)
3918 GenericDataEssenceDescriptor::Copy(rhs);
3923 DCDataDescriptor::Dump(FILE* stream)
3925 char identbuf[IdentBufferLen];
3931 GenericDataEssenceDescriptor::Dump(stream);
3936 DCDataDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3938 return InterchangeObject::InitFromBuffer(p, l);
3943 DCDataDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3945 return InterchangeObject::WriteToBuffer(Buffer);
3948 //------------------------------------------------------------------------------------------
3949 // PrivateDCDataDescriptor
3953 PrivateDCDataDescriptor::PrivateDCDataDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d)
3956 m_UL = m_Dict->ul(MDD_PrivateDCDataDescriptor);
3959 PrivateDCDataDescriptor::PrivateDCDataDescriptor(const PrivateDCDataDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3962 m_UL = m_Dict->ul(MDD_PrivateDCDataDescriptor);
3969 PrivateDCDataDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3972 Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
3978 PrivateDCDataDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3981 Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
3987 PrivateDCDataDescriptor::Copy(const PrivateDCDataDescriptor& rhs)
3989 GenericDataEssenceDescriptor::Copy(rhs);
3994 PrivateDCDataDescriptor::Dump(FILE* stream)
3996 char identbuf[IdentBufferLen];
4002 GenericDataEssenceDescriptor::Dump(stream);
4007 PrivateDCDataDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
4009 return InterchangeObject::InitFromBuffer(p, l);
4014 PrivateDCDataDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4016 return InterchangeObject::WriteToBuffer(Buffer);
4019 //------------------------------------------------------------------------------------------
4020 // DolbyAtmosSubDescriptor
4024 DolbyAtmosSubDescriptor::DolbyAtmosSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), FirstFrame(0), MaxChannelCount(0), MaxObjectCount(0), AtmosVersion(0)
4027 m_UL = m_Dict->ul(MDD_DolbyAtmosSubDescriptor);
4030 DolbyAtmosSubDescriptor::DolbyAtmosSubDescriptor(const DolbyAtmosSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
4033 m_UL = m_Dict->ul(MDD_DolbyAtmosSubDescriptor);
4040 DolbyAtmosSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
4043 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
4044 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, AtmosID));
4045 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, FirstFrame));
4046 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, MaxChannelCount));
4047 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, MaxObjectCount));
4048 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, AtmosVersion));
4054 DolbyAtmosSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
4057 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
4058 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, AtmosID));
4059 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, FirstFrame));
4060 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, MaxChannelCount));
4061 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, MaxObjectCount));
4062 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, AtmosVersion));
4068 DolbyAtmosSubDescriptor::Copy(const DolbyAtmosSubDescriptor& rhs)
4070 InterchangeObject::Copy(rhs);
4071 AtmosID = rhs.AtmosID;
4072 FirstFrame = rhs.FirstFrame;
4073 MaxChannelCount = rhs.MaxChannelCount;
4074 MaxObjectCount = rhs.MaxObjectCount;
4075 AtmosVersion = rhs.AtmosVersion;
4080 DolbyAtmosSubDescriptor::Dump(FILE* stream)
4082 char identbuf[IdentBufferLen];
4088 InterchangeObject::Dump(stream);
4089 fprintf(stream, " %22s = %s\n", "AtmosID", AtmosID.EncodeString(identbuf, IdentBufferLen));
4090 fprintf(stream, " %22s = %d\n", "FirstFrame", FirstFrame);
4091 fprintf(stream, " %22s = %d\n", "MaxChannelCount", MaxChannelCount);
4092 fprintf(stream, " %22s = %d\n", "MaxObjectCount", MaxObjectCount);
4093 fprintf(stream, " %22s = %d\n", "AtmosVersion", AtmosVersion);
4098 DolbyAtmosSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
4100 return InterchangeObject::InitFromBuffer(p, l);
4105 DolbyAtmosSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4107 return InterchangeObject::WriteToBuffer(Buffer);
4110 //------------------------------------------------------------------------------------------
4111 // ACESPictureSubDescriptor
4115 ACESPictureSubDescriptor::ACESPictureSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
4118 m_UL = m_Dict->ul(MDD_ACESPictureSubDescriptor);
4121 ACESPictureSubDescriptor::ACESPictureSubDescriptor(const ACESPictureSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
4124 m_UL = m_Dict->ul(MDD_ACESPictureSubDescriptor);
4131 ACESPictureSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
4134 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
4135 if ( ASDCP_SUCCESS(result) ) {
4136 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(ACESPictureSubDescriptor, ACESAuthoringInformation));
4137 ACESAuthoringInformation.set_has_value( result == RESULT_OK );
4139 if ( ASDCP_SUCCESS(result) ) {
4140 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayPrimaries));
4141 ACESMasteringDisplayPrimaries.set_has_value( result == RESULT_OK );
4143 if ( ASDCP_SUCCESS(result) ) {
4144 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayWhitePointChromaticity));
4145 ACESMasteringDisplayWhitePointChromaticity.set_has_value( result == RESULT_OK );
4147 if ( ASDCP_SUCCESS(result) ) {
4148 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayMaximumLuminance));
4149 ACESMasteringDisplayMaximumLuminance.set_has_value( result == RESULT_OK );
4151 if ( ASDCP_SUCCESS(result) ) {
4152 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayMinimumLuminance));
4153 ACESMasteringDisplayMinimumLuminance.set_has_value( result == RESULT_OK );
4160 ACESPictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
4163 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
4164 if ( ASDCP_SUCCESS(result) && ! ACESAuthoringInformation.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(ACESPictureSubDescriptor, ACESAuthoringInformation));
4165 if ( ASDCP_SUCCESS(result) && ! ACESMasteringDisplayPrimaries.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayPrimaries));
4166 if ( ASDCP_SUCCESS(result) && ! ACESMasteringDisplayWhitePointChromaticity.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayWhitePointChromaticity));
4167 if ( ASDCP_SUCCESS(result) && ! ACESMasteringDisplayMaximumLuminance.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayMaximumLuminance));
4168 if ( ASDCP_SUCCESS(result) && ! ACESMasteringDisplayMinimumLuminance.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayMinimumLuminance));
4174 ACESPictureSubDescriptor::Copy(const ACESPictureSubDescriptor& rhs)
4176 InterchangeObject::Copy(rhs);
4177 ACESAuthoringInformation = rhs.ACESAuthoringInformation;
4178 ACESMasteringDisplayPrimaries = rhs.ACESMasteringDisplayPrimaries;
4179 ACESMasteringDisplayWhitePointChromaticity = rhs.ACESMasteringDisplayWhitePointChromaticity;
4180 ACESMasteringDisplayMaximumLuminance = rhs.ACESMasteringDisplayMaximumLuminance;
4181 ACESMasteringDisplayMinimumLuminance = rhs.ACESMasteringDisplayMinimumLuminance;
4186 ACESPictureSubDescriptor::Dump(FILE* stream)
4188 char identbuf[IdentBufferLen];
4194 InterchangeObject::Dump(stream);
4195 if ( ! ACESAuthoringInformation.empty() ) {
4196 fprintf(stream, " %22s = %s\n", "ACESAuthoringInformation", ACESAuthoringInformation.get().EncodeString(identbuf, IdentBufferLen));
4198 if ( ! ACESMasteringDisplayPrimaries.empty() ) {
4199 fprintf(stream, " %22s = %s\n", "ACESMasteringDisplayPrimaries", ACESMasteringDisplayPrimaries.get().EncodeString(identbuf, IdentBufferLen));
4201 if ( ! ACESMasteringDisplayWhitePointChromaticity.empty() ) {
4202 fprintf(stream, " %22s = %s\n", "ACESMasteringDisplayWhitePointChromaticity", ACESMasteringDisplayWhitePointChromaticity.get().EncodeString(identbuf, IdentBufferLen));
4204 if ( ! ACESMasteringDisplayMaximumLuminance.empty() ) {
4205 fprintf(stream, " %22s = %d\n", "ACESMasteringDisplayMaximumLuminance", ACESMasteringDisplayMaximumLuminance.get());
4207 if ( ! ACESMasteringDisplayMinimumLuminance.empty() ) {
4208 fprintf(stream, " %22s = %d\n", "ACESMasteringDisplayMinimumLuminance", ACESMasteringDisplayMinimumLuminance.get());
4214 ACESPictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
4216 return InterchangeObject::InitFromBuffer(p, l);
4221 ACESPictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4223 return InterchangeObject::WriteToBuffer(Buffer);
4226 //------------------------------------------------------------------------------------------
4227 // TargetFrameSubDescriptor
4231 TargetFrameSubDescriptor::TargetFrameSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), TargetFrameIndex(0), TargetFrameComponentMaxRef(0), TargetFrameComponentMinRef(0), TargetFrameEssenceStreamID(0)
4234 m_UL = m_Dict->ul(MDD_TargetFrameSubDescriptor);
4237 TargetFrameSubDescriptor::TargetFrameSubDescriptor(const TargetFrameSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
4240 m_UL = m_Dict->ul(MDD_TargetFrameSubDescriptor);
4247 TargetFrameSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
4250 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
4251 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameAncillaryResourceID));
4252 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TargetFrameSubDescriptor, MediaType));
4253 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameIndex));
4254 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameTransferCharacteristic));
4255 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameColorPrimaries));
4256 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameComponentMaxRef));
4257 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameComponentMinRef));
4258 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameEssenceStreamID));
4259 if ( ASDCP_SUCCESS(result) ) {
4260 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(TargetFrameSubDescriptor, ACESPictureSubDescriptorInstanceID));
4261 ACESPictureSubDescriptorInstanceID.set_has_value( result == RESULT_OK );
4263 if ( ASDCP_SUCCESS(result) ) {
4264 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(TargetFrameSubDescriptor, TargetFrameViewingEnvironment));
4265 TargetFrameViewingEnvironment.set_has_value( result == RESULT_OK );
4272 TargetFrameSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
4275 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
4276 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameAncillaryResourceID));
4277 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, MediaType));
4278 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameIndex));
4279 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameTransferCharacteristic));
4280 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameColorPrimaries));
4281 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameComponentMaxRef));
4282 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameComponentMinRef));
4283 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameEssenceStreamID));
4284 if ( ASDCP_SUCCESS(result) && ! ACESPictureSubDescriptorInstanceID.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(TargetFrameSubDescriptor, ACESPictureSubDescriptorInstanceID));
4285 if ( ASDCP_SUCCESS(result) && ! TargetFrameViewingEnvironment.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(TargetFrameSubDescriptor, TargetFrameViewingEnvironment));
4291 TargetFrameSubDescriptor::Copy(const TargetFrameSubDescriptor& rhs)
4293 InterchangeObject::Copy(rhs);
4294 TargetFrameAncillaryResourceID = rhs.TargetFrameAncillaryResourceID;
4295 MediaType = rhs.MediaType;
4296 TargetFrameIndex = rhs.TargetFrameIndex;
4297 TargetFrameTransferCharacteristic = rhs.TargetFrameTransferCharacteristic;
4298 TargetFrameColorPrimaries = rhs.TargetFrameColorPrimaries;
4299 TargetFrameComponentMaxRef = rhs.TargetFrameComponentMaxRef;
4300 TargetFrameComponentMinRef = rhs.TargetFrameComponentMinRef;
4301 TargetFrameEssenceStreamID = rhs.TargetFrameEssenceStreamID;
4302 ACESPictureSubDescriptorInstanceID = rhs.ACESPictureSubDescriptorInstanceID;
4303 TargetFrameViewingEnvironment = rhs.TargetFrameViewingEnvironment;
4308 TargetFrameSubDescriptor::Dump(FILE* stream)
4310 char identbuf[IdentBufferLen];
4316 InterchangeObject::Dump(stream);
4317 fprintf(stream, " %22s = %s\n", "TargetFrameAncillaryResourceID", TargetFrameAncillaryResourceID.EncodeString(identbuf, IdentBufferLen));
4318 fprintf(stream, " %22s = %s\n", "MediaType", MediaType.EncodeString(identbuf, IdentBufferLen));
4319 fprintf(stream, " %22s = %s\n", "TargetFrameIndex", i64sz(TargetFrameIndex, identbuf));
4320 fprintf(stream, " %22s = %s\n", "TargetFrameTransferCharacteristic", TargetFrameTransferCharacteristic.EncodeString(identbuf, IdentBufferLen));
4321 fprintf(stream, " %22s = %s\n", "TargetFrameColorPrimaries", TargetFrameColorPrimaries.EncodeString(identbuf, IdentBufferLen));
4322 fprintf(stream, " %22s = %d\n", "TargetFrameComponentMaxRef", TargetFrameComponentMaxRef);
4323 fprintf(stream, " %22s = %d\n", "TargetFrameComponentMinRef", TargetFrameComponentMinRef);
4324 fprintf(stream, " %22s = %d\n", "TargetFrameEssenceStreamID", TargetFrameEssenceStreamID);
4325 if ( ! ACESPictureSubDescriptorInstanceID.empty() ) {
4326 fprintf(stream, " %22s = %s\n", "ACESPictureSubDescriptorInstanceID", ACESPictureSubDescriptorInstanceID.get().EncodeString(identbuf, IdentBufferLen));
4328 if ( ! TargetFrameViewingEnvironment.empty() ) {
4329 fprintf(stream, " %22s = %s\n", "TargetFrameViewingEnvironment", TargetFrameViewingEnvironment.get().EncodeString(identbuf, IdentBufferLen));
4335 TargetFrameSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
4337 return InterchangeObject::InitFromBuffer(p, l);
4342 TargetFrameSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4344 return InterchangeObject::WriteToBuffer(Buffer);
4347 //------------------------------------------------------------------------------------------
4348 // TextBasedDMFramework
4352 TextBasedDMFramework::TextBasedDMFramework(const Dictionary*& d) : DescriptiveFramework(d), m_Dict(d)
4355 m_UL = m_Dict->ul(MDD_TextBasedDMFramework);
4358 TextBasedDMFramework::TextBasedDMFramework(const TextBasedDMFramework& rhs) : DescriptiveFramework(rhs.m_Dict), m_Dict(rhs.m_Dict)
4361 m_UL = m_Dict->ul(MDD_TextBasedDMFramework);
4368 TextBasedDMFramework::InitFromTLVSet(TLVReader& TLVSet)
4371 Result_t result = DescriptiveFramework::InitFromTLVSet(TLVSet);
4372 if ( ASDCP_SUCCESS(result) ) {
4373 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(TextBasedDMFramework, ObjectRef));
4374 ObjectRef.set_has_value( result == RESULT_OK );
4381 TextBasedDMFramework::WriteToTLVSet(TLVWriter& TLVSet)
4384 Result_t result = DescriptiveFramework::WriteToTLVSet(TLVSet);
4385 if ( ASDCP_SUCCESS(result) && ! ObjectRef.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(TextBasedDMFramework, ObjectRef));
4391 TextBasedDMFramework::Copy(const TextBasedDMFramework& rhs)
4393 DescriptiveFramework::Copy(rhs);
4394 ObjectRef = rhs.ObjectRef;
4399 TextBasedDMFramework::Dump(FILE* stream)
4401 char identbuf[IdentBufferLen];
4407 DescriptiveFramework::Dump(stream);
4408 if ( ! ObjectRef.empty() ) {
4409 fprintf(stream, " %22s = %s\n", "ObjectRef", ObjectRef.get().EncodeString(identbuf, IdentBufferLen));
4415 TextBasedDMFramework::InitFromBuffer(const byte_t* p, ui32_t l)
4417 return InterchangeObject::InitFromBuffer(p, l);
4422 TextBasedDMFramework::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4424 return InterchangeObject::WriteToBuffer(Buffer);
4427 //------------------------------------------------------------------------------------------
4432 TextBasedObject::TextBasedObject(const Dictionary*& d) : DescriptiveObject(d), m_Dict(d)
4435 m_UL = m_Dict->ul(MDD_TextBasedObject);
4438 TextBasedObject::TextBasedObject(const TextBasedObject& rhs) : DescriptiveObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
4441 m_UL = m_Dict->ul(MDD_TextBasedObject);
4448 TextBasedObject::InitFromTLVSet(TLVReader& TLVSet)
4451 Result_t result = DescriptiveObject::InitFromTLVSet(TLVSet);
4452 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TextBasedObject, PayloadSchemeID));
4453 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TextBasedObject, TextMIMEMediaType));
4454 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TextBasedObject, RFC5646TextLanguageCode));
4455 if ( ASDCP_SUCCESS(result) ) {
4456 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(TextBasedObject, TextDataDescription));
4457 TextDataDescription.set_has_value( result == RESULT_OK );
4464 TextBasedObject::WriteToTLVSet(TLVWriter& TLVSet)
4467 Result_t result = DescriptiveObject::WriteToTLVSet(TLVSet);
4468 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TextBasedObject, PayloadSchemeID));
4469 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TextBasedObject, TextMIMEMediaType));
4470 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TextBasedObject, RFC5646TextLanguageCode));
4471 if ( ASDCP_SUCCESS(result) && ! TextDataDescription.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(TextBasedObject, TextDataDescription));
4477 TextBasedObject::Copy(const TextBasedObject& rhs)
4479 DescriptiveObject::Copy(rhs);
4480 PayloadSchemeID = rhs.PayloadSchemeID;
4481 TextMIMEMediaType = rhs.TextMIMEMediaType;
4482 RFC5646TextLanguageCode = rhs.RFC5646TextLanguageCode;
4483 TextDataDescription = rhs.TextDataDescription;
4488 TextBasedObject::Dump(FILE* stream)
4490 char identbuf[IdentBufferLen];
4496 DescriptiveObject::Dump(stream);
4497 fprintf(stream, " %22s = %s\n", "PayloadSchemeID", PayloadSchemeID.EncodeString(identbuf, IdentBufferLen));
4498 fprintf(stream, " %22s = %s\n", "TextMIMEMediaType", TextMIMEMediaType.EncodeString(identbuf, IdentBufferLen));
4499 fprintf(stream, " %22s = %s\n", "RFC5646TextLanguageCode", RFC5646TextLanguageCode.EncodeString(identbuf, IdentBufferLen));
4500 if ( ! TextDataDescription.empty() ) {
4501 fprintf(stream, " %22s = %s\n", "TextDataDescription", TextDataDescription.get().EncodeString(identbuf, IdentBufferLen));
4507 TextBasedObject::InitFromBuffer(const byte_t* p, ui32_t l)
4509 return InterchangeObject::InitFromBuffer(p, l);
4514 TextBasedObject::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4516 return InterchangeObject::WriteToBuffer(Buffer);
4519 //------------------------------------------------------------------------------------------
4520 // GenericStreamTextBasedSet
4524 GenericStreamTextBasedSet::GenericStreamTextBasedSet(const Dictionary*& d) : TextBasedObject(d), m_Dict(d), GenericStreamSID(0)
4527 m_UL = m_Dict->ul(MDD_GenericStreamTextBasedSet);
4530 GenericStreamTextBasedSet::GenericStreamTextBasedSet(const GenericStreamTextBasedSet& rhs) : TextBasedObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
4533 m_UL = m_Dict->ul(MDD_GenericStreamTextBasedSet);
4540 GenericStreamTextBasedSet::InitFromTLVSet(TLVReader& TLVSet)
4543 Result_t result = TextBasedObject::InitFromTLVSet(TLVSet);
4544 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericStreamTextBasedSet, GenericStreamSID));
4550 GenericStreamTextBasedSet::WriteToTLVSet(TLVWriter& TLVSet)
4553 Result_t result = TextBasedObject::WriteToTLVSet(TLVSet);
4554 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericStreamTextBasedSet, GenericStreamSID));
4560 GenericStreamTextBasedSet::Copy(const GenericStreamTextBasedSet& rhs)
4562 TextBasedObject::Copy(rhs);
4563 GenericStreamSID = rhs.GenericStreamSID;
4568 GenericStreamTextBasedSet::Dump(FILE* stream)
4570 char identbuf[IdentBufferLen];
4576 TextBasedObject::Dump(stream);
4577 fprintf(stream, " %22s = %d\n", "GenericStreamSID", GenericStreamSID);
4582 GenericStreamTextBasedSet::InitFromBuffer(const byte_t* p, ui32_t l)
4584 return InterchangeObject::InitFromBuffer(p, l);
4589 GenericStreamTextBasedSet::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4591 return InterchangeObject::WriteToBuffer(Buffer);
4594 //------------------------------------------------------------------------------------------
4595 // ISXDDataEssenceDescriptor
4599 ISXDDataEssenceDescriptor::ISXDDataEssenceDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d)
4602 m_UL = m_Dict->ul(MDD_ISXDDataEssenceDescriptor);
4605 ISXDDataEssenceDescriptor::ISXDDataEssenceDescriptor(const ISXDDataEssenceDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
4608 m_UL = m_Dict->ul(MDD_ISXDDataEssenceDescriptor);
4615 ISXDDataEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
4618 Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
4619 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(ISXDDataEssenceDescriptor, NamespaceURI));
4625 ISXDDataEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
4628 Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
4629 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(ISXDDataEssenceDescriptor, NamespaceURI));
4635 ISXDDataEssenceDescriptor::Copy(const ISXDDataEssenceDescriptor& rhs)
4637 GenericDataEssenceDescriptor::Copy(rhs);
4638 NamespaceURI = rhs.NamespaceURI;
4643 ISXDDataEssenceDescriptor::Dump(FILE* stream)
4645 char identbuf[IdentBufferLen];
4651 GenericDataEssenceDescriptor::Dump(stream);
4652 fprintf(stream, " %22s = %s\n", "NamespaceURI", NamespaceURI.EncodeString(identbuf, IdentBufferLen));
4657 ISXDDataEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
4659 return InterchangeObject::InitFromBuffer(p, l);
4664 ISXDDataEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4666 return InterchangeObject::WriteToBuffer(Buffer);
4669 //------------------------------------------------------------------------------------------
4670 // PHDRMetadataTrackSubDescriptor
4674 PHDRMetadataTrackSubDescriptor::PHDRMetadataTrackSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), SourceTrackID(0), SimplePayloadSID(0)
4677 m_UL = m_Dict->ul(MDD_PHDRMetadataTrackSubDescriptor);
4680 PHDRMetadataTrackSubDescriptor::PHDRMetadataTrackSubDescriptor(const PHDRMetadataTrackSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
4683 m_UL = m_Dict->ul(MDD_PHDRMetadataTrackSubDescriptor);
4690 PHDRMetadataTrackSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
4693 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
4694 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(PHDRMetadataTrackSubDescriptor, DataDefinition));
4695 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(PHDRMetadataTrackSubDescriptor, SourceTrackID));
4696 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(PHDRMetadataTrackSubDescriptor, SimplePayloadSID));
4702 PHDRMetadataTrackSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
4705 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
4706 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(PHDRMetadataTrackSubDescriptor, DataDefinition));
4707 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(PHDRMetadataTrackSubDescriptor, SourceTrackID));
4708 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(PHDRMetadataTrackSubDescriptor, SimplePayloadSID));
4714 PHDRMetadataTrackSubDescriptor::Copy(const PHDRMetadataTrackSubDescriptor& rhs)
4716 InterchangeObject::Copy(rhs);
4717 DataDefinition = rhs.DataDefinition;
4718 SourceTrackID = rhs.SourceTrackID;
4719 SimplePayloadSID = rhs.SimplePayloadSID;
4724 PHDRMetadataTrackSubDescriptor::Dump(FILE* stream)
4726 char identbuf[IdentBufferLen];
4732 InterchangeObject::Dump(stream);
4733 fprintf(stream, " %22s = %s\n", "DataDefinition", DataDefinition.EncodeString(identbuf, IdentBufferLen));
4734 fprintf(stream, " %22s = %d\n", "SourceTrackID", SourceTrackID);
4735 fprintf(stream, " %22s = %d\n", "SimplePayloadSID", SimplePayloadSID);
4740 PHDRMetadataTrackSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
4742 return InterchangeObject::InitFromBuffer(p, l);
4747 PHDRMetadataTrackSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4749 return InterchangeObject::WriteToBuffer(Buffer);
4752 //------------------------------------------------------------------------------------------
4753 // PIMFDynamicMetadataDescriptor
4757 PIMFDynamicMetadataDescriptor::PIMFDynamicMetadataDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d), GlobalPayloadSID(0)
4760 m_UL = m_Dict->ul(MDD_PIMFDynamicMetadataDescriptor);
4763 PIMFDynamicMetadataDescriptor::PIMFDynamicMetadataDescriptor(const PIMFDynamicMetadataDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
4766 m_UL = m_Dict->ul(MDD_PIMFDynamicMetadataDescriptor);
4773 PIMFDynamicMetadataDescriptor::InitFromTLVSet(TLVReader& TLVSet)
4776 Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
4777 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(PIMFDynamicMetadataDescriptor, GlobalPayloadSID));
4783 PIMFDynamicMetadataDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
4786 Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
4787 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(PIMFDynamicMetadataDescriptor, GlobalPayloadSID));
4793 PIMFDynamicMetadataDescriptor::Copy(const PIMFDynamicMetadataDescriptor& rhs)
4795 GenericDataEssenceDescriptor::Copy(rhs);
4796 GlobalPayloadSID = rhs.GlobalPayloadSID;
4801 PIMFDynamicMetadataDescriptor::Dump(FILE* stream)
4803 char identbuf[IdentBufferLen];
4809 GenericDataEssenceDescriptor::Dump(stream);
4810 fprintf(stream, " %22s = %d\n", "GlobalPayloadSID", GlobalPayloadSID);
4815 PIMFDynamicMetadataDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
4817 return InterchangeObject::InitFromBuffer(p, l);
4822 PIMFDynamicMetadataDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4824 return InterchangeObject::WriteToBuffer(Buffer);