/*
-Copyright (c) 2005-2006, John Hurst
+Copyright (c) 2005-2016, John Hurst
All rights reserved.
Redistribution and use in source and binary forms, with or without
\brief MXF objects
*/
+#include <KM_prng.h>
+#include <KM_tai.h>
#include "MXFTypes.h"
-#include "FortunaRNG.h"
+#include <KM_log.h>
+
+using Kumu::DefaultLogSink;
//------------------------------------------------------------------------------------------
//
+//
+bool
+ASDCP::UL::operator==(const UL& rhs) const
+{
+ if ( m_Value[0] == rhs.m_Value[0] &&
+ m_Value[1] == rhs.m_Value[1] &&
+ m_Value[2] == rhs.m_Value[2] &&
+ m_Value[3] == rhs.m_Value[3] &&
+ m_Value[4] == rhs.m_Value[4] &&
+ m_Value[5] == rhs.m_Value[5] &&
+ m_Value[6] == rhs.m_Value[6] &&
+ // m_Value[7] == rhs.m_Value[7] && // version is ignored when performing lookups
+ m_Value[8] == rhs.m_Value[8] &&
+ m_Value[9] == rhs.m_Value[9] &&
+ m_Value[10] == rhs.m_Value[10] &&
+ m_Value[11] == rhs.m_Value[11] &&
+ m_Value[12] == rhs.m_Value[12] &&
+ m_Value[13] == rhs.m_Value[13] &&
+ m_Value[14] == rhs.m_Value[14] &&
+ m_Value[15] == rhs.m_Value[15]
+ )
+ return true;
+
+ return false;
+}
+
+//
+bool
+ASDCP::UL::MatchIgnoreStream(const UL& rhs) const
+{
+ if ( m_Value[0] == rhs.m_Value[0] &&
+ m_Value[1] == rhs.m_Value[1] &&
+ m_Value[2] == rhs.m_Value[2] &&
+ m_Value[3] == rhs.m_Value[3] &&
+ m_Value[4] == rhs.m_Value[4] &&
+ m_Value[5] == rhs.m_Value[5] &&
+ m_Value[6] == rhs.m_Value[6] &&
+ // m_Value[7] == rhs.m_Value[7] && // version is ignored when performing lookups
+ m_Value[8] == rhs.m_Value[8] &&
+ m_Value[9] == rhs.m_Value[9] &&
+ m_Value[10] == rhs.m_Value[10] &&
+ m_Value[11] == rhs.m_Value[11] &&
+ m_Value[12] == rhs.m_Value[12] &&
+ m_Value[13] == rhs.m_Value[13] &&
+ m_Value[14] == rhs.m_Value[14]
+ // m_Value[15] == rhs.m_Value[15] // ignore stream number
+ )
+ return true;
+
+ return false;
+}
+
+//
+bool
+ASDCP::UL::MatchExact(const UL& rhs) const
+{
+ if ( m_Value[0] == rhs.m_Value[0] &&
+ m_Value[1] == rhs.m_Value[1] &&
+ m_Value[2] == rhs.m_Value[2] &&
+ m_Value[3] == rhs.m_Value[3] &&
+ m_Value[4] == rhs.m_Value[4] &&
+ m_Value[5] == rhs.m_Value[5] &&
+ m_Value[6] == rhs.m_Value[6] &&
+ m_Value[7] == rhs.m_Value[7] &&
+ m_Value[8] == rhs.m_Value[8] &&
+ m_Value[9] == rhs.m_Value[9] &&
+ m_Value[10] == rhs.m_Value[10] &&
+ m_Value[11] == rhs.m_Value[11] &&
+ m_Value[12] == rhs.m_Value[12] &&
+ m_Value[13] == rhs.m_Value[13] &&
+ m_Value[14] == rhs.m_Value[14] &&
+ m_Value[15] == rhs.m_Value[15]
+ )
+ return true;
+
+ return false;
+}
+
+const char*
+ASDCP::UL::EncodeString(char* str_buf, ui32_t buf_len) const
+{
+ if ( buf_len > 38 ) // room for dotted notation?
+ {
+ snprintf(str_buf, buf_len,
+ "%02x%02x%02x%02x.%02x%02x%02x%02x.%02x%02x%02x%02x.%02x%02x%02x%02x",
+ m_Value[0], m_Value[1], m_Value[2], m_Value[3],
+ m_Value[4], m_Value[5], m_Value[6], m_Value[7],
+ m_Value[8], m_Value[9], m_Value[10], m_Value[11],
+ m_Value[12], m_Value[13], m_Value[14], m_Value[15]
+ );
+
+ return str_buf;
+ }
+ else if ( buf_len > 32 ) // room for compact?
+ {
+ snprintf(str_buf, buf_len,
+ "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
+ m_Value[0], m_Value[1], m_Value[2], m_Value[3],
+ m_Value[4], m_Value[5], m_Value[6], m_Value[7],
+ m_Value[8], m_Value[9], m_Value[10], m_Value[11],
+ m_Value[12], m_Value[13], m_Value[14], m_Value[15]
+ );
+
+ return str_buf;
+ }
+
+ return 0;
+}
//
void
ASDCP::UMID::MakeUMID(int Type)
{
UUID AssetID;
- AssetID.GenRandomValue();
+ Kumu::GenRandomValue(AssetID);
MakeUMID(Type, AssetID);
}
m_Value[13] = m_Value[14] = m_Value[15] = 0;
memcpy(&m_Value[16], AssetID.Value(), AssetID.Size());
+ m_HasValue = true;
}
-// Write the timestamp value to the given buffer in the form 2004-05-01 13:20:00.000
+// Write the UMID value to the given buffer in the form
+// [00000000.0000.0000.00000000],00,00,00,00,00000000.0000.0000.00000000.00000000]
+// or
+// [00000000.0000.0000.00000000],00,00,00,00,00000000-0000-0000-0000-000000000000]
// returns 0 if the buffer is smaller than DateTimeLen
const char*
-ASDCP::UMID::ToString(char* str_buf) const
+ASDCP::UMID::EncodeString(char* str_buf, ui32_t buf_len) const
{
assert(str_buf);
- snprintf(str_buf, IdentBufferLen, "[%02x%02x%02x%02x.%02x%02x.%02x%02x.%02x%02x%02x%02x],%02x,%02x,%02x,%02x,",
+ snprintf(str_buf, buf_len, "[%02x%02x%02x%02x.%02x%02x%02x%02x.%02x%02x%02x%02x],%02x,%02x,%02x,%02x,",
m_Value[0], m_Value[1], m_Value[2], m_Value[3],
m_Value[4], m_Value[5], m_Value[6], m_Value[7],
m_Value[8], m_Value[9], m_Value[10], m_Value[11],
if ( ( m_Value[8] & 0x80 ) == 0 )
{
// half-swapped UL, use [bbaa9988.ddcc.ffee.00010203.04050607]
- snprintf(str_buf + offset, IdentBufferLen - offset,
- "[%02x%02x%02x%02x.%02x%02x.%02x%02x.%02x%02x%02x%02x.%02x%02x%02x%02x]",
+ snprintf(str_buf + offset, buf_len - offset,
+ "[%02x%02x%02x%02x.%02x%02x%02x%02x.%02x%02x%02x%02x.%02x%02x%02x%02x]",
m_Value[24], m_Value[25], m_Value[26], m_Value[27],
m_Value[28], m_Value[29], m_Value[30], m_Value[31],
m_Value[16], m_Value[17], m_Value[18], m_Value[19],
else
{
// UUID, use {00112233-4455-6677-8899-aabbccddeeff}
- snprintf(str_buf + offset, IdentBufferLen - offset,
+ snprintf(str_buf + offset, buf_len - offset,
"{%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
m_Value[16], m_Value[17], m_Value[18], m_Value[19],
m_Value[20], m_Value[21], m_Value[22], m_Value[23],
return str_buf;
}
+//------------------------------------------------------------------------------------------
//
-void
-ASDCP::UUID::GenRandomValue()
+
+//
+ASDCP::MXF::UTF16String::UTF16String(const char* sz)
{
- FortunaRNG RNG;
- RNG.FillRandom(m_Value, UUIDlen);
- m_Value[6] &= 0x0f; // clear bits 4-7
- m_Value[6] |= 0x40; // set UUID version
- m_Value[8] &= 0x3f; // clear bits 6&7
- m_Value[8] |= 0x80; // set bit 7
- // m_HasValue = true;
+ if ( sz != 0 && *sz != 0 )
+ {
+ this->assign(sz);
+ }
}
+ASDCP::MXF::UTF16String::UTF16String(const std::string& str)
+{
+ this->assign(str);
+}
-//------------------------------------------------------------------------------------------
//
-
const ASDCP::MXF::UTF16String&
ASDCP::MXF::UTF16String::operator=(const char* sz)
{
if ( sz == 0 || *sz == 0 )
- {
- m_length = 0;
- *m_buffer = 0;
- }
+ erase();
+
else
- {
- ui32_t len = xmin((ui32_t)strlen(sz), (IdentBufferLen - 1));
- m_length = len;
- memcpy(m_buffer, sz, m_length);
- m_buffer[m_length] = 0;
- }
+ this->assign(sz);
return *this;
}
-
//
-ASDCP::Result_t
-ASDCP::MXF::UTF16String::Unarchive(ASDCP::MemIOReader& Reader)
+const ASDCP::MXF::UTF16String&
+ASDCP::MXF::UTF16String::operator=(const std::string& str)
{
- const byte_t* p = Reader.CurrentData();
- m_length = Reader.Remainder();
- assert(m_length % 2 == 0);
- m_length /= 2;
- assert(IdentBufferLen >= m_length);
- ui32_t i = 0;
-
- for ( i = 0; i < m_length; i++ )
- m_buffer[i] = p[(i*2)+1];
-
- m_buffer[i] = 0;
-
- Reader.SkipOffset(m_length*2);
- return RESULT_OK;
+ this->assign(str);
+ return *this;
}
//
-ASDCP::Result_t
-ASDCP::MXF::UTF16String::Archive(ASDCP::MemIOWriter& Writer) const
+const char*
+ASDCP::MXF::UTF16String::EncodeString(char* str_buf, ui32_t buf_len) const
{
- byte_t* p = Writer.Data() + Writer.Size();
- ui32_t i = 0;
- memset(p, 0, (m_length*2)+2);
-
- for ( i = 0; i < m_length; i++ )
- p[(i*2)+1] = m_buffer[i];
-
- Writer.AddOffset(m_length * 2);
- return RESULT_OK;
+ ui32_t write_len = Kumu::xmin(buf_len - 1, (ui32_t)size());
+ strncpy(str_buf, c_str(), write_len);
+ str_buf[write_len] = 0;
+ return str_buf;
}
-
-//------------------------------------------------------------------------------------------
//
+bool
+ASDCP::MXF::UTF16String::Unarchive(Kumu::MemIOReader* Reader)
+{
+ erase();
+ const ui16_t* p = (ui16_t*)Reader->CurrentData();
+ ui32_t length = Reader->Remainder() / 2;
+ char mb_buf[MB_LEN_MAX];
-#ifdef WIN32
-
-#define TIMESTAMP_TO_SYSTIME(ts, t) \
- (t)->wYear = (ts).Year; /* year */ \
- (t)->wMonth = (ts).Month; /* month of year (1 - 12) */ \
- (t)->wDay = (ts).Day; /* day of month (1 - 31) */ \
- (t)->wHour = (ts).Hour; /* hours (0 - 23) */ \
- (t)->wMinute = (ts).Minute; /* minutes (0 - 59) */ \
- (t)->wSecond = (ts).Second; /* seconds (0 - 60) */ \
- (t)->wDayOfWeek = 0; \
- (t)->wMilliseconds = ((ts).Tick * 4);
-
-#define SYSTIME_TO_TIMESTAMP(t, ts) \
- (ts).Year = (t)->wYear; /* year */ \
- (ts).Month = (t)->wMonth; /* month of year (1 - 12) */ \
- (ts).Day = (t)->wDay; /* day of month (1 - 31) */ \
- (ts).Hour = (t)->wHour; /* hours (0 - 23) */ \
- (ts).Minute = (t)->wMinute; /* minutes (0 - 59) */ \
- (ts).Second = (t)->wSecond; /* seconds (0 - 60) */ \
- (ts).Tick = (t)->wMilliseconds / 4;
+ mbstate_t ps;
+ memset(&ps, 0, sizeof(mbstate_t));
-//
-ASDCP::MXF::Timestamp::Timestamp() :
- Year(0), Month(0), Day(0), Hour(0), Minute(0), Second(0), Tick(0)
-{
- SYSTEMTIME sys_time;
- GetSystemTime(&sys_time);
- SYSTIME_TO_TIMESTAMP(&sys_time, *this);
-}
+ for ( ui32_t i = 0; i < length; i++ )
+ {
+ int count = wcrtomb(mb_buf, KM_i16_BE(p[i]), &ps);
-//
-bool
-ASDCP::MXF::Timestamp::operator<(const Timestamp& rhs) const
-{
- SYSTEMTIME lhst, rhst;
- FILETIME lft, rft;
+ if ( count == -1 )
+ {
+ DefaultLogSink().Error("Unable to decode wide character 0x%04hx\n", p[i]);
+ return false;
+ }
- TIMESTAMP_TO_SYSTIME(*this, &lhst);
- TIMESTAMP_TO_SYSTIME(rhs, &rhst);
- SystemTimeToFileTime(&lhst, &lft);
- SystemTimeToFileTime(&rhst, &rft);
- return ( CompareFileTime(&lft, &rft) == -1 );
-}
+ assert(count <= MB_LEN_MAX);
+ mb_buf[count] = 0;
+ this->append(mb_buf);
+ }
-inline ui64_t
-seconds_to_ns100(ui32_t seconds)
-{
- return ((ui64_t)seconds * 10000000);
+ Reader->SkipOffset(length*2);
+ return true;
}
//
-void
-ASDCP::MXF::Timestamp::AddDays(i32_t days)
+bool
+ASDCP::MXF::UTF16String::Archive(Kumu::MemIOWriter* Writer) const
{
- SYSTEMTIME current_st;
- FILETIME current_ft;
- ULARGE_INTEGER current_ul;
-
- if ( days != 0 )
+ if ( size() > IdentBufferLen )
{
- TIMESTAMP_TO_SYSTIME(*this, ¤t_st);
- SystemTimeToFileTime(¤t_st, ¤t_ft);
- memcpy(¤t_ul, ¤t_ft, sizeof(current_ul));
- current_ul.QuadPart += ( seconds_to_ns100(86400) * (ui64_t)days );
- memcpy(¤t_ft, ¤t_ul, sizeof(current_ft));
- FileTimeToSystemTime(¤t_ft, ¤t_st);
- SYSTIME_TO_TIMESTAMP(¤t_st, *this);
+ DefaultLogSink().Error("String length exceeds maximum %u bytes\n", IdentBufferLen);
+ return false;
}
-}
-//
-void
-ASDCP::MXF::Timestamp::AddHours(i32_t hours)
-{
- SYSTEMTIME current_st;
- FILETIME current_ft;
- ULARGE_INTEGER current_ul;
+ const char* mbp = c_str();
+ wchar_t wcp;
+ ui32_t remainder = size();
+ ui32_t length = size();
+ ui32_t i = 0;
+
+ mbstate_t ps;
+ memset(&ps, 0, sizeof(mbstate_t));
- if ( hours != 0 )
+ while ( i < length )
{
- TIMESTAMP_TO_SYSTIME(*this, ¤t_st);
- SystemTimeToFileTime(¤t_st, ¤t_ft);
- memcpy(¤t_ul, ¤t_ft, sizeof(current_ul));
- current_ul.QuadPart += ( seconds_to_ns100(3600) * (ui64_t)hours );
- memcpy(¤t_ft, ¤t_ul, sizeof(current_ft));
- FileTimeToSystemTime(¤t_ft, ¤t_st);
- SYSTIME_TO_TIMESTAMP(¤t_st, *this);
- }
-}
+ int count = mbrtowc(&wcp, mbp+i, remainder, &ps);
-#else // WM_WIN32
+ if ( count == -1 )
+ {
+ DefaultLogSink().Error("Error decoding multi-byte sequence starting at offset %u\n", i);
+ return false;
+ }
+ else if ( count == 0 )
+ {
+ break;
+ }
-#include <time.h>
+ bool result = Writer->WriteUi16BE((ui16_t)wcp);
-#define TIMESTAMP_TO_TM(ts, t) \
- (t)->tm_year = (ts).Year - 1900; /* year - 1900 */ \
- (t)->tm_mon = (ts).Month - 1; /* month of year (0 - 11) */ \
- (t)->tm_mday = (ts).Day; /* day of month (1 - 31) */ \
- (t)->tm_hour = (ts).Hour; /* hours (0 - 23) */ \
- (t)->tm_min = (ts).Minute; /* minutes (0 - 59) */ \
- (t)->tm_sec = (ts).Second; /* seconds (0 - 60) */
+ if ( result == false )
+ {
+ DefaultLogSink().Error("No more space in memory IO writer\n");
+ return false;
+ }
-#define TM_TO_TIMESTAMP(t, ts) \
- (ts).Year = (t)->tm_year + 1900; /* year - 1900 */ \
- (ts).Month = (t)->tm_mon + 1; /* month of year (0 - 11) */ \
- (ts).Day = (t)->tm_mday; /* day of month (1 - 31) */ \
- (ts).Hour = (t)->tm_hour; /* hours (0 - 23) */ \
- (ts).Minute = (t)->tm_min; /* minutes (0 - 59) */ \
- (ts).Second = (t)->tm_sec; /* seconds (0 - 60) */
+ i += count;
+ remainder -= count;
+ }
-//
-ASDCP::MXF::Timestamp::Timestamp() :
- Year(0), Month(0), Day(0), Hour(0), Minute(0), Second(0)
-{
- time_t t_now = time(0);
- struct tm* now = gmtime(&t_now);
- TM_TO_TIMESTAMP(now, *this);
+ return true;
}
+//------------------------------------------------------------------------------------------
//
-bool
-ASDCP::MXF::Timestamp::operator<(const Timestamp& rhs) const
-{
- struct tm lhtm, rhtm;
- TIMESTAMP_TO_TM(*this, &lhtm);
- TIMESTAMP_TO_TM(rhs, &rhtm);
- return ( timegm(&lhtm) < timegm(&rhtm) );
-}
//
-void
-ASDCP::MXF::Timestamp::AddDays(i32_t days)
+ASDCP::MXF::ISO8String::ISO8String(const char* sz)
{
- struct tm current;
-
- if ( days != 0 )
+ if ( sz != 0 && *sz != 0 )
{
- TIMESTAMP_TO_TM(*this, ¤t);
- time_t adj_time = timegm(¤t);
- adj_time += 86400 * days;
- struct tm* now = gmtime(&adj_time);
- TM_TO_TIMESTAMP(now, *this);
+ this->assign(sz);
}
}
-//
-void
-ASDCP::MXF::Timestamp::AddHours(i32_t hours)
+ASDCP::MXF::ISO8String::ISO8String(const std::string& str)
{
- struct tm current;
-
- if ( hours != 0 )
- {
- TIMESTAMP_TO_TM(*this, ¤t);
- time_t adj_time = timegm(¤t);
- adj_time += 3600 * hours;
- struct tm* now = gmtime(&adj_time);
- TM_TO_TIMESTAMP(now, *this);
- }
+ this->assign(str);
}
-#endif // WM_WIN32
-
-ASDCP::MXF::Timestamp::Timestamp(const Timestamp& rhs)
+//
+const ASDCP::MXF::ISO8String&
+ASDCP::MXF::ISO8String::operator=(const char* sz)
{
- Year = rhs.Year;
- Month = rhs.Month;
- Day = rhs.Day;
- Hour = rhs.Hour;
- Minute = rhs.Minute;
- Second = rhs.Second;
-}
+ if ( sz == 0 || *sz == 0 )
+ erase();
-ASDCP::MXF::Timestamp::~Timestamp()
-{
+ else
+ this->assign(sz);
+
+ return *this;
}
//
-const ASDCP::MXF::Timestamp&
-ASDCP::MXF::Timestamp::operator=(const Timestamp& rhs)
+const ASDCP::MXF::ISO8String&
+ASDCP::MXF::ISO8String::operator=(const std::string& str)
{
- Year = rhs.Year;
- Month = rhs.Month;
- Day = rhs.Day;
- Hour = rhs.Hour;
- Minute = rhs.Minute;
- Second = rhs.Second;
+ this->assign(str);
return *this;
}
//
-bool
-ASDCP::MXF::Timestamp::operator==(const Timestamp& rhs) const
-{
- if ( Year == rhs.Year
- && Month == rhs.Month
- && Day == rhs.Day
- && Hour == rhs.Hour
- && Minute == rhs.Minute
- && Second == rhs.Second )
- return true;
-
- return false;
+const char*
+ASDCP::MXF::ISO8String::EncodeString(char* str_buf, ui32_t buf_len) const
+{
+ ui32_t write_len = Kumu::xmin(buf_len - 1, (ui32_t)size());
+ strncpy(str_buf, c_str(), write_len);
+ str_buf[write_len] = 0;
+ return str_buf;
}
//
bool
-ASDCP::MXF::Timestamp::operator!=(const Timestamp& rhs) const
-{
- if ( Year != rhs.Year
- || Month != rhs.Month
- || Day != rhs.Day
- || Hour != rhs.Hour
- || Minute != rhs.Minute
- || Second != rhs.Second )
- return true;
-
- return false;
+ASDCP::MXF::ISO8String::Unarchive(Kumu::MemIOReader* Reader)
+{
+ assign((char*)Reader->CurrentData(), Reader->Remainder());
+ return true;
}
//
-const char*
-ASDCP::MXF::Timestamp::ToString(char* str_buf) const
+bool
+ASDCP::MXF::ISO8String::Archive(Kumu::MemIOWriter* Writer) const
{
- // 2004-05-01 13:20:00.000
- snprintf(str_buf, IntBufferLen,
- "%04hu-%02hu-%02hu %02hu:%02hu:%02hu.000",
- Year, Month, Day, Hour, Minute, Second, Tick);
-
- return str_buf;
+ if ( size() > IdentBufferLen )
+ {
+ DefaultLogSink().Error("String length exceeds maximum %u bytes\n", IdentBufferLen);
+ return false;
+ }
+
+ return Writer->WriteRaw((const byte_t*)c_str(), size());
}
//------------------------------------------------------------------------------------------
TagValue Tag;
ui16_t pkt_len = 0;
- result = MemIOReader::ReadUi8(&Tag.a);
-
- if ( ASDCP_SUCCESS(result) )
- result = MemIOReader::ReadUi8(&Tag.b);
-
- if ( ASDCP_SUCCESS(result) )
- result = MemIOReader::ReadUi16BE(&pkt_len);
-
- if ( ASDCP_SUCCESS(result) )
- {
- m_ElementMap.insert(TagMap::value_type(Tag, ItemInfo(m_size, pkt_len)));
- result = SkipOffset(pkt_len);
- }
-
- if ( ASDCP_FAILURE(result) )
- {
- DefaultLogSink().Error("Malformed Set\n");
- m_ElementMap.clear();
- break;
- }
+ if ( MemIOReader::ReadUi8(&Tag.a) )
+ if ( MemIOReader::ReadUi8(&Tag.b) )
+ if ( MemIOReader::ReadUi16BE(&pkt_len) )
+ {
+ m_ElementMap.insert(TagMap::value_type(Tag, ItemInfo(m_size, pkt_len)));
+ if ( SkipOffset(pkt_len) )
+ continue;;
+ }
+
+ DefaultLogSink().Error("Malformed Set\n");
+ m_ElementMap.clear();
+ result = RESULT_KLV_CODING(__LINE__, __FILE__);
}
}
{
if ( Entry.tag.a == 0 )
{
- DefaultLogSink().Info("No such UL in this TL list: %s (%02x %02x)\n",
- Entry.name, Entry.tag.a, Entry.tag.b);
+ // DefaultLogSink().Debug("No such UL in this TL list: %s (%02x %02x)\n",
+ // Entry.name, Entry.tag.a, Entry.tag.b);
return false;
}
return true;
}
- DefaultLogSink().Info("Not Found (%02x %02x): %s\n", TmpTag.a, TmpTag.b, Entry.name);
+ // DefaultLogSink().Debug("Not Found (%02x %02x): %s\n", TmpTag.a, TmpTag.b, Entry.name);
return false;
}
//
ASDCP::Result_t
-ASDCP::MXF::TLVReader::ReadObject(const MDDEntry& Entry, IArchive* Object)
+ASDCP::MXF::TLVReader::ReadObject(const MDDEntry& Entry, Kumu::IArchive* Object)
{
ASDCP_TEST_NULL(Object);
if ( FindTL(Entry) )
{
if ( m_size < m_capacity ) // don't try to unarchive an empty item
- return Object->Unarchive(*this);
+ {
+ // TODO: carry on if uachive fails
+ return Object->Unarchive(this) ? RESULT_OK : RESULT_FALSE(__LINE__, __FILE__);
+ }
}
return RESULT_FALSE;
ASDCP_TEST_NULL(value);
if ( FindTL(Entry) )
- return MemIOReader::ReadUi8(value);
+ return MemIOReader::ReadUi8(value) ? RESULT_OK : RESULT_FALSE(__LINE__, __FILE__);
return RESULT_FALSE;
}
ASDCP_TEST_NULL(value);
if ( FindTL(Entry) )
- return MemIOReader::ReadUi16BE(value);
+ return MemIOReader::ReadUi16BE(value) ? RESULT_OK : RESULT_FALSE(__LINE__, __FILE__);
return RESULT_FALSE;
}
ASDCP_TEST_NULL(value);
if ( FindTL(Entry) )
- return MemIOReader::ReadUi32BE(value);
+ return MemIOReader::ReadUi32BE(value) ? RESULT_OK : RESULT_FALSE(__LINE__, __FILE__);
return RESULT_FALSE;
}
ASDCP_TEST_NULL(value);
if ( FindTL(Entry) )
- return MemIOReader::ReadUi64BE(value);
+ return MemIOReader::ReadUi64BE(value) ? RESULT_OK : RESULT_FALSE(__LINE__, __FILE__);
return RESULT_FALSE;
}
{
if ( m_Lookup == 0 )
{
- DefaultLogSink().Error("No Primer object available\n");
+ DefaultLogSink().Error("No Primer object available.\n");
return RESULT_FAIL;
}
return RESULT_FAIL;
}
- Result_t result = MemIOWriter::WriteUi8(TmpTag.a);
- if ( ASDCP_SUCCESS(result) ) MemIOWriter::WriteUi8(TmpTag.b);
-
- return result;
+ if ( ! MemIOWriter::WriteUi8(TmpTag.a) ) return RESULT_KLV_CODING(__LINE__, __FILE__);
+ if ( ! MemIOWriter::WriteUi8(TmpTag.b) ) return RESULT_KLV_CODING(__LINE__, __FILE__);
+ return RESULT_OK;
}
//
ASDCP::Result_t
-ASDCP::MXF::TLVWriter::WriteObject(const MDDEntry& Entry, IArchive* Object)
+ASDCP::MXF::TLVWriter::WriteObject(const MDDEntry& Entry, Kumu::IArchive* Object)
{
ASDCP_TEST_NULL(Object);
Result_t result = WriteTag(Entry);
- // write a temp length
- byte_t* l_p = CurrentData();
-
- if ( ASDCP_SUCCESS(result) )
- MemIOWriter::WriteUi16BE(0);
-
if ( ASDCP_SUCCESS(result) )
{
- ui32_t before = Size();
- result = Object->Archive(*this);
+ // write a temp length
+ byte_t* l_p = CurrentData();
- if ( ASDCP_SUCCESS(result) )
- i2p<ui16_t>(ASDCP_i16_BE( Size() - before), l_p);
+ if ( ! MemIOWriter::WriteUi16BE(0) ) return RESULT_KLV_CODING(__LINE__, __FILE__);
+
+ ui32_t before = Length();
+ if ( ! Object->Archive(this) ) return RESULT_KLV_CODING(__LINE__, __FILE__);
+ if ( (Length() - before) > 0xffffL ) return RESULT_KLV_CODING(__LINE__, __FILE__);
+ Kumu::i2p<ui16_t>(KM_i16_BE(Length() - before), l_p);
}
return result;
{
ASDCP_TEST_NULL(value);
Result_t result = WriteTag(Entry);
- if ( ASDCP_SUCCESS(result) ) MemIOWriter::WriteUi16BE(sizeof(ui8_t));
- if ( ASDCP_SUCCESS(result) ) MemIOWriter::WriteUi8(*value);
+
+ if ( ASDCP_SUCCESS(result) )
+ {
+ if ( ! MemIOWriter::WriteUi16BE(sizeof(ui8_t)) ) return RESULT_KLV_CODING(__LINE__, __FILE__);
+ if ( ! MemIOWriter::WriteUi8(*value) ) return RESULT_KLV_CODING(__LINE__, __FILE__);
+ }
+
return result;
}
{
ASDCP_TEST_NULL(value);
Result_t result = WriteTag(Entry);
- if ( ASDCP_SUCCESS(result) ) MemIOWriter::WriteUi16BE(sizeof(ui16_t));
- if ( ASDCP_SUCCESS(result) ) MemIOWriter::WriteUi16BE(*value);
+
+ if ( KM_SUCCESS(result) )
+ {
+ if ( ! MemIOWriter::WriteUi16BE(sizeof(ui16_t)) ) return RESULT_KLV_CODING(__LINE__, __FILE__);
+ if ( ! MemIOWriter::WriteUi16BE(*value) ) return RESULT_KLV_CODING(__LINE__, __FILE__);
+ }
+
return result;
}
{
ASDCP_TEST_NULL(value);
Result_t result = WriteTag(Entry);
- if ( ASDCP_SUCCESS(result) ) MemIOWriter::WriteUi16BE(sizeof(ui32_t));
- if ( ASDCP_SUCCESS(result) ) MemIOWriter::WriteUi32BE(*value);
+
+ if ( KM_SUCCESS(result) )
+ {
+ if ( ! MemIOWriter::WriteUi16BE(sizeof(ui32_t)) ) return RESULT_KLV_CODING(__LINE__, __FILE__);
+ if ( ! MemIOWriter::WriteUi32BE(*value) ) return RESULT_KLV_CODING(__LINE__, __FILE__);
+ }
+
return result;
}
{
ASDCP_TEST_NULL(value);
Result_t result = WriteTag(Entry);
- if ( ASDCP_SUCCESS(result) ) MemIOWriter::WriteUi16BE(sizeof(ui64_t));
- if ( ASDCP_SUCCESS(result) ) MemIOWriter::WriteUi64BE(*value);
+
+ if ( KM_SUCCESS(result) )
+ {
+ if ( ! MemIOWriter::WriteUi16BE(sizeof(ui64_t)) ) return RESULT_KLV_CODING(__LINE__, __FILE__);
+ if ( ! MemIOWriter::WriteUi64BE(*value) ) return RESULT_KLV_CODING(__LINE__, __FILE__);
+ }
+
return result;
}
//----------------------------------------------------------------------------------------------------
//
-ASDCP::MXF::Raw::Raw()
+
+ASDCP::MXF::RGBALayout::RGBALayout()
{
- Capacity(256);
+ memset(m_value, 0, RGBAValueLength);
}
-ASDCP::MXF::Raw::~Raw()
+ASDCP::MXF::RGBALayout::RGBALayout(const byte_t* value)
{
+ memcpy(m_value, value, RGBAValueLength);
}
-//
-ASDCP::Result_t
-ASDCP::MXF::Raw::Unarchive(ASDCP::MemIOReader& Reader)
+ASDCP::MXF::RGBALayout::~RGBALayout()
{
- ui32_t payload_size = Reader.Remainder();
+}
- if ( payload_size == 0 )
- return RESULT_OK;
+static char
+get_char_for_code(byte_t c)
+{
+ for ( int i = 0; ASDCP::MXF::RGBALayoutTable[i].code != 0; ++i )
+ {
+ if ( ASDCP::MXF::RGBALayoutTable[i].code == c )
+ {
+ return ASDCP::MXF::RGBALayoutTable[i].symbol;
+ }
+ }
- Result_t result = Capacity(payload_size);
+ return '_';
+}
- if ( ASDCP_SUCCESS(result) )
+//
+const char*
+ASDCP::MXF::RGBALayout::EncodeString(char* buf, ui32_t buf_len) const
+{
+ std::string tmp_str;
+ char tmp_buf[64];
+
+ for ( int i = 0; i < RGBAValueLength && m_value[i] != 0; i += 2 )
{
- memcpy(Data(), Reader.CurrentData(), payload_size);
- Size(payload_size);
+ snprintf(tmp_buf, 64, "%c(%d)", get_char_for_code(m_value[i]), m_value[i+1]);
+
+ if ( ! tmp_str.empty() )
+ {
+ tmp_str += " ";
+ }
+
+ tmp_str += tmp_buf;
}
- return result;
+ assert(tmp_str.size() < buf_len);
+ strncpy(buf, tmp_str.c_str(), tmp_str.size());
+ return buf;
}
+
+//----------------------------------------------------------------------------------------------------
//
-ASDCP::Result_t
-ASDCP::MXF::Raw::Archive(ASDCP::MemIOWriter& Writer) const
+
+ASDCP::MXF::Raw::Raw()
+{
+ Capacity(256);
+}
+
+ASDCP::MXF::Raw::~Raw()
+{
+}
+
+//
+bool
+ASDCP::MXF::Raw::Unarchive(Kumu::MemIOReader* Reader)
+{
+ ui32_t payload_size = Reader->Remainder();
+ if ( payload_size == 0 ) return false;
+ if ( KM_FAILURE(Capacity(payload_size)) ) return false;
+
+ memcpy(Data(), Reader->CurrentData(), payload_size);
+ Length(payload_size);
+ return true;
+}
+
+//
+bool
+ASDCP::MXF::Raw::Archive(Kumu::MemIOWriter* Writer) const
{
- return Writer.WriteRaw(RoData(), Size());
+ return Writer->WriteRaw(RoData(), Length());
}
//
const char*
-ASDCP::MXF::Raw::ToString(char* str_buf) const
+ASDCP::MXF::Raw::EncodeString(char* str_buf, ui32_t buf_len) const
{
*str_buf = 0;
- bin2hex(RoData(), Size(), str_buf, IdentBufferLen);
- snprintf(str_buf, IdentBufferLen, "%s\n", str_buf);
+ Kumu::bin2hex(RoData(), Length(), str_buf, buf_len);
return str_buf;
}
projects / asdcplib.git / blobdiff