[EXPERIMENTAL] Generic stereo codec with index header sending single frames

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.
  */
 
 #include "media/engine/webrtcvideoengine.h"
 
 #include <stdio.h>
 #include <algorithm>
 #include <set>
 #include <string>
 #include <utility>
 
 #include "api/video/i420_buffer.h"
 #include "api/video_codecs/sdp_video_format.h"
 #include "api/video_codecs/video_decoder.h"
 #include "api/video_codecs/video_decoder_factory.h"
 #include "api/video_codecs/video_encoder.h"
 #include "api/video_codecs/video_encoder_factory.h"
 #include "call/call.h"
 #include "common_video/h264/profile_level_id.h"
+#include "media/base/codec.h"
 #include "media/engine/constants.h"
 #include "media/engine/internaldecoderfactory.h"
 #include "media/engine/internalencoderfactory.h"
 #include "media/engine/scopedvideodecoder.h"
 #include "media/engine/scopedvideoencoder.h"
 #include "media/engine/simulcast.h"
 #include "media/engine/simulcast_encoder_adapter.h"
 #include "media/engine/videodecodersoftwarefallbackwrapper.h"
 #include "media/engine/videoencodersoftwarefallbackwrapper.h"
 #include "media/engine/webrtcmediaengine.h"
 #include "media/engine/webrtcvideoencoderfactory.h"
 #include "media/engine/webrtcvoiceengine.h"
+#include "modules/video_coding/codecs/stereo/include/stereo_decoder_adapter.h"
+#include "modules/video_coding/codecs/stereo/include/stereo_encoder_adapter.h"
 #include "rtc_base/copyonwritebuffer.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/stringutils.h"
 #include "rtc_base/timeutils.h"
 #include "rtc_base/trace_event.h"
 #include "system_wrappers/include/field_trial.h"
 
 using DegradationPreference = webrtc::VideoSendStream::DegradationPreference;
 
 namespace cricket {
@@ skipping 12 matching lines @@
 
     std::unique_ptr<webrtc::VideoEncoder> encoder;
     bool is_hardware_accelerated;
     bool has_internal_source;
   };
 
   virtual ~EncoderFactoryAdapter() {}
 
   virtual AllocatedEncoder CreateVideoEncoder(
       const VideoCodec& codec,
-      bool is_conference_mode_screenshare) const = 0;
+      bool is_conference_mode_screenshare,
+      bool is_stereo_codec) const = 0;
 
   virtual std::vector<VideoCodec> GetSupportedCodecs() const = 0;
 };
 
 class DecoderFactoryAdapter {
  public:
   virtual ~DecoderFactoryAdapter() {}
 
   virtual std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
       const VideoCodec& codec,
-      const VideoDecoderParams& decoder_params) const = 0;
+      const VideoDecoderParams& decoder_params,
+      bool is_stereo_codec) const = 0;
 };
 
 namespace {
 
 std::vector<VideoCodec> AssignPayloadTypesAndAddAssociatedRtxCodecs(
     const std::vector<VideoCodec>& input_codecs);
 
 // Wraps cricket::WebRtcVideoEncoderFactory* into common EncoderFactoryAdapter
 // interface.
 // TODO(magjed): Remove once WebRtcVideoEncoderFactory* is deprecated and
 // webrtc:7925 is fixed.
 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;
+      bool is_conference_mode_screenshare,
+      bool is_stereo_codec) const override;
 
   std::vector<VideoCodec> GetSupportedCodecs() const override;
 
   const std::unique_ptr<WebRtcVideoEncoderFactory> internal_encoder_factory_;
   WebRtcVideoEncoderFactory* const external_encoder_factory_;
+  std::unique_ptr<WebRtcVideoEncoderFactory> stereo_encoder_factory_;
 };
 
 class CricketDecoderFactoryAdapter : public DecoderFactoryAdapter {
  public:
   explicit CricketDecoderFactoryAdapter(
       WebRtcVideoDecoderFactory* external_decoder_factory)
       : internal_decoder_factory_(new InternalDecoderFactory()),
         external_decoder_factory_(external_decoder_factory) {}
 
  private:
   explicit CricketDecoderFactoryAdapter(
       const CricketDecoderFactoryAdapter& other)
       : CricketDecoderFactoryAdapter(other.external_decoder_factory_) {}
 
   std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
       const VideoCodec& codec,
-      const VideoDecoderParams& decoder_params) const override;
+      const VideoDecoderParams& decoder_params,
+      bool is_stereo_codec) const override;
 
   const std::unique_ptr<WebRtcVideoDecoderFactory> internal_decoder_factory_;
   WebRtcVideoDecoderFactory* const external_decoder_factory_;
+  std::unique_ptr<WebRtcVideoDecoderFactory> stereo_decoder_factory_;
 };
 
 // Wraps webrtc::VideoEncoderFactory into common EncoderFactoryAdapter
 // interface.
 class WebRtcEncoderFactoryAdapter : public EncoderFactoryAdapter {
  public:
   explicit WebRtcEncoderFactoryAdapter(
       std::unique_ptr<webrtc::VideoEncoderFactory> encoder_factory)
       : encoder_factory_(std::move(encoder_factory)) {}
 
  private:
   AllocatedEncoder CreateVideoEncoder(
       const VideoCodec& codec,
-      bool is_conference_mode_screenshare) const override {
+      bool is_conference_mode_screenshare,
+      bool is_stereo_codec) const override {
     if (!encoder_factory_)
       return AllocatedEncoder();
     const webrtc::SdpVideoFormat format(codec.name, codec.params);
     const webrtc::VideoEncoderFactory::CodecInfo info =
         encoder_factory_->QueryVideoEncoder(format);
     return AllocatedEncoder(encoder_factory_->CreateVideoEncoder(format),
                             info.is_hardware_accelerated,
                             info.has_internal_source);
   }
 
@@ skipping 18 matching lines @@
 // interface.
 class WebRtcDecoderFactoryAdapter : public DecoderFactoryAdapter {
  public:
   explicit WebRtcDecoderFactoryAdapter(
       std::unique_ptr<webrtc::VideoDecoderFactory> decoder_factory)
       : decoder_factory_(std::move(decoder_factory)) {}
 
  private:
   std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
       const VideoCodec& codec,
-      const VideoDecoderParams& decoder_params) const override {
+      const VideoDecoderParams& decoder_params,
+      bool is_stereo_codec) const override {
     return decoder_factory_
                ? decoder_factory_->CreateVideoDecoder(
                      webrtc::SdpVideoFormat(codec.name, codec.params))
                : nullptr;
   }
 
   std::unique_ptr<webrtc::VideoDecoderFactory> decoder_factory_;
 };
 
 // If this field trial is enabled, we will enable sending FlexFEC and disable
@@ skipping 352 matching lines @@
         CodecNamesEq(codec.name, kH264CodecName) ||
         CodecNamesEq(codec.name, kRedCodecName)) {
       output_codecs.push_back(
           VideoCodec::CreateRtxCodec(payload_type, codec.id));
 
       // Increment payload type.
       ++payload_type;
       if (payload_type > kLastDynamicPayloadType)
         break;
     }
+
+    if (CodecNamesEq(codec.name, kVp9CodecName)) {
+      output_codecs.push_back(
+          VideoCodec::CreateStereoCodec(payload_type, codec));
+      ++payload_type;
+      if (payload_type > kLastDynamicPayloadType)
+        break;
+    }
   }
   return output_codecs;
 }
 }  // namespace
 
 std::vector<VideoCodec> CricketEncoderFactoryAdapter::GetSupportedCodecs()
     const {
   std::vector<VideoCodec> codecs = InternalEncoderFactory().supported_codecs();
   LOG(LS_INFO) << "Internally supported codecs: "
                << CodecVectorToString(codecs);
 
   // Add external codecs.
   if (external_encoder_factory_ != nullptr) {
     const std::vector<VideoCodec>& external_codecs =
         external_encoder_factory_->supported_codecs();
     for (const VideoCodec& codec : external_codecs) {
       // Don't add same codec twice.
       if (!FindMatchingCodec(codecs, codec))
         codecs.push_back(codec);
     }
     LOG(LS_INFO) << "Codecs supported by the external encoder factory: "
                  << CodecVectorToString(external_codecs);
   }
 
   return AssignPayloadTypesAndAddAssociatedRtxCodecs(codecs);
 }
 
-WebRtcVideoChannel::WebRtcVideoChannel(
-    webrtc::Call* call,
-    const MediaConfig& config,
-    const VideoOptions& options,
-    const EncoderFactoryAdapter* encoder_factory,
-    const DecoderFactoryAdapter* decoder_factory)
+WebRtcVideoChannel::WebRtcVideoChannel(webrtc::Call* call,
+                                       const MediaConfig& config,
+                                       const VideoOptions& options,
+                                       EncoderFactoryAdapter* encoder_factory,
+                                       DecoderFactoryAdapter* decoder_factory)
     : VideoMediaChannel(config),
       call_(call),
       unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
       video_config_(config.video),
       encoder_factory_(encoder_factory),
       decoder_factory_(decoder_factory),
       default_send_options_(options),
       last_stats_log_ms_(-1) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 10 matching lines @@
     delete kv.second;
 }
 
 rtc::Optional<WebRtcVideoChannel::VideoCodecSettings>
 WebRtcVideoChannel::SelectSendVideoCodec(
     const std::vector<VideoCodecSettings>& remote_mapped_codecs) const {
   const std::vector<VideoCodec> local_supported_codecs =
       encoder_factory_->GetSupportedCodecs();
   // Select the first remote codec that is supported locally.
   for (const VideoCodecSettings& remote_mapped_codec : remote_mapped_codecs) {
+    // HARDCODE TO ALPHA
+    if (!cricket::VideoCodec::IsStereoCodec(remote_mapped_codec.codec))
+      continue;
     // 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);
   }
   // No remote codec was supported.
   return rtc::Optional<VideoCodecSettings>();
 }
 
+rtc::Optional<WebRtcVideoChannel::VideoCodecSettings>
+WebRtcVideoChannel::SelectStereoAssociatedVideoCodec(
+    const std::vector<VideoCodecSettings>& remote_mapped_codecs) const {
+  const std::vector<VideoCodec> local_supported_codecs =
+      encoder_factory_->GetSupportedCodecs();
+
+  // Select the first remote codec that is supported locally.
+  for (const VideoCodecSettings& remote_mapped_codec : remote_mapped_codecs) {
+    // HARDCODE TO VP9
+    if (!CodecNamesEq(remote_mapped_codec.codec.name.c_str(), kVp9CodecName))
+      continue;
+    if (!cricket::VideoCodec::IsStereoCodec(remote_mapped_codec.codec) &&
+        FindMatchingCodec(local_supported_codecs, remote_mapped_codec.codec))
+      return rtc::Optional<VideoCodecSettings>(remote_mapped_codec);
+  }
+  return rtc::Optional<VideoCodecSettings>();
+}
+
 bool WebRtcVideoChannel::NonFlexfecReceiveCodecsHaveChanged(
     std::vector<VideoCodecSettings> before,
     std::vector<VideoCodecSettings> after) {
   if (before.size() != after.size()) {
     return true;
   }
 
   // The receive codec order doesn't matter, so we sort the codecs before
   // comparing. This is necessary because currently the
   // only way to change the send codec is to munge SDP, which causes
@@ skipping 26 matching lines @@
 
   // Select one of the remote codecs that will be used as send codec.
   rtc::Optional<VideoCodecSettings> selected_send_codec =
       SelectSendVideoCodec(MapCodecs(params.codecs));
 
   if (!selected_send_codec) {
     LOG(LS_ERROR) << "No video codecs supported.";
     return false;
   }
 
+  if (VideoCodec::IsStereoCodec(selected_send_codec->codec)) {
+    rtc::Optional<VideoCodecSettings> associated_codec_settings =
+        SelectStereoAssociatedVideoCodec(MapCodecs(params.codecs));
+    LOG(LS_ERROR) << __func__ << associated_codec_settings->codec.ToString();
+    if (!associated_codec_settings) {
+      LOG(LS_ERROR)
+          << "Stereo codec is not associated with any supported codec.";
+      return false;
+    }
+    associated_codec_settings->stereo_codec.emplace(selected_send_codec->codec);
+    selected_send_codec = associated_codec_settings;
+  }
+
   // Never enable sending FlexFEC, unless we are in the experiment.
   if (!IsFlexfecFieldTrialEnabled()) {
     if (selected_send_codec->flexfec_payload_type != -1) {
       LOG(LS_INFO) << "Remote supports flexfec-03, but we will not send since "
                    << "WebRTC-FlexFEC-03 field trial is not enabled.";
     }
     selected_send_codec->flexfec_payload_type = -1;
   }
 
   if (!send_codec_ || *selected_send_codec != *send_codec_)
@@ skipping 852 matching lines @@
     bool has_internal_source)
     : encoder(std::move(encoder)),
       is_hardware_accelerated(is_hardware_accelerated),
       has_internal_source(has_internal_source) {}
 
 WebRtcVideoChannel::WebRtcVideoSendStream::WebRtcVideoSendStream(
     webrtc::Call* call,
     const StreamParams& sp,
     webrtc::VideoSendStream::Config config,
     const VideoOptions& options,
-    const EncoderFactoryAdapter* encoder_factory,
+    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),
@@ skipping 129 matching lines @@
 }
 
 const std::vector<uint32_t>&
 WebRtcVideoChannel::WebRtcVideoSendStream::GetSsrcs() const {
   return ssrcs_;
 }
 
 EncoderFactoryAdapter::AllocatedEncoder
 CricketEncoderFactoryAdapter::CreateVideoEncoder(
     const VideoCodec& codec,
-    bool is_conference_mode_screenshare) const {
+    bool is_conference_mode_screenshare,
+    bool is_stereo_codec) const {
+  if (is_stereo_codec) {
+    if (external_encoder_factory_ != nullptr &&
+        FindMatchingCodec(external_encoder_factory_->supported_codecs(),
+                          codec)) {
+      std::unique_ptr<webrtc::VideoEncoder> stereo_encoder(
+          new webrtc::StereoEncoderAdapter(external_encoder_factory_));
+      return AllocatedEncoder(std::move(stereo_encoder),
+                              true /* is_hardware_accelerated */,
+                              false /* is_external */);
+    }
+    if (FindMatchingCodec(internal_encoder_factory_->supported_codecs(),
+                          codec)) {
+      std::unique_ptr<webrtc::VideoEncoder> stereo_encoder(
+          new webrtc::StereoEncoderAdapter(internal_encoder_factory_.get()));
+      return AllocatedEncoder(std::move(stereo_encoder),
+                              false /* is_hardware_accelerated */,
+                              false /* is_external */);
+    }
+    RTC_NOTREACHED();
+    return AllocatedEncoder();
+  }
+
   // 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 =
@@ skipping 37 matching lines @@
   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);
 
+  const bool is_stereo_codec = codec_settings.stereo_codec.has_value();
+
   // 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.
   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);
+                                             is_conference_mode_screenshare,
+                                             is_stereo_codec);
     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_hardware_accelerated;
     parameters_.config.encoder_settings.internal_source =
         new_allocated_encoder.has_internal_source;
   } else {
     new_encoder = std::move(allocated_encoder_);
   }
-  parameters_.config.encoder_settings.payload_name = codec_settings.codec.name;
-  parameters_.config.encoder_settings.payload_type = codec_settings.codec.id;
+  VideoCodec payload_codec = is_stereo_codec
+                                 ? codec_settings.stereo_codec.value()
+                                 : codec_settings.codec;
+  parameters_.config.encoder_settings.payload_name = payload_codec.name;
+  parameters_.config.encoder_settings.payload_type = payload_codec.id;
+  parameters_.config.encoder_settings.stereo_associated_payload_name =
+      codec_settings.codec.name;
   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();
@@ skipping 222 matching lines @@
   }
 }
 
 VideoSenderInfo WebRtcVideoChannel::WebRtcVideoSendStream::GetVideoSenderInfo(
     bool log_stats) {
   VideoSenderInfo info;
   RTC_DCHECK_RUN_ON(&thread_checker_);
   for (uint32_t ssrc : parameters_.config.rtp.ssrcs)
     info.add_ssrc(ssrc);
 
+  // TODO(emircan): Add stereo codec case.
   if (parameters_.codec_settings) {
     info.codec_name = parameters_.codec_settings->codec.name;
     info.codec_payload_type = rtc::Optional<int>(
         parameters_.codec_settings->codec.id);
   }
 
   if (stream_ == NULL)
     return info;
 
   webrtc::VideoSendStream::Stats stats = stream_->GetStats();
@@ skipping 106 matching lines @@
   }
 
   // Call stream_->Start() if necessary conditions are met.
   UpdateSendState();
 }
 
 WebRtcVideoChannel::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
     webrtc::Call* call,
     const StreamParams& sp,
     webrtc::VideoReceiveStream::Config config,
-    const DecoderFactoryAdapter* decoder_factory,
+    DecoderFactoryAdapter* decoder_factory,
     bool default_stream,
     const std::vector<VideoCodecSettings>& recv_codecs,
     const webrtc::FlexfecReceiveStream::Config& flexfec_config)
     : call_(call),
       stream_params_(sp),
       stream_(NULL),
       default_stream_(default_stream),
       config_(std::move(config)),
       flexfec_config_(flexfec_config),
       flexfec_stream_(nullptr),
@@ skipping 33 matching lines @@
     LOG(LS_WARNING) << "Empty primary ssrcs vector, returning empty optional";
     return rtc::Optional<uint32_t>();
   } else {
     return rtc::Optional<uint32_t>(primary_ssrcs[0]);
   }
 }
 
 std::unique_ptr<webrtc::VideoDecoder>
 CricketDecoderFactoryAdapter::CreateVideoDecoder(
     const VideoCodec& codec,
-    const VideoDecoderParams& decoder_params) const {
+    const VideoDecoderParams& decoder_params,
+    bool is_stereo_codec) const {
+  if (is_stereo_codec) {
+    if (external_decoder_factory_ != nullptr) {
+      std::unique_ptr<webrtc::VideoDecoder> external_decoder(
+          new webrtc::StereoDecoderAdapter(external_decoder_factory_));
+      return external_decoder;
+    }
+    std::unique_ptr<webrtc::VideoDecoder> internal_decoder(
+        new webrtc::StereoDecoderAdapter(internal_decoder_factory_.get()));
+    return internal_decoder;
+  }
+
   if (external_decoder_factory_ != nullptr) {
     std::unique_ptr<webrtc::VideoDecoder> external_decoder =
         CreateScopedVideoDecoder(external_decoder_factory_, codec,
                                  decoder_params);
     if (external_decoder) {
       webrtc::VideoCodecType type =
           webrtc::PayloadStringToCodecType(codec.name);
       std::unique_ptr<webrtc::VideoDecoder> internal_decoder(
           new webrtc::VideoDecoderSoftwareFallbackWrapper(
               type, std::move(external_decoder)));
       return internal_decoder;
     }
   }
 
   std::unique_ptr<webrtc::VideoDecoder> internal_decoder(
       internal_decoder_factory_->CreateVideoDecoderWithParams(codec,
                                                               decoder_params));
   return internal_decoder;
 }
 
 void WebRtcVideoChannel::WebRtcVideoReceiveStream::ConfigureCodecs(
     const std::vector<VideoCodecSettings>& recv_codecs,
     DecoderMap* old_decoders) {
   *old_decoders = std::move(allocated_decoders_);
   config_.decoders.clear();
   config_.rtp.rtx_associated_payload_types.clear();
   for (const auto& recv_codec : recv_codecs) {
+    const bool is_stereo_codec =
+        cricket::VideoCodec::IsStereoCodec(recv_codec.codec);
     webrtc::SdpVideoFormat video_format(recv_codec.codec.name,
                                         recv_codec.codec.params);
     std::unique_ptr<webrtc::VideoDecoder> new_decoder;
 
     auto it = old_decoders->find(video_format);
-    if (it != old_decoders->end()) {
+    if (it != old_decoders->end() && !is_stereo_codec) {
       new_decoder = std::move(it->second);
       old_decoders->erase(it);
     }
 
     if (!new_decoder) {
-      new_decoder = decoder_factory_->CreateVideoDecoder(recv_codec.codec,
-                                                         {stream_params_.id});
+      new_decoder = decoder_factory_->CreateVideoDecoder(
+          recv_codec.codec, {stream_params_.id}, is_stereo_codec);
     }
 
     webrtc::VideoReceiveStream::Decoder decoder;
     decoder.decoder = new_decoder.get();
     decoder.payload_type = recv_codec.codec.id;
     decoder.payload_name = recv_codec.codec.name;
     decoder.codec_params = recv_codec.codec.params;
     config_.decoders.push_back(decoder);
     config_.rtp.rtx_associated_payload_types[recv_codec.rtx_payload_type] =
         recv_codec.codec.id;
@@ skipping 423 matching lines @@
     stream.temporal_layer_thresholds_bps.resize(GetDefaultVp9TemporalLayers() -
                                                 1);
   }
 
   std::vector<webrtc::VideoStream> streams;
   streams.push_back(stream);
   return streams;
 }
 
 }  // namespace cricket