admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rename ViEReceiver and move ownership to VideoReceiveStream.

Browse Source 
This CL will be followed up with another CL removing everything related
to RTP from ViEChannel to RtpStreamReceiver, i.e. remove ViEChannel::rtp_stream_receiver_.

BUG=5838

Review-Url: https://codereview.webrtc.org/1917363005
Cr-Commit-Position: refs/heads/master@{#12553}
This commit is contained in:
mflodman 2016-04-28 23:15:33 -07:00 committed by Commit bot
parent acbc8d0963
commit fa66659c6b
8 changed files with 139 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
webrtc/video/BUILD.gn
View File

@ -24,6 +24,8 @@ source_set("video") {
"receive_statistics_proxy.h",
"report_block_stats.cc",
"report_block_stats.h",
"rtp_stream_receiver.cc",
"rtp_stream_receiver.h",
"send_statistics_proxy.cc",
"send_statistics_proxy.h",
"stream_synchronization.cc",
@ -40,8 +42,6 @@ source_set("video") {
"vie_channel.h",
"vie_encoder.cc",
"vie_encoder.h",
"vie_receiver.cc",
"vie_receiver.h",
"vie_remb.cc",
"vie_remb.h",
"vie_sync_module.cc",

116
webrtc/video/vie_receiver.cc → webrtc/video/rtp_stream_receiver.cc
View File

@ -8,7 +8,7 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "webrtc/video/vie_receiver.h"
#include "webrtc/video/rtp_stream_receiver.h"
#include <vector>
@ -67,13 +67,13 @@ std::unique_ptr<RtpRtcp> CreateRtpRtcpModule(
static const int kPacketLogIntervalMs = 10000;
ViEReceiver::ViEReceiver(vcm::VideoReceiver* video_receiver,
RemoteBitrateEstimator* remote_bitrate_estimator,
RtpFeedback* rtp_feedback,
Transport* transport,
RtcpRttStats* rtt_stats,
PacedSender* paced_sender,
PacketRouter* packet_router)
RtpStreamReceiver::RtpStreamReceiver(
vcm::VideoReceiver* video_receiver,
RemoteBitrateEstimator* remote_bitrate_estimator,
Transport* transport,
RtcpRttStats* rtt_stats,
PacedSender* paced_sender,
PacketRouter* packet_router)
: clock_(Clock::GetRealTimeClock()),
video_receiver_(video_receiver),
remote_bitrate_estimator_(remote_bitrate_estimator),
@ -83,7 +83,7 @@ ViEReceiver::ViEReceiver(vcm::VideoReceiver* video_receiver,
rtp_header_parser_(RtpHeaderParser::Create()),
rtp_receiver_(RtpReceiver::CreateVideoReceiver(clock_,
this,
rtp_feedback,
this,
&rtp_payload_registry_)),
rtp_receive_statistics_(ReceiveStatistics::Create(clock_)),
fec_receiver_(FecReceiver::Create(this)),
@ -101,12 +101,12 @@ ViEReceiver::ViEReceiver(vcm::VideoReceiver* video_receiver,
rtp_rtcp_->SetKeyFrameRequestMethod(kKeyFrameReqPliRtcp);
}
ViEReceiver::~ViEReceiver() {
RtpStreamReceiver::~RtpStreamReceiver() {
packet_router_->RemoveRtpModule(rtp_rtcp_.get());
UpdateHistograms();
}
void ViEReceiver::UpdateHistograms() {
void RtpStreamReceiver::UpdateHistograms() {
FecPacketCounter counter = fec_receiver_->GetPacketCounter();
if (counter.num_packets > 0) {
RTC_LOGGED_HISTOGRAM_PERCENTAGE(
@ -121,7 +121,7 @@ void ViEReceiver::UpdateHistograms() {
}
}
bool ViEReceiver::SetReceiveCodec(const VideoCodec& video_codec) {
bool RtpStreamReceiver::SetReceiveCodec(const VideoCodec& video_codec) {
int8_t old_pltype = -1;
if (rtp_payload_registry_.ReceivePayloadType(
video_codec.plName, kVideoPayloadTypeFrequency, 0,
@ -134,8 +134,8 @@ bool ViEReceiver::SetReceiveCodec(const VideoCodec& video_codec) {
0, 0) == 0;
}
void ViEReceiver::SetNackStatus(bool enable,
int max_nack_reordering_threshold) {
void RtpStreamReceiver::SetNackStatus(bool enable,
int max_nack_reordering_threshold) {
if (!enable) {
// Reset the threshold back to the lower default threshold when NACK is
// disabled since we no longer will be receiving retransmissions.
@ -146,56 +146,57 @@ void ViEReceiver::SetNackStatus(bool enable,
rtp_receiver_->SetNACKStatus(enable ? kNackRtcp : kNackOff);
}
void ViEReceiver::SetRtxPayloadType(int payload_type,
int associated_payload_type) {
void RtpStreamReceiver::SetRtxPayloadType(int payload_type,
int associated_payload_type) {
rtp_payload_registry_.SetRtxPayloadType(payload_type,
associated_payload_type);
}
void ViEReceiver::SetUseRtxPayloadMappingOnRestore(bool val) {
void RtpStreamReceiver::SetUseRtxPayloadMappingOnRestore(bool val) {
rtp_payload_registry_.set_use_rtx_payload_mapping_on_restore(val);
}
void ViEReceiver::SetRtxSsrc(uint32_t ssrc) {
void RtpStreamReceiver::SetRtxSsrc(uint32_t ssrc) {
rtp_payload_registry_.SetRtxSsrc(ssrc);
}
bool ViEReceiver::GetRtxSsrc(uint32_t* ssrc) const {
bool RtpStreamReceiver::GetRtxSsrc(uint32_t* ssrc) const {
return rtp_payload_registry_.GetRtxSsrc(ssrc);
}
bool ViEReceiver::IsFecEnabled() const {
bool RtpStreamReceiver::IsFecEnabled() const {
return rtp_payload_registry_.ulpfec_payload_type() > -1;
}
uint32_t ViEReceiver::GetRemoteSsrc() const {
uint32_t RtpStreamReceiver::GetRemoteSsrc() const {
return rtp_receiver_->SSRC();
}
int ViEReceiver::GetCsrcs(uint32_t* csrcs) const {
int RtpStreamReceiver::GetCsrcs(uint32_t* csrcs) const {
return rtp_receiver_->CSRCs(csrcs);
}
RtpReceiver* ViEReceiver::GetRtpReceiver() const {
RtpReceiver* RtpStreamReceiver::GetRtpReceiver() const {
return rtp_receiver_.get();
}
void ViEReceiver::EnableReceiveRtpHeaderExtension(const std::string& extension,
int id) {
void RtpStreamReceiver::EnableReceiveRtpHeaderExtension(
const std::string& extension, int id) {
RTC_DCHECK(RtpExtension::IsSupportedForVideo(extension));
RTC_CHECK(rtp_header_parser_->RegisterRtpHeaderExtension(
StringToRtpExtensionType(extension), id));
}
void ViEReceiver::RegisterRtcpPacketTypeCounterObserver(
void RtpStreamReceiver::RegisterRtcpPacketTypeCounterObserver(
RtcpPacketTypeCounterObserver* observer) {
rtcp_packet_type_counter_observer_.Set(observer);
}
int32_t ViEReceiver::OnReceivedPayloadData(const uint8_t* payload_data,
const size_t payload_size,
const WebRtcRTPHeader* rtp_header) {
int32_t RtpStreamReceiver::OnReceivedPayloadData(
const uint8_t* payload_data,
const size_t payload_size,
const WebRtcRTPHeader* rtp_header) {
RTC_DCHECK(video_receiver_);
WebRtcRTPHeader rtp_header_with_ntp = *rtp_header;
rtp_header_with_ntp.ntp_time_ms =
@ -208,8 +209,8 @@ int32_t ViEReceiver::OnReceivedPayloadData(const uint8_t* payload_data,
return 0;
}
bool ViEReceiver::OnRecoveredPacket(const uint8_t* rtp_packet,
size_t rtp_packet_length) {
bool RtpStreamReceiver::OnRecoveredPacket(const uint8_t* rtp_packet,
size_t rtp_packet_length) {
RTPHeader header;
if (!rtp_header_parser_->Parse(rtp_packet, rtp_packet_length, &header)) {
return false;
@ -219,9 +220,25 @@ bool ViEReceiver::OnRecoveredPacket(const uint8_t* rtp_packet,
return ReceivePacket(rtp_packet, rtp_packet_length, header, in_order);
}
bool ViEReceiver::DeliverRtp(const uint8_t* rtp_packet,
size_t rtp_packet_length,
const PacketTime& packet_time) {
// TODO(pbos): Remove as soon as audio can handle a changing payload type
// without this callback.
int32_t RtpStreamReceiver::OnInitializeDecoder(
const int8_t payload_type,
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
const int frequency,
const size_t channels,
const uint32_t rate) {
RTC_NOTREACHED();
return 0;
}
void RtpStreamReceiver::OnIncomingSSRCChanged(const uint32_t ssrc) {
rtp_rtcp_->SetRemoteSSRC(ssrc);
}
bool RtpStreamReceiver::DeliverRtp(const uint8_t* rtp_packet,
size_t rtp_packet_length,
const PacketTime& packet_time) {
RTC_DCHECK(remote_bitrate_estimator_);
{
rtc::CritScope lock(&receive_cs_);
@ -276,10 +293,10 @@ bool ViEReceiver::DeliverRtp(const uint8_t* rtp_packet,
return ret;
}
bool ViEReceiver::ReceivePacket(const uint8_t* packet,
size_t packet_length,
const RTPHeader& header,
bool in_order) {
bool RtpStreamReceiver::ReceivePacket(const uint8_t* packet,
size_t packet_length,
const RTPHeader& header,
bool in_order) {
if (rtp_payload_registry_.IsEncapsulated(header)) {
return ParseAndHandleEncapsulatingHeader(packet, packet_length, header);
}
@ -295,9 +312,8 @@ bool ViEReceiver::ReceivePacket(const uint8_t* packet,
payload_specific, in_order);
}
bool ViEReceiver::ParseAndHandleEncapsulatingHeader(const uint8_t* packet,
size_t packet_length,
const RTPHeader& header) {
bool RtpStreamReceiver::ParseAndHandleEncapsulatingHeader(
const uint8_t* packet, size_t packet_length, const RTPHeader& header) {
if (rtp_payload_registry_.IsRed(header)) {
int8_t ulpfec_pt = rtp_payload_registry_.ulpfec_payload_type();
if (packet[header.headerLength] == ulpfec_pt) {
@ -343,7 +359,7 @@ bool ViEReceiver::ParseAndHandleEncapsulatingHeader(const uint8_t* packet,
return false;
}
void ViEReceiver::NotifyReceiverOfFecPacket(const RTPHeader& header) {
void RtpStreamReceiver::NotifyReceiverOfFecPacket(const RTPHeader& header) {
int8_t last_media_payload_type =
rtp_payload_registry_.last_received_media_payload_type();
if (last_media_payload_type < 0) {
@ -370,8 +386,8 @@ void ViEReceiver::NotifyReceiverOfFecPacket(const RTPHeader& header) {
OnReceivedPayloadData(nullptr, 0, &rtp_header);
}
bool ViEReceiver::DeliverRtcp(const uint8_t* rtcp_packet,
size_t rtcp_packet_length) {
bool RtpStreamReceiver::DeliverRtcp(const uint8_t* rtcp_packet,
size_t rtcp_packet_length) {
{
rtc::CritScope lock(&receive_cs_);
if (!receiving_) {
@ -400,21 +416,21 @@ bool ViEReceiver::DeliverRtcp(const uint8_t* rtcp_packet,
return true;
}
void ViEReceiver::StartReceive() {
void RtpStreamReceiver::StartReceive() {
rtc::CritScope lock(&receive_cs_);
receiving_ = true;
}
void ViEReceiver::StopReceive() {
void RtpStreamReceiver::StopReceive() {
rtc::CritScope lock(&receive_cs_);
receiving_ = false;
}
ReceiveStatistics* ViEReceiver::GetReceiveStatistics() const {
ReceiveStatistics* RtpStreamReceiver::GetReceiveStatistics() const {
return rtp_receive_statistics_.get();
}
bool ViEReceiver::IsPacketInOrder(const RTPHeader& header) const {
bool RtpStreamReceiver::IsPacketInOrder(const RTPHeader& header) const {
StreamStatistician* statistician =
rtp_receive_statistics_->GetStatistician(header.ssrc);
if (!statistician)
@ -422,8 +438,8 @@ bool ViEReceiver::IsPacketInOrder(const RTPHeader& header) const {
return statistician->IsPacketInOrder(header.sequenceNumber);
}
bool ViEReceiver::IsPacketRetransmitted(const RTPHeader& header,
bool in_order) const {
bool RtpStreamReceiver::IsPacketRetransmitted(const RTPHeader& header,
bool in_order) const {
// Retransmissions are handled separately if RTX is enabled.
if (rtp_payload_registry_.RtxEnabled())
return false;

32
webrtc/video/vie_receiver.h → webrtc/video/rtp_stream_receiver.h
View File

@ -8,8 +8,8 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef WEBRTC_VIDEO_VIE_RECEIVER_H_
#define WEBRTC_VIDEO_VIE_RECEIVER_H_
#ifndef WEBRTC_VIDEO_RTP_STREAM_RECEIVER_H_
#define WEBRTC_VIDEO_RTP_STREAM_RECEIVER_H_
#include <list>
#include <memory>
@ -44,16 +44,15 @@ namespace vcm {
class VideoReceiver;
} // namespace vcm
class ViEReceiver : public RtpData {
class RtpStreamReceiver : public RtpData, public RtpFeedback {
public:
ViEReceiver(vcm::VideoReceiver* video_receiver,
RemoteBitrateEstimator* remote_bitrate_estimator,
RtpFeedback* rtp_feedback,
Transport* transport,
RtcpRttStats* rtt_stats,
PacedSender* paced_sender,
PacketRouter* packet_router);
~ViEReceiver();
RtpStreamReceiver(vcm::VideoReceiver* video_receiver,
RemoteBitrateEstimator* remote_bitrate_estimator,
Transport* transport,
RtcpRttStats* rtt_stats,
PacedSender* paced_sender,
PacketRouter* packet_router);
~RtpStreamReceiver();
bool SetReceiveCodec(const VideoCodec& video_codec);
@ -93,6 +92,15 @@ class ViEReceiver : public RtpData {
const WebRtcRTPHeader* rtp_header) override;
bool OnRecoveredPacket(const uint8_t* packet, size_t packet_length) override;
// Implements RtpFeedback.
int32_t OnInitializeDecoder(const int8_t payload_type,
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
const int frequency,
const size_t channels,
const uint32_t rate) override;
void OnIncomingSSRCChanged(const uint32_t ssrc) override;
void OnIncomingCSRCChanged(const uint32_t CSRC, const bool added) override {}
ReceiveStatistics* GetReceiveStatistics() const;
template <class T>
@ -169,4 +177,4 @@ class ViEReceiver : public RtpData {
} // namespace webrtc
#endif // WEBRTC_VIDEO_VIE_RECEIVER_H_
#endif // WEBRTC_VIDEO_RTP_STREAM_RECEIVER_H_

60
webrtc/video/video_receive_stream.cc
View File

@ -165,15 +165,15 @@ VideoReceiveStream::VideoReceiveStream(
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,
&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()),
rtp_stream_receiver_(&video_receiver_,
congestion_controller_->GetRemoteBitrateEstimator(
UseSendSideBwe(config_)),
&transport_adapter_,
call_stats_->rtcp_rtt_stats(),
congestion_controller_->pacer(),
congestion_controller_->packet_router()),
vie_channel_(&video_receiver_,
&rtp_stream_receiver_),
vie_sync_(&video_receiver_),
rtp_rtcp_(vie_channel_.rtp_rtcp()) {
LOG(LS_INFO) << "VideoReceiveStream: " << config_.ToString();
@ -206,12 +206,12 @@ VideoReceiveStream::VideoReceiveStream(
RTC_DCHECK(kv.second.ssrc != 0);
RTC_DCHECK(kv.second.payload_type != 0);
vie_receiver_->SetRtxSsrc(kv.second.ssrc);
vie_receiver_->SetRtxPayloadType(kv.second.payload_type, kv.first);
rtp_stream_receiver_.SetRtxSsrc(kv.second.ssrc);
rtp_stream_receiver_.SetRtxPayloadType(kv.second.payload_type, kv.first);
}
// TODO(holmer): When Chrome no longer depends on this being false by default,
// always use the mapping and remove this whole codepath.
vie_receiver_->SetUseRtxPayloadMappingOnRestore(
rtp_stream_receiver_.SetUseRtxPayloadMappingOnRestore(
config_.rtp.use_rtx_payload_mapping_on_restore);
if (config_.rtp.remb) {
@ -225,7 +225,7 @@ VideoReceiveStream::VideoReceiveStream(
// One-byte-extension local identifiers are in the range 1-14 inclusive.
RTC_DCHECK_GE(id, 1);
RTC_DCHECK_LE(id, 14);
vie_receiver_->EnableReceiveRtpHeaderExtension(extension, id);
rtp_stream_receiver_.EnableReceiveRtpHeaderExtension(extension, id);
}
if (config_.rtp.fec.ulpfec_payload_type != -1) {
@ -236,7 +236,7 @@ VideoReceiveStream::VideoReceiveStream(
codec.codecType = kVideoCodecULPFEC;
strncpy(codec.plName, "ulpfec", sizeof(codec.plName));
codec.plType = config_.rtp.fec.ulpfec_payload_type;
RTC_CHECK(vie_receiver_->SetReceiveCodec(codec));
RTC_CHECK(rtp_stream_receiver_.SetReceiveCodec(codec));
}
if (config_.rtp.fec.red_payload_type != -1) {
VideoCodec codec;
@ -244,10 +244,11 @@ VideoReceiveStream::VideoReceiveStream(
codec.codecType = kVideoCodecRED;
strncpy(codec.plName, "red", sizeof(codec.plName));
codec.plType = config_.rtp.fec.red_payload_type;
RTC_CHECK(vie_receiver_->SetReceiveCodec(codec));
RTC_CHECK(rtp_stream_receiver_.SetReceiveCodec(codec));
if (config_.rtp.fec.red_rtx_payload_type != -1) {
vie_receiver_->SetRtxPayloadType(config_.rtp.fec.red_rtx_payload_type,
config_.rtp.fec.red_payload_type);
rtp_stream_receiver_.SetRtxPayloadType(
config_.rtp.fec.red_rtx_payload_type,
config_.rtp.fec.red_payload_type);
}
}
@ -255,9 +256,9 @@ VideoReceiveStream::VideoReceiveStream(
rtp_rtcp_->SetRtcpXrRrtrStatus(true);
vie_channel_.RegisterReceiveStatisticsProxy(&stats_proxy_);
vie_receiver_->GetReceiveStatistics()->RegisterRtpStatisticsCallback(
rtp_stream_receiver_.GetReceiveStatistics()->RegisterRtpStatisticsCallback(
&stats_proxy_);
vie_receiver_->GetReceiveStatistics()->RegisterRtcpStatisticsCallback(
rtp_stream_receiver_.GetReceiveStatistics()->RegisterRtcpStatisticsCallback(
&stats_proxy_);
// Stats callback for CNAME changes.
rtp_rtcp_->RegisterRtcpStatisticsCallback(&stats_proxy_);
@ -277,7 +278,7 @@ VideoReceiveStream::VideoReceiveStream(
VideoCodec codec = CreateDecoderVideoCodec(decoder);
RTC_CHECK(vie_receiver_->SetReceiveCodec(codec));
RTC_CHECK(rtp_stream_receiver_.SetReceiveCodec(codec));
RTC_CHECK_EQ(VCM_OK, video_receiver_.RegisterReceiveCodec(
&codec, num_cpu_cores, false));
}
@ -288,6 +289,8 @@ VideoReceiveStream::VideoReceiveStream(
vie_channel_.SetIncomingVideoStream(&incoming_video_stream_);
vie_channel_.RegisterPreRenderCallback(this);
process_thread_->RegisterModule(rtp_stream_receiver_.GetReceiveStatistics());
process_thread_->RegisterModule(rtp_stream_receiver_.rtp_rtcp());
process_thread_->RegisterModule(&video_receiver_);
process_thread_->RegisterModule(&vie_sync_);
}
@ -298,6 +301,9 @@ VideoReceiveStream::~VideoReceiveStream() {
process_thread_->DeRegisterModule(&vie_sync_);
process_thread_->DeRegisterModule(&video_receiver_);
process_thread_->DeRegisterModule(rtp_stream_receiver_.rtp_rtcp());
process_thread_->DeRegisterModule(
rtp_stream_receiver_.GetReceiveStatistics());
// Deregister external decoders so that they are no longer running during
// destruction. This effectively stops the VCM since the decoder thread is
@ -313,7 +319,7 @@ VideoReceiveStream::~VideoReceiveStream() {
remb_->RemoveReceiveChannel(rtp_rtcp_);
congestion_controller_->GetRemoteBitrateEstimator(UseSendSideBwe(config_))
->RemoveStream(vie_receiver_->GetRemoteSsrc());
->RemoveStream(rtp_stream_receiver_.GetRemoteSsrc());
}
void VideoReceiveStream::Start() {
@ -324,12 +330,12 @@ void VideoReceiveStream::Start() {
// Start the decode thread
decode_thread_.Start();
decode_thread_.SetPriority(rtc::kHighestPriority);
vie_receiver_->StartReceive();
rtp_stream_receiver_.StartReceive();
}
void VideoReceiveStream::Stop() {
incoming_video_stream_.Stop();
vie_receiver_->StopReceive();
rtp_stream_receiver_.StopReceive();
video_receiver_.TriggerDecoderShutdown();
decode_thread_.Stop();
transport_adapter_.Disable();
@ -340,12 +346,12 @@ void VideoReceiveStream::SetSyncChannel(VoiceEngine* voice_engine,
if (voice_engine && audio_channel_id != -1) {
VoEVideoSync* voe_sync_interface = VoEVideoSync::GetInterface(voice_engine);
vie_sync_.ConfigureSync(audio_channel_id, voe_sync_interface, rtp_rtcp_,
vie_receiver_->GetRtpReceiver());
rtp_stream_receiver_.GetRtpReceiver());
voe_sync_interface->Release();
return;
}
vie_sync_.ConfigureSync(-1, nullptr, rtp_rtcp_,
vie_receiver_->GetRtpReceiver());
rtp_stream_receiver_.GetRtpReceiver());
}
VideoReceiveStream::Stats VideoReceiveStream::GetStats() const {
@ -353,13 +359,13 @@ VideoReceiveStream::Stats VideoReceiveStream::GetStats() const {
}
bool VideoReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) {
return vie_receiver_->DeliverRtcp(packet, length);
return rtp_stream_receiver_.DeliverRtcp(packet, length);
}
bool VideoReceiveStream::DeliverRtp(const uint8_t* packet,
size_t length,
const PacketTime& packet_time) {
return vie_receiver_->DeliverRtp(packet, length, packet_time);
return rtp_stream_receiver_.DeliverRtp(packet, length, packet_time);
}
void VideoReceiveStream::FrameCallback(VideoFrame* video_frame) {

2
webrtc/video/video_receive_stream.h
View File

@ -108,8 +108,8 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream,
vcm::VideoReceiver video_receiver_;
IncomingVideoStream incoming_video_stream_;
ReceiveStatisticsProxy stats_proxy_;
RtpStreamReceiver rtp_stream_receiver_;
ViEChannel vie_channel_;
ViEReceiver* const vie_receiver_;
ViESyncModule vie_sync_;
RtpRtcp* const rtp_rtcp_;

59
webrtc/video/vie_channel.cc
View File

@ -16,13 +16,11 @@
#include "webrtc/base/checks.h"
#include "webrtc/base/logging.h"
#include "webrtc/base/platform_thread.h"
#include "webrtc/common_video/include/frame_callback.h"
#include "webrtc/common_video/include/incoming_video_stream.h"
#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
#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/video_coding_impl.h"
#include "webrtc/modules/video_processing/include/video_processing.h"
#include "webrtc/modules/video_render/video_render_defines.h"
@ -51,18 +49,11 @@ class ChannelStatsObserver : public CallStatsObserver {
ViEChannel* const owner_;
};
ViEChannel::ViEChannel(Transport* transport,
ProcessThread* module_process_thread,
vcm::VideoReceiver* video_receiver,
RemoteBitrateEstimator* remote_bitrate_estimator,
RtcpRttStats* rtt_stats,
PacedSender* paced_sender,
PacketRouter* packet_router)
: module_process_thread_(module_process_thread),
video_receiver_(video_receiver),
vie_receiver_(video_receiver, remote_bitrate_estimator, this, transport,
rtt_stats, paced_sender, packet_router),
rtp_rtcp_(vie_receiver_.rtp_rtcp()),
ViEChannel::ViEChannel(vcm::VideoReceiver* video_receiver,
RtpStreamReceiver* rtp_stream_receiver)
: video_receiver_(video_receiver),
rtp_stream_receiver_(rtp_stream_receiver),
rtp_rtcp_(rtp_stream_receiver_->rtp_rtcp()),
stats_observer_(new ChannelStatsObserver(this)),
receive_stats_callback_(nullptr),
incoming_video_stream_(nullptr),
@ -74,10 +65,10 @@ ViEChannel::ViEChannel(Transport* transport,
max_nack_reordering_threshold_, 0);
}
ViEChannel::~ViEChannel() {}
int32_t ViEChannel::Init() {
static const int kDefaultRenderDelayMs = 10;
module_process_thread_->RegisterModule(vie_receiver_.GetReceiveStatistics());
module_process_thread_->RegisterModule(rtp_rtcp_);
if (video_receiver_->RegisterReceiveCallback(this) != 0) {
return -1;
@ -90,14 +81,6 @@ int32_t ViEChannel::Init() {
return 0;
}
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(rtp_rtcp_);
}
void ViEChannel::SetProtectionMode(bool enable_nack,
bool enable_fec,
int payload_type_red,
@ -141,7 +124,7 @@ void ViEChannel::ProcessNACKRequest(const bool enable) {
// Turn on NACK.
if (rtp_rtcp_->RTCP() == RtcpMode::kOff)
return;
vie_receiver_.SetNackStatus(true, max_nack_reordering_threshold_);
rtp_stream_receiver_->SetNackStatus(true, max_nack_reordering_threshold_);
video_receiver_->RegisterPacketRequestCallback(this);
// Don't introduce errors when NACK is enabled.
video_receiver_->SetDecodeErrorMode(kNoErrors);
@ -151,7 +134,7 @@ void ViEChannel::ProcessNACKRequest(const bool enable) {
// When NACK is off, allow decoding with errors. Otherwise, the video
// will freeze, and will only recover with a complete key frame.
video_receiver_->SetDecodeErrorMode(kWithErrors);
vie_receiver_.SetNackStatus(false, max_nack_reordering_threshold_);
rtp_stream_receiver_->SetNackStatus(false, max_nack_reordering_threshold_);
}
}
@ -170,11 +153,7 @@ RtpState ViEChannel::GetRtpStateForSsrc(uint32_t ssrc) const {
void ViEChannel::RegisterRtcpPacketTypeCounterObserver(
RtcpPacketTypeCounterObserver* observer) {
vie_receiver_.RegisterRtcpPacketTypeCounterObserver(observer);
}
ViEReceiver* ViEChannel::vie_receiver() {
return &vie_receiver_;
rtp_stream_receiver_->RegisterRtcpPacketTypeCounterObserver(observer);
}
CallStatsObserver* ViEChannel::GetStatsObserver() {
@ -275,24 +254,6 @@ void ViEChannel::RegisterPreRenderCallback(
pre_render_callback_ = pre_render_callback;
}
// TODO(pbos): Remove as soon as audio can handle a changing payload type
// without this callback.
int32_t ViEChannel::OnInitializeDecoder(
const int8_t payload_type,
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
const int frequency,
const size_t channels,
const uint32_t rate) {
RTC_NOTREACHED();
return 0;
}
void ViEChannel::OnIncomingSSRCChanged(const uint32_t ssrc) {
rtp_rtcp_->SetRemoteSSRC(ssrc);
}
void ViEChannel::OnIncomingCSRCChanged(const uint32_t CSRC, const bool added) {}
void ViEChannel::RegisterReceiveStatisticsProxy(
ReceiveStatisticsProxy* receive_statistics_proxy) {
rtc::CritScope lock(&crit_);

30
webrtc/video/vie_channel.h
View File

@ -25,7 +25,7 @@
#include "webrtc/modules/video_coding/include/video_coding_defines.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/typedefs.h"
#include "webrtc/video/vie_receiver.h"
#include "webrtc/video/rtp_stream_receiver.h"
#include "webrtc/video/vie_sync_module.h"
namespace webrtc {
@ -39,7 +39,6 @@ class IncomingVideoStream;
class PacedSender;
class PacketRouter;
class PayloadRouter;
class ProcessThread;
class ReceiveStatisticsProxy;
class RtcpRttStats;
class ViERTPObserver;
@ -59,18 +58,12 @@ class ViEChannel : public VCMFrameTypeCallback,
public VCMReceiveCallback,
public VCMReceiveStatisticsCallback,
public VCMDecoderTimingCallback,
public VCMPacketRequestCallback,
public RtpFeedback {
public VCMPacketRequestCallback {
public:
friend class ChannelStatsObserver;
ViEChannel(Transport* transport,
ProcessThread* module_process_thread,
vcm::VideoReceiver* video_receiver,
RemoteBitrateEstimator* remote_bitrate_estimator,
RtcpRttStats* rtt_stats,
PacedSender* paced_sender,
PacketRouter* packet_router);
ViEChannel(vcm::VideoReceiver* video_receiver,
RtpStreamReceiver* rtp_stream_receiver);
~ViEChannel();
int32_t Init();
@ -84,17 +77,6 @@ class ViEChannel : public VCMFrameTypeCallback,
RtpState GetRtpStateForSsrc(uint32_t ssrc) const;
// Implements RtpFeedback.
int32_t OnInitializeDecoder(const int8_t payload_type,
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
const int frequency,
const size_t channels,
const uint32_t rate) override;
void OnIncomingSSRCChanged(const uint32_t ssrc) override;
void OnIncomingCSRCChanged(const uint32_t CSRC, const bool added) override;
// Gets the module used by the channel.
ViEReceiver* vie_receiver();
CallStatsObserver* GetStatsObserver();
@ -154,13 +136,11 @@ class ViEChannel : public VCMFrameTypeCallback,
// Compute NACK list parameters for the buffering mode.
int GetRequiredNackListSize(int target_delay_ms);
ProcessThread* const module_process_thread_;
// Used for all registered callbacks except rendering.
rtc::CriticalSection crit_;
vcm::VideoReceiver* const video_receiver_;
ViEReceiver vie_receiver_;
RtpStreamReceiver* const rtp_stream_receiver_;
RtpRtcp* const rtp_rtcp_;
// Helper to report call statistics.

4
webrtc/video/webrtc_video.gypi
View File

@ -39,6 +39,8 @@
'video/receive_statistics_proxy.h',
'video/report_block_stats.cc',
'video/report_block_stats.h',
'video/rtp_stream_receiver.cc',
'video/rtp_stream_receiver.h',
'video/send_statistics_proxy.cc',
'video/send_statistics_proxy.h',
'video/stream_synchronization.cc',
@ -55,8 +57,6 @@
'video/vie_channel.h',
'video/vie_encoder.cc',
'video/vie_encoder.h',
'video/vie_receiver.cc',
'video/vie_receiver.h',
'video/vie_remb.cc',
'video/vie_remb.h',
'video/vie_sync_module.cc',