Update audio code to use size_t more correctly, webrtc/voice_engine/ portion.

webrtc/voice_engine/voe_base_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.
  */
 
 #include "webrtc/voice_engine/voe_base_impl.h"
 
+#include "webrtc/base/format_macros.h"
 #include "webrtc/common.h"
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 #include "webrtc/modules/audio_coding/main/interface/audio_coding_module.h"
 #include "webrtc/modules/audio_device/audio_device_impl.h"
 #include "webrtc/modules/audio_processing/include/audio_processing.h"
 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/interface/file_wrapper.h"
 #include "webrtc/system_wrappers/interface/logging.h"
 #include "webrtc/voice_engine/channel.h"
 #include "webrtc/voice_engine/include/voe_errors.h"
@@ skipping 49 matching lines @@
     warningCode = VE_RUNTIME_PLAY_WARNING;
     LOG_F(LS_WARNING) << "VE_RUNTIME_PLAY_WARNING";
   }
   if (voiceEngineObserverPtr_) {
     // Deliver callback (-1 <=> no channel dependency)
     voiceEngineObserverPtr_->CallbackOnError(-1, warningCode);
   }
 }
 
 int32_t VoEBaseImpl::RecordedDataIsAvailable(
-    const void* audioSamples, uint32_t nSamples, uint8_t nBytesPerSample,
+    const void* audioSamples, size_t nSamples, size_t nBytesPerSample,
     uint8_t nChannels, uint32_t samplesPerSec, uint32_t totalDelayMS,
     int32_t clockDrift, uint32_t micLevel, bool keyPressed,
     uint32_t& newMicLevel) {
   newMicLevel = static_cast<uint32_t>(ProcessRecordedDataWithAPM(
       nullptr, 0, audioSamples, samplesPerSec, nChannels, nSamples,
       totalDelayMS, clockDrift, micLevel, keyPressed));
   return 0;
 }
 
-int32_t VoEBaseImpl::NeedMorePlayData(uint32_t nSamples,
-                                      uint8_t nBytesPerSample,
+int32_t VoEBaseImpl::NeedMorePlayData(size_t nSamples,
+                                      size_t nBytesPerSample,
                                       uint8_t nChannels, uint32_t samplesPerSec,
-                                      void* audioSamples, uint32_t& nSamplesOut,
+                                      void* audioSamples, size_t& nSamplesOut,
                                       int64_t* elapsed_time_ms,
                                       int64_t* ntp_time_ms) {
   GetPlayoutData(static_cast<int>(samplesPerSec), static_cast<int>(nChannels),
-                 static_cast<int>(nSamples), true, audioSamples,
+                 nSamples, true, audioSamples,
                  elapsed_time_ms, ntp_time_ms);
   nSamplesOut = audioFrame_.samples_per_channel_;
   return 0;
 }
 
 int VoEBaseImpl::OnDataAvailable(const int voe_channels[],
                                  int number_of_voe_channels,
                                  const int16_t* audio_data, int sample_rate,
-                                 int number_of_channels, int number_of_frames,
+                                 int number_of_channels,
+                                 size_t number_of_frames,
                                  int audio_delay_milliseconds, int volume,
                                  bool key_pressed, bool need_audio_processing) {
   if (number_of_voe_channels == 0) return 0;
 
   if (need_audio_processing) {
     return ProcessRecordedDataWithAPM(
         voe_channels, number_of_voe_channels, audio_data, sample_rate,
         number_of_channels, number_of_frames, audio_delay_milliseconds, 0,
         volume, key_pressed);
   }
 
   // No need to go through the APM, demultiplex the data to each VoE channel,
   // encode and send to the network.
   for (int i = 0; i < number_of_voe_channels; ++i) {
     // TODO(ajm): In the case where multiple channels are using the same codec
     // rate, this path needlessly does extra conversions. We should convert once
     // and share between channels.
     PushCaptureData(voe_channels[i], audio_data, 16, sample_rate,
                     number_of_channels, number_of_frames);
   }
 
   // Return 0 to indicate no need to change the volume.
   return 0;
 }
 
 void VoEBaseImpl::OnData(int voe_channel, const void* audio_data,
                          int bits_per_sample, int sample_rate,
-                         int number_of_channels, int number_of_frames) {
+                         int number_of_channels, size_t number_of_frames) {
   PushCaptureData(voe_channel, audio_data, bits_per_sample, sample_rate,
                   number_of_channels, number_of_frames);
 }
 
 void VoEBaseImpl::PushCaptureData(int voe_channel, const void* audio_data,
                                   int bits_per_sample, int sample_rate,
                                   int number_of_channels,
-                                  int number_of_frames) {
+                                  size_t number_of_frames) {
   voe::ChannelOwner ch = shared_->channel_manager().GetChannel(voe_channel);
   voe::Channel* channel_ptr = ch.channel();
   if (!channel_ptr) return;
 
   if (channel_ptr->Sending()) {
     channel_ptr->Demultiplex(static_cast<const int16_t*>(audio_data),
                              sample_rate, number_of_frames, number_of_channels);
     channel_ptr->PrepareEncodeAndSend(sample_rate);
     channel_ptr->EncodeAndSend();
   }
 }
 
-void VoEBaseImpl::PullRenderData(int bits_per_sample, int sample_rate,
-                                 int number_of_channels, int number_of_frames,
+void VoEBaseImpl::PullRenderData(int bits_per_sample,
+                                 int sample_rate,
+                                 int number_of_channels,
+                                 size_t number_of_frames,
                                  void* audio_data, int64_t* elapsed_time_ms,
                                  int64_t* ntp_time_ms) {
   assert(bits_per_sample == 16);
-  assert(number_of_frames == static_cast<int>(sample_rate / 100));
+  assert(number_of_frames == static_cast<size_t>(sample_rate / 100));
 
   GetPlayoutData(sample_rate, number_of_channels, number_of_frames, false,
                  audio_data, elapsed_time_ms, ntp_time_ms);
 }
 
 int VoEBaseImpl::RegisterVoiceEngineObserver(VoiceEngineObserver& observer) {
   CriticalSectionScoped cs(&callbackCritSect_);
   if (voiceEngineObserverPtr_) {
     shared_->SetLastError(
         VE_INVALID_OPERATION, kTraceError,
@@ skipping 568 matching lines @@
   if (shared_->audio_processing()) {
     shared_->set_audio_processing(nullptr);
   }
 
   return shared_->statistics().SetUnInitialized();
 }
 
 int VoEBaseImpl::ProcessRecordedDataWithAPM(
     const int voe_channels[], int number_of_voe_channels,
     const void* audio_data, uint32_t sample_rate, uint8_t number_of_channels,
-    uint32_t number_of_frames, uint32_t audio_delay_milliseconds,
+    size_t number_of_frames, uint32_t audio_delay_milliseconds,
     int32_t clock_drift, uint32_t volume, bool key_pressed) {
   assert(shared_->transmit_mixer() != nullptr);
   assert(shared_->audio_device() != nullptr);
 
   uint32_t max_volume = 0;
   uint16_t voe_mic_level = 0;
   // Check for zero to skip this calculation; the consumer may use this to
   // indicate no volume is available.
   if (volume != 0) {
     // Scale from ADM to VoE level range
@@ skipping 44 matching lines @@
     return static_cast<int>((new_voe_mic_level * max_volume +
                              static_cast<int>(kMaxVolumeLevel / 2)) /
                             kMaxVolumeLevel);
   }
 
   // Return 0 to indicate no change on the volume.
   return 0;
 }
 
 void VoEBaseImpl::GetPlayoutData(int sample_rate, int number_of_channels,
-                                 int number_of_frames, bool feed_data_to_apm,
+                                 size_t number_of_frames, bool feed_data_to_apm,
                                  void* audio_data, int64_t* elapsed_time_ms,
                                  int64_t* ntp_time_ms) {
   assert(shared_->output_mixer() != nullptr);
 
   // TODO(andrew): if the device is running in mono, we should tell the mixer
   // here so that it will only request mono from AudioCodingModule.
   // Perform mixing of all active participants (channel-based mixing)
   shared_->output_mixer()->MixActiveChannels();
 
   // Additional operations on the combined signal
@@ skipping 37 matching lines @@
     shared_->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
         "AssociateSendChannel() failed to locate accociate_send_channel");
     return -1;
   }
 
   channel_ptr->set_associate_send_channel(ch);
   return 0;
 }
 
 }  // namespace webrtc