X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fh264.c;h=18e5a4dd8b94cefa8ad5a3e03aff06fe310053f4;hb=d8151a7e944aea52d167571badc247c8d9972847;hp=6272f6f781f7fd10635dcf998f4b2e7d12d72ea4;hpb=6abd1e901c065280d50adbbf95eb54773870328c;p=ffmpeg diff --git a/libavcodec/h264.c b/libavcodec/h264.c index 6272f6f781f..18e5a4dd8b9 100644 --- a/libavcodec/h264.c +++ b/libavcodec/h264.c @@ -64,41 +64,42 @@ static void h264_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type, int mb_x, int mb_y, int mb_intra, int mb_skipped) { H264Context *h = opaque; + H264SliceContext *sl = &h->slice_ctx[0]; - h->mb_x = mb_x; - h->mb_y = mb_y; - h->mb_xy = mb_x + mb_y * h->mb_stride; - memset(h->non_zero_count_cache, 0, sizeof(h->non_zero_count_cache)); + sl->mb_x = mb_x; + sl->mb_y = mb_y; + sl->mb_xy = mb_x + mb_y * h->mb_stride; + memset(sl->non_zero_count_cache, 0, sizeof(sl->non_zero_count_cache)); av_assert1(ref >= 0); /* FIXME: It is possible albeit uncommon that slice references * differ between slices. We take the easy approach and ignore * it for now. If this turns out to have any relevance in * practice then correct remapping should be added. */ - if (ref >= h->ref_count[0]) + if (ref >= sl->ref_count[0]) ref = 0; - if (!h->ref_list[0][ref].f.data[0]) { + if (!sl->ref_list[0][ref].data[0]) { av_log(h->avctx, AV_LOG_DEBUG, "Reference not available for error concealing\n"); ref = 0; } - if ((h->ref_list[0][ref].reference&3) != 3) { + if ((sl->ref_list[0][ref].reference&3) != 3) { av_log(h->avctx, AV_LOG_DEBUG, "Reference invalid\n"); return; } - fill_rectangle(&h->cur_pic.ref_index[0][4 * h->mb_xy], + fill_rectangle(&h->cur_pic.ref_index[0][4 * sl->mb_xy], 2, 2, 2, ref, 1); - fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1); - fill_rectangle(h->mv_cache[0][scan8[0]], 4, 4, 8, + fill_rectangle(&sl->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1); + fill_rectangle(sl->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32((*mv)[0][0][0], (*mv)[0][0][1]), 4); - h->mb_mbaff = - h->mb_field_decoding_flag = 0; + sl->mb_mbaff = + sl->mb_field_decoding_flag = 0; ff_h264_hl_decode_mb(h, &h->slice_ctx[0]); } -void ff_h264_draw_horiz_band(H264Context *h, int y, int height) +void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl, + int y, int height) { AVCodecContext *avctx = h->avctx; - AVFrame *cur = &h->cur_pic.f; - AVFrame *last = h->ref_list[0][0].f.data[0] ? &h->ref_list[0][0].f : NULL; + const AVFrame *src = &h->cur_pic.f; const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt); int vshift = desc->log2_chroma_h; const int field_pic = h->picture_structure != PICT_FRAME; @@ -113,18 +114,9 @@ void ff_h264_draw_horiz_band(H264Context *h, int y, int height) return; if (avctx->draw_horiz_band) { - AVFrame *src; int offset[AV_NUM_DATA_POINTERS]; int i; - if (cur->pict_type == AV_PICTURE_TYPE_B || h->low_delay || - (avctx->slice_flags & SLICE_FLAG_CODED_ORDER)) - src = cur; - else if (last) - src = last; - else - return; - offset[0] = y * src->linesize[0]; offset[1] = offset[2] = (y >> vshift) * src->linesize[1]; @@ -142,7 +134,7 @@ void ff_h264_draw_horiz_band(H264Context *h, int y, int height) * Check if the top & left blocks are available if needed and * change the dc mode so it only uses the available blocks. */ -int ff_h264_check_intra4x4_pred_mode(H264Context *h, H264SliceContext *sl) +int ff_h264_check_intra4x4_pred_mode(const H264Context *h, H264SliceContext *sl) { static const int8_t top[12] = { -1, 0, LEFT_DC_PRED, -1, -1, -1, -1, -1, 0 @@ -152,13 +144,13 @@ int ff_h264_check_intra4x4_pred_mode(H264Context *h, H264SliceContext *sl) }; int i; - if (!(h->top_samples_available & 0x8000)) { + if (!(sl->top_samples_available & 0x8000)) { for (i = 0; i < 4; i++) { int status = top[sl->intra4x4_pred_mode_cache[scan8[0] + i]]; if (status < 0) { av_log(h->avctx, AV_LOG_ERROR, "top block unavailable for requested intra4x4 mode %d at %d %d\n", - status, h->mb_x, h->mb_y); + status, sl->mb_x, sl->mb_y); return AVERROR_INVALIDDATA; } else if (status) { sl->intra4x4_pred_mode_cache[scan8[0] + i] = status; @@ -166,15 +158,15 @@ int ff_h264_check_intra4x4_pred_mode(H264Context *h, H264SliceContext *sl) } } - if ((h->left_samples_available & 0x8888) != 0x8888) { + if ((sl->left_samples_available & 0x8888) != 0x8888) { static const int mask[4] = { 0x8000, 0x2000, 0x80, 0x20 }; for (i = 0; i < 4; i++) - if (!(h->left_samples_available & mask[i])) { + if (!(sl->left_samples_available & mask[i])) { int status = left[sl->intra4x4_pred_mode_cache[scan8[0] + 8 * i]]; if (status < 0) { av_log(h->avctx, AV_LOG_ERROR, "left block unavailable for requested intra4x4 mode %d at %d %d\n", - status, h->mb_x, h->mb_y); + status, sl->mb_x, sl->mb_y); return AVERROR_INVALIDDATA; } else if (status) { sl->intra4x4_pred_mode_cache[scan8[0] + 8 * i] = status; @@ -189,7 +181,8 @@ int ff_h264_check_intra4x4_pred_mode(H264Context *h, H264SliceContext *sl) * Check if the top & left blocks are available if needed and * change the dc mode so it only uses the available blocks. */ -int ff_h264_check_intra_pred_mode(H264Context *h, int mode, int is_chroma) +int ff_h264_check_intra_pred_mode(const H264Context *h, H264SliceContext *sl, + int mode, int is_chroma) { static const int8_t top[4] = { LEFT_DC_PRED8x8, 1, -1, -1 }; static const int8_t left[5] = { TOP_DC_PRED8x8, -1, 2, -1, DC_128_PRED8x8 }; @@ -197,32 +190,32 @@ int ff_h264_check_intra_pred_mode(H264Context *h, int mode, int is_chroma) if (mode > 3U) { av_log(h->avctx, AV_LOG_ERROR, "out of range intra chroma pred mode at %d %d\n", - h->mb_x, h->mb_y); + sl->mb_x, sl->mb_y); return AVERROR_INVALIDDATA; } - if (!(h->top_samples_available & 0x8000)) { + if (!(sl->top_samples_available & 0x8000)) { mode = top[mode]; if (mode < 0) { av_log(h->avctx, AV_LOG_ERROR, "top block unavailable for requested intra mode at %d %d\n", - h->mb_x, h->mb_y); + sl->mb_x, sl->mb_y); return AVERROR_INVALIDDATA; } } - if ((h->left_samples_available & 0x8080) != 0x8080) { + if ((sl->left_samples_available & 0x8080) != 0x8080) { mode = left[mode]; if (mode < 0) { av_log(h->avctx, AV_LOG_ERROR, "left block unavailable for requested intra mode at %d %d\n", - h->mb_x, h->mb_y); + sl->mb_x, sl->mb_y); return AVERROR_INVALIDDATA; } - if (is_chroma && (h->left_samples_available & 0x8080)) { + if (is_chroma && (sl->left_samples_available & 0x8080)) { // mad cow disease mode, aka MBAFF + constrained_intra_pred mode = ALZHEIMER_DC_L0T_PRED8x8 + - (!(h->left_samples_available & 0x8000)) + + (!(sl->left_samples_available & 0x8000)) + 2 * (mode == DC_128_PRED8x8); } } @@ -230,12 +223,12 @@ int ff_h264_check_intra_pred_mode(H264Context *h, int mode, int is_chroma) return mode; } -const uint8_t *ff_h264_decode_nal(H264Context *h, const uint8_t *src, +const uint8_t *ff_h264_decode_nal(H264Context *h, H264SliceContext *sl, + const uint8_t *src, int *dst_length, int *consumed, int length) { int i, si, di; uint8_t *dst; - int bufidx; // src[0]&0x80; // forbidden bit h->nal_ref_idc = src[0] >> 5; @@ -291,11 +284,8 @@ const uint8_t *ff_h264_decode_nal(H264Context *h, const uint8_t *src, } #endif - // use second escape buffer for inter data - bufidx = h->nal_unit_type == NAL_DPC ? 1 : 0; - - av_fast_padded_malloc(&h->rbsp_buffer[bufidx], &h->rbsp_buffer_size[bufidx], length+MAX_MBPAIR_SIZE); - dst = h->rbsp_buffer[bufidx]; + av_fast_padded_malloc(&sl->rbsp_buffer, &sl->rbsp_buffer_size, length+MAX_MBPAIR_SIZE); + dst = sl->rbsp_buffer; if (!dst) return NULL; @@ -365,7 +355,6 @@ static int decode_rbsp_trailing(H264Context *h, const uint8_t *src) void ff_h264_free_tables(H264Context *h, int free_rbsp) { int i; - H264Context *hx; av_freep(&h->intra4x4_pred_mode); av_freep(&h->chroma_pred_mode_table); @@ -398,29 +387,28 @@ void ff_h264_free_tables(H264Context *h, int free_rbsp) h->cur_pic_ptr = NULL; - for (i = 0; i < H264_MAX_THREADS; i++) { - hx = h->thread_context[i]; - if (!hx) - continue; - av_freep(&hx->top_borders[1]); - av_freep(&hx->top_borders[0]); - av_freep(&hx->bipred_scratchpad); - av_freep(&hx->edge_emu_buffer); - av_freep(&hx->dc_val_base); - av_freep(&hx->er.mb_index2xy); - av_freep(&hx->er.error_status_table); - av_freep(&hx->er.er_temp_buffer); - av_freep(&hx->er.mbintra_table); - av_freep(&hx->er.mbskip_table); + for (i = 0; i < h->nb_slice_ctx; i++) { + H264SliceContext *sl = &h->slice_ctx[i]; + + av_freep(&sl->dc_val_base); + av_freep(&sl->er.mb_index2xy); + av_freep(&sl->er.error_status_table); + av_freep(&sl->er.er_temp_buffer); + + av_freep(&sl->bipred_scratchpad); + av_freep(&sl->edge_emu_buffer); + av_freep(&sl->top_borders[0]); + av_freep(&sl->top_borders[1]); + + sl->bipred_scratchpad_allocated = 0; + sl->edge_emu_buffer_allocated = 0; + sl->top_borders_allocated[0] = 0; + sl->top_borders_allocated[1] = 0; if (free_rbsp) { - av_freep(&hx->rbsp_buffer[1]); - av_freep(&hx->rbsp_buffer[0]); - hx->rbsp_buffer_size[0] = 0; - hx->rbsp_buffer_size[1] = 0; + av_freep(&sl->rbsp_buffer); + sl->rbsp_buffer_size = 0; } - if (i) - av_freep(&h->thread_context[i]); } } @@ -446,6 +434,9 @@ int ff_h264_alloc_tables(H264Context *h) row_mb_num, 16 * sizeof(uint8_t), fail); FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->mvd_table[1], row_mb_num, 16 * sizeof(uint8_t), fail); + h->slice_ctx[0].mvd_table[0] = h->mvd_table[0]; + h->slice_ctx[0].mvd_table[1] = h->mvd_table[1]; + FF_ALLOCZ_OR_GOTO(h->avctx, h->direct_table, 4 * big_mb_num * sizeof(uint8_t), fail); FF_ALLOCZ_OR_GOTO(h->avctx, h->list_counts, @@ -491,26 +482,21 @@ fail: * Init context * Allocate buffers which are not shared amongst multiple threads. */ -int ff_h264_context_init(H264Context *h) +int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl) { - ERContext *er = &h->er; + ERContext *er = &sl->er; int mb_array_size = h->mb_height * h->mb_stride; int y_size = (2 * h->mb_width + 1) * (2 * h->mb_height + 1); int c_size = h->mb_stride * (h->mb_height + 1); int yc_size = y_size + 2 * c_size; int x, y, i; - FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->top_borders[0], - h->mb_width, 16 * 3 * sizeof(uint8_t) * 2, fail) - FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->top_borders[1], - h->mb_width, 16 * 3 * sizeof(uint8_t) * 2, fail) - - h->ref_cache[0][scan8[5] + 1] = - h->ref_cache[0][scan8[7] + 1] = - h->ref_cache[0][scan8[13] + 1] = - h->ref_cache[1][scan8[5] + 1] = - h->ref_cache[1][scan8[7] + 1] = - h->ref_cache[1][scan8[13] + 1] = PART_NOT_AVAILABLE; + sl->ref_cache[0][scan8[5] + 1] = + sl->ref_cache[0][scan8[7] + 1] = + sl->ref_cache[0][scan8[13] + 1] = + sl->ref_cache[1][scan8[5] + 1] = + sl->ref_cache[1][scan8[7] + 1] = + sl->ref_cache[1][scan8[13] + 1] = PART_NOT_AVAILABLE; if (CONFIG_ERROR_RESILIENCE) { /* init ER */ @@ -539,21 +525,16 @@ int ff_h264_context_init(H264Context *h) FF_ALLOCZ_OR_GOTO(h->avctx, er->error_status_table, mb_array_size * sizeof(uint8_t), fail); - FF_ALLOC_OR_GOTO(h->avctx, er->mbintra_table, mb_array_size, fail); - memset(er->mbintra_table, 1, mb_array_size); - - FF_ALLOCZ_OR_GOTO(h->avctx, er->mbskip_table, mb_array_size + 2, fail); - FF_ALLOC_OR_GOTO(h->avctx, er->er_temp_buffer, h->mb_height * h->mb_stride, fail); - FF_ALLOCZ_OR_GOTO(h->avctx, h->dc_val_base, + FF_ALLOCZ_OR_GOTO(h->avctx, sl->dc_val_base, yc_size * sizeof(int16_t), fail); - er->dc_val[0] = h->dc_val_base + h->mb_width * 2 + 2; - er->dc_val[1] = h->dc_val_base + y_size + h->mb_stride + 1; + er->dc_val[0] = sl->dc_val_base + h->mb_width * 2 + 2; + er->dc_val[1] = sl->dc_val_base + y_size + h->mb_stride + 1; er->dc_val[2] = er->dc_val[1] + c_size; for (i = 0; i < yc_size; i++) - h->dc_val_base[i] = 1024; + sl->dc_val_base[i] = 1024; } return 0; @@ -682,9 +663,8 @@ av_cold int ff_h264_decode_init(AVCodecContext *avctx) return AVERROR(ENOMEM); } - h->thread_context[0] = h; for (i = 0; i < h->nb_slice_ctx; i++) - h->slice_ctx[i].h264 = h->thread_context[0]; + h->slice_ctx[i].h264 = h; h->outputed_poc = h->next_outputed_poc = INT_MIN; for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++) @@ -746,10 +726,6 @@ static int decode_init_thread_copy(AVCodecContext *avctx) h->slice_ctx[i].h264 = h; h->avctx = avctx; - h->rbsp_buffer[0] = NULL; - h->rbsp_buffer[1] = NULL; - h->rbsp_buffer_size[0] = 0; - h->rbsp_buffer_size[1] = 0; h->context_initialized = 0; return 0; @@ -1010,9 +986,9 @@ int ff_pred_weight_table(H264Context *h, H264SliceContext *sl) sl->use_weight = 0; sl->use_weight_chroma = 0; - sl->luma_log2_weight_denom = get_ue_golomb(&h->gb); + sl->luma_log2_weight_denom = get_ue_golomb(&sl->gb); if (h->sps.chroma_format_idc) - sl->chroma_log2_weight_denom = get_ue_golomb(&h->gb); + sl->chroma_log2_weight_denom = get_ue_golomb(&sl->gb); if (sl->luma_log2_weight_denom > 7U) { av_log(h->avctx, AV_LOG_ERROR, "luma_log2_weight_denom %d is out of range\n", sl->luma_log2_weight_denom); @@ -1029,13 +1005,13 @@ int ff_pred_weight_table(H264Context *h, H264SliceContext *sl) for (list = 0; list < 2; list++) { sl->luma_weight_flag[list] = 0; sl->chroma_weight_flag[list] = 0; - for (i = 0; i < h->ref_count[list]; i++) { + for (i = 0; i < sl->ref_count[list]; i++) { int luma_weight_flag, chroma_weight_flag; - luma_weight_flag = get_bits1(&h->gb); + luma_weight_flag = get_bits1(&sl->gb); if (luma_weight_flag) { - sl->luma_weight[i][list][0] = get_se_golomb(&h->gb); - sl->luma_weight[i][list][1] = get_se_golomb(&h->gb); + sl->luma_weight[i][list][0] = get_se_golomb(&sl->gb); + sl->luma_weight[i][list][1] = get_se_golomb(&sl->gb); if (sl->luma_weight[i][list][0] != luma_def || sl->luma_weight[i][list][1] != 0) { sl->use_weight = 1; @@ -1047,12 +1023,12 @@ int ff_pred_weight_table(H264Context *h, H264SliceContext *sl) } if (h->sps.chroma_format_idc) { - chroma_weight_flag = get_bits1(&h->gb); + chroma_weight_flag = get_bits1(&sl->gb); if (chroma_weight_flag) { int j; for (j = 0; j < 2; j++) { - sl->chroma_weight[i][list][j][0] = get_se_golomb(&h->gb); - sl->chroma_weight[i][list][j][1] = get_se_golomb(&h->gb); + sl->chroma_weight[i][list][j][0] = get_se_golomb(&sl->gb); + sl->chroma_weight[i][list][j][1] = get_se_golomb(&sl->gb); if (sl->chroma_weight[i][list][j][0] != chroma_def || sl->chroma_weight[i][list][j][1] != 0) { sl->use_weight_chroma = 1; @@ -1068,7 +1044,7 @@ int ff_pred_weight_table(H264Context *h, H264SliceContext *sl) } } } - if (h->slice_type_nos != AV_PICTURE_TYPE_B) + if (sl->slice_type_nos != AV_PICTURE_TYPE_B) break; } sl->use_weight = sl->use_weight || sl->use_weight_chroma; @@ -1113,9 +1089,10 @@ void ff_h264_flush_change(H264Context *h) ff_h264_reset_sei(h); h->recovery_frame = -1; h->frame_recovered = 0; - h->list_count = 0; h->current_slice = 0; h->mmco_reset = 1; + for (i = 0; i < h->nb_slice_ctx; i++) + h->slice_ctx[i].list_count = 0; } /* forget old pics after a seek */ @@ -1134,7 +1111,7 @@ static void flush_dpb(AVCodecContext *avctx) h->cur_pic_ptr = NULL; ff_h264_unref_picture(h, &h->cur_pic); - h->mb_x = h->mb_y = 0; + h->mb_y = 0; ff_h264_free_tables(h, 1); h->context_initialized = 0; @@ -1292,7 +1269,7 @@ int ff_h264_set_parameter_from_sps(H264Context *h) return 0; } -int ff_set_ref_count(H264Context *h) +int ff_set_ref_count(H264Context *h, H264SliceContext *sl) { int ref_count[2], list_count; int num_ref_idx_active_override_flag; @@ -1301,18 +1278,18 @@ int ff_set_ref_count(H264Context *h) ref_count[0] = h->pps.ref_count[0]; ref_count[1] = h->pps.ref_count[1]; - if (h->slice_type_nos != AV_PICTURE_TYPE_I) { + if (sl->slice_type_nos != AV_PICTURE_TYPE_I) { unsigned max[2]; max[0] = max[1] = h->picture_structure == PICT_FRAME ? 15 : 31; - if (h->slice_type_nos == AV_PICTURE_TYPE_B) - h->direct_spatial_mv_pred = get_bits1(&h->gb); - num_ref_idx_active_override_flag = get_bits1(&h->gb); + if (sl->slice_type_nos == AV_PICTURE_TYPE_B) + sl->direct_spatial_mv_pred = get_bits1(&sl->gb); + num_ref_idx_active_override_flag = get_bits1(&sl->gb); if (num_ref_idx_active_override_flag) { - ref_count[0] = get_ue_golomb(&h->gb) + 1; - if (h->slice_type_nos == AV_PICTURE_TYPE_B) { - ref_count[1] = get_ue_golomb(&h->gb) + 1; + ref_count[0] = get_ue_golomb(&sl->gb) + 1; + if (sl->slice_type_nos == AV_PICTURE_TYPE_B) { + ref_count[1] = get_ue_golomb(&sl->gb) + 1; } else // full range is spec-ok in this case, even for frames ref_count[1] = 1; @@ -1320,12 +1297,12 @@ int ff_set_ref_count(H264Context *h) if (ref_count[0]-1 > max[0] || ref_count[1]-1 > max[1]){ av_log(h->avctx, AV_LOG_ERROR, "reference overflow %u > %u or %u > %u\n", ref_count[0]-1, max[0], ref_count[1]-1, max[1]); - h->ref_count[0] = h->ref_count[1] = 0; - h->list_count = 0; + sl->ref_count[0] = sl->ref_count[1] = 0; + sl->list_count = 0; return AVERROR_INVALIDDATA; } - if (h->slice_type_nos == AV_PICTURE_TYPE_B) + if (sl->slice_type_nos == AV_PICTURE_TYPE_B) list_count = 2; else list_count = 1; @@ -1334,12 +1311,12 @@ int ff_set_ref_count(H264Context *h) ref_count[0] = ref_count[1] = 0; } - if (list_count != h->list_count || - ref_count[0] != h->ref_count[0] || - ref_count[1] != h->ref_count[1]) { - h->ref_count[0] = ref_count[0]; - h->ref_count[1] = ref_count[1]; - h->list_count = list_count; + if (list_count != sl->list_count || + ref_count[0] != sl->ref_count[0] || + ref_count[1] != sl->ref_count[1]) { + sl->ref_count[0] = ref_count[0]; + sl->ref_count[1] = ref_count[1]; + sl->list_count = list_count; return 1; } @@ -1376,6 +1353,7 @@ static int get_last_needed_nal(H264Context *h, const uint8_t *buf, int buf_size) int first_slice = 0; while(1) { + GetBitContext gb; int nalsize = 0; int dst_length, bit_length, consumed; const uint8_t *ptr; @@ -1393,7 +1371,7 @@ static int get_last_needed_nal(H264Context *h, const uint8_t *buf, int buf_size) continue; } - ptr = ff_h264_decode_nal(h, buf + buf_index, &dst_length, &consumed, + ptr = ff_h264_decode_nal(h, &h->slice_ctx[0], buf + buf_index, &dst_length, &consumed, next_avc - buf_index); if (!ptr || dst_length < 0) @@ -1417,8 +1395,8 @@ static int get_last_needed_nal(H264Context *h, const uint8_t *buf, int buf_size) case NAL_DPA: case NAL_IDR_SLICE: case NAL_SLICE: - init_get_bits(&h->gb, ptr, bit_length); - if (!get_ue_golomb(&h->gb) || + init_get_bits(&gb, ptr, bit_length); + if (!get_ue_golomb(&gb) || !first_slice || first_slice != h->nal_unit_type) nals_needed = nal_index; @@ -1434,7 +1412,6 @@ static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size, int parse_extradata) { AVCodecContext *const avctx = h->avctx; - H264Context *hx; ///< thread context H264SliceContext *sl; int buf_index; unsigned context_count; @@ -1492,10 +1469,9 @@ static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size, continue; } - hx = h->thread_context[context_count]; sl = &h->slice_ctx[context_count]; - ptr = ff_h264_decode_nal(hx, buf + buf_index, &dst_length, + ptr = ff_h264_decode_nal(h, sl, buf + buf_index, &dst_length, &consumed, next_avc - buf_index); if (!ptr || dst_length < 0) { ret = -1; @@ -1508,7 +1484,7 @@ static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size, if (h->avctx->debug & FF_DEBUG_STARTCODE) av_log(h->avctx, AV_LOG_DEBUG, "NAL %d/%d at %d/%d length %d\n", - hx->nal_unit_type, hx->nal_ref_idc, buf_index, buf_size, dst_length); + h->nal_unit_type, h->nal_ref_idc, buf_index, buf_size, dst_length); if (h->is_avc && (nalsize != consumed) && nalsize) av_log(h->avctx, AV_LOG_DEBUG, @@ -1531,7 +1507,7 @@ again: * parsing. Decoding slices is not possible in codec init * with frame-mt */ if (parse_extradata) { - switch (hx->nal_unit_type) { + switch (h->nal_unit_type) { case NAL_IDR_SLICE: case NAL_SLICE: case NAL_DPA: @@ -1539,16 +1515,16 @@ again: case NAL_DPC: av_log(h->avctx, AV_LOG_WARNING, "Ignoring NAL %d in global header/extradata\n", - hx->nal_unit_type); + h->nal_unit_type); // fall through to next case case NAL_AUXILIARY_SLICE: - hx->nal_unit_type = NAL_FF_IGNORE; + h->nal_unit_type = NAL_FF_IGNORE; } } err = 0; - switch (hx->nal_unit_type) { + switch (h->nal_unit_type) { case NAL_IDR_SLICE: if ((ptr[0] & 0xFC) == 0x98) { av_log(h->avctx, AV_LOG_ERROR, "Invalid inter IDR frame\n"); @@ -1567,15 +1543,13 @@ again: idr_cleared = 1; h->has_recovery_point = 1; case NAL_SLICE: - init_get_bits(&hx->gb, ptr, bit_length); - hx->intra_gb_ptr = - hx->inter_gb_ptr = &hx->gb; + init_get_bits(&sl->gb, ptr, bit_length); - if ((err = ff_h264_decode_slice_header(hx, sl, h))) + if ((err = ff_h264_decode_slice_header(h, sl))) break; if (h->sei_recovery_frame_cnt >= 0) { - if (h->frame_num != h->sei_recovery_frame_cnt || hx->slice_type_nos != AV_PICTURE_TYPE_I) + if (h->frame_num != h->sei_recovery_frame_cnt || sl->slice_type_nos != AV_PICTURE_TYPE_I) h->valid_recovery_point = 1; if ( h->recovery_frame < 0 @@ -1589,16 +1563,16 @@ again: } h->cur_pic_ptr->f.key_frame |= - (hx->nal_unit_type == NAL_IDR_SLICE); + (h->nal_unit_type == NAL_IDR_SLICE); - if (hx->nal_unit_type == NAL_IDR_SLICE || + if (h->nal_unit_type == NAL_IDR_SLICE || h->recovery_frame == h->frame_num) { h->recovery_frame = -1; h->cur_pic_ptr->recovered = 1; } // If we have an IDR, all frames after it in decoded order are // "recovered". - if (hx->nal_unit_type == NAL_IDR_SLICE) + if (h->nal_unit_type == NAL_IDR_SLICE) h->frame_recovered |= FRAME_RECOVERED_IDR; h->frame_recovered |= 3*!!(avctx->flags2 & CODEC_FLAG2_SHOW_ALL); h->frame_recovered |= 3*!!(avctx->flags & CODEC_FLAG_OUTPUT_CORRUPT); @@ -1620,7 +1594,7 @@ again: ff_vdpau_h264_picture_start(h); } - if (hx->redundant_pic_count == 0) { + if (sl->redundant_pic_count == 0) { if (avctx->hwaccel) { ret = avctx->hwaccel->decode_slice(avctx, &buf[buf_index - consumed], @@ -1684,7 +1658,7 @@ again: break; default: av_log(avctx, AV_LOG_DEBUG, "Unknown NAL code: %d (%d bits)\n", - hx->nal_unit_type, bit_length); + h->nal_unit_type, bit_length); } if (context_count == h->max_contexts) { @@ -1697,15 +1671,11 @@ again: if (err < 0 || err == SLICE_SKIPED) { if (err < 0) av_log(h->avctx, AV_LOG_ERROR, "decode_slice_header error\n"); - h->ref_count[0] = h->ref_count[1] = h->list_count = 0; + sl->ref_count[0] = sl->ref_count[1] = sl->list_count = 0; } else if (err == SLICE_SINGLETHREAD) { - /* Slice could not be decoded in parallel mode, copy down - * NAL unit stuff to context 0 and restart. Note that - * rbsp_buffer is not transferred, but since we no longer + /* Slice could not be decoded in parallel mode, restart. Note + * that rbsp_buffer is not transferred, but since we no longer * run in parallel mode this should not be an issue. */ - h->nal_unit_type = hx->nal_unit_type; - h->nal_ref_idc = hx->nal_ref_idc; - hx = h; sl = &h->slice_ctx[0]; goto again; } @@ -1871,7 +1841,7 @@ static int h264_decode_frame(AVCodecContext *avctx, void *data, if (avctx->flags2 & CODEC_FLAG2_CHUNKS) decode_postinit(h, 1); - ff_h264_field_end(h, 0); + ff_h264_field_end(h, &h->slice_ctx[0], 0); /* Wait for second field. */ *got_frame = 0; @@ -1908,7 +1878,7 @@ static int h264_decode_frame(AVCodecContext *avctx, void *data, return ret; *got_frame = 1; if (CONFIG_MPEGVIDEO) { - ff_print_debug_info2(h->avctx, pict, h->er.mbskip_table, + ff_print_debug_info2(h->avctx, pict, NULL, h->next_output_pic->mb_type, h->next_output_pic->qscale_table, h->next_output_pic->motion_val,