1/* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17//#define LOG_NDEBUG 0 18#define LOG_TAG "HevcUtils" 19 20#include <cstring> 21#include <utility> 22 23#include "include/HevcUtils.h" 24#include "include/avc_utils.h" 25 26#include <media/stagefright/foundation/ABitReader.h> 27#include <media/stagefright/foundation/ABuffer.h> 28#include <media/stagefright/foundation/ADebug.h> 29#include <media/stagefright/foundation/AMessage.h> 30#include <media/stagefright/MediaErrors.h> 31#include <media/stagefright/Utils.h> 32 33namespace android { 34 35static const uint8_t kHevcNalUnitTypes[5] = { 36 kHevcNalUnitTypeVps, 37 kHevcNalUnitTypeSps, 38 kHevcNalUnitTypePps, 39 kHevcNalUnitTypePrefixSei, 40 kHevcNalUnitTypeSuffixSei, 41}; 42 43HevcParameterSets::HevcParameterSets() 44 : mInfo(kInfoNone) { 45} 46 47status_t HevcParameterSets::addNalUnit(const uint8_t* data, size_t size) { 48 uint8_t nalUnitType = (data[0] >> 1) & 0x3f; 49 status_t err = OK; 50 switch (nalUnitType) { 51 case 32: // VPS 52 err = parseVps(data + 2, size - 2); 53 break; 54 case 33: // SPS 55 err = parseSps(data + 2, size - 2); 56 break; 57 case 34: // PPS 58 err = parsePps(data + 2, size - 2); 59 break; 60 case 39: // Prefix SEI 61 case 40: // Suffix SEI 62 // Ignore 63 break; 64 default: 65 ALOGE("Unrecognized NAL unit type."); 66 return ERROR_MALFORMED; 67 } 68 69 if (err != OK) { 70 return err; 71 } 72 73 sp<ABuffer> buffer = ABuffer::CreateAsCopy(data, size); 74 buffer->setInt32Data(nalUnitType); 75 mNalUnits.push(buffer); 76 return OK; 77} 78 79template <typename T> 80static bool findParam(uint32_t key, T *param, 81 KeyedVector<uint32_t, uint64_t> ¶ms) { 82 CHECK(param); 83 if (params.indexOfKey(key) < 0) { 84 return false; 85 } 86 *param = (T) params[key]; 87 return true; 88} 89 90bool HevcParameterSets::findParam8(uint32_t key, uint8_t *param) { 91 return findParam(key, param, mParams); 92} 93 94bool HevcParameterSets::findParam16(uint32_t key, uint16_t *param) { 95 return findParam(key, param, mParams); 96} 97 98bool HevcParameterSets::findParam32(uint32_t key, uint32_t *param) { 99 return findParam(key, param, mParams); 100} 101 102bool HevcParameterSets::findParam64(uint32_t key, uint64_t *param) { 103 return findParam(key, param, mParams); 104} 105 106size_t HevcParameterSets::getNumNalUnitsOfType(uint8_t type) { 107 size_t num = 0; 108 for (size_t i = 0; i < mNalUnits.size(); ++i) { 109 if (getType(i) == type) { 110 ++num; 111 } 112 } 113 return num; 114} 115 116uint8_t HevcParameterSets::getType(size_t index) { 117 CHECK_LT(index, mNalUnits.size()); 118 return mNalUnits[index]->int32Data(); 119} 120 121size_t HevcParameterSets::getSize(size_t index) { 122 CHECK_LT(index, mNalUnits.size()); 123 return mNalUnits[index]->size(); 124} 125 126bool HevcParameterSets::write(size_t index, uint8_t* dest, size_t size) { 127 CHECK_LT(index, mNalUnits.size()); 128 const sp<ABuffer>& nalUnit = mNalUnits[index]; 129 if (size < nalUnit->size()) { 130 ALOGE("dest buffer size too small: %zu vs. %zu to be written", 131 size, nalUnit->size()); 132 return false; 133 } 134 memcpy(dest, nalUnit->data(), nalUnit->size()); 135 return true; 136} 137 138status_t HevcParameterSets::parseVps(const uint8_t* data, size_t size) { 139 // See Rec. ITU-T H.265 v3 (04/2015) Chapter 7.3.2.1 for reference 140 NALBitReader reader(data, size); 141 // Skip vps_video_parameter_set_id 142 reader.skipBits(4); 143 // Skip vps_base_layer_internal_flag 144 reader.skipBits(1); 145 // Skip vps_base_layer_available_flag 146 reader.skipBits(1); 147 // Skip vps_max_layers_minus_1 148 reader.skipBits(6); 149 // Skip vps_temporal_id_nesting_flags 150 reader.skipBits(1); 151 // Skip reserved 152 reader.skipBits(16); 153 154 if (reader.atLeastNumBitsLeft(96)) { 155 mParams.add(kGeneralProfileSpace, reader.getBits(2)); 156 mParams.add(kGeneralTierFlag, reader.getBits(1)); 157 mParams.add(kGeneralProfileIdc, reader.getBits(5)); 158 mParams.add(kGeneralProfileCompatibilityFlags, reader.getBits(32)); 159 mParams.add( 160 kGeneralConstraintIndicatorFlags, 161 ((uint64_t)reader.getBits(16) << 32) | reader.getBits(32)); 162 mParams.add(kGeneralLevelIdc, reader.getBits(8)); 163 // 96 bits total for general profile. 164 } else { 165 reader.skipBits(96); 166 } 167 168 return reader.overRead() ? ERROR_MALFORMED : OK; 169} 170 171status_t HevcParameterSets::parseSps(const uint8_t* data, size_t size) { 172 // See Rec. ITU-T H.265 v3 (04/2015) Chapter 7.3.2.2 for reference 173 NALBitReader reader(data, size); 174 // Skip sps_video_parameter_set_id 175 reader.skipBits(4); 176 uint8_t maxSubLayersMinus1 = reader.getBitsWithFallback(3, 0); 177 // Skip sps_temporal_id_nesting_flag; 178 reader.skipBits(1); 179 // Skip general profile 180 reader.skipBits(96); 181 if (maxSubLayersMinus1 > 0) { 182 bool subLayerProfilePresentFlag[8]; 183 bool subLayerLevelPresentFlag[8]; 184 for (int i = 0; i < maxSubLayersMinus1; ++i) { 185 subLayerProfilePresentFlag[i] = reader.getBitsWithFallback(1, 0); 186 subLayerLevelPresentFlag[i] = reader.getBitsWithFallback(1, 0); 187 } 188 // Skip reserved 189 reader.skipBits(2 * (8 - maxSubLayersMinus1)); 190 for (int i = 0; i < maxSubLayersMinus1; ++i) { 191 if (subLayerProfilePresentFlag[i]) { 192 // Skip profile 193 reader.skipBits(88); 194 } 195 if (subLayerLevelPresentFlag[i]) { 196 // Skip sub_layer_level_idc[i] 197 reader.skipBits(8); 198 } 199 } 200 } 201 // Skip sps_seq_parameter_set_id 202 skipUE(&reader); 203 uint8_t chromaFormatIdc = parseUEWithFallback(&reader, 0); 204 mParams.add(kChromaFormatIdc, chromaFormatIdc); 205 if (chromaFormatIdc == 3) { 206 // Skip separate_colour_plane_flag 207 reader.skipBits(1); 208 } 209 // Skip pic_width_in_luma_samples 210 skipUE(&reader); 211 // Skip pic_height_in_luma_samples 212 skipUE(&reader); 213 if (reader.getBitsWithFallback(1, 0) /* i.e. conformance_window_flag */) { 214 // Skip conf_win_left_offset 215 skipUE(&reader); 216 // Skip conf_win_right_offset 217 skipUE(&reader); 218 // Skip conf_win_top_offset 219 skipUE(&reader); 220 // Skip conf_win_bottom_offset 221 skipUE(&reader); 222 } 223 mParams.add(kBitDepthLumaMinus8, parseUEWithFallback(&reader, 0)); 224 mParams.add(kBitDepthChromaMinus8, parseUEWithFallback(&reader, 0)); 225 226 // log2_max_pic_order_cnt_lsb_minus4 227 size_t log2MaxPicOrderCntLsb = parseUEWithFallback(&reader, 0) + (size_t)4; 228 bool spsSubLayerOrderingInfoPresentFlag = reader.getBitsWithFallback(1, 0); 229 for (uint32_t i = spsSubLayerOrderingInfoPresentFlag ? 0 : maxSubLayersMinus1; 230 i <= maxSubLayersMinus1; ++i) { 231 skipUE(&reader); // sps_max_dec_pic_buffering_minus1[i] 232 skipUE(&reader); // sps_max_num_reorder_pics[i] 233 skipUE(&reader); // sps_max_latency_increase_plus1[i] 234 } 235 236 skipUE(&reader); // log2_min_luma_coding_block_size_minus3 237 skipUE(&reader); // log2_diff_max_min_luma_coding_block_size 238 skipUE(&reader); // log2_min_luma_transform_block_size_minus2 239 skipUE(&reader); // log2_diff_max_min_luma_transform_block_size 240 skipUE(&reader); // max_transform_hierarchy_depth_inter 241 skipUE(&reader); // max_transform_hierarchy_depth_intra 242 if (reader.getBitsWithFallback(1, 0)) { // scaling_list_enabled_flag u(1) 243 // scaling_list_data 244 if (reader.getBitsWithFallback(1, 0)) { // sps_scaling_list_data_present_flag 245 for (uint32_t sizeId = 0; sizeId < 4; ++sizeId) { 246 for (uint32_t matrixId = 0; matrixId < 6; matrixId += (sizeId == 3) ? 3 : 1) { 247 if (!reader.getBitsWithFallback(1, 1)) { 248 // scaling_list_pred_mode_flag[sizeId][matrixId] 249 skipUE(&reader); // scaling_list_pred_matrix_id_delta[sizeId][matrixId] 250 } else { 251 uint32_t coefNum = std::min(64, (1 << (4 + (sizeId << 1)))); 252 if (sizeId > 1) { 253 skipSE(&reader); // scaling_list_dc_coef_minus8[sizeId − 2][matrixId] 254 } 255 for (uint32_t i = 0; i < coefNum; ++i) { 256 skipSE(&reader); // scaling_list_delta_coef 257 } 258 } 259 } 260 } 261 } 262 } 263 reader.skipBits(1); // amp_enabled_flag 264 reader.skipBits(1); // sample_adaptive_offset_enabled_flag u(1) 265 if (reader.getBitsWithFallback(1, 0)) { // pcm_enabled_flag 266 reader.skipBits(4); // pcm_sample_bit_depth_luma_minus1 267 reader.skipBits(4); // pcm_sample_bit_depth_chroma_minus1 u(4) 268 skipUE(&reader); // log2_min_pcm_luma_coding_block_size_minus3 269 skipUE(&reader); // log2_diff_max_min_pcm_luma_coding_block_size 270 reader.skipBits(1); // pcm_loop_filter_disabled_flag 271 } 272 uint32_t numShortTermRefPicSets = parseUEWithFallback(&reader, 0); 273 uint32_t numPics = 0; 274 for (uint32_t i = 0; i < numShortTermRefPicSets; ++i) { 275 // st_ref_pic_set(i) 276 if (i != 0 && reader.getBitsWithFallback(1, 0)) { // inter_ref_pic_set_prediction_flag 277 reader.skipBits(1); // delta_rps_sign 278 skipUE(&reader); // abs_delta_rps_minus1 279 uint32_t nextNumPics = 0; 280 for (uint32_t j = 0; j <= numPics; ++j) { 281 if (reader.getBitsWithFallback(1, 0) // used_by_curr_pic_flag[j] 282 || reader.getBitsWithFallback(1, 0)) { // use_delta_flag[j] 283 ++nextNumPics; 284 } 285 } 286 numPics = nextNumPics; 287 } else { 288 uint32_t numNegativePics = parseUEWithFallback(&reader, 0); 289 uint32_t numPositivePics = parseUEWithFallback(&reader, 0); 290 if (numNegativePics > UINT32_MAX - numPositivePics) { 291 return ERROR_MALFORMED; 292 } 293 numPics = numNegativePics + numPositivePics; 294 for (uint32_t j = 0; j < numPics; ++j) { 295 skipUE(&reader); // delta_poc_s0|1_minus1[i] 296 reader.skipBits(1); // used_by_curr_pic_s0|1_flag[i] 297 } 298 } 299 } 300 if (reader.getBitsWithFallback(1, 0)) { // long_term_ref_pics_present_flag 301 uint32_t numLongTermRefPicSps = parseUEWithFallback(&reader, 0); 302 for (uint32_t i = 0; i < numLongTermRefPicSps; ++i) { 303 reader.skipBits(log2MaxPicOrderCntLsb); // lt_ref_pic_poc_lsb_sps[i] 304 reader.skipBits(1); // used_by_curr_pic_lt_sps_flag[i] 305 } 306 } 307 reader.skipBits(1); // sps_temporal_mvp_enabled_flag 308 reader.skipBits(1); // strong_intra_smoothing_enabled_flag 309 if (reader.getBitsWithFallback(1, 0)) { // vui_parameters_present_flag 310 if (reader.getBitsWithFallback(1, 0)) { // aspect_ratio_info_present_flag 311 uint32_t aspectRatioIdc = reader.getBitsWithFallback(8, 0); 312 if (aspectRatioIdc == 0xFF /* EXTENDED_SAR */) { 313 reader.skipBits(16); // sar_width 314 reader.skipBits(16); // sar_height 315 } 316 } 317 if (reader.getBitsWithFallback(1, 0)) { // overscan_info_present_flag 318 reader.skipBits(1); // overscan_appropriate_flag 319 } 320 if (reader.getBitsWithFallback(1, 0)) { // video_signal_type_present_flag 321 reader.skipBits(3); // video_format 322 uint32_t videoFullRangeFlag; 323 if (reader.getBitsGraceful(1, &videoFullRangeFlag)) { 324 mParams.add(kVideoFullRangeFlag, videoFullRangeFlag); 325 } 326 if (reader.getBitsWithFallback(1, 0)) { // colour_description_present_flag 327 mInfo = (Info)(mInfo | kInfoHasColorDescription); 328 uint32_t colourPrimaries, transferCharacteristics, matrixCoeffs; 329 if (reader.getBitsGraceful(8, &colourPrimaries)) { 330 mParams.add(kColourPrimaries, colourPrimaries); 331 } 332 if (reader.getBitsGraceful(8, &transferCharacteristics)) { 333 mParams.add(kTransferCharacteristics, transferCharacteristics); 334 if (transferCharacteristics == 16 /* ST 2084 */ 335 || transferCharacteristics == 18 /* ARIB STD-B67 HLG */) { 336 mInfo = (Info)(mInfo | kInfoIsHdr); 337 } 338 } 339 if (reader.getBitsGraceful(8, &matrixCoeffs)) { 340 mParams.add(kMatrixCoeffs, matrixCoeffs); 341 } 342 } 343 // skip rest of VUI 344 } 345 } 346 347 return reader.overRead() ? ERROR_MALFORMED : OK; 348} 349 350status_t HevcParameterSets::parsePps( 351 const uint8_t* data __unused, size_t size __unused) { 352 return OK; 353} 354 355status_t HevcParameterSets::makeHvcc(uint8_t *hvcc, size_t *hvccSize, 356 size_t nalSizeLength) { 357 if (hvcc == NULL || hvccSize == NULL 358 || (nalSizeLength != 4 && nalSizeLength != 2)) { 359 return BAD_VALUE; 360 } 361 // ISO 14496-15: HEVC file format 362 size_t size = 23; // 23 bytes in the header 363 size_t numOfArrays = 0; 364 const size_t numNalUnits = getNumNalUnits(); 365 for (size_t i = 0; i < ARRAY_SIZE(kHevcNalUnitTypes); ++i) { 366 uint8_t type = kHevcNalUnitTypes[i]; 367 size_t numNalus = getNumNalUnitsOfType(type); 368 if (numNalus == 0) { 369 continue; 370 } 371 ++numOfArrays; 372 size += 3; 373 for (size_t j = 0; j < numNalUnits; ++j) { 374 if (getType(j) != type) { 375 continue; 376 } 377 size += 2 + getSize(j); 378 } 379 } 380 uint8_t generalProfileSpace, generalTierFlag, generalProfileIdc; 381 if (!findParam8(kGeneralProfileSpace, &generalProfileSpace) 382 || !findParam8(kGeneralTierFlag, &generalTierFlag) 383 || !findParam8(kGeneralProfileIdc, &generalProfileIdc)) { 384 return ERROR_MALFORMED; 385 } 386 uint32_t compatibilityFlags; 387 uint64_t constraintIdcFlags; 388 if (!findParam32(kGeneralProfileCompatibilityFlags, &compatibilityFlags) 389 || !findParam64(kGeneralConstraintIndicatorFlags, &constraintIdcFlags)) { 390 return ERROR_MALFORMED; 391 } 392 uint8_t generalLevelIdc; 393 if (!findParam8(kGeneralLevelIdc, &generalLevelIdc)) { 394 return ERROR_MALFORMED; 395 } 396 uint8_t chromaFormatIdc, bitDepthLumaMinus8, bitDepthChromaMinus8; 397 if (!findParam8(kChromaFormatIdc, &chromaFormatIdc) 398 || !findParam8(kBitDepthLumaMinus8, &bitDepthLumaMinus8) 399 || !findParam8(kBitDepthChromaMinus8, &bitDepthChromaMinus8)) { 400 return ERROR_MALFORMED; 401 } 402 if (size > *hvccSize) { 403 return NO_MEMORY; 404 } 405 *hvccSize = size; 406 407 uint8_t *header = hvcc; 408 header[0] = 1; 409 header[1] = (kGeneralProfileSpace << 6) | (kGeneralTierFlag << 5) | kGeneralProfileIdc; 410 header[2] = (compatibilityFlags >> 24) & 0xff; 411 header[3] = (compatibilityFlags >> 16) & 0xff; 412 header[4] = (compatibilityFlags >> 8) & 0xff; 413 header[5] = compatibilityFlags & 0xff; 414 header[6] = (constraintIdcFlags >> 40) & 0xff; 415 header[7] = (constraintIdcFlags >> 32) & 0xff; 416 header[8] = (constraintIdcFlags >> 24) & 0xff; 417 header[9] = (constraintIdcFlags >> 16) & 0xff; 418 header[10] = (constraintIdcFlags >> 8) & 0xff; 419 header[11] = constraintIdcFlags & 0xff; 420 header[12] = generalLevelIdc; 421 // FIXME: parse min_spatial_segmentation_idc. 422 header[13] = 0xf0; 423 header[14] = 0; 424 // FIXME: derive parallelismType properly. 425 header[15] = 0xfc; 426 header[16] = 0xfc | chromaFormatIdc; 427 header[17] = 0xf8 | bitDepthLumaMinus8; 428 header[18] = 0xf8 | bitDepthChromaMinus8; 429 // FIXME: derive avgFrameRate 430 header[19] = 0; 431 header[20] = 0; 432 // constantFrameRate, numTemporalLayers, temporalIdNested all set to 0. 433 header[21] = nalSizeLength - 1; 434 header[22] = numOfArrays; 435 header += 23; 436 for (size_t i = 0; i < ARRAY_SIZE(kHevcNalUnitTypes); ++i) { 437 uint8_t type = kHevcNalUnitTypes[i]; 438 size_t numNalus = getNumNalUnitsOfType(type); 439 if (numNalus == 0) { 440 continue; 441 } 442 // array_completeness set to 0. 443 header[0] = type; 444 header[1] = (numNalus >> 8) & 0xff; 445 header[2] = numNalus & 0xff; 446 header += 3; 447 for (size_t j = 0; j < numNalUnits; ++j) { 448 if (getType(j) != type) { 449 continue; 450 } 451 header[0] = (getSize(j) >> 8) & 0xff; 452 header[1] = getSize(j) & 0xff; 453 if (!write(j, header + 2, size - (header - (uint8_t *)hvcc))) { 454 return NO_MEMORY; 455 } 456 header += (2 + getSize(j)); 457 } 458 } 459 CHECK_EQ(header - size, hvcc); 460 461 return OK; 462} 463 464} // namespace android 465