diff --git a/webrtc/modules/video_coding/receiver.cc b/webrtc/modules/video_coding/receiver.cc index a02fd01de6..abe8ede76c 100644 --- a/webrtc/modules/video_coding/receiver.cc +++ b/webrtc/modules/video_coding/receiver.cc @@ -42,12 +42,17 @@ VCMReceiver::VCMReceiver(VCMTiming* timing, EventFactory* event_factory, NackSender* nack_sender, KeyFrameRequestSender* keyframe_request_sender) - : VCMReceiver(timing, - clock, - std::unique_ptr(event_factory->CreateEvent()), - std::unique_ptr(event_factory->CreateEvent()), - nack_sender, - keyframe_request_sender) {} + : VCMReceiver( + timing, + clock, + std::unique_ptr(event_factory + ? event_factory->CreateEvent() + : EventWrapper::Create()), + std::unique_ptr(event_factory + ? event_factory->CreateEvent() + : EventWrapper::Create()), + nack_sender, + keyframe_request_sender) {} VCMReceiver::VCMReceiver(VCMTiming* timing, Clock* clock, diff --git a/webrtc/modules/video_coding/video_coding_impl.cc b/webrtc/modules/video_coding/video_coding_impl.cc index a9a4724ecf..5e9b0d4230 100644 --- a/webrtc/modules/video_coding/video_coding_impl.cc +++ b/webrtc/modules/video_coding/video_coding_impl.cc @@ -73,7 +73,6 @@ class VideoCodingModuleImpl : public VideoCodingModule { public: VideoCodingModuleImpl(Clock* clock, EventFactory* event_factory, - bool owns_event_factory, VideoEncoderRateObserver* encoder_rate_observer, VCMQMSettingsCallback* qm_settings_callback, NackSender* nack_sender, @@ -88,10 +87,9 @@ class VideoCodingModuleImpl : public VideoCodingModule { event_factory, pre_decode_image_callback, nack_sender, - keyframe_request_sender), - own_event_factory_(owns_event_factory ? event_factory : NULL) {} + keyframe_request_sender) {} - virtual ~VideoCodingModuleImpl() { own_event_factory_.reset(); } + virtual ~VideoCodingModuleImpl() {} int64_t TimeUntilNextProcess() override { int64_t sender_time = sender_.TimeUntilNextProcess(); @@ -286,7 +284,6 @@ class VideoCodingModuleImpl : public VideoCodingModule { EncodedImageCallbackWrapper post_encode_callback_; vcm::VideoSender sender_; vcm::VideoReceiver receiver_; - std::unique_ptr own_event_factory_; }; } // namespace @@ -315,10 +312,9 @@ VideoCodingModule* VideoCodingModule::Create( NackSender* nack_sender, KeyFrameRequestSender* keyframe_request_sender, EncodedImageCallback* pre_decode_image_callback) { - return new VideoCodingModuleImpl(clock, new EventFactoryImpl, true, - encoder_rate_observer, qm_settings_callback, - nack_sender, keyframe_request_sender, - pre_decode_image_callback); + return new VideoCodingModuleImpl( + clock, nullptr, encoder_rate_observer, qm_settings_callback, nack_sender, + keyframe_request_sender, pre_decode_image_callback); } // Create method for current interface, will be removed when the @@ -338,9 +334,9 @@ VideoCodingModule* VideoCodingModule::Create( KeyFrameRequestSender* keyframe_request_sender) { assert(clock); assert(event_factory); - return new VideoCodingModuleImpl(clock, event_factory, false, nullptr, - nullptr, nack_sender, - keyframe_request_sender, nullptr); + return new VideoCodingModuleImpl(clock, event_factory, nullptr, nullptr, + nack_sender, keyframe_request_sender, + nullptr); } } // namespace webrtc diff --git a/webrtc/modules/video_coding/video_coding_impl.h b/webrtc/modules/video_coding/video_coding_impl.h index e3184a83ec..f449632ac1 100644 --- a/webrtc/modules/video_coding/video_coding_impl.h +++ b/webrtc/modules/video_coding/video_coding_impl.h @@ -128,7 +128,7 @@ class VideoSender : public Module { std::vector next_frame_types_ GUARDED_BY(params_crit_); }; -class VideoReceiver { +class VideoReceiver : public Module { public: typedef VideoCodingModule::ReceiverRobustness ReceiverRobustness; @@ -179,8 +179,8 @@ class VideoReceiver { int32_t SetReceiveChannelParameters(int64_t rtt); int32_t SetVideoProtection(VCMVideoProtection videoProtection, bool enable); - int64_t TimeUntilNextProcess(); - void Process(); + int64_t TimeUntilNextProcess() override; + void Process() override; void TriggerDecoderShutdown(); diff --git a/webrtc/video/video_receive_stream.cc b/webrtc/video/video_receive_stream.cc index 2af1d891aa..fc98c582e1 100644 --- a/webrtc/video/video_receive_stream.cc +++ b/webrtc/video/video_receive_stream.cc @@ -162,24 +162,19 @@ VideoReceiveStream::VideoReceiveStream( congestion_controller_(congestion_controller), call_stats_(call_stats), remb_(remb), - vcm_(VideoCodingModule::Create(clock_, - nullptr, - nullptr, - this, - this, - this)), + video_receiver_(clock_, nullptr, this, this, this), incoming_video_stream_(0, config.disable_prerenderer_smoothing), stats_proxy_(config_, clock_), vie_channel_(&transport_adapter_, process_thread, - vcm_.get(), + &video_receiver_, congestion_controller_->GetRemoteBitrateEstimator( UseSendSideBwe(config_)), call_stats_->rtcp_rtt_stats(), congestion_controller_->pacer(), congestion_controller_->packet_router()), vie_receiver_(vie_channel_.vie_receiver()), - vie_sync_(vcm_.get()), + vie_sync_(&video_receiver_), rtp_rtcp_(vie_channel_.rtp_rtcp()) { LOG(LS_INFO) << "VideoReceiveStream: " << config_.ToString(); @@ -277,22 +272,23 @@ VideoReceiveStream::VideoReceiveStream( << "Duplicate payload type (" << decoder.payload_type << ") for different decoders."; decoder_payload_types.insert(decoder.payload_type); - vcm_->RegisterExternalDecoder(decoder.decoder, decoder.payload_type); + video_receiver_.RegisterExternalDecoder(decoder.decoder, + decoder.payload_type); VideoCodec codec = CreateDecoderVideoCodec(decoder); RTC_CHECK(vie_receiver_->SetReceiveCodec(codec)); - RTC_CHECK_EQ(VCM_OK, - vcm_->RegisterReceiveCodec(&codec, num_cpu_cores, false)); + RTC_CHECK_EQ(VCM_OK, video_receiver_.RegisterReceiveCodec( + &codec, num_cpu_cores, false)); } - vcm_->SetRenderDelay(config.render_delay_ms); + video_receiver_.SetRenderDelay(config.render_delay_ms); incoming_video_stream_.SetExpectedRenderDelay(config.render_delay_ms); incoming_video_stream_.SetExternalCallback(this); vie_channel_.SetIncomingVideoStream(&incoming_video_stream_); vie_channel_.RegisterPreRenderCallback(this); - process_thread_->RegisterModule(vcm_.get()); + process_thread_->RegisterModule(&video_receiver_); process_thread_->RegisterModule(&vie_sync_); } @@ -301,14 +297,14 @@ VideoReceiveStream::~VideoReceiveStream() { Stop(); process_thread_->DeRegisterModule(&vie_sync_); - process_thread_->DeRegisterModule(vcm_.get()); + process_thread_->DeRegisterModule(&video_receiver_); // Deregister external decoders so that they are no longer running during // destruction. This effectively stops the VCM since the decoder thread is // stopped, the VCM is deregistered and no asynchronous decoder threads are // running. for (const Decoder& decoder : config_.decoders) - vcm_->RegisterExternalDecoder(nullptr, decoder.payload_type); + video_receiver_.RegisterExternalDecoder(nullptr, decoder.payload_type); vie_channel_.RegisterPreRenderCallback(nullptr); @@ -334,7 +330,7 @@ void VideoReceiveStream::Start() { void VideoReceiveStream::Stop() { incoming_video_stream_.Stop(); vie_receiver_->StopReceive(); - vcm_->TriggerDecoderShutdown(); + video_receiver_.TriggerDecoderShutdown(); decode_thread_.Stop(); transport_adapter_.Disable(); } @@ -431,7 +427,7 @@ bool VideoReceiveStream::DecodeThreadFunction(void* ptr) { void VideoReceiveStream::Decode() { static const int kMaxDecodeWaitTimeMs = 50; - vcm_->Decode(kMaxDecodeWaitTimeMs); + video_receiver_.Decode(kMaxDecodeWaitTimeMs); } void VideoReceiveStream::SendNack( diff --git a/webrtc/video/video_receive_stream.h b/webrtc/video/video_receive_stream.h index d507a9b4e6..316e281fcc 100644 --- a/webrtc/video/video_receive_stream.h +++ b/webrtc/video/video_receive_stream.h @@ -19,6 +19,7 @@ #include "webrtc/common_video/include/incoming_video_stream.h" #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h" #include "webrtc/modules/video_render/video_render_defines.h" +#include "webrtc/modules/video_coding/video_coding_impl.h" #include "webrtc/system_wrappers/include/clock.h" #include "webrtc/video/encoded_frame_callback_adapter.h" #include "webrtc/video/receive_statistics_proxy.h" @@ -104,7 +105,7 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream, CallStats* const call_stats_; VieRemb* const remb_; - std::unique_ptr vcm_; + vcm::VideoReceiver video_receiver_; IncomingVideoStream incoming_video_stream_; ReceiveStatisticsProxy stats_proxy_; ViEChannel vie_channel_; diff --git a/webrtc/video/vie_channel.cc b/webrtc/video/vie_channel.cc index 108d409ce4..5416e39472 100644 --- a/webrtc/video/vie_channel.cc +++ b/webrtc/video/vie_channel.cc @@ -25,7 +25,7 @@ #include "webrtc/modules/rtp_rtcp/include/rtp_receiver.h" #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h" #include "webrtc/modules/utility/include/process_thread.h" -#include "webrtc/modules/video_coding/include/video_coding.h" +#include "webrtc/modules/video_coding/video_coding_impl.h" #include "webrtc/modules/video_processing/include/video_processing.h" #include "webrtc/modules/video_render/video_render_defines.h" #include "webrtc/system_wrappers/include/metrics.h" @@ -93,14 +93,14 @@ class ChannelStatsObserver : public CallStatsObserver { ViEChannel::ViEChannel(Transport* transport, ProcessThread* module_process_thread, - VideoCodingModule* vcm, + vcm::VideoReceiver* video_receiver, RemoteBitrateEstimator* remote_bitrate_estimator, RtcpRttStats* rtt_stats, PacedSender* paced_sender, PacketRouter* packet_router) : module_process_thread_(module_process_thread), - vcm_(vcm), - vie_receiver_(vcm_, remote_bitrate_estimator, this), + video_receiver_(video_receiver), + vie_receiver_(video_receiver_, remote_bitrate_estimator, this), stats_observer_(new ChannelStatsObserver(this)), receive_stats_callback_(nullptr), incoming_video_stream_(nullptr), @@ -118,8 +118,9 @@ ViEChannel::ViEChannel(Transport* transport, paced_sender_, packet_router_)) { vie_receiver_.Init(rtp_rtcp_.get()); - RTC_DCHECK(vcm_); - vcm_->SetNackSettings(kMaxNackListSize, max_nack_reordering_threshold_, 0); + RTC_DCHECK(video_receiver_); + video_receiver_->SetNackSettings(kMaxNackListSize, + max_nack_reordering_threshold_, 0); } int32_t ViEChannel::Init() { @@ -131,13 +132,13 @@ int32_t ViEChannel::Init() { packet_router_->AddRtpModule(rtp_rtcp_.get()); rtp_rtcp_->SetKeyFrameRequestMethod(kKeyFrameReqPliRtcp); - if (vcm_->RegisterReceiveCallback(this) != 0) { + if (video_receiver_->RegisterReceiveCallback(this) != 0) { return -1; } - vcm_->RegisterFrameTypeCallback(this); - vcm_->RegisterReceiveStatisticsCallback(this); - vcm_->RegisterDecoderTimingCallback(this); - vcm_->SetRenderDelay(kDefaultRenderDelayMs); + video_receiver_->RegisterFrameTypeCallback(this); + video_receiver_->RegisterReceiveStatisticsCallback(this); + video_receiver_->RegisterDecoderTimingCallback(this); + video_receiver_->SetRenderDelay(kDefaultRenderDelayMs); return 0; } @@ -178,7 +179,7 @@ void ViEChannel::SetProtectionMode(bool enable_nack, protection_method = kProtectionNone; } - vcm_->SetVideoProtection(protection_method, true); + video_receiver_->SetVideoProtection(protection_method, true); // Set NACK. ProcessNACKRequest(enable_nack); @@ -195,15 +196,15 @@ void ViEChannel::ProcessNACKRequest(const bool enable) { if (rtp_rtcp_->RTCP() == RtcpMode::kOff) return; vie_receiver_.SetNackStatus(true, max_nack_reordering_threshold_); - vcm_->RegisterPacketRequestCallback(this); + video_receiver_->RegisterPacketRequestCallback(this); // Don't introduce errors when NACK is enabled. - vcm_->SetDecodeErrorMode(kNoErrors); + video_receiver_->SetDecodeErrorMode(kNoErrors); } else { - vcm_->RegisterPacketRequestCallback(nullptr); + video_receiver_->RegisterPacketRequestCallback(nullptr); // 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); + video_receiver_->SetDecodeErrorMode(kWithErrors); vie_receiver_.SetNackStatus(false, max_nack_reordering_threshold_); } } @@ -238,10 +239,10 @@ CallStatsObserver* ViEChannel::GetStatsObserver() { return stats_observer_.get(); } -// Do not acquire the lock of |vcm_| in this function. Decode callback won't -// necessarily be called from the decoding thread. The decoding thread may have -// held the lock when calling VideoDecoder::Decode, Reset, or Release. Acquiring -// the same lock in the path of decode callback can deadlock. +// Do not acquire the lock of |video_receiver_| in this function. Decode +// callback won't necessarily be called from the decoding thread. The decoding +// thread may have held the lock when calling VideoDecoder::Decode, Reset, or +// Release. Acquiring the same lock in the path of decode callback can deadlock. int32_t ViEChannel::FrameToRender(VideoFrame& video_frame) { // NOLINT rtc::CritScope lock(&crit_); @@ -320,7 +321,7 @@ int32_t ViEChannel::ResendPackets(const uint16_t* sequence_numbers, } void ViEChannel::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) { - vcm_->SetReceiveChannelParameters(max_rtt_ms); + video_receiver_->SetReceiveChannelParameters(max_rtt_ms); rtc::CritScope lock(&crit_); last_rtt_ms_ = avg_rtt_ms; diff --git a/webrtc/video/vie_channel.h b/webrtc/video/vie_channel.h index 1bcae198c0..98c3f85b4c 100644 --- a/webrtc/video/vie_channel.h +++ b/webrtc/video/vie_channel.h @@ -43,10 +43,13 @@ class ProcessThread; class ReceiveStatisticsProxy; class RtcpRttStats; class ViERTPObserver; -class VideoCodingModule; class VideoRenderCallback; class VoEVideoSync; +namespace vcm { +class VideoReceiver; +} // namespace vcm + enum StreamType { kViEStreamTypeNormal = 0, // Normal media stream kViEStreamTypeRtx = 1 // Retransmission media stream @@ -63,7 +66,7 @@ class ViEChannel : public VCMFrameTypeCallback, ViEChannel(Transport* transport, ProcessThread* module_process_thread, - VideoCodingModule* vcm, + vcm::VideoReceiver* video_receiver, RemoteBitrateEstimator* remote_bitrate_estimator, RtcpRttStats* rtt_stats, PacedSender* paced_sender, @@ -196,7 +199,7 @@ class ViEChannel : public VCMFrameTypeCallback, // Used for all registered callbacks except rendering. rtc::CriticalSection crit_; - VideoCodingModule* const vcm_; + vcm::VideoReceiver* const video_receiver_; ViEReceiver vie_receiver_; // Helper to report call statistics. diff --git a/webrtc/video/vie_encoder.h b/webrtc/video/vie_encoder.h index 02fec6292a..d3ac0f945f 100644 --- a/webrtc/video/vie_encoder.h +++ b/webrtc/video/vie_encoder.h @@ -39,7 +39,6 @@ class QMVideoSettingsCallback; class SendStatisticsProxy; class ViEBitrateObserver; class ViEEffectFilter; -class VideoCodingModule; class VideoEncoder; class ViEEncoder : public VideoEncoderRateObserver, diff --git a/webrtc/video/vie_receiver.cc b/webrtc/video/vie_receiver.cc index 9ead910f5c..d6a5aa506e 100644 --- a/webrtc/video/vie_receiver.cc +++ b/webrtc/video/vie_receiver.cc @@ -21,7 +21,7 @@ #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h" #include "webrtc/modules/rtp_rtcp/include/rtp_receiver.h" #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h" -#include "webrtc/modules/video_coding/include/video_coding.h" +#include "webrtc/modules/video_coding/video_coding_impl.h" #include "webrtc/system_wrappers/include/metrics.h" #include "webrtc/system_wrappers/include/tick_util.h" #include "webrtc/system_wrappers/include/timestamp_extrapolator.h" @@ -31,11 +31,11 @@ namespace webrtc { static const int kPacketLogIntervalMs = 10000; -ViEReceiver::ViEReceiver(VideoCodingModule* module_vcm, +ViEReceiver::ViEReceiver(vcm::VideoReceiver* video_receiver, RemoteBitrateEstimator* remote_bitrate_estimator, RtpFeedback* rtp_feedback) : clock_(Clock::GetRealTimeClock()), - vcm_(module_vcm), + video_receiver_(video_receiver), remote_bitrate_estimator_(remote_bitrate_estimator), ntp_estimator_(clock_), rtp_payload_registry_(RTPPayloadStrategy::CreateStrategy(false)), @@ -142,13 +142,12 @@ void ViEReceiver::EnableReceiveRtpHeaderExtension(const std::string& extension, int32_t ViEReceiver::OnReceivedPayloadData(const uint8_t* payload_data, const size_t payload_size, const WebRtcRTPHeader* rtp_header) { - RTC_DCHECK(vcm_); + RTC_DCHECK(video_receiver_); WebRtcRTPHeader rtp_header_with_ntp = *rtp_header; rtp_header_with_ntp.ntp_time_ms = ntp_estimator_.Estimate(rtp_header->header.timestamp); - if (vcm_->IncomingPacket(payload_data, - payload_size, - rtp_header_with_ntp) != 0) { + if (video_receiver_->IncomingPacket(payload_data, payload_size, + rtp_header_with_ntp) != 0) { // Check this... return -1; } @@ -249,7 +248,8 @@ bool ViEReceiver::ParseAndHandleEncapsulatingHeader(const uint8_t* packet, int8_t ulpfec_pt = rtp_payload_registry_.ulpfec_payload_type(); if (packet[header.headerLength] == ulpfec_pt) { rtp_receive_statistics_->FecPacketReceived(header, packet_length); - // Notify vcm about received FEC packets to avoid NACKing these packets. + // Notify video_receiver about received FEC packets to avoid NACKing these + // packets. NotifyReceiverOfFecPacket(header); } if (fec_receiver_->AddReceivedRedPacket( diff --git a/webrtc/video/vie_receiver.h b/webrtc/video/vie_receiver.h index c96bf5e107..97a0fe4993 100644 --- a/webrtc/video/vie_receiver.h +++ b/webrtc/video/vie_receiver.h @@ -34,11 +34,14 @@ class RtpHeaderParser; class RTPPayloadRegistry; class RtpReceiver; class RtpRtcp; -class VideoCodingModule; + +namespace vcm { +class VideoReceiver; +} // namespace vcm class ViEReceiver : public RtpData { public: - ViEReceiver(VideoCodingModule* module_vcm, + ViEReceiver(vcm::VideoReceiver* video_receiver, RemoteBitrateEstimator* remote_bitrate_estimator, RtpFeedback* rtp_feedback); ~ViEReceiver(); @@ -98,7 +101,7 @@ class ViEReceiver : public RtpData { void UpdateHistograms(); Clock* const clock_; - VideoCodingModule* const vcm_; + vcm::VideoReceiver* const video_receiver_; RemoteBitrateEstimator* const remote_bitrate_estimator_; // TODO(pbos): Make const and set on construction. diff --git a/webrtc/video/vie_sync_module.cc b/webrtc/video/vie_sync_module.cc index af57ab4b76..02a82de4bb 100644 --- a/webrtc/video/vie_sync_module.cc +++ b/webrtc/video/vie_sync_module.cc @@ -15,7 +15,7 @@ #include "webrtc/base/trace_event.h" #include "webrtc/modules/rtp_rtcp/include/rtp_receiver.h" #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h" -#include "webrtc/modules/video_coding/include/video_coding.h" +#include "webrtc/modules/video_coding/video_coding_impl.h" #include "webrtc/system_wrappers/include/clock.h" #include "webrtc/video/stream_synchronization.h" #include "webrtc/video_frame.h" @@ -48,10 +48,10 @@ int UpdateMeasurements(StreamSynchronization::Measurements* stream, } } // namespace -ViESyncModule::ViESyncModule(VideoCodingModule* vcm) - : vcm_(vcm), +ViESyncModule::ViESyncModule(vcm::VideoReceiver* video_receiver) + : video_receiver_(video_receiver), clock_(Clock::GetRealTimeClock()), - video_receiver_(nullptr), + rtp_receiver_(nullptr), video_rtp_rtcp_(nullptr), voe_channel_id_(-1), voe_sync_interface_(nullptr), @@ -64,20 +64,19 @@ ViESyncModule::~ViESyncModule() { void ViESyncModule::ConfigureSync(int voe_channel_id, VoEVideoSync* voe_sync_interface, RtpRtcp* video_rtcp_module, - RtpReceiver* video_receiver) { + RtpReceiver* rtp_receiver) { if (voe_channel_id != -1) RTC_DCHECK(voe_sync_interface); rtc::CritScope lock(&data_cs_); // Prevent expensive no-ops. if (voe_channel_id_ == voe_channel_id && voe_sync_interface_ == voe_sync_interface && - video_receiver_ == video_receiver && - video_rtp_rtcp_ == video_rtcp_module) { + rtp_receiver_ == rtp_receiver && video_rtp_rtcp_ == video_rtcp_module) { return; } voe_channel_id_ = voe_channel_id; voe_sync_interface_ = voe_sync_interface; - video_receiver_ = video_receiver; + rtp_receiver_ = rtp_receiver; video_rtp_rtcp_ = video_rtcp_module; sync_.reset( new StreamSynchronization(video_rtp_rtcp_->SSRC(), voe_channel_id)); @@ -92,7 +91,7 @@ void ViESyncModule::Process() { rtc::CritScope lock(&data_cs_); last_sync_time_ = TickTime::Now(); - const int current_video_delay_ms = vcm_->Delay(); + const int current_video_delay_ms = video_receiver_->Delay(); if (voe_channel_id_ == -1) { return; @@ -120,7 +119,7 @@ void ViESyncModule::Process() { assert(voice_receiver); if (UpdateMeasurements(&video_measurement_, *video_rtp_rtcp_, - *video_receiver_) != 0) { + *rtp_receiver_) != 0) { return; } @@ -154,7 +153,7 @@ void ViESyncModule::Process() { voe_channel_id_, target_audio_delay_ms) == -1) { LOG(LS_ERROR) << "Error setting voice delay."; } - vcm_->SetMinimumPlayoutDelay(target_video_delay_ms); + video_receiver_->SetMinimumPlayoutDelay(target_video_delay_ms); } bool ViESyncModule::GetStreamSyncOffsetInMs(const VideoFrame& frame, diff --git a/webrtc/video/vie_sync_module.h b/webrtc/video/vie_sync_module.h index 2b499ff4d3..8a1933b7ea 100644 --- a/webrtc/video/vie_sync_module.h +++ b/webrtc/video/vie_sync_module.h @@ -26,20 +26,23 @@ namespace webrtc { class Clock; class RtpRtcp; -class VideoCodingModule; class VideoFrame; class ViEChannel; class VoEVideoSync; +namespace vcm { +class VideoReceiver; +} // namespace vcm + class ViESyncModule : public Module { public: - explicit ViESyncModule(VideoCodingModule* vcm); + explicit ViESyncModule(vcm::VideoReceiver* vcm); ~ViESyncModule(); void ConfigureSync(int voe_channel_id, VoEVideoSync* voe_sync_interface, RtpRtcp* video_rtcp_module, - RtpReceiver* video_receiver); + RtpReceiver* rtp_receiver); // Implements Module. int64_t TimeUntilNextProcess() override; @@ -52,9 +55,9 @@ class ViESyncModule : public Module { private: rtc::CriticalSection data_cs_; - VideoCodingModule* const vcm_; + vcm::VideoReceiver* const video_receiver_; Clock* const clock_; - RtpReceiver* video_receiver_; + RtpReceiver* rtp_receiver_; RtpRtcp* video_rtp_rtcp_; int voe_channel_id_; VoEVideoSync* voe_sync_interface_;