niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1 | /* |
leozwang@webrtc.org | 39e9659 | 2012-03-01 18:22:48 +0000 | [diff] [blame] | 2 | * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [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 06:47:31 +0200 | [diff] [blame] | 11 | #include "video/rtp_video_stream_receiver.h" |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 12 | |
philipel | 7acc4a4 | 2019-09-26 11:25:52 +0200 | [diff] [blame] | 13 | #include <algorithm> |
| 14 | #include <limits> |
philipel | fd5a20f | 2016-11-15 00:57:57 -0800 | [diff] [blame] | 15 | #include <utility> |
ilnik | 04f4d12 | 2017-06-19 07:18:55 -0700 | [diff] [blame] | 16 | #include <vector> |
mflodman@webrtc.org | 4fd5527 | 2013-02-06 17:46:39 +0000 | [diff] [blame] | 17 | |
Steve Anton | bd631a0 | 2019-03-28 10:51:27 -0700 | [diff] [blame] | 18 | #include "absl/algorithm/container.h" |
Niels Möller | 2ff1f2a | 2018-08-09 16:16:34 +0200 | [diff] [blame] | 19 | #include "absl/memory/memory.h" |
Danil Chapovalov | cebdbf6 | 2019-12-13 16:08:18 +0100 | [diff] [blame] | 20 | #include "absl/types/optional.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 21 | #include "media/base/media_constants.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 22 | #include "modules/pacing/packet_router.h" |
| 23 | #include "modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h" |
| 24 | #include "modules/rtp_rtcp/include/receive_statistics.h" |
| 25 | #include "modules/rtp_rtcp/include/rtp_cvo.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 26 | #include "modules/rtp_rtcp/include/rtp_rtcp.h" |
| 27 | #include "modules/rtp_rtcp/include/ulpfec_receiver.h" |
Danil Chapovalov | cebdbf6 | 2019-12-13 16:08:18 +0100 | [diff] [blame] | 28 | #include "modules/rtp_rtcp/source/create_video_rtp_depacketizer.h" |
Niels Möller | 2ff1f2a | 2018-08-09 16:16:34 +0200 | [diff] [blame] | 29 | #include "modules/rtp_rtcp/source/rtp_format.h" |
philipel | b3e42a4 | 2018-09-13 10:57:14 +0200 | [diff] [blame] | 30 | #include "modules/rtp_rtcp/source/rtp_generic_frame_descriptor_extension.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 31 | #include "modules/rtp_rtcp/source/rtp_header_extensions.h" |
| 32 | #include "modules/rtp_rtcp/source/rtp_packet_received.h" |
Niels Möller | 2ff1f2a | 2018-08-09 16:16:34 +0200 | [diff] [blame] | 33 | #include "modules/rtp_rtcp/source/rtp_rtcp_config.h" |
Danil Chapovalov | cebdbf6 | 2019-12-13 16:08:18 +0100 | [diff] [blame] | 34 | #include "modules/rtp_rtcp/source/video_rtp_depacketizer.h" |
| 35 | #include "modules/rtp_rtcp/source/video_rtp_depacketizer_raw.h" |
Niels Möller | fe407b7 | 2019-09-10 10:48:48 +0200 | [diff] [blame] | 36 | #include "modules/utility/include/process_thread.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 37 | #include "modules/video_coding/frame_object.h" |
| 38 | #include "modules/video_coding/h264_sprop_parameter_sets.h" |
| 39 | #include "modules/video_coding/h264_sps_pps_tracker.h" |
Ilya Nikolaevskiy | 8643b78 | 2018-06-07 16:15:40 +0200 | [diff] [blame] | 40 | #include "modules/video_coding/nack_module.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 41 | #include "modules/video_coding/packet_buffer.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 42 | #include "rtc_base/checks.h" |
| 43 | #include "rtc_base/location.h" |
| 44 | #include "rtc_base/logging.h" |
Jonas Olsson | 366a50c | 2018-09-06 13:41:30 +0200 | [diff] [blame] | 45 | #include "rtc_base/strings/string_builder.h" |
Karl Wiberg | 80ba333 | 2018-02-05 10:33:35 +0100 | [diff] [blame] | 46 | #include "rtc_base/system/fallthrough.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 47 | #include "system_wrappers/include/field_trial.h" |
| 48 | #include "system_wrappers/include/metrics.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 49 | #include "video/receive_statistics_proxy.h" |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 50 | |
| 51 | namespace webrtc { |
| 52 | |
philipel | fd5a20f | 2016-11-15 00:57:57 -0800 | [diff] [blame] | 53 | namespace { |
philipel | 3bf97cf | 2017-08-10 18:10:59 +0200 | [diff] [blame] | 54 | // TODO(philipel): Change kPacketBufferStartSize back to 32 in M63 see: |
| 55 | // crbug.com/752886 |
| 56 | constexpr int kPacketBufferStartSize = 512; |
Johannes Kron | 201596f | 2018-10-22 14:33:39 +0200 | [diff] [blame] | 57 | constexpr int kPacketBufferMaxSize = 2048; |
Danil Chapovalov | f7457e5 | 2019-09-20 17:57:15 +0200 | [diff] [blame] | 58 | |
| 59 | int PacketBufferMaxSize() { |
| 60 | // The group here must be a positive power of 2, in which case that is used as |
| 61 | // size. All other values shall result in the default value being used. |
| 62 | const std::string group_name = |
| 63 | webrtc::field_trial::FindFullName("WebRTC-PacketBufferMaxSize"); |
| 64 | int packet_buffer_max_size = kPacketBufferMaxSize; |
| 65 | if (!group_name.empty() && |
| 66 | (sscanf(group_name.c_str(), "%d", &packet_buffer_max_size) != 1 || |
| 67 | packet_buffer_max_size <= 0 || |
| 68 | // Verify that the number is a positive power of 2. |
| 69 | (packet_buffer_max_size & (packet_buffer_max_size - 1)) != 0)) { |
| 70 | RTC_LOG(LS_WARNING) << "Invalid packet buffer max size: " << group_name; |
| 71 | packet_buffer_max_size = kPacketBufferMaxSize; |
| 72 | } |
| 73 | return packet_buffer_max_size; |
| 74 | } |
| 75 | |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 76 | } // namespace |
philipel | fd5a20f | 2016-11-15 00:57:57 -0800 | [diff] [blame] | 77 | |
mflodman | c0e58a3 | 2016-04-25 01:26:26 -0700 | [diff] [blame] | 78 | std::unique_ptr<RtpRtcp> CreateRtpRtcpModule( |
Sebastian Jansson | 8026d60 | 2019-03-04 19:39:01 +0100 | [diff] [blame] | 79 | Clock* clock, |
mflodman | c0e58a3 | 2016-04-25 01:26:26 -0700 | [diff] [blame] | 80 | ReceiveStatistics* receive_statistics, |
| 81 | Transport* outgoing_transport, |
| 82 | RtcpRttStats* rtt_stats, |
Erik Språng | e3a10e1 | 2019-08-19 15:45:00 +0200 | [diff] [blame] | 83 | RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer, |
| 84 | uint32_t local_ssrc) { |
mflodman | c0e58a3 | 2016-04-25 01:26:26 -0700 | [diff] [blame] | 85 | RtpRtcp::Configuration configuration; |
Sebastian Jansson | 8026d60 | 2019-03-04 19:39:01 +0100 | [diff] [blame] | 86 | configuration.clock = clock; |
mflodman | c0e58a3 | 2016-04-25 01:26:26 -0700 | [diff] [blame] | 87 | configuration.audio = false; |
| 88 | configuration.receiver_only = true; |
| 89 | configuration.receive_statistics = receive_statistics; |
| 90 | configuration.outgoing_transport = outgoing_transport; |
mflodman | c0e58a3 | 2016-04-25 01:26:26 -0700 | [diff] [blame] | 91 | configuration.rtt_stats = rtt_stats; |
| 92 | configuration.rtcp_packet_type_counter_observer = |
| 93 | rtcp_packet_type_counter_observer; |
Erik Språng | 54d5d2c | 2019-08-20 17:22:36 +0200 | [diff] [blame] | 94 | configuration.local_media_ssrc = local_ssrc; |
mflodman | c0e58a3 | 2016-04-25 01:26:26 -0700 | [diff] [blame] | 95 | |
Danil Chapovalov | c44f6cc | 2019-03-06 11:31:09 +0100 | [diff] [blame] | 96 | std::unique_ptr<RtpRtcp> rtp_rtcp = RtpRtcp::Create(configuration); |
mflodman | c0e58a3 | 2016-04-25 01:26:26 -0700 | [diff] [blame] | 97 | rtp_rtcp->SetRTCPStatus(RtcpMode::kCompound); |
| 98 | |
| 99 | return rtp_rtcp; |
| 100 | } |
| 101 | |
stefan@webrtc.org | eb24b04 | 2014-10-14 11:40:13 +0000 | [diff] [blame] | 102 | static const int kPacketLogIntervalMs = 10000; |
| 103 | |
Elad Alon | ef09c5b | 2019-05-31 13:25:50 +0200 | [diff] [blame] | 104 | RtpVideoStreamReceiver::RtcpFeedbackBuffer::RtcpFeedbackBuffer( |
| 105 | KeyFrameRequestSender* key_frame_request_sender, |
| 106 | NackSender* nack_sender, |
| 107 | LossNotificationSender* loss_notification_sender) |
| 108 | : key_frame_request_sender_(key_frame_request_sender), |
| 109 | nack_sender_(nack_sender), |
| 110 | loss_notification_sender_(loss_notification_sender), |
| 111 | request_key_frame_(false) { |
| 112 | RTC_DCHECK(key_frame_request_sender_); |
| 113 | RTC_DCHECK(nack_sender_); |
| 114 | RTC_DCHECK(loss_notification_sender_); |
| 115 | } |
| 116 | |
| 117 | void RtpVideoStreamReceiver::RtcpFeedbackBuffer::RequestKeyFrame() { |
| 118 | rtc::CritScope lock(&cs_); |
| 119 | request_key_frame_ = true; |
| 120 | } |
| 121 | |
| 122 | void RtpVideoStreamReceiver::RtcpFeedbackBuffer::SendNack( |
Elad Alon | ef09c5b | 2019-05-31 13:25:50 +0200 | [diff] [blame] | 123 | const std::vector<uint16_t>& sequence_numbers, |
| 124 | bool buffering_allowed) { |
| 125 | RTC_DCHECK(!sequence_numbers.empty()); |
| 126 | rtc::CritScope lock(&cs_); |
| 127 | nack_sequence_numbers_.insert(nack_sequence_numbers_.end(), |
| 128 | sequence_numbers.cbegin(), |
| 129 | sequence_numbers.cend()); |
| 130 | if (!buffering_allowed) { |
| 131 | // Note that while *buffering* is not allowed, *batching* is, meaning that |
| 132 | // previously buffered messages may be sent along with the current message. |
| 133 | SendBufferedRtcpFeedback(); |
| 134 | } |
| 135 | } |
| 136 | |
| 137 | void RtpVideoStreamReceiver::RtcpFeedbackBuffer::SendLossNotification( |
| 138 | uint16_t last_decoded_seq_num, |
| 139 | uint16_t last_received_seq_num, |
Elad Alon | e86af2c | 2019-06-03 14:37:50 +0200 | [diff] [blame] | 140 | bool decodability_flag, |
| 141 | bool buffering_allowed) { |
| 142 | RTC_DCHECK(buffering_allowed); |
Elad Alon | ef09c5b | 2019-05-31 13:25:50 +0200 | [diff] [blame] | 143 | rtc::CritScope lock(&cs_); |
Elad Alon | 36690cd | 2019-06-04 22:59:54 +0200 | [diff] [blame] | 144 | RTC_DCHECK(!lntf_state_) |
Elad Alon | ef09c5b | 2019-05-31 13:25:50 +0200 | [diff] [blame] | 145 | << "SendLossNotification() called twice in a row with no call to " |
| 146 | "SendBufferedRtcpFeedback() in between."; |
| 147 | lntf_state_ = absl::make_optional<LossNotificationState>( |
| 148 | last_decoded_seq_num, last_received_seq_num, decodability_flag); |
| 149 | } |
| 150 | |
Elad Alon | ef09c5b | 2019-05-31 13:25:50 +0200 | [diff] [blame] | 151 | void RtpVideoStreamReceiver::RtcpFeedbackBuffer::SendBufferedRtcpFeedback() { |
| 152 | bool request_key_frame = false; |
| 153 | std::vector<uint16_t> nack_sequence_numbers; |
| 154 | absl::optional<LossNotificationState> lntf_state; |
| 155 | |
| 156 | { |
| 157 | rtc::CritScope lock(&cs_); |
| 158 | std::swap(request_key_frame, request_key_frame_); |
| 159 | std::swap(nack_sequence_numbers, nack_sequence_numbers_); |
| 160 | std::swap(lntf_state, lntf_state_); |
| 161 | } |
| 162 | |
Elad Alon | e86af2c | 2019-06-03 14:37:50 +0200 | [diff] [blame] | 163 | if (lntf_state) { |
| 164 | // If either a NACK or a key frame request is sent, we should buffer |
| 165 | // the LNTF and wait for them (NACK or key frame request) to trigger |
| 166 | // the compound feedback message. |
| 167 | // Otherwise, the LNTF should be sent out immediately. |
| 168 | const bool buffering_allowed = |
| 169 | request_key_frame || !nack_sequence_numbers.empty(); |
| 170 | |
| 171 | loss_notification_sender_->SendLossNotification( |
| 172 | lntf_state->last_decoded_seq_num, lntf_state->last_received_seq_num, |
| 173 | lntf_state->decodability_flag, buffering_allowed); |
| 174 | } |
| 175 | |
Elad Alon | ef09c5b | 2019-05-31 13:25:50 +0200 | [diff] [blame] | 176 | if (request_key_frame) { |
| 177 | key_frame_request_sender_->RequestKeyFrame(); |
| 178 | } else if (!nack_sequence_numbers.empty()) { |
| 179 | nack_sender_->SendNack(nack_sequence_numbers, true); |
| 180 | } |
Elad Alon | ef09c5b | 2019-05-31 13:25:50 +0200 | [diff] [blame] | 181 | } |
| 182 | |
nisse | b1f2ff9 | 2017-06-09 04:01:55 -0700 | [diff] [blame] | 183 | RtpVideoStreamReceiver::RtpVideoStreamReceiver( |
Sebastian Jansson | 8026d60 | 2019-03-04 19:39:01 +0100 | [diff] [blame] | 184 | Clock* clock, |
mflodman | fa66659 | 2016-04-28 23:15:33 -0700 | [diff] [blame] | 185 | Transport* transport, |
| 186 | RtcpRttStats* rtt_stats, |
mflodman | cfc8e3b | 2016-05-03 21:22:04 -0700 | [diff] [blame] | 187 | PacketRouter* packet_router, |
Tommi | 733b547 | 2016-06-10 17:58:01 +0200 | [diff] [blame] | 188 | const VideoReceiveStream::Config* config, |
nisse | ca5706d | 2017-09-11 02:32:16 -0700 | [diff] [blame] | 189 | ReceiveStatistics* rtp_receive_statistics, |
mflodman | dc7d0d2 | 2016-05-06 05:32:22 -0700 | [diff] [blame] | 190 | ReceiveStatisticsProxy* receive_stats_proxy, |
Erik Språng | 737336d | 2016-07-29 12:59:36 +0200 | [diff] [blame] | 191 | ProcessThread* process_thread, |
philipel | fd5a20f | 2016-11-15 00:57:57 -0800 | [diff] [blame] | 192 | NackSender* nack_sender, |
Niels Möller | 2f5554d | 2019-05-29 13:35:14 +0200 | [diff] [blame] | 193 | KeyFrameRequestSender* keyframe_request_sender, |
Benjamin Wright | 192eeec | 2018-10-17 17:27:25 -0700 | [diff] [blame] | 194 | video_coding::OnCompleteFrameCallback* complete_frame_callback, |
| 195 | rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor) |
Sebastian Jansson | 8026d60 | 2019-03-04 19:39:01 +0100 | [diff] [blame] | 196 | : clock_(clock), |
Tommi | 733b547 | 2016-06-10 17:58:01 +0200 | [diff] [blame] | 197 | config_(*config), |
mflodman | c0e58a3 | 2016-04-25 01:26:26 -0700 | [diff] [blame] | 198 | packet_router_(packet_router), |
mflodman | dc7d0d2 | 2016-05-06 05:32:22 -0700 | [diff] [blame] | 199 | process_thread_(process_thread), |
Sebastian Jansson | 8026d60 | 2019-03-04 19:39:01 +0100 | [diff] [blame] | 200 | ntp_estimator_(clock), |
Niels Möller | b0573bc | 2017-09-25 10:47:00 +0200 | [diff] [blame] | 201 | rtp_header_extensions_(config_.rtp.extensions), |
nisse | ca5706d | 2017-09-11 02:32:16 -0700 | [diff] [blame] | 202 | rtp_receive_statistics_(rtp_receive_statistics), |
Ilya Nikolaevskiy | 2d821c3 | 2019-06-26 14:39:36 +0200 | [diff] [blame] | 203 | ulpfec_receiver_(UlpfecReceiver::Create(config->rtp.remote_ssrc, |
| 204 | this, |
| 205 | config->rtp.extensions)), |
stefan@webrtc.org | 7bb8f02 | 2013-09-06 13:40:11 +0000 | [diff] [blame] | 206 | receiving_(false), |
mflodman | c0e58a3 | 2016-04-25 01:26:26 -0700 | [diff] [blame] | 207 | last_packet_log_ms_(-1), |
Niels Möller | 2f5554d | 2019-05-29 13:35:14 +0200 | [diff] [blame] | 208 | rtp_rtcp_(CreateRtpRtcpModule(clock, |
| 209 | rtp_receive_statistics_, |
| 210 | transport, |
| 211 | rtt_stats, |
Erik Språng | e3a10e1 | 2019-08-19 15:45:00 +0200 | [diff] [blame] | 212 | receive_stats_proxy, |
| 213 | config_.rtp.local_ssrc)), |
philipel | fd5a20f | 2016-11-15 00:57:57 -0800 | [diff] [blame] | 214 | complete_frame_callback_(complete_frame_callback), |
Niels Möller | 2f5554d | 2019-05-29 13:35:14 +0200 | [diff] [blame] | 215 | keyframe_request_sender_(keyframe_request_sender), |
Elad Alon | ef09c5b | 2019-05-31 13:25:50 +0200 | [diff] [blame] | 216 | // TODO(bugs.webrtc.org/10336): Let |rtcp_feedback_buffer_| communicate |
| 217 | // directly with |rtp_rtcp_|. |
| 218 | rtcp_feedback_buffer_(this, nack_sender, this), |
Danil Chapovalov | ce1ffcd | 2019-10-22 17:12:42 +0200 | [diff] [blame] | 219 | packet_buffer_(clock_, kPacketBufferStartSize, PacketBufferMaxSize()), |
Benjamin Wright | 52426ed | 2019-03-01 11:01:59 -0800 | [diff] [blame] | 220 | has_received_frame_(false), |
Ruslan Burakov | d08bb1e | 2019-11-27 16:49:10 +0100 | [diff] [blame] | 221 | frames_decryptable_(false), |
| 222 | absolute_capture_time_receiver_(clock) { |
eladalon | 822ff2b | 2017-08-01 06:30:28 -0700 | [diff] [blame] | 223 | constexpr bool remb_candidate = true; |
Niels Möller | 60f4e29 | 2019-05-20 11:06:33 +0200 | [diff] [blame] | 224 | if (packet_router_) |
| 225 | packet_router_->AddReceiveRtpModule(rtp_rtcp_.get(), remb_candidate); |
mflodman | cfc8e3b | 2016-05-03 21:22:04 -0700 | [diff] [blame] | 226 | |
Tommi | 733b547 | 2016-06-10 17:58:01 +0200 | [diff] [blame] | 227 | RTC_DCHECK(config_.rtp.rtcp_mode != RtcpMode::kOff) |
mflodman | cfc8e3b | 2016-05-03 21:22:04 -0700 | [diff] [blame] | 228 | << "A stream should not be configured with RTCP disabled. This value is " |
| 229 | "reserved for internal usage."; |
mflodman | dc7d0d2 | 2016-05-06 05:32:22 -0700 | [diff] [blame] | 230 | // TODO(pbos): What's an appropriate local_ssrc for receive-only streams? |
| 231 | RTC_DCHECK(config_.rtp.local_ssrc != 0); |
| 232 | RTC_DCHECK(config_.rtp.remote_ssrc != config_.rtp.local_ssrc); |
| 233 | |
Tommi | 733b547 | 2016-06-10 17:58:01 +0200 | [diff] [blame] | 234 | rtp_rtcp_->SetRTCPStatus(config_.rtp.rtcp_mode); |
stefan | b4ab381 | 2017-06-09 06:12:11 -0700 | [diff] [blame] | 235 | rtp_rtcp_->SetRemoteSSRC(config_.rtp.remote_ssrc); |
mflodman | dc7d0d2 | 2016-05-06 05:32:22 -0700 | [diff] [blame] | 236 | |
mflodman | cfc8e3b | 2016-05-03 21:22:04 -0700 | [diff] [blame] | 237 | static const int kMaxPacketAgeToNack = 450; |
Tommi | 733b547 | 2016-06-10 17:58:01 +0200 | [diff] [blame] | 238 | const int max_reordering_threshold = (config_.rtp.nack.rtp_history_ms > 0) |
| 239 | ? kMaxPacketAgeToNack |
| 240 | : kDefaultMaxReorderingThreshold; |
Niels Möller | 87da109 | 2019-05-24 14:04:28 +0200 | [diff] [blame] | 241 | rtp_receive_statistics_->SetMaxReorderingThreshold(config_.rtp.remote_ssrc, |
| 242 | max_reordering_threshold); |
| 243 | // TODO(nisse): For historic reasons, we applied the above |
| 244 | // max_reordering_threshold also for RTX stats, which makes little sense since |
| 245 | // we don't NACK rtx packets. Consider deleting the below block, and rely on |
| 246 | // the default threshold. |
| 247 | if (config_.rtp.rtx_ssrc) { |
| 248 | rtp_receive_statistics_->SetMaxReorderingThreshold( |
| 249 | config_.rtp.rtx_ssrc, max_reordering_threshold); |
| 250 | } |
Tommi | 733b547 | 2016-06-10 17:58:01 +0200 | [diff] [blame] | 251 | if (config_.rtp.rtcp_xr.receiver_reference_time_report) |
mflodman | dc7d0d2 | 2016-05-06 05:32:22 -0700 | [diff] [blame] | 252 | rtp_rtcp_->SetRtcpXrRrtrStatus(true); |
| 253 | |
| 254 | // Stats callback for CNAME changes. |
Niels Möller | 4d7c405 | 2019-08-05 12:45:19 +0200 | [diff] [blame] | 255 | rtp_rtcp_->RegisterRtcpCnameCallback(receive_stats_proxy); |
mflodman | dc7d0d2 | 2016-05-06 05:32:22 -0700 | [diff] [blame] | 256 | |
tommi | dea489f | 2017-03-03 03:20:24 -0800 | [diff] [blame] | 257 | process_thread_->RegisterModule(rtp_rtcp_.get(), RTC_FROM_HERE); |
philipel | fd5a20f | 2016-11-15 00:57:57 -0800 | [diff] [blame] | 258 | |
Elad Alon | fadb181 | 2019-05-24 13:40:02 +0200 | [diff] [blame] | 259 | if (config_.rtp.lntf.enabled) { |
Elad Alon | 7d6a4c0 | 2019-02-25 13:00:51 +0100 | [diff] [blame] | 260 | loss_notification_controller_ = |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 261 | std::make_unique<LossNotificationController>(&rtcp_feedback_buffer_, |
| 262 | &rtcp_feedback_buffer_); |
Elad Alon | ca2c430 | 2019-05-27 22:43:10 +0200 | [diff] [blame] | 263 | } |
| 264 | |
| 265 | if (config_.rtp.nack.rtp_history_ms != 0) { |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 266 | nack_module_ = std::make_unique<NackModule>(clock_, &rtcp_feedback_buffer_, |
| 267 | &rtcp_feedback_buffer_); |
tommi | dea489f | 2017-03-03 03:20:24 -0800 | [diff] [blame] | 268 | process_thread_->RegisterModule(nack_module_.get(), RTC_FROM_HERE); |
tommi | f284b7f | 2017-02-27 01:59:36 -0800 | [diff] [blame] | 269 | } |
philipel | fd5a20f | 2016-11-15 00:57:57 -0800 | [diff] [blame] | 270 | |
Elad Alon | a8f5461 | 2018-11-06 11:21:25 +0100 | [diff] [blame] | 271 | reference_finder_ = |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 272 | std::make_unique<video_coding::RtpFrameReferenceFinder>(this); |
Benjamin Wright | a556448 | 2019-04-03 10:44:18 -0700 | [diff] [blame] | 273 | |
Benjamin Wright | 0076529 | 2018-11-30 16:18:26 -0800 | [diff] [blame] | 274 | // Only construct the encrypted receiver if frame encryption is enabled. |
Benjamin Wright | a556448 | 2019-04-03 10:44:18 -0700 | [diff] [blame] | 275 | if (config_.crypto_options.sframe.require_frame_encryption) { |
Benjamin Wright | 0076529 | 2018-11-30 16:18:26 -0800 | [diff] [blame] | 276 | buffered_frame_decryptor_ = |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 277 | std::make_unique<BufferedFrameDecryptor>(this, this); |
Benjamin Wright | a556448 | 2019-04-03 10:44:18 -0700 | [diff] [blame] | 278 | if (frame_decryptor != nullptr) { |
| 279 | buffered_frame_decryptor_->SetFrameDecryptor(std::move(frame_decryptor)); |
| 280 | } |
Benjamin Wright | 0076529 | 2018-11-30 16:18:26 -0800 | [diff] [blame] | 281 | } |
mflodman | c0e58a3 | 2016-04-25 01:26:26 -0700 | [diff] [blame] | 282 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 283 | |
nisse | b1f2ff9 | 2017-06-09 04:01:55 -0700 | [diff] [blame] | 284 | RtpVideoStreamReceiver::~RtpVideoStreamReceiver() { |
eladalon | c0d481a | 2017-08-02 07:39:07 -0700 | [diff] [blame] | 285 | RTC_DCHECK(secondary_sinks_.empty()); |
| 286 | |
tommi | f284b7f | 2017-02-27 01:59:36 -0800 | [diff] [blame] | 287 | if (nack_module_) { |
| 288 | process_thread_->DeRegisterModule(nack_module_.get()); |
| 289 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 290 | |
tommi | f284b7f | 2017-02-27 01:59:36 -0800 | [diff] [blame] | 291 | process_thread_->DeRegisterModule(rtp_rtcp_.get()); |
philipel | fd5a20f | 2016-11-15 00:57:57 -0800 | [diff] [blame] | 292 | |
Niels Möller | 60f4e29 | 2019-05-20 11:06:33 +0200 | [diff] [blame] | 293 | if (packet_router_) |
| 294 | packet_router_->RemoveReceiveRtpModule(rtp_rtcp_.get()); |
mflodman | dc7d0d2 | 2016-05-06 05:32:22 -0700 | [diff] [blame] | 295 | UpdateHistograms(); |
asapersson@webrtc.org | 0800db7 | 2015-01-15 07:40:20 +0000 | [diff] [blame] | 296 | } |
| 297 | |
Niels Möller | 2ff1f2a | 2018-08-09 16:16:34 +0200 | [diff] [blame] | 298 | void RtpVideoStreamReceiver::AddReceiveCodec( |
philipel | 022b54e | 2016-12-20 04:15:59 -0800 | [diff] [blame] | 299 | const VideoCodec& video_codec, |
Mirta Dvornicic | fe68daa | 2019-05-23 13:21:12 +0200 | [diff] [blame] | 300 | const std::map<std::string, std::string>& codec_params, |
| 301 | bool raw_payload) { |
Danil Chapovalov | cebdbf6 | 2019-12-13 16:08:18 +0100 | [diff] [blame] | 302 | payload_type_map_.emplace( |
| 303 | video_codec.plType, |
| 304 | raw_payload ? std::make_unique<VideoRtpDepacketizerRaw>() |
| 305 | : CreateVideoRtpDepacketizer(video_codec.codecType)); |
Niels Möller | 2ff1f2a | 2018-08-09 16:16:34 +0200 | [diff] [blame] | 306 | pt_codec_params_.emplace(video_codec.plType, codec_params); |
wu@webrtc.org | 822fbd8 | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 307 | } |
| 308 | |
Niels Möller | df9e9ae | 2018-07-31 08:29:53 +0200 | [diff] [blame] | 309 | absl::optional<Syncable::Info> RtpVideoStreamReceiver::GetSyncInfo() const { |
Niels Möller | 2ff1f2a | 2018-08-09 16:16:34 +0200 | [diff] [blame] | 310 | Syncable::Info info; |
Niels Möller | df9e9ae | 2018-07-31 08:29:53 +0200 | [diff] [blame] | 311 | if (rtp_rtcp_->RemoteNTP(&info.capture_time_ntp_secs, |
| 312 | &info.capture_time_ntp_frac, nullptr, nullptr, |
| 313 | &info.capture_time_source_clock) != 0) { |
| 314 | return absl::nullopt; |
| 315 | } |
Niels Möller | b0d4b41 | 2018-08-28 13:58:15 +0200 | [diff] [blame] | 316 | { |
Chen Xing | 90f3b89 | 2019-06-25 10:16:14 +0200 | [diff] [blame] | 317 | rtc::CritScope lock(&sync_info_lock_); |
Niels Möller | b0d4b41 | 2018-08-28 13:58:15 +0200 | [diff] [blame] | 318 | if (!last_received_rtp_timestamp_ || !last_received_rtp_system_time_ms_) { |
| 319 | return absl::nullopt; |
| 320 | } |
| 321 | info.latest_received_capture_timestamp = *last_received_rtp_timestamp_; |
| 322 | info.latest_receive_time_ms = *last_received_rtp_system_time_ms_; |
| 323 | } |
Niels Möller | df9e9ae | 2018-07-31 08:29:53 +0200 | [diff] [blame] | 324 | |
| 325 | // Leaves info.current_delay_ms uninitialized. |
| 326 | return info; |
wu@webrtc.org | 822fbd8 | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 327 | } |
| 328 | |
Danil Chapovalov | c71d85b | 2019-10-16 19:18:21 +0200 | [diff] [blame] | 329 | void RtpVideoStreamReceiver::OnReceivedPayloadData( |
Danil Chapovalov | cebdbf6 | 2019-12-13 16:08:18 +0100 | [diff] [blame] | 330 | rtc::CopyOnWriteBuffer codec_payload, |
Danil Chapovalov | c71d85b | 2019-10-16 19:18:21 +0200 | [diff] [blame] | 331 | const RtpPacketReceived& rtp_packet, |
| 332 | const RTPVideoHeader& video) { |
Danil Chapovalov | 09860e0 | 2019-10-30 14:12:24 +0100 | [diff] [blame] | 333 | RTC_DCHECK_RUN_ON(&worker_task_checker_); |
Danil Chapovalov | aa3f5da | 2019-11-14 14:57:33 +0100 | [diff] [blame] | 334 | video_coding::PacketBuffer::Packet packet( |
| 335 | rtp_packet, video, ntp_estimator_.Estimate(rtp_packet.Timestamp()), |
| 336 | clock_->TimeInMilliseconds()); |
Danil Chapovalov | c71d85b | 2019-10-16 19:18:21 +0200 | [diff] [blame] | 337 | |
Ruslan Burakov | d08bb1e | 2019-11-27 16:49:10 +0100 | [diff] [blame] | 338 | // Try to extrapolate absolute capture time if it is missing. |
| 339 | // TODO(bugs.webrtc.org/10739): Add support for estimated capture clock |
| 340 | // offset. |
| 341 | packet.packet_info.set_absolute_capture_time( |
| 342 | absolute_capture_time_receiver_.OnReceivePacket( |
| 343 | AbsoluteCaptureTimeReceiver::GetSource(packet.packet_info.ssrc(), |
| 344 | packet.packet_info.csrcs()), |
| 345 | packet.packet_info.rtp_timestamp(), |
| 346 | // Assume frequency is the same one for all video frames. |
| 347 | kVideoPayloadTypeFrequency, |
| 348 | packet.packet_info.absolute_capture_time())); |
| 349 | |
Danil Chapovalov | c71d85b | 2019-10-16 19:18:21 +0200 | [diff] [blame] | 350 | RTPVideoHeader& video_header = packet.video_header; |
| 351 | video_header.rotation = kVideoRotation_0; |
| 352 | video_header.content_type = VideoContentType::UNSPECIFIED; |
| 353 | video_header.video_timing.flags = VideoSendTiming::kInvalid; |
| 354 | video_header.is_last_packet_in_frame |= rtp_packet.Marker(); |
| 355 | video_header.frame_marking.temporal_id = kNoTemporalIdx; |
| 356 | |
| 357 | if (const auto* vp9_header = |
| 358 | absl::get_if<RTPVideoHeaderVP9>(&video_header.video_type_header)) { |
| 359 | video_header.is_last_packet_in_frame |= vp9_header->end_of_frame; |
| 360 | video_header.is_first_packet_in_frame |= vp9_header->beginning_of_frame; |
| 361 | } |
| 362 | |
| 363 | rtp_packet.GetExtension<VideoOrientation>(&video_header.rotation); |
| 364 | rtp_packet.GetExtension<VideoContentTypeExtension>( |
| 365 | &video_header.content_type); |
| 366 | rtp_packet.GetExtension<VideoTimingExtension>(&video_header.video_timing); |
| 367 | rtp_packet.GetExtension<PlayoutDelayLimits>(&video_header.playout_delay); |
| 368 | rtp_packet.GetExtension<FrameMarkingExtension>(&video_header.frame_marking); |
| 369 | |
| 370 | RtpGenericFrameDescriptor& generic_descriptor = |
| 371 | packet.generic_descriptor.emplace(); |
| 372 | if (rtp_packet.GetExtension<RtpGenericFrameDescriptorExtension01>( |
| 373 | &generic_descriptor)) { |
| 374 | if (rtp_packet.HasExtension<RtpGenericFrameDescriptorExtension00>()) { |
| 375 | RTC_LOG(LS_WARNING) << "RTP packet had two different GFD versions."; |
| 376 | return; |
| 377 | } |
| 378 | generic_descriptor.SetByteRepresentation( |
| 379 | rtp_packet.GetRawExtension<RtpGenericFrameDescriptorExtension01>()); |
| 380 | } else if ((rtp_packet.GetExtension<RtpGenericFrameDescriptorExtension00>( |
| 381 | &generic_descriptor))) { |
| 382 | generic_descriptor.SetByteRepresentation( |
| 383 | rtp_packet.GetRawExtension<RtpGenericFrameDescriptorExtension00>()); |
| 384 | } else { |
| 385 | packet.generic_descriptor = absl::nullopt; |
| 386 | } |
| 387 | if (packet.generic_descriptor != absl::nullopt) { |
| 388 | video_header.is_first_packet_in_frame = |
| 389 | packet.generic_descriptor->FirstPacketInSubFrame(); |
| 390 | video_header.is_last_packet_in_frame = |
| 391 | rtp_packet.Marker() || |
| 392 | packet.generic_descriptor->LastPacketInSubFrame(); |
| 393 | |
| 394 | if (packet.generic_descriptor->FirstPacketInSubFrame()) { |
| 395 | video_header.frame_type = |
| 396 | packet.generic_descriptor->FrameDependenciesDiffs().empty() |
| 397 | ? VideoFrameType::kVideoFrameKey |
| 398 | : VideoFrameType::kVideoFrameDelta; |
| 399 | } |
| 400 | |
| 401 | video_header.width = packet.generic_descriptor->Width(); |
| 402 | video_header.height = packet.generic_descriptor->Height(); |
| 403 | } |
| 404 | |
| 405 | // Color space should only be transmitted in the last packet of a frame, |
| 406 | // therefore, neglect it otherwise so that last_color_space_ is not reset by |
| 407 | // mistake. |
| 408 | if (video_header.is_last_packet_in_frame) { |
| 409 | video_header.color_space = rtp_packet.GetExtension<ColorSpaceExtension>(); |
| 410 | if (video_header.color_space || |
| 411 | video_header.frame_type == VideoFrameType::kVideoFrameKey) { |
| 412 | // Store color space since it's only transmitted when changed or for key |
| 413 | // frames. Color space will be cleared if a key frame is transmitted |
| 414 | // without color space information. |
| 415 | last_color_space_ = video_header.color_space; |
| 416 | } else if (last_color_space_) { |
| 417 | video_header.color_space = last_color_space_; |
| 418 | } |
| 419 | } |
Elad Alon | 7d6a4c0 | 2019-02-25 13:00:51 +0100 | [diff] [blame] | 420 | |
Elad Alon | ca2c430 | 2019-05-27 22:43:10 +0200 | [diff] [blame] | 421 | if (loss_notification_controller_) { |
Danil Chapovalov | c71d85b | 2019-10-16 19:18:21 +0200 | [diff] [blame] | 422 | if (rtp_packet.recovered()) { |
Elad Alon | ca2c430 | 2019-05-27 22:43:10 +0200 | [diff] [blame] | 423 | // TODO(bugs.webrtc.org/10336): Implement support for reordering. |
Niels Möller | a740142 | 2019-09-13 14:18:58 +0200 | [diff] [blame] | 424 | RTC_LOG(LS_INFO) |
Elad Alon | ca2c430 | 2019-05-27 22:43:10 +0200 | [diff] [blame] | 425 | << "LossNotificationController does not support reordering."; |
Danil Chapovalov | c71d85b | 2019-10-16 19:18:21 +0200 | [diff] [blame] | 426 | } else if (!packet.generic_descriptor) { |
Niels Möller | a740142 | 2019-09-13 14:18:58 +0200 | [diff] [blame] | 427 | RTC_LOG(LS_WARNING) << "LossNotificationController requires generic " |
| 428 | "frame descriptor, but it is missing."; |
Elad Alon | ca2c430 | 2019-05-27 22:43:10 +0200 | [diff] [blame] | 429 | } else { |
Danil Chapovalov | c71d85b | 2019-10-16 19:18:21 +0200 | [diff] [blame] | 430 | loss_notification_controller_->OnReceivedPacket( |
| 431 | rtp_packet.SequenceNumber(), *packet.generic_descriptor); |
Elad Alon | ca2c430 | 2019-05-27 22:43:10 +0200 | [diff] [blame] | 432 | } |
| 433 | } |
| 434 | |
Niels Möller | 8dad9b4 | 2018-08-22 10:36:35 +0200 | [diff] [blame] | 435 | if (nack_module_) { |
Niels Möller | abbc50e | 2019-04-24 09:41:16 +0200 | [diff] [blame] | 436 | const bool is_keyframe = |
| 437 | video_header.is_first_packet_in_frame && |
| 438 | video_header.frame_type == VideoFrameType::kVideoFrameKey; |
Niels Möller | 8dad9b4 | 2018-08-22 10:36:35 +0200 | [diff] [blame] | 439 | |
Danil Chapovalov | aa3f5da | 2019-11-14 14:57:33 +0100 | [diff] [blame] | 440 | packet.times_nacked = nack_module_->OnReceivedPacket( |
Danil Chapovalov | c71d85b | 2019-10-16 19:18:21 +0200 | [diff] [blame] | 441 | rtp_packet.SequenceNumber(), is_keyframe, rtp_packet.recovered()); |
Niels Möller | 8dad9b4 | 2018-08-22 10:36:35 +0200 | [diff] [blame] | 442 | } else { |
Danil Chapovalov | aa3f5da | 2019-11-14 14:57:33 +0100 | [diff] [blame] | 443 | packet.times_nacked = -1; |
Niels Möller | 8dad9b4 | 2018-08-22 10:36:35 +0200 | [diff] [blame] | 444 | } |
philipel | fd5a20f | 2016-11-15 00:57:57 -0800 | [diff] [blame] | 445 | |
Danil Chapovalov | cebdbf6 | 2019-12-13 16:08:18 +0100 | [diff] [blame] | 446 | if (codec_payload.size() == 0) { |
Danil Chapovalov | aa3f5da | 2019-11-14 14:57:33 +0100 | [diff] [blame] | 447 | NotifyReceiverOfEmptyPacket(packet.seq_num); |
Elad Alon | ef09c5b | 2019-05-31 13:25:50 +0200 | [diff] [blame] | 448 | rtcp_feedback_buffer_.SendBufferedRtcpFeedback(); |
Danil Chapovalov | c71d85b | 2019-10-16 19:18:21 +0200 | [diff] [blame] | 449 | return; |
philipel | 54ca919 | 2017-03-21 05:45:18 -0700 | [diff] [blame] | 450 | } |
| 451 | |
Niels Möller | d5e02f0 | 2019-02-20 13:12:21 +0100 | [diff] [blame] | 452 | if (packet.codec() == kVideoCodecH264) { |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 453 | // Only when we start to receive packets will we know what payload type |
| 454 | // that will be used. When we know the payload type insert the correct |
| 455 | // sps/pps into the tracker. |
Danil Chapovalov | aa3f5da | 2019-11-14 14:57:33 +0100 | [diff] [blame] | 456 | if (packet.payload_type != last_payload_type_) { |
| 457 | last_payload_type_ = packet.payload_type; |
| 458 | InsertSpsPpsIntoTracker(packet.payload_type); |
philipel | fd5a20f | 2016-11-15 00:57:57 -0800 | [diff] [blame] | 459 | } |
| 460 | |
Danil Chapovalov | fbec2ec | 2019-10-28 13:27:05 +0100 | [diff] [blame] | 461 | video_coding::H264SpsPpsTracker::FixedBitstream fixed = |
Danil Chapovalov | cebdbf6 | 2019-12-13 16:08:18 +0100 | [diff] [blame] | 462 | tracker_.CopyAndFixBitstream( |
| 463 | rtc::MakeArrayView(codec_payload.cdata(), codec_payload.size()), |
| 464 | &packet.video_header); |
Danil Chapovalov | fbec2ec | 2019-10-28 13:27:05 +0100 | [diff] [blame] | 465 | |
| 466 | switch (fixed.action) { |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 467 | case video_coding::H264SpsPpsTracker::kRequestKeyframe: |
Elad Alon | ef09c5b | 2019-05-31 13:25:50 +0200 | [diff] [blame] | 468 | rtcp_feedback_buffer_.RequestKeyFrame(); |
| 469 | rtcp_feedback_buffer_.SendBufferedRtcpFeedback(); |
Karl Wiberg | 80ba333 | 2018-02-05 10:33:35 +0100 | [diff] [blame] | 470 | RTC_FALLTHROUGH(); |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 471 | case video_coding::H264SpsPpsTracker::kDrop: |
Danil Chapovalov | c71d85b | 2019-10-16 19:18:21 +0200 | [diff] [blame] | 472 | return; |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 473 | case video_coding::H264SpsPpsTracker::kInsert: |
Danil Chapovalov | e3c4884 | 2019-12-02 15:54:27 +0100 | [diff] [blame] | 474 | packet.video_payload = std::move(fixed.bitstream); |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 475 | break; |
| 476 | } |
| 477 | |
philipel | fd5a20f | 2016-11-15 00:57:57 -0800 | [diff] [blame] | 478 | } else { |
Danil Chapovalov | cebdbf6 | 2019-12-13 16:08:18 +0100 | [diff] [blame] | 479 | packet.video_payload = std::move(codec_payload); |
mflodman@webrtc.org | ad4ee36 | 2011-11-28 22:39:24 +0000 | [diff] [blame] | 480 | } |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 481 | |
Elad Alon | ef09c5b | 2019-05-31 13:25:50 +0200 | [diff] [blame] | 482 | rtcp_feedback_buffer_.SendBufferedRtcpFeedback(); |
Danil Chapovalov | 09860e0 | 2019-10-30 14:12:24 +0100 | [diff] [blame] | 483 | frame_counter_.Add(packet.timestamp); |
Danil Chapovalov | ce1ffcd | 2019-10-22 17:12:42 +0200 | [diff] [blame] | 484 | OnInsertedPacket(packet_buffer_.InsertPacket(&packet)); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 485 | } |
| 486 | |
nisse | b1f2ff9 | 2017-06-09 04:01:55 -0700 | [diff] [blame] | 487 | void RtpVideoStreamReceiver::OnRecoveredPacket(const uint8_t* rtp_packet, |
| 488 | size_t rtp_packet_length) { |
Niels Möller | b0573bc | 2017-09-25 10:47:00 +0200 | [diff] [blame] | 489 | RtpPacketReceived packet; |
| 490 | if (!packet.Parse(rtp_packet, rtp_packet_length)) |
nisse | 30e8931 | 2017-05-29 08:16:37 -0700 | [diff] [blame] | 491 | return; |
Niels Möller | 2ff1f2a | 2018-08-09 16:16:34 +0200 | [diff] [blame] | 492 | if (packet.PayloadType() == config_.rtp.red_payload_type) { |
| 493 | RTC_LOG(LS_WARNING) << "Discarding recovered packet with RED encapsulation"; |
| 494 | return; |
| 495 | } |
| 496 | |
Niels Möller | b0573bc | 2017-09-25 10:47:00 +0200 | [diff] [blame] | 497 | packet.IdentifyExtensions(rtp_header_extensions_); |
| 498 | packet.set_payload_type_frequency(kVideoPayloadTypeFrequency); |
Niels Möller | 2ff1f2a | 2018-08-09 16:16:34 +0200 | [diff] [blame] | 499 | // TODO(nisse): UlpfecReceiverImpl::ProcessReceivedFec passes both |
| 500 | // original (decapsulated) media packets and recovered packets to |
| 501 | // this callback. We need a way to distinguish, for setting |
| 502 | // packet.recovered() correctly. Ideally, move RED decapsulation out |
| 503 | // of the Ulpfec implementation. |
Niels Möller | b0573bc | 2017-09-25 10:47:00 +0200 | [diff] [blame] | 504 | |
Niels Möller | 2ff1f2a | 2018-08-09 16:16:34 +0200 | [diff] [blame] | 505 | ReceivePacket(packet); |
wu@webrtc.org | 822fbd8 | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 506 | } |
| 507 | |
nisse | d2ef314 | 2017-05-11 08:00:58 -0700 | [diff] [blame] | 508 | // This method handles both regular RTP packets and packets recovered |
| 509 | // via FlexFEC. |
nisse | b1f2ff9 | 2017-06-09 04:01:55 -0700 | [diff] [blame] | 510 | void RtpVideoStreamReceiver::OnRtpPacket(const RtpPacketReceived& packet) { |
Sebastian Jansson | b55015e | 2019-04-09 13:44:04 +0200 | [diff] [blame] | 511 | RTC_DCHECK_RUN_ON(&worker_task_checker_); |
eladalon | c0d481a | 2017-08-02 07:39:07 -0700 | [diff] [blame] | 512 | |
eladalon | 8b07305 | 2017-08-25 00:49:08 -0700 | [diff] [blame] | 513 | if (!receiving_) { |
| 514 | return; |
| 515 | } |
solenberg@webrtc.org | fc32046 | 2014-02-11 15:27:49 +0000 | [diff] [blame] | 516 | |
eladalon | 8b07305 | 2017-08-25 00:49:08 -0700 | [diff] [blame] | 517 | if (!packet.recovered()) { |
Jonas Oreland | 49ac595 | 2018-09-26 16:04:32 +0200 | [diff] [blame] | 518 | // TODO(nisse): Exclude out-of-order packets? |
eladalon | 8b07305 | 2017-08-25 00:49:08 -0700 | [diff] [blame] | 519 | int64_t now_ms = clock_->TimeInMilliseconds(); |
Niels Möller | b0d4b41 | 2018-08-28 13:58:15 +0200 | [diff] [blame] | 520 | { |
Chen Xing | 90f3b89 | 2019-06-25 10:16:14 +0200 | [diff] [blame] | 521 | rtc::CritScope cs(&sync_info_lock_); |
Niels Möller | b0d4b41 | 2018-08-28 13:58:15 +0200 | [diff] [blame] | 522 | last_received_rtp_timestamp_ = packet.Timestamp(); |
| 523 | last_received_rtp_system_time_ms_ = now_ms; |
| 524 | } |
eladalon | 8b07305 | 2017-08-25 00:49:08 -0700 | [diff] [blame] | 525 | // Periodically log the RTP header of incoming packets. |
| 526 | if (now_ms - last_packet_log_ms_ > kPacketLogIntervalMs) { |
Jonas Olsson | 366a50c | 2018-09-06 13:41:30 +0200 | [diff] [blame] | 527 | rtc::StringBuilder ss; |
eladalon | 8b07305 | 2017-08-25 00:49:08 -0700 | [diff] [blame] | 528 | ss << "Packet received on SSRC: " << packet.Ssrc() |
| 529 | << " with payload type: " << static_cast<int>(packet.PayloadType()) |
| 530 | << ", timestamp: " << packet.Timestamp() |
| 531 | << ", sequence number: " << packet.SequenceNumber() |
| 532 | << ", arrival time: " << packet.arrival_time_ms(); |
| 533 | int32_t time_offset; |
| 534 | if (packet.GetExtension<TransmissionOffset>(&time_offset)) { |
| 535 | ss << ", toffset: " << time_offset; |
nisse | 38cc1d6 | 2017-02-13 05:59:46 -0800 | [diff] [blame] | 536 | } |
eladalon | 8b07305 | 2017-08-25 00:49:08 -0700 | [diff] [blame] | 537 | uint32_t send_time; |
| 538 | if (packet.GetExtension<AbsoluteSendTime>(&send_time)) { |
| 539 | ss << ", abs send time: " << send_time; |
| 540 | } |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 541 | RTC_LOG(LS_INFO) << ss.str(); |
eladalon | 8b07305 | 2017-08-25 00:49:08 -0700 | [diff] [blame] | 542 | last_packet_log_ms_ = now_ms; |
stefan@webrtc.org | eb24b04 | 2014-10-14 11:40:13 +0000 | [diff] [blame] | 543 | } |
| 544 | } |
wu@webrtc.org | a989080 | 2013-12-13 00:21:03 +0000 | [diff] [blame] | 545 | |
Niels Möller | 2ff1f2a | 2018-08-09 16:16:34 +0200 | [diff] [blame] | 546 | ReceivePacket(packet); |
nisse | 38cc1d6 | 2017-02-13 05:59:46 -0800 | [diff] [blame] | 547 | |
asapersson@webrtc.org | 1457b47 | 2014-05-26 13:06:04 +0000 | [diff] [blame] | 548 | // Update receive statistics after ReceivePacket. |
| 549 | // Receive statistics will be reset if the payload type changes (make sure |
| 550 | // that the first packet is included in the stats). |
nisse | d2ef314 | 2017-05-11 08:00:58 -0700 | [diff] [blame] | 551 | if (!packet.recovered()) { |
Niels Möller | 1f3206c | 2018-09-14 08:26:32 +0200 | [diff] [blame] | 552 | rtp_receive_statistics_->OnRtpPacket(packet); |
nisse | d2ef314 | 2017-05-11 08:00:58 -0700 | [diff] [blame] | 553 | } |
eladalon | c0d481a | 2017-08-02 07:39:07 -0700 | [diff] [blame] | 554 | |
| 555 | for (RtpPacketSinkInterface* secondary_sink : secondary_sinks_) { |
| 556 | secondary_sink->OnRtpPacket(packet); |
| 557 | } |
stefan@webrtc.org | 7bb8f02 | 2013-09-06 13:40:11 +0000 | [diff] [blame] | 558 | } |
| 559 | |
Niels Möller | 4168437 | 2019-03-25 15:51:03 +0100 | [diff] [blame] | 560 | void RtpVideoStreamReceiver::RequestKeyFrame() { |
Elad Alon | ef09c5b | 2019-05-31 13:25:50 +0200 | [diff] [blame] | 561 | // TODO(bugs.webrtc.org/10336): Allow the sender to ignore key frame requests |
| 562 | // issued by anything other than the LossNotificationController if it (the |
| 563 | // sender) is relying on LNTF alone. |
Niels Möller | 2f5554d | 2019-05-29 13:35:14 +0200 | [diff] [blame] | 564 | if (keyframe_request_sender_) { |
| 565 | keyframe_request_sender_->RequestKeyFrame(); |
| 566 | } else { |
Niels Möller | dd0094a | 2019-06-04 14:46:27 +0200 | [diff] [blame] | 567 | rtp_rtcp_->SendPictureLossIndication(); |
Niels Möller | 2f5554d | 2019-05-29 13:35:14 +0200 | [diff] [blame] | 568 | } |
mflodman | cfc8e3b | 2016-05-03 21:22:04 -0700 | [diff] [blame] | 569 | } |
| 570 | |
Elad Alon | 7d6a4c0 | 2019-02-25 13:00:51 +0100 | [diff] [blame] | 571 | void RtpVideoStreamReceiver::SendLossNotification( |
| 572 | uint16_t last_decoded_seq_num, |
| 573 | uint16_t last_received_seq_num, |
Elad Alon | e86af2c | 2019-06-03 14:37:50 +0200 | [diff] [blame] | 574 | bool decodability_flag, |
| 575 | bool buffering_allowed) { |
Elad Alon | fadb181 | 2019-05-24 13:40:02 +0200 | [diff] [blame] | 576 | RTC_DCHECK(config_.rtp.lntf.enabled); |
Elad Alon | 7d6a4c0 | 2019-02-25 13:00:51 +0100 | [diff] [blame] | 577 | rtp_rtcp_->SendLossNotification(last_decoded_seq_num, last_received_seq_num, |
Elad Alon | e86af2c | 2019-06-03 14:37:50 +0200 | [diff] [blame] | 578 | decodability_flag, buffering_allowed); |
Elad Alon | 7d6a4c0 | 2019-02-25 13:00:51 +0100 | [diff] [blame] | 579 | } |
| 580 | |
nisse | b1f2ff9 | 2017-06-09 04:01:55 -0700 | [diff] [blame] | 581 | bool RtpVideoStreamReceiver::IsUlpfecEnabled() const { |
nisse | 3b3622f | 2017-09-26 02:49:21 -0700 | [diff] [blame] | 582 | return config_.rtp.ulpfec_payload_type != -1; |
brandtr | e6f98c7 | 2016-11-11 03:28:30 -0800 | [diff] [blame] | 583 | } |
| 584 | |
nisse | b1f2ff9 | 2017-06-09 04:01:55 -0700 | [diff] [blame] | 585 | bool RtpVideoStreamReceiver::IsRetransmissionsEnabled() const { |
mflodman | dc7d0d2 | 2016-05-06 05:32:22 -0700 | [diff] [blame] | 586 | return config_.rtp.nack.rtp_history_ms > 0; |
| 587 | } |
| 588 | |
nisse | b1f2ff9 | 2017-06-09 04:01:55 -0700 | [diff] [blame] | 589 | void RtpVideoStreamReceiver::RequestPacketRetransmit( |
mflodman | dc7d0d2 | 2016-05-06 05:32:22 -0700 | [diff] [blame] | 590 | const std::vector<uint16_t>& sequence_numbers) { |
| 591 | rtp_rtcp_->SendNack(sequence_numbers); |
| 592 | } |
| 593 | |
Benjamin Wright | 52426ed | 2019-03-01 11:01:59 -0800 | [diff] [blame] | 594 | bool RtpVideoStreamReceiver::IsDecryptable() const { |
| 595 | return frames_decryptable_.load(); |
| 596 | } |
| 597 | |
Danil Chapovalov | ce1ffcd | 2019-10-22 17:12:42 +0200 | [diff] [blame] | 598 | void RtpVideoStreamReceiver::OnInsertedPacket( |
| 599 | video_coding::PacketBuffer::InsertResult result) { |
| 600 | for (std::unique_ptr<video_coding::RtpFrameObject>& frame : result.frames) { |
| 601 | OnAssembledFrame(std::move(frame)); |
| 602 | } |
| 603 | if (result.buffer_cleared) { |
| 604 | RequestKeyFrame(); |
| 605 | } |
| 606 | } |
| 607 | |
Elad Alon | b4643ad | 2019-02-22 11:19:50 +0100 | [diff] [blame] | 608 | void RtpVideoStreamReceiver::OnAssembledFrame( |
philipel | fd5a20f | 2016-11-15 00:57:57 -0800 | [diff] [blame] | 609 | std::unique_ptr<video_coding::RtpFrameObject> frame) { |
Benjamin Wright | 0076529 | 2018-11-30 16:18:26 -0800 | [diff] [blame] | 610 | RTC_DCHECK_RUN_ON(&network_tc_); |
Elad Alon | 7d6a4c0 | 2019-02-25 13:00:51 +0100 | [diff] [blame] | 611 | RTC_DCHECK(frame); |
| 612 | |
| 613 | absl::optional<RtpGenericFrameDescriptor> descriptor = |
| 614 | frame->GetGenericFrameDescriptor(); |
| 615 | |
| 616 | if (loss_notification_controller_ && descriptor) { |
| 617 | loss_notification_controller_->OnAssembledFrame( |
| 618 | frame->first_seq_num(), descriptor->FrameId(), |
| 619 | descriptor->Discardable().value_or(false), |
| 620 | descriptor->FrameDependenciesDiffs()); |
Elad Alon | ca2c430 | 2019-05-27 22:43:10 +0200 | [diff] [blame] | 621 | } |
| 622 | |
Elad Alon | ef09c5b | 2019-05-31 13:25:50 +0200 | [diff] [blame] | 623 | // If frames arrive before a key frame, they would not be decodable. |
| 624 | // In that case, request a key frame ASAP. |
Elad Alon | ca2c430 | 2019-05-27 22:43:10 +0200 | [diff] [blame] | 625 | if (!has_received_frame_) { |
Niels Möller | 8f7ce22 | 2019-03-21 15:43:58 +0100 | [diff] [blame] | 626 | if (frame->FrameType() != VideoFrameType::kVideoFrameKey) { |
Elad Alon | ef09c5b | 2019-05-31 13:25:50 +0200 | [diff] [blame] | 627 | // |loss_notification_controller_|, if present, would have already |
| 628 | // requested a key frame when the first packet for the non-key frame |
| 629 | // had arrived, so no need to replicate the request. |
| 630 | if (!loss_notification_controller_) { |
| 631 | RequestKeyFrame(); |
| 632 | } |
Benjamin Wright | 39feabe | 2018-10-22 13:33:09 -0700 | [diff] [blame] | 633 | } |
Elad Alon | ef09c5b | 2019-05-31 13:25:50 +0200 | [diff] [blame] | 634 | has_received_frame_ = true; |
Benjamin Wright | 39feabe | 2018-10-22 13:33:09 -0700 | [diff] [blame] | 635 | } |
Elad Alon | 7d6a4c0 | 2019-02-25 13:00:51 +0100 | [diff] [blame] | 636 | |
philipel | 7acc4a4 | 2019-09-26 11:25:52 +0200 | [diff] [blame] | 637 | rtc::CritScope lock(&reference_finder_lock_); |
| 638 | // Reset |reference_finder_| if |frame| is new and the codec have changed. |
| 639 | if (current_codec_) { |
| 640 | bool frame_is_newer = |
| 641 | AheadOf(frame->Timestamp(), last_assembled_frame_rtp_timestamp_); |
| 642 | |
| 643 | if (frame->codec_type() != current_codec_) { |
| 644 | if (frame_is_newer) { |
Ilya Nikolaevskiy | 815e00c | 2019-11-12 15:20:21 +0000 | [diff] [blame] | 645 | // When we reset the |reference_finder_| we don't want new picture ids |
| 646 | // to overlap with old picture ids. To ensure that doesn't happen we |
| 647 | // start from the |last_completed_picture_id_| and add an offset in case |
| 648 | // of reordering. |
| 649 | reference_finder_ = |
| 650 | std::make_unique<video_coding::RtpFrameReferenceFinder>( |
| 651 | this, last_completed_picture_id_ + |
| 652 | std::numeric_limits<uint16_t>::max()); |
philipel | 7acc4a4 | 2019-09-26 11:25:52 +0200 | [diff] [blame] | 653 | current_codec_ = frame->codec_type(); |
| 654 | } else { |
| 655 | // Old frame from before the codec switch, discard it. |
| 656 | return; |
| 657 | } |
| 658 | } |
| 659 | |
| 660 | if (frame_is_newer) { |
| 661 | last_assembled_frame_rtp_timestamp_ = frame->Timestamp(); |
| 662 | } |
| 663 | } else { |
| 664 | current_codec_ = frame->codec_type(); |
| 665 | last_assembled_frame_rtp_timestamp_ = frame->Timestamp(); |
| 666 | } |
| 667 | |
Benjamin Wright | 0076529 | 2018-11-30 16:18:26 -0800 | [diff] [blame] | 668 | if (buffered_frame_decryptor_ == nullptr) { |
| 669 | reference_finder_->ManageFrame(std::move(frame)); |
| 670 | } else { |
| 671 | buffered_frame_decryptor_->ManageEncryptedFrame(std::move(frame)); |
Benjamin Wright | 192eeec | 2018-10-17 17:27:25 -0700 | [diff] [blame] | 672 | } |
philipel | fd5a20f | 2016-11-15 00:57:57 -0800 | [diff] [blame] | 673 | } |
| 674 | |
nisse | b1f2ff9 | 2017-06-09 04:01:55 -0700 | [diff] [blame] | 675 | void RtpVideoStreamReceiver::OnCompleteFrame( |
philipel | e7c891f | 2018-02-22 14:35:06 +0100 | [diff] [blame] | 676 | std::unique_ptr<video_coding::EncodedFrame> frame) { |
philipel | fd5a20f | 2016-11-15 00:57:57 -0800 | [diff] [blame] | 677 | { |
| 678 | rtc::CritScope lock(&last_seq_num_cs_); |
| 679 | video_coding::RtpFrameObject* rtp_frame = |
| 680 | static_cast<video_coding::RtpFrameObject*>(frame.get()); |
philipel | 0fa82a6 | 2018-03-19 15:34:53 +0100 | [diff] [blame] | 681 | last_seq_num_for_pic_id_[rtp_frame->id.picture_id] = |
| 682 | rtp_frame->last_seq_num(); |
philipel | fd5a20f | 2016-11-15 00:57:57 -0800 | [diff] [blame] | 683 | } |
philipel | 7acc4a4 | 2019-09-26 11:25:52 +0200 | [diff] [blame] | 684 | last_completed_picture_id_ = |
| 685 | std::max(last_completed_picture_id_, frame->id.picture_id); |
philipel | fd5a20f | 2016-11-15 00:57:57 -0800 | [diff] [blame] | 686 | complete_frame_callback_->OnCompleteFrame(std::move(frame)); |
| 687 | } |
| 688 | |
Benjamin Wright | 0076529 | 2018-11-30 16:18:26 -0800 | [diff] [blame] | 689 | void RtpVideoStreamReceiver::OnDecryptedFrame( |
| 690 | std::unique_ptr<video_coding::RtpFrameObject> frame) { |
philipel | 7acc4a4 | 2019-09-26 11:25:52 +0200 | [diff] [blame] | 691 | rtc::CritScope lock(&reference_finder_lock_); |
Benjamin Wright | 0076529 | 2018-11-30 16:18:26 -0800 | [diff] [blame] | 692 | reference_finder_->ManageFrame(std::move(frame)); |
| 693 | } |
| 694 | |
Benjamin Wright | 2af5dcb | 2019-04-09 20:08:41 +0000 | [diff] [blame] | 695 | void RtpVideoStreamReceiver::OnDecryptionStatusChange( |
| 696 | FrameDecryptorInterface::Status status) { |
| 697 | frames_decryptable_.store( |
| 698 | (status == FrameDecryptorInterface::Status::kOk) || |
| 699 | (status == FrameDecryptorInterface::Status::kRecoverable)); |
Benjamin Wright | 52426ed | 2019-03-01 11:01:59 -0800 | [diff] [blame] | 700 | } |
| 701 | |
Benjamin Wright | a556448 | 2019-04-03 10:44:18 -0700 | [diff] [blame] | 702 | void RtpVideoStreamReceiver::SetFrameDecryptor( |
| 703 | rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor) { |
| 704 | RTC_DCHECK_RUN_ON(&network_tc_); |
| 705 | if (buffered_frame_decryptor_ == nullptr) { |
| 706 | buffered_frame_decryptor_ = |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 707 | std::make_unique<BufferedFrameDecryptor>(this, this); |
Benjamin Wright | a556448 | 2019-04-03 10:44:18 -0700 | [diff] [blame] | 708 | } |
| 709 | buffered_frame_decryptor_->SetFrameDecryptor(std::move(frame_decryptor)); |
| 710 | } |
| 711 | |
Tommi | 81de14f | 2018-03-25 22:19:25 +0200 | [diff] [blame] | 712 | void RtpVideoStreamReceiver::UpdateRtt(int64_t max_rtt_ms) { |
tommi | f284b7f | 2017-02-27 01:59:36 -0800 | [diff] [blame] | 713 | if (nack_module_) |
| 714 | nack_module_->UpdateRtt(max_rtt_ms); |
philipel | fd5a20f | 2016-11-15 00:57:57 -0800 | [diff] [blame] | 715 | } |
| 716 | |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 717 | absl::optional<int64_t> RtpVideoStreamReceiver::LastReceivedPacketMs() const { |
Danil Chapovalov | f7457e5 | 2019-09-20 17:57:15 +0200 | [diff] [blame] | 718 | return packet_buffer_.LastReceivedPacketMs(); |
philipel | 3184f8e | 2017-05-18 08:08:53 -0700 | [diff] [blame] | 719 | } |
| 720 | |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 721 | absl::optional<int64_t> RtpVideoStreamReceiver::LastReceivedKeyframePacketMs() |
nisse | b1f2ff9 | 2017-06-09 04:01:55 -0700 | [diff] [blame] | 722 | const { |
Danil Chapovalov | f7457e5 | 2019-09-20 17:57:15 +0200 | [diff] [blame] | 723 | return packet_buffer_.LastReceivedKeyframePacketMs(); |
philipel | 3184f8e | 2017-05-18 08:08:53 -0700 | [diff] [blame] | 724 | } |
| 725 | |
eladalon | c0d481a | 2017-08-02 07:39:07 -0700 | [diff] [blame] | 726 | void RtpVideoStreamReceiver::AddSecondarySink(RtpPacketSinkInterface* sink) { |
Sebastian Jansson | b55015e | 2019-04-09 13:44:04 +0200 | [diff] [blame] | 727 | RTC_DCHECK_RUN_ON(&worker_task_checker_); |
Steve Anton | bd631a0 | 2019-03-28 10:51:27 -0700 | [diff] [blame] | 728 | RTC_DCHECK(!absl::c_linear_search(secondary_sinks_, sink)); |
eladalon | c0d481a | 2017-08-02 07:39:07 -0700 | [diff] [blame] | 729 | secondary_sinks_.push_back(sink); |
| 730 | } |
| 731 | |
| 732 | void RtpVideoStreamReceiver::RemoveSecondarySink( |
| 733 | const RtpPacketSinkInterface* sink) { |
Sebastian Jansson | b55015e | 2019-04-09 13:44:04 +0200 | [diff] [blame] | 734 | RTC_DCHECK_RUN_ON(&worker_task_checker_); |
Steve Anton | bd631a0 | 2019-03-28 10:51:27 -0700 | [diff] [blame] | 735 | auto it = absl::c_find(secondary_sinks_, sink); |
eladalon | c0d481a | 2017-08-02 07:39:07 -0700 | [diff] [blame] | 736 | if (it == secondary_sinks_.end()) { |
| 737 | // We might be rolling-back a call whose setup failed mid-way. In such a |
| 738 | // case, it's simpler to remove "everything" rather than remember what |
| 739 | // has already been added. |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 740 | RTC_LOG(LS_WARNING) << "Removal of unknown sink."; |
eladalon | c0d481a | 2017-08-02 07:39:07 -0700 | [diff] [blame] | 741 | return; |
| 742 | } |
| 743 | secondary_sinks_.erase(it); |
| 744 | } |
| 745 | |
Niels Möller | 2ff1f2a | 2018-08-09 16:16:34 +0200 | [diff] [blame] | 746 | void RtpVideoStreamReceiver::ReceivePacket(const RtpPacketReceived& packet) { |
| 747 | if (packet.payload_size() == 0) { |
Niels Möller | 0b92678 | 2018-08-21 17:49:24 +0200 | [diff] [blame] | 748 | // Padding or keep-alive packet. |
Niels Möller | 2ff1f2a | 2018-08-09 16:16:34 +0200 | [diff] [blame] | 749 | // TODO(nisse): Could drop empty packets earlier, but need to figure out how |
| 750 | // they should be counted in stats. |
Niels Möller | 0b92678 | 2018-08-21 17:49:24 +0200 | [diff] [blame] | 751 | NotifyReceiverOfEmptyPacket(packet.SequenceNumber()); |
nisse | 30e8931 | 2017-05-29 08:16:37 -0700 | [diff] [blame] | 752 | return; |
stefan@webrtc.org | 7bb8f02 | 2013-09-06 13:40:11 +0000 | [diff] [blame] | 753 | } |
Niels Möller | 2ff1f2a | 2018-08-09 16:16:34 +0200 | [diff] [blame] | 754 | if (packet.PayloadType() == config_.rtp.red_payload_type) { |
Niels Möller | 1f3206c | 2018-09-14 08:26:32 +0200 | [diff] [blame] | 755 | ParseAndHandleEncapsulatingHeader(packet); |
Niels Möller | 2ff1f2a | 2018-08-09 16:16:34 +0200 | [diff] [blame] | 756 | return; |
wu@webrtc.org | 822fbd8 | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 757 | } |
Niels Möller | 2ff1f2a | 2018-08-09 16:16:34 +0200 | [diff] [blame] | 758 | |
Mirta Dvornicic | fe68daa | 2019-05-23 13:21:12 +0200 | [diff] [blame] | 759 | const auto type_it = payload_type_map_.find(packet.PayloadType()); |
| 760 | if (type_it == payload_type_map_.end()) { |
Niels Möller | 2ff1f2a | 2018-08-09 16:16:34 +0200 | [diff] [blame] | 761 | return; |
| 762 | } |
Danil Chapovalov | cebdbf6 | 2019-12-13 16:08:18 +0100 | [diff] [blame] | 763 | absl::optional<VideoRtpDepacketizer::ParsedRtpPayload> parsed_payload = |
| 764 | type_it->second->Parse(packet.PayloadBuffer()); |
| 765 | if (parsed_payload == absl::nullopt) { |
Niels Möller | 2ff1f2a | 2018-08-09 16:16:34 +0200 | [diff] [blame] | 766 | RTC_LOG(LS_WARNING) << "Failed parsing payload."; |
| 767 | return; |
| 768 | } |
| 769 | |
Danil Chapovalov | cebdbf6 | 2019-12-13 16:08:18 +0100 | [diff] [blame] | 770 | OnReceivedPayloadData(std::move(parsed_payload->video_payload), packet, |
| 771 | parsed_payload->video_header); |
stefan@webrtc.org | 7bb8f02 | 2013-09-06 13:40:11 +0000 | [diff] [blame] | 772 | } |
| 773 | |
nisse | b1f2ff9 | 2017-06-09 04:01:55 -0700 | [diff] [blame] | 774 | void RtpVideoStreamReceiver::ParseAndHandleEncapsulatingHeader( |
Niels Möller | 1f3206c | 2018-09-14 08:26:32 +0200 | [diff] [blame] | 775 | const RtpPacketReceived& packet) { |
Sebastian Jansson | b55015e | 2019-04-09 13:44:04 +0200 | [diff] [blame] | 776 | RTC_DCHECK_RUN_ON(&worker_task_checker_); |
Niels Möller | 1f3206c | 2018-09-14 08:26:32 +0200 | [diff] [blame] | 777 | if (packet.PayloadType() == config_.rtp.red_payload_type && |
| 778 | packet.payload_size() > 0) { |
| 779 | if (packet.payload()[0] == config_.rtp.ulpfec_payload_type) { |
Peter Boström | 0b25072 | 2016-04-22 18:23:15 +0200 | [diff] [blame] | 780 | // Notify video_receiver about received FEC packets to avoid NACKing these |
| 781 | // packets. |
Niels Möller | 1f3206c | 2018-09-14 08:26:32 +0200 | [diff] [blame] | 782 | NotifyReceiverOfEmptyPacket(packet.SequenceNumber()); |
asapersson@webrtc.org | 37c0559 | 2015-01-28 13:58:27 +0000 | [diff] [blame] | 783 | } |
Danil Chapovalov | 04fd215 | 2019-09-20 11:40:12 +0200 | [diff] [blame] | 784 | if (!ulpfec_receiver_->AddReceivedRedPacket( |
| 785 | packet, config_.rtp.ulpfec_payload_type)) { |
nisse | 30e8931 | 2017-05-29 08:16:37 -0700 | [diff] [blame] | 786 | return; |
stefan@webrtc.org | 7bb8f02 | 2013-09-06 13:40:11 +0000 | [diff] [blame] | 787 | } |
nisse | 30e8931 | 2017-05-29 08:16:37 -0700 | [diff] [blame] | 788 | ulpfec_receiver_->ProcessReceivedFec(); |
stefan@webrtc.org | 7bb8f02 | 2013-09-06 13:40:11 +0000 | [diff] [blame] | 789 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 790 | } |
| 791 | |
Niels Möller | bc01047 | 2018-03-23 13:22:29 +0100 | [diff] [blame] | 792 | // In the case of a video stream without picture ids and no rtx the |
| 793 | // RtpFrameReferenceFinder will need to know about padding to |
| 794 | // correctly calculate frame references. |
| 795 | void RtpVideoStreamReceiver::NotifyReceiverOfEmptyPacket(uint16_t seq_num) { |
philipel | 7acc4a4 | 2019-09-26 11:25:52 +0200 | [diff] [blame] | 796 | { |
| 797 | rtc::CritScope lock(&reference_finder_lock_); |
| 798 | reference_finder_->PaddingReceived(seq_num); |
| 799 | } |
Danil Chapovalov | ce1ffcd | 2019-10-22 17:12:42 +0200 | [diff] [blame] | 800 | OnInsertedPacket(packet_buffer_.InsertPadding(seq_num)); |
Niels Möller | bc01047 | 2018-03-23 13:22:29 +0100 | [diff] [blame] | 801 | if (nack_module_) { |
Ying Wang | b32bb95 | 2018-10-31 10:12:27 +0100 | [diff] [blame] | 802 | nack_module_->OnReceivedPacket(seq_num, /* is_keyframe = */ false, |
| 803 | /* is _recovered = */ false); |
asapersson@webrtc.org | 37c0559 | 2015-01-28 13:58:27 +0000 | [diff] [blame] | 804 | } |
Elad Alon | 7d6a4c0 | 2019-02-25 13:00:51 +0100 | [diff] [blame] | 805 | if (loss_notification_controller_) { |
Elad Alon | ca2c430 | 2019-05-27 22:43:10 +0200 | [diff] [blame] | 806 | // TODO(bugs.webrtc.org/10336): Handle empty packets. |
Elad Alon | 7d6a4c0 | 2019-02-25 13:00:51 +0100 | [diff] [blame] | 807 | RTC_LOG(LS_WARNING) |
| 808 | << "LossNotificationController does not expect empty packets."; |
| 809 | } |
asapersson@webrtc.org | 37c0559 | 2015-01-28 13:58:27 +0000 | [diff] [blame] | 810 | } |
| 811 | |
nisse | b1f2ff9 | 2017-06-09 04:01:55 -0700 | [diff] [blame] | 812 | bool RtpVideoStreamReceiver::DeliverRtcp(const uint8_t* rtcp_packet, |
| 813 | size_t rtcp_packet_length) { |
Sebastian Jansson | b55015e | 2019-04-09 13:44:04 +0200 | [diff] [blame] | 814 | RTC_DCHECK_RUN_ON(&worker_task_checker_); |
eladalon | 8b07305 | 2017-08-25 00:49:08 -0700 | [diff] [blame] | 815 | |
| 816 | if (!receiving_) { |
| 817 | return false; |
Peter Boström | 4fa7eca | 2016-03-02 15:05:53 +0100 | [diff] [blame] | 818 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 819 | |
Per | 83d0910 | 2016-04-15 14:59:13 +0200 | [diff] [blame] | 820 | rtp_rtcp_->IncomingRtcpPacket(rtcp_packet, rtcp_packet_length); |
wu@webrtc.org | cd70119 | 2014-04-24 22:10:24 +0000 | [diff] [blame] | 821 | |
pkasting@chromium.org | 16825b1 | 2015-01-12 21:51:21 +0000 | [diff] [blame] | 822 | int64_t rtt = 0; |
Niels Möller | 2ff1f2a | 2018-08-09 16:16:34 +0200 | [diff] [blame] | 823 | rtp_rtcp_->RTT(config_.rtp.remote_ssrc, &rtt, nullptr, nullptr, nullptr); |
minyue@webrtc.org | 2c0cdbc | 2014-10-09 10:52:43 +0000 | [diff] [blame] | 824 | if (rtt == 0) { |
| 825 | // Waiting for valid rtt. |
Peter Boström | d1d66ba | 2016-02-08 14:07:14 +0100 | [diff] [blame] | 826 | return true; |
minyue@webrtc.org | 2c0cdbc | 2014-10-09 10:52:43 +0000 | [diff] [blame] | 827 | } |
| 828 | uint32_t ntp_secs = 0; |
| 829 | uint32_t ntp_frac = 0; |
| 830 | uint32_t rtp_timestamp = 0; |
Ilya Nikolaevskiy | 7172ea1 | 2017-10-30 11:17:34 +0100 | [diff] [blame] | 831 | uint32_t recieved_ntp_secs = 0; |
| 832 | uint32_t recieved_ntp_frac = 0; |
| 833 | if (rtp_rtcp_->RemoteNTP(&ntp_secs, &ntp_frac, &recieved_ntp_secs, |
| 834 | &recieved_ntp_frac, &rtp_timestamp) != 0) { |
minyue@webrtc.org | 2c0cdbc | 2014-10-09 10:52:43 +0000 | [diff] [blame] | 835 | // Waiting for RTCP. |
Peter Boström | d1d66ba | 2016-02-08 14:07:14 +0100 | [diff] [blame] | 836 | return true; |
minyue@webrtc.org | 2c0cdbc | 2014-10-09 10:52:43 +0000 | [diff] [blame] | 837 | } |
Ilya Nikolaevskiy | 7172ea1 | 2017-10-30 11:17:34 +0100 | [diff] [blame] | 838 | NtpTime recieved_ntp(recieved_ntp_secs, recieved_ntp_frac); |
| 839 | int64_t time_since_recieved = |
| 840 | clock_->CurrentNtpInMilliseconds() - recieved_ntp.ToMs(); |
| 841 | // Don't use old SRs to estimate time. |
| 842 | if (time_since_recieved <= 1) { |
| 843 | ntp_estimator_.UpdateRtcpTimestamp(rtt, ntp_secs, ntp_frac, rtp_timestamp); |
| 844 | } |
wu@webrtc.org | cd70119 | 2014-04-24 22:10:24 +0000 | [diff] [blame] | 845 | |
Peter Boström | d1d66ba | 2016-02-08 14:07:14 +0100 | [diff] [blame] | 846 | return true; |
wu@webrtc.org | cd70119 | 2014-04-24 22:10:24 +0000 | [diff] [blame] | 847 | } |
| 848 | |
philipel | d4fac69 | 2017-09-04 07:03:46 -0700 | [diff] [blame] | 849 | void RtpVideoStreamReceiver::FrameContinuous(int64_t picture_id) { |
tommi | f284b7f | 2017-02-27 01:59:36 -0800 | [diff] [blame] | 850 | if (!nack_module_) |
| 851 | return; |
| 852 | |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 853 | int seq_num = -1; |
| 854 | { |
| 855 | rtc::CritScope lock(&last_seq_num_cs_); |
| 856 | auto seq_num_it = last_seq_num_for_pic_id_.find(picture_id); |
| 857 | if (seq_num_it != last_seq_num_for_pic_id_.end()) |
| 858 | seq_num = seq_num_it->second; |
philipel | fd5a20f | 2016-11-15 00:57:57 -0800 | [diff] [blame] | 859 | } |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 860 | if (seq_num != -1) |
| 861 | nack_module_->ClearUpTo(seq_num); |
philipel | fd5a20f | 2016-11-15 00:57:57 -0800 | [diff] [blame] | 862 | } |
| 863 | |
philipel | d4fac69 | 2017-09-04 07:03:46 -0700 | [diff] [blame] | 864 | void RtpVideoStreamReceiver::FrameDecoded(int64_t picture_id) { |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 865 | int seq_num = -1; |
| 866 | { |
| 867 | rtc::CritScope lock(&last_seq_num_cs_); |
| 868 | auto seq_num_it = last_seq_num_for_pic_id_.find(picture_id); |
| 869 | if (seq_num_it != last_seq_num_for_pic_id_.end()) { |
| 870 | seq_num = seq_num_it->second; |
| 871 | last_seq_num_for_pic_id_.erase(last_seq_num_for_pic_id_.begin(), |
| 872 | ++seq_num_it); |
philipel | fd5a20f | 2016-11-15 00:57:57 -0800 | [diff] [blame] | 873 | } |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 874 | } |
| 875 | if (seq_num != -1) { |
Danil Chapovalov | f7457e5 | 2019-09-20 17:57:15 +0200 | [diff] [blame] | 876 | packet_buffer_.ClearTo(seq_num); |
philipel | 7acc4a4 | 2019-09-26 11:25:52 +0200 | [diff] [blame] | 877 | rtc::CritScope lock(&reference_finder_lock_); |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 878 | reference_finder_->ClearTo(seq_num); |
philipel | fd5a20f | 2016-11-15 00:57:57 -0800 | [diff] [blame] | 879 | } |
| 880 | } |
| 881 | |
nisse | b1f2ff9 | 2017-06-09 04:01:55 -0700 | [diff] [blame] | 882 | void RtpVideoStreamReceiver::SignalNetworkState(NetworkState state) { |
mflodman | dc7d0d2 | 2016-05-06 05:32:22 -0700 | [diff] [blame] | 883 | rtp_rtcp_->SetRTCPStatus(state == kNetworkUp ? config_.rtp.rtcp_mode |
| 884 | : RtcpMode::kOff); |
| 885 | } |
| 886 | |
nisse | b1f2ff9 | 2017-06-09 04:01:55 -0700 | [diff] [blame] | 887 | void RtpVideoStreamReceiver::StartReceive() { |
Sebastian Jansson | b55015e | 2019-04-09 13:44:04 +0200 | [diff] [blame] | 888 | RTC_DCHECK_RUN_ON(&worker_task_checker_); |
mflodman@webrtc.org | ad4ee36 | 2011-11-28 22:39:24 +0000 | [diff] [blame] | 889 | receiving_ = true; |
| 890 | } |
| 891 | |
nisse | b1f2ff9 | 2017-06-09 04:01:55 -0700 | [diff] [blame] | 892 | void RtpVideoStreamReceiver::StopReceive() { |
Sebastian Jansson | b55015e | 2019-04-09 13:44:04 +0200 | [diff] [blame] | 893 | RTC_DCHECK_RUN_ON(&worker_task_checker_); |
mflodman@webrtc.org | ad4ee36 | 2011-11-28 22:39:24 +0000 | [diff] [blame] | 894 | receiving_ = false; |
| 895 | } |
| 896 | |
nisse | b1f2ff9 | 2017-06-09 04:01:55 -0700 | [diff] [blame] | 897 | void RtpVideoStreamReceiver::UpdateHistograms() { |
brandtr | d55c3f6 | 2016-10-31 04:51:33 -0700 | [diff] [blame] | 898 | FecPacketCounter counter = ulpfec_receiver_->GetPacketCounter(); |
asapersson | 0c43f77 | 2016-11-30 01:42:26 -0800 | [diff] [blame] | 899 | if (counter.first_packet_time_ms == -1) |
| 900 | return; |
| 901 | |
| 902 | int64_t elapsed_sec = |
| 903 | (clock_->TimeInMilliseconds() - counter.first_packet_time_ms) / 1000; |
| 904 | if (elapsed_sec < metrics::kMinRunTimeInSeconds) |
| 905 | return; |
| 906 | |
mflodman | dc7d0d2 | 2016-05-06 05:32:22 -0700 | [diff] [blame] | 907 | if (counter.num_packets > 0) { |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 908 | RTC_HISTOGRAM_PERCENTAGE( |
mflodman | dc7d0d2 | 2016-05-06 05:32:22 -0700 | [diff] [blame] | 909 | "WebRTC.Video.ReceivedFecPacketsInPercent", |
| 910 | static_cast<int>(counter.num_fec_packets * 100 / counter.num_packets)); |
| 911 | } |
| 912 | if (counter.num_fec_packets > 0) { |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 913 | RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.RecoveredMediaPacketsInPercentOfFec", |
| 914 | static_cast<int>(counter.num_recovered_packets * |
| 915 | 100 / counter.num_fec_packets)); |
mflodman | dc7d0d2 | 2016-05-06 05:32:22 -0700 | [diff] [blame] | 916 | } |
Niels Möller | caef51e | 2019-08-27 09:19:49 +0200 | [diff] [blame] | 917 | if (config_.rtp.ulpfec_payload_type != -1) { |
| 918 | RTC_HISTOGRAM_COUNTS_10000( |
| 919 | "WebRTC.Video.FecBitrateReceivedInKbps", |
| 920 | static_cast<int>(counter.num_bytes * 8 / elapsed_sec / 1000)); |
| 921 | } |
mflodman | dc7d0d2 | 2016-05-06 05:32:22 -0700 | [diff] [blame] | 922 | } |
| 923 | |
nisse | b1f2ff9 | 2017-06-09 04:01:55 -0700 | [diff] [blame] | 924 | void RtpVideoStreamReceiver::InsertSpsPpsIntoTracker(uint8_t payload_type) { |
philipel | 022b54e | 2016-12-20 04:15:59 -0800 | [diff] [blame] | 925 | auto codec_params_it = pt_codec_params_.find(payload_type); |
| 926 | if (codec_params_it == pt_codec_params_.end()) |
| 927 | return; |
| 928 | |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 929 | RTC_LOG(LS_INFO) << "Found out of band supplied codec parameters for" |
| 930 | << " payload type: " << static_cast<int>(payload_type); |
philipel | 022b54e | 2016-12-20 04:15:59 -0800 | [diff] [blame] | 931 | |
| 932 | H264SpropParameterSets sprop_decoder; |
| 933 | auto sprop_base64_it = |
| 934 | codec_params_it->second.find(cricket::kH264FmtpSpropParameterSets); |
| 935 | |
| 936 | if (sprop_base64_it == codec_params_it->second.end()) |
| 937 | return; |
| 938 | |
johan | 62d02c3 | 2017-01-24 04:38:27 -0800 | [diff] [blame] | 939 | if (!sprop_decoder.DecodeSprop(sprop_base64_it->second.c_str())) |
philipel | 022b54e | 2016-12-20 04:15:59 -0800 | [diff] [blame] | 940 | return; |
| 941 | |
johan | d2b092f | 2017-01-24 02:38:17 -0800 | [diff] [blame] | 942 | tracker_.InsertSpsPpsNalus(sprop_decoder.sps_nalu(), |
| 943 | sprop_decoder.pps_nalu()); |
philipel | 022b54e | 2016-12-20 04:15:59 -0800 | [diff] [blame] | 944 | } |
| 945 | |
mflodman@webrtc.org | ad4ee36 | 2011-11-28 22:39:24 +0000 | [diff] [blame] | 946 | } // namespace webrtc |