src/Metadata.h

   1 /*
   2 Copyright (c) 2005-2012, John Hurst
   3 All rights reserved.
   4
   5 Redistribution and use in source and binary forms, with or without
   6 modification, are permitted provided that the following conditions
   7 are met:
   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.
  15
  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.
  26 */
  27 /*! \file    Metadata.h
  28     \version $Id$
  29     \brief   MXF metadata objects
  30 */
  31
  32 #ifndef _Metadata_H_
  33 #define _Metadata_H_
  34
  35 #include "MXF.h"
  36
  37 namespace ASDCP
  38 {
  39   namespace MXF
  40     {
  41       void Metadata_InitTypes(const Dictionary*& Dict);
  42
  43       //
  44
  45       //
  46       class Identification : public InterchangeObject
  47         {
  48           Identification();
  49
  50         public:
  51           const Dictionary*& m_Dict;
  52           UUID ThisGenerationUID;
  53           UTF16String CompanyName;
  54           UTF16String ProductName;
  55           VersionType ProductVersion;
  56           UTF16String VersionString;
  57           UUID ProductUID;
  58           Kumu::Timestamp ModificationDate;
  59           VersionType ToolkitVersion;
  60           optional_property<UTF16String> Platform;
  61
  62       Identification(const Dictionary*& d);
  63       Identification(const Identification& rhs);
  64       virtual ~Identification() {}
  65
  66       const Identification& operator=(const Identification& rhs) { Copy(rhs); return *this; }
  67       virtual void Copy(const Identification& rhs);
  68       virtual const char* HasName() { return "Identification"; }
  69       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
  70       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
  71       virtual void     Dump(FILE* = 0);
  72       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
  73       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
  74         };
  75
  76       //
  77       class ContentStorage : public InterchangeObject
  78         {
  79           ContentStorage();
  80
  81         public:
  82           const Dictionary*& m_Dict;
  83           Batch<UUID> Packages;
  84           Batch<UUID> EssenceContainerData;
  85
  86       ContentStorage(const Dictionary*& d);
  87       ContentStorage(const ContentStorage& rhs);
  88       virtual ~ContentStorage() {}
  89
  90       const ContentStorage& operator=(const ContentStorage& rhs) { Copy(rhs); return *this; }
  91       virtual void Copy(const ContentStorage& rhs);
  92       virtual const char* HasName() { return "ContentStorage"; }
  93       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
  94       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
  95       virtual void     Dump(FILE* = 0);
  96       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
  97       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
  98         };
  99
 100       //
 101       class EssenceContainerData : public InterchangeObject
 102         {
 103           EssenceContainerData();
 104
 105         public:
 106           const Dictionary*& m_Dict;
 107           UMID LinkedPackageUID;
 108           optional_property<ui32_t> IndexSID;
 109           ui32_t BodySID;
 110
 111       EssenceContainerData(const Dictionary*& d);
 112       EssenceContainerData(const EssenceContainerData& rhs);
 113       virtual ~EssenceContainerData() {}
 114
 115       const EssenceContainerData& operator=(const EssenceContainerData& rhs) { Copy(rhs); return *this; }
 116       virtual void Copy(const EssenceContainerData& rhs);
 117       virtual const char* HasName() { return "EssenceContainerData"; }
 118       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 119       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 120       virtual void     Dump(FILE* = 0);
 121       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 122       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 123         };
 124
 125       //
 126       class GenericPackage : public InterchangeObject
 127         {
 128           GenericPackage();
 129
 130         public:
 131           const Dictionary*& m_Dict;
 132           UMID PackageUID;
 133           optional_property<UTF16String> Name;
 134           Kumu::Timestamp PackageCreationDate;
 135           Kumu::Timestamp PackageModifiedDate;
 136           Batch<UUID> Tracks;
 137
 138       GenericPackage(const Dictionary*& d);
 139       GenericPackage(const GenericPackage& rhs);
 140       virtual ~GenericPackage() {}
 141
 142       const GenericPackage& operator=(const GenericPackage& rhs) { Copy(rhs); return *this; }
 143       virtual void Copy(const GenericPackage& rhs);
 144       virtual const char* HasName() { return "GenericPackage"; }
 145       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 146       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 147       virtual void     Dump(FILE* = 0);
 148         };
 149
 150       //
 151       class MaterialPackage : public GenericPackage
 152         {
 153           MaterialPackage();
 154
 155         public:
 156           const Dictionary*& m_Dict;
 157           optional_property<UUID> PackageMarker;
 158
 159       MaterialPackage(const Dictionary*& d);
 160       MaterialPackage(const MaterialPackage& rhs);
 161       virtual ~MaterialPackage() {}
 162
 163       const MaterialPackage& operator=(const MaterialPackage& rhs) { Copy(rhs); return *this; }
 164       virtual void Copy(const MaterialPackage& rhs);
 165       virtual const char* HasName() { return "MaterialPackage"; }
 166       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 167       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 168       virtual void     Dump(FILE* = 0);
 169       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 170       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 171         };
 172
 173       //
 174       class SourcePackage : public GenericPackage
 175         {
 176           SourcePackage();
 177
 178         public:
 179           const Dictionary*& m_Dict;
 180           UUID Descriptor;
 181
 182       SourcePackage(const Dictionary*& d);
 183       SourcePackage(const SourcePackage& rhs);
 184       virtual ~SourcePackage() {}
 185
 186       const SourcePackage& operator=(const SourcePackage& rhs) { Copy(rhs); return *this; }
 187       virtual void Copy(const SourcePackage& rhs);
 188       virtual const char* HasName() { return "SourcePackage"; }
 189       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 190       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 191       virtual void     Dump(FILE* = 0);
 192       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 193       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 194         };
 195
 196       //
 197       class GenericTrack : public InterchangeObject
 198         {
 199           GenericTrack();
 200
 201         public:
 202           const Dictionary*& m_Dict;
 203           ui32_t TrackID;
 204           ui32_t TrackNumber;
 205           optional_property<UTF16String> TrackName;
 206           optional_property<UUID> Sequence;
 207
 208       GenericTrack(const Dictionary*& d);
 209       GenericTrack(const GenericTrack& rhs);
 210       virtual ~GenericTrack() {}
 211
 212       const GenericTrack& operator=(const GenericTrack& rhs) { Copy(rhs); return *this; }
 213       virtual void Copy(const GenericTrack& rhs);
 214       virtual const char* HasName() { return "GenericTrack"; }
 215       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 216       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 217       virtual void     Dump(FILE* = 0);
 218         };
 219
 220       //
 221       class StaticTrack : public GenericTrack
 222         {
 223           StaticTrack();
 224
 225         public:
 226           const Dictionary*& m_Dict;
 227
 228       StaticTrack(const Dictionary*& d);
 229       StaticTrack(const StaticTrack& rhs);
 230       virtual ~StaticTrack() {}
 231
 232       const StaticTrack& operator=(const StaticTrack& rhs) { Copy(rhs); return *this; }
 233       virtual void Copy(const StaticTrack& rhs);
 234       virtual const char* HasName() { return "StaticTrack"; }
 235       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 236       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 237       virtual void     Dump(FILE* = 0);
 238       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 239       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 240         };
 241
 242       //
 243       class Track : public GenericTrack
 244         {
 245           Track();
 246
 247         public:
 248           const Dictionary*& m_Dict;
 249           Rational EditRate;
 250           ui64_t Origin;
 251
 252       Track(const Dictionary*& d);
 253       Track(const Track& rhs);
 254       virtual ~Track() {}
 255
 256       const Track& operator=(const Track& rhs) { Copy(rhs); return *this; }
 257       virtual void Copy(const Track& rhs);
 258       virtual const char* HasName() { return "Track"; }
 259       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 260       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 261       virtual void     Dump(FILE* = 0);
 262       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 263       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 264         };
 265
 266       //
 267       class StructuralComponent : public InterchangeObject
 268         {
 269           StructuralComponent();
 270
 271         public:
 272           const Dictionary*& m_Dict;
 273           UL DataDefinition;
 274           optional_property<ui64_t> Duration;
 275
 276       StructuralComponent(const Dictionary*& d);
 277       StructuralComponent(const StructuralComponent& rhs);
 278       virtual ~StructuralComponent() {}
 279
 280       const StructuralComponent& operator=(const StructuralComponent& rhs) { Copy(rhs); return *this; }
 281       virtual void Copy(const StructuralComponent& rhs);
 282       virtual const char* HasName() { return "StructuralComponent"; }
 283       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 284       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 285       virtual void     Dump(FILE* = 0);
 286         };
 287
 288       //
 289       class Sequence : public StructuralComponent
 290         {
 291           Sequence();
 292
 293         public:
 294           const Dictionary*& m_Dict;
 295           Batch<UUID> StructuralComponents;
 296
 297       Sequence(const Dictionary*& d);
 298       Sequence(const Sequence& rhs);
 299       virtual ~Sequence() {}
 300
 301       const Sequence& operator=(const Sequence& rhs) { Copy(rhs); return *this; }
 302       virtual void Copy(const Sequence& rhs);
 303       virtual const char* HasName() { return "Sequence"; }
 304       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 305       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 306       virtual void     Dump(FILE* = 0);
 307       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 308       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 309         };
 310
 311       //
 312       class SourceClip : public StructuralComponent
 313         {
 314           SourceClip();
 315
 316         public:
 317           const Dictionary*& m_Dict;
 318           ui64_t StartPosition;
 319           UMID SourcePackageID;
 320           ui32_t SourceTrackID;
 321
 322       SourceClip(const Dictionary*& d);
 323       SourceClip(const SourceClip& rhs);
 324       virtual ~SourceClip() {}
 325
 326       const SourceClip& operator=(const SourceClip& rhs) { Copy(rhs); return *this; }
 327       virtual void Copy(const SourceClip& rhs);
 328       virtual const char* HasName() { return "SourceClip"; }
 329       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 330       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 331       virtual void     Dump(FILE* = 0);
 332       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 333       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 334         };
 335
 336       //
 337       class TimecodeComponent : public StructuralComponent
 338         {
 339           TimecodeComponent();
 340
 341         public:
 342           const Dictionary*& m_Dict;
 343           ui16_t RoundedTimecodeBase;
 344           ui64_t StartTimecode;
 345           ui8_t DropFrame;
 346
 347       TimecodeComponent(const Dictionary*& d);
 348       TimecodeComponent(const TimecodeComponent& rhs);
 349       virtual ~TimecodeComponent() {}
 350
 351       const TimecodeComponent& operator=(const TimecodeComponent& rhs) { Copy(rhs); return *this; }
 352       virtual void Copy(const TimecodeComponent& rhs);
 353       virtual const char* HasName() { return "TimecodeComponent"; }
 354       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 355       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 356       virtual void     Dump(FILE* = 0);
 357       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 358       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 359         };
 360
 361       //
 362       class GenericDescriptor : public InterchangeObject
 363         {
 364           GenericDescriptor();
 365
 366         public:
 367           const Dictionary*& m_Dict;
 368           Batch<UUID> Locators;
 369           Batch<UUID> SubDescriptors;
 370
 371       GenericDescriptor(const Dictionary*& d);
 372       GenericDescriptor(const GenericDescriptor& rhs);
 373       virtual ~GenericDescriptor() {}
 374
 375       const GenericDescriptor& operator=(const GenericDescriptor& rhs) { Copy(rhs); return *this; }
 376       virtual void Copy(const GenericDescriptor& rhs);
 377       virtual const char* HasName() { return "GenericDescriptor"; }
 378       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 379       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 380       virtual void     Dump(FILE* = 0);
 381         };
 382
 383       //
 384       class FileDescriptor : public GenericDescriptor
 385         {
 386           FileDescriptor();
 387
 388         public:
 389           const Dictionary*& m_Dict;
 390           optional_property<ui32_t> LinkedTrackID;
 391           Rational SampleRate;
 392           optional_property<ui64_t> ContainerDuration;
 393           UL EssenceContainer;
 394           optional_property<UL> Codec;
 395
 396       FileDescriptor(const Dictionary*& d);
 397       FileDescriptor(const FileDescriptor& rhs);
 398       virtual ~FileDescriptor() {}
 399
 400       const FileDescriptor& operator=(const FileDescriptor& rhs) { Copy(rhs); return *this; }
 401       virtual void Copy(const FileDescriptor& rhs);
 402       virtual const char* HasName() { return "FileDescriptor"; }
 403       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 404       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 405       virtual void     Dump(FILE* = 0);
 406       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 407       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 408         };
 409
 410       //
 411       class GenericSoundEssenceDescriptor : public FileDescriptor
 412         {
 413           GenericSoundEssenceDescriptor();
 414
 415         public:
 416           const Dictionary*& m_Dict;
 417           Rational AudioSamplingRate;
 418           ui8_t Locked;
 419           optional_property<ui8_t> AudioRefLevel;
 420           optional_property<ui8_t> ElectroSpatialFormulation;
 421           ui32_t ChannelCount;
 422           ui32_t QuantizationBits;
 423           optional_property<ui8_t> DialNorm;
 424           UL SoundEssenceCoding;
 425
 426       GenericSoundEssenceDescriptor(const Dictionary*& d);
 427       GenericSoundEssenceDescriptor(const GenericSoundEssenceDescriptor& rhs);
 428       virtual ~GenericSoundEssenceDescriptor() {}
 429
 430       const GenericSoundEssenceDescriptor& operator=(const GenericSoundEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 431       virtual void Copy(const GenericSoundEssenceDescriptor& rhs);
 432       virtual const char* HasName() { return "GenericSoundEssenceDescriptor"; }
 433       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 434       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 435       virtual void     Dump(FILE* = 0);
 436       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 437       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 438         };
 439
 440       //
 441       class WaveAudioDescriptor : public GenericSoundEssenceDescriptor
 442         {
 443           WaveAudioDescriptor();
 444
 445         public:
 446           const Dictionary*& m_Dict;
 447           ui16_t BlockAlign;
 448           optional_property<ui8_t> SequenceOffset;
 449           ui32_t AvgBps;
 450           optional_property<UL> ChannelAssignment;
 451           optional_property<Rational> ReferenceImageEditRate;
 452           optional_property<ui8_t> ReferenceAudioAlignmentLevel;
 453
 454       WaveAudioDescriptor(const Dictionary*& d);
 455       WaveAudioDescriptor(const WaveAudioDescriptor& rhs);
 456       virtual ~WaveAudioDescriptor() {}
 457
 458       const WaveAudioDescriptor& operator=(const WaveAudioDescriptor& rhs) { Copy(rhs); return *this; }
 459       virtual void Copy(const WaveAudioDescriptor& rhs);
 460       virtual const char* HasName() { return "WaveAudioDescriptor"; }
 461       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 462       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 463       virtual void     Dump(FILE* = 0);
 464       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 465       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 466         };
 467
 468       //
 469       class GenericPictureEssenceDescriptor : public FileDescriptor
 470         {
 471           GenericPictureEssenceDescriptor();
 472
 473         public:
 474           const Dictionary*& m_Dict;
 475           optional_property<ui8_t> SignalStandard;
 476           ui8_t FrameLayout;
 477           ui32_t StoredWidth;
 478           ui32_t StoredHeight;
 479           optional_property<ui32_t> StoredF2Offset;
 480           optional_property<ui32_t> SampledWidth;
 481           optional_property<ui32_t> SampledHeight;
 482           optional_property<ui32_t> SampledXOffset;
 483           optional_property<ui32_t> SampledYOffset;
 484           optional_property<ui32_t> DisplayHeight;
 485           optional_property<ui32_t> DisplayWidth;
 486           optional_property<ui32_t> DisplayXOffset;
 487           optional_property<ui32_t> DisplayYOffset;
 488           optional_property<ui32_t> DisplayF2Offset;
 489           Rational AspectRatio;
 490           optional_property<ui8_t> ActiveFormatDescriptor;
 491           optional_property<ui8_t> AlphaTransparency;
 492           optional_property<UL> TransferCharacteristic;
 493           optional_property<ui32_t> ImageAlignmentOffset;
 494           optional_property<ui32_t> ImageStartOffset;
 495           optional_property<ui32_t> ImageEndOffset;
 496           optional_property<ui8_t> FieldDominance;
 497           UL PictureEssenceCoding;
 498           optional_property<UL> CodingEquations;
 499           optional_property<UL> ColorPrimaries;
 500           Batch<UL> AlternativeCenterCuts;
 501           optional_property<ui32_t> ActiveWidth;
 502           optional_property<ui32_t> ActiveHeight;
 503           optional_property<ui32_t> ActiveXOffset;
 504           optional_property<ui32_t> ActiveYOffset;
 505
 506       GenericPictureEssenceDescriptor(const Dictionary*& d);
 507       GenericPictureEssenceDescriptor(const GenericPictureEssenceDescriptor& rhs);
 508       virtual ~GenericPictureEssenceDescriptor() {}
 509
 510       const GenericPictureEssenceDescriptor& operator=(const GenericPictureEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 511       virtual void Copy(const GenericPictureEssenceDescriptor& rhs);
 512       virtual const char* HasName() { return "GenericPictureEssenceDescriptor"; }
 513       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 514       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 515       virtual void     Dump(FILE* = 0);
 516       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 517       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 518         };
 519
 520       //
 521       class RGBAEssenceDescriptor : public GenericPictureEssenceDescriptor
 522         {
 523           RGBAEssenceDescriptor();
 524
 525         public:
 526           const Dictionary*& m_Dict;
 527           optional_property<ui32_t> ComponentMaxRef;
 528           optional_property<ui32_t> ComponentMinRef;
 529           optional_property<ui32_t> AlphaMinRef;
 530           optional_property<ui32_t> AlphaMaxRef;
 531           optional_property<ui8_t> ScanningDirection;
 532
 533       RGBAEssenceDescriptor(const Dictionary*& d);
 534       RGBAEssenceDescriptor(const RGBAEssenceDescriptor& rhs);
 535       virtual ~RGBAEssenceDescriptor() {}
 536
 537       const RGBAEssenceDescriptor& operator=(const RGBAEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 538       virtual void Copy(const RGBAEssenceDescriptor& rhs);
 539       virtual const char* HasName() { return "RGBAEssenceDescriptor"; }
 540       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 541       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 542       virtual void     Dump(FILE* = 0);
 543       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 544       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 545         };
 546
 547       //
 548       class JPEG2000PictureSubDescriptor : public InterchangeObject
 549         {
 550           JPEG2000PictureSubDescriptor();
 551
 552         public:
 553           const Dictionary*& m_Dict;
 554           ui16_t Rsize;
 555           ui32_t Xsize;
 556           ui32_t Ysize;
 557           ui32_t XOsize;
 558           ui32_t YOsize;
 559           ui32_t XTsize;
 560           ui32_t YTsize;
 561           ui32_t XTOsize;
 562           ui32_t YTOsize;
 563           ui16_t Csize;
 564           optional_property<Raw> PictureComponentSizing;
 565           optional_property<Raw> CodingStyleDefault;
 566           optional_property<Raw> QuantizationDefault;
 567
 568       JPEG2000PictureSubDescriptor(const Dictionary*& d);
 569       JPEG2000PictureSubDescriptor(const JPEG2000PictureSubDescriptor& rhs);
 570       virtual ~JPEG2000PictureSubDescriptor() {}
 571
 572       const JPEG2000PictureSubDescriptor& operator=(const JPEG2000PictureSubDescriptor& rhs) { Copy(rhs); return *this; }
 573       virtual void Copy(const JPEG2000PictureSubDescriptor& rhs);
 574       virtual const char* HasName() { return "JPEG2000PictureSubDescriptor"; }
 575       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 576       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 577       virtual void     Dump(FILE* = 0);
 578       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 579       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 580         };
 581
 582       //
 583       class CDCIEssenceDescriptor : public GenericPictureEssenceDescriptor
 584         {
 585           CDCIEssenceDescriptor();
 586
 587         public:
 588           const Dictionary*& m_Dict;
 589           ui32_t ComponentDepth;
 590           ui32_t HorizontalSubsampling;
 591           optional_property<ui32_t> VerticalSubsampling;
 592           optional_property<ui8_t> ColorSiting;
 593           optional_property<ui8_t> ReversedByteOrder;
 594           optional_property<ui16_t> PaddingBits;
 595           optional_property<ui32_t> AlphaSampleDepth;
 596           optional_property<ui32_t> BlackRefLevel;
 597           optional_property<ui32_t> WhiteReflevel;
 598           optional_property<ui32_t> ColorRange;
 599
 600       CDCIEssenceDescriptor(const Dictionary*& d);
 601       CDCIEssenceDescriptor(const CDCIEssenceDescriptor& rhs);
 602       virtual ~CDCIEssenceDescriptor() {}
 603
 604       const CDCIEssenceDescriptor& operator=(const CDCIEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 605       virtual void Copy(const CDCIEssenceDescriptor& rhs);
 606       virtual const char* HasName() { return "CDCIEssenceDescriptor"; }
 607       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 608       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 609       virtual void     Dump(FILE* = 0);
 610       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 611       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 612         };
 613
 614       //
 615       class MPEG2VideoDescriptor : public CDCIEssenceDescriptor
 616         {
 617           MPEG2VideoDescriptor();
 618
 619         public:
 620           const Dictionary*& m_Dict;
 621           optional_property<ui8_t> SingleSequence;
 622           optional_property<ui8_t> ConstantBFrames;
 623           optional_property<ui8_t> CodedContentType;
 624           optional_property<ui8_t> LowDelay;
 625           optional_property<ui8_t> ClosedGOP;
 626           optional_property<ui8_t> IdenticalGOP;
 627           optional_property<ui8_t> MaxGOP;
 628           optional_property<ui8_t> BPictureCount;
 629           optional_property<ui32_t> BitRate;
 630           optional_property<ui8_t> ProfileAndLevel;
 631
 632       MPEG2VideoDescriptor(const Dictionary*& d);
 633       MPEG2VideoDescriptor(const MPEG2VideoDescriptor& rhs);
 634       virtual ~MPEG2VideoDescriptor() {}
 635
 636       const MPEG2VideoDescriptor& operator=(const MPEG2VideoDescriptor& rhs) { Copy(rhs); return *this; }
 637       virtual void Copy(const MPEG2VideoDescriptor& rhs);
 638       virtual const char* HasName() { return "MPEG2VideoDescriptor"; }
 639       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 640       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 641       virtual void     Dump(FILE* = 0);
 642       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 643       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 644         };
 645
 646       //
 647       class DMSegment : public InterchangeObject
 648         {
 649           DMSegment();
 650
 651         public:
 652           const Dictionary*& m_Dict;
 653           UL DataDefinition;
 654           ui64_t EventStartPosition;
 655           ui64_t Duration;
 656           UTF16String EventComment;
 657           UUID DMFramework;
 658
 659       DMSegment(const Dictionary*& d);
 660       DMSegment(const DMSegment& rhs);
 661       virtual ~DMSegment() {}
 662
 663       const DMSegment& operator=(const DMSegment& rhs) { Copy(rhs); return *this; }
 664       virtual void Copy(const DMSegment& rhs);
 665       virtual const char* HasName() { return "DMSegment"; }
 666       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 667       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 668       virtual void     Dump(FILE* = 0);
 669       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 670       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 671         };
 672
 673       //
 674       class CryptographicFramework : public InterchangeObject
 675         {
 676           CryptographicFramework();
 677
 678         public:
 679           const Dictionary*& m_Dict;
 680           UUID ContextSR;
 681
 682       CryptographicFramework(const Dictionary*& d);
 683       CryptographicFramework(const CryptographicFramework& rhs);
 684       virtual ~CryptographicFramework() {}
 685
 686       const CryptographicFramework& operator=(const CryptographicFramework& rhs) { Copy(rhs); return *this; }
 687       virtual void Copy(const CryptographicFramework& rhs);
 688       virtual const char* HasName() { return "CryptographicFramework"; }
 689       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 690       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 691       virtual void     Dump(FILE* = 0);
 692       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 693       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 694         };
 695
 696       //
 697       class CryptographicContext : public InterchangeObject
 698         {
 699           CryptographicContext();
 700
 701         public:
 702           const Dictionary*& m_Dict;
 703           UUID ContextID;
 704           UL SourceEssenceContainer;
 705           UL CipherAlgorithm;
 706           UL MICAlgorithm;
 707           UUID CryptographicKeyID;
 708
 709       CryptographicContext(const Dictionary*& d);
 710       CryptographicContext(const CryptographicContext& rhs);
 711       virtual ~CryptographicContext() {}
 712
 713       const CryptographicContext& operator=(const CryptographicContext& rhs) { Copy(rhs); return *this; }
 714       virtual void Copy(const CryptographicContext& rhs);
 715       virtual const char* HasName() { return "CryptographicContext"; }
 716       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 717       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 718       virtual void     Dump(FILE* = 0);
 719       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 720       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 721         };
 722
 723       //
 724       class GenericDataEssenceDescriptor : public FileDescriptor
 725         {
 726           GenericDataEssenceDescriptor();
 727
 728         public:
 729           const Dictionary*& m_Dict;
 730           UL DataEssenceCoding;
 731
 732       GenericDataEssenceDescriptor(const Dictionary*& d);
 733       GenericDataEssenceDescriptor(const GenericDataEssenceDescriptor& rhs);
 734       virtual ~GenericDataEssenceDescriptor() {}
 735
 736       const GenericDataEssenceDescriptor& operator=(const GenericDataEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 737       virtual void Copy(const GenericDataEssenceDescriptor& rhs);
 738       virtual const char* HasName() { return "GenericDataEssenceDescriptor"; }
 739       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 740       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 741       virtual void     Dump(FILE* = 0);
 742       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 743       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 744         };
 745
 746       //
 747       class TimedTextDescriptor : public GenericDataEssenceDescriptor
 748         {
 749           TimedTextDescriptor();
 750
 751         public:
 752           const Dictionary*& m_Dict;
 753           UUID ResourceID;
 754           UTF16String UCSEncoding;
 755           UTF16String NamespaceURI;
 756           optional_property<UTF16String> RFC5646LanguageTagList;
 757
 758       TimedTextDescriptor(const Dictionary*& d);
 759       TimedTextDescriptor(const TimedTextDescriptor& rhs);
 760       virtual ~TimedTextDescriptor() {}
 761
 762       const TimedTextDescriptor& operator=(const TimedTextDescriptor& rhs) { Copy(rhs); return *this; }
 763       virtual void Copy(const TimedTextDescriptor& rhs);
 764       virtual const char* HasName() { return "TimedTextDescriptor"; }
 765       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 766       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 767       virtual void     Dump(FILE* = 0);
 768       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 769       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 770         };
 771
 772       //
 773       class TimedTextResourceSubDescriptor : public InterchangeObject
 774         {
 775           TimedTextResourceSubDescriptor();
 776
 777         public:
 778           const Dictionary*& m_Dict;
 779           UUID AncillaryResourceID;
 780           UTF16String MIMEMediaType;
 781           ui32_t EssenceStreamID;
 782
 783       TimedTextResourceSubDescriptor(const Dictionary*& d);
 784       TimedTextResourceSubDescriptor(const TimedTextResourceSubDescriptor& rhs);
 785       virtual ~TimedTextResourceSubDescriptor() {}
 786
 787       const TimedTextResourceSubDescriptor& operator=(const TimedTextResourceSubDescriptor& rhs) { Copy(rhs); return *this; }
 788       virtual void Copy(const TimedTextResourceSubDescriptor& rhs);
 789       virtual const char* HasName() { return "TimedTextResourceSubDescriptor"; }
 790       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 791       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 792       virtual void     Dump(FILE* = 0);
 793       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 794       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 795         };
 796
 797       //
 798       class StereoscopicPictureSubDescriptor : public InterchangeObject
 799         {
 800           StereoscopicPictureSubDescriptor();
 801
 802         public:
 803           const Dictionary*& m_Dict;
 804
 805       StereoscopicPictureSubDescriptor(const Dictionary*& d);
 806       StereoscopicPictureSubDescriptor(const StereoscopicPictureSubDescriptor& rhs);
 807       virtual ~StereoscopicPictureSubDescriptor() {}
 808
 809       const StereoscopicPictureSubDescriptor& operator=(const StereoscopicPictureSubDescriptor& rhs) { Copy(rhs); return *this; }
 810       virtual void Copy(const StereoscopicPictureSubDescriptor& rhs);
 811       virtual const char* HasName() { return "StereoscopicPictureSubDescriptor"; }
 812       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 813       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 814       virtual void     Dump(FILE* = 0);
 815       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 816       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 817         };
 818
 819       //
 820       class NetworkLocator : public InterchangeObject
 821         {
 822           NetworkLocator();
 823
 824         public:
 825           const Dictionary*& m_Dict;
 826           UTF16String URLString;
 827
 828       NetworkLocator(const Dictionary*& d);
 829       NetworkLocator(const NetworkLocator& rhs);
 830       virtual ~NetworkLocator() {}
 831
 832       const NetworkLocator& operator=(const NetworkLocator& rhs) { Copy(rhs); return *this; }
 833       virtual void Copy(const NetworkLocator& rhs);
 834       virtual const char* HasName() { return "NetworkLocator"; }
 835       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 836       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 837       virtual void     Dump(FILE* = 0);
 838       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 839       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 840         };
 841
 842       //
 843       class MCALabelSubDescriptor : public InterchangeObject
 844         {
 845           MCALabelSubDescriptor();
 846
 847         public:
 848           const Dictionary*& m_Dict;
 849           UL MCALabelDictionaryID;
 850           UUID MCALinkID;
 851           UTF16String MCATagSymbol;
 852           optional_property<UTF16String> MCATagName;
 853           optional_property<ui32_t> MCAChannelID;
 854           optional_property<ISO8String> RFC5646SpokenLanguage;
 855
 856       MCALabelSubDescriptor(const Dictionary*& d);
 857       MCALabelSubDescriptor(const MCALabelSubDescriptor& rhs);
 858       virtual ~MCALabelSubDescriptor() {}
 859
 860       const MCALabelSubDescriptor& operator=(const MCALabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 861       virtual void Copy(const MCALabelSubDescriptor& rhs);
 862       virtual const char* HasName() { return "MCALabelSubDescriptor"; }
 863       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 864       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 865       virtual void     Dump(FILE* = 0);
 866       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 867       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 868         };
 869
 870       //
 871       class AudioChannelLabelSubDescriptor : public MCALabelSubDescriptor
 872         {
 873           AudioChannelLabelSubDescriptor();
 874
 875         public:
 876           const Dictionary*& m_Dict;
 877           UUID SoundfieldGroupLinkID;
 878
 879       AudioChannelLabelSubDescriptor(const Dictionary*& d);
 880       AudioChannelLabelSubDescriptor(const AudioChannelLabelSubDescriptor& rhs);
 881       virtual ~AudioChannelLabelSubDescriptor() {}
 882
 883       const AudioChannelLabelSubDescriptor& operator=(const AudioChannelLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 884       virtual void Copy(const AudioChannelLabelSubDescriptor& rhs);
 885       virtual const char* HasName() { return "AudioChannelLabelSubDescriptor"; }
 886       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 887       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 888       virtual void     Dump(FILE* = 0);
 889       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 890       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 891         };
 892
 893       //
 894       class SoundfieldGroupLabelSubDescriptor : public MCALabelSubDescriptor
 895         {
 896           SoundfieldGroupLabelSubDescriptor();
 897
 898         public:
 899           const Dictionary*& m_Dict;
 900           Array<UUID> GroupOfSoundfieldGroupsLinkID;
 901
 902       SoundfieldGroupLabelSubDescriptor(const Dictionary*& d);
 903       SoundfieldGroupLabelSubDescriptor(const SoundfieldGroupLabelSubDescriptor& rhs);
 904       virtual ~SoundfieldGroupLabelSubDescriptor() {}
 905
 906       const SoundfieldGroupLabelSubDescriptor& operator=(const SoundfieldGroupLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 907       virtual void Copy(const SoundfieldGroupLabelSubDescriptor& rhs);
 908       virtual const char* HasName() { return "SoundfieldGroupLabelSubDescriptor"; }
 909       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 910       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 911       virtual void     Dump(FILE* = 0);
 912       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 913       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 914         };
 915
 916       //
 917       class GroupOfSoundfieldGroupsLabelSubDescriptor : public MCALabelSubDescriptor
 918         {
 919           GroupOfSoundfieldGroupsLabelSubDescriptor();
 920
 921         public:
 922           const Dictionary*& m_Dict;
 923
 924       GroupOfSoundfieldGroupsLabelSubDescriptor(const Dictionary*& d);
 925       GroupOfSoundfieldGroupsLabelSubDescriptor(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs);
 926       virtual ~GroupOfSoundfieldGroupsLabelSubDescriptor() {}
 927
 928       const GroupOfSoundfieldGroupsLabelSubDescriptor& operator=(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 929       virtual void Copy(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs);
 930       virtual const char* HasName() { return "GroupOfSoundfieldGroupsLabelSubDescriptor"; }
 931       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 932       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 933       virtual void     Dump(FILE* = 0);
 934       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 935       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 936         };
 937
 938       //
 939       class DCDataDescriptor : public GenericDataEssenceDescriptor
 940         {
 941           DCDataDescriptor();
 942
 943         public:
 944           const Dictionary*& m_Dict;
 945
 946       DCDataDescriptor(const Dictionary*& d);
 947       DCDataDescriptor(const DCDataDescriptor& rhs);
 948       virtual ~DCDataDescriptor() {}
 949
 950       const DCDataDescriptor& operator=(const DCDataDescriptor& rhs) { Copy(rhs); return *this; }
 951       virtual void Copy(const DCDataDescriptor& rhs);
 952       virtual const char* HasName() { return "DCDataDescriptor"; }
 953       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 954       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 955       virtual void     Dump(FILE* = 0);
 956       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 957       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 958         };
 959
 960       //
 961       class DolbyAtmosSubDescriptor : public InterchangeObject
 962         {
 963           DolbyAtmosSubDescriptor();
 964
 965         public:
 966           const Dictionary*& m_Dict;
 967           UUID AtmosID;
 968           ui32_t FirstFrame;
 969           ui16_t MaxChannelCount;
 970           ui16_t MaxObjectCount;
 971           ui8_t AtmosVersion;
 972
 973       DolbyAtmosSubDescriptor(const Dictionary*& d);
 974       DolbyAtmosSubDescriptor(const DolbyAtmosSubDescriptor& rhs);
 975       virtual ~DolbyAtmosSubDescriptor() {}
 976
 977       const DolbyAtmosSubDescriptor& operator=(const DolbyAtmosSubDescriptor& rhs) { Copy(rhs); return *this; }
 978       virtual void Copy(const DolbyAtmosSubDescriptor& rhs);
 979       virtual const char* HasName() { return "DolbyAtmosSubDescriptor"; }
 980       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 981       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 982       virtual void     Dump(FILE* = 0);
 983       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 984       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 985         };
 986
 987     } // namespace MXF
 988 } // namespace ASDCP
 989
 990
 991 #endif // _Metadata_H_
 992
 993 //
 994 // end Metadata.h
 995 //