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->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->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->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->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->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)
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;
451 *fmt++ = sps->pix_fmt;
452 *fmt = AV_PIX_FMT_NONE;
454 ret = ff_get_format(s->avctx, pix_fmts);
457 s->avctx->pix_fmt = ret;
459 ff_hevc_pred_init(&s->hpc, sps->bit_depth);
460 ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
461 ff_videodsp_init (&s->vdsp, sps->bit_depth);
463 if (sps->sao_enabled && !s->avctx->hwaccel) {
464 av_frame_unref(s->tmp_frame);
465 ret = ff_get_buffer(s->avctx, s->tmp_frame, AV_GET_BUFFER_FLAG_REF);
468 s->frame = s->tmp_frame;
472 s->vps = (HEVCVPS*) s->vps_list[s->sps->vps_id]->data;
482 static int hls_slice_header(HEVCContext *s)
484 GetBitContext *gb = &s->HEVClc.gb;
485 SliceHeader *sh = &s->sh;
489 sh->first_slice_in_pic_flag = get_bits1(gb);
490 if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
491 s->seq_decode = (s->seq_decode + 1) & 0xff;
494 ff_hevc_clear_refs(s);
497 sh->no_output_of_prior_pics_flag = get_bits1(gb);
499 sh->pps_id = get_ue_golomb_long(gb);
500 if (sh->pps_id >= MAX_PPS_COUNT || !s->pps_list[sh->pps_id]) {
501 av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
502 return AVERROR_INVALIDDATA;
504 if (!sh->first_slice_in_pic_flag &&
505 s->pps != (HEVCPPS*)s->pps_list[sh->pps_id]->data) {
506 av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
507 return AVERROR_INVALIDDATA;
509 s->pps = (HEVCPPS*)s->pps_list[sh->pps_id]->data;
511 if (s->sps != (HEVCSPS*)s->sps_list[s->pps->sps_id]->data) {
512 s->sps = (HEVCSPS*)s->sps_list[s->pps->sps_id]->data;
514 ff_hevc_clear_refs(s);
515 ret = set_sps(s, s->sps);
519 s->seq_decode = (s->seq_decode + 1) & 0xff;
523 sh->dependent_slice_segment_flag = 0;
524 if (!sh->first_slice_in_pic_flag) {
525 int slice_address_length;
527 if (s->pps->dependent_slice_segments_enabled_flag)
528 sh->dependent_slice_segment_flag = get_bits1(gb);
530 slice_address_length = av_ceil_log2(s->sps->ctb_width *
532 sh->slice_segment_addr = get_bits(gb, slice_address_length);
533 if (sh->slice_segment_addr >= s->sps->ctb_width * s->sps->ctb_height) {
534 av_log(s->avctx, AV_LOG_ERROR,
535 "Invalid slice segment address: %u.\n",
536 sh->slice_segment_addr);
537 return AVERROR_INVALIDDATA;
540 if (!sh->dependent_slice_segment_flag) {
541 sh->slice_addr = sh->slice_segment_addr;
545 sh->slice_segment_addr = sh->slice_addr = 0;
547 s->slice_initialized = 0;
550 if (!sh->dependent_slice_segment_flag) {
551 s->slice_initialized = 0;
553 for (i = 0; i < s->pps->num_extra_slice_header_bits; i++)
554 skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
556 sh->slice_type = get_ue_golomb_long(gb);
557 if (!(sh->slice_type == I_SLICE ||
558 sh->slice_type == P_SLICE ||
559 sh->slice_type == B_SLICE)) {
560 av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
562 return AVERROR_INVALIDDATA;
564 if (IS_IRAP(s) && sh->slice_type != I_SLICE) {
565 av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
566 return AVERROR_INVALIDDATA;
569 // when flag is not present, picture is inferred to be output
570 sh->pic_output_flag = 1;
571 if (s->pps->output_flag_present_flag)
572 sh->pic_output_flag = get_bits1(gb);
574 if (s->sps->separate_colour_plane_flag)
575 sh->colour_plane_id = get_bits(gb, 2);
580 sh->pic_order_cnt_lsb = get_bits(gb, s->sps->log2_max_poc_lsb);
581 poc = ff_hevc_compute_poc(s, sh->pic_order_cnt_lsb);
582 if (!sh->first_slice_in_pic_flag && poc != s->poc) {
583 av_log(s->avctx, AV_LOG_WARNING,
584 "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
585 if (s->avctx->err_recognition & AV_EF_EXPLODE)
586 return AVERROR_INVALIDDATA;
591 sh->short_term_ref_pic_set_sps_flag = get_bits1(gb);
592 if (!sh->short_term_ref_pic_set_sps_flag) {
593 int pos = get_bits_left(gb);
594 ret = ff_hevc_decode_short_term_rps(s, &sh->slice_rps, s->sps, 1);
598 sh->short_term_ref_pic_set_size = pos - get_bits_left(gb);
599 sh->short_term_rps = &sh->slice_rps;
601 int numbits, rps_idx;
603 if (!s->sps->nb_st_rps) {
604 av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
605 return AVERROR_INVALIDDATA;
608 numbits = av_ceil_log2(s->sps->nb_st_rps);
609 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
610 sh->short_term_rps = &s->sps->st_rps[rps_idx];
613 ret = decode_lt_rps(s, &sh->long_term_rps, gb);
615 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
616 if (s->avctx->err_recognition & AV_EF_EXPLODE)
617 return AVERROR_INVALIDDATA;
620 if (s->sps->sps_temporal_mvp_enabled_flag)
621 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
623 sh->slice_temporal_mvp_enabled_flag = 0;
625 s->sh.short_term_rps = NULL;
630 if (s->temporal_id == 0 &&
631 s->nal_unit_type != NAL_TRAIL_N &&
632 s->nal_unit_type != NAL_TSA_N &&
633 s->nal_unit_type != NAL_STSA_N &&
634 s->nal_unit_type != NAL_RADL_N &&
635 s->nal_unit_type != NAL_RADL_R &&
636 s->nal_unit_type != NAL_RASL_N &&
637 s->nal_unit_type != NAL_RASL_R)
640 if (s->sps->sao_enabled) {
641 sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
642 sh->slice_sample_adaptive_offset_flag[1] =
643 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
645 sh->slice_sample_adaptive_offset_flag[0] = 0;
646 sh->slice_sample_adaptive_offset_flag[1] = 0;
647 sh->slice_sample_adaptive_offset_flag[2] = 0;
650 sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
651 if (sh->slice_type == P_SLICE || sh->slice_type == B_SLICE) {
654 sh->nb_refs[L0] = s->pps->num_ref_idx_l0_default_active;
655 if (sh->slice_type == B_SLICE)
656 sh->nb_refs[L1] = s->pps->num_ref_idx_l1_default_active;
658 if (get_bits1(gb)) { // num_ref_idx_active_override_flag
659 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
660 if (sh->slice_type == B_SLICE)
661 sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
663 if (sh->nb_refs[L0] > MAX_REFS || sh->nb_refs[L1] > MAX_REFS) {
664 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
665 sh->nb_refs[L0], sh->nb_refs[L1]);
666 return AVERROR_INVALIDDATA;
669 sh->rpl_modification_flag[0] = 0;
670 sh->rpl_modification_flag[1] = 0;
671 nb_refs = ff_hevc_frame_nb_refs(s);
673 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
674 return AVERROR_INVALIDDATA;
677 if (s->pps->lists_modification_present_flag && nb_refs > 1) {
678 sh->rpl_modification_flag[0] = get_bits1(gb);
679 if (sh->rpl_modification_flag[0]) {
680 for (i = 0; i < sh->nb_refs[L0]; i++)
681 sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
684 if (sh->slice_type == B_SLICE) {
685 sh->rpl_modification_flag[1] = get_bits1(gb);
686 if (sh->rpl_modification_flag[1] == 1)
687 for (i = 0; i < sh->nb_refs[L1]; i++)
688 sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
692 if (sh->slice_type == B_SLICE)
693 sh->mvd_l1_zero_flag = get_bits1(gb);
695 if (s->pps->cabac_init_present_flag)
696 sh->cabac_init_flag = get_bits1(gb);
698 sh->cabac_init_flag = 0;
700 sh->collocated_ref_idx = 0;
701 if (sh->slice_temporal_mvp_enabled_flag) {
702 sh->collocated_list = L0;
703 if (sh->slice_type == B_SLICE)
704 sh->collocated_list = !get_bits1(gb);
706 if (sh->nb_refs[sh->collocated_list] > 1) {
707 sh->collocated_ref_idx = get_ue_golomb_long(gb);
708 if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
709 av_log(s->avctx, AV_LOG_ERROR,
710 "Invalid collocated_ref_idx: %d.\n",
711 sh->collocated_ref_idx);
712 return AVERROR_INVALIDDATA;
717 if ((s->pps->weighted_pred_flag && sh->slice_type == P_SLICE) ||
718 (s->pps->weighted_bipred_flag && sh->slice_type == B_SLICE)) {
719 pred_weight_table(s, gb);
722 sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
723 if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
724 av_log(s->avctx, AV_LOG_ERROR,
725 "Invalid number of merging MVP candidates: %d.\n",
726 sh->max_num_merge_cand);
727 return AVERROR_INVALIDDATA;
731 sh->slice_qp_delta = get_se_golomb(gb);
733 if (s->pps->pic_slice_level_chroma_qp_offsets_present_flag) {
734 sh->slice_cb_qp_offset = get_se_golomb(gb);
735 sh->slice_cr_qp_offset = get_se_golomb(gb);
737 sh->slice_cb_qp_offset = 0;
738 sh->slice_cr_qp_offset = 0;
741 if (s->pps->deblocking_filter_control_present_flag) {
742 int deblocking_filter_override_flag = 0;
744 if (s->pps->deblocking_filter_override_enabled_flag)
745 deblocking_filter_override_flag = get_bits1(gb);
747 if (deblocking_filter_override_flag) {
748 sh->disable_deblocking_filter_flag = get_bits1(gb);
749 if (!sh->disable_deblocking_filter_flag) {
750 sh->beta_offset = get_se_golomb(gb) * 2;
751 sh->tc_offset = get_se_golomb(gb) * 2;
754 sh->disable_deblocking_filter_flag = s->pps->disable_dbf;
755 sh->beta_offset = s->pps->beta_offset;
756 sh->tc_offset = s->pps->tc_offset;
759 sh->disable_deblocking_filter_flag = 0;
764 if (s->pps->seq_loop_filter_across_slices_enabled_flag &&
765 (sh->slice_sample_adaptive_offset_flag[0] ||
766 sh->slice_sample_adaptive_offset_flag[1] ||
767 !sh->disable_deblocking_filter_flag)) {
768 sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
770 sh->slice_loop_filter_across_slices_enabled_flag = s->pps->seq_loop_filter_across_slices_enabled_flag;
772 } else if (!s->slice_initialized) {
773 av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
774 return AVERROR_INVALIDDATA;
777 sh->num_entry_point_offsets = 0;
778 if (s->pps->tiles_enabled_flag || s->pps->entropy_coding_sync_enabled_flag) {
779 sh->num_entry_point_offsets = get_ue_golomb_long(gb);
780 if (sh->num_entry_point_offsets > 0) {
781 int offset_len = get_ue_golomb_long(gb) + 1;
783 for (i = 0; i < sh->num_entry_point_offsets; i++)
784 skip_bits(gb, offset_len);
788 if (s->pps->slice_header_extension_present_flag) {
789 unsigned int length = get_ue_golomb_long(gb);
790 for (i = 0; i < length; i++)
791 skip_bits(gb, 8); // slice_header_extension_data_byte
794 // Inferred parameters
795 sh->slice_qp = 26 + s->pps->pic_init_qp_minus26 + sh->slice_qp_delta;
796 if (sh->slice_qp > 51 ||
797 sh->slice_qp < -s->sps->qp_bd_offset) {
798 av_log(s->avctx, AV_LOG_ERROR,
799 "The slice_qp %d is outside the valid range "
802 -s->sps->qp_bd_offset);
803 return AVERROR_INVALIDDATA;
806 sh->slice_ctb_addr_rs = sh->slice_segment_addr;
808 if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) {
809 av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
810 return AVERROR_INVALIDDATA;
813 s->HEVClc.first_qp_group = !s->sh.dependent_slice_segment_flag;
815 if (!s->pps->cu_qp_delta_enabled_flag)
816 s->HEVClc.qp_y = FFUMOD(s->sh.slice_qp + 52 + 2 * s->sps->qp_bd_offset,
817 52 + s->sps->qp_bd_offset) - s->sps->qp_bd_offset;
819 s->slice_initialized = 1;
824 #define CTB(tab, x, y) ((tab)[(y) * s->sps->ctb_width + (x)])
826 #define SET_SAO(elem, value) \
828 if (!sao_merge_up_flag && !sao_merge_left_flag) \
830 else if (sao_merge_left_flag) \
831 sao->elem = CTB(s->sao, rx-1, ry).elem; \
832 else if (sao_merge_up_flag) \
833 sao->elem = CTB(s->sao, rx, ry-1).elem; \
838 static void hls_sao_param(HEVCContext *s, int rx, int ry)
840 HEVCLocalContext *lc = &s->HEVClc;
841 int sao_merge_left_flag = 0;
842 int sao_merge_up_flag = 0;
843 int shift = s->sps->bit_depth - FFMIN(s->sps->bit_depth, 10);
844 SAOParams *sao = &CTB(s->sao, rx, ry);
847 if (s->sh.slice_sample_adaptive_offset_flag[0] ||
848 s->sh.slice_sample_adaptive_offset_flag[1]) {
850 if (lc->ctb_left_flag)
851 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
853 if (ry > 0 && !sao_merge_left_flag) {
855 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
859 for (c_idx = 0; c_idx < 3; c_idx++) {
860 if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
861 sao->type_idx[c_idx] = SAO_NOT_APPLIED;
866 sao->type_idx[2] = sao->type_idx[1];
867 sao->eo_class[2] = sao->eo_class[1];
869 SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
872 if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
875 for (i = 0; i < 4; i++)
876 SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
878 if (sao->type_idx[c_idx] == SAO_BAND) {
879 for (i = 0; i < 4; i++) {
880 if (sao->offset_abs[c_idx][i]) {
881 SET_SAO(offset_sign[c_idx][i],
882 ff_hevc_sao_offset_sign_decode(s));
884 sao->offset_sign[c_idx][i] = 0;
887 SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
888 } else if (c_idx != 2) {
889 SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
892 // Inferred parameters
893 sao->offset_val[c_idx][0] = 0;
894 for (i = 0; i < 4; i++) {
895 sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i] << shift;
896 if (sao->type_idx[c_idx] == SAO_EDGE) {
898 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
899 } else if (sao->offset_sign[c_idx][i]) {
900 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
909 static void hls_residual_coding(HEVCContext *s, int x0, int y0,
910 int log2_trafo_size, enum ScanType scan_idx,
913 #define GET_COORD(offset, n) \
915 x_c = (scan_x_cg[offset >> 4] << 2) + scan_x_off[n]; \
916 y_c = (scan_y_cg[offset >> 4] << 2) + scan_y_off[n]; \
918 HEVCLocalContext *lc = &s->HEVClc;
919 int transform_skip_flag = 0;
921 int last_significant_coeff_x, last_significant_coeff_y;
925 int greater1_ctx = 1;
928 int x_cg_last_sig, y_cg_last_sig;
930 const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
932 ptrdiff_t stride = s->frame->linesize[c_idx];
933 int hshift = s->sps->hshift[c_idx];
934 int vshift = s->sps->vshift[c_idx];
935 uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
936 ((x0 >> hshift) << s->sps->pixel_shift)];
937 DECLARE_ALIGNED(16, int16_t, coeffs[MAX_TB_SIZE * MAX_TB_SIZE]) = { 0 };
938 DECLARE_ALIGNED(8, uint8_t, significant_coeff_group_flag[8][8]) = { { 0 } };
940 int trafo_size = 1 << log2_trafo_size;
941 int i, qp, shift, add, scale, scale_m;
942 const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
943 const uint8_t *scale_matrix;
946 // Derive QP for dequant
947 if (!lc->cu.cu_transquant_bypass_flag) {
948 static const int qp_c[] = {
949 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37
952 static const uint8_t rem6[51 + 2 * 6 + 1] = {
953 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
954 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
955 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
958 static const uint8_t div6[51 + 2 * 6 + 1] = {
959 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
960 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
961 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
966 qp = qp_y + s->sps->qp_bd_offset;
971 offset = s->pps->cb_qp_offset + s->sh.slice_cb_qp_offset;
973 offset = s->pps->cr_qp_offset + s->sh.slice_cr_qp_offset;
975 qp_i = av_clip(qp_y + offset, -s->sps->qp_bd_offset, 57);
981 qp = qp_c[qp_i - 30];
983 qp += s->sps->qp_bd_offset;
986 shift = s->sps->bit_depth + log2_trafo_size - 5;
987 add = 1 << (shift - 1);
988 scale = level_scale[rem6[qp]] << (div6[qp]);
989 scale_m = 16; // default when no custom scaling lists.
992 if (s->sps->scaling_list_enable_flag) {
993 const ScalingList *sl = s->pps->scaling_list_data_present_flag ?
994 &s->pps->scaling_list : &s->sps->scaling_list;
995 int matrix_id = lc->cu.pred_mode != MODE_INTRA;
997 if (log2_trafo_size != 5)
998 matrix_id = 3 * matrix_id + c_idx;
1000 scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
1001 if (log2_trafo_size >= 4)
1002 dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
1006 if (s->pps->transform_skip_enabled_flag &&
1007 !lc->cu.cu_transquant_bypass_flag &&
1008 log2_trafo_size == 2) {
1009 transform_skip_flag = ff_hevc_transform_skip_flag_decode(s, c_idx);
1012 last_significant_coeff_x =
1013 ff_hevc_last_significant_coeff_x_prefix_decode(s, c_idx, log2_trafo_size);
1014 last_significant_coeff_y =
1015 ff_hevc_last_significant_coeff_y_prefix_decode(s, c_idx, log2_trafo_size);
1017 if (last_significant_coeff_x > 3) {
1018 int suffix = ff_hevc_last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
1019 last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
1020 (2 + (last_significant_coeff_x & 1)) +
1024 if (last_significant_coeff_y > 3) {
1025 int suffix = ff_hevc_last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
1026 last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
1027 (2 + (last_significant_coeff_y & 1)) +
1031 if (scan_idx == SCAN_VERT)
1032 FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
1034 x_cg_last_sig = last_significant_coeff_x >> 2;
1035 y_cg_last_sig = last_significant_coeff_y >> 2;
1039 int last_x_c = last_significant_coeff_x & 3;
1040 int last_y_c = last_significant_coeff_y & 3;
1042 scan_x_off = ff_hevc_diag_scan4x4_x;
1043 scan_y_off = ff_hevc_diag_scan4x4_y;
1044 num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
1045 if (trafo_size == 4) {
1046 scan_x_cg = scan_1x1;
1047 scan_y_cg = scan_1x1;
1048 } else if (trafo_size == 8) {
1049 num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1050 scan_x_cg = diag_scan2x2_x;
1051 scan_y_cg = diag_scan2x2_y;
1052 } else if (trafo_size == 16) {
1053 num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1054 scan_x_cg = ff_hevc_diag_scan4x4_x;
1055 scan_y_cg = ff_hevc_diag_scan4x4_y;
1056 } else { // trafo_size == 32
1057 num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1058 scan_x_cg = ff_hevc_diag_scan8x8_x;
1059 scan_y_cg = ff_hevc_diag_scan8x8_y;
1064 scan_x_cg = horiz_scan2x2_x;
1065 scan_y_cg = horiz_scan2x2_y;
1066 scan_x_off = horiz_scan4x4_x;
1067 scan_y_off = horiz_scan4x4_y;
1068 num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1070 default: //SCAN_VERT
1071 scan_x_cg = horiz_scan2x2_y;
1072 scan_y_cg = horiz_scan2x2_x;
1073 scan_x_off = horiz_scan4x4_y;
1074 scan_y_off = horiz_scan4x4_x;
1075 num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1079 num_last_subset = (num_coeff - 1) >> 4;
1081 for (i = num_last_subset; i >= 0; i--) {
1083 int x_cg, y_cg, x_c, y_c;
1084 int implicit_non_zero_coeff = 0;
1085 int64_t trans_coeff_level;
1087 int offset = i << 4;
1089 uint8_t significant_coeff_flag_idx[16];
1090 uint8_t nb_significant_coeff_flag = 0;
1092 x_cg = scan_x_cg[i];
1093 y_cg = scan_y_cg[i];
1095 if (i < num_last_subset && i > 0) {
1097 if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1098 ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1099 if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1100 ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1102 significant_coeff_group_flag[x_cg][y_cg] =
1103 ff_hevc_significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
1104 implicit_non_zero_coeff = 1;
1106 significant_coeff_group_flag[x_cg][y_cg] =
1107 ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1108 (x_cg == 0 && y_cg == 0));
1111 last_scan_pos = num_coeff - offset - 1;
1113 if (i == num_last_subset) {
1114 n_end = last_scan_pos - 1;
1115 significant_coeff_flag_idx[0] = last_scan_pos;
1116 nb_significant_coeff_flag = 1;
1121 if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1122 prev_sig = significant_coeff_group_flag[x_cg + 1][y_cg];
1123 if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1124 prev_sig += significant_coeff_group_flag[x_cg][y_cg + 1] << 1;
1126 for (n = n_end; n >= 0; n--) {
1127 GET_COORD(offset, n);
1129 if (significant_coeff_group_flag[x_cg][y_cg] &&
1130 (n > 0 || implicit_non_zero_coeff == 0)) {
1131 if (ff_hevc_significant_coeff_flag_decode(s, c_idx, x_c, y_c,
1135 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1136 nb_significant_coeff_flag++;
1137 implicit_non_zero_coeff = 0;
1140 int last_cg = (x_c == (x_cg << 2) && y_c == (y_cg << 2));
1141 if (last_cg && implicit_non_zero_coeff && significant_coeff_group_flag[x_cg][y_cg]) {
1142 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1143 nb_significant_coeff_flag++;
1148 n_end = nb_significant_coeff_flag;
1151 int first_nz_pos_in_cg = 16;
1152 int last_nz_pos_in_cg = -1;
1153 int c_rice_param = 0;
1154 int first_greater1_coeff_idx = -1;
1155 uint8_t coeff_abs_level_greater1_flag[16] = { 0 };
1156 uint16_t coeff_sign_flag;
1158 int sign_hidden = 0;
1160 // initialize first elem of coeff_bas_level_greater1_flag
1161 int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1163 if (!(i == num_last_subset) && greater1_ctx == 0)
1166 last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1168 for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1169 int n_idx = significant_coeff_flag_idx[m];
1170 int inc = (ctx_set << 2) + greater1_ctx;
1171 coeff_abs_level_greater1_flag[n_idx] =
1172 ff_hevc_coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
1173 if (coeff_abs_level_greater1_flag[n_idx]) {
1175 } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1179 if (coeff_abs_level_greater1_flag[n_idx] &&
1180 first_greater1_coeff_idx == -1)
1181 first_greater1_coeff_idx = n_idx;
1183 first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1184 sign_hidden = last_nz_pos_in_cg - first_nz_pos_in_cg >= 4 &&
1185 !lc->cu.cu_transquant_bypass_flag;
1187 if (first_greater1_coeff_idx != -1) {
1188 coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += ff_hevc_coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1190 if (!s->pps->sign_data_hiding_flag || !sign_hidden) {
1191 coeff_sign_flag = ff_hevc_coeff_sign_flag(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1193 coeff_sign_flag = ff_hevc_coeff_sign_flag(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1196 for (m = 0; m < n_end; m++) {
1197 n = significant_coeff_flag_idx[m];
1198 GET_COORD(offset, n);
1199 trans_coeff_level = 1 + coeff_abs_level_greater1_flag[n];
1200 if (trans_coeff_level == ((m < 8) ?
1201 ((n == first_greater1_coeff_idx) ? 3 : 2) : 1)) {
1202 int last_coeff_abs_level_remaining = ff_hevc_coeff_abs_level_remaining(s, trans_coeff_level, c_rice_param);
1204 trans_coeff_level += last_coeff_abs_level_remaining;
1205 if ((trans_coeff_level) > (3 * (1 << c_rice_param)))
1206 c_rice_param = FFMIN(c_rice_param + 1, 4);
1208 if (s->pps->sign_data_hiding_flag && sign_hidden) {
1209 sum_abs += trans_coeff_level;
1210 if (n == first_nz_pos_in_cg && ((sum_abs & 1) == 1))
1211 trans_coeff_level = -trans_coeff_level;
1213 if (coeff_sign_flag >> 15)
1214 trans_coeff_level = -trans_coeff_level;
1215 coeff_sign_flag <<= 1;
1216 if (!lc->cu.cu_transquant_bypass_flag) {
1217 if (s->sps->scaling_list_enable_flag) {
1218 if (y_c || x_c || log2_trafo_size < 4) {
1220 switch (log2_trafo_size) {
1221 case 3: pos = (y_c << 3) + x_c; break;
1222 case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1223 case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1224 default: pos = (y_c << 2) + x_c;
1226 scale_m = scale_matrix[pos];
1231 trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1232 if(trans_coeff_level < 0) {
1233 if((~trans_coeff_level) & 0xFffffffffff8000)
1234 trans_coeff_level = -32768;
1236 if (trans_coeff_level & 0xffffffffffff8000)
1237 trans_coeff_level = 32767;
1240 coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1245 if (lc->cu.cu_transquant_bypass_flag) {
1246 s->hevcdsp.transquant_bypass[log2_trafo_size - 2](dst, coeffs, stride);
1248 if (transform_skip_flag)
1249 s->hevcdsp.transform_skip(dst, coeffs, stride);
1250 else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 &&
1251 log2_trafo_size == 2)
1252 s->hevcdsp.transform_4x4_luma_add(dst, coeffs, stride);
1254 s->hevcdsp.transform_add[log2_trafo_size - 2](dst, coeffs, stride);
1258 static int hls_transform_unit(HEVCContext *s, int x0, int y0,
1259 int xBase, int yBase, int cb_xBase, int cb_yBase,
1260 int log2_cb_size, int log2_trafo_size,
1261 int blk_idx, int cbf_luma, int cbf_cb, int cbf_cr)
1263 HEVCLocalContext *lc = &s->HEVClc;
1265 if (lc->cu.pred_mode == MODE_INTRA) {
1266 int trafo_size = 1 << log2_trafo_size;
1267 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1269 s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
1270 if (log2_trafo_size > 2) {
1271 trafo_size = trafo_size << (s->sps->hshift[1] - 1);
1272 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1273 s->hpc.intra_pred[log2_trafo_size - 3](s, x0, y0, 1);
1274 s->hpc.intra_pred[log2_trafo_size - 3](s, x0, y0, 2);
1275 } else if (blk_idx == 3) {
1276 trafo_size = trafo_size << s->sps->hshift[1];
1277 ff_hevc_set_neighbour_available(s, xBase, yBase,
1278 trafo_size, trafo_size);
1279 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1280 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1284 if (cbf_luma || cbf_cb || cbf_cr) {
1285 int scan_idx = SCAN_DIAG;
1286 int scan_idx_c = SCAN_DIAG;
1288 if (s->pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
1289 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
1290 if (lc->tu.cu_qp_delta != 0)
1291 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
1292 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
1293 lc->tu.is_cu_qp_delta_coded = 1;
1295 if (lc->tu.cu_qp_delta < -(26 + s->sps->qp_bd_offset / 2) ||
1296 lc->tu.cu_qp_delta > (25 + s->sps->qp_bd_offset / 2)) {
1297 av_log(s->avctx, AV_LOG_ERROR,
1298 "The cu_qp_delta %d is outside the valid range "
1301 -(26 + s->sps->qp_bd_offset / 2),
1302 (25 + s->sps->qp_bd_offset / 2));
1303 return AVERROR_INVALIDDATA;
1306 ff_hevc_set_qPy(s, x0, y0, cb_xBase, cb_yBase, log2_cb_size);
1309 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
1310 if (lc->tu.cur_intra_pred_mode >= 6 &&
1311 lc->tu.cur_intra_pred_mode <= 14) {
1312 scan_idx = SCAN_VERT;
1313 } else if (lc->tu.cur_intra_pred_mode >= 22 &&
1314 lc->tu.cur_intra_pred_mode <= 30) {
1315 scan_idx = SCAN_HORIZ;
1318 if (lc->pu.intra_pred_mode_c >= 6 &&
1319 lc->pu.intra_pred_mode_c <= 14) {
1320 scan_idx_c = SCAN_VERT;
1321 } else if (lc->pu.intra_pred_mode_c >= 22 &&
1322 lc->pu.intra_pred_mode_c <= 30) {
1323 scan_idx_c = SCAN_HORIZ;
1328 hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
1329 if (log2_trafo_size > 2) {
1331 hls_residual_coding(s, x0, y0, log2_trafo_size - 1, scan_idx_c, 1);
1333 hls_residual_coding(s, x0, y0, log2_trafo_size - 1, scan_idx_c, 2);
1334 } else if (blk_idx == 3) {
1336 hls_residual_coding(s, xBase, yBase, log2_trafo_size, scan_idx_c, 1);
1338 hls_residual_coding(s, xBase, yBase, log2_trafo_size, scan_idx_c, 2);
1344 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1346 int cb_size = 1 << log2_cb_size;
1347 int log2_min_pu_size = s->sps->log2_min_pu_size;
1349 int min_pu_width = s->sps->min_pu_width;
1350 int x_end = FFMIN(x0 + cb_size, s->sps->width);
1351 int y_end = FFMIN(y0 + cb_size, s->sps->height);
1354 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1355 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1356 s->is_pcm[i + j * min_pu_width] = 2;
1359 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1360 int xBase, int yBase, int cb_xBase, int cb_yBase,
1361 int log2_cb_size, int log2_trafo_size,
1362 int trafo_depth, int blk_idx,
1363 int cbf_cb, int cbf_cr)
1365 HEVCLocalContext *lc = &s->HEVClc;
1366 uint8_t split_transform_flag;
1369 if (lc->cu.intra_split_flag) {
1370 if (trafo_depth == 1)
1371 lc->tu.cur_intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1373 lc->tu.cur_intra_pred_mode = lc->pu.intra_pred_mode[0];
1376 if (log2_trafo_size <= s->sps->log2_max_trafo_size &&
1377 log2_trafo_size > s->sps->log2_min_tb_size &&
1378 trafo_depth < lc->cu.max_trafo_depth &&
1379 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1380 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1382 int inter_split = s->sps->max_transform_hierarchy_depth_inter == 0 &&
1383 lc->cu.pred_mode == MODE_INTER &&
1384 lc->cu.part_mode != PART_2Nx2N &&
1387 split_transform_flag = log2_trafo_size > s->sps->log2_max_trafo_size ||
1388 (lc->cu.intra_split_flag && trafo_depth == 0) ||
1392 if (log2_trafo_size > 2 && (trafo_depth == 0 || cbf_cb))
1393 cbf_cb = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1394 else if (log2_trafo_size > 2 || trafo_depth == 0)
1396 if (log2_trafo_size > 2 && (trafo_depth == 0 || cbf_cr))
1397 cbf_cr = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1398 else if (log2_trafo_size > 2 || trafo_depth == 0)
1401 if (split_transform_flag) {
1402 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1403 const int x1 = x0 + trafo_size_split;
1404 const int y1 = y0 + trafo_size_split;
1406 #define SUBDIVIDE(x, y, idx) \
1408 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1409 log2_trafo_size - 1, trafo_depth + 1, idx, \
1415 SUBDIVIDE(x0, y0, 0);
1416 SUBDIVIDE(x1, y0, 1);
1417 SUBDIVIDE(x0, y1, 2);
1418 SUBDIVIDE(x1, y1, 3);
1422 int min_tu_size = 1 << s->sps->log2_min_tb_size;
1423 int log2_min_tu_size = s->sps->log2_min_tb_size;
1424 int min_tu_width = s->sps->min_tb_width;
1427 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1429 cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1431 ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1432 log2_cb_size, log2_trafo_size,
1433 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1436 // TODO: store cbf_luma somewhere else
1439 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1440 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1441 int x_tu = (x0 + j) >> log2_min_tu_size;
1442 int y_tu = (y0 + i) >> log2_min_tu_size;
1443 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1446 if (!s->sh.disable_deblocking_filter_flag) {
1447 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1448 if (s->pps->transquant_bypass_enable_flag &&
1449 lc->cu.cu_transquant_bypass_flag)
1450 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1456 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1458 //TODO: non-4:2:0 support
1459 HEVCLocalContext *lc = &s->HEVClc;
1461 int cb_size = 1 << log2_cb_size;
1462 int stride0 = s->frame->linesize[0];
1463 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->sps->pixel_shift)];
1464 int stride1 = s->frame->linesize[1];
1465 uint8_t *dst1 = &s->frame->data[1][(y0 >> s->sps->vshift[1]) * stride1 + ((x0 >> s->sps->hshift[1]) << s->sps->pixel_shift)];
1466 int stride2 = s->frame->linesize[2];
1467 uint8_t *dst2 = &s->frame->data[2][(y0 >> s->sps->vshift[2]) * stride2 + ((x0 >> s->sps->hshift[2]) << s->sps->pixel_shift)];
1469 int length = cb_size * cb_size * s->sps->pcm.bit_depth + ((cb_size * cb_size) >> 1) * s->sps->pcm.bit_depth_chroma;
1470 const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1473 if (!s->sh.disable_deblocking_filter_flag)
1474 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1476 ret = init_get_bits(&gb, pcm, length);
1480 s->hevcdsp.put_pcm(dst0, stride0, cb_size, &gb, s->sps->pcm.bit_depth);
1481 s->hevcdsp.put_pcm(dst1, stride1, cb_size / 2, &gb, s->sps->pcm.bit_depth_chroma);
1482 s->hevcdsp.put_pcm(dst2, stride2, cb_size / 2, &gb, s->sps->pcm.bit_depth_chroma);
1486 static void hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1488 HEVCLocalContext *lc = &s->HEVClc;
1489 int x = ff_hevc_abs_mvd_greater0_flag_decode(s);
1490 int y = ff_hevc_abs_mvd_greater0_flag_decode(s);
1493 x += ff_hevc_abs_mvd_greater1_flag_decode(s);
1495 y += ff_hevc_abs_mvd_greater1_flag_decode(s);
1498 case 2: lc->pu.mvd.x = ff_hevc_mvd_decode(s); break;
1499 case 1: lc->pu.mvd.x = ff_hevc_mvd_sign_flag_decode(s); break;
1500 case 0: lc->pu.mvd.x = 0; break;
1504 case 2: lc->pu.mvd.y = ff_hevc_mvd_decode(s); break;
1505 case 1: lc->pu.mvd.y = ff_hevc_mvd_sign_flag_decode(s); break;
1506 case 0: lc->pu.mvd.y = 0; break;
1511 * 8.5.3.2.2.1 Luma sample interpolation process
1513 * @param s HEVC decoding context
1514 * @param dst target buffer for block data at block position
1515 * @param dststride stride of the dst buffer
1516 * @param ref reference picture buffer at origin (0, 0)
1517 * @param mv motion vector (relative to block position) to get pixel data from
1518 * @param x_off horizontal position of block from origin (0, 0)
1519 * @param y_off vertical position of block from origin (0, 0)
1520 * @param block_w width of block
1521 * @param block_h height of block
1523 static void luma_mc(HEVCContext *s, int16_t *dst, ptrdiff_t dststride,
1524 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1525 int block_w, int block_h)
1527 HEVCLocalContext *lc = &s->HEVClc;
1528 uint8_t *src = ref->data[0];
1529 ptrdiff_t srcstride = ref->linesize[0];
1530 int pic_width = s->sps->width;
1531 int pic_height = s->sps->height;
1535 int extra_left = ff_hevc_qpel_extra_before[mx];
1536 int extra_top = ff_hevc_qpel_extra_before[my];
1538 x_off += mv->x >> 2;
1539 y_off += mv->y >> 2;
1540 src += y_off * srcstride + (x_off << s->sps->pixel_shift);
1542 if (x_off < extra_left || y_off < extra_top ||
1543 x_off >= pic_width - block_w - ff_hevc_qpel_extra_after[mx] ||
1544 y_off >= pic_height - block_h - ff_hevc_qpel_extra_after[my]) {
1545 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1546 int offset = extra_top * srcstride + (extra_left << s->sps->pixel_shift);
1547 int buf_offset = extra_top *
1548 edge_emu_stride + (extra_left << s->sps->pixel_shift);
1550 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1551 edge_emu_stride, srcstride,
1552 block_w + ff_hevc_qpel_extra[mx],
1553 block_h + ff_hevc_qpel_extra[my],
1554 x_off - extra_left, y_off - extra_top,
1555 pic_width, pic_height);
1556 src = lc->edge_emu_buffer + buf_offset;
1557 srcstride = edge_emu_stride;
1559 s->hevcdsp.put_hevc_qpel[my][mx](dst, dststride, src, srcstride, block_w,
1560 block_h, lc->mc_buffer);
1564 * 8.5.3.2.2.2 Chroma sample interpolation process
1566 * @param s HEVC decoding context
1567 * @param dst1 target buffer for block data at block position (U plane)
1568 * @param dst2 target buffer for block data at block position (V plane)
1569 * @param dststride stride of the dst1 and dst2 buffers
1570 * @param ref reference picture buffer at origin (0, 0)
1571 * @param mv motion vector (relative to block position) to get pixel data from
1572 * @param x_off horizontal position of block from origin (0, 0)
1573 * @param y_off vertical position of block from origin (0, 0)
1574 * @param block_w width of block
1575 * @param block_h height of block
1577 static void chroma_mc(HEVCContext *s, int16_t *dst1, int16_t *dst2,
1578 ptrdiff_t dststride, AVFrame *ref, const Mv *mv,
1579 int x_off, int y_off, int block_w, int block_h)
1581 HEVCLocalContext *lc = &s->HEVClc;
1582 uint8_t *src1 = ref->data[1];
1583 uint8_t *src2 = ref->data[2];
1584 ptrdiff_t src1stride = ref->linesize[1];
1585 ptrdiff_t src2stride = ref->linesize[2];
1586 int pic_width = s->sps->width >> 1;
1587 int pic_height = s->sps->height >> 1;
1592 x_off += mv->x >> 3;
1593 y_off += mv->y >> 3;
1594 src1 += y_off * src1stride + (x_off << s->sps->pixel_shift);
1595 src2 += y_off * src2stride + (x_off << s->sps->pixel_shift);
1597 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1598 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1599 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1600 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1601 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->sps->pixel_shift));
1602 int buf_offset1 = EPEL_EXTRA_BEFORE *
1603 (edge_emu_stride + (1 << s->sps->pixel_shift));
1604 int offset2 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->sps->pixel_shift));
1605 int buf_offset2 = EPEL_EXTRA_BEFORE *
1606 (edge_emu_stride + (1 << s->sps->pixel_shift));
1608 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1609 edge_emu_stride, src1stride,
1610 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1611 x_off - EPEL_EXTRA_BEFORE,
1612 y_off - EPEL_EXTRA_BEFORE,
1613 pic_width, pic_height);
1615 src1 = lc->edge_emu_buffer + buf_offset1;
1616 src1stride = edge_emu_stride;
1617 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst1, dststride, src1, src1stride,
1618 block_w, block_h, mx, my, lc->mc_buffer);
1620 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src2 - offset2,
1621 edge_emu_stride, src2stride,
1622 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1623 x_off - EPEL_EXTRA_BEFORE,
1624 y_off - EPEL_EXTRA_BEFORE,
1625 pic_width, pic_height);
1626 src2 = lc->edge_emu_buffer + buf_offset2;
1627 src2stride = edge_emu_stride;
1629 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst2, dststride, src2, src2stride,
1630 block_w, block_h, mx, my,
1633 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst1, dststride, src1, src1stride,
1634 block_w, block_h, mx, my,
1636 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst2, dststride, src2, src2stride,
1637 block_w, block_h, mx, my,
1642 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1643 const Mv *mv, int y0, int height)
1645 int y = (mv->y >> 2) + y0 + height + 9;
1646 ff_thread_await_progress(&ref->tf, y, 0);
1649 static void hevc_luma_mv_mpv_mode(HEVCContext *s, int x0, int y0, int nPbW,
1650 int nPbH, int log2_cb_size, int part_idx,
1651 int merge_idx, MvField *mv)
1653 HEVCLocalContext *lc = &s->HEVClc;
1654 enum InterPredIdc inter_pred_idc = PRED_L0;
1657 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1658 if (s->sh.slice_type == B_SLICE)
1659 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1661 if (inter_pred_idc != PRED_L1) {
1662 if (s->sh.nb_refs[L0])
1663 mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1665 mv->pred_flag[0] = 1;
1666 hls_mvd_coding(s, x0, y0, 0);
1667 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1668 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1669 part_idx, merge_idx, mv, mvp_flag, 0);
1670 mv->mv[0].x += lc->pu.mvd.x;
1671 mv->mv[0].y += lc->pu.mvd.y;
1674 if (inter_pred_idc != PRED_L0) {
1675 if (s->sh.nb_refs[L1])
1676 mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1678 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1679 AV_ZERO32(&lc->pu.mvd);
1681 hls_mvd_coding(s, x0, y0, 1);
1684 mv->pred_flag[1] = 1;
1685 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1686 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1687 part_idx, merge_idx, mv, mvp_flag, 1);
1688 mv->mv[1].x += lc->pu.mvd.x;
1689 mv->mv[1].y += lc->pu.mvd.y;
1693 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1695 int log2_cb_size, int partIdx)
1697 #define POS(c_idx, x, y) \
1698 &s->frame->data[c_idx][((y) >> s->sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1699 (((x) >> s->sps->hshift[c_idx]) << s->sps->pixel_shift)]
1700 HEVCLocalContext *lc = &s->HEVClc;
1702 struct MvField current_mv = {{{ 0 }}};
1704 int min_pu_width = s->sps->min_pu_width;
1706 MvField *tab_mvf = s->ref->tab_mvf;
1707 RefPicList *refPicList = s->ref->refPicList;
1708 HEVCFrame *ref0, *ref1;
1710 int tmpstride = MAX_PB_SIZE;
1712 uint8_t *dst0 = POS(0, x0, y0);
1713 uint8_t *dst1 = POS(1, x0, y0);
1714 uint8_t *dst2 = POS(2, x0, y0);
1715 int log2_min_cb_size = s->sps->log2_min_cb_size;
1716 int min_cb_width = s->sps->min_cb_width;
1717 int x_cb = x0 >> log2_min_cb_size;
1718 int y_cb = y0 >> log2_min_cb_size;
1722 int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1725 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1727 if (skip_flag || lc->pu.merge_flag) {
1728 if (s->sh.max_num_merge_cand > 1)
1729 merge_idx = ff_hevc_merge_idx_decode(s);
1733 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1734 partIdx, merge_idx, ¤t_mv);
1736 hevc_luma_mv_mpv_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1737 partIdx, merge_idx, ¤t_mv);
1740 x_pu = x0 >> s->sps->log2_min_pu_size;
1741 y_pu = y0 >> s->sps->log2_min_pu_size;
1743 for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1744 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1745 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1747 if (current_mv.pred_flag[0]) {
1748 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1751 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1753 if (current_mv.pred_flag[1]) {
1754 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1757 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1760 if (current_mv.pred_flag[0] && !current_mv.pred_flag[1]) {
1761 DECLARE_ALIGNED(16, int16_t, tmp[MAX_PB_SIZE * MAX_PB_SIZE]);
1762 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1764 luma_mc(s, tmp, tmpstride, ref0->frame,
1765 ¤t_mv.mv[0], x0, y0, nPbW, nPbH);
1767 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1768 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1769 s->hevcdsp.weighted_pred(s->sh.luma_log2_weight_denom,
1770 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1771 s->sh.luma_offset_l0[current_mv.ref_idx[0]],
1772 dst0, s->frame->linesize[0], tmp,
1773 tmpstride, nPbW, nPbH);
1775 s->hevcdsp.put_unweighted_pred(dst0, s->frame->linesize[0], tmp, tmpstride, nPbW, nPbH);
1777 chroma_mc(s, tmp, tmp2, tmpstride, ref0->frame,
1778 ¤t_mv.mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1780 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1781 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1782 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1783 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0],
1784 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0],
1785 dst1, s->frame->linesize[1], tmp, tmpstride,
1786 nPbW / 2, nPbH / 2);
1787 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1788 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1],
1789 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1],
1790 dst2, s->frame->linesize[2], tmp2, tmpstride,
1791 nPbW / 2, nPbH / 2);
1793 s->hevcdsp.put_unweighted_pred(dst1, s->frame->linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1794 s->hevcdsp.put_unweighted_pred(dst2, s->frame->linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1796 } else if (!current_mv.pred_flag[0] && current_mv.pred_flag[1]) {
1797 DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1798 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1800 luma_mc(s, tmp, tmpstride, ref1->frame,
1801 ¤t_mv.mv[1], x0, y0, nPbW, nPbH);
1803 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1804 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1805 s->hevcdsp.weighted_pred(s->sh.luma_log2_weight_denom,
1806 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1807 s->sh.luma_offset_l1[current_mv.ref_idx[1]],
1808 dst0, s->frame->linesize[0], tmp, tmpstride,
1811 s->hevcdsp.put_unweighted_pred(dst0, s->frame->linesize[0], tmp, tmpstride, nPbW, nPbH);
1814 chroma_mc(s, tmp, tmp2, tmpstride, ref1->frame,
1815 ¤t_mv.mv[1], x0/2, y0/2, nPbW/2, nPbH/2);
1817 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1818 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1819 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1820 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0],
1821 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0],
1822 dst1, s->frame->linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1823 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1824 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1],
1825 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1],
1826 dst2, s->frame->linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1828 s->hevcdsp.put_unweighted_pred(dst1, s->frame->linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1829 s->hevcdsp.put_unweighted_pred(dst2, s->frame->linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1831 } else if (current_mv.pred_flag[0] && current_mv.pred_flag[1]) {
1832 DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1833 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1834 DECLARE_ALIGNED(16, int16_t, tmp3[MAX_PB_SIZE * MAX_PB_SIZE]);
1835 DECLARE_ALIGNED(16, int16_t, tmp4[MAX_PB_SIZE * MAX_PB_SIZE]);
1837 luma_mc(s, tmp, tmpstride, ref0->frame,
1838 ¤t_mv.mv[0], x0, y0, nPbW, nPbH);
1839 luma_mc(s, tmp2, tmpstride, ref1->frame,
1840 ¤t_mv.mv[1], x0, y0, nPbW, nPbH);
1842 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1843 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1844 s->hevcdsp.weighted_pred_avg(s->sh.luma_log2_weight_denom,
1845 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1846 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1847 s->sh.luma_offset_l0[current_mv.ref_idx[0]],
1848 s->sh.luma_offset_l1[current_mv.ref_idx[1]],
1849 dst0, s->frame->linesize[0],
1850 tmp, tmp2, tmpstride, nPbW, nPbH);
1852 s->hevcdsp.put_weighted_pred_avg(dst0, s->frame->linesize[0],
1853 tmp, tmp2, tmpstride, nPbW, nPbH);
1856 chroma_mc(s, tmp, tmp2, tmpstride, ref0->frame,
1857 ¤t_mv.mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1858 chroma_mc(s, tmp3, tmp4, tmpstride, ref1->frame,
1859 ¤t_mv.mv[1], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1861 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1862 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1863 s->hevcdsp.weighted_pred_avg(s->sh.chroma_log2_weight_denom,
1864 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0],
1865 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0],
1866 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0],
1867 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0],
1868 dst1, s->frame->linesize[1], tmp, tmp3,
1869 tmpstride, nPbW / 2, nPbH / 2);
1870 s->hevcdsp.weighted_pred_avg(s->sh.chroma_log2_weight_denom,
1871 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1],
1872 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1],
1873 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1],
1874 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1],
1875 dst2, s->frame->linesize[2], tmp2, tmp4,
1876 tmpstride, nPbW / 2, nPbH / 2);
1878 s->hevcdsp.put_weighted_pred_avg(dst1, s->frame->linesize[1], tmp, tmp3, tmpstride, nPbW/2, nPbH/2);
1879 s->hevcdsp.put_weighted_pred_avg(dst2, s->frame->linesize[2], tmp2, tmp4, tmpstride, nPbW/2, nPbH/2);
1887 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1888 int prev_intra_luma_pred_flag)
1890 HEVCLocalContext *lc = &s->HEVClc;
1891 int x_pu = x0 >> s->sps->log2_min_pu_size;
1892 int y_pu = y0 >> s->sps->log2_min_pu_size;
1893 int min_pu_width = s->sps->min_pu_width;
1894 int size_in_pus = pu_size >> s->sps->log2_min_pu_size;
1895 int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1);
1896 int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1);
1898 int cand_up = (lc->ctb_up_flag || y0b) ?
1899 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1900 int cand_left = (lc->ctb_left_flag || x0b) ?
1901 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1903 int y_ctb = (y0 >> (s->sps->log2_ctb_size)) << (s->sps->log2_ctb_size);
1905 MvField *tab_mvf = s->ref->tab_mvf;
1906 int intra_pred_mode;
1910 // intra_pred_mode prediction does not cross vertical CTB boundaries
1911 if ((y0 - 1) < y_ctb)
1914 if (cand_left == cand_up) {
1915 if (cand_left < 2) {
1916 candidate[0] = INTRA_PLANAR;
1917 candidate[1] = INTRA_DC;
1918 candidate[2] = INTRA_ANGULAR_26;
1920 candidate[0] = cand_left;
1921 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1922 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1925 candidate[0] = cand_left;
1926 candidate[1] = cand_up;
1927 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1928 candidate[2] = INTRA_PLANAR;
1929 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1930 candidate[2] = INTRA_DC;
1932 candidate[2] = INTRA_ANGULAR_26;
1936 if (prev_intra_luma_pred_flag) {
1937 intra_pred_mode = candidate[lc->pu.mpm_idx];
1939 if (candidate[0] > candidate[1])
1940 FFSWAP(uint8_t, candidate[0], candidate[1]);
1941 if (candidate[0] > candidate[2])
1942 FFSWAP(uint8_t, candidate[0], candidate[2]);
1943 if (candidate[1] > candidate[2])
1944 FFSWAP(uint8_t, candidate[1], candidate[2]);
1946 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1947 for (i = 0; i < 3; i++)
1948 if (intra_pred_mode >= candidate[i])
1952 /* write the intra prediction units into the mv array */
1955 for (i = 0; i < size_in_pus; i++) {
1956 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1957 intra_pred_mode, size_in_pus);
1959 for (j = 0; j < size_in_pus; j++) {
1960 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].is_intra = 1;
1961 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[0] = 0;
1962 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[1] = 0;
1963 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[0] = 0;
1964 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[1] = 0;
1965 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].x = 0;
1966 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].y = 0;
1967 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].x = 0;
1968 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].y = 0;
1972 return intra_pred_mode;
1975 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1976 int log2_cb_size, int ct_depth)
1978 int length = (1 << log2_cb_size) >> s->sps->log2_min_cb_size;
1979 int x_cb = x0 >> s->sps->log2_min_cb_size;
1980 int y_cb = y0 >> s->sps->log2_min_cb_size;
1983 for (y = 0; y < length; y++)
1984 memset(&s->tab_ct_depth[(y_cb + y) * s->sps->min_cb_width + x_cb],
1988 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1991 HEVCLocalContext *lc = &s->HEVClc;
1992 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1993 uint8_t prev_intra_luma_pred_flag[4];
1994 int split = lc->cu.part_mode == PART_NxN;
1995 int pb_size = (1 << log2_cb_size) >> split;
1996 int side = split + 1;
2000 for (i = 0; i < side; i++)
2001 for (j = 0; j < side; j++)
2002 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
2004 for (i = 0; i < side; i++) {
2005 for (j = 0; j < side; j++) {
2006 if (prev_intra_luma_pred_flag[2 * i + j])
2007 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
2009 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
2011 lc->pu.intra_pred_mode[2 * i + j] =
2012 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
2013 prev_intra_luma_pred_flag[2 * i + j]);
2017 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
2018 if (chroma_mode != 4) {
2019 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
2020 lc->pu.intra_pred_mode_c = 34;
2022 lc->pu.intra_pred_mode_c = intra_chroma_table[chroma_mode];
2024 lc->pu.intra_pred_mode_c = lc->pu.intra_pred_mode[0];
2028 static void intra_prediction_unit_default_value(HEVCContext *s,
2032 HEVCLocalContext *lc = &s->HEVClc;
2033 int pb_size = 1 << log2_cb_size;
2034 int size_in_pus = pb_size >> s->sps->log2_min_pu_size;
2035 int min_pu_width = s->sps->min_pu_width;
2036 MvField *tab_mvf = s->ref->tab_mvf;
2037 int x_pu = x0 >> s->sps->log2_min_pu_size;
2038 int y_pu = y0 >> s->sps->log2_min_pu_size;
2041 if (size_in_pus == 0)
2043 for (j = 0; j < size_in_pus; j++) {
2044 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
2045 for (k = 0; k < size_in_pus; k++)
2046 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].is_intra = lc->cu.pred_mode == MODE_INTRA;
2050 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
2052 int cb_size = 1 << log2_cb_size;
2053 HEVCLocalContext *lc = &s->HEVClc;
2054 int log2_min_cb_size = s->sps->log2_min_cb_size;
2055 int length = cb_size >> log2_min_cb_size;
2056 int min_cb_width = s->sps->min_cb_width;
2057 int x_cb = x0 >> log2_min_cb_size;
2058 int y_cb = y0 >> log2_min_cb_size;
2063 lc->cu.pred_mode = MODE_INTRA;
2064 lc->cu.part_mode = PART_2Nx2N;
2065 lc->cu.intra_split_flag = 0;
2067 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
2068 for (x = 0; x < 4; x++)
2069 lc->pu.intra_pred_mode[x] = 1;
2070 if (s->pps->transquant_bypass_enable_flag) {
2071 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
2072 if (lc->cu.cu_transquant_bypass_flag)
2073 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2075 lc->cu.cu_transquant_bypass_flag = 0;
2077 if (s->sh.slice_type != I_SLICE) {
2078 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
2080 x = y_cb * min_cb_width + x_cb;
2081 for (y = 0; y < length; y++) {
2082 memset(&s->skip_flag[x], skip_flag, length);
2085 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2088 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2089 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0);
2090 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2092 if (!s->sh.disable_deblocking_filter_flag)
2093 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2097 if (s->sh.slice_type != I_SLICE)
2098 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2099 if (lc->cu.pred_mode != MODE_INTRA ||
2100 log2_cb_size == s->sps->log2_min_cb_size) {
2101 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2102 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2103 lc->cu.pred_mode == MODE_INTRA;
2106 if (lc->cu.pred_mode == MODE_INTRA) {
2107 if (lc->cu.part_mode == PART_2Nx2N && s->sps->pcm_enabled_flag &&
2108 log2_cb_size >= s->sps->pcm.log2_min_pcm_cb_size &&
2109 log2_cb_size <= s->sps->pcm.log2_max_pcm_cb_size) {
2110 pcm_flag = ff_hevc_pcm_flag_decode(s);
2113 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2114 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2115 if (s->sps->pcm.loop_filter_disable_flag)
2116 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2121 intra_prediction_unit(s, x0, y0, log2_cb_size);
2124 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2125 switch (lc->cu.part_mode) {
2127 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0);
2130 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0);
2131 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1);
2134 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0);
2135 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1);
2138 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0);
2139 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1);
2142 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0);
2143 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1);
2146 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0);
2147 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1);
2150 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0);
2151 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1);
2154 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0);
2155 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1);
2156 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2);
2157 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3);
2163 int rqt_root_cbf = 1;
2165 if (lc->cu.pred_mode != MODE_INTRA &&
2166 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2167 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2170 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2171 s->sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2172 s->sps->max_transform_hierarchy_depth_inter;
2173 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2175 log2_cb_size, 0, 0, 0, 0);
2179 if (!s->sh.disable_deblocking_filter_flag)
2180 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2185 if (s->pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2186 ff_hevc_set_qPy(s, x0, y0, x0, y0, log2_cb_size);
2188 x = y_cb * min_cb_width + x_cb;
2189 for (y = 0; y < length; y++) {
2190 memset(&s->qp_y_tab[x], lc->qp_y, length);
2194 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct.depth);
2199 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2200 int log2_cb_size, int cb_depth)
2202 HEVCLocalContext *lc = &s->HEVClc;
2203 const int cb_size = 1 << log2_cb_size;
2206 lc->ct.depth = cb_depth;
2207 if (x0 + cb_size <= s->sps->width &&
2208 y0 + cb_size <= s->sps->height &&
2209 log2_cb_size > s->sps->log2_min_cb_size) {
2210 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2212 split_cu = (log2_cb_size > s->sps->log2_min_cb_size);
2214 if (s->pps->cu_qp_delta_enabled_flag &&
2215 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth) {
2216 lc->tu.is_cu_qp_delta_coded = 0;
2217 lc->tu.cu_qp_delta = 0;
2221 const int cb_size_split = cb_size >> 1;
2222 const int x1 = x0 + cb_size_split;
2223 const int y1 = y0 + cb_size_split;
2228 #define SUBDIVIDE(x, y) \
2230 if (x < s->sps->width && y < s->sps->height) { \
2231 int ret = hls_coding_quadtree(s, x, y, log2_cb_size, cb_depth);\
2242 int ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2250 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2253 HEVCLocalContext *lc = &s->HEVClc;
2254 int ctb_size = 1 << s->sps->log2_ctb_size;
2255 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2256 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2258 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2260 if (s->pps->entropy_coding_sync_enabled_flag) {
2261 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2262 lc->first_qp_group = 1;
2263 lc->end_of_tiles_x = s->sps->width;
2264 } else if (s->pps->tiles_enabled_flag) {
2265 if (ctb_addr_ts && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1]) {
2266 int idxX = s->pps->col_idxX[x_ctb >> s->sps->log2_ctb_size];
2267 lc->start_of_tiles_x = x_ctb;
2268 lc->end_of_tiles_x = x_ctb + (s->pps->column_width[idxX] << s->sps->log2_ctb_size);
2269 lc->first_qp_group = 1;
2272 lc->end_of_tiles_x = s->sps->width;
2275 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->sps->height);
2277 lc->boundary_flags = 0;
2278 if (s->pps->tiles_enabled_flag) {
2279 if (x_ctb > 0 && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs - 1]])
2280 lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2281 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2282 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2283 if (y_ctb > 0 && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs - s->sps->ctb_width]])
2284 lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2285 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->sps->ctb_width])
2286 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2288 if (!ctb_addr_in_slice > 0)
2289 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2290 if (ctb_addr_in_slice < s->sps->ctb_width)
2291 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2294 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2295 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2296 lc->ctb_up_right_flag = ((y_ctb > 0) && (ctb_addr_in_slice+1 >= s->sps->ctb_width) && (s->pps->tile_id[ctb_addr_ts] == s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs+1 - s->sps->ctb_width]]));
2297 lc->ctb_up_left_flag = ((x_ctb > 0) && (y_ctb > 0) && (ctb_addr_in_slice-1 >= s->sps->ctb_width) && (s->pps->tile_id[ctb_addr_ts] == s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs-1 - s->sps->ctb_width]]));
2300 static int hls_slice_data(HEVCContext *s)
2302 int ctb_size = 1 << s->sps->log2_ctb_size;
2306 int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2309 while (more_data && ctb_addr_ts < s->sps->ctb_size) {
2310 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2312 x_ctb = (ctb_addr_rs % ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2313 y_ctb = (ctb_addr_rs / ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2314 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2316 ff_hevc_cabac_init(s, ctb_addr_ts);
2318 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2320 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2321 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2322 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2324 ret = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2327 more_data = !ff_hevc_end_of_slice_flag_decode(s);
2330 ff_hevc_save_states(s, ctb_addr_ts);
2331 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2334 if (x_ctb + ctb_size >= s->sps->width &&
2335 y_ctb + ctb_size >= s->sps->height)
2336 ff_hevc_hls_filter(s, x_ctb, y_ctb);
2342 * @return AVERROR_INVALIDDATA if the packet is not a valid NAL unit,
2343 * 0 if the unit should be skipped, 1 otherwise
2345 static int hls_nal_unit(HEVCContext *s)
2347 GetBitContext *gb = &s->HEVClc.gb;
2350 if (get_bits1(gb) != 0)
2351 return AVERROR_INVALIDDATA;
2353 s->nal_unit_type = get_bits(gb, 6);
2355 nuh_layer_id = get_bits(gb, 6);
2356 s->temporal_id = get_bits(gb, 3) - 1;
2357 if (s->temporal_id < 0)
2358 return AVERROR_INVALIDDATA;
2360 av_log(s->avctx, AV_LOG_DEBUG,
2361 "nal_unit_type: %d, nuh_layer_id: %dtemporal_id: %d\n",
2362 s->nal_unit_type, nuh_layer_id, s->temporal_id);
2364 return nuh_layer_id == 0;
2367 static void restore_tqb_pixels(HEVCContext *s)
2369 int min_pu_size = 1 << s->sps->log2_min_pu_size;
2372 for (c_idx = 0; c_idx < 3; c_idx++) {
2373 ptrdiff_t stride = s->frame->linesize[c_idx];
2374 int hshift = s->sps->hshift[c_idx];
2375 int vshift = s->sps->vshift[c_idx];
2376 for (y = 0; y < s->sps->min_pu_height; y++) {
2377 for (x = 0; x < s->sps->min_pu_width; x++) {
2378 if (s->is_pcm[y * s->sps->min_pu_width + x]) {
2380 int len = min_pu_size >> hshift;
2381 uint8_t *src = &s->frame->data[c_idx][((y << s->sps->log2_min_pu_size) >> vshift) * stride + (((x << s->sps->log2_min_pu_size) >> hshift) << s->sps->pixel_shift)];
2382 uint8_t *dst = &s->sao_frame->data[c_idx][((y << s->sps->log2_min_pu_size) >> vshift) * stride + (((x << s->sps->log2_min_pu_size) >> hshift) << s->sps->pixel_shift)];
2383 for (n = 0; n < (min_pu_size >> vshift); n++) {
2384 memcpy(dst, src, len);
2394 static int set_side_data(HEVCContext *s)
2396 AVFrame *out = s->ref->frame;
2398 if (s->sei_frame_packing_present &&
2399 s->frame_packing_arrangement_type >= 3 &&
2400 s->frame_packing_arrangement_type <= 5 &&
2401 s->content_interpretation_type > 0 &&
2402 s->content_interpretation_type < 3) {
2403 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2405 return AVERROR(ENOMEM);
2407 switch (s->frame_packing_arrangement_type) {
2409 if (s->quincunx_subsampling)
2410 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2412 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2415 stereo->type = AV_STEREO3D_TOPBOTTOM;
2418 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2422 if (s->content_interpretation_type == 2)
2423 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2426 if (s->sei_display_orientation_present &&
2427 (s->sei_anticlockwise_rotation || s->sei_hflip || s->sei_vflip)) {
2428 double angle = s->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
2429 AVFrameSideData *rotation = av_frame_new_side_data(out,
2430 AV_FRAME_DATA_DISPLAYMATRIX,
2431 sizeof(int32_t) * 9);
2433 return AVERROR(ENOMEM);
2435 av_display_rotation_set((int32_t *)rotation->data, angle);
2436 av_display_matrix_flip((int32_t *)rotation->data,
2437 s->sei_hflip, s->sei_vflip);
2443 static int hevc_frame_start(HEVCContext *s)
2445 HEVCLocalContext *lc = &s->HEVClc;
2448 memset(s->horizontal_bs, 0, 2 * s->bs_width * (s->bs_height + 1));
2449 memset(s->vertical_bs, 0, 2 * s->bs_width * (s->bs_height + 1));
2450 memset(s->cbf_luma, 0, s->sps->min_tb_width * s->sps->min_tb_height);
2451 memset(s->is_pcm, 0, s->sps->min_pu_width * s->sps->min_pu_height);
2453 lc->start_of_tiles_x = 0;
2455 s->first_nal_type = s->nal_unit_type;
2457 if (s->pps->tiles_enabled_flag)
2458 lc->end_of_tiles_x = s->pps->column_width[0] << s->sps->log2_ctb_size;
2460 ret = ff_hevc_set_new_ref(s, s->sps->sao_enabled ? &s->sao_frame : &s->frame,
2465 ret = ff_hevc_frame_rps(s);
2467 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2471 s->ref->frame->key_frame = IS_IRAP(s);
2473 ret = set_side_data(s);
2477 av_frame_unref(s->output_frame);
2478 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2482 ff_thread_finish_setup(s->avctx);
2488 ff_hevc_unref_frame(s, s->ref, ~0);
2493 static int decode_nal_unit(HEVCContext *s, const HEVCNAL *nal)
2495 HEVCLocalContext *lc = &s->HEVClc;
2496 GetBitContext *gb = &lc->gb;
2497 int ctb_addr_ts, ret;
2499 ret = init_get_bits8(gb, nal->data, nal->size);
2503 ret = hls_nal_unit(s);
2505 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit %d, skipping.\n",
2511 switch (s->nal_unit_type) {
2513 ret = ff_hevc_decode_nal_vps(s);
2518 ret = ff_hevc_decode_nal_sps(s);
2523 ret = ff_hevc_decode_nal_pps(s);
2527 case NAL_SEI_PREFIX:
2528 case NAL_SEI_SUFFIX:
2529 ret = ff_hevc_decode_nal_sei(s);
2540 case NAL_BLA_W_RADL:
2542 case NAL_IDR_W_RADL:
2549 ret = hls_slice_header(s);
2553 if (s->max_ra == INT_MAX) {
2554 if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
2558 s->max_ra = INT_MIN;
2562 if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
2563 s->poc <= s->max_ra) {
2567 if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
2568 s->max_ra = INT_MIN;
2571 if (s->sh.first_slice_in_pic_flag) {
2572 ret = hevc_frame_start(s);
2575 } else if (!s->ref) {
2576 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2580 if (s->nal_unit_type != s->first_nal_type) {
2581 av_log(s->avctx, AV_LOG_ERROR,
2582 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2583 s->first_nal_type, s->nal_unit_type);
2584 return AVERROR_INVALIDDATA;
2587 if (!s->sh.dependent_slice_segment_flag &&
2588 s->sh.slice_type != I_SLICE) {
2589 ret = ff_hevc_slice_rpl(s);
2591 av_log(s->avctx, AV_LOG_WARNING,
2592 "Error constructing the reference lists for the current slice.\n");
2597 if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) {
2598 ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0);
2603 if (s->avctx->hwaccel) {
2604 ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size);
2608 ctb_addr_ts = hls_slice_data(s);
2609 if (ctb_addr_ts >= (s->sps->ctb_width * s->sps->ctb_height)) {
2611 if ((s->pps->transquant_bypass_enable_flag ||
2612 (s->sps->pcm.loop_filter_disable_flag && s->sps->pcm_enabled_flag)) &&
2613 s->sps->sao_enabled)
2614 restore_tqb_pixels(s);
2617 if (ctb_addr_ts < 0) {
2625 s->seq_decode = (s->seq_decode + 1) & 0xff;
2626 s->max_ra = INT_MAX;
2632 av_log(s->avctx, AV_LOG_INFO,
2633 "Skipping NAL unit %d\n", s->nal_unit_type);
2638 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2643 /* FIXME: This is adapted from ff_h264_decode_nal, avoiding duplication
2644 * between these functions would be nice. */
2645 static int extract_rbsp(const uint8_t *src, int length,
2651 #define STARTCODE_TEST \
2652 if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \
2653 if (src[i + 2] != 3) { \
2654 /* startcode, so we must be past the end */ \
2659 #if HAVE_FAST_UNALIGNED
2660 #define FIND_FIRST_ZERO \
2661 if (i > 0 && !src[i]) \
2666 for (i = 0; i + 1 < length; i += 9) {
2667 if (!((~AV_RN64A(src + i) &
2668 (AV_RN64A(src + i) - 0x0100010001000101ULL)) &
2669 0x8000800080008080ULL))
2676 for (i = 0; i + 1 < length; i += 5) {
2677 if (!((~AV_RN32A(src + i) &
2678 (AV_RN32A(src + i) - 0x01000101U)) &
2685 #endif /* HAVE_FAST_64BIT */
2687 for (i = 0; i + 1 < length; i += 2) {
2690 if (i > 0 && src[i - 1] == 0)
2694 #endif /* HAVE_FAST_UNALIGNED */
2696 if (i >= length - 1) { // no escaped 0
2698 nal->raw_data = src;
2700 nal->raw_size = length;
2704 av_fast_malloc(&nal->rbsp_buffer, &nal->rbsp_buffer_size,
2705 length + FF_INPUT_BUFFER_PADDING_SIZE);
2706 if (!nal->rbsp_buffer)
2707 return AVERROR(ENOMEM);
2709 dst = nal->rbsp_buffer;
2711 memcpy(dst, src, i);
2713 while (si + 2 < length) {
2714 // remove escapes (very rare 1:2^22)
2715 if (src[si + 2] > 3) {
2716 dst[di++] = src[si++];
2717 dst[di++] = src[si++];
2718 } else if (src[si] == 0 && src[si + 1] == 0) {
2719 if (src[si + 2] == 3) { // escape
2725 } else // next start code
2729 dst[di++] = src[si++];
2732 dst[di++] = src[si++];
2735 memset(dst + di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2739 nal->raw_data = src;
2744 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2746 int i, consumed, ret = 0;
2751 /* split the input packet into NAL units, so we know the upper bound on the
2752 * number of slices in the frame */
2754 while (length >= 4) {
2756 int extract_length = 0;
2760 for (i = 0; i < s->nal_length_size; i++)
2761 extract_length = (extract_length << 8) | buf[i];
2762 buf += s->nal_length_size;
2763 length -= s->nal_length_size;
2765 if (extract_length > length) {
2766 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit size.\n");
2767 ret = AVERROR_INVALIDDATA;
2776 if (buf[0] != 0 || buf[1] != 0 || buf[2] != 1) {
2777 ret = AVERROR_INVALIDDATA;
2783 extract_length = length;
2786 if (s->nals_allocated < s->nb_nals + 1) {
2787 int new_size = s->nals_allocated + 1;
2788 HEVCNAL *tmp = av_realloc_array(s->nals, new_size, sizeof(*tmp));
2790 ret = AVERROR(ENOMEM);
2794 memset(s->nals + s->nals_allocated, 0,
2795 (new_size - s->nals_allocated) * sizeof(*tmp));
2796 s->nals_allocated = new_size;
2798 nal = &s->nals[s->nb_nals++];
2800 consumed = extract_rbsp(buf, extract_length, nal);
2806 ret = init_get_bits8(&s->HEVClc.gb, nal->data, nal->size);
2811 if (s->nal_unit_type == NAL_EOB_NUT ||
2812 s->nal_unit_type == NAL_EOS_NUT)
2819 /* parse the NAL units */
2820 for (i = 0; i < s->nb_nals; i++) {
2821 ret = decode_nal_unit(s, &s->nals[i]);
2823 av_log(s->avctx, AV_LOG_WARNING,
2824 "Error parsing NAL unit #%d.\n", i);
2831 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2836 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2839 for (i = 0; i < 16; i++)
2840 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
2843 static int verify_md5(HEVCContext *s, AVFrame *frame)
2845 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
2850 return AVERROR(EINVAL);
2852 pixel_shift = desc->comp[0].depth_minus1 > 7;
2854 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
2857 /* the checksums are LE, so we have to byteswap for >8bpp formats
2860 if (pixel_shift && !s->checksum_buf) {
2861 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
2862 FFMAX3(frame->linesize[0], frame->linesize[1],
2863 frame->linesize[2]));
2864 if (!s->checksum_buf)
2865 return AVERROR(ENOMEM);
2869 for (i = 0; frame->data[i]; i++) {
2870 int width = s->avctx->coded_width;
2871 int height = s->avctx->coded_height;
2872 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
2873 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
2876 av_md5_init(s->md5_ctx);
2877 for (j = 0; j < h; j++) {
2878 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
2881 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
2882 (const uint16_t *) src, w);
2883 src = s->checksum_buf;
2886 av_md5_update(s->md5_ctx, src, w << pixel_shift);
2888 av_md5_final(s->md5_ctx, md5);
2890 if (!memcmp(md5, s->md5[i], 16)) {
2891 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
2892 print_md5(s->avctx, AV_LOG_DEBUG, md5);
2893 av_log (s->avctx, AV_LOG_DEBUG, "; ");
2895 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
2896 print_md5(s->avctx, AV_LOG_ERROR, md5);
2897 av_log (s->avctx, AV_LOG_ERROR, " != ");
2898 print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
2899 av_log (s->avctx, AV_LOG_ERROR, "\n");
2900 return AVERROR_INVALIDDATA;
2904 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2909 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
2913 HEVCContext *s = avctx->priv_data;
2916 ret = ff_hevc_output_frame(s, data, 1);
2925 ret = decode_nal_units(s, avpkt->data, avpkt->size);
2929 if (avctx->hwaccel) {
2930 if (s->ref && avctx->hwaccel->end_frame(avctx) < 0)
2931 av_log(avctx, AV_LOG_ERROR,
2932 "hardware accelerator failed to decode picture\n");
2934 /* verify the SEI checksum */
2935 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
2937 ret = verify_md5(s, s->ref->frame);
2938 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
2939 ff_hevc_unref_frame(s, s->ref, ~0);
2946 if (s->is_decoded) {
2947 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
2951 if (s->output_frame->buf[0]) {
2952 av_frame_move_ref(data, s->output_frame);
2959 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
2961 int ret = ff_thread_ref_frame(&dst->tf, &src->tf);
2965 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
2966 if (!dst->tab_mvf_buf)
2968 dst->tab_mvf = src->tab_mvf;
2970 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
2971 if (!dst->rpl_tab_buf)
2973 dst->rpl_tab = src->rpl_tab;
2975 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
2979 dst->poc = src->poc;
2980 dst->ctb_count = src->ctb_count;
2981 dst->window = src->window;
2982 dst->flags = src->flags;
2983 dst->sequence = src->sequence;
2985 if (src->hwaccel_picture_private) {
2986 dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
2987 if (!dst->hwaccel_priv_buf)
2989 dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
2994 ff_hevc_unref_frame(s, dst, ~0);
2995 return AVERROR(ENOMEM);
2998 static av_cold int hevc_decode_free(AVCodecContext *avctx)
3000 HEVCContext *s = avctx->priv_data;
3005 av_freep(&s->md5_ctx);
3007 av_frame_free(&s->tmp_frame);
3008 av_frame_free(&s->output_frame);
3010 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3011 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3012 av_frame_free(&s->DPB[i].frame);
3015 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++)
3016 av_buffer_unref(&s->vps_list[i]);
3017 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++)
3018 av_buffer_unref(&s->sps_list[i]);
3019 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
3020 av_buffer_unref(&s->pps_list[i]);
3022 for (i = 0; i < s->nals_allocated; i++)
3023 av_freep(&s->nals[i].rbsp_buffer);
3025 s->nals_allocated = 0;
3030 static av_cold int hevc_init_context(AVCodecContext *avctx)
3032 HEVCContext *s = avctx->priv_data;
3037 s->tmp_frame = av_frame_alloc();
3041 s->output_frame = av_frame_alloc();
3042 if (!s->output_frame)
3045 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3046 s->DPB[i].frame = av_frame_alloc();
3047 if (!s->DPB[i].frame)
3049 s->DPB[i].tf.f = s->DPB[i].frame;
3052 s->max_ra = INT_MAX;
3054 s->md5_ctx = av_md5_alloc();
3058 ff_bswapdsp_init(&s->bdsp);
3060 s->context_initialized = 1;
3065 hevc_decode_free(avctx);
3066 return AVERROR(ENOMEM);
3069 static int hevc_update_thread_context(AVCodecContext *dst,
3070 const AVCodecContext *src)
3072 HEVCContext *s = dst->priv_data;
3073 HEVCContext *s0 = src->priv_data;
3076 if (!s->context_initialized) {
3077 ret = hevc_init_context(dst);
3082 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3083 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3084 if (s0->DPB[i].frame->buf[0]) {
3085 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3091 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++) {
3092 av_buffer_unref(&s->vps_list[i]);
3093 if (s0->vps_list[i]) {
3094 s->vps_list[i] = av_buffer_ref(s0->vps_list[i]);
3095 if (!s->vps_list[i])
3096 return AVERROR(ENOMEM);
3100 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++) {
3101 av_buffer_unref(&s->sps_list[i]);
3102 if (s0->sps_list[i]) {
3103 s->sps_list[i] = av_buffer_ref(s0->sps_list[i]);
3104 if (!s->sps_list[i])
3105 return AVERROR(ENOMEM);
3109 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++) {
3110 av_buffer_unref(&s->pps_list[i]);
3111 if (s0->pps_list[i]) {
3112 s->pps_list[i] = av_buffer_ref(s0->pps_list[i]);
3113 if (!s->pps_list[i])
3114 return AVERROR(ENOMEM);
3118 if (s->sps != s0->sps)
3119 ret = set_sps(s, s0->sps);
3121 s->seq_decode = s0->seq_decode;
3122 s->seq_output = s0->seq_output;
3123 s->pocTid0 = s0->pocTid0;
3124 s->max_ra = s0->max_ra;
3126 s->is_nalff = s0->is_nalff;
3127 s->nal_length_size = s0->nal_length_size;
3130 s->seq_decode = (s->seq_decode + 1) & 0xff;
3131 s->max_ra = INT_MAX;
3137 static int hevc_decode_extradata(HEVCContext *s)
3139 AVCodecContext *avctx = s->avctx;
3143 bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
3145 if (avctx->extradata_size > 3 &&
3146 (avctx->extradata[0] || avctx->extradata[1] ||
3147 avctx->extradata[2] > 1)) {
3148 /* It seems the extradata is encoded as hvcC format.
3149 * Temporarily, we support configurationVersion==0 until 14496-15 3rd
3150 * is finalized. When finalized, configurationVersion will be 1 and we
3151 * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
3152 int i, j, num_arrays, nal_len_size;
3156 bytestream2_skip(&gb, 21);
3157 nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
3158 num_arrays = bytestream2_get_byte(&gb);
3160 /* nal units in the hvcC always have length coded with 2 bytes,
3161 * so put a fake nal_length_size = 2 while parsing them */
3162 s->nal_length_size = 2;
3164 /* Decode nal units from hvcC. */
3165 for (i = 0; i < num_arrays; i++) {
3166 int type = bytestream2_get_byte(&gb) & 0x3f;
3167 int cnt = bytestream2_get_be16(&gb);
3169 for (j = 0; j < cnt; j++) {
3170 // +2 for the nal size field
3171 int nalsize = bytestream2_peek_be16(&gb) + 2;
3172 if (bytestream2_get_bytes_left(&gb) < nalsize) {
3173 av_log(s->avctx, AV_LOG_ERROR,
3174 "Invalid NAL unit size in extradata.\n");
3175 return AVERROR_INVALIDDATA;
3178 ret = decode_nal_units(s, gb.buffer, nalsize);
3180 av_log(avctx, AV_LOG_ERROR,
3181 "Decoding nal unit %d %d from hvcC failed\n",
3185 bytestream2_skip(&gb, nalsize);
3189 /* Now store right nal length size, that will be used to parse
3191 s->nal_length_size = nal_len_size;
3194 ret = decode_nal_units(s, avctx->extradata, avctx->extradata_size);
3199 /* export stream parameters from the first SPS */
3200 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++) {
3201 if (s->sps_list[i]) {
3202 const HEVCSPS *sps = (const HEVCSPS*)s->sps_list[i]->data;
3203 export_stream_params(s->avctx, s, sps);
3211 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3213 HEVCContext *s = avctx->priv_data;
3216 ff_init_cabac_states();
3218 avctx->internal->allocate_progress = 1;
3220 ret = hevc_init_context(avctx);
3224 if (avctx->extradata_size > 0 && avctx->extradata) {
3225 ret = hevc_decode_extradata(s);
3227 hevc_decode_free(avctx);
3235 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3237 HEVCContext *s = avctx->priv_data;
3240 memset(s, 0, sizeof(*s));
3242 ret = hevc_init_context(avctx);
3249 static void hevc_decode_flush(AVCodecContext *avctx)
3251 HEVCContext *s = avctx->priv_data;
3252 ff_hevc_flush_dpb(s);
3253 s->max_ra = INT_MAX;
3256 #define OFFSET(x) offsetof(HEVCContext, x)
3257 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3259 static const AVProfile profiles[] = {
3260 { FF_PROFILE_HEVC_MAIN, "Main" },
3261 { FF_PROFILE_HEVC_MAIN_10, "Main 10" },
3262 { FF_PROFILE_HEVC_MAIN_STILL_PICTURE, "Main Still Picture" },
3263 { FF_PROFILE_UNKNOWN },
3266 static const AVOption options[] = {
3267 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3268 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3272 static const AVClass hevc_decoder_class = {
3273 .class_name = "HEVC decoder",
3274 .item_name = av_default_item_name,
3276 .version = LIBAVUTIL_VERSION_INT,
3279 AVCodec ff_hevc_decoder = {
3281 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3282 .type = AVMEDIA_TYPE_VIDEO,
3283 .id = AV_CODEC_ID_HEVC,
3284 .priv_data_size = sizeof(HEVCContext),
3285 .priv_class = &hevc_decoder_class,
3286 .init = hevc_decode_init,
3287 .close = hevc_decode_free,
3288 .decode = hevc_decode_frame,
3289 .flush = hevc_decode_flush,
3290 .update_thread_context = hevc_update_thread_context,
3291 .init_thread_copy = hevc_init_thread_copy,
3292 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY |
3293 CODEC_CAP_FRAME_THREADS,
3294 .profiles = NULL_IF_CONFIG_SMALL(profiles),