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
 388           GenericPictureEssenceDescriptor() : FrameLayout(0), StoredWidth(0), StoredHeight(0) {}
 389           virtual ~GenericPictureEssenceDescriptor() {}
 390           virtual const char* HasName() { return "GenericPictureEssenceDescriptor"; }
 391           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 392           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 393           virtual void     Dump(FILE* = 0);
 394           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 395           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 396         };
 397
 398       //
 399       class RGBAEssenceDescriptor : public GenericPictureEssenceDescriptor
 400         {
 401           ASDCP_NO_COPY_CONSTRUCT(RGBAEssenceDescriptor);
 402
 403         public:
 404           ui32_t ComponentMaxRef;
 405           ui32_t ComponentMinRef;
 406
 407           RGBAEssenceDescriptor() : ComponentMaxRef(0), ComponentMinRef(0) {}
 408           virtual ~RGBAEssenceDescriptor() {}
 409           virtual const char* HasName() { return "RGBAEssenceDescriptor"; }
 410           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 411           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 412           virtual void     Dump(FILE* = 0);
 413           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 414           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 415         };
 416
 417       //
 418       class JPEG2000PictureSubDescriptor : public InterchangeObject
 419         {
 420           ASDCP_NO_COPY_CONSTRUCT(JPEG2000PictureSubDescriptor);
 421
 422         public:
 423           ui16_t Rsize;
 424           ui32_t Xsize;
 425           ui32_t Ysize;
 426           ui32_t XOsize;
 427           ui32_t YOsize;
 428           ui32_t XTsize;
 429           ui32_t YTsize;
 430           ui32_t XTOsize;
 431           ui32_t YTOsize;
 432           ui16_t Csize;
 433           Raw PictureComponentSizing;
 434           Raw CodingStyleDefault;
 435           Raw QuantizationDefault;
 436
 437           JPEG2000PictureSubDescriptor() : Rsize(0), Xsize(0), Ysize(0), XOsize(0), YOsize(0), XTsize(0), YTsize(0), XTOsize(0), YTOsize(0), Csize(0) {}
 438           virtual ~JPEG2000PictureSubDescriptor() {}
 439           virtual const char* HasName() { return "JPEG2000PictureSubDescriptor"; }
 440           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 441           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 442           virtual void     Dump(FILE* = 0);
 443           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 444           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 445         };
 446
 447       //
 448       class CDCIEssenceDescriptor : public GenericPictureEssenceDescriptor
 449         {
 450           ASDCP_NO_COPY_CONSTRUCT(CDCIEssenceDescriptor);
 451
 452         public:
 453           ui32_t ComponentDepth;
 454           ui32_t HorizontalSubsampling;
 455           ui32_t VerticalSubsampling;
 456           ui8_t ColorSiting;
 457
 458           CDCIEssenceDescriptor() : ComponentDepth(0), HorizontalSubsampling(0), VerticalSubsampling(0), ColorSiting(0) {}
 459           virtual ~CDCIEssenceDescriptor() {}
 460           virtual const char* HasName() { return "CDCIEssenceDescriptor"; }
 461           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 462           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 463           virtual void     Dump(FILE* = 0);
 464           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 465           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 466         };
 467
 468       //
 469       class MPEG2VideoDescriptor : public CDCIEssenceDescriptor
 470         {
 471           ASDCP_NO_COPY_CONSTRUCT(MPEG2VideoDescriptor);
 472
 473         public:
 474           ui8_t CodedContentType;
 475           ui8_t LowDelay;
 476           ui32_t BitRate;
 477           ui8_t ProfileAndLevel;
 478
 479           MPEG2VideoDescriptor() : CodedContentType(0), LowDelay(0), BitRate(0), ProfileAndLevel(0) {}
 480           virtual ~MPEG2VideoDescriptor() {}
 481           virtual const char* HasName() { return "MPEG2VideoDescriptor"; }
 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 DMSegment : public InterchangeObject
 491         {
 492           ASDCP_NO_COPY_CONSTRUCT(DMSegment);
 493
 494         public:
 495           UL DataDefinition;
 496           ui64_t EventStartPosition;
 497           ui64_t Duration;
 498           UTF16String EventComment;
 499           UUID DMFramework;
 500
 501           DMSegment() : EventStartPosition(0), Duration(0) {}
 502           virtual ~DMSegment() {}
 503           virtual const char* HasName() { return "DMSegment"; }
 504           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 505           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 506           virtual void     Dump(FILE* = 0);
 507           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 508           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 509         };
 510
 511       //
 512       class CryptographicFramework : public InterchangeObject
 513         {
 514           ASDCP_NO_COPY_CONSTRUCT(CryptographicFramework);
 515
 516         public:
 517           UUID ContextSR;
 518
 519           CryptographicFramework() {}
 520           virtual ~CryptographicFramework() {}
 521           virtual const char* HasName() { return "CryptographicFramework"; }
 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 CryptographicContext : public InterchangeObject
 531         {
 532           ASDCP_NO_COPY_CONSTRUCT(CryptographicContext);
 533
 534         public:
 535           UUID ContextID;
 536           UL SourceEssenceContainer;
 537           UL CipherAlgorithm;
 538           UL MICAlgorithm;
 539           UUID CryptographicKeyID;
 540
 541           CryptographicContext() {}
 542           virtual ~CryptographicContext() {}
 543           virtual const char* HasName() { return "CryptographicContext"; }
 544           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 545           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 546           virtual void     Dump(FILE* = 0);
 547           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 548           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 549         };
 550
 551       //
 552       class GenericDataEssenceDescriptor : public FileDescriptor
 553         {
 554           ASDCP_NO_COPY_CONSTRUCT(GenericDataEssenceDescriptor);
 555
 556         public:
 557           UL DataEssenceCoding;
 558
 559           GenericDataEssenceDescriptor() {}
 560           virtual ~GenericDataEssenceDescriptor() {}
 561           virtual const char* HasName() { return "GenericDataEssenceDescriptor"; }
 562           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 563           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 564           virtual void     Dump(FILE* = 0);
 565           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 566           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 567         };
 568
 569       //
 570       class DCTimedTextDescriptor : public GenericDataEssenceDescriptor
 571         {
 572           ASDCP_NO_COPY_CONSTRUCT(DCTimedTextDescriptor);
 573
 574         public:
 575           UTF16String UTFEncoding;
 576           UTF16String RootNamespaceName;
 577
 578           DCTimedTextDescriptor() {}
 579           virtual ~DCTimedTextDescriptor() {}
 580           virtual const char* HasName() { return "DCTimedTextDescriptor"; }
 581           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 582           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 583           virtual void     Dump(FILE* = 0);
 584           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 585           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 586         };
 587
 588       //
 589       class DCTimedTextResourceDescriptor : public InterchangeObject
 590         {
 591           ASDCP_NO_COPY_CONSTRUCT(DCTimedTextResourceDescriptor);
 592
 593         public:
 594           UUID ResourcePackageID;
 595           UTF16String ResourceMIMEType;
 596           ui32_t ResourceSID;
 597
 598           DCTimedTextResourceDescriptor() : ResourceSID(0) {}
 599           virtual ~DCTimedTextResourceDescriptor() {}
 600           virtual const char* HasName() { return "DCTimedTextResourceDescriptor"; }
 601           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 602           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 603           virtual void     Dump(FILE* = 0);
 604           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 605           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 606         };
 607     } // namespace MXF
 608 } // namespace ASDCP
 609
 610
 611 #endif // _Metadata_H_
 612
 613 //
 614 // end Metadata.h
 615 //