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. 4 5 #include "media/filters/h264_to_annex_b_bitstream_converter.h" 6 7 #include "base/logging.h" 8 9 namespace media { 10 11 static const uint8 kStartCodePrefix[3] = {0, 0, 1}; 12 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 17 // packet type. 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 23 return true; 24 } 25 return false; 26 } 27 28 H264ToAnnexBBitstreamConverter::H264ToAnnexBBitstreamConverter() 29 : configuration_processed_(false), 30 first_nal_unit_in_access_unit_(true), 31 nal_unit_length_field_width_(0) { 32 } 33 34 H264ToAnnexBBitstreamConverter::~H264ToAnnexBBitstreamConverter() {} 35 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 45 } 46 const uint8* decoder_configuration = configuration_record; 47 uint32 parameter_set_size_bytes = 0; 48 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 56 } 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 66 } 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; 73 } 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 82 } 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; 89 } 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; 95 } 96 97 uint32 H264ToAnnexBBitstreamConverter::CalculateNeededOutputBufferSize( 98 const uint8* input, 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_; 103 104 if (input == NULL || input_size == 0) { 105 return 0; // Error: invalid input data 106 } 107 if (!configuration_processed_) { 108 return 0; // Error: configuration not handled, we don't know nal unit width 109 } 110 CHECK(nal_unit_length_field_width_ == 1 || 111 nal_unit_length_field_width_ == 2 || 112 nal_unit_length_field_width_ == 4); 113 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. 118 } 119 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; 128 } 129 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 134 } 135 data_left -= nal_unit_length; 136 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; 143 } 144 // Start code prefix 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 150 } 151 return output_size; 152 } 153 154 bool H264ToAnnexBBitstreamConverter::ConvertAVCDecoderConfigToByteStream( 155 const uint8* input, 156 uint32 input_size, 157 uint8* output, 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; 165 uint32 out_size = 0; 166 167 if (decoder_configuration == NULL || decoderconfiguration_size == 0) { 168 return 0; // Error: input invalid 169 } 170 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 178 } 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 > 189 *output_size) { 190 *output_size = 0; 191 return 0; // too small output buffer; 192 } 193 // write the SPS to output, always with zero byte + start code prefix 194 *outscan = 0; // zero byte 195 outscan += 1; 196 memcpy(outscan, kStartCodePrefix, sizeof(kStartCodePrefix)); 197 outscan += sizeof(kStartCodePrefix); 198 memcpy(outscan, decoder_configuration, sps_len); 199 decoder_configuration += sps_len; 200 outscan += sps_len; 201 out_size += 1 + sizeof(kStartCodePrefix) + sps_len; 202 } 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 > 211 *output_size) { 212 *output_size = 0; 213 return 0; // too small output buffer; 214 } 215 // write the SPS to output, always with zero byte + start code prefix 216 *outscan = 0; // zero byte 217 outscan += 1; 218 memcpy(outscan, kStartCodePrefix, sizeof(kStartCodePrefix)); 219 outscan += sizeof(kStartCodePrefix); 220 memcpy(outscan, decoder_configuration, pps_len); 221 decoder_configuration += pps_len; 222 outscan += pps_len; 223 out_size += 1 + sizeof(kStartCodePrefix) + pps_len; 224 } 225 // We're done processing the AVCDecoderConfigurationRecord, store the needed 226 // information 227 nal_unit_length_field_width_ = size_of_len_field; 228 configuration_processed_ = true; 229 *output_size = out_size; 230 return true; 231 } 232 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; 239 240 if (inscan == NULL || input_size == 0 || 241 outscan == NULL || *output_size == 0) { 242 *output_size = 0; 243 return false; // Error: invalid input 244 } 245 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); 250 251 // Do the actual conversion for the actual input packet 252 while (data_left > 0) { 253 uint8 i; 254 uint32 nal_unit_length; 255 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; 263 } 264 265 if (nal_unit_length == 0) { 266 break; // Successful conversion, end of buffer 267 } else if (nal_unit_length > data_left) { 268 *output_size = 0; 269 return false; // Error: not enough data for correct conversion 270 } 271 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) { 278 *output_size = 0; 279 return false; // Error: too small output buffer 280 } 281 282 // Five least significant bits of first NAL unit byte signify 283 // nal_unit_type. 284 int nal_unit_type = *inscan & 0x1F; 285 286 // Check if this packet marks access unit boundary by checking the 287 // packet type. 288 if (IsAccessUnitBoundaryNal(nal_unit_type)) { 289 first_nal_unit_in_access_unit_ = true; 290 } 291 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_) { 295 *outscan = 0; 296 outscan++; 297 first_nal_unit_in_access_unit_ = false; 298 } 299 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. 310 } 311 // Successful conversion, output the freshly allocated bitstream buffer. 312 *output_size = static_cast<uint32>(outscan - output); 313 return true; 314 } 315 316 } // namespace media 317