stefan@webrtc.org | 2ec5606 | 2014-07-31 14:59:24 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2014 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 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 11 | #include "modules/rtp_rtcp/source/rtp_format.h" |
stefan@webrtc.org | 2ec5606 | 2014-07-31 14:59:24 +0000 | [diff] [blame] | 12 | |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame^] | 13 | #include <memory> |
| 14 | |
Yves Gerey | 988cc08 | 2018-10-23 12:03:01 +0200 | [diff] [blame] | 15 | #include "absl/types/variant.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 16 | #include "modules/rtp_rtcp/source/rtp_format_h264.h" |
| 17 | #include "modules/rtp_rtcp/source/rtp_format_video_generic.h" |
| 18 | #include "modules/rtp_rtcp/source/rtp_format_vp8.h" |
| 19 | #include "modules/rtp_rtcp/source/rtp_format_vp9.h" |
Yves Gerey | 988cc08 | 2018-10-23 12:03:01 +0200 | [diff] [blame] | 20 | #include "modules/video_coding/codecs/h264/include/h264_globals.h" |
| 21 | #include "modules/video_coding/codecs/vp8/include/vp8_globals.h" |
| 22 | #include "modules/video_coding/codecs/vp9/include/vp9_globals.h" |
Danil Chapovalov | 376e114 | 2018-09-04 16:11:58 +0200 | [diff] [blame] | 23 | #include "rtc_base/checks.h" |
stefan@webrtc.org | 2ec5606 | 2014-07-31 14:59:24 +0000 | [diff] [blame] | 24 | |
| 25 | namespace webrtc { |
Danil Chapovalov | f7f8a1f | 2018-08-28 19:45:31 +0200 | [diff] [blame] | 26 | |
| 27 | std::unique_ptr<RtpPacketizer> RtpPacketizer::Create( |
Mirta Dvornicic | fe68daa | 2019-05-23 13:21:12 +0200 | [diff] [blame] | 28 | absl::optional<VideoCodecType> type, |
Danil Chapovalov | f7f8a1f | 2018-08-28 19:45:31 +0200 | [diff] [blame] | 29 | rtc::ArrayView<const uint8_t> payload, |
| 30 | PayloadSizeLimits limits, |
| 31 | // Codec-specific details. |
| 32 | const RTPVideoHeader& rtp_video_header, |
Niels Möller | 87e2d78 | 2019-03-07 10:18:23 +0100 | [diff] [blame] | 33 | VideoFrameType frame_type, |
Danil Chapovalov | f7f8a1f | 2018-08-28 19:45:31 +0200 | [diff] [blame] | 34 | const RTPFragmentationHeader* fragmentation) { |
Mirta Dvornicic | fe68daa | 2019-05-23 13:21:12 +0200 | [diff] [blame] | 35 | if (!type) { |
| 36 | // Use raw packetizer. |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame^] | 37 | return std::make_unique<RtpPacketizerGeneric>(payload, limits); |
Mirta Dvornicic | fe68daa | 2019-05-23 13:21:12 +0200 | [diff] [blame] | 38 | } |
| 39 | |
| 40 | switch (*type) { |
philipel | 7d745e5 | 2018-08-02 14:03:53 +0200 | [diff] [blame] | 41 | case kVideoCodecH264: { |
Danil Chapovalov | fd5fbd0 | 2018-09-12 10:23:15 +0200 | [diff] [blame] | 42 | RTC_CHECK(fragmentation); |
philipel | 7d745e5 | 2018-08-02 14:03:53 +0200 | [diff] [blame] | 43 | const auto& h264 = |
Danil Chapovalov | f7f8a1f | 2018-08-28 19:45:31 +0200 | [diff] [blame] | 44 | absl::get<RTPVideoHeaderH264>(rtp_video_header.video_type_header); |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame^] | 45 | return std::make_unique<RtpPacketizerH264>( |
Danil Chapovalov | fd5fbd0 | 2018-09-12 10:23:15 +0200 | [diff] [blame] | 46 | payload, limits, h264.packetization_mode, *fragmentation); |
philipel | 7d745e5 | 2018-08-02 14:03:53 +0200 | [diff] [blame] | 47 | } |
Danil Chapovalov | f7f8a1f | 2018-08-28 19:45:31 +0200 | [diff] [blame] | 48 | case kVideoCodecVP8: { |
| 49 | const auto& vp8 = |
| 50 | absl::get<RTPVideoHeaderVP8>(rtp_video_header.video_type_header); |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame^] | 51 | return std::make_unique<RtpPacketizerVp8>(payload, limits, vp8); |
Danil Chapovalov | f7f8a1f | 2018-08-28 19:45:31 +0200 | [diff] [blame] | 52 | } |
philipel | 29d8846 | 2018-08-08 14:26:00 +0200 | [diff] [blame] | 53 | case kVideoCodecVP9: { |
| 54 | const auto& vp9 = |
Danil Chapovalov | f7f8a1f | 2018-08-28 19:45:31 +0200 | [diff] [blame] | 55 | absl::get<RTPVideoHeaderVP9>(rtp_video_header.video_type_header); |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame^] | 56 | return std::make_unique<RtpPacketizerVp9>(payload, limits, vp9); |
philipel | 29d8846 | 2018-08-08 14:26:00 +0200 | [diff] [blame] | 57 | } |
Danil Chapovalov | f7f8a1f | 2018-08-28 19:45:31 +0200 | [diff] [blame] | 58 | default: { |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame^] | 59 | return std::make_unique<RtpPacketizerGeneric>( |
Danil Chapovalov | af8c036 | 2018-09-05 16:54:22 +0200 | [diff] [blame] | 60 | payload, limits, rtp_video_header, frame_type); |
Danil Chapovalov | f7f8a1f | 2018-08-28 19:45:31 +0200 | [diff] [blame] | 61 | } |
stefan@webrtc.org | 2ec5606 | 2014-07-31 14:59:24 +0000 | [diff] [blame] | 62 | } |
stefan@webrtc.org | 2ec5606 | 2014-07-31 14:59:24 +0000 | [diff] [blame] | 63 | } |
| 64 | |
Danil Chapovalov | fa5ec8d | 2018-09-07 10:57:26 +0200 | [diff] [blame] | 65 | std::vector<int> RtpPacketizer::SplitAboutEqually( |
| 66 | int payload_len, |
Danil Chapovalov | 376e114 | 2018-09-04 16:11:58 +0200 | [diff] [blame] | 67 | const PayloadSizeLimits& limits) { |
Danil Chapovalov | fa5ec8d | 2018-09-07 10:57:26 +0200 | [diff] [blame] | 68 | RTC_DCHECK_GT(payload_len, 0); |
| 69 | // First or last packet larger than normal are unsupported. |
| 70 | RTC_DCHECK_GE(limits.first_packet_reduction_len, 0); |
| 71 | RTC_DCHECK_GE(limits.last_packet_reduction_len, 0); |
Danil Chapovalov | 376e114 | 2018-09-04 16:11:58 +0200 | [diff] [blame] | 72 | |
Danil Chapovalov | fa5ec8d | 2018-09-07 10:57:26 +0200 | [diff] [blame] | 73 | std::vector<int> result; |
Danil Chapovalov | fcebe0e | 2018-10-12 17:51:22 +0200 | [diff] [blame] | 74 | if (limits.max_payload_len >= |
| 75 | limits.single_packet_reduction_len + payload_len) { |
| 76 | result.push_back(payload_len); |
| 77 | return result; |
| 78 | } |
Danil Chapovalov | fa5ec8d | 2018-09-07 10:57:26 +0200 | [diff] [blame] | 79 | if (limits.max_payload_len - limits.first_packet_reduction_len < 1 || |
| 80 | limits.max_payload_len - limits.last_packet_reduction_len < 1) { |
| 81 | // Capacity is not enough to put a single byte into one of the packets. |
| 82 | return result; |
| 83 | } |
Danil Chapovalov | bace3a4 | 2018-09-05 16:15:08 +0200 | [diff] [blame] | 84 | // First and last packet of the frame can be smaller. Pretend that it's |
| 85 | // the same size, but we must write more payload to it. |
| 86 | // Assume frame fits in single packet if packet has extra space for sum |
| 87 | // of first and last packets reductions. |
Danil Chapovalov | fa5ec8d | 2018-09-07 10:57:26 +0200 | [diff] [blame] | 88 | int total_bytes = payload_len + limits.first_packet_reduction_len + |
| 89 | limits.last_packet_reduction_len; |
Danil Chapovalov | 376e114 | 2018-09-04 16:11:58 +0200 | [diff] [blame] | 90 | // Integer divisions with rounding up. |
Danil Chapovalov | fa5ec8d | 2018-09-07 10:57:26 +0200 | [diff] [blame] | 91 | int num_packets_left = |
Danil Chapovalov | 376e114 | 2018-09-04 16:11:58 +0200 | [diff] [blame] | 92 | (total_bytes + limits.max_payload_len - 1) / limits.max_payload_len; |
Danil Chapovalov | fcebe0e | 2018-10-12 17:51:22 +0200 | [diff] [blame] | 93 | if (num_packets_left == 1) { |
| 94 | // Single packet is a special case handled above. |
| 95 | num_packets_left = 2; |
| 96 | } |
Danil Chapovalov | 376e114 | 2018-09-04 16:11:58 +0200 | [diff] [blame] | 97 | |
Danil Chapovalov | fa5ec8d | 2018-09-07 10:57:26 +0200 | [diff] [blame] | 98 | if (payload_len < num_packets_left) { |
| 99 | // Edge case where limits force to have more packets than there are payload |
| 100 | // bytes. This may happen when there is single byte of payload that can't be |
| 101 | // put into single packet if |
| 102 | // first_packet_reduction + last_packet_reduction >= max_payload_len. |
| 103 | return result; |
| 104 | } |
| 105 | |
| 106 | int bytes_per_packet = total_bytes / num_packets_left; |
| 107 | int num_larger_packets = total_bytes % num_packets_left; |
| 108 | int remaining_data = payload_len; |
| 109 | |
Danil Chapovalov | 376e114 | 2018-09-04 16:11:58 +0200 | [diff] [blame] | 110 | result.reserve(num_packets_left); |
Danil Chapovalov | bace3a4 | 2018-09-05 16:15:08 +0200 | [diff] [blame] | 111 | bool first_packet = true; |
Danil Chapovalov | 376e114 | 2018-09-04 16:11:58 +0200 | [diff] [blame] | 112 | while (remaining_data > 0) { |
| 113 | // Last num_larger_packets are 1 byte wider than the rest. Increase |
| 114 | // per-packet payload size when needed. |
| 115 | if (num_packets_left == num_larger_packets) |
| 116 | ++bytes_per_packet; |
Danil Chapovalov | fa5ec8d | 2018-09-07 10:57:26 +0200 | [diff] [blame] | 117 | int current_packet_bytes = bytes_per_packet; |
Danil Chapovalov | bace3a4 | 2018-09-05 16:15:08 +0200 | [diff] [blame] | 118 | if (first_packet) { |
| 119 | if (current_packet_bytes > limits.first_packet_reduction_len + 1) |
| 120 | current_packet_bytes -= limits.first_packet_reduction_len; |
| 121 | else |
| 122 | current_packet_bytes = 1; |
| 123 | } |
Danil Chapovalov | 376e114 | 2018-09-04 16:11:58 +0200 | [diff] [blame] | 124 | if (current_packet_bytes > remaining_data) { |
| 125 | current_packet_bytes = remaining_data; |
| 126 | } |
| 127 | // This is not the last packet in the whole payload, but there's no data |
| 128 | // left for the last packet. Leave at least one byte for the last packet. |
| 129 | if (num_packets_left == 2 && current_packet_bytes == remaining_data) { |
| 130 | --current_packet_bytes; |
| 131 | } |
Danil Chapovalov | 376e114 | 2018-09-04 16:11:58 +0200 | [diff] [blame] | 132 | result.push_back(current_packet_bytes); |
| 133 | |
| 134 | remaining_data -= current_packet_bytes; |
| 135 | --num_packets_left; |
Danil Chapovalov | bace3a4 | 2018-09-05 16:15:08 +0200 | [diff] [blame] | 136 | first_packet = false; |
Danil Chapovalov | 376e114 | 2018-09-04 16:11:58 +0200 | [diff] [blame] | 137 | } |
| 138 | |
| 139 | return result; |
| 140 | } |
| 141 | |
Mirta Dvornicic | fe68daa | 2019-05-23 13:21:12 +0200 | [diff] [blame] | 142 | RtpDepacketizer* RtpDepacketizer::Create(absl::optional<VideoCodecType> type) { |
| 143 | if (!type) { |
| 144 | // Use raw depacketizer. |
| 145 | return new RtpDepacketizerGeneric(/*generic_header_enabled=*/false); |
| 146 | } |
| 147 | |
| 148 | switch (*type) { |
Niels Möller | 520ca4e | 2018-06-04 11:14:38 +0200 | [diff] [blame] | 149 | case kVideoCodecH264: |
pbos@webrtc.org | 730d270 | 2014-09-29 08:00:22 +0000 | [diff] [blame] | 150 | return new RtpDepacketizerH264(); |
Niels Möller | 520ca4e | 2018-06-04 11:14:38 +0200 | [diff] [blame] | 151 | case kVideoCodecVP8: |
pbos@webrtc.org | 730d270 | 2014-09-29 08:00:22 +0000 | [diff] [blame] | 152 | return new RtpDepacketizerVp8(); |
Niels Möller | 520ca4e | 2018-06-04 11:14:38 +0200 | [diff] [blame] | 153 | case kVideoCodecVP9: |
asapersson | f38ea3c | 2015-07-28 04:02:54 -0700 | [diff] [blame] | 154 | return new RtpDepacketizerVp9(); |
Niels Moller | 1788dcb | 2018-08-09 06:18:57 +0000 | [diff] [blame] | 155 | default: |
Mirta Dvornicic | a24d934 | 2019-05-16 15:51:15 +0200 | [diff] [blame] | 156 | return new RtpDepacketizerGeneric(/*generic_header_enabled=*/true); |
stefan@webrtc.org | 2ec5606 | 2014-07-31 14:59:24 +0000 | [diff] [blame] | 157 | } |
stefan@webrtc.org | 2ec5606 | 2014-07-31 14:59:24 +0000 | [diff] [blame] | 158 | } |
Mirta Dvornicic | fe68daa | 2019-05-23 13:21:12 +0200 | [diff] [blame] | 159 | |
stefan@webrtc.org | 2ec5606 | 2014-07-31 14:59:24 +0000 | [diff] [blame] | 160 | } // namespace webrtc |