Remove default encoder/decoders.

This path is not used, senders/receivers already disable default coders.

BUG=1695
R=mflodman@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/54449004

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

webrtc/video/call.cc

@@ -169,8 +169,7 @@ Call::Call(const Call::Config& config)
 
   // TODO(pbos): Remove base channel when CreateReceiveChannel no longer
   // requires one.
-  CHECK(channel_group_->CreateSendChannel(base_channel_id_, 0, num_cpu_cores_,
+  CHECK(channel_group_->CreateSendChannel(base_channel_id_, 0, num_cpu_cores_));
-                                          true));
 
   if (config.overuse_callback) {
     overuse_observer_proxy_.reset(

webrtc/video/video_receive_stream.cc

@@ -138,7 +138,7 @@ VideoReceiveStream::VideoReceiveStream(int num_cpu_cores,
       channel_id_(channel_id),
       voe_sync_interface_(nullptr) {
   CHECK(channel_group_->CreateReceiveChannel(channel_id_, 0, base_channel_id,
-                                             num_cpu_cores, true));
+                                             num_cpu_cores));
 
   vie_channel_ = channel_group_->GetChannel(channel_id_);
 

webrtc/video/video_send_stream.cc

@@ -119,7 +119,7 @@ VideoSendStream::VideoSendStream(
       channel_id_(channel_id),
       use_config_bitrate_(true),
       stats_proxy_(Clock::GetRealTimeClock(), config) {
-  CHECK(channel_group->CreateSendChannel(channel_id_, 0, num_cpu_cores, true));
+  CHECK(channel_group->CreateSendChannel(channel_id_, 0, num_cpu_cores));
   vie_channel_ = channel_group_->GetChannel(channel_id_);
   vie_encoder_ = channel_group_->GetEncoder(channel_id_);
 

webrtc/video_engine/encoder_state_feedback_unittest.cc

@@ -31,7 +31,7 @@ namespace webrtc {
 class MockVieEncoder : public ViEEncoder {
  public:
   explicit MockVieEncoder(ProcessThread* process_thread, PacedSender* pacer)
-      : ViEEncoder(1, 1, config_, *process_thread, pacer, NULL, NULL, false) {}
+      : ViEEncoder(1, 1, config_, *process_thread, pacer, NULL, NULL) {}
   ~MockVieEncoder() {}
 
   MOCK_METHOD1(OnReceivedIntraFrameRequest,

webrtc/video_engine/vie_channel.cc

@@ -90,8 +90,7 @@ ViEChannel::ViEChannel(int32_t channel_id,
                        RtcpRttStats* rtt_stats,
                        PacedSender* paced_sender,
                        PacketRouter* packet_router,
-                       bool sender,
+                       bool sender)
-                       bool disable_default_encoder)
     : ViEFrameProviderBase(channel_id, engine_id),
       channel_id_(channel_id),
       engine_id_(engine_id),
@@ -125,7 +124,6 @@ ViEChannel::ViEChannel(int32_t channel_id,
       wait_for_key_frame_(false),
       mtu_(0),
       sender_(sender),
-      disable_default_encoder_(disable_default_encoder),
       nack_history_size_sender_(kSendSidePacketHistorySize),
       max_nack_reordering_threshold_(kMaxPacketAgeToNack),
       pre_render_callback_(NULL),
@@ -170,24 +168,6 @@ int32_t ViEChannel::Init() {
   module_process_thread_.RegisterModule(vcm_);
   module_process_thread_.RegisterModule(&vie_sync_);
 
-#ifdef VIDEOCODEC_VP8
-  if (!disable_default_encoder_) {
-    VideoCodec video_codec;
-    if (vcm_->Codec(kVideoCodecVP8, &video_codec) == VCM_OK) {
-      rtp_rtcp_->RegisterSendPayload(video_codec);
-      // TODO(holmer): Can we call SetReceiveCodec() here instead?
-      if (!vie_receiver_.RegisterPayload(video_codec)) {
-        return -1;
-      }
-      vcm_->RegisterReceiveCodec(&video_codec, number_of_cores_);
-      vcm_->RegisterSendCodec(&video_codec, number_of_cores_,
-                              rtp_rtcp_->MaxDataPayloadLength());
-    } else {
-      assert(false);
-    }
-  }
-#endif
-
   return 0;
 }
 

webrtc/video_engine/vie_channel.h

@@ -115,8 +115,7 @@ class ViEChannel
              RtcpRttStats* rtt_stats,
              PacedSender* paced_sender,
              PacketRouter* packet_router,
-             bool sender,
+             bool sender);
-             bool disable_default_encoder);
   ~ViEChannel();
 
   int32_t Init();
@@ -528,8 +527,6 @@ class ViEChannel
   // User set MTU, -1 if not set.
   uint16_t mtu_;
   const bool sender_;
-  // Used to skip default encoder in the new API.
-  const bool disable_default_encoder_;
 
   int nack_history_size_sender_;
   int max_nack_reordering_threshold_;

webrtc/video_engine/vie_channel_group.cc

@@ -200,17 +200,16 @@ ChannelGroup::~ChannelGroup() {
 
 bool ChannelGroup::CreateSendChannel(int channel_id,
                                      int engine_id,
-                                     int number_of_cores,
+                                     int number_of_cores) {
-                                     bool disable_default_encoder) {
   rtc::scoped_ptr<ViEEncoder> vie_encoder(new ViEEncoder(
       channel_id, number_of_cores, *config_, *process_thread_, pacer_.get(),
-      bitrate_allocator_.get(), bitrate_controller_.get(), false));
+      bitrate_allocator_.get(), bitrate_controller_.get()));
   if (!vie_encoder->Init()) {
     return false;
   }
   ViEEncoder* encoder = vie_encoder.get();
   if (!CreateChannel(channel_id, engine_id, number_of_cores,
-                     vie_encoder.release(), true, disable_default_encoder)) {
+                     vie_encoder.release(), true)) {
     return false;
   }
   ViEChannel* channel = channel_map_[channel_id];
@@ -232,19 +231,16 @@ bool ChannelGroup::CreateSendChannel(int channel_id,
 bool ChannelGroup::CreateReceiveChannel(int channel_id,
                                         int engine_id,
                                         int base_channel_id,
-                                        int number_of_cores,
+                                        int number_of_cores) {
-                                        bool disable_default_encoder) {
   ViEEncoder* encoder = GetEncoder(base_channel_id);
-  return CreateChannel(channel_id, engine_id, number_of_cores, encoder, false,
+  return CreateChannel(channel_id, engine_id, number_of_cores, encoder, false);
-                       disable_default_encoder);
 }
 
 bool ChannelGroup::CreateChannel(int channel_id,
                                  int engine_id,
                                  int number_of_cores,
                                  ViEEncoder* vie_encoder,
-                                 bool sender,
+                                 bool sender) {
-                                 bool disable_default_encoder) {
   DCHECK(vie_encoder);
 
   rtc::scoped_ptr<ViEChannel> channel(new ViEChannel(
@@ -252,19 +248,10 @@ bool ChannelGroup::CreateChannel(int channel_id,
       encoder_state_feedback_->GetRtcpIntraFrameObserver(),
       bitrate_controller_->CreateRtcpBandwidthObserver(),
       remote_bitrate_estimator_.get(), call_stats_->rtcp_rtt_stats(),
-      pacer_.get(), packet_router_.get(), sender, disable_default_encoder));
+      pacer_.get(), packet_router_.get(), sender));
   if (channel->Init() != 0) {
     return false;
   }
-  if (!disable_default_encoder) {
-    VideoCodec encoder;
-    if (vie_encoder->GetEncoder(&encoder) != 0) {
-      return false;
-    }
-    if (sender && channel->SetSendCodec(encoder) != 0) {
-      return false;
-    }
-  }
 
   // Register the channel to receive stats updates.
   call_stats_->RegisterStatsObserver(channel->GetStatsObserver());

webrtc/video_engine/vie_channel_group.h

@@ -44,13 +44,11 @@ class ChannelGroup : public BitrateObserver {
   ~ChannelGroup();
   bool CreateSendChannel(int channel_id,
                          int engine_id,
-                         int number_of_cores,
+                         int number_of_cores);
-                         bool disable_default_encoder);
   bool CreateReceiveChannel(int channel_id,
                             int engine_id,
                             int base_channel_id,
-                            int number_of_cores,
+                            int number_of_cores);
-                            bool disable_default_encoder);
   void DeleteChannel(int channel_id);
   void AddChannel(int channel_id);
   void RemoveChannel(int channel_id);
@@ -86,8 +84,7 @@ class ChannelGroup : public BitrateObserver {
                      int engine_id,
                      int number_of_cores,
                      ViEEncoder* vie_encoder,
-                     bool sender,
+                     bool sender);
-                     bool disable_default_encoder);
   ViEChannel* PopChannel(int channel_id);
   ViEEncoder* PopEncoder(int channel_id);
 

webrtc/video_engine/vie_encoder.cc

@@ -104,11 +104,9 @@ ViEEncoder::ViEEncoder(int32_t channel_id,
                        ProcessThread& module_process_thread,
                        PacedSender* pacer,
                        BitrateAllocator* bitrate_allocator,
-                       BitrateController* bitrate_controller,
+                       BitrateController* bitrate_controller)
-                       bool disable_default_encoder)
     : channel_id_(channel_id),
       number_of_cores_(number_of_cores),
-      disable_default_encoder_(disable_default_encoder),
       vpm_(VideoProcessingModule::Create(ViEModuleId(-1, channel_id))),
       qm_callback_(new QMVideoSettingsCallback(vpm_.get())),
       vcm_(VideoCodingModule::Create(Clock::GetRealTimeClock(),
@@ -149,26 +147,6 @@ bool ViEEncoder::Init() {
   // Enable/disable content analysis: off by default for now.
   vpm_->EnableContentAnalysis(false);
 
-  if (!disable_default_encoder_) {
-#ifdef VIDEOCODEC_VP8
-    VideoCodecType codec_type = webrtc::kVideoCodecVP8;
-#else
-    VideoCodecType codec_type = webrtc::kVideoCodecI420;
-#endif
-    VideoCodec video_codec;
-    if (vcm_->Codec(codec_type, &video_codec) != VCM_OK) {
-      return false;
-    }
-    {
-      CriticalSectionScoped cs(data_cs_.get());
-      send_padding_ = video_codec.numberOfSimulcastStreams > 1;
-    }
-    if (vcm_->RegisterSendCodec(&video_codec, number_of_cores_,
-                                PayloadRouter::DefaultMaxPayloadLength()) !=
-        0) {
-      return false;
-    }
-  }
   if (vcm_->RegisterTransportCallback(this) != 0) {
     return false;
   }
@@ -282,30 +260,6 @@ int32_t ViEEncoder::DeRegisterExternalEncoder(uint8_t pl_type) {
     return -1;
   }
 
-  if (disable_default_encoder_)
-    return 0;
-
-  // If the external encoder is the current send codec, use vcm internal
-  // encoder.
-  if (current_send_codec.plType == pl_type) {
-    {
-      CriticalSectionScoped cs(data_cs_.get());
-      send_padding_ = current_send_codec.numberOfSimulcastStreams > 1;
-    }
-    // TODO(mflodman): Unfortunately the VideoCodec that VCM has cached a
-    // raw pointer to an |extra_options| that's long gone.  Clearing it here is
-    // a hack to prevent the following code from crashing.  This should be fixed
-    // for realz.  https://code.google.com/p/chromium/issues/detail?id=348222
-    current_send_codec.extra_options = NULL;
-    size_t max_data_payload_length = send_payload_router_->MaxPayloadLength();
-    if (vcm_->RegisterSendCodec(&current_send_codec, number_of_cores_,
-                                max_data_payload_length) != VCM_OK) {
-      LOG(LS_INFO) << "De-registered the currently used external encoder ("
-                   << static_cast<int>(pl_type) << ") and therefore tried to "
-                   << "register the corresponding internal encoder, but none "
-                   << "was supported.";
-    }
-  }
   return 0;
 }
 

webrtc/video_engine/vie_encoder.h

@@ -78,8 +78,7 @@ class ViEEncoder
              ProcessThread& module_process_thread,
              PacedSender* pacer,
              BitrateAllocator* bitrate_allocator,
-             BitrateController* bitrate_controller,
+             BitrateController* bitrate_controller);
-             bool disable_default_encoder);
   ~ViEEncoder();
 
   bool Init();
@@ -203,7 +202,6 @@ class ViEEncoder
 
   const int channel_id_;
   const uint32_t number_of_cores_;
-  const bool disable_default_encoder_;
 
   const rtc::scoped_ptr<VideoProcessingModule> vpm_;
   const rtc::scoped_ptr<QMVideoSettingsCallback> qm_callback_;