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

webrtc/modules/audio_device/test/func_test_manager.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 174 matching lines @@
 
     for (AudioPacketList::iterator iter = _audioList.begin();
          iter != _audioList.end(); ++iter) {
             delete *iter;
     }
     _audioList.clear();
 }
 
 int32_t AudioTransportImpl::RecordedDataIsAvailable(
     const void* audioSamples,
-    const uint32_t nSamples,
-    const uint8_t nBytesPerSample,
+    const size_t nSamples,
+    const size_t nBytesPerSample,
     const uint8_t nChannels,
     const uint32_t samplesPerSec,
     const uint32_t totalDelayMS,
     const int32_t clockDrift,
     const uint32_t currentMicLevel,
     const bool keyPressed,
     uint32_t& newMicLevel)
 {
     if (_fullDuplex && _audioList.size() < 15)
     {
         AudioPacket* packet = new AudioPacket();
         memcpy(packet->dataBuffer, audioSamples, nSamples * nBytesPerSample);
-        packet->nSamples = (uint16_t) nSamples;
+        packet->nSamples = nSamples;
         packet->nBytesPerSample = nBytesPerSample;
         packet->nChannels = nChannels;
         packet->samplesPerSec = samplesPerSec;
         _audioList.push_back(packet);
     }
 
     _recCount++;
     if (_recCount % 100 == 0)
     {
         bool addMarker(true);
@@ skipping 110 matching lines @@
         {
             // TEST_LOG("=> emulated mono (one channel exctracted from stereo input)\n");
         }
     }
 
     return 0;
 }
 
 
 int32_t AudioTransportImpl::NeedMorePlayData(
-    const uint32_t nSamples,
-    const uint8_t nBytesPerSample,
+    const size_t nSamples,
+    const size_t nBytesPerSample,
     const uint8_t nChannels,
     const uint32_t samplesPerSec,
     void* audioSamples,
-    uint32_t& nSamplesOut,
+    size_t& nSamplesOut,
     int64_t* elapsed_time_ms,
     int64_t* ntp_time_ms)
 {
     if (_fullDuplex)
     {
         if (_audioList.empty())
         {
             // use zero stuffing when not enough data
             memset(audioSamples, 0, nBytesPerSample * nSamples);
         } else
         {
             AudioPacket* packet = _audioList.front();
             _audioList.pop_front();
             if (packet)
             {
                 int ret(0);
-                int lenOut(0);
+                size_t lenOut(0);
                 int16_t tmpBuf_96kHz[80 * 12];
                 int16_t* ptr16In = NULL;
                 int16_t* ptr16Out = NULL;
 
-                const uint16_t nSamplesIn = packet->nSamples;
+                const size_t nSamplesIn = packet->nSamples;
                 const uint8_t nChannelsIn = packet->nChannels;
                 const uint32_t samplesPerSecIn = packet->samplesPerSec;
-                const uint16_t nBytesPerSampleIn = packet->nBytesPerSample;
+                const size_t nBytesPerSampleIn = packet->nBytesPerSample;
 
                 int32_t fsInHz(samplesPerSecIn);
                 int32_t fsOutHz(samplesPerSec);
 
                 if (fsInHz == 44100)
                     fsInHz = 44000;
 
                 if (fsOutHz == 44100)
                     fsOutHz = 44000;
 
@@ skipping 13 matching lines @@
                         {
                             _resampler.Push(
                                 (const int16_t*) packet->dataBuffer,
                                 2 * nSamplesIn, tmpBuf_96kHz, 2 * nSamples,
                                 lenOut);
 
                             ptr16In = &tmpBuf_96kHz[0];
                             ptr16Out = (int16_t*) audioSamples;
 
                             // do stereo -> mono
-                            for (unsigned int i = 0; i < nSamples; i++)
+                            for (size_t i = 0; i < nSamples; i++)
                             {
                                 *ptr16Out = *ptr16In; // use left channel
                                 ptr16Out++;
                                 ptr16In++;
                                 ptr16In++;
                             }
                         }
-                        assert(2*nSamples == (uint32_t)lenOut);
+                        assert(2*nSamples == lenOut);
                     } else
                     {
                         if (_playCount % 100 == 0)
                             TEST_LOG(
                                      "ERROR: unable to resample from %d to %d\n",
                                      samplesPerSecIn, samplesPerSec);
                     }
                 } else
                 {
                     // input is mono (can be "reduced from stereo" as well) =>
                     // we will resample in mono
                     ret = _resampler.ResetIfNeeded(fsInHz, fsOutHz, 1);
                     if (ret == 0)
                     {
                         if (nChannels == 1)
                         {
                             _resampler.Push(
                                 (const int16_t*) packet->dataBuffer, nSamplesIn,
                                 (int16_t*) audioSamples, nSamples, lenOut);
                         } else
                         {
                             _resampler.Push(
                                 (const int16_t*) packet->dataBuffer, nSamplesIn,
                                 tmpBuf_96kHz, nSamples, lenOut);
 
                             ptr16In = &tmpBuf_96kHz[0];
                             ptr16Out = (int16_t*) audioSamples;
 
                             // do mono -> stereo
-                            for (unsigned int i = 0; i < nSamples; i++)
+                            for (size_t i = 0; i < nSamples; i++)
                             {
                                 *ptr16Out = *ptr16In; // left
                                 ptr16Out++;
                                 *ptr16Out = *ptr16In; // right (same as left sample)
                                 ptr16Out++;
                                 ptr16In++;
                             }
                         }
-                        assert(nSamples == (uint32_t)lenOut);
+                        assert(nSamples == lenOut);
                     } else
                     {
                         if (_playCount % 100 == 0)
                             TEST_LOG("ERROR: unable to resample from %d to %d\n",
                                      samplesPerSecIn, samplesPerSec);
                     }
                 }
                 nSamplesOut = nSamples;
                 delete packet;
             }
@@ skipping 14 matching lines @@
 
         // convert to stero if required
         if (nChannels == 1)
         {
             memcpy(audioSamples, fileBuf, 2 * nSamples);
         } else
         {
             // mono sample from file is duplicated and sent to left and right
             // channels
             int16_t* audio16 = (int16_t*) audioSamples;
-            for (unsigned int i = 0; i < nSamples; i++)
+            for (size_t i = 0; i < nSamples; i++)
             {
                 (*audio16) = fileBuf[i]; // left
                 audio16++;
                 (*audio16) = fileBuf[i]; // right
                 audio16++;
             }
         }
     }  // if (_playFromFile && _playFile.Open())
 
     _playCount++;
@@ skipping 74 matching lines @@
     nSamplesOut = nSamples;
 
     return 0;
 }
 
 int AudioTransportImpl::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,
+                                        size_t number_of_frames,
                                         int audio_delay_milliseconds,
                                         int current_volume,
                                         bool key_pressed,
                                         bool need_audio_processing) {
   return 0;
 }
 
 void AudioTransportImpl::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) {}
 
 void AudioTransportImpl::PullRenderData(int bits_per_sample, int sample_rate,
                                         int number_of_channels,
-                                        int number_of_frames,
+                                        size_t number_of_frames,
                                         void* audio_data,
                                         int64_t* elapsed_time_ms,
                                         int64_t* ntp_time_ms) {}
 
 FuncTestManager::FuncTestManager() :
     _audioDevice(NULL),
     _audioEventObserver(NULL),
     _audioTransport(NULL)
 {
   _playoutFile48 = webrtc::test::ResourcePath("audio_device\\audio_short48",
@@ skipping 2154 matching lines @@
 
     TEST_LOG("\n");
     PRINT_TEST_RESULTS;
 
     return 0;
 }
 
 }  // namespace webrtc
 
 // EOF