996 lines
30 KiB
C++
996 lines
30 KiB
C++
/*
|
|
* Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#include "rtp_utility.h"
|
|
|
|
#include <cstring> // memcpy
|
|
#include <cmath> // ceil
|
|
#include <cassert>
|
|
|
|
#if defined(_WIN32)
|
|
#include <Windows.h> // FILETIME
|
|
#include <WinSock.h> // timeval
|
|
#include <MMSystem.h> //timeGetTime
|
|
#elif ((defined WEBRTC_LINUX) || (defined WEBRTC_MAC))
|
|
#include <sys/time.h> // gettimeofday
|
|
#include <time.h>
|
|
#endif
|
|
|
|
#if (defined(_DEBUG) && defined(_WIN32) && (_MSC_VER >= 1400))
|
|
#include <stdio.h>
|
|
#define DEBUG_PRINT(...) \
|
|
{ \
|
|
char msg[256]; \
|
|
sprintf(msg, __VA_ARGS__); \
|
|
OutputDebugString(msg); \
|
|
}
|
|
#else
|
|
// special fix for visual 2003
|
|
#define DEBUG_PRINT(exp) ((void)0)
|
|
#endif // defined(_DEBUG) && defined(_WIN32)
|
|
|
|
namespace
|
|
{
|
|
const float FRAC = 4.294967296E9;
|
|
}
|
|
|
|
namespace webrtc {
|
|
// PLATFORM SPECIFIC [BEGIN]
|
|
#if defined(_WIN32)
|
|
#include <Windows.h>
|
|
|
|
namespace ModuleRTPUtility
|
|
{
|
|
WebRtc_UWord32 GetTimeInMS()
|
|
{
|
|
return timeGetTime();
|
|
}
|
|
bool StringCompare(const WebRtc_Word8* str1 , const WebRtc_Word8* str2, const WebRtc_UWord32 length)
|
|
{
|
|
return (_strnicmp(str1, str2, length) == 0)?true: false;
|
|
}
|
|
|
|
class HelpTimer
|
|
{
|
|
public:
|
|
struct reference_point
|
|
{
|
|
FILETIME file_time;
|
|
LARGE_INTEGER counterMS;
|
|
};
|
|
|
|
HelpTimer()
|
|
{
|
|
// set timer accuracy to 1 ms
|
|
timeBeginPeriod(1);
|
|
|
|
_timeInMs = 0;
|
|
_numWrapTimeInMs = 0;
|
|
synchronize();
|
|
};
|
|
|
|
virtual ~HelpTimer()
|
|
{
|
|
timeEndPeriod(1);
|
|
};
|
|
|
|
void get_time(FILETIME& current_time)
|
|
{
|
|
// we can't use query performance counter due to speed stepping
|
|
DWORD t = timeGetTime();
|
|
// NOTE: we have a miss match in sign between _timeInMs(LONG) and t(DWORD) however we only use it here without +- etc
|
|
volatile LONG* timeInMsPtr = &_timeInMs;
|
|
DWORD old = InterlockedExchange(timeInMsPtr, t); // make sure that we only inc wrapper once
|
|
if(old > t)
|
|
{
|
|
// wrap
|
|
_numWrapTimeInMs++;
|
|
}
|
|
LARGE_INTEGER elapsedMS;
|
|
elapsedMS.HighPart = _numWrapTimeInMs;
|
|
elapsedMS.LowPart = t;
|
|
|
|
elapsedMS.QuadPart = elapsedMS.QuadPart - _ref_point.counterMS.QuadPart;
|
|
|
|
//
|
|
// Translate to 100-nanoseconds intervals (FILETIME resolution) and add to
|
|
// reference FILETIME to get current FILETIME.
|
|
//
|
|
ULARGE_INTEGER filetime_ref_as_ul;
|
|
|
|
filetime_ref_as_ul.HighPart = _ref_point.file_time.dwHighDateTime;
|
|
filetime_ref_as_ul.LowPart = _ref_point.file_time.dwLowDateTime;
|
|
filetime_ref_as_ul.QuadPart += (ULONGLONG)((elapsedMS.QuadPart)*1000*10);
|
|
//
|
|
// Copy to result
|
|
//
|
|
current_time.dwHighDateTime = filetime_ref_as_ul.HighPart;
|
|
current_time.dwLowDateTime = filetime_ref_as_ul.LowPart;
|
|
};
|
|
|
|
private:
|
|
void synchronize()
|
|
{
|
|
FILETIME ft0 = { 0, 0 },
|
|
ft1 = { 0, 0 };
|
|
//
|
|
// Spin waiting for a change in system time. Get the matching
|
|
// performance counter value for that time.
|
|
//
|
|
::GetSystemTimeAsFileTime(&ft0);
|
|
do
|
|
{
|
|
::GetSystemTimeAsFileTime(&ft1);
|
|
_ref_point.counterMS.QuadPart = ::timeGetTime();
|
|
::Sleep(0);
|
|
}
|
|
while ((ft0.dwHighDateTime == ft1.dwHighDateTime) &&
|
|
(ft0.dwLowDateTime == ft1.dwLowDateTime));
|
|
|
|
_ref_point.file_time = ft1;
|
|
}
|
|
volatile LONG _timeInMs; // this needs to be long due to Windows, not an issue due to its usage
|
|
volatile WebRtc_UWord32 _numWrapTimeInMs;
|
|
reference_point _ref_point;
|
|
};
|
|
|
|
static HelpTimer helpTimer;
|
|
|
|
}; // end namespace
|
|
|
|
#elif defined(WEBRTC_LINUX) || defined(WEBRTC_MAC)
|
|
#include <sys/time.h> // gettimeofday
|
|
#include <time.h> // nanosleep, gettimeofday
|
|
|
|
WebRtc_UWord32
|
|
ModuleRTPUtility::GetTimeInMS()
|
|
{
|
|
struct timeval tv;
|
|
struct timezone tz;
|
|
WebRtc_UWord32 val;
|
|
|
|
gettimeofday(&tv, &tz);
|
|
val = (WebRtc_UWord32)(tv.tv_sec*1000 + tv.tv_usec/1000);
|
|
return val;
|
|
}
|
|
bool ModuleRTPUtility::StringCompare(const WebRtc_Word8* str1 , const WebRtc_Word8* str2, const WebRtc_UWord32 length)
|
|
{
|
|
return (strncasecmp(str1, str2, length) == 0)?true: false;
|
|
}
|
|
#endif // PLATFORM SPECIFIC [END]
|
|
|
|
#if !defined(WEBRTC_LITTLE_ENDIAN) && !defined(WEBRTC_BIG_ENDIAN)
|
|
#error Either WEBRTC_LITTLE_ENDIAN or WEBRTC_BIG_ENDIAN must be defined
|
|
#endif
|
|
|
|
/* for RTP/RTCP
|
|
All integer fields are carried in network byte order, that is, most
|
|
significant byte (octet) first. AKA big-endian.
|
|
*/
|
|
void
|
|
ModuleRTPUtility::AssignUWord32ToBuffer(WebRtc_UWord8* dataBuffer, WebRtc_UWord32 value)
|
|
{
|
|
#if defined(WEBRTC_LITTLE_ENDIAN)
|
|
dataBuffer[0] = static_cast<WebRtc_UWord8>(value>>24);
|
|
dataBuffer[1] = static_cast<WebRtc_UWord8>(value>>16);
|
|
dataBuffer[2] = static_cast<WebRtc_UWord8>(value>>8);
|
|
dataBuffer[3] = static_cast<WebRtc_UWord8>(value);
|
|
#else
|
|
WebRtc_UWord32* ptr = reinterpret_cast<WebRtc_UWord32*>(dataBuffer);
|
|
ptr[0] = value;
|
|
#endif
|
|
}
|
|
|
|
void
|
|
ModuleRTPUtility::AssignUWord24ToBuffer(WebRtc_UWord8* dataBuffer, WebRtc_UWord32 value)
|
|
{
|
|
#if defined(WEBRTC_LITTLE_ENDIAN)
|
|
dataBuffer[0] = static_cast<WebRtc_UWord8>(value>>16);
|
|
dataBuffer[1] = static_cast<WebRtc_UWord8>(value>>8);
|
|
dataBuffer[2] = static_cast<WebRtc_UWord8>(value);
|
|
#else
|
|
dataBuffer[0] = static_cast<WebRtc_UWord8>(value);
|
|
dataBuffer[1] = static_cast<WebRtc_UWord8>(value>>8);
|
|
dataBuffer[2] = static_cast<WebRtc_UWord8>(value>>16);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
ModuleRTPUtility::AssignUWord16ToBuffer(WebRtc_UWord8* dataBuffer, WebRtc_UWord16 value)
|
|
{
|
|
#if defined(WEBRTC_LITTLE_ENDIAN)
|
|
dataBuffer[0] = static_cast<WebRtc_UWord8>(value>>8);
|
|
dataBuffer[1] = static_cast<WebRtc_UWord8>(value);
|
|
#else
|
|
WebRtc_UWord16* ptr = reinterpret_cast<WebRtc_UWord16*>(dataBuffer);
|
|
ptr[0] = value;
|
|
#endif
|
|
}
|
|
|
|
WebRtc_UWord16
|
|
ModuleRTPUtility::BufferToUWord16(const WebRtc_UWord8* dataBuffer)
|
|
{
|
|
#if defined(WEBRTC_LITTLE_ENDIAN)
|
|
return (dataBuffer[0] << 8) + dataBuffer[1];
|
|
#else
|
|
return *reinterpret_cast<const WebRtc_UWord16*>(dataBuffer);
|
|
#endif
|
|
}
|
|
|
|
WebRtc_UWord32
|
|
ModuleRTPUtility::BufferToUWord24(const WebRtc_UWord8* dataBuffer)
|
|
{
|
|
return (dataBuffer[0] << 16) + (dataBuffer[1] << 8) + dataBuffer[2];
|
|
}
|
|
|
|
WebRtc_UWord32
|
|
ModuleRTPUtility::BufferToUWord32(const WebRtc_UWord8* dataBuffer)
|
|
{
|
|
#if defined(WEBRTC_LITTLE_ENDIAN)
|
|
return (dataBuffer[0] << 24) + (dataBuffer[1] << 16) + (dataBuffer[2] << 8) +
|
|
dataBuffer[3];
|
|
#else
|
|
return *reinterpret_cast<const WebRtc_UWord32*>(dataBuffer);
|
|
#endif
|
|
}
|
|
|
|
WebRtc_UWord32
|
|
ModuleRTPUtility::pow2(WebRtc_UWord8 exp)
|
|
{
|
|
return 1 << exp;
|
|
}
|
|
|
|
WebRtc_Word32
|
|
ModuleRTPUtility::CurrentNTP(WebRtc_UWord32& secs, WebRtc_UWord32& frac)
|
|
{
|
|
/*
|
|
* Use the system time (roughly synchronised to the tick, and
|
|
* extrapolated using the system performance counter.
|
|
*/
|
|
const WebRtc_UWord32 JAN_1970 = 2208988800UL; // NTP seconds
|
|
|
|
#if defined(_WIN32)
|
|
const WebRtc_UWord64 FILETIME_1970 = 0x019db1ded53e8000;
|
|
|
|
FILETIME StartTime;
|
|
WebRtc_UWord64 Time;
|
|
struct timeval tv;
|
|
|
|
// we can't use query performance counter since they can change depending on speed steping
|
|
helpTimer.get_time(StartTime);
|
|
|
|
Time = (((WebRtc_UWord64) StartTime.dwHighDateTime) << 32) +
|
|
(WebRtc_UWord64) StartTime.dwLowDateTime;
|
|
|
|
// Convert the hecto-nano second time to tv format
|
|
Time -= FILETIME_1970;
|
|
|
|
tv.tv_sec = (WebRtc_UWord32) ( Time / (WebRtc_UWord64)10000000);
|
|
tv.tv_usec = (WebRtc_UWord32) (( Time % (WebRtc_UWord64)10000000) / 10);
|
|
|
|
double dtemp;
|
|
|
|
secs = tv.tv_sec + JAN_1970;
|
|
dtemp = tv.tv_usec / 1e6;
|
|
|
|
if (dtemp >= 1)
|
|
{
|
|
dtemp -= 1;
|
|
secs++;
|
|
} else if (dtemp < -1)
|
|
{
|
|
dtemp += 1;
|
|
secs--;
|
|
}
|
|
dtemp *= FRAC;
|
|
frac = (WebRtc_UWord32)dtemp;
|
|
return 0;
|
|
#endif
|
|
|
|
#if ((defined WEBRTC_LINUX) || (defined WEBRTC_MAC))
|
|
|
|
double dtemp;
|
|
struct timeval tv;
|
|
struct timezone tz;
|
|
tz.tz_minuteswest = 0;
|
|
tz.tz_dsttime = 0;
|
|
gettimeofday(&tv,&tz);
|
|
|
|
secs = tv.tv_sec + JAN_1970;
|
|
dtemp = tv.tv_usec / 1e6;
|
|
if (dtemp >= 1)
|
|
{
|
|
dtemp -= 1;
|
|
secs++;
|
|
} else if (dtemp < -1)
|
|
{
|
|
dtemp += 1;
|
|
secs--;
|
|
}
|
|
dtemp *= FRAC;
|
|
frac = (WebRtc_UWord32)dtemp;
|
|
|
|
return(0);
|
|
#endif
|
|
}
|
|
|
|
WebRtc_UWord32
|
|
ModuleRTPUtility::ConvertNTPTimeToMS(WebRtc_UWord32 NTPsec, WebRtc_UWord32 NTPfrac)
|
|
{
|
|
int freq = 1000;
|
|
float ftemp = (float)NTPfrac/(float)FRAC;
|
|
WebRtc_UWord32 tmp = (WebRtc_UWord32)(ftemp * freq);
|
|
WebRtc_UWord32 MStime= NTPsec*freq + tmp;
|
|
return MStime;
|
|
}
|
|
|
|
WebRtc_UWord32
|
|
ModuleRTPUtility::CurrentRTP(WebRtc_UWord32 freq)
|
|
{
|
|
WebRtc_UWord32 NTPsec = 0;
|
|
WebRtc_UWord32 NTPfrac = 0;
|
|
CurrentNTP( NTPsec, NTPfrac);
|
|
float ftemp = (float)NTPfrac/(float)FRAC;
|
|
WebRtc_UWord32 tmp = (WebRtc_UWord32)(ftemp * freq);
|
|
return NTPsec*freq + tmp;
|
|
}
|
|
|
|
void
|
|
ModuleRTPUtility::RTPPayload::SetType(RtpVideoCodecTypes videoType)
|
|
{
|
|
type = videoType;
|
|
|
|
switch (type)
|
|
{
|
|
case kRtpNoVideo:
|
|
break;
|
|
case kRtpH263Video:
|
|
case kRtpH2631998Video:
|
|
{
|
|
info.H263.hasPictureStartCode = false;
|
|
info.H263.insert2byteStartCode = false;
|
|
info.H263.hasPbit = false;
|
|
info.H263.frameWidth = 0;
|
|
info.H263.frameHeight = 0;
|
|
info.H263.startBits = 0;
|
|
info.H263.endBits = 0;
|
|
info.H263.data = 0;
|
|
info.H263.dataLength = 0;
|
|
break;
|
|
}
|
|
case kRtpMpeg4Video:
|
|
{
|
|
info.MPEG4.isFirstPacket = false;
|
|
info.MPEG4.data = 0;
|
|
info.MPEG4.dataLength = 0;
|
|
break;
|
|
}
|
|
case kRtpVp8Video:
|
|
{
|
|
info.VP8.beginningOfFrame = false;
|
|
info.VP8.nonReferenceFrame = false;
|
|
info.VP8.hasPictureID = false;
|
|
info.VP8.fragments = false;
|
|
info.VP8.startFragment = false;
|
|
info.VP8.stopFragment = false;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
ModuleRTPUtility::RTPHeaderParser::RTPHeaderParser(const WebRtc_UWord8* rtpData,
|
|
const WebRtc_UWord32 rtpDataLength):
|
|
_ptrRTPDataBegin(rtpData),
|
|
_ptrRTPDataEnd(rtpData ? (rtpData + rtpDataLength) : NULL)
|
|
{
|
|
}
|
|
|
|
ModuleRTPUtility::RTPHeaderParser::~RTPHeaderParser()
|
|
{
|
|
}
|
|
|
|
bool
|
|
ModuleRTPUtility::RTPHeaderParser::RTCP() const
|
|
{
|
|
// 72 to 76 is reserved for RTP
|
|
// 77 to 79 is not reserver but they are not assigned we will block them
|
|
// for RTCP 200 SR == marker bit + 72
|
|
// for RTCP 204 APP == marker bit + 76
|
|
/*
|
|
* RTCP
|
|
*
|
|
* FIR full INTRA-frame request 192 [RFC2032] supported
|
|
* NACK negative acknowledgement 193 [RFC2032]
|
|
* IJ Extended inter-arrival jitter report 195 [RFC-ietf-avt-rtp-toffset-07.txt] http://tools.ietf.org/html/draft-ietf-avt-rtp-toffset-07
|
|
* SR sender report 200 [RFC3551] supported
|
|
* RR receiver report 201 [RFC3551] supported
|
|
* SDES source description 202 [RFC3551] supported
|
|
* BYE goodbye 203 [RFC3551] supported
|
|
* APP application-defined 204 [RFC3551] ignored
|
|
* RTPFB Transport layer FB message 205 [RFC4585] supported
|
|
* PSFB Payload-specific FB message 206 [RFC4585] supported
|
|
* XR extended report 207 [RFC3611] supported
|
|
*/
|
|
|
|
/* 205 RFC 5104
|
|
* FMT 1 NACK supported
|
|
* FMT 2 reserved
|
|
* FMT 3 TMMBR supported
|
|
* FMT 4 TMMBN supported
|
|
*/
|
|
|
|
/* 206 RFC 5104
|
|
* FMT 1: Picture Loss Indication (PLI) supported
|
|
* FMT 2: Slice Lost Indication (SLI)
|
|
* FMT 3: Reference Picture Selection Indication (RPSI)
|
|
* FMT 4: Full Intra Request (FIR) Command supported
|
|
* FMT 5: Temporal-Spatial Trade-off Request (TSTR)
|
|
* FMT 6: Temporal-Spatial Trade-off Notification (TSTN)
|
|
* FMT 7: Video Back Channel Message (VBCM)
|
|
* FMT 15: Application layer FB message
|
|
*/
|
|
|
|
const WebRtc_UWord8 payloadType = _ptrRTPDataBegin[1];
|
|
|
|
bool RTCP = false;
|
|
|
|
// check if this is a RTCP packet
|
|
switch(payloadType)
|
|
{
|
|
case 192:
|
|
RTCP = true;
|
|
break;
|
|
case 193:
|
|
case 195:
|
|
// not supported
|
|
// pass through and check for a potential RTP packet
|
|
break;
|
|
case 200:
|
|
case 201:
|
|
case 202:
|
|
case 203:
|
|
case 204:
|
|
case 205:
|
|
case 206:
|
|
case 207:
|
|
RTCP = true;
|
|
break;
|
|
}
|
|
return RTCP;
|
|
}
|
|
|
|
bool
|
|
ModuleRTPUtility::RTPHeaderParser::Parse(WebRtcRTPHeader& parsedPacket) const
|
|
{
|
|
const ptrdiff_t length = _ptrRTPDataEnd - _ptrRTPDataBegin;
|
|
|
|
if (length < 12)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const WebRtc_UWord8 V = _ptrRTPDataBegin[0] >> 6 ; // Version
|
|
const bool P = ((_ptrRTPDataBegin[0] & 0x20) == 0) ? false : true; // Padding
|
|
const bool X = ((_ptrRTPDataBegin[0] & 0x10) == 0) ? false : true; // eXtension
|
|
const WebRtc_UWord8 CC = _ptrRTPDataBegin[0] & 0x0f;
|
|
const bool M = ((_ptrRTPDataBegin[1] & 0x80) == 0) ? false : true;
|
|
|
|
const WebRtc_UWord8 PT = _ptrRTPDataBegin[1] & 0x7f;
|
|
|
|
const WebRtc_UWord16 sequenceNumber = (_ptrRTPDataBegin[2] << 8) + _ptrRTPDataBegin[3];
|
|
|
|
const WebRtc_UWord8* ptr = &_ptrRTPDataBegin[4];
|
|
|
|
WebRtc_UWord32 RTPTimestamp = *ptr++ << 24;
|
|
RTPTimestamp += *ptr++ << 16;
|
|
RTPTimestamp += *ptr++ << 8;
|
|
RTPTimestamp += *ptr++;
|
|
|
|
WebRtc_UWord32 SSRC = *ptr++ << 24;
|
|
SSRC += *ptr++ << 16;
|
|
SSRC += *ptr++ << 8;
|
|
SSRC += *ptr++;
|
|
|
|
if (V != 2)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const WebRtc_UWord8 CSRCocts = CC * 4;
|
|
|
|
if ((ptr + CSRCocts) > _ptrRTPDataEnd)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
parsedPacket.header.markerBit = M;
|
|
parsedPacket.header.payloadType = PT;
|
|
parsedPacket.header.sequenceNumber = sequenceNumber;
|
|
parsedPacket.header.timestamp = RTPTimestamp;
|
|
parsedPacket.header.ssrc = SSRC;
|
|
parsedPacket.header.numCSRCs = CC;
|
|
parsedPacket.header.paddingLength = P ? *(_ptrRTPDataEnd - 1) : 0;
|
|
|
|
for (unsigned int i = 0; i < CC; ++i)
|
|
{
|
|
WebRtc_UWord32 CSRC = *ptr++ << 24;
|
|
CSRC += *ptr++ << 16;
|
|
CSRC += *ptr++ << 8;
|
|
CSRC += *ptr++;
|
|
parsedPacket.header.arrOfCSRCs[i] = CSRC;
|
|
}
|
|
parsedPacket.type.Audio.numEnergy = parsedPacket.header.numCSRCs;
|
|
|
|
parsedPacket.header.headerLength = 12 + CSRCocts;
|
|
if (X)
|
|
{
|
|
const ptrdiff_t remain = _ptrRTPDataEnd - ptr;
|
|
if (remain < 4)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
parsedPacket.header.headerLength += 4;
|
|
|
|
WebRtc_UWord16 definedByProfile = *ptr++ << 8;
|
|
definedByProfile += *ptr++;
|
|
|
|
WebRtc_UWord16 XLen = *ptr++ << 8;
|
|
XLen += *ptr++; // in 32 bit words
|
|
XLen *= 4; // in octs
|
|
|
|
if (remain < (4 + XLen))
|
|
{
|
|
return false;
|
|
}
|
|
if(definedByProfile == RTP_AUDIO_LEVEL_UNIQUE_ID && XLen == 4)
|
|
{
|
|
// --- Only used for debugging ---
|
|
|
|
/*
|
|
0 1 2 3
|
|
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
|
|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
|
| 0xBE | 0xDE | length=1 |
|
|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
|
| ID | len=0 |V| level | 0x00 | 0x00 |
|
|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
|
*/
|
|
|
|
// Parse out the fields but only use it for debugging for now.
|
|
const WebRtc_UWord8 ID = (*ptr & 0xf0) >> 4;
|
|
const WebRtc_UWord8 len = (*ptr & 0x0f);
|
|
ptr++;
|
|
const WebRtc_UWord8 V = (*ptr & 0x80) >> 7;
|
|
const WebRtc_UWord8 level = (*ptr & 0x7f);
|
|
// DEBUG_PRINT("RTP_AUDIO_LEVEL_UNIQUE_ID: ID=%u, len=%u, V=%u, level=%u", ID, len, V, level);
|
|
}
|
|
parsedPacket.header.headerLength += XLen;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// RTP payload parser
|
|
ModuleRTPUtility::RTPPayloadParser::RTPPayloadParser(const RtpVideoCodecTypes videoType,
|
|
const WebRtc_UWord8* payloadData,
|
|
const WebRtc_UWord16 payloadDataLength)
|
|
:
|
|
_dataPtr(payloadData),
|
|
_dataLength(payloadDataLength),
|
|
_videoType(videoType)
|
|
{
|
|
}
|
|
|
|
ModuleRTPUtility::RTPPayloadParser::~RTPPayloadParser()
|
|
{
|
|
}
|
|
|
|
bool
|
|
ModuleRTPUtility::RTPPayloadParser::Parse( RTPPayload& parsedPacket) const
|
|
{
|
|
parsedPacket.SetType(_videoType);
|
|
|
|
switch (_videoType)
|
|
{
|
|
case kRtpNoVideo:
|
|
return ParseGeneric(parsedPacket);
|
|
case kRtpH263Video:
|
|
return ParseH263(parsedPacket);
|
|
case kRtpH2631998Video:
|
|
return ParseH2631998(parsedPacket);
|
|
case kRtpMpeg4Video:
|
|
return ParseMPEG4(parsedPacket);
|
|
case kRtpVp8Video:
|
|
return ParseVP8(parsedPacket);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool
|
|
ModuleRTPUtility::RTPPayloadParser::ParseGeneric(RTPPayload& /*parsedPacket*/) const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
ModuleRTPUtility::RTPPayloadParser::ParseH263(RTPPayload& parsedPacket) const
|
|
{
|
|
if(_dataLength <= 2)
|
|
{
|
|
// data length sanity check.
|
|
return false;
|
|
}
|
|
|
|
const WebRtc_UWord8 header1 = _dataPtr[0];
|
|
const WebRtc_UWord8 header2 = _dataPtr[1];
|
|
bool modeA = false;
|
|
bool modeB = false;
|
|
bool modeC = false;
|
|
|
|
parsedPacket.frameType = ((header2 & 0x10) == 0) ? kIFrame : kPFrame;
|
|
|
|
unsigned int h263HeaderLength = 0;
|
|
if ((header1 & 0x80) == 0)
|
|
{
|
|
// Mode A
|
|
modeA = true;
|
|
h263HeaderLength = 4;
|
|
}
|
|
else
|
|
{
|
|
// In Mode B and Mode C, I bit is in 5th byte of header
|
|
const WebRtc_UWord8 header5 = _dataPtr[4];
|
|
parsedPacket.frameType = ((header5 & 0x80) == 0) ? kIFrame : kPFrame;
|
|
|
|
if((header1 & 0x40) == 0)
|
|
{
|
|
// IMPROVEMENT use the information in the H263 header? GQuant of the first MB
|
|
modeB = true;
|
|
h263HeaderLength = 8;
|
|
}else
|
|
{
|
|
modeC = true;
|
|
h263HeaderLength = 12;
|
|
}
|
|
}
|
|
|
|
if (_dataLength < h263HeaderLength)
|
|
{
|
|
// Received empty H263 packet
|
|
return false;
|
|
}
|
|
|
|
// Get SBIT and EBIT
|
|
WebRtc_UWord8 sbit = 0;
|
|
WebRtc_UWord8 ebit = 0;
|
|
const WebRtc_UWord8 seBit = header1 & 0x3f;
|
|
if (seBit)
|
|
{
|
|
// We got SBIT or EBIT
|
|
sbit = (seBit >> 3) & 0x07;
|
|
ebit = seBit & 0x07;
|
|
}
|
|
|
|
const bool isH263PictureStartCode = H263PictureStartCode(_dataPtr + h263HeaderLength);
|
|
if (isH263PictureStartCode)
|
|
{
|
|
// parse out real size and inform the decoder
|
|
WebRtc_UWord16 width = 0;
|
|
WebRtc_UWord16 height = 0;
|
|
|
|
GetH263FrameSize(_dataPtr + h263HeaderLength, width, height);
|
|
|
|
parsedPacket.info.H263.hasPictureStartCode = true;
|
|
parsedPacket.info.H263.frameWidth = width;
|
|
parsedPacket.info.H263.frameHeight = height;
|
|
}
|
|
parsedPacket.info.H263.startBits = sbit;
|
|
parsedPacket.info.H263.endBits = ebit;
|
|
parsedPacket.info.H263.data = _dataPtr + h263HeaderLength;
|
|
parsedPacket.info.H263.dataLength = _dataLength - h263HeaderLength;
|
|
parsedPacket.info.H263.insert2byteStartCode = false; // not used in this mode
|
|
parsedPacket.info.H263.hasPbit = true; // not used in this mode
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
ModuleRTPUtility::RTPPayloadParser::ParseH2631998( RTPPayload& parsedPacket) const
|
|
{
|
|
unsigned int h2631998HeaderLength = 2;
|
|
if(_dataLength <= h2631998HeaderLength)
|
|
{
|
|
// Received empty H263 (1998) packet
|
|
return false;
|
|
}
|
|
|
|
const WebRtc_UWord8 header1 = _dataPtr[0];
|
|
const WebRtc_UWord8 header2 = _dataPtr[1];
|
|
|
|
parsedPacket.frameType = kPFrame;
|
|
|
|
WebRtc_UWord8 p = (header1 >> 2) & 0x01; // picture start or a picture segment
|
|
WebRtc_UWord8 vrc = header1 & 0x02; // Video Redundancy Coding (VRC)
|
|
WebRtc_UWord8 pLen = ((header1 & 0x01) << 5) + ((header2 >> 3) & 0x1f); // Length, in bytes, of the extra picture header
|
|
//WebRtc_UWord8 peBit = (header2 & 0x07); // number of bits that shall be ignored in the last byte of the extra picture header
|
|
|
|
if (vrc)
|
|
{
|
|
return false;
|
|
}
|
|
if (pLen > 0)
|
|
{
|
|
h2631998HeaderLength += pLen;
|
|
//get extra header
|
|
|
|
// IMPROVEMENT we don't use the redundant picture header
|
|
}
|
|
|
|
if (_dataLength <= h2631998HeaderLength)
|
|
{
|
|
// Received empty H263 (1998) packet
|
|
return false;
|
|
}
|
|
// if p == 0
|
|
// it's a follow-on packet, hence it's not independently decodable
|
|
|
|
const bool isH263PictureStartCode = H263PictureStartCode(_dataPtr + h2631998HeaderLength, (p>0)?true:false);
|
|
if (isH263PictureStartCode)
|
|
{
|
|
// parse out real size and inform the decoder
|
|
WebRtc_UWord16 width = 0;
|
|
WebRtc_UWord16 height = 0;
|
|
|
|
if(p)
|
|
{
|
|
parsedPacket.frameType = GetH263FrameType(_dataPtr + h2631998HeaderLength - 2);
|
|
GetH263FrameSize(_dataPtr + h2631998HeaderLength - 2, width, height);
|
|
}
|
|
|
|
parsedPacket.info.H263.hasPictureStartCode = true;
|
|
parsedPacket.info.H263.frameWidth = width;
|
|
parsedPacket.info.H263.frameHeight = height;
|
|
|
|
}
|
|
parsedPacket.info.H263.hasPbit = (p>0)?true:false;
|
|
parsedPacket.info.H263.insert2byteStartCode = (p>0)?true:false;
|
|
parsedPacket.info.H263.data = _dataPtr + h2631998HeaderLength;
|
|
parsedPacket.info.H263.dataLength = _dataLength - h2631998HeaderLength;
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
ModuleRTPUtility::RTPPayloadParser::ParseMPEG4(
|
|
RTPPayload& parsedPacket) const
|
|
{
|
|
if (_dataLength <= 5)
|
|
{
|
|
// Received empty MPEG4 packet
|
|
return false;
|
|
}
|
|
|
|
parsedPacket.frameType = kPFrame;
|
|
|
|
if (_dataPtr[0] == 0 && _dataPtr[1] == 0 && _dataPtr[2] == 1)
|
|
{
|
|
parsedPacket.info.MPEG4.isFirstPacket = true;
|
|
if (!(_dataPtr[4] & 0x40))
|
|
{
|
|
parsedPacket.frameType = kIFrame;
|
|
}
|
|
}
|
|
|
|
parsedPacket.info.MPEG4.data = _dataPtr;
|
|
parsedPacket.info.MPEG4.dataLength = _dataLength;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
ModuleRTPUtility::RTPPayloadParser::ParseVP8(RTPPayload& parsedPacket) const
|
|
{
|
|
parsedPacket.info.VP8.hasPictureID = (_dataPtr[0] & 0x10)?true:false;
|
|
parsedPacket.info.VP8.nonReferenceFrame = (_dataPtr[0] & 0x08)?true:false;
|
|
parsedPacket.info.VP8.fragments = (_dataPtr[0] & 0x06)?true:false;
|
|
parsedPacket.info.VP8.beginningOfFrame = (_dataPtr[0] & 0x01)?true:false;
|
|
|
|
if(parsedPacket.info.VP8.fragments)
|
|
{
|
|
WebRtc_UWord8 fragments = (_dataPtr[0] >> 1) & 0x03;
|
|
if( fragments == 1)
|
|
{
|
|
parsedPacket.info.VP8.startFragment = true;
|
|
parsedPacket.info.VP8.stopFragment = false;
|
|
} else if(fragments == 3)
|
|
{
|
|
parsedPacket.info.VP8.startFragment = false;
|
|
parsedPacket.info.VP8.stopFragment = true;
|
|
} else
|
|
{
|
|
parsedPacket.info.VP8.startFragment = false;
|
|
parsedPacket.info.VP8.stopFragment = false;
|
|
}
|
|
} else
|
|
{
|
|
parsedPacket.info.VP8.startFragment = true;
|
|
parsedPacket.info.VP8.stopFragment = true;
|
|
}
|
|
if(parsedPacket.info.VP8.hasPictureID)
|
|
{
|
|
WebRtc_UWord8 numBytesPictureId = 1;
|
|
while(_dataPtr[numBytesPictureId] & 0x80)
|
|
{
|
|
numBytesPictureId++;
|
|
}
|
|
|
|
parsedPacket.frameType = (_dataPtr[1+numBytesPictureId] & 0x01) ? kPFrame : kIFrame; // first bit after picture id
|
|
|
|
if(!parsedPacket.info.VP8.startFragment)
|
|
{
|
|
// if not start fragment parse away all picture IDs
|
|
parsedPacket.info.VP8.hasPictureID = false;
|
|
parsedPacket.info.VP8.data = _dataPtr+numBytesPictureId;
|
|
parsedPacket.info.VP8.dataLength = _dataLength-numBytesPictureId;
|
|
return true;
|
|
}
|
|
} else
|
|
{
|
|
parsedPacket.frameType = (_dataPtr[1] & 0x01) ? kPFrame : kIFrame; // first bit after picture id
|
|
}
|
|
parsedPacket.info.VP8.data = _dataPtr+1;
|
|
parsedPacket.info.VP8.dataLength = _dataLength-1;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
ModuleRTPUtility::RTPPayloadParser::H263PictureStartCode(const WebRtc_UWord8* data, const bool skipFirst2bytes) const
|
|
{
|
|
// data is at least 3 bytes!
|
|
|
|
if(skipFirst2bytes)
|
|
{
|
|
const WebRtc_UWord8 h3 = *(data);
|
|
if((h3 & 0x7C) == 0 && (h3 & 0x80))
|
|
{
|
|
return true;
|
|
}
|
|
}else
|
|
{
|
|
// first part of the frame
|
|
const WebRtc_UWord8 h1 = *(data);
|
|
const WebRtc_UWord8 h2 = *(data+1);
|
|
const WebRtc_UWord8 h3 = *(data+2);
|
|
if(h1 == 0 && h2 == 0 && (h3 & 0x7C) == 0 && (h3 & 0x80))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void
|
|
ModuleRTPUtility::RTPPayloadParser::GetH263FrameSize(const WebRtc_UWord8* inputVideoBuffer,
|
|
WebRtc_UWord16& width,
|
|
WebRtc_UWord16& height) const
|
|
{
|
|
WebRtc_UWord8 uiH263PTypeFmt = (inputVideoBuffer[4] >> 2) & 0x07;
|
|
if (uiH263PTypeFmt == 7) //extended PTYPE (for QQVGA, QVGA, VGA)
|
|
{
|
|
const WebRtc_UWord8 uiH263PlusPTypeUFEP = ((inputVideoBuffer[4] & 0x03) << 1) + ((inputVideoBuffer[5] >> 7) & 0x01);
|
|
if (uiH263PlusPTypeUFEP == 1) //optional part included
|
|
{
|
|
WebRtc_UWord8 uiH263PlusPTypeFmt = (inputVideoBuffer[5] >> 4) & 0x07;
|
|
if(uiH263PlusPTypeFmt == 6) //custom picture format
|
|
{
|
|
const WebRtc_UWord16 uiH263PlusPTypeCPFmt_PWI = ((inputVideoBuffer[9] & 0x7F) << 2) + ((inputVideoBuffer[10] >> 6) & 0x03);
|
|
const WebRtc_UWord16 uiH263PlusPTypeCPFmt_PHI = ((inputVideoBuffer[10] & 0x1F) << 4) + ((inputVideoBuffer[11] >> 4) & 0x0F);
|
|
width = (uiH263PlusPTypeCPFmt_PWI + 1)*4;
|
|
width = uiH263PlusPTypeCPFmt_PHI*4;
|
|
}
|
|
else
|
|
{
|
|
switch (uiH263PlusPTypeFmt)
|
|
{
|
|
case 1: // SQCIF
|
|
width = 128;
|
|
height = 96;
|
|
break;
|
|
case 2: // QCIF
|
|
width = 176;
|
|
height = 144;
|
|
break;
|
|
case 3: // CIF
|
|
width = 352;
|
|
height = 288;
|
|
break;
|
|
case 4: // 4CIF
|
|
width = 704;
|
|
height = 576;
|
|
break;
|
|
case 5: // 16CIF
|
|
width = 1408;
|
|
height = 1152;
|
|
break;
|
|
default:
|
|
assert(false);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (uiH263PTypeFmt)
|
|
{
|
|
case 1: // SQCIF
|
|
width = 128;
|
|
height = 96;
|
|
break;
|
|
case 2: // QCIF
|
|
width = 176;
|
|
height = 144;
|
|
break;
|
|
case 3: // CIF
|
|
width = 352;
|
|
height = 288;
|
|
break;
|
|
case 4: // 4CIF
|
|
width = 704;
|
|
height = 576;
|
|
break;
|
|
case 5: // 16CIF
|
|
width = 1408;
|
|
height = 1152;
|
|
break;
|
|
default:
|
|
assert(false);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
ModuleRTPUtility::FrameTypes
|
|
ModuleRTPUtility::RTPPayloadParser::GetH263FrameType(
|
|
const WebRtc_UWord8* inputVideoBuffer) const
|
|
{
|
|
FrameTypes frameType = kPFrame;
|
|
const WebRtc_UWord8 uiH263PTypeFmt = (inputVideoBuffer[4] >> 2) & 0x07;
|
|
WebRtc_UWord8 pType = 1;
|
|
if (uiH263PTypeFmt != 7)
|
|
{
|
|
pType = (inputVideoBuffer[4] >> 1) & 0x01;
|
|
}
|
|
else
|
|
{
|
|
const WebRtc_UWord8 uiH263PlusPTypeUFEP = ((inputVideoBuffer[4] & 0x03) << 1) + ((inputVideoBuffer[5] >> 7) & 0x01);
|
|
if (uiH263PlusPTypeUFEP == 1)
|
|
{
|
|
pType = ((inputVideoBuffer[7] >> 2) & 0x07);
|
|
}
|
|
else if (uiH263PlusPTypeUFEP == 0)
|
|
{
|
|
pType = ((inputVideoBuffer[5] >> 4) & 0x07);
|
|
}
|
|
}
|
|
|
|
if (pType == 0)
|
|
{
|
|
frameType = kIFrame;
|
|
}
|
|
|
|
return frameType;
|
|
}
|
|
} // namespace webrtc
|