Remove internal encoders from VCMCodecDatabase.

Encoders need to be externally provided. To use software encoders they
need to be created and registered from the outside.

BUG=webrtc:1695
R=stefan@webrtc.org

Review URL: https://codereview.webrtc.org/1394823002 .

Cr-Commit-Position: refs/heads/master@{#10283}

webrtc/modules/video_coding/main/source/codec_database.cc

@@ -106,14 +106,12 @@ VCMCodecDataBase::VCMCodecDataBase(
       max_payload_size_(kDefaultPayloadSize),
       periodic_key_frames_(false),
       pending_encoder_reset_(true),
-      current_enc_is_external_(false),
       send_codec_(),
       receive_codec_(),
-      external_payload_type_(0),
+      encoder_payload_type_(0),
       external_encoder_(NULL),
       internal_source_(false),
       encoder_rate_observer_(encoder_rate_observer),
-      ptr_encoder_(NULL),
       ptr_decoder_(NULL),
       dec_map_(),
       dec_external_map_() {
@@ -296,17 +294,10 @@ bool VCMCodecDataBase::SetSendCodec(
 
   // If encoder exists, will destroy it and create new one.
   DeleteEncoder();
-  if (send_codec_.plType == external_payload_type_) {
+  RTC_DCHECK_EQ(encoder_payload_type_, send_codec_.plType)
-    // External encoder.
+      << "Encoder not registered for payload type " << send_codec_.plType;
-    ptr_encoder_ = new VCMGenericEncoder(
+  ptr_encoder_.reset(new VCMGenericEncoder(
-        external_encoder_, encoder_rate_observer_, internal_source_);
+      external_encoder_, encoder_rate_observer_, internal_source_));
-    current_enc_is_external_ = true;
-  } else {
-    ptr_encoder_ = CreateEncoder(send_codec_.codecType);
-    current_enc_is_external_ = false;
-    if (!ptr_encoder_)
-      return false;
-  }
   encoded_frame_callback->SetPayloadType(send_codec_.plType);
   if (ptr_encoder_->InitEncode(&send_codec_, number_of_cores_,
                                max_payload_size_) < 0) {
@@ -348,17 +339,16 @@ bool VCMCodecDataBase::DeregisterExternalEncoder(
     uint8_t payload_type, bool* was_send_codec) {
   assert(was_send_codec);
   *was_send_codec = false;
-  if (external_payload_type_ != payload_type) {
+  if (encoder_payload_type_ != payload_type) {
     return false;
   }
   if (send_codec_.plType == payload_type) {
     // De-register as send codec if needed.
     DeleteEncoder();
     memset(&send_codec_, 0, sizeof(VideoCodec));
-    current_enc_is_external_ = false;
     *was_send_codec = true;
   }
-  external_payload_type_ = 0;
+  encoder_payload_type_ = 0;
   external_encoder_ = NULL;
   internal_source_ = false;
   return true;
@@ -371,7 +361,7 @@ void VCMCodecDataBase::RegisterExternalEncoder(
   // Since only one encoder can be used at a given time, only one external
   // encoder can be registered/used.
   external_encoder_ = external_encoder;
-  external_payload_type_ = payload_type;
+  encoder_payload_type_ = payload_type;
   internal_source_ = internal_source;
   pending_encoder_reset_ = true;
 }
@@ -446,7 +436,7 @@ bool VCMCodecDataBase::RequiresEncoderReset(const VideoCodec& new_send_codec) {
 }
 
 VCMGenericEncoder* VCMCodecDataBase::GetEncoder() {
-  return ptr_encoder_;
+  return ptr_encoder_.get();
 }
 
 bool VCMCodecDataBase::SetPeriodicKeyFrames(bool enable) {
@@ -649,48 +639,11 @@ VCMGenericDecoder* VCMCodecDataBase::CreateAndInitDecoder(
   return ptr_decoder;
 }
 
-VCMGenericEncoder* VCMCodecDataBase::CreateEncoder(
-  const VideoCodecType type) const {
-  switch (type) {
-#ifdef VIDEOCODEC_VP8
-    case kVideoCodecVP8:
-      return new VCMGenericEncoder(VP8Encoder::Create(), encoder_rate_observer_,
-                                   false);
-#endif
-#ifdef VIDEOCODEC_VP9
-    case kVideoCodecVP9:
-      return new VCMGenericEncoder(VP9Encoder::Create(), encoder_rate_observer_,
-                                   false);
-#endif
-#ifdef VIDEOCODEC_I420
-    case kVideoCodecI420:
-      return new VCMGenericEncoder(new I420Encoder(), encoder_rate_observer_,
-                                   false);
-#endif
-#ifdef VIDEOCODEC_H264
-    case kVideoCodecH264:
-      if (H264Encoder::IsSupported()) {
-        return new VCMGenericEncoder(H264Encoder::Create(),
-                                     encoder_rate_observer_,
-                                     false);
-      }
-      break;
-#endif
-    default:
-      break;
-  }
-  LOG(LS_WARNING) << "No internal encoder of this type exists.";
-  return NULL;
-}
-
 void VCMCodecDataBase::DeleteEncoder() {
-  if (ptr_encoder_) {
+  if (!ptr_encoder_)
+    return;
   ptr_encoder_->Release();
-    if (!current_enc_is_external_)
+  ptr_encoder_.reset();
-      delete ptr_encoder_->encoder_;
-    delete ptr_encoder_;
-    ptr_encoder_ = NULL;
-  }
 }
 
 VCMGenericDecoder* VCMCodecDataBase::CreateDecoder(VideoCodecType type) const {

webrtc/modules/video_coding/main/source/codec_database.h

@@ -151,8 +151,6 @@ class VCMCodecDataBase {
   // Determines whether a new codec has to be created or not.
   // Checks every setting apart from maxFramerate and startBitrate.
   bool RequiresEncoderReset(const VideoCodec& send_codec);
-  // Create an internal encoder given a codec type.
-  VCMGenericEncoder* CreateEncoder(const VideoCodecType type) const;
 
   void DeleteEncoder();
 
@@ -168,14 +166,13 @@ class VCMCodecDataBase {
   size_t max_payload_size_;
   bool periodic_key_frames_;
   bool pending_encoder_reset_;
-  bool current_enc_is_external_;
   VideoCodec send_codec_;
   VideoCodec receive_codec_;
-  uint8_t external_payload_type_;
+  uint8_t encoder_payload_type_;
   VideoEncoder* external_encoder_;
   bool internal_source_;
   VideoEncoderRateObserver* const encoder_rate_observer_;
-  VCMGenericEncoder* ptr_encoder_;
+  rtc::scoped_ptr<VCMGenericEncoder> ptr_encoder_;
   VCMGenericDecoder* ptr_decoder_;
   DecoderMap dec_map_;
   ExternalDecoderMap dec_external_map_;

webrtc/modules/video_coding/main/source/video_sender_unittest.cc

@@ -14,6 +14,7 @@
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/common.h"
 #include "webrtc/modules/video_coding/codecs/interface/mock/mock_video_codec_interface.h"
+#include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h"
 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8_common_types.h"
 #include "webrtc/modules/video_coding/codecs/vp8/temporal_layers.h"
 #include "webrtc/modules/video_coding/main/interface/mock/mock_vcm_callbacks.h"
@@ -190,6 +191,8 @@ class TestVideoSender : public ::testing::Test {
   SimulatedClock clock_;
   PacketizationCallback packetization_callback_;
   MockEncodedImageCallback post_encode_callback_;
+  // Used by subclassing tests, need to outlive sender_.
+  rtc::scoped_ptr<VideoEncoder> encoder_;
   rtc::scoped_ptr<VideoSender> sender_;
   rtc::scoped_ptr<FrameGenerator> generator_;
 };
@@ -347,6 +350,9 @@ class TestVideoSenderWithVp8 : public TestVideoSender {
     codec_.minBitrate = 10;
     codec_.startBitrate = codec_bitrate_kbps_;
     codec_.maxBitrate = codec_bitrate_kbps_;
+    encoder_.reset(VP8Encoder::Create());
+    ASSERT_EQ(0, sender_->RegisterExternalEncoder(encoder_.get(), codec_.plType,
+                                                  false));
     EXPECT_EQ(0, sender_->RegisterSendCodec(&codec_, 1, 1200));
   }