generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

git-svn-id: http://webrtc.googlecode.com/svn/trunk@4 4adac7df-926f-26a2-2b94-8c16560cd09d

Browse Source
This commit is contained in:
niklase@google.com
2011-05-30 11:22:19 +00:00
parent 01813fe945
commit 77ae29bc81
1153 changed files with 404089 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

517
modules/audio_coding/NetEQ/main/source/recin.c Normal file
View File

@@ -0,0 +1,517 @@
/*
* 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.
*/
/*
* Implementation of the RecIn function, which is the main function for inserting RTP
* packets into NetEQ.
*/
#include "mcu.h"
#include <string.h>
#include "signal_processing_library.h"
#include "automode.h"
#include "dtmf_buffer.h"
#include "neteq_defines.h"
#include "neteq_error_codes.h"
int WebRtcNetEQ_RecInInternal(MCUInst_t *MCU_inst, RTPPacket_t *RTPpacketInput,
WebRtc_UWord32 uw32_timeRec)
{
RTPPacket_t RTPpacket[2];
int i_k;
int i_ok = 0, i_No_Of_Payloads = 1;
WebRtc_Word16 flushed = 0;
WebRtc_Word16 codecPos;
WebRtc_UWord32 diffTS, uw32_tmp;
int curr_Codec;
WebRtc_Word16 isREDPayload = 0;
WebRtc_Word32 temp_bufsize = MCU_inst->PacketBuffer_inst.numPacketsInBuffer;
#ifdef NETEQ_RED_CODEC
RTPPacket_t* RTPpacketPtr[2]; /* Support for redundancy up to 2 payloads */
RTPpacketPtr[0] = &RTPpacket[0];
RTPpacketPtr[1] = &RTPpacket[1];
#endif
/*
* Copy from input RTP packet to local copy
* (mainly to enable multiple payloads using RED)
*/
WEBRTC_SPL_MEMCPY_W8(&RTPpacket[0], RTPpacketInput, sizeof(RTPPacket_t));
/* Reinitialize NetEq if it's needed (changed SSRC or first call) */
if ((RTPpacket[0].ssrc != MCU_inst->ssrc) || (MCU_inst->first_packet == 1))
{
WebRtcNetEQ_RTCPInit(&MCU_inst->RTCP_inst, RTPpacket[0].seqNumber);
MCU_inst->first_packet = 0;
/* Flush the buffer */
WebRtcNetEQ_PacketBufferFlush(&MCU_inst->PacketBuffer_inst);
/* Store new SSRC */
MCU_inst->ssrc = RTPpacket[0].ssrc;
/* Update codecs */
MCU_inst->timeStamp = RTPpacket[0].timeStamp;
MCU_inst->current_Payload = RTPpacket[0].payloadType;
/*Set MCU to update codec on next SignalMCU call */
MCU_inst->new_codec = 1;
/* Reset timestamp scaling */
MCU_inst->TSscalingInitialized = 0;
}
/* Call RTCP statistics */
i_ok |= WebRtcNetEQ_RTCPUpdate(&(MCU_inst->RTCP_inst), RTPpacket[0].seqNumber,
RTPpacket[0].timeStamp, uw32_timeRec);
/* If Redundancy is supported and this is the redundancy payload, separate the payloads */
#ifdef NETEQ_RED_CODEC
if (RTPpacket[0].payloadType == WebRtcNetEQ_DbGetPayload(&MCU_inst->codec_DB_inst,
kDecoderRED))
{
/* Split the payload into a main and a redundancy payloads */
i_ok = WebRtcNetEQ_RedundancySplit(RTPpacketPtr, 2, &i_No_Of_Payloads);
if (i_ok < 0)
{
/* error returned */
return i_ok;
}
/*
* Only accept a few redundancies of the same type as the main data,
* AVT events and CNG.
*/
if ((i_No_Of_Payloads > 1) && (RTPpacket[0].payloadType != RTPpacket[1].payloadType)
&& (RTPpacket[0].payloadType != WebRtcNetEQ_DbGetPayload(&MCU_inst->codec_DB_inst,
kDecoderAVT)) && (RTPpacket[1].payloadType != WebRtcNetEQ_DbGetPayload(
&MCU_inst->codec_DB_inst, kDecoderAVT)) && (!WebRtcNetEQ_DbIsCNGPayload(
&MCU_inst->codec_DB_inst, RTPpacket[0].payloadType))
&& (!WebRtcNetEQ_DbIsCNGPayload(&MCU_inst->codec_DB_inst, RTPpacket[1].payloadType)))
{
i_No_Of_Payloads = 1;
}
isREDPayload = 1;
}
#endif
/* loop over the number of payloads */
for (i_k = 0; i_k < i_No_Of_Payloads; i_k++)
{
if (isREDPayload == 1)
{
RTPpacket[i_k].rcuPlCntr = i_k;
}
else
{
RTPpacket[i_k].rcuPlCntr = 0;
}
/* Force update of SplitInfo if it's iLBC because of potential change between 20/30ms */
if (RTPpacket[i_k].payloadType == WebRtcNetEQ_DbGetPayload(&MCU_inst->codec_DB_inst,
kDecoderILBC))
{
i_ok = WebRtcNetEQ_DbGetSplitInfo(
&MCU_inst->PayloadSplit_inst,
(enum WebRtcNetEQDecoder) WebRtcNetEQ_DbGetCodec(&MCU_inst->codec_DB_inst,
RTPpacket[i_k].payloadType), RTPpacket[i_k].payloadLen);
if (i_ok < 0)
{
/* error returned */
return i_ok;
}
}
/* Get information about timestamp scaling for this payload type */
i_ok = WebRtcNetEQ_GetTimestampScaling(MCU_inst, RTPpacket[i_k].payloadType);
if (i_ok < 0)
{
/* error returned */
return i_ok;
}
if (MCU_inst->TSscalingInitialized == 0 && MCU_inst->scalingFactor != kTSnoScaling)
{
/* Must initialize scaling with current timestamps */
MCU_inst->externalTS = RTPpacket[i_k].timeStamp;
MCU_inst->internalTS = RTPpacket[i_k].timeStamp;
MCU_inst->TSscalingInitialized = 1;
}
/* Adjust timestamp if timestamp scaling is needed (e.g. SILK or G.722) */
if (MCU_inst->TSscalingInitialized == 1)
{
WebRtc_UWord32 newTS = WebRtcNetEQ_ScaleTimestampExternalToInternal(MCU_inst,
RTPpacket[i_k].timeStamp);
/* save the incoming timestamp for next time */
MCU_inst->externalTS = RTPpacket[i_k].timeStamp;
/* add the scaled difference to last scaled timestamp and save ... */
MCU_inst->internalTS = newTS;
RTPpacket[i_k].timeStamp = newTS;
}
/* Is this a DTMF packet?*/
if (RTPpacket[i_k].payloadType == WebRtcNetEQ_DbGetPayload(&MCU_inst->codec_DB_inst,
kDecoderAVT))
{
#ifdef NETEQ_ATEVENT_DECODE
if (MCU_inst->AVT_PlayoutOn)
{
i_ok = WebRtcNetEQ_DtmfInsertEvent(&MCU_inst->DTMF_inst,
RTPpacket[i_k].payload, RTPpacket[i_k].payloadLen,
RTPpacket[i_k].timeStamp);
if (i_ok != 0)
{
return i_ok;
}
}
#endif
#ifdef NETEQ_STEREO
if (MCU_inst->usingStereo == 0)
{
/* do not set this for DTMF packets when using stereo mode */
MCU_inst->BufferStat_inst.Automode_inst.lastPackCNGorDTMF = 1;
}
#else
MCU_inst->BufferStat_inst.Automode_inst.lastPackCNGorDTMF = 1;
#endif
}
else if (WebRtcNetEQ_DbIsCNGPayload(&MCU_inst->codec_DB_inst,
RTPpacket[i_k].payloadType))
{
/* Is this a CNG packet? how should we handle this?*/
#ifdef NETEQ_CNG_CODEC
/* Get CNG sample rate */
WebRtc_UWord16 fsCng = WebRtcNetEQ_DbGetSampleRate(&MCU_inst->codec_DB_inst,
RTPpacket[i_k].payloadType);
if ((fsCng != MCU_inst->fs) && (fsCng > 8000))
{
/*
* We have received CNG with a different sample rate from what we are using
* now (must be > 8000, since we may use only one CNG type (default) for all
* frequencies). Flush buffer and signal new codec.
*/
WebRtcNetEQ_PacketBufferFlush(&MCU_inst->PacketBuffer_inst);
MCU_inst->new_codec = 1;
MCU_inst->current_Codec = -1;
}
i_ok = WebRtcNetEQ_PacketBufferInsert(&MCU_inst->PacketBuffer_inst,
&RTPpacket[i_k], &flushed);
if (i_ok < 0)
{
return RECIN_CNG_ERROR;
}
MCU_inst->BufferStat_inst.Automode_inst.lastPackCNGorDTMF = 1;
#else /* NETEQ_CNG_CODEC not defined */
return RECIN_UNKNOWNPAYLOAD;
#endif /* NETEQ_CNG_CODEC */
}
else
{
/* Reinitialize the splitting if the payload and/or the payload length has changed */
curr_Codec = WebRtcNetEQ_DbGetCodec(&MCU_inst->codec_DB_inst,
RTPpacket[i_k].payloadType);
if (curr_Codec != MCU_inst->current_Codec)
{
if (curr_Codec < 0)
{
return RECIN_UNKNOWNPAYLOAD;
}
MCU_inst->current_Codec = curr_Codec;
MCU_inst->current_Payload = RTPpacket[i_k].payloadType;
i_ok = WebRtcNetEQ_DbGetSplitInfo(&MCU_inst->PayloadSplit_inst,
(enum WebRtcNetEQDecoder) MCU_inst->current_Codec,
RTPpacket[i_k].payloadLen);
if (i_ok < 0)
{ /* error returned */
return i_ok;
}
WebRtcNetEQ_PacketBufferFlush(&MCU_inst->PacketBuffer_inst);
MCU_inst->new_codec = 1;
}
/* update post-call statistics */
if (MCU_inst->new_codec != 1) /* not if in codec change */
{
diffTS = RTPpacket[i_k].timeStamp - MCU_inst->timeStamp; /* waiting time */
if (diffTS < 0x0FFFFFFF) /* guard against re-ordering */
{
/* waiting time in ms */
diffTS = WEBRTC_SPL_UDIV(diffTS,
WEBRTC_SPL_UDIV((WebRtc_UWord32) MCU_inst->fs, 1000) );
if (diffTS < MCU_inst->statInst.minPacketDelayMs)
{
/* new all-time low */
MCU_inst->statInst.minPacketDelayMs = diffTS;
}
if (diffTS > MCU_inst->statInst.maxPacketDelayMs)
{
/* new all-time high */
MCU_inst->statInst.maxPacketDelayMs = diffTS;
}
/* Update avg waiting time:
* avgPacketDelayMs =
* (avgPacketCount * avgPacketDelayMs + diffTS)/(avgPacketCount+1)
* with proper rounding.
*/
uw32_tmp
= WEBRTC_SPL_UMUL((WebRtc_UWord32) MCU_inst->statInst.avgPacketCount,
(WebRtc_UWord32) MCU_inst->statInst.avgPacketDelayMs);
uw32_tmp
= WEBRTC_SPL_ADD_SAT_W32(uw32_tmp,
(diffTS + (MCU_inst->statInst.avgPacketCount>>1)));
uw32_tmp = WebRtcSpl_DivU32U16(uw32_tmp,
(WebRtc_UWord16) (MCU_inst->statInst.avgPacketCount + 1));
MCU_inst->statInst.avgPacketDelayMs
= (WebRtc_UWord16) WEBRTC_SPL_MIN(uw32_tmp, (WebRtc_UWord32) 65535);
/* increase counter, but not to more than 65534 */
if (MCU_inst->statInst.avgPacketCount < (0xFFFF - 1))
{
MCU_inst->statInst.avgPacketCount++;
}
}
}
/* Parse the payload and insert it into the buffer */
i_ok = WebRtcNetEQ_SplitAndInsertPayload(&RTPpacket[i_k],
&MCU_inst->PacketBuffer_inst, &MCU_inst->PayloadSplit_inst, &flushed);
if (i_ok < 0)
{
return i_ok;
}
if (MCU_inst->BufferStat_inst.Automode_inst.lastPackCNGorDTMF != 0)
{
/* first normal packet after CNG or DTMF */
MCU_inst->BufferStat_inst.Automode_inst.lastPackCNGorDTMF = -1;
}
}
/* Reset DSP timestamp etc. if packet buffer flushed */
if (flushed)
{
MCU_inst->new_codec = 1;
}
}
/*
* Update Bandwidth Estimate
* Only send the main payload to BWE
*/
if ((curr_Codec = WebRtcNetEQ_DbGetCodec(&MCU_inst->codec_DB_inst,
RTPpacket[0].payloadType)) >= 0)
{
codecPos = MCU_inst->codec_DB_inst.position[curr_Codec];
if (MCU_inst->codec_DB_inst.funcUpdBWEst[codecPos] != NULL) /* codec has BWE function */
{
if (RTPpacket[0].starts_byte1) /* check for shifted byte alignment */
{
/* re-align to 16-bit alignment */
for (i_k = 0; i_k < RTPpacket[0].payloadLen; i_k++)
{
WEBRTC_SPL_SET_BYTE(RTPpacket[0].payload,
WEBRTC_SPL_GET_BYTE(RTPpacket[0].payload, i_k+1),
i_k);
}
RTPpacket[0].starts_byte1 = 0;
}
MCU_inst->codec_DB_inst.funcUpdBWEst[codecPos](
MCU_inst->codec_DB_inst.codec_state[codecPos],
(G_CONST WebRtc_UWord16 *) RTPpacket[0].payload,
(WebRtc_Word32) RTPpacket[0].payloadLen, RTPpacket[0].seqNumber,
(WebRtc_UWord32) RTPpacket[0].timeStamp, (WebRtc_UWord32) uw32_timeRec);
}
}
if (MCU_inst->BufferStat_inst.Automode_inst.lastPackCNGorDTMF == 0)
{
/* Calculate the total speech length carried in each packet */
temp_bufsize = MCU_inst->PacketBuffer_inst.numPacketsInBuffer - temp_bufsize;
temp_bufsize *= MCU_inst->PacketBuffer_inst.packSizeSamples;
if ((temp_bufsize > 0) && (MCU_inst->BufferStat_inst.Automode_inst.lastPackCNGorDTMF
== 0) && (temp_bufsize
!= MCU_inst->BufferStat_inst.Automode_inst.packetSpeechLenSamp))
{
/* Change the auto-mode parameters if packet length has changed */
WebRtcNetEQ_SetPacketSpeechLen(&(MCU_inst->BufferStat_inst.Automode_inst),
(WebRtc_Word16) temp_bufsize, MCU_inst->fs);
}
/* update statistics */
if ((WebRtc_Word32) (RTPpacket[0].timeStamp - MCU_inst->timeStamp) >= 0
&& !MCU_inst->new_codec)
{
/*
* Only update statistics if incoming packet is not older than last played out
* packet, and if new codec flag is not set.
*/
WebRtcNetEQ_UpdateIatStatistics(&MCU_inst->BufferStat_inst.Automode_inst,
MCU_inst->PacketBuffer_inst.maxInsertPositions, RTPpacket[0].seqNumber,
RTPpacket[0].timeStamp, MCU_inst->fs,
WebRtcNetEQ_DbIsMDCodec((enum WebRtcNetEQDecoder) MCU_inst->current_Codec),
(MCU_inst->NetEqPlayoutMode == kPlayoutStreaming));
}
}
else if (MCU_inst->BufferStat_inst.Automode_inst.lastPackCNGorDTMF == -1)
{
/*
* This is first "normal" packet after CNG or DTMF.
* Reset packet time counter and measure time until next packet,
* but don't update statistics.
*/
MCU_inst->BufferStat_inst.Automode_inst.lastPackCNGorDTMF = 0;
MCU_inst->BufferStat_inst.Automode_inst.packetIatCountSamp = 0;
}
return 0;
}
int WebRtcNetEQ_GetTimestampScaling(MCUInst_t *MCU_inst, int rtpPayloadType)
{
enum WebRtcNetEQDecoder codec;
int codecNumber;
codecNumber = WebRtcNetEQ_DbGetCodec(&MCU_inst->codec_DB_inst, rtpPayloadType);
if (codecNumber < 0)
{
/* error */
return codecNumber;
}
/* cast to enumerator */
codec = (enum WebRtcNetEQDecoder) codecNumber;
/*
* The factor obtained below is the number with which the RTP timestamp must be
* multiplied to get the true sample count.
*/
switch (codec)
{
case kDecoderG722:
{
/* Use timestamp scaling with factor 2 (two output samples per RTP timestamp) */
MCU_inst->scalingFactor = kTSscalingTwo;
break;
}
case kDecoderAVT:
case kDecoderCNG:
{
/* do not change the timestamp scaling settings */
break;
}
default:
{
/* do not use timestamp scaling */
MCU_inst->scalingFactor = kTSnoScaling;
break;
}
}
return 0;
}
WebRtc_UWord32 WebRtcNetEQ_ScaleTimestampExternalToInternal(const MCUInst_t *MCU_inst,
WebRtc_UWord32 externalTS)
{
WebRtc_Word32 timestampDiff;
WebRtc_UWord32 internalTS;
/* difference between this and last incoming timestamp */
timestampDiff = externalTS - MCU_inst->externalTS;
switch (MCU_inst->scalingFactor)
{
case kTSscalingTwo:
{
/* multiply with 2 */
timestampDiff = WEBRTC_SPL_LSHIFT_W32(timestampDiff, 1);
break;
}
case kTSscalingTwoThirds:
{
/* multiply with 2/3 */
timestampDiff = WEBRTC_SPL_LSHIFT_W32(timestampDiff, 1);
timestampDiff = WebRtcSpl_DivW32W16(timestampDiff, 3);
break;
}
case kTSscalingFourThirds:
{
/* multiply with 4/3 */
timestampDiff = WEBRTC_SPL_LSHIFT_W32(timestampDiff, 2);
timestampDiff = WebRtcSpl_DivW32W16(timestampDiff, 3);
break;
}
default:
{
/* no scaling */
}
}
/* add the scaled difference to last scaled timestamp and save ... */
internalTS = MCU_inst->internalTS + timestampDiff;
return internalTS;
}
WebRtc_UWord32 WebRtcNetEQ_ScaleTimestampInternalToExternal(const MCUInst_t *MCU_inst,
WebRtc_UWord32 internalTS)
{
WebRtc_Word32 timestampDiff;
WebRtc_UWord32 externalTS;
/* difference between this and last incoming timestamp */
timestampDiff = (WebRtc_Word32) internalTS - MCU_inst->internalTS;
switch (MCU_inst->scalingFactor)
{
case kTSscalingTwo:
{
/* divide by 2 */
timestampDiff = WEBRTC_SPL_RSHIFT_W32(timestampDiff, 1);
break;
}
case kTSscalingTwoThirds:
{
/* multiply with 3/2 */
timestampDiff = WEBRTC_SPL_MUL_32_16(timestampDiff, 3);
timestampDiff = WEBRTC_SPL_RSHIFT_W32(timestampDiff, 1);
break;
}
case kTSscalingFourThirds:
{
/* multiply with 3/4 */
timestampDiff = WEBRTC_SPL_MUL_32_16(timestampDiff, 3);
timestampDiff = WEBRTC_SPL_RSHIFT_W32(timestampDiff, 2);
break;
}
default:
{
/* no scaling */
}
}
/* add the scaled difference to last scaled timestamp and save ... */
externalTS = MCU_inst->externalTS + timestampDiff;
return externalTS;
}