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

Remove deprecated functions in RTPSenderVideo

Browse Source 
Bug: webrtc:10809
Change-Id: I7f5b175b43f3e79c0400b80c7278723d6036d8ee
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/156567
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Erik Språng <sprang@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#29463}
This commit is contained in:
Danil Chapovalov
2019-10-14 14:20:20 +02:00
committed by Commit Bot
parent fbde32e596
commit 0deef725b9
2 changed files with 40 additions and 192 deletions
Download Patch File Download Diff File Expand all files Collapse all files

118
modules/rtp_rtcp/source/rtp_sender_video.cc
View File

@ -255,28 +255,6 @@ RTPSenderVideo::RTPSenderVideo(const Config& config)
RTPSenderVideo::~RTPSenderVideo() {} RTPSenderVideo::~RTPSenderVideo() {}
void RTPSenderVideo::RegisterPayloadType(int8_t payload_type,
absl::string_view payload_name,
bool raw_payload) {
absl::optional<VideoCodecType> video_type;
if (!raw_payload) {
if (absl::EqualsIgnoreCase(payload_name, "VP8")) {
video_type = kVideoCodecVP8;
} else if (absl::EqualsIgnoreCase(payload_name, "VP9")) {
video_type = kVideoCodecVP9;
} else if (absl::EqualsIgnoreCase(payload_name, "H264")) {
video_type = kVideoCodecH264;
} else {
video_type = kVideoCodecGeneric;
}
}
{
rtc::CritScope cs(&payload_type_crit_);
payload_type_map_[payload_type] = video_type;
}
}
void RTPSenderVideo::AppendAsRedMaybeWithUlpfec( void RTPSenderVideo::AppendAsRedMaybeWithUlpfec(
std::unique_ptr<RtpPacketToSend> media_packet, std::unique_ptr<RtpPacketToSend> media_packet,
bool protect_media_packet, bool protect_media_packet,
@ -284,12 +262,9 @@ void RTPSenderVideo::AppendAsRedMaybeWithUlpfec(
std::unique_ptr<RtpPacketToSend> red_packet( std::unique_ptr<RtpPacketToSend> red_packet(
new RtpPacketToSend(*media_packet)); new RtpPacketToSend(*media_packet));
BuildRedPayload(*media_packet, red_packet.get()); BuildRedPayload(*media_packet, red_packet.get());
red_packet->SetPayloadType(*red_payload_type_);
std::vector<std::unique_ptr<RedPacket>> fec_packets; std::vector<std::unique_ptr<RedPacket>> fec_packets;
{
// Only protect while creating RED and FEC packets, not when sending.
rtc::CritScope cs(&crit_);
red_packet->SetPayloadType(*red_payload_type_);
if (ulpfec_enabled()) { if (ulpfec_enabled()) {
if (protect_media_packet) { if (protect_media_packet) {
if (exclude_transport_sequence_number_from_fec_experiment_) { if (exclude_transport_sequence_number_from_fec_experiment_) {
@ -318,12 +293,10 @@ void RTPSenderVideo::AppendAsRedMaybeWithUlpfec(
uint16_t first_fec_sequence_number = uint16_t first_fec_sequence_number =
rtp_sender_->AllocateSequenceNumber(num_fec_packets); rtp_sender_->AllocateSequenceNumber(num_fec_packets);
fec_packets = ulpfec_generator_.GetUlpfecPacketsAsRed( fec_packets = ulpfec_generator_.GetUlpfecPacketsAsRed(
*red_payload_type_, *ulpfec_payload_type_, *red_payload_type_, *ulpfec_payload_type_, first_fec_sequence_number);
first_fec_sequence_number);
RTC_DCHECK_EQ(num_fec_packets, fec_packets.size()); RTC_DCHECK_EQ(num_fec_packets, fec_packets.size());
} }
} }
}
// Send |red_packet| instead of |packet| for allocated sequence number. // Send |red_packet| instead of |packet| for allocated sequence number.
red_packet->set_packet_type(RtpPacketToSend::Type::kVideo); red_packet->set_packet_type(RtpPacketToSend::Type::kVideo);
@ -405,33 +378,7 @@ void RTPSenderVideo::LogAndSendToNetwork(
} }
} }
void RTPSenderVideo::SetUlpfecConfig(int red_payload_type, size_t RTPSenderVideo::FecPacketOverhead() const {
int ulpfec_payload_type) {
// Sanity check. Per the definition of UlpfecConfig (see config.h),
// a payload type of -1 means that the corresponding feature is
// turned off.
RTC_DCHECK_GE(red_payload_type, -1);
RTC_DCHECK_LE(red_payload_type, 127);
RTC_DCHECK_GE(ulpfec_payload_type, -1);
RTC_DCHECK_LE(ulpfec_payload_type, 127);
rtc::CritScope cs(&crit_);
if (red_payload_type != -1) {
red_payload_type_ = red_payload_type;
}
if (ulpfec_payload_type != -1) {
ulpfec_payload_type_ = ulpfec_payload_type;
}
// Must not enable ULPFEC without RED.
RTC_DCHECK(!(red_enabled() ^ ulpfec_enabled()));
// Reset FEC parameters.
delta_fec_params_ = FecProtectionParams{0, 1, kFecMaskRandom};
key_fec_params_ = FecProtectionParams{0, 1, kFecMaskRandom};
}
size_t RTPSenderVideo::CalculateFecPacketOverhead() const {
if (flexfec_enabled()) if (flexfec_enabled())
return flexfec_sender_->MaxPacketOverhead(); return flexfec_sender_->MaxPacketOverhead();
@ -467,54 +414,6 @@ absl::optional<uint32_t> RTPSenderVideo::FlexfecSsrc() const {
return absl::nullopt; return absl::nullopt;
} }
bool RTPSenderVideo::SendVideo(
VideoFrameType frame_type,
int8_t payload_type,
uint32_t rtp_timestamp,
int64_t capture_time_ms,
const uint8_t* payload_data,
size_t payload_size,
const RTPFragmentationHeader* fragmentation,
const RTPVideoHeader* video_header,
absl::optional<int64_t> expected_retransmission_time_ms) {
absl::optional<VideoCodecType> codec_type;
{
rtc::CritScope cs(&payload_type_crit_);
const auto it = payload_type_map_.find(payload_type);
if (it == payload_type_map_.end()) {
RTC_LOG(LS_ERROR) << "Payload type " << static_cast<int>(payload_type)
<< " not registered.";
return false;
}
codec_type = it->second;
}
RTPVideoHeader rtp_video_header = *video_header;
rtp_video_header.frame_type = frame_type;
return SendVideo(payload_type, codec_type, rtp_timestamp, capture_time_ms,
rtc::MakeArrayView(payload_data, payload_size),
fragmentation, rtp_video_header,
expected_retransmission_time_ms);
}
bool RTPSenderVideo::SendVideo(
VideoFrameType frame_type,
int8_t payload_type,
absl::optional<VideoCodecType> codec_type,
uint32_t rtp_timestamp,
int64_t capture_time_ms,
const uint8_t* payload_data,
size_t payload_size,
const RTPFragmentationHeader* fragmentation,
const RTPVideoHeader* video_header,
absl::optional<int64_t> expected_retransmission_time_ms) {
RTPVideoHeader rtp_video_header = *video_header;
rtp_video_header.frame_type = frame_type;
return SendVideo(payload_type, codec_type, rtp_timestamp, capture_time_ms,
rtc::MakeArrayView(payload_data, payload_size),
fragmentation, rtp_video_header,
expected_retransmission_time_ms);
}
bool RTPSenderVideo::SendVideo( bool RTPSenderVideo::SendVideo(
int payload_type, int payload_type,
absl::optional<VideoCodecType> codec_type, absl::optional<VideoCodecType> codec_type,
@ -581,9 +480,7 @@ bool RTPSenderVideo::SendVideo(
transmit_color_space_next_frame_ ? !IsBaseLayer(video_header) : false; transmit_color_space_next_frame_ ? !IsBaseLayer(video_header) : false;
} }
size_t fec_packet_overhead; if (flexfec_enabled() || ulpfec_enabled()) {
bool red_enabled;
{
rtc::CritScope cs(&crit_); rtc::CritScope cs(&crit_);
// FEC settings. // FEC settings.
const FecProtectionParams& fec_params = const FecProtectionParams& fec_params =
@ -594,14 +491,11 @@ bool RTPSenderVideo::SendVideo(
flexfec_sender_->SetFecParameters(fec_params); flexfec_sender_->SetFecParameters(fec_params);
if (ulpfec_enabled()) if (ulpfec_enabled())
ulpfec_generator_.SetFecParameters(fec_params); ulpfec_generator_.SetFecParameters(fec_params);
fec_packet_overhead = CalculateFecPacketOverhead();
red_enabled = this->red_enabled();
} }
// Maximum size of packet including rtp headers. // Maximum size of packet including rtp headers.
// Extra space left in case packet will be resent using fec or rtx. // Extra space left in case packet will be resent using fec or rtx.
int packet_capacity = rtp_sender_->MaxRtpPacketSize() - fec_packet_overhead - int packet_capacity = rtp_sender_->MaxRtpPacketSize() - FecPacketOverhead() -
(rtp_sender_->RtxStatus() ? kRtxHeaderSize : 0); (rtp_sender_->RtxStatus() ? kRtxHeaderSize : 0);
std::unique_ptr<RtpPacketToSend> single_packet = std::unique_ptr<RtpPacketToSend> single_packet =
@ -782,7 +676,7 @@ bool RTPSenderVideo::SendVideo(
protect_packet = false; protect_packet = false;
} }
if (red_enabled) { if (red_enabled()) {
AppendAsRedMaybeWithUlpfec(std::move(packet), protect_packet, AppendAsRedMaybeWithUlpfec(std::move(packet), protect_packet,
&rtp_packets); &rtp_packets);
} else { } else {

62
modules/rtp_rtcp/source/rtp_sender_video.h
View File

@ -102,43 +102,6 @@ class RTPSenderVideo {
const RTPFragmentationHeader* fragmentation, const RTPFragmentationHeader* fragmentation,
RTPVideoHeader video_header, RTPVideoHeader video_header,
absl::optional<int64_t> expected_retransmission_time_ms); absl::optional<int64_t> expected_retransmission_time_ms);
RTC_DEPRECATED
bool SendVideo(VideoFrameType frame_type,
int8_t payload_type,
absl::optional<VideoCodecType> codec_type,
uint32_t rtp_timestamp,
int64_t capture_time_ms,
const uint8_t* payload_data,
size_t payload_size,
const RTPFragmentationHeader* fragmentation,
const RTPVideoHeader* video_header,
absl::optional<int64_t> expected_retransmission_time_ms);
// TODO(bugs.webrtc.org/10809): Remove when downstream usage is gone.
RTC_DEPRECATED
bool SendVideo(VideoFrameType frame_type,
int8_t payload_type,
uint32_t capture_timestamp,
int64_t capture_time_ms,
const uint8_t* payload_data,
size_t payload_size,
const RTPFragmentationHeader* fragmentation,
const RTPVideoHeader* video_header,
absl::optional<int64_t> expected_retransmission_time_ms);
// TODO(bugs.webrtc.org/10809): Remove when downstream usage is gone.
void RegisterPayloadType(int8_t payload_type,
absl::string_view payload_name,
bool raw_payload);
// Set RED and ULPFEC payload types. A payload type of -1 means that the
// corresponding feature is turned off. Note that we DO NOT support enabling
// ULPFEC without enabling RED, and RED is only ever used when ULPFEC is
// enabled.
// TODO(bugs.webrtc.org/10809): Remove when downstream usage is gone.
void SetUlpfecConfig(int red_payload_type, int ulpfec_payload_type);
// FlexFEC/ULPFEC. // FlexFEC/ULPFEC.
// Set FEC rates, max frames before FEC is sent, and type of FEC masks. // Set FEC rates, max frames before FEC is sent, and type of FEC masks.
// Returns false on failure. // Returns false on failure.
@ -182,12 +145,13 @@ class RTPSenderVideo {
int64_t last_frame_time_ms; int64_t last_frame_time_ms;
}; };
size_t CalculateFecPacketOverhead() const RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_); size_t FecPacketOverhead() const RTC_EXCLUSIVE_LOCKS_REQUIRED(send_checker_);
void AppendAsRedMaybeWithUlpfec( void AppendAsRedMaybeWithUlpfec(
std::unique_ptr<RtpPacketToSend> media_packet, std::unique_ptr<RtpPacketToSend> media_packet,
bool protect_media_packet, bool protect_media_packet,
std::vector<std::unique_ptr<RtpPacketToSend>>* packets); std::vector<std::unique_ptr<RtpPacketToSend>>* packets)
RTC_EXCLUSIVE_LOCKS_REQUIRED(send_checker_);
// TODO(brandtr): Remove the FlexFEC functions when FlexfecSender has been // TODO(brandtr): Remove the FlexFEC functions when FlexfecSender has been
// moved to PacedSender. // moved to PacedSender.
@ -198,13 +162,9 @@ class RTPSenderVideo {
std::vector<std::unique_ptr<RtpPacketToSend>> packets, std::vector<std::unique_ptr<RtpPacketToSend>> packets,
size_t unpacketized_payload_size); size_t unpacketized_payload_size);
bool red_enabled() const RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_) { bool red_enabled() const { return red_payload_type_.has_value(); }
return red_payload_type_.has_value();
}
bool ulpfec_enabled() const RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_) { bool ulpfec_enabled() const { return ulpfec_payload_type_.has_value(); }
return ulpfec_payload_type_.has_value();
}
bool flexfec_enabled() const { return flexfec_sender_ != nullptr; } bool flexfec_enabled() const { return flexfec_sender_ != nullptr; }
@ -215,12 +175,6 @@ class RTPSenderVideo {
RTPSender* const rtp_sender_; RTPSender* const rtp_sender_;
Clock* const clock_; Clock* const clock_;
// Maps payload type to codec type, for packetization.
// TODO(bugs.webrtc.org/10809): Remove when downstream usage is gone.
rtc::CriticalSection payload_type_crit_;
std::map<int8_t, absl::optional<VideoCodecType>> payload_type_map_
RTC_GUARDED_BY(payload_type_crit_);
const int32_t retransmission_settings_; const int32_t retransmission_settings_;
// These members should only be accessed from within SendVideo() to avoid // These members should only be accessed from within SendVideo() to avoid
@ -246,9 +200,9 @@ class RTPSenderVideo {
RTC_PT_GUARDED_BY(crit_); RTC_PT_GUARDED_BY(crit_);
// RED/ULPFEC. // RED/ULPFEC.
absl::optional<int> red_payload_type_ RTC_GUARDED_BY(crit_); const absl::optional<int> red_payload_type_;
absl::optional<int> ulpfec_payload_type_ RTC_GUARDED_BY(crit_); const absl::optional<int> ulpfec_payload_type_;
UlpfecGenerator ulpfec_generator_ RTC_GUARDED_BY(crit_); UlpfecGenerator ulpfec_generator_ RTC_GUARDED_BY(send_checker_);
// FlexFEC. // FlexFEC.
FlexfecSender* const flexfec_sender_; FlexfecSender* const flexfec_sender_;