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].f.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 *cur = &h->cur_pic.f;
+ AVFrame *last = sl->ref_list[0][0].f.data[0] ? &sl->ref_list[0][0].f : NULL;
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;
+ const AVFrame *src;
int offset[AV_NUM_DATA_POINTERS];
int i;
* 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);
}
}
{
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(&h->rbsp_buffer, &h->rbsp_buffer_size, length+MAX_MBPAIR_SIZE);
+ dst = h->rbsp_buffer;
if (!dst)
return NULL;
av_freep(&hx->er.mbskip_table);
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(&hx->rbsp_buffer);
+ hx->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,
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;
+ for (i = 0; i < h->nb_slice_ctx; i++) {
+ h->slice_ctx[i].ref_cache[0][scan8[5] + 1] =
+ h->slice_ctx[i].ref_cache[0][scan8[7] + 1] =
+ h->slice_ctx[i].ref_cache[0][scan8[13] + 1] =
+ h->slice_ctx[i].ref_cache[1][scan8[5] + 1] =
+ h->slice_ctx[i].ref_cache[1][scan8[7] + 1] =
+ h->slice_ctx[i].ref_cache[1][scan8[13] + 1] = PART_NOT_AVAILABLE;
+ }
if (CONFIG_ERROR_RESILIENCE) {
/* init ER */
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->rbsp_buffer = NULL;
+ h->rbsp_buffer_size = 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;
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;
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)))
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
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],
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
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;
projects / ffmpeg / blobdiff