On WVoMC::SetSendParameters(), figure out send codec settings ONCE, not for each send stream.

webrtc/media/engine/webrtcvoiceengine.cc

 /*
  *  Copyright (c) 2004 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 362 matching lines @@
           codec->pacsize = (codec->plfreq / 1000) * packet_size_ms;
           return true;
         }
       }
     }
     return false;
   }
 
   static const AudioCodec* GetPreferredCodec(
       const std::vector<AudioCodec>& codecs,
-      webrtc::CodecInst* voe_codec,
+      webrtc::CodecInst* out,
       int* red_payload_type) {
-    RTC_DCHECK(voe_codec);
+    RTC_DCHECK(out);
     RTC_DCHECK(red_payload_type);
     // Select the preferred send codec (the first non-telephone-event/CN codec).
     for (const AudioCodec& codec : codecs) {
       *red_payload_type = -1;
       if (IsCodec(codec, kDtmfCodecName) || IsCodec(codec, kCnCodecName)) {
         // Skip telephone-event/CN codec, which will be handled later.
         continue;
       }
 
       // We'll use the first codec in the list to actually send audio data.
       // Be sure to use the payload type requested by the remote side.
       // "red", for RED audio, is a special case where the actual codec to be
       // used is specified in params.
       const AudioCodec* found_codec = &codec;
       if (IsCodec(*found_codec, kRedCodecName)) {
         // Parse out the RED parameters. If we fail, just ignore RED;
         // we don't support all possible params/usage scenarios.
         *red_payload_type = codec.id;
         found_codec = GetRedSendCodec(*found_codec, codecs);
         if (!found_codec) {
           continue;
         }
       }
       // Ignore codecs we don't know about. The negotiation step should prevent
       // this, but double-check to be sure.
-      if (!ToCodecInst(*found_codec, voe_codec)) {
+      webrtc::CodecInst voe_codec = {0};
+      if (!ToCodecInst(*found_codec, &voe_codec)) {
         LOG(LS_WARNING) << "Unknown codec " << ToString(*found_codec);
         continue;
       }
+      *out = voe_codec;

[minyue-webrtc, 2016/03/08 10:19:47]

what is the benefit of copying?

[the sun, 2016/03/08 12:04:02]

The benefit is that we don't risk mutating the caller's state until we really
have a result available.

       return found_codec;
     }
     return nullptr;
   }
 
  private:
   static const int kMaxNumPacketSize = 6;
   struct CodecPref {
     const char* name;
     int clockrate;
@@ skipping 134 matching lines @@
     LOG(LS_INFO) << "WebRtcVoiceEngine::Init Done!";
   } else {
     LOG(LS_ERROR) << "WebRtcVoiceEngine::Init failed";
     Terminate();
   }
   return res;
 }
 
 bool WebRtcVoiceEngine::InitInternal() {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  // Temporarily turn logging level up for the Init call
+  // Temporarily turn logging level up for the Init call.
   webrtc::Trace::set_level_filter(kElevatedTraceFilter);
   LOG(LS_INFO) << webrtc::VoiceEngine::GetVersionString();
   if (voe_wrapper_->base()->Init(adm_) == -1) {
     LOG_RTCERR0_EX(Init, voe_wrapper_->error());
     return false;
   }
   webrtc::Trace::set_level_filter(kDefaultTraceFilter);
 
   // Save the default AGC configuration settings. This must happen before
   // calling ApplyOptions or the default will be overwritten.
@@ skipping 16 matching lines @@
     options.adjust_agc_delta = rtc::Optional<int>(0);
     options.experimental_agc = rtc::Optional<bool>(false);
     options.extended_filter_aec = rtc::Optional<bool>(false);
     options.delay_agnostic_aec = rtc::Optional<bool>(false);
     options.experimental_ns = rtc::Optional<bool>(false);
     if (!ApplyOptions(options)) {
       return false;
     }
   }
 
-  // Print our codec list again for the call diagnostic log
+  // Print our codec list again for the call diagnostic log.
   LOG(LS_INFO) << "WebRtc VoiceEngine codecs:";
   for (const AudioCodec& codec : codecs_) {
     LOG(LS_INFO) << ToString(codec);
   }
 
   SetDefaultDevices();
 
   initialized_ = true;
   return true;
 }
@@ skipping 379 matching lines @@
   rtc::LoggingSeverity sev = rtc::LS_VERBOSE;
   if (level == webrtc::kTraceError || level == webrtc::kTraceCritical)
     sev = rtc::LS_ERROR;
   else if (level == webrtc::kTraceWarning)
     sev = rtc::LS_WARNING;
   else if (level == webrtc::kTraceStateInfo || level == webrtc::kTraceInfo)
     sev = rtc::LS_INFO;
   else if (level == webrtc::kTraceTerseInfo)
     sev = rtc::LS_INFO;
 
-  // Skip past boilerplate prefix text
+  // Skip past boilerplate prefix text.
   if (length < 72) {
     std::string msg(trace, length);
     LOG(LS_ERROR) << "Malformed webrtc log message: ";
     LOG_V(sev) << msg;
   } else {
     std::string msg(trace + 71, length - 72);
     LOG_V(sev) << "webrtc: " << msg;
   }
 }
 
@@ skipping 465 matching lines @@
   }
 
   if (playout_) {
     // Receive codecs can not be changed while playing. So we temporarily
     // pause playout.
     PausePlayout();
   }
 
   bool result = true;
   for (const AudioCodec& codec : new_codecs) {
-    webrtc::CodecInst voe_codec;
+    webrtc::CodecInst voe_codec = {0};
     if (WebRtcVoiceEngine::ToCodecInst(codec, &voe_codec)) {
       LOG(LS_INFO) << ToString(codec);
       voe_codec.pltype = codec.id;
       for (const auto& ch : recv_streams_) {
         if (engine()->voe()->codec()->SetRecPayloadType(
                 ch.second->channel(), voe_codec) == -1) {
           LOG_RTCERR2(SetRecPayloadType, ch.second->channel(),
                       ToString(voe_codec));
           result = false;
         }
       }
     } else {
       LOG(LS_WARNING) << "Unknown codec " << ToString(codec);
       result = false;
       break;
     }
   }
   if (result) {
     recv_codecs_ = codecs;
   }
 
   if (desired_playout_ && !playout_) {
     ResumePlayout();
   }
   return result;
 }
 
+// Utility function called from SetSendParameters() to extract current send
+// codec settings from the given list of codecs (originally from SDP). Both send
+// and receive streams may be reconfigured based on the new settings.
 bool WebRtcVoiceMediaChannel::SetSendCodecs(
-    int channel, const std::vector<AudioCodec>& codecs) {
+    const std::vector<AudioCodec>& codecs) {
+  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+  // TODO(solenberg): Validate input - that payload types don't overlap, are
+  //                  within range, filter out codecs we don't support,
+  //                  redundant codecs etc.
+
+  // Find the DTMF telephone event "codec" payload type.
+  dtmf_payload_type_ = rtc::Optional<int>();
+  for (const AudioCodec& codec : codecs) {
+    if (IsCodec(codec, kDtmfCodecName)) {
+      dtmf_payload_type_ = rtc::Optional<int>(codec.id);
+      break;
+    }
+  }
+
+  // Scan through the list to figure out the codec to use for sending, along
+  // with the proper configuration for VAD, CNG, RED, NACK and Opus-specific
+  // parameters.
+  {
+    SendCodecSpec send_codec_spec;
+    send_codec_spec.nack_enabled = send_codec_spec_.nack_enabled;
+
+    // Find send codec (the first non-telephone-event/CN codec).
+    const AudioCodec* codec = WebRtcVoiceCodecs::GetPreferredCodec(
+        codecs, &send_codec_spec.codec_inst, &send_codec_spec.red_payload_type);
+    if (!codec) {
+      LOG(LS_WARNING) << "Received empty list of codecs.";
+      return false;
+    }
+
+    send_codec_spec.transport_cc_enabled = HasTransportCc(*codec);
+
+    // TODO(solenberg): This is a curious condition - kept for legacy reasons -
+    //                  why would we only want to figure out these parameters
+    //                  when RED is disabled?
+    if (send_codec_spec.red_payload_type == -1) {
+      send_codec_spec.nack_enabled = HasNack(*codec);
+      // For Opus as the send codec, we are to determine inband FEC, maximum
+      // playback rate, and opus internal dtx.
+      if (IsCodec(*codec, kOpusCodecName)) {
+        GetOpusConfig(*codec, &send_codec_spec.codec_inst,
+                      &send_codec_spec.enable_codec_fec,
+                      &send_codec_spec.opus_max_playback_rate,
+                      &send_codec_spec.enable_opus_dtx);
+      }
+
+      // Set packet size if the AudioCodec param kCodecParamPTime is set.
+      int ptime_ms = 0;
+      if (codec->GetParam(kCodecParamPTime, &ptime_ms)) {
+        if (!WebRtcVoiceCodecs::SetPTimeAsPacketSize(
+            &send_codec_spec.codec_inst, ptime_ms)) {
+          LOG(LS_WARNING) << "Failed to set packet size for codec "
+                          << send_codec_spec.codec_inst.plname;
+          return false;
+        }
+      }
+    }
+
+    // Loop through the codecs list again to find the CN codec.
+    // TODO(solenberg): Break out into a separate function?

[minyue-webrtc, 2016/03/08 10:19:47]

may just do it in this CL

[the sun, 2016/03/08 12:04:02]

No, I'm not sure it is the right thing to do.

+    for (const AudioCodec& codec : codecs) {
+      // Ignore codecs we don't know about. The negotiation step should prevent
+      // this, but double-check to be sure.
+      webrtc::CodecInst voe_codec = {0};
+      if (!WebRtcVoiceEngine::ToCodecInst(codec, &voe_codec)) {
+        LOG(LS_WARNING) << "Unknown codec " << ToString(codec);
+        continue;
+      }
+
+      if (IsCodec(codec, kCnCodecName)) {
+        // Turn voice activity detection/comfort noise on if supported.
+        // Set the wideband CN payload type appropriately.
+        // (narrowband always uses the static payload type 13).
+        int cng_plfreq = -1;
+        switch (codec.clockrate) {
+          case 8000:
+          case 16000:
+          case 32000:
+            cng_plfreq = codec.clockrate;
+            break;
+          default:
+            LOG(LS_WARNING) << "CN frequency " << codec.clockrate
+                            << " not supported.";
+            continue;
+        }
+        send_codec_spec.cng_payload_type = codec.id;
+        send_codec_spec.cng_plfreq = cng_plfreq;
+        break;
+      }
+    }
+
+    // Latch in the new state.
+    send_codec_spec_ = std::move(send_codec_spec);
+  }
+
+  // Cache the codecs in order to configure the channel created later.
+  for (const auto& ch : send_streams_) {
+    if (!SetSendCodecs(ch.second->channel())) {
+      return false;
+    }
+  }
+
+  // Set nack status on receive channels.
+  if (!send_streams_.empty()) {
+    for (const auto& kv : recv_streams_) {
+      SetNack(kv.second->channel(), send_codec_spec_.nack_enabled);
+    }
+  }
+
+  // Check if the transport cc feedback has changed on the preferred send codec,
+  // and in that case reconfigure all receive streams.
+  if (recv_transport_cc_enabled_ != send_codec_spec_.transport_cc_enabled) {
+    LOG(LS_INFO) << "Recreate all the receive streams because the send "
+                    "codec has changed.";
+    recv_transport_cc_enabled_ = send_codec_spec_.transport_cc_enabled;
+    for (auto& kv : recv_streams_) {
+      kv.second->RecreateAudioReceiveStream(recv_transport_cc_enabled_);
+    }
+  }
+
+  return true;
+}
+
+// Apply current codec settings to a single voe::Channel used for sending.
+bool WebRtcVoiceMediaChannel::SetSendCodecs(int channel) {
   // Disable VAD, FEC, and RED unless we know the other side wants them.
   engine()->voe()->codec()->SetVADStatus(channel, false);
   engine()->voe()->rtp()->SetNACKStatus(channel, false, 0);
   engine()->voe()->rtp()->SetREDStatus(channel, false);
   engine()->voe()->codec()->SetFECStatus(channel, false);
 
-  // Scan through the list to figure out the codec to use for sending, along
-  // with the proper configuration for VAD.
-  webrtc::CodecInst send_codec;
-  memset(&send_codec, 0, sizeof(send_codec));
-
-  bool nack_enabled = nack_enabled_;
-  bool enable_codec_fec = false;
-  bool enable_opus_dtx = false;
-  int opus_max_playback_rate = 0;
-  int red_payload_type = -1;
-
-  // Set send codec (the first non-telephone-event/CN codec)
-  const AudioCodec* codec = WebRtcVoiceCodecs::GetPreferredCodec(
-      codecs, &send_codec, &red_payload_type);
-  if (codec) {
-    if (red_payload_type != -1) {
-      // Enable redundant encoding of the specified codec. Treat any
-      // failure as a fatal internal error.
-      LOG(LS_INFO) << "Enabling RED on channel " << channel;
-      if (engine()->voe()->rtp()->SetREDStatus(channel, true,
-                                               red_payload_type) == -1) {
-        LOG_RTCERR3(SetREDStatus, channel, true, red_payload_type);
-        return false;
-      }
-    } else {
-      nack_enabled = HasNack(*codec);
-      // For Opus as the send codec, we are to determine inband FEC, maximum
-      // playback rate, and opus internal dtx.
-      if (IsCodec(*codec, kOpusCodecName)) {
-        GetOpusConfig(*codec, &send_codec, &enable_codec_fec,
-                      &opus_max_playback_rate, &enable_opus_dtx);
-      }
-
-      // Set packet size if the AudioCodec param kCodecParamPTime is set.
-      int ptime_ms = 0;
-      if (codec->GetParam(kCodecParamPTime, &ptime_ms)) {
-        if (!WebRtcVoiceCodecs::SetPTimeAsPacketSize(&send_codec, ptime_ms)) {
-          LOG(LS_WARNING) << "Failed to set packet size for codec "
-                          << send_codec.plname;
-          return false;
-        }
-      }
+  if (send_codec_spec_.red_payload_type != -1) {
+    // Enable redundant encoding of the specified codec. Treat any
+    // failure as a fatal internal error.
+    LOG(LS_INFO) << "Enabling RED on channel " << channel;
+    if (engine()->voe()->rtp()->SetREDStatus(channel, true,
+        send_codec_spec_.red_payload_type) == -1) {
+      LOG_RTCERR3(SetREDStatus, channel, true,
+                  send_codec_spec_.red_payload_type);
+      return false;
     }
   }
 
-  if (nack_enabled_ != nack_enabled) {
-    SetNack(channel, nack_enabled);
-    nack_enabled_ = nack_enabled;
-  }
-  if (!codec) {
-    LOG(LS_WARNING) << "Received empty list of codecs.";
+  SetNack(channel, send_codec_spec_.nack_enabled);
+
+  // Set the codec immediately, since SetVADStatus() depends on whether
+  // the current codec is mono or stereo.
+  if (!SetSendCodec(channel, send_codec_spec_.codec_inst)) {
     return false;
   }
 
-  // Set the codec immediately, since SetVADStatus() depends on whether
-  // the current codec is mono or stereo.
-  if (!SetSendCodec(channel, send_codec))
-    return false;
-
   // FEC should be enabled after SetSendCodec.
-  if (enable_codec_fec) {
+  if (send_codec_spec_.enable_codec_fec) {
     LOG(LS_INFO) << "Attempt to enable codec internal FEC on channel "
                  << channel;
     if (engine()->voe()->codec()->SetFECStatus(channel, true) == -1) {
       // Enable codec internal FEC. Treat any failure as fatal internal error.
       LOG_RTCERR2(SetFECStatus, channel, true);
       return false;
     }
   }
 
-  if (IsCodec(send_codec, kOpusCodecName)) {
+  if (IsCodec(send_codec_spec_.codec_inst, kOpusCodecName)) {
     // DTX and maxplaybackrate should be set after SetSendCodec. Because current
     // send codec has to be Opus.
 
     // Set Opus internal DTX.
     LOG(LS_INFO) << "Attempt to "
-                 << (enable_opus_dtx ? "enable" : "disable")
+                 << (send_codec_spec_.enable_opus_dtx ? "enable" : "disable")
                  << " Opus DTX on channel "
                  << channel;
-    if (engine()->voe()->codec()->SetOpusDtx(channel, enable_opus_dtx)) {
-      LOG_RTCERR2(SetOpusDtx, channel, enable_opus_dtx);
+    if (engine()->voe()->codec()->SetOpusDtx(channel,
+        send_codec_spec_.enable_opus_dtx)) {
+      LOG_RTCERR2(SetOpusDtx, channel, send_codec_spec_.enable_opus_dtx);
       return false;
     }
 
     // If opus_max_playback_rate <= 0, the default maximum playback rate
     // (48 kHz) will be used.
-    if (opus_max_playback_rate > 0) {
+    if (send_codec_spec_.opus_max_playback_rate > 0) {
       LOG(LS_INFO) << "Attempt to set maximum playback rate to "
-                   << opus_max_playback_rate
+                   << send_codec_spec_.opus_max_playback_rate
                    << " Hz on channel "
                    << channel;
       if (engine()->voe()->codec()->SetOpusMaxPlaybackRate(
-          channel, opus_max_playback_rate) == -1) {
-        LOG_RTCERR2(SetOpusMaxPlaybackRate, channel, opus_max_playback_rate);
+          channel, send_codec_spec_.opus_max_playback_rate) == -1) {
+        LOG_RTCERR2(SetOpusMaxPlaybackRate, channel,
+                    send_codec_spec_.opus_max_playback_rate);
         return false;
       }
     }
   }
 
-  // Always update the |send_codec_| to the currently set send codec.
-  send_codec_.reset(new webrtc::CodecInst(send_codec));
-
   if (send_bitrate_setting_) {
     SetSendBitrateInternal(send_bitrate_bps_);
   }
 
-  // Loop through the codecs list again to config the CN codec.
-  for (const AudioCodec& codec : codecs) {
-    // Ignore codecs we don't know about. The negotiation step should prevent
-    // this, but double-check to be sure.
-    webrtc::CodecInst voe_codec;
-    if (!WebRtcVoiceEngine::ToCodecInst(codec, &voe_codec)) {
-      LOG(LS_WARNING) << "Unknown codec " << ToString(codec);
-      continue;
-    }
-
-    if (IsCodec(codec, kCnCodecName)) {
-      // Turn voice activity detection/comfort noise on if supported.
-      // Set the wideband CN payload type appropriately.
-      // (narrowband always uses the static payload type 13).
+  // Set the CN payloadtype and the VAD status.
+  if (send_codec_spec_.cng_payload_type != -1) {
+    // The CN payload type for 8000 Hz clockrate is fixed at 13.
+    if (send_codec_spec_.cng_plfreq != 8000) {
       webrtc::PayloadFrequencies cn_freq;
-      switch (codec.clockrate) {
-        case 8000:
-          cn_freq = webrtc::kFreq8000Hz;
-          break;
+      switch (send_codec_spec_.cng_plfreq) {
         case 16000:
           cn_freq = webrtc::kFreq16000Hz;
           break;
         case 32000:
           cn_freq = webrtc::kFreq32000Hz;
           break;
         default:
-          LOG(LS_WARNING) << "CN frequency " << codec.clockrate
-                          << " not supported.";
-          continue;
+          RTC_NOTREACHED();
+          return false;
       }
-      // Set the CN payloadtype and the VAD status.
-      // The CN payload type for 8000 Hz clockrate is fixed at 13.
-      if (cn_freq != webrtc::kFreq8000Hz) {
-        if (engine()->voe()->codec()->SetSendCNPayloadType(
-                channel, codec.id, cn_freq) == -1) {
-          LOG_RTCERR3(SetSendCNPayloadType, channel, codec.id, cn_freq);
-          // TODO(ajm): This failure condition will be removed from VoE.
-          // Restore the return here when we update to a new enough webrtc.
-          //
-          // Not returning false because the SetSendCNPayloadType will fail if
-          // the channel is already sending.
-          // This can happen if the remote description is applied twice, for
-          // example in the case of ROAP on top of JSEP, where both side will
-          // send the offer.
-        }
+      if (engine()->voe()->codec()->SetSendCNPayloadType(
+              channel, send_codec_spec_.cng_payload_type, cn_freq) == -1) {
+        LOG_RTCERR3(SetSendCNPayloadType, channel,
+                    send_codec_spec_.cng_payload_type, cn_freq);
+        // TODO(ajm): This failure condition will be removed from VoE.
+        // Restore the return here when we update to a new enough webrtc.
+        //
+        // Not returning false because the SetSendCNPayloadType will fail if
+        // the channel is already sending.
+        // This can happen if the remote description is applied twice, for
+        // example in the case of ROAP on top of JSEP, where both side will
+        // send the offer.
       }
-      // Only turn on VAD if we have a CN payload type that matches the
-      // clockrate for the codec we are going to use.
-      if (codec.clockrate == send_codec.plfreq && send_codec.channels != 2) {
-        // TODO(minyue): If CN frequency == 48000 Hz is allowed, consider the
-        // interaction between VAD and Opus FEC.
-        LOG(LS_INFO) << "Enabling VAD";
-        if (engine()->voe()->codec()->SetVADStatus(channel, true) == -1) {
-          LOG_RTCERR2(SetVADStatus, channel, true);
-          return false;
-        }
+    }
+
+    // Only turn on VAD if we have a CN payload type that matches the
+    // clockrate for the codec we are going to use.
+    if (send_codec_spec_.cng_plfreq == send_codec_spec_.codec_inst.plfreq &&
+        send_codec_spec_.codec_inst.channels == 1) {
+      // TODO(minyue): If CN frequency == 48000 Hz is allowed, consider the
+      // interaction between VAD and Opus FEC.
+      LOG(LS_INFO) << "Enabling VAD";
+      if (engine()->voe()->codec()->SetVADStatus(channel, true) == -1) {
+        LOG_RTCERR2(SetVADStatus, channel, true);
+        return false;
       }
     }
   }
   return true;
 }
 
-bool WebRtcVoiceMediaChannel::SetSendCodecs(
-    const std::vector<AudioCodec>& codecs) {
-  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  // TODO(solenberg): Validate input - that payload types don't overlap, are
-  //                  within range, filter out codecs we don't support,
-  //                  redundant codecs etc.
-
-  // Find the DTMF telephone event "codec" payload type.
-  dtmf_payload_type_ = rtc::Optional<int>();
-  for (const AudioCodec& codec : codecs) {
-    if (IsCodec(codec, kDtmfCodecName)) {
-      dtmf_payload_type_ = rtc::Optional<int>(codec.id);
-      break;
-    }
-  }
-
-  // Cache the codecs in order to configure the channel created later.
-  send_codecs_ = codecs;
-  for (const auto& ch : send_streams_) {
-    if (!SetSendCodecs(ch.second->channel(), codecs)) {
-      return false;
-    }
-  }
-
-  // Set nack status on receive channels and update |nack_enabled_|.
-  for (const auto& ch : recv_streams_) {
-    SetNack(ch.second->channel(), nack_enabled_);
-  }
-
-  // Check if the transport cc feedback has changed on the preferred send codec,
-  // and in that case reconfigure all receive streams.
-  webrtc::CodecInst voe_codec;
-  int red_payload_type;
-  const AudioCodec* send_codec = WebRtcVoiceCodecs::GetPreferredCodec(
-      send_codecs_, &voe_codec, &red_payload_type);
-  if (send_codec) {
-    bool transport_cc = HasTransportCc(*send_codec);
-    if (transport_cc_enabled_ != transport_cc) {
-      LOG(LS_INFO) << "Recreate all the receive streams because the send "
-                      "codec has changed.";
-      transport_cc_enabled_ = transport_cc;
-      for (auto& kv : recv_streams_) {
-        RTC_DCHECK(kv.second != nullptr);
-        kv.second->RecreateAudioReceiveStream(transport_cc_enabled_);
-      }
-    }
-  }
-
-  return true;
-}
-
 void WebRtcVoiceMediaChannel::SetNack(int channel, bool nack_enabled) {
   if (nack_enabled) {
     LOG(LS_INFO) << "Enabling NACK for channel " << channel;
     engine()->voe()->rtp()->SetNACKStatus(channel, true, kNackMaxPackets);
   } else {
     LOG(LS_INFO) << "Disabling NACK for channel " << channel;
     engine()->voe()->rtp()->SetNACKStatus(channel, false, 0);
   }
 }
 
 bool WebRtcVoiceMediaChannel::SetSendCodec(
     int channel, const webrtc::CodecInst& send_codec) {
   LOG(LS_INFO) << "Send channel " << channel <<  " selected voice codec "
                << ToString(send_codec) << ", bitrate=" << send_codec.rate;
 
-  webrtc::CodecInst current_codec;
+  webrtc::CodecInst current_codec = {0};
   if (engine()->voe()->codec()->GetSendCodec(channel, current_codec) == 0 &&
       (send_codec == current_codec)) {
     // Codec is already configured, we can return without setting it again.
     return true;
   }
 
   if (engine()->voe()->codec()->SetSendCodec(channel, send_codec) == -1) {
     LOG_RTCERR2(SetSendCodec, channel, ToString(send_codec));
     return false;
   }
@@ skipping 149 matching lines @@
   // Save the channel to send_streams_, so that RemoveSendStream() can still
   // delete the channel in case failure happens below.
   webrtc::AudioTransport* audio_transport =
       engine()->voe()->base()->audio_transport();
   send_streams_.insert(std::make_pair(ssrc, new WebRtcAudioSendStream(
       channel, audio_transport, ssrc, sp.cname, send_rtp_extensions_, call_)));
 
   // Set the current codecs to be used for the new channel. We need to do this
   // after adding the channel to send_channels_, because of how max bitrate is
   // currently being configured by SetSendCodec().
-  if (!send_codecs_.empty() && !SetSendCodecs(channel, send_codecs_)) {
+  if (HasSendCodec() && !SetSendCodecs(channel)) {
     RemoveSendStream(ssrc);
     return false;
   }
 
   // At this point the channel's local SSRC has been updated. If the channel is
   // the first send channel make sure that all the receive channels are updated
   // with the same SSRC in order to send receiver reports.
   if (send_streams_.size() == 1) {
     receiver_reports_ssrc_ = ssrc;
     for (const auto& stream : recv_streams_) {
@@ skipping 76 matching lines @@
     voe_codec.pltype = -1;
     if (engine()->voe()->codec()->SetRecPayloadType(channel, voe_codec) == -1) {
       LOG_RTCERR2(SetRecPayloadType, channel, ToString(voe_codec));
       DeleteVoEChannel(channel);
       return false;
     }
   }
 
   // Only enable those configured for this channel.
   for (const auto& codec : recv_codecs_) {
-    webrtc::CodecInst voe_codec;
+    webrtc::CodecInst voe_codec = {0};
     if (WebRtcVoiceEngine::ToCodecInst(codec, &voe_codec)) {
       voe_codec.pltype = codec.id;
       if (engine()->voe()->codec()->SetRecPayloadType(
           channel, voe_codec) == -1) {
         LOG_RTCERR2(SetRecPayloadType, channel, ToString(voe_codec));
         DeleteVoEChannel(channel);
         return false;
       }
     }
   }
 
   const int send_channel = GetSendChannelId(receiver_reports_ssrc_);
   if (send_channel != -1) {
     // Associate receive channel with first send channel (so the receive channel
     // can obtain RTT from the send channel)
     engine()->voe()->base()->AssociateSendChannel(channel, send_channel);
     LOG(LS_INFO) << "VoiceEngine channel #" << channel
                  << " is associated with channel #" << send_channel << ".";
   }
 
-  transport_cc_enabled_ =
-      !send_codecs_.empty() ? HasTransportCc(send_codecs_[0]) : false;
-
   recv_streams_.insert(std::make_pair(
       ssrc, new WebRtcAudioReceiveStream(channel, ssrc, receiver_reports_ssrc_,
-                                         transport_cc_enabled_, sp.sync_label,
-                                         recv_rtp_extensions_, call_)));
+                                         recv_transport_cc_enabled_,
+                                         sp.sync_label, recv_rtp_extensions_,
+                                         call_)));
 
-  SetNack(channel, nack_enabled_);
+  SetNack(channel, send_codec_spec_.nack_enabled);
   SetPlayout(channel, playout_);
 
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::RemoveRecvStream(uint32_t ssrc) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   LOG(LS_INFO) << "RemoveRecvStream: " << ssrc;
 
   const auto it = recv_streams_.find(ssrc);
@@ skipping 283 matching lines @@
   LOG(LS_INFO) << "WebRtcVoiceMediaChannel::SetMaxSendBandwidth.";
   return SetSendBitrateInternal(bps);
 }
 
 bool WebRtcVoiceMediaChannel::SetSendBitrateInternal(int bps) {
   LOG(LS_INFO) << "WebRtcVoiceMediaChannel::SetSendBitrateInternal.";
 
   send_bitrate_setting_ = true;
   send_bitrate_bps_ = bps;
 
-  if (!send_codec_) {
+  if (!HasSendCodec()) {
     LOG(LS_INFO) << "The send codec has not been set up yet. "
                  << "The send bitrate setting will be applied later.";
     return true;
   }
 
   // Bitrate is auto by default.
   // TODO(bemasc): Fix this so that if SetMaxSendBandwidth(50) is followed by
   // SetMaxSendBandwith(0), the second call removes the previous limit.
   if (bps <= 0)
     return true;
 
-  webrtc::CodecInst codec = *send_codec_;
+  webrtc::CodecInst codec = send_codec_spec_.codec_inst;
   bool is_multi_rate = WebRtcVoiceCodecs::IsCodecMultiRate(codec);
 
   if (is_multi_rate) {
     // If codec is multi-rate then just set the bitrate.
     codec.rate = bps;
     for (const auto& ch : send_streams_) {
       if (!SetSendCodec(ch.second->channel(), codec)) {
         LOG(LS_INFO) << "Failed to set codec " << codec.plname
                      << " to bitrate " << bps << " bps.";
         return false;
@@ skipping 135 matching lines @@
     }
   } else {
     LOG(LS_INFO) << "Stopping playout for channel #" << channel;
     engine()->voe()->base()->StopPlayout(channel);
   }
   return true;
 }
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE