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;
+ 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
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(&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, H264SliceContext *sl,
+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;
+ 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;
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
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 (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, H264SliceContext *sl,
+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 };
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 (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 (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 && (sl->left_samples_available & 0x8080)) {
{
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]);
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 (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;
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;
max[0] = max[1] = h->picture_structure == PICT_FRAME ? 15 : 31;
if (sl->slice_type_nos == AV_PICTURE_TYPE_B)
- sl->direct_spatial_mv_pred = get_bits1(&h->gb);
- num_ref_idx_active_override_flag = get_bits1(&h->gb);
+ 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;
+ ref_count[0] = get_ue_golomb(&sl->gb) + 1;
if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
- ref_count[1] = get_ue_golomb(&h->gb) + 1;
+ 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;
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;