src/Metadata.h

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