Update audio code to use size_t more correctly, webrtc/modules/audio_device/

webrtc/modules/audio_device/audio_device_buffer.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/modules/audio_device/audio_device_buffer.h"
 
 #include <assert.h>
 #include <string.h>
 
+#include "webrtc/base/format_macros.h"
 #include "webrtc/modules/audio_device/audio_device_config.h"
 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/interface/logging.h"
 #include "webrtc/system_wrappers/interface/trace.h"
 
 namespace webrtc {
 
 static const int kHighDelayThresholdMs = 300;
 static const int kLogHighDelayIntervalFrames = 500;  // 5 seconds.
 
@@ skipping 347 matching lines @@
 //  This method can also parse out left or right channel from a stereo
 //  input signal, i.e., emulate mono.
 //
 //  Examples:
 //
 //  16-bit,48kHz mono,  10ms => nSamples=480 => _recSize=2*480=960 bytes
 //  16-bit,48kHz stereo,10ms => nSamples=480 => _recSize=4*480=1920 bytes
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceBuffer::SetRecordedBuffer(const void* audioBuffer,
-                                             uint32_t nSamples)
+                                             size_t nSamples)
 {
     CriticalSectionScoped lock(&_critSect);
 
     if (_recBytesPerSample == 0)
     {
         assert(false);
         return -1;
     }
 
     _recSamples = nSamples;
@@ skipping 13 matching lines @@
     {
         int16_t* ptr16In = (int16_t*)audioBuffer;
         int16_t* ptr16Out = (int16_t*)&_recBuffer[0];
 
         if (AudioDeviceModule::kChannelRight == _recChannel)
         {
             ptr16In++;
         }
 
         // exctract left or right channel from input buffer to the local buffer
-        for (uint32_t i = 0; i < _recSamples; i++)
+        for (size_t i = 0; i < _recSamples; i++)
         {
             *ptr16Out = *ptr16In;
             ptr16Out++;
             ptr16In++;
             ptr16In++;
         }
     }
 
     if (_recFile.Open())
     {
@@ skipping 47 matching lines @@
         _newMicLevel = newMicLevel;
     }
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  RequestPlayoutData
 // ----------------------------------------------------------------------------
 
-int32_t AudioDeviceBuffer::RequestPlayoutData(uint32_t nSamples)
+int32_t AudioDeviceBuffer::RequestPlayoutData(size_t nSamples)
 {
     uint32_t playSampleRate = 0;
-    uint8_t playBytesPerSample = 0;
+    size_t playBytesPerSample = 0;
     uint8_t playChannels = 0;
     {
         CriticalSectionScoped lock(&_critSect);
 
         // Store copies under lock and use copies hereafter to avoid race with
         // setter methods.
         playSampleRate = _playSampleRate;
         playBytesPerSample = _playBytesPerSample;
         playChannels = _playChannels;
 
@@ skipping 14 matching lines @@
             return -1;
         }
 
         if (nSamples != _playSamples)
         {
             WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "invalid number of samples to be played out (%d)", nSamples);
             return -1;
         }
     }
 
-    uint32_t nSamplesOut(0);
+    size_t nSamplesOut(0);
 
     CriticalSectionScoped lock(&_critSectCb);
 
     if (_ptrCbAudioTransport == NULL)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "failed to feed data to playout (AudioTransport does not exist)");
         return 0;
     }
 
     if (_ptrCbAudioTransport)
@@ skipping 22 matching lines @@
 //  GetPlayoutData
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceBuffer::GetPlayoutData(void* audioBuffer)
 {
     CriticalSectionScoped lock(&_critSect);
 
     if (_playSize > kMaxBufferSizeBytes)
     {
        WEBRTC_TRACE(kTraceError, kTraceUtility, _id,
-                    "_playSize %i exceeds kMaxBufferSizeBytes in "
+                    "_playSize %" PRIuS " exceeds kMaxBufferSizeBytes in "
                     "AudioDeviceBuffer::GetPlayoutData", _playSize);
        assert(false);
        return -1;
     }
 
     memcpy(audioBuffer, &_playBuffer[0], _playSize);
 
     if (_playFile.Open())
     {
         // write to binary file in mono or stereo (interleaved)
         _playFile.Write(&_playBuffer[0], _playSize);
     }
 
     return static_cast<int32_t>(_playSamples);
 }
 
 }  // namespace webrtc