AudioDecoder: Replace Init() with Reset()

webrtc/modules/audio_coding/neteq/audio_decoder_impl.cc

 /*
  *  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.
  */
 
@@ skipping 21 matching lines @@
 #include "webrtc/modules/audio_coding/codecs/opus/interface/opus_interface.h"
 #endif
 #ifdef WEBRTC_CODEC_PCM16
 #include "webrtc/modules/audio_coding/codecs/pcm16b/include/pcm16b.h"
 #endif
 
 namespace webrtc {
 
 // PCMu
 
-int AudioDecoderPcmU::Init() {
-  return 0;
+void AudioDecoderPcmU::Reset() {
 }
 size_t AudioDecoderPcmU::Channels() const {
   return 1;
 }
 
 int AudioDecoderPcmU::DecodeInternal(const uint8_t* encoded,
                                      size_t encoded_len,
                                      int sample_rate_hz,
                                      int16_t* decoded,
                                      SpeechType* speech_type) {
   DCHECK_EQ(sample_rate_hz, 8000);
   int16_t temp_type = 1;  // Default is speech.
   size_t ret = WebRtcG711_DecodeU(encoded, encoded_len, decoded, &temp_type);
   *speech_type = ConvertSpeechType(temp_type);
   return static_cast<int>(ret);
 }
 
 int AudioDecoderPcmU::PacketDuration(const uint8_t* encoded,
                                      size_t encoded_len) const {
   // One encoded byte per sample per channel.
   return static_cast<int>(encoded_len / Channels());
 }
 
 size_t AudioDecoderPcmUMultiCh::Channels() const {
   return channels_;
 }
 
 // PCMa
 
-int AudioDecoderPcmA::Init() {
-  return 0;
+void AudioDecoderPcmA::Reset() {
 }
 size_t AudioDecoderPcmA::Channels() const {
   return 1;
 }
 
 int AudioDecoderPcmA::DecodeInternal(const uint8_t* encoded,
                                      size_t encoded_len,
                                      int sample_rate_hz,
                                      int16_t* decoded,
                                      SpeechType* speech_type) {
@@ skipping 11 matching lines @@
 }
 
 size_t AudioDecoderPcmAMultiCh::Channels() const {
   return channels_;
 }
 
 // PCM16B
 #ifdef WEBRTC_CODEC_PCM16
 AudioDecoderPcm16B::AudioDecoderPcm16B() {}
 
-int AudioDecoderPcm16B::Init() {
-  return 0;
+void AudioDecoderPcm16B::Reset() {
 }
 size_t AudioDecoderPcm16B::Channels() const {
   return 1;
 }
 
 int AudioDecoderPcm16B::DecodeInternal(const uint8_t* encoded,
                                        size_t encoded_len,
                                        int sample_rate_hz,
                                        int16_t* decoded,
                                        SpeechType* speech_type) {
@@ skipping 18 matching lines @@
 
 size_t AudioDecoderPcm16BMultiCh::Channels() const {
   return channels_;
 }
 #endif
 
 // iLBC
 #ifdef WEBRTC_CODEC_ILBC
 AudioDecoderIlbc::AudioDecoderIlbc() {
   WebRtcIlbcfix_DecoderCreate(&dec_state_);
+  WebRtcIlbcfix_Decoderinit30Ms(dec_state_);
 }
 
 AudioDecoderIlbc::~AudioDecoderIlbc() {
   WebRtcIlbcfix_DecoderFree(dec_state_);
 }
 
 bool AudioDecoderIlbc::HasDecodePlc() const {
   return true;
 }
 
 int AudioDecoderIlbc::DecodeInternal(const uint8_t* encoded,
                                      size_t encoded_len,
                                      int sample_rate_hz,
                                      int16_t* decoded,
                                      SpeechType* speech_type) {
   DCHECK_EQ(sample_rate_hz, 8000);
   int16_t temp_type = 1;  // Default is speech.
   int ret = WebRtcIlbcfix_Decode(dec_state_, encoded, encoded_len, decoded,
                                  &temp_type);
   *speech_type = ConvertSpeechType(temp_type);
   return ret;
 }
 
 size_t AudioDecoderIlbc::DecodePlc(size_t num_frames, int16_t* decoded) {
   return WebRtcIlbcfix_NetEqPlc(dec_state_, decoded, num_frames);
 }
 
-int AudioDecoderIlbc::Init() {
-  return WebRtcIlbcfix_Decoderinit30Ms(dec_state_);
+void AudioDecoderIlbc::Reset() {
+  WebRtcIlbcfix_Decoderinit30Ms(dec_state_);
 }
 
 size_t AudioDecoderIlbc::Channels() const {
   return 1;
 }
 #endif
 
 // G.722
 #ifdef WEBRTC_CODEC_G722
 AudioDecoderG722::AudioDecoderG722() {
   WebRtcG722_CreateDecoder(&dec_state_);
+  WebRtcG722_DecoderInit(dec_state_);
 }
 
 AudioDecoderG722::~AudioDecoderG722() {
   WebRtcG722_FreeDecoder(dec_state_);
 }
 
 bool AudioDecoderG722::HasDecodePlc() const {
   return false;
 }
 
 int AudioDecoderG722::DecodeInternal(const uint8_t* encoded,
                                      size_t encoded_len,
                                      int sample_rate_hz,
                                      int16_t* decoded,
                                      SpeechType* speech_type) {
   DCHECK_EQ(sample_rate_hz, 16000);
   int16_t temp_type = 1;  // Default is speech.
   size_t ret =
       WebRtcG722_Decode(dec_state_, encoded, encoded_len, decoded, &temp_type);
   *speech_type = ConvertSpeechType(temp_type);
   return static_cast<int>(ret);
 }
 
-int AudioDecoderG722::Init() {
-  return WebRtcG722_DecoderInit(dec_state_);
+void AudioDecoderG722::Reset() {
+  WebRtcG722_DecoderInit(dec_state_);
 }
 
 int AudioDecoderG722::PacketDuration(const uint8_t* encoded,
                                      size_t encoded_len) const {
   // 1/2 encoded byte per sample per channel.
   return static_cast<int>(2 * encoded_len / Channels());
 }
 
 size_t AudioDecoderG722::Channels() const {
   return 1;
 }
 
 AudioDecoderG722Stereo::AudioDecoderG722Stereo() {
   WebRtcG722_CreateDecoder(&dec_state_left_);
   WebRtcG722_CreateDecoder(&dec_state_right_);
+  WebRtcG722_DecoderInit(dec_state_left_);
+  WebRtcG722_DecoderInit(dec_state_right_);
 }
 
 AudioDecoderG722Stereo::~AudioDecoderG722Stereo() {
   WebRtcG722_FreeDecoder(dec_state_left_);
   WebRtcG722_FreeDecoder(dec_state_right_);
 }
 
 int AudioDecoderG722Stereo::DecodeInternal(const uint8_t* encoded,
                                            size_t encoded_len,
                                            int sample_rate_hz,
@@ skipping 22 matching lines @@
   }
   *speech_type = ConvertSpeechType(temp_type);
   delete [] encoded_deinterleaved;
   return static_cast<int>(ret);
 }
 
 size_t AudioDecoderG722Stereo::Channels() const {
   return 2;
 }
 
-int AudioDecoderG722Stereo::Init() {
-  int r = WebRtcG722_DecoderInit(dec_state_left_);
-  if (r != 0)
-    return r;
-  return WebRtcG722_DecoderInit(dec_state_right_);
+void AudioDecoderG722Stereo::Reset() {
+  WebRtcG722_DecoderInit(dec_state_left_);
+  WebRtcG722_DecoderInit(dec_state_right_);
 }
 
 // Split the stereo packet and place left and right channel after each other
 // in the output array.
 void AudioDecoderG722Stereo::SplitStereoPacket(const uint8_t* encoded,
                                                size_t encoded_len,
                                                uint8_t* encoded_deinterleaved) {
   assert(encoded);
   // Regroup the 4 bits/sample so |l1 l2| |r1 r2| |l3 l4| |r3 r4| ...,
   // where "lx" is 4 bits representing left sample number x, and "rx" right
@@ skipping 16 matching lines @@
   }
 }
 #endif
 
 // Opus
 #ifdef WEBRTC_CODEC_OPUS
 AudioDecoderOpus::AudioDecoderOpus(size_t num_channels)
     : channels_(num_channels) {
   DCHECK(num_channels == 1 || num_channels == 2);
   WebRtcOpus_DecoderCreate(&dec_state_, static_cast<int>(channels_));
+  WebRtcOpus_DecoderInit(dec_state_);
 }
 
 AudioDecoderOpus::~AudioDecoderOpus() {
   WebRtcOpus_DecoderFree(dec_state_);
 }
 
 int AudioDecoderOpus::DecodeInternal(const uint8_t* encoded,
                                      size_t encoded_len,
                                      int sample_rate_hz,
                                      int16_t* decoded,
@@ skipping 22 matching lines @@
   DCHECK_EQ(sample_rate_hz, 48000);
   int16_t temp_type = 1;  // Default is speech.
   int ret = WebRtcOpus_DecodeFec(dec_state_, encoded, encoded_len, decoded,
                                  &temp_type);
   if (ret > 0)
     ret *= static_cast<int>(channels_);  // Return total number of samples.
   *speech_type = ConvertSpeechType(temp_type);
   return ret;
 }
 
-int AudioDecoderOpus::Init() {
-  return WebRtcOpus_DecoderInit(dec_state_);
+void AudioDecoderOpus::Reset() {
+  WebRtcOpus_DecoderInit(dec_state_);
 }
 
 int AudioDecoderOpus::PacketDuration(const uint8_t* encoded,
                                      size_t encoded_len) const {
   return WebRtcOpus_DurationEst(dec_state_, encoded, encoded_len);
 }
 
 int AudioDecoderOpus::PacketDurationRedundant(const uint8_t* encoded,
                                               size_t encoded_len) const {
   if (!PacketHasFec(encoded, encoded_len)) {
@@ skipping 11 matching lines @@
   return (fec == 1);
 }
 
 size_t AudioDecoderOpus::Channels() const {
   return channels_;
 }
 #endif
 
 AudioDecoderCng::AudioDecoderCng() {
   CHECK_EQ(0, WebRtcCng_CreateDec(&dec_state_));
+  WebRtcCng_InitDec(dec_state_);
 }
 
 AudioDecoderCng::~AudioDecoderCng() {
   WebRtcCng_FreeDec(dec_state_);
 }
 
-int AudioDecoderCng::Init() {
-  return WebRtcCng_InitDec(dec_state_);
+void AudioDecoderCng::Reset() {
+  WebRtcCng_InitDec(dec_state_);
 }
 
 int AudioDecoderCng::IncomingPacket(const uint8_t* payload,
                                     size_t payload_len,
                                     uint16_t rtp_sequence_number,
                                     uint32_t rtp_timestamp,
                                     uint32_t arrival_timestamp) {
   return -1;
 }
 
@@ skipping 187 matching lines @@
     case kDecoderRED:
     case kDecoderAVT:
     case kDecoderArbitrary:
     default: {
       return NULL;
     }
   }
 }
 
 }  // namespace webrtc