Update audio code to use size_t more correctly,

webrtc/modules/audio_coding/main/acm2/audio_coding_module_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.
  */
 
@@ skipping 58 matching lines @@
 
 bool IsCodecCN(const CodecInst* codec) {
   return (STR_CASE_CMP(codec->plname, "CN") == 0);
 }
 
 bool IsCodecCN(int index) {
   return (IsCodecCN(&ACMCodecDB::database_[index]));
 }
 
 // Stereo-to-mono can be used as in-place.
-int DownMix(const AudioFrame& frame, int length_out_buff, int16_t* out_buff) {
+int DownMix(const AudioFrame& frame,
+            size_t length_out_buff,
+            int16_t* out_buff) {
   if (length_out_buff < frame.samples_per_channel_) {
     return -1;
   }
-  for (int n = 0; n < frame.samples_per_channel_; ++n)
+  for (size_t n = 0; n < frame.samples_per_channel_; ++n)
     out_buff[n] = (frame.data_[2 * n] + frame.data_[2 * n + 1]) >> 1;
   return 0;
 }
 
 // Mono-to-stereo can be used as in-place.
-int UpMix(const AudioFrame& frame, int length_out_buff, int16_t* out_buff) {
+int UpMix(const AudioFrame& frame, size_t length_out_buff, int16_t* out_buff) {
   if (length_out_buff < frame.samples_per_channel_) {
     return -1;
   }
-  for (int n = frame.samples_per_channel_; n > 0; --n) {
-    int i = n - 1;

[kwiberg-webrtc, 2015/07/12 17:39:26]

Hmm. This code already jumps through all the hoops needed for an unsigned loop
variable, even though it's signed. Curious...

[Peter Kasting, 2015/07/13 02:46:26]

That's probably a sign that I updated the code to jump through those hoops as a
precursor change, to minimize the deltas in this later enormous patch.

+  for (size_t n = frame.samples_per_channel_; n > 0; --n) {

[kwiberg-webrtc, 2015/07/12 17:39:26]

Maybe n != 0 now that it can't be negative.

[Peter Kasting, 2015/07/13 02:46:26]

Is one preferred over the other for some reason?  It seems like both should be
optimized the same way, but "> 0" is more restrictive from a reader's
perspective, which I think is a good thing, since it means you don't have to
mentally think, "oh, size_t is unsigned, so this can't be negative, so it really
means > 0".

[kwiberg-webrtc, 2015/07/15 01:05:00]

The compiler is surely smart enough to realize that they're the same operation
for unsigned numbers. My opinion is that != 0 is more readable for unsigned
numbers, since that's what the operation actually is; when you wrote > 0, I had
to double check that n was actually unsigned, since that operation would (in my
head) have made more sense for a signed number.

It seems our intuitions about what's most natural here differ. But the
difference isn't large, and the compiler can't possibly care, so choose based on
whether getting the last word or sucking up to reviewers is more important to
you. :-)

[Peter Kasting, 2015/07/15 06:30:09]

When I'm working with webrtc code (where I'm basically an interloper) and trying
to earn reviewer approval for montrous patchsets that change hundreds of files,
I'll choose sucking up to reviewers :)

[Peter Kasting, 2015/07/17 00:12:08]

Done.

+    size_t i = n - 1;
     int16_t sample = frame.data_[i];
     out_buff[2 * i + 1] = sample;
     out_buff[2 * i] = sample;
   }
   return 0;
 }
 
 void ConvertEncodedInfoToFragmentationHeader(
     const AudioEncoder::EncodedInfo& info,
     RTPFragmentationHeader* frag) {
@@ skipping 226 matching lines @@
 // Add 10MS of raw (PCM) audio data to the encoder.
 int AudioCodingModuleImpl::Add10MsData(const AudioFrame& audio_frame) {
   InputData input_data;
   CriticalSectionScoped lock(acm_crit_sect_);
   int r = Add10MsDataInternal(audio_frame, &input_data);
   return r < 0 ? r : Encode(input_data);
 }
 
 int AudioCodingModuleImpl::Add10MsDataInternal(const AudioFrame& audio_frame,
                                                InputData* input_data) {
-  if (audio_frame.samples_per_channel_ <= 0) {
+  if (audio_frame.samples_per_channel_ == 0) {
     assert(false);
     WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
-                 "Cannot Add 10 ms audio, payload length is negative or "
-                 "zero");
+                 "Cannot Add 10 ms audio, payload length is zero");
     return -1;
   }
 
   if (audio_frame.sample_rate_hz_ > 48000) {
     assert(false);
     WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
                  "Cannot Add 10 ms audio, input frequency not valid");
     return -1;
   }
 
   // If the length and frequency matches. We currently just support raw PCM.
-  if ((audio_frame.sample_rate_hz_ / 100) !=
+  if (static_cast<size_t>(audio_frame.sample_rate_hz_ / 100) !=
       audio_frame.samples_per_channel_) {
     WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
                  "Cannot Add 10 ms audio, input frequency and length doesn't"
                  " match");
     return -1;
   }
 
   if (audio_frame.num_channels_ != 1 && audio_frame.num_channels_ != 2) {
     WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
                  "Cannot Add 10 ms audio, invalid number of channels.");
@@ skipping 102 matching lines @@
   }
 
   preprocess_frame_.timestamp_ = expected_codec_ts_;
   preprocess_frame_.samples_per_channel_ = in_frame.samples_per_channel_;
   preprocess_frame_.sample_rate_hz_ = in_frame.sample_rate_hz_;
   // If it is required, we have to do a resampling.
   if (resample) {
     // The result of the resampler is written to output frame.
     dest_ptr_audio = preprocess_frame_.data_;
 
-    preprocess_frame_.samples_per_channel_ = resampler_.Resample10Msec(
+    int samples_per_channel = resampler_.Resample10Msec(
         src_ptr_audio, in_frame.sample_rate_hz_,
         codec_manager_.CurrentEncoder()->SampleRateHz(),
         preprocess_frame_.num_channels_, AudioFrame::kMaxDataSizeSamples,
         dest_ptr_audio);
 
-    if (preprocess_frame_.samples_per_channel_ < 0) {
+    if (samples_per_channel < 0) {
       WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
                    "Cannot add 10 ms audio, resampling failed");
       return -1;
     }
+    preprocess_frame_.samples_per_channel_ =
+        static_cast<size_t>(samples_per_channel);
     preprocess_frame_.sample_rate_hz_ =
         codec_manager_.CurrentEncoder()->SampleRateHz();
   }
 
   expected_codec_ts_ +=
       static_cast<uint32_t>(preprocess_frame_.samples_per_channel_);
   expected_in_ts_ += static_cast<uint32_t>(in_frame.samples_per_channel_);
 
   return 0;
 }
@@ skipping 772 matching lines @@
       *channels = 1;
       break;
 #endif
     default:
       FATAL() << "Codec type " << codec_type << " not supported.";
   }
   return true;
 }
 
 }  // namespace webrtc