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

Rename class RtpStreamReceiver --> RtpVideoStreamReceiver.

Browse Source 
This class is video-specific, and we want to free the name
"RtpStreamReceiver" so it can be reused for a media-independent RTP
receive class.

Also renames related files.

BUG=webrtc:7135

Review-Url: https://codereview.webrtc.org/2926253002
Cr-Commit-Position: refs/heads/master@{#18510}
This commit is contained in:
nisse 2017-06-09 04:01:55 -07:00 committed by Commit Bot
parent e2baffb055
commit b1f2ff900e
7 changed files with 134 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
webrtc/modules/rtp_rtcp/source/flexfec_receiver.cc
View File

@ -112,7 +112,7 @@ bool FlexfecReceiver::AddReceivedPacket(const RtpPacketReceived& packet) {
// This implementation only returns _recovered_ media packets through the
// callback, whereas the implementation in UlpfecReceiver returns _all inserted_
// media packets through the callback. The latter behaviour makes sense
// for ULPFEC, since the ULPFEC receiver is owned by the RtpStreamReceiver.
// for ULPFEC, since the ULPFEC receiver is owned by the RtpVideoStreamReceiver.
// Here, however, the received media pipeline is more decoupled from the
// FlexFEC decoder, and we therefore do not interfere with the reception
// of non-recovered media packets.

6
webrtc/video/BUILD.gn
View File

@ -24,10 +24,10 @@ rtc_static_library("video") {
"receive_statistics_proxy.h",
"report_block_stats.cc",
"report_block_stats.h",
"rtp_stream_receiver.cc",
"rtp_stream_receiver.h",
"rtp_streams_synchronizer.cc",
"rtp_streams_synchronizer.h",
"rtp_video_stream_receiver.cc",
"rtp_video_stream_receiver.h",
"send_delay_stats.cc",
"send_delay_stats.h",
"send_statistics_proxy.cc",
@ -240,7 +240,7 @@ if (rtc_include_tests) {
"quality_threshold_unittest.cc",
"receive_statistics_proxy_unittest.cc",
"report_block_stats_unittest.cc",
"rtp_stream_receiver_unittest.cc",
"rtp_video_stream_receiver_unittest.cc",
"send_delay_stats_unittest.cc",
"send_statistics_proxy_unittest.cc",
"stats_counter_unittest.cc",

94
webrtc/video/rtp_stream_receiver.cc → webrtc/video/rtp_video_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/rtp_stream_receiver.h"
#include "webrtc/video/rtp_video_stream_receiver.h"
#include <vector>
#include <utility>
@ -78,7 +78,7 @@ std::unique_ptr<RtpRtcp> CreateRtpRtcpModule(
static const int kPacketLogIntervalMs = 10000;
RtpStreamReceiver::RtpStreamReceiver(
RtpVideoStreamReceiver::RtpVideoStreamReceiver(
Transport* transport,
RtcpRttStats* rtt_stats,
PacketRouter* packet_router,
@ -189,7 +189,7 @@ RtpStreamReceiver::RtpStreamReceiver(
reference_finder_.reset(new video_coding::RtpFrameReferenceFinder(this));
}
RtpStreamReceiver::~RtpStreamReceiver() {
RtpVideoStreamReceiver::~RtpVideoStreamReceiver() {
if (nack_module_) {
process_thread_->DeRegisterModule(nack_module_.get());
}
@ -200,14 +200,14 @@ RtpStreamReceiver::~RtpStreamReceiver() {
UpdateHistograms();
}
bool RtpStreamReceiver::AddReceiveCodec(
bool RtpVideoStreamReceiver::AddReceiveCodec(
const VideoCodec& video_codec,
const std::map<std::string, std::string>& codec_params) {
pt_codec_params_.insert(make_pair(video_codec.plType, codec_params));
return AddReceiveCodec(video_codec);
}
bool RtpStreamReceiver::AddReceiveCodec(const VideoCodec& video_codec) {
bool RtpVideoStreamReceiver::AddReceiveCodec(const VideoCodec& video_codec) {
int8_t old_pltype = -1;
if (rtp_payload_registry_.ReceivePayloadType(video_codec, &old_pltype) !=
-1) {
@ -216,19 +216,19 @@ bool RtpStreamReceiver::AddReceiveCodec(const VideoCodec& video_codec) {
return rtp_payload_registry_.RegisterReceivePayload(video_codec) == 0;
}
uint32_t RtpStreamReceiver::GetRemoteSsrc() const {
uint32_t RtpVideoStreamReceiver::GetRemoteSsrc() const {
return rtp_receiver_->SSRC();
}
int RtpStreamReceiver::GetCsrcs(uint32_t* csrcs) const {
int RtpVideoStreamReceiver::GetCsrcs(uint32_t* csrcs) const {
return rtp_receiver_->CSRCs(csrcs);
}
RtpReceiver* RtpStreamReceiver::GetRtpReceiver() const {
RtpReceiver* RtpVideoStreamReceiver::GetRtpReceiver() const {
return rtp_receiver_.get();
}
int32_t RtpStreamReceiver::OnReceivedPayloadData(
int32_t RtpVideoStreamReceiver::OnReceivedPayloadData(
const uint8_t* payload_data,
size_t payload_size,
const WebRtcRTPHeader* rtp_header) {
@ -279,8 +279,8 @@ int32_t RtpStreamReceiver::OnReceivedPayloadData(
// TODO(nisse): Try to delete this method. Obstacles: It is used by
// ParseAndHandleEncapsulatingHeader, for handling Rtx packets, and
// for callbacks from |ulpfec_receiver_|.
void RtpStreamReceiver::OnRecoveredPacket(const uint8_t* rtp_packet,
size_t rtp_packet_length) {
void RtpVideoStreamReceiver::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;
@ -292,7 +292,7 @@ void RtpStreamReceiver::OnRecoveredPacket(const uint8_t* rtp_packet,
// TODO(pbos): Remove as soon as audio can handle a changing payload type
// without this callback.
int32_t RtpStreamReceiver::OnInitializeDecoder(
int32_t RtpVideoStreamReceiver::OnInitializeDecoder(
const int8_t payload_type,
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
const int frequency,
@ -302,13 +302,13 @@ int32_t RtpStreamReceiver::OnInitializeDecoder(
return 0;
}
void RtpStreamReceiver::OnIncomingSSRCChanged(const uint32_t ssrc) {
void RtpVideoStreamReceiver::OnIncomingSSRCChanged(const uint32_t ssrc) {
rtp_rtcp_->SetRemoteSSRC(ssrc);
}
// This method handles both regular RTP packets and packets recovered
// via FlexFEC.
void RtpStreamReceiver::OnRtpPacket(const RtpPacketReceived& packet) {
void RtpVideoStreamReceiver::OnRtpPacket(const RtpPacketReceived& packet) {
{
rtc::CritScope lock(&receive_cs_);
if (!receiving_) {
@ -364,35 +364,34 @@ void RtpStreamReceiver::OnRtpPacket(const RtpPacketReceived& packet) {
}
}
int32_t RtpStreamReceiver::RequestKeyFrame() {
int32_t RtpVideoStreamReceiver::RequestKeyFrame() {
return rtp_rtcp_->RequestKeyFrame();
}
bool RtpStreamReceiver::IsUlpfecEnabled() const {
bool RtpVideoStreamReceiver::IsUlpfecEnabled() const {
return config_.rtp.ulpfec.ulpfec_payload_type != -1;
}
bool RtpStreamReceiver::IsRedEnabled() const {
bool RtpVideoStreamReceiver::IsRedEnabled() const {
return config_.rtp.ulpfec.red_payload_type != -1;
}
bool RtpStreamReceiver::IsRetransmissionsEnabled() const {
bool RtpVideoStreamReceiver::IsRetransmissionsEnabled() const {
return config_.rtp.nack.rtp_history_ms > 0;
}
void RtpStreamReceiver::RequestPacketRetransmit(
void RtpVideoStreamReceiver::RequestPacketRetransmit(
const std::vector<uint16_t>& sequence_numbers) {
rtp_rtcp_->SendNack(sequence_numbers);
}
int32_t RtpStreamReceiver::ResendPackets(const uint16_t* sequence_numbers,
uint16_t length) {
int32_t RtpVideoStreamReceiver::ResendPackets(const uint16_t* sequence_numbers,
uint16_t length) {
return rtp_rtcp_->SendNACK(sequence_numbers, length);
}
void RtpStreamReceiver::OnReceivedFrame(
void RtpVideoStreamReceiver::OnReceivedFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame) {
if (!has_received_frame_) {
has_received_frame_ = true;
if (frame->FrameType() != kVideoFrameKey)
@ -404,7 +403,7 @@ void RtpStreamReceiver::OnReceivedFrame(
reference_finder_->ManageFrame(std::move(frame));
}
void RtpStreamReceiver::OnCompleteFrame(
void RtpVideoStreamReceiver::OnCompleteFrame(
std::unique_ptr<video_coding::FrameObject> frame) {
{
rtc::CritScope lock(&last_seq_num_cs_);
@ -415,23 +414,25 @@ void RtpStreamReceiver::OnCompleteFrame(
complete_frame_callback_->OnCompleteFrame(std::move(frame));
}
void RtpStreamReceiver::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) {
void RtpVideoStreamReceiver::OnRttUpdate(int64_t avg_rtt_ms,
int64_t max_rtt_ms) {
if (nack_module_)
nack_module_->UpdateRtt(max_rtt_ms);
}
rtc::Optional<int64_t> RtpStreamReceiver::LastReceivedPacketMs() const {
rtc::Optional<int64_t> RtpVideoStreamReceiver::LastReceivedPacketMs() const {
return packet_buffer_->LastReceivedPacketMs();
}
rtc::Optional<int64_t> RtpStreamReceiver::LastReceivedKeyframePacketMs() const {
rtc::Optional<int64_t> RtpVideoStreamReceiver::LastReceivedKeyframePacketMs()
const {
return packet_buffer_->LastReceivedKeyframePacketMs();
}
void RtpStreamReceiver::ReceivePacket(const uint8_t* packet,
size_t packet_length,
const RTPHeader& header,
bool in_order) {
void RtpVideoStreamReceiver::ReceivePacket(const uint8_t* packet,
size_t packet_length,
const RTPHeader& header,
bool in_order) {
if (rtp_payload_registry_.IsEncapsulated(header)) {
ParseAndHandleEncapsulatingHeader(packet, packet_length, header);
return;
@ -448,7 +449,7 @@ void RtpStreamReceiver::ReceivePacket(const uint8_t* packet,
payload_specific, in_order);
}
void RtpStreamReceiver::ParseAndHandleEncapsulatingHeader(
void RtpVideoStreamReceiver::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();
@ -493,7 +494,8 @@ void RtpStreamReceiver::ParseAndHandleEncapsulatingHeader(
}
}
void RtpStreamReceiver::NotifyReceiverOfFecPacket(const RTPHeader& header) {
void RtpVideoStreamReceiver::NotifyReceiverOfFecPacket(
const RTPHeader& header) {
int8_t last_media_payload_type =
rtp_payload_registry_.last_received_media_payload_type();
if (last_media_payload_type < 0) {
@ -525,8 +527,8 @@ void RtpStreamReceiver::NotifyReceiverOfFecPacket(const RTPHeader& header) {
OnReceivedPayloadData(nullptr, 0, &rtp_header);
}
bool RtpStreamReceiver::DeliverRtcp(const uint8_t* rtcp_packet,
size_t rtcp_packet_length) {
bool RtpVideoStreamReceiver::DeliverRtcp(const uint8_t* rtcp_packet,
size_t rtcp_packet_length) {
{
rtc::CritScope lock(&receive_cs_);
if (!receiving_) {
@ -555,7 +557,7 @@ bool RtpStreamReceiver::DeliverRtcp(const uint8_t* rtcp_packet,
return true;
}
void RtpStreamReceiver::FrameContinuous(uint16_t picture_id) {
void RtpVideoStreamReceiver::FrameContinuous(uint16_t picture_id) {
if (!nack_module_)
return;
@ -570,7 +572,7 @@ void RtpStreamReceiver::FrameContinuous(uint16_t picture_id) {
nack_module_->ClearUpTo(seq_num);
}
void RtpStreamReceiver::FrameDecoded(uint16_t picture_id) {
void RtpVideoStreamReceiver::FrameDecoded(uint16_t picture_id) {
int seq_num = -1;
{
rtc::CritScope lock(&last_seq_num_cs_);
@ -587,22 +589,22 @@ void RtpStreamReceiver::FrameDecoded(uint16_t picture_id) {
}
}
void RtpStreamReceiver::SignalNetworkState(NetworkState state) {
void RtpVideoStreamReceiver::SignalNetworkState(NetworkState state) {
rtp_rtcp_->SetRTCPStatus(state == kNetworkUp ? config_.rtp.rtcp_mode
: RtcpMode::kOff);
}
void RtpStreamReceiver::StartReceive() {
void RtpVideoStreamReceiver::StartReceive() {
rtc::CritScope lock(&receive_cs_);
receiving_ = true;
}
void RtpStreamReceiver::StopReceive() {
void RtpVideoStreamReceiver::StopReceive() {
rtc::CritScope lock(&receive_cs_);
receiving_ = false;
}
bool RtpStreamReceiver::IsPacketInOrder(const RTPHeader& header) const {
bool RtpVideoStreamReceiver::IsPacketInOrder(const RTPHeader& header) const {
StreamStatistician* statistician =
rtp_receive_statistics_->GetStatistician(header.ssrc);
if (!statistician)
@ -610,8 +612,8 @@ bool RtpStreamReceiver::IsPacketInOrder(const RTPHeader& header) const {
return statistician->IsPacketInOrder(header.sequenceNumber);
}
bool RtpStreamReceiver::IsPacketRetransmitted(const RTPHeader& header,
bool in_order) const {
bool RtpVideoStreamReceiver::IsPacketRetransmitted(const RTPHeader& header,
bool in_order) const {
// Retransmissions are handled separately if RTX is enabled.
if (rtp_payload_registry_.RtxEnabled())
return false;
@ -626,7 +628,7 @@ bool RtpStreamReceiver::IsPacketRetransmitted(const RTPHeader& header,
statistician->IsRetransmitOfOldPacket(header, min_rtt);
}
void RtpStreamReceiver::UpdateHistograms() {
void RtpVideoStreamReceiver::UpdateHistograms() {
FecPacketCounter counter = ulpfec_receiver_->GetPacketCounter();
if (counter.first_packet_time_ms == -1)
return;
@ -648,7 +650,7 @@ void RtpStreamReceiver::UpdateHistograms() {
}
}
void RtpStreamReceiver::EnableReceiveRtpHeaderExtension(
void RtpVideoStreamReceiver::EnableReceiveRtpHeaderExtension(
const std::string& extension, int id) {
// One-byte-extension local identifiers are in the range 1-14 inclusive.
RTC_DCHECK_GE(id, 1);
@ -658,7 +660,7 @@ void RtpStreamReceiver::EnableReceiveRtpHeaderExtension(
StringToRtpExtensionType(extension), id));
}
void RtpStreamReceiver::InsertSpsPpsIntoTracker(uint8_t payload_type) {
void RtpVideoStreamReceiver::InsertSpsPpsIntoTracker(uint8_t payload_type) {
auto codec_params_it = pt_codec_params_.find(payload_type);
if (codec_params_it == pt_codec_params_.end())
return;

26
webrtc/video/rtp_stream_receiver.h → webrtc/video/rtp_video_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_RTP_STREAM_RECEIVER_H_
#define WEBRTC_VIDEO_RTP_STREAM_RECEIVER_H_
#ifndef WEBRTC_VIDEO_RTP_VIDEO_STREAM_RECEIVER_H_
#define WEBRTC_VIDEO_RTP_VIDEO_STREAM_RECEIVER_H_
#include <list>
#include <map>
@ -55,16 +55,16 @@ namespace vcm {
class VideoReceiver;
} // namespace vcm
class RtpStreamReceiver : public RtpData,
public RecoveredPacketReceiver,
public RtpFeedback,
public VCMFrameTypeCallback,
public VCMPacketRequestCallback,
public video_coding::OnReceivedFrameCallback,
public video_coding::OnCompleteFrameCallback,
public CallStatsObserver {
class RtpVideoStreamReceiver : public RtpData,
public RecoveredPacketReceiver,
public RtpFeedback,
public VCMFrameTypeCallback,
public VCMPacketRequestCallback,
public video_coding::OnReceivedFrameCallback,
public video_coding::OnCompleteFrameCallback,
public CallStatsObserver {
public:
RtpStreamReceiver(
RtpVideoStreamReceiver(
Transport* transport,
RtcpRttStats* rtt_stats,
PacketRouter* packet_router,
@ -75,7 +75,7 @@ class RtpStreamReceiver : public RtpData,
KeyFrameRequestSender* keyframe_request_sender,
video_coding::OnCompleteFrameCallback* complete_frame_callback,
VCMTiming* timing);
~RtpStreamReceiver();
~RtpVideoStreamReceiver();
bool AddReceiveCodec(const VideoCodec& video_codec,
const std::map<std::string, std::string>& codec_params);
@ -203,4 +203,4 @@ class RtpStreamReceiver : public RtpData,
} // namespace webrtc
#endif // WEBRTC_VIDEO_RTP_STREAM_RECEIVER_H_
#endif // WEBRTC_VIDEO_RTP_VIDEO_STREAM_RECEIVER_H_

68
webrtc/video/rtp_stream_receiver_unittest.cc → webrtc/video/rtp_video_stream_receiver_unittest.cc
View File

@ -25,7 +25,7 @@
#include "webrtc/system_wrappers/include/clock.h"
#include "webrtc/system_wrappers/include/field_trial_default.h"
#include "webrtc/test/field_trial.h"
#include "webrtc/video/rtp_stream_receiver.h"
#include "webrtc/video/rtp_video_stream_receiver.h"
using testing::_;
@ -95,15 +95,15 @@ class MockOnCompleteFrameCallback
} // namespace
class RtpStreamReceiverTest : public testing::Test {
class RtpVideoStreamReceiverTest : public testing::Test {
public:
RtpStreamReceiverTest()
RtpVideoStreamReceiverTest()
: config_(CreateConfig()),
timing_(Clock::GetRealTimeClock()),
process_thread_(ProcessThread::Create("TestThread")) {}
void SetUp() {
rtp_stream_receiver_.reset(new RtpStreamReceiver(
rtp_video_stream_receiver_.reset(new RtpVideoStreamReceiver(
&mock_transport_, nullptr, &packet_router_, &config_,
nullptr, process_thread_.get(), &mock_nack_sender_,
&mock_key_frame_request_sender_, &mock_on_complete_frame_callback_,
@ -175,10 +175,10 @@ class RtpStreamReceiverTest : public testing::Test {
PacketRouter packet_router_;
VCMTiming timing_;
std::unique_ptr<ProcessThread> process_thread_;
std::unique_ptr<RtpStreamReceiver> rtp_stream_receiver_;
std::unique_ptr<RtpVideoStreamReceiver> rtp_video_stream_receiver_;
};
TEST_F(RtpStreamReceiverTest, GenericKeyFrame) {
TEST_F(RtpVideoStreamReceiverTest, GenericKeyFrame) {
WebRtcRTPHeader rtp_header;
const std::vector<uint8_t> data({1, 2, 3, 4});
memset(&rtp_header, 0, sizeof(rtp_header));
@ -190,11 +190,11 @@ TEST_F(RtpStreamReceiverTest, GenericKeyFrame) {
mock_on_complete_frame_callback_.AppendExpectedBitstream(data.data(),
data.size());
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_));
rtp_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(),
&rtp_header);
rtp_video_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(),
&rtp_header);
}
TEST_F(RtpStreamReceiverTest, GenericKeyFrameBitstreamError) {
TEST_F(RtpVideoStreamReceiverTest, GenericKeyFrameBitstreamError) {
WebRtcRTPHeader rtp_header;
const std::vector<uint8_t> data({1, 2, 3, 4});
memset(&rtp_header, 0, sizeof(rtp_header));
@ -208,11 +208,11 @@ TEST_F(RtpStreamReceiverTest, GenericKeyFrameBitstreamError) {
expected_bitsteam, sizeof(expected_bitsteam));
EXPECT_CALL(mock_on_complete_frame_callback_,
DoOnCompleteFrameFailBitstream(_));
rtp_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(),
&rtp_header);
rtp_video_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(),
&rtp_header);
}
TEST_F(RtpStreamReceiverTest, InBandSpsPps) {
TEST_F(RtpVideoStreamReceiverTest, InBandSpsPps) {
std::vector<uint8_t> sps_data;
WebRtcRTPHeader sps_packet = GetDefaultPacket();
AddSps(&sps_packet, 0, &sps_data);
@ -221,8 +221,8 @@ TEST_F(RtpStreamReceiverTest, InBandSpsPps) {
kH264StartCode, sizeof(kH264StartCode));
mock_on_complete_frame_callback_.AppendExpectedBitstream(sps_data.data(),
sps_data.size());
rtp_stream_receiver_->OnReceivedPayloadData(sps_data.data(), sps_data.size(),
&sps_packet);
rtp_video_stream_receiver_->OnReceivedPayloadData(
sps_data.data(), sps_data.size(), &sps_packet);
std::vector<uint8_t> pps_data;
WebRtcRTPHeader pps_packet = GetDefaultPacket();
@ -232,8 +232,8 @@ TEST_F(RtpStreamReceiverTest, InBandSpsPps) {
kH264StartCode, sizeof(kH264StartCode));
mock_on_complete_frame_callback_.AppendExpectedBitstream(pps_data.data(),
pps_data.size());
rtp_stream_receiver_->OnReceivedPayloadData(pps_data.data(), pps_data.size(),
&pps_packet);
rtp_video_stream_receiver_->OnReceivedPayloadData(
pps_data.data(), pps_data.size(), &pps_packet);
std::vector<uint8_t> idr_data;
WebRtcRTPHeader idr_packet = GetDefaultPacket();
@ -250,11 +250,11 @@ TEST_F(RtpStreamReceiverTest, InBandSpsPps) {
mock_on_complete_frame_callback_.AppendExpectedBitstream(idr_data.data(),
idr_data.size());
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_));
rtp_stream_receiver_->OnReceivedPayloadData(idr_data.data(), idr_data.size(),
&idr_packet);
rtp_video_stream_receiver_->OnReceivedPayloadData(
idr_data.data(), idr_data.size(), &idr_packet);
}
TEST_F(RtpStreamReceiverTest, OutOfBandFmtpSpsPps) {
TEST_F(RtpVideoStreamReceiverTest, OutOfBandFmtpSpsPps) {
constexpr int kPayloadType = 99;
VideoCodec codec;
codec.plType = kPayloadType;
@ -263,7 +263,7 @@ TEST_F(RtpStreamReceiverTest, OutOfBandFmtpSpsPps) {
// .
codec_params.insert(
{cricket::kH264FmtpSpropParameterSets, "Z0IACpZTBYmI,aMljiA=="});
rtp_stream_receiver_->AddReceiveCodec(codec, codec_params);
rtp_video_stream_receiver_->AddReceiveCodec(codec, codec_params);
const uint8_t binary_sps[] = {0x67, 0x42, 0x00, 0x0a, 0x96,
0x53, 0x05, 0x89, 0x88};
mock_on_complete_frame_callback_.AppendExpectedBitstream(
@ -292,11 +292,11 @@ TEST_F(RtpStreamReceiverTest, OutOfBandFmtpSpsPps) {
mock_on_complete_frame_callback_.AppendExpectedBitstream(data.data(),
data.size());
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_));
rtp_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(),
&idr_packet);
rtp_video_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(),
&idr_packet);
}
TEST_F(RtpStreamReceiverTest, PaddingInMediaStream) {
TEST_F(RtpVideoStreamReceiverTest, PaddingInMediaStream) {
WebRtcRTPHeader header = GetDefaultPacket();
std::vector<uint8_t> data;
data.insert(data.end(), {1, 2, 3});
@ -310,28 +310,28 @@ TEST_F(RtpStreamReceiverTest, PaddingInMediaStream) {
data.size());
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_));
rtp_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(),
&header);
rtp_video_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(),
&header);
header.header.sequenceNumber = 3;
rtp_stream_receiver_->OnReceivedPayloadData(nullptr, 0, &header);
rtp_video_stream_receiver_->OnReceivedPayloadData(nullptr, 0, &header);
header.frameType = kVideoFrameDelta;
header.header.sequenceNumber = 4;
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_));
rtp_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(),
&header);
rtp_video_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(),
&header);
header.header.sequenceNumber = 6;
rtp_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(),
&header);
rtp_video_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(),
&header);
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_));
header.header.sequenceNumber = 5;
rtp_stream_receiver_->OnReceivedPayloadData(nullptr, 0, &header);
rtp_video_stream_receiver_->OnReceivedPayloadData(nullptr, 0, &header);
}
TEST_F(RtpStreamReceiverTest, RequestKeyframeIfFirstFrameIsDelta) {
TEST_F(RtpVideoStreamReceiverTest, RequestKeyframeIfFirstFrameIsDelta) {
WebRtcRTPHeader rtp_header;
const std::vector<uint8_t> data({1, 2, 3, 4});
memset(&rtp_header, 0, sizeof(rtp_header));
@ -342,8 +342,8 @@ TEST_F(RtpStreamReceiverTest, RequestKeyframeIfFirstFrameIsDelta) {
rtp_header.type.Video.codec = kRtpVideoGeneric;
EXPECT_CALL(mock_key_frame_request_sender_, RequestKeyFrame());
rtp_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(),
&rtp_header);
rtp_video_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(),
&rtp_header);
}
} // namespace webrtc

64
webrtc/video/video_receive_stream.cc
View File

@ -184,16 +184,16 @@ VideoReceiveStream::VideoReceiveStream(
timing_(new VCMTiming(clock_)),
video_receiver_(clock_, nullptr, this, timing_.get(), this, this),
stats_proxy_(&config_, clock_),
rtp_stream_receiver_(&transport_adapter_,
call_stats_->rtcp_rtt_stats(),
packet_router,
&config_,
&stats_proxy_,
process_thread_,
this, // NackSender
this, // KeyFrameRequestSender
this, // OnCompleteFrameCallback
timing_.get()),
rtp_video_stream_receiver_(&transport_adapter_,
call_stats_->rtcp_rtt_stats(),
packet_router,
&config_,
&stats_proxy_,
process_thread_,
this, // NackSender
this, // KeyFrameRequestSender
this, // OnCompleteFrameCallback
timing_.get()),
rtp_stream_sync_(this) {
LOG(LS_INFO) << "VideoReceiveStream: " << config_.ToString();
@ -234,16 +234,16 @@ VideoReceiveStream::~VideoReceiveStream() {
void VideoReceiveStream::SignalNetworkState(NetworkState state) {
RTC_DCHECK_RUN_ON(&worker_thread_checker_);
rtp_stream_receiver_.SignalNetworkState(state);
rtp_video_stream_receiver_.SignalNetworkState(state);
}
bool VideoReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) {
return rtp_stream_receiver_.DeliverRtcp(packet, length);
return rtp_video_stream_receiver_.DeliverRtcp(packet, length);
}
void VideoReceiveStream::OnRtpPacket(const RtpPacketReceived& packet) {
rtp_stream_receiver_.OnRtpPacket(packet);
rtp_video_stream_receiver_.OnRtpPacket(packet);
}
void VideoReceiveStream::SetSync(Syncable* audio_syncable) {
@ -257,12 +257,13 @@ void VideoReceiveStream::Start() {
return;
bool protected_by_fec = config_.rtp.protected_by_flexfec ||
rtp_stream_receiver_.IsUlpfecEnabled();
rtp_video_stream_receiver_.IsUlpfecEnabled();
frame_buffer_->Start();
call_stats_->RegisterStatsObserver(&rtp_stream_receiver_);
call_stats_->RegisterStatsObserver(&rtp_video_stream_receiver_);
if (rtp_stream_receiver_.IsRetransmissionsEnabled() && protected_by_fec) {
if (rtp_video_stream_receiver_.IsRetransmissionsEnabled() &&
protected_by_fec) {
frame_buffer_->SetProtectionMode(kProtectionNackFEC);
}
@ -283,34 +284,35 @@ void VideoReceiveStream::Start() {
video_receiver_.RegisterExternalDecoder(decoder.decoder,
decoder.payload_type);
VideoCodec codec = CreateDecoderVideoCodec(decoder);
RTC_CHECK(
rtp_stream_receiver_.AddReceiveCodec(codec, decoder.codec_params));
RTC_CHECK(rtp_video_stream_receiver_.AddReceiveCodec(codec,
decoder.codec_params));
RTC_CHECK_EQ(VCM_OK, video_receiver_.RegisterReceiveCodec(
&codec, num_cpu_cores_, false));
}
video_stream_decoder_.reset(new VideoStreamDecoder(
&video_receiver_, &rtp_stream_receiver_, &rtp_stream_receiver_,
rtp_stream_receiver_.IsRetransmissionsEnabled(), protected_by_fec,
&video_receiver_, &rtp_video_stream_receiver_,
&rtp_video_stream_receiver_,
rtp_video_stream_receiver_.IsRetransmissionsEnabled(), protected_by_fec,
&stats_proxy_, renderer));
// Register the channel to receive stats updates.
call_stats_->RegisterStatsObserver(video_stream_decoder_.get());
// Start the decode thread
decode_thread_.Start();
decode_thread_.SetPriority(rtc::kHighestPriority);
rtp_stream_receiver_.StartReceive();
rtp_video_stream_receiver_.StartReceive();
}
void VideoReceiveStream::Stop() {
RTC_DCHECK_RUN_ON(&worker_thread_checker_);
rtp_stream_receiver_.StopReceive();
rtp_video_stream_receiver_.StopReceive();
// TriggerDecoderShutdown will release any waiting decoder thread and make it
// stop immediately, instead of waiting for a timeout. Needs to be called
// before joining the decoder thread thread.
video_receiver_.TriggerDecoderShutdown();
frame_buffer_->Stop();
call_stats_->DeregisterStatsObserver(&rtp_stream_receiver_);
call_stats_->DeregisterStatsObserver(&rtp_video_stream_receiver_);
if (decode_thread_.IsRunning()) {
decode_thread_.Stop();
@ -403,18 +405,18 @@ EncodedImageCallback::Result VideoReceiveStream::OnEncodedImage(
void VideoReceiveStream::SendNack(
const std::vector<uint16_t>& sequence_numbers) {
rtp_stream_receiver_.RequestPacketRetransmit(sequence_numbers);
rtp_video_stream_receiver_.RequestPacketRetransmit(sequence_numbers);
}
void VideoReceiveStream::RequestKeyFrame() {
rtp_stream_receiver_.RequestKeyFrame();
rtp_video_stream_receiver_.RequestKeyFrame();
}
void VideoReceiveStream::OnCompleteFrame(
std::unique_ptr<video_coding::FrameObject> frame) {
int last_continuous_pid = frame_buffer_->InsertFrame(std::move(frame));
if (last_continuous_pid != -1)
rtp_stream_receiver_.FrameContinuous(last_continuous_pid);
rtp_video_stream_receiver_.FrameContinuous(last_continuous_pid);
}
int VideoReceiveStream::id() const {
@ -426,14 +428,14 @@ rtc::Optional<Syncable::Info> VideoReceiveStream::GetInfo() const {
RTC_DCHECK_RUN_ON(&module_process_thread_checker_);
Syncable::Info info;
RtpReceiver* rtp_receiver = rtp_stream_receiver_.GetRtpReceiver();
RtpReceiver* rtp_receiver = rtp_video_stream_receiver_.GetRtpReceiver();
RTC_DCHECK(rtp_receiver);
if (!rtp_receiver->Timestamp(&info.latest_received_capture_timestamp))
return rtc::Optional<Syncable::Info>();
if (!rtp_receiver->LastReceivedTimeMs(&info.latest_receive_time_ms))
return rtc::Optional<Syncable::Info>();
RtpRtcp* rtp_rtcp = rtp_stream_receiver_.rtp_rtcp();
RtpRtcp* rtp_rtcp = rtp_video_stream_receiver_.rtp_rtcp();
RTC_DCHECK(rtp_rtcp);
if (rtp_rtcp->RemoteNTP(&info.capture_time_ntp_secs,
&info.capture_time_ntp_frac,
@ -475,13 +477,13 @@ bool VideoReceiveStream::Decode() {
if (frame) {
if (video_receiver_.Decode(frame.get()) == VCM_OK)
rtp_stream_receiver_.FrameDecoded(frame->picture_id);
rtp_video_stream_receiver_.FrameDecoded(frame->picture_id);
} else {
int64_t now_ms = clock_->TimeInMilliseconds();
rtc::Optional<int64_t> last_packet_ms =
rtp_stream_receiver_.LastReceivedPacketMs();
rtp_video_stream_receiver_.LastReceivedPacketMs();
rtc::Optional<int64_t> last_keyframe_packet_ms =
rtp_stream_receiver_.LastReceivedKeyframePacketMs();
rtp_video_stream_receiver_.LastReceivedKeyframePacketMs();
// To avoid spamming keyframe requests for a stream that is not active we
// check if we have received a packet within the last 5 seconds.

4
webrtc/video/video_receive_stream.h
View File

@ -24,8 +24,8 @@
#include "webrtc/modules/video_coding/video_coding_impl.h"
#include "webrtc/system_wrappers/include/clock.h"
#include "webrtc/video/receive_statistics_proxy.h"
#include "webrtc/video/rtp_stream_receiver.h"
#include "webrtc/video/rtp_streams_synchronizer.h"
#include "webrtc/video/rtp_video_stream_receiver.h"
#include "webrtc/video/transport_adapter.h"
#include "webrtc/video/video_stream_decoder.h"
#include "webrtc/video_receive_stream.h"
@ -127,7 +127,7 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream,
vcm::VideoReceiver video_receiver_;
std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>> incoming_video_stream_;
ReceiveStatisticsProxy stats_proxy_;
RtpStreamReceiver rtp_stream_receiver_;
RtpVideoStreamReceiver rtp_video_stream_receiver_;
std::unique_ptr<VideoStreamDecoder> video_stream_decoder_;
RtpStreamsSynchronizer rtp_stream_sync_;