2 Copyright (c) 2005-2012, John Hurst
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions
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.
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.
28 \version $Id: MXFTypes.h,v 1.29 2012/02/21 02:09:31 jhurst Exp $
41 // used with TLVReader::Read*
43 // these are used below to manufacture arguments
44 #define OBJ_READ_ARGS(s,l) m_Dict->Type(MDD_##s##_##l), &l
45 #define OBJ_WRITE_ARGS(s,l) m_Dict->Type(MDD_##s##_##l), &l
46 #define OBJ_TYPE_ARGS(t) m_Dict->Type(MDD_##t).ul
53 typedef std::pair<ui32_t, ui32_t> ItemInfo;
54 typedef std::map<TagValue, ItemInfo> TagMap;
57 class TLVReader : public Kumu::MemIOReader
61 IPrimerLookup* m_Lookup;
64 ASDCP_NO_COPY_CONSTRUCT(TLVReader);
65 bool FindTL(const MDDEntry&);
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*);
77 class TLVWriter : public Kumu::MemIOWriter
81 IPrimerLookup* m_Lookup;
84 ASDCP_NO_COPY_CONSTRUCT(TLVWriter);
85 Result_t WriteTag(const MDDEntry&);
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*);
98 class Batch : public std::vector<T>, public Kumu::IArchive
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;
110 if ( ( ItemCount > 65536 ) || ( ItemSize > 1024 ) )
114 for ( ui32_t i = 0; i < ItemCount && result; i++ )
117 result = Tmp.Unarchive(Reader);
120 this->push_back(Tmp);
126 inline virtual bool HasValue() const { return ! this->empty(); }
128 virtual ui32_t ArchiveLength() const {
129 ui32_t arch_size = sizeof(ui32_t)*2;
131 typename std::vector<T>::const_iterator l_i = this->begin();
132 assert(l_i != this->end());
134 for ( ; l_i != this->end(); l_i++ )
135 arch_size += l_i->ArchiveLength();
141 virtual bool Archive(Kumu::MemIOWriter* Writer) const {
142 if ( ! Writer->WriteUi32BE(this->size()) ) return false;
143 byte_t* p = Writer->CurrentData();
145 if ( ! Writer->WriteUi32BE(0) ) return false;
146 if ( this->empty() ) return true;
148 typename std::vector<T>::const_iterator l_i = this->begin();
149 assert(l_i != this->end());
151 ui32_t ItemSize = Writer->Remainder();
152 if ( ! (*l_i).Archive(Writer) ) return false;
153 ItemSize -= Writer->Remainder();
154 Kumu::i2p<ui32_t>(KM_i32_BE(ItemSize), p);
158 for ( ; l_i != this->end() && result; l_i++ )
159 result = (*l_i).Archive(Writer);
165 void Dump(FILE* stream = 0, ui32_t = 0)
167 char identbuf[IdentBufferLen];
172 typename std::vector<T>::iterator i = this->begin();
173 for ( ; i != this->end(); i++ )
174 fprintf(stream, " %s\n", (*i).EncodeString(identbuf, IdentBufferLen));
180 class Array : public std::list<T>, public Kumu::IArchive
187 virtual bool Unarchive(Kumu::MemIOReader* Reader)
191 while ( Reader->Remainder() > 0 && result )
194 result = Tmp.Unarchive(Reader);
195 this->push_back(Tmp);
201 inline virtual bool HasValue() const { return ! this->empty(); }
203 virtual ui32_t ArchiveLength() const {
204 ui32_t arch_size = 0;
206 typename std::list<T>::const_iterator l_i = this->begin();
208 for ( ; l_i != this->end(); l_i++ )
209 arch_size += l_i->ArchiveLength();
215 virtual bool Archive(Kumu::MemIOWriter* Writer) const {
217 typename std::list<T>::const_iterator l_i = this->begin();
219 for ( ; l_i != this->end() && result; l_i++ )
220 result = (*l_i).Archive(Writer);
226 void Dump(FILE* stream = 0, ui32_t = 0)
228 char identbuf[IdentBufferLen];
233 typename std::list<T>::iterator i = this->begin();
234 for ( ; i != this->end(); i++ )
235 fprintf(stream, " %s\n", (*i).EncodeString(identbuf, IdentBufferLen));
240 class ISO8String : public std::string, public Kumu::IArchive
246 const ISO8String& operator=(const char*);
247 const ISO8String& operator=(const std::string&);
249 const char* EncodeString(char* str_buf, ui32_t buf_len) const;
250 inline virtual bool HasValue() const { return ! empty(); }
251 inline virtual ui32_t ArchiveLength() const { return sizeof(ui32_t) + size(); }
252 virtual bool Unarchive(Kumu::MemIOReader* Reader);
253 virtual bool Archive(Kumu::MemIOWriter* Writer) const;
257 class UTF16String : public std::string, public Kumu::IArchive
263 const UTF16String& operator=(const char*);
264 const UTF16String& operator=(const std::string&);
266 const char* EncodeString(char* str_buf, ui32_t buf_len) const;
267 inline virtual bool HasValue() const { return ! empty(); }
268 inline virtual ui32_t ArchiveLength() const { return sizeof(ui32_t) + size(); }
269 virtual bool Unarchive(Kumu::MemIOReader* Reader);
270 virtual bool Archive(Kumu::MemIOWriter* Writer) const;
274 class Rational : public ASDCP::Rational, public Kumu::IArchive
280 Rational(const Rational& rhs) : ASDCP::Rational(), IArchive() {
281 Numerator = rhs.Numerator;
282 Denominator = rhs.Denominator;
285 const Rational& operator=(const Rational& rhs) {
286 Numerator = rhs.Numerator;
287 Denominator = rhs.Denominator;
291 Rational(const ASDCP::Rational& rhs) {
292 Numerator = rhs.Numerator;
293 Denominator = rhs.Denominator;
296 const Rational& operator=(const ASDCP::Rational& rhs) {
297 Numerator = rhs.Numerator;
298 Denominator = rhs.Denominator;
303 inline const char* EncodeString(char* str_buf, ui32_t buf_len) const {
304 snprintf(str_buf, buf_len, "%d/%d", Numerator, Denominator);
308 inline virtual bool Unarchive(Kumu::MemIOReader* Reader) {
309 if ( ! Reader->ReadUi32BE((ui32_t*)&Numerator) ) return false;
310 if ( ! Reader->ReadUi32BE((ui32_t*)&Denominator) ) return false;
314 inline virtual bool HasValue() const { return true; }
315 inline virtual ui32_t ArchiveLength() const { return sizeof(ui32_t)*2; }
317 inline virtual bool Archive(Kumu::MemIOWriter* Writer) const {
318 if ( ! Writer->WriteUi32BE((ui32_t)Numerator) ) return false;
319 if ( ! Writer->WriteUi32BE((ui32_t)Denominator) ) return false;
325 class VersionType : public Kumu::IArchive
328 enum Release_t { RL_UNKNOWN, RL_RELEASE, RL_DEVELOPMENT, RL_PATCHED, RL_BETA, RL_PRIVATE };
335 VersionType() : Major(0), Minor(0), Patch(0), Build(0), Release(RL_UNKNOWN) {}
336 VersionType(const VersionType& rhs) { Copy(rhs); }
337 virtual ~VersionType() {}
339 const VersionType& operator=(const VersionType& rhs) { Copy(rhs); return *this; }
340 void Copy(const VersionType& rhs) {
345 Release = rhs.Release;
348 void Dump(FILE* = 0);
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);
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;
361 if ( ! Reader->ReadUi16BE(&tmp_release) ) return false;
362 Release = (Release_t)tmp_release;
366 inline virtual bool HasValue() const { return true; }
367 inline virtual ui32_t ArchiveLength() const { return sizeof(ui16_t)*5; }
369 virtual bool Archive(Kumu::MemIOWriter* Writer) const {
370 if ( ! Writer->WriteUi16BE(Major) ) return false;
371 if ( ! Writer->WriteUi16BE(Minor) ) return false;
372 if ( ! Writer->WriteUi16BE(Patch) ) return false;
373 if ( ! Writer->WriteUi16BE(Build) ) return false;
374 if ( ! Writer->WriteUi16BE((ui16_t)(Release & 0x0000ffffL)) ) return false;
380 class Raw : public Kumu::ByteString
384 Raw(const Raw& rhs) : Kumu::ByteString () { Copy(rhs); }
387 const Raw& operator=(const Raw& rhs) { Copy(rhs); return *this; }
388 void Copy(const Raw& rhs) {
389 if ( KM_SUCCESS(Capacity(rhs.Length())) )
396 virtual bool Unarchive(Kumu::MemIOReader* Reader);
397 virtual bool Archive(Kumu::MemIOWriter* Writer) const;
398 const char* EncodeString(char* str_buf, ui32_t buf_len) const;
405 #endif //_MXFTYPES_H_