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

Add some virtual and OVERRIDEs in webrtc/modules/audio_coding/

Browse Source 
BUG=163
TBR=turaj@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/1900004

git-svn-id: http://webrtc.googlecode.com/svn/trunk@4447 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
pbos@webrtc.org 2013-07-31 15:54:00 +00:00
parent e72428442d
commit 2d1a55caed
33 changed files with 443 additions and 351 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
webrtc/modules/audio_coding/main/source/acm_amr.h
View File

@ -24,17 +24,19 @@ enum ACMAMRPackingFormat;
class ACMAMR: public ACMGenericCodec { class ACMAMR: public ACMGenericCodec {
public: public:
explicit ACMAMR(int16_t codec_id); explicit ACMAMR(int16_t codec_id);
~ACMAMR(); virtual ~ACMAMR();
// for FEC // for FEC
ACMGenericCodec* CreateInstance(void); virtual ACMGenericCodec* CreateInstance(void) OVERRIDE;
int16_t InternalEncode(uint8_t* bitstream, virtual int16_t InternalEncode(uint8_t* bitstream,
int16_t* bitstream_len_byte); int16_t* bitstream_len_byte) OVERRIDE;
int16_t InternalInitEncoder(WebRtcACMCodecParams *codec_params); virtual int16_t InternalInitEncoder(
WebRtcACMCodecParams* codec_params) OVERRIDE;
int16_t InternalInitDecoder(WebRtcACMCodecParams *codec_params); virtual int16_t InternalInitDecoder(
WebRtcACMCodecParams* codec_params) OVERRIDE;
int16_t SetAMREncoderPackingFormat( int16_t SetAMREncoderPackingFormat(
const ACMAMRPackingFormat packing_format); const ACMAMRPackingFormat packing_format);
@ -47,29 +49,29 @@ class ACMAMR: public ACMGenericCodec {
ACMAMRPackingFormat AMRDecoderPackingFormat() const; ACMAMRPackingFormat AMRDecoderPackingFormat() const;
protected: protected:
int16_t DecodeSafe(uint8_t* bitstream, virtual int16_t DecodeSafe(uint8_t* bitstream,
int16_t bitstream_len_byte, int16_t bitstream_len_byte,
int16_t* audio, int16_t* audio_samples, int16_t* audio, int16_t* audio_samples,
int8_t* speech_type); int8_t* speech_type) OVERRIDE;
int32_t CodecDef(WebRtcNetEQ_CodecDef& codec_def, virtual int32_t CodecDef(WebRtcNetEQ_CodecDef& codec_def,
const CodecInst& codec_inst); const CodecInst& codec_inst) OVERRIDE;
void DestructEncoderSafe(); virtual void DestructEncoderSafe() OVERRIDE;
void DestructDecoderSafe(); virtual void DestructDecoderSafe() OVERRIDE;
int16_t InternalCreateEncoder(); virtual int16_t InternalCreateEncoder() OVERRIDE;
int16_t InternalCreateDecoder(); virtual int16_t InternalCreateDecoder() OVERRIDE;
void InternalDestructEncoderInst(void* ptr_inst); virtual void InternalDestructEncoderInst(void* ptr_inst) OVERRIDE;
int16_t SetBitRateSafe(const int32_t rate); virtual int16_t SetBitRateSafe(const int32_t rate) OVERRIDE;
int16_t EnableDTX(); virtual int16_t EnableDTX() OVERRIDE;
int16_t DisableDTX(); virtual int16_t DisableDTX() OVERRIDE;
AMR_encinst_t_* encoder_inst_ptr_; AMR_encinst_t_* encoder_inst_ptr_;
AMR_decinst_t_* decoder_inst_ptr_; AMR_decinst_t_* decoder_inst_ptr_;

46
webrtc/modules/audio_coding/main/source/acm_amrwb.h
View File

@ -22,52 +22,54 @@ namespace webrtc {
class ACMAMRwb: public ACMGenericCodec { class ACMAMRwb: public ACMGenericCodec {
public: public:
explicit ACMAMRwb(int16_t codec_id); explicit ACMAMRwb(int16_t codec_id);
~ACMAMRwb(); virtual ~ACMAMRwb();
// for FEC // for FEC
ACMGenericCodec* CreateInstance(void); virtual ACMGenericCodec* CreateInstance(void) OVERRIDE;
int16_t InternalEncode(uint8_t* bitstream, virtual int16_t InternalEncode(uint8_t* bitstream,
int16_t* bitstream_len_byte); int16_t* bitstream_len_byte) OVERRIDE;
int16_t InternalInitEncoder(WebRtcACMCodecParams* codec_params); virtual int16_t InternalInitEncoder(
WebRtcACMCodecParams* codec_params) OVERRIDE;
int16_t InternalInitDecoder(WebRtcACMCodecParams* codec_params); virtual int16_t InternalInitDecoder(
WebRtcACMCodecParams* codec_params) OVERRIDE;
int16_t SetAMRwbEncoderPackingFormat( virtual int16_t SetAMRwbEncoderPackingFormat(
const ACMAMRPackingFormat packing_format); const ACMAMRPackingFormat packing_format);
ACMAMRPackingFormat AMRwbEncoderPackingFormat() const; virtual ACMAMRPackingFormat AMRwbEncoderPackingFormat() const;
int16_t SetAMRwbDecoderPackingFormat( virtual int16_t SetAMRwbDecoderPackingFormat(
const ACMAMRPackingFormat packing_format); const ACMAMRPackingFormat packing_format);
ACMAMRPackingFormat AMRwbDecoderPackingFormat() const; virtual ACMAMRPackingFormat AMRwbDecoderPackingFormat() const;
protected: protected:
int16_t DecodeSafe(uint8_t* bitstream, virtual int16_t DecodeSafe(uint8_t* bitstream,
int16_t bitstream_len_byte, int16_t bitstream_len_byte,
int16_t* audio, int16_t* audio_samples, int16_t* audio, int16_t* audio_samples,
int8_t* speech_type); int8_t* speech_type) OVERRIDE;
int32_t CodecDef(WebRtcNetEQ_CodecDef& codec_def, virtual int32_t CodecDef(WebRtcNetEQ_CodecDef& codec_def,
const CodecInst& codec_inst); const CodecInst& codec_inst) OVERRIDE;
void DestructEncoderSafe(); virtual void DestructEncoderSafe() OVERRIDE;
void DestructDecoderSafe(); virtual void DestructDecoderSafe() OVERRIDE;
int16_t InternalCreateEncoder(); virtual int16_t InternalCreateEncoder() OVERRIDE;
int16_t InternalCreateDecoder(); virtual int16_t InternalCreateDecoder() OVERRIDE;
void InternalDestructEncoderInst(void* ptr_inst); virtual void InternalDestructEncoderInst(void* ptr_inst) OVERRIDE;
int16_t SetBitRateSafe(const int32_t rate); virtual int16_t SetBitRateSafe(const int32_t rate) OVERRIDE;
int16_t EnableDTX(); virtual int16_t EnableDTX() OVERRIDE;
int16_t DisableDTX(); virtual int16_t DisableDTX() OVERRIDE;
AMRWB_encinst_t_* encoder_inst_ptr_; AMRWB_encinst_t_* encoder_inst_ptr_;
AMRWB_decinst_t_* decoder_inst_ptr_; AMRWB_decinst_t_* decoder_inst_ptr_;

38
webrtc/modules/audio_coding/main/source/acm_celt.h
View File

@ -22,42 +22,46 @@ namespace webrtc {
class ACMCELT : public ACMGenericCodec { class ACMCELT : public ACMGenericCodec {
public: public:
explicit ACMCELT(int16_t codec_id); explicit ACMCELT(int16_t codec_id);
~ACMCELT(); virtual ~ACMCELT();
ACMGenericCodec* CreateInstance(void); virtual ACMGenericCodec* CreateInstance(void) OVERRIDE;
int16_t InternalEncode(uint8_t* bitstream, int16_t* bitstream_len_byte); virtual int16_t InternalEncode(uint8_t* bitstream,
int16_t* bitstream_len_byte) OVERRIDE;
int16_t InternalInitEncoder(WebRtcACMCodecParams *codec_params); virtual int16_t InternalInitEncoder(
WebRtcACMCodecParams* codec_params) OVERRIDE;
int16_t InternalInitDecoder(WebRtcACMCodecParams *codec_params); virtual int16_t InternalInitDecoder(
WebRtcACMCodecParams* codec_params) OVERRIDE;
protected: protected:
int16_t DecodeSafe( virtual int16_t DecodeSafe(
uint8_t* /* bitstream */, uint8_t* /* bitstream */,
int16_t /* bitstream_len_byte */, int16_t /* bitstream_len_byte */,
int16_t* /* audio */, int16_t* /* audio */,
int16_t* /* audio_samples */, int16_t* /* audio_samples */,
int8_t* /* speech_type */); int8_t* /* speech_type */) OVERRIDE;
int32_t CodecDef(WebRtcNetEQ_CodecDef& codec_def, virtual int32_t CodecDef(WebRtcNetEQ_CodecDef& codec_def,
const CodecInst& codec_inst); const CodecInst& codec_inst) OVERRIDE;
void DestructEncoderSafe(); virtual void DestructEncoderSafe() OVERRIDE;
void DestructDecoderSafe(); virtual void DestructDecoderSafe() OVERRIDE;
int16_t InternalCreateEncoder(); virtual int16_t InternalCreateEncoder() OVERRIDE;
int16_t InternalCreateDecoder(); virtual int16_t InternalCreateDecoder() OVERRIDE;
void InternalDestructEncoderInst(void* ptr_inst); virtual void InternalDestructEncoderInst(void* ptr_inst) OVERRIDE;
bool IsTrueStereoCodec(); virtual bool IsTrueStereoCodec() OVERRIDE;
int16_t SetBitRateSafe(const int32_t rate); virtual int16_t SetBitRateSafe(const int32_t rate) OVERRIDE;
void SplitStereoPacket(uint8_t* payload, int32_t* payload_length); virtual void SplitStereoPacket(uint8_t* payload,
int32_t* payload_length) OVERRIDE;
CELT_encinst_t_* enc_inst_ptr_; CELT_encinst_t_* enc_inst_ptr_;
CELT_decinst_t_* dec_inst_ptr_; CELT_decinst_t_* dec_inst_ptr_;

3
webrtc/modules/audio_coding/main/source/acm_cng.cc
View File

@ -140,4 +140,7 @@ void ACMCNG::InternalDestructEncoderInst(void* ptr_inst) {
return; return;
} }
int16_t ACMCNG::EnableDTX() { return -1; }
int16_t ACMCNG::DisableDTX() { return -1; }
} // namespace webrtc } // namespace webrtc

41
webrtc/modules/audio_coding/main/source/acm_cng.h
View File

@ -22,44 +22,41 @@ namespace webrtc {
class ACMCNG: public ACMGenericCodec { class ACMCNG: public ACMGenericCodec {
public: public:
explicit ACMCNG(int16_t codec_id); explicit ACMCNG(int16_t codec_id);
~ACMCNG(); virtual ~ACMCNG();
// for FEC // for FEC
ACMGenericCodec* CreateInstance(void); virtual ACMGenericCodec* CreateInstance(void) OVERRIDE;
int16_t InternalEncode(uint8_t* bitstream, virtual int16_t InternalEncode(uint8_t* bitstream,
int16_t* bitstream_len_byte); int16_t* bitstream_len_byte) OVERRIDE;
int16_t InternalInitEncoder(WebRtcACMCodecParams *codec_params); virtual int16_t InternalInitEncoder(
WebRtcACMCodecParams* codec_params) OVERRIDE;
int16_t InternalInitDecoder(WebRtcACMCodecParams *codec_params); virtual int16_t InternalInitDecoder(
WebRtcACMCodecParams* codec_params) OVERRIDE;
protected: protected:
int16_t DecodeSafe(uint8_t* bitstream, virtual int16_t DecodeSafe(uint8_t* bitstream,
int16_t bitstream_len_byte, int16_t bitstream_len_byte,
int16_t* audio, int16_t* audio_samples, int16_t* audio, int16_t* audio_samples,
int8_t* speech_type); int8_t* speech_type) OVERRIDE;
int32_t CodecDef(WebRtcNetEQ_CodecDef& codec_def, virtual int32_t CodecDef(WebRtcNetEQ_CodecDef& codec_def,
const CodecInst& codec_inst); const CodecInst& codec_inst) OVERRIDE;
void DestructEncoderSafe(); virtual void DestructEncoderSafe() OVERRIDE;
void DestructDecoderSafe(); virtual void DestructDecoderSafe() OVERRIDE;
int16_t InternalCreateEncoder(); virtual int16_t InternalCreateEncoder() OVERRIDE;
int16_t InternalCreateDecoder(); virtual int16_t InternalCreateDecoder() OVERRIDE;
void InternalDestructEncoderInst(void* ptr_inst); virtual void InternalDestructEncoderInst(void* ptr_inst) OVERRIDE;
int16_t EnableDTX() { virtual int16_t EnableDTX() OVERRIDE;
return -1; virtual int16_t DisableDTX() OVERRIDE;
}
int16_t DisableDTX() {
return -1;
}
WebRtcCngEncInst* encoder_inst_ptr_; WebRtcCngEncInst* encoder_inst_ptr_;
WebRtcCngDecInst* decoder_inst_ptr_; WebRtcCngDecInst* decoder_inst_ptr_;

31
webrtc/modules/audio_coding/main/source/acm_dtmf_playout.h
View File

@ -18,35 +18,38 @@ namespace webrtc {
class ACMDTMFPlayout: public ACMGenericCodec { class ACMDTMFPlayout: public ACMGenericCodec {
public: public:
explicit ACMDTMFPlayout(int16_t codec_id); explicit ACMDTMFPlayout(int16_t codec_id);
~ACMDTMFPlayout(); virtual ~ACMDTMFPlayout();
// for FEC // for FEC
ACMGenericCodec* CreateInstance(void); virtual ACMGenericCodec* CreateInstance(void) OVERRIDE;
int16_t InternalEncode(uint8_t* bitstream, int16_t* bitstream_len_byte); virtual int16_t InternalEncode(uint8_t* bitstream,
int16_t* bitstream_len_byte) OVERRIDE;
int16_t InternalInitEncoder(WebRtcACMCodecParams *codec_params); virtual int16_t InternalInitEncoder(
WebRtcACMCodecParams* codec_params) OVERRIDE;
int16_t InternalInitDecoder(WebRtcACMCodecParams *codec_params); virtual int16_t InternalInitDecoder(
WebRtcACMCodecParams* codec_params) OVERRIDE;
protected: protected:
int16_t DecodeSafe(uint8_t* bitstream, virtual int16_t DecodeSafe(uint8_t* bitstream,
int16_t bitstream_len_byte, int16_t bitstream_len_byte,
int16_t* audio, int16_t* audio_samples, int16_t* audio, int16_t* audio_samples,
int8_t* speech_type); int8_t* speech_type) OVERRIDE;
int32_t CodecDef(WebRtcNetEQ_CodecDef& codec_def, virtual int32_t CodecDef(WebRtcNetEQ_CodecDef& codec_def,
const CodecInst& codec_inst); const CodecInst& codec_inst) OVERRIDE;
void DestructEncoderSafe(); virtual void DestructEncoderSafe() OVERRIDE;
void DestructDecoderSafe(); virtual void DestructDecoderSafe() OVERRIDE;
int16_t InternalCreateEncoder(); virtual int16_t InternalCreateEncoder() OVERRIDE;
int16_t InternalCreateDecoder(); virtual int16_t InternalCreateDecoder() OVERRIDE;
void InternalDestructEncoderInst(void* ptr_inst); virtual void InternalDestructEncoderInst(void* ptr_inst) OVERRIDE;
}; };
} // namespace webrtc } // namespace webrtc

38
webrtc/modules/audio_coding/main/source/acm_g722.h
View File

@ -25,42 +25,46 @@ struct ACMG722DecStr;
class ACMG722: public ACMGenericCodec { class ACMG722: public ACMGenericCodec {
public: public:
explicit ACMG722(int16_t codec_id); explicit ACMG722(int16_t codec_id);
~ACMG722(); virtual ~ACMG722();
// for FEC // for FEC
ACMGenericCodec* CreateInstance(void); virtual ACMGenericCodec* CreateInstance(void) OVERRIDE;
int16_t InternalEncode(uint8_t* bitstream, int16_t* bitstream_len_byte); virtual int16_t InternalEncode(uint8_t* bitstream,
int16_t* bitstream_len_byte) OVERRIDE;
int16_t InternalInitEncoder(WebRtcACMCodecParams *codec_params); virtual int16_t InternalInitEncoder(
WebRtcACMCodecParams* codec_params) OVERRIDE;
int16_t InternalInitDecoder(WebRtcACMCodecParams *codec_params); virtual int16_t InternalInitDecoder(
WebRtcACMCodecParams* codec_params) OVERRIDE;
protected: protected:
int16_t DecodeSafe(uint8_t* bitstream, virtual int16_t DecodeSafe(uint8_t* bitstream,
int16_t bitstream_len_byte, int16_t bitstream_len_byte,
int16_t* audio, int16_t* audio_samples, int16_t* audio, int16_t* audio_samples,
int8_t* speech_type); int8_t* speech_type) OVERRIDE;
int32_t CodecDef(WebRtcNetEQ_CodecDef& codec_def, virtual int32_t CodecDef(WebRtcNetEQ_CodecDef& codec_def,
const CodecInst& codec_inst); const CodecInst& codec_inst) OVERRIDE;
int32_t Add10MsDataSafe(const uint32_t timestamp, virtual int32_t Add10MsDataSafe(const uint32_t timestamp,
const int16_t* data, const int16_t* data,
const uint16_t length_smpl, const uint16_t length_smpl,
const uint8_t audio_channel); const uint8_t audio_channel) OVERRIDE;
void DestructEncoderSafe(); virtual void DestructEncoderSafe() OVERRIDE;
void DestructDecoderSafe(); virtual void DestructDecoderSafe() OVERRIDE;
int16_t InternalCreateEncoder(); virtual int16_t InternalCreateEncoder() OVERRIDE;
int16_t InternalCreateDecoder(); virtual int16_t InternalCreateDecoder() OVERRIDE;
void InternalDestructEncoderInst(void* ptr_inst); virtual void InternalDestructEncoderInst(void* ptr_inst) OVERRIDE;
void SplitStereoPacket(uint8_t* payload, int32_t* payload_length); virtual void SplitStereoPacket(uint8_t* payload,
int32_t* payload_length) OVERRIDE;
ACMG722EncStr* ptr_enc_str_; ACMG722EncStr* ptr_enc_str_;
ACMG722DecStr* ptr_dec_str_; ACMG722DecStr* ptr_dec_str_;

10
webrtc/modules/audio_coding/main/source/acm_generic_codec.cc
View File

@ -591,6 +591,10 @@ bool ACMGenericCodec::CanChangeEncodingParam(CodecInst& /*codec_inst*/) {
return true; return true;
} }
void ACMGenericCodec::CurrentRate(int32_t& /* rate_bps */) {
return;
}
int16_t ACMGenericCodec::InitDecoder(WebRtcACMCodecParams* codec_params, int16_t ACMGenericCodec::InitDecoder(WebRtcACMCodecParams* codec_params,
bool force_initialization) { bool force_initialization) {
WriteLockScoped lockCodc(codec_wrapper_lock_); WriteLockScoped lockCodc(codec_wrapper_lock_);
@ -1159,6 +1163,10 @@ bool ACMGenericCodec::IsAudioBufferFresh() const {
return is_audio_buff_fresh_; return is_audio_buff_fresh_;
} }
int16_t ACMGenericCodec::UpdateDecoderSampFreq(int16_t /* codec_id */) {
return 0;
}
// This function is replaced by codec specific functions for some codecs. // This function is replaced by codec specific functions for some codecs.
int16_t ACMGenericCodec::EncoderSampFreq(uint16_t& samp_freq_hz) { int16_t ACMGenericCodec::EncoderSampFreq(uint16_t& samp_freq_hz) {
int32_t f; int32_t f;
@ -1231,4 +1239,6 @@ int16_t ACMGenericCodec::REDPayloadISAC(const int32_t /* isac_rate */,
return -1; return -1;
} }
bool ACMGenericCodec::IsTrueStereoCodec() { return false; }
} // namespace webrtc } // namespace webrtc

12
webrtc/modules/audio_coding/main/source/acm_generic_codec.h
View File

@ -594,9 +594,7 @@ class ACMGenericCodec {
// 0 if succeeded in updating the decoder. // 0 if succeeded in updating the decoder.
// -1 if failed to update. // -1 if failed to update.
// //
virtual int16_t UpdateDecoderSampFreq(int16_t /* codec_id */) { virtual int16_t UpdateDecoderSampFreq(int16_t /* codec_id */);
return 0;
}
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
// UpdateEncoderSampFreq() // UpdateEncoderSampFreq()
@ -747,9 +745,7 @@ class ACMGenericCodec {
// -true if stereo codec // -true if stereo codec
// -false if not stereo codec. // -false if not stereo codec.
// //
virtual bool IsTrueStereoCodec() { virtual bool IsTrueStereoCodec();
return false;
}
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
// HasFrameToEncode() // HasFrameToEncode()
@ -1148,9 +1144,7 @@ class ACMGenericCodec {
// Output: // Output:
// -rate_bps : the current target rate of the codec. // -rate_bps : the current target rate of the codec.
// //
virtual void CurrentRate(int32_t& /* rate_bps */) { virtual void CurrentRate(int32_t& /* rate_bps */);
return;
}
virtual void SaveDecoderParamSafe(const WebRtcACMCodecParams* codec_params); virtual void SaveDecoderParamSafe(const WebRtcACMCodecParams* codec_params);

34
webrtc/modules/audio_coding/main/source/acm_ilbc.h
View File

@ -22,39 +22,41 @@ namespace webrtc {
class ACMILBC : public ACMGenericCodec { class ACMILBC : public ACMGenericCodec {
public: public:
explicit ACMILBC(int16_t codec_id); explicit ACMILBC(int16_t codec_id);
~ACMILBC(); virtual ~ACMILBC();
// for FEC // for FEC
ACMGenericCodec* CreateInstance(void); virtual ACMGenericCodec* CreateInstance(void) OVERRIDE;
int16_t InternalEncode(uint8_t* bitstream, virtual int16_t InternalEncode(uint8_t* bitstream,
int16_t* bitstream_len_byte); int16_t* bitstream_len_byte) OVERRIDE;
int16_t InternalInitEncoder(WebRtcACMCodecParams *codec_params); virtual int16_t InternalInitEncoder(
WebRtcACMCodecParams* codec_params) OVERRIDE;
int16_t InternalInitDecoder(WebRtcACMCodecParams *codec_params); virtual int16_t InternalInitDecoder(
WebRtcACMCodecParams* codec_params) OVERRIDE;
protected: protected:
int16_t DecodeSafe(uint8_t* bitstream, virtual int16_t DecodeSafe(uint8_t* bitstream,
int16_t bitstream_len_byte, int16_t bitstream_len_byte,
int16_t* audio, int16_t* audio,
int16_t* audio_samples, int16_t* audio_samples,
int8_t* speech_type); int8_t* speech_type) OVERRIDE;
int32_t CodecDef(WebRtcNetEQ_CodecDef& codec_def, virtual int32_t CodecDef(WebRtcNetEQ_CodecDef& codec_def,
const CodecInst& codec_inst); const CodecInst& codec_inst) OVERRIDE;
int16_t SetBitRateSafe(const int32_t rate); virtual int16_t SetBitRateSafe(const int32_t rate) OVERRIDE;
void DestructEncoderSafe(); virtual void DestructEncoderSafe() OVERRIDE;
void DestructDecoderSafe(); virtual void DestructDecoderSafe() OVERRIDE;
int16_t InternalCreateEncoder(); virtual int16_t InternalCreateEncoder() OVERRIDE;
int16_t InternalCreateDecoder(); virtual int16_t InternalCreateDecoder() OVERRIDE;
void InternalDestructEncoderInst(void* ptr_inst); virtual void InternalDestructEncoderInst(void* ptr_inst) OVERRIDE;
iLBC_encinst_t_* encoder_inst_ptr_; iLBC_encinst_t_* encoder_inst_ptr_;
iLBC_decinst_t_* decoder_inst_ptr_; iLBC_decinst_t_* decoder_inst_ptr_;

72
webrtc/modules/audio_coding/main/source/acm_isac.h
View File

@ -25,17 +25,19 @@ enum IsacCodingMode {
class ACMISAC : public ACMGenericCodec { class ACMISAC : public ACMGenericCodec {
public: public:
explicit ACMISAC(int16_t codec_id); explicit ACMISAC(int16_t codec_id);
~ACMISAC(); virtual ~ACMISAC();
// for FEC // for FEC
ACMGenericCodec* CreateInstance(void); virtual ACMGenericCodec* CreateInstance(void) OVERRIDE;
int16_t InternalEncode(uint8_t* bitstream, virtual int16_t InternalEncode(uint8_t* bitstream,
int16_t* bitstream_len_byte); int16_t* bitstream_len_byte) OVERRIDE;
int16_t InternalInitEncoder(WebRtcACMCodecParams *codec_params); virtual int16_t InternalInitEncoder(
WebRtcACMCodecParams* codec_params) OVERRIDE;
int16_t InternalInitDecoder(WebRtcACMCodecParams *codec_params); virtual int16_t InternalInitDecoder(
WebRtcACMCodecParams* codec_params) OVERRIDE;
int16_t DeliverCachedIsacData(uint8_t* bitstream, int16_t DeliverCachedIsacData(uint8_t* bitstream,
int16_t* bitstream_len_byte, int16_t* bitstream_len_byte,
@ -51,55 +53,56 @@ class ACMISAC : public ACMGenericCodec {
return -1; return -1;
} }
int16_t UpdateDecoderSampFreq(int16_t codec_id); virtual int16_t UpdateDecoderSampFreq(int16_t codec_id) OVERRIDE;
int16_t UpdateEncoderSampFreq(uint16_t samp_freq_hz); virtual int16_t UpdateEncoderSampFreq(uint16_t samp_freq_hz) OVERRIDE;
int16_t EncoderSampFreq(uint16_t& samp_freq_hz); virtual int16_t EncoderSampFreq(uint16_t& samp_freq_hz) OVERRIDE;
int32_t ConfigISACBandwidthEstimator( virtual int32_t ConfigISACBandwidthEstimator(
const uint8_t init_frame_size_msec, const uint8_t init_frame_size_msec,
const uint16_t init_rate_bit_per_sec, const uint16_t init_rate_bit_per_sec,
const bool enforce_frame_size); const bool enforce_frame_size) OVERRIDE;
int32_t SetISACMaxPayloadSize( virtual int32_t SetISACMaxPayloadSize(
const uint16_t max_payload_len_bytes); const uint16_t max_payload_len_bytes) OVERRIDE;
int32_t SetISACMaxRate(const uint32_t max_rate_bit_per_sec); virtual int32_t SetISACMaxRate(const uint32_t max_rate_bit_per_sec) OVERRIDE;
int16_t REDPayloadISAC(const int32_t isac_rate, virtual int16_t REDPayloadISAC(const int32_t isac_rate,
const int16_t isac_bw_estimate, const int16_t isac_bw_estimate,
uint8_t* payload, uint8_t* payload,
int16_t* payload_len_bytes); int16_t* payload_len_bytes) OVERRIDE;
protected: protected:
int16_t DecodeSafe(uint8_t* bitstream, virtual int16_t DecodeSafe(uint8_t* bitstream,
int16_t bitstream_len_byte, int16_t bitstream_len_byte,
int16_t* audio, int16_t* audio,
int16_t* audio_samples, int16_t* audio_samples,
int8_t* speech_type); int8_t* speech_type) OVERRIDE;
int32_t CodecDef(WebRtcNetEQ_CodecDef& codec_def, virtual int32_t CodecDef(WebRtcNetEQ_CodecDef& codec_def,
const CodecInst& codec_inst); const CodecInst& codec_inst) OVERRIDE;
void DestructEncoderSafe(); virtual void DestructEncoderSafe() OVERRIDE;
void DestructDecoderSafe(); virtual void DestructDecoderSafe() OVERRIDE;
int16_t SetBitRateSafe(const int32_t bit_rate); virtual int16_t SetBitRateSafe(const int32_t bit_rate) OVERRIDE;
int32_t GetEstimatedBandwidthSafe(); virtual int32_t GetEstimatedBandwidthSafe() OVERRIDE;
int32_t SetEstimatedBandwidthSafe(int32_t estimated_bandwidth); virtual int32_t SetEstimatedBandwidthSafe(
int32_t estimated_bandwidth) OVERRIDE;
int32_t GetRedPayloadSafe(uint8_t* red_payload, virtual int32_t GetRedPayloadSafe(uint8_t* red_payload,
int16_t* payload_bytes); int16_t* payload_bytes) OVERRIDE;
int16_t InternalCreateEncoder(); virtual int16_t InternalCreateEncoder() OVERRIDE;
int16_t InternalCreateDecoder(); virtual int16_t InternalCreateDecoder() OVERRIDE;
void InternalDestructEncoderInst(void* ptr_inst); virtual void InternalDestructEncoderInst(void* ptr_inst) OVERRIDE;
int16_t Transcode(uint8_t* bitstream, int16_t Transcode(uint8_t* bitstream,
int16_t* bitstream_len_byte, int16_t* bitstream_len_byte,
@ -107,14 +110,15 @@ class ACMISAC : public ACMGenericCodec {
int32_t rate, int32_t rate,
bool is_red); bool is_red);
void CurrentRate(int32_t& rate_bit_per_sec); virtual void CurrentRate(int32_t& rate_bit_per_sec) OVERRIDE;
void UpdateFrameLen(); void UpdateFrameLen();
bool DecoderParamsSafe(WebRtcACMCodecParams *dec_params, virtual bool DecoderParamsSafe(WebRtcACMCodecParams *dec_params,
const uint8_t payload_type); const uint8_t payload_type) OVERRIDE;
void SaveDecoderParamSafe(const WebRtcACMCodecParams* codec_params); virtual void SaveDecoderParamSafe(
const WebRtcACMCodecParams* codec_params) OVERRIDE;
ACMISACInst* codec_inst_ptr_; ACMISACInst* codec_inst_ptr_;
bool is_enc_initialized_; bool is_enc_initialized_;

38
webrtc/modules/audio_coding/main/source/acm_opus.h
View File

@ -22,41 +22,45 @@ namespace webrtc {
class ACMOpus : public ACMGenericCodec { class ACMOpus : public ACMGenericCodec {
public: public:
explicit ACMOpus(int16_t codec_id); explicit ACMOpus(int16_t codec_id);
~ACMOpus(); virtual ~ACMOpus();
ACMGenericCodec* CreateInstance(void); virtual ACMGenericCodec* CreateInstance(void) OVERRIDE;
int16_t InternalEncode(uint8_t* bitstream, int16_t* bitstream_len_byte); virtual int16_t InternalEncode(uint8_t* bitstream,
int16_t* bitstream_len_byte) OVERRIDE;
int16_t InternalInitEncoder(WebRtcACMCodecParams *codec_params); virtual int16_t InternalInitEncoder(
WebRtcACMCodecParams* codec_params) OVERRIDE;
int16_t InternalInitDecoder(WebRtcACMCodecParams *codec_params); virtual int16_t InternalInitDecoder(
WebRtcACMCodecParams* codec_params) OVERRIDE;
protected: protected:
int16_t DecodeSafe(uint8_t* bitstream, virtual int16_t DecodeSafe(uint8_t* bitstream,
int16_t bitstream_len_byte, int16_t bitstream_len_byte,
int16_t* audio, int16_t* audio,
int16_t* audio_samples, int16_t* audio_samples,
int8_t* speech_type); int8_t* speech_type) OVERRIDE;
int32_t CodecDef(WebRtcNetEQ_CodecDef& codec_def, virtual int32_t CodecDef(WebRtcNetEQ_CodecDef& codec_def,
const CodecInst& codec_inst); const CodecInst& codec_inst) OVERRIDE;
void DestructEncoderSafe(); virtual void DestructEncoderSafe() OVERRIDE;
void DestructDecoderSafe(); virtual void DestructDecoderSafe() OVERRIDE;
int16_t InternalCreateEncoder(); virtual int16_t InternalCreateEncoder() OVERRIDE;
int16_t InternalCreateDecoder(); virtual int16_t InternalCreateDecoder() OVERRIDE;
void InternalDestructEncoderInst(void* ptr_inst); virtual void InternalDestructEncoderInst(void* ptr_inst) OVERRIDE;
int16_t SetBitRateSafe(const int32_t rate); virtual int16_t SetBitRateSafe(const int32_t rate) OVERRIDE;
bool IsTrueStereoCodec(); virtual bool IsTrueStereoCodec() OVERRIDE;
void SplitStereoPacket(uint8_t* payload, int32_t* payload_length); virtual void SplitStereoPacket(uint8_t* payload,
int32_t* payload_length) OVERRIDE;
WebRtcOpusEncInst* encoder_inst_ptr_; WebRtcOpusEncInst* encoder_inst_ptr_;
WebRtcOpusDecInst* decoder_inst_ptr_; WebRtcOpusDecInst* decoder_inst_ptr_;

35
webrtc/modules/audio_coding/main/source/acm_pcm16b.h
View File

@ -18,39 +18,42 @@ namespace webrtc {
class ACMPCM16B : public ACMGenericCodec { class ACMPCM16B : public ACMGenericCodec {
public: public:
explicit ACMPCM16B(int16_t codec_id); explicit ACMPCM16B(int16_t codec_id);
~ACMPCM16B(); virtual ~ACMPCM16B();
// for FEC // for FEC
ACMGenericCodec* CreateInstance(void); virtual ACMGenericCodec* CreateInstance(void) OVERRIDE;
int16_t InternalEncode(uint8_t* bitstream, virtual int16_t InternalEncode(uint8_t* bitstream,
int16_t* bitstream_len_byte); int16_t* bitstream_len_byte) OVERRIDE;
int16_t InternalInitEncoder(WebRtcACMCodecParams *codec_params); virtual int16_t InternalInitEncoder(
WebRtcACMCodecParams* codec_params) OVERRIDE;
int16_t InternalInitDecoder(WebRtcACMCodecParams *codec_params); virtual int16_t InternalInitDecoder(
WebRtcACMCodecParams* codec_params) OVERRIDE;
protected: protected:
int16_t DecodeSafe(uint8_t* bitstream, virtual int16_t DecodeSafe(uint8_t* bitstream,
int16_t bitstream_len_byte, int16_t bitstream_len_byte,
int16_t* audio, int16_t* audio,
int16_t* audio_samples, int16_t* audio_samples,
int8_t* speech_type); int8_t* speech_type) OVERRIDE;
int32_t CodecDef(WebRtcNetEQ_CodecDef& codec_def, virtual int32_t CodecDef(WebRtcNetEQ_CodecDef& codec_def,
const CodecInst& codec_inst); const CodecInst& codec_inst) OVERRIDE;
void DestructEncoderSafe(); virtual void DestructEncoderSafe() OVERRIDE;
void DestructDecoderSafe(); virtual void DestructDecoderSafe() OVERRIDE;
int16_t InternalCreateEncoder(); virtual int16_t InternalCreateEncoder() OVERRIDE;
int16_t InternalCreateDecoder(); virtual int16_t InternalCreateDecoder() OVERRIDE;
void InternalDestructEncoderInst(void* ptr_inst); virtual void InternalDestructEncoderInst(void* ptr_inst) OVERRIDE;
void SplitStereoPacket(uint8_t* payload, int32_t* payload_length); virtual void SplitStereoPacket(uint8_t* payload,
int32_t* payload_length) OVERRIDE;
int32_t sampling_freq_hz_; int32_t sampling_freq_hz_;
}; };

35
webrtc/modules/audio_coding/main/source/acm_pcma.h
View File

@ -18,39 +18,42 @@ namespace webrtc {
class ACMPCMA : public ACMGenericCodec { class ACMPCMA : public ACMGenericCodec {
public: public:
explicit ACMPCMA(int16_t codec_id); explicit ACMPCMA(int16_t codec_id);
~ACMPCMA(); virtual ~ACMPCMA();
// for FEC // for FEC
ACMGenericCodec* CreateInstance(void); virtual ACMGenericCodec* CreateInstance(void) OVERRIDE;
int16_t InternalEncode(uint8_t* bitstream, virtual int16_t InternalEncode(uint8_t* bitstream,
int16_t* bitstream_len_byte); int16_t* bitstream_len_byte) OVERRIDE;
int16_t InternalInitEncoder(WebRtcACMCodecParams *codec_params); virtual int16_t InternalInitEncoder(
WebRtcACMCodecParams* codec_params) OVERRIDE;
int16_t InternalInitDecoder(WebRtcACMCodecParams *codec_params); virtual int16_t InternalInitDecoder(
WebRtcACMCodecParams* codec_params) OVERRIDE;
protected: protected:
int16_t DecodeSafe(uint8_t* bitstream, virtual int16_t DecodeSafe(uint8_t* bitstream,
int16_t bitstream_len_byte, int16_t bitstream_len_byte,
int16_t* audio, int16_t* audio,
int16_t* audio_samples, int16_t* audio_samples,
int8_t* speech_type); int8_t* speech_type) OVERRIDE;
int32_t CodecDef(WebRtcNetEQ_CodecDef& codec_def, virtual int32_t CodecDef(WebRtcNetEQ_CodecDef& codec_def,
const CodecInst& codec_inst); const CodecInst& codec_inst) OVERRIDE;
void DestructEncoderSafe(); virtual void DestructEncoderSafe() OVERRIDE;
void DestructDecoderSafe(); virtual void DestructDecoderSafe() OVERRIDE;
int16_t InternalCreateEncoder(); virtual int16_t InternalCreateEncoder() OVERRIDE;
int16_t InternalCreateDecoder(); virtual int16_t InternalCreateDecoder() OVERRIDE;
void InternalDestructEncoderInst(void* ptr_inst); virtual void InternalDestructEncoderInst(void* ptr_inst) OVERRIDE;
void SplitStereoPacket(uint8_t* payload, int32_t* payload_length); virtual void SplitStereoPacket(uint8_t* payload,
int32_t* payload_length) OVERRIDE;
}; };
} // namespace webrtc } // namespace webrtc

35
webrtc/modules/audio_coding/main/source/acm_pcmu.h
View File

@ -18,39 +18,42 @@ namespace webrtc {
class ACMPCMU : public ACMGenericCodec { class ACMPCMU : public ACMGenericCodec {
public: public:
explicit ACMPCMU(int16_t codec_id); explicit ACMPCMU(int16_t codec_id);
~ACMPCMU(); virtual ~ACMPCMU();
// for FEC // for FEC
ACMGenericCodec* CreateInstance(void); virtual ACMGenericCodec* CreateInstance(void) OVERRIDE;
int16_t InternalEncode(uint8_t* bitstream, virtual int16_t InternalEncode(uint8_t* bitstream,
int16_t* bitstream_len_byte); int16_t* bitstream_len_byte) OVERRIDE;
int16_t InternalInitEncoder(WebRtcACMCodecParams *codec_params); virtual int16_t InternalInitEncoder(
WebRtcACMCodecParams* codec_params) OVERRIDE;
int16_t InternalInitDecoder(WebRtcACMCodecParams *codec_params); virtual int16_t InternalInitDecoder(
WebRtcACMCodecParams* codec_params) OVERRIDE;
protected: protected:
int16_t DecodeSafe(uint8_t* bitstream, virtual int16_t DecodeSafe(uint8_t* bitstream,
int16_t bitstream_len_byte, int16_t bitstream_len_byte,
int16_t* audio, int16_t* audio,
int16_t* audio_samples, int16_t* audio_samples,
int8_t* speech_type); int8_t* speech_type) OVERRIDE;
int32_t CodecDef(WebRtcNetEQ_CodecDef& codec_def, virtual int32_t CodecDef(WebRtcNetEQ_CodecDef& codec_def,
const CodecInst& codec_inst); const CodecInst& codec_inst) OVERRIDE;
void DestructEncoderSafe(); virtual void DestructEncoderSafe() OVERRIDE;
void DestructDecoderSafe(); virtual void DestructDecoderSafe() OVERRIDE;
int16_t InternalCreateEncoder(); virtual int16_t InternalCreateEncoder() OVERRIDE;
int16_t InternalCreateDecoder(); virtual int16_t InternalCreateDecoder() OVERRIDE;
void InternalDestructEncoderInst(void* ptr_inst); virtual void InternalDestructEncoderInst(void* ptr_inst) OVERRIDE;
void SplitStereoPacket(uint8_t* payload, int32_t* payload_length); virtual void SplitStereoPacket(uint8_t* payload,
int32_t* payload_length) OVERRIDE;
}; };
} // namespace webrtc } // namespace webrtc

32
webrtc/modules/audio_coding/main/source/acm_red.h
View File

@ -18,37 +18,39 @@ namespace webrtc {
class ACMRED : public ACMGenericCodec { class ACMRED : public ACMGenericCodec {
public: public:
explicit ACMRED(int16_t codec_id); explicit ACMRED(int16_t codec_id);
~ACMRED(); virtual ~ACMRED();
// for FEC // for FEC
ACMGenericCodec* CreateInstance(void); virtual ACMGenericCodec* CreateInstance(void) OVERRIDE;
int16_t InternalEncode(uint8_t* bitstream, virtual int16_t InternalEncode(uint8_t* bitstream,
int16_t* bitstream_len_byte); int16_t* bitstream_len_byte) OVERRIDE;
int16_t InternalInitEncoder(WebRtcACMCodecParams *codec_params); virtual int16_t InternalInitEncoder(
WebRtcACMCodecParams* codec_params) OVERRIDE;
int16_t InternalInitDecoder(WebRtcACMCodecParams *codec_params); virtual int16_t InternalInitDecoder(
WebRtcACMCodecParams* codec_params) OVERRIDE;
protected: protected:
int16_t DecodeSafe(uint8_t* bitstream, virtual int16_t DecodeSafe(uint8_t* bitstream,
int16_t bitstream_len_byte, int16_t bitstream_len_byte,
int16_t* audio, int16_t* audio,
int16_t* audio_samples, int16_t* audio_samples,
int8_t* speech_type); int8_t* speech_type) OVERRIDE;
int32_t CodecDef(WebRtcNetEQ_CodecDef& codec_def, virtual int32_t CodecDef(WebRtcNetEQ_CodecDef& codec_def,
const CodecInst& codec_inst); const CodecInst& codec_inst) OVERRIDE;
void DestructEncoderSafe(); virtual void DestructEncoderSafe() OVERRIDE;
void DestructDecoderSafe(); virtual void DestructDecoderSafe() OVERRIDE;
int16_t InternalCreateEncoder(); virtual int16_t InternalCreateEncoder() OVERRIDE;
int16_t InternalCreateDecoder(); virtual int16_t InternalCreateDecoder() OVERRIDE;
void InternalDestructEncoderInst(void* ptr_inst); virtual void InternalDestructEncoderInst(void* ptr_inst) OVERRIDE;
}; };
} // namespace webrtc } // namespace webrtc

66
webrtc/modules/audio_coding/neteq/test/NETEQTEST_CodecClass.h
View File

@ -51,7 +51,7 @@ class decoder_iSAC : public NETEQTEST_Decoder
public: public:
decoder_iSAC(uint8_t pt = 0); decoder_iSAC(uint8_t pt = 0);
virtual ~decoder_iSAC(); virtual ~decoder_iSAC();
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
@ -60,7 +60,7 @@ class decoder_iSACSWB : public NETEQTEST_Decoder
public: public:
decoder_iSACSWB(uint8_t pt = 0); decoder_iSACSWB(uint8_t pt = 0);
virtual ~decoder_iSACSWB(); virtual ~decoder_iSACSWB();
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
@ -68,7 +68,7 @@ class decoder_iSACFB : public NETEQTEST_Decoder {
public: public:
decoder_iSACFB(uint8_t pt = 0); decoder_iSACFB(uint8_t pt = 0);
virtual ~decoder_iSACFB(); virtual ~decoder_iSACFB();
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
@ -77,7 +77,7 @@ class decoder_PCMU : public NETEQTEST_Decoder
public: public:
decoder_PCMU(uint8_t pt = 0); decoder_PCMU(uint8_t pt = 0);
virtual ~decoder_PCMU() {}; virtual ~decoder_PCMU() {};
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
@ -86,7 +86,7 @@ class decoder_PCMA : public NETEQTEST_Decoder
public: public:
decoder_PCMA(uint8_t pt = 0); decoder_PCMA(uint8_t pt = 0);
virtual ~decoder_PCMA() {}; virtual ~decoder_PCMA() {};
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
class decoder_PCM16B_NB : public NETEQTEST_Decoder class decoder_PCM16B_NB : public NETEQTEST_Decoder
@ -94,37 +94,37 @@ class decoder_PCM16B_NB : public NETEQTEST_Decoder
public: public:
decoder_PCM16B_NB(uint8_t pt = 0) : NETEQTEST_Decoder(kDecoderPCM16B, 8000, "PCM16 nb", pt) {}; decoder_PCM16B_NB(uint8_t pt = 0) : NETEQTEST_Decoder(kDecoderPCM16B, 8000, "PCM16 nb", pt) {};
virtual ~decoder_PCM16B_NB() {}; virtual ~decoder_PCM16B_NB() {};
virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
class decoder_PCM16B_WB : public NETEQTEST_Decoder class decoder_PCM16B_WB : public NETEQTEST_Decoder
{ {
public: public:
decoder_PCM16B_WB(uint8_t pt = 0) : NETEQTEST_Decoder(kDecoderPCM16Bwb, 16000, "PCM16 wb", pt) {}; decoder_PCM16B_WB(uint8_t pt = 0) : NETEQTEST_Decoder(kDecoderPCM16Bwb, 16000, "PCM16 wb", pt) {};
virtual ~decoder_PCM16B_WB() {}; virtual ~decoder_PCM16B_WB() {};
virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
class decoder_PCM16B_SWB32 : public NETEQTEST_Decoder class decoder_PCM16B_SWB32 : public NETEQTEST_Decoder
{ {
public: public:
decoder_PCM16B_SWB32(uint8_t pt = 0) : NETEQTEST_Decoder(kDecoderPCM16Bswb32kHz, 32000, "PCM16 swb32", pt) {}; decoder_PCM16B_SWB32(uint8_t pt = 0) : NETEQTEST_Decoder(kDecoderPCM16Bswb32kHz, 32000, "PCM16 swb32", pt) {};
virtual ~decoder_PCM16B_SWB32() {}; virtual ~decoder_PCM16B_SWB32() {};
virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
class decoder_PCM16B_SWB48 : public NETEQTEST_Decoder class decoder_PCM16B_SWB48 : public NETEQTEST_Decoder
{ {
public: public:
decoder_PCM16B_SWB48(uint8_t pt = 0) : NETEQTEST_Decoder(kDecoderPCM16Bswb48kHz, 48000, "PCM16 swb48", pt) {}; decoder_PCM16B_SWB48(uint8_t pt = 0) : NETEQTEST_Decoder(kDecoderPCM16Bswb48kHz, 48000, "PCM16 swb48", pt) {};
virtual ~decoder_PCM16B_SWB48() {}; virtual ~decoder_PCM16B_SWB48() {};
virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
class decoder_ILBC : public NETEQTEST_Decoder class decoder_ILBC : public NETEQTEST_Decoder
{ {
public: public:
decoder_ILBC(uint8_t pt = 0); decoder_ILBC(uint8_t pt = 0);
virtual ~decoder_ILBC(); virtual ~decoder_ILBC();
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
@ -133,7 +133,7 @@ class decoder_G729 : public NETEQTEST_Decoder
public: public:
decoder_G729(uint8_t pt = 0); decoder_G729(uint8_t pt = 0);
virtual ~decoder_G729(); virtual ~decoder_G729();
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
class decoder_G729_1 : public NETEQTEST_Decoder class decoder_G729_1 : public NETEQTEST_Decoder
@ -141,7 +141,7 @@ class decoder_G729_1 : public NETEQTEST_Decoder
public: public:
decoder_G729_1(uint8_t pt = 0); decoder_G729_1(uint8_t pt = 0);
virtual ~decoder_G729_1(); virtual ~decoder_G729_1();
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
@ -150,7 +150,7 @@ class decoder_G722 : public NETEQTEST_Decoder
public: public:
decoder_G722(uint8_t pt = 0); decoder_G722(uint8_t pt = 0);
virtual ~decoder_G722(); virtual ~decoder_G722();
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
@ -159,7 +159,7 @@ class decoder_G722_1_16 : public NETEQTEST_Decoder
public: public:
decoder_G722_1_16(uint8_t pt = 0); decoder_G722_1_16(uint8_t pt = 0);
virtual ~decoder_G722_1_16(); virtual ~decoder_G722_1_16();
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
class decoder_G722_1_24 : public NETEQTEST_Decoder class decoder_G722_1_24 : public NETEQTEST_Decoder
@ -167,7 +167,7 @@ class decoder_G722_1_24 : public NETEQTEST_Decoder
public: public:
decoder_G722_1_24(uint8_t pt = 0); decoder_G722_1_24(uint8_t pt = 0);
virtual ~decoder_G722_1_24(); virtual ~decoder_G722_1_24();
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
class decoder_G722_1_32 : public NETEQTEST_Decoder class decoder_G722_1_32 : public NETEQTEST_Decoder
@ -175,7 +175,7 @@ class decoder_G722_1_32 : public NETEQTEST_Decoder
public: public:
decoder_G722_1_32(uint8_t pt = 0); decoder_G722_1_32(uint8_t pt = 0);
virtual ~decoder_G722_1_32(); virtual ~decoder_G722_1_32();
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
@ -184,7 +184,7 @@ class decoder_G722_1C_24 : public NETEQTEST_Decoder
public: public:
decoder_G722_1C_24(uint8_t pt = 0); decoder_G722_1C_24(uint8_t pt = 0);
virtual ~decoder_G722_1C_24(); virtual ~decoder_G722_1C_24();
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
class decoder_G722_1C_32 : public NETEQTEST_Decoder class decoder_G722_1C_32 : public NETEQTEST_Decoder
@ -192,7 +192,7 @@ class decoder_G722_1C_32 : public NETEQTEST_Decoder
public: public:
decoder_G722_1C_32(uint8_t pt = 0); decoder_G722_1C_32(uint8_t pt = 0);
virtual ~decoder_G722_1C_32(); virtual ~decoder_G722_1C_32();
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
class decoder_G722_1C_48 : public NETEQTEST_Decoder class decoder_G722_1C_48 : public NETEQTEST_Decoder
@ -200,7 +200,7 @@ class decoder_G722_1C_48 : public NETEQTEST_Decoder
public: public:
decoder_G722_1C_48(uint8_t pt = 0); decoder_G722_1C_48(uint8_t pt = 0);
virtual ~decoder_G722_1C_48(); virtual ~decoder_G722_1C_48();
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
@ -209,7 +209,7 @@ class decoder_AMR : public NETEQTEST_Decoder
public: public:
decoder_AMR(uint8_t pt = 0); decoder_AMR(uint8_t pt = 0);
virtual ~decoder_AMR(); virtual ~decoder_AMR();
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
class decoder_AMRWB : public NETEQTEST_Decoder class decoder_AMRWB : public NETEQTEST_Decoder
@ -217,7 +217,7 @@ class decoder_AMRWB : public NETEQTEST_Decoder
public: public:
decoder_AMRWB(uint8_t pt = 0); decoder_AMRWB(uint8_t pt = 0);
virtual ~decoder_AMRWB(); virtual ~decoder_AMRWB();
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
class decoder_GSMFR : public NETEQTEST_Decoder class decoder_GSMFR : public NETEQTEST_Decoder
@ -225,7 +225,7 @@ class decoder_GSMFR : public NETEQTEST_Decoder
public: public:
decoder_GSMFR(uint8_t pt = 0); decoder_GSMFR(uint8_t pt = 0);
virtual ~decoder_GSMFR(); virtual ~decoder_GSMFR();
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
class decoder_G726 : public NETEQTEST_Decoder class decoder_G726 : public NETEQTEST_Decoder
@ -241,28 +241,28 @@ class decoder_G726_16 : public decoder_G726
{ {
public: public:
decoder_G726_16(uint8_t pt = 0) : decoder_G726(kDecoderG726_16, "G.726 (16 kbps)", pt) {}; decoder_G726_16(uint8_t pt = 0) : decoder_G726(kDecoderG726_16, "G.726 (16 kbps)", pt) {};
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
class decoder_G726_24 : public decoder_G726 class decoder_G726_24 : public decoder_G726
{ {
public: public:
decoder_G726_24(uint8_t pt = 0) : decoder_G726(kDecoderG726_24, "G.726 (24 kbps)", pt) {}; decoder_G726_24(uint8_t pt = 0) : decoder_G726(kDecoderG726_24, "G.726 (24 kbps)", pt) {};
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
class decoder_G726_32 : public decoder_G726 class decoder_G726_32 : public decoder_G726
{ {
public: public:
decoder_G726_32(uint8_t pt = 0) : decoder_G726(kDecoderG726_32, "G.726 (32 kbps)", pt) {}; decoder_G726_32(uint8_t pt = 0) : decoder_G726(kDecoderG726_32, "G.726 (32 kbps)", pt) {};
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
class decoder_G726_40 : public decoder_G726 class decoder_G726_40 : public decoder_G726
{ {
public: public:
decoder_G726_40(uint8_t pt = 0) : decoder_G726(kDecoderG726_40, "G.726 (40 kbps)", pt) {}; decoder_G726_40(uint8_t pt = 0) : decoder_G726(kDecoderG726_40, "G.726 (40 kbps)", pt) {};
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
class decoder_SPEEX : public NETEQTEST_Decoder class decoder_SPEEX : public NETEQTEST_Decoder
@ -270,7 +270,7 @@ class decoder_SPEEX : public NETEQTEST_Decoder
public: public:
decoder_SPEEX(uint8_t pt = 0, uint16_t fs = 8000); decoder_SPEEX(uint8_t pt = 0, uint16_t fs = 8000);
virtual ~decoder_SPEEX(); virtual ~decoder_SPEEX();
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
class decoder_CELT : public NETEQTEST_Decoder class decoder_CELT : public NETEQTEST_Decoder
@ -278,14 +278,14 @@ class decoder_CELT : public NETEQTEST_Decoder
public: public:
decoder_CELT(uint8_t pt = 0, uint16_t fs = 32000); decoder_CELT(uint8_t pt = 0, uint16_t fs = 32000);
virtual ~decoder_CELT(); virtual ~decoder_CELT();
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
class decoder_CELTslave : public NETEQTEST_Decoder class decoder_CELTslave : public NETEQTEST_Decoder
{ {
public: public:
decoder_CELTslave(uint8_t pt = 0, uint16_t fs = 32000); decoder_CELTslave(uint8_t pt = 0, uint16_t fs = 32000);
virtual ~decoder_CELTslave(); virtual ~decoder_CELTslave();
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
class decoder_RED : public NETEQTEST_Decoder class decoder_RED : public NETEQTEST_Decoder
@ -293,7 +293,7 @@ class decoder_RED : public NETEQTEST_Decoder
public: public:
decoder_RED(uint8_t pt = 0) : NETEQTEST_Decoder(kDecoderRED, 8000, "RED", pt) {}; decoder_RED(uint8_t pt = 0) : NETEQTEST_Decoder(kDecoderRED, 8000, "RED", pt) {};
virtual ~decoder_RED() {}; virtual ~decoder_RED() {};
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
class decoder_AVT : public NETEQTEST_Decoder class decoder_AVT : public NETEQTEST_Decoder
@ -301,7 +301,7 @@ class decoder_AVT : public NETEQTEST_Decoder
public: public:
decoder_AVT(uint8_t pt = 0) : NETEQTEST_Decoder(kDecoderAVT, 8000, "AVT", pt) {}; decoder_AVT(uint8_t pt = 0) : NETEQTEST_Decoder(kDecoderAVT, 8000, "AVT", pt) {};
virtual ~decoder_AVT() {}; virtual ~decoder_AVT() {};
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
@ -310,7 +310,7 @@ class decoder_CNG : public NETEQTEST_Decoder
public: public:
decoder_CNG(uint8_t pt = 0, uint16_t fs = 8000); decoder_CNG(uint8_t pt = 0, uint16_t fs = 8000);
virtual ~decoder_CNG(); virtual ~decoder_CNG();
int loadToNetEQ(NETEQTEST_NetEQClass & neteq); virtual int loadToNetEQ(NETEQTEST_NetEQClass & neteq) OVERRIDE;
}; };
#endif //NETEQTEST_CODECCLASS_H #endif //NETEQTEST_CODECCLASS_H

7
webrtc/modules/audio_coding/neteq/test/NETEQTEST_DummyRTPpacket.h
View File

@ -13,11 +13,10 @@
#include "NETEQTEST_RTPpacket.h" #include "NETEQTEST_RTPpacket.h"
class NETEQTEST_DummyRTPpacket : public NETEQTEST_RTPpacket class NETEQTEST_DummyRTPpacket : public NETEQTEST_RTPpacket {
{
public: public:
virtual int readFromFile(FILE *fp); virtual int readFromFile(FILE* fp) OVERRIDE;
virtual int writeToFile(FILE *fp); virtual int writeToFile(FILE* fp) OVERRIDE;
}; };
#endif // NETEQTEST_DUMMYRTPPACKET_H #endif // NETEQTEST_DUMMYRTPPACKET_H

4
webrtc/modules/audio_coding/neteq4/accelerate.h
View File

@ -51,14 +51,14 @@ class Accelerate : public TimeStretch {
// values when the signal contains no active speech. // values when the signal contains no active speech.
virtual void SetParametersForPassiveSpeech(int len, virtual void SetParametersForPassiveSpeech(int len,
int16_t* best_correlation, int16_t* best_correlation,
int* peak_index) const; int* peak_index) const OVERRIDE;
// Checks the criteria for performing the time-stretching operation and, // Checks the criteria for performing the time-stretching operation and,
// if possible, performs the time-stretching. // if possible, performs the time-stretching.
virtual ReturnCodes CheckCriteriaAndStretch( virtual ReturnCodes CheckCriteriaAndStretch(
const int16_t* input, int input_length, size_t peak_index, const int16_t* input, int input_length, size_t peak_index,
int16_t best_correlation, bool active_speech, int16_t best_correlation, bool active_speech,
AudioMultiVector<int16_t>* output) const; AudioMultiVector<int16_t>* output) const OVERRIDE;
private: private:
DISALLOW_COPY_AND_ASSIGN(Accelerate); DISALLOW_COPY_AND_ASSIGN(Accelerate);

27
webrtc/modules/audio_coding/neteq4/audio_decoder.cc
View File

@ -16,6 +16,33 @@
namespace webrtc { namespace webrtc {
int AudioDecoder::DecodeRedundant(const uint8_t* encoded,
size_t encoded_len,
int16_t* decoded,
SpeechType* speech_type) {
return Decode(encoded, encoded_len, decoded, speech_type);
}
bool AudioDecoder::HasDecodePlc() const { return false; }
int AudioDecoder::DecodePlc(int num_frames, int16_t* decoded) { return -1; }
int AudioDecoder::IncomingPacket(const uint8_t* payload,
size_t payload_len,
uint16_t rtp_sequence_number,
uint32_t rtp_timestamp,
uint32_t arrival_timestamp) {
return 0;
}
int AudioDecoder::ErrorCode() { return 0; }
int AudioDecoder::PacketDuration(const uint8_t* encoded, size_t encoded_len) {
return kNotImplemented;
}
NetEqDecoder AudioDecoder::codec_type() const { return codec_type_; }
bool AudioDecoder::CodecSupported(NetEqDecoder codec_type) { bool AudioDecoder::CodecSupported(NetEqDecoder codec_type) {
switch (codec_type) { switch (codec_type) {
case kDecoderPCMu: case kDecoderPCMu:

9
webrtc/modules/audio_coding/neteq4/background_noise.cc
View File

@ -21,6 +21,15 @@
namespace webrtc { namespace webrtc {
BackgroundNoise::BackgroundNoise(size_t num_channels)
: num_channels_(num_channels),
channel_parameters_(new ChannelParameters[num_channels_]),
mode_(kBgnOn) {
Reset();
}
BackgroundNoise::~BackgroundNoise() {}
void BackgroundNoise::Reset() { void BackgroundNoise::Reset() {
initialized_ = false; initialized_ = false;
for (size_t channel = 0; channel < num_channels_; ++channel) { for (size_t channel = 0; channel < num_channels_; ++channel) {

11
webrtc/modules/audio_coding/neteq4/background_noise.h
View File

@ -36,15 +36,8 @@ class BackgroundNoise {
// Will work anyway, but probably sound a little worse. // Will work anyway, but probably sound a little worse.
static const int kMaxLpcOrder = 8; // 32000 / 8000 + 4. static const int kMaxLpcOrder = 8; // 32000 / 8000 + 4.
explicit BackgroundNoise(size_t num_channels) explicit BackgroundNoise(size_t num_channels);
: num_channels_(num_channels), virtual ~BackgroundNoise();
channel_parameters_(new ChannelParameters[num_channels_]),
mode_(kBgnOn) {
Reset();
}
virtual ~BackgroundNoise() {
}
void Reset(); void Reset();

2
webrtc/modules/audio_coding/neteq4/decision_logic_fax.h
View File

@ -53,7 +53,7 @@ class DecisionLogicFax : public DecisionLogic {
const RTPHeader* packet_header, const RTPHeader* packet_header,
Modes prev_mode, Modes prev_mode,
bool play_dtmf, bool play_dtmf,
bool* reset_decoder); bool* reset_decoder) OVERRIDE;
private: private:
DISALLOW_COPY_AND_ASSIGN(DecisionLogicFax); DISALLOW_COPY_AND_ASSIGN(DecisionLogicFax);

9
webrtc/modules/audio_coding/neteq4/decoder_database.cc
View File

@ -17,10 +17,19 @@
namespace webrtc { namespace webrtc {
DecoderDatabase::DecoderDatabase()
: active_decoder_(-1), active_cng_decoder_(-1) {}
DecoderDatabase::~DecoderDatabase() {}
DecoderDatabase::DecoderInfo::~DecoderInfo() { DecoderDatabase::DecoderInfo::~DecoderInfo() {
if (!external) delete decoder; if (!external) delete decoder;
} }
bool DecoderDatabase::Empty() const { return decoders_.empty(); }
int DecoderDatabase::Size() const { return decoders_.size(); }
void DecoderDatabase::Reset() { void DecoderDatabase::Reset() {
decoders_.clear(); decoders_.clear();
active_decoder_ = -1; active_decoder_ = -1;

11
webrtc/modules/audio_coding/neteq4/decoder_database.h
View File

@ -65,18 +65,15 @@ class DecoderDatabase {
// only 7 bits). // only 7 bits).
static const uint8_t kRtpPayloadTypeError = 0xFF; static const uint8_t kRtpPayloadTypeError = 0xFF;
DecoderDatabase() DecoderDatabase();
: active_decoder_(-1),
active_cng_decoder_(-1) {
}
virtual ~DecoderDatabase() {} virtual ~DecoderDatabase();
// Returns true if the database is empty. // Returns true if the database is empty.
virtual bool Empty() const { return decoders_.empty(); } virtual bool Empty() const;
// Returns the number of decoders registered in the database. // Returns the number of decoders registered in the database.
virtual int Size() const { return decoders_.size(); } virtual int Size() const;
// Resets the database, erasing all registered payload types, and deleting // Resets the database, erasing all registered payload types, and deleting
// any AudioDecoder objects that were not externally created and inserted // any AudioDecoder objects that were not externally created and inserted

22
webrtc/modules/audio_coding/neteq4/delay_manager.cc
View File

@ -44,6 +44,12 @@ DelayManager::DelayManager(int max_packets_in_buffer,
Reset(); Reset();
} }
DelayManager::~DelayManager() {}
const DelayManager::IATVector& DelayManager::iat_vector() const {
return iat_vector_;
}
// Set the histogram vector to an exponentially decaying distribution // Set the histogram vector to an exponentially decaying distribution
// iat_vector_[i] = 0.5^(i+1), i = 0, 1, 2, ... // iat_vector_[i] = 0.5^(i+1), i = 0, 1, 2, ...
// iat_vector_ is in Q30. // iat_vector_ is in Q30.
@ -323,6 +329,8 @@ void DelayManager::UpdateCounters(int elapsed_time_ms) {
max_timer_ms_ += elapsed_time_ms; max_timer_ms_ += elapsed_time_ms;
} }
void DelayManager::ResetPacketIatCount() { packet_iat_count_ms_ = 0; }
void DelayManager::BufferLimits(int* lower_limit, int* higher_limit) const { void DelayManager::BufferLimits(int* lower_limit, int* higher_limit) const {
if (!lower_limit || !higher_limit) { if (!lower_limit || !higher_limit) {
LOG_F(LS_ERROR) << "NULL pointers supplied as input"; LOG_F(LS_ERROR) << "NULL pointers supplied as input";
@ -366,4 +374,18 @@ void DelayManager::LastDecoderType(NetEqDecoder decoder_type) {
last_pack_cng_or_dtmf_ = -1; last_pack_cng_or_dtmf_ = -1;
} }
} }
void DelayManager::set_extra_delay_ms(int16_t delay) {
extra_delay_ms_ = delay;
}
int DelayManager::base_target_level() const { return base_target_level_; }
void DelayManager::set_streaming_mode(bool value) { streaming_mode_ = value; }
int DelayManager::last_pack_cng_or_dtmf() const {
return last_pack_cng_or_dtmf_;
}
void DelayManager::set_last_pack_cng_or_dtmf(int value) {
last_pack_cng_or_dtmf_ = value;
}
} // namespace webrtc } // namespace webrtc

18
webrtc/modules/audio_coding/neteq4/delay_manager.h
View File

@ -33,10 +33,10 @@ class DelayManager {
// object to the DelayManager. // object to the DelayManager.
DelayManager(int max_packets_in_buffer, DelayPeakDetector* peak_detector); DelayManager(int max_packets_in_buffer, DelayPeakDetector* peak_detector);
virtual ~DelayManager() {} virtual ~DelayManager();
// Read the inter-arrival time histogram. Mainly for testing purposes. // Read the inter-arrival time histogram. Mainly for testing purposes.
virtual const IATVector& iat_vector() const { return iat_vector_; } virtual const IATVector& iat_vector() const;
// Updates the delay manager with a new incoming packet, with // Updates the delay manager with a new incoming packet, with
// |sequence_number| and |timestamp| from the RTP header. This updates the // |sequence_number| and |timestamp| from the RTP header. This updates the
@ -79,7 +79,7 @@ class DelayManager {
virtual void UpdateCounters(int elapsed_time_ms); virtual void UpdateCounters(int elapsed_time_ms);
// Reset the inter-arrival time counter to 0. // Reset the inter-arrival time counter to 0.
virtual void ResetPacketIatCount() { packet_iat_count_ms_ = 0; } virtual void ResetPacketIatCount();
// Writes the lower and higher limits which the buffer level should stay // Writes the lower and higher limits which the buffer level should stay
// within to the corresponding pointers. The values are in (fractions of) // within to the corresponding pointers. The values are in (fractions of)
@ -93,13 +93,11 @@ class DelayManager {
virtual void LastDecoderType(NetEqDecoder decoder_type); virtual void LastDecoderType(NetEqDecoder decoder_type);
// Accessors and mutators. // Accessors and mutators.
virtual void set_extra_delay_ms(int16_t delay) { extra_delay_ms_ = delay; } virtual void set_extra_delay_ms(int16_t delay);
virtual int base_target_level() const { return base_target_level_; } virtual int base_target_level() const;
virtual void set_streaming_mode(bool value) { streaming_mode_ = value; } virtual void set_streaming_mode(bool value);
virtual int last_pack_cng_or_dtmf() const { return last_pack_cng_or_dtmf_; } virtual int last_pack_cng_or_dtmf() const;
virtual void set_last_pack_cng_or_dtmf(int value) { virtual void set_last_pack_cng_or_dtmf(int value);
last_pack_cng_or_dtmf_ = value;
}
private: private:
static const int kLimitProbability = 53687091; // 1/20 in Q30. static const int kLimitProbability = 53687091; // 1/20 in Q30.

18
webrtc/modules/audio_coding/neteq4/interface/audio_decoder.h
View File

@ -81,16 +81,14 @@ class AudioDecoder {
// Same as Decode(), but interfaces to the decoders redundant decode function. // Same as Decode(), but interfaces to the decoders redundant decode function.
// The default implementation simply calls the regular Decode() method. // The default implementation simply calls the regular Decode() method.
virtual int DecodeRedundant(const uint8_t* encoded, size_t encoded_len, virtual int DecodeRedundant(const uint8_t* encoded, size_t encoded_len,
int16_t* decoded, SpeechType* speech_type) { int16_t* decoded, SpeechType* speech_type);
return Decode(encoded, encoded_len, decoded, speech_type);
}
// Indicates if the decoder implements the DecodePlc method. // Indicates if the decoder implements the DecodePlc method.
virtual bool HasDecodePlc() const { return false; } virtual bool HasDecodePlc() const;
// Calls the packet-loss concealment of the decoder to update the state after // Calls the packet-loss concealment of the decoder to update the state after
// one or several lost packets. // one or several lost packets.
virtual int DecodePlc(int num_frames, int16_t* decoded) { return -1; } virtual int DecodePlc(int num_frames, int16_t* decoded);
// Initializes the decoder. // Initializes the decoder.
virtual int Init() = 0; virtual int Init() = 0;
@ -100,19 +98,17 @@ class AudioDecoder {
size_t payload_len, size_t payload_len,
uint16_t rtp_sequence_number, uint16_t rtp_sequence_number,
uint32_t rtp_timestamp, uint32_t rtp_timestamp,
uint32_t arrival_timestamp) { return 0; } uint32_t arrival_timestamp);
// Returns the last error code from the decoder. // Returns the last error code from the decoder.
virtual int ErrorCode() { return 0; } virtual int ErrorCode();
// Returns the duration in samples of the payload in |encoded| which is // Returns the duration in samples of the payload in |encoded| which is
// |encoded_len| bytes long. Returns kNotImplemented if no duration estimate // |encoded_len| bytes long. Returns kNotImplemented if no duration estimate
// is available, or -1 in case of an error. // is available, or -1 in case of an error.
virtual int PacketDuration(const uint8_t* encoded, size_t encoded_len) { virtual int PacketDuration(const uint8_t* encoded, size_t encoded_len);
return kNotImplemented;
}
virtual NetEqDecoder codec_type() const { return codec_type_; } virtual NetEqDecoder codec_type() const;
// Returns the underlying decoder state. // Returns the underlying decoder state.
void* state() { return state_; } void* state() { return state_; }

5
webrtc/modules/audio_coding/neteq4/post_decode_vad.cc
View File

@ -12,6 +12,11 @@
namespace webrtc { namespace webrtc {
PostDecodeVad::~PostDecodeVad() {
if (vad_instance_)
WebRtcVad_Free(vad_instance_);
}
void PostDecodeVad::Enable() { void PostDecodeVad::Enable() {
if (!vad_instance_) { if (!vad_instance_) {
// Create the instance. // Create the instance.

6
webrtc/modules/audio_coding/neteq4/post_decode_vad.h
View File

@ -33,11 +33,7 @@ class PostDecodeVad {
vad_instance_(NULL) { vad_instance_(NULL) {
} }
virtual ~PostDecodeVad() { virtual ~PostDecodeVad();
if (vad_instance_) {
WebRtcVad_Free(vad_instance_);
}
}
// Enables post-decode VAD. // Enables post-decode VAD.
void Enable(); void Enable();

7
webrtc/modules/audio_coding/neteq4/test/NETEQTEST_DummyRTPpacket.h
View File

@ -13,11 +13,10 @@
#include "NETEQTEST_RTPpacket.h" #include "NETEQTEST_RTPpacket.h"
class NETEQTEST_DummyRTPpacket : public NETEQTEST_RTPpacket class NETEQTEST_DummyRTPpacket : public NETEQTEST_RTPpacket {
{
public: public:
virtual int readFromFile(FILE *fp); virtual int readFromFile(FILE* fp) OVERRIDE;
virtual int writeToFile(FILE *fp); virtual int writeToFile(FILE* fp) OVERRIDE;
}; };
#endif // NETEQTEST_DUMMYRTPPACKET_H #endif // NETEQTEST_DUMMYRTPPACKET_H

6
webrtc/modules/audio_coding/neteq4/tools/input_audio_file.cc
View File

@ -13,6 +13,12 @@
namespace webrtc { namespace webrtc {
namespace test { namespace test {
InputAudioFile::InputAudioFile(const std::string file_name) {
fp_ = fopen(file_name.c_str(), "rb");
}
InputAudioFile::~InputAudioFile() { fclose(fp_); }
bool InputAudioFile::Read(size_t samples, int16_t* destination) { bool InputAudioFile::Read(size_t samples, int16_t* destination) {
if (!fp_) { if (!fp_) {
return false; return false;

8
webrtc/modules/audio_coding/neteq4/tools/input_audio_file.h
View File

@ -23,13 +23,9 @@ namespace test {
// Class for handling a looping input audio file. // Class for handling a looping input audio file.
class InputAudioFile { class InputAudioFile {
public: public:
explicit InputAudioFile(const std::string file_name) { explicit InputAudioFile(const std::string file_name);
fp_ = fopen(file_name.c_str(), "rb");
}
virtual ~InputAudioFile() { virtual ~InputAudioFile();
fclose(fp_);
}
// Reads |samples| elements from source file to |destination|. Returns true // Reads |samples| elements from source file to |destination|. Returns true
// if the read was successful, otherwise false. If the file end is reached, // if the read was successful, otherwise false. If the file end is reached,