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,
387 const HEVCContext *s, const HEVCSPS *sps)
389 const HEVCVPS *vps = (const HEVCVPS*)s->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;
438 export_stream_params(s->avctx, s, sps);
441 ret = pic_arrays_init(s, sps);
445 if (sps->pix_fmt == AV_PIX_FMT_YUV420P || sps->pix_fmt == AV_PIX_FMT_YUVJ420P) {
446 #if CONFIG_HEVC_DXVA2_HWACCEL
447 *fmt++ = AV_PIX_FMT_DXVA2_VLD;
449 #if CONFIG_HEVC_D3D11VA_HWACCEL
450 *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
454 *fmt++ = sps->pix_fmt;
455 *fmt = AV_PIX_FMT_NONE;
457 ret = ff_get_format(s->avctx, pix_fmts);
460 s->avctx->pix_fmt = ret;
462 ff_hevc_pred_init(&s->hpc, sps->bit_depth);
463 ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
464 ff_videodsp_init (&s->vdsp, sps->bit_depth);
466 if (sps->sao_enabled && !s->avctx->hwaccel) {
467 av_frame_unref(s->tmp_frame);
468 ret = ff_get_buffer(s->avctx, s->tmp_frame, AV_GET_BUFFER_FLAG_REF);
471 s->frame = s->tmp_frame;
475 s->ps.vps = (HEVCVPS*) s->ps.vps_list[s->ps.sps->vps_id]->data;
485 static int hls_slice_header(HEVCContext *s)
487 GetBitContext *gb = &s->HEVClc.gb;
488 SliceHeader *sh = &s->sh;
492 sh->first_slice_in_pic_flag = get_bits1(gb);
493 if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
494 s->seq_decode = (s->seq_decode + 1) & 0xff;
497 ff_hevc_clear_refs(s);
500 sh->no_output_of_prior_pics_flag = get_bits1(gb);
502 sh->pps_id = get_ue_golomb_long(gb);
503 if (sh->pps_id >= MAX_PPS_COUNT || !s->ps.pps_list[sh->pps_id]) {
504 av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
505 return AVERROR_INVALIDDATA;
507 if (!sh->first_slice_in_pic_flag &&
508 s->ps.pps != (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data) {
509 av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
510 return AVERROR_INVALIDDATA;
512 s->ps.pps = (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data;
514 if (s->ps.sps != (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data) {
515 s->ps.sps = (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data;
517 ff_hevc_clear_refs(s);
518 ret = set_sps(s, s->ps.sps);
522 s->seq_decode = (s->seq_decode + 1) & 0xff;
526 sh->dependent_slice_segment_flag = 0;
527 if (!sh->first_slice_in_pic_flag) {
528 int slice_address_length;
530 if (s->ps.pps->dependent_slice_segments_enabled_flag)
531 sh->dependent_slice_segment_flag = get_bits1(gb);
533 slice_address_length = av_ceil_log2(s->ps.sps->ctb_width *
534 s->ps.sps->ctb_height);
535 sh->slice_segment_addr = slice_address_length ? get_bits(gb, slice_address_length) : 0;
536 if (sh->slice_segment_addr >= s->ps.sps->ctb_width * s->ps.sps->ctb_height) {
537 av_log(s->avctx, AV_LOG_ERROR,
538 "Invalid slice segment address: %u.\n",
539 sh->slice_segment_addr);
540 return AVERROR_INVALIDDATA;
543 if (!sh->dependent_slice_segment_flag) {
544 sh->slice_addr = sh->slice_segment_addr;
548 sh->slice_segment_addr = sh->slice_addr = 0;
550 s->slice_initialized = 0;
553 if (!sh->dependent_slice_segment_flag) {
554 s->slice_initialized = 0;
556 for (i = 0; i < s->ps.pps->num_extra_slice_header_bits; i++)
557 skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
559 sh->slice_type = get_ue_golomb_long(gb);
560 if (!(sh->slice_type == I_SLICE ||
561 sh->slice_type == P_SLICE ||
562 sh->slice_type == B_SLICE)) {
563 av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
565 return AVERROR_INVALIDDATA;
567 if (IS_IRAP(s) && sh->slice_type != I_SLICE) {
568 av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
569 return AVERROR_INVALIDDATA;
572 // when flag is not present, picture is inferred to be output
573 sh->pic_output_flag = 1;
574 if (s->ps.pps->output_flag_present_flag)
575 sh->pic_output_flag = get_bits1(gb);
577 if (s->ps.sps->separate_colour_plane_flag)
578 sh->colour_plane_id = get_bits(gb, 2);
583 sh->pic_order_cnt_lsb = get_bits(gb, s->ps.sps->log2_max_poc_lsb);
584 poc = ff_hevc_compute_poc(s, sh->pic_order_cnt_lsb);
585 if (!sh->first_slice_in_pic_flag && poc != s->poc) {
586 av_log(s->avctx, AV_LOG_WARNING,
587 "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
588 if (s->avctx->err_recognition & AV_EF_EXPLODE)
589 return AVERROR_INVALIDDATA;
594 sh->short_term_ref_pic_set_sps_flag = get_bits1(gb);
595 if (!sh->short_term_ref_pic_set_sps_flag) {
596 int pos = get_bits_left(gb);
597 ret = ff_hevc_decode_short_term_rps(gb, s->avctx, &sh->slice_rps, s->ps.sps, 1);
601 sh->short_term_ref_pic_set_size = pos - get_bits_left(gb);
602 sh->short_term_rps = &sh->slice_rps;
604 int numbits, rps_idx;
606 if (!s->ps.sps->nb_st_rps) {
607 av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
608 return AVERROR_INVALIDDATA;
611 numbits = av_ceil_log2(s->ps.sps->nb_st_rps);
612 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
613 sh->short_term_rps = &s->ps.sps->st_rps[rps_idx];
616 ret = decode_lt_rps(s, &sh->long_term_rps, gb);
618 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
619 if (s->avctx->err_recognition & AV_EF_EXPLODE)
620 return AVERROR_INVALIDDATA;
623 if (s->ps.sps->sps_temporal_mvp_enabled_flag)
624 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
626 sh->slice_temporal_mvp_enabled_flag = 0;
628 s->sh.short_term_rps = NULL;
633 if (s->temporal_id == 0 &&
634 s->nal_unit_type != NAL_TRAIL_N &&
635 s->nal_unit_type != NAL_TSA_N &&
636 s->nal_unit_type != NAL_STSA_N &&
637 s->nal_unit_type != NAL_RADL_N &&
638 s->nal_unit_type != NAL_RADL_R &&
639 s->nal_unit_type != NAL_RASL_N &&
640 s->nal_unit_type != NAL_RASL_R)
643 if (s->ps.sps->sao_enabled) {
644 sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
645 sh->slice_sample_adaptive_offset_flag[1] =
646 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
648 sh->slice_sample_adaptive_offset_flag[0] = 0;
649 sh->slice_sample_adaptive_offset_flag[1] = 0;
650 sh->slice_sample_adaptive_offset_flag[2] = 0;
653 sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
654 if (sh->slice_type == P_SLICE || sh->slice_type == B_SLICE) {
657 sh->nb_refs[L0] = s->ps.pps->num_ref_idx_l0_default_active;
658 if (sh->slice_type == B_SLICE)
659 sh->nb_refs[L1] = s->ps.pps->num_ref_idx_l1_default_active;
661 if (get_bits1(gb)) { // num_ref_idx_active_override_flag
662 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
663 if (sh->slice_type == B_SLICE)
664 sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
666 if (sh->nb_refs[L0] > MAX_REFS || sh->nb_refs[L1] > MAX_REFS) {
667 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
668 sh->nb_refs[L0], sh->nb_refs[L1]);
669 return AVERROR_INVALIDDATA;
672 sh->rpl_modification_flag[0] = 0;
673 sh->rpl_modification_flag[1] = 0;
674 nb_refs = ff_hevc_frame_nb_refs(s);
676 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
677 return AVERROR_INVALIDDATA;
680 if (s->ps.pps->lists_modification_present_flag && nb_refs > 1) {
681 sh->rpl_modification_flag[0] = get_bits1(gb);
682 if (sh->rpl_modification_flag[0]) {
683 for (i = 0; i < sh->nb_refs[L0]; i++)
684 sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
687 if (sh->slice_type == B_SLICE) {
688 sh->rpl_modification_flag[1] = get_bits1(gb);
689 if (sh->rpl_modification_flag[1] == 1)
690 for (i = 0; i < sh->nb_refs[L1]; i++)
691 sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
695 if (sh->slice_type == B_SLICE)
696 sh->mvd_l1_zero_flag = get_bits1(gb);
698 if (s->ps.pps->cabac_init_present_flag)
699 sh->cabac_init_flag = get_bits1(gb);
701 sh->cabac_init_flag = 0;
703 sh->collocated_ref_idx = 0;
704 if (sh->slice_temporal_mvp_enabled_flag) {
705 sh->collocated_list = L0;
706 if (sh->slice_type == B_SLICE)
707 sh->collocated_list = !get_bits1(gb);
709 if (sh->nb_refs[sh->collocated_list] > 1) {
710 sh->collocated_ref_idx = get_ue_golomb_long(gb);
711 if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
712 av_log(s->avctx, AV_LOG_ERROR,
713 "Invalid collocated_ref_idx: %d.\n",
714 sh->collocated_ref_idx);
715 return AVERROR_INVALIDDATA;
720 if ((s->ps.pps->weighted_pred_flag && sh->slice_type == P_SLICE) ||
721 (s->ps.pps->weighted_bipred_flag && sh->slice_type == B_SLICE)) {
722 pred_weight_table(s, gb);
725 sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
726 if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
727 av_log(s->avctx, AV_LOG_ERROR,
728 "Invalid number of merging MVP candidates: %d.\n",
729 sh->max_num_merge_cand);
730 return AVERROR_INVALIDDATA;
734 sh->slice_qp_delta = get_se_golomb(gb);
736 if (s->ps.pps->pic_slice_level_chroma_qp_offsets_present_flag) {
737 sh->slice_cb_qp_offset = get_se_golomb(gb);
738 sh->slice_cr_qp_offset = get_se_golomb(gb);
740 sh->slice_cb_qp_offset = 0;
741 sh->slice_cr_qp_offset = 0;
744 if (s->ps.pps->deblocking_filter_control_present_flag) {
745 int deblocking_filter_override_flag = 0;
747 if (s->ps.pps->deblocking_filter_override_enabled_flag)
748 deblocking_filter_override_flag = get_bits1(gb);
750 if (deblocking_filter_override_flag) {
751 sh->disable_deblocking_filter_flag = get_bits1(gb);
752 if (!sh->disable_deblocking_filter_flag) {
753 sh->beta_offset = get_se_golomb(gb) * 2;
754 sh->tc_offset = get_se_golomb(gb) * 2;
757 sh->disable_deblocking_filter_flag = s->ps.pps->disable_dbf;
758 sh->beta_offset = s->ps.pps->beta_offset;
759 sh->tc_offset = s->ps.pps->tc_offset;
762 sh->disable_deblocking_filter_flag = 0;
767 if (s->ps.pps->seq_loop_filter_across_slices_enabled_flag &&
768 (sh->slice_sample_adaptive_offset_flag[0] ||
769 sh->slice_sample_adaptive_offset_flag[1] ||
770 !sh->disable_deblocking_filter_flag)) {
771 sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
773 sh->slice_loop_filter_across_slices_enabled_flag = s->ps.pps->seq_loop_filter_across_slices_enabled_flag;
775 } else if (!s->slice_initialized) {
776 av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
777 return AVERROR_INVALIDDATA;
780 sh->num_entry_point_offsets = 0;
781 if (s->ps.pps->tiles_enabled_flag || s->ps.pps->entropy_coding_sync_enabled_flag) {
782 sh->num_entry_point_offsets = get_ue_golomb_long(gb);
783 if (sh->num_entry_point_offsets > 0) {
784 int offset_len = get_ue_golomb_long(gb) + 1;
786 for (i = 0; i < sh->num_entry_point_offsets; i++)
787 skip_bits(gb, offset_len);
791 if (s->ps.pps->slice_header_extension_present_flag) {
792 unsigned int length = get_ue_golomb_long(gb);
793 for (i = 0; i < length; i++)
794 skip_bits(gb, 8); // slice_header_extension_data_byte
797 // Inferred parameters
798 sh->slice_qp = 26 + s->ps.pps->pic_init_qp_minus26 + sh->slice_qp_delta;
799 if (sh->slice_qp > 51 ||
800 sh->slice_qp < -s->ps.sps->qp_bd_offset) {
801 av_log(s->avctx, AV_LOG_ERROR,
802 "The slice_qp %d is outside the valid range "
805 -s->ps.sps->qp_bd_offset);
806 return AVERROR_INVALIDDATA;
809 sh->slice_ctb_addr_rs = sh->slice_segment_addr;
811 if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) {
812 av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
813 return AVERROR_INVALIDDATA;
816 s->HEVClc.first_qp_group = !s->sh.dependent_slice_segment_flag;
818 if (!s->ps.pps->cu_qp_delta_enabled_flag)
819 s->HEVClc.qp_y = FFUMOD(s->sh.slice_qp + 52 + 2 * s->ps.sps->qp_bd_offset,
820 52 + s->ps.sps->qp_bd_offset) - s->ps.sps->qp_bd_offset;
822 s->slice_initialized = 1;
827 #define CTB(tab, x, y) ((tab)[(y) * s->ps.sps->ctb_width + (x)])
829 #define SET_SAO(elem, value) \
831 if (!sao_merge_up_flag && !sao_merge_left_flag) \
833 else if (sao_merge_left_flag) \
834 sao->elem = CTB(s->sao, rx-1, ry).elem; \
835 else if (sao_merge_up_flag) \
836 sao->elem = CTB(s->sao, rx, ry-1).elem; \
841 static void hls_sao_param(HEVCContext *s, int rx, int ry)
843 HEVCLocalContext *lc = &s->HEVClc;
844 int sao_merge_left_flag = 0;
845 int sao_merge_up_flag = 0;
846 int shift = s->ps.sps->bit_depth - FFMIN(s->ps.sps->bit_depth, 10);
847 SAOParams *sao = &CTB(s->sao, rx, ry);
850 if (s->sh.slice_sample_adaptive_offset_flag[0] ||
851 s->sh.slice_sample_adaptive_offset_flag[1]) {
853 if (lc->ctb_left_flag)
854 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
856 if (ry > 0 && !sao_merge_left_flag) {
858 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
862 for (c_idx = 0; c_idx < 3; c_idx++) {
863 if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
864 sao->type_idx[c_idx] = SAO_NOT_APPLIED;
869 sao->type_idx[2] = sao->type_idx[1];
870 sao->eo_class[2] = sao->eo_class[1];
872 SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
875 if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
878 for (i = 0; i < 4; i++)
879 SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
881 if (sao->type_idx[c_idx] == SAO_BAND) {
882 for (i = 0; i < 4; i++) {
883 if (sao->offset_abs[c_idx][i]) {
884 SET_SAO(offset_sign[c_idx][i],
885 ff_hevc_sao_offset_sign_decode(s));
887 sao->offset_sign[c_idx][i] = 0;
890 SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
891 } else if (c_idx != 2) {
892 SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
895 // Inferred parameters
896 sao->offset_val[c_idx][0] = 0;
897 for (i = 0; i < 4; i++) {
898 sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i] << shift;
899 if (sao->type_idx[c_idx] == SAO_EDGE) {
901 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
902 } else if (sao->offset_sign[c_idx][i]) {
903 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
912 static void hls_residual_coding(HEVCContext *s, int x0, int y0,
913 int log2_trafo_size, enum ScanType scan_idx,
916 #define GET_COORD(offset, n) \
918 x_c = (scan_x_cg[offset >> 4] << 2) + scan_x_off[n]; \
919 y_c = (scan_y_cg[offset >> 4] << 2) + scan_y_off[n]; \
921 HEVCLocalContext *lc = &s->HEVClc;
922 int transform_skip_flag = 0;
924 int last_significant_coeff_x, last_significant_coeff_y;
928 int greater1_ctx = 1;
931 int x_cg_last_sig, y_cg_last_sig;
933 const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
935 ptrdiff_t stride = s->frame->linesize[c_idx];
936 int hshift = s->ps.sps->hshift[c_idx];
937 int vshift = s->ps.sps->vshift[c_idx];
938 uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
939 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
940 DECLARE_ALIGNED(16, int16_t, coeffs[MAX_TB_SIZE * MAX_TB_SIZE]) = { 0 };
941 DECLARE_ALIGNED(8, uint8_t, significant_coeff_group_flag[8][8]) = { { 0 } };
943 int trafo_size = 1 << log2_trafo_size;
944 int i, qp, shift, add, scale, scale_m;
945 const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
946 const uint8_t *scale_matrix;
949 // Derive QP for dequant
950 if (!lc->cu.cu_transquant_bypass_flag) {
951 static const int qp_c[] = {
952 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37
955 static const uint8_t rem6[51 + 2 * 6 + 1] = {
956 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
957 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
958 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
961 static const uint8_t div6[51 + 2 * 6 + 1] = {
962 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
963 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
964 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
969 qp = qp_y + s->ps.sps->qp_bd_offset;
974 offset = s->ps.pps->cb_qp_offset + s->sh.slice_cb_qp_offset;
976 offset = s->ps.pps->cr_qp_offset + s->sh.slice_cr_qp_offset;
978 qp_i = av_clip(qp_y + offset, -s->ps.sps->qp_bd_offset, 57);
984 qp = qp_c[qp_i - 30];
986 qp += s->ps.sps->qp_bd_offset;
989 shift = s->ps.sps->bit_depth + log2_trafo_size - 5;
990 add = 1 << (shift - 1);
991 scale = level_scale[rem6[qp]] << (div6[qp]);
992 scale_m = 16; // default when no custom scaling lists.
995 if (s->ps.sps->scaling_list_enable_flag) {
996 const ScalingList *sl = s->ps.pps->scaling_list_data_present_flag ?
997 &s->ps.pps->scaling_list : &s->ps.sps->scaling_list;
998 int matrix_id = lc->cu.pred_mode != MODE_INTRA;
1000 if (log2_trafo_size != 5)
1001 matrix_id = 3 * matrix_id + c_idx;
1003 scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
1004 if (log2_trafo_size >= 4)
1005 dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
1009 if (s->ps.pps->transform_skip_enabled_flag &&
1010 !lc->cu.cu_transquant_bypass_flag &&
1011 log2_trafo_size == 2) {
1012 transform_skip_flag = ff_hevc_transform_skip_flag_decode(s, c_idx);
1015 last_significant_coeff_x =
1016 ff_hevc_last_significant_coeff_x_prefix_decode(s, c_idx, log2_trafo_size);
1017 last_significant_coeff_y =
1018 ff_hevc_last_significant_coeff_y_prefix_decode(s, c_idx, log2_trafo_size);
1020 if (last_significant_coeff_x > 3) {
1021 int suffix = ff_hevc_last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
1022 last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
1023 (2 + (last_significant_coeff_x & 1)) +
1027 if (last_significant_coeff_y > 3) {
1028 int suffix = ff_hevc_last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
1029 last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
1030 (2 + (last_significant_coeff_y & 1)) +
1034 if (scan_idx == SCAN_VERT)
1035 FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
1037 x_cg_last_sig = last_significant_coeff_x >> 2;
1038 y_cg_last_sig = last_significant_coeff_y >> 2;
1042 int last_x_c = last_significant_coeff_x & 3;
1043 int last_y_c = last_significant_coeff_y & 3;
1045 scan_x_off = ff_hevc_diag_scan4x4_x;
1046 scan_y_off = ff_hevc_diag_scan4x4_y;
1047 num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
1048 if (trafo_size == 4) {
1049 scan_x_cg = scan_1x1;
1050 scan_y_cg = scan_1x1;
1051 } else if (trafo_size == 8) {
1052 num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1053 scan_x_cg = diag_scan2x2_x;
1054 scan_y_cg = diag_scan2x2_y;
1055 } else if (trafo_size == 16) {
1056 num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1057 scan_x_cg = ff_hevc_diag_scan4x4_x;
1058 scan_y_cg = ff_hevc_diag_scan4x4_y;
1059 } else { // trafo_size == 32
1060 num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1061 scan_x_cg = ff_hevc_diag_scan8x8_x;
1062 scan_y_cg = ff_hevc_diag_scan8x8_y;
1067 scan_x_cg = horiz_scan2x2_x;
1068 scan_y_cg = horiz_scan2x2_y;
1069 scan_x_off = horiz_scan4x4_x;
1070 scan_y_off = horiz_scan4x4_y;
1071 num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1073 default: //SCAN_VERT
1074 scan_x_cg = horiz_scan2x2_y;
1075 scan_y_cg = horiz_scan2x2_x;
1076 scan_x_off = horiz_scan4x4_y;
1077 scan_y_off = horiz_scan4x4_x;
1078 num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1082 num_last_subset = (num_coeff - 1) >> 4;
1084 for (i = num_last_subset; i >= 0; i--) {
1086 int x_cg, y_cg, x_c, y_c;
1087 int implicit_non_zero_coeff = 0;
1088 int64_t trans_coeff_level;
1090 int offset = i << 4;
1092 uint8_t significant_coeff_flag_idx[16];
1093 uint8_t nb_significant_coeff_flag = 0;
1095 x_cg = scan_x_cg[i];
1096 y_cg = scan_y_cg[i];
1098 if (i < num_last_subset && i > 0) {
1100 if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1101 ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1102 if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1103 ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1105 significant_coeff_group_flag[x_cg][y_cg] =
1106 ff_hevc_significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
1107 implicit_non_zero_coeff = 1;
1109 significant_coeff_group_flag[x_cg][y_cg] =
1110 ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1111 (x_cg == 0 && y_cg == 0));
1114 last_scan_pos = num_coeff - offset - 1;
1116 if (i == num_last_subset) {
1117 n_end = last_scan_pos - 1;
1118 significant_coeff_flag_idx[0] = last_scan_pos;
1119 nb_significant_coeff_flag = 1;
1124 if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1125 prev_sig = significant_coeff_group_flag[x_cg + 1][y_cg];
1126 if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1127 prev_sig += significant_coeff_group_flag[x_cg][y_cg + 1] << 1;
1129 for (n = n_end; n >= 0; n--) {
1130 GET_COORD(offset, n);
1132 if (significant_coeff_group_flag[x_cg][y_cg] &&
1133 (n > 0 || implicit_non_zero_coeff == 0)) {
1134 if (ff_hevc_significant_coeff_flag_decode(s, c_idx, x_c, y_c,
1138 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1139 nb_significant_coeff_flag++;
1140 implicit_non_zero_coeff = 0;
1143 int last_cg = (x_c == (x_cg << 2) && y_c == (y_cg << 2));
1144 if (last_cg && implicit_non_zero_coeff && significant_coeff_group_flag[x_cg][y_cg]) {
1145 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1146 nb_significant_coeff_flag++;
1151 n_end = nb_significant_coeff_flag;
1154 int first_nz_pos_in_cg = 16;
1155 int last_nz_pos_in_cg = -1;
1156 int c_rice_param = 0;
1157 int first_greater1_coeff_idx = -1;
1158 uint8_t coeff_abs_level_greater1_flag[16] = { 0 };
1159 uint16_t coeff_sign_flag;
1161 int sign_hidden = 0;
1163 // initialize first elem of coeff_bas_level_greater1_flag
1164 int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1166 if (!(i == num_last_subset) && greater1_ctx == 0)
1169 last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1171 for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1172 int n_idx = significant_coeff_flag_idx[m];
1173 int inc = (ctx_set << 2) + greater1_ctx;
1174 coeff_abs_level_greater1_flag[n_idx] =
1175 ff_hevc_coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
1176 if (coeff_abs_level_greater1_flag[n_idx]) {
1178 } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1182 if (coeff_abs_level_greater1_flag[n_idx] &&
1183 first_greater1_coeff_idx == -1)
1184 first_greater1_coeff_idx = n_idx;
1186 first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1187 sign_hidden = last_nz_pos_in_cg - first_nz_pos_in_cg >= 4 &&
1188 !lc->cu.cu_transquant_bypass_flag;
1190 if (first_greater1_coeff_idx != -1) {
1191 coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += ff_hevc_coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1193 if (!s->ps.pps->sign_data_hiding_flag || !sign_hidden) {
1194 coeff_sign_flag = ff_hevc_coeff_sign_flag(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1196 coeff_sign_flag = ff_hevc_coeff_sign_flag(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1199 for (m = 0; m < n_end; m++) {
1200 n = significant_coeff_flag_idx[m];
1201 GET_COORD(offset, n);
1202 trans_coeff_level = 1 + coeff_abs_level_greater1_flag[n];
1203 if (trans_coeff_level == ((m < 8) ?
1204 ((n == first_greater1_coeff_idx) ? 3 : 2) : 1)) {
1205 int last_coeff_abs_level_remaining = ff_hevc_coeff_abs_level_remaining(s, trans_coeff_level, c_rice_param);
1207 trans_coeff_level += last_coeff_abs_level_remaining;
1208 if ((trans_coeff_level) > (3 * (1 << c_rice_param)))
1209 c_rice_param = FFMIN(c_rice_param + 1, 4);
1211 if (s->ps.pps->sign_data_hiding_flag && sign_hidden) {
1212 sum_abs += trans_coeff_level;
1213 if (n == first_nz_pos_in_cg && ((sum_abs & 1) == 1))
1214 trans_coeff_level = -trans_coeff_level;
1216 if (coeff_sign_flag >> 15)
1217 trans_coeff_level = -trans_coeff_level;
1218 coeff_sign_flag <<= 1;
1219 if (!lc->cu.cu_transquant_bypass_flag) {
1220 if (s->ps.sps->scaling_list_enable_flag) {
1221 if (y_c || x_c || log2_trafo_size < 4) {
1223 switch (log2_trafo_size) {
1224 case 3: pos = (y_c << 3) + x_c; break;
1225 case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1226 case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1227 default: pos = (y_c << 2) + x_c;
1229 scale_m = scale_matrix[pos];
1234 trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1235 if(trans_coeff_level < 0) {
1236 if((~trans_coeff_level) & 0xFffffffffff8000)
1237 trans_coeff_level = -32768;
1239 if (trans_coeff_level & 0xffffffffffff8000)
1240 trans_coeff_level = 32767;
1243 coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1248 if (lc->cu.cu_transquant_bypass_flag) {
1249 s->hevcdsp.transquant_bypass[log2_trafo_size - 2](dst, coeffs, stride);
1251 if (transform_skip_flag)
1252 s->hevcdsp.transform_skip(dst, coeffs, stride);
1253 else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 &&
1254 log2_trafo_size == 2)
1255 s->hevcdsp.transform_4x4_luma_add(dst, coeffs, stride);
1257 s->hevcdsp.transform_add[log2_trafo_size - 2](dst, coeffs, stride);
1261 static int hls_transform_unit(HEVCContext *s, int x0, int y0,
1262 int xBase, int yBase, int cb_xBase, int cb_yBase,
1263 int log2_cb_size, int log2_trafo_size,
1264 int blk_idx, int cbf_luma, int cbf_cb, int cbf_cr)
1266 HEVCLocalContext *lc = &s->HEVClc;
1268 if (lc->cu.pred_mode == MODE_INTRA) {
1269 int trafo_size = 1 << log2_trafo_size;
1270 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1272 s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
1273 if (log2_trafo_size > 2) {
1274 trafo_size = trafo_size << (s->ps.sps->hshift[1] - 1);
1275 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1276 s->hpc.intra_pred[log2_trafo_size - 3](s, x0, y0, 1);
1277 s->hpc.intra_pred[log2_trafo_size - 3](s, x0, y0, 2);
1278 } else if (blk_idx == 3) {
1279 trafo_size = trafo_size << s->ps.sps->hshift[1];
1280 ff_hevc_set_neighbour_available(s, xBase, yBase,
1281 trafo_size, trafo_size);
1282 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1283 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1287 if (cbf_luma || cbf_cb || cbf_cr) {
1288 int scan_idx = SCAN_DIAG;
1289 int scan_idx_c = SCAN_DIAG;
1291 if (s->ps.pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
1292 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
1293 if (lc->tu.cu_qp_delta != 0)
1294 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
1295 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
1296 lc->tu.is_cu_qp_delta_coded = 1;
1298 if (lc->tu.cu_qp_delta < -(26 + s->ps.sps->qp_bd_offset / 2) ||
1299 lc->tu.cu_qp_delta > (25 + s->ps.sps->qp_bd_offset / 2)) {
1300 av_log(s->avctx, AV_LOG_ERROR,
1301 "The cu_qp_delta %d is outside the valid range "
1304 -(26 + s->ps.sps->qp_bd_offset / 2),
1305 (25 + s->ps.sps->qp_bd_offset / 2));
1306 return AVERROR_INVALIDDATA;
1309 ff_hevc_set_qPy(s, x0, y0, cb_xBase, cb_yBase, log2_cb_size);
1312 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
1313 if (lc->tu.cur_intra_pred_mode >= 6 &&
1314 lc->tu.cur_intra_pred_mode <= 14) {
1315 scan_idx = SCAN_VERT;
1316 } else if (lc->tu.cur_intra_pred_mode >= 22 &&
1317 lc->tu.cur_intra_pred_mode <= 30) {
1318 scan_idx = SCAN_HORIZ;
1321 if (lc->pu.intra_pred_mode_c >= 6 &&
1322 lc->pu.intra_pred_mode_c <= 14) {
1323 scan_idx_c = SCAN_VERT;
1324 } else if (lc->pu.intra_pred_mode_c >= 22 &&
1325 lc->pu.intra_pred_mode_c <= 30) {
1326 scan_idx_c = SCAN_HORIZ;
1331 hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
1332 if (log2_trafo_size > 2) {
1334 hls_residual_coding(s, x0, y0, log2_trafo_size - 1, scan_idx_c, 1);
1336 hls_residual_coding(s, x0, y0, log2_trafo_size - 1, scan_idx_c, 2);
1337 } else if (blk_idx == 3) {
1339 hls_residual_coding(s, xBase, yBase, log2_trafo_size, scan_idx_c, 1);
1341 hls_residual_coding(s, xBase, yBase, log2_trafo_size, scan_idx_c, 2);
1347 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1349 int cb_size = 1 << log2_cb_size;
1350 int log2_min_pu_size = s->ps.sps->log2_min_pu_size;
1352 int min_pu_width = s->ps.sps->min_pu_width;
1353 int x_end = FFMIN(x0 + cb_size, s->ps.sps->width);
1354 int y_end = FFMIN(y0 + cb_size, s->ps.sps->height);
1357 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1358 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1359 s->is_pcm[i + j * min_pu_width] = 2;
1362 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1363 int xBase, int yBase, int cb_xBase, int cb_yBase,
1364 int log2_cb_size, int log2_trafo_size,
1365 int trafo_depth, int blk_idx,
1366 int cbf_cb, int cbf_cr)
1368 HEVCLocalContext *lc = &s->HEVClc;
1369 uint8_t split_transform_flag;
1372 if (lc->cu.intra_split_flag) {
1373 if (trafo_depth == 1)
1374 lc->tu.cur_intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1376 lc->tu.cur_intra_pred_mode = lc->pu.intra_pred_mode[0];
1379 if (log2_trafo_size <= s->ps.sps->log2_max_trafo_size &&
1380 log2_trafo_size > s->ps.sps->log2_min_tb_size &&
1381 trafo_depth < lc->cu.max_trafo_depth &&
1382 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1383 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1385 int inter_split = s->ps.sps->max_transform_hierarchy_depth_inter == 0 &&
1386 lc->cu.pred_mode == MODE_INTER &&
1387 lc->cu.part_mode != PART_2Nx2N &&
1390 split_transform_flag = log2_trafo_size > s->ps.sps->log2_max_trafo_size ||
1391 (lc->cu.intra_split_flag && trafo_depth == 0) ||
1395 if (log2_trafo_size > 2 && (trafo_depth == 0 || cbf_cb))
1396 cbf_cb = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1397 else if (log2_trafo_size > 2 || trafo_depth == 0)
1399 if (log2_trafo_size > 2 && (trafo_depth == 0 || cbf_cr))
1400 cbf_cr = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1401 else if (log2_trafo_size > 2 || trafo_depth == 0)
1404 if (split_transform_flag) {
1405 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1406 const int x1 = x0 + trafo_size_split;
1407 const int y1 = y0 + trafo_size_split;
1409 #define SUBDIVIDE(x, y, idx) \
1411 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1412 log2_trafo_size - 1, trafo_depth + 1, idx, \
1418 SUBDIVIDE(x0, y0, 0);
1419 SUBDIVIDE(x1, y0, 1);
1420 SUBDIVIDE(x0, y1, 2);
1421 SUBDIVIDE(x1, y1, 3);
1425 int min_tu_size = 1 << s->ps.sps->log2_min_tb_size;
1426 int log2_min_tu_size = s->ps.sps->log2_min_tb_size;
1427 int min_tu_width = s->ps.sps->min_tb_width;
1430 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1432 cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1434 ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1435 log2_cb_size, log2_trafo_size,
1436 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1439 // TODO: store cbf_luma somewhere else
1442 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1443 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1444 int x_tu = (x0 + j) >> log2_min_tu_size;
1445 int y_tu = (y0 + i) >> log2_min_tu_size;
1446 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1449 if (!s->sh.disable_deblocking_filter_flag) {
1450 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1451 if (s->ps.pps->transquant_bypass_enable_flag &&
1452 lc->cu.cu_transquant_bypass_flag)
1453 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1459 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1461 //TODO: non-4:2:0 support
1462 HEVCLocalContext *lc = &s->HEVClc;
1464 int cb_size = 1 << log2_cb_size;
1465 int stride0 = s->frame->linesize[0];
1466 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->ps.sps->pixel_shift)];
1467 int stride1 = s->frame->linesize[1];
1468 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)];
1469 int stride2 = s->frame->linesize[2];
1470 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)];
1472 int length = cb_size * cb_size * s->ps.sps->pcm.bit_depth + ((cb_size * cb_size) >> 1) * s->ps.sps->pcm.bit_depth_chroma;
1473 const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1476 if (!s->sh.disable_deblocking_filter_flag)
1477 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1479 ret = init_get_bits(&gb, pcm, length);
1483 s->hevcdsp.put_pcm(dst0, stride0, cb_size, &gb, s->ps.sps->pcm.bit_depth);
1484 s->hevcdsp.put_pcm(dst1, stride1, cb_size / 2, &gb, s->ps.sps->pcm.bit_depth_chroma);
1485 s->hevcdsp.put_pcm(dst2, stride2, cb_size / 2, &gb, s->ps.sps->pcm.bit_depth_chroma);
1489 static void hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1491 HEVCLocalContext *lc = &s->HEVClc;
1492 int x = ff_hevc_abs_mvd_greater0_flag_decode(s);
1493 int y = ff_hevc_abs_mvd_greater0_flag_decode(s);
1496 x += ff_hevc_abs_mvd_greater1_flag_decode(s);
1498 y += ff_hevc_abs_mvd_greater1_flag_decode(s);
1501 case 2: lc->pu.mvd.x = ff_hevc_mvd_decode(s); break;
1502 case 1: lc->pu.mvd.x = ff_hevc_mvd_sign_flag_decode(s); break;
1503 case 0: lc->pu.mvd.x = 0; break;
1507 case 2: lc->pu.mvd.y = ff_hevc_mvd_decode(s); break;
1508 case 1: lc->pu.mvd.y = ff_hevc_mvd_sign_flag_decode(s); break;
1509 case 0: lc->pu.mvd.y = 0; break;
1514 * 8.5.3.2.2.1 Luma sample interpolation process
1516 * @param s HEVC decoding context
1517 * @param dst target buffer for block data at block position
1518 * @param dststride stride of the dst buffer
1519 * @param ref reference picture buffer at origin (0, 0)
1520 * @param mv motion vector (relative to block position) to get pixel data from
1521 * @param x_off horizontal position of block from origin (0, 0)
1522 * @param y_off vertical position of block from origin (0, 0)
1523 * @param block_w width of block
1524 * @param block_h height of block
1526 static void luma_mc(HEVCContext *s, int16_t *dst, ptrdiff_t dststride,
1527 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1528 int block_w, int block_h)
1530 HEVCLocalContext *lc = &s->HEVClc;
1531 uint8_t *src = ref->data[0];
1532 ptrdiff_t srcstride = ref->linesize[0];
1533 int pic_width = s->ps.sps->width;
1534 int pic_height = s->ps.sps->height;
1538 int extra_left = ff_hevc_qpel_extra_before[mx];
1539 int extra_top = ff_hevc_qpel_extra_before[my];
1541 x_off += mv->x >> 2;
1542 y_off += mv->y >> 2;
1543 src += y_off * srcstride + (x_off << s->ps.sps->pixel_shift);
1545 if (x_off < extra_left || y_off < extra_top ||
1546 x_off >= pic_width - block_w - ff_hevc_qpel_extra_after[mx] ||
1547 y_off >= pic_height - block_h - ff_hevc_qpel_extra_after[my]) {
1548 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1549 int offset = extra_top * srcstride + (extra_left << s->ps.sps->pixel_shift);
1550 int buf_offset = extra_top *
1551 edge_emu_stride + (extra_left << s->ps.sps->pixel_shift);
1553 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1554 edge_emu_stride, srcstride,
1555 block_w + ff_hevc_qpel_extra[mx],
1556 block_h + ff_hevc_qpel_extra[my],
1557 x_off - extra_left, y_off - extra_top,
1558 pic_width, pic_height);
1559 src = lc->edge_emu_buffer + buf_offset;
1560 srcstride = edge_emu_stride;
1562 s->hevcdsp.put_hevc_qpel[my][mx](dst, dststride, src, srcstride, block_w,
1563 block_h, lc->mc_buffer);
1567 * 8.5.3.2.2.2 Chroma sample interpolation process
1569 * @param s HEVC decoding context
1570 * @param dst1 target buffer for block data at block position (U plane)
1571 * @param dst2 target buffer for block data at block position (V plane)
1572 * @param dststride stride of the dst1 and dst2 buffers
1573 * @param ref reference picture buffer at origin (0, 0)
1574 * @param mv motion vector (relative to block position) to get pixel data from
1575 * @param x_off horizontal position of block from origin (0, 0)
1576 * @param y_off vertical position of block from origin (0, 0)
1577 * @param block_w width of block
1578 * @param block_h height of block
1580 static void chroma_mc(HEVCContext *s, int16_t *dst1, int16_t *dst2,
1581 ptrdiff_t dststride, AVFrame *ref, const Mv *mv,
1582 int x_off, int y_off, int block_w, int block_h)
1584 HEVCLocalContext *lc = &s->HEVClc;
1585 uint8_t *src1 = ref->data[1];
1586 uint8_t *src2 = ref->data[2];
1587 ptrdiff_t src1stride = ref->linesize[1];
1588 ptrdiff_t src2stride = ref->linesize[2];
1589 int pic_width = s->ps.sps->width >> 1;
1590 int pic_height = s->ps.sps->height >> 1;
1595 x_off += mv->x >> 3;
1596 y_off += mv->y >> 3;
1597 src1 += y_off * src1stride + (x_off << s->ps.sps->pixel_shift);
1598 src2 += y_off * src2stride + (x_off << s->ps.sps->pixel_shift);
1600 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1601 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1602 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1603 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1604 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->ps.sps->pixel_shift));
1605 int buf_offset1 = EPEL_EXTRA_BEFORE *
1606 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1607 int offset2 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->ps.sps->pixel_shift));
1608 int buf_offset2 = EPEL_EXTRA_BEFORE *
1609 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1611 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1612 edge_emu_stride, src1stride,
1613 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1614 x_off - EPEL_EXTRA_BEFORE,
1615 y_off - EPEL_EXTRA_BEFORE,
1616 pic_width, pic_height);
1618 src1 = lc->edge_emu_buffer + buf_offset1;
1619 src1stride = edge_emu_stride;
1620 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst1, dststride, src1, src1stride,
1621 block_w, block_h, mx, my, lc->mc_buffer);
1623 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src2 - offset2,
1624 edge_emu_stride, src2stride,
1625 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1626 x_off - EPEL_EXTRA_BEFORE,
1627 y_off - EPEL_EXTRA_BEFORE,
1628 pic_width, pic_height);
1629 src2 = lc->edge_emu_buffer + buf_offset2;
1630 src2stride = edge_emu_stride;
1632 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst2, dststride, src2, src2stride,
1633 block_w, block_h, mx, my,
1636 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst1, dststride, src1, src1stride,
1637 block_w, block_h, mx, my,
1639 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst2, dststride, src2, src2stride,
1640 block_w, block_h, mx, my,
1645 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1646 const Mv *mv, int y0, int height)
1648 int y = (mv->y >> 2) + y0 + height + 9;
1649 ff_thread_await_progress(&ref->tf, y, 0);
1652 static void hevc_luma_mv_mpv_mode(HEVCContext *s, int x0, int y0, int nPbW,
1653 int nPbH, int log2_cb_size, int part_idx,
1654 int merge_idx, MvField *mv)
1656 HEVCLocalContext *lc = &s->HEVClc;
1657 enum InterPredIdc inter_pred_idc = PRED_L0;
1660 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1661 if (s->sh.slice_type == B_SLICE)
1662 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1664 if (inter_pred_idc != PRED_L1) {
1665 if (s->sh.nb_refs[L0])
1666 mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1668 mv->pred_flag[0] = 1;
1669 hls_mvd_coding(s, x0, y0, 0);
1670 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1671 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1672 part_idx, merge_idx, mv, mvp_flag, 0);
1673 mv->mv[0].x += lc->pu.mvd.x;
1674 mv->mv[0].y += lc->pu.mvd.y;
1677 if (inter_pred_idc != PRED_L0) {
1678 if (s->sh.nb_refs[L1])
1679 mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1681 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1682 AV_ZERO32(&lc->pu.mvd);
1684 hls_mvd_coding(s, x0, y0, 1);
1687 mv->pred_flag[1] = 1;
1688 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1689 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1690 part_idx, merge_idx, mv, mvp_flag, 1);
1691 mv->mv[1].x += lc->pu.mvd.x;
1692 mv->mv[1].y += lc->pu.mvd.y;
1696 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1698 int log2_cb_size, int partIdx)
1700 #define POS(c_idx, x, y) \
1701 &s->frame->data[c_idx][((y) >> s->ps.sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1702 (((x) >> s->ps.sps->hshift[c_idx]) << s->ps.sps->pixel_shift)]
1703 HEVCLocalContext *lc = &s->HEVClc;
1705 struct MvField current_mv = {{{ 0 }}};
1707 int min_pu_width = s->ps.sps->min_pu_width;
1709 MvField *tab_mvf = s->ref->tab_mvf;
1710 RefPicList *refPicList = s->ref->refPicList;
1711 HEVCFrame *ref0, *ref1;
1713 int tmpstride = MAX_PB_SIZE;
1715 uint8_t *dst0 = POS(0, x0, y0);
1716 uint8_t *dst1 = POS(1, x0, y0);
1717 uint8_t *dst2 = POS(2, x0, y0);
1718 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
1719 int min_cb_width = s->ps.sps->min_cb_width;
1720 int x_cb = x0 >> log2_min_cb_size;
1721 int y_cb = y0 >> log2_min_cb_size;
1725 int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1728 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1730 if (skip_flag || lc->pu.merge_flag) {
1731 if (s->sh.max_num_merge_cand > 1)
1732 merge_idx = ff_hevc_merge_idx_decode(s);
1736 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1737 partIdx, merge_idx, ¤t_mv);
1739 hevc_luma_mv_mpv_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1740 partIdx, merge_idx, ¤t_mv);
1743 x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1744 y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1746 for (j = 0; j < nPbH >> s->ps.sps->log2_min_pu_size; j++)
1747 for (i = 0; i < nPbW >> s->ps.sps->log2_min_pu_size; i++)
1748 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1750 if (current_mv.pred_flag[0]) {
1751 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1754 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1756 if (current_mv.pred_flag[1]) {
1757 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1760 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1763 if (current_mv.pred_flag[0] && !current_mv.pred_flag[1]) {
1764 DECLARE_ALIGNED(16, int16_t, tmp[MAX_PB_SIZE * MAX_PB_SIZE]);
1765 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1767 luma_mc(s, tmp, tmpstride, ref0->frame,
1768 ¤t_mv.mv[0], x0, y0, nPbW, nPbH);
1770 if ((s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1771 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag)) {
1772 s->hevcdsp.weighted_pred(s->sh.luma_log2_weight_denom,
1773 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1774 s->sh.luma_offset_l0[current_mv.ref_idx[0]],
1775 dst0, s->frame->linesize[0], tmp,
1776 tmpstride, nPbW, nPbH);
1778 s->hevcdsp.put_unweighted_pred(dst0, s->frame->linesize[0], tmp, tmpstride, nPbW, nPbH);
1780 chroma_mc(s, tmp, tmp2, tmpstride, ref0->frame,
1781 ¤t_mv.mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1783 if ((s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1784 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag)) {
1785 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1786 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0],
1787 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0],
1788 dst1, s->frame->linesize[1], tmp, tmpstride,
1789 nPbW / 2, nPbH / 2);
1790 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1791 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1],
1792 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1],
1793 dst2, s->frame->linesize[2], tmp2, tmpstride,
1794 nPbW / 2, nPbH / 2);
1796 s->hevcdsp.put_unweighted_pred(dst1, s->frame->linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1797 s->hevcdsp.put_unweighted_pred(dst2, s->frame->linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1799 } else if (!current_mv.pred_flag[0] && current_mv.pred_flag[1]) {
1800 DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1801 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1803 luma_mc(s, tmp, tmpstride, ref1->frame,
1804 ¤t_mv.mv[1], x0, y0, nPbW, nPbH);
1806 if ((s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1807 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag)) {
1808 s->hevcdsp.weighted_pred(s->sh.luma_log2_weight_denom,
1809 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1810 s->sh.luma_offset_l1[current_mv.ref_idx[1]],
1811 dst0, s->frame->linesize[0], tmp, tmpstride,
1814 s->hevcdsp.put_unweighted_pred(dst0, s->frame->linesize[0], tmp, tmpstride, nPbW, nPbH);
1817 chroma_mc(s, tmp, tmp2, tmpstride, ref1->frame,
1818 ¤t_mv.mv[1], x0/2, y0/2, nPbW/2, nPbH/2);
1820 if ((s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1821 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag)) {
1822 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1823 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0],
1824 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0],
1825 dst1, s->frame->linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1826 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1827 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1],
1828 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1],
1829 dst2, s->frame->linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1831 s->hevcdsp.put_unweighted_pred(dst1, s->frame->linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1832 s->hevcdsp.put_unweighted_pred(dst2, s->frame->linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1834 } else if (current_mv.pred_flag[0] && current_mv.pred_flag[1]) {
1835 DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1836 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1837 DECLARE_ALIGNED(16, int16_t, tmp3[MAX_PB_SIZE * MAX_PB_SIZE]);
1838 DECLARE_ALIGNED(16, int16_t, tmp4[MAX_PB_SIZE * MAX_PB_SIZE]);
1840 luma_mc(s, tmp, tmpstride, ref0->frame,
1841 ¤t_mv.mv[0], x0, y0, nPbW, nPbH);
1842 luma_mc(s, tmp2, tmpstride, ref1->frame,
1843 ¤t_mv.mv[1], x0, y0, nPbW, nPbH);
1845 if ((s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1846 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag)) {
1847 s->hevcdsp.weighted_pred_avg(s->sh.luma_log2_weight_denom,
1848 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1849 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1850 s->sh.luma_offset_l0[current_mv.ref_idx[0]],
1851 s->sh.luma_offset_l1[current_mv.ref_idx[1]],
1852 dst0, s->frame->linesize[0],
1853 tmp, tmp2, tmpstride, nPbW, nPbH);
1855 s->hevcdsp.put_weighted_pred_avg(dst0, s->frame->linesize[0],
1856 tmp, tmp2, tmpstride, nPbW, nPbH);
1859 chroma_mc(s, tmp, tmp2, tmpstride, ref0->frame,
1860 ¤t_mv.mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1861 chroma_mc(s, tmp3, tmp4, tmpstride, ref1->frame,
1862 ¤t_mv.mv[1], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1864 if ((s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1865 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag)) {
1866 s->hevcdsp.weighted_pred_avg(s->sh.chroma_log2_weight_denom,
1867 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0],
1868 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0],
1869 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0],
1870 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0],
1871 dst1, s->frame->linesize[1], tmp, tmp3,
1872 tmpstride, nPbW / 2, nPbH / 2);
1873 s->hevcdsp.weighted_pred_avg(s->sh.chroma_log2_weight_denom,
1874 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1],
1875 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1],
1876 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1],
1877 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1],
1878 dst2, s->frame->linesize[2], tmp2, tmp4,
1879 tmpstride, nPbW / 2, nPbH / 2);
1881 s->hevcdsp.put_weighted_pred_avg(dst1, s->frame->linesize[1], tmp, tmp3, tmpstride, nPbW/2, nPbH/2);
1882 s->hevcdsp.put_weighted_pred_avg(dst2, s->frame->linesize[2], tmp2, tmp4, tmpstride, nPbW/2, nPbH/2);
1890 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1891 int prev_intra_luma_pred_flag)
1893 HEVCLocalContext *lc = &s->HEVClc;
1894 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1895 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1896 int min_pu_width = s->ps.sps->min_pu_width;
1897 int size_in_pus = pu_size >> s->ps.sps->log2_min_pu_size;
1898 int x0b = x0 & ((1 << s->ps.sps->log2_ctb_size) - 1);
1899 int y0b = y0 & ((1 << s->ps.sps->log2_ctb_size) - 1);
1901 int cand_up = (lc->ctb_up_flag || y0b) ?
1902 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1903 int cand_left = (lc->ctb_left_flag || x0b) ?
1904 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1906 int y_ctb = (y0 >> (s->ps.sps->log2_ctb_size)) << (s->ps.sps->log2_ctb_size);
1908 MvField *tab_mvf = s->ref->tab_mvf;
1909 int intra_pred_mode;
1913 // intra_pred_mode prediction does not cross vertical CTB boundaries
1914 if ((y0 - 1) < y_ctb)
1917 if (cand_left == cand_up) {
1918 if (cand_left < 2) {
1919 candidate[0] = INTRA_PLANAR;
1920 candidate[1] = INTRA_DC;
1921 candidate[2] = INTRA_ANGULAR_26;
1923 candidate[0] = cand_left;
1924 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1925 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1928 candidate[0] = cand_left;
1929 candidate[1] = cand_up;
1930 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1931 candidate[2] = INTRA_PLANAR;
1932 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1933 candidate[2] = INTRA_DC;
1935 candidate[2] = INTRA_ANGULAR_26;
1939 if (prev_intra_luma_pred_flag) {
1940 intra_pred_mode = candidate[lc->pu.mpm_idx];
1942 if (candidate[0] > candidate[1])
1943 FFSWAP(uint8_t, candidate[0], candidate[1]);
1944 if (candidate[0] > candidate[2])
1945 FFSWAP(uint8_t, candidate[0], candidate[2]);
1946 if (candidate[1] > candidate[2])
1947 FFSWAP(uint8_t, candidate[1], candidate[2]);
1949 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1950 for (i = 0; i < 3; i++)
1951 if (intra_pred_mode >= candidate[i])
1955 /* write the intra prediction units into the mv array */
1958 for (i = 0; i < size_in_pus; i++) {
1959 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1960 intra_pred_mode, size_in_pus);
1962 for (j = 0; j < size_in_pus; j++) {
1963 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].is_intra = 1;
1964 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[0] = 0;
1965 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[1] = 0;
1966 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[0] = 0;
1967 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[1] = 0;
1968 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].x = 0;
1969 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].y = 0;
1970 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].x = 0;
1971 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].y = 0;
1975 return intra_pred_mode;
1978 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1979 int log2_cb_size, int ct_depth)
1981 int length = (1 << log2_cb_size) >> s->ps.sps->log2_min_cb_size;
1982 int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
1983 int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
1986 for (y = 0; y < length; y++)
1987 memset(&s->tab_ct_depth[(y_cb + y) * s->ps.sps->min_cb_width + x_cb],
1991 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1994 HEVCLocalContext *lc = &s->HEVClc;
1995 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1996 uint8_t prev_intra_luma_pred_flag[4];
1997 int split = lc->cu.part_mode == PART_NxN;
1998 int pb_size = (1 << log2_cb_size) >> split;
1999 int side = split + 1;
2003 for (i = 0; i < side; i++)
2004 for (j = 0; j < side; j++)
2005 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
2007 for (i = 0; i < side; i++) {
2008 for (j = 0; j < side; j++) {
2009 if (prev_intra_luma_pred_flag[2 * i + j])
2010 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
2012 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
2014 lc->pu.intra_pred_mode[2 * i + j] =
2015 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
2016 prev_intra_luma_pred_flag[2 * i + j]);
2020 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
2021 if (chroma_mode != 4) {
2022 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
2023 lc->pu.intra_pred_mode_c = 34;
2025 lc->pu.intra_pred_mode_c = intra_chroma_table[chroma_mode];
2027 lc->pu.intra_pred_mode_c = lc->pu.intra_pred_mode[0];
2031 static void intra_prediction_unit_default_value(HEVCContext *s,
2035 HEVCLocalContext *lc = &s->HEVClc;
2036 int pb_size = 1 << log2_cb_size;
2037 int size_in_pus = pb_size >> s->ps.sps->log2_min_pu_size;
2038 int min_pu_width = s->ps.sps->min_pu_width;
2039 MvField *tab_mvf = s->ref->tab_mvf;
2040 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
2041 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
2044 if (size_in_pus == 0)
2046 for (j = 0; j < size_in_pus; j++) {
2047 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
2048 for (k = 0; k < size_in_pus; k++)
2049 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].is_intra = lc->cu.pred_mode == MODE_INTRA;
2053 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
2055 int cb_size = 1 << log2_cb_size;
2056 HEVCLocalContext *lc = &s->HEVClc;
2057 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
2058 int length = cb_size >> log2_min_cb_size;
2059 int min_cb_width = s->ps.sps->min_cb_width;
2060 int x_cb = x0 >> log2_min_cb_size;
2061 int y_cb = y0 >> log2_min_cb_size;
2066 lc->cu.pred_mode = MODE_INTRA;
2067 lc->cu.part_mode = PART_2Nx2N;
2068 lc->cu.intra_split_flag = 0;
2070 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
2071 for (x = 0; x < 4; x++)
2072 lc->pu.intra_pred_mode[x] = 1;
2073 if (s->ps.pps->transquant_bypass_enable_flag) {
2074 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
2075 if (lc->cu.cu_transquant_bypass_flag)
2076 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2078 lc->cu.cu_transquant_bypass_flag = 0;
2080 if (s->sh.slice_type != I_SLICE) {
2081 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
2083 x = y_cb * min_cb_width + x_cb;
2084 for (y = 0; y < length; y++) {
2085 memset(&s->skip_flag[x], skip_flag, length);
2088 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2091 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2092 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0);
2093 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2095 if (!s->sh.disable_deblocking_filter_flag)
2096 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2100 if (s->sh.slice_type != I_SLICE)
2101 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2102 if (lc->cu.pred_mode != MODE_INTRA ||
2103 log2_cb_size == s->ps.sps->log2_min_cb_size) {
2104 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2105 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2106 lc->cu.pred_mode == MODE_INTRA;
2109 if (lc->cu.pred_mode == MODE_INTRA) {
2110 if (lc->cu.part_mode == PART_2Nx2N && s->ps.sps->pcm_enabled_flag &&
2111 log2_cb_size >= s->ps.sps->pcm.log2_min_pcm_cb_size &&
2112 log2_cb_size <= s->ps.sps->pcm.log2_max_pcm_cb_size) {
2113 pcm_flag = ff_hevc_pcm_flag_decode(s);
2116 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2117 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2118 if (s->ps.sps->pcm.loop_filter_disable_flag)
2119 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2124 intra_prediction_unit(s, x0, y0, log2_cb_size);
2127 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2128 switch (lc->cu.part_mode) {
2130 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0);
2133 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0);
2134 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1);
2137 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0);
2138 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1);
2141 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0);
2142 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1);
2145 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0);
2146 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1);
2149 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0);
2150 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1);
2153 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0);
2154 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1);
2157 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0);
2158 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1);
2159 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2);
2160 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3);
2166 int rqt_root_cbf = 1;
2168 if (lc->cu.pred_mode != MODE_INTRA &&
2169 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2170 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2173 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2174 s->ps.sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2175 s->ps.sps->max_transform_hierarchy_depth_inter;
2176 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2178 log2_cb_size, 0, 0, 0, 0);
2182 if (!s->sh.disable_deblocking_filter_flag)
2183 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2188 if (s->ps.pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2189 ff_hevc_set_qPy(s, x0, y0, x0, y0, log2_cb_size);
2191 x = y_cb * min_cb_width + x_cb;
2192 for (y = 0; y < length; y++) {
2193 memset(&s->qp_y_tab[x], lc->qp_y, length);
2197 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct.depth);
2202 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2203 int log2_cb_size, int cb_depth)
2205 HEVCLocalContext *lc = &s->HEVClc;
2206 const int cb_size = 1 << log2_cb_size;
2209 lc->ct.depth = cb_depth;
2210 if (x0 + cb_size <= s->ps.sps->width &&
2211 y0 + cb_size <= s->ps.sps->height &&
2212 log2_cb_size > s->ps.sps->log2_min_cb_size) {
2213 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2215 split_cu = (log2_cb_size > s->ps.sps->log2_min_cb_size);
2217 if (s->ps.pps->cu_qp_delta_enabled_flag &&
2218 log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth) {
2219 lc->tu.is_cu_qp_delta_coded = 0;
2220 lc->tu.cu_qp_delta = 0;
2224 const int cb_size_split = cb_size >> 1;
2225 const int x1 = x0 + cb_size_split;
2226 const int y1 = y0 + cb_size_split;
2231 #define SUBDIVIDE(x, y) \
2233 if (x < s->ps.sps->width && y < s->ps.sps->height) { \
2234 int ret = hls_coding_quadtree(s, x, y, log2_cb_size, cb_depth);\
2245 int ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2253 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2256 HEVCLocalContext *lc = &s->HEVClc;
2257 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2258 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2259 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2261 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2263 if (s->ps.pps->entropy_coding_sync_enabled_flag) {
2264 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2265 lc->first_qp_group = 1;
2266 lc->end_of_tiles_x = s->ps.sps->width;
2267 } else if (s->ps.pps->tiles_enabled_flag) {
2268 if (ctb_addr_ts && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
2269 int idxX = s->ps.pps->col_idxX[x_ctb >> s->ps.sps->log2_ctb_size];
2270 lc->start_of_tiles_x = x_ctb;
2271 lc->end_of_tiles_x = x_ctb + (s->ps.pps->column_width[idxX] << s->ps.sps->log2_ctb_size);
2272 lc->first_qp_group = 1;
2275 lc->end_of_tiles_x = s->ps.sps->width;
2278 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->ps.sps->height);
2280 lc->boundary_flags = 0;
2281 if (s->ps.pps->tiles_enabled_flag) {
2282 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]])
2283 lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2284 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2285 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2286 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]])
2287 lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2288 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->ps.sps->ctb_width])
2289 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2291 if (!ctb_addr_in_slice > 0)
2292 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2293 if (ctb_addr_in_slice < s->ps.sps->ctb_width)
2294 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2297 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2298 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->ps.sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2299 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]]));
2300 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]]));
2303 static int hls_slice_data(HEVCContext *s)
2305 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2309 int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2312 while (more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2313 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2315 x_ctb = (ctb_addr_rs % ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2316 y_ctb = (ctb_addr_rs / ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2317 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2319 ff_hevc_cabac_init(s, ctb_addr_ts);
2321 hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2323 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2324 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2325 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2327 ret = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2330 more_data = !ff_hevc_end_of_slice_flag_decode(s);
2333 ff_hevc_save_states(s, ctb_addr_ts);
2334 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2337 if (x_ctb + ctb_size >= s->ps.sps->width &&
2338 y_ctb + ctb_size >= s->ps.sps->height)
2339 ff_hevc_hls_filter(s, x_ctb, y_ctb);
2344 static void restore_tqb_pixels(HEVCContext *s)
2346 int min_pu_size = 1 << s->ps.sps->log2_min_pu_size;
2349 for (c_idx = 0; c_idx < 3; c_idx++) {
2350 ptrdiff_t stride = s->frame->linesize[c_idx];
2351 int hshift = s->ps.sps->hshift[c_idx];
2352 int vshift = s->ps.sps->vshift[c_idx];
2353 for (y = 0; y < s->ps.sps->min_pu_height; y++) {
2354 for (x = 0; x < s->ps.sps->min_pu_width; x++) {
2355 if (s->is_pcm[y * s->ps.sps->min_pu_width + x]) {
2357 int len = min_pu_size >> hshift;
2358 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)];
2359 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)];
2360 for (n = 0; n < (min_pu_size >> vshift); n++) {
2361 memcpy(dst, src, len);
2371 static int set_side_data(HEVCContext *s)
2373 AVFrame *out = s->ref->frame;
2375 if (s->sei_frame_packing_present &&
2376 s->frame_packing_arrangement_type >= 3 &&
2377 s->frame_packing_arrangement_type <= 5 &&
2378 s->content_interpretation_type > 0 &&
2379 s->content_interpretation_type < 3) {
2380 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2382 return AVERROR(ENOMEM);
2384 switch (s->frame_packing_arrangement_type) {
2386 if (s->quincunx_subsampling)
2387 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2389 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2392 stereo->type = AV_STEREO3D_TOPBOTTOM;
2395 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2399 if (s->content_interpretation_type == 2)
2400 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2403 if (s->sei_display_orientation_present &&
2404 (s->sei_anticlockwise_rotation || s->sei_hflip || s->sei_vflip)) {
2405 double angle = s->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
2406 AVFrameSideData *rotation = av_frame_new_side_data(out,
2407 AV_FRAME_DATA_DISPLAYMATRIX,
2408 sizeof(int32_t) * 9);
2410 return AVERROR(ENOMEM);
2412 av_display_rotation_set((int32_t *)rotation->data, angle);
2413 av_display_matrix_flip((int32_t *)rotation->data,
2414 s->sei_hflip, s->sei_vflip);
2420 static int hevc_frame_start(HEVCContext *s)
2422 HEVCLocalContext *lc = &s->HEVClc;
2425 memset(s->horizontal_bs, 0, 2 * s->bs_width * (s->bs_height + 1));
2426 memset(s->vertical_bs, 0, 2 * s->bs_width * (s->bs_height + 1));
2427 memset(s->cbf_luma, 0, s->ps.sps->min_tb_width * s->ps.sps->min_tb_height);
2428 memset(s->is_pcm, 0, s->ps.sps->min_pu_width * s->ps.sps->min_pu_height);
2430 lc->start_of_tiles_x = 0;
2432 s->first_nal_type = s->nal_unit_type;
2434 if (s->ps.pps->tiles_enabled_flag)
2435 lc->end_of_tiles_x = s->ps.pps->column_width[0] << s->ps.sps->log2_ctb_size;
2437 ret = ff_hevc_set_new_ref(s, s->ps.sps->sao_enabled ? &s->sao_frame : &s->frame,
2442 ret = ff_hevc_frame_rps(s);
2444 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2448 s->ref->frame->key_frame = IS_IRAP(s);
2450 ret = set_side_data(s);
2454 av_frame_unref(s->output_frame);
2455 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2459 ff_thread_finish_setup(s->avctx);
2465 ff_hevc_unref_frame(s, s->ref, ~0);
2470 static int decode_nal_unit(HEVCContext *s, const HEVCNAL *nal)
2472 HEVCLocalContext *lc = &s->HEVClc;
2473 GetBitContext *gb = &lc->gb;
2474 int ctb_addr_ts, ret;
2477 s->nal_unit_type = nal->type;
2478 s->temporal_id = nal->temporal_id;
2480 switch (s->nal_unit_type) {
2482 ret = ff_hevc_decode_nal_vps(gb, s->avctx, &s->ps);
2487 ret = ff_hevc_decode_nal_sps(gb, s->avctx, &s->ps,
2488 s->apply_defdispwin);
2493 ret = ff_hevc_decode_nal_pps(gb, s->avctx, &s->ps);
2497 case NAL_SEI_PREFIX:
2498 case NAL_SEI_SUFFIX:
2499 ret = ff_hevc_decode_nal_sei(s);
2510 case NAL_BLA_W_RADL:
2512 case NAL_IDR_W_RADL:
2519 ret = hls_slice_header(s);
2523 if (s->max_ra == INT_MAX) {
2524 if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
2528 s->max_ra = INT_MIN;
2532 if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
2533 s->poc <= s->max_ra) {
2537 if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
2538 s->max_ra = INT_MIN;
2541 if (s->sh.first_slice_in_pic_flag) {
2542 ret = hevc_frame_start(s);
2545 } else if (!s->ref) {
2546 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2550 if (s->nal_unit_type != s->first_nal_type) {
2551 av_log(s->avctx, AV_LOG_ERROR,
2552 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2553 s->first_nal_type, s->nal_unit_type);
2554 return AVERROR_INVALIDDATA;
2557 if (!s->sh.dependent_slice_segment_flag &&
2558 s->sh.slice_type != I_SLICE) {
2559 ret = ff_hevc_slice_rpl(s);
2561 av_log(s->avctx, AV_LOG_WARNING,
2562 "Error constructing the reference lists for the current slice.\n");
2567 if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) {
2568 ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0);
2573 if (s->avctx->hwaccel) {
2574 ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size);
2578 ctb_addr_ts = hls_slice_data(s);
2579 if (ctb_addr_ts >= (s->ps.sps->ctb_width * s->ps.sps->ctb_height)) {
2581 if ((s->ps.pps->transquant_bypass_enable_flag ||
2582 (s->ps.sps->pcm.loop_filter_disable_flag && s->ps.sps->pcm_enabled_flag)) &&
2583 s->ps.sps->sao_enabled)
2584 restore_tqb_pixels(s);
2587 if (ctb_addr_ts < 0) {
2595 s->seq_decode = (s->seq_decode + 1) & 0xff;
2596 s->max_ra = INT_MAX;
2602 av_log(s->avctx, AV_LOG_INFO,
2603 "Skipping NAL unit %d\n", s->nal_unit_type);
2608 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2613 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2620 /* split the input packet into NAL units, so we know the upper bound on the
2621 * number of slices in the frame */
2622 ret = ff_hevc_split_packet(&s->pkt, buf, length, s->avctx, s->is_nalff,
2623 s->nal_length_size);
2625 av_log(s->avctx, AV_LOG_ERROR,
2626 "Error splitting the input into NAL units.\n");
2630 for (i = 0; i < s->pkt.nb_nals; i++) {
2631 if (s->pkt.nals[i].type == NAL_EOB_NUT ||
2632 s->pkt.nals[i].type == NAL_EOS_NUT)
2636 /* decode the NAL units */
2637 for (i = 0; i < s->pkt.nb_nals; i++) {
2638 ret = decode_nal_unit(s, &s->pkt.nals[i]);
2640 av_log(s->avctx, AV_LOG_WARNING,
2641 "Error parsing NAL unit #%d.\n", i);
2648 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2653 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2656 for (i = 0; i < 16; i++)
2657 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
2660 static int verify_md5(HEVCContext *s, AVFrame *frame)
2662 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
2667 return AVERROR(EINVAL);
2669 pixel_shift = desc->comp[0].depth_minus1 > 7;
2671 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
2674 /* the checksums are LE, so we have to byteswap for >8bpp formats
2677 if (pixel_shift && !s->checksum_buf) {
2678 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
2679 FFMAX3(frame->linesize[0], frame->linesize[1],
2680 frame->linesize[2]));
2681 if (!s->checksum_buf)
2682 return AVERROR(ENOMEM);
2686 for (i = 0; frame->data[i]; i++) {
2687 int width = s->avctx->coded_width;
2688 int height = s->avctx->coded_height;
2689 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
2690 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
2693 av_md5_init(s->md5_ctx);
2694 for (j = 0; j < h; j++) {
2695 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
2698 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
2699 (const uint16_t *) src, w);
2700 src = s->checksum_buf;
2703 av_md5_update(s->md5_ctx, src, w << pixel_shift);
2705 av_md5_final(s->md5_ctx, md5);
2707 if (!memcmp(md5, s->md5[i], 16)) {
2708 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
2709 print_md5(s->avctx, AV_LOG_DEBUG, md5);
2710 av_log (s->avctx, AV_LOG_DEBUG, "; ");
2712 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
2713 print_md5(s->avctx, AV_LOG_ERROR, md5);
2714 av_log (s->avctx, AV_LOG_ERROR, " != ");
2715 print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
2716 av_log (s->avctx, AV_LOG_ERROR, "\n");
2717 return AVERROR_INVALIDDATA;
2721 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2726 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
2730 HEVCContext *s = avctx->priv_data;
2733 ret = ff_hevc_output_frame(s, data, 1);
2742 ret = decode_nal_units(s, avpkt->data, avpkt->size);
2746 if (avctx->hwaccel) {
2747 if (s->ref && avctx->hwaccel->end_frame(avctx) < 0)
2748 av_log(avctx, AV_LOG_ERROR,
2749 "hardware accelerator failed to decode picture\n");
2751 /* verify the SEI checksum */
2752 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
2754 ret = verify_md5(s, s->ref->frame);
2755 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
2756 ff_hevc_unref_frame(s, s->ref, ~0);
2763 if (s->is_decoded) {
2764 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
2768 if (s->output_frame->buf[0]) {
2769 av_frame_move_ref(data, s->output_frame);
2776 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
2778 int ret = ff_thread_ref_frame(&dst->tf, &src->tf);
2782 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
2783 if (!dst->tab_mvf_buf)
2785 dst->tab_mvf = src->tab_mvf;
2787 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
2788 if (!dst->rpl_tab_buf)
2790 dst->rpl_tab = src->rpl_tab;
2792 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
2796 dst->poc = src->poc;
2797 dst->ctb_count = src->ctb_count;
2798 dst->window = src->window;
2799 dst->flags = src->flags;
2800 dst->sequence = src->sequence;
2802 if (src->hwaccel_picture_private) {
2803 dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
2804 if (!dst->hwaccel_priv_buf)
2806 dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
2811 ff_hevc_unref_frame(s, dst, ~0);
2812 return AVERROR(ENOMEM);
2815 static av_cold int hevc_decode_free(AVCodecContext *avctx)
2817 HEVCContext *s = avctx->priv_data;
2822 av_freep(&s->md5_ctx);
2824 av_frame_free(&s->tmp_frame);
2825 av_frame_free(&s->output_frame);
2827 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2828 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
2829 av_frame_free(&s->DPB[i].frame);
2832 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++)
2833 av_buffer_unref(&s->ps.vps_list[i]);
2834 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++)
2835 av_buffer_unref(&s->ps.sps_list[i]);
2836 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++)
2837 av_buffer_unref(&s->ps.pps_list[i]);
2839 for (i = 0; i < s->pkt.nals_allocated; i++)
2840 av_freep(&s->pkt.nals[i].rbsp_buffer);
2841 av_freep(&s->pkt.nals);
2842 s->pkt.nals_allocated = 0;
2847 static av_cold int hevc_init_context(AVCodecContext *avctx)
2849 HEVCContext *s = avctx->priv_data;
2854 s->tmp_frame = av_frame_alloc();
2858 s->output_frame = av_frame_alloc();
2859 if (!s->output_frame)
2862 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2863 s->DPB[i].frame = av_frame_alloc();
2864 if (!s->DPB[i].frame)
2866 s->DPB[i].tf.f = s->DPB[i].frame;
2869 s->max_ra = INT_MAX;
2871 s->md5_ctx = av_md5_alloc();
2875 ff_bswapdsp_init(&s->bdsp);
2877 s->context_initialized = 1;
2882 hevc_decode_free(avctx);
2883 return AVERROR(ENOMEM);
2886 static int hevc_update_thread_context(AVCodecContext *dst,
2887 const AVCodecContext *src)
2889 HEVCContext *s = dst->priv_data;
2890 HEVCContext *s0 = src->priv_data;
2893 if (!s->context_initialized) {
2894 ret = hevc_init_context(dst);
2899 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2900 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
2901 if (s0->DPB[i].frame->buf[0]) {
2902 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
2908 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++) {
2909 av_buffer_unref(&s->ps.vps_list[i]);
2910 if (s0->ps.vps_list[i]) {
2911 s->ps.vps_list[i] = av_buffer_ref(s0->ps.vps_list[i]);
2912 if (!s->ps.vps_list[i])
2913 return AVERROR(ENOMEM);
2917 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
2918 av_buffer_unref(&s->ps.sps_list[i]);
2919 if (s0->ps.sps_list[i]) {
2920 s->ps.sps_list[i] = av_buffer_ref(s0->ps.sps_list[i]);
2921 if (!s->ps.sps_list[i])
2922 return AVERROR(ENOMEM);
2926 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++) {
2927 av_buffer_unref(&s->ps.pps_list[i]);
2928 if (s0->ps.pps_list[i]) {
2929 s->ps.pps_list[i] = av_buffer_ref(s0->ps.pps_list[i]);
2930 if (!s->ps.pps_list[i])
2931 return AVERROR(ENOMEM);
2935 if (s->ps.sps != s0->ps.sps)
2936 ret = set_sps(s, s0->ps.sps);
2938 s->seq_decode = s0->seq_decode;
2939 s->seq_output = s0->seq_output;
2940 s->pocTid0 = s0->pocTid0;
2941 s->max_ra = s0->max_ra;
2943 s->is_nalff = s0->is_nalff;
2944 s->nal_length_size = s0->nal_length_size;
2947 s->seq_decode = (s->seq_decode + 1) & 0xff;
2948 s->max_ra = INT_MAX;
2954 static int hevc_decode_extradata(HEVCContext *s)
2956 AVCodecContext *avctx = s->avctx;
2960 bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
2962 if (avctx->extradata_size > 3 &&
2963 (avctx->extradata[0] || avctx->extradata[1] ||
2964 avctx->extradata[2] > 1)) {
2965 /* It seems the extradata is encoded as hvcC format.
2966 * Temporarily, we support configurationVersion==0 until 14496-15 3rd
2967 * is finalized. When finalized, configurationVersion will be 1 and we
2968 * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
2969 int i, j, num_arrays, nal_len_size;
2973 bytestream2_skip(&gb, 21);
2974 nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
2975 num_arrays = bytestream2_get_byte(&gb);
2977 /* nal units in the hvcC always have length coded with 2 bytes,
2978 * so put a fake nal_length_size = 2 while parsing them */
2979 s->nal_length_size = 2;
2981 /* Decode nal units from hvcC. */
2982 for (i = 0; i < num_arrays; i++) {
2983 int type = bytestream2_get_byte(&gb) & 0x3f;
2984 int cnt = bytestream2_get_be16(&gb);
2986 for (j = 0; j < cnt; j++) {
2987 // +2 for the nal size field
2988 int nalsize = bytestream2_peek_be16(&gb) + 2;
2989 if (bytestream2_get_bytes_left(&gb) < nalsize) {
2990 av_log(s->avctx, AV_LOG_ERROR,
2991 "Invalid NAL unit size in extradata.\n");
2992 return AVERROR_INVALIDDATA;
2995 ret = decode_nal_units(s, gb.buffer, nalsize);
2997 av_log(avctx, AV_LOG_ERROR,
2998 "Decoding nal unit %d %d from hvcC failed\n",
3002 bytestream2_skip(&gb, nalsize);
3006 /* Now store right nal length size, that will be used to parse
3008 s->nal_length_size = nal_len_size;
3011 ret = decode_nal_units(s, avctx->extradata, avctx->extradata_size);
3016 /* export stream parameters from the first SPS */
3017 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3018 if (s->ps.sps_list[i]) {
3019 const HEVCSPS *sps = (const HEVCSPS*)s->ps.sps_list[i]->data;
3020 export_stream_params(s->avctx, s, sps);
3028 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3030 HEVCContext *s = avctx->priv_data;
3033 ff_init_cabac_states();
3035 avctx->internal->allocate_progress = 1;
3037 ret = hevc_init_context(avctx);
3041 if (avctx->extradata_size > 0 && avctx->extradata) {
3042 ret = hevc_decode_extradata(s);
3044 hevc_decode_free(avctx);
3052 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3054 HEVCContext *s = avctx->priv_data;
3057 memset(s, 0, sizeof(*s));
3059 ret = hevc_init_context(avctx);
3066 static void hevc_decode_flush(AVCodecContext *avctx)
3068 HEVCContext *s = avctx->priv_data;
3069 ff_hevc_flush_dpb(s);
3070 s->max_ra = INT_MAX;
3073 #define OFFSET(x) offsetof(HEVCContext, x)
3074 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3076 static const AVProfile profiles[] = {
3077 { FF_PROFILE_HEVC_MAIN, "Main" },
3078 { FF_PROFILE_HEVC_MAIN_10, "Main 10" },
3079 { FF_PROFILE_HEVC_MAIN_STILL_PICTURE, "Main Still Picture" },
3080 { FF_PROFILE_UNKNOWN },
3083 static const AVOption options[] = {
3084 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3085 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3089 static const AVClass hevc_decoder_class = {
3090 .class_name = "HEVC decoder",
3091 .item_name = av_default_item_name,
3093 .version = LIBAVUTIL_VERSION_INT,
3096 AVCodec ff_hevc_decoder = {
3098 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3099 .type = AVMEDIA_TYPE_VIDEO,
3100 .id = AV_CODEC_ID_HEVC,
3101 .priv_data_size = sizeof(HEVCContext),
3102 .priv_class = &hevc_decoder_class,
3103 .init = hevc_decode_init,
3104 .close = hevc_decode_free,
3105 .decode = hevc_decode_frame,
3106 .flush = hevc_decode_flush,
3107 .update_thread_context = hevc_update_thread_context,
3108 .init_thread_copy = hevc_init_thread_copy,
3109 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY |
3110 CODEC_CAP_FRAME_THREADS,
3111 .profiles = NULL_IF_CONFIG_SMALL(profiles),