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 trans_coeff_level += ff_hevc_coeff_abs_level_remaining(s, trans_coeff_level, c_rice_param);
1171 if ((trans_coeff_level) > (3 * (1 << c_rice_param)))
1172 c_rice_param = FFMIN(c_rice_param + 1, 4);
1174 if (s->ps.pps->sign_data_hiding_flag && sign_hidden) {
1175 sum_abs += trans_coeff_level;
1176 if (n == first_nz_pos_in_cg && ((sum_abs & 1) == 1))
1177 trans_coeff_level = -trans_coeff_level;
1179 if (coeff_sign_flag >> 15)
1180 trans_coeff_level = -trans_coeff_level;
1181 coeff_sign_flag <<= 1;
1182 if (!lc->cu.cu_transquant_bypass_flag) {
1183 if (s->ps.sps->scaling_list_enable_flag) {
1184 if (y_c || x_c || log2_trafo_size < 4) {
1186 switch (log2_trafo_size) {
1187 case 3: pos = (y_c << 3) + x_c; break;
1188 case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1189 case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1190 default: pos = (y_c << 2) + x_c;
1192 scale_m = scale_matrix[pos];
1197 trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1198 if(trans_coeff_level < 0) {
1199 if((~trans_coeff_level) & 0xFffffffffff8000)
1200 trans_coeff_level = -32768;
1202 if (trans_coeff_level & 0xffffffffffff8000)
1203 trans_coeff_level = 32767;
1206 coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1211 if (!lc->cu.cu_transquant_bypass_flag) {
1212 if (transform_skip_flag)
1213 s->hevcdsp.dequant(coeffs);
1214 else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 &&
1215 log2_trafo_size == 2)
1216 s->hevcdsp.transform_4x4_luma(coeffs);
1218 int max_xy = FFMAX(last_significant_coeff_x, last_significant_coeff_y);
1220 s->hevcdsp.idct_dc[log2_trafo_size - 2](coeffs);
1222 int col_limit = last_significant_coeff_x + last_significant_coeff_y + 4;
1224 col_limit = FFMIN(4, col_limit);
1225 else if (max_xy < 8)
1226 col_limit = FFMIN(8, col_limit);
1227 else if (max_xy < 12)
1228 col_limit = FFMIN(24, col_limit);
1229 s->hevcdsp.idct[log2_trafo_size - 2](coeffs, col_limit);
1233 s->hevcdsp.add_residual[log2_trafo_size - 2](dst, coeffs, stride);
1236 static int hls_transform_unit(HEVCContext *s, int x0, int y0,
1237 int xBase, int yBase, int cb_xBase, int cb_yBase,
1238 int log2_cb_size, int log2_trafo_size,
1239 int blk_idx, int cbf_luma, int cbf_cb, int cbf_cr)
1241 HEVCLocalContext *lc = &s->HEVClc;
1243 if (lc->cu.pred_mode == MODE_INTRA) {
1244 int trafo_size = 1 << log2_trafo_size;
1245 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1247 s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
1248 if (log2_trafo_size > 2) {
1249 trafo_size = trafo_size << (s->ps.sps->hshift[1] - 1);
1250 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1251 s->hpc.intra_pred[log2_trafo_size - 3](s, x0, y0, 1);
1252 s->hpc.intra_pred[log2_trafo_size - 3](s, x0, y0, 2);
1253 } else if (blk_idx == 3) {
1254 trafo_size = trafo_size << s->ps.sps->hshift[1];
1255 ff_hevc_set_neighbour_available(s, xBase, yBase,
1256 trafo_size, trafo_size);
1257 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1258 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1262 if (cbf_luma || cbf_cb || cbf_cr) {
1263 int scan_idx = SCAN_DIAG;
1264 int scan_idx_c = SCAN_DIAG;
1266 if (s->ps.pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
1267 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
1268 if (lc->tu.cu_qp_delta != 0)
1269 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
1270 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
1271 lc->tu.is_cu_qp_delta_coded = 1;
1273 if (lc->tu.cu_qp_delta < -(26 + s->ps.sps->qp_bd_offset / 2) ||
1274 lc->tu.cu_qp_delta > (25 + s->ps.sps->qp_bd_offset / 2)) {
1275 av_log(s->avctx, AV_LOG_ERROR,
1276 "The cu_qp_delta %d is outside the valid range "
1279 -(26 + s->ps.sps->qp_bd_offset / 2),
1280 (25 + s->ps.sps->qp_bd_offset / 2));
1281 return AVERROR_INVALIDDATA;
1284 ff_hevc_set_qPy(s, x0, y0, cb_xBase, cb_yBase, log2_cb_size);
1287 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
1288 if (lc->tu.cur_intra_pred_mode >= 6 &&
1289 lc->tu.cur_intra_pred_mode <= 14) {
1290 scan_idx = SCAN_VERT;
1291 } else if (lc->tu.cur_intra_pred_mode >= 22 &&
1292 lc->tu.cur_intra_pred_mode <= 30) {
1293 scan_idx = SCAN_HORIZ;
1296 if (lc->pu.intra_pred_mode_c >= 6 &&
1297 lc->pu.intra_pred_mode_c <= 14) {
1298 scan_idx_c = SCAN_VERT;
1299 } else if (lc->pu.intra_pred_mode_c >= 22 &&
1300 lc->pu.intra_pred_mode_c <= 30) {
1301 scan_idx_c = SCAN_HORIZ;
1306 hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
1307 if (log2_trafo_size > 2) {
1309 hls_residual_coding(s, x0, y0, log2_trafo_size - 1, scan_idx_c, 1);
1311 hls_residual_coding(s, x0, y0, log2_trafo_size - 1, scan_idx_c, 2);
1312 } else if (blk_idx == 3) {
1314 hls_residual_coding(s, xBase, yBase, log2_trafo_size, scan_idx_c, 1);
1316 hls_residual_coding(s, xBase, yBase, log2_trafo_size, scan_idx_c, 2);
1322 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1324 int cb_size = 1 << log2_cb_size;
1325 int log2_min_pu_size = s->ps.sps->log2_min_pu_size;
1327 int min_pu_width = s->ps.sps->min_pu_width;
1328 int x_end = FFMIN(x0 + cb_size, s->ps.sps->width);
1329 int y_end = FFMIN(y0 + cb_size, s->ps.sps->height);
1332 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1333 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1334 s->is_pcm[i + j * min_pu_width] = 2;
1337 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1338 int xBase, int yBase, int cb_xBase, int cb_yBase,
1339 int log2_cb_size, int log2_trafo_size,
1340 int trafo_depth, int blk_idx,
1341 int cbf_cb, int cbf_cr)
1343 HEVCLocalContext *lc = &s->HEVClc;
1344 uint8_t split_transform_flag;
1347 if (lc->cu.intra_split_flag) {
1348 if (trafo_depth == 1)
1349 lc->tu.cur_intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1351 lc->tu.cur_intra_pred_mode = lc->pu.intra_pred_mode[0];
1354 if (log2_trafo_size <= s->ps.sps->log2_max_trafo_size &&
1355 log2_trafo_size > s->ps.sps->log2_min_tb_size &&
1356 trafo_depth < lc->cu.max_trafo_depth &&
1357 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1358 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1360 int inter_split = s->ps.sps->max_transform_hierarchy_depth_inter == 0 &&
1361 lc->cu.pred_mode == MODE_INTER &&
1362 lc->cu.part_mode != PART_2Nx2N &&
1365 split_transform_flag = log2_trafo_size > s->ps.sps->log2_max_trafo_size ||
1366 (lc->cu.intra_split_flag && trafo_depth == 0) ||
1370 if (log2_trafo_size > 2 && (trafo_depth == 0 || cbf_cb))
1371 cbf_cb = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1372 else if (log2_trafo_size > 2 || trafo_depth == 0)
1374 if (log2_trafo_size > 2 && (trafo_depth == 0 || cbf_cr))
1375 cbf_cr = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1376 else if (log2_trafo_size > 2 || trafo_depth == 0)
1379 if (split_transform_flag) {
1380 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1381 const int x1 = x0 + trafo_size_split;
1382 const int y1 = y0 + trafo_size_split;
1384 #define SUBDIVIDE(x, y, idx) \
1386 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1387 log2_trafo_size - 1, trafo_depth + 1, idx, \
1393 SUBDIVIDE(x0, y0, 0);
1394 SUBDIVIDE(x1, y0, 1);
1395 SUBDIVIDE(x0, y1, 2);
1396 SUBDIVIDE(x1, y1, 3);
1400 int min_tu_size = 1 << s->ps.sps->log2_min_tb_size;
1401 int log2_min_tu_size = s->ps.sps->log2_min_tb_size;
1402 int min_tu_width = s->ps.sps->min_tb_width;
1405 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1407 cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1409 ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1410 log2_cb_size, log2_trafo_size,
1411 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1414 // TODO: store cbf_luma somewhere else
1417 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1418 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1419 int x_tu = (x0 + j) >> log2_min_tu_size;
1420 int y_tu = (y0 + i) >> log2_min_tu_size;
1421 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1424 if (!s->sh.disable_deblocking_filter_flag) {
1425 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1426 if (s->ps.pps->transquant_bypass_enable_flag &&
1427 lc->cu.cu_transquant_bypass_flag)
1428 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1434 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1436 //TODO: non-4:2:0 support
1437 HEVCLocalContext *lc = &s->HEVClc;
1439 int cb_size = 1 << log2_cb_size;
1440 ptrdiff_t stride0 = s->frame->linesize[0];
1441 ptrdiff_t stride1 = s->frame->linesize[1];
1442 ptrdiff_t stride2 = s->frame->linesize[2];
1443 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->ps.sps->pixel_shift)];
1444 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)];
1445 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)];
1447 int length = cb_size * cb_size * s->ps.sps->pcm.bit_depth + ((cb_size * cb_size) >> 1) * s->ps.sps->pcm.bit_depth_chroma;
1448 const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1451 if (!s->sh.disable_deblocking_filter_flag)
1452 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1454 ret = init_get_bits(&gb, pcm, length);
1458 s->hevcdsp.put_pcm(dst0, stride0, cb_size, &gb, s->ps.sps->pcm.bit_depth);
1459 s->hevcdsp.put_pcm(dst1, stride1, cb_size / 2, &gb, s->ps.sps->pcm.bit_depth_chroma);
1460 s->hevcdsp.put_pcm(dst2, stride2, cb_size / 2, &gb, s->ps.sps->pcm.bit_depth_chroma);
1464 static void hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1466 HEVCLocalContext *lc = &s->HEVClc;
1467 int x = ff_hevc_abs_mvd_greater0_flag_decode(s);
1468 int y = ff_hevc_abs_mvd_greater0_flag_decode(s);
1471 x += ff_hevc_abs_mvd_greater1_flag_decode(s);
1473 y += ff_hevc_abs_mvd_greater1_flag_decode(s);
1476 case 2: lc->pu.mvd.x = ff_hevc_mvd_decode(s); break;
1477 case 1: lc->pu.mvd.x = ff_hevc_mvd_sign_flag_decode(s); break;
1478 case 0: lc->pu.mvd.x = 0; break;
1482 case 2: lc->pu.mvd.y = ff_hevc_mvd_decode(s); break;
1483 case 1: lc->pu.mvd.y = ff_hevc_mvd_sign_flag_decode(s); break;
1484 case 0: lc->pu.mvd.y = 0; break;
1489 * 8.5.3.2.2.1 Luma sample interpolation process
1491 * @param s HEVC decoding context
1492 * @param dst target buffer for block data at block position
1493 * @param dststride stride of the dst buffer
1494 * @param ref reference picture buffer at origin (0, 0)
1495 * @param mv motion vector (relative to block position) to get pixel data from
1496 * @param x_off horizontal position of block from origin (0, 0)
1497 * @param y_off vertical position of block from origin (0, 0)
1498 * @param block_w width of block
1499 * @param block_h height of block
1501 static void luma_mc(HEVCContext *s, int16_t *dst, ptrdiff_t dststride,
1502 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1503 int block_w, int block_h, int pred_idx)
1505 HEVCLocalContext *lc = &s->HEVClc;
1506 uint8_t *src = ref->data[0];
1507 ptrdiff_t srcstride = ref->linesize[0];
1508 int pic_width = s->ps.sps->width;
1509 int pic_height = s->ps.sps->height;
1513 int extra_left = ff_hevc_qpel_extra_before[mx];
1514 int extra_top = ff_hevc_qpel_extra_before[my];
1516 x_off += mv->x >> 2;
1517 y_off += mv->y >> 2;
1518 src += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1520 if (x_off < extra_left || y_off < extra_top ||
1521 x_off >= pic_width - block_w - ff_hevc_qpel_extra_after[mx] ||
1522 y_off >= pic_height - block_h - ff_hevc_qpel_extra_after[my]) {
1523 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1524 int offset = extra_top * srcstride + (extra_left << s->ps.sps->pixel_shift);
1525 int buf_offset = extra_top *
1526 edge_emu_stride + (extra_left << s->ps.sps->pixel_shift);
1528 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1529 edge_emu_stride, srcstride,
1530 block_w + ff_hevc_qpel_extra[mx],
1531 block_h + ff_hevc_qpel_extra[my],
1532 x_off - extra_left, y_off - extra_top,
1533 pic_width, pic_height);
1534 src = lc->edge_emu_buffer + buf_offset;
1535 srcstride = edge_emu_stride;
1537 s->hevcdsp.put_hevc_qpel[!!my][!!mx][pred_idx](dst, dststride, src, srcstride,
1538 block_h, mx, my, lc->mc_buffer);
1542 * 8.5.3.2.2.2 Chroma sample interpolation process
1544 * @param s HEVC decoding context
1545 * @param dst1 target buffer for block data at block position (U plane)
1546 * @param dst2 target buffer for block data at block position (V plane)
1547 * @param dststride stride of the dst1 and dst2 buffers
1548 * @param ref reference picture buffer at origin (0, 0)
1549 * @param mv motion vector (relative to block position) to get pixel data from
1550 * @param x_off horizontal position of block from origin (0, 0)
1551 * @param y_off vertical position of block from origin (0, 0)
1552 * @param block_w width of block
1553 * @param block_h height of block
1555 static void chroma_mc(HEVCContext *s, int16_t *dst1, int16_t *dst2,
1556 ptrdiff_t dststride, AVFrame *ref, const Mv *mv,
1557 int x_off, int y_off, int block_w, int block_h, int pred_idx)
1559 HEVCLocalContext *lc = &s->HEVClc;
1560 uint8_t *src1 = ref->data[1];
1561 uint8_t *src2 = ref->data[2];
1562 ptrdiff_t src1stride = ref->linesize[1];
1563 ptrdiff_t src2stride = ref->linesize[2];
1564 int pic_width = s->ps.sps->width >> 1;
1565 int pic_height = s->ps.sps->height >> 1;
1570 x_off += mv->x >> 3;
1571 y_off += mv->y >> 3;
1572 src1 += y_off * src1stride + (x_off * (1 << s->ps.sps->pixel_shift));
1573 src2 += y_off * src2stride + (x_off * (1 << s->ps.sps->pixel_shift));
1575 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1576 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1577 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1578 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1579 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->ps.sps->pixel_shift));
1580 int buf_offset1 = EPEL_EXTRA_BEFORE *
1581 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1582 int offset2 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->ps.sps->pixel_shift));
1583 int buf_offset2 = EPEL_EXTRA_BEFORE *
1584 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1586 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1587 edge_emu_stride, src1stride,
1588 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1589 x_off - EPEL_EXTRA_BEFORE,
1590 y_off - EPEL_EXTRA_BEFORE,
1591 pic_width, pic_height);
1593 src1 = lc->edge_emu_buffer + buf_offset1;
1594 src1stride = edge_emu_stride;
1595 s->hevcdsp.put_hevc_epel[!!my][!!mx][pred_idx](dst1, dststride, src1, src1stride,
1596 block_h, mx, my, lc->mc_buffer);
1598 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src2 - offset2,
1599 edge_emu_stride, src2stride,
1600 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1601 x_off - EPEL_EXTRA_BEFORE,
1602 y_off - EPEL_EXTRA_BEFORE,
1603 pic_width, pic_height);
1604 src2 = lc->edge_emu_buffer + buf_offset2;
1605 src2stride = edge_emu_stride;
1607 s->hevcdsp.put_hevc_epel[!!my][!!mx][pred_idx](dst2, dststride, src2, src2stride,
1608 block_h, mx, my, lc->mc_buffer);
1610 s->hevcdsp.put_hevc_epel[!!my][!!mx][pred_idx](dst1, dststride, src1, src1stride,
1611 block_h, mx, my, lc->mc_buffer);
1612 s->hevcdsp.put_hevc_epel[!!my][!!mx][pred_idx](dst2, dststride, src2, src2stride,
1613 block_h, mx, my, lc->mc_buffer);
1617 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1618 const Mv *mv, int y0, int height)
1620 int y = (mv->y >> 2) + y0 + height + 9;
1621 ff_thread_await_progress(&ref->tf, y, 0);
1624 static void hevc_luma_mv_mpv_mode(HEVCContext *s, int x0, int y0, int nPbW,
1625 int nPbH, int log2_cb_size, int part_idx,
1626 int merge_idx, MvField *mv)
1628 HEVCLocalContext *lc = &s->HEVClc;
1629 enum InterPredIdc inter_pred_idc = PRED_L0;
1632 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1633 if (s->sh.slice_type == HEVC_SLICE_B)
1634 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1636 if (inter_pred_idc != PRED_L1) {
1637 if (s->sh.nb_refs[L0])
1638 mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1640 mv->pred_flag[0] = 1;
1641 hls_mvd_coding(s, x0, y0, 0);
1642 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1643 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1644 part_idx, merge_idx, mv, mvp_flag, 0);
1645 mv->mv[0].x += lc->pu.mvd.x;
1646 mv->mv[0].y += lc->pu.mvd.y;
1649 if (inter_pred_idc != PRED_L0) {
1650 if (s->sh.nb_refs[L1])
1651 mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1653 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1654 AV_ZERO32(&lc->pu.mvd);
1656 hls_mvd_coding(s, x0, y0, 1);
1659 mv->pred_flag[1] = 1;
1660 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1661 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1662 part_idx, merge_idx, mv, mvp_flag, 1);
1663 mv->mv[1].x += lc->pu.mvd.x;
1664 mv->mv[1].y += lc->pu.mvd.y;
1668 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1670 int log2_cb_size, int partIdx)
1672 static const int pred_indices[] = {
1673 [4] = 0, [8] = 1, [12] = 2, [16] = 3, [24] = 4, [32] = 5, [48] = 6, [64] = 7,
1675 const int pred_idx = pred_indices[nPbW];
1677 #define POS(c_idx, x, y) \
1678 &s->frame->data[c_idx][((y) >> s->ps.sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1679 (((x) >> s->ps.sps->hshift[c_idx]) << s->ps.sps->pixel_shift)]
1680 HEVCLocalContext *lc = &s->HEVClc;
1682 struct MvField current_mv = {{{ 0 }}};
1684 int min_pu_width = s->ps.sps->min_pu_width;
1685 int weighted_pred = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1686 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1688 MvField *tab_mvf = s->ref->tab_mvf;
1689 RefPicList *refPicList = s->ref->refPicList;
1690 HEVCFrame *ref0, *ref1;
1692 ptrdiff_t tmpstride = MAX_PB_SIZE * sizeof(int16_t);
1694 uint8_t *dst0 = POS(0, x0, y0);
1695 uint8_t *dst1 = POS(1, x0, y0);
1696 uint8_t *dst2 = POS(2, x0, y0);
1697 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
1698 int min_cb_width = s->ps.sps->min_cb_width;
1699 int x_cb = x0 >> log2_min_cb_size;
1700 int y_cb = y0 >> log2_min_cb_size;
1704 int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1707 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1709 if (skip_flag || lc->pu.merge_flag) {
1710 if (s->sh.max_num_merge_cand > 1)
1711 merge_idx = ff_hevc_merge_idx_decode(s);
1715 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1716 partIdx, merge_idx, ¤t_mv);
1718 hevc_luma_mv_mpv_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1719 partIdx, merge_idx, ¤t_mv);
1722 x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1723 y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1725 for (j = 0; j < nPbH >> s->ps.sps->log2_min_pu_size; j++)
1726 for (i = 0; i < nPbW >> s->ps.sps->log2_min_pu_size; i++)
1727 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1729 if (current_mv.pred_flag[0]) {
1730 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1733 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1735 if (current_mv.pred_flag[1]) {
1736 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1739 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1742 if (current_mv.pred_flag[0] && !current_mv.pred_flag[1]) {
1743 DECLARE_ALIGNED(16, int16_t, tmp[MAX_PB_SIZE * MAX_PB_SIZE]);
1744 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1746 luma_mc(s, tmp, tmpstride, ref0->frame,
1747 ¤t_mv.mv[0], x0, y0, nPbW, nPbH, pred_idx);
1749 if (weighted_pred) {
1750 s->hevcdsp.weighted_pred[pred_idx](s->sh.luma_log2_weight_denom,
1751 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1752 s->sh.luma_offset_l0[current_mv.ref_idx[0]],
1753 dst0, s->frame->linesize[0], tmp,
1756 s->hevcdsp.put_unweighted_pred[pred_idx](dst0, s->frame->linesize[0], tmp, tmpstride, nPbH);
1758 chroma_mc(s, tmp, tmp2, tmpstride, ref0->frame,
1759 ¤t_mv.mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2, pred_idx);
1761 if (weighted_pred) {
1762 s->hevcdsp.weighted_pred_chroma[pred_idx](s->sh.chroma_log2_weight_denom,
1763 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0],
1764 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0],
1765 dst1, s->frame->linesize[1], tmp, tmpstride,
1767 s->hevcdsp.weighted_pred_chroma[pred_idx](s->sh.chroma_log2_weight_denom,
1768 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1],
1769 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1],
1770 dst2, s->frame->linesize[2], tmp2, tmpstride,
1773 s->hevcdsp.put_unweighted_pred_chroma[pred_idx](dst1, s->frame->linesize[1], tmp, tmpstride, nPbH / 2);
1774 s->hevcdsp.put_unweighted_pred_chroma[pred_idx](dst2, s->frame->linesize[2], tmp2, tmpstride, nPbH / 2);
1776 } else if (!current_mv.pred_flag[0] && current_mv.pred_flag[1]) {
1777 DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1778 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1780 luma_mc(s, tmp, tmpstride, ref1->frame,
1781 ¤t_mv.mv[1], x0, y0, nPbW, nPbH, pred_idx);
1783 if (weighted_pred) {
1784 s->hevcdsp.weighted_pred[pred_idx](s->sh.luma_log2_weight_denom,
1785 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1786 s->sh.luma_offset_l1[current_mv.ref_idx[1]],
1787 dst0, s->frame->linesize[0], tmp, tmpstride,
1790 s->hevcdsp.put_unweighted_pred[pred_idx](dst0, s->frame->linesize[0], tmp, tmpstride, nPbH);
1793 chroma_mc(s, tmp, tmp2, tmpstride, ref1->frame,
1794 ¤t_mv.mv[1], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2, pred_idx);
1796 if (weighted_pred) {
1797 s->hevcdsp.weighted_pred_chroma[pred_idx](s->sh.chroma_log2_weight_denom,
1798 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0],
1799 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0],
1800 dst1, s->frame->linesize[1], tmp, tmpstride, nPbH/2);
1801 s->hevcdsp.weighted_pred_chroma[pred_idx](s->sh.chroma_log2_weight_denom,
1802 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1],
1803 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1],
1804 dst2, s->frame->linesize[2], tmp2, tmpstride, nPbH/2);
1806 s->hevcdsp.put_unweighted_pred_chroma[pred_idx](dst1, s->frame->linesize[1], tmp, tmpstride, nPbH / 2);
1807 s->hevcdsp.put_unweighted_pred_chroma[pred_idx](dst2, s->frame->linesize[2], tmp2, tmpstride, nPbH / 2);
1809 } else if (current_mv.pred_flag[0] && current_mv.pred_flag[1]) {
1810 DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1811 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1812 DECLARE_ALIGNED(16, int16_t, tmp3[MAX_PB_SIZE * MAX_PB_SIZE]);
1813 DECLARE_ALIGNED(16, int16_t, tmp4[MAX_PB_SIZE * MAX_PB_SIZE]);
1815 luma_mc(s, tmp, tmpstride, ref0->frame,
1816 ¤t_mv.mv[0], x0, y0, nPbW, nPbH, pred_idx);
1817 luma_mc(s, tmp2, tmpstride, ref1->frame,
1818 ¤t_mv.mv[1], x0, y0, nPbW, nPbH, pred_idx);
1820 if (weighted_pred) {
1821 s->hevcdsp.weighted_pred_avg[pred_idx](s->sh.luma_log2_weight_denom,
1822 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1823 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1824 s->sh.luma_offset_l0[current_mv.ref_idx[0]],
1825 s->sh.luma_offset_l1[current_mv.ref_idx[1]],
1826 dst0, s->frame->linesize[0],
1827 tmp, tmp2, tmpstride, nPbH);
1829 s->hevcdsp.put_unweighted_pred_avg[pred_idx](dst0, s->frame->linesize[0],
1830 tmp, tmp2, tmpstride, nPbH);
1833 chroma_mc(s, tmp, tmp2, tmpstride, ref0->frame,
1834 ¤t_mv.mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2, pred_idx);
1835 chroma_mc(s, tmp3, tmp4, tmpstride, ref1->frame,
1836 ¤t_mv.mv[1], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2, pred_idx);
1838 if (weighted_pred) {
1839 s->hevcdsp.weighted_pred_avg_chroma[pred_idx](s->sh.chroma_log2_weight_denom,
1840 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0],
1841 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0],
1842 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0],
1843 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0],
1844 dst1, s->frame->linesize[1], tmp, tmp3,
1845 tmpstride, nPbH / 2);
1846 s->hevcdsp.weighted_pred_avg_chroma[pred_idx](s->sh.chroma_log2_weight_denom,
1847 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1],
1848 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1],
1849 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1],
1850 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1],
1851 dst2, s->frame->linesize[2], tmp2, tmp4,
1852 tmpstride, nPbH / 2);
1854 s->hevcdsp.put_unweighted_pred_avg_chroma[pred_idx](dst1, s->frame->linesize[1], tmp, tmp3, tmpstride, nPbH/2);
1855 s->hevcdsp.put_unweighted_pred_avg_chroma[pred_idx](dst2, s->frame->linesize[2], tmp2, tmp4, tmpstride, nPbH/2);
1863 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1864 int prev_intra_luma_pred_flag)
1866 HEVCLocalContext *lc = &s->HEVClc;
1867 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1868 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1869 int min_pu_width = s->ps.sps->min_pu_width;
1870 int size_in_pus = pu_size >> s->ps.sps->log2_min_pu_size;
1871 int x0b = x0 & ((1 << s->ps.sps->log2_ctb_size) - 1);
1872 int y0b = y0 & ((1 << s->ps.sps->log2_ctb_size) - 1);
1874 int cand_up = (lc->ctb_up_flag || y0b) ?
1875 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1876 int cand_left = (lc->ctb_left_flag || x0b) ?
1877 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1879 int y_ctb = (y0 >> (s->ps.sps->log2_ctb_size)) << (s->ps.sps->log2_ctb_size);
1881 MvField *tab_mvf = s->ref->tab_mvf;
1882 int intra_pred_mode;
1886 // intra_pred_mode prediction does not cross vertical CTB boundaries
1887 if ((y0 - 1) < y_ctb)
1890 if (cand_left == cand_up) {
1891 if (cand_left < 2) {
1892 candidate[0] = INTRA_PLANAR;
1893 candidate[1] = INTRA_DC;
1894 candidate[2] = INTRA_ANGULAR_26;
1896 candidate[0] = cand_left;
1897 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1898 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1901 candidate[0] = cand_left;
1902 candidate[1] = cand_up;
1903 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1904 candidate[2] = INTRA_PLANAR;
1905 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1906 candidate[2] = INTRA_DC;
1908 candidate[2] = INTRA_ANGULAR_26;
1912 if (prev_intra_luma_pred_flag) {
1913 intra_pred_mode = candidate[lc->pu.mpm_idx];
1915 if (candidate[0] > candidate[1])
1916 FFSWAP(uint8_t, candidate[0], candidate[1]);
1917 if (candidate[0] > candidate[2])
1918 FFSWAP(uint8_t, candidate[0], candidate[2]);
1919 if (candidate[1] > candidate[2])
1920 FFSWAP(uint8_t, candidate[1], candidate[2]);
1922 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1923 for (i = 0; i < 3; i++)
1924 if (intra_pred_mode >= candidate[i])
1928 /* write the intra prediction units into the mv array */
1931 for (i = 0; i < size_in_pus; i++) {
1932 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1933 intra_pred_mode, size_in_pus);
1935 for (j = 0; j < size_in_pus; j++) {
1936 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].is_intra = 1;
1937 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[0] = 0;
1938 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[1] = 0;
1939 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[0] = 0;
1940 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[1] = 0;
1941 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].x = 0;
1942 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].y = 0;
1943 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].x = 0;
1944 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].y = 0;
1948 return intra_pred_mode;
1951 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1952 int log2_cb_size, int ct_depth)
1954 int length = (1 << log2_cb_size) >> s->ps.sps->log2_min_cb_size;
1955 int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
1956 int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
1959 for (y = 0; y < length; y++)
1960 memset(&s->tab_ct_depth[(y_cb + y) * s->ps.sps->min_cb_width + x_cb],
1964 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1967 HEVCLocalContext *lc = &s->HEVClc;
1968 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1969 uint8_t prev_intra_luma_pred_flag[4];
1970 int split = lc->cu.part_mode == PART_NxN;
1971 int pb_size = (1 << log2_cb_size) >> split;
1972 int side = split + 1;
1976 for (i = 0; i < side; i++)
1977 for (j = 0; j < side; j++)
1978 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1980 for (i = 0; i < side; i++) {
1981 for (j = 0; j < side; j++) {
1982 if (prev_intra_luma_pred_flag[2 * i + j])
1983 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
1985 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
1987 lc->pu.intra_pred_mode[2 * i + j] =
1988 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1989 prev_intra_luma_pred_flag[2 * i + j]);
1993 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1994 if (chroma_mode != 4) {
1995 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1996 lc->pu.intra_pred_mode_c = 34;
1998 lc->pu.intra_pred_mode_c = intra_chroma_table[chroma_mode];
2000 lc->pu.intra_pred_mode_c = lc->pu.intra_pred_mode[0];
2004 static void intra_prediction_unit_default_value(HEVCContext *s,
2008 HEVCLocalContext *lc = &s->HEVClc;
2009 int pb_size = 1 << log2_cb_size;
2010 int size_in_pus = pb_size >> s->ps.sps->log2_min_pu_size;
2011 int min_pu_width = s->ps.sps->min_pu_width;
2012 MvField *tab_mvf = s->ref->tab_mvf;
2013 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
2014 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
2017 if (size_in_pus == 0)
2019 for (j = 0; j < size_in_pus; j++) {
2020 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
2021 for (k = 0; k < size_in_pus; k++)
2022 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].is_intra = lc->cu.pred_mode == MODE_INTRA;
2026 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
2028 int cb_size = 1 << log2_cb_size;
2029 HEVCLocalContext *lc = &s->HEVClc;
2030 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
2031 int length = cb_size >> log2_min_cb_size;
2032 int min_cb_width = s->ps.sps->min_cb_width;
2033 int x_cb = x0 >> log2_min_cb_size;
2034 int y_cb = y0 >> log2_min_cb_size;
2039 lc->cu.pred_mode = MODE_INTRA;
2040 lc->cu.part_mode = PART_2Nx2N;
2041 lc->cu.intra_split_flag = 0;
2043 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
2044 for (x = 0; x < 4; x++)
2045 lc->pu.intra_pred_mode[x] = 1;
2046 if (s->ps.pps->transquant_bypass_enable_flag) {
2047 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
2048 if (lc->cu.cu_transquant_bypass_flag)
2049 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2051 lc->cu.cu_transquant_bypass_flag = 0;
2053 if (s->sh.slice_type != HEVC_SLICE_I) {
2054 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
2056 x = y_cb * min_cb_width + x_cb;
2057 for (y = 0; y < length; y++) {
2058 memset(&s->skip_flag[x], skip_flag, length);
2061 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2064 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2065 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0);
2066 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2068 if (!s->sh.disable_deblocking_filter_flag)
2069 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2073 if (s->sh.slice_type != HEVC_SLICE_I)
2074 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2075 if (lc->cu.pred_mode != MODE_INTRA ||
2076 log2_cb_size == s->ps.sps->log2_min_cb_size) {
2077 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2078 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2079 lc->cu.pred_mode == MODE_INTRA;
2082 if (lc->cu.pred_mode == MODE_INTRA) {
2083 if (lc->cu.part_mode == PART_2Nx2N && s->ps.sps->pcm_enabled_flag &&
2084 log2_cb_size >= s->ps.sps->pcm.log2_min_pcm_cb_size &&
2085 log2_cb_size <= s->ps.sps->pcm.log2_max_pcm_cb_size) {
2086 pcm_flag = ff_hevc_pcm_flag_decode(s);
2089 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2090 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2091 if (s->ps.sps->pcm.loop_filter_disable_flag)
2092 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2097 intra_prediction_unit(s, x0, y0, log2_cb_size);
2100 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2101 switch (lc->cu.part_mode) {
2103 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0);
2106 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0);
2107 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1);
2110 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0);
2111 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1);
2114 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0);
2115 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1);
2118 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0);
2119 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1);
2122 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0);
2123 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1);
2126 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0);
2127 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1);
2130 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0);
2131 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1);
2132 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2);
2133 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3);
2139 int rqt_root_cbf = 1;
2141 if (lc->cu.pred_mode != MODE_INTRA &&
2142 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2143 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2146 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2147 s->ps.sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2148 s->ps.sps->max_transform_hierarchy_depth_inter;
2149 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2151 log2_cb_size, 0, 0, 0, 0);
2155 if (!s->sh.disable_deblocking_filter_flag)
2156 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2161 if (s->ps.pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2162 ff_hevc_set_qPy(s, x0, y0, x0, y0, log2_cb_size);
2164 x = y_cb * min_cb_width + x_cb;
2165 for (y = 0; y < length; y++) {
2166 memset(&s->qp_y_tab[x], lc->qp_y, length);
2170 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct.depth);
2175 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2176 int log2_cb_size, int cb_depth)
2178 HEVCLocalContext *lc = &s->HEVClc;
2179 const int cb_size = 1 << log2_cb_size;
2182 lc->ct.depth = cb_depth;
2183 if (x0 + cb_size <= s->ps.sps->width &&
2184 y0 + cb_size <= s->ps.sps->height &&
2185 log2_cb_size > s->ps.sps->log2_min_cb_size) {
2186 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2188 split_cu = (log2_cb_size > s->ps.sps->log2_min_cb_size);
2190 if (s->ps.pps->cu_qp_delta_enabled_flag &&
2191 log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth) {
2192 lc->tu.is_cu_qp_delta_coded = 0;
2193 lc->tu.cu_qp_delta = 0;
2197 const int cb_size_split = cb_size >> 1;
2198 const int x1 = x0 + cb_size_split;
2199 const int y1 = y0 + cb_size_split;
2204 #define SUBDIVIDE(x, y) \
2206 if (x < s->ps.sps->width && y < s->ps.sps->height) { \
2207 int ret = hls_coding_quadtree(s, x, y, log2_cb_size, cb_depth);\
2218 int ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2226 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2229 HEVCLocalContext *lc = &s->HEVClc;
2230 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2231 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2232 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2234 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2236 if (s->ps.pps->entropy_coding_sync_enabled_flag) {
2237 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2238 lc->first_qp_group = 1;
2239 lc->end_of_tiles_x = s->ps.sps->width;
2240 } else if (s->ps.pps->tiles_enabled_flag) {
2241 if (ctb_addr_ts && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
2242 int idxX = s->ps.pps->col_idxX[x_ctb >> s->ps.sps->log2_ctb_size];
2243 lc->start_of_tiles_x = x_ctb;
2244 lc->end_of_tiles_x = x_ctb + (s->ps.pps->column_width[idxX] << s->ps.sps->log2_ctb_size);
2245 lc->first_qp_group = 1;
2248 lc->end_of_tiles_x = s->ps.sps->width;
2251 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->ps.sps->height);
2253 lc->boundary_flags = 0;
2254 if (s->ps.pps->tiles_enabled_flag) {
2255 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]])
2256 lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2257 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2258 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2259 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]])
2260 lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2261 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->ps.sps->ctb_width])
2262 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2264 if (!ctb_addr_in_slice)
2265 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2266 if (ctb_addr_in_slice < s->ps.sps->ctb_width)
2267 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2270 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2271 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->ps.sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2272 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]]));
2273 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]]));
2276 static int hls_slice_data(HEVCContext *s)
2278 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2282 int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2285 while (more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2286 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2288 x_ctb = (ctb_addr_rs % ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2289 y_ctb = (ctb_addr_rs / ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.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->ps.sps->log2_ctb_size, y_ctb >> s->ps.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 ret = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2303 more_data = !ff_hevc_end_of_slice_flag_decode(s);
2306 ff_hevc_save_states(s, ctb_addr_ts);
2307 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2310 if (x_ctb + ctb_size >= s->ps.sps->width &&
2311 y_ctb + ctb_size >= s->ps.sps->height)
2312 ff_hevc_hls_filter(s, x_ctb, y_ctb);
2317 static void restore_tqb_pixels(HEVCContext *s)
2319 int min_pu_size = 1 << s->ps.sps->log2_min_pu_size;
2322 for (c_idx = 0; c_idx < 3; c_idx++) {
2323 ptrdiff_t stride = s->frame->linesize[c_idx];
2324 int hshift = s->ps.sps->hshift[c_idx];
2325 int vshift = s->ps.sps->vshift[c_idx];
2326 for (y = 0; y < s->ps.sps->min_pu_height; y++) {
2327 for (x = 0; x < s->ps.sps->min_pu_width; x++) {
2328 if (s->is_pcm[y * s->ps.sps->min_pu_width + x]) {
2330 int len = min_pu_size >> hshift;
2331 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)];
2332 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)];
2333 for (n = 0; n < (min_pu_size >> vshift); n++) {
2334 memcpy(dst, src, len);
2344 static int set_side_data(HEVCContext *s)
2346 AVFrame *out = s->ref->frame;
2348 if (s->sei_frame_packing_present &&
2349 s->frame_packing_arrangement_type >= 3 &&
2350 s->frame_packing_arrangement_type <= 5 &&
2351 s->content_interpretation_type > 0 &&
2352 s->content_interpretation_type < 3) {
2353 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2355 return AVERROR(ENOMEM);
2357 switch (s->frame_packing_arrangement_type) {
2359 if (s->quincunx_subsampling)
2360 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2362 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2365 stereo->type = AV_STEREO3D_TOPBOTTOM;
2368 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2372 if (s->content_interpretation_type == 2)
2373 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2376 if (s->sei_display_orientation_present &&
2377 (s->sei_anticlockwise_rotation || s->sei_hflip || s->sei_vflip)) {
2378 double angle = s->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
2379 AVFrameSideData *rotation = av_frame_new_side_data(out,
2380 AV_FRAME_DATA_DISPLAYMATRIX,
2381 sizeof(int32_t) * 9);
2383 return AVERROR(ENOMEM);
2385 av_display_rotation_set((int32_t *)rotation->data, angle);
2386 av_display_matrix_flip((int32_t *)rotation->data,
2387 s->sei_hflip, s->sei_vflip);
2393 static int hevc_frame_start(HEVCContext *s)
2395 HEVCLocalContext *lc = &s->HEVClc;
2398 memset(s->horizontal_bs, 0, 2 * s->bs_width * (s->bs_height + 1));
2399 memset(s->vertical_bs, 0, 2 * s->bs_width * (s->bs_height + 1));
2400 memset(s->cbf_luma, 0, s->ps.sps->min_tb_width * s->ps.sps->min_tb_height);
2401 memset(s->is_pcm, 0, s->ps.sps->min_pu_width * s->ps.sps->min_pu_height);
2403 lc->start_of_tiles_x = 0;
2405 s->first_nal_type = s->nal_unit_type;
2407 if (s->ps.pps->tiles_enabled_flag)
2408 lc->end_of_tiles_x = s->ps.pps->column_width[0] << s->ps.sps->log2_ctb_size;
2410 ret = ff_hevc_set_new_ref(s, s->ps.sps->sao_enabled ? &s->sao_frame : &s->frame,
2415 ret = ff_hevc_frame_rps(s);
2417 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2421 s->ref->frame->key_frame = IS_IRAP(s);
2423 ret = set_side_data(s);
2427 av_frame_unref(s->output_frame);
2428 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2432 ff_thread_finish_setup(s->avctx);
2438 ff_hevc_unref_frame(s, s->ref, ~0);
2443 static int decode_nal_unit(HEVCContext *s, const H2645NAL *nal)
2445 HEVCLocalContext *lc = &s->HEVClc;
2446 GetBitContext *gb = &lc->gb;
2447 int ctb_addr_ts, ret;
2450 s->nal_unit_type = nal->type;
2451 s->temporal_id = nal->temporal_id;
2453 switch (s->nal_unit_type) {
2455 ret = ff_hevc_decode_nal_vps(gb, s->avctx, &s->ps);
2460 ret = ff_hevc_decode_nal_sps(gb, s->avctx, &s->ps,
2461 s->apply_defdispwin);
2466 ret = ff_hevc_decode_nal_pps(gb, s->avctx, &s->ps);
2470 case HEVC_NAL_SEI_PREFIX:
2471 case HEVC_NAL_SEI_SUFFIX:
2472 ret = ff_hevc_decode_nal_sei(s);
2476 case HEVC_NAL_TRAIL_R:
2477 case HEVC_NAL_TRAIL_N:
2478 case HEVC_NAL_TSA_N:
2479 case HEVC_NAL_TSA_R:
2480 case HEVC_NAL_STSA_N:
2481 case HEVC_NAL_STSA_R:
2482 case HEVC_NAL_BLA_W_LP:
2483 case HEVC_NAL_BLA_W_RADL:
2484 case HEVC_NAL_BLA_N_LP:
2485 case HEVC_NAL_IDR_W_RADL:
2486 case HEVC_NAL_IDR_N_LP:
2487 case HEVC_NAL_CRA_NUT:
2488 case HEVC_NAL_RADL_N:
2489 case HEVC_NAL_RADL_R:
2490 case HEVC_NAL_RASL_N:
2491 case HEVC_NAL_RASL_R:
2492 ret = hls_slice_header(s);
2496 if (s->max_ra == INT_MAX) {
2497 if (s->nal_unit_type == HEVC_NAL_CRA_NUT || IS_BLA(s)) {
2501 s->max_ra = INT_MIN;
2505 if ((s->nal_unit_type == HEVC_NAL_RASL_R || s->nal_unit_type == HEVC_NAL_RASL_N) &&
2506 s->poc <= s->max_ra) {
2510 if (s->nal_unit_type == HEVC_NAL_RASL_R && s->poc > s->max_ra)
2511 s->max_ra = INT_MIN;
2514 if (s->sh.first_slice_in_pic_flag) {
2515 ret = hevc_frame_start(s);
2518 } else if (!s->ref) {
2519 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2523 if (s->nal_unit_type != s->first_nal_type) {
2524 av_log(s->avctx, AV_LOG_ERROR,
2525 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2526 s->first_nal_type, s->nal_unit_type);
2527 return AVERROR_INVALIDDATA;
2530 if (!s->sh.dependent_slice_segment_flag &&
2531 s->sh.slice_type != HEVC_SLICE_I) {
2532 ret = ff_hevc_slice_rpl(s);
2534 av_log(s->avctx, AV_LOG_WARNING,
2535 "Error constructing the reference lists for the current slice.\n");
2540 if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) {
2541 ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0);
2546 if (s->avctx->hwaccel) {
2547 ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size);
2551 ctb_addr_ts = hls_slice_data(s);
2552 if (ctb_addr_ts >= (s->ps.sps->ctb_width * s->ps.sps->ctb_height)) {
2554 if ((s->ps.pps->transquant_bypass_enable_flag ||
2555 (s->ps.sps->pcm.loop_filter_disable_flag && s->ps.sps->pcm_enabled_flag)) &&
2556 s->ps.sps->sao_enabled)
2557 restore_tqb_pixels(s);
2560 if (ctb_addr_ts < 0) {
2566 case HEVC_NAL_EOS_NUT:
2567 case HEVC_NAL_EOB_NUT:
2568 s->seq_decode = (s->seq_decode + 1) & 0xff;
2569 s->max_ra = INT_MAX;
2572 case HEVC_NAL_FD_NUT:
2575 av_log(s->avctx, AV_LOG_INFO,
2576 "Skipping NAL unit %d\n", s->nal_unit_type);
2581 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2586 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2593 /* split the input packet into NAL units, so we know the upper bound on the
2594 * number of slices in the frame */
2595 ret = ff_h2645_packet_split(&s->pkt, buf, length, s->avctx, s->is_nalff,
2596 s->nal_length_size, s->avctx->codec_id);
2598 av_log(s->avctx, AV_LOG_ERROR,
2599 "Error splitting the input into NAL units.\n");
2603 for (i = 0; i < s->pkt.nb_nals; i++) {
2604 if (s->pkt.nals[i].type == HEVC_NAL_EOB_NUT ||
2605 s->pkt.nals[i].type == HEVC_NAL_EOS_NUT)
2609 /* decode the NAL units */
2610 for (i = 0; i < s->pkt.nb_nals; i++) {
2611 ret = decode_nal_unit(s, &s->pkt.nals[i]);
2613 av_log(s->avctx, AV_LOG_WARNING,
2614 "Error parsing NAL unit #%d.\n", i);
2621 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2626 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2629 for (i = 0; i < 16; i++)
2630 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
2633 static int verify_md5(HEVCContext *s, AVFrame *frame)
2635 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
2640 return AVERROR(EINVAL);
2642 pixel_shift = desc->comp[0].depth > 8;
2644 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
2647 /* the checksums are LE, so we have to byteswap for >8bpp formats
2650 if (pixel_shift && !s->checksum_buf) {
2651 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
2652 FFMAX3(frame->linesize[0], frame->linesize[1],
2653 frame->linesize[2]));
2654 if (!s->checksum_buf)
2655 return AVERROR(ENOMEM);
2659 for (i = 0; frame->data[i]; i++) {
2660 int width = s->avctx->coded_width;
2661 int height = s->avctx->coded_height;
2662 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
2663 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
2666 av_md5_init(s->md5_ctx);
2667 for (j = 0; j < h; j++) {
2668 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
2671 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
2672 (const uint16_t *) src, w);
2673 src = s->checksum_buf;
2676 av_md5_update(s->md5_ctx, src, w << pixel_shift);
2678 av_md5_final(s->md5_ctx, md5);
2680 if (!memcmp(md5, s->md5[i], 16)) {
2681 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
2682 print_md5(s->avctx, AV_LOG_DEBUG, md5);
2683 av_log (s->avctx, AV_LOG_DEBUG, "; ");
2685 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
2686 print_md5(s->avctx, AV_LOG_ERROR, md5);
2687 av_log (s->avctx, AV_LOG_ERROR, " != ");
2688 print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
2689 av_log (s->avctx, AV_LOG_ERROR, "\n");
2690 return AVERROR_INVALIDDATA;
2694 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2699 static int hevc_decode_extradata(HEVCContext *s, uint8_t *buf, int length)
2701 AVCodecContext *avctx = s->avctx;
2705 bytestream2_init(&gb, buf, length);
2707 if (length > 3 && (buf[0] || buf[1] || buf[2] > 1)) {
2708 /* It seems the extradata is encoded as hvcC format.
2709 * Temporarily, we support configurationVersion==0 until 14496-15 3rd
2710 * is finalized. When finalized, configurationVersion will be 1 and we
2711 * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
2712 int i, j, num_arrays, nal_len_size;
2716 bytestream2_skip(&gb, 21);
2717 nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
2718 num_arrays = bytestream2_get_byte(&gb);
2720 /* nal units in the hvcC always have length coded with 2 bytes,
2721 * so put a fake nal_length_size = 2 while parsing them */
2722 s->nal_length_size = 2;
2724 /* Decode nal units from hvcC. */
2725 for (i = 0; i < num_arrays; i++) {
2726 int type = bytestream2_get_byte(&gb) & 0x3f;
2727 int cnt = bytestream2_get_be16(&gb);
2729 for (j = 0; j < cnt; j++) {
2730 // +2 for the nal size field
2731 int nalsize = bytestream2_peek_be16(&gb) + 2;
2732 if (bytestream2_get_bytes_left(&gb) < nalsize) {
2733 av_log(s->avctx, AV_LOG_ERROR,
2734 "Invalid NAL unit size in extradata.\n");
2735 return AVERROR_INVALIDDATA;
2738 ret = decode_nal_units(s, gb.buffer, nalsize);
2740 av_log(avctx, AV_LOG_ERROR,
2741 "Decoding nal unit %d %d from hvcC failed\n",
2745 bytestream2_skip(&gb, nalsize);
2749 /* Now store right nal length size, that will be used to parse
2751 s->nal_length_size = nal_len_size;
2754 ret = decode_nal_units(s, buf, length);
2759 /* export stream parameters from the first SPS */
2760 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
2761 if (s->ps.sps_list[i]) {
2762 const HEVCSPS *sps = (const HEVCSPS*)s->ps.sps_list[i]->data;
2763 export_stream_params(s->avctx, &s->ps, sps);
2771 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
2775 int new_extradata_size;
2776 uint8_t *new_extradata;
2777 HEVCContext *s = avctx->priv_data;
2780 ret = ff_hevc_output_frame(s, data, 1);
2788 new_extradata = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,
2789 &new_extradata_size);
2790 if (new_extradata && new_extradata_size > 0) {
2791 ret = hevc_decode_extradata(s, new_extradata, new_extradata_size);
2797 ret = decode_nal_units(s, avpkt->data, avpkt->size);
2801 if (avctx->hwaccel) {
2802 if (s->ref && avctx->hwaccel->end_frame(avctx) < 0)
2803 av_log(avctx, AV_LOG_ERROR,
2804 "hardware accelerator failed to decode picture\n");
2806 /* verify the SEI checksum */
2807 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
2809 ret = verify_md5(s, s->ref->frame);
2810 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
2811 ff_hevc_unref_frame(s, s->ref, ~0);
2818 if (s->is_decoded) {
2819 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
2823 if (s->output_frame->buf[0]) {
2824 av_frame_move_ref(data, s->output_frame);
2831 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
2833 int ret = ff_thread_ref_frame(&dst->tf, &src->tf);
2837 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
2838 if (!dst->tab_mvf_buf)
2840 dst->tab_mvf = src->tab_mvf;
2842 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
2843 if (!dst->rpl_tab_buf)
2845 dst->rpl_tab = src->rpl_tab;
2847 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
2851 dst->poc = src->poc;
2852 dst->ctb_count = src->ctb_count;
2853 dst->window = src->window;
2854 dst->flags = src->flags;
2855 dst->sequence = src->sequence;
2857 if (src->hwaccel_picture_private) {
2858 dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
2859 if (!dst->hwaccel_priv_buf)
2861 dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
2866 ff_hevc_unref_frame(s, dst, ~0);
2867 return AVERROR(ENOMEM);
2870 static av_cold int hevc_decode_free(AVCodecContext *avctx)
2872 HEVCContext *s = avctx->priv_data;
2877 av_freep(&s->md5_ctx);
2879 av_frame_free(&s->tmp_frame);
2880 av_frame_free(&s->output_frame);
2882 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2883 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
2884 av_frame_free(&s->DPB[i].frame);
2887 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++)
2888 av_buffer_unref(&s->ps.vps_list[i]);
2889 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++)
2890 av_buffer_unref(&s->ps.sps_list[i]);
2891 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++)
2892 av_buffer_unref(&s->ps.pps_list[i]);
2894 ff_h2645_packet_uninit(&s->pkt);
2899 static av_cold int hevc_init_context(AVCodecContext *avctx)
2901 HEVCContext *s = avctx->priv_data;
2906 s->tmp_frame = av_frame_alloc();
2910 s->output_frame = av_frame_alloc();
2911 if (!s->output_frame)
2914 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2915 s->DPB[i].frame = av_frame_alloc();
2916 if (!s->DPB[i].frame)
2918 s->DPB[i].tf.f = s->DPB[i].frame;
2921 s->max_ra = INT_MAX;
2923 s->md5_ctx = av_md5_alloc();
2927 ff_bswapdsp_init(&s->bdsp);
2929 s->context_initialized = 1;
2934 hevc_decode_free(avctx);
2935 return AVERROR(ENOMEM);
2938 static int hevc_update_thread_context(AVCodecContext *dst,
2939 const AVCodecContext *src)
2941 HEVCContext *s = dst->priv_data;
2942 HEVCContext *s0 = src->priv_data;
2945 if (!s->context_initialized) {
2946 ret = hevc_init_context(dst);
2951 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2952 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
2953 if (s0->DPB[i].frame->buf[0]) {
2954 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
2960 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++) {
2961 av_buffer_unref(&s->ps.vps_list[i]);
2962 if (s0->ps.vps_list[i]) {
2963 s->ps.vps_list[i] = av_buffer_ref(s0->ps.vps_list[i]);
2964 if (!s->ps.vps_list[i])
2965 return AVERROR(ENOMEM);
2969 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
2970 av_buffer_unref(&s->ps.sps_list[i]);
2971 if (s0->ps.sps_list[i]) {
2972 s->ps.sps_list[i] = av_buffer_ref(s0->ps.sps_list[i]);
2973 if (!s->ps.sps_list[i])
2974 return AVERROR(ENOMEM);
2978 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++) {
2979 av_buffer_unref(&s->ps.pps_list[i]);
2980 if (s0->ps.pps_list[i]) {
2981 s->ps.pps_list[i] = av_buffer_ref(s0->ps.pps_list[i]);
2982 if (!s->ps.pps_list[i])
2983 return AVERROR(ENOMEM);
2987 if (s->ps.sps != s0->ps.sps)
2988 ret = set_sps(s, s0->ps.sps);
2990 s->seq_decode = s0->seq_decode;
2991 s->seq_output = s0->seq_output;
2992 s->pocTid0 = s0->pocTid0;
2993 s->max_ra = s0->max_ra;
2995 s->is_nalff = s0->is_nalff;
2996 s->nal_length_size = s0->nal_length_size;
2999 s->seq_decode = (s->seq_decode + 1) & 0xff;
3000 s->max_ra = INT_MAX;
3006 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3008 HEVCContext *s = avctx->priv_data;
3011 avctx->internal->allocate_progress = 1;
3013 ret = hevc_init_context(avctx);
3017 if (avctx->extradata_size > 0 && avctx->extradata) {
3018 ret = hevc_decode_extradata(s, avctx->extradata, avctx->extradata_size);
3020 hevc_decode_free(avctx);
3028 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3030 HEVCContext *s = avctx->priv_data;
3033 memset(s, 0, sizeof(*s));
3035 ret = hevc_init_context(avctx);
3042 static void hevc_decode_flush(AVCodecContext *avctx)
3044 HEVCContext *s = avctx->priv_data;
3045 ff_hevc_flush_dpb(s);
3046 s->max_ra = INT_MAX;
3049 #define OFFSET(x) offsetof(HEVCContext, x)
3050 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3052 static const AVOption options[] = {
3053 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3054 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3058 static const AVClass hevc_decoder_class = {
3059 .class_name = "HEVC decoder",
3060 .item_name = av_default_item_name,
3062 .version = LIBAVUTIL_VERSION_INT,
3065 AVCodec ff_hevc_decoder = {
3067 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3068 .type = AVMEDIA_TYPE_VIDEO,
3069 .id = AV_CODEC_ID_HEVC,
3070 .priv_data_size = sizeof(HEVCContext),
3071 .priv_class = &hevc_decoder_class,
3072 .init = hevc_decode_init,
3073 .close = hevc_decode_free,
3074 .decode = hevc_decode_frame,
3075 .flush = hevc_decode_flush,
3076 .update_thread_context = hevc_update_thread_context,
3077 .init_thread_copy = hevc_init_thread_copy,
3078 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
3079 AV_CODEC_CAP_FRAME_THREADS,
3080 .profiles = NULL_IF_CONFIG_SMALL(ff_hevc_profiles),