1/* 2 * This file is part of FFmpeg. 3 * 4 * FFmpeg is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU Lesser General Public 6 * License as published by the Free Software Foundation; either 7 * version 2.1 of the License, or (at your option) any later version. 8 * 9 * FFmpeg is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 * Lesser General Public License for more details. 13 * 14 * You should have received a copy of the GNU Lesser General Public 15 * License along with FFmpeg; if not, write to the Free Software 16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 17 */ 18 19#include "bytestream.h" 20#include "get_bits.h" 21#include "golomb.h" 22#include "h264.h" 23#include "h264pred.h" 24#include "h264_parse.h" 25#include "h264_ps.h" 26#include "h2645_parse.h" 27#include "mpegutils.h" 28 29int ff_h264_pred_weight_table(GetBitContext *gb, const SPS *sps, 30 const int *ref_count, int slice_type_nos, 31 H264PredWeightTable *pwt, 32 int picture_structure, void *logctx) 33{ 34 int list, i, j; 35 int luma_def, chroma_def; 36 37 pwt->use_weight = 0; 38 pwt->use_weight_chroma = 0; 39 40 pwt->luma_log2_weight_denom = get_ue_golomb_31(gb); 41 if (pwt->luma_log2_weight_denom > 7U) { 42 av_log(logctx, AV_LOG_ERROR, "luma_log2_weight_denom %d is out of range\n", pwt->luma_log2_weight_denom); 43 pwt->luma_log2_weight_denom = 0; 44 } 45 luma_def = 1 << pwt->luma_log2_weight_denom; 46 47 if (sps->chroma_format_idc) { 48 pwt->chroma_log2_weight_denom = get_ue_golomb_31(gb); 49 if (pwt->chroma_log2_weight_denom > 7U) { 50 av_log(logctx, AV_LOG_ERROR, "chroma_log2_weight_denom %d is out of range\n", pwt->chroma_log2_weight_denom); 51 pwt->chroma_log2_weight_denom = 0; 52 } 53 chroma_def = 1 << pwt->chroma_log2_weight_denom; 54 } 55 56 for (list = 0; list < 2; list++) { 57 pwt->luma_weight_flag[list] = 0; 58 pwt->chroma_weight_flag[list] = 0; 59 for (i = 0; i < ref_count[list]; i++) { 60 int luma_weight_flag, chroma_weight_flag; 61 62 luma_weight_flag = get_bits1(gb); 63 if (luma_weight_flag) { 64 pwt->luma_weight[i][list][0] = get_se_golomb(gb); 65 pwt->luma_weight[i][list][1] = get_se_golomb(gb); 66 if ((int8_t)pwt->luma_weight[i][list][0] != pwt->luma_weight[i][list][0] || 67 (int8_t)pwt->luma_weight[i][list][1] != pwt->luma_weight[i][list][1]) 68 goto out_range_weight; 69 if (pwt->luma_weight[i][list][0] != luma_def || 70 pwt->luma_weight[i][list][1] != 0) { 71 pwt->use_weight = 1; 72 pwt->luma_weight_flag[list] = 1; 73 } 74 } else { 75 pwt->luma_weight[i][list][0] = luma_def; 76 pwt->luma_weight[i][list][1] = 0; 77 } 78 79 if (sps->chroma_format_idc) { 80 chroma_weight_flag = get_bits1(gb); 81 if (chroma_weight_flag) { 82 int j; 83 for (j = 0; j < 2; j++) { 84 pwt->chroma_weight[i][list][j][0] = get_se_golomb(gb); 85 pwt->chroma_weight[i][list][j][1] = get_se_golomb(gb); 86 if ((int8_t)pwt->chroma_weight[i][list][j][0] != pwt->chroma_weight[i][list][j][0] || 87 (int8_t)pwt->chroma_weight[i][list][j][1] != pwt->chroma_weight[i][list][j][1]) { 88 pwt->chroma_weight[i][list][j][0] = chroma_def; 89 pwt->chroma_weight[i][list][j][1] = 0; 90 goto out_range_weight; 91 } 92 if (pwt->chroma_weight[i][list][j][0] != chroma_def || 93 pwt->chroma_weight[i][list][j][1] != 0) { 94 pwt->use_weight_chroma = 1; 95 pwt->chroma_weight_flag[list] = 1; 96 } 97 } 98 } else { 99 int j; 100 for (j = 0; j < 2; j++) { 101 pwt->chroma_weight[i][list][j][0] = chroma_def; 102 pwt->chroma_weight[i][list][j][1] = 0; 103 } 104 } 105 } 106 107 // for MBAFF 108 if (picture_structure == PICT_FRAME) { 109 pwt->luma_weight[16 + 2 * i][list][0] = pwt->luma_weight[16 + 2 * i + 1][list][0] = pwt->luma_weight[i][list][0]; 110 pwt->luma_weight[16 + 2 * i][list][1] = pwt->luma_weight[16 + 2 * i + 1][list][1] = pwt->luma_weight[i][list][1]; 111 if (sps->chroma_format_idc) { 112 for (j = 0; j < 2; j++) { 113 pwt->chroma_weight[16 + 2 * i][list][j][0] = pwt->chroma_weight[16 + 2 * i + 1][list][j][0] = pwt->chroma_weight[i][list][j][0]; 114 pwt->chroma_weight[16 + 2 * i][list][j][1] = pwt->chroma_weight[16 + 2 * i + 1][list][j][1] = pwt->chroma_weight[i][list][j][1]; 115 } 116 } 117 } 118 } 119 if (slice_type_nos != AV_PICTURE_TYPE_B) 120 break; 121 } 122 pwt->use_weight = pwt->use_weight || pwt->use_weight_chroma; 123 return 0; 124out_range_weight: 125 avpriv_request_sample(logctx, "Out of range weight"); 126 return AVERROR_INVALIDDATA; 127} 128 129/** 130 * Check if the top & left blocks are available if needed and 131 * change the dc mode so it only uses the available blocks. 132 */ 133int ff_h264_check_intra4x4_pred_mode(int8_t *pred_mode_cache, void *logctx, 134 int top_samples_available, int left_samples_available) 135{ 136 static const int8_t top[12] = { 137 -1, 0, LEFT_DC_PRED, -1, -1, -1, -1, -1, 0 138 }; 139 static const int8_t left[12] = { 140 0, -1, TOP_DC_PRED, 0, -1, -1, -1, 0, -1, DC_128_PRED 141 }; 142 int i; 143 144 if (!(top_samples_available & 0x8000)) { 145 for (i = 0; i < 4; i++) { 146 int status = top[pred_mode_cache[scan8[0] + i]]; 147 if (status < 0) { 148 av_log(logctx, AV_LOG_ERROR, 149 "top block unavailable for requested intra mode %d\n", 150 status); 151 return AVERROR_INVALIDDATA; 152 } else if (status) { 153 pred_mode_cache[scan8[0] + i] = status; 154 } 155 } 156 } 157 158 if ((left_samples_available & 0x8888) != 0x8888) { 159 static const int mask[4] = { 0x8000, 0x2000, 0x80, 0x20 }; 160 for (i = 0; i < 4; i++) 161 if (!(left_samples_available & mask[i])) { 162 int status = left[pred_mode_cache[scan8[0] + 8 * i]]; 163 if (status < 0) { 164 av_log(logctx, AV_LOG_ERROR, 165 "left block unavailable for requested intra4x4 mode %d\n", 166 status); 167 return AVERROR_INVALIDDATA; 168 } else if (status) { 169 pred_mode_cache[scan8[0] + 8 * i] = status; 170 } 171 } 172 } 173 174 return 0; 175} 176 177/** 178 * Check if the top & left blocks are available if needed and 179 * change the dc mode so it only uses the available blocks. 180 */ 181int ff_h264_check_intra_pred_mode(void *logctx, int top_samples_available, 182 int left_samples_available, 183 int mode, int is_chroma) 184{ 185 static const int8_t top[4] = { LEFT_DC_PRED8x8, 1, -1, -1 }; 186 static const int8_t left[5] = { TOP_DC_PRED8x8, -1, 2, -1, DC_128_PRED8x8 }; 187 188 if (mode > 3U) { 189 av_log(logctx, AV_LOG_ERROR, 190 "out of range intra chroma pred mode\n"); 191 return AVERROR_INVALIDDATA; 192 } 193 194 if (!(top_samples_available & 0x8000)) { 195 mode = top[mode]; 196 if (mode < 0) { 197 av_log(logctx, AV_LOG_ERROR, 198 "top block unavailable for requested intra mode\n"); 199 return AVERROR_INVALIDDATA; 200 } 201 } 202 203 if ((left_samples_available & 0x8080) != 0x8080) { 204 mode = left[mode]; 205 if (mode < 0) { 206 av_log(logctx, AV_LOG_ERROR, 207 "left block unavailable for requested intra mode\n"); 208 return AVERROR_INVALIDDATA; 209 } 210 if (is_chroma && (left_samples_available & 0x8080)) { 211 // mad cow disease mode, aka MBAFF + constrained_intra_pred 212 mode = ALZHEIMER_DC_L0T_PRED8x8 + 213 (!(left_samples_available & 0x8000)) + 214 2 * (mode == DC_128_PRED8x8); 215 } 216 } 217 218 return mode; 219} 220 221int ff_h264_parse_ref_count(int *plist_count, int ref_count[2], 222 GetBitContext *gb, const PPS *pps, 223 int slice_type_nos, int picture_structure, void *logctx) 224{ 225 int list_count; 226 int num_ref_idx_active_override_flag; 227 228 // set defaults, might be overridden a few lines later 229 ref_count[0] = pps->ref_count[0]; 230 ref_count[1] = pps->ref_count[1]; 231 232 if (slice_type_nos != AV_PICTURE_TYPE_I) { 233 unsigned max[2]; 234 max[0] = max[1] = picture_structure == PICT_FRAME ? 15 : 31; 235 236 num_ref_idx_active_override_flag = get_bits1(gb); 237 238 if (num_ref_idx_active_override_flag) { 239 ref_count[0] = get_ue_golomb(gb) + 1; 240 if (slice_type_nos == AV_PICTURE_TYPE_B) { 241 ref_count[1] = get_ue_golomb(gb) + 1; 242 } else 243 // full range is spec-ok in this case, even for frames 244 ref_count[1] = 1; 245 } 246 247 if (slice_type_nos == AV_PICTURE_TYPE_B) 248 list_count = 2; 249 else 250 list_count = 1; 251 252 if (ref_count[0] - 1 > max[0] || (list_count == 2 && (ref_count[1] - 1 > max[1]))) { 253 av_log(logctx, AV_LOG_ERROR, "reference overflow %u > %u or %u > %u\n", 254 ref_count[0] - 1, max[0], ref_count[1] - 1, max[1]); 255 ref_count[0] = ref_count[1] = 0; 256 *plist_count = 0; 257 goto fail; 258 } else if (ref_count[1] - 1 > max[1]) { 259 av_log(logctx, AV_LOG_DEBUG, "reference overflow %u > %u \n", 260 ref_count[1] - 1, max[1]); 261 ref_count[1] = 0; 262 } 263 264 } else { 265 list_count = 0; 266 ref_count[0] = ref_count[1] = 0; 267 } 268 269 *plist_count = list_count; 270 271 return 0; 272fail: 273 *plist_count = 0; 274 ref_count[0] = 0; 275 ref_count[1] = 0; 276 return AVERROR_INVALIDDATA; 277} 278 279int ff_h264_init_poc(int pic_field_poc[2], int *pic_poc, 280 const SPS *sps, H264POCContext *pc, 281 int picture_structure, int nal_ref_idc) 282{ 283 const int max_frame_num = 1 << sps->log2_max_frame_num; 284 int64_t field_poc[2]; 285 286 pc->frame_num_offset = pc->prev_frame_num_offset; 287 if (pc->frame_num < pc->prev_frame_num) 288 pc->frame_num_offset += max_frame_num; 289 290 if (sps->poc_type == 0) { 291 const int max_poc_lsb = 1 << sps->log2_max_poc_lsb; 292 if (pc->prev_poc_lsb < 0) 293 pc->prev_poc_lsb = pc->poc_lsb; 294 295 if (pc->poc_lsb < pc->prev_poc_lsb && 296 pc->prev_poc_lsb - pc->poc_lsb >= max_poc_lsb / 2) 297 pc->poc_msb = pc->prev_poc_msb + max_poc_lsb; 298 else if (pc->poc_lsb > pc->prev_poc_lsb && 299 pc->prev_poc_lsb - pc->poc_lsb < -max_poc_lsb / 2) 300 pc->poc_msb = pc->prev_poc_msb - max_poc_lsb; 301 else 302 pc->poc_msb = pc->prev_poc_msb; 303 field_poc[0] = 304 field_poc[1] = pc->poc_msb + pc->poc_lsb; 305 if (picture_structure == PICT_FRAME) 306 field_poc[1] += pc->delta_poc_bottom; 307 } else if (sps->poc_type == 1) { 308 int abs_frame_num; 309 int64_t expected_delta_per_poc_cycle, expectedpoc; 310 int i; 311 312 if (sps->poc_cycle_length != 0) 313 abs_frame_num = pc->frame_num_offset + pc->frame_num; 314 else 315 abs_frame_num = 0; 316 317 if (nal_ref_idc == 0 && abs_frame_num > 0) 318 abs_frame_num--; 319 320 expected_delta_per_poc_cycle = 0; 321 for (i = 0; i < sps->poc_cycle_length; i++) 322 // FIXME integrate during sps parse 323 expected_delta_per_poc_cycle += sps->offset_for_ref_frame[i]; 324 325 if (abs_frame_num > 0) { 326 int poc_cycle_cnt = (abs_frame_num - 1) / sps->poc_cycle_length; 327 int frame_num_in_poc_cycle = (abs_frame_num - 1) % sps->poc_cycle_length; 328 329 expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle; 330 for (i = 0; i <= frame_num_in_poc_cycle; i++) 331 expectedpoc = expectedpoc + sps->offset_for_ref_frame[i]; 332 } else 333 expectedpoc = 0; 334 335 if (nal_ref_idc == 0) 336 expectedpoc = expectedpoc + sps->offset_for_non_ref_pic; 337 338 field_poc[0] = expectedpoc + pc->delta_poc[0]; 339 field_poc[1] = field_poc[0] + sps->offset_for_top_to_bottom_field; 340 341 if (picture_structure == PICT_FRAME) 342 field_poc[1] += pc->delta_poc[1]; 343 } else { 344 int poc = 2 * (pc->frame_num_offset + pc->frame_num); 345 346 if (!nal_ref_idc) 347 poc--; 348 349 field_poc[0] = poc; 350 field_poc[1] = poc; 351 } 352 353 if ( field_poc[0] != (int)field_poc[0] 354 || field_poc[1] != (int)field_poc[1]) 355 return AVERROR_INVALIDDATA; 356 357 if (picture_structure != PICT_BOTTOM_FIELD) 358 pic_field_poc[0] = field_poc[0]; 359 if (picture_structure != PICT_TOP_FIELD) 360 pic_field_poc[1] = field_poc[1]; 361 *pic_poc = FFMIN(pic_field_poc[0], pic_field_poc[1]); 362 363 return 0; 364} 365 366static int decode_extradata_ps(const uint8_t *data, int size, H264ParamSets *ps, 367 int is_avc, void *logctx) 368{ 369 H2645Packet pkt = { 0 }; 370 int i, ret = 0; 371 372 ret = ff_h2645_packet_split(&pkt, data, size, logctx, is_avc, 2, AV_CODEC_ID_H264, 1, 0); 373 if (ret < 0) { 374 ret = 0; 375 goto fail; 376 } 377 378 for (i = 0; i < pkt.nb_nals; i++) { 379 H2645NAL *nal = &pkt.nals[i]; 380 switch (nal->type) { 381 case H264_NAL_SPS: { 382 GetBitContext tmp_gb = nal->gb; 383 ret = ff_h264_decode_seq_parameter_set(&tmp_gb, logctx, ps, 0); 384 if (ret >= 0) 385 break; 386 av_log(logctx, AV_LOG_DEBUG, 387 "SPS decoding failure, trying again with the complete NAL\n"); 388 init_get_bits8(&tmp_gb, nal->raw_data + 1, nal->raw_size - 1); 389 ret = ff_h264_decode_seq_parameter_set(&tmp_gb, logctx, ps, 0); 390 if (ret >= 0) 391 break; 392 ret = ff_h264_decode_seq_parameter_set(&nal->gb, logctx, ps, 1); 393 if (ret < 0) 394 goto fail; 395 break; 396 } 397 case H264_NAL_PPS: 398 ret = ff_h264_decode_picture_parameter_set(&nal->gb, logctx, ps, 399 nal->size_bits); 400 if (ret < 0) 401 goto fail; 402 break; 403 default: 404 av_log(logctx, AV_LOG_VERBOSE, "Ignoring NAL type %d in extradata\n", 405 nal->type); 406 break; 407 } 408 } 409 410fail: 411 ff_h2645_packet_uninit(&pkt); 412 return ret; 413} 414 415/* There are (invalid) samples in the wild with mp4-style extradata, where the 416 * parameter sets are stored unescaped (i.e. as RBSP). 417 * This function catches the parameter set decoding failure and tries again 418 * after escaping it */ 419static int decode_extradata_ps_mp4(const uint8_t *buf, int buf_size, H264ParamSets *ps, 420 int err_recognition, void *logctx) 421{ 422 int ret; 423 424 ret = decode_extradata_ps(buf, buf_size, ps, 1, logctx); 425 if (ret < 0 && !(err_recognition & AV_EF_EXPLODE)) { 426 GetByteContext gbc; 427 PutByteContext pbc; 428 uint8_t *escaped_buf; 429 int escaped_buf_size; 430 431 av_log(logctx, AV_LOG_WARNING, 432 "SPS decoding failure, trying again after escaping the NAL\n"); 433 434 if (buf_size / 2 >= (INT16_MAX - AV_INPUT_BUFFER_PADDING_SIZE) / 3) 435 return AVERROR(ERANGE); 436 escaped_buf_size = buf_size * 3 / 2 + AV_INPUT_BUFFER_PADDING_SIZE; 437 escaped_buf = av_mallocz(escaped_buf_size); 438 if (!escaped_buf) 439 return AVERROR(ENOMEM); 440 441 bytestream2_init(&gbc, buf, buf_size); 442 bytestream2_init_writer(&pbc, escaped_buf, escaped_buf_size); 443 444 while (bytestream2_get_bytes_left(&gbc)) { 445 if (bytestream2_get_bytes_left(&gbc) >= 3 && 446 bytestream2_peek_be24(&gbc) <= 3) { 447 bytestream2_put_be24(&pbc, 3); 448 bytestream2_skip(&gbc, 2); 449 } else 450 bytestream2_put_byte(&pbc, bytestream2_get_byte(&gbc)); 451 } 452 453 escaped_buf_size = bytestream2_tell_p(&pbc); 454 AV_WB16(escaped_buf, escaped_buf_size - 2); 455 456 (void)decode_extradata_ps(escaped_buf, escaped_buf_size, ps, 1, logctx); 457 // lorex.mp4 decodes ok even with extradata decoding failing 458 av_freep(&escaped_buf); 459 } 460 461 return 0; 462} 463 464int ff_h264_decode_extradata(const uint8_t *data, int size, H264ParamSets *ps, 465 int *is_avc, int *nal_length_size, 466 int err_recognition, void *logctx) 467{ 468 int ret; 469 470 if (!data || size <= 0) 471 return -1; 472 473 if (data[0] == 1) { 474 int i, cnt, nalsize; 475 const uint8_t *p = data; 476 477 *is_avc = 1; 478 479 if (size < 7) { 480 av_log(logctx, AV_LOG_ERROR, "avcC %d too short\n", size); 481 return AVERROR_INVALIDDATA; 482 } 483 484 // Decode sps from avcC 485 cnt = *(p + 5) & 0x1f; // Number of sps 486 p += 6; 487 for (i = 0; i < cnt; i++) { 488 nalsize = AV_RB16(p) + 2; 489 if (nalsize > size - (p - data)) 490 return AVERROR_INVALIDDATA; 491 ret = decode_extradata_ps_mp4(p, nalsize, ps, err_recognition, logctx); 492 if (ret < 0) { 493 av_log(logctx, AV_LOG_ERROR, 494 "Decoding sps %d from avcC failed\n", i); 495 return ret; 496 } 497 p += nalsize; 498 } 499 // Decode pps from avcC 500 cnt = *(p++); // Number of pps 501 for (i = 0; i < cnt; i++) { 502 nalsize = AV_RB16(p) + 2; 503 if (nalsize > size - (p - data)) 504 return AVERROR_INVALIDDATA; 505 ret = decode_extradata_ps_mp4(p, nalsize, ps, err_recognition, logctx); 506 if (ret < 0) { 507 av_log(logctx, AV_LOG_ERROR, 508 "Decoding pps %d from avcC failed\n", i); 509 return ret; 510 } 511 p += nalsize; 512 } 513 // Store right nal length size that will be used to parse all other nals 514 *nal_length_size = (data[4] & 0x03) + 1; 515 } else { 516 *is_avc = 0; 517 ret = decode_extradata_ps(data, size, ps, 0, logctx); 518 if (ret < 0) 519 return ret; 520 } 521 return size; 522} 523 524/** 525 * Compute profile from profile_idc and constraint_set?_flags. 526 * 527 * @param sps SPS 528 * 529 * @return profile as defined by FF_PROFILE_H264_* 530 */ 531int ff_h264_get_profile(const SPS *sps) 532{ 533 int profile = sps->profile_idc; 534 535 switch (sps->profile_idc) { 536 case FF_PROFILE_H264_BASELINE: 537 // constraint_set1_flag set to 1 538 profile |= (sps->constraint_set_flags & 1 << 1) ? FF_PROFILE_H264_CONSTRAINED : 0; 539 break; 540 case FF_PROFILE_H264_HIGH_10: 541 case FF_PROFILE_H264_HIGH_422: 542 case FF_PROFILE_H264_HIGH_444_PREDICTIVE: 543 // constraint_set3_flag set to 1 544 profile |= (sps->constraint_set_flags & 1 << 3) ? FF_PROFILE_H264_INTRA : 0; 545 break; 546 } 547 548 return profile; 549} 550