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"
41 const uint8_t ff_hevc_qpel_extra_before[4] = { 0, 3, 3, 2 };
42 const uint8_t ff_hevc_qpel_extra_after[4] = { 0, 3, 4, 4 };
43 const uint8_t ff_hevc_qpel_extra[4] = { 0, 6, 7, 6 };
45 static const uint8_t scan_1x1[1] = { 0 };
47 static const uint8_t horiz_scan2x2_x[4] = { 0, 1, 0, 1 };
49 static const uint8_t horiz_scan2x2_y[4] = { 0, 0, 1, 1 };
51 static const uint8_t horiz_scan4x4_x[16] = {
58 static const uint8_t horiz_scan4x4_y[16] = {
65 static const uint8_t horiz_scan8x8_inv[8][8] = {
66 { 0, 1, 2, 3, 16, 17, 18, 19, },
67 { 4, 5, 6, 7, 20, 21, 22, 23, },
68 { 8, 9, 10, 11, 24, 25, 26, 27, },
69 { 12, 13, 14, 15, 28, 29, 30, 31, },
70 { 32, 33, 34, 35, 48, 49, 50, 51, },
71 { 36, 37, 38, 39, 52, 53, 54, 55, },
72 { 40, 41, 42, 43, 56, 57, 58, 59, },
73 { 44, 45, 46, 47, 60, 61, 62, 63, },
76 static const uint8_t diag_scan2x2_x[4] = { 0, 0, 1, 1 };
78 static const uint8_t diag_scan2x2_y[4] = { 0, 1, 0, 1 };
80 static const uint8_t diag_scan2x2_inv[2][2] = {
85 const uint8_t ff_hevc_diag_scan4x4_x[16] = {
92 const uint8_t ff_hevc_diag_scan4x4_y[16] = {
99 static const uint8_t diag_scan4x4_inv[4][4] = {
106 const uint8_t ff_hevc_diag_scan8x8_x[64] = {
125 const uint8_t ff_hevc_diag_scan8x8_y[64] = {
144 static const uint8_t diag_scan8x8_inv[8][8] = {
145 { 0, 2, 5, 9, 14, 20, 27, 35, },
146 { 1, 4, 8, 13, 19, 26, 34, 42, },
147 { 3, 7, 12, 18, 25, 33, 41, 48, },
148 { 6, 11, 17, 24, 32, 40, 47, 53, },
149 { 10, 16, 23, 31, 39, 46, 52, 57, },
150 { 15, 22, 30, 38, 45, 51, 56, 60, },
151 { 21, 29, 37, 44, 50, 55, 59, 62, },
152 { 28, 36, 43, 49, 54, 58, 61, 63, },
156 * NOTE: Each function hls_foo correspond to the function foo in the
157 * specification (HLS stands for High Level Syntax).
164 /* free everything allocated by pic_arrays_init() */
165 static void pic_arrays_free(HEVCContext *s)
168 av_freep(&s->deblock);
170 av_freep(&s->skip_flag);
171 av_freep(&s->tab_ct_depth);
173 av_freep(&s->tab_ipm);
174 av_freep(&s->cbf_luma);
175 av_freep(&s->is_pcm);
177 av_freep(&s->qp_y_tab);
178 av_freep(&s->tab_slice_address);
179 av_freep(&s->filter_slice_edges);
181 av_freep(&s->horizontal_bs);
182 av_freep(&s->vertical_bs);
184 av_buffer_pool_uninit(&s->tab_mvf_pool);
185 av_buffer_pool_uninit(&s->rpl_tab_pool);
188 /* allocate arrays that depend on frame dimensions */
189 static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
191 int log2_min_cb_size = sps->log2_min_cb_size;
192 int width = sps->width;
193 int height = sps->height;
194 int pic_size_in_ctb = ((width >> log2_min_cb_size) + 1) *
195 ((height >> log2_min_cb_size) + 1);
196 int ctb_count = sps->ctb_width * sps->ctb_height;
197 int min_pu_size = sps->min_pu_width * sps->min_pu_height;
199 s->bs_width = width >> 3;
200 s->bs_height = height >> 3;
202 s->sao = av_mallocz_array(ctb_count, sizeof(*s->sao));
203 s->deblock = av_mallocz_array(ctb_count, sizeof(*s->deblock));
204 if (!s->sao || !s->deblock)
207 s->skip_flag = av_malloc(pic_size_in_ctb);
208 s->tab_ct_depth = av_malloc(sps->min_cb_height * sps->min_cb_width);
209 if (!s->skip_flag || !s->tab_ct_depth)
212 s->cbf_luma = av_malloc(sps->min_tb_width * sps->min_tb_height);
213 s->tab_ipm = av_mallocz(min_pu_size);
214 s->is_pcm = av_malloc(min_pu_size);
215 if (!s->tab_ipm || !s->cbf_luma || !s->is_pcm)
218 s->filter_slice_edges = av_malloc(ctb_count);
219 s->tab_slice_address = av_malloc(pic_size_in_ctb *
220 sizeof(*s->tab_slice_address));
221 s->qp_y_tab = av_malloc(pic_size_in_ctb *
222 sizeof(*s->qp_y_tab));
223 if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address)
226 s->horizontal_bs = av_mallocz(2 * s->bs_width * (s->bs_height + 1));
227 s->vertical_bs = av_mallocz(2 * s->bs_width * (s->bs_height + 1));
228 if (!s->horizontal_bs || !s->vertical_bs)
231 s->tab_mvf_pool = av_buffer_pool_init(min_pu_size * sizeof(MvField),
233 s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab),
235 if (!s->tab_mvf_pool || !s->rpl_tab_pool)
242 return AVERROR(ENOMEM);
245 static void pred_weight_table(HEVCContext *s, GetBitContext *gb)
249 uint8_t luma_weight_l0_flag[16];
250 uint8_t chroma_weight_l0_flag[16];
251 uint8_t luma_weight_l1_flag[16];
252 uint8_t chroma_weight_l1_flag[16];
254 s->sh.luma_log2_weight_denom = av_clip(get_ue_golomb_long(gb), 0, 7);
255 if (s->ps.sps->chroma_format_idc != 0) {
256 int delta = get_se_golomb(gb);
257 s->sh.chroma_log2_weight_denom = av_clip(s->sh.luma_log2_weight_denom + delta, 0, 7);
260 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
261 luma_weight_l0_flag[i] = get_bits1(gb);
262 if (!luma_weight_l0_flag[i]) {
263 s->sh.luma_weight_l0[i] = 1 << s->sh.luma_log2_weight_denom;
264 s->sh.luma_offset_l0[i] = 0;
267 if (s->ps.sps->chroma_format_idc != 0) { // FIXME: invert "if" and "for"
268 for (i = 0; i < s->sh.nb_refs[L0]; i++)
269 chroma_weight_l0_flag[i] = get_bits1(gb);
271 for (i = 0; i < s->sh.nb_refs[L0]; i++)
272 chroma_weight_l0_flag[i] = 0;
274 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
275 if (luma_weight_l0_flag[i]) {
276 int delta_luma_weight_l0 = get_se_golomb(gb);
277 s->sh.luma_weight_l0[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;
278 s->sh.luma_offset_l0[i] = get_se_golomb(gb);
280 if (chroma_weight_l0_flag[i]) {
281 for (j = 0; j < 2; j++) {
282 int delta_chroma_weight_l0 = get_se_golomb(gb);
283 int delta_chroma_offset_l0 = get_se_golomb(gb);
284 s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
285 s->sh.chroma_offset_l0[i][j] = av_clip((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j])
286 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
289 s->sh.chroma_weight_l0[i][0] = 1 << s->sh.chroma_log2_weight_denom;
290 s->sh.chroma_offset_l0[i][0] = 0;
291 s->sh.chroma_weight_l0[i][1] = 1 << s->sh.chroma_log2_weight_denom;
292 s->sh.chroma_offset_l0[i][1] = 0;
295 if (s->sh.slice_type == B_SLICE) {
296 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
297 luma_weight_l1_flag[i] = get_bits1(gb);
298 if (!luma_weight_l1_flag[i]) {
299 s->sh.luma_weight_l1[i] = 1 << s->sh.luma_log2_weight_denom;
300 s->sh.luma_offset_l1[i] = 0;
303 if (s->ps.sps->chroma_format_idc != 0) {
304 for (i = 0; i < s->sh.nb_refs[L1]; i++)
305 chroma_weight_l1_flag[i] = get_bits1(gb);
307 for (i = 0; i < s->sh.nb_refs[L1]; i++)
308 chroma_weight_l1_flag[i] = 0;
310 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
311 if (luma_weight_l1_flag[i]) {
312 int delta_luma_weight_l1 = get_se_golomb(gb);
313 s->sh.luma_weight_l1[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;
314 s->sh.luma_offset_l1[i] = get_se_golomb(gb);
316 if (chroma_weight_l1_flag[i]) {
317 for (j = 0; j < 2; j++) {
318 int delta_chroma_weight_l1 = get_se_golomb(gb);
319 int delta_chroma_offset_l1 = get_se_golomb(gb);
320 s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
321 s->sh.chroma_offset_l1[i][j] = av_clip((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j])
322 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
325 s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom;
326 s->sh.chroma_offset_l1[i][0] = 0;
327 s->sh.chroma_weight_l1[i][1] = 1 << s->sh.chroma_log2_weight_denom;
328 s->sh.chroma_offset_l1[i][1] = 0;
334 static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
336 const HEVCSPS *sps = s->ps.sps;
337 int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
338 int prev_delta_msb = 0;
339 unsigned int nb_sps = 0, nb_sh;
343 if (!sps->long_term_ref_pics_present_flag)
346 if (sps->num_long_term_ref_pics_sps > 0)
347 nb_sps = get_ue_golomb_long(gb);
348 nb_sh = get_ue_golomb_long(gb);
350 if (nb_sh + nb_sps > FF_ARRAY_ELEMS(rps->poc))
351 return AVERROR_INVALIDDATA;
353 rps->nb_refs = nb_sh + nb_sps;
355 for (i = 0; i < rps->nb_refs; i++) {
356 uint8_t delta_poc_msb_present;
359 uint8_t lt_idx_sps = 0;
361 if (sps->num_long_term_ref_pics_sps > 1)
362 lt_idx_sps = get_bits(gb, av_ceil_log2(sps->num_long_term_ref_pics_sps));
364 rps->poc[i] = sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
365 rps->used[i] = sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];
367 rps->poc[i] = get_bits(gb, sps->log2_max_poc_lsb);
368 rps->used[i] = get_bits1(gb);
371 delta_poc_msb_present = get_bits1(gb);
372 if (delta_poc_msb_present) {
373 int delta = get_ue_golomb_long(gb);
375 if (i && i != nb_sps)
376 delta += prev_delta_msb;
378 rps->poc[i] += s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
379 prev_delta_msb = delta;
386 static void export_stream_params(AVCodecContext *avctx, const HEVCParamSets *ps,
389 const HEVCVPS *vps = (const HEVCVPS*)ps->vps_list[sps->vps_id]->data;
390 unsigned int num = 0, den = 0;
392 avctx->pix_fmt = sps->pix_fmt;
393 avctx->coded_width = sps->width;
394 avctx->coded_height = sps->height;
395 avctx->width = sps->output_width;
396 avctx->height = sps->output_height;
397 avctx->has_b_frames = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics;
398 avctx->profile = sps->ptl.general_ptl.profile_idc;
399 avctx->level = sps->ptl.general_ptl.level_idc;
401 ff_set_sar(avctx, sps->vui.sar);
403 if (sps->vui.video_signal_type_present_flag)
404 avctx->color_range = sps->vui.video_full_range_flag ? AVCOL_RANGE_JPEG
407 avctx->color_range = AVCOL_RANGE_MPEG;
409 if (sps->vui.colour_description_present_flag) {
410 avctx->color_primaries = sps->vui.colour_primaries;
411 avctx->color_trc = sps->vui.transfer_characteristic;
412 avctx->colorspace = sps->vui.matrix_coeffs;
414 avctx->color_primaries = AVCOL_PRI_UNSPECIFIED;
415 avctx->color_trc = AVCOL_TRC_UNSPECIFIED;
416 avctx->colorspace = AVCOL_SPC_UNSPECIFIED;
419 if (vps->vps_timing_info_present_flag) {
420 num = vps->vps_num_units_in_tick;
421 den = vps->vps_time_scale;
422 } else if (sps->vui.vui_timing_info_present_flag) {
423 num = sps->vui.vui_num_units_in_tick;
424 den = sps->vui.vui_time_scale;
427 if (num != 0 && den != 0)
428 av_reduce(&avctx->framerate.den, &avctx->framerate.num,
432 static int set_sps(HEVCContext *s, const HEVCSPS *sps)
434 #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + CONFIG_HEVC_D3D11VA_HWACCEL)
435 enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
445 ret = pic_arrays_init(s, sps);
449 export_stream_params(s->avctx, &s->ps, sps);
451 if (sps->pix_fmt == AV_PIX_FMT_YUV420P || sps->pix_fmt == AV_PIX_FMT_YUVJ420P) {
452 #if CONFIG_HEVC_DXVA2_HWACCEL
453 *fmt++ = AV_PIX_FMT_DXVA2_VLD;
455 #if CONFIG_HEVC_D3D11VA_HWACCEL
456 *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
460 *fmt++ = sps->pix_fmt;
461 *fmt = AV_PIX_FMT_NONE;
463 ret = ff_get_format(s->avctx, pix_fmts);
466 s->avctx->pix_fmt = ret;
468 ff_hevc_pred_init(&s->hpc, sps->bit_depth);
469 ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
470 ff_videodsp_init (&s->vdsp, sps->bit_depth);
472 if (sps->sao_enabled && !s->avctx->hwaccel) {
473 av_frame_unref(s->tmp_frame);
474 ret = ff_get_buffer(s->avctx, s->tmp_frame, AV_GET_BUFFER_FLAG_REF);
477 s->frame = s->tmp_frame;
481 s->ps.vps = (HEVCVPS*) s->ps.vps_list[s->ps.sps->vps_id]->data;
491 static int hls_slice_header(HEVCContext *s)
493 GetBitContext *gb = &s->HEVClc.gb;
494 SliceHeader *sh = &s->sh;
498 sh->first_slice_in_pic_flag = get_bits1(gb);
499 if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
500 s->seq_decode = (s->seq_decode + 1) & 0xff;
503 ff_hevc_clear_refs(s);
506 sh->no_output_of_prior_pics_flag = get_bits1(gb);
508 sh->pps_id = get_ue_golomb_long(gb);
509 if (sh->pps_id >= MAX_PPS_COUNT || !s->ps.pps_list[sh->pps_id]) {
510 av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
511 return AVERROR_INVALIDDATA;
513 if (!sh->first_slice_in_pic_flag &&
514 s->ps.pps != (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data) {
515 av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
516 return AVERROR_INVALIDDATA;
518 s->ps.pps = (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data;
520 if (s->ps.sps != (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data) {
521 s->ps.sps = (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data;
523 ff_hevc_clear_refs(s);
524 ret = set_sps(s, s->ps.sps);
528 s->seq_decode = (s->seq_decode + 1) & 0xff;
532 sh->dependent_slice_segment_flag = 0;
533 if (!sh->first_slice_in_pic_flag) {
534 int slice_address_length;
536 if (s->ps.pps->dependent_slice_segments_enabled_flag)
537 sh->dependent_slice_segment_flag = get_bits1(gb);
539 slice_address_length = av_ceil_log2(s->ps.sps->ctb_width *
540 s->ps.sps->ctb_height);
541 sh->slice_segment_addr = slice_address_length ? get_bits(gb, slice_address_length) : 0;
542 if (sh->slice_segment_addr >= s->ps.sps->ctb_width * s->ps.sps->ctb_height) {
543 av_log(s->avctx, AV_LOG_ERROR,
544 "Invalid slice segment address: %u.\n",
545 sh->slice_segment_addr);
546 return AVERROR_INVALIDDATA;
549 if (!sh->dependent_slice_segment_flag) {
550 sh->slice_addr = sh->slice_segment_addr;
554 sh->slice_segment_addr = sh->slice_addr = 0;
556 s->slice_initialized = 0;
559 if (!sh->dependent_slice_segment_flag) {
560 s->slice_initialized = 0;
562 for (i = 0; i < s->ps.pps->num_extra_slice_header_bits; i++)
563 skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
565 sh->slice_type = get_ue_golomb_long(gb);
566 if (!(sh->slice_type == I_SLICE ||
567 sh->slice_type == P_SLICE ||
568 sh->slice_type == B_SLICE)) {
569 av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
571 return AVERROR_INVALIDDATA;
573 if (IS_IRAP(s) && sh->slice_type != I_SLICE) {
574 av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
575 return AVERROR_INVALIDDATA;
578 // when flag is not present, picture is inferred to be output
579 sh->pic_output_flag = 1;
580 if (s->ps.pps->output_flag_present_flag)
581 sh->pic_output_flag = get_bits1(gb);
583 if (s->ps.sps->separate_colour_plane_flag)
584 sh->colour_plane_id = get_bits(gb, 2);
589 sh->pic_order_cnt_lsb = get_bits(gb, s->ps.sps->log2_max_poc_lsb);
590 poc = ff_hevc_compute_poc(s, sh->pic_order_cnt_lsb);
591 if (!sh->first_slice_in_pic_flag && poc != s->poc) {
592 av_log(s->avctx, AV_LOG_WARNING,
593 "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
594 if (s->avctx->err_recognition & AV_EF_EXPLODE)
595 return AVERROR_INVALIDDATA;
600 sh->short_term_ref_pic_set_sps_flag = get_bits1(gb);
601 if (!sh->short_term_ref_pic_set_sps_flag) {
602 int pos = get_bits_left(gb);
603 ret = ff_hevc_decode_short_term_rps(gb, s->avctx, &sh->slice_rps, s->ps.sps, 1);
607 sh->short_term_ref_pic_set_size = pos - get_bits_left(gb);
608 sh->short_term_rps = &sh->slice_rps;
610 int numbits, rps_idx;
612 if (!s->ps.sps->nb_st_rps) {
613 av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
614 return AVERROR_INVALIDDATA;
617 numbits = av_ceil_log2(s->ps.sps->nb_st_rps);
618 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
619 sh->short_term_rps = &s->ps.sps->st_rps[rps_idx];
622 ret = decode_lt_rps(s, &sh->long_term_rps, gb);
624 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
625 if (s->avctx->err_recognition & AV_EF_EXPLODE)
626 return AVERROR_INVALIDDATA;
629 if (s->ps.sps->sps_temporal_mvp_enabled_flag)
630 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
632 sh->slice_temporal_mvp_enabled_flag = 0;
634 s->sh.short_term_rps = NULL;
639 if (s->temporal_id == 0 &&
640 s->nal_unit_type != NAL_TRAIL_N &&
641 s->nal_unit_type != NAL_TSA_N &&
642 s->nal_unit_type != NAL_STSA_N &&
643 s->nal_unit_type != NAL_RADL_N &&
644 s->nal_unit_type != NAL_RADL_R &&
645 s->nal_unit_type != NAL_RASL_N &&
646 s->nal_unit_type != NAL_RASL_R)
649 if (s->ps.sps->sao_enabled) {
650 sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
651 sh->slice_sample_adaptive_offset_flag[1] =
652 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
654 sh->slice_sample_adaptive_offset_flag[0] = 0;
655 sh->slice_sample_adaptive_offset_flag[1] = 0;
656 sh->slice_sample_adaptive_offset_flag[2] = 0;
659 sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
660 if (sh->slice_type == P_SLICE || sh->slice_type == B_SLICE) {
663 sh->nb_refs[L0] = s->ps.pps->num_ref_idx_l0_default_active;
664 if (sh->slice_type == B_SLICE)
665 sh->nb_refs[L1] = s->ps.pps->num_ref_idx_l1_default_active;
667 if (get_bits1(gb)) { // num_ref_idx_active_override_flag
668 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
669 if (sh->slice_type == B_SLICE)
670 sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
672 if (sh->nb_refs[L0] > MAX_REFS || sh->nb_refs[L1] > MAX_REFS) {
673 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
674 sh->nb_refs[L0], sh->nb_refs[L1]);
675 return AVERROR_INVALIDDATA;
678 sh->rpl_modification_flag[0] = 0;
679 sh->rpl_modification_flag[1] = 0;
680 nb_refs = ff_hevc_frame_nb_refs(s);
682 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
683 return AVERROR_INVALIDDATA;
686 if (s->ps.pps->lists_modification_present_flag && nb_refs > 1) {
687 sh->rpl_modification_flag[0] = get_bits1(gb);
688 if (sh->rpl_modification_flag[0]) {
689 for (i = 0; i < sh->nb_refs[L0]; i++)
690 sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
693 if (sh->slice_type == B_SLICE) {
694 sh->rpl_modification_flag[1] = get_bits1(gb);
695 if (sh->rpl_modification_flag[1] == 1)
696 for (i = 0; i < sh->nb_refs[L1]; i++)
697 sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
701 if (sh->slice_type == B_SLICE)
702 sh->mvd_l1_zero_flag = get_bits1(gb);
704 if (s->ps.pps->cabac_init_present_flag)
705 sh->cabac_init_flag = get_bits1(gb);
707 sh->cabac_init_flag = 0;
709 sh->collocated_ref_idx = 0;
710 if (sh->slice_temporal_mvp_enabled_flag) {
711 sh->collocated_list = L0;
712 if (sh->slice_type == B_SLICE)
713 sh->collocated_list = !get_bits1(gb);
715 if (sh->nb_refs[sh->collocated_list] > 1) {
716 sh->collocated_ref_idx = get_ue_golomb_long(gb);
717 if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
718 av_log(s->avctx, AV_LOG_ERROR,
719 "Invalid collocated_ref_idx: %d.\n",
720 sh->collocated_ref_idx);
721 return AVERROR_INVALIDDATA;
726 if ((s->ps.pps->weighted_pred_flag && sh->slice_type == P_SLICE) ||
727 (s->ps.pps->weighted_bipred_flag && sh->slice_type == B_SLICE)) {
728 pred_weight_table(s, gb);
731 sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
732 if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
733 av_log(s->avctx, AV_LOG_ERROR,
734 "Invalid number of merging MVP candidates: %d.\n",
735 sh->max_num_merge_cand);
736 return AVERROR_INVALIDDATA;
740 sh->slice_qp_delta = get_se_golomb(gb);
742 if (s->ps.pps->pic_slice_level_chroma_qp_offsets_present_flag) {
743 sh->slice_cb_qp_offset = get_se_golomb(gb);
744 sh->slice_cr_qp_offset = get_se_golomb(gb);
746 sh->slice_cb_qp_offset = 0;
747 sh->slice_cr_qp_offset = 0;
750 if (s->ps.pps->deblocking_filter_control_present_flag) {
751 int deblocking_filter_override_flag = 0;
753 if (s->ps.pps->deblocking_filter_override_enabled_flag)
754 deblocking_filter_override_flag = get_bits1(gb);
756 if (deblocking_filter_override_flag) {
757 sh->disable_deblocking_filter_flag = get_bits1(gb);
758 if (!sh->disable_deblocking_filter_flag) {
759 sh->beta_offset = get_se_golomb(gb) * 2;
760 sh->tc_offset = get_se_golomb(gb) * 2;
763 sh->disable_deblocking_filter_flag = s->ps.pps->disable_dbf;
764 sh->beta_offset = s->ps.pps->beta_offset;
765 sh->tc_offset = s->ps.pps->tc_offset;
768 sh->disable_deblocking_filter_flag = 0;
773 if (s->ps.pps->seq_loop_filter_across_slices_enabled_flag &&
774 (sh->slice_sample_adaptive_offset_flag[0] ||
775 sh->slice_sample_adaptive_offset_flag[1] ||
776 !sh->disable_deblocking_filter_flag)) {
777 sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
779 sh->slice_loop_filter_across_slices_enabled_flag = s->ps.pps->seq_loop_filter_across_slices_enabled_flag;
781 } else if (!s->slice_initialized) {
782 av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
783 return AVERROR_INVALIDDATA;
786 sh->num_entry_point_offsets = 0;
787 if (s->ps.pps->tiles_enabled_flag || s->ps.pps->entropy_coding_sync_enabled_flag) {
788 sh->num_entry_point_offsets = get_ue_golomb_long(gb);
789 if (sh->num_entry_point_offsets > 0) {
790 int offset_len = get_ue_golomb_long(gb) + 1;
792 for (i = 0; i < sh->num_entry_point_offsets; i++)
793 skip_bits(gb, offset_len);
797 if (s->ps.pps->slice_header_extension_present_flag) {
798 unsigned int length = get_ue_golomb_long(gb);
799 for (i = 0; i < length; i++)
800 skip_bits(gb, 8); // slice_header_extension_data_byte
803 // Inferred parameters
804 sh->slice_qp = 26 + s->ps.pps->pic_init_qp_minus26 + sh->slice_qp_delta;
805 if (sh->slice_qp > 51 ||
806 sh->slice_qp < -s->ps.sps->qp_bd_offset) {
807 av_log(s->avctx, AV_LOG_ERROR,
808 "The slice_qp %d is outside the valid range "
811 -s->ps.sps->qp_bd_offset);
812 return AVERROR_INVALIDDATA;
815 sh->slice_ctb_addr_rs = sh->slice_segment_addr;
817 if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) {
818 av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
819 return AVERROR_INVALIDDATA;
822 s->HEVClc.first_qp_group = !s->sh.dependent_slice_segment_flag;
824 if (!s->ps.pps->cu_qp_delta_enabled_flag)
825 s->HEVClc.qp_y = FFUMOD(s->sh.slice_qp + 52 + 2 * s->ps.sps->qp_bd_offset,
826 52 + s->ps.sps->qp_bd_offset) - s->ps.sps->qp_bd_offset;
828 s->slice_initialized = 1;
833 #define CTB(tab, x, y) ((tab)[(y) * s->ps.sps->ctb_width + (x)])
835 #define SET_SAO(elem, value) \
837 if (!sao_merge_up_flag && !sao_merge_left_flag) \
839 else if (sao_merge_left_flag) \
840 sao->elem = CTB(s->sao, rx-1, ry).elem; \
841 else if (sao_merge_up_flag) \
842 sao->elem = CTB(s->sao, rx, ry-1).elem; \
847 static void hls_sao_param(HEVCContext *s, int rx, int ry)
849 HEVCLocalContext *lc = &s->HEVClc;
850 int sao_merge_left_flag = 0;
851 int sao_merge_up_flag = 0;
852 int shift = s->ps.sps->bit_depth - FFMIN(s->ps.sps->bit_depth, 10);
853 SAOParams *sao = &CTB(s->sao, rx, ry);
856 if (s->sh.slice_sample_adaptive_offset_flag[0] ||
857 s->sh.slice_sample_adaptive_offset_flag[1]) {
859 if (lc->ctb_left_flag)
860 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
862 if (ry > 0 && !sao_merge_left_flag) {
864 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
868 for (c_idx = 0; c_idx < 3; c_idx++) {
869 if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
870 sao->type_idx[c_idx] = SAO_NOT_APPLIED;
875 sao->type_idx[2] = sao->type_idx[1];
876 sao->eo_class[2] = sao->eo_class[1];
878 SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
881 if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
884 for (i = 0; i < 4; i++)
885 SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
887 if (sao->type_idx[c_idx] == SAO_BAND) {
888 for (i = 0; i < 4; i++) {
889 if (sao->offset_abs[c_idx][i]) {
890 SET_SAO(offset_sign[c_idx][i],
891 ff_hevc_sao_offset_sign_decode(s));
893 sao->offset_sign[c_idx][i] = 0;
896 SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
897 } else if (c_idx != 2) {
898 SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
901 // Inferred parameters
902 sao->offset_val[c_idx][0] = 0;
903 for (i = 0; i < 4; i++) {
904 sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i] << shift;
905 if (sao->type_idx[c_idx] == SAO_EDGE) {
907 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
908 } else if (sao->offset_sign[c_idx][i]) {
909 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
918 static void hls_residual_coding(HEVCContext *s, int x0, int y0,
919 int log2_trafo_size, enum ScanType scan_idx,
922 #define GET_COORD(offset, n) \
924 x_c = (scan_x_cg[offset >> 4] << 2) + scan_x_off[n]; \
925 y_c = (scan_y_cg[offset >> 4] << 2) + scan_y_off[n]; \
927 HEVCLocalContext *lc = &s->HEVClc;
928 int transform_skip_flag = 0;
930 int last_significant_coeff_x, last_significant_coeff_y;
934 int greater1_ctx = 1;
937 int x_cg_last_sig, y_cg_last_sig;
939 const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
941 ptrdiff_t stride = s->frame->linesize[c_idx];
942 int hshift = s->ps.sps->hshift[c_idx];
943 int vshift = s->ps.sps->vshift[c_idx];
944 uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
945 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
946 DECLARE_ALIGNED(16, int16_t, coeffs[MAX_TB_SIZE * MAX_TB_SIZE]) = { 0 };
947 DECLARE_ALIGNED(8, uint8_t, significant_coeff_group_flag[8][8]) = { { 0 } };
949 int trafo_size = 1 << log2_trafo_size;
950 int i, qp, shift, add, scale, scale_m;
951 const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
952 const uint8_t *scale_matrix;
955 // Derive QP for dequant
956 if (!lc->cu.cu_transquant_bypass_flag) {
957 static const int qp_c[] = {
958 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37
961 static const uint8_t rem6[51 + 2 * 6 + 1] = {
962 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
963 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
964 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
967 static const uint8_t div6[51 + 2 * 6 + 1] = {
968 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
969 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
970 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
975 qp = qp_y + s->ps.sps->qp_bd_offset;
980 offset = s->ps.pps->cb_qp_offset + s->sh.slice_cb_qp_offset;
982 offset = s->ps.pps->cr_qp_offset + s->sh.slice_cr_qp_offset;
984 qp_i = av_clip(qp_y + offset, -s->ps.sps->qp_bd_offset, 57);
990 qp = qp_c[qp_i - 30];
992 qp += s->ps.sps->qp_bd_offset;
995 shift = s->ps.sps->bit_depth + log2_trafo_size - 5;
996 add = 1 << (shift - 1);
997 scale = level_scale[rem6[qp]] << (div6[qp]);
998 scale_m = 16; // default when no custom scaling lists.
1001 if (s->ps.sps->scaling_list_enable_flag) {
1002 const ScalingList *sl = s->ps.pps->scaling_list_data_present_flag ?
1003 &s->ps.pps->scaling_list : &s->ps.sps->scaling_list;
1004 int matrix_id = lc->cu.pred_mode != MODE_INTRA;
1006 if (log2_trafo_size != 5)
1007 matrix_id = 3 * matrix_id + c_idx;
1009 scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
1010 if (log2_trafo_size >= 4)
1011 dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
1015 if (s->ps.pps->transform_skip_enabled_flag &&
1016 !lc->cu.cu_transquant_bypass_flag &&
1017 log2_trafo_size == 2) {
1018 transform_skip_flag = ff_hevc_transform_skip_flag_decode(s, c_idx);
1021 last_significant_coeff_x =
1022 ff_hevc_last_significant_coeff_x_prefix_decode(s, c_idx, log2_trafo_size);
1023 last_significant_coeff_y =
1024 ff_hevc_last_significant_coeff_y_prefix_decode(s, c_idx, log2_trafo_size);
1026 if (last_significant_coeff_x > 3) {
1027 int suffix = ff_hevc_last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
1028 last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
1029 (2 + (last_significant_coeff_x & 1)) +
1033 if (last_significant_coeff_y > 3) {
1034 int suffix = ff_hevc_last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
1035 last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
1036 (2 + (last_significant_coeff_y & 1)) +
1040 if (scan_idx == SCAN_VERT)
1041 FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
1043 x_cg_last_sig = last_significant_coeff_x >> 2;
1044 y_cg_last_sig = last_significant_coeff_y >> 2;
1048 int last_x_c = last_significant_coeff_x & 3;
1049 int last_y_c = last_significant_coeff_y & 3;
1051 scan_x_off = ff_hevc_diag_scan4x4_x;
1052 scan_y_off = ff_hevc_diag_scan4x4_y;
1053 num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
1054 if (trafo_size == 4) {
1055 scan_x_cg = scan_1x1;
1056 scan_y_cg = scan_1x1;
1057 } else if (trafo_size == 8) {
1058 num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1059 scan_x_cg = diag_scan2x2_x;
1060 scan_y_cg = diag_scan2x2_y;
1061 } else if (trafo_size == 16) {
1062 num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1063 scan_x_cg = ff_hevc_diag_scan4x4_x;
1064 scan_y_cg = ff_hevc_diag_scan4x4_y;
1065 } else { // trafo_size == 32
1066 num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1067 scan_x_cg = ff_hevc_diag_scan8x8_x;
1068 scan_y_cg = ff_hevc_diag_scan8x8_y;
1073 scan_x_cg = horiz_scan2x2_x;
1074 scan_y_cg = horiz_scan2x2_y;
1075 scan_x_off = horiz_scan4x4_x;
1076 scan_y_off = horiz_scan4x4_y;
1077 num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1079 default: //SCAN_VERT
1080 scan_x_cg = horiz_scan2x2_y;
1081 scan_y_cg = horiz_scan2x2_x;
1082 scan_x_off = horiz_scan4x4_y;
1083 scan_y_off = horiz_scan4x4_x;
1084 num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1088 num_last_subset = (num_coeff - 1) >> 4;
1090 for (i = num_last_subset; i >= 0; i--) {
1092 int x_cg, y_cg, x_c, y_c;
1093 int implicit_non_zero_coeff = 0;
1094 int64_t trans_coeff_level;
1096 int offset = i << 4;
1098 uint8_t significant_coeff_flag_idx[16];
1099 uint8_t nb_significant_coeff_flag = 0;
1101 x_cg = scan_x_cg[i];
1102 y_cg = scan_y_cg[i];
1104 if (i < num_last_subset && i > 0) {
1106 if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1107 ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1108 if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1109 ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1111 significant_coeff_group_flag[x_cg][y_cg] =
1112 ff_hevc_significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
1113 implicit_non_zero_coeff = 1;
1115 significant_coeff_group_flag[x_cg][y_cg] =
1116 ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1117 (x_cg == 0 && y_cg == 0));
1120 last_scan_pos = num_coeff - offset - 1;
1122 if (i == num_last_subset) {
1123 n_end = last_scan_pos - 1;
1124 significant_coeff_flag_idx[0] = last_scan_pos;
1125 nb_significant_coeff_flag = 1;
1130 if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1131 prev_sig = significant_coeff_group_flag[x_cg + 1][y_cg];
1132 if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1133 prev_sig += significant_coeff_group_flag[x_cg][y_cg + 1] << 1;
1135 for (n = n_end; n >= 0; n--) {
1136 GET_COORD(offset, n);
1138 if (significant_coeff_group_flag[x_cg][y_cg] &&
1139 (n > 0 || implicit_non_zero_coeff == 0)) {
1140 if (ff_hevc_significant_coeff_flag_decode(s, c_idx, x_c, y_c,
1144 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1145 nb_significant_coeff_flag++;
1146 implicit_non_zero_coeff = 0;
1149 int last_cg = (x_c == (x_cg << 2) && y_c == (y_cg << 2));
1150 if (last_cg && implicit_non_zero_coeff && significant_coeff_group_flag[x_cg][y_cg]) {
1151 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1152 nb_significant_coeff_flag++;
1157 n_end = nb_significant_coeff_flag;
1160 int first_nz_pos_in_cg = 16;
1161 int last_nz_pos_in_cg = -1;
1162 int c_rice_param = 0;
1163 int first_greater1_coeff_idx = -1;
1164 uint8_t coeff_abs_level_greater1_flag[16] = { 0 };
1165 uint16_t coeff_sign_flag;
1167 int sign_hidden = 0;
1169 // initialize first elem of coeff_bas_level_greater1_flag
1170 int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1172 if (!(i == num_last_subset) && greater1_ctx == 0)
1175 last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1177 for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1178 int n_idx = significant_coeff_flag_idx[m];
1179 int inc = (ctx_set << 2) + greater1_ctx;
1180 coeff_abs_level_greater1_flag[n_idx] =
1181 ff_hevc_coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
1182 if (coeff_abs_level_greater1_flag[n_idx]) {
1184 } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1188 if (coeff_abs_level_greater1_flag[n_idx] &&
1189 first_greater1_coeff_idx == -1)
1190 first_greater1_coeff_idx = n_idx;
1192 first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1193 sign_hidden = last_nz_pos_in_cg - first_nz_pos_in_cg >= 4 &&
1194 !lc->cu.cu_transquant_bypass_flag;
1196 if (first_greater1_coeff_idx != -1) {
1197 coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += ff_hevc_coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1199 if (!s->ps.pps->sign_data_hiding_flag || !sign_hidden) {
1200 coeff_sign_flag = ff_hevc_coeff_sign_flag(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1202 coeff_sign_flag = ff_hevc_coeff_sign_flag(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1205 for (m = 0; m < n_end; m++) {
1206 n = significant_coeff_flag_idx[m];
1207 GET_COORD(offset, n);
1208 trans_coeff_level = 1 + coeff_abs_level_greater1_flag[n];
1209 if (trans_coeff_level == ((m < 8) ?
1210 ((n == first_greater1_coeff_idx) ? 3 : 2) : 1)) {
1211 int last_coeff_abs_level_remaining = ff_hevc_coeff_abs_level_remaining(s, trans_coeff_level, c_rice_param);
1213 trans_coeff_level += last_coeff_abs_level_remaining;
1214 if ((trans_coeff_level) > (3 * (1 << c_rice_param)))
1215 c_rice_param = FFMIN(c_rice_param + 1, 4);
1217 if (s->ps.pps->sign_data_hiding_flag && sign_hidden) {
1218 sum_abs += trans_coeff_level;
1219 if (n == first_nz_pos_in_cg && ((sum_abs & 1) == 1))
1220 trans_coeff_level = -trans_coeff_level;
1222 if (coeff_sign_flag >> 15)
1223 trans_coeff_level = -trans_coeff_level;
1224 coeff_sign_flag <<= 1;
1225 if (!lc->cu.cu_transquant_bypass_flag) {
1226 if (s->ps.sps->scaling_list_enable_flag) {
1227 if (y_c || x_c || log2_trafo_size < 4) {
1229 switch (log2_trafo_size) {
1230 case 3: pos = (y_c << 3) + x_c; break;
1231 case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1232 case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1233 default: pos = (y_c << 2) + x_c;
1235 scale_m = scale_matrix[pos];
1240 trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1241 if(trans_coeff_level < 0) {
1242 if((~trans_coeff_level) & 0xFffffffffff8000)
1243 trans_coeff_level = -32768;
1245 if (trans_coeff_level & 0xffffffffffff8000)
1246 trans_coeff_level = 32767;
1249 coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1254 if (lc->cu.cu_transquant_bypass_flag) {
1255 s->hevcdsp.transquant_bypass[log2_trafo_size - 2](dst, coeffs, stride);
1257 if (transform_skip_flag)
1258 s->hevcdsp.transform_skip(dst, coeffs, stride);
1259 else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 &&
1260 log2_trafo_size == 2)
1261 s->hevcdsp.transform_4x4_luma_add(dst, coeffs, stride);
1263 s->hevcdsp.transform_add[log2_trafo_size - 2](dst, coeffs, stride);
1267 static int hls_transform_unit(HEVCContext *s, int x0, int y0,
1268 int xBase, int yBase, int cb_xBase, int cb_yBase,
1269 int log2_cb_size, int log2_trafo_size,
1270 int blk_idx, int cbf_luma, int cbf_cb, int cbf_cr)
1272 HEVCLocalContext *lc = &s->HEVClc;
1274 if (lc->cu.pred_mode == MODE_INTRA) {
1275 int trafo_size = 1 << log2_trafo_size;
1276 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1278 s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
1279 if (log2_trafo_size > 2) {
1280 trafo_size = trafo_size << (s->ps.sps->hshift[1] - 1);
1281 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1282 s->hpc.intra_pred[log2_trafo_size - 3](s, x0, y0, 1);
1283 s->hpc.intra_pred[log2_trafo_size - 3](s, x0, y0, 2);
1284 } else if (blk_idx == 3) {
1285 trafo_size = trafo_size << s->ps.sps->hshift[1];
1286 ff_hevc_set_neighbour_available(s, xBase, yBase,
1287 trafo_size, trafo_size);
1288 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1289 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1293 if (cbf_luma || cbf_cb || cbf_cr) {
1294 int scan_idx = SCAN_DIAG;
1295 int scan_idx_c = SCAN_DIAG;
1297 if (s->ps.pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
1298 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
1299 if (lc->tu.cu_qp_delta != 0)
1300 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
1301 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
1302 lc->tu.is_cu_qp_delta_coded = 1;
1304 if (lc->tu.cu_qp_delta < -(26 + s->ps.sps->qp_bd_offset / 2) ||
1305 lc->tu.cu_qp_delta > (25 + s->ps.sps->qp_bd_offset / 2)) {
1306 av_log(s->avctx, AV_LOG_ERROR,
1307 "The cu_qp_delta %d is outside the valid range "
1310 -(26 + s->ps.sps->qp_bd_offset / 2),
1311 (25 + s->ps.sps->qp_bd_offset / 2));
1312 return AVERROR_INVALIDDATA;
1315 ff_hevc_set_qPy(s, x0, y0, cb_xBase, cb_yBase, log2_cb_size);
1318 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
1319 if (lc->tu.cur_intra_pred_mode >= 6 &&
1320 lc->tu.cur_intra_pred_mode <= 14) {
1321 scan_idx = SCAN_VERT;
1322 } else if (lc->tu.cur_intra_pred_mode >= 22 &&
1323 lc->tu.cur_intra_pred_mode <= 30) {
1324 scan_idx = SCAN_HORIZ;
1327 if (lc->pu.intra_pred_mode_c >= 6 &&
1328 lc->pu.intra_pred_mode_c <= 14) {
1329 scan_idx_c = SCAN_VERT;
1330 } else if (lc->pu.intra_pred_mode_c >= 22 &&
1331 lc->pu.intra_pred_mode_c <= 30) {
1332 scan_idx_c = SCAN_HORIZ;
1337 hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
1338 if (log2_trafo_size > 2) {
1340 hls_residual_coding(s, x0, y0, log2_trafo_size - 1, scan_idx_c, 1);
1342 hls_residual_coding(s, x0, y0, log2_trafo_size - 1, scan_idx_c, 2);
1343 } else if (blk_idx == 3) {
1345 hls_residual_coding(s, xBase, yBase, log2_trafo_size, scan_idx_c, 1);
1347 hls_residual_coding(s, xBase, yBase, log2_trafo_size, scan_idx_c, 2);
1353 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1355 int cb_size = 1 << log2_cb_size;
1356 int log2_min_pu_size = s->ps.sps->log2_min_pu_size;
1358 int min_pu_width = s->ps.sps->min_pu_width;
1359 int x_end = FFMIN(x0 + cb_size, s->ps.sps->width);
1360 int y_end = FFMIN(y0 + cb_size, s->ps.sps->height);
1363 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1364 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1365 s->is_pcm[i + j * min_pu_width] = 2;
1368 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1369 int xBase, int yBase, int cb_xBase, int cb_yBase,
1370 int log2_cb_size, int log2_trafo_size,
1371 int trafo_depth, int blk_idx,
1372 int cbf_cb, int cbf_cr)
1374 HEVCLocalContext *lc = &s->HEVClc;
1375 uint8_t split_transform_flag;
1378 if (lc->cu.intra_split_flag) {
1379 if (trafo_depth == 1)
1380 lc->tu.cur_intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1382 lc->tu.cur_intra_pred_mode = lc->pu.intra_pred_mode[0];
1385 if (log2_trafo_size <= s->ps.sps->log2_max_trafo_size &&
1386 log2_trafo_size > s->ps.sps->log2_min_tb_size &&
1387 trafo_depth < lc->cu.max_trafo_depth &&
1388 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1389 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1391 int inter_split = s->ps.sps->max_transform_hierarchy_depth_inter == 0 &&
1392 lc->cu.pred_mode == MODE_INTER &&
1393 lc->cu.part_mode != PART_2Nx2N &&
1396 split_transform_flag = log2_trafo_size > s->ps.sps->log2_max_trafo_size ||
1397 (lc->cu.intra_split_flag && trafo_depth == 0) ||
1401 if (log2_trafo_size > 2 && (trafo_depth == 0 || cbf_cb))
1402 cbf_cb = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1403 else if (log2_trafo_size > 2 || trafo_depth == 0)
1405 if (log2_trafo_size > 2 && (trafo_depth == 0 || cbf_cr))
1406 cbf_cr = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1407 else if (log2_trafo_size > 2 || trafo_depth == 0)
1410 if (split_transform_flag) {
1411 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1412 const int x1 = x0 + trafo_size_split;
1413 const int y1 = y0 + trafo_size_split;
1415 #define SUBDIVIDE(x, y, idx) \
1417 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1418 log2_trafo_size - 1, trafo_depth + 1, idx, \
1424 SUBDIVIDE(x0, y0, 0);
1425 SUBDIVIDE(x1, y0, 1);
1426 SUBDIVIDE(x0, y1, 2);
1427 SUBDIVIDE(x1, y1, 3);
1431 int min_tu_size = 1 << s->ps.sps->log2_min_tb_size;
1432 int log2_min_tu_size = s->ps.sps->log2_min_tb_size;
1433 int min_tu_width = s->ps.sps->min_tb_width;
1436 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1438 cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1440 ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1441 log2_cb_size, log2_trafo_size,
1442 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1445 // TODO: store cbf_luma somewhere else
1448 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1449 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1450 int x_tu = (x0 + j) >> log2_min_tu_size;
1451 int y_tu = (y0 + i) >> log2_min_tu_size;
1452 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1455 if (!s->sh.disable_deblocking_filter_flag) {
1456 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1457 if (s->ps.pps->transquant_bypass_enable_flag &&
1458 lc->cu.cu_transquant_bypass_flag)
1459 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1465 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1467 //TODO: non-4:2:0 support
1468 HEVCLocalContext *lc = &s->HEVClc;
1470 int cb_size = 1 << log2_cb_size;
1471 int stride0 = s->frame->linesize[0];
1472 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->ps.sps->pixel_shift)];
1473 int stride1 = s->frame->linesize[1];
1474 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)];
1475 int stride2 = s->frame->linesize[2];
1476 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)];
1478 int length = cb_size * cb_size * s->ps.sps->pcm.bit_depth + ((cb_size * cb_size) >> 1) * s->ps.sps->pcm.bit_depth_chroma;
1479 const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1482 if (!s->sh.disable_deblocking_filter_flag)
1483 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1485 ret = init_get_bits(&gb, pcm, length);
1489 s->hevcdsp.put_pcm(dst0, stride0, cb_size, &gb, s->ps.sps->pcm.bit_depth);
1490 s->hevcdsp.put_pcm(dst1, stride1, cb_size / 2, &gb, s->ps.sps->pcm.bit_depth_chroma);
1491 s->hevcdsp.put_pcm(dst2, stride2, cb_size / 2, &gb, s->ps.sps->pcm.bit_depth_chroma);
1495 static void hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1497 HEVCLocalContext *lc = &s->HEVClc;
1498 int x = ff_hevc_abs_mvd_greater0_flag_decode(s);
1499 int y = ff_hevc_abs_mvd_greater0_flag_decode(s);
1502 x += ff_hevc_abs_mvd_greater1_flag_decode(s);
1504 y += ff_hevc_abs_mvd_greater1_flag_decode(s);
1507 case 2: lc->pu.mvd.x = ff_hevc_mvd_decode(s); break;
1508 case 1: lc->pu.mvd.x = ff_hevc_mvd_sign_flag_decode(s); break;
1509 case 0: lc->pu.mvd.x = 0; break;
1513 case 2: lc->pu.mvd.y = ff_hevc_mvd_decode(s); break;
1514 case 1: lc->pu.mvd.y = ff_hevc_mvd_sign_flag_decode(s); break;
1515 case 0: lc->pu.mvd.y = 0; break;
1520 * 8.5.3.2.2.1 Luma sample interpolation process
1522 * @param s HEVC decoding context
1523 * @param dst target buffer for block data at block position
1524 * @param dststride stride of the dst buffer
1525 * @param ref reference picture buffer at origin (0, 0)
1526 * @param mv motion vector (relative to block position) to get pixel data from
1527 * @param x_off horizontal position of block from origin (0, 0)
1528 * @param y_off vertical position of block from origin (0, 0)
1529 * @param block_w width of block
1530 * @param block_h height of block
1532 static void luma_mc(HEVCContext *s, int16_t *dst, ptrdiff_t dststride,
1533 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1534 int block_w, int block_h)
1536 HEVCLocalContext *lc = &s->HEVClc;
1537 uint8_t *src = ref->data[0];
1538 ptrdiff_t srcstride = ref->linesize[0];
1539 int pic_width = s->ps.sps->width;
1540 int pic_height = s->ps.sps->height;
1544 int extra_left = ff_hevc_qpel_extra_before[mx];
1545 int extra_top = ff_hevc_qpel_extra_before[my];
1547 x_off += mv->x >> 2;
1548 y_off += mv->y >> 2;
1549 src += y_off * srcstride + (x_off << s->ps.sps->pixel_shift);
1551 if (x_off < extra_left || y_off < extra_top ||
1552 x_off >= pic_width - block_w - ff_hevc_qpel_extra_after[mx] ||
1553 y_off >= pic_height - block_h - ff_hevc_qpel_extra_after[my]) {
1554 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1555 int offset = extra_top * srcstride + (extra_left << s->ps.sps->pixel_shift);
1556 int buf_offset = extra_top *
1557 edge_emu_stride + (extra_left << s->ps.sps->pixel_shift);
1559 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1560 edge_emu_stride, srcstride,
1561 block_w + ff_hevc_qpel_extra[mx],
1562 block_h + ff_hevc_qpel_extra[my],
1563 x_off - extra_left, y_off - extra_top,
1564 pic_width, pic_height);
1565 src = lc->edge_emu_buffer + buf_offset;
1566 srcstride = edge_emu_stride;
1568 s->hevcdsp.put_hevc_qpel[my][mx](dst, dststride, src, srcstride, block_w,
1569 block_h, lc->mc_buffer);
1573 * 8.5.3.2.2.2 Chroma sample interpolation process
1575 * @param s HEVC decoding context
1576 * @param dst1 target buffer for block data at block position (U plane)
1577 * @param dst2 target buffer for block data at block position (V plane)
1578 * @param dststride stride of the dst1 and dst2 buffers
1579 * @param ref reference picture buffer at origin (0, 0)
1580 * @param mv motion vector (relative to block position) to get pixel data from
1581 * @param x_off horizontal position of block from origin (0, 0)
1582 * @param y_off vertical position of block from origin (0, 0)
1583 * @param block_w width of block
1584 * @param block_h height of block
1586 static void chroma_mc(HEVCContext *s, int16_t *dst1, int16_t *dst2,
1587 ptrdiff_t dststride, AVFrame *ref, const Mv *mv,
1588 int x_off, int y_off, int block_w, int block_h)
1590 HEVCLocalContext *lc = &s->HEVClc;
1591 uint8_t *src1 = ref->data[1];
1592 uint8_t *src2 = ref->data[2];
1593 ptrdiff_t src1stride = ref->linesize[1];
1594 ptrdiff_t src2stride = ref->linesize[2];
1595 int pic_width = s->ps.sps->width >> 1;
1596 int pic_height = s->ps.sps->height >> 1;
1601 x_off += mv->x >> 3;
1602 y_off += mv->y >> 3;
1603 src1 += y_off * src1stride + (x_off << s->ps.sps->pixel_shift);
1604 src2 += y_off * src2stride + (x_off << s->ps.sps->pixel_shift);
1606 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1607 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1608 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1609 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1610 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->ps.sps->pixel_shift));
1611 int buf_offset1 = EPEL_EXTRA_BEFORE *
1612 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1613 int offset2 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->ps.sps->pixel_shift));
1614 int buf_offset2 = EPEL_EXTRA_BEFORE *
1615 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1617 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1618 edge_emu_stride, src1stride,
1619 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1620 x_off - EPEL_EXTRA_BEFORE,
1621 y_off - EPEL_EXTRA_BEFORE,
1622 pic_width, pic_height);
1624 src1 = lc->edge_emu_buffer + buf_offset1;
1625 src1stride = edge_emu_stride;
1626 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst1, dststride, src1, src1stride,
1627 block_w, block_h, mx, my, lc->mc_buffer);
1629 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src2 - offset2,
1630 edge_emu_stride, src2stride,
1631 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1632 x_off - EPEL_EXTRA_BEFORE,
1633 y_off - EPEL_EXTRA_BEFORE,
1634 pic_width, pic_height);
1635 src2 = lc->edge_emu_buffer + buf_offset2;
1636 src2stride = edge_emu_stride;
1638 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst2, dststride, src2, src2stride,
1639 block_w, block_h, mx, my,
1642 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst1, dststride, src1, src1stride,
1643 block_w, block_h, mx, my,
1645 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst2, dststride, src2, src2stride,
1646 block_w, block_h, mx, my,
1651 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1652 const Mv *mv, int y0, int height)
1654 int y = (mv->y >> 2) + y0 + height + 9;
1655 ff_thread_await_progress(&ref->tf, y, 0);
1658 static void hevc_luma_mv_mpv_mode(HEVCContext *s, int x0, int y0, int nPbW,
1659 int nPbH, int log2_cb_size, int part_idx,
1660 int merge_idx, MvField *mv)
1662 HEVCLocalContext *lc = &s->HEVClc;
1663 enum InterPredIdc inter_pred_idc = PRED_L0;
1666 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1667 if (s->sh.slice_type == B_SLICE)
1668 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1670 if (inter_pred_idc != PRED_L1) {
1671 if (s->sh.nb_refs[L0])
1672 mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1674 mv->pred_flag[0] = 1;
1675 hls_mvd_coding(s, x0, y0, 0);
1676 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1677 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1678 part_idx, merge_idx, mv, mvp_flag, 0);
1679 mv->mv[0].x += lc->pu.mvd.x;
1680 mv->mv[0].y += lc->pu.mvd.y;
1683 if (inter_pred_idc != PRED_L0) {
1684 if (s->sh.nb_refs[L1])
1685 mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1687 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1688 AV_ZERO32(&lc->pu.mvd);
1690 hls_mvd_coding(s, x0, y0, 1);
1693 mv->pred_flag[1] = 1;
1694 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1695 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1696 part_idx, merge_idx, mv, mvp_flag, 1);
1697 mv->mv[1].x += lc->pu.mvd.x;
1698 mv->mv[1].y += lc->pu.mvd.y;
1702 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1704 int log2_cb_size, int partIdx)
1706 #define POS(c_idx, x, y) \
1707 &s->frame->data[c_idx][((y) >> s->ps.sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1708 (((x) >> s->ps.sps->hshift[c_idx]) << s->ps.sps->pixel_shift)]
1709 HEVCLocalContext *lc = &s->HEVClc;
1711 struct MvField current_mv = {{{ 0 }}};
1713 int min_pu_width = s->ps.sps->min_pu_width;
1715 MvField *tab_mvf = s->ref->tab_mvf;
1716 RefPicList *refPicList = s->ref->refPicList;
1717 HEVCFrame *ref0, *ref1;
1719 int tmpstride = MAX_PB_SIZE;
1721 uint8_t *dst0 = POS(0, x0, y0);
1722 uint8_t *dst1 = POS(1, x0, y0);
1723 uint8_t *dst2 = POS(2, x0, y0);
1724 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
1725 int min_cb_width = s->ps.sps->min_cb_width;
1726 int x_cb = x0 >> log2_min_cb_size;
1727 int y_cb = y0 >> log2_min_cb_size;
1731 int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1734 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1736 if (skip_flag || lc->pu.merge_flag) {
1737 if (s->sh.max_num_merge_cand > 1)
1738 merge_idx = ff_hevc_merge_idx_decode(s);
1742 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1743 partIdx, merge_idx, ¤t_mv);
1745 hevc_luma_mv_mpv_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1746 partIdx, merge_idx, ¤t_mv);
1749 x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1750 y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1752 for (j = 0; j < nPbH >> s->ps.sps->log2_min_pu_size; j++)
1753 for (i = 0; i < nPbW >> s->ps.sps->log2_min_pu_size; i++)
1754 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1756 if (current_mv.pred_flag[0]) {
1757 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1760 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1762 if (current_mv.pred_flag[1]) {
1763 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1766 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1769 if (current_mv.pred_flag[0] && !current_mv.pred_flag[1]) {
1770 DECLARE_ALIGNED(16, int16_t, tmp[MAX_PB_SIZE * MAX_PB_SIZE]);
1771 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1773 luma_mc(s, tmp, tmpstride, ref0->frame,
1774 ¤t_mv.mv[0], x0, y0, nPbW, nPbH);
1776 if ((s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1777 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag)) {
1778 s->hevcdsp.weighted_pred(s->sh.luma_log2_weight_denom,
1779 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1780 s->sh.luma_offset_l0[current_mv.ref_idx[0]],
1781 dst0, s->frame->linesize[0], tmp,
1782 tmpstride, nPbW, nPbH);
1784 s->hevcdsp.put_unweighted_pred(dst0, s->frame->linesize[0], tmp, tmpstride, nPbW, nPbH);
1786 chroma_mc(s, tmp, tmp2, tmpstride, ref0->frame,
1787 ¤t_mv.mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1789 if ((s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1790 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag)) {
1791 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1792 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0],
1793 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0],
1794 dst1, s->frame->linesize[1], tmp, tmpstride,
1795 nPbW / 2, nPbH / 2);
1796 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1797 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1],
1798 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1],
1799 dst2, s->frame->linesize[2], tmp2, tmpstride,
1800 nPbW / 2, nPbH / 2);
1802 s->hevcdsp.put_unweighted_pred(dst1, s->frame->linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1803 s->hevcdsp.put_unweighted_pred(dst2, s->frame->linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1805 } else if (!current_mv.pred_flag[0] && current_mv.pred_flag[1]) {
1806 DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1807 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1809 luma_mc(s, tmp, tmpstride, ref1->frame,
1810 ¤t_mv.mv[1], x0, y0, nPbW, nPbH);
1812 if ((s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1813 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag)) {
1814 s->hevcdsp.weighted_pred(s->sh.luma_log2_weight_denom,
1815 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1816 s->sh.luma_offset_l1[current_mv.ref_idx[1]],
1817 dst0, s->frame->linesize[0], tmp, tmpstride,
1820 s->hevcdsp.put_unweighted_pred(dst0, s->frame->linesize[0], tmp, tmpstride, nPbW, nPbH);
1823 chroma_mc(s, tmp, tmp2, tmpstride, ref1->frame,
1824 ¤t_mv.mv[1], x0/2, y0/2, nPbW/2, nPbH/2);
1826 if ((s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1827 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag)) {
1828 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1829 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0],
1830 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0],
1831 dst1, s->frame->linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1832 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1833 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1],
1834 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1],
1835 dst2, s->frame->linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1837 s->hevcdsp.put_unweighted_pred(dst1, s->frame->linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1838 s->hevcdsp.put_unweighted_pred(dst2, s->frame->linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1840 } else if (current_mv.pred_flag[0] && current_mv.pred_flag[1]) {
1841 DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1842 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1843 DECLARE_ALIGNED(16, int16_t, tmp3[MAX_PB_SIZE * MAX_PB_SIZE]);
1844 DECLARE_ALIGNED(16, int16_t, tmp4[MAX_PB_SIZE * MAX_PB_SIZE]);
1846 luma_mc(s, tmp, tmpstride, ref0->frame,
1847 ¤t_mv.mv[0], x0, y0, nPbW, nPbH);
1848 luma_mc(s, tmp2, tmpstride, ref1->frame,
1849 ¤t_mv.mv[1], x0, y0, nPbW, nPbH);
1851 if ((s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1852 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag)) {
1853 s->hevcdsp.weighted_pred_avg(s->sh.luma_log2_weight_denom,
1854 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1855 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1856 s->sh.luma_offset_l0[current_mv.ref_idx[0]],
1857 s->sh.luma_offset_l1[current_mv.ref_idx[1]],
1858 dst0, s->frame->linesize[0],
1859 tmp, tmp2, tmpstride, nPbW, nPbH);
1861 s->hevcdsp.put_weighted_pred_avg(dst0, s->frame->linesize[0],
1862 tmp, tmp2, tmpstride, nPbW, nPbH);
1865 chroma_mc(s, tmp, tmp2, tmpstride, ref0->frame,
1866 ¤t_mv.mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1867 chroma_mc(s, tmp3, tmp4, tmpstride, ref1->frame,
1868 ¤t_mv.mv[1], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1870 if ((s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1871 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag)) {
1872 s->hevcdsp.weighted_pred_avg(s->sh.chroma_log2_weight_denom,
1873 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0],
1874 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0],
1875 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0],
1876 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0],
1877 dst1, s->frame->linesize[1], tmp, tmp3,
1878 tmpstride, nPbW / 2, nPbH / 2);
1879 s->hevcdsp.weighted_pred_avg(s->sh.chroma_log2_weight_denom,
1880 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1],
1881 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1],
1882 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1],
1883 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1],
1884 dst2, s->frame->linesize[2], tmp2, tmp4,
1885 tmpstride, nPbW / 2, nPbH / 2);
1887 s->hevcdsp.put_weighted_pred_avg(dst1, s->frame->linesize[1], tmp, tmp3, tmpstride, nPbW/2, nPbH/2);
1888 s->hevcdsp.put_weighted_pred_avg(dst2, s->frame->linesize[2], tmp2, tmp4, tmpstride, nPbW/2, nPbH/2);
1896 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1897 int prev_intra_luma_pred_flag)
1899 HEVCLocalContext *lc = &s->HEVClc;
1900 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1901 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1902 int min_pu_width = s->ps.sps->min_pu_width;
1903 int size_in_pus = pu_size >> s->ps.sps->log2_min_pu_size;
1904 int x0b = x0 & ((1 << s->ps.sps->log2_ctb_size) - 1);
1905 int y0b = y0 & ((1 << s->ps.sps->log2_ctb_size) - 1);
1907 int cand_up = (lc->ctb_up_flag || y0b) ?
1908 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1909 int cand_left = (lc->ctb_left_flag || x0b) ?
1910 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1912 int y_ctb = (y0 >> (s->ps.sps->log2_ctb_size)) << (s->ps.sps->log2_ctb_size);
1914 MvField *tab_mvf = s->ref->tab_mvf;
1915 int intra_pred_mode;
1919 // intra_pred_mode prediction does not cross vertical CTB boundaries
1920 if ((y0 - 1) < y_ctb)
1923 if (cand_left == cand_up) {
1924 if (cand_left < 2) {
1925 candidate[0] = INTRA_PLANAR;
1926 candidate[1] = INTRA_DC;
1927 candidate[2] = INTRA_ANGULAR_26;
1929 candidate[0] = cand_left;
1930 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1931 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1934 candidate[0] = cand_left;
1935 candidate[1] = cand_up;
1936 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1937 candidate[2] = INTRA_PLANAR;
1938 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1939 candidate[2] = INTRA_DC;
1941 candidate[2] = INTRA_ANGULAR_26;
1945 if (prev_intra_luma_pred_flag) {
1946 intra_pred_mode = candidate[lc->pu.mpm_idx];
1948 if (candidate[0] > candidate[1])
1949 FFSWAP(uint8_t, candidate[0], candidate[1]);
1950 if (candidate[0] > candidate[2])
1951 FFSWAP(uint8_t, candidate[0], candidate[2]);
1952 if (candidate[1] > candidate[2])
1953 FFSWAP(uint8_t, candidate[1], candidate[2]);
1955 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1956 for (i = 0; i < 3; i++)
1957 if (intra_pred_mode >= candidate[i])
1961 /* write the intra prediction units into the mv array */
1964 for (i = 0; i < size_in_pus; i++) {
1965 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1966 intra_pred_mode, size_in_pus);
1968 for (j = 0; j < size_in_pus; j++) {
1969 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].is_intra = 1;
1970 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[0] = 0;
1971 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[1] = 0;
1972 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[0] = 0;
1973 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[1] = 0;
1974 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].x = 0;
1975 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].y = 0;
1976 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].x = 0;
1977 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].y = 0;
1981 return intra_pred_mode;
1984 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1985 int log2_cb_size, int ct_depth)
1987 int length = (1 << log2_cb_size) >> s->ps.sps->log2_min_cb_size;
1988 int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
1989 int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
1992 for (y = 0; y < length; y++)
1993 memset(&s->tab_ct_depth[(y_cb + y) * s->ps.sps->min_cb_width + x_cb],
1997 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
2000 HEVCLocalContext *lc = &s->HEVClc;
2001 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
2002 uint8_t prev_intra_luma_pred_flag[4];
2003 int split = lc->cu.part_mode == PART_NxN;
2004 int pb_size = (1 << log2_cb_size) >> split;
2005 int side = split + 1;
2009 for (i = 0; i < side; i++)
2010 for (j = 0; j < side; j++)
2011 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
2013 for (i = 0; i < side; i++) {
2014 for (j = 0; j < side; j++) {
2015 if (prev_intra_luma_pred_flag[2 * i + j])
2016 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
2018 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
2020 lc->pu.intra_pred_mode[2 * i + j] =
2021 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
2022 prev_intra_luma_pred_flag[2 * i + j]);
2026 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
2027 if (chroma_mode != 4) {
2028 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
2029 lc->pu.intra_pred_mode_c = 34;
2031 lc->pu.intra_pred_mode_c = intra_chroma_table[chroma_mode];
2033 lc->pu.intra_pred_mode_c = lc->pu.intra_pred_mode[0];
2037 static void intra_prediction_unit_default_value(HEVCContext *s,
2041 HEVCLocalContext *lc = &s->HEVClc;
2042 int pb_size = 1 << log2_cb_size;
2043 int size_in_pus = pb_size >> s->ps.sps->log2_min_pu_size;
2044 int min_pu_width = s->ps.sps->min_pu_width;
2045 MvField *tab_mvf = s->ref->tab_mvf;
2046 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
2047 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
2050 if (size_in_pus == 0)
2052 for (j = 0; j < size_in_pus; j++) {
2053 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
2054 for (k = 0; k < size_in_pus; k++)
2055 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].is_intra = lc->cu.pred_mode == MODE_INTRA;
2059 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
2061 int cb_size = 1 << log2_cb_size;
2062 HEVCLocalContext *lc = &s->HEVClc;
2063 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
2064 int length = cb_size >> log2_min_cb_size;
2065 int min_cb_width = s->ps.sps->min_cb_width;
2066 int x_cb = x0 >> log2_min_cb_size;
2067 int y_cb = y0 >> log2_min_cb_size;
2072 lc->cu.pred_mode = MODE_INTRA;
2073 lc->cu.part_mode = PART_2Nx2N;
2074 lc->cu.intra_split_flag = 0;
2076 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
2077 for (x = 0; x < 4; x++)
2078 lc->pu.intra_pred_mode[x] = 1;
2079 if (s->ps.pps->transquant_bypass_enable_flag) {
2080 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
2081 if (lc->cu.cu_transquant_bypass_flag)
2082 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2084 lc->cu.cu_transquant_bypass_flag = 0;
2086 if (s->sh.slice_type != I_SLICE) {
2087 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
2089 x = y_cb * min_cb_width + x_cb;
2090 for (y = 0; y < length; y++) {
2091 memset(&s->skip_flag[x], skip_flag, length);
2094 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2097 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2098 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0);
2099 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2101 if (!s->sh.disable_deblocking_filter_flag)
2102 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2106 if (s->sh.slice_type != I_SLICE)
2107 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2108 if (lc->cu.pred_mode != MODE_INTRA ||
2109 log2_cb_size == s->ps.sps->log2_min_cb_size) {
2110 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2111 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2112 lc->cu.pred_mode == MODE_INTRA;
2115 if (lc->cu.pred_mode == MODE_INTRA) {
2116 if (lc->cu.part_mode == PART_2Nx2N && s->ps.sps->pcm_enabled_flag &&
2117 log2_cb_size >= s->ps.sps->pcm.log2_min_pcm_cb_size &&
2118 log2_cb_size <= s->ps.sps->pcm.log2_max_pcm_cb_size) {
2119 pcm_flag = ff_hevc_pcm_flag_decode(s);
2122 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2123 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2124 if (s->ps.sps->pcm.loop_filter_disable_flag)
2125 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2130 intra_prediction_unit(s, x0, y0, log2_cb_size);
2133 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2134 switch (lc->cu.part_mode) {
2136 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0);
2139 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0);
2140 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1);
2143 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0);
2144 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1);
2147 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0);
2148 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1);
2151 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0);
2152 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1);
2155 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0);
2156 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1);
2159 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0);
2160 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1);
2163 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0);
2164 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1);
2165 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2);
2166 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3);
2172 int rqt_root_cbf = 1;
2174 if (lc->cu.pred_mode != MODE_INTRA &&
2175 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2176 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2179 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2180 s->ps.sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2181 s->ps.sps->max_transform_hierarchy_depth_inter;
2182 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2184 log2_cb_size, 0, 0, 0, 0);
2188 if (!s->sh.disable_deblocking_filter_flag)
2189 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2194 if (s->ps.pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2195 ff_hevc_set_qPy(s, x0, y0, x0, y0, log2_cb_size);
2197 x = y_cb * min_cb_width + x_cb;
2198 for (y = 0; y < length; y++) {
2199 memset(&s->qp_y_tab[x], lc->qp_y, length);
2203 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct.depth);
2208 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2209 int log2_cb_size, int cb_depth)
2211 HEVCLocalContext *lc = &s->HEVClc;
2212 const int cb_size = 1 << log2_cb_size;
2215 lc->ct.depth = cb_depth;
2216 if (x0 + cb_size <= s->ps.sps->width &&
2217 y0 + cb_size <= s->ps.sps->height &&
2218 log2_cb_size > s->ps.sps->log2_min_cb_size) {
2219 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2221 split_cu = (log2_cb_size > s->ps.sps->log2_min_cb_size);
2223 if (s->ps.pps->cu_qp_delta_enabled_flag &&
2224 log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth) {
2225 lc->tu.is_cu_qp_delta_coded = 0;
2226 lc->tu.cu_qp_delta = 0;
2230 const int cb_size_split = cb_size >> 1;
2231 const int x1 = x0 + cb_size_split;
2232 const int y1 = y0 + cb_size_split;
2237 #define SUBDIVIDE(x, y) \
2239 if (x < s->ps.sps->width && y < s->ps.sps->height) { \
2240 int ret = hls_coding_quadtree(s, x, y, log2_cb_size, cb_depth);\
2251 int ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2259 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2262 HEVCLocalContext *lc = &s->HEVClc;
2263 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2264 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2265 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2267 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2269 if (s->ps.pps->entropy_coding_sync_enabled_flag) {
2270 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2271 lc->first_qp_group = 1;
2272 lc->end_of_tiles_x = s->ps.sps->width;
2273 } else if (s->ps.pps->tiles_enabled_flag) {
2274 if (ctb_addr_ts && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
2275 int idxX = s->ps.pps->col_idxX[x_ctb >> s->ps.sps->log2_ctb_size];
2276 lc->start_of_tiles_x = x_ctb;
2277 lc->end_of_tiles_x = x_ctb + (s->ps.pps->column_width[idxX] << s->ps.sps->log2_ctb_size);
2278 lc->first_qp_group = 1;
2281 lc->end_of_tiles_x = s->ps.sps->width;
2284 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->ps.sps->height);
2286 lc->boundary_flags = 0;
2287 if (s->ps.pps->tiles_enabled_flag) {
2288 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]])
2289 lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2290 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2291 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2292 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]])
2293 lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2294 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->ps.sps->ctb_width])
2295 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2297 if (!ctb_addr_in_slice > 0)
2298 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2299 if (ctb_addr_in_slice < s->ps.sps->ctb_width)
2300 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2303 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2304 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->ps.sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2305 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]]));
2306 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]]));
2309 static int hls_slice_data(HEVCContext *s)
2311 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2315 int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2318 while (more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2319 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2321 x_ctb = (ctb_addr_rs % ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2322 y_ctb = (ctb_addr_rs / ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2323 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2325 ff_hevc_cabac_init(s, ctb_addr_ts);
2327 hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2329 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2330 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2331 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2333 ret = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2336 more_data = !ff_hevc_end_of_slice_flag_decode(s);
2339 ff_hevc_save_states(s, ctb_addr_ts);
2340 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2343 if (x_ctb + ctb_size >= s->ps.sps->width &&
2344 y_ctb + ctb_size >= s->ps.sps->height)
2345 ff_hevc_hls_filter(s, x_ctb, y_ctb);
2350 static void restore_tqb_pixels(HEVCContext *s)
2352 int min_pu_size = 1 << s->ps.sps->log2_min_pu_size;
2355 for (c_idx = 0; c_idx < 3; c_idx++) {
2356 ptrdiff_t stride = s->frame->linesize[c_idx];
2357 int hshift = s->ps.sps->hshift[c_idx];
2358 int vshift = s->ps.sps->vshift[c_idx];
2359 for (y = 0; y < s->ps.sps->min_pu_height; y++) {
2360 for (x = 0; x < s->ps.sps->min_pu_width; x++) {
2361 if (s->is_pcm[y * s->ps.sps->min_pu_width + x]) {
2363 int len = min_pu_size >> hshift;
2364 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)];
2365 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)];
2366 for (n = 0; n < (min_pu_size >> vshift); n++) {
2367 memcpy(dst, src, len);
2377 static int set_side_data(HEVCContext *s)
2379 AVFrame *out = s->ref->frame;
2381 if (s->sei_frame_packing_present &&
2382 s->frame_packing_arrangement_type >= 3 &&
2383 s->frame_packing_arrangement_type <= 5 &&
2384 s->content_interpretation_type > 0 &&
2385 s->content_interpretation_type < 3) {
2386 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2388 return AVERROR(ENOMEM);
2390 switch (s->frame_packing_arrangement_type) {
2392 if (s->quincunx_subsampling)
2393 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2395 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2398 stereo->type = AV_STEREO3D_TOPBOTTOM;
2401 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2405 if (s->content_interpretation_type == 2)
2406 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2409 if (s->sei_display_orientation_present &&
2410 (s->sei_anticlockwise_rotation || s->sei_hflip || s->sei_vflip)) {
2411 double angle = s->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
2412 AVFrameSideData *rotation = av_frame_new_side_data(out,
2413 AV_FRAME_DATA_DISPLAYMATRIX,
2414 sizeof(int32_t) * 9);
2416 return AVERROR(ENOMEM);
2418 av_display_rotation_set((int32_t *)rotation->data, angle);
2419 av_display_matrix_flip((int32_t *)rotation->data,
2420 s->sei_hflip, s->sei_vflip);
2426 static int hevc_frame_start(HEVCContext *s)
2428 HEVCLocalContext *lc = &s->HEVClc;
2431 memset(s->horizontal_bs, 0, 2 * s->bs_width * (s->bs_height + 1));
2432 memset(s->vertical_bs, 0, 2 * s->bs_width * (s->bs_height + 1));
2433 memset(s->cbf_luma, 0, s->ps.sps->min_tb_width * s->ps.sps->min_tb_height);
2434 memset(s->is_pcm, 0, s->ps.sps->min_pu_width * s->ps.sps->min_pu_height);
2436 lc->start_of_tiles_x = 0;
2438 s->first_nal_type = s->nal_unit_type;
2440 if (s->ps.pps->tiles_enabled_flag)
2441 lc->end_of_tiles_x = s->ps.pps->column_width[0] << s->ps.sps->log2_ctb_size;
2443 ret = ff_hevc_set_new_ref(s, s->ps.sps->sao_enabled ? &s->sao_frame : &s->frame,
2448 ret = ff_hevc_frame_rps(s);
2450 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2454 s->ref->frame->key_frame = IS_IRAP(s);
2456 ret = set_side_data(s);
2460 av_frame_unref(s->output_frame);
2461 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2465 ff_thread_finish_setup(s->avctx);
2471 ff_hevc_unref_frame(s, s->ref, ~0);
2476 static int decode_nal_unit(HEVCContext *s, const HEVCNAL *nal)
2478 HEVCLocalContext *lc = &s->HEVClc;
2479 GetBitContext *gb = &lc->gb;
2480 int ctb_addr_ts, ret;
2483 s->nal_unit_type = nal->type;
2484 s->temporal_id = nal->temporal_id;
2486 switch (s->nal_unit_type) {
2488 ret = ff_hevc_decode_nal_vps(gb, s->avctx, &s->ps);
2493 ret = ff_hevc_decode_nal_sps(gb, s->avctx, &s->ps,
2494 s->apply_defdispwin);
2499 ret = ff_hevc_decode_nal_pps(gb, s->avctx, &s->ps);
2503 case NAL_SEI_PREFIX:
2504 case NAL_SEI_SUFFIX:
2505 ret = ff_hevc_decode_nal_sei(s);
2516 case NAL_BLA_W_RADL:
2518 case NAL_IDR_W_RADL:
2525 ret = hls_slice_header(s);
2529 if (s->max_ra == INT_MAX) {
2530 if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
2534 s->max_ra = INT_MIN;
2538 if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
2539 s->poc <= s->max_ra) {
2543 if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
2544 s->max_ra = INT_MIN;
2547 if (s->sh.first_slice_in_pic_flag) {
2548 ret = hevc_frame_start(s);
2551 } else if (!s->ref) {
2552 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2556 if (s->nal_unit_type != s->first_nal_type) {
2557 av_log(s->avctx, AV_LOG_ERROR,
2558 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2559 s->first_nal_type, s->nal_unit_type);
2560 return AVERROR_INVALIDDATA;
2563 if (!s->sh.dependent_slice_segment_flag &&
2564 s->sh.slice_type != I_SLICE) {
2565 ret = ff_hevc_slice_rpl(s);
2567 av_log(s->avctx, AV_LOG_WARNING,
2568 "Error constructing the reference lists for the current slice.\n");
2573 if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) {
2574 ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0);
2579 if (s->avctx->hwaccel) {
2580 ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size);
2584 ctb_addr_ts = hls_slice_data(s);
2585 if (ctb_addr_ts >= (s->ps.sps->ctb_width * s->ps.sps->ctb_height)) {
2587 if ((s->ps.pps->transquant_bypass_enable_flag ||
2588 (s->ps.sps->pcm.loop_filter_disable_flag && s->ps.sps->pcm_enabled_flag)) &&
2589 s->ps.sps->sao_enabled)
2590 restore_tqb_pixels(s);
2593 if (ctb_addr_ts < 0) {
2601 s->seq_decode = (s->seq_decode + 1) & 0xff;
2602 s->max_ra = INT_MAX;
2608 av_log(s->avctx, AV_LOG_INFO,
2609 "Skipping NAL unit %d\n", s->nal_unit_type);
2614 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2619 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2626 /* split the input packet into NAL units, so we know the upper bound on the
2627 * number of slices in the frame */
2628 ret = ff_hevc_split_packet(&s->pkt, buf, length, s->avctx, s->is_nalff,
2629 s->nal_length_size);
2631 av_log(s->avctx, AV_LOG_ERROR,
2632 "Error splitting the input into NAL units.\n");
2636 for (i = 0; i < s->pkt.nb_nals; i++) {
2637 if (s->pkt.nals[i].type == NAL_EOB_NUT ||
2638 s->pkt.nals[i].type == NAL_EOS_NUT)
2642 /* decode the NAL units */
2643 for (i = 0; i < s->pkt.nb_nals; i++) {
2644 ret = decode_nal_unit(s, &s->pkt.nals[i]);
2646 av_log(s->avctx, AV_LOG_WARNING,
2647 "Error parsing NAL unit #%d.\n", i);
2654 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2659 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2662 for (i = 0; i < 16; i++)
2663 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
2666 static int verify_md5(HEVCContext *s, AVFrame *frame)
2668 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
2673 return AVERROR(EINVAL);
2675 pixel_shift = desc->comp[0].depth_minus1 > 7;
2677 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
2680 /* the checksums are LE, so we have to byteswap for >8bpp formats
2683 if (pixel_shift && !s->checksum_buf) {
2684 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
2685 FFMAX3(frame->linesize[0], frame->linesize[1],
2686 frame->linesize[2]));
2687 if (!s->checksum_buf)
2688 return AVERROR(ENOMEM);
2692 for (i = 0; frame->data[i]; i++) {
2693 int width = s->avctx->coded_width;
2694 int height = s->avctx->coded_height;
2695 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
2696 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
2699 av_md5_init(s->md5_ctx);
2700 for (j = 0; j < h; j++) {
2701 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
2704 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
2705 (const uint16_t *) src, w);
2706 src = s->checksum_buf;
2709 av_md5_update(s->md5_ctx, src, w << pixel_shift);
2711 av_md5_final(s->md5_ctx, md5);
2713 if (!memcmp(md5, s->md5[i], 16)) {
2714 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
2715 print_md5(s->avctx, AV_LOG_DEBUG, md5);
2716 av_log (s->avctx, AV_LOG_DEBUG, "; ");
2718 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
2719 print_md5(s->avctx, AV_LOG_ERROR, md5);
2720 av_log (s->avctx, AV_LOG_ERROR, " != ");
2721 print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
2722 av_log (s->avctx, AV_LOG_ERROR, "\n");
2723 return AVERROR_INVALIDDATA;
2727 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2732 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
2736 HEVCContext *s = avctx->priv_data;
2739 ret = ff_hevc_output_frame(s, data, 1);
2748 ret = decode_nal_units(s, avpkt->data, avpkt->size);
2752 if (avctx->hwaccel) {
2753 if (s->ref && avctx->hwaccel->end_frame(avctx) < 0)
2754 av_log(avctx, AV_LOG_ERROR,
2755 "hardware accelerator failed to decode picture\n");
2757 /* verify the SEI checksum */
2758 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
2760 ret = verify_md5(s, s->ref->frame);
2761 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
2762 ff_hevc_unref_frame(s, s->ref, ~0);
2769 if (s->is_decoded) {
2770 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
2774 if (s->output_frame->buf[0]) {
2775 av_frame_move_ref(data, s->output_frame);
2782 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
2784 int ret = ff_thread_ref_frame(&dst->tf, &src->tf);
2788 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
2789 if (!dst->tab_mvf_buf)
2791 dst->tab_mvf = src->tab_mvf;
2793 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
2794 if (!dst->rpl_tab_buf)
2796 dst->rpl_tab = src->rpl_tab;
2798 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
2802 dst->poc = src->poc;
2803 dst->ctb_count = src->ctb_count;
2804 dst->window = src->window;
2805 dst->flags = src->flags;
2806 dst->sequence = src->sequence;
2808 if (src->hwaccel_picture_private) {
2809 dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
2810 if (!dst->hwaccel_priv_buf)
2812 dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
2817 ff_hevc_unref_frame(s, dst, ~0);
2818 return AVERROR(ENOMEM);
2821 static av_cold int hevc_decode_free(AVCodecContext *avctx)
2823 HEVCContext *s = avctx->priv_data;
2828 av_freep(&s->md5_ctx);
2830 av_frame_free(&s->tmp_frame);
2831 av_frame_free(&s->output_frame);
2833 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2834 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
2835 av_frame_free(&s->DPB[i].frame);
2838 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++)
2839 av_buffer_unref(&s->ps.vps_list[i]);
2840 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++)
2841 av_buffer_unref(&s->ps.sps_list[i]);
2842 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++)
2843 av_buffer_unref(&s->ps.pps_list[i]);
2845 for (i = 0; i < s->pkt.nals_allocated; i++)
2846 av_freep(&s->pkt.nals[i].rbsp_buffer);
2847 av_freep(&s->pkt.nals);
2848 s->pkt.nals_allocated = 0;
2853 static av_cold int hevc_init_context(AVCodecContext *avctx)
2855 HEVCContext *s = avctx->priv_data;
2860 s->tmp_frame = av_frame_alloc();
2864 s->output_frame = av_frame_alloc();
2865 if (!s->output_frame)
2868 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2869 s->DPB[i].frame = av_frame_alloc();
2870 if (!s->DPB[i].frame)
2872 s->DPB[i].tf.f = s->DPB[i].frame;
2875 s->max_ra = INT_MAX;
2877 s->md5_ctx = av_md5_alloc();
2881 ff_bswapdsp_init(&s->bdsp);
2883 s->context_initialized = 1;
2888 hevc_decode_free(avctx);
2889 return AVERROR(ENOMEM);
2892 static int hevc_update_thread_context(AVCodecContext *dst,
2893 const AVCodecContext *src)
2895 HEVCContext *s = dst->priv_data;
2896 HEVCContext *s0 = src->priv_data;
2899 if (!s->context_initialized) {
2900 ret = hevc_init_context(dst);
2905 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2906 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
2907 if (s0->DPB[i].frame->buf[0]) {
2908 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
2914 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++) {
2915 av_buffer_unref(&s->ps.vps_list[i]);
2916 if (s0->ps.vps_list[i]) {
2917 s->ps.vps_list[i] = av_buffer_ref(s0->ps.vps_list[i]);
2918 if (!s->ps.vps_list[i])
2919 return AVERROR(ENOMEM);
2923 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
2924 av_buffer_unref(&s->ps.sps_list[i]);
2925 if (s0->ps.sps_list[i]) {
2926 s->ps.sps_list[i] = av_buffer_ref(s0->ps.sps_list[i]);
2927 if (!s->ps.sps_list[i])
2928 return AVERROR(ENOMEM);
2932 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++) {
2933 av_buffer_unref(&s->ps.pps_list[i]);
2934 if (s0->ps.pps_list[i]) {
2935 s->ps.pps_list[i] = av_buffer_ref(s0->ps.pps_list[i]);
2936 if (!s->ps.pps_list[i])
2937 return AVERROR(ENOMEM);
2941 if (s->ps.sps != s0->ps.sps)
2942 ret = set_sps(s, s0->ps.sps);
2944 s->seq_decode = s0->seq_decode;
2945 s->seq_output = s0->seq_output;
2946 s->pocTid0 = s0->pocTid0;
2947 s->max_ra = s0->max_ra;
2949 s->is_nalff = s0->is_nalff;
2950 s->nal_length_size = s0->nal_length_size;
2953 s->seq_decode = (s->seq_decode + 1) & 0xff;
2954 s->max_ra = INT_MAX;
2960 static int hevc_decode_extradata(HEVCContext *s)
2962 AVCodecContext *avctx = s->avctx;
2966 bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
2968 if (avctx->extradata_size > 3 &&
2969 (avctx->extradata[0] || avctx->extradata[1] ||
2970 avctx->extradata[2] > 1)) {
2971 /* It seems the extradata is encoded as hvcC format.
2972 * Temporarily, we support configurationVersion==0 until 14496-15 3rd
2973 * is finalized. When finalized, configurationVersion will be 1 and we
2974 * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
2975 int i, j, num_arrays, nal_len_size;
2979 bytestream2_skip(&gb, 21);
2980 nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
2981 num_arrays = bytestream2_get_byte(&gb);
2983 /* nal units in the hvcC always have length coded with 2 bytes,
2984 * so put a fake nal_length_size = 2 while parsing them */
2985 s->nal_length_size = 2;
2987 /* Decode nal units from hvcC. */
2988 for (i = 0; i < num_arrays; i++) {
2989 int type = bytestream2_get_byte(&gb) & 0x3f;
2990 int cnt = bytestream2_get_be16(&gb);
2992 for (j = 0; j < cnt; j++) {
2993 // +2 for the nal size field
2994 int nalsize = bytestream2_peek_be16(&gb) + 2;
2995 if (bytestream2_get_bytes_left(&gb) < nalsize) {
2996 av_log(s->avctx, AV_LOG_ERROR,
2997 "Invalid NAL unit size in extradata.\n");
2998 return AVERROR_INVALIDDATA;
3001 ret = decode_nal_units(s, gb.buffer, nalsize);
3003 av_log(avctx, AV_LOG_ERROR,
3004 "Decoding nal unit %d %d from hvcC failed\n",
3008 bytestream2_skip(&gb, nalsize);
3012 /* Now store right nal length size, that will be used to parse
3014 s->nal_length_size = nal_len_size;
3017 ret = decode_nal_units(s, avctx->extradata, avctx->extradata_size);
3022 /* export stream parameters from the first SPS */
3023 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3024 if (s->ps.sps_list[i]) {
3025 const HEVCSPS *sps = (const HEVCSPS*)s->ps.sps_list[i]->data;
3026 export_stream_params(s->avctx, &s->ps, sps);
3034 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3036 HEVCContext *s = avctx->priv_data;
3039 ff_init_cabac_states();
3041 avctx->internal->allocate_progress = 1;
3043 ret = hevc_init_context(avctx);
3047 if (avctx->extradata_size > 0 && avctx->extradata) {
3048 ret = hevc_decode_extradata(s);
3050 hevc_decode_free(avctx);
3058 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3060 HEVCContext *s = avctx->priv_data;
3063 memset(s, 0, sizeof(*s));
3065 ret = hevc_init_context(avctx);
3072 static void hevc_decode_flush(AVCodecContext *avctx)
3074 HEVCContext *s = avctx->priv_data;
3075 ff_hevc_flush_dpb(s);
3076 s->max_ra = INT_MAX;
3079 #define OFFSET(x) offsetof(HEVCContext, x)
3080 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3082 static const AVProfile profiles[] = {
3083 { FF_PROFILE_HEVC_MAIN, "Main" },
3084 { FF_PROFILE_HEVC_MAIN_10, "Main 10" },
3085 { FF_PROFILE_HEVC_MAIN_STILL_PICTURE, "Main Still Picture" },
3086 { FF_PROFILE_UNKNOWN },
3089 static const AVOption options[] = {
3090 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3091 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3095 static const AVClass hevc_decoder_class = {
3096 .class_name = "HEVC decoder",
3097 .item_name = av_default_item_name,
3099 .version = LIBAVUTIL_VERSION_INT,
3102 AVCodec ff_hevc_decoder = {
3104 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3105 .type = AVMEDIA_TYPE_VIDEO,
3106 .id = AV_CODEC_ID_HEVC,
3107 .priv_data_size = sizeof(HEVCContext),
3108 .priv_class = &hevc_decoder_class,
3109 .init = hevc_decode_init,
3110 .close = hevc_decode_free,
3111 .decode = hevc_decode_frame,
3112 .flush = hevc_decode_flush,
3113 .update_thread_context = hevc_update_thread_context,
3114 .init_thread_copy = hevc_init_thread_copy,
3115 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY |
3116 CODEC_CAP_FRAME_THREADS,
3117 .profiles = NULL_IF_CONFIG_SMALL(profiles),