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;
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];
* 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
};
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;
}
}
- 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;
* 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 };
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);
}
}
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;
}
#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;
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);
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]);
}
}
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,
* 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 */
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;
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++)
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;
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);
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;
}
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;
}
}
}
- 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;
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 */
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;
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;
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;
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;
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;
}
int first_slice = 0;
while(1) {
+ GetBitContext gb;
int nalsize = 0;
int dst_length, bit_length, consumed;
const uint8_t *ptr;
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)
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;
int parse_extradata)
{
AVCodecContext *const avctx = h->avctx;
- H264Context *hx; ///< thread context
H264SliceContext *sl;
int buf_index;
unsigned context_count;
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;
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,
* 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:
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");
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
}
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);
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],
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) {
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;
}
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;
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,
projects / ffmpeg / blobdiff