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

Delete support for sending RTCP RPSI and SLI messages.

Browse Source 
BUG=webrtc:7338

Review-Url: https://codereview.webrtc.org/2746413003
Cr-Commit-Position: refs/heads/master@{#17229}
This commit is contained in:
nisse
2017-03-14 08:54:43 -07:00
committed by Commit bot
parent 0a73564338
commit cd386eb13f
14 changed files with 8 additions and 160 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
webrtc/modules/rtp_rtcp/include/rtp_rtcp.h
View File

@ -313,13 +313,6 @@ class RtpRtcp : public Module {
virtual int32_t SendCompoundRTCP(
const std::set<RTCPPacketType>& rtcp_packet_types) = 0;
// Notifies the sender about good state of the RTP receiver.
virtual int32_t SendRTCPReferencePictureSelection(uint64_t picture_id) = 0;
// Send a RTCP Slice Loss Indication (SLI).
// |picture_id| - 6 least significant bits of picture_id.
virtual int32_t SendRTCPSliceLossIndication(uint8_t picture_id) = 0;
// Returns statistics of the amount of data sent.
// Returns -1 on failure else 0.
virtual int32_t DataCountersRTP(size_t* bytes_sent,

2
webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
View File

@ -144,8 +144,6 @@ class MockRtpRtcp : public RtpRtcp {
MOCK_METHOD1(SendRTCP, int32_t(RTCPPacketType packet_type));
MOCK_METHOD1(SendCompoundRTCP,
int32_t(const std::set<RTCPPacketType>& packet_types));
MOCK_METHOD1(SendRTCPReferencePictureSelection, int32_t(uint64_t picture_id));
MOCK_METHOD1(SendRTCPSliceLossIndication, int32_t(uint8_t picture_id));
MOCK_CONST_METHOD2(DataCountersRTP,
int32_t(size_t* bytes_sent, uint32_t* packets_sent));
MOCK_CONST_METHOD2(GetSendStreamDataCounters,

60
webrtc/modules/rtp_rtcp/source/rtcp_sender.cc
View File

@ -30,10 +30,8 @@
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/pli.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sli.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
@ -129,18 +127,15 @@ class RTCPSender::RtcpContext {
RtcpContext(const FeedbackState& feedback_state,
int32_t nack_size,
const uint16_t* nack_list,
uint64_t picture_id,
NtpTime now)
: feedback_state_(feedback_state),
nack_size_(nack_size),
nack_list_(nack_list),
picture_id_(picture_id),
now_(now) {}
const FeedbackState& feedback_state_;
const int32_t nack_size_;
const uint16_t* nack_list_;
const uint64_t picture_id_;
const NtpTime now_;
};
@ -190,8 +185,6 @@ RTCPSender::RTCPSender(
builders_[kRtcpSdes] = &RTCPSender::BuildSDES;
builders_[kRtcpPli] = &RTCPSender::BuildPLI;
builders_[kRtcpFir] = &RTCPSender::BuildFIR;
builders_[kRtcpSli] = &RTCPSender::BuildSLI;
builders_[kRtcpRpsi] = &RTCPSender::BuildRPSI;
builders_[kRtcpRemb] = &RTCPSender::BuildREMB;
builders_[kRtcpBye] = &RTCPSender::BuildBYE;
builders_[kRtcpApp] = &RTCPSender::BuildAPP;
@ -516,49 +509,6 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildFIR(const RtcpContext& ctx) {
return std::unique_ptr<rtcp::RtcpPacket>(fir);
}
/*
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| First | Number | PictureID |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*/
std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildSLI(const RtcpContext& ctx) {
rtcp::Sli* sli = new rtcp::Sli();
sli->SetSenderSsrc(ssrc_);
sli->SetMediaSsrc(remote_ssrc_);
// Crop picture id to 6 least significant bits.
sli->AddPictureId(ctx.picture_id_ & 0x3F);
return std::unique_ptr<rtcp::RtcpPacket>(sli);
}
/*
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| PB |0| Payload Type| Native RPSI bit string |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| defined per codec ... | Padding (0) |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*/
/*
* Note: not generic made for VP8
*/
std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildRPSI(
const RtcpContext& ctx) {
if (ctx.feedback_state_.send_payload_type == 0xFF)
return nullptr;
rtcp::Rpsi* rpsi = new rtcp::Rpsi();
rpsi->SetSenderSsrc(ssrc_);
rpsi->SetMediaSsrc(remote_ssrc_);
rpsi->SetPayloadType(ctx.feedback_state_.send_payload_type);
rpsi->SetPictureId(ctx.picture_id_);
return std::unique_ptr<rtcp::RtcpPacket>(rpsi);
}
std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildREMB(
const RtcpContext& ctx) {
rtcp::Remb* remb = new rtcp::Remb();
@ -736,19 +686,17 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildExtendedReports(
int32_t RTCPSender::SendRTCP(const FeedbackState& feedback_state,
RTCPPacketType packetType,
int32_t nack_size,
const uint16_t* nack_list,
uint64_t pictureID) {
const uint16_t* nack_list) {
return SendCompoundRTCP(
feedback_state, std::set<RTCPPacketType>(&packetType, &packetType + 1),
nack_size, nack_list, pictureID);
nack_size, nack_list);
}
int32_t RTCPSender::SendCompoundRTCP(
const FeedbackState& feedback_state,
const std::set<RTCPPacketType>& packet_types,
int32_t nack_size,
const uint16_t* nack_list,
uint64_t pictureID) {
const uint16_t* nack_list) {
PacketContainer container(transport_, event_log_);
size_t max_packet_size;
@ -782,7 +730,7 @@ int32_t RTCPSender::SendCompoundRTCP(
packet_type_counter_.first_packet_time_ms = clock_->TimeInMilliseconds();
// We need to send our NTP even if we haven't received any reports.
RtcpContext context(feedback_state, nack_size, nack_list, pictureID,
RtcpContext context(feedback_state, nack_size, nack_list,
clock_->CurrentNtpTime());
PrepareReport(feedback_state);

10
webrtc/modules/rtp_rtcp/source/rtcp_sender.h
View File

@ -112,14 +112,12 @@ class RTCPSender {
int32_t SendRTCP(const FeedbackState& feedback_state,
RTCPPacketType packetType,
int32_t nackSize = 0,
const uint16_t* nackList = 0,
uint64_t pictureID = 0);
const uint16_t* nackList = 0);
int32_t SendCompoundRTCP(const FeedbackState& feedback_state,
const std::set<RTCPPacketType>& packetTypes,
int32_t nackSize = 0,
const uint16_t* nackList = 0,
uint64_t pictureID = 0);
const uint16_t* nackList = 0);
bool REMB() const;
@ -186,10 +184,6 @@ class RTCPSender {
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
std::unique_ptr<rtcp::RtcpPacket> BuildFIR(const RtcpContext& context)
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
std::unique_ptr<rtcp::RtcpPacket> BuildSLI(const RtcpContext& context)
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
std::unique_ptr<rtcp::RtcpPacket> BuildRPSI(const RtcpContext& context)
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
std::unique_ptr<rtcp::RtcpPacket> BuildNACK(const RtcpContext& context)
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);

29
webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
View File

@ -472,35 +472,6 @@ TEST_F(RtcpSenderTest, SendPli) {
EXPECT_EQ(kRemoteSsrc, parser()->pli()->media_ssrc());
}
TEST_F(RtcpSenderTest, SendRpsi) {
const uint64_t kPictureId = 0x41;
const int8_t kPayloadType = 100;
rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
feedback_state.send_payload_type = kPayloadType;
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpRpsi, 0, nullptr,
kPictureId));
EXPECT_EQ(1, parser()->rpsi()->num_packets());
EXPECT_EQ(kPayloadType, parser()->rpsi()->payload_type());
EXPECT_EQ(kPictureId, parser()->rpsi()->picture_id());
}
TEST_F(RtcpSenderTest, SendSli) {
const uint16_t kFirstMb = 0;
const uint16_t kNumberOfMb = 0x1FFF;
const uint8_t kPictureId = 60;
rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSli, 0, nullptr,
kPictureId));
EXPECT_EQ(1, parser()->sli()->num_packets());
EXPECT_EQ(kSenderSsrc, parser()->sli()->sender_ssrc());
EXPECT_EQ(kRemoteSsrc, parser()->sli()->media_ssrc());
EXPECT_EQ(1U, parser()->sli()->macroblocks().size());
EXPECT_EQ(kFirstMb, parser()->sli()->macroblocks()[0].first());
EXPECT_EQ(kNumberOfMb, parser()->sli()->macroblocks()[0].number());
EXPECT_EQ(kPictureId, parser()->sli()->macroblocks()[0].picture_id());
}
TEST_F(RtcpSenderTest, SendNack) {
rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
const uint16_t kList[] = {0, 1, 16};

9
webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
View File

@ -754,10 +754,6 @@ int32_t ModuleRtpRtcpImpl::RequestKeyFrame() {
return -1;
}
int32_t ModuleRtpRtcpImpl::SendRTCPSliceLossIndication(uint8_t picture_id) {
return rtcp_sender_.SendRTCP(GetFeedbackState(), kRtcpSli, 0, 0, picture_id);
}
void ModuleRtpRtcpImpl::SetUlpfecConfig(int red_payload_type,
int ulpfec_payload_type) {
rtp_sender_.SetUlpfecConfig(red_payload_type, ulpfec_payload_type);
@ -789,11 +785,6 @@ void ModuleRtpRtcpImpl::OnRequestSendReport() {
SendRTCP(kRtcpSr);
}
int32_t ModuleRtpRtcpImpl::SendRTCPReferencePictureSelection(
const uint64_t picture_id) {
return rtcp_sender_.SendRTCP(GetFeedbackState(), kRtcpRpsi, 0, 0, picture_id);
}
void ModuleRtpRtcpImpl::OnReceivedNack(
const std::vector<uint16_t>& nack_sequence_numbers) {
for (uint16_t nack_sequence_number : nack_sequence_numbers) {

5
webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h
View File

@ -269,8 +269,6 @@ class ModuleRtpRtcpImpl : public RtpRtcp, public RTCPReceiver::ModuleRtpRtcp {
// Video part.
int32_t SendRTCPSliceLossIndication(uint8_t picture_id) override;
// Set method for requesting a new key frame.
int32_t SetKeyFrameRequestMethod(KeyFrameRequestMethod method) override;
@ -293,9 +291,6 @@ class ModuleRtpRtcpImpl : public RtpRtcp, public RTCPReceiver::ModuleRtpRtcp {
uint32_t* fec_rate,
uint32_t* nackRate) const override;
// Good state of RTP receiver inform sender.
int32_t SendRTCPReferencePictureSelection(uint64_t picture_id) override;
void RegisterSendChannelRtpStatisticsCallback(
StreamDataCountersCallback* callback) override;
StreamDataCountersCallback* GetSendChannelRtpStatisticsCallback()

5
webrtc/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc
View File

@ -191,11 +191,6 @@ class RtpRtcpRtcpTest : public ::testing::Test {
RateLimiter retransmission_rate_limiter_;
};
TEST_F(RtpRtcpRtcpTest, RTCP_PLI_RPSI) {
EXPECT_EQ(0, module1->SendRTCPReferencePictureSelection(kTestPictureId));
EXPECT_EQ(0, module1->SendRTCPSliceLossIndication(kSliPictureId));
}
TEST_F(RtpRtcpRtcpTest, RTCP_CNAME) {
uint32_t testOfCSRC[webrtc::kRtpCsrcSize];
EXPECT_EQ(2, rtp_receiver2_->CSRCs(testOfCSRC));

1
webrtc/modules/video_coding/include/mock/mock_vcm_callbacks.h
View File

@ -20,7 +20,6 @@ namespace webrtc {
class MockVCMFrameTypeCallback : public VCMFrameTypeCallback {
public:
MOCK_METHOD0(RequestKeyFrame, int32_t());
MOCK_METHOD1(SliceLossIndicationRequest, int32_t(const uint64_t pictureId));
};
class MockPacketRequestCallback : public VCMPacketRequestCallback {

5
webrtc/modules/video_coding/include/video_coding_defines.h
View File

@ -24,7 +24,6 @@ namespace webrtc {
// Error codes
#define VCM_FRAME_NOT_READY 3
#define VCM_REQUEST_SLI 2
#define VCM_MISSING_CALLBACK 1
#define VCM_OK 0
#define VCM_GENERAL_ERROR -1
@ -38,7 +37,6 @@ namespace webrtc {
#define VCM_JITTER_BUFFER_ERROR -9
#define VCM_OLD_PACKET_ERROR -10
#define VCM_NO_FRAME_DECODED -11
#define VCM_ERROR_REQUEST_SLI -12
#define VCM_NOT_IMPLEMENTED -20
enum { kDefaultStartBitrateKbps = 300 };
@ -141,9 +139,6 @@ class VCMProtectionCallback {
class VCMFrameTypeCallback {
public:
virtual int32_t RequestKeyFrame() = 0;
virtual int32_t SliceLossIndicationRequest(const uint64_t pictureId) {
return -1;
}
protected:
virtual ~VCMFrameTypeCallback() {}

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

@ -207,7 +207,6 @@ class VideoReceiver : public Module {
int32_t Decode(const webrtc::VCMEncodedFrame& frame)
EXCLUSIVE_LOCKS_REQUIRED(receive_crit_);
int32_t RequestKeyFrame();
int32_t RequestSliceLossIndication(const uint64_t pictureID) const;
private:
rtc::ThreadChecker construction_thread_;

25
webrtc/modules/video_coding/video_receiver.cc
View File

@ -306,22 +306,6 @@ void VideoReceiver::DecodingStopped() {
// TODO(tommi): Make use of this to clarify and check threading model.
}
int32_t VideoReceiver::RequestSliceLossIndication(
const uint64_t pictureID) const {
TRACE_EVENT1("webrtc", "RequestSLI", "picture_id", pictureID);
rtc::CritScope cs(&process_crit_);
if (_frameTypeCallback != nullptr) {
const int32_t ret =
_frameTypeCallback->SliceLossIndicationRequest(pictureID);
if (ret < 0) {
return ret;
}
} else {
return VCM_MISSING_CALLBACK;
}
return VCM_OK;
}
int32_t VideoReceiver::RequestKeyFrame() {
TRACE_EVENT0("webrtc", "RequestKeyFrame");
rtc::CritScope cs(&process_crit_);
@ -352,16 +336,9 @@ int32_t VideoReceiver::Decode(const VCMEncodedFrame& frame) {
// Check for failed decoding, run frame type request callback if needed.
bool request_key_frame = false;
if (ret < 0) {
if (ret == VCM_ERROR_REQUEST_SLI) {
return RequestSliceLossIndication(
_decodedFrameCallback.LastReceivedPictureID() + 1);
} else {
request_key_frame = true;
}
} else if (ret == VCM_REQUEST_SLI) {
ret = RequestSliceLossIndication(
_decodedFrameCallback.LastReceivedPictureID() + 1);
}
if (!frame.Complete() || frame.MissingFrame()) {
request_key_frame = true;
ret = VCM_OK;

6
webrtc/video/rtp_stream_receiver.cc
View File

@ -362,12 +362,6 @@ int32_t RtpStreamReceiver::RequestKeyFrame() {
return rtp_rtcp_->RequestKeyFrame();
}
int32_t RtpStreamReceiver::SliceLossIndicationRequest(
const uint64_t picture_id) {
return rtp_rtcp_->SendRTCPSliceLossIndication(
static_cast<uint8_t>(picture_id));
}
bool RtpStreamReceiver::IsUlpfecEnabled() const {
return config_.rtp.ulpfec.ulpfec_payload_type != -1;
}

1
webrtc/video/rtp_stream_receiver.h
View File

@ -117,7 +117,6 @@ class RtpStreamReceiver : public RtpData,
// Implements VCMFrameTypeCallback.
int32_t RequestKeyFrame() override;
int32_t SliceLossIndicationRequest(const uint64_t picture_id) override;
bool IsUlpfecEnabled() const;
bool IsRetransmissionsEnabled() const;