Add receive stream id argument to CreateDecoder() method

This is necessary to migrate some clients so that we can move forward
with removal of cricket::WebRtcVideoDecoderFactory.

TBR=stefan@webrtc.org

Bug: webrtc:7925
Change-Id: Icc2949e3f7f3137d1b68eb30874f14a33168e41f
Reviewed-on: https://webrtc-review.googlesource.com/97500
Commit-Queue: Magnus Jedvert <magjed@webrtc.org>
Reviewed-by: Anders Carlsson <andersc@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#24671}

api/video_codecs/BUILD.gn

@@ -21,6 +21,7 @@ rtc_source_set("video_codecs_api") {
     "video_codec.h",
     "video_decoder.cc",
     "video_decoder.h",
+    "video_decoder_factory.cc",
     "video_decoder_factory.h",
     "video_encoder.cc",
     "video_encoder.h",

api/video_codecs/video_decoder_factory.cc

@@ -0,0 +1,23 @@
+/*
+ *  Copyright (c) 2018 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 "api/video_codecs/video_decoder_factory.h"
+
+#include "api/video_codecs/video_decoder.h"
+
+namespace webrtc {
+
+std::unique_ptr<VideoDecoder> VideoDecoderFactory::LegacyCreateVideoDecoder(
+    const SdpVideoFormat& format,
+    const std::string& receive_stream_id) {
+  return CreateVideoDecoder(format);
+}
+
+}  // namespace webrtc

api/video_codecs/video_decoder_factory.h

@@ -12,6 +12,7 @@
 #define API_VIDEO_CODECS_VIDEO_DECODER_FACTORY_H_
 
 #include <memory>
+#include <string>
 #include <vector>
 
 namespace webrtc {
@@ -31,6 +32,12 @@ class VideoDecoderFactory {
   virtual std::unique_ptr<VideoDecoder> CreateVideoDecoder(
       const SdpVideoFormat& format) = 0;
 
+  // Note: Do not call or override this method! This method is a legacy
+  // workaround and is scheduled for removal without notice.
+  virtual std::unique_ptr<VideoDecoder> LegacyCreateVideoDecoder(
+      const SdpVideoFormat& format,
+      const std::string& receive_stream_id);
+
   virtual ~VideoDecoderFactory() {}
 };
 

media/engine/convert_legacy_video_factory.cc

@@ -10,6 +10,7 @@
 
 #include "media/engine/convert_legacy_video_factory.h"
 
+#include <string>
 #include <utility>
 #include <vector>
 
@@ -186,9 +187,15 @@ class CricketToWebRtcDecoderFactory : public webrtc::VideoDecoderFactory {
 
   std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
       const webrtc::SdpVideoFormat& format) override {
+    return LegacyCreateVideoDecoder(format, /* receive_stream_id= */ "");
+  }
+
+  std::unique_ptr<webrtc::VideoDecoder> LegacyCreateVideoDecoder(
+      const webrtc::SdpVideoFormat& format,
+      const std::string& receive_stream_id) override {
     if (external_decoder_factory_ != nullptr) {
       return CreateScopedVideoDecoder(external_decoder_factory_.get(),
-                                      VideoCodec(format), {});
+                                      VideoCodec(format), {receive_stream_id});
     }
     return nullptr;
   }
@@ -214,13 +221,14 @@ class DecoderAdapter : public webrtc::VideoDecoderFactory {
             absl::make_unique<CricketToWebRtcDecoderFactory>(
                 std::move(external_decoder_factory))) {}
 
-  explicit DecoderAdapter(
-      std::unique_ptr<webrtc::VideoDecoderFactory> external_decoder_factory)
-      : internal_decoder_factory_(new webrtc::InternalDecoderFactory()),
-        external_decoder_factory_(std::move(external_decoder_factory)) {}
-
   std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
       const webrtc::SdpVideoFormat& format) override {
+    return LegacyCreateVideoDecoder(format, /* receive_stream_id= */ "");
+  }
+
+  std::unique_ptr<webrtc::VideoDecoder> LegacyCreateVideoDecoder(
+      const webrtc::SdpVideoFormat& format,
+      const std::string& receive_stream_id) override {
     std::unique_ptr<webrtc::VideoDecoder> internal_decoder;
     if (IsFormatSupported(internal_decoder_factory_->GetSupportedFormats(),
                           format)) {
@@ -229,7 +237,8 @@ class DecoderAdapter : public webrtc::VideoDecoderFactory {
 
     std::unique_ptr<webrtc::VideoDecoder> external_decoder = nullptr;
     if (external_decoder_factory_ != nullptr) {
-      external_decoder = external_decoder_factory_->CreateVideoDecoder(format);
+      external_decoder = external_decoder_factory_->LegacyCreateVideoDecoder(
+          format, receive_stream_id);
     }
 
     if (internal_decoder && external_decoder) {
@@ -270,22 +279,10 @@ std::unique_ptr<webrtc::VideoEncoderFactory> ConvertVideoEncoderFactory(
       new EncoderAdapter(std::move(external_encoder_factory)));
 }
 
-std::unique_ptr<webrtc::VideoEncoderFactory> ConvertVideoEncoderFactory(
-    std::unique_ptr<webrtc::VideoEncoderFactory> external_encoder_factory) {
-  return std::unique_ptr<webrtc::VideoEncoderFactory>(
-      new EncoderAdapter(std::move(external_encoder_factory)));
-}
-
 std::unique_ptr<webrtc::VideoDecoderFactory> ConvertVideoDecoderFactory(
     std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory) {
   return std::unique_ptr<webrtc::VideoDecoderFactory>(
       new DecoderAdapter(std::move(external_decoder_factory)));
 }
 
-std::unique_ptr<webrtc::VideoDecoderFactory> ConvertVideoDecoderFactory(
-    std::unique_ptr<webrtc::VideoDecoderFactory> external_decoder_factory) {
-  return std::unique_ptr<webrtc::VideoDecoderFactory>(
-      new DecoderAdapter(std::move(external_decoder_factory)));
-}
-
 }  // namespace cricket

media/engine/convert_legacy_video_factory.h

@@ -30,15 +30,9 @@ class WebRtcVideoDecoderFactory;
 std::unique_ptr<webrtc::VideoEncoderFactory> ConvertVideoEncoderFactory(
     std::unique_ptr<WebRtcVideoEncoderFactory> external_encoder_factory);
 
-std::unique_ptr<webrtc::VideoEncoderFactory> ConvertVideoEncoderFactory(
-    std::unique_ptr<webrtc::VideoEncoderFactory> external_encoder_factory);
-
 std::unique_ptr<webrtc::VideoDecoderFactory> ConvertVideoDecoderFactory(
     std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory);
 
-std::unique_ptr<webrtc::VideoDecoderFactory> ConvertVideoDecoderFactory(
-    std::unique_ptr<webrtc::VideoDecoderFactory> external_decoder_factory);
-
 }  // namespace cricket
 
 #endif  // MEDIA_ENGINE_CONVERT_LEGACY_VIDEO_FACTORY_H_

media/engine/webrtcvideoengine.cc

@@ -41,89 +41,6 @@
 
 namespace cricket {
 
-// Hack in order to pass in |receive_stream_id| to legacy clients.
-// TODO(magjed): Remove once WebRtcVideoDecoderFactory is deprecated and
-// webrtc:7925 is fixed.
-class DecoderFactoryAdapter {
- public:
-#if defined(USE_BUILTIN_SW_CODECS)
-  explicit DecoderFactoryAdapter(
-      std::unique_ptr<WebRtcVideoDecoderFactory> external_video_decoder_factory)
-      : cricket_decoder_with_params_(new CricketDecoderWithParams(
-            std::move(external_video_decoder_factory))),
-        decoder_factory_(ConvertVideoDecoderFactory(
-            std::unique_ptr<WebRtcVideoDecoderFactory>(
-                cricket_decoder_with_params_))) {}
-#endif
-
-  explicit DecoderFactoryAdapter(
-      std::unique_ptr<webrtc::VideoDecoderFactory> video_decoder_factory)
-      : cricket_decoder_with_params_(nullptr),
-        decoder_factory_(std::move(video_decoder_factory)) {}
-
-  void SetReceiveStreamId(const std::string& receive_stream_id) {
-    if (cricket_decoder_with_params_)
-      cricket_decoder_with_params_->SetReceiveStreamId(receive_stream_id);
-  }
-
-  std::vector<webrtc::SdpVideoFormat> GetSupportedFormats() const {
-    return decoder_factory_->GetSupportedFormats();
-  }
-
-  std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
-      const webrtc::SdpVideoFormat& format) {
-    return decoder_factory_->CreateVideoDecoder(format);
-  }
-
- private:
-  // WebRtcVideoDecoderFactory implementation that allows to override
-  // |receive_stream_id|.
-  class CricketDecoderWithParams : public WebRtcVideoDecoderFactory {
-   public:
-    explicit CricketDecoderWithParams(
-        std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory)
-        : external_decoder_factory_(std::move(external_decoder_factory)) {}
-
-    void SetReceiveStreamId(const std::string& receive_stream_id) {
-      receive_stream_id_ = receive_stream_id;
-    }
-
-   private:
-    webrtc::VideoDecoder* CreateVideoDecoderWithParams(
-        const VideoCodec& codec,
-        VideoDecoderParams params) override {
-      if (!external_decoder_factory_)
-        return nullptr;
-      params.receive_stream_id = receive_stream_id_;
-      return external_decoder_factory_->CreateVideoDecoderWithParams(codec,
-                                                                     params);
-    }
-
-    webrtc::VideoDecoder* CreateVideoDecoderWithParams(
-        webrtc::VideoCodecType type,
-        VideoDecoderParams params) override {
-      RTC_NOTREACHED();
-      return nullptr;
-    }
-
-    void DestroyVideoDecoder(webrtc::VideoDecoder* decoder) override {
-      if (external_decoder_factory_) {
-        external_decoder_factory_->DestroyVideoDecoder(decoder);
-      } else {
-        delete decoder;
-      }
-    }
-
-    const std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory_;
-    std::string receive_stream_id_;
-  };
-
-  // If |cricket_decoder_with_params_| is non-null, it's owned by
-  // |decoder_factory_|.
-  CricketDecoderWithParams* const cricket_decoder_with_params_;
-  std::unique_ptr<webrtc::VideoDecoderFactory> decoder_factory_;
-};
-
 namespace {
 
 // Video decoder class to be used for unknown codecs. Doesn't support decoding
@@ -536,8 +453,8 @@ void DefaultUnsignalledSsrcHandler::SetDefaultSink(
 WebRtcVideoEngine::WebRtcVideoEngine(
     std::unique_ptr<WebRtcVideoEncoderFactory> external_video_encoder_factory,
     std::unique_ptr<WebRtcVideoDecoderFactory> external_video_decoder_factory)
-    : decoder_factory_(
+    : decoder_factory_(ConvertVideoDecoderFactory(
-          new DecoderFactoryAdapter(std::move(external_video_decoder_factory))),
+          std::move(external_video_decoder_factory))),
       encoder_factory_(ConvertVideoEncoderFactory(
           std::move(external_video_encoder_factory))) {
   RTC_LOG(LS_INFO) << "WebRtcVideoEngine::WebRtcVideoEngine()";
@@ -547,8 +464,7 @@ WebRtcVideoEngine::WebRtcVideoEngine(
 WebRtcVideoEngine::WebRtcVideoEngine(
     std::unique_ptr<webrtc::VideoEncoderFactory> video_encoder_factory,
     std::unique_ptr<webrtc::VideoDecoderFactory> video_decoder_factory)
-    : decoder_factory_(
+    : decoder_factory_(std::move(video_decoder_factory)),
-          new DecoderFactoryAdapter(std::move(video_decoder_factory))),
       encoder_factory_(std::move(video_encoder_factory)) {
   RTC_LOG(LS_INFO) << "WebRtcVideoEngine::WebRtcVideoEngine()";
 }
@@ -605,7 +521,7 @@ WebRtcVideoChannel::WebRtcVideoChannel(
     const MediaConfig& config,
     const VideoOptions& options,
     webrtc::VideoEncoderFactory* encoder_factory,
-    DecoderFactoryAdapter* decoder_factory)
+    webrtc::VideoDecoderFactory* decoder_factory)
     : VideoMediaChannel(config),
       call_(call),
       unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
@@ -2226,7 +2142,7 @@ WebRtcVideoChannel::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
     webrtc::Call* call,
     const StreamParams& sp,
     webrtc::VideoReceiveStream::Config config,
-    DecoderFactoryAdapter* decoder_factory,
+    webrtc::VideoDecoderFactory* decoder_factory,
     bool default_stream,
     const std::vector<VideoCodecSettings>& recv_codecs,
     const webrtc::FlexfecReceiveStream::Config& flexfec_config)
@@ -2314,9 +2230,10 @@ void WebRtcVideoChannel::WebRtcVideoReceiveStream::ConfigureCodecs(
     }
 
     if (!new_decoder && decoder_factory_) {
-      decoder_factory_->SetReceiveStreamId(stream_params_.id);
+      new_decoder = decoder_factory_->LegacyCreateVideoDecoder(
-      new_decoder = decoder_factory_->CreateVideoDecoder(webrtc::SdpVideoFormat(
+          webrtc::SdpVideoFormat(recv_codec.codec.name,
-          recv_codec.codec.name, recv_codec.codec.params));
+                                 recv_codec.codec.params),
+          stream_params_.id);
     }
 
     // If we still have no valid decoder, we have to create a "Null" decoder

media/engine/webrtcvideoengine.h

@@ -50,7 +50,6 @@ class Thread;
 
 namespace cricket {
 
-class DecoderFactoryAdapter;
 class WebRtcVideoChannel;
 
 class UnsignalledSsrcHandler {
@@ -107,7 +106,7 @@ class WebRtcVideoEngine {
   RtpCapabilities GetCapabilities() const;
 
  private:
-  const std::unique_ptr<DecoderFactoryAdapter> decoder_factory_;
+  const std::unique_ptr<webrtc::VideoDecoderFactory> decoder_factory_;
   const std::unique_ptr<webrtc::VideoEncoderFactory> encoder_factory_;
 };
 
@@ -117,7 +116,7 @@ class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport {
                      const MediaConfig& config,
                      const VideoOptions& options,
                      webrtc::VideoEncoderFactory* encoder_factory,
-                     DecoderFactoryAdapter* decoder_factory);
+                     webrtc::VideoDecoderFactory* decoder_factory);
   ~WebRtcVideoChannel() override;
 
   // VideoMediaChannel implementation
@@ -350,7 +349,7 @@ class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport {
         webrtc::Call* call,
         const StreamParams& sp,
         webrtc::VideoReceiveStream::Config config,
-        DecoderFactoryAdapter* decoder_factory,
+        webrtc::VideoDecoderFactory* decoder_factory,
         bool default_stream,
         const std::vector<VideoCodecSettings>& recv_codecs,
         const webrtc::FlexfecReceiveStream::Config& flexfec_config);
@@ -415,7 +414,7 @@ class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport {
     webrtc::FlexfecReceiveStream::Config flexfec_config_;
     webrtc::FlexfecReceiveStream* flexfec_stream_;
 
-    DecoderFactoryAdapter* decoder_factory_;
+    webrtc::VideoDecoderFactory* decoder_factory_;
     DecoderMap allocated_decoders_;
 
     rtc::CriticalSection sink_lock_;
@@ -480,7 +479,7 @@ class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport {
   absl::optional<std::vector<webrtc::RtpExtension>> send_rtp_extensions_;
 
   webrtc::VideoEncoderFactory* const encoder_factory_;
-  DecoderFactoryAdapter* const decoder_factory_;
+  webrtc::VideoDecoderFactory* const decoder_factory_;
   std::vector<VideoCodecSettings> recv_codecs_;
   std::vector<webrtc::RtpExtension> recv_rtp_extensions_;
   // See reason for keeping track of the FlexFEC payload type separately in