Replace VideoEncoderFactory::QueryVideoEncoder with VideoEncoder::GetEncoderInfo

Make implementation of VideoEncoderFactory::QueryVideoEncoder optional
until it is removed downstream and remove all implementations of it.

Bug: webrtc:10065
Change-Id: Ibb1f9612234e536651ce53f05ee048a5d172a41f
Reviewed-on: https://webrtc-review.googlesource.com/c/113065
Commit-Queue: Mirta Dvornicic <mirtad@webrtc.org>
Reviewed-by: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Per Kjellander <perkj@webrtc.org>
Reviewed-by: Rasmus Brandt <brandtr@webrtc.org>
Reviewed-by: Sami Kalliomäki <sakal@webrtc.org>
Reviewed-by: Kári Helgason <kthelgason@webrtc.org>
Reviewed-by: Erik Språng <sprang@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#25924}

api/test/mock_video_encoder_factory.h

@@ -24,8 +24,6 @@ class MockVideoEncoderFactory : public webrtc::VideoEncoderFactory {
  public:
   MOCK_CONST_METHOD0(GetSupportedFormats,
                      std::vector<webrtc::SdpVideoFormat>());
-  MOCK_CONST_METHOD1(QueryVideoEncoder,
-                     CodecInfo(const webrtc::SdpVideoFormat&));
 
   // We need to proxy to a return type that is copyable.
   std::unique_ptr<webrtc::VideoEncoder> CreateVideoEncoder(

api/test/video/function_video_encoder_factory.h

@@ -41,14 +41,6 @@ class FunctionVideoEncoderFactory final : public VideoEncoderFactory {
     return {};
   }
 
-  CodecInfo QueryVideoEncoder(
-      const SdpVideoFormat& /* format */) const override {
-    CodecInfo codec_info;
-    codec_info.is_hardware_accelerated = false;
-    codec_info.has_internal_source = false;
-    return codec_info;
-  }
-
   std::unique_ptr<VideoEncoder> CreateVideoEncoder(
       const SdpVideoFormat& format) override {
     return create_(format);

api/video_codecs/BUILD.gn

@@ -27,6 +27,7 @@ rtc_source_set("video_codecs_api") {
     "video_encoder.h",
     "video_encoder_config.cc",
     "video_encoder_config.h",
+    "video_encoder_factory.cc",
     "video_encoder_factory.h",
     "vp8_temporal_layers.h",
   ]

api/video_codecs/builtin_video_encoder_factory.cc

@@ -44,17 +44,6 @@ class BuiltinVideoEncoderFactory : public VideoEncoderFactory {
   BuiltinVideoEncoderFactory()
       : internal_encoder_factory_(new InternalEncoderFactory()) {}
 
-  VideoEncoderFactory::CodecInfo QueryVideoEncoder(
-      const SdpVideoFormat& format) const override {
-    // Format must be one of the internal formats.
-    RTC_DCHECK(IsFormatSupported(
-        internal_encoder_factory_->GetSupportedFormats(), format));
-    VideoEncoderFactory::CodecInfo info;
-    info.has_internal_source = false;
-    info.is_hardware_accelerated = false;
-    return info;
-  }
-
   std::unique_ptr<VideoEncoder> CreateVideoEncoder(
       const SdpVideoFormat& format) override {
     // Try creating internal encoder.

api/video_codecs/video_encoder_factory.cc

@@ -0,0 +1,26 @@
+/*
+ *  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_encoder_factory.h"
+
+// TODO(webrtc:10065) Remove once downstream projects have been updated.
+namespace webrtc {
+
+VideoEncoderFactory::CodecInfo::CodecInfo()
+    : is_hardware_accelerated(false), has_internal_source(false) {}
+
+VideoEncoderFactory::CodecInfo::~CodecInfo() = default;
+
+VideoEncoderFactory::CodecInfo VideoEncoderFactory::QueryVideoEncoder(
+    const SdpVideoFormat& format) const {
+  return CodecInfo();
+}
+
+}  // namespace webrtc

api/video_codecs/video_encoder_factory.h

@@ -25,6 +25,9 @@ class VideoEncoderFactory {
  public:
   // TODO(magjed): Try to get rid of this struct.
   struct CodecInfo {
+    CodecInfo();
+    ~CodecInfo();
+
     // |is_hardware_accelerated| is true if the encoders created by this factory
     // of the given codec will use hardware support.
     bool is_hardware_accelerated;
@@ -43,7 +46,7 @@ class VideoEncoderFactory {
   // Returns information about how this format will be encoded. The specified
   // format must be one of the supported formats by this factory.
   // TODO(magjed): Try to get rid of this method.
-  virtual CodecInfo QueryVideoEncoder(const SdpVideoFormat& format) const = 0;
+  virtual CodecInfo QueryVideoEncoder(const SdpVideoFormat& format) const;
 
   // Creates a VideoEncoder for the specified format.
   virtual std::unique_ptr<VideoEncoder> CreateVideoEncoder(

media/engine/convert_legacy_video_factory.cc

@@ -60,21 +60,6 @@ class CricketToWebRtcEncoderFactory : public webrtc::VideoEncoderFactory {
       std::unique_ptr<WebRtcVideoEncoderFactory> external_encoder_factory)
       : external_encoder_factory_(std::move(external_encoder_factory)) {}
 
-  webrtc::VideoEncoderFactory::CodecInfo QueryVideoEncoder(
-      const webrtc::SdpVideoFormat& format) const override {
-    CodecInfo info;
-    info.has_internal_source = false;
-    info.is_hardware_accelerated = false;
-    if (!external_encoder_factory_)
-      return info;
-
-    info.has_internal_source =
-        external_encoder_factory_->EncoderTypeHasInternalSource(
-            webrtc::PayloadStringToCodecType(format.name));
-    info.is_hardware_accelerated = true;
-    return info;
-  }
-
   std::vector<webrtc::SdpVideoFormat> GetSupportedFormats() const override {
     if (!external_encoder_factory_)
       return std::vector<webrtc::SdpVideoFormat>();
@@ -113,22 +98,6 @@ class EncoderAdapter : public webrtc::VideoEncoderFactory {
       : internal_encoder_factory_(new webrtc::InternalEncoderFactory()),
         external_encoder_factory_(std::move(external_encoder_factory)) {}
 
-  webrtc::VideoEncoderFactory::CodecInfo QueryVideoEncoder(
-      const webrtc::SdpVideoFormat& format) const override {
-    if (IsFormatSupported(external_encoder_factory_->GetSupportedFormats(),
-                          format)) {
-      return external_encoder_factory_->QueryVideoEncoder(format);
-    }
-
-    // Format must be one of the internal formats.
-    RTC_DCHECK(IsFormatSupported(
-        internal_encoder_factory_->GetSupportedFormats(), format));
-    webrtc::VideoEncoderFactory::CodecInfo info;
-    info.has_internal_source = false;
-    info.is_hardware_accelerated = false;
-    return info;
-  }
-
   std::unique_ptr<webrtc::VideoEncoder> CreateVideoEncoder(
       const webrtc::SdpVideoFormat& format) override {
     // Try creating internal encoder.

media/engine/fakewebrtcvideoengine.cc

@@ -187,10 +187,17 @@ int FakeWebRtcVideoEncoder::GetNumEncodedFrames() {
   return num_frames_encoded_;
 }
 
+webrtc::VideoEncoder::EncoderInfo FakeWebRtcVideoEncoder::GetEncoderInfo()
+    const {
+  EncoderInfo info;
+  info.is_hardware_accelerated = true;
+  info.has_internal_source = false;
+  return info;
+}
+
 // Video encoder factory.
 FakeWebRtcVideoEncoderFactory::FakeWebRtcVideoEncoderFactory()
     : num_created_encoders_(0),
-      encoders_have_internal_sources_(false),
       vp8_factory_mode_(false) {}
 
 std::vector<webrtc::SdpVideoFormat>
@@ -230,15 +237,6 @@ FakeWebRtcVideoEncoderFactory::CreateVideoEncoder(
   return encoder;
 }
 
-webrtc::VideoEncoderFactory::CodecInfo
-FakeWebRtcVideoEncoderFactory::QueryVideoEncoder(
-    const webrtc::SdpVideoFormat& format) const {
-  webrtc::VideoEncoderFactory::CodecInfo info;
-  info.has_internal_source = encoders_have_internal_sources_;
-  info.is_hardware_accelerated = true;
-  return info;
-}
-
 bool FakeWebRtcVideoEncoderFactory::WaitForCreatedVideoEncoders(
     int num_encoders) {
   int64_t start_offset_ms = rtc::TimeMillis();
@@ -258,11 +256,6 @@ void FakeWebRtcVideoEncoderFactory::EncoderDestroyed(
                   encoders_.end());
 }
 
-void FakeWebRtcVideoEncoderFactory::set_encoders_have_internal_sources(
-    bool internal_source) {
-  encoders_have_internal_sources_ = internal_source;
-}
-
 void FakeWebRtcVideoEncoderFactory::AddSupportedVideoCodec(
     const webrtc::SdpVideoFormat& format) {
   formats_.push_back(format);

media/engine/fakewebrtcvideoengine.h

@@ -96,6 +96,7 @@ class FakeWebRtcVideoEncoder : public webrtc::VideoEncoder {
   int32_t Release() override;
   int32_t SetRateAllocation(const webrtc::VideoBitrateAllocation& allocation,
                             uint32_t framerate) override;
+  webrtc::VideoEncoder::EncoderInfo GetEncoderInfo() const override;
 
   bool WaitForInitEncode();
   webrtc::VideoCodec GetCodecSettings();
@@ -117,8 +118,6 @@ class FakeWebRtcVideoEncoderFactory : public webrtc::VideoEncoderFactory {
   std::vector<webrtc::SdpVideoFormat> GetSupportedFormats() const override;
   std::unique_ptr<webrtc::VideoEncoder> CreateVideoEncoder(
       const webrtc::SdpVideoFormat& format) override;
-  CodecInfo QueryVideoEncoder(
-      const webrtc::SdpVideoFormat& format) const override;
 
   bool WaitForCreatedVideoEncoders(int num_encoders);
   void EncoderDestroyed(FakeWebRtcVideoEncoder* encoder);

media/engine/internalencoderfactory.cc

@@ -34,14 +34,6 @@ std::vector<SdpVideoFormat> InternalEncoderFactory::GetSupportedFormats()
   return supported_codecs;
 }
 
-VideoEncoderFactory::CodecInfo InternalEncoderFactory::QueryVideoEncoder(
-    const SdpVideoFormat& format) const {
-  CodecInfo info;
-  info.is_hardware_accelerated = false;
-  info.has_internal_source = false;
-  return info;
-}
-
 std::unique_ptr<VideoEncoder> InternalEncoderFactory::CreateVideoEncoder(
     const SdpVideoFormat& format) {
   if (absl::EqualsIgnoreCase(format.name, cricket::kVp8CodecName))

media/engine/internalencoderfactory.h

@@ -24,8 +24,6 @@ class InternalEncoderFactory : public VideoEncoderFactory {
  public:
   std::vector<SdpVideoFormat> GetSupportedFormats() const override;
 
-  CodecInfo QueryVideoEncoder(const SdpVideoFormat& format) const override;
-
   std::unique_ptr<VideoEncoder> CreateVideoEncoder(
       const SdpVideoFormat& format) override;
 };

media/engine/multiplexcodecfactory.cc

@@ -57,14 +57,6 @@ std::vector<SdpVideoFormat> MultiplexEncoderFactory::GetSupportedFormats()
   return formats;
 }
 
-VideoEncoderFactory::CodecInfo MultiplexEncoderFactory::QueryVideoEncoder(
-    const SdpVideoFormat& format) const {
-  if (!IsMultiplexCodec(cricket::VideoCodec(format)))
-    return factory_->QueryVideoEncoder(format);
-  return factory_->QueryVideoEncoder(
-      SdpVideoFormat(kMultiplexAssociatedCodecName));
-}
-
 std::unique_ptr<VideoEncoder> MultiplexEncoderFactory::CreateVideoEncoder(
     const SdpVideoFormat& format) {
   if (!IsMultiplexCodec(cricket::VideoCodec(format)))

media/engine/multiplexcodecfactory.h

@@ -49,7 +49,6 @@ class RTC_EXPORT MultiplexEncoderFactory : public VideoEncoderFactory {
                           bool supports_augmenting_data = false);
 
   std::vector<SdpVideoFormat> GetSupportedFormats() const override;
-  CodecInfo QueryVideoEncoder(const SdpVideoFormat& format) const override;
   std::unique_ptr<VideoEncoder> CreateVideoEncoder(
       const SdpVideoFormat& format) override;
 

media/engine/simulcast_encoder_adapter_unittest.cc

@@ -159,8 +159,6 @@ class MockVideoEncoderFactory : public VideoEncoderFactory {
   std::unique_ptr<VideoEncoder> CreateVideoEncoder(
       const SdpVideoFormat& format) override;
 
-  CodecInfo QueryVideoEncoder(const SdpVideoFormat& format) const override;
-
   const std::vector<MockVideoEncoder*>& encoders() const;
   void SetEncoderNames(const std::vector<const char*>& encoder_names);
   void set_init_encode_return_value(int32_t value);
@@ -310,11 +308,6 @@ void MockVideoEncoderFactory::DestroyVideoEncoder(VideoEncoder* encoder) {
   }
 }
 
-VideoEncoderFactory::CodecInfo MockVideoEncoderFactory::QueryVideoEncoder(
-    const SdpVideoFormat& format) const {
-  return CodecInfo();
-}
-
 const std::vector<MockVideoEncoder*>& MockVideoEncoderFactory::encoders()
     const {
   return encoders_;

media/engine/webrtcvideoengine_unittest.cc

@@ -1090,12 +1090,7 @@ TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, Vp8) {
   VerifyCodecHasDefaultFeedbackParams(engine_codecs.at(0));
 
   // Mock encoder creation. |engine| take ownership of the encoder.
-  webrtc::VideoEncoderFactory::CodecInfo codec_info;
-  codec_info.is_hardware_accelerated = false;
-  codec_info.has_internal_source = false;
   const webrtc::SdpVideoFormat format("VP8");
-  EXPECT_CALL(*encoder_factory, QueryVideoEncoder(format))
-      .WillRepeatedly(testing::Return(codec_info));
   FakeWebRtcVideoEncoder* const encoder = new FakeWebRtcVideoEncoder(nullptr);
   rtc::Event encoder_created;
   EXPECT_CALL(*encoder_factory, CreateVideoEncoderProxy(format))

sdk/android/src/jni/videoencoderfactorywrapper.cc

@@ -50,20 +50,5 @@ std::vector<SdpVideoFormat> VideoEncoderFactoryWrapper::GetSupportedFormats()
   return supported_formats_;
 }
 
-VideoEncoderFactory::CodecInfo VideoEncoderFactoryWrapper::QueryVideoEncoder(
-    const SdpVideoFormat& format) const {
-  JNIEnv* jni = AttachCurrentThreadIfNeeded();
-  ScopedJavaLocalRef<jobject> j_codec_info =
-      SdpVideoFormatToVideoCodecInfo(jni, format);
-  ScopedJavaLocalRef<jobject> encoder = Java_VideoEncoderFactory_createEncoder(
-      jni, encoder_factory_, j_codec_info);
-
-  CodecInfo codec_info;
-  // Check if this is a wrapped native software encoder implementation.
-  codec_info.is_hardware_accelerated = IsHardwareVideoEncoder(jni, encoder);
-  codec_info.has_internal_source = false;
-  return codec_info;
-}
-
 }  // namespace jni
 }  // namespace webrtc

sdk/android/src/jni/videoencoderfactorywrapper.h

@@ -35,8 +35,6 @@ class VideoEncoderFactoryWrapper : public VideoEncoderFactory {
   // Returns a list of supported codecs in order of preference.
   std::vector<SdpVideoFormat> GetSupportedFormats() const override;
 
-  CodecInfo QueryVideoEncoder(const SdpVideoFormat& format) const override;
-
  private:
   const ScopedJavaGlobalRef<jobject> encoder_factory_;
   std::vector<SdpVideoFormat> supported_formats_;

sdk/objc/native/src/objc_video_encoder_factory.h

@@ -29,7 +29,6 @@ class ObjCVideoEncoderFactory : public VideoEncoderFactory {
   std::vector<SdpVideoFormat> GetSupportedFormats() const override;
   std::unique_ptr<VideoEncoder> CreateVideoEncoder(
       const SdpVideoFormat& format) override;
-  CodecInfo QueryVideoEncoder(const SdpVideoFormat& format) const override;
 
  private:
   id<RTCVideoEncoderFactory> encoder_factory_;

sdk/objc/native/src/objc_video_encoder_factory.mm

@@ -129,19 +129,6 @@ std::vector<SdpVideoFormat> ObjCVideoEncoderFactory::GetSupportedFormats() const
   return supported_formats;
 }
 
-VideoEncoderFactory::CodecInfo ObjCVideoEncoderFactory::QueryVideoEncoder(
-    const SdpVideoFormat &format) const {
-  // TODO(andersc): This is a hack until we figure out how this should be done properly.
-  NSString *formatName = [NSString stringForStdString:format.name];
-  NSSet *wrappedSoftwareFormats =
-      [NSSet setWithObjects:kRTCVideoCodecVp8Name, kRTCVideoCodecVp9Name, nil];
-
-  CodecInfo codec_info;
-  codec_info.is_hardware_accelerated = ![wrappedSoftwareFormats containsObject:formatName];
-  codec_info.has_internal_source = false;
-  return codec_info;
-}
-
 std::unique_ptr<VideoEncoder> ObjCVideoEncoderFactory::CreateVideoEncoder(
     const SdpVideoFormat &format) {
   RTCVideoCodecInfo *info = [[RTCVideoCodecInfo alloc] initWithNativeSdpVideoFormat:format];

test/fake_encoder.cc

@@ -54,6 +54,8 @@ FakeEncoder::FakeEncoder(Clock* clock)
       max_target_bitrate_kbps_(-1),
       pending_keyframe_(true),
       counter_(0),
+      is_hardware_accelerated_(false),
+      has_internal_source_(false),
       debt_bytes_(0) {
   // Generate some arbitrary not-all-zero data
   for (size_t i = 0; i < sizeof(encoded_buffer_); ++i) {
@@ -267,9 +269,19 @@ const char* FakeEncoder::kImplementationName = "fake_encoder";
 VideoEncoder::EncoderInfo FakeEncoder::GetEncoderInfo() const {
   EncoderInfo info;
   info.implementation_name = kImplementationName;
+  info.is_hardware_accelerated = is_hardware_accelerated_;
+  info.has_internal_source = has_internal_source_;
   return info;
 }
 
+void FakeEncoder::SetIsHardwareAccelerated(bool is_hardware_accelerated) {
+  is_hardware_accelerated_ = is_hardware_accelerated;
+}
+
+void FakeEncoder::SetHasInternalSource(bool has_internal_source) {
+  has_internal_source_ = has_internal_source;
+}
+
 int FakeEncoder::GetConfiguredInputFramerate() const {
   rtc::CritScope cs(&crit_sect_);
   return configured_input_framerate_;

test/fake_encoder.h

@@ -55,6 +55,9 @@ class FakeEncoder : public VideoEncoder {
   int GetConfiguredInputFramerate() const;
   EncoderInfo GetEncoderInfo() const override;
 
+  void SetIsHardwareAccelerated(bool is_hardware_accelerated);
+  void SetHasInternalSource(bool has_internal_source);
+
   static const char* kImplementationName;
 
  protected:
@@ -91,6 +94,9 @@ class FakeEncoder : public VideoEncoder {
   uint32_t counter_ RTC_GUARDED_BY(crit_sect_);
   rtc::CriticalSection crit_sect_;
 
+  bool is_hardware_accelerated_;
+  bool has_internal_source_;
+
   uint8_t encoded_buffer_[100000];
   bool used_layers_[kMaxSimulcastStreams];
 

test/video_encoder_proxy_factory.h

@@ -26,10 +26,8 @@ namespace test {
 // a proxy for the same encoder, typically an instance of FakeEncoder.
 class VideoEncoderProxyFactory final : public VideoEncoderFactory {
  public:
-  explicit VideoEncoderProxyFactory(VideoEncoder* encoder) : encoder_(encoder) {
-    codec_info_.is_hardware_accelerated = false;
-    codec_info_.has_internal_source = false;
-  }
+  explicit VideoEncoderProxyFactory(VideoEncoder* encoder)
+      : encoder_(encoder) {}
 
   // Unused by tests.
   std::vector<SdpVideoFormat> GetSupportedFormats() const override {
@@ -37,22 +35,11 @@ class VideoEncoderProxyFactory final : public VideoEncoderFactory {
     return {};
   }
 
-  CodecInfo QueryVideoEncoder(const SdpVideoFormat& format) const override {
-    return codec_info_;
-  }
-
   std::unique_ptr<VideoEncoder> CreateVideoEncoder(
       const SdpVideoFormat& format) override {
     return absl::make_unique<EncoderProxy>(encoder_);
   }
 
-  void SetIsHardwareAccelerated(bool is_hardware_accelerated) {
-    codec_info_.is_hardware_accelerated = is_hardware_accelerated;
-  }
-  void SetHasInternalSource(bool has_internal_source) {
-    codec_info_.has_internal_source = has_internal_source;
-  }
-
  private:
   // Wrapper class, since CreateVideoEncoder needs to surrender
   // ownership to the object it returns.
@@ -88,7 +75,6 @@ class VideoEncoderProxyFactory final : public VideoEncoderFactory {
   };
 
   VideoEncoder* const encoder_;
-  CodecInfo codec_info_;
 };
 
 }  // namespace test

video/video_send_stream_tests.cc

@@ -2043,10 +2043,10 @@ TEST_P(VideoSendStreamTest, CanReconfigureToUseStartBitrateAbovePreviousMax) {
       bitrate_config);
 
   StartBitrateObserver encoder;
-  test::VideoEncoderProxyFactory encoder_factory(&encoder);
   // Since this test does not use a capturer, set |internal_source| = true.
   // Encoder configuration is otherwise updated on the next video frame.
-  encoder_factory.SetHasInternalSource(true);
+  encoder.SetHasInternalSource(true);
+  test::VideoEncoderProxyFactory encoder_factory(&encoder);
   GetVideoSendConfig()->encoder_settings.encoder_factory = &encoder_factory;
 
   CreateVideoStreams();
@@ -2125,8 +2125,8 @@ class StartStopBitrateObserver : public test::FakeEncoder {
 TEST_P(VideoSendStreamTest, VideoSendStreamStopSetEncoderRateToZero) {
   test::NullTransport transport;
   StartStopBitrateObserver encoder;
+  encoder.SetHasInternalSource(true);
   test::VideoEncoderProxyFactory encoder_factory(&encoder);
-  encoder_factory.SetHasInternalSource(true);
   test::FrameForwarder forwarder;
 
   task_queue_.SendTask([this, &transport, &encoder_factory, &forwarder]() {
@@ -2168,8 +2168,8 @@ TEST_P(VideoSendStreamTest, VideoSendStreamStopSetEncoderRateToZero) {
 TEST_P(VideoSendStreamTest, VideoSendStreamUpdateActiveSimulcastLayers) {
   test::NullTransport transport;
   StartStopBitrateObserver encoder;
+  encoder.SetHasInternalSource(true);
   test::VideoEncoderProxyFactory encoder_factory(&encoder);
-  encoder_factory.SetHasInternalSource(true);
   test::FrameForwarder forwarder;
 
   task_queue_.SendTask([this, &transport, &encoder_factory, &forwarder]() {

video/video_stream_encoder.cc

@@ -363,7 +363,6 @@ VideoStreamEncoder::VideoStreamEncoder(
       pre_encode_callback_(pre_encode_callback),
       max_framerate_(-1),
       pending_encoder_reconfiguration_(false),
-      pending_encoder_creation_(false),
       crop_width_(0),
       crop_height_(0),
       encoder_start_bitrate_bps_(0),
@@ -439,8 +438,9 @@ void VideoStreamEncoder::SetSource(
     }
     degradation_preference_ = degradation_preference;
 
-    if (encoder_)
+    if (encoder_) {
       ConfigureQualityScaler();
+    }
 
     if (!IsFramerateScalingEnabled(degradation_preference) &&
         max_framerate_ != -1) {
@@ -491,8 +491,13 @@ void VideoStreamEncoder::ConfigureEncoderOnTaskQueue(
   RTC_LOG(LS_INFO) << "ConfigureEncoder requested.";
 
   max_data_payload_length_ = max_data_payload_length;
-  pending_encoder_creation_ =
-      (!encoder_ || encoder_config_.video_format != config.video_format);
+  if (!encoder_ || encoder_config_.video_format != config.video_format) {
+    pending_encoder_ =
+        settings_.encoder_factory->CreateVideoEncoder(config.video_format);
+    // TODO(nisse): What to do if creating the encoder fails? Crash,
+    // or just discard incoming frames?
+    RTC_CHECK(pending_encoder_);
+  }
   encoder_config_ = std::move(config);
   pending_encoder_reconfiguration_ = true;
 
@@ -502,13 +507,15 @@ void VideoStreamEncoder::ConfigureEncoderOnTaskQueue(
   // The codec configuration depends on incoming video frame size.
   if (last_frame_info_) {
     ReconfigureEncoder();
-  } else if (settings_.encoder_factory
-                 ->QueryVideoEncoder(encoder_config_.video_format)
-                 .has_internal_source) {
+  } else {
+    VideoEncoder* encoder =
+        pending_encoder_ ? pending_encoder_.get() : encoder_.get();
+    if (encoder->GetEncoderInfo().has_internal_source) {
       last_frame_info_ = VideoFrameInfo(176, 144, false);
       ReconfigureEncoder();
     }
   }
+}
 
 // TODO(bugs.webrtc.org/8807): Currently this always does a hard
 // reconfiguration, but this isn't always necessary. Add in logic to only update
@@ -584,28 +591,21 @@ void VideoStreamEncoder::ReconfigureEncoder() {
   source_proxy_->SetMaxFramerate(max_framerate);
 
   // Keep the same encoder, as long as the video_format is unchanged.
-  if (pending_encoder_creation_) {
-    pending_encoder_creation_ = false;
+  if (pending_encoder_) {
     if (encoder_) {
       video_sender_.RegisterExternalEncoder(nullptr, false);
     }
+    encoder_ = std::move(pending_encoder_);
 
-    encoder_ = settings_.encoder_factory->CreateVideoEncoder(
-        encoder_config_.video_format);
-    // TODO(nisse): What to do if creating the encoder fails? Crash,
-    // or just discard incoming frames?
-    RTC_CHECK(encoder_);
-
-    const webrtc::VideoEncoderFactory::CodecInfo info =
-        settings_.encoder_factory->QueryVideoEncoder(
-            encoder_config_.video_format);
+    const VideoEncoder::EncoderInfo& encoder_info = encoder_->GetEncoderInfo();
 
     overuse_detector_->StopCheckForOveruse();
     overuse_detector_->StartCheckForOveruse(
-        GetCpuOveruseOptions(settings_, info.is_hardware_accelerated), this);
+        GetCpuOveruseOptions(settings_, encoder_info.is_hardware_accelerated),
+        this);
 
     video_sender_.RegisterExternalEncoder(encoder_.get(),
-                                          info.has_internal_source);
+                                          encoder_info.has_internal_source);
   }
   // RegisterSendCodec implies an unconditional call to
   // encoder_->InitEncode().

video/video_stream_encoder.h

@@ -202,6 +202,9 @@ class VideoStreamEncoder : public VideoStreamEncoderInterface,
   rtc::ThreadChecker thread_checker_;
 
   VideoEncoderConfig encoder_config_ RTC_GUARDED_BY(&encoder_queue_);
+  // Pending encoder object (e.g. because of a codec change).
+  std::unique_ptr<VideoEncoder> pending_encoder_ RTC_GUARDED_BY(&encoder_queue_)
+      RTC_PT_GUARDED_BY(&encoder_queue_);
   std::unique_ptr<VideoEncoder> encoder_ RTC_GUARDED_BY(&encoder_queue_)
       RTC_PT_GUARDED_BY(&encoder_queue_);
   std::unique_ptr<VideoBitrateAllocator> rate_allocator_
@@ -213,9 +216,6 @@ class VideoStreamEncoder : public VideoStreamEncoderInterface,
   // Set when ConfigureEncoder has been called in order to lazy reconfigure the
   // encoder on the next frame.
   bool pending_encoder_reconfiguration_ RTC_GUARDED_BY(&encoder_queue_);
-  // Set when configuration must create a new encoder object, e.g.,
-  // because of a codec change.
-  bool pending_encoder_creation_ RTC_GUARDED_BY(&encoder_queue_);
   absl::optional<VideoFrameInfo> last_frame_info_
       RTC_GUARDED_BY(&encoder_queue_);
   int crop_width_ RTC_GUARDED_BY(&encoder_queue_);

video/video_stream_encoder_unittest.cc

@@ -511,8 +511,8 @@ class VideoStreamEncoderTest : public ::testing::Test {
     }
 
     VideoEncoder::EncoderInfo GetEncoderInfo() const override {
-      EncoderInfo info;
       rtc::CritScope lock(&local_crit_sect_);
+      EncoderInfo info = FakeEncoder::GetEncoderInfo();
       if (quality_scaling_) {
         info.scaling_settings =
             VideoEncoder::ScalingSettings(1, 2, kMinPixelsPerFrame);
@@ -3198,7 +3198,7 @@ TEST_F(VideoStreamEncoderTest,
   CpuOveruseOptions hardware_options;
   hardware_options.low_encode_usage_threshold_percent = 150;
   hardware_options.high_encode_usage_threshold_percent = 200;
-  encoder_factory_.SetIsHardwareAccelerated(true);
+  fake_encoder_.SetIsHardwareAccelerated(true);
 
   video_stream_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
   video_source_.IncomingCapturedFrame(