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"
41 #include "hevc_data.h"
42 #include "hevc_parse.h"
46 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 };
49 * NOTE: Each function hls_foo correspond to the function foo in the
50 * specification (HLS stands for High Level Syntax).
57 /* free everything allocated by pic_arrays_init() */
58 static void pic_arrays_free(HEVCContext *s)
61 av_freep(&s->deblock);
63 av_freep(&s->skip_flag);
64 av_freep(&s->tab_ct_depth);
66 av_freep(&s->tab_ipm);
67 av_freep(&s->cbf_luma);
70 av_freep(&s->qp_y_tab);
71 av_freep(&s->tab_slice_address);
72 av_freep(&s->filter_slice_edges);
74 av_freep(&s->horizontal_bs);
75 av_freep(&s->vertical_bs);
77 av_freep(&s->sh.entry_point_offset);
78 av_freep(&s->sh.size);
79 av_freep(&s->sh.offset);
81 av_buffer_pool_uninit(&s->tab_mvf_pool);
82 av_buffer_pool_uninit(&s->rpl_tab_pool);
85 /* allocate arrays that depend on frame dimensions */
86 static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
88 int log2_min_cb_size = sps->log2_min_cb_size;
89 int width = sps->width;
90 int height = sps->height;
91 int pic_size_in_ctb = ((width >> log2_min_cb_size) + 1) *
92 ((height >> log2_min_cb_size) + 1);
93 int ctb_count = sps->ctb_width * sps->ctb_height;
94 int min_pu_size = sps->min_pu_width * sps->min_pu_height;
96 s->bs_width = (width >> 2) + 1;
97 s->bs_height = (height >> 2) + 1;
99 s->sao = av_mallocz_array(ctb_count, sizeof(*s->sao));
100 s->deblock = av_mallocz_array(ctb_count, sizeof(*s->deblock));
101 if (!s->sao || !s->deblock)
104 s->skip_flag = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
105 s->tab_ct_depth = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
106 if (!s->skip_flag || !s->tab_ct_depth)
109 s->cbf_luma = av_malloc_array(sps->min_tb_width, sps->min_tb_height);
110 s->tab_ipm = av_mallocz(min_pu_size);
111 s->is_pcm = av_malloc_array(sps->min_pu_width + 1, sps->min_pu_height + 1);
112 if (!s->tab_ipm || !s->cbf_luma || !s->is_pcm)
115 s->filter_slice_edges = av_mallocz(ctb_count);
116 s->tab_slice_address = av_malloc_array(pic_size_in_ctb,
117 sizeof(*s->tab_slice_address));
118 s->qp_y_tab = av_malloc_array(pic_size_in_ctb,
119 sizeof(*s->qp_y_tab));
120 if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address)
123 s->horizontal_bs = av_mallocz_array(s->bs_width, s->bs_height);
124 s->vertical_bs = av_mallocz_array(s->bs_width, s->bs_height);
125 if (!s->horizontal_bs || !s->vertical_bs)
128 s->tab_mvf_pool = av_buffer_pool_init(min_pu_size * sizeof(MvField),
130 s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab),
132 if (!s->tab_mvf_pool || !s->rpl_tab_pool)
139 return AVERROR(ENOMEM);
142 static void pred_weight_table(HEVCContext *s, GetBitContext *gb)
146 uint8_t luma_weight_l0_flag[16];
147 uint8_t chroma_weight_l0_flag[16];
148 uint8_t luma_weight_l1_flag[16];
149 uint8_t chroma_weight_l1_flag[16];
150 int luma_log2_weight_denom;
152 luma_log2_weight_denom = get_ue_golomb_long(gb);
153 if (luma_log2_weight_denom < 0 || luma_log2_weight_denom > 7)
154 av_log(s->avctx, AV_LOG_ERROR, "luma_log2_weight_denom %d is invalid\n", luma_log2_weight_denom);
155 s->sh.luma_log2_weight_denom = av_clip_uintp2(luma_log2_weight_denom, 3);
156 if (s->ps.sps->chroma_format_idc != 0) {
157 int delta = get_se_golomb(gb);
158 s->sh.chroma_log2_weight_denom = av_clip_uintp2(s->sh.luma_log2_weight_denom + delta, 3);
161 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
162 luma_weight_l0_flag[i] = get_bits1(gb);
163 if (!luma_weight_l0_flag[i]) {
164 s->sh.luma_weight_l0[i] = 1 << s->sh.luma_log2_weight_denom;
165 s->sh.luma_offset_l0[i] = 0;
168 if (s->ps.sps->chroma_format_idc != 0) {
169 for (i = 0; i < s->sh.nb_refs[L0]; i++)
170 chroma_weight_l0_flag[i] = get_bits1(gb);
172 for (i = 0; i < s->sh.nb_refs[L0]; i++)
173 chroma_weight_l0_flag[i] = 0;
175 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
176 if (luma_weight_l0_flag[i]) {
177 int delta_luma_weight_l0 = get_se_golomb(gb);
178 s->sh.luma_weight_l0[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;
179 s->sh.luma_offset_l0[i] = get_se_golomb(gb);
181 if (chroma_weight_l0_flag[i]) {
182 for (j = 0; j < 2; j++) {
183 int delta_chroma_weight_l0 = get_se_golomb(gb);
184 int delta_chroma_offset_l0 = get_se_golomb(gb);
185 s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
186 s->sh.chroma_offset_l0[i][j] = av_clip((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j])
187 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
190 s->sh.chroma_weight_l0[i][0] = 1 << s->sh.chroma_log2_weight_denom;
191 s->sh.chroma_offset_l0[i][0] = 0;
192 s->sh.chroma_weight_l0[i][1] = 1 << s->sh.chroma_log2_weight_denom;
193 s->sh.chroma_offset_l0[i][1] = 0;
196 if (s->sh.slice_type == HEVC_SLICE_B) {
197 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
198 luma_weight_l1_flag[i] = get_bits1(gb);
199 if (!luma_weight_l1_flag[i]) {
200 s->sh.luma_weight_l1[i] = 1 << s->sh.luma_log2_weight_denom;
201 s->sh.luma_offset_l1[i] = 0;
204 if (s->ps.sps->chroma_format_idc != 0) {
205 for (i = 0; i < s->sh.nb_refs[L1]; i++)
206 chroma_weight_l1_flag[i] = get_bits1(gb);
208 for (i = 0; i < s->sh.nb_refs[L1]; i++)
209 chroma_weight_l1_flag[i] = 0;
211 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
212 if (luma_weight_l1_flag[i]) {
213 int delta_luma_weight_l1 = get_se_golomb(gb);
214 s->sh.luma_weight_l1[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;
215 s->sh.luma_offset_l1[i] = get_se_golomb(gb);
217 if (chroma_weight_l1_flag[i]) {
218 for (j = 0; j < 2; j++) {
219 int delta_chroma_weight_l1 = get_se_golomb(gb);
220 int delta_chroma_offset_l1 = get_se_golomb(gb);
221 s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
222 s->sh.chroma_offset_l1[i][j] = av_clip((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j])
223 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
226 s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom;
227 s->sh.chroma_offset_l1[i][0] = 0;
228 s->sh.chroma_weight_l1[i][1] = 1 << s->sh.chroma_log2_weight_denom;
229 s->sh.chroma_offset_l1[i][1] = 0;
235 static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
237 const HEVCSPS *sps = s->ps.sps;
238 int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
239 int prev_delta_msb = 0;
240 unsigned int nb_sps = 0, nb_sh;
244 if (!sps->long_term_ref_pics_present_flag)
247 if (sps->num_long_term_ref_pics_sps > 0)
248 nb_sps = get_ue_golomb_long(gb);
249 nb_sh = get_ue_golomb_long(gb);
251 if (nb_sh + (uint64_t)nb_sps > FF_ARRAY_ELEMS(rps->poc))
252 return AVERROR_INVALIDDATA;
254 rps->nb_refs = nb_sh + nb_sps;
256 for (i = 0; i < rps->nb_refs; i++) {
257 uint8_t delta_poc_msb_present;
260 uint8_t lt_idx_sps = 0;
262 if (sps->num_long_term_ref_pics_sps > 1)
263 lt_idx_sps = get_bits(gb, av_ceil_log2(sps->num_long_term_ref_pics_sps));
265 rps->poc[i] = sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
266 rps->used[i] = sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];
268 rps->poc[i] = get_bits(gb, sps->log2_max_poc_lsb);
269 rps->used[i] = get_bits1(gb);
272 delta_poc_msb_present = get_bits1(gb);
273 if (delta_poc_msb_present) {
274 int delta = get_ue_golomb_long(gb);
276 if (i && i != nb_sps)
277 delta += prev_delta_msb;
279 rps->poc[i] += s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
280 prev_delta_msb = delta;
287 static void export_stream_params(AVCodecContext *avctx, const HEVCParamSets *ps,
290 const HEVCVPS *vps = (const HEVCVPS*)ps->vps_list[sps->vps_id]->data;
291 unsigned int num = 0, den = 0;
293 avctx->pix_fmt = sps->pix_fmt;
294 avctx->coded_width = sps->width;
295 avctx->coded_height = sps->height;
296 avctx->width = sps->output_width;
297 avctx->height = sps->output_height;
298 avctx->has_b_frames = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics;
299 avctx->profile = sps->ptl.general_ptl.profile_idc;
300 avctx->level = sps->ptl.general_ptl.level_idc;
302 ff_set_sar(avctx, sps->vui.sar);
304 if (sps->vui.video_signal_type_present_flag)
305 avctx->color_range = sps->vui.video_full_range_flag ? AVCOL_RANGE_JPEG
308 avctx->color_range = AVCOL_RANGE_MPEG;
310 if (sps->vui.colour_description_present_flag) {
311 avctx->color_primaries = sps->vui.colour_primaries;
312 avctx->color_trc = sps->vui.transfer_characteristic;
313 avctx->colorspace = sps->vui.matrix_coeffs;
315 avctx->color_primaries = AVCOL_PRI_UNSPECIFIED;
316 avctx->color_trc = AVCOL_TRC_UNSPECIFIED;
317 avctx->colorspace = AVCOL_SPC_UNSPECIFIED;
320 if (vps->vps_timing_info_present_flag) {
321 num = vps->vps_num_units_in_tick;
322 den = vps->vps_time_scale;
323 } else if (sps->vui.vui_timing_info_present_flag) {
324 num = sps->vui.vui_num_units_in_tick;
325 den = sps->vui.vui_time_scale;
328 if (num != 0 && den != 0)
329 av_reduce(&avctx->framerate.den, &avctx->framerate.num,
333 static int set_sps(HEVCContext *s, const HEVCSPS *sps, enum AVPixelFormat pix_fmt)
335 #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + CONFIG_HEVC_D3D11VA_HWACCEL + CONFIG_HEVC_VAAPI_HWACCEL + CONFIG_HEVC_VDPAU_HWACCEL)
336 enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
346 ret = pic_arrays_init(s, sps);
350 export_stream_params(s->avctx, &s->ps, sps);
352 switch (sps->pix_fmt) {
353 case AV_PIX_FMT_YUV420P:
354 case AV_PIX_FMT_YUVJ420P:
355 #if CONFIG_HEVC_DXVA2_HWACCEL
356 *fmt++ = AV_PIX_FMT_DXVA2_VLD;
358 #if CONFIG_HEVC_D3D11VA_HWACCEL
359 *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
361 #if CONFIG_HEVC_VAAPI_HWACCEL
362 *fmt++ = AV_PIX_FMT_VAAPI;
364 #if CONFIG_HEVC_VDPAU_HWACCEL
365 *fmt++ = AV_PIX_FMT_VDPAU;
368 case AV_PIX_FMT_YUV420P10:
369 #if CONFIG_HEVC_DXVA2_HWACCEL
370 *fmt++ = AV_PIX_FMT_DXVA2_VLD;
372 #if CONFIG_HEVC_D3D11VA_HWACCEL
373 *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
375 #if CONFIG_HEVC_VAAPI_HWACCEL
376 *fmt++ = AV_PIX_FMT_VAAPI;
381 if (pix_fmt == AV_PIX_FMT_NONE) {
382 *fmt++ = sps->pix_fmt;
383 *fmt = AV_PIX_FMT_NONE;
385 ret = ff_thread_get_format(s->avctx, pix_fmts);
388 s->avctx->pix_fmt = ret;
391 s->avctx->pix_fmt = pix_fmt;
394 ff_hevc_pred_init(&s->hpc, sps->bit_depth);
395 ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
396 ff_videodsp_init (&s->vdsp, sps->bit_depth);
398 for (i = 0; i < 3; i++) {
399 av_freep(&s->sao_pixel_buffer_h[i]);
400 av_freep(&s->sao_pixel_buffer_v[i]);
403 if (sps->sao_enabled && !s->avctx->hwaccel) {
404 int c_count = (sps->chroma_format_idc != 0) ? 3 : 1;
407 for(c_idx = 0; c_idx < c_count; c_idx++) {
408 int w = sps->width >> sps->hshift[c_idx];
409 int h = sps->height >> sps->vshift[c_idx];
410 s->sao_pixel_buffer_h[c_idx] =
411 av_malloc((w * 2 * sps->ctb_height) <<
413 s->sao_pixel_buffer_v[c_idx] =
414 av_malloc((h * 2 * sps->ctb_width) <<
420 s->ps.vps = (HEVCVPS*) s->ps.vps_list[s->ps.sps->vps_id]->data;
430 static int hls_slice_header(HEVCContext *s)
432 GetBitContext *gb = &s->HEVClc->gb;
433 SliceHeader *sh = &s->sh;
437 sh->first_slice_in_pic_flag = get_bits1(gb);
438 if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
439 s->seq_decode = (s->seq_decode + 1) & 0xff;
442 ff_hevc_clear_refs(s);
444 sh->no_output_of_prior_pics_flag = 0;
446 sh->no_output_of_prior_pics_flag = get_bits1(gb);
448 sh->pps_id = get_ue_golomb_long(gb);
449 if (sh->pps_id >= HEVC_MAX_PPS_COUNT || !s->ps.pps_list[sh->pps_id]) {
450 av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
451 return AVERROR_INVALIDDATA;
453 if (!sh->first_slice_in_pic_flag &&
454 s->ps.pps != (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data) {
455 av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
456 return AVERROR_INVALIDDATA;
458 s->ps.pps = (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data;
459 if (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos == 1)
460 sh->no_output_of_prior_pics_flag = 1;
462 if (s->ps.sps != (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data) {
463 const HEVCSPS* last_sps = s->ps.sps;
464 s->ps.sps = (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data;
465 if (last_sps && IS_IRAP(s) && s->nal_unit_type != HEVC_NAL_CRA_NUT) {
466 if (s->ps.sps->width != last_sps->width || s->ps.sps->height != last_sps->height ||
467 s->ps.sps->temporal_layer[s->ps.sps->max_sub_layers - 1].max_dec_pic_buffering !=
468 last_sps->temporal_layer[last_sps->max_sub_layers - 1].max_dec_pic_buffering)
469 sh->no_output_of_prior_pics_flag = 0;
471 ff_hevc_clear_refs(s);
472 ret = set_sps(s, s->ps.sps, AV_PIX_FMT_NONE);
476 s->seq_decode = (s->seq_decode + 1) & 0xff;
480 sh->dependent_slice_segment_flag = 0;
481 if (!sh->first_slice_in_pic_flag) {
482 int slice_address_length;
484 if (s->ps.pps->dependent_slice_segments_enabled_flag)
485 sh->dependent_slice_segment_flag = get_bits1(gb);
487 slice_address_length = av_ceil_log2(s->ps.sps->ctb_width *
488 s->ps.sps->ctb_height);
489 sh->slice_segment_addr = get_bitsz(gb, slice_address_length);
490 if (sh->slice_segment_addr >= s->ps.sps->ctb_width * s->ps.sps->ctb_height) {
491 av_log(s->avctx, AV_LOG_ERROR,
492 "Invalid slice segment address: %u.\n",
493 sh->slice_segment_addr);
494 return AVERROR_INVALIDDATA;
497 if (!sh->dependent_slice_segment_flag) {
498 sh->slice_addr = sh->slice_segment_addr;
502 sh->slice_segment_addr = sh->slice_addr = 0;
504 s->slice_initialized = 0;
507 if (!sh->dependent_slice_segment_flag) {
508 s->slice_initialized = 0;
510 for (i = 0; i < s->ps.pps->num_extra_slice_header_bits; i++)
511 skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
513 sh->slice_type = get_ue_golomb_long(gb);
514 if (!(sh->slice_type == HEVC_SLICE_I ||
515 sh->slice_type == HEVC_SLICE_P ||
516 sh->slice_type == HEVC_SLICE_B)) {
517 av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
519 return AVERROR_INVALIDDATA;
521 if (IS_IRAP(s) && sh->slice_type != HEVC_SLICE_I) {
522 av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
523 return AVERROR_INVALIDDATA;
526 // when flag is not present, picture is inferred to be output
527 sh->pic_output_flag = 1;
528 if (s->ps.pps->output_flag_present_flag)
529 sh->pic_output_flag = get_bits1(gb);
531 if (s->ps.sps->separate_colour_plane_flag)
532 sh->colour_plane_id = get_bits(gb, 2);
537 sh->pic_order_cnt_lsb = get_bits(gb, s->ps.sps->log2_max_poc_lsb);
538 poc = ff_hevc_compute_poc(s, sh->pic_order_cnt_lsb);
539 if (!sh->first_slice_in_pic_flag && poc != s->poc) {
540 av_log(s->avctx, AV_LOG_WARNING,
541 "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
542 if (s->avctx->err_recognition & AV_EF_EXPLODE)
543 return AVERROR_INVALIDDATA;
548 sh->short_term_ref_pic_set_sps_flag = get_bits1(gb);
549 pos = get_bits_left(gb);
550 if (!sh->short_term_ref_pic_set_sps_flag) {
551 ret = ff_hevc_decode_short_term_rps(gb, s->avctx, &sh->slice_rps, s->ps.sps, 1);
555 sh->short_term_rps = &sh->slice_rps;
557 int numbits, rps_idx;
559 if (!s->ps.sps->nb_st_rps) {
560 av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
561 return AVERROR_INVALIDDATA;
564 numbits = av_ceil_log2(s->ps.sps->nb_st_rps);
565 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
566 sh->short_term_rps = &s->ps.sps->st_rps[rps_idx];
568 sh->short_term_ref_pic_set_size = pos - get_bits_left(gb);
570 pos = get_bits_left(gb);
571 ret = decode_lt_rps(s, &sh->long_term_rps, gb);
573 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
574 if (s->avctx->err_recognition & AV_EF_EXPLODE)
575 return AVERROR_INVALIDDATA;
577 sh->long_term_ref_pic_set_size = pos - get_bits_left(gb);
579 if (s->ps.sps->sps_temporal_mvp_enabled_flag)
580 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
582 sh->slice_temporal_mvp_enabled_flag = 0;
584 s->sh.short_term_rps = NULL;
589 if (sh->first_slice_in_pic_flag && s->temporal_id == 0 &&
590 s->nal_unit_type != HEVC_NAL_TRAIL_N &&
591 s->nal_unit_type != HEVC_NAL_TSA_N &&
592 s->nal_unit_type != HEVC_NAL_STSA_N &&
593 s->nal_unit_type != HEVC_NAL_RADL_N &&
594 s->nal_unit_type != HEVC_NAL_RADL_R &&
595 s->nal_unit_type != HEVC_NAL_RASL_N &&
596 s->nal_unit_type != HEVC_NAL_RASL_R)
599 if (s->ps.sps->sao_enabled) {
600 sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
601 if (s->ps.sps->chroma_format_idc) {
602 sh->slice_sample_adaptive_offset_flag[1] =
603 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
606 sh->slice_sample_adaptive_offset_flag[0] = 0;
607 sh->slice_sample_adaptive_offset_flag[1] = 0;
608 sh->slice_sample_adaptive_offset_flag[2] = 0;
611 sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
612 if (sh->slice_type == HEVC_SLICE_P || sh->slice_type == HEVC_SLICE_B) {
615 sh->nb_refs[L0] = s->ps.pps->num_ref_idx_l0_default_active;
616 if (sh->slice_type == HEVC_SLICE_B)
617 sh->nb_refs[L1] = s->ps.pps->num_ref_idx_l1_default_active;
619 if (get_bits1(gb)) { // num_ref_idx_active_override_flag
620 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
621 if (sh->slice_type == HEVC_SLICE_B)
622 sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
624 if (sh->nb_refs[L0] > HEVC_MAX_REFS || sh->nb_refs[L1] > HEVC_MAX_REFS) {
625 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
626 sh->nb_refs[L0], sh->nb_refs[L1]);
627 return AVERROR_INVALIDDATA;
630 sh->rpl_modification_flag[0] = 0;
631 sh->rpl_modification_flag[1] = 0;
632 nb_refs = ff_hevc_frame_nb_refs(s);
634 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
635 return AVERROR_INVALIDDATA;
638 if (s->ps.pps->lists_modification_present_flag && nb_refs > 1) {
639 sh->rpl_modification_flag[0] = get_bits1(gb);
640 if (sh->rpl_modification_flag[0]) {
641 for (i = 0; i < sh->nb_refs[L0]; i++)
642 sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
645 if (sh->slice_type == HEVC_SLICE_B) {
646 sh->rpl_modification_flag[1] = get_bits1(gb);
647 if (sh->rpl_modification_flag[1] == 1)
648 for (i = 0; i < sh->nb_refs[L1]; i++)
649 sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
653 if (sh->slice_type == HEVC_SLICE_B)
654 sh->mvd_l1_zero_flag = get_bits1(gb);
656 if (s->ps.pps->cabac_init_present_flag)
657 sh->cabac_init_flag = get_bits1(gb);
659 sh->cabac_init_flag = 0;
661 sh->collocated_ref_idx = 0;
662 if (sh->slice_temporal_mvp_enabled_flag) {
663 sh->collocated_list = L0;
664 if (sh->slice_type == HEVC_SLICE_B)
665 sh->collocated_list = !get_bits1(gb);
667 if (sh->nb_refs[sh->collocated_list] > 1) {
668 sh->collocated_ref_idx = get_ue_golomb_long(gb);
669 if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
670 av_log(s->avctx, AV_LOG_ERROR,
671 "Invalid collocated_ref_idx: %d.\n",
672 sh->collocated_ref_idx);
673 return AVERROR_INVALIDDATA;
678 if ((s->ps.pps->weighted_pred_flag && sh->slice_type == HEVC_SLICE_P) ||
679 (s->ps.pps->weighted_bipred_flag && sh->slice_type == HEVC_SLICE_B)) {
680 pred_weight_table(s, gb);
683 sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
684 if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
685 av_log(s->avctx, AV_LOG_ERROR,
686 "Invalid number of merging MVP candidates: %d.\n",
687 sh->max_num_merge_cand);
688 return AVERROR_INVALIDDATA;
692 sh->slice_qp_delta = get_se_golomb(gb);
694 if (s->ps.pps->pic_slice_level_chroma_qp_offsets_present_flag) {
695 sh->slice_cb_qp_offset = get_se_golomb(gb);
696 sh->slice_cr_qp_offset = get_se_golomb(gb);
698 sh->slice_cb_qp_offset = 0;
699 sh->slice_cr_qp_offset = 0;
702 if (s->ps.pps->chroma_qp_offset_list_enabled_flag)
703 sh->cu_chroma_qp_offset_enabled_flag = get_bits1(gb);
705 sh->cu_chroma_qp_offset_enabled_flag = 0;
707 if (s->ps.pps->deblocking_filter_control_present_flag) {
708 int deblocking_filter_override_flag = 0;
710 if (s->ps.pps->deblocking_filter_override_enabled_flag)
711 deblocking_filter_override_flag = get_bits1(gb);
713 if (deblocking_filter_override_flag) {
714 sh->disable_deblocking_filter_flag = get_bits1(gb);
715 if (!sh->disable_deblocking_filter_flag) {
716 sh->beta_offset = get_se_golomb(gb) * 2;
717 sh->tc_offset = get_se_golomb(gb) * 2;
720 sh->disable_deblocking_filter_flag = s->ps.pps->disable_dbf;
721 sh->beta_offset = s->ps.pps->beta_offset;
722 sh->tc_offset = s->ps.pps->tc_offset;
725 sh->disable_deblocking_filter_flag = 0;
730 if (s->ps.pps->seq_loop_filter_across_slices_enabled_flag &&
731 (sh->slice_sample_adaptive_offset_flag[0] ||
732 sh->slice_sample_adaptive_offset_flag[1] ||
733 !sh->disable_deblocking_filter_flag)) {
734 sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
736 sh->slice_loop_filter_across_slices_enabled_flag = s->ps.pps->seq_loop_filter_across_slices_enabled_flag;
738 } else if (!s->slice_initialized) {
739 av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
740 return AVERROR_INVALIDDATA;
743 sh->num_entry_point_offsets = 0;
744 if (s->ps.pps->tiles_enabled_flag || s->ps.pps->entropy_coding_sync_enabled_flag) {
745 unsigned num_entry_point_offsets = get_ue_golomb_long(gb);
746 // It would be possible to bound this tighter but this here is simpler
747 if (num_entry_point_offsets > get_bits_left(gb)) {
748 av_log(s->avctx, AV_LOG_ERROR, "num_entry_point_offsets %d is invalid\n", num_entry_point_offsets);
749 return AVERROR_INVALIDDATA;
752 sh->num_entry_point_offsets = num_entry_point_offsets;
753 if (sh->num_entry_point_offsets > 0) {
754 int offset_len = get_ue_golomb_long(gb) + 1;
756 if (offset_len < 1 || offset_len > 32) {
757 sh->num_entry_point_offsets = 0;
758 av_log(s->avctx, AV_LOG_ERROR, "offset_len %d is invalid\n", offset_len);
759 return AVERROR_INVALIDDATA;
762 av_freep(&sh->entry_point_offset);
763 av_freep(&sh->offset);
765 sh->entry_point_offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(unsigned));
766 sh->offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
767 sh->size = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
768 if (!sh->entry_point_offset || !sh->offset || !sh->size) {
769 sh->num_entry_point_offsets = 0;
770 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate memory\n");
771 return AVERROR(ENOMEM);
773 for (i = 0; i < sh->num_entry_point_offsets; i++) {
774 unsigned val = get_bits_long(gb, offset_len);
775 sh->entry_point_offset[i] = val + 1; // +1; // +1 to get the size
777 if (s->threads_number > 1 && (s->ps.pps->num_tile_rows > 1 || s->ps.pps->num_tile_columns > 1)) {
778 s->enable_parallel_tiles = 0; // TODO: you can enable tiles in parallel here
779 s->threads_number = 1;
781 s->enable_parallel_tiles = 0;
783 s->enable_parallel_tiles = 0;
786 if (s->ps.pps->slice_header_extension_present_flag) {
787 unsigned int length = get_ue_golomb_long(gb);
788 if (length*8LL > get_bits_left(gb)) {
789 av_log(s->avctx, AV_LOG_ERROR, "too many slice_header_extension_data_bytes\n");
790 return AVERROR_INVALIDDATA;
792 for (i = 0; i < length; i++)
793 skip_bits(gb, 8); // slice_header_extension_data_byte
796 // Inferred parameters
797 sh->slice_qp = 26U + s->ps.pps->pic_init_qp_minus26 + sh->slice_qp_delta;
798 if (sh->slice_qp > 51 ||
799 sh->slice_qp < -s->ps.sps->qp_bd_offset) {
800 av_log(s->avctx, AV_LOG_ERROR,
801 "The slice_qp %d is outside the valid range "
804 -s->ps.sps->qp_bd_offset);
805 return AVERROR_INVALIDDATA;
808 sh->slice_ctb_addr_rs = sh->slice_segment_addr;
810 if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) {
811 av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
812 return AVERROR_INVALIDDATA;
815 if (get_bits_left(gb) < 0) {
816 av_log(s->avctx, AV_LOG_ERROR,
817 "Overread slice header by %d bits\n", -get_bits_left(gb));
818 return AVERROR_INVALIDDATA;
821 s->HEVClc->first_qp_group = !s->sh.dependent_slice_segment_flag;
823 if (!s->ps.pps->cu_qp_delta_enabled_flag)
824 s->HEVClc->qp_y = s->sh.slice_qp;
826 s->slice_initialized = 1;
827 s->HEVClc->tu.cu_qp_offset_cb = 0;
828 s->HEVClc->tu.cu_qp_offset_cr = 0;
833 #define CTB(tab, x, y) ((tab)[(y) * s->ps.sps->ctb_width + (x)])
835 #define SET_SAO(elem, value) \
837 if (!sao_merge_up_flag && !sao_merge_left_flag) \
839 else if (sao_merge_left_flag) \
840 sao->elem = CTB(s->sao, rx-1, ry).elem; \
841 else if (sao_merge_up_flag) \
842 sao->elem = CTB(s->sao, rx, ry-1).elem; \
847 static void hls_sao_param(HEVCContext *s, int rx, int ry)
849 HEVCLocalContext *lc = s->HEVClc;
850 int sao_merge_left_flag = 0;
851 int sao_merge_up_flag = 0;
852 SAOParams *sao = &CTB(s->sao, rx, ry);
855 if (s->sh.slice_sample_adaptive_offset_flag[0] ||
856 s->sh.slice_sample_adaptive_offset_flag[1]) {
858 if (lc->ctb_left_flag)
859 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
861 if (ry > 0 && !sao_merge_left_flag) {
863 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
867 for (c_idx = 0; c_idx < (s->ps.sps->chroma_format_idc ? 3 : 1); c_idx++) {
868 int log2_sao_offset_scale = c_idx == 0 ? s->ps.pps->log2_sao_offset_scale_luma :
869 s->ps.pps->log2_sao_offset_scale_chroma;
871 if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
872 sao->type_idx[c_idx] = SAO_NOT_APPLIED;
877 sao->type_idx[2] = sao->type_idx[1];
878 sao->eo_class[2] = sao->eo_class[1];
880 SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
883 if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
886 for (i = 0; i < 4; i++)
887 SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
889 if (sao->type_idx[c_idx] == SAO_BAND) {
890 for (i = 0; i < 4; i++) {
891 if (sao->offset_abs[c_idx][i]) {
892 SET_SAO(offset_sign[c_idx][i],
893 ff_hevc_sao_offset_sign_decode(s));
895 sao->offset_sign[c_idx][i] = 0;
898 SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
899 } else if (c_idx != 2) {
900 SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
903 // Inferred parameters
904 sao->offset_val[c_idx][0] = 0;
905 for (i = 0; i < 4; i++) {
906 sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i];
907 if (sao->type_idx[c_idx] == SAO_EDGE) {
909 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
910 } else if (sao->offset_sign[c_idx][i]) {
911 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
913 sao->offset_val[c_idx][i + 1] *= 1 << log2_sao_offset_scale;
921 static int hls_cross_component_pred(HEVCContext *s, int idx) {
922 HEVCLocalContext *lc = s->HEVClc;
923 int log2_res_scale_abs_plus1 = ff_hevc_log2_res_scale_abs(s, idx);
925 if (log2_res_scale_abs_plus1 != 0) {
926 int res_scale_sign_flag = ff_hevc_res_scale_sign_flag(s, idx);
927 lc->tu.res_scale_val = (1 << (log2_res_scale_abs_plus1 - 1)) *
928 (1 - 2 * res_scale_sign_flag);
930 lc->tu.res_scale_val = 0;
937 static int hls_transform_unit(HEVCContext *s, int x0, int y0,
938 int xBase, int yBase, int cb_xBase, int cb_yBase,
939 int log2_cb_size, int log2_trafo_size,
940 int blk_idx, int cbf_luma, int *cbf_cb, int *cbf_cr)
942 HEVCLocalContext *lc = s->HEVClc;
943 const int log2_trafo_size_c = log2_trafo_size - s->ps.sps->hshift[1];
946 if (lc->cu.pred_mode == MODE_INTRA) {
947 int trafo_size = 1 << log2_trafo_size;
948 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
950 s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
953 if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
954 (s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
955 int scan_idx = SCAN_DIAG;
956 int scan_idx_c = SCAN_DIAG;
957 int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
958 (s->ps.sps->chroma_format_idc == 2 &&
959 (cbf_cb[1] || cbf_cr[1]));
961 if (s->ps.pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
962 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
963 if (lc->tu.cu_qp_delta != 0)
964 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
965 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
966 lc->tu.is_cu_qp_delta_coded = 1;
968 if (lc->tu.cu_qp_delta < -(26 + s->ps.sps->qp_bd_offset / 2) ||
969 lc->tu.cu_qp_delta > (25 + s->ps.sps->qp_bd_offset / 2)) {
970 av_log(s->avctx, AV_LOG_ERROR,
971 "The cu_qp_delta %d is outside the valid range "
974 -(26 + s->ps.sps->qp_bd_offset / 2),
975 (25 + s->ps.sps->qp_bd_offset / 2));
976 return AVERROR_INVALIDDATA;
979 ff_hevc_set_qPy(s, cb_xBase, cb_yBase, log2_cb_size);
982 if (s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
983 !lc->cu.cu_transquant_bypass_flag && !lc->tu.is_cu_chroma_qp_offset_coded) {
984 int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(s);
985 if (cu_chroma_qp_offset_flag) {
986 int cu_chroma_qp_offset_idx = 0;
987 if (s->ps.pps->chroma_qp_offset_list_len_minus1 > 0) {
988 cu_chroma_qp_offset_idx = ff_hevc_cu_chroma_qp_offset_idx(s);
989 av_log(s->avctx, AV_LOG_ERROR,
990 "cu_chroma_qp_offset_idx not yet tested.\n");
992 lc->tu.cu_qp_offset_cb = s->ps.pps->cb_qp_offset_list[cu_chroma_qp_offset_idx];
993 lc->tu.cu_qp_offset_cr = s->ps.pps->cr_qp_offset_list[cu_chroma_qp_offset_idx];
995 lc->tu.cu_qp_offset_cb = 0;
996 lc->tu.cu_qp_offset_cr = 0;
998 lc->tu.is_cu_chroma_qp_offset_coded = 1;
1001 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
1002 if (lc->tu.intra_pred_mode >= 6 &&
1003 lc->tu.intra_pred_mode <= 14) {
1004 scan_idx = SCAN_VERT;
1005 } else if (lc->tu.intra_pred_mode >= 22 &&
1006 lc->tu.intra_pred_mode <= 30) {
1007 scan_idx = SCAN_HORIZ;
1010 if (lc->tu.intra_pred_mode_c >= 6 &&
1011 lc->tu.intra_pred_mode_c <= 14) {
1012 scan_idx_c = SCAN_VERT;
1013 } else if (lc->tu.intra_pred_mode_c >= 22 &&
1014 lc->tu.intra_pred_mode_c <= 30) {
1015 scan_idx_c = SCAN_HORIZ;
1019 lc->tu.cross_pf = 0;
1022 ff_hevc_hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
1023 if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) {
1024 int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]);
1025 int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]);
1026 lc->tu.cross_pf = (s->ps.pps->cross_component_prediction_enabled_flag && cbf_luma &&
1027 (lc->cu.pred_mode == MODE_INTER ||
1028 (lc->tu.chroma_mode_c == 4)));
1030 if (lc->tu.cross_pf) {
1031 hls_cross_component_pred(s, 0);
1033 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1034 if (lc->cu.pred_mode == MODE_INTRA) {
1035 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1036 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 1);
1039 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1040 log2_trafo_size_c, scan_idx_c, 1);
1042 if (lc->tu.cross_pf) {
1043 ptrdiff_t stride = s->frame->linesize[1];
1044 int hshift = s->ps.sps->hshift[1];
1045 int vshift = s->ps.sps->vshift[1];
1046 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1047 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1048 int size = 1 << log2_trafo_size_c;
1050 uint8_t *dst = &s->frame->data[1][(y0 >> vshift) * stride +
1051 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1052 for (i = 0; i < (size * size); i++) {
1053 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1055 s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
1059 if (lc->tu.cross_pf) {
1060 hls_cross_component_pred(s, 1);
1062 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1063 if (lc->cu.pred_mode == MODE_INTRA) {
1064 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1065 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 2);
1068 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1069 log2_trafo_size_c, scan_idx_c, 2);
1071 if (lc->tu.cross_pf) {
1072 ptrdiff_t stride = s->frame->linesize[2];
1073 int hshift = s->ps.sps->hshift[2];
1074 int vshift = s->ps.sps->vshift[2];
1075 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1076 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1077 int size = 1 << log2_trafo_size_c;
1079 uint8_t *dst = &s->frame->data[2][(y0 >> vshift) * stride +
1080 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1081 for (i = 0; i < (size * size); i++) {
1082 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1084 s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
1087 } else if (s->ps.sps->chroma_format_idc && blk_idx == 3) {
1088 int trafo_size_h = 1 << (log2_trafo_size + 1);
1089 int trafo_size_v = 1 << (log2_trafo_size + s->ps.sps->vshift[1]);
1090 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1091 if (lc->cu.pred_mode == MODE_INTRA) {
1092 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1093 trafo_size_h, trafo_size_v);
1094 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 1);
1097 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1098 log2_trafo_size, scan_idx_c, 1);
1100 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1101 if (lc->cu.pred_mode == MODE_INTRA) {
1102 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1103 trafo_size_h, trafo_size_v);
1104 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 2);
1107 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1108 log2_trafo_size, scan_idx_c, 2);
1111 } else if (s->ps.sps->chroma_format_idc && lc->cu.pred_mode == MODE_INTRA) {
1112 if (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3) {
1113 int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]);
1114 int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]);
1115 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size_h, trafo_size_v);
1116 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 1);
1117 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 2);
1118 if (s->ps.sps->chroma_format_idc == 2) {
1119 ff_hevc_set_neighbour_available(s, x0, y0 + (1 << log2_trafo_size_c),
1120 trafo_size_h, trafo_size_v);
1121 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 1);
1122 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 2);
1124 } else if (blk_idx == 3) {
1125 int trafo_size_h = 1 << (log2_trafo_size + 1);
1126 int trafo_size_v = 1 << (log2_trafo_size + s->ps.sps->vshift[1]);
1127 ff_hevc_set_neighbour_available(s, xBase, yBase,
1128 trafo_size_h, trafo_size_v);
1129 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1130 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1131 if (s->ps.sps->chroma_format_idc == 2) {
1132 ff_hevc_set_neighbour_available(s, xBase, yBase + (1 << (log2_trafo_size)),
1133 trafo_size_h, trafo_size_v);
1134 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 1);
1135 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 2);
1143 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1145 int cb_size = 1 << log2_cb_size;
1146 int log2_min_pu_size = s->ps.sps->log2_min_pu_size;
1148 int min_pu_width = s->ps.sps->min_pu_width;
1149 int x_end = FFMIN(x0 + cb_size, s->ps.sps->width);
1150 int y_end = FFMIN(y0 + cb_size, s->ps.sps->height);
1153 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1154 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1155 s->is_pcm[i + j * min_pu_width] = 2;
1158 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1159 int xBase, int yBase, int cb_xBase, int cb_yBase,
1160 int log2_cb_size, int log2_trafo_size,
1161 int trafo_depth, int blk_idx,
1162 const int *base_cbf_cb, const int *base_cbf_cr)
1164 HEVCLocalContext *lc = s->HEVClc;
1165 uint8_t split_transform_flag;
1170 cbf_cb[0] = base_cbf_cb[0];
1171 cbf_cb[1] = base_cbf_cb[1];
1172 cbf_cr[0] = base_cbf_cr[0];
1173 cbf_cr[1] = base_cbf_cr[1];
1175 if (lc->cu.intra_split_flag) {
1176 if (trafo_depth == 1) {
1177 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1178 if (s->ps.sps->chroma_format_idc == 3) {
1179 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[blk_idx];
1180 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[blk_idx];
1182 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1183 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1187 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[0];
1188 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1189 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1192 if (log2_trafo_size <= s->ps.sps->log2_max_trafo_size &&
1193 log2_trafo_size > s->ps.sps->log2_min_tb_size &&
1194 trafo_depth < lc->cu.max_trafo_depth &&
1195 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1196 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1198 int inter_split = s->ps.sps->max_transform_hierarchy_depth_inter == 0 &&
1199 lc->cu.pred_mode == MODE_INTER &&
1200 lc->cu.part_mode != PART_2Nx2N &&
1203 split_transform_flag = log2_trafo_size > s->ps.sps->log2_max_trafo_size ||
1204 (lc->cu.intra_split_flag && trafo_depth == 0) ||
1208 if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) {
1209 if (trafo_depth == 0 || cbf_cb[0]) {
1210 cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1211 if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1212 cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1216 if (trafo_depth == 0 || cbf_cr[0]) {
1217 cbf_cr[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1218 if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1219 cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1224 if (split_transform_flag) {
1225 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1226 const int x1 = x0 + trafo_size_split;
1227 const int y1 = y0 + trafo_size_split;
1229 #define SUBDIVIDE(x, y, idx) \
1231 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1232 log2_trafo_size - 1, trafo_depth + 1, idx, \
1238 SUBDIVIDE(x0, y0, 0);
1239 SUBDIVIDE(x1, y0, 1);
1240 SUBDIVIDE(x0, y1, 2);
1241 SUBDIVIDE(x1, y1, 3);
1245 int min_tu_size = 1 << s->ps.sps->log2_min_tb_size;
1246 int log2_min_tu_size = s->ps.sps->log2_min_tb_size;
1247 int min_tu_width = s->ps.sps->min_tb_width;
1250 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1251 cbf_cb[0] || cbf_cr[0] ||
1252 (s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1253 cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1256 ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1257 log2_cb_size, log2_trafo_size,
1258 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1261 // TODO: store cbf_luma somewhere else
1264 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1265 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1266 int x_tu = (x0 + j) >> log2_min_tu_size;
1267 int y_tu = (y0 + i) >> log2_min_tu_size;
1268 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1271 if (!s->sh.disable_deblocking_filter_flag) {
1272 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1273 if (s->ps.pps->transquant_bypass_enable_flag &&
1274 lc->cu.cu_transquant_bypass_flag)
1275 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1281 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1283 HEVCLocalContext *lc = s->HEVClc;
1285 int cb_size = 1 << log2_cb_size;
1286 ptrdiff_t stride0 = s->frame->linesize[0];
1287 ptrdiff_t stride1 = s->frame->linesize[1];
1288 ptrdiff_t stride2 = s->frame->linesize[2];
1289 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->ps.sps->pixel_shift)];
1290 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)];
1291 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)];
1293 int length = cb_size * cb_size * s->ps.sps->pcm.bit_depth +
1294 (((cb_size >> s->ps.sps->hshift[1]) * (cb_size >> s->ps.sps->vshift[1])) +
1295 ((cb_size >> s->ps.sps->hshift[2]) * (cb_size >> s->ps.sps->vshift[2]))) *
1296 s->ps.sps->pcm.bit_depth_chroma;
1297 const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1300 if (!s->sh.disable_deblocking_filter_flag)
1301 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1303 ret = init_get_bits(&gb, pcm, length);
1307 s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size, &gb, s->ps.sps->pcm.bit_depth);
1308 if (s->ps.sps->chroma_format_idc) {
1309 s->hevcdsp.put_pcm(dst1, stride1,
1310 cb_size >> s->ps.sps->hshift[1],
1311 cb_size >> s->ps.sps->vshift[1],
1312 &gb, s->ps.sps->pcm.bit_depth_chroma);
1313 s->hevcdsp.put_pcm(dst2, stride2,
1314 cb_size >> s->ps.sps->hshift[2],
1315 cb_size >> s->ps.sps->vshift[2],
1316 &gb, s->ps.sps->pcm.bit_depth_chroma);
1323 * 8.5.3.2.2.1 Luma sample unidirectional interpolation process
1325 * @param s HEVC decoding context
1326 * @param dst target buffer for block data at block position
1327 * @param dststride stride of the dst buffer
1328 * @param ref reference picture buffer at origin (0, 0)
1329 * @param mv motion vector (relative to block position) to get pixel data from
1330 * @param x_off horizontal position of block from origin (0, 0)
1331 * @param y_off vertical position of block from origin (0, 0)
1332 * @param block_w width of block
1333 * @param block_h height of block
1334 * @param luma_weight weighting factor applied to the luma prediction
1335 * @param luma_offset additive offset applied to the luma prediction value
1338 static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1339 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1340 int block_w, int block_h, int luma_weight, int luma_offset)
1342 HEVCLocalContext *lc = s->HEVClc;
1343 uint8_t *src = ref->data[0];
1344 ptrdiff_t srcstride = ref->linesize[0];
1345 int pic_width = s->ps.sps->width;
1346 int pic_height = s->ps.sps->height;
1349 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1350 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1351 int idx = ff_hevc_pel_weight[block_w];
1353 x_off += mv->x >> 2;
1354 y_off += mv->y >> 2;
1355 src += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1357 if (x_off < QPEL_EXTRA_BEFORE || y_off < QPEL_EXTRA_AFTER ||
1358 x_off >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1359 y_off >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1360 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1361 int offset = QPEL_EXTRA_BEFORE * srcstride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1362 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1364 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1365 edge_emu_stride, srcstride,
1366 block_w + QPEL_EXTRA,
1367 block_h + QPEL_EXTRA,
1368 x_off - QPEL_EXTRA_BEFORE, y_off - QPEL_EXTRA_BEFORE,
1369 pic_width, pic_height);
1370 src = lc->edge_emu_buffer + buf_offset;
1371 srcstride = edge_emu_stride;
1375 s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride, src, srcstride,
1376 block_h, mx, my, block_w);
1378 s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride, src, srcstride,
1379 block_h, s->sh.luma_log2_weight_denom,
1380 luma_weight, luma_offset, mx, my, block_w);
1384 * 8.5.3.2.2.1 Luma sample bidirectional interpolation process
1386 * @param s HEVC decoding context
1387 * @param dst target buffer for block data at block position
1388 * @param dststride stride of the dst buffer
1389 * @param ref0 reference picture0 buffer at origin (0, 0)
1390 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1391 * @param x_off horizontal position of block from origin (0, 0)
1392 * @param y_off vertical position of block from origin (0, 0)
1393 * @param block_w width of block
1394 * @param block_h height of block
1395 * @param ref1 reference picture1 buffer at origin (0, 0)
1396 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1397 * @param current_mv current motion vector structure
1399 static void luma_mc_bi(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1400 AVFrame *ref0, const Mv *mv0, int x_off, int y_off,
1401 int block_w, int block_h, AVFrame *ref1, const Mv *mv1, struct MvField *current_mv)
1403 HEVCLocalContext *lc = s->HEVClc;
1404 ptrdiff_t src0stride = ref0->linesize[0];
1405 ptrdiff_t src1stride = ref1->linesize[0];
1406 int pic_width = s->ps.sps->width;
1407 int pic_height = s->ps.sps->height;
1408 int mx0 = mv0->x & 3;
1409 int my0 = mv0->y & 3;
1410 int mx1 = mv1->x & 3;
1411 int my1 = mv1->y & 3;
1412 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1413 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1414 int x_off0 = x_off + (mv0->x >> 2);
1415 int y_off0 = y_off + (mv0->y >> 2);
1416 int x_off1 = x_off + (mv1->x >> 2);
1417 int y_off1 = y_off + (mv1->y >> 2);
1418 int idx = ff_hevc_pel_weight[block_w];
1420 uint8_t *src0 = ref0->data[0] + y_off0 * src0stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift);
1421 uint8_t *src1 = ref1->data[0] + y_off1 * src1stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift);
1423 if (x_off0 < QPEL_EXTRA_BEFORE || y_off0 < QPEL_EXTRA_AFTER ||
1424 x_off0 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1425 y_off0 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1426 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1427 int offset = QPEL_EXTRA_BEFORE * src0stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1428 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1430 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset,
1431 edge_emu_stride, src0stride,
1432 block_w + QPEL_EXTRA,
1433 block_h + QPEL_EXTRA,
1434 x_off0 - QPEL_EXTRA_BEFORE, y_off0 - QPEL_EXTRA_BEFORE,
1435 pic_width, pic_height);
1436 src0 = lc->edge_emu_buffer + buf_offset;
1437 src0stride = edge_emu_stride;
1440 if (x_off1 < QPEL_EXTRA_BEFORE || y_off1 < QPEL_EXTRA_AFTER ||
1441 x_off1 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1442 y_off1 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1443 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1444 int offset = QPEL_EXTRA_BEFORE * src1stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1445 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1447 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src1 - offset,
1448 edge_emu_stride, src1stride,
1449 block_w + QPEL_EXTRA,
1450 block_h + QPEL_EXTRA,
1451 x_off1 - QPEL_EXTRA_BEFORE, y_off1 - QPEL_EXTRA_BEFORE,
1452 pic_width, pic_height);
1453 src1 = lc->edge_emu_buffer2 + buf_offset;
1454 src1stride = edge_emu_stride;
1457 s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](lc->tmp, src0, src0stride,
1458 block_h, mx0, my0, block_w);
1460 s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1461 block_h, mx1, my1, block_w);
1463 s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1464 block_h, s->sh.luma_log2_weight_denom,
1465 s->sh.luma_weight_l0[current_mv->ref_idx[0]],
1466 s->sh.luma_weight_l1[current_mv->ref_idx[1]],
1467 s->sh.luma_offset_l0[current_mv->ref_idx[0]],
1468 s->sh.luma_offset_l1[current_mv->ref_idx[1]],
1474 * 8.5.3.2.2.2 Chroma sample uniprediction interpolation process
1476 * @param s HEVC decoding context
1477 * @param dst1 target buffer for block data at block position (U plane)
1478 * @param dst2 target buffer for block data at block position (V plane)
1479 * @param dststride stride of the dst1 and dst2 buffers
1480 * @param ref reference picture buffer at origin (0, 0)
1481 * @param mv motion vector (relative to block position) to get pixel data from
1482 * @param x_off horizontal position of block from origin (0, 0)
1483 * @param y_off vertical position of block from origin (0, 0)
1484 * @param block_w width of block
1485 * @param block_h height of block
1486 * @param chroma_weight weighting factor applied to the chroma prediction
1487 * @param chroma_offset additive offset applied to the chroma prediction value
1490 static void chroma_mc_uni(HEVCContext *s, uint8_t *dst0,
1491 ptrdiff_t dststride, uint8_t *src0, ptrdiff_t srcstride, int reflist,
1492 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int chroma_weight, int chroma_offset)
1494 HEVCLocalContext *lc = s->HEVClc;
1495 int pic_width = s->ps.sps->width >> s->ps.sps->hshift[1];
1496 int pic_height = s->ps.sps->height >> s->ps.sps->vshift[1];
1497 const Mv *mv = ¤t_mv->mv[reflist];
1498 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1499 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1500 int idx = ff_hevc_pel_weight[block_w];
1501 int hshift = s->ps.sps->hshift[1];
1502 int vshift = s->ps.sps->vshift[1];
1503 intptr_t mx = av_mod_uintp2(mv->x, 2 + hshift);
1504 intptr_t my = av_mod_uintp2(mv->y, 2 + vshift);
1505 intptr_t _mx = mx << (1 - hshift);
1506 intptr_t _my = my << (1 - vshift);
1508 x_off += mv->x >> (2 + hshift);
1509 y_off += mv->y >> (2 + vshift);
1510 src0 += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1512 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1513 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1514 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1515 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1516 int offset0 = EPEL_EXTRA_BEFORE * (srcstride + (1 << s->ps.sps->pixel_shift));
1517 int buf_offset0 = EPEL_EXTRA_BEFORE *
1518 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1519 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset0,
1520 edge_emu_stride, srcstride,
1521 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1522 x_off - EPEL_EXTRA_BEFORE,
1523 y_off - EPEL_EXTRA_BEFORE,
1524 pic_width, pic_height);
1526 src0 = lc->edge_emu_buffer + buf_offset0;
1527 srcstride = edge_emu_stride;
1530 s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1531 block_h, _mx, _my, block_w);
1533 s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1534 block_h, s->sh.chroma_log2_weight_denom,
1535 chroma_weight, chroma_offset, _mx, _my, block_w);
1539 * 8.5.3.2.2.2 Chroma sample bidirectional interpolation process
1541 * @param s HEVC decoding context
1542 * @param dst target buffer for block data at block position
1543 * @param dststride stride of the dst buffer
1544 * @param ref0 reference picture0 buffer at origin (0, 0)
1545 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1546 * @param x_off horizontal position of block from origin (0, 0)
1547 * @param y_off vertical position of block from origin (0, 0)
1548 * @param block_w width of block
1549 * @param block_h height of block
1550 * @param ref1 reference picture1 buffer at origin (0, 0)
1551 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1552 * @param current_mv current motion vector structure
1553 * @param cidx chroma component(cb, cr)
1555 static void chroma_mc_bi(HEVCContext *s, uint8_t *dst0, ptrdiff_t dststride, AVFrame *ref0, AVFrame *ref1,
1556 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int cidx)
1558 HEVCLocalContext *lc = s->HEVClc;
1559 uint8_t *src1 = ref0->data[cidx+1];
1560 uint8_t *src2 = ref1->data[cidx+1];
1561 ptrdiff_t src1stride = ref0->linesize[cidx+1];
1562 ptrdiff_t src2stride = ref1->linesize[cidx+1];
1563 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1564 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1565 int pic_width = s->ps.sps->width >> s->ps.sps->hshift[1];
1566 int pic_height = s->ps.sps->height >> s->ps.sps->vshift[1];
1567 Mv *mv0 = ¤t_mv->mv[0];
1568 Mv *mv1 = ¤t_mv->mv[1];
1569 int hshift = s->ps.sps->hshift[1];
1570 int vshift = s->ps.sps->vshift[1];
1572 intptr_t mx0 = av_mod_uintp2(mv0->x, 2 + hshift);
1573 intptr_t my0 = av_mod_uintp2(mv0->y, 2 + vshift);
1574 intptr_t mx1 = av_mod_uintp2(mv1->x, 2 + hshift);
1575 intptr_t my1 = av_mod_uintp2(mv1->y, 2 + vshift);
1576 intptr_t _mx0 = mx0 << (1 - hshift);
1577 intptr_t _my0 = my0 << (1 - vshift);
1578 intptr_t _mx1 = mx1 << (1 - hshift);
1579 intptr_t _my1 = my1 << (1 - vshift);
1581 int x_off0 = x_off + (mv0->x >> (2 + hshift));
1582 int y_off0 = y_off + (mv0->y >> (2 + vshift));
1583 int x_off1 = x_off + (mv1->x >> (2 + hshift));
1584 int y_off1 = y_off + (mv1->y >> (2 + vshift));
1585 int idx = ff_hevc_pel_weight[block_w];
1586 src1 += y_off0 * src1stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift);
1587 src2 += y_off1 * src2stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift);
1589 if (x_off0 < EPEL_EXTRA_BEFORE || y_off0 < EPEL_EXTRA_AFTER ||
1590 x_off0 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1591 y_off0 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1592 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1593 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->ps.sps->pixel_shift));
1594 int buf_offset1 = EPEL_EXTRA_BEFORE *
1595 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1597 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1598 edge_emu_stride, src1stride,
1599 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1600 x_off0 - EPEL_EXTRA_BEFORE,
1601 y_off0 - EPEL_EXTRA_BEFORE,
1602 pic_width, pic_height);
1604 src1 = lc->edge_emu_buffer + buf_offset1;
1605 src1stride = edge_emu_stride;
1608 if (x_off1 < EPEL_EXTRA_BEFORE || y_off1 < EPEL_EXTRA_AFTER ||
1609 x_off1 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1610 y_off1 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1611 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1612 int offset1 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->ps.sps->pixel_shift));
1613 int buf_offset1 = EPEL_EXTRA_BEFORE *
1614 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1616 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src2 - offset1,
1617 edge_emu_stride, src2stride,
1618 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1619 x_off1 - EPEL_EXTRA_BEFORE,
1620 y_off1 - EPEL_EXTRA_BEFORE,
1621 pic_width, pic_height);
1623 src2 = lc->edge_emu_buffer2 + buf_offset1;
1624 src2stride = edge_emu_stride;
1627 s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](lc->tmp, src1, src1stride,
1628 block_h, _mx0, _my0, block_w);
1630 s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1631 src2, src2stride, lc->tmp,
1632 block_h, _mx1, _my1, block_w);
1634 s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1635 src2, src2stride, lc->tmp,
1637 s->sh.chroma_log2_weight_denom,
1638 s->sh.chroma_weight_l0[current_mv->ref_idx[0]][cidx],
1639 s->sh.chroma_weight_l1[current_mv->ref_idx[1]][cidx],
1640 s->sh.chroma_offset_l0[current_mv->ref_idx[0]][cidx],
1641 s->sh.chroma_offset_l1[current_mv->ref_idx[1]][cidx],
1642 _mx1, _my1, block_w);
1645 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1646 const Mv *mv, int y0, int height)
1648 int y = FFMAX(0, (mv->y >> 2) + y0 + height + 9);
1650 if (s->threads_type == FF_THREAD_FRAME )
1651 ff_thread_await_progress(&ref->tf, y, 0);
1654 static void hevc_luma_mv_mvp_mode(HEVCContext *s, int x0, int y0, int nPbW,
1655 int nPbH, int log2_cb_size, int part_idx,
1656 int merge_idx, MvField *mv)
1658 HEVCLocalContext *lc = s->HEVClc;
1659 enum InterPredIdc inter_pred_idc = PRED_L0;
1662 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1664 if (s->sh.slice_type == HEVC_SLICE_B)
1665 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1667 if (inter_pred_idc != PRED_L1) {
1668 if (s->sh.nb_refs[L0])
1669 mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1671 mv->pred_flag = PF_L0;
1672 ff_hevc_hls_mvd_coding(s, x0, y0, 0);
1673 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1674 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1675 part_idx, merge_idx, mv, mvp_flag, 0);
1676 mv->mv[0].x += lc->pu.mvd.x;
1677 mv->mv[0].y += lc->pu.mvd.y;
1680 if (inter_pred_idc != PRED_L0) {
1681 if (s->sh.nb_refs[L1])
1682 mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1684 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1685 AV_ZERO32(&lc->pu.mvd);
1687 ff_hevc_hls_mvd_coding(s, x0, y0, 1);
1690 mv->pred_flag += PF_L1;
1691 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1692 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1693 part_idx, merge_idx, mv, mvp_flag, 1);
1694 mv->mv[1].x += lc->pu.mvd.x;
1695 mv->mv[1].y += lc->pu.mvd.y;
1699 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1701 int log2_cb_size, int partIdx, int idx)
1703 #define POS(c_idx, x, y) \
1704 &s->frame->data[c_idx][((y) >> s->ps.sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1705 (((x) >> s->ps.sps->hshift[c_idx]) << s->ps.sps->pixel_shift)]
1706 HEVCLocalContext *lc = s->HEVClc;
1708 struct MvField current_mv = {{{ 0 }}};
1710 int min_pu_width = s->ps.sps->min_pu_width;
1712 MvField *tab_mvf = s->ref->tab_mvf;
1713 RefPicList *refPicList = s->ref->refPicList;
1714 HEVCFrame *ref0 = NULL, *ref1 = NULL;
1715 uint8_t *dst0 = POS(0, x0, y0);
1716 uint8_t *dst1 = POS(1, x0, y0);
1717 uint8_t *dst2 = POS(2, x0, y0);
1718 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
1719 int min_cb_width = s->ps.sps->min_cb_width;
1720 int x_cb = x0 >> log2_min_cb_size;
1721 int y_cb = y0 >> log2_min_cb_size;
1725 int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1728 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1730 if (skip_flag || lc->pu.merge_flag) {
1731 if (s->sh.max_num_merge_cand > 1)
1732 merge_idx = ff_hevc_merge_idx_decode(s);
1736 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1737 partIdx, merge_idx, ¤t_mv);
1739 hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1740 partIdx, merge_idx, ¤t_mv);
1743 x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1744 y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1746 for (j = 0; j < nPbH >> s->ps.sps->log2_min_pu_size; j++)
1747 for (i = 0; i < nPbW >> s->ps.sps->log2_min_pu_size; i++)
1748 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1750 if (current_mv.pred_flag & PF_L0) {
1751 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1754 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1756 if (current_mv.pred_flag & PF_L1) {
1757 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1760 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1763 if (current_mv.pred_flag == PF_L0) {
1764 int x0_c = x0 >> s->ps.sps->hshift[1];
1765 int y0_c = y0 >> s->ps.sps->vshift[1];
1766 int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1767 int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1769 luma_mc_uni(s, dst0, s->frame->linesize[0], ref0->frame,
1770 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1771 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1772 s->sh.luma_offset_l0[current_mv.ref_idx[0]]);
1774 if (s->ps.sps->chroma_format_idc) {
1775 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref0->frame->data[1], ref0->frame->linesize[1],
1776 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1777 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]);
1778 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref0->frame->data[2], ref0->frame->linesize[2],
1779 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1780 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]);
1782 } else if (current_mv.pred_flag == PF_L1) {
1783 int x0_c = x0 >> s->ps.sps->hshift[1];
1784 int y0_c = y0 >> s->ps.sps->vshift[1];
1785 int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1786 int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1788 luma_mc_uni(s, dst0, s->frame->linesize[0], ref1->frame,
1789 ¤t_mv.mv[1], x0, y0, nPbW, nPbH,
1790 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1791 s->sh.luma_offset_l1[current_mv.ref_idx[1]]);
1793 if (s->ps.sps->chroma_format_idc) {
1794 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
1795 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1796 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]);
1798 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
1799 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1800 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]);
1802 } else if (current_mv.pred_flag == PF_BI) {
1803 int x0_c = x0 >> s->ps.sps->hshift[1];
1804 int y0_c = y0 >> s->ps.sps->vshift[1];
1805 int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1806 int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1808 luma_mc_bi(s, dst0, s->frame->linesize[0], ref0->frame,
1809 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1810 ref1->frame, ¤t_mv.mv[1], ¤t_mv);
1812 if (s->ps.sps->chroma_format_idc) {
1813 chroma_mc_bi(s, dst1, s->frame->linesize[1], ref0->frame, ref1->frame,
1814 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 0);
1816 chroma_mc_bi(s, dst2, s->frame->linesize[2], ref0->frame, ref1->frame,
1817 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1);
1825 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1826 int prev_intra_luma_pred_flag)
1828 HEVCLocalContext *lc = s->HEVClc;
1829 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1830 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1831 int min_pu_width = s->ps.sps->min_pu_width;
1832 int size_in_pus = pu_size >> s->ps.sps->log2_min_pu_size;
1833 int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
1834 int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
1836 int cand_up = (lc->ctb_up_flag || y0b) ?
1837 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1838 int cand_left = (lc->ctb_left_flag || x0b) ?
1839 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1841 int y_ctb = (y0 >> (s->ps.sps->log2_ctb_size)) << (s->ps.sps->log2_ctb_size);
1843 MvField *tab_mvf = s->ref->tab_mvf;
1844 int intra_pred_mode;
1848 // intra_pred_mode prediction does not cross vertical CTB boundaries
1849 if ((y0 - 1) < y_ctb)
1852 if (cand_left == cand_up) {
1853 if (cand_left < 2) {
1854 candidate[0] = INTRA_PLANAR;
1855 candidate[1] = INTRA_DC;
1856 candidate[2] = INTRA_ANGULAR_26;
1858 candidate[0] = cand_left;
1859 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1860 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1863 candidate[0] = cand_left;
1864 candidate[1] = cand_up;
1865 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1866 candidate[2] = INTRA_PLANAR;
1867 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1868 candidate[2] = INTRA_DC;
1870 candidate[2] = INTRA_ANGULAR_26;
1874 if (prev_intra_luma_pred_flag) {
1875 intra_pred_mode = candidate[lc->pu.mpm_idx];
1877 if (candidate[0] > candidate[1])
1878 FFSWAP(uint8_t, candidate[0], candidate[1]);
1879 if (candidate[0] > candidate[2])
1880 FFSWAP(uint8_t, candidate[0], candidate[2]);
1881 if (candidate[1] > candidate[2])
1882 FFSWAP(uint8_t, candidate[1], candidate[2]);
1884 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1885 for (i = 0; i < 3; i++)
1886 if (intra_pred_mode >= candidate[i])
1890 /* write the intra prediction units into the mv array */
1893 for (i = 0; i < size_in_pus; i++) {
1894 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1895 intra_pred_mode, size_in_pus);
1897 for (j = 0; j < size_in_pus; j++) {
1898 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag = PF_INTRA;
1902 return intra_pred_mode;
1905 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1906 int log2_cb_size, int ct_depth)
1908 int length = (1 << log2_cb_size) >> s->ps.sps->log2_min_cb_size;
1909 int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
1910 int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
1913 for (y = 0; y < length; y++)
1914 memset(&s->tab_ct_depth[(y_cb + y) * s->ps.sps->min_cb_width + x_cb],
1918 static const uint8_t tab_mode_idx[] = {
1919 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
1920 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
1922 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1925 HEVCLocalContext *lc = s->HEVClc;
1926 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1927 uint8_t prev_intra_luma_pred_flag[4];
1928 int split = lc->cu.part_mode == PART_NxN;
1929 int pb_size = (1 << log2_cb_size) >> split;
1930 int side = split + 1;
1934 for (i = 0; i < side; i++)
1935 for (j = 0; j < side; j++)
1936 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1938 for (i = 0; i < side; i++) {
1939 for (j = 0; j < side; j++) {
1940 if (prev_intra_luma_pred_flag[2 * i + j])
1941 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
1943 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
1945 lc->pu.intra_pred_mode[2 * i + j] =
1946 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1947 prev_intra_luma_pred_flag[2 * i + j]);
1951 if (s->ps.sps->chroma_format_idc == 3) {
1952 for (i = 0; i < side; i++) {
1953 for (j = 0; j < side; j++) {
1954 lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1955 if (chroma_mode != 4) {
1956 if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode])
1957 lc->pu.intra_pred_mode_c[2 * i + j] = 34;
1959 lc->pu.intra_pred_mode_c[2 * i + j] = intra_chroma_table[chroma_mode];
1961 lc->pu.intra_pred_mode_c[2 * i + j] = lc->pu.intra_pred_mode[2 * i + j];
1965 } else if (s->ps.sps->chroma_format_idc == 2) {
1967 lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1968 if (chroma_mode != 4) {
1969 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1972 mode_idx = intra_chroma_table[chroma_mode];
1974 mode_idx = lc->pu.intra_pred_mode[0];
1976 lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx];
1977 } else if (s->ps.sps->chroma_format_idc != 0) {
1978 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1979 if (chroma_mode != 4) {
1980 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1981 lc->pu.intra_pred_mode_c[0] = 34;
1983 lc->pu.intra_pred_mode_c[0] = intra_chroma_table[chroma_mode];
1985 lc->pu.intra_pred_mode_c[0] = lc->pu.intra_pred_mode[0];
1990 static void intra_prediction_unit_default_value(HEVCContext *s,
1994 HEVCLocalContext *lc = s->HEVClc;
1995 int pb_size = 1 << log2_cb_size;
1996 int size_in_pus = pb_size >> s->ps.sps->log2_min_pu_size;
1997 int min_pu_width = s->ps.sps->min_pu_width;
1998 MvField *tab_mvf = s->ref->tab_mvf;
1999 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
2000 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
2003 if (size_in_pus == 0)
2005 for (j = 0; j < size_in_pus; j++)
2006 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
2007 if (lc->cu.pred_mode == MODE_INTRA)
2008 for (j = 0; j < size_in_pus; j++)
2009 for (k = 0; k < size_in_pus; k++)
2010 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].pred_flag = PF_INTRA;
2013 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
2015 int cb_size = 1 << log2_cb_size;
2016 HEVCLocalContext *lc = s->HEVClc;
2017 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
2018 int length = cb_size >> log2_min_cb_size;
2019 int min_cb_width = s->ps.sps->min_cb_width;
2020 int x_cb = x0 >> log2_min_cb_size;
2021 int y_cb = y0 >> log2_min_cb_size;
2022 int idx = log2_cb_size - 2;
2023 int qp_block_mask = (1<<(s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2028 lc->cu.pred_mode = MODE_INTRA;
2029 lc->cu.part_mode = PART_2Nx2N;
2030 lc->cu.intra_split_flag = 0;
2032 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
2033 for (x = 0; x < 4; x++)
2034 lc->pu.intra_pred_mode[x] = 1;
2035 if (s->ps.pps->transquant_bypass_enable_flag) {
2036 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
2037 if (lc->cu.cu_transquant_bypass_flag)
2038 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2040 lc->cu.cu_transquant_bypass_flag = 0;
2042 if (s->sh.slice_type != HEVC_SLICE_I) {
2043 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
2045 x = y_cb * min_cb_width + x_cb;
2046 for (y = 0; y < length; y++) {
2047 memset(&s->skip_flag[x], skip_flag, length);
2050 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2052 x = y_cb * min_cb_width + x_cb;
2053 for (y = 0; y < length; y++) {
2054 memset(&s->skip_flag[x], 0, length);
2059 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2060 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2061 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2063 if (!s->sh.disable_deblocking_filter_flag)
2064 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2068 if (s->sh.slice_type != HEVC_SLICE_I)
2069 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2070 if (lc->cu.pred_mode != MODE_INTRA ||
2071 log2_cb_size == s->ps.sps->log2_min_cb_size) {
2072 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2073 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2074 lc->cu.pred_mode == MODE_INTRA;
2077 if (lc->cu.pred_mode == MODE_INTRA) {
2078 if (lc->cu.part_mode == PART_2Nx2N && s->ps.sps->pcm_enabled_flag &&
2079 log2_cb_size >= s->ps.sps->pcm.log2_min_pcm_cb_size &&
2080 log2_cb_size <= s->ps.sps->pcm.log2_max_pcm_cb_size) {
2081 pcm_flag = ff_hevc_pcm_flag_decode(s);
2084 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2085 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2086 if (s->ps.sps->pcm.loop_filter_disable_flag)
2087 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2092 intra_prediction_unit(s, x0, y0, log2_cb_size);
2095 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2096 switch (lc->cu.part_mode) {
2098 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2101 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0, idx);
2102 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2105 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2106 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2109 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0, idx);
2110 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2113 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2114 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2117 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0, idx - 2);
2118 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2121 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2122 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2125 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2126 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2127 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2128 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2134 int rqt_root_cbf = 1;
2136 if (lc->cu.pred_mode != MODE_INTRA &&
2137 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2138 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2141 const static int cbf[2] = { 0 };
2142 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2143 s->ps.sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2144 s->ps.sps->max_transform_hierarchy_depth_inter;
2145 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2147 log2_cb_size, 0, 0, cbf, cbf);
2151 if (!s->sh.disable_deblocking_filter_flag)
2152 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2157 if (s->ps.pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2158 ff_hevc_set_qPy(s, x0, y0, log2_cb_size);
2160 x = y_cb * min_cb_width + x_cb;
2161 for (y = 0; y < length; y++) {
2162 memset(&s->qp_y_tab[x], lc->qp_y, length);
2166 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2167 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2168 lc->qPy_pred = lc->qp_y;
2171 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct_depth);
2176 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2177 int log2_cb_size, int cb_depth)
2179 HEVCLocalContext *lc = s->HEVClc;
2180 const int cb_size = 1 << log2_cb_size;
2184 lc->ct_depth = cb_depth;
2185 if (x0 + cb_size <= s->ps.sps->width &&
2186 y0 + cb_size <= s->ps.sps->height &&
2187 log2_cb_size > s->ps.sps->log2_min_cb_size) {
2188 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2190 split_cu = (log2_cb_size > s->ps.sps->log2_min_cb_size);
2192 if (s->ps.pps->cu_qp_delta_enabled_flag &&
2193 log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth) {
2194 lc->tu.is_cu_qp_delta_coded = 0;
2195 lc->tu.cu_qp_delta = 0;
2198 if (s->sh.cu_chroma_qp_offset_enabled_flag &&
2199 log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_chroma_qp_offset_depth) {
2200 lc->tu.is_cu_chroma_qp_offset_coded = 0;
2204 int qp_block_mask = (1<<(s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2205 const int cb_size_split = cb_size >> 1;
2206 const int x1 = x0 + cb_size_split;
2207 const int y1 = y0 + cb_size_split;
2211 more_data = hls_coding_quadtree(s, x0, y0, log2_cb_size - 1, cb_depth + 1);
2215 if (more_data && x1 < s->ps.sps->width) {
2216 more_data = hls_coding_quadtree(s, x1, y0, log2_cb_size - 1, cb_depth + 1);
2220 if (more_data && y1 < s->ps.sps->height) {
2221 more_data = hls_coding_quadtree(s, x0, y1, log2_cb_size - 1, cb_depth + 1);
2225 if (more_data && x1 < s->ps.sps->width &&
2226 y1 < s->ps.sps->height) {
2227 more_data = hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1);
2232 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2233 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2234 lc->qPy_pred = lc->qp_y;
2237 return ((x1 + cb_size_split) < s->ps.sps->width ||
2238 (y1 + cb_size_split) < s->ps.sps->height);
2242 ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2245 if ((!((x0 + cb_size) %
2246 (1 << (s->ps.sps->log2_ctb_size))) ||
2247 (x0 + cb_size >= s->ps.sps->width)) &&
2249 (1 << (s->ps.sps->log2_ctb_size))) ||
2250 (y0 + cb_size >= s->ps.sps->height))) {
2251 int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s);
2252 return !end_of_slice_flag;
2261 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2264 HEVCLocalContext *lc = s->HEVClc;
2265 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2266 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2267 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2269 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2271 if (s->ps.pps->entropy_coding_sync_enabled_flag) {
2272 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2273 lc->first_qp_group = 1;
2274 lc->end_of_tiles_x = s->ps.sps->width;
2275 } else if (s->ps.pps->tiles_enabled_flag) {
2276 if (ctb_addr_ts && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
2277 int idxX = s->ps.pps->col_idxX[x_ctb >> s->ps.sps->log2_ctb_size];
2278 lc->end_of_tiles_x = x_ctb + (s->ps.pps->column_width[idxX] << s->ps.sps->log2_ctb_size);
2279 lc->first_qp_group = 1;
2282 lc->end_of_tiles_x = s->ps.sps->width;
2285 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->ps.sps->height);
2287 lc->boundary_flags = 0;
2288 if (s->ps.pps->tiles_enabled_flag) {
2289 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]])
2290 lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2291 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2292 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2293 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]])
2294 lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2295 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->ps.sps->ctb_width])
2296 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2298 if (ctb_addr_in_slice <= 0)
2299 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2300 if (ctb_addr_in_slice < s->ps.sps->ctb_width)
2301 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2304 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2305 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->ps.sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2306 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]]));
2307 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]]));
2310 static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
2312 HEVCContext *s = avctxt->priv_data;
2313 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2317 int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2319 if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) {
2320 av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n");
2321 return AVERROR_INVALIDDATA;
2324 if (s->sh.dependent_slice_segment_flag) {
2325 int prev_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2326 if (s->tab_slice_address[prev_rs] != s->sh.slice_addr) {
2327 av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n");
2328 return AVERROR_INVALIDDATA;
2332 while (more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2333 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2335 x_ctb = (ctb_addr_rs % ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2336 y_ctb = (ctb_addr_rs / ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2337 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2339 ff_hevc_cabac_init(s, ctb_addr_ts);
2341 hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2343 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2344 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2345 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2347 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2348 if (more_data < 0) {
2349 s->tab_slice_address[ctb_addr_rs] = -1;
2355 ff_hevc_save_states(s, ctb_addr_ts);
2356 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2359 if (x_ctb + ctb_size >= s->ps.sps->width &&
2360 y_ctb + ctb_size >= s->ps.sps->height)
2361 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2366 static int hls_slice_data(HEVCContext *s)
2374 s->avctx->execute(s->avctx, hls_decode_entry, arg, ret , 1, sizeof(int));
2377 static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int job, int self_id)
2379 HEVCContext *s1 = avctxt->priv_data, *s;
2380 HEVCLocalContext *lc;
2381 int ctb_size = 1<< s1->ps.sps->log2_ctb_size;
2383 int *ctb_row_p = input_ctb_row;
2384 int ctb_row = ctb_row_p[job];
2385 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);
2386 int ctb_addr_ts = s1->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2387 int thread = ctb_row % s1->threads_number;
2390 s = s1->sList[self_id];
2394 ret = init_get_bits8(&lc->gb, s->data + s->sh.offset[ctb_row - 1], s->sh.size[ctb_row - 1]);
2398 ff_init_cabac_decoder(&lc->cc, s->data + s->sh.offset[(ctb_row)-1], s->sh.size[ctb_row - 1]);
2401 while(more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2402 int x_ctb = (ctb_addr_rs % s->ps.sps->ctb_width) << s->ps.sps->log2_ctb_size;
2403 int y_ctb = (ctb_addr_rs / s->ps.sps->ctb_width) << s->ps.sps->log2_ctb_size;
2405 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2407 ff_thread_await_progress2(s->avctx, ctb_row, thread, SHIFT_CTB_WPP);
2409 if (atomic_load(&s1->wpp_err)) {
2410 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2414 ff_hevc_cabac_init(s, ctb_addr_ts);
2415 hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2416 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2418 if (more_data < 0) {
2419 s->tab_slice_address[ctb_addr_rs] = -1;
2420 atomic_store(&s1->wpp_err, 1);
2421 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2427 ff_hevc_save_states(s, ctb_addr_ts);
2428 ff_thread_report_progress2(s->avctx, ctb_row, thread, 1);
2429 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2431 if (!more_data && (x_ctb+ctb_size) < s->ps.sps->width && ctb_row != s->sh.num_entry_point_offsets) {
2432 atomic_store(&s1->wpp_err, 1);
2433 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2437 if ((x_ctb+ctb_size) >= s->ps.sps->width && (y_ctb+ctb_size) >= s->ps.sps->height ) {
2438 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2439 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2442 ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2445 if(x_ctb >= s->ps.sps->width) {
2449 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2454 static int hls_slice_data_wpp(HEVCContext *s, const H2645NAL *nal)
2456 const uint8_t *data = nal->data;
2457 int length = nal->size;
2458 HEVCLocalContext *lc = s->HEVClc;
2459 int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2460 int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2462 int64_t startheader, cmpt = 0;
2468 return AVERROR(ENOMEM);
2471 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) {
2472 av_log(s->avctx, AV_LOG_ERROR, "WPP ctb addresses are wrong (%d %d %d %d)\n",
2473 s->sh.slice_ctb_addr_rs, s->sh.num_entry_point_offsets,
2474 s->ps.sps->ctb_width, s->ps.sps->ctb_height
2476 res = AVERROR_INVALIDDATA;
2480 ff_alloc_entries(s->avctx, s->sh.num_entry_point_offsets + 1);
2483 for (i = 1; i < s->threads_number; i++) {
2484 s->sList[i] = av_malloc(sizeof(HEVCContext));
2485 memcpy(s->sList[i], s, sizeof(HEVCContext));
2486 s->HEVClcList[i] = av_mallocz(sizeof(HEVCLocalContext));
2487 s->sList[i]->HEVClc = s->HEVClcList[i];
2491 offset = (lc->gb.index >> 3);
2493 for (j = 0, cmpt = 0, startheader = offset + s->sh.entry_point_offset[0]; j < nal->skipped_bytes; j++) {
2494 if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) {
2500 for (i = 1; i < s->sh.num_entry_point_offsets; i++) {
2501 offset += (s->sh.entry_point_offset[i - 1] - cmpt);
2502 for (j = 0, cmpt = 0, startheader = offset
2503 + s->sh.entry_point_offset[i]; j < nal->skipped_bytes; j++) {
2504 if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) {
2509 s->sh.size[i - 1] = s->sh.entry_point_offset[i] - cmpt;
2510 s->sh.offset[i - 1] = offset;
2513 if (s->sh.num_entry_point_offsets != 0) {
2514 offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt;
2515 if (length < offset) {
2516 av_log(s->avctx, AV_LOG_ERROR, "entry_point_offset table is corrupted\n");
2517 res = AVERROR_INVALIDDATA;
2520 s->sh.size[s->sh.num_entry_point_offsets - 1] = length - offset;
2521 s->sh.offset[s->sh.num_entry_point_offsets - 1] = offset;
2526 for (i = 1; i < s->threads_number; i++) {
2527 s->sList[i]->HEVClc->first_qp_group = 1;
2528 s->sList[i]->HEVClc->qp_y = s->sList[0]->HEVClc->qp_y;
2529 memcpy(s->sList[i], s, sizeof(HEVCContext));
2530 s->sList[i]->HEVClc = s->HEVClcList[i];
2533 atomic_store(&s->wpp_err, 0);
2534 ff_reset_entries(s->avctx);
2536 for (i = 0; i <= s->sh.num_entry_point_offsets; i++) {
2541 if (s->ps.pps->entropy_coding_sync_enabled_flag)
2542 s->avctx->execute2(s->avctx, hls_decode_entry_wpp, arg, ret, s->sh.num_entry_point_offsets + 1);
2544 for (i = 0; i <= s->sh.num_entry_point_offsets; i++)
2552 static int set_side_data(HEVCContext *s)
2554 AVFrame *out = s->ref->frame;
2556 if (s->sei_frame_packing_present &&
2557 s->frame_packing_arrangement_type >= 3 &&
2558 s->frame_packing_arrangement_type <= 5 &&
2559 s->content_interpretation_type > 0 &&
2560 s->content_interpretation_type < 3) {
2561 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2563 return AVERROR(ENOMEM);
2565 switch (s->frame_packing_arrangement_type) {
2567 if (s->quincunx_subsampling)
2568 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2570 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2573 stereo->type = AV_STEREO3D_TOPBOTTOM;
2576 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2580 if (s->content_interpretation_type == 2)
2581 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2584 if (s->sei_display_orientation_present &&
2585 (s->sei_anticlockwise_rotation || s->sei_hflip || s->sei_vflip)) {
2586 double angle = s->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
2587 AVFrameSideData *rotation = av_frame_new_side_data(out,
2588 AV_FRAME_DATA_DISPLAYMATRIX,
2589 sizeof(int32_t) * 9);
2591 return AVERROR(ENOMEM);
2593 av_display_rotation_set((int32_t *)rotation->data, angle);
2594 av_display_matrix_flip((int32_t *)rotation->data,
2595 s->sei_hflip, s->sei_vflip);
2598 // Decrement the mastering display flag when IRAP frame has no_rasl_output_flag=1
2599 // so the side data persists for the entire coded video sequence.
2600 if (s->sei_mastering_display_info_present > 0 &&
2601 IS_IRAP(s) && s->no_rasl_output_flag) {
2602 s->sei_mastering_display_info_present--;
2604 if (s->sei_mastering_display_info_present) {
2605 // HEVC uses a g,b,r ordering, which we convert to a more natural r,g,b
2606 const int mapping[3] = {2, 0, 1};
2607 const int chroma_den = 50000;
2608 const int luma_den = 10000;
2610 AVMasteringDisplayMetadata *metadata =
2611 av_mastering_display_metadata_create_side_data(out);
2613 return AVERROR(ENOMEM);
2615 for (i = 0; i < 3; i++) {
2616 const int j = mapping[i];
2617 metadata->display_primaries[i][0].num = s->display_primaries[j][0];
2618 metadata->display_primaries[i][0].den = chroma_den;
2619 metadata->display_primaries[i][1].num = s->display_primaries[j][1];
2620 metadata->display_primaries[i][1].den = chroma_den;
2622 metadata->white_point[0].num = s->white_point[0];
2623 metadata->white_point[0].den = chroma_den;
2624 metadata->white_point[1].num = s->white_point[1];
2625 metadata->white_point[1].den = chroma_den;
2627 metadata->max_luminance.num = s->max_mastering_luminance;
2628 metadata->max_luminance.den = luma_den;
2629 metadata->min_luminance.num = s->min_mastering_luminance;
2630 metadata->min_luminance.den = luma_den;
2631 metadata->has_luminance = 1;
2632 metadata->has_primaries = 1;
2634 av_log(s->avctx, AV_LOG_DEBUG, "Mastering Display Metadata:\n");
2635 av_log(s->avctx, AV_LOG_DEBUG,
2636 "r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f)\n",
2637 av_q2d(metadata->display_primaries[0][0]),
2638 av_q2d(metadata->display_primaries[0][1]),
2639 av_q2d(metadata->display_primaries[1][0]),
2640 av_q2d(metadata->display_primaries[1][1]),
2641 av_q2d(metadata->display_primaries[2][0]),
2642 av_q2d(metadata->display_primaries[2][1]),
2643 av_q2d(metadata->white_point[0]), av_q2d(metadata->white_point[1]));
2644 av_log(s->avctx, AV_LOG_DEBUG,
2645 "min_luminance=%f, max_luminance=%f\n",
2646 av_q2d(metadata->min_luminance), av_q2d(metadata->max_luminance));
2648 // Decrement the mastering display flag when IRAP frame has no_rasl_output_flag=1
2649 // so the side data persists for the entire coded video sequence.
2650 if (s->sei_content_light_present > 0 &&
2651 IS_IRAP(s) && s->no_rasl_output_flag) {
2652 s->sei_content_light_present--;
2654 if (s->sei_content_light_present) {
2655 AVContentLightMetadata *metadata =
2656 av_content_light_metadata_create_side_data(out);
2658 return AVERROR(ENOMEM);
2659 metadata->MaxCLL = s->max_content_light_level;
2660 metadata->MaxFALL = s->max_pic_average_light_level;
2662 av_log(s->avctx, AV_LOG_DEBUG, "Content Light Level Metadata:\n");
2663 av_log(s->avctx, AV_LOG_DEBUG, "MaxCLL=%d, MaxFALL=%d\n",
2664 metadata->MaxCLL, metadata->MaxFALL);
2667 if (s->a53_caption) {
2668 AVFrameSideData* sd = av_frame_new_side_data(out,
2669 AV_FRAME_DATA_A53_CC,
2670 s->a53_caption_size);
2672 memcpy(sd->data, s->a53_caption, s->a53_caption_size);
2673 av_freep(&s->a53_caption);
2674 s->a53_caption_size = 0;
2675 s->avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
2681 static int hevc_frame_start(HEVCContext *s)
2683 HEVCLocalContext *lc = s->HEVClc;
2684 int pic_size_in_ctb = ((s->ps.sps->width >> s->ps.sps->log2_min_cb_size) + 1) *
2685 ((s->ps.sps->height >> s->ps.sps->log2_min_cb_size) + 1);
2688 memset(s->horizontal_bs, 0, s->bs_width * s->bs_height);
2689 memset(s->vertical_bs, 0, s->bs_width * s->bs_height);
2690 memset(s->cbf_luma, 0, s->ps.sps->min_tb_width * s->ps.sps->min_tb_height);
2691 memset(s->is_pcm, 0, (s->ps.sps->min_pu_width + 1) * (s->ps.sps->min_pu_height + 1));
2692 memset(s->tab_slice_address, -1, pic_size_in_ctb * sizeof(*s->tab_slice_address));
2695 s->first_nal_type = s->nal_unit_type;
2697 s->no_rasl_output_flag = IS_IDR(s) || IS_BLA(s) || (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos);
2699 if (s->ps.pps->tiles_enabled_flag)
2700 lc->end_of_tiles_x = s->ps.pps->column_width[0] << s->ps.sps->log2_ctb_size;
2702 ret = ff_hevc_set_new_ref(s, &s->frame, s->poc);
2706 ret = ff_hevc_frame_rps(s);
2708 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2712 s->ref->frame->key_frame = IS_IRAP(s);
2714 ret = set_side_data(s);
2718 s->frame->pict_type = 3 - s->sh.slice_type;
2721 ff_hevc_bump_frame(s);
2723 av_frame_unref(s->output_frame);
2724 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2728 if (!s->avctx->hwaccel)
2729 ff_thread_finish_setup(s->avctx);
2735 ff_hevc_unref_frame(s, s->ref, ~0);
2740 static int decode_nal_unit(HEVCContext *s, const H2645NAL *nal)
2742 HEVCLocalContext *lc = s->HEVClc;
2743 GetBitContext *gb = &lc->gb;
2744 int ctb_addr_ts, ret;
2747 s->nal_unit_type = nal->type;
2748 s->temporal_id = nal->temporal_id;
2750 switch (s->nal_unit_type) {
2752 ret = ff_hevc_decode_nal_vps(gb, s->avctx, &s->ps);
2757 ret = ff_hevc_decode_nal_sps(gb, s->avctx, &s->ps,
2758 s->apply_defdispwin);
2763 ret = ff_hevc_decode_nal_pps(gb, s->avctx, &s->ps);
2767 case HEVC_NAL_SEI_PREFIX:
2768 case HEVC_NAL_SEI_SUFFIX:
2769 ret = ff_hevc_decode_nal_sei(s);
2773 case HEVC_NAL_TRAIL_R:
2774 case HEVC_NAL_TRAIL_N:
2775 case HEVC_NAL_TSA_N:
2776 case HEVC_NAL_TSA_R:
2777 case HEVC_NAL_STSA_N:
2778 case HEVC_NAL_STSA_R:
2779 case HEVC_NAL_BLA_W_LP:
2780 case HEVC_NAL_BLA_W_RADL:
2781 case HEVC_NAL_BLA_N_LP:
2782 case HEVC_NAL_IDR_W_RADL:
2783 case HEVC_NAL_IDR_N_LP:
2784 case HEVC_NAL_CRA_NUT:
2785 case HEVC_NAL_RADL_N:
2786 case HEVC_NAL_RADL_R:
2787 case HEVC_NAL_RASL_N:
2788 case HEVC_NAL_RASL_R:
2789 ret = hls_slice_header(s);
2793 if (s->sh.first_slice_in_pic_flag) {
2794 if (s->max_ra == INT_MAX) {
2795 if (s->nal_unit_type == HEVC_NAL_CRA_NUT || IS_BLA(s)) {
2799 s->max_ra = INT_MIN;
2803 if ((s->nal_unit_type == HEVC_NAL_RASL_R || s->nal_unit_type == HEVC_NAL_RASL_N) &&
2804 s->poc <= s->max_ra) {
2808 if (s->nal_unit_type == HEVC_NAL_RASL_R && s->poc > s->max_ra)
2809 s->max_ra = INT_MIN;
2812 ret = hevc_frame_start(s);
2815 } else if (!s->ref) {
2816 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2820 if (s->nal_unit_type != s->first_nal_type) {
2821 av_log(s->avctx, AV_LOG_ERROR,
2822 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2823 s->first_nal_type, s->nal_unit_type);
2824 return AVERROR_INVALIDDATA;
2827 if (!s->sh.dependent_slice_segment_flag &&
2828 s->sh.slice_type != HEVC_SLICE_I) {
2829 ret = ff_hevc_slice_rpl(s);
2831 av_log(s->avctx, AV_LOG_WARNING,
2832 "Error constructing the reference lists for the current slice.\n");
2837 if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) {
2838 ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0);
2843 if (s->avctx->hwaccel) {
2844 ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size);
2848 if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
2849 ctb_addr_ts = hls_slice_data_wpp(s, nal);
2851 ctb_addr_ts = hls_slice_data(s);
2852 if (ctb_addr_ts >= (s->ps.sps->ctb_width * s->ps.sps->ctb_height)) {
2856 if (ctb_addr_ts < 0) {
2862 case HEVC_NAL_EOS_NUT:
2863 case HEVC_NAL_EOB_NUT:
2864 s->seq_decode = (s->seq_decode + 1) & 0xff;
2865 s->max_ra = INT_MAX;
2868 case HEVC_NAL_FD_NUT:
2871 av_log(s->avctx, AV_LOG_INFO,
2872 "Skipping NAL unit %d\n", s->nal_unit_type);
2877 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2882 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2887 s->last_eos = s->eos;
2890 /* split the input packet into NAL units, so we know the upper bound on the
2891 * number of slices in the frame */
2892 ret = ff_h2645_packet_split(&s->pkt, buf, length, s->avctx, s->is_nalff,
2893 s->nal_length_size, s->avctx->codec_id, 1);
2895 av_log(s->avctx, AV_LOG_ERROR,
2896 "Error splitting the input into NAL units.\n");
2900 for (i = 0; i < s->pkt.nb_nals; i++) {
2901 if (s->pkt.nals[i].type == HEVC_NAL_EOB_NUT ||
2902 s->pkt.nals[i].type == HEVC_NAL_EOS_NUT)
2906 /* decode the NAL units */
2907 for (i = 0; i < s->pkt.nb_nals; i++) {
2908 ret = decode_nal_unit(s, &s->pkt.nals[i]);
2910 av_log(s->avctx, AV_LOG_WARNING,
2911 "Error parsing NAL unit #%d.\n", i);
2917 if (s->ref && s->threads_type == FF_THREAD_FRAME)
2918 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2923 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2926 for (i = 0; i < 16; i++)
2927 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
2930 static int verify_md5(HEVCContext *s, AVFrame *frame)
2932 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
2937 return AVERROR(EINVAL);
2939 pixel_shift = desc->comp[0].depth > 8;
2941 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
2944 /* the checksums are LE, so we have to byteswap for >8bpp formats
2947 if (pixel_shift && !s->checksum_buf) {
2948 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
2949 FFMAX3(frame->linesize[0], frame->linesize[1],
2950 frame->linesize[2]));
2951 if (!s->checksum_buf)
2952 return AVERROR(ENOMEM);
2956 for (i = 0; frame->data[i]; i++) {
2957 int width = s->avctx->coded_width;
2958 int height = s->avctx->coded_height;
2959 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
2960 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
2963 av_md5_init(s->md5_ctx);
2964 for (j = 0; j < h; j++) {
2965 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
2968 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
2969 (const uint16_t *) src, w);
2970 src = s->checksum_buf;
2973 av_md5_update(s->md5_ctx, src, w << pixel_shift);
2975 av_md5_final(s->md5_ctx, md5);
2977 if (!memcmp(md5, s->md5[i], 16)) {
2978 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
2979 print_md5(s->avctx, AV_LOG_DEBUG, md5);
2980 av_log (s->avctx, AV_LOG_DEBUG, "; ");
2982 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
2983 print_md5(s->avctx, AV_LOG_ERROR, md5);
2984 av_log (s->avctx, AV_LOG_ERROR, " != ");
2985 print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
2986 av_log (s->avctx, AV_LOG_ERROR, "\n");
2987 return AVERROR_INVALIDDATA;
2991 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2996 static int hevc_decode_extradata(HEVCContext *s, uint8_t *buf, int length)
3000 ret = ff_hevc_decode_extradata(buf, length, &s->ps, &s->is_nalff,
3001 &s->nal_length_size, s->avctx->err_recognition,
3002 s->apply_defdispwin, s->avctx);
3006 /* export stream parameters from the first SPS */
3007 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3008 if (s->ps.sps_list[i]) {
3009 const HEVCSPS *sps = (const HEVCSPS*)s->ps.sps_list[i]->data;
3010 export_stream_params(s->avctx, &s->ps, sps);
3018 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
3022 int new_extradata_size;
3023 uint8_t *new_extradata;
3024 HEVCContext *s = avctx->priv_data;
3027 ret = ff_hevc_output_frame(s, data, 1);
3035 new_extradata = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,
3036 &new_extradata_size);
3037 if (new_extradata && new_extradata_size > 0) {
3038 ret = hevc_decode_extradata(s, new_extradata, new_extradata_size);
3044 ret = decode_nal_units(s, avpkt->data, avpkt->size);
3048 if (avctx->hwaccel) {
3049 if (s->ref && (ret = avctx->hwaccel->end_frame(avctx)) < 0) {
3050 av_log(avctx, AV_LOG_ERROR,
3051 "hardware accelerator failed to decode picture\n");
3052 ff_hevc_unref_frame(s, s->ref, ~0);
3056 /* verify the SEI checksum */
3057 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
3059 ret = verify_md5(s, s->ref->frame);
3060 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
3061 ff_hevc_unref_frame(s, s->ref, ~0);
3068 if (s->is_decoded) {
3069 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
3073 if (s->output_frame->buf[0]) {
3074 av_frame_move_ref(data, s->output_frame);
3081 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
3085 ret = ff_thread_ref_frame(&dst->tf, &src->tf);
3089 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
3090 if (!dst->tab_mvf_buf)
3092 dst->tab_mvf = src->tab_mvf;
3094 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
3095 if (!dst->rpl_tab_buf)
3097 dst->rpl_tab = src->rpl_tab;
3099 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
3103 dst->poc = src->poc;
3104 dst->ctb_count = src->ctb_count;
3105 dst->window = src->window;
3106 dst->flags = src->flags;
3107 dst->sequence = src->sequence;
3109 if (src->hwaccel_picture_private) {
3110 dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
3111 if (!dst->hwaccel_priv_buf)
3113 dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
3118 ff_hevc_unref_frame(s, dst, ~0);
3119 return AVERROR(ENOMEM);
3122 static av_cold int hevc_decode_free(AVCodecContext *avctx)
3124 HEVCContext *s = avctx->priv_data;
3129 av_freep(&s->md5_ctx);
3131 av_freep(&s->cabac_state);
3133 for (i = 0; i < 3; i++) {
3134 av_freep(&s->sao_pixel_buffer_h[i]);
3135 av_freep(&s->sao_pixel_buffer_v[i]);
3137 av_frame_free(&s->output_frame);
3139 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3140 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3141 av_frame_free(&s->DPB[i].frame);
3144 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++)
3145 av_buffer_unref(&s->ps.vps_list[i]);
3146 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++)
3147 av_buffer_unref(&s->ps.sps_list[i]);
3148 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++)
3149 av_buffer_unref(&s->ps.pps_list[i]);
3154 av_freep(&s->sh.entry_point_offset);
3155 av_freep(&s->sh.offset);
3156 av_freep(&s->sh.size);
3158 for (i = 1; i < s->threads_number; i++) {
3159 HEVCLocalContext *lc = s->HEVClcList[i];
3161 av_freep(&s->HEVClcList[i]);
3162 av_freep(&s->sList[i]);
3165 if (s->HEVClc == s->HEVClcList[0])
3167 av_freep(&s->HEVClcList[0]);
3169 ff_h2645_packet_uninit(&s->pkt);
3174 static av_cold int hevc_init_context(AVCodecContext *avctx)
3176 HEVCContext *s = avctx->priv_data;
3181 s->HEVClc = av_mallocz(sizeof(HEVCLocalContext));
3184 s->HEVClcList[0] = s->HEVClc;
3187 s->cabac_state = av_malloc(HEVC_CONTEXTS);
3188 if (!s->cabac_state)
3191 s->output_frame = av_frame_alloc();
3192 if (!s->output_frame)
3195 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3196 s->DPB[i].frame = av_frame_alloc();
3197 if (!s->DPB[i].frame)
3199 s->DPB[i].tf.f = s->DPB[i].frame;
3202 s->max_ra = INT_MAX;
3204 s->md5_ctx = av_md5_alloc();
3208 ff_bswapdsp_init(&s->bdsp);
3210 s->context_initialized = 1;
3213 ff_hevc_reset_sei(s);
3218 hevc_decode_free(avctx);
3219 return AVERROR(ENOMEM);
3222 static int hevc_update_thread_context(AVCodecContext *dst,
3223 const AVCodecContext *src)
3225 HEVCContext *s = dst->priv_data;
3226 HEVCContext *s0 = src->priv_data;
3229 if (!s->context_initialized) {
3230 ret = hevc_init_context(dst);
3235 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3236 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3237 if (s0->DPB[i].frame->buf[0]) {
3238 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3244 if (s->ps.sps != s0->ps.sps)
3246 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++) {
3247 av_buffer_unref(&s->ps.vps_list[i]);
3248 if (s0->ps.vps_list[i]) {
3249 s->ps.vps_list[i] = av_buffer_ref(s0->ps.vps_list[i]);
3250 if (!s->ps.vps_list[i])
3251 return AVERROR(ENOMEM);
3255 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3256 av_buffer_unref(&s->ps.sps_list[i]);
3257 if (s0->ps.sps_list[i]) {
3258 s->ps.sps_list[i] = av_buffer_ref(s0->ps.sps_list[i]);
3259 if (!s->ps.sps_list[i])
3260 return AVERROR(ENOMEM);
3264 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++) {
3265 av_buffer_unref(&s->ps.pps_list[i]);
3266 if (s0->ps.pps_list[i]) {
3267 s->ps.pps_list[i] = av_buffer_ref(s0->ps.pps_list[i]);
3268 if (!s->ps.pps_list[i])
3269 return AVERROR(ENOMEM);
3273 if (s->ps.sps != s0->ps.sps)
3274 if ((ret = set_sps(s, s0->ps.sps, src->pix_fmt)) < 0)
3277 s->seq_decode = s0->seq_decode;
3278 s->seq_output = s0->seq_output;
3279 s->pocTid0 = s0->pocTid0;
3280 s->max_ra = s0->max_ra;
3282 s->no_rasl_output_flag = s0->no_rasl_output_flag;
3284 s->is_nalff = s0->is_nalff;
3285 s->nal_length_size = s0->nal_length_size;
3287 s->threads_number = s0->threads_number;
3288 s->threads_type = s0->threads_type;
3291 s->seq_decode = (s->seq_decode + 1) & 0xff;
3292 s->max_ra = INT_MAX;
3298 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3300 HEVCContext *s = avctx->priv_data;
3303 avctx->internal->allocate_progress = 1;
3305 ret = hevc_init_context(avctx);
3309 s->enable_parallel_tiles = 0;
3310 s->picture_struct = 0;
3313 atomic_init(&s->wpp_err, 0);
3315 if(avctx->active_thread_type & FF_THREAD_SLICE)
3316 s->threads_number = avctx->thread_count;
3318 s->threads_number = 1;
3320 if (avctx->extradata_size > 0 && avctx->extradata) {
3321 ret = hevc_decode_extradata(s, avctx->extradata, avctx->extradata_size);
3323 hevc_decode_free(avctx);
3328 if((avctx->active_thread_type & FF_THREAD_FRAME) && avctx->thread_count > 1)
3329 s->threads_type = FF_THREAD_FRAME;
3331 s->threads_type = FF_THREAD_SLICE;
3336 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3338 HEVCContext *s = avctx->priv_data;
3341 memset(s, 0, sizeof(*s));
3343 ret = hevc_init_context(avctx);
3350 static void hevc_decode_flush(AVCodecContext *avctx)
3352 HEVCContext *s = avctx->priv_data;
3353 ff_hevc_flush_dpb(s);
3354 s->max_ra = INT_MAX;
3358 #define OFFSET(x) offsetof(HEVCContext, x)
3359 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3361 static const AVOption options[] = {
3362 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3363 AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR },
3364 { "strict-displaywin", "stricly apply default display window size", OFFSET(apply_defdispwin),
3365 AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR },
3369 static const AVClass hevc_decoder_class = {
3370 .class_name = "HEVC decoder",
3371 .item_name = av_default_item_name,
3373 .version = LIBAVUTIL_VERSION_INT,
3376 AVCodec ff_hevc_decoder = {
3378 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3379 .type = AVMEDIA_TYPE_VIDEO,
3380 .id = AV_CODEC_ID_HEVC,
3381 .priv_data_size = sizeof(HEVCContext),
3382 .priv_class = &hevc_decoder_class,
3383 .init = hevc_decode_init,
3384 .close = hevc_decode_free,
3385 .decode = hevc_decode_frame,
3386 .flush = hevc_decode_flush,
3387 .update_thread_context = hevc_update_thread_context,
3388 .init_thread_copy = hevc_init_thread_copy,
3389 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
3390 AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS,
3391 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
3392 .profiles = NULL_IF_CONFIG_SMALL(ff_hevc_profiles),