uint8_t luma_weight_l1_flag[16];
uint8_t chroma_weight_l1_flag[16];
- s->sh.luma_log2_weight_denom = get_ue_golomb_long(gb);
+ s->sh.luma_log2_weight_denom = av_clip_c(get_ue_golomb_long(gb), 0, 7);
if (s->sps->chroma_format_idc != 0) {
int delta = get_se_golomb(gb);
s->sh.chroma_log2_weight_denom = av_clip_c(s->sh.luma_log2_weight_denom + delta, 0, 7);
static int set_sps(HEVCContext *s, const HEVCSPS *sps)
{
+ #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL)
+ enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
int ret;
unsigned int num = 0, den = 0;
s->avctx->coded_height = sps->height;
s->avctx->width = sps->output_width;
s->avctx->height = sps->output_height;
- s->avctx->pix_fmt = sps->pix_fmt;
s->avctx->has_b_frames = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics;
+ if (sps->pix_fmt == AV_PIX_FMT_YUV420P || sps->pix_fmt == AV_PIX_FMT_YUVJ420P) {
+#if CONFIG_HEVC_DXVA2_HWACCEL
+ *fmt++ = AV_PIX_FMT_DXVA2_VLD;
+#endif
+ }
+
+ *fmt++ = sps->pix_fmt;
+ *fmt = AV_PIX_FMT_NONE;
+
+ ret = ff_get_format(s->avctx, pix_fmts);
+ if (ret < 0)
+ goto fail;
+ s->avctx->pix_fmt = ret;
+
ff_set_sar(s->avctx, sps->vui.sar);
if (sps->vui.video_signal_type_present_flag)
ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
ff_videodsp_init (&s->vdsp, sps->bit_depth);
- if (sps->sao_enabled) {
+ if (sps->sao_enabled && !s->avctx->hwaccel) {
av_frame_unref(s->tmp_frame);
ret = ff_get_buffer(s->avctx, s->tmp_frame, AV_GET_BUFFER_FLAG_REF);
if (ret < 0)
sh->colour_plane_id = get_bits(gb, 2);
if (!IS_IDR(s)) {
- int short_term_ref_pic_set_sps_flag, poc;
+ int poc;
sh->pic_order_cnt_lsb = get_bits(gb, s->sps->log2_max_poc_lsb);
poc = ff_hevc_compute_poc(s, sh->pic_order_cnt_lsb);
}
s->poc = poc;
- short_term_ref_pic_set_sps_flag = get_bits1(gb);
- if (!short_term_ref_pic_set_sps_flag) {
+ sh->short_term_ref_pic_set_sps_flag = get_bits1(gb);
+ if (!sh->short_term_ref_pic_set_sps_flag) {
+ int pos = get_bits_left(gb);
ret = ff_hevc_decode_short_term_rps(s, &sh->slice_rps, s->sps, 1);
if (ret < 0)
return ret;
+ sh->short_term_ref_pic_set_size = pos - get_bits_left(gb);
sh->short_term_rps = &sh->slice_rps;
} else {
int numbits, rps_idx;
static int hls_transform_unit(HEVCContext *s, int x0, int y0,
int xBase, int yBase, int cb_xBase, int cb_yBase,
int log2_cb_size, int log2_trafo_size,
- int trafo_depth, int blk_idx,
- int cbf_luma, int cbf_cb, int cbf_cr)
+ int blk_idx, int cbf_luma, int cbf_cb, int cbf_cr)
{
HEVCLocalContext *lc = &s->HEVClc;
cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
- log2_cb_size, log2_trafo_size, trafo_depth,
+ log2_cb_size, log2_trafo_size,
blk_idx, cbf_luma, cbf_cb, cbf_cr);
if (ret < 0)
return ret;
ff_thread_await_progress(&ref->tf, y, 0);
}
+static void hevc_luma_mv_mpv_mode(HEVCContext *s, int x0, int y0, int nPbW,
+ int nPbH, int log2_cb_size, int part_idx,
+ int merge_idx, MvField *mv)
+{
+ HEVCLocalContext *lc = &s->HEVClc;
+ enum InterPredIdc inter_pred_idc = PRED_L0;
+ int mvp_flag;
+
+ ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
+ if (s->sh.slice_type == B_SLICE)
+ inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
+
+ if (inter_pred_idc != PRED_L1) {
+ if (s->sh.nb_refs[L0])
+ mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
+
+ mv->pred_flag[0] = 1;
+ hls_mvd_coding(s, x0, y0, 0);
+ mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
+ ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
+ part_idx, merge_idx, mv, mvp_flag, 0);
+ mv->mv[0].x += lc->pu.mvd.x;
+ mv->mv[0].y += lc->pu.mvd.y;
+ }
+
+ if (inter_pred_idc != PRED_L0) {
+ if (s->sh.nb_refs[L1])
+ mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
+
+ if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
+ AV_ZERO32(&lc->pu.mvd);
+ } else {
+ hls_mvd_coding(s, x0, y0, 1);
+ }
+
+ mv->pred_flag[1] = 1;
+ mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
+ ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
+ part_idx, merge_idx, mv, mvp_flag, 1);
+ mv->mv[1].x += lc->pu.mvd.x;
+ mv->mv[1].y += lc->pu.mvd.y;
+ }
+}
+
static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
int nPbW, int nPbH,
int log2_cb_size, int partIdx)
int min_cb_width = s->sps->min_cb_width;
int x_cb = x0 >> log2_min_cb_size;
int y_cb = y0 >> log2_min_cb_size;
- int ref_idx[2];
- int mvp_flag[2];
int x_pu, y_pu;
int i, j;
- if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
+ int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
+
+ if (!skip_flag)
+ lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
+
+ if (skip_flag || lc->pu.merge_flag) {
if (s->sh.max_num_merge_cand > 1)
merge_idx = ff_hevc_merge_idx_decode(s);
else
merge_idx = 0;
- ff_hevc_luma_mv_merge_mode(s, x0, y0,
- 1 << log2_cb_size,
- 1 << log2_cb_size,
- log2_cb_size, partIdx,
- merge_idx, ¤t_mv);
- x_pu = x0 >> s->sps->log2_min_pu_size;
- y_pu = y0 >> s->sps->log2_min_pu_size;
-
- for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
- for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
- tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
- } else { /* MODE_INTER */
- lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
- if (lc->pu.merge_flag) {
- if (s->sh.max_num_merge_cand > 1)
- merge_idx = ff_hevc_merge_idx_decode(s);
- else
- merge_idx = 0;
-
- ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
- partIdx, merge_idx, ¤t_mv);
- x_pu = x0 >> s->sps->log2_min_pu_size;
- y_pu = y0 >> s->sps->log2_min_pu_size;
-
- for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
- for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
- tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
- } else {
- enum InterPredIdc inter_pred_idc = PRED_L0;
- ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
- if (s->sh.slice_type == B_SLICE)
- inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
-
- if (inter_pred_idc != PRED_L1) {
- if (s->sh.nb_refs[L0]) {
- ref_idx[0] = ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
- current_mv.ref_idx[0] = ref_idx[0];
- }
- current_mv.pred_flag[0] = 1;
- hls_mvd_coding(s, x0, y0, 0);
- mvp_flag[0] = ff_hevc_mvp_lx_flag_decode(s);
- ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
- partIdx, merge_idx, ¤t_mv,
- mvp_flag[0], 0);
- current_mv.mv[0].x += lc->pu.mvd.x;
- current_mv.mv[0].y += lc->pu.mvd.y;
- }
-
- if (inter_pred_idc != PRED_L0) {
- if (s->sh.nb_refs[L1]) {
- ref_idx[1] = ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
- current_mv.ref_idx[1] = ref_idx[1];
- }
-
- if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
- AV_ZERO32(&lc->pu.mvd);
- } else {
- hls_mvd_coding(s, x0, y0, 1);
- }
+ ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
+ partIdx, merge_idx, ¤t_mv);
+ } else {
+ hevc_luma_mv_mpv_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
+ partIdx, merge_idx, ¤t_mv);
+ }
- current_mv.pred_flag[1] = 1;
- mvp_flag[1] = ff_hevc_mvp_lx_flag_decode(s);
- ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
- partIdx, merge_idx, ¤t_mv,
- mvp_flag[1], 1);
- current_mv.mv[1].x += lc->pu.mvd.x;
- current_mv.mv[1].y += lc->pu.mvd.y;
- }
+ x_pu = x0 >> s->sps->log2_min_pu_size;
+ y_pu = y0 >> s->sps->log2_min_pu_size;
- x_pu = x0 >> s->sps->log2_min_pu_size;
- y_pu = y0 >> s->sps->log2_min_pu_size;
-
- for(j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
- for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
- tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
- }
- }
+ for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
+ for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
+ tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
if (current_mv.pred_flag[0]) {
ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
- if (!ref1)
- return;
-
luma_mc(s, tmp, tmpstride, ref1->frame,
¤t_mv.mv[1], x0, y0, nPbW, nPbH);
DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
DECLARE_ALIGNED(16, int16_t, tmp3[MAX_PB_SIZE * MAX_PB_SIZE]);
DECLARE_ALIGNED(16, int16_t, tmp4[MAX_PB_SIZE * MAX_PB_SIZE]);
- HEVCFrame *ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
- HEVCFrame *ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
-
- if (!ref0 || !ref1)
- return;
luma_mc(s, tmp, tmpstride, ref0->frame,
¤t_mv.mv[0], x0, y0, nPbW, nPbH);
if (s->sh.slice_type != I_SLICE) {
uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
- lc->cu.pred_mode = MODE_SKIP;
x = y_cb * min_cb_width + x_cb;
for (y = 0; y < length; y++) {
memset(&s->skip_flag[x], skip_flag, length);
fail:
if (s->ref)
- ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
+ ff_hevc_unref_frame(s, s->ref, ~0);
s->ref = NULL;
return ret;
}
-static int decode_nal_unit(HEVCContext *s, const uint8_t *nal, int length)
+static int decode_nal_unit(HEVCContext *s, const HEVCNAL *nal)
{
HEVCLocalContext *lc = &s->HEVClc;
GetBitContext *gb = &lc->gb;
int ctb_addr_ts, ret;
- ret = init_get_bits8(gb, nal, length);
+ ret = init_get_bits8(gb, nal->data, nal->size);
if (ret < 0)
return ret;
}
}
- ctb_addr_ts = hls_slice_data(s);
- if (ctb_addr_ts >= (s->sps->ctb_width * s->sps->ctb_height)) {
- s->is_decoded = 1;
- if ((s->pps->transquant_bypass_enable_flag ||
- (s->sps->pcm.loop_filter_disable_flag && s->sps->pcm_enabled_flag)) &&
- s->sps->sao_enabled)
- restore_tqb_pixels(s);
+ if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) {
+ ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0);
+ if (ret < 0)
+ goto fail;
}
- if (ctb_addr_ts < 0) {
- ret = ctb_addr_ts;
- goto fail;
+ if (s->avctx->hwaccel) {
+ ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size);
+ if (ret < 0)
+ goto fail;
+ } else {
+ ctb_addr_ts = hls_slice_data(s);
+ if (ctb_addr_ts >= (s->sps->ctb_width * s->sps->ctb_height)) {
+ s->is_decoded = 1;
+ if ((s->pps->transquant_bypass_enable_flag ||
+ (s->sps->pcm.loop_filter_disable_flag && s->sps->pcm_enabled_flag)) &&
+ s->sps->sao_enabled)
+ restore_tqb_pixels(s);
+ }
+
+ if (ctb_addr_ts < 0) {
+ ret = ctb_addr_ts;
+ goto fail;
+ }
}
break;
case NAL_EOS_NUT:
#endif /* HAVE_FAST_UNALIGNED */
if (i >= length - 1) { // no escaped 0
- nal->data = src;
- nal->size = length;
+ nal->data =
+ nal->raw_data = src;
+ nal->size =
+ nal->raw_size = length;
return length;
}
nal->data = dst;
nal->size = di;
+ nal->raw_data = src;
+ nal->raw_size = si;
return si;
}
/* parse the NAL units */
for (i = 0; i < s->nb_nals; i++) {
- int ret = decode_nal_unit(s, s->nals[i].data, s->nals[i].size);
+ int ret = decode_nal_unit(s, &s->nals[i]);
if (ret < 0) {
av_log(s->avctx, AV_LOG_WARNING,
"Error parsing NAL unit #%d.\n", i);
if (ret < 0)
return ret;
- /* verify the SEI checksum */
- if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
- s->is_md5) {
- ret = verify_md5(s, s->ref->frame);
- if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
- ff_hevc_unref_frame(s, s->ref, ~0);
- return ret;
+ if (avctx->hwaccel) {
+ if (s->ref && avctx->hwaccel->end_frame(avctx) < 0)
+ av_log(avctx, AV_LOG_ERROR,
+ "hardware accelerator failed to decode picture\n");
+ } else {
+ /* verify the SEI checksum */
+ if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
+ s->is_md5) {
+ ret = verify_md5(s, s->ref->frame);
+ if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
+ ff_hevc_unref_frame(s, s->ref, ~0);
+ return ret;
+ }
}
}
s->is_md5 = 0;
dst->flags = src->flags;
dst->sequence = src->sequence;
+ if (src->hwaccel_picture_private) {
+ dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
+ if (!dst->hwaccel_priv_buf)
+ goto fail;
+ dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
+ }
+
return 0;
fail:
ff_hevc_unref_frame(s, dst, ~0);
projects / ffmpeg / blobdiff