niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 1 | /* |
pwestin@webrtc.org | f6bb77a | 2012-01-24 17:16:59 | [diff] [blame] | 2 | * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 11 | #include "modules/rtp_rtcp/source/rtp_sender_video.h" |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 12 | |
pbos@webrtc.org | a048d7c | 2013-05-29 14:27:38 | [diff] [blame] | 13 | #include <stdlib.h> |
| 14 | #include <string.h> |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 15 | |
Erik Språng | 56e611b | 2020-02-06 16:10:08 | [diff] [blame] | 16 | #include <algorithm> |
sprang | a8ae6f2 | 2017-09-04 14:23:56 | [diff] [blame] | 17 | #include <limits> |
kwiberg | 84be511 | 2016-04-27 08:19:58 | [diff] [blame] | 18 | #include <memory> |
Elad Alon | 8b60e8b | 2019-04-08 12:14:05 | [diff] [blame] | 19 | #include <string> |
danilchap | 7411061 | 2016-10-02 17:54:29 | [diff] [blame] | 20 | #include <utility> |
mflodman | fcf54bd | 2015-04-14 19:28:08 | [diff] [blame] | 21 | |
Danil Chapovalov | 4c3a7db | 2020-04-20 07:53:03 | [diff] [blame] | 22 | #include "absl/algorithm/container.h" |
Danil Chapovalov | 670af26 | 2020-01-30 15:28:53 | [diff] [blame] | 23 | #include "absl/memory/memory.h" |
Niels Möller | aa3c1cc | 2018-11-02 09:54:56 | [diff] [blame] | 24 | #include "absl/strings/match.h" |
Steve Anton | 10542f2 | 2019-01-11 17:11:00 | [diff] [blame] | 25 | #include "api/crypto/frame_encryptor_interface.h" |
Danil Chapovalov | 670af26 | 2020-01-30 15:28:53 | [diff] [blame] | 26 | #include "api/transport/rtp/dependency_descriptor.h" |
Niels Möller | 59ab1cf | 2019-02-06 21:48:11 | [diff] [blame] | 27 | #include "modules/remote_bitrate_estimator/test/bwe_test_logging.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 28 | #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" |
Minyue Li | 5bb9adc | 2020-01-22 12:02:34 | [diff] [blame] | 29 | #include "modules/rtp_rtcp/source/absolute_capture_time_sender.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 30 | #include "modules/rtp_rtcp/source/byte_io.h" |
Danil Chapovalov | 670af26 | 2020-01-30 15:28:53 | [diff] [blame] | 31 | #include "modules/rtp_rtcp/source/rtp_dependency_descriptor_extension.h" |
Danil Chapovalov | 95800f6 | 2020-02-20 14:01:15 | [diff] [blame] | 32 | #include "modules/rtp_rtcp/source/rtp_descriptor_authentication.h" |
Mirta Dvornicic | fe68daa | 2019-05-23 11:21:12 | [diff] [blame] | 33 | #include "modules/rtp_rtcp/source/rtp_format.h" |
philipel | b3e42a4 | 2018-09-13 08:57:14 | [diff] [blame] | 34 | #include "modules/rtp_rtcp/source/rtp_generic_frame_descriptor_extension.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 35 | #include "modules/rtp_rtcp/source/rtp_header_extensions.h" |
| 36 | #include "modules/rtp_rtcp/source/rtp_packet_to_send.h" |
Per Kjellander | 4f350ba | 2020-10-14 06:41:52 | [diff] [blame] | 37 | #include "modules/rtp_rtcp/source/rtp_video_layers_allocation_extension.h" |
Minyue Li | 5bb9adc | 2020-01-22 12:02:34 | [diff] [blame] | 38 | #include "modules/rtp_rtcp/source/time_util.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 39 | #include "rtc_base/checks.h" |
Johannes Kron | 4da8e4c | 2020-09-22 14:23:30 | [diff] [blame] | 40 | #include "rtc_base/experiments/field_trial_parser.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 41 | #include "rtc_base/logging.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 42 | #include "rtc_base/trace_event.h" |
ilnik | ed9b9ff | 2017-06-02 14:30:20 | [diff] [blame] | 43 | |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 44 | namespace webrtc { |
Sergey Ulanov | ec4f068 | 2016-07-28 22:19:10 | [diff] [blame] | 45 | |
brandtr | 6631e8a | 2016-09-13 10:23:29 | [diff] [blame] | 46 | namespace { |
| 47 | constexpr size_t kRedForFecHeaderLength = 1; |
sprang | a8ae6f2 | 2017-09-04 14:23:56 | [diff] [blame] | 48 | constexpr int64_t kMaxUnretransmittableFrameIntervalMs = 33 * 4; |
Minyue Li | e64b3d0 | 2020-08-20 14:18:31 | [diff] [blame] | 49 | constexpr char kIncludeCaptureClockOffset[] = |
| 50 | "WebRTC-IncludeCaptureClockOffset"; |
danilchap | 7411061 | 2016-10-02 17:54:29 | [diff] [blame] | 51 | |
| 52 | void BuildRedPayload(const RtpPacketToSend& media_packet, |
| 53 | RtpPacketToSend* red_packet) { |
| 54 | uint8_t* red_payload = red_packet->AllocatePayload( |
| 55 | kRedForFecHeaderLength + media_packet.payload_size()); |
| 56 | RTC_DCHECK(red_payload); |
| 57 | red_payload[0] = media_packet.PayloadType(); |
danilchap | 96c1587 | 2016-11-21 09:35:29 | [diff] [blame] | 58 | |
| 59 | auto media_payload = media_packet.payload(); |
| 60 | memcpy(&red_payload[kRedForFecHeaderLength], media_payload.data(), |
| 61 | media_payload.size()); |
danilchap | 7411061 | 2016-10-02 17:54:29 | [diff] [blame] | 62 | } |
Danil Chapovalov | e4f8b38 | 2018-09-07 15:30:26 | [diff] [blame] | 63 | |
Danil Chapovalov | 51bf200 | 2019-10-11 08:53:27 | [diff] [blame] | 64 | bool MinimizeDescriptor(RTPVideoHeader* video_header) { |
| 65 | if (auto* vp8 = |
| 66 | absl::get_if<RTPVideoHeaderVP8>(&video_header->video_type_header)) { |
Danil Chapovalov | 84ffb35 | 2018-09-25 16:59:09 | [diff] [blame] | 67 | // Set minimum fields the RtpPacketizer is using to create vp8 packets. |
Danil Chapovalov | 51bf200 | 2019-10-11 08:53:27 | [diff] [blame] | 68 | // nonReference is the only field that doesn't require extra space. |
| 69 | bool non_reference = vp8->nonReference; |
| 70 | vp8->InitRTPVideoHeaderVP8(); |
| 71 | vp8->nonReference = non_reference; |
Danil Chapovalov | 84ffb35 | 2018-09-25 16:59:09 | [diff] [blame] | 72 | return true; |
| 73 | } |
| 74 | // TODO(danilchap): Reduce vp9 codec specific descriptor too. |
| 75 | return false; |
| 76 | } |
| 77 | |
Johannes Kron | d0b69a8 | 2018-12-03 13:18:53 | [diff] [blame] | 78 | bool IsBaseLayer(const RTPVideoHeader& video_header) { |
| 79 | switch (video_header.codec) { |
| 80 | case kVideoCodecVP8: { |
| 81 | const auto& vp8 = |
| 82 | absl::get<RTPVideoHeaderVP8>(video_header.video_type_header); |
| 83 | return (vp8.temporalIdx == 0 || vp8.temporalIdx == kNoTemporalIdx); |
| 84 | } |
| 85 | case kVideoCodecVP9: { |
| 86 | const auto& vp9 = |
| 87 | absl::get<RTPVideoHeaderVP9>(video_header.video_type_header); |
| 88 | return (vp9.temporal_idx == 0 || vp9.temporal_idx == kNoTemporalIdx); |
| 89 | } |
| 90 | case kVideoCodecH264: |
| 91 | // TODO(kron): Implement logic for H264 once WebRTC supports temporal |
| 92 | // layers for H264. |
| 93 | break; |
| 94 | default: |
| 95 | break; |
| 96 | } |
| 97 | return true; |
| 98 | } |
| 99 | |
Doudou Kisabaka | 2dec496 | 2019-11-28 13:24:31 | [diff] [blame] | 100 | #if RTC_TRACE_EVENTS_ENABLED |
Niels Möller | 87e2d78 | 2019-03-07 09:18:23 | [diff] [blame] | 101 | const char* FrameTypeToString(VideoFrameType frame_type) { |
Niels Möller | 59ab1cf | 2019-02-06 21:48:11 | [diff] [blame] | 102 | switch (frame_type) { |
Niels Möller | 8f7ce22 | 2019-03-21 14:43:58 | [diff] [blame] | 103 | case VideoFrameType::kEmptyFrame: |
Niels Möller | 59ab1cf | 2019-02-06 21:48:11 | [diff] [blame] | 104 | return "empty"; |
Niels Möller | 8f7ce22 | 2019-03-21 14:43:58 | [diff] [blame] | 105 | case VideoFrameType::kVideoFrameKey: |
Niels Möller | 59ab1cf | 2019-02-06 21:48:11 | [diff] [blame] | 106 | return "video_key"; |
Niels Möller | 8f7ce22 | 2019-03-21 14:43:58 | [diff] [blame] | 107 | case VideoFrameType::kVideoFrameDelta: |
Niels Möller | 59ab1cf | 2019-02-06 21:48:11 | [diff] [blame] | 108 | return "video_delta"; |
| 109 | default: |
| 110 | RTC_NOTREACHED(); |
| 111 | return ""; |
| 112 | } |
| 113 | } |
Doudou Kisabaka | 2dec496 | 2019-11-28 13:24:31 | [diff] [blame] | 114 | #endif |
Niels Möller | 59ab1cf | 2019-02-06 21:48:11 | [diff] [blame] | 115 | |
Niels Möller | d381eed | 2020-09-02 13:34:40 | [diff] [blame] | 116 | bool IsNoopDelay(const VideoPlayoutDelay& delay) { |
Erik Språng | 56e611b | 2020-02-06 16:10:08 | [diff] [blame] | 117 | return delay.min_ms == -1 && delay.max_ms == -1; |
| 118 | } |
| 119 | |
Johannes Kron | 4da8e4c | 2020-09-22 14:23:30 | [diff] [blame] | 120 | absl::optional<VideoPlayoutDelay> LoadVideoPlayoutDelayOverride( |
| 121 | const WebRtcKeyValueConfig* key_value_config) { |
| 122 | RTC_DCHECK(key_value_config); |
| 123 | FieldTrialOptional<int> playout_delay_min_ms("min_ms", absl::nullopt); |
| 124 | FieldTrialOptional<int> playout_delay_max_ms("max_ms", absl::nullopt); |
| 125 | ParseFieldTrial({&playout_delay_max_ms, &playout_delay_min_ms}, |
| 126 | key_value_config->Lookup("WebRTC-ForceSendPlayoutDelay")); |
| 127 | return playout_delay_max_ms && playout_delay_min_ms |
| 128 | ? absl::make_optional<VideoPlayoutDelay>(*playout_delay_min_ms, |
| 129 | *playout_delay_max_ms) |
| 130 | : absl::nullopt; |
| 131 | } |
| 132 | |
Per Kjellander | 4f350ba | 2020-10-14 06:41:52 | [diff] [blame] | 133 | // Some packets can be skipped and the stream can still be decoded. Those |
| 134 | // packets are less likely to be retransmitted if they are lost. |
| 135 | bool PacketWillLikelyBeRequestedForRestransmitionIfLost( |
| 136 | const RTPVideoHeader& video_header) { |
| 137 | return IsBaseLayer(video_header) && |
| 138 | !(video_header.generic.has_value() |
| 139 | ? absl::c_linear_search( |
| 140 | video_header.generic->decode_target_indications, |
| 141 | DecodeTargetIndication::kDiscardable) |
| 142 | : false); |
| 143 | } |
| 144 | |
brandtr | 6631e8a | 2016-09-13 10:23:29 | [diff] [blame] | 145 | } // namespace |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 146 | |
Erik Språng | dc34a25 | 2019-10-04 13:17:29 | [diff] [blame] | 147 | RTPSenderVideo::RTPSenderVideo(const Config& config) |
| 148 | : rtp_sender_(config.rtp_sender), |
| 149 | clock_(config.clock), |
Andrei Dumitru | 0987273 | 2019-08-29 19:00:29 | [diff] [blame] | 150 | retransmission_settings_( |
Erik Språng | dc34a25 | 2019-10-04 13:17:29 | [diff] [blame] | 151 | config.enable_retransmit_all_layers |
Andrei Dumitru | 0987273 | 2019-08-29 19:00:29 | [diff] [blame] | 152 | ? kRetransmitAllLayers |
| 153 | : (kRetransmitBaseLayer | kConditionallyRetransmitHigherLayers)), |
brandtr | d804895 | 2016-11-07 10:08:51 | [diff] [blame] | 154 | last_rotation_(kVideoRotation_0), |
Johannes Kron | d0b69a8 | 2018-12-03 13:18:53 | [diff] [blame] | 155 | transmit_color_space_next_frame_(false), |
Per Kjellander | dbf9549 | 2020-12-22 15:12:15 | [diff] [blame] | 156 | send_allocation_(SendVideoLayersAllocation::kDontSend), |
Erik Språng | 56e611b | 2020-02-06 16:10:08 | [diff] [blame] | 157 | current_playout_delay_{-1, -1}, |
| 158 | playout_delay_pending_(false), |
Johannes Kron | 4da8e4c | 2020-09-22 14:23:30 | [diff] [blame] | 159 | forced_playout_delay_(LoadVideoPlayoutDelayOverride(config.field_trials)), |
Erik Språng | dc34a25 | 2019-10-04 13:17:29 | [diff] [blame] | 160 | red_payload_type_(config.red_payload_type), |
Erik Språng | 4210888 | 2020-05-05 12:51:09 | [diff] [blame] | 161 | fec_type_(config.fec_type), |
| 162 | fec_overhead_bytes_(config.fec_overhead_bytes), |
Erik Språng | 482b3ef | 2019-01-08 15:19:11 | [diff] [blame] | 163 | packetization_overhead_bitrate_(1000, RateStatistics::kBpsScale), |
Erik Språng | dc34a25 | 2019-10-04 13:17:29 | [diff] [blame] | 164 | frame_encryptor_(config.frame_encryptor), |
| 165 | require_frame_encryption_(config.require_frame_encryption), |
Mirko Bonadei | 06d3559 | 2020-04-01 11:43:08 | [diff] [blame] | 166 | generic_descriptor_auth_experiment_(!absl::StartsWith( |
| 167 | config.field_trials->Lookup("WebRTC-GenericDescriptorAuth"), |
| 168 | "Disabled")), |
Marina Ciocea | e77912b | 2020-02-27 15:16:55 | [diff] [blame] | 169 | absolute_capture_time_sender_(config.clock), |
Marina Ciocea | 3a087a8 | 2020-03-03 04:39:28 | [diff] [blame] | 170 | frame_transformer_delegate_( |
| 171 | config.frame_transformer |
| 172 | ? new rtc::RefCountedObject< |
| 173 | RTPSenderVideoFrameTransformerDelegate>( |
Marina Ciocea | dc69fd2 | 2020-04-10 18:19:14 | [diff] [blame] | 174 | this, |
| 175 | config.frame_transformer, |
Marina Ciocea | 2e69660 | 2020-05-29 10:37:01 | [diff] [blame] | 176 | rtp_sender_->SSRC(), |
Marina Ciocea | f1c5b95 | 2020-06-01 10:03:09 | [diff] [blame] | 177 | config.send_transport_queue) |
Minyue Li | e64b3d0 | 2020-08-20 14:18:31 | [diff] [blame] | 178 | : nullptr), |
| 179 | include_capture_clock_offset_(absl::StartsWith( |
| 180 | config.field_trials->Lookup(kIncludeCaptureClockOffset), |
| 181 | "Enabled")) { |
Marina Ciocea | 3a087a8 | 2020-03-03 04:39:28 | [diff] [blame] | 182 | if (frame_transformer_delegate_) |
| 183 | frame_transformer_delegate_->Init(); |
| 184 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 185 | |
Marina Ciocea | 3a087a8 | 2020-03-03 04:39:28 | [diff] [blame] | 186 | RTPSenderVideo::~RTPSenderVideo() { |
| 187 | if (frame_transformer_delegate_) |
| 188 | frame_transformer_delegate_->Reset(); |
| 189 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 190 | |
Erik Språng | f1e97b9 | 2019-09-26 10:48:47 | [diff] [blame] | 191 | void RTPSenderVideo::LogAndSendToNetwork( |
| 192 | std::vector<std::unique_ptr<RtpPacketToSend>> packets, |
| 193 | size_t unpacketized_payload_size) { |
Erik Språng | f1e97b9 | 2019-09-26 10:48:47 | [diff] [blame] | 194 | { |
Markus Handell | e7c015e | 2020-07-07 09:44:28 | [diff] [blame] | 195 | MutexLock lock(&stats_mutex_); |
Erik Språng | f1e97b9 | 2019-09-26 10:48:47 | [diff] [blame] | 196 | size_t packetized_payload_size = 0; |
| 197 | for (const auto& packet : packets) { |
Erik Språng | f87536c | 2020-03-05 09:14:04 | [diff] [blame] | 198 | if (*packet->packet_type() == RtpPacketMediaType::kVideo) { |
Erik Språng | f87536c | 2020-03-05 09:14:04 | [diff] [blame] | 199 | packetized_payload_size += packet->payload_size(); |
Erik Språng | f1e97b9 | 2019-09-26 10:48:47 | [diff] [blame] | 200 | } |
| 201 | } |
Danil Chapovalov | 31cb3ab | 2020-07-21 13:01:50 | [diff] [blame] | 202 | // AV1 and H264 packetizers may produce less packetized bytes than |
| 203 | // unpacketized. |
Danil Chapovalov | 0682ca9 | 2019-11-28 15:50:02 | [diff] [blame] | 204 | if (packetized_payload_size >= unpacketized_payload_size) { |
| 205 | packetization_overhead_bitrate_.Update( |
| 206 | packetized_payload_size - unpacketized_payload_size, |
| 207 | clock_->TimeInMilliseconds()); |
| 208 | } |
Erik Språng | f1e97b9 | 2019-09-26 10:48:47 | [diff] [blame] | 209 | } |
| 210 | |
Erik Språng | fc78aac | 2019-10-24 10:55:30 | [diff] [blame] | 211 | rtp_sender_->EnqueuePackets(std::move(packets)); |
Niels Möller | 59ab1cf | 2019-02-06 21:48:11 | [diff] [blame] | 212 | } |
| 213 | |
Danil Chapovalov | 0deef72 | 2019-10-14 12:20:20 | [diff] [blame] | 214 | size_t RTPSenderVideo::FecPacketOverhead() const { |
Erik Språng | 4210888 | 2020-05-05 12:51:09 | [diff] [blame] | 215 | size_t overhead = fec_overhead_bytes_; |
brandtr | f1bb476 | 2016-11-07 11:05:06 | [diff] [blame] | 216 | if (red_enabled()) { |
brandtr | 131bc49 | 2016-11-10 13:01:11 | [diff] [blame] | 217 | // The RED overhead is due to a small header. |
| 218 | overhead += kRedForFecHeaderLength; |
Erik Språng | f87536c | 2020-03-05 09:14:04 | [diff] [blame] | 219 | |
Erik Språng | 4210888 | 2020-05-05 12:51:09 | [diff] [blame] | 220 | if (fec_type_ == VideoFecGenerator::FecType::kUlpFec) { |
Erik Språng | f87536c | 2020-03-05 09:14:04 | [diff] [blame] | 221 | // For ULPFEC, the overhead is the FEC headers plus RED for FEC header |
| 222 | // (see above) plus anything in RTP header beyond the 12 bytes base header |
| 223 | // (CSRC list, extensions...) |
| 224 | // This reason for the header extensions to be included here is that |
| 225 | // from an FEC viewpoint, they are part of the payload to be protected. |
| 226 | // (The base RTP header is already protected by the FEC header.) |
Erik Språng | 04e1bab | 2020-05-07 16:18:32 | [diff] [blame] | 227 | overhead += |
| 228 | rtp_sender_->FecOrPaddingPacketMaxRtpHeaderLength() - kRtpHeaderSize; |
Erik Språng | f87536c | 2020-03-05 09:14:04 | [diff] [blame] | 229 | } |
pbos@webrtc.org | b5e6bfc | 2014-09-12 11:05:55 | [diff] [blame] | 230 | } |
stefan | 8f4c77f | 2016-06-03 07:16:45 | [diff] [blame] | 231 | return overhead; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 232 | } |
| 233 | |
Danil Chapovalov | 670af26 | 2020-01-30 15:28:53 | [diff] [blame] | 234 | void RTPSenderVideo::SetVideoStructure( |
| 235 | const FrameDependencyStructure* video_structure) { |
Marina Ciocea | 3a087a8 | 2020-03-03 04:39:28 | [diff] [blame] | 236 | if (frame_transformer_delegate_) { |
| 237 | frame_transformer_delegate_->SetVideoStructureUnderLock(video_structure); |
| 238 | return; |
| 239 | } |
Per Kjellander | 4f350ba | 2020-10-14 06:41:52 | [diff] [blame] | 240 | SetVideoStructureInternal(video_structure); |
Marina Ciocea | 3a087a8 | 2020-03-03 04:39:28 | [diff] [blame] | 241 | } |
| 242 | |
Per Kjellander | 4f350ba | 2020-10-14 06:41:52 | [diff] [blame] | 243 | void RTPSenderVideo::SetVideoStructureAfterTransformation( |
| 244 | const FrameDependencyStructure* video_structure) { |
| 245 | SetVideoStructureInternal(video_structure); |
| 246 | } |
| 247 | |
| 248 | void RTPSenderVideo::SetVideoStructureInternal( |
Marina Ciocea | 3a087a8 | 2020-03-03 04:39:28 | [diff] [blame] | 249 | const FrameDependencyStructure* video_structure) { |
Danil Chapovalov | 670af26 | 2020-01-30 15:28:53 | [diff] [blame] | 250 | RTC_DCHECK_RUNS_SERIALIZED(&send_checker_); |
| 251 | if (video_structure == nullptr) { |
| 252 | video_structure_ = nullptr; |
| 253 | return; |
| 254 | } |
| 255 | // Simple sanity checks video structure is set up. |
| 256 | RTC_DCHECK_GT(video_structure->num_decode_targets, 0); |
| 257 | RTC_DCHECK_GT(video_structure->templates.size(), 0); |
| 258 | |
| 259 | int structure_id = 0; |
| 260 | if (video_structure_) { |
| 261 | if (*video_structure_ == *video_structure) { |
| 262 | // Same structure (just a new key frame), no update required. |
| 263 | return; |
| 264 | } |
| 265 | // When setting different video structure make sure structure_id is updated |
| 266 | // so that templates from different structures do not collide. |
| 267 | static constexpr int kMaxTemplates = 64; |
| 268 | structure_id = |
| 269 | (video_structure_->structure_id + video_structure_->templates.size()) % |
| 270 | kMaxTemplates; |
| 271 | } |
| 272 | |
| 273 | video_structure_ = |
| 274 | std::make_unique<FrameDependencyStructure>(*video_structure); |
| 275 | video_structure_->structure_id = structure_id; |
Danil Chapovalov | 670af26 | 2020-01-30 15:28:53 | [diff] [blame] | 276 | } |
| 277 | |
Per Kjellander | 4f350ba | 2020-10-14 06:41:52 | [diff] [blame] | 278 | void RTPSenderVideo::SetVideoLayersAllocation( |
| 279 | VideoLayersAllocation allocation) { |
| 280 | if (frame_transformer_delegate_) { |
| 281 | frame_transformer_delegate_->SetVideoLayersAllocationUnderLock( |
| 282 | std::move(allocation)); |
| 283 | return; |
| 284 | } |
| 285 | SetVideoLayersAllocationInternal(std::move(allocation)); |
| 286 | } |
| 287 | |
| 288 | void RTPSenderVideo::SetVideoLayersAllocationAfterTransformation( |
| 289 | VideoLayersAllocation allocation) { |
| 290 | SetVideoLayersAllocationInternal(std::move(allocation)); |
| 291 | } |
| 292 | |
| 293 | void RTPSenderVideo::SetVideoLayersAllocationInternal( |
| 294 | VideoLayersAllocation allocation) { |
| 295 | RTC_DCHECK_RUNS_SERIALIZED(&send_checker_); |
Per Kjellander | dbf9549 | 2020-12-22 15:12:15 | [diff] [blame] | 296 | if (!allocation_ || allocation.active_spatial_layers.size() > |
| 297 | allocation_->active_spatial_layers.size()) { |
| 298 | send_allocation_ = SendVideoLayersAllocation::kSendWithResolution; |
| 299 | } else if (send_allocation_ == SendVideoLayersAllocation::kDontSend) { |
| 300 | send_allocation_ = SendVideoLayersAllocation::kSendWithoutResolution; |
| 301 | } |
Per Kjellander | 4f350ba | 2020-10-14 06:41:52 | [diff] [blame] | 302 | allocation_ = std::move(allocation); |
Per Kjellander | 4f350ba | 2020-10-14 06:41:52 | [diff] [blame] | 303 | } |
| 304 | |
Danil Chapovalov | 5efb02b | 2020-03-13 16:29:12 | [diff] [blame] | 305 | void RTPSenderVideo::AddRtpHeaderExtensions( |
| 306 | const RTPVideoHeader& video_header, |
| 307 | const absl::optional<AbsoluteCaptureTime>& absolute_capture_time, |
| 308 | bool first_packet, |
| 309 | bool last_packet, |
| 310 | RtpPacketToSend* packet) const { |
| 311 | // Send color space when changed or if the frame is a key frame. Keep |
| 312 | // sending color space information until the first base layer frame to |
| 313 | // guarantee that the information is retrieved by the receiver. |
| 314 | bool set_color_space = |
| 315 | video_header.color_space != last_color_space_ || |
| 316 | video_header.frame_type == VideoFrameType::kVideoFrameKey || |
| 317 | transmit_color_space_next_frame_; |
| 318 | // Color space requires two-byte header extensions if HDR metadata is |
| 319 | // included. Therefore, it's best to add this extension first so that the |
| 320 | // other extensions in the same packet are written as two-byte headers at |
| 321 | // once. |
| 322 | if (last_packet && set_color_space && video_header.color_space) |
| 323 | packet->SetExtension<ColorSpaceExtension>(video_header.color_space.value()); |
| 324 | |
| 325 | // According to |
| 326 | // http://www.etsi.org/deliver/etsi_ts/126100_126199/126114/12.07.00_60/ |
| 327 | // ts_126114v120700p.pdf Section 7.4.5: |
| 328 | // The MTSI client shall add the payload bytes as defined in this clause |
| 329 | // onto the last RTP packet in each group of packets which make up a key |
| 330 | // frame (I-frame or IDR frame in H.264 (AVC), or an IRAP picture in H.265 |
| 331 | // (HEVC)). The MTSI client may also add the payload bytes onto the last RTP |
| 332 | // packet in each group of packets which make up another type of frame |
| 333 | // (e.g. a P-Frame) only if the current value is different from the previous |
| 334 | // value sent. |
| 335 | // Set rotation when key frame or when changed (to follow standard). |
| 336 | // Or when different from 0 (to follow current receiver implementation). |
| 337 | bool set_video_rotation = |
| 338 | video_header.frame_type == VideoFrameType::kVideoFrameKey || |
| 339 | video_header.rotation != last_rotation_ || |
| 340 | video_header.rotation != kVideoRotation_0; |
| 341 | if (last_packet && set_video_rotation) |
| 342 | packet->SetExtension<VideoOrientation>(video_header.rotation); |
| 343 | |
| 344 | // Report content type only for key frames. |
| 345 | if (last_packet && |
| 346 | video_header.frame_type == VideoFrameType::kVideoFrameKey && |
| 347 | video_header.content_type != VideoContentType::UNSPECIFIED) |
| 348 | packet->SetExtension<VideoContentTypeExtension>(video_header.content_type); |
| 349 | |
| 350 | if (last_packet && |
| 351 | video_header.video_timing.flags != VideoSendTiming::kInvalid) |
| 352 | packet->SetExtension<VideoTimingExtension>(video_header.video_timing); |
| 353 | |
| 354 | // If transmitted, add to all packets; ack logic depends on this. |
| 355 | if (playout_delay_pending_) { |
| 356 | packet->SetExtension<PlayoutDelayLimits>(current_playout_delay_); |
| 357 | } |
| 358 | |
| 359 | if (first_packet && absolute_capture_time) { |
| 360 | packet->SetExtension<AbsoluteCaptureTimeExtension>(*absolute_capture_time); |
| 361 | } |
| 362 | |
Danil Chapovalov | 5efb02b | 2020-03-13 16:29:12 | [diff] [blame] | 363 | if (video_header.generic) { |
| 364 | bool extension_is_set = false; |
| 365 | if (video_structure_ != nullptr) { |
| 366 | DependencyDescriptor descriptor; |
| 367 | descriptor.first_packet_in_frame = first_packet; |
| 368 | descriptor.last_packet_in_frame = last_packet; |
| 369 | descriptor.frame_number = video_header.generic->frame_id & 0xFFFF; |
| 370 | descriptor.frame_dependencies.spatial_id = |
| 371 | video_header.generic->spatial_index; |
| 372 | descriptor.frame_dependencies.temporal_id = |
| 373 | video_header.generic->temporal_index; |
| 374 | for (int64_t dep : video_header.generic->dependencies) { |
| 375 | descriptor.frame_dependencies.frame_diffs.push_back( |
| 376 | video_header.generic->frame_id - dep); |
| 377 | } |
Danil Chapovalov | 37120ab | 2020-05-14 14:35:23 | [diff] [blame] | 378 | descriptor.frame_dependencies.chain_diffs = |
| 379 | video_header.generic->chain_diffs; |
Danil Chapovalov | 5efb02b | 2020-03-13 16:29:12 | [diff] [blame] | 380 | descriptor.frame_dependencies.decode_target_indications = |
| 381 | video_header.generic->decode_target_indications; |
| 382 | RTC_DCHECK_EQ( |
| 383 | descriptor.frame_dependencies.decode_target_indications.size(), |
| 384 | video_structure_->num_decode_targets); |
| 385 | |
Danil Chapovalov | e6ac8ff | 2020-06-26 11:51:08 | [diff] [blame] | 386 | if (first_packet) { |
| 387 | descriptor.active_decode_targets_bitmask = |
| 388 | active_decode_targets_tracker_.ActiveDecodeTargetsBitmask(); |
| 389 | } |
Danil Chapovalov | 5ad731a | 2020-10-15 15:26:46 | [diff] [blame] | 390 | // VP9 mark all layer frames of the first picture as kVideoFrameKey, |
| 391 | // Structure should be attached to the descriptor to lowest spatial layer |
| 392 | // when inter layer dependency is used, i.e. L structures; or to all |
| 393 | // layers when inter layer dependency is not used, i.e. S structures. |
| 394 | // Distinguish these two cases by checking if there are any dependencies. |
Danil Chapovalov | 5efb02b | 2020-03-13 16:29:12 | [diff] [blame] | 395 | if (video_header.frame_type == VideoFrameType::kVideoFrameKey && |
Danil Chapovalov | 5ad731a | 2020-10-15 15:26:46 | [diff] [blame] | 396 | video_header.generic->dependencies.empty() && first_packet) { |
| 397 | // To avoid extra structure copy, temporary share ownership of the |
| 398 | // video_structure with the dependency descriptor. |
Danil Chapovalov | 5efb02b | 2020-03-13 16:29:12 | [diff] [blame] | 399 | descriptor.attached_structure = |
| 400 | absl::WrapUnique(video_structure_.get()); |
| 401 | } |
| 402 | extension_is_set = packet->SetExtension<RtpDependencyDescriptorExtension>( |
Danil Chapovalov | e6ac8ff | 2020-06-26 11:51:08 | [diff] [blame] | 403 | *video_structure_, |
| 404 | active_decode_targets_tracker_.ActiveChainsBitmask(), descriptor); |
Danil Chapovalov | 5efb02b | 2020-03-13 16:29:12 | [diff] [blame] | 405 | |
| 406 | // Remove the temporary shared ownership. |
| 407 | descriptor.attached_structure.release(); |
| 408 | } |
| 409 | |
Danil Chapovalov | ec9fc22 | 2020-04-14 14:11:59 | [diff] [blame] | 410 | // Do not use generic frame descriptor when dependency descriptor is stored. |
Danil Chapovalov | 5efb02b | 2020-03-13 16:29:12 | [diff] [blame] | 411 | if (!extension_is_set) { |
| 412 | RtpGenericFrameDescriptor generic_descriptor; |
| 413 | generic_descriptor.SetFirstPacketInSubFrame(first_packet); |
| 414 | generic_descriptor.SetLastPacketInSubFrame(last_packet); |
Danil Chapovalov | 5efb02b | 2020-03-13 16:29:12 | [diff] [blame] | 415 | |
| 416 | if (first_packet) { |
| 417 | generic_descriptor.SetFrameId( |
| 418 | static_cast<uint16_t>(video_header.generic->frame_id)); |
| 419 | for (int64_t dep : video_header.generic->dependencies) { |
| 420 | generic_descriptor.AddFrameDependencyDiff( |
| 421 | video_header.generic->frame_id - dep); |
| 422 | } |
| 423 | |
| 424 | uint8_t spatial_bimask = 1 << video_header.generic->spatial_index; |
| 425 | generic_descriptor.SetSpatialLayersBitmask(spatial_bimask); |
| 426 | |
| 427 | generic_descriptor.SetTemporalLayer( |
| 428 | video_header.generic->temporal_index); |
| 429 | |
| 430 | if (video_header.frame_type == VideoFrameType::kVideoFrameKey) { |
| 431 | generic_descriptor.SetResolution(video_header.width, |
| 432 | video_header.height); |
| 433 | } |
| 434 | } |
| 435 | |
Danil Chapovalov | 9d287bf | 2020-04-06 09:34:34 | [diff] [blame] | 436 | packet->SetExtension<RtpGenericFrameDescriptorExtension00>( |
| 437 | generic_descriptor); |
Danil Chapovalov | 5efb02b | 2020-03-13 16:29:12 | [diff] [blame] | 438 | } |
| 439 | } |
Per Kjellander | 4f350ba | 2020-10-14 06:41:52 | [diff] [blame] | 440 | |
Per Kjellander | dbf9549 | 2020-12-22 15:12:15 | [diff] [blame] | 441 | if (first_packet && |
| 442 | send_allocation_ != SendVideoLayersAllocation::kDontSend && |
| 443 | (video_header.frame_type == VideoFrameType::kVideoFrameKey || |
| 444 | PacketWillLikelyBeRequestedForRestransmitionIfLost(video_header))) { |
| 445 | VideoLayersAllocation allocation = allocation_.value(); |
| 446 | allocation.resolution_and_frame_rate_is_valid = |
| 447 | send_allocation_ == SendVideoLayersAllocation::kSendWithResolution; |
| 448 | packet->SetExtension<RtpVideoLayersAllocationExtension>(allocation); |
Per Kjellander | 4f350ba | 2020-10-14 06:41:52 | [diff] [blame] | 449 | } |
Danil Chapovalov | 5efb02b | 2020-03-13 16:29:12 | [diff] [blame] | 450 | } |
| 451 | |
Elad Alon | b64af4b | 2019-06-05 09:39:37 | [diff] [blame] | 452 | bool RTPSenderVideo::SendVideo( |
Danil Chapovalov | 51bf200 | 2019-10-11 08:53:27 | [diff] [blame] | 453 | int payload_type, |
| 454 | absl::optional<VideoCodecType> codec_type, |
| 455 | uint32_t rtp_timestamp, |
| 456 | int64_t capture_time_ms, |
| 457 | rtc::ArrayView<const uint8_t> payload, |
Danil Chapovalov | 51bf200 | 2019-10-11 08:53:27 | [diff] [blame] | 458 | RTPVideoHeader video_header, |
Minyue Li | d37b0ec | 2020-08-21 14:28:07 | [diff] [blame] | 459 | absl::optional<int64_t> expected_retransmission_time_ms, |
| 460 | absl::optional<int64_t> estimated_capture_clock_offset_ms) { |
Marina Ciocea | 3a087a8 | 2020-03-03 04:39:28 | [diff] [blame] | 461 | #if RTC_TRACE_EVENTS_ENABLED |
Niels Möller | 59ab1cf | 2019-02-06 21:48:11 | [diff] [blame] | 462 | TRACE_EVENT_ASYNC_STEP1("webrtc", "Video", capture_time_ms, "Send", "type", |
Danil Chapovalov | 51bf200 | 2019-10-11 08:53:27 | [diff] [blame] | 463 | FrameTypeToString(video_header.frame_type)); |
Marina Ciocea | 3a087a8 | 2020-03-03 04:39:28 | [diff] [blame] | 464 | #endif |
Erik Språng | 6cf554e | 2019-10-02 18:55:39 | [diff] [blame] | 465 | RTC_CHECK_RUNS_SERIALIZED(&send_checker_); |
Niels Möller | 59ab1cf | 2019-02-06 21:48:11 | [diff] [blame] | 466 | |
Danil Chapovalov | 51bf200 | 2019-10-11 08:53:27 | [diff] [blame] | 467 | if (video_header.frame_type == VideoFrameType::kEmptyFrame) |
Niels Möller | 59ab1cf | 2019-02-06 21:48:11 | [diff] [blame] | 468 | return true; |
| 469 | |
Danil Chapovalov | 51bf200 | 2019-10-11 08:53:27 | [diff] [blame] | 470 | if (payload.empty()) |
Sergey Ulanov | 525df3f | 2016-08-03 00:46:41 | [diff] [blame] | 471 | return false; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 472 | |
Erik Språng | 6cf554e | 2019-10-02 18:55:39 | [diff] [blame] | 473 | int32_t retransmission_settings = retransmission_settings_; |
| 474 | if (codec_type == VideoCodecType::kVideoCodecH264) { |
| 475 | // Backward compatibility for older receivers without temporal layer logic. |
| 476 | retransmission_settings = kRetransmitBaseLayer | kRetransmitHigherLayers; |
| 477 | } |
| 478 | |
Erik Språng | 56e611b | 2020-02-06 16:10:08 | [diff] [blame] | 479 | MaybeUpdateCurrentPlayoutDelay(video_header); |
Per Kjellander | 4f350ba | 2020-10-14 06:41:52 | [diff] [blame] | 480 | if (video_header.frame_type == VideoFrameType::kVideoFrameKey) { |
| 481 | if (!IsNoopDelay(current_playout_delay_)) { |
| 482 | // Force playout delay on key-frames, if set. |
| 483 | playout_delay_pending_ = true; |
| 484 | } |
| 485 | if (allocation_) { |
| 486 | // Send the bitrate allocation on every key frame. |
Per Kjellander | dbf9549 | 2020-12-22 15:12:15 | [diff] [blame] | 487 | send_allocation_ = SendVideoLayersAllocation::kSendWithResolution; |
Per Kjellander | 4f350ba | 2020-10-14 06:41:52 | [diff] [blame] | 488 | } |
Erik Språng | 56e611b | 2020-02-06 16:10:08 | [diff] [blame] | 489 | } |
Erik Språng | 6cf554e | 2019-10-02 18:55:39 | [diff] [blame] | 490 | |
Danil Chapovalov | e6ac8ff | 2020-06-26 11:51:08 | [diff] [blame] | 491 | if (video_structure_ != nullptr && video_header.generic) { |
| 492 | active_decode_targets_tracker_.OnFrame( |
| 493 | video_structure_->decode_target_protected_by_chain, |
| 494 | video_header.generic->active_decode_targets, |
| 495 | video_header.frame_type == VideoFrameType::kVideoFrameKey, |
| 496 | video_header.generic->frame_id, video_header.generic->chain_diffs); |
| 497 | } |
| 498 | |
Erik Språng | b647785 | 2020-10-05 12:20:51 | [diff] [blame] | 499 | const uint8_t temporal_id = GetTemporalId(video_header); |
| 500 | // No FEC protection for upper temporal layers, if used. |
| 501 | const bool use_fec = fec_type_.has_value() && |
| 502 | (temporal_id == 0 || temporal_id == kNoTemporalIdx); |
| 503 | |
Danil Chapovalov | e4f8b38 | 2018-09-07 15:30:26 | [diff] [blame] | 504 | // Maximum size of packet including rtp headers. |
| 505 | // Extra space left in case packet will be resent using fec or rtx. |
Erik Språng | b647785 | 2020-10-05 12:20:51 | [diff] [blame] | 506 | int packet_capacity = rtp_sender_->MaxRtpPacketSize() - |
| 507 | (use_fec ? FecPacketOverhead() : 0) - |
Danil Chapovalov | fa5ec8d | 2018-09-07 08:57:26 | [diff] [blame] | 508 | (rtp_sender_->RtxStatus() ? kRtxHeaderSize : 0); |
Danil Chapovalov | e4f8b38 | 2018-09-07 15:30:26 | [diff] [blame] | 509 | |
Danil Chapovalov | 6026f05 | 2018-10-16 14:22:33 | [diff] [blame] | 510 | std::unique_ptr<RtpPacketToSend> single_packet = |
| 511 | rtp_sender_->AllocatePacket(); |
| 512 | RTC_DCHECK_LE(packet_capacity, single_packet->capacity()); |
| 513 | single_packet->SetPayloadType(payload_type); |
| 514 | single_packet->SetTimestamp(rtp_timestamp); |
| 515 | single_packet->set_capture_time_ms(capture_time_ms); |
Danil Chapovalov | e4f8b38 | 2018-09-07 15:30:26 | [diff] [blame] | 516 | |
Minyue Li | 5bb9adc | 2020-01-22 12:02:34 | [diff] [blame] | 517 | const absl::optional<AbsoluteCaptureTime> absolute_capture_time = |
| 518 | absolute_capture_time_sender_.OnSendPacket( |
| 519 | AbsoluteCaptureTimeSender::GetSource(single_packet->Ssrc(), |
| 520 | single_packet->Csrcs()), |
| 521 | single_packet->Timestamp(), kVideoPayloadTypeFrequency, |
| 522 | Int64MsToUQ32x32(single_packet->capture_time_ms() + NtpOffsetMs()), |
Minyue Li | e64b3d0 | 2020-08-20 14:18:31 | [diff] [blame] | 523 | /*estimated_capture_clock_offset=*/ |
Minyue Li | d37b0ec | 2020-08-21 14:28:07 | [diff] [blame] | 524 | include_capture_clock_offset_ ? estimated_capture_clock_offset_ms |
Minyue Li | e64b3d0 | 2020-08-20 14:18:31 | [diff] [blame] | 525 | : absl::nullopt); |
Minyue Li | 5bb9adc | 2020-01-22 12:02:34 | [diff] [blame] | 526 | |
Mirko Bonadei | 317a1f0 | 2019-09-17 15:06:18 | [diff] [blame] | 527 | auto first_packet = std::make_unique<RtpPacketToSend>(*single_packet); |
| 528 | auto middle_packet = std::make_unique<RtpPacketToSend>(*single_packet); |
| 529 | auto last_packet = std::make_unique<RtpPacketToSend>(*single_packet); |
Danil Chapovalov | e4f8b38 | 2018-09-07 15:30:26 | [diff] [blame] | 530 | // Simplest way to estimate how much extensions would occupy is to set them. |
Danil Chapovalov | 5efb02b | 2020-03-13 16:29:12 | [diff] [blame] | 531 | AddRtpHeaderExtensions(video_header, absolute_capture_time, |
| 532 | /*first_packet=*/true, /*last_packet=*/true, |
| 533 | single_packet.get()); |
| 534 | AddRtpHeaderExtensions(video_header, absolute_capture_time, |
| 535 | /*first_packet=*/true, /*last_packet=*/false, |
| 536 | first_packet.get()); |
| 537 | AddRtpHeaderExtensions(video_header, absolute_capture_time, |
| 538 | /*first_packet=*/false, /*last_packet=*/false, |
| 539 | middle_packet.get()); |
| 540 | AddRtpHeaderExtensions(video_header, absolute_capture_time, |
| 541 | /*first_packet=*/false, /*last_packet=*/true, |
| 542 | last_packet.get()); |
Johnny Lee | 1a1c52b | 2019-02-08 19:25:40 | [diff] [blame] | 543 | |
Danil Chapovalov | 6026f05 | 2018-10-16 14:22:33 | [diff] [blame] | 544 | RTC_DCHECK_GT(packet_capacity, single_packet->headers_size()); |
Danil Chapovalov | e4f8b38 | 2018-09-07 15:30:26 | [diff] [blame] | 545 | RTC_DCHECK_GT(packet_capacity, first_packet->headers_size()); |
| 546 | RTC_DCHECK_GT(packet_capacity, middle_packet->headers_size()); |
ilnik | 7a3006b | 2017-05-23 16:34:21 | [diff] [blame] | 547 | RTC_DCHECK_GT(packet_capacity, last_packet->headers_size()); |
Danil Chapovalov | fa5ec8d | 2018-09-07 08:57:26 | [diff] [blame] | 548 | RtpPacketizer::PayloadSizeLimits limits; |
Danil Chapovalov | e4f8b38 | 2018-09-07 15:30:26 | [diff] [blame] | 549 | limits.max_payload_len = packet_capacity - middle_packet->headers_size(); |
Danil Chapovalov | fa5ec8d | 2018-09-07 08:57:26 | [diff] [blame] | 550 | |
Danil Chapovalov | 6026f05 | 2018-10-16 14:22:33 | [diff] [blame] | 551 | RTC_DCHECK_GE(single_packet->headers_size(), middle_packet->headers_size()); |
| 552 | limits.single_packet_reduction_len = |
| 553 | single_packet->headers_size() - middle_packet->headers_size(); |
| 554 | |
Danil Chapovalov | e4f8b38 | 2018-09-07 15:30:26 | [diff] [blame] | 555 | RTC_DCHECK_GE(first_packet->headers_size(), middle_packet->headers_size()); |
| 556 | limits.first_packet_reduction_len = |
| 557 | first_packet->headers_size() - middle_packet->headers_size(); |
| 558 | |
| 559 | RTC_DCHECK_GE(last_packet->headers_size(), middle_packet->headers_size()); |
Danil Chapovalov | fa5ec8d | 2018-09-07 08:57:26 | [diff] [blame] | 560 | limits.last_packet_reduction_len = |
Danil Chapovalov | e4f8b38 | 2018-09-07 15:30:26 | [diff] [blame] | 561 | last_packet->headers_size() - middle_packet->headers_size(); |
danilchap | 7411061 | 2016-10-02 17:54:29 | [diff] [blame] | 562 | |
Danil Chapovalov | 9d287bf | 2020-04-06 09:34:34 | [diff] [blame] | 563 | bool has_generic_descriptor = |
| 564 | first_packet->HasExtension<RtpGenericFrameDescriptorExtension00>() || |
Danil Chapovalov | 95800f6 | 2020-02-20 14:01:15 | [diff] [blame] | 565 | first_packet->HasExtension<RtpDependencyDescriptorExtension>(); |
Elad Alon | ccb9b75 | 2019-02-19 12:01:31 | [diff] [blame] | 566 | |
Erik Språng | b647785 | 2020-10-05 12:20:51 | [diff] [blame] | 567 | // Minimization of the vp8 descriptor may erase temporal_id, so use |
| 568 | // |temporal_id| rather than reference |video_header| beyond this point. |
Danil Chapovalov | 95800f6 | 2020-02-20 14:01:15 | [diff] [blame] | 569 | if (has_generic_descriptor) { |
Danil Chapovalov | 51bf200 | 2019-10-11 08:53:27 | [diff] [blame] | 570 | MinimizeDescriptor(&video_header); |
Benjamin Wright | 192eeec | 2018-10-18 00:27:25 | [diff] [blame] | 571 | } |
| 572 | |
| 573 | // TODO(benwright@webrtc.org) - Allocate enough to always encrypt inline. |
| 574 | rtc::Buffer encrypted_video_payload; |
| 575 | if (frame_encryptor_ != nullptr) { |
Danil Chapovalov | 95800f6 | 2020-02-20 14:01:15 | [diff] [blame] | 576 | if (!has_generic_descriptor) { |
Benjamin Wright | 192eeec | 2018-10-18 00:27:25 | [diff] [blame] | 577 | return false; |
| 578 | } |
| 579 | |
| 580 | const size_t max_ciphertext_size = |
| 581 | frame_encryptor_->GetMaxCiphertextByteSize(cricket::MEDIA_TYPE_VIDEO, |
Danil Chapovalov | 51bf200 | 2019-10-11 08:53:27 | [diff] [blame] | 582 | payload.size()); |
Benjamin Wright | 192eeec | 2018-10-18 00:27:25 | [diff] [blame] | 583 | encrypted_video_payload.SetSize(max_ciphertext_size); |
| 584 | |
| 585 | size_t bytes_written = 0; |
Benjamin Wright | 168456c | 2018-12-07 19:31:25 | [diff] [blame] | 586 | |
Markus Handell | c1cbf6b | 2020-02-17 19:03:57 | [diff] [blame] | 587 | // Enable header authentication if the field trial isn't disabled. |
Danil Chapovalov | 95800f6 | 2020-02-20 14:01:15 | [diff] [blame] | 588 | std::vector<uint8_t> additional_data; |
Benjamin Wright | 168456c | 2018-12-07 19:31:25 | [diff] [blame] | 589 | if (generic_descriptor_auth_experiment_) { |
Danil Chapovalov | 95800f6 | 2020-02-20 14:01:15 | [diff] [blame] | 590 | additional_data = RtpDescriptorAuthentication(video_header); |
Benjamin Wright | 168456c | 2018-12-07 19:31:25 | [diff] [blame] | 591 | } |
| 592 | |
Benjamin Wright | 192eeec | 2018-10-18 00:27:25 | [diff] [blame] | 593 | if (frame_encryptor_->Encrypt( |
Benjamin Wright | 168456c | 2018-12-07 19:31:25 | [diff] [blame] | 594 | cricket::MEDIA_TYPE_VIDEO, first_packet->Ssrc(), additional_data, |
Danil Chapovalov | 51bf200 | 2019-10-11 08:53:27 | [diff] [blame] | 595 | payload, encrypted_video_payload, &bytes_written) != 0) { |
Benjamin Wright | 192eeec | 2018-10-18 00:27:25 | [diff] [blame] | 596 | return false; |
| 597 | } |
| 598 | |
| 599 | encrypted_video_payload.SetSize(bytes_written); |
Danil Chapovalov | 51bf200 | 2019-10-11 08:53:27 | [diff] [blame] | 600 | payload = encrypted_video_payload; |
Benjamin Wright | 192eeec | 2018-10-18 00:27:25 | [diff] [blame] | 601 | } else if (require_frame_encryption_) { |
| 602 | RTC_LOG(LS_WARNING) |
| 603 | << "No FrameEncryptor is attached to this video sending stream but " |
Jonas Olsson | b2b2031 | 2020-01-14 11:11:31 | [diff] [blame] | 604 | "one is required since require_frame_encryptor is set"; |
Danil Chapovalov | 84ffb35 | 2018-09-25 16:59:09 | [diff] [blame] | 605 | } |
| 606 | |
Danil Chapovalov | 31cb3ab | 2020-07-21 13:01:50 | [diff] [blame] | 607 | std::unique_ptr<RtpPacketizer> packetizer = |
| 608 | RtpPacketizer::Create(codec_type, payload, limits, video_header); |
sprang | a8ae6f2 | 2017-09-04 14:23:56 | [diff] [blame] | 609 | |
Elad Alon | b64af4b | 2019-06-05 09:39:37 | [diff] [blame] | 610 | // TODO(bugs.webrtc.org/10714): retransmission_settings_ should generally be |
| 611 | // replaced by expected_retransmission_time_ms.has_value(). For now, though, |
| 612 | // only VP8 with an injected frame buffer controller actually controls it. |
Erik Språng | 70768f4 | 2019-08-27 16:16:26 | [diff] [blame] | 613 | const bool allow_retransmission = |
Elad Alon | b64af4b | 2019-06-05 09:39:37 | [diff] [blame] | 614 | expected_retransmission_time_ms.has_value() |
Erik Språng | 70768f4 | 2019-08-27 16:16:26 | [diff] [blame] | 615 | ? AllowRetransmission(temporal_id, retransmission_settings, |
| 616 | expected_retransmission_time_ms.value()) |
| 617 | : false; |
Elad Alon | 8b60e8b | 2019-04-08 12:14:05 | [diff] [blame] | 618 | const size_t num_packets = packetizer->NumPackets(); |
ilnik | 7a3006b | 2017-05-23 16:34:21 | [diff] [blame] | 619 | |
| 620 | if (num_packets == 0) |
| 621 | return false; |
pbos@webrtc.org | b5e6bfc | 2014-09-12 11:05:55 | [diff] [blame] | 622 | |
danilchap | 2a615fc | 2016-11-11 10:27:35 | [diff] [blame] | 623 | bool first_frame = first_frame_sent_(); |
Erik Språng | f1e97b9 | 2019-09-26 10:48:47 | [diff] [blame] | 624 | std::vector<std::unique_ptr<RtpPacketToSend>> rtp_packets; |
ilnik | 7a3006b | 2017-05-23 16:34:21 | [diff] [blame] | 625 | for (size_t i = 0; i < num_packets; ++i) { |
Danil Chapovalov | e4f8b38 | 2018-09-07 15:30:26 | [diff] [blame] | 626 | std::unique_ptr<RtpPacketToSend> packet; |
| 627 | int expected_payload_capacity; |
| 628 | // Choose right packet template: |
| 629 | if (num_packets == 1) { |
Danil Chapovalov | 6026f05 | 2018-10-16 14:22:33 | [diff] [blame] | 630 | packet = std::move(single_packet); |
Danil Chapovalov | fcebe0e | 2018-10-12 15:51:22 | [diff] [blame] | 631 | expected_payload_capacity = |
| 632 | limits.max_payload_len - limits.single_packet_reduction_len; |
Danil Chapovalov | e4f8b38 | 2018-09-07 15:30:26 | [diff] [blame] | 633 | } else if (i == 0) { |
| 634 | packet = std::move(first_packet); |
| 635 | expected_payload_capacity = |
| 636 | limits.max_payload_len - limits.first_packet_reduction_len; |
| 637 | } else if (i == num_packets - 1) { |
| 638 | packet = std::move(last_packet); |
| 639 | expected_payload_capacity = |
| 640 | limits.max_payload_len - limits.last_packet_reduction_len; |
| 641 | } else { |
Mirko Bonadei | 317a1f0 | 2019-09-17 15:06:18 | [diff] [blame] | 642 | packet = std::make_unique<RtpPacketToSend>(*middle_packet); |
Danil Chapovalov | e4f8b38 | 2018-09-07 15:30:26 | [diff] [blame] | 643 | expected_payload_capacity = limits.max_payload_len; |
| 644 | } |
| 645 | |
Erik Språng | 3663f94 | 2020-02-07 09:05:15 | [diff] [blame] | 646 | packet->set_first_packet_of_frame(i == 0); |
| 647 | |
ilnik | 7a3006b | 2017-05-23 16:34:21 | [diff] [blame] | 648 | if (!packetizer->NextPacket(packet.get())) |
Sergey Ulanov | 525df3f | 2016-08-03 00:46:41 | [diff] [blame] | 649 | return false; |
Danil Chapovalov | e4f8b38 | 2018-09-07 15:30:26 | [diff] [blame] | 650 | RTC_DCHECK_LE(packet->payload_size(), expected_payload_capacity); |
danilchap | 7411061 | 2016-10-02 17:54:29 | [diff] [blame] | 651 | |
Erik Språng | 70768f4 | 2019-08-27 16:16:26 | [diff] [blame] | 652 | packet->set_allow_retransmission(allow_retransmission); |
Erik Språng | cf15cb5 | 2020-12-07 12:18:34 | [diff] [blame] | 653 | packet->set_is_key_frame(video_header.frame_type == |
| 654 | VideoFrameType::kVideoFrameKey); |
Erik Språng | 70768f4 | 2019-08-27 16:16:26 | [diff] [blame] | 655 | |
ilnik | 04f4d12 | 2017-06-19 14:18:55 | [diff] [blame] | 656 | // Put packetization finish timestamp into extension. |
ilnik | e435019 | 2017-06-29 09:27:44 | [diff] [blame] | 657 | if (packet->HasExtension<VideoTimingExtension>()) { |
ilnik | 04f4d12 | 2017-06-19 14:18:55 | [diff] [blame] | 658 | packet->set_packetization_finish_time_ms(clock_->TimeInMilliseconds()); |
| 659 | } |
| 660 | |
Erik Språng | b647785 | 2020-10-05 12:20:51 | [diff] [blame] | 661 | packet->set_fec_protect_packet(use_fec); |
Erik Språng | f87536c | 2020-03-05 09:14:04 | [diff] [blame] | 662 | |
Danil Chapovalov | 0deef72 | 2019-10-14 12:20:20 | [diff] [blame] | 663 | if (red_enabled()) { |
Erik Språng | b647785 | 2020-10-05 12:20:51 | [diff] [blame] | 664 | // TODO(sprang): Consider packetizing directly into packets with the RED |
| 665 | // header already in place, to avoid this copy. |
Erik Språng | f87536c | 2020-03-05 09:14:04 | [diff] [blame] | 666 | std::unique_ptr<RtpPacketToSend> red_packet(new RtpPacketToSend(*packet)); |
| 667 | BuildRedPayload(*packet, red_packet.get()); |
| 668 | red_packet->SetPayloadType(*red_payload_type_); |
Erik Språng | 1d50cb6 | 2020-07-02 15:41:32 | [diff] [blame] | 669 | red_packet->set_is_red(true); |
Erik Språng | f87536c | 2020-03-05 09:14:04 | [diff] [blame] | 670 | |
Erik Språng | 0f71871 | 2021-02-17 14:19:06 | [diff] [blame^] | 671 | // Append |red_packet| instead of |packet| to output. |
Erik Språng | f87536c | 2020-03-05 09:14:04 | [diff] [blame] | 672 | red_packet->set_packet_type(RtpPacketMediaType::kVideo); |
| 673 | red_packet->set_allow_retransmission(packet->allow_retransmission()); |
| 674 | rtp_packets.emplace_back(std::move(red_packet)); |
mflodman | fcf54bd | 2015-04-14 19:28:08 | [diff] [blame] | 675 | } else { |
Björn Terelius | 31d0f7c | 2020-02-06 15:35:46 | [diff] [blame] | 676 | packet->set_packet_type(RtpPacketMediaType::kVideo); |
Erik Språng | f1e97b9 | 2019-09-26 10:48:47 | [diff] [blame] | 677 | rtp_packets.emplace_back(std::move(packet)); |
stefan@webrtc.org | 2ec5606 | 2014-07-31 14:59:24 | [diff] [blame] | 678 | } |
skvlad | 98bb664 | 2016-04-07 22:36:45 | [diff] [blame] | 679 | |
| 680 | if (first_frame) { |
ilnik | 7a3006b | 2017-05-23 16:34:21 | [diff] [blame] | 681 | if (i == 0) { |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 682 | RTC_LOG(LS_INFO) |
skvlad | 98bb664 | 2016-04-07 22:36:45 | [diff] [blame] | 683 | << "Sent first RTP packet of the first video frame (pre-pacer)"; |
| 684 | } |
Danil Chapovalov | e4f8b38 | 2018-09-07 15:30:26 | [diff] [blame] | 685 | if (i == num_packets - 1) { |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 686 | RTC_LOG(LS_INFO) |
skvlad | 98bb664 | 2016-04-07 22:36:45 | [diff] [blame] | 687 | << "Sent last RTP packet of the first video frame (pre-pacer)"; |
| 688 | } |
| 689 | } |
stefan@webrtc.org | 2ec5606 | 2014-07-31 14:59:24 | [diff] [blame] | 690 | } |
pbos@webrtc.org | b5e6bfc | 2014-09-12 11:05:55 | [diff] [blame] | 691 | |
Erik Språng | 0f71871 | 2021-02-17 14:19:06 | [diff] [blame^] | 692 | if (!rtp_sender_->AssignSequenceNumbersAndStoreLastPacketState(rtp_packets)) { |
| 693 | // Media not being sent. |
| 694 | return false; |
| 695 | } |
| 696 | |
Danil Chapovalov | 31cb3ab | 2020-07-21 13:01:50 | [diff] [blame] | 697 | LogAndSendToNetwork(std::move(rtp_packets), payload.size()); |
Erik Språng | 482b3ef | 2019-01-08 15:19:11 | [diff] [blame] | 698 | |
Danil Chapovalov | 5efb02b | 2020-03-13 16:29:12 | [diff] [blame] | 699 | // Update details about the last sent frame. |
| 700 | last_rotation_ = video_header.rotation; |
| 701 | |
| 702 | if (video_header.color_space != last_color_space_) { |
| 703 | last_color_space_ = video_header.color_space; |
| 704 | transmit_color_space_next_frame_ = !IsBaseLayer(video_header); |
| 705 | } else { |
| 706 | transmit_color_space_next_frame_ = |
| 707 | transmit_color_space_next_frame_ ? !IsBaseLayer(video_header) : false; |
| 708 | } |
| 709 | |
| 710 | if (video_header.frame_type == VideoFrameType::kVideoFrameKey || |
Per Kjellander | 4f350ba | 2020-10-14 06:41:52 | [diff] [blame] | 711 | PacketWillLikelyBeRequestedForRestransmitionIfLost(video_header)) { |
| 712 | // This frame will likely be delivered, no need to populate playout |
Danil Chapovalov | 5efb02b | 2020-03-13 16:29:12 | [diff] [blame] | 713 | // delay extensions until it changes again. |
| 714 | playout_delay_pending_ = false; |
Per Kjellander | dbf9549 | 2020-12-22 15:12:15 | [diff] [blame] | 715 | send_allocation_ = SendVideoLayersAllocation::kDontSend; |
Danil Chapovalov | 5efb02b | 2020-03-13 16:29:12 | [diff] [blame] | 716 | } |
| 717 | |
Sergey Ulanov | ec4f068 | 2016-07-28 22:19:10 | [diff] [blame] | 718 | TRACE_EVENT_ASYNC_END1("webrtc", "Video", capture_time_ms, "timestamp", |
danilchap | e5b4141 | 2016-08-22 10:39:23 | [diff] [blame] | 719 | rtp_timestamp); |
Sergey Ulanov | 525df3f | 2016-08-03 00:46:41 | [diff] [blame] | 720 | return true; |
mflodman | fcf54bd | 2015-04-14 19:28:08 | [diff] [blame] | 721 | } |
| 722 | |
Marina Ciocea | 3a087a8 | 2020-03-03 04:39:28 | [diff] [blame] | 723 | bool RTPSenderVideo::SendEncodedImage( |
| 724 | int payload_type, |
| 725 | absl::optional<VideoCodecType> codec_type, |
| 726 | uint32_t rtp_timestamp, |
| 727 | const EncodedImage& encoded_image, |
Marina Ciocea | 3a087a8 | 2020-03-03 04:39:28 | [diff] [blame] | 728 | RTPVideoHeader video_header, |
| 729 | absl::optional<int64_t> expected_retransmission_time_ms) { |
| 730 | if (frame_transformer_delegate_) { |
| 731 | // The frame will be sent async once transformed. |
| 732 | return frame_transformer_delegate_->TransformFrame( |
Danil Chapovalov | 31cb3ab | 2020-07-21 13:01:50 | [diff] [blame] | 733 | payload_type, codec_type, rtp_timestamp, encoded_image, video_header, |
| 734 | expected_retransmission_time_ms); |
Marina Ciocea | 3a087a8 | 2020-03-03 04:39:28 | [diff] [blame] | 735 | } |
| 736 | return SendVideo(payload_type, codec_type, rtp_timestamp, |
Danil Chapovalov | 31cb3ab | 2020-07-21 13:01:50 | [diff] [blame] | 737 | encoded_image.capture_time_ms_, encoded_image, video_header, |
| 738 | expected_retransmission_time_ms); |
Marina Ciocea | 3a087a8 | 2020-03-03 04:39:28 | [diff] [blame] | 739 | } |
| 740 | |
Erik Språng | 482b3ef | 2019-01-08 15:19:11 | [diff] [blame] | 741 | uint32_t RTPSenderVideo::PacketizationOverheadBps() const { |
Markus Handell | e7c015e | 2020-07-07 09:44:28 | [diff] [blame] | 742 | MutexLock lock(&stats_mutex_); |
Erik Språng | 482b3ef | 2019-01-08 15:19:11 | [diff] [blame] | 743 | return packetization_overhead_bitrate_.Rate(clock_->TimeInMilliseconds()) |
| 744 | .value_or(0); |
| 745 | } |
| 746 | |
Erik Språng | 70768f4 | 2019-08-27 16:16:26 | [diff] [blame] | 747 | bool RTPSenderVideo::AllowRetransmission( |
sprang | a8ae6f2 | 2017-09-04 14:23:56 | [diff] [blame] | 748 | uint8_t temporal_id, |
| 749 | int32_t retransmission_settings, |
| 750 | int64_t expected_retransmission_time_ms) { |
| 751 | if (retransmission_settings == kRetransmitOff) |
Erik Språng | 70768f4 | 2019-08-27 16:16:26 | [diff] [blame] | 752 | return false; |
sprang | a8ae6f2 | 2017-09-04 14:23:56 | [diff] [blame] | 753 | |
Markus Handell | e7c015e | 2020-07-07 09:44:28 | [diff] [blame] | 754 | MutexLock lock(&stats_mutex_); |
sprang | a8ae6f2 | 2017-09-04 14:23:56 | [diff] [blame] | 755 | // Media packet storage. |
| 756 | if ((retransmission_settings & kConditionallyRetransmitHigherLayers) && |
| 757 | UpdateConditionalRetransmit(temporal_id, |
| 758 | expected_retransmission_time_ms)) { |
| 759 | retransmission_settings |= kRetransmitHigherLayers; |
| 760 | } |
| 761 | |
| 762 | if (temporal_id == kNoTemporalIdx) |
Erik Språng | 70768f4 | 2019-08-27 16:16:26 | [diff] [blame] | 763 | return true; |
sprang | a8ae6f2 | 2017-09-04 14:23:56 | [diff] [blame] | 764 | |
| 765 | if ((retransmission_settings & kRetransmitBaseLayer) && temporal_id == 0) |
Erik Språng | 70768f4 | 2019-08-27 16:16:26 | [diff] [blame] | 766 | return true; |
sprang | a8ae6f2 | 2017-09-04 14:23:56 | [diff] [blame] | 767 | |
| 768 | if ((retransmission_settings & kRetransmitHigherLayers) && temporal_id > 0) |
Erik Språng | 70768f4 | 2019-08-27 16:16:26 | [diff] [blame] | 769 | return true; |
sprang | a8ae6f2 | 2017-09-04 14:23:56 | [diff] [blame] | 770 | |
Erik Språng | 70768f4 | 2019-08-27 16:16:26 | [diff] [blame] | 771 | return false; |
sprang | a8ae6f2 | 2017-09-04 14:23:56 | [diff] [blame] | 772 | } |
| 773 | |
| 774 | uint8_t RTPSenderVideo::GetTemporalId(const RTPVideoHeader& header) { |
Philip Eliasson | d52a1a6 | 2018-09-07 13:03:55 | [diff] [blame] | 775 | struct TemporalIdGetter { |
| 776 | uint8_t operator()(const RTPVideoHeaderVP8& vp8) { return vp8.temporalIdx; } |
| 777 | uint8_t operator()(const RTPVideoHeaderVP9& vp9) { |
| 778 | return vp9.temporal_idx; |
| 779 | } |
| 780 | uint8_t operator()(const RTPVideoHeaderH264&) { return kNoTemporalIdx; } |
Danil Chapovalov | b6bf0b2 | 2020-01-28 17:36:57 | [diff] [blame] | 781 | uint8_t operator()(const RTPVideoHeaderLegacyGeneric&) { |
| 782 | return kNoTemporalIdx; |
| 783 | } |
Philip Eliasson | d52a1a6 | 2018-09-07 13:03:55 | [diff] [blame] | 784 | uint8_t operator()(const absl::monostate&) { return kNoTemporalIdx; } |
| 785 | }; |
philipel | 9465978 | 2020-06-15 10:26:39 | [diff] [blame] | 786 | return absl::visit(TemporalIdGetter(), header.video_type_header); |
sprang | a8ae6f2 | 2017-09-04 14:23:56 | [diff] [blame] | 787 | } |
| 788 | |
| 789 | bool RTPSenderVideo::UpdateConditionalRetransmit( |
| 790 | uint8_t temporal_id, |
| 791 | int64_t expected_retransmission_time_ms) { |
| 792 | int64_t now_ms = clock_->TimeInMilliseconds(); |
| 793 | // Update stats for any temporal layer. |
| 794 | TemporalLayerStats* current_layer_stats = |
| 795 | &frame_stats_by_temporal_layer_[temporal_id]; |
| 796 | current_layer_stats->frame_rate_fp1000s.Update(1, now_ms); |
| 797 | int64_t tl_frame_interval = now_ms - current_layer_stats->last_frame_time_ms; |
| 798 | current_layer_stats->last_frame_time_ms = now_ms; |
| 799 | |
| 800 | // Conditional retransmit only applies to upper layers. |
| 801 | if (temporal_id != kNoTemporalIdx && temporal_id > 0) { |
| 802 | if (tl_frame_interval >= kMaxUnretransmittableFrameIntervalMs) { |
| 803 | // Too long since a retransmittable frame in this layer, enable NACK |
| 804 | // protection. |
| 805 | return true; |
| 806 | } else { |
| 807 | // Estimate when the next frame of any lower layer will be sent. |
| 808 | const int64_t kUndefined = std::numeric_limits<int64_t>::max(); |
| 809 | int64_t expected_next_frame_time = kUndefined; |
| 810 | for (int i = temporal_id - 1; i >= 0; --i) { |
| 811 | TemporalLayerStats* stats = &frame_stats_by_temporal_layer_[i]; |
Danil Chapovalov | d264df5 | 2018-06-14 10:59:38 | [diff] [blame] | 812 | absl::optional<uint32_t> rate = stats->frame_rate_fp1000s.Rate(now_ms); |
sprang | a8ae6f2 | 2017-09-04 14:23:56 | [diff] [blame] | 813 | if (rate) { |
| 814 | int64_t tl_next = stats->last_frame_time_ms + 1000000 / *rate; |
| 815 | if (tl_next - now_ms > -expected_retransmission_time_ms && |
| 816 | tl_next < expected_next_frame_time) { |
| 817 | expected_next_frame_time = tl_next; |
| 818 | } |
| 819 | } |
| 820 | } |
| 821 | |
| 822 | if (expected_next_frame_time == kUndefined || |
| 823 | expected_next_frame_time - now_ms > expected_retransmission_time_ms) { |
| 824 | // The next frame in a lower layer is expected at a later time (or |
| 825 | // unable to tell due to lack of data) than a retransmission is |
| 826 | // estimated to be able to arrive, so allow this packet to be nacked. |
| 827 | return true; |
| 828 | } |
| 829 | } |
| 830 | } |
| 831 | |
| 832 | return false; |
| 833 | } |
| 834 | |
Erik Språng | 56e611b | 2020-02-06 16:10:08 | [diff] [blame] | 835 | void RTPSenderVideo::MaybeUpdateCurrentPlayoutDelay( |
| 836 | const RTPVideoHeader& header) { |
Johannes Kron | 4da8e4c | 2020-09-22 14:23:30 | [diff] [blame] | 837 | VideoPlayoutDelay requested_delay = |
| 838 | forced_playout_delay_.value_or(header.playout_delay); |
| 839 | |
| 840 | if (IsNoopDelay(requested_delay)) { |
Erik Språng | 56e611b | 2020-02-06 16:10:08 | [diff] [blame] | 841 | return; |
| 842 | } |
| 843 | |
Erik Språng | 56e611b | 2020-02-06 16:10:08 | [diff] [blame] | 844 | if (requested_delay.min_ms > PlayoutDelayLimits::kMaxMs || |
| 845 | requested_delay.max_ms > PlayoutDelayLimits::kMaxMs) { |
| 846 | RTC_DLOG(LS_ERROR) |
| 847 | << "Requested playout delay values out of range, ignored"; |
| 848 | return; |
| 849 | } |
| 850 | if (requested_delay.max_ms != -1 && |
| 851 | requested_delay.min_ms > requested_delay.max_ms) { |
| 852 | RTC_DLOG(LS_ERROR) << "Requested playout delay values out of order"; |
| 853 | return; |
| 854 | } |
| 855 | |
| 856 | if (!playout_delay_pending_) { |
| 857 | current_playout_delay_ = requested_delay; |
| 858 | playout_delay_pending_ = true; |
| 859 | return; |
| 860 | } |
| 861 | |
| 862 | if ((requested_delay.min_ms == -1 || |
| 863 | requested_delay.min_ms == current_playout_delay_.min_ms) && |
| 864 | (requested_delay.max_ms == -1 || |
| 865 | requested_delay.max_ms == current_playout_delay_.max_ms)) { |
| 866 | // No change, ignore. |
| 867 | return; |
| 868 | } |
| 869 | |
| 870 | if (requested_delay.min_ms == -1) { |
| 871 | RTC_DCHECK_GE(requested_delay.max_ms, 0); |
| 872 | requested_delay.min_ms = |
| 873 | std::min(current_playout_delay_.min_ms, requested_delay.max_ms); |
| 874 | } |
| 875 | if (requested_delay.max_ms == -1) { |
| 876 | requested_delay.max_ms = |
| 877 | std::max(current_playout_delay_.max_ms, requested_delay.min_ms); |
| 878 | } |
| 879 | |
| 880 | current_playout_delay_ = requested_delay; |
| 881 | playout_delay_pending_ = true; |
| 882 | } |
| 883 | |
pbos@webrtc.org | d900e8b | 2013-07-03 15:12:26 | [diff] [blame] | 884 | } // namespace webrtc |