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)
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;
348 if (pix_fmt == AV_PIX_FMT_NONE) {
349 *fmt++ = sps->pix_fmt;
350 *fmt = AV_PIX_FMT_NONE;
352 ret = ff_thread_get_format(s->avctx, pix_fmts);
355 s->avctx->pix_fmt = ret;
358 s->avctx->pix_fmt = pix_fmt;
361 ff_hevc_pred_init(&s->hpc, sps->bit_depth);
362 ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
363 ff_videodsp_init (&s->vdsp, sps->bit_depth);
365 for (i = 0; i < 3; i++) {
366 av_freep(&s->sao_pixel_buffer_h[i]);
367 av_freep(&s->sao_pixel_buffer_v[i]);
370 if (sps->sao_enabled && !s->avctx->hwaccel) {
371 int c_count = (sps->chroma_format_idc != 0) ? 3 : 1;
374 for(c_idx = 0; c_idx < c_count; c_idx++) {
375 int w = sps->width >> sps->hshift[c_idx];
376 int h = sps->height >> sps->vshift[c_idx];
377 s->sao_pixel_buffer_h[c_idx] =
378 av_malloc((w * 2 * sps->ctb_height) <<
380 s->sao_pixel_buffer_v[c_idx] =
381 av_malloc((h * 2 * sps->ctb_width) <<
387 s->vps = (HEVCVPS*) s->vps_list[s->sps->vps_id]->data;
397 static int hls_slice_header(HEVCContext *s)
399 GetBitContext *gb = &s->HEVClc->gb;
400 SliceHeader *sh = &s->sh;
404 sh->first_slice_in_pic_flag = get_bits1(gb);
405 if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
406 s->seq_decode = (s->seq_decode + 1) & 0xff;
409 ff_hevc_clear_refs(s);
411 sh->no_output_of_prior_pics_flag = 0;
413 sh->no_output_of_prior_pics_flag = get_bits1(gb);
415 sh->pps_id = get_ue_golomb_long(gb);
416 if (sh->pps_id >= MAX_PPS_COUNT || !s->pps_list[sh->pps_id]) {
417 av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
418 return AVERROR_INVALIDDATA;
420 if (!sh->first_slice_in_pic_flag &&
421 s->pps != (HEVCPPS*)s->pps_list[sh->pps_id]->data) {
422 av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
423 return AVERROR_INVALIDDATA;
425 s->pps = (HEVCPPS*)s->pps_list[sh->pps_id]->data;
426 if (s->nal_unit_type == NAL_CRA_NUT && s->last_eos == 1)
427 sh->no_output_of_prior_pics_flag = 1;
429 if (s->sps != (HEVCSPS*)s->sps_list[s->pps->sps_id]->data) {
430 const HEVCSPS* last_sps = s->sps;
431 s->sps = (HEVCSPS*)s->sps_list[s->pps->sps_id]->data;
432 if (last_sps && IS_IRAP(s) && s->nal_unit_type != NAL_CRA_NUT) {
433 if (s->sps->width != last_sps->width || s->sps->height != last_sps->height ||
434 s->sps->temporal_layer[s->sps->max_sub_layers - 1].max_dec_pic_buffering !=
435 last_sps->temporal_layer[last_sps->max_sub_layers - 1].max_dec_pic_buffering)
436 sh->no_output_of_prior_pics_flag = 0;
438 ff_hevc_clear_refs(s);
439 ret = set_sps(s, s->sps, AV_PIX_FMT_NONE);
443 s->seq_decode = (s->seq_decode + 1) & 0xff;
447 sh->dependent_slice_segment_flag = 0;
448 if (!sh->first_slice_in_pic_flag) {
449 int slice_address_length;
451 if (s->pps->dependent_slice_segments_enabled_flag)
452 sh->dependent_slice_segment_flag = get_bits1(gb);
454 slice_address_length = av_ceil_log2(s->sps->ctb_width *
456 sh->slice_segment_addr = get_bits(gb, slice_address_length);
457 if (sh->slice_segment_addr >= s->sps->ctb_width * s->sps->ctb_height) {
458 av_log(s->avctx, AV_LOG_ERROR,
459 "Invalid slice segment address: %u.\n",
460 sh->slice_segment_addr);
461 return AVERROR_INVALIDDATA;
464 if (!sh->dependent_slice_segment_flag) {
465 sh->slice_addr = sh->slice_segment_addr;
469 sh->slice_segment_addr = sh->slice_addr = 0;
471 s->slice_initialized = 0;
474 if (!sh->dependent_slice_segment_flag) {
475 s->slice_initialized = 0;
477 for (i = 0; i < s->pps->num_extra_slice_header_bits; i++)
478 skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
480 sh->slice_type = get_ue_golomb_long(gb);
481 if (!(sh->slice_type == I_SLICE ||
482 sh->slice_type == P_SLICE ||
483 sh->slice_type == B_SLICE)) {
484 av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
486 return AVERROR_INVALIDDATA;
488 if (IS_IRAP(s) && sh->slice_type != I_SLICE) {
489 av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
490 return AVERROR_INVALIDDATA;
493 // when flag is not present, picture is inferred to be output
494 sh->pic_output_flag = 1;
495 if (s->pps->output_flag_present_flag)
496 sh->pic_output_flag = get_bits1(gb);
498 if (s->sps->separate_colour_plane_flag)
499 sh->colour_plane_id = get_bits(gb, 2);
504 sh->pic_order_cnt_lsb = get_bits(gb, s->sps->log2_max_poc_lsb);
505 poc = ff_hevc_compute_poc(s, sh->pic_order_cnt_lsb);
506 if (!sh->first_slice_in_pic_flag && poc != s->poc) {
507 av_log(s->avctx, AV_LOG_WARNING,
508 "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
509 if (s->avctx->err_recognition & AV_EF_EXPLODE)
510 return AVERROR_INVALIDDATA;
515 sh->short_term_ref_pic_set_sps_flag = get_bits1(gb);
516 if (!sh->short_term_ref_pic_set_sps_flag) {
517 int pos = get_bits_left(gb);
518 ret = ff_hevc_decode_short_term_rps(s, &sh->slice_rps, s->sps, 1);
522 sh->short_term_ref_pic_set_size = pos - get_bits_left(gb);
523 sh->short_term_rps = &sh->slice_rps;
525 int numbits, rps_idx;
527 if (!s->sps->nb_st_rps) {
528 av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
529 return AVERROR_INVALIDDATA;
532 numbits = av_ceil_log2(s->sps->nb_st_rps);
533 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
534 sh->short_term_rps = &s->sps->st_rps[rps_idx];
537 ret = decode_lt_rps(s, &sh->long_term_rps, gb);
539 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
540 if (s->avctx->err_recognition & AV_EF_EXPLODE)
541 return AVERROR_INVALIDDATA;
544 if (s->sps->sps_temporal_mvp_enabled_flag)
545 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
547 sh->slice_temporal_mvp_enabled_flag = 0;
549 s->sh.short_term_rps = NULL;
554 if (s->temporal_id == 0 &&
555 s->nal_unit_type != NAL_TRAIL_N &&
556 s->nal_unit_type != NAL_TSA_N &&
557 s->nal_unit_type != NAL_STSA_N &&
558 s->nal_unit_type != NAL_RADL_N &&
559 s->nal_unit_type != NAL_RADL_R &&
560 s->nal_unit_type != NAL_RASL_N &&
561 s->nal_unit_type != NAL_RASL_R)
564 if (s->sps->sao_enabled) {
565 sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
566 if (s->sps->chroma_format_idc) {
567 sh->slice_sample_adaptive_offset_flag[1] =
568 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
571 sh->slice_sample_adaptive_offset_flag[0] = 0;
572 sh->slice_sample_adaptive_offset_flag[1] = 0;
573 sh->slice_sample_adaptive_offset_flag[2] = 0;
576 sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
577 if (sh->slice_type == P_SLICE || sh->slice_type == B_SLICE) {
580 sh->nb_refs[L0] = s->pps->num_ref_idx_l0_default_active;
581 if (sh->slice_type == B_SLICE)
582 sh->nb_refs[L1] = s->pps->num_ref_idx_l1_default_active;
584 if (get_bits1(gb)) { // num_ref_idx_active_override_flag
585 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
586 if (sh->slice_type == B_SLICE)
587 sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
589 if (sh->nb_refs[L0] > MAX_REFS || sh->nb_refs[L1] > MAX_REFS) {
590 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
591 sh->nb_refs[L0], sh->nb_refs[L1]);
592 return AVERROR_INVALIDDATA;
595 sh->rpl_modification_flag[0] = 0;
596 sh->rpl_modification_flag[1] = 0;
597 nb_refs = ff_hevc_frame_nb_refs(s);
599 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
600 return AVERROR_INVALIDDATA;
603 if (s->pps->lists_modification_present_flag && nb_refs > 1) {
604 sh->rpl_modification_flag[0] = get_bits1(gb);
605 if (sh->rpl_modification_flag[0]) {
606 for (i = 0; i < sh->nb_refs[L0]; i++)
607 sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
610 if (sh->slice_type == B_SLICE) {
611 sh->rpl_modification_flag[1] = get_bits1(gb);
612 if (sh->rpl_modification_flag[1] == 1)
613 for (i = 0; i < sh->nb_refs[L1]; i++)
614 sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
618 if (sh->slice_type == B_SLICE)
619 sh->mvd_l1_zero_flag = get_bits1(gb);
621 if (s->pps->cabac_init_present_flag)
622 sh->cabac_init_flag = get_bits1(gb);
624 sh->cabac_init_flag = 0;
626 sh->collocated_ref_idx = 0;
627 if (sh->slice_temporal_mvp_enabled_flag) {
628 sh->collocated_list = L0;
629 if (sh->slice_type == B_SLICE)
630 sh->collocated_list = !get_bits1(gb);
632 if (sh->nb_refs[sh->collocated_list] > 1) {
633 sh->collocated_ref_idx = get_ue_golomb_long(gb);
634 if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
635 av_log(s->avctx, AV_LOG_ERROR,
636 "Invalid collocated_ref_idx: %d.\n",
637 sh->collocated_ref_idx);
638 return AVERROR_INVALIDDATA;
643 if ((s->pps->weighted_pred_flag && sh->slice_type == P_SLICE) ||
644 (s->pps->weighted_bipred_flag && sh->slice_type == B_SLICE)) {
645 pred_weight_table(s, gb);
648 sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
649 if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
650 av_log(s->avctx, AV_LOG_ERROR,
651 "Invalid number of merging MVP candidates: %d.\n",
652 sh->max_num_merge_cand);
653 return AVERROR_INVALIDDATA;
657 sh->slice_qp_delta = get_se_golomb(gb);
659 if (s->pps->pic_slice_level_chroma_qp_offsets_present_flag) {
660 sh->slice_cb_qp_offset = get_se_golomb(gb);
661 sh->slice_cr_qp_offset = get_se_golomb(gb);
663 sh->slice_cb_qp_offset = 0;
664 sh->slice_cr_qp_offset = 0;
667 if (s->pps->chroma_qp_offset_list_enabled_flag)
668 sh->cu_chroma_qp_offset_enabled_flag = get_bits1(gb);
670 sh->cu_chroma_qp_offset_enabled_flag = 0;
672 if (s->pps->deblocking_filter_control_present_flag) {
673 int deblocking_filter_override_flag = 0;
675 if (s->pps->deblocking_filter_override_enabled_flag)
676 deblocking_filter_override_flag = get_bits1(gb);
678 if (deblocking_filter_override_flag) {
679 sh->disable_deblocking_filter_flag = get_bits1(gb);
680 if (!sh->disable_deblocking_filter_flag) {
681 sh->beta_offset = get_se_golomb(gb) * 2;
682 sh->tc_offset = get_se_golomb(gb) * 2;
685 sh->disable_deblocking_filter_flag = s->pps->disable_dbf;
686 sh->beta_offset = s->pps->beta_offset;
687 sh->tc_offset = s->pps->tc_offset;
690 sh->disable_deblocking_filter_flag = 0;
695 if (s->pps->seq_loop_filter_across_slices_enabled_flag &&
696 (sh->slice_sample_adaptive_offset_flag[0] ||
697 sh->slice_sample_adaptive_offset_flag[1] ||
698 !sh->disable_deblocking_filter_flag)) {
699 sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
701 sh->slice_loop_filter_across_slices_enabled_flag = s->pps->seq_loop_filter_across_slices_enabled_flag;
703 } else if (!s->slice_initialized) {
704 av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
705 return AVERROR_INVALIDDATA;
708 sh->num_entry_point_offsets = 0;
709 if (s->pps->tiles_enabled_flag || s->pps->entropy_coding_sync_enabled_flag) {
710 sh->num_entry_point_offsets = get_ue_golomb_long(gb);
711 if (sh->num_entry_point_offsets > 0) {
712 int offset_len = get_ue_golomb_long(gb) + 1;
713 int segments = offset_len >> 4;
714 int rest = (offset_len & 15);
715 av_freep(&sh->entry_point_offset);
716 av_freep(&sh->offset);
718 sh->entry_point_offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
719 sh->offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
720 sh->size = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
721 if (!sh->entry_point_offset || !sh->offset || !sh->size) {
722 sh->num_entry_point_offsets = 0;
723 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate memory\n");
724 return AVERROR(ENOMEM);
726 for (i = 0; i < sh->num_entry_point_offsets; i++) {
728 for (j = 0; j < segments; j++) {
730 val += get_bits(gb, 16);
734 val += get_bits(gb, rest);
736 sh->entry_point_offset[i] = val + 1; // +1; // +1 to get the size
738 if (s->threads_number > 1 && (s->pps->num_tile_rows > 1 || s->pps->num_tile_columns > 1)) {
739 s->enable_parallel_tiles = 0; // TODO: you can enable tiles in parallel here
740 s->threads_number = 1;
742 s->enable_parallel_tiles = 0;
744 s->enable_parallel_tiles = 0;
747 if (s->pps->slice_header_extension_present_flag) {
748 unsigned int length = get_ue_golomb_long(gb);
749 if (length*8LL > get_bits_left(gb)) {
750 av_log(s->avctx, AV_LOG_ERROR, "too many slice_header_extension_data_bytes\n");
751 return AVERROR_INVALIDDATA;
753 for (i = 0; i < length; i++)
754 skip_bits(gb, 8); // slice_header_extension_data_byte
757 // Inferred parameters
758 sh->slice_qp = 26U + s->pps->pic_init_qp_minus26 + sh->slice_qp_delta;
759 if (sh->slice_qp > 51 ||
760 sh->slice_qp < -s->sps->qp_bd_offset) {
761 av_log(s->avctx, AV_LOG_ERROR,
762 "The slice_qp %d is outside the valid range "
765 -s->sps->qp_bd_offset);
766 return AVERROR_INVALIDDATA;
769 sh->slice_ctb_addr_rs = sh->slice_segment_addr;
771 if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) {
772 av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
773 return AVERROR_INVALIDDATA;
776 if (get_bits_left(gb) < 0) {
777 av_log(s->avctx, AV_LOG_ERROR,
778 "Overread slice header by %d bits\n", -get_bits_left(gb));
779 return AVERROR_INVALIDDATA;
782 s->HEVClc->first_qp_group = !s->sh.dependent_slice_segment_flag;
784 if (!s->pps->cu_qp_delta_enabled_flag)
785 s->HEVClc->qp_y = s->sh.slice_qp;
787 s->slice_initialized = 1;
788 s->HEVClc->tu.cu_qp_offset_cb = 0;
789 s->HEVClc->tu.cu_qp_offset_cr = 0;
794 #define CTB(tab, x, y) ((tab)[(y) * s->sps->ctb_width + (x)])
796 #define SET_SAO(elem, value) \
798 if (!sao_merge_up_flag && !sao_merge_left_flag) \
800 else if (sao_merge_left_flag) \
801 sao->elem = CTB(s->sao, rx-1, ry).elem; \
802 else if (sao_merge_up_flag) \
803 sao->elem = CTB(s->sao, rx, ry-1).elem; \
808 static void hls_sao_param(HEVCContext *s, int rx, int ry)
810 HEVCLocalContext *lc = s->HEVClc;
811 int sao_merge_left_flag = 0;
812 int sao_merge_up_flag = 0;
813 SAOParams *sao = &CTB(s->sao, rx, ry);
816 if (s->sh.slice_sample_adaptive_offset_flag[0] ||
817 s->sh.slice_sample_adaptive_offset_flag[1]) {
819 if (lc->ctb_left_flag)
820 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
822 if (ry > 0 && !sao_merge_left_flag) {
824 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
828 for (c_idx = 0; c_idx < (s->sps->chroma_format_idc ? 3 : 1); c_idx++) {
829 int log2_sao_offset_scale = c_idx == 0 ? s->pps->log2_sao_offset_scale_luma :
830 s->pps->log2_sao_offset_scale_chroma;
832 if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
833 sao->type_idx[c_idx] = SAO_NOT_APPLIED;
838 sao->type_idx[2] = sao->type_idx[1];
839 sao->eo_class[2] = sao->eo_class[1];
841 SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
844 if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
847 for (i = 0; i < 4; i++)
848 SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
850 if (sao->type_idx[c_idx] == SAO_BAND) {
851 for (i = 0; i < 4; i++) {
852 if (sao->offset_abs[c_idx][i]) {
853 SET_SAO(offset_sign[c_idx][i],
854 ff_hevc_sao_offset_sign_decode(s));
856 sao->offset_sign[c_idx][i] = 0;
859 SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
860 } else if (c_idx != 2) {
861 SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
864 // Inferred parameters
865 sao->offset_val[c_idx][0] = 0;
866 for (i = 0; i < 4; i++) {
867 sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i];
868 if (sao->type_idx[c_idx] == SAO_EDGE) {
870 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
871 } else if (sao->offset_sign[c_idx][i]) {
872 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
874 sao->offset_val[c_idx][i + 1] *= 1 << log2_sao_offset_scale;
882 static int hls_cross_component_pred(HEVCContext *s, int idx) {
883 HEVCLocalContext *lc = s->HEVClc;
884 int log2_res_scale_abs_plus1 = ff_hevc_log2_res_scale_abs(s, idx);
886 if (log2_res_scale_abs_plus1 != 0) {
887 int res_scale_sign_flag = ff_hevc_res_scale_sign_flag(s, idx);
888 lc->tu.res_scale_val = (1 << (log2_res_scale_abs_plus1 - 1)) *
889 (1 - 2 * res_scale_sign_flag);
891 lc->tu.res_scale_val = 0;
898 static int hls_transform_unit(HEVCContext *s, int x0, int y0,
899 int xBase, int yBase, int cb_xBase, int cb_yBase,
900 int log2_cb_size, int log2_trafo_size,
901 int blk_idx, int cbf_luma, int *cbf_cb, int *cbf_cr)
903 HEVCLocalContext *lc = s->HEVClc;
904 const int log2_trafo_size_c = log2_trafo_size - s->sps->hshift[1];
907 if (lc->cu.pred_mode == MODE_INTRA) {
908 int trafo_size = 1 << log2_trafo_size;
909 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
911 s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
914 if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
915 (s->sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
916 int scan_idx = SCAN_DIAG;
917 int scan_idx_c = SCAN_DIAG;
918 int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
919 (s->sps->chroma_format_idc == 2 &&
920 (cbf_cb[1] || cbf_cr[1]));
922 if (s->pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
923 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
924 if (lc->tu.cu_qp_delta != 0)
925 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
926 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
927 lc->tu.is_cu_qp_delta_coded = 1;
929 if (lc->tu.cu_qp_delta < -(26 + s->sps->qp_bd_offset / 2) ||
930 lc->tu.cu_qp_delta > (25 + s->sps->qp_bd_offset / 2)) {
931 av_log(s->avctx, AV_LOG_ERROR,
932 "The cu_qp_delta %d is outside the valid range "
935 -(26 + s->sps->qp_bd_offset / 2),
936 (25 + s->sps->qp_bd_offset / 2));
937 return AVERROR_INVALIDDATA;
940 ff_hevc_set_qPy(s, cb_xBase, cb_yBase, log2_cb_size);
943 if (s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
944 !lc->cu.cu_transquant_bypass_flag && !lc->tu.is_cu_chroma_qp_offset_coded) {
945 int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(s);
946 if (cu_chroma_qp_offset_flag) {
947 int cu_chroma_qp_offset_idx = 0;
948 if (s->pps->chroma_qp_offset_list_len_minus1 > 0) {
949 cu_chroma_qp_offset_idx = ff_hevc_cu_chroma_qp_offset_idx(s);
950 av_log(s->avctx, AV_LOG_ERROR,
951 "cu_chroma_qp_offset_idx not yet tested.\n");
953 lc->tu.cu_qp_offset_cb = s->pps->cb_qp_offset_list[cu_chroma_qp_offset_idx];
954 lc->tu.cu_qp_offset_cr = s->pps->cr_qp_offset_list[cu_chroma_qp_offset_idx];
956 lc->tu.cu_qp_offset_cb = 0;
957 lc->tu.cu_qp_offset_cr = 0;
959 lc->tu.is_cu_chroma_qp_offset_coded = 1;
962 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
963 if (lc->tu.intra_pred_mode >= 6 &&
964 lc->tu.intra_pred_mode <= 14) {
965 scan_idx = SCAN_VERT;
966 } else if (lc->tu.intra_pred_mode >= 22 &&
967 lc->tu.intra_pred_mode <= 30) {
968 scan_idx = SCAN_HORIZ;
971 if (lc->tu.intra_pred_mode_c >= 6 &&
972 lc->tu.intra_pred_mode_c <= 14) {
973 scan_idx_c = SCAN_VERT;
974 } else if (lc->tu.intra_pred_mode_c >= 22 &&
975 lc->tu.intra_pred_mode_c <= 30) {
976 scan_idx_c = SCAN_HORIZ;
983 ff_hevc_hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
984 if (s->sps->chroma_format_idc && (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3)) {
985 int trafo_size_h = 1 << (log2_trafo_size_c + s->sps->hshift[1]);
986 int trafo_size_v = 1 << (log2_trafo_size_c + s->sps->vshift[1]);
987 lc->tu.cross_pf = (s->pps->cross_component_prediction_enabled_flag && cbf_luma &&
988 (lc->cu.pred_mode == MODE_INTER ||
989 (lc->tu.chroma_mode_c == 4)));
991 if (lc->tu.cross_pf) {
992 hls_cross_component_pred(s, 0);
994 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
995 if (lc->cu.pred_mode == MODE_INTRA) {
996 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
997 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 1);
1000 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1001 log2_trafo_size_c, scan_idx_c, 1);
1003 if (lc->tu.cross_pf) {
1004 ptrdiff_t stride = s->frame->linesize[1];
1005 int hshift = s->sps->hshift[1];
1006 int vshift = s->sps->vshift[1];
1007 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1008 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1009 int size = 1 << log2_trafo_size_c;
1011 uint8_t *dst = &s->frame->data[1][(y0 >> vshift) * stride +
1012 ((x0 >> hshift) << s->sps->pixel_shift)];
1013 for (i = 0; i < (size * size); i++) {
1014 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1016 s->hevcdsp.transform_add[log2_trafo_size_c-2](dst, coeffs, stride);
1020 if (lc->tu.cross_pf) {
1021 hls_cross_component_pred(s, 1);
1023 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1024 if (lc->cu.pred_mode == MODE_INTRA) {
1025 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1026 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 2);
1029 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1030 log2_trafo_size_c, scan_idx_c, 2);
1032 if (lc->tu.cross_pf) {
1033 ptrdiff_t stride = s->frame->linesize[2];
1034 int hshift = s->sps->hshift[2];
1035 int vshift = s->sps->vshift[2];
1036 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1037 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1038 int size = 1 << log2_trafo_size_c;
1040 uint8_t *dst = &s->frame->data[2][(y0 >> vshift) * stride +
1041 ((x0 >> hshift) << s->sps->pixel_shift)];
1042 for (i = 0; i < (size * size); i++) {
1043 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1045 s->hevcdsp.transform_add[log2_trafo_size_c-2](dst, coeffs, stride);
1048 } else if (s->sps->chroma_format_idc && blk_idx == 3) {
1049 int trafo_size_h = 1 << (log2_trafo_size + 1);
1050 int trafo_size_v = 1 << (log2_trafo_size + s->sps->vshift[1]);
1051 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1052 if (lc->cu.pred_mode == MODE_INTRA) {
1053 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1054 trafo_size_h, trafo_size_v);
1055 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 1);
1058 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1059 log2_trafo_size, scan_idx_c, 1);
1061 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1062 if (lc->cu.pred_mode == MODE_INTRA) {
1063 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1064 trafo_size_h, trafo_size_v);
1065 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 2);
1068 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1069 log2_trafo_size, scan_idx_c, 2);
1072 } else if (s->sps->chroma_format_idc && lc->cu.pred_mode == MODE_INTRA) {
1073 if (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3) {
1074 int trafo_size_h = 1 << (log2_trafo_size_c + s->sps->hshift[1]);
1075 int trafo_size_v = 1 << (log2_trafo_size_c + s->sps->vshift[1]);
1076 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size_h, trafo_size_v);
1077 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 1);
1078 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 2);
1079 if (s->sps->chroma_format_idc == 2) {
1080 ff_hevc_set_neighbour_available(s, x0, y0 + (1 << log2_trafo_size_c),
1081 trafo_size_h, trafo_size_v);
1082 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 1);
1083 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 2);
1085 } else if (blk_idx == 3) {
1086 int trafo_size_h = 1 << (log2_trafo_size + 1);
1087 int trafo_size_v = 1 << (log2_trafo_size + s->sps->vshift[1]);
1088 ff_hevc_set_neighbour_available(s, xBase, yBase,
1089 trafo_size_h, trafo_size_v);
1090 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1091 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1092 if (s->sps->chroma_format_idc == 2) {
1093 ff_hevc_set_neighbour_available(s, xBase, yBase + (1 << (log2_trafo_size)),
1094 trafo_size_h, trafo_size_v);
1095 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 1);
1096 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 2);
1104 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1106 int cb_size = 1 << log2_cb_size;
1107 int log2_min_pu_size = s->sps->log2_min_pu_size;
1109 int min_pu_width = s->sps->min_pu_width;
1110 int x_end = FFMIN(x0 + cb_size, s->sps->width);
1111 int y_end = FFMIN(y0 + cb_size, s->sps->height);
1114 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1115 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1116 s->is_pcm[i + j * min_pu_width] = 2;
1119 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1120 int xBase, int yBase, int cb_xBase, int cb_yBase,
1121 int log2_cb_size, int log2_trafo_size,
1122 int trafo_depth, int blk_idx,
1123 const int *base_cbf_cb, const int *base_cbf_cr)
1125 HEVCLocalContext *lc = s->HEVClc;
1126 uint8_t split_transform_flag;
1131 cbf_cb[0] = base_cbf_cb[0];
1132 cbf_cb[1] = base_cbf_cb[1];
1133 cbf_cr[0] = base_cbf_cr[0];
1134 cbf_cr[1] = base_cbf_cr[1];
1136 if (lc->cu.intra_split_flag) {
1137 if (trafo_depth == 1) {
1138 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1139 if (s->sps->chroma_format_idc == 3) {
1140 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[blk_idx];
1141 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[blk_idx];
1143 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1144 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1148 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[0];
1149 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1150 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1153 if (log2_trafo_size <= s->sps->log2_max_trafo_size &&
1154 log2_trafo_size > s->sps->log2_min_tb_size &&
1155 trafo_depth < lc->cu.max_trafo_depth &&
1156 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1157 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1159 int inter_split = s->sps->max_transform_hierarchy_depth_inter == 0 &&
1160 lc->cu.pred_mode == MODE_INTER &&
1161 lc->cu.part_mode != PART_2Nx2N &&
1164 split_transform_flag = log2_trafo_size > s->sps->log2_max_trafo_size ||
1165 (lc->cu.intra_split_flag && trafo_depth == 0) ||
1169 if (s->sps->chroma_format_idc && (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3)) {
1170 if (trafo_depth == 0 || cbf_cb[0]) {
1171 cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1172 if (s->sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1173 cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1177 if (trafo_depth == 0 || cbf_cr[0]) {
1178 cbf_cr[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_cr[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1185 if (split_transform_flag) {
1186 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1187 const int x1 = x0 + trafo_size_split;
1188 const int y1 = y0 + trafo_size_split;
1190 #define SUBDIVIDE(x, y, idx) \
1192 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1193 log2_trafo_size - 1, trafo_depth + 1, idx, \
1199 SUBDIVIDE(x0, y0, 0);
1200 SUBDIVIDE(x1, y0, 1);
1201 SUBDIVIDE(x0, y1, 2);
1202 SUBDIVIDE(x1, y1, 3);
1206 int min_tu_size = 1 << s->sps->log2_min_tb_size;
1207 int log2_min_tu_size = s->sps->log2_min_tb_size;
1208 int min_tu_width = s->sps->min_tb_width;
1211 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1212 cbf_cb[0] || cbf_cr[0] ||
1213 (s->sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1214 cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1217 ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1218 log2_cb_size, log2_trafo_size,
1219 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1222 // TODO: store cbf_luma somewhere else
1225 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1226 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1227 int x_tu = (x0 + j) >> log2_min_tu_size;
1228 int y_tu = (y0 + i) >> log2_min_tu_size;
1229 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1232 if (!s->sh.disable_deblocking_filter_flag) {
1233 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1234 if (s->pps->transquant_bypass_enable_flag &&
1235 lc->cu.cu_transquant_bypass_flag)
1236 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1242 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1244 HEVCLocalContext *lc = s->HEVClc;
1246 int cb_size = 1 << log2_cb_size;
1247 int stride0 = s->frame->linesize[0];
1248 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->sps->pixel_shift)];
1249 int stride1 = s->frame->linesize[1];
1250 uint8_t *dst1 = &s->frame->data[1][(y0 >> s->sps->vshift[1]) * stride1 + ((x0 >> s->sps->hshift[1]) << s->sps->pixel_shift)];
1251 int stride2 = s->frame->linesize[2];
1252 uint8_t *dst2 = &s->frame->data[2][(y0 >> s->sps->vshift[2]) * stride2 + ((x0 >> s->sps->hshift[2]) << s->sps->pixel_shift)];
1254 int length = cb_size * cb_size * s->sps->pcm.bit_depth +
1255 (((cb_size >> s->sps->hshift[1]) * (cb_size >> s->sps->vshift[1])) +
1256 ((cb_size >> s->sps->hshift[2]) * (cb_size >> s->sps->vshift[2]))) *
1257 s->sps->pcm.bit_depth_chroma;
1258 const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1261 if (!s->sh.disable_deblocking_filter_flag)
1262 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1264 ret = init_get_bits(&gb, pcm, length);
1268 s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size, &gb, s->sps->pcm.bit_depth);
1269 if (s->sps->chroma_format_idc) {
1270 s->hevcdsp.put_pcm(dst1, stride1,
1271 cb_size >> s->sps->hshift[1],
1272 cb_size >> s->sps->vshift[1],
1273 &gb, s->sps->pcm.bit_depth_chroma);
1274 s->hevcdsp.put_pcm(dst2, stride2,
1275 cb_size >> s->sps->hshift[2],
1276 cb_size >> s->sps->vshift[2],
1277 &gb, s->sps->pcm.bit_depth_chroma);
1284 * 8.5.3.2.2.1 Luma sample unidirectional interpolation process
1286 * @param s HEVC decoding context
1287 * @param dst target buffer for block data at block position
1288 * @param dststride stride of the dst buffer
1289 * @param ref reference picture buffer at origin (0, 0)
1290 * @param mv motion vector (relative to block position) to get pixel data from
1291 * @param x_off horizontal position of block from origin (0, 0)
1292 * @param y_off vertical position of block from origin (0, 0)
1293 * @param block_w width of block
1294 * @param block_h height of block
1295 * @param luma_weight weighting factor applied to the luma prediction
1296 * @param luma_offset additive offset applied to the luma prediction value
1299 static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1300 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1301 int block_w, int block_h, int luma_weight, int luma_offset)
1303 HEVCLocalContext *lc = s->HEVClc;
1304 uint8_t *src = ref->data[0];
1305 ptrdiff_t srcstride = ref->linesize[0];
1306 int pic_width = s->sps->width;
1307 int pic_height = s->sps->height;
1310 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1311 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1312 int idx = ff_hevc_pel_weight[block_w];
1314 x_off += mv->x >> 2;
1315 y_off += mv->y >> 2;
1316 src += y_off * srcstride + x_off * (1 << s->sps->pixel_shift);
1318 if (x_off < QPEL_EXTRA_BEFORE || y_off < QPEL_EXTRA_AFTER ||
1319 x_off >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1320 y_off >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1321 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1322 int offset = QPEL_EXTRA_BEFORE * srcstride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1323 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1325 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1326 edge_emu_stride, srcstride,
1327 block_w + QPEL_EXTRA,
1328 block_h + QPEL_EXTRA,
1329 x_off - QPEL_EXTRA_BEFORE, y_off - QPEL_EXTRA_BEFORE,
1330 pic_width, pic_height);
1331 src = lc->edge_emu_buffer + buf_offset;
1332 srcstride = edge_emu_stride;
1336 s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride, src, srcstride,
1337 block_h, mx, my, block_w);
1339 s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride, src, srcstride,
1340 block_h, s->sh.luma_log2_weight_denom,
1341 luma_weight, luma_offset, mx, my, block_w);
1345 * 8.5.3.2.2.1 Luma sample bidirectional interpolation process
1347 * @param s HEVC decoding context
1348 * @param dst target buffer for block data at block position
1349 * @param dststride stride of the dst buffer
1350 * @param ref0 reference picture0 buffer at origin (0, 0)
1351 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1352 * @param x_off horizontal position of block from origin (0, 0)
1353 * @param y_off vertical position of block from origin (0, 0)
1354 * @param block_w width of block
1355 * @param block_h height of block
1356 * @param ref1 reference picture1 buffer at origin (0, 0)
1357 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1358 * @param current_mv current motion vector structure
1360 static void luma_mc_bi(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1361 AVFrame *ref0, const Mv *mv0, int x_off, int y_off,
1362 int block_w, int block_h, AVFrame *ref1, const Mv *mv1, struct MvField *current_mv)
1364 HEVCLocalContext *lc = s->HEVClc;
1365 ptrdiff_t src0stride = ref0->linesize[0];
1366 ptrdiff_t src1stride = ref1->linesize[0];
1367 int pic_width = s->sps->width;
1368 int pic_height = s->sps->height;
1369 int mx0 = mv0->x & 3;
1370 int my0 = mv0->y & 3;
1371 int mx1 = mv1->x & 3;
1372 int my1 = mv1->y & 3;
1373 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1374 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1375 int x_off0 = x_off + (mv0->x >> 2);
1376 int y_off0 = y_off + (mv0->y >> 2);
1377 int x_off1 = x_off + (mv1->x >> 2);
1378 int y_off1 = y_off + (mv1->y >> 2);
1379 int idx = ff_hevc_pel_weight[block_w];
1381 uint8_t *src0 = ref0->data[0] + y_off0 * src0stride + (int)((unsigned)x_off0 << s->sps->pixel_shift);
1382 uint8_t *src1 = ref1->data[0] + y_off1 * src1stride + (int)((unsigned)x_off1 << s->sps->pixel_shift);
1384 if (x_off0 < QPEL_EXTRA_BEFORE || y_off0 < QPEL_EXTRA_AFTER ||
1385 x_off0 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1386 y_off0 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1387 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1388 int offset = QPEL_EXTRA_BEFORE * src0stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1389 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1391 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset,
1392 edge_emu_stride, src0stride,
1393 block_w + QPEL_EXTRA,
1394 block_h + QPEL_EXTRA,
1395 x_off0 - QPEL_EXTRA_BEFORE, y_off0 - QPEL_EXTRA_BEFORE,
1396 pic_width, pic_height);
1397 src0 = lc->edge_emu_buffer + buf_offset;
1398 src0stride = edge_emu_stride;
1401 if (x_off1 < QPEL_EXTRA_BEFORE || y_off1 < QPEL_EXTRA_AFTER ||
1402 x_off1 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1403 y_off1 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1404 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1405 int offset = QPEL_EXTRA_BEFORE * src1stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1406 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1408 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src1 - offset,
1409 edge_emu_stride, src1stride,
1410 block_w + QPEL_EXTRA,
1411 block_h + QPEL_EXTRA,
1412 x_off1 - QPEL_EXTRA_BEFORE, y_off1 - QPEL_EXTRA_BEFORE,
1413 pic_width, pic_height);
1414 src1 = lc->edge_emu_buffer2 + buf_offset;
1415 src1stride = edge_emu_stride;
1418 s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](lc->tmp, src0, src0stride,
1419 block_h, mx0, my0, block_w);
1421 s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1422 block_h, mx1, my1, block_w);
1424 s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1425 block_h, s->sh.luma_log2_weight_denom,
1426 s->sh.luma_weight_l0[current_mv->ref_idx[0]],
1427 s->sh.luma_weight_l1[current_mv->ref_idx[1]],
1428 s->sh.luma_offset_l0[current_mv->ref_idx[0]],
1429 s->sh.luma_offset_l1[current_mv->ref_idx[1]],
1435 * 8.5.3.2.2.2 Chroma sample uniprediction interpolation process
1437 * @param s HEVC decoding context
1438 * @param dst1 target buffer for block data at block position (U plane)
1439 * @param dst2 target buffer for block data at block position (V plane)
1440 * @param dststride stride of the dst1 and dst2 buffers
1441 * @param ref reference picture buffer at origin (0, 0)
1442 * @param mv motion vector (relative to block position) to get pixel data from
1443 * @param x_off horizontal position of block from origin (0, 0)
1444 * @param y_off vertical position of block from origin (0, 0)
1445 * @param block_w width of block
1446 * @param block_h height of block
1447 * @param chroma_weight weighting factor applied to the chroma prediction
1448 * @param chroma_offset additive offset applied to the chroma prediction value
1451 static void chroma_mc_uni(HEVCContext *s, uint8_t *dst0,
1452 ptrdiff_t dststride, uint8_t *src0, ptrdiff_t srcstride, int reflist,
1453 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int chroma_weight, int chroma_offset)
1455 HEVCLocalContext *lc = s->HEVClc;
1456 int pic_width = s->sps->width >> s->sps->hshift[1];
1457 int pic_height = s->sps->height >> s->sps->vshift[1];
1458 const Mv *mv = ¤t_mv->mv[reflist];
1459 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1460 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1461 int idx = ff_hevc_pel_weight[block_w];
1462 int hshift = s->sps->hshift[1];
1463 int vshift = s->sps->vshift[1];
1464 intptr_t mx = mv->x & ((1 << (2 + hshift)) - 1);
1465 intptr_t my = mv->y & ((1 << (2 + vshift)) - 1);
1466 intptr_t _mx = mx << (1 - hshift);
1467 intptr_t _my = my << (1 - vshift);
1469 x_off += mv->x >> (2 + hshift);
1470 y_off += mv->y >> (2 + vshift);
1471 src0 += y_off * srcstride + x_off * (1 << s->sps->pixel_shift);
1473 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1474 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1475 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1476 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1477 int offset0 = EPEL_EXTRA_BEFORE * (srcstride + (1 << s->sps->pixel_shift));
1478 int buf_offset0 = EPEL_EXTRA_BEFORE *
1479 (edge_emu_stride + (1 << s->sps->pixel_shift));
1480 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset0,
1481 edge_emu_stride, srcstride,
1482 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1483 x_off - EPEL_EXTRA_BEFORE,
1484 y_off - EPEL_EXTRA_BEFORE,
1485 pic_width, pic_height);
1487 src0 = lc->edge_emu_buffer + buf_offset0;
1488 srcstride = edge_emu_stride;
1491 s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1492 block_h, _mx, _my, block_w);
1494 s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1495 block_h, s->sh.chroma_log2_weight_denom,
1496 chroma_weight, chroma_offset, _mx, _my, block_w);
1500 * 8.5.3.2.2.2 Chroma sample bidirectional interpolation process
1502 * @param s HEVC decoding context
1503 * @param dst target buffer for block data at block position
1504 * @param dststride stride of the dst buffer
1505 * @param ref0 reference picture0 buffer at origin (0, 0)
1506 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1507 * @param x_off horizontal position of block from origin (0, 0)
1508 * @param y_off vertical position of block from origin (0, 0)
1509 * @param block_w width of block
1510 * @param block_h height of block
1511 * @param ref1 reference picture1 buffer at origin (0, 0)
1512 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1513 * @param current_mv current motion vector structure
1514 * @param cidx chroma component(cb, cr)
1516 static void chroma_mc_bi(HEVCContext *s, uint8_t *dst0, ptrdiff_t dststride, AVFrame *ref0, AVFrame *ref1,
1517 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int cidx)
1519 HEVCLocalContext *lc = s->HEVClc;
1520 uint8_t *src1 = ref0->data[cidx+1];
1521 uint8_t *src2 = ref1->data[cidx+1];
1522 ptrdiff_t src1stride = ref0->linesize[cidx+1];
1523 ptrdiff_t src2stride = ref1->linesize[cidx+1];
1524 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1525 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1526 int pic_width = s->sps->width >> s->sps->hshift[1];
1527 int pic_height = s->sps->height >> s->sps->vshift[1];
1528 Mv *mv0 = ¤t_mv->mv[0];
1529 Mv *mv1 = ¤t_mv->mv[1];
1530 int hshift = s->sps->hshift[1];
1531 int vshift = s->sps->vshift[1];
1533 intptr_t mx0 = mv0->x & ((1 << (2 + hshift)) - 1);
1534 intptr_t my0 = mv0->y & ((1 << (2 + vshift)) - 1);
1535 intptr_t mx1 = mv1->x & ((1 << (2 + hshift)) - 1);
1536 intptr_t my1 = mv1->y & ((1 << (2 + vshift)) - 1);
1537 intptr_t _mx0 = mx0 << (1 - hshift);
1538 intptr_t _my0 = my0 << (1 - vshift);
1539 intptr_t _mx1 = mx1 << (1 - hshift);
1540 intptr_t _my1 = my1 << (1 - vshift);
1542 int x_off0 = x_off + (mv0->x >> (2 + hshift));
1543 int y_off0 = y_off + (mv0->y >> (2 + vshift));
1544 int x_off1 = x_off + (mv1->x >> (2 + hshift));
1545 int y_off1 = y_off + (mv1->y >> (2 + vshift));
1546 int idx = ff_hevc_pel_weight[block_w];
1547 src1 += y_off0 * src1stride + (int)((unsigned)x_off0 << s->sps->pixel_shift);
1548 src2 += y_off1 * src2stride + (int)((unsigned)x_off1 << s->sps->pixel_shift);
1550 if (x_off0 < EPEL_EXTRA_BEFORE || y_off0 < EPEL_EXTRA_AFTER ||
1551 x_off0 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1552 y_off0 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1553 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1554 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->sps->pixel_shift));
1555 int buf_offset1 = EPEL_EXTRA_BEFORE *
1556 (edge_emu_stride + (1 << s->sps->pixel_shift));
1558 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1559 edge_emu_stride, src1stride,
1560 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1561 x_off0 - EPEL_EXTRA_BEFORE,
1562 y_off0 - EPEL_EXTRA_BEFORE,
1563 pic_width, pic_height);
1565 src1 = lc->edge_emu_buffer + buf_offset1;
1566 src1stride = edge_emu_stride;
1569 if (x_off1 < EPEL_EXTRA_BEFORE || y_off1 < EPEL_EXTRA_AFTER ||
1570 x_off1 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1571 y_off1 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1572 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1573 int offset1 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->sps->pixel_shift));
1574 int buf_offset1 = EPEL_EXTRA_BEFORE *
1575 (edge_emu_stride + (1 << s->sps->pixel_shift));
1577 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src2 - offset1,
1578 edge_emu_stride, src2stride,
1579 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1580 x_off1 - EPEL_EXTRA_BEFORE,
1581 y_off1 - EPEL_EXTRA_BEFORE,
1582 pic_width, pic_height);
1584 src2 = lc->edge_emu_buffer2 + buf_offset1;
1585 src2stride = edge_emu_stride;
1588 s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](lc->tmp, src1, src1stride,
1589 block_h, _mx0, _my0, block_w);
1591 s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1592 src2, src2stride, lc->tmp,
1593 block_h, _mx1, _my1, block_w);
1595 s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1596 src2, src2stride, lc->tmp,
1598 s->sh.chroma_log2_weight_denom,
1599 s->sh.chroma_weight_l0[current_mv->ref_idx[0]][cidx],
1600 s->sh.chroma_weight_l1[current_mv->ref_idx[1]][cidx],
1601 s->sh.chroma_offset_l0[current_mv->ref_idx[0]][cidx],
1602 s->sh.chroma_offset_l1[current_mv->ref_idx[1]][cidx],
1603 _mx1, _my1, block_w);
1606 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1607 const Mv *mv, int y0, int height)
1609 int y = FFMAX(0, (mv->y >> 2) + y0 + height + 9);
1611 if (s->threads_type == FF_THREAD_FRAME )
1612 ff_thread_await_progress(&ref->tf, y, 0);
1615 static void hevc_luma_mv_mpv_mode(HEVCContext *s, int x0, int y0, int nPbW,
1616 int nPbH, int log2_cb_size, int part_idx,
1617 int merge_idx, MvField *mv)
1619 HEVCLocalContext *lc = s->HEVClc;
1620 enum InterPredIdc inter_pred_idc = PRED_L0;
1623 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1625 if (s->sh.slice_type == B_SLICE)
1626 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1628 if (inter_pred_idc != PRED_L1) {
1629 if (s->sh.nb_refs[L0])
1630 mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1632 mv->pred_flag = PF_L0;
1633 ff_hevc_hls_mvd_coding(s, x0, y0, 0);
1634 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1635 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1636 part_idx, merge_idx, mv, mvp_flag, 0);
1637 mv->mv[0].x += lc->pu.mvd.x;
1638 mv->mv[0].y += lc->pu.mvd.y;
1641 if (inter_pred_idc != PRED_L0) {
1642 if (s->sh.nb_refs[L1])
1643 mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1645 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1646 AV_ZERO32(&lc->pu.mvd);
1648 ff_hevc_hls_mvd_coding(s, x0, y0, 1);
1651 mv->pred_flag += PF_L1;
1652 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1653 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1654 part_idx, merge_idx, mv, mvp_flag, 1);
1655 mv->mv[1].x += lc->pu.mvd.x;
1656 mv->mv[1].y += lc->pu.mvd.y;
1660 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1662 int log2_cb_size, int partIdx, int idx)
1664 #define POS(c_idx, x, y) \
1665 &s->frame->data[c_idx][((y) >> s->sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1666 (((x) >> s->sps->hshift[c_idx]) << s->sps->pixel_shift)]
1667 HEVCLocalContext *lc = s->HEVClc;
1669 struct MvField current_mv = {{{ 0 }}};
1671 int min_pu_width = s->sps->min_pu_width;
1673 MvField *tab_mvf = s->ref->tab_mvf;
1674 RefPicList *refPicList = s->ref->refPicList;
1675 HEVCFrame *ref0 = NULL, *ref1 = NULL;
1676 uint8_t *dst0 = POS(0, x0, y0);
1677 uint8_t *dst1 = POS(1, x0, y0);
1678 uint8_t *dst2 = POS(2, x0, y0);
1679 int log2_min_cb_size = s->sps->log2_min_cb_size;
1680 int min_cb_width = s->sps->min_cb_width;
1681 int x_cb = x0 >> log2_min_cb_size;
1682 int y_cb = y0 >> log2_min_cb_size;
1686 int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1689 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1691 if (skip_flag || lc->pu.merge_flag) {
1692 if (s->sh.max_num_merge_cand > 1)
1693 merge_idx = ff_hevc_merge_idx_decode(s);
1697 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1698 partIdx, merge_idx, ¤t_mv);
1700 hevc_luma_mv_mpv_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1701 partIdx, merge_idx, ¤t_mv);
1704 x_pu = x0 >> s->sps->log2_min_pu_size;
1705 y_pu = y0 >> s->sps->log2_min_pu_size;
1707 for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1708 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1709 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1711 if (current_mv.pred_flag & PF_L0) {
1712 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1715 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1717 if (current_mv.pred_flag & PF_L1) {
1718 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1721 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1724 if (current_mv.pred_flag == PF_L0) {
1725 int x0_c = x0 >> s->sps->hshift[1];
1726 int y0_c = y0 >> s->sps->vshift[1];
1727 int nPbW_c = nPbW >> s->sps->hshift[1];
1728 int nPbH_c = nPbH >> s->sps->vshift[1];
1730 luma_mc_uni(s, dst0, s->frame->linesize[0], ref0->frame,
1731 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1732 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1733 s->sh.luma_offset_l0[current_mv.ref_idx[0]]);
1735 if (s->sps->chroma_format_idc) {
1736 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref0->frame->data[1], ref0->frame->linesize[1],
1737 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1738 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]);
1739 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref0->frame->data[2], ref0->frame->linesize[2],
1740 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1741 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]);
1743 } else if (current_mv.pred_flag == PF_L1) {
1744 int x0_c = x0 >> s->sps->hshift[1];
1745 int y0_c = y0 >> s->sps->vshift[1];
1746 int nPbW_c = nPbW >> s->sps->hshift[1];
1747 int nPbH_c = nPbH >> s->sps->vshift[1];
1749 luma_mc_uni(s, dst0, s->frame->linesize[0], ref1->frame,
1750 ¤t_mv.mv[1], x0, y0, nPbW, nPbH,
1751 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1752 s->sh.luma_offset_l1[current_mv.ref_idx[1]]);
1754 if (s->sps->chroma_format_idc) {
1755 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
1756 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1757 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]);
1759 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
1760 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1761 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]);
1763 } else if (current_mv.pred_flag == PF_BI) {
1764 int x0_c = x0 >> s->sps->hshift[1];
1765 int y0_c = y0 >> s->sps->vshift[1];
1766 int nPbW_c = nPbW >> s->sps->hshift[1];
1767 int nPbH_c = nPbH >> s->sps->vshift[1];
1769 luma_mc_bi(s, dst0, s->frame->linesize[0], ref0->frame,
1770 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1771 ref1->frame, ¤t_mv.mv[1], ¤t_mv);
1773 if (s->sps->chroma_format_idc) {
1774 chroma_mc_bi(s, dst1, s->frame->linesize[1], ref0->frame, ref1->frame,
1775 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 0);
1777 chroma_mc_bi(s, dst2, s->frame->linesize[2], ref0->frame, ref1->frame,
1778 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1);
1786 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1787 int prev_intra_luma_pred_flag)
1789 HEVCLocalContext *lc = s->HEVClc;
1790 int x_pu = x0 >> s->sps->log2_min_pu_size;
1791 int y_pu = y0 >> s->sps->log2_min_pu_size;
1792 int min_pu_width = s->sps->min_pu_width;
1793 int size_in_pus = pu_size >> s->sps->log2_min_pu_size;
1794 int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1);
1795 int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1);
1797 int cand_up = (lc->ctb_up_flag || y0b) ?
1798 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1799 int cand_left = (lc->ctb_left_flag || x0b) ?
1800 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1802 int y_ctb = (y0 >> (s->sps->log2_ctb_size)) << (s->sps->log2_ctb_size);
1804 MvField *tab_mvf = s->ref->tab_mvf;
1805 int intra_pred_mode;
1809 // intra_pred_mode prediction does not cross vertical CTB boundaries
1810 if ((y0 - 1) < y_ctb)
1813 if (cand_left == cand_up) {
1814 if (cand_left < 2) {
1815 candidate[0] = INTRA_PLANAR;
1816 candidate[1] = INTRA_DC;
1817 candidate[2] = INTRA_ANGULAR_26;
1819 candidate[0] = cand_left;
1820 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1821 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1824 candidate[0] = cand_left;
1825 candidate[1] = cand_up;
1826 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1827 candidate[2] = INTRA_PLANAR;
1828 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1829 candidate[2] = INTRA_DC;
1831 candidate[2] = INTRA_ANGULAR_26;
1835 if (prev_intra_luma_pred_flag) {
1836 intra_pred_mode = candidate[lc->pu.mpm_idx];
1838 if (candidate[0] > candidate[1])
1839 FFSWAP(uint8_t, candidate[0], candidate[1]);
1840 if (candidate[0] > candidate[2])
1841 FFSWAP(uint8_t, candidate[0], candidate[2]);
1842 if (candidate[1] > candidate[2])
1843 FFSWAP(uint8_t, candidate[1], candidate[2]);
1845 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1846 for (i = 0; i < 3; i++)
1847 if (intra_pred_mode >= candidate[i])
1851 /* write the intra prediction units into the mv array */
1854 for (i = 0; i < size_in_pus; i++) {
1855 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1856 intra_pred_mode, size_in_pus);
1858 for (j = 0; j < size_in_pus; j++) {
1859 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag = PF_INTRA;
1863 return intra_pred_mode;
1866 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1867 int log2_cb_size, int ct_depth)
1869 int length = (1 << log2_cb_size) >> s->sps->log2_min_cb_size;
1870 int x_cb = x0 >> s->sps->log2_min_cb_size;
1871 int y_cb = y0 >> s->sps->log2_min_cb_size;
1874 for (y = 0; y < length; y++)
1875 memset(&s->tab_ct_depth[(y_cb + y) * s->sps->min_cb_width + x_cb],
1879 static const uint8_t tab_mode_idx[] = {
1880 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
1881 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
1883 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1886 HEVCLocalContext *lc = s->HEVClc;
1887 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1888 uint8_t prev_intra_luma_pred_flag[4];
1889 int split = lc->cu.part_mode == PART_NxN;
1890 int pb_size = (1 << log2_cb_size) >> split;
1891 int side = split + 1;
1895 for (i = 0; i < side; i++)
1896 for (j = 0; j < side; j++)
1897 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1899 for (i = 0; i < side; i++) {
1900 for (j = 0; j < side; j++) {
1901 if (prev_intra_luma_pred_flag[2 * i + j])
1902 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
1904 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
1906 lc->pu.intra_pred_mode[2 * i + j] =
1907 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1908 prev_intra_luma_pred_flag[2 * i + j]);
1912 if (s->sps->chroma_format_idc == 3) {
1913 for (i = 0; i < side; i++) {
1914 for (j = 0; j < side; j++) {
1915 lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1916 if (chroma_mode != 4) {
1917 if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode])
1918 lc->pu.intra_pred_mode_c[2 * i + j] = 34;
1920 lc->pu.intra_pred_mode_c[2 * i + j] = intra_chroma_table[chroma_mode];
1922 lc->pu.intra_pred_mode_c[2 * i + j] = lc->pu.intra_pred_mode[2 * i + j];
1926 } else if (s->sps->chroma_format_idc == 2) {
1928 lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1929 if (chroma_mode != 4) {
1930 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1933 mode_idx = intra_chroma_table[chroma_mode];
1935 mode_idx = lc->pu.intra_pred_mode[0];
1937 lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx];
1938 } else if (s->sps->chroma_format_idc != 0) {
1939 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1940 if (chroma_mode != 4) {
1941 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1942 lc->pu.intra_pred_mode_c[0] = 34;
1944 lc->pu.intra_pred_mode_c[0] = intra_chroma_table[chroma_mode];
1946 lc->pu.intra_pred_mode_c[0] = lc->pu.intra_pred_mode[0];
1951 static void intra_prediction_unit_default_value(HEVCContext *s,
1955 HEVCLocalContext *lc = s->HEVClc;
1956 int pb_size = 1 << log2_cb_size;
1957 int size_in_pus = pb_size >> s->sps->log2_min_pu_size;
1958 int min_pu_width = s->sps->min_pu_width;
1959 MvField *tab_mvf = s->ref->tab_mvf;
1960 int x_pu = x0 >> s->sps->log2_min_pu_size;
1961 int y_pu = y0 >> s->sps->log2_min_pu_size;
1964 if (size_in_pus == 0)
1966 for (j = 0; j < size_in_pus; j++)
1967 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
1968 if (lc->cu.pred_mode == MODE_INTRA)
1969 for (j = 0; j < size_in_pus; j++)
1970 for (k = 0; k < size_in_pus; k++)
1971 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].pred_flag = PF_INTRA;
1974 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
1976 int cb_size = 1 << log2_cb_size;
1977 HEVCLocalContext *lc = s->HEVClc;
1978 int log2_min_cb_size = s->sps->log2_min_cb_size;
1979 int length = cb_size >> log2_min_cb_size;
1980 int min_cb_width = s->sps->min_cb_width;
1981 int x_cb = x0 >> log2_min_cb_size;
1982 int y_cb = y0 >> log2_min_cb_size;
1983 int idx = log2_cb_size - 2;
1984 int qp_block_mask = (1<<(s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth)) - 1;
1989 lc->cu.pred_mode = MODE_INTRA;
1990 lc->cu.part_mode = PART_2Nx2N;
1991 lc->cu.intra_split_flag = 0;
1993 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
1994 for (x = 0; x < 4; x++)
1995 lc->pu.intra_pred_mode[x] = 1;
1996 if (s->pps->transquant_bypass_enable_flag) {
1997 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
1998 if (lc->cu.cu_transquant_bypass_flag)
1999 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2001 lc->cu.cu_transquant_bypass_flag = 0;
2003 if (s->sh.slice_type != I_SLICE) {
2004 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
2006 x = y_cb * min_cb_width + x_cb;
2007 for (y = 0; y < length; y++) {
2008 memset(&s->skip_flag[x], skip_flag, length);
2011 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2013 x = y_cb * min_cb_width + x_cb;
2014 for (y = 0; y < length; y++) {
2015 memset(&s->skip_flag[x], 0, length);
2020 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2021 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2022 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2024 if (!s->sh.disable_deblocking_filter_flag)
2025 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2029 if (s->sh.slice_type != I_SLICE)
2030 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2031 if (lc->cu.pred_mode != MODE_INTRA ||
2032 log2_cb_size == s->sps->log2_min_cb_size) {
2033 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2034 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2035 lc->cu.pred_mode == MODE_INTRA;
2038 if (lc->cu.pred_mode == MODE_INTRA) {
2039 if (lc->cu.part_mode == PART_2Nx2N && s->sps->pcm_enabled_flag &&
2040 log2_cb_size >= s->sps->pcm.log2_min_pcm_cb_size &&
2041 log2_cb_size <= s->sps->pcm.log2_max_pcm_cb_size) {
2042 pcm_flag = ff_hevc_pcm_flag_decode(s);
2045 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2046 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2047 if (s->sps->pcm.loop_filter_disable_flag)
2048 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2053 intra_prediction_unit(s, x0, y0, log2_cb_size);
2056 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2057 switch (lc->cu.part_mode) {
2059 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2062 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0, idx);
2063 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2066 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2067 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2070 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0, idx);
2071 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2074 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2075 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2078 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0, idx - 2);
2079 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2082 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2083 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2086 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2087 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2088 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2089 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2095 int rqt_root_cbf = 1;
2097 if (lc->cu.pred_mode != MODE_INTRA &&
2098 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2099 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2102 const static int cbf[2] = { 0 };
2103 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2104 s->sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2105 s->sps->max_transform_hierarchy_depth_inter;
2106 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2108 log2_cb_size, 0, 0, cbf, cbf);
2112 if (!s->sh.disable_deblocking_filter_flag)
2113 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2118 if (s->pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2119 ff_hevc_set_qPy(s, x0, y0, log2_cb_size);
2121 x = y_cb * min_cb_width + x_cb;
2122 for (y = 0; y < length; y++) {
2123 memset(&s->qp_y_tab[x], lc->qp_y, length);
2127 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2128 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2129 lc->qPy_pred = lc->qp_y;
2132 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct_depth);
2137 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2138 int log2_cb_size, int cb_depth)
2140 HEVCLocalContext *lc = s->HEVClc;
2141 const int cb_size = 1 << log2_cb_size;
2145 lc->ct_depth = cb_depth;
2146 if (x0 + cb_size <= s->sps->width &&
2147 y0 + cb_size <= s->sps->height &&
2148 log2_cb_size > s->sps->log2_min_cb_size) {
2149 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2151 split_cu = (log2_cb_size > s->sps->log2_min_cb_size);
2153 if (s->pps->cu_qp_delta_enabled_flag &&
2154 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth) {
2155 lc->tu.is_cu_qp_delta_coded = 0;
2156 lc->tu.cu_qp_delta = 0;
2159 if (s->sh.cu_chroma_qp_offset_enabled_flag &&
2160 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_chroma_qp_offset_depth) {
2161 lc->tu.is_cu_chroma_qp_offset_coded = 0;
2165 int qp_block_mask = (1<<(s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth)) - 1;
2166 const int cb_size_split = cb_size >> 1;
2167 const int x1 = x0 + cb_size_split;
2168 const int y1 = y0 + cb_size_split;
2172 more_data = hls_coding_quadtree(s, x0, y0, log2_cb_size - 1, cb_depth + 1);
2176 if (more_data && x1 < s->sps->width) {
2177 more_data = hls_coding_quadtree(s, x1, y0, log2_cb_size - 1, cb_depth + 1);
2181 if (more_data && y1 < s->sps->height) {
2182 more_data = hls_coding_quadtree(s, x0, y1, log2_cb_size - 1, cb_depth + 1);
2186 if (more_data && x1 < s->sps->width &&
2187 y1 < s->sps->height) {
2188 more_data = hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1);
2193 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2194 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2195 lc->qPy_pred = lc->qp_y;
2198 return ((x1 + cb_size_split) < s->sps->width ||
2199 (y1 + cb_size_split) < s->sps->height);
2203 ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2206 if ((!((x0 + cb_size) %
2207 (1 << (s->sps->log2_ctb_size))) ||
2208 (x0 + cb_size >= s->sps->width)) &&
2210 (1 << (s->sps->log2_ctb_size))) ||
2211 (y0 + cb_size >= s->sps->height))) {
2212 int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s);
2213 return !end_of_slice_flag;
2222 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2225 HEVCLocalContext *lc = s->HEVClc;
2226 int ctb_size = 1 << s->sps->log2_ctb_size;
2227 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2228 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2230 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2232 if (s->pps->entropy_coding_sync_enabled_flag) {
2233 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2234 lc->first_qp_group = 1;
2235 lc->end_of_tiles_x = s->sps->width;
2236 } else if (s->pps->tiles_enabled_flag) {
2237 if (ctb_addr_ts && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1]) {
2238 int idxX = s->pps->col_idxX[x_ctb >> s->sps->log2_ctb_size];
2239 lc->end_of_tiles_x = x_ctb + (s->pps->column_width[idxX] << s->sps->log2_ctb_size);
2240 lc->first_qp_group = 1;
2243 lc->end_of_tiles_x = s->sps->width;
2246 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->sps->height);
2248 lc->boundary_flags = 0;
2249 if (s->pps->tiles_enabled_flag) {
2250 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]])
2251 lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2252 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2253 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2254 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]])
2255 lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2256 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->sps->ctb_width])
2257 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2259 if (!ctb_addr_in_slice > 0)
2260 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2261 if (ctb_addr_in_slice < s->sps->ctb_width)
2262 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2265 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2266 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2267 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]]));
2268 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]]));
2271 static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
2273 HEVCContext *s = avctxt->priv_data;
2274 int ctb_size = 1 << s->sps->log2_ctb_size;
2278 int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2280 if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) {
2281 av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n");
2282 return AVERROR_INVALIDDATA;
2285 if (s->sh.dependent_slice_segment_flag) {
2286 int prev_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2287 if (s->tab_slice_address[prev_rs] != s->sh.slice_addr) {
2288 av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n");
2289 return AVERROR_INVALIDDATA;
2293 while (more_data && ctb_addr_ts < s->sps->ctb_size) {
2294 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2296 x_ctb = (ctb_addr_rs % ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2297 y_ctb = (ctb_addr_rs / ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2298 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2300 ff_hevc_cabac_init(s, ctb_addr_ts);
2302 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2304 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2305 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2306 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2308 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2309 if (more_data < 0) {
2310 s->tab_slice_address[ctb_addr_rs] = -1;
2316 ff_hevc_save_states(s, ctb_addr_ts);
2317 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2320 if (x_ctb + ctb_size >= s->sps->width &&
2321 y_ctb + ctb_size >= s->sps->height)
2322 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2327 static int hls_slice_data(HEVCContext *s)
2335 s->avctx->execute(s->avctx, hls_decode_entry, arg, ret , 1, sizeof(int));
2338 static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int job, int self_id)
2340 HEVCContext *s1 = avctxt->priv_data, *s;
2341 HEVCLocalContext *lc;
2342 int ctb_size = 1<< s1->sps->log2_ctb_size;
2344 int *ctb_row_p = input_ctb_row;
2345 int ctb_row = ctb_row_p[job];
2346 int ctb_addr_rs = s1->sh.slice_ctb_addr_rs + ctb_row * ((s1->sps->width + ctb_size - 1) >> s1->sps->log2_ctb_size);
2347 int ctb_addr_ts = s1->pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2348 int thread = ctb_row % s1->threads_number;
2351 s = s1->sList[self_id];
2355 ret = init_get_bits8(&lc->gb, s->data + s->sh.offset[ctb_row - 1], s->sh.size[ctb_row - 1]);
2359 ff_init_cabac_decoder(&lc->cc, s->data + s->sh.offset[(ctb_row)-1], s->sh.size[ctb_row - 1]);
2362 while(more_data && ctb_addr_ts < s->sps->ctb_size) {
2363 int x_ctb = (ctb_addr_rs % s->sps->ctb_width) << s->sps->log2_ctb_size;
2364 int y_ctb = (ctb_addr_rs / s->sps->ctb_width) << s->sps->log2_ctb_size;
2366 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2368 ff_thread_await_progress2(s->avctx, ctb_row, thread, SHIFT_CTB_WPP);
2370 if (avpriv_atomic_int_get(&s1->wpp_err)){
2371 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2375 ff_hevc_cabac_init(s, ctb_addr_ts);
2376 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2377 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2379 if (more_data < 0) {
2380 s->tab_slice_address[ctb_addr_rs] = -1;
2386 ff_hevc_save_states(s, ctb_addr_ts);
2387 ff_thread_report_progress2(s->avctx, ctb_row, thread, 1);
2388 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2390 if (!more_data && (x_ctb+ctb_size) < s->sps->width && ctb_row != s->sh.num_entry_point_offsets) {
2391 avpriv_atomic_int_set(&s1->wpp_err, 1);
2392 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2396 if ((x_ctb+ctb_size) >= s->sps->width && (y_ctb+ctb_size) >= s->sps->height ) {
2397 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2398 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2401 ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2404 if(x_ctb >= s->sps->width) {
2408 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2413 static int hls_slice_data_wpp(HEVCContext *s, const uint8_t *nal, int length)
2415 HEVCLocalContext *lc = s->HEVClc;
2416 int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2417 int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2419 int startheader, cmpt = 0;
2425 return AVERROR(ENOMEM);
2430 ff_alloc_entries(s->avctx, s->sh.num_entry_point_offsets + 1);
2433 for (i = 1; i < s->threads_number; i++) {
2434 s->sList[i] = av_malloc(sizeof(HEVCContext));
2435 memcpy(s->sList[i], s, sizeof(HEVCContext));
2436 s->HEVClcList[i] = av_mallocz(sizeof(HEVCLocalContext));
2437 s->sList[i]->HEVClc = s->HEVClcList[i];
2441 offset = (lc->gb.index >> 3);
2443 for (j = 0, cmpt = 0, startheader = offset + s->sh.entry_point_offset[0]; j < s->skipped_bytes; j++) {
2444 if (s->skipped_bytes_pos[j] >= offset && s->skipped_bytes_pos[j] < startheader) {
2450 for (i = 1; i < s->sh.num_entry_point_offsets; i++) {
2451 offset += (s->sh.entry_point_offset[i - 1] - cmpt);
2452 for (j = 0, cmpt = 0, startheader = offset
2453 + s->sh.entry_point_offset[i]; j < s->skipped_bytes; j++) {
2454 if (s->skipped_bytes_pos[j] >= offset && s->skipped_bytes_pos[j] < startheader) {
2459 s->sh.size[i - 1] = s->sh.entry_point_offset[i] - cmpt;
2460 s->sh.offset[i - 1] = offset;
2463 if (s->sh.num_entry_point_offsets != 0) {
2464 offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt;
2465 s->sh.size[s->sh.num_entry_point_offsets - 1] = length - offset;
2466 s->sh.offset[s->sh.num_entry_point_offsets - 1] = offset;
2471 for (i = 1; i < s->threads_number; i++) {
2472 s->sList[i]->HEVClc->first_qp_group = 1;
2473 s->sList[i]->HEVClc->qp_y = s->sList[0]->HEVClc->qp_y;
2474 memcpy(s->sList[i], s, sizeof(HEVCContext));
2475 s->sList[i]->HEVClc = s->HEVClcList[i];
2478 avpriv_atomic_int_set(&s->wpp_err, 0);
2479 ff_reset_entries(s->avctx);
2481 for (i = 0; i <= s->sh.num_entry_point_offsets; i++) {
2486 if (s->pps->entropy_coding_sync_enabled_flag)
2487 s->avctx->execute2(s->avctx, (void *) hls_decode_entry_wpp, arg, ret, s->sh.num_entry_point_offsets + 1);
2489 for (i = 0; i <= s->sh.num_entry_point_offsets; i++)
2497 * @return AVERROR_INVALIDDATA if the packet is not a valid NAL unit,
2498 * 0 if the unit should be skipped, 1 otherwise
2500 static int hls_nal_unit(HEVCContext *s)
2502 GetBitContext *gb = &s->HEVClc->gb;
2505 if (get_bits1(gb) != 0)
2506 return AVERROR_INVALIDDATA;
2508 s->nal_unit_type = get_bits(gb, 6);
2510 nuh_layer_id = get_bits(gb, 6);
2511 s->temporal_id = get_bits(gb, 3) - 1;
2512 if (s->temporal_id < 0)
2513 return AVERROR_INVALIDDATA;
2515 av_log(s->avctx, AV_LOG_DEBUG,
2516 "nal_unit_type: %d, nuh_layer_id: %d, temporal_id: %d\n",
2517 s->nal_unit_type, nuh_layer_id, s->temporal_id);
2519 return nuh_layer_id == 0;
2522 static int set_side_data(HEVCContext *s)
2524 AVFrame *out = s->ref->frame;
2526 if (s->sei_frame_packing_present &&
2527 s->frame_packing_arrangement_type >= 3 &&
2528 s->frame_packing_arrangement_type <= 5 &&
2529 s->content_interpretation_type > 0 &&
2530 s->content_interpretation_type < 3) {
2531 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2533 return AVERROR(ENOMEM);
2535 switch (s->frame_packing_arrangement_type) {
2537 if (s->quincunx_subsampling)
2538 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2540 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2543 stereo->type = AV_STEREO3D_TOPBOTTOM;
2546 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2550 if (s->content_interpretation_type == 2)
2551 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2554 if (s->sei_display_orientation_present &&
2555 (s->sei_anticlockwise_rotation || s->sei_hflip || s->sei_vflip)) {
2556 double angle = s->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
2557 AVFrameSideData *rotation = av_frame_new_side_data(out,
2558 AV_FRAME_DATA_DISPLAYMATRIX,
2559 sizeof(int32_t) * 9);
2561 return AVERROR(ENOMEM);
2563 av_display_rotation_set((int32_t *)rotation->data, angle);
2564 av_display_matrix_flip((int32_t *)rotation->data,
2565 s->sei_hflip, s->sei_vflip);
2571 static int hevc_frame_start(HEVCContext *s)
2573 HEVCLocalContext *lc = s->HEVClc;
2574 int pic_size_in_ctb = ((s->sps->width >> s->sps->log2_min_cb_size) + 1) *
2575 ((s->sps->height >> s->sps->log2_min_cb_size) + 1);
2578 memset(s->horizontal_bs, 0, s->bs_width * s->bs_height);
2579 memset(s->vertical_bs, 0, s->bs_width * s->bs_height);
2580 memset(s->cbf_luma, 0, s->sps->min_tb_width * s->sps->min_tb_height);
2581 memset(s->is_pcm, 0, (s->sps->min_pu_width + 1) * (s->sps->min_pu_height + 1));
2582 memset(s->tab_slice_address, -1, pic_size_in_ctb * sizeof(*s->tab_slice_address));
2585 s->first_nal_type = s->nal_unit_type;
2587 if (s->pps->tiles_enabled_flag)
2588 lc->end_of_tiles_x = s->pps->column_width[0] << s->sps->log2_ctb_size;
2590 ret = ff_hevc_set_new_ref(s, &s->frame, s->poc);
2594 ret = ff_hevc_frame_rps(s);
2596 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2600 s->ref->frame->key_frame = IS_IRAP(s);
2602 ret = set_side_data(s);
2606 s->frame->pict_type = 3 - s->sh.slice_type;
2609 ff_hevc_bump_frame(s);
2611 av_frame_unref(s->output_frame);
2612 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2616 if (!s->avctx->hwaccel)
2617 ff_thread_finish_setup(s->avctx);
2623 ff_hevc_unref_frame(s, s->ref, ~0);
2628 static int decode_nal_unit(HEVCContext *s, const HEVCNAL *nal)
2630 HEVCLocalContext *lc = s->HEVClc;
2631 GetBitContext *gb = &lc->gb;
2632 int ctb_addr_ts, ret;
2634 ret = init_get_bits8(gb, nal->data, nal->size);
2638 ret = hls_nal_unit(s);
2640 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit %d, skipping.\n",
2646 switch (s->nal_unit_type) {
2648 ret = ff_hevc_decode_nal_vps(s);
2653 ret = ff_hevc_decode_nal_sps(s);
2658 ret = ff_hevc_decode_nal_pps(s);
2662 case NAL_SEI_PREFIX:
2663 case NAL_SEI_SUFFIX:
2664 ret = ff_hevc_decode_nal_sei(s);
2675 case NAL_BLA_W_RADL:
2677 case NAL_IDR_W_RADL:
2684 ret = hls_slice_header(s);
2688 if (s->max_ra == INT_MAX) {
2689 if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
2693 s->max_ra = INT_MIN;
2697 if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
2698 s->poc <= s->max_ra) {
2702 if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
2703 s->max_ra = INT_MIN;
2706 if (s->sh.first_slice_in_pic_flag) {
2707 ret = hevc_frame_start(s);
2710 } else if (!s->ref) {
2711 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2715 if (s->nal_unit_type != s->first_nal_type) {
2716 av_log(s->avctx, AV_LOG_ERROR,
2717 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2718 s->first_nal_type, s->nal_unit_type);
2719 return AVERROR_INVALIDDATA;
2722 if (!s->sh.dependent_slice_segment_flag &&
2723 s->sh.slice_type != I_SLICE) {
2724 ret = ff_hevc_slice_rpl(s);
2726 av_log(s->avctx, AV_LOG_WARNING,
2727 "Error constructing the reference lists for the current slice.\n");
2732 if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) {
2733 ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0);
2738 if (s->avctx->hwaccel) {
2739 ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size);
2743 if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
2744 ctb_addr_ts = hls_slice_data_wpp(s, nal->data, nal->size);
2746 ctb_addr_ts = hls_slice_data(s);
2747 if (ctb_addr_ts >= (s->sps->ctb_width * s->sps->ctb_height)) {
2751 if (ctb_addr_ts < 0) {
2759 s->seq_decode = (s->seq_decode + 1) & 0xff;
2760 s->max_ra = INT_MAX;
2766 av_log(s->avctx, AV_LOG_INFO,
2767 "Skipping NAL unit %d\n", s->nal_unit_type);
2772 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2777 /* FIXME: This is adapted from ff_h264_decode_nal, avoiding duplication
2778 * between these functions would be nice. */
2779 int ff_hevc_extract_rbsp(HEVCContext *s, const uint8_t *src, int length,
2785 s->skipped_bytes = 0;
2786 #define STARTCODE_TEST \
2787 if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \
2788 if (src[i + 2] != 3) { \
2789 /* startcode, so we must be past the end */ \
2794 #if HAVE_FAST_UNALIGNED
2795 #define FIND_FIRST_ZERO \
2796 if (i > 0 && !src[i]) \
2801 for (i = 0; i + 1 < length; i += 9) {
2802 if (!((~AV_RN64A(src + i) &
2803 (AV_RN64A(src + i) - 0x0100010001000101ULL)) &
2804 0x8000800080008080ULL))
2811 for (i = 0; i + 1 < length; i += 5) {
2812 if (!((~AV_RN32A(src + i) &
2813 (AV_RN32A(src + i) - 0x01000101U)) &
2820 #endif /* HAVE_FAST_64BIT */
2822 for (i = 0; i + 1 < length; i += 2) {
2825 if (i > 0 && src[i - 1] == 0)
2829 #endif /* HAVE_FAST_UNALIGNED */
2831 if (i >= length - 1) { // no escaped 0
2833 nal->raw_data = src;
2835 nal->raw_size = length;
2839 av_fast_malloc(&nal->rbsp_buffer, &nal->rbsp_buffer_size,
2840 length + FF_INPUT_BUFFER_PADDING_SIZE);
2841 if (!nal->rbsp_buffer)
2842 return AVERROR(ENOMEM);
2844 dst = nal->rbsp_buffer;
2846 memcpy(dst, src, i);
2848 while (si + 2 < length) {
2849 // remove escapes (very rare 1:2^22)
2850 if (src[si + 2] > 3) {
2851 dst[di++] = src[si++];
2852 dst[di++] = src[si++];
2853 } else if (src[si] == 0 && src[si + 1] == 0) {
2854 if (src[si + 2] == 3) { // escape
2860 if (s->skipped_bytes_pos_size < s->skipped_bytes) {
2861 s->skipped_bytes_pos_size *= 2;
2862 av_reallocp_array(&s->skipped_bytes_pos,
2863 s->skipped_bytes_pos_size,
2864 sizeof(*s->skipped_bytes_pos));
2865 if (!s->skipped_bytes_pos)
2866 return AVERROR(ENOMEM);
2868 if (s->skipped_bytes_pos)
2869 s->skipped_bytes_pos[s->skipped_bytes-1] = di - 1;
2871 } else // next start code
2875 dst[di++] = src[si++];
2878 dst[di++] = src[si++];
2881 memset(dst + di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2885 nal->raw_data = src;
2890 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2892 int i, consumed, ret = 0;
2895 s->last_eos = s->eos;
2898 /* split the input packet into NAL units, so we know the upper bound on the
2899 * number of slices in the frame */
2901 while (length >= 4) {
2903 int extract_length = 0;
2907 for (i = 0; i < s->nal_length_size; i++)
2908 extract_length = (extract_length << 8) | buf[i];
2909 buf += s->nal_length_size;
2910 length -= s->nal_length_size;
2912 if (extract_length > length) {
2913 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit size.\n");
2914 ret = AVERROR_INVALIDDATA;
2918 /* search start code */
2919 while (buf[0] != 0 || buf[1] != 0 || buf[2] != 1) {
2923 av_log(s->avctx, AV_LOG_ERROR, "No start code is found.\n");
2924 ret = AVERROR_INVALIDDATA;
2934 extract_length = length;
2936 if (s->nals_allocated < s->nb_nals + 1) {
2937 int new_size = s->nals_allocated + 1;
2938 void *tmp = av_realloc_array(s->nals, new_size, sizeof(*s->nals));
2939 ret = AVERROR(ENOMEM);
2944 memset(s->nals + s->nals_allocated, 0,
2945 (new_size - s->nals_allocated) * sizeof(*s->nals));
2947 tmp = av_realloc_array(s->skipped_bytes_nal, new_size, sizeof(*s->skipped_bytes_nal));
2950 s->skipped_bytes_nal = tmp;
2952 tmp = av_realloc_array(s->skipped_bytes_pos_size_nal, new_size, sizeof(*s->skipped_bytes_pos_size_nal));
2955 s->skipped_bytes_pos_size_nal = tmp;
2957 tmp = av_realloc_array(s->skipped_bytes_pos_nal, new_size, sizeof(*s->skipped_bytes_pos_nal));
2960 s->skipped_bytes_pos_nal = tmp;
2962 s->skipped_bytes_pos_size_nal[s->nals_allocated] = 1024; // initial buffer size
2963 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));
2964 if (!s->skipped_bytes_pos_nal[s->nals_allocated])
2966 s->nals_allocated = new_size;
2968 s->skipped_bytes_pos_size = s->skipped_bytes_pos_size_nal[s->nb_nals];
2969 s->skipped_bytes_pos = s->skipped_bytes_pos_nal[s->nb_nals];
2970 nal = &s->nals[s->nb_nals];
2972 consumed = ff_hevc_extract_rbsp(s, buf, extract_length, nal);
2974 s->skipped_bytes_nal[s->nb_nals] = s->skipped_bytes;
2975 s->skipped_bytes_pos_size_nal[s->nb_nals] = s->skipped_bytes_pos_size;
2976 s->skipped_bytes_pos_nal[s->nb_nals++] = s->skipped_bytes_pos;
2984 ret = init_get_bits8(&s->HEVClc->gb, nal->data, nal->size);
2989 if (s->nal_unit_type == NAL_EOB_NUT ||
2990 s->nal_unit_type == NAL_EOS_NUT)
2997 /* parse the NAL units */
2998 for (i = 0; i < s->nb_nals; i++) {
3000 s->skipped_bytes = s->skipped_bytes_nal[i];
3001 s->skipped_bytes_pos = s->skipped_bytes_pos_nal[i];
3003 ret = decode_nal_unit(s, &s->nals[i]);
3005 av_log(s->avctx, AV_LOG_WARNING,
3006 "Error parsing NAL unit #%d.\n", i);
3012 if (s->ref && s->threads_type == FF_THREAD_FRAME)
3013 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
3018 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
3021 for (i = 0; i < 16; i++)
3022 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
3025 static int verify_md5(HEVCContext *s, AVFrame *frame)
3027 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
3032 return AVERROR(EINVAL);
3034 pixel_shift = desc->comp[0].depth_minus1 > 7;
3036 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
3039 /* the checksums are LE, so we have to byteswap for >8bpp formats
3042 if (pixel_shift && !s->checksum_buf) {
3043 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
3044 FFMAX3(frame->linesize[0], frame->linesize[1],
3045 frame->linesize[2]));
3046 if (!s->checksum_buf)
3047 return AVERROR(ENOMEM);
3051 for (i = 0; frame->data[i]; i++) {
3052 int width = s->avctx->coded_width;
3053 int height = s->avctx->coded_height;
3054 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
3055 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
3058 av_md5_init(s->md5_ctx);
3059 for (j = 0; j < h; j++) {
3060 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
3063 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
3064 (const uint16_t *) src, w);
3065 src = s->checksum_buf;
3068 av_md5_update(s->md5_ctx, src, w << pixel_shift);
3070 av_md5_final(s->md5_ctx, md5);
3072 if (!memcmp(md5, s->md5[i], 16)) {
3073 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
3074 print_md5(s->avctx, AV_LOG_DEBUG, md5);
3075 av_log (s->avctx, AV_LOG_DEBUG, "; ");
3077 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
3078 print_md5(s->avctx, AV_LOG_ERROR, md5);
3079 av_log (s->avctx, AV_LOG_ERROR, " != ");
3080 print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
3081 av_log (s->avctx, AV_LOG_ERROR, "\n");
3082 return AVERROR_INVALIDDATA;
3086 av_log(s->avctx, AV_LOG_DEBUG, "\n");
3091 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
3095 HEVCContext *s = avctx->priv_data;
3098 ret = ff_hevc_output_frame(s, data, 1);
3107 ret = decode_nal_units(s, avpkt->data, avpkt->size);
3111 if (avctx->hwaccel) {
3112 if (s->ref && avctx->hwaccel->end_frame(avctx) < 0)
3113 av_log(avctx, AV_LOG_ERROR,
3114 "hardware accelerator failed to decode picture\n");
3116 /* verify the SEI checksum */
3117 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
3119 ret = verify_md5(s, s->ref->frame);
3120 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
3121 ff_hevc_unref_frame(s, s->ref, ~0);
3128 if (s->is_decoded) {
3129 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
3133 if (s->output_frame->buf[0]) {
3134 av_frame_move_ref(data, s->output_frame);
3141 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
3145 ret = ff_thread_ref_frame(&dst->tf, &src->tf);
3149 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
3150 if (!dst->tab_mvf_buf)
3152 dst->tab_mvf = src->tab_mvf;
3154 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
3155 if (!dst->rpl_tab_buf)
3157 dst->rpl_tab = src->rpl_tab;
3159 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
3163 dst->poc = src->poc;
3164 dst->ctb_count = src->ctb_count;
3165 dst->window = src->window;
3166 dst->flags = src->flags;
3167 dst->sequence = src->sequence;
3169 if (src->hwaccel_picture_private) {
3170 dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
3171 if (!dst->hwaccel_priv_buf)
3173 dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
3178 ff_hevc_unref_frame(s, dst, ~0);
3179 return AVERROR(ENOMEM);
3182 static av_cold int hevc_decode_free(AVCodecContext *avctx)
3184 HEVCContext *s = avctx->priv_data;
3189 av_freep(&s->md5_ctx);
3191 for(i=0; i < s->nals_allocated; i++) {
3192 av_freep(&s->skipped_bytes_pos_nal[i]);
3194 av_freep(&s->skipped_bytes_pos_size_nal);
3195 av_freep(&s->skipped_bytes_nal);
3196 av_freep(&s->skipped_bytes_pos_nal);
3198 av_freep(&s->cabac_state);
3200 for (i = 0; i < 3; i++) {
3201 av_freep(&s->sao_pixel_buffer_h[i]);
3202 av_freep(&s->sao_pixel_buffer_v[i]);
3204 av_frame_free(&s->output_frame);
3206 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3207 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3208 av_frame_free(&s->DPB[i].frame);
3211 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++)
3212 av_buffer_unref(&s->vps_list[i]);
3213 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++)
3214 av_buffer_unref(&s->sps_list[i]);
3215 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
3216 av_buffer_unref(&s->pps_list[i]);
3221 av_buffer_unref(&s->current_sps);
3223 av_freep(&s->sh.entry_point_offset);
3224 av_freep(&s->sh.offset);
3225 av_freep(&s->sh.size);
3227 for (i = 1; i < s->threads_number; i++) {
3228 HEVCLocalContext *lc = s->HEVClcList[i];
3230 av_freep(&s->HEVClcList[i]);
3231 av_freep(&s->sList[i]);
3234 if (s->HEVClc == s->HEVClcList[0])
3236 av_freep(&s->HEVClcList[0]);
3238 for (i = 0; i < s->nals_allocated; i++)
3239 av_freep(&s->nals[i].rbsp_buffer);
3241 s->nals_allocated = 0;
3246 static av_cold int hevc_init_context(AVCodecContext *avctx)
3248 HEVCContext *s = avctx->priv_data;
3253 s->HEVClc = av_mallocz(sizeof(HEVCLocalContext));
3256 s->HEVClcList[0] = s->HEVClc;
3259 s->cabac_state = av_malloc(HEVC_CONTEXTS);
3260 if (!s->cabac_state)
3263 s->output_frame = av_frame_alloc();
3264 if (!s->output_frame)
3267 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3268 s->DPB[i].frame = av_frame_alloc();
3269 if (!s->DPB[i].frame)
3271 s->DPB[i].tf.f = s->DPB[i].frame;
3274 s->max_ra = INT_MAX;
3276 s->md5_ctx = av_md5_alloc();
3280 ff_bswapdsp_init(&s->bdsp);
3282 s->context_initialized = 1;
3288 hevc_decode_free(avctx);
3289 return AVERROR(ENOMEM);
3292 static int hevc_update_thread_context(AVCodecContext *dst,
3293 const AVCodecContext *src)
3295 HEVCContext *s = dst->priv_data;
3296 HEVCContext *s0 = src->priv_data;
3299 if (!s->context_initialized) {
3300 ret = hevc_init_context(dst);
3305 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3306 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3307 if (s0->DPB[i].frame->buf[0]) {
3308 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3314 if (s->sps != s0->sps)
3316 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++) {
3317 av_buffer_unref(&s->vps_list[i]);
3318 if (s0->vps_list[i]) {
3319 s->vps_list[i] = av_buffer_ref(s0->vps_list[i]);
3320 if (!s->vps_list[i])
3321 return AVERROR(ENOMEM);
3325 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++) {
3326 av_buffer_unref(&s->sps_list[i]);
3327 if (s0->sps_list[i]) {
3328 s->sps_list[i] = av_buffer_ref(s0->sps_list[i]);
3329 if (!s->sps_list[i])
3330 return AVERROR(ENOMEM);
3334 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++) {
3335 av_buffer_unref(&s->pps_list[i]);
3336 if (s0->pps_list[i]) {
3337 s->pps_list[i] = av_buffer_ref(s0->pps_list[i]);
3338 if (!s->pps_list[i])
3339 return AVERROR(ENOMEM);
3343 av_buffer_unref(&s->current_sps);
3344 if (s0->current_sps) {
3345 s->current_sps = av_buffer_ref(s0->current_sps);
3346 if (!s->current_sps)
3347 return AVERROR(ENOMEM);
3350 if (s->sps != s0->sps)
3351 if ((ret = set_sps(s, s0->sps, src->pix_fmt)) < 0)
3354 s->seq_decode = s0->seq_decode;
3355 s->seq_output = s0->seq_output;
3356 s->pocTid0 = s0->pocTid0;
3357 s->max_ra = s0->max_ra;
3360 s->is_nalff = s0->is_nalff;
3361 s->nal_length_size = s0->nal_length_size;
3363 s->threads_number = s0->threads_number;
3364 s->threads_type = s0->threads_type;
3367 s->seq_decode = (s->seq_decode + 1) & 0xff;
3368 s->max_ra = INT_MAX;
3374 static int hevc_decode_extradata(HEVCContext *s)
3376 AVCodecContext *avctx = s->avctx;
3380 bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
3382 if (avctx->extradata_size > 3 &&
3383 (avctx->extradata[0] || avctx->extradata[1] ||
3384 avctx->extradata[2] > 1)) {
3385 /* It seems the extradata is encoded as hvcC format.
3386 * Temporarily, we support configurationVersion==0 until 14496-15 3rd
3387 * is finalized. When finalized, configurationVersion will be 1 and we
3388 * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
3389 int i, j, num_arrays, nal_len_size;
3393 bytestream2_skip(&gb, 21);
3394 nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
3395 num_arrays = bytestream2_get_byte(&gb);
3397 /* nal units in the hvcC always have length coded with 2 bytes,
3398 * so put a fake nal_length_size = 2 while parsing them */
3399 s->nal_length_size = 2;
3401 /* Decode nal units from hvcC. */
3402 for (i = 0; i < num_arrays; i++) {
3403 int type = bytestream2_get_byte(&gb) & 0x3f;
3404 int cnt = bytestream2_get_be16(&gb);
3406 for (j = 0; j < cnt; j++) {
3407 // +2 for the nal size field
3408 int nalsize = bytestream2_peek_be16(&gb) + 2;
3409 if (bytestream2_get_bytes_left(&gb) < nalsize) {
3410 av_log(s->avctx, AV_LOG_ERROR,
3411 "Invalid NAL unit size in extradata.\n");
3412 return AVERROR_INVALIDDATA;
3415 ret = decode_nal_units(s, gb.buffer, nalsize);
3417 av_log(avctx, AV_LOG_ERROR,
3418 "Decoding nal unit %d %d from hvcC failed\n",
3422 bytestream2_skip(&gb, nalsize);
3426 /* Now store right nal length size, that will be used to parse
3428 s->nal_length_size = nal_len_size;
3431 ret = decode_nal_units(s, avctx->extradata, avctx->extradata_size);
3436 /* export stream parameters from the first SPS */
3437 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++) {
3438 if (s->sps_list[i]) {
3439 const HEVCSPS *sps = (const HEVCSPS*)s->sps_list[i]->data;
3440 export_stream_params(s->avctx, s, sps);
3448 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3450 HEVCContext *s = avctx->priv_data;
3453 ff_init_cabac_states();
3455 avctx->internal->allocate_progress = 1;
3457 ret = hevc_init_context(avctx);
3461 s->enable_parallel_tiles = 0;
3462 s->picture_struct = 0;
3464 if(avctx->active_thread_type & FF_THREAD_SLICE)
3465 s->threads_number = avctx->thread_count;
3467 s->threads_number = 1;
3469 if (avctx->extradata_size > 0 && avctx->extradata) {
3470 ret = hevc_decode_extradata(s);
3472 hevc_decode_free(avctx);
3477 if((avctx->active_thread_type & FF_THREAD_FRAME) && avctx->thread_count > 1)
3478 s->threads_type = FF_THREAD_FRAME;
3480 s->threads_type = FF_THREAD_SLICE;
3485 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3487 HEVCContext *s = avctx->priv_data;
3490 memset(s, 0, sizeof(*s));
3492 ret = hevc_init_context(avctx);
3499 static void hevc_decode_flush(AVCodecContext *avctx)
3501 HEVCContext *s = avctx->priv_data;
3502 ff_hevc_flush_dpb(s);
3503 s->max_ra = INT_MAX;
3506 #define OFFSET(x) offsetof(HEVCContext, x)
3507 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3509 static const AVProfile profiles[] = {
3510 { FF_PROFILE_HEVC_MAIN, "Main" },
3511 { FF_PROFILE_HEVC_MAIN_10, "Main 10" },
3512 { FF_PROFILE_HEVC_MAIN_STILL_PICTURE, "Main Still Picture" },
3513 { FF_PROFILE_HEVC_REXT, "Rext" },
3514 { FF_PROFILE_UNKNOWN },
3517 static const AVOption options[] = {
3518 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3519 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3520 { "strict-displaywin", "stricly apply default display window size", OFFSET(apply_defdispwin),
3521 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3525 static const AVClass hevc_decoder_class = {
3526 .class_name = "HEVC decoder",
3527 .item_name = av_default_item_name,
3529 .version = LIBAVUTIL_VERSION_INT,
3532 AVCodec ff_hevc_decoder = {
3534 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3535 .type = AVMEDIA_TYPE_VIDEO,
3536 .id = AV_CODEC_ID_HEVC,
3537 .priv_data_size = sizeof(HEVCContext),
3538 .priv_class = &hevc_decoder_class,
3539 .init = hevc_decode_init,
3540 .close = hevc_decode_free,
3541 .decode = hevc_decode_frame,
3542 .flush = hevc_decode_flush,
3543 .update_thread_context = hevc_update_thread_context,
3544 .init_thread_copy = hevc_init_thread_copy,
3545 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY |
3546 CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS,
3547 .profiles = NULL_IF_CONFIG_SMALL(profiles),