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();
  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           UL ChannelAssignment;
 367
 368           WaveAudioDescriptor() : BlockAlign(0), SequenceOffset(0), AvgBps(0) {}
 369           virtual ~WaveAudioDescriptor() {}
 370           virtual const char* HasName() { return "WaveAudioDescriptor"; }
 371           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 372           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 373           virtual void     Dump(FILE* = 0);
 374           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 375           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 376         };
 377
 378       //
 379       class GenericPictureEssenceDescriptor : public FileDescriptor
 380         {
 381           ASDCP_NO_COPY_CONSTRUCT(GenericPictureEssenceDescriptor);
 382
 383         public:
 384           ui8_t FrameLayout;
 385           ui32_t StoredWidth;
 386           ui32_t StoredHeight;
 387           Rational AspectRatio;
 388           UL PictureEssenceCoding;
 389
 390           GenericPictureEssenceDescriptor() : FrameLayout(0), StoredWidth(0), StoredHeight(0) {}
 391           virtual ~GenericPictureEssenceDescriptor() {}
 392           virtual const char* HasName() { return "GenericPictureEssenceDescriptor"; }
 393           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 394           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 395           virtual void     Dump(FILE* = 0);
 396           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 397           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 398         };
 399
 400       //
 401       class RGBAEssenceDescriptor : public GenericPictureEssenceDescriptor
 402         {
 403           ASDCP_NO_COPY_CONSTRUCT(RGBAEssenceDescriptor);
 404
 405         public:
 406           ui32_t ComponentMaxRef;
 407           ui32_t ComponentMinRef;
 408
 409           RGBAEssenceDescriptor() : ComponentMaxRef(0), ComponentMinRef(0) {}
 410           virtual ~RGBAEssenceDescriptor() {}
 411           virtual const char* HasName() { return "RGBAEssenceDescriptor"; }
 412           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 413           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 414           virtual void     Dump(FILE* = 0);
 415           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 416           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 417         };
 418
 419       //
 420       class JPEG2000PictureSubDescriptor : public InterchangeObject
 421         {
 422           ASDCP_NO_COPY_CONSTRUCT(JPEG2000PictureSubDescriptor);
 423
 424         public:
 425           ui16_t Rsize;
 426           ui32_t Xsize;
 427           ui32_t Ysize;
 428           ui32_t XOsize;
 429           ui32_t YOsize;
 430           ui32_t XTsize;
 431           ui32_t YTsize;
 432           ui32_t XTOsize;
 433           ui32_t YTOsize;
 434           ui16_t Csize;
 435           Raw PictureComponentSizing;
 436           Raw CodingStyleDefault;
 437           Raw QuantizationDefault;
 438
 439           JPEG2000PictureSubDescriptor() : Rsize(0), Xsize(0), Ysize(0), XOsize(0), YOsize(0), XTsize(0), YTsize(0), XTOsize(0), YTOsize(0), Csize(0) {}
 440           virtual ~JPEG2000PictureSubDescriptor() {}
 441           virtual const char* HasName() { return "JPEG2000PictureSubDescriptor"; }
 442           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 443           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 444           virtual void     Dump(FILE* = 0);
 445           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 446           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 447         };
 448
 449       //
 450       class CDCIEssenceDescriptor : public GenericPictureEssenceDescriptor
 451         {
 452           ASDCP_NO_COPY_CONSTRUCT(CDCIEssenceDescriptor);
 453
 454         public:
 455           ui32_t ComponentDepth;
 456           ui32_t HorizontalSubsampling;
 457           ui32_t VerticalSubsampling;
 458           ui8_t ColorSiting;
 459
 460           CDCIEssenceDescriptor() : ComponentDepth(0), HorizontalSubsampling(0), VerticalSubsampling(0), ColorSiting(0) {}
 461           virtual ~CDCIEssenceDescriptor() {}
 462           virtual const char* HasName() { return "CDCIEssenceDescriptor"; }
 463           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 464           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 465           virtual void     Dump(FILE* = 0);
 466           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 467           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 468         };
 469
 470       //
 471       class MPEG2VideoDescriptor : public CDCIEssenceDescriptor
 472         {
 473           ASDCP_NO_COPY_CONSTRUCT(MPEG2VideoDescriptor);
 474
 475         public:
 476           ui8_t CodedContentType;
 477           ui8_t LowDelay;
 478           ui32_t BitRate;
 479           ui8_t ProfileAndLevel;
 480
 481           MPEG2VideoDescriptor() : CodedContentType(0), LowDelay(0), BitRate(0), ProfileAndLevel(0) {}
 482           virtual ~MPEG2VideoDescriptor() {}
 483           virtual const char* HasName() { return "MPEG2VideoDescriptor"; }
 484           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 485           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 486           virtual void     Dump(FILE* = 0);
 487           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 488           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 489         };
 490
 491       //
 492       class DMSegment : public InterchangeObject
 493         {
 494           ASDCP_NO_COPY_CONSTRUCT(DMSegment);
 495
 496         public:
 497           UL DataDefinition;
 498           ui64_t EventStartPosition;
 499           ui64_t Duration;
 500           UTF16String EventComment;
 501           UUID DMFramework;
 502
 503           DMSegment() : EventStartPosition(0), Duration(0) {}
 504           virtual ~DMSegment() {}
 505           virtual const char* HasName() { return "DMSegment"; }
 506           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 507           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 508           virtual void     Dump(FILE* = 0);
 509           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 510           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 511         };
 512
 513       //
 514       class CryptographicFramework : public InterchangeObject
 515         {
 516           ASDCP_NO_COPY_CONSTRUCT(CryptographicFramework);
 517
 518         public:
 519           UUID ContextSR;
 520
 521           CryptographicFramework() {}
 522           virtual ~CryptographicFramework() {}
 523           virtual const char* HasName() { return "CryptographicFramework"; }
 524           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 525           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 526           virtual void     Dump(FILE* = 0);
 527           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 528           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 529         };
 530
 531       //
 532       class CryptographicContext : public InterchangeObject
 533         {
 534           ASDCP_NO_COPY_CONSTRUCT(CryptographicContext);
 535
 536         public:
 537           UUID ContextID;
 538           UL SourceEssenceContainer;
 539           UL CipherAlgorithm;
 540           UL MICAlgorithm;
 541           UUID CryptographicKeyID;
 542
 543           CryptographicContext() {}
 544           virtual ~CryptographicContext() {}
 545           virtual const char* HasName() { return "CryptographicContext"; }
 546           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 547           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 548           virtual void     Dump(FILE* = 0);
 549           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 550           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 551         };
 552
 553       //
 554       class GenericDataEssenceDescriptor : public FileDescriptor
 555         {
 556           ASDCP_NO_COPY_CONSTRUCT(GenericDataEssenceDescriptor);
 557
 558         public:
 559           UL DataEssenceCoding;
 560
 561           GenericDataEssenceDescriptor() {}
 562           virtual ~GenericDataEssenceDescriptor() {}
 563           virtual const char* HasName() { return "GenericDataEssenceDescriptor"; }
 564           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 565           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 566           virtual void     Dump(FILE* = 0);
 567           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 568           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 569         };
 570
 571       //
 572       class TimedTextDescriptor : public GenericDataEssenceDescriptor
 573         {
 574           ASDCP_NO_COPY_CONSTRUCT(TimedTextDescriptor);
 575
 576         public:
 577           UUID ResourceID;
 578           UTF16String UCSEncoding;
 579           UTF16String NamespaceURI;
 580
 581           TimedTextDescriptor() {}
 582           virtual ~TimedTextDescriptor() {}
 583           virtual const char* HasName() { return "TimedTextDescriptor"; }
 584           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 585           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 586           virtual void     Dump(FILE* = 0);
 587           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 588           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 589         };
 590
 591       //
 592       class TimedTextResourceSubDescriptor : public InterchangeObject
 593         {
 594           ASDCP_NO_COPY_CONSTRUCT(TimedTextResourceSubDescriptor);
 595
 596         public:
 597           UUID AncillaryResourceID;
 598           UTF16String MIMEMediaType;
 599           ui32_t EssenceStreamID;
 600
 601           TimedTextResourceSubDescriptor() : EssenceStreamID(0) {}
 602           virtual ~TimedTextResourceSubDescriptor() {}
 603           virtual const char* HasName() { return "TimedTextResourceSubDescriptor"; }
 604           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 605           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 606           virtual void     Dump(FILE* = 0);
 607           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 608           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 609         };
 610
 611       //
 612       class StereoscopicPictureSubDescriptor : public InterchangeObject
 613         {
 614           ASDCP_NO_COPY_CONSTRUCT(StereoscopicPictureSubDescriptor);
 615
 616         public:
 617
 618           StereoscopicPictureSubDescriptor() {}
 619           virtual ~StereoscopicPictureSubDescriptor() {}
 620           virtual const char* HasName() { return "StereoscopicPictureSubDescriptor"; }
 621           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 622           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 623           virtual void     Dump(FILE* = 0);
 624           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 625           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 626         };
 627
 628     } // namespace MXF
 629 } // namespace ASDCP
 630
 631
 632 #endif // _Metadata_H_
 633
 634 //
 635 // end Metadata.h
 636 //