Convert some more things to size_t.

webrtc/modules/audio_device/android/opensles_player.cc

 /*
  *  Copyright (c) 2015 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.
  */
 
 #include "webrtc/modules/audio_device/android/opensles_player.h"
 
 #include <android/log.h>
 
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/checks.h"
+#include "webrtc/base/format_macros.h"
 #include "webrtc/modules/audio_device/android/audio_manager.h"
 #include "webrtc/modules/audio_device/android/fine_audio_buffer.h"
 
 #define TAG "OpenSLESPlayer"
 #define ALOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, TAG, __VA_ARGS__)
 #define ALOGD(...) __android_log_print(ANDROID_LOG_DEBUG, TAG, __VA_ARGS__)
 #define ALOGE(...) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__)
 #define ALOGW(...) __android_log_print(ANDROID_LOG_WARN, TAG, __VA_ARGS__)
 #define ALOGI(...) __android_log_print(ANDROID_LOG_INFO, TAG, __VA_ARGS__)
 
@@ skipping 148 matching lines @@
   const int sample_rate_hz = audio_parameters_.sample_rate();
   ALOGD("SetPlayoutSampleRate(%d)", sample_rate_hz);
   audio_device_buffer_->SetPlayoutSampleRate(sample_rate_hz);
   const int channels = audio_parameters_.channels();
   ALOGD("SetPlayoutChannels(%d)", channels);
   audio_device_buffer_->SetPlayoutChannels(channels);
   CHECK(audio_device_buffer_);
   AllocateDataBuffers();
 }
 
-SLDataFormat_PCM OpenSLESPlayer::CreatePCMConfiguration(int channels,
-                                                        int sample_rate,
-                                                        int bits_per_sample) {
+SLDataFormat_PCM OpenSLESPlayer::CreatePCMConfiguration(
+    int channels,
+    int sample_rate,
+    size_t bits_per_sample) {
   ALOGD("CreatePCMConfiguration");
   CHECK_EQ(bits_per_sample, SL_PCMSAMPLEFORMAT_FIXED_16);
   SLDataFormat_PCM format;
   format.formatType = SL_DATAFORMAT_PCM;
   format.numChannels = static_cast<SLuint32>(channels);
   // Note that, the unit of sample rate is actually in milliHertz and not Hertz.
   switch (sample_rate) {
     case 8000:
       format.samplesPerSec = SL_SAMPLINGRATE_8;
       break;
@@ skipping 26 matching lines @@
     CHECK(false) << "Unsupported number of channels: " << format.numChannels;
   return format;
 }
 
 void OpenSLESPlayer::AllocateDataBuffers() {
   ALOGD("AllocateDataBuffers");
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!simple_buffer_queue_);
   CHECK(audio_device_buffer_);
   bytes_per_buffer_ = audio_parameters_.GetBytesPerBuffer();
-  ALOGD("native buffer size: %d", bytes_per_buffer_);
+  ALOGD("native buffer size: %" PRIuS, bytes_per_buffer_);
   // Create a modified audio buffer class which allows us to ask for any number
   // of samples (and not only multiple of 10ms) to match the native OpenSL ES
   // buffer size.
   fine_buffer_.reset(new FineAudioBuffer(audio_device_buffer_,
                                          bytes_per_buffer_,
                                          audio_parameters_.sample_rate()));
   // Each buffer must be of this size to avoid unnecessary memcpy while caching
   // data between successive callbacks.
-  const int required_buffer_size = fine_buffer_->RequiredBufferSizeBytes();
-  ALOGD("required buffer size: %d", required_buffer_size);
+  const size_t required_buffer_size = fine_buffer_->RequiredBufferSizeBytes();
+  ALOGD("required buffer size: %" PRIuS, required_buffer_size);
   for (int i = 0; i < kNumOfOpenSLESBuffers; ++i) {
     audio_buffers_[i].reset(new SLint8[required_buffer_size]);
   }
 }
 
 bool OpenSLESPlayer::CreateEngine() {
   ALOGD("CreateEngine");
   DCHECK(thread_checker_.CalledOnValidThread());
   if (engine_object_.Get())
     return true;
@@ skipping 178 matching lines @@
   DCHECK(player_);
   SLuint32 state;
   SLresult err = (*player_)->GetPlayState(player_, &state);
   if (SL_RESULT_SUCCESS != err) {
     ALOGE("GetPlayState failed: %d", err);
   }
   return state;
 }
 
 }  // namespace webrtc