1/* 2 * H.26L/H.264/AVC/JVT/14496-10/... decoder 3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at> 4 * 5 * This file is part of FFmpeg. 6 * 7 * FFmpeg is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Lesser General Public 9 * License as published by the Free Software Foundation; either 10 * version 2.1 of the License, or (at your option) any later version. 11 * 12 * FFmpeg is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with FFmpeg; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 */ 21 22/** 23 * @file 24 * H.264 / AVC / MPEG-4 part10 codec. 25 * @author Michael Niedermayer <michaelni@gmx.at> 26 */ 27 28#define UNCHECKED_BITSTREAM_READER 1 29 30#include "config_components.h" 31 32#include "libavutil/avassert.h" 33#include "libavutil/imgutils.h" 34#include "libavutil/opt.h" 35#include "libavutil/thread.h" 36#include "libavutil/video_enc_params.h" 37 38#include "codec_internal.h" 39#include "internal.h" 40#include "error_resilience.h" 41#include "avcodec.h" 42#include "h264.h" 43#include "h264dec.h" 44#include "h2645_parse.h" 45#include "h264data.h" 46#include "h264_ps.h" 47#include "golomb.h" 48#include "hwconfig.h" 49#include "mpegutils.h" 50#include "profiles.h" 51#include "rectangle.h" 52#include "thread.h" 53#include "threadframe.h" 54 55const uint16_t ff_h264_mb_sizes[4] = { 256, 384, 512, 768 }; 56 57int avpriv_h264_has_num_reorder_frames(AVCodecContext *avctx) 58{ 59 H264Context *h = avctx->priv_data; 60 return h && h->ps.sps ? h->ps.sps->num_reorder_frames : 0; 61} 62 63static void h264_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type, 64 int (*mv)[2][4][2], 65 int mb_x, int mb_y, int mb_intra, int mb_skipped) 66{ 67 H264Context *h = opaque; 68 H264SliceContext *sl = &h->slice_ctx[0]; 69 70 sl->mb_x = mb_x; 71 sl->mb_y = mb_y; 72 sl->mb_xy = mb_x + mb_y * h->mb_stride; 73 memset(sl->non_zero_count_cache, 0, sizeof(sl->non_zero_count_cache)); 74 av_assert1(ref >= 0); 75 /* FIXME: It is possible albeit uncommon that slice references 76 * differ between slices. We take the easy approach and ignore 77 * it for now. If this turns out to have any relevance in 78 * practice then correct remapping should be added. */ 79 if (ref >= sl->ref_count[0]) 80 ref = 0; 81 if (!sl->ref_list[0][ref].data[0]) { 82 av_log(h->avctx, AV_LOG_DEBUG, "Reference not available for error concealing\n"); 83 ref = 0; 84 } 85 if ((sl->ref_list[0][ref].reference&3) != 3) { 86 av_log(h->avctx, AV_LOG_DEBUG, "Reference invalid\n"); 87 return; 88 } 89 fill_rectangle(&h->cur_pic.ref_index[0][4 * sl->mb_xy], 90 2, 2, 2, ref, 1); 91 fill_rectangle(&sl->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1); 92 fill_rectangle(sl->mv_cache[0][scan8[0]], 4, 4, 8, 93 pack16to32((*mv)[0][0][0], (*mv)[0][0][1]), 4); 94 sl->mb_mbaff = 95 sl->mb_field_decoding_flag = 0; 96 ff_h264_hl_decode_mb(h, &h->slice_ctx[0]); 97} 98 99void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl, 100 int y, int height) 101{ 102 AVCodecContext *avctx = h->avctx; 103 const AVFrame *src = h->cur_pic.f; 104 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt); 105 int vshift = desc->log2_chroma_h; 106 const int field_pic = h->picture_structure != PICT_FRAME; 107 if (field_pic) { 108 height <<= 1; 109 y <<= 1; 110 } 111 112 height = FFMIN(height, avctx->height - y); 113 114 if (field_pic && h->first_field && !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) 115 return; 116 117 if (avctx->draw_horiz_band) { 118 int offset[AV_NUM_DATA_POINTERS]; 119 int i; 120 121 offset[0] = y * src->linesize[0]; 122 offset[1] = 123 offset[2] = (y >> vshift) * src->linesize[1]; 124 for (i = 3; i < AV_NUM_DATA_POINTERS; i++) 125 offset[i] = 0; 126 127 emms_c(); 128 129 avctx->draw_horiz_band(avctx, src, offset, 130 y, h->picture_structure, height); 131 } 132} 133 134void ff_h264_free_tables(H264Context *h) 135{ 136 int i; 137 138 av_freep(&h->intra4x4_pred_mode); 139 av_freep(&h->chroma_pred_mode_table); 140 av_freep(&h->cbp_table); 141 av_freep(&h->mvd_table[0]); 142 av_freep(&h->mvd_table[1]); 143 av_freep(&h->direct_table); 144 av_freep(&h->non_zero_count); 145 av_freep(&h->slice_table_base); 146 h->slice_table = NULL; 147 av_freep(&h->list_counts); 148 149 av_freep(&h->mb2b_xy); 150 av_freep(&h->mb2br_xy); 151 152 av_buffer_pool_uninit(&h->qscale_table_pool); 153 av_buffer_pool_uninit(&h->mb_type_pool); 154 av_buffer_pool_uninit(&h->motion_val_pool); 155 av_buffer_pool_uninit(&h->ref_index_pool); 156 157#if CONFIG_ERROR_RESILIENCE 158 av_freep(&h->er.mb_index2xy); 159 av_freep(&h->er.error_status_table); 160 av_freep(&h->er.er_temp_buffer); 161 av_freep(&h->dc_val_base); 162#endif 163 164 for (i = 0; i < h->nb_slice_ctx; i++) { 165 H264SliceContext *sl = &h->slice_ctx[i]; 166 167 av_freep(&sl->bipred_scratchpad); 168 av_freep(&sl->edge_emu_buffer); 169 av_freep(&sl->top_borders[0]); 170 av_freep(&sl->top_borders[1]); 171 172 sl->bipred_scratchpad_allocated = 0; 173 sl->edge_emu_buffer_allocated = 0; 174 sl->top_borders_allocated[0] = 0; 175 sl->top_borders_allocated[1] = 0; 176 } 177} 178 179int ff_h264_alloc_tables(H264Context *h) 180{ 181 ERContext *const er = &h->er; 182 const int big_mb_num = h->mb_stride * (h->mb_height + 1); 183 const int row_mb_num = 2*h->mb_stride*FFMAX(h->nb_slice_ctx, 1); 184 const int st_size = big_mb_num + h->mb_stride; 185 int x, y; 186 187 if (!FF_ALLOCZ_TYPED_ARRAY(h->intra4x4_pred_mode, row_mb_num * 8) || 188 !FF_ALLOCZ_TYPED_ARRAY(h->non_zero_count, big_mb_num) || 189 !FF_ALLOCZ_TYPED_ARRAY(h->slice_table_base, st_size) || 190 !FF_ALLOCZ_TYPED_ARRAY(h->cbp_table, big_mb_num) || 191 !FF_ALLOCZ_TYPED_ARRAY(h->chroma_pred_mode_table, big_mb_num) || 192 !FF_ALLOCZ_TYPED_ARRAY(h->mvd_table[0], row_mb_num * 8) || 193 !FF_ALLOCZ_TYPED_ARRAY(h->mvd_table[1], row_mb_num * 8) || 194 !FF_ALLOCZ_TYPED_ARRAY(h->direct_table, big_mb_num * 4) || 195 !FF_ALLOCZ_TYPED_ARRAY(h->list_counts, big_mb_num) || 196 !FF_ALLOCZ_TYPED_ARRAY(h->mb2b_xy, big_mb_num) || 197 !FF_ALLOCZ_TYPED_ARRAY(h->mb2br_xy, big_mb_num)) 198 return AVERROR(ENOMEM); 199 h->slice_ctx[0].intra4x4_pred_mode = h->intra4x4_pred_mode; 200 h->slice_ctx[0].mvd_table[0] = h->mvd_table[0]; 201 h->slice_ctx[0].mvd_table[1] = h->mvd_table[1]; 202 memset(h->slice_table_base, -1, 203 st_size * sizeof(*h->slice_table_base)); 204 h->slice_table = h->slice_table_base + h->mb_stride * 2 + 1; 205 for (y = 0; y < h->mb_height; y++) 206 for (x = 0; x < h->mb_width; x++) { 207 const int mb_xy = x + y * h->mb_stride; 208 const int b_xy = 4 * x + 4 * y * h->b_stride; 209 210 h->mb2b_xy[mb_xy] = b_xy; 211 h->mb2br_xy[mb_xy] = 8 * (FMO ? mb_xy : (mb_xy % (2 * h->mb_stride))); 212 } 213 214 if (CONFIG_ERROR_RESILIENCE) { 215 const int er_size = h->mb_height * h->mb_stride * (4*sizeof(int) + 1); 216 int mb_array_size = h->mb_height * h->mb_stride; 217 int y_size = (2 * h->mb_width + 1) * (2 * h->mb_height + 1); 218 int yc_size = y_size + 2 * big_mb_num; 219 220 /* init ER */ 221 er->avctx = h->avctx; 222 er->decode_mb = h264_er_decode_mb; 223 er->opaque = h; 224 er->quarter_sample = 1; 225 226 er->mb_num = h->mb_num; 227 er->mb_width = h->mb_width; 228 er->mb_height = h->mb_height; 229 er->mb_stride = h->mb_stride; 230 er->b8_stride = h->mb_width * 2 + 1; 231 232 // error resilience code looks cleaner with this 233 if (!FF_ALLOCZ_TYPED_ARRAY(er->mb_index2xy, h->mb_num + 1) || 234 !FF_ALLOCZ_TYPED_ARRAY(er->error_status_table, mb_array_size) || 235 !FF_ALLOCZ_TYPED_ARRAY(er->er_temp_buffer, er_size) || 236 !FF_ALLOCZ_TYPED_ARRAY(h->dc_val_base, yc_size)) 237 return AVERROR(ENOMEM); // ff_h264_free_tables will clean up for us 238 239 for (y = 0; y < h->mb_height; y++) 240 for (x = 0; x < h->mb_width; x++) 241 er->mb_index2xy[x + y * h->mb_width] = x + y * h->mb_stride; 242 243 er->mb_index2xy[h->mb_height * h->mb_width] = (h->mb_height - 1) * 244 h->mb_stride + h->mb_width; 245 er->dc_val[0] = h->dc_val_base + h->mb_width * 2 + 2; 246 er->dc_val[1] = h->dc_val_base + y_size + h->mb_stride + 1; 247 er->dc_val[2] = er->dc_val[1] + big_mb_num; 248 for (int i = 0; i < yc_size; i++) 249 h->dc_val_base[i] = 1024; 250 } 251 252 return 0; 253} 254 255/** 256 * Init slice context 257 */ 258void ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl) 259{ 260 sl->ref_cache[0][scan8[5] + 1] = 261 sl->ref_cache[0][scan8[7] + 1] = 262 sl->ref_cache[0][scan8[13] + 1] = 263 sl->ref_cache[1][scan8[5] + 1] = 264 sl->ref_cache[1][scan8[7] + 1] = 265 sl->ref_cache[1][scan8[13] + 1] = PART_NOT_AVAILABLE; 266 267 sl->er = &h->er; 268} 269 270static int h264_init_pic(H264Picture *pic) 271{ 272 pic->f = av_frame_alloc(); 273 if (!pic->f) 274 return AVERROR(ENOMEM); 275 276 pic->f_grain = av_frame_alloc(); 277 if (!pic->f_grain) 278 return AVERROR(ENOMEM); 279 280 return 0; 281} 282 283static int h264_init_context(AVCodecContext *avctx, H264Context *h) 284{ 285 int i, ret; 286 287 h->avctx = avctx; 288 h->cur_chroma_format_idc = -1; 289 290 h->width_from_caller = avctx->width; 291 h->height_from_caller = avctx->height; 292 293 h->workaround_bugs = avctx->workaround_bugs; 294 h->flags = avctx->flags; 295 h->poc.prev_poc_msb = 1 << 16; 296 h->recovery_frame = -1; 297 h->frame_recovered = 0; 298 h->poc.prev_frame_num = -1; 299 h->sei.frame_packing.arrangement_cancel_flag = -1; 300 h->sei.unregistered.x264_build = -1; 301 302 h->next_outputed_poc = INT_MIN; 303 for (i = 0; i < FF_ARRAY_ELEMS(h->last_pocs); i++) 304 h->last_pocs[i] = INT_MIN; 305 306 ff_h264_sei_uninit(&h->sei); 307 308 h->nb_slice_ctx = (avctx->active_thread_type & FF_THREAD_SLICE) ? avctx->thread_count : 1; 309 h->slice_ctx = av_calloc(h->nb_slice_ctx, sizeof(*h->slice_ctx)); 310 if (!h->slice_ctx) { 311 h->nb_slice_ctx = 0; 312 return AVERROR(ENOMEM); 313 } 314 315 for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) { 316 if ((ret = h264_init_pic(&h->DPB[i])) < 0) 317 return ret; 318 } 319 320 if ((ret = h264_init_pic(&h->cur_pic)) < 0) 321 return ret; 322 323 if ((ret = h264_init_pic(&h->last_pic_for_ec)) < 0) 324 return ret; 325 326 for (i = 0; i < h->nb_slice_ctx; i++) 327 h->slice_ctx[i].h264 = h; 328 329 return 0; 330} 331 332static void h264_free_pic(H264Context *h, H264Picture *pic) 333{ 334 ff_h264_unref_picture(h, pic); 335 av_frame_free(&pic->f); 336 av_frame_free(&pic->f_grain); 337} 338 339static av_cold int h264_decode_end(AVCodecContext *avctx) 340{ 341 H264Context *h = avctx->priv_data; 342 int i; 343 344 ff_h264_remove_all_refs(h); 345 ff_h264_free_tables(h); 346 347 for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) { 348 h264_free_pic(h, &h->DPB[i]); 349 } 350 memset(h->delayed_pic, 0, sizeof(h->delayed_pic)); 351 352 h->cur_pic_ptr = NULL; 353 354 av_freep(&h->slice_ctx); 355 h->nb_slice_ctx = 0; 356 357 ff_h264_sei_uninit(&h->sei); 358 ff_h264_ps_uninit(&h->ps); 359 360 ff_h2645_packet_uninit(&h->pkt); 361 362 h264_free_pic(h, &h->cur_pic); 363 h264_free_pic(h, &h->last_pic_for_ec); 364 365 return 0; 366} 367 368static AVOnce h264_vlc_init = AV_ONCE_INIT; 369 370static av_cold int h264_decode_init(AVCodecContext *avctx) 371{ 372 H264Context *h = avctx->priv_data; 373 int ret; 374 375 ret = h264_init_context(avctx, h); 376 if (ret < 0) 377 return ret; 378 379 ret = ff_thread_once(&h264_vlc_init, ff_h264_decode_init_vlc); 380 if (ret != 0) { 381 av_log(avctx, AV_LOG_ERROR, "pthread_once has failed."); 382 return AVERROR_UNKNOWN; 383 } 384 385 if (avctx->ticks_per_frame == 1) { 386 if(h->avctx->time_base.den < INT_MAX/2) { 387 h->avctx->time_base.den *= 2; 388 } else 389 h->avctx->time_base.num /= 2; 390 } 391 avctx->ticks_per_frame = 2; 392 393 if (!avctx->internal->is_copy) { 394 if (avctx->extradata_size > 0 && avctx->extradata) { 395 ret = ff_h264_decode_extradata(avctx->extradata, avctx->extradata_size, 396 &h->ps, &h->is_avc, &h->nal_length_size, 397 avctx->err_recognition, avctx); 398 if (ret < 0) { 399 int explode = avctx->err_recognition & AV_EF_EXPLODE; 400 av_log(avctx, explode ? AV_LOG_ERROR: AV_LOG_WARNING, 401 "Error decoding the extradata\n"); 402 if (explode) { 403 return ret; 404 } 405 ret = 0; 406 } 407 } 408 } 409 410 if (h->ps.sps && h->ps.sps->bitstream_restriction_flag && 411 h->avctx->has_b_frames < h->ps.sps->num_reorder_frames) { 412 h->avctx->has_b_frames = h->ps.sps->num_reorder_frames; 413 } 414 415 ff_h264_flush_change(h); 416 417 if (h->enable_er < 0 && (avctx->active_thread_type & FF_THREAD_SLICE)) 418 h->enable_er = 0; 419 420 if (h->enable_er && (avctx->active_thread_type & FF_THREAD_SLICE)) { 421 av_log(avctx, AV_LOG_WARNING, 422 "Error resilience with slice threads is enabled. It is unsafe and unsupported and may crash. " 423 "Use it at your own risk\n"); 424 } 425 426 return 0; 427} 428 429/** 430 * instantaneous decoder refresh. 431 */ 432static void idr(H264Context *h) 433{ 434 int i; 435 ff_h264_remove_all_refs(h); 436 h->poc.prev_frame_num = 437 h->poc.prev_frame_num_offset = 0; 438 h->poc.prev_poc_msb = 1<<16; 439 h->poc.prev_poc_lsb = -1; 440 for (i = 0; i < FF_ARRAY_ELEMS(h->last_pocs); i++) 441 h->last_pocs[i] = INT_MIN; 442} 443 444/* forget old pics after a seek */ 445void ff_h264_flush_change(H264Context *h) 446{ 447 int i, j; 448 449 h->next_outputed_poc = INT_MIN; 450 h->prev_interlaced_frame = 1; 451 idr(h); 452 453 h->poc.prev_frame_num = -1; 454 if (h->cur_pic_ptr) { 455 h->cur_pic_ptr->reference = 0; 456 for (j=i=0; h->delayed_pic[i]; i++) 457 if (h->delayed_pic[i] != h->cur_pic_ptr) 458 h->delayed_pic[j++] = h->delayed_pic[i]; 459 h->delayed_pic[j] = NULL; 460 } 461 ff_h264_unref_picture(h, &h->last_pic_for_ec); 462 463 h->first_field = 0; 464 h->recovery_frame = -1; 465 h->frame_recovered = 0; 466 h->current_slice = 0; 467 h->mmco_reset = 1; 468} 469 470static void h264_decode_flush(AVCodecContext *avctx) 471{ 472 H264Context *h = avctx->priv_data; 473 int i; 474 475 memset(h->delayed_pic, 0, sizeof(h->delayed_pic)); 476 477 ff_h264_flush_change(h); 478 ff_h264_sei_uninit(&h->sei); 479 480 for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) 481 ff_h264_unref_picture(h, &h->DPB[i]); 482 h->cur_pic_ptr = NULL; 483 ff_h264_unref_picture(h, &h->cur_pic); 484 485 h->mb_y = 0; 486 487 ff_h264_free_tables(h); 488 h->context_initialized = 0; 489} 490 491static int get_last_needed_nal(H264Context *h) 492{ 493 int nals_needed = 0; 494 int slice_type = 0; 495 int picture_intra_only = 1; 496 int first_slice = 0; 497 int i, ret; 498 499 for (i = 0; i < h->pkt.nb_nals; i++) { 500 H2645NAL *nal = &h->pkt.nals[i]; 501 GetBitContext gb; 502 503 /* packets can sometimes contain multiple PPS/SPS, 504 * e.g. two PAFF field pictures in one packet, or a demuxer 505 * which splits NALs strangely if so, when frame threading we 506 * can't start the next thread until we've read all of them */ 507 switch (nal->type) { 508 case H264_NAL_SPS: 509 case H264_NAL_PPS: 510 nals_needed = i; 511 break; 512 case H264_NAL_DPA: 513 case H264_NAL_IDR_SLICE: 514 case H264_NAL_SLICE: 515 ret = init_get_bits8(&gb, nal->data + 1, nal->size - 1); 516 if (ret < 0) { 517 av_log(h->avctx, AV_LOG_ERROR, "Invalid zero-sized VCL NAL unit\n"); 518 if (h->avctx->err_recognition & AV_EF_EXPLODE) 519 return ret; 520 521 break; 522 } 523 if (!get_ue_golomb_long(&gb) || // first_mb_in_slice 524 !first_slice || 525 first_slice != nal->type) 526 nals_needed = i; 527 slice_type = get_ue_golomb_31(&gb); 528 if (slice_type > 9) 529 slice_type = 0; 530 if (slice_type > 4) 531 slice_type -= 5; 532 533 slice_type = ff_h264_golomb_to_pict_type[slice_type]; 534 picture_intra_only &= (slice_type & 3) == AV_PICTURE_TYPE_I; 535 if (!first_slice) 536 first_slice = nal->type; 537 } 538 } 539 540 h->picture_intra_only = picture_intra_only; 541 542 return nals_needed; 543} 544 545static void debug_green_metadata(const H264SEIGreenMetaData *gm, void *logctx) 546{ 547 av_log(logctx, AV_LOG_DEBUG, "Green Metadata Info SEI message\n"); 548 av_log(logctx, AV_LOG_DEBUG, " green_metadata_type: %d\n", gm->green_metadata_type); 549 550 if (gm->green_metadata_type == 0) { 551 av_log(logctx, AV_LOG_DEBUG, " green_metadata_period_type: %d\n", gm->period_type); 552 553 if (gm->period_type == 2) 554 av_log(logctx, AV_LOG_DEBUG, " green_metadata_num_seconds: %d\n", gm->num_seconds); 555 else if (gm->period_type == 3) 556 av_log(logctx, AV_LOG_DEBUG, " green_metadata_num_pictures: %d\n", gm->num_pictures); 557 558 av_log(logctx, AV_LOG_DEBUG, " SEI GREEN Complexity Metrics: %f %f %f %f\n", 559 (float)gm->percent_non_zero_macroblocks/255, 560 (float)gm->percent_intra_coded_macroblocks/255, 561 (float)gm->percent_six_tap_filtering/255, 562 (float)gm->percent_alpha_point_deblocking_instance/255); 563 564 } else if (gm->green_metadata_type == 1) { 565 av_log(logctx, AV_LOG_DEBUG, " xsd_metric_type: %d\n", gm->xsd_metric_type); 566 567 if (gm->xsd_metric_type == 0) 568 av_log(logctx, AV_LOG_DEBUG, " xsd_metric_value: %f\n", 569 (float)gm->xsd_metric_value/100); 570 } 571} 572 573static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size) 574{ 575 AVCodecContext *const avctx = h->avctx; 576 int nals_needed = 0; ///< number of NALs that need decoding before the next frame thread starts 577 int idr_cleared=0; 578 int i, ret = 0; 579 580 h->has_slice = 0; 581 h->nal_unit_type= 0; 582 583 if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) { 584 h->current_slice = 0; 585 if (!h->first_field) { 586 h->cur_pic_ptr = NULL; 587 ff_h264_sei_uninit(&h->sei); 588 } 589 } 590 591 if (h->nal_length_size == 4) { 592 if (buf_size > 8 && AV_RB32(buf) == 1 && AV_RB32(buf+5) > (unsigned)buf_size) { 593 h->is_avc = 0; 594 }else if(buf_size > 3 && AV_RB32(buf) > 1 && AV_RB32(buf) <= (unsigned)buf_size) 595 h->is_avc = 1; 596 } 597 598 ret = ff_h2645_packet_split(&h->pkt, buf, buf_size, avctx, h->is_avc, h->nal_length_size, 599 avctx->codec_id, 0, 0); 600 if (ret < 0) { 601 av_log(avctx, AV_LOG_ERROR, 602 "Error splitting the input into NAL units.\n"); 603 return ret; 604 } 605 606 if (avctx->active_thread_type & FF_THREAD_FRAME) 607 nals_needed = get_last_needed_nal(h); 608 if (nals_needed < 0) 609 return nals_needed; 610 611 for (i = 0; i < h->pkt.nb_nals; i++) { 612 H2645NAL *nal = &h->pkt.nals[i]; 613 int max_slice_ctx, err; 614 615 if (avctx->skip_frame >= AVDISCARD_NONREF && 616 nal->ref_idc == 0 && nal->type != H264_NAL_SEI) 617 continue; 618 619 // FIXME these should stop being context-global variables 620 h->nal_ref_idc = nal->ref_idc; 621 h->nal_unit_type = nal->type; 622 623 err = 0; 624 switch (nal->type) { 625 case H264_NAL_IDR_SLICE: 626 if ((nal->data[1] & 0xFC) == 0x98) { 627 av_log(h->avctx, AV_LOG_ERROR, "Invalid inter IDR frame\n"); 628 h->next_outputed_poc = INT_MIN; 629 ret = -1; 630 goto end; 631 } 632 if(!idr_cleared) { 633 idr(h); // FIXME ensure we don't lose some frames if there is reordering 634 } 635 idr_cleared = 1; 636 h->has_recovery_point = 1; 637 case H264_NAL_SLICE: 638 h->has_slice = 1; 639 640 if ((err = ff_h264_queue_decode_slice(h, nal))) { 641 H264SliceContext *sl = h->slice_ctx + h->nb_slice_ctx_queued; 642 sl->ref_count[0] = sl->ref_count[1] = 0; 643 break; 644 } 645 646 if (h->current_slice == 1) { 647 if (avctx->active_thread_type & FF_THREAD_FRAME && 648 i >= nals_needed && !h->setup_finished && h->cur_pic_ptr) { 649 ff_thread_finish_setup(avctx); 650 h->setup_finished = 1; 651 } 652 653 if (h->avctx->hwaccel && 654 (ret = h->avctx->hwaccel->start_frame(h->avctx, buf, buf_size)) < 0) 655 goto end; 656 } 657 658 max_slice_ctx = avctx->hwaccel ? 1 : h->nb_slice_ctx; 659 if (h->nb_slice_ctx_queued == max_slice_ctx) { 660 if (h->avctx->hwaccel) { 661 ret = avctx->hwaccel->decode_slice(avctx, nal->raw_data, nal->raw_size); 662 h->nb_slice_ctx_queued = 0; 663 } else 664 ret = ff_h264_execute_decode_slices(h); 665 if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE)) 666 goto end; 667 } 668 break; 669 case H264_NAL_DPA: 670 case H264_NAL_DPB: 671 case H264_NAL_DPC: 672 avpriv_request_sample(avctx, "data partitioning"); 673 break; 674 case H264_NAL_SEI: 675 if (h->setup_finished) { 676 avpriv_request_sample(avctx, "Late SEI"); 677 break; 678 } 679 ret = ff_h264_sei_decode(&h->sei, &nal->gb, &h->ps, avctx); 680 h->has_recovery_point = h->has_recovery_point || h->sei.recovery_point.recovery_frame_cnt != -1; 681 if (avctx->debug & FF_DEBUG_GREEN_MD) 682 debug_green_metadata(&h->sei.green_metadata, h->avctx); 683 if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE)) 684 goto end; 685 break; 686 case H264_NAL_SPS: { 687 GetBitContext tmp_gb = nal->gb; 688 if (avctx->hwaccel && avctx->hwaccel->decode_params) { 689 ret = avctx->hwaccel->decode_params(avctx, 690 nal->type, 691 nal->raw_data, 692 nal->raw_size); 693 if (ret < 0) 694 goto end; 695 } 696 if (ff_h264_decode_seq_parameter_set(&tmp_gb, avctx, &h->ps, 0) >= 0) 697 break; 698 av_log(h->avctx, AV_LOG_DEBUG, 699 "SPS decoding failure, trying again with the complete NAL\n"); 700 init_get_bits8(&tmp_gb, nal->raw_data + 1, nal->raw_size - 1); 701 if (ff_h264_decode_seq_parameter_set(&tmp_gb, avctx, &h->ps, 0) >= 0) 702 break; 703 ff_h264_decode_seq_parameter_set(&nal->gb, avctx, &h->ps, 1); 704 break; 705 } 706 case H264_NAL_PPS: 707 if (avctx->hwaccel && avctx->hwaccel->decode_params) { 708 ret = avctx->hwaccel->decode_params(avctx, 709 nal->type, 710 nal->raw_data, 711 nal->raw_size); 712 if (ret < 0) 713 goto end; 714 } 715 ret = ff_h264_decode_picture_parameter_set(&nal->gb, avctx, &h->ps, 716 nal->size_bits); 717 if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE)) 718 goto end; 719 break; 720 case H264_NAL_AUD: 721 case H264_NAL_END_SEQUENCE: 722 case H264_NAL_END_STREAM: 723 case H264_NAL_FILLER_DATA: 724 case H264_NAL_SPS_EXT: 725 case H264_NAL_AUXILIARY_SLICE: 726 break; 727 default: 728 av_log(avctx, AV_LOG_DEBUG, "Unknown NAL code: %d (%d bits)\n", 729 nal->type, nal->size_bits); 730 } 731 732 if (err < 0) { 733 av_log(h->avctx, AV_LOG_ERROR, "decode_slice_header error\n"); 734 } 735 } 736 737 ret = ff_h264_execute_decode_slices(h); 738 if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE)) 739 goto end; 740 741 // set decode_error_flags to allow users to detect concealed decoding errors 742 if ((ret < 0 || h->er.error_occurred) && h->cur_pic_ptr) { 743 h->cur_pic_ptr->f->decode_error_flags |= FF_DECODE_ERROR_DECODE_SLICES; 744 } 745 746 ret = 0; 747end: 748 749#if CONFIG_ERROR_RESILIENCE 750 /* 751 * FIXME: Error handling code does not seem to support interlaced 752 * when slices span multiple rows 753 * The ff_er_add_slice calls don't work right for bottom 754 * fields; they cause massive erroneous error concealing 755 * Error marking covers both fields (top and bottom). 756 * This causes a mismatched s->error_count 757 * and a bad error table. Further, the error count goes to 758 * INT_MAX when called for bottom field, because mb_y is 759 * past end by one (callers fault) and resync_mb_y != 0 760 * causes problems for the first MB line, too. 761 */ 762 if (!FIELD_PICTURE(h) && h->current_slice && h->enable_er) { 763 764 H264SliceContext *sl = h->slice_ctx; 765 int use_last_pic = h->last_pic_for_ec.f->buf[0] && !sl->ref_count[0]; 766 767 ff_h264_set_erpic(&h->er.cur_pic, h->cur_pic_ptr); 768 769 if (use_last_pic) { 770 ff_h264_set_erpic(&h->er.last_pic, &h->last_pic_for_ec); 771 sl->ref_list[0][0].parent = &h->last_pic_for_ec; 772 memcpy(sl->ref_list[0][0].data, h->last_pic_for_ec.f->data, sizeof(sl->ref_list[0][0].data)); 773 memcpy(sl->ref_list[0][0].linesize, h->last_pic_for_ec.f->linesize, sizeof(sl->ref_list[0][0].linesize)); 774 sl->ref_list[0][0].reference = h->last_pic_for_ec.reference; 775 } else if (sl->ref_count[0]) { 776 ff_h264_set_erpic(&h->er.last_pic, sl->ref_list[0][0].parent); 777 } else 778 ff_h264_set_erpic(&h->er.last_pic, NULL); 779 780 if (sl->ref_count[1]) 781 ff_h264_set_erpic(&h->er.next_pic, sl->ref_list[1][0].parent); 782 783 ff_er_frame_end(&h->er); 784 if (use_last_pic) 785 memset(&sl->ref_list[0][0], 0, sizeof(sl->ref_list[0][0])); 786 } 787#endif /* CONFIG_ERROR_RESILIENCE */ 788 /* clean up */ 789 if (h->cur_pic_ptr && !h->droppable && h->has_slice) { 790 ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 791 h->picture_structure == PICT_BOTTOM_FIELD); 792 } 793 794 return (ret < 0) ? ret : buf_size; 795} 796 797/** 798 * Return the number of bytes consumed for building the current frame. 799 */ 800static int get_consumed_bytes(int pos, int buf_size) 801{ 802 if (pos == 0) 803 pos = 1; // avoid infinite loops (I doubt that is needed but...) 804 if (pos + 10 > buf_size) 805 pos = buf_size; // oops ;) 806 807 return pos; 808} 809 810static int h264_export_enc_params(AVFrame *f, H264Picture *p) 811{ 812 AVVideoEncParams *par; 813 unsigned int nb_mb = p->mb_height * p->mb_width; 814 unsigned int x, y; 815 816 par = av_video_enc_params_create_side_data(f, AV_VIDEO_ENC_PARAMS_H264, nb_mb); 817 if (!par) 818 return AVERROR(ENOMEM); 819 820 par->qp = p->pps->init_qp; 821 822 par->delta_qp[1][0] = p->pps->chroma_qp_index_offset[0]; 823 par->delta_qp[1][1] = p->pps->chroma_qp_index_offset[0]; 824 par->delta_qp[2][0] = p->pps->chroma_qp_index_offset[1]; 825 par->delta_qp[2][1] = p->pps->chroma_qp_index_offset[1]; 826 827 for (y = 0; y < p->mb_height; y++) 828 for (x = 0; x < p->mb_width; x++) { 829 const unsigned int block_idx = y * p->mb_width + x; 830 const unsigned int mb_xy = y * p->mb_stride + x; 831 AVVideoBlockParams *b = av_video_enc_params_block(par, block_idx); 832 833 b->src_x = x * 16; 834 b->src_y = y * 16; 835 b->w = 16; 836 b->h = 16; 837 838 b->delta_qp = p->qscale_table[mb_xy] - par->qp; 839 } 840 841 return 0; 842} 843 844static int output_frame(H264Context *h, AVFrame *dst, H264Picture *srcp) 845{ 846 int ret; 847 848 ret = av_frame_ref(dst, srcp->needs_fg ? srcp->f_grain : srcp->f); 849 if (ret < 0) 850 return ret; 851 852 if (srcp->needs_fg && (ret = av_frame_copy_props(dst, srcp->f)) < 0) 853 return ret; 854 855 av_dict_set(&dst->metadata, "stereo_mode", ff_h264_sei_stereo_mode(&h->sei.frame_packing), 0); 856 857 if (srcp->sei_recovery_frame_cnt == 0) 858 dst->key_frame = 1; 859 860 if (h->avctx->export_side_data & AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS) { 861 ret = h264_export_enc_params(dst, srcp); 862 if (ret < 0) 863 goto fail; 864 } 865 866 if (!(h->avctx->export_side_data & AV_CODEC_EXPORT_DATA_FILM_GRAIN)) 867 av_frame_remove_side_data(dst, AV_FRAME_DATA_FILM_GRAIN_PARAMS); 868 869 return 0; 870fail: 871 av_frame_unref(dst); 872 return ret; 873} 874 875static int is_avcc_extradata(const uint8_t *buf, int buf_size) 876{ 877 int cnt= buf[5]&0x1f; 878 const uint8_t *p= buf+6; 879 if (!cnt) 880 return 0; 881 while(cnt--){ 882 int nalsize= AV_RB16(p) + 2; 883 if(nalsize > buf_size - (p-buf) || (p[2] & 0x9F) != 7) 884 return 0; 885 p += nalsize; 886 } 887 cnt = *(p++); 888 if(!cnt) 889 return 0; 890 while(cnt--){ 891 int nalsize= AV_RB16(p) + 2; 892 if(nalsize > buf_size - (p-buf) || (p[2] & 0x9F) != 8) 893 return 0; 894 p += nalsize; 895 } 896 return 1; 897} 898 899static int finalize_frame(H264Context *h, AVFrame *dst, H264Picture *out, int *got_frame) 900{ 901 int ret; 902 903 if (((h->avctx->flags & AV_CODEC_FLAG_OUTPUT_CORRUPT) || 904 (h->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL) || 905 out->recovered)) { 906 907 if (!h->avctx->hwaccel && 908 (out->field_poc[0] == INT_MAX || 909 out->field_poc[1] == INT_MAX) 910 ) { 911 int p; 912 AVFrame *f = out->f; 913 int field = out->field_poc[0] == INT_MAX; 914 uint8_t *dst_data[4]; 915 int linesizes[4]; 916 const uint8_t *src_data[4]; 917 918 av_log(h->avctx, AV_LOG_DEBUG, "Duplicating field %d to fill missing\n", field); 919 920 for (p = 0; p<4; p++) { 921 dst_data[p] = f->data[p] + (field^1)*f->linesize[p]; 922 src_data[p] = f->data[p] + field *f->linesize[p]; 923 linesizes[p] = 2*f->linesize[p]; 924 } 925 926 av_image_copy(dst_data, linesizes, src_data, linesizes, 927 f->format, f->width, f->height>>1); 928 } 929 930 ret = output_frame(h, dst, out); 931 if (ret < 0) 932 return ret; 933 934 *got_frame = 1; 935 936 if (CONFIG_MPEGVIDEODEC) { 937 ff_print_debug_info2(h->avctx, dst, NULL, 938 out->mb_type, 939 out->qscale_table, 940 out->motion_val, 941 out->mb_width, out->mb_height, out->mb_stride, 1); 942 } 943 } 944 945 return 0; 946} 947 948static int send_next_delayed_frame(H264Context *h, AVFrame *dst_frame, 949 int *got_frame, int buf_index) 950{ 951 int ret, i, out_idx; 952 H264Picture *out = h->delayed_pic[0]; 953 954 h->cur_pic_ptr = NULL; 955 h->first_field = 0; 956 957 out_idx = 0; 958 for (i = 1; 959 h->delayed_pic[i] && 960 !h->delayed_pic[i]->f->key_frame && 961 !h->delayed_pic[i]->mmco_reset; 962 i++) 963 if (h->delayed_pic[i]->poc < out->poc) { 964 out = h->delayed_pic[i]; 965 out_idx = i; 966 } 967 968 for (i = out_idx; h->delayed_pic[i]; i++) 969 h->delayed_pic[i] = h->delayed_pic[i + 1]; 970 971 if (out) { 972 out->reference &= ~DELAYED_PIC_REF; 973 ret = finalize_frame(h, dst_frame, out, got_frame); 974 if (ret < 0) 975 return ret; 976 } 977 978 return buf_index; 979} 980 981static int h264_decode_frame(AVCodecContext *avctx, AVFrame *pict, 982 int *got_frame, AVPacket *avpkt) 983{ 984 const uint8_t *buf = avpkt->data; 985 int buf_size = avpkt->size; 986 H264Context *h = avctx->priv_data; 987 int buf_index; 988 int ret; 989 990 h->flags = avctx->flags; 991 h->setup_finished = 0; 992 h->nb_slice_ctx_queued = 0; 993 994 ff_h264_unref_picture(h, &h->last_pic_for_ec); 995 996 /* end of stream, output what is still in the buffers */ 997 if (buf_size == 0) 998 return send_next_delayed_frame(h, pict, got_frame, 0); 999 1000 if (av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, NULL)) { 1001 size_t side_size; 1002 uint8_t *side = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size); 1003 ff_h264_decode_extradata(side, side_size, 1004 &h->ps, &h->is_avc, &h->nal_length_size, 1005 avctx->err_recognition, avctx); 1006 } 1007 if (h->is_avc && buf_size >= 9 && buf[0]==1 && buf[2]==0 && (buf[4]&0xFC)==0xFC) { 1008 if (is_avcc_extradata(buf, buf_size)) 1009 return ff_h264_decode_extradata(buf, buf_size, 1010 &h->ps, &h->is_avc, &h->nal_length_size, 1011 avctx->err_recognition, avctx); 1012 } 1013 1014 buf_index = decode_nal_units(h, buf, buf_size); 1015 if (buf_index < 0) 1016 return AVERROR_INVALIDDATA; 1017 1018 if (!h->cur_pic_ptr && h->nal_unit_type == H264_NAL_END_SEQUENCE) { 1019 av_assert0(buf_index <= buf_size); 1020 return send_next_delayed_frame(h, pict, got_frame, buf_index); 1021 } 1022 1023 if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS) && (!h->cur_pic_ptr || !h->has_slice)) { 1024 if (avctx->skip_frame >= AVDISCARD_NONREF || 1025 buf_size >= 4 && !memcmp("Q264", buf, 4)) 1026 return buf_size; 1027 av_log(avctx, AV_LOG_ERROR, "no frame!\n"); 1028 return AVERROR_INVALIDDATA; 1029 } 1030 1031 if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS) || 1032 (h->mb_y >= h->mb_height && h->mb_height)) { 1033 if ((ret = ff_h264_field_end(h, &h->slice_ctx[0], 0)) < 0) 1034 return ret; 1035 1036 /* Wait for second field. */ 1037 if (h->next_output_pic) { 1038 ret = finalize_frame(h, pict, h->next_output_pic, got_frame); 1039 if (ret < 0) 1040 return ret; 1041 } 1042 } 1043 1044 av_assert0(pict->buf[0] || !*got_frame); 1045 1046 ff_h264_unref_picture(h, &h->last_pic_for_ec); 1047 1048 return get_consumed_bytes(buf_index, buf_size); 1049} 1050 1051#define OFFSET(x) offsetof(H264Context, x) 1052#define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM 1053#define VDX VD | AV_OPT_FLAG_EXPORT 1054static const AVOption h264_options[] = { 1055 { "is_avc", "is avc", OFFSET(is_avc), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, VDX }, 1056 { "nal_length_size", "nal_length_size", OFFSET(nal_length_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 4, VDX }, 1057 { "enable_er", "Enable error resilience on damaged frames (unsafe)", OFFSET(enable_er), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VD }, 1058 { "x264_build", "Assume this x264 version if no x264 version found in any SEI", OFFSET(x264_build), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VD }, 1059 { NULL }, 1060}; 1061 1062static const AVClass h264_class = { 1063 .class_name = "H264 Decoder", 1064 .item_name = av_default_item_name, 1065 .option = h264_options, 1066 .version = LIBAVUTIL_VERSION_INT, 1067}; 1068 1069const FFCodec ff_h264_decoder = { 1070 .p.name = "h264", 1071 .p.long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"), 1072 .p.type = AVMEDIA_TYPE_VIDEO, 1073 .p.id = AV_CODEC_ID_H264, 1074 .priv_data_size = sizeof(H264Context), 1075 .init = h264_decode_init, 1076 .close = h264_decode_end, 1077 FF_CODEC_DECODE_CB(h264_decode_frame), 1078 .p.capabilities = /*AV_CODEC_CAP_DRAW_HORIZ_BAND |*/ AV_CODEC_CAP_DR1 | 1079 AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS | 1080 AV_CODEC_CAP_FRAME_THREADS, 1081 .hw_configs = (const AVCodecHWConfigInternal *const []) { 1082#if CONFIG_H264_DXVA2_HWACCEL 1083 HWACCEL_DXVA2(h264), 1084#endif 1085#if CONFIG_H264_D3D11VA_HWACCEL 1086 HWACCEL_D3D11VA(h264), 1087#endif 1088#if CONFIG_H264_D3D11VA2_HWACCEL 1089 HWACCEL_D3D11VA2(h264), 1090#endif 1091#if CONFIG_H264_NVDEC_HWACCEL 1092 HWACCEL_NVDEC(h264), 1093#endif 1094#if CONFIG_H264_VAAPI_HWACCEL 1095 HWACCEL_VAAPI(h264), 1096#endif 1097#if CONFIG_H264_VDPAU_HWACCEL 1098 HWACCEL_VDPAU(h264), 1099#endif 1100#if CONFIG_H264_VIDEOTOOLBOX_HWACCEL 1101 HWACCEL_VIDEOTOOLBOX(h264), 1102#endif 1103 NULL 1104 }, 1105 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_EXPORTS_CROPPING | 1106 FF_CODEC_CAP_ALLOCATE_PROGRESS | FF_CODEC_CAP_INIT_CLEANUP, 1107 .flush = h264_decode_flush, 1108 .update_thread_context = ONLY_IF_THREADS_ENABLED(ff_h264_update_thread_context), 1109 .update_thread_context_for_user = ONLY_IF_THREADS_ENABLED(ff_h264_update_thread_context_for_user), 1110 .p.profiles = NULL_IF_CONFIG_SMALL(ff_h264_profiles), 1111 .p.priv_class = &h264_class, 1112}; 1113