1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #include "media/filters/h264_to_annex_b_bitstream_converter.h"
7 #include "base/logging.h"
11 static const uint8 kStartCodePrefix[3] = {0, 0, 1};
13 // Helper function which determines whether NAL unit of given type marks
14 // access unit boundary.
15 static bool IsAccessUnitBoundaryNal(int nal_unit_type) {
16 // Check if this packet marks access unit boundary by checking the
18 if (nal_unit_type == 6 || // Supplemental enhancement information
19 nal_unit_type == 7 || // Picture parameter set
20 nal_unit_type == 8 || // Sequence parameter set
21 nal_unit_type == 9 || // Access unit delimiter
22 (nal_unit_type >= 14 && nal_unit_type <= 18)) { // Reserved types
28 H264ToAnnexBBitstreamConverter::H264ToAnnexBBitstreamConverter()
29 : configuration_processed_(false),
30 first_nal_unit_in_access_unit_(true),
31 nal_unit_length_field_width_(0) {
34 H264ToAnnexBBitstreamConverter::~H264ToAnnexBBitstreamConverter() {}
36 uint32 H264ToAnnexBBitstreamConverter::ParseConfigurationAndCalculateSize(
37 const uint8* configuration_record,
38 uint32 configuration_record_size) {
39 // FFmpeg's AVCodecContext's extradata field contains the Decoder Specific
40 // Information from MP4 headers that contain the H.264 SPS and PPS members.
41 // ISO 14496-15 Chapter 5.2.4 AVCDecoderConfigurationRecord.
42 // AVCConfigurationRecord must be at least 7 bytes long.
43 if (configuration_record == NULL || configuration_record_size < 7) {
44 return 0; // Error: invalid input
46 const uint8* decoder_configuration = configuration_record;
47 uint32 parameter_set_size_bytes = 0;
49 // We can skip the four first bytes as they're only profile information
50 decoder_configuration += 4;
51 // Fifth byte's two LSBs contain the interleaving field's size minus one
52 uint8 size_of_len_field = (*decoder_configuration & 0x3) + 1;
53 if (size_of_len_field != 1 && size_of_len_field != 2 &&
54 size_of_len_field != 4) {
55 return 0; // Error: invalid input, NAL unit field len is not correct
57 decoder_configuration++;
58 // Sixth byte's five LSBs contain the number of SPSs
59 uint8 sps_count = *decoder_configuration & 0x1F;
60 decoder_configuration++;
61 // Then we have N * SPS's with two byte length field and actual SPS
62 while (sps_count-- > 0) {
63 if ((decoder_configuration - configuration_record) + 2 >
64 static_cast<int32>(configuration_record_size)) {
65 return 0; // Error: ran out of data
67 uint16 sps_len = decoder_configuration[0] << 8 | decoder_configuration[1];
68 decoder_configuration += 2;
69 // write the SPS to output, always with zero byte + start code prefix
70 parameter_set_size_bytes += 1 + sizeof(kStartCodePrefix);
71 decoder_configuration += sps_len;
72 parameter_set_size_bytes += sps_len;
74 // Then we have the numner of pps in one byte
75 uint8 pps_count = *decoder_configuration;
76 decoder_configuration++;
77 // And finally, we have N * PPS with two byte length field and actual PPS
78 while (pps_count-- > 0) {
79 if ((decoder_configuration - configuration_record) + 2 >
80 static_cast<int32>(configuration_record_size)) {
81 return 0; // Error: ran out of data
83 uint16 pps_len = decoder_configuration[0] << 8 | decoder_configuration[1];
84 decoder_configuration += 2;
85 // write the SPS to output, always with zero byte + start code prefix
86 parameter_set_size_bytes += 1 + sizeof(kStartCodePrefix);
87 decoder_configuration += pps_len;
88 parameter_set_size_bytes += pps_len;
90 // We're done processing the AVCDecoderConfigurationRecord,
91 // store the needed information for parsing actual payload
92 nal_unit_length_field_width_ = size_of_len_field;
93 configuration_processed_ = true;
94 return parameter_set_size_bytes;
97 uint32 H264ToAnnexBBitstreamConverter::CalculateNeededOutputBufferSize(
99 uint32 input_size) const {
100 uint32 output_size = 0;
101 uint32 data_left = input_size;
102 bool first_nal_in_this_access_unit = first_nal_unit_in_access_unit_;
104 if (input == NULL || input_size == 0) {
105 return 0; // Error: invalid input data
107 if (!configuration_processed_) {
108 return 0; // Error: configuration not handled, we don't know nal unit width
110 CHECK(nal_unit_length_field_width_ == 1 ||
111 nal_unit_length_field_width_ == 2 ||
112 nal_unit_length_field_width_ == 4);
114 // Then add the needed size for the actual packet
115 while (data_left > 0) {
116 if (data_left < nal_unit_length_field_width_) {
117 return 0; // Error: not enough data for correct conversion.
120 // Read the next NAL unit length from the input buffer
121 uint8 size_of_len_field;
122 uint32 nal_unit_length;
123 for (nal_unit_length = 0, size_of_len_field = nal_unit_length_field_width_;
124 size_of_len_field > 0;
125 input++, size_of_len_field--, data_left--) {
126 nal_unit_length <<= 8;
127 nal_unit_length |= *input;
130 if (nal_unit_length == 0) {
131 break; // Signifies that no more data left in the buffer
132 } else if (nal_unit_length > data_left) {
133 return 0; // Error: Not enough data for correct conversion
135 data_left -= nal_unit_length;
137 // five least significant bits of first NAL unit byte signify nal_unit_type
138 int nal_unit_type = *input & 0x1F;
139 if (first_nal_in_this_access_unit ||
140 IsAccessUnitBoundaryNal(nal_unit_type)) {
141 output_size += 1; // Extra zero_byte for these nal units
142 first_nal_in_this_access_unit = false;
145 output_size += sizeof(kStartCodePrefix);
146 // Actual NAL unit size
147 output_size += nal_unit_length;
148 input += nal_unit_length;
149 // No need for trailing zero bits
154 bool H264ToAnnexBBitstreamConverter::ConvertAVCDecoderConfigToByteStream(
158 uint32* output_size) {
159 uint8* outscan = output;
160 // FFmpeg's AVCodecContext's extradata field contains the Decoder Specific
161 // Information from MP4 headers that contain the H.264 SPS and PPS members.
162 // ISO 14496-15 Chapter 5.2.4 AVCDecoderConfigurationRecord.
163 const uint8* decoder_configuration = input;
164 uint32 decoderconfiguration_size = input_size;
167 if (decoder_configuration == NULL || decoderconfiguration_size == 0) {
168 return 0; // Error: input invalid
171 // We can skip the four first bytes as they're only profile information.
172 decoder_configuration += 4;
173 // Fifth byte's two LSBs contain the interleaving field's size minus one
174 uint8 size_of_len_field = (*decoder_configuration & 0x3) + 1;
175 if (size_of_len_field != 1 && size_of_len_field != 2 &&
176 size_of_len_field != 4) {
177 return 0; // Error: invalid input, NAL unit field len is not correct
179 decoder_configuration++;
180 // Sixth byte's five LSBs contain the number of SPSs
181 uint8 sps_count = *decoder_configuration & 0x1F;
182 decoder_configuration++;
183 // Then we have N * SPS's with two byte length field and actual SPS
184 while (sps_count-- > 0) {
185 uint16 sps_len = decoder_configuration[0] << 8 |
186 decoder_configuration[1];
187 decoder_configuration += 2;
188 if (out_size + 1 + sizeof(kStartCodePrefix) + sps_len >
191 return 0; // too small output buffer;
193 // write the SPS to output, always with zero byte + start code prefix
194 *outscan = 0; // zero byte
196 memcpy(outscan, kStartCodePrefix, sizeof(kStartCodePrefix));
197 outscan += sizeof(kStartCodePrefix);
198 memcpy(outscan, decoder_configuration, sps_len);
199 decoder_configuration += sps_len;
201 out_size += 1 + sizeof(kStartCodePrefix) + sps_len;
203 // Then we have the numner of pps in one byte
204 uint8 pps_count = *decoder_configuration;
205 decoder_configuration++;
206 // And finally, we have N * PPS with two byte length field and actual PPS
207 while (pps_count-- > 0) {
208 uint16 pps_len = decoder_configuration[0] << 8 | decoder_configuration[1];
209 decoder_configuration += 2;
210 if (out_size + 1 + sizeof(kStartCodePrefix) + pps_len >
213 return 0; // too small output buffer;
215 // write the SPS to output, always with zero byte + start code prefix
216 *outscan = 0; // zero byte
218 memcpy(outscan, kStartCodePrefix, sizeof(kStartCodePrefix));
219 outscan += sizeof(kStartCodePrefix);
220 memcpy(outscan, decoder_configuration, pps_len);
221 decoder_configuration += pps_len;
223 out_size += 1 + sizeof(kStartCodePrefix) + pps_len;
225 // We're done processing the AVCDecoderConfigurationRecord, store the needed
227 nal_unit_length_field_width_ = size_of_len_field;
228 configuration_processed_ = true;
229 *output_size = out_size;
233 bool H264ToAnnexBBitstreamConverter::ConvertNalUnitStreamToByteStream(
234 const uint8* input, uint32 input_size,
235 uint8* output, uint32* output_size) {
236 const uint8* inscan = input; // We read the input from here progressively
237 uint8* outscan = output; // We write the output to here progressively
238 uint32 data_left = input_size;
240 if (inscan == NULL || input_size == 0 ||
241 outscan == NULL || *output_size == 0) {
243 return false; // Error: invalid input
246 // NAL unit width should be known at this point
247 CHECK(nal_unit_length_field_width_ == 1 ||
248 nal_unit_length_field_width_ == 2 ||
249 nal_unit_length_field_width_ == 4);
251 // Do the actual conversion for the actual input packet
252 while (data_left > 0) {
254 uint32 nal_unit_length;
256 // Read the next NAL unit length from the input buffer by scanning
257 // the input stream with the specific length field width
258 for (nal_unit_length = 0, i = nal_unit_length_field_width_;
259 i > 0 && data_left > 0;
260 inscan++, i--, data_left--) {
261 nal_unit_length <<= 8;
262 nal_unit_length |= *inscan;
265 if (nal_unit_length == 0) {
266 break; // Successful conversion, end of buffer
267 } else if (nal_unit_length > data_left) {
269 return false; // Error: not enough data for correct conversion
272 uint32 start_code_len;
273 first_nal_unit_in_access_unit_ ?
274 start_code_len = sizeof(kStartCodePrefix) + 1 :
275 start_code_len = sizeof(kStartCodePrefix);
276 if (static_cast<uint32>(outscan - output) +
277 start_code_len + nal_unit_length > *output_size) {
279 return false; // Error: too small output buffer
282 // Five least significant bits of first NAL unit byte signify
284 int nal_unit_type = *inscan & 0x1F;
286 // Check if this packet marks access unit boundary by checking the
288 if (IsAccessUnitBoundaryNal(nal_unit_type)) {
289 first_nal_unit_in_access_unit_ = true;
292 // Write extra zero-byte before start code prefix if this packet
293 // signals next access unit.
294 if (first_nal_unit_in_access_unit_) {
297 first_nal_unit_in_access_unit_ = false;
300 // No need to write leading zero bits.
301 // Write start-code prefix.
302 memcpy(outscan, kStartCodePrefix, sizeof(kStartCodePrefix));
303 outscan += sizeof(kStartCodePrefix);
304 // Then write the actual NAL unit from the input buffer.
305 memcpy(outscan, inscan, nal_unit_length);
306 inscan += nal_unit_length;
307 data_left -= nal_unit_length;
308 outscan += nal_unit_length;
309 // No need for trailing zero bits.
311 // Successful conversion, output the freshly allocated bitstream buffer.
312 *output_size = static_cast<uint32>(outscan - output);