Remove base channel for video receivers.

webrtc/video_engine/vie_channel.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 73 matching lines @@
                        const Config& config,
                        Transport* transport,
                        ProcessThread* module_process_thread,
                        RtcpIntraFrameObserver* intra_frame_observer,
                        RtcpBandwidthObserver* bandwidth_observer,
                        RemoteBitrateEstimator* remote_bitrate_estimator,
                        RtcpRttStats* rtt_stats,
                        PacedSender* paced_sender,
                        PacketRouter* packet_router,
                        size_t max_rtp_streams,
-                       bool sender,
-                       bool disable_default_encoder)
+                       bool sender)
     : channel_id_(channel_id),
       engine_id_(engine_id),
       number_of_cores_(number_of_cores),
       sender_(sender),
       module_process_thread_(module_process_thread),
       crit_(CriticalSectionWrapper::CreateCriticalSection()),
       send_payload_router_(new PayloadRouter()),
       vcm_protection_callback_(new ViEChannelProtectionCallback(this)),
       vcm_(VideoCodingModule::Create(Clock::GetRealTimeClock(),
                                      nullptr,
                                      nullptr)),
       vie_receiver_(channel_id, vcm_, remote_bitrate_estimator, this),
       vie_sync_(vcm_),
       stats_observer_(new ChannelStatsObserver(this)),
       vcm_receive_stats_callback_(NULL),
       incoming_video_stream_(nullptr),
       codec_observer_(NULL),
       intra_frame_observer_(intra_frame_observer),
       rtt_stats_(rtt_stats),
       paced_sender_(paced_sender),
       packet_router_(packet_router),
       bandwidth_observer_(bandwidth_observer),
       decoder_reset_(true),
-      disable_default_encoder_(disable_default_encoder),
       nack_history_size_sender_(kSendSidePacketHistorySize),
       max_nack_reordering_threshold_(kMaxPacketAgeToNack),
       pre_render_callback_(NULL),
       report_block_stats_sender_(new ReportBlockStats()),
       rtp_rtcp_modules_(
           CreateRtpRtcpModules(ViEModuleId(engine_id_, channel_id_),
                                !sender,
                                vie_receiver_.GetReceiveStatistics(),
                                transport,
                                sender ? intra_frame_observer_ : nullptr,
@@ skipping 35 matching lines @@
     return -1;
   }
   vcm_->RegisterFrameTypeCallback(this);
   vcm_->RegisterReceiveStatisticsCallback(this);
   vcm_->RegisterDecoderTimingCallback(this);
   vcm_->SetRenderDelay(kViEDefaultRenderDelayMs);
 
   module_process_thread_->RegisterModule(vcm_);
   module_process_thread_->RegisterModule(&vie_sync_);
 
-#ifdef VIDEOCODEC_VP8

[stefan-webrtc, 2015/07/23 08:34:38]

I don't fully understand how this is related to this CL? Is it just cleaning
away more stuff while you are at it? Maybe it would be good to make it two
separate CLs in that case.

[pbos-webrtc, 2015/07/23 08:51:09]

All call sites (of CreateSendChannel and CreateReceiveChannel) had
disable_default_encoder == true, so this is actually dead code.

[stefan-webrtc, 2015/07/23 12:43:46]

Thanks

-  if (!disable_default_encoder_) {
-    VideoCodec video_codec;
-    if (vcm_->Codec(kVideoCodecVP8, &video_codec) == VCM_OK) {
-      rtp_rtcp_modules_[0]->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_modules_[0]->MaxDataPayloadLength());
-    } else {
-      RTC_NOTREACHED();
-    }
-  }
-#endif
-
   return 0;
 }
 
 ViEChannel::~ViEChannel() {
   UpdateHistograms();
   // Make sure we don't get more callbacks from the RTP module.
   module_process_thread_->DeRegisterModule(
       vie_receiver_.GetReceiveStatistics());
   module_process_thread_->DeRegisterModule(vcm_);
   module_process_thread_->DeRegisterModule(&vie_sync_);
@@ skipping 1065 matching lines @@
   CriticalSectionScoped cs(crit_.get());
   vcm_receive_stats_callback_ = receive_statistics_proxy;
 }
 
 void ViEChannel::SetIncomingVideoStream(
     IncomingVideoStream* incoming_video_stream) {
   CriticalSectionScoped cs(crit_.get());
   incoming_video_stream_ = incoming_video_stream;
 }
 }  // namespace webrtc