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