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_c(luma_log2_weight_denom, 0, 7);
152 if (s->sps->chroma_format_idc != 0) {
153 int delta = get_se_golomb(gb);
154 s->sh.chroma_log2_weight_denom = av_clip(s->sh.luma_log2_weight_denom + delta, 0, 7);
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 int get_buffer_sao(HEVCContext *s, AVFrame *frame, const HEVCSPS *sps)
287 frame->width = FFALIGN(s->avctx->coded_width + 2, FF_INPUT_BUFFER_PADDING_SIZE);
288 frame->height = s->avctx->coded_height + 3;
289 if ((ret = ff_get_buffer(s->avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
291 for (i = 0; frame->data[i]; i++) {
292 int offset = frame->linesize[i] + FF_INPUT_BUFFER_PADDING_SIZE;
293 frame->data[i] += offset;
295 frame->width = s->avctx->coded_width;
296 frame->height = s->avctx->coded_height;
301 static int set_sps(HEVCContext *s, const HEVCSPS *sps)
303 #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL)
304 enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
306 unsigned int num = 0, den = 0;
309 ret = pic_arrays_init(s, sps);
313 s->avctx->coded_width = sps->width;
314 s->avctx->coded_height = sps->height;
315 s->avctx->width = sps->output_width;
316 s->avctx->height = sps->output_height;
317 s->avctx->has_b_frames = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics;
319 if (sps->pix_fmt == AV_PIX_FMT_YUV420P || sps->pix_fmt == AV_PIX_FMT_YUVJ420P) {
320 #if CONFIG_HEVC_DXVA2_HWACCEL
321 *fmt++ = AV_PIX_FMT_DXVA2_VLD;
325 *fmt++ = sps->pix_fmt;
326 *fmt = AV_PIX_FMT_NONE;
328 ret = ff_thread_get_format(s->avctx, pix_fmts);
331 s->avctx->pix_fmt = ret;
333 ff_set_sar(s->avctx, sps->vui.sar);
335 if (sps->vui.video_signal_type_present_flag)
336 s->avctx->color_range = sps->vui.video_full_range_flag ? AVCOL_RANGE_JPEG
339 s->avctx->color_range = AVCOL_RANGE_MPEG;
341 if (sps->vui.colour_description_present_flag) {
342 s->avctx->color_primaries = sps->vui.colour_primaries;
343 s->avctx->color_trc = sps->vui.transfer_characteristic;
344 s->avctx->colorspace = sps->vui.matrix_coeffs;
346 s->avctx->color_primaries = AVCOL_PRI_UNSPECIFIED;
347 s->avctx->color_trc = AVCOL_TRC_UNSPECIFIED;
348 s->avctx->colorspace = AVCOL_SPC_UNSPECIFIED;
351 ff_hevc_pred_init(&s->hpc, sps->bit_depth);
352 ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
353 ff_videodsp_init (&s->vdsp, sps->bit_depth);
355 if (sps->sao_enabled && !s->avctx->hwaccel) {
356 av_frame_unref(s->tmp_frame);
357 ret = get_buffer_sao(s, s->tmp_frame, sps);
358 s->sao_frame = s->tmp_frame;
362 s->vps = (HEVCVPS*) s->vps_list[s->sps->vps_id]->data;
364 if (s->vps->vps_timing_info_present_flag) {
365 num = s->vps->vps_num_units_in_tick;
366 den = s->vps->vps_time_scale;
367 } else if (sps->vui.vui_timing_info_present_flag) {
368 num = sps->vui.vui_num_units_in_tick;
369 den = sps->vui.vui_time_scale;
372 if (num != 0 && den != 0)
373 av_reduce(&s->avctx->framerate.den, &s->avctx->framerate.num,
384 static int hls_slice_header(HEVCContext *s)
386 GetBitContext *gb = &s->HEVClc->gb;
387 SliceHeader *sh = &s->sh;
391 sh->first_slice_in_pic_flag = get_bits1(gb);
392 if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
393 s->seq_decode = (s->seq_decode + 1) & 0xff;
396 ff_hevc_clear_refs(s);
398 sh->no_output_of_prior_pics_flag = 0;
400 sh->no_output_of_prior_pics_flag = get_bits1(gb);
402 sh->pps_id = get_ue_golomb_long(gb);
403 if (sh->pps_id >= MAX_PPS_COUNT || !s->pps_list[sh->pps_id]) {
404 av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
405 return AVERROR_INVALIDDATA;
407 if (!sh->first_slice_in_pic_flag &&
408 s->pps != (HEVCPPS*)s->pps_list[sh->pps_id]->data) {
409 av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
410 return AVERROR_INVALIDDATA;
412 s->pps = (HEVCPPS*)s->pps_list[sh->pps_id]->data;
413 if (s->nal_unit_type == NAL_CRA_NUT && s->last_eos == 1)
414 sh->no_output_of_prior_pics_flag = 1;
416 if (s->sps != (HEVCSPS*)s->sps_list[s->pps->sps_id]->data) {
417 const HEVCSPS* last_sps = s->sps;
418 s->sps = (HEVCSPS*)s->sps_list[s->pps->sps_id]->data;
419 if (last_sps && IS_IRAP(s) && s->nal_unit_type != NAL_CRA_NUT) {
420 if (s->sps->width != last_sps->width || s->sps->height != last_sps->height ||
421 s->sps->temporal_layer[s->sps->max_sub_layers - 1].max_dec_pic_buffering !=
422 last_sps->temporal_layer[last_sps->max_sub_layers - 1].max_dec_pic_buffering)
423 sh->no_output_of_prior_pics_flag = 0;
425 ff_hevc_clear_refs(s);
426 ret = set_sps(s, s->sps);
430 s->seq_decode = (s->seq_decode + 1) & 0xff;
434 s->avctx->profile = s->sps->ptl.general_ptl.profile_idc;
435 s->avctx->level = s->sps->ptl.general_ptl.level_idc;
437 sh->dependent_slice_segment_flag = 0;
438 if (!sh->first_slice_in_pic_flag) {
439 int slice_address_length;
441 if (s->pps->dependent_slice_segments_enabled_flag)
442 sh->dependent_slice_segment_flag = get_bits1(gb);
444 slice_address_length = av_ceil_log2(s->sps->ctb_width *
446 sh->slice_segment_addr = get_bits(gb, slice_address_length);
447 if (sh->slice_segment_addr >= s->sps->ctb_width * s->sps->ctb_height) {
448 av_log(s->avctx, AV_LOG_ERROR,
449 "Invalid slice segment address: %u.\n",
450 sh->slice_segment_addr);
451 return AVERROR_INVALIDDATA;
454 if (!sh->dependent_slice_segment_flag) {
455 sh->slice_addr = sh->slice_segment_addr;
459 sh->slice_segment_addr = sh->slice_addr = 0;
461 s->slice_initialized = 0;
464 if (!sh->dependent_slice_segment_flag) {
465 s->slice_initialized = 0;
467 for (i = 0; i < s->pps->num_extra_slice_header_bits; i++)
468 skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
470 sh->slice_type = get_ue_golomb_long(gb);
471 if (!(sh->slice_type == I_SLICE ||
472 sh->slice_type == P_SLICE ||
473 sh->slice_type == B_SLICE)) {
474 av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
476 return AVERROR_INVALIDDATA;
478 if (IS_IRAP(s) && sh->slice_type != I_SLICE) {
479 av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
480 return AVERROR_INVALIDDATA;
483 // when flag is not present, picture is inferred to be output
484 sh->pic_output_flag = 1;
485 if (s->pps->output_flag_present_flag)
486 sh->pic_output_flag = get_bits1(gb);
488 if (s->sps->separate_colour_plane_flag)
489 sh->colour_plane_id = get_bits(gb, 2);
494 sh->pic_order_cnt_lsb = get_bits(gb, s->sps->log2_max_poc_lsb);
495 poc = ff_hevc_compute_poc(s, sh->pic_order_cnt_lsb);
496 if (!sh->first_slice_in_pic_flag && poc != s->poc) {
497 av_log(s->avctx, AV_LOG_WARNING,
498 "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
499 if (s->avctx->err_recognition & AV_EF_EXPLODE)
500 return AVERROR_INVALIDDATA;
505 sh->short_term_ref_pic_set_sps_flag = get_bits1(gb);
506 if (!sh->short_term_ref_pic_set_sps_flag) {
507 int pos = get_bits_left(gb);
508 ret = ff_hevc_decode_short_term_rps(s, &sh->slice_rps, s->sps, 1);
512 sh->short_term_ref_pic_set_size = pos - get_bits_left(gb);
513 sh->short_term_rps = &sh->slice_rps;
515 int numbits, rps_idx;
517 if (!s->sps->nb_st_rps) {
518 av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
519 return AVERROR_INVALIDDATA;
522 numbits = av_ceil_log2(s->sps->nb_st_rps);
523 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
524 sh->short_term_rps = &s->sps->st_rps[rps_idx];
527 ret = decode_lt_rps(s, &sh->long_term_rps, gb);
529 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
530 if (s->avctx->err_recognition & AV_EF_EXPLODE)
531 return AVERROR_INVALIDDATA;
534 if (s->sps->sps_temporal_mvp_enabled_flag)
535 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
537 sh->slice_temporal_mvp_enabled_flag = 0;
539 s->sh.short_term_rps = NULL;
544 if (s->temporal_id == 0 &&
545 s->nal_unit_type != NAL_TRAIL_N &&
546 s->nal_unit_type != NAL_TSA_N &&
547 s->nal_unit_type != NAL_STSA_N &&
548 s->nal_unit_type != NAL_RADL_N &&
549 s->nal_unit_type != NAL_RADL_R &&
550 s->nal_unit_type != NAL_RASL_N &&
551 s->nal_unit_type != NAL_RASL_R)
554 if (s->sps->sao_enabled) {
555 sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
556 if (s->sps->chroma_format_idc) {
557 sh->slice_sample_adaptive_offset_flag[1] =
558 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
561 sh->slice_sample_adaptive_offset_flag[0] = 0;
562 sh->slice_sample_adaptive_offset_flag[1] = 0;
563 sh->slice_sample_adaptive_offset_flag[2] = 0;
566 sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
567 if (sh->slice_type == P_SLICE || sh->slice_type == B_SLICE) {
570 sh->nb_refs[L0] = s->pps->num_ref_idx_l0_default_active;
571 if (sh->slice_type == B_SLICE)
572 sh->nb_refs[L1] = s->pps->num_ref_idx_l1_default_active;
574 if (get_bits1(gb)) { // num_ref_idx_active_override_flag
575 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
576 if (sh->slice_type == B_SLICE)
577 sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
579 if (sh->nb_refs[L0] > MAX_REFS || sh->nb_refs[L1] > MAX_REFS) {
580 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
581 sh->nb_refs[L0], sh->nb_refs[L1]);
582 return AVERROR_INVALIDDATA;
585 sh->rpl_modification_flag[0] = 0;
586 sh->rpl_modification_flag[1] = 0;
587 nb_refs = ff_hevc_frame_nb_refs(s);
589 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
590 return AVERROR_INVALIDDATA;
593 if (s->pps->lists_modification_present_flag && nb_refs > 1) {
594 sh->rpl_modification_flag[0] = get_bits1(gb);
595 if (sh->rpl_modification_flag[0]) {
596 for (i = 0; i < sh->nb_refs[L0]; i++)
597 sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
600 if (sh->slice_type == B_SLICE) {
601 sh->rpl_modification_flag[1] = get_bits1(gb);
602 if (sh->rpl_modification_flag[1] == 1)
603 for (i = 0; i < sh->nb_refs[L1]; i++)
604 sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
608 if (sh->slice_type == B_SLICE)
609 sh->mvd_l1_zero_flag = get_bits1(gb);
611 if (s->pps->cabac_init_present_flag)
612 sh->cabac_init_flag = get_bits1(gb);
614 sh->cabac_init_flag = 0;
616 sh->collocated_ref_idx = 0;
617 if (sh->slice_temporal_mvp_enabled_flag) {
618 sh->collocated_list = L0;
619 if (sh->slice_type == B_SLICE)
620 sh->collocated_list = !get_bits1(gb);
622 if (sh->nb_refs[sh->collocated_list] > 1) {
623 sh->collocated_ref_idx = get_ue_golomb_long(gb);
624 if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
625 av_log(s->avctx, AV_LOG_ERROR,
626 "Invalid collocated_ref_idx: %d.\n",
627 sh->collocated_ref_idx);
628 return AVERROR_INVALIDDATA;
633 if ((s->pps->weighted_pred_flag && sh->slice_type == P_SLICE) ||
634 (s->pps->weighted_bipred_flag && sh->slice_type == B_SLICE)) {
635 pred_weight_table(s, gb);
638 sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
639 if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
640 av_log(s->avctx, AV_LOG_ERROR,
641 "Invalid number of merging MVP candidates: %d.\n",
642 sh->max_num_merge_cand);
643 return AVERROR_INVALIDDATA;
647 sh->slice_qp_delta = get_se_golomb(gb);
649 if (s->pps->pic_slice_level_chroma_qp_offsets_present_flag) {
650 sh->slice_cb_qp_offset = get_se_golomb(gb);
651 sh->slice_cr_qp_offset = get_se_golomb(gb);
653 sh->slice_cb_qp_offset = 0;
654 sh->slice_cr_qp_offset = 0;
657 if (s->pps->chroma_qp_offset_list_enabled_flag)
658 sh->cu_chroma_qp_offset_enabled_flag = get_bits1(gb);
660 sh->cu_chroma_qp_offset_enabled_flag = 0;
662 if (s->pps->deblocking_filter_control_present_flag) {
663 int deblocking_filter_override_flag = 0;
665 if (s->pps->deblocking_filter_override_enabled_flag)
666 deblocking_filter_override_flag = get_bits1(gb);
668 if (deblocking_filter_override_flag) {
669 sh->disable_deblocking_filter_flag = get_bits1(gb);
670 if (!sh->disable_deblocking_filter_flag) {
671 sh->beta_offset = get_se_golomb(gb) * 2;
672 sh->tc_offset = get_se_golomb(gb) * 2;
675 sh->disable_deblocking_filter_flag = s->pps->disable_dbf;
676 sh->beta_offset = s->pps->beta_offset;
677 sh->tc_offset = s->pps->tc_offset;
680 sh->disable_deblocking_filter_flag = 0;
685 if (s->pps->seq_loop_filter_across_slices_enabled_flag &&
686 (sh->slice_sample_adaptive_offset_flag[0] ||
687 sh->slice_sample_adaptive_offset_flag[1] ||
688 !sh->disable_deblocking_filter_flag)) {
689 sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
691 sh->slice_loop_filter_across_slices_enabled_flag = s->pps->seq_loop_filter_across_slices_enabled_flag;
693 } else if (!s->slice_initialized) {
694 av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
695 return AVERROR_INVALIDDATA;
698 sh->num_entry_point_offsets = 0;
699 if (s->pps->tiles_enabled_flag || s->pps->entropy_coding_sync_enabled_flag) {
700 sh->num_entry_point_offsets = get_ue_golomb_long(gb);
701 if (sh->num_entry_point_offsets > 0) {
702 int offset_len = get_ue_golomb_long(gb) + 1;
703 int segments = offset_len >> 4;
704 int rest = (offset_len & 15);
705 av_freep(&sh->entry_point_offset);
706 av_freep(&sh->offset);
708 sh->entry_point_offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
709 sh->offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
710 sh->size = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
711 if (!sh->entry_point_offset || !sh->offset || !sh->size) {
712 sh->num_entry_point_offsets = 0;
713 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate memory\n");
714 return AVERROR(ENOMEM);
716 for (i = 0; i < sh->num_entry_point_offsets; i++) {
718 for (j = 0; j < segments; j++) {
720 val += get_bits(gb, 16);
724 val += get_bits(gb, rest);
726 sh->entry_point_offset[i] = val + 1; // +1; // +1 to get the size
728 if (s->threads_number > 1 && (s->pps->num_tile_rows > 1 || s->pps->num_tile_columns > 1)) {
729 s->enable_parallel_tiles = 0; // TODO: you can enable tiles in parallel here
730 s->threads_number = 1;
732 s->enable_parallel_tiles = 0;
734 s->enable_parallel_tiles = 0;
737 if (s->pps->slice_header_extension_present_flag) {
738 unsigned int length = get_ue_golomb_long(gb);
739 if (length*8LL > get_bits_left(gb)) {
740 av_log(s->avctx, AV_LOG_ERROR, "too many slice_header_extension_data_bytes\n");
741 return AVERROR_INVALIDDATA;
743 for (i = 0; i < length; i++)
744 skip_bits(gb, 8); // slice_header_extension_data_byte
747 // Inferred parameters
748 sh->slice_qp = 26U + s->pps->pic_init_qp_minus26 + sh->slice_qp_delta;
749 if (sh->slice_qp > 51 ||
750 sh->slice_qp < -s->sps->qp_bd_offset) {
751 av_log(s->avctx, AV_LOG_ERROR,
752 "The slice_qp %d is outside the valid range "
755 -s->sps->qp_bd_offset);
756 return AVERROR_INVALIDDATA;
759 sh->slice_ctb_addr_rs = sh->slice_segment_addr;
761 if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) {
762 av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
763 return AVERROR_INVALIDDATA;
766 if (get_bits_left(gb) < 0) {
767 av_log(s->avctx, AV_LOG_ERROR,
768 "Overread slice header by %d bits\n", -get_bits_left(gb));
769 return AVERROR_INVALIDDATA;
772 s->HEVClc->first_qp_group = !s->sh.dependent_slice_segment_flag;
774 if (!s->pps->cu_qp_delta_enabled_flag)
775 s->HEVClc->qp_y = s->sh.slice_qp;
777 s->slice_initialized = 1;
778 s->HEVClc->tu.cu_qp_offset_cb = 0;
779 s->HEVClc->tu.cu_qp_offset_cr = 0;
784 #define CTB(tab, x, y) ((tab)[(y) * s->sps->ctb_width + (x)])
786 #define SET_SAO(elem, value) \
788 if (!sao_merge_up_flag && !sao_merge_left_flag) \
790 else if (sao_merge_left_flag) \
791 sao->elem = CTB(s->sao, rx-1, ry).elem; \
792 else if (sao_merge_up_flag) \
793 sao->elem = CTB(s->sao, rx, ry-1).elem; \
798 static void hls_sao_param(HEVCContext *s, int rx, int ry)
800 HEVCLocalContext *lc = s->HEVClc;
801 int sao_merge_left_flag = 0;
802 int sao_merge_up_flag = 0;
803 SAOParams *sao = &CTB(s->sao, rx, ry);
806 if (s->sh.slice_sample_adaptive_offset_flag[0] ||
807 s->sh.slice_sample_adaptive_offset_flag[1]) {
809 if (lc->ctb_left_flag)
810 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
812 if (ry > 0 && !sao_merge_left_flag) {
814 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
818 for (c_idx = 0; c_idx < (s->sps->chroma_format_idc ? 3 : 1); c_idx++) {
819 int log2_sao_offset_scale = c_idx == 0 ? s->pps->log2_sao_offset_scale_luma :
820 s->pps->log2_sao_offset_scale_chroma;
822 if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
823 sao->type_idx[c_idx] = SAO_NOT_APPLIED;
828 sao->type_idx[2] = sao->type_idx[1];
829 sao->eo_class[2] = sao->eo_class[1];
831 SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
834 if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
837 for (i = 0; i < 4; i++)
838 SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
840 if (sao->type_idx[c_idx] == SAO_BAND) {
841 for (i = 0; i < 4; i++) {
842 if (sao->offset_abs[c_idx][i]) {
843 SET_SAO(offset_sign[c_idx][i],
844 ff_hevc_sao_offset_sign_decode(s));
846 sao->offset_sign[c_idx][i] = 0;
849 SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
850 } else if (c_idx != 2) {
851 SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
854 // Inferred parameters
855 sao->offset_val[c_idx][0] = 0;
856 for (i = 0; i < 4; i++) {
857 sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i];
858 if (sao->type_idx[c_idx] == SAO_EDGE) {
860 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
861 } else if (sao->offset_sign[c_idx][i]) {
862 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
864 sao->offset_val[c_idx][i + 1] <<= log2_sao_offset_scale;
872 static int hls_cross_component_pred(HEVCContext *s, int idx) {
873 HEVCLocalContext *lc = s->HEVClc;
874 int log2_res_scale_abs_plus1 = ff_hevc_log2_res_scale_abs(s, idx);
876 if (log2_res_scale_abs_plus1 != 0) {
877 int res_scale_sign_flag = ff_hevc_res_scale_sign_flag(s, idx);
878 lc->tu.res_scale_val = (1 << (log2_res_scale_abs_plus1 - 1)) *
879 (1 - 2 * res_scale_sign_flag);
881 lc->tu.res_scale_val = 0;
888 static int hls_transform_unit(HEVCContext *s, int x0, int y0,
889 int xBase, int yBase, int cb_xBase, int cb_yBase,
890 int log2_cb_size, int log2_trafo_size,
891 int blk_idx, int cbf_luma, int *cbf_cb, int *cbf_cr)
893 HEVCLocalContext *lc = s->HEVClc;
894 const int log2_trafo_size_c = log2_trafo_size - s->sps->hshift[1];
897 if (lc->cu.pred_mode == MODE_INTRA) {
898 int trafo_size = 1 << log2_trafo_size;
899 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
901 s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
904 if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
905 (s->sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
906 int scan_idx = SCAN_DIAG;
907 int scan_idx_c = SCAN_DIAG;
908 int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
909 (s->sps->chroma_format_idc == 2 &&
910 (cbf_cb[1] || cbf_cr[1]));
912 if (s->pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
913 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
914 if (lc->tu.cu_qp_delta != 0)
915 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
916 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
917 lc->tu.is_cu_qp_delta_coded = 1;
919 if (lc->tu.cu_qp_delta < -(26 + s->sps->qp_bd_offset / 2) ||
920 lc->tu.cu_qp_delta > (25 + s->sps->qp_bd_offset / 2)) {
921 av_log(s->avctx, AV_LOG_ERROR,
922 "The cu_qp_delta %d is outside the valid range "
925 -(26 + s->sps->qp_bd_offset / 2),
926 (25 + s->sps->qp_bd_offset / 2));
927 return AVERROR_INVALIDDATA;
930 ff_hevc_set_qPy(s, cb_xBase, cb_yBase, log2_cb_size);
933 if (s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
934 !lc->cu.cu_transquant_bypass_flag && !lc->tu.is_cu_chroma_qp_offset_coded) {
935 int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(s);
936 if (cu_chroma_qp_offset_flag) {
937 int cu_chroma_qp_offset_idx = 0;
938 if (s->pps->chroma_qp_offset_list_len_minus1 > 0) {
939 cu_chroma_qp_offset_idx = ff_hevc_cu_chroma_qp_offset_idx(s);
940 av_log(s->avctx, AV_LOG_ERROR,
941 "cu_chroma_qp_offset_idx not yet tested.\n");
943 lc->tu.cu_qp_offset_cb = s->pps->cb_qp_offset_list[cu_chroma_qp_offset_idx];
944 lc->tu.cu_qp_offset_cr = s->pps->cr_qp_offset_list[cu_chroma_qp_offset_idx];
946 lc->tu.cu_qp_offset_cb = 0;
947 lc->tu.cu_qp_offset_cr = 0;
949 lc->tu.is_cu_chroma_qp_offset_coded = 1;
952 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
953 if (lc->tu.intra_pred_mode >= 6 &&
954 lc->tu.intra_pred_mode <= 14) {
955 scan_idx = SCAN_VERT;
956 } else if (lc->tu.intra_pred_mode >= 22 &&
957 lc->tu.intra_pred_mode <= 30) {
958 scan_idx = SCAN_HORIZ;
961 if (lc->tu.intra_pred_mode_c >= 6 &&
962 lc->tu.intra_pred_mode_c <= 14) {
963 scan_idx_c = SCAN_VERT;
964 } else if (lc->tu.intra_pred_mode_c >= 22 &&
965 lc->tu.intra_pred_mode_c <= 30) {
966 scan_idx_c = SCAN_HORIZ;
973 ff_hevc_hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
974 if (s->sps->chroma_format_idc && (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3)) {
975 int trafo_size_h = 1 << (log2_trafo_size_c + s->sps->hshift[1]);
976 int trafo_size_v = 1 << (log2_trafo_size_c + s->sps->vshift[1]);
977 lc->tu.cross_pf = (s->pps->cross_component_prediction_enabled_flag && cbf_luma &&
978 (lc->cu.pred_mode == MODE_INTER ||
979 (lc->tu.chroma_mode_c == 4)));
981 if (lc->tu.cross_pf) {
982 hls_cross_component_pred(s, 0);
984 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
985 if (lc->cu.pred_mode == MODE_INTRA) {
986 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
987 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 1);
990 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
991 log2_trafo_size_c, scan_idx_c, 1);
993 if (lc->tu.cross_pf) {
994 ptrdiff_t stride = s->frame->linesize[1];
995 int hshift = s->sps->hshift[1];
996 int vshift = s->sps->vshift[1];
997 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
998 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
999 int size = 1 << log2_trafo_size_c;
1001 uint8_t *dst = &s->frame->data[1][(y0 >> vshift) * stride +
1002 ((x0 >> hshift) << s->sps->pixel_shift)];
1003 for (i = 0; i < (size * size); i++) {
1004 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1006 s->hevcdsp.transform_add[log2_trafo_size_c-2](dst, coeffs, stride);
1010 if (lc->tu.cross_pf) {
1011 hls_cross_component_pred(s, 1);
1013 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1014 if (lc->cu.pred_mode == MODE_INTRA) {
1015 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1016 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 2);
1019 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1020 log2_trafo_size_c, scan_idx_c, 2);
1022 if (lc->tu.cross_pf) {
1023 ptrdiff_t stride = s->frame->linesize[2];
1024 int hshift = s->sps->hshift[2];
1025 int vshift = s->sps->vshift[2];
1026 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1027 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1028 int size = 1 << log2_trafo_size_c;
1030 uint8_t *dst = &s->frame->data[2][(y0 >> vshift) * stride +
1031 ((x0 >> hshift) << s->sps->pixel_shift)];
1032 for (i = 0; i < (size * size); i++) {
1033 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1035 s->hevcdsp.transform_add[log2_trafo_size_c-2](dst, coeffs, stride);
1038 } else if (s->sps->chroma_format_idc && blk_idx == 3) {
1039 int trafo_size_h = 1 << (log2_trafo_size + 1);
1040 int trafo_size_v = 1 << (log2_trafo_size + s->sps->vshift[1]);
1041 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1042 if (lc->cu.pred_mode == MODE_INTRA) {
1043 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1044 trafo_size_h, trafo_size_v);
1045 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 1);
1048 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1049 log2_trafo_size, scan_idx_c, 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), 2);
1058 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1059 log2_trafo_size, scan_idx_c, 2);
1062 } else if (s->sps->chroma_format_idc && lc->cu.pred_mode == MODE_INTRA) {
1063 if (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3) {
1064 int trafo_size_h = 1 << (log2_trafo_size_c + s->sps->hshift[1]);
1065 int trafo_size_v = 1 << (log2_trafo_size_c + s->sps->vshift[1]);
1066 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size_h, trafo_size_v);
1067 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 1);
1068 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 2);
1069 if (s->sps->chroma_format_idc == 2) {
1070 ff_hevc_set_neighbour_available(s, x0, y0 + (1 << log2_trafo_size_c),
1071 trafo_size_h, trafo_size_v);
1072 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 1);
1073 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 2);
1075 } else if (blk_idx == 3) {
1076 int trafo_size_h = 1 << (log2_trafo_size + 1);
1077 int trafo_size_v = 1 << (log2_trafo_size + s->sps->vshift[1]);
1078 ff_hevc_set_neighbour_available(s, xBase, yBase,
1079 trafo_size_h, trafo_size_v);
1080 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1081 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1082 if (s->sps->chroma_format_idc == 2) {
1083 ff_hevc_set_neighbour_available(s, xBase, yBase + (1 << (log2_trafo_size)),
1084 trafo_size_h, trafo_size_v);
1085 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 1);
1086 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 2);
1094 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1096 int cb_size = 1 << log2_cb_size;
1097 int log2_min_pu_size = s->sps->log2_min_pu_size;
1099 int min_pu_width = s->sps->min_pu_width;
1100 int x_end = FFMIN(x0 + cb_size, s->sps->width);
1101 int y_end = FFMIN(y0 + cb_size, s->sps->height);
1104 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1105 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1106 s->is_pcm[i + j * min_pu_width] = 2;
1109 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1110 int xBase, int yBase, int cb_xBase, int cb_yBase,
1111 int log2_cb_size, int log2_trafo_size,
1112 int trafo_depth, int blk_idx,
1113 const int *base_cbf_cb, const int *base_cbf_cr)
1115 HEVCLocalContext *lc = s->HEVClc;
1116 uint8_t split_transform_flag;
1121 cbf_cb[0] = base_cbf_cb[0];
1122 cbf_cb[1] = base_cbf_cb[1];
1123 cbf_cr[0] = base_cbf_cr[0];
1124 cbf_cr[1] = base_cbf_cr[1];
1126 if (lc->cu.intra_split_flag) {
1127 if (trafo_depth == 1) {
1128 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1129 if (s->sps->chroma_format_idc == 3) {
1130 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[blk_idx];
1131 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[blk_idx];
1133 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1134 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1138 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[0];
1139 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1140 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1143 if (log2_trafo_size <= s->sps->log2_max_trafo_size &&
1144 log2_trafo_size > s->sps->log2_min_tb_size &&
1145 trafo_depth < lc->cu.max_trafo_depth &&
1146 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1147 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1149 int inter_split = s->sps->max_transform_hierarchy_depth_inter == 0 &&
1150 lc->cu.pred_mode == MODE_INTER &&
1151 lc->cu.part_mode != PART_2Nx2N &&
1154 split_transform_flag = log2_trafo_size > s->sps->log2_max_trafo_size ||
1155 (lc->cu.intra_split_flag && trafo_depth == 0) ||
1159 if (s->sps->chroma_format_idc && (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3)) {
1160 if (trafo_depth == 0 || cbf_cb[0]) {
1161 cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1162 if (s->sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1163 cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1167 if (trafo_depth == 0 || cbf_cr[0]) {
1168 cbf_cr[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1169 if (s->sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1170 cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1175 if (split_transform_flag) {
1176 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1177 const int x1 = x0 + trafo_size_split;
1178 const int y1 = y0 + trafo_size_split;
1180 #define SUBDIVIDE(x, y, idx) \
1182 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1183 log2_trafo_size - 1, trafo_depth + 1, idx, \
1189 SUBDIVIDE(x0, y0, 0);
1190 SUBDIVIDE(x1, y0, 1);
1191 SUBDIVIDE(x0, y1, 2);
1192 SUBDIVIDE(x1, y1, 3);
1196 int min_tu_size = 1 << s->sps->log2_min_tb_size;
1197 int log2_min_tu_size = s->sps->log2_min_tb_size;
1198 int min_tu_width = s->sps->min_tb_width;
1201 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1202 cbf_cb[0] || cbf_cr[0] ||
1203 (s->sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1204 cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1207 ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1208 log2_cb_size, log2_trafo_size,
1209 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1212 // TODO: store cbf_luma somewhere else
1215 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1216 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1217 int x_tu = (x0 + j) >> log2_min_tu_size;
1218 int y_tu = (y0 + i) >> log2_min_tu_size;
1219 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1222 if (!s->sh.disable_deblocking_filter_flag) {
1223 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1224 if (s->pps->transquant_bypass_enable_flag &&
1225 lc->cu.cu_transquant_bypass_flag)
1226 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1232 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1234 HEVCLocalContext *lc = s->HEVClc;
1236 int cb_size = 1 << log2_cb_size;
1237 int stride0 = s->frame->linesize[0];
1238 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->sps->pixel_shift)];
1239 int stride1 = s->frame->linesize[1];
1240 uint8_t *dst1 = &s->frame->data[1][(y0 >> s->sps->vshift[1]) * stride1 + ((x0 >> s->sps->hshift[1]) << s->sps->pixel_shift)];
1241 int stride2 = s->frame->linesize[2];
1242 uint8_t *dst2 = &s->frame->data[2][(y0 >> s->sps->vshift[2]) * stride2 + ((x0 >> s->sps->hshift[2]) << s->sps->pixel_shift)];
1244 int length = cb_size * cb_size * s->sps->pcm.bit_depth +
1245 (((cb_size >> s->sps->hshift[1]) * (cb_size >> s->sps->vshift[1])) +
1246 ((cb_size >> s->sps->hshift[2]) * (cb_size >> s->sps->vshift[2]))) *
1247 s->sps->pcm.bit_depth_chroma;
1248 const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1251 if (!s->sh.disable_deblocking_filter_flag)
1252 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1254 ret = init_get_bits(&gb, pcm, length);
1258 s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size, &gb, s->sps->pcm.bit_depth);
1259 if (s->sps->chroma_format_idc) {
1260 s->hevcdsp.put_pcm(dst1, stride1,
1261 cb_size >> s->sps->hshift[1],
1262 cb_size >> s->sps->vshift[1],
1263 &gb, s->sps->pcm.bit_depth_chroma);
1264 s->hevcdsp.put_pcm(dst2, stride2,
1265 cb_size >> s->sps->hshift[2],
1266 cb_size >> s->sps->vshift[2],
1267 &gb, s->sps->pcm.bit_depth_chroma);
1274 * 8.5.3.2.2.1 Luma sample unidirectional interpolation process
1276 * @param s HEVC decoding context
1277 * @param dst target buffer for block data at block position
1278 * @param dststride stride of the dst buffer
1279 * @param ref reference picture buffer at origin (0, 0)
1280 * @param mv motion vector (relative to block position) to get pixel data from
1281 * @param x_off horizontal position of block from origin (0, 0)
1282 * @param y_off vertical position of block from origin (0, 0)
1283 * @param block_w width of block
1284 * @param block_h height of block
1285 * @param luma_weight weighting factor applied to the luma prediction
1286 * @param luma_offset additive offset applied to the luma prediction value
1289 static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1290 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1291 int block_w, int block_h, int luma_weight, int luma_offset)
1293 HEVCLocalContext *lc = s->HEVClc;
1294 uint8_t *src = ref->data[0];
1295 ptrdiff_t srcstride = ref->linesize[0];
1296 int pic_width = s->sps->width;
1297 int pic_height = s->sps->height;
1300 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1301 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1302 int idx = ff_hevc_pel_weight[block_w];
1304 x_off += mv->x >> 2;
1305 y_off += mv->y >> 2;
1306 src += y_off * srcstride + (x_off << s->sps->pixel_shift);
1308 if (x_off < QPEL_EXTRA_BEFORE || y_off < QPEL_EXTRA_AFTER ||
1309 x_off >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1310 y_off >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1311 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1312 int offset = QPEL_EXTRA_BEFORE * srcstride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1313 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1315 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1316 edge_emu_stride, srcstride,
1317 block_w + QPEL_EXTRA,
1318 block_h + QPEL_EXTRA,
1319 x_off - QPEL_EXTRA_BEFORE, y_off - QPEL_EXTRA_BEFORE,
1320 pic_width, pic_height);
1321 src = lc->edge_emu_buffer + buf_offset;
1322 srcstride = edge_emu_stride;
1326 s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride, src, srcstride,
1327 block_h, mx, my, block_w);
1329 s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride, src, srcstride,
1330 block_h, s->sh.luma_log2_weight_denom,
1331 luma_weight, luma_offset, mx, my, block_w);
1335 * 8.5.3.2.2.1 Luma sample bidirectional interpolation process
1337 * @param s HEVC decoding context
1338 * @param dst target buffer for block data at block position
1339 * @param dststride stride of the dst buffer
1340 * @param ref0 reference picture0 buffer at origin (0, 0)
1341 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1342 * @param x_off horizontal position of block from origin (0, 0)
1343 * @param y_off vertical position of block from origin (0, 0)
1344 * @param block_w width of block
1345 * @param block_h height of block
1346 * @param ref1 reference picture1 buffer at origin (0, 0)
1347 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1348 * @param current_mv current motion vector structure
1350 static void luma_mc_bi(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1351 AVFrame *ref0, const Mv *mv0, int x_off, int y_off,
1352 int block_w, int block_h, AVFrame *ref1, const Mv *mv1, struct MvField *current_mv)
1354 HEVCLocalContext *lc = s->HEVClc;
1355 ptrdiff_t src0stride = ref0->linesize[0];
1356 ptrdiff_t src1stride = ref1->linesize[0];
1357 int pic_width = s->sps->width;
1358 int pic_height = s->sps->height;
1359 int mx0 = mv0->x & 3;
1360 int my0 = mv0->y & 3;
1361 int mx1 = mv1->x & 3;
1362 int my1 = mv1->y & 3;
1363 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1364 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1365 int x_off0 = x_off + (mv0->x >> 2);
1366 int y_off0 = y_off + (mv0->y >> 2);
1367 int x_off1 = x_off + (mv1->x >> 2);
1368 int y_off1 = y_off + (mv1->y >> 2);
1369 int idx = ff_hevc_pel_weight[block_w];
1371 uint8_t *src0 = ref0->data[0] + y_off0 * src0stride + (int)((unsigned)x_off0 << s->sps->pixel_shift);
1372 uint8_t *src1 = ref1->data[0] + y_off1 * src1stride + (int)((unsigned)x_off1 << s->sps->pixel_shift);
1374 if (x_off0 < QPEL_EXTRA_BEFORE || y_off0 < QPEL_EXTRA_AFTER ||
1375 x_off0 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1376 y_off0 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1377 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1378 int offset = QPEL_EXTRA_BEFORE * src0stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1379 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1381 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset,
1382 edge_emu_stride, src0stride,
1383 block_w + QPEL_EXTRA,
1384 block_h + QPEL_EXTRA,
1385 x_off0 - QPEL_EXTRA_BEFORE, y_off0 - QPEL_EXTRA_BEFORE,
1386 pic_width, pic_height);
1387 src0 = lc->edge_emu_buffer + buf_offset;
1388 src0stride = edge_emu_stride;
1391 if (x_off1 < QPEL_EXTRA_BEFORE || y_off1 < QPEL_EXTRA_AFTER ||
1392 x_off1 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1393 y_off1 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1394 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1395 int offset = QPEL_EXTRA_BEFORE * src1stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1396 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1398 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src1 - offset,
1399 edge_emu_stride, src1stride,
1400 block_w + QPEL_EXTRA,
1401 block_h + QPEL_EXTRA,
1402 x_off1 - QPEL_EXTRA_BEFORE, y_off1 - QPEL_EXTRA_BEFORE,
1403 pic_width, pic_height);
1404 src1 = lc->edge_emu_buffer2 + buf_offset;
1405 src1stride = edge_emu_stride;
1408 s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](lc->tmp, src0, src0stride,
1409 block_h, mx0, my0, block_w);
1411 s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1412 block_h, mx1, my1, block_w);
1414 s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1415 block_h, s->sh.luma_log2_weight_denom,
1416 s->sh.luma_weight_l0[current_mv->ref_idx[0]],
1417 s->sh.luma_weight_l1[current_mv->ref_idx[1]],
1418 s->sh.luma_offset_l0[current_mv->ref_idx[0]],
1419 s->sh.luma_offset_l1[current_mv->ref_idx[1]],
1425 * 8.5.3.2.2.2 Chroma sample uniprediction interpolation process
1427 * @param s HEVC decoding context
1428 * @param dst1 target buffer for block data at block position (U plane)
1429 * @param dst2 target buffer for block data at block position (V plane)
1430 * @param dststride stride of the dst1 and dst2 buffers
1431 * @param ref reference picture buffer at origin (0, 0)
1432 * @param mv motion vector (relative to block position) to get pixel data from
1433 * @param x_off horizontal position of block from origin (0, 0)
1434 * @param y_off vertical position of block from origin (0, 0)
1435 * @param block_w width of block
1436 * @param block_h height of block
1437 * @param chroma_weight weighting factor applied to the chroma prediction
1438 * @param chroma_offset additive offset applied to the chroma prediction value
1441 static void chroma_mc_uni(HEVCContext *s, uint8_t *dst0,
1442 ptrdiff_t dststride, uint8_t *src0, ptrdiff_t srcstride, int reflist,
1443 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int chroma_weight, int chroma_offset)
1445 HEVCLocalContext *lc = s->HEVClc;
1446 int pic_width = s->sps->width >> s->sps->hshift[1];
1447 int pic_height = s->sps->height >> s->sps->vshift[1];
1448 const Mv *mv = ¤t_mv->mv[reflist];
1449 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1450 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1451 int idx = ff_hevc_pel_weight[block_w];
1452 int hshift = s->sps->hshift[1];
1453 int vshift = s->sps->vshift[1];
1454 intptr_t mx = mv->x & ((1 << (2 + hshift)) - 1);
1455 intptr_t my = mv->y & ((1 << (2 + vshift)) - 1);
1456 intptr_t _mx = mx << (1 - hshift);
1457 intptr_t _my = my << (1 - vshift);
1459 x_off += mv->x >> (2 + hshift);
1460 y_off += mv->y >> (2 + vshift);
1461 src0 += y_off * srcstride + (x_off << s->sps->pixel_shift);
1463 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1464 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1465 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1466 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1467 int offset0 = EPEL_EXTRA_BEFORE * (srcstride + (1 << s->sps->pixel_shift));
1468 int buf_offset0 = EPEL_EXTRA_BEFORE *
1469 (edge_emu_stride + (1 << s->sps->pixel_shift));
1470 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset0,
1471 edge_emu_stride, srcstride,
1472 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1473 x_off - EPEL_EXTRA_BEFORE,
1474 y_off - EPEL_EXTRA_BEFORE,
1475 pic_width, pic_height);
1477 src0 = lc->edge_emu_buffer + buf_offset0;
1478 srcstride = edge_emu_stride;
1481 s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1482 block_h, _mx, _my, block_w);
1484 s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1485 block_h, s->sh.chroma_log2_weight_denom,
1486 chroma_weight, chroma_offset, _mx, _my, block_w);
1490 * 8.5.3.2.2.2 Chroma sample bidirectional interpolation process
1492 * @param s HEVC decoding context
1493 * @param dst target buffer for block data at block position
1494 * @param dststride stride of the dst buffer
1495 * @param ref0 reference picture0 buffer at origin (0, 0)
1496 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1497 * @param x_off horizontal position of block from origin (0, 0)
1498 * @param y_off vertical position of block from origin (0, 0)
1499 * @param block_w width of block
1500 * @param block_h height of block
1501 * @param ref1 reference picture1 buffer at origin (0, 0)
1502 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1503 * @param current_mv current motion vector structure
1504 * @param cidx chroma component(cb, cr)
1506 static void chroma_mc_bi(HEVCContext *s, uint8_t *dst0, ptrdiff_t dststride, AVFrame *ref0, AVFrame *ref1,
1507 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int cidx)
1509 HEVCLocalContext *lc = s->HEVClc;
1510 uint8_t *src1 = ref0->data[cidx+1];
1511 uint8_t *src2 = ref1->data[cidx+1];
1512 ptrdiff_t src1stride = ref0->linesize[cidx+1];
1513 ptrdiff_t src2stride = ref1->linesize[cidx+1];
1514 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1515 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1516 int pic_width = s->sps->width >> s->sps->hshift[1];
1517 int pic_height = s->sps->height >> s->sps->vshift[1];
1518 Mv *mv0 = ¤t_mv->mv[0];
1519 Mv *mv1 = ¤t_mv->mv[1];
1520 int hshift = s->sps->hshift[1];
1521 int vshift = s->sps->vshift[1];
1523 intptr_t mx0 = mv0->x & ((1 << (2 + hshift)) - 1);
1524 intptr_t my0 = mv0->y & ((1 << (2 + vshift)) - 1);
1525 intptr_t mx1 = mv1->x & ((1 << (2 + hshift)) - 1);
1526 intptr_t my1 = mv1->y & ((1 << (2 + vshift)) - 1);
1527 intptr_t _mx0 = mx0 << (1 - hshift);
1528 intptr_t _my0 = my0 << (1 - vshift);
1529 intptr_t _mx1 = mx1 << (1 - hshift);
1530 intptr_t _my1 = my1 << (1 - vshift);
1532 int x_off0 = x_off + (mv0->x >> (2 + hshift));
1533 int y_off0 = y_off + (mv0->y >> (2 + vshift));
1534 int x_off1 = x_off + (mv1->x >> (2 + hshift));
1535 int y_off1 = y_off + (mv1->y >> (2 + vshift));
1536 int idx = ff_hevc_pel_weight[block_w];
1537 src1 += y_off0 * src1stride + (int)((unsigned)x_off0 << s->sps->pixel_shift);
1538 src2 += y_off1 * src2stride + (int)((unsigned)x_off1 << s->sps->pixel_shift);
1540 if (x_off0 < EPEL_EXTRA_BEFORE || y_off0 < EPEL_EXTRA_AFTER ||
1541 x_off0 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1542 y_off0 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1543 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1544 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->sps->pixel_shift));
1545 int buf_offset1 = EPEL_EXTRA_BEFORE *
1546 (edge_emu_stride + (1 << s->sps->pixel_shift));
1548 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1549 edge_emu_stride, src1stride,
1550 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1551 x_off0 - EPEL_EXTRA_BEFORE,
1552 y_off0 - EPEL_EXTRA_BEFORE,
1553 pic_width, pic_height);
1555 src1 = lc->edge_emu_buffer + buf_offset1;
1556 src1stride = edge_emu_stride;
1559 if (x_off1 < EPEL_EXTRA_BEFORE || y_off1 < EPEL_EXTRA_AFTER ||
1560 x_off1 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1561 y_off1 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1562 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1563 int offset1 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->sps->pixel_shift));
1564 int buf_offset1 = EPEL_EXTRA_BEFORE *
1565 (edge_emu_stride + (1 << s->sps->pixel_shift));
1567 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src2 - offset1,
1568 edge_emu_stride, src2stride,
1569 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1570 x_off1 - EPEL_EXTRA_BEFORE,
1571 y_off1 - EPEL_EXTRA_BEFORE,
1572 pic_width, pic_height);
1574 src2 = lc->edge_emu_buffer2 + buf_offset1;
1575 src2stride = edge_emu_stride;
1578 s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](lc->tmp, src1, src1stride,
1579 block_h, _mx0, _my0, block_w);
1581 s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1582 src2, src2stride, lc->tmp,
1583 block_h, _mx1, _my1, block_w);
1585 s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1586 src2, src2stride, lc->tmp,
1588 s->sh.chroma_log2_weight_denom,
1589 s->sh.chroma_weight_l0[current_mv->ref_idx[0]][cidx],
1590 s->sh.chroma_weight_l1[current_mv->ref_idx[1]][cidx],
1591 s->sh.chroma_offset_l0[current_mv->ref_idx[0]][cidx],
1592 s->sh.chroma_offset_l1[current_mv->ref_idx[1]][cidx],
1593 _mx1, _my1, block_w);
1596 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1597 const Mv *mv, int y0, int height)
1599 int y = FFMAX(0, (mv->y >> 2) + y0 + height + 9);
1601 if (s->threads_type == FF_THREAD_FRAME )
1602 ff_thread_await_progress(&ref->tf, y, 0);
1605 static void hevc_luma_mv_mpv_mode(HEVCContext *s, int x0, int y0, int nPbW,
1606 int nPbH, int log2_cb_size, int part_idx,
1607 int merge_idx, MvField *mv)
1609 HEVCLocalContext *lc = s->HEVClc;
1610 enum InterPredIdc inter_pred_idc = PRED_L0;
1613 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1615 if (s->sh.slice_type == B_SLICE)
1616 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1618 if (inter_pred_idc != PRED_L1) {
1619 if (s->sh.nb_refs[L0])
1620 mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1622 mv->pred_flag = PF_L0;
1623 ff_hevc_hls_mvd_coding(s, x0, y0, 0);
1624 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1625 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1626 part_idx, merge_idx, mv, mvp_flag, 0);
1627 mv->mv[0].x += lc->pu.mvd.x;
1628 mv->mv[0].y += lc->pu.mvd.y;
1631 if (inter_pred_idc != PRED_L0) {
1632 if (s->sh.nb_refs[L1])
1633 mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1635 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1636 AV_ZERO32(&lc->pu.mvd);
1638 ff_hevc_hls_mvd_coding(s, x0, y0, 1);
1641 mv->pred_flag += PF_L1;
1642 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1643 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1644 part_idx, merge_idx, mv, mvp_flag, 1);
1645 mv->mv[1].x += lc->pu.mvd.x;
1646 mv->mv[1].y += lc->pu.mvd.y;
1650 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1652 int log2_cb_size, int partIdx, int idx)
1654 #define POS(c_idx, x, y) \
1655 &s->frame->data[c_idx][((y) >> s->sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1656 (((x) >> s->sps->hshift[c_idx]) << s->sps->pixel_shift)]
1657 HEVCLocalContext *lc = s->HEVClc;
1659 struct MvField current_mv = {{{ 0 }}};
1661 int min_pu_width = s->sps->min_pu_width;
1663 MvField *tab_mvf = s->ref->tab_mvf;
1664 RefPicList *refPicList = s->ref->refPicList;
1665 HEVCFrame *ref0 = NULL, *ref1 = NULL;
1666 uint8_t *dst0 = POS(0, x0, y0);
1667 uint8_t *dst1 = POS(1, x0, y0);
1668 uint8_t *dst2 = POS(2, x0, y0);
1669 int log2_min_cb_size = s->sps->log2_min_cb_size;
1670 int min_cb_width = s->sps->min_cb_width;
1671 int x_cb = x0 >> log2_min_cb_size;
1672 int y_cb = y0 >> log2_min_cb_size;
1676 int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1679 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1681 if (skip_flag || lc->pu.merge_flag) {
1682 if (s->sh.max_num_merge_cand > 1)
1683 merge_idx = ff_hevc_merge_idx_decode(s);
1687 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1688 partIdx, merge_idx, ¤t_mv);
1690 hevc_luma_mv_mpv_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1691 partIdx, merge_idx, ¤t_mv);
1694 x_pu = x0 >> s->sps->log2_min_pu_size;
1695 y_pu = y0 >> s->sps->log2_min_pu_size;
1697 for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1698 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1699 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1701 if (current_mv.pred_flag & PF_L0) {
1702 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1705 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1707 if (current_mv.pred_flag & PF_L1) {
1708 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1711 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1714 if (current_mv.pred_flag == PF_L0) {
1715 int x0_c = x0 >> s->sps->hshift[1];
1716 int y0_c = y0 >> s->sps->vshift[1];
1717 int nPbW_c = nPbW >> s->sps->hshift[1];
1718 int nPbH_c = nPbH >> s->sps->vshift[1];
1720 luma_mc_uni(s, dst0, s->frame->linesize[0], ref0->frame,
1721 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1722 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1723 s->sh.luma_offset_l0[current_mv.ref_idx[0]]);
1725 if (s->sps->chroma_format_idc) {
1726 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref0->frame->data[1], ref0->frame->linesize[1],
1727 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1728 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]);
1729 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref0->frame->data[2], ref0->frame->linesize[2],
1730 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1731 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]);
1733 } else if (current_mv.pred_flag == PF_L1) {
1734 int x0_c = x0 >> s->sps->hshift[1];
1735 int y0_c = y0 >> s->sps->vshift[1];
1736 int nPbW_c = nPbW >> s->sps->hshift[1];
1737 int nPbH_c = nPbH >> s->sps->vshift[1];
1739 luma_mc_uni(s, dst0, s->frame->linesize[0], ref1->frame,
1740 ¤t_mv.mv[1], x0, y0, nPbW, nPbH,
1741 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1742 s->sh.luma_offset_l1[current_mv.ref_idx[1]]);
1744 if (s->sps->chroma_format_idc) {
1745 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
1746 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1747 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]);
1749 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
1750 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1751 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]);
1753 } else if (current_mv.pred_flag == PF_BI) {
1754 int x0_c = x0 >> s->sps->hshift[1];
1755 int y0_c = y0 >> s->sps->vshift[1];
1756 int nPbW_c = nPbW >> s->sps->hshift[1];
1757 int nPbH_c = nPbH >> s->sps->vshift[1];
1759 luma_mc_bi(s, dst0, s->frame->linesize[0], ref0->frame,
1760 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1761 ref1->frame, ¤t_mv.mv[1], ¤t_mv);
1763 if (s->sps->chroma_format_idc) {
1764 chroma_mc_bi(s, dst1, s->frame->linesize[1], ref0->frame, ref1->frame,
1765 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 0);
1767 chroma_mc_bi(s, dst2, s->frame->linesize[2], ref0->frame, ref1->frame,
1768 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1);
1776 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1777 int prev_intra_luma_pred_flag)
1779 HEVCLocalContext *lc = s->HEVClc;
1780 int x_pu = x0 >> s->sps->log2_min_pu_size;
1781 int y_pu = y0 >> s->sps->log2_min_pu_size;
1782 int min_pu_width = s->sps->min_pu_width;
1783 int size_in_pus = pu_size >> s->sps->log2_min_pu_size;
1784 int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1);
1785 int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1);
1787 int cand_up = (lc->ctb_up_flag || y0b) ?
1788 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1789 int cand_left = (lc->ctb_left_flag || x0b) ?
1790 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1792 int y_ctb = (y0 >> (s->sps->log2_ctb_size)) << (s->sps->log2_ctb_size);
1794 MvField *tab_mvf = s->ref->tab_mvf;
1795 int intra_pred_mode;
1799 // intra_pred_mode prediction does not cross vertical CTB boundaries
1800 if ((y0 - 1) < y_ctb)
1803 if (cand_left == cand_up) {
1804 if (cand_left < 2) {
1805 candidate[0] = INTRA_PLANAR;
1806 candidate[1] = INTRA_DC;
1807 candidate[2] = INTRA_ANGULAR_26;
1809 candidate[0] = cand_left;
1810 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1811 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1814 candidate[0] = cand_left;
1815 candidate[1] = cand_up;
1816 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1817 candidate[2] = INTRA_PLANAR;
1818 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1819 candidate[2] = INTRA_DC;
1821 candidate[2] = INTRA_ANGULAR_26;
1825 if (prev_intra_luma_pred_flag) {
1826 intra_pred_mode = candidate[lc->pu.mpm_idx];
1828 if (candidate[0] > candidate[1])
1829 FFSWAP(uint8_t, candidate[0], candidate[1]);
1830 if (candidate[0] > candidate[2])
1831 FFSWAP(uint8_t, candidate[0], candidate[2]);
1832 if (candidate[1] > candidate[2])
1833 FFSWAP(uint8_t, candidate[1], candidate[2]);
1835 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1836 for (i = 0; i < 3; i++)
1837 if (intra_pred_mode >= candidate[i])
1841 /* write the intra prediction units into the mv array */
1844 for (i = 0; i < size_in_pus; i++) {
1845 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1846 intra_pred_mode, size_in_pus);
1848 for (j = 0; j < size_in_pus; j++) {
1849 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag = PF_INTRA;
1853 return intra_pred_mode;
1856 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1857 int log2_cb_size, int ct_depth)
1859 int length = (1 << log2_cb_size) >> s->sps->log2_min_cb_size;
1860 int x_cb = x0 >> s->sps->log2_min_cb_size;
1861 int y_cb = y0 >> s->sps->log2_min_cb_size;
1864 for (y = 0; y < length; y++)
1865 memset(&s->tab_ct_depth[(y_cb + y) * s->sps->min_cb_width + x_cb],
1869 static const uint8_t tab_mode_idx[] = {
1870 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
1871 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
1873 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1876 HEVCLocalContext *lc = s->HEVClc;
1877 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1878 uint8_t prev_intra_luma_pred_flag[4];
1879 int split = lc->cu.part_mode == PART_NxN;
1880 int pb_size = (1 << log2_cb_size) >> split;
1881 int side = split + 1;
1885 for (i = 0; i < side; i++)
1886 for (j = 0; j < side; j++)
1887 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1889 for (i = 0; i < side; i++) {
1890 for (j = 0; j < side; j++) {
1891 if (prev_intra_luma_pred_flag[2 * i + j])
1892 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
1894 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
1896 lc->pu.intra_pred_mode[2 * i + j] =
1897 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1898 prev_intra_luma_pred_flag[2 * i + j]);
1902 if (s->sps->chroma_format_idc == 3) {
1903 for (i = 0; i < side; i++) {
1904 for (j = 0; j < side; j++) {
1905 lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1906 if (chroma_mode != 4) {
1907 if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode])
1908 lc->pu.intra_pred_mode_c[2 * i + j] = 34;
1910 lc->pu.intra_pred_mode_c[2 * i + j] = intra_chroma_table[chroma_mode];
1912 lc->pu.intra_pred_mode_c[2 * i + j] = lc->pu.intra_pred_mode[2 * i + j];
1916 } else if (s->sps->chroma_format_idc == 2) {
1918 lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1919 if (chroma_mode != 4) {
1920 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1923 mode_idx = intra_chroma_table[chroma_mode];
1925 mode_idx = lc->pu.intra_pred_mode[0];
1927 lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx];
1928 } else if (s->sps->chroma_format_idc != 0) {
1929 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1930 if (chroma_mode != 4) {
1931 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1932 lc->pu.intra_pred_mode_c[0] = 34;
1934 lc->pu.intra_pred_mode_c[0] = intra_chroma_table[chroma_mode];
1936 lc->pu.intra_pred_mode_c[0] = lc->pu.intra_pred_mode[0];
1941 static void intra_prediction_unit_default_value(HEVCContext *s,
1945 HEVCLocalContext *lc = s->HEVClc;
1946 int pb_size = 1 << log2_cb_size;
1947 int size_in_pus = pb_size >> s->sps->log2_min_pu_size;
1948 int min_pu_width = s->sps->min_pu_width;
1949 MvField *tab_mvf = s->ref->tab_mvf;
1950 int x_pu = x0 >> s->sps->log2_min_pu_size;
1951 int y_pu = y0 >> s->sps->log2_min_pu_size;
1954 if (size_in_pus == 0)
1956 for (j = 0; j < size_in_pus; j++)
1957 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
1958 if (lc->cu.pred_mode == MODE_INTRA)
1959 for (j = 0; j < size_in_pus; j++)
1960 for (k = 0; k < size_in_pus; k++)
1961 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].pred_flag = PF_INTRA;
1964 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
1966 int cb_size = 1 << log2_cb_size;
1967 HEVCLocalContext *lc = s->HEVClc;
1968 int log2_min_cb_size = s->sps->log2_min_cb_size;
1969 int length = cb_size >> log2_min_cb_size;
1970 int min_cb_width = s->sps->min_cb_width;
1971 int x_cb = x0 >> log2_min_cb_size;
1972 int y_cb = y0 >> log2_min_cb_size;
1973 int idx = log2_cb_size - 2;
1974 int qp_block_mask = (1<<(s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth)) - 1;
1979 lc->cu.pred_mode = MODE_INTRA;
1980 lc->cu.part_mode = PART_2Nx2N;
1981 lc->cu.intra_split_flag = 0;
1983 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
1984 for (x = 0; x < 4; x++)
1985 lc->pu.intra_pred_mode[x] = 1;
1986 if (s->pps->transquant_bypass_enable_flag) {
1987 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
1988 if (lc->cu.cu_transquant_bypass_flag)
1989 set_deblocking_bypass(s, x0, y0, log2_cb_size);
1991 lc->cu.cu_transquant_bypass_flag = 0;
1993 if (s->sh.slice_type != I_SLICE) {
1994 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
1996 x = y_cb * min_cb_width + x_cb;
1997 for (y = 0; y < length; y++) {
1998 memset(&s->skip_flag[x], skip_flag, length);
2001 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2003 x = y_cb * min_cb_width + x_cb;
2004 for (y = 0; y < length; y++) {
2005 memset(&s->skip_flag[x], 0, length);
2010 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2011 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2012 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2014 if (!s->sh.disable_deblocking_filter_flag)
2015 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2019 if (s->sh.slice_type != I_SLICE)
2020 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2021 if (lc->cu.pred_mode != MODE_INTRA ||
2022 log2_cb_size == s->sps->log2_min_cb_size) {
2023 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2024 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2025 lc->cu.pred_mode == MODE_INTRA;
2028 if (lc->cu.pred_mode == MODE_INTRA) {
2029 if (lc->cu.part_mode == PART_2Nx2N && s->sps->pcm_enabled_flag &&
2030 log2_cb_size >= s->sps->pcm.log2_min_pcm_cb_size &&
2031 log2_cb_size <= s->sps->pcm.log2_max_pcm_cb_size) {
2032 pcm_flag = ff_hevc_pcm_flag_decode(s);
2035 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2036 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2037 if (s->sps->pcm.loop_filter_disable_flag)
2038 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2043 intra_prediction_unit(s, x0, y0, log2_cb_size);
2046 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2047 switch (lc->cu.part_mode) {
2049 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2052 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0, idx);
2053 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2056 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2057 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2060 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0, idx);
2061 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2064 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2065 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2068 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0, idx - 2);
2069 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2072 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2073 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2076 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2077 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2078 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2079 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2085 int rqt_root_cbf = 1;
2087 if (lc->cu.pred_mode != MODE_INTRA &&
2088 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2089 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2092 const static int cbf[2] = { 0 };
2093 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2094 s->sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2095 s->sps->max_transform_hierarchy_depth_inter;
2096 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2098 log2_cb_size, 0, 0, cbf, cbf);
2102 if (!s->sh.disable_deblocking_filter_flag)
2103 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2108 if (s->pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2109 ff_hevc_set_qPy(s, x0, y0, log2_cb_size);
2111 x = y_cb * min_cb_width + x_cb;
2112 for (y = 0; y < length; y++) {
2113 memset(&s->qp_y_tab[x], lc->qp_y, length);
2117 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2118 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2119 lc->qPy_pred = lc->qp_y;
2122 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct_depth);
2127 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2128 int log2_cb_size, int cb_depth)
2130 HEVCLocalContext *lc = s->HEVClc;
2131 const int cb_size = 1 << log2_cb_size;
2135 lc->ct_depth = cb_depth;
2136 if (x0 + cb_size <= s->sps->width &&
2137 y0 + cb_size <= s->sps->height &&
2138 log2_cb_size > s->sps->log2_min_cb_size) {
2139 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2141 split_cu = (log2_cb_size > s->sps->log2_min_cb_size);
2143 if (s->pps->cu_qp_delta_enabled_flag &&
2144 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth) {
2145 lc->tu.is_cu_qp_delta_coded = 0;
2146 lc->tu.cu_qp_delta = 0;
2149 if (s->sh.cu_chroma_qp_offset_enabled_flag &&
2150 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_chroma_qp_offset_depth) {
2151 lc->tu.is_cu_chroma_qp_offset_coded = 0;
2155 int qp_block_mask = (1<<(s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth)) - 1;
2156 const int cb_size_split = cb_size >> 1;
2157 const int x1 = x0 + cb_size_split;
2158 const int y1 = y0 + cb_size_split;
2162 more_data = hls_coding_quadtree(s, x0, y0, log2_cb_size - 1, cb_depth + 1);
2166 if (more_data && x1 < s->sps->width) {
2167 more_data = hls_coding_quadtree(s, x1, y0, log2_cb_size - 1, cb_depth + 1);
2171 if (more_data && y1 < s->sps->height) {
2172 more_data = hls_coding_quadtree(s, x0, y1, log2_cb_size - 1, cb_depth + 1);
2176 if (more_data && x1 < s->sps->width &&
2177 y1 < s->sps->height) {
2178 more_data = hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1);
2183 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2184 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2185 lc->qPy_pred = lc->qp_y;
2188 return ((x1 + cb_size_split) < s->sps->width ||
2189 (y1 + cb_size_split) < s->sps->height);
2193 ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2196 if ((!((x0 + cb_size) %
2197 (1 << (s->sps->log2_ctb_size))) ||
2198 (x0 + cb_size >= s->sps->width)) &&
2200 (1 << (s->sps->log2_ctb_size))) ||
2201 (y0 + cb_size >= s->sps->height))) {
2202 int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s);
2203 return !end_of_slice_flag;
2212 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2215 HEVCLocalContext *lc = s->HEVClc;
2216 int ctb_size = 1 << s->sps->log2_ctb_size;
2217 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2218 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2220 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2222 if (s->pps->entropy_coding_sync_enabled_flag) {
2223 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2224 lc->first_qp_group = 1;
2225 lc->end_of_tiles_x = s->sps->width;
2226 } else if (s->pps->tiles_enabled_flag) {
2227 if (ctb_addr_ts && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1]) {
2228 int idxX = s->pps->col_idxX[x_ctb >> s->sps->log2_ctb_size];
2229 lc->end_of_tiles_x = x_ctb + (s->pps->column_width[idxX] << s->sps->log2_ctb_size);
2230 lc->first_qp_group = 1;
2233 lc->end_of_tiles_x = s->sps->width;
2236 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->sps->height);
2238 lc->boundary_flags = 0;
2239 if (s->pps->tiles_enabled_flag) {
2240 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]])
2241 lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2242 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2243 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2244 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]])
2245 lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2246 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->sps->ctb_width])
2247 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2249 if (!ctb_addr_in_slice > 0)
2250 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2251 if (ctb_addr_in_slice < s->sps->ctb_width)
2252 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2255 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2256 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2257 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]]));
2258 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]]));
2261 static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
2263 HEVCContext *s = avctxt->priv_data;
2264 int ctb_size = 1 << s->sps->log2_ctb_size;
2268 int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2270 if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) {
2271 av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n");
2272 return AVERROR_INVALIDDATA;
2275 if (s->sh.dependent_slice_segment_flag) {
2276 int prev_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2277 if (s->tab_slice_address[prev_rs] != s->sh.slice_addr) {
2278 av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n");
2279 return AVERROR_INVALIDDATA;
2283 while (more_data && ctb_addr_ts < s->sps->ctb_size) {
2284 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2286 x_ctb = (ctb_addr_rs % ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2287 y_ctb = (ctb_addr_rs / ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2288 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2290 ff_hevc_cabac_init(s, ctb_addr_ts);
2292 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2294 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2295 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2296 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2298 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2299 if (more_data < 0) {
2300 s->tab_slice_address[ctb_addr_rs] = -1;
2306 ff_hevc_save_states(s, ctb_addr_ts);
2307 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2310 if (x_ctb + ctb_size >= s->sps->width &&
2311 y_ctb + ctb_size >= s->sps->height)
2312 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2317 static int hls_slice_data(HEVCContext *s)
2325 s->avctx->execute(s->avctx, hls_decode_entry, arg, ret , 1, sizeof(int));
2328 static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int job, int self_id)
2330 HEVCContext *s1 = avctxt->priv_data, *s;
2331 HEVCLocalContext *lc;
2332 int ctb_size = 1<< s1->sps->log2_ctb_size;
2334 int *ctb_row_p = input_ctb_row;
2335 int ctb_row = ctb_row_p[job];
2336 int ctb_addr_rs = s1->sh.slice_ctb_addr_rs + ctb_row * ((s1->sps->width + ctb_size - 1) >> s1->sps->log2_ctb_size);
2337 int ctb_addr_ts = s1->pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2338 int thread = ctb_row % s1->threads_number;
2341 s = s1->sList[self_id];
2345 ret = init_get_bits8(&lc->gb, s->data + s->sh.offset[ctb_row - 1], s->sh.size[ctb_row - 1]);
2349 ff_init_cabac_decoder(&lc->cc, s->data + s->sh.offset[(ctb_row)-1], s->sh.size[ctb_row - 1]);
2352 while(more_data && ctb_addr_ts < s->sps->ctb_size) {
2353 int x_ctb = (ctb_addr_rs % s->sps->ctb_width) << s->sps->log2_ctb_size;
2354 int y_ctb = (ctb_addr_rs / s->sps->ctb_width) << s->sps->log2_ctb_size;
2356 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2358 ff_thread_await_progress2(s->avctx, ctb_row, thread, SHIFT_CTB_WPP);
2360 if (avpriv_atomic_int_get(&s1->wpp_err)){
2361 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2365 ff_hevc_cabac_init(s, ctb_addr_ts);
2366 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2367 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2369 if (more_data < 0) {
2370 s->tab_slice_address[ctb_addr_rs] = -1;
2376 ff_hevc_save_states(s, ctb_addr_ts);
2377 ff_thread_report_progress2(s->avctx, ctb_row, thread, 1);
2378 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2380 if (!more_data && (x_ctb+ctb_size) < s->sps->width && ctb_row != s->sh.num_entry_point_offsets) {
2381 avpriv_atomic_int_set(&s1->wpp_err, 1);
2382 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2386 if ((x_ctb+ctb_size) >= s->sps->width && (y_ctb+ctb_size) >= s->sps->height ) {
2387 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2388 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2391 ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2394 if(x_ctb >= s->sps->width) {
2398 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2403 static int hls_slice_data_wpp(HEVCContext *s, const uint8_t *nal, int length)
2405 HEVCLocalContext *lc = s->HEVClc;
2406 int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2407 int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2409 int startheader, cmpt = 0;
2415 return AVERROR(ENOMEM);
2420 ff_alloc_entries(s->avctx, s->sh.num_entry_point_offsets + 1);
2423 for (i = 1; i < s->threads_number; i++) {
2424 s->sList[i] = av_malloc(sizeof(HEVCContext));
2425 memcpy(s->sList[i], s, sizeof(HEVCContext));
2426 s->HEVClcList[i] = av_mallocz(sizeof(HEVCLocalContext));
2427 s->sList[i]->HEVClc = s->HEVClcList[i];
2431 offset = (lc->gb.index >> 3);
2433 for (j = 0, cmpt = 0, startheader = offset + s->sh.entry_point_offset[0]; j < s->skipped_bytes; j++) {
2434 if (s->skipped_bytes_pos[j] >= offset && s->skipped_bytes_pos[j] < startheader) {
2440 for (i = 1; i < s->sh.num_entry_point_offsets; i++) {
2441 offset += (s->sh.entry_point_offset[i - 1] - cmpt);
2442 for (j = 0, cmpt = 0, startheader = offset
2443 + s->sh.entry_point_offset[i]; j < s->skipped_bytes; j++) {
2444 if (s->skipped_bytes_pos[j] >= offset && s->skipped_bytes_pos[j] < startheader) {
2449 s->sh.size[i - 1] = s->sh.entry_point_offset[i] - cmpt;
2450 s->sh.offset[i - 1] = offset;
2453 if (s->sh.num_entry_point_offsets != 0) {
2454 offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt;
2455 s->sh.size[s->sh.num_entry_point_offsets - 1] = length - offset;
2456 s->sh.offset[s->sh.num_entry_point_offsets - 1] = offset;
2461 for (i = 1; i < s->threads_number; i++) {
2462 s->sList[i]->HEVClc->first_qp_group = 1;
2463 s->sList[i]->HEVClc->qp_y = s->sList[0]->HEVClc->qp_y;
2464 memcpy(s->sList[i], s, sizeof(HEVCContext));
2465 s->sList[i]->HEVClc = s->HEVClcList[i];
2468 avpriv_atomic_int_set(&s->wpp_err, 0);
2469 ff_reset_entries(s->avctx);
2471 for (i = 0; i <= s->sh.num_entry_point_offsets; i++) {
2476 if (s->pps->entropy_coding_sync_enabled_flag)
2477 s->avctx->execute2(s->avctx, (void *) hls_decode_entry_wpp, arg, ret, s->sh.num_entry_point_offsets + 1);
2479 for (i = 0; i <= s->sh.num_entry_point_offsets; i++)
2487 * @return AVERROR_INVALIDDATA if the packet is not a valid NAL unit,
2488 * 0 if the unit should be skipped, 1 otherwise
2490 static int hls_nal_unit(HEVCContext *s)
2492 GetBitContext *gb = &s->HEVClc->gb;
2495 if (get_bits1(gb) != 0)
2496 return AVERROR_INVALIDDATA;
2498 s->nal_unit_type = get_bits(gb, 6);
2500 nuh_layer_id = get_bits(gb, 6);
2501 s->temporal_id = get_bits(gb, 3) - 1;
2502 if (s->temporal_id < 0)
2503 return AVERROR_INVALIDDATA;
2505 av_log(s->avctx, AV_LOG_DEBUG,
2506 "nal_unit_type: %d, nuh_layer_id: %d, temporal_id: %d\n",
2507 s->nal_unit_type, nuh_layer_id, s->temporal_id);
2509 return nuh_layer_id == 0;
2512 static int set_side_data(HEVCContext *s)
2514 AVFrame *out = s->ref->frame;
2516 if (s->sei_frame_packing_present &&
2517 s->frame_packing_arrangement_type >= 3 &&
2518 s->frame_packing_arrangement_type <= 5 &&
2519 s->content_interpretation_type > 0 &&
2520 s->content_interpretation_type < 3) {
2521 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2523 return AVERROR(ENOMEM);
2525 switch (s->frame_packing_arrangement_type) {
2527 if (s->quincunx_subsampling)
2528 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2530 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2533 stereo->type = AV_STEREO3D_TOPBOTTOM;
2536 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2540 if (s->content_interpretation_type == 2)
2541 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2544 if (s->sei_display_orientation_present &&
2545 (s->sei_anticlockwise_rotation || s->sei_hflip || s->sei_vflip)) {
2546 double angle = s->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
2547 AVFrameSideData *rotation = av_frame_new_side_data(out,
2548 AV_FRAME_DATA_DISPLAYMATRIX,
2549 sizeof(int32_t) * 9);
2551 return AVERROR(ENOMEM);
2553 av_display_rotation_set((int32_t *)rotation->data, angle);
2554 av_display_matrix_flip((int32_t *)rotation->data,
2555 s->sei_hflip, s->sei_vflip);
2561 static int hevc_frame_start(HEVCContext *s)
2563 HEVCLocalContext *lc = s->HEVClc;
2564 int pic_size_in_ctb = ((s->sps->width >> s->sps->log2_min_cb_size) + 1) *
2565 ((s->sps->height >> s->sps->log2_min_cb_size) + 1);
2568 memset(s->horizontal_bs, 0, s->bs_width * s->bs_height);
2569 memset(s->vertical_bs, 0, s->bs_width * s->bs_height);
2570 memset(s->cbf_luma, 0, s->sps->min_tb_width * s->sps->min_tb_height);
2571 memset(s->is_pcm, 0, (s->sps->min_pu_width + 1) * (s->sps->min_pu_height + 1));
2572 memset(s->tab_slice_address, -1, pic_size_in_ctb * sizeof(*s->tab_slice_address));
2575 s->first_nal_type = s->nal_unit_type;
2577 if (s->pps->tiles_enabled_flag)
2578 lc->end_of_tiles_x = s->pps->column_width[0] << s->sps->log2_ctb_size;
2580 ret = ff_hevc_set_new_ref(s, &s->frame, s->poc);
2584 ret = ff_hevc_frame_rps(s);
2586 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2590 s->ref->frame->key_frame = IS_IRAP(s);
2592 ret = set_side_data(s);
2596 s->frame->pict_type = 3 - s->sh.slice_type;
2599 ff_hevc_bump_frame(s);
2601 av_frame_unref(s->output_frame);
2602 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2606 ff_thread_finish_setup(s->avctx);
2612 ff_hevc_unref_frame(s, s->ref, ~0);
2617 static int decode_nal_unit(HEVCContext *s, const HEVCNAL *nal)
2619 HEVCLocalContext *lc = s->HEVClc;
2620 GetBitContext *gb = &lc->gb;
2621 int ctb_addr_ts, ret;
2623 ret = init_get_bits8(gb, nal->data, nal->size);
2627 ret = hls_nal_unit(s);
2629 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit %d, skipping.\n",
2635 switch (s->nal_unit_type) {
2637 ret = ff_hevc_decode_nal_vps(s);
2642 ret = ff_hevc_decode_nal_sps(s);
2647 ret = ff_hevc_decode_nal_pps(s);
2651 case NAL_SEI_PREFIX:
2652 case NAL_SEI_SUFFIX:
2653 ret = ff_hevc_decode_nal_sei(s);
2664 case NAL_BLA_W_RADL:
2666 case NAL_IDR_W_RADL:
2673 ret = hls_slice_header(s);
2677 if (s->max_ra == INT_MAX) {
2678 if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
2682 s->max_ra = INT_MIN;
2686 if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
2687 s->poc <= s->max_ra) {
2691 if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
2692 s->max_ra = INT_MIN;
2695 if (s->sh.first_slice_in_pic_flag) {
2696 ret = hevc_frame_start(s);
2699 } else if (!s->ref) {
2700 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2704 if (s->nal_unit_type != s->first_nal_type) {
2705 av_log(s->avctx, AV_LOG_ERROR,
2706 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2707 s->first_nal_type, s->nal_unit_type);
2708 return AVERROR_INVALIDDATA;
2711 if (!s->sh.dependent_slice_segment_flag &&
2712 s->sh.slice_type != I_SLICE) {
2713 ret = ff_hevc_slice_rpl(s);
2715 av_log(s->avctx, AV_LOG_WARNING,
2716 "Error constructing the reference lists for the current slice.\n");
2721 if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) {
2722 ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0);
2727 if (s->avctx->hwaccel) {
2728 ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size);
2732 if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
2733 ctb_addr_ts = hls_slice_data_wpp(s, nal->data, nal->size);
2735 ctb_addr_ts = hls_slice_data(s);
2736 if (ctb_addr_ts >= (s->sps->ctb_width * s->sps->ctb_height)) {
2740 if (ctb_addr_ts < 0) {
2748 s->seq_decode = (s->seq_decode + 1) & 0xff;
2749 s->max_ra = INT_MAX;
2755 av_log(s->avctx, AV_LOG_INFO,
2756 "Skipping NAL unit %d\n", s->nal_unit_type);
2761 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2766 /* FIXME: This is adapted from ff_h264_decode_nal, avoiding duplication
2767 * between these functions would be nice. */
2768 int ff_hevc_extract_rbsp(HEVCContext *s, const uint8_t *src, int length,
2774 s->skipped_bytes = 0;
2775 #define STARTCODE_TEST \
2776 if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \
2777 if (src[i + 2] != 3) { \
2778 /* startcode, so we must be past the end */ \
2783 #if HAVE_FAST_UNALIGNED
2784 #define FIND_FIRST_ZERO \
2785 if (i > 0 && !src[i]) \
2790 for (i = 0; i + 1 < length; i += 9) {
2791 if (!((~AV_RN64A(src + i) &
2792 (AV_RN64A(src + i) - 0x0100010001000101ULL)) &
2793 0x8000800080008080ULL))
2800 for (i = 0; i + 1 < length; i += 5) {
2801 if (!((~AV_RN32A(src + i) &
2802 (AV_RN32A(src + i) - 0x01000101U)) &
2809 #endif /* HAVE_FAST_64BIT */
2811 for (i = 0; i + 1 < length; i += 2) {
2814 if (i > 0 && src[i - 1] == 0)
2818 #endif /* HAVE_FAST_UNALIGNED */
2820 if (i >= length - 1) { // no escaped 0
2822 nal->raw_data = src;
2824 nal->raw_size = length;
2828 av_fast_malloc(&nal->rbsp_buffer, &nal->rbsp_buffer_size,
2829 length + FF_INPUT_BUFFER_PADDING_SIZE);
2830 if (!nal->rbsp_buffer)
2831 return AVERROR(ENOMEM);
2833 dst = nal->rbsp_buffer;
2835 memcpy(dst, src, i);
2837 while (si + 2 < length) {
2838 // remove escapes (very rare 1:2^22)
2839 if (src[si + 2] > 3) {
2840 dst[di++] = src[si++];
2841 dst[di++] = src[si++];
2842 } else if (src[si] == 0 && src[si + 1] == 0) {
2843 if (src[si + 2] == 3) { // escape
2849 if (s->skipped_bytes_pos_size < s->skipped_bytes) {
2850 s->skipped_bytes_pos_size *= 2;
2851 av_reallocp_array(&s->skipped_bytes_pos,
2852 s->skipped_bytes_pos_size,
2853 sizeof(*s->skipped_bytes_pos));
2854 if (!s->skipped_bytes_pos)
2855 return AVERROR(ENOMEM);
2857 if (s->skipped_bytes_pos)
2858 s->skipped_bytes_pos[s->skipped_bytes-1] = di - 1;
2860 } else // next start code
2864 dst[di++] = src[si++];
2867 dst[di++] = src[si++];
2870 memset(dst + di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2874 nal->raw_data = src;
2879 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2881 int i, consumed, ret = 0;
2884 s->last_eos = s->eos;
2887 /* split the input packet into NAL units, so we know the upper bound on the
2888 * number of slices in the frame */
2890 while (length >= 4) {
2892 int extract_length = 0;
2896 for (i = 0; i < s->nal_length_size; i++)
2897 extract_length = (extract_length << 8) | buf[i];
2898 buf += s->nal_length_size;
2899 length -= s->nal_length_size;
2901 if (extract_length > length) {
2902 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit size.\n");
2903 ret = AVERROR_INVALIDDATA;
2907 /* search start code */
2908 while (buf[0] != 0 || buf[1] != 0 || buf[2] != 1) {
2912 av_log(s->avctx, AV_LOG_ERROR, "No start code is found.\n");
2913 ret = AVERROR_INVALIDDATA;
2923 extract_length = length;
2925 if (s->nals_allocated < s->nb_nals + 1) {
2926 int new_size = s->nals_allocated + 1;
2927 void *tmp = av_realloc_array(s->nals, new_size, sizeof(*s->nals));
2928 ret = AVERROR(ENOMEM);
2933 memset(s->nals + s->nals_allocated, 0,
2934 (new_size - s->nals_allocated) * sizeof(*s->nals));
2936 tmp = av_realloc_array(s->skipped_bytes_nal, new_size, sizeof(*s->skipped_bytes_nal));
2939 s->skipped_bytes_nal = tmp;
2941 tmp = av_realloc_array(s->skipped_bytes_pos_size_nal, new_size, sizeof(*s->skipped_bytes_pos_size_nal));
2944 s->skipped_bytes_pos_size_nal = tmp;
2946 tmp = av_realloc_array(s->skipped_bytes_pos_nal, new_size, sizeof(*s->skipped_bytes_pos_nal));
2949 s->skipped_bytes_pos_nal = tmp;
2951 s->skipped_bytes_pos_size_nal[s->nals_allocated] = 1024; // initial buffer size
2952 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));
2953 if (!s->skipped_bytes_pos_nal[s->nals_allocated])
2955 s->nals_allocated = new_size;
2957 s->skipped_bytes_pos_size = s->skipped_bytes_pos_size_nal[s->nb_nals];
2958 s->skipped_bytes_pos = s->skipped_bytes_pos_nal[s->nb_nals];
2959 nal = &s->nals[s->nb_nals];
2961 consumed = ff_hevc_extract_rbsp(s, buf, extract_length, nal);
2963 s->skipped_bytes_nal[s->nb_nals] = s->skipped_bytes;
2964 s->skipped_bytes_pos_size_nal[s->nb_nals] = s->skipped_bytes_pos_size;
2965 s->skipped_bytes_pos_nal[s->nb_nals++] = s->skipped_bytes_pos;
2973 ret = init_get_bits8(&s->HEVClc->gb, nal->data, nal->size);
2978 if (s->nal_unit_type == NAL_EOB_NUT ||
2979 s->nal_unit_type == NAL_EOS_NUT)
2986 /* parse the NAL units */
2987 for (i = 0; i < s->nb_nals; i++) {
2989 s->skipped_bytes = s->skipped_bytes_nal[i];
2990 s->skipped_bytes_pos = s->skipped_bytes_pos_nal[i];
2992 ret = decode_nal_unit(s, &s->nals[i]);
2994 av_log(s->avctx, AV_LOG_WARNING,
2995 "Error parsing NAL unit #%d.\n", i);
3001 if (s->ref && s->threads_type == FF_THREAD_FRAME)
3002 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
3007 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
3010 for (i = 0; i < 16; i++)
3011 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
3014 static int verify_md5(HEVCContext *s, AVFrame *frame)
3016 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
3021 return AVERROR(EINVAL);
3023 pixel_shift = desc->comp[0].depth_minus1 > 7;
3025 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
3028 /* the checksums are LE, so we have to byteswap for >8bpp formats
3031 if (pixel_shift && !s->checksum_buf) {
3032 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
3033 FFMAX3(frame->linesize[0], frame->linesize[1],
3034 frame->linesize[2]));
3035 if (!s->checksum_buf)
3036 return AVERROR(ENOMEM);
3040 for (i = 0; frame->data[i]; i++) {
3041 int width = s->avctx->coded_width;
3042 int height = s->avctx->coded_height;
3043 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
3044 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
3047 av_md5_init(s->md5_ctx);
3048 for (j = 0; j < h; j++) {
3049 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
3052 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
3053 (const uint16_t *) src, w);
3054 src = s->checksum_buf;
3057 av_md5_update(s->md5_ctx, src, w << pixel_shift);
3059 av_md5_final(s->md5_ctx, md5);
3061 if (!memcmp(md5, s->md5[i], 16)) {
3062 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
3063 print_md5(s->avctx, AV_LOG_DEBUG, md5);
3064 av_log (s->avctx, AV_LOG_DEBUG, "; ");
3066 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
3067 print_md5(s->avctx, AV_LOG_ERROR, md5);
3068 av_log (s->avctx, AV_LOG_ERROR, " != ");
3069 print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
3070 av_log (s->avctx, AV_LOG_ERROR, "\n");
3071 return AVERROR_INVALIDDATA;
3075 av_log(s->avctx, AV_LOG_DEBUG, "\n");
3080 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
3084 HEVCContext *s = avctx->priv_data;
3087 ret = ff_hevc_output_frame(s, data, 1);
3096 ret = decode_nal_units(s, avpkt->data, avpkt->size);
3100 if (avctx->hwaccel) {
3101 if (s->ref && avctx->hwaccel->end_frame(avctx) < 0)
3102 av_log(avctx, AV_LOG_ERROR,
3103 "hardware accelerator failed to decode picture\n");
3105 /* verify the SEI checksum */
3106 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
3108 ret = verify_md5(s, s->ref->frame);
3109 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
3110 ff_hevc_unref_frame(s, s->ref, ~0);
3117 if (s->is_decoded) {
3118 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
3122 if (s->output_frame->buf[0]) {
3123 av_frame_move_ref(data, s->output_frame);
3130 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
3134 ret = ff_thread_ref_frame(&dst->tf, &src->tf);
3138 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
3139 if (!dst->tab_mvf_buf)
3141 dst->tab_mvf = src->tab_mvf;
3143 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
3144 if (!dst->rpl_tab_buf)
3146 dst->rpl_tab = src->rpl_tab;
3148 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
3152 dst->poc = src->poc;
3153 dst->ctb_count = src->ctb_count;
3154 dst->window = src->window;
3155 dst->flags = src->flags;
3156 dst->sequence = src->sequence;
3158 if (src->hwaccel_picture_private) {
3159 dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
3160 if (!dst->hwaccel_priv_buf)
3162 dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
3167 ff_hevc_unref_frame(s, dst, ~0);
3168 return AVERROR(ENOMEM);
3171 static av_cold int hevc_decode_free(AVCodecContext *avctx)
3173 HEVCContext *s = avctx->priv_data;
3178 av_freep(&s->md5_ctx);
3180 for(i=0; i < s->nals_allocated; i++) {
3181 av_freep(&s->skipped_bytes_pos_nal[i]);
3183 av_freep(&s->skipped_bytes_pos_size_nal);
3184 av_freep(&s->skipped_bytes_nal);
3185 av_freep(&s->skipped_bytes_pos_nal);
3187 av_freep(&s->cabac_state);
3189 av_frame_free(&s->tmp_frame);
3190 av_frame_free(&s->output_frame);
3192 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3193 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3194 av_frame_free(&s->DPB[i].frame);
3197 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++)
3198 av_buffer_unref(&s->vps_list[i]);
3199 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++)
3200 av_buffer_unref(&s->sps_list[i]);
3201 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
3202 av_buffer_unref(&s->pps_list[i]);
3207 av_buffer_unref(&s->current_sps);
3209 av_freep(&s->sh.entry_point_offset);
3210 av_freep(&s->sh.offset);
3211 av_freep(&s->sh.size);
3213 for (i = 1; i < s->threads_number; i++) {
3214 HEVCLocalContext *lc = s->HEVClcList[i];
3216 av_freep(&s->HEVClcList[i]);
3217 av_freep(&s->sList[i]);
3220 if (s->HEVClc == s->HEVClcList[0])
3222 av_freep(&s->HEVClcList[0]);
3224 for (i = 0; i < s->nals_allocated; i++)
3225 av_freep(&s->nals[i].rbsp_buffer);
3227 s->nals_allocated = 0;
3232 static av_cold int hevc_init_context(AVCodecContext *avctx)
3234 HEVCContext *s = avctx->priv_data;
3239 s->HEVClc = av_mallocz(sizeof(HEVCLocalContext));
3242 s->HEVClcList[0] = s->HEVClc;
3245 s->cabac_state = av_malloc(HEVC_CONTEXTS);
3246 if (!s->cabac_state)
3249 s->tmp_frame = av_frame_alloc();
3253 s->output_frame = av_frame_alloc();
3254 if (!s->output_frame)
3257 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3258 s->DPB[i].frame = av_frame_alloc();
3259 if (!s->DPB[i].frame)
3261 s->DPB[i].tf.f = s->DPB[i].frame;
3264 s->max_ra = INT_MAX;
3266 s->md5_ctx = av_md5_alloc();
3270 ff_bswapdsp_init(&s->bdsp);
3272 s->context_initialized = 1;
3278 hevc_decode_free(avctx);
3279 return AVERROR(ENOMEM);
3282 static int hevc_update_thread_context(AVCodecContext *dst,
3283 const AVCodecContext *src)
3285 HEVCContext *s = dst->priv_data;
3286 HEVCContext *s0 = src->priv_data;
3289 if (!s->context_initialized) {
3290 ret = hevc_init_context(dst);
3295 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3296 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3297 if (s0->DPB[i].frame->buf[0]) {
3298 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3304 if (s->sps != s0->sps)
3306 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++) {
3307 av_buffer_unref(&s->vps_list[i]);
3308 if (s0->vps_list[i]) {
3309 s->vps_list[i] = av_buffer_ref(s0->vps_list[i]);
3310 if (!s->vps_list[i])
3311 return AVERROR(ENOMEM);
3315 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++) {
3316 av_buffer_unref(&s->sps_list[i]);
3317 if (s0->sps_list[i]) {
3318 s->sps_list[i] = av_buffer_ref(s0->sps_list[i]);
3319 if (!s->sps_list[i])
3320 return AVERROR(ENOMEM);
3324 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++) {
3325 av_buffer_unref(&s->pps_list[i]);
3326 if (s0->pps_list[i]) {
3327 s->pps_list[i] = av_buffer_ref(s0->pps_list[i]);
3328 if (!s->pps_list[i])
3329 return AVERROR(ENOMEM);
3333 av_buffer_unref(&s->current_sps);
3334 if (s0->current_sps) {
3335 s->current_sps = av_buffer_ref(s0->current_sps);
3336 if (!s->current_sps)
3337 return AVERROR(ENOMEM);
3340 if (s->sps != s0->sps)
3341 if ((ret = set_sps(s, s0->sps)) < 0)
3344 s->seq_decode = s0->seq_decode;
3345 s->seq_output = s0->seq_output;
3346 s->pocTid0 = s0->pocTid0;
3347 s->max_ra = s0->max_ra;
3350 s->is_nalff = s0->is_nalff;
3351 s->nal_length_size = s0->nal_length_size;
3353 s->threads_number = s0->threads_number;
3354 s->threads_type = s0->threads_type;
3357 s->seq_decode = (s->seq_decode + 1) & 0xff;
3358 s->max_ra = INT_MAX;
3364 static int hevc_decode_extradata(HEVCContext *s)
3366 AVCodecContext *avctx = s->avctx;
3370 bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
3372 if (avctx->extradata_size > 3 &&
3373 (avctx->extradata[0] || avctx->extradata[1] ||
3374 avctx->extradata[2] > 1)) {
3375 /* It seems the extradata is encoded as hvcC format.
3376 * Temporarily, we support configurationVersion==0 until 14496-15 3rd
3377 * is finalized. When finalized, configurationVersion will be 1 and we
3378 * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
3379 int i, j, num_arrays, nal_len_size;
3383 bytestream2_skip(&gb, 21);
3384 nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
3385 num_arrays = bytestream2_get_byte(&gb);
3387 /* nal units in the hvcC always have length coded with 2 bytes,
3388 * so put a fake nal_length_size = 2 while parsing them */
3389 s->nal_length_size = 2;
3391 /* Decode nal units from hvcC. */
3392 for (i = 0; i < num_arrays; i++) {
3393 int type = bytestream2_get_byte(&gb) & 0x3f;
3394 int cnt = bytestream2_get_be16(&gb);
3396 for (j = 0; j < cnt; j++) {
3397 // +2 for the nal size field
3398 int nalsize = bytestream2_peek_be16(&gb) + 2;
3399 if (bytestream2_get_bytes_left(&gb) < nalsize) {
3400 av_log(s->avctx, AV_LOG_ERROR,
3401 "Invalid NAL unit size in extradata.\n");
3402 return AVERROR_INVALIDDATA;
3405 ret = decode_nal_units(s, gb.buffer, nalsize);
3407 av_log(avctx, AV_LOG_ERROR,
3408 "Decoding nal unit %d %d from hvcC failed\n",
3412 bytestream2_skip(&gb, nalsize);
3416 /* Now store right nal length size, that will be used to parse
3418 s->nal_length_size = nal_len_size;
3421 ret = decode_nal_units(s, avctx->extradata, avctx->extradata_size);
3428 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3430 HEVCContext *s = avctx->priv_data;
3433 ff_init_cabac_states();
3435 avctx->internal->allocate_progress = 1;
3437 ret = hevc_init_context(avctx);
3441 s->enable_parallel_tiles = 0;
3442 s->picture_struct = 0;
3444 if(avctx->active_thread_type & FF_THREAD_SLICE)
3445 s->threads_number = avctx->thread_count;
3447 s->threads_number = 1;
3449 if (avctx->extradata_size > 0 && avctx->extradata) {
3450 ret = hevc_decode_extradata(s);
3452 hevc_decode_free(avctx);
3457 if((avctx->active_thread_type & FF_THREAD_FRAME) && avctx->thread_count > 1)
3458 s->threads_type = FF_THREAD_FRAME;
3460 s->threads_type = FF_THREAD_SLICE;
3465 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3467 HEVCContext *s = avctx->priv_data;
3470 memset(s, 0, sizeof(*s));
3472 ret = hevc_init_context(avctx);
3479 static void hevc_decode_flush(AVCodecContext *avctx)
3481 HEVCContext *s = avctx->priv_data;
3482 ff_hevc_flush_dpb(s);
3483 s->max_ra = INT_MAX;
3486 #define OFFSET(x) offsetof(HEVCContext, x)
3487 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3489 static const AVProfile profiles[] = {
3490 { FF_PROFILE_HEVC_MAIN, "Main" },
3491 { FF_PROFILE_HEVC_MAIN_10, "Main 10" },
3492 { FF_PROFILE_HEVC_MAIN_STILL_PICTURE, "Main Still Picture" },
3493 { FF_PROFILE_HEVC_REXT, "Rext" },
3494 { FF_PROFILE_UNKNOWN },
3497 static const AVOption options[] = {
3498 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3499 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3500 { "strict-displaywin", "stricly apply default display window size", OFFSET(apply_defdispwin),
3501 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3505 static const AVClass hevc_decoder_class = {
3506 .class_name = "HEVC decoder",
3507 .item_name = av_default_item_name,
3509 .version = LIBAVUTIL_VERSION_INT,
3512 AVCodec ff_hevc_decoder = {
3514 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3515 .type = AVMEDIA_TYPE_VIDEO,
3516 .id = AV_CODEC_ID_HEVC,
3517 .priv_data_size = sizeof(HEVCContext),
3518 .priv_class = &hevc_decoder_class,
3519 .init = hevc_decode_init,
3520 .close = hevc_decode_free,
3521 .decode = hevc_decode_frame,
3522 .flush = hevc_decode_flush,
3523 .update_thread_context = hevc_update_thread_context,
3524 .init_thread_copy = hevc_init_thread_copy,
3525 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY |
3526 CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS,
3527 .profiles = NULL_IF_CONFIG_SMALL(profiles),