Remove webrtc::VideoEncoderFactory

webrtc/media/engine/simulcast_encoder_adapter.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 "webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h"
+#include "webrtc/media/engine/simulcast_encoder_adapter.h"
 
 #include <algorithm>
 
 // NOTE(ajm): Path provided by gyp.
 #include "libyuv/scale.h"  // NOLINT
 
 #include "webrtc/api/video/i420_buffer.h"
 #include "webrtc/modules/video_coding/codecs/vp8/screenshare_layers.h"
 #include "webrtc/modules/video_coding/codecs/vp8/simulcast_rate_allocator.h"
 #include "webrtc/rtc_base/checks.h"
@@ skipping 97 matching lines @@
   }
 
   const int adapted_simulcast_id_;
   const TemporalLayersFactory& tl_factory_;
 };
 
 }  // namespace
 
 namespace webrtc {
 
-SimulcastEncoderAdapter::SimulcastEncoderAdapter(VideoEncoderFactory* factory)
+SimulcastEncoderAdapter::SimulcastEncoderAdapter(
+    cricket::WebRtcVideoEncoderFactory* factory)
     : inited_(0),
       factory_(factory),
       encoded_complete_callback_(nullptr),
       implementation_name_("SimulcastEncoderAdapter") {
   // The adapter is typically created on the worker thread, but operated on
   // the encoder task queue.
   encoder_queue_.Detach();
 
   memset(&codec_, 0, sizeof(webrtc::VideoCodec));
 }
@@ skipping 89 matching lines @@
     }
 
     // If an existing encoder instance exists, reuse it.
     // TODO(brandtr): Set initial RTP state (e.g., picture_id/tl0_pic_idx) here,
     // when we start storing that state outside the encoder wrappers.
     VideoEncoder* encoder;
     if (!stored_encoders_.empty()) {
       encoder = stored_encoders_.top();
       stored_encoders_.pop();
     } else {
-      encoder = factory_->Create();
+      encoder = factory_->CreateVideoEncoder(cricket::VideoCodec("VP8"));
     }
 
     ret = encoder->InitEncode(&stream_codec, number_of_cores, max_payload_size);
     if (ret < 0) {
       // Explicitly destroy the current encoder; because we haven't registered a
       // StreamInfo for it yet, Release won't do anything about it.
-      factory_->Destroy(encoder);
+      factory_->DestroyVideoEncoder(encoder);
       Release();
       return ret;
     }
     std::unique_ptr<EncodedImageCallback> callback(
         new AdapterEncodedImageCallback(this, i));
     encoder->RegisterEncodeCompleteCallback(callback.get());
     streaminfos_.emplace_back(encoder, std::move(callback), stream_codec.width,
                               stream_codec.height, start_bitrate_kbps > 0);
 
     if (i != 0) {
@@ skipping 236 matching lines @@
   stream_codec->startBitrate = start_bitrate_kbps;
 }
 
 bool SimulcastEncoderAdapter::Initialized() const {
   return rtc::AtomicOps::AcquireLoad(&inited_) == 1;
 }
 
 void SimulcastEncoderAdapter::DestroyStoredEncoders() {
   while (!stored_encoders_.empty()) {
     VideoEncoder* encoder = stored_encoders_.top();
-    factory_->Destroy(encoder);
+    factory_->DestroyVideoEncoder(encoder);
     stored_encoders_.pop();
   }
 }
 
 bool SimulcastEncoderAdapter::SupportsNativeHandle() const {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_);
   // We should not be calling this method before streaminfos_ are configured.
   RTC_DCHECK(!streaminfos_.empty());
   for (const auto& streaminfo : streaminfos_) {
     if (!streaminfo.encoder->SupportsNativeHandle()) {
@@ skipping 13 matching lines @@
   }
   return streaminfos_[0].encoder->GetScalingSettings();
 }
 
 const char* SimulcastEncoderAdapter::ImplementationName() const {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_);
   return implementation_name_.c_str();
 }
 
 }  // namespace webrtc