src/Metadata.h

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