4 * Copyright (C) 2012 - 2013 Guillaume Martres
5 * Copyright (C) 2012 - 2013 Mickael Raulet
6 * Copyright (C) 2012 - 2013 Gildas Cocherel
7 * Copyright (C) 2012 - 2013 Wassim Hamidouche
9 * This file is part of FFmpeg.
11 * FFmpeg is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
16 * FFmpeg is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with FFmpeg; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavutil/attributes.h"
27 #include "libavutil/common.h"
28 #include "libavutil/display.h"
29 #include "libavutil/internal.h"
30 #include "libavutil/mastering_display_metadata.h"
31 #include "libavutil/md5.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/pixdesc.h"
34 #include "libavutil/stereo3d.h"
37 #include "bytestream.h"
38 #include "cabac_functions.h"
43 const uint8_t ff_hevc_pel_weight[65] = { [2] = 0, [4] = 1, [6] = 2, [8] = 3, [12] = 4, [16] = 5, [24] = 6, [32] = 7, [48] = 8, [64] = 9 };
46 * NOTE: Each function hls_foo correspond to the function foo in the
47 * specification (HLS stands for High Level Syntax).
54 /* free everything allocated by pic_arrays_init() */
55 static void pic_arrays_free(HEVCContext *s)
58 av_freep(&s->deblock);
60 av_freep(&s->skip_flag);
61 av_freep(&s->tab_ct_depth);
63 av_freep(&s->tab_ipm);
64 av_freep(&s->cbf_luma);
67 av_freep(&s->qp_y_tab);
68 av_freep(&s->tab_slice_address);
69 av_freep(&s->filter_slice_edges);
71 av_freep(&s->horizontal_bs);
72 av_freep(&s->vertical_bs);
74 av_freep(&s->sh.entry_point_offset);
75 av_freep(&s->sh.size);
76 av_freep(&s->sh.offset);
78 av_buffer_pool_uninit(&s->tab_mvf_pool);
79 av_buffer_pool_uninit(&s->rpl_tab_pool);
82 /* allocate arrays that depend on frame dimensions */
83 static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
85 int log2_min_cb_size = sps->log2_min_cb_size;
86 int width = sps->width;
87 int height = sps->height;
88 int pic_size_in_ctb = ((width >> log2_min_cb_size) + 1) *
89 ((height >> log2_min_cb_size) + 1);
90 int ctb_count = sps->ctb_width * sps->ctb_height;
91 int min_pu_size = sps->min_pu_width * sps->min_pu_height;
93 s->bs_width = (width >> 2) + 1;
94 s->bs_height = (height >> 2) + 1;
96 s->sao = av_mallocz_array(ctb_count, sizeof(*s->sao));
97 s->deblock = av_mallocz_array(ctb_count, sizeof(*s->deblock));
98 if (!s->sao || !s->deblock)
101 s->skip_flag = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
102 s->tab_ct_depth = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
103 if (!s->skip_flag || !s->tab_ct_depth)
106 s->cbf_luma = av_malloc_array(sps->min_tb_width, sps->min_tb_height);
107 s->tab_ipm = av_mallocz(min_pu_size);
108 s->is_pcm = av_malloc_array(sps->min_pu_width + 1, sps->min_pu_height + 1);
109 if (!s->tab_ipm || !s->cbf_luma || !s->is_pcm)
112 s->filter_slice_edges = av_mallocz(ctb_count);
113 s->tab_slice_address = av_malloc_array(pic_size_in_ctb,
114 sizeof(*s->tab_slice_address));
115 s->qp_y_tab = av_malloc_array(pic_size_in_ctb,
116 sizeof(*s->qp_y_tab));
117 if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address)
120 s->horizontal_bs = av_mallocz_array(s->bs_width, s->bs_height);
121 s->vertical_bs = av_mallocz_array(s->bs_width, s->bs_height);
122 if (!s->horizontal_bs || !s->vertical_bs)
125 s->tab_mvf_pool = av_buffer_pool_init(min_pu_size * sizeof(MvField),
127 s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab),
129 if (!s->tab_mvf_pool || !s->rpl_tab_pool)
136 return AVERROR(ENOMEM);
139 static void pred_weight_table(HEVCContext *s, GetBitContext *gb)
143 uint8_t luma_weight_l0_flag[16];
144 uint8_t chroma_weight_l0_flag[16];
145 uint8_t luma_weight_l1_flag[16];
146 uint8_t chroma_weight_l1_flag[16];
147 int luma_log2_weight_denom;
149 luma_log2_weight_denom = get_ue_golomb_long(gb);
150 if (luma_log2_weight_denom < 0 || luma_log2_weight_denom > 7)
151 av_log(s->avctx, AV_LOG_ERROR, "luma_log2_weight_denom %d is invalid\n", luma_log2_weight_denom);
152 s->sh.luma_log2_weight_denom = av_clip_uintp2(luma_log2_weight_denom, 3);
153 if (s->ps.sps->chroma_format_idc != 0) {
154 int delta = get_se_golomb(gb);
155 s->sh.chroma_log2_weight_denom = av_clip_uintp2(s->sh.luma_log2_weight_denom + delta, 3);
158 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
159 luma_weight_l0_flag[i] = get_bits1(gb);
160 if (!luma_weight_l0_flag[i]) {
161 s->sh.luma_weight_l0[i] = 1 << s->sh.luma_log2_weight_denom;
162 s->sh.luma_offset_l0[i] = 0;
165 if (s->ps.sps->chroma_format_idc != 0) {
166 for (i = 0; i < s->sh.nb_refs[L0]; i++)
167 chroma_weight_l0_flag[i] = get_bits1(gb);
169 for (i = 0; i < s->sh.nb_refs[L0]; i++)
170 chroma_weight_l0_flag[i] = 0;
172 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
173 if (luma_weight_l0_flag[i]) {
174 int delta_luma_weight_l0 = get_se_golomb(gb);
175 s->sh.luma_weight_l0[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;
176 s->sh.luma_offset_l0[i] = get_se_golomb(gb);
178 if (chroma_weight_l0_flag[i]) {
179 for (j = 0; j < 2; j++) {
180 int delta_chroma_weight_l0 = get_se_golomb(gb);
181 int delta_chroma_offset_l0 = get_se_golomb(gb);
182 s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
183 s->sh.chroma_offset_l0[i][j] = av_clip((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j])
184 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
187 s->sh.chroma_weight_l0[i][0] = 1 << s->sh.chroma_log2_weight_denom;
188 s->sh.chroma_offset_l0[i][0] = 0;
189 s->sh.chroma_weight_l0[i][1] = 1 << s->sh.chroma_log2_weight_denom;
190 s->sh.chroma_offset_l0[i][1] = 0;
193 if (s->sh.slice_type == B_SLICE) {
194 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
195 luma_weight_l1_flag[i] = get_bits1(gb);
196 if (!luma_weight_l1_flag[i]) {
197 s->sh.luma_weight_l1[i] = 1 << s->sh.luma_log2_weight_denom;
198 s->sh.luma_offset_l1[i] = 0;
201 if (s->ps.sps->chroma_format_idc != 0) {
202 for (i = 0; i < s->sh.nb_refs[L1]; i++)
203 chroma_weight_l1_flag[i] = get_bits1(gb);
205 for (i = 0; i < s->sh.nb_refs[L1]; i++)
206 chroma_weight_l1_flag[i] = 0;
208 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
209 if (luma_weight_l1_flag[i]) {
210 int delta_luma_weight_l1 = get_se_golomb(gb);
211 s->sh.luma_weight_l1[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;
212 s->sh.luma_offset_l1[i] = get_se_golomb(gb);
214 if (chroma_weight_l1_flag[i]) {
215 for (j = 0; j < 2; j++) {
216 int delta_chroma_weight_l1 = get_se_golomb(gb);
217 int delta_chroma_offset_l1 = get_se_golomb(gb);
218 s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
219 s->sh.chroma_offset_l1[i][j] = av_clip((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j])
220 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
223 s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom;
224 s->sh.chroma_offset_l1[i][0] = 0;
225 s->sh.chroma_weight_l1[i][1] = 1 << s->sh.chroma_log2_weight_denom;
226 s->sh.chroma_offset_l1[i][1] = 0;
232 static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
234 const HEVCSPS *sps = s->ps.sps;
235 int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
236 int prev_delta_msb = 0;
237 unsigned int nb_sps = 0, nb_sh;
241 if (!sps->long_term_ref_pics_present_flag)
244 if (sps->num_long_term_ref_pics_sps > 0)
245 nb_sps = get_ue_golomb_long(gb);
246 nb_sh = get_ue_golomb_long(gb);
248 if (nb_sh + (uint64_t)nb_sps > FF_ARRAY_ELEMS(rps->poc))
249 return AVERROR_INVALIDDATA;
251 rps->nb_refs = nb_sh + nb_sps;
253 for (i = 0; i < rps->nb_refs; i++) {
254 uint8_t delta_poc_msb_present;
257 uint8_t lt_idx_sps = 0;
259 if (sps->num_long_term_ref_pics_sps > 1)
260 lt_idx_sps = get_bits(gb, av_ceil_log2(sps->num_long_term_ref_pics_sps));
262 rps->poc[i] = sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
263 rps->used[i] = sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];
265 rps->poc[i] = get_bits(gb, sps->log2_max_poc_lsb);
266 rps->used[i] = get_bits1(gb);
269 delta_poc_msb_present = get_bits1(gb);
270 if (delta_poc_msb_present) {
271 int delta = get_ue_golomb_long(gb);
273 if (i && i != nb_sps)
274 delta += prev_delta_msb;
276 rps->poc[i] += s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
277 prev_delta_msb = delta;
284 static void export_stream_params(AVCodecContext *avctx, const HEVCParamSets *ps,
287 const HEVCVPS *vps = (const HEVCVPS*)ps->vps_list[sps->vps_id]->data;
288 unsigned int num = 0, den = 0;
290 avctx->pix_fmt = sps->pix_fmt;
291 avctx->coded_width = sps->width;
292 avctx->coded_height = sps->height;
293 avctx->width = sps->output_width;
294 avctx->height = sps->output_height;
295 avctx->has_b_frames = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics;
296 avctx->profile = sps->ptl.general_ptl.profile_idc;
297 avctx->level = sps->ptl.general_ptl.level_idc;
299 ff_set_sar(avctx, sps->vui.sar);
301 if (sps->vui.video_signal_type_present_flag)
302 avctx->color_range = sps->vui.video_full_range_flag ? AVCOL_RANGE_JPEG
305 avctx->color_range = AVCOL_RANGE_MPEG;
307 if (sps->vui.colour_description_present_flag) {
308 avctx->color_primaries = sps->vui.colour_primaries;
309 avctx->color_trc = sps->vui.transfer_characteristic;
310 avctx->colorspace = sps->vui.matrix_coeffs;
312 avctx->color_primaries = AVCOL_PRI_UNSPECIFIED;
313 avctx->color_trc = AVCOL_TRC_UNSPECIFIED;
314 avctx->colorspace = AVCOL_SPC_UNSPECIFIED;
317 if (vps->vps_timing_info_present_flag) {
318 num = vps->vps_num_units_in_tick;
319 den = vps->vps_time_scale;
320 } else if (sps->vui.vui_timing_info_present_flag) {
321 num = sps->vui.vui_num_units_in_tick;
322 den = sps->vui.vui_time_scale;
325 if (num != 0 && den != 0)
326 av_reduce(&avctx->framerate.den, &avctx->framerate.num,
330 static int set_sps(HEVCContext *s, const HEVCSPS *sps, enum AVPixelFormat pix_fmt)
332 #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + CONFIG_HEVC_D3D11VA_HWACCEL + CONFIG_HEVC_VAAPI_HWACCEL + CONFIG_HEVC_VDPAU_HWACCEL)
333 enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
343 ret = pic_arrays_init(s, sps);
347 export_stream_params(s->avctx, &s->ps, sps);
349 switch (sps->pix_fmt) {
350 case AV_PIX_FMT_YUV420P:
351 case AV_PIX_FMT_YUVJ420P:
352 #if CONFIG_HEVC_DXVA2_HWACCEL
353 *fmt++ = AV_PIX_FMT_DXVA2_VLD;
355 #if CONFIG_HEVC_D3D11VA_HWACCEL
356 *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
358 #if CONFIG_HEVC_VAAPI_HWACCEL
359 *fmt++ = AV_PIX_FMT_VAAPI;
361 #if CONFIG_HEVC_VDPAU_HWACCEL
362 *fmt++ = AV_PIX_FMT_VDPAU;
365 case AV_PIX_FMT_YUV420P10:
366 #if CONFIG_HEVC_DXVA2_HWACCEL
367 *fmt++ = AV_PIX_FMT_DXVA2_VLD;
369 #if CONFIG_HEVC_D3D11VA_HWACCEL
370 *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
372 #if CONFIG_HEVC_VAAPI_HWACCEL
373 *fmt++ = AV_PIX_FMT_VAAPI;
378 if (pix_fmt == AV_PIX_FMT_NONE) {
379 *fmt++ = sps->pix_fmt;
380 *fmt = AV_PIX_FMT_NONE;
382 ret = ff_thread_get_format(s->avctx, pix_fmts);
385 s->avctx->pix_fmt = ret;
388 s->avctx->pix_fmt = pix_fmt;
391 ff_hevc_pred_init(&s->hpc, sps->bit_depth);
392 ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
393 ff_videodsp_init (&s->vdsp, sps->bit_depth);
395 for (i = 0; i < 3; i++) {
396 av_freep(&s->sao_pixel_buffer_h[i]);
397 av_freep(&s->sao_pixel_buffer_v[i]);
400 if (sps->sao_enabled && !s->avctx->hwaccel) {
401 int c_count = (sps->chroma_format_idc != 0) ? 3 : 1;
404 for(c_idx = 0; c_idx < c_count; c_idx++) {
405 int w = sps->width >> sps->hshift[c_idx];
406 int h = sps->height >> sps->vshift[c_idx];
407 s->sao_pixel_buffer_h[c_idx] =
408 av_malloc((w * 2 * sps->ctb_height) <<
410 s->sao_pixel_buffer_v[c_idx] =
411 av_malloc((h * 2 * sps->ctb_width) <<
417 s->ps.vps = (HEVCVPS*) s->ps.vps_list[s->ps.sps->vps_id]->data;
427 static int hls_slice_header(HEVCContext *s)
429 GetBitContext *gb = &s->HEVClc->gb;
430 SliceHeader *sh = &s->sh;
434 sh->first_slice_in_pic_flag = get_bits1(gb);
435 if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
436 s->seq_decode = (s->seq_decode + 1) & 0xff;
439 ff_hevc_clear_refs(s);
441 sh->no_output_of_prior_pics_flag = 0;
443 sh->no_output_of_prior_pics_flag = get_bits1(gb);
445 sh->pps_id = get_ue_golomb_long(gb);
446 if (sh->pps_id >= MAX_PPS_COUNT || !s->ps.pps_list[sh->pps_id]) {
447 av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
448 return AVERROR_INVALIDDATA;
450 if (!sh->first_slice_in_pic_flag &&
451 s->ps.pps != (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data) {
452 av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
453 return AVERROR_INVALIDDATA;
455 s->ps.pps = (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data;
456 if (s->nal_unit_type == NAL_CRA_NUT && s->last_eos == 1)
457 sh->no_output_of_prior_pics_flag = 1;
459 if (s->ps.sps != (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data) {
460 const HEVCSPS* last_sps = s->ps.sps;
461 s->ps.sps = (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data;
462 if (last_sps && IS_IRAP(s) && s->nal_unit_type != NAL_CRA_NUT) {
463 if (s->ps.sps->width != last_sps->width || s->ps.sps->height != last_sps->height ||
464 s->ps.sps->temporal_layer[s->ps.sps->max_sub_layers - 1].max_dec_pic_buffering !=
465 last_sps->temporal_layer[last_sps->max_sub_layers - 1].max_dec_pic_buffering)
466 sh->no_output_of_prior_pics_flag = 0;
468 ff_hevc_clear_refs(s);
469 ret = set_sps(s, s->ps.sps, AV_PIX_FMT_NONE);
473 s->seq_decode = (s->seq_decode + 1) & 0xff;
477 sh->dependent_slice_segment_flag = 0;
478 if (!sh->first_slice_in_pic_flag) {
479 int slice_address_length;
481 if (s->ps.pps->dependent_slice_segments_enabled_flag)
482 sh->dependent_slice_segment_flag = get_bits1(gb);
484 slice_address_length = av_ceil_log2(s->ps.sps->ctb_width *
485 s->ps.sps->ctb_height);
486 sh->slice_segment_addr = get_bitsz(gb, slice_address_length);
487 if (sh->slice_segment_addr >= s->ps.sps->ctb_width * s->ps.sps->ctb_height) {
488 av_log(s->avctx, AV_LOG_ERROR,
489 "Invalid slice segment address: %u.\n",
490 sh->slice_segment_addr);
491 return AVERROR_INVALIDDATA;
494 if (!sh->dependent_slice_segment_flag) {
495 sh->slice_addr = sh->slice_segment_addr;
499 sh->slice_segment_addr = sh->slice_addr = 0;
501 s->slice_initialized = 0;
504 if (!sh->dependent_slice_segment_flag) {
505 s->slice_initialized = 0;
507 for (i = 0; i < s->ps.pps->num_extra_slice_header_bits; i++)
508 skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
510 sh->slice_type = get_ue_golomb_long(gb);
511 if (!(sh->slice_type == I_SLICE ||
512 sh->slice_type == P_SLICE ||
513 sh->slice_type == B_SLICE)) {
514 av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
516 return AVERROR_INVALIDDATA;
518 if (IS_IRAP(s) && sh->slice_type != I_SLICE) {
519 av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
520 return AVERROR_INVALIDDATA;
523 // when flag is not present, picture is inferred to be output
524 sh->pic_output_flag = 1;
525 if (s->ps.pps->output_flag_present_flag)
526 sh->pic_output_flag = get_bits1(gb);
528 if (s->ps.sps->separate_colour_plane_flag)
529 sh->colour_plane_id = get_bits(gb, 2);
534 sh->pic_order_cnt_lsb = get_bits(gb, s->ps.sps->log2_max_poc_lsb);
535 poc = ff_hevc_compute_poc(s, sh->pic_order_cnt_lsb);
536 if (!sh->first_slice_in_pic_flag && poc != s->poc) {
537 av_log(s->avctx, AV_LOG_WARNING,
538 "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
539 if (s->avctx->err_recognition & AV_EF_EXPLODE)
540 return AVERROR_INVALIDDATA;
545 sh->short_term_ref_pic_set_sps_flag = get_bits1(gb);
546 pos = get_bits_left(gb);
547 if (!sh->short_term_ref_pic_set_sps_flag) {
548 ret = ff_hevc_decode_short_term_rps(gb, s->avctx, &sh->slice_rps, s->ps.sps, 1);
552 sh->short_term_rps = &sh->slice_rps;
554 int numbits, rps_idx;
556 if (!s->ps.sps->nb_st_rps) {
557 av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
558 return AVERROR_INVALIDDATA;
561 numbits = av_ceil_log2(s->ps.sps->nb_st_rps);
562 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
563 sh->short_term_rps = &s->ps.sps->st_rps[rps_idx];
565 sh->short_term_ref_pic_set_size = pos - get_bits_left(gb);
567 pos = get_bits_left(gb);
568 ret = decode_lt_rps(s, &sh->long_term_rps, gb);
570 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
571 if (s->avctx->err_recognition & AV_EF_EXPLODE)
572 return AVERROR_INVALIDDATA;
574 sh->long_term_ref_pic_set_size = pos - get_bits_left(gb);
576 if (s->ps.sps->sps_temporal_mvp_enabled_flag)
577 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
579 sh->slice_temporal_mvp_enabled_flag = 0;
581 s->sh.short_term_rps = NULL;
586 if (s->temporal_id == 0 &&
587 s->nal_unit_type != NAL_TRAIL_N &&
588 s->nal_unit_type != NAL_TSA_N &&
589 s->nal_unit_type != NAL_STSA_N &&
590 s->nal_unit_type != NAL_RADL_N &&
591 s->nal_unit_type != NAL_RADL_R &&
592 s->nal_unit_type != NAL_RASL_N &&
593 s->nal_unit_type != NAL_RASL_R)
596 if (s->ps.sps->sao_enabled) {
597 sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
598 if (s->ps.sps->chroma_format_idc) {
599 sh->slice_sample_adaptive_offset_flag[1] =
600 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
603 sh->slice_sample_adaptive_offset_flag[0] = 0;
604 sh->slice_sample_adaptive_offset_flag[1] = 0;
605 sh->slice_sample_adaptive_offset_flag[2] = 0;
608 sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
609 if (sh->slice_type == P_SLICE || sh->slice_type == B_SLICE) {
612 sh->nb_refs[L0] = s->ps.pps->num_ref_idx_l0_default_active;
613 if (sh->slice_type == B_SLICE)
614 sh->nb_refs[L1] = s->ps.pps->num_ref_idx_l1_default_active;
616 if (get_bits1(gb)) { // num_ref_idx_active_override_flag
617 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
618 if (sh->slice_type == B_SLICE)
619 sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
621 if (sh->nb_refs[L0] > MAX_REFS || sh->nb_refs[L1] > MAX_REFS) {
622 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
623 sh->nb_refs[L0], sh->nb_refs[L1]);
624 return AVERROR_INVALIDDATA;
627 sh->rpl_modification_flag[0] = 0;
628 sh->rpl_modification_flag[1] = 0;
629 nb_refs = ff_hevc_frame_nb_refs(s);
631 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
632 return AVERROR_INVALIDDATA;
635 if (s->ps.pps->lists_modification_present_flag && nb_refs > 1) {
636 sh->rpl_modification_flag[0] = get_bits1(gb);
637 if (sh->rpl_modification_flag[0]) {
638 for (i = 0; i < sh->nb_refs[L0]; i++)
639 sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
642 if (sh->slice_type == B_SLICE) {
643 sh->rpl_modification_flag[1] = get_bits1(gb);
644 if (sh->rpl_modification_flag[1] == 1)
645 for (i = 0; i < sh->nb_refs[L1]; i++)
646 sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
650 if (sh->slice_type == B_SLICE)
651 sh->mvd_l1_zero_flag = get_bits1(gb);
653 if (s->ps.pps->cabac_init_present_flag)
654 sh->cabac_init_flag = get_bits1(gb);
656 sh->cabac_init_flag = 0;
658 sh->collocated_ref_idx = 0;
659 if (sh->slice_temporal_mvp_enabled_flag) {
660 sh->collocated_list = L0;
661 if (sh->slice_type == B_SLICE)
662 sh->collocated_list = !get_bits1(gb);
664 if (sh->nb_refs[sh->collocated_list] > 1) {
665 sh->collocated_ref_idx = get_ue_golomb_long(gb);
666 if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
667 av_log(s->avctx, AV_LOG_ERROR,
668 "Invalid collocated_ref_idx: %d.\n",
669 sh->collocated_ref_idx);
670 return AVERROR_INVALIDDATA;
675 if ((s->ps.pps->weighted_pred_flag && sh->slice_type == P_SLICE) ||
676 (s->ps.pps->weighted_bipred_flag && sh->slice_type == B_SLICE)) {
677 pred_weight_table(s, gb);
680 sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
681 if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
682 av_log(s->avctx, AV_LOG_ERROR,
683 "Invalid number of merging MVP candidates: %d.\n",
684 sh->max_num_merge_cand);
685 return AVERROR_INVALIDDATA;
689 sh->slice_qp_delta = get_se_golomb(gb);
691 if (s->ps.pps->pic_slice_level_chroma_qp_offsets_present_flag) {
692 sh->slice_cb_qp_offset = get_se_golomb(gb);
693 sh->slice_cr_qp_offset = get_se_golomb(gb);
695 sh->slice_cb_qp_offset = 0;
696 sh->slice_cr_qp_offset = 0;
699 if (s->ps.pps->chroma_qp_offset_list_enabled_flag)
700 sh->cu_chroma_qp_offset_enabled_flag = get_bits1(gb);
702 sh->cu_chroma_qp_offset_enabled_flag = 0;
704 if (s->ps.pps->deblocking_filter_control_present_flag) {
705 int deblocking_filter_override_flag = 0;
707 if (s->ps.pps->deblocking_filter_override_enabled_flag)
708 deblocking_filter_override_flag = get_bits1(gb);
710 if (deblocking_filter_override_flag) {
711 sh->disable_deblocking_filter_flag = get_bits1(gb);
712 if (!sh->disable_deblocking_filter_flag) {
713 sh->beta_offset = get_se_golomb(gb) * 2;
714 sh->tc_offset = get_se_golomb(gb) * 2;
717 sh->disable_deblocking_filter_flag = s->ps.pps->disable_dbf;
718 sh->beta_offset = s->ps.pps->beta_offset;
719 sh->tc_offset = s->ps.pps->tc_offset;
722 sh->disable_deblocking_filter_flag = 0;
727 if (s->ps.pps->seq_loop_filter_across_slices_enabled_flag &&
728 (sh->slice_sample_adaptive_offset_flag[0] ||
729 sh->slice_sample_adaptive_offset_flag[1] ||
730 !sh->disable_deblocking_filter_flag)) {
731 sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
733 sh->slice_loop_filter_across_slices_enabled_flag = s->ps.pps->seq_loop_filter_across_slices_enabled_flag;
735 } else if (!s->slice_initialized) {
736 av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
737 return AVERROR_INVALIDDATA;
740 sh->num_entry_point_offsets = 0;
741 if (s->ps.pps->tiles_enabled_flag || s->ps.pps->entropy_coding_sync_enabled_flag) {
742 unsigned num_entry_point_offsets = get_ue_golomb_long(gb);
743 // It would be possible to bound this tighter but this here is simpler
744 if (num_entry_point_offsets > get_bits_left(gb)) {
745 av_log(s->avctx, AV_LOG_ERROR, "num_entry_point_offsets %d is invalid\n", num_entry_point_offsets);
746 return AVERROR_INVALIDDATA;
749 sh->num_entry_point_offsets = num_entry_point_offsets;
750 if (sh->num_entry_point_offsets > 0) {
751 int offset_len = get_ue_golomb_long(gb) + 1;
753 if (offset_len < 1 || offset_len > 32) {
754 sh->num_entry_point_offsets = 0;
755 av_log(s->avctx, AV_LOG_ERROR, "offset_len %d is invalid\n", offset_len);
756 return AVERROR_INVALIDDATA;
759 av_freep(&sh->entry_point_offset);
760 av_freep(&sh->offset);
762 sh->entry_point_offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(unsigned));
763 sh->offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
764 sh->size = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
765 if (!sh->entry_point_offset || !sh->offset || !sh->size) {
766 sh->num_entry_point_offsets = 0;
767 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate memory\n");
768 return AVERROR(ENOMEM);
770 for (i = 0; i < sh->num_entry_point_offsets; i++) {
771 unsigned val = get_bits_long(gb, offset_len);
772 sh->entry_point_offset[i] = val + 1; // +1; // +1 to get the size
774 if (s->threads_number > 1 && (s->ps.pps->num_tile_rows > 1 || s->ps.pps->num_tile_columns > 1)) {
775 s->enable_parallel_tiles = 0; // TODO: you can enable tiles in parallel here
776 s->threads_number = 1;
778 s->enable_parallel_tiles = 0;
780 s->enable_parallel_tiles = 0;
783 if (s->ps.pps->slice_header_extension_present_flag) {
784 unsigned int length = get_ue_golomb_long(gb);
785 if (length*8LL > get_bits_left(gb)) {
786 av_log(s->avctx, AV_LOG_ERROR, "too many slice_header_extension_data_bytes\n");
787 return AVERROR_INVALIDDATA;
789 for (i = 0; i < length; i++)
790 skip_bits(gb, 8); // slice_header_extension_data_byte
793 // Inferred parameters
794 sh->slice_qp = 26U + s->ps.pps->pic_init_qp_minus26 + sh->slice_qp_delta;
795 if (sh->slice_qp > 51 ||
796 sh->slice_qp < -s->ps.sps->qp_bd_offset) {
797 av_log(s->avctx, AV_LOG_ERROR,
798 "The slice_qp %d is outside the valid range "
801 -s->ps.sps->qp_bd_offset);
802 return AVERROR_INVALIDDATA;
805 sh->slice_ctb_addr_rs = sh->slice_segment_addr;
807 if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) {
808 av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
809 return AVERROR_INVALIDDATA;
812 if (get_bits_left(gb) < 0) {
813 av_log(s->avctx, AV_LOG_ERROR,
814 "Overread slice header by %d bits\n", -get_bits_left(gb));
815 return AVERROR_INVALIDDATA;
818 s->HEVClc->first_qp_group = !s->sh.dependent_slice_segment_flag;
820 if (!s->ps.pps->cu_qp_delta_enabled_flag)
821 s->HEVClc->qp_y = s->sh.slice_qp;
823 s->slice_initialized = 1;
824 s->HEVClc->tu.cu_qp_offset_cb = 0;
825 s->HEVClc->tu.cu_qp_offset_cr = 0;
827 s->no_rasl_output_flag = IS_IDR(s) || IS_BLA(s) || (s->nal_unit_type == NAL_CRA_NUT && s->last_eos);
832 #define CTB(tab, x, y) ((tab)[(y) * s->ps.sps->ctb_width + (x)])
834 #define SET_SAO(elem, value) \
836 if (!sao_merge_up_flag && !sao_merge_left_flag) \
838 else if (sao_merge_left_flag) \
839 sao->elem = CTB(s->sao, rx-1, ry).elem; \
840 else if (sao_merge_up_flag) \
841 sao->elem = CTB(s->sao, rx, ry-1).elem; \
846 static void hls_sao_param(HEVCContext *s, int rx, int ry)
848 HEVCLocalContext *lc = s->HEVClc;
849 int sao_merge_left_flag = 0;
850 int sao_merge_up_flag = 0;
851 SAOParams *sao = &CTB(s->sao, rx, ry);
854 if (s->sh.slice_sample_adaptive_offset_flag[0] ||
855 s->sh.slice_sample_adaptive_offset_flag[1]) {
857 if (lc->ctb_left_flag)
858 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
860 if (ry > 0 && !sao_merge_left_flag) {
862 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
866 for (c_idx = 0; c_idx < (s->ps.sps->chroma_format_idc ? 3 : 1); c_idx++) {
867 int log2_sao_offset_scale = c_idx == 0 ? s->ps.pps->log2_sao_offset_scale_luma :
868 s->ps.pps->log2_sao_offset_scale_chroma;
870 if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
871 sao->type_idx[c_idx] = SAO_NOT_APPLIED;
876 sao->type_idx[2] = sao->type_idx[1];
877 sao->eo_class[2] = sao->eo_class[1];
879 SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
882 if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
885 for (i = 0; i < 4; i++)
886 SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
888 if (sao->type_idx[c_idx] == SAO_BAND) {
889 for (i = 0; i < 4; i++) {
890 if (sao->offset_abs[c_idx][i]) {
891 SET_SAO(offset_sign[c_idx][i],
892 ff_hevc_sao_offset_sign_decode(s));
894 sao->offset_sign[c_idx][i] = 0;
897 SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
898 } else if (c_idx != 2) {
899 SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
902 // Inferred parameters
903 sao->offset_val[c_idx][0] = 0;
904 for (i = 0; i < 4; i++) {
905 sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i];
906 if (sao->type_idx[c_idx] == SAO_EDGE) {
908 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
909 } else if (sao->offset_sign[c_idx][i]) {
910 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
912 sao->offset_val[c_idx][i + 1] *= 1 << log2_sao_offset_scale;
920 static int hls_cross_component_pred(HEVCContext *s, int idx) {
921 HEVCLocalContext *lc = s->HEVClc;
922 int log2_res_scale_abs_plus1 = ff_hevc_log2_res_scale_abs(s, idx);
924 if (log2_res_scale_abs_plus1 != 0) {
925 int res_scale_sign_flag = ff_hevc_res_scale_sign_flag(s, idx);
926 lc->tu.res_scale_val = (1 << (log2_res_scale_abs_plus1 - 1)) *
927 (1 - 2 * res_scale_sign_flag);
929 lc->tu.res_scale_val = 0;
936 static int hls_transform_unit(HEVCContext *s, int x0, int y0,
937 int xBase, int yBase, int cb_xBase, int cb_yBase,
938 int log2_cb_size, int log2_trafo_size,
939 int blk_idx, int cbf_luma, int *cbf_cb, int *cbf_cr)
941 HEVCLocalContext *lc = s->HEVClc;
942 const int log2_trafo_size_c = log2_trafo_size - s->ps.sps->hshift[1];
945 if (lc->cu.pred_mode == MODE_INTRA) {
946 int trafo_size = 1 << log2_trafo_size;
947 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
949 s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
952 if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
953 (s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
954 int scan_idx = SCAN_DIAG;
955 int scan_idx_c = SCAN_DIAG;
956 int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
957 (s->ps.sps->chroma_format_idc == 2 &&
958 (cbf_cb[1] || cbf_cr[1]));
960 if (s->ps.pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
961 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
962 if (lc->tu.cu_qp_delta != 0)
963 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
964 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
965 lc->tu.is_cu_qp_delta_coded = 1;
967 if (lc->tu.cu_qp_delta < -(26 + s->ps.sps->qp_bd_offset / 2) ||
968 lc->tu.cu_qp_delta > (25 + s->ps.sps->qp_bd_offset / 2)) {
969 av_log(s->avctx, AV_LOG_ERROR,
970 "The cu_qp_delta %d is outside the valid range "
973 -(26 + s->ps.sps->qp_bd_offset / 2),
974 (25 + s->ps.sps->qp_bd_offset / 2));
975 return AVERROR_INVALIDDATA;
978 ff_hevc_set_qPy(s, cb_xBase, cb_yBase, log2_cb_size);
981 if (s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
982 !lc->cu.cu_transquant_bypass_flag && !lc->tu.is_cu_chroma_qp_offset_coded) {
983 int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(s);
984 if (cu_chroma_qp_offset_flag) {
985 int cu_chroma_qp_offset_idx = 0;
986 if (s->ps.pps->chroma_qp_offset_list_len_minus1 > 0) {
987 cu_chroma_qp_offset_idx = ff_hevc_cu_chroma_qp_offset_idx(s);
988 av_log(s->avctx, AV_LOG_ERROR,
989 "cu_chroma_qp_offset_idx not yet tested.\n");
991 lc->tu.cu_qp_offset_cb = s->ps.pps->cb_qp_offset_list[cu_chroma_qp_offset_idx];
992 lc->tu.cu_qp_offset_cr = s->ps.pps->cr_qp_offset_list[cu_chroma_qp_offset_idx];
994 lc->tu.cu_qp_offset_cb = 0;
995 lc->tu.cu_qp_offset_cr = 0;
997 lc->tu.is_cu_chroma_qp_offset_coded = 1;
1000 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
1001 if (lc->tu.intra_pred_mode >= 6 &&
1002 lc->tu.intra_pred_mode <= 14) {
1003 scan_idx = SCAN_VERT;
1004 } else if (lc->tu.intra_pred_mode >= 22 &&
1005 lc->tu.intra_pred_mode <= 30) {
1006 scan_idx = SCAN_HORIZ;
1009 if (lc->tu.intra_pred_mode_c >= 6 &&
1010 lc->tu.intra_pred_mode_c <= 14) {
1011 scan_idx_c = SCAN_VERT;
1012 } else if (lc->tu.intra_pred_mode_c >= 22 &&
1013 lc->tu.intra_pred_mode_c <= 30) {
1014 scan_idx_c = SCAN_HORIZ;
1018 lc->tu.cross_pf = 0;
1021 ff_hevc_hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
1022 if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) {
1023 int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]);
1024 int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]);
1025 lc->tu.cross_pf = (s->ps.pps->cross_component_prediction_enabled_flag && cbf_luma &&
1026 (lc->cu.pred_mode == MODE_INTER ||
1027 (lc->tu.chroma_mode_c == 4)));
1029 if (lc->tu.cross_pf) {
1030 hls_cross_component_pred(s, 0);
1032 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1033 if (lc->cu.pred_mode == MODE_INTRA) {
1034 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1035 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 1);
1038 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1039 log2_trafo_size_c, scan_idx_c, 1);
1041 if (lc->tu.cross_pf) {
1042 ptrdiff_t stride = s->frame->linesize[1];
1043 int hshift = s->ps.sps->hshift[1];
1044 int vshift = s->ps.sps->vshift[1];
1045 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1046 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1047 int size = 1 << log2_trafo_size_c;
1049 uint8_t *dst = &s->frame->data[1][(y0 >> vshift) * stride +
1050 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1051 for (i = 0; i < (size * size); i++) {
1052 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1054 s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
1058 if (lc->tu.cross_pf) {
1059 hls_cross_component_pred(s, 1);
1061 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1062 if (lc->cu.pred_mode == MODE_INTRA) {
1063 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1064 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 2);
1067 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1068 log2_trafo_size_c, scan_idx_c, 2);
1070 if (lc->tu.cross_pf) {
1071 ptrdiff_t stride = s->frame->linesize[2];
1072 int hshift = s->ps.sps->hshift[2];
1073 int vshift = s->ps.sps->vshift[2];
1074 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1075 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1076 int size = 1 << log2_trafo_size_c;
1078 uint8_t *dst = &s->frame->data[2][(y0 >> vshift) * stride +
1079 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1080 for (i = 0; i < (size * size); i++) {
1081 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1083 s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
1086 } else if (s->ps.sps->chroma_format_idc && blk_idx == 3) {
1087 int trafo_size_h = 1 << (log2_trafo_size + 1);
1088 int trafo_size_v = 1 << (log2_trafo_size + s->ps.sps->vshift[1]);
1089 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1090 if (lc->cu.pred_mode == MODE_INTRA) {
1091 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1092 trafo_size_h, trafo_size_v);
1093 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 1);
1096 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1097 log2_trafo_size, scan_idx_c, 1);
1099 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1100 if (lc->cu.pred_mode == MODE_INTRA) {
1101 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1102 trafo_size_h, trafo_size_v);
1103 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 2);
1106 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1107 log2_trafo_size, scan_idx_c, 2);
1110 } else if (s->ps.sps->chroma_format_idc && lc->cu.pred_mode == MODE_INTRA) {
1111 if (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3) {
1112 int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]);
1113 int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]);
1114 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size_h, trafo_size_v);
1115 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 1);
1116 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 2);
1117 if (s->ps.sps->chroma_format_idc == 2) {
1118 ff_hevc_set_neighbour_available(s, x0, y0 + (1 << log2_trafo_size_c),
1119 trafo_size_h, trafo_size_v);
1120 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 1);
1121 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 2);
1123 } else if (blk_idx == 3) {
1124 int trafo_size_h = 1 << (log2_trafo_size + 1);
1125 int trafo_size_v = 1 << (log2_trafo_size + s->ps.sps->vshift[1]);
1126 ff_hevc_set_neighbour_available(s, xBase, yBase,
1127 trafo_size_h, trafo_size_v);
1128 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1129 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1130 if (s->ps.sps->chroma_format_idc == 2) {
1131 ff_hevc_set_neighbour_available(s, xBase, yBase + (1 << (log2_trafo_size)),
1132 trafo_size_h, trafo_size_v);
1133 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 1);
1134 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 2);
1142 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1144 int cb_size = 1 << log2_cb_size;
1145 int log2_min_pu_size = s->ps.sps->log2_min_pu_size;
1147 int min_pu_width = s->ps.sps->min_pu_width;
1148 int x_end = FFMIN(x0 + cb_size, s->ps.sps->width);
1149 int y_end = FFMIN(y0 + cb_size, s->ps.sps->height);
1152 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1153 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1154 s->is_pcm[i + j * min_pu_width] = 2;
1157 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1158 int xBase, int yBase, int cb_xBase, int cb_yBase,
1159 int log2_cb_size, int log2_trafo_size,
1160 int trafo_depth, int blk_idx,
1161 const int *base_cbf_cb, const int *base_cbf_cr)
1163 HEVCLocalContext *lc = s->HEVClc;
1164 uint8_t split_transform_flag;
1169 cbf_cb[0] = base_cbf_cb[0];
1170 cbf_cb[1] = base_cbf_cb[1];
1171 cbf_cr[0] = base_cbf_cr[0];
1172 cbf_cr[1] = base_cbf_cr[1];
1174 if (lc->cu.intra_split_flag) {
1175 if (trafo_depth == 1) {
1176 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1177 if (s->ps.sps->chroma_format_idc == 3) {
1178 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[blk_idx];
1179 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[blk_idx];
1181 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1182 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1186 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[0];
1187 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1188 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1191 if (log2_trafo_size <= s->ps.sps->log2_max_trafo_size &&
1192 log2_trafo_size > s->ps.sps->log2_min_tb_size &&
1193 trafo_depth < lc->cu.max_trafo_depth &&
1194 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1195 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1197 int inter_split = s->ps.sps->max_transform_hierarchy_depth_inter == 0 &&
1198 lc->cu.pred_mode == MODE_INTER &&
1199 lc->cu.part_mode != PART_2Nx2N &&
1202 split_transform_flag = log2_trafo_size > s->ps.sps->log2_max_trafo_size ||
1203 (lc->cu.intra_split_flag && trafo_depth == 0) ||
1207 if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) {
1208 if (trafo_depth == 0 || cbf_cb[0]) {
1209 cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1210 if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1211 cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1215 if (trafo_depth == 0 || cbf_cr[0]) {
1216 cbf_cr[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1217 if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1218 cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1223 if (split_transform_flag) {
1224 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1225 const int x1 = x0 + trafo_size_split;
1226 const int y1 = y0 + trafo_size_split;
1228 #define SUBDIVIDE(x, y, idx) \
1230 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1231 log2_trafo_size - 1, trafo_depth + 1, idx, \
1237 SUBDIVIDE(x0, y0, 0);
1238 SUBDIVIDE(x1, y0, 1);
1239 SUBDIVIDE(x0, y1, 2);
1240 SUBDIVIDE(x1, y1, 3);
1244 int min_tu_size = 1 << s->ps.sps->log2_min_tb_size;
1245 int log2_min_tu_size = s->ps.sps->log2_min_tb_size;
1246 int min_tu_width = s->ps.sps->min_tb_width;
1249 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1250 cbf_cb[0] || cbf_cr[0] ||
1251 (s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1252 cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1255 ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1256 log2_cb_size, log2_trafo_size,
1257 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1260 // TODO: store cbf_luma somewhere else
1263 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1264 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1265 int x_tu = (x0 + j) >> log2_min_tu_size;
1266 int y_tu = (y0 + i) >> log2_min_tu_size;
1267 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1270 if (!s->sh.disable_deblocking_filter_flag) {
1271 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1272 if (s->ps.pps->transquant_bypass_enable_flag &&
1273 lc->cu.cu_transquant_bypass_flag)
1274 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1280 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1282 HEVCLocalContext *lc = s->HEVClc;
1284 int cb_size = 1 << log2_cb_size;
1285 ptrdiff_t stride0 = s->frame->linesize[0];
1286 ptrdiff_t stride1 = s->frame->linesize[1];
1287 ptrdiff_t stride2 = s->frame->linesize[2];
1288 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->ps.sps->pixel_shift)];
1289 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)];
1290 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)];
1292 int length = cb_size * cb_size * s->ps.sps->pcm.bit_depth +
1293 (((cb_size >> s->ps.sps->hshift[1]) * (cb_size >> s->ps.sps->vshift[1])) +
1294 ((cb_size >> s->ps.sps->hshift[2]) * (cb_size >> s->ps.sps->vshift[2]))) *
1295 s->ps.sps->pcm.bit_depth_chroma;
1296 const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1299 if (!s->sh.disable_deblocking_filter_flag)
1300 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1302 ret = init_get_bits(&gb, pcm, length);
1306 s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size, &gb, s->ps.sps->pcm.bit_depth);
1307 if (s->ps.sps->chroma_format_idc) {
1308 s->hevcdsp.put_pcm(dst1, stride1,
1309 cb_size >> s->ps.sps->hshift[1],
1310 cb_size >> s->ps.sps->vshift[1],
1311 &gb, s->ps.sps->pcm.bit_depth_chroma);
1312 s->hevcdsp.put_pcm(dst2, stride2,
1313 cb_size >> s->ps.sps->hshift[2],
1314 cb_size >> s->ps.sps->vshift[2],
1315 &gb, s->ps.sps->pcm.bit_depth_chroma);
1322 * 8.5.3.2.2.1 Luma sample unidirectional interpolation process
1324 * @param s HEVC decoding context
1325 * @param dst target buffer for block data at block position
1326 * @param dststride stride of the dst buffer
1327 * @param ref reference picture buffer at origin (0, 0)
1328 * @param mv motion vector (relative to block position) to get pixel data from
1329 * @param x_off horizontal position of block from origin (0, 0)
1330 * @param y_off vertical position of block from origin (0, 0)
1331 * @param block_w width of block
1332 * @param block_h height of block
1333 * @param luma_weight weighting factor applied to the luma prediction
1334 * @param luma_offset additive offset applied to the luma prediction value
1337 static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1338 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1339 int block_w, int block_h, int luma_weight, int luma_offset)
1341 HEVCLocalContext *lc = s->HEVClc;
1342 uint8_t *src = ref->data[0];
1343 ptrdiff_t srcstride = ref->linesize[0];
1344 int pic_width = s->ps.sps->width;
1345 int pic_height = s->ps.sps->height;
1348 int weight_flag = (s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1349 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag);
1350 int idx = ff_hevc_pel_weight[block_w];
1352 x_off += mv->x >> 2;
1353 y_off += mv->y >> 2;
1354 src += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1356 if (x_off < QPEL_EXTRA_BEFORE || y_off < QPEL_EXTRA_AFTER ||
1357 x_off >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1358 y_off >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1359 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1360 int offset = QPEL_EXTRA_BEFORE * srcstride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1361 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1363 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1364 edge_emu_stride, srcstride,
1365 block_w + QPEL_EXTRA,
1366 block_h + QPEL_EXTRA,
1367 x_off - QPEL_EXTRA_BEFORE, y_off - QPEL_EXTRA_BEFORE,
1368 pic_width, pic_height);
1369 src = lc->edge_emu_buffer + buf_offset;
1370 srcstride = edge_emu_stride;
1374 s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride, src, srcstride,
1375 block_h, mx, my, block_w);
1377 s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride, src, srcstride,
1378 block_h, s->sh.luma_log2_weight_denom,
1379 luma_weight, luma_offset, mx, my, block_w);
1383 * 8.5.3.2.2.1 Luma sample bidirectional interpolation process
1385 * @param s HEVC decoding context
1386 * @param dst target buffer for block data at block position
1387 * @param dststride stride of the dst buffer
1388 * @param ref0 reference picture0 buffer at origin (0, 0)
1389 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1390 * @param x_off horizontal position of block from origin (0, 0)
1391 * @param y_off vertical position of block from origin (0, 0)
1392 * @param block_w width of block
1393 * @param block_h height of block
1394 * @param ref1 reference picture1 buffer at origin (0, 0)
1395 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1396 * @param current_mv current motion vector structure
1398 static void luma_mc_bi(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1399 AVFrame *ref0, const Mv *mv0, int x_off, int y_off,
1400 int block_w, int block_h, AVFrame *ref1, const Mv *mv1, struct MvField *current_mv)
1402 HEVCLocalContext *lc = s->HEVClc;
1403 ptrdiff_t src0stride = ref0->linesize[0];
1404 ptrdiff_t src1stride = ref1->linesize[0];
1405 int pic_width = s->ps.sps->width;
1406 int pic_height = s->ps.sps->height;
1407 int mx0 = mv0->x & 3;
1408 int my0 = mv0->y & 3;
1409 int mx1 = mv1->x & 3;
1410 int my1 = mv1->y & 3;
1411 int weight_flag = (s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1412 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag);
1413 int x_off0 = x_off + (mv0->x >> 2);
1414 int y_off0 = y_off + (mv0->y >> 2);
1415 int x_off1 = x_off + (mv1->x >> 2);
1416 int y_off1 = y_off + (mv1->y >> 2);
1417 int idx = ff_hevc_pel_weight[block_w];
1419 uint8_t *src0 = ref0->data[0] + y_off0 * src0stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift);
1420 uint8_t *src1 = ref1->data[0] + y_off1 * src1stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift);
1422 if (x_off0 < QPEL_EXTRA_BEFORE || y_off0 < QPEL_EXTRA_AFTER ||
1423 x_off0 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1424 y_off0 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1425 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1426 int offset = QPEL_EXTRA_BEFORE * src0stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1427 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1429 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset,
1430 edge_emu_stride, src0stride,
1431 block_w + QPEL_EXTRA,
1432 block_h + QPEL_EXTRA,
1433 x_off0 - QPEL_EXTRA_BEFORE, y_off0 - QPEL_EXTRA_BEFORE,
1434 pic_width, pic_height);
1435 src0 = lc->edge_emu_buffer + buf_offset;
1436 src0stride = edge_emu_stride;
1439 if (x_off1 < QPEL_EXTRA_BEFORE || y_off1 < QPEL_EXTRA_AFTER ||
1440 x_off1 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1441 y_off1 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1442 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1443 int offset = QPEL_EXTRA_BEFORE * src1stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1444 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1446 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src1 - offset,
1447 edge_emu_stride, src1stride,
1448 block_w + QPEL_EXTRA,
1449 block_h + QPEL_EXTRA,
1450 x_off1 - QPEL_EXTRA_BEFORE, y_off1 - QPEL_EXTRA_BEFORE,
1451 pic_width, pic_height);
1452 src1 = lc->edge_emu_buffer2 + buf_offset;
1453 src1stride = edge_emu_stride;
1456 s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](lc->tmp, src0, src0stride,
1457 block_h, mx0, my0, block_w);
1459 s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1460 block_h, mx1, my1, block_w);
1462 s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1463 block_h, s->sh.luma_log2_weight_denom,
1464 s->sh.luma_weight_l0[current_mv->ref_idx[0]],
1465 s->sh.luma_weight_l1[current_mv->ref_idx[1]],
1466 s->sh.luma_offset_l0[current_mv->ref_idx[0]],
1467 s->sh.luma_offset_l1[current_mv->ref_idx[1]],
1473 * 8.5.3.2.2.2 Chroma sample uniprediction interpolation process
1475 * @param s HEVC decoding context
1476 * @param dst1 target buffer for block data at block position (U plane)
1477 * @param dst2 target buffer for block data at block position (V plane)
1478 * @param dststride stride of the dst1 and dst2 buffers
1479 * @param ref reference picture buffer at origin (0, 0)
1480 * @param mv motion vector (relative to block position) to get pixel data from
1481 * @param x_off horizontal position of block from origin (0, 0)
1482 * @param y_off vertical position of block from origin (0, 0)
1483 * @param block_w width of block
1484 * @param block_h height of block
1485 * @param chroma_weight weighting factor applied to the chroma prediction
1486 * @param chroma_offset additive offset applied to the chroma prediction value
1489 static void chroma_mc_uni(HEVCContext *s, uint8_t *dst0,
1490 ptrdiff_t dststride, uint8_t *src0, ptrdiff_t srcstride, int reflist,
1491 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int chroma_weight, int chroma_offset)
1493 HEVCLocalContext *lc = s->HEVClc;
1494 int pic_width = s->ps.sps->width >> s->ps.sps->hshift[1];
1495 int pic_height = s->ps.sps->height >> s->ps.sps->vshift[1];
1496 const Mv *mv = ¤t_mv->mv[reflist];
1497 int weight_flag = (s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1498 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag);
1499 int idx = ff_hevc_pel_weight[block_w];
1500 int hshift = s->ps.sps->hshift[1];
1501 int vshift = s->ps.sps->vshift[1];
1502 intptr_t mx = av_mod_uintp2(mv->x, 2 + hshift);
1503 intptr_t my = av_mod_uintp2(mv->y, 2 + vshift);
1504 intptr_t _mx = mx << (1 - hshift);
1505 intptr_t _my = my << (1 - vshift);
1507 x_off += mv->x >> (2 + hshift);
1508 y_off += mv->y >> (2 + vshift);
1509 src0 += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1511 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1512 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1513 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1514 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1515 int offset0 = EPEL_EXTRA_BEFORE * (srcstride + (1 << s->ps.sps->pixel_shift));
1516 int buf_offset0 = EPEL_EXTRA_BEFORE *
1517 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1518 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset0,
1519 edge_emu_stride, srcstride,
1520 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1521 x_off - EPEL_EXTRA_BEFORE,
1522 y_off - EPEL_EXTRA_BEFORE,
1523 pic_width, pic_height);
1525 src0 = lc->edge_emu_buffer + buf_offset0;
1526 srcstride = edge_emu_stride;
1529 s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1530 block_h, _mx, _my, block_w);
1532 s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1533 block_h, s->sh.chroma_log2_weight_denom,
1534 chroma_weight, chroma_offset, _mx, _my, block_w);
1538 * 8.5.3.2.2.2 Chroma sample bidirectional interpolation process
1540 * @param s HEVC decoding context
1541 * @param dst target buffer for block data at block position
1542 * @param dststride stride of the dst buffer
1543 * @param ref0 reference picture0 buffer at origin (0, 0)
1544 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1545 * @param x_off horizontal position of block from origin (0, 0)
1546 * @param y_off vertical position of block from origin (0, 0)
1547 * @param block_w width of block
1548 * @param block_h height of block
1549 * @param ref1 reference picture1 buffer at origin (0, 0)
1550 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1551 * @param current_mv current motion vector structure
1552 * @param cidx chroma component(cb, cr)
1554 static void chroma_mc_bi(HEVCContext *s, uint8_t *dst0, ptrdiff_t dststride, AVFrame *ref0, AVFrame *ref1,
1555 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int cidx)
1557 HEVCLocalContext *lc = s->HEVClc;
1558 uint8_t *src1 = ref0->data[cidx+1];
1559 uint8_t *src2 = ref1->data[cidx+1];
1560 ptrdiff_t src1stride = ref0->linesize[cidx+1];
1561 ptrdiff_t src2stride = ref1->linesize[cidx+1];
1562 int weight_flag = (s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1563 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag);
1564 int pic_width = s->ps.sps->width >> s->ps.sps->hshift[1];
1565 int pic_height = s->ps.sps->height >> s->ps.sps->vshift[1];
1566 Mv *mv0 = ¤t_mv->mv[0];
1567 Mv *mv1 = ¤t_mv->mv[1];
1568 int hshift = s->ps.sps->hshift[1];
1569 int vshift = s->ps.sps->vshift[1];
1571 intptr_t mx0 = av_mod_uintp2(mv0->x, 2 + hshift);
1572 intptr_t my0 = av_mod_uintp2(mv0->y, 2 + vshift);
1573 intptr_t mx1 = av_mod_uintp2(mv1->x, 2 + hshift);
1574 intptr_t my1 = av_mod_uintp2(mv1->y, 2 + vshift);
1575 intptr_t _mx0 = mx0 << (1 - hshift);
1576 intptr_t _my0 = my0 << (1 - vshift);
1577 intptr_t _mx1 = mx1 << (1 - hshift);
1578 intptr_t _my1 = my1 << (1 - vshift);
1580 int x_off0 = x_off + (mv0->x >> (2 + hshift));
1581 int y_off0 = y_off + (mv0->y >> (2 + vshift));
1582 int x_off1 = x_off + (mv1->x >> (2 + hshift));
1583 int y_off1 = y_off + (mv1->y >> (2 + vshift));
1584 int idx = ff_hevc_pel_weight[block_w];
1585 src1 += y_off0 * src1stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift);
1586 src2 += y_off1 * src2stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift);
1588 if (x_off0 < EPEL_EXTRA_BEFORE || y_off0 < EPEL_EXTRA_AFTER ||
1589 x_off0 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1590 y_off0 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1591 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1592 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->ps.sps->pixel_shift));
1593 int buf_offset1 = EPEL_EXTRA_BEFORE *
1594 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1596 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1597 edge_emu_stride, src1stride,
1598 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1599 x_off0 - EPEL_EXTRA_BEFORE,
1600 y_off0 - EPEL_EXTRA_BEFORE,
1601 pic_width, pic_height);
1603 src1 = lc->edge_emu_buffer + buf_offset1;
1604 src1stride = edge_emu_stride;
1607 if (x_off1 < EPEL_EXTRA_BEFORE || y_off1 < EPEL_EXTRA_AFTER ||
1608 x_off1 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1609 y_off1 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1610 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1611 int offset1 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->ps.sps->pixel_shift));
1612 int buf_offset1 = EPEL_EXTRA_BEFORE *
1613 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1615 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src2 - offset1,
1616 edge_emu_stride, src2stride,
1617 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1618 x_off1 - EPEL_EXTRA_BEFORE,
1619 y_off1 - EPEL_EXTRA_BEFORE,
1620 pic_width, pic_height);
1622 src2 = lc->edge_emu_buffer2 + buf_offset1;
1623 src2stride = edge_emu_stride;
1626 s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](lc->tmp, src1, src1stride,
1627 block_h, _mx0, _my0, block_w);
1629 s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1630 src2, src2stride, lc->tmp,
1631 block_h, _mx1, _my1, block_w);
1633 s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1634 src2, src2stride, lc->tmp,
1636 s->sh.chroma_log2_weight_denom,
1637 s->sh.chroma_weight_l0[current_mv->ref_idx[0]][cidx],
1638 s->sh.chroma_weight_l1[current_mv->ref_idx[1]][cidx],
1639 s->sh.chroma_offset_l0[current_mv->ref_idx[0]][cidx],
1640 s->sh.chroma_offset_l1[current_mv->ref_idx[1]][cidx],
1641 _mx1, _my1, block_w);
1644 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1645 const Mv *mv, int y0, int height)
1647 int y = FFMAX(0, (mv->y >> 2) + y0 + height + 9);
1649 if (s->threads_type == FF_THREAD_FRAME )
1650 ff_thread_await_progress(&ref->tf, y, 0);
1653 static void hevc_luma_mv_mvp_mode(HEVCContext *s, int x0, int y0, int nPbW,
1654 int nPbH, int log2_cb_size, int part_idx,
1655 int merge_idx, MvField *mv)
1657 HEVCLocalContext *lc = s->HEVClc;
1658 enum InterPredIdc inter_pred_idc = PRED_L0;
1661 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1663 if (s->sh.slice_type == B_SLICE)
1664 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1666 if (inter_pred_idc != PRED_L1) {
1667 if (s->sh.nb_refs[L0])
1668 mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1670 mv->pred_flag = PF_L0;
1671 ff_hevc_hls_mvd_coding(s, x0, y0, 0);
1672 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1673 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1674 part_idx, merge_idx, mv, mvp_flag, 0);
1675 mv->mv[0].x += lc->pu.mvd.x;
1676 mv->mv[0].y += lc->pu.mvd.y;
1679 if (inter_pred_idc != PRED_L0) {
1680 if (s->sh.nb_refs[L1])
1681 mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1683 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1684 AV_ZERO32(&lc->pu.mvd);
1686 ff_hevc_hls_mvd_coding(s, x0, y0, 1);
1689 mv->pred_flag += PF_L1;
1690 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1691 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1692 part_idx, merge_idx, mv, mvp_flag, 1);
1693 mv->mv[1].x += lc->pu.mvd.x;
1694 mv->mv[1].y += lc->pu.mvd.y;
1698 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1700 int log2_cb_size, int partIdx, int idx)
1702 #define POS(c_idx, x, y) \
1703 &s->frame->data[c_idx][((y) >> s->ps.sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1704 (((x) >> s->ps.sps->hshift[c_idx]) << s->ps.sps->pixel_shift)]
1705 HEVCLocalContext *lc = s->HEVClc;
1707 struct MvField current_mv = {{{ 0 }}};
1709 int min_pu_width = s->ps.sps->min_pu_width;
1711 MvField *tab_mvf = s->ref->tab_mvf;
1712 RefPicList *refPicList = s->ref->refPicList;
1713 HEVCFrame *ref0 = NULL, *ref1 = NULL;
1714 uint8_t *dst0 = POS(0, x0, y0);
1715 uint8_t *dst1 = POS(1, x0, y0);
1716 uint8_t *dst2 = POS(2, x0, y0);
1717 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
1718 int min_cb_width = s->ps.sps->min_cb_width;
1719 int x_cb = x0 >> log2_min_cb_size;
1720 int y_cb = y0 >> log2_min_cb_size;
1724 int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1727 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1729 if (skip_flag || lc->pu.merge_flag) {
1730 if (s->sh.max_num_merge_cand > 1)
1731 merge_idx = ff_hevc_merge_idx_decode(s);
1735 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1736 partIdx, merge_idx, ¤t_mv);
1738 hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1739 partIdx, merge_idx, ¤t_mv);
1742 x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1743 y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1745 for (j = 0; j < nPbH >> s->ps.sps->log2_min_pu_size; j++)
1746 for (i = 0; i < nPbW >> s->ps.sps->log2_min_pu_size; i++)
1747 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1749 if (current_mv.pred_flag & PF_L0) {
1750 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1753 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1755 if (current_mv.pred_flag & PF_L1) {
1756 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1759 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1762 if (current_mv.pred_flag == PF_L0) {
1763 int x0_c = x0 >> s->ps.sps->hshift[1];
1764 int y0_c = y0 >> s->ps.sps->vshift[1];
1765 int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1766 int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1768 luma_mc_uni(s, dst0, s->frame->linesize[0], ref0->frame,
1769 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1770 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1771 s->sh.luma_offset_l0[current_mv.ref_idx[0]]);
1773 if (s->ps.sps->chroma_format_idc) {
1774 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref0->frame->data[1], ref0->frame->linesize[1],
1775 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1776 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]);
1777 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref0->frame->data[2], ref0->frame->linesize[2],
1778 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1779 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]);
1781 } else if (current_mv.pred_flag == PF_L1) {
1782 int x0_c = x0 >> s->ps.sps->hshift[1];
1783 int y0_c = y0 >> s->ps.sps->vshift[1];
1784 int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1785 int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1787 luma_mc_uni(s, dst0, s->frame->linesize[0], ref1->frame,
1788 ¤t_mv.mv[1], x0, y0, nPbW, nPbH,
1789 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1790 s->sh.luma_offset_l1[current_mv.ref_idx[1]]);
1792 if (s->ps.sps->chroma_format_idc) {
1793 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
1794 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1795 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]);
1797 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
1798 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1799 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]);
1801 } else if (current_mv.pred_flag == PF_BI) {
1802 int x0_c = x0 >> s->ps.sps->hshift[1];
1803 int y0_c = y0 >> s->ps.sps->vshift[1];
1804 int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1805 int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1807 luma_mc_bi(s, dst0, s->frame->linesize[0], ref0->frame,
1808 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1809 ref1->frame, ¤t_mv.mv[1], ¤t_mv);
1811 if (s->ps.sps->chroma_format_idc) {
1812 chroma_mc_bi(s, dst1, s->frame->linesize[1], ref0->frame, ref1->frame,
1813 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 0);
1815 chroma_mc_bi(s, dst2, s->frame->linesize[2], ref0->frame, ref1->frame,
1816 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1);
1824 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1825 int prev_intra_luma_pred_flag)
1827 HEVCLocalContext *lc = s->HEVClc;
1828 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1829 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1830 int min_pu_width = s->ps.sps->min_pu_width;
1831 int size_in_pus = pu_size >> s->ps.sps->log2_min_pu_size;
1832 int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
1833 int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
1835 int cand_up = (lc->ctb_up_flag || y0b) ?
1836 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1837 int cand_left = (lc->ctb_left_flag || x0b) ?
1838 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1840 int y_ctb = (y0 >> (s->ps.sps->log2_ctb_size)) << (s->ps.sps->log2_ctb_size);
1842 MvField *tab_mvf = s->ref->tab_mvf;
1843 int intra_pred_mode;
1847 // intra_pred_mode prediction does not cross vertical CTB boundaries
1848 if ((y0 - 1) < y_ctb)
1851 if (cand_left == cand_up) {
1852 if (cand_left < 2) {
1853 candidate[0] = INTRA_PLANAR;
1854 candidate[1] = INTRA_DC;
1855 candidate[2] = INTRA_ANGULAR_26;
1857 candidate[0] = cand_left;
1858 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1859 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1862 candidate[0] = cand_left;
1863 candidate[1] = cand_up;
1864 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1865 candidate[2] = INTRA_PLANAR;
1866 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1867 candidate[2] = INTRA_DC;
1869 candidate[2] = INTRA_ANGULAR_26;
1873 if (prev_intra_luma_pred_flag) {
1874 intra_pred_mode = candidate[lc->pu.mpm_idx];
1876 if (candidate[0] > candidate[1])
1877 FFSWAP(uint8_t, candidate[0], candidate[1]);
1878 if (candidate[0] > candidate[2])
1879 FFSWAP(uint8_t, candidate[0], candidate[2]);
1880 if (candidate[1] > candidate[2])
1881 FFSWAP(uint8_t, candidate[1], candidate[2]);
1883 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1884 for (i = 0; i < 3; i++)
1885 if (intra_pred_mode >= candidate[i])
1889 /* write the intra prediction units into the mv array */
1892 for (i = 0; i < size_in_pus; i++) {
1893 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1894 intra_pred_mode, size_in_pus);
1896 for (j = 0; j < size_in_pus; j++) {
1897 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag = PF_INTRA;
1901 return intra_pred_mode;
1904 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1905 int log2_cb_size, int ct_depth)
1907 int length = (1 << log2_cb_size) >> s->ps.sps->log2_min_cb_size;
1908 int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
1909 int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
1912 for (y = 0; y < length; y++)
1913 memset(&s->tab_ct_depth[(y_cb + y) * s->ps.sps->min_cb_width + x_cb],
1917 static const uint8_t tab_mode_idx[] = {
1918 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
1919 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
1921 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1924 HEVCLocalContext *lc = s->HEVClc;
1925 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1926 uint8_t prev_intra_luma_pred_flag[4];
1927 int split = lc->cu.part_mode == PART_NxN;
1928 int pb_size = (1 << log2_cb_size) >> split;
1929 int side = split + 1;
1933 for (i = 0; i < side; i++)
1934 for (j = 0; j < side; j++)
1935 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1937 for (i = 0; i < side; i++) {
1938 for (j = 0; j < side; j++) {
1939 if (prev_intra_luma_pred_flag[2 * i + j])
1940 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
1942 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
1944 lc->pu.intra_pred_mode[2 * i + j] =
1945 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1946 prev_intra_luma_pred_flag[2 * i + j]);
1950 if (s->ps.sps->chroma_format_idc == 3) {
1951 for (i = 0; i < side; i++) {
1952 for (j = 0; j < side; j++) {
1953 lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1954 if (chroma_mode != 4) {
1955 if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode])
1956 lc->pu.intra_pred_mode_c[2 * i + j] = 34;
1958 lc->pu.intra_pred_mode_c[2 * i + j] = intra_chroma_table[chroma_mode];
1960 lc->pu.intra_pred_mode_c[2 * i + j] = lc->pu.intra_pred_mode[2 * i + j];
1964 } else if (s->ps.sps->chroma_format_idc == 2) {
1966 lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1967 if (chroma_mode != 4) {
1968 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1971 mode_idx = intra_chroma_table[chroma_mode];
1973 mode_idx = lc->pu.intra_pred_mode[0];
1975 lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx];
1976 } else if (s->ps.sps->chroma_format_idc != 0) {
1977 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1978 if (chroma_mode != 4) {
1979 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1980 lc->pu.intra_pred_mode_c[0] = 34;
1982 lc->pu.intra_pred_mode_c[0] = intra_chroma_table[chroma_mode];
1984 lc->pu.intra_pred_mode_c[0] = lc->pu.intra_pred_mode[0];
1989 static void intra_prediction_unit_default_value(HEVCContext *s,
1993 HEVCLocalContext *lc = s->HEVClc;
1994 int pb_size = 1 << log2_cb_size;
1995 int size_in_pus = pb_size >> s->ps.sps->log2_min_pu_size;
1996 int min_pu_width = s->ps.sps->min_pu_width;
1997 MvField *tab_mvf = s->ref->tab_mvf;
1998 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1999 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
2002 if (size_in_pus == 0)
2004 for (j = 0; j < size_in_pus; j++)
2005 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
2006 if (lc->cu.pred_mode == MODE_INTRA)
2007 for (j = 0; j < size_in_pus; j++)
2008 for (k = 0; k < size_in_pus; k++)
2009 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].pred_flag = PF_INTRA;
2012 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
2014 int cb_size = 1 << log2_cb_size;
2015 HEVCLocalContext *lc = s->HEVClc;
2016 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
2017 int length = cb_size >> log2_min_cb_size;
2018 int min_cb_width = s->ps.sps->min_cb_width;
2019 int x_cb = x0 >> log2_min_cb_size;
2020 int y_cb = y0 >> log2_min_cb_size;
2021 int idx = log2_cb_size - 2;
2022 int qp_block_mask = (1<<(s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2027 lc->cu.pred_mode = MODE_INTRA;
2028 lc->cu.part_mode = PART_2Nx2N;
2029 lc->cu.intra_split_flag = 0;
2031 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
2032 for (x = 0; x < 4; x++)
2033 lc->pu.intra_pred_mode[x] = 1;
2034 if (s->ps.pps->transquant_bypass_enable_flag) {
2035 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
2036 if (lc->cu.cu_transquant_bypass_flag)
2037 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2039 lc->cu.cu_transquant_bypass_flag = 0;
2041 if (s->sh.slice_type != I_SLICE) {
2042 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
2044 x = y_cb * min_cb_width + x_cb;
2045 for (y = 0; y < length; y++) {
2046 memset(&s->skip_flag[x], skip_flag, length);
2049 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2051 x = y_cb * min_cb_width + x_cb;
2052 for (y = 0; y < length; y++) {
2053 memset(&s->skip_flag[x], 0, length);
2058 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2059 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2060 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2062 if (!s->sh.disable_deblocking_filter_flag)
2063 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2067 if (s->sh.slice_type != I_SLICE)
2068 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2069 if (lc->cu.pred_mode != MODE_INTRA ||
2070 log2_cb_size == s->ps.sps->log2_min_cb_size) {
2071 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2072 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2073 lc->cu.pred_mode == MODE_INTRA;
2076 if (lc->cu.pred_mode == MODE_INTRA) {
2077 if (lc->cu.part_mode == PART_2Nx2N && s->ps.sps->pcm_enabled_flag &&
2078 log2_cb_size >= s->ps.sps->pcm.log2_min_pcm_cb_size &&
2079 log2_cb_size <= s->ps.sps->pcm.log2_max_pcm_cb_size) {
2080 pcm_flag = ff_hevc_pcm_flag_decode(s);
2083 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2084 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2085 if (s->ps.sps->pcm.loop_filter_disable_flag)
2086 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2091 intra_prediction_unit(s, x0, y0, log2_cb_size);
2094 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2095 switch (lc->cu.part_mode) {
2097 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2100 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0, idx);
2101 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2104 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2105 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2108 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0, idx);
2109 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2112 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2113 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2116 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0, idx - 2);
2117 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2120 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2121 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2124 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2125 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2126 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2127 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2133 int rqt_root_cbf = 1;
2135 if (lc->cu.pred_mode != MODE_INTRA &&
2136 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2137 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2140 const static int cbf[2] = { 0 };
2141 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2142 s->ps.sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2143 s->ps.sps->max_transform_hierarchy_depth_inter;
2144 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2146 log2_cb_size, 0, 0, cbf, cbf);
2150 if (!s->sh.disable_deblocking_filter_flag)
2151 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2156 if (s->ps.pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2157 ff_hevc_set_qPy(s, x0, y0, log2_cb_size);
2159 x = y_cb * min_cb_width + x_cb;
2160 for (y = 0; y < length; y++) {
2161 memset(&s->qp_y_tab[x], lc->qp_y, length);
2165 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2166 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2167 lc->qPy_pred = lc->qp_y;
2170 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct_depth);
2175 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2176 int log2_cb_size, int cb_depth)
2178 HEVCLocalContext *lc = s->HEVClc;
2179 const int cb_size = 1 << log2_cb_size;
2183 lc->ct_depth = cb_depth;
2184 if (x0 + cb_size <= s->ps.sps->width &&
2185 y0 + cb_size <= s->ps.sps->height &&
2186 log2_cb_size > s->ps.sps->log2_min_cb_size) {
2187 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2189 split_cu = (log2_cb_size > s->ps.sps->log2_min_cb_size);
2191 if (s->ps.pps->cu_qp_delta_enabled_flag &&
2192 log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth) {
2193 lc->tu.is_cu_qp_delta_coded = 0;
2194 lc->tu.cu_qp_delta = 0;
2197 if (s->sh.cu_chroma_qp_offset_enabled_flag &&
2198 log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_chroma_qp_offset_depth) {
2199 lc->tu.is_cu_chroma_qp_offset_coded = 0;
2203 int qp_block_mask = (1<<(s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2204 const int cb_size_split = cb_size >> 1;
2205 const int x1 = x0 + cb_size_split;
2206 const int y1 = y0 + cb_size_split;
2210 more_data = hls_coding_quadtree(s, x0, y0, log2_cb_size - 1, cb_depth + 1);
2214 if (more_data && x1 < s->ps.sps->width) {
2215 more_data = hls_coding_quadtree(s, x1, y0, log2_cb_size - 1, cb_depth + 1);
2219 if (more_data && y1 < s->ps.sps->height) {
2220 more_data = hls_coding_quadtree(s, x0, y1, log2_cb_size - 1, cb_depth + 1);
2224 if (more_data && x1 < s->ps.sps->width &&
2225 y1 < s->ps.sps->height) {
2226 more_data = hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1);
2231 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2232 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2233 lc->qPy_pred = lc->qp_y;
2236 return ((x1 + cb_size_split) < s->ps.sps->width ||
2237 (y1 + cb_size_split) < s->ps.sps->height);
2241 ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2244 if ((!((x0 + cb_size) %
2245 (1 << (s->ps.sps->log2_ctb_size))) ||
2246 (x0 + cb_size >= s->ps.sps->width)) &&
2248 (1 << (s->ps.sps->log2_ctb_size))) ||
2249 (y0 + cb_size >= s->ps.sps->height))) {
2250 int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s);
2251 return !end_of_slice_flag;
2260 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2263 HEVCLocalContext *lc = s->HEVClc;
2264 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2265 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2266 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2268 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2270 if (s->ps.pps->entropy_coding_sync_enabled_flag) {
2271 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2272 lc->first_qp_group = 1;
2273 lc->end_of_tiles_x = s->ps.sps->width;
2274 } else if (s->ps.pps->tiles_enabled_flag) {
2275 if (ctb_addr_ts && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
2276 int idxX = s->ps.pps->col_idxX[x_ctb >> s->ps.sps->log2_ctb_size];
2277 lc->end_of_tiles_x = x_ctb + (s->ps.pps->column_width[idxX] << s->ps.sps->log2_ctb_size);
2278 lc->first_qp_group = 1;
2281 lc->end_of_tiles_x = s->ps.sps->width;
2284 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->ps.sps->height);
2286 lc->boundary_flags = 0;
2287 if (s->ps.pps->tiles_enabled_flag) {
2288 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]])
2289 lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2290 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2291 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2292 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]])
2293 lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2294 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->ps.sps->ctb_width])
2295 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2297 if (ctb_addr_in_slice <= 0)
2298 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2299 if (ctb_addr_in_slice < s->ps.sps->ctb_width)
2300 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2303 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2304 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->ps.sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2305 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]]));
2306 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]]));
2309 static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
2311 HEVCContext *s = avctxt->priv_data;
2312 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2316 int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2318 if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) {
2319 av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n");
2320 return AVERROR_INVALIDDATA;
2323 if (s->sh.dependent_slice_segment_flag) {
2324 int prev_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2325 if (s->tab_slice_address[prev_rs] != s->sh.slice_addr) {
2326 av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n");
2327 return AVERROR_INVALIDDATA;
2331 while (more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2332 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2334 x_ctb = (ctb_addr_rs % ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2335 y_ctb = (ctb_addr_rs / ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2336 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2338 ff_hevc_cabac_init(s, ctb_addr_ts);
2340 hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2342 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2343 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2344 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2346 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2347 if (more_data < 0) {
2348 s->tab_slice_address[ctb_addr_rs] = -1;
2354 ff_hevc_save_states(s, ctb_addr_ts);
2355 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2358 if (x_ctb + ctb_size >= s->ps.sps->width &&
2359 y_ctb + ctb_size >= s->ps.sps->height)
2360 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2365 static int hls_slice_data(HEVCContext *s)
2373 s->avctx->execute(s->avctx, hls_decode_entry, arg, ret , 1, sizeof(int));
2376 static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int job, int self_id)
2378 HEVCContext *s1 = avctxt->priv_data, *s;
2379 HEVCLocalContext *lc;
2380 int ctb_size = 1<< s1->ps.sps->log2_ctb_size;
2382 int *ctb_row_p = input_ctb_row;
2383 int ctb_row = ctb_row_p[job];
2384 int ctb_addr_rs = s1->sh.slice_ctb_addr_rs + ctb_row * ((s1->ps.sps->width + ctb_size - 1) >> s1->ps.sps->log2_ctb_size);
2385 int ctb_addr_ts = s1->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2386 int thread = ctb_row % s1->threads_number;
2389 s = s1->sList[self_id];
2393 ret = init_get_bits8(&lc->gb, s->data + s->sh.offset[ctb_row - 1], s->sh.size[ctb_row - 1]);
2397 ff_init_cabac_decoder(&lc->cc, s->data + s->sh.offset[(ctb_row)-1], s->sh.size[ctb_row - 1]);
2400 while(more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2401 int x_ctb = (ctb_addr_rs % s->ps.sps->ctb_width) << s->ps.sps->log2_ctb_size;
2402 int y_ctb = (ctb_addr_rs / s->ps.sps->ctb_width) << s->ps.sps->log2_ctb_size;
2404 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2406 ff_thread_await_progress2(s->avctx, ctb_row, thread, SHIFT_CTB_WPP);
2408 if (atomic_load(&s1->wpp_err)) {
2409 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2413 ff_hevc_cabac_init(s, ctb_addr_ts);
2414 hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2415 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2417 if (more_data < 0) {
2418 s->tab_slice_address[ctb_addr_rs] = -1;
2419 atomic_store(&s1->wpp_err, 1);
2420 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2426 ff_hevc_save_states(s, ctb_addr_ts);
2427 ff_thread_report_progress2(s->avctx, ctb_row, thread, 1);
2428 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2430 if (!more_data && (x_ctb+ctb_size) < s->ps.sps->width && ctb_row != s->sh.num_entry_point_offsets) {
2431 atomic_store(&s1->wpp_err, 1);
2432 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2436 if ((x_ctb+ctb_size) >= s->ps.sps->width && (y_ctb+ctb_size) >= s->ps.sps->height ) {
2437 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2438 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2441 ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2444 if(x_ctb >= s->ps.sps->width) {
2448 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2453 static int hls_slice_data_wpp(HEVCContext *s, const H2645NAL *nal)
2455 const uint8_t *data = nal->data;
2456 int length = nal->size;
2457 HEVCLocalContext *lc = s->HEVClc;
2458 int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2459 int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2461 int64_t startheader, cmpt = 0;
2467 return AVERROR(ENOMEM);
2470 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) {
2471 av_log(s->avctx, AV_LOG_ERROR, "WPP ctb addresses are wrong (%d %d %d %d)\n",
2472 s->sh.slice_ctb_addr_rs, s->sh.num_entry_point_offsets,
2473 s->ps.sps->ctb_width, s->ps.sps->ctb_height
2475 res = AVERROR_INVALIDDATA;
2479 ff_alloc_entries(s->avctx, s->sh.num_entry_point_offsets + 1);
2482 for (i = 1; i < s->threads_number; i++) {
2483 s->sList[i] = av_malloc(sizeof(HEVCContext));
2484 memcpy(s->sList[i], s, sizeof(HEVCContext));
2485 s->HEVClcList[i] = av_mallocz(sizeof(HEVCLocalContext));
2486 s->sList[i]->HEVClc = s->HEVClcList[i];
2490 offset = (lc->gb.index >> 3);
2492 for (j = 0, cmpt = 0, startheader = offset + s->sh.entry_point_offset[0]; j < nal->skipped_bytes; j++) {
2493 if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) {
2499 for (i = 1; i < s->sh.num_entry_point_offsets; i++) {
2500 offset += (s->sh.entry_point_offset[i - 1] - cmpt);
2501 for (j = 0, cmpt = 0, startheader = offset
2502 + s->sh.entry_point_offset[i]; j < nal->skipped_bytes; j++) {
2503 if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) {
2508 s->sh.size[i - 1] = s->sh.entry_point_offset[i] - cmpt;
2509 s->sh.offset[i - 1] = offset;
2512 if (s->sh.num_entry_point_offsets != 0) {
2513 offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt;
2514 if (length < offset) {
2515 av_log(s->avctx, AV_LOG_ERROR, "entry_point_offset table is corrupted\n");
2516 res = AVERROR_INVALIDDATA;
2519 s->sh.size[s->sh.num_entry_point_offsets - 1] = length - offset;
2520 s->sh.offset[s->sh.num_entry_point_offsets - 1] = offset;
2525 for (i = 1; i < s->threads_number; i++) {
2526 s->sList[i]->HEVClc->first_qp_group = 1;
2527 s->sList[i]->HEVClc->qp_y = s->sList[0]->HEVClc->qp_y;
2528 memcpy(s->sList[i], s, sizeof(HEVCContext));
2529 s->sList[i]->HEVClc = s->HEVClcList[i];
2532 atomic_store(&s->wpp_err, 0);
2533 ff_reset_entries(s->avctx);
2535 for (i = 0; i <= s->sh.num_entry_point_offsets; i++) {
2540 if (s->ps.pps->entropy_coding_sync_enabled_flag)
2541 s->avctx->execute2(s->avctx, hls_decode_entry_wpp, arg, ret, s->sh.num_entry_point_offsets + 1);
2543 for (i = 0; i <= s->sh.num_entry_point_offsets; i++)
2551 static int set_side_data(HEVCContext *s)
2553 AVFrame *out = s->ref->frame;
2555 if (s->sei_frame_packing_present &&
2556 s->frame_packing_arrangement_type >= 3 &&
2557 s->frame_packing_arrangement_type <= 5 &&
2558 s->content_interpretation_type > 0 &&
2559 s->content_interpretation_type < 3) {
2560 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2562 return AVERROR(ENOMEM);
2564 switch (s->frame_packing_arrangement_type) {
2566 if (s->quincunx_subsampling)
2567 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2569 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2572 stereo->type = AV_STEREO3D_TOPBOTTOM;
2575 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2579 if (s->content_interpretation_type == 2)
2580 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2583 if (s->sei_display_orientation_present &&
2584 (s->sei_anticlockwise_rotation || s->sei_hflip || s->sei_vflip)) {
2585 double angle = s->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
2586 AVFrameSideData *rotation = av_frame_new_side_data(out,
2587 AV_FRAME_DATA_DISPLAYMATRIX,
2588 sizeof(int32_t) * 9);
2590 return AVERROR(ENOMEM);
2592 av_display_rotation_set((int32_t *)rotation->data, angle);
2593 av_display_matrix_flip((int32_t *)rotation->data,
2594 s->sei_hflip, s->sei_vflip);
2597 // Decrement the mastering display flag when IRAP frame has no_rasl_output_flag=1
2598 // so the side data persists for the entire coded video sequence.
2599 if (s->sei_mastering_display_info_present > 0 &&
2600 IS_IRAP(s) && s->no_rasl_output_flag) {
2601 s->sei_mastering_display_info_present--;
2603 if (s->sei_mastering_display_info_present) {
2604 // HEVC uses a g,b,r ordering, which we convert to a more natural r,g,b
2605 const int mapping[3] = {2, 0, 1};
2606 const int chroma_den = 50000;
2607 const int luma_den = 10000;
2609 AVMasteringDisplayMetadata *metadata =
2610 av_mastering_display_metadata_create_side_data(out);
2612 return AVERROR(ENOMEM);
2614 for (i = 0; i < 3; i++) {
2615 const int j = mapping[i];
2616 metadata->display_primaries[i][0].num = s->display_primaries[j][0];
2617 metadata->display_primaries[i][0].den = chroma_den;
2618 metadata->display_primaries[i][1].num = s->display_primaries[j][1];
2619 metadata->display_primaries[i][1].den = chroma_den;
2621 metadata->white_point[0].num = s->white_point[0];
2622 metadata->white_point[0].den = chroma_den;
2623 metadata->white_point[1].num = s->white_point[1];
2624 metadata->white_point[1].den = chroma_den;
2626 metadata->max_luminance.num = s->max_mastering_luminance;
2627 metadata->max_luminance.den = luma_den;
2628 metadata->min_luminance.num = s->min_mastering_luminance;
2629 metadata->min_luminance.den = luma_den;
2630 metadata->has_luminance = 1;
2631 metadata->has_primaries = 1;
2633 av_log(s->avctx, AV_LOG_DEBUG, "Mastering Display Metadata:\n");
2634 av_log(s->avctx, AV_LOG_DEBUG,
2635 "r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f)\n",
2636 av_q2d(metadata->display_primaries[0][0]),
2637 av_q2d(metadata->display_primaries[0][1]),
2638 av_q2d(metadata->display_primaries[1][0]),
2639 av_q2d(metadata->display_primaries[1][1]),
2640 av_q2d(metadata->display_primaries[2][0]),
2641 av_q2d(metadata->display_primaries[2][1]),
2642 av_q2d(metadata->white_point[0]), av_q2d(metadata->white_point[1]));
2643 av_log(s->avctx, AV_LOG_DEBUG,
2644 "min_luminance=%f, max_luminance=%f\n",
2645 av_q2d(metadata->min_luminance), av_q2d(metadata->max_luminance));
2648 if (s->a53_caption) {
2649 AVFrameSideData* sd = av_frame_new_side_data(out,
2650 AV_FRAME_DATA_A53_CC,
2651 s->a53_caption_size);
2653 memcpy(sd->data, s->a53_caption, s->a53_caption_size);
2654 av_freep(&s->a53_caption);
2655 s->a53_caption_size = 0;
2656 s->avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
2662 static int hevc_frame_start(HEVCContext *s)
2664 HEVCLocalContext *lc = s->HEVClc;
2665 int pic_size_in_ctb = ((s->ps.sps->width >> s->ps.sps->log2_min_cb_size) + 1) *
2666 ((s->ps.sps->height >> s->ps.sps->log2_min_cb_size) + 1);
2669 memset(s->horizontal_bs, 0, s->bs_width * s->bs_height);
2670 memset(s->vertical_bs, 0, s->bs_width * s->bs_height);
2671 memset(s->cbf_luma, 0, s->ps.sps->min_tb_width * s->ps.sps->min_tb_height);
2672 memset(s->is_pcm, 0, (s->ps.sps->min_pu_width + 1) * (s->ps.sps->min_pu_height + 1));
2673 memset(s->tab_slice_address, -1, pic_size_in_ctb * sizeof(*s->tab_slice_address));
2676 s->first_nal_type = s->nal_unit_type;
2678 if (s->ps.pps->tiles_enabled_flag)
2679 lc->end_of_tiles_x = s->ps.pps->column_width[0] << s->ps.sps->log2_ctb_size;
2681 ret = ff_hevc_set_new_ref(s, &s->frame, s->poc);
2685 ret = ff_hevc_frame_rps(s);
2687 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2691 s->ref->frame->key_frame = IS_IRAP(s);
2693 ret = set_side_data(s);
2697 s->frame->pict_type = 3 - s->sh.slice_type;
2700 ff_hevc_bump_frame(s);
2702 av_frame_unref(s->output_frame);
2703 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2707 if (!s->avctx->hwaccel)
2708 ff_thread_finish_setup(s->avctx);
2714 ff_hevc_unref_frame(s, s->ref, ~0);
2719 static int decode_nal_unit(HEVCContext *s, const H2645NAL *nal)
2721 HEVCLocalContext *lc = s->HEVClc;
2722 GetBitContext *gb = &lc->gb;
2723 int ctb_addr_ts, ret;
2726 s->nal_unit_type = nal->type;
2727 s->temporal_id = nal->temporal_id;
2729 switch (s->nal_unit_type) {
2731 ret = ff_hevc_decode_nal_vps(gb, s->avctx, &s->ps);
2736 ret = ff_hevc_decode_nal_sps(gb, s->avctx, &s->ps,
2737 s->apply_defdispwin);
2742 ret = ff_hevc_decode_nal_pps(gb, s->avctx, &s->ps);
2746 case NAL_SEI_PREFIX:
2747 case NAL_SEI_SUFFIX:
2748 ret = ff_hevc_decode_nal_sei(s);
2759 case NAL_BLA_W_RADL:
2761 case NAL_IDR_W_RADL:
2768 ret = hls_slice_header(s);
2772 if (s->max_ra == INT_MAX) {
2773 if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
2777 s->max_ra = INT_MIN;
2781 if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
2782 s->poc <= s->max_ra) {
2786 if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
2787 s->max_ra = INT_MIN;
2790 if (s->sh.first_slice_in_pic_flag) {
2791 ret = hevc_frame_start(s);
2794 } else if (!s->ref) {
2795 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2799 if (s->nal_unit_type != s->first_nal_type) {
2800 av_log(s->avctx, AV_LOG_ERROR,
2801 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2802 s->first_nal_type, s->nal_unit_type);
2803 return AVERROR_INVALIDDATA;
2806 if (!s->sh.dependent_slice_segment_flag &&
2807 s->sh.slice_type != I_SLICE) {
2808 ret = ff_hevc_slice_rpl(s);
2810 av_log(s->avctx, AV_LOG_WARNING,
2811 "Error constructing the reference lists for the current slice.\n");
2816 if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) {
2817 ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0);
2822 if (s->avctx->hwaccel) {
2823 ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size);
2827 if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
2828 ctb_addr_ts = hls_slice_data_wpp(s, nal);
2830 ctb_addr_ts = hls_slice_data(s);
2831 if (ctb_addr_ts >= (s->ps.sps->ctb_width * s->ps.sps->ctb_height)) {
2835 if (ctb_addr_ts < 0) {
2843 s->seq_decode = (s->seq_decode + 1) & 0xff;
2844 s->max_ra = INT_MAX;
2850 av_log(s->avctx, AV_LOG_INFO,
2851 "Skipping NAL unit %d\n", s->nal_unit_type);
2856 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2861 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2866 s->last_eos = s->eos;
2869 /* split the input packet into NAL units, so we know the upper bound on the
2870 * number of slices in the frame */
2871 ret = ff_h2645_packet_split(&s->pkt, buf, length, s->avctx, s->is_nalff,
2872 s->nal_length_size, s->avctx->codec_id, 1);
2874 av_log(s->avctx, AV_LOG_ERROR,
2875 "Error splitting the input into NAL units.\n");
2879 for (i = 0; i < s->pkt.nb_nals; i++) {
2880 if (s->pkt.nals[i].type == NAL_EOB_NUT ||
2881 s->pkt.nals[i].type == NAL_EOS_NUT)
2885 /* decode the NAL units */
2886 for (i = 0; i < s->pkt.nb_nals; i++) {
2887 ret = decode_nal_unit(s, &s->pkt.nals[i]);
2889 av_log(s->avctx, AV_LOG_WARNING,
2890 "Error parsing NAL unit #%d.\n", i);
2896 if (s->ref && s->threads_type == FF_THREAD_FRAME)
2897 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2902 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2905 for (i = 0; i < 16; i++)
2906 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
2909 static int verify_md5(HEVCContext *s, AVFrame *frame)
2911 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
2916 return AVERROR(EINVAL);
2918 pixel_shift = desc->comp[0].depth > 8;
2920 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
2923 /* the checksums are LE, so we have to byteswap for >8bpp formats
2926 if (pixel_shift && !s->checksum_buf) {
2927 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
2928 FFMAX3(frame->linesize[0], frame->linesize[1],
2929 frame->linesize[2]));
2930 if (!s->checksum_buf)
2931 return AVERROR(ENOMEM);
2935 for (i = 0; frame->data[i]; i++) {
2936 int width = s->avctx->coded_width;
2937 int height = s->avctx->coded_height;
2938 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
2939 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
2942 av_md5_init(s->md5_ctx);
2943 for (j = 0; j < h; j++) {
2944 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
2947 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
2948 (const uint16_t *) src, w);
2949 src = s->checksum_buf;
2952 av_md5_update(s->md5_ctx, src, w << pixel_shift);
2954 av_md5_final(s->md5_ctx, md5);
2956 if (!memcmp(md5, s->md5[i], 16)) {
2957 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
2958 print_md5(s->avctx, AV_LOG_DEBUG, md5);
2959 av_log (s->avctx, AV_LOG_DEBUG, "; ");
2961 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
2962 print_md5(s->avctx, AV_LOG_ERROR, md5);
2963 av_log (s->avctx, AV_LOG_ERROR, " != ");
2964 print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
2965 av_log (s->avctx, AV_LOG_ERROR, "\n");
2966 return AVERROR_INVALIDDATA;
2970 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2975 static int hevc_decode_extradata(HEVCContext *s, uint8_t *buf, int length)
2977 AVCodecContext *avctx = s->avctx;
2981 bytestream2_init(&gb, buf, length);
2983 if (length > 3 && (buf[0] || buf[1] || buf[2] > 1)) {
2984 /* It seems the extradata is encoded as hvcC format.
2985 * Temporarily, we support configurationVersion==0 until 14496-15 3rd
2986 * is finalized. When finalized, configurationVersion will be 1 and we
2987 * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
2988 int i, j, num_arrays, nal_len_size;
2992 bytestream2_skip(&gb, 21);
2993 nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
2994 num_arrays = bytestream2_get_byte(&gb);
2996 /* nal units in the hvcC always have length coded with 2 bytes,
2997 * so put a fake nal_length_size = 2 while parsing them */
2998 s->nal_length_size = 2;
3000 /* Decode nal units from hvcC. */
3001 for (i = 0; i < num_arrays; i++) {
3002 int type = bytestream2_get_byte(&gb) & 0x3f;
3003 int cnt = bytestream2_get_be16(&gb);
3005 for (j = 0; j < cnt; j++) {
3006 // +2 for the nal size field
3007 int nalsize = bytestream2_peek_be16(&gb) + 2;
3008 if (bytestream2_get_bytes_left(&gb) < nalsize) {
3009 av_log(s->avctx, AV_LOG_ERROR,
3010 "Invalid NAL unit size in extradata.\n");
3011 return AVERROR_INVALIDDATA;
3014 ret = decode_nal_units(s, gb.buffer, nalsize);
3016 av_log(avctx, AV_LOG_ERROR,
3017 "Decoding nal unit %d %d from hvcC failed\n",
3021 bytestream2_skip(&gb, nalsize);
3025 /* Now store right nal length size, that will be used to parse
3027 s->nal_length_size = nal_len_size;
3030 ret = decode_nal_units(s, buf, length);
3035 /* export stream parameters from the first SPS */
3036 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3037 if (s->ps.sps_list[i]) {
3038 const HEVCSPS *sps = (const HEVCSPS*)s->ps.sps_list[i]->data;
3039 export_stream_params(s->avctx, &s->ps, sps);
3047 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
3051 int new_extradata_size;
3052 uint8_t *new_extradata;
3053 HEVCContext *s = avctx->priv_data;
3056 ret = ff_hevc_output_frame(s, data, 1);
3064 new_extradata = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,
3065 &new_extradata_size);
3066 if (new_extradata && new_extradata_size > 0) {
3067 ret = hevc_decode_extradata(s, new_extradata, new_extradata_size);
3073 ret = decode_nal_units(s, avpkt->data, avpkt->size);
3077 if (avctx->hwaccel) {
3078 if (s->ref && (ret = avctx->hwaccel->end_frame(avctx)) < 0) {
3079 av_log(avctx, AV_LOG_ERROR,
3080 "hardware accelerator failed to decode picture\n");
3081 ff_hevc_unref_frame(s, s->ref, ~0);
3085 /* verify the SEI checksum */
3086 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
3088 ret = verify_md5(s, s->ref->frame);
3089 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
3090 ff_hevc_unref_frame(s, s->ref, ~0);
3097 if (s->is_decoded) {
3098 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
3102 if (s->output_frame->buf[0]) {
3103 av_frame_move_ref(data, s->output_frame);
3110 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
3114 ret = ff_thread_ref_frame(&dst->tf, &src->tf);
3118 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
3119 if (!dst->tab_mvf_buf)
3121 dst->tab_mvf = src->tab_mvf;
3123 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
3124 if (!dst->rpl_tab_buf)
3126 dst->rpl_tab = src->rpl_tab;
3128 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
3132 dst->poc = src->poc;
3133 dst->ctb_count = src->ctb_count;
3134 dst->window = src->window;
3135 dst->flags = src->flags;
3136 dst->sequence = src->sequence;
3138 if (src->hwaccel_picture_private) {
3139 dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
3140 if (!dst->hwaccel_priv_buf)
3142 dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
3147 ff_hevc_unref_frame(s, dst, ~0);
3148 return AVERROR(ENOMEM);
3151 static av_cold int hevc_decode_free(AVCodecContext *avctx)
3153 HEVCContext *s = avctx->priv_data;
3158 av_freep(&s->md5_ctx);
3160 av_freep(&s->cabac_state);
3162 for (i = 0; i < 3; i++) {
3163 av_freep(&s->sao_pixel_buffer_h[i]);
3164 av_freep(&s->sao_pixel_buffer_v[i]);
3166 av_frame_free(&s->output_frame);
3168 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3169 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3170 av_frame_free(&s->DPB[i].frame);
3173 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++)
3174 av_buffer_unref(&s->ps.vps_list[i]);
3175 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++)
3176 av_buffer_unref(&s->ps.sps_list[i]);
3177 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++)
3178 av_buffer_unref(&s->ps.pps_list[i]);
3183 av_freep(&s->sh.entry_point_offset);
3184 av_freep(&s->sh.offset);
3185 av_freep(&s->sh.size);
3187 for (i = 1; i < s->threads_number; i++) {
3188 HEVCLocalContext *lc = s->HEVClcList[i];
3190 av_freep(&s->HEVClcList[i]);
3191 av_freep(&s->sList[i]);
3194 if (s->HEVClc == s->HEVClcList[0])
3196 av_freep(&s->HEVClcList[0]);
3198 ff_h2645_packet_uninit(&s->pkt);
3203 static av_cold int hevc_init_context(AVCodecContext *avctx)
3205 HEVCContext *s = avctx->priv_data;
3210 s->HEVClc = av_mallocz(sizeof(HEVCLocalContext));
3213 s->HEVClcList[0] = s->HEVClc;
3216 s->cabac_state = av_malloc(HEVC_CONTEXTS);
3217 if (!s->cabac_state)
3220 s->output_frame = av_frame_alloc();
3221 if (!s->output_frame)
3224 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3225 s->DPB[i].frame = av_frame_alloc();
3226 if (!s->DPB[i].frame)
3228 s->DPB[i].tf.f = s->DPB[i].frame;
3231 s->max_ra = INT_MAX;
3233 s->md5_ctx = av_md5_alloc();
3237 ff_bswapdsp_init(&s->bdsp);
3239 s->context_initialized = 1;
3242 ff_hevc_reset_sei(s);
3247 hevc_decode_free(avctx);
3248 return AVERROR(ENOMEM);
3251 static int hevc_update_thread_context(AVCodecContext *dst,
3252 const AVCodecContext *src)
3254 HEVCContext *s = dst->priv_data;
3255 HEVCContext *s0 = src->priv_data;
3258 if (!s->context_initialized) {
3259 ret = hevc_init_context(dst);
3264 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3265 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3266 if (s0->DPB[i].frame->buf[0]) {
3267 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3273 if (s->ps.sps != s0->ps.sps)
3275 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++) {
3276 av_buffer_unref(&s->ps.vps_list[i]);
3277 if (s0->ps.vps_list[i]) {
3278 s->ps.vps_list[i] = av_buffer_ref(s0->ps.vps_list[i]);
3279 if (!s->ps.vps_list[i])
3280 return AVERROR(ENOMEM);
3284 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3285 av_buffer_unref(&s->ps.sps_list[i]);
3286 if (s0->ps.sps_list[i]) {
3287 s->ps.sps_list[i] = av_buffer_ref(s0->ps.sps_list[i]);
3288 if (!s->ps.sps_list[i])
3289 return AVERROR(ENOMEM);
3293 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++) {
3294 av_buffer_unref(&s->ps.pps_list[i]);
3295 if (s0->ps.pps_list[i]) {
3296 s->ps.pps_list[i] = av_buffer_ref(s0->ps.pps_list[i]);
3297 if (!s->ps.pps_list[i])
3298 return AVERROR(ENOMEM);
3302 if (s->ps.sps != s0->ps.sps)
3303 if ((ret = set_sps(s, s0->ps.sps, src->pix_fmt)) < 0)
3306 s->seq_decode = s0->seq_decode;
3307 s->seq_output = s0->seq_output;
3308 s->pocTid0 = s0->pocTid0;
3309 s->max_ra = s0->max_ra;
3311 s->no_rasl_output_flag = s0->no_rasl_output_flag;
3313 s->is_nalff = s0->is_nalff;
3314 s->nal_length_size = s0->nal_length_size;
3316 s->threads_number = s0->threads_number;
3317 s->threads_type = s0->threads_type;
3320 s->seq_decode = (s->seq_decode + 1) & 0xff;
3321 s->max_ra = INT_MAX;
3327 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3329 HEVCContext *s = avctx->priv_data;
3332 avctx->internal->allocate_progress = 1;
3334 ret = hevc_init_context(avctx);
3338 s->enable_parallel_tiles = 0;
3339 s->picture_struct = 0;
3342 atomic_init(&s->wpp_err, 0);
3344 if(avctx->active_thread_type & FF_THREAD_SLICE)
3345 s->threads_number = avctx->thread_count;
3347 s->threads_number = 1;
3349 if (avctx->extradata_size > 0 && avctx->extradata) {
3350 ret = hevc_decode_extradata(s, avctx->extradata, avctx->extradata_size);
3352 hevc_decode_free(avctx);
3357 if((avctx->active_thread_type & FF_THREAD_FRAME) && avctx->thread_count > 1)
3358 s->threads_type = FF_THREAD_FRAME;
3360 s->threads_type = FF_THREAD_SLICE;
3365 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3367 HEVCContext *s = avctx->priv_data;
3370 memset(s, 0, sizeof(*s));
3372 ret = hevc_init_context(avctx);
3379 static void hevc_decode_flush(AVCodecContext *avctx)
3381 HEVCContext *s = avctx->priv_data;
3382 ff_hevc_flush_dpb(s);
3383 s->max_ra = INT_MAX;
3387 #define OFFSET(x) offsetof(HEVCContext, x)
3388 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3390 static const AVOption options[] = {
3391 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3392 AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR },
3393 { "strict-displaywin", "stricly apply default display window size", OFFSET(apply_defdispwin),
3394 AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR },
3398 static const AVClass hevc_decoder_class = {
3399 .class_name = "HEVC decoder",
3400 .item_name = av_default_item_name,
3402 .version = LIBAVUTIL_VERSION_INT,
3405 AVCodec ff_hevc_decoder = {
3407 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3408 .type = AVMEDIA_TYPE_VIDEO,
3409 .id = AV_CODEC_ID_HEVC,
3410 .priv_data_size = sizeof(HEVCContext),
3411 .priv_class = &hevc_decoder_class,
3412 .init = hevc_decode_init,
3413 .close = hevc_decode_free,
3414 .decode = hevc_decode_frame,
3415 .flush = hevc_decode_flush,
3416 .update_thread_context = hevc_update_thread_context,
3417 .init_thread_copy = hevc_init_thread_copy,
3418 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
3419 AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS,
3420 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
3421 .profiles = NULL_IF_CONFIG_SMALL(ff_hevc_profiles),