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,
NackSender* nack_sender,
KeyFrameRequestSender* keyframe_request_sender)
: VCMReceiver(timing,
clock,
std::unique_ptr<EventWrapper>(event_factory->CreateEvent()),
std::unique_ptr<EventWrapper>(event_factory->CreateEvent()),
nack_sender,
keyframe_request_sender) {}
: VCMReceiver(
timing,
clock,
std::unique_ptr<EventWrapper>(event_factory
? event_factory->CreateEvent()
: EventWrapper::Create()),
std::unique_ptr<EventWrapper>(event_factory
? event_factory->CreateEvent()
: EventWrapper::Create()),
nack_sender,
keyframe_request_sender) {}
VCMReceiver::VCMReceiver(VCMTiming* timing,
Clock* clock,

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

@ -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<EventFactory> 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

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_);
};
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();

30
webrtc/video/video_receive_stream.cc
View File

@ -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(

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/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<VideoCodingModule> vcm_;
vcm::VideoReceiver video_receiver_;
IncomingVideoStream incoming_video_stream_;
ReceiveStatisticsProxy stats_proxy_;
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_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;

9
webrtc/video/vie_channel.h
View File

@ -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.

1
webrtc/video/vie_encoder.h
View File

@ -39,7 +39,6 @@ class QMVideoSettingsCallback;
class SendStatisticsProxy;
class ViEBitrateObserver;
class ViEEffectFilter;
class VideoCodingModule;
class VideoEncoder;
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_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(

9
webrtc/video/vie_receiver.h
View File

@ -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.

21
webrtc/video/vie_sync_module.cc
View File

@ -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,

13
webrtc/video/vie_sync_module.h
View File

@ -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_;