src/MXFTypes.cpp

   1
   2 #include "MXFTypes.h"
   3
   4 //------------------------------------------------------------------------------------------
   5 //
   6
   7 //
   8 ASDCP::Result_t
   9 ASDCP::MXF::UTF16String::ReadFrom(ASDCP::MemIOReader& Reader)
  10 {
  11   const byte_t* p = Reader.Data() + Reader.Offset();
  12   /// cheating - for all use cases, we know the previous two bytes are the length
  13   m_length = ASDCP_i16_BE(cp2i<ui16_t>(p-2));
  14   assert(m_length % 2 == 0);
  15   m_length /= 2;
  16   assert(IdentBufferLen >= m_length);
  17   ui32_t i = 0;
  18
  19   for ( i = 0; i < m_length; i++ )
  20     m_buffer[i] = p[(i*2)+1];
  21
  22   m_buffer[i] = 0;
  23
  24   Reader.SkipOffset(m_length*2);
  25   return RESULT_OK;
  26 }
  27
  28 //
  29 ASDCP::Result_t
  30 ASDCP::MXF::UTF16String::WriteTo(ASDCP::MemIOWriter& Writer)
  31 {
  32   byte_t* p = Writer.Data() + Writer.Size();
  33   ui32_t i = 0;
  34   m_length = strlen(m_buffer);
  35   memset(p, 0, m_length*2);
  36
  37   for ( i = 0; i < m_length; i++ )
  38     p[(i*2)+1] = m_buffer[i];
  39
  40   m_buffer[i] = 0;
  41
  42   Writer.AddOffset(m_length*2);
  43   return RESULT_OK;
  44 }
  45
  46
  47 //------------------------------------------------------------------------------------------
  48 //
  49
  50 ASDCP::MXF::TLVReader::TLVReader(const byte_t* p, ui32_t c, IPrimerLookup* PrimerLookup) :
  51   MemIOReader(p, c), m_Lookup(PrimerLookup)
  52 {
  53   Result_t result = RESULT_OK;
  54
  55   while ( Remainder() > 0 && ASDCP_SUCCESS(result) )
  56     {
  57       TagValue Tag;
  58       ui16_t pkt_len = 0;
  59
  60       result = MemIOReader::ReadUi8(&Tag.a);
  61
  62       if ( ASDCP_SUCCESS(result) )
  63         result = MemIOReader::ReadUi8(&Tag.b);
  64
  65       if ( ASDCP_SUCCESS(result) )
  66         result = MemIOReader::ReadUi16BE(&pkt_len);
  67
  68       if ( ASDCP_SUCCESS(result) )
  69         {
  70           m_ElementMap.insert(TagMap::value_type(Tag, ItemInfo(m_size, pkt_len)));
  71           result = SkipOffset(pkt_len);
  72         }
  73
  74       if ( ASDCP_FAILURE(result) )
  75         {
  76           DefaultLogSink().Error("Malformed Set\n");
  77           m_ElementMap.clear();
  78           break;
  79         }
  80     }
  81 }
  82
  83 //
  84 bool
  85 ASDCP::MXF::TLVReader::FindTL(const MDDEntry& Entry)
  86 {
  87   if ( m_Lookup == 0 )
  88     {
  89       fprintf(stderr, "No Lookup service\n");
  90       return false;
  91     }
  92
  93   TagValue TmpTag;
  94
  95   if ( m_Lookup->TagForKey(Entry.ul, TmpTag) != RESULT_OK )
  96     {
  97       if ( Entry.tag.a == 0 )
  98         {
  99           DefaultLogSink().Error("No such UL in this TL list: %s (%02x %02x)\n",
 100                                  Entry.name, Entry.tag.a, Entry.tag.b);
 101           return false;
 102         }
 103
 104       TmpTag = Entry.tag;
 105     }
 106
 107   TagMap::iterator e_i = m_ElementMap.find(TmpTag);
 108
 109   if ( e_i != m_ElementMap.end() )
 110     {
 111       m_size = (*e_i).second.first;
 112       m_capacity = m_size + (*e_i).second.second;
 113       return true;
 114     }
 115
 116   //  DefaultLogSink().Warn("Not Found (%02x %02x): %s\n", TmpTag.a, TmpTag.b, Entry.name);
 117   return false;
 118 }
 119
 120 //
 121 ASDCP::Result_t
 122 ASDCP::MXF::TLVReader::ReadObject(const MDDEntry& Entry, IArchive* Object)
 123 {
 124   ASDCP_TEST_NULL(Object);
 125
 126   if ( FindTL(Entry) )
 127     return Object->ReadFrom(*this);
 128
 129   return RESULT_FALSE;
 130 }
 131
 132 //
 133 ASDCP::Result_t
 134 ASDCP::MXF::TLVReader::ReadUi8(const MDDEntry& Entry, ui8_t* value)
 135 {
 136   ASDCP_TEST_NULL(value);
 137
 138   if ( FindTL(Entry) )
 139     return MemIOReader::ReadUi8(value);
 140
 141   return RESULT_FALSE;
 142 }
 143
 144 //
 145 ASDCP::Result_t
 146 ASDCP::MXF::TLVReader::ReadUi16(const MDDEntry& Entry, ui16_t* value)
 147 {
 148   ASDCP_TEST_NULL(value);
 149
 150   if ( FindTL(Entry) )
 151     return MemIOReader::ReadUi16BE(value);
 152
 153   return RESULT_FALSE;
 154 }
 155
 156 //
 157 ASDCP::Result_t
 158 ASDCP::MXF::TLVReader::ReadUi32(const MDDEntry& Entry, ui32_t* value)
 159 {
 160   ASDCP_TEST_NULL(value);
 161
 162   if ( FindTL(Entry) )
 163     return MemIOReader::ReadUi32BE(value);
 164
 165   return RESULT_FALSE;
 166 }
 167
 168 //
 169 ASDCP::Result_t
 170 ASDCP::MXF::TLVReader::ReadUi64(const MDDEntry& Entry, ui64_t* value)
 171 {
 172   ASDCP_TEST_NULL(value);
 173
 174   if ( FindTL(Entry) )
 175     return MemIOReader::ReadUi64BE(value);
 176
 177   return RESULT_FALSE;
 178 }
 179
 180 //------------------------------------------------------------------------------------------
 181 //
 182
 183 ASDCP::MXF::TLVWriter::TLVWriter(byte_t* p, ui32_t c, IPrimerLookup* PrimerLookup) :
 184   MemIOWriter(p, c), m_Lookup(PrimerLookup)
 185 {
 186   assert(c > 3);
 187 }
 188
 189 //
 190 ASDCP::Result_t
 191 ASDCP::MXF::TLVWriter::WriteTag(const MDDEntry& Entry)
 192 {
 193   TagValue TmpTag;
 194
 195   if ( m_Lookup == 0 )
 196     {
 197       DefaultLogSink().Error("No Primer object available\n");
 198       return RESULT_FAIL;
 199     }
 200
 201   if ( m_Lookup->InsertTag(Entry.ul, TmpTag) != RESULT_OK )
 202     {
 203       DefaultLogSink().Error("No tag for entry %s\n", Entry.name);
 204       return RESULT_FAIL;
 205     }
 206
 207   Result_t result = MemIOWriter::WriteUi8(TmpTag.a);
 208   if ( ASDCP_SUCCESS(result) ) MemIOWriter::WriteUi8(TmpTag.b);
 209
 210   return result;
 211 }
 212
 213 //
 214 ASDCP::Result_t
 215 ASDCP::MXF::TLVWriter::WriteObject(const MDDEntry& Entry, IArchive* Object)
 216 {
 217   ASDCP_TEST_NULL(Object);
 218   Result_t result = WriteTag(Entry);
 219
 220   // write a temp length
 221   byte_t* l_p = CurrentData();
 222
 223   if ( ASDCP_SUCCESS(result) )
 224     MemIOWriter::WriteUi16BE(0);
 225
 226   if ( ASDCP_SUCCESS(result) )
 227     {
 228       ui32_t before = Size();
 229       result = Object->WriteTo(*this);
 230
 231       if ( ASDCP_SUCCESS(result) )
 232         i2p<ui16_t>(ASDCP_i16_BE( Size() - before), l_p);
 233     }
 234
 235   return result;
 236 }
 237
 238 //
 239 ASDCP::Result_t
 240 ASDCP::MXF::TLVWriter::WriteUi8(const MDDEntry& Entry, ui8_t* value)
 241 {
 242   ASDCP_TEST_NULL(value);
 243   Result_t result = WriteTag(Entry);
 244   if ( ASDCP_SUCCESS(result) ) MemIOWriter::WriteUi16BE(sizeof(ui8_t));
 245   if ( ASDCP_SUCCESS(result) ) MemIOWriter::WriteUi8(*value);
 246   return result;
 247 }
 248
 249 //
 250 ASDCP::Result_t
 251 ASDCP::MXF::TLVWriter::WriteUi16(const MDDEntry& Entry, ui16_t* value)
 252 {
 253   ASDCP_TEST_NULL(value);
 254   Result_t result = WriteTag(Entry);
 255   if ( ASDCP_SUCCESS(result) ) MemIOWriter::WriteUi16BE(sizeof(ui16_t));
 256   if ( ASDCP_SUCCESS(result) ) MemIOWriter::WriteUi8(*value);
 257   return result;
 258 }
 259
 260 //
 261 ASDCP::Result_t
 262 ASDCP::MXF::TLVWriter::WriteUi32(const MDDEntry& Entry, ui32_t* value)
 263 {
 264   ASDCP_TEST_NULL(value);
 265   Result_t result = WriteTag(Entry);
 266   if ( ASDCP_SUCCESS(result) ) MemIOWriter::WriteUi16BE(sizeof(ui32_t));
 267   if ( ASDCP_SUCCESS(result) ) MemIOWriter::WriteUi8(*value);
 268   return result;
 269 }
 270
 271 //
 272 ASDCP::Result_t
 273 ASDCP::MXF::TLVWriter::WriteUi64(const MDDEntry& Entry, ui64_t* value)
 274 {
 275   ASDCP_TEST_NULL(value);
 276   Result_t result = WriteTag(Entry);
 277   if ( ASDCP_SUCCESS(result) ) MemIOWriter::WriteUi16BE(sizeof(ui64_t));
 278   if ( ASDCP_SUCCESS(result) ) MemIOWriter::WriteUi8(*value);
 279   return result;
 280 }
 281
 282 //
 283 // end
 284 //