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

webrtc/modules/audio_coding/codecs/opus/opus_interface.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.
  */
 
@@ skipping 62 matching lines @@
     opus_encoder_destroy(inst->encoder);
     free(inst);
     return 0;
   } else {
     return -1;
   }
 }
 
 int WebRtcOpus_Encode(OpusEncInst* inst,
                       const int16_t* audio_in,
-                      int16_t samples,
-                      int16_t length_encoded_buffer,
+                      size_t samples,
+                      size_t length_encoded_buffer,
                       uint8_t* encoded) {
   int res;
 
   if (samples > 48 * kWebRtcOpusMaxEncodeFrameSizeMs) {
     return -1;
   }
 
   res = opus_encode(inst->encoder,
                     (const opus_int16*)audio_in,
-                    samples,
+                    (int)samples,
                     encoded,
-                    length_encoded_buffer);
+                    (opus_int32)length_encoded_buffer);
 
   if (res == 1) {
     // Indicates DTX since the packet has nothing but a header. In principle,
     // there is no need to send this packet. However, we do transmit the first
     // occurrence to let the decoder know that the encoder enters DTX mode.
     if (inst->in_dtx_mode) {
       return 0;
     } else {
       inst->in_dtx_mode = 1;
       return 1;
@@ skipping 146 matching lines @@
 int16_t WebRtcOpus_DecoderInit(OpusDecInst* inst) {
   int error = opus_decoder_ctl(inst->decoder, OPUS_RESET_STATE);
   if (error == OPUS_OK) {
     inst->in_dtx_mode = 0;
     return 0;
   }
   return -1;
 }
 
 /* For decoder to determine if it is to output speech or comfort noise. */
-static int16_t DetermineAudioType(OpusDecInst* inst, int16_t encoded_bytes) {
+static int16_t DetermineAudioType(OpusDecInst* inst, size_t encoded_bytes) {
   // Audio type becomes comfort noise if |encoded_byte| is 1 and keeps
   // to be so if the following |encoded_byte| are 0 or 1.
   if (encoded_bytes == 0 && inst->in_dtx_mode) {
     return 2;  // Comfort noise.
   } else if (encoded_bytes == 1) {
     inst->in_dtx_mode = 1;
     return 2;  // Comfort noise.
   } else {
     inst->in_dtx_mode = 0;
     return 0;  // Speech.
   }
 }
 
 /* |frame_size| is set to maximum Opus frame size in the normal case, and
  * is set to the number of samples needed for PLC in case of losses.
  * It is up to the caller to make sure the value is correct. */
 static int DecodeNative(OpusDecInst* inst, const uint8_t* encoded,
-                        int16_t encoded_bytes, int frame_size,
+                        size_t encoded_bytes, int frame_size,
                         int16_t* decoded, int16_t* audio_type, int decode_fec) {
-  int res = opus_decode(inst->decoder, encoded, encoded_bytes,
+  int res = opus_decode(inst->decoder, encoded, (opus_int32)encoded_bytes,
                         (opus_int16*)decoded, frame_size, decode_fec);
 
   if (res <= 0)
     return -1;
 
   *audio_type = DetermineAudioType(inst, encoded_bytes);
 
   return res;
 }
 
 int WebRtcOpus_Decode(OpusDecInst* inst, const uint8_t* encoded,
-                      int16_t encoded_bytes, int16_t* decoded,
+                      size_t encoded_bytes, int16_t* decoded,
                       int16_t* audio_type) {
   int decoded_samples;
 
   if (encoded_bytes == 0) {
     *audio_type = DetermineAudioType(inst, encoded_bytes);
     decoded_samples = WebRtcOpus_DecodePlc(inst, decoded, 1);
   } else {
     decoded_samples = DecodeNative(inst,
                                    encoded,
                                    encoded_bytes,
@@ skipping 27 matching lines @@
   decoded_samples = DecodeNative(inst, NULL, 0, plc_samples,
                                  decoded, &audio_type, 0);
   if (decoded_samples < 0) {
     return -1;
   }
 
   return decoded_samples;
 }
 
 int WebRtcOpus_DecodeFec(OpusDecInst* inst, const uint8_t* encoded,
-                         int16_t encoded_bytes, int16_t* decoded,
+                         size_t encoded_bytes, int16_t* decoded,
                          int16_t* audio_type) {
   int decoded_samples;
   int fec_samples;
 
   if (WebRtcOpus_PacketHasFec(encoded, encoded_bytes) != 1) {
     return 0;
   }
 
   fec_samples = opus_packet_get_samples_per_frame(encoded, 48000);
 
   decoded_samples = DecodeNative(inst, encoded, encoded_bytes,
                                  fec_samples, decoded, audio_type, 1);
   if (decoded_samples < 0) {
     return -1;
   }
 
   return decoded_samples;
 }
 
 int WebRtcOpus_DurationEst(OpusDecInst* inst,
                            const uint8_t* payload,
-                           int payload_length_bytes) {
+                           size_t payload_length_bytes) {
   int frames, samples;
-  frames = opus_packet_get_nb_frames(payload, payload_length_bytes);
+  frames = opus_packet_get_nb_frames(payload, (opus_int32)payload_length_bytes);
   if (frames < 0) {
     /* Invalid payload data. */
     return 0;
   }
   samples = frames * opus_packet_get_samples_per_frame(payload, 48000);
   if (samples < 120 || samples > 5760) {
     /* Invalid payload duration. */
     return 0;
   }
   return samples;
 }
 
 int WebRtcOpus_FecDurationEst(const uint8_t* payload,
-                              int payload_length_bytes) {
+                              size_t payload_length_bytes) {
   int samples;
   if (WebRtcOpus_PacketHasFec(payload, payload_length_bytes) != 1) {
     return 0;
   }
 
   samples = opus_packet_get_samples_per_frame(payload, 48000);
   if (samples < 480 || samples > 5760) {
     /* Invalid payload duration. */
     return 0;
   }
   return samples;
 }
 
 int WebRtcOpus_PacketHasFec(const uint8_t* payload,
-                            int payload_length_bytes) {
+                            size_t payload_length_bytes) {
   int frames, channels, payload_length_ms;
   int n;
   opus_int16 frame_sizes[48];
   const unsigned char *frame_data[48];
 
-  if (payload == NULL || payload_length_bytes <= 0)
+  if (payload == NULL || payload_length_bytes == 0)
     return 0;
 
   /* In CELT_ONLY mode, packets should not have FEC. */
   if (payload[0] & 0x80)
     return 0;
 
   payload_length_ms = opus_packet_get_samples_per_frame(payload, 48000) / 48;
   if (10 > payload_length_ms)
     payload_length_ms = 10;
 
@@ skipping 12 matching lines @@
     case 60: {
       frames = 3;
       break;
     }
     default: {
       return 0; // It is actually even an invalid packet.
     }
   }
 
   /* The following is to parse the LBRR flags. */
-  if (opus_packet_parse(payload, payload_length_bytes, NULL, frame_data,
-                        frame_sizes, NULL) < 0) {
+  if (opus_packet_parse(payload, (opus_int32)payload_length_bytes, NULL,
+                        frame_data, frame_sizes, NULL) < 0) {
     return 0;
   }
 
   if (frame_sizes[0] <= 1) {
     return 0;
   }
 
   for (n = 0; n < channels; n++) {
     if (frame_data[0][0] & (0x80 >> ((n + 1) * (frames + 1) - 1)))
       return 1;
   }
 
   return 0;
 }