f7fa6276e2
This CL format the ramaining files on the audio coding module. No other changes are done, except for fixing a few long lines and TODOs without owner. BUG=issue1024 Review URL: https://webrtc-codereview.appspot.com/928012 git-svn-id: http://webrtc.googlecode.com/svn/trunk@3042 4adac7df-926f-26a2-2b94-8c16560cd09d
361 lines
9.4 KiB
C++
361 lines
9.4 KiB
C++
/*
|
|
* Copyright (c) 2012 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_g729.h"
|
|
#include "acm_common_defs.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 calls and names of used G.729 API
|
|
// file.
|
|
#include "g729_interface.h"
|
|
#endif
|
|
|
|
namespace webrtc {
|
|
|
|
#ifndef WEBRTC_CODEC_G729
|
|
|
|
ACMG729::ACMG729(WebRtc_Word16 /* codecID */)
|
|
: _encoderInstPtr(NULL),
|
|
_decoderInstPtr(NULL) {
|
|
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;
|
|
}
|
|
|
|
#else //===================== Actual Implementation =======================
|
|
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 disable 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;
|
|
}
|
|
|
|
#endif
|
|
|
|
} // namespace webrtc
|