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/internal.h"
29 #include "libavutil/md5.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/pixdesc.h"
32 #include "libavutil/stereo3d.h"
34 #include "bytestream.h"
35 #include "cabac_functions.h"
40 const uint8_t ff_hevc_qpel_extra_before[4] = { 0, 3, 3, 2 };
41 const uint8_t ff_hevc_qpel_extra_after[4] = { 0, 3, 4, 4 };
42 const uint8_t ff_hevc_qpel_extra[4] = { 0, 6, 7, 6 };
44 static const uint8_t scan_1x1[1] = { 0 };
46 static const uint8_t horiz_scan2x2_x[4] = { 0, 1, 0, 1 };
48 static const uint8_t horiz_scan2x2_y[4] = { 0, 0, 1, 1 };
50 static const uint8_t horiz_scan4x4_x[16] = {
57 static const uint8_t horiz_scan4x4_y[16] = {
64 static const uint8_t horiz_scan8x8_inv[8][8] = {
65 { 0, 1, 2, 3, 16, 17, 18, 19, },
66 { 4, 5, 6, 7, 20, 21, 22, 23, },
67 { 8, 9, 10, 11, 24, 25, 26, 27, },
68 { 12, 13, 14, 15, 28, 29, 30, 31, },
69 { 32, 33, 34, 35, 48, 49, 50, 51, },
70 { 36, 37, 38, 39, 52, 53, 54, 55, },
71 { 40, 41, 42, 43, 56, 57, 58, 59, },
72 { 44, 45, 46, 47, 60, 61, 62, 63, },
75 static const uint8_t diag_scan2x2_x[4] = { 0, 0, 1, 1 };
77 static const uint8_t diag_scan2x2_y[4] = { 0, 1, 0, 1 };
79 static const uint8_t diag_scan2x2_inv[2][2] = {
84 const uint8_t ff_hevc_diag_scan4x4_x[16] = {
91 const uint8_t ff_hevc_diag_scan4x4_y[16] = {
98 static const uint8_t diag_scan4x4_inv[4][4] = {
105 const uint8_t ff_hevc_diag_scan8x8_x[64] = {
124 const uint8_t ff_hevc_diag_scan8x8_y[64] = {
143 static const uint8_t diag_scan8x8_inv[8][8] = {
144 { 0, 2, 5, 9, 14, 20, 27, 35, },
145 { 1, 4, 8, 13, 19, 26, 34, 42, },
146 { 3, 7, 12, 18, 25, 33, 41, 48, },
147 { 6, 11, 17, 24, 32, 40, 47, 53, },
148 { 10, 16, 23, 31, 39, 46, 52, 57, },
149 { 15, 22, 30, 38, 45, 51, 56, 60, },
150 { 21, 29, 37, 44, 50, 55, 59, 62, },
151 { 28, 36, 43, 49, 54, 58, 61, 63, },
155 * NOTE: Each function hls_foo correspond to the function foo in the
156 * specification (HLS stands for High Level Syntax).
163 /* free everything allocated by pic_arrays_init() */
164 static void pic_arrays_free(HEVCContext *s)
167 av_freep(&s->deblock);
168 av_freep(&s->split_cu_flag);
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 = width * height;
195 int pic_size_in_ctb = ((width >> log2_min_cb_size) + 1) *
196 ((height >> log2_min_cb_size) + 1);
197 int ctb_count = sps->ctb_width * sps->ctb_height;
198 int min_pu_size = sps->min_pu_width * sps->min_pu_height;
200 s->bs_width = width >> 3;
201 s->bs_height = height >> 3;
203 s->sao = av_mallocz_array(ctb_count, sizeof(*s->sao));
204 s->deblock = av_mallocz_array(ctb_count, sizeof(*s->deblock));
205 s->split_cu_flag = av_malloc(pic_size);
206 if (!s->sao || !s->deblock || !s->split_cu_flag)
209 s->skip_flag = av_malloc(pic_size_in_ctb);
210 s->tab_ct_depth = av_malloc(sps->min_cb_height * sps->min_cb_width);
211 if (!s->skip_flag || !s->tab_ct_depth)
214 s->cbf_luma = av_malloc(sps->min_tb_width * sps->min_tb_height);
215 s->tab_ipm = av_malloc(min_pu_size);
216 s->is_pcm = av_malloc(min_pu_size);
217 if (!s->tab_ipm || !s->cbf_luma || !s->is_pcm)
220 s->filter_slice_edges = av_malloc(ctb_count);
221 s->tab_slice_address = av_malloc(pic_size_in_ctb *
222 sizeof(*s->tab_slice_address));
223 s->qp_y_tab = av_malloc(pic_size_in_ctb *
224 sizeof(*s->qp_y_tab));
225 if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address)
228 s->horizontal_bs = av_mallocz(2 * s->bs_width * (s->bs_height + 1));
229 s->vertical_bs = av_mallocz(2 * s->bs_width * (s->bs_height + 1));
230 if (!s->horizontal_bs || !s->vertical_bs)
233 s->tab_mvf_pool = av_buffer_pool_init(min_pu_size * sizeof(MvField),
235 s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab),
237 if (!s->tab_mvf_pool || !s->rpl_tab_pool)
244 return AVERROR(ENOMEM);
247 static void pred_weight_table(HEVCContext *s, GetBitContext *gb)
251 uint8_t luma_weight_l0_flag[16];
252 uint8_t chroma_weight_l0_flag[16];
253 uint8_t luma_weight_l1_flag[16];
254 uint8_t chroma_weight_l1_flag[16];
256 s->sh.luma_log2_weight_denom = get_ue_golomb_long(gb);
257 if (s->sps->chroma_format_idc != 0) {
258 int delta = get_se_golomb(gb);
259 s->sh.chroma_log2_weight_denom = av_clip_c(s->sh.luma_log2_weight_denom + delta, 0, 7);
262 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
263 luma_weight_l0_flag[i] = get_bits1(gb);
264 if (!luma_weight_l0_flag[i]) {
265 s->sh.luma_weight_l0[i] = 1 << s->sh.luma_log2_weight_denom;
266 s->sh.luma_offset_l0[i] = 0;
269 if (s->sps->chroma_format_idc != 0) { // FIXME: invert "if" and "for"
270 for (i = 0; i < s->sh.nb_refs[L0]; i++)
271 chroma_weight_l0_flag[i] = get_bits1(gb);
273 for (i = 0; i < s->sh.nb_refs[L0]; i++)
274 chroma_weight_l0_flag[i] = 0;
276 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
277 if (luma_weight_l0_flag[i]) {
278 int delta_luma_weight_l0 = get_se_golomb(gb);
279 s->sh.luma_weight_l0[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;
280 s->sh.luma_offset_l0[i] = get_se_golomb(gb);
282 if (chroma_weight_l0_flag[i]) {
283 for (j = 0; j < 2; j++) {
284 int delta_chroma_weight_l0 = get_se_golomb(gb);
285 int delta_chroma_offset_l0 = get_se_golomb(gb);
286 s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
287 s->sh.chroma_offset_l0[i][j] = av_clip_c((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j])
288 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
291 s->sh.chroma_weight_l0[i][0] = 1 << s->sh.chroma_log2_weight_denom;
292 s->sh.chroma_offset_l0[i][0] = 0;
293 s->sh.chroma_weight_l0[i][1] = 1 << s->sh.chroma_log2_weight_denom;
294 s->sh.chroma_offset_l0[i][1] = 0;
297 if (s->sh.slice_type == B_SLICE) {
298 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
299 luma_weight_l1_flag[i] = get_bits1(gb);
300 if (!luma_weight_l1_flag[i]) {
301 s->sh.luma_weight_l1[i] = 1 << s->sh.luma_log2_weight_denom;
302 s->sh.luma_offset_l1[i] = 0;
305 if (s->sps->chroma_format_idc != 0) {
306 for (i = 0; i < s->sh.nb_refs[L1]; i++)
307 chroma_weight_l1_flag[i] = get_bits1(gb);
309 for (i = 0; i < s->sh.nb_refs[L1]; i++)
310 chroma_weight_l1_flag[i] = 0;
312 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
313 if (luma_weight_l1_flag[i]) {
314 int delta_luma_weight_l1 = get_se_golomb(gb);
315 s->sh.luma_weight_l1[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;
316 s->sh.luma_offset_l1[i] = get_se_golomb(gb);
318 if (chroma_weight_l1_flag[i]) {
319 for (j = 0; j < 2; j++) {
320 int delta_chroma_weight_l1 = get_se_golomb(gb);
321 int delta_chroma_offset_l1 = get_se_golomb(gb);
322 s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
323 s->sh.chroma_offset_l1[i][j] = av_clip_c((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j])
324 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
327 s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom;
328 s->sh.chroma_offset_l1[i][0] = 0;
329 s->sh.chroma_weight_l1[i][1] = 1 << s->sh.chroma_log2_weight_denom;
330 s->sh.chroma_offset_l1[i][1] = 0;
336 static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
338 const HEVCSPS *sps = s->sps;
339 int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
340 int prev_delta_msb = 0;
341 int nb_sps = 0, nb_sh;
345 if (!sps->long_term_ref_pics_present_flag)
348 if (sps->num_long_term_ref_pics_sps > 0)
349 nb_sps = get_ue_golomb_long(gb);
350 nb_sh = get_ue_golomb_long(gb);
352 if (nb_sh + nb_sps > FF_ARRAY_ELEMS(rps->poc))
353 return AVERROR_INVALIDDATA;
355 rps->nb_refs = nb_sh + nb_sps;
357 for (i = 0; i < rps->nb_refs; i++) {
358 uint8_t delta_poc_msb_present;
361 uint8_t lt_idx_sps = 0;
363 if (sps->num_long_term_ref_pics_sps > 1)
364 lt_idx_sps = get_bits(gb, av_ceil_log2(sps->num_long_term_ref_pics_sps));
366 rps->poc[i] = sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
367 rps->used[i] = sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];
369 rps->poc[i] = get_bits(gb, sps->log2_max_poc_lsb);
370 rps->used[i] = get_bits1(gb);
373 delta_poc_msb_present = get_bits1(gb);
374 if (delta_poc_msb_present) {
375 int delta = get_ue_golomb_long(gb);
377 if (i && i != nb_sps)
378 delta += prev_delta_msb;
380 rps->poc[i] += s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
381 prev_delta_msb = delta;
388 static int set_sps(HEVCContext *s, const HEVCSPS *sps)
391 int num = 0, den = 0;
394 ret = pic_arrays_init(s, sps);
398 s->avctx->coded_width = sps->width;
399 s->avctx->coded_height = sps->height;
400 s->avctx->width = sps->output_width;
401 s->avctx->height = sps->output_height;
402 s->avctx->pix_fmt = sps->pix_fmt;
403 s->avctx->sample_aspect_ratio = sps->vui.sar;
404 s->avctx->has_b_frames = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics;
406 if (sps->vui.video_signal_type_present_flag)
407 s->avctx->color_range = sps->vui.video_full_range_flag ? AVCOL_RANGE_JPEG
410 s->avctx->color_range = AVCOL_RANGE_MPEG;
412 if (sps->vui.colour_description_present_flag) {
413 s->avctx->color_primaries = sps->vui.colour_primaries;
414 s->avctx->color_trc = sps->vui.transfer_characteristic;
415 s->avctx->colorspace = sps->vui.matrix_coeffs;
417 s->avctx->color_primaries = AVCOL_PRI_UNSPECIFIED;
418 s->avctx->color_trc = AVCOL_TRC_UNSPECIFIED;
419 s->avctx->colorspace = AVCOL_SPC_UNSPECIFIED;
422 ff_hevc_pred_init(&s->hpc, sps->bit_depth);
423 ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
424 ff_videodsp_init (&s->vdsp, sps->bit_depth);
426 if (sps->sao_enabled) {
427 av_frame_unref(s->tmp_frame);
428 ret = ff_get_buffer(s->avctx, s->tmp_frame, AV_GET_BUFFER_FLAG_REF);
431 s->frame = s->tmp_frame;
435 s->vps = (HEVCVPS*) s->vps_list[s->sps->vps_id]->data;
437 if (s->vps->vps_timing_info_present_flag) {
438 num = s->vps->vps_num_units_in_tick;
439 den = s->vps->vps_time_scale;
440 } else if (sps->vui.vui_timing_info_present_flag) {
441 num = sps->vui.vui_num_units_in_tick;
442 den = sps->vui.vui_time_scale;
445 if (num != 0 && den != 0)
446 av_reduce(&s->avctx->time_base.num, &s->avctx->time_base.den,
457 static int hls_slice_header(HEVCContext *s)
459 GetBitContext *gb = &s->HEVClc.gb;
460 SliceHeader *sh = &s->sh;
464 sh->first_slice_in_pic_flag = get_bits1(gb);
465 if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
466 s->seq_decode = (s->seq_decode + 1) & 0xff;
469 ff_hevc_clear_refs(s);
471 if (s->nal_unit_type >= 16 && s->nal_unit_type <= 23)
472 sh->no_output_of_prior_pics_flag = get_bits1(gb);
474 sh->pps_id = get_ue_golomb_long(gb);
475 if (sh->pps_id >= MAX_PPS_COUNT || !s->pps_list[sh->pps_id]) {
476 av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
477 return AVERROR_INVALIDDATA;
479 if (!sh->first_slice_in_pic_flag &&
480 s->pps != (HEVCPPS*)s->pps_list[sh->pps_id]->data) {
481 av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
482 return AVERROR_INVALIDDATA;
484 s->pps = (HEVCPPS*)s->pps_list[sh->pps_id]->data;
486 if (s->sps != (HEVCSPS*)s->sps_list[s->pps->sps_id]->data) {
487 s->sps = (HEVCSPS*)s->sps_list[s->pps->sps_id]->data;
489 ff_hevc_clear_refs(s);
490 ret = set_sps(s, s->sps);
494 s->seq_decode = (s->seq_decode + 1) & 0xff;
498 sh->dependent_slice_segment_flag = 0;
499 if (!sh->first_slice_in_pic_flag) {
500 int slice_address_length;
502 if (s->pps->dependent_slice_segments_enabled_flag)
503 sh->dependent_slice_segment_flag = get_bits1(gb);
505 slice_address_length = av_ceil_log2(s->sps->ctb_width *
507 sh->slice_segment_addr = get_bits(gb, slice_address_length);
508 if (sh->slice_segment_addr >= s->sps->ctb_width * s->sps->ctb_height) {
509 av_log(s->avctx, AV_LOG_ERROR,
510 "Invalid slice segment address: %u.\n",
511 sh->slice_segment_addr);
512 return AVERROR_INVALIDDATA;
515 if (!sh->dependent_slice_segment_flag) {
516 sh->slice_addr = sh->slice_segment_addr;
520 sh->slice_segment_addr = sh->slice_addr = 0;
522 s->slice_initialized = 0;
525 if (!sh->dependent_slice_segment_flag) {
526 s->slice_initialized = 0;
528 for (i = 0; i < s->pps->num_extra_slice_header_bits; i++)
529 skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
531 sh->slice_type = get_ue_golomb_long(gb);
532 if (!(sh->slice_type == I_SLICE ||
533 sh->slice_type == P_SLICE ||
534 sh->slice_type == B_SLICE)) {
535 av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
537 return AVERROR_INVALIDDATA;
539 if (IS_IRAP(s) && sh->slice_type != I_SLICE) {
540 av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
541 return AVERROR_INVALIDDATA;
544 if (s->pps->output_flag_present_flag)
545 sh->pic_output_flag = get_bits1(gb);
547 if (s->sps->separate_colour_plane_flag)
548 sh->colour_plane_id = get_bits(gb, 2);
551 int short_term_ref_pic_set_sps_flag, poc;
553 sh->pic_order_cnt_lsb = get_bits(gb, s->sps->log2_max_poc_lsb);
554 poc = ff_hevc_compute_poc(s, sh->pic_order_cnt_lsb);
555 if (!sh->first_slice_in_pic_flag && poc != s->poc) {
556 av_log(s->avctx, AV_LOG_WARNING,
557 "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
558 if (s->avctx->err_recognition & AV_EF_EXPLODE)
559 return AVERROR_INVALIDDATA;
564 short_term_ref_pic_set_sps_flag = get_bits1(gb);
565 if (!short_term_ref_pic_set_sps_flag) {
566 ret = ff_hevc_decode_short_term_rps(s, &sh->slice_rps, s->sps, 1);
570 sh->short_term_rps = &sh->slice_rps;
572 int numbits, rps_idx;
574 if (!s->sps->nb_st_rps) {
575 av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
576 return AVERROR_INVALIDDATA;
579 numbits = av_ceil_log2(s->sps->nb_st_rps);
580 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
581 sh->short_term_rps = &s->sps->st_rps[rps_idx];
584 ret = decode_lt_rps(s, &sh->long_term_rps, gb);
586 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
587 if (s->avctx->err_recognition & AV_EF_EXPLODE)
588 return AVERROR_INVALIDDATA;
591 if (s->sps->sps_temporal_mvp_enabled_flag)
592 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
594 sh->slice_temporal_mvp_enabled_flag = 0;
596 s->sh.short_term_rps = NULL;
601 if (s->temporal_id == 0 &&
602 s->nal_unit_type != NAL_TRAIL_N &&
603 s->nal_unit_type != NAL_TSA_N &&
604 s->nal_unit_type != NAL_STSA_N &&
605 s->nal_unit_type != NAL_RADL_N &&
606 s->nal_unit_type != NAL_RADL_R &&
607 s->nal_unit_type != NAL_RASL_N &&
608 s->nal_unit_type != NAL_RASL_R)
611 if (s->sps->sao_enabled) {
612 sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
613 sh->slice_sample_adaptive_offset_flag[1] =
614 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
616 sh->slice_sample_adaptive_offset_flag[0] = 0;
617 sh->slice_sample_adaptive_offset_flag[1] = 0;
618 sh->slice_sample_adaptive_offset_flag[2] = 0;
621 sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
622 if (sh->slice_type == P_SLICE || sh->slice_type == B_SLICE) {
625 sh->nb_refs[L0] = s->pps->num_ref_idx_l0_default_active;
626 if (sh->slice_type == B_SLICE)
627 sh->nb_refs[L1] = s->pps->num_ref_idx_l1_default_active;
629 if (get_bits1(gb)) { // num_ref_idx_active_override_flag
630 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
631 if (sh->slice_type == B_SLICE)
632 sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
634 if (sh->nb_refs[L0] > MAX_REFS || sh->nb_refs[L1] > MAX_REFS) {
635 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
636 sh->nb_refs[L0], sh->nb_refs[L1]);
637 return AVERROR_INVALIDDATA;
640 sh->rpl_modification_flag[0] = 0;
641 sh->rpl_modification_flag[1] = 0;
642 nb_refs = ff_hevc_frame_nb_refs(s);
644 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
645 return AVERROR_INVALIDDATA;
648 if (s->pps->lists_modification_present_flag && nb_refs > 1) {
649 sh->rpl_modification_flag[0] = get_bits1(gb);
650 if (sh->rpl_modification_flag[0]) {
651 for (i = 0; i < sh->nb_refs[L0]; i++)
652 sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
655 if (sh->slice_type == B_SLICE) {
656 sh->rpl_modification_flag[1] = get_bits1(gb);
657 if (sh->rpl_modification_flag[1] == 1)
658 for (i = 0; i < sh->nb_refs[L1]; i++)
659 sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
663 if (sh->slice_type == B_SLICE)
664 sh->mvd_l1_zero_flag = get_bits1(gb);
666 if (s->pps->cabac_init_present_flag)
667 sh->cabac_init_flag = get_bits1(gb);
669 sh->cabac_init_flag = 0;
671 sh->collocated_ref_idx = 0;
672 if (sh->slice_temporal_mvp_enabled_flag) {
673 sh->collocated_list = L0;
674 if (sh->slice_type == B_SLICE)
675 sh->collocated_list = !get_bits1(gb);
677 if (sh->nb_refs[sh->collocated_list] > 1) {
678 sh->collocated_ref_idx = get_ue_golomb_long(gb);
679 if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
680 av_log(s->avctx, AV_LOG_ERROR,
681 "Invalid collocated_ref_idx: %d.\n",
682 sh->collocated_ref_idx);
683 return AVERROR_INVALIDDATA;
688 if ((s->pps->weighted_pred_flag && sh->slice_type == P_SLICE) ||
689 (s->pps->weighted_bipred_flag && sh->slice_type == B_SLICE)) {
690 pred_weight_table(s, gb);
693 sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
694 if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
695 av_log(s->avctx, AV_LOG_ERROR,
696 "Invalid number of merging MVP candidates: %d.\n",
697 sh->max_num_merge_cand);
698 return AVERROR_INVALIDDATA;
702 sh->slice_qp_delta = get_se_golomb(gb);
703 if (s->pps->pic_slice_level_chroma_qp_offsets_present_flag) {
704 sh->slice_cb_qp_offset = get_se_golomb(gb);
705 sh->slice_cr_qp_offset = get_se_golomb(gb);
707 sh->slice_cb_qp_offset = 0;
708 sh->slice_cr_qp_offset = 0;
711 if (s->pps->deblocking_filter_control_present_flag) {
712 int deblocking_filter_override_flag = 0;
714 if (s->pps->deblocking_filter_override_enabled_flag)
715 deblocking_filter_override_flag = get_bits1(gb);
717 if (deblocking_filter_override_flag) {
718 sh->disable_deblocking_filter_flag = get_bits1(gb);
719 if (!sh->disable_deblocking_filter_flag) {
720 sh->beta_offset = get_se_golomb(gb) * 2;
721 sh->tc_offset = get_se_golomb(gb) * 2;
724 sh->disable_deblocking_filter_flag = s->pps->disable_dbf;
725 sh->beta_offset = s->pps->beta_offset;
726 sh->tc_offset = s->pps->tc_offset;
729 sh->disable_deblocking_filter_flag = 0;
734 if (s->pps->seq_loop_filter_across_slices_enabled_flag &&
735 (sh->slice_sample_adaptive_offset_flag[0] ||
736 sh->slice_sample_adaptive_offset_flag[1] ||
737 !sh->disable_deblocking_filter_flag)) {
738 sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
740 sh->slice_loop_filter_across_slices_enabled_flag = s->pps->seq_loop_filter_across_slices_enabled_flag;
742 } else if (!s->slice_initialized) {
743 av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
744 return AVERROR_INVALIDDATA;
747 sh->num_entry_point_offsets = 0;
748 if (s->pps->tiles_enabled_flag || s->pps->entropy_coding_sync_enabled_flag) {
749 sh->num_entry_point_offsets = get_ue_golomb_long(gb);
750 if (sh->num_entry_point_offsets > 0) {
751 int offset_len = get_ue_golomb_long(gb) + 1;
753 for (i = 0; i < sh->num_entry_point_offsets; i++)
754 skip_bits(gb, offset_len);
758 if (s->pps->slice_header_extension_present_flag) {
759 int length = get_ue_golomb_long(gb);
760 for (i = 0; i < length; i++)
761 skip_bits(gb, 8); // slice_header_extension_data_byte
764 // Inferred parameters
765 sh->slice_qp = 26 + s->pps->pic_init_qp_minus26 + sh->slice_qp_delta;
766 sh->slice_ctb_addr_rs = sh->slice_segment_addr;
768 s->HEVClc.first_qp_group = !s->sh.dependent_slice_segment_flag;
770 if (!s->pps->cu_qp_delta_enabled_flag)
771 s->HEVClc.qp_y = ((s->sh.slice_qp + 52 + 2 * s->sps->qp_bd_offset) %
772 (52 + s->sps->qp_bd_offset)) - s->sps->qp_bd_offset;
774 s->slice_initialized = 1;
779 #define CTB(tab, x, y) ((tab)[(y) * s->sps->ctb_width + (x)])
781 #define SET_SAO(elem, value) \
783 if (!sao_merge_up_flag && !sao_merge_left_flag) \
785 else if (sao_merge_left_flag) \
786 sao->elem = CTB(s->sao, rx-1, ry).elem; \
787 else if (sao_merge_up_flag) \
788 sao->elem = CTB(s->sao, rx, ry-1).elem; \
793 static void hls_sao_param(HEVCContext *s, int rx, int ry)
795 HEVCLocalContext *lc = &s->HEVClc;
796 int sao_merge_left_flag = 0;
797 int sao_merge_up_flag = 0;
798 int shift = s->sps->bit_depth - FFMIN(s->sps->bit_depth, 10);
799 SAOParams *sao = &CTB(s->sao, rx, ry);
802 if (s->sh.slice_sample_adaptive_offset_flag[0] ||
803 s->sh.slice_sample_adaptive_offset_flag[1]) {
805 if (lc->ctb_left_flag)
806 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
808 if (ry > 0 && !sao_merge_left_flag) {
810 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
814 for (c_idx = 0; c_idx < 3; c_idx++) {
815 if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
816 sao->type_idx[c_idx] = SAO_NOT_APPLIED;
821 sao->type_idx[2] = sao->type_idx[1];
822 sao->eo_class[2] = sao->eo_class[1];
824 SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
827 if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
830 for (i = 0; i < 4; i++)
831 SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
833 if (sao->type_idx[c_idx] == SAO_BAND) {
834 for (i = 0; i < 4; i++) {
835 if (sao->offset_abs[c_idx][i]) {
836 SET_SAO(offset_sign[c_idx][i],
837 ff_hevc_sao_offset_sign_decode(s));
839 sao->offset_sign[c_idx][i] = 0;
842 SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
843 } else if (c_idx != 2) {
844 SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
847 // Inferred parameters
848 sao->offset_val[c_idx][0] = 0;
849 for (i = 0; i < 4; i++) {
850 sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i] << shift;
851 if (sao->type_idx[c_idx] == SAO_EDGE) {
853 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
854 } else if (sao->offset_sign[c_idx][i]) {
855 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
864 static void hls_residual_coding(HEVCContext *s, int x0, int y0,
865 int log2_trafo_size, enum ScanType scan_idx,
868 #define GET_COORD(offset, n) \
870 x_c = (scan_x_cg[offset >> 4] << 2) + scan_x_off[n]; \
871 y_c = (scan_y_cg[offset >> 4] << 2) + scan_y_off[n]; \
873 HEVCLocalContext *lc = &s->HEVClc;
874 int transform_skip_flag = 0;
876 int last_significant_coeff_x, last_significant_coeff_y;
880 int greater1_ctx = 1;
883 int x_cg_last_sig, y_cg_last_sig;
885 const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
887 ptrdiff_t stride = s->frame->linesize[c_idx];
888 int hshift = s->sps->hshift[c_idx];
889 int vshift = s->sps->vshift[c_idx];
890 uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
891 ((x0 >> hshift) << s->sps->pixel_shift)];
892 DECLARE_ALIGNED(16, int16_t, coeffs[MAX_TB_SIZE * MAX_TB_SIZE]) = { 0 };
893 DECLARE_ALIGNED(8, uint8_t, significant_coeff_group_flag[8][8]) = { { 0 } };
895 int trafo_size = 1 << log2_trafo_size;
896 int i, qp, shift, add, scale, scale_m;
897 const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
898 const uint8_t *scale_matrix;
901 // Derive QP for dequant
902 if (!lc->cu.cu_transquant_bypass_flag) {
903 static const int qp_c[] = {
904 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37
907 static const uint8_t rem6[51 + 2 * 6 + 1] = {
908 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
909 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
910 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
913 static const uint8_t div6[51 + 2 * 6 + 1] = {
914 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
915 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
916 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
921 qp = qp_y + s->sps->qp_bd_offset;
926 offset = s->pps->cb_qp_offset + s->sh.slice_cb_qp_offset;
928 offset = s->pps->cr_qp_offset + s->sh.slice_cr_qp_offset;
930 qp_i = av_clip_c(qp_y + offset, -s->sps->qp_bd_offset, 57);
936 qp = qp_c[qp_i - 30];
938 qp += s->sps->qp_bd_offset;
941 shift = s->sps->bit_depth + log2_trafo_size - 5;
942 add = 1 << (shift - 1);
943 scale = level_scale[rem6[qp]] << (div6[qp]);
944 scale_m = 16; // default when no custom scaling lists.
947 if (s->sps->scaling_list_enable_flag) {
948 const ScalingList *sl = s->pps->scaling_list_data_present_flag ?
949 &s->pps->scaling_list : &s->sps->scaling_list;
950 int matrix_id = lc->cu.pred_mode != MODE_INTRA;
952 if (log2_trafo_size != 5)
953 matrix_id = 3 * matrix_id + c_idx;
955 scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
956 if (log2_trafo_size >= 4)
957 dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
961 if (s->pps->transform_skip_enabled_flag &&
962 !lc->cu.cu_transquant_bypass_flag &&
963 log2_trafo_size == 2) {
964 transform_skip_flag = ff_hevc_transform_skip_flag_decode(s, c_idx);
967 last_significant_coeff_x =
968 ff_hevc_last_significant_coeff_x_prefix_decode(s, c_idx, log2_trafo_size);
969 last_significant_coeff_y =
970 ff_hevc_last_significant_coeff_y_prefix_decode(s, c_idx, log2_trafo_size);
972 if (last_significant_coeff_x > 3) {
973 int suffix = ff_hevc_last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
974 last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
975 (2 + (last_significant_coeff_x & 1)) +
979 if (last_significant_coeff_y > 3) {
980 int suffix = ff_hevc_last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
981 last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
982 (2 + (last_significant_coeff_y & 1)) +
986 if (scan_idx == SCAN_VERT)
987 FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
989 x_cg_last_sig = last_significant_coeff_x >> 2;
990 y_cg_last_sig = last_significant_coeff_y >> 2;
994 int last_x_c = last_significant_coeff_x & 3;
995 int last_y_c = last_significant_coeff_y & 3;
997 scan_x_off = ff_hevc_diag_scan4x4_x;
998 scan_y_off = ff_hevc_diag_scan4x4_y;
999 num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
1000 if (trafo_size == 4) {
1001 scan_x_cg = scan_1x1;
1002 scan_y_cg = scan_1x1;
1003 } else if (trafo_size == 8) {
1004 num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1005 scan_x_cg = diag_scan2x2_x;
1006 scan_y_cg = diag_scan2x2_y;
1007 } else if (trafo_size == 16) {
1008 num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1009 scan_x_cg = ff_hevc_diag_scan4x4_x;
1010 scan_y_cg = ff_hevc_diag_scan4x4_y;
1011 } else { // trafo_size == 32
1012 num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1013 scan_x_cg = ff_hevc_diag_scan8x8_x;
1014 scan_y_cg = ff_hevc_diag_scan8x8_y;
1019 scan_x_cg = horiz_scan2x2_x;
1020 scan_y_cg = horiz_scan2x2_y;
1021 scan_x_off = horiz_scan4x4_x;
1022 scan_y_off = horiz_scan4x4_y;
1023 num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1025 default: //SCAN_VERT
1026 scan_x_cg = horiz_scan2x2_y;
1027 scan_y_cg = horiz_scan2x2_x;
1028 scan_x_off = horiz_scan4x4_y;
1029 scan_y_off = horiz_scan4x4_x;
1030 num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1034 num_last_subset = (num_coeff - 1) >> 4;
1036 for (i = num_last_subset; i >= 0; i--) {
1038 int x_cg, y_cg, x_c, y_c;
1039 int implicit_non_zero_coeff = 0;
1040 int64_t trans_coeff_level;
1042 int offset = i << 4;
1044 uint8_t significant_coeff_flag_idx[16];
1045 uint8_t nb_significant_coeff_flag = 0;
1047 x_cg = scan_x_cg[i];
1048 y_cg = scan_y_cg[i];
1050 if (i < num_last_subset && i > 0) {
1052 if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1053 ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1054 if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1055 ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1057 significant_coeff_group_flag[x_cg][y_cg] =
1058 ff_hevc_significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
1059 implicit_non_zero_coeff = 1;
1061 significant_coeff_group_flag[x_cg][y_cg] =
1062 ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1063 (x_cg == 0 && y_cg == 0));
1066 last_scan_pos = num_coeff - offset - 1;
1068 if (i == num_last_subset) {
1069 n_end = last_scan_pos - 1;
1070 significant_coeff_flag_idx[0] = last_scan_pos;
1071 nb_significant_coeff_flag = 1;
1076 if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1077 prev_sig = significant_coeff_group_flag[x_cg + 1][y_cg];
1078 if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1079 prev_sig += significant_coeff_group_flag[x_cg][y_cg + 1] << 1;
1081 for (n = n_end; n >= 0; n--) {
1082 GET_COORD(offset, n);
1084 if (significant_coeff_group_flag[x_cg][y_cg] &&
1085 (n > 0 || implicit_non_zero_coeff == 0)) {
1086 if (ff_hevc_significant_coeff_flag_decode(s, c_idx, x_c, y_c,
1090 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1091 nb_significant_coeff_flag++;
1092 implicit_non_zero_coeff = 0;
1095 int last_cg = (x_c == (x_cg << 2) && y_c == (y_cg << 2));
1096 if (last_cg && implicit_non_zero_coeff && significant_coeff_group_flag[x_cg][y_cg]) {
1097 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1098 nb_significant_coeff_flag++;
1103 n_end = nb_significant_coeff_flag;
1106 int first_nz_pos_in_cg = 16;
1107 int last_nz_pos_in_cg = -1;
1108 int c_rice_param = 0;
1109 int first_greater1_coeff_idx = -1;
1110 uint8_t coeff_abs_level_greater1_flag[16] = { 0 };
1111 uint16_t coeff_sign_flag;
1113 int sign_hidden = 0;
1115 // initialize first elem of coeff_bas_level_greater1_flag
1116 int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1118 if (!(i == num_last_subset) && greater1_ctx == 0)
1121 last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1123 for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1124 int n_idx = significant_coeff_flag_idx[m];
1125 int inc = (ctx_set << 2) + greater1_ctx;
1126 coeff_abs_level_greater1_flag[n_idx] =
1127 ff_hevc_coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
1128 if (coeff_abs_level_greater1_flag[n_idx]) {
1130 } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1134 if (coeff_abs_level_greater1_flag[n_idx] &&
1135 first_greater1_coeff_idx == -1)
1136 first_greater1_coeff_idx = n_idx;
1138 first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1139 sign_hidden = last_nz_pos_in_cg - first_nz_pos_in_cg >= 4 &&
1140 !lc->cu.cu_transquant_bypass_flag;
1142 if (first_greater1_coeff_idx != -1) {
1143 coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += ff_hevc_coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1145 if (!s->pps->sign_data_hiding_flag || !sign_hidden) {
1146 coeff_sign_flag = ff_hevc_coeff_sign_flag(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1148 coeff_sign_flag = ff_hevc_coeff_sign_flag(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1151 for (m = 0; m < n_end; m++) {
1152 n = significant_coeff_flag_idx[m];
1153 GET_COORD(offset, n);
1154 trans_coeff_level = 1 + coeff_abs_level_greater1_flag[n];
1155 if (trans_coeff_level == ((m < 8) ?
1156 ((n == first_greater1_coeff_idx) ? 3 : 2) : 1)) {
1157 int last_coeff_abs_level_remaining = ff_hevc_coeff_abs_level_remaining(s, trans_coeff_level, c_rice_param);
1159 trans_coeff_level += last_coeff_abs_level_remaining;
1160 if ((trans_coeff_level) > (3 * (1 << c_rice_param)))
1161 c_rice_param = FFMIN(c_rice_param + 1, 4);
1163 if (s->pps->sign_data_hiding_flag && sign_hidden) {
1164 sum_abs += trans_coeff_level;
1165 if (n == first_nz_pos_in_cg && ((sum_abs & 1) == 1))
1166 trans_coeff_level = -trans_coeff_level;
1168 if (coeff_sign_flag >> 15)
1169 trans_coeff_level = -trans_coeff_level;
1170 coeff_sign_flag <<= 1;
1171 if (!lc->cu.cu_transquant_bypass_flag) {
1172 if (s->sps->scaling_list_enable_flag) {
1173 if (y_c || x_c || log2_trafo_size < 4) {
1175 switch (log2_trafo_size) {
1176 case 3: pos = (y_c << 3) + x_c; break;
1177 case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1178 case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1179 default: pos = (y_c << 2) + x_c;
1181 scale_m = scale_matrix[pos];
1186 trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1187 if(trans_coeff_level < 0) {
1188 if((~trans_coeff_level) & 0xFffffffffff8000)
1189 trans_coeff_level = -32768;
1191 if (trans_coeff_level & 0xffffffffffff8000)
1192 trans_coeff_level = 32767;
1195 coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1200 if (lc->cu.cu_transquant_bypass_flag) {
1201 s->hevcdsp.transquant_bypass[log2_trafo_size - 2](dst, coeffs, stride);
1203 if (transform_skip_flag)
1204 s->hevcdsp.transform_skip(dst, coeffs, stride);
1205 else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 &&
1206 log2_trafo_size == 2)
1207 s->hevcdsp.transform_4x4_luma_add(dst, coeffs, stride);
1209 s->hevcdsp.transform_add[log2_trafo_size - 2](dst, coeffs, stride);
1213 static void hls_transform_unit(HEVCContext *s, int x0, int y0,
1214 int xBase, int yBase, int cb_xBase, int cb_yBase,
1215 int log2_cb_size, int log2_trafo_size,
1216 int trafo_depth, int blk_idx)
1218 HEVCLocalContext *lc = &s->HEVClc;
1220 if (lc->cu.pred_mode == MODE_INTRA) {
1221 int trafo_size = 1 << log2_trafo_size;
1222 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1224 s->hpc.intra_pred(s, x0, y0, log2_trafo_size, 0);
1225 if (log2_trafo_size > 2) {
1226 trafo_size = trafo_size << (s->sps->hshift[1] - 1);
1227 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1228 s->hpc.intra_pred(s, x0, y0, log2_trafo_size - 1, 1);
1229 s->hpc.intra_pred(s, x0, y0, log2_trafo_size - 1, 2);
1230 } else if (blk_idx == 3) {
1231 trafo_size = trafo_size << s->sps->hshift[1];
1232 ff_hevc_set_neighbour_available(s, xBase, yBase,
1233 trafo_size, trafo_size);
1234 s->hpc.intra_pred(s, xBase, yBase, log2_trafo_size, 1);
1235 s->hpc.intra_pred(s, xBase, yBase, log2_trafo_size, 2);
1239 if (lc->tt.cbf_luma ||
1240 SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], x0, y0) ||
1241 SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], x0, y0)) {
1242 int scan_idx = SCAN_DIAG;
1243 int scan_idx_c = SCAN_DIAG;
1245 if (s->pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
1246 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
1247 if (lc->tu.cu_qp_delta != 0)
1248 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
1249 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
1250 lc->tu.is_cu_qp_delta_coded = 1;
1251 ff_hevc_set_qPy(s, x0, y0, cb_xBase, cb_yBase, log2_cb_size);
1254 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
1255 if (lc->tu.cur_intra_pred_mode >= 6 &&
1256 lc->tu.cur_intra_pred_mode <= 14) {
1257 scan_idx = SCAN_VERT;
1258 } else if (lc->tu.cur_intra_pred_mode >= 22 &&
1259 lc->tu.cur_intra_pred_mode <= 30) {
1260 scan_idx = SCAN_HORIZ;
1263 if (lc->pu.intra_pred_mode_c >= 6 &&
1264 lc->pu.intra_pred_mode_c <= 14) {
1265 scan_idx_c = SCAN_VERT;
1266 } else if (lc->pu.intra_pred_mode_c >= 22 &&
1267 lc->pu.intra_pred_mode_c <= 30) {
1268 scan_idx_c = SCAN_HORIZ;
1272 if (lc->tt.cbf_luma)
1273 hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
1274 if (log2_trafo_size > 2) {
1275 if (SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], x0, y0))
1276 hls_residual_coding(s, x0, y0, log2_trafo_size - 1, scan_idx_c, 1);
1277 if (SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], x0, y0))
1278 hls_residual_coding(s, x0, y0, log2_trafo_size - 1, scan_idx_c, 2);
1279 } else if (blk_idx == 3) {
1280 if (SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], xBase, yBase))
1281 hls_residual_coding(s, xBase, yBase, log2_trafo_size, scan_idx_c, 1);
1282 if (SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], xBase, yBase))
1283 hls_residual_coding(s, xBase, yBase, log2_trafo_size, scan_idx_c, 2);
1288 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1290 int cb_size = 1 << log2_cb_size;
1291 int log2_min_pu_size = s->sps->log2_min_pu_size;
1293 int min_pu_width = s->sps->min_pu_width;
1294 int x_end = FFMIN(x0 + cb_size, s->sps->width);
1295 int y_end = FFMIN(y0 + cb_size, s->sps->height);
1298 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1299 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1300 s->is_pcm[i + j * min_pu_width] = 2;
1303 static void hls_transform_tree(HEVCContext *s, int x0, int y0,
1304 int xBase, int yBase, int cb_xBase, int cb_yBase,
1305 int log2_cb_size, int log2_trafo_size,
1306 int trafo_depth, int blk_idx)
1308 HEVCLocalContext *lc = &s->HEVClc;
1309 uint8_t split_transform_flag;
1311 if (trafo_depth > 0 && log2_trafo_size == 2) {
1312 SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], x0, y0) =
1313 SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth - 1], xBase, yBase);
1314 SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], x0, y0) =
1315 SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth - 1], xBase, yBase);
1317 SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], x0, y0) =
1318 SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], x0, y0) = 0;
1321 if (lc->cu.intra_split_flag) {
1322 if (trafo_depth == 1)
1323 lc->tu.cur_intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1325 lc->tu.cur_intra_pred_mode = lc->pu.intra_pred_mode[0];
1328 lc->tt.cbf_luma = 1;
1330 lc->tt.inter_split_flag = s->sps->max_transform_hierarchy_depth_inter == 0 &&
1331 lc->cu.pred_mode == MODE_INTER &&
1332 lc->cu.part_mode != PART_2Nx2N &&
1335 if (log2_trafo_size <= s->sps->log2_max_trafo_size &&
1336 log2_trafo_size > s->sps->log2_min_tb_size &&
1337 trafo_depth < lc->cu.max_trafo_depth &&
1338 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1339 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1341 split_transform_flag = log2_trafo_size > s->sps->log2_max_trafo_size ||
1342 (lc->cu.intra_split_flag && trafo_depth == 0) ||
1343 lc->tt.inter_split_flag;
1346 if (log2_trafo_size > 2) {
1347 if (trafo_depth == 0 ||
1348 SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth - 1], xBase, yBase)) {
1349 SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], x0, y0) =
1350 ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1353 if (trafo_depth == 0 ||
1354 SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth - 1], xBase, yBase)) {
1355 SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], x0, y0) =
1356 ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1360 if (split_transform_flag) {
1361 int x1 = x0 + ((1 << log2_trafo_size) >> 1);
1362 int y1 = y0 + ((1 << log2_trafo_size) >> 1);
1364 hls_transform_tree(s, x0, y0, x0, y0, cb_xBase, cb_yBase, log2_cb_size,
1365 log2_trafo_size - 1, trafo_depth + 1, 0);
1366 hls_transform_tree(s, x1, y0, x0, y0, cb_xBase, cb_yBase, log2_cb_size,
1367 log2_trafo_size - 1, trafo_depth + 1, 1);
1368 hls_transform_tree(s, x0, y1, x0, y0, cb_xBase, cb_yBase, log2_cb_size,
1369 log2_trafo_size - 1, trafo_depth + 1, 2);
1370 hls_transform_tree(s, x1, y1, x0, y0, cb_xBase, cb_yBase, log2_cb_size,
1371 log2_trafo_size - 1, trafo_depth + 1, 3);
1373 int min_tu_size = 1 << s->sps->log2_min_tb_size;
1374 int log2_min_tu_size = s->sps->log2_min_tb_size;
1375 int min_tu_width = s->sps->min_tb_width;
1377 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1378 SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], x0, y0) ||
1379 SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], x0, y0)) {
1380 lc->tt.cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1383 hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1384 log2_cb_size, log2_trafo_size, trafo_depth, blk_idx);
1386 // TODO: store cbf_luma somewhere else
1387 if (lc->tt.cbf_luma) {
1389 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1390 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1391 int x_tu = (x0 + j) >> log2_min_tu_size;
1392 int y_tu = (y0 + i) >> log2_min_tu_size;
1393 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1396 if (!s->sh.disable_deblocking_filter_flag) {
1397 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size,
1398 lc->slice_or_tiles_up_boundary,
1399 lc->slice_or_tiles_left_boundary);
1400 if (s->pps->transquant_bypass_enable_flag &&
1401 lc->cu.cu_transquant_bypass_flag)
1402 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1407 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1409 //TODO: non-4:2:0 support
1410 HEVCLocalContext *lc = &s->HEVClc;
1412 int cb_size = 1 << log2_cb_size;
1413 int stride0 = s->frame->linesize[0];
1414 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->sps->pixel_shift)];
1415 int stride1 = s->frame->linesize[1];
1416 uint8_t *dst1 = &s->frame->data[1][(y0 >> s->sps->vshift[1]) * stride1 + ((x0 >> s->sps->hshift[1]) << s->sps->pixel_shift)];
1417 int stride2 = s->frame->linesize[2];
1418 uint8_t *dst2 = &s->frame->data[2][(y0 >> s->sps->vshift[2]) * stride2 + ((x0 >> s->sps->hshift[2]) << s->sps->pixel_shift)];
1420 int length = cb_size * cb_size * s->sps->pcm.bit_depth + ((cb_size * cb_size) >> 1) * s->sps->pcm.bit_depth;
1421 const uint8_t *pcm = skip_bytes(&s->HEVClc.cc, (length + 7) >> 3);
1424 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size,
1425 lc->slice_or_tiles_up_boundary,
1426 lc->slice_or_tiles_left_boundary);
1428 ret = init_get_bits(&gb, pcm, length);
1432 s->hevcdsp.put_pcm(dst0, stride0, cb_size, &gb, s->sps->pcm.bit_depth);
1433 s->hevcdsp.put_pcm(dst1, stride1, cb_size / 2, &gb, s->sps->pcm.bit_depth);
1434 s->hevcdsp.put_pcm(dst2, stride2, cb_size / 2, &gb, s->sps->pcm.bit_depth);
1438 static void hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1440 HEVCLocalContext *lc = &s->HEVClc;
1441 int x = ff_hevc_abs_mvd_greater0_flag_decode(s);
1442 int y = ff_hevc_abs_mvd_greater0_flag_decode(s);
1445 x += ff_hevc_abs_mvd_greater1_flag_decode(s);
1447 y += ff_hevc_abs_mvd_greater1_flag_decode(s);
1450 case 2: lc->pu.mvd.x = ff_hevc_mvd_decode(s); break;
1451 case 1: lc->pu.mvd.x = ff_hevc_mvd_sign_flag_decode(s); break;
1452 case 0: lc->pu.mvd.x = 0; break;
1456 case 2: lc->pu.mvd.y = ff_hevc_mvd_decode(s); break;
1457 case 1: lc->pu.mvd.y = ff_hevc_mvd_sign_flag_decode(s); break;
1458 case 0: lc->pu.mvd.y = 0; break;
1463 * 8.5.3.2.2.1 Luma sample interpolation process
1465 * @param s HEVC decoding context
1466 * @param dst target buffer for block data at block position
1467 * @param dststride stride of the dst buffer
1468 * @param ref reference picture buffer at origin (0, 0)
1469 * @param mv motion vector (relative to block position) to get pixel data from
1470 * @param x_off horizontal position of block from origin (0, 0)
1471 * @param y_off vertical position of block from origin (0, 0)
1472 * @param block_w width of block
1473 * @param block_h height of block
1475 static void luma_mc(HEVCContext *s, int16_t *dst, ptrdiff_t dststride,
1476 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1477 int block_w, int block_h)
1479 HEVCLocalContext *lc = &s->HEVClc;
1480 uint8_t *src = ref->data[0];
1481 ptrdiff_t srcstride = ref->linesize[0];
1482 int pic_width = s->sps->width;
1483 int pic_height = s->sps->height;
1487 int extra_left = ff_hevc_qpel_extra_before[mx];
1488 int extra_top = ff_hevc_qpel_extra_before[my];
1490 x_off += mv->x >> 2;
1491 y_off += mv->y >> 2;
1492 src += y_off * srcstride + (x_off << s->sps->pixel_shift);
1494 if (x_off < extra_left || y_off < extra_top ||
1495 x_off >= pic_width - block_w - ff_hevc_qpel_extra_after[mx] ||
1496 y_off >= pic_height - block_h - ff_hevc_qpel_extra_after[my]) {
1497 int offset = extra_top * srcstride + (extra_left << s->sps->pixel_shift);
1499 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1500 srcstride, srcstride,
1501 block_w + ff_hevc_qpel_extra[mx],
1502 block_h + ff_hevc_qpel_extra[my],
1503 x_off - extra_left, y_off - extra_top,
1504 pic_width, pic_height);
1505 src = lc->edge_emu_buffer + offset;
1507 s->hevcdsp.put_hevc_qpel[my][mx](dst, dststride, src, srcstride, block_w,
1508 block_h, lc->mc_buffer);
1512 * 8.5.3.2.2.2 Chroma sample interpolation process
1514 * @param s HEVC decoding context
1515 * @param dst1 target buffer for block data at block position (U plane)
1516 * @param dst2 target buffer for block data at block position (V plane)
1517 * @param dststride stride of the dst1 and dst2 buffers
1518 * @param ref reference picture buffer at origin (0, 0)
1519 * @param mv motion vector (relative to block position) to get pixel data from
1520 * @param x_off horizontal position of block from origin (0, 0)
1521 * @param y_off vertical position of block from origin (0, 0)
1522 * @param block_w width of block
1523 * @param block_h height of block
1525 static void chroma_mc(HEVCContext *s, int16_t *dst1, int16_t *dst2,
1526 ptrdiff_t dststride, AVFrame *ref, const Mv *mv,
1527 int x_off, int y_off, int block_w, int block_h)
1529 HEVCLocalContext *lc = &s->HEVClc;
1530 uint8_t *src1 = ref->data[1];
1531 uint8_t *src2 = ref->data[2];
1532 ptrdiff_t src1stride = ref->linesize[1];
1533 ptrdiff_t src2stride = ref->linesize[2];
1534 int pic_width = s->sps->width >> 1;
1535 int pic_height = s->sps->height >> 1;
1540 x_off += mv->x >> 3;
1541 y_off += mv->y >> 3;
1542 src1 += y_off * src1stride + (x_off << s->sps->pixel_shift);
1543 src2 += y_off * src2stride + (x_off << s->sps->pixel_shift);
1545 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1546 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1547 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1548 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->sps->pixel_shift));
1549 int offset2 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->sps->pixel_shift));
1551 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1552 src1stride, src1stride,
1553 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1554 x_off - EPEL_EXTRA_BEFORE,
1555 y_off - EPEL_EXTRA_BEFORE,
1556 pic_width, pic_height);
1558 src1 = lc->edge_emu_buffer + offset1;
1559 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst1, dststride, src1, src1stride,
1560 block_w, block_h, mx, my, lc->mc_buffer);
1562 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src2 - offset2,
1563 src2stride, src2stride,
1564 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1565 x_off - EPEL_EXTRA_BEFORE,
1566 y_off - EPEL_EXTRA_BEFORE,
1567 pic_width, pic_height);
1568 src2 = lc->edge_emu_buffer + offset2;
1569 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst2, dststride, src2, src2stride,
1570 block_w, block_h, mx, my,
1573 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst1, dststride, src1, src1stride,
1574 block_w, block_h, mx, my,
1576 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst2, dststride, src2, src2stride,
1577 block_w, block_h, mx, my,
1582 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1583 const Mv *mv, int y0, int height)
1585 int y = (mv->y >> 2) + y0 + height + 9;
1586 ff_thread_await_progress(&ref->tf, y, 0);
1589 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1591 int log2_cb_size, int partIdx)
1593 #define POS(c_idx, x, y) \
1594 &s->frame->data[c_idx][((y) >> s->sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1595 (((x) >> s->sps->hshift[c_idx]) << s->sps->pixel_shift)]
1596 HEVCLocalContext *lc = &s->HEVClc;
1598 struct MvField current_mv = {{{ 0 }}};
1600 int min_pu_width = s->sps->min_pu_width;
1602 MvField *tab_mvf = s->ref->tab_mvf;
1603 RefPicList *refPicList = s->ref->refPicList;
1604 HEVCFrame *ref0, *ref1;
1606 int tmpstride = MAX_PB_SIZE;
1608 uint8_t *dst0 = POS(0, x0, y0);
1609 uint8_t *dst1 = POS(1, x0, y0);
1610 uint8_t *dst2 = POS(2, x0, y0);
1611 int log2_min_cb_size = s->sps->log2_min_cb_size;
1612 int min_cb_width = s->sps->min_cb_width;
1613 int x_cb = x0 >> log2_min_cb_size;
1614 int y_cb = y0 >> log2_min_cb_size;
1620 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
1621 if (s->sh.max_num_merge_cand > 1)
1622 merge_idx = ff_hevc_merge_idx_decode(s);
1626 ff_hevc_luma_mv_merge_mode(s, x0, y0,
1629 log2_cb_size, partIdx,
1630 merge_idx, ¤t_mv);
1631 x_pu = x0 >> s->sps->log2_min_pu_size;
1632 y_pu = y0 >> s->sps->log2_min_pu_size;
1634 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1635 for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1636 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1637 } else { /* MODE_INTER */
1638 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1639 if (lc->pu.merge_flag) {
1640 if (s->sh.max_num_merge_cand > 1)
1641 merge_idx = ff_hevc_merge_idx_decode(s);
1645 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1646 partIdx, merge_idx, ¤t_mv);
1647 x_pu = x0 >> s->sps->log2_min_pu_size;
1648 y_pu = y0 >> s->sps->log2_min_pu_size;
1650 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1651 for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1652 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1654 enum InterPredIdc inter_pred_idc = PRED_L0;
1655 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1656 if (s->sh.slice_type == B_SLICE)
1657 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1659 if (inter_pred_idc != PRED_L1) {
1660 if (s->sh.nb_refs[L0]) {
1661 ref_idx[0] = ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1662 current_mv.ref_idx[0] = ref_idx[0];
1664 current_mv.pred_flag[0] = 1;
1665 hls_mvd_coding(s, x0, y0, 0);
1666 mvp_flag[0] = ff_hevc_mvp_lx_flag_decode(s);
1667 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1668 partIdx, merge_idx, ¤t_mv,
1670 current_mv.mv[0].x += lc->pu.mvd.x;
1671 current_mv.mv[0].y += lc->pu.mvd.y;
1674 if (inter_pred_idc != PRED_L0) {
1675 if (s->sh.nb_refs[L1]) {
1676 ref_idx[1] = ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1677 current_mv.ref_idx[1] = ref_idx[1];
1680 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1684 hls_mvd_coding(s, x0, y0, 1);
1687 current_mv.pred_flag[1] = 1;
1688 mvp_flag[1] = ff_hevc_mvp_lx_flag_decode(s);
1689 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1690 partIdx, merge_idx, ¤t_mv,
1692 current_mv.mv[1].x += lc->pu.mvd.x;
1693 current_mv.mv[1].y += lc->pu.mvd.y;
1696 x_pu = x0 >> s->sps->log2_min_pu_size;
1697 y_pu = y0 >> s->sps->log2_min_pu_size;
1699 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1700 for(j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1701 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1705 if (current_mv.pred_flag[0]) {
1706 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1709 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1711 if (current_mv.pred_flag[1]) {
1712 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1715 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1718 if (current_mv.pred_flag[0] && !current_mv.pred_flag[1]) {
1719 DECLARE_ALIGNED(16, int16_t, tmp[MAX_PB_SIZE * MAX_PB_SIZE]);
1720 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1722 luma_mc(s, tmp, tmpstride, ref0->frame,
1723 ¤t_mv.mv[0], x0, y0, nPbW, nPbH);
1725 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1726 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1727 s->hevcdsp.weighted_pred(s->sh.luma_log2_weight_denom,
1728 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1729 s->sh.luma_offset_l0[current_mv.ref_idx[0]],
1730 dst0, s->frame->linesize[0], tmp,
1731 tmpstride, nPbW, nPbH);
1733 s->hevcdsp.put_unweighted_pred(dst0, s->frame->linesize[0], tmp, tmpstride, nPbW, nPbH);
1735 chroma_mc(s, tmp, tmp2, tmpstride, ref0->frame,
1736 ¤t_mv.mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1738 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1739 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1740 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1741 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0],
1742 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0],
1743 dst1, s->frame->linesize[1], tmp, tmpstride,
1744 nPbW / 2, nPbH / 2);
1745 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1746 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1],
1747 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1],
1748 dst2, s->frame->linesize[2], tmp2, tmpstride,
1749 nPbW / 2, nPbH / 2);
1751 s->hevcdsp.put_unweighted_pred(dst1, s->frame->linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1752 s->hevcdsp.put_unweighted_pred(dst2, s->frame->linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1754 } else if (!current_mv.pred_flag[0] && current_mv.pred_flag[1]) {
1755 DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1756 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1761 luma_mc(s, tmp, tmpstride, ref1->frame,
1762 ¤t_mv.mv[1], x0, y0, nPbW, nPbH);
1764 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1765 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1766 s->hevcdsp.weighted_pred(s->sh.luma_log2_weight_denom,
1767 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1768 s->sh.luma_offset_l1[current_mv.ref_idx[1]],
1769 dst0, s->frame->linesize[0], tmp, tmpstride,
1772 s->hevcdsp.put_unweighted_pred(dst0, s->frame->linesize[0], tmp, tmpstride, nPbW, nPbH);
1775 chroma_mc(s, tmp, tmp2, tmpstride, ref1->frame,
1776 ¤t_mv.mv[1], x0/2, y0/2, nPbW/2, nPbH/2);
1778 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1779 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1780 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1781 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0],
1782 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0],
1783 dst1, s->frame->linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1784 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1785 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1],
1786 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1],
1787 dst2, s->frame->linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1789 s->hevcdsp.put_unweighted_pred(dst1, s->frame->linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1790 s->hevcdsp.put_unweighted_pred(dst2, s->frame->linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1792 } else if (current_mv.pred_flag[0] && current_mv.pred_flag[1]) {
1793 DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1794 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1795 DECLARE_ALIGNED(16, int16_t, tmp3[MAX_PB_SIZE * MAX_PB_SIZE]);
1796 DECLARE_ALIGNED(16, int16_t, tmp4[MAX_PB_SIZE * MAX_PB_SIZE]);
1797 HEVCFrame *ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1798 HEVCFrame *ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1803 luma_mc(s, tmp, tmpstride, ref0->frame,
1804 ¤t_mv.mv[0], x0, y0, nPbW, nPbH);
1805 luma_mc(s, tmp2, tmpstride, ref1->frame,
1806 ¤t_mv.mv[1], x0, y0, nPbW, nPbH);
1808 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1809 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1810 s->hevcdsp.weighted_pred_avg(s->sh.luma_log2_weight_denom,
1811 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1812 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1813 s->sh.luma_offset_l0[current_mv.ref_idx[0]],
1814 s->sh.luma_offset_l1[current_mv.ref_idx[1]],
1815 dst0, s->frame->linesize[0],
1816 tmp, tmp2, tmpstride, nPbW, nPbH);
1818 s->hevcdsp.put_weighted_pred_avg(dst0, s->frame->linesize[0],
1819 tmp, tmp2, tmpstride, nPbW, nPbH);
1822 chroma_mc(s, tmp, tmp2, tmpstride, ref0->frame,
1823 ¤t_mv.mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1824 chroma_mc(s, tmp3, tmp4, tmpstride, ref1->frame,
1825 ¤t_mv.mv[1], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
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.chroma_log2_weight_denom,
1830 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0],
1831 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0],
1832 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0],
1833 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0],
1834 dst1, s->frame->linesize[1], tmp, tmp3,
1835 tmpstride, nPbW / 2, nPbH / 2);
1836 s->hevcdsp.weighted_pred_avg(s->sh.chroma_log2_weight_denom,
1837 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1],
1838 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1],
1839 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1],
1840 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1],
1841 dst2, s->frame->linesize[2], tmp2, tmp4,
1842 tmpstride, nPbW / 2, nPbH / 2);
1844 s->hevcdsp.put_weighted_pred_avg(dst1, s->frame->linesize[1], tmp, tmp3, tmpstride, nPbW/2, nPbH/2);
1845 s->hevcdsp.put_weighted_pred_avg(dst2, s->frame->linesize[2], tmp2, tmp4, tmpstride, nPbW/2, nPbH/2);
1853 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1854 int prev_intra_luma_pred_flag)
1856 HEVCLocalContext *lc = &s->HEVClc;
1857 int x_pu = x0 >> s->sps->log2_min_pu_size;
1858 int y_pu = y0 >> s->sps->log2_min_pu_size;
1859 int min_pu_width = s->sps->min_pu_width;
1860 int size_in_pus = pu_size >> s->sps->log2_min_pu_size;
1861 int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1);
1862 int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1);
1864 int cand_up = (lc->ctb_up_flag || y0b) ?
1865 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1866 int cand_left = (lc->ctb_left_flag || x0b) ?
1867 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1869 int y_ctb = (y0 >> (s->sps->log2_ctb_size)) << (s->sps->log2_ctb_size);
1871 MvField *tab_mvf = s->ref->tab_mvf;
1872 int intra_pred_mode;
1876 // intra_pred_mode prediction does not cross vertical CTB boundaries
1877 if ((y0 - 1) < y_ctb)
1880 if (cand_left == cand_up) {
1881 if (cand_left < 2) {
1882 candidate[0] = INTRA_PLANAR;
1883 candidate[1] = INTRA_DC;
1884 candidate[2] = INTRA_ANGULAR_26;
1886 candidate[0] = cand_left;
1887 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1888 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1891 candidate[0] = cand_left;
1892 candidate[1] = cand_up;
1893 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1894 candidate[2] = INTRA_PLANAR;
1895 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1896 candidate[2] = INTRA_DC;
1898 candidate[2] = INTRA_ANGULAR_26;
1902 if (prev_intra_luma_pred_flag) {
1903 intra_pred_mode = candidate[lc->pu.mpm_idx];
1905 if (candidate[0] > candidate[1])
1906 FFSWAP(uint8_t, candidate[0], candidate[1]);
1907 if (candidate[0] > candidate[2])
1908 FFSWAP(uint8_t, candidate[0], candidate[2]);
1909 if (candidate[1] > candidate[2])
1910 FFSWAP(uint8_t, candidate[1], candidate[2]);
1912 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1913 for (i = 0; i < 3; i++)
1914 if (intra_pred_mode >= candidate[i])
1918 /* write the intra prediction units into the mv array */
1921 for (i = 0; i < size_in_pus; i++) {
1922 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1923 intra_pred_mode, size_in_pus);
1925 for (j = 0; j < size_in_pus; j++) {
1926 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].is_intra = 1;
1927 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[0] = 0;
1928 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[1] = 0;
1929 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[0] = 0;
1930 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[1] = 0;
1931 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].x = 0;
1932 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].y = 0;
1933 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].x = 0;
1934 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].y = 0;
1938 return intra_pred_mode;
1941 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1942 int log2_cb_size, int ct_depth)
1944 int length = (1 << log2_cb_size) >> s->sps->log2_min_cb_size;
1945 int x_cb = x0 >> s->sps->log2_min_cb_size;
1946 int y_cb = y0 >> s->sps->log2_min_cb_size;
1949 for (y = 0; y < length; y++)
1950 memset(&s->tab_ct_depth[(y_cb + y) * s->sps->min_cb_width + x_cb],
1954 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1957 HEVCLocalContext *lc = &s->HEVClc;
1958 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1959 uint8_t prev_intra_luma_pred_flag[4];
1960 int split = lc->cu.part_mode == PART_NxN;
1961 int pb_size = (1 << log2_cb_size) >> split;
1962 int side = split + 1;
1966 for (i = 0; i < side; i++)
1967 for (j = 0; j < side; j++)
1968 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1970 for (i = 0; i < side; i++) {
1971 for (j = 0; j < side; j++) {
1972 if (prev_intra_luma_pred_flag[2 * i + j])
1973 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
1975 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
1977 lc->pu.intra_pred_mode[2 * i + j] =
1978 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1979 prev_intra_luma_pred_flag[2 * i + j]);
1983 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1984 if (chroma_mode != 4) {
1985 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1986 lc->pu.intra_pred_mode_c = 34;
1988 lc->pu.intra_pred_mode_c = intra_chroma_table[chroma_mode];
1990 lc->pu.intra_pred_mode_c = lc->pu.intra_pred_mode[0];
1994 static void intra_prediction_unit_default_value(HEVCContext *s,
1998 HEVCLocalContext *lc = &s->HEVClc;
1999 int pb_size = 1 << log2_cb_size;
2000 int size_in_pus = pb_size >> s->sps->log2_min_pu_size;
2001 int min_pu_width = s->sps->min_pu_width;
2002 MvField *tab_mvf = s->ref->tab_mvf;
2003 int x_pu = x0 >> s->sps->log2_min_pu_size;
2004 int y_pu = y0 >> s->sps->log2_min_pu_size;
2007 if (size_in_pus == 0)
2009 for (j = 0; j < size_in_pus; j++) {
2010 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
2011 for (k = 0; k < size_in_pus; k++)
2012 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].is_intra = lc->cu.pred_mode == MODE_INTRA;
2016 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
2018 int cb_size = 1 << log2_cb_size;
2019 HEVCLocalContext *lc = &s->HEVClc;
2020 int log2_min_cb_size = s->sps->log2_min_cb_size;
2021 int length = cb_size >> log2_min_cb_size;
2022 int min_cb_width = s->sps->min_cb_width;
2023 int x_cb = x0 >> log2_min_cb_size;
2024 int y_cb = y0 >> log2_min_cb_size;
2029 lc->cu.rqt_root_cbf = 1;
2030 lc->cu.pred_mode = MODE_INTRA;
2031 lc->cu.part_mode = PART_2Nx2N;
2032 lc->cu.intra_split_flag = 0;
2033 lc->cu.pcm_flag = 0;
2035 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
2036 for (x = 0; x < 4; x++)
2037 lc->pu.intra_pred_mode[x] = 1;
2038 if (s->pps->transquant_bypass_enable_flag) {
2039 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
2040 if (lc->cu.cu_transquant_bypass_flag)
2041 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2043 lc->cu.cu_transquant_bypass_flag = 0;
2045 if (s->sh.slice_type != I_SLICE) {
2046 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
2048 lc->cu.pred_mode = MODE_SKIP;
2049 x = y_cb * min_cb_width + x_cb;
2050 for (y = 0; y < length; y++) {
2051 memset(&s->skip_flag[x], skip_flag, length);
2054 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2057 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2058 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0);
2059 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2061 if (!s->sh.disable_deblocking_filter_flag)
2062 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size,
2063 lc->slice_or_tiles_up_boundary,
2064 lc->slice_or_tiles_left_boundary);
2066 if (s->sh.slice_type != I_SLICE)
2067 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2068 if (lc->cu.pred_mode != MODE_INTRA ||
2069 log2_cb_size == s->sps->log2_min_cb_size) {
2070 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2071 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2072 lc->cu.pred_mode == MODE_INTRA;
2075 if (lc->cu.pred_mode == MODE_INTRA) {
2076 if (lc->cu.part_mode == PART_2Nx2N && s->sps->pcm_enabled_flag &&
2077 log2_cb_size >= s->sps->pcm.log2_min_pcm_cb_size &&
2078 log2_cb_size <= s->sps->pcm.log2_max_pcm_cb_size) {
2079 lc->cu.pcm_flag = ff_hevc_pcm_flag_decode(s);
2081 if (lc->cu.pcm_flag) {
2083 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2084 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2085 if (s->sps->pcm.loop_filter_disable_flag)
2086 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2091 intra_prediction_unit(s, x0, y0, log2_cb_size);
2094 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2095 switch (lc->cu.part_mode) {
2097 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0);
2100 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0);
2101 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1);
2104 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0);
2105 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1);
2108 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0);
2109 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1);
2112 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0);
2113 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1);
2116 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0);
2117 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1);
2120 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0);
2121 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1);
2124 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0);
2125 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1);
2126 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2);
2127 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3);
2132 if (!lc->cu.pcm_flag) {
2133 if (lc->cu.pred_mode != MODE_INTRA &&
2134 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2135 lc->cu.rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2137 if (lc->cu.rqt_root_cbf) {
2138 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2139 s->sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2140 s->sps->max_transform_hierarchy_depth_inter;
2141 hls_transform_tree(s, x0, y0, x0, y0, x0, y0, log2_cb_size,
2142 log2_cb_size, 0, 0);
2144 if (!s->sh.disable_deblocking_filter_flag)
2145 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size,
2146 lc->slice_or_tiles_up_boundary,
2147 lc->slice_or_tiles_left_boundary);
2152 if (s->pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2153 ff_hevc_set_qPy(s, x0, y0, x0, y0, log2_cb_size);
2155 x = y_cb * min_cb_width + x_cb;
2156 for (y = 0; y < length; y++) {
2157 memset(&s->qp_y_tab[x], lc->qp_y, length);
2161 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct.depth);
2166 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2167 int log2_cb_size, int cb_depth)
2169 HEVCLocalContext *lc = &s->HEVClc;
2170 const int cb_size = 1 << log2_cb_size;
2172 lc->ct.depth = cb_depth;
2173 if (x0 + cb_size <= s->sps->width &&
2174 y0 + cb_size <= s->sps->height &&
2175 log2_cb_size > s->sps->log2_min_cb_size) {
2176 SAMPLE(s->split_cu_flag, x0, y0) =
2177 ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2179 SAMPLE(s->split_cu_flag, x0, y0) =
2180 (log2_cb_size > s->sps->log2_min_cb_size);
2182 if (s->pps->cu_qp_delta_enabled_flag &&
2183 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth) {
2184 lc->tu.is_cu_qp_delta_coded = 0;
2185 lc->tu.cu_qp_delta = 0;
2188 if (SAMPLE(s->split_cu_flag, x0, y0)) {
2189 const int cb_size_split = cb_size >> 1;
2190 const int x1 = x0 + cb_size_split;
2191 const int y1 = y0 + cb_size_split;
2196 #define SUBDIVIDE(x, y) \
2198 if (x < s->sps->width && y < s->sps->height) { \
2199 int ret = hls_coding_quadtree(s, x, y, log2_cb_size, cb_depth);\
2210 int ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2218 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2221 HEVCLocalContext *lc = &s->HEVClc;
2222 int ctb_size = 1 << s->sps->log2_ctb_size;
2223 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2224 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2226 int tile_left_boundary, tile_up_boundary;
2227 int slice_left_boundary, slice_up_boundary;
2229 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2231 if (s->pps->entropy_coding_sync_enabled_flag) {
2232 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2233 lc->first_qp_group = 1;
2234 lc->end_of_tiles_x = s->sps->width;
2235 } else if (s->pps->tiles_enabled_flag) {
2236 if (ctb_addr_ts && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1]) {
2237 int idxX = s->pps->col_idxX[x_ctb >> s->sps->log2_ctb_size];
2238 lc->start_of_tiles_x = x_ctb;
2239 lc->end_of_tiles_x = x_ctb + (s->pps->column_width[idxX] << s->sps->log2_ctb_size);
2240 lc->first_qp_group = 1;
2243 lc->end_of_tiles_x = s->sps->width;
2246 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->sps->height);
2248 if (s->pps->tiles_enabled_flag) {
2249 tile_left_boundary = x_ctb > 0 &&
2250 s->pps->tile_id[ctb_addr_ts] == s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs - 1]];
2251 slice_left_boundary = x_ctb > 0 &&
2252 s->tab_slice_address[ctb_addr_rs] == s->tab_slice_address[ctb_addr_rs - 1];
2253 tile_up_boundary = y_ctb > 0 &&
2254 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]];
2255 slice_up_boundary = y_ctb > 0 &&
2256 s->tab_slice_address[ctb_addr_rs] == s->tab_slice_address[ctb_addr_rs - s->sps->ctb_width];
2258 tile_left_boundary =
2259 tile_up_boundary = 1;
2260 slice_left_boundary = ctb_addr_in_slice > 0;
2261 slice_up_boundary = ctb_addr_in_slice >= s->sps->ctb_width;
2263 lc->slice_or_tiles_left_boundary = (!slice_left_boundary) + (!tile_left_boundary << 1);
2264 lc->slice_or_tiles_up_boundary = (!slice_up_boundary + (!tile_up_boundary << 1));
2265 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && tile_left_boundary);
2266 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->sps->ctb_width) && tile_up_boundary);
2267 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]]));
2268 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]]));
2271 static int hls_slice_data(HEVCContext *s)
2273 int ctb_size = 1 << s->sps->log2_ctb_size;
2277 int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2280 while (more_data && ctb_addr_ts < s->sps->ctb_size) {
2281 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2283 x_ctb = (ctb_addr_rs % ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2284 y_ctb = (ctb_addr_rs / ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2285 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2287 ff_hevc_cabac_init(s, ctb_addr_ts);
2289 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2291 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2292 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2293 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2295 ret = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2298 more_data = !ff_hevc_end_of_slice_flag_decode(s);
2301 ff_hevc_save_states(s, ctb_addr_ts);
2302 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2305 if (x_ctb + ctb_size >= s->sps->width &&
2306 y_ctb + ctb_size >= s->sps->height)
2307 ff_hevc_hls_filter(s, x_ctb, y_ctb);
2313 * @return AVERROR_INVALIDDATA if the packet is not a valid NAL unit,
2314 * 0 if the unit should be skipped, 1 otherwise
2316 static int hls_nal_unit(HEVCContext *s)
2318 GetBitContext *gb = &s->HEVClc.gb;
2321 if (get_bits1(gb) != 0)
2322 return AVERROR_INVALIDDATA;
2324 s->nal_unit_type = get_bits(gb, 6);
2326 nuh_layer_id = get_bits(gb, 6);
2327 s->temporal_id = get_bits(gb, 3) - 1;
2328 if (s->temporal_id < 0)
2329 return AVERROR_INVALIDDATA;
2331 av_log(s->avctx, AV_LOG_DEBUG,
2332 "nal_unit_type: %d, nuh_layer_id: %dtemporal_id: %d\n",
2333 s->nal_unit_type, nuh_layer_id, s->temporal_id);
2335 return nuh_layer_id == 0;
2338 static void restore_tqb_pixels(HEVCContext *s)
2340 int min_pu_size = 1 << s->sps->log2_min_pu_size;
2343 for (c_idx = 0; c_idx < 3; c_idx++) {
2344 ptrdiff_t stride = s->frame->linesize[c_idx];
2345 int hshift = s->sps->hshift[c_idx];
2346 int vshift = s->sps->vshift[c_idx];
2347 for (y = 0; y < s->sps->min_pu_height; y++) {
2348 for (x = 0; x < s->sps->min_pu_width; x++) {
2349 if (s->is_pcm[y * s->sps->min_pu_width + x]) {
2351 int len = min_pu_size >> hshift;
2352 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)];
2353 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)];
2354 for (n = 0; n < (min_pu_size >> vshift); n++) {
2355 memcpy(dst, src, len);
2365 static int set_side_data(HEVCContext *s)
2367 AVFrame *out = s->ref->frame;
2369 if (s->sei_frame_packing_present &&
2370 s->frame_packing_arrangement_type >= 3 &&
2371 s->frame_packing_arrangement_type <= 5 &&
2372 s->content_interpretation_type > 0 &&
2373 s->content_interpretation_type < 3) {
2374 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2376 return AVERROR(ENOMEM);
2378 switch (s->frame_packing_arrangement_type) {
2380 if (s->quincunx_subsampling)
2381 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2383 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2386 stereo->type = AV_STEREO3D_TOPBOTTOM;
2389 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2393 if (s->content_interpretation_type == 2)
2394 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2400 static int hevc_frame_start(HEVCContext *s)
2402 HEVCLocalContext *lc = &s->HEVClc;
2405 memset(s->horizontal_bs, 0, 2 * s->bs_width * (s->bs_height + 1));
2406 memset(s->vertical_bs, 0, 2 * s->bs_width * (s->bs_height + 1));
2407 memset(s->cbf_luma, 0, s->sps->min_tb_width * s->sps->min_tb_height);
2408 memset(s->is_pcm, 0, s->sps->min_pu_width * s->sps->min_pu_height);
2410 lc->start_of_tiles_x = 0;
2413 if (s->pps->tiles_enabled_flag)
2414 lc->end_of_tiles_x = s->pps->column_width[0] << s->sps->log2_ctb_size;
2416 ret = ff_hevc_set_new_ref(s, s->sps->sao_enabled ? &s->sao_frame : &s->frame,
2421 av_fast_malloc(&lc->edge_emu_buffer, &lc->edge_emu_buffer_size,
2422 (MAX_PB_SIZE + 7) * s->ref->frame->linesize[0]);
2423 if (!lc->edge_emu_buffer) {
2424 ret = AVERROR(ENOMEM);
2428 ret = ff_hevc_frame_rps(s);
2430 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2434 ret = set_side_data(s);
2438 av_frame_unref(s->output_frame);
2439 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2443 ff_thread_finish_setup(s->avctx);
2449 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2454 static int decode_nal_unit(HEVCContext *s, const uint8_t *nal, int length)
2456 HEVCLocalContext *lc = &s->HEVClc;
2457 GetBitContext *gb = &lc->gb;
2458 int ctb_addr_ts, ret;
2460 ret = init_get_bits8(gb, nal, length);
2464 ret = hls_nal_unit(s);
2466 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit %d, skipping.\n",
2468 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2474 switch (s->nal_unit_type) {
2476 ret = ff_hevc_decode_nal_vps(s);
2481 ret = ff_hevc_decode_nal_sps(s);
2486 ret = ff_hevc_decode_nal_pps(s);
2490 case NAL_SEI_PREFIX:
2491 case NAL_SEI_SUFFIX:
2492 ret = ff_hevc_decode_nal_sei(s);
2503 case NAL_BLA_W_RADL:
2505 case NAL_IDR_W_RADL:
2512 ret = hls_slice_header(s);
2516 if (s->max_ra == INT_MAX) {
2517 if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
2521 s->max_ra = INT_MIN;
2525 if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
2526 s->poc <= s->max_ra) {
2530 if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
2531 s->max_ra = INT_MIN;
2534 if (s->sh.first_slice_in_pic_flag) {
2535 ret = hevc_frame_start(s);
2538 } else if (!s->ref) {
2539 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2540 return AVERROR_INVALIDDATA;
2543 if (!s->sh.dependent_slice_segment_flag &&
2544 s->sh.slice_type != I_SLICE) {
2545 ret = ff_hevc_slice_rpl(s);
2547 av_log(s->avctx, AV_LOG_WARNING,
2548 "Error constructing the reference lists for the current slice.\n");
2549 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2554 ctb_addr_ts = hls_slice_data(s);
2555 if (ctb_addr_ts >= (s->sps->ctb_width * s->sps->ctb_height)) {
2557 if ((s->pps->transquant_bypass_enable_flag ||
2558 (s->sps->pcm.loop_filter_disable_flag && s->sps->pcm_enabled_flag)) &&
2559 s->sps->sao_enabled)
2560 restore_tqb_pixels(s);
2563 if (ctb_addr_ts < 0)
2568 s->seq_decode = (s->seq_decode + 1) & 0xff;
2569 s->max_ra = INT_MAX;
2575 av_log(s->avctx, AV_LOG_INFO,
2576 "Skipping NAL unit %d\n", s->nal_unit_type);
2582 /* FIXME: This is adapted from ff_h264_decode_nal, avoiding duplication
2583 * between these functions would be nice. */
2584 static int extract_rbsp(const uint8_t *src, int length,
2590 #define STARTCODE_TEST \
2591 if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \
2592 if (src[i + 2] != 3) { \
2593 /* startcode, so we must be past the end */ \
2598 #if HAVE_FAST_UNALIGNED
2599 #define FIND_FIRST_ZERO \
2600 if (i > 0 && !src[i]) \
2605 for (i = 0; i + 1 < length; i += 9) {
2606 if (!((~AV_RN64A(src + i) &
2607 (AV_RN64A(src + i) - 0x0100010001000101ULL)) &
2608 0x8000800080008080ULL))
2615 for (i = 0; i + 1 < length; i += 5) {
2616 if (!((~AV_RN32A(src + i) &
2617 (AV_RN32A(src + i) - 0x01000101U)) &
2624 #endif /* HAVE_FAST_64BIT */
2626 for (i = 0; i + 1 < length; i += 2) {
2629 if (i > 0 && src[i - 1] == 0)
2633 #endif /* HAVE_FAST_UNALIGNED */
2635 if (i >= length - 1) { // no escaped 0
2641 av_fast_malloc(&nal->rbsp_buffer, &nal->rbsp_buffer_size,
2642 length + FF_INPUT_BUFFER_PADDING_SIZE);
2643 if (!nal->rbsp_buffer)
2644 return AVERROR(ENOMEM);
2646 dst = nal->rbsp_buffer;
2648 memcpy(dst, src, i);
2650 while (si + 2 < length) {
2651 // remove escapes (very rare 1:2^22)
2652 if (src[si + 2] > 3) {
2653 dst[di++] = src[si++];
2654 dst[di++] = src[si++];
2655 } else if (src[si] == 0 && src[si + 1] == 0) {
2656 if (src[si + 2] == 3) { // escape
2662 } else // next start code
2666 dst[di++] = src[si++];
2669 dst[di++] = src[si++];
2672 memset(dst + di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2679 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2681 int i, consumed, ret = 0;
2686 /* split the input packet into NAL units, so we know the upper bound on the
2687 * number of slices in the frame */
2689 while (length >= 4) {
2691 int extract_length = 0;
2695 for (i = 0; i < s->nal_length_size; i++)
2696 extract_length = (extract_length << 8) | buf[i];
2697 buf += s->nal_length_size;
2698 length -= s->nal_length_size;
2700 if (extract_length > length) {
2701 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit size.\n");
2702 ret = AVERROR_INVALIDDATA;
2711 if (buf[0] != 0 || buf[1] != 0 || buf[2] != 1) {
2712 ret = AVERROR_INVALIDDATA;
2718 extract_length = length;
2721 if (s->nals_allocated < s->nb_nals + 1) {
2722 int new_size = s->nals_allocated + 1;
2723 HEVCNAL *tmp = av_realloc_array(s->nals, new_size, sizeof(*tmp));
2725 ret = AVERROR(ENOMEM);
2729 memset(s->nals + s->nals_allocated, 0,
2730 (new_size - s->nals_allocated) * sizeof(*tmp));
2731 s->nals_allocated = new_size;
2733 nal = &s->nals[s->nb_nals++];
2735 consumed = extract_rbsp(buf, extract_length, nal);
2741 ret = init_get_bits8(&s->HEVClc.gb, nal->data, nal->size);
2746 if (s->nal_unit_type == NAL_EOB_NUT ||
2747 s->nal_unit_type == NAL_EOS_NUT)
2754 /* parse the NAL units */
2755 for (i = 0; i < s->nb_nals; i++) {
2756 int ret = decode_nal_unit(s, s->nals[i].data, s->nals[i].size);
2758 av_log(s->avctx, AV_LOG_WARNING,
2759 "Error parsing NAL unit #%d.\n", i);
2760 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2767 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2772 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2775 for (i = 0; i < 16; i++)
2776 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
2779 static int verify_md5(HEVCContext *s, AVFrame *frame)
2781 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
2786 return AVERROR(EINVAL);
2788 pixel_shift = desc->comp[0].depth_minus1 > 7;
2790 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
2793 /* the checksums are LE, so we have to byteswap for >8bpp formats
2796 if (pixel_shift && !s->checksum_buf) {
2797 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
2798 FFMAX3(frame->linesize[0], frame->linesize[1],
2799 frame->linesize[2]));
2800 if (!s->checksum_buf)
2801 return AVERROR(ENOMEM);
2805 for (i = 0; frame->data[i]; i++) {
2806 int width = s->avctx->coded_width;
2807 int height = s->avctx->coded_height;
2808 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
2809 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
2812 av_md5_init(s->md5_ctx);
2813 for (j = 0; j < h; j++) {
2814 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
2817 s->dsp.bswap16_buf((uint16_t*)s->checksum_buf,
2818 (const uint16_t*)src, w);
2819 src = s->checksum_buf;
2822 av_md5_update(s->md5_ctx, src, w << pixel_shift);
2824 av_md5_final(s->md5_ctx, md5);
2826 if (!memcmp(md5, s->md5[i], 16)) {
2827 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
2828 print_md5(s->avctx, AV_LOG_DEBUG, md5);
2829 av_log (s->avctx, AV_LOG_DEBUG, "; ");
2831 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
2832 print_md5(s->avctx, AV_LOG_ERROR, md5);
2833 av_log (s->avctx, AV_LOG_ERROR, " != ");
2834 print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
2835 av_log (s->avctx, AV_LOG_ERROR, "\n");
2836 return AVERROR_INVALIDDATA;
2840 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2845 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
2849 HEVCContext *s = avctx->priv_data;
2852 ret = ff_hevc_output_frame(s, data, 1);
2861 ret = decode_nal_units(s, avpkt->data, avpkt->size);
2865 /* verify the SEI checksum */
2866 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
2868 ret = verify_md5(s, s->ref->frame);
2869 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
2870 ff_hevc_unref_frame(s, s->ref, ~0);
2876 if (s->is_decoded) {
2877 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
2881 if (s->output_frame->buf[0]) {
2882 av_frame_move_ref(data, s->output_frame);
2889 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
2891 int ret = ff_thread_ref_frame(&dst->tf, &src->tf);
2895 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
2896 if (!dst->tab_mvf_buf)
2898 dst->tab_mvf = src->tab_mvf;
2900 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
2901 if (!dst->rpl_tab_buf)
2903 dst->rpl_tab = src->rpl_tab;
2905 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
2909 dst->poc = src->poc;
2910 dst->ctb_count = src->ctb_count;
2911 dst->window = src->window;
2912 dst->flags = src->flags;
2913 dst->sequence = src->sequence;
2917 ff_hevc_unref_frame(s, dst, ~0);
2918 return AVERROR(ENOMEM);
2921 static av_cold int hevc_decode_free(AVCodecContext *avctx)
2923 HEVCContext *s = avctx->priv_data;
2924 HEVCLocalContext *lc = &s->HEVClc;
2929 av_freep(&lc->edge_emu_buffer);
2930 av_freep(&s->md5_ctx);
2932 av_frame_free(&s->tmp_frame);
2933 av_frame_free(&s->output_frame);
2935 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2936 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
2937 av_frame_free(&s->DPB[i].frame);
2940 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++)
2941 av_buffer_unref(&s->vps_list[i]);
2942 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++)
2943 av_buffer_unref(&s->sps_list[i]);
2944 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
2945 av_buffer_unref(&s->pps_list[i]);
2947 for (i = 0; i < s->nals_allocated; i++)
2948 av_freep(&s->nals[i].rbsp_buffer);
2950 s->nals_allocated = 0;
2955 static av_cold int hevc_init_context(AVCodecContext *avctx)
2957 HEVCContext *s = avctx->priv_data;
2962 s->tmp_frame = av_frame_alloc();
2966 s->output_frame = av_frame_alloc();
2967 if (!s->output_frame)
2970 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2971 s->DPB[i].frame = av_frame_alloc();
2972 if (!s->DPB[i].frame)
2974 s->DPB[i].tf.f = s->DPB[i].frame;
2977 s->max_ra = INT_MAX;
2979 s->md5_ctx = av_md5_alloc();
2983 ff_dsputil_init(&s->dsp, avctx);
2985 s->context_initialized = 1;
2990 hevc_decode_free(avctx);
2991 return AVERROR(ENOMEM);
2994 static int hevc_update_thread_context(AVCodecContext *dst,
2995 const AVCodecContext *src)
2997 HEVCContext *s = dst->priv_data;
2998 HEVCContext *s0 = src->priv_data;
3001 if (!s->context_initialized) {
3002 ret = hevc_init_context(dst);
3007 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3008 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3009 if (s0->DPB[i].frame->buf[0]) {
3010 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3016 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++) {
3017 av_buffer_unref(&s->vps_list[i]);
3018 if (s0->vps_list[i]) {
3019 s->vps_list[i] = av_buffer_ref(s0->vps_list[i]);
3020 if (!s->vps_list[i])
3021 return AVERROR(ENOMEM);
3025 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++) {
3026 av_buffer_unref(&s->sps_list[i]);
3027 if (s0->sps_list[i]) {
3028 s->sps_list[i] = av_buffer_ref(s0->sps_list[i]);
3029 if (!s->sps_list[i])
3030 return AVERROR(ENOMEM);
3034 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++) {
3035 av_buffer_unref(&s->pps_list[i]);
3036 if (s0->pps_list[i]) {
3037 s->pps_list[i] = av_buffer_ref(s0->pps_list[i]);
3038 if (!s->pps_list[i])
3039 return AVERROR(ENOMEM);
3043 if (s->sps != s0->sps)
3044 ret = set_sps(s, s0->sps);
3046 s->seq_decode = s0->seq_decode;
3047 s->seq_output = s0->seq_output;
3048 s->pocTid0 = s0->pocTid0;
3049 s->max_ra = s0->max_ra;
3051 s->is_nalff = s0->is_nalff;
3052 s->nal_length_size = s0->nal_length_size;
3055 s->seq_decode = (s->seq_decode + 1) & 0xff;
3056 s->max_ra = INT_MAX;
3062 static int hevc_decode_extradata(HEVCContext *s)
3064 AVCodecContext *avctx = s->avctx;
3068 bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
3070 if (avctx->extradata_size > 3 &&
3071 (avctx->extradata[0] || avctx->extradata[1] ||
3072 avctx->extradata[2] > 1)) {
3073 /* It seems the extradata is encoded as hvcC format.
3074 * Temporarily, we support configurationVersion==0 until 14496-15 3rd
3075 * is finalized. When finalized, configurationVersion will be 1 and we
3076 * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
3077 int i, j, num_arrays, nal_len_size;
3081 bytestream2_skip(&gb, 21);
3082 nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
3083 num_arrays = bytestream2_get_byte(&gb);
3085 /* nal units in the hvcC always have length coded with 2 bytes,
3086 * so put a fake nal_length_size = 2 while parsing them */
3087 s->nal_length_size = 2;
3089 /* Decode nal units from hvcC. */
3090 for (i = 0; i < num_arrays; i++) {
3091 int type = bytestream2_get_byte(&gb) & 0x3f;
3092 int cnt = bytestream2_get_be16(&gb);
3094 for (j = 0; j < cnt; j++) {
3095 // +2 for the nal size field
3096 int nalsize = bytestream2_peek_be16(&gb) + 2;
3097 if (bytestream2_get_bytes_left(&gb) < nalsize) {
3098 av_log(s->avctx, AV_LOG_ERROR,
3099 "Invalid NAL unit size in extradata.\n");
3100 return AVERROR_INVALIDDATA;
3103 ret = decode_nal_units(s, gb.buffer, nalsize);
3105 av_log(avctx, AV_LOG_ERROR,
3106 "Decoding nal unit %d %d from hvcC failed\n",
3110 bytestream2_skip(&gb, nalsize);
3114 /* Now store right nal length size, that will be used to parse
3116 s->nal_length_size = nal_len_size;
3119 ret = decode_nal_units(s, avctx->extradata, avctx->extradata_size);
3126 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3128 HEVCContext *s = avctx->priv_data;
3131 ff_init_cabac_states();
3133 avctx->internal->allocate_progress = 1;
3135 ret = hevc_init_context(avctx);
3139 if (avctx->extradata_size > 0 && avctx->extradata) {
3140 ret = hevc_decode_extradata(s);
3142 hevc_decode_free(avctx);
3150 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3152 HEVCContext *s = avctx->priv_data;
3155 memset(s, 0, sizeof(*s));
3157 ret = hevc_init_context(avctx);
3164 static void hevc_decode_flush(AVCodecContext *avctx)
3166 HEVCContext *s = avctx->priv_data;
3167 ff_hevc_flush_dpb(s);
3168 s->max_ra = INT_MAX;
3171 #define OFFSET(x) offsetof(HEVCContext, x)
3172 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3173 static const AVOption options[] = {
3174 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3175 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3179 static const AVClass hevc_decoder_class = {
3180 .class_name = "HEVC decoder",
3181 .item_name = av_default_item_name,
3183 .version = LIBAVUTIL_VERSION_INT,
3186 AVCodec ff_hevc_decoder = {
3188 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3189 .type = AVMEDIA_TYPE_VIDEO,
3190 .id = AV_CODEC_ID_HEVC,
3191 .priv_data_size = sizeof(HEVCContext),
3192 .priv_class = &hevc_decoder_class,
3193 .init = hevc_decode_init,
3194 .close = hevc_decode_free,
3195 .decode = hevc_decode_frame,
3196 .flush = hevc_decode_flush,
3197 .update_thread_context = hevc_update_thread_context,
3198 .init_thread_copy = hevc_init_thread_copy,
3199 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY |
3200 CODEC_CAP_FRAME_THREADS,