4 * Copyright (C) 2012 - 2013 Guillaume Martres
5 * Copyright (C) 2012 - 2013 Mickael Raulet
6 * Copyright (C) 2012 - 2013 Gildas Cocherel
7 * Copyright (C) 2012 - 2013 Wassim Hamidouche
9 * This file is part of FFmpeg.
11 * FFmpeg is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
16 * FFmpeg is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with FFmpeg; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavutil/atomic.h"
27 #include "libavutil/attributes.h"
28 #include "libavutil/common.h"
29 #include "libavutil/display.h"
30 #include "libavutil/internal.h"
31 #include "libavutil/md5.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/pixdesc.h"
34 #include "libavutil/stereo3d.h"
37 #include "bytestream.h"
38 #include "cabac_functions.h"
42 const uint8_t ff_hevc_pel_weight[65] = { [2] = 0, [4] = 1, [6] = 2, [8] = 3, [12] = 4, [16] = 5, [24] = 6, [32] = 7, [48] = 8, [64] = 9 };
45 * NOTE: Each function hls_foo correspond to the function foo in the
46 * specification (HLS stands for High Level Syntax).
53 /* free everything allocated by pic_arrays_init() */
54 static void pic_arrays_free(HEVCContext *s)
57 av_freep(&s->deblock);
59 av_freep(&s->skip_flag);
60 av_freep(&s->tab_ct_depth);
62 av_freep(&s->tab_ipm);
63 av_freep(&s->cbf_luma);
66 av_freep(&s->qp_y_tab);
67 av_freep(&s->tab_slice_address);
68 av_freep(&s->filter_slice_edges);
70 av_freep(&s->horizontal_bs);
71 av_freep(&s->vertical_bs);
73 av_freep(&s->sh.entry_point_offset);
74 av_freep(&s->sh.size);
75 av_freep(&s->sh.offset);
77 av_buffer_pool_uninit(&s->tab_mvf_pool);
78 av_buffer_pool_uninit(&s->rpl_tab_pool);
81 /* allocate arrays that depend on frame dimensions */
82 static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
84 int log2_min_cb_size = sps->log2_min_cb_size;
85 int width = sps->width;
86 int height = sps->height;
87 int pic_size_in_ctb = ((width >> log2_min_cb_size) + 1) *
88 ((height >> log2_min_cb_size) + 1);
89 int ctb_count = sps->ctb_width * sps->ctb_height;
90 int min_pu_size = sps->min_pu_width * sps->min_pu_height;
92 s->bs_width = (width >> 2) + 1;
93 s->bs_height = (height >> 2) + 1;
95 s->sao = av_mallocz_array(ctb_count, sizeof(*s->sao));
96 s->deblock = av_mallocz_array(ctb_count, sizeof(*s->deblock));
97 if (!s->sao || !s->deblock)
100 s->skip_flag = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
101 s->tab_ct_depth = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
102 if (!s->skip_flag || !s->tab_ct_depth)
105 s->cbf_luma = av_malloc_array(sps->min_tb_width, sps->min_tb_height);
106 s->tab_ipm = av_mallocz(min_pu_size);
107 s->is_pcm = av_malloc_array(sps->min_pu_width + 1, sps->min_pu_height + 1);
108 if (!s->tab_ipm || !s->cbf_luma || !s->is_pcm)
111 s->filter_slice_edges = av_mallocz(ctb_count);
112 s->tab_slice_address = av_malloc_array(pic_size_in_ctb,
113 sizeof(*s->tab_slice_address));
114 s->qp_y_tab = av_malloc_array(pic_size_in_ctb,
115 sizeof(*s->qp_y_tab));
116 if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address)
119 s->horizontal_bs = av_mallocz_array(s->bs_width, s->bs_height);
120 s->vertical_bs = av_mallocz_array(s->bs_width, s->bs_height);
121 if (!s->horizontal_bs || !s->vertical_bs)
124 s->tab_mvf_pool = av_buffer_pool_init(min_pu_size * sizeof(MvField),
126 s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab),
128 if (!s->tab_mvf_pool || !s->rpl_tab_pool)
135 return AVERROR(ENOMEM);
138 static void pred_weight_table(HEVCContext *s, GetBitContext *gb)
142 uint8_t luma_weight_l0_flag[16];
143 uint8_t chroma_weight_l0_flag[16];
144 uint8_t luma_weight_l1_flag[16];
145 uint8_t chroma_weight_l1_flag[16];
146 int luma_log2_weight_denom;
148 luma_log2_weight_denom = get_ue_golomb_long(gb);
149 if (luma_log2_weight_denom < 0 || luma_log2_weight_denom > 7)
150 av_log(s->avctx, AV_LOG_ERROR, "luma_log2_weight_denom %d is invalid\n", luma_log2_weight_denom);
151 s->sh.luma_log2_weight_denom = av_clip_uintp2(luma_log2_weight_denom, 3);
152 if (s->sps->chroma_format_idc != 0) {
153 int delta = get_se_golomb(gb);
154 s->sh.chroma_log2_weight_denom = av_clip_uintp2(s->sh.luma_log2_weight_denom + delta, 3);
157 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
158 luma_weight_l0_flag[i] = get_bits1(gb);
159 if (!luma_weight_l0_flag[i]) {
160 s->sh.luma_weight_l0[i] = 1 << s->sh.luma_log2_weight_denom;
161 s->sh.luma_offset_l0[i] = 0;
164 if (s->sps->chroma_format_idc != 0) {
165 for (i = 0; i < s->sh.nb_refs[L0]; i++)
166 chroma_weight_l0_flag[i] = get_bits1(gb);
168 for (i = 0; i < s->sh.nb_refs[L0]; i++)
169 chroma_weight_l0_flag[i] = 0;
171 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
172 if (luma_weight_l0_flag[i]) {
173 int delta_luma_weight_l0 = get_se_golomb(gb);
174 s->sh.luma_weight_l0[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;
175 s->sh.luma_offset_l0[i] = get_se_golomb(gb);
177 if (chroma_weight_l0_flag[i]) {
178 for (j = 0; j < 2; j++) {
179 int delta_chroma_weight_l0 = get_se_golomb(gb);
180 int delta_chroma_offset_l0 = get_se_golomb(gb);
181 s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
182 s->sh.chroma_offset_l0[i][j] = av_clip((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j])
183 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
186 s->sh.chroma_weight_l0[i][0] = 1 << s->sh.chroma_log2_weight_denom;
187 s->sh.chroma_offset_l0[i][0] = 0;
188 s->sh.chroma_weight_l0[i][1] = 1 << s->sh.chroma_log2_weight_denom;
189 s->sh.chroma_offset_l0[i][1] = 0;
192 if (s->sh.slice_type == B_SLICE) {
193 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
194 luma_weight_l1_flag[i] = get_bits1(gb);
195 if (!luma_weight_l1_flag[i]) {
196 s->sh.luma_weight_l1[i] = 1 << s->sh.luma_log2_weight_denom;
197 s->sh.luma_offset_l1[i] = 0;
200 if (s->sps->chroma_format_idc != 0) {
201 for (i = 0; i < s->sh.nb_refs[L1]; i++)
202 chroma_weight_l1_flag[i] = get_bits1(gb);
204 for (i = 0; i < s->sh.nb_refs[L1]; i++)
205 chroma_weight_l1_flag[i] = 0;
207 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
208 if (luma_weight_l1_flag[i]) {
209 int delta_luma_weight_l1 = get_se_golomb(gb);
210 s->sh.luma_weight_l1[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;
211 s->sh.luma_offset_l1[i] = get_se_golomb(gb);
213 if (chroma_weight_l1_flag[i]) {
214 for (j = 0; j < 2; j++) {
215 int delta_chroma_weight_l1 = get_se_golomb(gb);
216 int delta_chroma_offset_l1 = get_se_golomb(gb);
217 s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
218 s->sh.chroma_offset_l1[i][j] = av_clip((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j])
219 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
222 s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom;
223 s->sh.chroma_offset_l1[i][0] = 0;
224 s->sh.chroma_weight_l1[i][1] = 1 << s->sh.chroma_log2_weight_denom;
225 s->sh.chroma_offset_l1[i][1] = 0;
231 static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
233 const HEVCSPS *sps = s->sps;
234 int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
235 int prev_delta_msb = 0;
236 unsigned int nb_sps = 0, nb_sh;
240 if (!sps->long_term_ref_pics_present_flag)
243 if (sps->num_long_term_ref_pics_sps > 0)
244 nb_sps = get_ue_golomb_long(gb);
245 nb_sh = get_ue_golomb_long(gb);
247 if (nb_sh + (uint64_t)nb_sps > FF_ARRAY_ELEMS(rps->poc))
248 return AVERROR_INVALIDDATA;
250 rps->nb_refs = nb_sh + nb_sps;
252 for (i = 0; i < rps->nb_refs; i++) {
253 uint8_t delta_poc_msb_present;
256 uint8_t lt_idx_sps = 0;
258 if (sps->num_long_term_ref_pics_sps > 1)
259 lt_idx_sps = get_bits(gb, av_ceil_log2(sps->num_long_term_ref_pics_sps));
261 rps->poc[i] = sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
262 rps->used[i] = sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];
264 rps->poc[i] = get_bits(gb, sps->log2_max_poc_lsb);
265 rps->used[i] = get_bits1(gb);
268 delta_poc_msb_present = get_bits1(gb);
269 if (delta_poc_msb_present) {
270 int delta = get_ue_golomb_long(gb);
272 if (i && i != nb_sps)
273 delta += prev_delta_msb;
275 rps->poc[i] += s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
276 prev_delta_msb = delta;
283 static int set_sps(HEVCContext *s, const HEVCSPS *sps, enum AVPixelFormat pix_fmt)
285 #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL)
286 enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
288 unsigned int num = 0, den = 0;
291 ret = pic_arrays_init(s, sps);
295 s->avctx->coded_width = sps->width;
296 s->avctx->coded_height = sps->height;
297 s->avctx->width = sps->output_width;
298 s->avctx->height = sps->output_height;
299 s->avctx->has_b_frames = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics;
301 if (sps->pix_fmt == AV_PIX_FMT_YUV420P || sps->pix_fmt == AV_PIX_FMT_YUVJ420P) {
302 #if CONFIG_HEVC_DXVA2_HWACCEL
303 *fmt++ = AV_PIX_FMT_DXVA2_VLD;
307 if (pix_fmt == AV_PIX_FMT_NONE) {
308 *fmt++ = sps->pix_fmt;
309 *fmt = AV_PIX_FMT_NONE;
311 ret = ff_thread_get_format(s->avctx, pix_fmts);
314 s->avctx->pix_fmt = ret;
317 s->avctx->pix_fmt = pix_fmt;
320 ff_set_sar(s->avctx, sps->vui.sar);
322 if (sps->vui.video_signal_type_present_flag)
323 s->avctx->color_range = sps->vui.video_full_range_flag ? AVCOL_RANGE_JPEG
326 s->avctx->color_range = AVCOL_RANGE_MPEG;
328 if (sps->vui.colour_description_present_flag) {
329 s->avctx->color_primaries = sps->vui.colour_primaries;
330 s->avctx->color_trc = sps->vui.transfer_characteristic;
331 s->avctx->colorspace = sps->vui.matrix_coeffs;
333 s->avctx->color_primaries = AVCOL_PRI_UNSPECIFIED;
334 s->avctx->color_trc = AVCOL_TRC_UNSPECIFIED;
335 s->avctx->colorspace = AVCOL_SPC_UNSPECIFIED;
338 ff_hevc_pred_init(&s->hpc, sps->bit_depth);
339 ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
340 ff_videodsp_init (&s->vdsp, sps->bit_depth);
342 for (i = 0; i < 3; i++) {
343 av_freep(&s->sao_pixel_buffer_h[i]);
344 av_freep(&s->sao_pixel_buffer_v[i]);
347 if (sps->sao_enabled && !s->avctx->hwaccel) {
348 int c_count = (sps->chroma_format_idc != 0) ? 3 : 1;
351 for(c_idx = 0; c_idx < c_count; c_idx++) {
352 int w = sps->width >> sps->hshift[c_idx];
353 int h = sps->height >> sps->vshift[c_idx];
354 s->sao_pixel_buffer_h[c_idx] =
355 av_malloc((w * 2 * sps->ctb_height) <<
357 s->sao_pixel_buffer_v[c_idx] =
358 av_malloc((h * 2 * sps->ctb_width) <<
364 s->vps = (HEVCVPS*) s->vps_list[s->sps->vps_id]->data;
366 if (s->vps->vps_timing_info_present_flag) {
367 num = s->vps->vps_num_units_in_tick;
368 den = s->vps->vps_time_scale;
369 } else if (sps->vui.vui_timing_info_present_flag) {
370 num = sps->vui.vui_num_units_in_tick;
371 den = sps->vui.vui_time_scale;
374 if (num != 0 && den != 0)
375 av_reduce(&s->avctx->framerate.den, &s->avctx->framerate.num,
386 static int hls_slice_header(HEVCContext *s)
388 GetBitContext *gb = &s->HEVClc->gb;
389 SliceHeader *sh = &s->sh;
393 sh->first_slice_in_pic_flag = get_bits1(gb);
394 if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
395 s->seq_decode = (s->seq_decode + 1) & 0xff;
398 ff_hevc_clear_refs(s);
400 sh->no_output_of_prior_pics_flag = 0;
402 sh->no_output_of_prior_pics_flag = get_bits1(gb);
404 sh->pps_id = get_ue_golomb_long(gb);
405 if (sh->pps_id >= MAX_PPS_COUNT || !s->pps_list[sh->pps_id]) {
406 av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
407 return AVERROR_INVALIDDATA;
409 if (!sh->first_slice_in_pic_flag &&
410 s->pps != (HEVCPPS*)s->pps_list[sh->pps_id]->data) {
411 av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
412 return AVERROR_INVALIDDATA;
414 s->pps = (HEVCPPS*)s->pps_list[sh->pps_id]->data;
415 if (s->nal_unit_type == NAL_CRA_NUT && s->last_eos == 1)
416 sh->no_output_of_prior_pics_flag = 1;
418 if (s->sps != (HEVCSPS*)s->sps_list[s->pps->sps_id]->data) {
419 const HEVCSPS* last_sps = s->sps;
420 s->sps = (HEVCSPS*)s->sps_list[s->pps->sps_id]->data;
421 if (last_sps && IS_IRAP(s) && s->nal_unit_type != NAL_CRA_NUT) {
422 if (s->sps->width != last_sps->width || s->sps->height != last_sps->height ||
423 s->sps->temporal_layer[s->sps->max_sub_layers - 1].max_dec_pic_buffering !=
424 last_sps->temporal_layer[last_sps->max_sub_layers - 1].max_dec_pic_buffering)
425 sh->no_output_of_prior_pics_flag = 0;
427 ff_hevc_clear_refs(s);
428 ret = set_sps(s, s->sps, AV_PIX_FMT_NONE);
432 s->seq_decode = (s->seq_decode + 1) & 0xff;
436 s->avctx->profile = s->sps->ptl.general_ptl.profile_idc;
437 s->avctx->level = s->sps->ptl.general_ptl.level_idc;
439 sh->dependent_slice_segment_flag = 0;
440 if (!sh->first_slice_in_pic_flag) {
441 int slice_address_length;
443 if (s->pps->dependent_slice_segments_enabled_flag)
444 sh->dependent_slice_segment_flag = get_bits1(gb);
446 slice_address_length = av_ceil_log2(s->sps->ctb_width *
448 sh->slice_segment_addr = get_bits(gb, slice_address_length);
449 if (sh->slice_segment_addr >= s->sps->ctb_width * s->sps->ctb_height) {
450 av_log(s->avctx, AV_LOG_ERROR,
451 "Invalid slice segment address: %u.\n",
452 sh->slice_segment_addr);
453 return AVERROR_INVALIDDATA;
456 if (!sh->dependent_slice_segment_flag) {
457 sh->slice_addr = sh->slice_segment_addr;
461 sh->slice_segment_addr = sh->slice_addr = 0;
463 s->slice_initialized = 0;
466 if (!sh->dependent_slice_segment_flag) {
467 s->slice_initialized = 0;
469 for (i = 0; i < s->pps->num_extra_slice_header_bits; i++)
470 skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
472 sh->slice_type = get_ue_golomb_long(gb);
473 if (!(sh->slice_type == I_SLICE ||
474 sh->slice_type == P_SLICE ||
475 sh->slice_type == B_SLICE)) {
476 av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
478 return AVERROR_INVALIDDATA;
480 if (IS_IRAP(s) && sh->slice_type != I_SLICE) {
481 av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
482 return AVERROR_INVALIDDATA;
485 // when flag is not present, picture is inferred to be output
486 sh->pic_output_flag = 1;
487 if (s->pps->output_flag_present_flag)
488 sh->pic_output_flag = get_bits1(gb);
490 if (s->sps->separate_colour_plane_flag)
491 sh->colour_plane_id = get_bits(gb, 2);
496 sh->pic_order_cnt_lsb = get_bits(gb, s->sps->log2_max_poc_lsb);
497 poc = ff_hevc_compute_poc(s, sh->pic_order_cnt_lsb);
498 if (!sh->first_slice_in_pic_flag && poc != s->poc) {
499 av_log(s->avctx, AV_LOG_WARNING,
500 "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
501 if (s->avctx->err_recognition & AV_EF_EXPLODE)
502 return AVERROR_INVALIDDATA;
507 sh->short_term_ref_pic_set_sps_flag = get_bits1(gb);
508 if (!sh->short_term_ref_pic_set_sps_flag) {
509 int pos = get_bits_left(gb);
510 ret = ff_hevc_decode_short_term_rps(s, &sh->slice_rps, s->sps, 1);
514 sh->short_term_ref_pic_set_size = pos - get_bits_left(gb);
515 sh->short_term_rps = &sh->slice_rps;
517 int numbits, rps_idx;
519 if (!s->sps->nb_st_rps) {
520 av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
521 return AVERROR_INVALIDDATA;
524 numbits = av_ceil_log2(s->sps->nb_st_rps);
525 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
526 sh->short_term_rps = &s->sps->st_rps[rps_idx];
529 ret = decode_lt_rps(s, &sh->long_term_rps, gb);
531 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
532 if (s->avctx->err_recognition & AV_EF_EXPLODE)
533 return AVERROR_INVALIDDATA;
536 if (s->sps->sps_temporal_mvp_enabled_flag)
537 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
539 sh->slice_temporal_mvp_enabled_flag = 0;
541 s->sh.short_term_rps = NULL;
546 if (s->temporal_id == 0 &&
547 s->nal_unit_type != NAL_TRAIL_N &&
548 s->nal_unit_type != NAL_TSA_N &&
549 s->nal_unit_type != NAL_STSA_N &&
550 s->nal_unit_type != NAL_RADL_N &&
551 s->nal_unit_type != NAL_RADL_R &&
552 s->nal_unit_type != NAL_RASL_N &&
553 s->nal_unit_type != NAL_RASL_R)
556 if (s->sps->sao_enabled) {
557 sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
558 if (s->sps->chroma_format_idc) {
559 sh->slice_sample_adaptive_offset_flag[1] =
560 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
563 sh->slice_sample_adaptive_offset_flag[0] = 0;
564 sh->slice_sample_adaptive_offset_flag[1] = 0;
565 sh->slice_sample_adaptive_offset_flag[2] = 0;
568 sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
569 if (sh->slice_type == P_SLICE || sh->slice_type == B_SLICE) {
572 sh->nb_refs[L0] = s->pps->num_ref_idx_l0_default_active;
573 if (sh->slice_type == B_SLICE)
574 sh->nb_refs[L1] = s->pps->num_ref_idx_l1_default_active;
576 if (get_bits1(gb)) { // num_ref_idx_active_override_flag
577 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
578 if (sh->slice_type == B_SLICE)
579 sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
581 if (sh->nb_refs[L0] > MAX_REFS || sh->nb_refs[L1] > MAX_REFS) {
582 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
583 sh->nb_refs[L0], sh->nb_refs[L1]);
584 return AVERROR_INVALIDDATA;
587 sh->rpl_modification_flag[0] = 0;
588 sh->rpl_modification_flag[1] = 0;
589 nb_refs = ff_hevc_frame_nb_refs(s);
591 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
592 return AVERROR_INVALIDDATA;
595 if (s->pps->lists_modification_present_flag && nb_refs > 1) {
596 sh->rpl_modification_flag[0] = get_bits1(gb);
597 if (sh->rpl_modification_flag[0]) {
598 for (i = 0; i < sh->nb_refs[L0]; i++)
599 sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
602 if (sh->slice_type == B_SLICE) {
603 sh->rpl_modification_flag[1] = get_bits1(gb);
604 if (sh->rpl_modification_flag[1] == 1)
605 for (i = 0; i < sh->nb_refs[L1]; i++)
606 sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
610 if (sh->slice_type == B_SLICE)
611 sh->mvd_l1_zero_flag = get_bits1(gb);
613 if (s->pps->cabac_init_present_flag)
614 sh->cabac_init_flag = get_bits1(gb);
616 sh->cabac_init_flag = 0;
618 sh->collocated_ref_idx = 0;
619 if (sh->slice_temporal_mvp_enabled_flag) {
620 sh->collocated_list = L0;
621 if (sh->slice_type == B_SLICE)
622 sh->collocated_list = !get_bits1(gb);
624 if (sh->nb_refs[sh->collocated_list] > 1) {
625 sh->collocated_ref_idx = get_ue_golomb_long(gb);
626 if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
627 av_log(s->avctx, AV_LOG_ERROR,
628 "Invalid collocated_ref_idx: %d.\n",
629 sh->collocated_ref_idx);
630 return AVERROR_INVALIDDATA;
635 if ((s->pps->weighted_pred_flag && sh->slice_type == P_SLICE) ||
636 (s->pps->weighted_bipred_flag && sh->slice_type == B_SLICE)) {
637 pred_weight_table(s, gb);
640 sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
641 if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
642 av_log(s->avctx, AV_LOG_ERROR,
643 "Invalid number of merging MVP candidates: %d.\n",
644 sh->max_num_merge_cand);
645 return AVERROR_INVALIDDATA;
649 sh->slice_qp_delta = get_se_golomb(gb);
651 if (s->pps->pic_slice_level_chroma_qp_offsets_present_flag) {
652 sh->slice_cb_qp_offset = get_se_golomb(gb);
653 sh->slice_cr_qp_offset = get_se_golomb(gb);
655 sh->slice_cb_qp_offset = 0;
656 sh->slice_cr_qp_offset = 0;
659 if (s->pps->chroma_qp_offset_list_enabled_flag)
660 sh->cu_chroma_qp_offset_enabled_flag = get_bits1(gb);
662 sh->cu_chroma_qp_offset_enabled_flag = 0;
664 if (s->pps->deblocking_filter_control_present_flag) {
665 int deblocking_filter_override_flag = 0;
667 if (s->pps->deblocking_filter_override_enabled_flag)
668 deblocking_filter_override_flag = get_bits1(gb);
670 if (deblocking_filter_override_flag) {
671 sh->disable_deblocking_filter_flag = get_bits1(gb);
672 if (!sh->disable_deblocking_filter_flag) {
673 sh->beta_offset = get_se_golomb(gb) * 2;
674 sh->tc_offset = get_se_golomb(gb) * 2;
677 sh->disable_deblocking_filter_flag = s->pps->disable_dbf;
678 sh->beta_offset = s->pps->beta_offset;
679 sh->tc_offset = s->pps->tc_offset;
682 sh->disable_deblocking_filter_flag = 0;
687 if (s->pps->seq_loop_filter_across_slices_enabled_flag &&
688 (sh->slice_sample_adaptive_offset_flag[0] ||
689 sh->slice_sample_adaptive_offset_flag[1] ||
690 !sh->disable_deblocking_filter_flag)) {
691 sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
693 sh->slice_loop_filter_across_slices_enabled_flag = s->pps->seq_loop_filter_across_slices_enabled_flag;
695 } else if (!s->slice_initialized) {
696 av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
697 return AVERROR_INVALIDDATA;
700 sh->num_entry_point_offsets = 0;
701 if (s->pps->tiles_enabled_flag || s->pps->entropy_coding_sync_enabled_flag) {
702 sh->num_entry_point_offsets = get_ue_golomb_long(gb);
703 if (sh->num_entry_point_offsets > 0) {
704 int offset_len = get_ue_golomb_long(gb) + 1;
705 int segments = offset_len >> 4;
706 int rest = (offset_len & 15);
707 av_freep(&sh->entry_point_offset);
708 av_freep(&sh->offset);
710 sh->entry_point_offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
711 sh->offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
712 sh->size = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
713 if (!sh->entry_point_offset || !sh->offset || !sh->size) {
714 sh->num_entry_point_offsets = 0;
715 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate memory\n");
716 return AVERROR(ENOMEM);
718 for (i = 0; i < sh->num_entry_point_offsets; i++) {
720 for (j = 0; j < segments; j++) {
722 val += get_bits(gb, 16);
726 val += get_bits(gb, rest);
728 sh->entry_point_offset[i] = val + 1; // +1; // +1 to get the size
730 if (s->threads_number > 1 && (s->pps->num_tile_rows > 1 || s->pps->num_tile_columns > 1)) {
731 s->enable_parallel_tiles = 0; // TODO: you can enable tiles in parallel here
732 s->threads_number = 1;
734 s->enable_parallel_tiles = 0;
736 s->enable_parallel_tiles = 0;
739 if (s->pps->slice_header_extension_present_flag) {
740 unsigned int length = get_ue_golomb_long(gb);
741 if (length*8LL > get_bits_left(gb)) {
742 av_log(s->avctx, AV_LOG_ERROR, "too many slice_header_extension_data_bytes\n");
743 return AVERROR_INVALIDDATA;
745 for (i = 0; i < length; i++)
746 skip_bits(gb, 8); // slice_header_extension_data_byte
749 // Inferred parameters
750 sh->slice_qp = 26U + s->pps->pic_init_qp_minus26 + sh->slice_qp_delta;
751 if (sh->slice_qp > 51 ||
752 sh->slice_qp < -s->sps->qp_bd_offset) {
753 av_log(s->avctx, AV_LOG_ERROR,
754 "The slice_qp %d is outside the valid range "
757 -s->sps->qp_bd_offset);
758 return AVERROR_INVALIDDATA;
761 sh->slice_ctb_addr_rs = sh->slice_segment_addr;
763 if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) {
764 av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
765 return AVERROR_INVALIDDATA;
768 if (get_bits_left(gb) < 0) {
769 av_log(s->avctx, AV_LOG_ERROR,
770 "Overread slice header by %d bits\n", -get_bits_left(gb));
771 return AVERROR_INVALIDDATA;
774 s->HEVClc->first_qp_group = !s->sh.dependent_slice_segment_flag;
776 if (!s->pps->cu_qp_delta_enabled_flag)
777 s->HEVClc->qp_y = s->sh.slice_qp;
779 s->slice_initialized = 1;
780 s->HEVClc->tu.cu_qp_offset_cb = 0;
781 s->HEVClc->tu.cu_qp_offset_cr = 0;
786 #define CTB(tab, x, y) ((tab)[(y) * s->sps->ctb_width + (x)])
788 #define SET_SAO(elem, value) \
790 if (!sao_merge_up_flag && !sao_merge_left_flag) \
792 else if (sao_merge_left_flag) \
793 sao->elem = CTB(s->sao, rx-1, ry).elem; \
794 else if (sao_merge_up_flag) \
795 sao->elem = CTB(s->sao, rx, ry-1).elem; \
800 static void hls_sao_param(HEVCContext *s, int rx, int ry)
802 HEVCLocalContext *lc = s->HEVClc;
803 int sao_merge_left_flag = 0;
804 int sao_merge_up_flag = 0;
805 SAOParams *sao = &CTB(s->sao, rx, ry);
808 if (s->sh.slice_sample_adaptive_offset_flag[0] ||
809 s->sh.slice_sample_adaptive_offset_flag[1]) {
811 if (lc->ctb_left_flag)
812 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
814 if (ry > 0 && !sao_merge_left_flag) {
816 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
820 for (c_idx = 0; c_idx < (s->sps->chroma_format_idc ? 3 : 1); c_idx++) {
821 int log2_sao_offset_scale = c_idx == 0 ? s->pps->log2_sao_offset_scale_luma :
822 s->pps->log2_sao_offset_scale_chroma;
824 if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
825 sao->type_idx[c_idx] = SAO_NOT_APPLIED;
830 sao->type_idx[2] = sao->type_idx[1];
831 sao->eo_class[2] = sao->eo_class[1];
833 SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
836 if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
839 for (i = 0; i < 4; i++)
840 SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
842 if (sao->type_idx[c_idx] == SAO_BAND) {
843 for (i = 0; i < 4; i++) {
844 if (sao->offset_abs[c_idx][i]) {
845 SET_SAO(offset_sign[c_idx][i],
846 ff_hevc_sao_offset_sign_decode(s));
848 sao->offset_sign[c_idx][i] = 0;
851 SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
852 } else if (c_idx != 2) {
853 SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
856 // Inferred parameters
857 sao->offset_val[c_idx][0] = 0;
858 for (i = 0; i < 4; i++) {
859 sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i];
860 if (sao->type_idx[c_idx] == SAO_EDGE) {
862 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
863 } else if (sao->offset_sign[c_idx][i]) {
864 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
866 sao->offset_val[c_idx][i + 1] *= 1 << log2_sao_offset_scale;
874 static int hls_cross_component_pred(HEVCContext *s, int idx) {
875 HEVCLocalContext *lc = s->HEVClc;
876 int log2_res_scale_abs_plus1 = ff_hevc_log2_res_scale_abs(s, idx);
878 if (log2_res_scale_abs_plus1 != 0) {
879 int res_scale_sign_flag = ff_hevc_res_scale_sign_flag(s, idx);
880 lc->tu.res_scale_val = (1 << (log2_res_scale_abs_plus1 - 1)) *
881 (1 - 2 * res_scale_sign_flag);
883 lc->tu.res_scale_val = 0;
890 static int hls_transform_unit(HEVCContext *s, int x0, int y0,
891 int xBase, int yBase, int cb_xBase, int cb_yBase,
892 int log2_cb_size, int log2_trafo_size,
893 int blk_idx, int cbf_luma, int *cbf_cb, int *cbf_cr)
895 HEVCLocalContext *lc = s->HEVClc;
896 const int log2_trafo_size_c = log2_trafo_size - s->sps->hshift[1];
899 if (lc->cu.pred_mode == MODE_INTRA) {
900 int trafo_size = 1 << log2_trafo_size;
901 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
903 s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
906 if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
907 (s->sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
908 int scan_idx = SCAN_DIAG;
909 int scan_idx_c = SCAN_DIAG;
910 int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
911 (s->sps->chroma_format_idc == 2 &&
912 (cbf_cb[1] || cbf_cr[1]));
914 if (s->pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
915 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
916 if (lc->tu.cu_qp_delta != 0)
917 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
918 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
919 lc->tu.is_cu_qp_delta_coded = 1;
921 if (lc->tu.cu_qp_delta < -(26 + s->sps->qp_bd_offset / 2) ||
922 lc->tu.cu_qp_delta > (25 + s->sps->qp_bd_offset / 2)) {
923 av_log(s->avctx, AV_LOG_ERROR,
924 "The cu_qp_delta %d is outside the valid range "
927 -(26 + s->sps->qp_bd_offset / 2),
928 (25 + s->sps->qp_bd_offset / 2));
929 return AVERROR_INVALIDDATA;
932 ff_hevc_set_qPy(s, cb_xBase, cb_yBase, log2_cb_size);
935 if (s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
936 !lc->cu.cu_transquant_bypass_flag && !lc->tu.is_cu_chroma_qp_offset_coded) {
937 int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(s);
938 if (cu_chroma_qp_offset_flag) {
939 int cu_chroma_qp_offset_idx = 0;
940 if (s->pps->chroma_qp_offset_list_len_minus1 > 0) {
941 cu_chroma_qp_offset_idx = ff_hevc_cu_chroma_qp_offset_idx(s);
942 av_log(s->avctx, AV_LOG_ERROR,
943 "cu_chroma_qp_offset_idx not yet tested.\n");
945 lc->tu.cu_qp_offset_cb = s->pps->cb_qp_offset_list[cu_chroma_qp_offset_idx];
946 lc->tu.cu_qp_offset_cr = s->pps->cr_qp_offset_list[cu_chroma_qp_offset_idx];
948 lc->tu.cu_qp_offset_cb = 0;
949 lc->tu.cu_qp_offset_cr = 0;
951 lc->tu.is_cu_chroma_qp_offset_coded = 1;
954 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
955 if (lc->tu.intra_pred_mode >= 6 &&
956 lc->tu.intra_pred_mode <= 14) {
957 scan_idx = SCAN_VERT;
958 } else if (lc->tu.intra_pred_mode >= 22 &&
959 lc->tu.intra_pred_mode <= 30) {
960 scan_idx = SCAN_HORIZ;
963 if (lc->tu.intra_pred_mode_c >= 6 &&
964 lc->tu.intra_pred_mode_c <= 14) {
965 scan_idx_c = SCAN_VERT;
966 } else if (lc->tu.intra_pred_mode_c >= 22 &&
967 lc->tu.intra_pred_mode_c <= 30) {
968 scan_idx_c = SCAN_HORIZ;
975 ff_hevc_hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
976 if (s->sps->chroma_format_idc && (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3)) {
977 int trafo_size_h = 1 << (log2_trafo_size_c + s->sps->hshift[1]);
978 int trafo_size_v = 1 << (log2_trafo_size_c + s->sps->vshift[1]);
979 lc->tu.cross_pf = (s->pps->cross_component_prediction_enabled_flag && cbf_luma &&
980 (lc->cu.pred_mode == MODE_INTER ||
981 (lc->tu.chroma_mode_c == 4)));
983 if (lc->tu.cross_pf) {
984 hls_cross_component_pred(s, 0);
986 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
987 if (lc->cu.pred_mode == MODE_INTRA) {
988 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
989 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 1);
992 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
993 log2_trafo_size_c, scan_idx_c, 1);
995 if (lc->tu.cross_pf) {
996 ptrdiff_t stride = s->frame->linesize[1];
997 int hshift = s->sps->hshift[1];
998 int vshift = s->sps->vshift[1];
999 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1000 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1001 int size = 1 << log2_trafo_size_c;
1003 uint8_t *dst = &s->frame->data[1][(y0 >> vshift) * stride +
1004 ((x0 >> hshift) << s->sps->pixel_shift)];
1005 for (i = 0; i < (size * size); i++) {
1006 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1008 s->hevcdsp.transform_add[log2_trafo_size_c-2](dst, coeffs, stride);
1012 if (lc->tu.cross_pf) {
1013 hls_cross_component_pred(s, 1);
1015 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1016 if (lc->cu.pred_mode == MODE_INTRA) {
1017 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1018 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 2);
1021 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1022 log2_trafo_size_c, scan_idx_c, 2);
1024 if (lc->tu.cross_pf) {
1025 ptrdiff_t stride = s->frame->linesize[2];
1026 int hshift = s->sps->hshift[2];
1027 int vshift = s->sps->vshift[2];
1028 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1029 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1030 int size = 1 << log2_trafo_size_c;
1032 uint8_t *dst = &s->frame->data[2][(y0 >> vshift) * stride +
1033 ((x0 >> hshift) << s->sps->pixel_shift)];
1034 for (i = 0; i < (size * size); i++) {
1035 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1037 s->hevcdsp.transform_add[log2_trafo_size_c-2](dst, coeffs, stride);
1040 } else if (s->sps->chroma_format_idc && blk_idx == 3) {
1041 int trafo_size_h = 1 << (log2_trafo_size + 1);
1042 int trafo_size_v = 1 << (log2_trafo_size + s->sps->vshift[1]);
1043 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1044 if (lc->cu.pred_mode == MODE_INTRA) {
1045 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1046 trafo_size_h, trafo_size_v);
1047 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 1);
1050 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1051 log2_trafo_size, scan_idx_c, 1);
1053 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1054 if (lc->cu.pred_mode == MODE_INTRA) {
1055 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1056 trafo_size_h, trafo_size_v);
1057 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 2);
1060 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1061 log2_trafo_size, scan_idx_c, 2);
1064 } else if (s->sps->chroma_format_idc && lc->cu.pred_mode == MODE_INTRA) {
1065 if (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3) {
1066 int trafo_size_h = 1 << (log2_trafo_size_c + s->sps->hshift[1]);
1067 int trafo_size_v = 1 << (log2_trafo_size_c + s->sps->vshift[1]);
1068 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size_h, trafo_size_v);
1069 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 1);
1070 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 2);
1071 if (s->sps->chroma_format_idc == 2) {
1072 ff_hevc_set_neighbour_available(s, x0, y0 + (1 << log2_trafo_size_c),
1073 trafo_size_h, trafo_size_v);
1074 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 1);
1075 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 2);
1077 } else if (blk_idx == 3) {
1078 int trafo_size_h = 1 << (log2_trafo_size + 1);
1079 int trafo_size_v = 1 << (log2_trafo_size + s->sps->vshift[1]);
1080 ff_hevc_set_neighbour_available(s, xBase, yBase,
1081 trafo_size_h, trafo_size_v);
1082 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1083 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1084 if (s->sps->chroma_format_idc == 2) {
1085 ff_hevc_set_neighbour_available(s, xBase, yBase + (1 << (log2_trafo_size)),
1086 trafo_size_h, trafo_size_v);
1087 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 1);
1088 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 2);
1096 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1098 int cb_size = 1 << log2_cb_size;
1099 int log2_min_pu_size = s->sps->log2_min_pu_size;
1101 int min_pu_width = s->sps->min_pu_width;
1102 int x_end = FFMIN(x0 + cb_size, s->sps->width);
1103 int y_end = FFMIN(y0 + cb_size, s->sps->height);
1106 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1107 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1108 s->is_pcm[i + j * min_pu_width] = 2;
1111 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1112 int xBase, int yBase, int cb_xBase, int cb_yBase,
1113 int log2_cb_size, int log2_trafo_size,
1114 int trafo_depth, int blk_idx,
1115 const int *base_cbf_cb, const int *base_cbf_cr)
1117 HEVCLocalContext *lc = s->HEVClc;
1118 uint8_t split_transform_flag;
1123 cbf_cb[0] = base_cbf_cb[0];
1124 cbf_cb[1] = base_cbf_cb[1];
1125 cbf_cr[0] = base_cbf_cr[0];
1126 cbf_cr[1] = base_cbf_cr[1];
1128 if (lc->cu.intra_split_flag) {
1129 if (trafo_depth == 1) {
1130 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1131 if (s->sps->chroma_format_idc == 3) {
1132 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[blk_idx];
1133 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[blk_idx];
1135 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1136 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1140 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[0];
1141 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1142 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1145 if (log2_trafo_size <= s->sps->log2_max_trafo_size &&
1146 log2_trafo_size > s->sps->log2_min_tb_size &&
1147 trafo_depth < lc->cu.max_trafo_depth &&
1148 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1149 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1151 int inter_split = s->sps->max_transform_hierarchy_depth_inter == 0 &&
1152 lc->cu.pred_mode == MODE_INTER &&
1153 lc->cu.part_mode != PART_2Nx2N &&
1156 split_transform_flag = log2_trafo_size > s->sps->log2_max_trafo_size ||
1157 (lc->cu.intra_split_flag && trafo_depth == 0) ||
1161 if (s->sps->chroma_format_idc && (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3)) {
1162 if (trafo_depth == 0 || cbf_cb[0]) {
1163 cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1164 if (s->sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1165 cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1169 if (trafo_depth == 0 || cbf_cr[0]) {
1170 cbf_cr[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1171 if (s->sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1172 cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1177 if (split_transform_flag) {
1178 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1179 const int x1 = x0 + trafo_size_split;
1180 const int y1 = y0 + trafo_size_split;
1182 #define SUBDIVIDE(x, y, idx) \
1184 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1185 log2_trafo_size - 1, trafo_depth + 1, idx, \
1191 SUBDIVIDE(x0, y0, 0);
1192 SUBDIVIDE(x1, y0, 1);
1193 SUBDIVIDE(x0, y1, 2);
1194 SUBDIVIDE(x1, y1, 3);
1198 int min_tu_size = 1 << s->sps->log2_min_tb_size;
1199 int log2_min_tu_size = s->sps->log2_min_tb_size;
1200 int min_tu_width = s->sps->min_tb_width;
1203 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1204 cbf_cb[0] || cbf_cr[0] ||
1205 (s->sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1206 cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1209 ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1210 log2_cb_size, log2_trafo_size,
1211 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1214 // TODO: store cbf_luma somewhere else
1217 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1218 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1219 int x_tu = (x0 + j) >> log2_min_tu_size;
1220 int y_tu = (y0 + i) >> log2_min_tu_size;
1221 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1224 if (!s->sh.disable_deblocking_filter_flag) {
1225 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1226 if (s->pps->transquant_bypass_enable_flag &&
1227 lc->cu.cu_transquant_bypass_flag)
1228 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1234 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1236 HEVCLocalContext *lc = s->HEVClc;
1238 int cb_size = 1 << log2_cb_size;
1239 int stride0 = s->frame->linesize[0];
1240 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->sps->pixel_shift)];
1241 int stride1 = s->frame->linesize[1];
1242 uint8_t *dst1 = &s->frame->data[1][(y0 >> s->sps->vshift[1]) * stride1 + ((x0 >> s->sps->hshift[1]) << s->sps->pixel_shift)];
1243 int stride2 = s->frame->linesize[2];
1244 uint8_t *dst2 = &s->frame->data[2][(y0 >> s->sps->vshift[2]) * stride2 + ((x0 >> s->sps->hshift[2]) << s->sps->pixel_shift)];
1246 int length = cb_size * cb_size * s->sps->pcm.bit_depth +
1247 (((cb_size >> s->sps->hshift[1]) * (cb_size >> s->sps->vshift[1])) +
1248 ((cb_size >> s->sps->hshift[2]) * (cb_size >> s->sps->vshift[2]))) *
1249 s->sps->pcm.bit_depth_chroma;
1250 const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1253 if (!s->sh.disable_deblocking_filter_flag)
1254 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1256 ret = init_get_bits(&gb, pcm, length);
1260 s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size, &gb, s->sps->pcm.bit_depth);
1261 if (s->sps->chroma_format_idc) {
1262 s->hevcdsp.put_pcm(dst1, stride1,
1263 cb_size >> s->sps->hshift[1],
1264 cb_size >> s->sps->vshift[1],
1265 &gb, s->sps->pcm.bit_depth_chroma);
1266 s->hevcdsp.put_pcm(dst2, stride2,
1267 cb_size >> s->sps->hshift[2],
1268 cb_size >> s->sps->vshift[2],
1269 &gb, s->sps->pcm.bit_depth_chroma);
1276 * 8.5.3.2.2.1 Luma sample unidirectional interpolation process
1278 * @param s HEVC decoding context
1279 * @param dst target buffer for block data at block position
1280 * @param dststride stride of the dst buffer
1281 * @param ref reference picture buffer at origin (0, 0)
1282 * @param mv motion vector (relative to block position) to get pixel data from
1283 * @param x_off horizontal position of block from origin (0, 0)
1284 * @param y_off vertical position of block from origin (0, 0)
1285 * @param block_w width of block
1286 * @param block_h height of block
1287 * @param luma_weight weighting factor applied to the luma prediction
1288 * @param luma_offset additive offset applied to the luma prediction value
1291 static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1292 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1293 int block_w, int block_h, int luma_weight, int luma_offset)
1295 HEVCLocalContext *lc = s->HEVClc;
1296 uint8_t *src = ref->data[0];
1297 ptrdiff_t srcstride = ref->linesize[0];
1298 int pic_width = s->sps->width;
1299 int pic_height = s->sps->height;
1302 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1303 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1304 int idx = ff_hevc_pel_weight[block_w];
1306 x_off += mv->x >> 2;
1307 y_off += mv->y >> 2;
1308 src += y_off * srcstride + x_off * (1 << s->sps->pixel_shift);
1310 if (x_off < QPEL_EXTRA_BEFORE || y_off < QPEL_EXTRA_AFTER ||
1311 x_off >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1312 y_off >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1313 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1314 int offset = QPEL_EXTRA_BEFORE * srcstride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1315 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1317 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1318 edge_emu_stride, srcstride,
1319 block_w + QPEL_EXTRA,
1320 block_h + QPEL_EXTRA,
1321 x_off - QPEL_EXTRA_BEFORE, y_off - QPEL_EXTRA_BEFORE,
1322 pic_width, pic_height);
1323 src = lc->edge_emu_buffer + buf_offset;
1324 srcstride = edge_emu_stride;
1328 s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride, src, srcstride,
1329 block_h, mx, my, block_w);
1331 s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride, src, srcstride,
1332 block_h, s->sh.luma_log2_weight_denom,
1333 luma_weight, luma_offset, mx, my, block_w);
1337 * 8.5.3.2.2.1 Luma sample bidirectional interpolation process
1339 * @param s HEVC decoding context
1340 * @param dst target buffer for block data at block position
1341 * @param dststride stride of the dst buffer
1342 * @param ref0 reference picture0 buffer at origin (0, 0)
1343 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1344 * @param x_off horizontal position of block from origin (0, 0)
1345 * @param y_off vertical position of block from origin (0, 0)
1346 * @param block_w width of block
1347 * @param block_h height of block
1348 * @param ref1 reference picture1 buffer at origin (0, 0)
1349 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1350 * @param current_mv current motion vector structure
1352 static void luma_mc_bi(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1353 AVFrame *ref0, const Mv *mv0, int x_off, int y_off,
1354 int block_w, int block_h, AVFrame *ref1, const Mv *mv1, struct MvField *current_mv)
1356 HEVCLocalContext *lc = s->HEVClc;
1357 ptrdiff_t src0stride = ref0->linesize[0];
1358 ptrdiff_t src1stride = ref1->linesize[0];
1359 int pic_width = s->sps->width;
1360 int pic_height = s->sps->height;
1361 int mx0 = mv0->x & 3;
1362 int my0 = mv0->y & 3;
1363 int mx1 = mv1->x & 3;
1364 int my1 = mv1->y & 3;
1365 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1366 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1367 int x_off0 = x_off + (mv0->x >> 2);
1368 int y_off0 = y_off + (mv0->y >> 2);
1369 int x_off1 = x_off + (mv1->x >> 2);
1370 int y_off1 = y_off + (mv1->y >> 2);
1371 int idx = ff_hevc_pel_weight[block_w];
1373 uint8_t *src0 = ref0->data[0] + y_off0 * src0stride + (int)((unsigned)x_off0 << s->sps->pixel_shift);
1374 uint8_t *src1 = ref1->data[0] + y_off1 * src1stride + (int)((unsigned)x_off1 << s->sps->pixel_shift);
1376 if (x_off0 < QPEL_EXTRA_BEFORE || y_off0 < QPEL_EXTRA_AFTER ||
1377 x_off0 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1378 y_off0 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1379 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1380 int offset = QPEL_EXTRA_BEFORE * src0stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1381 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1383 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset,
1384 edge_emu_stride, src0stride,
1385 block_w + QPEL_EXTRA,
1386 block_h + QPEL_EXTRA,
1387 x_off0 - QPEL_EXTRA_BEFORE, y_off0 - QPEL_EXTRA_BEFORE,
1388 pic_width, pic_height);
1389 src0 = lc->edge_emu_buffer + buf_offset;
1390 src0stride = edge_emu_stride;
1393 if (x_off1 < QPEL_EXTRA_BEFORE || y_off1 < QPEL_EXTRA_AFTER ||
1394 x_off1 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1395 y_off1 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1396 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1397 int offset = QPEL_EXTRA_BEFORE * src1stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1398 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1400 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src1 - offset,
1401 edge_emu_stride, src1stride,
1402 block_w + QPEL_EXTRA,
1403 block_h + QPEL_EXTRA,
1404 x_off1 - QPEL_EXTRA_BEFORE, y_off1 - QPEL_EXTRA_BEFORE,
1405 pic_width, pic_height);
1406 src1 = lc->edge_emu_buffer2 + buf_offset;
1407 src1stride = edge_emu_stride;
1410 s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](lc->tmp, src0, src0stride,
1411 block_h, mx0, my0, block_w);
1413 s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1414 block_h, mx1, my1, block_w);
1416 s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1417 block_h, s->sh.luma_log2_weight_denom,
1418 s->sh.luma_weight_l0[current_mv->ref_idx[0]],
1419 s->sh.luma_weight_l1[current_mv->ref_idx[1]],
1420 s->sh.luma_offset_l0[current_mv->ref_idx[0]],
1421 s->sh.luma_offset_l1[current_mv->ref_idx[1]],
1427 * 8.5.3.2.2.2 Chroma sample uniprediction interpolation process
1429 * @param s HEVC decoding context
1430 * @param dst1 target buffer for block data at block position (U plane)
1431 * @param dst2 target buffer for block data at block position (V plane)
1432 * @param dststride stride of the dst1 and dst2 buffers
1433 * @param ref reference picture buffer at origin (0, 0)
1434 * @param mv motion vector (relative to block position) to get pixel data from
1435 * @param x_off horizontal position of block from origin (0, 0)
1436 * @param y_off vertical position of block from origin (0, 0)
1437 * @param block_w width of block
1438 * @param block_h height of block
1439 * @param chroma_weight weighting factor applied to the chroma prediction
1440 * @param chroma_offset additive offset applied to the chroma prediction value
1443 static void chroma_mc_uni(HEVCContext *s, uint8_t *dst0,
1444 ptrdiff_t dststride, uint8_t *src0, ptrdiff_t srcstride, int reflist,
1445 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int chroma_weight, int chroma_offset)
1447 HEVCLocalContext *lc = s->HEVClc;
1448 int pic_width = s->sps->width >> s->sps->hshift[1];
1449 int pic_height = s->sps->height >> s->sps->vshift[1];
1450 const Mv *mv = ¤t_mv->mv[reflist];
1451 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1452 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1453 int idx = ff_hevc_pel_weight[block_w];
1454 int hshift = s->sps->hshift[1];
1455 int vshift = s->sps->vshift[1];
1456 intptr_t mx = mv->x & ((1 << (2 + hshift)) - 1);
1457 intptr_t my = mv->y & ((1 << (2 + vshift)) - 1);
1458 intptr_t _mx = mx << (1 - hshift);
1459 intptr_t _my = my << (1 - vshift);
1461 x_off += mv->x >> (2 + hshift);
1462 y_off += mv->y >> (2 + vshift);
1463 src0 += y_off * srcstride + x_off * (1 << s->sps->pixel_shift);
1465 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1466 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1467 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1468 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1469 int offset0 = EPEL_EXTRA_BEFORE * (srcstride + (1 << s->sps->pixel_shift));
1470 int buf_offset0 = EPEL_EXTRA_BEFORE *
1471 (edge_emu_stride + (1 << s->sps->pixel_shift));
1472 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset0,
1473 edge_emu_stride, srcstride,
1474 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1475 x_off - EPEL_EXTRA_BEFORE,
1476 y_off - EPEL_EXTRA_BEFORE,
1477 pic_width, pic_height);
1479 src0 = lc->edge_emu_buffer + buf_offset0;
1480 srcstride = edge_emu_stride;
1483 s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1484 block_h, _mx, _my, block_w);
1486 s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1487 block_h, s->sh.chroma_log2_weight_denom,
1488 chroma_weight, chroma_offset, _mx, _my, block_w);
1492 * 8.5.3.2.2.2 Chroma sample bidirectional interpolation process
1494 * @param s HEVC decoding context
1495 * @param dst target buffer for block data at block position
1496 * @param dststride stride of the dst buffer
1497 * @param ref0 reference picture0 buffer at origin (0, 0)
1498 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1499 * @param x_off horizontal position of block from origin (0, 0)
1500 * @param y_off vertical position of block from origin (0, 0)
1501 * @param block_w width of block
1502 * @param block_h height of block
1503 * @param ref1 reference picture1 buffer at origin (0, 0)
1504 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1505 * @param current_mv current motion vector structure
1506 * @param cidx chroma component(cb, cr)
1508 static void chroma_mc_bi(HEVCContext *s, uint8_t *dst0, ptrdiff_t dststride, AVFrame *ref0, AVFrame *ref1,
1509 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int cidx)
1511 HEVCLocalContext *lc = s->HEVClc;
1512 uint8_t *src1 = ref0->data[cidx+1];
1513 uint8_t *src2 = ref1->data[cidx+1];
1514 ptrdiff_t src1stride = ref0->linesize[cidx+1];
1515 ptrdiff_t src2stride = ref1->linesize[cidx+1];
1516 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1517 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1518 int pic_width = s->sps->width >> s->sps->hshift[1];
1519 int pic_height = s->sps->height >> s->sps->vshift[1];
1520 Mv *mv0 = ¤t_mv->mv[0];
1521 Mv *mv1 = ¤t_mv->mv[1];
1522 int hshift = s->sps->hshift[1];
1523 int vshift = s->sps->vshift[1];
1525 intptr_t mx0 = mv0->x & ((1 << (2 + hshift)) - 1);
1526 intptr_t my0 = mv0->y & ((1 << (2 + vshift)) - 1);
1527 intptr_t mx1 = mv1->x & ((1 << (2 + hshift)) - 1);
1528 intptr_t my1 = mv1->y & ((1 << (2 + vshift)) - 1);
1529 intptr_t _mx0 = mx0 << (1 - hshift);
1530 intptr_t _my0 = my0 << (1 - vshift);
1531 intptr_t _mx1 = mx1 << (1 - hshift);
1532 intptr_t _my1 = my1 << (1 - vshift);
1534 int x_off0 = x_off + (mv0->x >> (2 + hshift));
1535 int y_off0 = y_off + (mv0->y >> (2 + vshift));
1536 int x_off1 = x_off + (mv1->x >> (2 + hshift));
1537 int y_off1 = y_off + (mv1->y >> (2 + vshift));
1538 int idx = ff_hevc_pel_weight[block_w];
1539 src1 += y_off0 * src1stride + (int)((unsigned)x_off0 << s->sps->pixel_shift);
1540 src2 += y_off1 * src2stride + (int)((unsigned)x_off1 << s->sps->pixel_shift);
1542 if (x_off0 < EPEL_EXTRA_BEFORE || y_off0 < EPEL_EXTRA_AFTER ||
1543 x_off0 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1544 y_off0 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1545 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1546 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->sps->pixel_shift));
1547 int buf_offset1 = EPEL_EXTRA_BEFORE *
1548 (edge_emu_stride + (1 << s->sps->pixel_shift));
1550 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1551 edge_emu_stride, src1stride,
1552 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1553 x_off0 - EPEL_EXTRA_BEFORE,
1554 y_off0 - EPEL_EXTRA_BEFORE,
1555 pic_width, pic_height);
1557 src1 = lc->edge_emu_buffer + buf_offset1;
1558 src1stride = edge_emu_stride;
1561 if (x_off1 < EPEL_EXTRA_BEFORE || y_off1 < EPEL_EXTRA_AFTER ||
1562 x_off1 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1563 y_off1 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1564 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1565 int offset1 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->sps->pixel_shift));
1566 int buf_offset1 = EPEL_EXTRA_BEFORE *
1567 (edge_emu_stride + (1 << s->sps->pixel_shift));
1569 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src2 - offset1,
1570 edge_emu_stride, src2stride,
1571 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1572 x_off1 - EPEL_EXTRA_BEFORE,
1573 y_off1 - EPEL_EXTRA_BEFORE,
1574 pic_width, pic_height);
1576 src2 = lc->edge_emu_buffer2 + buf_offset1;
1577 src2stride = edge_emu_stride;
1580 s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](lc->tmp, src1, src1stride,
1581 block_h, _mx0, _my0, block_w);
1583 s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1584 src2, src2stride, lc->tmp,
1585 block_h, _mx1, _my1, block_w);
1587 s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1588 src2, src2stride, lc->tmp,
1590 s->sh.chroma_log2_weight_denom,
1591 s->sh.chroma_weight_l0[current_mv->ref_idx[0]][cidx],
1592 s->sh.chroma_weight_l1[current_mv->ref_idx[1]][cidx],
1593 s->sh.chroma_offset_l0[current_mv->ref_idx[0]][cidx],
1594 s->sh.chroma_offset_l1[current_mv->ref_idx[1]][cidx],
1595 _mx1, _my1, block_w);
1598 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1599 const Mv *mv, int y0, int height)
1601 int y = FFMAX(0, (mv->y >> 2) + y0 + height + 9);
1603 if (s->threads_type == FF_THREAD_FRAME )
1604 ff_thread_await_progress(&ref->tf, y, 0);
1607 static void hevc_luma_mv_mpv_mode(HEVCContext *s, int x0, int y0, int nPbW,
1608 int nPbH, int log2_cb_size, int part_idx,
1609 int merge_idx, MvField *mv)
1611 HEVCLocalContext *lc = s->HEVClc;
1612 enum InterPredIdc inter_pred_idc = PRED_L0;
1615 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1617 if (s->sh.slice_type == B_SLICE)
1618 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1620 if (inter_pred_idc != PRED_L1) {
1621 if (s->sh.nb_refs[L0])
1622 mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1624 mv->pred_flag = PF_L0;
1625 ff_hevc_hls_mvd_coding(s, x0, y0, 0);
1626 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1627 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1628 part_idx, merge_idx, mv, mvp_flag, 0);
1629 mv->mv[0].x += lc->pu.mvd.x;
1630 mv->mv[0].y += lc->pu.mvd.y;
1633 if (inter_pred_idc != PRED_L0) {
1634 if (s->sh.nb_refs[L1])
1635 mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1637 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1638 AV_ZERO32(&lc->pu.mvd);
1640 ff_hevc_hls_mvd_coding(s, x0, y0, 1);
1643 mv->pred_flag += PF_L1;
1644 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1645 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1646 part_idx, merge_idx, mv, mvp_flag, 1);
1647 mv->mv[1].x += lc->pu.mvd.x;
1648 mv->mv[1].y += lc->pu.mvd.y;
1652 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1654 int log2_cb_size, int partIdx, int idx)
1656 #define POS(c_idx, x, y) \
1657 &s->frame->data[c_idx][((y) >> s->sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1658 (((x) >> s->sps->hshift[c_idx]) << s->sps->pixel_shift)]
1659 HEVCLocalContext *lc = s->HEVClc;
1661 struct MvField current_mv = {{{ 0 }}};
1663 int min_pu_width = s->sps->min_pu_width;
1665 MvField *tab_mvf = s->ref->tab_mvf;
1666 RefPicList *refPicList = s->ref->refPicList;
1667 HEVCFrame *ref0 = NULL, *ref1 = NULL;
1668 uint8_t *dst0 = POS(0, x0, y0);
1669 uint8_t *dst1 = POS(1, x0, y0);
1670 uint8_t *dst2 = POS(2, x0, y0);
1671 int log2_min_cb_size = s->sps->log2_min_cb_size;
1672 int min_cb_width = s->sps->min_cb_width;
1673 int x_cb = x0 >> log2_min_cb_size;
1674 int y_cb = y0 >> log2_min_cb_size;
1678 int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1681 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1683 if (skip_flag || lc->pu.merge_flag) {
1684 if (s->sh.max_num_merge_cand > 1)
1685 merge_idx = ff_hevc_merge_idx_decode(s);
1689 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1690 partIdx, merge_idx, ¤t_mv);
1692 hevc_luma_mv_mpv_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1693 partIdx, merge_idx, ¤t_mv);
1696 x_pu = x0 >> s->sps->log2_min_pu_size;
1697 y_pu = y0 >> s->sps->log2_min_pu_size;
1699 for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1700 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1701 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1703 if (current_mv.pred_flag & PF_L0) {
1704 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1707 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1709 if (current_mv.pred_flag & PF_L1) {
1710 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1713 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1716 if (current_mv.pred_flag == PF_L0) {
1717 int x0_c = x0 >> s->sps->hshift[1];
1718 int y0_c = y0 >> s->sps->vshift[1];
1719 int nPbW_c = nPbW >> s->sps->hshift[1];
1720 int nPbH_c = nPbH >> s->sps->vshift[1];
1722 luma_mc_uni(s, dst0, s->frame->linesize[0], ref0->frame,
1723 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1724 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1725 s->sh.luma_offset_l0[current_mv.ref_idx[0]]);
1727 if (s->sps->chroma_format_idc) {
1728 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref0->frame->data[1], ref0->frame->linesize[1],
1729 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1730 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]);
1731 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref0->frame->data[2], ref0->frame->linesize[2],
1732 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1733 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]);
1735 } else if (current_mv.pred_flag == PF_L1) {
1736 int x0_c = x0 >> s->sps->hshift[1];
1737 int y0_c = y0 >> s->sps->vshift[1];
1738 int nPbW_c = nPbW >> s->sps->hshift[1];
1739 int nPbH_c = nPbH >> s->sps->vshift[1];
1741 luma_mc_uni(s, dst0, s->frame->linesize[0], ref1->frame,
1742 ¤t_mv.mv[1], x0, y0, nPbW, nPbH,
1743 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1744 s->sh.luma_offset_l1[current_mv.ref_idx[1]]);
1746 if (s->sps->chroma_format_idc) {
1747 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
1748 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1749 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]);
1751 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
1752 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1753 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]);
1755 } else if (current_mv.pred_flag == PF_BI) {
1756 int x0_c = x0 >> s->sps->hshift[1];
1757 int y0_c = y0 >> s->sps->vshift[1];
1758 int nPbW_c = nPbW >> s->sps->hshift[1];
1759 int nPbH_c = nPbH >> s->sps->vshift[1];
1761 luma_mc_bi(s, dst0, s->frame->linesize[0], ref0->frame,
1762 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1763 ref1->frame, ¤t_mv.mv[1], ¤t_mv);
1765 if (s->sps->chroma_format_idc) {
1766 chroma_mc_bi(s, dst1, s->frame->linesize[1], ref0->frame, ref1->frame,
1767 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 0);
1769 chroma_mc_bi(s, dst2, s->frame->linesize[2], ref0->frame, ref1->frame,
1770 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1);
1778 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1779 int prev_intra_luma_pred_flag)
1781 HEVCLocalContext *lc = s->HEVClc;
1782 int x_pu = x0 >> s->sps->log2_min_pu_size;
1783 int y_pu = y0 >> s->sps->log2_min_pu_size;
1784 int min_pu_width = s->sps->min_pu_width;
1785 int size_in_pus = pu_size >> s->sps->log2_min_pu_size;
1786 int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1);
1787 int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1);
1789 int cand_up = (lc->ctb_up_flag || y0b) ?
1790 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1791 int cand_left = (lc->ctb_left_flag || x0b) ?
1792 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1794 int y_ctb = (y0 >> (s->sps->log2_ctb_size)) << (s->sps->log2_ctb_size);
1796 MvField *tab_mvf = s->ref->tab_mvf;
1797 int intra_pred_mode;
1801 // intra_pred_mode prediction does not cross vertical CTB boundaries
1802 if ((y0 - 1) < y_ctb)
1805 if (cand_left == cand_up) {
1806 if (cand_left < 2) {
1807 candidate[0] = INTRA_PLANAR;
1808 candidate[1] = INTRA_DC;
1809 candidate[2] = INTRA_ANGULAR_26;
1811 candidate[0] = cand_left;
1812 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1813 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1816 candidate[0] = cand_left;
1817 candidate[1] = cand_up;
1818 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1819 candidate[2] = INTRA_PLANAR;
1820 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1821 candidate[2] = INTRA_DC;
1823 candidate[2] = INTRA_ANGULAR_26;
1827 if (prev_intra_luma_pred_flag) {
1828 intra_pred_mode = candidate[lc->pu.mpm_idx];
1830 if (candidate[0] > candidate[1])
1831 FFSWAP(uint8_t, candidate[0], candidate[1]);
1832 if (candidate[0] > candidate[2])
1833 FFSWAP(uint8_t, candidate[0], candidate[2]);
1834 if (candidate[1] > candidate[2])
1835 FFSWAP(uint8_t, candidate[1], candidate[2]);
1837 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1838 for (i = 0; i < 3; i++)
1839 if (intra_pred_mode >= candidate[i])
1843 /* write the intra prediction units into the mv array */
1846 for (i = 0; i < size_in_pus; i++) {
1847 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1848 intra_pred_mode, size_in_pus);
1850 for (j = 0; j < size_in_pus; j++) {
1851 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag = PF_INTRA;
1855 return intra_pred_mode;
1858 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1859 int log2_cb_size, int ct_depth)
1861 int length = (1 << log2_cb_size) >> s->sps->log2_min_cb_size;
1862 int x_cb = x0 >> s->sps->log2_min_cb_size;
1863 int y_cb = y0 >> s->sps->log2_min_cb_size;
1866 for (y = 0; y < length; y++)
1867 memset(&s->tab_ct_depth[(y_cb + y) * s->sps->min_cb_width + x_cb],
1871 static const uint8_t tab_mode_idx[] = {
1872 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
1873 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
1875 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1878 HEVCLocalContext *lc = s->HEVClc;
1879 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1880 uint8_t prev_intra_luma_pred_flag[4];
1881 int split = lc->cu.part_mode == PART_NxN;
1882 int pb_size = (1 << log2_cb_size) >> split;
1883 int side = split + 1;
1887 for (i = 0; i < side; i++)
1888 for (j = 0; j < side; j++)
1889 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1891 for (i = 0; i < side; i++) {
1892 for (j = 0; j < side; j++) {
1893 if (prev_intra_luma_pred_flag[2 * i + j])
1894 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
1896 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
1898 lc->pu.intra_pred_mode[2 * i + j] =
1899 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1900 prev_intra_luma_pred_flag[2 * i + j]);
1904 if (s->sps->chroma_format_idc == 3) {
1905 for (i = 0; i < side; i++) {
1906 for (j = 0; j < side; j++) {
1907 lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1908 if (chroma_mode != 4) {
1909 if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode])
1910 lc->pu.intra_pred_mode_c[2 * i + j] = 34;
1912 lc->pu.intra_pred_mode_c[2 * i + j] = intra_chroma_table[chroma_mode];
1914 lc->pu.intra_pred_mode_c[2 * i + j] = lc->pu.intra_pred_mode[2 * i + j];
1918 } else if (s->sps->chroma_format_idc == 2) {
1920 lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1921 if (chroma_mode != 4) {
1922 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1925 mode_idx = intra_chroma_table[chroma_mode];
1927 mode_idx = lc->pu.intra_pred_mode[0];
1929 lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx];
1930 } else if (s->sps->chroma_format_idc != 0) {
1931 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1932 if (chroma_mode != 4) {
1933 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1934 lc->pu.intra_pred_mode_c[0] = 34;
1936 lc->pu.intra_pred_mode_c[0] = intra_chroma_table[chroma_mode];
1938 lc->pu.intra_pred_mode_c[0] = lc->pu.intra_pred_mode[0];
1943 static void intra_prediction_unit_default_value(HEVCContext *s,
1947 HEVCLocalContext *lc = s->HEVClc;
1948 int pb_size = 1 << log2_cb_size;
1949 int size_in_pus = pb_size >> s->sps->log2_min_pu_size;
1950 int min_pu_width = s->sps->min_pu_width;
1951 MvField *tab_mvf = s->ref->tab_mvf;
1952 int x_pu = x0 >> s->sps->log2_min_pu_size;
1953 int y_pu = y0 >> s->sps->log2_min_pu_size;
1956 if (size_in_pus == 0)
1958 for (j = 0; j < size_in_pus; j++)
1959 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
1960 if (lc->cu.pred_mode == MODE_INTRA)
1961 for (j = 0; j < size_in_pus; j++)
1962 for (k = 0; k < size_in_pus; k++)
1963 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].pred_flag = PF_INTRA;
1966 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
1968 int cb_size = 1 << log2_cb_size;
1969 HEVCLocalContext *lc = s->HEVClc;
1970 int log2_min_cb_size = s->sps->log2_min_cb_size;
1971 int length = cb_size >> log2_min_cb_size;
1972 int min_cb_width = s->sps->min_cb_width;
1973 int x_cb = x0 >> log2_min_cb_size;
1974 int y_cb = y0 >> log2_min_cb_size;
1975 int idx = log2_cb_size - 2;
1976 int qp_block_mask = (1<<(s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth)) - 1;
1981 lc->cu.pred_mode = MODE_INTRA;
1982 lc->cu.part_mode = PART_2Nx2N;
1983 lc->cu.intra_split_flag = 0;
1985 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
1986 for (x = 0; x < 4; x++)
1987 lc->pu.intra_pred_mode[x] = 1;
1988 if (s->pps->transquant_bypass_enable_flag) {
1989 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
1990 if (lc->cu.cu_transquant_bypass_flag)
1991 set_deblocking_bypass(s, x0, y0, log2_cb_size);
1993 lc->cu.cu_transquant_bypass_flag = 0;
1995 if (s->sh.slice_type != I_SLICE) {
1996 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
1998 x = y_cb * min_cb_width + x_cb;
1999 for (y = 0; y < length; y++) {
2000 memset(&s->skip_flag[x], skip_flag, length);
2003 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2005 x = y_cb * min_cb_width + x_cb;
2006 for (y = 0; y < length; y++) {
2007 memset(&s->skip_flag[x], 0, length);
2012 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2013 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2014 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2016 if (!s->sh.disable_deblocking_filter_flag)
2017 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2021 if (s->sh.slice_type != I_SLICE)
2022 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2023 if (lc->cu.pred_mode != MODE_INTRA ||
2024 log2_cb_size == s->sps->log2_min_cb_size) {
2025 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2026 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2027 lc->cu.pred_mode == MODE_INTRA;
2030 if (lc->cu.pred_mode == MODE_INTRA) {
2031 if (lc->cu.part_mode == PART_2Nx2N && s->sps->pcm_enabled_flag &&
2032 log2_cb_size >= s->sps->pcm.log2_min_pcm_cb_size &&
2033 log2_cb_size <= s->sps->pcm.log2_max_pcm_cb_size) {
2034 pcm_flag = ff_hevc_pcm_flag_decode(s);
2037 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2038 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2039 if (s->sps->pcm.loop_filter_disable_flag)
2040 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2045 intra_prediction_unit(s, x0, y0, log2_cb_size);
2048 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2049 switch (lc->cu.part_mode) {
2051 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2054 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0, idx);
2055 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2058 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2059 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2062 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0, idx);
2063 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2066 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2067 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2070 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0, idx - 2);
2071 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2074 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2075 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2078 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2079 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2080 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2081 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2087 int rqt_root_cbf = 1;
2089 if (lc->cu.pred_mode != MODE_INTRA &&
2090 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2091 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2094 const static int cbf[2] = { 0 };
2095 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2096 s->sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2097 s->sps->max_transform_hierarchy_depth_inter;
2098 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2100 log2_cb_size, 0, 0, cbf, cbf);
2104 if (!s->sh.disable_deblocking_filter_flag)
2105 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2110 if (s->pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2111 ff_hevc_set_qPy(s, x0, y0, log2_cb_size);
2113 x = y_cb * min_cb_width + x_cb;
2114 for (y = 0; y < length; y++) {
2115 memset(&s->qp_y_tab[x], lc->qp_y, length);
2119 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2120 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2121 lc->qPy_pred = lc->qp_y;
2124 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct_depth);
2129 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2130 int log2_cb_size, int cb_depth)
2132 HEVCLocalContext *lc = s->HEVClc;
2133 const int cb_size = 1 << log2_cb_size;
2137 lc->ct_depth = cb_depth;
2138 if (x0 + cb_size <= s->sps->width &&
2139 y0 + cb_size <= s->sps->height &&
2140 log2_cb_size > s->sps->log2_min_cb_size) {
2141 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2143 split_cu = (log2_cb_size > s->sps->log2_min_cb_size);
2145 if (s->pps->cu_qp_delta_enabled_flag &&
2146 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth) {
2147 lc->tu.is_cu_qp_delta_coded = 0;
2148 lc->tu.cu_qp_delta = 0;
2151 if (s->sh.cu_chroma_qp_offset_enabled_flag &&
2152 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_chroma_qp_offset_depth) {
2153 lc->tu.is_cu_chroma_qp_offset_coded = 0;
2157 int qp_block_mask = (1<<(s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth)) - 1;
2158 const int cb_size_split = cb_size >> 1;
2159 const int x1 = x0 + cb_size_split;
2160 const int y1 = y0 + cb_size_split;
2164 more_data = hls_coding_quadtree(s, x0, y0, log2_cb_size - 1, cb_depth + 1);
2168 if (more_data && x1 < s->sps->width) {
2169 more_data = hls_coding_quadtree(s, x1, y0, log2_cb_size - 1, cb_depth + 1);
2173 if (more_data && y1 < s->sps->height) {
2174 more_data = hls_coding_quadtree(s, x0, y1, log2_cb_size - 1, cb_depth + 1);
2178 if (more_data && x1 < s->sps->width &&
2179 y1 < s->sps->height) {
2180 more_data = hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1);
2185 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2186 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2187 lc->qPy_pred = lc->qp_y;
2190 return ((x1 + cb_size_split) < s->sps->width ||
2191 (y1 + cb_size_split) < s->sps->height);
2195 ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2198 if ((!((x0 + cb_size) %
2199 (1 << (s->sps->log2_ctb_size))) ||
2200 (x0 + cb_size >= s->sps->width)) &&
2202 (1 << (s->sps->log2_ctb_size))) ||
2203 (y0 + cb_size >= s->sps->height))) {
2204 int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s);
2205 return !end_of_slice_flag;
2214 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2217 HEVCLocalContext *lc = s->HEVClc;
2218 int ctb_size = 1 << s->sps->log2_ctb_size;
2219 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2220 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2222 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2224 if (s->pps->entropy_coding_sync_enabled_flag) {
2225 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2226 lc->first_qp_group = 1;
2227 lc->end_of_tiles_x = s->sps->width;
2228 } else if (s->pps->tiles_enabled_flag) {
2229 if (ctb_addr_ts && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1]) {
2230 int idxX = s->pps->col_idxX[x_ctb >> s->sps->log2_ctb_size];
2231 lc->end_of_tiles_x = x_ctb + (s->pps->column_width[idxX] << s->sps->log2_ctb_size);
2232 lc->first_qp_group = 1;
2235 lc->end_of_tiles_x = s->sps->width;
2238 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->sps->height);
2240 lc->boundary_flags = 0;
2241 if (s->pps->tiles_enabled_flag) {
2242 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]])
2243 lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2244 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2245 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2246 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]])
2247 lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2248 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->sps->ctb_width])
2249 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2251 if (!ctb_addr_in_slice > 0)
2252 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2253 if (ctb_addr_in_slice < s->sps->ctb_width)
2254 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2257 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2258 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2259 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]]));
2260 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]]));
2263 static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
2265 HEVCContext *s = avctxt->priv_data;
2266 int ctb_size = 1 << s->sps->log2_ctb_size;
2270 int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2272 if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) {
2273 av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n");
2274 return AVERROR_INVALIDDATA;
2277 if (s->sh.dependent_slice_segment_flag) {
2278 int prev_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2279 if (s->tab_slice_address[prev_rs] != s->sh.slice_addr) {
2280 av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n");
2281 return AVERROR_INVALIDDATA;
2285 while (more_data && ctb_addr_ts < s->sps->ctb_size) {
2286 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2288 x_ctb = (ctb_addr_rs % ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2289 y_ctb = (ctb_addr_rs / ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2290 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2292 ff_hevc_cabac_init(s, ctb_addr_ts);
2294 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2296 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2297 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2298 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2300 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2301 if (more_data < 0) {
2302 s->tab_slice_address[ctb_addr_rs] = -1;
2308 ff_hevc_save_states(s, ctb_addr_ts);
2309 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2312 if (x_ctb + ctb_size >= s->sps->width &&
2313 y_ctb + ctb_size >= s->sps->height)
2314 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2319 static int hls_slice_data(HEVCContext *s)
2327 s->avctx->execute(s->avctx, hls_decode_entry, arg, ret , 1, sizeof(int));
2330 static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int job, int self_id)
2332 HEVCContext *s1 = avctxt->priv_data, *s;
2333 HEVCLocalContext *lc;
2334 int ctb_size = 1<< s1->sps->log2_ctb_size;
2336 int *ctb_row_p = input_ctb_row;
2337 int ctb_row = ctb_row_p[job];
2338 int ctb_addr_rs = s1->sh.slice_ctb_addr_rs + ctb_row * ((s1->sps->width + ctb_size - 1) >> s1->sps->log2_ctb_size);
2339 int ctb_addr_ts = s1->pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2340 int thread = ctb_row % s1->threads_number;
2343 s = s1->sList[self_id];
2347 ret = init_get_bits8(&lc->gb, s->data + s->sh.offset[ctb_row - 1], s->sh.size[ctb_row - 1]);
2351 ff_init_cabac_decoder(&lc->cc, s->data + s->sh.offset[(ctb_row)-1], s->sh.size[ctb_row - 1]);
2354 while(more_data && ctb_addr_ts < s->sps->ctb_size) {
2355 int x_ctb = (ctb_addr_rs % s->sps->ctb_width) << s->sps->log2_ctb_size;
2356 int y_ctb = (ctb_addr_rs / s->sps->ctb_width) << s->sps->log2_ctb_size;
2358 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2360 ff_thread_await_progress2(s->avctx, ctb_row, thread, SHIFT_CTB_WPP);
2362 if (avpriv_atomic_int_get(&s1->wpp_err)){
2363 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2367 ff_hevc_cabac_init(s, ctb_addr_ts);
2368 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2369 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2371 if (more_data < 0) {
2372 s->tab_slice_address[ctb_addr_rs] = -1;
2378 ff_hevc_save_states(s, ctb_addr_ts);
2379 ff_thread_report_progress2(s->avctx, ctb_row, thread, 1);
2380 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2382 if (!more_data && (x_ctb+ctb_size) < s->sps->width && ctb_row != s->sh.num_entry_point_offsets) {
2383 avpriv_atomic_int_set(&s1->wpp_err, 1);
2384 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2388 if ((x_ctb+ctb_size) >= s->sps->width && (y_ctb+ctb_size) >= s->sps->height ) {
2389 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2390 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2393 ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2396 if(x_ctb >= s->sps->width) {
2400 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2405 static int hls_slice_data_wpp(HEVCContext *s, const uint8_t *nal, int length)
2407 HEVCLocalContext *lc = s->HEVClc;
2408 int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2409 int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2411 int startheader, cmpt = 0;
2417 return AVERROR(ENOMEM);
2422 ff_alloc_entries(s->avctx, s->sh.num_entry_point_offsets + 1);
2425 for (i = 1; i < s->threads_number; i++) {
2426 s->sList[i] = av_malloc(sizeof(HEVCContext));
2427 memcpy(s->sList[i], s, sizeof(HEVCContext));
2428 s->HEVClcList[i] = av_mallocz(sizeof(HEVCLocalContext));
2429 s->sList[i]->HEVClc = s->HEVClcList[i];
2433 offset = (lc->gb.index >> 3);
2435 for (j = 0, cmpt = 0, startheader = offset + s->sh.entry_point_offset[0]; j < s->skipped_bytes; j++) {
2436 if (s->skipped_bytes_pos[j] >= offset && s->skipped_bytes_pos[j] < startheader) {
2442 for (i = 1; i < s->sh.num_entry_point_offsets; i++) {
2443 offset += (s->sh.entry_point_offset[i - 1] - cmpt);
2444 for (j = 0, cmpt = 0, startheader = offset
2445 + s->sh.entry_point_offset[i]; j < s->skipped_bytes; j++) {
2446 if (s->skipped_bytes_pos[j] >= offset && s->skipped_bytes_pos[j] < startheader) {
2451 s->sh.size[i - 1] = s->sh.entry_point_offset[i] - cmpt;
2452 s->sh.offset[i - 1] = offset;
2455 if (s->sh.num_entry_point_offsets != 0) {
2456 offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt;
2457 s->sh.size[s->sh.num_entry_point_offsets - 1] = length - offset;
2458 s->sh.offset[s->sh.num_entry_point_offsets - 1] = offset;
2463 for (i = 1; i < s->threads_number; i++) {
2464 s->sList[i]->HEVClc->first_qp_group = 1;
2465 s->sList[i]->HEVClc->qp_y = s->sList[0]->HEVClc->qp_y;
2466 memcpy(s->sList[i], s, sizeof(HEVCContext));
2467 s->sList[i]->HEVClc = s->HEVClcList[i];
2470 avpriv_atomic_int_set(&s->wpp_err, 0);
2471 ff_reset_entries(s->avctx);
2473 for (i = 0; i <= s->sh.num_entry_point_offsets; i++) {
2478 if (s->pps->entropy_coding_sync_enabled_flag)
2479 s->avctx->execute2(s->avctx, (void *) hls_decode_entry_wpp, arg, ret, s->sh.num_entry_point_offsets + 1);
2481 for (i = 0; i <= s->sh.num_entry_point_offsets; i++)
2489 * @return AVERROR_INVALIDDATA if the packet is not a valid NAL unit,
2490 * 0 if the unit should be skipped, 1 otherwise
2492 static int hls_nal_unit(HEVCContext *s)
2494 GetBitContext *gb = &s->HEVClc->gb;
2497 if (get_bits1(gb) != 0)
2498 return AVERROR_INVALIDDATA;
2500 s->nal_unit_type = get_bits(gb, 6);
2502 nuh_layer_id = get_bits(gb, 6);
2503 s->temporal_id = get_bits(gb, 3) - 1;
2504 if (s->temporal_id < 0)
2505 return AVERROR_INVALIDDATA;
2507 av_log(s->avctx, AV_LOG_DEBUG,
2508 "nal_unit_type: %d, nuh_layer_id: %d, temporal_id: %d\n",
2509 s->nal_unit_type, nuh_layer_id, s->temporal_id);
2511 return nuh_layer_id == 0;
2514 static int set_side_data(HEVCContext *s)
2516 AVFrame *out = s->ref->frame;
2518 if (s->sei_frame_packing_present &&
2519 s->frame_packing_arrangement_type >= 3 &&
2520 s->frame_packing_arrangement_type <= 5 &&
2521 s->content_interpretation_type > 0 &&
2522 s->content_interpretation_type < 3) {
2523 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2525 return AVERROR(ENOMEM);
2527 switch (s->frame_packing_arrangement_type) {
2529 if (s->quincunx_subsampling)
2530 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2532 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2535 stereo->type = AV_STEREO3D_TOPBOTTOM;
2538 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2542 if (s->content_interpretation_type == 2)
2543 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2546 if (s->sei_display_orientation_present &&
2547 (s->sei_anticlockwise_rotation || s->sei_hflip || s->sei_vflip)) {
2548 double angle = s->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
2549 AVFrameSideData *rotation = av_frame_new_side_data(out,
2550 AV_FRAME_DATA_DISPLAYMATRIX,
2551 sizeof(int32_t) * 9);
2553 return AVERROR(ENOMEM);
2555 av_display_rotation_set((int32_t *)rotation->data, angle);
2556 av_display_matrix_flip((int32_t *)rotation->data,
2557 s->sei_hflip, s->sei_vflip);
2563 static int hevc_frame_start(HEVCContext *s)
2565 HEVCLocalContext *lc = s->HEVClc;
2566 int pic_size_in_ctb = ((s->sps->width >> s->sps->log2_min_cb_size) + 1) *
2567 ((s->sps->height >> s->sps->log2_min_cb_size) + 1);
2570 memset(s->horizontal_bs, 0, s->bs_width * s->bs_height);
2571 memset(s->vertical_bs, 0, s->bs_width * s->bs_height);
2572 memset(s->cbf_luma, 0, s->sps->min_tb_width * s->sps->min_tb_height);
2573 memset(s->is_pcm, 0, (s->sps->min_pu_width + 1) * (s->sps->min_pu_height + 1));
2574 memset(s->tab_slice_address, -1, pic_size_in_ctb * sizeof(*s->tab_slice_address));
2577 s->first_nal_type = s->nal_unit_type;
2579 if (s->pps->tiles_enabled_flag)
2580 lc->end_of_tiles_x = s->pps->column_width[0] << s->sps->log2_ctb_size;
2582 ret = ff_hevc_set_new_ref(s, &s->frame, s->poc);
2586 ret = ff_hevc_frame_rps(s);
2588 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2592 s->ref->frame->key_frame = IS_IRAP(s);
2594 ret = set_side_data(s);
2598 s->frame->pict_type = 3 - s->sh.slice_type;
2601 ff_hevc_bump_frame(s);
2603 av_frame_unref(s->output_frame);
2604 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2608 if (!s->avctx->hwaccel)
2609 ff_thread_finish_setup(s->avctx);
2615 ff_hevc_unref_frame(s, s->ref, ~0);
2620 static int decode_nal_unit(HEVCContext *s, const HEVCNAL *nal)
2622 HEVCLocalContext *lc = s->HEVClc;
2623 GetBitContext *gb = &lc->gb;
2624 int ctb_addr_ts, ret;
2626 ret = init_get_bits8(gb, nal->data, nal->size);
2630 ret = hls_nal_unit(s);
2632 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit %d, skipping.\n",
2638 switch (s->nal_unit_type) {
2640 ret = ff_hevc_decode_nal_vps(s);
2645 ret = ff_hevc_decode_nal_sps(s);
2650 ret = ff_hevc_decode_nal_pps(s);
2654 case NAL_SEI_PREFIX:
2655 case NAL_SEI_SUFFIX:
2656 ret = ff_hevc_decode_nal_sei(s);
2667 case NAL_BLA_W_RADL:
2669 case NAL_IDR_W_RADL:
2676 ret = hls_slice_header(s);
2680 if (s->max_ra == INT_MAX) {
2681 if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
2685 s->max_ra = INT_MIN;
2689 if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
2690 s->poc <= s->max_ra) {
2694 if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
2695 s->max_ra = INT_MIN;
2698 if (s->sh.first_slice_in_pic_flag) {
2699 ret = hevc_frame_start(s);
2702 } else if (!s->ref) {
2703 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2707 if (s->nal_unit_type != s->first_nal_type) {
2708 av_log(s->avctx, AV_LOG_ERROR,
2709 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2710 s->first_nal_type, s->nal_unit_type);
2711 return AVERROR_INVALIDDATA;
2714 if (!s->sh.dependent_slice_segment_flag &&
2715 s->sh.slice_type != I_SLICE) {
2716 ret = ff_hevc_slice_rpl(s);
2718 av_log(s->avctx, AV_LOG_WARNING,
2719 "Error constructing the reference lists for the current slice.\n");
2724 if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) {
2725 ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0);
2730 if (s->avctx->hwaccel) {
2731 ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size);
2735 if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
2736 ctb_addr_ts = hls_slice_data_wpp(s, nal->data, nal->size);
2738 ctb_addr_ts = hls_slice_data(s);
2739 if (ctb_addr_ts >= (s->sps->ctb_width * s->sps->ctb_height)) {
2743 if (ctb_addr_ts < 0) {
2751 s->seq_decode = (s->seq_decode + 1) & 0xff;
2752 s->max_ra = INT_MAX;
2758 av_log(s->avctx, AV_LOG_INFO,
2759 "Skipping NAL unit %d\n", s->nal_unit_type);
2764 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2769 /* FIXME: This is adapted from ff_h264_decode_nal, avoiding duplication
2770 * between these functions would be nice. */
2771 int ff_hevc_extract_rbsp(HEVCContext *s, const uint8_t *src, int length,
2777 s->skipped_bytes = 0;
2778 #define STARTCODE_TEST \
2779 if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \
2780 if (src[i + 2] != 3) { \
2781 /* startcode, so we must be past the end */ \
2786 #if HAVE_FAST_UNALIGNED
2787 #define FIND_FIRST_ZERO \
2788 if (i > 0 && !src[i]) \
2793 for (i = 0; i + 1 < length; i += 9) {
2794 if (!((~AV_RN64A(src + i) &
2795 (AV_RN64A(src + i) - 0x0100010001000101ULL)) &
2796 0x8000800080008080ULL))
2803 for (i = 0; i + 1 < length; i += 5) {
2804 if (!((~AV_RN32A(src + i) &
2805 (AV_RN32A(src + i) - 0x01000101U)) &
2812 #endif /* HAVE_FAST_64BIT */
2814 for (i = 0; i + 1 < length; i += 2) {
2817 if (i > 0 && src[i - 1] == 0)
2821 #endif /* HAVE_FAST_UNALIGNED */
2823 if (i >= length - 1) { // no escaped 0
2825 nal->raw_data = src;
2827 nal->raw_size = length;
2831 av_fast_malloc(&nal->rbsp_buffer, &nal->rbsp_buffer_size,
2832 length + FF_INPUT_BUFFER_PADDING_SIZE);
2833 if (!nal->rbsp_buffer)
2834 return AVERROR(ENOMEM);
2836 dst = nal->rbsp_buffer;
2838 memcpy(dst, src, i);
2840 while (si + 2 < length) {
2841 // remove escapes (very rare 1:2^22)
2842 if (src[si + 2] > 3) {
2843 dst[di++] = src[si++];
2844 dst[di++] = src[si++];
2845 } else if (src[si] == 0 && src[si + 1] == 0) {
2846 if (src[si + 2] == 3) { // escape
2852 if (s->skipped_bytes_pos_size < s->skipped_bytes) {
2853 s->skipped_bytes_pos_size *= 2;
2854 av_reallocp_array(&s->skipped_bytes_pos,
2855 s->skipped_bytes_pos_size,
2856 sizeof(*s->skipped_bytes_pos));
2857 if (!s->skipped_bytes_pos)
2858 return AVERROR(ENOMEM);
2860 if (s->skipped_bytes_pos)
2861 s->skipped_bytes_pos[s->skipped_bytes-1] = di - 1;
2863 } else // next start code
2867 dst[di++] = src[si++];
2870 dst[di++] = src[si++];
2873 memset(dst + di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2877 nal->raw_data = src;
2882 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2884 int i, consumed, ret = 0;
2887 s->last_eos = s->eos;
2890 /* split the input packet into NAL units, so we know the upper bound on the
2891 * number of slices in the frame */
2893 while (length >= 4) {
2895 int extract_length = 0;
2899 for (i = 0; i < s->nal_length_size; i++)
2900 extract_length = (extract_length << 8) | buf[i];
2901 buf += s->nal_length_size;
2902 length -= s->nal_length_size;
2904 if (extract_length > length) {
2905 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit size.\n");
2906 ret = AVERROR_INVALIDDATA;
2910 /* search start code */
2911 while (buf[0] != 0 || buf[1] != 0 || buf[2] != 1) {
2915 av_log(s->avctx, AV_LOG_ERROR, "No start code is found.\n");
2916 ret = AVERROR_INVALIDDATA;
2926 extract_length = length;
2928 if (s->nals_allocated < s->nb_nals + 1) {
2929 int new_size = s->nals_allocated + 1;
2930 void *tmp = av_realloc_array(s->nals, new_size, sizeof(*s->nals));
2931 ret = AVERROR(ENOMEM);
2936 memset(s->nals + s->nals_allocated, 0,
2937 (new_size - s->nals_allocated) * sizeof(*s->nals));
2939 tmp = av_realloc_array(s->skipped_bytes_nal, new_size, sizeof(*s->skipped_bytes_nal));
2942 s->skipped_bytes_nal = tmp;
2944 tmp = av_realloc_array(s->skipped_bytes_pos_size_nal, new_size, sizeof(*s->skipped_bytes_pos_size_nal));
2947 s->skipped_bytes_pos_size_nal = tmp;
2949 tmp = av_realloc_array(s->skipped_bytes_pos_nal, new_size, sizeof(*s->skipped_bytes_pos_nal));
2952 s->skipped_bytes_pos_nal = tmp;
2954 s->skipped_bytes_pos_size_nal[s->nals_allocated] = 1024; // initial buffer size
2955 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));
2956 if (!s->skipped_bytes_pos_nal[s->nals_allocated])
2958 s->nals_allocated = new_size;
2960 s->skipped_bytes_pos_size = s->skipped_bytes_pos_size_nal[s->nb_nals];
2961 s->skipped_bytes_pos = s->skipped_bytes_pos_nal[s->nb_nals];
2962 nal = &s->nals[s->nb_nals];
2964 consumed = ff_hevc_extract_rbsp(s, buf, extract_length, nal);
2966 s->skipped_bytes_nal[s->nb_nals] = s->skipped_bytes;
2967 s->skipped_bytes_pos_size_nal[s->nb_nals] = s->skipped_bytes_pos_size;
2968 s->skipped_bytes_pos_nal[s->nb_nals++] = s->skipped_bytes_pos;
2976 ret = init_get_bits8(&s->HEVClc->gb, nal->data, nal->size);
2981 if (s->nal_unit_type == NAL_EOB_NUT ||
2982 s->nal_unit_type == NAL_EOS_NUT)
2989 /* parse the NAL units */
2990 for (i = 0; i < s->nb_nals; i++) {
2992 s->skipped_bytes = s->skipped_bytes_nal[i];
2993 s->skipped_bytes_pos = s->skipped_bytes_pos_nal[i];
2995 ret = decode_nal_unit(s, &s->nals[i]);
2997 av_log(s->avctx, AV_LOG_WARNING,
2998 "Error parsing NAL unit #%d.\n", i);
3004 if (s->ref && s->threads_type == FF_THREAD_FRAME)
3005 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
3010 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
3013 for (i = 0; i < 16; i++)
3014 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
3017 static int verify_md5(HEVCContext *s, AVFrame *frame)
3019 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
3024 return AVERROR(EINVAL);
3026 pixel_shift = desc->comp[0].depth_minus1 > 7;
3028 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
3031 /* the checksums are LE, so we have to byteswap for >8bpp formats
3034 if (pixel_shift && !s->checksum_buf) {
3035 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
3036 FFMAX3(frame->linesize[0], frame->linesize[1],
3037 frame->linesize[2]));
3038 if (!s->checksum_buf)
3039 return AVERROR(ENOMEM);
3043 for (i = 0; frame->data[i]; i++) {
3044 int width = s->avctx->coded_width;
3045 int height = s->avctx->coded_height;
3046 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
3047 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
3050 av_md5_init(s->md5_ctx);
3051 for (j = 0; j < h; j++) {
3052 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
3055 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
3056 (const uint16_t *) src, w);
3057 src = s->checksum_buf;
3060 av_md5_update(s->md5_ctx, src, w << pixel_shift);
3062 av_md5_final(s->md5_ctx, md5);
3064 if (!memcmp(md5, s->md5[i], 16)) {
3065 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
3066 print_md5(s->avctx, AV_LOG_DEBUG, md5);
3067 av_log (s->avctx, AV_LOG_DEBUG, "; ");
3069 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
3070 print_md5(s->avctx, AV_LOG_ERROR, md5);
3071 av_log (s->avctx, AV_LOG_ERROR, " != ");
3072 print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
3073 av_log (s->avctx, AV_LOG_ERROR, "\n");
3074 return AVERROR_INVALIDDATA;
3078 av_log(s->avctx, AV_LOG_DEBUG, "\n");
3083 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
3087 HEVCContext *s = avctx->priv_data;
3090 ret = ff_hevc_output_frame(s, data, 1);
3099 ret = decode_nal_units(s, avpkt->data, avpkt->size);
3103 if (avctx->hwaccel) {
3104 if (s->ref && avctx->hwaccel->end_frame(avctx) < 0)
3105 av_log(avctx, AV_LOG_ERROR,
3106 "hardware accelerator failed to decode picture\n");
3108 /* verify the SEI checksum */
3109 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
3111 ret = verify_md5(s, s->ref->frame);
3112 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
3113 ff_hevc_unref_frame(s, s->ref, ~0);
3120 if (s->is_decoded) {
3121 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
3125 if (s->output_frame->buf[0]) {
3126 av_frame_move_ref(data, s->output_frame);
3133 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
3137 ret = ff_thread_ref_frame(&dst->tf, &src->tf);
3141 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
3142 if (!dst->tab_mvf_buf)
3144 dst->tab_mvf = src->tab_mvf;
3146 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
3147 if (!dst->rpl_tab_buf)
3149 dst->rpl_tab = src->rpl_tab;
3151 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
3155 dst->poc = src->poc;
3156 dst->ctb_count = src->ctb_count;
3157 dst->window = src->window;
3158 dst->flags = src->flags;
3159 dst->sequence = src->sequence;
3161 if (src->hwaccel_picture_private) {
3162 dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
3163 if (!dst->hwaccel_priv_buf)
3165 dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
3170 ff_hevc_unref_frame(s, dst, ~0);
3171 return AVERROR(ENOMEM);
3174 static av_cold int hevc_decode_free(AVCodecContext *avctx)
3176 HEVCContext *s = avctx->priv_data;
3181 av_freep(&s->md5_ctx);
3183 for(i=0; i < s->nals_allocated; i++) {
3184 av_freep(&s->skipped_bytes_pos_nal[i]);
3186 av_freep(&s->skipped_bytes_pos_size_nal);
3187 av_freep(&s->skipped_bytes_nal);
3188 av_freep(&s->skipped_bytes_pos_nal);
3190 av_freep(&s->cabac_state);
3192 for (i = 0; i < 3; i++) {
3193 av_freep(&s->sao_pixel_buffer_h[i]);
3194 av_freep(&s->sao_pixel_buffer_v[i]);
3196 av_frame_free(&s->output_frame);
3198 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3199 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3200 av_frame_free(&s->DPB[i].frame);
3203 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++)
3204 av_buffer_unref(&s->vps_list[i]);
3205 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++)
3206 av_buffer_unref(&s->sps_list[i]);
3207 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
3208 av_buffer_unref(&s->pps_list[i]);
3213 av_buffer_unref(&s->current_sps);
3215 av_freep(&s->sh.entry_point_offset);
3216 av_freep(&s->sh.offset);
3217 av_freep(&s->sh.size);
3219 for (i = 1; i < s->threads_number; i++) {
3220 HEVCLocalContext *lc = s->HEVClcList[i];
3222 av_freep(&s->HEVClcList[i]);
3223 av_freep(&s->sList[i]);
3226 if (s->HEVClc == s->HEVClcList[0])
3228 av_freep(&s->HEVClcList[0]);
3230 for (i = 0; i < s->nals_allocated; i++)
3231 av_freep(&s->nals[i].rbsp_buffer);
3233 s->nals_allocated = 0;
3238 static av_cold int hevc_init_context(AVCodecContext *avctx)
3240 HEVCContext *s = avctx->priv_data;
3245 s->HEVClc = av_mallocz(sizeof(HEVCLocalContext));
3248 s->HEVClcList[0] = s->HEVClc;
3251 s->cabac_state = av_malloc(HEVC_CONTEXTS);
3252 if (!s->cabac_state)
3255 s->output_frame = av_frame_alloc();
3256 if (!s->output_frame)
3259 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3260 s->DPB[i].frame = av_frame_alloc();
3261 if (!s->DPB[i].frame)
3263 s->DPB[i].tf.f = s->DPB[i].frame;
3266 s->max_ra = INT_MAX;
3268 s->md5_ctx = av_md5_alloc();
3272 ff_bswapdsp_init(&s->bdsp);
3274 s->context_initialized = 1;
3280 hevc_decode_free(avctx);
3281 return AVERROR(ENOMEM);
3284 static int hevc_update_thread_context(AVCodecContext *dst,
3285 const AVCodecContext *src)
3287 HEVCContext *s = dst->priv_data;
3288 HEVCContext *s0 = src->priv_data;
3291 if (!s->context_initialized) {
3292 ret = hevc_init_context(dst);
3297 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3298 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3299 if (s0->DPB[i].frame->buf[0]) {
3300 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3306 if (s->sps != s0->sps)
3308 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++) {
3309 av_buffer_unref(&s->vps_list[i]);
3310 if (s0->vps_list[i]) {
3311 s->vps_list[i] = av_buffer_ref(s0->vps_list[i]);
3312 if (!s->vps_list[i])
3313 return AVERROR(ENOMEM);
3317 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++) {
3318 av_buffer_unref(&s->sps_list[i]);
3319 if (s0->sps_list[i]) {
3320 s->sps_list[i] = av_buffer_ref(s0->sps_list[i]);
3321 if (!s->sps_list[i])
3322 return AVERROR(ENOMEM);
3326 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++) {
3327 av_buffer_unref(&s->pps_list[i]);
3328 if (s0->pps_list[i]) {
3329 s->pps_list[i] = av_buffer_ref(s0->pps_list[i]);
3330 if (!s->pps_list[i])
3331 return AVERROR(ENOMEM);
3335 av_buffer_unref(&s->current_sps);
3336 if (s0->current_sps) {
3337 s->current_sps = av_buffer_ref(s0->current_sps);
3338 if (!s->current_sps)
3339 return AVERROR(ENOMEM);
3342 if (s->sps != s0->sps)
3343 if ((ret = set_sps(s, s0->sps, src->pix_fmt)) < 0)
3346 s->seq_decode = s0->seq_decode;
3347 s->seq_output = s0->seq_output;
3348 s->pocTid0 = s0->pocTid0;
3349 s->max_ra = s0->max_ra;
3352 s->is_nalff = s0->is_nalff;
3353 s->nal_length_size = s0->nal_length_size;
3355 s->threads_number = s0->threads_number;
3356 s->threads_type = s0->threads_type;
3359 s->seq_decode = (s->seq_decode + 1) & 0xff;
3360 s->max_ra = INT_MAX;
3366 static int hevc_decode_extradata(HEVCContext *s)
3368 AVCodecContext *avctx = s->avctx;
3372 bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
3374 if (avctx->extradata_size > 3 &&
3375 (avctx->extradata[0] || avctx->extradata[1] ||
3376 avctx->extradata[2] > 1)) {
3377 /* It seems the extradata is encoded as hvcC format.
3378 * Temporarily, we support configurationVersion==0 until 14496-15 3rd
3379 * is finalized. When finalized, configurationVersion will be 1 and we
3380 * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
3381 int i, j, num_arrays, nal_len_size;
3385 bytestream2_skip(&gb, 21);
3386 nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
3387 num_arrays = bytestream2_get_byte(&gb);
3389 /* nal units in the hvcC always have length coded with 2 bytes,
3390 * so put a fake nal_length_size = 2 while parsing them */
3391 s->nal_length_size = 2;
3393 /* Decode nal units from hvcC. */
3394 for (i = 0; i < num_arrays; i++) {
3395 int type = bytestream2_get_byte(&gb) & 0x3f;
3396 int cnt = bytestream2_get_be16(&gb);
3398 for (j = 0; j < cnt; j++) {
3399 // +2 for the nal size field
3400 int nalsize = bytestream2_peek_be16(&gb) + 2;
3401 if (bytestream2_get_bytes_left(&gb) < nalsize) {
3402 av_log(s->avctx, AV_LOG_ERROR,
3403 "Invalid NAL unit size in extradata.\n");
3404 return AVERROR_INVALIDDATA;
3407 ret = decode_nal_units(s, gb.buffer, nalsize);
3409 av_log(avctx, AV_LOG_ERROR,
3410 "Decoding nal unit %d %d from hvcC failed\n",
3414 bytestream2_skip(&gb, nalsize);
3418 /* Now store right nal length size, that will be used to parse
3420 s->nal_length_size = nal_len_size;
3423 ret = decode_nal_units(s, avctx->extradata, avctx->extradata_size);
3430 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3432 HEVCContext *s = avctx->priv_data;
3435 ff_init_cabac_states();
3437 avctx->internal->allocate_progress = 1;
3439 ret = hevc_init_context(avctx);
3443 s->enable_parallel_tiles = 0;
3444 s->picture_struct = 0;
3446 if(avctx->active_thread_type & FF_THREAD_SLICE)
3447 s->threads_number = avctx->thread_count;
3449 s->threads_number = 1;
3451 if (avctx->extradata_size > 0 && avctx->extradata) {
3452 ret = hevc_decode_extradata(s);
3454 hevc_decode_free(avctx);
3459 if((avctx->active_thread_type & FF_THREAD_FRAME) && avctx->thread_count > 1)
3460 s->threads_type = FF_THREAD_FRAME;
3462 s->threads_type = FF_THREAD_SLICE;
3467 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3469 HEVCContext *s = avctx->priv_data;
3472 memset(s, 0, sizeof(*s));
3474 ret = hevc_init_context(avctx);
3481 static void hevc_decode_flush(AVCodecContext *avctx)
3483 HEVCContext *s = avctx->priv_data;
3484 ff_hevc_flush_dpb(s);
3485 s->max_ra = INT_MAX;
3488 #define OFFSET(x) offsetof(HEVCContext, x)
3489 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3491 static const AVProfile profiles[] = {
3492 { FF_PROFILE_HEVC_MAIN, "Main" },
3493 { FF_PROFILE_HEVC_MAIN_10, "Main 10" },
3494 { FF_PROFILE_HEVC_MAIN_STILL_PICTURE, "Main Still Picture" },
3495 { FF_PROFILE_HEVC_REXT, "Rext" },
3496 { FF_PROFILE_UNKNOWN },
3499 static const AVOption options[] = {
3500 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3501 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3502 { "strict-displaywin", "stricly apply default display window size", OFFSET(apply_defdispwin),
3503 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3507 static const AVClass hevc_decoder_class = {
3508 .class_name = "HEVC decoder",
3509 .item_name = av_default_item_name,
3511 .version = LIBAVUTIL_VERSION_INT,
3514 AVCodec ff_hevc_decoder = {
3516 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3517 .type = AVMEDIA_TYPE_VIDEO,
3518 .id = AV_CODEC_ID_HEVC,
3519 .priv_data_size = sizeof(HEVCContext),
3520 .priv_class = &hevc_decoder_class,
3521 .init = hevc_decode_init,
3522 .close = hevc_decode_free,
3523 .decode = hevc_decode_frame,
3524 .flush = hevc_decode_flush,
3525 .update_thread_context = hevc_update_thread_context,
3526 .init_thread_copy = hevc_init_thread_copy,
3527 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY |
3528 CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS,
3529 .profiles = NULL_IF_CONFIG_SMALL(profiles),