git-svn-id: http://webrtc.googlecode.com/svn/trunk@4 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
niklase@google.com
995
modules/rtp_rtcp/source/rtp_utility.cc
Normal file
995
modules/rtp_rtcp/source/rtp_utility.cc
Normal file
@@ -0,0 +1,995 @@
|
||||
/*
|
||||
* 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
|
||||
Reference in New Issue
Block a user