26 #include "config_components.h"
55 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 };
97 int log2_min_cb_size =
sps->log2_min_cb_size;
100 int pic_size_in_ctb = ((
width >> log2_min_cb_size) + 1) *
101 ((
height >> log2_min_cb_size) + 1);
102 int ctb_count =
sps->ctb_width *
sps->ctb_height;
103 int min_pu_size =
sps->min_pu_width *
sps->min_pu_height;
105 s->bs_width = (
width >> 2) + 1;
106 s->bs_height = (
height >> 2) + 1;
109 s->deblock =
av_calloc(ctb_count,
sizeof(*
s->deblock));
110 if (!
s->sao || !
s->deblock)
115 if (!
s->skip_flag || !
s->tab_ct_depth)
121 if (!
s->tab_ipm || !
s->cbf_luma || !
s->is_pcm)
126 sizeof(*
s->tab_slice_address));
128 sizeof(*
s->qp_y_tab));
129 if (!
s->qp_y_tab || !
s->filter_slice_edges || !
s->tab_slice_address)
132 s->horizontal_bs =
av_calloc(
s->bs_width,
s->bs_height);
134 if (!
s->horizontal_bs || !
s->vertical_bs)
139 if (!
s->tab_mvf_pool || !
s->rpl_tab_pool)
153 uint8_t luma_weight_l0_flag[16];
154 uint8_t chroma_weight_l0_flag[16];
155 uint8_t luma_weight_l1_flag[16];
156 uint8_t chroma_weight_l1_flag[16];
157 int luma_log2_weight_denom;
160 if (luma_log2_weight_denom < 0 || luma_log2_weight_denom > 7) {
161 av_log(
s->avctx,
AV_LOG_ERROR,
"luma_log2_weight_denom %d is invalid\n", luma_log2_weight_denom);
164 s->sh.luma_log2_weight_denom =
av_clip_uintp2(luma_log2_weight_denom, 3);
165 if (
s->ps.sps->chroma_format_idc != 0) {
166 int64_t chroma_log2_weight_denom = luma_log2_weight_denom + (int64_t)
get_se_golomb(gb);
167 if (chroma_log2_weight_denom < 0 || chroma_log2_weight_denom > 7) {
168 av_log(
s->avctx,
AV_LOG_ERROR,
"chroma_log2_weight_denom %"PRId64
" is invalid\n", chroma_log2_weight_denom);
171 s->sh.chroma_log2_weight_denom = chroma_log2_weight_denom;
174 for (
i = 0;
i <
s->sh.nb_refs[
L0];
i++) {
176 if (!luma_weight_l0_flag[
i]) {
177 s->sh.luma_weight_l0[
i] = 1 <<
s->sh.luma_log2_weight_denom;
178 s->sh.luma_offset_l0[
i] = 0;
181 if (
s->ps.sps->chroma_format_idc != 0) {
182 for (
i = 0;
i <
s->sh.nb_refs[
L0];
i++)
185 for (
i = 0;
i <
s->sh.nb_refs[
L0];
i++)
186 chroma_weight_l0_flag[
i] = 0;
188 for (
i = 0;
i <
s->sh.nb_refs[
L0];
i++) {
189 if (luma_weight_l0_flag[
i]) {
191 if ((int8_t)delta_luma_weight_l0 != delta_luma_weight_l0)
193 s->sh.luma_weight_l0[
i] = (1 <<
s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;
196 if (chroma_weight_l0_flag[
i]) {
197 for (j = 0; j < 2; j++) {
201 if ( (int8_t)delta_chroma_weight_l0 != delta_chroma_weight_l0
202 || delta_chroma_offset_l0 < -(1<<17) || delta_chroma_offset_l0 > (1<<17)) {
206 s->sh.chroma_weight_l0[
i][j] = (1 <<
s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
207 s->sh.chroma_offset_l0[
i][j] =
av_clip((delta_chroma_offset_l0 - ((128 *
s->sh.chroma_weight_l0[
i][j])
208 >>
s->sh.chroma_log2_weight_denom) + 128), -128, 127);
211 s->sh.chroma_weight_l0[
i][0] = 1 <<
s->sh.chroma_log2_weight_denom;
212 s->sh.chroma_offset_l0[
i][0] = 0;
213 s->sh.chroma_weight_l0[
i][1] = 1 <<
s->sh.chroma_log2_weight_denom;
214 s->sh.chroma_offset_l0[
i][1] = 0;
218 for (
i = 0;
i <
s->sh.nb_refs[
L1];
i++) {
220 if (!luma_weight_l1_flag[
i]) {
221 s->sh.luma_weight_l1[
i] = 1 <<
s->sh.luma_log2_weight_denom;
222 s->sh.luma_offset_l1[
i] = 0;
225 if (
s->ps.sps->chroma_format_idc != 0) {
226 for (
i = 0;
i <
s->sh.nb_refs[
L1];
i++)
229 for (
i = 0;
i <
s->sh.nb_refs[
L1];
i++)
230 chroma_weight_l1_flag[
i] = 0;
232 for (
i = 0;
i <
s->sh.nb_refs[
L1];
i++) {
233 if (luma_weight_l1_flag[
i]) {
235 if ((int8_t)delta_luma_weight_l1 != delta_luma_weight_l1)
237 s->sh.luma_weight_l1[
i] = (1 <<
s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;
240 if (chroma_weight_l1_flag[
i]) {
241 for (j = 0; j < 2; j++) {
245 if ( (int8_t)delta_chroma_weight_l1 != delta_chroma_weight_l1
246 || delta_chroma_offset_l1 < -(1<<17) || delta_chroma_offset_l1 > (1<<17)) {
250 s->sh.chroma_weight_l1[
i][j] = (1 <<
s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
251 s->sh.chroma_offset_l1[
i][j] =
av_clip((delta_chroma_offset_l1 - ((128 *
s->sh.chroma_weight_l1[
i][j])
252 >>
s->sh.chroma_log2_weight_denom) + 128), -128, 127);
255 s->sh.chroma_weight_l1[
i][0] = 1 <<
s->sh.chroma_log2_weight_denom;
256 s->sh.chroma_offset_l1[
i][0] = 0;
257 s->sh.chroma_weight_l1[
i][1] = 1 <<
s->sh.chroma_log2_weight_denom;
258 s->sh.chroma_offset_l1[
i][1] = 0;
268 int max_poc_lsb = 1 <<
sps->log2_max_poc_lsb;
269 int prev_delta_msb = 0;
270 unsigned int nb_sps = 0, nb_sh;
274 if (!
sps->long_term_ref_pics_present_flag)
277 if (
sps->num_long_term_ref_pics_sps > 0)
281 if (nb_sps >
sps->num_long_term_ref_pics_sps)
291 uint8_t lt_idx_sps = 0;
293 if (
sps->num_long_term_ref_pics_sps > 1)
296 rps->
poc[
i] =
sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
297 rps->
used[
i] =
sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];
308 if (
i &&
i != nb_sps)
309 delta += prev_delta_msb;
311 poc = rps->
poc[
i] +
s->poc -
delta * max_poc_lsb -
s->sh.pic_order_cnt_lsb;
315 prev_delta_msb =
delta;
328 unsigned int num = 0, den = 0;
336 avctx->
profile =
sps->ptl.general_ptl.profile_idc;
337 avctx->
level =
sps->ptl.general_ptl.level_idc;
341 if (
sps->vui.common.video_signal_type_present_flag)
347 if (
sps->vui.common.colour_description_present_flag) {
349 avctx->
color_trc =
sps->vui.common.transfer_characteristics;
358 if (
sps->chroma_format_idc == 1) {
359 if (
sps->vui.common.chroma_loc_info_present_flag) {
360 if (
sps->vui.common.chroma_sample_loc_type_top_field <= 5)
366 if (
vps->vps_timing_info_present_flag) {
367 num =
vps->vps_num_units_in_tick;
368 den =
vps->vps_time_scale;
369 }
else if (
sps->vui.vui_timing_info_present_flag) {
370 num =
sps->vui.vui_num_units_in_tick;
371 den =
sps->vui.vui_time_scale;
374 if (num != 0 && den != 0)
383 if (
s->sei.common.a53_caption.buf_ref)
386 if (
s->sei.common.alternative_transfer.present &&
389 avctx->
color_trc =
s->sei.common.alternative_transfer.preferred_transfer_characteristics;
392 if (
s->sei.common.film_grain_characteristics.present ||
393 s->sei.common.aom_film_grain.enable)
401 #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + \
402 CONFIG_HEVC_D3D11VA_HWACCEL * 2 + \
403 CONFIG_HEVC_D3D12VA_HWACCEL + \
404 CONFIG_HEVC_NVDEC_HWACCEL + \
405 CONFIG_HEVC_VAAPI_HWACCEL + \
406 CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL + \
407 CONFIG_HEVC_VDPAU_HWACCEL + \
408 CONFIG_HEVC_VULKAN_HWACCEL)
411 switch (
sps->pix_fmt) {
414 #if CONFIG_HEVC_DXVA2_HWACCEL
417 #if CONFIG_HEVC_D3D11VA_HWACCEL
421 #if CONFIG_HEVC_D3D12VA_HWACCEL
424 #if CONFIG_HEVC_VAAPI_HWACCEL
427 #if CONFIG_HEVC_VDPAU_HWACCEL
430 #if CONFIG_HEVC_NVDEC_HWACCEL
433 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
436 #if CONFIG_HEVC_VULKAN_HWACCEL
441 #if CONFIG_HEVC_DXVA2_HWACCEL
444 #if CONFIG_HEVC_D3D11VA_HWACCEL
448 #if CONFIG_HEVC_D3D12VA_HWACCEL
451 #if CONFIG_HEVC_VAAPI_HWACCEL
454 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
457 #if CONFIG_HEVC_VULKAN_HWACCEL
460 #if CONFIG_HEVC_VDPAU_HWACCEL
463 #if CONFIG_HEVC_NVDEC_HWACCEL
468 #if CONFIG_HEVC_VAAPI_HWACCEL
471 #if CONFIG_HEVC_VDPAU_HWACCEL
474 #if CONFIG_HEVC_NVDEC_HWACCEL
477 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
480 #if CONFIG_HEVC_VULKAN_HWACCEL
486 #if CONFIG_HEVC_VAAPI_HWACCEL
489 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
492 #if CONFIG_HEVC_VULKAN_HWACCEL
497 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
503 #if CONFIG_HEVC_VAAPI_HWACCEL
506 #if CONFIG_HEVC_VDPAU_HWACCEL
509 #if CONFIG_HEVC_VULKAN_HWACCEL
512 #if CONFIG_HEVC_NVDEC_HWACCEL
517 #if CONFIG_HEVC_VAAPI_HWACCEL
520 #if CONFIG_HEVC_VULKAN_HWACCEL
526 *fmt++ =
sps->pix_fmt;
556 for (
i = 0;
i < 3;
i++) {
561 if (
sps->sao_enabled && !
s->avctx->hwaccel) {
562 int c_count = (
sps->chroma_format_idc != 0) ? 3 : 1;
565 for(c_idx = 0; c_idx < c_count; c_idx++) {
566 int w =
sps->width >>
sps->hshift[c_idx];
567 int h =
sps->height >>
sps->vshift[c_idx];
568 s->sao_pixel_buffer_h[c_idx] =
571 s->sao_pixel_buffer_v[c_idx] =
574 if (!
s->sao_pixel_buffer_h[c_idx] ||
575 !
s->sao_pixel_buffer_v[c_idx])
581 s->ps.vps =
s->ps.vps_list[
s->ps.sps->vps_id];
587 for (
i = 0;
i < 3;
i++) {
604 av_log(
s->avctx,
AV_LOG_ERROR,
"Two slices reporting being the first in the same frame.\n");
624 s->ps.pps !=
s->ps.pps_list[sh->
pps_id]) {
628 s->ps.pps =
s->ps.pps_list[sh->
pps_id];
632 if (
s->ps.sps !=
s->ps.sps_list[
s->ps.pps->sps_id]) {
657 int slice_address_length;
659 if (
s->ps.pps->dependent_slice_segments_enabled_flag)
663 s->ps.sps->ctb_height);
667 "Invalid slice segment address: %u.\n",
679 s->slice_initialized = 0;
683 s->slice_initialized = 0;
685 for (
i = 0;
i <
s->ps.pps->num_extra_slice_header_bits;
i++)
697 !
s->ps.pps->pps_curr_pic_ref_enabled_flag) {
704 if (
s->ps.pps->output_flag_present_flag)
707 if (
s->ps.sps->separate_colour_plane_flag)
717 "Ignoring POC change between slices: %d -> %d\n",
s->poc, poc);
733 int numbits, rps_idx;
735 if (!
s->ps.sps->nb_st_rps) {
741 rps_idx = numbits > 0 ?
get_bits(gb, numbits) : 0;
755 if (
s->ps.sps->sps_temporal_mvp_enabled_flag)
780 if (
s->ps.sps->sao_enabled) {
782 if (
s->ps.sps->chroma_format_idc) {
796 sh->
nb_refs[
L0] =
s->ps.pps->num_ref_idx_l0_default_active;
798 sh->
nb_refs[
L1] =
s->ps.pps->num_ref_idx_l1_default_active;
819 if (
s->ps.pps->lists_modification_present_flag && nb_refs > 1) {
837 if (
s->ps.pps->cabac_init_present_flag)
852 "Invalid collocated_ref_idx: %d.\n",
869 "Invalid number of merging MVP candidates: %d.\n",
875 if (
s->ps.sps->motion_vector_resolution_control_idc == 2)
885 if (
s->ps.pps->pic_slice_level_chroma_qp_offsets_present_flag) {
898 if (
s->ps.pps->pps_slice_act_qp_offsets_present_flag) {
904 if (
s->ps.pps->chroma_qp_offset_list_enabled_flag)
909 if (
s->ps.pps->deblocking_filter_control_present_flag) {
910 int deblocking_filter_override_flag = 0;
912 if (
s->ps.pps->deblocking_filter_override_enabled_flag)
913 deblocking_filter_override_flag =
get_bits1(gb);
915 if (deblocking_filter_override_flag) {
920 if (beta_offset_div2 < -6 || beta_offset_div2 > 6 ||
921 tc_offset_div2 < -6 || tc_offset_div2 > 6) {
923 "Invalid deblock filter offsets: %d, %d\n",
924 beta_offset_div2, tc_offset_div2);
941 if (
s->ps.pps->seq_loop_filter_across_slices_enabled_flag &&
949 }
else if (!
s->slice_initialized) {
955 if (
s->ps.pps->tiles_enabled_flag ||
s->ps.pps->entropy_coding_sync_enabled_flag) {
959 av_log(
s->avctx,
AV_LOG_ERROR,
"num_entry_point_offsets %d is invalid\n", num_entry_point_offsets);
967 if (offset_len < 1 || offset_len > 32) {
988 if (
s->threads_number > 1 && (
s->ps.pps->num_tile_rows > 1 ||
s->ps.pps->num_tile_columns > 1)) {
989 s->enable_parallel_tiles = 0;
990 s->threads_number = 1;
992 s->enable_parallel_tiles = 0;
994 s->enable_parallel_tiles = 0;
997 if (
s->ps.pps->slice_header_extension_present_flag) {
1003 for (
i = 0;
i < length;
i++)
1010 sh->
slice_qp < -
s->ps.sps->qp_bd_offset) {
1012 "The slice_qp %d is outside the valid range "
1015 -
s->ps.sps->qp_bd_offset);
1021 if (!
s->sh.slice_ctb_addr_rs &&
s->sh.dependent_slice_segment_flag) {
1032 s->HEVClc->first_qp_group = !
s->sh.dependent_slice_segment_flag;
1034 if (!
s->ps.pps->cu_qp_delta_enabled_flag)
1035 s->HEVClc->qp_y =
s->sh.slice_qp;
1037 s->slice_initialized = 1;
1038 s->HEVClc->tu.cu_qp_offset_cb = 0;
1039 s->HEVClc->tu.cu_qp_offset_cr = 0;
1044 #define CTB(tab, x, y) ((tab)[(y) * s->ps.sps->ctb_width + (x)])
1046 #define SET_SAO(elem, value) \
1048 if (!sao_merge_up_flag && !sao_merge_left_flag) \
1049 sao->elem = value; \
1050 else if (sao_merge_left_flag) \
1051 sao->elem = CTB(s->sao, rx-1, ry).elem; \
1052 else if (sao_merge_up_flag) \
1053 sao->elem = CTB(s->sao, rx, ry-1).elem; \
1061 int sao_merge_left_flag = 0;
1062 int sao_merge_up_flag = 0;
1066 if (
s->sh.slice_sample_adaptive_offset_flag[0] ||
1067 s->sh.slice_sample_adaptive_offset_flag[1]) {
1072 if (ry > 0 && !sao_merge_left_flag) {
1078 for (c_idx = 0; c_idx < (
s->ps.sps->chroma_format_idc ? 3 : 1); c_idx++) {
1079 int log2_sao_offset_scale = c_idx == 0 ?
s->ps.pps->log2_sao_offset_scale_luma :
1080 s->ps.pps->log2_sao_offset_scale_chroma;
1082 if (!
s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
1097 for (
i = 0;
i < 4;
i++)
1101 for (
i = 0;
i < 4;
i++) {
1110 }
else if (c_idx != 2) {
1116 for (
i = 0;
i < 4;
i++) {
1124 sao->
offset_val[c_idx][
i + 1] *= 1 << log2_sao_offset_scale;
1136 if (log2_res_scale_abs_plus1 != 0) {
1139 (1 - 2 * res_scale_sign_flag);
1149 int xBase,
int yBase,
int cb_xBase,
int cb_yBase,
1150 int log2_cb_size,
int log2_trafo_size,
1151 int blk_idx,
int cbf_luma,
int *cbf_cb,
int *cbf_cr)
1154 const int log2_trafo_size_c = log2_trafo_size -
s->ps.sps->hshift[1];
1158 int trafo_size = 1 << log2_trafo_size;
1161 s->hpc.intra_pred[log2_trafo_size - 2](lc, x0, y0, 0);
1164 if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
1165 (
s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1168 int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
1169 (
s->ps.sps->chroma_format_idc == 2 &&
1170 (cbf_cb[1] || cbf_cr[1]));
1182 "The cu_qp_delta %d is outside the valid range "
1185 -(26 +
s->ps.sps->qp_bd_offset / 2),
1186 (25 +
s->ps.sps->qp_bd_offset / 2));
1193 if (
s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
1196 if (cu_chroma_qp_offset_flag) {
1197 int cu_chroma_qp_offset_idx = 0;
1198 if (
s->ps.pps->chroma_qp_offset_list_len_minus1 > 0) {
1201 "cu_chroma_qp_offset_idx not yet tested.\n");
1234 if (
s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 ||
s->ps.sps->chroma_format_idc == 3)) {
1235 int trafo_size_h = 1 << (log2_trafo_size_c +
s->ps.sps->hshift[1]);
1236 int trafo_size_v = 1 << (log2_trafo_size_c +
s->ps.sps->vshift[1]);
1237 lc->
tu.
cross_pf = (
s->ps.pps->cross_component_prediction_enabled_flag && cbf_luma &&
1244 for (
i = 0;
i < (
s->ps.sps->chroma_format_idc == 2 ? 2 : 1);
i++) {
1247 s->hpc.intra_pred[log2_trafo_size_c - 2](lc, x0, y0 + (
i << log2_trafo_size_c), 1);
1251 log2_trafo_size_c, scan_idx_c, 1);
1254 ptrdiff_t
stride =
s->frame->linesize[1];
1255 int hshift =
s->ps.sps->hshift[1];
1256 int vshift =
s->ps.sps->vshift[1];
1259 int size = 1 << log2_trafo_size_c;
1261 uint8_t *dst = &
s->frame->data[1][(y0 >> vshift) *
stride +
1262 ((x0 >> hshift) <<
s->ps.sps->pixel_shift)];
1266 s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs,
stride);
1273 for (
i = 0;
i < (
s->ps.sps->chroma_format_idc == 2 ? 2 : 1);
i++) {
1276 trafo_size_h, trafo_size_v);
1277 s->hpc.intra_pred[log2_trafo_size_c - 2](lc, x0, y0 + (
i << log2_trafo_size_c), 2);
1281 log2_trafo_size_c, scan_idx_c, 2);
1284 ptrdiff_t
stride =
s->frame->linesize[2];
1285 int hshift =
s->ps.sps->hshift[2];
1286 int vshift =
s->ps.sps->vshift[2];
1289 int size = 1 << log2_trafo_size_c;
1291 uint8_t *dst = &
s->frame->data[2][(y0 >> vshift) *
stride +
1292 ((x0 >> hshift) <<
s->ps.sps->pixel_shift)];
1296 s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs,
stride);
1299 }
else if (
s->ps.sps->chroma_format_idc && blk_idx == 3) {
1300 int trafo_size_h = 1 << (log2_trafo_size + 1);
1301 int trafo_size_v = 1 << (log2_trafo_size +
s->ps.sps->vshift[1]);
1302 for (
i = 0;
i < (
s->ps.sps->chroma_format_idc == 2 ? 2 : 1);
i++) {
1305 trafo_size_h, trafo_size_v);
1306 s->hpc.intra_pred[log2_trafo_size - 2](lc, xBase, yBase + (
i << log2_trafo_size), 1);
1310 log2_trafo_size, scan_idx_c, 1);
1312 for (
i = 0;
i < (
s->ps.sps->chroma_format_idc == 2 ? 2 : 1);
i++) {
1315 trafo_size_h, trafo_size_v);
1316 s->hpc.intra_pred[log2_trafo_size - 2](lc, xBase, yBase + (
i << log2_trafo_size), 2);
1320 log2_trafo_size, scan_idx_c, 2);
1324 if (log2_trafo_size > 2 ||
s->ps.sps->chroma_format_idc == 3) {
1325 int trafo_size_h = 1 << (log2_trafo_size_c +
s->ps.sps->hshift[1]);
1326 int trafo_size_v = 1 << (log2_trafo_size_c +
s->ps.sps->vshift[1]);
1328 s->hpc.intra_pred[log2_trafo_size_c - 2](lc, x0, y0, 1);
1329 s->hpc.intra_pred[log2_trafo_size_c - 2](lc, x0, y0, 2);
1330 if (
s->ps.sps->chroma_format_idc == 2) {
1332 trafo_size_h, trafo_size_v);
1333 s->hpc.intra_pred[log2_trafo_size_c - 2](lc, x0, y0 + (1 << log2_trafo_size_c), 1);
1334 s->hpc.intra_pred[log2_trafo_size_c - 2](lc, x0, y0 + (1 << log2_trafo_size_c), 2);
1336 }
else if (blk_idx == 3) {
1337 int trafo_size_h = 1 << (log2_trafo_size + 1);
1338 int trafo_size_v = 1 << (log2_trafo_size +
s->ps.sps->vshift[1]);
1340 trafo_size_h, trafo_size_v);
1341 s->hpc.intra_pred[log2_trafo_size - 2](lc, xBase, yBase, 1);
1342 s->hpc.intra_pred[log2_trafo_size - 2](lc, xBase, yBase, 2);
1343 if (
s->ps.sps->chroma_format_idc == 2) {
1345 trafo_size_h, trafo_size_v);
1346 s->hpc.intra_pred[log2_trafo_size - 2](lc, xBase, yBase + (1 << log2_trafo_size), 1);
1347 s->hpc.intra_pred[log2_trafo_size - 2](lc, xBase, yBase + (1 << log2_trafo_size), 2);
1357 int cb_size = 1 << log2_cb_size;
1358 int log2_min_pu_size =
s->ps.sps->log2_min_pu_size;
1360 int min_pu_width =
s->ps.sps->min_pu_width;
1361 int x_end =
FFMIN(x0 + cb_size,
s->ps.sps->width);
1362 int y_end =
FFMIN(y0 + cb_size,
s->ps.sps->height);
1365 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1366 for (
i = (x0 >> log2_min_pu_size);
i < (x_end >> log2_min_pu_size);
i++)
1367 s->is_pcm[
i + j * min_pu_width] = 2;
1371 int xBase,
int yBase,
int cb_xBase,
int cb_yBase,
1372 int log2_cb_size,
int log2_trafo_size,
1373 int trafo_depth,
int blk_idx,
1374 const int *base_cbf_cb,
const int *base_cbf_cr)
1377 uint8_t split_transform_flag;
1382 cbf_cb[0] = base_cbf_cb[0];
1383 cbf_cb[1] = base_cbf_cb[1];
1384 cbf_cr[0] = base_cbf_cr[0];
1385 cbf_cr[1] = base_cbf_cr[1];
1388 if (trafo_depth == 1) {
1390 if (
s->ps.sps->chroma_format_idc == 3) {
1404 if (log2_trafo_size <= s->ps.sps->log2_max_trafo_size &&
1405 log2_trafo_size >
s->ps.sps->log2_min_tb_size &&
1406 trafo_depth < lc->cu.max_trafo_depth &&
1410 int inter_split =
s->ps.sps->max_transform_hierarchy_depth_inter == 0 &&
1415 split_transform_flag = log2_trafo_size >
s->ps.sps->log2_max_trafo_size ||
1420 if (
s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 ||
s->ps.sps->chroma_format_idc == 3)) {
1421 if (trafo_depth == 0 || cbf_cb[0]) {
1423 if (
s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1428 if (trafo_depth == 0 || cbf_cr[0]) {
1430 if (
s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1436 if (split_transform_flag) {
1437 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1438 const int x1 = x0 + trafo_size_split;
1439 const int y1 = y0 + trafo_size_split;
1441 #define SUBDIVIDE(x, y, idx) \
1443 ret = hls_transform_tree(lc, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size,\
1444 log2_trafo_size - 1, trafo_depth + 1, idx, \
1457 int min_tu_size = 1 <<
s->ps.sps->log2_min_tb_size;
1458 int log2_min_tu_size =
s->ps.sps->log2_min_tb_size;
1459 int min_tu_width =
s->ps.sps->min_tb_width;
1463 cbf_cb[0] || cbf_cr[0] ||
1464 (
s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1469 log2_cb_size, log2_trafo_size,
1470 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1476 for (
i = 0;
i < (1 << log2_trafo_size);
i += min_tu_size)
1477 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1478 int x_tu = (x0 + j) >> log2_min_tu_size;
1479 int y_tu = (y0 +
i) >> log2_min_tu_size;
1480 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1483 if (!
s->sh.disable_deblocking_filter_flag) {
1485 if (
s->ps.pps->transquant_bypass_enable_flag &&
1497 int cb_size = 1 << log2_cb_size;
1498 ptrdiff_t stride0 =
s->frame->linesize[0];
1499 ptrdiff_t stride1 =
s->frame->linesize[1];
1500 ptrdiff_t stride2 =
s->frame->linesize[2];
1501 uint8_t *dst0 = &
s->frame->data[0][y0 * stride0 + (x0 <<
s->ps.sps->pixel_shift)];
1502 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)];
1503 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)];
1505 int length = cb_size * cb_size *
s->ps.sps->pcm.bit_depth +
1506 (((cb_size >>
s->ps.sps->hshift[1]) * (cb_size >>
s->ps.sps->vshift[1])) +
1507 ((cb_size >>
s->ps.sps->hshift[2]) * (cb_size >>
s->ps.sps->vshift[2]))) *
1508 s->ps.sps->pcm.bit_depth_chroma;
1509 const uint8_t *pcm =
skip_bytes(&lc->
cc, (length + 7) >> 3);
1512 if (!
s->sh.disable_deblocking_filter_flag)
1519 s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size, &gb,
s->ps.sps->pcm.bit_depth);
1520 if (
s->ps.sps->chroma_format_idc) {
1521 s->hevcdsp.put_pcm(dst1, stride1,
1522 cb_size >>
s->ps.sps->hshift[1],
1523 cb_size >>
s->ps.sps->vshift[1],
1524 &gb,
s->ps.sps->pcm.bit_depth_chroma);
1525 s->hevcdsp.put_pcm(dst2, stride2,
1526 cb_size >>
s->ps.sps->hshift[2],
1527 cb_size >>
s->ps.sps->vshift[2],
1528 &gb,
s->ps.sps->pcm.bit_depth_chroma);
1552 int block_w,
int block_h,
int luma_weight,
int luma_offset)
1555 const uint8_t *
src =
ref->data[0];
1556 ptrdiff_t srcstride =
ref->linesize[0];
1557 int pic_width =
s->ps.sps->width;
1558 int pic_height =
s->ps.sps->height;
1561 int weight_flag = (
s->sh.slice_type ==
HEVC_SLICE_P &&
s->ps.pps->weighted_pred_flag) ||
1562 (
s->sh.slice_type ==
HEVC_SLICE_B &&
s->ps.pps->weighted_bipred_flag);
1565 x_off +=
mv->x >> 2;
1566 y_off +=
mv->y >> 2;
1567 src += y_off * srcstride + (x_off * (1 <<
s->ps.sps->pixel_shift));
1578 edge_emu_stride, srcstride,
1582 pic_width, pic_height);
1584 srcstride = edge_emu_stride;
1588 s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride,
src, srcstride,
1589 block_h, mx, my, block_w);
1591 s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride,
src, srcstride,
1592 block_h,
s->sh.luma_log2_weight_denom,
1593 luma_weight, luma_offset, mx, my, block_w);
1613 const AVFrame *ref0,
const Mv *mv0,
int x_off,
int y_off,
1614 int block_w,
int block_h,
const AVFrame *ref1,
1615 const Mv *mv1,
struct MvField *current_mv)
1618 ptrdiff_t src0stride = ref0->
linesize[0];
1619 ptrdiff_t src1stride = ref1->
linesize[0];
1620 int pic_width =
s->ps.sps->width;
1621 int pic_height =
s->ps.sps->height;
1622 int mx0 = mv0->
x & 3;
1623 int my0 = mv0->
y & 3;
1624 int mx1 = mv1->
x & 3;
1625 int my1 = mv1->
y & 3;
1626 int weight_flag = (
s->sh.slice_type ==
HEVC_SLICE_P &&
s->ps.pps->weighted_pred_flag) ||
1627 (
s->sh.slice_type ==
HEVC_SLICE_B &&
s->ps.pps->weighted_bipred_flag);
1628 int x_off0 = x_off + (mv0->
x >> 2);
1629 int y_off0 = y_off + (mv0->
y >> 2);
1630 int x_off1 = x_off + (mv1->
x >> 2);
1631 int y_off1 = y_off + (mv1->
y >> 2);
1634 const uint8_t *
src0 = ref0->
data[0] + y_off0 * src0stride + (
int)((
unsigned)x_off0 <<
s->ps.sps->pixel_shift);
1635 const uint8_t *
src1 = ref1->
data[0] + y_off1 * src1stride + (
int)((
unsigned)x_off1 <<
s->ps.sps->pixel_shift);
1645 edge_emu_stride, src0stride,
1649 pic_width, pic_height);
1651 src0stride = edge_emu_stride;
1662 edge_emu_stride, src1stride,
1666 pic_width, pic_height);
1668 src1stride = edge_emu_stride;
1671 s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](lc->
tmp,
src0, src0stride,
1672 block_h, mx0, my0, block_w);
1674 s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride,
src1, src1stride, lc->
tmp,
1675 block_h, mx1, my1, block_w);
1677 s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride,
src1, src1stride, lc->
tmp,
1678 block_h,
s->sh.luma_log2_weight_denom,
1679 s->sh.luma_weight_l0[current_mv->
ref_idx[0]],
1680 s->sh.luma_weight_l1[current_mv->
ref_idx[1]],
1681 s->sh.luma_offset_l0[current_mv->
ref_idx[0]],
1682 s->sh.luma_offset_l1[current_mv->
ref_idx[1]],
1705 ptrdiff_t dststride,
const uint8_t *
src0, ptrdiff_t srcstride,
int reflist,
1706 int x_off,
int y_off,
int block_w,
int block_h,
1707 const struct MvField *current_mv,
int chroma_weight,
int chroma_offset)
1710 int pic_width =
s->ps.sps->width >>
s->ps.sps->hshift[1];
1711 int pic_height =
s->ps.sps->height >>
s->ps.sps->vshift[1];
1712 const Mv *
mv = ¤t_mv->
mv[reflist];
1713 int weight_flag = (
s->sh.slice_type ==
HEVC_SLICE_P &&
s->ps.pps->weighted_pred_flag) ||
1714 (
s->sh.slice_type ==
HEVC_SLICE_B &&
s->ps.pps->weighted_bipred_flag);
1716 int hshift =
s->ps.sps->hshift[1];
1717 int vshift =
s->ps.sps->vshift[1];
1720 intptr_t _mx = mx << (1 - hshift);
1721 intptr_t _my = my << (1 - vshift);
1722 int emu =
src0 ==
s->frame->data[1] ||
src0 ==
s->frame->data[2];
1724 x_off +=
mv->x >> (2 + hshift);
1725 y_off +=
mv->y >> (2 + vshift);
1726 src0 += y_off * srcstride + (x_off * (1 <<
s->ps.sps->pixel_shift));
1735 (edge_emu_stride + (1 <<
s->ps.sps->pixel_shift));
1737 edge_emu_stride, srcstride,
1741 pic_width, pic_height);
1744 srcstride = edge_emu_stride;
1747 s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride,
src0, srcstride,
1748 block_h, _mx, _my, block_w);
1750 s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride,
src0, srcstride,
1751 block_h,
s->sh.chroma_log2_weight_denom,
1752 chroma_weight, chroma_offset, _mx, _my, block_w);
1774 int x_off,
int y_off,
int block_w,
int block_h,
const MvField *current_mv,
int cidx)
1777 const uint8_t *
src1 = ref0->
data[cidx+1];
1778 const uint8_t *
src2 = ref1->
data[cidx+1];
1779 ptrdiff_t src1stride = ref0->
linesize[cidx+1];
1780 ptrdiff_t src2stride = ref1->
linesize[cidx+1];
1781 int weight_flag = (
s->sh.slice_type ==
HEVC_SLICE_P &&
s->ps.pps->weighted_pred_flag) ||
1782 (
s->sh.slice_type ==
HEVC_SLICE_B &&
s->ps.pps->weighted_bipred_flag);
1783 int pic_width =
s->ps.sps->width >>
s->ps.sps->hshift[1];
1784 int pic_height =
s->ps.sps->height >>
s->ps.sps->vshift[1];
1785 const Mv *
const mv0 = ¤t_mv->
mv[0];
1786 const Mv *
const mv1 = ¤t_mv->
mv[1];
1787 int hshift =
s->ps.sps->hshift[1];
1788 int vshift =
s->ps.sps->vshift[1];
1794 intptr_t _mx0 = mx0 << (1 - hshift);
1795 intptr_t _my0 = my0 << (1 - vshift);
1796 intptr_t _mx1 = mx1 << (1 - hshift);
1797 intptr_t _my1 = my1 << (1 - vshift);
1799 int x_off0 = x_off + (mv0->
x >> (2 + hshift));
1800 int y_off0 = y_off + (mv0->
y >> (2 + vshift));
1801 int x_off1 = x_off + (mv1->
x >> (2 + hshift));
1802 int y_off1 = y_off + (mv1->
y >> (2 + vshift));
1804 src1 += y_off0 * src1stride + (
int)((
unsigned)x_off0 <<
s->ps.sps->pixel_shift);
1805 src2 += y_off1 * src2stride + (
int)((
unsigned)x_off1 <<
s->ps.sps->pixel_shift);
1813 (edge_emu_stride + (1 <<
s->ps.sps->pixel_shift));
1816 edge_emu_stride, src1stride,
1820 pic_width, pic_height);
1823 src1stride = edge_emu_stride;
1832 (edge_emu_stride + (1 <<
s->ps.sps->pixel_shift));
1835 edge_emu_stride, src2stride,
1839 pic_width, pic_height);
1842 src2stride = edge_emu_stride;
1845 s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](lc->
tmp,
src1, src1stride,
1846 block_h, _mx0, _my0, block_w);
1848 s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0,
s->frame->linesize[cidx+1],
1850 block_h, _mx1, _my1, block_w);
1852 s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0,
s->frame->linesize[cidx+1],
1855 s->sh.chroma_log2_weight_denom,
1856 s->sh.chroma_weight_l0[current_mv->
ref_idx[0]][cidx],
1857 s->sh.chroma_weight_l1[current_mv->
ref_idx[1]][cidx],
1858 s->sh.chroma_offset_l0[current_mv->
ref_idx[0]][cidx],
1859 s->sh.chroma_offset_l1[current_mv->
ref_idx[1]][cidx],
1860 _mx1, _my1, block_w);
1874 int nPbH,
int log2_cb_size,
int part_idx,
1886 if (inter_pred_idc !=
PRED_L1) {
1887 if (
s->sh.nb_refs[
L0])
1894 part_idx, merge_idx,
mv, mvp_flag, 0);
1899 if (inter_pred_idc !=
PRED_L0) {
1900 if (
s->sh.nb_refs[
L1])
1903 if (
s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc ==
PRED_BI) {
1912 part_idx, merge_idx,
mv, mvp_flag, 1);
1920 int log2_cb_size,
int partIdx,
int idx)
1922 #define POS(c_idx, x, y) \
1923 &s->frame->data[c_idx][((y) >> s->ps.sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1924 (((x) >> s->ps.sps->hshift[c_idx]) << s->ps.sps->pixel_shift)]
1927 struct MvField current_mv = {{{ 0 }}};
1929 int min_pu_width =
s->ps.sps->min_pu_width;
1931 MvField *tab_mvf =
s->ref->tab_mvf;
1932 const RefPicList *refPicList =
s->ref->refPicList;
1934 uint8_t *dst0 =
POS(0, x0, y0);
1935 uint8_t *dst1 =
POS(1, x0, y0);
1936 uint8_t *dst2 =
POS(2, x0, y0);
1937 int log2_min_cb_size =
s->ps.sps->log2_min_cb_size;
1938 int min_cb_width =
s->ps.sps->min_cb_width;
1939 int x_cb = x0 >> log2_min_cb_size;
1940 int y_cb = y0 >> log2_min_cb_size;
1944 int skip_flag =
SAMPLE_CTB(
s->skip_flag, x_cb, y_cb);
1950 if (
s->sh.max_num_merge_cand > 1)
1956 partIdx, merge_idx, ¤t_mv);
1959 partIdx, merge_idx, ¤t_mv);
1962 x_pu = x0 >>
s->ps.sps->log2_min_pu_size;
1963 y_pu = y0 >>
s->ps.sps->log2_min_pu_size;
1965 for (j = 0; j < nPbH >>
s->ps.sps->log2_min_pu_size; j++)
1966 for (
i = 0; i < nPbW >>
s->ps.sps->log2_min_pu_size;
i++)
1967 tab_mvf[(y_pu + j) * min_pu_width + x_pu +
i] = current_mv;
1970 ref0 = refPicList[0].
ref[current_mv.
ref_idx[0]];
1976 ref1 = refPicList[1].
ref[current_mv.
ref_idx[1]];
1977 if (!ref1 || !ref1->frame->data[0])
1983 int x0_c = x0 >>
s->ps.sps->hshift[1];
1984 int y0_c = y0 >>
s->ps.sps->vshift[1];
1985 int nPbW_c = nPbW >>
s->ps.sps->hshift[1];
1986 int nPbH_c = nPbH >>
s->ps.sps->vshift[1];
1989 ¤t_mv.
mv[0], x0, y0, nPbW, nPbH,
1990 s->sh.luma_weight_l0[current_mv.
ref_idx[0]],
1991 s->sh.luma_offset_l0[current_mv.
ref_idx[0]]);
1993 if (
s->ps.sps->chroma_format_idc) {
1995 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1996 s->sh.chroma_weight_l0[current_mv.
ref_idx[0]][0],
s->sh.chroma_offset_l0[current_mv.
ref_idx[0]][0]);
1998 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1999 s->sh.chroma_weight_l0[current_mv.
ref_idx[0]][1],
s->sh.chroma_offset_l0[current_mv.
ref_idx[0]][1]);
2002 int x0_c = x0 >>
s->ps.sps->hshift[1];
2003 int y0_c = y0 >>
s->ps.sps->vshift[1];
2004 int nPbW_c = nPbW >>
s->ps.sps->hshift[1];
2005 int nPbH_c = nPbH >>
s->ps.sps->vshift[1];
2007 luma_mc_uni(lc, dst0,
s->frame->linesize[0], ref1->frame,
2008 ¤t_mv.
mv[1], x0, y0, nPbW, nPbH,
2009 s->sh.luma_weight_l1[current_mv.
ref_idx[1]],
2010 s->sh.luma_offset_l1[current_mv.
ref_idx[1]]);
2012 if (
s->ps.sps->chroma_format_idc) {
2013 chroma_mc_uni(lc, dst1,
s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
2014 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
2015 s->sh.chroma_weight_l1[current_mv.
ref_idx[1]][0],
s->sh.chroma_offset_l1[current_mv.
ref_idx[1]][0]);
2017 chroma_mc_uni(lc, dst2,
s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
2018 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
2019 s->sh.chroma_weight_l1[current_mv.
ref_idx[1]][1],
s->sh.chroma_offset_l1[current_mv.
ref_idx[1]][1]);
2022 int x0_c = x0 >>
s->ps.sps->hshift[1];
2023 int y0_c = y0 >>
s->ps.sps->vshift[1];
2024 int nPbW_c = nPbW >>
s->ps.sps->hshift[1];
2025 int nPbH_c = nPbH >>
s->ps.sps->vshift[1];
2028 ¤t_mv.
mv[0], x0, y0, nPbW, nPbH,
2029 ref1->frame, ¤t_mv.
mv[1], ¤t_mv);
2031 if (
s->ps.sps->chroma_format_idc) {
2033 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 0);
2036 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1);
2045 int prev_intra_luma_pred_flag)
2048 int x_pu = x0 >>
s->ps.sps->log2_min_pu_size;
2049 int y_pu = y0 >>
s->ps.sps->log2_min_pu_size;
2050 int min_pu_width =
s->ps.sps->min_pu_width;
2051 int size_in_pus = pu_size >>
s->ps.sps->log2_min_pu_size;
2056 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] :
INTRA_DC;
2058 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] :
INTRA_DC;
2060 int y_ctb = (y0 >> (
s->ps.sps->log2_ctb_size)) << (
s->ps.sps->log2_ctb_size);
2062 MvField *tab_mvf =
s->ref->tab_mvf;
2063 int intra_pred_mode;
2068 if ((y0 - 1) < y_ctb)
2071 if (cand_left == cand_up) {
2072 if (cand_left < 2) {
2077 candidate[0] = cand_left;
2078 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
2079 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
2082 candidate[0] = cand_left;
2083 candidate[1] = cand_up;
2093 if (prev_intra_luma_pred_flag) {
2094 intra_pred_mode = candidate[lc->
pu.
mpm_idx];
2096 if (candidate[0] > candidate[1])
2097 FFSWAP(uint8_t, candidate[0], candidate[1]);
2098 if (candidate[0] > candidate[2])
2099 FFSWAP(uint8_t, candidate[0], candidate[2]);
2100 if (candidate[1] > candidate[2])
2101 FFSWAP(uint8_t, candidate[1], candidate[2]);
2104 for (
i = 0;
i < 3;
i++)
2105 if (intra_pred_mode >= candidate[
i])
2112 for (
i = 0;
i < size_in_pus;
i++) {
2113 memset(&
s->tab_ipm[(y_pu +
i) * min_pu_width + x_pu],
2114 intra_pred_mode, size_in_pus);
2116 for (j = 0; j < size_in_pus; j++) {
2121 return intra_pred_mode;
2125 int log2_cb_size,
int ct_depth)
2127 int length = (1 << log2_cb_size) >>
s->ps.sps->log2_min_cb_size;
2128 int x_cb = x0 >>
s->ps.sps->log2_min_cb_size;
2129 int y_cb = y0 >>
s->ps.sps->log2_min_cb_size;
2132 for (y = 0; y < length; y++)
2133 memset(&
s->tab_ct_depth[(y_cb + y) *
s->ps.sps->min_cb_width + x_cb],
2138 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
2139 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
2145 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
2146 uint8_t prev_intra_luma_pred_flag[4];
2148 int pb_size = (1 << log2_cb_size) >>
split;
2149 int side =
split + 1;
2153 for (
i = 0;
i < side;
i++)
2154 for (j = 0; j < side; j++)
2157 for (
i = 0;
i < side;
i++) {
2158 for (j = 0; j < side; j++) {
2159 if (prev_intra_luma_pred_flag[2 *
i + j])
2166 prev_intra_luma_pred_flag[2 *
i + j]);
2170 if (
s->ps.sps->chroma_format_idc == 3) {
2171 for (
i = 0;
i < side;
i++) {
2172 for (j = 0; j < side; j++) {
2174 if (chroma_mode != 4) {
2184 }
else if (
s->ps.sps->chroma_format_idc == 2) {
2187 if (chroma_mode != 4) {
2191 mode_idx = intra_chroma_table[chroma_mode];
2196 }
else if (
s->ps.sps->chroma_format_idc != 0) {
2198 if (chroma_mode != 4) {
2214 int pb_size = 1 << log2_cb_size;
2215 int size_in_pus = pb_size >>
s->ps.sps->log2_min_pu_size;
2216 int min_pu_width =
s->ps.sps->min_pu_width;
2217 MvField *tab_mvf =
s->ref->tab_mvf;
2218 int x_pu = x0 >>
s->ps.sps->log2_min_pu_size;
2219 int y_pu = y0 >>
s->ps.sps->log2_min_pu_size;
2222 if (size_in_pus == 0)
2224 for (j = 0; j < size_in_pus; j++)
2225 memset(&
s->tab_ipm[(y_pu + j) * min_pu_width + x_pu],
INTRA_DC, size_in_pus);
2227 for (j = 0; j < size_in_pus; j++)
2228 for (k = 0; k < size_in_pus; k++)
2234 int cb_size = 1 << log2_cb_size;
2235 int log2_min_cb_size =
s->ps.sps->log2_min_cb_size;
2236 int length = cb_size >> log2_min_cb_size;
2237 int min_cb_width =
s->ps.sps->min_cb_width;
2238 int x_cb = x0 >> log2_min_cb_size;
2239 int y_cb = y0 >> log2_min_cb_size;
2240 int idx = log2_cb_size - 2;
2241 int qp_block_mask = (1<<(
s->ps.sps->log2_ctb_size -
s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2251 for (x = 0; x < 4; x++)
2253 if (
s->ps.pps->transquant_bypass_enable_flag) {
2263 x = y_cb * min_cb_width + x_cb;
2264 for (y = 0; y < length; y++) {
2265 memset(&
s->skip_flag[x], skip_flag, length);
2270 x = y_cb * min_cb_width + x_cb;
2271 for (y = 0; y < length; y++) {
2272 memset(&
s->skip_flag[x], 0, length);
2281 if (!
s->sh.disable_deblocking_filter_flag)
2289 log2_cb_size ==
s->ps.sps->log2_min_cb_size) {
2297 log2_cb_size >=
s->ps.sps->pcm.log2_min_pcm_cb_size &&
2298 log2_cb_size <= s->ps.sps->pcm.log2_max_pcm_cb_size) {
2304 if (
s->ps.sps->pcm.loop_filter_disable_flag)
2320 hls_prediction_unit(lc, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2324 hls_prediction_unit(lc, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2328 hls_prediction_unit(lc, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2332 hls_prediction_unit(lc, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2336 hls_prediction_unit(lc, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2340 hls_prediction_unit(lc, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2344 hls_prediction_unit(lc, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2345 hls_prediction_unit(lc, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2346 hls_prediction_unit(lc, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2352 int rqt_root_cbf = 1;
2359 const static int cbf[2] = { 0 };
2362 s->ps.sps->max_transform_hierarchy_depth_inter;
2365 log2_cb_size, 0, 0, cbf, cbf);
2369 if (!
s->sh.disable_deblocking_filter_flag)
2378 x = y_cb * min_cb_width + x_cb;
2379 for (y = 0; y < length; y++) {
2380 memset(&
s->qp_y_tab[x], lc->
qp_y, length);
2384 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2385 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2395 int log2_cb_size,
int cb_depth)
2398 const int cb_size = 1 << log2_cb_size;
2403 if (x0 + cb_size <= s->ps.sps->width &&
2404 y0 + cb_size <= s->ps.sps->height &&
2405 log2_cb_size >
s->ps.sps->log2_min_cb_size) {
2408 split_cu = (log2_cb_size >
s->ps.sps->log2_min_cb_size);
2410 if (
s->ps.pps->cu_qp_delta_enabled_flag &&
2411 log2_cb_size >=
s->ps.sps->log2_ctb_size -
s->ps.pps->diff_cu_qp_delta_depth) {
2416 if (
s->sh.cu_chroma_qp_offset_enabled_flag &&
2417 log2_cb_size >=
s->ps.sps->log2_ctb_size -
s->ps.pps->diff_cu_chroma_qp_offset_depth) {
2422 int qp_block_mask = (1<<(
s->ps.sps->log2_ctb_size -
s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2423 const int cb_size_split = cb_size >> 1;
2424 const int x1 = x0 + cb_size_split;
2425 const int y1 = y0 + cb_size_split;
2433 if (more_data && x1 < s->ps.sps->width) {
2438 if (more_data && y1 < s->ps.sps->height) {
2443 if (more_data && x1 < s->ps.sps->width &&
2444 y1 < s->ps.sps->height) {
2450 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2451 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2455 return ((x1 + cb_size_split) <
s->ps.sps->width ||
2456 (y1 + cb_size_split) <
s->ps.sps->height);
2463 if ((!((x0 + cb_size) %
2464 (1 << (
s->ps.sps->log2_ctb_size))) ||
2465 (x0 + cb_size >=
s->ps.sps->width)) &&
2467 (1 << (
s->ps.sps->log2_ctb_size))) ||
2468 (y0 + cb_size >=
s->ps.sps->height))) {
2470 return !end_of_slice_flag;
2483 int ctb_size = 1 <<
s->ps.sps->log2_ctb_size;
2484 int ctb_addr_rs =
s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2485 int ctb_addr_in_slice = ctb_addr_rs -
s->sh.slice_addr;
2487 s->tab_slice_address[ctb_addr_rs] =
s->sh.slice_addr;
2489 if (
s->ps.pps->entropy_coding_sync_enabled_flag) {
2490 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2493 }
else if (
s->ps.pps->tiles_enabled_flag) {
2494 if (ctb_addr_ts &&
s->ps.pps->tile_id[ctb_addr_ts] !=
s->ps.pps->tile_id[ctb_addr_ts - 1]) {
2495 int idxX =
s->ps.pps->col_idxX[x_ctb >>
s->ps.sps->log2_ctb_size];
2496 lc->
end_of_tiles_x = x_ctb + (
s->ps.pps->column_width[idxX] <<
s->ps.sps->log2_ctb_size);
2506 if (
s->ps.pps->tiles_enabled_flag) {
2507 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]])
2509 if (x_ctb > 0 &&
s->tab_slice_address[ctb_addr_rs] !=
s->tab_slice_address[ctb_addr_rs - 1])
2511 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]])
2513 if (y_ctb > 0 &&
s->tab_slice_address[ctb_addr_rs] !=
s->tab_slice_address[ctb_addr_rs -
s->ps.sps->ctb_width])
2516 if (ctb_addr_in_slice <= 0)
2518 if (ctb_addr_in_slice < s->ps.sps->ctb_width)
2524 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]]));
2525 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]]));
2532 int ctb_size = 1 <<
s->ps.sps->log2_ctb_size;
2536 int ctb_addr_ts =
s->ps.pps->ctb_addr_rs_to_ts[
s->sh.slice_ctb_addr_rs];
2539 if (!ctb_addr_ts &&
s->sh.dependent_slice_segment_flag) {
2544 if (
s->sh.dependent_slice_segment_flag) {
2545 int prev_rs =
s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2546 if (
s->tab_slice_address[prev_rs] !=
s->sh.slice_addr) {
2552 while (more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2553 int ctb_addr_rs =
s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2555 x_ctb = (ctb_addr_rs % ((
s->ps.sps->width + ctb_size - 1) >>
s->ps.sps->log2_ctb_size)) <<
s->ps.sps->log2_ctb_size;
2556 y_ctb = (ctb_addr_rs / ((
s->ps.sps->width + ctb_size - 1) >>
s->ps.sps->log2_ctb_size)) <<
s->ps.sps->log2_ctb_size;
2561 s->tab_slice_address[ctb_addr_rs] = -1;
2565 hls_sao_param(lc, x_ctb >>
s->ps.sps->log2_ctb_size, y_ctb >>
s->ps.sps->log2_ctb_size);
2567 s->deblock[ctb_addr_rs].beta_offset =
s->sh.beta_offset;
2568 s->deblock[ctb_addr_rs].tc_offset =
s->sh.tc_offset;
2569 s->filter_slice_edges[ctb_addr_rs] =
s->sh.slice_loop_filter_across_slices_enabled_flag;
2572 if (more_data < 0) {
2573 s->tab_slice_address[ctb_addr_rs] = -1;
2583 if (x_ctb + ctb_size >=
s->ps.sps->width &&
2584 y_ctb + ctb_size >=
s->ps.sps->height)
2598 int job,
int self_id)
2602 int ctb_size = 1 <<
s->ps.sps->log2_ctb_size;
2605 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);
2606 int ctb_addr_ts =
s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2607 int thread = ctb_row %
s->threads_number;
2617 while(more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2618 int x_ctb = (ctb_addr_rs %
s->ps.sps->ctb_width) <<
s->ps.sps->log2_ctb_size;
2619 int y_ctb = (ctb_addr_rs /
s->ps.sps->ctb_width) <<
s->ps.sps->log2_ctb_size;
2636 hls_sao_param(lc, x_ctb >>
s->ps.sps->log2_ctb_size, y_ctb >>
s->ps.sps->log2_ctb_size);
2639 if (more_data < 0) {
2650 if (!more_data && (x_ctb+ctb_size) <
s->ps.sps->width && ctb_row !=
s->sh.num_entry_point_offsets) {
2657 if ((x_ctb+ctb_size) >=
s->ps.sps->width && (y_ctb+ctb_size) >=
s->ps.sps->height ) {
2662 ctb_addr_rs =
s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2665 if(x_ctb >=
s->ps.sps->width) {
2673 s->tab_slice_address[ctb_addr_rs] = -1;
2683 int length = nal->
size;
2687 int64_t startheader, cmpt = 0;
2690 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) {
2692 s->sh.slice_ctb_addr_rs,
s->sh.num_entry_point_offsets,
2693 s->ps.sps->ctb_width,
s->ps.sps->ctb_height
2698 for (
i = 1;
i <
s->threads_number;
i++) {
2699 if (
s->HEVClcList[
i])
2702 if (!
s->HEVClcList[
i])
2704 s->HEVClcList[
i]->logctx =
s->avctx;
2705 s->HEVClcList[
i]->parent =
s;
2706 s->HEVClcList[
i]->common_cabac_state = &
s->cabac;
2711 for (j = 0, cmpt = 0, startheader =
offset +
s->sh.entry_point_offset[0]; j < nal->skipped_bytes; j++) {
2718 for (
i = 1;
i <
s->sh.num_entry_point_offsets;
i++) {
2719 offset += (
s->sh.entry_point_offset[
i - 1] - cmpt);
2720 for (j = 0, cmpt = 0, startheader =
offset
2721 +
s->sh.entry_point_offset[
i]; j < nal->skipped_bytes; j++) {
2727 s->sh.size[
i - 1] =
s->sh.entry_point_offset[
i] - cmpt;
2731 if (
s->sh.num_entry_point_offsets != 0) {
2732 offset +=
s->sh.entry_point_offset[
s->sh.num_entry_point_offsets - 1] - cmpt;
2737 s->sh.size[
s->sh.num_entry_point_offsets - 1] = length -
offset;
2738 s->sh.offset[
s->sh.num_entry_point_offsets - 1] =
offset;
2743 for (
i = 1;
i <
s->threads_number;
i++) {
2744 s->HEVClcList[
i]->first_qp_group = 1;
2745 s->HEVClcList[
i]->qp_y =
s->HEVClc->qp_y;
2757 if (
s->ps.pps->entropy_coding_sync_enabled_flag)
2760 for (
i = 0;
i <=
s->sh.num_entry_point_offsets;
i++)
2775 if (
IS_IRAP(
s) &&
s->no_rasl_output_flag) {
2776 if (
s->sei.common.mastering_display.present > 0)
2777 s->sei.common.mastering_display.present--;
2779 if (
s->sei.common.content_light.present > 0)
2780 s->sei.common.content_light.present--;
2784 &
s->ps.sps->vui.common,
2785 s->ps.sps->bit_depth,
s->ps.sps->bit_depth_chroma,
2790 if (
s->sei.timecode.present) {
2795 sizeof(uint32_t) * 4, &tcside);
2800 tc_sd = (uint32_t*)tcside->
data;
2801 tc_sd[0] =
s->sei.timecode.num_clock_ts;
2803 for (
int i = 0;
i < tc_sd[0];
i++) {
2804 int drop =
s->sei.timecode.cnt_dropped_flag[
i];
2805 int hh =
s->sei.timecode.hours_value[
i];
2806 int mm =
s->sei.timecode.minutes_value[
i];
2807 int ss =
s->sei.timecode.seconds_value[
i];
2808 int ff =
s->sei.timecode.n_frames[
i];
2816 s->sei.timecode.num_clock_ts = 0;
2819 if (
s->sei.common.dynamic_hdr_plus.info) {
2840 if (
s->sei.common.dynamic_hdr_vivid.info) {
2857 int pic_size_in_ctb = ((
s->ps.sps->width >>
s->ps.sps->log2_min_cb_size) + 1) *
2858 ((
s->ps.sps->height >>
s->ps.sps->log2_min_cb_size) + 1);
2861 memset(
s->horizontal_bs, 0,
s->bs_width *
s->bs_height);
2862 memset(
s->vertical_bs, 0,
s->bs_width *
s->bs_height);
2863 memset(
s->cbf_luma, 0,
s->ps.sps->min_tb_width *
s->ps.sps->min_tb_height);
2864 memset(
s->is_pcm, 0, (
s->ps.sps->min_pu_width + 1) * (
s->ps.sps->min_pu_height + 1));
2865 memset(
s->tab_slice_address, -1, pic_size_in_ctb *
sizeof(*
s->tab_slice_address));
2868 s->first_nal_type =
s->nal_unit_type;
2872 if (
s->ps.pps->tiles_enabled_flag)
2873 lc->
end_of_tiles_x =
s->ps.pps->column_width[0] <<
s->ps.sps->log2_ctb_size;
2890 s->ref->needs_fg = (
s->sei.common.film_grain_characteristics.present ||
2891 s->sei.common.aom_film_grain.enable) &&
2895 if (
s->ref->needs_fg &&
2896 s->sei.common.film_grain_characteristics.present &&
2898 s->ref->frame->format)) {
2900 "Unsupported film grain parameters. Ignoring film grain.\n");
2901 s->ref->needs_fg = 0;
2904 if (
s->ref->needs_fg) {
2905 s->ref->frame_grain->format =
s->ref->frame->format;
2906 s->ref->frame_grain->width =
s->ref->frame->width;
2907 s->ref->frame_grain->height =
s->ref->frame->height;
2916 s->frame->pict_type = 3 -
s->sh.slice_type;
2926 if (!
s->avctx->hwaccel)
2934 s->ref =
s->collocated_ref =
NULL;
2944 if (
out->needs_fg) {
2947 switch (fgp->
type) {
2969 int ctb_addr_ts,
ret;
2972 s->nal_unit_type = nal->
type;
2975 switch (
s->nal_unit_type) {
2995 s->apply_defdispwin);
3054 if (
s->sh.first_slice_in_pic_flag) {
3055 if (
s->max_ra == INT_MAX) {
3060 s->max_ra = INT_MIN;
3065 s->poc <=
s->max_ra) {
3070 s->max_ra = INT_MIN;
3077 }
else if (!
s->ref) {
3082 if (
s->nal_unit_type !=
s->first_nal_type) {
3084 "Non-matching NAL types of the VCL NALUs: %d %d\n",
3085 s->first_nal_type,
s->nal_unit_type);
3089 if (!
s->sh.dependent_slice_segment_flag &&
3094 "Error constructing the reference lists for the current slice.\n");
3099 if (
s->sh.first_slice_in_pic_flag &&
s->avctx->hwaccel) {
3105 if (
s->avctx->hwaccel) {
3112 "SCC profile is not yet implemented in hevc native decoder.\n");
3117 if (
s->threads_number > 1 &&
s->sh.num_entry_point_offsets > 0)
3121 if (ctb_addr_ts >= (
s->ps.sps->ctb_width *
s->ps.sps->ctb_height)) {
3128 if (ctb_addr_ts < 0) {
3137 s->max_ra = INT_MAX;
3145 "Skipping NAL unit %d\n",
s->nal_unit_type);
3158 int eos_at_start = 1;
3160 s->ref =
s->collocated_ref =
NULL;
3161 s->last_eos =
s->eos;
3168 s->nal_length_size,
s->avctx->codec_id, 1, 0);
3171 "Error splitting the input into NAL units.\n");
3175 for (
i = 0;
i <
s->pkt.nb_nals;
i++) {
3197 s->pkt.nals[
s->pkt.nb_nals - 1].size > 2 && !
s->pkt.nals[
s->pkt.nb_nals - 1].nuh_layer_id
3198 && !
s->pkt.nals[
s->pkt.nb_nals - 1].temporal_id) {
3199 H2645NAL *nal = &
s->pkt.nals[
s->pkt.nb_nals - 1];
3202 av_log(
s->avctx,
AV_LOG_WARNING,
"Multiple Dolby Vision RPUs found in one AU. Skipping previous.\n");
3219 for (
i = 0;
i <
s->pkt.nb_nals;
i++) {
3228 if (
ret >= 0 &&
s->overlap > 2)
3232 "Error parsing NAL unit #%d.\n",
i);
3247 char msg_buf[4 * (50 + 2 * 2 * 16 )];
3255 pixel_shift =
desc->comp[0].depth > 8;
3260 if (pixel_shift && !
s->checksum_buf) {
3264 if (!
s->checksum_buf)
3271 int width =
s->avctx->coded_width;
3272 int height =
s->avctx->coded_height;
3278 for (j = 0; j <
h; j++) {
3282 s->bdsp.bswap16_buf((uint16_t *)
s->checksum_buf,
3283 (
const uint16_t *)
src,
w);
3284 src =
s->checksum_buf;
3291 #define MD5_PRI "%016" PRIx64 "%016" PRIx64
3292 #define MD5_PRI_ARG(buf) AV_RB64(buf), AV_RB64((const uint8_t*)(buf) + 8)
3294 if (!memcmp(
md5,
s->sei.picture_hash.md5[
i], 16)) {
3296 "plane %d - correct " MD5_PRI "; ",
3300 "mismatching checksum of plane %d - " MD5_PRI " != " MD5_PRI "; ",
3307 "Verifying checksum for frame with POC %d: %s\n",
3318 &
s->nal_length_size,
s->avctx->err_recognition,
3319 s->apply_defdispwin,
s->avctx);
3325 if (
first &&
s->ps.sps_list[
i]) {
3358 if (sd && sd_size > 0) {
3365 if (sd && sd_size > 0) {
3366 int old =
s->dovi_ctx.dv_profile;
3371 "New DOVI configuration record from input packet (profile %d -> %u).\n",
3372 old,
s->dovi_ctx.dv_profile);
3375 s->ref =
s->collocated_ref =
NULL;
3383 "hardware accelerator failed to decode picture\n");
3390 s->sei.picture_hash.is_md5) {
3398 s->sei.picture_hash.is_md5 = 0;
3400 if (
s->is_decoded) {
3405 if (
s->output_frame->buf[0]) {
3421 if (
src->needs_fg) {
3439 src->hwaccel_picture_private);
3456 for (
i = 0;
i < 3;
i++) {
3474 if (
s->HEVClcList) {
3475 for (
i = 1;
i <
s->threads_number;
i++) {
3498 if (!
s->HEVClc || !
s->HEVClcList)
3500 s->HEVClc->parent =
s;
3501 s->HEVClc->logctx = avctx;
3502 s->HEVClc->common_cabac_state = &
s->cabac;
3503 s->HEVClcList[0] =
s->HEVClc;
3506 if (!
s->output_frame)
3511 if (!
s->DPB[
i].frame)
3513 s->DPB[
i].tf.f =
s->DPB[
i].frame;
3516 if (!
s->DPB[
i].frame_grain)
3520 s->max_ra = INT_MAX;
3528 s->dovi_ctx.logctx = avctx;
3546 if (
s0->DPB[
i].frame->buf[0]) {
3553 if (
s->ps.sps !=
s0->ps.sps)
3564 if (
s->ps.sps !=
s0->ps.sps)
3568 s->seq_decode =
s0->seq_decode;
3569 s->seq_output =
s0->seq_output;
3570 s->pocTid0 =
s0->pocTid0;
3571 s->max_ra =
s0->max_ra;
3573 s->no_rasl_output_flag =
s0->no_rasl_output_flag;
3575 s->is_nalff =
s0->is_nalff;
3576 s->nal_length_size =
s0->nal_length_size;
3578 s->threads_number =
s0->threads_number;
3579 s->threads_type =
s0->threads_type;
3581 s->film_grain_warning_shown =
s0->film_grain_warning_shown;
3585 s->max_ra = INT_MAX;
3593 s0->sei.common.dynamic_hdr_plus.info);
3604 s0->sei.common.dynamic_hdr_vivid.info);
3608 s->sei.common.frame_packing =
s0->sei.common.frame_packing;
3609 s->sei.common.display_orientation =
s0->sei.common.display_orientation;
3610 s->sei.common.alternative_transfer =
s0->sei.common.alternative_transfer;
3611 s->sei.common.mastering_display =
s0->sei.common.mastering_display;
3612 s->sei.common.content_light =
s0->sei.common.content_light;
3613 s->sei.common.aom_film_grain =
s0->sei.common.aom_film_grain;
3634 s->threads_number = 1;
3645 s->enable_parallel_tiles = 0;
3646 s->sei.picture_timing.picture_struct = 0;
3662 if (sd && sd->
size > 0)
3676 s->max_ra = INT_MAX;
3683 #define OFFSET(x) offsetof(HEVCContext, x)
3684 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3687 {
"apply_defdispwin",
"Apply default display window from VUI",
OFFSET(apply_defdispwin),
3689 {
"strict-displaywin",
"stricly apply default display window size",
OFFSET(apply_defdispwin),
3719 #if CONFIG_HEVC_DXVA2_HWACCEL
3722 #if CONFIG_HEVC_D3D11VA_HWACCEL
3725 #if CONFIG_HEVC_D3D11VA2_HWACCEL
3728 #if CONFIG_HEVC_D3D12VA_HWACCEL
3731 #if CONFIG_HEVC_NVDEC_HWACCEL
3734 #if CONFIG_HEVC_VAAPI_HWACCEL
3737 #if CONFIG_HEVC_VDPAU_HWACCEL
3740 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
3743 #if CONFIG_HEVC_VULKAN_HWACCEL