545 lines
12 KiB
C++
545 lines
12 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 "acm_common_defs.h"
|
|
#include "acm_g729.h"
|
|
#include "acm_neteq.h"
|
|
#include "trace.h"
|
|
#include "webrtc_neteq.h"
|
|
#include "webrtc_neteq_help_macros.h"
|
|
|
|
#ifdef WEBRTC_CODEC_G729
|
|
// NOTE! G.729 is not included in the open-source package. Modify this file or your codec
|
|
// API to match the function call and name of used G.729 API file.
|
|
// #include "g729_interface.h"
|
|
#endif
|
|
|
|
namespace webrtc
|
|
{
|
|
|
|
#ifndef WEBRTC_CODEC_G729
|
|
|
|
ACMG729::ACMG729(
|
|
WebRtc_Word16 /* codecID */)
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
ACMG729::~ACMG729()
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
WebRtc_Word16
|
|
ACMG729::InternalEncode(
|
|
WebRtc_UWord8* /* bitStream */,
|
|
WebRtc_Word16* /* bitStreamLenByte */)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
|
|
WebRtc_Word16
|
|
ACMG729::EnableDTX()
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
|
|
WebRtc_Word16
|
|
ACMG729::DisableDTX()
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
WebRtc_Word32
|
|
ACMG729::ReplaceInternalDTXSafe(
|
|
const bool /*replaceInternalDTX*/)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
WebRtc_Word32
|
|
ACMG729::IsInternalDTXReplacedSafe(
|
|
bool* /* internalDTXReplaced */)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
|
|
WebRtc_Word16
|
|
ACMG729::DecodeSafe(
|
|
WebRtc_UWord8* /* bitStream */,
|
|
WebRtc_Word16 /* bitStreamLenByte */,
|
|
WebRtc_Word16* /* audio */,
|
|
WebRtc_Word16* /* audioSamples */,
|
|
WebRtc_Word8* /* speechType */)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
|
|
WebRtc_Word16
|
|
ACMG729::InternalInitEncoder(
|
|
WebRtcACMCodecParams* /* codecParams */)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
|
|
WebRtc_Word16
|
|
ACMG729::InternalInitDecoder(
|
|
WebRtcACMCodecParams* /* codecParams */)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
|
|
WebRtc_Word32
|
|
ACMG729::CodecDef(
|
|
WebRtcNetEQ_CodecDef& /* codecDef */,
|
|
const CodecInst& /* codecInst */)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
|
|
ACMGenericCodec*
|
|
ACMG729::CreateInstance(void)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
|
|
WebRtc_Word16
|
|
ACMG729::InternalCreateEncoder()
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
|
|
void
|
|
ACMG729::DestructEncoderSafe()
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
WebRtc_Word16
|
|
ACMG729::InternalCreateDecoder()
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
|
|
void
|
|
ACMG729::DestructDecoderSafe()
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
void
|
|
ACMG729::InternalDestructEncoderInst(
|
|
void* /* ptrInst */)
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
WebRtc_Word16
|
|
ACMG729::UnregisterFromNetEqSafe(
|
|
ACMNetEQ* /* netEq */,
|
|
WebRtc_Word16 /* payloadType */)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
|
|
#else //===================== Actual Implementation =======================
|
|
|
|
// Remove when integrating a real GSM FR wrapper
|
|
extern WebRtc_Word16 WebRtcG729_CreateEnc(G729_encinst_t_** inst);
|
|
extern WebRtc_Word16 WebRtcG729_CreateDec(G729_decinst_t_** inst);
|
|
extern WebRtc_Word16 WebRtcG729_FreeEnc(G729_encinst_t_* inst);
|
|
extern WebRtc_Word16 WebRtcG729_FreeDec(G729_decinst_t_* inst);
|
|
extern WebRtc_Word16 WebRtcG729_Encode(G729_encinst_t_* encInst, WebRtc_Word16* input,
|
|
WebRtc_Word16 len, WebRtc_Word16* output);
|
|
extern WebRtc_Word16 WebRtcG729_EncoderInit(G729_encinst_t_* encInst, WebRtc_Word16 mode);
|
|
extern WebRtc_Word16 WebRtcG729_Decode(G729_decinst_t_* decInst);
|
|
extern WebRtc_Word16 WebRtcG729_DecodeBwe(G729_decinst_t_* decInst, WebRtc_Word16* input);
|
|
extern WebRtc_Word16 WebRtcG729_DecodePlc(G729_decinst_t_* decInst);
|
|
extern WebRtc_Word16 WebRtcG729_DecoderInit(G729_decinst_t_* decInst);
|
|
|
|
|
|
ACMG729::ACMG729(
|
|
WebRtc_Word16 codecID):
|
|
_encoderInstPtr(NULL),
|
|
_decoderInstPtr(NULL)
|
|
{
|
|
_codecID = codecID;
|
|
_hasInternalDTX = true;
|
|
return;
|
|
}
|
|
|
|
|
|
ACMG729::~ACMG729()
|
|
{
|
|
if(_encoderInstPtr != NULL)
|
|
{
|
|
// Delete encoder memory
|
|
WebRtcG729_FreeEnc(_encoderInstPtr);
|
|
_encoderInstPtr = NULL;
|
|
}
|
|
if(_decoderInstPtr != NULL)
|
|
{
|
|
// Delete decoder memory
|
|
WebRtcG729_FreeDec(_decoderInstPtr);
|
|
_decoderInstPtr = NULL;
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
WebRtc_Word16
|
|
ACMG729::InternalEncode(
|
|
WebRtc_UWord8* bitStream,
|
|
WebRtc_Word16* bitStreamLenByte)
|
|
{
|
|
// Initialize before entering the loop
|
|
WebRtc_Word16 noEncodedSamples = 0;
|
|
WebRtc_Word16 tmpLenByte = 0;
|
|
WebRtc_Word16 vadDecision = 0;
|
|
*bitStreamLenByte = 0;
|
|
while(noEncodedSamples < _frameLenSmpl)
|
|
{
|
|
// Call G.729 encoder with pointer to encoder memory, input
|
|
// audio, number of samples and bitsream
|
|
tmpLenByte = WebRtcG729_Encode(_encoderInstPtr,
|
|
&_inAudio[_inAudioIxRead], 80,
|
|
(WebRtc_Word16*)(&(bitStream[*bitStreamLenByte])));
|
|
|
|
// increment the read index this tell the caller that how far
|
|
// we have gone forward in reading the audio buffer
|
|
_inAudioIxRead += 80;
|
|
|
|
// sanity check
|
|
if(tmpLenByte < 0)
|
|
{
|
|
// error has happened
|
|
*bitStreamLenByte = 0;
|
|
return -1;
|
|
}
|
|
|
|
// increment number of written bytes
|
|
*bitStreamLenByte += tmpLenByte;
|
|
switch(tmpLenByte)
|
|
{
|
|
case 0:
|
|
{
|
|
if(0 == noEncodedSamples)
|
|
{
|
|
// this is the first 10 ms in this packet and there is
|
|
// no data generated, perhaps DTX is enabled and the
|
|
// codec is not generating any bit-stream for this 10 ms.
|
|
// we do not continue encoding this frame.
|
|
return 0;
|
|
}
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
// check if G.729 internal DTX is enabled
|
|
if(_hasInternalDTX && _dtxEnabled)
|
|
{
|
|
vadDecision = 0;
|
|
for(WebRtc_Word16 n = 0; n < MAX_FRAME_SIZE_10MSEC; n++)
|
|
{
|
|
_vadLabel[n] = vadDecision;
|
|
}
|
|
}
|
|
// we got a SID and have to send out this packet no matter
|
|
// how much audio we have encoded
|
|
return *bitStreamLenByte;
|
|
}
|
|
case 10:
|
|
{
|
|
vadDecision = 1;
|
|
// this is a valid length just continue encoding
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
// update number of encoded samples
|
|
noEncodedSamples += 80;
|
|
}
|
|
|
|
// update VAD decision vector
|
|
if(_hasInternalDTX && !vadDecision && _dtxEnabled)
|
|
{
|
|
for(WebRtc_Word16 n = 0; n < MAX_FRAME_SIZE_10MSEC; n++)
|
|
{
|
|
_vadLabel[n] = vadDecision;
|
|
}
|
|
}
|
|
|
|
// done encoding, return number of encoded bytes
|
|
return *bitStreamLenByte;
|
|
}
|
|
|
|
|
|
WebRtc_Word16
|
|
ACMG729::EnableDTX()
|
|
{
|
|
if(_dtxEnabled)
|
|
{
|
|
// DTX already enabled, do nothing
|
|
return 0;
|
|
}
|
|
else if(_encoderExist)
|
|
{
|
|
// Re-init the G.729 encoder to turn on DTX
|
|
if(WebRtcG729_EncoderInit(_encoderInstPtr, 1) < 0)
|
|
{
|
|
return -1;
|
|
}
|
|
_dtxEnabled = true;
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
|
|
WebRtc_Word16
|
|
ACMG729::DisableDTX()
|
|
{
|
|
if(!_dtxEnabled)
|
|
{
|
|
// DTX already dissabled, do nothing
|
|
return 0;
|
|
}
|
|
else if(_encoderExist)
|
|
{
|
|
// Re-init the G.729 decoder to turn off DTX
|
|
if(WebRtcG729_EncoderInit(_encoderInstPtr, 0) < 0)
|
|
{
|
|
return -1;
|
|
}
|
|
_dtxEnabled = false;
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
// encoder doesn't exists, therefore disabling is harmless
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
WebRtc_Word32
|
|
ACMG729::ReplaceInternalDTXSafe(
|
|
const bool replaceInternalDTX)
|
|
{
|
|
// This function is used to dissable the G.729 built in DTX and use an
|
|
// external instead.
|
|
|
|
if(replaceInternalDTX == _hasInternalDTX)
|
|
{
|
|
// Make sure we keep the DTX/VAD setting if possible
|
|
bool oldEnableDTX = _dtxEnabled;
|
|
bool oldEnableVAD = _vadEnabled;
|
|
ACMVADMode oldMode = _vadMode;
|
|
if (replaceInternalDTX)
|
|
{
|
|
// Disable internal DTX before enabling external DTX
|
|
DisableDTX();
|
|
}
|
|
else
|
|
{
|
|
// Disable external DTX before enabling internal
|
|
ACMGenericCodec::DisableDTX();
|
|
}
|
|
_hasInternalDTX = !replaceInternalDTX;
|
|
WebRtc_Word16 status = SetVADSafe(oldEnableDTX, oldEnableVAD, oldMode);
|
|
// Check if VAD status has changed from inactive to active, or if error was
|
|
// reported
|
|
if (status == 1) {
|
|
_vadEnabled = true;
|
|
return status;
|
|
} else if (status < 0) {
|
|
_hasInternalDTX = replaceInternalDTX;
|
|
return -1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
WebRtc_Word32
|
|
ACMG729::IsInternalDTXReplacedSafe(
|
|
bool* internalDTXReplaced)
|
|
{
|
|
// Get status of wether DTX is replaced or not
|
|
*internalDTXReplaced = !_hasInternalDTX;
|
|
return 0;
|
|
}
|
|
|
|
|
|
WebRtc_Word16
|
|
ACMG729::DecodeSafe(
|
|
WebRtc_UWord8* /* bitStream */,
|
|
WebRtc_Word16 /* bitStreamLenByte */,
|
|
WebRtc_Word16* /* audio */,
|
|
WebRtc_Word16* /* audioSamples */,
|
|
WebRtc_Word8* /* speechType */)
|
|
{
|
|
// This function is not used. G.729 decoder is called from inside NetEQ
|
|
return 0;
|
|
}
|
|
|
|
|
|
WebRtc_Word16
|
|
ACMG729::InternalInitEncoder(
|
|
WebRtcACMCodecParams* codecParams)
|
|
{
|
|
// Init G.729 encoder
|
|
return WebRtcG729_EncoderInit(_encoderInstPtr,
|
|
((codecParams->enableDTX)? 1:0));
|
|
}
|
|
|
|
|
|
WebRtc_Word16
|
|
ACMG729::InternalInitDecoder(
|
|
WebRtcACMCodecParams* /* codecParams */)
|
|
{
|
|
// Init G.729 decoder
|
|
return WebRtcG729_DecoderInit(_decoderInstPtr);
|
|
}
|
|
|
|
|
|
WebRtc_Word32
|
|
ACMG729::CodecDef(
|
|
WebRtcNetEQ_CodecDef& codecDef,
|
|
const CodecInst& codecInst)
|
|
{
|
|
if (!_decoderInitialized)
|
|
{
|
|
// Todo:
|
|
// log error
|
|
return -1;
|
|
}
|
|
|
|
// Fill up the structure by calling
|
|
// "SET_CODEC_PAR" & "SET_G729_FUNCTION."
|
|
// Then call NetEQ to add the codec to it's
|
|
// database.
|
|
SET_CODEC_PAR((codecDef), kDecoderG729, codecInst.pltype,
|
|
_decoderInstPtr, 8000);
|
|
SET_G729_FUNCTIONS((codecDef));
|
|
return 0;
|
|
}
|
|
|
|
|
|
ACMGenericCodec*
|
|
ACMG729::CreateInstance(void)
|
|
{
|
|
// Function not used
|
|
return NULL;
|
|
}
|
|
|
|
|
|
WebRtc_Word16
|
|
ACMG729::InternalCreateEncoder()
|
|
{
|
|
// Create encoder memory
|
|
return WebRtcG729_CreateEnc(&_encoderInstPtr);
|
|
}
|
|
|
|
|
|
void
|
|
ACMG729::DestructEncoderSafe()
|
|
{
|
|
// Free encoder memory
|
|
_encoderExist = false;
|
|
_encoderInitialized = false;
|
|
if(_encoderInstPtr != NULL)
|
|
{
|
|
WebRtcG729_FreeEnc(_encoderInstPtr);
|
|
_encoderInstPtr = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
WebRtc_Word16
|
|
ACMG729::InternalCreateDecoder()
|
|
{
|
|
// Create decoder memory
|
|
return WebRtcG729_CreateDec(&_decoderInstPtr);
|
|
}
|
|
|
|
|
|
void
|
|
ACMG729::DestructDecoderSafe()
|
|
{
|
|
// Free decoder memory
|
|
_decoderExist = false;
|
|
_decoderInitialized = false;
|
|
if(_decoderInstPtr != NULL)
|
|
{
|
|
WebRtcG729_FreeDec(_decoderInstPtr);
|
|
_decoderInstPtr = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
ACMG729::InternalDestructEncoderInst(
|
|
void* ptrInst)
|
|
{
|
|
if(ptrInst != NULL)
|
|
{
|
|
WebRtcG729_FreeEnc((G729_encinst_t_*)ptrInst);
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
WebRtc_Word16
|
|
ACMG729::UnregisterFromNetEqSafe(
|
|
ACMNetEQ* netEq,
|
|
WebRtc_Word16 payloadType)
|
|
{
|
|
// Remove codec from the NetEQ database
|
|
if(payloadType != _decoderParams.codecInstant.pltype)
|
|
{
|
|
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, _uniqueID,
|
|
"Cannot unregister codec %s given payload-type %d does not match \
|
|
the stored payload type",
|
|
_decoderParams.codecInstant.plname,
|
|
payloadType,
|
|
_decoderParams.codecInstant.pltype);
|
|
return -1;
|
|
}
|
|
return netEq->RemoveCodec(kDecoderG729);
|
|
}
|
|
|
|
#endif
|
|
|
|
} // namespace webrtc
|