26 #include "config_components.h"
54 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 };
96 int log2_min_cb_size =
sps->log2_min_cb_size;
99 int pic_size_in_ctb = ((
width >> log2_min_cb_size) + 1) *
100 ((
height >> log2_min_cb_size) + 1);
101 int ctb_count =
sps->ctb_width *
sps->ctb_height;
102 int min_pu_size =
sps->min_pu_width *
sps->min_pu_height;
104 s->bs_width = (
width >> 2) + 1;
105 s->bs_height = (
height >> 2) + 1;
108 s->deblock =
av_calloc(ctb_count,
sizeof(*
s->deblock));
109 if (!
s->sao || !
s->deblock)
114 if (!
s->skip_flag || !
s->tab_ct_depth)
120 if (!
s->tab_ipm || !
s->cbf_luma || !
s->is_pcm)
125 sizeof(*
s->tab_slice_address));
127 sizeof(*
s->qp_y_tab));
128 if (!
s->qp_y_tab || !
s->filter_slice_edges || !
s->tab_slice_address)
131 s->horizontal_bs =
av_calloc(
s->bs_width,
s->bs_height);
133 if (!
s->horizontal_bs || !
s->vertical_bs)
138 if (!
s->tab_mvf_pool || !
s->rpl_tab_pool)
152 uint8_t luma_weight_l0_flag[16];
153 uint8_t chroma_weight_l0_flag[16];
154 uint8_t luma_weight_l1_flag[16];
155 uint8_t chroma_weight_l1_flag[16];
156 int luma_log2_weight_denom;
159 if (luma_log2_weight_denom < 0 || luma_log2_weight_denom > 7) {
160 av_log(
s->avctx,
AV_LOG_ERROR,
"luma_log2_weight_denom %d is invalid\n", luma_log2_weight_denom);
163 s->sh.luma_log2_weight_denom =
av_clip_uintp2(luma_log2_weight_denom, 3);
164 if (
s->ps.sps->chroma_format_idc != 0) {
165 int64_t chroma_log2_weight_denom = luma_log2_weight_denom + (int64_t)
get_se_golomb(gb);
166 if (chroma_log2_weight_denom < 0 || chroma_log2_weight_denom > 7) {
167 av_log(
s->avctx,
AV_LOG_ERROR,
"chroma_log2_weight_denom %"PRId64
" is invalid\n", chroma_log2_weight_denom);
170 s->sh.chroma_log2_weight_denom = chroma_log2_weight_denom;
173 for (
i = 0;
i <
s->sh.nb_refs[
L0];
i++) {
175 if (!luma_weight_l0_flag[
i]) {
176 s->sh.luma_weight_l0[
i] = 1 <<
s->sh.luma_log2_weight_denom;
177 s->sh.luma_offset_l0[
i] = 0;
180 if (
s->ps.sps->chroma_format_idc != 0) {
181 for (
i = 0;
i <
s->sh.nb_refs[
L0];
i++)
184 for (
i = 0;
i <
s->sh.nb_refs[
L0];
i++)
185 chroma_weight_l0_flag[
i] = 0;
187 for (
i = 0;
i <
s->sh.nb_refs[
L0];
i++) {
188 if (luma_weight_l0_flag[
i]) {
190 if ((int8_t)delta_luma_weight_l0 != delta_luma_weight_l0)
192 s->sh.luma_weight_l0[
i] = (1 <<
s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;
195 if (chroma_weight_l0_flag[
i]) {
196 for (j = 0; j < 2; j++) {
200 if ( (int8_t)delta_chroma_weight_l0 != delta_chroma_weight_l0
201 || delta_chroma_offset_l0 < -(1<<17) || delta_chroma_offset_l0 > (1<<17)) {
205 s->sh.chroma_weight_l0[
i][j] = (1 <<
s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
206 s->sh.chroma_offset_l0[
i][j] =
av_clip((delta_chroma_offset_l0 - ((128 *
s->sh.chroma_weight_l0[
i][j])
207 >>
s->sh.chroma_log2_weight_denom) + 128), -128, 127);
210 s->sh.chroma_weight_l0[
i][0] = 1 <<
s->sh.chroma_log2_weight_denom;
211 s->sh.chroma_offset_l0[
i][0] = 0;
212 s->sh.chroma_weight_l0[
i][1] = 1 <<
s->sh.chroma_log2_weight_denom;
213 s->sh.chroma_offset_l0[
i][1] = 0;
217 for (
i = 0;
i <
s->sh.nb_refs[
L1];
i++) {
219 if (!luma_weight_l1_flag[
i]) {
220 s->sh.luma_weight_l1[
i] = 1 <<
s->sh.luma_log2_weight_denom;
221 s->sh.luma_offset_l1[
i] = 0;
224 if (
s->ps.sps->chroma_format_idc != 0) {
225 for (
i = 0;
i <
s->sh.nb_refs[
L1];
i++)
228 for (
i = 0;
i <
s->sh.nb_refs[
L1];
i++)
229 chroma_weight_l1_flag[
i] = 0;
231 for (
i = 0;
i <
s->sh.nb_refs[
L1];
i++) {
232 if (luma_weight_l1_flag[
i]) {
234 if ((int8_t)delta_luma_weight_l1 != delta_luma_weight_l1)
236 s->sh.luma_weight_l1[
i] = (1 <<
s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;
239 if (chroma_weight_l1_flag[
i]) {
240 for (j = 0; j < 2; j++) {
244 if ( (int8_t)delta_chroma_weight_l1 != delta_chroma_weight_l1
245 || delta_chroma_offset_l1 < -(1<<17) || delta_chroma_offset_l1 > (1<<17)) {
249 s->sh.chroma_weight_l1[
i][j] = (1 <<
s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
250 s->sh.chroma_offset_l1[
i][j] =
av_clip((delta_chroma_offset_l1 - ((128 *
s->sh.chroma_weight_l1[
i][j])
251 >>
s->sh.chroma_log2_weight_denom) + 128), -128, 127);
254 s->sh.chroma_weight_l1[
i][0] = 1 <<
s->sh.chroma_log2_weight_denom;
255 s->sh.chroma_offset_l1[
i][0] = 0;
256 s->sh.chroma_weight_l1[
i][1] = 1 <<
s->sh.chroma_log2_weight_denom;
257 s->sh.chroma_offset_l1[
i][1] = 0;
267 int max_poc_lsb = 1 <<
sps->log2_max_poc_lsb;
268 int prev_delta_msb = 0;
269 unsigned int nb_sps = 0, nb_sh;
273 if (!
sps->long_term_ref_pics_present_flag)
276 if (
sps->num_long_term_ref_pics_sps > 0)
280 if (nb_sps >
sps->num_long_term_ref_pics_sps)
290 uint8_t lt_idx_sps = 0;
292 if (
sps->num_long_term_ref_pics_sps > 1)
295 rps->
poc[
i] =
sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
296 rps->
used[
i] =
sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];
307 if (
i &&
i != nb_sps)
308 delta += prev_delta_msb;
310 poc = rps->
poc[
i] +
s->poc -
delta * max_poc_lsb -
s->sh.pic_order_cnt_lsb;
314 prev_delta_msb =
delta;
327 unsigned int num = 0, den = 0;
335 avctx->
profile =
sps->ptl.general_ptl.profile_idc;
336 avctx->
level =
sps->ptl.general_ptl.level_idc;
340 if (
sps->vui.common.video_signal_type_present_flag)
346 if (
sps->vui.common.colour_description_present_flag) {
348 avctx->
color_trc =
sps->vui.common.transfer_characteristics;
357 if (
sps->chroma_format_idc == 1) {
358 if (
sps->vui.common.chroma_loc_info_present_flag) {
359 if (
sps->vui.common.chroma_sample_loc_type_top_field <= 5)
365 if (
vps->vps_timing_info_present_flag) {
366 num =
vps->vps_num_units_in_tick;
367 den =
vps->vps_time_scale;
368 }
else if (
sps->vui.vui_timing_info_present_flag) {
369 num =
sps->vui.vui_num_units_in_tick;
370 den =
sps->vui.vui_time_scale;
373 if (num != 0 && den != 0)
382 if (
s->sei.common.a53_caption.buf_ref)
385 if (
s->sei.common.alternative_transfer.present &&
388 avctx->
color_trc =
s->sei.common.alternative_transfer.preferred_transfer_characteristics;
391 if (
s->sei.common.film_grain_characteristics.present)
399 #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + \
400 CONFIG_HEVC_D3D11VA_HWACCEL * 2 + \
401 CONFIG_HEVC_D3D12VA_HWACCEL + \
402 CONFIG_HEVC_NVDEC_HWACCEL + \
403 CONFIG_HEVC_VAAPI_HWACCEL + \
404 CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL + \
405 CONFIG_HEVC_VDPAU_HWACCEL + \
406 CONFIG_HEVC_VULKAN_HWACCEL)
409 switch (
sps->pix_fmt) {
412 #if CONFIG_HEVC_DXVA2_HWACCEL
415 #if CONFIG_HEVC_D3D11VA_HWACCEL
419 #if CONFIG_HEVC_D3D12VA_HWACCEL
422 #if CONFIG_HEVC_VAAPI_HWACCEL
425 #if CONFIG_HEVC_VDPAU_HWACCEL
428 #if CONFIG_HEVC_NVDEC_HWACCEL
431 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
434 #if CONFIG_HEVC_VULKAN_HWACCEL
439 #if CONFIG_HEVC_DXVA2_HWACCEL
442 #if CONFIG_HEVC_D3D11VA_HWACCEL
446 #if CONFIG_HEVC_D3D12VA_HWACCEL
449 #if CONFIG_HEVC_VAAPI_HWACCEL
452 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
455 #if CONFIG_HEVC_VULKAN_HWACCEL
458 #if CONFIG_HEVC_VDPAU_HWACCEL
461 #if CONFIG_HEVC_NVDEC_HWACCEL
466 #if CONFIG_HEVC_VAAPI_HWACCEL
469 #if CONFIG_HEVC_VDPAU_HWACCEL
472 #if CONFIG_HEVC_NVDEC_HWACCEL
475 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
478 #if CONFIG_HEVC_VULKAN_HWACCEL
484 #if CONFIG_HEVC_VAAPI_HWACCEL
487 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
490 #if CONFIG_HEVC_VULKAN_HWACCEL
495 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
501 #if CONFIG_HEVC_VAAPI_HWACCEL
504 #if CONFIG_HEVC_VDPAU_HWACCEL
507 #if CONFIG_HEVC_VULKAN_HWACCEL
510 #if CONFIG_HEVC_NVDEC_HWACCEL
515 #if CONFIG_HEVC_VAAPI_HWACCEL
518 #if CONFIG_HEVC_VULKAN_HWACCEL
524 *fmt++ =
sps->pix_fmt;
554 for (
i = 0;
i < 3;
i++) {
559 if (
sps->sao_enabled && !
s->avctx->hwaccel) {
560 int c_count = (
sps->chroma_format_idc != 0) ? 3 : 1;
563 for(c_idx = 0; c_idx < c_count; c_idx++) {
564 int w =
sps->width >>
sps->hshift[c_idx];
565 int h =
sps->height >>
sps->vshift[c_idx];
566 s->sao_pixel_buffer_h[c_idx] =
569 s->sao_pixel_buffer_v[c_idx] =
572 if (!
s->sao_pixel_buffer_h[c_idx] ||
573 !
s->sao_pixel_buffer_v[c_idx])
579 s->ps.vps =
s->ps.vps_list[
s->ps.sps->vps_id];
585 for (
i = 0;
i < 3;
i++) {
602 av_log(
s->avctx,
AV_LOG_ERROR,
"Two slices reporting being the first in the same frame.\n");
622 s->ps.pps !=
s->ps.pps_list[sh->
pps_id]) {
626 s->ps.pps =
s->ps.pps_list[sh->
pps_id];
630 if (
s->ps.sps !=
s->ps.sps_list[
s->ps.pps->sps_id]) {
655 int slice_address_length;
657 if (
s->ps.pps->dependent_slice_segments_enabled_flag)
661 s->ps.sps->ctb_height);
665 "Invalid slice segment address: %u.\n",
677 s->slice_initialized = 0;
681 s->slice_initialized = 0;
683 for (
i = 0;
i <
s->ps.pps->num_extra_slice_header_bits;
i++)
695 !
s->ps.pps->pps_curr_pic_ref_enabled_flag) {
702 if (
s->ps.pps->output_flag_present_flag)
705 if (
s->ps.sps->separate_colour_plane_flag)
715 "Ignoring POC change between slices: %d -> %d\n",
s->poc, poc);
731 int numbits, rps_idx;
733 if (!
s->ps.sps->nb_st_rps) {
739 rps_idx = numbits > 0 ?
get_bits(gb, numbits) : 0;
753 if (
s->ps.sps->sps_temporal_mvp_enabled_flag)
778 if (
s->ps.sps->sao_enabled) {
780 if (
s->ps.sps->chroma_format_idc) {
794 sh->
nb_refs[
L0] =
s->ps.pps->num_ref_idx_l0_default_active;
796 sh->
nb_refs[
L1] =
s->ps.pps->num_ref_idx_l1_default_active;
817 if (
s->ps.pps->lists_modification_present_flag && nb_refs > 1) {
835 if (
s->ps.pps->cabac_init_present_flag)
850 "Invalid collocated_ref_idx: %d.\n",
867 "Invalid number of merging MVP candidates: %d.\n",
873 if (
s->ps.sps->motion_vector_resolution_control_idc == 2)
883 if (
s->ps.pps->pic_slice_level_chroma_qp_offsets_present_flag) {
896 if (
s->ps.pps->pps_slice_act_qp_offsets_present_flag) {
902 if (
s->ps.pps->chroma_qp_offset_list_enabled_flag)
907 if (
s->ps.pps->deblocking_filter_control_present_flag) {
908 int deblocking_filter_override_flag = 0;
910 if (
s->ps.pps->deblocking_filter_override_enabled_flag)
911 deblocking_filter_override_flag =
get_bits1(gb);
913 if (deblocking_filter_override_flag) {
918 if (beta_offset_div2 < -6 || beta_offset_div2 > 6 ||
919 tc_offset_div2 < -6 || tc_offset_div2 > 6) {
921 "Invalid deblock filter offsets: %d, %d\n",
922 beta_offset_div2, tc_offset_div2);
939 if (
s->ps.pps->seq_loop_filter_across_slices_enabled_flag &&
947 }
else if (!
s->slice_initialized) {
953 if (
s->ps.pps->tiles_enabled_flag ||
s->ps.pps->entropy_coding_sync_enabled_flag) {
957 av_log(
s->avctx,
AV_LOG_ERROR,
"num_entry_point_offsets %d is invalid\n", num_entry_point_offsets);
965 if (offset_len < 1 || offset_len > 32) {
986 if (
s->threads_number > 1 && (
s->ps.pps->num_tile_rows > 1 ||
s->ps.pps->num_tile_columns > 1)) {
987 s->enable_parallel_tiles = 0;
988 s->threads_number = 1;
990 s->enable_parallel_tiles = 0;
992 s->enable_parallel_tiles = 0;
995 if (
s->ps.pps->slice_header_extension_present_flag) {
1001 for (
i = 0;
i < length;
i++)
1008 sh->
slice_qp < -
s->ps.sps->qp_bd_offset) {
1010 "The slice_qp %d is outside the valid range "
1013 -
s->ps.sps->qp_bd_offset);
1019 if (!
s->sh.slice_ctb_addr_rs &&
s->sh.dependent_slice_segment_flag) {
1030 s->HEVClc->first_qp_group = !
s->sh.dependent_slice_segment_flag;
1032 if (!
s->ps.pps->cu_qp_delta_enabled_flag)
1033 s->HEVClc->qp_y =
s->sh.slice_qp;
1035 s->slice_initialized = 1;
1036 s->HEVClc->tu.cu_qp_offset_cb = 0;
1037 s->HEVClc->tu.cu_qp_offset_cr = 0;
1042 #define CTB(tab, x, y) ((tab)[(y) * s->ps.sps->ctb_width + (x)])
1044 #define SET_SAO(elem, value) \
1046 if (!sao_merge_up_flag && !sao_merge_left_flag) \
1047 sao->elem = value; \
1048 else if (sao_merge_left_flag) \
1049 sao->elem = CTB(s->sao, rx-1, ry).elem; \
1050 else if (sao_merge_up_flag) \
1051 sao->elem = CTB(s->sao, rx, ry-1).elem; \
1059 int sao_merge_left_flag = 0;
1060 int sao_merge_up_flag = 0;
1064 if (
s->sh.slice_sample_adaptive_offset_flag[0] ||
1065 s->sh.slice_sample_adaptive_offset_flag[1]) {
1070 if (ry > 0 && !sao_merge_left_flag) {
1076 for (c_idx = 0; c_idx < (
s->ps.sps->chroma_format_idc ? 3 : 1); c_idx++) {
1077 int log2_sao_offset_scale = c_idx == 0 ?
s->ps.pps->log2_sao_offset_scale_luma :
1078 s->ps.pps->log2_sao_offset_scale_chroma;
1080 if (!
s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
1095 for (
i = 0;
i < 4;
i++)
1099 for (
i = 0;
i < 4;
i++) {
1108 }
else if (c_idx != 2) {
1114 for (
i = 0;
i < 4;
i++) {
1122 sao->
offset_val[c_idx][
i + 1] *= 1 << log2_sao_offset_scale;
1134 if (log2_res_scale_abs_plus1 != 0) {
1137 (1 - 2 * res_scale_sign_flag);
1147 int xBase,
int yBase,
int cb_xBase,
int cb_yBase,
1148 int log2_cb_size,
int log2_trafo_size,
1149 int blk_idx,
int cbf_luma,
int *cbf_cb,
int *cbf_cr)
1152 const int log2_trafo_size_c = log2_trafo_size -
s->ps.sps->hshift[1];
1156 int trafo_size = 1 << log2_trafo_size;
1159 s->hpc.intra_pred[log2_trafo_size - 2](lc, x0, y0, 0);
1162 if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
1163 (
s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1166 int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
1167 (
s->ps.sps->chroma_format_idc == 2 &&
1168 (cbf_cb[1] || cbf_cr[1]));
1180 "The cu_qp_delta %d is outside the valid range "
1183 -(26 +
s->ps.sps->qp_bd_offset / 2),
1184 (25 +
s->ps.sps->qp_bd_offset / 2));
1191 if (
s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
1194 if (cu_chroma_qp_offset_flag) {
1195 int cu_chroma_qp_offset_idx = 0;
1196 if (
s->ps.pps->chroma_qp_offset_list_len_minus1 > 0) {
1199 "cu_chroma_qp_offset_idx not yet tested.\n");
1232 if (
s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 ||
s->ps.sps->chroma_format_idc == 3)) {
1233 int trafo_size_h = 1 << (log2_trafo_size_c +
s->ps.sps->hshift[1]);
1234 int trafo_size_v = 1 << (log2_trafo_size_c +
s->ps.sps->vshift[1]);
1235 lc->
tu.
cross_pf = (
s->ps.pps->cross_component_prediction_enabled_flag && cbf_luma &&
1242 for (
i = 0;
i < (
s->ps.sps->chroma_format_idc == 2 ? 2 : 1);
i++) {
1245 s->hpc.intra_pred[log2_trafo_size_c - 2](lc, x0, y0 + (
i << log2_trafo_size_c), 1);
1249 log2_trafo_size_c, scan_idx_c, 1);
1252 ptrdiff_t
stride =
s->frame->linesize[1];
1253 int hshift =
s->ps.sps->hshift[1];
1254 int vshift =
s->ps.sps->vshift[1];
1257 int size = 1 << log2_trafo_size_c;
1259 uint8_t *dst = &
s->frame->data[1][(y0 >> vshift) *
stride +
1260 ((x0 >> hshift) <<
s->ps.sps->pixel_shift)];
1264 s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs,
stride);
1271 for (
i = 0;
i < (
s->ps.sps->chroma_format_idc == 2 ? 2 : 1);
i++) {
1274 trafo_size_h, trafo_size_v);
1275 s->hpc.intra_pred[log2_trafo_size_c - 2](lc, x0, y0 + (
i << log2_trafo_size_c), 2);
1279 log2_trafo_size_c, scan_idx_c, 2);
1282 ptrdiff_t
stride =
s->frame->linesize[2];
1283 int hshift =
s->ps.sps->hshift[2];
1284 int vshift =
s->ps.sps->vshift[2];
1287 int size = 1 << log2_trafo_size_c;
1289 uint8_t *dst = &
s->frame->data[2][(y0 >> vshift) *
stride +
1290 ((x0 >> hshift) <<
s->ps.sps->pixel_shift)];
1294 s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs,
stride);
1297 }
else if (
s->ps.sps->chroma_format_idc && blk_idx == 3) {
1298 int trafo_size_h = 1 << (log2_trafo_size + 1);
1299 int trafo_size_v = 1 << (log2_trafo_size +
s->ps.sps->vshift[1]);
1300 for (
i = 0;
i < (
s->ps.sps->chroma_format_idc == 2 ? 2 : 1);
i++) {
1303 trafo_size_h, trafo_size_v);
1304 s->hpc.intra_pred[log2_trafo_size - 2](lc, xBase, yBase + (
i << log2_trafo_size), 1);
1308 log2_trafo_size, scan_idx_c, 1);
1310 for (
i = 0;
i < (
s->ps.sps->chroma_format_idc == 2 ? 2 : 1);
i++) {
1313 trafo_size_h, trafo_size_v);
1314 s->hpc.intra_pred[log2_trafo_size - 2](lc, xBase, yBase + (
i << log2_trafo_size), 2);
1318 log2_trafo_size, scan_idx_c, 2);
1322 if (log2_trafo_size > 2 ||
s->ps.sps->chroma_format_idc == 3) {
1323 int trafo_size_h = 1 << (log2_trafo_size_c +
s->ps.sps->hshift[1]);
1324 int trafo_size_v = 1 << (log2_trafo_size_c +
s->ps.sps->vshift[1]);
1326 s->hpc.intra_pred[log2_trafo_size_c - 2](lc, x0, y0, 1);
1327 s->hpc.intra_pred[log2_trafo_size_c - 2](lc, x0, y0, 2);
1328 if (
s->ps.sps->chroma_format_idc == 2) {
1330 trafo_size_h, trafo_size_v);
1331 s->hpc.intra_pred[log2_trafo_size_c - 2](lc, x0, y0 + (1 << log2_trafo_size_c), 1);
1332 s->hpc.intra_pred[log2_trafo_size_c - 2](lc, x0, y0 + (1 << log2_trafo_size_c), 2);
1334 }
else if (blk_idx == 3) {
1335 int trafo_size_h = 1 << (log2_trafo_size + 1);
1336 int trafo_size_v = 1 << (log2_trafo_size +
s->ps.sps->vshift[1]);
1338 trafo_size_h, trafo_size_v);
1339 s->hpc.intra_pred[log2_trafo_size - 2](lc, xBase, yBase, 1);
1340 s->hpc.intra_pred[log2_trafo_size - 2](lc, xBase, yBase, 2);
1341 if (
s->ps.sps->chroma_format_idc == 2) {
1343 trafo_size_h, trafo_size_v);
1344 s->hpc.intra_pred[log2_trafo_size - 2](lc, xBase, yBase + (1 << log2_trafo_size), 1);
1345 s->hpc.intra_pred[log2_trafo_size - 2](lc, xBase, yBase + (1 << log2_trafo_size), 2);
1355 int cb_size = 1 << log2_cb_size;
1356 int log2_min_pu_size =
s->ps.sps->log2_min_pu_size;
1358 int min_pu_width =
s->ps.sps->min_pu_width;
1359 int x_end =
FFMIN(x0 + cb_size,
s->ps.sps->width);
1360 int y_end =
FFMIN(y0 + cb_size,
s->ps.sps->height);
1363 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1364 for (
i = (x0 >> log2_min_pu_size);
i < (x_end >> log2_min_pu_size);
i++)
1365 s->is_pcm[
i + j * min_pu_width] = 2;
1369 int xBase,
int yBase,
int cb_xBase,
int cb_yBase,
1370 int log2_cb_size,
int log2_trafo_size,
1371 int trafo_depth,
int blk_idx,
1372 const int *base_cbf_cb,
const int *base_cbf_cr)
1375 uint8_t split_transform_flag;
1380 cbf_cb[0] = base_cbf_cb[0];
1381 cbf_cb[1] = base_cbf_cb[1];
1382 cbf_cr[0] = base_cbf_cr[0];
1383 cbf_cr[1] = base_cbf_cr[1];
1386 if (trafo_depth == 1) {
1388 if (
s->ps.sps->chroma_format_idc == 3) {
1402 if (log2_trafo_size <= s->ps.sps->log2_max_trafo_size &&
1403 log2_trafo_size >
s->ps.sps->log2_min_tb_size &&
1404 trafo_depth < lc->cu.max_trafo_depth &&
1408 int inter_split =
s->ps.sps->max_transform_hierarchy_depth_inter == 0 &&
1413 split_transform_flag = log2_trafo_size >
s->ps.sps->log2_max_trafo_size ||
1418 if (
s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 ||
s->ps.sps->chroma_format_idc == 3)) {
1419 if (trafo_depth == 0 || cbf_cb[0]) {
1421 if (
s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1426 if (trafo_depth == 0 || cbf_cr[0]) {
1428 if (
s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1434 if (split_transform_flag) {
1435 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1436 const int x1 = x0 + trafo_size_split;
1437 const int y1 = y0 + trafo_size_split;
1439 #define SUBDIVIDE(x, y, idx) \
1441 ret = hls_transform_tree(lc, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size,\
1442 log2_trafo_size - 1, trafo_depth + 1, idx, \
1455 int min_tu_size = 1 <<
s->ps.sps->log2_min_tb_size;
1456 int log2_min_tu_size =
s->ps.sps->log2_min_tb_size;
1457 int min_tu_width =
s->ps.sps->min_tb_width;
1461 cbf_cb[0] || cbf_cr[0] ||
1462 (
s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1467 log2_cb_size, log2_trafo_size,
1468 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1474 for (
i = 0;
i < (1 << log2_trafo_size);
i += min_tu_size)
1475 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1476 int x_tu = (x0 + j) >> log2_min_tu_size;
1477 int y_tu = (y0 +
i) >> log2_min_tu_size;
1478 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1481 if (!
s->sh.disable_deblocking_filter_flag) {
1483 if (
s->ps.pps->transquant_bypass_enable_flag &&
1495 int cb_size = 1 << log2_cb_size;
1496 ptrdiff_t stride0 =
s->frame->linesize[0];
1497 ptrdiff_t stride1 =
s->frame->linesize[1];
1498 ptrdiff_t stride2 =
s->frame->linesize[2];
1499 uint8_t *dst0 = &
s->frame->data[0][y0 * stride0 + (x0 <<
s->ps.sps->pixel_shift)];
1500 uint8_t *dst1 = &
s->frame->data[1][(y0 >>
s->ps.sps->vshift[1]) * stride1 + ((x0 >>
s->ps.sps->hshift[1]) <<
s->ps.sps->pixel_shift)];
1501 uint8_t *dst2 = &
s->frame->data[2][(y0 >>
s->ps.sps->vshift[2]) * stride2 + ((x0 >>
s->ps.sps->hshift[2]) <<
s->ps.sps->pixel_shift)];
1503 int length = cb_size * cb_size *
s->ps.sps->pcm.bit_depth +
1504 (((cb_size >>
s->ps.sps->hshift[1]) * (cb_size >>
s->ps.sps->vshift[1])) +
1505 ((cb_size >>
s->ps.sps->hshift[2]) * (cb_size >>
s->ps.sps->vshift[2]))) *
1506 s->ps.sps->pcm.bit_depth_chroma;
1507 const uint8_t *pcm =
skip_bytes(&lc->
cc, (length + 7) >> 3);
1510 if (!
s->sh.disable_deblocking_filter_flag)
1517 s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size, &gb,
s->ps.sps->pcm.bit_depth);
1518 if (
s->ps.sps->chroma_format_idc) {
1519 s->hevcdsp.put_pcm(dst1, stride1,
1520 cb_size >>
s->ps.sps->hshift[1],
1521 cb_size >>
s->ps.sps->vshift[1],
1522 &gb,
s->ps.sps->pcm.bit_depth_chroma);
1523 s->hevcdsp.put_pcm(dst2, stride2,
1524 cb_size >>
s->ps.sps->hshift[2],
1525 cb_size >>
s->ps.sps->vshift[2],
1526 &gb,
s->ps.sps->pcm.bit_depth_chroma);
1550 int block_w,
int block_h,
int luma_weight,
int luma_offset)
1553 const uint8_t *
src =
ref->data[0];
1554 ptrdiff_t srcstride =
ref->linesize[0];
1555 int pic_width =
s->ps.sps->width;
1556 int pic_height =
s->ps.sps->height;
1559 int weight_flag = (
s->sh.slice_type ==
HEVC_SLICE_P &&
s->ps.pps->weighted_pred_flag) ||
1560 (
s->sh.slice_type ==
HEVC_SLICE_B &&
s->ps.pps->weighted_bipred_flag);
1563 x_off +=
mv->x >> 2;
1564 y_off +=
mv->y >> 2;
1565 src += y_off * srcstride + (x_off * (1 <<
s->ps.sps->pixel_shift));
1576 edge_emu_stride, srcstride,
1580 pic_width, pic_height);
1582 srcstride = edge_emu_stride;
1586 s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride,
src, srcstride,
1587 block_h, mx, my, block_w);
1589 s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride,
src, srcstride,
1590 block_h,
s->sh.luma_log2_weight_denom,
1591 luma_weight, luma_offset, mx, my, block_w);
1611 const AVFrame *ref0,
const Mv *mv0,
int x_off,
int y_off,
1612 int block_w,
int block_h,
const AVFrame *ref1,
1613 const Mv *mv1,
struct MvField *current_mv)
1616 ptrdiff_t src0stride = ref0->
linesize[0];
1617 ptrdiff_t src1stride = ref1->
linesize[0];
1618 int pic_width =
s->ps.sps->width;
1619 int pic_height =
s->ps.sps->height;
1620 int mx0 = mv0->
x & 3;
1621 int my0 = mv0->
y & 3;
1622 int mx1 = mv1->
x & 3;
1623 int my1 = mv1->
y & 3;
1624 int weight_flag = (
s->sh.slice_type ==
HEVC_SLICE_P &&
s->ps.pps->weighted_pred_flag) ||
1625 (
s->sh.slice_type ==
HEVC_SLICE_B &&
s->ps.pps->weighted_bipred_flag);
1626 int x_off0 = x_off + (mv0->
x >> 2);
1627 int y_off0 = y_off + (mv0->
y >> 2);
1628 int x_off1 = x_off + (mv1->
x >> 2);
1629 int y_off1 = y_off + (mv1->
y >> 2);
1632 const uint8_t *
src0 = ref0->
data[0] + y_off0 * src0stride + (
int)((
unsigned)x_off0 <<
s->ps.sps->pixel_shift);
1633 const uint8_t *
src1 = ref1->
data[0] + y_off1 * src1stride + (
int)((
unsigned)x_off1 <<
s->ps.sps->pixel_shift);
1643 edge_emu_stride, src0stride,
1647 pic_width, pic_height);
1649 src0stride = edge_emu_stride;
1660 edge_emu_stride, src1stride,
1664 pic_width, pic_height);
1666 src1stride = edge_emu_stride;
1669 s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](lc->
tmp,
src0, src0stride,
1670 block_h, mx0, my0, block_w);
1672 s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride,
src1, src1stride, lc->
tmp,
1673 block_h, mx1, my1, block_w);
1675 s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride,
src1, src1stride, lc->
tmp,
1676 block_h,
s->sh.luma_log2_weight_denom,
1677 s->sh.luma_weight_l0[current_mv->
ref_idx[0]],
1678 s->sh.luma_weight_l1[current_mv->
ref_idx[1]],
1679 s->sh.luma_offset_l0[current_mv->
ref_idx[0]],
1680 s->sh.luma_offset_l1[current_mv->
ref_idx[1]],
1703 ptrdiff_t dststride,
const uint8_t *
src0, ptrdiff_t srcstride,
int reflist,
1704 int x_off,
int y_off,
int block_w,
int block_h,
1705 const struct MvField *current_mv,
int chroma_weight,
int chroma_offset)
1708 int pic_width =
s->ps.sps->width >>
s->ps.sps->hshift[1];
1709 int pic_height =
s->ps.sps->height >>
s->ps.sps->vshift[1];
1710 const Mv *
mv = ¤t_mv->
mv[reflist];
1711 int weight_flag = (
s->sh.slice_type ==
HEVC_SLICE_P &&
s->ps.pps->weighted_pred_flag) ||
1712 (
s->sh.slice_type ==
HEVC_SLICE_B &&
s->ps.pps->weighted_bipred_flag);
1714 int hshift =
s->ps.sps->hshift[1];
1715 int vshift =
s->ps.sps->vshift[1];
1718 intptr_t _mx = mx << (1 - hshift);
1719 intptr_t _my = my << (1 - vshift);
1720 int emu =
src0 ==
s->frame->data[1] ||
src0 ==
s->frame->data[2];
1722 x_off +=
mv->x >> (2 + hshift);
1723 y_off +=
mv->y >> (2 + vshift);
1724 src0 += y_off * srcstride + (x_off * (1 <<
s->ps.sps->pixel_shift));
1733 (edge_emu_stride + (1 <<
s->ps.sps->pixel_shift));
1735 edge_emu_stride, srcstride,
1739 pic_width, pic_height);
1742 srcstride = edge_emu_stride;
1745 s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride,
src0, srcstride,
1746 block_h, _mx, _my, block_w);
1748 s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride,
src0, srcstride,
1749 block_h,
s->sh.chroma_log2_weight_denom,
1750 chroma_weight, chroma_offset, _mx, _my, block_w);
1772 int x_off,
int y_off,
int block_w,
int block_h,
const MvField *current_mv,
int cidx)
1775 const uint8_t *
src1 = ref0->
data[cidx+1];
1776 const uint8_t *
src2 = ref1->
data[cidx+1];
1777 ptrdiff_t src1stride = ref0->
linesize[cidx+1];
1778 ptrdiff_t src2stride = ref1->
linesize[cidx+1];
1779 int weight_flag = (
s->sh.slice_type ==
HEVC_SLICE_P &&
s->ps.pps->weighted_pred_flag) ||
1780 (
s->sh.slice_type ==
HEVC_SLICE_B &&
s->ps.pps->weighted_bipred_flag);
1781 int pic_width =
s->ps.sps->width >>
s->ps.sps->hshift[1];
1782 int pic_height =
s->ps.sps->height >>
s->ps.sps->vshift[1];
1783 const Mv *
const mv0 = ¤t_mv->
mv[0];
1784 const Mv *
const mv1 = ¤t_mv->
mv[1];
1785 int hshift =
s->ps.sps->hshift[1];
1786 int vshift =
s->ps.sps->vshift[1];
1792 intptr_t _mx0 = mx0 << (1 - hshift);
1793 intptr_t _my0 = my0 << (1 - vshift);
1794 intptr_t _mx1 = mx1 << (1 - hshift);
1795 intptr_t _my1 = my1 << (1 - vshift);
1797 int x_off0 = x_off + (mv0->
x >> (2 + hshift));
1798 int y_off0 = y_off + (mv0->
y >> (2 + vshift));
1799 int x_off1 = x_off + (mv1->
x >> (2 + hshift));
1800 int y_off1 = y_off + (mv1->
y >> (2 + vshift));
1802 src1 += y_off0 * src1stride + (
int)((
unsigned)x_off0 <<
s->ps.sps->pixel_shift);
1803 src2 += y_off1 * src2stride + (
int)((
unsigned)x_off1 <<
s->ps.sps->pixel_shift);
1811 (edge_emu_stride + (1 <<
s->ps.sps->pixel_shift));
1814 edge_emu_stride, src1stride,
1818 pic_width, pic_height);
1821 src1stride = edge_emu_stride;
1830 (edge_emu_stride + (1 <<
s->ps.sps->pixel_shift));
1833 edge_emu_stride, src2stride,
1837 pic_width, pic_height);
1840 src2stride = edge_emu_stride;
1843 s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](lc->
tmp,
src1, src1stride,
1844 block_h, _mx0, _my0, block_w);
1846 s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0,
s->frame->linesize[cidx+1],
1848 block_h, _mx1, _my1, block_w);
1850 s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0,
s->frame->linesize[cidx+1],
1853 s->sh.chroma_log2_weight_denom,
1854 s->sh.chroma_weight_l0[current_mv->
ref_idx[0]][cidx],
1855 s->sh.chroma_weight_l1[current_mv->
ref_idx[1]][cidx],
1856 s->sh.chroma_offset_l0[current_mv->
ref_idx[0]][cidx],
1857 s->sh.chroma_offset_l1[current_mv->
ref_idx[1]][cidx],
1858 _mx1, _my1, block_w);
1872 int nPbH,
int log2_cb_size,
int part_idx,
1884 if (inter_pred_idc !=
PRED_L1) {
1885 if (
s->sh.nb_refs[
L0])
1892 part_idx, merge_idx,
mv, mvp_flag, 0);
1897 if (inter_pred_idc !=
PRED_L0) {
1898 if (
s->sh.nb_refs[
L1])
1901 if (
s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc ==
PRED_BI) {
1910 part_idx, merge_idx,
mv, mvp_flag, 1);
1918 int log2_cb_size,
int partIdx,
int idx)
1920 #define POS(c_idx, x, y) \
1921 &s->frame->data[c_idx][((y) >> s->ps.sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1922 (((x) >> s->ps.sps->hshift[c_idx]) << s->ps.sps->pixel_shift)]
1925 struct MvField current_mv = {{{ 0 }}};
1927 int min_pu_width =
s->ps.sps->min_pu_width;
1929 MvField *tab_mvf =
s->ref->tab_mvf;
1930 const RefPicList *refPicList =
s->ref->refPicList;
1932 uint8_t *dst0 =
POS(0, x0, y0);
1933 uint8_t *dst1 =
POS(1, x0, y0);
1934 uint8_t *dst2 =
POS(2, x0, y0);
1935 int log2_min_cb_size =
s->ps.sps->log2_min_cb_size;
1936 int min_cb_width =
s->ps.sps->min_cb_width;
1937 int x_cb = x0 >> log2_min_cb_size;
1938 int y_cb = y0 >> log2_min_cb_size;
1942 int skip_flag =
SAMPLE_CTB(
s->skip_flag, x_cb, y_cb);
1948 if (
s->sh.max_num_merge_cand > 1)
1954 partIdx, merge_idx, ¤t_mv);
1957 partIdx, merge_idx, ¤t_mv);
1960 x_pu = x0 >>
s->ps.sps->log2_min_pu_size;
1961 y_pu = y0 >>
s->ps.sps->log2_min_pu_size;
1963 for (j = 0; j < nPbH >>
s->ps.sps->log2_min_pu_size; j++)
1964 for (
i = 0; i < nPbW >>
s->ps.sps->log2_min_pu_size;
i++)
1965 tab_mvf[(y_pu + j) * min_pu_width + x_pu +
i] = current_mv;
1968 ref0 = refPicList[0].
ref[current_mv.
ref_idx[0]];
1974 ref1 = refPicList[1].
ref[current_mv.
ref_idx[1]];
1975 if (!ref1 || !ref1->frame->data[0])
1981 int x0_c = x0 >>
s->ps.sps->hshift[1];
1982 int y0_c = y0 >>
s->ps.sps->vshift[1];
1983 int nPbW_c = nPbW >>
s->ps.sps->hshift[1];
1984 int nPbH_c = nPbH >>
s->ps.sps->vshift[1];
1987 ¤t_mv.
mv[0], x0, y0, nPbW, nPbH,
1988 s->sh.luma_weight_l0[current_mv.
ref_idx[0]],
1989 s->sh.luma_offset_l0[current_mv.
ref_idx[0]]);
1991 if (
s->ps.sps->chroma_format_idc) {
1993 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1994 s->sh.chroma_weight_l0[current_mv.
ref_idx[0]][0],
s->sh.chroma_offset_l0[current_mv.
ref_idx[0]][0]);
1996 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1997 s->sh.chroma_weight_l0[current_mv.
ref_idx[0]][1],
s->sh.chroma_offset_l0[current_mv.
ref_idx[0]][1]);
2000 int x0_c = x0 >>
s->ps.sps->hshift[1];
2001 int y0_c = y0 >>
s->ps.sps->vshift[1];
2002 int nPbW_c = nPbW >>
s->ps.sps->hshift[1];
2003 int nPbH_c = nPbH >>
s->ps.sps->vshift[1];
2005 luma_mc_uni(lc, dst0,
s->frame->linesize[0], ref1->frame,
2006 ¤t_mv.
mv[1], x0, y0, nPbW, nPbH,
2007 s->sh.luma_weight_l1[current_mv.
ref_idx[1]],
2008 s->sh.luma_offset_l1[current_mv.
ref_idx[1]]);
2010 if (
s->ps.sps->chroma_format_idc) {
2011 chroma_mc_uni(lc, dst1,
s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
2012 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
2013 s->sh.chroma_weight_l1[current_mv.
ref_idx[1]][0],
s->sh.chroma_offset_l1[current_mv.
ref_idx[1]][0]);
2015 chroma_mc_uni(lc, dst2,
s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
2016 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
2017 s->sh.chroma_weight_l1[current_mv.
ref_idx[1]][1],
s->sh.chroma_offset_l1[current_mv.
ref_idx[1]][1]);
2020 int x0_c = x0 >>
s->ps.sps->hshift[1];
2021 int y0_c = y0 >>
s->ps.sps->vshift[1];
2022 int nPbW_c = nPbW >>
s->ps.sps->hshift[1];
2023 int nPbH_c = nPbH >>
s->ps.sps->vshift[1];
2026 ¤t_mv.
mv[0], x0, y0, nPbW, nPbH,
2027 ref1->frame, ¤t_mv.
mv[1], ¤t_mv);
2029 if (
s->ps.sps->chroma_format_idc) {
2031 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 0);
2034 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1);
2043 int prev_intra_luma_pred_flag)
2046 int x_pu = x0 >>
s->ps.sps->log2_min_pu_size;
2047 int y_pu = y0 >>
s->ps.sps->log2_min_pu_size;
2048 int min_pu_width =
s->ps.sps->min_pu_width;
2049 int size_in_pus = pu_size >>
s->ps.sps->log2_min_pu_size;
2054 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] :
INTRA_DC;
2056 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] :
INTRA_DC;
2058 int y_ctb = (y0 >> (
s->ps.sps->log2_ctb_size)) << (
s->ps.sps->log2_ctb_size);
2060 MvField *tab_mvf =
s->ref->tab_mvf;
2061 int intra_pred_mode;
2066 if ((y0 - 1) < y_ctb)
2069 if (cand_left == cand_up) {
2070 if (cand_left < 2) {
2075 candidate[0] = cand_left;
2076 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
2077 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
2080 candidate[0] = cand_left;
2081 candidate[1] = cand_up;
2091 if (prev_intra_luma_pred_flag) {
2092 intra_pred_mode = candidate[lc->
pu.
mpm_idx];
2094 if (candidate[0] > candidate[1])
2095 FFSWAP(uint8_t, candidate[0], candidate[1]);
2096 if (candidate[0] > candidate[2])
2097 FFSWAP(uint8_t, candidate[0], candidate[2]);
2098 if (candidate[1] > candidate[2])
2099 FFSWAP(uint8_t, candidate[1], candidate[2]);
2102 for (
i = 0;
i < 3;
i++)
2103 if (intra_pred_mode >= candidate[
i])
2110 for (
i = 0;
i < size_in_pus;
i++) {
2111 memset(&
s->tab_ipm[(y_pu +
i) * min_pu_width + x_pu],
2112 intra_pred_mode, size_in_pus);
2114 for (j = 0; j < size_in_pus; j++) {
2119 return intra_pred_mode;
2123 int log2_cb_size,
int ct_depth)
2125 int length = (1 << log2_cb_size) >>
s->ps.sps->log2_min_cb_size;
2126 int x_cb = x0 >>
s->ps.sps->log2_min_cb_size;
2127 int y_cb = y0 >>
s->ps.sps->log2_min_cb_size;
2130 for (y = 0; y < length; y++)
2131 memset(&
s->tab_ct_depth[(y_cb + y) *
s->ps.sps->min_cb_width + x_cb],
2136 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
2137 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
2143 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
2144 uint8_t prev_intra_luma_pred_flag[4];
2146 int pb_size = (1 << log2_cb_size) >>
split;
2147 int side =
split + 1;
2151 for (
i = 0;
i < side;
i++)
2152 for (j = 0; j < side; j++)
2155 for (
i = 0;
i < side;
i++) {
2156 for (j = 0; j < side; j++) {
2157 if (prev_intra_luma_pred_flag[2 *
i + j])
2164 prev_intra_luma_pred_flag[2 *
i + j]);
2168 if (
s->ps.sps->chroma_format_idc == 3) {
2169 for (
i = 0;
i < side;
i++) {
2170 for (j = 0; j < side; j++) {
2172 if (chroma_mode != 4) {
2182 }
else if (
s->ps.sps->chroma_format_idc == 2) {
2185 if (chroma_mode != 4) {
2189 mode_idx = intra_chroma_table[chroma_mode];
2194 }
else if (
s->ps.sps->chroma_format_idc != 0) {
2196 if (chroma_mode != 4) {
2212 int pb_size = 1 << log2_cb_size;
2213 int size_in_pus = pb_size >>
s->ps.sps->log2_min_pu_size;
2214 int min_pu_width =
s->ps.sps->min_pu_width;
2215 MvField *tab_mvf =
s->ref->tab_mvf;
2216 int x_pu = x0 >>
s->ps.sps->log2_min_pu_size;
2217 int y_pu = y0 >>
s->ps.sps->log2_min_pu_size;
2220 if (size_in_pus == 0)
2222 for (j = 0; j < size_in_pus; j++)
2223 memset(&
s->tab_ipm[(y_pu + j) * min_pu_width + x_pu],
INTRA_DC, size_in_pus);
2225 for (j = 0; j < size_in_pus; j++)
2226 for (k = 0; k < size_in_pus; k++)
2232 int cb_size = 1 << log2_cb_size;
2233 int log2_min_cb_size =
s->ps.sps->log2_min_cb_size;
2234 int length = cb_size >> log2_min_cb_size;
2235 int min_cb_width =
s->ps.sps->min_cb_width;
2236 int x_cb = x0 >> log2_min_cb_size;
2237 int y_cb = y0 >> log2_min_cb_size;
2238 int idx = log2_cb_size - 2;
2239 int qp_block_mask = (1<<(
s->ps.sps->log2_ctb_size -
s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2249 for (x = 0; x < 4; x++)
2251 if (
s->ps.pps->transquant_bypass_enable_flag) {
2261 x = y_cb * min_cb_width + x_cb;
2262 for (y = 0; y < length; y++) {
2263 memset(&
s->skip_flag[x], skip_flag, length);
2268 x = y_cb * min_cb_width + x_cb;
2269 for (y = 0; y < length; y++) {
2270 memset(&
s->skip_flag[x], 0, length);
2279 if (!
s->sh.disable_deblocking_filter_flag)
2287 log2_cb_size ==
s->ps.sps->log2_min_cb_size) {
2295 log2_cb_size >=
s->ps.sps->pcm.log2_min_pcm_cb_size &&
2296 log2_cb_size <= s->ps.sps->pcm.log2_max_pcm_cb_size) {
2302 if (
s->ps.sps->pcm.loop_filter_disable_flag)
2318 hls_prediction_unit(lc, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2322 hls_prediction_unit(lc, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2326 hls_prediction_unit(lc, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2330 hls_prediction_unit(lc, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2334 hls_prediction_unit(lc, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2338 hls_prediction_unit(lc, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2342 hls_prediction_unit(lc, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2343 hls_prediction_unit(lc, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2344 hls_prediction_unit(lc, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2350 int rqt_root_cbf = 1;
2357 const static int cbf[2] = { 0 };
2360 s->ps.sps->max_transform_hierarchy_depth_inter;
2363 log2_cb_size, 0, 0, cbf, cbf);
2367 if (!
s->sh.disable_deblocking_filter_flag)
2376 x = y_cb * min_cb_width + x_cb;
2377 for (y = 0; y < length; y++) {
2378 memset(&
s->qp_y_tab[x], lc->
qp_y, length);
2382 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2383 ((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 <= s->ps.sps->width &&
2402 y0 + cb_size <= s->ps.sps->height &&
2403 log2_cb_size >
s->ps.sps->log2_min_cb_size) {
2406 split_cu = (log2_cb_size >
s->ps.sps->log2_min_cb_size);
2408 if (
s->ps.pps->cu_qp_delta_enabled_flag &&
2409 log2_cb_size >=
s->ps.sps->log2_ctb_size -
s->ps.pps->diff_cu_qp_delta_depth) {
2414 if (
s->sh.cu_chroma_qp_offset_enabled_flag &&
2415 log2_cb_size >=
s->ps.sps->log2_ctb_size -
s->ps.pps->diff_cu_chroma_qp_offset_depth) {
2420 int qp_block_mask = (1<<(
s->ps.sps->log2_ctb_size -
s->ps.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 < s->ps.sps->width) {
2436 if (more_data && y1 < s->ps.sps->height) {
2441 if (more_data && x1 < s->ps.sps->width &&
2442 y1 < s->ps.sps->height) {
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) <
s->ps.sps->width ||
2454 (y1 + cb_size_split) <
s->ps.sps->height);
2461 if ((!((x0 + cb_size) %
2462 (1 << (
s->ps.sps->log2_ctb_size))) ||
2463 (x0 + cb_size >=
s->ps.sps->width)) &&
2465 (1 << (
s->ps.sps->log2_ctb_size))) ||
2466 (y0 + cb_size >=
s->ps.sps->height))) {
2468 return !end_of_slice_flag;
2481 int ctb_size = 1 <<
s->ps.sps->log2_ctb_size;
2482 int ctb_addr_rs =
s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2483 int ctb_addr_in_slice = ctb_addr_rs -
s->sh.slice_addr;
2485 s->tab_slice_address[ctb_addr_rs] =
s->sh.slice_addr;
2487 if (
s->ps.pps->entropy_coding_sync_enabled_flag) {
2488 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2491 }
else if (
s->ps.pps->tiles_enabled_flag) {
2492 if (ctb_addr_ts &&
s->ps.pps->tile_id[ctb_addr_ts] !=
s->ps.pps->tile_id[ctb_addr_ts - 1]) {
2493 int idxX =
s->ps.pps->col_idxX[x_ctb >>
s->ps.sps->log2_ctb_size];
2494 lc->
end_of_tiles_x = x_ctb + (
s->ps.pps->column_width[idxX] <<
s->ps.sps->log2_ctb_size);
2504 if (
s->ps.pps->tiles_enabled_flag) {
2505 if (x_ctb > 0 &&
s->ps.pps->tile_id[ctb_addr_ts] !=
s->ps.pps->tile_id[
s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs - 1]])
2507 if (x_ctb > 0 &&
s->tab_slice_address[ctb_addr_rs] !=
s->tab_slice_address[ctb_addr_rs - 1])
2509 if (y_ctb > 0 &&
s->ps.pps->tile_id[ctb_addr_ts] !=
s->ps.pps->tile_id[
s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs -
s->ps.sps->ctb_width]])
2511 if (y_ctb > 0 &&
s->tab_slice_address[ctb_addr_rs] !=
s->tab_slice_address[ctb_addr_rs -
s->ps.sps->ctb_width])
2514 if (ctb_addr_in_slice <= 0)
2516 if (ctb_addr_in_slice < s->ps.sps->ctb_width)
2522 lc->
ctb_up_right_flag = ((y_ctb > 0) && (ctb_addr_in_slice+1 >=
s->ps.sps->ctb_width) && (
s->ps.pps->tile_id[ctb_addr_ts] ==
s->ps.pps->tile_id[
s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs+1 -
s->ps.sps->ctb_width]]));
2523 lc->
ctb_up_left_flag = ((x_ctb > 0) && (y_ctb > 0) && (ctb_addr_in_slice-1 >=
s->ps.sps->ctb_width) && (
s->ps.pps->tile_id[ctb_addr_ts] ==
s->ps.pps->tile_id[
s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs-1 -
s->ps.sps->ctb_width]]));
2530 int ctb_size = 1 <<
s->ps.sps->log2_ctb_size;
2534 int ctb_addr_ts =
s->ps.pps->ctb_addr_rs_to_ts[
s->sh.slice_ctb_addr_rs];
2537 if (!ctb_addr_ts &&
s->sh.dependent_slice_segment_flag) {
2542 if (
s->sh.dependent_slice_segment_flag) {
2543 int prev_rs =
s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2544 if (
s->tab_slice_address[prev_rs] !=
s->sh.slice_addr) {
2550 while (more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2551 int ctb_addr_rs =
s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2553 x_ctb = (ctb_addr_rs % ((
s->ps.sps->width + ctb_size - 1) >>
s->ps.sps->log2_ctb_size)) <<
s->ps.sps->log2_ctb_size;
2554 y_ctb = (ctb_addr_rs / ((
s->ps.sps->width + ctb_size - 1) >>
s->ps.sps->log2_ctb_size)) <<
s->ps.sps->log2_ctb_size;
2559 s->tab_slice_address[ctb_addr_rs] = -1;
2563 hls_sao_param(lc, x_ctb >>
s->ps.sps->log2_ctb_size, y_ctb >>
s->ps.sps->log2_ctb_size);
2565 s->deblock[ctb_addr_rs].beta_offset =
s->sh.beta_offset;
2566 s->deblock[ctb_addr_rs].tc_offset =
s->sh.tc_offset;
2567 s->filter_slice_edges[ctb_addr_rs] =
s->sh.slice_loop_filter_across_slices_enabled_flag;
2570 if (more_data < 0) {
2571 s->tab_slice_address[ctb_addr_rs] = -1;
2581 if (x_ctb + ctb_size >=
s->ps.sps->width &&
2582 y_ctb + ctb_size >=
s->ps.sps->height)
2596 int job,
int self_id)
2600 int ctb_size = 1 <<
s->ps.sps->log2_ctb_size;
2603 int ctb_addr_rs =
s->sh.slice_ctb_addr_rs + ctb_row * ((
s->ps.sps->width + ctb_size - 1) >>
s->ps.sps->log2_ctb_size);
2604 int ctb_addr_ts =
s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2605 int thread = ctb_row %
s->threads_number;
2615 while(more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2616 int x_ctb = (ctb_addr_rs %
s->ps.sps->ctb_width) <<
s->ps.sps->log2_ctb_size;
2617 int y_ctb = (ctb_addr_rs /
s->ps.sps->ctb_width) <<
s->ps.sps->log2_ctb_size;
2634 hls_sao_param(lc, x_ctb >>
s->ps.sps->log2_ctb_size, y_ctb >>
s->ps.sps->log2_ctb_size);
2637 if (more_data < 0) {
2648 if (!more_data && (x_ctb+ctb_size) <
s->ps.sps->width && ctb_row !=
s->sh.num_entry_point_offsets) {
2655 if ((x_ctb+ctb_size) >=
s->ps.sps->width && (y_ctb+ctb_size) >=
s->ps.sps->height ) {
2660 ctb_addr_rs =
s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2663 if(x_ctb >=
s->ps.sps->width) {
2671 s->tab_slice_address[ctb_addr_rs] = -1;
2681 int length = nal->
size;
2685 int64_t startheader, cmpt = 0;
2688 if (
s->sh.slice_ctb_addr_rs +
s->sh.num_entry_point_offsets *
s->ps.sps->ctb_width >=
s->ps.sps->ctb_width *
s->ps.sps->ctb_height) {
2690 s->sh.slice_ctb_addr_rs,
s->sh.num_entry_point_offsets,
2691 s->ps.sps->ctb_width,
s->ps.sps->ctb_height
2696 for (
i = 1;
i <
s->threads_number;
i++) {
2697 if (
s->HEVClcList[
i])
2700 if (!
s->HEVClcList[
i])
2702 s->HEVClcList[
i]->logctx =
s->avctx;
2703 s->HEVClcList[
i]->parent =
s;
2704 s->HEVClcList[
i]->common_cabac_state = &
s->cabac;
2709 for (j = 0, cmpt = 0, startheader =
offset +
s->sh.entry_point_offset[0]; j < nal->skipped_bytes; j++) {
2716 for (
i = 1;
i <
s->sh.num_entry_point_offsets;
i++) {
2717 offset += (
s->sh.entry_point_offset[
i - 1] - cmpt);
2718 for (j = 0, cmpt = 0, startheader =
offset
2719 +
s->sh.entry_point_offset[
i]; j < nal->skipped_bytes; j++) {
2725 s->sh.size[
i - 1] =
s->sh.entry_point_offset[
i] - cmpt;
2729 if (
s->sh.num_entry_point_offsets != 0) {
2730 offset +=
s->sh.entry_point_offset[
s->sh.num_entry_point_offsets - 1] - cmpt;
2735 s->sh.size[
s->sh.num_entry_point_offsets - 1] = length -
offset;
2736 s->sh.offset[
s->sh.num_entry_point_offsets - 1] =
offset;
2741 for (
i = 1;
i <
s->threads_number;
i++) {
2742 s->HEVClcList[
i]->first_qp_group = 1;
2743 s->HEVClcList[
i]->qp_y =
s->HEVClc->qp_y;
2755 if (
s->ps.pps->entropy_coding_sync_enabled_flag)
2758 for (
i = 0;
i <=
s->sh.num_entry_point_offsets;
i++)
2773 if (
IS_IRAP(
s) &&
s->no_rasl_output_flag) {
2774 if (
s->sei.common.mastering_display.present > 0)
2775 s->sei.common.mastering_display.present--;
2777 if (
s->sei.common.content_light.present > 0)
2778 s->sei.common.content_light.present--;
2782 &
s->ps.sps->vui.common,
2783 s->ps.sps->bit_depth,
s->ps.sps->bit_depth_chroma,
2788 if (
s->sei.timecode.present) {
2793 sizeof(uint32_t) * 4, &tcside);
2798 tc_sd = (uint32_t*)tcside->
data;
2799 tc_sd[0] =
s->sei.timecode.num_clock_ts;
2801 for (
int i = 0;
i < tc_sd[0];
i++) {
2802 int drop =
s->sei.timecode.cnt_dropped_flag[
i];
2803 int hh =
s->sei.timecode.hours_value[
i];
2804 int mm =
s->sei.timecode.minutes_value[
i];
2805 int ss =
s->sei.timecode.seconds_value[
i];
2806 int ff =
s->sei.timecode.n_frames[
i];
2814 s->sei.timecode.num_clock_ts = 0;
2817 if (
s->sei.common.dynamic_hdr_plus.info) {
2838 if (
s->sei.common.dynamic_hdr_vivid.info) {
2855 int pic_size_in_ctb = ((
s->ps.sps->width >>
s->ps.sps->log2_min_cb_size) + 1) *
2856 ((
s->ps.sps->height >>
s->ps.sps->log2_min_cb_size) + 1);
2859 memset(
s->horizontal_bs, 0,
s->bs_width *
s->bs_height);
2860 memset(
s->vertical_bs, 0,
s->bs_width *
s->bs_height);
2861 memset(
s->cbf_luma, 0,
s->ps.sps->min_tb_width *
s->ps.sps->min_tb_height);
2862 memset(
s->is_pcm, 0, (
s->ps.sps->min_pu_width + 1) * (
s->ps.sps->min_pu_height + 1));
2863 memset(
s->tab_slice_address, -1, pic_size_in_ctb *
sizeof(*
s->tab_slice_address));
2866 s->first_nal_type =
s->nal_unit_type;
2870 if (
s->ps.pps->tiles_enabled_flag)
2871 lc->
end_of_tiles_x =
s->ps.pps->column_width[0] <<
s->ps.sps->log2_ctb_size;
2888 s->ref->needs_fg =
s->sei.common.film_grain_characteristics.present &&
2892 if (
s->ref->needs_fg &&
2894 s->ref->frame->format)) {
2896 "Unsupported film grain parameters. Ignoring film grain.\n");
2897 s->ref->needs_fg = 0;
2900 if (
s->ref->needs_fg) {
2901 s->ref->frame_grain->format =
s->ref->frame->format;
2902 s->ref->frame_grain->width =
s->ref->frame->width;
2903 s->ref->frame_grain->height =
s->ref->frame->height;
2912 s->frame->pict_type = 3 -
s->sh.slice_type;
2922 if (!
s->avctx->hwaccel)
2930 s->ref =
s->collocated_ref =
NULL;
2940 if (
out->needs_fg) {
2955 int ctb_addr_ts,
ret;
2958 s->nal_unit_type = nal->
type;
2961 switch (
s->nal_unit_type) {
2981 s->apply_defdispwin);
3040 if (
s->sh.first_slice_in_pic_flag) {
3041 if (
s->max_ra == INT_MAX) {
3046 s->max_ra = INT_MIN;
3051 s->poc <=
s->max_ra) {
3056 s->max_ra = INT_MIN;
3063 }
else if (!
s->ref) {
3068 if (
s->nal_unit_type !=
s->first_nal_type) {
3070 "Non-matching NAL types of the VCL NALUs: %d %d\n",
3071 s->first_nal_type,
s->nal_unit_type);
3075 if (!
s->sh.dependent_slice_segment_flag &&
3080 "Error constructing the reference lists for the current slice.\n");
3085 if (
s->sh.first_slice_in_pic_flag &&
s->avctx->hwaccel) {
3091 if (
s->avctx->hwaccel) {
3098 "SCC profile is not yet implemented in hevc native decoder.\n");
3103 if (
s->threads_number > 1 &&
s->sh.num_entry_point_offsets > 0)
3107 if (ctb_addr_ts >= (
s->ps.sps->ctb_width *
s->ps.sps->ctb_height)) {
3114 if (ctb_addr_ts < 0) {
3123 s->max_ra = INT_MAX;
3131 "Skipping NAL unit %d\n",
s->nal_unit_type);
3144 int eos_at_start = 1;
3146 s->ref =
s->collocated_ref =
NULL;
3147 s->last_eos =
s->eos;
3154 s->nal_length_size,
s->avctx->codec_id, 1, 0);
3157 "Error splitting the input into NAL units.\n");
3161 for (
i = 0;
i <
s->pkt.nb_nals;
i++) {
3183 s->pkt.nals[
s->pkt.nb_nals - 1].size > 2 && !
s->pkt.nals[
s->pkt.nb_nals - 1].nuh_layer_id
3184 && !
s->pkt.nals[
s->pkt.nb_nals - 1].temporal_id) {
3185 H2645NAL *nal = &
s->pkt.nals[
s->pkt.nb_nals - 1];
3188 av_log(
s->avctx,
AV_LOG_WARNING,
"Multiple Dolby Vision RPUs found in one AU. Skipping previous.\n");
3205 for (
i = 0;
i <
s->pkt.nb_nals;
i++) {
3214 if (
ret >= 0 &&
s->overlap > 2)
3218 "Error parsing NAL unit #%d.\n",
i);
3233 char msg_buf[4 * (50 + 2 * 2 * 16 )];
3241 pixel_shift =
desc->comp[0].depth > 8;
3246 if (pixel_shift && !
s->checksum_buf) {
3250 if (!
s->checksum_buf)
3257 int width =
s->avctx->coded_width;
3258 int height =
s->avctx->coded_height;
3264 for (j = 0; j <
h; j++) {
3268 s->bdsp.bswap16_buf((uint16_t *)
s->checksum_buf,
3269 (
const uint16_t *)
src,
w);
3270 src =
s->checksum_buf;
3277 #define MD5_PRI "%016" PRIx64 "%016" PRIx64
3278 #define MD5_PRI_ARG(buf) AV_RB64(buf), AV_RB64((const uint8_t*)(buf) + 8)
3280 if (!memcmp(
md5,
s->sei.picture_hash.md5[
i], 16)) {
3282 "plane %d - correct " MD5_PRI "; ",
3286 "mismatching checksum of plane %d - " MD5_PRI " != " MD5_PRI "; ",
3293 "Verifying checksum for frame with POC %d: %s\n",
3304 &
s->nal_length_size,
s->avctx->err_recognition,
3305 s->apply_defdispwin,
s->avctx);
3311 if (
first &&
s->ps.sps_list[
i]) {
3344 if (sd && sd_size > 0) {
3351 if (sd && sd_size > 0) {
3352 int old =
s->dovi_ctx.dv_profile;
3357 "New DOVI configuration record from input packet (profile %d -> %u).\n",
3358 old,
s->dovi_ctx.dv_profile);
3361 s->ref =
s->collocated_ref =
NULL;
3369 "hardware accelerator failed to decode picture\n");
3376 s->sei.picture_hash.is_md5) {
3384 s->sei.picture_hash.is_md5 = 0;
3386 if (
s->is_decoded) {
3391 if (
s->output_frame->buf[0]) {
3407 if (
src->needs_fg) {
3425 src->hwaccel_picture_private);
3442 for (
i = 0;
i < 3;
i++) {
3460 if (
s->HEVClcList) {
3461 for (
i = 1;
i <
s->threads_number;
i++) {
3484 if (!
s->HEVClc || !
s->HEVClcList)
3486 s->HEVClc->parent =
s;
3487 s->HEVClc->logctx = avctx;
3488 s->HEVClc->common_cabac_state = &
s->cabac;
3489 s->HEVClcList[0] =
s->HEVClc;
3492 if (!
s->output_frame)
3497 if (!
s->DPB[
i].frame)
3499 s->DPB[
i].tf.f =
s->DPB[
i].frame;
3502 if (!
s->DPB[
i].frame_grain)
3506 s->max_ra = INT_MAX;
3514 s->dovi_ctx.logctx = avctx;
3532 if (
s0->DPB[
i].frame->buf[0]) {
3539 if (
s->ps.sps !=
s0->ps.sps)
3550 if (
s->ps.sps !=
s0->ps.sps)
3554 s->seq_decode =
s0->seq_decode;
3555 s->seq_output =
s0->seq_output;
3556 s->pocTid0 =
s0->pocTid0;
3557 s->max_ra =
s0->max_ra;
3559 s->no_rasl_output_flag =
s0->no_rasl_output_flag;
3561 s->is_nalff =
s0->is_nalff;
3562 s->nal_length_size =
s0->nal_length_size;
3564 s->threads_number =
s0->threads_number;
3565 s->threads_type =
s0->threads_type;
3567 s->film_grain_warning_shown =
s0->film_grain_warning_shown;
3571 s->max_ra = INT_MAX;
3579 s0->sei.common.dynamic_hdr_plus.info);
3590 s0->sei.common.dynamic_hdr_vivid.info);
3594 s->sei.common.frame_packing =
s0->sei.common.frame_packing;
3595 s->sei.common.display_orientation =
s0->sei.common.display_orientation;
3596 s->sei.common.alternative_transfer =
s0->sei.common.alternative_transfer;
3597 s->sei.common.mastering_display =
s0->sei.common.mastering_display;
3598 s->sei.common.content_light =
s0->sei.common.content_light;
3619 s->threads_number = 1;
3630 s->enable_parallel_tiles = 0;
3631 s->sei.picture_timing.picture_struct = 0;
3647 if (sd && sd->
size > 0)
3661 s->max_ra = INT_MAX;
3668 #define OFFSET(x) offsetof(HEVCContext, x)
3669 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3672 {
"apply_defdispwin",
"Apply default display window from VUI",
OFFSET(apply_defdispwin),
3674 {
"strict-displaywin",
"stricly apply default display window size",
OFFSET(apply_defdispwin),
3704 #if CONFIG_HEVC_DXVA2_HWACCEL
3707 #if CONFIG_HEVC_D3D11VA_HWACCEL
3710 #if CONFIG_HEVC_D3D11VA2_HWACCEL
3713 #if CONFIG_HEVC_D3D12VA_HWACCEL
3716 #if CONFIG_HEVC_NVDEC_HWACCEL
3719 #if CONFIG_HEVC_VAAPI_HWACCEL
3722 #if CONFIG_HEVC_VDPAU_HWACCEL
3725 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
3728 #if CONFIG_HEVC_VULKAN_HWACCEL