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* GenericDataEssenceDescriptor_Factory(const Dictionary*& Dict) { return new GenericDataEssenceDescriptor(Dict); }
68 static InterchangeObject* TimedTextDescriptor_Factory(const Dictionary*& Dict) { return new TimedTextDescriptor(Dict); }
69 static InterchangeObject* TimedTextResourceSubDescriptor_Factory(const Dictionary*& Dict) { return new TimedTextResourceSubDescriptor(Dict); }
70 static InterchangeObject* StereoscopicPictureSubDescriptor_Factory(const Dictionary*& Dict) { return new StereoscopicPictureSubDescriptor(Dict); }
71 static InterchangeObject* ContainerConstraintSubDescriptor_Factory(const Dictionary*& Dict) { return new ContainerConstraintSubDescriptor(Dict); }
72 static InterchangeObject* NetworkLocator_Factory(const Dictionary*& Dict) { return new NetworkLocator(Dict); }
73 static InterchangeObject* MCALabelSubDescriptor_Factory(const Dictionary*& Dict) { return new MCALabelSubDescriptor(Dict); }
74 static InterchangeObject* AudioChannelLabelSubDescriptor_Factory(const Dictionary*& Dict) { return new AudioChannelLabelSubDescriptor(Dict); }
75 static InterchangeObject* SoundfieldGroupLabelSubDescriptor_Factory(const Dictionary*& Dict) { return new SoundfieldGroupLabelSubDescriptor(Dict); }
76 static InterchangeObject* GroupOfSoundfieldGroupsLabelSubDescriptor_Factory(const Dictionary*& Dict) { return new GroupOfSoundfieldGroupsLabelSubDescriptor(Dict); }
77 static InterchangeObject* DCDataDescriptor_Factory(const Dictionary*& Dict) { return new DCDataDescriptor(Dict); }
78 static InterchangeObject* PrivateDCDataDescriptor_Factory(const Dictionary*& Dict) { return new PrivateDCDataDescriptor(Dict); }
79 static InterchangeObject* DolbyAtmosSubDescriptor_Factory(const Dictionary*& Dict) { return new DolbyAtmosSubDescriptor(Dict); }
80 static InterchangeObject* PHDRMetadataTrackSubDescriptor_Factory(const Dictionary*& Dict) { return new PHDRMetadataTrackSubDescriptor(Dict); }
81 static InterchangeObject* PIMFDynamicMetadataDescriptor_Factory(const Dictionary*& Dict) { return new PIMFDynamicMetadataDescriptor(Dict); }
85 ASDCP::MXF::Metadata_InitTypes(const Dictionary*& Dict)
88 SetObjectFactory(Dict->ul(MDD_Preface), Preface_Factory);
89 SetObjectFactory(Dict->ul(MDD_IndexTableSegment), IndexTableSegment_Factory);
91 SetObjectFactory(Dict->ul(MDD_Identification), Identification_Factory);
92 SetObjectFactory(Dict->ul(MDD_ContentStorage), ContentStorage_Factory);
93 SetObjectFactory(Dict->ul(MDD_EssenceContainerData), EssenceContainerData_Factory);
94 SetObjectFactory(Dict->ul(MDD_MaterialPackage), MaterialPackage_Factory);
95 SetObjectFactory(Dict->ul(MDD_SourcePackage), SourcePackage_Factory);
96 SetObjectFactory(Dict->ul(MDD_StaticTrack), StaticTrack_Factory);
97 SetObjectFactory(Dict->ul(MDD_Track), Track_Factory);
98 SetObjectFactory(Dict->ul(MDD_Sequence), Sequence_Factory);
99 SetObjectFactory(Dict->ul(MDD_SourceClip), SourceClip_Factory);
100 SetObjectFactory(Dict->ul(MDD_TimecodeComponent), TimecodeComponent_Factory);
101 SetObjectFactory(Dict->ul(MDD_FileDescriptor), FileDescriptor_Factory);
102 SetObjectFactory(Dict->ul(MDD_GenericSoundEssenceDescriptor), GenericSoundEssenceDescriptor_Factory);
103 SetObjectFactory(Dict->ul(MDD_WaveAudioDescriptor), WaveAudioDescriptor_Factory);
104 SetObjectFactory(Dict->ul(MDD_GenericPictureEssenceDescriptor), GenericPictureEssenceDescriptor_Factory);
105 SetObjectFactory(Dict->ul(MDD_RGBAEssenceDescriptor), RGBAEssenceDescriptor_Factory);
106 SetObjectFactory(Dict->ul(MDD_JPEG2000PictureSubDescriptor), JPEG2000PictureSubDescriptor_Factory);
107 SetObjectFactory(Dict->ul(MDD_CDCIEssenceDescriptor), CDCIEssenceDescriptor_Factory);
108 SetObjectFactory(Dict->ul(MDD_MPEG2VideoDescriptor), MPEG2VideoDescriptor_Factory);
109 SetObjectFactory(Dict->ul(MDD_DMSegment), DMSegment_Factory);
110 SetObjectFactory(Dict->ul(MDD_CryptographicFramework), CryptographicFramework_Factory);
111 SetObjectFactory(Dict->ul(MDD_CryptographicContext), CryptographicContext_Factory);
112 SetObjectFactory(Dict->ul(MDD_GenericDataEssenceDescriptor), GenericDataEssenceDescriptor_Factory);
113 SetObjectFactory(Dict->ul(MDD_TimedTextDescriptor), TimedTextDescriptor_Factory);
114 SetObjectFactory(Dict->ul(MDD_TimedTextResourceSubDescriptor), TimedTextResourceSubDescriptor_Factory);
115 SetObjectFactory(Dict->ul(MDD_StereoscopicPictureSubDescriptor), StereoscopicPictureSubDescriptor_Factory);
116 SetObjectFactory(Dict->ul(MDD_ContainerConstraintSubDescriptor), ContainerConstraintSubDescriptor_Factory);
117 SetObjectFactory(Dict->ul(MDD_NetworkLocator), NetworkLocator_Factory);
118 SetObjectFactory(Dict->ul(MDD_MCALabelSubDescriptor), MCALabelSubDescriptor_Factory);
119 SetObjectFactory(Dict->ul(MDD_AudioChannelLabelSubDescriptor), AudioChannelLabelSubDescriptor_Factory);
120 SetObjectFactory(Dict->ul(MDD_SoundfieldGroupLabelSubDescriptor), SoundfieldGroupLabelSubDescriptor_Factory);
121 SetObjectFactory(Dict->ul(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor), GroupOfSoundfieldGroupsLabelSubDescriptor_Factory);
122 SetObjectFactory(Dict->ul(MDD_DCDataDescriptor), DCDataDescriptor_Factory);
123 SetObjectFactory(Dict->ul(MDD_PrivateDCDataDescriptor), PrivateDCDataDescriptor_Factory);
124 SetObjectFactory(Dict->ul(MDD_DolbyAtmosSubDescriptor), DolbyAtmosSubDescriptor_Factory);
125 SetObjectFactory(Dict->ul(MDD_PHDRMetadataTrackSubDescriptor), PHDRMetadataTrackSubDescriptor_Factory);
126 SetObjectFactory(Dict->ul(MDD_PIMFDynamicMetadataDescriptor), PIMFDynamicMetadataDescriptor_Factory);
129 //------------------------------------------------------------------------------------------
134 //------------------------------------------------------------------------------------------
139 Identification::Identification(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
142 m_UL = m_Dict->ul(MDD_Identification);
145 Identification::Identification(const Identification& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
148 m_UL = m_Dict->ul(MDD_Identification);
155 Identification::InitFromTLVSet(TLVReader& TLVSet)
158 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
159 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ThisGenerationUID));
160 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, CompanyName));
161 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ProductName));
162 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ProductVersion));
163 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, VersionString));
164 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ProductUID));
165 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ModificationDate));
166 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ToolkitVersion));
167 if ( ASDCP_SUCCESS(result) ) {
168 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(Identification, Platform));
169 Platform.set_has_value( result == RESULT_OK );
176 Identification::WriteToTLVSet(TLVWriter& TLVSet)
179 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
180 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ThisGenerationUID));
181 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, CompanyName));
182 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ProductName));
183 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ProductVersion));
184 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, VersionString));
185 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ProductUID));
186 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ModificationDate));
187 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ToolkitVersion));
188 if ( ASDCP_SUCCESS(result) && ! Platform.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(Identification, Platform));
194 Identification::Copy(const Identification& rhs)
196 InterchangeObject::Copy(rhs);
197 ThisGenerationUID = rhs.ThisGenerationUID;
198 CompanyName = rhs.CompanyName;
199 ProductName = rhs.ProductName;
200 ProductVersion = rhs.ProductVersion;
201 VersionString = rhs.VersionString;
202 ProductUID = rhs.ProductUID;
203 ModificationDate = rhs.ModificationDate;
204 ToolkitVersion = rhs.ToolkitVersion;
205 Platform = rhs.Platform;
210 Identification::Dump(FILE* stream)
212 char identbuf[IdentBufferLen];
218 InterchangeObject::Dump(stream);
219 fprintf(stream, " %22s = %s\n", "ThisGenerationUID", ThisGenerationUID.EncodeString(identbuf, IdentBufferLen));
220 fprintf(stream, " %22s = %s\n", "CompanyName", CompanyName.EncodeString(identbuf, IdentBufferLen));
221 fprintf(stream, " %22s = %s\n", "ProductName", ProductName.EncodeString(identbuf, IdentBufferLen));
222 fprintf(stream, " %22s = %s\n", "ProductVersion", ProductVersion.EncodeString(identbuf, IdentBufferLen));
223 fprintf(stream, " %22s = %s\n", "VersionString", VersionString.EncodeString(identbuf, IdentBufferLen));
224 fprintf(stream, " %22s = %s\n", "ProductUID", ProductUID.EncodeString(identbuf, IdentBufferLen));
225 fprintf(stream, " %22s = %s\n", "ModificationDate", ModificationDate.EncodeString(identbuf, IdentBufferLen));
226 fprintf(stream, " %22s = %s\n", "ToolkitVersion", ToolkitVersion.EncodeString(identbuf, IdentBufferLen));
227 if ( ! Platform.empty() ) {
228 fprintf(stream, " %22s = %s\n", "Platform", Platform.get().EncodeString(identbuf, IdentBufferLen));
234 Identification::InitFromBuffer(const byte_t* p, ui32_t l)
236 return InterchangeObject::InitFromBuffer(p, l);
241 Identification::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
243 return InterchangeObject::WriteToBuffer(Buffer);
246 //------------------------------------------------------------------------------------------
251 ContentStorage::ContentStorage(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
254 m_UL = m_Dict->ul(MDD_ContentStorage);
257 ContentStorage::ContentStorage(const ContentStorage& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
260 m_UL = m_Dict->ul(MDD_ContentStorage);
267 ContentStorage::InitFromTLVSet(TLVReader& TLVSet)
270 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
271 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(ContentStorage, Packages));
272 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(ContentStorage, EssenceContainerData));
278 ContentStorage::WriteToTLVSet(TLVWriter& TLVSet)
281 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
282 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(ContentStorage, Packages));
283 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(ContentStorage, EssenceContainerData));
289 ContentStorage::Copy(const ContentStorage& rhs)
291 InterchangeObject::Copy(rhs);
292 Packages = rhs.Packages;
293 EssenceContainerData = rhs.EssenceContainerData;
298 ContentStorage::Dump(FILE* stream)
300 char identbuf[IdentBufferLen];
306 InterchangeObject::Dump(stream);
307 fprintf(stream, " %22s:\n", "Packages");
308 Packages.Dump(stream);
309 fprintf(stream, " %22s:\n", "EssenceContainerData");
310 EssenceContainerData.Dump(stream);
315 ContentStorage::InitFromBuffer(const byte_t* p, ui32_t l)
317 return InterchangeObject::InitFromBuffer(p, l);
322 ContentStorage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
324 return InterchangeObject::WriteToBuffer(Buffer);
327 //------------------------------------------------------------------------------------------
328 // EssenceContainerData
332 EssenceContainerData::EssenceContainerData(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), BodySID(0)
335 m_UL = m_Dict->ul(MDD_EssenceContainerData);
338 EssenceContainerData::EssenceContainerData(const EssenceContainerData& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
341 m_UL = m_Dict->ul(MDD_EssenceContainerData);
348 EssenceContainerData::InitFromTLVSet(TLVReader& TLVSet)
351 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
352 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(EssenceContainerData, LinkedPackageUID));
353 if ( ASDCP_SUCCESS(result) ) {
354 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(EssenceContainerData, IndexSID));
355 IndexSID.set_has_value( result == RESULT_OK );
357 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(EssenceContainerData, BodySID));
363 EssenceContainerData::WriteToTLVSet(TLVWriter& TLVSet)
366 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
367 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(EssenceContainerData, LinkedPackageUID));
368 if ( ASDCP_SUCCESS(result) && ! IndexSID.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(EssenceContainerData, IndexSID));
369 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(EssenceContainerData, BodySID));
375 EssenceContainerData::Copy(const EssenceContainerData& rhs)
377 InterchangeObject::Copy(rhs);
378 LinkedPackageUID = rhs.LinkedPackageUID;
379 IndexSID = rhs.IndexSID;
380 BodySID = rhs.BodySID;
385 EssenceContainerData::Dump(FILE* stream)
387 char identbuf[IdentBufferLen];
393 InterchangeObject::Dump(stream);
394 fprintf(stream, " %22s = %s\n", "LinkedPackageUID", LinkedPackageUID.EncodeString(identbuf, IdentBufferLen));
395 if ( ! IndexSID.empty() ) {
396 fprintf(stream, " %22s = %d\n", "IndexSID", IndexSID.get());
398 fprintf(stream, " %22s = %d\n", "BodySID", BodySID);
403 EssenceContainerData::InitFromBuffer(const byte_t* p, ui32_t l)
405 return InterchangeObject::InitFromBuffer(p, l);
410 EssenceContainerData::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
412 return InterchangeObject::WriteToBuffer(Buffer);
415 //------------------------------------------------------------------------------------------
419 GenericPackage::GenericPackage(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
421 GenericPackage::GenericPackage(const GenericPackage& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
429 GenericPackage::InitFromTLVSet(TLVReader& TLVSet)
432 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
433 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, PackageUID));
434 if ( ASDCP_SUCCESS(result) ) {
435 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPackage, Name));
436 Name.set_has_value( result == RESULT_OK );
438 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, PackageCreationDate));
439 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, PackageModifiedDate));
440 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, Tracks));
446 GenericPackage::WriteToTLVSet(TLVWriter& TLVSet)
449 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
450 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPackage, PackageUID));
451 if ( ASDCP_SUCCESS(result) && ! Name.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPackage, Name));
452 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPackage, PackageCreationDate));
453 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPackage, PackageModifiedDate));
454 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPackage, Tracks));
460 GenericPackage::Copy(const GenericPackage& rhs)
462 InterchangeObject::Copy(rhs);
463 PackageUID = rhs.PackageUID;
465 PackageCreationDate = rhs.PackageCreationDate;
466 PackageModifiedDate = rhs.PackageModifiedDate;
472 GenericPackage::Dump(FILE* stream)
474 char identbuf[IdentBufferLen];
480 InterchangeObject::Dump(stream);
481 fprintf(stream, " %22s = %s\n", "PackageUID", PackageUID.EncodeString(identbuf, IdentBufferLen));
482 if ( ! Name.empty() ) {
483 fprintf(stream, " %22s = %s\n", "Name", Name.get().EncodeString(identbuf, IdentBufferLen));
485 fprintf(stream, " %22s = %s\n", "PackageCreationDate", PackageCreationDate.EncodeString(identbuf, IdentBufferLen));
486 fprintf(stream, " %22s = %s\n", "PackageModifiedDate", PackageModifiedDate.EncodeString(identbuf, IdentBufferLen));
487 fprintf(stream, " %22s:\n", "Tracks");
492 //------------------------------------------------------------------------------------------
497 MaterialPackage::MaterialPackage(const Dictionary*& d) : GenericPackage(d), m_Dict(d)
500 m_UL = m_Dict->ul(MDD_MaterialPackage);
503 MaterialPackage::MaterialPackage(const MaterialPackage& rhs) : GenericPackage(rhs.m_Dict), m_Dict(rhs.m_Dict)
506 m_UL = m_Dict->ul(MDD_MaterialPackage);
513 MaterialPackage::InitFromTLVSet(TLVReader& TLVSet)
516 Result_t result = GenericPackage::InitFromTLVSet(TLVSet);
517 if ( ASDCP_SUCCESS(result) ) {
518 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MaterialPackage, PackageMarker));
519 PackageMarker.set_has_value( result == RESULT_OK );
526 MaterialPackage::WriteToTLVSet(TLVWriter& TLVSet)
529 Result_t result = GenericPackage::WriteToTLVSet(TLVSet);
530 if ( ASDCP_SUCCESS(result) && ! PackageMarker.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MaterialPackage, PackageMarker));
536 MaterialPackage::Copy(const MaterialPackage& rhs)
538 GenericPackage::Copy(rhs);
539 PackageMarker = rhs.PackageMarker;
544 MaterialPackage::Dump(FILE* stream)
546 char identbuf[IdentBufferLen];
552 GenericPackage::Dump(stream);
553 if ( ! PackageMarker.empty() ) {
554 fprintf(stream, " %22s = %s\n", "PackageMarker", PackageMarker.get().EncodeString(identbuf, IdentBufferLen));
560 MaterialPackage::InitFromBuffer(const byte_t* p, ui32_t l)
562 return InterchangeObject::InitFromBuffer(p, l);
567 MaterialPackage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
569 return InterchangeObject::WriteToBuffer(Buffer);
572 //------------------------------------------------------------------------------------------
577 SourcePackage::SourcePackage(const Dictionary*& d) : GenericPackage(d), m_Dict(d)
580 m_UL = m_Dict->ul(MDD_SourcePackage);
583 SourcePackage::SourcePackage(const SourcePackage& rhs) : GenericPackage(rhs.m_Dict), m_Dict(rhs.m_Dict)
586 m_UL = m_Dict->ul(MDD_SourcePackage);
593 SourcePackage::InitFromTLVSet(TLVReader& TLVSet)
596 Result_t result = GenericPackage::InitFromTLVSet(TLVSet);
597 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(SourcePackage, Descriptor));
603 SourcePackage::WriteToTLVSet(TLVWriter& TLVSet)
606 Result_t result = GenericPackage::WriteToTLVSet(TLVSet);
607 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(SourcePackage, Descriptor));
613 SourcePackage::Copy(const SourcePackage& rhs)
615 GenericPackage::Copy(rhs);
616 Descriptor = rhs.Descriptor;
621 SourcePackage::Dump(FILE* stream)
623 char identbuf[IdentBufferLen];
629 GenericPackage::Dump(stream);
630 fprintf(stream, " %22s = %s\n", "Descriptor", Descriptor.EncodeString(identbuf, IdentBufferLen));
635 SourcePackage::InitFromBuffer(const byte_t* p, ui32_t l)
637 return InterchangeObject::InitFromBuffer(p, l);
642 SourcePackage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
644 return InterchangeObject::WriteToBuffer(Buffer);
647 //------------------------------------------------------------------------------------------
651 GenericTrack::GenericTrack(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), TrackID(0), TrackNumber(0) {}
653 GenericTrack::GenericTrack(const GenericTrack& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
661 GenericTrack::InitFromTLVSet(TLVReader& TLVSet)
664 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
665 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericTrack, TrackID));
666 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericTrack, TrackNumber));
667 if ( ASDCP_SUCCESS(result) ) {
668 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericTrack, TrackName));
669 TrackName.set_has_value( result == RESULT_OK );
671 if ( ASDCP_SUCCESS(result) ) {
672 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericTrack, Sequence));
673 Sequence.set_has_value( result == RESULT_OK );
680 GenericTrack::WriteToTLVSet(TLVWriter& TLVSet)
683 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
684 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericTrack, TrackID));
685 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericTrack, TrackNumber));
686 if ( ASDCP_SUCCESS(result) && ! TrackName.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericTrack, TrackName));
687 if ( ASDCP_SUCCESS(result) && ! Sequence.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericTrack, Sequence));
693 GenericTrack::Copy(const GenericTrack& rhs)
695 InterchangeObject::Copy(rhs);
696 TrackID = rhs.TrackID;
697 TrackNumber = rhs.TrackNumber;
698 TrackName = rhs.TrackName;
699 Sequence = rhs.Sequence;
704 GenericTrack::Dump(FILE* stream)
706 char identbuf[IdentBufferLen];
712 InterchangeObject::Dump(stream);
713 fprintf(stream, " %22s = %d\n", "TrackID", TrackID);
714 fprintf(stream, " %22s = %d\n", "TrackNumber", TrackNumber);
715 if ( ! TrackName.empty() ) {
716 fprintf(stream, " %22s = %s\n", "TrackName", TrackName.get().EncodeString(identbuf, IdentBufferLen));
718 if ( ! Sequence.empty() ) {
719 fprintf(stream, " %22s = %s\n", "Sequence", Sequence.get().EncodeString(identbuf, IdentBufferLen));
724 //------------------------------------------------------------------------------------------
729 StaticTrack::StaticTrack(const Dictionary*& d) : GenericTrack(d), m_Dict(d)
732 m_UL = m_Dict->ul(MDD_StaticTrack);
735 StaticTrack::StaticTrack(const StaticTrack& rhs) : GenericTrack(rhs.m_Dict), m_Dict(rhs.m_Dict)
738 m_UL = m_Dict->ul(MDD_StaticTrack);
745 StaticTrack::InitFromTLVSet(TLVReader& TLVSet)
748 Result_t result = GenericTrack::InitFromTLVSet(TLVSet);
754 StaticTrack::WriteToTLVSet(TLVWriter& TLVSet)
757 Result_t result = GenericTrack::WriteToTLVSet(TLVSet);
763 StaticTrack::Copy(const StaticTrack& rhs)
765 GenericTrack::Copy(rhs);
770 StaticTrack::Dump(FILE* stream)
772 char identbuf[IdentBufferLen];
778 GenericTrack::Dump(stream);
783 StaticTrack::InitFromBuffer(const byte_t* p, ui32_t l)
785 return InterchangeObject::InitFromBuffer(p, l);
790 StaticTrack::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
792 return InterchangeObject::WriteToBuffer(Buffer);
795 //------------------------------------------------------------------------------------------
800 Track::Track(const Dictionary*& d) : GenericTrack(d), m_Dict(d), Origin(0)
803 m_UL = m_Dict->ul(MDD_Track);
806 Track::Track(const Track& rhs) : GenericTrack(rhs.m_Dict), m_Dict(rhs.m_Dict)
809 m_UL = m_Dict->ul(MDD_Track);
816 Track::InitFromTLVSet(TLVReader& TLVSet)
819 Result_t result = GenericTrack::InitFromTLVSet(TLVSet);
820 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Track, EditRate));
821 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(Track, Origin));
827 Track::WriteToTLVSet(TLVWriter& TLVSet)
830 Result_t result = GenericTrack::WriteToTLVSet(TLVSet);
831 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Track, EditRate));
832 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(Track, Origin));
838 Track::Copy(const Track& rhs)
840 GenericTrack::Copy(rhs);
841 EditRate = rhs.EditRate;
847 Track::Dump(FILE* stream)
849 char identbuf[IdentBufferLen];
855 GenericTrack::Dump(stream);
856 fprintf(stream, " %22s = %s\n", "EditRate", EditRate.EncodeString(identbuf, IdentBufferLen));
857 fprintf(stream, " %22s = %s\n", "Origin", i64sz(Origin, identbuf));
862 Track::InitFromBuffer(const byte_t* p, ui32_t l)
864 return InterchangeObject::InitFromBuffer(p, l);
869 Track::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
871 return InterchangeObject::WriteToBuffer(Buffer);
874 //------------------------------------------------------------------------------------------
875 // StructuralComponent
878 StructuralComponent::StructuralComponent(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
880 StructuralComponent::StructuralComponent(const StructuralComponent& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
888 StructuralComponent::InitFromTLVSet(TLVReader& TLVSet)
891 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
892 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(StructuralComponent, DataDefinition));
893 if ( ASDCP_SUCCESS(result) ) {
894 result = TLVSet.ReadUi64(OBJ_READ_ARGS_OPT(StructuralComponent, Duration));
895 Duration.set_has_value( result == RESULT_OK );
902 StructuralComponent::WriteToTLVSet(TLVWriter& TLVSet)
905 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
906 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(StructuralComponent, DataDefinition));
907 if ( ASDCP_SUCCESS(result) && ! Duration.empty() ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS_OPT(StructuralComponent, Duration));
913 StructuralComponent::Copy(const StructuralComponent& rhs)
915 InterchangeObject::Copy(rhs);
916 DataDefinition = rhs.DataDefinition;
917 Duration = rhs.Duration;
922 StructuralComponent::Dump(FILE* stream)
924 char identbuf[IdentBufferLen];
930 InterchangeObject::Dump(stream);
931 fprintf(stream, " %22s = %s\n", "DataDefinition", DataDefinition.EncodeString(identbuf, IdentBufferLen));
932 if ( ! Duration.empty() ) {
933 fprintf(stream, " %22s = %s\n", "Duration", i64sz(Duration.get(), identbuf));
938 //------------------------------------------------------------------------------------------
943 Sequence::Sequence(const Dictionary*& d) : StructuralComponent(d), m_Dict(d)
946 m_UL = m_Dict->ul(MDD_Sequence);
949 Sequence::Sequence(const Sequence& rhs) : StructuralComponent(rhs.m_Dict), m_Dict(rhs.m_Dict)
952 m_UL = m_Dict->ul(MDD_Sequence);
959 Sequence::InitFromTLVSet(TLVReader& TLVSet)
962 Result_t result = StructuralComponent::InitFromTLVSet(TLVSet);
963 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Sequence, StructuralComponents));
969 Sequence::WriteToTLVSet(TLVWriter& TLVSet)
972 Result_t result = StructuralComponent::WriteToTLVSet(TLVSet);
973 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Sequence, StructuralComponents));
979 Sequence::Copy(const Sequence& rhs)
981 StructuralComponent::Copy(rhs);
982 StructuralComponents = rhs.StructuralComponents;
987 Sequence::Dump(FILE* stream)
989 char identbuf[IdentBufferLen];
995 StructuralComponent::Dump(stream);
996 fprintf(stream, " %22s:\n", "StructuralComponents");
997 StructuralComponents.Dump(stream);
1002 Sequence::InitFromBuffer(const byte_t* p, ui32_t l)
1004 return InterchangeObject::InitFromBuffer(p, l);
1009 Sequence::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1011 return InterchangeObject::WriteToBuffer(Buffer);
1014 //------------------------------------------------------------------------------------------
1019 SourceClip::SourceClip(const Dictionary*& d) : StructuralComponent(d), m_Dict(d), StartPosition(0), SourceTrackID(0)
1022 m_UL = m_Dict->ul(MDD_SourceClip);
1025 SourceClip::SourceClip(const SourceClip& rhs) : StructuralComponent(rhs.m_Dict), m_Dict(rhs.m_Dict)
1028 m_UL = m_Dict->ul(MDD_SourceClip);
1035 SourceClip::InitFromTLVSet(TLVReader& TLVSet)
1038 Result_t result = StructuralComponent::InitFromTLVSet(TLVSet);
1039 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(SourceClip, StartPosition));
1040 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(SourceClip, SourcePackageID));
1041 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(SourceClip, SourceTrackID));
1047 SourceClip::WriteToTLVSet(TLVWriter& TLVSet)
1050 Result_t result = StructuralComponent::WriteToTLVSet(TLVSet);
1051 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(SourceClip, StartPosition));
1052 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(SourceClip, SourcePackageID));
1053 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(SourceClip, SourceTrackID));
1059 SourceClip::Copy(const SourceClip& rhs)
1061 StructuralComponent::Copy(rhs);
1062 StartPosition = rhs.StartPosition;
1063 SourcePackageID = rhs.SourcePackageID;
1064 SourceTrackID = rhs.SourceTrackID;
1069 SourceClip::Dump(FILE* stream)
1071 char identbuf[IdentBufferLen];
1077 StructuralComponent::Dump(stream);
1078 fprintf(stream, " %22s = %s\n", "StartPosition", i64sz(StartPosition, identbuf));
1079 fprintf(stream, " %22s = %s\n", "SourcePackageID", SourcePackageID.EncodeString(identbuf, IdentBufferLen));
1080 fprintf(stream, " %22s = %d\n", "SourceTrackID", SourceTrackID);
1085 SourceClip::InitFromBuffer(const byte_t* p, ui32_t l)
1087 return InterchangeObject::InitFromBuffer(p, l);
1092 SourceClip::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1094 return InterchangeObject::WriteToBuffer(Buffer);
1097 //------------------------------------------------------------------------------------------
1098 // TimecodeComponent
1102 TimecodeComponent::TimecodeComponent(const Dictionary*& d) : StructuralComponent(d), m_Dict(d), RoundedTimecodeBase(0), StartTimecode(0), DropFrame(0)
1105 m_UL = m_Dict->ul(MDD_TimecodeComponent);
1108 TimecodeComponent::TimecodeComponent(const TimecodeComponent& rhs) : StructuralComponent(rhs.m_Dict), m_Dict(rhs.m_Dict)
1111 m_UL = m_Dict->ul(MDD_TimecodeComponent);
1118 TimecodeComponent::InitFromTLVSet(TLVReader& TLVSet)
1121 Result_t result = StructuralComponent::InitFromTLVSet(TLVSet);
1122 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(TimecodeComponent, RoundedTimecodeBase));
1123 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(TimecodeComponent, StartTimecode));
1124 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(TimecodeComponent, DropFrame));
1130 TimecodeComponent::WriteToTLVSet(TLVWriter& TLVSet)
1133 Result_t result = StructuralComponent::WriteToTLVSet(TLVSet);
1134 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(TimecodeComponent, RoundedTimecodeBase));
1135 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(TimecodeComponent, StartTimecode));
1136 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(TimecodeComponent, DropFrame));
1142 TimecodeComponent::Copy(const TimecodeComponent& rhs)
1144 StructuralComponent::Copy(rhs);
1145 RoundedTimecodeBase = rhs.RoundedTimecodeBase;
1146 StartTimecode = rhs.StartTimecode;
1147 DropFrame = rhs.DropFrame;
1152 TimecodeComponent::Dump(FILE* stream)
1154 char identbuf[IdentBufferLen];
1160 StructuralComponent::Dump(stream);
1161 fprintf(stream, " %22s = %d\n", "RoundedTimecodeBase", RoundedTimecodeBase);
1162 fprintf(stream, " %22s = %s\n", "StartTimecode", i64sz(StartTimecode, identbuf));
1163 fprintf(stream, " %22s = %d\n", "DropFrame", DropFrame);
1168 TimecodeComponent::InitFromBuffer(const byte_t* p, ui32_t l)
1170 return InterchangeObject::InitFromBuffer(p, l);
1175 TimecodeComponent::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1177 return InterchangeObject::WriteToBuffer(Buffer);
1180 //------------------------------------------------------------------------------------------
1181 // GenericDescriptor
1184 GenericDescriptor::GenericDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
1186 GenericDescriptor::GenericDescriptor(const GenericDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
1194 GenericDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1197 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
1198 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericDescriptor, Locators));
1199 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericDescriptor, SubDescriptors));
1205 GenericDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1208 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
1209 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericDescriptor, Locators));
1210 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericDescriptor, SubDescriptors));
1216 GenericDescriptor::Copy(const GenericDescriptor& rhs)
1218 InterchangeObject::Copy(rhs);
1219 Locators = rhs.Locators;
1220 SubDescriptors = rhs.SubDescriptors;
1225 GenericDescriptor::Dump(FILE* stream)
1227 char identbuf[IdentBufferLen];
1233 InterchangeObject::Dump(stream);
1234 fprintf(stream, " %22s:\n", "Locators");
1235 Locators.Dump(stream);
1236 fprintf(stream, " %22s:\n", "SubDescriptors");
1237 SubDescriptors.Dump(stream);
1241 //------------------------------------------------------------------------------------------
1246 FileDescriptor::FileDescriptor(const Dictionary*& d) : GenericDescriptor(d), m_Dict(d)
1249 m_UL = m_Dict->ul(MDD_FileDescriptor);
1252 FileDescriptor::FileDescriptor(const FileDescriptor& rhs) : GenericDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1255 m_UL = m_Dict->ul(MDD_FileDescriptor);
1262 FileDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1265 Result_t result = GenericDescriptor::InitFromTLVSet(TLVSet);
1266 if ( ASDCP_SUCCESS(result) ) {
1267 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(FileDescriptor, LinkedTrackID));
1268 LinkedTrackID.set_has_value( result == RESULT_OK );
1270 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(FileDescriptor, SampleRate));
1271 if ( ASDCP_SUCCESS(result) ) {
1272 result = TLVSet.ReadUi64(OBJ_READ_ARGS_OPT(FileDescriptor, ContainerDuration));
1273 ContainerDuration.set_has_value( result == RESULT_OK );
1275 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(FileDescriptor, EssenceContainer));
1276 if ( ASDCP_SUCCESS(result) ) {
1277 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(FileDescriptor, Codec));
1278 Codec.set_has_value( result == RESULT_OK );
1285 FileDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1288 Result_t result = GenericDescriptor::WriteToTLVSet(TLVSet);
1289 if ( ASDCP_SUCCESS(result) && ! LinkedTrackID.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(FileDescriptor, LinkedTrackID));
1290 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(FileDescriptor, SampleRate));
1291 if ( ASDCP_SUCCESS(result) && ! ContainerDuration.empty() ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS_OPT(FileDescriptor, ContainerDuration));
1292 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(FileDescriptor, EssenceContainer));
1293 if ( ASDCP_SUCCESS(result) && ! Codec.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(FileDescriptor, Codec));
1299 FileDescriptor::Copy(const FileDescriptor& rhs)
1301 GenericDescriptor::Copy(rhs);
1302 LinkedTrackID = rhs.LinkedTrackID;
1303 SampleRate = rhs.SampleRate;
1304 ContainerDuration = rhs.ContainerDuration;
1305 EssenceContainer = rhs.EssenceContainer;
1311 FileDescriptor::Dump(FILE* stream)
1313 char identbuf[IdentBufferLen];
1319 GenericDescriptor::Dump(stream);
1320 if ( ! LinkedTrackID.empty() ) {
1321 fprintf(stream, " %22s = %d\n", "LinkedTrackID", LinkedTrackID.get());
1323 fprintf(stream, " %22s = %s\n", "SampleRate", SampleRate.EncodeString(identbuf, IdentBufferLen));
1324 if ( ! ContainerDuration.empty() ) {
1325 fprintf(stream, " %22s = %s\n", "ContainerDuration", i64sz(ContainerDuration.get(), identbuf));
1327 fprintf(stream, " %22s = %s\n", "EssenceContainer", EssenceContainer.EncodeString(identbuf, IdentBufferLen));
1328 if ( ! Codec.empty() ) {
1329 fprintf(stream, " %22s = %s\n", "Codec", Codec.get().EncodeString(identbuf, IdentBufferLen));
1335 FileDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1337 return InterchangeObject::InitFromBuffer(p, l);
1342 FileDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1344 return InterchangeObject::WriteToBuffer(Buffer);
1347 //------------------------------------------------------------------------------------------
1348 // GenericSoundEssenceDescriptor
1352 GenericSoundEssenceDescriptor::GenericSoundEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d), Locked(0), ChannelCount(0), QuantizationBits(0)
1355 m_UL = m_Dict->ul(MDD_GenericSoundEssenceDescriptor);
1358 GenericSoundEssenceDescriptor::GenericSoundEssenceDescriptor(const GenericSoundEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1361 m_UL = m_Dict->ul(MDD_GenericSoundEssenceDescriptor);
1368 GenericSoundEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1371 Result_t result = FileDescriptor::InitFromTLVSet(TLVSet);
1372 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, AudioSamplingRate));
1373 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, Locked));
1374 if ( ASDCP_SUCCESS(result) ) {
1375 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(GenericSoundEssenceDescriptor, AudioRefLevel));
1376 AudioRefLevel.set_has_value( result == RESULT_OK );
1378 if ( ASDCP_SUCCESS(result) ) {
1379 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(GenericSoundEssenceDescriptor, ElectroSpatialFormulation));
1380 ElectroSpatialFormulation.set_has_value( result == RESULT_OK );
1382 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, ChannelCount));
1383 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, QuantizationBits));
1384 if ( ASDCP_SUCCESS(result) ) {
1385 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(GenericSoundEssenceDescriptor, DialNorm));
1386 DialNorm.set_has_value( result == RESULT_OK );
1388 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, SoundEssenceCoding));
1394 GenericSoundEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1397 Result_t result = FileDescriptor::WriteToTLVSet(TLVSet);
1398 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, AudioSamplingRate));
1399 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, Locked));
1400 if ( ASDCP_SUCCESS(result) && ! AudioRefLevel.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericSoundEssenceDescriptor, AudioRefLevel));
1401 if ( ASDCP_SUCCESS(result) && ! ElectroSpatialFormulation.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericSoundEssenceDescriptor, ElectroSpatialFormulation));
1402 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, ChannelCount));
1403 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, QuantizationBits));
1404 if ( ASDCP_SUCCESS(result) && ! DialNorm.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericSoundEssenceDescriptor, DialNorm));
1405 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, SoundEssenceCoding));
1411 GenericSoundEssenceDescriptor::Copy(const GenericSoundEssenceDescriptor& rhs)
1413 FileDescriptor::Copy(rhs);
1414 AudioSamplingRate = rhs.AudioSamplingRate;
1415 Locked = rhs.Locked;
1416 AudioRefLevel = rhs.AudioRefLevel;
1417 ElectroSpatialFormulation = rhs.ElectroSpatialFormulation;
1418 ChannelCount = rhs.ChannelCount;
1419 QuantizationBits = rhs.QuantizationBits;
1420 DialNorm = rhs.DialNorm;
1421 SoundEssenceCoding = rhs.SoundEssenceCoding;
1426 GenericSoundEssenceDescriptor::Dump(FILE* stream)
1428 char identbuf[IdentBufferLen];
1434 FileDescriptor::Dump(stream);
1435 fprintf(stream, " %22s = %s\n", "AudioSamplingRate", AudioSamplingRate.EncodeString(identbuf, IdentBufferLen));
1436 fprintf(stream, " %22s = %d\n", "Locked", Locked);
1437 if ( ! AudioRefLevel.empty() ) {
1438 fprintf(stream, " %22s = %d\n", "AudioRefLevel", AudioRefLevel.get());
1440 if ( ! ElectroSpatialFormulation.empty() ) {
1441 fprintf(stream, " %22s = %d\n", "ElectroSpatialFormulation", ElectroSpatialFormulation.get());
1443 fprintf(stream, " %22s = %d\n", "ChannelCount", ChannelCount);
1444 fprintf(stream, " %22s = %d\n", "QuantizationBits", QuantizationBits);
1445 if ( ! DialNorm.empty() ) {
1446 fprintf(stream, " %22s = %d\n", "DialNorm", DialNorm.get());
1448 fprintf(stream, " %22s = %s\n", "SoundEssenceCoding", SoundEssenceCoding.EncodeString(identbuf, IdentBufferLen));
1453 GenericSoundEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1455 return InterchangeObject::InitFromBuffer(p, l);
1460 GenericSoundEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1462 return InterchangeObject::WriteToBuffer(Buffer);
1465 //------------------------------------------------------------------------------------------
1466 // WaveAudioDescriptor
1470 WaveAudioDescriptor::WaveAudioDescriptor(const Dictionary*& d) : GenericSoundEssenceDescriptor(d), m_Dict(d), BlockAlign(0), AvgBps(0)
1473 m_UL = m_Dict->ul(MDD_WaveAudioDescriptor);
1476 WaveAudioDescriptor::WaveAudioDescriptor(const WaveAudioDescriptor& rhs) : GenericSoundEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1479 m_UL = m_Dict->ul(MDD_WaveAudioDescriptor);
1486 WaveAudioDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1489 Result_t result = GenericSoundEssenceDescriptor::InitFromTLVSet(TLVSet);
1490 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(WaveAudioDescriptor, BlockAlign));
1491 if ( ASDCP_SUCCESS(result) ) {
1492 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(WaveAudioDescriptor, SequenceOffset));
1493 SequenceOffset.set_has_value( result == RESULT_OK );
1495 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(WaveAudioDescriptor, AvgBps));
1496 if ( ASDCP_SUCCESS(result) ) {
1497 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(WaveAudioDescriptor, ChannelAssignment));
1498 ChannelAssignment.set_has_value( result == RESULT_OK );
1500 if ( ASDCP_SUCCESS(result) ) {
1501 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(WaveAudioDescriptor, ReferenceImageEditRate));
1502 ReferenceImageEditRate.set_has_value( result == RESULT_OK );
1504 if ( ASDCP_SUCCESS(result) ) {
1505 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(WaveAudioDescriptor, ReferenceAudioAlignmentLevel));
1506 ReferenceAudioAlignmentLevel.set_has_value( result == RESULT_OK );
1513 WaveAudioDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1516 Result_t result = GenericSoundEssenceDescriptor::WriteToTLVSet(TLVSet);
1517 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(WaveAudioDescriptor, BlockAlign));
1518 if ( ASDCP_SUCCESS(result) && ! SequenceOffset.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(WaveAudioDescriptor, SequenceOffset));
1519 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(WaveAudioDescriptor, AvgBps));
1520 if ( ASDCP_SUCCESS(result) && ! ChannelAssignment.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(WaveAudioDescriptor, ChannelAssignment));
1521 if ( ASDCP_SUCCESS(result) && ! ReferenceImageEditRate.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(WaveAudioDescriptor, ReferenceImageEditRate));
1522 if ( ASDCP_SUCCESS(result) && ! ReferenceAudioAlignmentLevel.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(WaveAudioDescriptor, ReferenceAudioAlignmentLevel));
1528 WaveAudioDescriptor::Copy(const WaveAudioDescriptor& rhs)
1530 GenericSoundEssenceDescriptor::Copy(rhs);
1531 BlockAlign = rhs.BlockAlign;
1532 SequenceOffset = rhs.SequenceOffset;
1533 AvgBps = rhs.AvgBps;
1534 ChannelAssignment = rhs.ChannelAssignment;
1535 ReferenceImageEditRate = rhs.ReferenceImageEditRate;
1536 ReferenceAudioAlignmentLevel = rhs.ReferenceAudioAlignmentLevel;
1541 WaveAudioDescriptor::Dump(FILE* stream)
1543 char identbuf[IdentBufferLen];
1549 GenericSoundEssenceDescriptor::Dump(stream);
1550 fprintf(stream, " %22s = %d\n", "BlockAlign", BlockAlign);
1551 if ( ! SequenceOffset.empty() ) {
1552 fprintf(stream, " %22s = %d\n", "SequenceOffset", SequenceOffset.get());
1554 fprintf(stream, " %22s = %d\n", "AvgBps", AvgBps);
1555 if ( ! ChannelAssignment.empty() ) {
1556 fprintf(stream, " %22s = %s\n", "ChannelAssignment", ChannelAssignment.get().EncodeString(identbuf, IdentBufferLen));
1558 if ( ! ReferenceImageEditRate.empty() ) {
1559 fprintf(stream, " %22s = %s\n", "ReferenceImageEditRate", ReferenceImageEditRate.get().EncodeString(identbuf, IdentBufferLen));
1561 if ( ! ReferenceAudioAlignmentLevel.empty() ) {
1562 fprintf(stream, " %22s = %d\n", "ReferenceAudioAlignmentLevel", ReferenceAudioAlignmentLevel.get());
1568 WaveAudioDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1570 return InterchangeObject::InitFromBuffer(p, l);
1575 WaveAudioDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1577 return InterchangeObject::WriteToBuffer(Buffer);
1580 //------------------------------------------------------------------------------------------
1581 // GenericPictureEssenceDescriptor
1585 GenericPictureEssenceDescriptor::GenericPictureEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d), FrameLayout(0), StoredWidth(0), StoredHeight(0)
1588 m_UL = m_Dict->ul(MDD_GenericPictureEssenceDescriptor);
1591 GenericPictureEssenceDescriptor::GenericPictureEssenceDescriptor(const GenericPictureEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1594 m_UL = m_Dict->ul(MDD_GenericPictureEssenceDescriptor);
1601 GenericPictureEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1604 Result_t result = FileDescriptor::InitFromTLVSet(TLVSet);
1605 if ( ASDCP_SUCCESS(result) ) {
1606 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, SignalStandard));
1607 SignalStandard.set_has_value( result == RESULT_OK );
1609 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, FrameLayout));
1610 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, StoredWidth));
1611 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, StoredHeight));
1612 if ( ASDCP_SUCCESS(result) ) {
1613 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, StoredF2Offset));
1614 StoredF2Offset.set_has_value( result == RESULT_OK );
1616 if ( ASDCP_SUCCESS(result) ) {
1617 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, SampledWidth));
1618 SampledWidth.set_has_value( result == RESULT_OK );
1620 if ( ASDCP_SUCCESS(result) ) {
1621 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, SampledHeight));
1622 SampledHeight.set_has_value( result == RESULT_OK );
1624 if ( ASDCP_SUCCESS(result) ) {
1625 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, SampledXOffset));
1626 SampledXOffset.set_has_value( result == RESULT_OK );
1628 if ( ASDCP_SUCCESS(result) ) {
1629 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, SampledYOffset));
1630 SampledYOffset.set_has_value( result == RESULT_OK );
1632 if ( ASDCP_SUCCESS(result) ) {
1633 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayHeight));
1634 DisplayHeight.set_has_value( result == RESULT_OK );
1636 if ( ASDCP_SUCCESS(result) ) {
1637 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayWidth));
1638 DisplayWidth.set_has_value( result == RESULT_OK );
1640 if ( ASDCP_SUCCESS(result) ) {
1641 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayXOffset));
1642 DisplayXOffset.set_has_value( result == RESULT_OK );
1644 if ( ASDCP_SUCCESS(result) ) {
1645 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayYOffset));
1646 DisplayYOffset.set_has_value( result == RESULT_OK );
1648 if ( ASDCP_SUCCESS(result) ) {
1649 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayF2Offset));
1650 DisplayF2Offset.set_has_value( result == RESULT_OK );
1652 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, AspectRatio));
1653 if ( ASDCP_SUCCESS(result) ) {
1654 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveFormatDescriptor));
1655 ActiveFormatDescriptor.set_has_value( result == RESULT_OK );
1657 if ( ASDCP_SUCCESS(result) ) {
1658 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, AlphaTransparency));
1659 AlphaTransparency.set_has_value( result == RESULT_OK );
1661 if ( ASDCP_SUCCESS(result) ) {
1662 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, TransferCharacteristic));
1663 TransferCharacteristic.set_has_value( result == RESULT_OK );
1665 if ( ASDCP_SUCCESS(result) ) {
1666 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ImageAlignmentOffset));
1667 ImageAlignmentOffset.set_has_value( result == RESULT_OK );
1669 if ( ASDCP_SUCCESS(result) ) {
1670 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ImageStartOffset));
1671 ImageStartOffset.set_has_value( result == RESULT_OK );
1673 if ( ASDCP_SUCCESS(result) ) {
1674 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ImageEndOffset));
1675 ImageEndOffset.set_has_value( result == RESULT_OK );
1677 if ( ASDCP_SUCCESS(result) ) {
1678 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, FieldDominance));
1679 FieldDominance.set_has_value( result == RESULT_OK );
1681 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, PictureEssenceCoding));
1682 if ( ASDCP_SUCCESS(result) ) {
1683 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, CodingEquations));
1684 CodingEquations.set_has_value( result == RESULT_OK );
1686 if ( ASDCP_SUCCESS(result) ) {
1687 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ColorPrimaries));
1688 ColorPrimaries.set_has_value( result == RESULT_OK );
1690 if ( ASDCP_SUCCESS(result) ) {
1691 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, AlternativeCenterCuts));
1693 if ( ASDCP_SUCCESS(result) ) {
1694 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveWidth));
1695 ActiveWidth.set_has_value( result == RESULT_OK );
1697 if ( ASDCP_SUCCESS(result) ) {
1698 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveHeight));
1699 ActiveHeight.set_has_value( result == RESULT_OK );
1701 if ( ASDCP_SUCCESS(result) ) {
1702 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveXOffset));
1703 ActiveXOffset.set_has_value( result == RESULT_OK );
1705 if ( ASDCP_SUCCESS(result) ) {
1706 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveYOffset));
1707 ActiveYOffset.set_has_value( result == RESULT_OK );
1709 if ( ASDCP_SUCCESS(result) ) {
1710 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, VideoLineMap));
1711 VideoLineMap.set_has_value( result == RESULT_OK );
1713 if ( ASDCP_SUCCESS(result) ) {
1714 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, MasteringDisplayPrimaries));
1715 MasteringDisplayPrimaries.set_has_value( result == RESULT_OK );
1717 if ( ASDCP_SUCCESS(result) ) {
1718 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, MasteringDisplayWhitePointChromaticity));
1719 MasteringDisplayWhitePointChromaticity.set_has_value( result == RESULT_OK );
1721 if ( ASDCP_SUCCESS(result) ) {
1722 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, MasteringDisplayMaximumLuminance));
1723 MasteringDisplayMaximumLuminance.set_has_value( result == RESULT_OK );
1725 if ( ASDCP_SUCCESS(result) ) {
1726 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, MasteringDisplayMinimumLuminance));
1727 MasteringDisplayMinimumLuminance.set_has_value( result == RESULT_OK );
1734 GenericPictureEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1737 Result_t result = FileDescriptor::WriteToTLVSet(TLVSet);
1738 if ( ASDCP_SUCCESS(result) && ! SignalStandard.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, SignalStandard));
1739 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, FrameLayout));
1740 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, StoredWidth));
1741 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, StoredHeight));
1742 if ( ASDCP_SUCCESS(result) && ! StoredF2Offset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, StoredF2Offset));
1743 if ( ASDCP_SUCCESS(result) && ! SampledWidth.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, SampledWidth));
1744 if ( ASDCP_SUCCESS(result) && ! SampledHeight.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, SampledHeight));
1745 if ( ASDCP_SUCCESS(result) && ! SampledXOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, SampledXOffset));
1746 if ( ASDCP_SUCCESS(result) && ! SampledYOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, SampledYOffset));
1747 if ( ASDCP_SUCCESS(result) && ! DisplayHeight.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayHeight));
1748 if ( ASDCP_SUCCESS(result) && ! DisplayWidth.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayWidth));
1749 if ( ASDCP_SUCCESS(result) && ! DisplayXOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayXOffset));
1750 if ( ASDCP_SUCCESS(result) && ! DisplayYOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayYOffset));
1751 if ( ASDCP_SUCCESS(result) && ! DisplayF2Offset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayF2Offset));
1752 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, AspectRatio));
1753 if ( ASDCP_SUCCESS(result) && ! ActiveFormatDescriptor.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveFormatDescriptor));
1754 if ( ASDCP_SUCCESS(result) && ! AlphaTransparency.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, AlphaTransparency));
1755 if ( ASDCP_SUCCESS(result) && ! TransferCharacteristic.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, TransferCharacteristic));
1756 if ( ASDCP_SUCCESS(result) && ! ImageAlignmentOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ImageAlignmentOffset));
1757 if ( ASDCP_SUCCESS(result) && ! ImageStartOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ImageStartOffset));
1758 if ( ASDCP_SUCCESS(result) && ! ImageEndOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ImageEndOffset));
1759 if ( ASDCP_SUCCESS(result) && ! FieldDominance.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, FieldDominance));
1760 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, PictureEssenceCoding));
1761 if ( ASDCP_SUCCESS(result) && ! CodingEquations.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, CodingEquations));
1762 if ( ASDCP_SUCCESS(result) && ! ColorPrimaries.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ColorPrimaries));
1763 if ( ASDCP_SUCCESS(result) && ! AlternativeCenterCuts.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, AlternativeCenterCuts));
1764 if ( ASDCP_SUCCESS(result) && ! ActiveWidth.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveWidth));
1765 if ( ASDCP_SUCCESS(result) && ! ActiveHeight.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveHeight));
1766 if ( ASDCP_SUCCESS(result) && ! ActiveXOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveXOffset));
1767 if ( ASDCP_SUCCESS(result) && ! ActiveYOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveYOffset));
1768 if ( ASDCP_SUCCESS(result) && ! VideoLineMap.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, VideoLineMap));
1769 if ( ASDCP_SUCCESS(result) && ! MasteringDisplayPrimaries.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, MasteringDisplayPrimaries));
1770 if ( ASDCP_SUCCESS(result) && ! MasteringDisplayWhitePointChromaticity.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, MasteringDisplayWhitePointChromaticity));
1771 if ( ASDCP_SUCCESS(result) && ! MasteringDisplayMaximumLuminance.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, MasteringDisplayMaximumLuminance));
1772 if ( ASDCP_SUCCESS(result) && ! MasteringDisplayMinimumLuminance.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, MasteringDisplayMinimumLuminance));
1778 GenericPictureEssenceDescriptor::Copy(const GenericPictureEssenceDescriptor& rhs)
1780 FileDescriptor::Copy(rhs);
1781 SignalStandard = rhs.SignalStandard;
1782 FrameLayout = rhs.FrameLayout;
1783 StoredWidth = rhs.StoredWidth;
1784 StoredHeight = rhs.StoredHeight;
1785 StoredF2Offset = rhs.StoredF2Offset;
1786 SampledWidth = rhs.SampledWidth;
1787 SampledHeight = rhs.SampledHeight;
1788 SampledXOffset = rhs.SampledXOffset;
1789 SampledYOffset = rhs.SampledYOffset;
1790 DisplayHeight = rhs.DisplayHeight;
1791 DisplayWidth = rhs.DisplayWidth;
1792 DisplayXOffset = rhs.DisplayXOffset;
1793 DisplayYOffset = rhs.DisplayYOffset;
1794 DisplayF2Offset = rhs.DisplayF2Offset;
1795 AspectRatio = rhs.AspectRatio;
1796 ActiveFormatDescriptor = rhs.ActiveFormatDescriptor;
1797 AlphaTransparency = rhs.AlphaTransparency;
1798 TransferCharacteristic = rhs.TransferCharacteristic;
1799 ImageAlignmentOffset = rhs.ImageAlignmentOffset;
1800 ImageStartOffset = rhs.ImageStartOffset;
1801 ImageEndOffset = rhs.ImageEndOffset;
1802 FieldDominance = rhs.FieldDominance;
1803 PictureEssenceCoding = rhs.PictureEssenceCoding;
1804 CodingEquations = rhs.CodingEquations;
1805 ColorPrimaries = rhs.ColorPrimaries;
1806 AlternativeCenterCuts = rhs.AlternativeCenterCuts;
1807 ActiveWidth = rhs.ActiveWidth;
1808 ActiveHeight = rhs.ActiveHeight;
1809 ActiveXOffset = rhs.ActiveXOffset;
1810 ActiveYOffset = rhs.ActiveYOffset;
1811 VideoLineMap = rhs.VideoLineMap;
1812 MasteringDisplayPrimaries = rhs.MasteringDisplayPrimaries;
1813 MasteringDisplayWhitePointChromaticity = rhs.MasteringDisplayWhitePointChromaticity;
1814 MasteringDisplayMaximumLuminance = rhs.MasteringDisplayMaximumLuminance;
1815 MasteringDisplayMinimumLuminance = rhs.MasteringDisplayMinimumLuminance;
1820 GenericPictureEssenceDescriptor::Dump(FILE* stream)
1822 char identbuf[IdentBufferLen];
1828 FileDescriptor::Dump(stream);
1829 if ( ! SignalStandard.empty() ) {
1830 fprintf(stream, " %22s = %d\n", "SignalStandard", SignalStandard.get());
1832 fprintf(stream, " %22s = %d\n", "FrameLayout", FrameLayout);
1833 fprintf(stream, " %22s = %d\n", "StoredWidth", StoredWidth);
1834 fprintf(stream, " %22s = %d\n", "StoredHeight", StoredHeight);
1835 if ( ! StoredF2Offset.empty() ) {
1836 fprintf(stream, " %22s = %d\n", "StoredF2Offset", StoredF2Offset.get());
1838 if ( ! SampledWidth.empty() ) {
1839 fprintf(stream, " %22s = %d\n", "SampledWidth", SampledWidth.get());
1841 if ( ! SampledHeight.empty() ) {
1842 fprintf(stream, " %22s = %d\n", "SampledHeight", SampledHeight.get());
1844 if ( ! SampledXOffset.empty() ) {
1845 fprintf(stream, " %22s = %d\n", "SampledXOffset", SampledXOffset.get());
1847 if ( ! SampledYOffset.empty() ) {
1848 fprintf(stream, " %22s = %d\n", "SampledYOffset", SampledYOffset.get());
1850 if ( ! DisplayHeight.empty() ) {
1851 fprintf(stream, " %22s = %d\n", "DisplayHeight", DisplayHeight.get());
1853 if ( ! DisplayWidth.empty() ) {
1854 fprintf(stream, " %22s = %d\n", "DisplayWidth", DisplayWidth.get());
1856 if ( ! DisplayXOffset.empty() ) {
1857 fprintf(stream, " %22s = %d\n", "DisplayXOffset", DisplayXOffset.get());
1859 if ( ! DisplayYOffset.empty() ) {
1860 fprintf(stream, " %22s = %d\n", "DisplayYOffset", DisplayYOffset.get());
1862 if ( ! DisplayF2Offset.empty() ) {
1863 fprintf(stream, " %22s = %d\n", "DisplayF2Offset", DisplayF2Offset.get());
1865 fprintf(stream, " %22s = %s\n", "AspectRatio", AspectRatio.EncodeString(identbuf, IdentBufferLen));
1866 if ( ! ActiveFormatDescriptor.empty() ) {
1867 fprintf(stream, " %22s = %d\n", "ActiveFormatDescriptor", ActiveFormatDescriptor.get());
1869 if ( ! AlphaTransparency.empty() ) {
1870 fprintf(stream, " %22s = %d\n", "AlphaTransparency", AlphaTransparency.get());
1872 if ( ! TransferCharacteristic.empty() ) {
1873 fprintf(stream, " %22s = %s\n", "TransferCharacteristic", TransferCharacteristic.get().EncodeString(identbuf, IdentBufferLen));
1875 if ( ! ImageAlignmentOffset.empty() ) {
1876 fprintf(stream, " %22s = %d\n", "ImageAlignmentOffset", ImageAlignmentOffset.get());
1878 if ( ! ImageStartOffset.empty() ) {
1879 fprintf(stream, " %22s = %d\n", "ImageStartOffset", ImageStartOffset.get());
1881 if ( ! ImageEndOffset.empty() ) {
1882 fprintf(stream, " %22s = %d\n", "ImageEndOffset", ImageEndOffset.get());
1884 if ( ! FieldDominance.empty() ) {
1885 fprintf(stream, " %22s = %d\n", "FieldDominance", FieldDominance.get());
1887 fprintf(stream, " %22s = %s\n", "PictureEssenceCoding", PictureEssenceCoding.EncodeString(identbuf, IdentBufferLen));
1888 if ( ! CodingEquations.empty() ) {
1889 fprintf(stream, " %22s = %s\n", "CodingEquations", CodingEquations.get().EncodeString(identbuf, IdentBufferLen));
1891 if ( ! ColorPrimaries.empty() ) {
1892 fprintf(stream, " %22s = %s\n", "ColorPrimaries", ColorPrimaries.get().EncodeString(identbuf, IdentBufferLen));
1894 if ( ! AlternativeCenterCuts.empty() ) {
1895 fprintf(stream, " %22s:\n", "AlternativeCenterCuts");
1896 AlternativeCenterCuts.get().Dump(stream);
1898 if ( ! ActiveWidth.empty() ) {
1899 fprintf(stream, " %22s = %d\n", "ActiveWidth", ActiveWidth.get());
1901 if ( ! ActiveHeight.empty() ) {
1902 fprintf(stream, " %22s = %d\n", "ActiveHeight", ActiveHeight.get());
1904 if ( ! ActiveXOffset.empty() ) {
1905 fprintf(stream, " %22s = %d\n", "ActiveXOffset", ActiveXOffset.get());
1907 if ( ! ActiveYOffset.empty() ) {
1908 fprintf(stream, " %22s = %d\n", "ActiveYOffset", ActiveYOffset.get());
1910 if ( ! VideoLineMap.empty() ) {
1911 fprintf(stream, " %22s = %s\n", "VideoLineMap", VideoLineMap.get().EncodeString(identbuf, IdentBufferLen));
1913 if ( ! MasteringDisplayPrimaries.empty() ) {
1914 fprintf(stream, " %22s = %s\n", "MasteringDisplayPrimaries", MasteringDisplayPrimaries.get().EncodeString(identbuf, IdentBufferLen));
1916 if ( ! MasteringDisplayWhitePointChromaticity.empty() ) {
1917 fprintf(stream, " %22s = %s\n", "MasteringDisplayWhitePointChromaticity", MasteringDisplayWhitePointChromaticity.get().EncodeString(identbuf, IdentBufferLen));
1919 if ( ! MasteringDisplayMaximumLuminance.empty() ) {
1920 fprintf(stream, " %22s = %d\n", "MasteringDisplayMaximumLuminance", MasteringDisplayMaximumLuminance.get());
1922 if ( ! MasteringDisplayMinimumLuminance.empty() ) {
1923 fprintf(stream, " %22s = %d\n", "MasteringDisplayMinimumLuminance", MasteringDisplayMinimumLuminance.get());
1929 GenericPictureEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1931 return InterchangeObject::InitFromBuffer(p, l);
1936 GenericPictureEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1938 return InterchangeObject::WriteToBuffer(Buffer);
1941 //------------------------------------------------------------------------------------------
1942 // RGBAEssenceDescriptor
1946 RGBAEssenceDescriptor::RGBAEssenceDescriptor(const Dictionary*& d) : GenericPictureEssenceDescriptor(d), m_Dict(d)
1949 m_UL = m_Dict->ul(MDD_RGBAEssenceDescriptor);
1952 RGBAEssenceDescriptor::RGBAEssenceDescriptor(const RGBAEssenceDescriptor& rhs) : GenericPictureEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1955 m_UL = m_Dict->ul(MDD_RGBAEssenceDescriptor);
1962 RGBAEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1965 Result_t result = GenericPictureEssenceDescriptor::InitFromTLVSet(TLVSet);
1966 if ( ASDCP_SUCCESS(result) ) {
1967 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(RGBAEssenceDescriptor, ComponentMaxRef));
1968 ComponentMaxRef.set_has_value( result == RESULT_OK );
1970 if ( ASDCP_SUCCESS(result) ) {
1971 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(RGBAEssenceDescriptor, ComponentMinRef));
1972 ComponentMinRef.set_has_value( result == RESULT_OK );
1974 if ( ASDCP_SUCCESS(result) ) {
1975 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(RGBAEssenceDescriptor, AlphaMinRef));
1976 AlphaMinRef.set_has_value( result == RESULT_OK );
1978 if ( ASDCP_SUCCESS(result) ) {
1979 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(RGBAEssenceDescriptor, AlphaMaxRef));
1980 AlphaMaxRef.set_has_value( result == RESULT_OK );
1982 if ( ASDCP_SUCCESS(result) ) {
1983 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(RGBAEssenceDescriptor, ScanningDirection));
1984 ScanningDirection.set_has_value( result == RESULT_OK );
1986 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(RGBAEssenceDescriptor, PixelLayout));
1992 RGBAEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1995 Result_t result = GenericPictureEssenceDescriptor::WriteToTLVSet(TLVSet);
1996 if ( ASDCP_SUCCESS(result) && ! ComponentMaxRef.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(RGBAEssenceDescriptor, ComponentMaxRef));
1997 if ( ASDCP_SUCCESS(result) && ! ComponentMinRef.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(RGBAEssenceDescriptor, ComponentMinRef));
1998 if ( ASDCP_SUCCESS(result) && ! AlphaMinRef.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(RGBAEssenceDescriptor, AlphaMinRef));
1999 if ( ASDCP_SUCCESS(result) && ! AlphaMaxRef.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(RGBAEssenceDescriptor, AlphaMaxRef));
2000 if ( ASDCP_SUCCESS(result) && ! ScanningDirection.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(RGBAEssenceDescriptor, ScanningDirection));
2001 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(RGBAEssenceDescriptor, PixelLayout));
2007 RGBAEssenceDescriptor::Copy(const RGBAEssenceDescriptor& rhs)
2009 GenericPictureEssenceDescriptor::Copy(rhs);
2010 ComponentMaxRef = rhs.ComponentMaxRef;
2011 ComponentMinRef = rhs.ComponentMinRef;
2012 AlphaMinRef = rhs.AlphaMinRef;
2013 AlphaMaxRef = rhs.AlphaMaxRef;
2014 ScanningDirection = rhs.ScanningDirection;
2015 PixelLayout = rhs.PixelLayout;
2020 RGBAEssenceDescriptor::Dump(FILE* stream)
2022 char identbuf[IdentBufferLen];
2028 GenericPictureEssenceDescriptor::Dump(stream);
2029 if ( ! ComponentMaxRef.empty() ) {
2030 fprintf(stream, " %22s = %d\n", "ComponentMaxRef", ComponentMaxRef.get());
2032 if ( ! ComponentMinRef.empty() ) {
2033 fprintf(stream, " %22s = %d\n", "ComponentMinRef", ComponentMinRef.get());
2035 if ( ! AlphaMinRef.empty() ) {
2036 fprintf(stream, " %22s = %d\n", "AlphaMinRef", AlphaMinRef.get());
2038 if ( ! AlphaMaxRef.empty() ) {
2039 fprintf(stream, " %22s = %d\n", "AlphaMaxRef", AlphaMaxRef.get());
2041 if ( ! ScanningDirection.empty() ) {
2042 fprintf(stream, " %22s = %d\n", "ScanningDirection", ScanningDirection.get());
2044 fprintf(stream, " %22s = %s\n", "PixelLayout", PixelLayout.EncodeString(identbuf, IdentBufferLen));
2049 RGBAEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2051 return InterchangeObject::InitFromBuffer(p, l);
2056 RGBAEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2058 return InterchangeObject::WriteToBuffer(Buffer);
2061 //------------------------------------------------------------------------------------------
2062 // JPEG2000PictureSubDescriptor
2066 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)
2069 m_UL = m_Dict->ul(MDD_JPEG2000PictureSubDescriptor);
2072 JPEG2000PictureSubDescriptor::JPEG2000PictureSubDescriptor(const JPEG2000PictureSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2075 m_UL = m_Dict->ul(MDD_JPEG2000PictureSubDescriptor);
2082 JPEG2000PictureSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2085 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2086 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Rsize));
2087 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Xsize));
2088 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Ysize));
2089 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XOsize));
2090 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YOsize));
2091 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XTsize));
2092 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YTsize));
2093 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XTOsize));
2094 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YTOsize));
2095 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Csize));
2096 if ( ASDCP_SUCCESS(result) ) {
2097 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(JPEG2000PictureSubDescriptor, PictureComponentSizing));
2098 PictureComponentSizing.set_has_value( result == RESULT_OK );
2100 if ( ASDCP_SUCCESS(result) ) {
2101 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(JPEG2000PictureSubDescriptor, CodingStyleDefault));
2102 CodingStyleDefault.set_has_value( result == RESULT_OK );
2104 if ( ASDCP_SUCCESS(result) ) {
2105 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(JPEG2000PictureSubDescriptor, QuantizationDefault));
2106 QuantizationDefault.set_has_value( result == RESULT_OK );
2108 if ( ASDCP_SUCCESS(result) ) {
2109 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(JPEG2000PictureSubDescriptor, J2CLayout));
2110 J2CLayout.set_has_value( result == RESULT_OK );
2117 JPEG2000PictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2120 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2121 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Rsize));
2122 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Xsize));
2123 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Ysize));
2124 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XOsize));
2125 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YOsize));
2126 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XTsize));
2127 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YTsize));
2128 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XTOsize));
2129 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YTOsize));
2130 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Csize));
2131 if ( ASDCP_SUCCESS(result) && ! PictureComponentSizing.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(JPEG2000PictureSubDescriptor, PictureComponentSizing));
2132 if ( ASDCP_SUCCESS(result) && ! CodingStyleDefault.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(JPEG2000PictureSubDescriptor, CodingStyleDefault));
2133 if ( ASDCP_SUCCESS(result) && ! QuantizationDefault.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(JPEG2000PictureSubDescriptor, QuantizationDefault));
2134 if ( ASDCP_SUCCESS(result) && ! J2CLayout.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(JPEG2000PictureSubDescriptor, J2CLayout));
2140 JPEG2000PictureSubDescriptor::Copy(const JPEG2000PictureSubDescriptor& rhs)
2142 InterchangeObject::Copy(rhs);
2146 XOsize = rhs.XOsize;
2147 YOsize = rhs.YOsize;
2148 XTsize = rhs.XTsize;
2149 YTsize = rhs.YTsize;
2150 XTOsize = rhs.XTOsize;
2151 YTOsize = rhs.YTOsize;
2153 PictureComponentSizing = rhs.PictureComponentSizing;
2154 CodingStyleDefault = rhs.CodingStyleDefault;
2155 QuantizationDefault = rhs.QuantizationDefault;
2156 J2CLayout = rhs.J2CLayout;
2161 JPEG2000PictureSubDescriptor::Dump(FILE* stream)
2163 char identbuf[IdentBufferLen];
2169 InterchangeObject::Dump(stream);
2170 fprintf(stream, " %22s = %d\n", "Rsize", Rsize);
2171 fprintf(stream, " %22s = %d\n", "Xsize", Xsize);
2172 fprintf(stream, " %22s = %d\n", "Ysize", Ysize);
2173 fprintf(stream, " %22s = %d\n", "XOsize", XOsize);
2174 fprintf(stream, " %22s = %d\n", "YOsize", YOsize);
2175 fprintf(stream, " %22s = %d\n", "XTsize", XTsize);
2176 fprintf(stream, " %22s = %d\n", "YTsize", YTsize);
2177 fprintf(stream, " %22s = %d\n", "XTOsize", XTOsize);
2178 fprintf(stream, " %22s = %d\n", "YTOsize", YTOsize);
2179 fprintf(stream, " %22s = %d\n", "Csize", Csize);
2180 if ( ! PictureComponentSizing.empty() ) {
2181 fprintf(stream, " %22s = %s\n", "PictureComponentSizing", PictureComponentSizing.get().EncodeString(identbuf, IdentBufferLen));
2183 if ( ! CodingStyleDefault.empty() ) {
2184 fprintf(stream, " %22s = %s\n", "CodingStyleDefault", CodingStyleDefault.get().EncodeString(identbuf, IdentBufferLen));
2186 if ( ! QuantizationDefault.empty() ) {
2187 fprintf(stream, " %22s = %s\n", "QuantizationDefault", QuantizationDefault.get().EncodeString(identbuf, IdentBufferLen));
2189 if ( ! J2CLayout.empty() ) {
2190 fprintf(stream, " %22s = %s\n", "J2CLayout", J2CLayout.get().EncodeString(identbuf, IdentBufferLen));
2196 JPEG2000PictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2198 return InterchangeObject::InitFromBuffer(p, l);
2203 JPEG2000PictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2205 return InterchangeObject::WriteToBuffer(Buffer);
2208 //------------------------------------------------------------------------------------------
2209 // CDCIEssenceDescriptor
2213 CDCIEssenceDescriptor::CDCIEssenceDescriptor(const Dictionary*& d) : GenericPictureEssenceDescriptor(d), m_Dict(d), ComponentDepth(0), HorizontalSubsampling(0)
2216 m_UL = m_Dict->ul(MDD_CDCIEssenceDescriptor);
2219 CDCIEssenceDescriptor::CDCIEssenceDescriptor(const CDCIEssenceDescriptor& rhs) : GenericPictureEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2222 m_UL = m_Dict->ul(MDD_CDCIEssenceDescriptor);
2229 CDCIEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2232 Result_t result = GenericPictureEssenceDescriptor::InitFromTLVSet(TLVSet);
2233 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, ComponentDepth));
2234 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, HorizontalSubsampling));
2235 if ( ASDCP_SUCCESS(result) ) {
2236 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, VerticalSubsampling));
2237 VerticalSubsampling.set_has_value( result == RESULT_OK );
2239 if ( ASDCP_SUCCESS(result) ) {
2240 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, ColorSiting));
2241 ColorSiting.set_has_value( result == RESULT_OK );
2243 if ( ASDCP_SUCCESS(result) ) {
2244 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, ReversedByteOrder));
2245 ReversedByteOrder.set_has_value( result == RESULT_OK );
2247 if ( ASDCP_SUCCESS(result) ) {
2248 result = TLVSet.ReadUi16(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, PaddingBits));
2249 PaddingBits.set_has_value( result == RESULT_OK );
2251 if ( ASDCP_SUCCESS(result) ) {
2252 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, AlphaSampleDepth));
2253 AlphaSampleDepth.set_has_value( result == RESULT_OK );
2255 if ( ASDCP_SUCCESS(result) ) {
2256 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, BlackRefLevel));
2257 BlackRefLevel.set_has_value( result == RESULT_OK );
2259 if ( ASDCP_SUCCESS(result) ) {
2260 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, WhiteReflevel));
2261 WhiteReflevel.set_has_value( result == RESULT_OK );
2263 if ( ASDCP_SUCCESS(result) ) {
2264 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, ColorRange));
2265 ColorRange.set_has_value( result == RESULT_OK );
2272 CDCIEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2275 Result_t result = GenericPictureEssenceDescriptor::WriteToTLVSet(TLVSet);
2276 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, ComponentDepth));
2277 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, HorizontalSubsampling));
2278 if ( ASDCP_SUCCESS(result) && ! VerticalSubsampling.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, VerticalSubsampling));
2279 if ( ASDCP_SUCCESS(result) && ! ColorSiting.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, ColorSiting));
2280 if ( ASDCP_SUCCESS(result) && ! ReversedByteOrder.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, ReversedByteOrder));
2281 if ( ASDCP_SUCCESS(result) && ! PaddingBits.empty() ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, PaddingBits));
2282 if ( ASDCP_SUCCESS(result) && ! AlphaSampleDepth.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, AlphaSampleDepth));
2283 if ( ASDCP_SUCCESS(result) && ! BlackRefLevel.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, BlackRefLevel));
2284 if ( ASDCP_SUCCESS(result) && ! WhiteReflevel.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, WhiteReflevel));
2285 if ( ASDCP_SUCCESS(result) && ! ColorRange.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, ColorRange));
2291 CDCIEssenceDescriptor::Copy(const CDCIEssenceDescriptor& rhs)
2293 GenericPictureEssenceDescriptor::Copy(rhs);
2294 ComponentDepth = rhs.ComponentDepth;
2295 HorizontalSubsampling = rhs.HorizontalSubsampling;
2296 VerticalSubsampling = rhs.VerticalSubsampling;
2297 ColorSiting = rhs.ColorSiting;
2298 ReversedByteOrder = rhs.ReversedByteOrder;
2299 PaddingBits = rhs.PaddingBits;
2300 AlphaSampleDepth = rhs.AlphaSampleDepth;
2301 BlackRefLevel = rhs.BlackRefLevel;
2302 WhiteReflevel = rhs.WhiteReflevel;
2303 ColorRange = rhs.ColorRange;
2308 CDCIEssenceDescriptor::Dump(FILE* stream)
2310 char identbuf[IdentBufferLen];
2316 GenericPictureEssenceDescriptor::Dump(stream);
2317 fprintf(stream, " %22s = %d\n", "ComponentDepth", ComponentDepth);
2318 fprintf(stream, " %22s = %d\n", "HorizontalSubsampling", HorizontalSubsampling);
2319 if ( ! VerticalSubsampling.empty() ) {
2320 fprintf(stream, " %22s = %d\n", "VerticalSubsampling", VerticalSubsampling.get());
2322 if ( ! ColorSiting.empty() ) {
2323 fprintf(stream, " %22s = %d\n", "ColorSiting", ColorSiting.get());
2325 if ( ! ReversedByteOrder.empty() ) {
2326 fprintf(stream, " %22s = %d\n", "ReversedByteOrder", ReversedByteOrder.get());
2328 if ( ! PaddingBits.empty() ) {
2329 fprintf(stream, " %22s = %d\n", "PaddingBits", PaddingBits.get());
2331 if ( ! AlphaSampleDepth.empty() ) {
2332 fprintf(stream, " %22s = %d\n", "AlphaSampleDepth", AlphaSampleDepth.get());
2334 if ( ! BlackRefLevel.empty() ) {
2335 fprintf(stream, " %22s = %d\n", "BlackRefLevel", BlackRefLevel.get());
2337 if ( ! WhiteReflevel.empty() ) {
2338 fprintf(stream, " %22s = %d\n", "WhiteReflevel", WhiteReflevel.get());
2340 if ( ! ColorRange.empty() ) {
2341 fprintf(stream, " %22s = %d\n", "ColorRange", ColorRange.get());
2347 CDCIEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2349 return InterchangeObject::InitFromBuffer(p, l);
2354 CDCIEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2356 return InterchangeObject::WriteToBuffer(Buffer);
2359 //------------------------------------------------------------------------------------------
2360 // MPEG2VideoDescriptor
2364 MPEG2VideoDescriptor::MPEG2VideoDescriptor(const Dictionary*& d) : CDCIEssenceDescriptor(d), m_Dict(d)
2367 m_UL = m_Dict->ul(MDD_MPEG2VideoDescriptor);
2370 MPEG2VideoDescriptor::MPEG2VideoDescriptor(const MPEG2VideoDescriptor& rhs) : CDCIEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2373 m_UL = m_Dict->ul(MDD_MPEG2VideoDescriptor);
2380 MPEG2VideoDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2383 Result_t result = CDCIEssenceDescriptor::InitFromTLVSet(TLVSet);
2384 if ( ASDCP_SUCCESS(result) ) {
2385 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, SingleSequence));
2386 SingleSequence.set_has_value( result == RESULT_OK );
2388 if ( ASDCP_SUCCESS(result) ) {
2389 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, ConstantBFrames));
2390 ConstantBFrames.set_has_value( result == RESULT_OK );
2392 if ( ASDCP_SUCCESS(result) ) {
2393 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, CodedContentType));
2394 CodedContentType.set_has_value( result == RESULT_OK );
2396 if ( ASDCP_SUCCESS(result) ) {
2397 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, LowDelay));
2398 LowDelay.set_has_value( result == RESULT_OK );
2400 if ( ASDCP_SUCCESS(result) ) {
2401 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, ClosedGOP));
2402 ClosedGOP.set_has_value( result == RESULT_OK );
2404 if ( ASDCP_SUCCESS(result) ) {
2405 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, IdenticalGOP));
2406 IdenticalGOP.set_has_value( result == RESULT_OK );
2408 if ( ASDCP_SUCCESS(result) ) {
2409 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, MaxGOP));
2410 MaxGOP.set_has_value( result == RESULT_OK );
2412 if ( ASDCP_SUCCESS(result) ) {
2413 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, BPictureCount));
2414 BPictureCount.set_has_value( result == RESULT_OK );
2416 if ( ASDCP_SUCCESS(result) ) {
2417 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, BitRate));
2418 BitRate.set_has_value( result == RESULT_OK );
2420 if ( ASDCP_SUCCESS(result) ) {
2421 result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, ProfileAndLevel));
2422 ProfileAndLevel.set_has_value( result == RESULT_OK );
2429 MPEG2VideoDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2432 Result_t result = CDCIEssenceDescriptor::WriteToTLVSet(TLVSet);
2433 if ( ASDCP_SUCCESS(result) && ! SingleSequence.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, SingleSequence));
2434 if ( ASDCP_SUCCESS(result) && ! ConstantBFrames.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, ConstantBFrames));
2435 if ( ASDCP_SUCCESS(result) && ! CodedContentType.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, CodedContentType));
2436 if ( ASDCP_SUCCESS(result) && ! LowDelay.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, LowDelay));
2437 if ( ASDCP_SUCCESS(result) && ! ClosedGOP.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, ClosedGOP));
2438 if ( ASDCP_SUCCESS(result) && ! IdenticalGOP.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, IdenticalGOP));
2439 if ( ASDCP_SUCCESS(result) && ! MaxGOP.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, MaxGOP));
2440 if ( ASDCP_SUCCESS(result) && ! BPictureCount.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, BPictureCount));
2441 if ( ASDCP_SUCCESS(result) && ! BitRate.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, BitRate));
2442 if ( ASDCP_SUCCESS(result) && ! ProfileAndLevel.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, ProfileAndLevel));
2448 MPEG2VideoDescriptor::Copy(const MPEG2VideoDescriptor& rhs)
2450 CDCIEssenceDescriptor::Copy(rhs);
2451 SingleSequence = rhs.SingleSequence;
2452 ConstantBFrames = rhs.ConstantBFrames;
2453 CodedContentType = rhs.CodedContentType;
2454 LowDelay = rhs.LowDelay;
2455 ClosedGOP = rhs.ClosedGOP;
2456 IdenticalGOP = rhs.IdenticalGOP;
2457 MaxGOP = rhs.MaxGOP;
2458 BPictureCount = rhs.BPictureCount;
2459 BitRate = rhs.BitRate;
2460 ProfileAndLevel = rhs.ProfileAndLevel;
2465 MPEG2VideoDescriptor::Dump(FILE* stream)
2467 char identbuf[IdentBufferLen];
2473 CDCIEssenceDescriptor::Dump(stream);
2474 if ( ! SingleSequence.empty() ) {
2475 fprintf(stream, " %22s = %d\n", "SingleSequence", SingleSequence.get());
2477 if ( ! ConstantBFrames.empty() ) {
2478 fprintf(stream, " %22s = %d\n", "ConstantBFrames", ConstantBFrames.get());
2480 if ( ! CodedContentType.empty() ) {
2481 fprintf(stream, " %22s = %d\n", "CodedContentType", CodedContentType.get());
2483 if ( ! LowDelay.empty() ) {
2484 fprintf(stream, " %22s = %d\n", "LowDelay", LowDelay.get());
2486 if ( ! ClosedGOP.empty() ) {
2487 fprintf(stream, " %22s = %d\n", "ClosedGOP", ClosedGOP.get());
2489 if ( ! IdenticalGOP.empty() ) {
2490 fprintf(stream, " %22s = %d\n", "IdenticalGOP", IdenticalGOP.get());
2492 if ( ! MaxGOP.empty() ) {
2493 fprintf(stream, " %22s = %d\n", "MaxGOP", MaxGOP.get());
2495 if ( ! BPictureCount.empty() ) {
2496 fprintf(stream, " %22s = %d\n", "BPictureCount", BPictureCount.get());
2498 if ( ! BitRate.empty() ) {
2499 fprintf(stream, " %22s = %d\n", "BitRate", BitRate.get());
2501 if ( ! ProfileAndLevel.empty() ) {
2502 fprintf(stream, " %22s = %d\n", "ProfileAndLevel", ProfileAndLevel.get());
2508 MPEG2VideoDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2510 return InterchangeObject::InitFromBuffer(p, l);
2515 MPEG2VideoDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2517 return InterchangeObject::WriteToBuffer(Buffer);
2520 //------------------------------------------------------------------------------------------
2525 DMSegment::DMSegment(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), EventStartPosition(0), Duration(0)
2528 m_UL = m_Dict->ul(MDD_DMSegment);
2531 DMSegment::DMSegment(const DMSegment& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2534 m_UL = m_Dict->ul(MDD_DMSegment);
2541 DMSegment::InitFromTLVSet(TLVReader& TLVSet)
2544 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2545 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, DataDefinition));
2546 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(DMSegment, EventStartPosition));
2547 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(DMSegment, Duration));
2548 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, EventComment));
2549 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, DMFramework));
2555 DMSegment::WriteToTLVSet(TLVWriter& TLVSet)
2558 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2559 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, DataDefinition));
2560 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(DMSegment, EventStartPosition));
2561 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(DMSegment, Duration));
2562 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, EventComment));
2563 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, DMFramework));
2569 DMSegment::Copy(const DMSegment& rhs)
2571 InterchangeObject::Copy(rhs);
2572 DataDefinition = rhs.DataDefinition;
2573 EventStartPosition = rhs.EventStartPosition;
2574 Duration = rhs.Duration;
2575 EventComment = rhs.EventComment;
2576 DMFramework = rhs.DMFramework;
2581 DMSegment::Dump(FILE* stream)
2583 char identbuf[IdentBufferLen];
2589 InterchangeObject::Dump(stream);
2590 fprintf(stream, " %22s = %s\n", "DataDefinition", DataDefinition.EncodeString(identbuf, IdentBufferLen));
2591 fprintf(stream, " %22s = %s\n", "EventStartPosition", i64sz(EventStartPosition, identbuf));
2592 fprintf(stream, " %22s = %s\n", "Duration", i64sz(Duration, identbuf));
2593 fprintf(stream, " %22s = %s\n", "EventComment", EventComment.EncodeString(identbuf, IdentBufferLen));
2594 fprintf(stream, " %22s = %s\n", "DMFramework", DMFramework.EncodeString(identbuf, IdentBufferLen));
2599 DMSegment::InitFromBuffer(const byte_t* p, ui32_t l)
2601 return InterchangeObject::InitFromBuffer(p, l);
2606 DMSegment::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2608 return InterchangeObject::WriteToBuffer(Buffer);
2611 //------------------------------------------------------------------------------------------
2612 // CryptographicFramework
2616 CryptographicFramework::CryptographicFramework(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2619 m_UL = m_Dict->ul(MDD_CryptographicFramework);
2622 CryptographicFramework::CryptographicFramework(const CryptographicFramework& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2625 m_UL = m_Dict->ul(MDD_CryptographicFramework);
2632 CryptographicFramework::InitFromTLVSet(TLVReader& TLVSet)
2635 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2636 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicFramework, ContextSR));
2642 CryptographicFramework::WriteToTLVSet(TLVWriter& TLVSet)
2645 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2646 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicFramework, ContextSR));
2652 CryptographicFramework::Copy(const CryptographicFramework& rhs)
2654 InterchangeObject::Copy(rhs);
2655 ContextSR = rhs.ContextSR;
2660 CryptographicFramework::Dump(FILE* stream)
2662 char identbuf[IdentBufferLen];
2668 InterchangeObject::Dump(stream);
2669 fprintf(stream, " %22s = %s\n", "ContextSR", ContextSR.EncodeString(identbuf, IdentBufferLen));
2674 CryptographicFramework::InitFromBuffer(const byte_t* p, ui32_t l)
2676 return InterchangeObject::InitFromBuffer(p, l);
2681 CryptographicFramework::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2683 return InterchangeObject::WriteToBuffer(Buffer);
2686 //------------------------------------------------------------------------------------------
2687 // CryptographicContext
2691 CryptographicContext::CryptographicContext(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2694 m_UL = m_Dict->ul(MDD_CryptographicContext);
2697 CryptographicContext::CryptographicContext(const CryptographicContext& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2700 m_UL = m_Dict->ul(MDD_CryptographicContext);
2707 CryptographicContext::InitFromTLVSet(TLVReader& TLVSet)
2710 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2711 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, ContextID));
2712 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, SourceEssenceContainer));
2713 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, CipherAlgorithm));
2714 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, MICAlgorithm));
2715 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, CryptographicKeyID));
2721 CryptographicContext::WriteToTLVSet(TLVWriter& TLVSet)
2724 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2725 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, ContextID));
2726 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, SourceEssenceContainer));
2727 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, CipherAlgorithm));
2728 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, MICAlgorithm));
2729 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, CryptographicKeyID));
2735 CryptographicContext::Copy(const CryptographicContext& rhs)
2737 InterchangeObject::Copy(rhs);
2738 ContextID = rhs.ContextID;
2739 SourceEssenceContainer = rhs.SourceEssenceContainer;
2740 CipherAlgorithm = rhs.CipherAlgorithm;
2741 MICAlgorithm = rhs.MICAlgorithm;
2742 CryptographicKeyID = rhs.CryptographicKeyID;
2747 CryptographicContext::Dump(FILE* stream)
2749 char identbuf[IdentBufferLen];
2755 InterchangeObject::Dump(stream);
2756 fprintf(stream, " %22s = %s\n", "ContextID", ContextID.EncodeString(identbuf, IdentBufferLen));
2757 fprintf(stream, " %22s = %s\n", "SourceEssenceContainer", SourceEssenceContainer.EncodeString(identbuf, IdentBufferLen));
2758 fprintf(stream, " %22s = %s\n", "CipherAlgorithm", CipherAlgorithm.EncodeString(identbuf, IdentBufferLen));
2759 fprintf(stream, " %22s = %s\n", "MICAlgorithm", MICAlgorithm.EncodeString(identbuf, IdentBufferLen));
2760 fprintf(stream, " %22s = %s\n", "CryptographicKeyID", CryptographicKeyID.EncodeString(identbuf, IdentBufferLen));
2765 CryptographicContext::InitFromBuffer(const byte_t* p, ui32_t l)
2767 return InterchangeObject::InitFromBuffer(p, l);
2772 CryptographicContext::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2774 return InterchangeObject::WriteToBuffer(Buffer);
2777 //------------------------------------------------------------------------------------------
2778 // GenericDataEssenceDescriptor
2782 GenericDataEssenceDescriptor::GenericDataEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d)
2785 m_UL = m_Dict->ul(MDD_GenericDataEssenceDescriptor);
2788 GenericDataEssenceDescriptor::GenericDataEssenceDescriptor(const GenericDataEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2791 m_UL = m_Dict->ul(MDD_GenericDataEssenceDescriptor);
2798 GenericDataEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2801 Result_t result = FileDescriptor::InitFromTLVSet(TLVSet);
2802 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericDataEssenceDescriptor, DataEssenceCoding));
2808 GenericDataEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2811 Result_t result = FileDescriptor::WriteToTLVSet(TLVSet);
2812 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericDataEssenceDescriptor, DataEssenceCoding));
2818 GenericDataEssenceDescriptor::Copy(const GenericDataEssenceDescriptor& rhs)
2820 FileDescriptor::Copy(rhs);
2821 DataEssenceCoding = rhs.DataEssenceCoding;
2826 GenericDataEssenceDescriptor::Dump(FILE* stream)
2828 char identbuf[IdentBufferLen];
2834 FileDescriptor::Dump(stream);
2835 fprintf(stream, " %22s = %s\n", "DataEssenceCoding", DataEssenceCoding.EncodeString(identbuf, IdentBufferLen));
2840 GenericDataEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2842 return InterchangeObject::InitFromBuffer(p, l);
2847 GenericDataEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2849 return InterchangeObject::WriteToBuffer(Buffer);
2852 //------------------------------------------------------------------------------------------
2853 // TimedTextDescriptor
2857 TimedTextDescriptor::TimedTextDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d)
2860 m_UL = m_Dict->ul(MDD_TimedTextDescriptor);
2863 TimedTextDescriptor::TimedTextDescriptor(const TimedTextDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2866 m_UL = m_Dict->ul(MDD_TimedTextDescriptor);
2873 TimedTextDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2876 Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
2877 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextDescriptor, ResourceID));
2878 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextDescriptor, UCSEncoding));
2879 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextDescriptor, NamespaceURI));
2880 if ( ASDCP_SUCCESS(result) ) {
2881 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(TimedTextDescriptor, RFC5646LanguageTagList));
2882 RFC5646LanguageTagList.set_has_value( result == RESULT_OK );
2889 TimedTextDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2892 Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
2893 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextDescriptor, ResourceID));
2894 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextDescriptor, UCSEncoding));
2895 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextDescriptor, NamespaceURI));
2896 if ( ASDCP_SUCCESS(result) && ! RFC5646LanguageTagList.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(TimedTextDescriptor, RFC5646LanguageTagList));
2902 TimedTextDescriptor::Copy(const TimedTextDescriptor& rhs)
2904 GenericDataEssenceDescriptor::Copy(rhs);
2905 ResourceID = rhs.ResourceID;
2906 UCSEncoding = rhs.UCSEncoding;
2907 NamespaceURI = rhs.NamespaceURI;
2908 RFC5646LanguageTagList = rhs.RFC5646LanguageTagList;
2913 TimedTextDescriptor::Dump(FILE* stream)
2915 char identbuf[IdentBufferLen];
2921 GenericDataEssenceDescriptor::Dump(stream);
2922 fprintf(stream, " %22s = %s\n", "ResourceID", ResourceID.EncodeString(identbuf, IdentBufferLen));
2923 fprintf(stream, " %22s = %s\n", "UCSEncoding", UCSEncoding.EncodeString(identbuf, IdentBufferLen));
2924 fprintf(stream, " %22s = %s\n", "NamespaceURI", NamespaceURI.EncodeString(identbuf, IdentBufferLen));
2925 if ( ! RFC5646LanguageTagList.empty() ) {
2926 fprintf(stream, " %22s = %s\n", "RFC5646LanguageTagList", RFC5646LanguageTagList.get().EncodeString(identbuf, IdentBufferLen));
2932 TimedTextDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2934 return InterchangeObject::InitFromBuffer(p, l);
2939 TimedTextDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2941 return InterchangeObject::WriteToBuffer(Buffer);
2944 //------------------------------------------------------------------------------------------
2945 // TimedTextResourceSubDescriptor
2949 TimedTextResourceSubDescriptor::TimedTextResourceSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), EssenceStreamID(0)
2952 m_UL = m_Dict->ul(MDD_TimedTextResourceSubDescriptor);
2955 TimedTextResourceSubDescriptor::TimedTextResourceSubDescriptor(const TimedTextResourceSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2958 m_UL = m_Dict->ul(MDD_TimedTextResourceSubDescriptor);
2965 TimedTextResourceSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2968 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2969 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextResourceSubDescriptor, AncillaryResourceID));
2970 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextResourceSubDescriptor, MIMEMediaType));
2971 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(TimedTextResourceSubDescriptor, EssenceStreamID));
2977 TimedTextResourceSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2980 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2981 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextResourceSubDescriptor, AncillaryResourceID));
2982 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextResourceSubDescriptor, MIMEMediaType));
2983 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(TimedTextResourceSubDescriptor, EssenceStreamID));
2989 TimedTextResourceSubDescriptor::Copy(const TimedTextResourceSubDescriptor& rhs)
2991 InterchangeObject::Copy(rhs);
2992 AncillaryResourceID = rhs.AncillaryResourceID;
2993 MIMEMediaType = rhs.MIMEMediaType;
2994 EssenceStreamID = rhs.EssenceStreamID;
2999 TimedTextResourceSubDescriptor::Dump(FILE* stream)
3001 char identbuf[IdentBufferLen];
3007 InterchangeObject::Dump(stream);
3008 fprintf(stream, " %22s = %s\n", "AncillaryResourceID", AncillaryResourceID.EncodeString(identbuf, IdentBufferLen));
3009 fprintf(stream, " %22s = %s\n", "MIMEMediaType", MIMEMediaType.EncodeString(identbuf, IdentBufferLen));
3010 fprintf(stream, " %22s = %d\n", "EssenceStreamID", EssenceStreamID);
3015 TimedTextResourceSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3017 return InterchangeObject::InitFromBuffer(p, l);
3022 TimedTextResourceSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3024 return InterchangeObject::WriteToBuffer(Buffer);
3027 //------------------------------------------------------------------------------------------
3028 // StereoscopicPictureSubDescriptor
3032 StereoscopicPictureSubDescriptor::StereoscopicPictureSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
3035 m_UL = m_Dict->ul(MDD_StereoscopicPictureSubDescriptor);
3038 StereoscopicPictureSubDescriptor::StereoscopicPictureSubDescriptor(const StereoscopicPictureSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3041 m_UL = m_Dict->ul(MDD_StereoscopicPictureSubDescriptor);
3048 StereoscopicPictureSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3051 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3057 StereoscopicPictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3060 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3066 StereoscopicPictureSubDescriptor::Copy(const StereoscopicPictureSubDescriptor& rhs)
3068 InterchangeObject::Copy(rhs);
3073 StereoscopicPictureSubDescriptor::Dump(FILE* stream)
3075 char identbuf[IdentBufferLen];
3081 InterchangeObject::Dump(stream);
3086 StereoscopicPictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3088 return InterchangeObject::InitFromBuffer(p, l);
3093 StereoscopicPictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3095 return InterchangeObject::WriteToBuffer(Buffer);
3098 //------------------------------------------------------------------------------------------
3099 // ContainerConstraintSubDescriptor
3103 ContainerConstraintSubDescriptor::ContainerConstraintSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
3106 m_UL = m_Dict->ul(MDD_ContainerConstraintSubDescriptor);
3109 ContainerConstraintSubDescriptor::ContainerConstraintSubDescriptor(const ContainerConstraintSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3112 m_UL = m_Dict->ul(MDD_ContainerConstraintSubDescriptor);
3119 ContainerConstraintSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3122 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3128 ContainerConstraintSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3131 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3137 ContainerConstraintSubDescriptor::Copy(const ContainerConstraintSubDescriptor& rhs)
3139 InterchangeObject::Copy(rhs);
3144 ContainerConstraintSubDescriptor::Dump(FILE* stream)
3146 char identbuf[IdentBufferLen];
3152 InterchangeObject::Dump(stream);
3157 ContainerConstraintSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3159 return InterchangeObject::InitFromBuffer(p, l);
3164 ContainerConstraintSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3166 return InterchangeObject::WriteToBuffer(Buffer);
3169 //------------------------------------------------------------------------------------------
3174 NetworkLocator::NetworkLocator(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
3177 m_UL = m_Dict->ul(MDD_NetworkLocator);
3180 NetworkLocator::NetworkLocator(const NetworkLocator& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3183 m_UL = m_Dict->ul(MDD_NetworkLocator);
3190 NetworkLocator::InitFromTLVSet(TLVReader& TLVSet)
3193 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3194 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(NetworkLocator, URLString));
3200 NetworkLocator::WriteToTLVSet(TLVWriter& TLVSet)
3203 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3204 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(NetworkLocator, URLString));
3210 NetworkLocator::Copy(const NetworkLocator& rhs)
3212 InterchangeObject::Copy(rhs);
3213 URLString = rhs.URLString;
3218 NetworkLocator::Dump(FILE* stream)
3220 char identbuf[IdentBufferLen];
3226 InterchangeObject::Dump(stream);
3227 fprintf(stream, " %22s = %s\n", "URLString", URLString.EncodeString(identbuf, IdentBufferLen));
3232 NetworkLocator::InitFromBuffer(const byte_t* p, ui32_t l)
3234 return InterchangeObject::InitFromBuffer(p, l);
3239 NetworkLocator::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3241 return InterchangeObject::WriteToBuffer(Buffer);
3244 //------------------------------------------------------------------------------------------
3245 // MCALabelSubDescriptor
3249 MCALabelSubDescriptor::MCALabelSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
3252 m_UL = m_Dict->ul(MDD_MCALabelSubDescriptor);
3255 MCALabelSubDescriptor::MCALabelSubDescriptor(const MCALabelSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3258 m_UL = m_Dict->ul(MDD_MCALabelSubDescriptor);
3265 MCALabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3268 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3269 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCALabelDictionaryID));
3270 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCALinkID));
3271 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCATagSymbol));
3272 if ( ASDCP_SUCCESS(result) ) {
3273 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCATagName));
3274 MCATagName.set_has_value( result == RESULT_OK );
3276 if ( ASDCP_SUCCESS(result) ) {
3277 result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCAChannelID));
3278 MCAChannelID.set_has_value( result == RESULT_OK );
3280 if ( ASDCP_SUCCESS(result) ) {
3281 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, RFC5646SpokenLanguage));
3282 RFC5646SpokenLanguage.set_has_value( result == RESULT_OK );
3284 if ( ASDCP_SUCCESS(result) ) {
3285 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCATitle));
3286 MCATitle.set_has_value( result == RESULT_OK );
3288 if ( ASDCP_SUCCESS(result) ) {
3289 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCATitleVersion));
3290 MCATitleVersion.set_has_value( result == RESULT_OK );
3292 if ( ASDCP_SUCCESS(result) ) {
3293 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCATitleSubVersion));
3294 MCATitleSubVersion.set_has_value( result == RESULT_OK );
3296 if ( ASDCP_SUCCESS(result) ) {
3297 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCAEpisode));
3298 MCAEpisode.set_has_value( result == RESULT_OK );
3300 if ( ASDCP_SUCCESS(result) ) {
3301 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCAPartitionKind));
3302 MCAPartitionKind.set_has_value( result == RESULT_OK );
3304 if ( ASDCP_SUCCESS(result) ) {
3305 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCAPartitionNumber));
3306 MCAPartitionNumber.set_has_value( result == RESULT_OK );
3308 if ( ASDCP_SUCCESS(result) ) {
3309 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCAAudioContentKind));
3310 MCAAudioContentKind.set_has_value( result == RESULT_OK );
3312 if ( ASDCP_SUCCESS(result) ) {
3313 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCAAudioElementKind));
3314 MCAAudioElementKind.set_has_value( result == RESULT_OK );
3321 MCALabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3324 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3325 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCALabelDictionaryID));
3326 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCALinkID));
3327 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCATagSymbol));
3328 if ( ASDCP_SUCCESS(result) && ! MCATagName.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCATagName));
3329 if ( ASDCP_SUCCESS(result) && ! MCAChannelID.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCAChannelID));
3330 if ( ASDCP_SUCCESS(result) && ! RFC5646SpokenLanguage.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, RFC5646SpokenLanguage));
3331 if ( ASDCP_SUCCESS(result) && ! MCATitle.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCATitle));
3332 if ( ASDCP_SUCCESS(result) && ! MCATitleVersion.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCATitleVersion));
3333 if ( ASDCP_SUCCESS(result) && ! MCATitleSubVersion.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCATitleSubVersion));
3334 if ( ASDCP_SUCCESS(result) && ! MCAEpisode.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCAEpisode));
3335 if ( ASDCP_SUCCESS(result) && ! MCAPartitionKind.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCAPartitionKind));
3336 if ( ASDCP_SUCCESS(result) && ! MCAPartitionNumber.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCAPartitionNumber));
3337 if ( ASDCP_SUCCESS(result) && ! MCAAudioContentKind.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCAAudioContentKind));
3338 if ( ASDCP_SUCCESS(result) && ! MCAAudioElementKind.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCAAudioElementKind));
3344 MCALabelSubDescriptor::Copy(const MCALabelSubDescriptor& rhs)
3346 InterchangeObject::Copy(rhs);
3347 MCALabelDictionaryID = rhs.MCALabelDictionaryID;
3348 MCALinkID = rhs.MCALinkID;
3349 MCATagSymbol = rhs.MCATagSymbol;
3350 MCATagName = rhs.MCATagName;
3351 MCAChannelID = rhs.MCAChannelID;
3352 RFC5646SpokenLanguage = rhs.RFC5646SpokenLanguage;
3353 MCATitle = rhs.MCATitle;
3354 MCATitleVersion = rhs.MCATitleVersion;
3355 MCATitleSubVersion = rhs.MCATitleSubVersion;
3356 MCAEpisode = rhs.MCAEpisode;
3357 MCAPartitionKind = rhs.MCAPartitionKind;
3358 MCAPartitionNumber = rhs.MCAPartitionNumber;
3359 MCAAudioContentKind = rhs.MCAAudioContentKind;
3360 MCAAudioElementKind = rhs.MCAAudioElementKind;
3365 MCALabelSubDescriptor::Dump(FILE* stream)
3367 char identbuf[IdentBufferLen];
3373 InterchangeObject::Dump(stream);
3374 fprintf(stream, " %22s = %s\n", "MCALabelDictionaryID", MCALabelDictionaryID.EncodeString(identbuf, IdentBufferLen));
3375 fprintf(stream, " %22s = %s\n", "MCALinkID", MCALinkID.EncodeString(identbuf, IdentBufferLen));
3376 fprintf(stream, " %22s = %s\n", "MCATagSymbol", MCATagSymbol.EncodeString(identbuf, IdentBufferLen));
3377 if ( ! MCATagName.empty() ) {
3378 fprintf(stream, " %22s = %s\n", "MCATagName", MCATagName.get().EncodeString(identbuf, IdentBufferLen));
3380 if ( ! MCAChannelID.empty() ) {
3381 fprintf(stream, " %22s = %d\n", "MCAChannelID", MCAChannelID.get());
3383 if ( ! RFC5646SpokenLanguage.empty() ) {
3384 fprintf(stream, " %22s = %s\n", "RFC5646SpokenLanguage", RFC5646SpokenLanguage.get().EncodeString(identbuf, IdentBufferLen));
3386 if ( ! MCATitle.empty() ) {
3387 fprintf(stream, " %22s = %s\n", "MCATitle", MCATitle.get().EncodeString(identbuf, IdentBufferLen));
3389 if ( ! MCATitleVersion.empty() ) {
3390 fprintf(stream, " %22s = %s\n", "MCATitleVersion", MCATitleVersion.get().EncodeString(identbuf, IdentBufferLen));
3392 if ( ! MCATitleSubVersion.empty() ) {
3393 fprintf(stream, " %22s = %s\n", "MCATitleSubVersion", MCATitleSubVersion.get().EncodeString(identbuf, IdentBufferLen));
3395 if ( ! MCAEpisode.empty() ) {
3396 fprintf(stream, " %22s = %s\n", "MCAEpisode", MCAEpisode.get().EncodeString(identbuf, IdentBufferLen));
3398 if ( ! MCAPartitionKind.empty() ) {
3399 fprintf(stream, " %22s = %s\n", "MCAPartitionKind", MCAPartitionKind.get().EncodeString(identbuf, IdentBufferLen));
3401 if ( ! MCAPartitionNumber.empty() ) {
3402 fprintf(stream, " %22s = %s\n", "MCAPartitionNumber", MCAPartitionNumber.get().EncodeString(identbuf, IdentBufferLen));
3404 if ( ! MCAAudioContentKind.empty() ) {
3405 fprintf(stream, " %22s = %s\n", "MCAAudioContentKind", MCAAudioContentKind.get().EncodeString(identbuf, IdentBufferLen));
3407 if ( ! MCAAudioElementKind.empty() ) {
3408 fprintf(stream, " %22s = %s\n", "MCAAudioElementKind", MCAAudioElementKind.get().EncodeString(identbuf, IdentBufferLen));
3414 MCALabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3416 return InterchangeObject::InitFromBuffer(p, l);
3421 MCALabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3423 return InterchangeObject::WriteToBuffer(Buffer);
3426 //------------------------------------------------------------------------------------------
3427 // AudioChannelLabelSubDescriptor
3431 AudioChannelLabelSubDescriptor::AudioChannelLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d)
3434 m_UL = m_Dict->ul(MDD_AudioChannelLabelSubDescriptor);
3437 AudioChannelLabelSubDescriptor::AudioChannelLabelSubDescriptor(const AudioChannelLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3440 m_UL = m_Dict->ul(MDD_AudioChannelLabelSubDescriptor);
3447 AudioChannelLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3450 Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet);
3451 if ( ASDCP_SUCCESS(result) ) {
3452 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(AudioChannelLabelSubDescriptor, SoundfieldGroupLinkID));
3453 SoundfieldGroupLinkID.set_has_value( result == RESULT_OK );
3460 AudioChannelLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3463 Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet);
3464 if ( ASDCP_SUCCESS(result) && ! SoundfieldGroupLinkID.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(AudioChannelLabelSubDescriptor, SoundfieldGroupLinkID));
3470 AudioChannelLabelSubDescriptor::Copy(const AudioChannelLabelSubDescriptor& rhs)
3472 MCALabelSubDescriptor::Copy(rhs);
3473 SoundfieldGroupLinkID = rhs.SoundfieldGroupLinkID;
3478 AudioChannelLabelSubDescriptor::Dump(FILE* stream)
3480 char identbuf[IdentBufferLen];
3486 MCALabelSubDescriptor::Dump(stream);
3487 if ( ! SoundfieldGroupLinkID.empty() ) {
3488 fprintf(stream, " %22s = %s\n", "SoundfieldGroupLinkID", SoundfieldGroupLinkID.get().EncodeString(identbuf, IdentBufferLen));
3494 AudioChannelLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3496 return InterchangeObject::InitFromBuffer(p, l);
3501 AudioChannelLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3503 return InterchangeObject::WriteToBuffer(Buffer);
3506 //------------------------------------------------------------------------------------------
3507 // SoundfieldGroupLabelSubDescriptor
3511 SoundfieldGroupLabelSubDescriptor::SoundfieldGroupLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d)
3514 m_UL = m_Dict->ul(MDD_SoundfieldGroupLabelSubDescriptor);
3517 SoundfieldGroupLabelSubDescriptor::SoundfieldGroupLabelSubDescriptor(const SoundfieldGroupLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3520 m_UL = m_Dict->ul(MDD_SoundfieldGroupLabelSubDescriptor);
3527 SoundfieldGroupLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3530 Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet);
3531 if ( ASDCP_SUCCESS(result) ) {
3532 result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(SoundfieldGroupLabelSubDescriptor, GroupOfSoundfieldGroupsLinkID));
3539 SoundfieldGroupLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3542 Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet);
3543 if ( ASDCP_SUCCESS(result) && ! GroupOfSoundfieldGroupsLinkID.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(SoundfieldGroupLabelSubDescriptor, GroupOfSoundfieldGroupsLinkID));
3549 SoundfieldGroupLabelSubDescriptor::Copy(const SoundfieldGroupLabelSubDescriptor& rhs)
3551 MCALabelSubDescriptor::Copy(rhs);
3552 GroupOfSoundfieldGroupsLinkID = rhs.GroupOfSoundfieldGroupsLinkID;
3557 SoundfieldGroupLabelSubDescriptor::Dump(FILE* stream)
3559 char identbuf[IdentBufferLen];
3565 MCALabelSubDescriptor::Dump(stream);
3566 if ( ! GroupOfSoundfieldGroupsLinkID.empty() ) {
3567 fprintf(stream, " %22s:\n", "GroupOfSoundfieldGroupsLinkID");
3568 GroupOfSoundfieldGroupsLinkID.get().Dump(stream);
3574 SoundfieldGroupLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3576 return InterchangeObject::InitFromBuffer(p, l);
3581 SoundfieldGroupLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3583 return InterchangeObject::WriteToBuffer(Buffer);
3586 //------------------------------------------------------------------------------------------
3587 // GroupOfSoundfieldGroupsLabelSubDescriptor
3591 GroupOfSoundfieldGroupsLabelSubDescriptor::GroupOfSoundfieldGroupsLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d)
3594 m_UL = m_Dict->ul(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor);
3597 GroupOfSoundfieldGroupsLabelSubDescriptor::GroupOfSoundfieldGroupsLabelSubDescriptor(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3600 m_UL = m_Dict->ul(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor);
3607 GroupOfSoundfieldGroupsLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3610 Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet);
3616 GroupOfSoundfieldGroupsLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3619 Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet);
3625 GroupOfSoundfieldGroupsLabelSubDescriptor::Copy(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs)
3627 MCALabelSubDescriptor::Copy(rhs);
3632 GroupOfSoundfieldGroupsLabelSubDescriptor::Dump(FILE* stream)
3634 char identbuf[IdentBufferLen];
3640 MCALabelSubDescriptor::Dump(stream);
3645 GroupOfSoundfieldGroupsLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3647 return InterchangeObject::InitFromBuffer(p, l);
3652 GroupOfSoundfieldGroupsLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3654 return InterchangeObject::WriteToBuffer(Buffer);
3657 //------------------------------------------------------------------------------------------
3662 DCDataDescriptor::DCDataDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d)
3665 m_UL = m_Dict->ul(MDD_DCDataDescriptor);
3668 DCDataDescriptor::DCDataDescriptor(const DCDataDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3671 m_UL = m_Dict->ul(MDD_DCDataDescriptor);
3678 DCDataDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3681 Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
3687 DCDataDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3690 Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
3696 DCDataDescriptor::Copy(const DCDataDescriptor& rhs)
3698 GenericDataEssenceDescriptor::Copy(rhs);
3703 DCDataDescriptor::Dump(FILE* stream)
3705 char identbuf[IdentBufferLen];
3711 GenericDataEssenceDescriptor::Dump(stream);
3716 DCDataDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3718 return InterchangeObject::InitFromBuffer(p, l);
3723 DCDataDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3725 return InterchangeObject::WriteToBuffer(Buffer);
3728 //------------------------------------------------------------------------------------------
3729 // PrivateDCDataDescriptor
3733 PrivateDCDataDescriptor::PrivateDCDataDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d)
3736 m_UL = m_Dict->ul(MDD_PrivateDCDataDescriptor);
3739 PrivateDCDataDescriptor::PrivateDCDataDescriptor(const PrivateDCDataDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3742 m_UL = m_Dict->ul(MDD_PrivateDCDataDescriptor);
3749 PrivateDCDataDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3752 Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
3758 PrivateDCDataDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3761 Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
3767 PrivateDCDataDescriptor::Copy(const PrivateDCDataDescriptor& rhs)
3769 GenericDataEssenceDescriptor::Copy(rhs);
3774 PrivateDCDataDescriptor::Dump(FILE* stream)
3776 char identbuf[IdentBufferLen];
3782 GenericDataEssenceDescriptor::Dump(stream);
3787 PrivateDCDataDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3789 return InterchangeObject::InitFromBuffer(p, l);
3794 PrivateDCDataDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3796 return InterchangeObject::WriteToBuffer(Buffer);
3799 //------------------------------------------------------------------------------------------
3800 // DolbyAtmosSubDescriptor
3804 DolbyAtmosSubDescriptor::DolbyAtmosSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), FirstFrame(0), MaxChannelCount(0), MaxObjectCount(0), AtmosVersion(0)
3807 m_UL = m_Dict->ul(MDD_DolbyAtmosSubDescriptor);
3810 DolbyAtmosSubDescriptor::DolbyAtmosSubDescriptor(const DolbyAtmosSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3813 m_UL = m_Dict->ul(MDD_DolbyAtmosSubDescriptor);
3820 DolbyAtmosSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3823 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3824 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, AtmosID));
3825 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, FirstFrame));
3826 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, MaxChannelCount));
3827 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, MaxObjectCount));
3828 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, AtmosVersion));
3834 DolbyAtmosSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3837 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3838 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, AtmosID));
3839 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, FirstFrame));
3840 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, MaxChannelCount));
3841 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, MaxObjectCount));
3842 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, AtmosVersion));
3848 DolbyAtmosSubDescriptor::Copy(const DolbyAtmosSubDescriptor& rhs)
3850 InterchangeObject::Copy(rhs);
3851 AtmosID = rhs.AtmosID;
3852 FirstFrame = rhs.FirstFrame;
3853 MaxChannelCount = rhs.MaxChannelCount;
3854 MaxObjectCount = rhs.MaxObjectCount;
3855 AtmosVersion = rhs.AtmosVersion;
3860 DolbyAtmosSubDescriptor::Dump(FILE* stream)
3862 char identbuf[IdentBufferLen];
3868 InterchangeObject::Dump(stream);
3869 fprintf(stream, " %22s = %s\n", "AtmosID", AtmosID.EncodeString(identbuf, IdentBufferLen));
3870 fprintf(stream, " %22s = %d\n", "FirstFrame", FirstFrame);
3871 fprintf(stream, " %22s = %d\n", "MaxChannelCount", MaxChannelCount);
3872 fprintf(stream, " %22s = %d\n", "MaxObjectCount", MaxObjectCount);
3873 fprintf(stream, " %22s = %d\n", "AtmosVersion", AtmosVersion);
3878 DolbyAtmosSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3880 return InterchangeObject::InitFromBuffer(p, l);
3885 DolbyAtmosSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3887 return InterchangeObject::WriteToBuffer(Buffer);
3890 //------------------------------------------------------------------------------------------
3891 // PHDRMetadataTrackSubDescriptor
3895 PHDRMetadataTrackSubDescriptor::PHDRMetadataTrackSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), SourceTrackID(0), SimplePayloadSID(0)
3898 m_UL = m_Dict->ul(MDD_PHDRMetadataTrackSubDescriptor);
3901 PHDRMetadataTrackSubDescriptor::PHDRMetadataTrackSubDescriptor(const PHDRMetadataTrackSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3904 m_UL = m_Dict->ul(MDD_PHDRMetadataTrackSubDescriptor);
3911 PHDRMetadataTrackSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3914 Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3915 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(PHDRMetadataTrackSubDescriptor, DataDefinition));
3916 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(PHDRMetadataTrackSubDescriptor, SourceTrackID));
3917 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(PHDRMetadataTrackSubDescriptor, SimplePayloadSID));
3923 PHDRMetadataTrackSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3926 Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3927 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(PHDRMetadataTrackSubDescriptor, DataDefinition));
3928 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(PHDRMetadataTrackSubDescriptor, SourceTrackID));
3929 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(PHDRMetadataTrackSubDescriptor, SimplePayloadSID));
3935 PHDRMetadataTrackSubDescriptor::Copy(const PHDRMetadataTrackSubDescriptor& rhs)
3937 InterchangeObject::Copy(rhs);
3938 DataDefinition = rhs.DataDefinition;
3939 SourceTrackID = rhs.SourceTrackID;
3940 SimplePayloadSID = rhs.SimplePayloadSID;
3945 PHDRMetadataTrackSubDescriptor::Dump(FILE* stream)
3947 char identbuf[IdentBufferLen];
3953 InterchangeObject::Dump(stream);
3954 fprintf(stream, " %22s = %s\n", "DataDefinition", DataDefinition.EncodeString(identbuf, IdentBufferLen));
3955 fprintf(stream, " %22s = %d\n", "SourceTrackID", SourceTrackID);
3956 fprintf(stream, " %22s = %d\n", "SimplePayloadSID", SimplePayloadSID);
3961 PHDRMetadataTrackSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3963 return InterchangeObject::InitFromBuffer(p, l);
3968 PHDRMetadataTrackSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3970 return InterchangeObject::WriteToBuffer(Buffer);
3973 //------------------------------------------------------------------------------------------
3974 // PIMFDynamicMetadataDescriptor
3978 PIMFDynamicMetadataDescriptor::PIMFDynamicMetadataDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d), GlobalPayloadSID(0)
3981 m_UL = m_Dict->ul(MDD_PIMFDynamicMetadataDescriptor);
3984 PIMFDynamicMetadataDescriptor::PIMFDynamicMetadataDescriptor(const PIMFDynamicMetadataDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3987 m_UL = m_Dict->ul(MDD_PIMFDynamicMetadataDescriptor);
3994 PIMFDynamicMetadataDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3997 Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
3998 if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(PIMFDynamicMetadataDescriptor, GlobalPayloadSID));
4004 PIMFDynamicMetadataDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
4007 Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
4008 if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(PIMFDynamicMetadataDescriptor, GlobalPayloadSID));
4014 PIMFDynamicMetadataDescriptor::Copy(const PIMFDynamicMetadataDescriptor& rhs)
4016 GenericDataEssenceDescriptor::Copy(rhs);
4017 GlobalPayloadSID = rhs.GlobalPayloadSID;
4022 PIMFDynamicMetadataDescriptor::Dump(FILE* stream)
4024 char identbuf[IdentBufferLen];
4030 GenericDataEssenceDescriptor::Dump(stream);
4031 fprintf(stream, " %22s = %d\n", "GlobalPayloadSID", GlobalPayloadSID);
4036 PIMFDynamicMetadataDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
4038 return InterchangeObject::InitFromBuffer(p, l);
4043 PIMFDynamicMetadataDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4045 return InterchangeObject::WriteToBuffer(Buffer);