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/atomic.h"
27 #include "libavutil/attributes.h"
28 #include "libavutil/common.h"
29 #include "libavutil/display.h"
30 #include "libavutil/internal.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"
42 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 };
45 * NOTE: Each function hls_foo correspond to the function foo in the
46 * specification (HLS stands for High Level Syntax).
53 /* free everything allocated by pic_arrays_init() */
54 static void pic_arrays_free(HEVCContext *s)
57 av_freep(&s->deblock);
59 av_freep(&s->skip_flag);
60 av_freep(&s->tab_ct_depth);
62 av_freep(&s->tab_ipm);
63 av_freep(&s->cbf_luma);
66 av_freep(&s->qp_y_tab);
67 av_freep(&s->tab_slice_address);
68 av_freep(&s->filter_slice_edges);
70 av_freep(&s->horizontal_bs);
71 av_freep(&s->vertical_bs);
73 av_freep(&s->sh.entry_point_offset);
74 av_freep(&s->sh.size);
75 av_freep(&s->sh.offset);
77 av_buffer_pool_uninit(&s->tab_mvf_pool);
78 av_buffer_pool_uninit(&s->rpl_tab_pool);
81 /* allocate arrays that depend on frame dimensions */
82 static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
84 int log2_min_cb_size = sps->log2_min_cb_size;
85 int width = sps->width;
86 int height = sps->height;
87 int pic_size_in_ctb = ((width >> log2_min_cb_size) + 1) *
88 ((height >> log2_min_cb_size) + 1);
89 int ctb_count = sps->ctb_width * sps->ctb_height;
90 int min_pu_size = sps->min_pu_width * sps->min_pu_height;
92 s->bs_width = (width >> 2) + 1;
93 s->bs_height = (height >> 2) + 1;
95 s->sao = av_mallocz_array(ctb_count, sizeof(*s->sao));
96 s->deblock = av_mallocz_array(ctb_count, sizeof(*s->deblock));
97 if (!s->sao || !s->deblock)
100 s->skip_flag = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
101 s->tab_ct_depth = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
102 if (!s->skip_flag || !s->tab_ct_depth)
105 s->cbf_luma = av_malloc_array(sps->min_tb_width, sps->min_tb_height);
106 s->tab_ipm = av_mallocz(min_pu_size);
107 s->is_pcm = av_malloc_array(sps->min_pu_width + 1, sps->min_pu_height + 1);
108 if (!s->tab_ipm || !s->cbf_luma || !s->is_pcm)
111 s->filter_slice_edges = av_mallocz(ctb_count);
112 s->tab_slice_address = av_malloc_array(pic_size_in_ctb,
113 sizeof(*s->tab_slice_address));
114 s->qp_y_tab = av_malloc_array(pic_size_in_ctb,
115 sizeof(*s->qp_y_tab));
116 if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address)
119 s->horizontal_bs = av_mallocz_array(s->bs_width, s->bs_height);
120 s->vertical_bs = av_mallocz_array(s->bs_width, s->bs_height);
121 if (!s->horizontal_bs || !s->vertical_bs)
124 s->tab_mvf_pool = av_buffer_pool_init(min_pu_size * sizeof(MvField),
126 s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab),
128 if (!s->tab_mvf_pool || !s->rpl_tab_pool)
135 return AVERROR(ENOMEM);
138 static void pred_weight_table(HEVCContext *s, GetBitContext *gb)
142 uint8_t luma_weight_l0_flag[16];
143 uint8_t chroma_weight_l0_flag[16];
144 uint8_t luma_weight_l1_flag[16];
145 uint8_t chroma_weight_l1_flag[16];
146 int luma_log2_weight_denom;
148 luma_log2_weight_denom = get_ue_golomb_long(gb);
149 if (luma_log2_weight_denom < 0 || luma_log2_weight_denom > 7)
150 av_log(s->avctx, AV_LOG_ERROR, "luma_log2_weight_denom %d is invalid\n", luma_log2_weight_denom);
151 s->sh.luma_log2_weight_denom = av_clip_uintp2(luma_log2_weight_denom, 3);
152 if (s->sps->chroma_format_idc != 0) {
153 int delta = get_se_golomb(gb);
154 s->sh.chroma_log2_weight_denom = av_clip_uintp2(s->sh.luma_log2_weight_denom + delta, 3);
157 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
158 luma_weight_l0_flag[i] = get_bits1(gb);
159 if (!luma_weight_l0_flag[i]) {
160 s->sh.luma_weight_l0[i] = 1 << s->sh.luma_log2_weight_denom;
161 s->sh.luma_offset_l0[i] = 0;
164 if (s->sps->chroma_format_idc != 0) {
165 for (i = 0; i < s->sh.nb_refs[L0]; i++)
166 chroma_weight_l0_flag[i] = get_bits1(gb);
168 for (i = 0; i < s->sh.nb_refs[L0]; i++)
169 chroma_weight_l0_flag[i] = 0;
171 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
172 if (luma_weight_l0_flag[i]) {
173 int delta_luma_weight_l0 = get_se_golomb(gb);
174 s->sh.luma_weight_l0[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;
175 s->sh.luma_offset_l0[i] = get_se_golomb(gb);
177 if (chroma_weight_l0_flag[i]) {
178 for (j = 0; j < 2; j++) {
179 int delta_chroma_weight_l0 = get_se_golomb(gb);
180 int delta_chroma_offset_l0 = get_se_golomb(gb);
181 s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
182 s->sh.chroma_offset_l0[i][j] = av_clip((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j])
183 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
186 s->sh.chroma_weight_l0[i][0] = 1 << s->sh.chroma_log2_weight_denom;
187 s->sh.chroma_offset_l0[i][0] = 0;
188 s->sh.chroma_weight_l0[i][1] = 1 << s->sh.chroma_log2_weight_denom;
189 s->sh.chroma_offset_l0[i][1] = 0;
192 if (s->sh.slice_type == B_SLICE) {
193 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
194 luma_weight_l1_flag[i] = get_bits1(gb);
195 if (!luma_weight_l1_flag[i]) {
196 s->sh.luma_weight_l1[i] = 1 << s->sh.luma_log2_weight_denom;
197 s->sh.luma_offset_l1[i] = 0;
200 if (s->sps->chroma_format_idc != 0) {
201 for (i = 0; i < s->sh.nb_refs[L1]; i++)
202 chroma_weight_l1_flag[i] = get_bits1(gb);
204 for (i = 0; i < s->sh.nb_refs[L1]; i++)
205 chroma_weight_l1_flag[i] = 0;
207 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
208 if (luma_weight_l1_flag[i]) {
209 int delta_luma_weight_l1 = get_se_golomb(gb);
210 s->sh.luma_weight_l1[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;
211 s->sh.luma_offset_l1[i] = get_se_golomb(gb);
213 if (chroma_weight_l1_flag[i]) {
214 for (j = 0; j < 2; j++) {
215 int delta_chroma_weight_l1 = get_se_golomb(gb);
216 int delta_chroma_offset_l1 = get_se_golomb(gb);
217 s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
218 s->sh.chroma_offset_l1[i][j] = av_clip((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j])
219 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
222 s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom;
223 s->sh.chroma_offset_l1[i][0] = 0;
224 s->sh.chroma_weight_l1[i][1] = 1 << s->sh.chroma_log2_weight_denom;
225 s->sh.chroma_offset_l1[i][1] = 0;
231 static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
233 const HEVCSPS *sps = s->sps;
234 int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
235 int prev_delta_msb = 0;
236 unsigned int nb_sps = 0, nb_sh;
240 if (!sps->long_term_ref_pics_present_flag)
243 if (sps->num_long_term_ref_pics_sps > 0)
244 nb_sps = get_ue_golomb_long(gb);
245 nb_sh = get_ue_golomb_long(gb);
247 if (nb_sh + (uint64_t)nb_sps > FF_ARRAY_ELEMS(rps->poc))
248 return AVERROR_INVALIDDATA;
250 rps->nb_refs = nb_sh + nb_sps;
252 for (i = 0; i < rps->nb_refs; i++) {
253 uint8_t delta_poc_msb_present;
256 uint8_t lt_idx_sps = 0;
258 if (sps->num_long_term_ref_pics_sps > 1)
259 lt_idx_sps = get_bits(gb, av_ceil_log2(sps->num_long_term_ref_pics_sps));
261 rps->poc[i] = sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
262 rps->used[i] = sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];
264 rps->poc[i] = get_bits(gb, sps->log2_max_poc_lsb);
265 rps->used[i] = get_bits1(gb);
268 delta_poc_msb_present = get_bits1(gb);
269 if (delta_poc_msb_present) {
270 int delta = get_ue_golomb_long(gb);
272 if (i && i != nb_sps)
273 delta += prev_delta_msb;
275 rps->poc[i] += s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
276 prev_delta_msb = delta;
283 static void export_stream_params(AVCodecContext *avctx,
284 const HEVCContext *s, const HEVCSPS *sps)
286 const HEVCVPS *vps = (const HEVCVPS*)s->vps_list[sps->vps_id]->data;
287 unsigned int num = 0, den = 0;
289 avctx->pix_fmt = sps->pix_fmt;
290 avctx->coded_width = sps->width;
291 avctx->coded_height = sps->height;
292 avctx->width = sps->output_width;
293 avctx->height = sps->output_height;
294 avctx->has_b_frames = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics;
295 avctx->profile = sps->ptl.general_ptl.profile_idc;
296 avctx->level = sps->ptl.general_ptl.level_idc;
298 ff_set_sar(avctx, sps->vui.sar);
300 if (sps->vui.video_signal_type_present_flag)
301 avctx->color_range = sps->vui.video_full_range_flag ? AVCOL_RANGE_JPEG
304 avctx->color_range = AVCOL_RANGE_MPEG;
306 if (sps->vui.colour_description_present_flag) {
307 avctx->color_primaries = sps->vui.colour_primaries;
308 avctx->color_trc = sps->vui.transfer_characteristic;
309 avctx->colorspace = sps->vui.matrix_coeffs;
311 avctx->color_primaries = AVCOL_PRI_UNSPECIFIED;
312 avctx->color_trc = AVCOL_TRC_UNSPECIFIED;
313 avctx->colorspace = AVCOL_SPC_UNSPECIFIED;
316 if (vps->vps_timing_info_present_flag) {
317 num = vps->vps_num_units_in_tick;
318 den = vps->vps_time_scale;
319 } else if (sps->vui.vui_timing_info_present_flag) {
320 num = sps->vui.vui_num_units_in_tick;
321 den = sps->vui.vui_time_scale;
324 if (num != 0 && den != 0)
325 av_reduce(&avctx->framerate.den, &avctx->framerate.num,
329 static int set_sps(HEVCContext *s, const HEVCSPS *sps, enum AVPixelFormat pix_fmt)
331 #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + CONFIG_HEVC_D3D11VA_HWACCEL)
332 enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
335 export_stream_params(s->avctx, s, sps);
338 ret = pic_arrays_init(s, sps);
342 if (sps->pix_fmt == AV_PIX_FMT_YUV420P || sps->pix_fmt == AV_PIX_FMT_YUVJ420P) {
343 #if CONFIG_HEVC_DXVA2_HWACCEL
344 *fmt++ = AV_PIX_FMT_DXVA2_VLD;
346 #if CONFIG_HEVC_D3D11VA_HWACCEL
347 *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
351 if (pix_fmt == AV_PIX_FMT_NONE) {
352 *fmt++ = sps->pix_fmt;
353 *fmt = AV_PIX_FMT_NONE;
355 ret = ff_thread_get_format(s->avctx, pix_fmts);
358 s->avctx->pix_fmt = ret;
361 s->avctx->pix_fmt = pix_fmt;
364 ff_hevc_pred_init(&s->hpc, sps->bit_depth);
365 ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
366 ff_videodsp_init (&s->vdsp, sps->bit_depth);
368 for (i = 0; i < 3; i++) {
369 av_freep(&s->sao_pixel_buffer_h[i]);
370 av_freep(&s->sao_pixel_buffer_v[i]);
373 if (sps->sao_enabled && !s->avctx->hwaccel) {
374 int c_count = (sps->chroma_format_idc != 0) ? 3 : 1;
377 for(c_idx = 0; c_idx < c_count; c_idx++) {
378 int w = sps->width >> sps->hshift[c_idx];
379 int h = sps->height >> sps->vshift[c_idx];
380 s->sao_pixel_buffer_h[c_idx] =
381 av_malloc((w * 2 * sps->ctb_height) <<
383 s->sao_pixel_buffer_v[c_idx] =
384 av_malloc((h * 2 * sps->ctb_width) <<
390 s->vps = (HEVCVPS*) s->vps_list[s->sps->vps_id]->data;
400 static int hls_slice_header(HEVCContext *s)
402 GetBitContext *gb = &s->HEVClc->gb;
403 SliceHeader *sh = &s->sh;
407 sh->first_slice_in_pic_flag = get_bits1(gb);
408 if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
409 s->seq_decode = (s->seq_decode + 1) & 0xff;
412 ff_hevc_clear_refs(s);
414 sh->no_output_of_prior_pics_flag = 0;
416 sh->no_output_of_prior_pics_flag = get_bits1(gb);
418 sh->pps_id = get_ue_golomb_long(gb);
419 if (sh->pps_id >= MAX_PPS_COUNT || !s->pps_list[sh->pps_id]) {
420 av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
421 return AVERROR_INVALIDDATA;
423 if (!sh->first_slice_in_pic_flag &&
424 s->pps != (HEVCPPS*)s->pps_list[sh->pps_id]->data) {
425 av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
426 return AVERROR_INVALIDDATA;
428 s->pps = (HEVCPPS*)s->pps_list[sh->pps_id]->data;
429 if (s->nal_unit_type == NAL_CRA_NUT && s->last_eos == 1)
430 sh->no_output_of_prior_pics_flag = 1;
432 if (s->sps != (HEVCSPS*)s->sps_list[s->pps->sps_id]->data) {
433 const HEVCSPS* last_sps = s->sps;
434 s->sps = (HEVCSPS*)s->sps_list[s->pps->sps_id]->data;
435 if (last_sps && IS_IRAP(s) && s->nal_unit_type != NAL_CRA_NUT) {
436 if (s->sps->width != last_sps->width || s->sps->height != last_sps->height ||
437 s->sps->temporal_layer[s->sps->max_sub_layers - 1].max_dec_pic_buffering !=
438 last_sps->temporal_layer[last_sps->max_sub_layers - 1].max_dec_pic_buffering)
439 sh->no_output_of_prior_pics_flag = 0;
441 ff_hevc_clear_refs(s);
442 ret = set_sps(s, s->sps, AV_PIX_FMT_NONE);
446 s->seq_decode = (s->seq_decode + 1) & 0xff;
450 sh->dependent_slice_segment_flag = 0;
451 if (!sh->first_slice_in_pic_flag) {
452 int slice_address_length;
454 if (s->pps->dependent_slice_segments_enabled_flag)
455 sh->dependent_slice_segment_flag = get_bits1(gb);
457 slice_address_length = av_ceil_log2(s->sps->ctb_width *
459 sh->slice_segment_addr = get_bits(gb, slice_address_length);
460 if (sh->slice_segment_addr >= s->sps->ctb_width * s->sps->ctb_height) {
461 av_log(s->avctx, AV_LOG_ERROR,
462 "Invalid slice segment address: %u.\n",
463 sh->slice_segment_addr);
464 return AVERROR_INVALIDDATA;
467 if (!sh->dependent_slice_segment_flag) {
468 sh->slice_addr = sh->slice_segment_addr;
472 sh->slice_segment_addr = sh->slice_addr = 0;
474 s->slice_initialized = 0;
477 if (!sh->dependent_slice_segment_flag) {
478 s->slice_initialized = 0;
480 for (i = 0; i < s->pps->num_extra_slice_header_bits; i++)
481 skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
483 sh->slice_type = get_ue_golomb_long(gb);
484 if (!(sh->slice_type == I_SLICE ||
485 sh->slice_type == P_SLICE ||
486 sh->slice_type == B_SLICE)) {
487 av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
489 return AVERROR_INVALIDDATA;
491 if (IS_IRAP(s) && sh->slice_type != I_SLICE) {
492 av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
493 return AVERROR_INVALIDDATA;
496 // when flag is not present, picture is inferred to be output
497 sh->pic_output_flag = 1;
498 if (s->pps->output_flag_present_flag)
499 sh->pic_output_flag = get_bits1(gb);
501 if (s->sps->separate_colour_plane_flag)
502 sh->colour_plane_id = get_bits(gb, 2);
507 sh->pic_order_cnt_lsb = get_bits(gb, s->sps->log2_max_poc_lsb);
508 poc = ff_hevc_compute_poc(s, sh->pic_order_cnt_lsb);
509 if (!sh->first_slice_in_pic_flag && poc != s->poc) {
510 av_log(s->avctx, AV_LOG_WARNING,
511 "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
512 if (s->avctx->err_recognition & AV_EF_EXPLODE)
513 return AVERROR_INVALIDDATA;
518 sh->short_term_ref_pic_set_sps_flag = get_bits1(gb);
519 if (!sh->short_term_ref_pic_set_sps_flag) {
520 int pos = get_bits_left(gb);
521 ret = ff_hevc_decode_short_term_rps(s, &sh->slice_rps, s->sps, 1);
525 sh->short_term_ref_pic_set_size = pos - get_bits_left(gb);
526 sh->short_term_rps = &sh->slice_rps;
528 int numbits, rps_idx;
530 if (!s->sps->nb_st_rps) {
531 av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
532 return AVERROR_INVALIDDATA;
535 numbits = av_ceil_log2(s->sps->nb_st_rps);
536 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
537 sh->short_term_rps = &s->sps->st_rps[rps_idx];
540 ret = decode_lt_rps(s, &sh->long_term_rps, gb);
542 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
543 if (s->avctx->err_recognition & AV_EF_EXPLODE)
544 return AVERROR_INVALIDDATA;
547 if (s->sps->sps_temporal_mvp_enabled_flag)
548 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
550 sh->slice_temporal_mvp_enabled_flag = 0;
552 s->sh.short_term_rps = NULL;
557 if (s->temporal_id == 0 &&
558 s->nal_unit_type != NAL_TRAIL_N &&
559 s->nal_unit_type != NAL_TSA_N &&
560 s->nal_unit_type != NAL_STSA_N &&
561 s->nal_unit_type != NAL_RADL_N &&
562 s->nal_unit_type != NAL_RADL_R &&
563 s->nal_unit_type != NAL_RASL_N &&
564 s->nal_unit_type != NAL_RASL_R)
567 if (s->sps->sao_enabled) {
568 sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
569 if (s->sps->chroma_format_idc) {
570 sh->slice_sample_adaptive_offset_flag[1] =
571 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
574 sh->slice_sample_adaptive_offset_flag[0] = 0;
575 sh->slice_sample_adaptive_offset_flag[1] = 0;
576 sh->slice_sample_adaptive_offset_flag[2] = 0;
579 sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
580 if (sh->slice_type == P_SLICE || sh->slice_type == B_SLICE) {
583 sh->nb_refs[L0] = s->pps->num_ref_idx_l0_default_active;
584 if (sh->slice_type == B_SLICE)
585 sh->nb_refs[L1] = s->pps->num_ref_idx_l1_default_active;
587 if (get_bits1(gb)) { // num_ref_idx_active_override_flag
588 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
589 if (sh->slice_type == B_SLICE)
590 sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
592 if (sh->nb_refs[L0] > MAX_REFS || sh->nb_refs[L1] > MAX_REFS) {
593 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
594 sh->nb_refs[L0], sh->nb_refs[L1]);
595 return AVERROR_INVALIDDATA;
598 sh->rpl_modification_flag[0] = 0;
599 sh->rpl_modification_flag[1] = 0;
600 nb_refs = ff_hevc_frame_nb_refs(s);
602 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
603 return AVERROR_INVALIDDATA;
606 if (s->pps->lists_modification_present_flag && nb_refs > 1) {
607 sh->rpl_modification_flag[0] = get_bits1(gb);
608 if (sh->rpl_modification_flag[0]) {
609 for (i = 0; i < sh->nb_refs[L0]; i++)
610 sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
613 if (sh->slice_type == B_SLICE) {
614 sh->rpl_modification_flag[1] = get_bits1(gb);
615 if (sh->rpl_modification_flag[1] == 1)
616 for (i = 0; i < sh->nb_refs[L1]; i++)
617 sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
621 if (sh->slice_type == B_SLICE)
622 sh->mvd_l1_zero_flag = get_bits1(gb);
624 if (s->pps->cabac_init_present_flag)
625 sh->cabac_init_flag = get_bits1(gb);
627 sh->cabac_init_flag = 0;
629 sh->collocated_ref_idx = 0;
630 if (sh->slice_temporal_mvp_enabled_flag) {
631 sh->collocated_list = L0;
632 if (sh->slice_type == B_SLICE)
633 sh->collocated_list = !get_bits1(gb);
635 if (sh->nb_refs[sh->collocated_list] > 1) {
636 sh->collocated_ref_idx = get_ue_golomb_long(gb);
637 if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
638 av_log(s->avctx, AV_LOG_ERROR,
639 "Invalid collocated_ref_idx: %d.\n",
640 sh->collocated_ref_idx);
641 return AVERROR_INVALIDDATA;
646 if ((s->pps->weighted_pred_flag && sh->slice_type == P_SLICE) ||
647 (s->pps->weighted_bipred_flag && sh->slice_type == B_SLICE)) {
648 pred_weight_table(s, gb);
651 sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
652 if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
653 av_log(s->avctx, AV_LOG_ERROR,
654 "Invalid number of merging MVP candidates: %d.\n",
655 sh->max_num_merge_cand);
656 return AVERROR_INVALIDDATA;
660 sh->slice_qp_delta = get_se_golomb(gb);
662 if (s->pps->pic_slice_level_chroma_qp_offsets_present_flag) {
663 sh->slice_cb_qp_offset = get_se_golomb(gb);
664 sh->slice_cr_qp_offset = get_se_golomb(gb);
666 sh->slice_cb_qp_offset = 0;
667 sh->slice_cr_qp_offset = 0;
670 if (s->pps->chroma_qp_offset_list_enabled_flag)
671 sh->cu_chroma_qp_offset_enabled_flag = get_bits1(gb);
673 sh->cu_chroma_qp_offset_enabled_flag = 0;
675 if (s->pps->deblocking_filter_control_present_flag) {
676 int deblocking_filter_override_flag = 0;
678 if (s->pps->deblocking_filter_override_enabled_flag)
679 deblocking_filter_override_flag = get_bits1(gb);
681 if (deblocking_filter_override_flag) {
682 sh->disable_deblocking_filter_flag = get_bits1(gb);
683 if (!sh->disable_deblocking_filter_flag) {
684 sh->beta_offset = get_se_golomb(gb) * 2;
685 sh->tc_offset = get_se_golomb(gb) * 2;
688 sh->disable_deblocking_filter_flag = s->pps->disable_dbf;
689 sh->beta_offset = s->pps->beta_offset;
690 sh->tc_offset = s->pps->tc_offset;
693 sh->disable_deblocking_filter_flag = 0;
698 if (s->pps->seq_loop_filter_across_slices_enabled_flag &&
699 (sh->slice_sample_adaptive_offset_flag[0] ||
700 sh->slice_sample_adaptive_offset_flag[1] ||
701 !sh->disable_deblocking_filter_flag)) {
702 sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
704 sh->slice_loop_filter_across_slices_enabled_flag = s->pps->seq_loop_filter_across_slices_enabled_flag;
706 } else if (!s->slice_initialized) {
707 av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
708 return AVERROR_INVALIDDATA;
711 sh->num_entry_point_offsets = 0;
712 if (s->pps->tiles_enabled_flag || s->pps->entropy_coding_sync_enabled_flag) {
713 unsigned num_entry_point_offsets = get_ue_golomb_long(gb);
714 // It would be possible to bound this tighter but this here is simpler
715 if (num_entry_point_offsets > get_bits_left(gb)) {
716 av_log(s->avctx, AV_LOG_ERROR, "num_entry_point_offsets %d is invalid\n", num_entry_point_offsets);
717 return AVERROR_INVALIDDATA;
720 sh->num_entry_point_offsets = num_entry_point_offsets;
721 if (sh->num_entry_point_offsets > 0) {
722 int offset_len = get_ue_golomb_long(gb) + 1;
724 if (offset_len < 1 || offset_len > 32) {
725 sh->num_entry_point_offsets = 0;
726 av_log(s->avctx, AV_LOG_ERROR, "offset_len %d is invalid\n", offset_len);
727 return AVERROR_INVALIDDATA;
730 av_freep(&sh->entry_point_offset);
731 av_freep(&sh->offset);
733 sh->entry_point_offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
734 sh->offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
735 sh->size = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
736 if (!sh->entry_point_offset || !sh->offset || !sh->size) {
737 sh->num_entry_point_offsets = 0;
738 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate memory\n");
739 return AVERROR(ENOMEM);
741 for (i = 0; i < sh->num_entry_point_offsets; i++) {
742 unsigned val = get_bits_long(gb, offset_len);
743 sh->entry_point_offset[i] = val + 1; // +1; // +1 to get the size
745 if (s->threads_number > 1 && (s->pps->num_tile_rows > 1 || s->pps->num_tile_columns > 1)) {
746 s->enable_parallel_tiles = 0; // TODO: you can enable tiles in parallel here
747 s->threads_number = 1;
749 s->enable_parallel_tiles = 0;
751 s->enable_parallel_tiles = 0;
754 if (s->pps->slice_header_extension_present_flag) {
755 unsigned int length = get_ue_golomb_long(gb);
756 if (length*8LL > get_bits_left(gb)) {
757 av_log(s->avctx, AV_LOG_ERROR, "too many slice_header_extension_data_bytes\n");
758 return AVERROR_INVALIDDATA;
760 for (i = 0; i < length; i++)
761 skip_bits(gb, 8); // slice_header_extension_data_byte
764 // Inferred parameters
765 sh->slice_qp = 26U + s->pps->pic_init_qp_minus26 + sh->slice_qp_delta;
766 if (sh->slice_qp > 51 ||
767 sh->slice_qp < -s->sps->qp_bd_offset) {
768 av_log(s->avctx, AV_LOG_ERROR,
769 "The slice_qp %d is outside the valid range "
772 -s->sps->qp_bd_offset);
773 return AVERROR_INVALIDDATA;
776 sh->slice_ctb_addr_rs = sh->slice_segment_addr;
778 if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) {
779 av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
780 return AVERROR_INVALIDDATA;
783 if (get_bits_left(gb) < 0) {
784 av_log(s->avctx, AV_LOG_ERROR,
785 "Overread slice header by %d bits\n", -get_bits_left(gb));
786 return AVERROR_INVALIDDATA;
789 s->HEVClc->first_qp_group = !s->sh.dependent_slice_segment_flag;
791 if (!s->pps->cu_qp_delta_enabled_flag)
792 s->HEVClc->qp_y = s->sh.slice_qp;
794 s->slice_initialized = 1;
795 s->HEVClc->tu.cu_qp_offset_cb = 0;
796 s->HEVClc->tu.cu_qp_offset_cr = 0;
801 #define CTB(tab, x, y) ((tab)[(y) * s->sps->ctb_width + (x)])
803 #define SET_SAO(elem, value) \
805 if (!sao_merge_up_flag && !sao_merge_left_flag) \
807 else if (sao_merge_left_flag) \
808 sao->elem = CTB(s->sao, rx-1, ry).elem; \
809 else if (sao_merge_up_flag) \
810 sao->elem = CTB(s->sao, rx, ry-1).elem; \
815 static void hls_sao_param(HEVCContext *s, int rx, int ry)
817 HEVCLocalContext *lc = s->HEVClc;
818 int sao_merge_left_flag = 0;
819 int sao_merge_up_flag = 0;
820 SAOParams *sao = &CTB(s->sao, rx, ry);
823 if (s->sh.slice_sample_adaptive_offset_flag[0] ||
824 s->sh.slice_sample_adaptive_offset_flag[1]) {
826 if (lc->ctb_left_flag)
827 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
829 if (ry > 0 && !sao_merge_left_flag) {
831 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
835 for (c_idx = 0; c_idx < (s->sps->chroma_format_idc ? 3 : 1); c_idx++) {
836 int log2_sao_offset_scale = c_idx == 0 ? s->pps->log2_sao_offset_scale_luma :
837 s->pps->log2_sao_offset_scale_chroma;
839 if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
840 sao->type_idx[c_idx] = SAO_NOT_APPLIED;
845 sao->type_idx[2] = sao->type_idx[1];
846 sao->eo_class[2] = sao->eo_class[1];
848 SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
851 if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
854 for (i = 0; i < 4; i++)
855 SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
857 if (sao->type_idx[c_idx] == SAO_BAND) {
858 for (i = 0; i < 4; i++) {
859 if (sao->offset_abs[c_idx][i]) {
860 SET_SAO(offset_sign[c_idx][i],
861 ff_hevc_sao_offset_sign_decode(s));
863 sao->offset_sign[c_idx][i] = 0;
866 SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
867 } else if (c_idx != 2) {
868 SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
871 // Inferred parameters
872 sao->offset_val[c_idx][0] = 0;
873 for (i = 0; i < 4; i++) {
874 sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i];
875 if (sao->type_idx[c_idx] == SAO_EDGE) {
877 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
878 } else if (sao->offset_sign[c_idx][i]) {
879 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
881 sao->offset_val[c_idx][i + 1] *= 1 << log2_sao_offset_scale;
889 static int hls_cross_component_pred(HEVCContext *s, int idx) {
890 HEVCLocalContext *lc = s->HEVClc;
891 int log2_res_scale_abs_plus1 = ff_hevc_log2_res_scale_abs(s, idx);
893 if (log2_res_scale_abs_plus1 != 0) {
894 int res_scale_sign_flag = ff_hevc_res_scale_sign_flag(s, idx);
895 lc->tu.res_scale_val = (1 << (log2_res_scale_abs_plus1 - 1)) *
896 (1 - 2 * res_scale_sign_flag);
898 lc->tu.res_scale_val = 0;
905 static int hls_transform_unit(HEVCContext *s, int x0, int y0,
906 int xBase, int yBase, int cb_xBase, int cb_yBase,
907 int log2_cb_size, int log2_trafo_size,
908 int blk_idx, int cbf_luma, int *cbf_cb, int *cbf_cr)
910 HEVCLocalContext *lc = s->HEVClc;
911 const int log2_trafo_size_c = log2_trafo_size - s->sps->hshift[1];
914 if (lc->cu.pred_mode == MODE_INTRA) {
915 int trafo_size = 1 << log2_trafo_size;
916 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
918 s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
921 if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
922 (s->sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
923 int scan_idx = SCAN_DIAG;
924 int scan_idx_c = SCAN_DIAG;
925 int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
926 (s->sps->chroma_format_idc == 2 &&
927 (cbf_cb[1] || cbf_cr[1]));
929 if (s->pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
930 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
931 if (lc->tu.cu_qp_delta != 0)
932 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
933 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
934 lc->tu.is_cu_qp_delta_coded = 1;
936 if (lc->tu.cu_qp_delta < -(26 + s->sps->qp_bd_offset / 2) ||
937 lc->tu.cu_qp_delta > (25 + s->sps->qp_bd_offset / 2)) {
938 av_log(s->avctx, AV_LOG_ERROR,
939 "The cu_qp_delta %d is outside the valid range "
942 -(26 + s->sps->qp_bd_offset / 2),
943 (25 + s->sps->qp_bd_offset / 2));
944 return AVERROR_INVALIDDATA;
947 ff_hevc_set_qPy(s, cb_xBase, cb_yBase, log2_cb_size);
950 if (s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
951 !lc->cu.cu_transquant_bypass_flag && !lc->tu.is_cu_chroma_qp_offset_coded) {
952 int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(s);
953 if (cu_chroma_qp_offset_flag) {
954 int cu_chroma_qp_offset_idx = 0;
955 if (s->pps->chroma_qp_offset_list_len_minus1 > 0) {
956 cu_chroma_qp_offset_idx = ff_hevc_cu_chroma_qp_offset_idx(s);
957 av_log(s->avctx, AV_LOG_ERROR,
958 "cu_chroma_qp_offset_idx not yet tested.\n");
960 lc->tu.cu_qp_offset_cb = s->pps->cb_qp_offset_list[cu_chroma_qp_offset_idx];
961 lc->tu.cu_qp_offset_cr = s->pps->cr_qp_offset_list[cu_chroma_qp_offset_idx];
963 lc->tu.cu_qp_offset_cb = 0;
964 lc->tu.cu_qp_offset_cr = 0;
966 lc->tu.is_cu_chroma_qp_offset_coded = 1;
969 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
970 if (lc->tu.intra_pred_mode >= 6 &&
971 lc->tu.intra_pred_mode <= 14) {
972 scan_idx = SCAN_VERT;
973 } else if (lc->tu.intra_pred_mode >= 22 &&
974 lc->tu.intra_pred_mode <= 30) {
975 scan_idx = SCAN_HORIZ;
978 if (lc->tu.intra_pred_mode_c >= 6 &&
979 lc->tu.intra_pred_mode_c <= 14) {
980 scan_idx_c = SCAN_VERT;
981 } else if (lc->tu.intra_pred_mode_c >= 22 &&
982 lc->tu.intra_pred_mode_c <= 30) {
983 scan_idx_c = SCAN_HORIZ;
990 ff_hevc_hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
991 if (s->sps->chroma_format_idc && (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3)) {
992 int trafo_size_h = 1 << (log2_trafo_size_c + s->sps->hshift[1]);
993 int trafo_size_v = 1 << (log2_trafo_size_c + s->sps->vshift[1]);
994 lc->tu.cross_pf = (s->pps->cross_component_prediction_enabled_flag && cbf_luma &&
995 (lc->cu.pred_mode == MODE_INTER ||
996 (lc->tu.chroma_mode_c == 4)));
998 if (lc->tu.cross_pf) {
999 hls_cross_component_pred(s, 0);
1001 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1002 if (lc->cu.pred_mode == MODE_INTRA) {
1003 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1004 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 1);
1007 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1008 log2_trafo_size_c, scan_idx_c, 1);
1010 if (lc->tu.cross_pf) {
1011 ptrdiff_t stride = s->frame->linesize[1];
1012 int hshift = s->sps->hshift[1];
1013 int vshift = s->sps->vshift[1];
1014 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1015 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1016 int size = 1 << log2_trafo_size_c;
1018 uint8_t *dst = &s->frame->data[1][(y0 >> vshift) * stride +
1019 ((x0 >> hshift) << s->sps->pixel_shift)];
1020 for (i = 0; i < (size * size); i++) {
1021 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1023 s->hevcdsp.transform_add[log2_trafo_size_c-2](dst, coeffs, stride);
1027 if (lc->tu.cross_pf) {
1028 hls_cross_component_pred(s, 1);
1030 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1031 if (lc->cu.pred_mode == MODE_INTRA) {
1032 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1033 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 2);
1036 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1037 log2_trafo_size_c, scan_idx_c, 2);
1039 if (lc->tu.cross_pf) {
1040 ptrdiff_t stride = s->frame->linesize[2];
1041 int hshift = s->sps->hshift[2];
1042 int vshift = s->sps->vshift[2];
1043 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1044 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1045 int size = 1 << log2_trafo_size_c;
1047 uint8_t *dst = &s->frame->data[2][(y0 >> vshift) * stride +
1048 ((x0 >> hshift) << s->sps->pixel_shift)];
1049 for (i = 0; i < (size * size); i++) {
1050 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1052 s->hevcdsp.transform_add[log2_trafo_size_c-2](dst, coeffs, stride);
1055 } else if (s->sps->chroma_format_idc && blk_idx == 3) {
1056 int trafo_size_h = 1 << (log2_trafo_size + 1);
1057 int trafo_size_v = 1 << (log2_trafo_size + s->sps->vshift[1]);
1058 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1059 if (lc->cu.pred_mode == MODE_INTRA) {
1060 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1061 trafo_size_h, trafo_size_v);
1062 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 1);
1065 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1066 log2_trafo_size, scan_idx_c, 1);
1068 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1069 if (lc->cu.pred_mode == MODE_INTRA) {
1070 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1071 trafo_size_h, trafo_size_v);
1072 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 2);
1075 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1076 log2_trafo_size, scan_idx_c, 2);
1079 } else if (s->sps->chroma_format_idc && lc->cu.pred_mode == MODE_INTRA) {
1080 if (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3) {
1081 int trafo_size_h = 1 << (log2_trafo_size_c + s->sps->hshift[1]);
1082 int trafo_size_v = 1 << (log2_trafo_size_c + s->sps->vshift[1]);
1083 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size_h, trafo_size_v);
1084 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 1);
1085 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 2);
1086 if (s->sps->chroma_format_idc == 2) {
1087 ff_hevc_set_neighbour_available(s, x0, y0 + (1 << log2_trafo_size_c),
1088 trafo_size_h, trafo_size_v);
1089 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 1);
1090 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 2);
1092 } else if (blk_idx == 3) {
1093 int trafo_size_h = 1 << (log2_trafo_size + 1);
1094 int trafo_size_v = 1 << (log2_trafo_size + s->sps->vshift[1]);
1095 ff_hevc_set_neighbour_available(s, xBase, yBase,
1096 trafo_size_h, trafo_size_v);
1097 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1098 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1099 if (s->sps->chroma_format_idc == 2) {
1100 ff_hevc_set_neighbour_available(s, xBase, yBase + (1 << (log2_trafo_size)),
1101 trafo_size_h, trafo_size_v);
1102 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 1);
1103 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 2);
1111 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1113 int cb_size = 1 << log2_cb_size;
1114 int log2_min_pu_size = s->sps->log2_min_pu_size;
1116 int min_pu_width = s->sps->min_pu_width;
1117 int x_end = FFMIN(x0 + cb_size, s->sps->width);
1118 int y_end = FFMIN(y0 + cb_size, s->sps->height);
1121 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1122 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1123 s->is_pcm[i + j * min_pu_width] = 2;
1126 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1127 int xBase, int yBase, int cb_xBase, int cb_yBase,
1128 int log2_cb_size, int log2_trafo_size,
1129 int trafo_depth, int blk_idx,
1130 const int *base_cbf_cb, const int *base_cbf_cr)
1132 HEVCLocalContext *lc = s->HEVClc;
1133 uint8_t split_transform_flag;
1138 cbf_cb[0] = base_cbf_cb[0];
1139 cbf_cb[1] = base_cbf_cb[1];
1140 cbf_cr[0] = base_cbf_cr[0];
1141 cbf_cr[1] = base_cbf_cr[1];
1143 if (lc->cu.intra_split_flag) {
1144 if (trafo_depth == 1) {
1145 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1146 if (s->sps->chroma_format_idc == 3) {
1147 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[blk_idx];
1148 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[blk_idx];
1150 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1151 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1155 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[0];
1156 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1157 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1160 if (log2_trafo_size <= s->sps->log2_max_trafo_size &&
1161 log2_trafo_size > s->sps->log2_min_tb_size &&
1162 trafo_depth < lc->cu.max_trafo_depth &&
1163 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1164 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1166 int inter_split = s->sps->max_transform_hierarchy_depth_inter == 0 &&
1167 lc->cu.pred_mode == MODE_INTER &&
1168 lc->cu.part_mode != PART_2Nx2N &&
1171 split_transform_flag = log2_trafo_size > s->sps->log2_max_trafo_size ||
1172 (lc->cu.intra_split_flag && trafo_depth == 0) ||
1176 if (s->sps->chroma_format_idc && (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3)) {
1177 if (trafo_depth == 0 || cbf_cb[0]) {
1178 cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1179 if (s->sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1180 cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1184 if (trafo_depth == 0 || cbf_cr[0]) {
1185 cbf_cr[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1186 if (s->sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1187 cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1192 if (split_transform_flag) {
1193 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1194 const int x1 = x0 + trafo_size_split;
1195 const int y1 = y0 + trafo_size_split;
1197 #define SUBDIVIDE(x, y, idx) \
1199 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1200 log2_trafo_size - 1, trafo_depth + 1, idx, \
1206 SUBDIVIDE(x0, y0, 0);
1207 SUBDIVIDE(x1, y0, 1);
1208 SUBDIVIDE(x0, y1, 2);
1209 SUBDIVIDE(x1, y1, 3);
1213 int min_tu_size = 1 << s->sps->log2_min_tb_size;
1214 int log2_min_tu_size = s->sps->log2_min_tb_size;
1215 int min_tu_width = s->sps->min_tb_width;
1218 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1219 cbf_cb[0] || cbf_cr[0] ||
1220 (s->sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1221 cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1224 ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1225 log2_cb_size, log2_trafo_size,
1226 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1229 // TODO: store cbf_luma somewhere else
1232 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1233 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1234 int x_tu = (x0 + j) >> log2_min_tu_size;
1235 int y_tu = (y0 + i) >> log2_min_tu_size;
1236 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1239 if (!s->sh.disable_deblocking_filter_flag) {
1240 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1241 if (s->pps->transquant_bypass_enable_flag &&
1242 lc->cu.cu_transquant_bypass_flag)
1243 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1249 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1251 HEVCLocalContext *lc = s->HEVClc;
1253 int cb_size = 1 << log2_cb_size;
1254 int stride0 = s->frame->linesize[0];
1255 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->sps->pixel_shift)];
1256 int stride1 = s->frame->linesize[1];
1257 uint8_t *dst1 = &s->frame->data[1][(y0 >> s->sps->vshift[1]) * stride1 + ((x0 >> s->sps->hshift[1]) << s->sps->pixel_shift)];
1258 int stride2 = s->frame->linesize[2];
1259 uint8_t *dst2 = &s->frame->data[2][(y0 >> s->sps->vshift[2]) * stride2 + ((x0 >> s->sps->hshift[2]) << s->sps->pixel_shift)];
1261 int length = cb_size * cb_size * s->sps->pcm.bit_depth +
1262 (((cb_size >> s->sps->hshift[1]) * (cb_size >> s->sps->vshift[1])) +
1263 ((cb_size >> s->sps->hshift[2]) * (cb_size >> s->sps->vshift[2]))) *
1264 s->sps->pcm.bit_depth_chroma;
1265 const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1268 if (!s->sh.disable_deblocking_filter_flag)
1269 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1271 ret = init_get_bits(&gb, pcm, length);
1275 s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size, &gb, s->sps->pcm.bit_depth);
1276 if (s->sps->chroma_format_idc) {
1277 s->hevcdsp.put_pcm(dst1, stride1,
1278 cb_size >> s->sps->hshift[1],
1279 cb_size >> s->sps->vshift[1],
1280 &gb, s->sps->pcm.bit_depth_chroma);
1281 s->hevcdsp.put_pcm(dst2, stride2,
1282 cb_size >> s->sps->hshift[2],
1283 cb_size >> s->sps->vshift[2],
1284 &gb, s->sps->pcm.bit_depth_chroma);
1291 * 8.5.3.2.2.1 Luma sample unidirectional interpolation process
1293 * @param s HEVC decoding context
1294 * @param dst target buffer for block data at block position
1295 * @param dststride stride of the dst buffer
1296 * @param ref reference picture buffer at origin (0, 0)
1297 * @param mv motion vector (relative to block position) to get pixel data from
1298 * @param x_off horizontal position of block from origin (0, 0)
1299 * @param y_off vertical position of block from origin (0, 0)
1300 * @param block_w width of block
1301 * @param block_h height of block
1302 * @param luma_weight weighting factor applied to the luma prediction
1303 * @param luma_offset additive offset applied to the luma prediction value
1306 static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1307 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1308 int block_w, int block_h, int luma_weight, int luma_offset)
1310 HEVCLocalContext *lc = s->HEVClc;
1311 uint8_t *src = ref->data[0];
1312 ptrdiff_t srcstride = ref->linesize[0];
1313 int pic_width = s->sps->width;
1314 int pic_height = s->sps->height;
1317 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1318 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1319 int idx = ff_hevc_pel_weight[block_w];
1321 x_off += mv->x >> 2;
1322 y_off += mv->y >> 2;
1323 src += y_off * srcstride + x_off * (1 << s->sps->pixel_shift);
1325 if (x_off < QPEL_EXTRA_BEFORE || y_off < QPEL_EXTRA_AFTER ||
1326 x_off >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1327 y_off >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1328 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1329 int offset = QPEL_EXTRA_BEFORE * srcstride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1330 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1332 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1333 edge_emu_stride, srcstride,
1334 block_w + QPEL_EXTRA,
1335 block_h + QPEL_EXTRA,
1336 x_off - QPEL_EXTRA_BEFORE, y_off - QPEL_EXTRA_BEFORE,
1337 pic_width, pic_height);
1338 src = lc->edge_emu_buffer + buf_offset;
1339 srcstride = edge_emu_stride;
1343 s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride, src, srcstride,
1344 block_h, mx, my, block_w);
1346 s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride, src, srcstride,
1347 block_h, s->sh.luma_log2_weight_denom,
1348 luma_weight, luma_offset, mx, my, block_w);
1352 * 8.5.3.2.2.1 Luma sample bidirectional interpolation process
1354 * @param s HEVC decoding context
1355 * @param dst target buffer for block data at block position
1356 * @param dststride stride of the dst buffer
1357 * @param ref0 reference picture0 buffer at origin (0, 0)
1358 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1359 * @param x_off horizontal position of block from origin (0, 0)
1360 * @param y_off vertical position of block from origin (0, 0)
1361 * @param block_w width of block
1362 * @param block_h height of block
1363 * @param ref1 reference picture1 buffer at origin (0, 0)
1364 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1365 * @param current_mv current motion vector structure
1367 static void luma_mc_bi(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1368 AVFrame *ref0, const Mv *mv0, int x_off, int y_off,
1369 int block_w, int block_h, AVFrame *ref1, const Mv *mv1, struct MvField *current_mv)
1371 HEVCLocalContext *lc = s->HEVClc;
1372 ptrdiff_t src0stride = ref0->linesize[0];
1373 ptrdiff_t src1stride = ref1->linesize[0];
1374 int pic_width = s->sps->width;
1375 int pic_height = s->sps->height;
1376 int mx0 = mv0->x & 3;
1377 int my0 = mv0->y & 3;
1378 int mx1 = mv1->x & 3;
1379 int my1 = mv1->y & 3;
1380 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1381 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1382 int x_off0 = x_off + (mv0->x >> 2);
1383 int y_off0 = y_off + (mv0->y >> 2);
1384 int x_off1 = x_off + (mv1->x >> 2);
1385 int y_off1 = y_off + (mv1->y >> 2);
1386 int idx = ff_hevc_pel_weight[block_w];
1388 uint8_t *src0 = ref0->data[0] + y_off0 * src0stride + (int)((unsigned)x_off0 << s->sps->pixel_shift);
1389 uint8_t *src1 = ref1->data[0] + y_off1 * src1stride + (int)((unsigned)x_off1 << s->sps->pixel_shift);
1391 if (x_off0 < QPEL_EXTRA_BEFORE || y_off0 < QPEL_EXTRA_AFTER ||
1392 x_off0 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1393 y_off0 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1394 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1395 int offset = QPEL_EXTRA_BEFORE * src0stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1396 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1398 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset,
1399 edge_emu_stride, src0stride,
1400 block_w + QPEL_EXTRA,
1401 block_h + QPEL_EXTRA,
1402 x_off0 - QPEL_EXTRA_BEFORE, y_off0 - QPEL_EXTRA_BEFORE,
1403 pic_width, pic_height);
1404 src0 = lc->edge_emu_buffer + buf_offset;
1405 src0stride = edge_emu_stride;
1408 if (x_off1 < QPEL_EXTRA_BEFORE || y_off1 < QPEL_EXTRA_AFTER ||
1409 x_off1 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1410 y_off1 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1411 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1412 int offset = QPEL_EXTRA_BEFORE * src1stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1413 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1415 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src1 - offset,
1416 edge_emu_stride, src1stride,
1417 block_w + QPEL_EXTRA,
1418 block_h + QPEL_EXTRA,
1419 x_off1 - QPEL_EXTRA_BEFORE, y_off1 - QPEL_EXTRA_BEFORE,
1420 pic_width, pic_height);
1421 src1 = lc->edge_emu_buffer2 + buf_offset;
1422 src1stride = edge_emu_stride;
1425 s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](lc->tmp, src0, src0stride,
1426 block_h, mx0, my0, block_w);
1428 s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1429 block_h, mx1, my1, block_w);
1431 s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1432 block_h, s->sh.luma_log2_weight_denom,
1433 s->sh.luma_weight_l0[current_mv->ref_idx[0]],
1434 s->sh.luma_weight_l1[current_mv->ref_idx[1]],
1435 s->sh.luma_offset_l0[current_mv->ref_idx[0]],
1436 s->sh.luma_offset_l1[current_mv->ref_idx[1]],
1442 * 8.5.3.2.2.2 Chroma sample uniprediction interpolation process
1444 * @param s HEVC decoding context
1445 * @param dst1 target buffer for block data at block position (U plane)
1446 * @param dst2 target buffer for block data at block position (V plane)
1447 * @param dststride stride of the dst1 and dst2 buffers
1448 * @param ref reference picture buffer at origin (0, 0)
1449 * @param mv motion vector (relative to block position) to get pixel data from
1450 * @param x_off horizontal position of block from origin (0, 0)
1451 * @param y_off vertical position of block from origin (0, 0)
1452 * @param block_w width of block
1453 * @param block_h height of block
1454 * @param chroma_weight weighting factor applied to the chroma prediction
1455 * @param chroma_offset additive offset applied to the chroma prediction value
1458 static void chroma_mc_uni(HEVCContext *s, uint8_t *dst0,
1459 ptrdiff_t dststride, uint8_t *src0, ptrdiff_t srcstride, int reflist,
1460 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int chroma_weight, int chroma_offset)
1462 HEVCLocalContext *lc = s->HEVClc;
1463 int pic_width = s->sps->width >> s->sps->hshift[1];
1464 int pic_height = s->sps->height >> s->sps->vshift[1];
1465 const Mv *mv = ¤t_mv->mv[reflist];
1466 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1467 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1468 int idx = ff_hevc_pel_weight[block_w];
1469 int hshift = s->sps->hshift[1];
1470 int vshift = s->sps->vshift[1];
1471 intptr_t mx = av_mod_uintp2(mv->x, 2 + hshift);
1472 intptr_t my = av_mod_uintp2(mv->y, 2 + vshift);
1473 intptr_t _mx = mx << (1 - hshift);
1474 intptr_t _my = my << (1 - vshift);
1476 x_off += mv->x >> (2 + hshift);
1477 y_off += mv->y >> (2 + vshift);
1478 src0 += y_off * srcstride + x_off * (1 << s->sps->pixel_shift);
1480 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1481 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1482 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1483 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1484 int offset0 = EPEL_EXTRA_BEFORE * (srcstride + (1 << s->sps->pixel_shift));
1485 int buf_offset0 = EPEL_EXTRA_BEFORE *
1486 (edge_emu_stride + (1 << s->sps->pixel_shift));
1487 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset0,
1488 edge_emu_stride, srcstride,
1489 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1490 x_off - EPEL_EXTRA_BEFORE,
1491 y_off - EPEL_EXTRA_BEFORE,
1492 pic_width, pic_height);
1494 src0 = lc->edge_emu_buffer + buf_offset0;
1495 srcstride = edge_emu_stride;
1498 s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1499 block_h, _mx, _my, block_w);
1501 s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1502 block_h, s->sh.chroma_log2_weight_denom,
1503 chroma_weight, chroma_offset, _mx, _my, block_w);
1507 * 8.5.3.2.2.2 Chroma sample bidirectional interpolation process
1509 * @param s HEVC decoding context
1510 * @param dst target buffer for block data at block position
1511 * @param dststride stride of the dst buffer
1512 * @param ref0 reference picture0 buffer at origin (0, 0)
1513 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1514 * @param x_off horizontal position of block from origin (0, 0)
1515 * @param y_off vertical position of block from origin (0, 0)
1516 * @param block_w width of block
1517 * @param block_h height of block
1518 * @param ref1 reference picture1 buffer at origin (0, 0)
1519 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1520 * @param current_mv current motion vector structure
1521 * @param cidx chroma component(cb, cr)
1523 static void chroma_mc_bi(HEVCContext *s, uint8_t *dst0, ptrdiff_t dststride, AVFrame *ref0, AVFrame *ref1,
1524 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int cidx)
1526 HEVCLocalContext *lc = s->HEVClc;
1527 uint8_t *src1 = ref0->data[cidx+1];
1528 uint8_t *src2 = ref1->data[cidx+1];
1529 ptrdiff_t src1stride = ref0->linesize[cidx+1];
1530 ptrdiff_t src2stride = ref1->linesize[cidx+1];
1531 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1532 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1533 int pic_width = s->sps->width >> s->sps->hshift[1];
1534 int pic_height = s->sps->height >> s->sps->vshift[1];
1535 Mv *mv0 = ¤t_mv->mv[0];
1536 Mv *mv1 = ¤t_mv->mv[1];
1537 int hshift = s->sps->hshift[1];
1538 int vshift = s->sps->vshift[1];
1540 intptr_t mx0 = av_mod_uintp2(mv0->x, 2 + hshift);
1541 intptr_t my0 = av_mod_uintp2(mv0->y, 2 + vshift);
1542 intptr_t mx1 = av_mod_uintp2(mv1->x, 2 + hshift);
1543 intptr_t my1 = av_mod_uintp2(mv1->y, 2 + vshift);
1544 intptr_t _mx0 = mx0 << (1 - hshift);
1545 intptr_t _my0 = my0 << (1 - vshift);
1546 intptr_t _mx1 = mx1 << (1 - hshift);
1547 intptr_t _my1 = my1 << (1 - vshift);
1549 int x_off0 = x_off + (mv0->x >> (2 + hshift));
1550 int y_off0 = y_off + (mv0->y >> (2 + vshift));
1551 int x_off1 = x_off + (mv1->x >> (2 + hshift));
1552 int y_off1 = y_off + (mv1->y >> (2 + vshift));
1553 int idx = ff_hevc_pel_weight[block_w];
1554 src1 += y_off0 * src1stride + (int)((unsigned)x_off0 << s->sps->pixel_shift);
1555 src2 += y_off1 * src2stride + (int)((unsigned)x_off1 << s->sps->pixel_shift);
1557 if (x_off0 < EPEL_EXTRA_BEFORE || y_off0 < EPEL_EXTRA_AFTER ||
1558 x_off0 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1559 y_off0 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1560 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1561 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->sps->pixel_shift));
1562 int buf_offset1 = EPEL_EXTRA_BEFORE *
1563 (edge_emu_stride + (1 << s->sps->pixel_shift));
1565 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1566 edge_emu_stride, src1stride,
1567 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1568 x_off0 - EPEL_EXTRA_BEFORE,
1569 y_off0 - EPEL_EXTRA_BEFORE,
1570 pic_width, pic_height);
1572 src1 = lc->edge_emu_buffer + buf_offset1;
1573 src1stride = edge_emu_stride;
1576 if (x_off1 < EPEL_EXTRA_BEFORE || y_off1 < EPEL_EXTRA_AFTER ||
1577 x_off1 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1578 y_off1 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1579 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1580 int offset1 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->sps->pixel_shift));
1581 int buf_offset1 = EPEL_EXTRA_BEFORE *
1582 (edge_emu_stride + (1 << s->sps->pixel_shift));
1584 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src2 - offset1,
1585 edge_emu_stride, src2stride,
1586 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1587 x_off1 - EPEL_EXTRA_BEFORE,
1588 y_off1 - EPEL_EXTRA_BEFORE,
1589 pic_width, pic_height);
1591 src2 = lc->edge_emu_buffer2 + buf_offset1;
1592 src2stride = edge_emu_stride;
1595 s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](lc->tmp, src1, src1stride,
1596 block_h, _mx0, _my0, block_w);
1598 s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1599 src2, src2stride, lc->tmp,
1600 block_h, _mx1, _my1, block_w);
1602 s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1603 src2, src2stride, lc->tmp,
1605 s->sh.chroma_log2_weight_denom,
1606 s->sh.chroma_weight_l0[current_mv->ref_idx[0]][cidx],
1607 s->sh.chroma_weight_l1[current_mv->ref_idx[1]][cidx],
1608 s->sh.chroma_offset_l0[current_mv->ref_idx[0]][cidx],
1609 s->sh.chroma_offset_l1[current_mv->ref_idx[1]][cidx],
1610 _mx1, _my1, block_w);
1613 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1614 const Mv *mv, int y0, int height)
1616 int y = FFMAX(0, (mv->y >> 2) + y0 + height + 9);
1618 if (s->threads_type == FF_THREAD_FRAME )
1619 ff_thread_await_progress(&ref->tf, y, 0);
1622 static void hevc_luma_mv_mpv_mode(HEVCContext *s, int x0, int y0, int nPbW,
1623 int nPbH, int log2_cb_size, int part_idx,
1624 int merge_idx, MvField *mv)
1626 HEVCLocalContext *lc = s->HEVClc;
1627 enum InterPredIdc inter_pred_idc = PRED_L0;
1630 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1632 if (s->sh.slice_type == B_SLICE)
1633 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1635 if (inter_pred_idc != PRED_L1) {
1636 if (s->sh.nb_refs[L0])
1637 mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1639 mv->pred_flag = PF_L0;
1640 ff_hevc_hls_mvd_coding(s, x0, y0, 0);
1641 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1642 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1643 part_idx, merge_idx, mv, mvp_flag, 0);
1644 mv->mv[0].x += lc->pu.mvd.x;
1645 mv->mv[0].y += lc->pu.mvd.y;
1648 if (inter_pred_idc != PRED_L0) {
1649 if (s->sh.nb_refs[L1])
1650 mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1652 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1653 AV_ZERO32(&lc->pu.mvd);
1655 ff_hevc_hls_mvd_coding(s, x0, y0, 1);
1658 mv->pred_flag += PF_L1;
1659 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1660 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1661 part_idx, merge_idx, mv, mvp_flag, 1);
1662 mv->mv[1].x += lc->pu.mvd.x;
1663 mv->mv[1].y += lc->pu.mvd.y;
1667 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1669 int log2_cb_size, int partIdx, int idx)
1671 #define POS(c_idx, x, y) \
1672 &s->frame->data[c_idx][((y) >> s->sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1673 (((x) >> s->sps->hshift[c_idx]) << s->sps->pixel_shift)]
1674 HEVCLocalContext *lc = s->HEVClc;
1676 struct MvField current_mv = {{{ 0 }}};
1678 int min_pu_width = s->sps->min_pu_width;
1680 MvField *tab_mvf = s->ref->tab_mvf;
1681 RefPicList *refPicList = s->ref->refPicList;
1682 HEVCFrame *ref0 = NULL, *ref1 = NULL;
1683 uint8_t *dst0 = POS(0, x0, y0);
1684 uint8_t *dst1 = POS(1, x0, y0);
1685 uint8_t *dst2 = POS(2, x0, y0);
1686 int log2_min_cb_size = s->sps->log2_min_cb_size;
1687 int min_cb_width = s->sps->min_cb_width;
1688 int x_cb = x0 >> log2_min_cb_size;
1689 int y_cb = y0 >> log2_min_cb_size;
1693 int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1696 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1698 if (skip_flag || lc->pu.merge_flag) {
1699 if (s->sh.max_num_merge_cand > 1)
1700 merge_idx = ff_hevc_merge_idx_decode(s);
1704 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1705 partIdx, merge_idx, ¤t_mv);
1707 hevc_luma_mv_mpv_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1708 partIdx, merge_idx, ¤t_mv);
1711 x_pu = x0 >> s->sps->log2_min_pu_size;
1712 y_pu = y0 >> s->sps->log2_min_pu_size;
1714 for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1715 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1716 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1718 if (current_mv.pred_flag & PF_L0) {
1719 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1722 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1724 if (current_mv.pred_flag & PF_L1) {
1725 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1728 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1731 if (current_mv.pred_flag == PF_L0) {
1732 int x0_c = x0 >> s->sps->hshift[1];
1733 int y0_c = y0 >> s->sps->vshift[1];
1734 int nPbW_c = nPbW >> s->sps->hshift[1];
1735 int nPbH_c = nPbH >> s->sps->vshift[1];
1737 luma_mc_uni(s, dst0, s->frame->linesize[0], ref0->frame,
1738 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1739 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1740 s->sh.luma_offset_l0[current_mv.ref_idx[0]]);
1742 if (s->sps->chroma_format_idc) {
1743 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref0->frame->data[1], ref0->frame->linesize[1],
1744 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1745 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]);
1746 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref0->frame->data[2], ref0->frame->linesize[2],
1747 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1748 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]);
1750 } else if (current_mv.pred_flag == PF_L1) {
1751 int x0_c = x0 >> s->sps->hshift[1];
1752 int y0_c = y0 >> s->sps->vshift[1];
1753 int nPbW_c = nPbW >> s->sps->hshift[1];
1754 int nPbH_c = nPbH >> s->sps->vshift[1];
1756 luma_mc_uni(s, dst0, s->frame->linesize[0], ref1->frame,
1757 ¤t_mv.mv[1], x0, y0, nPbW, nPbH,
1758 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1759 s->sh.luma_offset_l1[current_mv.ref_idx[1]]);
1761 if (s->sps->chroma_format_idc) {
1762 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
1763 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1764 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]);
1766 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
1767 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1768 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]);
1770 } else if (current_mv.pred_flag == PF_BI) {
1771 int x0_c = x0 >> s->sps->hshift[1];
1772 int y0_c = y0 >> s->sps->vshift[1];
1773 int nPbW_c = nPbW >> s->sps->hshift[1];
1774 int nPbH_c = nPbH >> s->sps->vshift[1];
1776 luma_mc_bi(s, dst0, s->frame->linesize[0], ref0->frame,
1777 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1778 ref1->frame, ¤t_mv.mv[1], ¤t_mv);
1780 if (s->sps->chroma_format_idc) {
1781 chroma_mc_bi(s, dst1, s->frame->linesize[1], ref0->frame, ref1->frame,
1782 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 0);
1784 chroma_mc_bi(s, dst2, s->frame->linesize[2], ref0->frame, ref1->frame,
1785 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1);
1793 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1794 int prev_intra_luma_pred_flag)
1796 HEVCLocalContext *lc = s->HEVClc;
1797 int x_pu = x0 >> s->sps->log2_min_pu_size;
1798 int y_pu = y0 >> s->sps->log2_min_pu_size;
1799 int min_pu_width = s->sps->min_pu_width;
1800 int size_in_pus = pu_size >> s->sps->log2_min_pu_size;
1801 int x0b = av_mod_uintp2(x0, s->sps->log2_ctb_size);
1802 int y0b = av_mod_uintp2(y0, s->sps->log2_ctb_size);
1804 int cand_up = (lc->ctb_up_flag || y0b) ?
1805 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1806 int cand_left = (lc->ctb_left_flag || x0b) ?
1807 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1809 int y_ctb = (y0 >> (s->sps->log2_ctb_size)) << (s->sps->log2_ctb_size);
1811 MvField *tab_mvf = s->ref->tab_mvf;
1812 int intra_pred_mode;
1816 // intra_pred_mode prediction does not cross vertical CTB boundaries
1817 if ((y0 - 1) < y_ctb)
1820 if (cand_left == cand_up) {
1821 if (cand_left < 2) {
1822 candidate[0] = INTRA_PLANAR;
1823 candidate[1] = INTRA_DC;
1824 candidate[2] = INTRA_ANGULAR_26;
1826 candidate[0] = cand_left;
1827 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1828 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1831 candidate[0] = cand_left;
1832 candidate[1] = cand_up;
1833 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1834 candidate[2] = INTRA_PLANAR;
1835 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1836 candidate[2] = INTRA_DC;
1838 candidate[2] = INTRA_ANGULAR_26;
1842 if (prev_intra_luma_pred_flag) {
1843 intra_pred_mode = candidate[lc->pu.mpm_idx];
1845 if (candidate[0] > candidate[1])
1846 FFSWAP(uint8_t, candidate[0], candidate[1]);
1847 if (candidate[0] > candidate[2])
1848 FFSWAP(uint8_t, candidate[0], candidate[2]);
1849 if (candidate[1] > candidate[2])
1850 FFSWAP(uint8_t, candidate[1], candidate[2]);
1852 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1853 for (i = 0; i < 3; i++)
1854 if (intra_pred_mode >= candidate[i])
1858 /* write the intra prediction units into the mv array */
1861 for (i = 0; i < size_in_pus; i++) {
1862 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1863 intra_pred_mode, size_in_pus);
1865 for (j = 0; j < size_in_pus; j++) {
1866 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag = PF_INTRA;
1870 return intra_pred_mode;
1873 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1874 int log2_cb_size, int ct_depth)
1876 int length = (1 << log2_cb_size) >> s->sps->log2_min_cb_size;
1877 int x_cb = x0 >> s->sps->log2_min_cb_size;
1878 int y_cb = y0 >> s->sps->log2_min_cb_size;
1881 for (y = 0; y < length; y++)
1882 memset(&s->tab_ct_depth[(y_cb + y) * s->sps->min_cb_width + x_cb],
1886 static const uint8_t tab_mode_idx[] = {
1887 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
1888 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
1890 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1893 HEVCLocalContext *lc = s->HEVClc;
1894 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1895 uint8_t prev_intra_luma_pred_flag[4];
1896 int split = lc->cu.part_mode == PART_NxN;
1897 int pb_size = (1 << log2_cb_size) >> split;
1898 int side = split + 1;
1902 for (i = 0; i < side; i++)
1903 for (j = 0; j < side; j++)
1904 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1906 for (i = 0; i < side; i++) {
1907 for (j = 0; j < side; j++) {
1908 if (prev_intra_luma_pred_flag[2 * i + j])
1909 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
1911 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
1913 lc->pu.intra_pred_mode[2 * i + j] =
1914 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1915 prev_intra_luma_pred_flag[2 * i + j]);
1919 if (s->sps->chroma_format_idc == 3) {
1920 for (i = 0; i < side; i++) {
1921 for (j = 0; j < side; j++) {
1922 lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1923 if (chroma_mode != 4) {
1924 if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode])
1925 lc->pu.intra_pred_mode_c[2 * i + j] = 34;
1927 lc->pu.intra_pred_mode_c[2 * i + j] = intra_chroma_table[chroma_mode];
1929 lc->pu.intra_pred_mode_c[2 * i + j] = lc->pu.intra_pred_mode[2 * i + j];
1933 } else if (s->sps->chroma_format_idc == 2) {
1935 lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1936 if (chroma_mode != 4) {
1937 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1940 mode_idx = intra_chroma_table[chroma_mode];
1942 mode_idx = lc->pu.intra_pred_mode[0];
1944 lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx];
1945 } else if (s->sps->chroma_format_idc != 0) {
1946 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1947 if (chroma_mode != 4) {
1948 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1949 lc->pu.intra_pred_mode_c[0] = 34;
1951 lc->pu.intra_pred_mode_c[0] = intra_chroma_table[chroma_mode];
1953 lc->pu.intra_pred_mode_c[0] = lc->pu.intra_pred_mode[0];
1958 static void intra_prediction_unit_default_value(HEVCContext *s,
1962 HEVCLocalContext *lc = s->HEVClc;
1963 int pb_size = 1 << log2_cb_size;
1964 int size_in_pus = pb_size >> s->sps->log2_min_pu_size;
1965 int min_pu_width = s->sps->min_pu_width;
1966 MvField *tab_mvf = s->ref->tab_mvf;
1967 int x_pu = x0 >> s->sps->log2_min_pu_size;
1968 int y_pu = y0 >> s->sps->log2_min_pu_size;
1971 if (size_in_pus == 0)
1973 for (j = 0; j < size_in_pus; j++)
1974 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
1975 if (lc->cu.pred_mode == MODE_INTRA)
1976 for (j = 0; j < size_in_pus; j++)
1977 for (k = 0; k < size_in_pus; k++)
1978 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].pred_flag = PF_INTRA;
1981 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
1983 int cb_size = 1 << log2_cb_size;
1984 HEVCLocalContext *lc = s->HEVClc;
1985 int log2_min_cb_size = s->sps->log2_min_cb_size;
1986 int length = cb_size >> log2_min_cb_size;
1987 int min_cb_width = s->sps->min_cb_width;
1988 int x_cb = x0 >> log2_min_cb_size;
1989 int y_cb = y0 >> log2_min_cb_size;
1990 int idx = log2_cb_size - 2;
1991 int qp_block_mask = (1<<(s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth)) - 1;
1996 lc->cu.pred_mode = MODE_INTRA;
1997 lc->cu.part_mode = PART_2Nx2N;
1998 lc->cu.intra_split_flag = 0;
2000 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
2001 for (x = 0; x < 4; x++)
2002 lc->pu.intra_pred_mode[x] = 1;
2003 if (s->pps->transquant_bypass_enable_flag) {
2004 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
2005 if (lc->cu.cu_transquant_bypass_flag)
2006 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2008 lc->cu.cu_transquant_bypass_flag = 0;
2010 if (s->sh.slice_type != I_SLICE) {
2011 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
2013 x = y_cb * min_cb_width + x_cb;
2014 for (y = 0; y < length; y++) {
2015 memset(&s->skip_flag[x], skip_flag, length);
2018 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2020 x = y_cb * min_cb_width + x_cb;
2021 for (y = 0; y < length; y++) {
2022 memset(&s->skip_flag[x], 0, length);
2027 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2028 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2029 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2031 if (!s->sh.disable_deblocking_filter_flag)
2032 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2036 if (s->sh.slice_type != I_SLICE)
2037 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2038 if (lc->cu.pred_mode != MODE_INTRA ||
2039 log2_cb_size == s->sps->log2_min_cb_size) {
2040 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2041 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2042 lc->cu.pred_mode == MODE_INTRA;
2045 if (lc->cu.pred_mode == MODE_INTRA) {
2046 if (lc->cu.part_mode == PART_2Nx2N && s->sps->pcm_enabled_flag &&
2047 log2_cb_size >= s->sps->pcm.log2_min_pcm_cb_size &&
2048 log2_cb_size <= s->sps->pcm.log2_max_pcm_cb_size) {
2049 pcm_flag = ff_hevc_pcm_flag_decode(s);
2052 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2053 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2054 if (s->sps->pcm.loop_filter_disable_flag)
2055 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2060 intra_prediction_unit(s, x0, y0, log2_cb_size);
2063 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2064 switch (lc->cu.part_mode) {
2066 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2069 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0, idx);
2070 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2073 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2074 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2077 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0, idx);
2078 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2081 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2082 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2085 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0, idx - 2);
2086 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2089 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2090 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2093 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2094 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2095 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2096 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2102 int rqt_root_cbf = 1;
2104 if (lc->cu.pred_mode != MODE_INTRA &&
2105 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2106 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2109 const static int cbf[2] = { 0 };
2110 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2111 s->sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2112 s->sps->max_transform_hierarchy_depth_inter;
2113 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2115 log2_cb_size, 0, 0, cbf, cbf);
2119 if (!s->sh.disable_deblocking_filter_flag)
2120 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2125 if (s->pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2126 ff_hevc_set_qPy(s, x0, y0, log2_cb_size);
2128 x = y_cb * min_cb_width + x_cb;
2129 for (y = 0; y < length; y++) {
2130 memset(&s->qp_y_tab[x], lc->qp_y, length);
2134 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2135 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2136 lc->qPy_pred = lc->qp_y;
2139 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct_depth);
2144 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2145 int log2_cb_size, int cb_depth)
2147 HEVCLocalContext *lc = s->HEVClc;
2148 const int cb_size = 1 << log2_cb_size;
2152 lc->ct_depth = cb_depth;
2153 if (x0 + cb_size <= s->sps->width &&
2154 y0 + cb_size <= s->sps->height &&
2155 log2_cb_size > s->sps->log2_min_cb_size) {
2156 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2158 split_cu = (log2_cb_size > s->sps->log2_min_cb_size);
2160 if (s->pps->cu_qp_delta_enabled_flag &&
2161 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth) {
2162 lc->tu.is_cu_qp_delta_coded = 0;
2163 lc->tu.cu_qp_delta = 0;
2166 if (s->sh.cu_chroma_qp_offset_enabled_flag &&
2167 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_chroma_qp_offset_depth) {
2168 lc->tu.is_cu_chroma_qp_offset_coded = 0;
2172 int qp_block_mask = (1<<(s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth)) - 1;
2173 const int cb_size_split = cb_size >> 1;
2174 const int x1 = x0 + cb_size_split;
2175 const int y1 = y0 + cb_size_split;
2179 more_data = hls_coding_quadtree(s, x0, y0, log2_cb_size - 1, cb_depth + 1);
2183 if (more_data && x1 < s->sps->width) {
2184 more_data = hls_coding_quadtree(s, x1, y0, log2_cb_size - 1, cb_depth + 1);
2188 if (more_data && y1 < s->sps->height) {
2189 more_data = hls_coding_quadtree(s, x0, y1, log2_cb_size - 1, cb_depth + 1);
2193 if (more_data && x1 < s->sps->width &&
2194 y1 < s->sps->height) {
2195 more_data = hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1);
2200 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2201 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2202 lc->qPy_pred = lc->qp_y;
2205 return ((x1 + cb_size_split) < s->sps->width ||
2206 (y1 + cb_size_split) < s->sps->height);
2210 ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2213 if ((!((x0 + cb_size) %
2214 (1 << (s->sps->log2_ctb_size))) ||
2215 (x0 + cb_size >= s->sps->width)) &&
2217 (1 << (s->sps->log2_ctb_size))) ||
2218 (y0 + cb_size >= s->sps->height))) {
2219 int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s);
2220 return !end_of_slice_flag;
2229 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2232 HEVCLocalContext *lc = s->HEVClc;
2233 int ctb_size = 1 << s->sps->log2_ctb_size;
2234 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2235 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2237 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2239 if (s->pps->entropy_coding_sync_enabled_flag) {
2240 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2241 lc->first_qp_group = 1;
2242 lc->end_of_tiles_x = s->sps->width;
2243 } else if (s->pps->tiles_enabled_flag) {
2244 if (ctb_addr_ts && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1]) {
2245 int idxX = s->pps->col_idxX[x_ctb >> s->sps->log2_ctb_size];
2246 lc->end_of_tiles_x = x_ctb + (s->pps->column_width[idxX] << s->sps->log2_ctb_size);
2247 lc->first_qp_group = 1;
2250 lc->end_of_tiles_x = s->sps->width;
2253 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->sps->height);
2255 lc->boundary_flags = 0;
2256 if (s->pps->tiles_enabled_flag) {
2257 if (x_ctb > 0 && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs - 1]])
2258 lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2259 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2260 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2261 if (y_ctb > 0 && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs - s->sps->ctb_width]])
2262 lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2263 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->sps->ctb_width])
2264 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2266 if (ctb_addr_in_slice <= 0)
2267 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2268 if (ctb_addr_in_slice < s->sps->ctb_width)
2269 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2272 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2273 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2274 lc->ctb_up_right_flag = ((y_ctb > 0) && (ctb_addr_in_slice+1 >= s->sps->ctb_width) && (s->pps->tile_id[ctb_addr_ts] == s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs+1 - s->sps->ctb_width]]));
2275 lc->ctb_up_left_flag = ((x_ctb > 0) && (y_ctb > 0) && (ctb_addr_in_slice-1 >= s->sps->ctb_width) && (s->pps->tile_id[ctb_addr_ts] == s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs-1 - s->sps->ctb_width]]));
2278 static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
2280 HEVCContext *s = avctxt->priv_data;
2281 int ctb_size = 1 << s->sps->log2_ctb_size;
2285 int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2287 if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) {
2288 av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n");
2289 return AVERROR_INVALIDDATA;
2292 if (s->sh.dependent_slice_segment_flag) {
2293 int prev_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2294 if (s->tab_slice_address[prev_rs] != s->sh.slice_addr) {
2295 av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n");
2296 return AVERROR_INVALIDDATA;
2300 while (more_data && ctb_addr_ts < s->sps->ctb_size) {
2301 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2303 x_ctb = (ctb_addr_rs % ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2304 y_ctb = (ctb_addr_rs / ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2305 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2307 ff_hevc_cabac_init(s, ctb_addr_ts);
2309 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2311 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2312 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2313 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2315 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2316 if (more_data < 0) {
2317 s->tab_slice_address[ctb_addr_rs] = -1;
2323 ff_hevc_save_states(s, ctb_addr_ts);
2324 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2327 if (x_ctb + ctb_size >= s->sps->width &&
2328 y_ctb + ctb_size >= s->sps->height)
2329 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2334 static int hls_slice_data(HEVCContext *s)
2342 s->avctx->execute(s->avctx, hls_decode_entry, arg, ret , 1, sizeof(int));
2345 static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int job, int self_id)
2347 HEVCContext *s1 = avctxt->priv_data, *s;
2348 HEVCLocalContext *lc;
2349 int ctb_size = 1<< s1->sps->log2_ctb_size;
2351 int *ctb_row_p = input_ctb_row;
2352 int ctb_row = ctb_row_p[job];
2353 int ctb_addr_rs = s1->sh.slice_ctb_addr_rs + ctb_row * ((s1->sps->width + ctb_size - 1) >> s1->sps->log2_ctb_size);
2354 int ctb_addr_ts = s1->pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2355 int thread = ctb_row % s1->threads_number;
2358 s = s1->sList[self_id];
2362 ret = init_get_bits8(&lc->gb, s->data + s->sh.offset[ctb_row - 1], s->sh.size[ctb_row - 1]);
2366 ff_init_cabac_decoder(&lc->cc, s->data + s->sh.offset[(ctb_row)-1], s->sh.size[ctb_row - 1]);
2369 while(more_data && ctb_addr_ts < s->sps->ctb_size) {
2370 int x_ctb = (ctb_addr_rs % s->sps->ctb_width) << s->sps->log2_ctb_size;
2371 int y_ctb = (ctb_addr_rs / s->sps->ctb_width) << s->sps->log2_ctb_size;
2373 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2375 ff_thread_await_progress2(s->avctx, ctb_row, thread, SHIFT_CTB_WPP);
2377 if (avpriv_atomic_int_get(&s1->wpp_err)){
2378 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2382 ff_hevc_cabac_init(s, ctb_addr_ts);
2383 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2384 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2386 if (more_data < 0) {
2387 s->tab_slice_address[ctb_addr_rs] = -1;
2393 ff_hevc_save_states(s, ctb_addr_ts);
2394 ff_thread_report_progress2(s->avctx, ctb_row, thread, 1);
2395 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2397 if (!more_data && (x_ctb+ctb_size) < s->sps->width && ctb_row != s->sh.num_entry_point_offsets) {
2398 avpriv_atomic_int_set(&s1->wpp_err, 1);
2399 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2403 if ((x_ctb+ctb_size) >= s->sps->width && (y_ctb+ctb_size) >= s->sps->height ) {
2404 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2405 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2408 ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2411 if(x_ctb >= s->sps->width) {
2415 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2420 static int hls_slice_data_wpp(HEVCContext *s, const uint8_t *nal, int length)
2422 HEVCLocalContext *lc = s->HEVClc;
2423 int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2424 int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2426 int startheader, cmpt = 0;
2432 return AVERROR(ENOMEM);
2437 ff_alloc_entries(s->avctx, s->sh.num_entry_point_offsets + 1);
2440 for (i = 1; i < s->threads_number; i++) {
2441 s->sList[i] = av_malloc(sizeof(HEVCContext));
2442 memcpy(s->sList[i], s, sizeof(HEVCContext));
2443 s->HEVClcList[i] = av_mallocz(sizeof(HEVCLocalContext));
2444 s->sList[i]->HEVClc = s->HEVClcList[i];
2448 offset = (lc->gb.index >> 3);
2450 for (j = 0, cmpt = 0, startheader = offset + s->sh.entry_point_offset[0]; j < s->skipped_bytes; j++) {
2451 if (s->skipped_bytes_pos[j] >= offset && s->skipped_bytes_pos[j] < startheader) {
2457 for (i = 1; i < s->sh.num_entry_point_offsets; i++) {
2458 offset += (s->sh.entry_point_offset[i - 1] - cmpt);
2459 for (j = 0, cmpt = 0, startheader = offset
2460 + s->sh.entry_point_offset[i]; j < s->skipped_bytes; j++) {
2461 if (s->skipped_bytes_pos[j] >= offset && s->skipped_bytes_pos[j] < startheader) {
2466 s->sh.size[i - 1] = s->sh.entry_point_offset[i] - cmpt;
2467 s->sh.offset[i - 1] = offset;
2470 if (s->sh.num_entry_point_offsets != 0) {
2471 offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt;
2472 s->sh.size[s->sh.num_entry_point_offsets - 1] = length - offset;
2473 s->sh.offset[s->sh.num_entry_point_offsets - 1] = offset;
2478 for (i = 1; i < s->threads_number; i++) {
2479 s->sList[i]->HEVClc->first_qp_group = 1;
2480 s->sList[i]->HEVClc->qp_y = s->sList[0]->HEVClc->qp_y;
2481 memcpy(s->sList[i], s, sizeof(HEVCContext));
2482 s->sList[i]->HEVClc = s->HEVClcList[i];
2485 avpriv_atomic_int_set(&s->wpp_err, 0);
2486 ff_reset_entries(s->avctx);
2488 for (i = 0; i <= s->sh.num_entry_point_offsets; i++) {
2493 if (s->pps->entropy_coding_sync_enabled_flag)
2494 s->avctx->execute2(s->avctx, (void *) hls_decode_entry_wpp, arg, ret, s->sh.num_entry_point_offsets + 1);
2496 for (i = 0; i <= s->sh.num_entry_point_offsets; i++)
2504 * @return AVERROR_INVALIDDATA if the packet is not a valid NAL unit,
2505 * 0 if the unit should be skipped, 1 otherwise
2507 static int hls_nal_unit(HEVCContext *s)
2509 GetBitContext *gb = &s->HEVClc->gb;
2512 if (get_bits1(gb) != 0)
2513 return AVERROR_INVALIDDATA;
2515 s->nal_unit_type = get_bits(gb, 6);
2517 nuh_layer_id = get_bits(gb, 6);
2518 s->temporal_id = get_bits(gb, 3) - 1;
2519 if (s->temporal_id < 0)
2520 return AVERROR_INVALIDDATA;
2522 av_log(s->avctx, AV_LOG_DEBUG,
2523 "nal_unit_type: %d, nuh_layer_id: %d, temporal_id: %d\n",
2524 s->nal_unit_type, nuh_layer_id, s->temporal_id);
2526 return nuh_layer_id == 0;
2529 static int set_side_data(HEVCContext *s)
2531 AVFrame *out = s->ref->frame;
2533 if (s->sei_frame_packing_present &&
2534 s->frame_packing_arrangement_type >= 3 &&
2535 s->frame_packing_arrangement_type <= 5 &&
2536 s->content_interpretation_type > 0 &&
2537 s->content_interpretation_type < 3) {
2538 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2540 return AVERROR(ENOMEM);
2542 switch (s->frame_packing_arrangement_type) {
2544 if (s->quincunx_subsampling)
2545 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2547 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2550 stereo->type = AV_STEREO3D_TOPBOTTOM;
2553 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2557 if (s->content_interpretation_type == 2)
2558 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2561 if (s->sei_display_orientation_present &&
2562 (s->sei_anticlockwise_rotation || s->sei_hflip || s->sei_vflip)) {
2563 double angle = s->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
2564 AVFrameSideData *rotation = av_frame_new_side_data(out,
2565 AV_FRAME_DATA_DISPLAYMATRIX,
2566 sizeof(int32_t) * 9);
2568 return AVERROR(ENOMEM);
2570 av_display_rotation_set((int32_t *)rotation->data, angle);
2571 av_display_matrix_flip((int32_t *)rotation->data,
2572 s->sei_hflip, s->sei_vflip);
2578 static int hevc_frame_start(HEVCContext *s)
2580 HEVCLocalContext *lc = s->HEVClc;
2581 int pic_size_in_ctb = ((s->sps->width >> s->sps->log2_min_cb_size) + 1) *
2582 ((s->sps->height >> s->sps->log2_min_cb_size) + 1);
2585 memset(s->horizontal_bs, 0, s->bs_width * s->bs_height);
2586 memset(s->vertical_bs, 0, s->bs_width * s->bs_height);
2587 memset(s->cbf_luma, 0, s->sps->min_tb_width * s->sps->min_tb_height);
2588 memset(s->is_pcm, 0, (s->sps->min_pu_width + 1) * (s->sps->min_pu_height + 1));
2589 memset(s->tab_slice_address, -1, pic_size_in_ctb * sizeof(*s->tab_slice_address));
2592 s->first_nal_type = s->nal_unit_type;
2594 if (s->pps->tiles_enabled_flag)
2595 lc->end_of_tiles_x = s->pps->column_width[0] << s->sps->log2_ctb_size;
2597 ret = ff_hevc_set_new_ref(s, &s->frame, s->poc);
2601 ret = ff_hevc_frame_rps(s);
2603 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2607 s->ref->frame->key_frame = IS_IRAP(s);
2609 ret = set_side_data(s);
2613 s->frame->pict_type = 3 - s->sh.slice_type;
2616 ff_hevc_bump_frame(s);
2618 av_frame_unref(s->output_frame);
2619 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2623 if (!s->avctx->hwaccel)
2624 ff_thread_finish_setup(s->avctx);
2630 ff_hevc_unref_frame(s, s->ref, ~0);
2635 static int decode_nal_unit(HEVCContext *s, const HEVCNAL *nal)
2637 HEVCLocalContext *lc = s->HEVClc;
2638 GetBitContext *gb = &lc->gb;
2639 int ctb_addr_ts, ret;
2641 ret = init_get_bits8(gb, nal->data, nal->size);
2645 ret = hls_nal_unit(s);
2647 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit %d, skipping.\n",
2653 switch (s->nal_unit_type) {
2655 ret = ff_hevc_decode_nal_vps(s);
2660 ret = ff_hevc_decode_nal_sps(s);
2665 ret = ff_hevc_decode_nal_pps(s);
2669 case NAL_SEI_PREFIX:
2670 case NAL_SEI_SUFFIX:
2671 ret = ff_hevc_decode_nal_sei(s);
2682 case NAL_BLA_W_RADL:
2684 case NAL_IDR_W_RADL:
2691 ret = hls_slice_header(s);
2695 if (s->max_ra == INT_MAX) {
2696 if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
2700 s->max_ra = INT_MIN;
2704 if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
2705 s->poc <= s->max_ra) {
2709 if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
2710 s->max_ra = INT_MIN;
2713 if (s->sh.first_slice_in_pic_flag) {
2714 ret = hevc_frame_start(s);
2717 } else if (!s->ref) {
2718 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2722 if (s->nal_unit_type != s->first_nal_type) {
2723 av_log(s->avctx, AV_LOG_ERROR,
2724 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2725 s->first_nal_type, s->nal_unit_type);
2726 return AVERROR_INVALIDDATA;
2729 if (!s->sh.dependent_slice_segment_flag &&
2730 s->sh.slice_type != I_SLICE) {
2731 ret = ff_hevc_slice_rpl(s);
2733 av_log(s->avctx, AV_LOG_WARNING,
2734 "Error constructing the reference lists for the current slice.\n");
2739 if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) {
2740 ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0);
2745 if (s->avctx->hwaccel) {
2746 ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size);
2750 if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
2751 ctb_addr_ts = hls_slice_data_wpp(s, nal->data, nal->size);
2753 ctb_addr_ts = hls_slice_data(s);
2754 if (ctb_addr_ts >= (s->sps->ctb_width * s->sps->ctb_height)) {
2758 if (ctb_addr_ts < 0) {
2766 s->seq_decode = (s->seq_decode + 1) & 0xff;
2767 s->max_ra = INT_MAX;
2773 av_log(s->avctx, AV_LOG_INFO,
2774 "Skipping NAL unit %d\n", s->nal_unit_type);
2779 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2784 /* FIXME: This is adapted from ff_h264_decode_nal, avoiding duplication
2785 * between these functions would be nice. */
2786 int ff_hevc_extract_rbsp(HEVCContext *s, const uint8_t *src, int length,
2792 s->skipped_bytes = 0;
2793 #define STARTCODE_TEST \
2794 if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \
2795 if (src[i + 2] != 3) { \
2796 /* startcode, so we must be past the end */ \
2801 #if HAVE_FAST_UNALIGNED
2802 #define FIND_FIRST_ZERO \
2803 if (i > 0 && !src[i]) \
2808 for (i = 0; i + 1 < length; i += 9) {
2809 if (!((~AV_RN64A(src + i) &
2810 (AV_RN64A(src + i) - 0x0100010001000101ULL)) &
2811 0x8000800080008080ULL))
2818 for (i = 0; i + 1 < length; i += 5) {
2819 if (!((~AV_RN32A(src + i) &
2820 (AV_RN32A(src + i) - 0x01000101U)) &
2827 #endif /* HAVE_FAST_64BIT */
2829 for (i = 0; i + 1 < length; i += 2) {
2832 if (i > 0 && src[i - 1] == 0)
2836 #endif /* HAVE_FAST_UNALIGNED */
2838 if (i >= length - 1) { // no escaped 0
2840 nal->raw_data = src;
2842 nal->raw_size = length;
2846 av_fast_malloc(&nal->rbsp_buffer, &nal->rbsp_buffer_size,
2847 length + FF_INPUT_BUFFER_PADDING_SIZE);
2848 if (!nal->rbsp_buffer)
2849 return AVERROR(ENOMEM);
2851 dst = nal->rbsp_buffer;
2853 memcpy(dst, src, i);
2855 while (si + 2 < length) {
2856 // remove escapes (very rare 1:2^22)
2857 if (src[si + 2] > 3) {
2858 dst[di++] = src[si++];
2859 dst[di++] = src[si++];
2860 } else if (src[si] == 0 && src[si + 1] == 0) {
2861 if (src[si + 2] == 3) { // escape
2867 if (s->skipped_bytes_pos_size < s->skipped_bytes) {
2868 s->skipped_bytes_pos_size *= 2;
2869 av_reallocp_array(&s->skipped_bytes_pos,
2870 s->skipped_bytes_pos_size,
2871 sizeof(*s->skipped_bytes_pos));
2872 if (!s->skipped_bytes_pos)
2873 return AVERROR(ENOMEM);
2875 if (s->skipped_bytes_pos)
2876 s->skipped_bytes_pos[s->skipped_bytes-1] = di - 1;
2878 } else // next start code
2882 dst[di++] = src[si++];
2885 dst[di++] = src[si++];
2888 memset(dst + di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2892 nal->raw_data = src;
2897 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2899 int i, consumed, ret = 0;
2902 s->last_eos = s->eos;
2905 /* split the input packet into NAL units, so we know the upper bound on the
2906 * number of slices in the frame */
2908 while (length >= 4) {
2910 int extract_length = 0;
2914 for (i = 0; i < s->nal_length_size; i++)
2915 extract_length = (extract_length << 8) | buf[i];
2916 buf += s->nal_length_size;
2917 length -= s->nal_length_size;
2919 if (extract_length > length) {
2920 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit size.\n");
2921 ret = AVERROR_INVALIDDATA;
2925 /* search start code */
2926 while (buf[0] != 0 || buf[1] != 0 || buf[2] != 1) {
2930 av_log(s->avctx, AV_LOG_ERROR, "No start code is found.\n");
2931 ret = AVERROR_INVALIDDATA;
2941 extract_length = length;
2943 if (s->nals_allocated < s->nb_nals + 1) {
2944 int new_size = s->nals_allocated + 1;
2945 void *tmp = av_realloc_array(s->nals, new_size, sizeof(*s->nals));
2946 ret = AVERROR(ENOMEM);
2951 memset(s->nals + s->nals_allocated, 0,
2952 (new_size - s->nals_allocated) * sizeof(*s->nals));
2954 tmp = av_realloc_array(s->skipped_bytes_nal, new_size, sizeof(*s->skipped_bytes_nal));
2957 s->skipped_bytes_nal = tmp;
2959 tmp = av_realloc_array(s->skipped_bytes_pos_size_nal, new_size, sizeof(*s->skipped_bytes_pos_size_nal));
2962 s->skipped_bytes_pos_size_nal = tmp;
2964 tmp = av_realloc_array(s->skipped_bytes_pos_nal, new_size, sizeof(*s->skipped_bytes_pos_nal));
2967 s->skipped_bytes_pos_nal = tmp;
2969 s->skipped_bytes_pos_size_nal[s->nals_allocated] = 1024; // initial buffer size
2970 s->skipped_bytes_pos_nal[s->nals_allocated] = av_malloc_array(s->skipped_bytes_pos_size_nal[s->nals_allocated], sizeof(*s->skipped_bytes_pos));
2971 if (!s->skipped_bytes_pos_nal[s->nals_allocated])
2973 s->nals_allocated = new_size;
2975 s->skipped_bytes_pos_size = s->skipped_bytes_pos_size_nal[s->nb_nals];
2976 s->skipped_bytes_pos = s->skipped_bytes_pos_nal[s->nb_nals];
2977 nal = &s->nals[s->nb_nals];
2979 consumed = ff_hevc_extract_rbsp(s, buf, extract_length, nal);
2981 s->skipped_bytes_nal[s->nb_nals] = s->skipped_bytes;
2982 s->skipped_bytes_pos_size_nal[s->nb_nals] = s->skipped_bytes_pos_size;
2983 s->skipped_bytes_pos_nal[s->nb_nals++] = s->skipped_bytes_pos;
2991 ret = init_get_bits8(&s->HEVClc->gb, nal->data, nal->size);
2996 if (s->nal_unit_type == NAL_EOB_NUT ||
2997 s->nal_unit_type == NAL_EOS_NUT)
3004 /* parse the NAL units */
3005 for (i = 0; i < s->nb_nals; i++) {
3006 s->skipped_bytes = s->skipped_bytes_nal[i];
3007 s->skipped_bytes_pos = s->skipped_bytes_pos_nal[i];
3009 ret = decode_nal_unit(s, &s->nals[i]);
3011 av_log(s->avctx, AV_LOG_WARNING,
3012 "Error parsing NAL unit #%d.\n", i);
3018 if (s->ref && s->threads_type == FF_THREAD_FRAME)
3019 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
3024 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
3027 for (i = 0; i < 16; i++)
3028 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
3031 static int verify_md5(HEVCContext *s, AVFrame *frame)
3033 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
3038 return AVERROR(EINVAL);
3040 pixel_shift = desc->comp[0].depth_minus1 > 7;
3042 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
3045 /* the checksums are LE, so we have to byteswap for >8bpp formats
3048 if (pixel_shift && !s->checksum_buf) {
3049 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
3050 FFMAX3(frame->linesize[0], frame->linesize[1],
3051 frame->linesize[2]));
3052 if (!s->checksum_buf)
3053 return AVERROR(ENOMEM);
3057 for (i = 0; frame->data[i]; i++) {
3058 int width = s->avctx->coded_width;
3059 int height = s->avctx->coded_height;
3060 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
3061 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
3064 av_md5_init(s->md5_ctx);
3065 for (j = 0; j < h; j++) {
3066 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
3069 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
3070 (const uint16_t *) src, w);
3071 src = s->checksum_buf;
3074 av_md5_update(s->md5_ctx, src, w << pixel_shift);
3076 av_md5_final(s->md5_ctx, md5);
3078 if (!memcmp(md5, s->md5[i], 16)) {
3079 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
3080 print_md5(s->avctx, AV_LOG_DEBUG, md5);
3081 av_log (s->avctx, AV_LOG_DEBUG, "; ");
3083 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
3084 print_md5(s->avctx, AV_LOG_ERROR, md5);
3085 av_log (s->avctx, AV_LOG_ERROR, " != ");
3086 print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
3087 av_log (s->avctx, AV_LOG_ERROR, "\n");
3088 return AVERROR_INVALIDDATA;
3092 av_log(s->avctx, AV_LOG_DEBUG, "\n");
3097 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
3101 HEVCContext *s = avctx->priv_data;
3104 ret = ff_hevc_output_frame(s, data, 1);
3113 ret = decode_nal_units(s, avpkt->data, avpkt->size);
3117 if (avctx->hwaccel) {
3118 if (s->ref && avctx->hwaccel->end_frame(avctx) < 0)
3119 av_log(avctx, AV_LOG_ERROR,
3120 "hardware accelerator failed to decode picture\n");
3122 /* verify the SEI checksum */
3123 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
3125 ret = verify_md5(s, s->ref->frame);
3126 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
3127 ff_hevc_unref_frame(s, s->ref, ~0);
3134 if (s->is_decoded) {
3135 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
3139 if (s->output_frame->buf[0]) {
3140 av_frame_move_ref(data, s->output_frame);
3147 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
3151 ret = ff_thread_ref_frame(&dst->tf, &src->tf);
3155 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
3156 if (!dst->tab_mvf_buf)
3158 dst->tab_mvf = src->tab_mvf;
3160 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
3161 if (!dst->rpl_tab_buf)
3163 dst->rpl_tab = src->rpl_tab;
3165 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
3169 dst->poc = src->poc;
3170 dst->ctb_count = src->ctb_count;
3171 dst->window = src->window;
3172 dst->flags = src->flags;
3173 dst->sequence = src->sequence;
3175 if (src->hwaccel_picture_private) {
3176 dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
3177 if (!dst->hwaccel_priv_buf)
3179 dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
3184 ff_hevc_unref_frame(s, dst, ~0);
3185 return AVERROR(ENOMEM);
3188 static av_cold int hevc_decode_free(AVCodecContext *avctx)
3190 HEVCContext *s = avctx->priv_data;
3195 av_freep(&s->md5_ctx);
3197 for(i=0; i < s->nals_allocated; i++) {
3198 av_freep(&s->skipped_bytes_pos_nal[i]);
3200 av_freep(&s->skipped_bytes_pos_size_nal);
3201 av_freep(&s->skipped_bytes_nal);
3202 av_freep(&s->skipped_bytes_pos_nal);
3204 av_freep(&s->cabac_state);
3206 for (i = 0; i < 3; i++) {
3207 av_freep(&s->sao_pixel_buffer_h[i]);
3208 av_freep(&s->sao_pixel_buffer_v[i]);
3210 av_frame_free(&s->output_frame);
3212 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3213 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3214 av_frame_free(&s->DPB[i].frame);
3217 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++)
3218 av_buffer_unref(&s->vps_list[i]);
3219 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++)
3220 av_buffer_unref(&s->sps_list[i]);
3221 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
3222 av_buffer_unref(&s->pps_list[i]);
3227 av_freep(&s->sh.entry_point_offset);
3228 av_freep(&s->sh.offset);
3229 av_freep(&s->sh.size);
3231 for (i = 1; i < s->threads_number; i++) {
3232 HEVCLocalContext *lc = s->HEVClcList[i];
3234 av_freep(&s->HEVClcList[i]);
3235 av_freep(&s->sList[i]);
3238 if (s->HEVClc == s->HEVClcList[0])
3240 av_freep(&s->HEVClcList[0]);
3242 for (i = 0; i < s->nals_allocated; i++)
3243 av_freep(&s->nals[i].rbsp_buffer);
3245 s->nals_allocated = 0;
3250 static av_cold int hevc_init_context(AVCodecContext *avctx)
3252 HEVCContext *s = avctx->priv_data;
3257 s->HEVClc = av_mallocz(sizeof(HEVCLocalContext));
3260 s->HEVClcList[0] = s->HEVClc;
3263 s->cabac_state = av_malloc(HEVC_CONTEXTS);
3264 if (!s->cabac_state)
3267 s->output_frame = av_frame_alloc();
3268 if (!s->output_frame)
3271 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3272 s->DPB[i].frame = av_frame_alloc();
3273 if (!s->DPB[i].frame)
3275 s->DPB[i].tf.f = s->DPB[i].frame;
3278 s->max_ra = INT_MAX;
3280 s->md5_ctx = av_md5_alloc();
3284 ff_bswapdsp_init(&s->bdsp);
3286 s->context_initialized = 1;
3292 hevc_decode_free(avctx);
3293 return AVERROR(ENOMEM);
3296 static int hevc_update_thread_context(AVCodecContext *dst,
3297 const AVCodecContext *src)
3299 HEVCContext *s = dst->priv_data;
3300 HEVCContext *s0 = src->priv_data;
3303 if (!s->context_initialized) {
3304 ret = hevc_init_context(dst);
3309 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3310 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3311 if (s0->DPB[i].frame->buf[0]) {
3312 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3318 if (s->sps != s0->sps)
3320 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++) {
3321 av_buffer_unref(&s->vps_list[i]);
3322 if (s0->vps_list[i]) {
3323 s->vps_list[i] = av_buffer_ref(s0->vps_list[i]);
3324 if (!s->vps_list[i])
3325 return AVERROR(ENOMEM);
3329 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++) {
3330 av_buffer_unref(&s->sps_list[i]);
3331 if (s0->sps_list[i]) {
3332 s->sps_list[i] = av_buffer_ref(s0->sps_list[i]);
3333 if (!s->sps_list[i])
3334 return AVERROR(ENOMEM);
3338 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++) {
3339 av_buffer_unref(&s->pps_list[i]);
3340 if (s0->pps_list[i]) {
3341 s->pps_list[i] = av_buffer_ref(s0->pps_list[i]);
3342 if (!s->pps_list[i])
3343 return AVERROR(ENOMEM);
3347 if (s->sps != s0->sps)
3348 if ((ret = set_sps(s, s0->sps, src->pix_fmt)) < 0)
3351 s->seq_decode = s0->seq_decode;
3352 s->seq_output = s0->seq_output;
3353 s->pocTid0 = s0->pocTid0;
3354 s->max_ra = s0->max_ra;
3357 s->is_nalff = s0->is_nalff;
3358 s->nal_length_size = s0->nal_length_size;
3360 s->threads_number = s0->threads_number;
3361 s->threads_type = s0->threads_type;
3364 s->seq_decode = (s->seq_decode + 1) & 0xff;
3365 s->max_ra = INT_MAX;
3371 static int hevc_decode_extradata(HEVCContext *s)
3373 AVCodecContext *avctx = s->avctx;
3377 bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
3379 if (avctx->extradata_size > 3 &&
3380 (avctx->extradata[0] || avctx->extradata[1] ||
3381 avctx->extradata[2] > 1)) {
3382 /* It seems the extradata is encoded as hvcC format.
3383 * Temporarily, we support configurationVersion==0 until 14496-15 3rd
3384 * is finalized. When finalized, configurationVersion will be 1 and we
3385 * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
3386 int i, j, num_arrays, nal_len_size;
3390 bytestream2_skip(&gb, 21);
3391 nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
3392 num_arrays = bytestream2_get_byte(&gb);
3394 /* nal units in the hvcC always have length coded with 2 bytes,
3395 * so put a fake nal_length_size = 2 while parsing them */
3396 s->nal_length_size = 2;
3398 /* Decode nal units from hvcC. */
3399 for (i = 0; i < num_arrays; i++) {
3400 int type = bytestream2_get_byte(&gb) & 0x3f;
3401 int cnt = bytestream2_get_be16(&gb);
3403 for (j = 0; j < cnt; j++) {
3404 // +2 for the nal size field
3405 int nalsize = bytestream2_peek_be16(&gb) + 2;
3406 if (bytestream2_get_bytes_left(&gb) < nalsize) {
3407 av_log(s->avctx, AV_LOG_ERROR,
3408 "Invalid NAL unit size in extradata.\n");
3409 return AVERROR_INVALIDDATA;
3412 ret = decode_nal_units(s, gb.buffer, nalsize);
3414 av_log(avctx, AV_LOG_ERROR,
3415 "Decoding nal unit %d %d from hvcC failed\n",
3419 bytestream2_skip(&gb, nalsize);
3423 /* Now store right nal length size, that will be used to parse
3425 s->nal_length_size = nal_len_size;
3428 ret = decode_nal_units(s, avctx->extradata, avctx->extradata_size);
3433 /* export stream parameters from the first SPS */
3434 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++) {
3435 if (s->sps_list[i]) {
3436 const HEVCSPS *sps = (const HEVCSPS*)s->sps_list[i]->data;
3437 export_stream_params(s->avctx, s, sps);
3445 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3447 HEVCContext *s = avctx->priv_data;
3450 ff_init_cabac_states();
3452 avctx->internal->allocate_progress = 1;
3454 ret = hevc_init_context(avctx);
3458 s->enable_parallel_tiles = 0;
3459 s->picture_struct = 0;
3461 if(avctx->active_thread_type & FF_THREAD_SLICE)
3462 s->threads_number = avctx->thread_count;
3464 s->threads_number = 1;
3466 if (avctx->extradata_size > 0 && avctx->extradata) {
3467 ret = hevc_decode_extradata(s);
3469 hevc_decode_free(avctx);
3474 if((avctx->active_thread_type & FF_THREAD_FRAME) && avctx->thread_count > 1)
3475 s->threads_type = FF_THREAD_FRAME;
3477 s->threads_type = FF_THREAD_SLICE;
3482 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3484 HEVCContext *s = avctx->priv_data;
3487 memset(s, 0, sizeof(*s));
3489 ret = hevc_init_context(avctx);
3496 static void hevc_decode_flush(AVCodecContext *avctx)
3498 HEVCContext *s = avctx->priv_data;
3499 ff_hevc_flush_dpb(s);
3500 s->max_ra = INT_MAX;
3503 #define OFFSET(x) offsetof(HEVCContext, x)
3504 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3506 static const AVProfile profiles[] = {
3507 { FF_PROFILE_HEVC_MAIN, "Main" },
3508 { FF_PROFILE_HEVC_MAIN_10, "Main 10" },
3509 { FF_PROFILE_HEVC_MAIN_STILL_PICTURE, "Main Still Picture" },
3510 { FF_PROFILE_HEVC_REXT, "Rext" },
3511 { FF_PROFILE_UNKNOWN },
3514 static const AVOption options[] = {
3515 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3516 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3517 { "strict-displaywin", "stricly apply default display window size", OFFSET(apply_defdispwin),
3518 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3522 static const AVClass hevc_decoder_class = {
3523 .class_name = "HEVC decoder",
3524 .item_name = av_default_item_name,
3526 .version = LIBAVUTIL_VERSION_INT,
3529 AVCodec ff_hevc_decoder = {
3531 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3532 .type = AVMEDIA_TYPE_VIDEO,
3533 .id = AV_CODEC_ID_HEVC,
3534 .priv_data_size = sizeof(HEVCContext),
3535 .priv_class = &hevc_decoder_class,
3536 .init = hevc_decode_init,
3537 .close = hevc_decode_free,
3538 .decode = hevc_decode_frame,
3539 .flush = hevc_decode_flush,
3540 .update_thread_context = hevc_update_thread_context,
3541 .init_thread_copy = hevc_init_thread_copy,
3542 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY |
3543 CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS,
3544 .profiles = NULL_IF_CONFIG_SMALL(profiles),