bool AMF0Serializer::ReadShortString(IOBuffer &buffer, Variant &variant,
bool readType) {
if (readType) {
AMF_CHECK_BOUNDARIES(buffer, 1);
if (GETIBPOINTER(buffer)[0] != AMF0_SHORT_STRING) {
FATAL("AMF type not valid: want: %hhu; got: %hhu",
AMF0_SHORT_STRING, GETIBPOINTER(buffer)[0]);
return false;
}
if (!buffer.Ignore(1)) {
FATAL("Unable to ignore 1 bytes");
return false;
}
}
AMF_CHECK_BOUNDARIES(buffer, 2);
uint16_t length = ENTOHSP(GETIBPOINTER(buffer)); //----MARKED-SHORT----
if (!buffer.Ignore(2)) {
FATAL("Unable to ignore 2 bytes");
return false;
}
AMF_CHECK_BOUNDARIES(buffer, length);
variant = string((char *) (GETIBPOINTER(buffer)), length);
if (!buffer.Ignore(length)) {
FATAL("Unable to ignore %hu bytes", length);
return false;
}
return true;
}
bool _VIDEO_AVC::Deserialize(IOBuffer &src, _VIDEO_AVC &dest) {
dest.Clear();
uint8_t *pBuffer = GETIBPOINTER(src);
uint32_t length = GETAVAILABLEBYTESCOUNT(src);
if (length<sizeof (dest._spsLength)) {
FATAL("Not enough data");
return false;
}
dest._spsLength = ENTOHSP(pBuffer);
if (length < (
sizeof (dest._spsLength)
+ dest._spsLength
+ sizeof (dest._ppsLength)
+ 2 * sizeof (uint32_t))) {
FATAL("Not enough data");
return false;
}
dest._ppsLength = ENTOHSP(pBuffer + sizeof (dest._spsLength) + dest._spsLength);
if (length < (
sizeof (dest._spsLength)
+ dest._spsLength
+ sizeof (dest._ppsLength)
+ dest._ppsLength
+ 2 * sizeof (uint32_t))) {
FATAL("Not enough data");
return false;
}
if (!dest.Init(
pBuffer + sizeof (dest._spsLength), dest._spsLength,
pBuffer + sizeof (dest._spsLength) + dest._spsLength + sizeof (dest._ppsLength), dest._ppsLength)) {
FATAL("Unable to init AVC");
return false;
}
dest._widthOverride = ENTOHLP(pBuffer + sizeof (dest._spsLength) + dest._spsLength + sizeof (dest._ppsLength) + dest._ppsLength);
dest._heightOverride = ENTOHLP(pBuffer + sizeof (dest._spsLength) + dest._spsLength + sizeof (dest._ppsLength) + dest._ppsLength + sizeof (uint32_t));
return src.Ignore(sizeof (dest._spsLength) + dest._spsLength + sizeof (dest._ppsLength) + dest._ppsLength + sizeof (uint32_t) + sizeof (uint32_t));
}
void CommonTestsSuite::test_Endianess() {
uint16_t ui16 = 0x0102;
uint32_t ui32 = 0x01020304;
uint64_t ui64 = 0x0102030405060708LL;
double d = 123.456;
//host to network
uint8_t *pBuffer = NULL;
ui16 = EHTONS(ui16);
pBuffer = (uint8_t *) & ui16;
TS_ASSERT(pBuffer[0] == 0x01);
TS_ASSERT(pBuffer[1] == 0x02);
pBuffer = NULL;
ui32 = EHTONL(ui32);
pBuffer = (uint8_t *) & ui32;
TS_ASSERT(pBuffer[0] == 0x01);
TS_ASSERT(pBuffer[1] == 0x02);
TS_ASSERT(pBuffer[2] == 0x03);
TS_ASSERT(pBuffer[3] == 0x04);
pBuffer = NULL;
ui32 = 0x01020304;
ui32 = EHTONA(ui32);
pBuffer = (uint8_t *) & ui32;
TS_ASSERT(pBuffer[0] == 0x02);
TS_ASSERT(pBuffer[1] == 0x03);
TS_ASSERT(pBuffer[2] == 0x04);
TS_ASSERT(pBuffer[3] == 0x01);
pBuffer = NULL;
ui64 = EHTONLL(ui64);
pBuffer = (uint8_t *) & ui64;
TS_ASSERT(pBuffer[0] == 0x01);
TS_ASSERT(pBuffer[1] == 0x02);
TS_ASSERT(pBuffer[2] == 0x03);
TS_ASSERT(pBuffer[3] == 0x04);
TS_ASSERT(pBuffer[4] == 0x05);
TS_ASSERT(pBuffer[5] == 0x06);
TS_ASSERT(pBuffer[6] == 0x07);
TS_ASSERT(pBuffer[7] == 0x08);
pBuffer = NULL;
EHTOND(d, ui64);
pBuffer = (uint8_t *) & ui64;
TS_ASSERT(pBuffer[0] == 0x40);
TS_ASSERT(pBuffer[1] == 0x5e);
TS_ASSERT(pBuffer[2] == 0xdd);
TS_ASSERT(pBuffer[3] == 0x2f);
TS_ASSERT(pBuffer[4] == 0x1a);
TS_ASSERT(pBuffer[5] == 0x9f);
TS_ASSERT(pBuffer[6] == 0xbe);
TS_ASSERT(pBuffer[7] == 0x77);
//network to host pointer
char buffer[] = {
0x00, 0x01, 0x02, 0x03,
0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b,
0x0c, 0x0d, 0x0e, 0x0f,
0x00, 0x01, 0x02, 0x03,
0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b,
0x0c, 0x0d, 0x0e, 0x0f,
0x00, 0x01, 0x02, 0x03,
0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b,
0x0c, 0x0d, 0x0e, 0x0f,
0x00, 0x01, 0x02, 0x03,
0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b,
0x0c, 0x0d, 0x0e, 0x0f,
0x00, 0x01, 0x02, 0x03,
0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b,
0x0c, 0x0d, 0x0e, 0x0f,
0x00, 0x01, 0x02, 0x03,
0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b,
0x0c, 0x0d, 0x0e, 0x0f,
0x00, 0x01, 0x02, 0x03,
0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b,
0x0c, 0x0d, 0x0e, 0x0f,
0x00, 0x01, 0x02, 0x03,
0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b,
0x0c, 0x0d, 0x0e, 0x0f
};
ui16 = ENTOHSP(buffer);
TS_ASSERT(ui16 == 0x0001);
ui16 = ENTOHSP(buffer + 1);
TS_ASSERT(ui16 == 0x0102);
ui16 = ENTOHSP(buffer + 2);
TS_ASSERT(ui16 == 0x0203);
ui16 = ENTOHSP(buffer + 3);
TS_ASSERT(ui16 == 0x0304);
ui16 = ENTOHSP(buffer + 4);
TS_ASSERT(ui16 == 0x0405);
ui16 = ENTOHSP(buffer + 5);
TS_ASSERT(ui16 == 0x0506);
ui16 = ENTOHSP(buffer + 6);
TS_ASSERT(ui16 == 0x0607);
ui16 = ENTOHSP(buffer + 7);
TS_ASSERT(ui16 == 0x0708);
ui16 = ENTOHSP(buffer + 8);
TS_ASSERT(ui16 == 0x0809);
ui16 = ENTOHSP(buffer + 9);
TS_ASSERT(ui16 == 0x090a);
ui16 = ENTOHSP(buffer + 10);
TS_ASSERT(ui16 == 0x0a0b);
ui16 = ENTOHSP(buffer + 11);
TS_ASSERT(ui16 == 0x0b0c);
ui16 = ENTOHSP(buffer + 12);
TS_ASSERT(ui16 == 0x0c0d);
ui16 = ENTOHSP(buffer + 13);
TS_ASSERT(ui16 == 0x0d0e);
ui16 = ENTOHSP(buffer + 14);
TS_ASSERT(ui16 == 0x0e0f);
ui32 = ENTOHLP(buffer);
TS_ASSERT(ui32 == 0x00010203);
ui32 = ENTOHLP(buffer + 1);
TS_ASSERT(ui32 == 0x01020304);
ui32 = ENTOHLP(buffer + 2);
TS_ASSERT(ui32 == 0x02030405);
ui32 = ENTOHLP(buffer + 3);
TS_ASSERT(ui32 == 0x03040506);
ui32 = ENTOHLP(buffer + 4);
TS_ASSERT(ui32 == 0x04050607);
ui32 = ENTOHLP(buffer + 5);
TS_ASSERT(ui32 == 0x05060708);
ui32 = ENTOHLP(buffer + 6);
TS_ASSERT(ui32 == 0x06070809);
ui32 = ENTOHLP(buffer + 7);
TS_ASSERT(ui32 == 0x0708090a);
ui32 = ENTOHLP(buffer + 8);
TS_ASSERT(ui32 == 0x08090a0b);
ui32 = ENTOHLP(buffer + 9);
TS_ASSERT(ui32 == 0x090a0b0c);
ui32 = ENTOHLP(buffer + 10);
TS_ASSERT(ui32 == 0x0a0b0c0d);
ui32 = ENTOHLP(buffer + 11);
TS_ASSERT(ui32 == 0x0b0c0d0e);
ui32 = ENTOHLP(buffer + 12);
TS_ASSERT(ui32 == 0x0c0d0e0f);
ui32 = ENTOHAP(buffer);
TS_ASSERT(ui32 == 0x03000102);
ui32 = ENTOHAP(buffer + 1);
TS_ASSERT(ui32 == 0x04010203);
ui32 = ENTOHAP(buffer + 2);
TS_ASSERT(ui32 == 0x05020304);
ui32 = ENTOHAP(buffer + 3);
TS_ASSERT(ui32 == 0x06030405);
ui32 = ENTOHAP(buffer + 4);
TS_ASSERT(ui32 == 0x07040506);
ui32 = ENTOHAP(buffer + 5);
TS_ASSERT(ui32 == 0x08050607);
ui32 = ENTOHAP(buffer + 6);
TS_ASSERT(ui32 == 0x09060708);
ui32 = ENTOHAP(buffer + 7);
TS_ASSERT(ui32 == 0x0a070809);
ui32 = ENTOHAP(buffer + 8);
TS_ASSERT(ui32 == 0x0b08090a);
ui32 = ENTOHAP(buffer + 9);
TS_ASSERT(ui32 == 0x0c090a0b);
ui32 = ENTOHAP(buffer + 10);
TS_ASSERT(ui32 == 0x0d0a0b0c);
ui32 = ENTOHAP(buffer + 11);
TS_ASSERT(ui32 == 0x0e0b0c0d);
ui32 = ENTOHAP(buffer + 12);
TS_ASSERT(ui32 == 0x0f0c0d0e);
ui64 = ENTOHLLP(buffer);
TS_ASSERT(ui64 == 0x0001020304050607LL);
ui64 = ENTOHLLP(buffer + 1);
TS_ASSERT(ui64 == 0x0102030405060708LL);
ui64 = ENTOHLLP(buffer + 2);
TS_ASSERT(ui64 == 0x0203040506070809LL);
ui64 = ENTOHLLP(buffer + 3);
TS_ASSERT(ui64 == 0x030405060708090aLL);
ui64 = ENTOHLLP(buffer + 4);
TS_ASSERT(ui64 == 0x0405060708090a0bLL);
ui64 = ENTOHLLP(buffer + 5);
TS_ASSERT(ui64 == 0x05060708090a0b0cLL);
ui64 = ENTOHLLP(buffer + 6);
TS_ASSERT(ui64 == 0x060708090a0b0c0dLL);
ui64 = ENTOHLLP(buffer + 7);
TS_ASSERT(ui64 == 0x0708090a0b0c0d0eLL);
ui64 = ENTOHLLP(buffer + 8);
TS_ASSERT(ui64 == 0x08090a0b0c0d0e0fLL);
char *pTempBuffer = new char[64 + 8];
unsigned char rawDouble[] = {0x40, 0x5E, 0xDD, 0x2F, 0x1A, 0x9F, 0xBE, 0x77};
double tempDoubleVal = 0;
for (int i = 0; i <= 64; i++) {
memset(pTempBuffer, 0, i);
memcpy(pTempBuffer + i, rawDouble, 8);
memset(pTempBuffer + i + 8, 0, 64 + 8 - i - 8);
ENTOHDP((pTempBuffer + i), tempDoubleVal);
TS_ASSERT(d == tempDoubleVal);
}
delete[] pTempBuffer;
//network to host
#ifdef LITTLE_ENDIAN_BYTE_ALIGNED
TS_ASSERT(ENTOHA(0x01040302) == 0x01020304);
TS_ASSERT(ENTOHLL(0x0807060504030201LL) == 0x0102030405060708LL);
ENTOHD(0x77BE9F1A2FDD5E40LL, tempDoubleVal);
TS_ASSERT(d == tempDoubleVal);
#endif /* LITTLE_ENDIAN_BYTE_ALIGNED */
#ifdef LITTLE_ENDIAN_SHORT_ALIGNED
TS_ASSERT(ENTOHA(0x01040302) == 0x01020304);
TS_ASSERT(ENTOHLL(0x0807060504030201LL) == 0x0102030405060708LL);
ENTOHD(0x77BE9F1A2FDD5E40LL, tempDoubleVal);
TS_ASSERT(d == tempDoubleVal);
#endif /* LITTLE_ENDIAN_SHORT_ALIGNED */
#ifdef BIG_ENDIAN_BYTE_ALIGNED
TS_ASSERT(ENTOHA(0x02030401) == 0x01020304);
TS_ASSERT(ENTOHLL(0x0102030405060708LL) == 0x0102030405060708LL);
#error ENTOHD not tested
#endif /* BIG_ENDIAN_BYTE_ALIGNED */
#ifdef BIG_ENDIAN_SHORT_ALIGNED
#error BIG_ENDIAN_SHORT_ALIGNED set of tests not yet implemented!!! Please take care of this first!!!
#endif /* BIG_ENDIAN_SHORT_ALIGNED */
//double mirror
TS_ASSERT(ENTOHS(EHTONS(0x0102)) == 0x0102);
TS_ASSERT(EHTONS(ENTOHS(0x0102)) == 0x0102);
TS_ASSERT(ENTOHL(EHTONL(0x01020304)) == 0x01020304);
TS_ASSERT(EHTONL(ENTOHL(0x01020304)) == 0x01020304);
TS_ASSERT(ENTOHLL(EHTONLL(0x0102030405060708LL)) == 0x0102030405060708LL);
TS_ASSERT(EHTONLL(ENTOHLL(0x0102030405060708LL)) == 0x0102030405060708LL);
//EHTOND/ENTOHD are different. Requires 2 parameters. So, no double mirror
TS_ASSERT(ENTOHA(EHTONA(0x01020304)) == 0x01020304);
TS_ASSERT(EHTONA(ENTOHA(0x01020304)) == 0x01020304);
// Buffer Put routines
for (int i = 0; i < 16; i++) {
EHTONSP(buffer + i, 0x0102);
TS_ASSERT(ENTOHSP(buffer + i) == 0x0102);
EHTONLP(buffer + i, 0x01020304);
TS_ASSERT(ENTOHLP(buffer + i) == 0x01020304);
EHTONLLP(buffer + i, 0x0102030405060708LL);
TS_ASSERT(ENTOHLLP(buffer + i) == 0x0102030405060708LL);
EHTONDP(d, (buffer + i));
ENTOHDP(buffer + i, tempDoubleVal);
TS_ASSERT(d == tempDoubleVal);
}
}
bool RTCPProtocol::SignalInputData(IOBuffer &buffer, sockaddr_in *pPeerAddress) {
//0. Save the last known address
if (&_lastAddress != pPeerAddress) {
_lastAddress = *pPeerAddress;
_validLastAddress = true;
}
//1. Parse the SR
uint8_t *pBuffer = GETIBPOINTER(buffer);
uint32_t bufferLength = GETAVAILABLEBYTESCOUNT(buffer);
while (bufferLength > 0) {
if (bufferLength < 4) {
buffer.IgnoreAll();
return true;
}
uint8_t PT = pBuffer[1];
uint16_t len = ENTOHSP(pBuffer + 2);
len = (len + 1)*4;
if (len > bufferLength) {
buffer.IgnoreAll();
return true;
}
switch (PT) {
case 200: //SR
{
if (len < 28) {
buffer.IgnoreAll();
return true;
}
uint32_t ntpSec = ENTOHLP(pBuffer + 8) - 2208988800UL;
uint32_t ntpFrac = ENTOHLP(pBuffer + 12);
uint64_t ntpMicroseconds = (uint32_t) (((double) ntpFrac / (double) (0x100000000LL))*1000000.0);
ntpMicroseconds += ((uint64_t) ntpSec)*1000000;
uint32_t rtpTimestamp = ENTOHLP(pBuffer + 16);
if (_pConnectivity == NULL) {
FATAL("No connectivity, unable to send SR");
return false;
}
_pConnectivity->ReportSR(ntpMicroseconds, rtpTimestamp, _isAudio);
_lsr = ENTOHLP(pBuffer + 10);
if (!_pConnectivity->SendRR(_isAudio)) {
FATAL("Unable to send RR");
_pConnectivity->EnqueueForDelete();
_pConnectivity = NULL;
return false;
}
break;
}
case 203: //BYE
{
if (_pConnectivity == NULL) {
FATAL("No connectivity, BYE packet ignored");
return false;
}
_pConnectivity->EnqueueForDelete();
_pConnectivity = NULL;
break;
}
default:
{
break;
}
}
buffer.Ignore(len);
pBuffer = GETIBPOINTER(buffer);
bufferLength = GETAVAILABLEBYTESCOUNT(buffer);
}
return true;
}
