mirror of https://github.com/f4exb/sdrangel.git
727 lines
15 KiB
C++
727 lines
15 KiB
C++
#include <stdint.h>
|
|
#include "util/simpleserializer.h"
|
|
|
|
#if __WORDSIZE == 64
|
|
#define PRINTF_FORMAT_S32 "%d"
|
|
#define PRINTF_FORMAT_U32 "%u"
|
|
#define PRINTF_FORMAT_S64 "%d"
|
|
#define PRINTF_FORMAT_U64 "%u"
|
|
#else
|
|
#define PRINTF_FORMAT_S32 "%d"
|
|
#define PRINTF_FORMAT_U32 "%u"
|
|
#define PRINTF_FORMAT_S64 "%lld"
|
|
#define PRINTF_FORMAT_U64 "%llu"
|
|
#endif
|
|
|
|
template <bool> struct Assert { };
|
|
typedef Assert<(bool(sizeof(float) == 4))> float_must_be_32_bits[bool(sizeof(float) == 4) ? 1 : -1];
|
|
typedef Assert<(bool(sizeof(double) == 8))> double_must_be_64_bits[bool(sizeof(double) == 8) ? 1 : -1];
|
|
|
|
SimpleSerializer::SimpleSerializer(uint version) :
|
|
m_data(),
|
|
m_finalized(false)
|
|
{
|
|
m_data.reserve(100);
|
|
|
|
// write version information
|
|
int length;
|
|
if(version >= (1 << 24))
|
|
length = 4;
|
|
else if(version >= (1 << 16))
|
|
length = 3;
|
|
else if(version >= (1 << 8))
|
|
length = 2;
|
|
else if(version > 0)
|
|
length = 1;
|
|
else length = 0;
|
|
if(!writeTag(TVersion, 0, length))
|
|
return;
|
|
length--;
|
|
for(int i = length; i >= 0; i--)
|
|
m_data.push_back((char)((version >> (i * 8)) & 0xff));
|
|
}
|
|
|
|
void SimpleSerializer::writeS32(quint32 id, qint32 value)
|
|
{
|
|
int length;
|
|
|
|
if(id == 0) {
|
|
qCritical("SimpleSerializer: ID 0 is not allowed");
|
|
return;
|
|
}
|
|
|
|
if((value < -(1 << 23)) || (value >= (1 << 23)))
|
|
length = 4;
|
|
else if((value < -(1 << 15)) || (value >= (1 << 15)))
|
|
length = 3;
|
|
else if((value < -(1 << 7)) || (value >= (1 << 7)))
|
|
length = 2;
|
|
else if(value != 0)
|
|
length = 1;
|
|
else length = 0;
|
|
|
|
if(!writeTag(TSigned32, id, length))
|
|
return;
|
|
|
|
length--;
|
|
for(int i = length; i >= 0; i--)
|
|
m_data.push_back((char)((value >> (i * 8)) & 0xff));
|
|
}
|
|
|
|
void SimpleSerializer::writeU32(quint32 id, quint32 value)
|
|
{
|
|
int length;
|
|
|
|
if(id == 0) {
|
|
qCritical("SimpleSerializer: ID 0 is not allowed");
|
|
return;
|
|
}
|
|
|
|
if(value >= (1 << 24))
|
|
length = 4;
|
|
else if(value >= (1 << 16))
|
|
length = 3;
|
|
else if(value >= (1 << 8))
|
|
length = 2;
|
|
else if(value > 0)
|
|
length = 1;
|
|
else length = 0;
|
|
|
|
if(!writeTag(TUnsigned32, id, length))
|
|
return;
|
|
|
|
length--;
|
|
for(int i = length; i >= 0; i--)
|
|
m_data.push_back((char)((value >> (i * 8)) & 0xff));
|
|
}
|
|
|
|
void SimpleSerializer::writeS64(quint32 id, qint64 value)
|
|
{
|
|
int length;
|
|
|
|
if(id == 0) {
|
|
qCritical("SimpleSerializer: ID 0 is not allowed");
|
|
return;
|
|
}
|
|
|
|
if((value < -(1ll << 55)) || (value >= (1ll << 55)))
|
|
length = 8;
|
|
else if((value < -(1ll << 47)) || (value >= (1ll << 47)))
|
|
length = 7;
|
|
else if((value < -(1ll << 39)) || (value >= (1ll << 39)))
|
|
length = 6;
|
|
else if((value < -(1ll << 31)) || (value >= (1ll << 31)))
|
|
length = 5;
|
|
else if((value < -(1ll << 23)) || (value >= (1ll << 23)))
|
|
length = 4;
|
|
else if((value < -(1ll << 15)) || (value >= (1ll << 15)))
|
|
length = 3;
|
|
else if((value < -(1ll << 7)) || (value >= (1ll << 7)))
|
|
length = 2;
|
|
else if(value != 0)
|
|
length = 1;
|
|
else length = 0;
|
|
|
|
if(!writeTag(TSigned64, id, length))
|
|
return;
|
|
|
|
length--;
|
|
for(int i = length; i >= 0; i--)
|
|
m_data.push_back((char)((value >> (i * 8)) & 0xff));
|
|
}
|
|
|
|
void SimpleSerializer::writeU64(quint32 id, quint64 value)
|
|
{
|
|
int length;
|
|
|
|
if(id == 0) {
|
|
qCritical("SimpleSerializer: ID 0 is not allowed");
|
|
return;
|
|
}
|
|
|
|
if(value >= (1ll << 56))
|
|
length = 8;
|
|
else if(value >= (1ll << 48))
|
|
length = 7;
|
|
else if(value >= (1ll << 40))
|
|
length = 6;
|
|
else if(value >= (1ll << 32))
|
|
length = 5;
|
|
else if(value >= (1ll << 24))
|
|
length = 4;
|
|
else if(value >= (1ll << 16))
|
|
length = 3;
|
|
else if(value >= (1ll << 8))
|
|
length = 2;
|
|
else if(value > 0)
|
|
length = 1;
|
|
else length = 0;
|
|
|
|
if(!writeTag(TUnsigned64, id, length))
|
|
return;
|
|
|
|
length--;
|
|
for(int i = length; i >= 0; i--)
|
|
m_data.push_back((char)((value >> (i * 8)) & 0xff));
|
|
}
|
|
|
|
union floatasint {
|
|
quint32 u;
|
|
float f;
|
|
};
|
|
|
|
void SimpleSerializer::writeFloat(quint32 id, float value)
|
|
{
|
|
union floatasint tmp;
|
|
if(id == 0) {
|
|
qCritical("SimpleSerializer: ID 0 is not allowed");
|
|
return;
|
|
}
|
|
|
|
if(!writeTag(TFloat, id, 4))
|
|
return;
|
|
|
|
tmp.f = value;
|
|
m_data.push_back((char)((tmp.u >> 24) & 0xff));
|
|
m_data.push_back((char)((tmp.u >> 16) & 0xff));
|
|
m_data.push_back((char)((tmp.u >> 8) & 0xff));
|
|
m_data.push_back((char)(tmp.u & 0xff));
|
|
}
|
|
|
|
union doubleasint {
|
|
quint64 u;
|
|
double d;
|
|
};
|
|
|
|
void SimpleSerializer::writeDouble(quint32 id, double value)
|
|
{
|
|
union doubleasint tmp;
|
|
if(id == 0) {
|
|
qCritical("SimpleSerializer: ID 0 is not allowed");
|
|
return;
|
|
}
|
|
|
|
if(!writeTag(TDouble, id, 8))
|
|
return;
|
|
|
|
tmp.d = value;
|
|
m_data.push_back((char)((tmp.u >> 56) & 0xff));
|
|
m_data.push_back((char)((tmp.u >> 48) & 0xff));
|
|
m_data.push_back((char)((tmp.u >> 40) & 0xff));
|
|
m_data.push_back((char)((tmp.u >> 32) & 0xff));
|
|
m_data.push_back((char)((tmp.u >> 24) & 0xff));
|
|
m_data.push_back((char)((tmp.u >> 16) & 0xff));
|
|
m_data.push_back((char)((tmp.u >> 8) & 0xff));
|
|
m_data.push_back((char)(tmp.u & 0xff));
|
|
}
|
|
|
|
void SimpleSerializer::writeBool(quint32 id, bool value)
|
|
{
|
|
if(id == 0) {
|
|
qCritical("SimpleSerializer: ID 0 is not allowed");
|
|
return;
|
|
}
|
|
|
|
if(!writeTag(TBool, id, 1))
|
|
return;
|
|
if(value)
|
|
m_data.push_back((char)0x01);
|
|
else m_data.push_back((char)0x00);
|
|
}
|
|
|
|
void SimpleSerializer::writeString(quint32 id, const QString& value)
|
|
{
|
|
if(id == 0) {
|
|
qCritical("SimpleSerializer: ID 0 is not allowed");
|
|
return;
|
|
}
|
|
|
|
QByteArray utf8 = value.toUtf8();
|
|
if(!writeTag(TString, id, utf8.size()))
|
|
return;
|
|
m_data.append(utf8);
|
|
}
|
|
|
|
void SimpleSerializer::writeBlob(quint32 id, const QByteArray& value)
|
|
{
|
|
if(id == 0) {
|
|
qCritical("SimpleSerializer: ID 0 is not allowed");
|
|
return;
|
|
}
|
|
|
|
if(!writeTag(TBlob, id, value.size()))
|
|
return;
|
|
m_data.append(value);
|
|
}
|
|
|
|
const QByteArray& SimpleSerializer::final()
|
|
{
|
|
m_finalized = true;
|
|
return m_data;
|
|
}
|
|
|
|
bool SimpleSerializer::writeTag(Type type, quint32 id, quint32 length)
|
|
{
|
|
if(m_finalized) {
|
|
qCritical("SimpleSerializer: config has already been finalized (id %u)", id);
|
|
return false;
|
|
}
|
|
|
|
int idLen;
|
|
int lengthLen;
|
|
|
|
if(id < (1 << 8))
|
|
idLen = 0;
|
|
else if(id < (1 << 16))
|
|
idLen = 1;
|
|
else if(id < (1 << 24))
|
|
idLen = 2;
|
|
else idLen = 3;
|
|
|
|
if(length < (1 << 8))
|
|
lengthLen = 0;
|
|
else if(length < (1 << 16))
|
|
lengthLen = 1;
|
|
else if(length < (1 << 24))
|
|
lengthLen = 2;
|
|
else lengthLen = 3;
|
|
|
|
m_data.push_back((char)((type << 4) | (idLen << 2) | lengthLen));
|
|
for(int i = idLen; i >= 0; i--)
|
|
m_data.push_back((char)((id >> (i * 8)) & 0xff));
|
|
for(int i = lengthLen; i >= 0; i--)
|
|
m_data.push_back((char)((length >> (i * 8)) & 0xff));
|
|
return true;
|
|
}
|
|
|
|
SimpleDeserializer::SimpleDeserializer(const QByteArray& data) :
|
|
m_data(data)
|
|
{
|
|
m_valid = parseAll();
|
|
|
|
// read version information
|
|
uint readOfs;
|
|
Elements::const_iterator it = m_elements.constFind(0);
|
|
if(it == m_elements.constEnd())
|
|
goto setInvalid;
|
|
if(it->type != TVersion)
|
|
goto setInvalid;
|
|
if(it->length > 4)
|
|
goto setInvalid;
|
|
|
|
readOfs = it->ofs;
|
|
m_version = 0;
|
|
for(uint i = 0; i < it->length; i++)
|
|
m_version = (m_version << 8) | readByte(&readOfs);
|
|
return;
|
|
|
|
setInvalid:
|
|
m_valid = false;
|
|
}
|
|
|
|
bool SimpleDeserializer::readS32(quint32 id, qint32* result, qint32 def) const
|
|
{
|
|
uint readOfs;
|
|
qint32 tmp;
|
|
Elements::const_iterator it = m_elements.constFind(id);
|
|
if(it == m_elements.constEnd())
|
|
goto returnDefault;
|
|
if(it->type != TSigned32)
|
|
goto returnDefault;
|
|
if(it->length > 4)
|
|
goto returnDefault;
|
|
|
|
readOfs = it->ofs;
|
|
tmp = 0;
|
|
for(uint i = 0; i < it->length; i++) {
|
|
quint8 byte = readByte(&readOfs);
|
|
if((i == 0) && (byte & 0x80))
|
|
tmp = -1;
|
|
tmp = (tmp << 8) | byte;
|
|
}
|
|
*result = tmp;
|
|
return true;
|
|
|
|
returnDefault:
|
|
*result = def;
|
|
return false;
|
|
}
|
|
|
|
bool SimpleDeserializer::readU32(quint32 id, quint32* result, quint32 def) const
|
|
{
|
|
uint readOfs;
|
|
quint32 tmp;
|
|
Elements::const_iterator it = m_elements.constFind(id);
|
|
if(it == m_elements.constEnd())
|
|
goto returnDefault;
|
|
if(it->type != TUnsigned32)
|
|
goto returnDefault;
|
|
if(it->length > 4)
|
|
goto returnDefault;
|
|
|
|
readOfs = it->ofs;
|
|
tmp = 0;
|
|
for(uint i = 0; i < it->length; i++)
|
|
tmp = (tmp << 8) | readByte(&readOfs);
|
|
*result = tmp;
|
|
return true;
|
|
|
|
returnDefault:
|
|
*result = def;
|
|
return false;
|
|
}
|
|
|
|
bool SimpleDeserializer::readS64(quint32 id, qint64* result, qint64 def) const
|
|
{
|
|
uint readOfs;
|
|
qint64 tmp;
|
|
Elements::const_iterator it = m_elements.constFind(id);
|
|
if(it == m_elements.constEnd())
|
|
goto returnDefault;
|
|
if(it->type != TSigned64)
|
|
goto returnDefault;
|
|
if(it->length > 8)
|
|
goto returnDefault;
|
|
|
|
readOfs = it->ofs;
|
|
tmp = 0;
|
|
for(uint i = 0; i < it->length; i++) {
|
|
quint8 byte = readByte(&readOfs);
|
|
if((i == 0) && (byte & 0x80))
|
|
tmp = -1;
|
|
tmp = (tmp << 8) | byte;
|
|
}
|
|
*result = tmp;
|
|
return true;
|
|
|
|
returnDefault:
|
|
*result = def;
|
|
return false;
|
|
}
|
|
|
|
bool SimpleDeserializer::readU64(quint32 id, quint64* result, quint64 def) const
|
|
{
|
|
uint readOfs;
|
|
quint64 tmp;
|
|
Elements::const_iterator it = m_elements.constFind(id);
|
|
if(it == m_elements.constEnd())
|
|
goto returnDefault;
|
|
if(it->type != TUnsigned64)
|
|
goto returnDefault;
|
|
if(it->length > 8)
|
|
goto returnDefault;
|
|
|
|
readOfs = it->ofs;
|
|
tmp = 0;
|
|
for(uint i = 0; i < it->length; i++)
|
|
tmp = (tmp << 8) | readByte(&readOfs);
|
|
*result = tmp;
|
|
return true;
|
|
|
|
returnDefault:
|
|
*result = def;
|
|
return false;
|
|
}
|
|
|
|
bool SimpleDeserializer::readFloat(quint32 id, float* result, float def) const
|
|
{
|
|
uint readOfs;
|
|
union floatasint tmp;
|
|
Elements::const_iterator it = m_elements.constFind(id);
|
|
if(it == m_elements.constEnd())
|
|
goto returnDefault;
|
|
if(it->type != TFloat)
|
|
goto returnDefault;
|
|
if(it->length != 4)
|
|
goto returnDefault;
|
|
|
|
readOfs = it->ofs;
|
|
tmp.u = 0;
|
|
for(int i = 0; i < 4; i++)
|
|
tmp.u = (tmp.u << 8) | readByte(&readOfs);
|
|
*result = tmp.f;
|
|
return true;
|
|
|
|
returnDefault:
|
|
*result = def;
|
|
return false;
|
|
}
|
|
|
|
bool SimpleDeserializer::readDouble(quint32 id, double* result, double def) const
|
|
{
|
|
uint readOfs;
|
|
union doubleasint tmp;
|
|
Elements::const_iterator it = m_elements.constFind(id);
|
|
if(it == m_elements.constEnd())
|
|
goto returnDefault;
|
|
if(it->type != TDouble)
|
|
goto returnDefault;
|
|
if(it->length != 8)
|
|
goto returnDefault;
|
|
|
|
readOfs = it->ofs;
|
|
tmp.u = 0;
|
|
for(int i = 0; i < 8; i++)
|
|
tmp.u = (tmp.u << 8) | readByte(&readOfs);
|
|
*result = tmp.d;
|
|
return true;
|
|
|
|
returnDefault:
|
|
*result = def;
|
|
return false;
|
|
}
|
|
|
|
union real4asint {
|
|
quint32 u;
|
|
Real r;
|
|
};
|
|
|
|
union real8asint {
|
|
quint64 u;
|
|
Real r;
|
|
};
|
|
|
|
bool SimpleDeserializer::readReal(quint32 id, Real* result, Real def) const
|
|
{
|
|
if(sizeof(Real) == 4) {
|
|
uint readOfs;
|
|
union real4asint tmp;
|
|
Elements::const_iterator it = m_elements.constFind(id);
|
|
if(it == m_elements.constEnd())
|
|
goto returnDefault32;
|
|
if(it->type != TFloat)
|
|
goto returnDefault32;
|
|
if(it->length != 4)
|
|
goto returnDefault32;
|
|
|
|
readOfs = it->ofs;
|
|
tmp.u = 0;
|
|
for(int i = 0; i < 4; i++)
|
|
tmp.u = (tmp.u << 8) | readByte(&readOfs);
|
|
*result = tmp.r;
|
|
return true;
|
|
|
|
returnDefault32:
|
|
*result = def;
|
|
return false;
|
|
} else {
|
|
uint readOfs;
|
|
union real8asint tmp;
|
|
Elements::const_iterator it = m_elements.constFind(id);
|
|
if(it == m_elements.constEnd())
|
|
goto returnDefault64;
|
|
if(it->type != TDouble)
|
|
goto returnDefault64;
|
|
if(it->length != 8)
|
|
goto returnDefault64;
|
|
|
|
readOfs = it->ofs;
|
|
tmp.u = 0;
|
|
for(int i = 0; i < 8; i++)
|
|
tmp.u = (tmp.u << 8) | readByte(&readOfs);
|
|
*result = tmp.r;
|
|
return true;
|
|
|
|
returnDefault64:
|
|
*result = def;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool SimpleDeserializer::readBool(quint32 id, bool* result, bool def) const
|
|
{
|
|
uint readOfs;
|
|
quint8 tmp;
|
|
Elements::const_iterator it = m_elements.constFind(id);
|
|
if(it == m_elements.constEnd())
|
|
goto returnDefault;
|
|
if(it->type != TBool)
|
|
goto returnDefault;
|
|
if(it->length != 1)
|
|
goto returnDefault;
|
|
|
|
readOfs = it->ofs;
|
|
tmp = readByte(&readOfs);
|
|
if(tmp == 0x00)
|
|
*result = false;
|
|
else *result = true;
|
|
return true;
|
|
|
|
returnDefault:
|
|
*result = def;
|
|
return false;
|
|
}
|
|
|
|
bool SimpleDeserializer::readString(quint32 id, QString* result, const QString& def) const
|
|
{
|
|
Elements::const_iterator it = m_elements.constFind(id);
|
|
if(it == m_elements.constEnd())
|
|
goto returnDefault;
|
|
if(it->type != TString)
|
|
goto returnDefault;
|
|
|
|
*result = QString::fromUtf8(m_data.data() + it->ofs, it->length);
|
|
return true;
|
|
|
|
returnDefault:
|
|
*result = def;
|
|
return false;
|
|
}
|
|
|
|
bool SimpleDeserializer::readBlob(quint32 id, QByteArray* result, const QByteArray& def) const
|
|
{
|
|
Elements::const_iterator it = m_elements.constFind(id);
|
|
if(it == m_elements.constEnd())
|
|
goto returnDefault;
|
|
if(it->type != TBlob)
|
|
goto returnDefault;
|
|
|
|
*result = QByteArray(m_data.data() + it->ofs, it->length);
|
|
return true;
|
|
|
|
returnDefault:
|
|
*result = def;
|
|
return false;
|
|
}
|
|
|
|
void SimpleDeserializer::dump() const
|
|
{
|
|
if(!m_valid) {
|
|
qDebug("SimpleDeserializer dump: data invalid");
|
|
return;
|
|
} else {
|
|
qDebug("SimpleDeserializer dump: version %u", m_version);
|
|
}
|
|
|
|
for(Elements::const_iterator it = m_elements.constBegin(); it != m_elements.constEnd(); ++it) {
|
|
switch(it->type) {
|
|
case TSigned32: {
|
|
qint32 tmp;
|
|
readS32(it.key(), &tmp);
|
|
qDebug("id %d, S32, len %d: " PRINTF_FORMAT_S32, it.key(), it->length, tmp);
|
|
break;
|
|
}
|
|
case TUnsigned32: {
|
|
quint32 tmp;
|
|
readU32(it.key(), &tmp);
|
|
qDebug("id %d, U32, len %d: " PRINTF_FORMAT_U32, it.key(), it->length, tmp);
|
|
break;
|
|
}
|
|
case TSigned64: {
|
|
qint64 tmp;
|
|
readS64(it.key(), &tmp);
|
|
// qDebug("id %d, S64, len %d: " PRINTF_FORMAT_S64, it.key(), it->length, (int)tmp);
|
|
break;
|
|
}
|
|
case TUnsigned64: {
|
|
quint64 tmp;
|
|
readU64(it.key(), &tmp);
|
|
// qDebug("id %d, U64, len %d: " PRINTF_FORMAT_U64, it.key(), it->length, (uint)tmp);
|
|
break;
|
|
}
|
|
case TFloat: {
|
|
float tmp;
|
|
readFloat(it.key(), &tmp);
|
|
qDebug("id %d, FLOAT, len %d: %f", it.key(), it->length, tmp);
|
|
break;
|
|
}
|
|
case TDouble: {
|
|
double tmp;
|
|
readDouble(it.key(), &tmp);
|
|
qDebug("id %d, DOUBLE, len %d: %f", it.key(), it->length, tmp);
|
|
break;
|
|
}
|
|
case TBool: {
|
|
bool tmp;
|
|
readBool(it.key(), &tmp);
|
|
qDebug("id %d, BOOL, len %d: %s", it.key(), it->length, tmp ? "true" : "false");
|
|
break;
|
|
}
|
|
case TString: {
|
|
QString tmp;
|
|
readString(it.key(), &tmp);
|
|
qDebug("id %d, STRING, len %d: \"%s\"", it.key(), it->length, qPrintable(tmp));
|
|
break;
|
|
}
|
|
case TBlob: {
|
|
QByteArray tmp;
|
|
readBlob(it.key(), &tmp);
|
|
qDebug("id %d, BLOB, len %d", it.key(), it->length);
|
|
break;
|
|
}
|
|
case TVersion: {
|
|
qDebug("id %d, VERSION, len %d", it.key(), it->length);
|
|
break;
|
|
}
|
|
default: {
|
|
qDebug("id %d, UNKNOWN TYPE 0x%02x, len %d", it.key(), it->type, it->length);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool SimpleDeserializer::parseAll()
|
|
{
|
|
uint readOfs = 0;
|
|
Type type;
|
|
quint32 id;
|
|
quint32 length;
|
|
|
|
/*
|
|
QString hex;
|
|
for(int i = 0; i < m_data.size(); i++)
|
|
hex.append(QString("%1 ").arg((quint8)m_data[i], 2, 16, QChar('0')));
|
|
qDebug("%s", qPrintable(hex));
|
|
qDebug("==");
|
|
*/
|
|
|
|
while(readOfs < (uint)m_data.size()) {
|
|
if(!readTag(&readOfs, m_data.size(), &type, &id, &length))
|
|
return false;
|
|
|
|
//qDebug("-- id %d, TYPE 0x%02x, len %d", id, type, length);
|
|
|
|
if(m_elements.contains(id)) {
|
|
qDebug("SimpleDeserializer: same ID found twice (id %u)", id);
|
|
return false;
|
|
}
|
|
|
|
m_elements.insert(id, Element(type, readOfs, length));
|
|
|
|
readOfs += length;
|
|
|
|
if(readOfs == (uint)m_data.size())
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool SimpleDeserializer::readTag(uint* readOfs, uint readEnd, Type* type, quint32* id, quint32* length) const
|
|
{
|
|
quint8 tag = readByte(readOfs);
|
|
|
|
*type = (Type)(tag >> 4);
|
|
int idLen = ((tag >> 2) & 0x03) + 1;
|
|
int lengthLen = (tag & 0x03) + 1;
|
|
|
|
// make sure we have enough header bytes left
|
|
if(((*readOfs) + idLen + lengthLen) > readEnd)
|
|
return false;
|
|
|
|
quint32 tmp = 0;
|
|
for(int i = 0; i < idLen; i++)
|
|
tmp = (tmp << 8) | readByte(readOfs);
|
|
*id = tmp;
|
|
tmp = 0;
|
|
for(int i = 0; i < lengthLen; i++)
|
|
tmp = (tmp << 8) | readByte(readOfs);
|
|
*length = tmp;
|
|
|
|
// check if payload fits the buffer
|
|
if(((*readOfs) + (*length)) > readEnd)
|
|
return false;
|
|
else return true;
|
|
}
|
|
|