Remove default ViEEncoder encoder instance.

webrtc/video_engine/vie_encoder.cc

 /*
  *  Copyright (c) 2012 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.
  */
 
@@ skipping 88 matching lines @@
   }
  private:
   ViEEncoder* owner_;
 };
 
 ViEEncoder::ViEEncoder(int32_t channel_id,
                        uint32_t number_of_cores,
                        ProcessThread& module_process_thread,
                        PacedSender* pacer,
                        BitrateAllocator* bitrate_allocator,
-                       BitrateController* bitrate_controller,
-                       bool disable_default_encoder)
+                       BitrateController* bitrate_controller)
     : 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(),
                                      this,
                                      qm_callback_.get())),
       send_payload_router_(NULL),
       callback_cs_(CriticalSectionWrapper::CreateCriticalSection()),
       data_cs_(CriticalSectionWrapper::CreateCriticalSection()),
       pacer_(pacer),
       bitrate_allocator_(bitrate_allocator),
       bitrate_controller_(bitrate_controller),
       time_of_last_frame_activity_ms_(0),
-      send_padding_(false),
+      simulcast_enabled_(false),
       min_transmit_bitrate_kbps_(0),
       last_observed_bitrate_bps_(0),
       target_delay_ms_(0),
       network_is_transmitting_(true),
       encoder_paused_(false),
       encoder_paused_and_dropped_frame_(false),
       fec_enabled_(false),
       nack_enabled_(false),
       codec_observer_(NULL),
       module_process_thread_(module_process_thread),
       has_received_sli_(false),
       picture_id_sli_(0),
       has_received_rpsi_(false),
       picture_id_rpsi_(0),
       video_suspended_(false),
       pre_encode_callback_(NULL),
       start_ms_(Clock::GetRealTimeClock()->TimeInMilliseconds()),
       send_statistics_proxy_(NULL) {
   bitrate_observer_.reset(new ViEBitrateObserver(this));
 }
 
 bool ViEEncoder::Init() {
   vpm_->EnableTemporalDecimation(true);
 
   // 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_,
-            static_cast<uint32_t>(PayloadRouter::DefaultMaxPayloadLength())) !=
-        0) {
-      return false;
-    }
-  }
   if (vcm_->RegisterTransportCallback(this) != 0) {
     return false;
   }
   if (vcm_->RegisterSendStatisticsCallback(this) != 0) {
     return false;
   }
   return true;
 }
 
 void ViEEncoder::StartThreadsAndSetSharedMembers(
@@ skipping 79 matching lines @@
     return -1;
 
   if (vcm_->RegisterExternalEncoder(encoder, pl_type, internal_source) !=
       VCM_OK) {
     return -1;
   }
   return 0;
 }
 
 int32_t ViEEncoder::DeRegisterExternalEncoder(uint8_t pl_type) {
-  DCHECK(send_payload_router_ != NULL);
-  webrtc::VideoCodec current_send_codec;
-  if (vcm_->SendCodec(&current_send_codec) == VCM_OK) {
-    uint32_t current_bitrate_bps = 0;
-    if (vcm_->Bitrate(&current_bitrate_bps) != 0) {
-      LOG(LS_WARNING) << "Failed to get the current encoder target bitrate.";
-    }
-    current_send_codec.startBitrate = (current_bitrate_bps + 500) / 1000;
-  }
-
   if (vcm_->RegisterExternalEncoder(NULL, pl_type) != VCM_OK) {
     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_,
-            static_cast<uint32_t>(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;
 }
 
 int32_t ViEEncoder::SetEncoder(const webrtc::VideoCodec& video_codec) {
   DCHECK(send_payload_router_ != NULL);
   // Setting target width and height for VPM.
   if (vpm_->SetTargetResolution(video_codec.width, video_codec.height,
                                 video_codec.maxFramerate) != VPM_OK) {
     return -1;
   }
 
   {
     CriticalSectionScoped cs(data_cs_.get());
-    send_padding_ = video_codec.numberOfSimulcastStreams > 1;
+    simulcast_enabled_ = video_codec.numberOfSimulcastStreams > 1;
   }
 
   // Add a bitrate observer to the allocator and update the start, max and
   // min bitrates of the bitrate controller as needed.
   int allocated_bitrate_bps;
   int new_bwe_candidate_bps = bitrate_allocator_->AddBitrateObserver(
       bitrate_observer_.get(), video_codec.startBitrate * 1000,
       video_codec.minBitrate * 1000, video_codec.maxBitrate * 1000,
       &allocated_bitrate_bps);
 
@@ skipping 58 matching lines @@
 
   return 0;
 }
 
 int ViEEncoder::GetPaddingNeededBps() const {
   int64_t time_of_last_frame_activity_ms;
   int min_transmit_bitrate_bps;
   int bitrate_bps;
   {
     CriticalSectionScoped cs(data_cs_.get());
-    bool send_padding =
-        send_padding_ || video_suspended_ || min_transmit_bitrate_kbps_ > 0;
+    bool send_padding = simulcast_enabled_ || video_suspended_ ||
+                        min_transmit_bitrate_kbps_ > 0;
     if (!send_padding)
       return 0;
     time_of_last_frame_activity_ms = time_of_last_frame_activity_ms_;
     min_transmit_bitrate_bps = 1000 * min_transmit_bitrate_kbps_;
     bitrate_bps = last_observed_bitrate_bps_;
   }
 
   VideoCodec send_codec;
   if (vcm_->SendCodec(&send_codec) != 0)
     return 0;
@@ skipping 451 matching lines @@
     const uint32_t width,
     const uint32_t height) {
   return vpm_->SetTargetResolution(width, height, frame_rate);
 }
 
 void QMVideoSettingsCallback::SetTargetFramerate(int frame_rate) {
   vpm_->SetTargetFramerate(frame_rate);
 }
 
 }  // namespace webrtc