src/Metadata.h

   1 //
   2 //
   3 // TODO: constructor initializers for all member variables
   4 //
   5
   6 #ifndef _METADATA_H_
   7 #define _METADATA_H_
   8
   9 #include "MXF.h"
  10
  11 namespace ASDCP
  12 {
  13   namespace MXF
  14     {
  15       //
  16       class Identification : public InterchangeObject
  17         {
  18           ASDCP_NO_COPY_CONSTRUCT(Identification);
  19
  20         public:
  21           UUID         ThisGenerationUID;
  22           UTF16String  CompanyName;
  23           UTF16String  ProductName;
  24           ui16_t       ProductVersion;
  25           UTF16String  VersionString;
  26           UUID         ProductUID;
  27           Timestamp    ModificationDate;
  28           ui16_t       ToolkitVersion;
  29           UTF16String  Platform;
  30
  31           Identification() {}
  32           virtual ~Identification() {}
  33           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
  34           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
  35           virtual void     Dump(FILE* = 0);
  36         };
  37
  38
  39       //
  40       class ContentStorage : public InterchangeObject
  41         {
  42           ASDCP_NO_COPY_CONSTRUCT(ContentStorage);
  43
  44         public:
  45           UUID        GenerationUID;
  46           Batch<UUID> Packages;
  47           Batch<UUID> EssenceContainerData;
  48
  49           ContentStorage() {}
  50           virtual ~ContentStorage() {}
  51           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
  52           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
  53           virtual void     Dump(FILE* = 0);
  54         };
  55
  56       //
  57       class GenericPackage : public InterchangeObject
  58         {
  59           ASDCP_NO_COPY_CONSTRUCT(GenericPackage);
  60
  61         public:
  62           UMID          PackageUID;
  63           UUID          GenerationUID;
  64           UTF16String   Name;
  65           Timestamp     PackageCreationDate;
  66           Timestamp     PackageModifiedDate;
  67           Batch<UID>    Tracks;
  68
  69           GenericPackage() {}
  70           virtual ~GenericPackage() {}
  71           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l) = 0;
  72           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
  73           virtual void     Dump(FILE* = 0) = 0;
  74         };
  75
  76
  77       //
  78       class MaterialPackage : public GenericPackage
  79         {
  80           ASDCP_NO_COPY_CONSTRUCT(MaterialPackage);
  81
  82         public:
  83           MaterialPackage() {}
  84           virtual ~MaterialPackage() {}
  85           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
  86           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
  87           virtual void     Dump(FILE* = 0);
  88         };
  89
  90
  91       //
  92       class SourcePackage : public GenericPackage
  93         {
  94           ASDCP_NO_COPY_CONSTRUCT(SourcePackage);
  95
  96         public:
  97           SourcePackage() {}
  98           virtual ~SourcePackage() {}
  99           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 100           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 101           virtual void     Dump(FILE* = 0);
 102         };
 103
 104       //
 105       class Track : public InterchangeObject
 106         {
 107           ASDCP_NO_COPY_CONSTRUCT(Track);
 108
 109         public:
 110           UUID        GenerationUID;
 111           ui32_t      TrackID;
 112           ui32_t      TrackNumber;
 113           UTF16String TrackName;
 114           UUID        Sequence;
 115           Rational    EditRate;
 116           ui64_t      Origin;
 117
 118           Track() {}
 119           virtual ~Track() {}
 120           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 121           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 122           virtual void     Dump(FILE* = 0);
 123         };
 124
 125       //
 126       class Sequence : public InterchangeObject
 127         {
 128           ASDCP_NO_COPY_CONSTRUCT(Sequence);
 129
 130         public:
 131           UUID          GenerationUID;
 132           UL            DataDefinition;
 133           ui64_t        Duration;
 134           Batch<UID>    StructuralComponents;
 135
 136           Sequence() {}
 137           virtual ~Sequence() {}
 138           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 139           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 140           virtual void     Dump(FILE* = 0);
 141         };
 142
 143       //
 144       class SourceClip : public InterchangeObject
 145         {
 146           ASDCP_NO_COPY_CONSTRUCT(SourceClip);
 147
 148         public:
 149           UUID          GenerationUID;
 150           UL            DataDefinition;
 151           ui64_t        StartPosition;
 152           ui64_t        Duration;
 153           UMID          SourcePackageID;
 154           ui32_t        SourceTrackID;
 155
 156           SourceClip() {}
 157           virtual ~SourceClip() {}
 158           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 159           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 160           virtual void     Dump(FILE* = 0);
 161         };
 162
 163        //
 164        class TimecodeComponent : public InterchangeObject
 165         {
 166           ASDCP_NO_COPY_CONSTRUCT(TimecodeComponent);
 167
 168         public:
 169           UUID          GenerationUID;
 170           UL            DataDefinition;
 171           ui64_t        Duration;
 172           ui16_t        RoundedTimecodeBase;
 173           ui64_t        StartTimecode;
 174           ui8_t         DropFrame;
 175
 176           TimecodeComponent() {}
 177           virtual ~TimecodeComponent() {}
 178           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 179           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 180           virtual void     Dump(FILE* = 0);
 181         };
 182
 183       //
 184       class MPEG2VideoDescriptor : public ASDCP::MPEG2::VideoDescriptor, public InterchangeObject
 185         {
 186           ASDCP_NO_COPY_CONSTRUCT(MPEG2VideoDescriptor);
 187
 188         public:
 189           ui32_t LinkedTrackID;
 190           UL     EssenceContainer;
 191
 192           MPEG2VideoDescriptor() : LinkedTrackID(0) {}
 193           ~MPEG2VideoDescriptor() {}
 194           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 195           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 196           virtual void     Dump(FILE* = 0);
 197         };
 198
 199       //
 200       class FileDescriptor : public InterchangeObject
 201         {
 202           ASDCP_NO_COPY_CONSTRUCT(FileDescriptor);
 203
 204         public:
 205           UUID      GenerationUID;
 206           Batch<UUID> Locators;
 207           Batch<UUID> SubDescriptors;
 208           ui32_t    LinkedTrackID;
 209           Rational  SampleRate;
 210           ui64_t    ContainerDuration;
 211           UL        EssenceContainer;
 212           UL        Codec;
 213
 214           FileDescriptor() : LinkedTrackID(0), ContainerDuration(0) {}
 215           ~FileDescriptor() {}
 216           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 217           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 218           virtual void     Dump(FILE* = 0);
 219         };
 220
 221       //
 222       class WaveAudioDescriptor : public FileDescriptor
 223         {
 224           ASDCP_NO_COPY_CONSTRUCT(WaveAudioDescriptor);
 225
 226         public:
 227           Rational AudioSamplingRate;
 228           ui8_t    Locked;
 229           i8_t     AudioRefLevel;
 230           ui8_t    ElectroSpatialFormulation;
 231           ui32_t   ChannelCount;
 232           ui32_t   QuantizationBits;
 233           i8_t     DialNorm;
 234           UL       SoundEssenceCompression;
 235           ui16_t   BlockAlign;
 236           ui8_t    SequenceOffset;
 237           ui32_t   AvgBps;
 238           //      Stream   PeakEnvelope;
 239
 240           WaveAudioDescriptor() :
 241             Locked(false), AudioRefLevel(0), ElectroSpatialFormulation(0),
 242             ChannelCount(0), QuantizationBits(0), DialNorm(0), BlockAlign(0),
 243             SequenceOffset(0), AvgBps(0) {}
 244
 245           ~WaveAudioDescriptor() {}
 246           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 247           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 248           virtual void     Dump(FILE* = 0);
 249         };
 250
 251       //
 252       class GenericPictureEssenceDescriptor : public FileDescriptor
 253         {
 254           ASDCP_NO_COPY_CONSTRUCT(GenericPictureEssenceDescriptor);
 255
 256         public:
 257           ui8_t    FrameLayout;
 258           ui32_t   StoredWidth;
 259           ui32_t   StoredHeight;
 260           ui32_t   DisplayWidth;
 261           ui32_t   DisplayHeight;
 262           Rational AspectRatio;
 263           ui32_t   ComponentMaxRef;
 264           ui32_t   ComponentMinRef;
 265           UL       Gamma;
 266           UL       PictureEssenceCoding;
 267
 268           GenericPictureEssenceDescriptor() :
 269             FrameLayout(0), StoredWidth(0), StoredHeight(0), DisplayWidth(0),
 270             DisplayHeight(0), ComponentMaxRef(0), ComponentMinRef(0) {}
 271
 272           ~GenericPictureEssenceDescriptor() {}
 273           //          virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 274           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 275           //          virtual void     Dump(FILE* = 0);
 276         };
 277
 278       //
 279       class RGBAEssenceDescriptor : public GenericPictureEssenceDescriptor
 280         {
 281           ASDCP_NO_COPY_CONSTRUCT(RGBAEssenceDescriptor);
 282
 283         public:
 284           class RGBLayout
 285             {
 286             public:
 287               struct element {
 288                 ui8_t Code;
 289                 ui8_t Depth;
 290               } PictureElement[8];
 291               RGBLayout() { memset(PictureElement, 0, sizeof(PictureElement)); }
 292             };
 293
 294           RGBLayout PixelLayout;
 295
 296           RGBAEssenceDescriptor() {}
 297           ~RGBAEssenceDescriptor() {}
 298           //          virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 299           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 300           //          virtual void     Dump(FILE* = 0);
 301         };
 302
 303       class Raw
 304         {
 305           ASDCP_NO_COPY_CONSTRUCT(Raw);
 306
 307         public:
 308           byte_t* data;
 309           Raw() {}
 310           ~Raw() {}
 311
 312         };
 313
 314       //
 315       class JPEG2000PictureSubDescriptor : public InterchangeObject
 316         {
 317           ASDCP_NO_COPY_CONSTRUCT(JPEG2000PictureSubDescriptor);
 318
 319         public:
 320           ui16_t Rsize;
 321           ui32_t Xsize;
 322           ui32_t Ysize;
 323           ui32_t XOsize;
 324           ui32_t YOsize;
 325           ui32_t XTsize;
 326           ui32_t YTsize;
 327           ui32_t XTOsize;
 328           ui32_t YTOsize;
 329           ui16_t Csize;
 330           Raw PictureComponentSizing;
 331           Raw CodingStyleDefault;
 332           Raw QuantizationDefault;
 333
 334           JPEG2000PictureSubDescriptor() :
 335             Rsize(0), Xsize(0), Ysize(0),
 336             XOsize(0), YOsize(0), XTsize(0),
 337             YTsize(0), XTOsize(0), YTOsize(0),
 338             Csize(0) {}
 339
 340           ~JPEG2000PictureSubDescriptor() {}
 341           //          virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 342           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 343           //          virtual void     Dump(FILE* = 0);
 344         };
 345
 346
 347       //
 348       class CryptographicFramework : public InterchangeObject
 349         {
 350           ASDCP_NO_COPY_CONSTRUCT(CryptographicFramework);
 351
 352         public:
 353           UUID ContextSR;
 354
 355           CryptographicFramework() {}
 356           ~CryptographicFramework() {}
 357           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 358           // virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 359           virtual void     Dump(FILE* = 0);
 360         };
 361
 362       //
 363       class CryptographicContext : public InterchangeObject
 364         {
 365           ASDCP_NO_COPY_CONSTRUCT(CryptographicContext);
 366
 367         public:
 368           UUID ContextID;
 369           UL   SourceEssenceContainer;
 370           UL   CipherAlgorithm;
 371           UL   MICAlgorithm;
 372           UUID CryptographicKeyID;
 373
 374           CryptographicContext() {}
 375           ~CryptographicContext() {}
 376           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 377           // virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 378           virtual void     Dump(FILE* = 0);
 379         };
 380
 381     } // namespace MXF
 382 } // namespace ASDCP
 383
 384
 385 #endif // _METADATA_H_
 386
 387 //
 388 // end Metadata.h
 389 //