ivica | 7f6a6fc | 2015-09-08 02:40:29 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. |
| 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 | |
Jonas Olsson | a4d8737 | 2019-07-05 19:08:33 +0200 | [diff] [blame] | 11 | #include "test/layer_filtering_transport.h" |
| 12 | |
Yves Gerey | 3e70781 | 2018-11-28 16:47:49 +0100 | [diff] [blame] | 13 | #include <string.h> |
Jonas Olsson | a4d8737 | 2019-07-05 19:08:33 +0200 | [diff] [blame] | 14 | |
Yves Gerey | 3e70781 | 2018-11-28 16:47:49 +0100 | [diff] [blame] | 15 | #include <algorithm> |
kwiberg | bfefb03 | 2016-05-01 14:53:46 -0700 | [diff] [blame] | 16 | #include <memory> |
Yves Gerey | 3e70781 | 2018-11-28 16:47:49 +0100 | [diff] [blame] | 17 | #include <utility> |
kwiberg | bfefb03 | 2016-05-01 14:53:46 -0700 | [diff] [blame] | 18 | |
Yves Gerey | 3e70781 | 2018-11-28 16:47:49 +0100 | [diff] [blame] | 19 | #include "api/rtp_headers.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 20 | #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" |
Danil Chapovalov | a3ecb7a | 2019-12-09 10:24:47 +0100 | [diff] [blame] | 21 | #include "modules/rtp_rtcp/source/create_video_rtp_depacketizer.h" |
Yves Gerey | 3e70781 | 2018-11-28 16:47:49 +0100 | [diff] [blame] | 22 | #include "modules/rtp_rtcp/source/rtp_video_header.h" |
Danil Chapovalov | a3ecb7a | 2019-12-09 10:24:47 +0100 | [diff] [blame] | 23 | #include "modules/rtp_rtcp/source/video_rtp_depacketizer.h" |
Yves Gerey | 3e70781 | 2018-11-28 16:47:49 +0100 | [diff] [blame] | 24 | #include "modules/video_coding/codecs/interface/common_constants.h" |
| 25 | #include "modules/video_coding/codecs/vp8/include/vp8_globals.h" |
| 26 | #include "modules/video_coding/codecs/vp9/include/vp9_globals.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 27 | #include "rtc_base/checks.h" |
ivica | 7f6a6fc | 2015-09-08 02:40:29 -0700 | [diff] [blame] | 28 | |
| 29 | namespace webrtc { |
| 30 | namespace test { |
| 31 | |
| 32 | LayerFilteringTransport::LayerFilteringTransport( |
Danil Chapovalov | 85a1000 | 2019-10-21 15:00:53 +0200 | [diff] [blame] | 33 | TaskQueueBase* task_queue, |
Artem Titov | 46c4e60 | 2018-08-17 14:26:54 +0200 | [diff] [blame] | 34 | std::unique_ptr<SimulatedPacketReceiverInterface> pipe, |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 35 | Call* send_call, |
| 36 | uint8_t vp8_video_payload_type, |
| 37 | uint8_t vp9_video_payload_type, |
| 38 | int selected_tl, |
| 39 | int selected_sl, |
Sebastian Jansson | 0940811 | 2018-04-24 14:41:22 +0200 | [diff] [blame] | 40 | const std::map<uint8_t, MediaType>& payload_type_map, |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 41 | uint32_t ssrc_to_filter_min, |
| 42 | uint32_t ssrc_to_filter_max) |
Sebastian Jansson | 0940811 | 2018-04-24 14:41:22 +0200 | [diff] [blame] | 43 | : DirectTransport(task_queue, std::move(pipe), send_call, payload_type_map), |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 44 | vp8_video_payload_type_(vp8_video_payload_type), |
| 45 | vp9_video_payload_type_(vp9_video_payload_type), |
Danil Chapovalov | a3ecb7a | 2019-12-09 10:24:47 +0100 | [diff] [blame] | 46 | vp8_depacketizer_(CreateVideoRtpDepacketizer(kVideoCodecVP8)), |
| 47 | vp9_depacketizer_(CreateVideoRtpDepacketizer(kVideoCodecVP9)), |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 48 | selected_tl_(selected_tl), |
| 49 | selected_sl_(selected_sl), |
| 50 | discarded_last_packet_(false), |
| 51 | ssrc_to_filter_min_(ssrc_to_filter_min), |
| 52 | ssrc_to_filter_max_(ssrc_to_filter_max) {} |
| 53 | |
| 54 | LayerFilteringTransport::LayerFilteringTransport( |
Danil Chapovalov | 85a1000 | 2019-10-21 15:00:53 +0200 | [diff] [blame] | 55 | TaskQueueBase* task_queue, |
Artem Titov | 46c4e60 | 2018-08-17 14:26:54 +0200 | [diff] [blame] | 56 | std::unique_ptr<SimulatedPacketReceiverInterface> pipe, |
Christoffer Rodbro | b4bb4eb | 2017-11-13 13:03:52 +0100 | [diff] [blame] | 57 | Call* send_call, |
| 58 | uint8_t vp8_video_payload_type, |
| 59 | uint8_t vp9_video_payload_type, |
| 60 | int selected_tl, |
Sebastian Jansson | 0940811 | 2018-04-24 14:41:22 +0200 | [diff] [blame] | 61 | int selected_sl, |
| 62 | const std::map<uint8_t, MediaType>& payload_type_map) |
Danil Chapovalov | a3ecb7a | 2019-12-09 10:24:47 +0100 | [diff] [blame] | 63 | : LayerFilteringTransport(task_queue, |
| 64 | std::move(pipe), |
| 65 | send_call, |
| 66 | vp8_video_payload_type, |
| 67 | vp9_video_payload_type, |
| 68 | selected_tl, |
| 69 | selected_sl, |
| 70 | payload_type_map, |
| 71 | /*ssrc_to_filter_min=*/0, |
| 72 | /*ssrc_to_filter_max=*/0xFFFFFFFF) {} |
Christoffer Rodbro | b4bb4eb | 2017-11-13 13:03:52 +0100 | [diff] [blame] | 73 | |
sprang | ce4aef1 | 2015-11-02 07:23:20 -0800 | [diff] [blame] | 74 | bool LayerFilteringTransport::DiscardedLastPacket() const { |
| 75 | return discarded_last_packet_; |
ivica | e78e2c7 | 2015-10-07 23:44:29 -0700 | [diff] [blame] | 76 | } |
ivica | 7f6a6fc | 2015-09-08 02:40:29 -0700 | [diff] [blame] | 77 | |
stefan | 1d8a506 | 2015-10-02 03:39:33 -0700 | [diff] [blame] | 78 | bool LayerFilteringTransport::SendRtp(const uint8_t* packet, |
| 79 | size_t length, |
| 80 | const PacketOptions& options) { |
sprang | ce4aef1 | 2015-11-02 07:23:20 -0800 | [diff] [blame] | 81 | if (selected_tl_ == -1 && selected_sl_ == -1) { |
ivica | 7f6a6fc | 2015-09-08 02:40:29 -0700 | [diff] [blame] | 82 | // Nothing to change, forward the packet immediately. |
stefan | 1d8a506 | 2015-10-02 03:39:33 -0700 | [diff] [blame] | 83 | return test::DirectTransport::SendRtp(packet, length, options); |
ivica | 7f6a6fc | 2015-09-08 02:40:29 -0700 | [diff] [blame] | 84 | } |
| 85 | |
Danil Chapovalov | a3ecb7a | 2019-12-09 10:24:47 +0100 | [diff] [blame] | 86 | RtpPacket rtp_packet; |
| 87 | rtp_packet.Parse(packet, length); |
sprang | ce4aef1 | 2015-11-02 07:23:20 -0800 | [diff] [blame] | 88 | |
Danil Chapovalov | a3ecb7a | 2019-12-09 10:24:47 +0100 | [diff] [blame] | 89 | if (rtp_packet.Ssrc() < ssrc_to_filter_min_ || |
| 90 | rtp_packet.Ssrc() > ssrc_to_filter_max_) { |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 91 | // Nothing to change, forward the packet immediately. |
| 92 | return test::DirectTransport::SendRtp(packet, length, options); |
| 93 | } |
| 94 | |
Danil Chapovalov | a3ecb7a | 2019-12-09 10:24:47 +0100 | [diff] [blame] | 95 | if (rtp_packet.PayloadType() == vp8_video_payload_type_ || |
| 96 | rtp_packet.PayloadType() == vp9_video_payload_type_) { |
| 97 | const bool is_vp8 = rtp_packet.PayloadType() == vp8_video_payload_type_; |
| 98 | VideoRtpDepacketizer& depacketizer = |
| 99 | is_vp8 ? *vp8_depacketizer_ : *vp9_depacketizer_; |
| 100 | if (auto parsed_payload = depacketizer.Parse(rtp_packet.PayloadBuffer())) { |
philipel | 29d8846 | 2018-08-08 14:26:00 +0200 | [diff] [blame] | 101 | int temporal_idx; |
| 102 | int spatial_idx; |
| 103 | bool non_ref_for_inter_layer_pred; |
| 104 | bool end_of_frame; |
| 105 | |
| 106 | if (is_vp8) { |
Philip Eliasson | d52a1a6 | 2018-09-07 13:03:55 +0000 | [diff] [blame] | 107 | temporal_idx = absl::get<RTPVideoHeaderVP8>( |
Danil Chapovalov | a3ecb7a | 2019-12-09 10:24:47 +0100 | [diff] [blame] | 108 | parsed_payload->video_header.video_type_header) |
Philip Eliasson | d52a1a6 | 2018-09-07 13:03:55 +0000 | [diff] [blame] | 109 | .temporalIdx; |
philipel | 29d8846 | 2018-08-08 14:26:00 +0200 | [diff] [blame] | 110 | spatial_idx = kNoSpatialIdx; |
“Michael | 23c5a99 | 2018-06-21 11:07:21 -0500 | [diff] [blame] | 111 | num_active_spatial_layers_ = 1; |
philipel | 29d8846 | 2018-08-08 14:26:00 +0200 | [diff] [blame] | 112 | non_ref_for_inter_layer_pred = false; |
| 113 | end_of_frame = true; |
| 114 | } else { |
| 115 | const auto& vp9_header = absl::get<RTPVideoHeaderVP9>( |
Danil Chapovalov | a3ecb7a | 2019-12-09 10:24:47 +0100 | [diff] [blame] | 116 | parsed_payload->video_header.video_type_header); |
philipel | 29d8846 | 2018-08-08 14:26:00 +0200 | [diff] [blame] | 117 | temporal_idx = vp9_header.temporal_idx; |
| 118 | spatial_idx = vp9_header.spatial_idx; |
| 119 | non_ref_for_inter_layer_pred = vp9_header.non_ref_for_inter_layer_pred; |
| 120 | end_of_frame = vp9_header.end_of_frame; |
Sergey Silkin | 941fd43 | 2018-12-20 10:19:51 +0100 | [diff] [blame] | 121 | if (vp9_header.ss_data_available) { |
| 122 | RTC_DCHECK(vp9_header.temporal_idx == kNoTemporalIdx || |
| 123 | vp9_header.temporal_idx == 0); |
| 124 | RTC_DCHECK(vp9_header.spatial_idx == kNoSpatialIdx || |
| 125 | vp9_header.spatial_idx == 0); |
philipel | 29d8846 | 2018-08-08 14:26:00 +0200 | [diff] [blame] | 126 | num_active_spatial_layers_ = vp9_header.num_spatial_layers; |
| 127 | } |
| 128 | } |
| 129 | |
| 130 | if (spatial_idx == kNoSpatialIdx) |
| 131 | num_active_spatial_layers_ = 1; |
| 132 | |
“Michael | 23c5a99 | 2018-06-21 11:07:21 -0500 | [diff] [blame] | 133 | RTC_CHECK_GT(num_active_spatial_layers_, 0); |
| 134 | |
| 135 | if (selected_sl_ >= 0 && |
| 136 | spatial_idx == |
| 137 | std::min(num_active_spatial_layers_ - 1, selected_sl_) && |
philipel | 29d8846 | 2018-08-08 14:26:00 +0200 | [diff] [blame] | 138 | end_of_frame) { |
ivica | 7f6a6fc | 2015-09-08 02:40:29 -0700 | [diff] [blame] | 139 | // This layer is now the last in the superframe. |
Danil Chapovalov | a3ecb7a | 2019-12-09 10:24:47 +0100 | [diff] [blame] | 140 | rtp_packet.SetMarker(true); |
Sergey Silkin | 5702736 | 2018-05-15 09:12:05 +0200 | [diff] [blame] | 141 | } else { |
| 142 | const bool higher_temporal_layer = |
| 143 | (selected_tl_ >= 0 && temporal_idx != kNoTemporalIdx && |
| 144 | temporal_idx > selected_tl_); |
| 145 | |
| 146 | const bool higher_spatial_layer = |
| 147 | (selected_sl_ >= 0 && spatial_idx != kNoSpatialIdx && |
| 148 | spatial_idx > selected_sl_); |
| 149 | |
| 150 | // Filter out non-reference lower spatial layers since they are not |
| 151 | // needed for decoding of target spatial layer. |
| 152 | const bool lower_non_ref_spatial_layer = |
| 153 | (selected_sl_ >= 0 && spatial_idx != kNoSpatialIdx && |
“Michael | 23c5a99 | 2018-06-21 11:07:21 -0500 | [diff] [blame] | 154 | spatial_idx < |
| 155 | std::min(num_active_spatial_layers_ - 1, selected_sl_) && |
| 156 | non_ref_for_inter_layer_pred); |
Sergey Silkin | 5702736 | 2018-05-15 09:12:05 +0200 | [diff] [blame] | 157 | |
| 158 | if (higher_temporal_layer || higher_spatial_layer || |
| 159 | lower_non_ref_spatial_layer) { |
| 160 | // Truncate packet to a padding packet. |
Danil Chapovalov | a3ecb7a | 2019-12-09 10:24:47 +0100 | [diff] [blame] | 161 | rtp_packet.SetPayloadSize(0); |
| 162 | rtp_packet.SetPadding(1); |
| 163 | rtp_packet.SetMarker(false); |
Sergey Silkin | 5702736 | 2018-05-15 09:12:05 +0200 | [diff] [blame] | 164 | discarded_last_packet_ = true; |
Sergey Silkin | 5702736 | 2018-05-15 09:12:05 +0200 | [diff] [blame] | 165 | } |
ivica | 7f6a6fc | 2015-09-08 02:40:29 -0700 | [diff] [blame] | 166 | } |
| 167 | } else { |
| 168 | RTC_NOTREACHED() << "Parse error"; |
| 169 | } |
| 170 | } |
| 171 | |
Danil Chapovalov | a3ecb7a | 2019-12-09 10:24:47 +0100 | [diff] [blame] | 172 | return test::DirectTransport::SendRtp(rtp_packet.data(), rtp_packet.size(), |
| 173 | options); |
ivica | 7f6a6fc | 2015-09-08 02:40:29 -0700 | [diff] [blame] | 174 | } |
| 175 | |
| 176 | } // namespace test |
| 177 | } // namespace webrtc |