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           Timestamp ModificationDate;
  59           VersionType ToolkitVersion;
  60           UTF16String Platform;
  61
  62   Identification(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
  63   Identification(const Identification& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
  64           virtual ~Identification() {}
  65           const Identification& operator=(const Identification& rhs) { Copy(rhs); return *this; }
  66           virtual void Copy(const Identification& rhs);
  67           virtual const char* HasName() { return "Identification"; }
  68           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
  69           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
  70           virtual void     Dump(FILE* = 0);
  71           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
  72           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
  73         };
  74
  75       //
  76       class ContentStorage : public InterchangeObject
  77         {
  78           ContentStorage();
  79
  80         public:
  81           const Dictionary*& m_Dict;
  82           Batch<UUID> Packages;
  83           Batch<UUID> EssenceContainerData;
  84
  85   ContentStorage(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
  86   ContentStorage(const ContentStorage& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
  87           virtual ~ContentStorage() {}
  88           const ContentStorage& operator=(const ContentStorage& rhs) { Copy(rhs); return *this; }
  89           virtual void Copy(const ContentStorage& rhs);
  90           virtual const char* HasName() { return "ContentStorage"; }
  91           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
  92           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
  93           virtual void     Dump(FILE* = 0);
  94           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
  95           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
  96         };
  97
  98       //
  99       class EssenceContainerData : public InterchangeObject
 100         {
 101           EssenceContainerData();
 102
 103         public:
 104           const Dictionary*& m_Dict;
 105           UMID LinkedPackageUID;
 106           ui32_t IndexSID;
 107           ui32_t BodySID;
 108
 109   EssenceContainerData(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), IndexSID(0), BodySID(0) {}
 110   EssenceContainerData(const EssenceContainerData& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 111           virtual ~EssenceContainerData() {}
 112           const EssenceContainerData& operator=(const EssenceContainerData& rhs) { Copy(rhs); return *this; }
 113           virtual void Copy(const EssenceContainerData& rhs);
 114           virtual const char* HasName() { return "EssenceContainerData"; }
 115           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 116           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 117           virtual void     Dump(FILE* = 0);
 118           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 119           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 120         };
 121
 122       //
 123       class GenericPackage : public InterchangeObject
 124         {
 125           GenericPackage();
 126
 127         public:
 128           const Dictionary*& m_Dict;
 129           UMID PackageUID;
 130           UTF16String Name;
 131           Timestamp PackageCreationDate;
 132           Timestamp PackageModifiedDate;
 133           Batch<UUID> Tracks;
 134
 135   GenericPackage(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
 136   GenericPackage(const GenericPackage& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 137           virtual ~GenericPackage() {}
 138           const GenericPackage& operator=(const GenericPackage& rhs) { Copy(rhs); return *this; }
 139           virtual void Copy(const GenericPackage& rhs);
 140           virtual const char* HasName() { return "GenericPackage"; }
 141           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 142           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 143           virtual void     Dump(FILE* = 0);
 144         };
 145
 146       //
 147       class MaterialPackage : public GenericPackage
 148         {
 149           MaterialPackage();
 150
 151         public:
 152           const Dictionary*& m_Dict;
 153
 154   MaterialPackage(const Dictionary*& d) : GenericPackage(d), m_Dict(d) {}
 155   MaterialPackage(const MaterialPackage& rhs) : GenericPackage(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 156           virtual ~MaterialPackage() {}
 157           const MaterialPackage& operator=(const MaterialPackage& rhs) { Copy(rhs); return *this; }
 158           virtual void Copy(const MaterialPackage& rhs);
 159           virtual const char* HasName() { return "MaterialPackage"; }
 160           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 161           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 162           virtual void     Dump(FILE* = 0);
 163           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 164           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 165         };
 166
 167       //
 168       class SourcePackage : public GenericPackage
 169         {
 170           SourcePackage();
 171
 172         public:
 173           const Dictionary*& m_Dict;
 174           UUID Descriptor;
 175
 176   SourcePackage(const Dictionary*& d) : GenericPackage(d), m_Dict(d) {}
 177   SourcePackage(const SourcePackage& rhs) : GenericPackage(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 178           virtual ~SourcePackage() {}
 179           const SourcePackage& operator=(const SourcePackage& rhs) { Copy(rhs); return *this; }
 180           virtual void Copy(const SourcePackage& rhs);
 181           virtual const char* HasName() { return "SourcePackage"; }
 182           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 183           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 184           virtual void     Dump(FILE* = 0);
 185           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 186           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 187         };
 188
 189       //
 190       class GenericTrack : public InterchangeObject
 191         {
 192           GenericTrack();
 193
 194         public:
 195           const Dictionary*& m_Dict;
 196           ui32_t TrackID;
 197           ui32_t TrackNumber;
 198           UTF16String TrackName;
 199           UUID Sequence;
 200
 201   GenericTrack(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), TrackID(0), TrackNumber(0) {}
 202   GenericTrack(const GenericTrack& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 203           virtual ~GenericTrack() {}
 204           const GenericTrack& operator=(const GenericTrack& rhs) { Copy(rhs); return *this; }
 205           virtual void Copy(const GenericTrack& rhs);
 206           virtual const char* HasName() { return "GenericTrack"; }
 207           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 208           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 209           virtual void     Dump(FILE* = 0);
 210         };
 211
 212       //
 213       class StaticTrack : public GenericTrack
 214         {
 215           StaticTrack();
 216
 217         public:
 218           const Dictionary*& m_Dict;
 219
 220   StaticTrack(const Dictionary*& d) : GenericTrack(d), m_Dict(d) {}
 221   StaticTrack(const StaticTrack& rhs) : GenericTrack(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 222           virtual ~StaticTrack() {}
 223           const StaticTrack& operator=(const StaticTrack& rhs) { Copy(rhs); return *this; }
 224           virtual void Copy(const StaticTrack& rhs);
 225           virtual const char* HasName() { return "StaticTrack"; }
 226           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 227           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 228           virtual void     Dump(FILE* = 0);
 229           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 230           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 231         };
 232
 233       //
 234       class Track : public GenericTrack
 235         {
 236           Track();
 237
 238         public:
 239           const Dictionary*& m_Dict;
 240           Rational EditRate;
 241           ui64_t Origin;
 242
 243   Track(const Dictionary*& d) : GenericTrack(d), m_Dict(d), Origin(0) {}
 244   Track(const Track& rhs) : GenericTrack(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 245           virtual ~Track() {}
 246           const Track& operator=(const Track& rhs) { Copy(rhs); return *this; }
 247           virtual void Copy(const Track& rhs);
 248           virtual const char* HasName() { return "Track"; }
 249           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 250           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 251           virtual void     Dump(FILE* = 0);
 252           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 253           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 254         };
 255
 256       //
 257       class StructuralComponent : public InterchangeObject
 258         {
 259           StructuralComponent();
 260
 261         public:
 262           const Dictionary*& m_Dict;
 263           UL DataDefinition;
 264           ui64_t Duration;
 265
 266   StructuralComponent(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), Duration(0) {}
 267   StructuralComponent(const StructuralComponent& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 268           virtual ~StructuralComponent() {}
 269           const StructuralComponent& operator=(const StructuralComponent& rhs) { Copy(rhs); return *this; }
 270           virtual void Copy(const StructuralComponent& rhs);
 271           virtual const char* HasName() { return "StructuralComponent"; }
 272           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 273           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 274           virtual void     Dump(FILE* = 0);
 275         };
 276
 277       //
 278       class Sequence : public StructuralComponent
 279         {
 280           Sequence();
 281
 282         public:
 283           const Dictionary*& m_Dict;
 284           Batch<UUID> StructuralComponents;
 285
 286   Sequence(const Dictionary*& d) : StructuralComponent(d), m_Dict(d) {}
 287   Sequence(const Sequence& rhs) : StructuralComponent(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 288           virtual ~Sequence() {}
 289           const Sequence& operator=(const Sequence& rhs) { Copy(rhs); return *this; }
 290           virtual void Copy(const Sequence& rhs);
 291           virtual const char* HasName() { return "Sequence"; }
 292           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 293           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 294           virtual void     Dump(FILE* = 0);
 295           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 296           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 297         };
 298
 299       //
 300       class SourceClip : public StructuralComponent
 301         {
 302           SourceClip();
 303
 304         public:
 305           const Dictionary*& m_Dict;
 306           ui64_t StartPosition;
 307           UMID SourcePackageID;
 308           ui32_t SourceTrackID;
 309
 310   SourceClip(const Dictionary*& d) : StructuralComponent(d), m_Dict(d), StartPosition(0), SourceTrackID(0) {}
 311   SourceClip(const SourceClip& rhs) : StructuralComponent(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 312           virtual ~SourceClip() {}
 313           const SourceClip& operator=(const SourceClip& rhs) { Copy(rhs); return *this; }
 314           virtual void Copy(const SourceClip& rhs);
 315           virtual const char* HasName() { return "SourceClip"; }
 316           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 317           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 318           virtual void     Dump(FILE* = 0);
 319           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 320           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 321         };
 322
 323       //
 324       class TimecodeComponent : public StructuralComponent
 325         {
 326           TimecodeComponent();
 327
 328         public:
 329           const Dictionary*& m_Dict;
 330           ui16_t RoundedTimecodeBase;
 331           ui64_t StartTimecode;
 332           ui8_t DropFrame;
 333
 334   TimecodeComponent(const Dictionary*& d) : StructuralComponent(d), m_Dict(d), RoundedTimecodeBase(0), StartTimecode(0), DropFrame(0) {}
 335   TimecodeComponent(const TimecodeComponent& rhs) : StructuralComponent(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 336           virtual ~TimecodeComponent() {}
 337           const TimecodeComponent& operator=(const TimecodeComponent& rhs) { Copy(rhs); return *this; }
 338           virtual void Copy(const TimecodeComponent& rhs);
 339           virtual const char* HasName() { return "TimecodeComponent"; }
 340           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 341           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 342           virtual void     Dump(FILE* = 0);
 343           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 344           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 345         };
 346
 347       //
 348       class GenericDescriptor : public InterchangeObject
 349         {
 350           GenericDescriptor();
 351
 352         public:
 353           const Dictionary*& m_Dict;
 354           Batch<UUID> Locators;
 355           Batch<UUID> SubDescriptors;
 356
 357   GenericDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
 358   GenericDescriptor(const GenericDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 359           virtual ~GenericDescriptor() {}
 360           const GenericDescriptor& operator=(const GenericDescriptor& rhs) { Copy(rhs); return *this; }
 361           virtual void Copy(const GenericDescriptor& rhs);
 362           virtual const char* HasName() { return "GenericDescriptor"; }
 363           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 364           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 365           virtual void     Dump(FILE* = 0);
 366         };
 367
 368       //
 369       class FileDescriptor : public GenericDescriptor
 370         {
 371           FileDescriptor();
 372
 373         public:
 374           const Dictionary*& m_Dict;
 375           ui32_t LinkedTrackID;
 376           Rational SampleRate;
 377           ui64_t ContainerDuration;
 378           UL EssenceContainer;
 379           UL Codec;
 380
 381   FileDescriptor(const Dictionary*& d) : GenericDescriptor(d), m_Dict(d), LinkedTrackID(0), ContainerDuration(0) {}
 382   FileDescriptor(const FileDescriptor& rhs) : GenericDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 383           virtual ~FileDescriptor() {}
 384           const FileDescriptor& operator=(const FileDescriptor& rhs) { Copy(rhs); return *this; }
 385           virtual void Copy(const FileDescriptor& rhs);
 386           virtual const char* HasName() { return "FileDescriptor"; }
 387           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 388           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 389           virtual void     Dump(FILE* = 0);
 390           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 391           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 392         };
 393
 394       //
 395       class GenericSoundEssenceDescriptor : public FileDescriptor
 396         {
 397           GenericSoundEssenceDescriptor();
 398
 399         public:
 400           const Dictionary*& m_Dict;
 401           Rational AudioSamplingRate;
 402           ui8_t Locked;
 403           ui8_t AudioRefLevel;
 404           ui32_t ChannelCount;
 405           ui32_t QuantizationBits;
 406           ui8_t DialNorm;
 407
 408   GenericSoundEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d), Locked(0), AudioRefLevel(0), ChannelCount(0), QuantizationBits(0), DialNorm(0) {}
 409   GenericSoundEssenceDescriptor(const GenericSoundEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 410           virtual ~GenericSoundEssenceDescriptor() {}
 411           const GenericSoundEssenceDescriptor& operator=(const GenericSoundEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 412           virtual void Copy(const GenericSoundEssenceDescriptor& rhs);
 413           virtual const char* HasName() { return "GenericSoundEssenceDescriptor"; }
 414           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 415           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 416           virtual void     Dump(FILE* = 0);
 417           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 418           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 419         };
 420
 421       //
 422       class WaveAudioDescriptor : public GenericSoundEssenceDescriptor
 423         {
 424           WaveAudioDescriptor();
 425
 426         public:
 427           const Dictionary*& m_Dict;
 428           ui16_t BlockAlign;
 429           ui8_t SequenceOffset;
 430           ui32_t AvgBps;
 431           UL ChannelAssignment;
 432
 433   WaveAudioDescriptor(const Dictionary*& d) : GenericSoundEssenceDescriptor(d), m_Dict(d), BlockAlign(0), SequenceOffset(0), AvgBps(0) {}
 434   WaveAudioDescriptor(const WaveAudioDescriptor& rhs) : GenericSoundEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 435           virtual ~WaveAudioDescriptor() {}
 436           const WaveAudioDescriptor& operator=(const WaveAudioDescriptor& rhs) { Copy(rhs); return *this; }
 437           virtual void Copy(const WaveAudioDescriptor& rhs);
 438           virtual const char* HasName() { return "WaveAudioDescriptor"; }
 439           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 440           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 441           virtual void     Dump(FILE* = 0);
 442           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 443           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 444         };
 445
 446       //
 447       class GenericPictureEssenceDescriptor : public FileDescriptor
 448         {
 449           GenericPictureEssenceDescriptor();
 450
 451         public:
 452           const Dictionary*& m_Dict;
 453           ui8_t FrameLayout;
 454           ui32_t StoredWidth;
 455           ui32_t StoredHeight;
 456           Rational AspectRatio;
 457           UL PictureEssenceCoding;
 458
 459   GenericPictureEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d), FrameLayout(0), StoredWidth(0), StoredHeight(0) {}
 460   GenericPictureEssenceDescriptor(const GenericPictureEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 461           virtual ~GenericPictureEssenceDescriptor() {}
 462           const GenericPictureEssenceDescriptor& operator=(const GenericPictureEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 463           virtual void Copy(const GenericPictureEssenceDescriptor& rhs);
 464           virtual const char* HasName() { return "GenericPictureEssenceDescriptor"; }
 465           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 466           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 467           virtual void     Dump(FILE* = 0);
 468           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 469           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 470         };
 471
 472       //
 473       class RGBAEssenceDescriptor : public GenericPictureEssenceDescriptor
 474         {
 475           RGBAEssenceDescriptor();
 476
 477         public:
 478           const Dictionary*& m_Dict;
 479           ui32_t ComponentMaxRef;
 480           ui32_t ComponentMinRef;
 481
 482   RGBAEssenceDescriptor(const Dictionary*& d) : GenericPictureEssenceDescriptor(d), m_Dict(d), ComponentMaxRef(0), ComponentMinRef(0) {}
 483   RGBAEssenceDescriptor(const RGBAEssenceDescriptor& rhs) : GenericPictureEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 484           virtual ~RGBAEssenceDescriptor() {}
 485           const RGBAEssenceDescriptor& operator=(const RGBAEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 486           virtual void Copy(const RGBAEssenceDescriptor& rhs);
 487           virtual const char* HasName() { return "RGBAEssenceDescriptor"; }
 488           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 489           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 490           virtual void     Dump(FILE* = 0);
 491           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 492           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 493         };
 494
 495       //
 496       class JPEG2000PictureSubDescriptor : public InterchangeObject
 497         {
 498           JPEG2000PictureSubDescriptor();
 499
 500         public:
 501           const Dictionary*& m_Dict;
 502           ui16_t Rsize;
 503           ui32_t Xsize;
 504           ui32_t Ysize;
 505           ui32_t XOsize;
 506           ui32_t YOsize;
 507           ui32_t XTsize;
 508           ui32_t YTsize;
 509           ui32_t XTOsize;
 510           ui32_t YTOsize;
 511           ui16_t Csize;
 512           Raw PictureComponentSizing;
 513           Raw CodingStyleDefault;
 514           Raw QuantizationDefault;
 515
 516   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) {}
 517   JPEG2000PictureSubDescriptor(const JPEG2000PictureSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 518           virtual ~JPEG2000PictureSubDescriptor() {}
 519           const JPEG2000PictureSubDescriptor& operator=(const JPEG2000PictureSubDescriptor& rhs) { Copy(rhs); return *this; }
 520           virtual void Copy(const JPEG2000PictureSubDescriptor& rhs);
 521           virtual const char* HasName() { return "JPEG2000PictureSubDescriptor"; }
 522           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 523           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 524           virtual void     Dump(FILE* = 0);
 525           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 526           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 527         };
 528
 529       //
 530       class CDCIEssenceDescriptor : public GenericPictureEssenceDescriptor
 531         {
 532           CDCIEssenceDescriptor();
 533
 534         public:
 535           const Dictionary*& m_Dict;
 536           ui32_t ComponentDepth;
 537           ui32_t HorizontalSubsampling;
 538           ui32_t VerticalSubsampling;
 539           ui8_t ColorSiting;
 540
 541   CDCIEssenceDescriptor(const Dictionary*& d) : GenericPictureEssenceDescriptor(d), m_Dict(d), ComponentDepth(0), HorizontalSubsampling(0), VerticalSubsampling(0), ColorSiting(0) {}
 542   CDCIEssenceDescriptor(const CDCIEssenceDescriptor& rhs) : GenericPictureEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 543           virtual ~CDCIEssenceDescriptor() {}
 544           const CDCIEssenceDescriptor& operator=(const CDCIEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 545           virtual void Copy(const CDCIEssenceDescriptor& rhs);
 546           virtual const char* HasName() { return "CDCIEssenceDescriptor"; }
 547           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 548           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 549           virtual void     Dump(FILE* = 0);
 550           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 551           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 552         };
 553
 554       //
 555       class MPEG2VideoDescriptor : public CDCIEssenceDescriptor
 556         {
 557           MPEG2VideoDescriptor();
 558
 559         public:
 560           const Dictionary*& m_Dict;
 561           ui8_t CodedContentType;
 562           ui8_t LowDelay;
 563           ui32_t BitRate;
 564           ui8_t ProfileAndLevel;
 565
 566   MPEG2VideoDescriptor(const Dictionary*& d) : CDCIEssenceDescriptor(d), m_Dict(d), CodedContentType(0), LowDelay(0), BitRate(0), ProfileAndLevel(0) {}
 567   MPEG2VideoDescriptor(const MPEG2VideoDescriptor& rhs) : CDCIEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 568           virtual ~MPEG2VideoDescriptor() {}
 569           const MPEG2VideoDescriptor& operator=(const MPEG2VideoDescriptor& rhs) { Copy(rhs); return *this; }
 570           virtual void Copy(const MPEG2VideoDescriptor& rhs);
 571           virtual const char* HasName() { return "MPEG2VideoDescriptor"; }
 572           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 573           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 574           virtual void     Dump(FILE* = 0);
 575           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 576           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 577         };
 578
 579       //
 580       class DMSegment : public InterchangeObject
 581         {
 582           DMSegment();
 583
 584         public:
 585           const Dictionary*& m_Dict;
 586           UL DataDefinition;
 587           ui64_t EventStartPosition;
 588           ui64_t Duration;
 589           UTF16String EventComment;
 590           UUID DMFramework;
 591
 592   DMSegment(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), EventStartPosition(0), Duration(0) {}
 593   DMSegment(const DMSegment& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 594           virtual ~DMSegment() {}
 595           const DMSegment& operator=(const DMSegment& rhs) { Copy(rhs); return *this; }
 596           virtual void Copy(const DMSegment& rhs);
 597           virtual const char* HasName() { return "DMSegment"; }
 598           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 599           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 600           virtual void     Dump(FILE* = 0);
 601           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 602           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 603         };
 604
 605       //
 606       class CryptographicFramework : public InterchangeObject
 607         {
 608           CryptographicFramework();
 609
 610         public:
 611           const Dictionary*& m_Dict;
 612           UUID ContextSR;
 613
 614   CryptographicFramework(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
 615   CryptographicFramework(const CryptographicFramework& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 616           virtual ~CryptographicFramework() {}
 617           const CryptographicFramework& operator=(const CryptographicFramework& rhs) { Copy(rhs); return *this; }
 618           virtual void Copy(const CryptographicFramework& rhs);
 619           virtual const char* HasName() { return "CryptographicFramework"; }
 620           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 621           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 622           virtual void     Dump(FILE* = 0);
 623           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 624           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 625         };
 626
 627       //
 628       class CryptographicContext : public InterchangeObject
 629         {
 630           CryptographicContext();
 631
 632         public:
 633           const Dictionary*& m_Dict;
 634           UUID ContextID;
 635           UL SourceEssenceContainer;
 636           UL CipherAlgorithm;
 637           UL MICAlgorithm;
 638           UUID CryptographicKeyID;
 639
 640   CryptographicContext(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
 641   CryptographicContext(const CryptographicContext& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 642           virtual ~CryptographicContext() {}
 643           const CryptographicContext& operator=(const CryptographicContext& rhs) { Copy(rhs); return *this; }
 644           virtual void Copy(const CryptographicContext& rhs);
 645           virtual const char* HasName() { return "CryptographicContext"; }
 646           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 647           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 648           virtual void     Dump(FILE* = 0);
 649           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 650           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 651         };
 652
 653       //
 654       class GenericDataEssenceDescriptor : public FileDescriptor
 655         {
 656           GenericDataEssenceDescriptor();
 657
 658         public:
 659           const Dictionary*& m_Dict;
 660           UL DataEssenceCoding;
 661
 662   GenericDataEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d) {}
 663   GenericDataEssenceDescriptor(const GenericDataEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 664           virtual ~GenericDataEssenceDescriptor() {}
 665           const GenericDataEssenceDescriptor& operator=(const GenericDataEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 666           virtual void Copy(const GenericDataEssenceDescriptor& rhs);
 667           virtual const char* HasName() { return "GenericDataEssenceDescriptor"; }
 668           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 669           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 670           virtual void     Dump(FILE* = 0);
 671           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 672           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 673         };
 674
 675       //
 676       class TimedTextDescriptor : public GenericDataEssenceDescriptor
 677         {
 678           TimedTextDescriptor();
 679
 680         public:
 681           const Dictionary*& m_Dict;
 682           UUID ResourceID;
 683           UTF16String UCSEncoding;
 684           UTF16String NamespaceURI;
 685
 686   TimedTextDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d) {}
 687   TimedTextDescriptor(const TimedTextDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 688           virtual ~TimedTextDescriptor() {}
 689           const TimedTextDescriptor& operator=(const TimedTextDescriptor& rhs) { Copy(rhs); return *this; }
 690           virtual void Copy(const TimedTextDescriptor& rhs);
 691           virtual const char* HasName() { return "TimedTextDescriptor"; }
 692           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 693           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 694           virtual void     Dump(FILE* = 0);
 695           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 696           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 697         };
 698
 699       //
 700       class TimedTextResourceSubDescriptor : public InterchangeObject
 701         {
 702           TimedTextResourceSubDescriptor();
 703
 704         public:
 705           const Dictionary*& m_Dict;
 706           UUID AncillaryResourceID;
 707           UTF16String MIMEMediaType;
 708           ui32_t EssenceStreamID;
 709
 710   TimedTextResourceSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), EssenceStreamID(0) {}
 711   TimedTextResourceSubDescriptor(const TimedTextResourceSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 712           virtual ~TimedTextResourceSubDescriptor() {}
 713           const TimedTextResourceSubDescriptor& operator=(const TimedTextResourceSubDescriptor& rhs) { Copy(rhs); return *this; }
 714           virtual void Copy(const TimedTextResourceSubDescriptor& rhs);
 715           virtual const char* HasName() { return "TimedTextResourceSubDescriptor"; }
 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 StereoscopicPictureSubDescriptor : public InterchangeObject
 725         {
 726           StereoscopicPictureSubDescriptor();
 727
 728         public:
 729           const Dictionary*& m_Dict;
 730
 731   StereoscopicPictureSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
 732   StereoscopicPictureSubDescriptor(const StereoscopicPictureSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 733           virtual ~StereoscopicPictureSubDescriptor() {}
 734           const StereoscopicPictureSubDescriptor& operator=(const StereoscopicPictureSubDescriptor& rhs) { Copy(rhs); return *this; }
 735           virtual void Copy(const StereoscopicPictureSubDescriptor& rhs);
 736           virtual const char* HasName() { return "StereoscopicPictureSubDescriptor"; }
 737           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 738           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 739           virtual void     Dump(FILE* = 0);
 740           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 741           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 742         };
 743
 744       //
 745       class NetworkLocator : public InterchangeObject
 746         {
 747           NetworkLocator();
 748
 749         public:
 750           const Dictionary*& m_Dict;
 751           UTF16String URLString;
 752
 753   NetworkLocator(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
 754   NetworkLocator(const NetworkLocator& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 755           virtual ~NetworkLocator() {}
 756           const NetworkLocator& operator=(const NetworkLocator& rhs) { Copy(rhs); return *this; }
 757           virtual void Copy(const NetworkLocator& rhs);
 758           virtual const char* HasName() { return "NetworkLocator"; }
 759           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 760           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 761           virtual void     Dump(FILE* = 0);
 762           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 763           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 764         };
 765
 766       //
 767       class MCALabelSubDescriptor : public InterchangeObject
 768         {
 769           MCALabelSubDescriptor();
 770
 771         public:
 772           const Dictionary*& m_Dict;
 773           UL MCALabelDictionaryID;
 774           UUID MCALinkID;
 775           UTF16String MCATagSymbol;
 776           UTF16String MCATagName;
 777           ui32_t MCAChannelID;
 778           ISO8String RFC5646SpokenLanguage;
 779
 780   MCALabelSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), MCAChannelID(0) {}
 781   MCALabelSubDescriptor(const MCALabelSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 782           virtual ~MCALabelSubDescriptor() {}
 783           const MCALabelSubDescriptor& operator=(const MCALabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 784           virtual void Copy(const MCALabelSubDescriptor& rhs);
 785           virtual const char* HasName() { return "MCALabelSubDescriptor"; }
 786           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 787           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 788           virtual void     Dump(FILE* = 0);
 789           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 790           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 791         };
 792
 793       //
 794       class AudioChannelLabelSubDescriptor : public MCALabelSubDescriptor
 795         {
 796           AudioChannelLabelSubDescriptor();
 797
 798         public:
 799           const Dictionary*& m_Dict;
 800           UUID SoundfieldGroupLinkID;
 801
 802   AudioChannelLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d) {}
 803   AudioChannelLabelSubDescriptor(const AudioChannelLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 804           virtual ~AudioChannelLabelSubDescriptor() {}
 805           const AudioChannelLabelSubDescriptor& operator=(const AudioChannelLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 806           virtual void Copy(const AudioChannelLabelSubDescriptor& rhs);
 807           virtual const char* HasName() { return "AudioChannelLabelSubDescriptor"; }
 808           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 809           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 810           virtual void     Dump(FILE* = 0);
 811           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 812           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 813         };
 814
 815       //
 816       class SoundfieldGroupLabelSubDescriptor : public MCALabelSubDescriptor
 817         {
 818           SoundfieldGroupLabelSubDescriptor();
 819
 820         public:
 821           const Dictionary*& m_Dict;
 822           Array<UUID> GroupOfSoundfieldGroupsLinkID;
 823
 824   SoundfieldGroupLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d) {}
 825   SoundfieldGroupLabelSubDescriptor(const SoundfieldGroupLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 826           virtual ~SoundfieldGroupLabelSubDescriptor() {}
 827           const SoundfieldGroupLabelSubDescriptor& operator=(const SoundfieldGroupLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 828           virtual void Copy(const SoundfieldGroupLabelSubDescriptor& rhs);
 829           virtual const char* HasName() { return "SoundfieldGroupLabelSubDescriptor"; }
 830           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 831           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 832           virtual void     Dump(FILE* = 0);
 833           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 834           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 835         };
 836
 837       //
 838       class GroupOfSoundfieldGroupsLabelSubDescriptor : public MCALabelSubDescriptor
 839         {
 840           GroupOfSoundfieldGroupsLabelSubDescriptor();
 841
 842         public:
 843           const Dictionary*& m_Dict;
 844
 845   GroupOfSoundfieldGroupsLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d) {}
 846   GroupOfSoundfieldGroupsLabelSubDescriptor(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); }
 847           virtual ~GroupOfSoundfieldGroupsLabelSubDescriptor() {}
 848           const GroupOfSoundfieldGroupsLabelSubDescriptor& operator=(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 849           virtual void Copy(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs);
 850           virtual const char* HasName() { return "GroupOfSoundfieldGroupsLabelSubDescriptor"; }
 851           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 852           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 853           virtual void     Dump(FILE* = 0);
 854           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 855           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 856         };
 857
 858     } // namespace MXF
 859 } // namespace ASDCP
 860
 861
 862 #endif // _Metadata_H_
 863
 864 //
 865 // end Metadata.h
 866 //