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

webrtc/modules/audio_device/android/audio_device_unittest.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 <algorithm>
 #include <limits>
 #include <list>
 #include <numeric>
 #include <string>
 #include <vector>
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/criticalsection.h"
+#include "webrtc/base/format_macros.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/scoped_ref_ptr.h"
 #include "webrtc/modules/audio_device/android/audio_common.h"
 #include "webrtc/modules/audio_device/android/audio_manager.h"
 #include "webrtc/modules/audio_device/android/build_info.h"
 #include "webrtc/modules/audio_device/android/ensure_initialized.h"
 #include "webrtc/modules/audio_device/audio_device_impl.h"
 #include "webrtc/modules/audio_device/include/audio_device.h"
 #include "webrtc/system_wrappers/interface/clock.h"
 #include "webrtc/system_wrappers/interface/event_wrapper.h"
@@ skipping 16 matching lines @@
 #define PRINTD(...) fprintf(stderr, __VA_ARGS__);
 #else
 #define PRINTD(...) ((void)0)
 #endif
 #define PRINT(...) fprintf(stderr, __VA_ARGS__);
 
 namespace webrtc {
 
 // Number of callbacks (input or output) the tests waits for before we set
 // an event indicating that the test was OK.
-static const int kNumCallbacks = 10;
+static const size_t kNumCallbacks = 10;
 // Max amount of time we wait for an event to be set while counting callbacks.
 static const int kTestTimeOutInMilliseconds = 10 * 1000;
 // Average number of audio callbacks per second assuming 10ms packet size.
-static const int kNumCallbacksPerSecond = 100;
+static const size_t kNumCallbacksPerSecond = 100;
 // Play out a test file during this time (unit is in seconds).
 static const int kFilePlayTimeInSec = 5;
-static const int kBitsPerSample = 16;
-static const int kBytesPerSample = kBitsPerSample / 8;
+static const size_t kBitsPerSample = 16;
+static const size_t kBytesPerSample = kBitsPerSample / 8;
 // Run the full-duplex test during this time (unit is in seconds).
 // Note that first |kNumIgnoreFirstCallbacks| are ignored.
 static const int kFullDuplexTimeInSec = 5;
 // Wait for the callback sequence to stabilize by ignoring this amount of the
 // initial callbacks (avoids initial FIFO access).
 // Only used in the RunPlayoutAndRecordingInFullDuplex test.
-static const int kNumIgnoreFirstCallbacks = 50;
+static const size_t kNumIgnoreFirstCallbacks = 50;
 // Sets the number of impulses per second in the latency test.
 static const int kImpulseFrequencyInHz = 1;
 // Length of round-trip latency measurements. Number of transmitted impulses
 // is kImpulseFrequencyInHz * kMeasureLatencyTimeInSec - 1.
 static const int kMeasureLatencyTimeInSec = 11;
 // Utilized in round-trip latency measurements to avoid capturing noise samples.
 static const int kImpulseThreshold = 1000;
 static const char kTag[] = "[..........] ";
 
 enum TransportType {
   kPlayout = 0x1,
   kRecording = 0x2,
 };
 
 // Interface for processing the audio stream. Real implementations can e.g.
 // run audio in loopback, read audio from a file or perform latency
 // measurements.
 class AudioStreamInterface {
  public:
-  virtual void Write(const void* source, int num_frames) = 0;
-  virtual void Read(void* destination, int num_frames) = 0;
+  virtual void Write(const void* source, size_t num_frames) = 0;
+  virtual void Read(void* destination, size_t num_frames) = 0;
  protected:
   virtual ~AudioStreamInterface() {}
 };
 
 // Reads audio samples from a PCM file where the file is stored in memory at
 // construction.
 class FileAudioStream : public AudioStreamInterface {
  public:
   FileAudioStream(
-      int num_callbacks, const std::string& file_name, int sample_rate)
+      size_t num_callbacks, const std::string& file_name, int sample_rate)
       : file_size_in_bytes_(0),
         sample_rate_(sample_rate),
         file_pos_(0) {
     file_size_in_bytes_ = test::GetFileSize(file_name);
     sample_rate_ = sample_rate;
     EXPECT_GE(file_size_in_callbacks(), num_callbacks)
         << "Size of test file is not large enough to last during the test.";
-    const int num_16bit_samples =
+    const size_t num_16bit_samples =
         test::GetFileSize(file_name) / kBytesPerSample;
     file_.reset(new int16_t[num_16bit_samples]);
     FILE* audio_file = fopen(file_name.c_str(), "rb");
     EXPECT_NE(audio_file, nullptr);
-    int num_samples_read = fread(
+    size_t num_samples_read = fread(
         file_.get(), sizeof(int16_t), num_16bit_samples, audio_file);
     EXPECT_EQ(num_samples_read, num_16bit_samples);
     fclose(audio_file);
   }
 
   // AudioStreamInterface::Write() is not implemented.
-  void Write(const void* source, int num_frames) override {}
+  void Write(const void* source, size_t num_frames) override {}
 
   // Read samples from file stored in memory (at construction) and copy
   // |num_frames| (<=> 10ms) to the |destination| byte buffer.
-  void Read(void* destination, int num_frames) override {
+  void Read(void* destination, size_t num_frames) override {
     memcpy(destination,
            static_cast<int16_t*> (&file_[file_pos_]),
            num_frames * sizeof(int16_t));
     file_pos_ += num_frames;
   }
 
   int file_size_in_seconds() const {
-    return (file_size_in_bytes_ / (kBytesPerSample * sample_rate_));
+    return static_cast<int>(
+        file_size_in_bytes_ / (kBytesPerSample * sample_rate_));
   }
-  int file_size_in_callbacks() const {
+  size_t file_size_in_callbacks() const {
     return file_size_in_seconds() * kNumCallbacksPerSecond;
   }
 
  private:
-  int file_size_in_bytes_;
+  size_t file_size_in_bytes_;
   int sample_rate_;
   rtc::scoped_ptr<int16_t[]> file_;
-  int file_pos_;
+  size_t file_pos_;
 };
 
 // Simple first in first out (FIFO) class that wraps a list of 16-bit audio
 // buffers of fixed size and allows Write and Read operations. The idea is to
 // store recorded audio buffers (using Write) and then read (using Read) these
 // stored buffers with as short delay as possible when the audio layer needs
 // data to play out. The number of buffers in the FIFO will stabilize under
 // normal conditions since there will be a balance between Write and Read calls.
 // The container is a std::list container and access is protected with a lock
 // since both sides (playout and recording) are driven by its own thread.
 class FifoAudioStream : public AudioStreamInterface {
  public:
-  explicit FifoAudioStream(int frames_per_buffer)
+  explicit FifoAudioStream(size_t frames_per_buffer)
       : frames_per_buffer_(frames_per_buffer),
         bytes_per_buffer_(frames_per_buffer_ * sizeof(int16_t)),
         fifo_(new AudioBufferList),
         largest_size_(0),
         total_written_elements_(0),
         write_count_(0) {
     EXPECT_NE(fifo_.get(), nullptr);
   }
 
   ~FifoAudioStream() {
     Flush();
   }
 
   // Allocate new memory, copy |num_frames| samples from |source| into memory
   // and add pointer to the memory location to end of the list.
   // Increases the size of the FIFO by one element.
-  void Write(const void* source, int num_frames) override {
+  void Write(const void* source, size_t num_frames) override {
     ASSERT_EQ(num_frames, frames_per_buffer_);
     PRINTD("+");
     if (write_count_++ < kNumIgnoreFirstCallbacks) {
       return;
     }
     int16_t* memory = new int16_t[frames_per_buffer_];
     memcpy(static_cast<int16_t*> (&memory[0]),
            source,
            bytes_per_buffer_);
     rtc::CritScope lock(&lock_);
     fifo_->push_back(memory);
-    const int size = fifo_->size();
+    const size_t size = fifo_->size();
     if (size > largest_size_) {
       largest_size_ = size;
-      PRINTD("(%d)", largest_size_);
+      PRINTD("(%" PRIuS ")", largest_size_);
     }
     total_written_elements_ += size;
   }
 
   // Read pointer to data buffer from front of list, copy |num_frames| of stored
   // data into |destination| and delete the utilized memory allocation.
   // Decreases the size of the FIFO by one element.
-  void Read(void* destination, int num_frames) override {
+  void Read(void* destination, size_t num_frames) override {
     ASSERT_EQ(num_frames, frames_per_buffer_);
     PRINTD("-");
     rtc::CritScope lock(&lock_);
     if (fifo_->empty()) {
       memset(destination, 0, bytes_per_buffer_);
     } else {
       int16_t* memory = fifo_->front();
       fifo_->pop_front();
       memcpy(destination,
              static_cast<int16_t*> (&memory[0]),
              bytes_per_buffer_);
       delete memory;
     }
   }
 
-  int size() const {
+  size_t size() const {
     return fifo_->size();
   }
 
-  int largest_size() const {
+  size_t largest_size() const {
     return largest_size_;
   }
 
-  int average_size() const {
+  size_t average_size() const {
     return (total_written_elements_ == 0) ? 0.0 : 0.5 + static_cast<float> (
       total_written_elements_) / (write_count_ - kNumIgnoreFirstCallbacks);
   }
 
  private:
   void Flush() {
     for (auto it = fifo_->begin(); it != fifo_->end(); ++it) {
       delete *it;
     }
     fifo_->clear();
   }
 
   using AudioBufferList = std::list<int16_t*>;
   rtc::CriticalSection lock_;
-  const int frames_per_buffer_;
-  const int bytes_per_buffer_;
+  const size_t frames_per_buffer_;
+  const size_t bytes_per_buffer_;
   rtc::scoped_ptr<AudioBufferList> fifo_;
-  int largest_size_;
-  int total_written_elements_;
-  int write_count_;
+  size_t largest_size_;
+  size_t total_written_elements_;
+  size_t write_count_;
 };
 
 // Inserts periodic impulses and measures the latency between the time of
 // transmission and time of receiving the same impulse.
 // Usage requires a special hardware called Audio Loopback Dongle.
 // See http://source.android.com/devices/audio/loopback.html for details.
 class LatencyMeasuringAudioStream : public AudioStreamInterface {
  public:
-  explicit LatencyMeasuringAudioStream(int frames_per_buffer)
+  explicit LatencyMeasuringAudioStream(size_t frames_per_buffer)
       : clock_(Clock::GetRealTimeClock()),
         frames_per_buffer_(frames_per_buffer),
         bytes_per_buffer_(frames_per_buffer_ * sizeof(int16_t)),
         play_count_(0),
         rec_count_(0),
         pulse_time_(0) {
   }
 
   // Insert periodic impulses in first two samples of |destination|.
-  void Read(void* destination, int num_frames) override {
+  void Read(void* destination, size_t num_frames) override {
     ASSERT_EQ(num_frames, frames_per_buffer_);
     if (play_count_ == 0) {
       PRINT("[");
     }
     play_count_++;
     memset(destination, 0, bytes_per_buffer_);
     if (play_count_ % (kNumCallbacksPerSecond / kImpulseFrequencyInHz) == 0) {
       if (pulse_time_ == 0) {
         pulse_time_ = clock_->TimeInMilliseconds();
       }
       PRINT(".");
       const int16_t impulse = std::numeric_limits<int16_t>::max();
       int16_t* ptr16 = static_cast<int16_t*> (destination);
-      for (int i = 0; i < 2; ++i) {
-        *ptr16++ = impulse;
+      for (size_t i = 0; i < 2; ++i) {
+        ptr16[i] = impulse;
       }
     }
   }
 
   // Detect received impulses in |source|, derive time between transmission and
   // detection and add the calculated delay to list of latencies.
-  void Write(const void* source, int num_frames) override {
+  void Write(const void* source, size_t num_frames) override {
     ASSERT_EQ(num_frames, frames_per_buffer_);
     rec_count_++;
     if (pulse_time_ == 0) {
       // Avoid detection of new impulse response until a new impulse has
       // been transmitted (sets |pulse_time_| to value larger than zero).
       return;
     }
     const int16_t* ptr16 = static_cast<const int16_t*> (source);
     std::vector<int16_t> vec(ptr16, ptr16 + num_frames);
     // Find max value in the audio buffer.
@@ skipping 13 matching lines @@
       // received impulse. It is transmitted at sample 0 but can be received
       // at sample N where N > 0. The term |extra_delay| accounts for N and it
       // is a value between 0 and 10ms.
       latencies_.push_back(now_time - pulse_time_ + extra_delay);
       pulse_time_ = 0;
     } else {
       PRINTD("-");
     }
   }
 
-  int num_latency_values() const {
+  size_t num_latency_values() const {
     return latencies_.size();
   }
 
   int min_latency() const {
     if (latencies_.empty())
       return 0;
     return *std::min_element(latencies_.begin(), latencies_.end());
   }
 
   int max_latency() const {
@@ skipping 19 matching lines @@
     PRINT("%s[min, max, avg]=[%d, %d, %d] ms\n", kTag,
         min_latency(), max_latency(), average_latency());
   }
 
   int IndexToMilliseconds(double index) const {
     return static_cast<int>(10.0 * (index / frames_per_buffer_) + 0.5);
   }
 
  private:
   Clock* clock_;
-  const int frames_per_buffer_;
-  const int bytes_per_buffer_;
-  int play_count_;
-  int rec_count_;
+  const size_t frames_per_buffer_;
+  const size_t bytes_per_buffer_;
+  size_t play_count_;
+  size_t rec_count_;
   int64_t pulse_time_;
   std::vector<int> latencies_;
 };
 
 // Mocks the AudioTransport object and proxies actions for the two callbacks
 // (RecordedDataIsAvailable and NeedMorePlayData) to different implementations
 // of AudioStreamInterface.
 class MockAudioTransport : public AudioTransport {
  public:
   explicit MockAudioTransport(int type)
       : num_callbacks_(0),
         type_(type),
         play_count_(0),
         rec_count_(0),
         audio_stream_(nullptr) {}
 
   virtual ~MockAudioTransport() {}
 
   MOCK_METHOD10(RecordedDataIsAvailable,
                 int32_t(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));
   MOCK_METHOD8(NeedMorePlayData,
-               int32_t(const uint32_t nSamples,
-                       const uint8_t nBytesPerSample,
+               int32_t(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));
 
   // Set default actions of the mock object. We are delegating to fake
   // implementations (of AudioStreamInterface) here.
   void HandleCallbacks(EventWrapper* test_is_done,
                        AudioStreamInterface* audio_stream,
                        int num_callbacks) {
     test_is_done_ = test_is_done;
     audio_stream_ = audio_stream;
     num_callbacks_ = num_callbacks;
     if (play_mode()) {
       ON_CALL(*this, NeedMorePlayData(_, _, _, _, _, _, _, _))
           .WillByDefault(
               Invoke(this, &MockAudioTransport::RealNeedMorePlayData));
     }
     if (rec_mode()) {
       ON_CALL(*this, RecordedDataIsAvailable(_, _, _, _, _, _, _, _, _, _))
           .WillByDefault(
               Invoke(this, &MockAudioTransport::RealRecordedDataIsAvailable));
     }
   }
 
   int32_t RealRecordedDataIsAvailable(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) {
     EXPECT_TRUE(rec_mode()) << "No test is expecting these callbacks.";
     rec_count_++;
     // Process the recorded audio stream if an AudioStreamInterface
     // implementation exists.
     if (audio_stream_) {
       audio_stream_->Write(audioSamples, nSamples);
     }
     if (ReceivedEnoughCallbacks()) {
       test_is_done_->Set();
     }
     return 0;
   }
 
-  int32_t RealNeedMorePlayData(const uint32_t nSamples,
-                               const uint8_t nBytesPerSample,
+  int32_t RealNeedMorePlayData(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) {
     EXPECT_TRUE(play_mode()) << "No test is expecting these callbacks.";
     play_count_++;
     nSamplesOut = nSamples;
     // Read (possibly processed) audio stream samples to be played out if an
     // AudioStreamInterface implementation exists.
     if (audio_stream_) {
       audio_stream_->Read(audioSamples, nSamples);
     }
@@ skipping 17 matching lines @@
       playout_done = true;
 
     return recording_done && playout_done;
   }
 
   bool play_mode() const { return type_ & kPlayout; }
   bool rec_mode() const { return type_ & kRecording; }
 
  private:
   EventWrapper* test_is_done_;
-  int num_callbacks_;
+  size_t num_callbacks_;
   int type_;
-  int play_count_;
-  int rec_count_;
+  size_t play_count_;
+  size_t rec_count_;
   AudioStreamInterface* audio_stream_;
   rtc::scoped_ptr<LatencyMeasuringAudioStream> latency_audio_stream_;
 };
 
 // AudioDeviceTest test fixture.
 class AudioDeviceTest : public ::testing::Test {
  protected:
   AudioDeviceTest()
       : test_is_done_(EventWrapper::Create()) {
     // One-time initialization of JVM and application context. Ensures that we
@@ skipping 17 matching lines @@
   }
   int record_sample_rate() const {
     return record_parameters_.sample_rate();
   }
   int playout_channels() const {
     return playout_parameters_.channels();
   }
   int record_channels() const {
     return record_parameters_.channels();
   }
-  int playout_frames_per_10ms_buffer() const {
+  size_t playout_frames_per_10ms_buffer() const {
     return playout_parameters_.frames_per_10ms_buffer();
   }
-  int record_frames_per_10ms_buffer() const {
+  size_t record_frames_per_10ms_buffer() const {
     return record_parameters_.frames_per_10ms_buffer();
   }
 
   int total_delay_ms() const {
     return audio_manager()->GetDelayEstimateInMilliseconds();
   }
 
   rtc::scoped_refptr<AudioDeviceModule> audio_device() const {
     return audio_device_;
   }
@@ skipping 27 matching lines @@
     EXPECT_TRUE(sample_rate == 48000 || sample_rate == 44100);
     char fname[64];
     snprintf(fname,
              sizeof(fname),
              "audio_device/audio_short%d",
              sample_rate / 1000);
     std::string file_name(webrtc::test::ResourcePath(fname, "pcm"));
     EXPECT_TRUE(test::FileExists(file_name));
 #ifdef ENABLE_PRINTF
     PRINT("file name: %s\n", file_name.c_str());
-    const int bytes = test::GetFileSize(file_name);
-    PRINT("file size: %d [bytes]\n", bytes);
-    PRINT("file size: %d [samples]\n", bytes / kBytesPerSample);
-    const int seconds = bytes / (sample_rate * kBytesPerSample);
+    const size_t bytes = test::GetFileSize(file_name);
+    PRINT("file size: %" PRIuS " [bytes]\n", bytes);
+    PRINT("file size: %" PRIuS " [samples]\n", bytes / kBytesPerSample);
+    const int seconds =
+        static_cast<int>(bytes / (sample_rate * kBytesPerSample));
     PRINT("file size: %d [secs]\n", seconds);
-    PRINT("file size: %d [callbacks]\n", seconds * kNumCallbacksPerSecond);
+    PRINT("file size: %" PRIuS " [callbacks]\n",
+          seconds * kNumCallbacksPerSecond);
 #endif
     return file_name;
   }
 
   AudioDeviceModule::AudioLayer GetActiveAudioLayer() const {
     AudioDeviceModule::AudioLayer audio_layer;
     EXPECT_EQ(0, audio_device()->ActiveAudioLayer(&audio_layer));
     return audio_layer;
   }
 
@@ skipping 359 matching lines @@
                        fifo_audio_stream.get(),
                        kFullDuplexTimeInSec * kNumCallbacksPerSecond);
   SetMaxPlayoutVolume();
   EXPECT_EQ(0, audio_device()->RegisterAudioCallback(&mock));
   StartRecording();
   StartPlayout();
   test_is_done_->Wait(std::max(kTestTimeOutInMilliseconds,
                                1000 * kFullDuplexTimeInSec));
   StopPlayout();
   StopRecording();
-  EXPECT_LE(fifo_audio_stream->average_size(), 10);
-  EXPECT_LE(fifo_audio_stream->largest_size(), 20);
+  EXPECT_LE(fifo_audio_stream->average_size(), 10u);
+  EXPECT_LE(fifo_audio_stream->largest_size(), 20u);
 }
 
 // Measures loopback latency and reports the min, max and average values for
 // a full duplex audio session.
 // The latency is measured like so:
 // - Insert impulses periodically on the output side.
 // - Detect the impulses on the input side.
 // - Measure the time difference between the transmit time and receive time.
 // - Store time differences in a vector and calculate min, max and average.
 // This test requires a special hardware called Audio Loopback Dongle.
@@ skipping 11 matching lines @@
   SetMaxPlayoutVolume();
   DisableBuiltInAECIfAvailable();
   StartRecording();
   StartPlayout();
   test_is_done_->Wait(std::max(kTestTimeOutInMilliseconds,
                                1000 * kMeasureLatencyTimeInSec));
   StopPlayout();
   StopRecording();
   // Verify that the correct number of transmitted impulses are detected.
   EXPECT_EQ(latency_audio_stream->num_latency_values(),
-            kImpulseFrequencyInHz * kMeasureLatencyTimeInSec - 1);
+            static_cast<size_t>(
+                kImpulseFrequencyInHz * kMeasureLatencyTimeInSec - 1));
   latency_audio_stream->PrintResults();
 }
 
 }  // namespace webrtc