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 Libav.
11 * Libav 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 * Libav 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 Libav; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavutil/attributes.h"
27 #include "libavutil/common.h"
28 #include "libavutil/display.h"
29 #include "libavutil/internal.h"
30 #include "libavutil/md5.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/pixdesc.h"
33 #include "libavutil/stereo3d.h"
36 #include "bytestream.h"
37 #include "cabac_functions.h"
40 #include "hevc_data.h"
44 const uint8_t ff_hevc_qpel_extra_before[4] = { 0, 3, 3, 3 };
45 const uint8_t ff_hevc_qpel_extra_after[4] = { 0, 4, 4, 4 };
46 const uint8_t ff_hevc_qpel_extra[4] = { 0, 7, 7, 7 };
48 static const uint8_t scan_1x1[1] = { 0 };
50 static const uint8_t horiz_scan2x2_x[4] = { 0, 1, 0, 1 };
52 static const uint8_t horiz_scan2x2_y[4] = { 0, 0, 1, 1 };
54 static const uint8_t horiz_scan4x4_x[16] = {
61 static const uint8_t horiz_scan4x4_y[16] = {
68 static const uint8_t horiz_scan8x8_inv[8][8] = {
69 { 0, 1, 2, 3, 16, 17, 18, 19, },
70 { 4, 5, 6, 7, 20, 21, 22, 23, },
71 { 8, 9, 10, 11, 24, 25, 26, 27, },
72 { 12, 13, 14, 15, 28, 29, 30, 31, },
73 { 32, 33, 34, 35, 48, 49, 50, 51, },
74 { 36, 37, 38, 39, 52, 53, 54, 55, },
75 { 40, 41, 42, 43, 56, 57, 58, 59, },
76 { 44, 45, 46, 47, 60, 61, 62, 63, },
79 static const uint8_t diag_scan2x2_x[4] = { 0, 0, 1, 1 };
81 static const uint8_t diag_scan2x2_y[4] = { 0, 1, 0, 1 };
83 static const uint8_t diag_scan2x2_inv[2][2] = {
88 static const uint8_t diag_scan4x4_inv[4][4] = {
95 static const uint8_t diag_scan8x8_inv[8][8] = {
96 { 0, 2, 5, 9, 14, 20, 27, 35, },
97 { 1, 4, 8, 13, 19, 26, 34, 42, },
98 { 3, 7, 12, 18, 25, 33, 41, 48, },
99 { 6, 11, 17, 24, 32, 40, 47, 53, },
100 { 10, 16, 23, 31, 39, 46, 52, 57, },
101 { 15, 22, 30, 38, 45, 51, 56, 60, },
102 { 21, 29, 37, 44, 50, 55, 59, 62, },
103 { 28, 36, 43, 49, 54, 58, 61, 63, },
107 * NOTE: Each function hls_foo correspond to the function foo in the
108 * specification (HLS stands for High Level Syntax).
115 /* free everything allocated by pic_arrays_init() */
116 static void pic_arrays_free(HEVCContext *s)
119 av_freep(&s->deblock);
121 av_freep(&s->skip_flag);
122 av_freep(&s->tab_ct_depth);
124 av_freep(&s->tab_ipm);
125 av_freep(&s->cbf_luma);
126 av_freep(&s->is_pcm);
128 av_freep(&s->qp_y_tab);
129 av_freep(&s->tab_slice_address);
130 av_freep(&s->filter_slice_edges);
132 av_freep(&s->horizontal_bs);
133 av_freep(&s->vertical_bs);
135 av_buffer_pool_uninit(&s->tab_mvf_pool);
136 av_buffer_pool_uninit(&s->rpl_tab_pool);
139 /* allocate arrays that depend on frame dimensions */
140 static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
142 int log2_min_cb_size = sps->log2_min_cb_size;
143 int width = sps->width;
144 int height = sps->height;
145 int pic_size_in_ctb = ((width >> log2_min_cb_size) + 1) *
146 ((height >> log2_min_cb_size) + 1);
147 int ctb_count = sps->ctb_width * sps->ctb_height;
148 int min_pu_size = sps->min_pu_width * sps->min_pu_height;
150 s->bs_width = width >> 3;
151 s->bs_height = height >> 3;
153 s->sao = av_mallocz_array(ctb_count, sizeof(*s->sao));
154 s->deblock = av_mallocz_array(ctb_count, sizeof(*s->deblock));
155 if (!s->sao || !s->deblock)
158 s->skip_flag = av_malloc(pic_size_in_ctb);
159 s->tab_ct_depth = av_malloc(sps->min_cb_height * sps->min_cb_width);
160 if (!s->skip_flag || !s->tab_ct_depth)
163 s->cbf_luma = av_malloc(sps->min_tb_width * sps->min_tb_height);
164 s->tab_ipm = av_mallocz(min_pu_size);
165 s->is_pcm = av_malloc(min_pu_size);
166 if (!s->tab_ipm || !s->cbf_luma || !s->is_pcm)
169 s->filter_slice_edges = av_malloc(ctb_count);
170 s->tab_slice_address = av_malloc(pic_size_in_ctb *
171 sizeof(*s->tab_slice_address));
172 s->qp_y_tab = av_malloc(pic_size_in_ctb *
173 sizeof(*s->qp_y_tab));
174 if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address)
177 s->horizontal_bs = av_mallocz(2 * s->bs_width * (s->bs_height + 1));
178 s->vertical_bs = av_mallocz(2 * s->bs_width * (s->bs_height + 1));
179 if (!s->horizontal_bs || !s->vertical_bs)
182 s->tab_mvf_pool = av_buffer_pool_init(min_pu_size * sizeof(MvField),
184 s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab),
186 if (!s->tab_mvf_pool || !s->rpl_tab_pool)
193 return AVERROR(ENOMEM);
196 static void pred_weight_table(HEVCContext *s, GetBitContext *gb)
200 uint8_t luma_weight_l0_flag[16];
201 uint8_t chroma_weight_l0_flag[16];
202 uint8_t luma_weight_l1_flag[16];
203 uint8_t chroma_weight_l1_flag[16];
205 s->sh.luma_log2_weight_denom = av_clip(get_ue_golomb_long(gb), 0, 7);
206 if (s->ps.sps->chroma_format_idc != 0) {
207 int delta = get_se_golomb(gb);
208 s->sh.chroma_log2_weight_denom = av_clip(s->sh.luma_log2_weight_denom + delta, 0, 7);
211 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
212 luma_weight_l0_flag[i] = get_bits1(gb);
213 if (!luma_weight_l0_flag[i]) {
214 s->sh.luma_weight_l0[i] = 1 << s->sh.luma_log2_weight_denom;
215 s->sh.luma_offset_l0[i] = 0;
218 if (s->ps.sps->chroma_format_idc != 0) { // FIXME: invert "if" and "for"
219 for (i = 0; i < s->sh.nb_refs[L0]; i++)
220 chroma_weight_l0_flag[i] = get_bits1(gb);
222 for (i = 0; i < s->sh.nb_refs[L0]; i++)
223 chroma_weight_l0_flag[i] = 0;
225 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
226 if (luma_weight_l0_flag[i]) {
227 int delta_luma_weight_l0 = get_se_golomb(gb);
228 s->sh.luma_weight_l0[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;
229 s->sh.luma_offset_l0[i] = get_se_golomb(gb);
231 if (chroma_weight_l0_flag[i]) {
232 for (j = 0; j < 2; j++) {
233 int delta_chroma_weight_l0 = get_se_golomb(gb);
234 int delta_chroma_offset_l0 = get_se_golomb(gb);
235 s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
236 s->sh.chroma_offset_l0[i][j] = av_clip((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j])
237 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
240 s->sh.chroma_weight_l0[i][0] = 1 << s->sh.chroma_log2_weight_denom;
241 s->sh.chroma_offset_l0[i][0] = 0;
242 s->sh.chroma_weight_l0[i][1] = 1 << s->sh.chroma_log2_weight_denom;
243 s->sh.chroma_offset_l0[i][1] = 0;
246 if (s->sh.slice_type == HEVC_SLICE_B) {
247 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
248 luma_weight_l1_flag[i] = get_bits1(gb);
249 if (!luma_weight_l1_flag[i]) {
250 s->sh.luma_weight_l1[i] = 1 << s->sh.luma_log2_weight_denom;
251 s->sh.luma_offset_l1[i] = 0;
254 if (s->ps.sps->chroma_format_idc != 0) {
255 for (i = 0; i < s->sh.nb_refs[L1]; i++)
256 chroma_weight_l1_flag[i] = get_bits1(gb);
258 for (i = 0; i < s->sh.nb_refs[L1]; i++)
259 chroma_weight_l1_flag[i] = 0;
261 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
262 if (luma_weight_l1_flag[i]) {
263 int delta_luma_weight_l1 = get_se_golomb(gb);
264 s->sh.luma_weight_l1[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;
265 s->sh.luma_offset_l1[i] = get_se_golomb(gb);
267 if (chroma_weight_l1_flag[i]) {
268 for (j = 0; j < 2; j++) {
269 int delta_chroma_weight_l1 = get_se_golomb(gb);
270 int delta_chroma_offset_l1 = get_se_golomb(gb);
271 s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
272 s->sh.chroma_offset_l1[i][j] = av_clip((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j])
273 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
276 s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom;
277 s->sh.chroma_offset_l1[i][0] = 0;
278 s->sh.chroma_weight_l1[i][1] = 1 << s->sh.chroma_log2_weight_denom;
279 s->sh.chroma_offset_l1[i][1] = 0;
285 static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
287 const HEVCSPS *sps = s->ps.sps;
288 int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
289 int prev_delta_msb = 0;
290 unsigned int nb_sps = 0, nb_sh;
294 if (!sps->long_term_ref_pics_present_flag)
297 if (sps->num_long_term_ref_pics_sps > 0)
298 nb_sps = get_ue_golomb_long(gb);
299 nb_sh = get_ue_golomb_long(gb);
301 if (nb_sh + nb_sps > FF_ARRAY_ELEMS(rps->poc))
302 return AVERROR_INVALIDDATA;
304 rps->nb_refs = nb_sh + nb_sps;
306 for (i = 0; i < rps->nb_refs; i++) {
307 uint8_t delta_poc_msb_present;
310 uint8_t lt_idx_sps = 0;
312 if (sps->num_long_term_ref_pics_sps > 1)
313 lt_idx_sps = get_bits(gb, av_ceil_log2(sps->num_long_term_ref_pics_sps));
315 rps->poc[i] = sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
316 rps->used[i] = sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];
318 rps->poc[i] = get_bits(gb, sps->log2_max_poc_lsb);
319 rps->used[i] = get_bits1(gb);
322 delta_poc_msb_present = get_bits1(gb);
323 if (delta_poc_msb_present) {
324 int delta = get_ue_golomb_long(gb);
326 if (i && i != nb_sps)
327 delta += prev_delta_msb;
329 rps->poc[i] += s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
330 prev_delta_msb = delta;
337 static void export_stream_params(AVCodecContext *avctx, const HEVCParamSets *ps,
340 const HEVCVPS *vps = (const HEVCVPS*)ps->vps_list[sps->vps_id]->data;
341 unsigned int num = 0, den = 0;
343 avctx->pix_fmt = sps->pix_fmt;
344 avctx->coded_width = sps->width;
345 avctx->coded_height = sps->height;
346 avctx->width = sps->output_width;
347 avctx->height = sps->output_height;
348 avctx->has_b_frames = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics;
349 avctx->profile = sps->ptl.general_ptl.profile_idc;
350 avctx->level = sps->ptl.general_ptl.level_idc;
352 ff_set_sar(avctx, sps->vui.sar);
354 if (sps->vui.video_signal_type_present_flag)
355 avctx->color_range = sps->vui.video_full_range_flag ? AVCOL_RANGE_JPEG
358 avctx->color_range = AVCOL_RANGE_MPEG;
360 if (sps->vui.colour_description_present_flag) {
361 avctx->color_primaries = sps->vui.colour_primaries;
362 avctx->color_trc = sps->vui.transfer_characteristic;
363 avctx->colorspace = sps->vui.matrix_coeffs;
365 avctx->color_primaries = AVCOL_PRI_UNSPECIFIED;
366 avctx->color_trc = AVCOL_TRC_UNSPECIFIED;
367 avctx->colorspace = AVCOL_SPC_UNSPECIFIED;
370 if (vps->vps_timing_info_present_flag) {
371 num = vps->vps_num_units_in_tick;
372 den = vps->vps_time_scale;
373 } else if (sps->vui.vui_timing_info_present_flag) {
374 num = sps->vui.vui_num_units_in_tick;
375 den = sps->vui.vui_time_scale;
378 if (num != 0 && den != 0)
379 av_reduce(&avctx->framerate.den, &avctx->framerate.num,
383 static int set_sps(HEVCContext *s, const HEVCSPS *sps)
385 #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + CONFIG_HEVC_D3D11VA_HWACCEL + CONFIG_HEVC_VDPAU_HWACCEL)
386 enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
396 ret = pic_arrays_init(s, sps);
400 export_stream_params(s->avctx, &s->ps, sps);
402 if (sps->pix_fmt == AV_PIX_FMT_YUV420P || sps->pix_fmt == AV_PIX_FMT_YUVJ420P ||
403 sps->pix_fmt == AV_PIX_FMT_YUV420P10) {
404 #if CONFIG_HEVC_DXVA2_HWACCEL
405 *fmt++ = AV_PIX_FMT_DXVA2_VLD;
408 if (sps->pix_fmt == AV_PIX_FMT_YUV420P || sps->pix_fmt == AV_PIX_FMT_YUVJ420P) {
409 #if CONFIG_HEVC_D3D11VA_HWACCEL
410 *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
412 #if CONFIG_HEVC_VDPAU_HWACCEL
413 *fmt++ = AV_PIX_FMT_VDPAU;
417 *fmt++ = sps->pix_fmt;
418 *fmt = AV_PIX_FMT_NONE;
420 ret = ff_get_format(s->avctx, pix_fmts);
423 s->avctx->pix_fmt = ret;
425 ff_hevc_pred_init(&s->hpc, sps->bit_depth);
426 ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
427 ff_videodsp_init (&s->vdsp, sps->bit_depth);
429 if (sps->sao_enabled && !s->avctx->hwaccel) {
430 av_frame_unref(s->tmp_frame);
431 ret = ff_get_buffer(s->avctx, s->tmp_frame, AV_GET_BUFFER_FLAG_REF);
434 s->frame = s->tmp_frame;
438 s->ps.vps = (HEVCVPS*) s->ps.vps_list[s->ps.sps->vps_id]->data;
448 static int hls_slice_header(HEVCContext *s)
450 GetBitContext *gb = &s->HEVClc.gb;
451 SliceHeader *sh = &s->sh;
455 sh->first_slice_in_pic_flag = get_bits1(gb);
456 if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
457 s->seq_decode = (s->seq_decode + 1) & 0xff;
460 ff_hevc_clear_refs(s);
463 sh->no_output_of_prior_pics_flag = get_bits1(gb);
465 sh->pps_id = get_ue_golomb_long(gb);
466 if (sh->pps_id >= HEVC_MAX_PPS_COUNT || !s->ps.pps_list[sh->pps_id]) {
467 av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
468 return AVERROR_INVALIDDATA;
470 if (!sh->first_slice_in_pic_flag &&
471 s->ps.pps != (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data) {
472 av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
473 return AVERROR_INVALIDDATA;
475 s->ps.pps = (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data;
477 if (s->ps.sps != (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data) {
478 s->ps.sps = (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data;
480 ff_hevc_clear_refs(s);
481 ret = set_sps(s, s->ps.sps);
485 s->seq_decode = (s->seq_decode + 1) & 0xff;
489 sh->dependent_slice_segment_flag = 0;
490 if (!sh->first_slice_in_pic_flag) {
491 int slice_address_length;
493 if (s->ps.pps->dependent_slice_segments_enabled_flag)
494 sh->dependent_slice_segment_flag = get_bits1(gb);
496 slice_address_length = av_ceil_log2(s->ps.sps->ctb_width *
497 s->ps.sps->ctb_height);
498 sh->slice_segment_addr = slice_address_length ? get_bits(gb, slice_address_length) : 0;
499 if (sh->slice_segment_addr >= s->ps.sps->ctb_width * s->ps.sps->ctb_height) {
500 av_log(s->avctx, AV_LOG_ERROR,
501 "Invalid slice segment address: %u.\n",
502 sh->slice_segment_addr);
503 return AVERROR_INVALIDDATA;
506 if (!sh->dependent_slice_segment_flag) {
507 sh->slice_addr = sh->slice_segment_addr;
511 sh->slice_segment_addr = sh->slice_addr = 0;
513 s->slice_initialized = 0;
516 if (!sh->dependent_slice_segment_flag) {
517 s->slice_initialized = 0;
519 for (i = 0; i < s->ps.pps->num_extra_slice_header_bits; i++)
520 skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
522 sh->slice_type = get_ue_golomb_long(gb);
523 if (!(sh->slice_type == HEVC_SLICE_I ||
524 sh->slice_type == HEVC_SLICE_P ||
525 sh->slice_type == HEVC_SLICE_B)) {
526 av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
528 return AVERROR_INVALIDDATA;
530 if (IS_IRAP(s) && sh->slice_type != HEVC_SLICE_I) {
531 av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
532 return AVERROR_INVALIDDATA;
535 // when flag is not present, picture is inferred to be output
536 sh->pic_output_flag = 1;
537 if (s->ps.pps->output_flag_present_flag)
538 sh->pic_output_flag = get_bits1(gb);
540 if (s->ps.sps->separate_colour_plane_flag)
541 sh->colour_plane_id = get_bits(gb, 2);
546 sh->pic_order_cnt_lsb = get_bits(gb, s->ps.sps->log2_max_poc_lsb);
547 poc = ff_hevc_compute_poc(s, sh->pic_order_cnt_lsb);
548 if (!sh->first_slice_in_pic_flag && poc != s->poc) {
549 av_log(s->avctx, AV_LOG_WARNING,
550 "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
551 if (s->avctx->err_recognition & AV_EF_EXPLODE)
552 return AVERROR_INVALIDDATA;
557 sh->short_term_ref_pic_set_sps_flag = get_bits1(gb);
558 pos = get_bits_left(gb);
559 if (!sh->short_term_ref_pic_set_sps_flag) {
560 ret = ff_hevc_decode_short_term_rps(gb, s->avctx, &sh->slice_rps, s->ps.sps, 1);
564 sh->short_term_rps = &sh->slice_rps;
566 int numbits, rps_idx;
568 if (!s->ps.sps->nb_st_rps) {
569 av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
570 return AVERROR_INVALIDDATA;
573 numbits = av_ceil_log2(s->ps.sps->nb_st_rps);
574 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
575 sh->short_term_rps = &s->ps.sps->st_rps[rps_idx];
577 sh->short_term_ref_pic_set_size = pos - get_bits_left(gb);
579 pos = get_bits_left(gb);
580 ret = decode_lt_rps(s, &sh->long_term_rps, gb);
582 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
583 if (s->avctx->err_recognition & AV_EF_EXPLODE)
584 return AVERROR_INVALIDDATA;
586 sh->long_term_ref_pic_set_size = pos - get_bits_left(gb);
588 if (s->ps.sps->sps_temporal_mvp_enabled_flag)
589 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
591 sh->slice_temporal_mvp_enabled_flag = 0;
593 s->sh.short_term_rps = NULL;
598 if (s->temporal_id == 0 &&
599 s->nal_unit_type != HEVC_NAL_TRAIL_N &&
600 s->nal_unit_type != HEVC_NAL_TSA_N &&
601 s->nal_unit_type != HEVC_NAL_STSA_N &&
602 s->nal_unit_type != HEVC_NAL_RADL_N &&
603 s->nal_unit_type != HEVC_NAL_RADL_R &&
604 s->nal_unit_type != HEVC_NAL_RASL_N &&
605 s->nal_unit_type != HEVC_NAL_RASL_R)
608 if (s->ps.sps->sao_enabled) {
609 sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
610 sh->slice_sample_adaptive_offset_flag[1] =
611 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
613 sh->slice_sample_adaptive_offset_flag[0] = 0;
614 sh->slice_sample_adaptive_offset_flag[1] = 0;
615 sh->slice_sample_adaptive_offset_flag[2] = 0;
618 sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
619 if (sh->slice_type == HEVC_SLICE_P || sh->slice_type == HEVC_SLICE_B) {
622 sh->nb_refs[L0] = s->ps.pps->num_ref_idx_l0_default_active;
623 if (sh->slice_type == HEVC_SLICE_B)
624 sh->nb_refs[L1] = s->ps.pps->num_ref_idx_l1_default_active;
626 if (get_bits1(gb)) { // num_ref_idx_active_override_flag
627 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
628 if (sh->slice_type == HEVC_SLICE_B)
629 sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
631 if (sh->nb_refs[L0] > HEVC_MAX_REFS || sh->nb_refs[L1] > HEVC_MAX_REFS) {
632 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
633 sh->nb_refs[L0], sh->nb_refs[L1]);
634 return AVERROR_INVALIDDATA;
637 sh->rpl_modification_flag[0] = 0;
638 sh->rpl_modification_flag[1] = 0;
639 nb_refs = ff_hevc_frame_nb_refs(s);
641 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
642 return AVERROR_INVALIDDATA;
645 if (s->ps.pps->lists_modification_present_flag && nb_refs > 1) {
646 sh->rpl_modification_flag[0] = get_bits1(gb);
647 if (sh->rpl_modification_flag[0]) {
648 for (i = 0; i < sh->nb_refs[L0]; i++)
649 sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
652 if (sh->slice_type == HEVC_SLICE_B) {
653 sh->rpl_modification_flag[1] = get_bits1(gb);
654 if (sh->rpl_modification_flag[1] == 1)
655 for (i = 0; i < sh->nb_refs[L1]; i++)
656 sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
660 if (sh->slice_type == HEVC_SLICE_B)
661 sh->mvd_l1_zero_flag = get_bits1(gb);
663 if (s->ps.pps->cabac_init_present_flag)
664 sh->cabac_init_flag = get_bits1(gb);
666 sh->cabac_init_flag = 0;
668 sh->collocated_ref_idx = 0;
669 if (sh->slice_temporal_mvp_enabled_flag) {
670 sh->collocated_list = L0;
671 if (sh->slice_type == HEVC_SLICE_B)
672 sh->collocated_list = !get_bits1(gb);
674 if (sh->nb_refs[sh->collocated_list] > 1) {
675 sh->collocated_ref_idx = get_ue_golomb_long(gb);
676 if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
677 av_log(s->avctx, AV_LOG_ERROR,
678 "Invalid collocated_ref_idx: %d.\n",
679 sh->collocated_ref_idx);
680 return AVERROR_INVALIDDATA;
685 if ((s->ps.pps->weighted_pred_flag && sh->slice_type == HEVC_SLICE_P) ||
686 (s->ps.pps->weighted_bipred_flag && sh->slice_type == HEVC_SLICE_B)) {
687 pred_weight_table(s, gb);
690 sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
691 if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
692 av_log(s->avctx, AV_LOG_ERROR,
693 "Invalid number of merging MVP candidates: %d.\n",
694 sh->max_num_merge_cand);
695 return AVERROR_INVALIDDATA;
699 sh->slice_qp_delta = get_se_golomb(gb);
701 if (s->ps.pps->pic_slice_level_chroma_qp_offsets_present_flag) {
702 sh->slice_cb_qp_offset = get_se_golomb(gb);
703 sh->slice_cr_qp_offset = get_se_golomb(gb);
705 sh->slice_cb_qp_offset = 0;
706 sh->slice_cr_qp_offset = 0;
709 if (s->ps.pps->deblocking_filter_control_present_flag) {
710 int deblocking_filter_override_flag = 0;
712 if (s->ps.pps->deblocking_filter_override_enabled_flag)
713 deblocking_filter_override_flag = get_bits1(gb);
715 if (deblocking_filter_override_flag) {
716 sh->disable_deblocking_filter_flag = get_bits1(gb);
717 if (!sh->disable_deblocking_filter_flag) {
718 sh->beta_offset = get_se_golomb(gb) * 2;
719 sh->tc_offset = get_se_golomb(gb) * 2;
722 sh->disable_deblocking_filter_flag = s->ps.pps->disable_dbf;
723 sh->beta_offset = s->ps.pps->beta_offset;
724 sh->tc_offset = s->ps.pps->tc_offset;
727 sh->disable_deblocking_filter_flag = 0;
732 if (s->ps.pps->seq_loop_filter_across_slices_enabled_flag &&
733 (sh->slice_sample_adaptive_offset_flag[0] ||
734 sh->slice_sample_adaptive_offset_flag[1] ||
735 !sh->disable_deblocking_filter_flag)) {
736 sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
738 sh->slice_loop_filter_across_slices_enabled_flag = s->ps.pps->seq_loop_filter_across_slices_enabled_flag;
740 } else if (!s->slice_initialized) {
741 av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
742 return AVERROR_INVALIDDATA;
745 sh->num_entry_point_offsets = 0;
746 if (s->ps.pps->tiles_enabled_flag || s->ps.pps->entropy_coding_sync_enabled_flag) {
747 sh->num_entry_point_offsets = get_ue_golomb_long(gb);
748 if (sh->num_entry_point_offsets > 0) {
749 int offset_len = get_ue_golomb_long(gb) + 1;
751 for (i = 0; i < sh->num_entry_point_offsets; i++)
752 skip_bits(gb, offset_len);
756 if (s->ps.pps->slice_header_extension_present_flag) {
757 unsigned int length = get_ue_golomb_long(gb);
758 for (i = 0; i < length; i++)
759 skip_bits(gb, 8); // slice_header_extension_data_byte
762 // Inferred parameters
763 sh->slice_qp = 26 + s->ps.pps->pic_init_qp_minus26 + sh->slice_qp_delta;
764 if (sh->slice_qp > 51 ||
765 sh->slice_qp < -s->ps.sps->qp_bd_offset) {
766 av_log(s->avctx, AV_LOG_ERROR,
767 "The slice_qp %d is outside the valid range "
770 -s->ps.sps->qp_bd_offset);
771 return AVERROR_INVALIDDATA;
774 sh->slice_ctb_addr_rs = sh->slice_segment_addr;
776 if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) {
777 av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
778 return AVERROR_INVALIDDATA;
781 s->HEVClc.first_qp_group = !s->sh.dependent_slice_segment_flag;
783 if (!s->ps.pps->cu_qp_delta_enabled_flag)
784 s->HEVClc.qp_y = FFUMOD(s->sh.slice_qp + 52 + 2 * s->ps.sps->qp_bd_offset,
785 52 + s->ps.sps->qp_bd_offset) - s->ps.sps->qp_bd_offset;
787 s->slice_initialized = 1;
792 #define CTB(tab, x, y) ((tab)[(y) * s->ps.sps->ctb_width + (x)])
794 #define SET_SAO(elem, value) \
796 if (!sao_merge_up_flag && !sao_merge_left_flag) \
798 else if (sao_merge_left_flag) \
799 sao->elem = CTB(s->sao, rx-1, ry).elem; \
800 else if (sao_merge_up_flag) \
801 sao->elem = CTB(s->sao, rx, ry-1).elem; \
806 static void hls_sao_param(HEVCContext *s, int rx, int ry)
808 HEVCLocalContext *lc = &s->HEVClc;
809 int sao_merge_left_flag = 0;
810 int sao_merge_up_flag = 0;
811 int shift = s->ps.sps->bit_depth - FFMIN(s->ps.sps->bit_depth, 10);
812 SAOParams *sao = &CTB(s->sao, rx, ry);
815 if (s->sh.slice_sample_adaptive_offset_flag[0] ||
816 s->sh.slice_sample_adaptive_offset_flag[1]) {
818 if (lc->ctb_left_flag)
819 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
821 if (ry > 0 && !sao_merge_left_flag) {
823 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
827 for (c_idx = 0; c_idx < 3; c_idx++) {
828 if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
829 sao->type_idx[c_idx] = SAO_NOT_APPLIED;
834 sao->type_idx[2] = sao->type_idx[1];
835 sao->eo_class[2] = sao->eo_class[1];
837 SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
840 if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
843 for (i = 0; i < 4; i++)
844 SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
846 if (sao->type_idx[c_idx] == SAO_BAND) {
847 for (i = 0; i < 4; i++) {
848 if (sao->offset_abs[c_idx][i]) {
849 SET_SAO(offset_sign[c_idx][i],
850 ff_hevc_sao_offset_sign_decode(s));
852 sao->offset_sign[c_idx][i] = 0;
855 SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
856 } else if (c_idx != 2) {
857 SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
860 // Inferred parameters
861 sao->offset_val[c_idx][0] = 0;
862 for (i = 0; i < 4; i++) {
863 sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i] << shift;
864 if (sao->type_idx[c_idx] == SAO_EDGE) {
866 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
867 } else if (sao->offset_sign[c_idx][i]) {
868 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
877 static void hls_residual_coding(HEVCContext *s, int x0, int y0,
878 int log2_trafo_size, enum ScanType scan_idx,
881 #define GET_COORD(offset, n) \
883 x_c = (scan_x_cg[offset >> 4] << 2) + scan_x_off[n]; \
884 y_c = (scan_y_cg[offset >> 4] << 2) + scan_y_off[n]; \
886 HEVCLocalContext *lc = &s->HEVClc;
887 int transform_skip_flag = 0;
889 int last_significant_coeff_x, last_significant_coeff_y;
893 int greater1_ctx = 1;
896 int x_cg_last_sig, y_cg_last_sig;
898 const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
900 ptrdiff_t stride = s->frame->linesize[c_idx];
901 int hshift = s->ps.sps->hshift[c_idx];
902 int vshift = s->ps.sps->vshift[c_idx];
903 uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
904 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
905 DECLARE_ALIGNED(32, int16_t, coeffs[MAX_TB_SIZE * MAX_TB_SIZE]) = { 0 };
906 DECLARE_ALIGNED(8, uint8_t, significant_coeff_group_flag[8][8]) = { { 0 } };
908 int trafo_size = 1 << log2_trafo_size;
909 int i, qp, shift, add, scale, scale_m;
910 static const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
911 const uint8_t *scale_matrix;
914 // Derive QP for dequant
915 if (!lc->cu.cu_transquant_bypass_flag) {
916 static const int qp_c[] = {
917 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37
920 static const uint8_t rem6[51 + 2 * 6 + 1] = {
921 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
922 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
923 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
926 static const uint8_t div6[51 + 2 * 6 + 1] = {
927 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
928 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
929 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
934 qp = qp_y + s->ps.sps->qp_bd_offset;
939 offset = s->ps.pps->cb_qp_offset + s->sh.slice_cb_qp_offset;
941 offset = s->ps.pps->cr_qp_offset + s->sh.slice_cr_qp_offset;
943 qp_i = av_clip(qp_y + offset, -s->ps.sps->qp_bd_offset, 57);
949 qp = qp_c[qp_i - 30];
951 qp += s->ps.sps->qp_bd_offset;
954 shift = s->ps.sps->bit_depth + log2_trafo_size - 5;
955 add = 1 << (shift - 1);
956 scale = level_scale[rem6[qp]] << (div6[qp]);
957 scale_m = 16; // default when no custom scaling lists.
960 if (s->ps.sps->scaling_list_enable_flag) {
961 const ScalingList *sl = s->ps.pps->scaling_list_data_present_flag ?
962 &s->ps.pps->scaling_list : &s->ps.sps->scaling_list;
963 int matrix_id = lc->cu.pred_mode != MODE_INTRA;
965 if (log2_trafo_size != 5)
966 matrix_id = 3 * matrix_id + c_idx;
968 scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
969 if (log2_trafo_size >= 4)
970 dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
974 if (s->ps.pps->transform_skip_enabled_flag &&
975 !lc->cu.cu_transquant_bypass_flag &&
976 log2_trafo_size == 2) {
977 transform_skip_flag = ff_hevc_transform_skip_flag_decode(s, c_idx);
980 last_significant_coeff_x =
981 ff_hevc_last_significant_coeff_x_prefix_decode(s, c_idx, log2_trafo_size);
982 last_significant_coeff_y =
983 ff_hevc_last_significant_coeff_y_prefix_decode(s, c_idx, log2_trafo_size);
985 if (last_significant_coeff_x > 3) {
986 int suffix = ff_hevc_last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
987 last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
988 (2 + (last_significant_coeff_x & 1)) +
992 if (last_significant_coeff_y > 3) {
993 int suffix = ff_hevc_last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
994 last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
995 (2 + (last_significant_coeff_y & 1)) +
999 if (scan_idx == SCAN_VERT)
1000 FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
1002 x_cg_last_sig = last_significant_coeff_x >> 2;
1003 y_cg_last_sig = last_significant_coeff_y >> 2;
1007 int last_x_c = last_significant_coeff_x & 3;
1008 int last_y_c = last_significant_coeff_y & 3;
1010 scan_x_off = ff_hevc_diag_scan4x4_x;
1011 scan_y_off = ff_hevc_diag_scan4x4_y;
1012 num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
1013 if (trafo_size == 4) {
1014 scan_x_cg = scan_1x1;
1015 scan_y_cg = scan_1x1;
1016 } else if (trafo_size == 8) {
1017 num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1018 scan_x_cg = diag_scan2x2_x;
1019 scan_y_cg = diag_scan2x2_y;
1020 } else if (trafo_size == 16) {
1021 num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1022 scan_x_cg = ff_hevc_diag_scan4x4_x;
1023 scan_y_cg = ff_hevc_diag_scan4x4_y;
1024 } else { // trafo_size == 32
1025 num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1026 scan_x_cg = ff_hevc_diag_scan8x8_x;
1027 scan_y_cg = ff_hevc_diag_scan8x8_y;
1032 scan_x_cg = horiz_scan2x2_x;
1033 scan_y_cg = horiz_scan2x2_y;
1034 scan_x_off = horiz_scan4x4_x;
1035 scan_y_off = horiz_scan4x4_y;
1036 num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1038 default: //SCAN_VERT
1039 scan_x_cg = horiz_scan2x2_y;
1040 scan_y_cg = horiz_scan2x2_x;
1041 scan_x_off = horiz_scan4x4_y;
1042 scan_y_off = horiz_scan4x4_x;
1043 num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1047 num_last_subset = (num_coeff - 1) >> 4;
1049 for (i = num_last_subset; i >= 0; i--) {
1051 int x_cg, y_cg, x_c, y_c;
1052 int implicit_non_zero_coeff = 0;
1053 int64_t trans_coeff_level;
1055 int offset = i << 4;
1057 uint8_t significant_coeff_flag_idx[16];
1058 uint8_t nb_significant_coeff_flag = 0;
1060 x_cg = scan_x_cg[i];
1061 y_cg = scan_y_cg[i];
1063 if (i < num_last_subset && i > 0) {
1065 if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1066 ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1067 if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1068 ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1070 significant_coeff_group_flag[x_cg][y_cg] =
1071 ff_hevc_significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
1072 implicit_non_zero_coeff = 1;
1074 significant_coeff_group_flag[x_cg][y_cg] =
1075 ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1076 (x_cg == 0 && y_cg == 0));
1079 last_scan_pos = num_coeff - offset - 1;
1081 if (i == num_last_subset) {
1082 n_end = last_scan_pos - 1;
1083 significant_coeff_flag_idx[0] = last_scan_pos;
1084 nb_significant_coeff_flag = 1;
1089 if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1090 prev_sig = significant_coeff_group_flag[x_cg + 1][y_cg];
1091 if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1092 prev_sig += significant_coeff_group_flag[x_cg][y_cg + 1] << 1;
1094 for (n = n_end; n >= 0; n--) {
1095 GET_COORD(offset, n);
1097 if (significant_coeff_group_flag[x_cg][y_cg] &&
1098 (n > 0 || implicit_non_zero_coeff == 0)) {
1099 if (ff_hevc_significant_coeff_flag_decode(s, c_idx, x_c, y_c,
1103 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1104 nb_significant_coeff_flag++;
1105 implicit_non_zero_coeff = 0;
1108 int last_cg = (x_c == (x_cg << 2) && y_c == (y_cg << 2));
1109 if (last_cg && implicit_non_zero_coeff && significant_coeff_group_flag[x_cg][y_cg]) {
1110 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1111 nb_significant_coeff_flag++;
1116 n_end = nb_significant_coeff_flag;
1119 int first_nz_pos_in_cg = 16;
1120 int last_nz_pos_in_cg = -1;
1121 int c_rice_param = 0;
1122 int first_greater1_coeff_idx = -1;
1123 uint8_t coeff_abs_level_greater1_flag[16] = { 0 };
1124 uint16_t coeff_sign_flag;
1126 int sign_hidden = 0;
1128 // initialize first elem of coeff_bas_level_greater1_flag
1129 int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1131 if (!(i == num_last_subset) && greater1_ctx == 0)
1134 last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1136 for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1137 int n_idx = significant_coeff_flag_idx[m];
1138 int inc = (ctx_set << 2) + greater1_ctx;
1139 coeff_abs_level_greater1_flag[n_idx] =
1140 ff_hevc_coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
1141 if (coeff_abs_level_greater1_flag[n_idx]) {
1143 } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1147 if (coeff_abs_level_greater1_flag[n_idx] &&
1148 first_greater1_coeff_idx == -1)
1149 first_greater1_coeff_idx = n_idx;
1151 first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1152 sign_hidden = last_nz_pos_in_cg - first_nz_pos_in_cg >= 4 &&
1153 !lc->cu.cu_transquant_bypass_flag;
1155 if (first_greater1_coeff_idx != -1) {
1156 coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += ff_hevc_coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1158 if (!s->ps.pps->sign_data_hiding_flag || !sign_hidden) {
1159 coeff_sign_flag = ff_hevc_coeff_sign_flag(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1161 coeff_sign_flag = ff_hevc_coeff_sign_flag(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1164 for (m = 0; m < n_end; m++) {
1165 n = significant_coeff_flag_idx[m];
1166 GET_COORD(offset, n);
1167 trans_coeff_level = 1 + coeff_abs_level_greater1_flag[n];
1168 if (trans_coeff_level == ((m < 8) ?
1169 ((n == first_greater1_coeff_idx) ? 3 : 2) : 1)) {
1170 int last_coeff_abs_level_remaining = ff_hevc_coeff_abs_level_remaining(s, trans_coeff_level, c_rice_param);
1172 trans_coeff_level += last_coeff_abs_level_remaining;
1173 if ((trans_coeff_level) > (3 * (1 << c_rice_param)))
1174 c_rice_param = FFMIN(c_rice_param + 1, 4);
1176 if (s->ps.pps->sign_data_hiding_flag && sign_hidden) {
1177 sum_abs += trans_coeff_level;
1178 if (n == first_nz_pos_in_cg && ((sum_abs & 1) == 1))
1179 trans_coeff_level = -trans_coeff_level;
1181 if (coeff_sign_flag >> 15)
1182 trans_coeff_level = -trans_coeff_level;
1183 coeff_sign_flag <<= 1;
1184 if (!lc->cu.cu_transquant_bypass_flag) {
1185 if (s->ps.sps->scaling_list_enable_flag) {
1186 if (y_c || x_c || log2_trafo_size < 4) {
1188 switch (log2_trafo_size) {
1189 case 3: pos = (y_c << 3) + x_c; break;
1190 case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1191 case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1192 default: pos = (y_c << 2) + x_c;
1194 scale_m = scale_matrix[pos];
1199 trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1200 if(trans_coeff_level < 0) {
1201 if((~trans_coeff_level) & 0xFffffffffff8000)
1202 trans_coeff_level = -32768;
1204 if (trans_coeff_level & 0xffffffffffff8000)
1205 trans_coeff_level = 32767;
1208 coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1213 if (!lc->cu.cu_transquant_bypass_flag) {
1214 if (transform_skip_flag)
1215 s->hevcdsp.dequant(coeffs);
1216 else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 &&
1217 log2_trafo_size == 2)
1218 s->hevcdsp.transform_4x4_luma(coeffs);
1220 int max_xy = FFMAX(last_significant_coeff_x, last_significant_coeff_y);
1222 s->hevcdsp.idct_dc[log2_trafo_size - 2](coeffs);
1224 int col_limit = last_significant_coeff_x + last_significant_coeff_y + 4;
1226 col_limit = FFMIN(4, col_limit);
1227 else if (max_xy < 8)
1228 col_limit = FFMIN(8, col_limit);
1229 else if (max_xy < 12)
1230 col_limit = FFMIN(24, col_limit);
1231 s->hevcdsp.idct[log2_trafo_size - 2](coeffs, col_limit);
1235 s->hevcdsp.add_residual[log2_trafo_size - 2](dst, coeffs, stride);
1238 static int hls_transform_unit(HEVCContext *s, int x0, int y0,
1239 int xBase, int yBase, int cb_xBase, int cb_yBase,
1240 int log2_cb_size, int log2_trafo_size,
1241 int blk_idx, int cbf_luma, int cbf_cb, int cbf_cr)
1243 HEVCLocalContext *lc = &s->HEVClc;
1245 if (lc->cu.pred_mode == MODE_INTRA) {
1246 int trafo_size = 1 << log2_trafo_size;
1247 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1249 s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
1250 if (log2_trafo_size > 2) {
1251 trafo_size = trafo_size << (s->ps.sps->hshift[1] - 1);
1252 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1253 s->hpc.intra_pred[log2_trafo_size - 3](s, x0, y0, 1);
1254 s->hpc.intra_pred[log2_trafo_size - 3](s, x0, y0, 2);
1255 } else if (blk_idx == 3) {
1256 trafo_size = trafo_size << s->ps.sps->hshift[1];
1257 ff_hevc_set_neighbour_available(s, xBase, yBase,
1258 trafo_size, trafo_size);
1259 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1260 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1264 if (cbf_luma || cbf_cb || cbf_cr) {
1265 int scan_idx = SCAN_DIAG;
1266 int scan_idx_c = SCAN_DIAG;
1268 if (s->ps.pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
1269 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
1270 if (lc->tu.cu_qp_delta != 0)
1271 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
1272 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
1273 lc->tu.is_cu_qp_delta_coded = 1;
1275 if (lc->tu.cu_qp_delta < -(26 + s->ps.sps->qp_bd_offset / 2) ||
1276 lc->tu.cu_qp_delta > (25 + s->ps.sps->qp_bd_offset / 2)) {
1277 av_log(s->avctx, AV_LOG_ERROR,
1278 "The cu_qp_delta %d is outside the valid range "
1281 -(26 + s->ps.sps->qp_bd_offset / 2),
1282 (25 + s->ps.sps->qp_bd_offset / 2));
1283 return AVERROR_INVALIDDATA;
1286 ff_hevc_set_qPy(s, x0, y0, cb_xBase, cb_yBase, log2_cb_size);
1289 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
1290 if (lc->tu.cur_intra_pred_mode >= 6 &&
1291 lc->tu.cur_intra_pred_mode <= 14) {
1292 scan_idx = SCAN_VERT;
1293 } else if (lc->tu.cur_intra_pred_mode >= 22 &&
1294 lc->tu.cur_intra_pred_mode <= 30) {
1295 scan_idx = SCAN_HORIZ;
1298 if (lc->pu.intra_pred_mode_c >= 6 &&
1299 lc->pu.intra_pred_mode_c <= 14) {
1300 scan_idx_c = SCAN_VERT;
1301 } else if (lc->pu.intra_pred_mode_c >= 22 &&
1302 lc->pu.intra_pred_mode_c <= 30) {
1303 scan_idx_c = SCAN_HORIZ;
1308 hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
1309 if (log2_trafo_size > 2) {
1311 hls_residual_coding(s, x0, y0, log2_trafo_size - 1, scan_idx_c, 1);
1313 hls_residual_coding(s, x0, y0, log2_trafo_size - 1, scan_idx_c, 2);
1314 } else if (blk_idx == 3) {
1316 hls_residual_coding(s, xBase, yBase, log2_trafo_size, scan_idx_c, 1);
1318 hls_residual_coding(s, xBase, yBase, log2_trafo_size, scan_idx_c, 2);
1324 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1326 int cb_size = 1 << log2_cb_size;
1327 int log2_min_pu_size = s->ps.sps->log2_min_pu_size;
1329 int min_pu_width = s->ps.sps->min_pu_width;
1330 int x_end = FFMIN(x0 + cb_size, s->ps.sps->width);
1331 int y_end = FFMIN(y0 + cb_size, s->ps.sps->height);
1334 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1335 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1336 s->is_pcm[i + j * min_pu_width] = 2;
1339 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1340 int xBase, int yBase, int cb_xBase, int cb_yBase,
1341 int log2_cb_size, int log2_trafo_size,
1342 int trafo_depth, int blk_idx,
1343 int cbf_cb, int cbf_cr)
1345 HEVCLocalContext *lc = &s->HEVClc;
1346 uint8_t split_transform_flag;
1349 if (lc->cu.intra_split_flag) {
1350 if (trafo_depth == 1)
1351 lc->tu.cur_intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1353 lc->tu.cur_intra_pred_mode = lc->pu.intra_pred_mode[0];
1356 if (log2_trafo_size <= s->ps.sps->log2_max_trafo_size &&
1357 log2_trafo_size > s->ps.sps->log2_min_tb_size &&
1358 trafo_depth < lc->cu.max_trafo_depth &&
1359 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1360 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1362 int inter_split = s->ps.sps->max_transform_hierarchy_depth_inter == 0 &&
1363 lc->cu.pred_mode == MODE_INTER &&
1364 lc->cu.part_mode != PART_2Nx2N &&
1367 split_transform_flag = log2_trafo_size > s->ps.sps->log2_max_trafo_size ||
1368 (lc->cu.intra_split_flag && trafo_depth == 0) ||
1372 if (log2_trafo_size > 2 && (trafo_depth == 0 || cbf_cb))
1373 cbf_cb = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1374 else if (log2_trafo_size > 2 || trafo_depth == 0)
1376 if (log2_trafo_size > 2 && (trafo_depth == 0 || cbf_cr))
1377 cbf_cr = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1378 else if (log2_trafo_size > 2 || trafo_depth == 0)
1381 if (split_transform_flag) {
1382 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1383 const int x1 = x0 + trafo_size_split;
1384 const int y1 = y0 + trafo_size_split;
1386 #define SUBDIVIDE(x, y, idx) \
1388 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1389 log2_trafo_size - 1, trafo_depth + 1, idx, \
1395 SUBDIVIDE(x0, y0, 0);
1396 SUBDIVIDE(x1, y0, 1);
1397 SUBDIVIDE(x0, y1, 2);
1398 SUBDIVIDE(x1, y1, 3);
1402 int min_tu_size = 1 << s->ps.sps->log2_min_tb_size;
1403 int log2_min_tu_size = s->ps.sps->log2_min_tb_size;
1404 int min_tu_width = s->ps.sps->min_tb_width;
1407 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1409 cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1411 ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1412 log2_cb_size, log2_trafo_size,
1413 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1416 // TODO: store cbf_luma somewhere else
1419 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1420 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1421 int x_tu = (x0 + j) >> log2_min_tu_size;
1422 int y_tu = (y0 + i) >> log2_min_tu_size;
1423 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1426 if (!s->sh.disable_deblocking_filter_flag) {
1427 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1428 if (s->ps.pps->transquant_bypass_enable_flag &&
1429 lc->cu.cu_transquant_bypass_flag)
1430 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1436 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1438 //TODO: non-4:2:0 support
1439 HEVCLocalContext *lc = &s->HEVClc;
1441 int cb_size = 1 << log2_cb_size;
1442 ptrdiff_t stride0 = s->frame->linesize[0];
1443 ptrdiff_t stride1 = s->frame->linesize[1];
1444 ptrdiff_t stride2 = s->frame->linesize[2];
1445 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->ps.sps->pixel_shift)];
1446 uint8_t *dst1 = &s->frame->data[1][(y0 >> s->ps.sps->vshift[1]) * stride1 + ((x0 >> s->ps.sps->hshift[1]) << s->ps.sps->pixel_shift)];
1447 uint8_t *dst2 = &s->frame->data[2][(y0 >> s->ps.sps->vshift[2]) * stride2 + ((x0 >> s->ps.sps->hshift[2]) << s->ps.sps->pixel_shift)];
1449 int length = cb_size * cb_size * s->ps.sps->pcm.bit_depth + ((cb_size * cb_size) >> 1) * s->ps.sps->pcm.bit_depth_chroma;
1450 const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1453 if (!s->sh.disable_deblocking_filter_flag)
1454 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1456 ret = init_get_bits(&gb, pcm, length);
1460 s->hevcdsp.put_pcm(dst0, stride0, cb_size, &gb, s->ps.sps->pcm.bit_depth);
1461 s->hevcdsp.put_pcm(dst1, stride1, cb_size / 2, &gb, s->ps.sps->pcm.bit_depth_chroma);
1462 s->hevcdsp.put_pcm(dst2, stride2, cb_size / 2, &gb, s->ps.sps->pcm.bit_depth_chroma);
1466 static void hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1468 HEVCLocalContext *lc = &s->HEVClc;
1469 int x = ff_hevc_abs_mvd_greater0_flag_decode(s);
1470 int y = ff_hevc_abs_mvd_greater0_flag_decode(s);
1473 x += ff_hevc_abs_mvd_greater1_flag_decode(s);
1475 y += ff_hevc_abs_mvd_greater1_flag_decode(s);
1478 case 2: lc->pu.mvd.x = ff_hevc_mvd_decode(s); break;
1479 case 1: lc->pu.mvd.x = ff_hevc_mvd_sign_flag_decode(s); break;
1480 case 0: lc->pu.mvd.x = 0; break;
1484 case 2: lc->pu.mvd.y = ff_hevc_mvd_decode(s); break;
1485 case 1: lc->pu.mvd.y = ff_hevc_mvd_sign_flag_decode(s); break;
1486 case 0: lc->pu.mvd.y = 0; break;
1491 * 8.5.3.2.2.1 Luma sample interpolation process
1493 * @param s HEVC decoding context
1494 * @param dst target buffer for block data at block position
1495 * @param dststride stride of the dst buffer
1496 * @param ref reference picture buffer at origin (0, 0)
1497 * @param mv motion vector (relative to block position) to get pixel data from
1498 * @param x_off horizontal position of block from origin (0, 0)
1499 * @param y_off vertical position of block from origin (0, 0)
1500 * @param block_w width of block
1501 * @param block_h height of block
1503 static void luma_mc(HEVCContext *s, int16_t *dst, ptrdiff_t dststride,
1504 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1505 int block_w, int block_h, int pred_idx)
1507 HEVCLocalContext *lc = &s->HEVClc;
1508 uint8_t *src = ref->data[0];
1509 ptrdiff_t srcstride = ref->linesize[0];
1510 int pic_width = s->ps.sps->width;
1511 int pic_height = s->ps.sps->height;
1515 int extra_left = ff_hevc_qpel_extra_before[mx];
1516 int extra_top = ff_hevc_qpel_extra_before[my];
1518 x_off += mv->x >> 2;
1519 y_off += mv->y >> 2;
1520 src += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1522 if (x_off < extra_left || y_off < extra_top ||
1523 x_off >= pic_width - block_w - ff_hevc_qpel_extra_after[mx] ||
1524 y_off >= pic_height - block_h - ff_hevc_qpel_extra_after[my]) {
1525 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1526 int offset = extra_top * srcstride + (extra_left << s->ps.sps->pixel_shift);
1527 int buf_offset = extra_top *
1528 edge_emu_stride + (extra_left << s->ps.sps->pixel_shift);
1530 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1531 edge_emu_stride, srcstride,
1532 block_w + ff_hevc_qpel_extra[mx],
1533 block_h + ff_hevc_qpel_extra[my],
1534 x_off - extra_left, y_off - extra_top,
1535 pic_width, pic_height);
1536 src = lc->edge_emu_buffer + buf_offset;
1537 srcstride = edge_emu_stride;
1539 s->hevcdsp.put_hevc_qpel[!!my][!!mx][pred_idx](dst, dststride, src, srcstride,
1540 block_h, mx, my, lc->mc_buffer);
1544 * 8.5.3.2.2.2 Chroma sample interpolation process
1546 * @param s HEVC decoding context
1547 * @param dst1 target buffer for block data at block position (U plane)
1548 * @param dst2 target buffer for block data at block position (V plane)
1549 * @param dststride stride of the dst1 and dst2 buffers
1550 * @param ref reference picture buffer at origin (0, 0)
1551 * @param mv motion vector (relative to block position) to get pixel data from
1552 * @param x_off horizontal position of block from origin (0, 0)
1553 * @param y_off vertical position of block from origin (0, 0)
1554 * @param block_w width of block
1555 * @param block_h height of block
1557 static void chroma_mc(HEVCContext *s, int16_t *dst1, int16_t *dst2,
1558 ptrdiff_t dststride, AVFrame *ref, const Mv *mv,
1559 int x_off, int y_off, int block_w, int block_h, int pred_idx)
1561 HEVCLocalContext *lc = &s->HEVClc;
1562 uint8_t *src1 = ref->data[1];
1563 uint8_t *src2 = ref->data[2];
1564 ptrdiff_t src1stride = ref->linesize[1];
1565 ptrdiff_t src2stride = ref->linesize[2];
1566 int pic_width = s->ps.sps->width >> 1;
1567 int pic_height = s->ps.sps->height >> 1;
1572 x_off += mv->x >> 3;
1573 y_off += mv->y >> 3;
1574 src1 += y_off * src1stride + (x_off * (1 << s->ps.sps->pixel_shift));
1575 src2 += y_off * src2stride + (x_off * (1 << s->ps.sps->pixel_shift));
1577 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1578 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1579 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1580 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1581 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->ps.sps->pixel_shift));
1582 int buf_offset1 = EPEL_EXTRA_BEFORE *
1583 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1584 int offset2 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->ps.sps->pixel_shift));
1585 int buf_offset2 = EPEL_EXTRA_BEFORE *
1586 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1588 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1589 edge_emu_stride, src1stride,
1590 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1591 x_off - EPEL_EXTRA_BEFORE,
1592 y_off - EPEL_EXTRA_BEFORE,
1593 pic_width, pic_height);
1595 src1 = lc->edge_emu_buffer + buf_offset1;
1596 src1stride = edge_emu_stride;
1597 s->hevcdsp.put_hevc_epel[!!my][!!mx][pred_idx](dst1, dststride, src1, src1stride,
1598 block_h, mx, my, lc->mc_buffer);
1600 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src2 - offset2,
1601 edge_emu_stride, src2stride,
1602 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1603 x_off - EPEL_EXTRA_BEFORE,
1604 y_off - EPEL_EXTRA_BEFORE,
1605 pic_width, pic_height);
1606 src2 = lc->edge_emu_buffer + buf_offset2;
1607 src2stride = edge_emu_stride;
1609 s->hevcdsp.put_hevc_epel[!!my][!!mx][pred_idx](dst2, dststride, src2, src2stride,
1610 block_h, mx, my, lc->mc_buffer);
1612 s->hevcdsp.put_hevc_epel[!!my][!!mx][pred_idx](dst1, dststride, src1, src1stride,
1613 block_h, mx, my, lc->mc_buffer);
1614 s->hevcdsp.put_hevc_epel[!!my][!!mx][pred_idx](dst2, dststride, src2, src2stride,
1615 block_h, mx, my, lc->mc_buffer);
1619 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1620 const Mv *mv, int y0, int height)
1622 int y = (mv->y >> 2) + y0 + height + 9;
1623 ff_thread_await_progress(&ref->tf, y, 0);
1626 static void hevc_luma_mv_mpv_mode(HEVCContext *s, int x0, int y0, int nPbW,
1627 int nPbH, int log2_cb_size, int part_idx,
1628 int merge_idx, MvField *mv)
1630 HEVCLocalContext *lc = &s->HEVClc;
1631 enum InterPredIdc inter_pred_idc = PRED_L0;
1634 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1635 if (s->sh.slice_type == HEVC_SLICE_B)
1636 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1638 if (inter_pred_idc != PRED_L1) {
1639 if (s->sh.nb_refs[L0])
1640 mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1642 mv->pred_flag[0] = 1;
1643 hls_mvd_coding(s, x0, y0, 0);
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, 0);
1647 mv->mv[0].x += lc->pu.mvd.x;
1648 mv->mv[0].y += lc->pu.mvd.y;
1651 if (inter_pred_idc != PRED_L0) {
1652 if (s->sh.nb_refs[L1])
1653 mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1655 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1656 AV_ZERO32(&lc->pu.mvd);
1658 hls_mvd_coding(s, x0, y0, 1);
1661 mv->pred_flag[1] = 1;
1662 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1663 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1664 part_idx, merge_idx, mv, mvp_flag, 1);
1665 mv->mv[1].x += lc->pu.mvd.x;
1666 mv->mv[1].y += lc->pu.mvd.y;
1670 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1672 int log2_cb_size, int partIdx)
1674 static const int pred_indices[] = {
1675 [4] = 0, [8] = 1, [12] = 2, [16] = 3, [24] = 4, [32] = 5, [48] = 6, [64] = 7,
1677 const int pred_idx = pred_indices[nPbW];
1679 #define POS(c_idx, x, y) \
1680 &s->frame->data[c_idx][((y) >> s->ps.sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1681 (((x) >> s->ps.sps->hshift[c_idx]) << s->ps.sps->pixel_shift)]
1682 HEVCLocalContext *lc = &s->HEVClc;
1684 struct MvField current_mv = {{{ 0 }}};
1686 int min_pu_width = s->ps.sps->min_pu_width;
1687 int weighted_pred = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1688 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1690 MvField *tab_mvf = s->ref->tab_mvf;
1691 RefPicList *refPicList = s->ref->refPicList;
1692 HEVCFrame *ref0, *ref1;
1694 ptrdiff_t tmpstride = MAX_PB_SIZE * sizeof(int16_t);
1696 uint8_t *dst0 = POS(0, x0, y0);
1697 uint8_t *dst1 = POS(1, x0, y0);
1698 uint8_t *dst2 = POS(2, x0, y0);
1699 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
1700 int min_cb_width = s->ps.sps->min_cb_width;
1701 int x_cb = x0 >> log2_min_cb_size;
1702 int y_cb = y0 >> log2_min_cb_size;
1706 int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1709 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1711 if (skip_flag || lc->pu.merge_flag) {
1712 if (s->sh.max_num_merge_cand > 1)
1713 merge_idx = ff_hevc_merge_idx_decode(s);
1717 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1718 partIdx, merge_idx, ¤t_mv);
1720 hevc_luma_mv_mpv_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1721 partIdx, merge_idx, ¤t_mv);
1724 x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1725 y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1727 for (j = 0; j < nPbH >> s->ps.sps->log2_min_pu_size; j++)
1728 for (i = 0; i < nPbW >> s->ps.sps->log2_min_pu_size; i++)
1729 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1731 if (current_mv.pred_flag[0]) {
1732 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1735 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1737 if (current_mv.pred_flag[1]) {
1738 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1741 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1744 if (current_mv.pred_flag[0] && !current_mv.pred_flag[1]) {
1745 DECLARE_ALIGNED(16, int16_t, tmp[MAX_PB_SIZE * MAX_PB_SIZE]);
1746 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1748 luma_mc(s, tmp, tmpstride, ref0->frame,
1749 ¤t_mv.mv[0], x0, y0, nPbW, nPbH, pred_idx);
1751 if (weighted_pred) {
1752 s->hevcdsp.weighted_pred[pred_idx](s->sh.luma_log2_weight_denom,
1753 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1754 s->sh.luma_offset_l0[current_mv.ref_idx[0]],
1755 dst0, s->frame->linesize[0], tmp,
1758 s->hevcdsp.put_unweighted_pred[pred_idx](dst0, s->frame->linesize[0], tmp, tmpstride, nPbH);
1760 chroma_mc(s, tmp, tmp2, tmpstride, ref0->frame,
1761 ¤t_mv.mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2, pred_idx);
1763 if (weighted_pred) {
1764 s->hevcdsp.weighted_pred_chroma[pred_idx](s->sh.chroma_log2_weight_denom,
1765 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0],
1766 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0],
1767 dst1, s->frame->linesize[1], tmp, tmpstride,
1769 s->hevcdsp.weighted_pred_chroma[pred_idx](s->sh.chroma_log2_weight_denom,
1770 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1],
1771 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1],
1772 dst2, s->frame->linesize[2], tmp2, tmpstride,
1775 s->hevcdsp.put_unweighted_pred_chroma[pred_idx](dst1, s->frame->linesize[1], tmp, tmpstride, nPbH / 2);
1776 s->hevcdsp.put_unweighted_pred_chroma[pred_idx](dst2, s->frame->linesize[2], tmp2, tmpstride, nPbH / 2);
1778 } else if (!current_mv.pred_flag[0] && current_mv.pred_flag[1]) {
1779 DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1780 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1782 luma_mc(s, tmp, tmpstride, ref1->frame,
1783 ¤t_mv.mv[1], x0, y0, nPbW, nPbH, pred_idx);
1785 if (weighted_pred) {
1786 s->hevcdsp.weighted_pred[pred_idx](s->sh.luma_log2_weight_denom,
1787 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1788 s->sh.luma_offset_l1[current_mv.ref_idx[1]],
1789 dst0, s->frame->linesize[0], tmp, tmpstride,
1792 s->hevcdsp.put_unweighted_pred[pred_idx](dst0, s->frame->linesize[0], tmp, tmpstride, nPbH);
1795 chroma_mc(s, tmp, tmp2, tmpstride, ref1->frame,
1796 ¤t_mv.mv[1], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2, pred_idx);
1798 if (weighted_pred) {
1799 s->hevcdsp.weighted_pred_chroma[pred_idx](s->sh.chroma_log2_weight_denom,
1800 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0],
1801 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0],
1802 dst1, s->frame->linesize[1], tmp, tmpstride, nPbH/2);
1803 s->hevcdsp.weighted_pred_chroma[pred_idx](s->sh.chroma_log2_weight_denom,
1804 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1],
1805 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1],
1806 dst2, s->frame->linesize[2], tmp2, tmpstride, nPbH/2);
1808 s->hevcdsp.put_unweighted_pred_chroma[pred_idx](dst1, s->frame->linesize[1], tmp, tmpstride, nPbH / 2);
1809 s->hevcdsp.put_unweighted_pred_chroma[pred_idx](dst2, s->frame->linesize[2], tmp2, tmpstride, nPbH / 2);
1811 } else if (current_mv.pred_flag[0] && current_mv.pred_flag[1]) {
1812 DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1813 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1814 DECLARE_ALIGNED(16, int16_t, tmp3[MAX_PB_SIZE * MAX_PB_SIZE]);
1815 DECLARE_ALIGNED(16, int16_t, tmp4[MAX_PB_SIZE * MAX_PB_SIZE]);
1817 luma_mc(s, tmp, tmpstride, ref0->frame,
1818 ¤t_mv.mv[0], x0, y0, nPbW, nPbH, pred_idx);
1819 luma_mc(s, tmp2, tmpstride, ref1->frame,
1820 ¤t_mv.mv[1], x0, y0, nPbW, nPbH, pred_idx);
1822 if (weighted_pred) {
1823 s->hevcdsp.weighted_pred_avg[pred_idx](s->sh.luma_log2_weight_denom,
1824 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1825 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1826 s->sh.luma_offset_l0[current_mv.ref_idx[0]],
1827 s->sh.luma_offset_l1[current_mv.ref_idx[1]],
1828 dst0, s->frame->linesize[0],
1829 tmp, tmp2, tmpstride, nPbH);
1831 s->hevcdsp.put_unweighted_pred_avg[pred_idx](dst0, s->frame->linesize[0],
1832 tmp, tmp2, tmpstride, nPbH);
1835 chroma_mc(s, tmp, tmp2, tmpstride, ref0->frame,
1836 ¤t_mv.mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2, pred_idx);
1837 chroma_mc(s, tmp3, tmp4, tmpstride, ref1->frame,
1838 ¤t_mv.mv[1], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2, pred_idx);
1840 if (weighted_pred) {
1841 s->hevcdsp.weighted_pred_avg_chroma[pred_idx](s->sh.chroma_log2_weight_denom,
1842 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0],
1843 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0],
1844 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0],
1845 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0],
1846 dst1, s->frame->linesize[1], tmp, tmp3,
1847 tmpstride, nPbH / 2);
1848 s->hevcdsp.weighted_pred_avg_chroma[pred_idx](s->sh.chroma_log2_weight_denom,
1849 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1],
1850 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1],
1851 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1],
1852 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1],
1853 dst2, s->frame->linesize[2], tmp2, tmp4,
1854 tmpstride, nPbH / 2);
1856 s->hevcdsp.put_unweighted_pred_avg_chroma[pred_idx](dst1, s->frame->linesize[1], tmp, tmp3, tmpstride, nPbH/2);
1857 s->hevcdsp.put_unweighted_pred_avg_chroma[pred_idx](dst2, s->frame->linesize[2], tmp2, tmp4, tmpstride, nPbH/2);
1865 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1866 int prev_intra_luma_pred_flag)
1868 HEVCLocalContext *lc = &s->HEVClc;
1869 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1870 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1871 int min_pu_width = s->ps.sps->min_pu_width;
1872 int size_in_pus = pu_size >> s->ps.sps->log2_min_pu_size;
1873 int x0b = x0 & ((1 << s->ps.sps->log2_ctb_size) - 1);
1874 int y0b = y0 & ((1 << s->ps.sps->log2_ctb_size) - 1);
1876 int cand_up = (lc->ctb_up_flag || y0b) ?
1877 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1878 int cand_left = (lc->ctb_left_flag || x0b) ?
1879 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1881 int y_ctb = (y0 >> (s->ps.sps->log2_ctb_size)) << (s->ps.sps->log2_ctb_size);
1883 MvField *tab_mvf = s->ref->tab_mvf;
1884 int intra_pred_mode;
1888 // intra_pred_mode prediction does not cross vertical CTB boundaries
1889 if ((y0 - 1) < y_ctb)
1892 if (cand_left == cand_up) {
1893 if (cand_left < 2) {
1894 candidate[0] = INTRA_PLANAR;
1895 candidate[1] = INTRA_DC;
1896 candidate[2] = INTRA_ANGULAR_26;
1898 candidate[0] = cand_left;
1899 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1900 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1903 candidate[0] = cand_left;
1904 candidate[1] = cand_up;
1905 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1906 candidate[2] = INTRA_PLANAR;
1907 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1908 candidate[2] = INTRA_DC;
1910 candidate[2] = INTRA_ANGULAR_26;
1914 if (prev_intra_luma_pred_flag) {
1915 intra_pred_mode = candidate[lc->pu.mpm_idx];
1917 if (candidate[0] > candidate[1])
1918 FFSWAP(uint8_t, candidate[0], candidate[1]);
1919 if (candidate[0] > candidate[2])
1920 FFSWAP(uint8_t, candidate[0], candidate[2]);
1921 if (candidate[1] > candidate[2])
1922 FFSWAP(uint8_t, candidate[1], candidate[2]);
1924 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1925 for (i = 0; i < 3; i++)
1926 if (intra_pred_mode >= candidate[i])
1930 /* write the intra prediction units into the mv array */
1933 for (i = 0; i < size_in_pus; i++) {
1934 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1935 intra_pred_mode, size_in_pus);
1937 for (j = 0; j < size_in_pus; j++) {
1938 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].is_intra = 1;
1939 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[0] = 0;
1940 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[1] = 0;
1941 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[0] = 0;
1942 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[1] = 0;
1943 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].x = 0;
1944 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].y = 0;
1945 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].x = 0;
1946 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].y = 0;
1950 return intra_pred_mode;
1953 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1954 int log2_cb_size, int ct_depth)
1956 int length = (1 << log2_cb_size) >> s->ps.sps->log2_min_cb_size;
1957 int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
1958 int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
1961 for (y = 0; y < length; y++)
1962 memset(&s->tab_ct_depth[(y_cb + y) * s->ps.sps->min_cb_width + x_cb],
1966 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1969 HEVCLocalContext *lc = &s->HEVClc;
1970 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1971 uint8_t prev_intra_luma_pred_flag[4];
1972 int split = lc->cu.part_mode == PART_NxN;
1973 int pb_size = (1 << log2_cb_size) >> split;
1974 int side = split + 1;
1978 for (i = 0; i < side; i++)
1979 for (j = 0; j < side; j++)
1980 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1982 for (i = 0; i < side; i++) {
1983 for (j = 0; j < side; j++) {
1984 if (prev_intra_luma_pred_flag[2 * i + j])
1985 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
1987 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
1989 lc->pu.intra_pred_mode[2 * i + j] =
1990 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1991 prev_intra_luma_pred_flag[2 * i + j]);
1995 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1996 if (chroma_mode != 4) {
1997 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1998 lc->pu.intra_pred_mode_c = 34;
2000 lc->pu.intra_pred_mode_c = intra_chroma_table[chroma_mode];
2002 lc->pu.intra_pred_mode_c = lc->pu.intra_pred_mode[0];
2006 static void intra_prediction_unit_default_value(HEVCContext *s,
2010 HEVCLocalContext *lc = &s->HEVClc;
2011 int pb_size = 1 << log2_cb_size;
2012 int size_in_pus = pb_size >> s->ps.sps->log2_min_pu_size;
2013 int min_pu_width = s->ps.sps->min_pu_width;
2014 MvField *tab_mvf = s->ref->tab_mvf;
2015 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
2016 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
2019 if (size_in_pus == 0)
2021 for (j = 0; j < size_in_pus; j++) {
2022 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
2023 for (k = 0; k < size_in_pus; k++)
2024 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].is_intra = lc->cu.pred_mode == MODE_INTRA;
2028 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
2030 int cb_size = 1 << log2_cb_size;
2031 HEVCLocalContext *lc = &s->HEVClc;
2032 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
2033 int length = cb_size >> log2_min_cb_size;
2034 int min_cb_width = s->ps.sps->min_cb_width;
2035 int x_cb = x0 >> log2_min_cb_size;
2036 int y_cb = y0 >> log2_min_cb_size;
2041 lc->cu.pred_mode = MODE_INTRA;
2042 lc->cu.part_mode = PART_2Nx2N;
2043 lc->cu.intra_split_flag = 0;
2045 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
2046 for (x = 0; x < 4; x++)
2047 lc->pu.intra_pred_mode[x] = 1;
2048 if (s->ps.pps->transquant_bypass_enable_flag) {
2049 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
2050 if (lc->cu.cu_transquant_bypass_flag)
2051 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2053 lc->cu.cu_transquant_bypass_flag = 0;
2055 if (s->sh.slice_type != HEVC_SLICE_I) {
2056 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
2058 x = y_cb * min_cb_width + x_cb;
2059 for (y = 0; y < length; y++) {
2060 memset(&s->skip_flag[x], skip_flag, length);
2063 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2066 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2067 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0);
2068 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2070 if (!s->sh.disable_deblocking_filter_flag)
2071 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2075 if (s->sh.slice_type != HEVC_SLICE_I)
2076 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2077 if (lc->cu.pred_mode != MODE_INTRA ||
2078 log2_cb_size == s->ps.sps->log2_min_cb_size) {
2079 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2080 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2081 lc->cu.pred_mode == MODE_INTRA;
2084 if (lc->cu.pred_mode == MODE_INTRA) {
2085 if (lc->cu.part_mode == PART_2Nx2N && s->ps.sps->pcm_enabled_flag &&
2086 log2_cb_size >= s->ps.sps->pcm.log2_min_pcm_cb_size &&
2087 log2_cb_size <= s->ps.sps->pcm.log2_max_pcm_cb_size) {
2088 pcm_flag = ff_hevc_pcm_flag_decode(s);
2091 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2092 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2093 if (s->ps.sps->pcm.loop_filter_disable_flag)
2094 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2099 intra_prediction_unit(s, x0, y0, log2_cb_size);
2102 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2103 switch (lc->cu.part_mode) {
2105 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0);
2108 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0);
2109 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1);
2112 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0);
2113 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1);
2116 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0);
2117 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1);
2120 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0);
2121 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1);
2124 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0);
2125 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1);
2128 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0);
2129 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1);
2132 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0);
2133 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1);
2134 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2);
2135 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3);
2141 int rqt_root_cbf = 1;
2143 if (lc->cu.pred_mode != MODE_INTRA &&
2144 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2145 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2148 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2149 s->ps.sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2150 s->ps.sps->max_transform_hierarchy_depth_inter;
2151 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2153 log2_cb_size, 0, 0, 0, 0);
2157 if (!s->sh.disable_deblocking_filter_flag)
2158 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2163 if (s->ps.pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2164 ff_hevc_set_qPy(s, x0, y0, x0, y0, log2_cb_size);
2166 x = y_cb * min_cb_width + x_cb;
2167 for (y = 0; y < length; y++) {
2168 memset(&s->qp_y_tab[x], lc->qp_y, length);
2172 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct.depth);
2177 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2178 int log2_cb_size, int cb_depth)
2180 HEVCLocalContext *lc = &s->HEVClc;
2181 const int cb_size = 1 << log2_cb_size;
2184 lc->ct.depth = cb_depth;
2185 if (x0 + cb_size <= s->ps.sps->width &&
2186 y0 + cb_size <= s->ps.sps->height &&
2187 log2_cb_size > s->ps.sps->log2_min_cb_size) {
2188 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2190 split_cu = (log2_cb_size > s->ps.sps->log2_min_cb_size);
2192 if (s->ps.pps->cu_qp_delta_enabled_flag &&
2193 log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth) {
2194 lc->tu.is_cu_qp_delta_coded = 0;
2195 lc->tu.cu_qp_delta = 0;
2199 const int cb_size_split = cb_size >> 1;
2200 const int x1 = x0 + cb_size_split;
2201 const int y1 = y0 + cb_size_split;
2206 #define SUBDIVIDE(x, y) \
2208 if (x < s->ps.sps->width && y < s->ps.sps->height) { \
2209 int ret = hls_coding_quadtree(s, x, y, log2_cb_size, cb_depth);\
2220 int ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2228 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2231 HEVCLocalContext *lc = &s->HEVClc;
2232 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2233 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2234 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2236 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2238 if (s->ps.pps->entropy_coding_sync_enabled_flag) {
2239 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2240 lc->first_qp_group = 1;
2241 lc->end_of_tiles_x = s->ps.sps->width;
2242 } else if (s->ps.pps->tiles_enabled_flag) {
2243 if (ctb_addr_ts && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
2244 int idxX = s->ps.pps->col_idxX[x_ctb >> s->ps.sps->log2_ctb_size];
2245 lc->start_of_tiles_x = x_ctb;
2246 lc->end_of_tiles_x = x_ctb + (s->ps.pps->column_width[idxX] << s->ps.sps->log2_ctb_size);
2247 lc->first_qp_group = 1;
2250 lc->end_of_tiles_x = s->ps.sps->width;
2253 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->ps.sps->height);
2255 lc->boundary_flags = 0;
2256 if (s->ps.pps->tiles_enabled_flag) {
2257 if (x_ctb > 0 && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs - 1]])
2258 lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2259 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2260 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2261 if (y_ctb > 0 && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs - s->ps.sps->ctb_width]])
2262 lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2263 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->ps.sps->ctb_width])
2264 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2266 if (!ctb_addr_in_slice)
2267 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2268 if (ctb_addr_in_slice < s->ps.sps->ctb_width)
2269 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2272 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2273 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->ps.sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2274 lc->ctb_up_right_flag = ((y_ctb > 0) && (ctb_addr_in_slice+1 >= s->ps.sps->ctb_width) && (s->ps.pps->tile_id[ctb_addr_ts] == s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs+1 - s->ps.sps->ctb_width]]));
2275 lc->ctb_up_left_flag = ((x_ctb > 0) && (y_ctb > 0) && (ctb_addr_in_slice-1 >= s->ps.sps->ctb_width) && (s->ps.pps->tile_id[ctb_addr_ts] == s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs-1 - s->ps.sps->ctb_width]]));
2278 static int hls_slice_data(HEVCContext *s)
2280 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2284 int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2287 while (more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2288 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2290 x_ctb = (ctb_addr_rs % ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2291 y_ctb = (ctb_addr_rs / ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2292 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2294 ff_hevc_cabac_init(s, ctb_addr_ts);
2296 hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2298 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2299 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2300 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2302 ret = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2305 more_data = !ff_hevc_end_of_slice_flag_decode(s);
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->ps.sps->width &&
2313 y_ctb + ctb_size >= s->ps.sps->height)
2314 ff_hevc_hls_filter(s, x_ctb, y_ctb);
2319 static void restore_tqb_pixels(HEVCContext *s)
2321 int min_pu_size = 1 << s->ps.sps->log2_min_pu_size;
2324 for (c_idx = 0; c_idx < 3; c_idx++) {
2325 ptrdiff_t stride = s->frame->linesize[c_idx];
2326 int hshift = s->ps.sps->hshift[c_idx];
2327 int vshift = s->ps.sps->vshift[c_idx];
2328 for (y = 0; y < s->ps.sps->min_pu_height; y++) {
2329 for (x = 0; x < s->ps.sps->min_pu_width; x++) {
2330 if (s->is_pcm[y * s->ps.sps->min_pu_width + x]) {
2332 int len = min_pu_size >> hshift;
2333 uint8_t *src = &s->frame->data[c_idx][((y << s->ps.sps->log2_min_pu_size) >> vshift) * stride + (((x << s->ps.sps->log2_min_pu_size) >> hshift) << s->ps.sps->pixel_shift)];
2334 uint8_t *dst = &s->sao_frame->data[c_idx][((y << s->ps.sps->log2_min_pu_size) >> vshift) * stride + (((x << s->ps.sps->log2_min_pu_size) >> hshift) << s->ps.sps->pixel_shift)];
2335 for (n = 0; n < (min_pu_size >> vshift); n++) {
2336 memcpy(dst, src, len);
2346 static int set_side_data(HEVCContext *s)
2348 AVFrame *out = s->ref->frame;
2350 if (s->sei_frame_packing_present &&
2351 s->frame_packing_arrangement_type >= 3 &&
2352 s->frame_packing_arrangement_type <= 5 &&
2353 s->content_interpretation_type > 0 &&
2354 s->content_interpretation_type < 3) {
2355 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2357 return AVERROR(ENOMEM);
2359 switch (s->frame_packing_arrangement_type) {
2361 if (s->quincunx_subsampling)
2362 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2364 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2367 stereo->type = AV_STEREO3D_TOPBOTTOM;
2370 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2374 if (s->content_interpretation_type == 2)
2375 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2378 if (s->sei_display_orientation_present &&
2379 (s->sei_anticlockwise_rotation || s->sei_hflip || s->sei_vflip)) {
2380 double angle = s->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
2381 AVFrameSideData *rotation = av_frame_new_side_data(out,
2382 AV_FRAME_DATA_DISPLAYMATRIX,
2383 sizeof(int32_t) * 9);
2385 return AVERROR(ENOMEM);
2387 av_display_rotation_set((int32_t *)rotation->data, angle);
2388 av_display_matrix_flip((int32_t *)rotation->data,
2389 s->sei_hflip, s->sei_vflip);
2395 static int hevc_frame_start(HEVCContext *s)
2397 HEVCLocalContext *lc = &s->HEVClc;
2400 memset(s->horizontal_bs, 0, 2 * s->bs_width * (s->bs_height + 1));
2401 memset(s->vertical_bs, 0, 2 * s->bs_width * (s->bs_height + 1));
2402 memset(s->cbf_luma, 0, s->ps.sps->min_tb_width * s->ps.sps->min_tb_height);
2403 memset(s->is_pcm, 0, s->ps.sps->min_pu_width * s->ps.sps->min_pu_height);
2405 lc->start_of_tiles_x = 0;
2407 s->first_nal_type = s->nal_unit_type;
2409 if (s->ps.pps->tiles_enabled_flag)
2410 lc->end_of_tiles_x = s->ps.pps->column_width[0] << s->ps.sps->log2_ctb_size;
2412 ret = ff_hevc_set_new_ref(s, s->ps.sps->sao_enabled ? &s->sao_frame : &s->frame,
2417 ret = ff_hevc_frame_rps(s);
2419 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2423 s->ref->frame->key_frame = IS_IRAP(s);
2425 ret = set_side_data(s);
2429 av_frame_unref(s->output_frame);
2430 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2434 ff_thread_finish_setup(s->avctx);
2440 ff_hevc_unref_frame(s, s->ref, ~0);
2445 static int decode_nal_unit(HEVCContext *s, const H2645NAL *nal)
2447 HEVCLocalContext *lc = &s->HEVClc;
2448 GetBitContext *gb = &lc->gb;
2449 int ctb_addr_ts, ret;
2452 s->nal_unit_type = nal->type;
2453 s->temporal_id = nal->temporal_id;
2455 switch (s->nal_unit_type) {
2457 ret = ff_hevc_decode_nal_vps(gb, s->avctx, &s->ps);
2462 ret = ff_hevc_decode_nal_sps(gb, s->avctx, &s->ps,
2463 s->apply_defdispwin);
2468 ret = ff_hevc_decode_nal_pps(gb, s->avctx, &s->ps);
2472 case HEVC_NAL_SEI_PREFIX:
2473 case HEVC_NAL_SEI_SUFFIX:
2474 ret = ff_hevc_decode_nal_sei(s);
2478 case HEVC_NAL_TRAIL_R:
2479 case HEVC_NAL_TRAIL_N:
2480 case HEVC_NAL_TSA_N:
2481 case HEVC_NAL_TSA_R:
2482 case HEVC_NAL_STSA_N:
2483 case HEVC_NAL_STSA_R:
2484 case HEVC_NAL_BLA_W_LP:
2485 case HEVC_NAL_BLA_W_RADL:
2486 case HEVC_NAL_BLA_N_LP:
2487 case HEVC_NAL_IDR_W_RADL:
2488 case HEVC_NAL_IDR_N_LP:
2489 case HEVC_NAL_CRA_NUT:
2490 case HEVC_NAL_RADL_N:
2491 case HEVC_NAL_RADL_R:
2492 case HEVC_NAL_RASL_N:
2493 case HEVC_NAL_RASL_R:
2494 ret = hls_slice_header(s);
2498 if (s->max_ra == INT_MAX) {
2499 if (s->nal_unit_type == HEVC_NAL_CRA_NUT || IS_BLA(s)) {
2503 s->max_ra = INT_MIN;
2507 if ((s->nal_unit_type == HEVC_NAL_RASL_R || s->nal_unit_type == HEVC_NAL_RASL_N) &&
2508 s->poc <= s->max_ra) {
2512 if (s->nal_unit_type == HEVC_NAL_RASL_R && s->poc > s->max_ra)
2513 s->max_ra = INT_MIN;
2516 if (s->sh.first_slice_in_pic_flag) {
2517 ret = hevc_frame_start(s);
2520 } else if (!s->ref) {
2521 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2525 if (s->nal_unit_type != s->first_nal_type) {
2526 av_log(s->avctx, AV_LOG_ERROR,
2527 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2528 s->first_nal_type, s->nal_unit_type);
2529 return AVERROR_INVALIDDATA;
2532 if (!s->sh.dependent_slice_segment_flag &&
2533 s->sh.slice_type != HEVC_SLICE_I) {
2534 ret = ff_hevc_slice_rpl(s);
2536 av_log(s->avctx, AV_LOG_WARNING,
2537 "Error constructing the reference lists for the current slice.\n");
2542 if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) {
2543 ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0);
2548 if (s->avctx->hwaccel) {
2549 ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size);
2553 ctb_addr_ts = hls_slice_data(s);
2554 if (ctb_addr_ts >= (s->ps.sps->ctb_width * s->ps.sps->ctb_height)) {
2556 if ((s->ps.pps->transquant_bypass_enable_flag ||
2557 (s->ps.sps->pcm.loop_filter_disable_flag && s->ps.sps->pcm_enabled_flag)) &&
2558 s->ps.sps->sao_enabled)
2559 restore_tqb_pixels(s);
2562 if (ctb_addr_ts < 0) {
2568 case HEVC_NAL_EOS_NUT:
2569 case HEVC_NAL_EOB_NUT:
2570 s->seq_decode = (s->seq_decode + 1) & 0xff;
2571 s->max_ra = INT_MAX;
2574 case HEVC_NAL_FD_NUT:
2577 av_log(s->avctx, AV_LOG_INFO,
2578 "Skipping NAL unit %d\n", s->nal_unit_type);
2583 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2588 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2595 /* split the input packet into NAL units, so we know the upper bound on the
2596 * number of slices in the frame */
2597 ret = ff_h2645_packet_split(&s->pkt, buf, length, s->avctx, s->is_nalff,
2598 s->nal_length_size, s->avctx->codec_id);
2600 av_log(s->avctx, AV_LOG_ERROR,
2601 "Error splitting the input into NAL units.\n");
2605 for (i = 0; i < s->pkt.nb_nals; i++) {
2606 if (s->pkt.nals[i].type == HEVC_NAL_EOB_NUT ||
2607 s->pkt.nals[i].type == HEVC_NAL_EOS_NUT)
2611 /* decode the NAL units */
2612 for (i = 0; i < s->pkt.nb_nals; i++) {
2613 ret = decode_nal_unit(s, &s->pkt.nals[i]);
2615 av_log(s->avctx, AV_LOG_WARNING,
2616 "Error parsing NAL unit #%d.\n", i);
2623 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2628 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2631 for (i = 0; i < 16; i++)
2632 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
2635 static int verify_md5(HEVCContext *s, AVFrame *frame)
2637 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
2642 return AVERROR(EINVAL);
2644 pixel_shift = desc->comp[0].depth > 8;
2646 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
2649 /* the checksums are LE, so we have to byteswap for >8bpp formats
2652 if (pixel_shift && !s->checksum_buf) {
2653 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
2654 FFMAX3(frame->linesize[0], frame->linesize[1],
2655 frame->linesize[2]));
2656 if (!s->checksum_buf)
2657 return AVERROR(ENOMEM);
2661 for (i = 0; frame->data[i]; i++) {
2662 int width = s->avctx->coded_width;
2663 int height = s->avctx->coded_height;
2664 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
2665 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
2668 av_md5_init(s->md5_ctx);
2669 for (j = 0; j < h; j++) {
2670 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
2673 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
2674 (const uint16_t *) src, w);
2675 src = s->checksum_buf;
2678 av_md5_update(s->md5_ctx, src, w << pixel_shift);
2680 av_md5_final(s->md5_ctx, md5);
2682 if (!memcmp(md5, s->md5[i], 16)) {
2683 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
2684 print_md5(s->avctx, AV_LOG_DEBUG, md5);
2685 av_log (s->avctx, AV_LOG_DEBUG, "; ");
2687 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
2688 print_md5(s->avctx, AV_LOG_ERROR, md5);
2689 av_log (s->avctx, AV_LOG_ERROR, " != ");
2690 print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
2691 av_log (s->avctx, AV_LOG_ERROR, "\n");
2692 return AVERROR_INVALIDDATA;
2696 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2701 static int hevc_decode_extradata(HEVCContext *s)
2703 AVCodecContext *avctx = s->avctx;
2707 bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
2709 if (avctx->extradata_size > 3 &&
2710 (avctx->extradata[0] || avctx->extradata[1] ||
2711 avctx->extradata[2] > 1)) {
2712 /* It seems the extradata is encoded as hvcC format.
2713 * Temporarily, we support configurationVersion==0 until 14496-15 3rd
2714 * is finalized. When finalized, configurationVersion will be 1 and we
2715 * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
2716 int i, j, num_arrays, nal_len_size;
2720 bytestream2_skip(&gb, 21);
2721 nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
2722 num_arrays = bytestream2_get_byte(&gb);
2724 /* nal units in the hvcC always have length coded with 2 bytes,
2725 * so put a fake nal_length_size = 2 while parsing them */
2726 s->nal_length_size = 2;
2728 /* Decode nal units from hvcC. */
2729 for (i = 0; i < num_arrays; i++) {
2730 int type = bytestream2_get_byte(&gb) & 0x3f;
2731 int cnt = bytestream2_get_be16(&gb);
2733 for (j = 0; j < cnt; j++) {
2734 // +2 for the nal size field
2735 int nalsize = bytestream2_peek_be16(&gb) + 2;
2736 if (bytestream2_get_bytes_left(&gb) < nalsize) {
2737 av_log(s->avctx, AV_LOG_ERROR,
2738 "Invalid NAL unit size in extradata.\n");
2739 return AVERROR_INVALIDDATA;
2742 ret = decode_nal_units(s, gb.buffer, nalsize);
2744 av_log(avctx, AV_LOG_ERROR,
2745 "Decoding nal unit %d %d from hvcC failed\n",
2749 bytestream2_skip(&gb, nalsize);
2753 /* Now store right nal length size, that will be used to parse
2755 s->nal_length_size = nal_len_size;
2758 ret = decode_nal_units(s, avctx->extradata, avctx->extradata_size);
2763 /* export stream parameters from the first SPS */
2764 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
2765 if (s->ps.sps_list[i]) {
2766 const HEVCSPS *sps = (const HEVCSPS*)s->ps.sps_list[i]->data;
2767 export_stream_params(s->avctx, &s->ps, sps);
2775 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
2779 HEVCContext *s = avctx->priv_data;
2782 ret = ff_hevc_output_frame(s, data, 1);
2791 ret = decode_nal_units(s, avpkt->data, avpkt->size);
2795 if (avctx->hwaccel) {
2796 if (s->ref && avctx->hwaccel->end_frame(avctx) < 0)
2797 av_log(avctx, AV_LOG_ERROR,
2798 "hardware accelerator failed to decode picture\n");
2800 /* verify the SEI checksum */
2801 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
2803 ret = verify_md5(s, s->ref->frame);
2804 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
2805 ff_hevc_unref_frame(s, s->ref, ~0);
2812 if (s->is_decoded) {
2813 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
2817 if (s->output_frame->buf[0]) {
2818 av_frame_move_ref(data, s->output_frame);
2825 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
2827 int ret = ff_thread_ref_frame(&dst->tf, &src->tf);
2831 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
2832 if (!dst->tab_mvf_buf)
2834 dst->tab_mvf = src->tab_mvf;
2836 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
2837 if (!dst->rpl_tab_buf)
2839 dst->rpl_tab = src->rpl_tab;
2841 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
2845 dst->poc = src->poc;
2846 dst->ctb_count = src->ctb_count;
2847 dst->window = src->window;
2848 dst->flags = src->flags;
2849 dst->sequence = src->sequence;
2851 if (src->hwaccel_picture_private) {
2852 dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
2853 if (!dst->hwaccel_priv_buf)
2855 dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
2860 ff_hevc_unref_frame(s, dst, ~0);
2861 return AVERROR(ENOMEM);
2864 static av_cold int hevc_decode_free(AVCodecContext *avctx)
2866 HEVCContext *s = avctx->priv_data;
2871 av_freep(&s->md5_ctx);
2873 av_frame_free(&s->tmp_frame);
2874 av_frame_free(&s->output_frame);
2876 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2877 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
2878 av_frame_free(&s->DPB[i].frame);
2881 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++)
2882 av_buffer_unref(&s->ps.vps_list[i]);
2883 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++)
2884 av_buffer_unref(&s->ps.sps_list[i]);
2885 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++)
2886 av_buffer_unref(&s->ps.pps_list[i]);
2888 ff_h2645_packet_uninit(&s->pkt);
2893 static av_cold int hevc_init_context(AVCodecContext *avctx)
2895 HEVCContext *s = avctx->priv_data;
2900 s->tmp_frame = av_frame_alloc();
2904 s->output_frame = av_frame_alloc();
2905 if (!s->output_frame)
2908 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2909 s->DPB[i].frame = av_frame_alloc();
2910 if (!s->DPB[i].frame)
2912 s->DPB[i].tf.f = s->DPB[i].frame;
2915 s->max_ra = INT_MAX;
2917 s->md5_ctx = av_md5_alloc();
2921 ff_bswapdsp_init(&s->bdsp);
2923 s->context_initialized = 1;
2928 hevc_decode_free(avctx);
2929 return AVERROR(ENOMEM);
2932 static int hevc_update_thread_context(AVCodecContext *dst,
2933 const AVCodecContext *src)
2935 HEVCContext *s = dst->priv_data;
2936 HEVCContext *s0 = src->priv_data;
2939 if (!s->context_initialized) {
2940 ret = hevc_init_context(dst);
2945 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2946 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
2947 if (s0->DPB[i].frame->buf[0]) {
2948 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
2954 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++) {
2955 av_buffer_unref(&s->ps.vps_list[i]);
2956 if (s0->ps.vps_list[i]) {
2957 s->ps.vps_list[i] = av_buffer_ref(s0->ps.vps_list[i]);
2958 if (!s->ps.vps_list[i])
2959 return AVERROR(ENOMEM);
2963 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
2964 av_buffer_unref(&s->ps.sps_list[i]);
2965 if (s0->ps.sps_list[i]) {
2966 s->ps.sps_list[i] = av_buffer_ref(s0->ps.sps_list[i]);
2967 if (!s->ps.sps_list[i])
2968 return AVERROR(ENOMEM);
2972 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++) {
2973 av_buffer_unref(&s->ps.pps_list[i]);
2974 if (s0->ps.pps_list[i]) {
2975 s->ps.pps_list[i] = av_buffer_ref(s0->ps.pps_list[i]);
2976 if (!s->ps.pps_list[i])
2977 return AVERROR(ENOMEM);
2981 if (s->ps.sps != s0->ps.sps)
2982 ret = set_sps(s, s0->ps.sps);
2984 s->seq_decode = s0->seq_decode;
2985 s->seq_output = s0->seq_output;
2986 s->pocTid0 = s0->pocTid0;
2987 s->max_ra = s0->max_ra;
2989 s->is_nalff = s0->is_nalff;
2990 s->nal_length_size = s0->nal_length_size;
2993 s->seq_decode = (s->seq_decode + 1) & 0xff;
2994 s->max_ra = INT_MAX;
3000 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3002 HEVCContext *s = avctx->priv_data;
3005 avctx->internal->allocate_progress = 1;
3007 ret = hevc_init_context(avctx);
3011 if (avctx->extradata_size > 0 && avctx->extradata) {
3012 ret = hevc_decode_extradata(s);
3014 hevc_decode_free(avctx);
3022 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3024 HEVCContext *s = avctx->priv_data;
3027 memset(s, 0, sizeof(*s));
3029 ret = hevc_init_context(avctx);
3036 static void hevc_decode_flush(AVCodecContext *avctx)
3038 HEVCContext *s = avctx->priv_data;
3039 ff_hevc_flush_dpb(s);
3040 s->max_ra = INT_MAX;
3043 #define OFFSET(x) offsetof(HEVCContext, x)
3044 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3046 static const AVOption options[] = {
3047 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3048 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3052 static const AVClass hevc_decoder_class = {
3053 .class_name = "HEVC decoder",
3054 .item_name = av_default_item_name,
3056 .version = LIBAVUTIL_VERSION_INT,
3059 AVCodec ff_hevc_decoder = {
3061 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3062 .type = AVMEDIA_TYPE_VIDEO,
3063 .id = AV_CODEC_ID_HEVC,
3064 .priv_data_size = sizeof(HEVCContext),
3065 .priv_class = &hevc_decoder_class,
3066 .init = hevc_decode_init,
3067 .close = hevc_decode_free,
3068 .decode = hevc_decode_frame,
3069 .flush = hevc_decode_flush,
3070 .update_thread_context = hevc_update_thread_context,
3071 .init_thread_copy = hevc_init_thread_copy,
3072 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
3073 AV_CODEC_CAP_FRAME_THREADS,
3074 .profiles = NULL_IF_CONFIG_SMALL(ff_hevc_profiles),