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

webrtc/modules/interface/module_common_types.h

 /*
  *  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 324 matching lines @@
  *   samples_per_channel_ * num_channels_
  *
  * - Stereo data is interleaved starting with the left channel.
  *
  * - The +operator assume that you would never add exactly opposite frames when
  *   deciding the resulting state. To do this use the -operator.
  */
 class AudioFrame {
  public:
   // Stereo, 32 kHz, 60 ms (2 * 32 * 60)
-  static const int kMaxDataSizeSamples = 3840;
+  static const size_t kMaxDataSizeSamples = 3840;
 
   enum VADActivity {
     kVadActive = 0,
     kVadPassive = 1,
     kVadUnknown = 2
   };
   enum SpeechType {
     kNormalSpeech = 0,
     kPLC = 1,
     kCNG = 2,
     kPLCCNG = 3,
     kUndefined = 4
   };
 
   AudioFrame();
   virtual ~AudioFrame() {}
 
   // Resets all members to their default state (except does not modify the
   // contents of |data_|).
   void Reset();
 
   // |interleaved_| is not changed by this method.
   void UpdateFrame(int id, uint32_t timestamp, const int16_t* data,
-                   int samples_per_channel, int sample_rate_hz,
+                   size_t samples_per_channel, int sample_rate_hz,
                    SpeechType speech_type, VADActivity vad_activity,
                    int num_channels = 1, uint32_t energy = -1);
 
   AudioFrame& Append(const AudioFrame& rhs);
 
   void CopyFrom(const AudioFrame& src);
 
   void Mute();
 
   AudioFrame& operator>>=(const int rhs);
   AudioFrame& operator+=(const AudioFrame& rhs);
   AudioFrame& operator-=(const AudioFrame& rhs);
 
   int id_;
   // RTP timestamp of the first sample in the AudioFrame.
   uint32_t timestamp_;
   // Time since the first frame in milliseconds.
   // -1 represents an uninitialized value.
   int64_t elapsed_time_ms_;
   // NTP time of the estimated capture time in local timebase in milliseconds.
   // -1 represents an uninitialized value.
   int64_t ntp_time_ms_;
   int16_t data_[kMaxDataSizeSamples];
-  int samples_per_channel_;
+  size_t samples_per_channel_;
   int sample_rate_hz_;
   int num_channels_;
   SpeechType speech_type_;
   VADActivity vad_activity_;
   // Note that there is no guarantee that |energy_| is correct. Any user of this
   // member must verify that the value is correct.
   // TODO(henrike) Remove |energy_|.
   // See https://code.google.com/p/webrtc/issues/detail?id=3315.
   uint32_t energy_;
   bool interleaved_;
@@ skipping 19 matching lines @@
   num_channels_ = 0;
   speech_type_ = kUndefined;
   vad_activity_ = kVadUnknown;
   energy_ = 0xffffffff;
   interleaved_ = true;
 }
 
 inline void AudioFrame::UpdateFrame(int id,
                                     uint32_t timestamp,
                                     const int16_t* data,
-                                    int samples_per_channel,
+                                    size_t samples_per_channel,
                                     int sample_rate_hz,
                                     SpeechType speech_type,
                                     VADActivity vad_activity,
                                     int num_channels,
                                     uint32_t energy) {
   id_ = id;
   timestamp_ = timestamp;
   samples_per_channel_ = samples_per_channel;
   sample_rate_hz_ = sample_rate_hz;
   speech_type_ = speech_type;
   vad_activity_ = vad_activity;
   num_channels_ = num_channels;
   energy_ = energy;
 
   assert(num_channels >= 0);
-  const int length = samples_per_channel * num_channels;
+  const size_t length = samples_per_channel * num_channels;
   assert(length <= kMaxDataSizeSamples);
   if (data != NULL) {
     memcpy(data_, data, sizeof(int16_t) * length);
   } else {
     memset(data_, 0, sizeof(int16_t) * length);
   }
 }
 
 inline void AudioFrame::CopyFrom(const AudioFrame& src) {
   if (this == &src) return;
 
   id_ = src.id_;
   timestamp_ = src.timestamp_;
   elapsed_time_ms_ = src.elapsed_time_ms_;
   ntp_time_ms_ = src.ntp_time_ms_;
   samples_per_channel_ = src.samples_per_channel_;
   sample_rate_hz_ = src.sample_rate_hz_;
   speech_type_ = src.speech_type_;
   vad_activity_ = src.vad_activity_;
   num_channels_ = src.num_channels_;
   energy_ = src.energy_;
   interleaved_ = src.interleaved_;
 
   assert(num_channels_ >= 0);
-  const int length = samples_per_channel_ * num_channels_;
+  const size_t length = samples_per_channel_ * num_channels_;
   assert(length <= kMaxDataSizeSamples);
   memcpy(data_, src.data_, sizeof(int16_t) * length);
 }
 
 inline void AudioFrame::Mute() {
   memset(data_, 0, samples_per_channel_ * num_channels_ * sizeof(int16_t));
 }
 
 inline AudioFrame& AudioFrame::operator>>=(const int rhs) {
   assert((num_channels_ > 0) && (num_channels_ < 3));
   if ((num_channels_ > 2) || (num_channels_ < 1)) return *this;
 
-  for (int i = 0; i < samples_per_channel_ * num_channels_; i++) {
+  for (size_t i = 0; i < samples_per_channel_ * num_channels_; i++) {
     data_[i] = static_cast<int16_t>(data_[i] >> rhs);
   }
   return *this;
 }
 
 inline AudioFrame& AudioFrame::Append(const AudioFrame& rhs) {
   // Sanity check
   assert((num_channels_ > 0) && (num_channels_ < 3));
   assert(interleaved_ == rhs.interleaved_);
   if ((num_channels_ > 2) || (num_channels_ < 1)) return *this;
   if (num_channels_ != rhs.num_channels_) return *this;
 
   if ((vad_activity_ == kVadActive) || rhs.vad_activity_ == kVadActive) {
     vad_activity_ = kVadActive;
   } else if (vad_activity_ == kVadUnknown || rhs.vad_activity_ == kVadUnknown) {
     vad_activity_ = kVadUnknown;
   }
   if (speech_type_ != rhs.speech_type_) {
     speech_type_ = kUndefined;
   }
 
-  int offset = samples_per_channel_ * num_channels_;
-  for (int i = 0; i < rhs.samples_per_channel_ * rhs.num_channels_; i++) {
+  size_t offset = samples_per_channel_ * num_channels_;
+  for (size_t i = 0; i < rhs.samples_per_channel_ * rhs.num_channels_; i++) {
     data_[offset + i] = rhs.data_[i];
   }
   samples_per_channel_ += rhs.samples_per_channel_;
   return *this;
 }
 
 namespace {
 inline int16_t ClampToInt16(int32_t input) {
   if (input < -0x00008000) {
     return -0x8000;
@@ skipping 29 matching lines @@
     vad_activity_ = kVadUnknown;
   }
 
   if (speech_type_ != rhs.speech_type_) speech_type_ = kUndefined;
 
   if (noPrevData) {
     memcpy(data_, rhs.data_,
            sizeof(int16_t) * rhs.samples_per_channel_ * num_channels_);
   } else {
     // IMPROVEMENT this can be done very fast in assembly
-    for (int i = 0; i < samples_per_channel_ * num_channels_; i++) {
+    for (size_t i = 0; i < samples_per_channel_ * num_channels_; i++) {
       int32_t wrap_guard =
           static_cast<int32_t>(data_[i]) + static_cast<int32_t>(rhs.data_[i]);
       data_[i] = ClampToInt16(wrap_guard);
     }
   }
   energy_ = 0xffffffff;
   return *this;
 }
 
 inline AudioFrame& AudioFrame::operator-=(const AudioFrame& rhs) {
   // Sanity check
   assert((num_channels_ > 0) && (num_channels_ < 3));
   assert(interleaved_ == rhs.interleaved_);
   if ((num_channels_ > 2) || (num_channels_ < 1)) return *this;
 
   if ((samples_per_channel_ != rhs.samples_per_channel_) ||
       (num_channels_ != rhs.num_channels_)) {
     return *this;
   }
   if ((vad_activity_ != kVadPassive) || rhs.vad_activity_ != kVadPassive) {
     vad_activity_ = kVadUnknown;
   }
   speech_type_ = kUndefined;
 
-  for (int i = 0; i < samples_per_channel_ * num_channels_; i++) {
+  for (size_t i = 0; i < samples_per_channel_ * num_channels_; i++) {
     int32_t wrap_guard =
         static_cast<int32_t>(data_[i]) - static_cast<int32_t>(rhs.data_[i]);
     data_[i] = ClampToInt16(wrap_guard);
   }
   energy_ = 0xffffffff;
   return *this;
 }
 
 inline bool IsNewerSequenceNumber(uint16_t sequence_number,
                                   uint16_t prev_sequence_number) {
@@ skipping 26 matching lines @@
              : sequence_number2;
 }
 
 inline uint32_t LatestTimestamp(uint32_t timestamp1, uint32_t timestamp2) {
   return IsNewerTimestamp(timestamp1, timestamp2) ? timestamp1 : timestamp2;
 }
 
 }  // namespace webrtc
 
 #endif  // MODULE_COMMON_TYPES_H