26 #include "config_components.h"
60 static const uint8_t
hevc_pel_weight[65] = { [2] = 0, [4] = 1, [6] = 2, [8] = 3, [12] = 4, [16] = 5, [24] = 6, [32] = 7, [48] = 8, [64] = 9 };
91 for (
int i = 0;
i < 3;
i++) {
103 int log2_min_cb_size =
sps->log2_min_cb_size;
106 int pic_size_in_ctb = ((
width >> log2_min_cb_size) + 1) *
107 ((
height >> log2_min_cb_size) + 1);
108 int ctb_count =
sps->ctb_width *
sps->ctb_height;
109 int min_pu_size =
sps->min_pu_width *
sps->min_pu_height;
148 if (
sps->sao_enabled) {
149 int c_count = (
sps->chroma_format_idc != 0) ? 3 : 1;
151 for (
int c_idx = 0; c_idx < c_count; c_idx++) {
152 int w =
sps->width >>
sps->hshift[c_idx];
153 int h =
sps->height >>
sps->vshift[c_idx];
178 int luma_log2_weight_denom;
179 unsigned luma_weight_flags, chroma_weight_flags;
182 if (luma_log2_weight_denom < 0 || luma_log2_weight_denom > 7) {
183 av_log(logctx,
AV_LOG_ERROR,
"luma_log2_weight_denom %d is invalid\n", luma_log2_weight_denom);
187 if (
sps->chroma_format_idc != 0) {
189 if (chroma_log2_weight_denom < 0 || chroma_log2_weight_denom > 7) {
190 av_log(logctx,
AV_LOG_ERROR,
"chroma_log2_weight_denom %"PRId64
" is invalid\n", chroma_log2_weight_denom);
199 unsigned flag_bit = 1 << (sh->
nb_refs[
L0] - 1 -
i);
201 if (luma_weight_flags & flag_bit) {
203 if ((int8_t)delta_luma_weight_l0 != delta_luma_weight_l0)
211 if (chroma_weight_flags & flag_bit) {
212 for (j = 0; j < 2; j++) {
216 if ( (int8_t)delta_chroma_weight_l0 != delta_chroma_weight_l0
217 || delta_chroma_offset_l0 < -(1<<17) || delta_chroma_offset_l0 > (1<<17)) {
236 unsigned flag_bit = 1 << (sh->
nb_refs[
L1] - 1 -
i);
238 if (luma_weight_flags & flag_bit) {
240 if ((int8_t)delta_luma_weight_l1 != delta_luma_weight_l1)
248 if (chroma_weight_flags & flag_bit) {
249 for (j = 0; j < 2; j++) {
253 if ( (int8_t)delta_chroma_weight_l1 != delta_chroma_weight_l1
254 || delta_chroma_offset_l1 < -(1<<17) || delta_chroma_offset_l1 > (1<<17)) {
276 int max_poc_lsb = 1 <<
sps->log2_max_poc_lsb;
277 int prev_delta_msb = 0;
278 unsigned int nb_sps = 0, nb_sh;
282 if (!
sps->long_term_ref_pics_present)
285 if (
sps->num_long_term_ref_pics_sps > 0)
289 if (nb_sps >
sps->num_long_term_ref_pics_sps)
299 uint8_t lt_idx_sps = 0;
301 if (
sps->num_long_term_ref_pics_sps > 1)
304 rps->
poc[
i] =
sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
305 rps->
used[
i] = !!(
sps->used_by_curr_pic_lt & (1
U << lt_idx_sps));
316 if (
i &&
i != nb_sps)
317 delta += prev_delta_msb;
319 poc = rps->
poc[
i] + cur_poc -
delta * max_poc_lsb - poc_lsb;
323 prev_delta_msb =
delta;
335 unsigned int num = 0, den = 0;
343 avctx->
profile =
sps->ptl.general_ptl.profile_idc;
344 avctx->
level =
sps->ptl.general_ptl.level_idc;
348 if (
sps->vui.common.video_signal_type_present_flag)
354 if (
sps->vui.common.colour_description_present_flag) {
356 avctx->
color_trc =
sps->vui.common.transfer_characteristics;
365 if (
sps->chroma_format_idc == 1) {
366 if (
sps->vui.common.chroma_loc_info_present_flag) {
367 if (
sps->vui.common.chroma_sample_loc_type_top_field <= 5)
373 if (
vps->vps_timing_info_present_flag) {
374 num =
vps->vps_num_units_in_tick;
375 den =
vps->vps_time_scale;
376 }
else if (
sps->vui.vui_timing_info_present_flag) {
377 num =
sps->vui.vui_num_units_in_tick;
378 den =
sps->vui.vui_time_scale;
381 if (num > 0 && den > 0)
390 #if FF_API_CODEC_PROPS
392 if (
s->sei.common.a53_caption.buf_ref)
397 if (
s->sei.common.alternative_transfer.present &&
400 avctx->
color_trc =
s->sei.common.alternative_transfer.preferred_transfer_characteristics;
403 #if FF_API_CODEC_PROPS
405 if ((
s->sei.common.film_grain_characteristics &&
s->sei.common.film_grain_characteristics->present) ||
406 s->sei.common.aom_film_grain.enable)
419 s->nb_view_ids_available = 0;
421 s->nb_view_pos_available = 0;
424 if (
vps->nb_layers < 2 && !
vps->view_id[0])
427 s->view_ids_available =
av_calloc(
vps->nb_layers,
sizeof(*
s->view_ids_available));
428 if (!
s->view_ids_available)
432 s->view_pos_available =
av_calloc(
vps->nb_layers,
sizeof(*
s->view_pos_available));
433 if (!
s->view_pos_available)
437 for (
int i = 0;
i <
vps->nb_layers;
i++) {
438 s->view_ids_available[
i] =
vps->view_id[
i];
440 if (
s->view_pos_available) {
447 s->nb_view_ids_available =
vps->nb_layers;
448 s->nb_view_pos_available =
s->view_pos_available ?
vps->nb_layers : 0;
458 if (
vps->nb_layers != 2 || !
vps->layer_id_in_nuh[1])
474 unsigned layers_active_output = 0, highest_layer;
476 s->layers_active_output = 1;
477 s->layers_active_decode = 1;
485 s->layers_active_decode = (1 <<
vps->nb_layers) - 1;
486 s->layers_active_output = 1;
495 if (
s->nb_view_ids == 1 &&
s->view_ids[0] == -1) {
496 layers_active_output = (1 <<
vps->nb_layers) - 1;
498 for (
int i = 0;
i <
s->nb_view_ids;
i++) {
499 int view_id =
s->view_ids[
i];
504 "Invalid view ID requested: %d\n", view_id);
508 for (
int j = 0; j <
vps->nb_layers; j++) {
509 if (
vps->view_id[j] == view_id) {
516 "View ID %d not present in VPS\n", view_id);
519 layers_active_output |= 1 << layer_idx;
523 if (!layers_active_output) {
528 highest_layer =
ff_log2(layers_active_output);
531 "Too many layers requested: %u\n", layers_active_output);
539 s->layers_active_decode = (1 << (highest_layer + 1)) - 1;
540 s->layers_active_output = layers_active_output;
543 s->layers_active_decode,
s->layers_active_output);
578 #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + \
579 CONFIG_HEVC_D3D11VA_HWACCEL * 2 + \
580 CONFIG_HEVC_D3D12VA_HWACCEL + \
581 CONFIG_HEVC_NVDEC_HWACCEL + \
582 CONFIG_HEVC_VAAPI_HWACCEL + \
583 CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL + \
584 CONFIG_HEVC_VDPAU_HWACCEL + \
585 CONFIG_HEVC_VULKAN_HWACCEL)
593 switch (
sps->pix_fmt) {
596 #if CONFIG_HEVC_DXVA2_HWACCEL
599 #if CONFIG_HEVC_D3D11VA_HWACCEL
603 #if CONFIG_HEVC_D3D12VA_HWACCEL
606 #if CONFIG_HEVC_VAAPI_HWACCEL
609 #if CONFIG_HEVC_VDPAU_HWACCEL
612 #if CONFIG_HEVC_NVDEC_HWACCEL
615 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
618 #if CONFIG_HEVC_VULKAN_HWACCEL
623 #if CONFIG_HEVC_DXVA2_HWACCEL
626 #if CONFIG_HEVC_D3D11VA_HWACCEL
630 #if CONFIG_HEVC_D3D12VA_HWACCEL
633 #if CONFIG_HEVC_VAAPI_HWACCEL
636 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
639 #if CONFIG_HEVC_VULKAN_HWACCEL
642 #if CONFIG_HEVC_VDPAU_HWACCEL
645 #if CONFIG_HEVC_NVDEC_HWACCEL
650 #if CONFIG_HEVC_VAAPI_HWACCEL
653 #if CONFIG_HEVC_VDPAU_HWACCEL
656 #if CONFIG_HEVC_NVDEC_HWACCEL
659 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
662 #if CONFIG_HEVC_VULKAN_HWACCEL
668 #if CONFIG_HEVC_VAAPI_HWACCEL
671 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
674 #if CONFIG_HEVC_VULKAN_HWACCEL
677 #if CONFIG_HEVC_NVDEC_HWACCEL
682 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
688 #if CONFIG_HEVC_VAAPI_HWACCEL
691 #if CONFIG_HEVC_VDPAU_HWACCEL
694 #if CONFIG_HEVC_VULKAN_HWACCEL
697 #if CONFIG_HEVC_NVDEC_HWACCEL
702 #if CONFIG_HEVC_VAAPI_HWACCEL
705 #if CONFIG_HEVC_VULKAN_HWACCEL
708 #if CONFIG_HEVC_NVDEC_HWACCEL
716 *fmt++ =
sps->pix_fmt;
728 s->avctx->pix_fmt =
ret;
773 unsigned pps_id, layer_idx;
794 pps =
s->ps.pps_list[pps_id];
797 layer_idx =
vps->layer_idx[
s->nuh_layer_id];
804 int slice_address_length;
806 if (
pps->dependent_slice_segments_enabled_flag)
818 "Invalid slice segment address: %u.\n",
831 for (
i = 0;
i <
pps->num_extra_slice_header_bits;
i++)
843 !
pps->pps_curr_pic_ref_enabled_flag &&
844 s->nuh_layer_id == 0) {
851 if (
pps->output_flag_present_flag)
854 if (
sps->separate_colour_plane)
858 (
s->nuh_layer_id > 0 &&
859 !(
vps->poc_lsb_not_present & (1 << layer_idx)))) {
866 "Ignoring POC change between slices: %d -> %d\n", poc, sh->
poc);
886 int numbits, rps_idx;
888 if (!
sps->nb_st_rps) {
894 rps_idx = numbits > 0 ?
get_bits(gb, numbits) : 0;
908 if (
sps->temporal_mvp_enabled)
923 if (
s->nuh_layer_id > 0) {
924 int num_direct_ref_layers =
vps->num_direct_ref_layers[layer_idx];
926 if (
vps->default_ref_layers_active)
928 else if (num_direct_ref_layers) {
933 "NumDirectRefLayers>1 not supported\n");
939 if (
sps->sao_enabled) {
941 if (
sps->chroma_format_idc) {
978 if (
pps->lists_modification_present_flag && nb_refs > 1) {
996 if (
pps->cabac_init_present_flag)
1011 "Invalid collocated_ref_idx: %d.\n",
1028 "Invalid number of merging MVP candidates: %d.\n",
1034 if (
sps->motion_vector_resolution_control_idc == 2)
1044 if (
pps->pic_slice_level_chroma_qp_offsets_present_flag) {
1057 if (
pps->pps_slice_act_qp_offsets_present_flag) {
1063 if (
pps->chroma_qp_offset_list_enabled_flag)
1068 if (
pps->deblocking_filter_control_present_flag) {
1069 int deblocking_filter_override_flag = 0;
1071 if (
pps->deblocking_filter_override_enabled_flag)
1072 deblocking_filter_override_flag =
get_bits1(gb);
1074 if (deblocking_filter_override_flag) {
1079 if (beta_offset_div2 < -6 || beta_offset_div2 > 6 ||
1080 tc_offset_div2 < -6 || tc_offset_div2 > 6) {
1082 "Invalid deblock filter offsets: %d, %d\n",
1083 beta_offset_div2, tc_offset_div2);
1100 if (
pps->seq_loop_filter_across_slices_enabled_flag &&
1111 if (
pps->tiles_enabled_flag ||
pps->entropy_coding_sync_enabled_flag) {
1114 if (num_entry_point_offsets >
get_bits_left(gb) || num_entry_point_offsets > UINT16_MAX) {
1115 av_log(
s->avctx,
AV_LOG_ERROR,
"num_entry_point_offsets %d is invalid\n", num_entry_point_offsets);
1123 if (offset_len < 1 || offset_len > 32) {
1147 if (
pps->slice_header_extension_present_flag) {
1153 for (
i = 0;
i < length;
i++)
1175 "The slice_qp %d is outside the valid range "
1178 -
sps->qp_bd_offset);
1193 #define CTB(tab, x, y) ((tab)[(y) * sps->ctb_width + (x)])
1195 #define SET_SAO(elem, value) \
1197 if (!sao_merge_up_flag && !sao_merge_left_flag) \
1198 sao->elem = value; \
1199 else if (sao_merge_left_flag) \
1200 sao->elem = CTB(l->sao, rx-1, ry).elem; \
1201 else if (sao_merge_up_flag) \
1202 sao->elem = CTB(l->sao, rx, ry-1).elem; \
1212 int sao_merge_left_flag = 0;
1213 int sao_merge_up_flag = 0;
1217 if (
s->sh.slice_sample_adaptive_offset_flag[0] ||
1218 s->sh.slice_sample_adaptive_offset_flag[1]) {
1223 if (ry > 0 && !sao_merge_left_flag) {
1229 for (c_idx = 0; c_idx < (
sps->chroma_format_idc ? 3 : 1); c_idx++) {
1230 int log2_sao_offset_scale = c_idx == 0 ?
pps->log2_sao_offset_scale_luma :
1231 pps->log2_sao_offset_scale_chroma;
1233 if (!
s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
1248 for (
i = 0;
i < 4;
i++)
1252 for (
i = 0;
i < 4;
i++) {
1261 }
else if (c_idx != 2) {
1267 for (
i = 0;
i < 4;
i++) {
1275 sao->
offset_val[c_idx][
i + 1] *= 1 << log2_sao_offset_scale;
1287 if (log2_res_scale_abs_plus1 != 0) {
1290 (1 - 2 * res_scale_sign_flag);
1303 int xBase,
int yBase,
int cb_xBase,
int cb_yBase,
1304 int log2_cb_size,
int log2_trafo_size,
1305 int blk_idx,
int cbf_luma,
int *cbf_cb,
int *cbf_cr)
1308 const int log2_trafo_size_c = log2_trafo_size -
sps->hshift[1];
1312 int trafo_size = 1 << log2_trafo_size;
1315 s->hpc.intra_pred[log2_trafo_size - 2](lc,
pps, x0, y0, 0);
1318 if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
1319 (
sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1322 int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
1323 (
sps->chroma_format_idc == 2 &&
1324 (cbf_cb[1] || cbf_cr[1]));
1336 "The cu_qp_delta %d is outside the valid range "
1339 -(26 +
sps->qp_bd_offset / 2),
1340 (25 +
sps->qp_bd_offset / 2));
1347 if (
s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
1350 if (cu_chroma_qp_offset_flag) {
1351 int cu_chroma_qp_offset_idx = 0;
1352 if (
pps->chroma_qp_offset_list_len_minus1 > 0) {
1355 "cu_chroma_qp_offset_idx not yet tested.\n");
1388 if (
sps->chroma_format_idc && (log2_trafo_size > 2 ||
sps->chroma_format_idc == 3)) {
1389 int trafo_size_h = 1 << (log2_trafo_size_c +
sps->hshift[1]);
1390 int trafo_size_v = 1 << (log2_trafo_size_c +
sps->vshift[1]);
1391 lc->
tu.
cross_pf = (
pps->cross_component_prediction_enabled_flag && cbf_luma &&
1398 for (
i = 0;
i < (
sps->chroma_format_idc == 2 ? 2 : 1);
i++) {
1401 trafo_size_h, trafo_size_v,
sps->log2_ctb_size);
1402 s->hpc.intra_pred[log2_trafo_size_c - 2](lc,
pps, x0, y0 + (
i << log2_trafo_size_c), 1);
1406 log2_trafo_size_c, scan_idx_c, 1);
1409 ptrdiff_t
stride =
s->cur_frame->f->linesize[1];
1410 int hshift =
sps->hshift[1];
1411 int vshift =
sps->vshift[1];
1414 int size = 1 << log2_trafo_size_c;
1416 uint8_t *
dst = &
s->cur_frame->f->data[1][(y0 >> vshift) *
stride +
1417 ((x0 >> hshift) <<
sps->pixel_shift)];
1421 s->hevcdsp.add_residual[log2_trafo_size_c-2](
dst, coeffs,
stride);
1428 for (
i = 0;
i < (
sps->chroma_format_idc == 2 ? 2 : 1);
i++) {
1431 trafo_size_h, trafo_size_v,
sps->log2_ctb_size);
1432 s->hpc.intra_pred[log2_trafo_size_c - 2](lc,
pps, x0, y0 + (
i << log2_trafo_size_c), 2);
1436 log2_trafo_size_c, scan_idx_c, 2);
1439 ptrdiff_t
stride =
s->cur_frame->f->linesize[2];
1440 int hshift =
sps->hshift[2];
1441 int vshift =
sps->vshift[2];
1444 int size = 1 << log2_trafo_size_c;
1446 uint8_t *
dst = &
s->cur_frame->f->data[2][(y0 >> vshift) *
stride +
1447 ((x0 >> hshift) <<
sps->pixel_shift)];
1451 s->hevcdsp.add_residual[log2_trafo_size_c-2](
dst, coeffs,
stride);
1454 }
else if (
sps->chroma_format_idc && blk_idx == 3) {
1455 int trafo_size_h = 1 << (log2_trafo_size + 1);
1456 int trafo_size_v = 1 << (log2_trafo_size +
sps->vshift[1]);
1457 for (
i = 0;
i < (
sps->chroma_format_idc == 2 ? 2 : 1);
i++) {
1460 trafo_size_h, trafo_size_v,
sps->log2_ctb_size);
1461 s->hpc.intra_pred[log2_trafo_size - 2](lc,
pps, xBase, yBase + (
i << log2_trafo_size), 1);
1465 log2_trafo_size, scan_idx_c, 1);
1467 for (
i = 0;
i < (
sps->chroma_format_idc == 2 ? 2 : 1);
i++) {
1470 trafo_size_h, trafo_size_v,
sps->log2_ctb_size);
1471 s->hpc.intra_pred[log2_trafo_size - 2](lc,
pps, xBase, yBase + (
i << log2_trafo_size), 2);
1475 log2_trafo_size, scan_idx_c, 2);
1479 if (log2_trafo_size > 2 ||
sps->chroma_format_idc == 3) {
1480 int trafo_size_h = 1 << (log2_trafo_size_c +
sps->hshift[1]);
1481 int trafo_size_v = 1 << (log2_trafo_size_c +
sps->vshift[1]);
1483 sps->log2_ctb_size);
1484 s->hpc.intra_pred[log2_trafo_size_c - 2](lc,
pps, x0, y0, 1);
1485 s->hpc.intra_pred[log2_trafo_size_c - 2](lc,
pps, x0, y0, 2);
1486 if (
sps->chroma_format_idc == 2) {
1488 trafo_size_h, trafo_size_v,
sps->log2_ctb_size);
1489 s->hpc.intra_pred[log2_trafo_size_c - 2](lc,
pps, x0, y0 + (1 << log2_trafo_size_c), 1);
1490 s->hpc.intra_pred[log2_trafo_size_c - 2](lc,
pps, x0, y0 + (1 << log2_trafo_size_c), 2);
1492 }
else if (blk_idx == 3) {
1493 int trafo_size_h = 1 << (log2_trafo_size + 1);
1494 int trafo_size_v = 1 << (log2_trafo_size +
sps->vshift[1]);
1496 trafo_size_h, trafo_size_v,
sps->log2_ctb_size);
1497 s->hpc.intra_pred[log2_trafo_size - 2](lc,
pps, xBase, yBase, 1);
1498 s->hpc.intra_pred[log2_trafo_size - 2](lc,
pps, xBase, yBase, 2);
1499 if (
sps->chroma_format_idc == 2) {
1501 trafo_size_h, trafo_size_v,
sps->log2_ctb_size);
1502 s->hpc.intra_pred[log2_trafo_size - 2](lc,
pps, xBase, yBase + (1 << log2_trafo_size), 1);
1503 s->hpc.intra_pred[log2_trafo_size - 2](lc,
pps, xBase, yBase + (1 << log2_trafo_size), 2);
1512 int x0,
int y0,
int log2_cb_size)
1514 int cb_size = 1 << log2_cb_size;
1515 int log2_min_pu_size =
sps->log2_min_pu_size;
1517 int min_pu_width =
sps->min_pu_width;
1518 int x_end =
FFMIN(x0 + cb_size,
sps->width);
1519 int y_end =
FFMIN(y0 + cb_size,
sps->height);
1522 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1523 for (
i = (x0 >> log2_min_pu_size);
i < (x_end >> log2_min_pu_size);
i++)
1524 is_pcm[
i + j * min_pu_width] = 2;
1531 int xBase,
int yBase,
int cb_xBase,
int cb_yBase,
1532 int log2_cb_size,
int log2_trafo_size,
1533 int trafo_depth,
int blk_idx,
1534 const int *base_cbf_cb,
const int *base_cbf_cr)
1537 uint8_t split_transform_flag;
1542 cbf_cb[0] = base_cbf_cb[0];
1543 cbf_cb[1] = base_cbf_cb[1];
1544 cbf_cr[0] = base_cbf_cr[0];
1545 cbf_cr[1] = base_cbf_cr[1];
1548 if (trafo_depth == 1) {
1550 if (
sps->chroma_format_idc == 3) {
1564 if (log2_trafo_size <= sps->log2_max_trafo_size &&
1565 log2_trafo_size >
sps->log2_min_tb_size &&
1566 trafo_depth < lc->cu.max_trafo_depth &&
1570 int inter_split =
sps->max_transform_hierarchy_depth_inter == 0 &&
1575 split_transform_flag = log2_trafo_size >
sps->log2_max_trafo_size ||
1580 if (
sps->chroma_format_idc && (log2_trafo_size > 2 ||
sps->chroma_format_idc == 3)) {
1581 if (trafo_depth == 0 || cbf_cb[0]) {
1583 if (
sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1588 if (trafo_depth == 0 || cbf_cr[0]) {
1590 if (
sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1596 if (split_transform_flag) {
1597 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1598 const int x1 = x0 + trafo_size_split;
1599 const int y1 = y0 + trafo_size_split;
1601 #define SUBDIVIDE(x, y, idx) \
1603 ret = hls_transform_tree(lc, l, pps, sps, \
1604 x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1605 log2_trafo_size - 1, trafo_depth + 1, idx, \
1618 int min_tu_size = 1 <<
sps->log2_min_tb_size;
1619 int log2_min_tu_size =
sps->log2_min_tb_size;
1620 int min_tu_width =
sps->min_tb_width;
1624 cbf_cb[0] || cbf_cr[0] ||
1625 (
sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1630 x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1631 log2_cb_size, log2_trafo_size,
1632 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1638 for (
i = 0;
i < (1 << log2_trafo_size);
i += min_tu_size)
1639 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1640 int x_tu = (x0 + j) >> log2_min_tu_size;
1641 int y_tu = (y0 +
i) >> log2_min_tu_size;
1642 l->
cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1645 if (!
s->sh.disable_deblocking_filter_flag) {
1647 if (
pps->transquant_bypass_enable_flag &&
1656 const HEVCPPS *
pps,
int x0,
int y0,
int log2_cb_size)
1661 int cb_size = 1 << log2_cb_size;
1662 ptrdiff_t stride0 =
s->cur_frame->f->linesize[0];
1663 ptrdiff_t stride1 =
s->cur_frame->f->linesize[1];
1664 ptrdiff_t stride2 =
s->cur_frame->f->linesize[2];
1665 uint8_t *dst0 = &
s->cur_frame->f->data[0][y0 * stride0 + (x0 <<
sps->pixel_shift)];
1666 uint8_t *dst1 = &
s->cur_frame->f->data[1][(y0 >>
sps->vshift[1]) * stride1 + ((x0 >>
sps->hshift[1]) <<
sps->pixel_shift)];
1667 uint8_t *dst2 = &
s->cur_frame->f->data[2][(y0 >>
sps->vshift[2]) * stride2 + ((x0 >>
sps->hshift[2]) <<
sps->pixel_shift)];
1669 int length = cb_size * cb_size *
sps->pcm.bit_depth +
1670 (((cb_size >>
sps->hshift[1]) * (cb_size >>
sps->vshift[1])) +
1671 ((cb_size >>
sps->hshift[2]) * (cb_size >>
sps->vshift[2]))) *
1672 sps->pcm.bit_depth_chroma;
1673 const uint8_t *pcm =
skip_bytes(&lc->
cc, (length + 7) >> 3);
1676 if (!
s->sh.disable_deblocking_filter_flag)
1683 s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size, &gb,
sps->pcm.bit_depth);
1684 if (
sps->chroma_format_idc) {
1685 s->hevcdsp.put_pcm(dst1, stride1,
1686 cb_size >>
sps->hshift[1],
1687 cb_size >>
sps->vshift[1],
1688 &gb,
sps->pcm.bit_depth_chroma);
1689 s->hevcdsp.put_pcm(dst2, stride2,
1690 cb_size >>
sps->hshift[2],
1691 cb_size >>
sps->vshift[2],
1692 &gb,
sps->pcm.bit_depth_chroma);
1716 uint8_t *
dst, ptrdiff_t dststride,
1718 int block_w,
int block_h,
int luma_weight,
int luma_offset)
1721 const uint8_t *
src =
ref->data[0];
1723 int pic_width =
sps->width;
1724 int pic_height =
sps->height;
1727 int weight_flag = (
s->sh.slice_type ==
HEVC_SLICE_P &&
pps->weighted_pred_flag) ||
1731 x_off +=
mv->x >> 2;
1732 y_off +=
mv->y >> 2;
1738 ref ==
s->cur_frame->f) {
1748 pic_width, pic_height);
1755 block_h,
mx,
my, block_w);
1758 block_h,
s->sh.luma_log2_weight_denom,
1759 luma_weight, luma_offset,
mx,
my, block_w);
1780 uint8_t *
dst, ptrdiff_t dststride,
1781 const AVFrame *ref0,
const Mv *mv0,
int x_off,
int y_off,
1782 int block_w,
int block_h,
const AVFrame *ref1,
1783 const Mv *mv1,
struct MvField *current_mv)
1786 ptrdiff_t src0stride = ref0->
linesize[0];
1787 ptrdiff_t src1stride = ref1->
linesize[0];
1788 int pic_width =
sps->width;
1789 int pic_height =
sps->height;
1790 int mx0 = mv0->
x & 3;
1791 int my0 = mv0->
y & 3;
1792 int mx1 = mv1->
x & 3;
1793 int my1 = mv1->
y & 3;
1794 int weight_flag = (
s->sh.slice_type ==
HEVC_SLICE_P &&
pps->weighted_pred_flag) ||
1796 int x_off0 = x_off + (mv0->
x >> 2);
1797 int y_off0 = y_off + (mv0->
y >> 2);
1798 int x_off1 = x_off + (mv1->
x >> 2);
1799 int y_off1 = y_off + (mv1->
y >> 2);
1802 const uint8_t *
src0 = ref0->
data[0] + y_off0 * src0stride + (int)((
unsigned)x_off0 <<
sps->pixel_shift);
1803 const uint8_t *
src1 = ref1->
data[0] + y_off1 * src1stride + (int)((
unsigned)x_off1 <<
sps->pixel_shift);
1813 edge_emu_stride, src0stride,
1817 pic_width, pic_height);
1819 src0stride = edge_emu_stride;
1830 edge_emu_stride, src1stride,
1834 pic_width, pic_height);
1836 src1stride = edge_emu_stride;
1839 s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](lc->
tmp,
src0, src0stride,
1840 block_h, mx0, my0, block_w);
1842 s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](
dst, dststride,
src1, src1stride, lc->
tmp,
1843 block_h, mx1, my1, block_w);
1845 s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](
dst, dststride,
src1, src1stride, lc->
tmp,
1846 block_h,
s->sh.luma_log2_weight_denom,
1847 s->sh.luma_weight_l0[current_mv->
ref_idx[0]],
1848 s->sh.luma_weight_l1[current_mv->
ref_idx[1]],
1849 s->sh.luma_offset_l0[current_mv->
ref_idx[0]],
1850 s->sh.luma_offset_l1[current_mv->
ref_idx[1]],
1875 ptrdiff_t dststride,
const uint8_t *
src0, ptrdiff_t
srcstride,
int reflist,
1876 int x_off,
int y_off,
int block_w,
int block_h,
1877 const struct MvField *current_mv,
int chroma_weight,
int chroma_offset)
1880 int pic_width =
sps->width >>
sps->hshift[1];
1881 int pic_height =
sps->height >>
sps->vshift[1];
1882 const Mv *
mv = ¤t_mv->
mv[reflist];
1883 int weight_flag = (
s->sh.slice_type ==
HEVC_SLICE_P &&
pps->weighted_pred_flag) ||
1886 int hshift =
sps->hshift[1];
1887 int vshift =
sps->vshift[1];
1890 intptr_t _mx =
mx << (1 - hshift);
1891 intptr_t _my =
my << (1 - vshift);
1892 int emu =
src0 ==
s->cur_frame->f->data[1] ||
src0 ==
s->cur_frame->f->data[2];
1894 x_off +=
mv->x >> (2 + hshift);
1895 y_off +=
mv->y >> (2 + vshift);
1905 (edge_emu_stride + (1 <<
sps->pixel_shift));
1911 pic_width, pic_height);
1918 block_h, _mx, _my, block_w);
1921 block_h,
s->sh.chroma_log2_weight_denom,
1922 chroma_weight, chroma_offset, _mx, _my, block_w);
1944 uint8_t *dst0, ptrdiff_t dststride,
1946 int x_off,
int y_off,
int block_w,
int block_h,
const MvField *current_mv,
int cidx)
1949 const uint8_t *
src1 = ref0->
data[cidx+1];
1950 const uint8_t *
src2 = ref1->
data[cidx+1];
1951 ptrdiff_t src1stride = ref0->
linesize[cidx+1];
1952 ptrdiff_t src2stride = ref1->
linesize[cidx+1];
1953 int weight_flag = (
s->sh.slice_type ==
HEVC_SLICE_P &&
pps->weighted_pred_flag) ||
1955 int pic_width =
sps->width >>
sps->hshift[1];
1956 int pic_height =
sps->height >>
sps->vshift[1];
1957 const Mv *
const mv0 = ¤t_mv->
mv[0];
1958 const Mv *
const mv1 = ¤t_mv->
mv[1];
1959 int hshift =
sps->hshift[1];
1960 int vshift =
sps->vshift[1];
1966 intptr_t _mx0 = mx0 << (1 - hshift);
1967 intptr_t _my0 = my0 << (1 - vshift);
1968 intptr_t _mx1 = mx1 << (1 - hshift);
1969 intptr_t _my1 = my1 << (1 - vshift);
1971 int x_off0 = x_off + (mv0->
x >> (2 + hshift));
1972 int y_off0 = y_off + (mv0->
y >> (2 + vshift));
1973 int x_off1 = x_off + (mv1->
x >> (2 + hshift));
1974 int y_off1 = y_off + (mv1->
y >> (2 + vshift));
1976 src1 += y_off0 * src1stride + (int)((
unsigned)x_off0 <<
sps->pixel_shift);
1977 src2 += y_off1 * src2stride + (int)((
unsigned)x_off1 <<
sps->pixel_shift);
1985 (edge_emu_stride + (1 <<
sps->pixel_shift));
1988 edge_emu_stride, src1stride,
1992 pic_width, pic_height);
1995 src1stride = edge_emu_stride;
2004 (edge_emu_stride + (1 <<
sps->pixel_shift));
2007 edge_emu_stride, src2stride,
2011 pic_width, pic_height);
2014 src2stride = edge_emu_stride;
2017 s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](lc->
tmp,
src1, src1stride,
2018 block_h, _mx0, _my0, block_w);
2020 s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0,
s->cur_frame->f->linesize[cidx+1],
2022 block_h, _mx1, _my1, block_w);
2024 s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0,
s->cur_frame->f->linesize[cidx+1],
2027 s->sh.chroma_log2_weight_denom,
2028 s->sh.chroma_weight_l0[current_mv->
ref_idx[0]][cidx],
2029 s->sh.chroma_weight_l1[current_mv->
ref_idx[1]][cidx],
2030 s->sh.chroma_offset_l0[current_mv->
ref_idx[0]][cidx],
2031 s->sh.chroma_offset_l1[current_mv->
ref_idx[1]][cidx],
2032 _mx1, _my1, block_w);
2047 int x0,
int y0,
int nPbW,
2048 int nPbH,
int log2_cb_size,
int part_idx,
2060 if (inter_pred_idc !=
PRED_L1) {
2061 if (
s->sh.nb_refs[
L0])
2068 part_idx, merge_idx,
mv, mvp_flag, 0);
2073 if (inter_pred_idc !=
PRED_L0) {
2074 if (
s->sh.nb_refs[
L1])
2077 if (
s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc ==
PRED_BI) {
2086 part_idx, merge_idx,
mv, mvp_flag, 1);
2095 int x0,
int y0,
int nPbW,
int nPbH,
2096 int log2_cb_size,
int partIdx,
int idx)
2098 #define POS(c_idx, x, y) \
2099 &s->cur_frame->f->data[c_idx] ? \
2100 &s->cur_frame->f->data[c_idx][((y) >> sps->vshift[c_idx]) * linesize[c_idx] + \
2101 (((x) >> sps->hshift[c_idx]) << sps->pixel_shift)] : NULL
2104 struct MvField current_mv = {{{ 0 }}};
2106 int min_pu_width =
sps->min_pu_width;
2108 MvField *tab_mvf =
s->cur_frame->tab_mvf;
2109 const RefPicList *refPicList =
s->cur_frame->refPicList;
2111 const int *linesize =
s->cur_frame->f->linesize;
2112 uint8_t *dst0 =
s->cur_frame->f->data[0] + y0 * linesize[0] + (x0 <<
sps->pixel_shift);
2113 uint8_t *dst1 =
POS(1, x0, y0);
2114 uint8_t *dst2 =
POS(2, x0, y0);
2115 int log2_min_cb_size =
sps->log2_min_cb_size;
2116 int min_cb_width =
sps->min_cb_width;
2117 int x_cb = x0 >> log2_min_cb_size;
2118 int y_cb = y0 >> log2_min_cb_size;
2128 if (
s->sh.max_num_merge_cand > 1)
2134 partIdx, merge_idx, ¤t_mv);
2137 partIdx, merge_idx, ¤t_mv);
2140 x_pu = x0 >>
sps->log2_min_pu_size;
2141 y_pu = y0 >>
sps->log2_min_pu_size;
2143 for (j = 0; j < nPbH >>
sps->log2_min_pu_size; j++)
2144 for (
i = 0; i < nPbW >>
sps->log2_min_pu_size;
i++)
2145 tab_mvf[(y_pu + j) * min_pu_width + x_pu +
i] = current_mv;
2148 ref0 = refPicList[0].
ref[current_mv.
ref_idx[0]];
2149 if (!ref0 || !ref0->
f)
2154 ref1 = refPicList[1].
ref[current_mv.
ref_idx[1]];
2155 if (!ref1 || !ref1->f)
2161 int x0_c = x0 >>
sps->hshift[1];
2162 int y0_c = y0 >>
sps->vshift[1];
2163 int nPbW_c = nPbW >>
sps->hshift[1];
2164 int nPbH_c = nPbH >>
sps->vshift[1];
2167 ¤t_mv.
mv[0], x0, y0, nPbW, nPbH,
2168 s->sh.luma_weight_l0[current_mv.
ref_idx[0]],
2169 s->sh.luma_offset_l0[current_mv.
ref_idx[0]]);
2171 if (
sps->chroma_format_idc) {
2173 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
2174 s->sh.chroma_weight_l0[current_mv.
ref_idx[0]][0],
s->sh.chroma_offset_l0[current_mv.
ref_idx[0]][0]);
2176 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
2177 s->sh.chroma_weight_l0[current_mv.
ref_idx[0]][1],
s->sh.chroma_offset_l0[current_mv.
ref_idx[0]][1]);
2180 int x0_c = x0 >>
sps->hshift[1];
2181 int y0_c = y0 >>
sps->vshift[1];
2182 int nPbW_c = nPbW >>
sps->hshift[1];
2183 int nPbH_c = nPbH >>
sps->vshift[1];
2186 ¤t_mv.
mv[1], x0, y0, nPbW, nPbH,
2187 s->sh.luma_weight_l1[current_mv.
ref_idx[1]],
2188 s->sh.luma_offset_l1[current_mv.
ref_idx[1]]);
2190 if (
sps->chroma_format_idc) {
2192 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
2193 s->sh.chroma_weight_l1[current_mv.
ref_idx[1]][0],
s->sh.chroma_offset_l1[current_mv.
ref_idx[1]][0]);
2196 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
2197 s->sh.chroma_weight_l1[current_mv.
ref_idx[1]][1],
s->sh.chroma_offset_l1[current_mv.
ref_idx[1]][1]);
2200 int x0_c = x0 >>
sps->hshift[1];
2201 int y0_c = y0 >>
sps->vshift[1];
2202 int nPbW_c = nPbW >>
sps->hshift[1];
2203 int nPbH_c = nPbH >>
sps->vshift[1];
2206 ¤t_mv.
mv[0], x0, y0, nPbW, nPbH,
2207 ref1->f, ¤t_mv.
mv[1], ¤t_mv);
2209 if (
sps->chroma_format_idc) {
2211 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 0);
2214 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1);
2224 int x0,
int y0,
int pu_size,
2225 int prev_intra_luma_pred_flag)
2228 int x_pu = x0 >>
sps->log2_min_pu_size;
2229 int y_pu = y0 >>
sps->log2_min_pu_size;
2230 int min_pu_width =
sps->min_pu_width;
2231 int size_in_pus = pu_size >>
sps->log2_min_pu_size;
2240 int y_ctb = (y0 >> (
sps->log2_ctb_size)) << (
sps->log2_ctb_size);
2242 MvField *tab_mvf =
s->cur_frame->tab_mvf;
2243 int intra_pred_mode;
2248 if ((y0 - 1) < y_ctb)
2251 if (cand_left == cand_up) {
2252 if (cand_left < 2) {
2257 candidate[0] = cand_left;
2258 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
2259 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
2262 candidate[0] = cand_left;
2263 candidate[1] = cand_up;
2273 if (prev_intra_luma_pred_flag) {
2274 intra_pred_mode = candidate[lc->
pu.
mpm_idx];
2276 if (candidate[0] > candidate[1])
2277 FFSWAP(uint8_t, candidate[0], candidate[1]);
2278 if (candidate[0] > candidate[2])
2279 FFSWAP(uint8_t, candidate[0], candidate[2]);
2280 if (candidate[1] > candidate[2])
2281 FFSWAP(uint8_t, candidate[1], candidate[2]);
2284 for (
i = 0;
i < 3;
i++)
2285 if (intra_pred_mode >= candidate[
i])
2292 for (
i = 0;
i < size_in_pus;
i++) {
2293 memset(&l->
tab_ipm[(y_pu +
i) * min_pu_width + x_pu],
2294 intra_pred_mode, size_in_pus);
2296 for (j = 0; j < size_in_pus; j++) {
2301 return intra_pred_mode;
2306 int log2_cb_size,
int ct_depth)
2308 int length = (1 << log2_cb_size) >>
sps->log2_min_cb_size;
2309 int x_cb = x0 >>
sps->log2_min_cb_size;
2310 int y_cb = y0 >>
sps->log2_min_cb_size;
2313 for (y = 0; y < length; y++)
2314 memset(&tab_ct_depth[(y_cb + y) *
sps->min_cb_width + x_cb],
2319 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
2320 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
2327 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
2328 uint8_t prev_intra_luma_pred_flag[4];
2330 int pb_size = (1 << log2_cb_size) >>
split;
2331 int side =
split + 1;
2335 for (
i = 0;
i < side;
i++)
2336 for (j = 0; j < side; j++)
2339 for (
i = 0;
i < side;
i++) {
2340 for (j = 0; j < side; j++) {
2341 if (prev_intra_luma_pred_flag[2 *
i + j])
2348 x0 + pb_size * j, y0 + pb_size *
i, pb_size,
2349 prev_intra_luma_pred_flag[2 *
i + j]);
2353 if (
sps->chroma_format_idc == 3) {
2354 for (
i = 0;
i < side;
i++) {
2355 for (j = 0; j < side; j++) {
2357 if (chroma_mode != 4) {
2367 }
else if (
sps->chroma_format_idc == 2) {
2370 if (chroma_mode != 4) {
2374 mode_idx = intra_chroma_table[chroma_mode];
2379 }
else if (
sps->chroma_format_idc != 0) {
2381 if (chroma_mode != 4) {
2399 int pb_size = 1 << log2_cb_size;
2400 int size_in_pus = pb_size >>
sps->log2_min_pu_size;
2401 int min_pu_width =
sps->min_pu_width;
2402 MvField *tab_mvf =
s->cur_frame->tab_mvf;
2403 int x_pu = x0 >>
sps->log2_min_pu_size;
2404 int y_pu = y0 >>
sps->log2_min_pu_size;
2407 if (size_in_pus == 0)
2409 for (j = 0; j < size_in_pus; j++)
2410 memset(&l->
tab_ipm[(y_pu + j) * min_pu_width + x_pu],
INTRA_DC, size_in_pus);
2412 for (j = 0; j < size_in_pus; j++)
2413 for (k = 0; k < size_in_pus; k++)
2420 int x0,
int y0,
int log2_cb_size)
2422 int cb_size = 1 << log2_cb_size;
2423 int log2_min_cb_size =
sps->log2_min_cb_size;
2424 int length = cb_size >> log2_min_cb_size;
2425 int min_cb_width =
sps->min_cb_width;
2426 int x_cb = x0 >> log2_min_cb_size;
2427 int y_cb = y0 >> log2_min_cb_size;
2428 int idx = log2_cb_size - 2;
2429 int qp_block_mask = (1 << (
sps->log2_ctb_size -
pps->diff_cu_qp_delta_depth)) - 1;
2439 for (x = 0; x < 4; x++)
2441 if (
pps->transquant_bypass_enable_flag) {
2452 x0b, y0b, x_cb, y_cb,
2455 x = y_cb * min_cb_width + x_cb;
2456 for (y = 0; y < length; y++) {
2457 memset(&l->
skip_flag[x], skip_flag, length);
2462 x = y_cb * min_cb_width + x_cb;
2463 for (y = 0; y < length; y++) {
2471 x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2474 if (!
s->sh.disable_deblocking_filter_flag)
2482 log2_cb_size ==
sps->log2_min_cb_size) {
2490 log2_cb_size >=
sps->pcm.log2_min_pcm_cb_size &&
2491 log2_cb_size <= sps->pcm.log2_max_pcm_cb_size) {
2497 if (
sps->pcm_loop_filter_disabled)
2510 x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2514 x0, y0, cb_size, cb_size / 2, log2_cb_size, 0, idx);
2516 x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2520 x0, y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2522 x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2526 x0, y0, cb_size, cb_size / 4, log2_cb_size, 0, idx);
2528 x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2532 x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2534 x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2538 x0, y0, cb_size / 4, cb_size, log2_cb_size, 0, idx - 2);
2540 x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2544 x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2546 x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2550 x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2552 x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2554 x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2556 x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2562 int rqt_root_cbf = 1;
2569 const static int cbf[2] = { 0 };
2572 sps->max_transform_hierarchy_depth_inter;
2573 ret =
hls_transform_tree(lc, l,
pps,
sps, x0, y0, x0, y0, x0, y0,
2575 log2_cb_size, 0, 0, cbf, cbf);
2579 if (!
s->sh.disable_deblocking_filter_flag)
2588 x = y_cb * min_cb_width + x_cb;
2589 for (y = 0; y < length; y++) {
2594 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2595 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2608 int log2_cb_size,
int cb_depth)
2611 const int cb_size = 1 << log2_cb_size;
2616 if (x0 + cb_size <= sps->
width &&
2617 y0 + cb_size <= sps->
height &&
2618 log2_cb_size >
sps->log2_min_cb_size) {
2620 sps, cb_depth, x0, y0);
2622 split_cu = (log2_cb_size >
sps->log2_min_cb_size);
2624 if (
pps->cu_qp_delta_enabled_flag &&
2625 log2_cb_size >=
sps->log2_ctb_size -
pps->diff_cu_qp_delta_depth) {
2630 if (
s->sh.cu_chroma_qp_offset_enabled_flag &&
2631 log2_cb_size >=
sps->log2_ctb_size -
pps->diff_cu_chroma_qp_offset_depth) {
2636 int qp_block_mask = (1 << (
sps->log2_ctb_size -
pps->diff_cu_qp_delta_depth)) - 1;
2637 const int cb_size_split = cb_size >> 1;
2638 const int x1 = x0 + cb_size_split;
2639 const int y1 = y0 + cb_size_split;
2644 x0, y0, log2_cb_size - 1, cb_depth + 1);
2648 if (more_data && x1 < sps->
width) {
2650 x1, y0, log2_cb_size - 1, cb_depth + 1);
2654 if (more_data && y1 < sps->
height) {
2656 x0, y1, log2_cb_size - 1, cb_depth + 1);
2660 if (more_data && x1 < sps->
width &&
2663 x1, y1, log2_cb_size - 1, cb_depth + 1);
2668 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2669 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2673 return ((x1 + cb_size_split) <
sps->width ||
2674 (y1 + cb_size_split) <
sps->height);
2681 if ((!((x0 + cb_size) %
2682 (1 << (
sps->log2_ctb_size))) ||
2683 (x0 + cb_size >=
sps->width)) &&
2685 (1 << (
sps->log2_ctb_size))) ||
2686 (y0 + cb_size >=
sps->height))) {
2688 return !end_of_slice_flag;
2700 int x_ctb,
int y_ctb,
int ctb_addr_ts)
2703 int ctb_size = 1 <<
sps->log2_ctb_size;
2704 int ctb_addr_rs =
pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2705 int ctb_addr_in_slice = ctb_addr_rs -
s->sh.slice_addr;
2709 if (
pps->entropy_coding_sync_enabled_flag) {
2710 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2713 }
else if (
pps->tiles_enabled_flag) {
2714 if (ctb_addr_ts &&
pps->tile_id[ctb_addr_ts] !=
pps->tile_id[ctb_addr_ts - 1]) {
2715 int idxX =
pps->col_idxX[x_ctb >>
sps->log2_ctb_size];
2726 if (
pps->tiles_enabled_flag) {
2727 if (x_ctb > 0 &&
pps->tile_id[ctb_addr_ts] !=
pps->tile_id[
pps->ctb_addr_rs_to_ts[ctb_addr_rs - 1]])
2731 if (y_ctb > 0 &&
pps->tile_id[ctb_addr_ts] !=
pps->tile_id[
pps->ctb_addr_rs_to_ts[ctb_addr_rs -
sps->ctb_width]])
2736 if (ctb_addr_in_slice <= 0)
2738 if (ctb_addr_in_slice < sps->ctb_width)
2744 lc->
ctb_up_right_flag = ((y_ctb > 0) && (ctb_addr_in_slice+1 >=
sps->ctb_width) && (
pps->tile_id[ctb_addr_ts] ==
pps->tile_id[
pps->ctb_addr_rs_to_ts[ctb_addr_rs+1 -
sps->ctb_width]]));
2745 lc->
ctb_up_left_flag = ((x_ctb > 0) && (y_ctb > 0) && (ctb_addr_in_slice-1 >=
sps->ctb_width) && (
pps->tile_id[ctb_addr_ts] ==
pps->tile_id[
pps->ctb_addr_rs_to_ts[ctb_addr_rs-1 -
sps->ctb_width]]));
2754 const uint8_t *slice_data = gb->
buffer +
s->sh.data_offset;
2756 int ctb_size = 1 <<
sps->log2_ctb_size;
2760 int ctb_addr_ts =
pps->ctb_addr_rs_to_ts[
s->sh.slice_ctb_addr_rs];
2763 while (more_data && ctb_addr_ts < sps->ctb_size) {
2764 int ctb_addr_rs =
pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2766 x_ctb = (ctb_addr_rs % ((
sps->width + ctb_size - 1) >>
sps->log2_ctb_size)) <<
sps->log2_ctb_size;
2767 y_ctb = (ctb_addr_rs / ((
sps->width + ctb_size - 1) >>
sps->log2_ctb_size)) <<
sps->log2_ctb_size;
2777 x_ctb >>
sps->log2_ctb_size, y_ctb >>
sps->log2_ctb_size);
2784 if (more_data < 0) {
2795 if (x_ctb + ctb_size >=
sps->width &&
2796 y_ctb + ctb_size >=
sps->height)
2803 int job,
int thread)
2810 int ctb_size = 1 <<
sps->log2_ctb_size;
2813 int ctb_addr_rs =
s->sh.slice_ctb_addr_rs + ctb_row * ((
sps->width + ctb_size - 1) >>
sps->log2_ctb_size);
2814 int ctb_addr_ts =
pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2816 const uint8_t *
data =
s->data +
s->sh.offset[ctb_row];
2817 const size_t data_size =
s->sh.size[ctb_row];
2826 while(more_data && ctb_addr_ts < sps->ctb_size) {
2827 int x_ctb = (ctb_addr_rs %
sps->ctb_width) <<
sps->log2_ctb_size;
2828 int y_ctb = (ctb_addr_rs /
sps->ctb_width) <<
sps->log2_ctb_size;
2848 x_ctb >>
sps->log2_ctb_size, y_ctb >>
sps->log2_ctb_size);
2856 if (more_data < 0) {
2867 if (!more_data && (x_ctb+ctb_size) <
sps->width && ctb_row !=
s->sh.num_entry_point_offsets) {
2874 if ((x_ctb+ctb_size) >=
sps->width && (y_ctb+ctb_size) >=
sps->height ) {
2879 ctb_addr_rs =
pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2882 if(x_ctb >=
sps->width) {
2899 if (
s->nb_wpp_progress < count) {
2901 sizeof(*
s->wpp_progress));
2905 s->wpp_progress =
tmp;
2906 memset(
s->wpp_progress +
s->nb_wpp_progress, 0,
2907 (count -
s->nb_wpp_progress) *
sizeof(*
s->wpp_progress));
2909 for (
int i =
s->nb_wpp_progress;
i < count;
i++) {
2913 s->nb_wpp_progress =
i + 1;
2917 for (
int i = 0;
i < count;
i++)
2928 int length = nal->
size;
2931 int64_t startheader, cmpt = 0;
2934 if (
s->sh.slice_ctb_addr_rs +
s->sh.num_entry_point_offsets *
sps->ctb_width >=
sps->ctb_width *
sps->ctb_height) {
2936 s->sh.slice_ctb_addr_rs,
s->sh.num_entry_point_offsets,
2937 sps->ctb_width,
sps->ctb_height
2942 if (
s->avctx->thread_count >
s->nb_local_ctx) {
2948 memcpy(
tmp,
s->local_ctx,
sizeof(*
s->local_ctx) *
s->nb_local_ctx);
2952 for (
unsigned i =
s->nb_local_ctx; i < s->avctx->thread_count;
i++) {
2953 tmp = &
s->local_ctx[
i];
2955 memset(
tmp, 0,
sizeof(*
tmp));
2957 tmp->logctx =
s->avctx;
2959 tmp->common_cabac_state = &
s->cabac;
2962 s->nb_local_ctx =
s->avctx->thread_count;
2967 for (j = 0, cmpt = 0, startheader =
offset +
s->sh.entry_point_offset[0]; j < nal->skipped_bytes; j++) {
2974 for (
i = 1;
i <
s->sh.num_entry_point_offsets;
i++) {
2975 offset += (
s->sh.entry_point_offset[
i - 1] - cmpt);
2976 for (j = 0, cmpt = 0, startheader =
offset
2977 +
s->sh.entry_point_offset[
i]; j < nal->skipped_bytes; j++) {
2983 s->sh.size[
i] =
s->sh.entry_point_offset[
i] - cmpt;
2988 offset +=
s->sh.entry_point_offset[
s->sh.num_entry_point_offsets - 1] - cmpt;
2993 s->sh.size [
s->sh.num_entry_point_offsets] = length -
offset;
2994 s->sh.offset[
s->sh.num_entry_point_offsets] =
offset;
2996 s->sh.offset[0] =
s->sh.data_offset;
2997 s->sh.size[0] =
s->sh.offset[1] -
s->sh.offset[0];
3001 for (
i = 1;
i <
s->nb_local_ctx;
i++) {
3002 s->local_ctx[
i].first_qp_group = 1;
3003 s->local_ctx[
i].qp_y =
s->local_ctx[0].qp_y;
3015 if (
pps->entropy_coding_sync_enabled_flag)
3018 for (
i = 0;
i <=
s->sh.num_entry_point_offsets;
i++)
3031 if (!
s->sh.first_slice_in_pic_flag)
3032 s->slice_idx += !
s->sh.dependent_slice_segment_flag;
3034 if (!
s->sh.dependent_slice_segment_flag &&
s->sh.slice_type !=
HEVC_SLICE_I) {
3038 "Error constructing the reference lists for the current slice.\n");
3043 s->slice_initialized = 1;
3045 if (
s->avctx->hwaccel)
3050 "SCC profile is not yet implemented in hevc native decoder.\n");
3054 if (
s->sh.dependent_slice_segment_flag) {
3055 int ctb_addr_ts =
pps->ctb_addr_rs_to_ts[
s->sh.slice_ctb_addr_rs];
3056 int prev_rs =
pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
3063 s->local_ctx[0].first_qp_group = !
s->sh.dependent_slice_segment_flag;
3065 if (!
pps->cu_qp_delta_enabled_flag)
3066 s->local_ctx[0].qp_y =
s->sh.slice_qp;
3068 s->local_ctx[0].tu.cu_qp_offset_cb = 0;
3069 s->local_ctx[0].tu.cu_qp_offset_cr = 0;
3072 s->sh.num_entry_point_offsets > 0 &&
3073 pps->num_tile_rows == 1 &&
pps->num_tile_columns == 1)
3088 if (
IS_IRAP(
s) &&
s->no_rasl_output_flag) {
3089 if (
s->sei.common.mastering_display.present > 0)
3090 s->sei.common.mastering_display.present--;
3092 if (
s->sei.common.content_light.present > 0)
3093 s->sei.common.content_light.present--;
3098 sps->bit_depth,
sps->bit_depth_chroma,
3099 s->cur_frame->poc );
3103 if (
s->sei.timecode.present) {
3108 sizeof(uint32_t) * 4, &tcside);
3113 tc_sd = (uint32_t*)tcside->
data;
3114 tc_sd[0] =
s->sei.timecode.num_clock_ts;
3116 for (
int i = 0;
i < tc_sd[0];
i++) {
3117 int drop =
s->sei.timecode.cnt_dropped_flag[
i];
3118 int hh =
s->sei.timecode.hours_value[
i];
3119 int mm =
s->sei.timecode.minutes_value[
i];
3120 int ss =
s->sei.timecode.seconds_value[
i];
3121 int ff =
s->sei.timecode.n_frames[
i];
3129 s->sei.timecode.num_clock_ts = 0;
3132 if (
s->sei.common.dynamic_hdr_plus.info) {
3153 if (
s->sei.common.dynamic_hdr_vivid.info) {
3156 &
s->sei.common.dynamic_hdr_vivid.info,
3168 for (
int i = nal_idx;
i <
s->pkt.nb_nals;
i++) {
3174 !(
s->layers_active_decode & (1 <<
s->vps->layer_idx[layer_id])))
3177 switch (nal->
type) {
3210 const HEVCPPS *
const pps =
s->ps.pps_list[
s->sh.pps_id];
3212 int pic_size_in_ctb = ((
sps->width >>
sps->log2_min_cb_size) + 1) *
3213 ((
sps->height >>
sps->log2_min_cb_size) + 1);
3214 int new_sequence = (l == &
s->layers[0]) &&
3216 int prev_layers_active_decode =
s->layers_active_decode;
3217 int prev_layers_active_output =
s->layers_active_output;
3220 if (
sps->vps !=
s->vps && l != &
s->layers[0]) {
3228 const HEVCSPS *sps_base =
s->layers[0].sps;
3231 if (l != &
s->layers[0]) {
3234 "Access unit starts with a non-base layer frame\n");
3243 !
sps->vui.common.video_signal_type_present_flag)
3256 "Base/non-base layer SPS have unsupported parameter combination\n");
3267 if (l == &
s->layers[0]) {
3283 memset(l->
is_pcm, 0, (
sps->min_pu_width + 1) * (
sps->min_pu_height + 1));
3290 s->first_nal_type =
s->nal_unit_type;
3300 s->sei.recovery_point.has_recovery_poc) {
3302 s->recovery_poc =
s->poc +
s->sei.recovery_point.recovery_poc_cnt;
3303 else if (
s->poc >=
s->recovery_poc)
3308 if (
s->temporal_id == 0 &&
3316 s->poc_tid0 =
s->poc;
3318 if (
pps->tiles_enabled_flag)
3319 s->local_ctx[0].end_of_tiles_x =
pps->column_width[0] <<
sps->log2_ctb_size;
3323 0, 0,
s->sh.no_output_of_prior_pics_flag);
3347 s->cur_frame->needs_fg = ((
s->sei.common.film_grain_characteristics &&
3348 s->sei.common.film_grain_characteristics->present) ||
3349 s->sei.common.aom_film_grain.enable) &&
3357 if (
s->cur_frame->needs_fg &&
3358 (
s->sei.common.film_grain_characteristics &&
s->sei.common.film_grain_characteristics->present &&
3360 s->cur_frame->f->format) ||
3363 "Unsupported film grain parameters. Ignoring film grain.\n");
3364 s->cur_frame->needs_fg = 0;
3367 if (
s->cur_frame->needs_fg) {
3368 s->cur_frame->frame_grain->format =
s->cur_frame->f->format;
3369 s->cur_frame->frame_grain->width =
s->cur_frame->f->width;
3370 s->cur_frame->frame_grain->height =
s->cur_frame->f->height;
3379 s->cur_frame->f->pict_type = 3 -
s->sh.slice_type;
3382 sps->temporal_layer[
sps->max_sub_layers - 1].num_reorder_pics,
3383 sps->temporal_layer[
sps->max_sub_layers - 1].max_dec_pic_buffering, 0);
3387 if (
s->avctx->hwaccel) {
3399 if (l == &
s->layers[0])
3402 if (nal_idx >=
s->finish_setup_nal_idx)
3411 s->cur_frame =
s->collocated_ref =
NULL;
3412 s->slice_initialized = 0;
3419 char msg_buf[4 * (50 + 2 * 2 * 16 )];
3427 pixel_shift =
desc->comp[0].depth > 8;
3432 if (pixel_shift && !
s->checksum_buf) {
3435 frame->linesize[2]));
3436 if (!
s->checksum_buf)
3443 int width =
s->avctx->coded_width;
3444 int height =
s->avctx->coded_height;
3450 for (j = 0; j <
h; j++) {
3454 s->bdsp.bswap16_buf((uint16_t *)
s->checksum_buf,
3455 (
const uint16_t *)
src,
w);
3456 src =
s->checksum_buf;
3463 #define MD5_PRI "%016" PRIx64 "%016" PRIx64
3464 #define MD5_PRI_ARG(buf) AV_RB64(buf), AV_RB64((const uint8_t*)(buf) + 8)
3466 if (!memcmp(
md5,
s->sei.picture_hash.md5[
i], 16)) {
3468 "plane %d - correct " MD5_PRI "; ",
3472 "mismatching checksum of plane %d - " MD5_PRI " != " MD5_PRI "; ",
3479 "Verifying checksum for frame with POC %d: %s\n",
3491 if (
out->needs_fg) {
3494 switch (fgp->
type) {
3509 if (
s->avctx->hwaccel) {
3513 "hardware accelerator failed to decode picture\n");
3518 s->sei.picture_hash.is_md5) {
3524 s->sei.picture_hash.is_md5 = 0;
3527 l -
s->layers,
s->poc);
3534 const int layer_idx =
s->vps ?
s->vps->layer_idx[
s->nuh_layer_id] : 0;
3541 if (layer_idx < 0 ||
3542 (
s->nuh_layer_id > 0 && !(
s->layers_active_decode & (1 << layer_idx))))
3548 s->slice_initialized = 0;
3556 s->no_rasl_output_flag)) {
3561 if (
s->cur_layer != layer_idx &&
3562 s->layers[
s->cur_layer].cur_frame &&
3566 s->cur_layer = layer_idx;
3567 l = &
s->layers[
s->cur_layer];
3569 if (
s->sh.first_slice_in_pic_flag) {
3571 av_log(
s->avctx,
AV_LOG_ERROR,
"Two slices reporting being the first in the same frame.\n");
3583 if (
s->nal_unit_type !=
s->first_nal_type) {
3585 "Non-matching NAL types of the VCL NALUs: %d %d\n",
3586 s->first_nal_type,
s->nal_unit_type);
3603 s->nal_unit_type = nal->
type;
3619 switch (
s->nal_unit_type) {
3670 "Skipping NAL unit %d\n",
s->nal_unit_type);
3678 "Skipping invalid undecodable NALU: %d\n",
s->nal_unit_type);
3687 s->sei.recovery_point.has_recovery_poc = 0;
3693 int eos_at_start = 1;
3696 s->cur_frame =
s->collocated_ref =
NULL;
3697 s->last_eos =
s->eos;
3699 s->slice_initialized = 0;
3711 s->nal_length_size,
s->avctx->codec_id,
flags);
3714 "Error splitting the input into NAL units.\n");
3718 for (
i = 0;
i <
s->pkt.nb_nals;
i++) {
3741 s->pkt.nals[
s->pkt.nb_nals - 1].size > 2 && !
s->pkt.nals[
s->pkt.nb_nals - 1].nuh_layer_id
3742 && !
s->pkt.nals[
s->pkt.nb_nals - 1].temporal_id) {
3743 H2645NAL *nal = &
s->pkt.nals[
s->pkt.nb_nals - 1];
3746 av_log(
s->avctx,
AV_LOG_WARNING,
"Multiple Dolby Vision RPUs found in one AU. Skipping previous.\n");
3755 s->avctx->err_recognition);
3764 for (
i = 0;
i <
s->pkt.nb_nals;
i++) {
3774 "Error parsing NAL unit #%d.\n",
i);
3801 &
s->nal_length_size,
s->avctx->err_recognition,
3802 s->apply_defdispwin,
s->avctx);
3808 if (
first &&
s->ps.sps_list[
i]) {
3847 s->layers_active_output, 0, 0, 0);
3854 s->pkt_dts = avpkt->
dts;
3857 if (sd && sd_size > 0) {
3864 if (sd && sd_size >=
sizeof(
s->dovi_ctx.cfg)) {
3865 int old =
s->dovi_ctx.cfg.dv_profile;
3869 "New DOVI configuration record from input packet (profile %d -> %u).\n",
3870 old,
s->dovi_ctx.cfg.dv_profile);
3894 if (
src->needs_fg) {
3907 dst->nb_rpl_elems =
src->nb_rpl_elems;
3910 dst->ctb_count =
src->ctb_count;
3913 dst->base_layer_frame =
src->base_layer_frame;
3916 src->hwaccel_picture_private);
3950 for (
int i = 0;
i <
s->nb_wpp_progress;
i++)
3976 s->nb_local_ctx = 1;
3978 s->local_ctx[0].parent =
s;
3979 s->local_ctx[0].logctx = avctx;
3980 s->local_ctx[0].common_cabac_state = &
s->cabac;
3983 if (!
s->output_fifo)
4001 s->dovi_ctx.logctx = avctx;
4060 memcmp(
s->view_ids, s0->
view_ids,
sizeof(*
s->view_ids) *
s->nb_view_ids)) {
4107 if (
sei->tdrdi.num_ref_displays) {
4121 tdrdi->prec_ref_display_width =
sei->tdrdi.prec_ref_display_width;
4122 tdrdi->ref_viewing_distance_flag =
sei->tdrdi.ref_viewing_distance_flag;
4123 tdrdi->prec_ref_viewing_dist =
sei->tdrdi.prec_ref_viewing_dist;
4124 tdrdi->num_ref_displays =
sei->tdrdi.num_ref_displays;
4125 for (
int i = 0;
i <
sei->tdrdi.num_ref_displays;
i++) {
4161 s->sei.picture_timing.picture_struct = 0;
4181 if (sd && sd->
size >=
sizeof(
s->dovi_ctx.cfg))
4201 #define OFFSET(x) offsetof(HEVCContext, x)
4202 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
4205 {
"apply_defdispwin",
"Apply default display window from VUI",
OFFSET(apply_defdispwin),
4207 {
"strict-displaywin",
"stricly apply default display window size",
OFFSET(apply_defdispwin),
4209 {
"view_ids",
"Array of view IDs that should be decoded and output; a single -1 to decode all views",
4211 .min = -1, .max = INT_MAX, .flags =
PAR },
4212 {
"view_ids_available",
"Array of available view IDs is exported here",
4215 {
"view_pos_available",
"Array of view positions for view_ids_available is exported here, as AVStereo3DView",
4251 #if CONFIG_HEVC_DXVA2_HWACCEL
4254 #if CONFIG_HEVC_D3D11VA_HWACCEL
4257 #if CONFIG_HEVC_D3D11VA2_HWACCEL
4260 #if CONFIG_HEVC_D3D12VA_HWACCEL
4263 #if CONFIG_HEVC_NVDEC_HWACCEL
4266 #if CONFIG_HEVC_VAAPI_HWACCEL
4269 #if CONFIG_HEVC_VDPAU_HWACCEL
4272 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
4275 #if CONFIG_HEVC_VULKAN_HWACCEL