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