src/MXFTypes.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    MXFTypes.h
  28     \version $Id$
  29     \brief   MXF objects
  30 */
  31
  32 #ifndef _MXFTYPES_H_
  33 #define _MXFTYPES_H_
  34
  35 #include "KLV.h"
  36 #include <list>
  37 #include <vector>
  38 #include <map>
  39 #include <wchar.h>
  40
  41 // used with TLVReader::Read*
  42 //
  43 // these are used below to manufacture arguments
  44 #define OBJ_READ_ARGS(s,l) Dict::Type(MDD_##s##_##l), &l
  45 #define OBJ_WRITE_ARGS(s,l) Dict::Type(MDD_##s##_##l), &l
  46 #define OBJ_TYPE_ARGS(t) Dict::Type(MDD_##t).ul
  47
  48
  49 namespace ASDCP
  50 {
  51   namespace MXF
  52     {
  53       typedef std::pair<ui32_t, ui32_t> ItemInfo;
  54       typedef std::map<TagValue, ItemInfo> TagMap;
  55
  56       //
  57       class TLVReader : public Kumu::MemIOReader
  58         {
  59
  60           TagMap         m_ElementMap;
  61           IPrimerLookup* m_Lookup;
  62
  63           TLVReader();
  64           ASDCP_NO_COPY_CONSTRUCT(TLVReader);
  65           bool FindTL(const MDDEntry&);
  66
  67         public:
  68           TLVReader(const byte_t* p, ui32_t c, IPrimerLookup* = 0);
  69           Result_t ReadObject(const MDDEntry&, Kumu::IArchive*);
  70           Result_t ReadUi8(const MDDEntry&, ui8_t*);
  71           Result_t ReadUi16(const MDDEntry&, ui16_t*);
  72           Result_t ReadUi32(const MDDEntry&, ui32_t*);
  73           Result_t ReadUi64(const MDDEntry&, ui64_t*);
  74         };
  75
  76       //
  77       class TLVWriter : public Kumu::MemIOWriter
  78         {
  79
  80           TagMap         m_ElementMap;
  81           IPrimerLookup* m_Lookup;
  82
  83           TLVWriter();
  84           ASDCP_NO_COPY_CONSTRUCT(TLVWriter);
  85           Result_t WriteTag(const MDDEntry&);
  86
  87         public:
  88           TLVWriter(byte_t* p, ui32_t c, IPrimerLookup* = 0);
  89           Result_t WriteObject(const MDDEntry&, Kumu::IArchive*);
  90           Result_t WriteUi8(const MDDEntry&, ui8_t*);
  91           Result_t WriteUi16(const MDDEntry&, ui16_t*);
  92           Result_t WriteUi32(const MDDEntry&, ui32_t*);
  93           Result_t WriteUi64(const MDDEntry&, ui64_t*);
  94         };
  95
  96       //
  97       template <class T>
  98         class Batch : public std::vector<T>, public Kumu::IArchive
  99         {
 100         public:
 101           Batch() {}
 102           ~Batch() {}
 103
 104           //
 105           virtual bool Unarchive(Kumu::MemIOReader* Reader) {
 106             ui32_t ItemCount, ItemSize;
 107             if ( ! Reader->ReadUi32BE(&ItemCount) ) return false;
 108             if ( ! Reader->ReadUi32BE(&ItemSize) ) return false;
 109
 110             if ( ( ItemCount > 65536 ) || ( ItemSize > 1024 ) )
 111               return false;
 112
 113             bool result = true;
 114             for ( ui32_t i = 0; i < ItemCount && result; i++ )
 115               {
 116                 T Tmp;
 117                 result = Tmp.Unarchive(Reader);
 118
 119                 if ( result )
 120                   push_back(Tmp);
 121               }
 122
 123             return result;
 124           }
 125
 126           inline virtual bool HasValue() const { return ! this->empty(); }
 127
 128           //
 129           virtual bool Archive(Kumu::MemIOWriter* Writer) const {
 130             if ( ! Writer->WriteUi32BE(this->size()) ) return false;
 131             byte_t* p = Writer->CurrentData();
 132
 133             if ( ! Writer->WriteUi32BE(0) ) return false;
 134             if ( this->empty() ) return true;
 135
 136             typename std::vector<T>::const_iterator l_i = this->begin();
 137             assert(l_i != this->end());
 138
 139             ui32_t ItemSize = Writer->Remainder();
 140             if ( ! (*l_i).Archive(Writer) ) return false;
 141             ItemSize -= Writer->Remainder();
 142             Kumu::i2p<ui32_t>(KM_i32_BE(ItemSize), p);
 143             l_i++;
 144
 145             bool result = true;
 146             for ( ; l_i != this->end() && result; l_i++ )
 147               result = (*l_i).Archive(Writer);
 148
 149             return result;
 150           }
 151
 152           //
 153           void Dump(FILE* stream = 0, ui32_t depth = 0)
 154             {
 155               char identbuf[IdentBufferLen];
 156
 157               if ( stream == 0 )
 158                 stream = stderr;
 159
 160               typename std::vector<T>::iterator i = this->begin();
 161               for ( ; i != this->end(); i++ )
 162                 fprintf(stream, "  %s\n", (*i).EncodeString(identbuf, IdentBufferLen));
 163             }
 164         };
 165
 166       //
 167       template <class T>
 168         class Array : public std::list<T>, public Kumu::IArchive
 169         {
 170         public:
 171           Array() {}
 172           ~Array() {}
 173
 174           //
 175           virtual bool Unarchive(Kumu::MemIOReader* Reader)
 176             {
 177               bool result = true;
 178
 179               while ( Reader->Remainder() > 0 && result )
 180                 {
 181                   T Tmp;
 182                   result = Tmp.Unarchive(Reader);
 183                   push_back(Tmp);
 184                 }
 185
 186               return result;
 187             }
 188
 189           inline virtual bool HasValue() const { return ! this->empty(); }
 190
 191           //
 192           virtual bool Archive(Kumu::MemIOWriter* Writer) const {
 193             bool result = true;
 194             typename std::list<T>::const_iterator l_i = this->begin();
 195
 196             for ( ; l_i != this->end() && result; l_i++ )
 197               result = (*l_i).Archive(Writer);
 198
 199             return result;
 200           }
 201
 202           //
 203           void Dump(FILE* stream = 0, ui32_t depth = 0)
 204             {
 205               char identbuf[IdentBufferLen];
 206
 207               if ( stream == 0 )
 208                 stream = stderr;
 209
 210               typename std::list<T>::iterator i = this->begin();
 211               for ( ; i != this->end(); i++ )
 212                 fprintf(stream, "  %s\n", (*i).EncodeString(identbuf, IdentBufferLen));
 213             }
 214         };
 215
 216       //
 217       class Timestamp : public Kumu::IArchive
 218         {
 219         public:
 220           ui16_t Year;
 221           ui8_t  Month;
 222           ui8_t  Day;
 223           ui8_t  Hour;
 224           ui8_t  Minute;
 225           ui8_t  Second;
 226           ui8_t  Tick;
 227
 228           Timestamp();
 229           Timestamp(const Timestamp& rhs);
 230           Timestamp(const char* datestr);
 231           virtual ~Timestamp();
 232
 233           const Timestamp& operator=(const Timestamp& rhs);
 234           bool operator<(const Timestamp& rhs) const;
 235           bool operator==(const Timestamp& rhs) const;
 236           bool operator!=(const Timestamp& rhs) const;
 237
 238           // decode and set value from string formatted by EncodeAsString
 239           Result_t    SetFromString(const char* datestr);
 240
 241           // add the given number of days or hours to the timestamp value. Values less than zero
 242           // will cause the value to decrease
 243           void AddDays(i32_t);
 244           void AddHours(i32_t);
 245
 246           // Write the timestamp value to the given buffer in the form 2004-05-01 13:20:00.000
 247           // returns 0 if the buffer is smaller than DateTimeLen
 248           const char* EncodeString(char* str_buf, ui32_t buf_len) const;
 249
 250           //
 251           inline virtual bool Unarchive(Kumu::MemIOReader* Reader) {
 252             if ( ! Reader->ReadUi16BE(&Year) ) return false;
 253             if ( ! Reader->ReadRaw(&Month, 6) ) return false;
 254             return true;
 255           }
 256
 257           inline virtual bool HasValue() const { return true; }
 258
 259           //
 260           inline virtual bool Archive(Kumu::MemIOWriter* Writer) const {
 261             if ( ! Writer->WriteUi16BE(Year) ) return false;
 262             if ( ! Writer->WriteRaw(&Month, 6) ) return false;
 263             return true;
 264           }
 265         };
 266
 267       //
 268     class UTF16String : public std::string, public Kumu::IArchive
 269         {
 270         public:
 271           UTF16String() {}
 272           ~UTF16String() {}
 273
 274           const UTF16String& operator=(const char*);
 275           const UTF16String& operator=(const std::string&);
 276
 277           const char* EncodeString(char* str_buf, ui32_t buf_len) const;
 278           virtual bool Unarchive(Kumu::MemIOReader* Reader);
 279           inline virtual bool HasValue() const { return ! empty(); }
 280           virtual bool Archive(Kumu::MemIOWriter* Writer) const;
 281         };
 282
 283       //
 284       class Rational : public ASDCP::Rational, public Kumu::IArchive
 285         {
 286         public:
 287           Rational() {}
 288           ~Rational() {}
 289
 290           Rational(const Rational& rhs) {
 291             Numerator = rhs.Numerator;
 292             Denominator = rhs.Denominator;
 293           }
 294
 295           const Rational& operator=(const Rational& rhs) {
 296             Numerator = rhs.Numerator;
 297             Denominator = rhs.Denominator;
 298             return *this;
 299           }
 300
 301           Rational(const ASDCP::Rational& rhs) {
 302             Numerator = rhs.Numerator;
 303             Denominator = rhs.Denominator;
 304           }
 305
 306           const Rational& operator=(const ASDCP::Rational& rhs) {
 307             Numerator = rhs.Numerator;
 308             Denominator = rhs.Denominator;
 309             return *this;
 310           }
 311
 312           //
 313           inline const char* EncodeString(char* str_buf, ui32_t buf_len) const {
 314             snprintf(str_buf, buf_len, "%d/%d", Numerator, Denominator);
 315             return str_buf;
 316           }
 317
 318           inline virtual bool Unarchive(Kumu::MemIOReader* Reader) {
 319             if ( ! Reader->ReadUi32BE((ui32_t*)&Numerator) ) return false;
 320             if ( ! Reader->ReadUi32BE((ui32_t*)&Denominator) ) return false;
 321             return true;
 322           }
 323
 324           inline virtual bool HasValue() const { return true; }
 325
 326           inline virtual bool Archive(Kumu::MemIOWriter* Writer) const {
 327             if ( ! Writer->WriteUi32BE((ui32_t)Numerator) ) return false;
 328             if ( ! Writer->WriteUi32BE((ui32_t)Denominator) ) return false;
 329             return true;
 330           }
 331         };
 332
 333       //
 334       class VersionType : public Kumu::IArchive
 335         {
 336           ASDCP_NO_COPY_CONSTRUCT(VersionType);
 337
 338         public:
 339           enum Release_t { RL_UNKNOWN, RL_RELEASE, RL_DEVELOPMENT, RL_PATCHED, RL_BETA, RL_PRIVATE };
 340           ui16_t Major;
 341           ui16_t Minor;
 342           ui16_t Patch;
 343           ui16_t Build;
 344           ui16_t Release;
 345
 346           VersionType() : Major(0), Minor(0), Patch(0), Build(0), Release(RL_UNKNOWN) {}
 347           ~VersionType() {}
 348           void Dump(FILE* = 0);
 349
 350           const char* EncodeString(char* str_buf, ui32_t buf_len) const {
 351             snprintf(str_buf, buf_len, "%hu.%hu.%hu.%hur%hu", Major, Minor, Patch, Build, Release);
 352             return str_buf;
 353           }
 354
 355           virtual bool Unarchive(Kumu::MemIOReader* Reader) {
 356             if ( ! Reader->ReadUi16BE(&Major) ) return false;
 357             if ( ! Reader->ReadUi16BE(&Minor) ) return false;
 358             if ( ! Reader->ReadUi16BE(&Patch) ) return false;
 359             if ( ! Reader->ReadUi16BE(&Build) ) return false;
 360             ui16_t tmp_release;
 361             if ( ! Reader->ReadUi16BE(&tmp_release) ) return false;
 362             Release = (Release_t)tmp_release;
 363             return true;
 364           }
 365
 366           inline virtual bool HasValue() const { return true; }
 367
 368           virtual bool Archive(Kumu::MemIOWriter* Writer) const {
 369             if ( ! Writer->WriteUi16BE(Major) ) return false;
 370             if ( ! Writer->WriteUi16BE(Minor) ) return false;
 371             if ( ! Writer->WriteUi16BE(Patch) ) return false;
 372             if ( ! Writer->WriteUi16BE(Build) ) return false;
 373             if ( ! Writer->WriteUi16BE((ui16_t)(Release & 0x0000ffffL)) ) return false;
 374             return true;
 375           }
 376         };
 377
 378       //
 379       class Raw : public Kumu::ByteString
 380         {
 381           ASDCP_NO_COPY_CONSTRUCT(Raw);
 382
 383         public:
 384           Raw();
 385           ~Raw();
 386
 387           //
 388           virtual bool Unarchive(Kumu::MemIOReader* Reader);
 389           virtual bool Archive(Kumu::MemIOWriter* Writer) const;
 390           const char* EncodeString(char* str_buf, ui32_t buf_len) const;
 391         };
 392
 393     } // namespace MXF
 394 } // namespace ASDCP
 395
 396
 397 #endif //_MXFTYPES_H_
 398
 399 //
 400 // end MXFTypes.h
 401 //