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 unsigned 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 s->avctx->profile = s->sps->ptl.general_ptl.profile_idc;
499 s->avctx->level = s->sps->ptl.general_ptl.level_idc;
501 sh->dependent_slice_segment_flag = 0;
502 if (!sh->first_slice_in_pic_flag) {
503 int slice_address_length;
505 if (s->pps->dependent_slice_segments_enabled_flag)
506 sh->dependent_slice_segment_flag = get_bits1(gb);
508 slice_address_length = av_ceil_log2(s->sps->ctb_width *
510 sh->slice_segment_addr = get_bits(gb, slice_address_length);
511 if (sh->slice_segment_addr >= s->sps->ctb_width * s->sps->ctb_height) {
512 av_log(s->avctx, AV_LOG_ERROR,
513 "Invalid slice segment address: %u.\n",
514 sh->slice_segment_addr);
515 return AVERROR_INVALIDDATA;
518 if (!sh->dependent_slice_segment_flag) {
519 sh->slice_addr = sh->slice_segment_addr;
523 sh->slice_segment_addr = sh->slice_addr = 0;
525 s->slice_initialized = 0;
528 if (!sh->dependent_slice_segment_flag) {
529 s->slice_initialized = 0;
531 for (i = 0; i < s->pps->num_extra_slice_header_bits; i++)
532 skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
534 sh->slice_type = get_ue_golomb_long(gb);
535 if (!(sh->slice_type == I_SLICE ||
536 sh->slice_type == P_SLICE ||
537 sh->slice_type == B_SLICE)) {
538 av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
540 return AVERROR_INVALIDDATA;
542 if (IS_IRAP(s) && sh->slice_type != I_SLICE) {
543 av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
544 return AVERROR_INVALIDDATA;
547 if (s->pps->output_flag_present_flag)
548 sh->pic_output_flag = get_bits1(gb);
550 if (s->sps->separate_colour_plane_flag)
551 sh->colour_plane_id = get_bits(gb, 2);
554 int short_term_ref_pic_set_sps_flag, poc;
556 sh->pic_order_cnt_lsb = get_bits(gb, s->sps->log2_max_poc_lsb);
557 poc = ff_hevc_compute_poc(s, sh->pic_order_cnt_lsb);
558 if (!sh->first_slice_in_pic_flag && poc != s->poc) {
559 av_log(s->avctx, AV_LOG_WARNING,
560 "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
561 if (s->avctx->err_recognition & AV_EF_EXPLODE)
562 return AVERROR_INVALIDDATA;
567 short_term_ref_pic_set_sps_flag = get_bits1(gb);
568 if (!short_term_ref_pic_set_sps_flag) {
569 ret = ff_hevc_decode_short_term_rps(s, &sh->slice_rps, s->sps, 1);
573 sh->short_term_rps = &sh->slice_rps;
575 int numbits, rps_idx;
577 if (!s->sps->nb_st_rps) {
578 av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
579 return AVERROR_INVALIDDATA;
582 numbits = av_ceil_log2(s->sps->nb_st_rps);
583 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
584 sh->short_term_rps = &s->sps->st_rps[rps_idx];
587 ret = decode_lt_rps(s, &sh->long_term_rps, gb);
589 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
590 if (s->avctx->err_recognition & AV_EF_EXPLODE)
591 return AVERROR_INVALIDDATA;
594 if (s->sps->sps_temporal_mvp_enabled_flag)
595 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
597 sh->slice_temporal_mvp_enabled_flag = 0;
599 s->sh.short_term_rps = NULL;
604 if (s->temporal_id == 0 &&
605 s->nal_unit_type != NAL_TRAIL_N &&
606 s->nal_unit_type != NAL_TSA_N &&
607 s->nal_unit_type != NAL_STSA_N &&
608 s->nal_unit_type != NAL_RADL_N &&
609 s->nal_unit_type != NAL_RADL_R &&
610 s->nal_unit_type != NAL_RASL_N &&
611 s->nal_unit_type != NAL_RASL_R)
614 if (s->sps->sao_enabled) {
615 sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
616 sh->slice_sample_adaptive_offset_flag[1] =
617 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
619 sh->slice_sample_adaptive_offset_flag[0] = 0;
620 sh->slice_sample_adaptive_offset_flag[1] = 0;
621 sh->slice_sample_adaptive_offset_flag[2] = 0;
624 sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
625 if (sh->slice_type == P_SLICE || sh->slice_type == B_SLICE) {
628 sh->nb_refs[L0] = s->pps->num_ref_idx_l0_default_active;
629 if (sh->slice_type == B_SLICE)
630 sh->nb_refs[L1] = s->pps->num_ref_idx_l1_default_active;
632 if (get_bits1(gb)) { // num_ref_idx_active_override_flag
633 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
634 if (sh->slice_type == B_SLICE)
635 sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
637 if (sh->nb_refs[L0] > MAX_REFS || sh->nb_refs[L1] > MAX_REFS) {
638 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
639 sh->nb_refs[L0], sh->nb_refs[L1]);
640 return AVERROR_INVALIDDATA;
643 sh->rpl_modification_flag[0] = 0;
644 sh->rpl_modification_flag[1] = 0;
645 nb_refs = ff_hevc_frame_nb_refs(s);
647 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
648 return AVERROR_INVALIDDATA;
651 if (s->pps->lists_modification_present_flag && nb_refs > 1) {
652 sh->rpl_modification_flag[0] = get_bits1(gb);
653 if (sh->rpl_modification_flag[0]) {
654 for (i = 0; i < sh->nb_refs[L0]; i++)
655 sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
658 if (sh->slice_type == B_SLICE) {
659 sh->rpl_modification_flag[1] = get_bits1(gb);
660 if (sh->rpl_modification_flag[1] == 1)
661 for (i = 0; i < sh->nb_refs[L1]; i++)
662 sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
666 if (sh->slice_type == B_SLICE)
667 sh->mvd_l1_zero_flag = get_bits1(gb);
669 if (s->pps->cabac_init_present_flag)
670 sh->cabac_init_flag = get_bits1(gb);
672 sh->cabac_init_flag = 0;
674 sh->collocated_ref_idx = 0;
675 if (sh->slice_temporal_mvp_enabled_flag) {
676 sh->collocated_list = L0;
677 if (sh->slice_type == B_SLICE)
678 sh->collocated_list = !get_bits1(gb);
680 if (sh->nb_refs[sh->collocated_list] > 1) {
681 sh->collocated_ref_idx = get_ue_golomb_long(gb);
682 if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
683 av_log(s->avctx, AV_LOG_ERROR,
684 "Invalid collocated_ref_idx: %d.\n",
685 sh->collocated_ref_idx);
686 return AVERROR_INVALIDDATA;
691 if ((s->pps->weighted_pred_flag && sh->slice_type == P_SLICE) ||
692 (s->pps->weighted_bipred_flag && sh->slice_type == B_SLICE)) {
693 pred_weight_table(s, gb);
696 sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
697 if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
698 av_log(s->avctx, AV_LOG_ERROR,
699 "Invalid number of merging MVP candidates: %d.\n",
700 sh->max_num_merge_cand);
701 return AVERROR_INVALIDDATA;
705 sh->slice_qp_delta = get_se_golomb(gb);
706 if (s->pps->pic_slice_level_chroma_qp_offsets_present_flag) {
707 sh->slice_cb_qp_offset = get_se_golomb(gb);
708 sh->slice_cr_qp_offset = get_se_golomb(gb);
710 sh->slice_cb_qp_offset = 0;
711 sh->slice_cr_qp_offset = 0;
714 if (s->pps->deblocking_filter_control_present_flag) {
715 int deblocking_filter_override_flag = 0;
717 if (s->pps->deblocking_filter_override_enabled_flag)
718 deblocking_filter_override_flag = get_bits1(gb);
720 if (deblocking_filter_override_flag) {
721 sh->disable_deblocking_filter_flag = get_bits1(gb);
722 if (!sh->disable_deblocking_filter_flag) {
723 sh->beta_offset = get_se_golomb(gb) * 2;
724 sh->tc_offset = get_se_golomb(gb) * 2;
727 sh->disable_deblocking_filter_flag = s->pps->disable_dbf;
728 sh->beta_offset = s->pps->beta_offset;
729 sh->tc_offset = s->pps->tc_offset;
732 sh->disable_deblocking_filter_flag = 0;
737 if (s->pps->seq_loop_filter_across_slices_enabled_flag &&
738 (sh->slice_sample_adaptive_offset_flag[0] ||
739 sh->slice_sample_adaptive_offset_flag[1] ||
740 !sh->disable_deblocking_filter_flag)) {
741 sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
743 sh->slice_loop_filter_across_slices_enabled_flag = s->pps->seq_loop_filter_across_slices_enabled_flag;
745 } else if (!s->slice_initialized) {
746 av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
747 return AVERROR_INVALIDDATA;
750 sh->num_entry_point_offsets = 0;
751 if (s->pps->tiles_enabled_flag || s->pps->entropy_coding_sync_enabled_flag) {
752 sh->num_entry_point_offsets = get_ue_golomb_long(gb);
753 if (sh->num_entry_point_offsets > 0) {
754 int offset_len = get_ue_golomb_long(gb) + 1;
756 for (i = 0; i < sh->num_entry_point_offsets; i++)
757 skip_bits(gb, offset_len);
761 if (s->pps->slice_header_extension_present_flag) {
762 unsigned int length = get_ue_golomb_long(gb);
763 for (i = 0; i < length; i++)
764 skip_bits(gb, 8); // slice_header_extension_data_byte
767 // Inferred parameters
768 sh->slice_qp = 26 + s->pps->pic_init_qp_minus26 + sh->slice_qp_delta;
769 sh->slice_ctb_addr_rs = sh->slice_segment_addr;
771 s->HEVClc.first_qp_group = !s->sh.dependent_slice_segment_flag;
773 if (!s->pps->cu_qp_delta_enabled_flag)
774 s->HEVClc.qp_y = FFUMOD(s->sh.slice_qp + 52 + 2 * s->sps->qp_bd_offset,
775 52 + s->sps->qp_bd_offset) - s->sps->qp_bd_offset;
777 s->slice_initialized = 1;
782 #define CTB(tab, x, y) ((tab)[(y) * s->sps->ctb_width + (x)])
784 #define SET_SAO(elem, value) \
786 if (!sao_merge_up_flag && !sao_merge_left_flag) \
788 else if (sao_merge_left_flag) \
789 sao->elem = CTB(s->sao, rx-1, ry).elem; \
790 else if (sao_merge_up_flag) \
791 sao->elem = CTB(s->sao, rx, ry-1).elem; \
796 static void hls_sao_param(HEVCContext *s, int rx, int ry)
798 HEVCLocalContext *lc = &s->HEVClc;
799 int sao_merge_left_flag = 0;
800 int sao_merge_up_flag = 0;
801 int shift = s->sps->bit_depth - FFMIN(s->sps->bit_depth, 10);
802 SAOParams *sao = &CTB(s->sao, rx, ry);
805 if (s->sh.slice_sample_adaptive_offset_flag[0] ||
806 s->sh.slice_sample_adaptive_offset_flag[1]) {
808 if (lc->ctb_left_flag)
809 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
811 if (ry > 0 && !sao_merge_left_flag) {
813 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
817 for (c_idx = 0; c_idx < 3; c_idx++) {
818 if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
819 sao->type_idx[c_idx] = SAO_NOT_APPLIED;
824 sao->type_idx[2] = sao->type_idx[1];
825 sao->eo_class[2] = sao->eo_class[1];
827 SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
830 if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
833 for (i = 0; i < 4; i++)
834 SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
836 if (sao->type_idx[c_idx] == SAO_BAND) {
837 for (i = 0; i < 4; i++) {
838 if (sao->offset_abs[c_idx][i]) {
839 SET_SAO(offset_sign[c_idx][i],
840 ff_hevc_sao_offset_sign_decode(s));
842 sao->offset_sign[c_idx][i] = 0;
845 SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
846 } else if (c_idx != 2) {
847 SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
850 // Inferred parameters
851 sao->offset_val[c_idx][0] = 0;
852 for (i = 0; i < 4; i++) {
853 sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i] << shift;
854 if (sao->type_idx[c_idx] == SAO_EDGE) {
856 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
857 } else if (sao->offset_sign[c_idx][i]) {
858 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
867 static void hls_residual_coding(HEVCContext *s, int x0, int y0,
868 int log2_trafo_size, enum ScanType scan_idx,
871 #define GET_COORD(offset, n) \
873 x_c = (scan_x_cg[offset >> 4] << 2) + scan_x_off[n]; \
874 y_c = (scan_y_cg[offset >> 4] << 2) + scan_y_off[n]; \
876 HEVCLocalContext *lc = &s->HEVClc;
877 int transform_skip_flag = 0;
879 int last_significant_coeff_x, last_significant_coeff_y;
883 int greater1_ctx = 1;
886 int x_cg_last_sig, y_cg_last_sig;
888 const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
890 ptrdiff_t stride = s->frame->linesize[c_idx];
891 int hshift = s->sps->hshift[c_idx];
892 int vshift = s->sps->vshift[c_idx];
893 uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
894 ((x0 >> hshift) << s->sps->pixel_shift)];
895 DECLARE_ALIGNED(16, int16_t, coeffs[MAX_TB_SIZE * MAX_TB_SIZE]) = { 0 };
896 DECLARE_ALIGNED(8, uint8_t, significant_coeff_group_flag[8][8]) = { { 0 } };
898 int trafo_size = 1 << log2_trafo_size;
899 int i, qp, shift, add, scale, scale_m;
900 const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
901 const uint8_t *scale_matrix;
904 // Derive QP for dequant
905 if (!lc->cu.cu_transquant_bypass_flag) {
906 static const int qp_c[] = {
907 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37
910 static const uint8_t rem6[51 + 2 * 6 + 1] = {
911 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
912 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
913 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
916 static const uint8_t div6[51 + 2 * 6 + 1] = {
917 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
918 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
919 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
924 qp = qp_y + s->sps->qp_bd_offset;
929 offset = s->pps->cb_qp_offset + s->sh.slice_cb_qp_offset;
931 offset = s->pps->cr_qp_offset + s->sh.slice_cr_qp_offset;
933 qp_i = av_clip_c(qp_y + offset, -s->sps->qp_bd_offset, 57);
939 qp = qp_c[qp_i - 30];
941 qp += s->sps->qp_bd_offset;
944 shift = s->sps->bit_depth + log2_trafo_size - 5;
945 add = 1 << (shift - 1);
946 scale = level_scale[rem6[qp]] << (div6[qp]);
947 scale_m = 16; // default when no custom scaling lists.
950 if (s->sps->scaling_list_enable_flag) {
951 const ScalingList *sl = s->pps->scaling_list_data_present_flag ?
952 &s->pps->scaling_list : &s->sps->scaling_list;
953 int matrix_id = lc->cu.pred_mode != MODE_INTRA;
955 if (log2_trafo_size != 5)
956 matrix_id = 3 * matrix_id + c_idx;
958 scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
959 if (log2_trafo_size >= 4)
960 dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
964 if (s->pps->transform_skip_enabled_flag &&
965 !lc->cu.cu_transquant_bypass_flag &&
966 log2_trafo_size == 2) {
967 transform_skip_flag = ff_hevc_transform_skip_flag_decode(s, c_idx);
970 last_significant_coeff_x =
971 ff_hevc_last_significant_coeff_x_prefix_decode(s, c_idx, log2_trafo_size);
972 last_significant_coeff_y =
973 ff_hevc_last_significant_coeff_y_prefix_decode(s, c_idx, log2_trafo_size);
975 if (last_significant_coeff_x > 3) {
976 int suffix = ff_hevc_last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
977 last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
978 (2 + (last_significant_coeff_x & 1)) +
982 if (last_significant_coeff_y > 3) {
983 int suffix = ff_hevc_last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
984 last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
985 (2 + (last_significant_coeff_y & 1)) +
989 if (scan_idx == SCAN_VERT)
990 FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
992 x_cg_last_sig = last_significant_coeff_x >> 2;
993 y_cg_last_sig = last_significant_coeff_y >> 2;
997 int last_x_c = last_significant_coeff_x & 3;
998 int last_y_c = last_significant_coeff_y & 3;
1000 scan_x_off = ff_hevc_diag_scan4x4_x;
1001 scan_y_off = ff_hevc_diag_scan4x4_y;
1002 num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
1003 if (trafo_size == 4) {
1004 scan_x_cg = scan_1x1;
1005 scan_y_cg = scan_1x1;
1006 } else if (trafo_size == 8) {
1007 num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1008 scan_x_cg = diag_scan2x2_x;
1009 scan_y_cg = diag_scan2x2_y;
1010 } else if (trafo_size == 16) {
1011 num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1012 scan_x_cg = ff_hevc_diag_scan4x4_x;
1013 scan_y_cg = ff_hevc_diag_scan4x4_y;
1014 } else { // trafo_size == 32
1015 num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1016 scan_x_cg = ff_hevc_diag_scan8x8_x;
1017 scan_y_cg = ff_hevc_diag_scan8x8_y;
1022 scan_x_cg = horiz_scan2x2_x;
1023 scan_y_cg = horiz_scan2x2_y;
1024 scan_x_off = horiz_scan4x4_x;
1025 scan_y_off = horiz_scan4x4_y;
1026 num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1028 default: //SCAN_VERT
1029 scan_x_cg = horiz_scan2x2_y;
1030 scan_y_cg = horiz_scan2x2_x;
1031 scan_x_off = horiz_scan4x4_y;
1032 scan_y_off = horiz_scan4x4_x;
1033 num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1037 num_last_subset = (num_coeff - 1) >> 4;
1039 for (i = num_last_subset; i >= 0; i--) {
1041 int x_cg, y_cg, x_c, y_c;
1042 int implicit_non_zero_coeff = 0;
1043 int64_t trans_coeff_level;
1045 int offset = i << 4;
1047 uint8_t significant_coeff_flag_idx[16];
1048 uint8_t nb_significant_coeff_flag = 0;
1050 x_cg = scan_x_cg[i];
1051 y_cg = scan_y_cg[i];
1053 if (i < num_last_subset && i > 0) {
1055 if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1056 ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1057 if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1058 ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1060 significant_coeff_group_flag[x_cg][y_cg] =
1061 ff_hevc_significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
1062 implicit_non_zero_coeff = 1;
1064 significant_coeff_group_flag[x_cg][y_cg] =
1065 ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1066 (x_cg == 0 && y_cg == 0));
1069 last_scan_pos = num_coeff - offset - 1;
1071 if (i == num_last_subset) {
1072 n_end = last_scan_pos - 1;
1073 significant_coeff_flag_idx[0] = last_scan_pos;
1074 nb_significant_coeff_flag = 1;
1079 if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1080 prev_sig = significant_coeff_group_flag[x_cg + 1][y_cg];
1081 if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1082 prev_sig += significant_coeff_group_flag[x_cg][y_cg + 1] << 1;
1084 for (n = n_end; n >= 0; n--) {
1085 GET_COORD(offset, n);
1087 if (significant_coeff_group_flag[x_cg][y_cg] &&
1088 (n > 0 || implicit_non_zero_coeff == 0)) {
1089 if (ff_hevc_significant_coeff_flag_decode(s, c_idx, x_c, y_c,
1093 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1094 nb_significant_coeff_flag++;
1095 implicit_non_zero_coeff = 0;
1098 int last_cg = (x_c == (x_cg << 2) && y_c == (y_cg << 2));
1099 if (last_cg && implicit_non_zero_coeff && significant_coeff_group_flag[x_cg][y_cg]) {
1100 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1101 nb_significant_coeff_flag++;
1106 n_end = nb_significant_coeff_flag;
1109 int first_nz_pos_in_cg = 16;
1110 int last_nz_pos_in_cg = -1;
1111 int c_rice_param = 0;
1112 int first_greater1_coeff_idx = -1;
1113 uint8_t coeff_abs_level_greater1_flag[16] = { 0 };
1114 uint16_t coeff_sign_flag;
1116 int sign_hidden = 0;
1118 // initialize first elem of coeff_bas_level_greater1_flag
1119 int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1121 if (!(i == num_last_subset) && greater1_ctx == 0)
1124 last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1126 for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1127 int n_idx = significant_coeff_flag_idx[m];
1128 int inc = (ctx_set << 2) + greater1_ctx;
1129 coeff_abs_level_greater1_flag[n_idx] =
1130 ff_hevc_coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
1131 if (coeff_abs_level_greater1_flag[n_idx]) {
1133 } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1137 if (coeff_abs_level_greater1_flag[n_idx] &&
1138 first_greater1_coeff_idx == -1)
1139 first_greater1_coeff_idx = n_idx;
1141 first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1142 sign_hidden = last_nz_pos_in_cg - first_nz_pos_in_cg >= 4 &&
1143 !lc->cu.cu_transquant_bypass_flag;
1145 if (first_greater1_coeff_idx != -1) {
1146 coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += ff_hevc_coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1148 if (!s->pps->sign_data_hiding_flag || !sign_hidden) {
1149 coeff_sign_flag = ff_hevc_coeff_sign_flag(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1151 coeff_sign_flag = ff_hevc_coeff_sign_flag(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1154 for (m = 0; m < n_end; m++) {
1155 n = significant_coeff_flag_idx[m];
1156 GET_COORD(offset, n);
1157 trans_coeff_level = 1 + coeff_abs_level_greater1_flag[n];
1158 if (trans_coeff_level == ((m < 8) ?
1159 ((n == first_greater1_coeff_idx) ? 3 : 2) : 1)) {
1160 int last_coeff_abs_level_remaining = ff_hevc_coeff_abs_level_remaining(s, trans_coeff_level, c_rice_param);
1162 trans_coeff_level += last_coeff_abs_level_remaining;
1163 if ((trans_coeff_level) > (3 * (1 << c_rice_param)))
1164 c_rice_param = FFMIN(c_rice_param + 1, 4);
1166 if (s->pps->sign_data_hiding_flag && sign_hidden) {
1167 sum_abs += trans_coeff_level;
1168 if (n == first_nz_pos_in_cg && ((sum_abs & 1) == 1))
1169 trans_coeff_level = -trans_coeff_level;
1171 if (coeff_sign_flag >> 15)
1172 trans_coeff_level = -trans_coeff_level;
1173 coeff_sign_flag <<= 1;
1174 if (!lc->cu.cu_transquant_bypass_flag) {
1175 if (s->sps->scaling_list_enable_flag) {
1176 if (y_c || x_c || log2_trafo_size < 4) {
1178 switch (log2_trafo_size) {
1179 case 3: pos = (y_c << 3) + x_c; break;
1180 case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1181 case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1182 default: pos = (y_c << 2) + x_c;
1184 scale_m = scale_matrix[pos];
1189 trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1190 if(trans_coeff_level < 0) {
1191 if((~trans_coeff_level) & 0xFffffffffff8000)
1192 trans_coeff_level = -32768;
1194 if (trans_coeff_level & 0xffffffffffff8000)
1195 trans_coeff_level = 32767;
1198 coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1203 if (lc->cu.cu_transquant_bypass_flag) {
1204 s->hevcdsp.transquant_bypass[log2_trafo_size - 2](dst, coeffs, stride);
1206 if (transform_skip_flag)
1207 s->hevcdsp.transform_skip(dst, coeffs, stride);
1208 else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 &&
1209 log2_trafo_size == 2)
1210 s->hevcdsp.transform_4x4_luma_add(dst, coeffs, stride);
1212 s->hevcdsp.transform_add[log2_trafo_size - 2](dst, coeffs, stride);
1216 static void hls_transform_unit(HEVCContext *s, int x0, int y0,
1217 int xBase, int yBase, int cb_xBase, int cb_yBase,
1218 int log2_cb_size, int log2_trafo_size,
1219 int trafo_depth, int blk_idx)
1221 HEVCLocalContext *lc = &s->HEVClc;
1223 if (lc->cu.pred_mode == MODE_INTRA) {
1224 int trafo_size = 1 << log2_trafo_size;
1225 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1227 s->hpc.intra_pred(s, x0, y0, log2_trafo_size, 0);
1228 if (log2_trafo_size > 2) {
1229 trafo_size = trafo_size << (s->sps->hshift[1] - 1);
1230 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1231 s->hpc.intra_pred(s, x0, y0, log2_trafo_size - 1, 1);
1232 s->hpc.intra_pred(s, x0, y0, log2_trafo_size - 1, 2);
1233 } else if (blk_idx == 3) {
1234 trafo_size = trafo_size << s->sps->hshift[1];
1235 ff_hevc_set_neighbour_available(s, xBase, yBase,
1236 trafo_size, trafo_size);
1237 s->hpc.intra_pred(s, xBase, yBase, log2_trafo_size, 1);
1238 s->hpc.intra_pred(s, xBase, yBase, log2_trafo_size, 2);
1242 if (lc->tt.cbf_luma ||
1243 SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], x0, y0) ||
1244 SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], x0, y0)) {
1245 int scan_idx = SCAN_DIAG;
1246 int scan_idx_c = SCAN_DIAG;
1248 if (s->pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
1249 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
1250 if (lc->tu.cu_qp_delta != 0)
1251 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
1252 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
1253 lc->tu.is_cu_qp_delta_coded = 1;
1254 ff_hevc_set_qPy(s, x0, y0, cb_xBase, cb_yBase, log2_cb_size);
1257 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
1258 if (lc->tu.cur_intra_pred_mode >= 6 &&
1259 lc->tu.cur_intra_pred_mode <= 14) {
1260 scan_idx = SCAN_VERT;
1261 } else if (lc->tu.cur_intra_pred_mode >= 22 &&
1262 lc->tu.cur_intra_pred_mode <= 30) {
1263 scan_idx = SCAN_HORIZ;
1266 if (lc->pu.intra_pred_mode_c >= 6 &&
1267 lc->pu.intra_pred_mode_c <= 14) {
1268 scan_idx_c = SCAN_VERT;
1269 } else if (lc->pu.intra_pred_mode_c >= 22 &&
1270 lc->pu.intra_pred_mode_c <= 30) {
1271 scan_idx_c = SCAN_HORIZ;
1275 if (lc->tt.cbf_luma)
1276 hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
1277 if (log2_trafo_size > 2) {
1278 if (SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], x0, y0))
1279 hls_residual_coding(s, x0, y0, log2_trafo_size - 1, scan_idx_c, 1);
1280 if (SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], x0, y0))
1281 hls_residual_coding(s, x0, y0, log2_trafo_size - 1, scan_idx_c, 2);
1282 } else if (blk_idx == 3) {
1283 if (SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], xBase, yBase))
1284 hls_residual_coding(s, xBase, yBase, log2_trafo_size, scan_idx_c, 1);
1285 if (SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], xBase, yBase))
1286 hls_residual_coding(s, xBase, yBase, log2_trafo_size, scan_idx_c, 2);
1291 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1293 int cb_size = 1 << log2_cb_size;
1294 int log2_min_pu_size = s->sps->log2_min_pu_size;
1296 int min_pu_width = s->sps->min_pu_width;
1297 int x_end = FFMIN(x0 + cb_size, s->sps->width);
1298 int y_end = FFMIN(y0 + cb_size, s->sps->height);
1301 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1302 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1303 s->is_pcm[i + j * min_pu_width] = 2;
1306 static void hls_transform_tree(HEVCContext *s, int x0, int y0,
1307 int xBase, int yBase, int cb_xBase, int cb_yBase,
1308 int log2_cb_size, int log2_trafo_size,
1309 int trafo_depth, int blk_idx)
1311 HEVCLocalContext *lc = &s->HEVClc;
1312 uint8_t split_transform_flag;
1314 if (trafo_depth > 0 && log2_trafo_size == 2) {
1315 SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], x0, y0) =
1316 SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth - 1], xBase, yBase);
1317 SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], x0, y0) =
1318 SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth - 1], xBase, yBase);
1320 SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], x0, y0) =
1321 SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], x0, y0) = 0;
1324 if (lc->cu.intra_split_flag) {
1325 if (trafo_depth == 1)
1326 lc->tu.cur_intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1328 lc->tu.cur_intra_pred_mode = lc->pu.intra_pred_mode[0];
1331 lc->tt.cbf_luma = 1;
1333 lc->tt.inter_split_flag = s->sps->max_transform_hierarchy_depth_inter == 0 &&
1334 lc->cu.pred_mode == MODE_INTER &&
1335 lc->cu.part_mode != PART_2Nx2N &&
1338 if (log2_trafo_size <= s->sps->log2_max_trafo_size &&
1339 log2_trafo_size > s->sps->log2_min_tb_size &&
1340 trafo_depth < lc->cu.max_trafo_depth &&
1341 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1342 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1344 split_transform_flag = log2_trafo_size > s->sps->log2_max_trafo_size ||
1345 (lc->cu.intra_split_flag && trafo_depth == 0) ||
1346 lc->tt.inter_split_flag;
1349 if (log2_trafo_size > 2) {
1350 if (trafo_depth == 0 ||
1351 SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth - 1], xBase, yBase)) {
1352 SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], x0, y0) =
1353 ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1356 if (trafo_depth == 0 ||
1357 SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth - 1], xBase, yBase)) {
1358 SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], x0, y0) =
1359 ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1363 if (split_transform_flag) {
1364 int x1 = x0 + ((1 << log2_trafo_size) >> 1);
1365 int y1 = y0 + ((1 << log2_trafo_size) >> 1);
1367 hls_transform_tree(s, x0, y0, x0, y0, cb_xBase, cb_yBase, log2_cb_size,
1368 log2_trafo_size - 1, trafo_depth + 1, 0);
1369 hls_transform_tree(s, x1, y0, x0, y0, cb_xBase, cb_yBase, log2_cb_size,
1370 log2_trafo_size - 1, trafo_depth + 1, 1);
1371 hls_transform_tree(s, x0, y1, x0, y0, cb_xBase, cb_yBase, log2_cb_size,
1372 log2_trafo_size - 1, trafo_depth + 1, 2);
1373 hls_transform_tree(s, x1, y1, x0, y0, cb_xBase, cb_yBase, log2_cb_size,
1374 log2_trafo_size - 1, trafo_depth + 1, 3);
1376 int min_tu_size = 1 << s->sps->log2_min_tb_size;
1377 int log2_min_tu_size = s->sps->log2_min_tb_size;
1378 int min_tu_width = s->sps->min_tb_width;
1380 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1381 SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], x0, y0) ||
1382 SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], x0, y0)) {
1383 lc->tt.cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1386 hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1387 log2_cb_size, log2_trafo_size, trafo_depth, blk_idx);
1389 // TODO: store cbf_luma somewhere else
1390 if (lc->tt.cbf_luma) {
1392 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1393 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1394 int x_tu = (x0 + j) >> log2_min_tu_size;
1395 int y_tu = (y0 + i) >> log2_min_tu_size;
1396 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1399 if (!s->sh.disable_deblocking_filter_flag) {
1400 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size,
1401 lc->slice_or_tiles_up_boundary,
1402 lc->slice_or_tiles_left_boundary);
1403 if (s->pps->transquant_bypass_enable_flag &&
1404 lc->cu.cu_transquant_bypass_flag)
1405 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1410 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1412 //TODO: non-4:2:0 support
1413 HEVCLocalContext *lc = &s->HEVClc;
1415 int cb_size = 1 << log2_cb_size;
1416 int stride0 = s->frame->linesize[0];
1417 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->sps->pixel_shift)];
1418 int stride1 = s->frame->linesize[1];
1419 uint8_t *dst1 = &s->frame->data[1][(y0 >> s->sps->vshift[1]) * stride1 + ((x0 >> s->sps->hshift[1]) << s->sps->pixel_shift)];
1420 int stride2 = s->frame->linesize[2];
1421 uint8_t *dst2 = &s->frame->data[2][(y0 >> s->sps->vshift[2]) * stride2 + ((x0 >> s->sps->hshift[2]) << s->sps->pixel_shift)];
1423 int length = cb_size * cb_size * s->sps->pcm.bit_depth + ((cb_size * cb_size) >> 1) * s->sps->pcm.bit_depth_chroma;
1424 const uint8_t *pcm = skip_bytes(&s->HEVClc.cc, (length + 7) >> 3);
1427 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size,
1428 lc->slice_or_tiles_up_boundary,
1429 lc->slice_or_tiles_left_boundary);
1431 ret = init_get_bits(&gb, pcm, length);
1435 s->hevcdsp.put_pcm(dst0, stride0, cb_size, &gb, s->sps->pcm.bit_depth);
1436 s->hevcdsp.put_pcm(dst1, stride1, cb_size / 2, &gb, s->sps->pcm.bit_depth_chroma);
1437 s->hevcdsp.put_pcm(dst2, stride2, cb_size / 2, &gb, s->sps->pcm.bit_depth_chroma);
1441 static void hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1443 HEVCLocalContext *lc = &s->HEVClc;
1444 int x = ff_hevc_abs_mvd_greater0_flag_decode(s);
1445 int y = ff_hevc_abs_mvd_greater0_flag_decode(s);
1448 x += ff_hevc_abs_mvd_greater1_flag_decode(s);
1450 y += ff_hevc_abs_mvd_greater1_flag_decode(s);
1453 case 2: lc->pu.mvd.x = ff_hevc_mvd_decode(s); break;
1454 case 1: lc->pu.mvd.x = ff_hevc_mvd_sign_flag_decode(s); break;
1455 case 0: lc->pu.mvd.x = 0; break;
1459 case 2: lc->pu.mvd.y = ff_hevc_mvd_decode(s); break;
1460 case 1: lc->pu.mvd.y = ff_hevc_mvd_sign_flag_decode(s); break;
1461 case 0: lc->pu.mvd.y = 0; break;
1466 * 8.5.3.2.2.1 Luma sample interpolation process
1468 * @param s HEVC decoding context
1469 * @param dst target buffer for block data at block position
1470 * @param dststride stride of the dst buffer
1471 * @param ref reference picture buffer at origin (0, 0)
1472 * @param mv motion vector (relative to block position) to get pixel data from
1473 * @param x_off horizontal position of block from origin (0, 0)
1474 * @param y_off vertical position of block from origin (0, 0)
1475 * @param block_w width of block
1476 * @param block_h height of block
1478 static void luma_mc(HEVCContext *s, int16_t *dst, ptrdiff_t dststride,
1479 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1480 int block_w, int block_h)
1482 HEVCLocalContext *lc = &s->HEVClc;
1483 uint8_t *src = ref->data[0];
1484 ptrdiff_t srcstride = ref->linesize[0];
1485 int pic_width = s->sps->width;
1486 int pic_height = s->sps->height;
1490 int extra_left = ff_hevc_qpel_extra_before[mx];
1491 int extra_top = ff_hevc_qpel_extra_before[my];
1493 x_off += mv->x >> 2;
1494 y_off += mv->y >> 2;
1495 src += y_off * srcstride + (x_off << s->sps->pixel_shift);
1497 if (x_off < extra_left || y_off < extra_top ||
1498 x_off >= pic_width - block_w - ff_hevc_qpel_extra_after[mx] ||
1499 y_off >= pic_height - block_h - ff_hevc_qpel_extra_after[my]) {
1500 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1501 int offset = extra_top * srcstride + (extra_left << s->sps->pixel_shift);
1502 int buf_offset = extra_top *
1503 edge_emu_stride + (extra_left << s->sps->pixel_shift);
1505 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1506 edge_emu_stride, srcstride,
1507 block_w + ff_hevc_qpel_extra[mx],
1508 block_h + ff_hevc_qpel_extra[my],
1509 x_off - extra_left, y_off - extra_top,
1510 pic_width, pic_height);
1511 src = lc->edge_emu_buffer + buf_offset;
1512 srcstride = edge_emu_stride;
1514 s->hevcdsp.put_hevc_qpel[my][mx](dst, dststride, src, srcstride, block_w,
1515 block_h, lc->mc_buffer);
1519 * 8.5.3.2.2.2 Chroma sample interpolation process
1521 * @param s HEVC decoding context
1522 * @param dst1 target buffer for block data at block position (U plane)
1523 * @param dst2 target buffer for block data at block position (V plane)
1524 * @param dststride stride of the dst1 and dst2 buffers
1525 * @param ref reference picture buffer at origin (0, 0)
1526 * @param mv motion vector (relative to block position) to get pixel data from
1527 * @param x_off horizontal position of block from origin (0, 0)
1528 * @param y_off vertical position of block from origin (0, 0)
1529 * @param block_w width of block
1530 * @param block_h height of block
1532 static void chroma_mc(HEVCContext *s, int16_t *dst1, int16_t *dst2,
1533 ptrdiff_t dststride, AVFrame *ref, const Mv *mv,
1534 int x_off, int y_off, int block_w, int block_h)
1536 HEVCLocalContext *lc = &s->HEVClc;
1537 uint8_t *src1 = ref->data[1];
1538 uint8_t *src2 = ref->data[2];
1539 ptrdiff_t src1stride = ref->linesize[1];
1540 ptrdiff_t src2stride = ref->linesize[2];
1541 int pic_width = s->sps->width >> 1;
1542 int pic_height = s->sps->height >> 1;
1547 x_off += mv->x >> 3;
1548 y_off += mv->y >> 3;
1549 src1 += y_off * src1stride + (x_off << s->sps->pixel_shift);
1550 src2 += y_off * src2stride + (x_off << s->sps->pixel_shift);
1552 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1553 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1554 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1555 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1556 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->sps->pixel_shift));
1557 int buf_offset1 = EPEL_EXTRA_BEFORE *
1558 (edge_emu_stride + (1 << s->sps->pixel_shift));
1559 int offset2 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->sps->pixel_shift));
1560 int buf_offset2 = EPEL_EXTRA_BEFORE *
1561 (edge_emu_stride + (1 << s->sps->pixel_shift));
1563 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1564 edge_emu_stride, src1stride,
1565 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1566 x_off - EPEL_EXTRA_BEFORE,
1567 y_off - EPEL_EXTRA_BEFORE,
1568 pic_width, pic_height);
1570 src1 = lc->edge_emu_buffer + buf_offset1;
1571 src1stride = edge_emu_stride;
1572 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst1, dststride, src1, src1stride,
1573 block_w, block_h, mx, my, lc->mc_buffer);
1575 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src2 - offset2,
1576 edge_emu_stride, src2stride,
1577 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1578 x_off - EPEL_EXTRA_BEFORE,
1579 y_off - EPEL_EXTRA_BEFORE,
1580 pic_width, pic_height);
1581 src2 = lc->edge_emu_buffer + buf_offset2;
1582 src2stride = edge_emu_stride;
1584 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst2, dststride, src2, src2stride,
1585 block_w, block_h, mx, my,
1588 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst1, dststride, src1, src1stride,
1589 block_w, block_h, mx, my,
1591 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst2, dststride, src2, src2stride,
1592 block_w, block_h, mx, my,
1597 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1598 const Mv *mv, int y0, int height)
1600 int y = (mv->y >> 2) + y0 + height + 9;
1601 ff_thread_await_progress(&ref->tf, y, 0);
1604 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1606 int log2_cb_size, int partIdx)
1608 #define POS(c_idx, x, y) \
1609 &s->frame->data[c_idx][((y) >> s->sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1610 (((x) >> s->sps->hshift[c_idx]) << s->sps->pixel_shift)]
1611 HEVCLocalContext *lc = &s->HEVClc;
1613 struct MvField current_mv = {{{ 0 }}};
1615 int min_pu_width = s->sps->min_pu_width;
1617 MvField *tab_mvf = s->ref->tab_mvf;
1618 RefPicList *refPicList = s->ref->refPicList;
1619 HEVCFrame *ref0, *ref1;
1621 int tmpstride = MAX_PB_SIZE;
1623 uint8_t *dst0 = POS(0, x0, y0);
1624 uint8_t *dst1 = POS(1, x0, y0);
1625 uint8_t *dst2 = POS(2, x0, y0);
1626 int log2_min_cb_size = s->sps->log2_min_cb_size;
1627 int min_cb_width = s->sps->min_cb_width;
1628 int x_cb = x0 >> log2_min_cb_size;
1629 int y_cb = y0 >> log2_min_cb_size;
1635 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
1636 if (s->sh.max_num_merge_cand > 1)
1637 merge_idx = ff_hevc_merge_idx_decode(s);
1641 ff_hevc_luma_mv_merge_mode(s, x0, y0,
1644 log2_cb_size, partIdx,
1645 merge_idx, ¤t_mv);
1646 x_pu = x0 >> s->sps->log2_min_pu_size;
1647 y_pu = y0 >> s->sps->log2_min_pu_size;
1649 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1650 for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1651 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1652 } else { /* MODE_INTER */
1653 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1654 if (lc->pu.merge_flag) {
1655 if (s->sh.max_num_merge_cand > 1)
1656 merge_idx = ff_hevc_merge_idx_decode(s);
1660 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1661 partIdx, merge_idx, ¤t_mv);
1662 x_pu = x0 >> s->sps->log2_min_pu_size;
1663 y_pu = y0 >> s->sps->log2_min_pu_size;
1665 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1666 for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1667 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1669 enum InterPredIdc inter_pred_idc = PRED_L0;
1670 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1671 if (s->sh.slice_type == B_SLICE)
1672 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1674 if (inter_pred_idc != PRED_L1) {
1675 if (s->sh.nb_refs[L0]) {
1676 ref_idx[0] = ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1677 current_mv.ref_idx[0] = ref_idx[0];
1679 current_mv.pred_flag[0] = 1;
1680 hls_mvd_coding(s, x0, y0, 0);
1681 mvp_flag[0] = ff_hevc_mvp_lx_flag_decode(s);
1682 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1683 partIdx, merge_idx, ¤t_mv,
1685 current_mv.mv[0].x += lc->pu.mvd.x;
1686 current_mv.mv[0].y += lc->pu.mvd.y;
1689 if (inter_pred_idc != PRED_L0) {
1690 if (s->sh.nb_refs[L1]) {
1691 ref_idx[1] = ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1692 current_mv.ref_idx[1] = ref_idx[1];
1695 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1699 hls_mvd_coding(s, x0, y0, 1);
1702 current_mv.pred_flag[1] = 1;
1703 mvp_flag[1] = ff_hevc_mvp_lx_flag_decode(s);
1704 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1705 partIdx, merge_idx, ¤t_mv,
1707 current_mv.mv[1].x += lc->pu.mvd.x;
1708 current_mv.mv[1].y += lc->pu.mvd.y;
1711 x_pu = x0 >> s->sps->log2_min_pu_size;
1712 y_pu = y0 >> s->sps->log2_min_pu_size;
1714 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1715 for(j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1716 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1720 if (current_mv.pred_flag[0]) {
1721 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1724 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1726 if (current_mv.pred_flag[1]) {
1727 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1730 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1733 if (current_mv.pred_flag[0] && !current_mv.pred_flag[1]) {
1734 DECLARE_ALIGNED(16, int16_t, tmp[MAX_PB_SIZE * MAX_PB_SIZE]);
1735 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1737 luma_mc(s, tmp, tmpstride, ref0->frame,
1738 ¤t_mv.mv[0], x0, y0, nPbW, nPbH);
1740 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1741 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1742 s->hevcdsp.weighted_pred(s->sh.luma_log2_weight_denom,
1743 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1744 s->sh.luma_offset_l0[current_mv.ref_idx[0]],
1745 dst0, s->frame->linesize[0], tmp,
1746 tmpstride, nPbW, nPbH);
1748 s->hevcdsp.put_unweighted_pred(dst0, s->frame->linesize[0], tmp, tmpstride, nPbW, nPbH);
1750 chroma_mc(s, tmp, tmp2, tmpstride, ref0->frame,
1751 ¤t_mv.mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1753 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1754 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1755 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1756 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0],
1757 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0],
1758 dst1, s->frame->linesize[1], tmp, tmpstride,
1759 nPbW / 2, nPbH / 2);
1760 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1761 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1],
1762 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1],
1763 dst2, s->frame->linesize[2], tmp2, tmpstride,
1764 nPbW / 2, nPbH / 2);
1766 s->hevcdsp.put_unweighted_pred(dst1, s->frame->linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1767 s->hevcdsp.put_unweighted_pred(dst2, s->frame->linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1769 } else if (!current_mv.pred_flag[0] && current_mv.pred_flag[1]) {
1770 DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1771 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1776 luma_mc(s, tmp, tmpstride, ref1->frame,
1777 ¤t_mv.mv[1], x0, y0, nPbW, nPbH);
1779 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1780 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1781 s->hevcdsp.weighted_pred(s->sh.luma_log2_weight_denom,
1782 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1783 s->sh.luma_offset_l1[current_mv.ref_idx[1]],
1784 dst0, s->frame->linesize[0], tmp, tmpstride,
1787 s->hevcdsp.put_unweighted_pred(dst0, s->frame->linesize[0], tmp, tmpstride, nPbW, nPbH);
1790 chroma_mc(s, tmp, tmp2, tmpstride, ref1->frame,
1791 ¤t_mv.mv[1], x0/2, y0/2, nPbW/2, nPbH/2);
1793 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1794 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1795 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1796 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0],
1797 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0],
1798 dst1, s->frame->linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1799 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1800 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1],
1801 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1],
1802 dst2, s->frame->linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1804 s->hevcdsp.put_unweighted_pred(dst1, s->frame->linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1805 s->hevcdsp.put_unweighted_pred(dst2, s->frame->linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1807 } else if (current_mv.pred_flag[0] && current_mv.pred_flag[1]) {
1808 DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1809 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1810 DECLARE_ALIGNED(16, int16_t, tmp3[MAX_PB_SIZE * MAX_PB_SIZE]);
1811 DECLARE_ALIGNED(16, int16_t, tmp4[MAX_PB_SIZE * MAX_PB_SIZE]);
1812 HEVCFrame *ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1813 HEVCFrame *ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1818 luma_mc(s, tmp, tmpstride, ref0->frame,
1819 ¤t_mv.mv[0], x0, y0, nPbW, nPbH);
1820 luma_mc(s, tmp2, tmpstride, ref1->frame,
1821 ¤t_mv.mv[1], x0, y0, nPbW, nPbH);
1823 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1824 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1825 s->hevcdsp.weighted_pred_avg(s->sh.luma_log2_weight_denom,
1826 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1827 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1828 s->sh.luma_offset_l0[current_mv.ref_idx[0]],
1829 s->sh.luma_offset_l1[current_mv.ref_idx[1]],
1830 dst0, s->frame->linesize[0],
1831 tmp, tmp2, tmpstride, nPbW, nPbH);
1833 s->hevcdsp.put_weighted_pred_avg(dst0, s->frame->linesize[0],
1834 tmp, tmp2, tmpstride, nPbW, nPbH);
1837 chroma_mc(s, tmp, tmp2, tmpstride, ref0->frame,
1838 ¤t_mv.mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1839 chroma_mc(s, tmp3, tmp4, tmpstride, ref1->frame,
1840 ¤t_mv.mv[1], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1842 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1843 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1844 s->hevcdsp.weighted_pred_avg(s->sh.chroma_log2_weight_denom,
1845 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0],
1846 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0],
1847 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0],
1848 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0],
1849 dst1, s->frame->linesize[1], tmp, tmp3,
1850 tmpstride, nPbW / 2, nPbH / 2);
1851 s->hevcdsp.weighted_pred_avg(s->sh.chroma_log2_weight_denom,
1852 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1],
1853 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1],
1854 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1],
1855 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1],
1856 dst2, s->frame->linesize[2], tmp2, tmp4,
1857 tmpstride, nPbW / 2, nPbH / 2);
1859 s->hevcdsp.put_weighted_pred_avg(dst1, s->frame->linesize[1], tmp, tmp3, tmpstride, nPbW/2, nPbH/2);
1860 s->hevcdsp.put_weighted_pred_avg(dst2, s->frame->linesize[2], tmp2, tmp4, tmpstride, nPbW/2, nPbH/2);
1868 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1869 int prev_intra_luma_pred_flag)
1871 HEVCLocalContext *lc = &s->HEVClc;
1872 int x_pu = x0 >> s->sps->log2_min_pu_size;
1873 int y_pu = y0 >> s->sps->log2_min_pu_size;
1874 int min_pu_width = s->sps->min_pu_width;
1875 int size_in_pus = pu_size >> s->sps->log2_min_pu_size;
1876 int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1);
1877 int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1);
1879 int cand_up = (lc->ctb_up_flag || y0b) ?
1880 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1881 int cand_left = (lc->ctb_left_flag || x0b) ?
1882 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1884 int y_ctb = (y0 >> (s->sps->log2_ctb_size)) << (s->sps->log2_ctb_size);
1886 MvField *tab_mvf = s->ref->tab_mvf;
1887 int intra_pred_mode;
1891 // intra_pred_mode prediction does not cross vertical CTB boundaries
1892 if ((y0 - 1) < y_ctb)
1895 if (cand_left == cand_up) {
1896 if (cand_left < 2) {
1897 candidate[0] = INTRA_PLANAR;
1898 candidate[1] = INTRA_DC;
1899 candidate[2] = INTRA_ANGULAR_26;
1901 candidate[0] = cand_left;
1902 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1903 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1906 candidate[0] = cand_left;
1907 candidate[1] = cand_up;
1908 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1909 candidate[2] = INTRA_PLANAR;
1910 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1911 candidate[2] = INTRA_DC;
1913 candidate[2] = INTRA_ANGULAR_26;
1917 if (prev_intra_luma_pred_flag) {
1918 intra_pred_mode = candidate[lc->pu.mpm_idx];
1920 if (candidate[0] > candidate[1])
1921 FFSWAP(uint8_t, candidate[0], candidate[1]);
1922 if (candidate[0] > candidate[2])
1923 FFSWAP(uint8_t, candidate[0], candidate[2]);
1924 if (candidate[1] > candidate[2])
1925 FFSWAP(uint8_t, candidate[1], candidate[2]);
1927 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1928 for (i = 0; i < 3; i++)
1929 if (intra_pred_mode >= candidate[i])
1933 /* write the intra prediction units into the mv array */
1936 for (i = 0; i < size_in_pus; i++) {
1937 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1938 intra_pred_mode, size_in_pus);
1940 for (j = 0; j < size_in_pus; j++) {
1941 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].is_intra = 1;
1942 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[0] = 0;
1943 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[1] = 0;
1944 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[0] = 0;
1945 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[1] = 0;
1946 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].x = 0;
1947 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].y = 0;
1948 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].x = 0;
1949 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].y = 0;
1953 return intra_pred_mode;
1956 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1957 int log2_cb_size, int ct_depth)
1959 int length = (1 << log2_cb_size) >> s->sps->log2_min_cb_size;
1960 int x_cb = x0 >> s->sps->log2_min_cb_size;
1961 int y_cb = y0 >> s->sps->log2_min_cb_size;
1964 for (y = 0; y < length; y++)
1965 memset(&s->tab_ct_depth[(y_cb + y) * s->sps->min_cb_width + x_cb],
1969 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1972 HEVCLocalContext *lc = &s->HEVClc;
1973 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1974 uint8_t prev_intra_luma_pred_flag[4];
1975 int split = lc->cu.part_mode == PART_NxN;
1976 int pb_size = (1 << log2_cb_size) >> split;
1977 int side = split + 1;
1981 for (i = 0; i < side; i++)
1982 for (j = 0; j < side; j++)
1983 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1985 for (i = 0; i < side; i++) {
1986 for (j = 0; j < side; j++) {
1987 if (prev_intra_luma_pred_flag[2 * i + j])
1988 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
1990 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
1992 lc->pu.intra_pred_mode[2 * i + j] =
1993 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1994 prev_intra_luma_pred_flag[2 * i + j]);
1998 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1999 if (chroma_mode != 4) {
2000 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
2001 lc->pu.intra_pred_mode_c = 34;
2003 lc->pu.intra_pred_mode_c = intra_chroma_table[chroma_mode];
2005 lc->pu.intra_pred_mode_c = lc->pu.intra_pred_mode[0];
2009 static void intra_prediction_unit_default_value(HEVCContext *s,
2013 HEVCLocalContext *lc = &s->HEVClc;
2014 int pb_size = 1 << log2_cb_size;
2015 int size_in_pus = pb_size >> s->sps->log2_min_pu_size;
2016 int min_pu_width = s->sps->min_pu_width;
2017 MvField *tab_mvf = s->ref->tab_mvf;
2018 int x_pu = x0 >> s->sps->log2_min_pu_size;
2019 int y_pu = y0 >> s->sps->log2_min_pu_size;
2022 if (size_in_pus == 0)
2024 for (j = 0; j < size_in_pus; j++) {
2025 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
2026 for (k = 0; k < size_in_pus; k++)
2027 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].is_intra = lc->cu.pred_mode == MODE_INTRA;
2031 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
2033 int cb_size = 1 << log2_cb_size;
2034 HEVCLocalContext *lc = &s->HEVClc;
2035 int log2_min_cb_size = s->sps->log2_min_cb_size;
2036 int length = cb_size >> log2_min_cb_size;
2037 int min_cb_width = s->sps->min_cb_width;
2038 int x_cb = x0 >> log2_min_cb_size;
2039 int y_cb = y0 >> log2_min_cb_size;
2044 lc->cu.rqt_root_cbf = 1;
2045 lc->cu.pred_mode = MODE_INTRA;
2046 lc->cu.part_mode = PART_2Nx2N;
2047 lc->cu.intra_split_flag = 0;
2048 lc->cu.pcm_flag = 0;
2050 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
2051 for (x = 0; x < 4; x++)
2052 lc->pu.intra_pred_mode[x] = 1;
2053 if (s->pps->transquant_bypass_enable_flag) {
2054 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
2055 if (lc->cu.cu_transquant_bypass_flag)
2056 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2058 lc->cu.cu_transquant_bypass_flag = 0;
2060 if (s->sh.slice_type != I_SLICE) {
2061 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
2063 lc->cu.pred_mode = MODE_SKIP;
2064 x = y_cb * min_cb_width + x_cb;
2065 for (y = 0; y < length; y++) {
2066 memset(&s->skip_flag[x], skip_flag, length);
2069 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2072 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2073 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0);
2074 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2076 if (!s->sh.disable_deblocking_filter_flag)
2077 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size,
2078 lc->slice_or_tiles_up_boundary,
2079 lc->slice_or_tiles_left_boundary);
2081 if (s->sh.slice_type != I_SLICE)
2082 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2083 if (lc->cu.pred_mode != MODE_INTRA ||
2084 log2_cb_size == s->sps->log2_min_cb_size) {
2085 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2086 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2087 lc->cu.pred_mode == MODE_INTRA;
2090 if (lc->cu.pred_mode == MODE_INTRA) {
2091 if (lc->cu.part_mode == PART_2Nx2N && s->sps->pcm_enabled_flag &&
2092 log2_cb_size >= s->sps->pcm.log2_min_pcm_cb_size &&
2093 log2_cb_size <= s->sps->pcm.log2_max_pcm_cb_size) {
2094 lc->cu.pcm_flag = ff_hevc_pcm_flag_decode(s);
2096 if (lc->cu.pcm_flag) {
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);
2147 if (!lc->cu.pcm_flag) {
2148 if (lc->cu.pred_mode != MODE_INTRA &&
2149 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2150 lc->cu.rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2152 if (lc->cu.rqt_root_cbf) {
2153 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2154 s->sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2155 s->sps->max_transform_hierarchy_depth_inter;
2156 hls_transform_tree(s, x0, y0, x0, y0, x0, y0, log2_cb_size,
2157 log2_cb_size, 0, 0);
2159 if (!s->sh.disable_deblocking_filter_flag)
2160 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size,
2161 lc->slice_or_tiles_up_boundary,
2162 lc->slice_or_tiles_left_boundary);
2167 if (s->pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2168 ff_hevc_set_qPy(s, x0, y0, x0, y0, log2_cb_size);
2170 x = y_cb * min_cb_width + x_cb;
2171 for (y = 0; y < length; y++) {
2172 memset(&s->qp_y_tab[x], lc->qp_y, length);
2176 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct.depth);
2181 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2182 int log2_cb_size, int cb_depth)
2184 HEVCLocalContext *lc = &s->HEVClc;
2185 const int cb_size = 1 << log2_cb_size;
2187 lc->ct.depth = cb_depth;
2188 if (x0 + cb_size <= s->sps->width &&
2189 y0 + cb_size <= s->sps->height &&
2190 log2_cb_size > s->sps->log2_min_cb_size) {
2191 SAMPLE(s->split_cu_flag, x0, y0) =
2192 ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2194 SAMPLE(s->split_cu_flag, x0, y0) =
2195 (log2_cb_size > s->sps->log2_min_cb_size);
2197 if (s->pps->cu_qp_delta_enabled_flag &&
2198 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth) {
2199 lc->tu.is_cu_qp_delta_coded = 0;
2200 lc->tu.cu_qp_delta = 0;
2203 if (SAMPLE(s->split_cu_flag, x0, y0)) {
2204 const int cb_size_split = cb_size >> 1;
2205 const int x1 = x0 + cb_size_split;
2206 const int y1 = y0 + cb_size_split;
2211 #define SUBDIVIDE(x, y) \
2213 if (x < s->sps->width && y < s->sps->height) { \
2214 int ret = hls_coding_quadtree(s, x, y, log2_cb_size, cb_depth);\
2225 int ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2233 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2236 HEVCLocalContext *lc = &s->HEVClc;
2237 int ctb_size = 1 << s->sps->log2_ctb_size;
2238 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2239 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2241 int tile_left_boundary, tile_up_boundary;
2242 int slice_left_boundary, slice_up_boundary;
2244 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2246 if (s->pps->entropy_coding_sync_enabled_flag) {
2247 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2248 lc->first_qp_group = 1;
2249 lc->end_of_tiles_x = s->sps->width;
2250 } else if (s->pps->tiles_enabled_flag) {
2251 if (ctb_addr_ts && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1]) {
2252 int idxX = s->pps->col_idxX[x_ctb >> s->sps->log2_ctb_size];
2253 lc->start_of_tiles_x = x_ctb;
2254 lc->end_of_tiles_x = x_ctb + (s->pps->column_width[idxX] << s->sps->log2_ctb_size);
2255 lc->first_qp_group = 1;
2258 lc->end_of_tiles_x = s->sps->width;
2261 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->sps->height);
2263 if (s->pps->tiles_enabled_flag) {
2264 tile_left_boundary = x_ctb > 0 &&
2265 s->pps->tile_id[ctb_addr_ts] == s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs - 1]];
2266 slice_left_boundary = x_ctb > 0 &&
2267 s->tab_slice_address[ctb_addr_rs] == s->tab_slice_address[ctb_addr_rs - 1];
2268 tile_up_boundary = y_ctb > 0 &&
2269 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]];
2270 slice_up_boundary = y_ctb > 0 &&
2271 s->tab_slice_address[ctb_addr_rs] == s->tab_slice_address[ctb_addr_rs - s->sps->ctb_width];
2273 tile_left_boundary =
2274 tile_up_boundary = 1;
2275 slice_left_boundary = ctb_addr_in_slice > 0;
2276 slice_up_boundary = ctb_addr_in_slice >= s->sps->ctb_width;
2278 lc->slice_or_tiles_left_boundary = (!slice_left_boundary) + (!tile_left_boundary << 1);
2279 lc->slice_or_tiles_up_boundary = (!slice_up_boundary + (!tile_up_boundary << 1));
2280 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && tile_left_boundary);
2281 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->sps->ctb_width) && tile_up_boundary);
2282 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]]));
2283 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]]));
2286 static int hls_slice_data(HEVCContext *s)
2288 int ctb_size = 1 << s->sps->log2_ctb_size;
2292 int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2295 while (more_data && ctb_addr_ts < s->sps->ctb_size) {
2296 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2298 x_ctb = (ctb_addr_rs % ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2299 y_ctb = (ctb_addr_rs / ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2300 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2302 ff_hevc_cabac_init(s, ctb_addr_ts);
2304 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2306 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2307 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2308 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2310 ret = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2313 more_data = !ff_hevc_end_of_slice_flag_decode(s);
2316 ff_hevc_save_states(s, ctb_addr_ts);
2317 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2320 if (x_ctb + ctb_size >= s->sps->width &&
2321 y_ctb + ctb_size >= s->sps->height)
2322 ff_hevc_hls_filter(s, x_ctb, y_ctb);
2328 * @return AVERROR_INVALIDDATA if the packet is not a valid NAL unit,
2329 * 0 if the unit should be skipped, 1 otherwise
2331 static int hls_nal_unit(HEVCContext *s)
2333 GetBitContext *gb = &s->HEVClc.gb;
2336 if (get_bits1(gb) != 0)
2337 return AVERROR_INVALIDDATA;
2339 s->nal_unit_type = get_bits(gb, 6);
2341 nuh_layer_id = get_bits(gb, 6);
2342 s->temporal_id = get_bits(gb, 3) - 1;
2343 if (s->temporal_id < 0)
2344 return AVERROR_INVALIDDATA;
2346 av_log(s->avctx, AV_LOG_DEBUG,
2347 "nal_unit_type: %d, nuh_layer_id: %dtemporal_id: %d\n",
2348 s->nal_unit_type, nuh_layer_id, s->temporal_id);
2350 return nuh_layer_id == 0;
2353 static void restore_tqb_pixels(HEVCContext *s)
2355 int min_pu_size = 1 << s->sps->log2_min_pu_size;
2358 for (c_idx = 0; c_idx < 3; c_idx++) {
2359 ptrdiff_t stride = s->frame->linesize[c_idx];
2360 int hshift = s->sps->hshift[c_idx];
2361 int vshift = s->sps->vshift[c_idx];
2362 for (y = 0; y < s->sps->min_pu_height; y++) {
2363 for (x = 0; x < s->sps->min_pu_width; x++) {
2364 if (s->is_pcm[y * s->sps->min_pu_width + x]) {
2366 int len = min_pu_size >> hshift;
2367 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)];
2368 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)];
2369 for (n = 0; n < (min_pu_size >> vshift); n++) {
2370 memcpy(dst, src, len);
2380 static int set_side_data(HEVCContext *s)
2382 AVFrame *out = s->ref->frame;
2384 if (s->sei_frame_packing_present &&
2385 s->frame_packing_arrangement_type >= 3 &&
2386 s->frame_packing_arrangement_type <= 5 &&
2387 s->content_interpretation_type > 0 &&
2388 s->content_interpretation_type < 3) {
2389 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2391 return AVERROR(ENOMEM);
2393 switch (s->frame_packing_arrangement_type) {
2395 if (s->quincunx_subsampling)
2396 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2398 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2401 stereo->type = AV_STEREO3D_TOPBOTTOM;
2404 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2408 if (s->content_interpretation_type == 2)
2409 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2415 static int hevc_frame_start(HEVCContext *s)
2417 HEVCLocalContext *lc = &s->HEVClc;
2420 memset(s->horizontal_bs, 0, 2 * s->bs_width * (s->bs_height + 1));
2421 memset(s->vertical_bs, 0, 2 * s->bs_width * (s->bs_height + 1));
2422 memset(s->cbf_luma, 0, s->sps->min_tb_width * s->sps->min_tb_height);
2423 memset(s->is_pcm, 0, s->sps->min_pu_width * s->sps->min_pu_height);
2425 lc->start_of_tiles_x = 0;
2428 if (s->pps->tiles_enabled_flag)
2429 lc->end_of_tiles_x = s->pps->column_width[0] << s->sps->log2_ctb_size;
2431 ret = ff_hevc_set_new_ref(s, s->sps->sao_enabled ? &s->sao_frame : &s->frame,
2436 ret = ff_hevc_frame_rps(s);
2438 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2442 ret = set_side_data(s);
2446 av_frame_unref(s->output_frame);
2447 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2451 ff_thread_finish_setup(s->avctx);
2457 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2462 static int decode_nal_unit(HEVCContext *s, const uint8_t *nal, int length)
2464 HEVCLocalContext *lc = &s->HEVClc;
2465 GetBitContext *gb = &lc->gb;
2466 int ctb_addr_ts, ret;
2468 ret = init_get_bits8(gb, nal, length);
2472 ret = hls_nal_unit(s);
2474 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit %d, skipping.\n",
2476 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2482 switch (s->nal_unit_type) {
2484 ret = ff_hevc_decode_nal_vps(s);
2489 ret = ff_hevc_decode_nal_sps(s);
2494 ret = ff_hevc_decode_nal_pps(s);
2498 case NAL_SEI_PREFIX:
2499 case NAL_SEI_SUFFIX:
2500 ret = ff_hevc_decode_nal_sei(s);
2511 case NAL_BLA_W_RADL:
2513 case NAL_IDR_W_RADL:
2520 ret = hls_slice_header(s);
2524 if (s->max_ra == INT_MAX) {
2525 if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
2529 s->max_ra = INT_MIN;
2533 if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
2534 s->poc <= s->max_ra) {
2538 if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
2539 s->max_ra = INT_MIN;
2542 if (s->sh.first_slice_in_pic_flag) {
2543 ret = hevc_frame_start(s);
2546 } else if (!s->ref) {
2547 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2548 return AVERROR_INVALIDDATA;
2551 if (!s->sh.dependent_slice_segment_flag &&
2552 s->sh.slice_type != I_SLICE) {
2553 ret = ff_hevc_slice_rpl(s);
2555 av_log(s->avctx, AV_LOG_WARNING,
2556 "Error constructing the reference lists for the current slice.\n");
2557 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2562 ctb_addr_ts = hls_slice_data(s);
2563 if (ctb_addr_ts >= (s->sps->ctb_width * s->sps->ctb_height)) {
2565 if ((s->pps->transquant_bypass_enable_flag ||
2566 (s->sps->pcm.loop_filter_disable_flag && s->sps->pcm_enabled_flag)) &&
2567 s->sps->sao_enabled)
2568 restore_tqb_pixels(s);
2571 if (ctb_addr_ts < 0)
2576 s->seq_decode = (s->seq_decode + 1) & 0xff;
2577 s->max_ra = INT_MAX;
2583 av_log(s->avctx, AV_LOG_INFO,
2584 "Skipping NAL unit %d\n", s->nal_unit_type);
2590 /* FIXME: This is adapted from ff_h264_decode_nal, avoiding duplication
2591 * between these functions would be nice. */
2592 static int extract_rbsp(const uint8_t *src, int length,
2598 #define STARTCODE_TEST \
2599 if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \
2600 if (src[i + 2] != 3) { \
2601 /* startcode, so we must be past the end */ \
2606 #if HAVE_FAST_UNALIGNED
2607 #define FIND_FIRST_ZERO \
2608 if (i > 0 && !src[i]) \
2613 for (i = 0; i + 1 < length; i += 9) {
2614 if (!((~AV_RN64A(src + i) &
2615 (AV_RN64A(src + i) - 0x0100010001000101ULL)) &
2616 0x8000800080008080ULL))
2623 for (i = 0; i + 1 < length; i += 5) {
2624 if (!((~AV_RN32A(src + i) &
2625 (AV_RN32A(src + i) - 0x01000101U)) &
2632 #endif /* HAVE_FAST_64BIT */
2634 for (i = 0; i + 1 < length; i += 2) {
2637 if (i > 0 && src[i - 1] == 0)
2641 #endif /* HAVE_FAST_UNALIGNED */
2643 if (i >= length - 1) { // no escaped 0
2649 av_fast_malloc(&nal->rbsp_buffer, &nal->rbsp_buffer_size,
2650 length + FF_INPUT_BUFFER_PADDING_SIZE);
2651 if (!nal->rbsp_buffer)
2652 return AVERROR(ENOMEM);
2654 dst = nal->rbsp_buffer;
2656 memcpy(dst, src, i);
2658 while (si + 2 < length) {
2659 // remove escapes (very rare 1:2^22)
2660 if (src[si + 2] > 3) {
2661 dst[di++] = src[si++];
2662 dst[di++] = src[si++];
2663 } else if (src[si] == 0 && src[si + 1] == 0) {
2664 if (src[si + 2] == 3) { // escape
2670 } else // next start code
2674 dst[di++] = src[si++];
2677 dst[di++] = src[si++];
2680 memset(dst + di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2687 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2689 int i, consumed, ret = 0;
2694 /* split the input packet into NAL units, so we know the upper bound on the
2695 * number of slices in the frame */
2697 while (length >= 4) {
2699 int extract_length = 0;
2703 for (i = 0; i < s->nal_length_size; i++)
2704 extract_length = (extract_length << 8) | buf[i];
2705 buf += s->nal_length_size;
2706 length -= s->nal_length_size;
2708 if (extract_length > length) {
2709 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit size.\n");
2710 ret = AVERROR_INVALIDDATA;
2719 if (buf[0] != 0 || buf[1] != 0 || buf[2] != 1) {
2720 ret = AVERROR_INVALIDDATA;
2726 extract_length = length;
2729 if (s->nals_allocated < s->nb_nals + 1) {
2730 int new_size = s->nals_allocated + 1;
2731 HEVCNAL *tmp = av_realloc_array(s->nals, new_size, sizeof(*tmp));
2733 ret = AVERROR(ENOMEM);
2737 memset(s->nals + s->nals_allocated, 0,
2738 (new_size - s->nals_allocated) * sizeof(*tmp));
2739 s->nals_allocated = new_size;
2741 nal = &s->nals[s->nb_nals++];
2743 consumed = extract_rbsp(buf, extract_length, nal);
2749 ret = init_get_bits8(&s->HEVClc.gb, nal->data, nal->size);
2754 if (s->nal_unit_type == NAL_EOB_NUT ||
2755 s->nal_unit_type == NAL_EOS_NUT)
2762 /* parse the NAL units */
2763 for (i = 0; i < s->nb_nals; i++) {
2764 int ret = decode_nal_unit(s, s->nals[i].data, s->nals[i].size);
2766 av_log(s->avctx, AV_LOG_WARNING,
2767 "Error parsing NAL unit #%d.\n", i);
2768 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2775 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2780 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2783 for (i = 0; i < 16; i++)
2784 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
2787 static int verify_md5(HEVCContext *s, AVFrame *frame)
2789 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
2794 return AVERROR(EINVAL);
2796 pixel_shift = desc->comp[0].depth_minus1 > 7;
2798 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
2801 /* the checksums are LE, so we have to byteswap for >8bpp formats
2804 if (pixel_shift && !s->checksum_buf) {
2805 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
2806 FFMAX3(frame->linesize[0], frame->linesize[1],
2807 frame->linesize[2]));
2808 if (!s->checksum_buf)
2809 return AVERROR(ENOMEM);
2813 for (i = 0; frame->data[i]; i++) {
2814 int width = s->avctx->coded_width;
2815 int height = s->avctx->coded_height;
2816 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
2817 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
2820 av_md5_init(s->md5_ctx);
2821 for (j = 0; j < h; j++) {
2822 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
2825 s->dsp.bswap16_buf((uint16_t*)s->checksum_buf,
2826 (const uint16_t*)src, w);
2827 src = s->checksum_buf;
2830 av_md5_update(s->md5_ctx, src, w << pixel_shift);
2832 av_md5_final(s->md5_ctx, md5);
2834 if (!memcmp(md5, s->md5[i], 16)) {
2835 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
2836 print_md5(s->avctx, AV_LOG_DEBUG, md5);
2837 av_log (s->avctx, AV_LOG_DEBUG, "; ");
2839 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
2840 print_md5(s->avctx, AV_LOG_ERROR, md5);
2841 av_log (s->avctx, AV_LOG_ERROR, " != ");
2842 print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
2843 av_log (s->avctx, AV_LOG_ERROR, "\n");
2844 return AVERROR_INVALIDDATA;
2848 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2853 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
2857 HEVCContext *s = avctx->priv_data;
2860 ret = ff_hevc_output_frame(s, data, 1);
2869 ret = decode_nal_units(s, avpkt->data, avpkt->size);
2873 /* verify the SEI checksum */
2874 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
2876 ret = verify_md5(s, s->ref->frame);
2877 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
2878 ff_hevc_unref_frame(s, s->ref, ~0);
2884 if (s->is_decoded) {
2885 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
2889 if (s->output_frame->buf[0]) {
2890 av_frame_move_ref(data, s->output_frame);
2897 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
2899 int ret = ff_thread_ref_frame(&dst->tf, &src->tf);
2903 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
2904 if (!dst->tab_mvf_buf)
2906 dst->tab_mvf = src->tab_mvf;
2908 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
2909 if (!dst->rpl_tab_buf)
2911 dst->rpl_tab = src->rpl_tab;
2913 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
2917 dst->poc = src->poc;
2918 dst->ctb_count = src->ctb_count;
2919 dst->window = src->window;
2920 dst->flags = src->flags;
2921 dst->sequence = src->sequence;
2925 ff_hevc_unref_frame(s, dst, ~0);
2926 return AVERROR(ENOMEM);
2929 static av_cold int hevc_decode_free(AVCodecContext *avctx)
2931 HEVCContext *s = avctx->priv_data;
2936 av_freep(&s->md5_ctx);
2938 av_frame_free(&s->tmp_frame);
2939 av_frame_free(&s->output_frame);
2941 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2942 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
2943 av_frame_free(&s->DPB[i].frame);
2946 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++)
2947 av_buffer_unref(&s->vps_list[i]);
2948 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++)
2949 av_buffer_unref(&s->sps_list[i]);
2950 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
2951 av_buffer_unref(&s->pps_list[i]);
2953 for (i = 0; i < s->nals_allocated; i++)
2954 av_freep(&s->nals[i].rbsp_buffer);
2956 s->nals_allocated = 0;
2961 static av_cold int hevc_init_context(AVCodecContext *avctx)
2963 HEVCContext *s = avctx->priv_data;
2968 s->tmp_frame = av_frame_alloc();
2972 s->output_frame = av_frame_alloc();
2973 if (!s->output_frame)
2976 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2977 s->DPB[i].frame = av_frame_alloc();
2978 if (!s->DPB[i].frame)
2980 s->DPB[i].tf.f = s->DPB[i].frame;
2983 s->max_ra = INT_MAX;
2985 s->md5_ctx = av_md5_alloc();
2989 ff_dsputil_init(&s->dsp, avctx);
2991 s->context_initialized = 1;
2996 hevc_decode_free(avctx);
2997 return AVERROR(ENOMEM);
3000 static int hevc_update_thread_context(AVCodecContext *dst,
3001 const AVCodecContext *src)
3003 HEVCContext *s = dst->priv_data;
3004 HEVCContext *s0 = src->priv_data;
3007 if (!s->context_initialized) {
3008 ret = hevc_init_context(dst);
3013 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3014 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3015 if (s0->DPB[i].frame->buf[0]) {
3016 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3022 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++) {
3023 av_buffer_unref(&s->vps_list[i]);
3024 if (s0->vps_list[i]) {
3025 s->vps_list[i] = av_buffer_ref(s0->vps_list[i]);
3026 if (!s->vps_list[i])
3027 return AVERROR(ENOMEM);
3031 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++) {
3032 av_buffer_unref(&s->sps_list[i]);
3033 if (s0->sps_list[i]) {
3034 s->sps_list[i] = av_buffer_ref(s0->sps_list[i]);
3035 if (!s->sps_list[i])
3036 return AVERROR(ENOMEM);
3040 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++) {
3041 av_buffer_unref(&s->pps_list[i]);
3042 if (s0->pps_list[i]) {
3043 s->pps_list[i] = av_buffer_ref(s0->pps_list[i]);
3044 if (!s->pps_list[i])
3045 return AVERROR(ENOMEM);
3049 if (s->sps != s0->sps)
3050 ret = set_sps(s, s0->sps);
3052 s->seq_decode = s0->seq_decode;
3053 s->seq_output = s0->seq_output;
3054 s->pocTid0 = s0->pocTid0;
3055 s->max_ra = s0->max_ra;
3057 s->is_nalff = s0->is_nalff;
3058 s->nal_length_size = s0->nal_length_size;
3061 s->seq_decode = (s->seq_decode + 1) & 0xff;
3062 s->max_ra = INT_MAX;
3068 static int hevc_decode_extradata(HEVCContext *s)
3070 AVCodecContext *avctx = s->avctx;
3074 bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
3076 if (avctx->extradata_size > 3 &&
3077 (avctx->extradata[0] || avctx->extradata[1] ||
3078 avctx->extradata[2] > 1)) {
3079 /* It seems the extradata is encoded as hvcC format.
3080 * Temporarily, we support configurationVersion==0 until 14496-15 3rd
3081 * is finalized. When finalized, configurationVersion will be 1 and we
3082 * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
3083 int i, j, num_arrays, nal_len_size;
3087 bytestream2_skip(&gb, 21);
3088 nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
3089 num_arrays = bytestream2_get_byte(&gb);
3091 /* nal units in the hvcC always have length coded with 2 bytes,
3092 * so put a fake nal_length_size = 2 while parsing them */
3093 s->nal_length_size = 2;
3095 /* Decode nal units from hvcC. */
3096 for (i = 0; i < num_arrays; i++) {
3097 int type = bytestream2_get_byte(&gb) & 0x3f;
3098 int cnt = bytestream2_get_be16(&gb);
3100 for (j = 0; j < cnt; j++) {
3101 // +2 for the nal size field
3102 int nalsize = bytestream2_peek_be16(&gb) + 2;
3103 if (bytestream2_get_bytes_left(&gb) < nalsize) {
3104 av_log(s->avctx, AV_LOG_ERROR,
3105 "Invalid NAL unit size in extradata.\n");
3106 return AVERROR_INVALIDDATA;
3109 ret = decode_nal_units(s, gb.buffer, nalsize);
3111 av_log(avctx, AV_LOG_ERROR,
3112 "Decoding nal unit %d %d from hvcC failed\n",
3116 bytestream2_skip(&gb, nalsize);
3120 /* Now store right nal length size, that will be used to parse
3122 s->nal_length_size = nal_len_size;
3125 ret = decode_nal_units(s, avctx->extradata, avctx->extradata_size);
3132 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3134 HEVCContext *s = avctx->priv_data;
3137 ff_init_cabac_states();
3139 avctx->internal->allocate_progress = 1;
3141 ret = hevc_init_context(avctx);
3145 if (avctx->extradata_size > 0 && avctx->extradata) {
3146 ret = hevc_decode_extradata(s);
3148 hevc_decode_free(avctx);
3156 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3158 HEVCContext *s = avctx->priv_data;
3161 memset(s, 0, sizeof(*s));
3163 ret = hevc_init_context(avctx);
3170 static void hevc_decode_flush(AVCodecContext *avctx)
3172 HEVCContext *s = avctx->priv_data;
3173 ff_hevc_flush_dpb(s);
3174 s->max_ra = INT_MAX;
3177 #define OFFSET(x) offsetof(HEVCContext, x)
3178 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3180 static const AVProfile profiles[] = {
3181 { FF_PROFILE_HEVC_MAIN, "Main" },
3182 { FF_PROFILE_HEVC_MAIN_10, "Main 10" },
3183 { FF_PROFILE_HEVC_MAIN_STILL_PICTURE, "Main Still Picture" },
3184 { FF_PROFILE_UNKNOWN },
3187 static const AVOption options[] = {
3188 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3189 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3193 static const AVClass hevc_decoder_class = {
3194 .class_name = "HEVC decoder",
3195 .item_name = av_default_item_name,
3197 .version = LIBAVUTIL_VERSION_INT,
3200 AVCodec ff_hevc_decoder = {
3202 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3203 .type = AVMEDIA_TYPE_VIDEO,
3204 .id = AV_CODEC_ID_HEVC,
3205 .priv_data_size = sizeof(HEVCContext),
3206 .priv_class = &hevc_decoder_class,
3207 .init = hevc_decode_init,
3208 .close = hevc_decode_free,
3209 .decode = hevc_decode_frame,
3210 .flush = hevc_decode_flush,
3211 .update_thread_context = hevc_update_thread_context,
3212 .init_thread_copy = hevc_init_thread_copy,
3213 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY |
3214 CODEC_CAP_FRAME_THREADS,
3215 .profiles = NULL_IF_CONFIG_SMALL(profiles),