Update a ton of audio code to use size_t more correctly and in general reduce

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 35 matching lines @@
   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.
-  int16_t ret = WebRtcG711_DecodeU(encoded, static_cast<int16_t>(encoded_len),
-                                   decoded, &temp_type);
+  size_t ret = WebRtcG711_DecodeU(encoded, encoded_len, decoded, &temp_type);
   *speech_type = ConvertSpeechType(temp_type);
-  return ret;
+  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;
 }
 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) {
   DCHECK_EQ(sample_rate_hz, 8000);
   int16_t temp_type = 1;  // Default is speech.
-  int16_t ret = WebRtcG711_DecodeA(encoded, static_cast<int16_t>(encoded_len),
-                                   decoded, &temp_type);
+  size_t ret = WebRtcG711_DecodeA(encoded, encoded_len, decoded, &temp_type);
   *speech_type = ConvertSpeechType(temp_type);
-  return ret;
+  return static_cast<int>(ret);
 }
 
 int AudioDecoderPcmA::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 AudioDecoderPcmAMultiCh::Channels() const {
   return channels_;
@@ skipping 11 matching lines @@
 }
 
 int AudioDecoderPcm16B::DecodeInternal(const uint8_t* encoded,
                                        size_t encoded_len,
                                        int sample_rate_hz,
                                        int16_t* decoded,
                                        SpeechType* speech_type) {
   DCHECK(sample_rate_hz == 8000 || sample_rate_hz == 16000 ||
          sample_rate_hz == 32000 || sample_rate_hz == 48000)
       << "Unsupported sample rate " << sample_rate_hz;
-  int16_t ret =
-      WebRtcPcm16b_Decode(encoded, static_cast<int16_t>(encoded_len), decoded);
+  size_t ret = WebRtcPcm16b_Decode(encoded, encoded_len, decoded);
   *speech_type = ConvertSpeechType(1);
-  return ret;
+  return static_cast<int>(ret);
 }
 
 int AudioDecoderPcm16B::PacketDuration(const uint8_t* encoded,
                                        size_t encoded_len) const {
   // Two encoded byte per sample per channel.
   return static_cast<int>(encoded_len / (2 * Channels()));
 }
 
-AudioDecoderPcm16BMultiCh::AudioDecoderPcm16BMultiCh(int num_channels)
+AudioDecoderPcm16BMultiCh::AudioDecoderPcm16BMultiCh(size_t num_channels)
     : channels_(num_channels) {
   DCHECK(num_channels > 0);
 }
 
 size_t AudioDecoderPcm16BMultiCh::Channels() const {
   return channels_;
 }
 #endif
 
 // iLBC
@@ skipping 10 matching lines @@
   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,
-                                 static_cast<int16_t>(encoded_len), decoded,
+  int ret = WebRtcIlbcfix_Decode(dec_state_, encoded, encoded_len, decoded,
                                  &temp_type);
   *speech_type = ConvertSpeechType(temp_type);
   return ret;
 }
 
-int AudioDecoderIlbc::DecodePlc(int num_frames, int16_t* decoded) {
+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_);
 }
 
 size_t AudioDecoderIlbc::Channels() const {
   return 1;
 }
@@ skipping 13 matching lines @@
   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.
-  int16_t ret =
-      WebRtcG722_Decode(dec_state_, encoded, static_cast<int16_t>(encoded_len),
-                        decoded, &temp_type);
+  size_t ret =
+      WebRtcG722_Decode(dec_state_, encoded, encoded_len, decoded, &temp_type);
   *speech_type = ConvertSpeechType(temp_type);
-  return ret;
+  return static_cast<int>(ret);
 }
 
 int AudioDecoderG722::Init() {
   return 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());
@@ skipping 17 matching lines @@
                                            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.
   // De-interleave the bit-stream into two separate payloads.
   uint8_t* encoded_deinterleaved = new uint8_t[encoded_len];
   SplitStereoPacket(encoded, encoded_len, encoded_deinterleaved);
   // Decode left and right.
-  int16_t ret = WebRtcG722_Decode(dec_state_left_, encoded_deinterleaved,
-                                  static_cast<int16_t>(encoded_len / 2),
-                                  decoded, &temp_type);
-  if (ret >= 0) {
-    int decoded_len = ret;
-    ret = WebRtcG722_Decode(dec_state_right_,
-                            &encoded_deinterleaved[encoded_len / 2],
-                            static_cast<int16_t>(encoded_len / 2),
-                            &decoded[decoded_len], &temp_type);
-    if (ret == decoded_len) {
-      ret += decoded_len;  // Return total number of samples.
-      // Interleave output.
-      for (int k = ret / 2; k < ret; k++) {
-          int16_t temp = decoded[k];
-          memmove(&decoded[2 * k - ret + 2], &decoded[2 * k - ret + 1],
-                  (ret - k - 1) * sizeof(int16_t));
-          decoded[2 * k - ret + 1] = temp;
-      }
+  size_t decoded_len = WebRtcG722_Decode(dec_state_left_, encoded_deinterleaved,
+                                         encoded_len / 2, decoded, &temp_type);
+  size_t ret = WebRtcG722_Decode(
+      dec_state_right_, &encoded_deinterleaved[encoded_len / 2],
+      encoded_len / 2, &decoded[decoded_len], &temp_type);
+  if (ret == decoded_len) {
+    ret += decoded_len;  // Return total number of samples.
+    // Interleave output.
+    for (size_t k = ret / 2; k < ret; k++) {
+        int16_t temp = decoded[k];
+        memmove(&decoded[2 * k - ret + 2], &decoded[2 * k - ret + 1],
+                (ret - k - 1) * sizeof(int16_t));
+        decoded[2 * k - ret + 1] = temp;
     }
   }
   *speech_type = ConvertSpeechType(temp_type);
   delete [] encoded_deinterleaved;
-  return ret;
+  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;
@@ skipping 23 matching lines @@
     uint8_t right_byte = encoded_deinterleaved[i + 1];
     memmove(&encoded_deinterleaved[i + 1], &encoded_deinterleaved[i + 2],
             encoded_len - i - 2);
     encoded_deinterleaved[encoded_len - 1] = right_byte;
   }
 }
 #endif
 
 // Opus
 #ifdef WEBRTC_CODEC_OPUS
-AudioDecoderOpus::AudioDecoderOpus(int num_channels) : channels_(num_channels) {
+AudioDecoderOpus::AudioDecoderOpus(size_t num_channels)
+    : channels_(num_channels) {
   DCHECK(num_channels == 1 || num_channels == 2);
   WebRtcOpus_DecoderCreate(&dec_state_, static_cast<int>(channels_));
 }
 
 AudioDecoderOpus::~AudioDecoderOpus() {
   WebRtcOpus_DecoderFree(dec_state_);
 }
 
 int AudioDecoderOpus::DecodeInternal(const uint8_t* encoded,
                                      size_t encoded_len,
                                      int sample_rate_hz,
                                      int16_t* decoded,
                                      SpeechType* speech_type) {
   DCHECK_EQ(sample_rate_hz, 48000);
   int16_t temp_type = 1;  // Default is speech.
-  int ret = WebRtcOpus_Decode(dec_state_, encoded,
-                              static_cast<int16_t>(encoded_len), decoded,
+  int ret = WebRtcOpus_Decode(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::DecodeRedundantInternal(const uint8_t* encoded,
                                               size_t encoded_len,
                                               int sample_rate_hz,
                                               int16_t* decoded,
                                               SpeechType* speech_type) {
   if (!PacketHasFec(encoded, encoded_len)) {
     // This packet is a RED packet.
     return DecodeInternal(encoded, encoded_len, sample_rate_hz, decoded,
                           speech_type);
   }
 
   DCHECK_EQ(sample_rate_hz, 48000);
   int16_t temp_type = 1;  // Default is speech.
-  int ret = WebRtcOpus_DecodeFec(dec_state_, encoded,
-                                 static_cast<int16_t>(encoded_len), decoded,
+  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_);
 }
 
 int AudioDecoderOpus::PacketDuration(const uint8_t* encoded,
                                      size_t encoded_len) const {
-  return WebRtcOpus_DurationEst(dec_state_,
-                                encoded, static_cast<int>(encoded_len));
+  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)) {
     // This packet is a RED packet.
     return PacketDuration(encoded, encoded_len);
   }
 
-  return WebRtcOpus_FecDurationEst(encoded, static_cast<int>(encoded_len));
+  return WebRtcOpus_FecDurationEst(encoded, encoded_len);
 }
 
 bool AudioDecoderOpus::PacketHasFec(const uint8_t* encoded,
                                     size_t encoded_len) const {
   int fec;
-  fec = WebRtcOpus_PacketHasFec(encoded, static_cast<int>(encoded_len));
+  fec = WebRtcOpus_PacketHasFec(encoded, encoded_len);
   return (fec == 1);
 }
 
 size_t AudioDecoderOpus::Channels() const {
   return channels_;
 }
 #endif
 
 AudioDecoderCng::AudioDecoderCng() {
   CHECK_EQ(0, WebRtcCng_CreateDec(&dec_state_));
@@ skipping 205 matching lines @@
     case kDecoderRED:
     case kDecoderAVT:
     case kDecoderArbitrary:
     default: {
       return NULL;
     }
   }
 }
 
 }  // namespace webrtc