Convert channel counts to size_t.

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 24 matching lines @@
   kZeroBreakCount = 157,
 
 #if defined(OPUS_FIXED_POINT)
   kZeroBreakValue = 10,
 #else
   kZeroBreakValue = 1,
 #endif
 };
 
 int16_t WebRtcOpus_EncoderCreate(OpusEncInst** inst,
-                                 int32_t channels,
+                                 size_t channels,
                                  int32_t application) {
   int opus_app;
   if (!inst)
     return -1;
 
   switch (application) {
     case 0:
       opus_app = OPUS_APPLICATION_VOIP;
       break;
     case 1:
       opus_app = OPUS_APPLICATION_AUDIO;
       break;
     default:
       return -1;
   }
 
   OpusEncInst* state = calloc(1, sizeof(OpusEncInst));
   assert(state);
 
   // Allocate zero counters.
   state->zero_counts = calloc(channels, sizeof(size_t));
   assert(state->zero_counts);
 
   int error;
-  state->encoder = opus_encoder_create(48000, channels, opus_app,
+  state->encoder = opus_encoder_create(48000, (int)channels, opus_app,
                                        &error);
   if (error != OPUS_OK || !state->encoder) {
     WebRtcOpus_EncoderFree(state);
     return -1;
   }
 
   state->in_dtx_mode = 0;
   state->channels = channels;
 
   *inst = state;
@@ skipping 11 matching lines @@
   }
 }
 
 int WebRtcOpus_Encode(OpusEncInst* inst,
                       const int16_t* audio_in,
                       size_t samples,
                       size_t length_encoded_buffer,
                       uint8_t* encoded) {
   int res;
   size_t i;
-  int c;
+  size_t c;
 
   int16_t buffer[2 * 48 * kWebRtcOpusMaxEncodeFrameSizeMs];
 
   if (samples > 48 * kWebRtcOpusMaxEncodeFrameSizeMs) {
     return -1;
   }
 
-  const int channels = inst->channels;
+  const size_t channels = inst->channels;
   int use_buffer = 0;
 
   // Break long consecutive zeros by forcing a "1" every |kZeroBreakCount|
   // samples.
   if (inst->in_dtx_mode) {
     for (i = 0; i < samples; ++i) {
       for (c = 0; c < channels; ++c) {
         if (audio_in[i * channels + c] == 0) {
           ++inst->zero_counts[c];
           if (inst->zero_counts[c] == kZeroBreakCount) {
@@ skipping 120 matching lines @@
 }
 
 int16_t WebRtcOpus_SetComplexity(OpusEncInst* inst, int32_t complexity) {
   if (inst) {
     return opus_encoder_ctl(inst->encoder, OPUS_SET_COMPLEXITY(complexity));
   } else {
     return -1;
   }
 }
 
-int16_t WebRtcOpus_DecoderCreate(OpusDecInst** inst, int channels) {
+int16_t WebRtcOpus_DecoderCreate(OpusDecInst** inst, size_t channels) {
   int error;
   OpusDecInst* state;
 
   if (inst != NULL) {
     /* Create Opus decoder state. */
     state = (OpusDecInst*) calloc(1, sizeof(OpusDecInst));
     if (state == NULL) {
       return -1;
     }
 
     /* Create new memory, always at 48000 Hz. */
-    state->decoder = opus_decoder_create(48000, channels, &error);
+    state->decoder = opus_decoder_create(48000, (int)channels, &error);
     if (error == OPUS_OK && state->decoder != NULL) {
       /* Creation of memory all ok. */
       state->channels = channels;
       state->prev_decoded_samples = kWebRtcOpusDefaultFrameSize;
       state->in_dtx_mode = 0;
       *inst = state;
       return 0;
     }
 
     /* If memory allocation was unsuccessful, free the entire state. */
     if (state->decoder) {
       opus_decoder_destroy(state->decoder);
     }
     free(state);
   }
   return -1;
 }
 
 int16_t WebRtcOpus_DecoderFree(OpusDecInst* inst) {
   if (inst) {
     opus_decoder_destroy(inst->decoder);
     free(inst);
     return 0;
   } else {
     return -1;
   }
 }
 
-int WebRtcOpus_DecoderChannels(OpusDecInst* inst) {
+size_t WebRtcOpus_DecoderChannels(OpusDecInst* inst) {
   return inst->channels;
 }
 
 void WebRtcOpus_DecoderInit(OpusDecInst* inst) {
   opus_decoder_ctl(inst->decoder, OPUS_RESET_STATE);
   inst->in_dtx_mode = 0;
 }
 
 /* For decoder to determine if it is to output speech or comfort noise. */
 static int16_t DetermineAudioType(OpusDecInst* inst, size_t encoded_bytes) {
@@ skipping 192 matching lines @@
     return 0;
   }
 
   for (n = 0; n < channels; n++) {
     if (frame_data[0][0] & (0x80 >> ((n + 1) * (frames + 1) - 1)))
       return 1;
   }
 
   return 0;
 }