src/Metadata.h

   1 /*
   2 Copyright (c) 2005-2009, 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           ASDCP_NO_COPY_CONSTRUCT(Identification);
  49           Identification();
  50
  51         public:
  52           const Dictionary& m_Dict;
  53           UUID ThisGenerationUID;
  54           UTF16String CompanyName;
  55           UTF16String ProductName;
  56           VersionType ProductVersion;
  57           UTF16String VersionString;
  58           UUID ProductUID;
  59           Timestamp ModificationDate;
  60           VersionType ToolkitVersion;
  61           UTF16String Platform;
  62
  63   Identification(const Dictionary& d) : InterchangeObject(d), m_Dict(d) {}
  64           virtual ~Identification() {}
  65           virtual const char* HasName() { return "Identification"; }
  66           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
  67           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
  68           virtual void     Dump(FILE* = 0);
  69           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
  70           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
  71         };
  72
  73       //
  74       class ContentStorage : public InterchangeObject
  75         {
  76           ASDCP_NO_COPY_CONSTRUCT(ContentStorage);
  77           ContentStorage();
  78
  79         public:
  80           const Dictionary& m_Dict;
  81           Batch<UUID> Packages;
  82           Batch<UUID> EssenceContainerData;
  83
  84   ContentStorage(const Dictionary& d) : InterchangeObject(d), m_Dict(d) {}
  85           virtual ~ContentStorage() {}
  86           virtual const char* HasName() { return "ContentStorage"; }
  87           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
  88           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
  89           virtual void     Dump(FILE* = 0);
  90           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
  91           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
  92         };
  93
  94       //
  95       class EssenceContainerData : public InterchangeObject
  96         {
  97           ASDCP_NO_COPY_CONSTRUCT(EssenceContainerData);
  98           EssenceContainerData();
  99
 100         public:
 101           const Dictionary& m_Dict;
 102           UMID LinkedPackageUID;
 103           ui32_t IndexSID;
 104           ui32_t BodySID;
 105
 106   EssenceContainerData(const Dictionary& d) : InterchangeObject(d), m_Dict(d), IndexSID(0), BodySID(0) {}
 107           virtual ~EssenceContainerData() {}
 108           virtual const char* HasName() { return "EssenceContainerData"; }
 109           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 110           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 111           virtual void     Dump(FILE* = 0);
 112           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 113           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 114         };
 115
 116       //
 117       class GenericPackage : public InterchangeObject
 118         {
 119           ASDCP_NO_COPY_CONSTRUCT(GenericPackage);
 120           GenericPackage();
 121
 122         public:
 123           const Dictionary& m_Dict;
 124           UMID PackageUID;
 125           UTF16String Name;
 126           Timestamp PackageCreationDate;
 127           Timestamp PackageModifiedDate;
 128           Batch<UUID> Tracks;
 129
 130   GenericPackage(const Dictionary& d) : InterchangeObject(d), m_Dict(d) {}
 131           virtual ~GenericPackage() {}
 132           virtual const char* HasName() { return "GenericPackage"; }
 133           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 134           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 135           virtual void     Dump(FILE* = 0);
 136         };
 137
 138       //
 139       class MaterialPackage : public GenericPackage
 140         {
 141           ASDCP_NO_COPY_CONSTRUCT(MaterialPackage);
 142           MaterialPackage();
 143
 144         public:
 145           const Dictionary& m_Dict;
 146
 147   MaterialPackage(const Dictionary& d) : GenericPackage(d), m_Dict(d) {}
 148           virtual ~MaterialPackage() {}
 149           virtual const char* HasName() { return "MaterialPackage"; }
 150           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 151           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 152           virtual void     Dump(FILE* = 0);
 153           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 154           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 155         };
 156
 157       //
 158       class SourcePackage : public GenericPackage
 159         {
 160           ASDCP_NO_COPY_CONSTRUCT(SourcePackage);
 161           SourcePackage();
 162
 163         public:
 164           const Dictionary& m_Dict;
 165           UUID Descriptor;
 166
 167   SourcePackage(const Dictionary& d) : GenericPackage(d), m_Dict(d) {}
 168           virtual ~SourcePackage() {}
 169           virtual const char* HasName() { return "SourcePackage"; }
 170           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 171           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 172           virtual void     Dump(FILE* = 0);
 173           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 174           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 175         };
 176
 177       //
 178       class GenericTrack : public InterchangeObject
 179         {
 180           ASDCP_NO_COPY_CONSTRUCT(GenericTrack);
 181           GenericTrack();
 182
 183         public:
 184           const Dictionary& m_Dict;
 185           ui32_t TrackID;
 186           ui32_t TrackNumber;
 187           UTF16String TrackName;
 188           UUID Sequence;
 189
 190   GenericTrack(const Dictionary& d) : InterchangeObject(d), m_Dict(d), TrackID(0), TrackNumber(0) {}
 191           virtual ~GenericTrack() {}
 192           virtual const char* HasName() { return "GenericTrack"; }
 193           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 194           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 195           virtual void     Dump(FILE* = 0);
 196         };
 197
 198       //
 199       class StaticTrack : public GenericTrack
 200         {
 201           ASDCP_NO_COPY_CONSTRUCT(StaticTrack);
 202           StaticTrack();
 203
 204         public:
 205           const Dictionary& m_Dict;
 206
 207   StaticTrack(const Dictionary& d) : GenericTrack(d), m_Dict(d) {}
 208           virtual ~StaticTrack() {}
 209           virtual const char* HasName() { return "StaticTrack"; }
 210           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 211           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 212           virtual void     Dump(FILE* = 0);
 213           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 214           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 215         };
 216
 217       //
 218       class Track : public GenericTrack
 219         {
 220           ASDCP_NO_COPY_CONSTRUCT(Track);
 221           Track();
 222
 223         public:
 224           const Dictionary& m_Dict;
 225           Rational EditRate;
 226           ui64_t Origin;
 227
 228   Track(const Dictionary& d) : GenericTrack(d), m_Dict(d), Origin(0) {}
 229           virtual ~Track() {}
 230           virtual const char* HasName() { return "Track"; }
 231           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 232           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 233           virtual void     Dump(FILE* = 0);
 234           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 235           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 236         };
 237
 238       //
 239       class StructuralComponent : public InterchangeObject
 240         {
 241           ASDCP_NO_COPY_CONSTRUCT(StructuralComponent);
 242           StructuralComponent();
 243
 244         public:
 245           const Dictionary& m_Dict;
 246           UL DataDefinition;
 247           ui64_t Duration;
 248
 249   StructuralComponent(const Dictionary& d) : InterchangeObject(d), m_Dict(d), Duration(0) {}
 250           virtual ~StructuralComponent() {}
 251           virtual const char* HasName() { return "StructuralComponent"; }
 252           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 253           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 254           virtual void     Dump(FILE* = 0);
 255         };
 256
 257       //
 258       class Sequence : public StructuralComponent
 259         {
 260           ASDCP_NO_COPY_CONSTRUCT(Sequence);
 261           Sequence();
 262
 263         public:
 264           const Dictionary& m_Dict;
 265           Batch<UUID> StructuralComponents;
 266
 267   Sequence(const Dictionary& d) : StructuralComponent(d), m_Dict(d) {}
 268           virtual ~Sequence() {}
 269           virtual const char* HasName() { return "Sequence"; }
 270           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 271           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 272           virtual void     Dump(FILE* = 0);
 273           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 274           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 275         };
 276
 277       //
 278       class SourceClip : public StructuralComponent
 279         {
 280           ASDCP_NO_COPY_CONSTRUCT(SourceClip);
 281           SourceClip();
 282
 283         public:
 284           const Dictionary& m_Dict;
 285           ui64_t StartPosition;
 286           UMID SourcePackageID;
 287           ui32_t SourceTrackID;
 288
 289   SourceClip(const Dictionary& d) : StructuralComponent(d), m_Dict(d), StartPosition(0), SourceTrackID(0) {}
 290           virtual ~SourceClip() {}
 291           virtual const char* HasName() { return "SourceClip"; }
 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 TimecodeComponent : public StructuralComponent
 301         {
 302           ASDCP_NO_COPY_CONSTRUCT(TimecodeComponent);
 303           TimecodeComponent();
 304
 305         public:
 306           const Dictionary& m_Dict;
 307           ui16_t RoundedTimecodeBase;
 308           ui64_t StartTimecode;
 309           ui8_t DropFrame;
 310
 311   TimecodeComponent(const Dictionary& d) : StructuralComponent(d), m_Dict(d), RoundedTimecodeBase(0), StartTimecode(0), DropFrame(0) {}
 312           virtual ~TimecodeComponent() {}
 313           virtual const char* HasName() { return "TimecodeComponent"; }
 314           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 315           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 316           virtual void     Dump(FILE* = 0);
 317           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 318           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 319         };
 320
 321       //
 322       class GenericDescriptor : public InterchangeObject
 323         {
 324           ASDCP_NO_COPY_CONSTRUCT(GenericDescriptor);
 325           GenericDescriptor();
 326
 327         public:
 328           const Dictionary& m_Dict;
 329           Batch<UUID> Locators;
 330           Batch<UUID> SubDescriptors;
 331
 332   GenericDescriptor(const Dictionary& d) : InterchangeObject(d), m_Dict(d) {}
 333           virtual ~GenericDescriptor() {}
 334           virtual const char* HasName() { return "GenericDescriptor"; }
 335           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 336           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 337           virtual void     Dump(FILE* = 0);
 338         };
 339
 340       //
 341       class FileDescriptor : public GenericDescriptor
 342         {
 343           ASDCP_NO_COPY_CONSTRUCT(FileDescriptor);
 344           FileDescriptor();
 345
 346         public:
 347           const Dictionary& m_Dict;
 348           ui32_t LinkedTrackID;
 349           Rational SampleRate;
 350           ui64_t ContainerDuration;
 351           UL EssenceContainer;
 352           UL Codec;
 353
 354   FileDescriptor(const Dictionary& d) : GenericDescriptor(d), m_Dict(d), LinkedTrackID(0), ContainerDuration(0) {}
 355           virtual ~FileDescriptor() {}
 356           virtual const char* HasName() { return "FileDescriptor"; }
 357           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 358           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 359           virtual void     Dump(FILE* = 0);
 360           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 361           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 362         };
 363
 364       //
 365       class GenericSoundEssenceDescriptor : public FileDescriptor
 366         {
 367           ASDCP_NO_COPY_CONSTRUCT(GenericSoundEssenceDescriptor);
 368           GenericSoundEssenceDescriptor();
 369
 370         public:
 371           const Dictionary& m_Dict;
 372           Rational AudioSamplingRate;
 373           ui8_t Locked;
 374           ui8_t AudioRefLevel;
 375           ui32_t ChannelCount;
 376           ui32_t QuantizationBits;
 377           ui8_t DialNorm;
 378
 379   GenericSoundEssenceDescriptor(const Dictionary& d) : FileDescriptor(d), m_Dict(d), Locked(0), AudioRefLevel(0), ChannelCount(0), QuantizationBits(0), DialNorm(0) {}
 380           virtual ~GenericSoundEssenceDescriptor() {}
 381           virtual const char* HasName() { return "GenericSoundEssenceDescriptor"; }
 382           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 383           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 384           virtual void     Dump(FILE* = 0);
 385           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 386           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 387         };
 388
 389       //
 390       class WaveAudioDescriptor : public GenericSoundEssenceDescriptor
 391         {
 392           ASDCP_NO_COPY_CONSTRUCT(WaveAudioDescriptor);
 393           WaveAudioDescriptor();
 394
 395         public:
 396           const Dictionary& m_Dict;
 397           ui16_t BlockAlign;
 398           ui8_t SequenceOffset;
 399           ui32_t AvgBps;
 400           UL ChannelAssignment;
 401
 402   WaveAudioDescriptor(const Dictionary& d) : GenericSoundEssenceDescriptor(d), m_Dict(d), BlockAlign(0), SequenceOffset(0), AvgBps(0) {}
 403           virtual ~WaveAudioDescriptor() {}
 404           virtual const char* HasName() { return "WaveAudioDescriptor"; }
 405           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 406           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 407           virtual void     Dump(FILE* = 0);
 408           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 409           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 410         };
 411
 412       //
 413       class GenericPictureEssenceDescriptor : public FileDescriptor
 414         {
 415           ASDCP_NO_COPY_CONSTRUCT(GenericPictureEssenceDescriptor);
 416           GenericPictureEssenceDescriptor();
 417
 418         public:
 419           const Dictionary& m_Dict;
 420           ui8_t FrameLayout;
 421           ui32_t StoredWidth;
 422           ui32_t StoredHeight;
 423           Rational AspectRatio;
 424           UL PictureEssenceCoding;
 425
 426   GenericPictureEssenceDescriptor(const Dictionary& d) : FileDescriptor(d), m_Dict(d), FrameLayout(0), StoredWidth(0), StoredHeight(0) {}
 427           virtual ~GenericPictureEssenceDescriptor() {}
 428           virtual const char* HasName() { return "GenericPictureEssenceDescriptor"; }
 429           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 430           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 431           virtual void     Dump(FILE* = 0);
 432           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 433           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 434         };
 435
 436       //
 437       class RGBAEssenceDescriptor : public GenericPictureEssenceDescriptor
 438         {
 439           ASDCP_NO_COPY_CONSTRUCT(RGBAEssenceDescriptor);
 440           RGBAEssenceDescriptor();
 441
 442         public:
 443           const Dictionary& m_Dict;
 444           ui32_t ComponentMaxRef;
 445           ui32_t ComponentMinRef;
 446
 447   RGBAEssenceDescriptor(const Dictionary& d) : GenericPictureEssenceDescriptor(d), m_Dict(d), ComponentMaxRef(0), ComponentMinRef(0) {}
 448           virtual ~RGBAEssenceDescriptor() {}
 449           virtual const char* HasName() { return "RGBAEssenceDescriptor"; }
 450           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 451           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 452           virtual void     Dump(FILE* = 0);
 453           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 454           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 455         };
 456
 457       //
 458       class JPEG2000PictureSubDescriptor : public InterchangeObject
 459         {
 460           ASDCP_NO_COPY_CONSTRUCT(JPEG2000PictureSubDescriptor);
 461           JPEG2000PictureSubDescriptor();
 462
 463         public:
 464           const Dictionary& m_Dict;
 465           ui16_t Rsize;
 466           ui32_t Xsize;
 467           ui32_t Ysize;
 468           ui32_t XOsize;
 469           ui32_t YOsize;
 470           ui32_t XTsize;
 471           ui32_t YTsize;
 472           ui32_t XTOsize;
 473           ui32_t YTOsize;
 474           ui16_t Csize;
 475           Raw PictureComponentSizing;
 476           Raw CodingStyleDefault;
 477           Raw QuantizationDefault;
 478
 479   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) {}
 480           virtual ~JPEG2000PictureSubDescriptor() {}
 481           virtual const char* HasName() { return "JPEG2000PictureSubDescriptor"; }
 482           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 483           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 484           virtual void     Dump(FILE* = 0);
 485           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 486           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 487         };
 488
 489       //
 490       class CDCIEssenceDescriptor : public GenericPictureEssenceDescriptor
 491         {
 492           ASDCP_NO_COPY_CONSTRUCT(CDCIEssenceDescriptor);
 493           CDCIEssenceDescriptor();
 494
 495         public:
 496           const Dictionary& m_Dict;
 497           ui32_t ComponentDepth;
 498           ui32_t HorizontalSubsampling;
 499           ui32_t VerticalSubsampling;
 500           ui8_t ColorSiting;
 501
 502   CDCIEssenceDescriptor(const Dictionary& d) : GenericPictureEssenceDescriptor(d), m_Dict(d), ComponentDepth(0), HorizontalSubsampling(0), VerticalSubsampling(0), ColorSiting(0) {}
 503           virtual ~CDCIEssenceDescriptor() {}
 504           virtual const char* HasName() { return "CDCIEssenceDescriptor"; }
 505           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 506           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 507           virtual void     Dump(FILE* = 0);
 508           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 509           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 510         };
 511
 512       //
 513       class MPEG2VideoDescriptor : public CDCIEssenceDescriptor
 514         {
 515           ASDCP_NO_COPY_CONSTRUCT(MPEG2VideoDescriptor);
 516           MPEG2VideoDescriptor();
 517
 518         public:
 519           const Dictionary& m_Dict;
 520           ui8_t CodedContentType;
 521           ui8_t LowDelay;
 522           ui32_t BitRate;
 523           ui8_t ProfileAndLevel;
 524
 525   MPEG2VideoDescriptor(const Dictionary& d) : CDCIEssenceDescriptor(d), m_Dict(d), CodedContentType(0), LowDelay(0), BitRate(0), ProfileAndLevel(0) {}
 526           virtual ~MPEG2VideoDescriptor() {}
 527           virtual const char* HasName() { return "MPEG2VideoDescriptor"; }
 528           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 529           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 530           virtual void     Dump(FILE* = 0);
 531           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 532           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 533         };
 534
 535       //
 536       class DMSegment : public InterchangeObject
 537         {
 538           ASDCP_NO_COPY_CONSTRUCT(DMSegment);
 539           DMSegment();
 540
 541         public:
 542           const Dictionary& m_Dict;
 543           UL DataDefinition;
 544           ui64_t EventStartPosition;
 545           ui64_t Duration;
 546           UTF16String EventComment;
 547           UUID DMFramework;
 548
 549   DMSegment(const Dictionary& d) : InterchangeObject(d), m_Dict(d), EventStartPosition(0), Duration(0) {}
 550           virtual ~DMSegment() {}
 551           virtual const char* HasName() { return "DMSegment"; }
 552           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 553           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 554           virtual void     Dump(FILE* = 0);
 555           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 556           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 557         };
 558
 559       //
 560       class CryptographicFramework : public InterchangeObject
 561         {
 562           ASDCP_NO_COPY_CONSTRUCT(CryptographicFramework);
 563           CryptographicFramework();
 564
 565         public:
 566           const Dictionary& m_Dict;
 567           UUID ContextSR;
 568
 569   CryptographicFramework(const Dictionary& d) : InterchangeObject(d), m_Dict(d) {}
 570           virtual ~CryptographicFramework() {}
 571           virtual const char* HasName() { return "CryptographicFramework"; }
 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 CryptographicContext : public InterchangeObject
 581         {
 582           ASDCP_NO_COPY_CONSTRUCT(CryptographicContext);
 583           CryptographicContext();
 584
 585         public:
 586           const Dictionary& m_Dict;
 587           UUID ContextID;
 588           UL SourceEssenceContainer;
 589           UL CipherAlgorithm;
 590           UL MICAlgorithm;
 591           UUID CryptographicKeyID;
 592
 593   CryptographicContext(const Dictionary& d) : InterchangeObject(d), m_Dict(d) {}
 594           virtual ~CryptographicContext() {}
 595           virtual const char* HasName() { return "CryptographicContext"; }
 596           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 597           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 598           virtual void     Dump(FILE* = 0);
 599           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 600           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 601         };
 602
 603       //
 604       class GenericDataEssenceDescriptor : public FileDescriptor
 605         {
 606           ASDCP_NO_COPY_CONSTRUCT(GenericDataEssenceDescriptor);
 607           GenericDataEssenceDescriptor();
 608
 609         public:
 610           const Dictionary& m_Dict;
 611           UL DataEssenceCoding;
 612
 613   GenericDataEssenceDescriptor(const Dictionary& d) : FileDescriptor(d), m_Dict(d) {}
 614           virtual ~GenericDataEssenceDescriptor() {}
 615           virtual const char* HasName() { return "GenericDataEssenceDescriptor"; }
 616           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 617           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 618           virtual void     Dump(FILE* = 0);
 619           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 620           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 621         };
 622
 623       //
 624       class TimedTextDescriptor : public GenericDataEssenceDescriptor
 625         {
 626           ASDCP_NO_COPY_CONSTRUCT(TimedTextDescriptor);
 627           TimedTextDescriptor();
 628
 629         public:
 630           const Dictionary& m_Dict;
 631           UUID ResourceID;
 632           UTF16String UCSEncoding;
 633           UTF16String NamespaceURI;
 634
 635   TimedTextDescriptor(const Dictionary& d) : GenericDataEssenceDescriptor(d), m_Dict(d) {}
 636           virtual ~TimedTextDescriptor() {}
 637           virtual const char* HasName() { return "TimedTextDescriptor"; }
 638           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 639           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 640           virtual void     Dump(FILE* = 0);
 641           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 642           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 643         };
 644
 645       //
 646       class TimedTextResourceSubDescriptor : public InterchangeObject
 647         {
 648           ASDCP_NO_COPY_CONSTRUCT(TimedTextResourceSubDescriptor);
 649           TimedTextResourceSubDescriptor();
 650
 651         public:
 652           const Dictionary& m_Dict;
 653           UUID AncillaryResourceID;
 654           UTF16String MIMEMediaType;
 655           ui32_t EssenceStreamID;
 656
 657   TimedTextResourceSubDescriptor(const Dictionary& d) : InterchangeObject(d), m_Dict(d), EssenceStreamID(0) {}
 658           virtual ~TimedTextResourceSubDescriptor() {}
 659           virtual const char* HasName() { return "TimedTextResourceSubDescriptor"; }
 660           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 661           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 662           virtual void     Dump(FILE* = 0);
 663           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 664           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 665         };
 666
 667       //
 668       class StereoscopicPictureSubDescriptor : public InterchangeObject
 669         {
 670           ASDCP_NO_COPY_CONSTRUCT(StereoscopicPictureSubDescriptor);
 671           StereoscopicPictureSubDescriptor();
 672
 673         public:
 674           const Dictionary& m_Dict;
 675
 676   StereoscopicPictureSubDescriptor(const Dictionary& d) : InterchangeObject(d), m_Dict(d) {}
 677           virtual ~StereoscopicPictureSubDescriptor() {}
 678           virtual const char* HasName() { return "StereoscopicPictureSubDescriptor"; }
 679           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 680           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 681           virtual void     Dump(FILE* = 0);
 682           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 683           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 684         };
 685
 686     } // namespace MXF
 687 } // namespace ASDCP
 688
 689
 690 #endif // _Metadata_H_
 691
 692 //
 693 // end Metadata.h
 694 //