From 1d04ac6f29f235e593fb04896ad229b63562717c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Peter=20Bostr=C3=B6m?= Date: Fri, 5 Feb 2016 11:25:46 +0100 Subject: [PATCH] Untangle ViEChannel and ViEEncoder. Extracts shared members outside the two objects, removing PayloadRouter from receivers and the VCM for ViEChannel from senders. Removes Start/StopThreadsAndSetSharedMembers that was used to set the shared state between them. Also adding DCHECKs to document what's only used by the sender/receiver side. BUG=webrtc:5494 R=stefan@webrtc.org Review URL: https://codereview.webrtc.org/1654913002 . Cr-Commit-Position: refs/heads/master@{#11500} --- .../video_coding/include/video_coding.h | 2 - .../modules/video_coding/video_coding_impl.cc | 5 - .../video_coding_robustness_unittest.cc | 6 +- .../video/encoder_state_feedback_unittest.cc | 1 + webrtc/video/video_receive_stream.cc | 16 ++- webrtc/video/video_receive_stream.h | 3 + webrtc/video/video_send_stream.cc | 27 ++--- webrtc/video/video_send_stream.h | 7 +- webrtc/video/vie_channel.cc | 98 ++++++++++--------- webrtc/video/vie_channel.h | 10 +- webrtc/video/vie_encoder.cc | 24 ++--- webrtc/video/vie_encoder.h | 15 +-- webrtc/video/vie_receiver.cc | 1 + 13 files changed, 105 insertions(+), 110 deletions(-) diff --git a/webrtc/modules/video_coding/include/video_coding.h b/webrtc/modules/video_coding/include/video_coding.h index 3920c257e8..6433f5628d 100644 --- a/webrtc/modules/video_coding/include/video_coding.h +++ b/webrtc/modules/video_coding/include/video_coding.h @@ -75,8 +75,6 @@ class VideoCodingModule : public Module { static VideoCodingModule* Create(Clock* clock, EventFactory* event_factory); - static void Destroy(VideoCodingModule* module); - // Get supported codec settings using codec type // // Input: diff --git a/webrtc/modules/video_coding/video_coding_impl.cc b/webrtc/modules/video_coding/video_coding_impl.cc index a9b277fd9e..7f74b4162f 100644 --- a/webrtc/modules/video_coding/video_coding_impl.cc +++ b/webrtc/modules/video_coding/video_coding_impl.cc @@ -310,9 +310,4 @@ VideoCodingModule* VideoCodingModule::Create(Clock* clock, nullptr); } -void VideoCodingModule::Destroy(VideoCodingModule* module) { - if (module != NULL) { - delete static_cast(module); - } -} } // namespace webrtc diff --git a/webrtc/modules/video_coding/video_coding_robustness_unittest.cc b/webrtc/modules/video_coding/video_coding_robustness_unittest.cc index dd6565d505..51cffcdb2d 100644 --- a/webrtc/modules/video_coding/video_coding_robustness_unittest.cc +++ b/webrtc/modules/video_coding/video_coding_robustness_unittest.cc @@ -35,7 +35,7 @@ class VCMRobustnessTest : public ::testing::Test { virtual void SetUp() { clock_.reset(new SimulatedClock(0)); ASSERT_TRUE(clock_.get() != NULL); - vcm_ = VideoCodingModule::Create(clock_.get(), &event_factory_); + vcm_.reset(VideoCodingModule::Create(clock_.get(), &event_factory_)); ASSERT_TRUE(vcm_ != NULL); const size_t kMaxNackListSize = 250; const int kMaxPacketAgeToNack = 450; @@ -47,7 +47,7 @@ class VCMRobustnessTest : public ::testing::Test { vcm_->RegisterExternalDecoder(&decoder_, video_codec_.plType); } - virtual void TearDown() { VideoCodingModule::Destroy(vcm_); } + virtual void TearDown() { vcm_.reset(); } void InsertPacket(uint32_t timestamp, uint16_t seq_no, @@ -69,7 +69,7 @@ class VCMRobustnessTest : public ::testing::Test { ASSERT_EQ(VCM_OK, vcm_->IncomingPacket(payload, kPayloadLen, rtp_info)); } - VideoCodingModule* vcm_; + rtc::scoped_ptr vcm_; VideoCodec video_codec_; MockVCMFrameTypeCallback frame_type_callback_; MockPacketRequestCallback request_callback_; diff --git a/webrtc/video/encoder_state_feedback_unittest.cc b/webrtc/video/encoder_state_feedback_unittest.cc index 8fa1c12f76..de4616f176 100644 --- a/webrtc/video/encoder_state_feedback_unittest.cc +++ b/webrtc/video/encoder_state_feedback_unittest.cc @@ -37,6 +37,7 @@ class MockVieEncoder : public ViEEncoder { nullptr, nullptr, pacer, + nullptr, nullptr) {} ~MockVieEncoder() {} diff --git a/webrtc/video/video_receive_stream.cc b/webrtc/video/video_receive_stream.cc index 7779fddd56..28fe7f3d6d 100644 --- a/webrtc/video/video_receive_stream.cc +++ b/webrtc/video/video_receive_stream.cc @@ -19,6 +19,7 @@ #include "webrtc/base/logging.h" #include "webrtc/call/congestion_controller.h" #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h" +#include "webrtc/modules/utility/include/process_thread.h" #include "webrtc/system_wrappers/include/clock.h" #include "webrtc/video/call_stats.h" #include "webrtc/video/receive_statistics_proxy.h" @@ -148,9 +149,11 @@ VideoReceiveStream::VideoReceiveStream( : transport_adapter_(config.rtcp_send_transport), encoded_frame_proxy_(config.pre_decode_callback), config_(config), + process_thread_(process_thread), clock_(Clock::GetRealTimeClock()), congestion_controller_(congestion_controller), - call_stats_(call_stats) { + call_stats_(call_stats), + vcm_(VideoCodingModule::Create(clock_, nullptr, nullptr)) { LOG(LS_INFO) << "VideoReceiveStream: " << config_.ToString(); bool send_side_bwe = @@ -160,10 +163,10 @@ VideoReceiveStream::VideoReceiveStream( congestion_controller_->GetRemoteBitrateEstimator(send_side_bwe); vie_channel_.reset(new ViEChannel( - num_cpu_cores, &transport_adapter_, process_thread, nullptr, - nullptr, nullptr, bitrate_estimator, call_stats_->rtcp_rtt_stats(), - congestion_controller_->pacer(), congestion_controller_->packet_router(), - 1, false)); + num_cpu_cores, &transport_adapter_, process_thread, nullptr, vcm_.get(), + nullptr, nullptr, nullptr, bitrate_estimator, + call_stats_->rtcp_rtt_stats(), congestion_controller_->pacer(), + congestion_controller_->packet_router(), 1, false)); RTC_CHECK(vie_channel_->Init() == 0); @@ -284,11 +287,14 @@ VideoReceiveStream::VideoReceiveStream( vie_channel_->RegisterPreDecodeImageCallback(this); vie_channel_->RegisterPreRenderCallback(this); + + process_thread_->RegisterModule(vcm_.get()); } VideoReceiveStream::~VideoReceiveStream() { LOG(LS_INFO) << "~VideoReceiveStream: " << config_.ToString(); incoming_video_stream_->Stop(); + process_thread_->DeRegisterModule(vcm_.get()); vie_channel_->RegisterPreRenderCallback(nullptr); vie_channel_->RegisterPreDecodeImageCallback(nullptr); diff --git a/webrtc/video/video_receive_stream.h b/webrtc/video/video_receive_stream.h index 0ff5269bb5..94e858a9bd 100644 --- a/webrtc/video/video_receive_stream.h +++ b/webrtc/video/video_receive_stream.h @@ -21,6 +21,7 @@ #include "webrtc/modules/video_render/video_render_defines.h" #include "webrtc/system_wrappers/include/clock.h" #include "webrtc/video/encoded_frame_callback_adapter.h" +#include "webrtc/video/payload_router.h" #include "webrtc/video/receive_statistics_proxy.h" #include "webrtc/video/vie_channel.h" #include "webrtc/video/vie_encoder.h" @@ -80,11 +81,13 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream, TransportAdapter transport_adapter_; EncodedFrameCallbackAdapter encoded_frame_proxy_; const VideoReceiveStream::Config config_; + ProcessThread* const process_thread_; Clock* const clock_; CongestionController* const congestion_controller_; CallStats* const call_stats_; + rtc::scoped_ptr vcm_; rtc::scoped_ptr incoming_video_stream_; rtc::scoped_ptr stats_proxy_; rtc::scoped_ptr vie_channel_; diff --git a/webrtc/video/video_send_stream.cc b/webrtc/video/video_send_stream.cc index 254805ff23..c7280ed40f 100644 --- a/webrtc/video/video_send_stream.cc +++ b/webrtc/video/video_send_stream.cc @@ -25,7 +25,6 @@ #include "webrtc/modules/utility/include/process_thread.h" #include "webrtc/video/call_stats.h" #include "webrtc/video/encoder_state_feedback.h" -#include "webrtc/video/payload_router.h" #include "webrtc/video/video_capture_input.h" #include "webrtc/video/vie_channel.h" #include "webrtc/video/vie_encoder.h" @@ -163,28 +162,27 @@ VideoSendStream::VideoSendStream( const std::vector& ssrcs = config.rtp.ssrcs; - vie_encoder_.reset( - new ViEEncoder(num_cpu_cores, module_process_thread_, &stats_proxy_, - config.pre_encode_callback, &overuse_detector_, - congestion_controller_->pacer(), bitrate_allocator)); + vie_encoder_.reset(new ViEEncoder( + num_cpu_cores, module_process_thread_, &stats_proxy_, + config.pre_encode_callback, &overuse_detector_, + congestion_controller_->pacer(), &payload_router_, bitrate_allocator)); + vcm_ = vie_encoder_->vcm(); RTC_CHECK(vie_encoder_->Init()); vie_channel_.reset(new ViEChannel( num_cpu_cores, config.send_transport, module_process_thread_, - encoder_feedback_->GetRtcpIntraFrameObserver(), - congestion_controller_->GetBitrateController()-> - CreateRtcpBandwidthObserver(), + &payload_router_, nullptr, encoder_feedback_->GetRtcpIntraFrameObserver(), + congestion_controller_->GetBitrateController() + ->CreateRtcpBandwidthObserver(), transport_feedback_observer, congestion_controller_->GetRemoteBitrateEstimator(false), call_stats_->rtcp_rtt_stats(), congestion_controller_->pacer(), congestion_controller_->packet_router(), ssrcs.size(), true)); RTC_CHECK(vie_channel_->Init() == 0); - call_stats_->RegisterStatsObserver(vie_channel_->GetStatsObserver()); + vcm_->RegisterProtectionCallback(vie_channel_->vcm_protection_callback()); - vie_encoder_->StartThreadsAndSetSharedMembers( - vie_channel_->send_payload_router(), - vie_channel_->vcm_protection_callback()); + call_stats_->RegisterStatsObserver(vie_channel_->GetStatsObserver()); std::vector first_ssrc(1, ssrcs[0]); vie_encoder_->SetSsrcs(first_ssrc); @@ -266,6 +264,10 @@ VideoSendStream::VideoSendStream( VideoSendStream::~VideoSendStream() { LOG(LS_INFO) << "~VideoSendStream: " << config_.ToString(); module_process_thread_->DeRegisterModule(&overuse_detector_); + // Remove vcm_protection_callback (part of vie_channel_) before destroying + // ViEChannel. vcm_ is owned by ViEEncoder and the registered callback does + // not outlive it. + vcm_->RegisterProtectionCallback(nullptr); vie_channel_->RegisterSendFrameCountObserver(nullptr); vie_channel_->RegisterSendBitrateObserver(nullptr); vie_channel_->RegisterRtcpPacketTypeCounterObserver(nullptr); @@ -287,7 +289,6 @@ VideoSendStream::~VideoSendStream() { // done before deleting the channel. congestion_controller_->RemoveEncoder(vie_encoder_.get()); encoder_feedback_->RemoveEncoder(vie_encoder_.get()); - vie_encoder_->StopThreadsAndRemoveSharedMembers(); uint32_t remote_ssrc = vie_channel_->GetRemoteSSRC(); congestion_controller_->GetRemoteBitrateEstimator(false)->RemoveStream( diff --git a/webrtc/video/video_send_stream.h b/webrtc/video/video_send_stream.h index acd36ec363..4a58e6f9ad 100644 --- a/webrtc/video/video_send_stream.h +++ b/webrtc/video/video_send_stream.h @@ -19,6 +19,7 @@ #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h" #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h" #include "webrtc/video/encoded_frame_callback_adapter.h" +#include "webrtc/video/payload_router.h" #include "webrtc/video/send_statistics_proxy.h" #include "webrtc/video/video_capture_input.h" #include "webrtc/video_receive_stream.h" @@ -88,8 +89,12 @@ class VideoSendStream : public webrtc::VideoSendStream, OveruseFrameDetector overuse_detector_; rtc::scoped_ptr input_; - rtc::scoped_ptr vie_channel_; + PayloadRouter payload_router_; rtc::scoped_ptr vie_encoder_; + rtc::scoped_ptr vie_channel_; + // TODO(pbos): Make proper const. + // const after construction. + VideoCodingModule* vcm_; rtc::scoped_ptr encoder_feedback_; // Used as a workaround to indicate that we should be using the configured diff --git a/webrtc/video/vie_channel.cc b/webrtc/video/vie_channel.cc index 28cc1d4ad7..8c67b50c9e 100644 --- a/webrtc/video/vie_channel.cc +++ b/webrtc/video/vie_channel.cc @@ -80,6 +80,8 @@ class ViEChannelProtectionCallback : public VCMProtectionCallback { ViEChannel::ViEChannel(uint32_t number_of_cores, Transport* transport, ProcessThread* module_process_thread, + PayloadRouter* send_payload_router, + VideoCodingModule* vcm, RtcpIntraFrameObserver* intra_frame_observer, RtcpBandwidthObserver* bandwidth_observer, TransportFeedbackObserver* transport_feedback_observer, @@ -92,11 +94,9 @@ ViEChannel::ViEChannel(uint32_t number_of_cores, : number_of_cores_(number_of_cores), sender_(sender), module_process_thread_(module_process_thread), - send_payload_router_(new PayloadRouter()), + send_payload_router_(send_payload_router), vcm_protection_callback_(new ViEChannelProtectionCallback(this)), - vcm_(VideoCodingModule::Create(Clock::GetRealTimeClock(), - nullptr, - nullptr)), + vcm_(vcm), vie_receiver_(vcm_, remote_bitrate_estimator, this), vie_sync_(vcm_), stats_observer_(new ChannelStatsObserver(this)), @@ -135,7 +135,14 @@ ViEChannel::ViEChannel(uint32_t number_of_cores, max_rtp_streams)), num_active_rtp_rtcp_modules_(1) { vie_receiver_.SetRtpRtcpModule(rtp_rtcp_modules_[0]); - vcm_->SetNackSettings(kMaxNackListSize, max_nack_reordering_threshold_, 0); + if (sender_) { + RTC_DCHECK(send_payload_router_); + RTC_DCHECK(!vcm_); + } else { + RTC_DCHECK(!send_payload_router_); + RTC_DCHECK(vcm_); + vcm_->SetNackSettings(kMaxNackListSize, max_nack_reordering_threshold_, 0); + } } int32_t ViEChannel::Init() { @@ -155,18 +162,16 @@ int32_t ViEChannel::Init() { std::list send_rtp_modules(1, rtp_rtcp_modules_[0]); send_payload_router_->SetSendingRtpModules(send_rtp_modules); RTC_DCHECK(!send_payload_router_->active()); + } else { + if (vcm_->RegisterReceiveCallback(this) != 0) { + return -1; + } + vcm_->RegisterFrameTypeCallback(this); + vcm_->RegisterReceiveStatisticsCallback(this); + vcm_->RegisterDecoderTimingCallback(this); + vcm_->SetRenderDelay(kDefaultRenderDelayMs); + module_process_thread_->RegisterModule(&vie_sync_); } - if (vcm_->RegisterReceiveCallback(this) != 0) { - return -1; - } - vcm_->RegisterFrameTypeCallback(this); - vcm_->RegisterReceiveStatisticsCallback(this); - vcm_->RegisterDecoderTimingCallback(this); - vcm_->SetRenderDelay(kDefaultRenderDelayMs); - - module_process_thread_->RegisterModule(vcm_); - module_process_thread_->RegisterModule(&vie_sync_); - return 0; } @@ -175,9 +180,11 @@ ViEChannel::~ViEChannel() { // 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_); - send_payload_router_->SetSendingRtpModules(std::list()); + if (sender_) { + send_payload_router_->SetSendingRtpModules(std::list()); + } else { + module_process_thread_->DeRegisterModule(&vie_sync_); + } for (size_t i = 0; i < num_active_rtp_rtcp_modules_; ++i) packet_router_->RemoveRtpModule(rtp_rtcp_modules_[i], sender_); for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { @@ -186,8 +193,6 @@ ViEChannel::~ViEChannel() { } if (!sender_) StopDecodeThread(); - // Release modules. - VideoCodingModule::Destroy(vcm_); } void ViEChannel::UpdateHistograms() { @@ -441,15 +446,8 @@ int32_t ViEChannel::ReceiveCodecStatistics(uint32_t* num_key_frames, return 0; } -uint32_t ViEChannel::DiscardedPackets() const { - return vcm_->DiscardedPackets(); -} - -int ViEChannel::ReceiveDelay() const { - return vcm_->Delay(); -} - void ViEChannel::SetExpectedRenderDelay(int delay_ms) { + RTC_DCHECK(!sender_); vcm_->SetRenderDelay(delay_ms); } @@ -483,7 +481,8 @@ void ViEChannel::SetProtectionMode(bool enable_nack, protection_method = kProtectionNone; } - vcm_->SetVideoProtection(protection_method, true); + if (!sender_) + vcm_->SetVideoProtection(protection_method, true); // Set NACK. ProcessNACKRequest(enable_nack); @@ -506,19 +505,21 @@ void ViEChannel::ProcessNACKRequest(const bool enable) { for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) rtp_rtcp->SetStorePacketsStatus(true, nack_history_size_sender_); - vcm_->RegisterPacketRequestCallback(this); - // Don't introduce errors when NACK is enabled. - vcm_->SetDecodeErrorMode(kNoErrors); + if (!sender_) { + vcm_->RegisterPacketRequestCallback(this); + // Don't introduce errors when NACK is enabled. + vcm_->SetDecodeErrorMode(kNoErrors); + } } else { - vcm_->RegisterPacketRequestCallback(NULL); - if (paced_sender_ == nullptr) { + if (!sender_) { + vcm_->RegisterPacketRequestCallback(nullptr); for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) rtp_rtcp->SetStorePacketsStatus(false, 0); + // When NACK is off, allow decoding with errors. Otherwise, the video + // will freeze, and will only recover with a complete key frame. + vcm_->SetDecodeErrorMode(kWithErrors); } vie_receiver_.SetNackStatus(false, max_nack_reordering_threshold_); - // When NACK is off, allow decoding with errors. Otherwise, the video - // will freeze, and will only recover with a complete key frame. - vcm_->SetDecodeErrorMode(kWithErrors); } } @@ -880,15 +881,18 @@ int32_t ViEChannel::StartSend() { for (size_t i = 0; i < num_active_rtp_rtcp_modules_; ++i) { RtpRtcp* rtp_rtcp = rtp_rtcp_modules_[i]; - rtp_rtcp->SetSendingMediaStatus(true); + // Only have senders send media. + rtp_rtcp->SetSendingMediaStatus(sender_); rtp_rtcp->SetSendingStatus(true); } - send_payload_router_->set_active(true); + if (sender_) + send_payload_router_->set_active(true); return 0; } int32_t ViEChannel::StopSend() { - send_payload_router_->set_active(false); + if (sender_) + send_payload_router_->set_active(false); for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) rtp_rtcp->SetSendingMediaStatus(false); @@ -940,10 +944,6 @@ RtpRtcp* ViEChannel::rtp_rtcp() { return rtp_rtcp_modules_[0]; } -rtc::scoped_refptr ViEChannel::send_payload_router() { - return send_payload_router_; -} - VCMProtectionCallback* ViEChannel::vcm_protection_callback() { return vcm_protection_callback_.get(); } @@ -1038,12 +1038,14 @@ bool ViEChannel::ChannelDecodeThreadFunction(void* obj) { } bool ViEChannel::ChannelDecodeProcess() { + RTC_DCHECK(!sender_); vcm_->Decode(kMaxDecodeWaitTimeMs); return true; } void ViEChannel::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) { - vcm_->SetReceiveChannelParameters(max_rtt_ms); + if (!sender_) + vcm_->SetReceiveChannelParameters(max_rtt_ms); rtc::CritScope lock(&crit_); if (time_of_first_rtt_ms_ == -1) @@ -1137,6 +1139,7 @@ void ViEChannel::StartDecodeThread() { } void ViEChannel::StopDecodeThread() { + RTC_DCHECK(!sender_); vcm_->TriggerDecoderShutdown(); decode_thread_.Stop(); @@ -1144,12 +1147,14 @@ void ViEChannel::StopDecodeThread() { int32_t ViEChannel::SetVoiceChannel(int32_t ve_channel_id, VoEVideoSync* ve_sync_interface) { + RTC_DCHECK(!sender_); return vie_sync_.ConfigureSync(ve_channel_id, ve_sync_interface, rtp_rtcp_modules_[0], vie_receiver_.GetRtpReceiver()); } int32_t ViEChannel::VoiceChannel() { + RTC_DCHECK(!sender_); return vie_sync_.VoiceChannel(); } @@ -1161,6 +1166,7 @@ void ViEChannel::RegisterPreRenderCallback( void ViEChannel::RegisterPreDecodeImageCallback( EncodedImageCallback* pre_decode_callback) { + RTC_DCHECK(!sender_); vcm_->RegisterPreDecodeImageCallback(pre_decode_callback); } diff --git a/webrtc/video/vie_channel.h b/webrtc/video/vie_channel.h index 9f5e1ff90d..3c00749e72 100644 --- a/webrtc/video/vie_channel.h +++ b/webrtc/video/vie_channel.h @@ -68,6 +68,8 @@ class ViEChannel : public VCMFrameTypeCallback, ViEChannel(uint32_t number_of_cores, Transport* transport, ProcessThread* module_process_thread, + PayloadRouter* send_payload_router, + VideoCodingModule* vcm, RtcpIntraFrameObserver* intra_frame_observer, RtcpBandwidthObserver* bandwidth_observer, TransportFeedbackObserver* transport_feedback_observer, @@ -89,11 +91,6 @@ class ViEChannel : public VCMFrameTypeCallback, void RegisterExternalDecoder(const uint8_t pl_type, VideoDecoder* decoder); int32_t ReceiveCodecStatistics(uint32_t* num_key_frames, uint32_t* num_delta_frames); - uint32_t DiscardedPackets() const; - - // Returns the estimated delay in milliseconds. - int ReceiveDelay() const; - void SetExpectedRenderDelay(int delay_ms); void SetRTCPMode(const RtcpMode rtcp_mode); @@ -214,7 +211,6 @@ class ViEChannel : public VCMFrameTypeCallback, // Gets the modules used by the channel. RtpRtcp* rtp_rtcp(); - rtc::scoped_refptr send_payload_router(); VCMProtectionCallback* vcm_protection_callback(); @@ -401,12 +397,12 @@ class ViEChannel : public VCMFrameTypeCallback, const bool sender_; ProcessThread* const module_process_thread_; + PayloadRouter* const send_payload_router_; // Used for all registered callbacks except rendering. rtc::CriticalSection crit_; // Owned modules/classes. - rtc::scoped_refptr send_payload_router_; rtc::scoped_ptr vcm_protection_callback_; VideoCodingModule* const vcm_; diff --git a/webrtc/video/vie_encoder.cc b/webrtc/video/vie_encoder.cc index a9b2abbcab..20cfaffb62 100644 --- a/webrtc/video/vie_encoder.cc +++ b/webrtc/video/vie_encoder.cc @@ -110,6 +110,7 @@ ViEEncoder::ViEEncoder(uint32_t number_of_cores, I420FrameCallback* pre_encode_callback, OveruseFrameDetector* overuse_detector, PacedSender* pacer, + PayloadRouter* payload_router, BitrateAllocator* bitrate_allocator) : number_of_cores_(number_of_cores), vp_(VideoProcessing::Create()), @@ -117,11 +118,11 @@ ViEEncoder::ViEEncoder(uint32_t number_of_cores, vcm_(VideoCodingModule::Create(Clock::GetRealTimeClock(), this, qm_callback_.get())), - send_payload_router_(NULL), stats_proxy_(stats_proxy), pre_encode_callback_(pre_encode_callback), overuse_detector_(overuse_detector), pacer_(pacer), + send_payload_router_(payload_router), bitrate_allocator_(bitrate_allocator), time_of_last_frame_activity_ms_(0), encoder_config_(), @@ -138,6 +139,7 @@ ViEEncoder::ViEEncoder(uint32_t number_of_cores, picture_id_rpsi_(0), video_suspended_(false) { bitrate_observer_.reset(new ViEBitrateObserver(this)); + module_process_thread_->RegisterModule(vcm_.get()); } bool ViEEncoder::Init() { @@ -155,23 +157,14 @@ bool ViEEncoder::Init() { return true; } -void ViEEncoder::StartThreadsAndSetSharedMembers( - rtc::scoped_refptr send_payload_router, - VCMProtectionCallback* vcm_protection_callback) { - RTC_DCHECK(send_payload_router_ == NULL); - - send_payload_router_ = send_payload_router; - vcm_->RegisterProtectionCallback(vcm_protection_callback); - module_process_thread_->RegisterModule(vcm_.get()); -} - -void ViEEncoder::StopThreadsAndRemoveSharedMembers() { - if (bitrate_allocator_) - bitrate_allocator_->RemoveBitrateObserver(bitrate_observer_.get()); - module_process_thread_->DeRegisterModule(vcm_.get()); +VideoCodingModule* ViEEncoder::vcm() const { + return vcm_.get(); } ViEEncoder::~ViEEncoder() { + module_process_thread_->DeRegisterModule(vcm_.get()); + if (bitrate_allocator_) + bitrate_allocator_->RemoveBitrateObserver(bitrate_observer_.get()); } void ViEEncoder::SetNetworkTransmissionState(bool is_transmitting) { @@ -338,7 +331,6 @@ void ViEEncoder::TraceFrameDropEnd() { } void ViEEncoder::DeliverFrame(VideoFrame video_frame) { - RTC_DCHECK(send_payload_router_ != NULL); if (!send_payload_router_->active()) { // We've paused or we have no channels attached, don't waste resources on // encoding. diff --git a/webrtc/video/vie_encoder.h b/webrtc/video/vie_encoder.h index b8944dc6f8..22457ef429 100644 --- a/webrtc/video/vie_encoder.h +++ b/webrtc/video/vie_encoder.h @@ -57,22 +57,13 @@ class ViEEncoder : public RtcpIntraFrameObserver, I420FrameCallback* pre_encode_callback, OveruseFrameDetector* overuse_detector, PacedSender* pacer, + PayloadRouter* payload_router, BitrateAllocator* bitrate_allocator); ~ViEEncoder(); bool Init(); - // This function is assumed to be called before any frames are delivered and - // only once. - // Ideally this would be done in Init, but the dependencies between ViEEncoder - // and ViEChannel makes it really hard to do in a good way. - void StartThreadsAndSetSharedMembers( - rtc::scoped_refptr send_payload_router, - VCMProtectionCallback* vcm_protection_callback); - - // This function must be called before the corresponding ViEChannel is - // deleted. - void StopThreadsAndRemoveSharedMembers(); + VideoCodingModule* vcm() const; void SetNetworkTransmissionState(bool is_transmitting); @@ -158,7 +149,6 @@ class ViEEncoder : public RtcpIntraFrameObserver, const rtc::scoped_ptr vp_; const rtc::scoped_ptr qm_callback_; const rtc::scoped_ptr vcm_; - rtc::scoped_refptr send_payload_router_; rtc::CriticalSection data_cs_; rtc::scoped_ptr bitrate_observer_; @@ -167,6 +157,7 @@ class ViEEncoder : public RtcpIntraFrameObserver, I420FrameCallback* const pre_encode_callback_; OveruseFrameDetector* const overuse_detector_; PacedSender* const pacer_; + PayloadRouter* const send_payload_router_; BitrateAllocator* const bitrate_allocator_; // The time we last received an input frame or encoded frame. This is used to diff --git a/webrtc/video/vie_receiver.cc b/webrtc/video/vie_receiver.cc index a8719ed3ea..d61eca44a6 100644 --- a/webrtc/video/vie_receiver.cc +++ b/webrtc/video/vie_receiver.cc @@ -232,6 +232,7 @@ int ViEReceiver::ReceivedRTCPPacket(const void* rtcp_packet, int32_t ViEReceiver::OnReceivedPayloadData(const uint8_t* payload_data, const size_t payload_size, const WebRtcRTPHeader* rtp_header) { + RTC_DCHECK(vcm_); WebRtcRTPHeader rtp_header_with_ntp = *rtp_header; rtp_header_with_ntp.ntp_time_ms = ntp_estimator_->Estimate(rtp_header->header.timestamp);