Convert channel counts to size_t.

webrtc/modules/include/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 10 matching lines @@
 #include "webrtc/common_types.h"
 #include "webrtc/common_video/rotation.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
 
 struct RTPAudioHeader {
   uint8_t numEnergy;                  // number of valid entries in arrOfEnergy
   uint8_t arrOfEnergy[kRtpCsrcSize];  // one energy byte (0-9) per channel
   bool isCNG;                         // is this CNG
-  uint8_t channel;                    // number of channels 2 = stereo
+  size_t channel;                     // number of channels 2 = stereo
 };
 
 const int16_t kNoPictureId = -1;
 const int16_t kMaxOneBytePictureId = 0x7F;    // 7 bits
 const int16_t kMaxTwoBytePictureId = 0x7FFF;  // 15 bits
 const int16_t kNoTl0PicIdx = -1;
 const uint8_t kNoTemporalIdx = 0xFF;
 const uint8_t kNoSpatialIdx = 0xFF;
 const uint8_t kNoGofIdx = 0xFF;
 const uint8_t kNumVp9Buffers = 8;
@@ skipping 459 matching lines @@
   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,
                    size_t samples_per_channel, int sample_rate_hz,
                    SpeechType speech_type, VADActivity vad_activity,
-                   int num_channels = 1, uint32_t energy = -1);
+                   size_t 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];
   size_t samples_per_channel_;
   int sample_rate_hz_;
-  int num_channels_;
+  size_t 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_;
 
  private:
@@ skipping 21 matching lines @@
   interleaved_ = true;
 }
 
 inline void AudioFrame::UpdateFrame(int id,
                                     uint32_t timestamp,
                                     const int16_t* data,
                                     size_t samples_per_channel,
                                     int sample_rate_hz,
                                     SpeechType speech_type,
                                     VADActivity vad_activity,
-                                    int num_channels,
+                                    size_t 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 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 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) {
@@ skipping 178 matching lines @@
     return unwrapped;
   }
 
  private:
   int64_t last_seq_;
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_INCLUDE_MODULE_COMMON_TYPES_H_