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 = s->avctx->coded_width + 2;
288 frame->height = s->avctx->coded_height + 2;
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] + (1 << sps->pixel_shift);
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 sh->slice_sample_adaptive_offset_flag[1] =
557 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
559 sh->slice_sample_adaptive_offset_flag[0] = 0;
560 sh->slice_sample_adaptive_offset_flag[1] = 0;
561 sh->slice_sample_adaptive_offset_flag[2] = 0;
564 sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
565 if (sh->slice_type == P_SLICE || sh->slice_type == B_SLICE) {
568 sh->nb_refs[L0] = s->pps->num_ref_idx_l0_default_active;
569 if (sh->slice_type == B_SLICE)
570 sh->nb_refs[L1] = s->pps->num_ref_idx_l1_default_active;
572 if (get_bits1(gb)) { // num_ref_idx_active_override_flag
573 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
574 if (sh->slice_type == B_SLICE)
575 sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
577 if (sh->nb_refs[L0] > MAX_REFS || sh->nb_refs[L1] > MAX_REFS) {
578 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
579 sh->nb_refs[L0], sh->nb_refs[L1]);
580 return AVERROR_INVALIDDATA;
583 sh->rpl_modification_flag[0] = 0;
584 sh->rpl_modification_flag[1] = 0;
585 nb_refs = ff_hevc_frame_nb_refs(s);
587 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
588 return AVERROR_INVALIDDATA;
591 if (s->pps->lists_modification_present_flag && nb_refs > 1) {
592 sh->rpl_modification_flag[0] = get_bits1(gb);
593 if (sh->rpl_modification_flag[0]) {
594 for (i = 0; i < sh->nb_refs[L0]; i++)
595 sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
598 if (sh->slice_type == B_SLICE) {
599 sh->rpl_modification_flag[1] = get_bits1(gb);
600 if (sh->rpl_modification_flag[1] == 1)
601 for (i = 0; i < sh->nb_refs[L1]; i++)
602 sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
606 if (sh->slice_type == B_SLICE)
607 sh->mvd_l1_zero_flag = get_bits1(gb);
609 if (s->pps->cabac_init_present_flag)
610 sh->cabac_init_flag = get_bits1(gb);
612 sh->cabac_init_flag = 0;
614 sh->collocated_ref_idx = 0;
615 if (sh->slice_temporal_mvp_enabled_flag) {
616 sh->collocated_list = L0;
617 if (sh->slice_type == B_SLICE)
618 sh->collocated_list = !get_bits1(gb);
620 if (sh->nb_refs[sh->collocated_list] > 1) {
621 sh->collocated_ref_idx = get_ue_golomb_long(gb);
622 if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
623 av_log(s->avctx, AV_LOG_ERROR,
624 "Invalid collocated_ref_idx: %d.\n",
625 sh->collocated_ref_idx);
626 return AVERROR_INVALIDDATA;
631 if ((s->pps->weighted_pred_flag && sh->slice_type == P_SLICE) ||
632 (s->pps->weighted_bipred_flag && sh->slice_type == B_SLICE)) {
633 pred_weight_table(s, gb);
636 sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
637 if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
638 av_log(s->avctx, AV_LOG_ERROR,
639 "Invalid number of merging MVP candidates: %d.\n",
640 sh->max_num_merge_cand);
641 return AVERROR_INVALIDDATA;
645 sh->slice_qp_delta = get_se_golomb(gb);
647 if (s->pps->pic_slice_level_chroma_qp_offsets_present_flag) {
648 sh->slice_cb_qp_offset = get_se_golomb(gb);
649 sh->slice_cr_qp_offset = get_se_golomb(gb);
651 sh->slice_cb_qp_offset = 0;
652 sh->slice_cr_qp_offset = 0;
655 if (s->pps->chroma_qp_offset_list_enabled_flag)
656 sh->cu_chroma_qp_offset_enabled_flag = get_bits1(gb);
658 sh->cu_chroma_qp_offset_enabled_flag = 0;
660 if (s->pps->deblocking_filter_control_present_flag) {
661 int deblocking_filter_override_flag = 0;
663 if (s->pps->deblocking_filter_override_enabled_flag)
664 deblocking_filter_override_flag = get_bits1(gb);
666 if (deblocking_filter_override_flag) {
667 sh->disable_deblocking_filter_flag = get_bits1(gb);
668 if (!sh->disable_deblocking_filter_flag) {
669 sh->beta_offset = get_se_golomb(gb) * 2;
670 sh->tc_offset = get_se_golomb(gb) * 2;
673 sh->disable_deblocking_filter_flag = s->pps->disable_dbf;
674 sh->beta_offset = s->pps->beta_offset;
675 sh->tc_offset = s->pps->tc_offset;
678 sh->disable_deblocking_filter_flag = 0;
683 if (s->pps->seq_loop_filter_across_slices_enabled_flag &&
684 (sh->slice_sample_adaptive_offset_flag[0] ||
685 sh->slice_sample_adaptive_offset_flag[1] ||
686 !sh->disable_deblocking_filter_flag)) {
687 sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
689 sh->slice_loop_filter_across_slices_enabled_flag = s->pps->seq_loop_filter_across_slices_enabled_flag;
691 } else if (!s->slice_initialized) {
692 av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
693 return AVERROR_INVALIDDATA;
696 sh->num_entry_point_offsets = 0;
697 if (s->pps->tiles_enabled_flag || s->pps->entropy_coding_sync_enabled_flag) {
698 sh->num_entry_point_offsets = get_ue_golomb_long(gb);
699 if (sh->num_entry_point_offsets > 0) {
700 int offset_len = get_ue_golomb_long(gb) + 1;
701 int segments = offset_len >> 4;
702 int rest = (offset_len & 15);
703 av_freep(&sh->entry_point_offset);
704 av_freep(&sh->offset);
706 sh->entry_point_offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
707 sh->offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
708 sh->size = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
709 if (!sh->entry_point_offset || !sh->offset || !sh->size) {
710 sh->num_entry_point_offsets = 0;
711 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate memory\n");
712 return AVERROR(ENOMEM);
714 for (i = 0; i < sh->num_entry_point_offsets; i++) {
716 for (j = 0; j < segments; j++) {
718 val += get_bits(gb, 16);
722 val += get_bits(gb, rest);
724 sh->entry_point_offset[i] = val + 1; // +1; // +1 to get the size
726 if (s->threads_number > 1 && (s->pps->num_tile_rows > 1 || s->pps->num_tile_columns > 1)) {
727 s->enable_parallel_tiles = 0; // TODO: you can enable tiles in parallel here
728 s->threads_number = 1;
730 s->enable_parallel_tiles = 0;
732 s->enable_parallel_tiles = 0;
735 if (s->pps->slice_header_extension_present_flag) {
736 unsigned int length = get_ue_golomb_long(gb);
737 if (length*8LL > get_bits_left(gb)) {
738 av_log(s->avctx, AV_LOG_ERROR, "too many slice_header_extension_data_bytes\n");
739 return AVERROR_INVALIDDATA;
741 for (i = 0; i < length; i++)
742 skip_bits(gb, 8); // slice_header_extension_data_byte
745 // Inferred parameters
746 sh->slice_qp = 26U + s->pps->pic_init_qp_minus26 + sh->slice_qp_delta;
747 if (sh->slice_qp > 51 ||
748 sh->slice_qp < -s->sps->qp_bd_offset) {
749 av_log(s->avctx, AV_LOG_ERROR,
750 "The slice_qp %d is outside the valid range "
753 -s->sps->qp_bd_offset);
754 return AVERROR_INVALIDDATA;
757 sh->slice_ctb_addr_rs = sh->slice_segment_addr;
759 if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) {
760 av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
761 return AVERROR_INVALIDDATA;
764 if (get_bits_left(gb) < 0) {
765 av_log(s->avctx, AV_LOG_ERROR,
766 "Overread slice header by %d bits\n", -get_bits_left(gb));
767 return AVERROR_INVALIDDATA;
770 s->HEVClc->first_qp_group = !s->sh.dependent_slice_segment_flag;
772 if (!s->pps->cu_qp_delta_enabled_flag)
773 s->HEVClc->qp_y = s->sh.slice_qp;
775 s->slice_initialized = 1;
776 s->HEVClc->tu.cu_qp_offset_cb = 0;
777 s->HEVClc->tu.cu_qp_offset_cr = 0;
782 #define CTB(tab, x, y) ((tab)[(y) * s->sps->ctb_width + (x)])
784 #define SET_SAO(elem, value) \
786 if (!sao_merge_up_flag && !sao_merge_left_flag) \
788 else if (sao_merge_left_flag) \
789 sao->elem = CTB(s->sao, rx-1, ry).elem; \
790 else if (sao_merge_up_flag) \
791 sao->elem = CTB(s->sao, rx, ry-1).elem; \
796 static void hls_sao_param(HEVCContext *s, int rx, int ry)
798 HEVCLocalContext *lc = s->HEVClc;
799 int sao_merge_left_flag = 0;
800 int sao_merge_up_flag = 0;
801 SAOParams *sao = &CTB(s->sao, rx, ry);
804 if (s->sh.slice_sample_adaptive_offset_flag[0] ||
805 s->sh.slice_sample_adaptive_offset_flag[1]) {
807 if (lc->ctb_left_flag)
808 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
810 if (ry > 0 && !sao_merge_left_flag) {
812 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
816 for (c_idx = 0; c_idx < 3; c_idx++) {
817 int log2_sao_offset_scale = c_idx == 0 ? s->pps->log2_sao_offset_scale_luma :
818 s->pps->log2_sao_offset_scale_chroma;
820 if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
821 sao->type_idx[c_idx] = SAO_NOT_APPLIED;
826 sao->type_idx[2] = sao->type_idx[1];
827 sao->eo_class[2] = sao->eo_class[1];
829 SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
832 if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
835 for (i = 0; i < 4; i++)
836 SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
838 if (sao->type_idx[c_idx] == SAO_BAND) {
839 for (i = 0; i < 4; i++) {
840 if (sao->offset_abs[c_idx][i]) {
841 SET_SAO(offset_sign[c_idx][i],
842 ff_hevc_sao_offset_sign_decode(s));
844 sao->offset_sign[c_idx][i] = 0;
847 SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
848 } else if (c_idx != 2) {
849 SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
852 // Inferred parameters
853 sao->offset_val[c_idx][0] = 0;
854 for (i = 0; i < 4; i++) {
855 sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i];
856 if (sao->type_idx[c_idx] == SAO_EDGE) {
858 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
859 } else if (sao->offset_sign[c_idx][i]) {
860 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
862 sao->offset_val[c_idx][i + 1] <<= log2_sao_offset_scale;
870 static int hls_cross_component_pred(HEVCContext *s, int idx) {
871 HEVCLocalContext *lc = s->HEVClc;
872 int log2_res_scale_abs_plus1 = ff_hevc_log2_res_scale_abs(s, idx);
874 if (log2_res_scale_abs_plus1 != 0) {
875 int res_scale_sign_flag = ff_hevc_res_scale_sign_flag(s, idx);
876 lc->tu.res_scale_val = (1 << (log2_res_scale_abs_plus1 - 1)) *
877 (1 - 2 * res_scale_sign_flag);
879 lc->tu.res_scale_val = 0;
886 static int hls_transform_unit(HEVCContext *s, int x0, int y0,
887 int xBase, int yBase, int cb_xBase, int cb_yBase,
888 int log2_cb_size, int log2_trafo_size,
889 int blk_idx, int cbf_luma, int *cbf_cb, int *cbf_cr)
891 HEVCLocalContext *lc = s->HEVClc;
892 const int log2_trafo_size_c = log2_trafo_size - s->sps->hshift[1];
895 if (lc->cu.pred_mode == MODE_INTRA) {
896 int trafo_size = 1 << log2_trafo_size;
897 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
899 s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
902 if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
903 (s->sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
904 int scan_idx = SCAN_DIAG;
905 int scan_idx_c = SCAN_DIAG;
906 int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
907 (s->sps->chroma_format_idc == 2 &&
908 (cbf_cb[1] || cbf_cr[1]));
910 if (s->pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
911 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
912 if (lc->tu.cu_qp_delta != 0)
913 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
914 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
915 lc->tu.is_cu_qp_delta_coded = 1;
917 if (lc->tu.cu_qp_delta < -(26 + s->sps->qp_bd_offset / 2) ||
918 lc->tu.cu_qp_delta > (25 + s->sps->qp_bd_offset / 2)) {
919 av_log(s->avctx, AV_LOG_ERROR,
920 "The cu_qp_delta %d is outside the valid range "
923 -(26 + s->sps->qp_bd_offset / 2),
924 (25 + s->sps->qp_bd_offset / 2));
925 return AVERROR_INVALIDDATA;
928 ff_hevc_set_qPy(s, cb_xBase, cb_yBase, log2_cb_size);
931 if (s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
932 !lc->cu.cu_transquant_bypass_flag && !lc->tu.is_cu_chroma_qp_offset_coded) {
933 int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(s);
934 if (cu_chroma_qp_offset_flag) {
935 int cu_chroma_qp_offset_idx = 0;
936 if (s->pps->chroma_qp_offset_list_len_minus1 > 0) {
937 cu_chroma_qp_offset_idx = ff_hevc_cu_chroma_qp_offset_idx(s);
938 av_log(s->avctx, AV_LOG_ERROR,
939 "cu_chroma_qp_offset_idx not yet tested.\n");
941 lc->tu.cu_qp_offset_cb = s->pps->cb_qp_offset_list[cu_chroma_qp_offset_idx];
942 lc->tu.cu_qp_offset_cr = s->pps->cr_qp_offset_list[cu_chroma_qp_offset_idx];
944 lc->tu.cu_qp_offset_cb = 0;
945 lc->tu.cu_qp_offset_cr = 0;
947 lc->tu.is_cu_chroma_qp_offset_coded = 1;
950 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
951 if (lc->tu.intra_pred_mode >= 6 &&
952 lc->tu.intra_pred_mode <= 14) {
953 scan_idx = SCAN_VERT;
954 } else if (lc->tu.intra_pred_mode >= 22 &&
955 lc->tu.intra_pred_mode <= 30) {
956 scan_idx = SCAN_HORIZ;
959 if (lc->tu.intra_pred_mode_c >= 6 &&
960 lc->tu.intra_pred_mode_c <= 14) {
961 scan_idx_c = SCAN_VERT;
962 } else if (lc->tu.intra_pred_mode_c >= 22 &&
963 lc->tu.intra_pred_mode_c <= 30) {
964 scan_idx_c = SCAN_HORIZ;
971 ff_hevc_hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
972 if (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3) {
973 int trafo_size_h = 1 << (log2_trafo_size_c + s->sps->hshift[1]);
974 int trafo_size_v = 1 << (log2_trafo_size_c + s->sps->vshift[1]);
975 lc->tu.cross_pf = (s->pps->cross_component_prediction_enabled_flag && cbf_luma &&
976 (lc->cu.pred_mode == MODE_INTER ||
977 (lc->tu.chroma_mode_c == 4)));
979 if (lc->tu.cross_pf) {
980 hls_cross_component_pred(s, 0);
982 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
983 if (lc->cu.pred_mode == MODE_INTRA) {
984 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
985 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 1);
988 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
989 log2_trafo_size_c, scan_idx_c, 1);
991 if (lc->tu.cross_pf) {
992 ptrdiff_t stride = s->frame->linesize[1];
993 int hshift = s->sps->hshift[1];
994 int vshift = s->sps->vshift[1];
995 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
996 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
997 int size = 1 << log2_trafo_size_c;
999 uint8_t *dst = &s->frame->data[1][(y0 >> vshift) * stride +
1000 ((x0 >> hshift) << s->sps->pixel_shift)];
1001 for (i = 0; i < (size * size); i++) {
1002 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1004 s->hevcdsp.transform_add[log2_trafo_size_c-2](dst, coeffs, stride);
1008 if (lc->tu.cross_pf) {
1009 hls_cross_component_pred(s, 1);
1011 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1012 if (lc->cu.pred_mode == MODE_INTRA) {
1013 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1014 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 2);
1017 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1018 log2_trafo_size_c, scan_idx_c, 2);
1020 if (lc->tu.cross_pf) {
1021 ptrdiff_t stride = s->frame->linesize[2];
1022 int hshift = s->sps->hshift[2];
1023 int vshift = s->sps->vshift[2];
1024 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1025 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1026 int size = 1 << log2_trafo_size_c;
1028 uint8_t *dst = &s->frame->data[2][(y0 >> vshift) * stride +
1029 ((x0 >> hshift) << s->sps->pixel_shift)];
1030 for (i = 0; i < (size * size); i++) {
1031 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1033 s->hevcdsp.transform_add[log2_trafo_size_c-2](dst, coeffs, stride);
1036 } else if (blk_idx == 3) {
1037 int trafo_size_h = 1 << (log2_trafo_size + 1);
1038 int trafo_size_v = 1 << (log2_trafo_size + s->sps->vshift[1]);
1039 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1040 if (lc->cu.pred_mode == MODE_INTRA) {
1041 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1042 trafo_size_h, trafo_size_v);
1043 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 1);
1046 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1047 log2_trafo_size, scan_idx_c, 1);
1049 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1050 if (lc->cu.pred_mode == MODE_INTRA) {
1051 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1052 trafo_size_h, trafo_size_v);
1053 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 2);
1056 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1057 log2_trafo_size, scan_idx_c, 2);
1060 } else if (lc->cu.pred_mode == MODE_INTRA) {
1061 if (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3) {
1062 int trafo_size_h = 1 << (log2_trafo_size_c + s->sps->hshift[1]);
1063 int trafo_size_v = 1 << (log2_trafo_size_c + s->sps->vshift[1]);
1064 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size_h, trafo_size_v);
1065 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 1);
1066 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 2);
1067 if (s->sps->chroma_format_idc == 2) {
1068 ff_hevc_set_neighbour_available(s, x0, y0 + (1 << log2_trafo_size_c),
1069 trafo_size_h, trafo_size_v);
1070 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 1);
1071 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 2);
1073 } else if (blk_idx == 3) {
1074 int trafo_size_h = 1 << (log2_trafo_size + 1);
1075 int trafo_size_v = 1 << (log2_trafo_size + s->sps->vshift[1]);
1076 ff_hevc_set_neighbour_available(s, xBase, yBase,
1077 trafo_size_h, trafo_size_v);
1078 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1079 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1080 if (s->sps->chroma_format_idc == 2) {
1081 ff_hevc_set_neighbour_available(s, xBase, yBase + (1 << (log2_trafo_size)),
1082 trafo_size_h, trafo_size_v);
1083 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 1);
1084 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 2);
1092 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1094 int cb_size = 1 << log2_cb_size;
1095 int log2_min_pu_size = s->sps->log2_min_pu_size;
1097 int min_pu_width = s->sps->min_pu_width;
1098 int x_end = FFMIN(x0 + cb_size, s->sps->width);
1099 int y_end = FFMIN(y0 + cb_size, s->sps->height);
1102 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1103 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1104 s->is_pcm[i + j * min_pu_width] = 2;
1107 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1108 int xBase, int yBase, int cb_xBase, int cb_yBase,
1109 int log2_cb_size, int log2_trafo_size,
1110 int trafo_depth, int blk_idx,
1111 const int *base_cbf_cb, const int *base_cbf_cr)
1113 HEVCLocalContext *lc = s->HEVClc;
1114 uint8_t split_transform_flag;
1119 cbf_cb[0] = base_cbf_cb[0];
1120 cbf_cb[1] = base_cbf_cb[1];
1121 cbf_cr[0] = base_cbf_cr[0];
1122 cbf_cr[1] = base_cbf_cr[1];
1124 if (lc->cu.intra_split_flag) {
1125 if (trafo_depth == 1) {
1126 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1127 if (s->sps->chroma_format_idc == 3) {
1128 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[blk_idx];
1129 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[blk_idx];
1131 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1132 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1136 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[0];
1137 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1138 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1141 if (log2_trafo_size <= s->sps->log2_max_trafo_size &&
1142 log2_trafo_size > s->sps->log2_min_tb_size &&
1143 trafo_depth < lc->cu.max_trafo_depth &&
1144 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1145 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1147 int inter_split = s->sps->max_transform_hierarchy_depth_inter == 0 &&
1148 lc->cu.pred_mode == MODE_INTER &&
1149 lc->cu.part_mode != PART_2Nx2N &&
1152 split_transform_flag = log2_trafo_size > s->sps->log2_max_trafo_size ||
1153 (lc->cu.intra_split_flag && trafo_depth == 0) ||
1157 if (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3) {
1158 if (trafo_depth == 0 || cbf_cb[0]) {
1159 cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1160 if (s->sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1161 cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1165 if (trafo_depth == 0 || cbf_cr[0]) {
1166 cbf_cr[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1167 if (s->sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1168 cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1173 if (split_transform_flag) {
1174 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1175 const int x1 = x0 + trafo_size_split;
1176 const int y1 = y0 + trafo_size_split;
1178 #define SUBDIVIDE(x, y, idx) \
1180 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1181 log2_trafo_size - 1, trafo_depth + 1, idx, \
1187 SUBDIVIDE(x0, y0, 0);
1188 SUBDIVIDE(x1, y0, 1);
1189 SUBDIVIDE(x0, y1, 2);
1190 SUBDIVIDE(x1, y1, 3);
1194 int min_tu_size = 1 << s->sps->log2_min_tb_size;
1195 int log2_min_tu_size = s->sps->log2_min_tb_size;
1196 int min_tu_width = s->sps->min_tb_width;
1199 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1200 cbf_cb[0] || cbf_cr[0] ||
1201 (s->sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1202 cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1205 ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1206 log2_cb_size, log2_trafo_size,
1207 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1210 // TODO: store cbf_luma somewhere else
1213 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1214 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1215 int x_tu = (x0 + j) >> log2_min_tu_size;
1216 int y_tu = (y0 + i) >> log2_min_tu_size;
1217 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1220 if (!s->sh.disable_deblocking_filter_flag) {
1221 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1222 if (s->pps->transquant_bypass_enable_flag &&
1223 lc->cu.cu_transquant_bypass_flag)
1224 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1230 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1232 HEVCLocalContext *lc = s->HEVClc;
1234 int cb_size = 1 << log2_cb_size;
1235 int stride0 = s->frame->linesize[0];
1236 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->sps->pixel_shift)];
1237 int stride1 = s->frame->linesize[1];
1238 uint8_t *dst1 = &s->frame->data[1][(y0 >> s->sps->vshift[1]) * stride1 + ((x0 >> s->sps->hshift[1]) << s->sps->pixel_shift)];
1239 int stride2 = s->frame->linesize[2];
1240 uint8_t *dst2 = &s->frame->data[2][(y0 >> s->sps->vshift[2]) * stride2 + ((x0 >> s->sps->hshift[2]) << s->sps->pixel_shift)];
1242 int length = cb_size * cb_size * s->sps->pcm.bit_depth +
1243 (((cb_size >> s->sps->hshift[1]) * (cb_size >> s->sps->vshift[1])) +
1244 ((cb_size >> s->sps->hshift[2]) * (cb_size >> s->sps->vshift[2]))) *
1245 s->sps->pcm.bit_depth_chroma;
1246 const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1249 if (!s->sh.disable_deblocking_filter_flag)
1250 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1252 ret = init_get_bits(&gb, pcm, length);
1256 s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size, &gb, s->sps->pcm.bit_depth);
1257 s->hevcdsp.put_pcm(dst1, stride1,
1258 cb_size >> s->sps->hshift[1],
1259 cb_size >> s->sps->vshift[1],
1260 &gb, s->sps->pcm.bit_depth_chroma);
1261 s->hevcdsp.put_pcm(dst2, stride2,
1262 cb_size >> s->sps->hshift[2],
1263 cb_size >> s->sps->vshift[2],
1264 &gb, s->sps->pcm.bit_depth_chroma);
1269 * 8.5.3.2.2.1 Luma sample unidirectional interpolation process
1271 * @param s HEVC decoding context
1272 * @param dst target buffer for block data at block position
1273 * @param dststride stride of the dst buffer
1274 * @param ref reference picture buffer at origin (0, 0)
1275 * @param mv motion vector (relative to block position) to get pixel data from
1276 * @param x_off horizontal position of block from origin (0, 0)
1277 * @param y_off vertical position of block from origin (0, 0)
1278 * @param block_w width of block
1279 * @param block_h height of block
1280 * @param luma_weight weighting factor applied to the luma prediction
1281 * @param luma_offset additive offset applied to the luma prediction value
1284 static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1285 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1286 int block_w, int block_h, int luma_weight, int luma_offset)
1288 HEVCLocalContext *lc = s->HEVClc;
1289 uint8_t *src = ref->data[0];
1290 ptrdiff_t srcstride = ref->linesize[0];
1291 int pic_width = s->sps->width;
1292 int pic_height = s->sps->height;
1295 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1296 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1297 int idx = ff_hevc_pel_weight[block_w];
1299 x_off += mv->x >> 2;
1300 y_off += mv->y >> 2;
1301 src += y_off * srcstride + (x_off << s->sps->pixel_shift);
1303 if (x_off < QPEL_EXTRA_BEFORE || y_off < QPEL_EXTRA_AFTER ||
1304 x_off >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1305 y_off >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1306 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1307 int offset = QPEL_EXTRA_BEFORE * srcstride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1308 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1310 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1311 edge_emu_stride, srcstride,
1312 block_w + QPEL_EXTRA,
1313 block_h + QPEL_EXTRA,
1314 x_off - QPEL_EXTRA_BEFORE, y_off - QPEL_EXTRA_BEFORE,
1315 pic_width, pic_height);
1316 src = lc->edge_emu_buffer + buf_offset;
1317 srcstride = edge_emu_stride;
1321 s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride, src, srcstride,
1322 block_h, mx, my, block_w);
1324 s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride, src, srcstride,
1325 block_h, s->sh.luma_log2_weight_denom,
1326 luma_weight, luma_offset, mx, my, block_w);
1330 * 8.5.3.2.2.1 Luma sample bidirectional interpolation process
1332 * @param s HEVC decoding context
1333 * @param dst target buffer for block data at block position
1334 * @param dststride stride of the dst buffer
1335 * @param ref0 reference picture0 buffer at origin (0, 0)
1336 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1337 * @param x_off horizontal position of block from origin (0, 0)
1338 * @param y_off vertical position of block from origin (0, 0)
1339 * @param block_w width of block
1340 * @param block_h height of block
1341 * @param ref1 reference picture1 buffer at origin (0, 0)
1342 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1343 * @param current_mv current motion vector structure
1345 static void luma_mc_bi(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1346 AVFrame *ref0, const Mv *mv0, int x_off, int y_off,
1347 int block_w, int block_h, AVFrame *ref1, const Mv *mv1, struct MvField *current_mv)
1349 HEVCLocalContext *lc = s->HEVClc;
1350 ptrdiff_t src0stride = ref0->linesize[0];
1351 ptrdiff_t src1stride = ref1->linesize[0];
1352 int pic_width = s->sps->width;
1353 int pic_height = s->sps->height;
1354 int mx0 = mv0->x & 3;
1355 int my0 = mv0->y & 3;
1356 int mx1 = mv1->x & 3;
1357 int my1 = mv1->y & 3;
1358 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1359 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1360 int x_off0 = x_off + (mv0->x >> 2);
1361 int y_off0 = y_off + (mv0->y >> 2);
1362 int x_off1 = x_off + (mv1->x >> 2);
1363 int y_off1 = y_off + (mv1->y >> 2);
1364 int idx = ff_hevc_pel_weight[block_w];
1366 uint8_t *src0 = ref0->data[0] + y_off0 * src0stride + (int)((unsigned)x_off0 << s->sps->pixel_shift);
1367 uint8_t *src1 = ref1->data[0] + y_off1 * src1stride + (int)((unsigned)x_off1 << s->sps->pixel_shift);
1369 if (x_off0 < QPEL_EXTRA_BEFORE || y_off0 < QPEL_EXTRA_AFTER ||
1370 x_off0 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1371 y_off0 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1372 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1373 int offset = QPEL_EXTRA_BEFORE * src0stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1374 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1376 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset,
1377 edge_emu_stride, src0stride,
1378 block_w + QPEL_EXTRA,
1379 block_h + QPEL_EXTRA,
1380 x_off0 - QPEL_EXTRA_BEFORE, y_off0 - QPEL_EXTRA_BEFORE,
1381 pic_width, pic_height);
1382 src0 = lc->edge_emu_buffer + buf_offset;
1383 src0stride = edge_emu_stride;
1386 if (x_off1 < QPEL_EXTRA_BEFORE || y_off1 < QPEL_EXTRA_AFTER ||
1387 x_off1 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1388 y_off1 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1389 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1390 int offset = QPEL_EXTRA_BEFORE * src1stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1391 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1393 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src1 - offset,
1394 edge_emu_stride, src1stride,
1395 block_w + QPEL_EXTRA,
1396 block_h + QPEL_EXTRA,
1397 x_off1 - QPEL_EXTRA_BEFORE, y_off1 - QPEL_EXTRA_BEFORE,
1398 pic_width, pic_height);
1399 src1 = lc->edge_emu_buffer2 + buf_offset;
1400 src1stride = edge_emu_stride;
1403 s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](lc->tmp, src0, src0stride,
1404 block_h, mx0, my0, block_w);
1406 s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1407 block_h, mx1, my1, block_w);
1409 s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1410 block_h, s->sh.luma_log2_weight_denom,
1411 s->sh.luma_weight_l0[current_mv->ref_idx[0]],
1412 s->sh.luma_weight_l1[current_mv->ref_idx[1]],
1413 s->sh.luma_offset_l0[current_mv->ref_idx[0]],
1414 s->sh.luma_offset_l1[current_mv->ref_idx[1]],
1420 * 8.5.3.2.2.2 Chroma sample uniprediction interpolation process
1422 * @param s HEVC decoding context
1423 * @param dst1 target buffer for block data at block position (U plane)
1424 * @param dst2 target buffer for block data at block position (V plane)
1425 * @param dststride stride of the dst1 and dst2 buffers
1426 * @param ref reference picture buffer at origin (0, 0)
1427 * @param mv motion vector (relative to block position) to get pixel data from
1428 * @param x_off horizontal position of block from origin (0, 0)
1429 * @param y_off vertical position of block from origin (0, 0)
1430 * @param block_w width of block
1431 * @param block_h height of block
1432 * @param chroma_weight weighting factor applied to the chroma prediction
1433 * @param chroma_offset additive offset applied to the chroma prediction value
1436 static void chroma_mc_uni(HEVCContext *s, uint8_t *dst0,
1437 ptrdiff_t dststride, uint8_t *src0, ptrdiff_t srcstride, int reflist,
1438 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int chroma_weight, int chroma_offset)
1440 HEVCLocalContext *lc = s->HEVClc;
1441 int pic_width = s->sps->width >> s->sps->hshift[1];
1442 int pic_height = s->sps->height >> s->sps->vshift[1];
1443 const Mv *mv = ¤t_mv->mv[reflist];
1444 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1445 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1446 int idx = ff_hevc_pel_weight[block_w];
1447 int hshift = s->sps->hshift[1];
1448 int vshift = s->sps->vshift[1];
1449 intptr_t mx = mv->x & ((1 << (2 + hshift)) - 1);
1450 intptr_t my = mv->y & ((1 << (2 + vshift)) - 1);
1451 intptr_t _mx = mx << (1 - hshift);
1452 intptr_t _my = my << (1 - vshift);
1454 x_off += mv->x >> (2 + hshift);
1455 y_off += mv->y >> (2 + vshift);
1456 src0 += y_off * srcstride + (x_off << s->sps->pixel_shift);
1458 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1459 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1460 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1461 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1462 int offset0 = EPEL_EXTRA_BEFORE * (srcstride + (1 << s->sps->pixel_shift));
1463 int buf_offset0 = EPEL_EXTRA_BEFORE *
1464 (edge_emu_stride + (1 << s->sps->pixel_shift));
1465 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset0,
1466 edge_emu_stride, srcstride,
1467 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1468 x_off - EPEL_EXTRA_BEFORE,
1469 y_off - EPEL_EXTRA_BEFORE,
1470 pic_width, pic_height);
1472 src0 = lc->edge_emu_buffer + buf_offset0;
1473 srcstride = edge_emu_stride;
1476 s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1477 block_h, _mx, _my, block_w);
1479 s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1480 block_h, s->sh.chroma_log2_weight_denom,
1481 chroma_weight, chroma_offset, _mx, _my, block_w);
1485 * 8.5.3.2.2.2 Chroma sample bidirectional interpolation process
1487 * @param s HEVC decoding context
1488 * @param dst target buffer for block data at block position
1489 * @param dststride stride of the dst buffer
1490 * @param ref0 reference picture0 buffer at origin (0, 0)
1491 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1492 * @param x_off horizontal position of block from origin (0, 0)
1493 * @param y_off vertical position of block from origin (0, 0)
1494 * @param block_w width of block
1495 * @param block_h height of block
1496 * @param ref1 reference picture1 buffer at origin (0, 0)
1497 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1498 * @param current_mv current motion vector structure
1499 * @param cidx chroma component(cb, cr)
1501 static void chroma_mc_bi(HEVCContext *s, uint8_t *dst0, ptrdiff_t dststride, AVFrame *ref0, AVFrame *ref1,
1502 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int cidx)
1504 HEVCLocalContext *lc = s->HEVClc;
1505 uint8_t *src1 = ref0->data[cidx+1];
1506 uint8_t *src2 = ref1->data[cidx+1];
1507 ptrdiff_t src1stride = ref0->linesize[cidx+1];
1508 ptrdiff_t src2stride = ref1->linesize[cidx+1];
1509 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1510 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1511 int pic_width = s->sps->width >> s->sps->hshift[1];
1512 int pic_height = s->sps->height >> s->sps->vshift[1];
1513 Mv *mv0 = ¤t_mv->mv[0];
1514 Mv *mv1 = ¤t_mv->mv[1];
1515 int hshift = s->sps->hshift[1];
1516 int vshift = s->sps->vshift[1];
1518 intptr_t mx0 = mv0->x & ((1 << (2 + hshift)) - 1);
1519 intptr_t my0 = mv0->y & ((1 << (2 + vshift)) - 1);
1520 intptr_t mx1 = mv1->x & ((1 << (2 + hshift)) - 1);
1521 intptr_t my1 = mv1->y & ((1 << (2 + vshift)) - 1);
1522 intptr_t _mx0 = mx0 << (1 - hshift);
1523 intptr_t _my0 = my0 << (1 - vshift);
1524 intptr_t _mx1 = mx1 << (1 - hshift);
1525 intptr_t _my1 = my1 << (1 - vshift);
1527 int x_off0 = x_off + (mv0->x >> (2 + hshift));
1528 int y_off0 = y_off + (mv0->y >> (2 + vshift));
1529 int x_off1 = x_off + (mv1->x >> (2 + hshift));
1530 int y_off1 = y_off + (mv1->y >> (2 + vshift));
1531 int idx = ff_hevc_pel_weight[block_w];
1532 src1 += y_off0 * src1stride + (int)((unsigned)x_off0 << s->sps->pixel_shift);
1533 src2 += y_off1 * src2stride + (int)((unsigned)x_off1 << s->sps->pixel_shift);
1535 if (x_off0 < EPEL_EXTRA_BEFORE || y_off0 < EPEL_EXTRA_AFTER ||
1536 x_off0 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1537 y_off0 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1538 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1539 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->sps->pixel_shift));
1540 int buf_offset1 = EPEL_EXTRA_BEFORE *
1541 (edge_emu_stride + (1 << s->sps->pixel_shift));
1543 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1544 edge_emu_stride, src1stride,
1545 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1546 x_off0 - EPEL_EXTRA_BEFORE,
1547 y_off0 - EPEL_EXTRA_BEFORE,
1548 pic_width, pic_height);
1550 src1 = lc->edge_emu_buffer + buf_offset1;
1551 src1stride = edge_emu_stride;
1554 if (x_off1 < EPEL_EXTRA_BEFORE || y_off1 < EPEL_EXTRA_AFTER ||
1555 x_off1 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1556 y_off1 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1557 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1558 int offset1 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->sps->pixel_shift));
1559 int buf_offset1 = EPEL_EXTRA_BEFORE *
1560 (edge_emu_stride + (1 << s->sps->pixel_shift));
1562 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src2 - offset1,
1563 edge_emu_stride, src2stride,
1564 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1565 x_off1 - EPEL_EXTRA_BEFORE,
1566 y_off1 - EPEL_EXTRA_BEFORE,
1567 pic_width, pic_height);
1569 src2 = lc->edge_emu_buffer2 + buf_offset1;
1570 src2stride = edge_emu_stride;
1573 s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](lc->tmp, src1, src1stride,
1574 block_h, _mx0, _my0, block_w);
1576 s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1577 src2, src2stride, lc->tmp,
1578 block_h, _mx1, _my1, block_w);
1580 s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1581 src2, src2stride, lc->tmp,
1583 s->sh.chroma_log2_weight_denom,
1584 s->sh.chroma_weight_l0[current_mv->ref_idx[0]][cidx],
1585 s->sh.chroma_weight_l1[current_mv->ref_idx[1]][cidx],
1586 s->sh.chroma_offset_l0[current_mv->ref_idx[0]][cidx],
1587 s->sh.chroma_offset_l1[current_mv->ref_idx[1]][cidx],
1588 _mx1, _my1, block_w);
1591 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1592 const Mv *mv, int y0, int height)
1594 int y = FFMAX(0, (mv->y >> 2) + y0 + height + 9);
1596 if (s->threads_type == FF_THREAD_FRAME )
1597 ff_thread_await_progress(&ref->tf, y, 0);
1600 static void hevc_luma_mv_mpv_mode(HEVCContext *s, int x0, int y0, int nPbW,
1601 int nPbH, int log2_cb_size, int part_idx,
1602 int merge_idx, MvField *mv)
1604 HEVCLocalContext *lc = s->HEVClc;
1605 enum InterPredIdc inter_pred_idc = PRED_L0;
1608 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1610 if (s->sh.slice_type == B_SLICE)
1611 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1613 if (inter_pred_idc != PRED_L1) {
1614 if (s->sh.nb_refs[L0])
1615 mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1617 mv->pred_flag = PF_L0;
1618 ff_hevc_hls_mvd_coding(s, x0, y0, 0);
1619 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1620 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1621 part_idx, merge_idx, mv, mvp_flag, 0);
1622 mv->mv[0].x += lc->pu.mvd.x;
1623 mv->mv[0].y += lc->pu.mvd.y;
1626 if (inter_pred_idc != PRED_L0) {
1627 if (s->sh.nb_refs[L1])
1628 mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1630 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1631 AV_ZERO32(&lc->pu.mvd);
1633 ff_hevc_hls_mvd_coding(s, x0, y0, 1);
1636 mv->pred_flag += PF_L1;
1637 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1638 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1639 part_idx, merge_idx, mv, mvp_flag, 1);
1640 mv->mv[1].x += lc->pu.mvd.x;
1641 mv->mv[1].y += lc->pu.mvd.y;
1645 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1647 int log2_cb_size, int partIdx, int idx)
1649 #define POS(c_idx, x, y) \
1650 &s->frame->data[c_idx][((y) >> s->sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1651 (((x) >> s->sps->hshift[c_idx]) << s->sps->pixel_shift)]
1652 HEVCLocalContext *lc = s->HEVClc;
1654 struct MvField current_mv = {{{ 0 }}};
1656 int min_pu_width = s->sps->min_pu_width;
1658 MvField *tab_mvf = s->ref->tab_mvf;
1659 RefPicList *refPicList = s->ref->refPicList;
1660 HEVCFrame *ref0 = NULL, *ref1 = NULL;
1661 uint8_t *dst0 = POS(0, x0, y0);
1662 uint8_t *dst1 = POS(1, x0, y0);
1663 uint8_t *dst2 = POS(2, x0, y0);
1664 int log2_min_cb_size = s->sps->log2_min_cb_size;
1665 int min_cb_width = s->sps->min_cb_width;
1666 int x_cb = x0 >> log2_min_cb_size;
1667 int y_cb = y0 >> log2_min_cb_size;
1671 int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1674 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1676 if (skip_flag || lc->pu.merge_flag) {
1677 if (s->sh.max_num_merge_cand > 1)
1678 merge_idx = ff_hevc_merge_idx_decode(s);
1682 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1683 partIdx, merge_idx, ¤t_mv);
1685 hevc_luma_mv_mpv_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1686 partIdx, merge_idx, ¤t_mv);
1689 x_pu = x0 >> s->sps->log2_min_pu_size;
1690 y_pu = y0 >> s->sps->log2_min_pu_size;
1692 for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1693 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1694 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1696 if (current_mv.pred_flag & PF_L0) {
1697 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1700 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1702 if (current_mv.pred_flag & PF_L1) {
1703 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1706 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1709 if (current_mv.pred_flag == PF_L0) {
1710 int x0_c = x0 >> s->sps->hshift[1];
1711 int y0_c = y0 >> s->sps->vshift[1];
1712 int nPbW_c = nPbW >> s->sps->hshift[1];
1713 int nPbH_c = nPbH >> s->sps->vshift[1];
1715 luma_mc_uni(s, dst0, s->frame->linesize[0], ref0->frame,
1716 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1717 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1718 s->sh.luma_offset_l0[current_mv.ref_idx[0]]);
1720 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref0->frame->data[1], ref0->frame->linesize[1],
1721 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1722 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]);
1723 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref0->frame->data[2], ref0->frame->linesize[2],
1724 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1725 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]);
1726 } else if (current_mv.pred_flag == PF_L1) {
1727 int x0_c = x0 >> s->sps->hshift[1];
1728 int y0_c = y0 >> s->sps->vshift[1];
1729 int nPbW_c = nPbW >> s->sps->hshift[1];
1730 int nPbH_c = nPbH >> s->sps->vshift[1];
1732 luma_mc_uni(s, dst0, s->frame->linesize[0], ref1->frame,
1733 ¤t_mv.mv[1], x0, y0, nPbW, nPbH,
1734 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1735 s->sh.luma_offset_l1[current_mv.ref_idx[1]]);
1737 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
1738 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1739 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]);
1741 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
1742 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1743 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]);
1744 } else if (current_mv.pred_flag == PF_BI) {
1745 int x0_c = x0 >> s->sps->hshift[1];
1746 int y0_c = y0 >> s->sps->vshift[1];
1747 int nPbW_c = nPbW >> s->sps->hshift[1];
1748 int nPbH_c = nPbH >> s->sps->vshift[1];
1750 luma_mc_bi(s, dst0, s->frame->linesize[0], ref0->frame,
1751 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1752 ref1->frame, ¤t_mv.mv[1], ¤t_mv);
1754 chroma_mc_bi(s, dst1, s->frame->linesize[1], ref0->frame, ref1->frame,
1755 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 0);
1757 chroma_mc_bi(s, dst2, s->frame->linesize[2], ref0->frame, ref1->frame,
1758 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1);
1765 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1766 int prev_intra_luma_pred_flag)
1768 HEVCLocalContext *lc = s->HEVClc;
1769 int x_pu = x0 >> s->sps->log2_min_pu_size;
1770 int y_pu = y0 >> s->sps->log2_min_pu_size;
1771 int min_pu_width = s->sps->min_pu_width;
1772 int size_in_pus = pu_size >> s->sps->log2_min_pu_size;
1773 int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1);
1774 int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1);
1776 int cand_up = (lc->ctb_up_flag || y0b) ?
1777 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1778 int cand_left = (lc->ctb_left_flag || x0b) ?
1779 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1781 int y_ctb = (y0 >> (s->sps->log2_ctb_size)) << (s->sps->log2_ctb_size);
1783 MvField *tab_mvf = s->ref->tab_mvf;
1784 int intra_pred_mode;
1788 // intra_pred_mode prediction does not cross vertical CTB boundaries
1789 if ((y0 - 1) < y_ctb)
1792 if (cand_left == cand_up) {
1793 if (cand_left < 2) {
1794 candidate[0] = INTRA_PLANAR;
1795 candidate[1] = INTRA_DC;
1796 candidate[2] = INTRA_ANGULAR_26;
1798 candidate[0] = cand_left;
1799 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1800 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1803 candidate[0] = cand_left;
1804 candidate[1] = cand_up;
1805 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1806 candidate[2] = INTRA_PLANAR;
1807 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1808 candidate[2] = INTRA_DC;
1810 candidate[2] = INTRA_ANGULAR_26;
1814 if (prev_intra_luma_pred_flag) {
1815 intra_pred_mode = candidate[lc->pu.mpm_idx];
1817 if (candidate[0] > candidate[1])
1818 FFSWAP(uint8_t, candidate[0], candidate[1]);
1819 if (candidate[0] > candidate[2])
1820 FFSWAP(uint8_t, candidate[0], candidate[2]);
1821 if (candidate[1] > candidate[2])
1822 FFSWAP(uint8_t, candidate[1], candidate[2]);
1824 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1825 for (i = 0; i < 3; i++)
1826 if (intra_pred_mode >= candidate[i])
1830 /* write the intra prediction units into the mv array */
1833 for (i = 0; i < size_in_pus; i++) {
1834 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1835 intra_pred_mode, size_in_pus);
1837 for (j = 0; j < size_in_pus; j++) {
1838 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag = PF_INTRA;
1842 return intra_pred_mode;
1845 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1846 int log2_cb_size, int ct_depth)
1848 int length = (1 << log2_cb_size) >> s->sps->log2_min_cb_size;
1849 int x_cb = x0 >> s->sps->log2_min_cb_size;
1850 int y_cb = y0 >> s->sps->log2_min_cb_size;
1853 for (y = 0; y < length; y++)
1854 memset(&s->tab_ct_depth[(y_cb + y) * s->sps->min_cb_width + x_cb],
1858 static const uint8_t tab_mode_idx[] = {
1859 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
1860 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
1862 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1865 HEVCLocalContext *lc = s->HEVClc;
1866 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1867 uint8_t prev_intra_luma_pred_flag[4];
1868 int split = lc->cu.part_mode == PART_NxN;
1869 int pb_size = (1 << log2_cb_size) >> split;
1870 int side = split + 1;
1874 for (i = 0; i < side; i++)
1875 for (j = 0; j < side; j++)
1876 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1878 for (i = 0; i < side; i++) {
1879 for (j = 0; j < side; j++) {
1880 if (prev_intra_luma_pred_flag[2 * i + j])
1881 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
1883 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
1885 lc->pu.intra_pred_mode[2 * i + j] =
1886 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1887 prev_intra_luma_pred_flag[2 * i + j]);
1891 if (s->sps->chroma_format_idc == 3) {
1892 for (i = 0; i < side; i++) {
1893 for (j = 0; j < side; j++) {
1894 lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1895 if (chroma_mode != 4) {
1896 if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode])
1897 lc->pu.intra_pred_mode_c[2 * i + j] = 34;
1899 lc->pu.intra_pred_mode_c[2 * i + j] = intra_chroma_table[chroma_mode];
1901 lc->pu.intra_pred_mode_c[2 * i + j] = lc->pu.intra_pred_mode[2 * i + j];
1905 } else if (s->sps->chroma_format_idc == 2) {
1907 lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1908 if (chroma_mode != 4) {
1909 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1912 mode_idx = intra_chroma_table[chroma_mode];
1914 mode_idx = lc->pu.intra_pred_mode[0];
1916 lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx];
1917 } else if (s->sps->chroma_format_idc != 0) {
1918 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])
1921 lc->pu.intra_pred_mode_c[0] = 34;
1923 lc->pu.intra_pred_mode_c[0] = intra_chroma_table[chroma_mode];
1925 lc->pu.intra_pred_mode_c[0] = lc->pu.intra_pred_mode[0];
1930 static void intra_prediction_unit_default_value(HEVCContext *s,
1934 HEVCLocalContext *lc = s->HEVClc;
1935 int pb_size = 1 << log2_cb_size;
1936 int size_in_pus = pb_size >> s->sps->log2_min_pu_size;
1937 int min_pu_width = s->sps->min_pu_width;
1938 MvField *tab_mvf = s->ref->tab_mvf;
1939 int x_pu = x0 >> s->sps->log2_min_pu_size;
1940 int y_pu = y0 >> s->sps->log2_min_pu_size;
1943 if (size_in_pus == 0)
1945 for (j = 0; j < size_in_pus; j++)
1946 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
1947 if (lc->cu.pred_mode == MODE_INTRA)
1948 for (j = 0; j < size_in_pus; j++)
1949 for (k = 0; k < size_in_pus; k++)
1950 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].pred_flag = PF_INTRA;
1953 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
1955 int cb_size = 1 << log2_cb_size;
1956 HEVCLocalContext *lc = s->HEVClc;
1957 int log2_min_cb_size = s->sps->log2_min_cb_size;
1958 int length = cb_size >> log2_min_cb_size;
1959 int min_cb_width = s->sps->min_cb_width;
1960 int x_cb = x0 >> log2_min_cb_size;
1961 int y_cb = y0 >> log2_min_cb_size;
1962 int idx = log2_cb_size - 2;
1963 int qp_block_mask = (1<<(s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth)) - 1;
1968 lc->cu.pred_mode = MODE_INTRA;
1969 lc->cu.part_mode = PART_2Nx2N;
1970 lc->cu.intra_split_flag = 0;
1972 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
1973 for (x = 0; x < 4; x++)
1974 lc->pu.intra_pred_mode[x] = 1;
1975 if (s->pps->transquant_bypass_enable_flag) {
1976 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
1977 if (lc->cu.cu_transquant_bypass_flag)
1978 set_deblocking_bypass(s, x0, y0, log2_cb_size);
1980 lc->cu.cu_transquant_bypass_flag = 0;
1982 if (s->sh.slice_type != I_SLICE) {
1983 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
1985 x = y_cb * min_cb_width + x_cb;
1986 for (y = 0; y < length; y++) {
1987 memset(&s->skip_flag[x], skip_flag, length);
1990 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
1992 x = y_cb * min_cb_width + x_cb;
1993 for (y = 0; y < length; y++) {
1994 memset(&s->skip_flag[x], 0, length);
1999 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2000 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2001 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2003 if (!s->sh.disable_deblocking_filter_flag)
2004 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2008 if (s->sh.slice_type != I_SLICE)
2009 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2010 if (lc->cu.pred_mode != MODE_INTRA ||
2011 log2_cb_size == s->sps->log2_min_cb_size) {
2012 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2013 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2014 lc->cu.pred_mode == MODE_INTRA;
2017 if (lc->cu.pred_mode == MODE_INTRA) {
2018 if (lc->cu.part_mode == PART_2Nx2N && s->sps->pcm_enabled_flag &&
2019 log2_cb_size >= s->sps->pcm.log2_min_pcm_cb_size &&
2020 log2_cb_size <= s->sps->pcm.log2_max_pcm_cb_size) {
2021 pcm_flag = ff_hevc_pcm_flag_decode(s);
2024 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2025 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2026 if (s->sps->pcm.loop_filter_disable_flag)
2027 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2032 intra_prediction_unit(s, x0, y0, log2_cb_size);
2035 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2036 switch (lc->cu.part_mode) {
2038 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2041 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0, idx);
2042 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2045 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2046 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2049 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0, idx);
2050 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2053 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2054 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2057 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0, idx - 2);
2058 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2061 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2062 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2065 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2066 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2067 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2068 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2074 int rqt_root_cbf = 1;
2076 if (lc->cu.pred_mode != MODE_INTRA &&
2077 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2078 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2081 const static int cbf[2] = { 0 };
2082 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2083 s->sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2084 s->sps->max_transform_hierarchy_depth_inter;
2085 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2087 log2_cb_size, 0, 0, cbf, cbf);
2091 if (!s->sh.disable_deblocking_filter_flag)
2092 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2097 if (s->pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2098 ff_hevc_set_qPy(s, x0, y0, log2_cb_size);
2100 x = y_cb * min_cb_width + x_cb;
2101 for (y = 0; y < length; y++) {
2102 memset(&s->qp_y_tab[x], lc->qp_y, length);
2106 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2107 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2108 lc->qPy_pred = lc->qp_y;
2111 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct_depth);
2116 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2117 int log2_cb_size, int cb_depth)
2119 HEVCLocalContext *lc = s->HEVClc;
2120 const int cb_size = 1 << log2_cb_size;
2124 lc->ct_depth = cb_depth;
2125 if (x0 + cb_size <= s->sps->width &&
2126 y0 + cb_size <= s->sps->height &&
2127 log2_cb_size > s->sps->log2_min_cb_size) {
2128 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2130 split_cu = (log2_cb_size > s->sps->log2_min_cb_size);
2132 if (s->pps->cu_qp_delta_enabled_flag &&
2133 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth) {
2134 lc->tu.is_cu_qp_delta_coded = 0;
2135 lc->tu.cu_qp_delta = 0;
2138 if (s->sh.cu_chroma_qp_offset_enabled_flag &&
2139 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_chroma_qp_offset_depth) {
2140 lc->tu.is_cu_chroma_qp_offset_coded = 0;
2144 int qp_block_mask = (1<<(s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth)) - 1;
2145 const int cb_size_split = cb_size >> 1;
2146 const int x1 = x0 + cb_size_split;
2147 const int y1 = y0 + cb_size_split;
2151 more_data = hls_coding_quadtree(s, x0, y0, log2_cb_size - 1, cb_depth + 1);
2155 if (more_data && x1 < s->sps->width) {
2156 more_data = hls_coding_quadtree(s, x1, y0, log2_cb_size - 1, cb_depth + 1);
2160 if (more_data && y1 < s->sps->height) {
2161 more_data = hls_coding_quadtree(s, x0, y1, log2_cb_size - 1, cb_depth + 1);
2165 if (more_data && x1 < s->sps->width &&
2166 y1 < s->sps->height) {
2167 more_data = hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1);
2172 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2173 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2174 lc->qPy_pred = lc->qp_y;
2177 return ((x1 + cb_size_split) < s->sps->width ||
2178 (y1 + cb_size_split) < s->sps->height);
2182 ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2185 if ((!((x0 + cb_size) %
2186 (1 << (s->sps->log2_ctb_size))) ||
2187 (x0 + cb_size >= s->sps->width)) &&
2189 (1 << (s->sps->log2_ctb_size))) ||
2190 (y0 + cb_size >= s->sps->height))) {
2191 int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s);
2192 return !end_of_slice_flag;
2201 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2204 HEVCLocalContext *lc = s->HEVClc;
2205 int ctb_size = 1 << s->sps->log2_ctb_size;
2206 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2207 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2209 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2211 if (s->pps->entropy_coding_sync_enabled_flag) {
2212 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2213 lc->first_qp_group = 1;
2214 lc->end_of_tiles_x = s->sps->width;
2215 } else if (s->pps->tiles_enabled_flag) {
2216 if (ctb_addr_ts && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1]) {
2217 int idxX = s->pps->col_idxX[x_ctb >> s->sps->log2_ctb_size];
2218 lc->end_of_tiles_x = x_ctb + (s->pps->column_width[idxX] << s->sps->log2_ctb_size);
2219 lc->first_qp_group = 1;
2222 lc->end_of_tiles_x = s->sps->width;
2225 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->sps->height);
2227 lc->boundary_flags = 0;
2228 if (s->pps->tiles_enabled_flag) {
2229 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]])
2230 lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2231 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2232 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2233 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]])
2234 lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2235 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->sps->ctb_width])
2236 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2238 if (!ctb_addr_in_slice > 0)
2239 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2240 if (ctb_addr_in_slice < s->sps->ctb_width)
2241 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2244 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2245 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2246 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]]));
2247 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]]));
2250 static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
2252 HEVCContext *s = avctxt->priv_data;
2253 int ctb_size = 1 << s->sps->log2_ctb_size;
2257 int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2259 if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) {
2260 av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n");
2261 return AVERROR_INVALIDDATA;
2264 if (s->sh.dependent_slice_segment_flag) {
2265 int prev_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2266 if (s->tab_slice_address[prev_rs] != s->sh.slice_addr) {
2267 av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n");
2268 return AVERROR_INVALIDDATA;
2272 while (more_data && ctb_addr_ts < s->sps->ctb_size) {
2273 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2275 x_ctb = (ctb_addr_rs % ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2276 y_ctb = (ctb_addr_rs / ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2277 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2279 ff_hevc_cabac_init(s, ctb_addr_ts);
2281 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2283 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2284 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2285 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2287 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2288 if (more_data < 0) {
2289 s->tab_slice_address[ctb_addr_rs] = -1;
2295 ff_hevc_save_states(s, ctb_addr_ts);
2296 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2299 if (x_ctb + ctb_size >= s->sps->width &&
2300 y_ctb + ctb_size >= s->sps->height)
2301 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2306 static int hls_slice_data(HEVCContext *s)
2314 s->avctx->execute(s->avctx, hls_decode_entry, arg, ret , 1, sizeof(int));
2317 static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int job, int self_id)
2319 HEVCContext *s1 = avctxt->priv_data, *s;
2320 HEVCLocalContext *lc;
2321 int ctb_size = 1<< s1->sps->log2_ctb_size;
2323 int *ctb_row_p = input_ctb_row;
2324 int ctb_row = ctb_row_p[job];
2325 int ctb_addr_rs = s1->sh.slice_ctb_addr_rs + ctb_row * ((s1->sps->width + ctb_size - 1) >> s1->sps->log2_ctb_size);
2326 int ctb_addr_ts = s1->pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2327 int thread = ctb_row % s1->threads_number;
2330 s = s1->sList[self_id];
2334 ret = init_get_bits8(&lc->gb, s->data + s->sh.offset[ctb_row - 1], s->sh.size[ctb_row - 1]);
2338 ff_init_cabac_decoder(&lc->cc, s->data + s->sh.offset[(ctb_row)-1], s->sh.size[ctb_row - 1]);
2341 while(more_data && ctb_addr_ts < s->sps->ctb_size) {
2342 int x_ctb = (ctb_addr_rs % s->sps->ctb_width) << s->sps->log2_ctb_size;
2343 int y_ctb = (ctb_addr_rs / s->sps->ctb_width) << s->sps->log2_ctb_size;
2345 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2347 ff_thread_await_progress2(s->avctx, ctb_row, thread, SHIFT_CTB_WPP);
2349 if (avpriv_atomic_int_get(&s1->wpp_err)){
2350 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2354 ff_hevc_cabac_init(s, ctb_addr_ts);
2355 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2356 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2358 if (more_data < 0) {
2359 s->tab_slice_address[ctb_addr_rs] = -1;
2365 ff_hevc_save_states(s, ctb_addr_ts);
2366 ff_thread_report_progress2(s->avctx, ctb_row, thread, 1);
2367 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2369 if (!more_data && (x_ctb+ctb_size) < s->sps->width && ctb_row != s->sh.num_entry_point_offsets) {
2370 avpriv_atomic_int_set(&s1->wpp_err, 1);
2371 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2375 if ((x_ctb+ctb_size) >= s->sps->width && (y_ctb+ctb_size) >= s->sps->height ) {
2376 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2377 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2380 ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2383 if(x_ctb >= s->sps->width) {
2387 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2392 static int hls_slice_data_wpp(HEVCContext *s, const uint8_t *nal, int length)
2394 HEVCLocalContext *lc = s->HEVClc;
2395 int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2396 int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2398 int startheader, cmpt = 0;
2404 return AVERROR(ENOMEM);
2409 ff_alloc_entries(s->avctx, s->sh.num_entry_point_offsets + 1);
2412 for (i = 1; i < s->threads_number; i++) {
2413 s->sList[i] = av_malloc(sizeof(HEVCContext));
2414 memcpy(s->sList[i], s, sizeof(HEVCContext));
2415 s->HEVClcList[i] = av_mallocz(sizeof(HEVCLocalContext));
2416 s->sList[i]->HEVClc = s->HEVClcList[i];
2420 offset = (lc->gb.index >> 3);
2422 for (j = 0, cmpt = 0, startheader = offset + s->sh.entry_point_offset[0]; j < s->skipped_bytes; j++) {
2423 if (s->skipped_bytes_pos[j] >= offset && s->skipped_bytes_pos[j] < startheader) {
2429 for (i = 1; i < s->sh.num_entry_point_offsets; i++) {
2430 offset += (s->sh.entry_point_offset[i - 1] - cmpt);
2431 for (j = 0, cmpt = 0, startheader = offset
2432 + s->sh.entry_point_offset[i]; j < s->skipped_bytes; j++) {
2433 if (s->skipped_bytes_pos[j] >= offset && s->skipped_bytes_pos[j] < startheader) {
2438 s->sh.size[i - 1] = s->sh.entry_point_offset[i] - cmpt;
2439 s->sh.offset[i - 1] = offset;
2442 if (s->sh.num_entry_point_offsets != 0) {
2443 offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt;
2444 s->sh.size[s->sh.num_entry_point_offsets - 1] = length - offset;
2445 s->sh.offset[s->sh.num_entry_point_offsets - 1] = offset;
2450 for (i = 1; i < s->threads_number; i++) {
2451 s->sList[i]->HEVClc->first_qp_group = 1;
2452 s->sList[i]->HEVClc->qp_y = s->sList[0]->HEVClc->qp_y;
2453 memcpy(s->sList[i], s, sizeof(HEVCContext));
2454 s->sList[i]->HEVClc = s->HEVClcList[i];
2457 avpriv_atomic_int_set(&s->wpp_err, 0);
2458 ff_reset_entries(s->avctx);
2460 for (i = 0; i <= s->sh.num_entry_point_offsets; i++) {
2465 if (s->pps->entropy_coding_sync_enabled_flag)
2466 s->avctx->execute2(s->avctx, (void *) hls_decode_entry_wpp, arg, ret, s->sh.num_entry_point_offsets + 1);
2468 for (i = 0; i <= s->sh.num_entry_point_offsets; i++)
2476 * @return AVERROR_INVALIDDATA if the packet is not a valid NAL unit,
2477 * 0 if the unit should be skipped, 1 otherwise
2479 static int hls_nal_unit(HEVCContext *s)
2481 GetBitContext *gb = &s->HEVClc->gb;
2484 if (get_bits1(gb) != 0)
2485 return AVERROR_INVALIDDATA;
2487 s->nal_unit_type = get_bits(gb, 6);
2489 nuh_layer_id = get_bits(gb, 6);
2490 s->temporal_id = get_bits(gb, 3) - 1;
2491 if (s->temporal_id < 0)
2492 return AVERROR_INVALIDDATA;
2494 av_log(s->avctx, AV_LOG_DEBUG,
2495 "nal_unit_type: %d, nuh_layer_id: %d, temporal_id: %d\n",
2496 s->nal_unit_type, nuh_layer_id, s->temporal_id);
2498 return nuh_layer_id == 0;
2501 static int set_side_data(HEVCContext *s)
2503 AVFrame *out = s->ref->frame;
2505 if (s->sei_frame_packing_present &&
2506 s->frame_packing_arrangement_type >= 3 &&
2507 s->frame_packing_arrangement_type <= 5 &&
2508 s->content_interpretation_type > 0 &&
2509 s->content_interpretation_type < 3) {
2510 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2512 return AVERROR(ENOMEM);
2514 switch (s->frame_packing_arrangement_type) {
2516 if (s->quincunx_subsampling)
2517 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2519 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2522 stereo->type = AV_STEREO3D_TOPBOTTOM;
2525 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2529 if (s->content_interpretation_type == 2)
2530 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2533 if (s->sei_display_orientation_present &&
2534 (s->sei_anticlockwise_rotation || s->sei_hflip || s->sei_vflip)) {
2535 double angle = s->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
2536 AVFrameSideData *rotation = av_frame_new_side_data(out,
2537 AV_FRAME_DATA_DISPLAYMATRIX,
2538 sizeof(int32_t) * 9);
2540 return AVERROR(ENOMEM);
2542 av_display_rotation_set((int32_t *)rotation->data, angle);
2543 av_display_matrix_flip((int32_t *)rotation->data,
2544 s->sei_hflip, s->sei_vflip);
2550 static int hevc_frame_start(HEVCContext *s)
2552 HEVCLocalContext *lc = s->HEVClc;
2553 int pic_size_in_ctb = ((s->sps->width >> s->sps->log2_min_cb_size) + 1) *
2554 ((s->sps->height >> s->sps->log2_min_cb_size) + 1);
2557 memset(s->horizontal_bs, 0, s->bs_width * s->bs_height);
2558 memset(s->vertical_bs, 0, s->bs_width * s->bs_height);
2559 memset(s->cbf_luma, 0, s->sps->min_tb_width * s->sps->min_tb_height);
2560 memset(s->is_pcm, 0, (s->sps->min_pu_width + 1) * (s->sps->min_pu_height + 1));
2561 memset(s->tab_slice_address, -1, pic_size_in_ctb * sizeof(*s->tab_slice_address));
2564 s->first_nal_type = s->nal_unit_type;
2566 if (s->pps->tiles_enabled_flag)
2567 lc->end_of_tiles_x = s->pps->column_width[0] << s->sps->log2_ctb_size;
2569 ret = ff_hevc_set_new_ref(s, &s->frame, s->poc);
2573 ret = ff_hevc_frame_rps(s);
2575 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2579 s->ref->frame->key_frame = IS_IRAP(s);
2581 ret = set_side_data(s);
2585 s->frame->pict_type = 3 - s->sh.slice_type;
2588 ff_hevc_bump_frame(s);
2590 av_frame_unref(s->output_frame);
2591 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2595 ff_thread_finish_setup(s->avctx);
2601 ff_hevc_unref_frame(s, s->ref, ~0);
2606 static int decode_nal_unit(HEVCContext *s, const HEVCNAL *nal)
2608 HEVCLocalContext *lc = s->HEVClc;
2609 GetBitContext *gb = &lc->gb;
2610 int ctb_addr_ts, ret;
2612 ret = init_get_bits8(gb, nal->data, nal->size);
2616 ret = hls_nal_unit(s);
2618 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit %d, skipping.\n",
2624 switch (s->nal_unit_type) {
2626 ret = ff_hevc_decode_nal_vps(s);
2631 ret = ff_hevc_decode_nal_sps(s);
2636 ret = ff_hevc_decode_nal_pps(s);
2640 case NAL_SEI_PREFIX:
2641 case NAL_SEI_SUFFIX:
2642 ret = ff_hevc_decode_nal_sei(s);
2653 case NAL_BLA_W_RADL:
2655 case NAL_IDR_W_RADL:
2662 ret = hls_slice_header(s);
2666 if (s->max_ra == INT_MAX) {
2667 if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
2671 s->max_ra = INT_MIN;
2675 if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
2676 s->poc <= s->max_ra) {
2680 if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
2681 s->max_ra = INT_MIN;
2684 if (s->sh.first_slice_in_pic_flag) {
2685 ret = hevc_frame_start(s);
2688 } else if (!s->ref) {
2689 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2693 if (s->nal_unit_type != s->first_nal_type) {
2694 av_log(s->avctx, AV_LOG_ERROR,
2695 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2696 s->first_nal_type, s->nal_unit_type);
2697 return AVERROR_INVALIDDATA;
2700 if (!s->sh.dependent_slice_segment_flag &&
2701 s->sh.slice_type != I_SLICE) {
2702 ret = ff_hevc_slice_rpl(s);
2704 av_log(s->avctx, AV_LOG_WARNING,
2705 "Error constructing the reference lists for the current slice.\n");
2710 if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) {
2711 ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0);
2716 if (s->avctx->hwaccel) {
2717 ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size);
2721 if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
2722 ctb_addr_ts = hls_slice_data_wpp(s, nal->data, nal->size);
2724 ctb_addr_ts = hls_slice_data(s);
2725 if (ctb_addr_ts >= (s->sps->ctb_width * s->sps->ctb_height)) {
2729 if (ctb_addr_ts < 0) {
2737 s->seq_decode = (s->seq_decode + 1) & 0xff;
2738 s->max_ra = INT_MAX;
2744 av_log(s->avctx, AV_LOG_INFO,
2745 "Skipping NAL unit %d\n", s->nal_unit_type);
2750 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2755 /* FIXME: This is adapted from ff_h264_decode_nal, avoiding duplication
2756 * between these functions would be nice. */
2757 int ff_hevc_extract_rbsp(HEVCContext *s, const uint8_t *src, int length,
2763 s->skipped_bytes = 0;
2764 #define STARTCODE_TEST \
2765 if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \
2766 if (src[i + 2] != 3) { \
2767 /* startcode, so we must be past the end */ \
2772 #if HAVE_FAST_UNALIGNED
2773 #define FIND_FIRST_ZERO \
2774 if (i > 0 && !src[i]) \
2779 for (i = 0; i + 1 < length; i += 9) {
2780 if (!((~AV_RN64A(src + i) &
2781 (AV_RN64A(src + i) - 0x0100010001000101ULL)) &
2782 0x8000800080008080ULL))
2789 for (i = 0; i + 1 < length; i += 5) {
2790 if (!((~AV_RN32A(src + i) &
2791 (AV_RN32A(src + i) - 0x01000101U)) &
2798 #endif /* HAVE_FAST_64BIT */
2800 for (i = 0; i + 1 < length; i += 2) {
2803 if (i > 0 && src[i - 1] == 0)
2807 #endif /* HAVE_FAST_UNALIGNED */
2809 if (i >= length - 1) { // no escaped 0
2811 nal->raw_data = src;
2813 nal->raw_size = length;
2817 av_fast_malloc(&nal->rbsp_buffer, &nal->rbsp_buffer_size,
2818 length + FF_INPUT_BUFFER_PADDING_SIZE);
2819 if (!nal->rbsp_buffer)
2820 return AVERROR(ENOMEM);
2822 dst = nal->rbsp_buffer;
2824 memcpy(dst, src, i);
2826 while (si + 2 < length) {
2827 // remove escapes (very rare 1:2^22)
2828 if (src[si + 2] > 3) {
2829 dst[di++] = src[si++];
2830 dst[di++] = src[si++];
2831 } else if (src[si] == 0 && src[si + 1] == 0) {
2832 if (src[si + 2] == 3) { // escape
2838 if (s->skipped_bytes_pos_size < s->skipped_bytes) {
2839 s->skipped_bytes_pos_size *= 2;
2840 av_reallocp_array(&s->skipped_bytes_pos,
2841 s->skipped_bytes_pos_size,
2842 sizeof(*s->skipped_bytes_pos));
2843 if (!s->skipped_bytes_pos)
2844 return AVERROR(ENOMEM);
2846 if (s->skipped_bytes_pos)
2847 s->skipped_bytes_pos[s->skipped_bytes-1] = di - 1;
2849 } else // next start code
2853 dst[di++] = src[si++];
2856 dst[di++] = src[si++];
2859 memset(dst + di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2863 nal->raw_data = src;
2868 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2870 int i, consumed, ret = 0;
2873 s->last_eos = s->eos;
2876 /* split the input packet into NAL units, so we know the upper bound on the
2877 * number of slices in the frame */
2879 while (length >= 4) {
2881 int extract_length = 0;
2885 for (i = 0; i < s->nal_length_size; i++)
2886 extract_length = (extract_length << 8) | buf[i];
2887 buf += s->nal_length_size;
2888 length -= s->nal_length_size;
2890 if (extract_length > length) {
2891 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit size.\n");
2892 ret = AVERROR_INVALIDDATA;
2896 /* search start code */
2897 while (buf[0] != 0 || buf[1] != 0 || buf[2] != 1) {
2901 av_log(s->avctx, AV_LOG_ERROR, "No start code is found.\n");
2902 ret = AVERROR_INVALIDDATA;
2912 extract_length = length;
2914 if (s->nals_allocated < s->nb_nals + 1) {
2915 int new_size = s->nals_allocated + 1;
2916 void *tmp = av_realloc_array(s->nals, new_size, sizeof(*s->nals));
2917 ret = AVERROR(ENOMEM);
2922 memset(s->nals + s->nals_allocated, 0,
2923 (new_size - s->nals_allocated) * sizeof(*s->nals));
2925 tmp = av_realloc_array(s->skipped_bytes_nal, new_size, sizeof(*s->skipped_bytes_nal));
2928 s->skipped_bytes_nal = tmp;
2930 tmp = av_realloc_array(s->skipped_bytes_pos_size_nal, new_size, sizeof(*s->skipped_bytes_pos_size_nal));
2933 s->skipped_bytes_pos_size_nal = tmp;
2935 tmp = av_realloc_array(s->skipped_bytes_pos_nal, new_size, sizeof(*s->skipped_bytes_pos_nal));
2938 s->skipped_bytes_pos_nal = tmp;
2940 s->skipped_bytes_pos_size_nal[s->nals_allocated] = 1024; // initial buffer size
2941 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));
2942 if (!s->skipped_bytes_pos_nal[s->nals_allocated])
2944 s->nals_allocated = new_size;
2946 s->skipped_bytes_pos_size = s->skipped_bytes_pos_size_nal[s->nb_nals];
2947 s->skipped_bytes_pos = s->skipped_bytes_pos_nal[s->nb_nals];
2948 nal = &s->nals[s->nb_nals];
2950 consumed = ff_hevc_extract_rbsp(s, buf, extract_length, nal);
2952 s->skipped_bytes_nal[s->nb_nals] = s->skipped_bytes;
2953 s->skipped_bytes_pos_size_nal[s->nb_nals] = s->skipped_bytes_pos_size;
2954 s->skipped_bytes_pos_nal[s->nb_nals++] = s->skipped_bytes_pos;
2962 ret = init_get_bits8(&s->HEVClc->gb, nal->data, nal->size);
2967 if (s->nal_unit_type == NAL_EOB_NUT ||
2968 s->nal_unit_type == NAL_EOS_NUT)
2975 /* parse the NAL units */
2976 for (i = 0; i < s->nb_nals; i++) {
2978 s->skipped_bytes = s->skipped_bytes_nal[i];
2979 s->skipped_bytes_pos = s->skipped_bytes_pos_nal[i];
2981 ret = decode_nal_unit(s, &s->nals[i]);
2983 av_log(s->avctx, AV_LOG_WARNING,
2984 "Error parsing NAL unit #%d.\n", i);
2990 if (s->ref && s->threads_type == FF_THREAD_FRAME)
2991 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2996 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2999 for (i = 0; i < 16; i++)
3000 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
3003 static int verify_md5(HEVCContext *s, AVFrame *frame)
3005 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
3010 return AVERROR(EINVAL);
3012 pixel_shift = desc->comp[0].depth_minus1 > 7;
3014 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
3017 /* the checksums are LE, so we have to byteswap for >8bpp formats
3020 if (pixel_shift && !s->checksum_buf) {
3021 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
3022 FFMAX3(frame->linesize[0], frame->linesize[1],
3023 frame->linesize[2]));
3024 if (!s->checksum_buf)
3025 return AVERROR(ENOMEM);
3029 for (i = 0; frame->data[i]; i++) {
3030 int width = s->avctx->coded_width;
3031 int height = s->avctx->coded_height;
3032 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
3033 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
3036 av_md5_init(s->md5_ctx);
3037 for (j = 0; j < h; j++) {
3038 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
3041 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
3042 (const uint16_t *) src, w);
3043 src = s->checksum_buf;
3046 av_md5_update(s->md5_ctx, src, w << pixel_shift);
3048 av_md5_final(s->md5_ctx, md5);
3050 if (!memcmp(md5, s->md5[i], 16)) {
3051 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
3052 print_md5(s->avctx, AV_LOG_DEBUG, md5);
3053 av_log (s->avctx, AV_LOG_DEBUG, "; ");
3055 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
3056 print_md5(s->avctx, AV_LOG_ERROR, md5);
3057 av_log (s->avctx, AV_LOG_ERROR, " != ");
3058 print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
3059 av_log (s->avctx, AV_LOG_ERROR, "\n");
3060 return AVERROR_INVALIDDATA;
3064 av_log(s->avctx, AV_LOG_DEBUG, "\n");
3069 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
3073 HEVCContext *s = avctx->priv_data;
3076 ret = ff_hevc_output_frame(s, data, 1);
3085 ret = decode_nal_units(s, avpkt->data, avpkt->size);
3089 if (avctx->hwaccel) {
3090 if (s->ref && avctx->hwaccel->end_frame(avctx) < 0)
3091 av_log(avctx, AV_LOG_ERROR,
3092 "hardware accelerator failed to decode picture\n");
3094 /* verify the SEI checksum */
3095 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
3097 ret = verify_md5(s, s->ref->frame);
3098 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
3099 ff_hevc_unref_frame(s, s->ref, ~0);
3106 if (s->is_decoded) {
3107 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
3111 if (s->output_frame->buf[0]) {
3112 av_frame_move_ref(data, s->output_frame);
3119 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
3123 ret = ff_thread_ref_frame(&dst->tf, &src->tf);
3127 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
3128 if (!dst->tab_mvf_buf)
3130 dst->tab_mvf = src->tab_mvf;
3132 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
3133 if (!dst->rpl_tab_buf)
3135 dst->rpl_tab = src->rpl_tab;
3137 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
3141 dst->poc = src->poc;
3142 dst->ctb_count = src->ctb_count;
3143 dst->window = src->window;
3144 dst->flags = src->flags;
3145 dst->sequence = src->sequence;
3147 if (src->hwaccel_picture_private) {
3148 dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
3149 if (!dst->hwaccel_priv_buf)
3151 dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
3156 ff_hevc_unref_frame(s, dst, ~0);
3157 return AVERROR(ENOMEM);
3160 static av_cold int hevc_decode_free(AVCodecContext *avctx)
3162 HEVCContext *s = avctx->priv_data;
3167 av_freep(&s->md5_ctx);
3169 for(i=0; i < s->nals_allocated; i++) {
3170 av_freep(&s->skipped_bytes_pos_nal[i]);
3172 av_freep(&s->skipped_bytes_pos_size_nal);
3173 av_freep(&s->skipped_bytes_nal);
3174 av_freep(&s->skipped_bytes_pos_nal);
3176 av_freep(&s->cabac_state);
3178 av_frame_free(&s->tmp_frame);
3179 av_frame_free(&s->output_frame);
3181 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3182 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3183 av_frame_free(&s->DPB[i].frame);
3186 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++)
3187 av_buffer_unref(&s->vps_list[i]);
3188 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++)
3189 av_buffer_unref(&s->sps_list[i]);
3190 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
3191 av_buffer_unref(&s->pps_list[i]);
3196 av_buffer_unref(&s->current_sps);
3198 av_freep(&s->sh.entry_point_offset);
3199 av_freep(&s->sh.offset);
3200 av_freep(&s->sh.size);
3202 for (i = 1; i < s->threads_number; i++) {
3203 HEVCLocalContext *lc = s->HEVClcList[i];
3205 av_freep(&s->HEVClcList[i]);
3206 av_freep(&s->sList[i]);
3209 if (s->HEVClc == s->HEVClcList[0])
3211 av_freep(&s->HEVClcList[0]);
3213 for (i = 0; i < s->nals_allocated; i++)
3214 av_freep(&s->nals[i].rbsp_buffer);
3216 s->nals_allocated = 0;
3221 static av_cold int hevc_init_context(AVCodecContext *avctx)
3223 HEVCContext *s = avctx->priv_data;
3228 s->HEVClc = av_mallocz(sizeof(HEVCLocalContext));
3231 s->HEVClcList[0] = s->HEVClc;
3234 s->cabac_state = av_malloc(HEVC_CONTEXTS);
3235 if (!s->cabac_state)
3238 s->tmp_frame = av_frame_alloc();
3242 s->output_frame = av_frame_alloc();
3243 if (!s->output_frame)
3246 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3247 s->DPB[i].frame = av_frame_alloc();
3248 if (!s->DPB[i].frame)
3250 s->DPB[i].tf.f = s->DPB[i].frame;
3253 s->max_ra = INT_MAX;
3255 s->md5_ctx = av_md5_alloc();
3259 ff_bswapdsp_init(&s->bdsp);
3261 s->context_initialized = 1;
3267 hevc_decode_free(avctx);
3268 return AVERROR(ENOMEM);
3271 static int hevc_update_thread_context(AVCodecContext *dst,
3272 const AVCodecContext *src)
3274 HEVCContext *s = dst->priv_data;
3275 HEVCContext *s0 = src->priv_data;
3278 if (!s->context_initialized) {
3279 ret = hevc_init_context(dst);
3284 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3285 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3286 if (s0->DPB[i].frame->buf[0]) {
3287 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3293 if (s->sps != s0->sps)
3295 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++) {
3296 av_buffer_unref(&s->vps_list[i]);
3297 if (s0->vps_list[i]) {
3298 s->vps_list[i] = av_buffer_ref(s0->vps_list[i]);
3299 if (!s->vps_list[i])
3300 return AVERROR(ENOMEM);
3304 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++) {
3305 av_buffer_unref(&s->sps_list[i]);
3306 if (s0->sps_list[i]) {
3307 s->sps_list[i] = av_buffer_ref(s0->sps_list[i]);
3308 if (!s->sps_list[i])
3309 return AVERROR(ENOMEM);
3313 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++) {
3314 av_buffer_unref(&s->pps_list[i]);
3315 if (s0->pps_list[i]) {
3316 s->pps_list[i] = av_buffer_ref(s0->pps_list[i]);
3317 if (!s->pps_list[i])
3318 return AVERROR(ENOMEM);
3322 av_buffer_unref(&s->current_sps);
3323 if (s0->current_sps) {
3324 s->current_sps = av_buffer_ref(s0->current_sps);
3325 if (!s->current_sps)
3326 return AVERROR(ENOMEM);
3329 if (s->sps != s0->sps)
3330 if ((ret = set_sps(s, s0->sps)) < 0)
3333 s->seq_decode = s0->seq_decode;
3334 s->seq_output = s0->seq_output;
3335 s->pocTid0 = s0->pocTid0;
3336 s->max_ra = s0->max_ra;
3339 s->is_nalff = s0->is_nalff;
3340 s->nal_length_size = s0->nal_length_size;
3342 s->threads_number = s0->threads_number;
3343 s->threads_type = s0->threads_type;
3346 s->seq_decode = (s->seq_decode + 1) & 0xff;
3347 s->max_ra = INT_MAX;
3353 static int hevc_decode_extradata(HEVCContext *s)
3355 AVCodecContext *avctx = s->avctx;
3359 bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
3361 if (avctx->extradata_size > 3 &&
3362 (avctx->extradata[0] || avctx->extradata[1] ||
3363 avctx->extradata[2] > 1)) {
3364 /* It seems the extradata is encoded as hvcC format.
3365 * Temporarily, we support configurationVersion==0 until 14496-15 3rd
3366 * is finalized. When finalized, configurationVersion will be 1 and we
3367 * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
3368 int i, j, num_arrays, nal_len_size;
3372 bytestream2_skip(&gb, 21);
3373 nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
3374 num_arrays = bytestream2_get_byte(&gb);
3376 /* nal units in the hvcC always have length coded with 2 bytes,
3377 * so put a fake nal_length_size = 2 while parsing them */
3378 s->nal_length_size = 2;
3380 /* Decode nal units from hvcC. */
3381 for (i = 0; i < num_arrays; i++) {
3382 int type = bytestream2_get_byte(&gb) & 0x3f;
3383 int cnt = bytestream2_get_be16(&gb);
3385 for (j = 0; j < cnt; j++) {
3386 // +2 for the nal size field
3387 int nalsize = bytestream2_peek_be16(&gb) + 2;
3388 if (bytestream2_get_bytes_left(&gb) < nalsize) {
3389 av_log(s->avctx, AV_LOG_ERROR,
3390 "Invalid NAL unit size in extradata.\n");
3391 return AVERROR_INVALIDDATA;
3394 ret = decode_nal_units(s, gb.buffer, nalsize);
3396 av_log(avctx, AV_LOG_ERROR,
3397 "Decoding nal unit %d %d from hvcC failed\n",
3401 bytestream2_skip(&gb, nalsize);
3405 /* Now store right nal length size, that will be used to parse
3407 s->nal_length_size = nal_len_size;
3410 ret = decode_nal_units(s, avctx->extradata, avctx->extradata_size);
3417 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3419 HEVCContext *s = avctx->priv_data;
3422 ff_init_cabac_states();
3424 avctx->internal->allocate_progress = 1;
3426 ret = hevc_init_context(avctx);
3430 s->enable_parallel_tiles = 0;
3431 s->picture_struct = 0;
3433 if(avctx->active_thread_type & FF_THREAD_SLICE)
3434 s->threads_number = avctx->thread_count;
3436 s->threads_number = 1;
3438 if (avctx->extradata_size > 0 && avctx->extradata) {
3439 ret = hevc_decode_extradata(s);
3441 hevc_decode_free(avctx);
3446 if((avctx->active_thread_type & FF_THREAD_FRAME) && avctx->thread_count > 1)
3447 s->threads_type = FF_THREAD_FRAME;
3449 s->threads_type = FF_THREAD_SLICE;
3454 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3456 HEVCContext *s = avctx->priv_data;
3459 memset(s, 0, sizeof(*s));
3461 ret = hevc_init_context(avctx);
3468 static void hevc_decode_flush(AVCodecContext *avctx)
3470 HEVCContext *s = avctx->priv_data;
3471 ff_hevc_flush_dpb(s);
3472 s->max_ra = INT_MAX;
3475 #define OFFSET(x) offsetof(HEVCContext, x)
3476 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3478 static const AVProfile profiles[] = {
3479 { FF_PROFILE_HEVC_MAIN, "Main" },
3480 { FF_PROFILE_HEVC_MAIN_10, "Main 10" },
3481 { FF_PROFILE_HEVC_MAIN_STILL_PICTURE, "Main Still Picture" },
3482 { FF_PROFILE_HEVC_REXT, "Rext" },
3483 { FF_PROFILE_UNKNOWN },
3486 static const AVOption options[] = {
3487 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3488 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3489 { "strict-displaywin", "stricly apply default display window size", OFFSET(apply_defdispwin),
3490 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3494 static const AVClass hevc_decoder_class = {
3495 .class_name = "HEVC decoder",
3496 .item_name = av_default_item_name,
3498 .version = LIBAVUTIL_VERSION_INT,
3501 AVCodec ff_hevc_decoder = {
3503 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3504 .type = AVMEDIA_TYPE_VIDEO,
3505 .id = AV_CODEC_ID_HEVC,
3506 .priv_data_size = sizeof(HEVCContext),
3507 .priv_class = &hevc_decoder_class,
3508 .init = hevc_decode_init,
3509 .close = hevc_decode_free,
3510 .decode = hevc_decode_frame,
3511 .flush = hevc_decode_flush,
3512 .update_thread_context = hevc_update_thread_context,
3513 .init_thread_copy = hevc_init_thread_copy,
3514 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY |
3515 CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS,
3516 .profiles = NULL_IF_CONFIG_SMALL(profiles),