CodecManager: Eliminate the stereo_send_ member

webrtc/modules/audio_coding/main/acm2/codec_manager.cc

 /*
  *  Copyright (c) 2015 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 119 matching lines @@
 
 const CodecInst kEmptyCodecInst = {-1, "noCodecRegistered", 0, 0, 0, 0};
 }  // namespace
 
 CodecManager::CodecManager()
     : cng_nb_pltype_(255),
       cng_wb_pltype_(255),
       cng_swb_pltype_(255),
       cng_fb_pltype_(255),
       red_nb_pltype_(255),
-      stereo_send_(false),
       dtx_enabled_(false),
       vad_mode_(VADNormal),
       send_codec_inst_(kEmptyCodecInst),
       red_enabled_(false),
       codec_fec_enabled_(false),
       encoder_is_opus_(false) {
   // Register the default payload type for RED and for CNG at sampling rates of
   // 8, 16, 32 and 48 kHz.
   for (const CodecInst& ci : RentACodec::Database()) {
     if (IsCodecRED(ci) && ci.plfreq == 8000) {
@@ skipping 73 matching lines @@
       default: {
         WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, dummy_id,
                      "RegisterSendCodec() failed, invalid frequency for CNG "
                      "registration");
         return -1;
       }
     }
   }
 
   // Set Stereo, and make sure VAD and DTX is turned off.
-  if (send_codec.channels == 2) {
-    stereo_send_ = true;
+  if (send_codec.channels != 1) {
     if (dtx_enabled_) {
       WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceAudioCoding, dummy_id,
                    "VAD/DTX is turned off, not supported when sending stereo.");
     }
     dtx_enabled_ = false;
-  } else {
-    stereo_send_ = false;
   }
 
   // Check if the codec is already registered as send codec.
   bool new_codec = true;
   if (codec_owner_.Encoder()) {
     auto new_codec_id = RentACodec::CodecIdByInst(send_codec_inst_);
     RTC_DCHECK(new_codec_id);
     auto old_codec_id = RentACodec::CodecIdFromIndex(codec_id);
     new_codec = !old_codec_id || *new_codec_id != *old_codec_id;
   }
@@ skipping 61 matching lines @@
   send_codec_inst_.plfreq = external_speech_encoder->SampleRateHz();
   send_codec_inst_.pacsize = rtc::CheckedDivExact(
       static_cast<int>(external_speech_encoder->Max10MsFramesInAPacket() *
                        send_codec_inst_.plfreq),
       100);
   send_codec_inst_.pltype = -1;  // Not valid.
   send_codec_inst_.rate = -1;    // Not valid.
   static const char kName[] = "external";
   memcpy(send_codec_inst_.plname, kName, sizeof(kName));
 
-  if (stereo_send_)
+  if (send_codec_inst_.channels != 1)
     dtx_enabled_ = false;
   codec_fec_enabled_ =
       codec_fec_enabled_ && codec_owner_.Encoder()->SetFec(codec_fec_enabled_);
   int cng_pt = dtx_enabled_
                    ? CngPayloadType(external_speech_encoder->SampleRateHz())
                    : -1;
   int red_pt = red_enabled_ ? RedPayloadType(send_codec_inst_.plfreq) : -1;
   codec_owner_.SetEncoders(external_speech_encoder, cng_pt, vad_mode_, red_pt);
 }
 
@@ skipping 32 matching lines @@
   return true;
 }
 
 int CodecManager::SetVAD(bool enable, ACMVADMode mode) {
   // Sanity check of the mode.
   RTC_DCHECK(mode == VADNormal || mode == VADLowBitrate || mode == VADAggr ||
              mode == VADVeryAggr);
 
   // Check that the send codec is mono. We don't support VAD/DTX for stereo
   // sending.
-  if (enable && stereo_send_) {
+  const auto* enc = codec_owner_.Encoder();
+  const bool stereo_send = enc ? (enc->NumChannels() != 1) : false;
+  if (enable && stereo_send) {
     WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, 0,
                  "VAD/DTX not supported for stereo sending");
     dtx_enabled_ = false;
     return -1;
   }
 
   // If a send codec is registered, set VAD/DTX for the codec.
   if (IsOpus(send_codec_inst_)) {
     // VAD/DTX not supported.
     dtx_enabled_ = false;
     return 0;
   }
 
   if (dtx_enabled_ != enable || vad_mode_ != mode) {
     dtx_enabled_ = enable;
     vad_mode_ = mode;
-    if (codec_owner_.Encoder()) {
+    if (enc) {
       int cng_pt = dtx_enabled_ ? CngPayloadType(send_codec_inst_.plfreq) : -1;
       int red_pt = red_enabled_ ? RedPayloadType(send_codec_inst_.plfreq) : -1;
       codec_owner_.ChangeCngAndRed(cng_pt, vad_mode_, red_pt);
     }
   }
   return 0;
 }
 
 void CodecManager::VAD(bool* dtx_enabled,
                        bool* vad_enabled,
@@ skipping 45 matching lines @@
     case 48000:
       return -1;
     default:
       FATAL() << sample_rate_hz << " Hz is not supported";
       return -1;
   }
 }
 
 }  // namespace acm2
 }  // namespace webrtc