zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use vcm::VideoReceiver on the receive side.

Browse Source 
BUG=
R=perkj@webrtc.org

Review URL: https://codereview.webrtc.org/1905983002 .

Cr-Commit-Position: refs/heads/master@{#12473}
This commit is contained in:
Peter Boström
2016-04-22 18:23:15 +02:00
parent 845afa8a02
commit 0b25072c4e
12 changed files with 97 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
webrtc/modules/video_coding/receiver.cc
View File

@ -42,12 +42,17 @@ VCMReceiver::VCMReceiver(VCMTiming* timing,
EventFactory* event_factory, EventFactory* event_factory,
NackSender* nack_sender, NackSender* nack_sender,
KeyFrameRequestSender* keyframe_request_sender) KeyFrameRequestSender* keyframe_request_sender)
: VCMReceiver(timing, : VCMReceiver(
clock, timing,
std::unique_ptr<EventWrapper>(event_factory->CreateEvent()), clock,
std::unique_ptr<EventWrapper>(event_factory->CreateEvent()), std::unique_ptr<EventWrapper>(event_factory
nack_sender, ? event_factory->CreateEvent()
keyframe_request_sender) {} : EventWrapper::Create()),
std::unique_ptr<EventWrapper>(event_factory
? event_factory->CreateEvent()
: EventWrapper::Create()),
nack_sender,
keyframe_request_sender) {}
VCMReceiver::VCMReceiver(VCMTiming* timing, VCMReceiver::VCMReceiver(VCMTiming* timing,
Clock* clock, Clock* clock,

20
webrtc/modules/video_coding/video_coding_impl.cc
View File

@ -73,7 +73,6 @@ class VideoCodingModuleImpl : public VideoCodingModule {
public: public:
VideoCodingModuleImpl(Clock* clock, VideoCodingModuleImpl(Clock* clock,
EventFactory* event_factory, EventFactory* event_factory,
bool owns_event_factory,
VideoEncoderRateObserver* encoder_rate_observer, VideoEncoderRateObserver* encoder_rate_observer,
VCMQMSettingsCallback* qm_settings_callback, VCMQMSettingsCallback* qm_settings_callback,
NackSender* nack_sender, NackSender* nack_sender,
@ -88,10 +87,9 @@ class VideoCodingModuleImpl : public VideoCodingModule {
event_factory, event_factory,
pre_decode_image_callback, pre_decode_image_callback,
nack_sender, nack_sender,
keyframe_request_sender), keyframe_request_sender) {}
own_event_factory_(owns_event_factory ? event_factory : NULL) {}
virtual ~VideoCodingModuleImpl() { own_event_factory_.reset(); } virtual ~VideoCodingModuleImpl() {}
int64_t TimeUntilNextProcess() override { int64_t TimeUntilNextProcess() override {
int64_t sender_time = sender_.TimeUntilNextProcess(); int64_t sender_time = sender_.TimeUntilNextProcess();
@ -286,7 +284,6 @@ class VideoCodingModuleImpl : public VideoCodingModule {
EncodedImageCallbackWrapper post_encode_callback_; EncodedImageCallbackWrapper post_encode_callback_;
vcm::VideoSender sender_; vcm::VideoSender sender_;
vcm::VideoReceiver receiver_; vcm::VideoReceiver receiver_;
std::unique_ptr<EventFactory> own_event_factory_;
}; };
} // namespace } // namespace
@ -315,10 +312,9 @@ VideoCodingModule* VideoCodingModule::Create(
NackSender* nack_sender, NackSender* nack_sender,
KeyFrameRequestSender* keyframe_request_sender, KeyFrameRequestSender* keyframe_request_sender,
EncodedImageCallback* pre_decode_image_callback) { EncodedImageCallback* pre_decode_image_callback) {
return new VideoCodingModuleImpl(clock, new EventFactoryImpl, true, return new VideoCodingModuleImpl(
encoder_rate_observer, qm_settings_callback, clock, nullptr, encoder_rate_observer, qm_settings_callback, nack_sender,
nack_sender, keyframe_request_sender, keyframe_request_sender, pre_decode_image_callback);
pre_decode_image_callback);
} }
// Create method for current interface, will be removed when the // Create method for current interface, will be removed when the
@ -338,9 +334,9 @@ VideoCodingModule* VideoCodingModule::Create(
KeyFrameRequestSender* keyframe_request_sender) { KeyFrameRequestSender* keyframe_request_sender) {
assert(clock); assert(clock);
assert(event_factory); assert(event_factory);
return new VideoCodingModuleImpl(clock, event_factory, false, nullptr, return new VideoCodingModuleImpl(clock, event_factory, nullptr, nullptr,
nullptr, nack_sender, nack_sender, keyframe_request_sender,
keyframe_request_sender, nullptr); nullptr);
} }
} // namespace webrtc } // namespace webrtc

6
webrtc/modules/video_coding/video_coding_impl.h
View File

@ -128,7 +128,7 @@ class VideoSender : public Module {
std::vector<FrameType> next_frame_types_ GUARDED_BY(params_crit_); std::vector<FrameType> next_frame_types_ GUARDED_BY(params_crit_);
}; };
class VideoReceiver { class VideoReceiver : public Module {
public: public:
typedef VideoCodingModule::ReceiverRobustness ReceiverRobustness; typedef VideoCodingModule::ReceiverRobustness ReceiverRobustness;
@ -179,8 +179,8 @@ class VideoReceiver {
int32_t SetReceiveChannelParameters(int64_t rtt); int32_t SetReceiveChannelParameters(int64_t rtt);
int32_t SetVideoProtection(VCMVideoProtection videoProtection, bool enable); int32_t SetVideoProtection(VCMVideoProtection videoProtection, bool enable);
int64_t TimeUntilNextProcess(); int64_t TimeUntilNextProcess() override;
void Process(); void Process() override;
void TriggerDecoderShutdown(); void TriggerDecoderShutdown();

30
webrtc/video/video_receive_stream.cc
View File

@ -162,24 +162,19 @@ VideoReceiveStream::VideoReceiveStream(
congestion_controller_(congestion_controller), congestion_controller_(congestion_controller),
call_stats_(call_stats), call_stats_(call_stats),
remb_(remb), remb_(remb),
vcm_(VideoCodingModule::Create(clock_, video_receiver_(clock_, nullptr, this, this, this),
nullptr,
nullptr,
this,
this,
this)),
incoming_video_stream_(0, config.disable_prerenderer_smoothing), incoming_video_stream_(0, config.disable_prerenderer_smoothing),
stats_proxy_(config_, clock_), stats_proxy_(config_, clock_),
vie_channel_(&transport_adapter_, vie_channel_(&transport_adapter_,
process_thread, process_thread,
vcm_.get(), &video_receiver_,
congestion_controller_->GetRemoteBitrateEstimator( congestion_controller_->GetRemoteBitrateEstimator(
UseSendSideBwe(config_)), UseSendSideBwe(config_)),
call_stats_->rtcp_rtt_stats(), call_stats_->rtcp_rtt_stats(),
congestion_controller_->pacer(), congestion_controller_->pacer(),
congestion_controller_->packet_router()), congestion_controller_->packet_router()),
vie_receiver_(vie_channel_.vie_receiver()), vie_receiver_(vie_channel_.vie_receiver()),
vie_sync_(vcm_.get()), vie_sync_(&video_receiver_),
rtp_rtcp_(vie_channel_.rtp_rtcp()) { rtp_rtcp_(vie_channel_.rtp_rtcp()) {
LOG(LS_INFO) << "VideoReceiveStream: " << config_.ToString(); LOG(LS_INFO) << "VideoReceiveStream: " << config_.ToString();
@ -277,22 +272,23 @@ VideoReceiveStream::VideoReceiveStream(
<< "Duplicate payload type (" << decoder.payload_type << "Duplicate payload type (" << decoder.payload_type
<< ") for different decoders."; << ") for different decoders.";
decoder_payload_types.insert(decoder.payload_type); 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); VideoCodec codec = CreateDecoderVideoCodec(decoder);
RTC_CHECK(vie_receiver_->SetReceiveCodec(codec)); RTC_CHECK(vie_receiver_->SetReceiveCodec(codec));
RTC_CHECK_EQ(VCM_OK, RTC_CHECK_EQ(VCM_OK, video_receiver_.RegisterReceiveCodec(
vcm_->RegisterReceiveCodec(&codec, num_cpu_cores, false)); &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_.SetExpectedRenderDelay(config.render_delay_ms);
incoming_video_stream_.SetExternalCallback(this); incoming_video_stream_.SetExternalCallback(this);
vie_channel_.SetIncomingVideoStream(&incoming_video_stream_); vie_channel_.SetIncomingVideoStream(&incoming_video_stream_);
vie_channel_.RegisterPreRenderCallback(this); vie_channel_.RegisterPreRenderCallback(this);
process_thread_->RegisterModule(vcm_.get()); process_thread_->RegisterModule(&video_receiver_);
process_thread_->RegisterModule(&vie_sync_); process_thread_->RegisterModule(&vie_sync_);
} }
@ -301,14 +297,14 @@ VideoReceiveStream::~VideoReceiveStream() {
Stop(); Stop();
process_thread_->DeRegisterModule(&vie_sync_); 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 // Deregister external decoders so that they are no longer running during
// destruction. This effectively stops the VCM since the decoder thread is // destruction. This effectively stops the VCM since the decoder thread is
// stopped, the VCM is deregistered and no asynchronous decoder threads are // stopped, the VCM is deregistered and no asynchronous decoder threads are
// running. // running.
for (const Decoder& decoder : config_.decoders) for (const Decoder& decoder : config_.decoders)
vcm_->RegisterExternalDecoder(nullptr, decoder.payload_type); video_receiver_.RegisterExternalDecoder(nullptr, decoder.payload_type);
vie_channel_.RegisterPreRenderCallback(nullptr); vie_channel_.RegisterPreRenderCallback(nullptr);
@ -334,7 +330,7 @@ void VideoReceiveStream::Start() {
void VideoReceiveStream::Stop() { void VideoReceiveStream::Stop() {
incoming_video_stream_.Stop(); incoming_video_stream_.Stop();
vie_receiver_->StopReceive(); vie_receiver_->StopReceive();
vcm_->TriggerDecoderShutdown(); video_receiver_.TriggerDecoderShutdown();
decode_thread_.Stop(); decode_thread_.Stop();
transport_adapter_.Disable(); transport_adapter_.Disable();
} }
@ -431,7 +427,7 @@ bool VideoReceiveStream::DecodeThreadFunction(void* ptr) {
void VideoReceiveStream::Decode() { void VideoReceiveStream::Decode() {
static const int kMaxDecodeWaitTimeMs = 50; static const int kMaxDecodeWaitTimeMs = 50;
vcm_->Decode(kMaxDecodeWaitTimeMs); video_receiver_.Decode(kMaxDecodeWaitTimeMs);
} }
void VideoReceiveStream::SendNack( void VideoReceiveStream::SendNack(

3
webrtc/video/video_receive_stream.h
View File

@ -19,6 +19,7 @@
#include "webrtc/common_video/include/incoming_video_stream.h" #include "webrtc/common_video/include/incoming_video_stream.h"
#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h" #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
#include "webrtc/modules/video_render/video_render_defines.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/system_wrappers/include/clock.h"
#include "webrtc/video/encoded_frame_callback_adapter.h" #include "webrtc/video/encoded_frame_callback_adapter.h"
#include "webrtc/video/receive_statistics_proxy.h" #include "webrtc/video/receive_statistics_proxy.h"
@ -104,7 +105,7 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream,
CallStats* const call_stats_; CallStats* const call_stats_;
VieRemb* const remb_; VieRemb* const remb_;
std::unique_ptr<VideoCodingModule> vcm_; vcm::VideoReceiver video_receiver_;
IncomingVideoStream incoming_video_stream_; IncomingVideoStream incoming_video_stream_;
ReceiveStatisticsProxy stats_proxy_; ReceiveStatisticsProxy stats_proxy_;
ViEChannel vie_channel_; ViEChannel vie_channel_;

43
webrtc/video/vie_channel.cc
View File

@ -25,7 +25,7 @@
#include "webrtc/modules/rtp_rtcp/include/rtp_receiver.h" #include "webrtc/modules/rtp_rtcp/include/rtp_receiver.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h" #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
#include "webrtc/modules/utility/include/process_thread.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_processing/include/video_processing.h"
#include "webrtc/modules/video_render/video_render_defines.h" #include "webrtc/modules/video_render/video_render_defines.h"
#include "webrtc/system_wrappers/include/metrics.h" #include "webrtc/system_wrappers/include/metrics.h"
@ -93,14 +93,14 @@ class ChannelStatsObserver : public CallStatsObserver {
ViEChannel::ViEChannel(Transport* transport, ViEChannel::ViEChannel(Transport* transport,
ProcessThread* module_process_thread, ProcessThread* module_process_thread,
VideoCodingModule* vcm, vcm::VideoReceiver* video_receiver,
RemoteBitrateEstimator* remote_bitrate_estimator, RemoteBitrateEstimator* remote_bitrate_estimator,
RtcpRttStats* rtt_stats, RtcpRttStats* rtt_stats,
PacedSender* paced_sender, PacedSender* paced_sender,
PacketRouter* packet_router) PacketRouter* packet_router)
: module_process_thread_(module_process_thread), : module_process_thread_(module_process_thread),
vcm_(vcm), video_receiver_(video_receiver),
vie_receiver_(vcm_, remote_bitrate_estimator, this), vie_receiver_(video_receiver_, remote_bitrate_estimator, this),
stats_observer_(new ChannelStatsObserver(this)), stats_observer_(new ChannelStatsObserver(this)),
receive_stats_callback_(nullptr), receive_stats_callback_(nullptr),
incoming_video_stream_(nullptr), incoming_video_stream_(nullptr),
@ -118,8 +118,9 @@ ViEChannel::ViEChannel(Transport* transport,
paced_sender_, paced_sender_,
packet_router_)) { packet_router_)) {
vie_receiver_.Init(rtp_rtcp_.get()); vie_receiver_.Init(rtp_rtcp_.get());
RTC_DCHECK(vcm_); RTC_DCHECK(video_receiver_);
vcm_->SetNackSettings(kMaxNackListSize, max_nack_reordering_threshold_, 0); video_receiver_->SetNackSettings(kMaxNackListSize,
max_nack_reordering_threshold_, 0);
} }
int32_t ViEChannel::Init() { int32_t ViEChannel::Init() {
@ -131,13 +132,13 @@ int32_t ViEChannel::Init() {
packet_router_->AddRtpModule(rtp_rtcp_.get()); packet_router_->AddRtpModule(rtp_rtcp_.get());
rtp_rtcp_->SetKeyFrameRequestMethod(kKeyFrameReqPliRtcp); rtp_rtcp_->SetKeyFrameRequestMethod(kKeyFrameReqPliRtcp);
if (vcm_->RegisterReceiveCallback(this) != 0) { if (video_receiver_->RegisterReceiveCallback(this) != 0) {
return -1; return -1;
} }
vcm_->RegisterFrameTypeCallback(this); video_receiver_->RegisterFrameTypeCallback(this);
vcm_->RegisterReceiveStatisticsCallback(this); video_receiver_->RegisterReceiveStatisticsCallback(this);
vcm_->RegisterDecoderTimingCallback(this); video_receiver_->RegisterDecoderTimingCallback(this);
vcm_->SetRenderDelay(kDefaultRenderDelayMs); video_receiver_->SetRenderDelay(kDefaultRenderDelayMs);
return 0; return 0;
} }
@ -178,7 +179,7 @@ void ViEChannel::SetProtectionMode(bool enable_nack,
protection_method = kProtectionNone; protection_method = kProtectionNone;
} }
vcm_->SetVideoProtection(protection_method, true); video_receiver_->SetVideoProtection(protection_method, true);
// Set NACK. // Set NACK.
ProcessNACKRequest(enable_nack); ProcessNACKRequest(enable_nack);
@ -195,15 +196,15 @@ void ViEChannel::ProcessNACKRequest(const bool enable) {
if (rtp_rtcp_->RTCP() == RtcpMode::kOff) if (rtp_rtcp_->RTCP() == RtcpMode::kOff)
return; return;
vie_receiver_.SetNackStatus(true, max_nack_reordering_threshold_); vie_receiver_.SetNackStatus(true, max_nack_reordering_threshold_);
vcm_->RegisterPacketRequestCallback(this); video_receiver_->RegisterPacketRequestCallback(this);
// Don't introduce errors when NACK is enabled. // Don't introduce errors when NACK is enabled.
vcm_->SetDecodeErrorMode(kNoErrors); video_receiver_->SetDecodeErrorMode(kNoErrors);
} else { } else {
vcm_->RegisterPacketRequestCallback(nullptr); video_receiver_->RegisterPacketRequestCallback(nullptr);
// When NACK is off, allow decoding with errors. Otherwise, the video // When NACK is off, allow decoding with errors. Otherwise, the video
// will freeze, and will only recover with a complete key frame. // 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_); vie_receiver_.SetNackStatus(false, max_nack_reordering_threshold_);
} }
} }
@ -238,10 +239,10 @@ CallStatsObserver* ViEChannel::GetStatsObserver() {
return stats_observer_.get(); return stats_observer_.get();
} }
// Do not acquire the lock of |vcm_| in this function. Decode callback won't // Do not acquire the lock of |video_receiver_| in this function. Decode
// necessarily be called from the decoding thread. The decoding thread may have // callback won't necessarily be called from the decoding thread. The decoding
// held the lock when calling VideoDecoder::Decode, Reset, or Release. Acquiring // thread may have held the lock when calling VideoDecoder::Decode, Reset, or
// the same lock in the path of decode callback can deadlock. // Release. Acquiring the same lock in the path of decode callback can deadlock.
int32_t ViEChannel::FrameToRender(VideoFrame& video_frame) { // NOLINT int32_t ViEChannel::FrameToRender(VideoFrame& video_frame) { // NOLINT
rtc::CritScope lock(&crit_); 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) { 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_); rtc::CritScope lock(&crit_);
last_rtt_ms_ = avg_rtt_ms; last_rtt_ms_ = avg_rtt_ms;

9
webrtc/video/vie_channel.h
View File

@ -43,10 +43,13 @@ class ProcessThread;
class ReceiveStatisticsProxy; class ReceiveStatisticsProxy;
class RtcpRttStats; class RtcpRttStats;
class ViERTPObserver; class ViERTPObserver;
class VideoCodingModule;
class VideoRenderCallback; class VideoRenderCallback;
class VoEVideoSync; class VoEVideoSync;
namespace vcm {
class VideoReceiver;
} // namespace vcm
enum StreamType { enum StreamType {
kViEStreamTypeNormal = 0, // Normal media stream kViEStreamTypeNormal = 0, // Normal media stream
kViEStreamTypeRtx = 1 // Retransmission media stream kViEStreamTypeRtx = 1 // Retransmission media stream
@ -63,7 +66,7 @@ class ViEChannel : public VCMFrameTypeCallback,
ViEChannel(Transport* transport, ViEChannel(Transport* transport,
ProcessThread* module_process_thread, ProcessThread* module_process_thread,
VideoCodingModule* vcm, vcm::VideoReceiver* video_receiver,
RemoteBitrateEstimator* remote_bitrate_estimator, RemoteBitrateEstimator* remote_bitrate_estimator,
RtcpRttStats* rtt_stats, RtcpRttStats* rtt_stats,
PacedSender* paced_sender, PacedSender* paced_sender,
@ -196,7 +199,7 @@ class ViEChannel : public VCMFrameTypeCallback,
// Used for all registered callbacks except rendering. // Used for all registered callbacks except rendering.
rtc::CriticalSection crit_; rtc::CriticalSection crit_;
VideoCodingModule* const vcm_; vcm::VideoReceiver* const video_receiver_;
ViEReceiver vie_receiver_; ViEReceiver vie_receiver_;
// Helper to report call statistics. // Helper to report call statistics.

1
webrtc/video/vie_encoder.h
View File

@ -39,7 +39,6 @@ class QMVideoSettingsCallback;
class SendStatisticsProxy; class SendStatisticsProxy;
class ViEBitrateObserver; class ViEBitrateObserver;
class ViEEffectFilter; class ViEEffectFilter;
class VideoCodingModule;
class VideoEncoder; class VideoEncoder;
class ViEEncoder : public VideoEncoderRateObserver, class ViEEncoder : public VideoEncoderRateObserver,

16
webrtc/video/vie_receiver.cc
View File

@ -21,7 +21,7 @@
#include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h" #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_receiver.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.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/metrics.h"
#include "webrtc/system_wrappers/include/tick_util.h" #include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/system_wrappers/include/timestamp_extrapolator.h" #include "webrtc/system_wrappers/include/timestamp_extrapolator.h"
@ -31,11 +31,11 @@ namespace webrtc {
static const int kPacketLogIntervalMs = 10000; static const int kPacketLogIntervalMs = 10000;
ViEReceiver::ViEReceiver(VideoCodingModule* module_vcm, ViEReceiver::ViEReceiver(vcm::VideoReceiver* video_receiver,
RemoteBitrateEstimator* remote_bitrate_estimator, RemoteBitrateEstimator* remote_bitrate_estimator,
RtpFeedback* rtp_feedback) RtpFeedback* rtp_feedback)
: clock_(Clock::GetRealTimeClock()), : clock_(Clock::GetRealTimeClock()),
vcm_(module_vcm), video_receiver_(video_receiver),
remote_bitrate_estimator_(remote_bitrate_estimator), remote_bitrate_estimator_(remote_bitrate_estimator),
ntp_estimator_(clock_), ntp_estimator_(clock_),
rtp_payload_registry_(RTPPayloadStrategy::CreateStrategy(false)), 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, int32_t ViEReceiver::OnReceivedPayloadData(const uint8_t* payload_data,
const size_t payload_size, const size_t payload_size,
const WebRtcRTPHeader* rtp_header) { const WebRtcRTPHeader* rtp_header) {
RTC_DCHECK(vcm_); RTC_DCHECK(video_receiver_);
WebRtcRTPHeader rtp_header_with_ntp = *rtp_header; WebRtcRTPHeader rtp_header_with_ntp = *rtp_header;
rtp_header_with_ntp.ntp_time_ms = rtp_header_with_ntp.ntp_time_ms =
ntp_estimator_.Estimate(rtp_header->header.timestamp); ntp_estimator_.Estimate(rtp_header->header.timestamp);
if (vcm_->IncomingPacket(payload_data, if (video_receiver_->IncomingPacket(payload_data, payload_size,
payload_size, rtp_header_with_ntp) != 0) {
rtp_header_with_ntp) != 0) {
// Check this... // Check this...
return -1; return -1;
} }
@ -249,7 +248,8 @@ bool ViEReceiver::ParseAndHandleEncapsulatingHeader(const uint8_t* packet,
int8_t ulpfec_pt = rtp_payload_registry_.ulpfec_payload_type(); int8_t ulpfec_pt = rtp_payload_registry_.ulpfec_payload_type();
if (packet[header.headerLength] == ulpfec_pt) { if (packet[header.headerLength] == ulpfec_pt) {
rtp_receive_statistics_->FecPacketReceived(header, packet_length); 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); NotifyReceiverOfFecPacket(header);
} }
if (fec_receiver_->AddReceivedRedPacket( if (fec_receiver_->AddReceivedRedPacket(

9
webrtc/video/vie_receiver.h
View File

@ -34,11 +34,14 @@ class RtpHeaderParser;
class RTPPayloadRegistry; class RTPPayloadRegistry;
class RtpReceiver; class RtpReceiver;
class RtpRtcp; class RtpRtcp;
class VideoCodingModule;
namespace vcm {
class VideoReceiver;
} // namespace vcm
class ViEReceiver : public RtpData { class ViEReceiver : public RtpData {
public: public:
ViEReceiver(VideoCodingModule* module_vcm, ViEReceiver(vcm::VideoReceiver* video_receiver,
RemoteBitrateEstimator* remote_bitrate_estimator, RemoteBitrateEstimator* remote_bitrate_estimator,
RtpFeedback* rtp_feedback); RtpFeedback* rtp_feedback);
~ViEReceiver(); ~ViEReceiver();
@ -98,7 +101,7 @@ class ViEReceiver : public RtpData {
void UpdateHistograms(); void UpdateHistograms();
Clock* const clock_; Clock* const clock_;
VideoCodingModule* const vcm_; vcm::VideoReceiver* const video_receiver_;
RemoteBitrateEstimator* const remote_bitrate_estimator_; RemoteBitrateEstimator* const remote_bitrate_estimator_;
// TODO(pbos): Make const and set on construction. // TODO(pbos): Make const and set on construction.

21
webrtc/video/vie_sync_module.cc
View File

@ -15,7 +15,7 @@
#include "webrtc/base/trace_event.h" #include "webrtc/base/trace_event.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_receiver.h" #include "webrtc/modules/rtp_rtcp/include/rtp_receiver.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.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/system_wrappers/include/clock.h"
#include "webrtc/video/stream_synchronization.h" #include "webrtc/video/stream_synchronization.h"
#include "webrtc/video_frame.h" #include "webrtc/video_frame.h"
@ -48,10 +48,10 @@ int UpdateMeasurements(StreamSynchronization::Measurements* stream,
} }
} // namespace } // namespace
ViESyncModule::ViESyncModule(VideoCodingModule* vcm) ViESyncModule::ViESyncModule(vcm::VideoReceiver* video_receiver)
: vcm_(vcm), : video_receiver_(video_receiver),
clock_(Clock::GetRealTimeClock()), clock_(Clock::GetRealTimeClock()),
video_receiver_(nullptr), rtp_receiver_(nullptr),
video_rtp_rtcp_(nullptr), video_rtp_rtcp_(nullptr),
voe_channel_id_(-1), voe_channel_id_(-1),
voe_sync_interface_(nullptr), voe_sync_interface_(nullptr),
@ -64,20 +64,19 @@ ViESyncModule::~ViESyncModule() {
void ViESyncModule::ConfigureSync(int voe_channel_id, void ViESyncModule::ConfigureSync(int voe_channel_id,
VoEVideoSync* voe_sync_interface, VoEVideoSync* voe_sync_interface,
RtpRtcp* video_rtcp_module, RtpRtcp* video_rtcp_module,
RtpReceiver* video_receiver) { RtpReceiver* rtp_receiver) {
if (voe_channel_id != -1) if (voe_channel_id != -1)
RTC_DCHECK(voe_sync_interface); RTC_DCHECK(voe_sync_interface);
rtc::CritScope lock(&data_cs_); rtc::CritScope lock(&data_cs_);
// Prevent expensive no-ops. // Prevent expensive no-ops.
if (voe_channel_id_ == voe_channel_id && if (voe_channel_id_ == voe_channel_id &&
voe_sync_interface_ == voe_sync_interface && voe_sync_interface_ == voe_sync_interface &&
video_receiver_ == video_receiver && rtp_receiver_ == rtp_receiver && video_rtp_rtcp_ == video_rtcp_module) {
video_rtp_rtcp_ == video_rtcp_module) {
return; return;
} }
voe_channel_id_ = voe_channel_id; voe_channel_id_ = voe_channel_id;
voe_sync_interface_ = voe_sync_interface; voe_sync_interface_ = voe_sync_interface;
video_receiver_ = video_receiver; rtp_receiver_ = rtp_receiver;
video_rtp_rtcp_ = video_rtcp_module; video_rtp_rtcp_ = video_rtcp_module;
sync_.reset( sync_.reset(
new StreamSynchronization(video_rtp_rtcp_->SSRC(), voe_channel_id)); new StreamSynchronization(video_rtp_rtcp_->SSRC(), voe_channel_id));
@ -92,7 +91,7 @@ void ViESyncModule::Process() {
rtc::CritScope lock(&data_cs_); rtc::CritScope lock(&data_cs_);
last_sync_time_ = TickTime::Now(); 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) { if (voe_channel_id_ == -1) {
return; return;
@ -120,7 +119,7 @@ void ViESyncModule::Process() {
assert(voice_receiver); assert(voice_receiver);
if (UpdateMeasurements(&video_measurement_, *video_rtp_rtcp_, if (UpdateMeasurements(&video_measurement_, *video_rtp_rtcp_,
*video_receiver_) != 0) { *rtp_receiver_) != 0) {
return; return;
} }
@ -154,7 +153,7 @@ void ViESyncModule::Process() {
voe_channel_id_, target_audio_delay_ms) == -1) { voe_channel_id_, target_audio_delay_ms) == -1) {
LOG(LS_ERROR) << "Error setting voice delay."; 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, bool ViESyncModule::GetStreamSyncOffsetInMs(const VideoFrame& frame,

13
webrtc/video/vie_sync_module.h
View File

@ -26,20 +26,23 @@ namespace webrtc {
class Clock; class Clock;
class RtpRtcp; class RtpRtcp;
class VideoCodingModule;
class VideoFrame; class VideoFrame;
class ViEChannel; class ViEChannel;
class VoEVideoSync; class VoEVideoSync;
namespace vcm {
class VideoReceiver;
} // namespace vcm
class ViESyncModule : public Module { class ViESyncModule : public Module {
public: public:
explicit ViESyncModule(VideoCodingModule* vcm); explicit ViESyncModule(vcm::VideoReceiver* vcm);
~ViESyncModule(); ~ViESyncModule();
void ConfigureSync(int voe_channel_id, void ConfigureSync(int voe_channel_id,
VoEVideoSync* voe_sync_interface, VoEVideoSync* voe_sync_interface,
RtpRtcp* video_rtcp_module, RtpRtcp* video_rtcp_module,
RtpReceiver* video_receiver); RtpReceiver* rtp_receiver);
// Implements Module. // Implements Module.
int64_t TimeUntilNextProcess() override; int64_t TimeUntilNextProcess() override;
@ -52,9 +55,9 @@ class ViESyncModule : public Module {
private: private:
rtc::CriticalSection data_cs_; rtc::CriticalSection data_cs_;
VideoCodingModule* const vcm_; vcm::VideoReceiver* const video_receiver_;
Clock* const clock_; Clock* const clock_;
RtpReceiver* video_receiver_; RtpReceiver* rtp_receiver_;
RtpRtcp* video_rtp_rtcp_; RtpRtcp* video_rtp_rtcp_;
int voe_channel_id_; int voe_channel_id_;
VoEVideoSync* voe_sync_interface_; VoEVideoSync* voe_sync_interface_;