26 #include "config_components.h"
56 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 };
94 int log2_min_cb_size =
sps->log2_min_cb_size;
97 int pic_size_in_ctb = ((
width >> log2_min_cb_size) + 1) *
98 ((
height >> log2_min_cb_size) + 1);
99 int ctb_count =
sps->ctb_width *
sps->ctb_height;
100 int min_pu_size =
sps->min_pu_width *
sps->min_pu_height;
102 s->bs_width = (
width >> 2) + 1;
103 s->bs_height = (
height >> 2) + 1;
106 s->deblock =
av_calloc(ctb_count,
sizeof(*
s->deblock));
107 if (!
s->sao || !
s->deblock)
112 if (!
s->skip_flag || !
s->tab_ct_depth)
118 if (!
s->tab_ipm || !
s->cbf_luma || !
s->is_pcm)
123 sizeof(*
s->tab_slice_address));
125 sizeof(*
s->qp_y_tab));
126 if (!
s->qp_y_tab || !
s->filter_slice_edges || !
s->tab_slice_address)
129 s->horizontal_bs =
av_calloc(
s->bs_width,
s->bs_height);
131 if (!
s->horizontal_bs || !
s->vertical_bs)
136 if (!
s->tab_mvf_pool || !
s->rpl_tab_pool)
151 uint8_t luma_weight_l0_flag[16];
152 uint8_t chroma_weight_l0_flag[16];
153 uint8_t luma_weight_l1_flag[16];
154 uint8_t chroma_weight_l1_flag[16];
155 int luma_log2_weight_denom;
158 if (luma_log2_weight_denom < 0 || luma_log2_weight_denom > 7) {
159 av_log(logctx,
AV_LOG_ERROR,
"luma_log2_weight_denom %d is invalid\n", luma_log2_weight_denom);
163 if (
sps->chroma_format_idc != 0) {
164 int64_t chroma_log2_weight_denom = luma_log2_weight_denom + (int64_t)
get_se_golomb(gb);
165 if (chroma_log2_weight_denom < 0 || chroma_log2_weight_denom > 7) {
166 av_log(logctx,
AV_LOG_ERROR,
"chroma_log2_weight_denom %"PRId64
" is invalid\n", chroma_log2_weight_denom);
174 if (!luma_weight_l0_flag[
i]) {
179 if (
sps->chroma_format_idc != 0) {
184 chroma_weight_l0_flag[
i] = 0;
187 if (luma_weight_l0_flag[
i]) {
189 if ((int8_t)delta_luma_weight_l0 != delta_luma_weight_l0)
194 if (chroma_weight_l0_flag[
i]) {
195 for (j = 0; j < 2; j++) {
199 if ( (int8_t)delta_chroma_weight_l0 != delta_chroma_weight_l0
200 || delta_chroma_offset_l0 < -(1<<17) || delta_chroma_offset_l0 > (1<<17)) {
218 if (!luma_weight_l1_flag[
i]) {
223 if (
sps->chroma_format_idc != 0) {
228 chroma_weight_l1_flag[
i] = 0;
231 if (luma_weight_l1_flag[
i]) {
233 if ((int8_t)delta_luma_weight_l1 != delta_luma_weight_l1)
238 if (chroma_weight_l1_flag[
i]) {
239 for (j = 0; j < 2; j++) {
243 if ( (int8_t)delta_chroma_weight_l1 != delta_chroma_weight_l1
244 || delta_chroma_offset_l1 < -(1<<17) || delta_chroma_offset_l1 > (1<<17)) {
266 int max_poc_lsb = 1 <<
sps->log2_max_poc_lsb;
267 int prev_delta_msb = 0;
268 unsigned int nb_sps = 0, nb_sh;
272 if (!
sps->long_term_ref_pics_present)
275 if (
sps->num_long_term_ref_pics_sps > 0)
279 if (nb_sps >
sps->num_long_term_ref_pics_sps)
289 uint8_t lt_idx_sps = 0;
291 if (
sps->num_long_term_ref_pics_sps > 1)
294 rps->
poc[
i] =
sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
295 rps->
used[
i] = !!(
sps->used_by_curr_pic_lt & (1 << lt_idx_sps));
306 if (
i &&
i != nb_sps)
307 delta += prev_delta_msb;
309 poc = rps->
poc[
i] + cur_poc -
delta * max_poc_lsb - poc_lsb;
313 prev_delta_msb =
delta;
325 unsigned int num = 0, den = 0;
333 avctx->
profile =
sps->ptl.general_ptl.profile_idc;
334 avctx->
level =
sps->ptl.general_ptl.level_idc;
338 if (
sps->vui.common.video_signal_type_present_flag)
344 if (
sps->vui.common.colour_description_present_flag) {
346 avctx->
color_trc =
sps->vui.common.transfer_characteristics;
355 if (
sps->chroma_format_idc == 1) {
356 if (
sps->vui.common.chroma_loc_info_present_flag) {
357 if (
sps->vui.common.chroma_sample_loc_type_top_field <= 5)
363 if (
vps->vps_timing_info_present_flag) {
364 num =
vps->vps_num_units_in_tick;
365 den =
vps->vps_time_scale;
366 }
else if (
sps->vui.vui_timing_info_present_flag) {
367 num =
sps->vui.vui_num_units_in_tick;
368 den =
sps->vui.vui_time_scale;
371 if (num != 0 && den != 0)
380 if (
s->sei.common.a53_caption.buf_ref)
383 if (
s->sei.common.alternative_transfer.present &&
386 avctx->
color_trc =
s->sei.common.alternative_transfer.preferred_transfer_characteristics;
389 if (
s->sei.common.film_grain_characteristics.present ||
390 s->sei.common.aom_film_grain.enable)
398 #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + \
399 CONFIG_HEVC_D3D11VA_HWACCEL * 2 + \
400 CONFIG_HEVC_D3D12VA_HWACCEL + \
401 CONFIG_HEVC_NVDEC_HWACCEL + \
402 CONFIG_HEVC_VAAPI_HWACCEL + \
403 CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL + \
404 CONFIG_HEVC_VDPAU_HWACCEL + \
405 CONFIG_HEVC_VULKAN_HWACCEL)
408 switch (
sps->pix_fmt) {
411 #if CONFIG_HEVC_DXVA2_HWACCEL
414 #if CONFIG_HEVC_D3D11VA_HWACCEL
418 #if CONFIG_HEVC_D3D12VA_HWACCEL
421 #if CONFIG_HEVC_VAAPI_HWACCEL
424 #if CONFIG_HEVC_VDPAU_HWACCEL
427 #if CONFIG_HEVC_NVDEC_HWACCEL
430 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
433 #if CONFIG_HEVC_VULKAN_HWACCEL
438 #if CONFIG_HEVC_DXVA2_HWACCEL
441 #if CONFIG_HEVC_D3D11VA_HWACCEL
445 #if CONFIG_HEVC_D3D12VA_HWACCEL
448 #if CONFIG_HEVC_VAAPI_HWACCEL
451 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
454 #if CONFIG_HEVC_VULKAN_HWACCEL
457 #if CONFIG_HEVC_VDPAU_HWACCEL
460 #if CONFIG_HEVC_NVDEC_HWACCEL
465 #if CONFIG_HEVC_VAAPI_HWACCEL
468 #if CONFIG_HEVC_VDPAU_HWACCEL
471 #if CONFIG_HEVC_NVDEC_HWACCEL
474 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
477 #if CONFIG_HEVC_VULKAN_HWACCEL
483 #if CONFIG_HEVC_VAAPI_HWACCEL
486 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
489 #if CONFIG_HEVC_VULKAN_HWACCEL
494 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
500 #if CONFIG_HEVC_VAAPI_HWACCEL
503 #if CONFIG_HEVC_VDPAU_HWACCEL
506 #if CONFIG_HEVC_VULKAN_HWACCEL
509 #if CONFIG_HEVC_NVDEC_HWACCEL
514 #if CONFIG_HEVC_VAAPI_HWACCEL
517 #if CONFIG_HEVC_VULKAN_HWACCEL
523 *fmt++ =
sps->pix_fmt;
553 for (
i = 0;
i < 3;
i++) {
558 if (
sps->sao_enabled && !
s->avctx->hwaccel) {
559 int c_count = (
sps->chroma_format_idc != 0) ? 3 : 1;
562 for(c_idx = 0; c_idx < c_count; c_idx++) {
563 int w =
sps->width >>
sps->hshift[c_idx];
564 int h =
sps->height >>
sps->vshift[c_idx];
565 s->sao_pixel_buffer_h[c_idx] =
568 s->sao_pixel_buffer_v[c_idx] =
571 if (!
s->sao_pixel_buffer_h[c_idx] ||
572 !
s->sao_pixel_buffer_v[c_idx])
578 s->ps.vps =
sps->vps;
584 for (
i = 0;
i < 3;
i++) {
617 pps =
s->ps.pps_list[pps_id];
625 int slice_address_length;
627 if (
pps->dependent_slice_segments_enabled_flag)
635 "Invalid slice segment address: %u.\n",
648 for (
i = 0;
i <
pps->num_extra_slice_header_bits;
i++)
660 !
pps->pps_curr_pic_ref_enabled_flag) {
667 if (
pps->output_flag_present_flag)
670 if (
sps->separate_colour_plane)
680 "Ignoring POC change between slices: %d -> %d\n", poc, sh->
poc);
696 int numbits, rps_idx;
698 if (!
sps->nb_st_rps) {
704 rps_idx = numbits > 0 ?
get_bits(gb, numbits) : 0;
718 if (
sps->temporal_mvp_enabled)
732 if (
sps->sao_enabled) {
734 if (
sps->chroma_format_idc) {
771 if (
pps->lists_modification_present_flag && nb_refs > 1) {
789 if (
pps->cabac_init_present_flag)
804 "Invalid collocated_ref_idx: %d.\n",
821 "Invalid number of merging MVP candidates: %d.\n",
827 if (
sps->motion_vector_resolution_control_idc == 2)
837 if (
pps->pic_slice_level_chroma_qp_offsets_present_flag) {
850 if (
pps->pps_slice_act_qp_offsets_present_flag) {
856 if (
pps->chroma_qp_offset_list_enabled_flag)
861 if (
pps->deblocking_filter_control_present_flag) {
862 int deblocking_filter_override_flag = 0;
864 if (
pps->deblocking_filter_override_enabled_flag)
865 deblocking_filter_override_flag =
get_bits1(gb);
867 if (deblocking_filter_override_flag) {
872 if (beta_offset_div2 < -6 || beta_offset_div2 > 6 ||
873 tc_offset_div2 < -6 || tc_offset_div2 > 6) {
875 "Invalid deblock filter offsets: %d, %d\n",
876 beta_offset_div2, tc_offset_div2);
893 if (
pps->seq_loop_filter_across_slices_enabled_flag &&
901 }
else if (!
s->slice_initialized) {
907 if (
pps->tiles_enabled_flag ||
pps->entropy_coding_sync_enabled_flag) {
911 av_log(
s->avctx,
AV_LOG_ERROR,
"num_entry_point_offsets %d is invalid\n", num_entry_point_offsets);
919 if (offset_len < 1 || offset_len > 32) {
943 if (
pps->slice_header_extension_present_flag) {
949 for (
i = 0;
i < length;
i++)
965 "The slice_qp %d is outside the valid range "
989 #define CTB(tab, x, y) ((tab)[(y) * sps->ctb_width + (x)])
991 #define SET_SAO(elem, value) \
993 if (!sao_merge_up_flag && !sao_merge_left_flag) \
995 else if (sao_merge_left_flag) \
996 sao->elem = CTB(s->sao, rx-1, ry).elem; \
997 else if (sao_merge_up_flag) \
998 sao->elem = CTB(s->sao, rx, ry-1).elem; \
1008 int sao_merge_left_flag = 0;
1009 int sao_merge_up_flag = 0;
1013 if (
s->sh.slice_sample_adaptive_offset_flag[0] ||
1014 s->sh.slice_sample_adaptive_offset_flag[1]) {
1019 if (ry > 0 && !sao_merge_left_flag) {
1025 for (c_idx = 0; c_idx < (
sps->chroma_format_idc ? 3 : 1); c_idx++) {
1026 int log2_sao_offset_scale = c_idx == 0 ?
pps->log2_sao_offset_scale_luma :
1027 pps->log2_sao_offset_scale_chroma;
1029 if (!
s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
1044 for (
i = 0;
i < 4;
i++)
1048 for (
i = 0;
i < 4;
i++) {
1057 }
else if (c_idx != 2) {
1063 for (
i = 0;
i < 4;
i++) {
1071 sao->
offset_val[c_idx][
i + 1] *= 1 << log2_sao_offset_scale;
1083 if (log2_res_scale_abs_plus1 != 0) {
1086 (1 - 2 * res_scale_sign_flag);
1098 int xBase,
int yBase,
int cb_xBase,
int cb_yBase,
1099 int log2_cb_size,
int log2_trafo_size,
1100 int blk_idx,
int cbf_luma,
int *cbf_cb,
int *cbf_cr)
1103 const int log2_trafo_size_c = log2_trafo_size -
sps->hshift[1];
1107 int trafo_size = 1 << log2_trafo_size;
1110 s->hpc.intra_pred[log2_trafo_size - 2](lc,
pps, x0, y0, 0);
1113 if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
1114 (
sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1117 int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
1118 (
sps->chroma_format_idc == 2 &&
1119 (cbf_cb[1] || cbf_cr[1]));
1131 "The cu_qp_delta %d is outside the valid range "
1134 -(26 +
sps->qp_bd_offset / 2),
1135 (25 +
sps->qp_bd_offset / 2));
1142 if (
s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
1145 if (cu_chroma_qp_offset_flag) {
1146 int cu_chroma_qp_offset_idx = 0;
1147 if (
pps->chroma_qp_offset_list_len_minus1 > 0) {
1150 "cu_chroma_qp_offset_idx not yet tested.\n");
1183 if (
sps->chroma_format_idc && (log2_trafo_size > 2 ||
sps->chroma_format_idc == 3)) {
1184 int trafo_size_h = 1 << (log2_trafo_size_c +
sps->hshift[1]);
1185 int trafo_size_v = 1 << (log2_trafo_size_c +
sps->vshift[1]);
1186 lc->
tu.
cross_pf = (
pps->cross_component_prediction_enabled_flag && cbf_luma &&
1193 for (
i = 0;
i < (
sps->chroma_format_idc == 2 ? 2 : 1);
i++) {
1196 trafo_size_h, trafo_size_v,
sps->log2_ctb_size);
1197 s->hpc.intra_pred[log2_trafo_size_c - 2](lc,
pps, x0, y0 + (
i << log2_trafo_size_c), 1);
1201 log2_trafo_size_c, scan_idx_c, 1);
1204 ptrdiff_t
stride =
s->cur_frame->f->linesize[1];
1205 int hshift =
sps->hshift[1];
1206 int vshift =
sps->vshift[1];
1209 int size = 1 << log2_trafo_size_c;
1211 uint8_t *dst = &
s->cur_frame->f->data[1][(y0 >> vshift) *
stride +
1212 ((x0 >> hshift) <<
sps->pixel_shift)];
1216 s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs,
stride);
1223 for (
i = 0;
i < (
sps->chroma_format_idc == 2 ? 2 : 1);
i++) {
1226 trafo_size_h, trafo_size_v,
sps->log2_ctb_size);
1227 s->hpc.intra_pred[log2_trafo_size_c - 2](lc,
pps, x0, y0 + (
i << log2_trafo_size_c), 2);
1231 log2_trafo_size_c, scan_idx_c, 2);
1234 ptrdiff_t
stride =
s->cur_frame->f->linesize[2];
1235 int hshift =
sps->hshift[2];
1236 int vshift =
sps->vshift[2];
1239 int size = 1 << log2_trafo_size_c;
1241 uint8_t *dst = &
s->cur_frame->f->data[2][(y0 >> vshift) *
stride +
1242 ((x0 >> hshift) <<
sps->pixel_shift)];
1246 s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs,
stride);
1249 }
else if (
sps->chroma_format_idc && blk_idx == 3) {
1250 int trafo_size_h = 1 << (log2_trafo_size + 1);
1251 int trafo_size_v = 1 << (log2_trafo_size +
sps->vshift[1]);
1252 for (
i = 0;
i < (
sps->chroma_format_idc == 2 ? 2 : 1);
i++) {
1255 trafo_size_h, trafo_size_v,
sps->log2_ctb_size);
1256 s->hpc.intra_pred[log2_trafo_size - 2](lc,
pps, xBase, yBase + (
i << log2_trafo_size), 1);
1260 log2_trafo_size, scan_idx_c, 1);
1262 for (
i = 0;
i < (
sps->chroma_format_idc == 2 ? 2 : 1);
i++) {
1265 trafo_size_h, trafo_size_v,
sps->log2_ctb_size);
1266 s->hpc.intra_pred[log2_trafo_size - 2](lc,
pps, xBase, yBase + (
i << log2_trafo_size), 2);
1270 log2_trafo_size, scan_idx_c, 2);
1274 if (log2_trafo_size > 2 ||
sps->chroma_format_idc == 3) {
1275 int trafo_size_h = 1 << (log2_trafo_size_c +
sps->hshift[1]);
1276 int trafo_size_v = 1 << (log2_trafo_size_c +
sps->vshift[1]);
1278 sps->log2_ctb_size);
1279 s->hpc.intra_pred[log2_trafo_size_c - 2](lc,
pps, x0, y0, 1);
1280 s->hpc.intra_pred[log2_trafo_size_c - 2](lc,
pps, x0, y0, 2);
1281 if (
sps->chroma_format_idc == 2) {
1283 trafo_size_h, trafo_size_v,
sps->log2_ctb_size);
1284 s->hpc.intra_pred[log2_trafo_size_c - 2](lc,
pps, x0, y0 + (1 << log2_trafo_size_c), 1);
1285 s->hpc.intra_pred[log2_trafo_size_c - 2](lc,
pps, x0, y0 + (1 << log2_trafo_size_c), 2);
1287 }
else if (blk_idx == 3) {
1288 int trafo_size_h = 1 << (log2_trafo_size + 1);
1289 int trafo_size_v = 1 << (log2_trafo_size +
sps->vshift[1]);
1291 trafo_size_h, trafo_size_v,
sps->log2_ctb_size);
1292 s->hpc.intra_pred[log2_trafo_size - 2](lc,
pps, xBase, yBase, 1);
1293 s->hpc.intra_pred[log2_trafo_size - 2](lc,
pps, xBase, yBase, 2);
1294 if (
sps->chroma_format_idc == 2) {
1296 trafo_size_h, trafo_size_v,
sps->log2_ctb_size);
1297 s->hpc.intra_pred[log2_trafo_size - 2](lc,
pps, xBase, yBase + (1 << log2_trafo_size), 1);
1298 s->hpc.intra_pred[log2_trafo_size - 2](lc,
pps, xBase, yBase + (1 << log2_trafo_size), 2);
1307 int x0,
int y0,
int log2_cb_size)
1309 int cb_size = 1 << log2_cb_size;
1310 int log2_min_pu_size =
sps->log2_min_pu_size;
1312 int min_pu_width =
sps->min_pu_width;
1313 int x_end =
FFMIN(x0 + cb_size,
sps->width);
1314 int y_end =
FFMIN(y0 + cb_size,
sps->height);
1317 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1318 for (
i = (x0 >> log2_min_pu_size);
i < (x_end >> log2_min_pu_size);
i++)
1319 s->is_pcm[
i + j * min_pu_width] = 2;
1325 int xBase,
int yBase,
int cb_xBase,
int cb_yBase,
1326 int log2_cb_size,
int log2_trafo_size,
1327 int trafo_depth,
int blk_idx,
1328 const int *base_cbf_cb,
const int *base_cbf_cr)
1331 uint8_t split_transform_flag;
1336 cbf_cb[0] = base_cbf_cb[0];
1337 cbf_cb[1] = base_cbf_cb[1];
1338 cbf_cr[0] = base_cbf_cr[0];
1339 cbf_cr[1] = base_cbf_cr[1];
1342 if (trafo_depth == 1) {
1344 if (
sps->chroma_format_idc == 3) {
1358 if (log2_trafo_size <= sps->log2_max_trafo_size &&
1359 log2_trafo_size >
sps->log2_min_tb_size &&
1360 trafo_depth < lc->cu.max_trafo_depth &&
1364 int inter_split =
sps->max_transform_hierarchy_depth_inter == 0 &&
1369 split_transform_flag = log2_trafo_size >
sps->log2_max_trafo_size ||
1374 if (
sps->chroma_format_idc && (log2_trafo_size > 2 ||
sps->chroma_format_idc == 3)) {
1375 if (trafo_depth == 0 || cbf_cb[0]) {
1377 if (
sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1382 if (trafo_depth == 0 || cbf_cr[0]) {
1384 if (
sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1390 if (split_transform_flag) {
1391 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1392 const int x1 = x0 + trafo_size_split;
1393 const int y1 = y0 + trafo_size_split;
1395 #define SUBDIVIDE(x, y, idx) \
1397 ret = hls_transform_tree(lc, pps, sps, \
1398 x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1399 log2_trafo_size - 1, trafo_depth + 1, idx, \
1412 int min_tu_size = 1 <<
sps->log2_min_tb_size;
1413 int log2_min_tu_size =
sps->log2_min_tb_size;
1414 int min_tu_width =
sps->min_tb_width;
1418 cbf_cb[0] || cbf_cr[0] ||
1419 (
sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1424 x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1425 log2_cb_size, log2_trafo_size,
1426 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1432 for (
i = 0;
i < (1 << log2_trafo_size);
i += min_tu_size)
1433 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1434 int x_tu = (x0 + j) >> log2_min_tu_size;
1435 int y_tu = (y0 +
i) >> log2_min_tu_size;
1436 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1439 if (!
s->sh.disable_deblocking_filter_flag) {
1441 if (
pps->transquant_bypass_enable_flag &&
1450 int x0,
int y0,
int log2_cb_size)
1455 int cb_size = 1 << log2_cb_size;
1456 ptrdiff_t stride0 =
s->cur_frame->f->linesize[0];
1457 ptrdiff_t stride1 =
s->cur_frame->f->linesize[1];
1458 ptrdiff_t stride2 =
s->cur_frame->f->linesize[2];
1459 uint8_t *dst0 = &
s->cur_frame->f->data[0][y0 * stride0 + (x0 <<
sps->pixel_shift)];
1460 uint8_t *dst1 = &
s->cur_frame->f->data[1][(y0 >>
sps->vshift[1]) * stride1 + ((x0 >>
sps->hshift[1]) <<
sps->pixel_shift)];
1461 uint8_t *dst2 = &
s->cur_frame->f->data[2][(y0 >>
sps->vshift[2]) * stride2 + ((x0 >>
sps->hshift[2]) <<
sps->pixel_shift)];
1463 int length = cb_size * cb_size *
sps->pcm.bit_depth +
1464 (((cb_size >>
sps->hshift[1]) * (cb_size >>
sps->vshift[1])) +
1465 ((cb_size >>
sps->hshift[2]) * (cb_size >>
sps->vshift[2]))) *
1466 sps->pcm.bit_depth_chroma;
1467 const uint8_t *pcm =
skip_bytes(&lc->
cc, (length + 7) >> 3);
1470 if (!
s->sh.disable_deblocking_filter_flag)
1477 s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size, &gb,
sps->pcm.bit_depth);
1478 if (
sps->chroma_format_idc) {
1479 s->hevcdsp.put_pcm(dst1, stride1,
1480 cb_size >>
sps->hshift[1],
1481 cb_size >>
sps->vshift[1],
1482 &gb,
sps->pcm.bit_depth_chroma);
1483 s->hevcdsp.put_pcm(dst2, stride2,
1484 cb_size >>
sps->hshift[2],
1485 cb_size >>
sps->vshift[2],
1486 &gb,
sps->pcm.bit_depth_chroma);
1510 uint8_t *dst, ptrdiff_t dststride,
1512 int block_w,
int block_h,
int luma_weight,
int luma_offset)
1515 const uint8_t *
src =
ref->data[0];
1516 ptrdiff_t srcstride =
ref->linesize[0];
1517 int pic_width =
sps->width;
1518 int pic_height =
sps->height;
1521 int weight_flag = (
s->sh.slice_type ==
HEVC_SLICE_P &&
pps->weighted_pred_flag) ||
1525 x_off +=
mv->x >> 2;
1526 y_off +=
mv->y >> 2;
1527 src += y_off * srcstride + (x_off * (1 <<
sps->pixel_shift));
1532 ref ==
s->cur_frame->f) {
1538 edge_emu_stride, srcstride,
1542 pic_width, pic_height);
1544 srcstride = edge_emu_stride;
1548 s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride,
src, srcstride,
1549 block_h, mx, my, block_w);
1551 s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride,
src, srcstride,
1552 block_h,
s->sh.luma_log2_weight_denom,
1553 luma_weight, luma_offset, mx, my, block_w);
1574 uint8_t *dst, ptrdiff_t dststride,
1575 const AVFrame *ref0,
const Mv *mv0,
int x_off,
int y_off,
1576 int block_w,
int block_h,
const AVFrame *ref1,
1577 const Mv *mv1,
struct MvField *current_mv)
1580 ptrdiff_t src0stride = ref0->
linesize[0];
1581 ptrdiff_t src1stride = ref1->
linesize[0];
1582 int pic_width =
sps->width;
1583 int pic_height =
sps->height;
1584 int mx0 = mv0->
x & 3;
1585 int my0 = mv0->
y & 3;
1586 int mx1 = mv1->
x & 3;
1587 int my1 = mv1->
y & 3;
1588 int weight_flag = (
s->sh.slice_type ==
HEVC_SLICE_P &&
pps->weighted_pred_flag) ||
1590 int x_off0 = x_off + (mv0->
x >> 2);
1591 int y_off0 = y_off + (mv0->
y >> 2);
1592 int x_off1 = x_off + (mv1->
x >> 2);
1593 int y_off1 = y_off + (mv1->
y >> 2);
1596 const uint8_t *
src0 = ref0->
data[0] + y_off0 * src0stride + (
int)((
unsigned)x_off0 <<
sps->pixel_shift);
1597 const uint8_t *
src1 = ref1->
data[0] + y_off1 * src1stride + (
int)((
unsigned)x_off1 <<
sps->pixel_shift);
1607 edge_emu_stride, src0stride,
1611 pic_width, pic_height);
1613 src0stride = edge_emu_stride;
1624 edge_emu_stride, src1stride,
1628 pic_width, pic_height);
1630 src1stride = edge_emu_stride;
1633 s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](lc->
tmp,
src0, src0stride,
1634 block_h, mx0, my0, block_w);
1636 s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride,
src1, src1stride, lc->
tmp,
1637 block_h, mx1, my1, block_w);
1639 s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride,
src1, src1stride, lc->
tmp,
1640 block_h,
s->sh.luma_log2_weight_denom,
1641 s->sh.luma_weight_l0[current_mv->
ref_idx[0]],
1642 s->sh.luma_weight_l1[current_mv->
ref_idx[1]],
1643 s->sh.luma_offset_l0[current_mv->
ref_idx[0]],
1644 s->sh.luma_offset_l1[current_mv->
ref_idx[1]],
1669 ptrdiff_t dststride,
const uint8_t *
src0, ptrdiff_t srcstride,
int reflist,
1670 int x_off,
int y_off,
int block_w,
int block_h,
1671 const struct MvField *current_mv,
int chroma_weight,
int chroma_offset)
1674 int pic_width =
sps->width >>
sps->hshift[1];
1675 int pic_height =
sps->height >>
sps->vshift[1];
1676 const Mv *
mv = ¤t_mv->
mv[reflist];
1677 int weight_flag = (
s->sh.slice_type ==
HEVC_SLICE_P &&
pps->weighted_pred_flag) ||
1680 int hshift =
sps->hshift[1];
1681 int vshift =
sps->vshift[1];
1684 intptr_t _mx = mx << (1 - hshift);
1685 intptr_t _my = my << (1 - vshift);
1686 int emu =
src0 ==
s->cur_frame->f->data[1] ||
src0 ==
s->cur_frame->f->data[2];
1688 x_off +=
mv->x >> (2 + hshift);
1689 y_off +=
mv->y >> (2 + vshift);
1690 src0 += y_off * srcstride + (x_off * (1 <<
sps->pixel_shift));
1699 (edge_emu_stride + (1 <<
sps->pixel_shift));
1701 edge_emu_stride, srcstride,
1705 pic_width, pic_height);
1708 srcstride = edge_emu_stride;
1711 s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride,
src0, srcstride,
1712 block_h, _mx, _my, block_w);
1714 s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride,
src0, srcstride,
1715 block_h,
s->sh.chroma_log2_weight_denom,
1716 chroma_weight, chroma_offset, _mx, _my, block_w);
1738 uint8_t *dst0, ptrdiff_t dststride,
1740 int x_off,
int y_off,
int block_w,
int block_h,
const MvField *current_mv,
int cidx)
1743 const uint8_t *
src1 = ref0->
data[cidx+1];
1744 const uint8_t *
src2 = ref1->
data[cidx+1];
1745 ptrdiff_t src1stride = ref0->
linesize[cidx+1];
1746 ptrdiff_t src2stride = ref1->
linesize[cidx+1];
1747 int weight_flag = (
s->sh.slice_type ==
HEVC_SLICE_P &&
pps->weighted_pred_flag) ||
1749 int pic_width =
sps->width >>
sps->hshift[1];
1750 int pic_height =
sps->height >>
sps->vshift[1];
1751 const Mv *
const mv0 = ¤t_mv->
mv[0];
1752 const Mv *
const mv1 = ¤t_mv->
mv[1];
1753 int hshift =
sps->hshift[1];
1754 int vshift =
sps->vshift[1];
1760 intptr_t _mx0 = mx0 << (1 - hshift);
1761 intptr_t _my0 = my0 << (1 - vshift);
1762 intptr_t _mx1 = mx1 << (1 - hshift);
1763 intptr_t _my1 = my1 << (1 - vshift);
1765 int x_off0 = x_off + (mv0->
x >> (2 + hshift));
1766 int y_off0 = y_off + (mv0->
y >> (2 + vshift));
1767 int x_off1 = x_off + (mv1->
x >> (2 + hshift));
1768 int y_off1 = y_off + (mv1->
y >> (2 + vshift));
1770 src1 += y_off0 * src1stride + (
int)((
unsigned)x_off0 <<
sps->pixel_shift);
1771 src2 += y_off1 * src2stride + (
int)((
unsigned)x_off1 <<
sps->pixel_shift);
1779 (edge_emu_stride + (1 <<
sps->pixel_shift));
1782 edge_emu_stride, src1stride,
1786 pic_width, pic_height);
1789 src1stride = edge_emu_stride;
1798 (edge_emu_stride + (1 <<
sps->pixel_shift));
1801 edge_emu_stride, src2stride,
1805 pic_width, pic_height);
1808 src2stride = edge_emu_stride;
1811 s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](lc->
tmp,
src1, src1stride,
1812 block_h, _mx0, _my0, block_w);
1814 s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0,
s->cur_frame->f->linesize[cidx+1],
1816 block_h, _mx1, _my1, block_w);
1818 s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0,
s->cur_frame->f->linesize[cidx+1],
1821 s->sh.chroma_log2_weight_denom,
1822 s->sh.chroma_weight_l0[current_mv->
ref_idx[0]][cidx],
1823 s->sh.chroma_weight_l1[current_mv->
ref_idx[1]][cidx],
1824 s->sh.chroma_offset_l0[current_mv->
ref_idx[0]][cidx],
1825 s->sh.chroma_offset_l1[current_mv->
ref_idx[1]][cidx],
1826 _mx1, _my1, block_w);
1841 int x0,
int y0,
int nPbW,
1842 int nPbH,
int log2_cb_size,
int part_idx,
1854 if (inter_pred_idc !=
PRED_L1) {
1855 if (
s->sh.nb_refs[
L0])
1862 part_idx, merge_idx,
mv, mvp_flag, 0);
1867 if (inter_pred_idc !=
PRED_L0) {
1868 if (
s->sh.nb_refs[
L1])
1871 if (
s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc ==
PRED_BI) {
1880 part_idx, merge_idx,
mv, mvp_flag, 1);
1888 int x0,
int y0,
int nPbW,
int nPbH,
1889 int log2_cb_size,
int partIdx,
int idx)
1891 #define POS(c_idx, x, y) \
1892 &s->cur_frame->f->data[c_idx][((y) >> sps->vshift[c_idx]) * linesize[c_idx] + \
1893 (((x) >> sps->hshift[c_idx]) << sps->pixel_shift)]
1896 struct MvField current_mv = {{{ 0 }}};
1898 int min_pu_width =
sps->min_pu_width;
1900 MvField *tab_mvf =
s->cur_frame->tab_mvf;
1901 const RefPicList *refPicList =
s->cur_frame->refPicList;
1903 const int *linesize =
s->cur_frame->f->linesize;
1904 uint8_t *dst0 =
POS(0, x0, y0);
1905 uint8_t *dst1 =
POS(1, x0, y0);
1906 uint8_t *dst2 =
POS(2, x0, y0);
1907 int log2_min_cb_size =
sps->log2_min_cb_size;
1908 int min_cb_width =
sps->min_cb_width;
1909 int x_cb = x0 >> log2_min_cb_size;
1910 int y_cb = y0 >> log2_min_cb_size;
1914 int skip_flag =
SAMPLE_CTB(
s->skip_flag, x_cb, y_cb);
1920 if (
s->sh.max_num_merge_cand > 1)
1926 partIdx, merge_idx, ¤t_mv);
1929 partIdx, merge_idx, ¤t_mv);
1932 x_pu = x0 >>
sps->log2_min_pu_size;
1933 y_pu = y0 >>
sps->log2_min_pu_size;
1935 for (j = 0; j < nPbH >>
sps->log2_min_pu_size; j++)
1936 for (
i = 0; i < nPbW >>
sps->log2_min_pu_size;
i++)
1937 tab_mvf[(y_pu + j) * min_pu_width + x_pu +
i] = current_mv;
1940 ref0 = refPicList[0].
ref[current_mv.
ref_idx[0]];
1941 if (!ref0 || !ref0->
f)
1946 ref1 = refPicList[1].
ref[current_mv.
ref_idx[1]];
1947 if (!ref1 || !ref1->f)
1953 int x0_c = x0 >>
sps->hshift[1];
1954 int y0_c = y0 >>
sps->vshift[1];
1955 int nPbW_c = nPbW >>
sps->hshift[1];
1956 int nPbH_c = nPbH >>
sps->vshift[1];
1959 ¤t_mv.
mv[0], x0, y0, nPbW, nPbH,
1960 s->sh.luma_weight_l0[current_mv.
ref_idx[0]],
1961 s->sh.luma_offset_l0[current_mv.
ref_idx[0]]);
1963 if (
sps->chroma_format_idc) {
1965 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1966 s->sh.chroma_weight_l0[current_mv.
ref_idx[0]][0],
s->sh.chroma_offset_l0[current_mv.
ref_idx[0]][0]);
1968 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1969 s->sh.chroma_weight_l0[current_mv.
ref_idx[0]][1],
s->sh.chroma_offset_l0[current_mv.
ref_idx[0]][1]);
1972 int x0_c = x0 >>
sps->hshift[1];
1973 int y0_c = y0 >>
sps->vshift[1];
1974 int nPbW_c = nPbW >>
sps->hshift[1];
1975 int nPbH_c = nPbH >>
sps->vshift[1];
1978 ¤t_mv.
mv[1], x0, y0, nPbW, nPbH,
1979 s->sh.luma_weight_l1[current_mv.
ref_idx[1]],
1980 s->sh.luma_offset_l1[current_mv.
ref_idx[1]]);
1982 if (
sps->chroma_format_idc) {
1984 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1985 s->sh.chroma_weight_l1[current_mv.
ref_idx[1]][0],
s->sh.chroma_offset_l1[current_mv.
ref_idx[1]][0]);
1988 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1989 s->sh.chroma_weight_l1[current_mv.
ref_idx[1]][1],
s->sh.chroma_offset_l1[current_mv.
ref_idx[1]][1]);
1992 int x0_c = x0 >>
sps->hshift[1];
1993 int y0_c = y0 >>
sps->vshift[1];
1994 int nPbW_c = nPbW >>
sps->hshift[1];
1995 int nPbH_c = nPbH >>
sps->vshift[1];
1998 ¤t_mv.
mv[0], x0, y0, nPbW, nPbH,
1999 ref1->f, ¤t_mv.
mv[1], ¤t_mv);
2001 if (
sps->chroma_format_idc) {
2003 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 0);
2006 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1);
2015 int x0,
int y0,
int pu_size,
2016 int prev_intra_luma_pred_flag)
2019 int x_pu = x0 >>
sps->log2_min_pu_size;
2020 int y_pu = y0 >>
sps->log2_min_pu_size;
2021 int min_pu_width =
sps->min_pu_width;
2022 int size_in_pus = pu_size >>
sps->log2_min_pu_size;
2027 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] :
INTRA_DC;
2029 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] :
INTRA_DC;
2031 int y_ctb = (y0 >> (
sps->log2_ctb_size)) << (
sps->log2_ctb_size);
2033 MvField *tab_mvf =
s->cur_frame->tab_mvf;
2034 int intra_pred_mode;
2039 if ((y0 - 1) < y_ctb)
2042 if (cand_left == cand_up) {
2043 if (cand_left < 2) {
2048 candidate[0] = cand_left;
2049 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
2050 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
2053 candidate[0] = cand_left;
2054 candidate[1] = cand_up;
2064 if (prev_intra_luma_pred_flag) {
2065 intra_pred_mode = candidate[lc->
pu.
mpm_idx];
2067 if (candidate[0] > candidate[1])
2068 FFSWAP(uint8_t, candidate[0], candidate[1]);
2069 if (candidate[0] > candidate[2])
2070 FFSWAP(uint8_t, candidate[0], candidate[2]);
2071 if (candidate[1] > candidate[2])
2072 FFSWAP(uint8_t, candidate[1], candidate[2]);
2075 for (
i = 0;
i < 3;
i++)
2076 if (intra_pred_mode >= candidate[
i])
2083 for (
i = 0;
i < size_in_pus;
i++) {
2084 memset(&
s->tab_ipm[(y_pu +
i) * min_pu_width + x_pu],
2085 intra_pred_mode, size_in_pus);
2087 for (j = 0; j < size_in_pus; j++) {
2092 return intra_pred_mode;
2097 int log2_cb_size,
int ct_depth)
2099 int length = (1 << log2_cb_size) >>
sps->log2_min_cb_size;
2100 int x_cb = x0 >>
sps->log2_min_cb_size;
2101 int y_cb = y0 >>
sps->log2_min_cb_size;
2104 for (y = 0; y < length; y++)
2105 memset(&tab_ct_depth[(y_cb + y) *
sps->min_cb_width + x_cb],
2110 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
2111 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
2117 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
2118 uint8_t prev_intra_luma_pred_flag[4];
2120 int pb_size = (1 << log2_cb_size) >>
split;
2121 int side =
split + 1;
2125 for (
i = 0;
i < side;
i++)
2126 for (j = 0; j < side; j++)
2129 for (
i = 0;
i < side;
i++) {
2130 for (j = 0; j < side; j++) {
2131 if (prev_intra_luma_pred_flag[2 *
i + j])
2138 prev_intra_luma_pred_flag[2 *
i + j]);
2142 if (
sps->chroma_format_idc == 3) {
2143 for (
i = 0;
i < side;
i++) {
2144 for (j = 0; j < side; j++) {
2146 if (chroma_mode != 4) {
2156 }
else if (
sps->chroma_format_idc == 2) {
2159 if (chroma_mode != 4) {
2163 mode_idx = intra_chroma_table[chroma_mode];
2168 }
else if (
sps->chroma_format_idc != 0) {
2170 if (chroma_mode != 4) {
2187 int pb_size = 1 << log2_cb_size;
2188 int size_in_pus = pb_size >>
sps->log2_min_pu_size;
2189 int min_pu_width =
sps->min_pu_width;
2190 MvField *tab_mvf =
s->cur_frame->tab_mvf;
2191 int x_pu = x0 >>
sps->log2_min_pu_size;
2192 int y_pu = y0 >>
sps->log2_min_pu_size;
2195 if (size_in_pus == 0)
2197 for (j = 0; j < size_in_pus; j++)
2198 memset(&
s->tab_ipm[(y_pu + j) * min_pu_width + x_pu],
INTRA_DC, size_in_pus);
2200 for (j = 0; j < size_in_pus; j++)
2201 for (k = 0; k < size_in_pus; k++)
2207 int x0,
int y0,
int log2_cb_size)
2209 int cb_size = 1 << log2_cb_size;
2210 int log2_min_cb_size =
sps->log2_min_cb_size;
2211 int length = cb_size >> log2_min_cb_size;
2212 int min_cb_width =
sps->min_cb_width;
2213 int x_cb = x0 >> log2_min_cb_size;
2214 int y_cb = y0 >> log2_min_cb_size;
2215 int idx = log2_cb_size - 2;
2216 int qp_block_mask = (1 << (
sps->log2_ctb_size -
pps->diff_cu_qp_delta_depth)) - 1;
2226 for (x = 0; x < 4; x++)
2228 if (
pps->transquant_bypass_enable_flag) {
2241 x = y_cb * min_cb_width + x_cb;
2242 for (y = 0; y < length; y++) {
2243 memset(&
s->skip_flag[x], skip_flag, length);
2248 x = y_cb * min_cb_width + x_cb;
2249 for (y = 0; y < length; y++) {
2250 memset(&
s->skip_flag[x], 0, length);
2257 x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2260 if (!
s->sh.disable_deblocking_filter_flag)
2268 log2_cb_size ==
sps->log2_min_cb_size) {
2276 log2_cb_size >=
sps->pcm.log2_min_pcm_cb_size &&
2277 log2_cb_size <= sps->pcm.log2_max_pcm_cb_size) {
2283 if (
sps->pcm_loop_filter_disabled)
2296 x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2300 x0, y0, cb_size, cb_size / 2, log2_cb_size, 0, idx);
2302 x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2306 x0, y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2308 x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2312 x0, y0, cb_size, cb_size / 4, log2_cb_size, 0, idx);
2314 x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2318 x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2320 x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2324 x0, y0, cb_size / 4, cb_size, log2_cb_size, 0, idx - 2);
2326 x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2330 x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2332 x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2336 x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2338 x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2340 x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2342 x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2348 int rqt_root_cbf = 1;
2355 const static int cbf[2] = { 0 };
2358 sps->max_transform_hierarchy_depth_inter;
2361 log2_cb_size, 0, 0, cbf, cbf);
2365 if (!
s->sh.disable_deblocking_filter_flag)
2374 x = y_cb * min_cb_width + x_cb;
2375 for (y = 0; y < length; y++) {
2376 memset(&
s->qp_y_tab[x], lc->
qp_y, length);
2380 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2381 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2393 int log2_cb_size,
int cb_depth)
2396 const int cb_size = 1 << log2_cb_size;
2401 if (x0 + cb_size <= sps->
width &&
2402 y0 + cb_size <= sps->
height &&
2403 log2_cb_size >
sps->log2_min_cb_size) {
2406 split_cu = (log2_cb_size >
sps->log2_min_cb_size);
2408 if (
pps->cu_qp_delta_enabled_flag &&
2409 log2_cb_size >=
sps->log2_ctb_size -
pps->diff_cu_qp_delta_depth) {
2414 if (
s->sh.cu_chroma_qp_offset_enabled_flag &&
2415 log2_cb_size >=
sps->log2_ctb_size -
pps->diff_cu_chroma_qp_offset_depth) {
2420 int qp_block_mask = (1 << (
sps->log2_ctb_size -
pps->diff_cu_qp_delta_depth)) - 1;
2421 const int cb_size_split = cb_size >> 1;
2422 const int x1 = x0 + cb_size_split;
2423 const int y1 = y0 + cb_size_split;
2431 if (more_data && x1 < sps->
width) {
2436 if (more_data && y1 < sps->
height) {
2441 if (more_data && x1 < sps->
width &&
2448 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2449 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2453 return ((x1 + cb_size_split) <
sps->width ||
2454 (y1 + cb_size_split) <
sps->height);
2461 if ((!((x0 + cb_size) %
2462 (1 << (
sps->log2_ctb_size))) ||
2463 (x0 + cb_size >=
sps->width)) &&
2465 (1 << (
sps->log2_ctb_size))) ||
2466 (y0 + cb_size >=
sps->height))) {
2468 return !end_of_slice_flag;
2479 int x_ctb,
int y_ctb,
int ctb_addr_ts)
2482 int ctb_size = 1 <<
sps->log2_ctb_size;
2483 int ctb_addr_rs =
pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2484 int ctb_addr_in_slice = ctb_addr_rs -
s->sh.slice_addr;
2486 s->tab_slice_address[ctb_addr_rs] =
s->sh.slice_addr;
2488 if (
pps->entropy_coding_sync_enabled_flag) {
2489 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2492 }
else if (
pps->tiles_enabled_flag) {
2493 if (ctb_addr_ts &&
pps->tile_id[ctb_addr_ts] !=
pps->tile_id[ctb_addr_ts - 1]) {
2494 int idxX =
pps->col_idxX[x_ctb >>
sps->log2_ctb_size];
2505 if (
pps->tiles_enabled_flag) {
2506 if (x_ctb > 0 &&
pps->tile_id[ctb_addr_ts] !=
pps->tile_id[
pps->ctb_addr_rs_to_ts[ctb_addr_rs - 1]])
2508 if (x_ctb > 0 &&
s->tab_slice_address[ctb_addr_rs] !=
s->tab_slice_address[ctb_addr_rs - 1])
2510 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]])
2512 if (y_ctb > 0 &&
s->tab_slice_address[ctb_addr_rs] !=
s->tab_slice_address[ctb_addr_rs -
sps->ctb_width])
2515 if (ctb_addr_in_slice <= 0)
2517 if (ctb_addr_in_slice < sps->ctb_width)
2523 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]]));
2524 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]]));
2532 const uint8_t *slice_data = gb->
buffer +
s->sh.data_offset;
2534 int ctb_size = 1 <<
sps->log2_ctb_size;
2538 int ctb_addr_ts =
pps->ctb_addr_rs_to_ts[
s->sh.slice_ctb_addr_rs];
2541 while (more_data && ctb_addr_ts < sps->ctb_size) {
2542 int ctb_addr_rs =
pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2544 x_ctb = (ctb_addr_rs % ((
sps->width + ctb_size - 1) >>
sps->log2_ctb_size)) <<
sps->log2_ctb_size;
2545 y_ctb = (ctb_addr_rs / ((
sps->width + ctb_size - 1) >>
sps->log2_ctb_size)) <<
sps->log2_ctb_size;
2550 s->tab_slice_address[ctb_addr_rs] = -1;
2555 x_ctb >>
sps->log2_ctb_size, y_ctb >>
sps->log2_ctb_size);
2557 s->deblock[ctb_addr_rs].beta_offset =
s->sh.beta_offset;
2558 s->deblock[ctb_addr_rs].tc_offset =
s->sh.tc_offset;
2559 s->filter_slice_edges[ctb_addr_rs] =
s->sh.slice_loop_filter_across_slices_enabled_flag;
2562 if (more_data < 0) {
2563 s->tab_slice_address[ctb_addr_rs] = -1;
2573 if (x_ctb + ctb_size >=
sps->width &&
2574 y_ctb + ctb_size >=
sps->height)
2581 int job,
int self_id)
2587 int ctb_size = 1 <<
sps->log2_ctb_size;
2590 int ctb_addr_rs =
s->sh.slice_ctb_addr_rs + ctb_row * ((
sps->width + ctb_size - 1) >>
sps->log2_ctb_size);
2591 int ctb_addr_ts =
pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2594 const uint8_t *
data =
s->data +
s->sh.offset[ctb_row];
2595 const size_t data_size =
s->sh.size[ctb_row];
2602 while(more_data && ctb_addr_ts < sps->ctb_size) {
2603 int x_ctb = (ctb_addr_rs %
sps->ctb_width) <<
sps->log2_ctb_size;
2604 int y_ctb = (ctb_addr_rs /
sps->ctb_width) <<
sps->log2_ctb_size;
2622 x_ctb >>
sps->log2_ctb_size, y_ctb >>
sps->log2_ctb_size);
2625 if (more_data < 0) {
2636 if (!more_data && (x_ctb+ctb_size) <
sps->width && ctb_row !=
s->sh.num_entry_point_offsets) {
2643 if ((x_ctb+ctb_size) >=
sps->width && (y_ctb+ctb_size) >=
sps->height ) {
2648 ctb_addr_rs =
pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2651 if(x_ctb >=
sps->width) {
2659 s->tab_slice_address[ctb_addr_rs] = -1;
2671 int length = nal->
size;
2674 int64_t startheader, cmpt = 0;
2677 if (
s->sh.slice_ctb_addr_rs +
s->sh.num_entry_point_offsets *
sps->ctb_width >=
sps->ctb_width *
sps->ctb_height) {
2679 s->sh.slice_ctb_addr_rs,
s->sh.num_entry_point_offsets,
2680 sps->ctb_width,
sps->ctb_height
2685 if (
s->avctx->thread_count >
s->nb_local_ctx) {
2691 memcpy(
tmp,
s->local_ctx,
sizeof(*
s->local_ctx) *
s->nb_local_ctx);
2695 for (
unsigned i =
s->nb_local_ctx; i < s->avctx->thread_count;
i++) {
2696 tmp = &
s->local_ctx[
i];
2698 memset(
tmp, 0,
sizeof(*
tmp));
2700 tmp->logctx =
s->avctx;
2702 tmp->common_cabac_state = &
s->cabac;
2705 s->nb_local_ctx =
s->avctx->thread_count;
2710 for (j = 0, cmpt = 0, startheader =
offset +
s->sh.entry_point_offset[0]; j < nal->skipped_bytes; j++) {
2717 for (
i = 1;
i <
s->sh.num_entry_point_offsets;
i++) {
2718 offset += (
s->sh.entry_point_offset[
i - 1] - cmpt);
2719 for (j = 0, cmpt = 0, startheader =
offset
2720 +
s->sh.entry_point_offset[
i]; j < nal->skipped_bytes; j++) {
2726 s->sh.size[
i] =
s->sh.entry_point_offset[
i] - cmpt;
2731 offset +=
s->sh.entry_point_offset[
s->sh.num_entry_point_offsets - 1] - cmpt;
2736 s->sh.size [
s->sh.num_entry_point_offsets] = length -
offset;
2737 s->sh.offset[
s->sh.num_entry_point_offsets] =
offset;
2739 s->sh.offset[0] =
s->sh.data_offset;
2740 s->sh.size[0] =
s->sh.offset[1] -
s->sh.offset[0];
2744 for (
i = 1;
i <
s->nb_local_ctx;
i++) {
2745 s->local_ctx[
i].first_qp_group = 1;
2746 s->local_ctx[
i].qp_y =
s->local_ctx[0].qp_y;
2758 if (
pps->entropy_coding_sync_enabled_flag)
2761 for (
i = 0;
i <=
s->sh.num_entry_point_offsets;
i++)
2773 if (
s->sh.dependent_slice_segment_flag) {
2774 int ctb_addr_ts =
pps->ctb_addr_rs_to_ts[
s->sh.slice_ctb_addr_rs];
2775 int prev_rs =
pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2776 if (
s->tab_slice_address[prev_rs] !=
s->sh.slice_addr) {
2782 if (!
s->sh.dependent_slice_segment_flag &&
s->sh.slice_type !=
HEVC_SLICE_I) {
2786 "Error constructing the reference lists for the current slice.\n");
2791 s->slice_initialized = 1;
2793 if (
s->avctx->hwaccel)
2798 "SCC profile is not yet implemented in hevc native decoder.\n");
2802 s->local_ctx[0].first_qp_group = !
s->sh.dependent_slice_segment_flag;
2804 if (!
pps->cu_qp_delta_enabled_flag)
2805 s->local_ctx[0].qp_y =
s->sh.slice_qp;
2807 s->local_ctx[0].tu.cu_qp_offset_cb = 0;
2808 s->local_ctx[0].tu.cu_qp_offset_cr = 0;
2810 s->slice_idx += !
s->sh.dependent_slice_segment_flag;
2813 s->sh.num_entry_point_offsets > 0 &&
2814 pps->num_tile_rows == 1 &&
pps->num_tile_columns == 1)
2828 if (
IS_IRAP(
s) &&
s->no_rasl_output_flag) {
2829 if (
s->sei.common.mastering_display.present > 0)
2830 s->sei.common.mastering_display.present--;
2832 if (
s->sei.common.content_light.present > 0)
2833 s->sei.common.content_light.present--;
2837 &
s->ps.sps->vui.common,
2838 s->ps.sps->bit_depth,
s->ps.sps->bit_depth_chroma,
2839 s->cur_frame->poc );
2843 if (
s->sei.timecode.present) {
2848 sizeof(uint32_t) * 4, &tcside);
2853 tc_sd = (uint32_t*)tcside->
data;
2854 tc_sd[0] =
s->sei.timecode.num_clock_ts;
2856 for (
int i = 0;
i < tc_sd[0];
i++) {
2857 int drop =
s->sei.timecode.cnt_dropped_flag[
i];
2858 int hh =
s->sei.timecode.hours_value[
i];
2859 int mm =
s->sei.timecode.minutes_value[
i];
2860 int ss =
s->sei.timecode.seconds_value[
i];
2861 int ff =
s->sei.timecode.n_frames[
i];
2869 s->sei.timecode.num_clock_ts = 0;
2872 if (
s->sei.common.dynamic_hdr_plus.info) {
2893 if (
s->sei.common.dynamic_hdr_vivid.info) {
2909 const HEVCPPS *
const pps =
s->ps.pps_list[
s->sh.pps_id];
2911 int pic_size_in_ctb = ((
sps->width >>
sps->log2_min_cb_size) + 1) *
2912 ((
sps->height >>
sps->log2_min_cb_size) + 1);
2916 if (
s->ps.sps !=
sps) {
2933 memset(
s->horizontal_bs, 0,
s->bs_width *
s->bs_height);
2934 memset(
s->vertical_bs, 0,
s->bs_width *
s->bs_height);
2935 memset(
s->cbf_luma, 0,
sps->min_tb_width *
sps->min_tb_height);
2936 memset(
s->is_pcm, 0, (
sps->min_pu_width + 1) * (
sps->min_pu_height + 1));
2937 memset(
s->tab_slice_address, -1, pic_size_in_ctb *
sizeof(*
s->tab_slice_address));
2946 s->first_nal_type =
s->nal_unit_type;
2954 if (
s->temporal_id == 0 &&
2962 s->poc_tid0 =
s->poc;
2964 if (
pps->tiles_enabled_flag)
2965 s->local_ctx[0].end_of_tiles_x =
pps->column_width[0] <<
sps->log2_ctb_size;
2982 s->cur_frame->needs_fg = (
s->sei.common.film_grain_characteristics.present ||
2983 s->sei.common.aom_film_grain.enable) &&
2995 if (
s->cur_frame->needs_fg &&
2996 (
s->sei.common.film_grain_characteristics.present &&
2998 s->cur_frame->f->format) ||
3001 "Unsupported film grain parameters. Ignoring film grain.\n");
3002 s->cur_frame->needs_fg = 0;
3005 if (
s->cur_frame->needs_fg) {
3006 s->cur_frame->frame_grain->format =
s->cur_frame->f->format;
3007 s->cur_frame->frame_grain->width =
s->cur_frame->f->width;
3008 s->cur_frame->frame_grain->height =
s->cur_frame->f->height;
3013 s->cur_frame->f->pict_type = 3 -
s->sh.slice_type;
3023 if (
s->avctx->hwaccel) {
3035 s->cur_frame =
s->collocated_ref =
NULL;
3036 s->slice_initialized = 0;
3043 char msg_buf[4 * (50 + 2 * 2 * 16 )];
3051 pixel_shift =
desc->comp[0].depth > 8;
3056 if (pixel_shift && !
s->checksum_buf) {
3059 frame->linesize[2]));
3060 if (!
s->checksum_buf)
3067 int width =
s->avctx->coded_width;
3068 int height =
s->avctx->coded_height;
3074 for (j = 0; j <
h; j++) {
3078 s->bdsp.bswap16_buf((uint16_t *)
s->checksum_buf,
3079 (
const uint16_t *)
src,
w);
3080 src =
s->checksum_buf;
3087 #define MD5_PRI "%016" PRIx64 "%016" PRIx64
3088 #define MD5_PRI_ARG(buf) AV_RB64(buf), AV_RB64((const uint8_t*)(buf) + 8)
3090 if (!memcmp(
md5,
s->sei.picture_hash.md5[
i], 16)) {
3092 "plane %d - correct " MD5_PRI "; ",
3096 "mismatching checksum of plane %d - " MD5_PRI " != " MD5_PRI "; ",
3103 "Verifying checksum for frame with POC %d: %s\n",
3115 if (
out->needs_fg) {
3118 switch (fgp->
type) {
3133 if (
s->avctx->hwaccel) {
3137 "hardware accelerator failed to decode picture\n");
3142 s->sei.picture_hash.is_md5) {
3148 s->sei.picture_hash.is_md5 = 0;
3167 s->no_rasl_output_flag)) {
3171 if (
s->sh.first_slice_in_pic_flag) {
3173 av_log(
s->avctx,
AV_LOG_ERROR,
"Two slices reporting being the first in the same frame.\n");
3180 }
else if (!
s->cur_frame) {
3185 if (
s->nal_unit_type !=
s->first_nal_type) {
3187 "Non-matching NAL types of the VCL NALUs: %d %d\n",
3188 s->first_nal_type,
s->nal_unit_type);
3204 s->nal_unit_type = nal->
type;
3219 switch (
s->nal_unit_type) {
3227 s->apply_defdispwin);
3272 "Skipping NAL unit %d\n",
s->nal_unit_type);
3280 "Skipping invalid undecodable NALU: %d\n",
s->nal_unit_type);
3289 int eos_at_start = 1;
3291 s->cur_frame =
s->collocated_ref =
NULL;
3292 s->last_eos =
s->eos;
3294 s->slice_initialized = 0;
3299 s->nal_length_size,
s->avctx->codec_id, 1, 0);
3302 "Error splitting the input into NAL units.\n");
3306 for (
i = 0;
i <
s->pkt.nb_nals;
i++) {
3328 s->pkt.nals[
s->pkt.nb_nals - 1].size > 2 && !
s->pkt.nals[
s->pkt.nb_nals - 1].nuh_layer_id
3329 && !
s->pkt.nals[
s->pkt.nb_nals - 1].temporal_id) {
3330 H2645NAL *nal = &
s->pkt.nals[
s->pkt.nb_nals - 1];
3333 av_log(
s->avctx,
AV_LOG_WARNING,
"Multiple Dolby Vision RPUs found in one AU. Skipping previous.\n");
3342 s->avctx->err_recognition);
3351 for (
i = 0;
i <
s->pkt.nb_nals;
i++) {
3362 "Error parsing NAL unit #%d.\n",
i);
3384 &
s->nal_length_size,
s->avctx->err_recognition,
3385 s->apply_defdispwin,
s->avctx);
3391 if (
first &&
s->ps.sps_list[
i]) {
3424 if (sd && sd_size > 0) {
3431 if (sd && sd_size >=
sizeof(
s->dovi_ctx.cfg)) {
3432 int old =
s->dovi_ctx.cfg.dv_profile;
3436 "New DOVI configuration record from input packet (profile %d -> %u).\n",
3437 old,
s->dovi_ctx.cfg.dv_profile);
3444 if (
s->output_frame->buf[0]) {
3458 if (
src->needs_fg) {
3478 src->hwaccel_picture_private);
3497 for (
i = 0;
i < 3;
i++) {
3533 s->nb_local_ctx = 1;
3535 s->local_ctx[0].parent =
s;
3536 s->local_ctx[0].logctx = avctx;
3537 s->local_ctx[0].common_cabac_state = &
s->cabac;
3540 if (!
s->output_frame)
3545 if (!
s->DPB[
i].frame_grain)
3555 s->dovi_ctx.logctx = avctx;
3580 if (
s->ps.sps != s0->
ps.
sps)
3594 if (
s->ps.sps != s0->
ps.
sps)
3663 s->sei.picture_timing.picture_struct = 0;
3683 if (sd && sd->
size >=
sizeof(
s->dovi_ctx.cfg))
3703 #define OFFSET(x) offsetof(HEVCContext, x)
3704 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3707 {
"apply_defdispwin",
"Apply default display window from VUI",
OFFSET(apply_defdispwin),
3709 {
"strict-displaywin",
"stricly apply default display window size",
OFFSET(apply_defdispwin),
3740 #if CONFIG_HEVC_DXVA2_HWACCEL
3743 #if CONFIG_HEVC_D3D11VA_HWACCEL
3746 #if CONFIG_HEVC_D3D11VA2_HWACCEL
3749 #if CONFIG_HEVC_D3D12VA_HWACCEL
3752 #if CONFIG_HEVC_NVDEC_HWACCEL
3755 #if CONFIG_HEVC_VAAPI_HWACCEL
3758 #if CONFIG_HEVC_VDPAU_HWACCEL
3761 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
3764 #if CONFIG_HEVC_VULKAN_HWACCEL