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 = get_ue_golomb_long(gb);
255 if (s->sps->chroma_format_idc != 0) {
256 int delta = get_se_golomb(gb);
257 s->sh.chroma_log2_weight_denom = av_clip_c(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_c((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_c((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 int set_sps(HEVCContext *s, const HEVCSPS *sps)
389 unsigned int num = 0, den = 0;
392 ret = pic_arrays_init(s, sps);
396 s->avctx->coded_width = sps->width;
397 s->avctx->coded_height = sps->height;
398 s->avctx->width = sps->output_width;
399 s->avctx->height = sps->output_height;
400 s->avctx->pix_fmt = sps->pix_fmt;
401 s->avctx->has_b_frames = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics;
403 ff_set_sar(s->avctx, sps->vui.sar);
405 if (sps->vui.video_signal_type_present_flag)
406 s->avctx->color_range = sps->vui.video_full_range_flag ? AVCOL_RANGE_JPEG
409 s->avctx->color_range = AVCOL_RANGE_MPEG;
411 if (sps->vui.colour_description_present_flag) {
412 s->avctx->color_primaries = sps->vui.colour_primaries;
413 s->avctx->color_trc = sps->vui.transfer_characteristic;
414 s->avctx->colorspace = sps->vui.matrix_coeffs;
416 s->avctx->color_primaries = AVCOL_PRI_UNSPECIFIED;
417 s->avctx->color_trc = AVCOL_TRC_UNSPECIFIED;
418 s->avctx->colorspace = AVCOL_SPC_UNSPECIFIED;
421 ff_hevc_pred_init(&s->hpc, sps->bit_depth);
422 ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
423 ff_videodsp_init (&s->vdsp, sps->bit_depth);
425 if (sps->sao_enabled) {
426 av_frame_unref(s->tmp_frame);
427 ret = ff_get_buffer(s->avctx, s->tmp_frame, AV_GET_BUFFER_FLAG_REF);
430 s->frame = s->tmp_frame;
434 s->vps = (HEVCVPS*) s->vps_list[s->sps->vps_id]->data;
436 if (s->vps->vps_timing_info_present_flag) {
437 num = s->vps->vps_num_units_in_tick;
438 den = s->vps->vps_time_scale;
439 } else if (sps->vui.vui_timing_info_present_flag) {
440 num = sps->vui.vui_num_units_in_tick;
441 den = sps->vui.vui_time_scale;
444 if (num != 0 && den != 0)
445 av_reduce(&s->avctx->framerate.den, &s->avctx->framerate.num,
456 static int hls_slice_header(HEVCContext *s)
458 GetBitContext *gb = &s->HEVClc.gb;
459 SliceHeader *sh = &s->sh;
463 sh->first_slice_in_pic_flag = get_bits1(gb);
464 if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
465 s->seq_decode = (s->seq_decode + 1) & 0xff;
468 ff_hevc_clear_refs(s);
471 sh->no_output_of_prior_pics_flag = get_bits1(gb);
473 sh->pps_id = get_ue_golomb_long(gb);
474 if (sh->pps_id >= MAX_PPS_COUNT || !s->pps_list[sh->pps_id]) {
475 av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
476 return AVERROR_INVALIDDATA;
478 if (!sh->first_slice_in_pic_flag &&
479 s->pps != (HEVCPPS*)s->pps_list[sh->pps_id]->data) {
480 av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
481 return AVERROR_INVALIDDATA;
483 s->pps = (HEVCPPS*)s->pps_list[sh->pps_id]->data;
485 if (s->sps != (HEVCSPS*)s->sps_list[s->pps->sps_id]->data) {
486 s->sps = (HEVCSPS*)s->sps_list[s->pps->sps_id]->data;
488 ff_hevc_clear_refs(s);
489 ret = set_sps(s, s->sps);
493 s->seq_decode = (s->seq_decode + 1) & 0xff;
497 s->avctx->profile = s->sps->ptl.general_ptl.profile_idc;
498 s->avctx->level = s->sps->ptl.general_ptl.level_idc;
500 sh->dependent_slice_segment_flag = 0;
501 if (!sh->first_slice_in_pic_flag) {
502 int slice_address_length;
504 if (s->pps->dependent_slice_segments_enabled_flag)
505 sh->dependent_slice_segment_flag = get_bits1(gb);
507 slice_address_length = av_ceil_log2(s->sps->ctb_width *
509 sh->slice_segment_addr = get_bits(gb, slice_address_length);
510 if (sh->slice_segment_addr >= s->sps->ctb_width * s->sps->ctb_height) {
511 av_log(s->avctx, AV_LOG_ERROR,
512 "Invalid slice segment address: %u.\n",
513 sh->slice_segment_addr);
514 return AVERROR_INVALIDDATA;
517 if (!sh->dependent_slice_segment_flag) {
518 sh->slice_addr = sh->slice_segment_addr;
522 sh->slice_segment_addr = sh->slice_addr = 0;
524 s->slice_initialized = 0;
527 if (!sh->dependent_slice_segment_flag) {
528 s->slice_initialized = 0;
530 for (i = 0; i < s->pps->num_extra_slice_header_bits; i++)
531 skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
533 sh->slice_type = get_ue_golomb_long(gb);
534 if (!(sh->slice_type == I_SLICE ||
535 sh->slice_type == P_SLICE ||
536 sh->slice_type == B_SLICE)) {
537 av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
539 return AVERROR_INVALIDDATA;
541 if (IS_IRAP(s) && sh->slice_type != I_SLICE) {
542 av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
543 return AVERROR_INVALIDDATA;
546 // when flag is not present, picture is inferred to be output
547 sh->pic_output_flag = 1;
548 if (s->pps->output_flag_present_flag)
549 sh->pic_output_flag = get_bits1(gb);
551 if (s->sps->separate_colour_plane_flag)
552 sh->colour_plane_id = get_bits(gb, 2);
555 int short_term_ref_pic_set_sps_flag, poc;
557 sh->pic_order_cnt_lsb = get_bits(gb, s->sps->log2_max_poc_lsb);
558 poc = ff_hevc_compute_poc(s, sh->pic_order_cnt_lsb);
559 if (!sh->first_slice_in_pic_flag && poc != s->poc) {
560 av_log(s->avctx, AV_LOG_WARNING,
561 "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
562 if (s->avctx->err_recognition & AV_EF_EXPLODE)
563 return AVERROR_INVALIDDATA;
568 short_term_ref_pic_set_sps_flag = get_bits1(gb);
569 if (!short_term_ref_pic_set_sps_flag) {
570 ret = ff_hevc_decode_short_term_rps(s, &sh->slice_rps, s->sps, 1);
574 sh->short_term_rps = &sh->slice_rps;
576 int numbits, rps_idx;
578 if (!s->sps->nb_st_rps) {
579 av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
580 return AVERROR_INVALIDDATA;
583 numbits = av_ceil_log2(s->sps->nb_st_rps);
584 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
585 sh->short_term_rps = &s->sps->st_rps[rps_idx];
588 ret = decode_lt_rps(s, &sh->long_term_rps, gb);
590 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
591 if (s->avctx->err_recognition & AV_EF_EXPLODE)
592 return AVERROR_INVALIDDATA;
595 if (s->sps->sps_temporal_mvp_enabled_flag)
596 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
598 sh->slice_temporal_mvp_enabled_flag = 0;
600 s->sh.short_term_rps = NULL;
605 if (s->temporal_id == 0 &&
606 s->nal_unit_type != NAL_TRAIL_N &&
607 s->nal_unit_type != NAL_TSA_N &&
608 s->nal_unit_type != NAL_STSA_N &&
609 s->nal_unit_type != NAL_RADL_N &&
610 s->nal_unit_type != NAL_RADL_R &&
611 s->nal_unit_type != NAL_RASL_N &&
612 s->nal_unit_type != NAL_RASL_R)
615 if (s->sps->sao_enabled) {
616 sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
617 sh->slice_sample_adaptive_offset_flag[1] =
618 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
620 sh->slice_sample_adaptive_offset_flag[0] = 0;
621 sh->slice_sample_adaptive_offset_flag[1] = 0;
622 sh->slice_sample_adaptive_offset_flag[2] = 0;
625 sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
626 if (sh->slice_type == P_SLICE || sh->slice_type == B_SLICE) {
629 sh->nb_refs[L0] = s->pps->num_ref_idx_l0_default_active;
630 if (sh->slice_type == B_SLICE)
631 sh->nb_refs[L1] = s->pps->num_ref_idx_l1_default_active;
633 if (get_bits1(gb)) { // num_ref_idx_active_override_flag
634 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
635 if (sh->slice_type == B_SLICE)
636 sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
638 if (sh->nb_refs[L0] > MAX_REFS || sh->nb_refs[L1] > MAX_REFS) {
639 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
640 sh->nb_refs[L0], sh->nb_refs[L1]);
641 return AVERROR_INVALIDDATA;
644 sh->rpl_modification_flag[0] = 0;
645 sh->rpl_modification_flag[1] = 0;
646 nb_refs = ff_hevc_frame_nb_refs(s);
648 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
649 return AVERROR_INVALIDDATA;
652 if (s->pps->lists_modification_present_flag && nb_refs > 1) {
653 sh->rpl_modification_flag[0] = get_bits1(gb);
654 if (sh->rpl_modification_flag[0]) {
655 for (i = 0; i < sh->nb_refs[L0]; i++)
656 sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
659 if (sh->slice_type == B_SLICE) {
660 sh->rpl_modification_flag[1] = get_bits1(gb);
661 if (sh->rpl_modification_flag[1] == 1)
662 for (i = 0; i < sh->nb_refs[L1]; i++)
663 sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
667 if (sh->slice_type == B_SLICE)
668 sh->mvd_l1_zero_flag = get_bits1(gb);
670 if (s->pps->cabac_init_present_flag)
671 sh->cabac_init_flag = get_bits1(gb);
673 sh->cabac_init_flag = 0;
675 sh->collocated_ref_idx = 0;
676 if (sh->slice_temporal_mvp_enabled_flag) {
677 sh->collocated_list = L0;
678 if (sh->slice_type == B_SLICE)
679 sh->collocated_list = !get_bits1(gb);
681 if (sh->nb_refs[sh->collocated_list] > 1) {
682 sh->collocated_ref_idx = get_ue_golomb_long(gb);
683 if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
684 av_log(s->avctx, AV_LOG_ERROR,
685 "Invalid collocated_ref_idx: %d.\n",
686 sh->collocated_ref_idx);
687 return AVERROR_INVALIDDATA;
692 if ((s->pps->weighted_pred_flag && sh->slice_type == P_SLICE) ||
693 (s->pps->weighted_bipred_flag && sh->slice_type == B_SLICE)) {
694 pred_weight_table(s, gb);
697 sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
698 if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
699 av_log(s->avctx, AV_LOG_ERROR,
700 "Invalid number of merging MVP candidates: %d.\n",
701 sh->max_num_merge_cand);
702 return AVERROR_INVALIDDATA;
706 sh->slice_qp_delta = get_se_golomb(gb);
708 if (s->pps->pic_slice_level_chroma_qp_offsets_present_flag) {
709 sh->slice_cb_qp_offset = get_se_golomb(gb);
710 sh->slice_cr_qp_offset = get_se_golomb(gb);
712 sh->slice_cb_qp_offset = 0;
713 sh->slice_cr_qp_offset = 0;
716 if (s->pps->deblocking_filter_control_present_flag) {
717 int deblocking_filter_override_flag = 0;
719 if (s->pps->deblocking_filter_override_enabled_flag)
720 deblocking_filter_override_flag = get_bits1(gb);
722 if (deblocking_filter_override_flag) {
723 sh->disable_deblocking_filter_flag = get_bits1(gb);
724 if (!sh->disable_deblocking_filter_flag) {
725 sh->beta_offset = get_se_golomb(gb) * 2;
726 sh->tc_offset = get_se_golomb(gb) * 2;
729 sh->disable_deblocking_filter_flag = s->pps->disable_dbf;
730 sh->beta_offset = s->pps->beta_offset;
731 sh->tc_offset = s->pps->tc_offset;
734 sh->disable_deblocking_filter_flag = 0;
739 if (s->pps->seq_loop_filter_across_slices_enabled_flag &&
740 (sh->slice_sample_adaptive_offset_flag[0] ||
741 sh->slice_sample_adaptive_offset_flag[1] ||
742 !sh->disable_deblocking_filter_flag)) {
743 sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
745 sh->slice_loop_filter_across_slices_enabled_flag = s->pps->seq_loop_filter_across_slices_enabled_flag;
747 } else if (!s->slice_initialized) {
748 av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
749 return AVERROR_INVALIDDATA;
752 sh->num_entry_point_offsets = 0;
753 if (s->pps->tiles_enabled_flag || s->pps->entropy_coding_sync_enabled_flag) {
754 sh->num_entry_point_offsets = get_ue_golomb_long(gb);
755 if (sh->num_entry_point_offsets > 0) {
756 int offset_len = get_ue_golomb_long(gb) + 1;
758 for (i = 0; i < sh->num_entry_point_offsets; i++)
759 skip_bits(gb, offset_len);
763 if (s->pps->slice_header_extension_present_flag) {
764 unsigned int length = get_ue_golomb_long(gb);
765 for (i = 0; i < length; i++)
766 skip_bits(gb, 8); // slice_header_extension_data_byte
769 // Inferred parameters
770 sh->slice_qp = 26 + s->pps->pic_init_qp_minus26 + sh->slice_qp_delta;
771 if (sh->slice_qp > 51 ||
772 sh->slice_qp < -s->sps->qp_bd_offset) {
773 av_log(s->avctx, AV_LOG_ERROR,
774 "The slice_qp %d is outside the valid range "
777 -s->sps->qp_bd_offset);
778 return AVERROR_INVALIDDATA;
781 sh->slice_ctb_addr_rs = sh->slice_segment_addr;
783 if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) {
784 av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
785 return AVERROR_INVALIDDATA;
788 s->HEVClc.first_qp_group = !s->sh.dependent_slice_segment_flag;
790 if (!s->pps->cu_qp_delta_enabled_flag)
791 s->HEVClc.qp_y = FFUMOD(s->sh.slice_qp + 52 + 2 * s->sps->qp_bd_offset,
792 52 + s->sps->qp_bd_offset) - s->sps->qp_bd_offset;
794 s->slice_initialized = 1;
799 #define CTB(tab, x, y) ((tab)[(y) * s->sps->ctb_width + (x)])
801 #define SET_SAO(elem, value) \
803 if (!sao_merge_up_flag && !sao_merge_left_flag) \
805 else if (sao_merge_left_flag) \
806 sao->elem = CTB(s->sao, rx-1, ry).elem; \
807 else if (sao_merge_up_flag) \
808 sao->elem = CTB(s->sao, rx, ry-1).elem; \
813 static void hls_sao_param(HEVCContext *s, int rx, int ry)
815 HEVCLocalContext *lc = &s->HEVClc;
816 int sao_merge_left_flag = 0;
817 int sao_merge_up_flag = 0;
818 int shift = s->sps->bit_depth - FFMIN(s->sps->bit_depth, 10);
819 SAOParams *sao = &CTB(s->sao, rx, ry);
822 if (s->sh.slice_sample_adaptive_offset_flag[0] ||
823 s->sh.slice_sample_adaptive_offset_flag[1]) {
825 if (lc->ctb_left_flag)
826 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
828 if (ry > 0 && !sao_merge_left_flag) {
830 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
834 for (c_idx = 0; c_idx < 3; c_idx++) {
835 if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
836 sao->type_idx[c_idx] = SAO_NOT_APPLIED;
841 sao->type_idx[2] = sao->type_idx[1];
842 sao->eo_class[2] = sao->eo_class[1];
844 SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
847 if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
850 for (i = 0; i < 4; i++)
851 SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
853 if (sao->type_idx[c_idx] == SAO_BAND) {
854 for (i = 0; i < 4; i++) {
855 if (sao->offset_abs[c_idx][i]) {
856 SET_SAO(offset_sign[c_idx][i],
857 ff_hevc_sao_offset_sign_decode(s));
859 sao->offset_sign[c_idx][i] = 0;
862 SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
863 } else if (c_idx != 2) {
864 SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
867 // Inferred parameters
868 sao->offset_val[c_idx][0] = 0;
869 for (i = 0; i < 4; i++) {
870 sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i] << shift;
871 if (sao->type_idx[c_idx] == SAO_EDGE) {
873 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
874 } else if (sao->offset_sign[c_idx][i]) {
875 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
884 static void hls_residual_coding(HEVCContext *s, int x0, int y0,
885 int log2_trafo_size, enum ScanType scan_idx,
888 #define GET_COORD(offset, n) \
890 x_c = (scan_x_cg[offset >> 4] << 2) + scan_x_off[n]; \
891 y_c = (scan_y_cg[offset >> 4] << 2) + scan_y_off[n]; \
893 HEVCLocalContext *lc = &s->HEVClc;
894 int transform_skip_flag = 0;
896 int last_significant_coeff_x, last_significant_coeff_y;
900 int greater1_ctx = 1;
903 int x_cg_last_sig, y_cg_last_sig;
905 const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
907 ptrdiff_t stride = s->frame->linesize[c_idx];
908 int hshift = s->sps->hshift[c_idx];
909 int vshift = s->sps->vshift[c_idx];
910 uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
911 ((x0 >> hshift) << s->sps->pixel_shift)];
912 DECLARE_ALIGNED(16, int16_t, coeffs[MAX_TB_SIZE * MAX_TB_SIZE]) = { 0 };
913 DECLARE_ALIGNED(8, uint8_t, significant_coeff_group_flag[8][8]) = { { 0 } };
915 int trafo_size = 1 << log2_trafo_size;
916 int i, qp, shift, add, scale, scale_m;
917 const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
918 const uint8_t *scale_matrix;
921 // Derive QP for dequant
922 if (!lc->cu.cu_transquant_bypass_flag) {
923 static const int qp_c[] = {
924 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37
927 static const uint8_t rem6[51 + 2 * 6 + 1] = {
928 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
929 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
930 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
933 static const uint8_t div6[51 + 2 * 6 + 1] = {
934 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
935 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
936 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
941 qp = qp_y + s->sps->qp_bd_offset;
946 offset = s->pps->cb_qp_offset + s->sh.slice_cb_qp_offset;
948 offset = s->pps->cr_qp_offset + s->sh.slice_cr_qp_offset;
950 qp_i = av_clip_c(qp_y + offset, -s->sps->qp_bd_offset, 57);
956 qp = qp_c[qp_i - 30];
958 qp += s->sps->qp_bd_offset;
961 shift = s->sps->bit_depth + log2_trafo_size - 5;
962 add = 1 << (shift - 1);
963 scale = level_scale[rem6[qp]] << (div6[qp]);
964 scale_m = 16; // default when no custom scaling lists.
967 if (s->sps->scaling_list_enable_flag) {
968 const ScalingList *sl = s->pps->scaling_list_data_present_flag ?
969 &s->pps->scaling_list : &s->sps->scaling_list;
970 int matrix_id = lc->cu.pred_mode != MODE_INTRA;
972 if (log2_trafo_size != 5)
973 matrix_id = 3 * matrix_id + c_idx;
975 scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
976 if (log2_trafo_size >= 4)
977 dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
981 if (s->pps->transform_skip_enabled_flag &&
982 !lc->cu.cu_transquant_bypass_flag &&
983 log2_trafo_size == 2) {
984 transform_skip_flag = ff_hevc_transform_skip_flag_decode(s, c_idx);
987 last_significant_coeff_x =
988 ff_hevc_last_significant_coeff_x_prefix_decode(s, c_idx, log2_trafo_size);
989 last_significant_coeff_y =
990 ff_hevc_last_significant_coeff_y_prefix_decode(s, c_idx, log2_trafo_size);
992 if (last_significant_coeff_x > 3) {
993 int suffix = ff_hevc_last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
994 last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
995 (2 + (last_significant_coeff_x & 1)) +
999 if (last_significant_coeff_y > 3) {
1000 int suffix = ff_hevc_last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
1001 last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
1002 (2 + (last_significant_coeff_y & 1)) +
1006 if (scan_idx == SCAN_VERT)
1007 FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
1009 x_cg_last_sig = last_significant_coeff_x >> 2;
1010 y_cg_last_sig = last_significant_coeff_y >> 2;
1014 int last_x_c = last_significant_coeff_x & 3;
1015 int last_y_c = last_significant_coeff_y & 3;
1017 scan_x_off = ff_hevc_diag_scan4x4_x;
1018 scan_y_off = ff_hevc_diag_scan4x4_y;
1019 num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
1020 if (trafo_size == 4) {
1021 scan_x_cg = scan_1x1;
1022 scan_y_cg = scan_1x1;
1023 } else if (trafo_size == 8) {
1024 num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1025 scan_x_cg = diag_scan2x2_x;
1026 scan_y_cg = diag_scan2x2_y;
1027 } else if (trafo_size == 16) {
1028 num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1029 scan_x_cg = ff_hevc_diag_scan4x4_x;
1030 scan_y_cg = ff_hevc_diag_scan4x4_y;
1031 } else { // trafo_size == 32
1032 num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1033 scan_x_cg = ff_hevc_diag_scan8x8_x;
1034 scan_y_cg = ff_hevc_diag_scan8x8_y;
1039 scan_x_cg = horiz_scan2x2_x;
1040 scan_y_cg = horiz_scan2x2_y;
1041 scan_x_off = horiz_scan4x4_x;
1042 scan_y_off = horiz_scan4x4_y;
1043 num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1045 default: //SCAN_VERT
1046 scan_x_cg = horiz_scan2x2_y;
1047 scan_y_cg = horiz_scan2x2_x;
1048 scan_x_off = horiz_scan4x4_y;
1049 scan_y_off = horiz_scan4x4_x;
1050 num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1054 num_last_subset = (num_coeff - 1) >> 4;
1056 for (i = num_last_subset; i >= 0; i--) {
1058 int x_cg, y_cg, x_c, y_c;
1059 int implicit_non_zero_coeff = 0;
1060 int64_t trans_coeff_level;
1062 int offset = i << 4;
1064 uint8_t significant_coeff_flag_idx[16];
1065 uint8_t nb_significant_coeff_flag = 0;
1067 x_cg = scan_x_cg[i];
1068 y_cg = scan_y_cg[i];
1070 if (i < num_last_subset && i > 0) {
1072 if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1073 ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1074 if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1075 ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1077 significant_coeff_group_flag[x_cg][y_cg] =
1078 ff_hevc_significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
1079 implicit_non_zero_coeff = 1;
1081 significant_coeff_group_flag[x_cg][y_cg] =
1082 ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1083 (x_cg == 0 && y_cg == 0));
1086 last_scan_pos = num_coeff - offset - 1;
1088 if (i == num_last_subset) {
1089 n_end = last_scan_pos - 1;
1090 significant_coeff_flag_idx[0] = last_scan_pos;
1091 nb_significant_coeff_flag = 1;
1096 if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1097 prev_sig = significant_coeff_group_flag[x_cg + 1][y_cg];
1098 if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1099 prev_sig += significant_coeff_group_flag[x_cg][y_cg + 1] << 1;
1101 for (n = n_end; n >= 0; n--) {
1102 GET_COORD(offset, n);
1104 if (significant_coeff_group_flag[x_cg][y_cg] &&
1105 (n > 0 || implicit_non_zero_coeff == 0)) {
1106 if (ff_hevc_significant_coeff_flag_decode(s, c_idx, x_c, y_c,
1110 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1111 nb_significant_coeff_flag++;
1112 implicit_non_zero_coeff = 0;
1115 int last_cg = (x_c == (x_cg << 2) && y_c == (y_cg << 2));
1116 if (last_cg && implicit_non_zero_coeff && significant_coeff_group_flag[x_cg][y_cg]) {
1117 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1118 nb_significant_coeff_flag++;
1123 n_end = nb_significant_coeff_flag;
1126 int first_nz_pos_in_cg = 16;
1127 int last_nz_pos_in_cg = -1;
1128 int c_rice_param = 0;
1129 int first_greater1_coeff_idx = -1;
1130 uint8_t coeff_abs_level_greater1_flag[16] = { 0 };
1131 uint16_t coeff_sign_flag;
1133 int sign_hidden = 0;
1135 // initialize first elem of coeff_bas_level_greater1_flag
1136 int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1138 if (!(i == num_last_subset) && greater1_ctx == 0)
1141 last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1143 for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1144 int n_idx = significant_coeff_flag_idx[m];
1145 int inc = (ctx_set << 2) + greater1_ctx;
1146 coeff_abs_level_greater1_flag[n_idx] =
1147 ff_hevc_coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
1148 if (coeff_abs_level_greater1_flag[n_idx]) {
1150 } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1154 if (coeff_abs_level_greater1_flag[n_idx] &&
1155 first_greater1_coeff_idx == -1)
1156 first_greater1_coeff_idx = n_idx;
1158 first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1159 sign_hidden = last_nz_pos_in_cg - first_nz_pos_in_cg >= 4 &&
1160 !lc->cu.cu_transquant_bypass_flag;
1162 if (first_greater1_coeff_idx != -1) {
1163 coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += ff_hevc_coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1165 if (!s->pps->sign_data_hiding_flag || !sign_hidden) {
1166 coeff_sign_flag = ff_hevc_coeff_sign_flag(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1168 coeff_sign_flag = ff_hevc_coeff_sign_flag(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1171 for (m = 0; m < n_end; m++) {
1172 n = significant_coeff_flag_idx[m];
1173 GET_COORD(offset, n);
1174 trans_coeff_level = 1 + coeff_abs_level_greater1_flag[n];
1175 if (trans_coeff_level == ((m < 8) ?
1176 ((n == first_greater1_coeff_idx) ? 3 : 2) : 1)) {
1177 int last_coeff_abs_level_remaining = ff_hevc_coeff_abs_level_remaining(s, trans_coeff_level, c_rice_param);
1179 trans_coeff_level += last_coeff_abs_level_remaining;
1180 if ((trans_coeff_level) > (3 * (1 << c_rice_param)))
1181 c_rice_param = FFMIN(c_rice_param + 1, 4);
1183 if (s->pps->sign_data_hiding_flag && sign_hidden) {
1184 sum_abs += trans_coeff_level;
1185 if (n == first_nz_pos_in_cg && ((sum_abs & 1) == 1))
1186 trans_coeff_level = -trans_coeff_level;
1188 if (coeff_sign_flag >> 15)
1189 trans_coeff_level = -trans_coeff_level;
1190 coeff_sign_flag <<= 1;
1191 if (!lc->cu.cu_transquant_bypass_flag) {
1192 if (s->sps->scaling_list_enable_flag) {
1193 if (y_c || x_c || log2_trafo_size < 4) {
1195 switch (log2_trafo_size) {
1196 case 3: pos = (y_c << 3) + x_c; break;
1197 case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1198 case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1199 default: pos = (y_c << 2) + x_c;
1201 scale_m = scale_matrix[pos];
1206 trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1207 if(trans_coeff_level < 0) {
1208 if((~trans_coeff_level) & 0xFffffffffff8000)
1209 trans_coeff_level = -32768;
1211 if (trans_coeff_level & 0xffffffffffff8000)
1212 trans_coeff_level = 32767;
1215 coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1220 if (lc->cu.cu_transquant_bypass_flag) {
1221 s->hevcdsp.transquant_bypass[log2_trafo_size - 2](dst, coeffs, stride);
1223 if (transform_skip_flag)
1224 s->hevcdsp.transform_skip(dst, coeffs, stride);
1225 else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 &&
1226 log2_trafo_size == 2)
1227 s->hevcdsp.transform_4x4_luma_add(dst, coeffs, stride);
1229 s->hevcdsp.transform_add[log2_trafo_size - 2](dst, coeffs, stride);
1233 static int hls_transform_unit(HEVCContext *s, int x0, int y0,
1234 int xBase, int yBase, int cb_xBase, int cb_yBase,
1235 int log2_cb_size, int log2_trafo_size,
1236 int blk_idx, int cbf_luma, int cbf_cb, int cbf_cr)
1238 HEVCLocalContext *lc = &s->HEVClc;
1240 if (lc->cu.pred_mode == MODE_INTRA) {
1241 int trafo_size = 1 << log2_trafo_size;
1242 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1244 s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
1245 if (log2_trafo_size > 2) {
1246 trafo_size = trafo_size << (s->sps->hshift[1] - 1);
1247 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1248 s->hpc.intra_pred[log2_trafo_size - 3](s, x0, y0, 1);
1249 s->hpc.intra_pred[log2_trafo_size - 3](s, x0, y0, 2);
1250 } else if (blk_idx == 3) {
1251 trafo_size = trafo_size << s->sps->hshift[1];
1252 ff_hevc_set_neighbour_available(s, xBase, yBase,
1253 trafo_size, trafo_size);
1254 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1255 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1259 if (cbf_luma || cbf_cb || cbf_cr) {
1260 int scan_idx = SCAN_DIAG;
1261 int scan_idx_c = SCAN_DIAG;
1263 if (s->pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
1264 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
1265 if (lc->tu.cu_qp_delta != 0)
1266 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
1267 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
1268 lc->tu.is_cu_qp_delta_coded = 1;
1270 if (lc->tu.cu_qp_delta < -(26 + s->sps->qp_bd_offset / 2) ||
1271 lc->tu.cu_qp_delta > (25 + s->sps->qp_bd_offset / 2)) {
1272 av_log(s->avctx, AV_LOG_ERROR,
1273 "The cu_qp_delta %d is outside the valid range "
1276 -(26 + s->sps->qp_bd_offset / 2),
1277 (25 + s->sps->qp_bd_offset / 2));
1278 return AVERROR_INVALIDDATA;
1281 ff_hevc_set_qPy(s, x0, y0, cb_xBase, cb_yBase, log2_cb_size);
1284 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
1285 if (lc->tu.cur_intra_pred_mode >= 6 &&
1286 lc->tu.cur_intra_pred_mode <= 14) {
1287 scan_idx = SCAN_VERT;
1288 } else if (lc->tu.cur_intra_pred_mode >= 22 &&
1289 lc->tu.cur_intra_pred_mode <= 30) {
1290 scan_idx = SCAN_HORIZ;
1293 if (lc->pu.intra_pred_mode_c >= 6 &&
1294 lc->pu.intra_pred_mode_c <= 14) {
1295 scan_idx_c = SCAN_VERT;
1296 } else if (lc->pu.intra_pred_mode_c >= 22 &&
1297 lc->pu.intra_pred_mode_c <= 30) {
1298 scan_idx_c = SCAN_HORIZ;
1303 hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
1304 if (log2_trafo_size > 2) {
1306 hls_residual_coding(s, x0, y0, log2_trafo_size - 1, scan_idx_c, 1);
1308 hls_residual_coding(s, x0, y0, log2_trafo_size - 1, scan_idx_c, 2);
1309 } else if (blk_idx == 3) {
1311 hls_residual_coding(s, xBase, yBase, log2_trafo_size, scan_idx_c, 1);
1313 hls_residual_coding(s, xBase, yBase, log2_trafo_size, scan_idx_c, 2);
1319 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1321 int cb_size = 1 << log2_cb_size;
1322 int log2_min_pu_size = s->sps->log2_min_pu_size;
1324 int min_pu_width = s->sps->min_pu_width;
1325 int x_end = FFMIN(x0 + cb_size, s->sps->width);
1326 int y_end = FFMIN(y0 + cb_size, s->sps->height);
1329 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1330 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1331 s->is_pcm[i + j * min_pu_width] = 2;
1334 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1335 int xBase, int yBase, int cb_xBase, int cb_yBase,
1336 int log2_cb_size, int log2_trafo_size,
1337 int trafo_depth, int blk_idx,
1338 int cbf_cb, int cbf_cr)
1340 HEVCLocalContext *lc = &s->HEVClc;
1341 uint8_t split_transform_flag;
1344 if (lc->cu.intra_split_flag) {
1345 if (trafo_depth == 1)
1346 lc->tu.cur_intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1348 lc->tu.cur_intra_pred_mode = lc->pu.intra_pred_mode[0];
1351 if (log2_trafo_size <= s->sps->log2_max_trafo_size &&
1352 log2_trafo_size > s->sps->log2_min_tb_size &&
1353 trafo_depth < lc->cu.max_trafo_depth &&
1354 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1355 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1357 int inter_split = s->sps->max_transform_hierarchy_depth_inter == 0 &&
1358 lc->cu.pred_mode == MODE_INTER &&
1359 lc->cu.part_mode != PART_2Nx2N &&
1362 split_transform_flag = log2_trafo_size > s->sps->log2_max_trafo_size ||
1363 (lc->cu.intra_split_flag && trafo_depth == 0) ||
1367 if (log2_trafo_size > 2 && (trafo_depth == 0 || cbf_cb))
1368 cbf_cb = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1369 else if (log2_trafo_size > 2 || trafo_depth == 0)
1371 if (log2_trafo_size > 2 && (trafo_depth == 0 || cbf_cr))
1372 cbf_cr = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1373 else if (log2_trafo_size > 2 || trafo_depth == 0)
1376 if (split_transform_flag) {
1377 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1378 const int x1 = x0 + trafo_size_split;
1379 const int y1 = y0 + trafo_size_split;
1381 #define SUBDIVIDE(x, y, idx) \
1383 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1384 log2_trafo_size - 1, trafo_depth + 1, idx, \
1390 SUBDIVIDE(x0, y0, 0);
1391 SUBDIVIDE(x1, y0, 1);
1392 SUBDIVIDE(x0, y1, 2);
1393 SUBDIVIDE(x1, y1, 3);
1397 int min_tu_size = 1 << s->sps->log2_min_tb_size;
1398 int log2_min_tu_size = s->sps->log2_min_tb_size;
1399 int min_tu_width = s->sps->min_tb_width;
1402 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1404 cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1406 ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1407 log2_cb_size, log2_trafo_size,
1408 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1411 // TODO: store cbf_luma somewhere else
1414 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1415 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1416 int x_tu = (x0 + j) >> log2_min_tu_size;
1417 int y_tu = (y0 + i) >> log2_min_tu_size;
1418 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1421 if (!s->sh.disable_deblocking_filter_flag) {
1422 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1423 if (s->pps->transquant_bypass_enable_flag &&
1424 lc->cu.cu_transquant_bypass_flag)
1425 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1431 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1433 //TODO: non-4:2:0 support
1434 HEVCLocalContext *lc = &s->HEVClc;
1436 int cb_size = 1 << log2_cb_size;
1437 int stride0 = s->frame->linesize[0];
1438 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->sps->pixel_shift)];
1439 int stride1 = s->frame->linesize[1];
1440 uint8_t *dst1 = &s->frame->data[1][(y0 >> s->sps->vshift[1]) * stride1 + ((x0 >> s->sps->hshift[1]) << s->sps->pixel_shift)];
1441 int stride2 = s->frame->linesize[2];
1442 uint8_t *dst2 = &s->frame->data[2][(y0 >> s->sps->vshift[2]) * stride2 + ((x0 >> s->sps->hshift[2]) << s->sps->pixel_shift)];
1444 int length = cb_size * cb_size * s->sps->pcm.bit_depth + ((cb_size * cb_size) >> 1) * s->sps->pcm.bit_depth_chroma;
1445 const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1448 if (!s->sh.disable_deblocking_filter_flag)
1449 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1451 ret = init_get_bits(&gb, pcm, length);
1455 s->hevcdsp.put_pcm(dst0, stride0, cb_size, &gb, s->sps->pcm.bit_depth);
1456 s->hevcdsp.put_pcm(dst1, stride1, cb_size / 2, &gb, s->sps->pcm.bit_depth_chroma);
1457 s->hevcdsp.put_pcm(dst2, stride2, cb_size / 2, &gb, s->sps->pcm.bit_depth_chroma);
1461 static void hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1463 HEVCLocalContext *lc = &s->HEVClc;
1464 int x = ff_hevc_abs_mvd_greater0_flag_decode(s);
1465 int y = ff_hevc_abs_mvd_greater0_flag_decode(s);
1468 x += ff_hevc_abs_mvd_greater1_flag_decode(s);
1470 y += ff_hevc_abs_mvd_greater1_flag_decode(s);
1473 case 2: lc->pu.mvd.x = ff_hevc_mvd_decode(s); break;
1474 case 1: lc->pu.mvd.x = ff_hevc_mvd_sign_flag_decode(s); break;
1475 case 0: lc->pu.mvd.x = 0; break;
1479 case 2: lc->pu.mvd.y = ff_hevc_mvd_decode(s); break;
1480 case 1: lc->pu.mvd.y = ff_hevc_mvd_sign_flag_decode(s); break;
1481 case 0: lc->pu.mvd.y = 0; break;
1486 * 8.5.3.2.2.1 Luma sample interpolation process
1488 * @param s HEVC decoding context
1489 * @param dst target buffer for block data at block position
1490 * @param dststride stride of the dst buffer
1491 * @param ref reference picture buffer at origin (0, 0)
1492 * @param mv motion vector (relative to block position) to get pixel data from
1493 * @param x_off horizontal position of block from origin (0, 0)
1494 * @param y_off vertical position of block from origin (0, 0)
1495 * @param block_w width of block
1496 * @param block_h height of block
1498 static void luma_mc(HEVCContext *s, int16_t *dst, ptrdiff_t dststride,
1499 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1500 int block_w, int block_h)
1502 HEVCLocalContext *lc = &s->HEVClc;
1503 uint8_t *src = ref->data[0];
1504 ptrdiff_t srcstride = ref->linesize[0];
1505 int pic_width = s->sps->width;
1506 int pic_height = s->sps->height;
1510 int extra_left = ff_hevc_qpel_extra_before[mx];
1511 int extra_top = ff_hevc_qpel_extra_before[my];
1513 x_off += mv->x >> 2;
1514 y_off += mv->y >> 2;
1515 src += y_off * srcstride + (x_off << s->sps->pixel_shift);
1517 if (x_off < extra_left || y_off < extra_top ||
1518 x_off >= pic_width - block_w - ff_hevc_qpel_extra_after[mx] ||
1519 y_off >= pic_height - block_h - ff_hevc_qpel_extra_after[my]) {
1520 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1521 int offset = extra_top * srcstride + (extra_left << s->sps->pixel_shift);
1522 int buf_offset = extra_top *
1523 edge_emu_stride + (extra_left << s->sps->pixel_shift);
1525 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1526 edge_emu_stride, srcstride,
1527 block_w + ff_hevc_qpel_extra[mx],
1528 block_h + ff_hevc_qpel_extra[my],
1529 x_off - extra_left, y_off - extra_top,
1530 pic_width, pic_height);
1531 src = lc->edge_emu_buffer + buf_offset;
1532 srcstride = edge_emu_stride;
1534 s->hevcdsp.put_hevc_qpel[my][mx](dst, dststride, src, srcstride, block_w,
1535 block_h, lc->mc_buffer);
1539 * 8.5.3.2.2.2 Chroma sample interpolation process
1541 * @param s HEVC decoding context
1542 * @param dst1 target buffer for block data at block position (U plane)
1543 * @param dst2 target buffer for block data at block position (V plane)
1544 * @param dststride stride of the dst1 and dst2 buffers
1545 * @param ref reference picture buffer at origin (0, 0)
1546 * @param mv motion vector (relative to block position) to get pixel data from
1547 * @param x_off horizontal position of block from origin (0, 0)
1548 * @param y_off vertical position of block from origin (0, 0)
1549 * @param block_w width of block
1550 * @param block_h height of block
1552 static void chroma_mc(HEVCContext *s, int16_t *dst1, int16_t *dst2,
1553 ptrdiff_t dststride, AVFrame *ref, const Mv *mv,
1554 int x_off, int y_off, int block_w, int block_h)
1556 HEVCLocalContext *lc = &s->HEVClc;
1557 uint8_t *src1 = ref->data[1];
1558 uint8_t *src2 = ref->data[2];
1559 ptrdiff_t src1stride = ref->linesize[1];
1560 ptrdiff_t src2stride = ref->linesize[2];
1561 int pic_width = s->sps->width >> 1;
1562 int pic_height = s->sps->height >> 1;
1567 x_off += mv->x >> 3;
1568 y_off += mv->y >> 3;
1569 src1 += y_off * src1stride + (x_off << s->sps->pixel_shift);
1570 src2 += y_off * src2stride + (x_off << s->sps->pixel_shift);
1572 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1573 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1574 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1575 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1576 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->sps->pixel_shift));
1577 int buf_offset1 = EPEL_EXTRA_BEFORE *
1578 (edge_emu_stride + (1 << s->sps->pixel_shift));
1579 int offset2 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->sps->pixel_shift));
1580 int buf_offset2 = EPEL_EXTRA_BEFORE *
1581 (edge_emu_stride + (1 << s->sps->pixel_shift));
1583 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1584 edge_emu_stride, src1stride,
1585 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1586 x_off - EPEL_EXTRA_BEFORE,
1587 y_off - EPEL_EXTRA_BEFORE,
1588 pic_width, pic_height);
1590 src1 = lc->edge_emu_buffer + buf_offset1;
1591 src1stride = edge_emu_stride;
1592 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst1, dststride, src1, src1stride,
1593 block_w, block_h, mx, my, lc->mc_buffer);
1595 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src2 - offset2,
1596 edge_emu_stride, src2stride,
1597 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1598 x_off - EPEL_EXTRA_BEFORE,
1599 y_off - EPEL_EXTRA_BEFORE,
1600 pic_width, pic_height);
1601 src2 = lc->edge_emu_buffer + buf_offset2;
1602 src2stride = edge_emu_stride;
1604 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst2, dststride, src2, src2stride,
1605 block_w, block_h, mx, my,
1608 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst1, dststride, src1, src1stride,
1609 block_w, block_h, mx, my,
1611 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst2, dststride, src2, src2stride,
1612 block_w, block_h, mx, my,
1617 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1618 const Mv *mv, int y0, int height)
1620 int y = (mv->y >> 2) + y0 + height + 9;
1621 ff_thread_await_progress(&ref->tf, y, 0);
1624 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1626 int log2_cb_size, int partIdx)
1628 #define POS(c_idx, x, y) \
1629 &s->frame->data[c_idx][((y) >> s->sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1630 (((x) >> s->sps->hshift[c_idx]) << s->sps->pixel_shift)]
1631 HEVCLocalContext *lc = &s->HEVClc;
1633 struct MvField current_mv = {{{ 0 }}};
1635 int min_pu_width = s->sps->min_pu_width;
1637 MvField *tab_mvf = s->ref->tab_mvf;
1638 RefPicList *refPicList = s->ref->refPicList;
1639 HEVCFrame *ref0, *ref1;
1641 int tmpstride = MAX_PB_SIZE;
1643 uint8_t *dst0 = POS(0, x0, y0);
1644 uint8_t *dst1 = POS(1, x0, y0);
1645 uint8_t *dst2 = POS(2, x0, y0);
1646 int log2_min_cb_size = s->sps->log2_min_cb_size;
1647 int min_cb_width = s->sps->min_cb_width;
1648 int x_cb = x0 >> log2_min_cb_size;
1649 int y_cb = y0 >> log2_min_cb_size;
1655 int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1658 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1660 if (skip_flag || lc->pu.merge_flag) {
1661 if (s->sh.max_num_merge_cand > 1)
1662 merge_idx = ff_hevc_merge_idx_decode(s);
1666 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1667 partIdx, merge_idx, ¤t_mv);
1668 x_pu = x0 >> s->sps->log2_min_pu_size;
1669 y_pu = y0 >> s->sps->log2_min_pu_size;
1671 for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1672 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1673 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1675 enum InterPredIdc inter_pred_idc = PRED_L0;
1676 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1677 if (s->sh.slice_type == B_SLICE)
1678 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1680 if (inter_pred_idc != PRED_L1) {
1681 if (s->sh.nb_refs[L0]) {
1682 ref_idx[0] = ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1683 current_mv.ref_idx[0] = ref_idx[0];
1685 current_mv.pred_flag[0] = 1;
1686 hls_mvd_coding(s, x0, y0, 0);
1687 mvp_flag[0] = ff_hevc_mvp_lx_flag_decode(s);
1688 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1689 partIdx, merge_idx, ¤t_mv,
1691 current_mv.mv[0].x += lc->pu.mvd.x;
1692 current_mv.mv[0].y += lc->pu.mvd.y;
1695 if (inter_pred_idc != PRED_L0) {
1696 if (s->sh.nb_refs[L1]) {
1697 ref_idx[1] = ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1698 current_mv.ref_idx[1] = ref_idx[1];
1701 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1702 AV_ZERO32(&lc->pu.mvd);
1704 hls_mvd_coding(s, x0, y0, 1);
1707 current_mv.pred_flag[1] = 1;
1708 mvp_flag[1] = ff_hevc_mvp_lx_flag_decode(s);
1709 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1710 partIdx, merge_idx, ¤t_mv,
1712 current_mv.mv[1].x += lc->pu.mvd.x;
1713 current_mv.mv[1].y += lc->pu.mvd.y;
1716 x_pu = x0 >> s->sps->log2_min_pu_size;
1717 y_pu = y0 >> s->sps->log2_min_pu_size;
1719 for(j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1720 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1721 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1724 if (current_mv.pred_flag[0]) {
1725 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1728 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1730 if (current_mv.pred_flag[1]) {
1731 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1734 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1737 if (current_mv.pred_flag[0] && !current_mv.pred_flag[1]) {
1738 DECLARE_ALIGNED(16, int16_t, tmp[MAX_PB_SIZE * MAX_PB_SIZE]);
1739 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1741 luma_mc(s, tmp, tmpstride, ref0->frame,
1742 ¤t_mv.mv[0], x0, y0, nPbW, nPbH);
1744 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1745 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1746 s->hevcdsp.weighted_pred(s->sh.luma_log2_weight_denom,
1747 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1748 s->sh.luma_offset_l0[current_mv.ref_idx[0]],
1749 dst0, s->frame->linesize[0], tmp,
1750 tmpstride, nPbW, nPbH);
1752 s->hevcdsp.put_unweighted_pred(dst0, s->frame->linesize[0], tmp, tmpstride, nPbW, nPbH);
1754 chroma_mc(s, tmp, tmp2, tmpstride, ref0->frame,
1755 ¤t_mv.mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1757 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1758 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1759 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1760 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0],
1761 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0],
1762 dst1, s->frame->linesize[1], tmp, tmpstride,
1763 nPbW / 2, nPbH / 2);
1764 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1765 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1],
1766 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1],
1767 dst2, s->frame->linesize[2], tmp2, tmpstride,
1768 nPbW / 2, nPbH / 2);
1770 s->hevcdsp.put_unweighted_pred(dst1, s->frame->linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1771 s->hevcdsp.put_unweighted_pred(dst2, s->frame->linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1773 } else if (!current_mv.pred_flag[0] && current_mv.pred_flag[1]) {
1774 DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1775 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1780 luma_mc(s, tmp, tmpstride, ref1->frame,
1781 ¤t_mv.mv[1], x0, y0, nPbW, nPbH);
1783 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1784 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1785 s->hevcdsp.weighted_pred(s->sh.luma_log2_weight_denom,
1786 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1787 s->sh.luma_offset_l1[current_mv.ref_idx[1]],
1788 dst0, s->frame->linesize[0], tmp, tmpstride,
1791 s->hevcdsp.put_unweighted_pred(dst0, s->frame->linesize[0], tmp, tmpstride, nPbW, nPbH);
1794 chroma_mc(s, tmp, tmp2, tmpstride, ref1->frame,
1795 ¤t_mv.mv[1], x0/2, y0/2, nPbW/2, nPbH/2);
1797 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1798 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1799 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1800 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0],
1801 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0],
1802 dst1, s->frame->linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1803 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1804 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1],
1805 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1],
1806 dst2, s->frame->linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1808 s->hevcdsp.put_unweighted_pred(dst1, s->frame->linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1809 s->hevcdsp.put_unweighted_pred(dst2, s->frame->linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1811 } else if (current_mv.pred_flag[0] && current_mv.pred_flag[1]) {
1812 DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1813 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1814 DECLARE_ALIGNED(16, int16_t, tmp3[MAX_PB_SIZE * MAX_PB_SIZE]);
1815 DECLARE_ALIGNED(16, int16_t, tmp4[MAX_PB_SIZE * MAX_PB_SIZE]);
1816 HEVCFrame *ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1817 HEVCFrame *ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1822 luma_mc(s, tmp, tmpstride, ref0->frame,
1823 ¤t_mv.mv[0], x0, y0, nPbW, nPbH);
1824 luma_mc(s, tmp2, tmpstride, ref1->frame,
1825 ¤t_mv.mv[1], x0, y0, nPbW, nPbH);
1827 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1828 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1829 s->hevcdsp.weighted_pred_avg(s->sh.luma_log2_weight_denom,
1830 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1831 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1832 s->sh.luma_offset_l0[current_mv.ref_idx[0]],
1833 s->sh.luma_offset_l1[current_mv.ref_idx[1]],
1834 dst0, s->frame->linesize[0],
1835 tmp, tmp2, tmpstride, nPbW, nPbH);
1837 s->hevcdsp.put_weighted_pred_avg(dst0, s->frame->linesize[0],
1838 tmp, tmp2, tmpstride, nPbW, nPbH);
1841 chroma_mc(s, tmp, tmp2, tmpstride, ref0->frame,
1842 ¤t_mv.mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1843 chroma_mc(s, tmp3, tmp4, tmpstride, ref1->frame,
1844 ¤t_mv.mv[1], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1846 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1847 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1848 s->hevcdsp.weighted_pred_avg(s->sh.chroma_log2_weight_denom,
1849 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0],
1850 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0],
1851 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0],
1852 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0],
1853 dst1, s->frame->linesize[1], tmp, tmp3,
1854 tmpstride, nPbW / 2, nPbH / 2);
1855 s->hevcdsp.weighted_pred_avg(s->sh.chroma_log2_weight_denom,
1856 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1],
1857 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1],
1858 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1],
1859 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1],
1860 dst2, s->frame->linesize[2], tmp2, tmp4,
1861 tmpstride, nPbW / 2, nPbH / 2);
1863 s->hevcdsp.put_weighted_pred_avg(dst1, s->frame->linesize[1], tmp, tmp3, tmpstride, nPbW/2, nPbH/2);
1864 s->hevcdsp.put_weighted_pred_avg(dst2, s->frame->linesize[2], tmp2, tmp4, tmpstride, nPbW/2, nPbH/2);
1872 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1873 int prev_intra_luma_pred_flag)
1875 HEVCLocalContext *lc = &s->HEVClc;
1876 int x_pu = x0 >> s->sps->log2_min_pu_size;
1877 int y_pu = y0 >> s->sps->log2_min_pu_size;
1878 int min_pu_width = s->sps->min_pu_width;
1879 int size_in_pus = pu_size >> s->sps->log2_min_pu_size;
1880 int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1);
1881 int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1);
1883 int cand_up = (lc->ctb_up_flag || y0b) ?
1884 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1885 int cand_left = (lc->ctb_left_flag || x0b) ?
1886 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1888 int y_ctb = (y0 >> (s->sps->log2_ctb_size)) << (s->sps->log2_ctb_size);
1890 MvField *tab_mvf = s->ref->tab_mvf;
1891 int intra_pred_mode;
1895 // intra_pred_mode prediction does not cross vertical CTB boundaries
1896 if ((y0 - 1) < y_ctb)
1899 if (cand_left == cand_up) {
1900 if (cand_left < 2) {
1901 candidate[0] = INTRA_PLANAR;
1902 candidate[1] = INTRA_DC;
1903 candidate[2] = INTRA_ANGULAR_26;
1905 candidate[0] = cand_left;
1906 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1907 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1910 candidate[0] = cand_left;
1911 candidate[1] = cand_up;
1912 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1913 candidate[2] = INTRA_PLANAR;
1914 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1915 candidate[2] = INTRA_DC;
1917 candidate[2] = INTRA_ANGULAR_26;
1921 if (prev_intra_luma_pred_flag) {
1922 intra_pred_mode = candidate[lc->pu.mpm_idx];
1924 if (candidate[0] > candidate[1])
1925 FFSWAP(uint8_t, candidate[0], candidate[1]);
1926 if (candidate[0] > candidate[2])
1927 FFSWAP(uint8_t, candidate[0], candidate[2]);
1928 if (candidate[1] > candidate[2])
1929 FFSWAP(uint8_t, candidate[1], candidate[2]);
1931 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1932 for (i = 0; i < 3; i++)
1933 if (intra_pred_mode >= candidate[i])
1937 /* write the intra prediction units into the mv array */
1940 for (i = 0; i < size_in_pus; i++) {
1941 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1942 intra_pred_mode, size_in_pus);
1944 for (j = 0; j < size_in_pus; j++) {
1945 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].is_intra = 1;
1946 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[0] = 0;
1947 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[1] = 0;
1948 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[0] = 0;
1949 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[1] = 0;
1950 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].x = 0;
1951 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].y = 0;
1952 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].x = 0;
1953 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].y = 0;
1957 return intra_pred_mode;
1960 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1961 int log2_cb_size, int ct_depth)
1963 int length = (1 << log2_cb_size) >> s->sps->log2_min_cb_size;
1964 int x_cb = x0 >> s->sps->log2_min_cb_size;
1965 int y_cb = y0 >> s->sps->log2_min_cb_size;
1968 for (y = 0; y < length; y++)
1969 memset(&s->tab_ct_depth[(y_cb + y) * s->sps->min_cb_width + x_cb],
1973 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1976 HEVCLocalContext *lc = &s->HEVClc;
1977 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1978 uint8_t prev_intra_luma_pred_flag[4];
1979 int split = lc->cu.part_mode == PART_NxN;
1980 int pb_size = (1 << log2_cb_size) >> split;
1981 int side = split + 1;
1985 for (i = 0; i < side; i++)
1986 for (j = 0; j < side; j++)
1987 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1989 for (i = 0; i < side; i++) {
1990 for (j = 0; j < side; j++) {
1991 if (prev_intra_luma_pred_flag[2 * i + j])
1992 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
1994 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
1996 lc->pu.intra_pred_mode[2 * i + j] =
1997 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1998 prev_intra_luma_pred_flag[2 * i + j]);
2002 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
2003 if (chroma_mode != 4) {
2004 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
2005 lc->pu.intra_pred_mode_c = 34;
2007 lc->pu.intra_pred_mode_c = intra_chroma_table[chroma_mode];
2009 lc->pu.intra_pred_mode_c = lc->pu.intra_pred_mode[0];
2013 static void intra_prediction_unit_default_value(HEVCContext *s,
2017 HEVCLocalContext *lc = &s->HEVClc;
2018 int pb_size = 1 << log2_cb_size;
2019 int size_in_pus = pb_size >> s->sps->log2_min_pu_size;
2020 int min_pu_width = s->sps->min_pu_width;
2021 MvField *tab_mvf = s->ref->tab_mvf;
2022 int x_pu = x0 >> s->sps->log2_min_pu_size;
2023 int y_pu = y0 >> s->sps->log2_min_pu_size;
2026 if (size_in_pus == 0)
2028 for (j = 0; j < size_in_pus; j++) {
2029 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
2030 for (k = 0; k < size_in_pus; k++)
2031 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].is_intra = lc->cu.pred_mode == MODE_INTRA;
2035 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
2037 int cb_size = 1 << log2_cb_size;
2038 HEVCLocalContext *lc = &s->HEVClc;
2039 int log2_min_cb_size = s->sps->log2_min_cb_size;
2040 int length = cb_size >> log2_min_cb_size;
2041 int min_cb_width = s->sps->min_cb_width;
2042 int x_cb = x0 >> log2_min_cb_size;
2043 int y_cb = y0 >> log2_min_cb_size;
2048 lc->cu.pred_mode = MODE_INTRA;
2049 lc->cu.part_mode = PART_2Nx2N;
2050 lc->cu.intra_split_flag = 0;
2052 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
2053 for (x = 0; x < 4; x++)
2054 lc->pu.intra_pred_mode[x] = 1;
2055 if (s->pps->transquant_bypass_enable_flag) {
2056 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
2057 if (lc->cu.cu_transquant_bypass_flag)
2058 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2060 lc->cu.cu_transquant_bypass_flag = 0;
2062 if (s->sh.slice_type != I_SLICE) {
2063 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
2065 x = y_cb * min_cb_width + x_cb;
2066 for (y = 0; y < length; y++) {
2067 memset(&s->skip_flag[x], skip_flag, length);
2070 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2073 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2074 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0);
2075 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2077 if (!s->sh.disable_deblocking_filter_flag)
2078 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2082 if (s->sh.slice_type != I_SLICE)
2083 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2084 if (lc->cu.pred_mode != MODE_INTRA ||
2085 log2_cb_size == s->sps->log2_min_cb_size) {
2086 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2087 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2088 lc->cu.pred_mode == MODE_INTRA;
2091 if (lc->cu.pred_mode == MODE_INTRA) {
2092 if (lc->cu.part_mode == PART_2Nx2N && s->sps->pcm_enabled_flag &&
2093 log2_cb_size >= s->sps->pcm.log2_min_pcm_cb_size &&
2094 log2_cb_size <= s->sps->pcm.log2_max_pcm_cb_size) {
2095 pcm_flag = ff_hevc_pcm_flag_decode(s);
2098 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2099 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2100 if (s->sps->pcm.loop_filter_disable_flag)
2101 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2106 intra_prediction_unit(s, x0, y0, log2_cb_size);
2109 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2110 switch (lc->cu.part_mode) {
2112 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0);
2115 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0);
2116 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1);
2119 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0);
2120 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1);
2123 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0);
2124 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1);
2127 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0);
2128 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1);
2131 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0);
2132 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1);
2135 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0);
2136 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1);
2139 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0);
2140 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1);
2141 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2);
2142 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3);
2148 int rqt_root_cbf = 1;
2150 if (lc->cu.pred_mode != MODE_INTRA &&
2151 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2152 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2155 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2156 s->sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2157 s->sps->max_transform_hierarchy_depth_inter;
2158 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2160 log2_cb_size, 0, 0, 0, 0);
2164 if (!s->sh.disable_deblocking_filter_flag)
2165 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2170 if (s->pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2171 ff_hevc_set_qPy(s, x0, y0, x0, y0, log2_cb_size);
2173 x = y_cb * min_cb_width + x_cb;
2174 for (y = 0; y < length; y++) {
2175 memset(&s->qp_y_tab[x], lc->qp_y, length);
2179 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct.depth);
2184 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2185 int log2_cb_size, int cb_depth)
2187 HEVCLocalContext *lc = &s->HEVClc;
2188 const int cb_size = 1 << log2_cb_size;
2191 lc->ct.depth = cb_depth;
2192 if (x0 + cb_size <= s->sps->width &&
2193 y0 + cb_size <= s->sps->height &&
2194 log2_cb_size > s->sps->log2_min_cb_size) {
2195 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2197 split_cu = (log2_cb_size > s->sps->log2_min_cb_size);
2199 if (s->pps->cu_qp_delta_enabled_flag &&
2200 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth) {
2201 lc->tu.is_cu_qp_delta_coded = 0;
2202 lc->tu.cu_qp_delta = 0;
2206 const int cb_size_split = cb_size >> 1;
2207 const int x1 = x0 + cb_size_split;
2208 const int y1 = y0 + cb_size_split;
2213 #define SUBDIVIDE(x, y) \
2215 if (x < s->sps->width && y < s->sps->height) { \
2216 int ret = hls_coding_quadtree(s, x, y, log2_cb_size, cb_depth);\
2227 int ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2235 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2238 HEVCLocalContext *lc = &s->HEVClc;
2239 int ctb_size = 1 << s->sps->log2_ctb_size;
2240 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2241 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2243 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2245 if (s->pps->entropy_coding_sync_enabled_flag) {
2246 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2247 lc->first_qp_group = 1;
2248 lc->end_of_tiles_x = s->sps->width;
2249 } else if (s->pps->tiles_enabled_flag) {
2250 if (ctb_addr_ts && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1]) {
2251 int idxX = s->pps->col_idxX[x_ctb >> s->sps->log2_ctb_size];
2252 lc->start_of_tiles_x = x_ctb;
2253 lc->end_of_tiles_x = x_ctb + (s->pps->column_width[idxX] << s->sps->log2_ctb_size);
2254 lc->first_qp_group = 1;
2257 lc->end_of_tiles_x = s->sps->width;
2260 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->sps->height);
2262 lc->boundary_flags = 0;
2263 if (s->pps->tiles_enabled_flag) {
2264 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]])
2265 lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2266 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2267 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2268 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]])
2269 lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2270 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->sps->ctb_width])
2271 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2273 if (!ctb_addr_in_slice > 0)
2274 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2275 if (ctb_addr_in_slice < s->sps->ctb_width)
2276 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2279 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2280 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2281 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]]));
2282 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]]));
2285 static int hls_slice_data(HEVCContext *s)
2287 int ctb_size = 1 << s->sps->log2_ctb_size;
2291 int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2294 while (more_data && ctb_addr_ts < s->sps->ctb_size) {
2295 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2297 x_ctb = (ctb_addr_rs % ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2298 y_ctb = (ctb_addr_rs / ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2299 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2301 ff_hevc_cabac_init(s, ctb_addr_ts);
2303 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2305 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2306 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2307 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2309 ret = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2312 more_data = !ff_hevc_end_of_slice_flag_decode(s);
2315 ff_hevc_save_states(s, ctb_addr_ts);
2316 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2319 if (x_ctb + ctb_size >= s->sps->width &&
2320 y_ctb + ctb_size >= s->sps->height)
2321 ff_hevc_hls_filter(s, x_ctb, y_ctb);
2327 * @return AVERROR_INVALIDDATA if the packet is not a valid NAL unit,
2328 * 0 if the unit should be skipped, 1 otherwise
2330 static int hls_nal_unit(HEVCContext *s)
2332 GetBitContext *gb = &s->HEVClc.gb;
2335 if (get_bits1(gb) != 0)
2336 return AVERROR_INVALIDDATA;
2338 s->nal_unit_type = get_bits(gb, 6);
2340 nuh_layer_id = get_bits(gb, 6);
2341 s->temporal_id = get_bits(gb, 3) - 1;
2342 if (s->temporal_id < 0)
2343 return AVERROR_INVALIDDATA;
2345 av_log(s->avctx, AV_LOG_DEBUG,
2346 "nal_unit_type: %d, nuh_layer_id: %dtemporal_id: %d\n",
2347 s->nal_unit_type, nuh_layer_id, s->temporal_id);
2349 return nuh_layer_id == 0;
2352 static void restore_tqb_pixels(HEVCContext *s)
2354 int min_pu_size = 1 << s->sps->log2_min_pu_size;
2357 for (c_idx = 0; c_idx < 3; c_idx++) {
2358 ptrdiff_t stride = s->frame->linesize[c_idx];
2359 int hshift = s->sps->hshift[c_idx];
2360 int vshift = s->sps->vshift[c_idx];
2361 for (y = 0; y < s->sps->min_pu_height; y++) {
2362 for (x = 0; x < s->sps->min_pu_width; x++) {
2363 if (s->is_pcm[y * s->sps->min_pu_width + x]) {
2365 int len = min_pu_size >> hshift;
2366 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)];
2367 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)];
2368 for (n = 0; n < (min_pu_size >> vshift); n++) {
2369 memcpy(dst, src, len);
2379 static int set_side_data(HEVCContext *s)
2381 AVFrame *out = s->ref->frame;
2383 if (s->sei_frame_packing_present &&
2384 s->frame_packing_arrangement_type >= 3 &&
2385 s->frame_packing_arrangement_type <= 5 &&
2386 s->content_interpretation_type > 0 &&
2387 s->content_interpretation_type < 3) {
2388 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2390 return AVERROR(ENOMEM);
2392 switch (s->frame_packing_arrangement_type) {
2394 if (s->quincunx_subsampling)
2395 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2397 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2400 stereo->type = AV_STEREO3D_TOPBOTTOM;
2403 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2407 if (s->content_interpretation_type == 2)
2408 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2411 if (s->sei_display_orientation_present &&
2412 (s->sei_anticlockwise_rotation || s->sei_hflip || s->sei_vflip)) {
2413 double angle = s->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
2414 AVFrameSideData *rotation = av_frame_new_side_data(out,
2415 AV_FRAME_DATA_DISPLAYMATRIX,
2416 sizeof(int32_t) * 9);
2418 return AVERROR(ENOMEM);
2420 av_display_rotation_set((int32_t *)rotation->data, angle);
2421 av_display_matrix_flip((int32_t *)rotation->data,
2422 s->sei_hflip, s->sei_vflip);
2428 static int hevc_frame_start(HEVCContext *s)
2430 HEVCLocalContext *lc = &s->HEVClc;
2433 memset(s->horizontal_bs, 0, 2 * s->bs_width * (s->bs_height + 1));
2434 memset(s->vertical_bs, 0, 2 * s->bs_width * (s->bs_height + 1));
2435 memset(s->cbf_luma, 0, s->sps->min_tb_width * s->sps->min_tb_height);
2436 memset(s->is_pcm, 0, s->sps->min_pu_width * s->sps->min_pu_height);
2438 lc->start_of_tiles_x = 0;
2440 s->first_nal_type = s->nal_unit_type;
2442 if (s->pps->tiles_enabled_flag)
2443 lc->end_of_tiles_x = s->pps->column_width[0] << s->sps->log2_ctb_size;
2445 ret = ff_hevc_set_new_ref(s, s->sps->sao_enabled ? &s->sao_frame : &s->frame,
2450 ret = ff_hevc_frame_rps(s);
2452 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2456 s->ref->frame->key_frame = IS_IRAP(s);
2458 ret = set_side_data(s);
2462 av_frame_unref(s->output_frame);
2463 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2467 ff_thread_finish_setup(s->avctx);
2473 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2478 static int decode_nal_unit(HEVCContext *s, const uint8_t *nal, int length)
2480 HEVCLocalContext *lc = &s->HEVClc;
2481 GetBitContext *gb = &lc->gb;
2482 int ctb_addr_ts, ret;
2484 ret = init_get_bits8(gb, nal, length);
2488 ret = hls_nal_unit(s);
2490 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit %d, skipping.\n",
2496 switch (s->nal_unit_type) {
2498 ret = ff_hevc_decode_nal_vps(s);
2503 ret = ff_hevc_decode_nal_sps(s);
2508 ret = ff_hevc_decode_nal_pps(s);
2512 case NAL_SEI_PREFIX:
2513 case NAL_SEI_SUFFIX:
2514 ret = ff_hevc_decode_nal_sei(s);
2525 case NAL_BLA_W_RADL:
2527 case NAL_IDR_W_RADL:
2534 ret = hls_slice_header(s);
2538 if (s->max_ra == INT_MAX) {
2539 if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
2543 s->max_ra = INT_MIN;
2547 if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
2548 s->poc <= s->max_ra) {
2552 if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
2553 s->max_ra = INT_MIN;
2556 if (s->sh.first_slice_in_pic_flag) {
2557 ret = hevc_frame_start(s);
2560 } else if (!s->ref) {
2561 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2565 if (s->nal_unit_type != s->first_nal_type) {
2566 av_log(s->avctx, AV_LOG_ERROR,
2567 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2568 s->first_nal_type, s->nal_unit_type);
2569 return AVERROR_INVALIDDATA;
2572 if (!s->sh.dependent_slice_segment_flag &&
2573 s->sh.slice_type != I_SLICE) {
2574 ret = ff_hevc_slice_rpl(s);
2576 av_log(s->avctx, AV_LOG_WARNING,
2577 "Error constructing the reference lists for the current slice.\n");
2582 ctb_addr_ts = hls_slice_data(s);
2583 if (ctb_addr_ts >= (s->sps->ctb_width * s->sps->ctb_height)) {
2585 if ((s->pps->transquant_bypass_enable_flag ||
2586 (s->sps->pcm.loop_filter_disable_flag && s->sps->pcm_enabled_flag)) &&
2587 s->sps->sao_enabled)
2588 restore_tqb_pixels(s);
2591 if (ctb_addr_ts < 0) {
2598 s->seq_decode = (s->seq_decode + 1) & 0xff;
2599 s->max_ra = INT_MAX;
2605 av_log(s->avctx, AV_LOG_INFO,
2606 "Skipping NAL unit %d\n", s->nal_unit_type);
2611 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2616 /* FIXME: This is adapted from ff_h264_decode_nal, avoiding duplication
2617 * between these functions would be nice. */
2618 static int extract_rbsp(const uint8_t *src, int length,
2624 #define STARTCODE_TEST \
2625 if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \
2626 if (src[i + 2] != 3) { \
2627 /* startcode, so we must be past the end */ \
2632 #if HAVE_FAST_UNALIGNED
2633 #define FIND_FIRST_ZERO \
2634 if (i > 0 && !src[i]) \
2639 for (i = 0; i + 1 < length; i += 9) {
2640 if (!((~AV_RN64A(src + i) &
2641 (AV_RN64A(src + i) - 0x0100010001000101ULL)) &
2642 0x8000800080008080ULL))
2649 for (i = 0; i + 1 < length; i += 5) {
2650 if (!((~AV_RN32A(src + i) &
2651 (AV_RN32A(src + i) - 0x01000101U)) &
2658 #endif /* HAVE_FAST_64BIT */
2660 for (i = 0; i + 1 < length; i += 2) {
2663 if (i > 0 && src[i - 1] == 0)
2667 #endif /* HAVE_FAST_UNALIGNED */
2669 if (i >= length - 1) { // no escaped 0
2675 av_fast_malloc(&nal->rbsp_buffer, &nal->rbsp_buffer_size,
2676 length + FF_INPUT_BUFFER_PADDING_SIZE);
2677 if (!nal->rbsp_buffer)
2678 return AVERROR(ENOMEM);
2680 dst = nal->rbsp_buffer;
2682 memcpy(dst, src, i);
2684 while (si + 2 < length) {
2685 // remove escapes (very rare 1:2^22)
2686 if (src[si + 2] > 3) {
2687 dst[di++] = src[si++];
2688 dst[di++] = src[si++];
2689 } else if (src[si] == 0 && src[si + 1] == 0) {
2690 if (src[si + 2] == 3) { // escape
2696 } else // next start code
2700 dst[di++] = src[si++];
2703 dst[di++] = src[si++];
2706 memset(dst + di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2713 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2715 int i, consumed, ret = 0;
2720 /* split the input packet into NAL units, so we know the upper bound on the
2721 * number of slices in the frame */
2723 while (length >= 4) {
2725 int extract_length = 0;
2729 for (i = 0; i < s->nal_length_size; i++)
2730 extract_length = (extract_length << 8) | buf[i];
2731 buf += s->nal_length_size;
2732 length -= s->nal_length_size;
2734 if (extract_length > length) {
2735 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit size.\n");
2736 ret = AVERROR_INVALIDDATA;
2745 if (buf[0] != 0 || buf[1] != 0 || buf[2] != 1) {
2746 ret = AVERROR_INVALIDDATA;
2752 extract_length = length;
2755 if (s->nals_allocated < s->nb_nals + 1) {
2756 int new_size = s->nals_allocated + 1;
2757 HEVCNAL *tmp = av_realloc_array(s->nals, new_size, sizeof(*tmp));
2759 ret = AVERROR(ENOMEM);
2763 memset(s->nals + s->nals_allocated, 0,
2764 (new_size - s->nals_allocated) * sizeof(*tmp));
2765 s->nals_allocated = new_size;
2767 nal = &s->nals[s->nb_nals++];
2769 consumed = extract_rbsp(buf, extract_length, nal);
2775 ret = init_get_bits8(&s->HEVClc.gb, nal->data, nal->size);
2780 if (s->nal_unit_type == NAL_EOB_NUT ||
2781 s->nal_unit_type == NAL_EOS_NUT)
2788 /* parse the NAL units */
2789 for (i = 0; i < s->nb_nals; i++) {
2790 int ret = decode_nal_unit(s, s->nals[i].data, s->nals[i].size);
2792 av_log(s->avctx, AV_LOG_WARNING,
2793 "Error parsing NAL unit #%d.\n", i);
2800 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2805 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2808 for (i = 0; i < 16; i++)
2809 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
2812 static int verify_md5(HEVCContext *s, AVFrame *frame)
2814 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
2819 return AVERROR(EINVAL);
2821 pixel_shift = desc->comp[0].depth_minus1 > 7;
2823 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
2826 /* the checksums are LE, so we have to byteswap for >8bpp formats
2829 if (pixel_shift && !s->checksum_buf) {
2830 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
2831 FFMAX3(frame->linesize[0], frame->linesize[1],
2832 frame->linesize[2]));
2833 if (!s->checksum_buf)
2834 return AVERROR(ENOMEM);
2838 for (i = 0; frame->data[i]; i++) {
2839 int width = s->avctx->coded_width;
2840 int height = s->avctx->coded_height;
2841 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
2842 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
2845 av_md5_init(s->md5_ctx);
2846 for (j = 0; j < h; j++) {
2847 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
2850 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
2851 (const uint16_t *) src, w);
2852 src = s->checksum_buf;
2855 av_md5_update(s->md5_ctx, src, w << pixel_shift);
2857 av_md5_final(s->md5_ctx, md5);
2859 if (!memcmp(md5, s->md5[i], 16)) {
2860 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
2861 print_md5(s->avctx, AV_LOG_DEBUG, md5);
2862 av_log (s->avctx, AV_LOG_DEBUG, "; ");
2864 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
2865 print_md5(s->avctx, AV_LOG_ERROR, md5);
2866 av_log (s->avctx, AV_LOG_ERROR, " != ");
2867 print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
2868 av_log (s->avctx, AV_LOG_ERROR, "\n");
2869 return AVERROR_INVALIDDATA;
2873 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2878 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
2882 HEVCContext *s = avctx->priv_data;
2885 ret = ff_hevc_output_frame(s, data, 1);
2894 ret = decode_nal_units(s, avpkt->data, avpkt->size);
2898 /* verify the SEI checksum */
2899 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
2901 ret = verify_md5(s, s->ref->frame);
2902 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
2903 ff_hevc_unref_frame(s, s->ref, ~0);
2909 if (s->is_decoded) {
2910 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
2914 if (s->output_frame->buf[0]) {
2915 av_frame_move_ref(data, s->output_frame);
2922 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
2924 int ret = ff_thread_ref_frame(&dst->tf, &src->tf);
2928 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
2929 if (!dst->tab_mvf_buf)
2931 dst->tab_mvf = src->tab_mvf;
2933 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
2934 if (!dst->rpl_tab_buf)
2936 dst->rpl_tab = src->rpl_tab;
2938 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
2942 dst->poc = src->poc;
2943 dst->ctb_count = src->ctb_count;
2944 dst->window = src->window;
2945 dst->flags = src->flags;
2946 dst->sequence = src->sequence;
2950 ff_hevc_unref_frame(s, dst, ~0);
2951 return AVERROR(ENOMEM);
2954 static av_cold int hevc_decode_free(AVCodecContext *avctx)
2956 HEVCContext *s = avctx->priv_data;
2961 av_freep(&s->md5_ctx);
2963 av_frame_free(&s->tmp_frame);
2964 av_frame_free(&s->output_frame);
2966 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2967 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
2968 av_frame_free(&s->DPB[i].frame);
2971 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++)
2972 av_buffer_unref(&s->vps_list[i]);
2973 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++)
2974 av_buffer_unref(&s->sps_list[i]);
2975 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
2976 av_buffer_unref(&s->pps_list[i]);
2978 for (i = 0; i < s->nals_allocated; i++)
2979 av_freep(&s->nals[i].rbsp_buffer);
2981 s->nals_allocated = 0;
2986 static av_cold int hevc_init_context(AVCodecContext *avctx)
2988 HEVCContext *s = avctx->priv_data;
2993 s->tmp_frame = av_frame_alloc();
2997 s->output_frame = av_frame_alloc();
2998 if (!s->output_frame)
3001 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3002 s->DPB[i].frame = av_frame_alloc();
3003 if (!s->DPB[i].frame)
3005 s->DPB[i].tf.f = s->DPB[i].frame;
3008 s->max_ra = INT_MAX;
3010 s->md5_ctx = av_md5_alloc();
3014 ff_bswapdsp_init(&s->bdsp);
3016 s->context_initialized = 1;
3021 hevc_decode_free(avctx);
3022 return AVERROR(ENOMEM);
3025 static int hevc_update_thread_context(AVCodecContext *dst,
3026 const AVCodecContext *src)
3028 HEVCContext *s = dst->priv_data;
3029 HEVCContext *s0 = src->priv_data;
3032 if (!s->context_initialized) {
3033 ret = hevc_init_context(dst);
3038 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3039 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3040 if (s0->DPB[i].frame->buf[0]) {
3041 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3047 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++) {
3048 av_buffer_unref(&s->vps_list[i]);
3049 if (s0->vps_list[i]) {
3050 s->vps_list[i] = av_buffer_ref(s0->vps_list[i]);
3051 if (!s->vps_list[i])
3052 return AVERROR(ENOMEM);
3056 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++) {
3057 av_buffer_unref(&s->sps_list[i]);
3058 if (s0->sps_list[i]) {
3059 s->sps_list[i] = av_buffer_ref(s0->sps_list[i]);
3060 if (!s->sps_list[i])
3061 return AVERROR(ENOMEM);
3065 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++) {
3066 av_buffer_unref(&s->pps_list[i]);
3067 if (s0->pps_list[i]) {
3068 s->pps_list[i] = av_buffer_ref(s0->pps_list[i]);
3069 if (!s->pps_list[i])
3070 return AVERROR(ENOMEM);
3074 if (s->sps != s0->sps)
3075 ret = set_sps(s, s0->sps);
3077 s->seq_decode = s0->seq_decode;
3078 s->seq_output = s0->seq_output;
3079 s->pocTid0 = s0->pocTid0;
3080 s->max_ra = s0->max_ra;
3082 s->is_nalff = s0->is_nalff;
3083 s->nal_length_size = s0->nal_length_size;
3086 s->seq_decode = (s->seq_decode + 1) & 0xff;
3087 s->max_ra = INT_MAX;
3093 static int hevc_decode_extradata(HEVCContext *s)
3095 AVCodecContext *avctx = s->avctx;
3099 bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
3101 if (avctx->extradata_size > 3 &&
3102 (avctx->extradata[0] || avctx->extradata[1] ||
3103 avctx->extradata[2] > 1)) {
3104 /* It seems the extradata is encoded as hvcC format.
3105 * Temporarily, we support configurationVersion==0 until 14496-15 3rd
3106 * is finalized. When finalized, configurationVersion will be 1 and we
3107 * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
3108 int i, j, num_arrays, nal_len_size;
3112 bytestream2_skip(&gb, 21);
3113 nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
3114 num_arrays = bytestream2_get_byte(&gb);
3116 /* nal units in the hvcC always have length coded with 2 bytes,
3117 * so put a fake nal_length_size = 2 while parsing them */
3118 s->nal_length_size = 2;
3120 /* Decode nal units from hvcC. */
3121 for (i = 0; i < num_arrays; i++) {
3122 int type = bytestream2_get_byte(&gb) & 0x3f;
3123 int cnt = bytestream2_get_be16(&gb);
3125 for (j = 0; j < cnt; j++) {
3126 // +2 for the nal size field
3127 int nalsize = bytestream2_peek_be16(&gb) + 2;
3128 if (bytestream2_get_bytes_left(&gb) < nalsize) {
3129 av_log(s->avctx, AV_LOG_ERROR,
3130 "Invalid NAL unit size in extradata.\n");
3131 return AVERROR_INVALIDDATA;
3134 ret = decode_nal_units(s, gb.buffer, nalsize);
3136 av_log(avctx, AV_LOG_ERROR,
3137 "Decoding nal unit %d %d from hvcC failed\n",
3141 bytestream2_skip(&gb, nalsize);
3145 /* Now store right nal length size, that will be used to parse
3147 s->nal_length_size = nal_len_size;
3150 ret = decode_nal_units(s, avctx->extradata, avctx->extradata_size);
3157 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3159 HEVCContext *s = avctx->priv_data;
3162 ff_init_cabac_states();
3164 avctx->internal->allocate_progress = 1;
3166 ret = hevc_init_context(avctx);
3170 if (avctx->extradata_size > 0 && avctx->extradata) {
3171 ret = hevc_decode_extradata(s);
3173 hevc_decode_free(avctx);
3181 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3183 HEVCContext *s = avctx->priv_data;
3186 memset(s, 0, sizeof(*s));
3188 ret = hevc_init_context(avctx);
3195 static void hevc_decode_flush(AVCodecContext *avctx)
3197 HEVCContext *s = avctx->priv_data;
3198 ff_hevc_flush_dpb(s);
3199 s->max_ra = INT_MAX;
3202 #define OFFSET(x) offsetof(HEVCContext, x)
3203 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3205 static const AVProfile profiles[] = {
3206 { FF_PROFILE_HEVC_MAIN, "Main" },
3207 { FF_PROFILE_HEVC_MAIN_10, "Main 10" },
3208 { FF_PROFILE_HEVC_MAIN_STILL_PICTURE, "Main Still Picture" },
3209 { FF_PROFILE_UNKNOWN },
3212 static const AVOption options[] = {
3213 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3214 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3218 static const AVClass hevc_decoder_class = {
3219 .class_name = "HEVC decoder",
3220 .item_name = av_default_item_name,
3222 .version = LIBAVUTIL_VERSION_INT,
3225 AVCodec ff_hevc_decoder = {
3227 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3228 .type = AVMEDIA_TYPE_VIDEO,
3229 .id = AV_CODEC_ID_HEVC,
3230 .priv_data_size = sizeof(HEVCContext),
3231 .priv_class = &hevc_decoder_class,
3232 .init = hevc_decode_init,
3233 .close = hevc_decode_free,
3234 .decode = hevc_decode_frame,
3235 .flush = hevc_decode_flush,
3236 .update_thread_context = hevc_update_thread_context,
3237 .init_thread_copy = hevc_init_thread_copy,
3238 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY |
3239 CODEC_CAP_FRAME_THREADS,
3240 .profiles = NULL_IF_CONFIG_SMALL(profiles),