WebRtcVideoEngine: Encapsulate logic for unifying internal and external video codecs

webrtc/media/engine/webrtcvideoengine.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.
  */
 
@@ skipping 24 matching lines @@
 #include "webrtc/rtc_base/copyonwritebuffer.h"
 #include "webrtc/rtc_base/logging.h"
 #include "webrtc/rtc_base/stringutils.h"
 #include "webrtc/rtc_base/timeutils.h"
 #include "webrtc/rtc_base/trace_event.h"
 #include "webrtc/system_wrappers/include/field_trial.h"
 
 using DegradationPreference = webrtc::VideoSendStream::DegradationPreference;
 
 namespace cricket {
+// This class represents all encoders, i.e. both internal and external. It
+// serves as a temporary adapter between WebRtcVideoEncoderFactory* and the new
+// factory interface that is being developed.
+// TODO(magjed): Remove once WebRtcVideoEncoderFactory* is deprecated and
+// webrtc:7925 is fixed.
+class EncoderFactoryAdapter {
+ public:
+  struct AllocatedEncoder {
+    AllocatedEncoder() = default;
+    AllocatedEncoder(std::unique_ptr<webrtc::VideoEncoder> encoder,
+                     bool is_external,
+                     bool has_internal_source);
+
+    std::unique_ptr<webrtc::VideoEncoder> encoder;
+    bool is_external;

[andersc, 2017/08/29 14:48:54]

Not sure if this is a good point to start changing the terminology, but should
this eventually be `is_hardware` instead?

[magjed_webrtc, 2017/08/30 08:41:52]

Exactly, probably best to change it now.

+    bool has_internal_source;
+  };
+
+  virtual ~EncoderFactoryAdapter() {}
+
+  virtual AllocatedEncoder CreateVideoEncoder(
+      const VideoCodec& codec,
+      bool is_conference_mode_screenshare) const = 0;
+
+  virtual std::vector<VideoCodec> GetSupportedCodecs() const = 0;
+
+  virtual std::unique_ptr<EncoderFactoryAdapter> clone() const = 0;
+};
+
 namespace {
+
+// Wraps cricket::WebRtcVideoEncoderFactory* into common EncoderFactoryAdapter
+// interface.
+// TODO(magjed): Add wrapper class for future webrtc::VideoEncoderFactory
+// interface, https://bugs.chromium.org/p/webrtc/issues/detail?id=7925.
+class CricketEncoderFactoryAdapter : public EncoderFactoryAdapter {
+ public:
+  explicit CricketEncoderFactoryAdapter(
+      WebRtcVideoEncoderFactory* external_encoder_factory)
+      : internal_encoder_factory_(new InternalEncoderFactory()),
+        external_encoder_factory_(external_encoder_factory) {}
+
+ private:
+  explicit CricketEncoderFactoryAdapter(
+      const CricketEncoderFactoryAdapter& other)
+      : CricketEncoderFactoryAdapter(other.external_encoder_factory_) {}
+
+  AllocatedEncoder CreateVideoEncoder(
+      const VideoCodec& codec,
+      bool is_conference_mode_screenshare) const override;
+
+  std::vector<VideoCodec> GetSupportedCodecs() const override;
+
+  std::unique_ptr<EncoderFactoryAdapter> clone() const override {
+    return std::unique_ptr<EncoderFactoryAdapter>(
+        new CricketEncoderFactoryAdapter(*this));
+  }
+
+  const std::unique_ptr<WebRtcVideoEncoderFactory> internal_encoder_factory_;
+  WebRtcVideoEncoderFactory* const external_encoder_factory_;
+};
+
 // If this field trial is enabled, we will enable sending FlexFEC and disable
 // sending ULPFEC whenever the former has been negotiated in the SDPs.
 bool IsFlexfecFieldTrialEnabled() {
   return webrtc::field_trial::IsEnabled("WebRTC-FlexFEC-03");
 }
 
 // If this field trial is enabled, the "flexfec-03" codec may have been
 // advertised as being supported in the local SDP. That means that we must be
 // ready to receive FlexFEC packets. See internalencoderfactory.cc.
 bool IsFlexfecAdvertisedFieldTrialEnabled() {
@@ skipping 143 matching lines @@
 
 // This constant is really an on/off, lower-level configurable NACK history
 // duration hasn't been implemented.
 static const int kNackHistoryMs = 1000;
 
 static const int kDefaultRtcpReceiverReportSsrc = 1;
 
 // Minimum time interval for logging stats.
 static const int64_t kStatsLogIntervalMs = 10000;
 
-static std::vector<VideoCodec> GetSupportedCodecs(
-    const WebRtcVideoEncoderFactory* external_encoder_factory);
-
 rtc::scoped_refptr<webrtc::VideoEncoderConfig::EncoderSpecificSettings>
 WebRtcVideoChannel::WebRtcVideoSendStream::ConfigureVideoEncoderSettings(
     const VideoCodec& codec) {
   RTC_DCHECK_RUN_ON(&thread_checker_);
   bool is_screencast = parameters_.options.is_screencast.value_or(false);
   // No automatic resizing when using simulcast or screencast.
   bool automatic_resize =
       !is_screencast && parameters_.config.rtp.ssrcs.size() == 1;
   bool frame_dropping = !is_screencast;
   bool denoising;
@@ skipping 81 matching lines @@
   rtc::Optional<uint32_t> default_recv_ssrc =
       channel->GetDefaultReceiveStreamSsrc();
   if (default_recv_ssrc) {
     channel->SetSink(*default_recv_ssrc, default_sink_);
   }
 }
 
 WebRtcVideoEngine::WebRtcVideoEngine()
     : initialized_(false),
       external_decoder_factory_(NULL),
-      external_encoder_factory_(NULL) {
+      encoder_factory_(new CricketEncoderFactoryAdapter(
+          nullptr /* external_encoder_factory */)) {
   LOG(LS_INFO) << "WebRtcVideoEngine::WebRtcVideoEngine()";
 }
 
 WebRtcVideoEngine::~WebRtcVideoEngine() {
   LOG(LS_INFO) << "WebRtcVideoEngine::~WebRtcVideoEngine";
 }
 
 void WebRtcVideoEngine::Init() {
   LOG(LS_INFO) << "WebRtcVideoEngine::Init";
   initialized_ = true;
 }
 
 WebRtcVideoChannel* WebRtcVideoEngine::CreateChannel(
     webrtc::Call* call,
     const MediaConfig& config,
     const VideoOptions& options) {
   RTC_DCHECK(initialized_);
   LOG(LS_INFO) << "CreateChannel. Options: " << options.ToString();
-  return new WebRtcVideoChannel(call, config, options,
-                                external_encoder_factory_,
+  return new WebRtcVideoChannel(call, config, options, *encoder_factory_,
                                 external_decoder_factory_);
 }
 
 std::vector<VideoCodec> WebRtcVideoEngine::codecs() const {
-  return GetSupportedCodecs(external_encoder_factory_);
+  return encoder_factory_->GetSupportedCodecs();
 }
 
 RtpCapabilities WebRtcVideoEngine::GetCapabilities() const {
   RtpCapabilities capabilities;
   capabilities.header_extensions.push_back(
       webrtc::RtpExtension(webrtc::RtpExtension::kTimestampOffsetUri,
                            webrtc::RtpExtension::kTimestampOffsetDefaultId));
   capabilities.header_extensions.push_back(
       webrtc::RtpExtension(webrtc::RtpExtension::kAbsSendTimeUri,
                            webrtc::RtpExtension::kAbsSendTimeDefaultId));
@@ skipping 17 matching lines @@
 
 void WebRtcVideoEngine::SetExternalDecoderFactory(
     WebRtcVideoDecoderFactory* decoder_factory) {
   RTC_DCHECK(!initialized_);
   external_decoder_factory_ = decoder_factory;
 }
 
 void WebRtcVideoEngine::SetExternalEncoderFactory(
     WebRtcVideoEncoderFactory* encoder_factory) {
   RTC_DCHECK(!initialized_);
-  external_encoder_factory_ = encoder_factory;
+  encoder_factory_.reset(new CricketEncoderFactoryAdapter(encoder_factory));
 }
 
 // This is a helper function for AppendVideoCodecs below. It will return the
 // first unused dynamic payload type (in the range [96, 127]), or nothing if no
 // payload type is unused.
 static rtc::Optional<int> NextFreePayloadType(
     const std::vector<VideoCodec>& codecs) {
   static const int kFirstDynamicPayloadType = 96;
   static const int kLastDynamicPayloadType = 127;
   bool is_payload_used[1 + kLastDynamicPayloadType - kFirstDynamicPayloadType] =
@@ skipping 45 matching lines @@
       const rtc::Optional<int> rtx_payload_type =
           NextFreePayloadType(*unified_codecs);
       if (!rtx_payload_type)
         return;
       unified_codecs->push_back(
           VideoCodec::CreateRtxCodec(*rtx_payload_type, codec.id));
     }
   }
 }
 
-static std::vector<VideoCodec> GetSupportedCodecs(
-    const WebRtcVideoEncoderFactory* external_encoder_factory) {
+std::vector<VideoCodec> CricketEncoderFactoryAdapter::GetSupportedCodecs()
+    const {
   const std::vector<VideoCodec> internal_codecs =
       InternalEncoderFactory().supported_codecs();
   LOG(LS_INFO) << "Internally supported codecs: "
                << CodecVectorToString(internal_codecs);
 
   std::vector<VideoCodec> unified_codecs;
   AppendVideoCodecs(internal_codecs, &unified_codecs);
 
-  if (external_encoder_factory != nullptr) {
+  if (external_encoder_factory_ != nullptr) {
     const std::vector<VideoCodec>& external_codecs =
-        external_encoder_factory->supported_codecs();
+        external_encoder_factory_->supported_codecs();
     AppendVideoCodecs(external_codecs, &unified_codecs);
     LOG(LS_INFO) << "Codecs supported by the external encoder factory: "
                  << CodecVectorToString(external_codecs);
   }
 
   return unified_codecs;
 }
 
 WebRtcVideoChannel::WebRtcVideoChannel(
     webrtc::Call* call,
     const MediaConfig& config,
     const VideoOptions& options,
-    WebRtcVideoEncoderFactory* external_encoder_factory,
+    const EncoderFactoryAdapter& encoder_factory,
     WebRtcVideoDecoderFactory* external_decoder_factory)
     : VideoMediaChannel(config),
       call_(call),
       unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
       video_config_(config.video),
-      external_encoder_factory_(external_encoder_factory),
+      encoder_factory_(encoder_factory.clone()),
       external_decoder_factory_(external_decoder_factory),
       default_send_options_(options),
       last_stats_log_ms_(-1) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
 
   rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc;
   sending_ = false;
-  recv_codecs_ = MapCodecs(GetSupportedCodecs(external_encoder_factory));
+  recv_codecs_ = MapCodecs(encoder_factory_->GetSupportedCodecs());
   recv_flexfec_payload_type_ = recv_codecs_.front().flexfec_payload_type;
 }
 
 WebRtcVideoChannel::~WebRtcVideoChannel() {
   for (auto& kv : send_streams_)
     delete kv.second;
   for (auto& kv : receive_streams_)
     delete kv.second;
 }
 
 rtc::Optional<WebRtcVideoChannel::VideoCodecSettings>
 WebRtcVideoChannel::SelectSendVideoCodec(
     const std::vector<VideoCodecSettings>& remote_mapped_codecs) const {
   const std::vector<VideoCodec> local_supported_codecs =
-      GetSupportedCodecs(external_encoder_factory_);
+      encoder_factory_->GetSupportedCodecs();
   // Select the first remote codec that is supported locally.
   for (const VideoCodecSettings& remote_mapped_codec : remote_mapped_codecs) {
     // For H264, we will limit the encode level to the remote offered level
     // regardless if level asymmetry is allowed or not. This is strictly not
     // following the spec in https://tools.ietf.org/html/rfc6184#section-8.2.2
     // since we should limit the encode level to the lower of local and remote
     // level when level asymmetry is not allowed.
     if (FindMatchingCodec(local_supported_codecs, remote_mapped_codec.codec))
       return rtc::Optional<VideoCodecSettings>(remote_mapped_codec);
   }
@@ skipping 291 matching lines @@
   // Handle receive codecs.
   const std::vector<VideoCodecSettings> mapped_codecs =
       MapCodecs(params.codecs);
   if (mapped_codecs.empty()) {
     LOG(LS_ERROR) << "SetRecvParameters called without any video codecs.";
     return false;
   }
 
   // Verify that every mapped codec is supported locally.
   const std::vector<VideoCodec> local_supported_codecs =
-      GetSupportedCodecs(external_encoder_factory_);
+      encoder_factory_->GetSupportedCodecs();
   for (const VideoCodecSettings& mapped_codec : mapped_codecs) {
     if (!FindMatchingCodec(local_supported_codecs, mapped_codec.codec)) {
       LOG(LS_ERROR) << "SetRecvParameters called with unsupported video codec: "
                     << mapped_codec.codec.ToString();
       return false;
     }
   }
 
   if (NonFlexfecReceiveCodecsHaveChanged(recv_codecs_, mapped_codecs)) {
     changed_params->codec_settings =
@@ skipping 150 matching lines @@
     return false;
 
   for (uint32_t used_ssrc : sp.ssrcs)
     send_ssrcs_.insert(used_ssrc);
 
   webrtc::VideoSendStream::Config config(this);
   config.suspend_below_min_bitrate = video_config_.suspend_below_min_bitrate;
   config.periodic_alr_bandwidth_probing =
       video_config_.periodic_alr_bandwidth_probing;
   WebRtcVideoSendStream* stream = new WebRtcVideoSendStream(
-      call_, sp, std::move(config), default_send_options_,
-      external_encoder_factory_, video_config_.enable_cpu_overuse_detection,
+      call_, sp, std::move(config), default_send_options_, *encoder_factory_,
+      video_config_.enable_cpu_overuse_detection,
       bitrate_config_.max_bitrate_bps, send_codec_, send_rtp_extensions_,
       send_params_);
 
   uint32_t ssrc = sp.first_ssrc();
   RTC_DCHECK(ssrc != 0);
   send_streams_[ssrc] = stream;
 
   if (rtcp_receiver_report_ssrc_ == kDefaultRtcpReceiverReportSsrc) {
     rtcp_receiver_report_ssrc_ = ssrc;
     LOG(LS_INFO) << "SetLocalSsrc on all the receive streams because we added "
@@ skipping 415 matching lines @@
         webrtc::VideoSendStream::Config config,
         const VideoOptions& options,
         int max_bitrate_bps,
         const rtc::Optional<VideoCodecSettings>& codec_settings)
     : config(std::move(config)),
       options(options),
       max_bitrate_bps(max_bitrate_bps),
       conference_mode(false),
       codec_settings(codec_settings) {}
 
-WebRtcVideoChannel::WebRtcVideoSendStream::AllocatedEncoder::AllocatedEncoder(
+EncoderFactoryAdapter::AllocatedEncoder::AllocatedEncoder(
     std::unique_ptr<webrtc::VideoEncoder> encoder,
     bool is_external,
-    const cricket::VideoCodec& codec,
     bool has_internal_source)
-    : encoder_(std::move(encoder)),
-      is_external_(is_external),
-      codec_(codec),
-      has_internal_source_(has_internal_source) {}
-
-void WebRtcVideoChannel::WebRtcVideoSendStream::AllocatedEncoder::Reset() {
-  encoder_.reset();
-  codec_ = cricket::VideoCodec();
-}
+    : encoder(std::move(encoder)),
+      is_external(is_external),
+      has_internal_source(has_internal_source) {}
 
 WebRtcVideoChannel::WebRtcVideoSendStream::WebRtcVideoSendStream(
     webrtc::Call* call,
     const StreamParams& sp,
     webrtc::VideoSendStream::Config config,
     const VideoOptions& options,
-    WebRtcVideoEncoderFactory* external_encoder_factory,
+    const EncoderFactoryAdapter& encoder_factory,
     bool enable_cpu_overuse_detection,
     int max_bitrate_bps,
     const rtc::Optional<VideoCodecSettings>& codec_settings,
     const rtc::Optional<std::vector<webrtc::RtpExtension>>& rtp_extensions,
     // TODO(deadbeef): Don't duplicate information between send_params,
     // rtp_extensions, options, etc.
     const VideoSendParameters& send_params)
     : worker_thread_(rtc::Thread::Current()),
       ssrcs_(sp.ssrcs),
       ssrc_groups_(sp.ssrc_groups),
       call_(call),
       enable_cpu_overuse_detection_(enable_cpu_overuse_detection),
       source_(nullptr),
-      external_encoder_factory_(external_encoder_factory),
-      internal_encoder_factory_(new InternalEncoderFactory()),
+      encoder_factory_(encoder_factory.clone()),
       stream_(nullptr),
       encoder_sink_(nullptr),
       parameters_(std::move(config), options, max_bitrate_bps, codec_settings),
       rtp_parameters_(CreateRtpParametersWithOneEncoding()),
       sending_(false) {
   parameters_.config.rtp.max_packet_size = kVideoMtu;
   parameters_.conference_mode = send_params.conference_mode;
 
   sp.GetPrimarySsrcs(&parameters_.config.rtp.ssrcs);
 
@@ skipping 41 matching lines @@
     bool force_encoder_allocation = false;
     SetCodec(*codec_settings, force_encoder_allocation);
   }
 }
 
 WebRtcVideoChannel::WebRtcVideoSendStream::~WebRtcVideoSendStream() {
   if (stream_ != NULL) {
     call_->DestroyVideoSendStream(stream_);
   }
   // Release |allocated_encoder_|.
-  allocated_encoder_.Reset();
+  allocated_encoder_.reset();
 }
 
 bool WebRtcVideoChannel::WebRtcVideoSendStream::SetVideoSend(
     bool enable,
     const VideoOptions* options,
     rtc::VideoSourceInterface<webrtc::VideoFrame>* source) {
   TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::SetVideoSend");
   RTC_DCHECK_RUN_ON(&thread_checker_);
 
   // Ignore |options| pointer if |enable| is false.
@@ skipping 50 matching lines @@
     }
   }
   return degradation_preference;
 }
 
 const std::vector<uint32_t>&
 WebRtcVideoChannel::WebRtcVideoSendStream::GetSsrcs() const {
   return ssrcs_;
 }
 
-WebRtcVideoChannel::WebRtcVideoSendStream::AllocatedEncoder
-WebRtcVideoChannel::WebRtcVideoSendStream::CreateVideoEncoder(
-    const VideoCodec& codec) {
-  RTC_DCHECK_RUN_ON(&thread_checker_);
-
+EncoderFactoryAdapter::AllocatedEncoder
+CricketEncoderFactoryAdapter::CreateVideoEncoder(
+    const VideoCodec& codec,
+    bool is_conference_mode_screenshare) const {
   // Try creating external encoder.
   if (external_encoder_factory_ != nullptr &&
       FindMatchingCodec(external_encoder_factory_->supported_codecs(), codec)) {
     std::unique_ptr<webrtc::VideoEncoder> external_encoder;
     if (CodecNamesEq(codec.name.c_str(), kVp8CodecName)) {
       // If it's a codec type we can simulcast, create a wrapped encoder.
       external_encoder = std::unique_ptr<webrtc::VideoEncoder>(
           new webrtc::SimulcastEncoderAdapter(external_encoder_factory_));
     } else {
       external_encoder =
           CreateScopedVideoEncoder(external_encoder_factory_, codec);
     }
     if (external_encoder) {
       std::unique_ptr<webrtc::VideoEncoder> internal_encoder(
           new webrtc::VideoEncoderSoftwareFallbackWrapper(
               codec, std::move(external_encoder)));
       const webrtc::VideoCodecType codec_type =
           webrtc::PayloadStringToCodecType(codec.name);
       const bool has_internal_source =
           external_encoder_factory_->EncoderTypeHasInternalSource(codec_type);
       return AllocatedEncoder(std::move(internal_encoder),
-                              true /* is_external */, codec,
-                              has_internal_source);
+                              true /* is_external */, has_internal_source);
     }
   }
 
   // Try creating internal encoder.
   std::unique_ptr<webrtc::VideoEncoder> internal_encoder;
   if (FindMatchingCodec(internal_encoder_factory_->supported_codecs(), codec)) {
     if (CodecNamesEq(codec.name.c_str(), kVp8CodecName) &&
-        parameters_.encoder_config.content_type ==
-            webrtc::VideoEncoderConfig::ContentType::kScreen &&
-        parameters_.conference_mode && UseSimulcastScreenshare()) {
+        is_conference_mode_screenshare && UseSimulcastScreenshare()) {
       // TODO(sprang): Remove this adapter once libvpx supports simulcast with
       // same-resolution substreams.
       internal_encoder = std::unique_ptr<webrtc::VideoEncoder>(
           new webrtc::SimulcastEncoderAdapter(internal_encoder_factory_.get()));
     } else {
       internal_encoder = std::unique_ptr<webrtc::VideoEncoder>(
           internal_encoder_factory_->CreateVideoEncoder(codec));
     }
     return AllocatedEncoder(std::move(internal_encoder),
-                            false /* is_external */, codec,
+                            false /* is_external */,
                             false /* has_internal_source */);
   }
 
   // This shouldn't happen, we should not be trying to create something we don't
   // support.
   RTC_NOTREACHED();
   return AllocatedEncoder();
 }
 
 void WebRtcVideoChannel::WebRtcVideoSendStream::SetCodec(
     const VideoCodecSettings& codec_settings,
     bool force_encoder_allocation) {
   RTC_DCHECK_RUN_ON(&thread_checker_);
   parameters_.encoder_config = CreateVideoEncoderConfig(codec_settings.codec);
   RTC_DCHECK_GT(parameters_.encoder_config.number_of_streams, 0);
 
   // Do not re-create encoders of the same type. We can't overwrite
   // |allocated_encoder_| immediately, because we need to release it after the
   // RecreateWebRtcStream() call.
-  AllocatedEncoder new_encoder;
-  if (force_encoder_allocation || !allocated_encoder_.encoder() ||
-      allocated_encoder_.codec() != codec_settings.codec) {
-    new_encoder = CreateVideoEncoder(codec_settings.codec);
+  std::unique_ptr<webrtc::VideoEncoder> new_encoder;
+  if (force_encoder_allocation || !allocated_encoder_ ||
+      allocated_codec_ != codec_settings.codec) {
+    const bool is_conference_mode_screenshare =
+        parameters_.encoder_config.content_type ==
+            webrtc::VideoEncoderConfig::ContentType::kScreen &&
+        parameters_.conference_mode;
+    EncoderFactoryAdapter::AllocatedEncoder new_allocated_encoder =
+        encoder_factory_->CreateVideoEncoder(codec_settings.codec,
+                                             is_conference_mode_screenshare);
+    new_encoder = std::unique_ptr<webrtc::VideoEncoder>(
+        std::move(new_allocated_encoder.encoder));
+    parameters_.config.encoder_settings.encoder = new_encoder.get();
+    parameters_.config.encoder_settings.full_overuse_time =
+        new_allocated_encoder.is_external;
+    parameters_.config.encoder_settings.internal_source =
+        new_allocated_encoder.has_internal_source;
   } else {
     new_encoder = std::move(allocated_encoder_);
   }
-  parameters_.config.encoder_settings.encoder = new_encoder.encoder();
-  parameters_.config.encoder_settings.full_overuse_time =
-      new_encoder.IsExternal();
   parameters_.config.encoder_settings.payload_name = codec_settings.codec.name;
   parameters_.config.encoder_settings.payload_type = codec_settings.codec.id;
-  parameters_.config.encoder_settings.internal_source =
-      new_encoder.HasInternalSource();
   parameters_.config.rtp.ulpfec = codec_settings.ulpfec;
   parameters_.config.rtp.flexfec.payload_type =
       codec_settings.flexfec_payload_type;
 
   // Set RTX payload type if RTX is enabled.
   if (!parameters_.config.rtp.rtx.ssrcs.empty()) {
     if (codec_settings.rtx_payload_type == -1) {
       LOG(LS_WARNING) << "RTX SSRCs configured but there's no configured RTX "
                          "payload type. Ignoring.";
       parameters_.config.rtp.rtx.ssrcs.clear();
     } else {
       parameters_.config.rtp.rtx.payload_type = codec_settings.rtx_payload_type;
     }
   }
 
   parameters_.config.rtp.nack.rtp_history_ms =
       HasNack(codec_settings.codec) ? kNackHistoryMs : 0;
 
   parameters_.codec_settings =
       rtc::Optional<WebRtcVideoChannel::VideoCodecSettings>(codec_settings);
 
   LOG(LS_INFO) << "RecreateWebRtcStream (send) because of SetCodec.";
   RecreateWebRtcStream();
   allocated_encoder_ = std::move(new_encoder);
+  allocated_codec_ = codec_settings.codec;
 }
 
 void WebRtcVideoChannel::WebRtcVideoSendStream::SetSendParameters(
     const ChangedSendParameters& params) {
   RTC_DCHECK_RUN_ON(&thread_checker_);
   // |recreate_stream| means construction-time parameters have changed and the
   // sending stream needs to be reset with the new config.
   bool recreate_stream = false;
   if (params.rtcp_mode) {
     parameters_.config.rtp.rtcp_mode = *params.rtcp_mode;
@@ skipping 873 matching lines @@
     stream.temporal_layer_thresholds_bps.resize(GetDefaultVp9TemporalLayers() -
                                                 1);
   }
 
   std::vector<webrtc::VideoStream> streams;
   streams.push_back(stream);
   return streams;
 }
 
 }  // namespace cricket