Convert channel counts to size_t.

webrtc/modules/audio_coding/codecs/g711/audio_encoder_pcm.cc

 /*
  *  Copyright (c) 2014 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_coding/codecs/g711/audio_encoder_pcm.h"
 
 #include <limits>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/common_types.h"
 #include "webrtc/modules/audio_coding/codecs/g711/g711_interface.h"
 
 namespace webrtc {
 
 namespace {
 
-int16_t NumSamplesPerFrame(int num_channels,
+int16_t NumSamplesPerFrame(size_t num_channels,
                            int frame_size_ms,
                            int sample_rate_hz) {
-  int samples_per_frame = num_channels * frame_size_ms * sample_rate_hz / 1000;
-  RTC_CHECK_LE(samples_per_frame, std::numeric_limits<int16_t>::max())
+  size_t samples_per_frame =

[minyue-webrtc, 2015/12/29 10:42:47]

but why not casting |num_channels| to int and keep the old code. Literally,
|samples_per_frame| can go negative.

[Peter Kasting, 2015/12/30 00:55:45]

What?  How can that be negative?  You'd have to have a negative frame size or a
negative sample rate, neither of which make sense.

And it's correct for |samples_per_frame| to be a size_t, as it's a count of
items stored in memory.

[minyue-webrtc, 2016/01/04 09:06:02]

sorry for ambiguity. I meant that there is no check on |frame_size_ms| and
|sample_rate_hz| to be non-negative. But I agree with you that
|samples_per_frame| sounds a size_t. Keep it this way.

Do you plan to let NumSamplesPerFrame return a size_t also?

[Peter Kasting, 2016/01/04 19:49:42]

Looking at its use, it should be, yes.  I can make that change, since it doesn't
look like it will transitively affect much else.  It's not clear to me whether
it's really necessary to CHECK that it's less than int16_t::max at that point.

[minyue-webrtc, 2016/01/04 22:03:18]

I guess that check is to make sure that casting on line 31 won't wrap around.
Making NumSamplesPerFrame return a size_t may be out-reached for this CL. I just
wanted to know if there is a plan in the future.

It is up to you whether to add a sanity check on the input argument. I prefer
you do it, to the degree that the function gives the same result in all cases as
it did before this CL, except for error input, which fails at the check.

[Peter Kasting, 2016/01/08 02:45:06]

I simplified everything to just do this calculation inline at the callsite,
since the result is being stored in a size_t anyway.  This looks like how other
similar sites do this anyway.

+      num_channels * frame_size_ms * sample_rate_hz / 1000;
+  RTC_CHECK_LE(samples_per_frame,
+               static_cast<size_t>(std::numeric_limits<int16_t>::max()))
       << "Frame size too large.";
   return static_cast<int16_t>(samples_per_frame);
 }
 
 template <typename T>
 typename T::Config CreateConfig(const CodecInst& codec_inst) {
   typename T::Config config;
   config.frame_size_ms = codec_inst.pacsize / 8;
   config.num_channels = codec_inst.channels;
   config.payload_type = codec_inst.pltype;
@@ skipping 25 matching lines @@
 AudioEncoderPcm::~AudioEncoderPcm() = default;
 
 size_t AudioEncoderPcm::MaxEncodedBytes() const {
   return full_frame_samples_ * BytesPerSample();
 }
 
 int AudioEncoderPcm::SampleRateHz() const {
   return sample_rate_hz_;
 }
 
-int AudioEncoderPcm::NumChannels() const {
+size_t AudioEncoderPcm::NumChannels() const {
   return num_channels_;
 }
 
 size_t AudioEncoderPcm::Num10MsFramesInNextPacket() const {
   return num_10ms_frames_per_packet_;
 }
 
 size_t AudioEncoderPcm::Max10MsFramesInAPacket() const {
   return num_10ms_frames_per_packet_;
 }
@@ skipping 50 matching lines @@
                                     size_t input_len,
                                     uint8_t* encoded) {
   return WebRtcG711_EncodeU(audio, input_len, encoded);
 }
 
 size_t AudioEncoderPcmU::BytesPerSample() const {
   return 1;
 }
 
 }  // namespace webrtc