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"
33 #include "bytestream.h"
34 #include "cabac_functions.h"
39 const uint8_t ff_hevc_qpel_extra_before[4] = { 0, 3, 3, 2 };
40 const uint8_t ff_hevc_qpel_extra_after[4] = { 0, 3, 4, 4 };
41 const uint8_t ff_hevc_qpel_extra[4] = { 0, 6, 7, 6 };
43 static const uint8_t scan_1x1[1] = { 0 };
45 static const uint8_t horiz_scan2x2_x[4] = { 0, 1, 0, 1 };
47 static const uint8_t horiz_scan2x2_y[4] = { 0, 0, 1, 1 };
49 static const uint8_t horiz_scan4x4_x[16] = {
56 static const uint8_t horiz_scan4x4_y[16] = {
63 static const uint8_t horiz_scan8x8_inv[8][8] = {
64 { 0, 1, 2, 3, 16, 17, 18, 19, },
65 { 4, 5, 6, 7, 20, 21, 22, 23, },
66 { 8, 9, 10, 11, 24, 25, 26, 27, },
67 { 12, 13, 14, 15, 28, 29, 30, 31, },
68 { 32, 33, 34, 35, 48, 49, 50, 51, },
69 { 36, 37, 38, 39, 52, 53, 54, 55, },
70 { 40, 41, 42, 43, 56, 57, 58, 59, },
71 { 44, 45, 46, 47, 60, 61, 62, 63, },
74 static const uint8_t diag_scan2x2_x[4] = { 0, 0, 1, 1 };
76 static const uint8_t diag_scan2x2_y[4] = { 0, 1, 0, 1 };
78 static const uint8_t diag_scan2x2_inv[2][2] = {
83 const uint8_t ff_hevc_diag_scan4x4_x[16] = {
90 const uint8_t ff_hevc_diag_scan4x4_y[16] = {
97 static const uint8_t diag_scan4x4_inv[4][4] = {
104 const uint8_t ff_hevc_diag_scan8x8_x[64] = {
123 const uint8_t ff_hevc_diag_scan8x8_y[64] = {
142 static const uint8_t diag_scan8x8_inv[8][8] = {
143 { 0, 2, 5, 9, 14, 20, 27, 35, },
144 { 1, 4, 8, 13, 19, 26, 34, 42, },
145 { 3, 7, 12, 18, 25, 33, 41, 48, },
146 { 6, 11, 17, 24, 32, 40, 47, 53, },
147 { 10, 16, 23, 31, 39, 46, 52, 57, },
148 { 15, 22, 30, 38, 45, 51, 56, 60, },
149 { 21, 29, 37, 44, 50, 55, 59, 62, },
150 { 28, 36, 43, 49, 54, 58, 61, 63, },
154 * NOTE: Each function hls_foo correspond to the function foo in the
155 * specification (HLS stands for High Level Syntax).
162 /* free everything allocated by pic_arrays_init() */
163 static void pic_arrays_free(HEVCContext *s)
166 av_freep(&s->deblock);
167 av_freep(&s->split_cu_flag);
169 av_freep(&s->skip_flag);
170 av_freep(&s->tab_ct_depth);
172 av_freep(&s->tab_ipm);
173 av_freep(&s->cbf_luma);
174 av_freep(&s->is_pcm);
176 av_freep(&s->qp_y_tab);
177 av_freep(&s->tab_slice_address);
178 av_freep(&s->filter_slice_edges);
180 av_freep(&s->horizontal_bs);
181 av_freep(&s->vertical_bs);
183 av_buffer_pool_uninit(&s->tab_mvf_pool);
184 av_buffer_pool_uninit(&s->rpl_tab_pool);
187 /* allocate arrays that depend on frame dimensions */
188 static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
190 int log2_min_cb_size = sps->log2_min_cb_size;
191 int width = sps->width;
192 int height = sps->height;
193 int pic_size = width * height;
194 int pic_size_in_ctb = ((width >> log2_min_cb_size) + 1) *
195 ((height >> log2_min_cb_size) + 1);
196 int ctb_count = sps->ctb_width * sps->ctb_height;
197 int min_pu_size = sps->min_pu_width * sps->min_pu_height;
199 s->bs_width = width >> 3;
200 s->bs_height = height >> 3;
202 s->sao = av_mallocz_array(ctb_count, sizeof(*s->sao));
203 s->deblock = av_mallocz_array(ctb_count, sizeof(*s->deblock));
204 s->split_cu_flag = av_malloc(pic_size);
205 if (!s->sao || !s->deblock || !s->split_cu_flag)
208 s->skip_flag = av_malloc(pic_size_in_ctb);
209 s->tab_ct_depth = av_malloc(sps->min_cb_height * sps->min_cb_width);
210 if (!s->skip_flag || !s->tab_ct_depth)
213 s->cbf_luma = av_malloc(sps->min_tb_width * sps->min_tb_height);
214 s->tab_ipm = av_malloc(min_pu_size);
215 s->is_pcm = av_malloc(min_pu_size);
216 if (!s->tab_ipm || !s->cbf_luma || !s->is_pcm)
219 s->filter_slice_edges = av_malloc(ctb_count);
220 s->tab_slice_address = av_malloc(pic_size_in_ctb *
221 sizeof(*s->tab_slice_address));
222 s->qp_y_tab = av_malloc(pic_size_in_ctb *
223 sizeof(*s->qp_y_tab));
224 if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address)
227 s->horizontal_bs = av_mallocz(2 * s->bs_width * (s->bs_height + 1));
228 s->vertical_bs = av_mallocz(2 * s->bs_width * (s->bs_height + 1));
229 if (!s->horizontal_bs || !s->vertical_bs)
232 s->tab_mvf_pool = av_buffer_pool_init(min_pu_size * sizeof(MvField),
234 s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab),
236 if (!s->tab_mvf_pool || !s->rpl_tab_pool)
243 return AVERROR(ENOMEM);
246 static void pred_weight_table(HEVCContext *s, GetBitContext *gb)
250 uint8_t luma_weight_l0_flag[16];
251 uint8_t chroma_weight_l0_flag[16];
252 uint8_t luma_weight_l1_flag[16];
253 uint8_t chroma_weight_l1_flag[16];
255 s->sh.luma_log2_weight_denom = get_ue_golomb_long(gb);
256 if (s->sps->chroma_format_idc != 0) {
257 int delta = get_se_golomb(gb);
258 s->sh.chroma_log2_weight_denom = av_clip_c(s->sh.luma_log2_weight_denom + delta, 0, 7);
261 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
262 luma_weight_l0_flag[i] = get_bits1(gb);
263 if (!luma_weight_l0_flag[i]) {
264 s->sh.luma_weight_l0[i] = 1 << s->sh.luma_log2_weight_denom;
265 s->sh.luma_offset_l0[i] = 0;
268 if (s->sps->chroma_format_idc != 0) { // FIXME: invert "if" and "for"
269 for (i = 0; i < s->sh.nb_refs[L0]; i++)
270 chroma_weight_l0_flag[i] = get_bits1(gb);
272 for (i = 0; i < s->sh.nb_refs[L0]; i++)
273 chroma_weight_l0_flag[i] = 0;
275 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
276 if (luma_weight_l0_flag[i]) {
277 int delta_luma_weight_l0 = get_se_golomb(gb);
278 s->sh.luma_weight_l0[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;
279 s->sh.luma_offset_l0[i] = get_se_golomb(gb);
281 if (chroma_weight_l0_flag[i]) {
282 for (j = 0; j < 2; j++) {
283 int delta_chroma_weight_l0 = get_se_golomb(gb);
284 int delta_chroma_offset_l0 = get_se_golomb(gb);
285 s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
286 s->sh.chroma_offset_l0[i][j] = av_clip_c((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j])
287 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
290 s->sh.chroma_weight_l0[i][0] = 1 << s->sh.chroma_log2_weight_denom;
291 s->sh.chroma_offset_l0[i][0] = 0;
292 s->sh.chroma_weight_l0[i][1] = 1 << s->sh.chroma_log2_weight_denom;
293 s->sh.chroma_offset_l0[i][1] = 0;
296 if (s->sh.slice_type == B_SLICE) {
297 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
298 luma_weight_l1_flag[i] = get_bits1(gb);
299 if (!luma_weight_l1_flag[i]) {
300 s->sh.luma_weight_l1[i] = 1 << s->sh.luma_log2_weight_denom;
301 s->sh.luma_offset_l1[i] = 0;
304 if (s->sps->chroma_format_idc != 0) {
305 for (i = 0; i < s->sh.nb_refs[L1]; i++)
306 chroma_weight_l1_flag[i] = get_bits1(gb);
308 for (i = 0; i < s->sh.nb_refs[L1]; i++)
309 chroma_weight_l1_flag[i] = 0;
311 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
312 if (luma_weight_l1_flag[i]) {
313 int delta_luma_weight_l1 = get_se_golomb(gb);
314 s->sh.luma_weight_l1[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;
315 s->sh.luma_offset_l1[i] = get_se_golomb(gb);
317 if (chroma_weight_l1_flag[i]) {
318 for (j = 0; j < 2; j++) {
319 int delta_chroma_weight_l1 = get_se_golomb(gb);
320 int delta_chroma_offset_l1 = get_se_golomb(gb);
321 s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
322 s->sh.chroma_offset_l1[i][j] = av_clip_c((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j])
323 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
326 s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom;
327 s->sh.chroma_offset_l1[i][0] = 0;
328 s->sh.chroma_weight_l1[i][1] = 1 << s->sh.chroma_log2_weight_denom;
329 s->sh.chroma_offset_l1[i][1] = 0;
335 static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
337 const HEVCSPS *sps = s->sps;
338 int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
339 int prev_delta_msb = 0;
340 int nb_sps = 0, nb_sh;
344 if (!sps->long_term_ref_pics_present_flag)
347 if (sps->num_long_term_ref_pics_sps > 0)
348 nb_sps = get_ue_golomb_long(gb);
349 nb_sh = get_ue_golomb_long(gb);
351 if (nb_sh + nb_sps > FF_ARRAY_ELEMS(rps->poc))
352 return AVERROR_INVALIDDATA;
354 rps->nb_refs = nb_sh + nb_sps;
356 for (i = 0; i < rps->nb_refs; i++) {
357 uint8_t delta_poc_msb_present;
360 uint8_t lt_idx_sps = 0;
362 if (sps->num_long_term_ref_pics_sps > 1)
363 lt_idx_sps = get_bits(gb, av_ceil_log2(sps->num_long_term_ref_pics_sps));
365 rps->poc[i] = sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
366 rps->used[i] = sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];
368 rps->poc[i] = get_bits(gb, sps->log2_max_poc_lsb);
369 rps->used[i] = get_bits1(gb);
372 delta_poc_msb_present = get_bits1(gb);
373 if (delta_poc_msb_present) {
374 int delta = get_ue_golomb_long(gb);
376 if (i && i != nb_sps)
377 delta += prev_delta_msb;
379 rps->poc[i] += s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
380 prev_delta_msb = delta;
387 static int set_sps(HEVCContext *s, const HEVCSPS *sps)
392 ret = pic_arrays_init(s, sps);
396 s->avctx->coded_width = sps->width;
397 s->avctx->coded_height = sps->height;
398 s->avctx->width = sps->output_width;
399 s->avctx->height = sps->output_height;
400 s->avctx->pix_fmt = sps->pix_fmt;
401 s->avctx->sample_aspect_ratio = sps->vui.sar;
402 s->avctx->has_b_frames = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics;
404 if (sps->vui.video_signal_type_present_flag)
405 s->avctx->color_range = sps->vui.video_full_range_flag ? AVCOL_RANGE_JPEG
408 s->avctx->color_range = AVCOL_RANGE_MPEG;
410 if (sps->vui.colour_description_present_flag) {
411 s->avctx->color_primaries = sps->vui.colour_primaries;
412 s->avctx->color_trc = sps->vui.transfer_characteristic;
413 s->avctx->colorspace = sps->vui.matrix_coeffs;
415 s->avctx->color_primaries = AVCOL_PRI_UNSPECIFIED;
416 s->avctx->color_trc = AVCOL_TRC_UNSPECIFIED;
417 s->avctx->colorspace = AVCOL_SPC_UNSPECIFIED;
420 ff_hevc_pred_init(&s->hpc, sps->bit_depth);
421 ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
422 ff_videodsp_init (&s->vdsp, sps->bit_depth);
424 if (sps->sao_enabled) {
425 av_frame_unref(s->tmp_frame);
426 ret = ff_get_buffer(s->avctx, s->tmp_frame, AV_GET_BUFFER_FLAG_REF);
429 s->frame = s->tmp_frame;
433 s->vps = s->vps_list[s->sps->vps_id];
442 static int hls_slice_header(HEVCContext *s)
444 GetBitContext *gb = &s->HEVClc.gb;
445 SliceHeader *sh = &s->sh;
449 sh->first_slice_in_pic_flag = get_bits1(gb);
450 if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
451 s->seq_decode = (s->seq_decode + 1) & 0xff;
454 ff_hevc_clear_refs(s);
456 if (s->nal_unit_type >= 16 && s->nal_unit_type <= 23)
457 sh->no_output_of_prior_pics_flag = get_bits1(gb);
459 sh->pps_id = get_ue_golomb_long(gb);
460 if (sh->pps_id >= MAX_PPS_COUNT || !s->pps_list[sh->pps_id]) {
461 av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
462 return AVERROR_INVALIDDATA;
464 if (!sh->first_slice_in_pic_flag &&
465 s->pps != (HEVCPPS*)s->pps_list[sh->pps_id]->data) {
466 av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
467 return AVERROR_INVALIDDATA;
469 s->pps = (HEVCPPS*)s->pps_list[sh->pps_id]->data;
471 if (s->sps != (HEVCSPS*)s->sps_list[s->pps->sps_id]->data) {
472 s->sps = (HEVCSPS*)s->sps_list[s->pps->sps_id]->data;
474 ff_hevc_clear_refs(s);
475 ret = set_sps(s, s->sps);
479 s->seq_decode = (s->seq_decode + 1) & 0xff;
483 sh->dependent_slice_segment_flag = 0;
484 if (!sh->first_slice_in_pic_flag) {
485 int slice_address_length;
487 if (s->pps->dependent_slice_segments_enabled_flag)
488 sh->dependent_slice_segment_flag = get_bits1(gb);
490 slice_address_length = av_ceil_log2(s->sps->ctb_width *
492 sh->slice_segment_addr = get_bits(gb, slice_address_length);
493 if (sh->slice_segment_addr >= s->sps->ctb_width * s->sps->ctb_height) {
494 av_log(s->avctx, AV_LOG_ERROR,
495 "Invalid slice segment address: %u.\n",
496 sh->slice_segment_addr);
497 return AVERROR_INVALIDDATA;
500 if (!sh->dependent_slice_segment_flag) {
501 sh->slice_addr = sh->slice_segment_addr;
505 sh->slice_segment_addr = sh->slice_addr = 0;
507 s->slice_initialized = 0;
510 if (!sh->dependent_slice_segment_flag) {
511 s->slice_initialized = 0;
513 for (i = 0; i < s->pps->num_extra_slice_header_bits; i++)
514 skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
516 sh->slice_type = get_ue_golomb_long(gb);
517 if (!(sh->slice_type == I_SLICE ||
518 sh->slice_type == P_SLICE ||
519 sh->slice_type == B_SLICE)) {
520 av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
522 return AVERROR_INVALIDDATA;
524 if (IS_IRAP(s) && sh->slice_type != I_SLICE) {
525 av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
526 return AVERROR_INVALIDDATA;
529 if (s->pps->output_flag_present_flag)
530 sh->pic_output_flag = get_bits1(gb);
532 if (s->sps->separate_colour_plane_flag)
533 sh->colour_plane_id = get_bits(gb, 2);
536 int short_term_ref_pic_set_sps_flag, poc;
538 sh->pic_order_cnt_lsb = get_bits(gb, s->sps->log2_max_poc_lsb);
539 poc = ff_hevc_compute_poc(s, sh->pic_order_cnt_lsb);
540 if (!sh->first_slice_in_pic_flag && poc != s->poc) {
541 av_log(s->avctx, AV_LOG_WARNING,
542 "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
543 if (s->avctx->err_recognition & AV_EF_EXPLODE)
544 return AVERROR_INVALIDDATA;
549 short_term_ref_pic_set_sps_flag = get_bits1(gb);
550 if (!short_term_ref_pic_set_sps_flag) {
551 ret = ff_hevc_decode_short_term_rps(s, &sh->slice_rps, s->sps, 1);
555 sh->short_term_rps = &sh->slice_rps;
557 int numbits, rps_idx;
559 if (!s->sps->nb_st_rps) {
560 av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
561 return AVERROR_INVALIDDATA;
564 numbits = av_ceil_log2(s->sps->nb_st_rps);
565 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
566 sh->short_term_rps = &s->sps->st_rps[rps_idx];
569 ret = decode_lt_rps(s, &sh->long_term_rps, gb);
571 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
572 if (s->avctx->err_recognition & AV_EF_EXPLODE)
573 return AVERROR_INVALIDDATA;
576 if (s->sps->sps_temporal_mvp_enabled_flag)
577 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
579 sh->slice_temporal_mvp_enabled_flag = 0;
581 s->sh.short_term_rps = NULL;
586 if (s->temporal_id == 0 &&
587 s->nal_unit_type != NAL_TRAIL_N &&
588 s->nal_unit_type != NAL_TSA_N &&
589 s->nal_unit_type != NAL_STSA_N &&
590 s->nal_unit_type != NAL_RADL_N &&
591 s->nal_unit_type != NAL_RADL_R &&
592 s->nal_unit_type != NAL_RASL_N &&
593 s->nal_unit_type != NAL_RASL_R)
596 if (s->sps->sao_enabled) {
597 sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
598 sh->slice_sample_adaptive_offset_flag[1] =
599 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
601 sh->slice_sample_adaptive_offset_flag[0] = 0;
602 sh->slice_sample_adaptive_offset_flag[1] = 0;
603 sh->slice_sample_adaptive_offset_flag[2] = 0;
606 sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
607 if (sh->slice_type == P_SLICE || sh->slice_type == B_SLICE) {
610 sh->nb_refs[L0] = s->pps->num_ref_idx_l0_default_active;
611 if (sh->slice_type == B_SLICE)
612 sh->nb_refs[L1] = s->pps->num_ref_idx_l1_default_active;
614 if (get_bits1(gb)) { // num_ref_idx_active_override_flag
615 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
616 if (sh->slice_type == B_SLICE)
617 sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
619 if (sh->nb_refs[L0] > MAX_REFS || sh->nb_refs[L1] > MAX_REFS) {
620 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
621 sh->nb_refs[L0], sh->nb_refs[L1]);
622 return AVERROR_INVALIDDATA;
625 sh->rpl_modification_flag[0] = 0;
626 sh->rpl_modification_flag[1] = 0;
627 nb_refs = ff_hevc_frame_nb_refs(s);
629 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
630 return AVERROR_INVALIDDATA;
633 if (s->pps->lists_modification_present_flag && nb_refs > 1) {
634 sh->rpl_modification_flag[0] = get_bits1(gb);
635 if (sh->rpl_modification_flag[0]) {
636 for (i = 0; i < sh->nb_refs[L0]; i++)
637 sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
640 if (sh->slice_type == B_SLICE) {
641 sh->rpl_modification_flag[1] = get_bits1(gb);
642 if (sh->rpl_modification_flag[1] == 1)
643 for (i = 0; i < sh->nb_refs[L1]; i++)
644 sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
648 if (sh->slice_type == B_SLICE)
649 sh->mvd_l1_zero_flag = get_bits1(gb);
651 if (s->pps->cabac_init_present_flag)
652 sh->cabac_init_flag = get_bits1(gb);
654 sh->cabac_init_flag = 0;
656 sh->collocated_ref_idx = 0;
657 if (sh->slice_temporal_mvp_enabled_flag) {
658 sh->collocated_list = L0;
659 if (sh->slice_type == B_SLICE)
660 sh->collocated_list = !get_bits1(gb);
662 if (sh->nb_refs[sh->collocated_list] > 1) {
663 sh->collocated_ref_idx = get_ue_golomb_long(gb);
664 if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
665 av_log(s->avctx, AV_LOG_ERROR,
666 "Invalid collocated_ref_idx: %d.\n",
667 sh->collocated_ref_idx);
668 return AVERROR_INVALIDDATA;
673 if ((s->pps->weighted_pred_flag && sh->slice_type == P_SLICE) ||
674 (s->pps->weighted_bipred_flag && sh->slice_type == B_SLICE)) {
675 pred_weight_table(s, gb);
678 sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
679 if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
680 av_log(s->avctx, AV_LOG_ERROR,
681 "Invalid number of merging MVP candidates: %d.\n",
682 sh->max_num_merge_cand);
683 return AVERROR_INVALIDDATA;
687 sh->slice_qp_delta = get_se_golomb(gb);
688 if (s->pps->pic_slice_level_chroma_qp_offsets_present_flag) {
689 sh->slice_cb_qp_offset = get_se_golomb(gb);
690 sh->slice_cr_qp_offset = get_se_golomb(gb);
692 sh->slice_cb_qp_offset = 0;
693 sh->slice_cr_qp_offset = 0;
696 if (s->pps->deblocking_filter_control_present_flag) {
697 int deblocking_filter_override_flag = 0;
699 if (s->pps->deblocking_filter_override_enabled_flag)
700 deblocking_filter_override_flag = get_bits1(gb);
702 if (deblocking_filter_override_flag) {
703 sh->disable_deblocking_filter_flag = get_bits1(gb);
704 if (!sh->disable_deblocking_filter_flag) {
705 sh->beta_offset = get_se_golomb(gb) * 2;
706 sh->tc_offset = get_se_golomb(gb) * 2;
709 sh->disable_deblocking_filter_flag = s->pps->disable_dbf;
710 sh->beta_offset = s->pps->beta_offset;
711 sh->tc_offset = s->pps->tc_offset;
714 sh->disable_deblocking_filter_flag = 0;
719 if (s->pps->seq_loop_filter_across_slices_enabled_flag &&
720 (sh->slice_sample_adaptive_offset_flag[0] ||
721 sh->slice_sample_adaptive_offset_flag[1] ||
722 !sh->disable_deblocking_filter_flag)) {
723 sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
725 sh->slice_loop_filter_across_slices_enabled_flag = s->pps->seq_loop_filter_across_slices_enabled_flag;
727 } else if (!s->slice_initialized) {
728 av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
729 return AVERROR_INVALIDDATA;
732 sh->num_entry_point_offsets = 0;
733 if (s->pps->tiles_enabled_flag || s->pps->entropy_coding_sync_enabled_flag) {
734 sh->num_entry_point_offsets = get_ue_golomb_long(gb);
735 if (sh->num_entry_point_offsets > 0) {
736 int offset_len = get_ue_golomb_long(gb) + 1;
738 for (i = 0; i < sh->num_entry_point_offsets; i++)
739 skip_bits(gb, offset_len);
743 if (s->pps->slice_header_extension_present_flag) {
744 int length = get_ue_golomb_long(gb);
745 for (i = 0; i < length; i++)
746 skip_bits(gb, 8); // slice_header_extension_data_byte
749 // Inferred parameters
750 sh->slice_qp = 26 + s->pps->pic_init_qp_minus26 + sh->slice_qp_delta;
751 sh->slice_ctb_addr_rs = sh->slice_segment_addr;
753 s->HEVClc.first_qp_group = !s->sh.dependent_slice_segment_flag;
755 if (!s->pps->cu_qp_delta_enabled_flag)
756 s->HEVClc.qp_y = ((s->sh.slice_qp + 52 + 2 * s->sps->qp_bd_offset) %
757 (52 + s->sps->qp_bd_offset)) - s->sps->qp_bd_offset;
759 s->slice_initialized = 1;
764 #define CTB(tab, x, y) ((tab)[(y) * s->sps->ctb_width + (x)])
766 #define SET_SAO(elem, value) \
768 if (!sao_merge_up_flag && !sao_merge_left_flag) \
770 else if (sao_merge_left_flag) \
771 sao->elem = CTB(s->sao, rx-1, ry).elem; \
772 else if (sao_merge_up_flag) \
773 sao->elem = CTB(s->sao, rx, ry-1).elem; \
778 static void hls_sao_param(HEVCContext *s, int rx, int ry)
780 HEVCLocalContext *lc = &s->HEVClc;
781 int sao_merge_left_flag = 0;
782 int sao_merge_up_flag = 0;
783 int shift = s->sps->bit_depth - FFMIN(s->sps->bit_depth, 10);
784 SAOParams *sao = &CTB(s->sao, rx, ry);
787 if (s->sh.slice_sample_adaptive_offset_flag[0] ||
788 s->sh.slice_sample_adaptive_offset_flag[1]) {
790 if (lc->ctb_left_flag)
791 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
793 if (ry > 0 && !sao_merge_left_flag) {
795 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
799 for (c_idx = 0; c_idx < 3; c_idx++) {
800 if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
801 sao->type_idx[c_idx] = SAO_NOT_APPLIED;
806 sao->type_idx[2] = sao->type_idx[1];
807 sao->eo_class[2] = sao->eo_class[1];
809 SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
812 if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
815 for (i = 0; i < 4; i++)
816 SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
818 if (sao->type_idx[c_idx] == SAO_BAND) {
819 for (i = 0; i < 4; i++) {
820 if (sao->offset_abs[c_idx][i]) {
821 SET_SAO(offset_sign[c_idx][i],
822 ff_hevc_sao_offset_sign_decode(s));
824 sao->offset_sign[c_idx][i] = 0;
827 SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
828 } else if (c_idx != 2) {
829 SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
832 // Inferred parameters
833 sao->offset_val[c_idx][0] = 0;
834 for (i = 0; i < 4; i++) {
835 sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i] << shift;
836 if (sao->type_idx[c_idx] == SAO_EDGE) {
838 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
839 } else if (sao->offset_sign[c_idx][i]) {
840 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
849 static void hls_residual_coding(HEVCContext *s, int x0, int y0,
850 int log2_trafo_size, enum ScanType scan_idx,
853 #define GET_COORD(offset, n) \
855 x_c = (scan_x_cg[offset >> 4] << 2) + scan_x_off[n]; \
856 y_c = (scan_y_cg[offset >> 4] << 2) + scan_y_off[n]; \
858 HEVCLocalContext *lc = &s->HEVClc;
859 int transform_skip_flag = 0;
861 int last_significant_coeff_x, last_significant_coeff_y;
865 int greater1_ctx = 1;
868 int x_cg_last_sig, y_cg_last_sig;
870 const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
872 ptrdiff_t stride = s->frame->linesize[c_idx];
873 int hshift = s->sps->hshift[c_idx];
874 int vshift = s->sps->vshift[c_idx];
875 uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
876 ((x0 >> hshift) << s->sps->pixel_shift)];
877 DECLARE_ALIGNED(16, int16_t, coeffs[MAX_TB_SIZE * MAX_TB_SIZE]) = { 0 };
878 DECLARE_ALIGNED(8, uint8_t, significant_coeff_group_flag[8][8]) = { { 0 } };
880 int trafo_size = 1 << log2_trafo_size;
881 int i, qp, shift, add, scale, scale_m;
882 const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
883 const uint8_t *scale_matrix;
886 // Derive QP for dequant
887 if (!lc->cu.cu_transquant_bypass_flag) {
888 static const int qp_c[] = {
889 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37
892 static const uint8_t rem6[51 + 2 * 6 + 1] = {
893 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
894 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
895 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
898 static const uint8_t div6[51 + 2 * 6 + 1] = {
899 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
900 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
901 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
906 qp = qp_y + s->sps->qp_bd_offset;
911 offset = s->pps->cb_qp_offset + s->sh.slice_cb_qp_offset;
913 offset = s->pps->cr_qp_offset + s->sh.slice_cr_qp_offset;
915 qp_i = av_clip_c(qp_y + offset, -s->sps->qp_bd_offset, 57);
921 qp = qp_c[qp_i - 30];
923 qp += s->sps->qp_bd_offset;
926 shift = s->sps->bit_depth + log2_trafo_size - 5;
927 add = 1 << (shift - 1);
928 scale = level_scale[rem6[qp]] << (div6[qp]);
929 scale_m = 16; // default when no custom scaling lists.
932 if (s->sps->scaling_list_enable_flag) {
933 const ScalingList *sl = s->pps->scaling_list_data_present_flag ?
934 &s->pps->scaling_list : &s->sps->scaling_list;
935 int matrix_id = lc->cu.pred_mode != MODE_INTRA;
937 if (log2_trafo_size != 5)
938 matrix_id = 3 * matrix_id + c_idx;
940 scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
941 if (log2_trafo_size >= 4)
942 dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
946 if (s->pps->transform_skip_enabled_flag &&
947 !lc->cu.cu_transquant_bypass_flag &&
948 log2_trafo_size == 2) {
949 transform_skip_flag = ff_hevc_transform_skip_flag_decode(s, c_idx);
952 last_significant_coeff_x =
953 ff_hevc_last_significant_coeff_x_prefix_decode(s, c_idx, log2_trafo_size);
954 last_significant_coeff_y =
955 ff_hevc_last_significant_coeff_y_prefix_decode(s, c_idx, log2_trafo_size);
957 if (last_significant_coeff_x > 3) {
958 int suffix = ff_hevc_last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
959 last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
960 (2 + (last_significant_coeff_x & 1)) +
964 if (last_significant_coeff_y > 3) {
965 int suffix = ff_hevc_last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
966 last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
967 (2 + (last_significant_coeff_y & 1)) +
971 if (scan_idx == SCAN_VERT)
972 FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
974 x_cg_last_sig = last_significant_coeff_x >> 2;
975 y_cg_last_sig = last_significant_coeff_y >> 2;
979 int last_x_c = last_significant_coeff_x & 3;
980 int last_y_c = last_significant_coeff_y & 3;
982 scan_x_off = ff_hevc_diag_scan4x4_x;
983 scan_y_off = ff_hevc_diag_scan4x4_y;
984 num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
985 if (trafo_size == 4) {
986 scan_x_cg = scan_1x1;
987 scan_y_cg = scan_1x1;
988 } else if (trafo_size == 8) {
989 num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
990 scan_x_cg = diag_scan2x2_x;
991 scan_y_cg = diag_scan2x2_y;
992 } else if (trafo_size == 16) {
993 num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
994 scan_x_cg = ff_hevc_diag_scan4x4_x;
995 scan_y_cg = ff_hevc_diag_scan4x4_y;
996 } else { // trafo_size == 32
997 num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
998 scan_x_cg = ff_hevc_diag_scan8x8_x;
999 scan_y_cg = ff_hevc_diag_scan8x8_y;
1004 scan_x_cg = horiz_scan2x2_x;
1005 scan_y_cg = horiz_scan2x2_y;
1006 scan_x_off = horiz_scan4x4_x;
1007 scan_y_off = horiz_scan4x4_y;
1008 num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1010 default: //SCAN_VERT
1011 scan_x_cg = horiz_scan2x2_y;
1012 scan_y_cg = horiz_scan2x2_x;
1013 scan_x_off = horiz_scan4x4_y;
1014 scan_y_off = horiz_scan4x4_x;
1015 num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1019 num_last_subset = (num_coeff - 1) >> 4;
1021 for (i = num_last_subset; i >= 0; i--) {
1023 int x_cg, y_cg, x_c, y_c;
1024 int implicit_non_zero_coeff = 0;
1025 int64_t trans_coeff_level;
1027 int offset = i << 4;
1029 uint8_t significant_coeff_flag_idx[16];
1030 uint8_t nb_significant_coeff_flag = 0;
1032 x_cg = scan_x_cg[i];
1033 y_cg = scan_y_cg[i];
1035 if (i < num_last_subset && i > 0) {
1037 if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1038 ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1039 if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1040 ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1042 significant_coeff_group_flag[x_cg][y_cg] =
1043 ff_hevc_significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
1044 implicit_non_zero_coeff = 1;
1046 significant_coeff_group_flag[x_cg][y_cg] =
1047 ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1048 (x_cg == 0 && y_cg == 0));
1051 last_scan_pos = num_coeff - offset - 1;
1053 if (i == num_last_subset) {
1054 n_end = last_scan_pos - 1;
1055 significant_coeff_flag_idx[0] = last_scan_pos;
1056 nb_significant_coeff_flag = 1;
1061 if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1062 prev_sig = significant_coeff_group_flag[x_cg + 1][y_cg];
1063 if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1064 prev_sig += significant_coeff_group_flag[x_cg][y_cg + 1] << 1;
1066 for (n = n_end; n >= 0; n--) {
1067 GET_COORD(offset, n);
1069 if (significant_coeff_group_flag[x_cg][y_cg] &&
1070 (n > 0 || implicit_non_zero_coeff == 0)) {
1071 if (ff_hevc_significant_coeff_flag_decode(s, c_idx, x_c, y_c,
1075 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1076 nb_significant_coeff_flag++;
1077 implicit_non_zero_coeff = 0;
1080 int last_cg = (x_c == (x_cg << 2) && y_c == (y_cg << 2));
1081 if (last_cg && implicit_non_zero_coeff && significant_coeff_group_flag[x_cg][y_cg]) {
1082 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1083 nb_significant_coeff_flag++;
1088 n_end = nb_significant_coeff_flag;
1091 int first_nz_pos_in_cg = 16;
1092 int last_nz_pos_in_cg = -1;
1093 int c_rice_param = 0;
1094 int first_greater1_coeff_idx = -1;
1095 uint8_t coeff_abs_level_greater1_flag[16] = { 0 };
1096 uint16_t coeff_sign_flag;
1098 int sign_hidden = 0;
1100 // initialize first elem of coeff_bas_level_greater1_flag
1101 int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1103 if (!(i == num_last_subset) && greater1_ctx == 0)
1106 last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1108 for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1109 int n_idx = significant_coeff_flag_idx[m];
1110 int inc = (ctx_set << 2) + greater1_ctx;
1111 coeff_abs_level_greater1_flag[n_idx] =
1112 ff_hevc_coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
1113 if (coeff_abs_level_greater1_flag[n_idx]) {
1115 } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1119 if (coeff_abs_level_greater1_flag[n_idx] &&
1120 first_greater1_coeff_idx == -1)
1121 first_greater1_coeff_idx = n_idx;
1123 first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1124 sign_hidden = last_nz_pos_in_cg - first_nz_pos_in_cg >= 4 &&
1125 !lc->cu.cu_transquant_bypass_flag;
1127 if (first_greater1_coeff_idx != -1) {
1128 coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += ff_hevc_coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1130 if (!s->pps->sign_data_hiding_flag || !sign_hidden) {
1131 coeff_sign_flag = ff_hevc_coeff_sign_flag(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1133 coeff_sign_flag = ff_hevc_coeff_sign_flag(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1136 for (m = 0; m < n_end; m++) {
1137 n = significant_coeff_flag_idx[m];
1138 GET_COORD(offset, n);
1139 trans_coeff_level = 1 + coeff_abs_level_greater1_flag[n];
1140 if (trans_coeff_level == ((m < 8) ?
1141 ((n == first_greater1_coeff_idx) ? 3 : 2) : 1)) {
1142 int last_coeff_abs_level_remaining = ff_hevc_coeff_abs_level_remaining(s, trans_coeff_level, c_rice_param);
1144 trans_coeff_level += last_coeff_abs_level_remaining;
1145 if ((trans_coeff_level) > (3 * (1 << c_rice_param)))
1146 c_rice_param = FFMIN(c_rice_param + 1, 4);
1148 if (s->pps->sign_data_hiding_flag && sign_hidden) {
1149 sum_abs += trans_coeff_level;
1150 if (n == first_nz_pos_in_cg && ((sum_abs & 1) == 1))
1151 trans_coeff_level = -trans_coeff_level;
1153 if (coeff_sign_flag >> 15)
1154 trans_coeff_level = -trans_coeff_level;
1155 coeff_sign_flag <<= 1;
1156 if (!lc->cu.cu_transquant_bypass_flag) {
1157 if (s->sps->scaling_list_enable_flag) {
1158 if (y_c || x_c || log2_trafo_size < 4) {
1160 switch (log2_trafo_size) {
1161 case 3: pos = (y_c << 3) + x_c; break;
1162 case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1163 case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1164 default: pos = (y_c << 2) + x_c;
1166 scale_m = scale_matrix[pos];
1171 trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1172 if(trans_coeff_level < 0) {
1173 if((~trans_coeff_level) & 0xFffffffffff8000)
1174 trans_coeff_level = -32768;
1176 if (trans_coeff_level & 0xffffffffffff8000)
1177 trans_coeff_level = 32767;
1180 coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1185 if (lc->cu.cu_transquant_bypass_flag) {
1186 s->hevcdsp.transquant_bypass[log2_trafo_size - 2](dst, coeffs, stride);
1188 if (transform_skip_flag)
1189 s->hevcdsp.transform_skip(dst, coeffs, stride);
1190 else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 &&
1191 log2_trafo_size == 2)
1192 s->hevcdsp.transform_4x4_luma_add(dst, coeffs, stride);
1194 s->hevcdsp.transform_add[log2_trafo_size - 2](dst, coeffs, stride);
1198 static void hls_transform_unit(HEVCContext *s, int x0, int y0,
1199 int xBase, int yBase, int cb_xBase, int cb_yBase,
1200 int log2_cb_size, int log2_trafo_size,
1201 int trafo_depth, int blk_idx)
1203 HEVCLocalContext *lc = &s->HEVClc;
1205 if (lc->cu.pred_mode == MODE_INTRA) {
1206 int trafo_size = 1 << log2_trafo_size;
1207 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1209 s->hpc.intra_pred(s, x0, y0, log2_trafo_size, 0);
1210 if (log2_trafo_size > 2) {
1211 trafo_size = trafo_size << (s->sps->hshift[1] - 1);
1212 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1213 s->hpc.intra_pred(s, x0, y0, log2_trafo_size - 1, 1);
1214 s->hpc.intra_pred(s, x0, y0, log2_trafo_size - 1, 2);
1215 } else if (blk_idx == 3) {
1216 trafo_size = trafo_size << s->sps->hshift[1];
1217 ff_hevc_set_neighbour_available(s, xBase, yBase,
1218 trafo_size, trafo_size);
1219 s->hpc.intra_pred(s, xBase, yBase, log2_trafo_size, 1);
1220 s->hpc.intra_pred(s, xBase, yBase, log2_trafo_size, 2);
1224 if (lc->tt.cbf_luma ||
1225 SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], x0, y0) ||
1226 SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], x0, y0)) {
1227 int scan_idx = SCAN_DIAG;
1228 int scan_idx_c = SCAN_DIAG;
1230 if (s->pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
1231 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
1232 if (lc->tu.cu_qp_delta != 0)
1233 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
1234 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
1235 lc->tu.is_cu_qp_delta_coded = 1;
1236 ff_hevc_set_qPy(s, x0, y0, cb_xBase, cb_yBase, log2_cb_size);
1239 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
1240 if (lc->tu.cur_intra_pred_mode >= 6 &&
1241 lc->tu.cur_intra_pred_mode <= 14) {
1242 scan_idx = SCAN_VERT;
1243 } else if (lc->tu.cur_intra_pred_mode >= 22 &&
1244 lc->tu.cur_intra_pred_mode <= 30) {
1245 scan_idx = SCAN_HORIZ;
1248 if (lc->pu.intra_pred_mode_c >= 6 &&
1249 lc->pu.intra_pred_mode_c <= 14) {
1250 scan_idx_c = SCAN_VERT;
1251 } else if (lc->pu.intra_pred_mode_c >= 22 &&
1252 lc->pu.intra_pred_mode_c <= 30) {
1253 scan_idx_c = SCAN_HORIZ;
1257 if (lc->tt.cbf_luma)
1258 hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
1259 if (log2_trafo_size > 2) {
1260 if (SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], x0, y0))
1261 hls_residual_coding(s, x0, y0, log2_trafo_size - 1, scan_idx_c, 1);
1262 if (SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], x0, y0))
1263 hls_residual_coding(s, x0, y0, log2_trafo_size - 1, scan_idx_c, 2);
1264 } else if (blk_idx == 3) {
1265 if (SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], xBase, yBase))
1266 hls_residual_coding(s, xBase, yBase, log2_trafo_size, scan_idx_c, 1);
1267 if (SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], xBase, yBase))
1268 hls_residual_coding(s, xBase, yBase, log2_trafo_size, scan_idx_c, 2);
1273 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1275 int cb_size = 1 << log2_cb_size;
1276 int log2_min_pu_size = s->sps->log2_min_pu_size;
1278 int min_pu_width = s->sps->min_pu_width;
1279 int x_end = FFMIN(x0 + cb_size, s->sps->width);
1280 int y_end = FFMIN(y0 + cb_size, s->sps->height);
1283 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1284 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1285 s->is_pcm[i + j * min_pu_width] = 2;
1288 static void hls_transform_tree(HEVCContext *s, int x0, int y0,
1289 int xBase, int yBase, int cb_xBase, int cb_yBase,
1290 int log2_cb_size, int log2_trafo_size,
1291 int trafo_depth, int blk_idx)
1293 HEVCLocalContext *lc = &s->HEVClc;
1294 uint8_t split_transform_flag;
1296 if (trafo_depth > 0 && log2_trafo_size == 2) {
1297 SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], x0, y0) =
1298 SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth - 1], xBase, yBase);
1299 SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], x0, y0) =
1300 SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth - 1], xBase, yBase);
1302 SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], x0, y0) =
1303 SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], x0, y0) = 0;
1306 if (lc->cu.intra_split_flag) {
1307 if (trafo_depth == 1)
1308 lc->tu.cur_intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1310 lc->tu.cur_intra_pred_mode = lc->pu.intra_pred_mode[0];
1313 lc->tt.cbf_luma = 1;
1315 lc->tt.inter_split_flag = s->sps->max_transform_hierarchy_depth_inter == 0 &&
1316 lc->cu.pred_mode == MODE_INTER &&
1317 lc->cu.part_mode != PART_2Nx2N &&
1320 if (log2_trafo_size <= s->sps->log2_max_trafo_size &&
1321 log2_trafo_size > s->sps->log2_min_tb_size &&
1322 trafo_depth < lc->cu.max_trafo_depth &&
1323 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1324 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1326 split_transform_flag = log2_trafo_size > s->sps->log2_max_trafo_size ||
1327 (lc->cu.intra_split_flag && trafo_depth == 0) ||
1328 lc->tt.inter_split_flag;
1331 if (log2_trafo_size > 2) {
1332 if (trafo_depth == 0 ||
1333 SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth - 1], xBase, yBase)) {
1334 SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], x0, y0) =
1335 ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1338 if (trafo_depth == 0 ||
1339 SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth - 1], xBase, yBase)) {
1340 SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], x0, y0) =
1341 ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1345 if (split_transform_flag) {
1346 int x1 = x0 + ((1 << log2_trafo_size) >> 1);
1347 int y1 = y0 + ((1 << log2_trafo_size) >> 1);
1349 hls_transform_tree(s, x0, y0, x0, y0, cb_xBase, cb_yBase, log2_cb_size,
1350 log2_trafo_size - 1, trafo_depth + 1, 0);
1351 hls_transform_tree(s, x1, y0, x0, y0, cb_xBase, cb_yBase, log2_cb_size,
1352 log2_trafo_size - 1, trafo_depth + 1, 1);
1353 hls_transform_tree(s, x0, y1, x0, y0, cb_xBase, cb_yBase, log2_cb_size,
1354 log2_trafo_size - 1, trafo_depth + 1, 2);
1355 hls_transform_tree(s, x1, y1, x0, y0, cb_xBase, cb_yBase, log2_cb_size,
1356 log2_trafo_size - 1, trafo_depth + 1, 3);
1358 int min_tu_size = 1 << s->sps->log2_min_tb_size;
1359 int log2_min_tu_size = s->sps->log2_min_tb_size;
1360 int min_tu_width = s->sps->min_tb_width;
1362 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1363 SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], x0, y0) ||
1364 SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], x0, y0)) {
1365 lc->tt.cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1368 hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1369 log2_cb_size, log2_trafo_size, trafo_depth, blk_idx);
1371 // TODO: store cbf_luma somewhere else
1372 if (lc->tt.cbf_luma) {
1374 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1375 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1376 int x_tu = (x0 + j) >> log2_min_tu_size;
1377 int y_tu = (y0 + i) >> log2_min_tu_size;
1378 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1381 if (!s->sh.disable_deblocking_filter_flag) {
1382 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size,
1383 lc->slice_or_tiles_up_boundary,
1384 lc->slice_or_tiles_left_boundary);
1385 if (s->pps->transquant_bypass_enable_flag &&
1386 lc->cu.cu_transquant_bypass_flag)
1387 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1392 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1394 //TODO: non-4:2:0 support
1395 HEVCLocalContext *lc = &s->HEVClc;
1397 int cb_size = 1 << log2_cb_size;
1398 int stride0 = s->frame->linesize[0];
1399 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->sps->pixel_shift)];
1400 int stride1 = s->frame->linesize[1];
1401 uint8_t *dst1 = &s->frame->data[1][(y0 >> s->sps->vshift[1]) * stride1 + ((x0 >> s->sps->hshift[1]) << s->sps->pixel_shift)];
1402 int stride2 = s->frame->linesize[2];
1403 uint8_t *dst2 = &s->frame->data[2][(y0 >> s->sps->vshift[2]) * stride2 + ((x0 >> s->sps->hshift[2]) << s->sps->pixel_shift)];
1405 int length = cb_size * cb_size * s->sps->pcm.bit_depth + ((cb_size * cb_size) >> 1) * s->sps->pcm.bit_depth;
1406 const uint8_t *pcm = skip_bytes(&s->HEVClc.cc, (length + 7) >> 3);
1409 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size,
1410 lc->slice_or_tiles_up_boundary,
1411 lc->slice_or_tiles_left_boundary);
1413 ret = init_get_bits(&gb, pcm, length);
1417 s->hevcdsp.put_pcm(dst0, stride0, cb_size, &gb, s->sps->pcm.bit_depth);
1418 s->hevcdsp.put_pcm(dst1, stride1, cb_size / 2, &gb, s->sps->pcm.bit_depth);
1419 s->hevcdsp.put_pcm(dst2, stride2, cb_size / 2, &gb, s->sps->pcm.bit_depth);
1423 static void hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1425 HEVCLocalContext *lc = &s->HEVClc;
1426 int x = ff_hevc_abs_mvd_greater0_flag_decode(s);
1427 int y = ff_hevc_abs_mvd_greater0_flag_decode(s);
1430 x += ff_hevc_abs_mvd_greater1_flag_decode(s);
1432 y += ff_hevc_abs_mvd_greater1_flag_decode(s);
1435 case 2: lc->pu.mvd.x = ff_hevc_mvd_decode(s); break;
1436 case 1: lc->pu.mvd.x = ff_hevc_mvd_sign_flag_decode(s); break;
1437 case 0: lc->pu.mvd.x = 0; break;
1441 case 2: lc->pu.mvd.y = ff_hevc_mvd_decode(s); break;
1442 case 1: lc->pu.mvd.y = ff_hevc_mvd_sign_flag_decode(s); break;
1443 case 0: lc->pu.mvd.y = 0; break;
1448 * 8.5.3.2.2.1 Luma sample interpolation process
1450 * @param s HEVC decoding context
1451 * @param dst target buffer for block data at block position
1452 * @param dststride stride of the dst buffer
1453 * @param ref reference picture buffer at origin (0, 0)
1454 * @param mv motion vector (relative to block position) to get pixel data from
1455 * @param x_off horizontal position of block from origin (0, 0)
1456 * @param y_off vertical position of block from origin (0, 0)
1457 * @param block_w width of block
1458 * @param block_h height of block
1460 static void luma_mc(HEVCContext *s, int16_t *dst, ptrdiff_t dststride,
1461 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1462 int block_w, int block_h)
1464 HEVCLocalContext *lc = &s->HEVClc;
1465 uint8_t *src = ref->data[0];
1466 ptrdiff_t srcstride = ref->linesize[0];
1467 int pic_width = s->sps->width;
1468 int pic_height = s->sps->height;
1472 int extra_left = ff_hevc_qpel_extra_before[mx];
1473 int extra_top = ff_hevc_qpel_extra_before[my];
1475 x_off += mv->x >> 2;
1476 y_off += mv->y >> 2;
1477 src += y_off * srcstride + (x_off << s->sps->pixel_shift);
1479 if (x_off < extra_left || y_off < extra_top ||
1480 x_off >= pic_width - block_w - ff_hevc_qpel_extra_after[mx] ||
1481 y_off >= pic_height - block_h - ff_hevc_qpel_extra_after[my]) {
1482 int offset = extra_top * srcstride + (extra_left << s->sps->pixel_shift);
1484 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset, srcstride,
1485 block_w + ff_hevc_qpel_extra[mx],
1486 block_h + ff_hevc_qpel_extra[my],
1487 x_off - extra_left, y_off - extra_top,
1488 pic_width, pic_height);
1489 src = lc->edge_emu_buffer + offset;
1491 s->hevcdsp.put_hevc_qpel[my][mx](dst, dststride, src, srcstride, block_w,
1492 block_h, lc->mc_buffer);
1496 * 8.5.3.2.2.2 Chroma sample interpolation process
1498 * @param s HEVC decoding context
1499 * @param dst1 target buffer for block data at block position (U plane)
1500 * @param dst2 target buffer for block data at block position (V plane)
1501 * @param dststride stride of the dst1 and dst2 buffers
1502 * @param ref reference picture buffer at origin (0, 0)
1503 * @param mv motion vector (relative to block position) to get pixel data from
1504 * @param x_off horizontal position of block from origin (0, 0)
1505 * @param y_off vertical position of block from origin (0, 0)
1506 * @param block_w width of block
1507 * @param block_h height of block
1509 static void chroma_mc(HEVCContext *s, int16_t *dst1, int16_t *dst2,
1510 ptrdiff_t dststride, AVFrame *ref, const Mv *mv,
1511 int x_off, int y_off, int block_w, int block_h)
1513 HEVCLocalContext *lc = &s->HEVClc;
1514 uint8_t *src1 = ref->data[1];
1515 uint8_t *src2 = ref->data[2];
1516 ptrdiff_t src1stride = ref->linesize[1];
1517 ptrdiff_t src2stride = ref->linesize[2];
1518 int pic_width = s->sps->width >> 1;
1519 int pic_height = s->sps->height >> 1;
1524 x_off += mv->x >> 3;
1525 y_off += mv->y >> 3;
1526 src1 += y_off * src1stride + (x_off << s->sps->pixel_shift);
1527 src2 += y_off * src2stride + (x_off << s->sps->pixel_shift);
1529 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1530 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1531 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1532 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->sps->pixel_shift));
1533 int offset2 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->sps->pixel_shift));
1535 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1, src1stride,
1536 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1537 x_off - EPEL_EXTRA_BEFORE,
1538 y_off - EPEL_EXTRA_BEFORE,
1539 pic_width, pic_height);
1541 src1 = lc->edge_emu_buffer + offset1;
1542 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst1, dststride, src1, src1stride,
1543 block_w, block_h, mx, my, lc->mc_buffer);
1545 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src2 - offset2, src2stride,
1546 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1547 x_off - EPEL_EXTRA_BEFORE,
1548 y_off - EPEL_EXTRA_BEFORE,
1549 pic_width, pic_height);
1550 src2 = lc->edge_emu_buffer + offset2;
1551 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst2, dststride, src2, src2stride,
1552 block_w, block_h, mx, my,
1555 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst1, dststride, src1, src1stride,
1556 block_w, block_h, mx, my,
1558 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst2, dststride, src2, src2stride,
1559 block_w, block_h, mx, my,
1564 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1565 const Mv *mv, int y0, int height)
1567 int y = (mv->y >> 2) + y0 + height + 9;
1568 ff_thread_await_progress(&ref->tf, y, 0);
1571 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1573 int log2_cb_size, int partIdx)
1575 #define POS(c_idx, x, y) \
1576 &s->frame->data[c_idx][((y) >> s->sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1577 (((x) >> s->sps->hshift[c_idx]) << s->sps->pixel_shift)]
1578 HEVCLocalContext *lc = &s->HEVClc;
1580 struct MvField current_mv = {{{ 0 }}};
1582 int min_pu_width = s->sps->min_pu_width;
1584 MvField *tab_mvf = s->ref->tab_mvf;
1585 RefPicList *refPicList = s->ref->refPicList;
1586 HEVCFrame *ref0, *ref1;
1588 int tmpstride = MAX_PB_SIZE;
1590 uint8_t *dst0 = POS(0, x0, y0);
1591 uint8_t *dst1 = POS(1, x0, y0);
1592 uint8_t *dst2 = POS(2, x0, y0);
1593 int log2_min_cb_size = s->sps->log2_min_cb_size;
1594 int min_cb_width = s->sps->min_cb_width;
1595 int x_cb = x0 >> log2_min_cb_size;
1596 int y_cb = y0 >> log2_min_cb_size;
1602 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
1603 if (s->sh.max_num_merge_cand > 1)
1604 merge_idx = ff_hevc_merge_idx_decode(s);
1608 ff_hevc_luma_mv_merge_mode(s, x0, y0,
1611 log2_cb_size, partIdx,
1612 merge_idx, ¤t_mv);
1613 x_pu = x0 >> s->sps->log2_min_pu_size;
1614 y_pu = y0 >> s->sps->log2_min_pu_size;
1616 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1617 for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1618 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1619 } else { /* MODE_INTER */
1620 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1621 if (lc->pu.merge_flag) {
1622 if (s->sh.max_num_merge_cand > 1)
1623 merge_idx = ff_hevc_merge_idx_decode(s);
1627 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1628 partIdx, merge_idx, ¤t_mv);
1629 x_pu = x0 >> s->sps->log2_min_pu_size;
1630 y_pu = y0 >> s->sps->log2_min_pu_size;
1632 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1633 for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1634 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1636 enum InterPredIdc inter_pred_idc = PRED_L0;
1637 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1638 if (s->sh.slice_type == B_SLICE)
1639 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1641 if (inter_pred_idc != PRED_L1) {
1642 if (s->sh.nb_refs[L0]) {
1643 ref_idx[0] = ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1644 current_mv.ref_idx[0] = ref_idx[0];
1646 current_mv.pred_flag[0] = 1;
1647 hls_mvd_coding(s, x0, y0, 0);
1648 mvp_flag[0] = ff_hevc_mvp_lx_flag_decode(s);
1649 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1650 partIdx, merge_idx, ¤t_mv,
1652 current_mv.mv[0].x += lc->pu.mvd.x;
1653 current_mv.mv[0].y += lc->pu.mvd.y;
1656 if (inter_pred_idc != PRED_L0) {
1657 if (s->sh.nb_refs[L1]) {
1658 ref_idx[1] = ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1659 current_mv.ref_idx[1] = ref_idx[1];
1662 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1666 hls_mvd_coding(s, x0, y0, 1);
1669 current_mv.pred_flag[1] = 1;
1670 mvp_flag[1] = ff_hevc_mvp_lx_flag_decode(s);
1671 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1672 partIdx, merge_idx, ¤t_mv,
1674 current_mv.mv[1].x += lc->pu.mvd.x;
1675 current_mv.mv[1].y += lc->pu.mvd.y;
1678 x_pu = x0 >> s->sps->log2_min_pu_size;
1679 y_pu = y0 >> s->sps->log2_min_pu_size;
1681 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1682 for(j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1683 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1687 if (current_mv.pred_flag[0]) {
1688 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1691 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1693 if (current_mv.pred_flag[1]) {
1694 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1697 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1700 if (current_mv.pred_flag[0] && !current_mv.pred_flag[1]) {
1701 DECLARE_ALIGNED(16, int16_t, tmp[MAX_PB_SIZE * MAX_PB_SIZE]);
1702 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1704 luma_mc(s, tmp, tmpstride, ref0->frame,
1705 ¤t_mv.mv[0], x0, y0, nPbW, nPbH);
1707 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1708 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1709 s->hevcdsp.weighted_pred(s->sh.luma_log2_weight_denom,
1710 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1711 s->sh.luma_offset_l0[current_mv.ref_idx[0]],
1712 dst0, s->frame->linesize[0], tmp,
1713 tmpstride, nPbW, nPbH);
1715 s->hevcdsp.put_unweighted_pred(dst0, s->frame->linesize[0], tmp, tmpstride, nPbW, nPbH);
1717 chroma_mc(s, tmp, tmp2, tmpstride, ref0->frame,
1718 ¤t_mv.mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1720 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1721 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1722 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1723 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0],
1724 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0],
1725 dst1, s->frame->linesize[1], tmp, tmpstride,
1726 nPbW / 2, nPbH / 2);
1727 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1728 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1],
1729 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1],
1730 dst2, s->frame->linesize[2], tmp2, tmpstride,
1731 nPbW / 2, nPbH / 2);
1733 s->hevcdsp.put_unweighted_pred(dst1, s->frame->linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1734 s->hevcdsp.put_unweighted_pred(dst2, s->frame->linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1736 } else if (!current_mv.pred_flag[0] && current_mv.pred_flag[1]) {
1737 DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1738 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1743 luma_mc(s, tmp, tmpstride, ref1->frame,
1744 ¤t_mv.mv[1], x0, y0, nPbW, nPbH);
1746 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1747 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1748 s->hevcdsp.weighted_pred(s->sh.luma_log2_weight_denom,
1749 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1750 s->sh.luma_offset_l1[current_mv.ref_idx[1]],
1751 dst0, s->frame->linesize[0], tmp, tmpstride,
1754 s->hevcdsp.put_unweighted_pred(dst0, s->frame->linesize[0], tmp, tmpstride, nPbW, nPbH);
1757 chroma_mc(s, tmp, tmp2, tmpstride, ref1->frame,
1758 ¤t_mv.mv[1], x0/2, y0/2, nPbW/2, nPbH/2);
1760 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1761 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1762 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1763 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0],
1764 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0],
1765 dst1, s->frame->linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1766 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1767 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1],
1768 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1],
1769 dst2, s->frame->linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1771 s->hevcdsp.put_unweighted_pred(dst1, s->frame->linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1772 s->hevcdsp.put_unweighted_pred(dst2, s->frame->linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1774 } else if (current_mv.pred_flag[0] && current_mv.pred_flag[1]) {
1775 DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1776 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1777 DECLARE_ALIGNED(16, int16_t, tmp3[MAX_PB_SIZE * MAX_PB_SIZE]);
1778 DECLARE_ALIGNED(16, int16_t, tmp4[MAX_PB_SIZE * MAX_PB_SIZE]);
1779 HEVCFrame *ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1780 HEVCFrame *ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1785 luma_mc(s, tmp, tmpstride, ref0->frame,
1786 ¤t_mv.mv[0], x0, y0, nPbW, nPbH);
1787 luma_mc(s, tmp2, tmpstride, ref1->frame,
1788 ¤t_mv.mv[1], x0, y0, nPbW, nPbH);
1790 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1791 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1792 s->hevcdsp.weighted_pred_avg(s->sh.luma_log2_weight_denom,
1793 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1794 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1795 s->sh.luma_offset_l0[current_mv.ref_idx[0]],
1796 s->sh.luma_offset_l1[current_mv.ref_idx[1]],
1797 dst0, s->frame->linesize[0],
1798 tmp, tmp2, tmpstride, nPbW, nPbH);
1800 s->hevcdsp.put_weighted_pred_avg(dst0, s->frame->linesize[0],
1801 tmp, tmp2, tmpstride, nPbW, nPbH);
1804 chroma_mc(s, tmp, tmp2, tmpstride, ref0->frame,
1805 ¤t_mv.mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1806 chroma_mc(s, tmp3, tmp4, tmpstride, ref1->frame,
1807 ¤t_mv.mv[1], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1809 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1810 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1811 s->hevcdsp.weighted_pred_avg(s->sh.chroma_log2_weight_denom,
1812 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0],
1813 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0],
1814 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0],
1815 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0],
1816 dst1, s->frame->linesize[1], tmp, tmp3,
1817 tmpstride, nPbW / 2, nPbH / 2);
1818 s->hevcdsp.weighted_pred_avg(s->sh.chroma_log2_weight_denom,
1819 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1],
1820 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1],
1821 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1],
1822 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1],
1823 dst2, s->frame->linesize[2], tmp2, tmp4,
1824 tmpstride, nPbW / 2, nPbH / 2);
1826 s->hevcdsp.put_weighted_pred_avg(dst1, s->frame->linesize[1], tmp, tmp3, tmpstride, nPbW/2, nPbH/2);
1827 s->hevcdsp.put_weighted_pred_avg(dst2, s->frame->linesize[2], tmp2, tmp4, tmpstride, nPbW/2, nPbH/2);
1835 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1836 int prev_intra_luma_pred_flag)
1838 HEVCLocalContext *lc = &s->HEVClc;
1839 int x_pu = x0 >> s->sps->log2_min_pu_size;
1840 int y_pu = y0 >> s->sps->log2_min_pu_size;
1841 int min_pu_width = s->sps->min_pu_width;
1842 int size_in_pus = pu_size >> s->sps->log2_min_pu_size;
1843 int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1);
1844 int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1);
1846 int cand_up = (lc->ctb_up_flag || y0b) ?
1847 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1848 int cand_left = (lc->ctb_left_flag || x0b) ?
1849 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1851 int y_ctb = (y0 >> (s->sps->log2_ctb_size)) << (s->sps->log2_ctb_size);
1853 MvField *tab_mvf = s->ref->tab_mvf;
1854 int intra_pred_mode;
1858 // intra_pred_mode prediction does not cross vertical CTB boundaries
1859 if ((y0 - 1) < y_ctb)
1862 if (cand_left == cand_up) {
1863 if (cand_left < 2) {
1864 candidate[0] = INTRA_PLANAR;
1865 candidate[1] = INTRA_DC;
1866 candidate[2] = INTRA_ANGULAR_26;
1868 candidate[0] = cand_left;
1869 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1870 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1873 candidate[0] = cand_left;
1874 candidate[1] = cand_up;
1875 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1876 candidate[2] = INTRA_PLANAR;
1877 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1878 candidate[2] = INTRA_DC;
1880 candidate[2] = INTRA_ANGULAR_26;
1884 if (prev_intra_luma_pred_flag) {
1885 intra_pred_mode = candidate[lc->pu.mpm_idx];
1887 if (candidate[0] > candidate[1])
1888 FFSWAP(uint8_t, candidate[0], candidate[1]);
1889 if (candidate[0] > candidate[2])
1890 FFSWAP(uint8_t, candidate[0], candidate[2]);
1891 if (candidate[1] > candidate[2])
1892 FFSWAP(uint8_t, candidate[1], candidate[2]);
1894 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1895 for (i = 0; i < 3; i++)
1896 if (intra_pred_mode >= candidate[i])
1900 /* write the intra prediction units into the mv array */
1903 for (i = 0; i < size_in_pus; i++) {
1904 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1905 intra_pred_mode, size_in_pus);
1907 for (j = 0; j < size_in_pus; j++) {
1908 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].is_intra = 1;
1909 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[0] = 0;
1910 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[1] = 0;
1911 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[0] = 0;
1912 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[1] = 0;
1913 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].x = 0;
1914 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].y = 0;
1915 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].x = 0;
1916 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].y = 0;
1920 return intra_pred_mode;
1923 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1924 int log2_cb_size, int ct_depth)
1926 int length = (1 << log2_cb_size) >> s->sps->log2_min_cb_size;
1927 int x_cb = x0 >> s->sps->log2_min_cb_size;
1928 int y_cb = y0 >> s->sps->log2_min_cb_size;
1931 for (y = 0; y < length; y++)
1932 memset(&s->tab_ct_depth[(y_cb + y) * s->sps->min_cb_width + x_cb],
1936 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1939 HEVCLocalContext *lc = &s->HEVClc;
1940 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1941 uint8_t prev_intra_luma_pred_flag[4];
1942 int split = lc->cu.part_mode == PART_NxN;
1943 int pb_size = (1 << log2_cb_size) >> split;
1944 int side = split + 1;
1948 for (i = 0; i < side; i++)
1949 for (j = 0; j < side; j++)
1950 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1952 for (i = 0; i < side; i++) {
1953 for (j = 0; j < side; j++) {
1954 if (prev_intra_luma_pred_flag[2 * i + j])
1955 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
1957 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
1959 lc->pu.intra_pred_mode[2 * i + j] =
1960 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1961 prev_intra_luma_pred_flag[2 * i + j]);
1965 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1966 if (chroma_mode != 4) {
1967 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1968 lc->pu.intra_pred_mode_c = 34;
1970 lc->pu.intra_pred_mode_c = intra_chroma_table[chroma_mode];
1972 lc->pu.intra_pred_mode_c = lc->pu.intra_pred_mode[0];
1976 static void intra_prediction_unit_default_value(HEVCContext *s,
1980 HEVCLocalContext *lc = &s->HEVClc;
1981 int pb_size = 1 << log2_cb_size;
1982 int size_in_pus = pb_size >> s->sps->log2_min_pu_size;
1983 int min_pu_width = s->sps->min_pu_width;
1984 MvField *tab_mvf = s->ref->tab_mvf;
1985 int x_pu = x0 >> s->sps->log2_min_pu_size;
1986 int y_pu = y0 >> s->sps->log2_min_pu_size;
1989 if (size_in_pus == 0)
1991 for (j = 0; j < size_in_pus; j++) {
1992 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
1993 for (k = 0; k < size_in_pus; k++)
1994 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].is_intra = lc->cu.pred_mode == MODE_INTRA;
1998 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
2000 int cb_size = 1 << log2_cb_size;
2001 HEVCLocalContext *lc = &s->HEVClc;
2002 int log2_min_cb_size = s->sps->log2_min_cb_size;
2003 int length = cb_size >> log2_min_cb_size;
2004 int min_cb_width = s->sps->min_cb_width;
2005 int x_cb = x0 >> log2_min_cb_size;
2006 int y_cb = y0 >> log2_min_cb_size;
2011 lc->cu.rqt_root_cbf = 1;
2012 lc->cu.pred_mode = MODE_INTRA;
2013 lc->cu.part_mode = PART_2Nx2N;
2014 lc->cu.intra_split_flag = 0;
2015 lc->cu.pcm_flag = 0;
2017 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
2018 for (x = 0; x < 4; x++)
2019 lc->pu.intra_pred_mode[x] = 1;
2020 if (s->pps->transquant_bypass_enable_flag) {
2021 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
2022 if (lc->cu.cu_transquant_bypass_flag)
2023 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2025 lc->cu.cu_transquant_bypass_flag = 0;
2027 if (s->sh.slice_type != I_SLICE) {
2028 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
2030 lc->cu.pred_mode = MODE_SKIP;
2031 x = y_cb * min_cb_width + x_cb;
2032 for (y = 0; y < length; y++) {
2033 memset(&s->skip_flag[x], skip_flag, length);
2036 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2039 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2040 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0);
2041 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2043 if (!s->sh.disable_deblocking_filter_flag)
2044 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size,
2045 lc->slice_or_tiles_up_boundary,
2046 lc->slice_or_tiles_left_boundary);
2048 if (s->sh.slice_type != I_SLICE)
2049 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2050 if (lc->cu.pred_mode != MODE_INTRA ||
2051 log2_cb_size == s->sps->log2_min_cb_size) {
2052 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2053 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2054 lc->cu.pred_mode == MODE_INTRA;
2057 if (lc->cu.pred_mode == MODE_INTRA) {
2058 if (lc->cu.part_mode == PART_2Nx2N && s->sps->pcm_enabled_flag &&
2059 log2_cb_size >= s->sps->pcm.log2_min_pcm_cb_size &&
2060 log2_cb_size <= s->sps->pcm.log2_max_pcm_cb_size) {
2061 lc->cu.pcm_flag = ff_hevc_pcm_flag_decode(s);
2063 if (lc->cu.pcm_flag) {
2065 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2066 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2067 if (s->sps->pcm.loop_filter_disable_flag)
2068 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2073 intra_prediction_unit(s, x0, y0, log2_cb_size);
2076 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2077 switch (lc->cu.part_mode) {
2079 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0);
2082 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0);
2083 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1);
2086 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0);
2087 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1);
2090 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0);
2091 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1);
2094 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0);
2095 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1);
2098 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0);
2099 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1);
2102 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0);
2103 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1);
2106 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0);
2107 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1);
2108 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2);
2109 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3);
2114 if (!lc->cu.pcm_flag) {
2115 if (lc->cu.pred_mode != MODE_INTRA &&
2116 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2117 lc->cu.rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2119 if (lc->cu.rqt_root_cbf) {
2120 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2121 s->sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2122 s->sps->max_transform_hierarchy_depth_inter;
2123 hls_transform_tree(s, x0, y0, x0, y0, x0, y0, log2_cb_size,
2124 log2_cb_size, 0, 0);
2126 if (!s->sh.disable_deblocking_filter_flag)
2127 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size,
2128 lc->slice_or_tiles_up_boundary,
2129 lc->slice_or_tiles_left_boundary);
2134 if (s->pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2135 ff_hevc_set_qPy(s, x0, y0, x0, y0, log2_cb_size);
2137 x = y_cb * min_cb_width + x_cb;
2138 for (y = 0; y < length; y++) {
2139 memset(&s->qp_y_tab[x], lc->qp_y, length);
2143 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct.depth);
2148 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2149 int log2_cb_size, int cb_depth)
2151 HEVCLocalContext *lc = &s->HEVClc;
2152 const int cb_size = 1 << log2_cb_size;
2154 lc->ct.depth = cb_depth;
2155 if (x0 + cb_size <= s->sps->width &&
2156 y0 + cb_size <= s->sps->height &&
2157 log2_cb_size > s->sps->log2_min_cb_size) {
2158 SAMPLE(s->split_cu_flag, x0, y0) =
2159 ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2161 SAMPLE(s->split_cu_flag, x0, y0) =
2162 (log2_cb_size > s->sps->log2_min_cb_size);
2164 if (s->pps->cu_qp_delta_enabled_flag &&
2165 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth) {
2166 lc->tu.is_cu_qp_delta_coded = 0;
2167 lc->tu.cu_qp_delta = 0;
2170 if (SAMPLE(s->split_cu_flag, x0, y0)) {
2171 const int cb_size_split = cb_size >> 1;
2172 const int x1 = x0 + cb_size_split;
2173 const int y1 = y0 + cb_size_split;
2178 #define SUBDIVIDE(x, y) \
2180 if (x < s->sps->width && y < s->sps->height) { \
2181 int ret = hls_coding_quadtree(s, x, y, log2_cb_size, cb_depth);\
2192 int ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2200 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2203 HEVCLocalContext *lc = &s->HEVClc;
2204 int ctb_size = 1 << s->sps->log2_ctb_size;
2205 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2206 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2208 int tile_left_boundary, tile_up_boundary;
2209 int slice_left_boundary, slice_up_boundary;
2211 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2213 if (s->pps->entropy_coding_sync_enabled_flag) {
2214 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2215 lc->first_qp_group = 1;
2216 lc->end_of_tiles_x = s->sps->width;
2217 } else if (s->pps->tiles_enabled_flag) {
2218 if (ctb_addr_ts && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1]) {
2219 int idxX = s->pps->col_idxX[x_ctb >> s->sps->log2_ctb_size];
2220 lc->start_of_tiles_x = x_ctb;
2221 lc->end_of_tiles_x = x_ctb + (s->pps->column_width[idxX] << s->sps->log2_ctb_size);
2222 lc->first_qp_group = 1;
2225 lc->end_of_tiles_x = s->sps->width;
2228 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->sps->height);
2230 if (s->pps->tiles_enabled_flag) {
2231 tile_left_boundary = x_ctb > 0 &&
2232 s->pps->tile_id[ctb_addr_ts] == s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs - 1]];
2233 slice_left_boundary = x_ctb > 0 &&
2234 s->tab_slice_address[ctb_addr_rs] == s->tab_slice_address[ctb_addr_rs - 1];
2235 tile_up_boundary = y_ctb > 0 &&
2236 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]];
2237 slice_up_boundary = y_ctb > 0 &&
2238 s->tab_slice_address[ctb_addr_rs] == s->tab_slice_address[ctb_addr_rs - s->sps->ctb_width];
2240 tile_left_boundary =
2241 tile_up_boundary = 1;
2242 slice_left_boundary = ctb_addr_in_slice > 0;
2243 slice_up_boundary = ctb_addr_in_slice >= s->sps->ctb_width;
2245 lc->slice_or_tiles_left_boundary = (!slice_left_boundary) + (!tile_left_boundary << 1);
2246 lc->slice_or_tiles_up_boundary = (!slice_up_boundary + (!tile_up_boundary << 1));
2247 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && tile_left_boundary);
2248 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->sps->ctb_width) && tile_up_boundary);
2249 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]]));
2250 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]]));
2253 static int hls_slice_data(HEVCContext *s)
2255 int ctb_size = 1 << s->sps->log2_ctb_size;
2259 int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2262 while (more_data && ctb_addr_ts < s->sps->ctb_size) {
2263 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2265 x_ctb = (ctb_addr_rs % ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2266 y_ctb = (ctb_addr_rs / ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2267 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2269 ff_hevc_cabac_init(s, ctb_addr_ts);
2271 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2273 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2274 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2275 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2277 ret = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2280 more_data = !ff_hevc_end_of_slice_flag_decode(s);
2283 ff_hevc_save_states(s, ctb_addr_ts);
2284 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2287 if (x_ctb + ctb_size >= s->sps->width &&
2288 y_ctb + ctb_size >= s->sps->height)
2289 ff_hevc_hls_filter(s, x_ctb, y_ctb);
2295 * @return AVERROR_INVALIDDATA if the packet is not a valid NAL unit,
2296 * 0 if the unit should be skipped, 1 otherwise
2298 static int hls_nal_unit(HEVCContext *s)
2300 GetBitContext *gb = &s->HEVClc.gb;
2303 if (get_bits1(gb) != 0)
2304 return AVERROR_INVALIDDATA;
2306 s->nal_unit_type = get_bits(gb, 6);
2308 nuh_layer_id = get_bits(gb, 6);
2309 s->temporal_id = get_bits(gb, 3) - 1;
2310 if (s->temporal_id < 0)
2311 return AVERROR_INVALIDDATA;
2313 av_log(s->avctx, AV_LOG_DEBUG,
2314 "nal_unit_type: %d, nuh_layer_id: %dtemporal_id: %d\n",
2315 s->nal_unit_type, nuh_layer_id, s->temporal_id);
2317 return nuh_layer_id == 0;
2320 static void restore_tqb_pixels(HEVCContext *s)
2322 int min_pu_size = 1 << s->sps->log2_min_pu_size;
2325 for (c_idx = 0; c_idx < 3; c_idx++) {
2326 ptrdiff_t stride = s->frame->linesize[c_idx];
2327 int hshift = s->sps->hshift[c_idx];
2328 int vshift = s->sps->vshift[c_idx];
2329 for (y = 0; y < s->sps->min_pu_height; y++) {
2330 for (x = 0; x < s->sps->min_pu_width; x++) {
2331 if (s->is_pcm[y * s->sps->min_pu_width + x]) {
2333 int len = min_pu_size >> hshift;
2334 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)];
2335 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)];
2336 for (n = 0; n < (min_pu_size >> vshift); n++) {
2337 memcpy(dst, src, len);
2347 static int hevc_frame_start(HEVCContext *s)
2349 HEVCLocalContext *lc = &s->HEVClc;
2352 memset(s->horizontal_bs, 0, 2 * s->bs_width * (s->bs_height + 1));
2353 memset(s->vertical_bs, 0, 2 * s->bs_width * (s->bs_height + 1));
2354 memset(s->cbf_luma, 0, s->sps->min_tb_width * s->sps->min_tb_height);
2355 memset(s->is_pcm, 0, s->sps->min_pu_width * s->sps->min_pu_height);
2357 lc->start_of_tiles_x = 0;
2360 if (s->pps->tiles_enabled_flag)
2361 lc->end_of_tiles_x = s->pps->column_width[0] << s->sps->log2_ctb_size;
2363 ret = ff_hevc_set_new_ref(s, s->sps->sao_enabled ? &s->sao_frame : &s->frame,
2368 av_fast_malloc(&lc->edge_emu_buffer, &lc->edge_emu_buffer_size,
2369 (MAX_PB_SIZE + 7) * s->ref->frame->linesize[0]);
2370 if (!lc->edge_emu_buffer) {
2371 ret = AVERROR(ENOMEM);
2375 ret = ff_hevc_frame_rps(s);
2377 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2381 av_frame_unref(s->output_frame);
2382 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2386 ff_thread_finish_setup(s->avctx);
2392 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2397 static int decode_nal_unit(HEVCContext *s, const uint8_t *nal, int length)
2399 HEVCLocalContext *lc = &s->HEVClc;
2400 GetBitContext *gb = &lc->gb;
2401 int ctb_addr_ts, ret;
2403 ret = init_get_bits8(gb, nal, length);
2407 ret = hls_nal_unit(s);
2409 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit %d, skipping.\n",
2411 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2417 switch (s->nal_unit_type) {
2419 ret = ff_hevc_decode_nal_vps(s);
2424 ret = ff_hevc_decode_nal_sps(s);
2429 ret = ff_hevc_decode_nal_pps(s);
2433 case NAL_SEI_PREFIX:
2434 case NAL_SEI_SUFFIX:
2435 ret = ff_hevc_decode_nal_sei(s);
2446 case NAL_BLA_W_RADL:
2448 case NAL_IDR_W_RADL:
2455 ret = hls_slice_header(s);
2459 if (s->max_ra == INT_MAX) {
2460 if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
2464 s->max_ra = INT_MIN;
2468 if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
2469 s->poc <= s->max_ra) {
2473 if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
2474 s->max_ra = INT_MIN;
2477 if (s->sh.first_slice_in_pic_flag) {
2478 ret = hevc_frame_start(s);
2481 } else if (!s->ref) {
2482 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2483 return AVERROR_INVALIDDATA;
2486 if (!s->sh.dependent_slice_segment_flag &&
2487 s->sh.slice_type != I_SLICE) {
2488 ret = ff_hevc_slice_rpl(s);
2490 av_log(s->avctx, AV_LOG_WARNING,
2491 "Error constructing the reference lists for the current slice.\n");
2492 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2497 ctb_addr_ts = hls_slice_data(s);
2498 if (ctb_addr_ts >= (s->sps->ctb_width * s->sps->ctb_height)) {
2500 if ((s->pps->transquant_bypass_enable_flag ||
2501 (s->sps->pcm.loop_filter_disable_flag && s->sps->pcm_enabled_flag)) &&
2502 s->sps->sao_enabled)
2503 restore_tqb_pixels(s);
2506 if (ctb_addr_ts < 0)
2511 s->seq_decode = (s->seq_decode + 1) & 0xff;
2512 s->max_ra = INT_MAX;
2518 av_log(s->avctx, AV_LOG_INFO,
2519 "Skipping NAL unit %d\n", s->nal_unit_type);
2525 /* FIXME: This is adapted from ff_h264_decode_nal, avoiding duplication
2526 * between these functions would be nice. */
2527 static int extract_rbsp(const uint8_t *src, int length,
2533 #define STARTCODE_TEST \
2534 if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \
2535 if (src[i + 2] != 3) { \
2536 /* startcode, so we must be past the end */ \
2541 #if HAVE_FAST_UNALIGNED
2542 #define FIND_FIRST_ZERO \
2543 if (i > 0 && !src[i]) \
2548 for (i = 0; i + 1 < length; i += 9) {
2549 if (!((~AV_RN64A(src + i) &
2550 (AV_RN64A(src + i) - 0x0100010001000101ULL)) &
2551 0x8000800080008080ULL))
2558 for (i = 0; i + 1 < length; i += 5) {
2559 if (!((~AV_RN32A(src + i) &
2560 (AV_RN32A(src + i) - 0x01000101U)) &
2567 #endif /* HAVE_FAST_64BIT */
2569 for (i = 0; i + 1 < length; i += 2) {
2572 if (i > 0 && src[i - 1] == 0)
2576 #endif /* HAVE_FAST_UNALIGNED */
2578 if (i >= length - 1) { // no escaped 0
2584 av_fast_malloc(&nal->rbsp_buffer, &nal->rbsp_buffer_size,
2585 length + FF_INPUT_BUFFER_PADDING_SIZE);
2586 if (!nal->rbsp_buffer)
2587 return AVERROR(ENOMEM);
2589 dst = nal->rbsp_buffer;
2591 memcpy(dst, src, i);
2593 while (si + 2 < length) {
2594 // remove escapes (very rare 1:2^22)
2595 if (src[si + 2] > 3) {
2596 dst[di++] = src[si++];
2597 dst[di++] = src[si++];
2598 } else if (src[si] == 0 && src[si + 1] == 0) {
2599 if (src[si + 2] == 3) { // escape
2605 } else // next start code
2609 dst[di++] = src[si++];
2612 dst[di++] = src[si++];
2615 memset(dst + di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2622 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2624 int i, consumed, ret = 0;
2629 /* split the input packet into NAL units, so we know the upper bound on the
2630 * number of slices in the frame */
2632 while (length >= 4) {
2634 int extract_length = 0;
2638 for (i = 0; i < s->nal_length_size; i++)
2639 extract_length = (extract_length << 8) | buf[i];
2640 buf += s->nal_length_size;
2641 length -= s->nal_length_size;
2643 if (extract_length > length) {
2644 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit size.\n");
2645 ret = AVERROR_INVALIDDATA;
2654 if (buf[0] != 0 || buf[1] != 0 || buf[2] != 1) {
2655 ret = AVERROR_INVALIDDATA;
2661 extract_length = length;
2664 if (s->nals_allocated < s->nb_nals + 1) {
2665 int new_size = s->nals_allocated + 1;
2666 HEVCNAL *tmp = av_realloc_array(s->nals, new_size, sizeof(*tmp));
2668 ret = AVERROR(ENOMEM);
2672 memset(s->nals + s->nals_allocated, 0,
2673 (new_size - s->nals_allocated) * sizeof(*tmp));
2674 s->nals_allocated = new_size;
2676 nal = &s->nals[s->nb_nals++];
2678 consumed = extract_rbsp(buf, extract_length, nal);
2684 ret = init_get_bits8(&s->HEVClc.gb, nal->data, nal->size);
2689 if (s->nal_unit_type == NAL_EOB_NUT ||
2690 s->nal_unit_type == NAL_EOS_NUT)
2697 /* parse the NAL units */
2698 for (i = 0; i < s->nb_nals; i++) {
2699 int ret = decode_nal_unit(s, s->nals[i].data, s->nals[i].size);
2701 av_log(s->avctx, AV_LOG_WARNING,
2702 "Error parsing NAL unit #%d.\n", i);
2703 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2710 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2715 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2718 for (i = 0; i < 16; i++)
2719 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
2722 static int verify_md5(HEVCContext *s, AVFrame *frame)
2724 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
2725 int pixel_shift = desc->comp[0].depth_minus1 > 7;
2729 return AVERROR(EINVAL);
2731 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
2734 /* the checksums are LE, so we have to byteswap for >8bpp formats
2737 if (pixel_shift && !s->checksum_buf) {
2738 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
2739 FFMAX3(frame->linesize[0], frame->linesize[1],
2740 frame->linesize[2]));
2741 if (!s->checksum_buf)
2742 return AVERROR(ENOMEM);
2746 for (i = 0; frame->data[i]; i++) {
2747 int width = s->avctx->coded_width;
2748 int height = s->avctx->coded_height;
2749 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
2750 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
2753 av_md5_init(s->md5_ctx);
2754 for (j = 0; j < h; j++) {
2755 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
2758 s->dsp.bswap16_buf((uint16_t*)s->checksum_buf,
2759 (const uint16_t*)src, w);
2760 src = s->checksum_buf;
2763 av_md5_update(s->md5_ctx, src, w << pixel_shift);
2765 av_md5_final(s->md5_ctx, md5);
2767 if (!memcmp(md5, s->md5[i], 16)) {
2768 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
2769 print_md5(s->avctx, AV_LOG_DEBUG, md5);
2770 av_log (s->avctx, AV_LOG_DEBUG, "; ");
2772 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
2773 print_md5(s->avctx, AV_LOG_ERROR, md5);
2774 av_log (s->avctx, AV_LOG_ERROR, " != ");
2775 print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
2776 av_log (s->avctx, AV_LOG_ERROR, "\n");
2777 return AVERROR_INVALIDDATA;
2781 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2786 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
2790 HEVCContext *s = avctx->priv_data;
2793 ret = ff_hevc_output_frame(s, data, 1);
2802 ret = decode_nal_units(s, avpkt->data, avpkt->size);
2806 /* verify the SEI checksum */
2807 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
2809 ret = verify_md5(s, s->ref->frame);
2810 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
2811 ff_hevc_unref_frame(s, s->ref, ~0);
2817 if (s->is_decoded) {
2818 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
2822 if (s->output_frame->buf[0]) {
2823 av_frame_move_ref(data, s->output_frame);
2830 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
2832 int ret = ff_thread_ref_frame(&dst->tf, &src->tf);
2836 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
2837 if (!dst->tab_mvf_buf)
2839 dst->tab_mvf = src->tab_mvf;
2841 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
2842 if (!dst->rpl_tab_buf)
2844 dst->rpl_tab = src->rpl_tab;
2846 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
2850 dst->poc = src->poc;
2851 dst->ctb_count = src->ctb_count;
2852 dst->window = src->window;
2853 dst->flags = src->flags;
2854 dst->sequence = src->sequence;
2858 ff_hevc_unref_frame(s, dst, ~0);
2859 return AVERROR(ENOMEM);
2862 static av_cold int hevc_decode_free(AVCodecContext *avctx)
2864 HEVCContext *s = avctx->priv_data;
2865 HEVCLocalContext *lc = &s->HEVClc;
2870 av_freep(&lc->edge_emu_buffer);
2871 av_freep(&s->md5_ctx);
2873 av_frame_free(&s->tmp_frame);
2874 av_frame_free(&s->output_frame);
2876 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2877 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
2878 av_frame_free(&s->DPB[i].frame);
2881 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++)
2882 av_freep(&s->vps_list[i]);
2883 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++)
2884 av_buffer_unref(&s->sps_list[i]);
2885 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
2886 av_buffer_unref(&s->pps_list[i]);
2888 for (i = 0; i < s->nals_allocated; i++)
2889 av_freep(&s->nals[i].rbsp_buffer);
2891 s->nals_allocated = 0;
2896 static av_cold int hevc_init_context(AVCodecContext *avctx)
2898 HEVCContext *s = avctx->priv_data;
2903 s->tmp_frame = av_frame_alloc();
2907 s->output_frame = av_frame_alloc();
2908 if (!s->output_frame)
2911 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2912 s->DPB[i].frame = av_frame_alloc();
2913 if (!s->DPB[i].frame)
2915 s->DPB[i].tf.f = s->DPB[i].frame;
2918 s->max_ra = INT_MAX;
2920 s->md5_ctx = av_md5_alloc();
2924 ff_dsputil_init(&s->dsp, avctx);
2926 s->context_initialized = 1;
2931 hevc_decode_free(avctx);
2932 return AVERROR(ENOMEM);
2935 static int hevc_update_thread_context(AVCodecContext *dst,
2936 const AVCodecContext *src)
2938 HEVCContext *s = dst->priv_data;
2939 HEVCContext *s0 = src->priv_data;
2942 if (!s->context_initialized) {
2943 ret = hevc_init_context(dst);
2948 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2949 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
2950 if (s0->DPB[i].frame->buf[0]) {
2951 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
2957 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++) {
2958 av_buffer_unref(&s->sps_list[i]);
2959 if (s0->sps_list[i]) {
2960 s->sps_list[i] = av_buffer_ref(s0->sps_list[i]);
2961 if (!s->sps_list[i])
2962 return AVERROR(ENOMEM);
2966 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++) {
2967 av_buffer_unref(&s->pps_list[i]);
2968 if (s0->pps_list[i]) {
2969 s->pps_list[i] = av_buffer_ref(s0->pps_list[i]);
2970 if (!s->pps_list[i])
2971 return AVERROR(ENOMEM);
2975 if (s->sps != s0->sps)
2976 ret = set_sps(s, s0->sps);
2978 s->seq_decode = s0->seq_decode;
2979 s->seq_output = s0->seq_output;
2980 s->pocTid0 = s0->pocTid0;
2981 s->max_ra = s0->max_ra;
2983 s->is_nalff = s0->is_nalff;
2984 s->nal_length_size = s0->nal_length_size;
2987 s->seq_decode = (s->seq_decode + 1) & 0xff;
2988 s->max_ra = INT_MAX;
2994 static int hevc_decode_extradata(HEVCContext *s)
2996 AVCodecContext *avctx = s->avctx;
3000 bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
3002 if (avctx->extradata_size > 3 &&
3003 (avctx->extradata[0] || avctx->extradata[1] ||
3004 avctx->extradata[2] > 1)) {
3005 /* It seems the extradata is encoded as hvcC format.
3006 * Temporarily, we support configurationVersion==0 until 14496-15 3rd
3007 * is finalized. When finalized, configurationVersion will be 1 and we
3008 * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
3009 int i, j, num_arrays, nal_len_size;
3013 bytestream2_skip(&gb, 21);
3014 nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
3015 num_arrays = bytestream2_get_byte(&gb);
3017 /* nal units in the hvcC always have length coded with 2 bytes,
3018 * so put a fake nal_length_size = 2 while parsing them */
3019 s->nal_length_size = 2;
3021 /* Decode nal units from hvcC. */
3022 for (i = 0; i < num_arrays; i++) {
3023 int type = bytestream2_get_byte(&gb) & 0x3f;
3024 int cnt = bytestream2_get_be16(&gb);
3026 for (j = 0; j < cnt; j++) {
3027 // +2 for the nal size field
3028 int nalsize = bytestream2_peek_be16(&gb) + 2;
3029 if (bytestream2_get_bytes_left(&gb) < nalsize) {
3030 av_log(s->avctx, AV_LOG_ERROR,
3031 "Invalid NAL unit size in extradata.\n");
3032 return AVERROR_INVALIDDATA;
3035 ret = decode_nal_units(s, gb.buffer, nalsize);
3037 av_log(avctx, AV_LOG_ERROR,
3038 "Decoding nal unit %d %d from hvcC failed\n",
3042 bytestream2_skip(&gb, nalsize);
3046 /* Now store right nal length size, that will be used to parse
3048 s->nal_length_size = nal_len_size;
3051 ret = decode_nal_units(s, avctx->extradata, avctx->extradata_size);
3058 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3060 HEVCContext *s = avctx->priv_data;
3063 ff_init_cabac_states();
3065 avctx->internal->allocate_progress = 1;
3067 ret = hevc_init_context(avctx);
3071 if (avctx->extradata_size > 0 && avctx->extradata) {
3072 ret = hevc_decode_extradata(s);
3074 hevc_decode_free(avctx);
3082 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3084 HEVCContext *s = avctx->priv_data;
3087 memset(s, 0, sizeof(*s));
3089 ret = hevc_init_context(avctx);
3096 static void hevc_decode_flush(AVCodecContext *avctx)
3098 HEVCContext *s = avctx->priv_data;
3099 ff_hevc_flush_dpb(s);
3100 s->max_ra = INT_MAX;
3103 #define OFFSET(x) offsetof(HEVCContext, x)
3104 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3105 static const AVOption options[] = {
3106 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3107 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3111 static const AVClass hevc_decoder_class = {
3112 .class_name = "HEVC decoder",
3113 .item_name = av_default_item_name,
3115 .version = LIBAVUTIL_VERSION_INT,
3118 AVCodec ff_hevc_decoder = {
3120 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3121 .type = AVMEDIA_TYPE_VIDEO,
3122 .id = AV_CODEC_ID_HEVC,
3123 .priv_data_size = sizeof(HEVCContext),
3124 .priv_class = &hevc_decoder_class,
3125 .init = hevc_decode_init,
3126 .close = hevc_decode_free,
3127 .decode = hevc_decode_frame,
3128 .flush = hevc_decode_flush,
3129 .update_thread_context = hevc_update_thread_context,
3130 .init_thread_copy = hevc_init_thread_copy,
3131 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY |
3132 CODEC_CAP_FRAME_THREADS,