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

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

@ -255,28 +255,6 @@ RTPSenderVideo::RTPSenderVideo(const Config& config)
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(
std::unique_ptr<RtpPacketToSend> media_packet,
bool protect_media_packet,
@ -284,44 +262,39 @@ void RTPSenderVideo::AppendAsRedMaybeWithUlpfec(
std::unique_ptr<RtpPacketToSend> red_packet(
new RtpPacketToSend(*media_packet));
BuildRedPayload(*media_packet, red_packet.get());
red_packet->SetPayloadType(*red_payload_type_);
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 (protect_media_packet) {
if (exclude_transport_sequence_number_from_fec_experiment_) {
// See comments at the top of the file why experiment
// "WebRTC-kExcludeTransportSequenceNumberFromFec" is needed in
// conjunction with datagram transport.
// TODO(sukhanov): We may also need to implement it for flexfec_sender
// if we decide to keep this approach in the future.
uint16_t transport_senquence_number;
if (media_packet->GetExtension<webrtc::TransportSequenceNumber>(
&transport_senquence_number)) {
if (!media_packet->RemoveExtension(
webrtc::TransportSequenceNumber::kId)) {
RTC_NOTREACHED()
<< "Failed to remove transport sequence number, packet="
<< media_packet->ToString();
}
if (ulpfec_enabled()) {
if (protect_media_packet) {
if (exclude_transport_sequence_number_from_fec_experiment_) {
// See comments at the top of the file why experiment
// "WebRTC-kExcludeTransportSequenceNumberFromFec" is needed in
// conjunction with datagram transport.
// TODO(sukhanov): We may also need to implement it for flexfec_sender
// if we decide to keep this approach in the future.
uint16_t transport_senquence_number;
if (media_packet->GetExtension<webrtc::TransportSequenceNumber>(
&transport_senquence_number)) {
if (!media_packet->RemoveExtension(
webrtc::TransportSequenceNumber::kId)) {
RTC_NOTREACHED()
<< "Failed to remove transport sequence number, packet="
<< media_packet->ToString();
}
}
}
ulpfec_generator_.AddRtpPacketAndGenerateFec(
media_packet->Buffer(), media_packet->headers_size());
}
uint16_t num_fec_packets = ulpfec_generator_.NumAvailableFecPackets();
if (num_fec_packets > 0) {
uint16_t first_fec_sequence_number =
rtp_sender_->AllocateSequenceNumber(num_fec_packets);
fec_packets = ulpfec_generator_.GetUlpfecPacketsAsRed(
*red_payload_type_, *ulpfec_payload_type_,
first_fec_sequence_number);
RTC_DCHECK_EQ(num_fec_packets, fec_packets.size());
}
ulpfec_generator_.AddRtpPacketAndGenerateFec(
media_packet->Buffer(), media_packet->headers_size());
}
uint16_t num_fec_packets = ulpfec_generator_.NumAvailableFecPackets();
if (num_fec_packets > 0) {
uint16_t first_fec_sequence_number =
rtp_sender_->AllocateSequenceNumber(num_fec_packets);
fec_packets = ulpfec_generator_.GetUlpfecPacketsAsRed(
*red_payload_type_, *ulpfec_payload_type_, first_fec_sequence_number);
RTC_DCHECK_EQ(num_fec_packets, fec_packets.size());
}
}
@ -405,33 +378,7 @@ void RTPSenderVideo::LogAndSendToNetwork(
}
}
void RTPSenderVideo::SetUlpfecConfig(int red_payload_type,
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 {
size_t RTPSenderVideo::FecPacketOverhead() const {
if (flexfec_enabled())
return flexfec_sender_->MaxPacketOverhead();
@ -467,54 +414,6 @@ absl::optional<uint32_t> RTPSenderVideo::FlexfecSsrc() const {
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(
int payload_type,
absl::optional<VideoCodecType> codec_type,
@ -581,9 +480,7 @@ bool RTPSenderVideo::SendVideo(
transmit_color_space_next_frame_ ? !IsBaseLayer(video_header) : false;
}
size_t fec_packet_overhead;
bool red_enabled;
{
if (flexfec_enabled() || ulpfec_enabled()) {
rtc::CritScope cs(&crit_);
// FEC settings.
const FecProtectionParams& fec_params =
@ -594,14 +491,11 @@ bool RTPSenderVideo::SendVideo(
flexfec_sender_->SetFecParameters(fec_params);
if (ulpfec_enabled())
ulpfec_generator_.SetFecParameters(fec_params);
fec_packet_overhead = CalculateFecPacketOverhead();
red_enabled = this->red_enabled();
}
// Maximum size of packet including rtp headers.
// 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);
std::unique_ptr<RtpPacketToSend> single_packet =
@ -782,7 +676,7 @@ bool RTPSenderVideo::SendVideo(
protect_packet = false;
}
if (red_enabled) {
if (red_enabled()) {
AppendAsRedMaybeWithUlpfec(std::move(packet), protect_packet,
&rtp_packets);
} else {

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

@ -102,43 +102,6 @@ class RTPSenderVideo {
const RTPFragmentationHeader* fragmentation,
RTPVideoHeader video_header,
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.
// Set FEC rates, max frames before FEC is sent, and type of FEC masks.
// Returns false on failure.
@ -182,12 +145,13 @@ class RTPSenderVideo {
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(
std::unique_ptr<RtpPacketToSend> 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
// moved to PacedSender.
@ -198,13 +162,9 @@ class RTPSenderVideo {
std::vector<std::unique_ptr<RtpPacketToSend>> packets,
size_t unpacketized_payload_size);
bool red_enabled() const RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_) {
return red_payload_type_.has_value();
}
bool red_enabled() const { return red_payload_type_.has_value(); }
bool ulpfec_enabled() const RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_) {
return ulpfec_payload_type_.has_value();
}
bool ulpfec_enabled() const { return ulpfec_payload_type_.has_value(); }
bool flexfec_enabled() const { return flexfec_sender_ != nullptr; }
@ -215,12 +175,6 @@ class RTPSenderVideo {
RTPSender* const rtp_sender_;
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_;
// These members should only be accessed from within SendVideo() to avoid
@ -246,9 +200,9 @@ class RTPSenderVideo {
RTC_PT_GUARDED_BY(crit_);
// RED/ULPFEC.
absl::optional<int> red_payload_type_ RTC_GUARDED_BY(crit_);
absl::optional<int> ulpfec_payload_type_ RTC_GUARDED_BY(crit_);
UlpfecGenerator ulpfec_generator_ RTC_GUARDED_BY(crit_);
const absl::optional<int> red_payload_type_;
const absl::optional<int> ulpfec_payload_type_;
UlpfecGenerator ulpfec_generator_ RTC_GUARDED_BY(send_checker_);
// FlexFEC.
FlexfecSender* const flexfec_sender_;