Convert channel counts to size_t.

webrtc/voice_engine/transmit_mixer.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 282 matching lines @@
 TransmitMixer::SetAudioProcessingModule(AudioProcessing* audioProcessingModule)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::SetAudioProcessingModule("
                  "audioProcessingModule=0x%x)",
                  audioProcessingModule);
     audioproc_ = audioProcessingModule;
     return 0;
 }
 
-void TransmitMixer::GetSendCodecInfo(int* max_sample_rate, int* max_channels) {
+void TransmitMixer::GetSendCodecInfo(int* max_sample_rate,
+                                     size_t* max_channels) {
   *max_sample_rate = 8000;
   *max_channels = 1;
   for (ChannelManager::Iterator it(_channelManagerPtr); it.IsValid();
        it.Increment()) {
     Channel* channel = it.GetChannel();
     if (channel->Sending()) {
       CodecInst codec;
       channel->GetSendCodec(codec);
       *max_sample_rate = std::max(*max_sample_rate, codec.plfreq);
       *max_channels = std::max(*max_channels, codec.channels);
     }
   }
 }
 
 int32_t
 TransmitMixer::PrepareDemux(const void* audioSamples,
                             size_t nSamples,
-                            uint8_t nChannels,
+                            size_t nChannels,
                             uint32_t samplesPerSec,
                             uint16_t totalDelayMS,
                             int32_t clockDrift,
                             uint16_t currentMicLevel,
                             bool keyPressed)
 {
     WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::PrepareDemux(nSamples=%" PRIuS ", "
-                 "nChannels=%u, samplesPerSec=%u, totalDelayMS=%u, "
+                 "nChannels=%" PRIuS ", samplesPerSec=%u, totalDelayMS=%u, "
                  "clockDrift=%d, currentMicLevel=%u)",
                  nSamples, nChannels, samplesPerSec, totalDelayMS, clockDrift,
                  currentMicLevel);
 
     // --- Resample input audio and create/store the initial audio frame
     GenerateAudioFrame(static_cast<const int16_t*>(audioSamples),
                        nSamples,
                        nChannels,
                        samplesPerSec);
 
@@ skipping 84 matching lines @@
         {
             // Demultiplex makes a copy of its input.
             channelPtr->Demultiplex(_audioFrame);
             channelPtr->PrepareEncodeAndSend(_audioFrame.sample_rate_hz_);
         }
     }
     return 0;
 }
 
 void TransmitMixer::DemuxAndMix(const int voe_channels[],
-                                int number_of_voe_channels) {
-  for (int i = 0; i < number_of_voe_channels; ++i) {
+                                size_t number_of_voe_channels) {
+  for (size_t i = 0; i < number_of_voe_channels; ++i) {
     voe::ChannelOwner ch = _channelManagerPtr->GetChannel(voe_channels[i]);
     voe::Channel* channel_ptr = ch.channel();
     if (channel_ptr) {
       if (channel_ptr->Sending()) {
         // Demultiplex makes a copy of its input.
         channel_ptr->Demultiplex(_audioFrame);
         channel_ptr->PrepareEncodeAndSend(_audioFrame.sample_rate_hz_);
       }
     }
   }
@@ skipping 11 matching lines @@
         Channel* channelPtr = it.GetChannel();
         if (channelPtr->Sending())
         {
             channelPtr->EncodeAndSend();
         }
     }
     return 0;
 }
 
 void TransmitMixer::EncodeAndSend(const int voe_channels[],
-                                  int number_of_voe_channels) {
-  for (int i = 0; i < number_of_voe_channels; ++i) {
+                                  size_t number_of_voe_channels) {
+  for (size_t i = 0; i < number_of_voe_channels; ++i) {
     voe::ChannelOwner ch = _channelManagerPtr->GetChannel(voe_channels[i]);
     voe::Channel* channel_ptr = ch.channel();
     if (channel_ptr && channel_ptr->Sending())
       channel_ptr->EncodeAndSend();
   }
 }
 
 uint32_t TransmitMixer::CaptureLevel() const
 {
     return _captureLevel;
@@ skipping 211 matching lines @@
     {
         WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
                      "StartRecordingMicrophone() is already recording");
         return 0;
     }
 
     FileFormats format;
     const uint32_t notificationTime(0); // Not supported in VoE
     CodecInst dummyCodec = { 100, "L16", 16000, 320, 1, 320000 };
 
-    if (codecInst != NULL &&
-      (codecInst->channels < 0 || codecInst->channels > 2))
+    if (codecInst != NULL && codecInst->channels > 2)
     {
         _engineStatisticsPtr->SetLastError(
             VE_BAD_ARGUMENT, kTraceError,
             "StartRecordingMicrophone() invalid compression");
         return (-1);
     }
     if (codecInst == NULL)
     {
         format = kFileFormatPcm16kHzFile;
         codecInst = &dummyCodec;
@@ skipping 413 matching lines @@
 }
 
 bool TransmitMixer::IsRecordingMic()
 {
     CriticalSectionScoped cs(&_critSect);
     return _fileRecording;
 }
 
 void TransmitMixer::GenerateAudioFrame(const int16_t* audio,
                                        size_t samples_per_channel,
-                                       int num_channels,
+                                       size_t num_channels,
                                        int sample_rate_hz) {
   int codec_rate;
-  int num_codec_channels;
+  size_t num_codec_channels;
   GetSendCodecInfo(&codec_rate, &num_codec_channels);
   stereo_codec_ = num_codec_channels == 2;
 
   // We want to process at the lowest rate possible without losing information.
   // Choose the lowest native rate at least equal to the input and codec rates.
   const int min_processing_rate = std::min(sample_rate_hz, codec_rate);
   for (size_t i = 0; i < AudioProcessing::kNumNativeSampleRates; ++i) {
     _audioFrame.sample_rate_hz_ = AudioProcessing::kNativeSampleRatesHz[i];
     if (_audioFrame.sample_rate_hz_ >= min_processing_rate) {
       break;
@@ skipping 183 matching lines @@
 void TransmitMixer::EnableStereoChannelSwapping(bool enable) {
   swap_stereo_channels_ = enable;
 }
 
 bool TransmitMixer::IsStereoChannelSwappingEnabled() {
   return swap_stereo_channels_;
 }
 
 }  // namespace voe
 }  // namespace webrtc