26 #include "config_components.h"
56 static const uint8_t
hevc_pel_weight[65] = { [2] = 0, [4] = 1, [6] = 2, [8] = 3, [12] = 4, [16] = 5, [24] = 6, [32] = 7, [48] = 8, [64] = 9 };
98 int log2_min_cb_size =
sps->log2_min_cb_size;
101 int pic_size_in_ctb = ((
width >> log2_min_cb_size) + 1) *
102 ((
height >> log2_min_cb_size) + 1);
103 int ctb_count =
sps->ctb_width *
sps->ctb_height;
104 int min_pu_size =
sps->min_pu_width *
sps->min_pu_height;
106 s->bs_width = (
width >> 2) + 1;
107 s->bs_height = (
height >> 2) + 1;
110 s->deblock =
av_calloc(ctb_count,
sizeof(*
s->deblock));
111 if (!
s->sao || !
s->deblock)
116 if (!
s->skip_flag || !
s->tab_ct_depth)
122 if (!
s->tab_ipm || !
s->cbf_luma || !
s->is_pcm)
127 sizeof(*
s->tab_slice_address));
129 sizeof(*
s->qp_y_tab));
130 if (!
s->qp_y_tab || !
s->filter_slice_edges || !
s->tab_slice_address)
133 s->horizontal_bs =
av_calloc(
s->bs_width,
s->bs_height);
135 if (!
s->horizontal_bs || !
s->vertical_bs)
142 if (!
s->tab_mvf_pool || !
s->rpl_tab_pool)
156 uint8_t luma_weight_l0_flag[16];
157 uint8_t chroma_weight_l0_flag[16];
158 uint8_t luma_weight_l1_flag[16];
159 uint8_t chroma_weight_l1_flag[16];
160 int luma_log2_weight_denom;
163 if (luma_log2_weight_denom < 0 || luma_log2_weight_denom > 7) {
164 av_log(
s->avctx,
AV_LOG_ERROR,
"luma_log2_weight_denom %d is invalid\n", luma_log2_weight_denom);
167 s->sh.luma_log2_weight_denom =
av_clip_uintp2(luma_log2_weight_denom, 3);
168 if (
s->ps.sps->chroma_format_idc != 0) {
169 int64_t chroma_log2_weight_denom = luma_log2_weight_denom + (int64_t)
get_se_golomb(gb);
170 if (chroma_log2_weight_denom < 0 || chroma_log2_weight_denom > 7) {
171 av_log(
s->avctx,
AV_LOG_ERROR,
"chroma_log2_weight_denom %"PRId64
" is invalid\n", chroma_log2_weight_denom);
174 s->sh.chroma_log2_weight_denom = chroma_log2_weight_denom;
177 for (
i = 0;
i <
s->sh.nb_refs[
L0];
i++) {
179 if (!luma_weight_l0_flag[
i]) {
180 s->sh.luma_weight_l0[
i] = 1 <<
s->sh.luma_log2_weight_denom;
181 s->sh.luma_offset_l0[
i] = 0;
184 if (
s->ps.sps->chroma_format_idc != 0) {
185 for (
i = 0;
i <
s->sh.nb_refs[
L0];
i++)
188 for (
i = 0;
i <
s->sh.nb_refs[
L0];
i++)
189 chroma_weight_l0_flag[
i] = 0;
191 for (
i = 0;
i <
s->sh.nb_refs[
L0];
i++) {
192 if (luma_weight_l0_flag[
i]) {
194 if ((int8_t)delta_luma_weight_l0 != delta_luma_weight_l0)
196 s->sh.luma_weight_l0[
i] = (1 <<
s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;
199 if (chroma_weight_l0_flag[
i]) {
200 for (j = 0; j < 2; j++) {
204 if ( (int8_t)delta_chroma_weight_l0 != delta_chroma_weight_l0
205 || delta_chroma_offset_l0 < -(1<<17) || delta_chroma_offset_l0 > (1<<17)) {
209 s->sh.chroma_weight_l0[
i][j] = (1 <<
s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
210 s->sh.chroma_offset_l0[
i][j] =
av_clip((delta_chroma_offset_l0 - ((128 *
s->sh.chroma_weight_l0[
i][j])
211 >>
s->sh.chroma_log2_weight_denom) + 128), -128, 127);
214 s->sh.chroma_weight_l0[
i][0] = 1 <<
s->sh.chroma_log2_weight_denom;
215 s->sh.chroma_offset_l0[
i][0] = 0;
216 s->sh.chroma_weight_l0[
i][1] = 1 <<
s->sh.chroma_log2_weight_denom;
217 s->sh.chroma_offset_l0[
i][1] = 0;
221 for (
i = 0;
i <
s->sh.nb_refs[
L1];
i++) {
223 if (!luma_weight_l1_flag[
i]) {
224 s->sh.luma_weight_l1[
i] = 1 <<
s->sh.luma_log2_weight_denom;
225 s->sh.luma_offset_l1[
i] = 0;
228 if (
s->ps.sps->chroma_format_idc != 0) {
229 for (
i = 0;
i <
s->sh.nb_refs[
L1];
i++)
232 for (
i = 0;
i <
s->sh.nb_refs[
L1];
i++)
233 chroma_weight_l1_flag[
i] = 0;
235 for (
i = 0;
i <
s->sh.nb_refs[
L1];
i++) {
236 if (luma_weight_l1_flag[
i]) {
238 if ((int8_t)delta_luma_weight_l1 != delta_luma_weight_l1)
240 s->sh.luma_weight_l1[
i] = (1 <<
s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;
243 if (chroma_weight_l1_flag[
i]) {
244 for (j = 0; j < 2; j++) {
248 if ( (int8_t)delta_chroma_weight_l1 != delta_chroma_weight_l1
249 || delta_chroma_offset_l1 < -(1<<17) || delta_chroma_offset_l1 > (1<<17)) {
253 s->sh.chroma_weight_l1[
i][j] = (1 <<
s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
254 s->sh.chroma_offset_l1[
i][j] =
av_clip((delta_chroma_offset_l1 - ((128 *
s->sh.chroma_weight_l1[
i][j])
255 >>
s->sh.chroma_log2_weight_denom) + 128), -128, 127);
258 s->sh.chroma_weight_l1[
i][0] = 1 <<
s->sh.chroma_log2_weight_denom;
259 s->sh.chroma_offset_l1[
i][0] = 0;
260 s->sh.chroma_weight_l1[
i][1] = 1 <<
s->sh.chroma_log2_weight_denom;
261 s->sh.chroma_offset_l1[
i][1] = 0;
271 int max_poc_lsb = 1 <<
sps->log2_max_poc_lsb;
272 int prev_delta_msb = 0;
273 unsigned int nb_sps = 0, nb_sh;
277 if (!
sps->long_term_ref_pics_present_flag)
280 if (
sps->num_long_term_ref_pics_sps > 0)
284 if (nb_sps >
sps->num_long_term_ref_pics_sps)
294 uint8_t lt_idx_sps = 0;
296 if (
sps->num_long_term_ref_pics_sps > 1)
299 rps->
poc[
i] =
sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
300 rps->
used[
i] =
sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];
311 if (
i &&
i != nb_sps)
312 delta += prev_delta_msb;
314 poc = rps->
poc[
i] +
s->poc -
delta * max_poc_lsb -
s->sh.pic_order_cnt_lsb;
318 prev_delta_msb =
delta;
331 unsigned int num = 0, den = 0;
336 avctx->
width =
sps->width - ow->left_offset - ow->right_offset;
337 avctx->
height =
sps->height - ow->top_offset - ow->bottom_offset;
339 avctx->
profile =
sps->ptl.general_ptl.profile_idc;
340 avctx->
level =
sps->ptl.general_ptl.level_idc;
344 if (
sps->vui.common.video_signal_type_present_flag)
350 if (
sps->vui.common.colour_description_present_flag) {
352 avctx->
color_trc =
sps->vui.common.transfer_characteristics;
361 if (
sps->chroma_format_idc == 1) {
362 if (
sps->vui.common.chroma_loc_info_present_flag) {
363 if (
sps->vui.common.chroma_sample_loc_type_top_field <= 5)
369 if (
vps->vps_timing_info_present_flag) {
370 num =
vps->vps_num_units_in_tick;
371 den =
vps->vps_time_scale;
372 }
else if (
sps->vui.vui_timing_info_present_flag) {
373 num =
sps->vui.vui_num_units_in_tick;
374 den =
sps->vui.vui_time_scale;
377 if (num != 0 && den != 0)
386 if (
s->sei.common.a53_caption.buf_ref)
389 if (
s->sei.common.alternative_transfer.present &&
392 avctx->
color_trc =
s->sei.common.alternative_transfer.preferred_transfer_characteristics;
395 if (
s->sei.common.film_grain_characteristics.present)
403 #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + \
404 CONFIG_HEVC_D3D11VA_HWACCEL * 2 + \
405 CONFIG_HEVC_NVDEC_HWACCEL + \
406 CONFIG_HEVC_VAAPI_HWACCEL + \
407 CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL + \
408 CONFIG_HEVC_VDPAU_HWACCEL)
411 switch (
sps->pix_fmt) {
414 #if CONFIG_HEVC_DXVA2_HWACCEL
417 #if CONFIG_HEVC_D3D11VA_HWACCEL
421 #if CONFIG_HEVC_VAAPI_HWACCEL
424 #if CONFIG_HEVC_VDPAU_HWACCEL
427 #if CONFIG_HEVC_NVDEC_HWACCEL
430 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
435 #if CONFIG_HEVC_DXVA2_HWACCEL
438 #if CONFIG_HEVC_D3D11VA_HWACCEL
442 #if CONFIG_HEVC_VAAPI_HWACCEL
445 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
448 #if CONFIG_HEVC_VDPAU_HWACCEL
451 #if CONFIG_HEVC_NVDEC_HWACCEL
456 #if CONFIG_HEVC_VAAPI_HWACCEL
459 #if CONFIG_HEVC_VDPAU_HWACCEL
462 #if CONFIG_HEVC_NVDEC_HWACCEL
465 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
471 #if CONFIG_HEVC_VAAPI_HWACCEL
474 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
479 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
484 #if CONFIG_HEVC_VAAPI_HWACCEL
487 #if CONFIG_HEVC_VDPAU_HWACCEL
490 #if CONFIG_HEVC_NVDEC_HWACCEL
495 #if CONFIG_HEVC_VAAPI_HWACCEL
501 *fmt++ =
sps->pix_fmt;
531 for (
i = 0;
i < 3;
i++) {
536 if (
sps->sao_enabled && !
s->avctx->hwaccel) {
537 int c_count = (
sps->chroma_format_idc != 0) ? 3 : 1;
540 for(c_idx = 0; c_idx < c_count; c_idx++) {
541 int w =
sps->width >>
sps->hshift[c_idx];
542 int h =
sps->height >>
sps->vshift[c_idx];
543 s->sao_pixel_buffer_h[c_idx] =
546 s->sao_pixel_buffer_v[c_idx] =
549 if (!
s->sao_pixel_buffer_h[c_idx] ||
550 !
s->sao_pixel_buffer_v[c_idx])
556 s->ps.vps = (
HEVCVPS*)
s->ps.vps_list[
s->ps.sps->vps_id]->data;
562 for (
i = 0;
i < 3;
i++) {
579 av_log(
s->avctx,
AV_LOG_ERROR,
"Two slices reporting being the first in the same frame.\n");
607 if (
s->ps.sps != (
HEVCSPS*)
s->ps.sps_list[
s->ps.pps->sps_id]->data) {
632 int slice_address_length;
634 if (
s->ps.pps->dependent_slice_segments_enabled_flag)
638 s->ps.sps->ctb_height);
642 "Invalid slice segment address: %u.\n",
654 s->slice_initialized = 0;
658 s->slice_initialized = 0;
660 for (
i = 0;
i <
s->ps.pps->num_extra_slice_header_bits;
i++)
672 !
s->ps.pps->pps_curr_pic_ref_enabled_flag) {
679 if (
s->ps.pps->output_flag_present_flag)
682 if (
s->ps.sps->separate_colour_plane_flag)
692 "Ignoring POC change between slices: %d -> %d\n",
s->poc, poc);
708 int numbits, rps_idx;
710 if (!
s->ps.sps->nb_st_rps) {
716 rps_idx = numbits > 0 ?
get_bits(gb, numbits) : 0;
730 if (
s->ps.sps->sps_temporal_mvp_enabled_flag)
735 s->sh.short_term_rps =
NULL;
750 if (
s->ps.sps->sao_enabled) {
752 if (
s->ps.sps->chroma_format_idc) {
766 sh->
nb_refs[
L0] =
s->ps.pps->num_ref_idx_l0_default_active;
768 sh->
nb_refs[
L1] =
s->ps.pps->num_ref_idx_l1_default_active;
789 if (
s->ps.pps->lists_modification_present_flag && nb_refs > 1) {
807 if (
s->ps.pps->cabac_init_present_flag)
822 "Invalid collocated_ref_idx: %d.\n",
839 "Invalid number of merging MVP candidates: %d.\n",
845 if (
s->ps.sps->motion_vector_resolution_control_idc == 2)
855 if (
s->ps.pps->pic_slice_level_chroma_qp_offsets_present_flag) {
868 if (
s->ps.pps->pps_slice_act_qp_offsets_present_flag) {
874 if (
s->ps.pps->chroma_qp_offset_list_enabled_flag)
879 if (
s->ps.pps->deblocking_filter_control_present_flag) {
880 int deblocking_filter_override_flag = 0;
882 if (
s->ps.pps->deblocking_filter_override_enabled_flag)
883 deblocking_filter_override_flag =
get_bits1(gb);
885 if (deblocking_filter_override_flag) {
890 if (beta_offset_div2 < -6 || beta_offset_div2 > 6 ||
891 tc_offset_div2 < -6 || tc_offset_div2 > 6) {
893 "Invalid deblock filter offsets: %d, %d\n",
894 beta_offset_div2, tc_offset_div2);
911 if (
s->ps.pps->seq_loop_filter_across_slices_enabled_flag &&
919 }
else if (!
s->slice_initialized) {
925 if (
s->ps.pps->tiles_enabled_flag ||
s->ps.pps->entropy_coding_sync_enabled_flag) {
929 av_log(
s->avctx,
AV_LOG_ERROR,
"num_entry_point_offsets %d is invalid\n", num_entry_point_offsets);
937 if (offset_len < 1 || offset_len > 32) {
958 if (
s->threads_number > 1 && (
s->ps.pps->num_tile_rows > 1 ||
s->ps.pps->num_tile_columns > 1)) {
959 s->enable_parallel_tiles = 0;
960 s->threads_number = 1;
962 s->enable_parallel_tiles = 0;
964 s->enable_parallel_tiles = 0;
967 if (
s->ps.pps->slice_header_extension_present_flag) {
973 for (
i = 0;
i < length;
i++)
980 sh->
slice_qp < -
s->ps.sps->qp_bd_offset) {
982 "The slice_qp %d is outside the valid range "
985 -
s->ps.sps->qp_bd_offset);
991 if (!
s->sh.slice_ctb_addr_rs &&
s->sh.dependent_slice_segment_flag) {
1002 s->HEVClc->first_qp_group = !
s->sh.dependent_slice_segment_flag;
1004 if (!
s->ps.pps->cu_qp_delta_enabled_flag)
1005 s->HEVClc->qp_y =
s->sh.slice_qp;
1007 s->slice_initialized = 1;
1008 s->HEVClc->tu.cu_qp_offset_cb = 0;
1009 s->HEVClc->tu.cu_qp_offset_cr = 0;
1014 #define CTB(tab, x, y) ((tab)[(y) * s->ps.sps->ctb_width + (x)])
1016 #define SET_SAO(elem, value) \
1018 if (!sao_merge_up_flag && !sao_merge_left_flag) \
1019 sao->elem = value; \
1020 else if (sao_merge_left_flag) \
1021 sao->elem = CTB(s->sao, rx-1, ry).elem; \
1022 else if (sao_merge_up_flag) \
1023 sao->elem = CTB(s->sao, rx, ry-1).elem; \
1031 int sao_merge_left_flag = 0;
1032 int sao_merge_up_flag = 0;
1036 if (
s->sh.slice_sample_adaptive_offset_flag[0] ||
1037 s->sh.slice_sample_adaptive_offset_flag[1]) {
1042 if (ry > 0 && !sao_merge_left_flag) {
1048 for (c_idx = 0; c_idx < (
s->ps.sps->chroma_format_idc ? 3 : 1); c_idx++) {
1049 int log2_sao_offset_scale = c_idx == 0 ?
s->ps.pps->log2_sao_offset_scale_luma :
1050 s->ps.pps->log2_sao_offset_scale_chroma;
1052 if (!
s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
1067 for (
i = 0;
i < 4;
i++)
1071 for (
i = 0;
i < 4;
i++) {
1080 }
else if (c_idx != 2) {
1086 for (
i = 0;
i < 4;
i++) {
1094 sao->
offset_val[c_idx][
i + 1] *= 1 << log2_sao_offset_scale;
1106 if (log2_res_scale_abs_plus1 != 0) {
1109 (1 - 2 * res_scale_sign_flag);
1119 int xBase,
int yBase,
int cb_xBase,
int cb_yBase,
1120 int log2_cb_size,
int log2_trafo_size,
1121 int blk_idx,
int cbf_luma,
int *cbf_cb,
int *cbf_cr)
1124 const int log2_trafo_size_c = log2_trafo_size -
s->ps.sps->hshift[1];
1128 int trafo_size = 1 << log2_trafo_size;
1131 s->hpc.intra_pred[log2_trafo_size - 2](lc, x0, y0, 0);
1134 if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
1135 (
s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1138 int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
1139 (
s->ps.sps->chroma_format_idc == 2 &&
1140 (cbf_cb[1] || cbf_cr[1]));
1152 "The cu_qp_delta %d is outside the valid range "
1155 -(26 +
s->ps.sps->qp_bd_offset / 2),
1156 (25 +
s->ps.sps->qp_bd_offset / 2));
1163 if (
s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
1166 if (cu_chroma_qp_offset_flag) {
1167 int cu_chroma_qp_offset_idx = 0;
1168 if (
s->ps.pps->chroma_qp_offset_list_len_minus1 > 0) {
1171 "cu_chroma_qp_offset_idx not yet tested.\n");
1204 if (
s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 ||
s->ps.sps->chroma_format_idc == 3)) {
1205 int trafo_size_h = 1 << (log2_trafo_size_c +
s->ps.sps->hshift[1]);
1206 int trafo_size_v = 1 << (log2_trafo_size_c +
s->ps.sps->vshift[1]);
1207 lc->
tu.
cross_pf = (
s->ps.pps->cross_component_prediction_enabled_flag && cbf_luma &&
1214 for (
i = 0;
i < (
s->ps.sps->chroma_format_idc == 2 ? 2 : 1);
i++) {
1217 s->hpc.intra_pred[log2_trafo_size_c - 2](lc, x0, y0 + (
i << log2_trafo_size_c), 1);
1221 log2_trafo_size_c, scan_idx_c, 1);
1224 ptrdiff_t
stride =
s->frame->linesize[1];
1225 int hshift =
s->ps.sps->hshift[1];
1226 int vshift =
s->ps.sps->vshift[1];
1229 int size = 1 << log2_trafo_size_c;
1231 uint8_t *dst = &
s->frame->data[1][(y0 >> vshift) *
stride +
1232 ((x0 >> hshift) <<
s->ps.sps->pixel_shift)];
1236 s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs,
stride);
1243 for (
i = 0;
i < (
s->ps.sps->chroma_format_idc == 2 ? 2 : 1);
i++) {
1246 trafo_size_h, trafo_size_v);
1247 s->hpc.intra_pred[log2_trafo_size_c - 2](lc, x0, y0 + (
i << log2_trafo_size_c), 2);
1251 log2_trafo_size_c, scan_idx_c, 2);
1254 ptrdiff_t
stride =
s->frame->linesize[2];
1255 int hshift =
s->ps.sps->hshift[2];
1256 int vshift =
s->ps.sps->vshift[2];
1259 int size = 1 << log2_trafo_size_c;
1261 uint8_t *dst = &
s->frame->data[2][(y0 >> vshift) *
stride +
1262 ((x0 >> hshift) <<
s->ps.sps->pixel_shift)];
1266 s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs,
stride);
1269 }
else if (
s->ps.sps->chroma_format_idc && blk_idx == 3) {
1270 int trafo_size_h = 1 << (log2_trafo_size + 1);
1271 int trafo_size_v = 1 << (log2_trafo_size +
s->ps.sps->vshift[1]);
1272 for (
i = 0;
i < (
s->ps.sps->chroma_format_idc == 2 ? 2 : 1);
i++) {
1275 trafo_size_h, trafo_size_v);
1276 s->hpc.intra_pred[log2_trafo_size - 2](lc, xBase, yBase + (
i << log2_trafo_size), 1);
1280 log2_trafo_size, scan_idx_c, 1);
1282 for (
i = 0;
i < (
s->ps.sps->chroma_format_idc == 2 ? 2 : 1);
i++) {
1285 trafo_size_h, trafo_size_v);
1286 s->hpc.intra_pred[log2_trafo_size - 2](lc, xBase, yBase + (
i << log2_trafo_size), 2);
1290 log2_trafo_size, scan_idx_c, 2);
1294 if (log2_trafo_size > 2 ||
s->ps.sps->chroma_format_idc == 3) {
1295 int trafo_size_h = 1 << (log2_trafo_size_c +
s->ps.sps->hshift[1]);
1296 int trafo_size_v = 1 << (log2_trafo_size_c +
s->ps.sps->vshift[1]);
1298 s->hpc.intra_pred[log2_trafo_size_c - 2](lc, x0, y0, 1);
1299 s->hpc.intra_pred[log2_trafo_size_c - 2](lc, x0, y0, 2);
1300 if (
s->ps.sps->chroma_format_idc == 2) {
1302 trafo_size_h, trafo_size_v);
1303 s->hpc.intra_pred[log2_trafo_size_c - 2](lc, x0, y0 + (1 << log2_trafo_size_c), 1);
1304 s->hpc.intra_pred[log2_trafo_size_c - 2](lc, x0, y0 + (1 << log2_trafo_size_c), 2);
1306 }
else if (blk_idx == 3) {
1307 int trafo_size_h = 1 << (log2_trafo_size + 1);
1308 int trafo_size_v = 1 << (log2_trafo_size +
s->ps.sps->vshift[1]);
1310 trafo_size_h, trafo_size_v);
1311 s->hpc.intra_pred[log2_trafo_size - 2](lc, xBase, yBase, 1);
1312 s->hpc.intra_pred[log2_trafo_size - 2](lc, xBase, yBase, 2);
1313 if (
s->ps.sps->chroma_format_idc == 2) {
1315 trafo_size_h, trafo_size_v);
1316 s->hpc.intra_pred[log2_trafo_size - 2](lc, xBase, yBase + (1 << log2_trafo_size), 1);
1317 s->hpc.intra_pred[log2_trafo_size - 2](lc, xBase, yBase + (1 << log2_trafo_size), 2);
1327 int cb_size = 1 << log2_cb_size;
1328 int log2_min_pu_size =
s->ps.sps->log2_min_pu_size;
1330 int min_pu_width =
s->ps.sps->min_pu_width;
1331 int x_end =
FFMIN(x0 + cb_size,
s->ps.sps->width);
1332 int y_end =
FFMIN(y0 + cb_size,
s->ps.sps->height);
1335 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1336 for (
i = (x0 >> log2_min_pu_size);
i < (x_end >> log2_min_pu_size);
i++)
1337 s->is_pcm[
i + j * min_pu_width] = 2;
1341 int xBase,
int yBase,
int cb_xBase,
int cb_yBase,
1342 int log2_cb_size,
int log2_trafo_size,
1343 int trafo_depth,
int blk_idx,
1344 const int *base_cbf_cb,
const int *base_cbf_cr)
1347 uint8_t split_transform_flag;
1352 cbf_cb[0] = base_cbf_cb[0];
1353 cbf_cb[1] = base_cbf_cb[1];
1354 cbf_cr[0] = base_cbf_cr[0];
1355 cbf_cr[1] = base_cbf_cr[1];
1358 if (trafo_depth == 1) {
1360 if (
s->ps.sps->chroma_format_idc == 3) {
1374 if (log2_trafo_size <= s->ps.sps->log2_max_trafo_size &&
1375 log2_trafo_size >
s->ps.sps->log2_min_tb_size &&
1376 trafo_depth < lc->cu.max_trafo_depth &&
1380 int inter_split =
s->ps.sps->max_transform_hierarchy_depth_inter == 0 &&
1385 split_transform_flag = log2_trafo_size >
s->ps.sps->log2_max_trafo_size ||
1390 if (
s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 ||
s->ps.sps->chroma_format_idc == 3)) {
1391 if (trafo_depth == 0 || cbf_cb[0]) {
1393 if (
s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1398 if (trafo_depth == 0 || cbf_cr[0]) {
1400 if (
s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1406 if (split_transform_flag) {
1407 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1408 const int x1 = x0 + trafo_size_split;
1409 const int y1 = y0 + trafo_size_split;
1411 #define SUBDIVIDE(x, y, idx) \
1413 ret = hls_transform_tree(lc, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size,\
1414 log2_trafo_size - 1, trafo_depth + 1, idx, \
1427 int min_tu_size = 1 <<
s->ps.sps->log2_min_tb_size;
1428 int log2_min_tu_size =
s->ps.sps->log2_min_tb_size;
1429 int min_tu_width =
s->ps.sps->min_tb_width;
1433 cbf_cb[0] || cbf_cr[0] ||
1434 (
s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1439 log2_cb_size, log2_trafo_size,
1440 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1446 for (
i = 0;
i < (1 << log2_trafo_size);
i += min_tu_size)
1447 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1448 int x_tu = (x0 + j) >> log2_min_tu_size;
1449 int y_tu = (y0 +
i) >> log2_min_tu_size;
1450 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1453 if (!
s->sh.disable_deblocking_filter_flag) {
1455 if (
s->ps.pps->transquant_bypass_enable_flag &&
1467 int cb_size = 1 << log2_cb_size;
1468 ptrdiff_t stride0 =
s->frame->linesize[0];
1469 ptrdiff_t stride1 =
s->frame->linesize[1];
1470 ptrdiff_t stride2 =
s->frame->linesize[2];
1471 uint8_t *dst0 = &
s->frame->data[0][y0 * stride0 + (x0 <<
s->ps.sps->pixel_shift)];
1472 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)];
1473 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)];
1475 int length = cb_size * cb_size *
s->ps.sps->pcm.bit_depth +
1476 (((cb_size >>
s->ps.sps->hshift[1]) * (cb_size >>
s->ps.sps->vshift[1])) +
1477 ((cb_size >>
s->ps.sps->hshift[2]) * (cb_size >>
s->ps.sps->vshift[2]))) *
1478 s->ps.sps->pcm.bit_depth_chroma;
1479 const uint8_t *pcm =
skip_bytes(&lc->
cc, (length + 7) >> 3);
1482 if (!
s->sh.disable_deblocking_filter_flag)
1489 s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size, &gb,
s->ps.sps->pcm.bit_depth);
1490 if (
s->ps.sps->chroma_format_idc) {
1491 s->hevcdsp.put_pcm(dst1, stride1,
1492 cb_size >>
s->ps.sps->hshift[1],
1493 cb_size >>
s->ps.sps->vshift[1],
1494 &gb,
s->ps.sps->pcm.bit_depth_chroma);
1495 s->hevcdsp.put_pcm(dst2, stride2,
1496 cb_size >>
s->ps.sps->hshift[2],
1497 cb_size >>
s->ps.sps->vshift[2],
1498 &gb,
s->ps.sps->pcm.bit_depth_chroma);
1522 int block_w,
int block_h,
int luma_weight,
int luma_offset)
1525 const uint8_t *
src =
ref->data[0];
1526 ptrdiff_t srcstride =
ref->linesize[0];
1527 int pic_width =
s->ps.sps->width;
1528 int pic_height =
s->ps.sps->height;
1531 int weight_flag = (
s->sh.slice_type ==
HEVC_SLICE_P &&
s->ps.pps->weighted_pred_flag) ||
1532 (
s->sh.slice_type ==
HEVC_SLICE_B &&
s->ps.pps->weighted_bipred_flag);
1535 x_off +=
mv->x >> 2;
1536 y_off +=
mv->y >> 2;
1537 src += y_off * srcstride + (x_off * (1 <<
s->ps.sps->pixel_shift));
1547 edge_emu_stride, srcstride,
1551 pic_width, pic_height);
1553 srcstride = edge_emu_stride;
1557 s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride,
src, srcstride,
1558 block_h, mx, my, block_w);
1560 s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride,
src, srcstride,
1561 block_h,
s->sh.luma_log2_weight_denom,
1562 luma_weight, luma_offset, mx, my, block_w);
1582 const AVFrame *ref0,
const Mv *mv0,
int x_off,
int y_off,
1583 int block_w,
int block_h,
const AVFrame *ref1,
1584 const Mv *mv1,
struct MvField *current_mv)
1587 ptrdiff_t src0stride = ref0->
linesize[0];
1588 ptrdiff_t src1stride = ref1->
linesize[0];
1589 int pic_width =
s->ps.sps->width;
1590 int pic_height =
s->ps.sps->height;
1591 int mx0 = mv0->
x & 3;
1592 int my0 = mv0->
y & 3;
1593 int mx1 = mv1->
x & 3;
1594 int my1 = mv1->
y & 3;
1595 int weight_flag = (
s->sh.slice_type ==
HEVC_SLICE_P &&
s->ps.pps->weighted_pred_flag) ||
1596 (
s->sh.slice_type ==
HEVC_SLICE_B &&
s->ps.pps->weighted_bipred_flag);
1597 int x_off0 = x_off + (mv0->
x >> 2);
1598 int y_off0 = y_off + (mv0->
y >> 2);
1599 int x_off1 = x_off + (mv1->
x >> 2);
1600 int y_off1 = y_off + (mv1->
y >> 2);
1603 const uint8_t *
src0 = ref0->
data[0] + y_off0 * src0stride + (
int)((
unsigned)x_off0 <<
s->ps.sps->pixel_shift);
1604 const uint8_t *
src1 = ref1->
data[0] + y_off1 * src1stride + (
int)((
unsigned)x_off1 <<
s->ps.sps->pixel_shift);
1614 edge_emu_stride, src0stride,
1618 pic_width, pic_height);
1620 src0stride = edge_emu_stride;
1631 edge_emu_stride, src1stride,
1635 pic_width, pic_height);
1637 src1stride = edge_emu_stride;
1640 s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](lc->
tmp,
src0, src0stride,
1641 block_h, mx0, my0, block_w);
1643 s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride,
src1, src1stride, lc->
tmp,
1644 block_h, mx1, my1, block_w);
1646 s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride,
src1, src1stride, lc->
tmp,
1647 block_h,
s->sh.luma_log2_weight_denom,
1648 s->sh.luma_weight_l0[current_mv->
ref_idx[0]],
1649 s->sh.luma_weight_l1[current_mv->
ref_idx[1]],
1650 s->sh.luma_offset_l0[current_mv->
ref_idx[0]],
1651 s->sh.luma_offset_l1[current_mv->
ref_idx[1]],
1674 ptrdiff_t dststride,
const uint8_t *
src0, ptrdiff_t srcstride,
int reflist,
1675 int x_off,
int y_off,
int block_w,
int block_h,
1676 const struct MvField *current_mv,
int chroma_weight,
int chroma_offset)
1679 int pic_width =
s->ps.sps->width >>
s->ps.sps->hshift[1];
1680 int pic_height =
s->ps.sps->height >>
s->ps.sps->vshift[1];
1681 const Mv *
mv = ¤t_mv->
mv[reflist];
1682 int weight_flag = (
s->sh.slice_type ==
HEVC_SLICE_P &&
s->ps.pps->weighted_pred_flag) ||
1683 (
s->sh.slice_type ==
HEVC_SLICE_B &&
s->ps.pps->weighted_bipred_flag);
1685 int hshift =
s->ps.sps->hshift[1];
1686 int vshift =
s->ps.sps->vshift[1];
1689 intptr_t _mx = mx << (1 - hshift);
1690 intptr_t _my = my << (1 - vshift);
1692 x_off +=
mv->x >> (2 + hshift);
1693 y_off +=
mv->y >> (2 + vshift);
1694 src0 += y_off * srcstride + (x_off * (1 <<
s->ps.sps->pixel_shift));
1702 (edge_emu_stride + (1 <<
s->ps.sps->pixel_shift));
1704 edge_emu_stride, srcstride,
1708 pic_width, pic_height);
1711 srcstride = edge_emu_stride;
1714 s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride,
src0, srcstride,
1715 block_h, _mx, _my, block_w);
1717 s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride,
src0, srcstride,
1718 block_h,
s->sh.chroma_log2_weight_denom,
1719 chroma_weight, chroma_offset, _mx, _my, block_w);
1741 int x_off,
int y_off,
int block_w,
int block_h,
const MvField *current_mv,
int cidx)
1744 const uint8_t *
src1 = ref0->
data[cidx+1];
1745 const uint8_t *
src2 = ref1->
data[cidx+1];
1746 ptrdiff_t src1stride = ref0->
linesize[cidx+1];
1747 ptrdiff_t src2stride = ref1->
linesize[cidx+1];
1748 int weight_flag = (
s->sh.slice_type ==
HEVC_SLICE_P &&
s->ps.pps->weighted_pred_flag) ||
1749 (
s->sh.slice_type ==
HEVC_SLICE_B &&
s->ps.pps->weighted_bipred_flag);
1750 int pic_width =
s->ps.sps->width >>
s->ps.sps->hshift[1];
1751 int pic_height =
s->ps.sps->height >>
s->ps.sps->vshift[1];
1752 const Mv *
const mv0 = ¤t_mv->
mv[0];
1753 const Mv *
const mv1 = ¤t_mv->
mv[1];
1754 int hshift =
s->ps.sps->hshift[1];
1755 int vshift =
s->ps.sps->vshift[1];
1761 intptr_t _mx0 = mx0 << (1 - hshift);
1762 intptr_t _my0 = my0 << (1 - vshift);
1763 intptr_t _mx1 = mx1 << (1 - hshift);
1764 intptr_t _my1 = my1 << (1 - vshift);
1766 int x_off0 = x_off + (mv0->
x >> (2 + hshift));
1767 int y_off0 = y_off + (mv0->
y >> (2 + vshift));
1768 int x_off1 = x_off + (mv1->
x >> (2 + hshift));
1769 int y_off1 = y_off + (mv1->
y >> (2 + vshift));
1771 src1 += y_off0 * src1stride + (
int)((
unsigned)x_off0 <<
s->ps.sps->pixel_shift);
1772 src2 += y_off1 * src2stride + (
int)((
unsigned)x_off1 <<
s->ps.sps->pixel_shift);
1780 (edge_emu_stride + (1 <<
s->ps.sps->pixel_shift));
1783 edge_emu_stride, src1stride,
1787 pic_width, pic_height);
1790 src1stride = edge_emu_stride;
1799 (edge_emu_stride + (1 <<
s->ps.sps->pixel_shift));
1802 edge_emu_stride, src2stride,
1806 pic_width, pic_height);
1809 src2stride = edge_emu_stride;
1812 s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](lc->
tmp,
src1, src1stride,
1813 block_h, _mx0, _my0, block_w);
1815 s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0,
s->frame->linesize[cidx+1],
1817 block_h, _mx1, _my1, block_w);
1819 s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0,
s->frame->linesize[cidx+1],
1822 s->sh.chroma_log2_weight_denom,
1823 s->sh.chroma_weight_l0[current_mv->
ref_idx[0]][cidx],
1824 s->sh.chroma_weight_l1[current_mv->
ref_idx[1]][cidx],
1825 s->sh.chroma_offset_l0[current_mv->
ref_idx[0]][cidx],
1826 s->sh.chroma_offset_l1[current_mv->
ref_idx[1]][cidx],
1827 _mx1, _my1, block_w);
1841 int nPbH,
int log2_cb_size,
int part_idx,
1853 if (inter_pred_idc !=
PRED_L1) {
1854 if (
s->sh.nb_refs[
L0])
1861 part_idx, merge_idx,
mv, mvp_flag, 0);
1866 if (inter_pred_idc !=
PRED_L0) {
1867 if (
s->sh.nb_refs[
L1])
1870 if (
s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc ==
PRED_BI) {
1879 part_idx, merge_idx,
mv, mvp_flag, 1);
1887 int log2_cb_size,
int partIdx,
int idx)
1889 #define POS(c_idx, x, y) \
1890 &s->frame->data[c_idx][((y) >> s->ps.sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1891 (((x) >> s->ps.sps->hshift[c_idx]) << s->ps.sps->pixel_shift)]
1894 struct MvField current_mv = {{{ 0 }}};
1896 int min_pu_width =
s->ps.sps->min_pu_width;
1898 MvField *tab_mvf =
s->ref->tab_mvf;
1899 const RefPicList *refPicList =
s->ref->refPicList;
1901 uint8_t *dst0 =
POS(0, x0, y0);
1902 uint8_t *dst1 =
POS(1, x0, y0);
1903 uint8_t *dst2 =
POS(2, x0, y0);
1904 int log2_min_cb_size =
s->ps.sps->log2_min_cb_size;
1905 int min_cb_width =
s->ps.sps->min_cb_width;
1906 int x_cb = x0 >> log2_min_cb_size;
1907 int y_cb = y0 >> log2_min_cb_size;
1911 int skip_flag =
SAMPLE_CTB(
s->skip_flag, x_cb, y_cb);
1917 if (
s->sh.max_num_merge_cand > 1)
1923 partIdx, merge_idx, ¤t_mv);
1926 partIdx, merge_idx, ¤t_mv);
1929 x_pu = x0 >>
s->ps.sps->log2_min_pu_size;
1930 y_pu = y0 >>
s->ps.sps->log2_min_pu_size;
1932 for (j = 0; j < nPbH >>
s->ps.sps->log2_min_pu_size; j++)
1933 for (
i = 0; i < nPbW >>
s->ps.sps->log2_min_pu_size;
i++)
1934 tab_mvf[(y_pu + j) * min_pu_width + x_pu +
i] = current_mv;
1937 ref0 = refPicList[0].
ref[current_mv.
ref_idx[0]];
1943 ref1 = refPicList[1].
ref[current_mv.
ref_idx[1]];
1950 int x0_c = x0 >>
s->ps.sps->hshift[1];
1951 int y0_c = y0 >>
s->ps.sps->vshift[1];
1952 int nPbW_c = nPbW >>
s->ps.sps->hshift[1];
1953 int nPbH_c = nPbH >>
s->ps.sps->vshift[1];
1956 ¤t_mv.
mv[0], x0, y0, nPbW, nPbH,
1957 s->sh.luma_weight_l0[current_mv.
ref_idx[0]],
1958 s->sh.luma_offset_l0[current_mv.
ref_idx[0]]);
1960 if (
s->ps.sps->chroma_format_idc) {
1962 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1963 s->sh.chroma_weight_l0[current_mv.
ref_idx[0]][0],
s->sh.chroma_offset_l0[current_mv.
ref_idx[0]][0]);
1965 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1966 s->sh.chroma_weight_l0[current_mv.
ref_idx[0]][1],
s->sh.chroma_offset_l0[current_mv.
ref_idx[0]][1]);
1969 int x0_c = x0 >>
s->ps.sps->hshift[1];
1970 int y0_c = y0 >>
s->ps.sps->vshift[1];
1971 int nPbW_c = nPbW >>
s->ps.sps->hshift[1];
1972 int nPbH_c = nPbH >>
s->ps.sps->vshift[1];
1974 luma_mc_uni(lc, dst0,
s->frame->linesize[0], ref1->frame,
1975 ¤t_mv.
mv[1], x0, y0, nPbW, nPbH,
1976 s->sh.luma_weight_l1[current_mv.
ref_idx[1]],
1977 s->sh.luma_offset_l1[current_mv.
ref_idx[1]]);
1979 if (
s->ps.sps->chroma_format_idc) {
1980 chroma_mc_uni(lc, dst1,
s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
1981 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1982 s->sh.chroma_weight_l1[current_mv.
ref_idx[1]][0],
s->sh.chroma_offset_l1[current_mv.
ref_idx[1]][0]);
1984 chroma_mc_uni(lc, dst2,
s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
1985 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1986 s->sh.chroma_weight_l1[current_mv.
ref_idx[1]][1],
s->sh.chroma_offset_l1[current_mv.
ref_idx[1]][1]);
1989 int x0_c = x0 >>
s->ps.sps->hshift[1];
1990 int y0_c = y0 >>
s->ps.sps->vshift[1];
1991 int nPbW_c = nPbW >>
s->ps.sps->hshift[1];
1992 int nPbH_c = nPbH >>
s->ps.sps->vshift[1];
1995 ¤t_mv.
mv[0], x0, y0, nPbW, nPbH,
1996 ref1->frame, ¤t_mv.
mv[1], ¤t_mv);
1998 if (
s->ps.sps->chroma_format_idc) {
2000 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 0);
2003 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1);
2012 int prev_intra_luma_pred_flag)
2015 int x_pu = x0 >>
s->ps.sps->log2_min_pu_size;
2016 int y_pu = y0 >>
s->ps.sps->log2_min_pu_size;
2017 int min_pu_width =
s->ps.sps->min_pu_width;
2018 int size_in_pus = pu_size >>
s->ps.sps->log2_min_pu_size;
2023 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] :
INTRA_DC;
2025 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] :
INTRA_DC;
2027 int y_ctb = (y0 >> (
s->ps.sps->log2_ctb_size)) << (
s->ps.sps->log2_ctb_size);
2029 MvField *tab_mvf =
s->ref->tab_mvf;
2030 int intra_pred_mode;
2035 if ((y0 - 1) < y_ctb)
2038 if (cand_left == cand_up) {
2039 if (cand_left < 2) {
2044 candidate[0] = cand_left;
2045 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
2046 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
2049 candidate[0] = cand_left;
2050 candidate[1] = cand_up;
2060 if (prev_intra_luma_pred_flag) {
2061 intra_pred_mode = candidate[lc->
pu.
mpm_idx];
2063 if (candidate[0] > candidate[1])
2064 FFSWAP(uint8_t, candidate[0], candidate[1]);
2065 if (candidate[0] > candidate[2])
2066 FFSWAP(uint8_t, candidate[0], candidate[2]);
2067 if (candidate[1] > candidate[2])
2068 FFSWAP(uint8_t, candidate[1], candidate[2]);
2071 for (
i = 0;
i < 3;
i++)
2072 if (intra_pred_mode >= candidate[
i])
2079 for (
i = 0;
i < size_in_pus;
i++) {
2080 memset(&
s->tab_ipm[(y_pu +
i) * min_pu_width + x_pu],
2081 intra_pred_mode, size_in_pus);
2083 for (j = 0; j < size_in_pus; j++) {
2088 return intra_pred_mode;
2092 int log2_cb_size,
int ct_depth)
2094 int length = (1 << log2_cb_size) >>
s->ps.sps->log2_min_cb_size;
2095 int x_cb = x0 >>
s->ps.sps->log2_min_cb_size;
2096 int y_cb = y0 >>
s->ps.sps->log2_min_cb_size;
2099 for (y = 0; y < length; y++)
2100 memset(&
s->tab_ct_depth[(y_cb + y) *
s->ps.sps->min_cb_width + x_cb],
2105 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
2106 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
2112 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
2113 uint8_t prev_intra_luma_pred_flag[4];
2115 int pb_size = (1 << log2_cb_size) >>
split;
2116 int side =
split + 1;
2120 for (
i = 0;
i < side;
i++)
2121 for (j = 0; j < side; j++)
2124 for (
i = 0;
i < side;
i++) {
2125 for (j = 0; j < side; j++) {
2126 if (prev_intra_luma_pred_flag[2 *
i + j])
2133 prev_intra_luma_pred_flag[2 *
i + j]);
2137 if (
s->ps.sps->chroma_format_idc == 3) {
2138 for (
i = 0;
i < side;
i++) {
2139 for (j = 0; j < side; j++) {
2141 if (chroma_mode != 4) {
2151 }
else if (
s->ps.sps->chroma_format_idc == 2) {
2154 if (chroma_mode != 4) {
2158 mode_idx = intra_chroma_table[chroma_mode];
2163 }
else if (
s->ps.sps->chroma_format_idc != 0) {
2165 if (chroma_mode != 4) {
2181 int pb_size = 1 << log2_cb_size;
2182 int size_in_pus = pb_size >>
s->ps.sps->log2_min_pu_size;
2183 int min_pu_width =
s->ps.sps->min_pu_width;
2184 MvField *tab_mvf =
s->ref->tab_mvf;
2185 int x_pu = x0 >>
s->ps.sps->log2_min_pu_size;
2186 int y_pu = y0 >>
s->ps.sps->log2_min_pu_size;
2189 if (size_in_pus == 0)
2191 for (j = 0; j < size_in_pus; j++)
2192 memset(&
s->tab_ipm[(y_pu + j) * min_pu_width + x_pu],
INTRA_DC, size_in_pus);
2194 for (j = 0; j < size_in_pus; j++)
2195 for (k = 0; k < size_in_pus; k++)
2201 int cb_size = 1 << log2_cb_size;
2202 int log2_min_cb_size =
s->ps.sps->log2_min_cb_size;
2203 int length = cb_size >> log2_min_cb_size;
2204 int min_cb_width =
s->ps.sps->min_cb_width;
2205 int x_cb = x0 >> log2_min_cb_size;
2206 int y_cb = y0 >> log2_min_cb_size;
2207 int idx = log2_cb_size - 2;
2208 int qp_block_mask = (1<<(
s->ps.sps->log2_ctb_size -
s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2218 for (x = 0; x < 4; x++)
2220 if (
s->ps.pps->transquant_bypass_enable_flag) {
2230 x = y_cb * min_cb_width + x_cb;
2231 for (y = 0; y < length; y++) {
2232 memset(&
s->skip_flag[x], skip_flag, length);
2237 x = y_cb * min_cb_width + x_cb;
2238 for (y = 0; y < length; y++) {
2239 memset(&
s->skip_flag[x], 0, length);
2248 if (!
s->sh.disable_deblocking_filter_flag)
2256 log2_cb_size ==
s->ps.sps->log2_min_cb_size) {
2264 log2_cb_size >=
s->ps.sps->pcm.log2_min_pcm_cb_size &&
2265 log2_cb_size <= s->ps.sps->pcm.log2_max_pcm_cb_size) {
2271 if (
s->ps.sps->pcm.loop_filter_disable_flag)
2287 hls_prediction_unit(lc, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2291 hls_prediction_unit(lc, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2295 hls_prediction_unit(lc, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2299 hls_prediction_unit(lc, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2303 hls_prediction_unit(lc, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2307 hls_prediction_unit(lc, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2311 hls_prediction_unit(lc, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2312 hls_prediction_unit(lc, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2313 hls_prediction_unit(lc, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2319 int rqt_root_cbf = 1;
2326 const static int cbf[2] = { 0 };
2329 s->ps.sps->max_transform_hierarchy_depth_inter;
2332 log2_cb_size, 0, 0, cbf, cbf);
2336 if (!
s->sh.disable_deblocking_filter_flag)
2345 x = y_cb * min_cb_width + x_cb;
2346 for (y = 0; y < length; y++) {
2347 memset(&
s->qp_y_tab[x], lc->
qp_y, length);
2351 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2352 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2362 int log2_cb_size,
int cb_depth)
2365 const int cb_size = 1 << log2_cb_size;
2370 if (x0 + cb_size <= s->ps.sps->width &&
2371 y0 + cb_size <= s->ps.sps->height &&
2372 log2_cb_size >
s->ps.sps->log2_min_cb_size) {
2375 split_cu = (log2_cb_size >
s->ps.sps->log2_min_cb_size);
2377 if (
s->ps.pps->cu_qp_delta_enabled_flag &&
2378 log2_cb_size >=
s->ps.sps->log2_ctb_size -
s->ps.pps->diff_cu_qp_delta_depth) {
2383 if (
s->sh.cu_chroma_qp_offset_enabled_flag &&
2384 log2_cb_size >=
s->ps.sps->log2_ctb_size -
s->ps.pps->diff_cu_chroma_qp_offset_depth) {
2389 int qp_block_mask = (1<<(
s->ps.sps->log2_ctb_size -
s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2390 const int cb_size_split = cb_size >> 1;
2391 const int x1 = x0 + cb_size_split;
2392 const int y1 = y0 + cb_size_split;
2400 if (more_data && x1 < s->ps.sps->width) {
2405 if (more_data && y1 < s->ps.sps->height) {
2410 if (more_data && x1 < s->ps.sps->width &&
2411 y1 < s->ps.sps->height) {
2417 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2418 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2422 return ((x1 + cb_size_split) <
s->ps.sps->width ||
2423 (y1 + cb_size_split) <
s->ps.sps->height);
2430 if ((!((x0 + cb_size) %
2431 (1 << (
s->ps.sps->log2_ctb_size))) ||
2432 (x0 + cb_size >=
s->ps.sps->width)) &&
2434 (1 << (
s->ps.sps->log2_ctb_size))) ||
2435 (y0 + cb_size >=
s->ps.sps->height))) {
2437 return !end_of_slice_flag;
2450 int ctb_size = 1 <<
s->ps.sps->log2_ctb_size;
2451 int ctb_addr_rs =
s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2452 int ctb_addr_in_slice = ctb_addr_rs -
s->sh.slice_addr;
2454 s->tab_slice_address[ctb_addr_rs] =
s->sh.slice_addr;
2456 if (
s->ps.pps->entropy_coding_sync_enabled_flag) {
2457 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2460 }
else if (
s->ps.pps->tiles_enabled_flag) {
2461 if (ctb_addr_ts &&
s->ps.pps->tile_id[ctb_addr_ts] !=
s->ps.pps->tile_id[ctb_addr_ts - 1]) {
2462 int idxX =
s->ps.pps->col_idxX[x_ctb >>
s->ps.sps->log2_ctb_size];
2463 lc->
end_of_tiles_x = x_ctb + (
s->ps.pps->column_width[idxX] <<
s->ps.sps->log2_ctb_size);
2473 if (
s->ps.pps->tiles_enabled_flag) {
2474 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]])
2476 if (x_ctb > 0 &&
s->tab_slice_address[ctb_addr_rs] !=
s->tab_slice_address[ctb_addr_rs - 1])
2478 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]])
2480 if (y_ctb > 0 &&
s->tab_slice_address[ctb_addr_rs] !=
s->tab_slice_address[ctb_addr_rs -
s->ps.sps->ctb_width])
2483 if (ctb_addr_in_slice <= 0)
2485 if (ctb_addr_in_slice < s->ps.sps->ctb_width)
2491 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]]));
2492 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]]));
2499 int ctb_size = 1 <<
s->ps.sps->log2_ctb_size;
2503 int ctb_addr_ts =
s->ps.pps->ctb_addr_rs_to_ts[
s->sh.slice_ctb_addr_rs];
2506 if (!ctb_addr_ts &&
s->sh.dependent_slice_segment_flag) {
2511 if (
s->sh.dependent_slice_segment_flag) {
2512 int prev_rs =
s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2513 if (
s->tab_slice_address[prev_rs] !=
s->sh.slice_addr) {
2519 while (more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2520 int ctb_addr_rs =
s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2522 x_ctb = (ctb_addr_rs % ((
s->ps.sps->width + ctb_size - 1) >>
s->ps.sps->log2_ctb_size)) <<
s->ps.sps->log2_ctb_size;
2523 y_ctb = (ctb_addr_rs / ((
s->ps.sps->width + ctb_size - 1) >>
s->ps.sps->log2_ctb_size)) <<
s->ps.sps->log2_ctb_size;
2528 s->tab_slice_address[ctb_addr_rs] = -1;
2532 hls_sao_param(lc, x_ctb >>
s->ps.sps->log2_ctb_size, y_ctb >>
s->ps.sps->log2_ctb_size);
2534 s->deblock[ctb_addr_rs].beta_offset =
s->sh.beta_offset;
2535 s->deblock[ctb_addr_rs].tc_offset =
s->sh.tc_offset;
2536 s->filter_slice_edges[ctb_addr_rs] =
s->sh.slice_loop_filter_across_slices_enabled_flag;
2539 if (more_data < 0) {
2540 s->tab_slice_address[ctb_addr_rs] = -1;
2550 if (x_ctb + ctb_size >=
s->ps.sps->width &&
2551 y_ctb + ctb_size >=
s->ps.sps->height)
2569 int job,
int self_id)
2573 int ctb_size = 1 <<
s->ps.sps->log2_ctb_size;
2576 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);
2577 int ctb_addr_ts =
s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2578 int thread = ctb_row %
s->threads_number;
2588 while(more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2589 int x_ctb = (ctb_addr_rs %
s->ps.sps->ctb_width) <<
s->ps.sps->log2_ctb_size;
2590 int y_ctb = (ctb_addr_rs /
s->ps.sps->ctb_width) <<
s->ps.sps->log2_ctb_size;
2607 hls_sao_param(lc, x_ctb >>
s->ps.sps->log2_ctb_size, y_ctb >>
s->ps.sps->log2_ctb_size);
2610 if (more_data < 0) {
2621 if (!more_data && (x_ctb+ctb_size) <
s->ps.sps->width && ctb_row !=
s->sh.num_entry_point_offsets) {
2628 if ((x_ctb+ctb_size) >=
s->ps.sps->width && (y_ctb+ctb_size) >=
s->ps.sps->height ) {
2633 ctb_addr_rs =
s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2636 if(x_ctb >=
s->ps.sps->width) {
2644 s->tab_slice_address[ctb_addr_rs] = -1;
2654 int length = nal->
size;
2658 int64_t startheader, cmpt = 0;
2661 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) {
2663 s->sh.slice_ctb_addr_rs,
s->sh.num_entry_point_offsets,
2664 s->ps.sps->ctb_width,
s->ps.sps->ctb_height
2669 for (
i = 1;
i <
s->threads_number;
i++) {
2670 if (
s->HEVClcList[
i])
2673 if (!
s->HEVClcList[
i])
2675 s->HEVClcList[
i]->logctx =
s->avctx;
2676 s->HEVClcList[
i]->parent =
s;
2677 s->HEVClcList[
i]->common_cabac_state = &
s->cabac;
2682 for (j = 0, cmpt = 0, startheader =
offset +
s->sh.entry_point_offset[0]; j < nal->skipped_bytes; j++) {
2689 for (
i = 1;
i <
s->sh.num_entry_point_offsets;
i++) {
2690 offset += (
s->sh.entry_point_offset[
i - 1] - cmpt);
2691 for (j = 0, cmpt = 0, startheader =
offset
2692 +
s->sh.entry_point_offset[
i]; j < nal->skipped_bytes; j++) {
2698 s->sh.size[
i - 1] =
s->sh.entry_point_offset[
i] - cmpt;
2702 if (
s->sh.num_entry_point_offsets != 0) {
2703 offset +=
s->sh.entry_point_offset[
s->sh.num_entry_point_offsets - 1] - cmpt;
2708 s->sh.size[
s->sh.num_entry_point_offsets - 1] = length -
offset;
2709 s->sh.offset[
s->sh.num_entry_point_offsets - 1] =
offset;
2714 for (
i = 1;
i <
s->threads_number;
i++) {
2715 s->HEVClcList[
i]->first_qp_group = 1;
2716 s->HEVClcList[
i]->qp_y =
s->HEVClc->qp_y;
2728 if (
s->ps.pps->entropy_coding_sync_enabled_flag)
2731 for (
i = 0;
i <=
s->sh.num_entry_point_offsets;
i++)
2745 if (
s->sei.mastering_display.present > 0 &&
2747 s->sei.mastering_display.present--;
2749 if (
s->sei.mastering_display.present) {
2751 const int mapping[3] = {2, 0, 1};
2752 const int chroma_den = 50000;
2753 const int luma_den = 10000;
2760 for (
i = 0;
i < 3;
i++) {
2761 const int j = mapping[
i];
2767 metadata->
white_point[0].
num =
s->sei.mastering_display.white_point[0];
2769 metadata->
white_point[1].
num =
s->sei.mastering_display.white_point[1];
2781 "r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f)\n",
2790 "min_luminance=%f, max_luminance=%f\n",
2795 if (
s->sei.content_light.present > 0 &&
2797 s->sei.content_light.present--;
2799 if (
s->sei.content_light.present) {
2804 metadata->
MaxCLL =
s->sei.content_light.max_content_light_level;
2805 metadata->
MaxFALL =
s->sei.content_light.max_pic_average_light_level;
2813 &
s->ps.sps->vui.common,
2814 s->ps.sps->bit_depth,
s->ps.sps->bit_depth_chroma,
2819 if (
s->sei.timecode.present) {
2823 sizeof(uint32_t) * 4);
2827 tc_sd = (uint32_t*)tcside->
data;
2828 tc_sd[0] =
s->sei.timecode.num_clock_ts;
2830 for (
int i = 0;
i < tc_sd[0];
i++) {
2831 int drop =
s->sei.timecode.cnt_dropped_flag[
i];
2832 int hh =
s->sei.timecode.hours_value[
i];
2833 int mm =
s->sei.timecode.minutes_value[
i];
2834 int ss =
s->sei.timecode.seconds_value[
i];
2835 int ff =
s->sei.timecode.n_frames[
i];
2842 s->sei.timecode.num_clock_ts = 0;
2845 if (
s->sei.common.dynamic_hdr_plus.info) {
2867 if (
s->sei.common.dynamic_hdr_vivid.info) {
2884 int pic_size_in_ctb = ((
s->ps.sps->width >>
s->ps.sps->log2_min_cb_size) + 1) *
2885 ((
s->ps.sps->height >>
s->ps.sps->log2_min_cb_size) + 1);
2888 memset(
s->horizontal_bs, 0,
s->bs_width *
s->bs_height);
2889 memset(
s->vertical_bs, 0,
s->bs_width *
s->bs_height);
2890 memset(
s->cbf_luma, 0,
s->ps.sps->min_tb_width *
s->ps.sps->min_tb_height);
2891 memset(
s->is_pcm, 0, (
s->ps.sps->min_pu_width + 1) * (
s->ps.sps->min_pu_height + 1));
2892 memset(
s->tab_slice_address, -1, pic_size_in_ctb *
sizeof(*
s->tab_slice_address));
2895 s->first_nal_type =
s->nal_unit_type;
2899 if (
s->ps.pps->tiles_enabled_flag)
2900 lc->
end_of_tiles_x =
s->ps.pps->column_width[0] <<
s->ps.sps->log2_ctb_size;
2914 s->ref->needs_fg =
s->sei.common.film_grain_characteristics.present &&
2918 if (
s->ref->needs_fg) {
2919 s->ref->frame_grain->format =
s->ref->frame->format;
2920 s->ref->frame_grain->width =
s->ref->frame->width;
2921 s->ref->frame_grain->height =
s->ref->frame->height;
2930 s->frame->pict_type = 3 -
s->sh.slice_type;
2940 if (!
s->avctx->hwaccel)
2958 if (
out->needs_fg) {
2978 int ctb_addr_ts,
ret;
2981 s->nal_unit_type = nal->
type;
2984 switch (
s->nal_unit_type) {
2986 if (
s->avctx->hwaccel &&
s->avctx->hwaccel->decode_params) {
2987 ret =
s->avctx->hwaccel->decode_params(
s->avctx,
2999 if (
s->avctx->hwaccel &&
s->avctx->hwaccel->decode_params) {
3000 ret =
s->avctx->hwaccel->decode_params(
s->avctx,
3008 s->apply_defdispwin);
3013 if (
s->avctx->hwaccel &&
s->avctx->hwaccel->decode_params) {
3014 ret =
s->avctx->hwaccel->decode_params(
s->avctx,
3027 if (
s->avctx->hwaccel &&
s->avctx->hwaccel->decode_params) {
3028 ret =
s->avctx->hwaccel->decode_params(
s->avctx,
3071 if (
s->sh.first_slice_in_pic_flag) {
3072 if (
s->max_ra == INT_MAX) {
3077 s->max_ra = INT_MIN;
3082 s->poc <=
s->max_ra) {
3087 s->max_ra = INT_MIN;
3094 }
else if (!
s->ref) {
3099 if (
s->nal_unit_type !=
s->first_nal_type) {
3101 "Non-matching NAL types of the VCL NALUs: %d %d\n",
3102 s->first_nal_type,
s->nal_unit_type);
3106 if (!
s->sh.dependent_slice_segment_flag &&
3111 "Error constructing the reference lists for the current slice.\n");
3116 if (
s->sh.first_slice_in_pic_flag &&
s->avctx->hwaccel) {
3117 ret =
s->avctx->hwaccel->start_frame(
s->avctx,
NULL, 0);
3122 if (
s->avctx->hwaccel) {
3129 "SCC profile is not yet implemented in hevc native decoder.\n");
3134 if (
s->threads_number > 1 &&
s->sh.num_entry_point_offsets > 0)
3138 if (ctb_addr_ts >= (
s->ps.sps->ctb_width *
s->ps.sps->ctb_height)) {
3145 if (ctb_addr_ts < 0) {
3154 s->max_ra = INT_MAX;
3162 "Skipping NAL unit %d\n",
s->nal_unit_type);
3175 int eos_at_start = 1;
3178 s->last_eos =
s->eos;
3185 s->nal_length_size,
s->avctx->codec_id, 1, 0);
3188 "Error splitting the input into NAL units.\n");
3192 for (
i = 0;
i <
s->pkt.nb_nals;
i++) {
3214 s->pkt.nals[
s->pkt.nb_nals - 1].size > 2 && !
s->pkt.nals[
s->pkt.nb_nals - 1].nuh_layer_id
3215 && !
s->pkt.nals[
s->pkt.nb_nals - 1].temporal_id) {
3216 H2645NAL *nal = &
s->pkt.nals[
s->pkt.nb_nals - 1];
3219 av_log(
s->avctx,
AV_LOG_WARNING,
"Multiple Dolby Vision RPUs found in one AU. Skipping previous.\n");
3236 for (
i = 0;
i <
s->pkt.nb_nals;
i++) {
3245 if (
ret >= 0 &&
s->overlap > 2)
3249 "Error parsing NAL unit #%d.\n",
i);
3264 char msg_buf[4 * (50 + 2 * 2 * 16 )];
3272 pixel_shift =
desc->comp[0].depth > 8;
3277 if (pixel_shift && !
s->checksum_buf) {
3280 frame->linesize[2]));
3281 if (!
s->checksum_buf)
3288 int width =
s->avctx->coded_width;
3289 int height =
s->avctx->coded_height;
3295 for (j = 0; j <
h; j++) {
3299 s->bdsp.bswap16_buf((uint16_t *)
s->checksum_buf,
3300 (
const uint16_t *)
src,
w);
3301 src =
s->checksum_buf;
3308 #define MD5_PRI "%016" PRIx64 "%016" PRIx64
3309 #define MD5_PRI_ARG(buf) AV_RB64(buf), AV_RB64((const uint8_t*)(buf) + 8)
3311 if (!memcmp(
md5,
s->sei.picture_hash.md5[
i], 16)) {
3313 "plane %d - correct " MD5_PRI "; ",
3317 "mismatching checksum of plane %d - " MD5_PRI " != " MD5_PRI "; ",
3324 "Verifying checksum for frame with POC %d: %s\n",
3335 &
s->nal_length_size,
s->avctx->err_recognition,
3336 s->apply_defdispwin,
s->avctx);
3342 if (
first &&
s->ps.sps_list[
i]) {
3375 if (sd && sd_size > 0) {
3382 if (sd && sd_size > 0)
3393 "hardware accelerator failed to decode picture\n");
3400 s->sei.picture_hash.is_md5) {
3408 s->sei.picture_hash.is_md5 = 0;
3410 if (
s->is_decoded) {
3415 if (
s->output_frame->buf[0]) {
3431 if (
src->needs_fg) {
3457 if (
src->hwaccel_picture_private) {
3482 for (
i = 0;
i < 3;
i++) {
3500 if (
s->HEVClcList) {
3501 for (
i = 1;
i <
s->threads_number;
i++) {
3524 if (!
s->HEVClc || !
s->HEVClcList)
3526 s->HEVClc->parent =
s;
3527 s->HEVClc->logctx = avctx;
3528 s->HEVClc->common_cabac_state = &
s->cabac;
3529 s->HEVClcList[0] =
s->HEVClc;
3532 if (!
s->output_frame)
3537 if (!
s->DPB[
i].frame)
3539 s->DPB[
i].tf.f =
s->DPB[
i].frame;
3542 if (!
s->DPB[
i].frame_grain)
3546 s->max_ra = INT_MAX;
3554 s->dovi_ctx.logctx = avctx;
3572 if (
s0->DPB[
i].frame->buf[0]) {
3579 if (
s->ps.sps !=
s0->ps.sps)
3599 if (
s->ps.sps !=
s0->ps.sps)
3603 s->seq_decode =
s0->seq_decode;
3604 s->seq_output =
s0->seq_output;
3605 s->pocTid0 =
s0->pocTid0;
3606 s->max_ra =
s0->max_ra;
3608 s->no_rasl_output_flag =
s0->no_rasl_output_flag;
3610 s->is_nalff =
s0->is_nalff;
3611 s->nal_length_size =
s0->nal_length_size;
3613 s->threads_number =
s0->threads_number;
3614 s->threads_type =
s0->threads_type;
3618 s->max_ra = INT_MAX;
3626 s0->sei.common.dynamic_hdr_plus.info);
3639 s0->sei.common.dynamic_hdr_vivid.info);
3643 s->sei.common.frame_packing =
s0->sei.common.frame_packing;
3644 s->sei.common.display_orientation =
s0->sei.common.display_orientation;
3645 s->sei.common.alternative_transfer =
s0->sei.common.alternative_transfer;
3646 s->sei.mastering_display =
s0->sei.mastering_display;
3647 s->sei.content_light =
s0->sei.content_light;
3668 s->threads_number = 1;
3679 s->enable_parallel_tiles = 0;
3680 s->sei.picture_timing.picture_struct = 0;
3704 s->max_ra = INT_MAX;
3708 #define OFFSET(x) offsetof(HEVCContext, x)
3709 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3712 {
"apply_defdispwin",
"Apply default display window from VUI",
OFFSET(apply_defdispwin),
3714 {
"strict-displaywin",
"stricly apply default display window size",
OFFSET(apply_defdispwin),
3744 #if CONFIG_HEVC_DXVA2_HWACCEL
3747 #if CONFIG_HEVC_D3D11VA_HWACCEL
3750 #if CONFIG_HEVC_D3D11VA2_HWACCEL
3753 #if CONFIG_HEVC_NVDEC_HWACCEL
3756 #if CONFIG_HEVC_VAAPI_HWACCEL
3759 #if CONFIG_HEVC_VDPAU_HWACCEL
3762 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL