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
11 #include "modules/rtp_rtcp/source/rtp_format_h264.h"
12
13 #include <string.h>
14
15 #include <cstddef>
16 #include <cstdint>
17 #include <iterator>
18 #include <memory>
19 #include <utility>
20 #include <vector>
21
22 #include "absl/types/optional.h"
23 #include "absl/types/variant.h"
24 #include "common_video/h264/h264_common.h"
25 #include "common_video/h264/pps_parser.h"
26 #include "common_video/h264/sps_parser.h"
27 #include "common_video/h264/sps_vui_rewriter.h"
28 #include "modules/rtp_rtcp/source/byte_io.h"
29 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
30 #include "rtc_base/checks.h"
31 #include "rtc_base/logging.h"
32
33 namespace webrtc {
34 namespace {
35
36 static const size_t kNalHeaderSize = 1;
37 static const size_t kFuAHeaderSize = 2;
38 static const size_t kLengthFieldSize = 2;
39
40 } // namespace
41
RtpPacketizerH264(rtc::ArrayView<const uint8_t> payload,PayloadSizeLimits limits,H264PacketizationMode packetization_mode)42 RtpPacketizerH264::RtpPacketizerH264(rtc::ArrayView<const uint8_t> payload,
43 PayloadSizeLimits limits,
44 H264PacketizationMode packetization_mode)
45 : limits_(limits), num_packets_left_(0) {
46 // Guard against uninitialized memory in packetization_mode.
47 RTC_CHECK(packetization_mode == H264PacketizationMode::NonInterleaved ||
48 packetization_mode == H264PacketizationMode::SingleNalUnit);
49
50 for (const auto& nalu :
51 H264::FindNaluIndices(payload.data(), payload.size())) {
52 input_fragments_.push_back(
53 payload.subview(nalu.payload_start_offset, nalu.payload_size));
54 }
55
56 if (!GeneratePackets(packetization_mode)) {
57 // If failed to generate all the packets, discard already generated
58 // packets in case the caller would ignore return value and still try to
59 // call NextPacket().
60 num_packets_left_ = 0;
61 while (!packets_.empty()) {
62 packets_.pop();
63 }
64 }
65 }
66
67 RtpPacketizerH264::~RtpPacketizerH264() = default;
68
NumPackets() const69 size_t RtpPacketizerH264::NumPackets() const {
70 return num_packets_left_;
71 }
72
GeneratePackets(H264PacketizationMode packetization_mode)73 bool RtpPacketizerH264::GeneratePackets(
74 H264PacketizationMode packetization_mode) {
75 for (size_t i = 0; i < input_fragments_.size();) {
76 switch (packetization_mode) {
77 case H264PacketizationMode::SingleNalUnit:
78 if (!PacketizeSingleNalu(i))
79 return false;
80 ++i;
81 break;
82 case H264PacketizationMode::NonInterleaved:
83 int fragment_len = input_fragments_[i].size();
84 int single_packet_capacity = limits_.max_payload_len;
85 if (input_fragments_.size() == 1)
86 single_packet_capacity -= limits_.single_packet_reduction_len;
87 else if (i == 0)
88 single_packet_capacity -= limits_.first_packet_reduction_len;
89 else if (i + 1 == input_fragments_.size())
90 single_packet_capacity -= limits_.last_packet_reduction_len;
91
92 if (fragment_len > single_packet_capacity) {
93 if (!PacketizeFuA(i))
94 return false;
95 ++i;
96 } else {
97 i = PacketizeStapA(i);
98 }
99 break;
100 }
101 }
102 return true;
103 }
104
PacketizeFuA(size_t fragment_index)105 bool RtpPacketizerH264::PacketizeFuA(size_t fragment_index) {
106 // Fragment payload into packets (FU-A).
107 rtc::ArrayView<const uint8_t> fragment = input_fragments_[fragment_index];
108
109 PayloadSizeLimits limits = limits_;
110 // Leave room for the FU-A header.
111 limits.max_payload_len -= kFuAHeaderSize;
112 // Update single/first/last packet reductions unless it is single/first/last
113 // fragment.
114 if (input_fragments_.size() != 1) {
115 // if this fragment is put into a single packet, it might still be the
116 // first or the last packet in the whole sequence of packets.
117 if (fragment_index == input_fragments_.size() - 1) {
118 limits.single_packet_reduction_len = limits_.last_packet_reduction_len;
119 } else if (fragment_index == 0) {
120 limits.single_packet_reduction_len = limits_.first_packet_reduction_len;
121 } else {
122 limits.single_packet_reduction_len = 0;
123 }
124 }
125 if (fragment_index != 0)
126 limits.first_packet_reduction_len = 0;
127 if (fragment_index != input_fragments_.size() - 1)
128 limits.last_packet_reduction_len = 0;
129
130 // Strip out the original header.
131 size_t payload_left = fragment.size() - kNalHeaderSize;
132 int offset = kNalHeaderSize;
133
134 std::vector<int> payload_sizes = SplitAboutEqually(payload_left, limits);
135 if (payload_sizes.empty())
136 return false;
137
138 for (size_t i = 0; i < payload_sizes.size(); ++i) {
139 int packet_length = payload_sizes[i];
140 RTC_CHECK_GT(packet_length, 0);
141 packets_.push(PacketUnit(fragment.subview(offset, packet_length),
142 /*first_fragment=*/i == 0,
143 /*last_fragment=*/i == payload_sizes.size() - 1,
144 false, fragment[0]));
145 offset += packet_length;
146 payload_left -= packet_length;
147 }
148 num_packets_left_ += payload_sizes.size();
149 RTC_CHECK_EQ(0, payload_left);
150 return true;
151 }
152
PacketizeStapA(size_t fragment_index)153 size_t RtpPacketizerH264::PacketizeStapA(size_t fragment_index) {
154 // Aggregate fragments into one packet (STAP-A).
155 size_t payload_size_left = limits_.max_payload_len;
156 if (input_fragments_.size() == 1)
157 payload_size_left -= limits_.single_packet_reduction_len;
158 else if (fragment_index == 0)
159 payload_size_left -= limits_.first_packet_reduction_len;
160 int aggregated_fragments = 0;
161 size_t fragment_headers_length = 0;
162 rtc::ArrayView<const uint8_t> fragment = input_fragments_[fragment_index];
163 RTC_CHECK_GE(payload_size_left, fragment.size());
164 ++num_packets_left_;
165
166 auto payload_size_needed = [&] {
167 size_t fragment_size = fragment.size() + fragment_headers_length;
168 if (input_fragments_.size() == 1) {
169 // Single fragment, single packet, payload_size_left already adjusted
170 // with limits_.single_packet_reduction_len.
171 return fragment_size;
172 }
173 if (fragment_index == input_fragments_.size() - 1) {
174 // Last fragment, so STAP-A might be the last packet.
175 return fragment_size + limits_.last_packet_reduction_len;
176 }
177 return fragment_size;
178 };
179
180 while (payload_size_left >= payload_size_needed()) {
181 RTC_CHECK_GT(fragment.size(), 0);
182 packets_.push(PacketUnit(fragment, aggregated_fragments == 0, false, true,
183 fragment[0]));
184 payload_size_left -= fragment.size();
185 payload_size_left -= fragment_headers_length;
186
187 fragment_headers_length = kLengthFieldSize;
188 // If we are going to try to aggregate more fragments into this packet
189 // we need to add the STAP-A NALU header and a length field for the first
190 // NALU of this packet.
191 if (aggregated_fragments == 0)
192 fragment_headers_length += kNalHeaderSize + kLengthFieldSize;
193 ++aggregated_fragments;
194
195 // Next fragment.
196 ++fragment_index;
197 if (fragment_index == input_fragments_.size())
198 break;
199 fragment = input_fragments_[fragment_index];
200 }
201 RTC_CHECK_GT(aggregated_fragments, 0);
202 packets_.back().last_fragment = true;
203 return fragment_index;
204 }
205
PacketizeSingleNalu(size_t fragment_index)206 bool RtpPacketizerH264::PacketizeSingleNalu(size_t fragment_index) {
207 // Add a single NALU to the queue, no aggregation.
208 size_t payload_size_left = limits_.max_payload_len;
209 if (input_fragments_.size() == 1)
210 payload_size_left -= limits_.single_packet_reduction_len;
211 else if (fragment_index == 0)
212 payload_size_left -= limits_.first_packet_reduction_len;
213 else if (fragment_index + 1 == input_fragments_.size())
214 payload_size_left -= limits_.last_packet_reduction_len;
215 rtc::ArrayView<const uint8_t> fragment = input_fragments_[fragment_index];
216 if (payload_size_left < fragment.size()) {
217 RTC_LOG(LS_ERROR) << "Failed to fit a fragment to packet in SingleNalu "
218 "packetization mode. Payload size left "
219 << payload_size_left << ", fragment length "
220 << fragment.size() << ", packet capacity "
221 << limits_.max_payload_len;
222 return false;
223 }
224 RTC_CHECK_GT(fragment.size(), 0u);
225 packets_.push(PacketUnit(fragment, true /* first */, true /* last */,
226 false /* aggregated */, fragment[0]));
227 ++num_packets_left_;
228 return true;
229 }
230
NextPacket(RtpPacketToSend * rtp_packet)231 bool RtpPacketizerH264::NextPacket(RtpPacketToSend* rtp_packet) {
232 RTC_DCHECK(rtp_packet);
233 if (packets_.empty()) {
234 return false;
235 }
236
237 PacketUnit packet = packets_.front();
238 if (packet.first_fragment && packet.last_fragment) {
239 // Single NAL unit packet.
240 size_t bytes_to_send = packet.source_fragment.size();
241 uint8_t* buffer = rtp_packet->AllocatePayload(bytes_to_send);
242 memcpy(buffer, packet.source_fragment.data(), bytes_to_send);
243 packets_.pop();
244 input_fragments_.pop_front();
245 } else if (packet.aggregated) {
246 NextAggregatePacket(rtp_packet);
247 } else {
248 NextFragmentPacket(rtp_packet);
249 }
250 rtp_packet->SetMarker(packets_.empty());
251 --num_packets_left_;
252 return true;
253 }
254
NextAggregatePacket(RtpPacketToSend * rtp_packet)255 void RtpPacketizerH264::NextAggregatePacket(RtpPacketToSend* rtp_packet) {
256 // Reserve maximum available payload, set actual payload size later.
257 size_t payload_capacity = rtp_packet->FreeCapacity();
258 RTC_CHECK_GE(payload_capacity, kNalHeaderSize);
259 uint8_t* buffer = rtp_packet->AllocatePayload(payload_capacity);
260 RTC_DCHECK(buffer);
261 PacketUnit* packet = &packets_.front();
262 RTC_CHECK(packet->first_fragment);
263 // STAP-A NALU header.
264 buffer[0] =
265 (packet->header & (kH264FBit | kH264NriMask)) | H264::NaluType::kStapA;
266 size_t index = kNalHeaderSize;
267 bool is_last_fragment = packet->last_fragment;
268 while (packet->aggregated) {
269 rtc::ArrayView<const uint8_t> fragment = packet->source_fragment;
270 RTC_CHECK_LE(index + kLengthFieldSize + fragment.size(), payload_capacity);
271 // Add NAL unit length field.
272 ByteWriter<uint16_t>::WriteBigEndian(&buffer[index], fragment.size());
273 index += kLengthFieldSize;
274 // Add NAL unit.
275 memcpy(&buffer[index], fragment.data(), fragment.size());
276 index += fragment.size();
277 packets_.pop();
278 input_fragments_.pop_front();
279 if (is_last_fragment)
280 break;
281 packet = &packets_.front();
282 is_last_fragment = packet->last_fragment;
283 }
284 RTC_CHECK(is_last_fragment);
285 rtp_packet->SetPayloadSize(index);
286 }
287
NextFragmentPacket(RtpPacketToSend * rtp_packet)288 void RtpPacketizerH264::NextFragmentPacket(RtpPacketToSend* rtp_packet) {
289 PacketUnit* packet = &packets_.front();
290 // NAL unit fragmented over multiple packets (FU-A).
291 // We do not send original NALU header, so it will be replaced by the
292 // FU indicator header of the first packet.
293 uint8_t fu_indicator =
294 (packet->header & (kH264FBit | kH264NriMask)) | H264::NaluType::kFuA;
295 uint8_t fu_header = 0;
296
297 // S | E | R | 5 bit type.
298 fu_header |= (packet->first_fragment ? kH264SBit : 0);
299 fu_header |= (packet->last_fragment ? kH264EBit : 0);
300 uint8_t type = packet->header & kH264TypeMask;
301 fu_header |= type;
302 rtc::ArrayView<const uint8_t> fragment = packet->source_fragment;
303 uint8_t* buffer =
304 rtp_packet->AllocatePayload(kFuAHeaderSize + fragment.size());
305 buffer[0] = fu_indicator;
306 buffer[1] = fu_header;
307 memcpy(buffer + kFuAHeaderSize, fragment.data(), fragment.size());
308 if (packet->last_fragment)
309 input_fragments_.pop_front();
310 packets_.pop();
311 }
312
313 } // namespace webrtc
314