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,
1485 srcstride, srcstride,
1486 block_w + ff_hevc_qpel_extra[mx],
1487 block_h + ff_hevc_qpel_extra[my],
1488 x_off - extra_left, y_off - extra_top,
1489 pic_width, pic_height);
1490 src = lc->edge_emu_buffer + offset;
1492 s->hevcdsp.put_hevc_qpel[my][mx](dst, dststride, src, srcstride, block_w,
1493 block_h, lc->mc_buffer);
1497 * 8.5.3.2.2.2 Chroma sample interpolation process
1499 * @param s HEVC decoding context
1500 * @param dst1 target buffer for block data at block position (U plane)
1501 * @param dst2 target buffer for block data at block position (V plane)
1502 * @param dststride stride of the dst1 and dst2 buffers
1503 * @param ref reference picture buffer at origin (0, 0)
1504 * @param mv motion vector (relative to block position) to get pixel data from
1505 * @param x_off horizontal position of block from origin (0, 0)
1506 * @param y_off vertical position of block from origin (0, 0)
1507 * @param block_w width of block
1508 * @param block_h height of block
1510 static void chroma_mc(HEVCContext *s, int16_t *dst1, int16_t *dst2,
1511 ptrdiff_t dststride, AVFrame *ref, const Mv *mv,
1512 int x_off, int y_off, int block_w, int block_h)
1514 HEVCLocalContext *lc = &s->HEVClc;
1515 uint8_t *src1 = ref->data[1];
1516 uint8_t *src2 = ref->data[2];
1517 ptrdiff_t src1stride = ref->linesize[1];
1518 ptrdiff_t src2stride = ref->linesize[2];
1519 int pic_width = s->sps->width >> 1;
1520 int pic_height = s->sps->height >> 1;
1525 x_off += mv->x >> 3;
1526 y_off += mv->y >> 3;
1527 src1 += y_off * src1stride + (x_off << s->sps->pixel_shift);
1528 src2 += y_off * src2stride + (x_off << s->sps->pixel_shift);
1530 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1531 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1532 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1533 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->sps->pixel_shift));
1534 int offset2 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->sps->pixel_shift));
1536 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1537 src1stride, src1stride,
1538 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1539 x_off - EPEL_EXTRA_BEFORE,
1540 y_off - EPEL_EXTRA_BEFORE,
1541 pic_width, pic_height);
1543 src1 = lc->edge_emu_buffer + offset1;
1544 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst1, dststride, src1, src1stride,
1545 block_w, block_h, mx, my, lc->mc_buffer);
1547 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src2 - offset2,
1548 src2stride, src2stride,
1549 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1550 x_off - EPEL_EXTRA_BEFORE,
1551 y_off - EPEL_EXTRA_BEFORE,
1552 pic_width, pic_height);
1553 src2 = lc->edge_emu_buffer + offset2;
1554 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst2, dststride, src2, src2stride,
1555 block_w, block_h, mx, my,
1558 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst1, dststride, src1, src1stride,
1559 block_w, block_h, mx, my,
1561 s->hevcdsp.put_hevc_epel[!!my][!!mx](dst2, dststride, src2, src2stride,
1562 block_w, block_h, mx, my,
1567 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1568 const Mv *mv, int y0, int height)
1570 int y = (mv->y >> 2) + y0 + height + 9;
1571 ff_thread_await_progress(&ref->tf, y, 0);
1574 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1576 int log2_cb_size, int partIdx)
1578 #define POS(c_idx, x, y) \
1579 &s->frame->data[c_idx][((y) >> s->sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1580 (((x) >> s->sps->hshift[c_idx]) << s->sps->pixel_shift)]
1581 HEVCLocalContext *lc = &s->HEVClc;
1583 struct MvField current_mv = {{{ 0 }}};
1585 int min_pu_width = s->sps->min_pu_width;
1587 MvField *tab_mvf = s->ref->tab_mvf;
1588 RefPicList *refPicList = s->ref->refPicList;
1589 HEVCFrame *ref0, *ref1;
1591 int tmpstride = MAX_PB_SIZE;
1593 uint8_t *dst0 = POS(0, x0, y0);
1594 uint8_t *dst1 = POS(1, x0, y0);
1595 uint8_t *dst2 = POS(2, x0, y0);
1596 int log2_min_cb_size = s->sps->log2_min_cb_size;
1597 int min_cb_width = s->sps->min_cb_width;
1598 int x_cb = x0 >> log2_min_cb_size;
1599 int y_cb = y0 >> log2_min_cb_size;
1605 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
1606 if (s->sh.max_num_merge_cand > 1)
1607 merge_idx = ff_hevc_merge_idx_decode(s);
1611 ff_hevc_luma_mv_merge_mode(s, x0, y0,
1614 log2_cb_size, partIdx,
1615 merge_idx, ¤t_mv);
1616 x_pu = x0 >> s->sps->log2_min_pu_size;
1617 y_pu = y0 >> s->sps->log2_min_pu_size;
1619 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1620 for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1621 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1622 } else { /* MODE_INTER */
1623 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1624 if (lc->pu.merge_flag) {
1625 if (s->sh.max_num_merge_cand > 1)
1626 merge_idx = ff_hevc_merge_idx_decode(s);
1630 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1631 partIdx, merge_idx, ¤t_mv);
1632 x_pu = x0 >> s->sps->log2_min_pu_size;
1633 y_pu = y0 >> s->sps->log2_min_pu_size;
1635 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1636 for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1637 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1639 enum InterPredIdc inter_pred_idc = PRED_L0;
1640 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1641 if (s->sh.slice_type == B_SLICE)
1642 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1644 if (inter_pred_idc != PRED_L1) {
1645 if (s->sh.nb_refs[L0]) {
1646 ref_idx[0] = ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1647 current_mv.ref_idx[0] = ref_idx[0];
1649 current_mv.pred_flag[0] = 1;
1650 hls_mvd_coding(s, x0, y0, 0);
1651 mvp_flag[0] = ff_hevc_mvp_lx_flag_decode(s);
1652 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1653 partIdx, merge_idx, ¤t_mv,
1655 current_mv.mv[0].x += lc->pu.mvd.x;
1656 current_mv.mv[0].y += lc->pu.mvd.y;
1659 if (inter_pred_idc != PRED_L0) {
1660 if (s->sh.nb_refs[L1]) {
1661 ref_idx[1] = ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1662 current_mv.ref_idx[1] = ref_idx[1];
1665 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1669 hls_mvd_coding(s, x0, y0, 1);
1672 current_mv.pred_flag[1] = 1;
1673 mvp_flag[1] = ff_hevc_mvp_lx_flag_decode(s);
1674 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1675 partIdx, merge_idx, ¤t_mv,
1677 current_mv.mv[1].x += lc->pu.mvd.x;
1678 current_mv.mv[1].y += lc->pu.mvd.y;
1681 x_pu = x0 >> s->sps->log2_min_pu_size;
1682 y_pu = y0 >> s->sps->log2_min_pu_size;
1684 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1685 for(j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1686 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1690 if (current_mv.pred_flag[0]) {
1691 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1694 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1696 if (current_mv.pred_flag[1]) {
1697 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1700 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1703 if (current_mv.pred_flag[0] && !current_mv.pred_flag[1]) {
1704 DECLARE_ALIGNED(16, int16_t, tmp[MAX_PB_SIZE * MAX_PB_SIZE]);
1705 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1707 luma_mc(s, tmp, tmpstride, ref0->frame,
1708 ¤t_mv.mv[0], x0, y0, nPbW, nPbH);
1710 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1711 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1712 s->hevcdsp.weighted_pred(s->sh.luma_log2_weight_denom,
1713 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1714 s->sh.luma_offset_l0[current_mv.ref_idx[0]],
1715 dst0, s->frame->linesize[0], tmp,
1716 tmpstride, nPbW, nPbH);
1718 s->hevcdsp.put_unweighted_pred(dst0, s->frame->linesize[0], tmp, tmpstride, nPbW, nPbH);
1720 chroma_mc(s, tmp, tmp2, tmpstride, ref0->frame,
1721 ¤t_mv.mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1723 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1724 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1725 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1726 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0],
1727 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0],
1728 dst1, s->frame->linesize[1], tmp, tmpstride,
1729 nPbW / 2, nPbH / 2);
1730 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1731 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1],
1732 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1],
1733 dst2, s->frame->linesize[2], tmp2, tmpstride,
1734 nPbW / 2, nPbH / 2);
1736 s->hevcdsp.put_unweighted_pred(dst1, s->frame->linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1737 s->hevcdsp.put_unweighted_pred(dst2, s->frame->linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1739 } else if (!current_mv.pred_flag[0] && current_mv.pred_flag[1]) {
1740 DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1741 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1746 luma_mc(s, tmp, tmpstride, ref1->frame,
1747 ¤t_mv.mv[1], x0, y0, nPbW, nPbH);
1749 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1750 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1751 s->hevcdsp.weighted_pred(s->sh.luma_log2_weight_denom,
1752 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1753 s->sh.luma_offset_l1[current_mv.ref_idx[1]],
1754 dst0, s->frame->linesize[0], tmp, tmpstride,
1757 s->hevcdsp.put_unweighted_pred(dst0, s->frame->linesize[0], tmp, tmpstride, nPbW, nPbH);
1760 chroma_mc(s, tmp, tmp2, tmpstride, ref1->frame,
1761 ¤t_mv.mv[1], x0/2, y0/2, nPbW/2, nPbH/2);
1763 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1764 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1765 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1766 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0],
1767 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0],
1768 dst1, s->frame->linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1769 s->hevcdsp.weighted_pred(s->sh.chroma_log2_weight_denom,
1770 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1],
1771 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1],
1772 dst2, s->frame->linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1774 s->hevcdsp.put_unweighted_pred(dst1, s->frame->linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1775 s->hevcdsp.put_unweighted_pred(dst2, s->frame->linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1777 } else if (current_mv.pred_flag[0] && current_mv.pred_flag[1]) {
1778 DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1779 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1780 DECLARE_ALIGNED(16, int16_t, tmp3[MAX_PB_SIZE * MAX_PB_SIZE]);
1781 DECLARE_ALIGNED(16, int16_t, tmp4[MAX_PB_SIZE * MAX_PB_SIZE]);
1782 HEVCFrame *ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1783 HEVCFrame *ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1788 luma_mc(s, tmp, tmpstride, ref0->frame,
1789 ¤t_mv.mv[0], x0, y0, nPbW, nPbH);
1790 luma_mc(s, tmp2, tmpstride, ref1->frame,
1791 ¤t_mv.mv[1], x0, y0, nPbW, nPbH);
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_avg(s->sh.luma_log2_weight_denom,
1796 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1797 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1798 s->sh.luma_offset_l0[current_mv.ref_idx[0]],
1799 s->sh.luma_offset_l1[current_mv.ref_idx[1]],
1800 dst0, s->frame->linesize[0],
1801 tmp, tmp2, tmpstride, nPbW, nPbH);
1803 s->hevcdsp.put_weighted_pred_avg(dst0, s->frame->linesize[0],
1804 tmp, tmp2, tmpstride, nPbW, nPbH);
1807 chroma_mc(s, tmp, tmp2, tmpstride, ref0->frame,
1808 ¤t_mv.mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1809 chroma_mc(s, tmp3, tmp4, tmpstride, ref1->frame,
1810 ¤t_mv.mv[1], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1812 if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1813 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1814 s->hevcdsp.weighted_pred_avg(s->sh.chroma_log2_weight_denom,
1815 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0],
1816 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0],
1817 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0],
1818 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0],
1819 dst1, s->frame->linesize[1], tmp, tmp3,
1820 tmpstride, nPbW / 2, nPbH / 2);
1821 s->hevcdsp.weighted_pred_avg(s->sh.chroma_log2_weight_denom,
1822 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1],
1823 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1],
1824 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1],
1825 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1],
1826 dst2, s->frame->linesize[2], tmp2, tmp4,
1827 tmpstride, nPbW / 2, nPbH / 2);
1829 s->hevcdsp.put_weighted_pred_avg(dst1, s->frame->linesize[1], tmp, tmp3, tmpstride, nPbW/2, nPbH/2);
1830 s->hevcdsp.put_weighted_pred_avg(dst2, s->frame->linesize[2], tmp2, tmp4, tmpstride, nPbW/2, nPbH/2);
1838 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1839 int prev_intra_luma_pred_flag)
1841 HEVCLocalContext *lc = &s->HEVClc;
1842 int x_pu = x0 >> s->sps->log2_min_pu_size;
1843 int y_pu = y0 >> s->sps->log2_min_pu_size;
1844 int min_pu_width = s->sps->min_pu_width;
1845 int size_in_pus = pu_size >> s->sps->log2_min_pu_size;
1846 int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1);
1847 int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1);
1849 int cand_up = (lc->ctb_up_flag || y0b) ?
1850 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1851 int cand_left = (lc->ctb_left_flag || x0b) ?
1852 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1854 int y_ctb = (y0 >> (s->sps->log2_ctb_size)) << (s->sps->log2_ctb_size);
1856 MvField *tab_mvf = s->ref->tab_mvf;
1857 int intra_pred_mode;
1861 // intra_pred_mode prediction does not cross vertical CTB boundaries
1862 if ((y0 - 1) < y_ctb)
1865 if (cand_left == cand_up) {
1866 if (cand_left < 2) {
1867 candidate[0] = INTRA_PLANAR;
1868 candidate[1] = INTRA_DC;
1869 candidate[2] = INTRA_ANGULAR_26;
1871 candidate[0] = cand_left;
1872 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1873 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1876 candidate[0] = cand_left;
1877 candidate[1] = cand_up;
1878 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1879 candidate[2] = INTRA_PLANAR;
1880 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1881 candidate[2] = INTRA_DC;
1883 candidate[2] = INTRA_ANGULAR_26;
1887 if (prev_intra_luma_pred_flag) {
1888 intra_pred_mode = candidate[lc->pu.mpm_idx];
1890 if (candidate[0] > candidate[1])
1891 FFSWAP(uint8_t, candidate[0], candidate[1]);
1892 if (candidate[0] > candidate[2])
1893 FFSWAP(uint8_t, candidate[0], candidate[2]);
1894 if (candidate[1] > candidate[2])
1895 FFSWAP(uint8_t, candidate[1], candidate[2]);
1897 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1898 for (i = 0; i < 3; i++)
1899 if (intra_pred_mode >= candidate[i])
1903 /* write the intra prediction units into the mv array */
1906 for (i = 0; i < size_in_pus; i++) {
1907 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1908 intra_pred_mode, size_in_pus);
1910 for (j = 0; j < size_in_pus; j++) {
1911 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].is_intra = 1;
1912 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[0] = 0;
1913 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[1] = 0;
1914 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[0] = 0;
1915 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[1] = 0;
1916 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].x = 0;
1917 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].y = 0;
1918 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].x = 0;
1919 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].y = 0;
1923 return intra_pred_mode;
1926 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1927 int log2_cb_size, int ct_depth)
1929 int length = (1 << log2_cb_size) >> s->sps->log2_min_cb_size;
1930 int x_cb = x0 >> s->sps->log2_min_cb_size;
1931 int y_cb = y0 >> s->sps->log2_min_cb_size;
1934 for (y = 0; y < length; y++)
1935 memset(&s->tab_ct_depth[(y_cb + y) * s->sps->min_cb_width + x_cb],
1939 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1942 HEVCLocalContext *lc = &s->HEVClc;
1943 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1944 uint8_t prev_intra_luma_pred_flag[4];
1945 int split = lc->cu.part_mode == PART_NxN;
1946 int pb_size = (1 << log2_cb_size) >> split;
1947 int side = split + 1;
1951 for (i = 0; i < side; i++)
1952 for (j = 0; j < side; j++)
1953 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1955 for (i = 0; i < side; i++) {
1956 for (j = 0; j < side; j++) {
1957 if (prev_intra_luma_pred_flag[2 * i + j])
1958 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
1960 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
1962 lc->pu.intra_pred_mode[2 * i + j] =
1963 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1964 prev_intra_luma_pred_flag[2 * i + j]);
1968 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1969 if (chroma_mode != 4) {
1970 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1971 lc->pu.intra_pred_mode_c = 34;
1973 lc->pu.intra_pred_mode_c = intra_chroma_table[chroma_mode];
1975 lc->pu.intra_pred_mode_c = lc->pu.intra_pred_mode[0];
1979 static void intra_prediction_unit_default_value(HEVCContext *s,
1983 HEVCLocalContext *lc = &s->HEVClc;
1984 int pb_size = 1 << log2_cb_size;
1985 int size_in_pus = pb_size >> s->sps->log2_min_pu_size;
1986 int min_pu_width = s->sps->min_pu_width;
1987 MvField *tab_mvf = s->ref->tab_mvf;
1988 int x_pu = x0 >> s->sps->log2_min_pu_size;
1989 int y_pu = y0 >> s->sps->log2_min_pu_size;
1992 if (size_in_pus == 0)
1994 for (j = 0; j < size_in_pus; j++) {
1995 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
1996 for (k = 0; k < size_in_pus; k++)
1997 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].is_intra = lc->cu.pred_mode == MODE_INTRA;
2001 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
2003 int cb_size = 1 << log2_cb_size;
2004 HEVCLocalContext *lc = &s->HEVClc;
2005 int log2_min_cb_size = s->sps->log2_min_cb_size;
2006 int length = cb_size >> log2_min_cb_size;
2007 int min_cb_width = s->sps->min_cb_width;
2008 int x_cb = x0 >> log2_min_cb_size;
2009 int y_cb = y0 >> log2_min_cb_size;
2014 lc->cu.rqt_root_cbf = 1;
2015 lc->cu.pred_mode = MODE_INTRA;
2016 lc->cu.part_mode = PART_2Nx2N;
2017 lc->cu.intra_split_flag = 0;
2018 lc->cu.pcm_flag = 0;
2020 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
2021 for (x = 0; x < 4; x++)
2022 lc->pu.intra_pred_mode[x] = 1;
2023 if (s->pps->transquant_bypass_enable_flag) {
2024 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
2025 if (lc->cu.cu_transquant_bypass_flag)
2026 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2028 lc->cu.cu_transquant_bypass_flag = 0;
2030 if (s->sh.slice_type != I_SLICE) {
2031 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
2033 lc->cu.pred_mode = MODE_SKIP;
2034 x = y_cb * min_cb_width + x_cb;
2035 for (y = 0; y < length; y++) {
2036 memset(&s->skip_flag[x], skip_flag, length);
2039 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2042 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2043 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0);
2044 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2046 if (!s->sh.disable_deblocking_filter_flag)
2047 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size,
2048 lc->slice_or_tiles_up_boundary,
2049 lc->slice_or_tiles_left_boundary);
2051 if (s->sh.slice_type != I_SLICE)
2052 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2053 if (lc->cu.pred_mode != MODE_INTRA ||
2054 log2_cb_size == s->sps->log2_min_cb_size) {
2055 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2056 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2057 lc->cu.pred_mode == MODE_INTRA;
2060 if (lc->cu.pred_mode == MODE_INTRA) {
2061 if (lc->cu.part_mode == PART_2Nx2N && s->sps->pcm_enabled_flag &&
2062 log2_cb_size >= s->sps->pcm.log2_min_pcm_cb_size &&
2063 log2_cb_size <= s->sps->pcm.log2_max_pcm_cb_size) {
2064 lc->cu.pcm_flag = ff_hevc_pcm_flag_decode(s);
2066 if (lc->cu.pcm_flag) {
2068 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2069 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2070 if (s->sps->pcm.loop_filter_disable_flag)
2071 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2076 intra_prediction_unit(s, x0, y0, log2_cb_size);
2079 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2080 switch (lc->cu.part_mode) {
2082 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0);
2085 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0);
2086 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1);
2089 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0);
2090 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1);
2093 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0);
2094 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1);
2097 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0);
2098 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1);
2101 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0);
2102 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1);
2105 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0);
2106 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1);
2109 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0);
2110 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1);
2111 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2);
2112 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3);
2117 if (!lc->cu.pcm_flag) {
2118 if (lc->cu.pred_mode != MODE_INTRA &&
2119 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2120 lc->cu.rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2122 if (lc->cu.rqt_root_cbf) {
2123 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2124 s->sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2125 s->sps->max_transform_hierarchy_depth_inter;
2126 hls_transform_tree(s, x0, y0, x0, y0, x0, y0, log2_cb_size,
2127 log2_cb_size, 0, 0);
2129 if (!s->sh.disable_deblocking_filter_flag)
2130 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size,
2131 lc->slice_or_tiles_up_boundary,
2132 lc->slice_or_tiles_left_boundary);
2137 if (s->pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2138 ff_hevc_set_qPy(s, x0, y0, x0, y0, log2_cb_size);
2140 x = y_cb * min_cb_width + x_cb;
2141 for (y = 0; y < length; y++) {
2142 memset(&s->qp_y_tab[x], lc->qp_y, length);
2146 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct.depth);
2151 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2152 int log2_cb_size, int cb_depth)
2154 HEVCLocalContext *lc = &s->HEVClc;
2155 const int cb_size = 1 << log2_cb_size;
2157 lc->ct.depth = cb_depth;
2158 if (x0 + cb_size <= s->sps->width &&
2159 y0 + cb_size <= s->sps->height &&
2160 log2_cb_size > s->sps->log2_min_cb_size) {
2161 SAMPLE(s->split_cu_flag, x0, y0) =
2162 ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2164 SAMPLE(s->split_cu_flag, x0, y0) =
2165 (log2_cb_size > s->sps->log2_min_cb_size);
2167 if (s->pps->cu_qp_delta_enabled_flag &&
2168 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth) {
2169 lc->tu.is_cu_qp_delta_coded = 0;
2170 lc->tu.cu_qp_delta = 0;
2173 if (SAMPLE(s->split_cu_flag, x0, y0)) {
2174 const int cb_size_split = cb_size >> 1;
2175 const int x1 = x0 + cb_size_split;
2176 const int y1 = y0 + cb_size_split;
2181 #define SUBDIVIDE(x, y) \
2183 if (x < s->sps->width && y < s->sps->height) { \
2184 int ret = hls_coding_quadtree(s, x, y, log2_cb_size, cb_depth);\
2195 int ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2203 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2206 HEVCLocalContext *lc = &s->HEVClc;
2207 int ctb_size = 1 << s->sps->log2_ctb_size;
2208 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2209 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2211 int tile_left_boundary, tile_up_boundary;
2212 int slice_left_boundary, slice_up_boundary;
2214 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2216 if (s->pps->entropy_coding_sync_enabled_flag) {
2217 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2218 lc->first_qp_group = 1;
2219 lc->end_of_tiles_x = s->sps->width;
2220 } else if (s->pps->tiles_enabled_flag) {
2221 if (ctb_addr_ts && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1]) {
2222 int idxX = s->pps->col_idxX[x_ctb >> s->sps->log2_ctb_size];
2223 lc->start_of_tiles_x = x_ctb;
2224 lc->end_of_tiles_x = x_ctb + (s->pps->column_width[idxX] << s->sps->log2_ctb_size);
2225 lc->first_qp_group = 1;
2228 lc->end_of_tiles_x = s->sps->width;
2231 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->sps->height);
2233 if (s->pps->tiles_enabled_flag) {
2234 tile_left_boundary = x_ctb > 0 &&
2235 s->pps->tile_id[ctb_addr_ts] == s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs - 1]];
2236 slice_left_boundary = x_ctb > 0 &&
2237 s->tab_slice_address[ctb_addr_rs] == s->tab_slice_address[ctb_addr_rs - 1];
2238 tile_up_boundary = y_ctb > 0 &&
2239 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]];
2240 slice_up_boundary = y_ctb > 0 &&
2241 s->tab_slice_address[ctb_addr_rs] == s->tab_slice_address[ctb_addr_rs - s->sps->ctb_width];
2243 tile_left_boundary =
2244 tile_up_boundary = 1;
2245 slice_left_boundary = ctb_addr_in_slice > 0;
2246 slice_up_boundary = ctb_addr_in_slice >= s->sps->ctb_width;
2248 lc->slice_or_tiles_left_boundary = (!slice_left_boundary) + (!tile_left_boundary << 1);
2249 lc->slice_or_tiles_up_boundary = (!slice_up_boundary + (!tile_up_boundary << 1));
2250 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && tile_left_boundary);
2251 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->sps->ctb_width) && tile_up_boundary);
2252 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]]));
2253 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]]));
2256 static int hls_slice_data(HEVCContext *s)
2258 int ctb_size = 1 << s->sps->log2_ctb_size;
2262 int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2265 while (more_data && ctb_addr_ts < s->sps->ctb_size) {
2266 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2268 x_ctb = (ctb_addr_rs % ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2269 y_ctb = (ctb_addr_rs / ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2270 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2272 ff_hevc_cabac_init(s, ctb_addr_ts);
2274 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2276 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2277 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2278 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2280 ret = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2283 more_data = !ff_hevc_end_of_slice_flag_decode(s);
2286 ff_hevc_save_states(s, ctb_addr_ts);
2287 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2290 if (x_ctb + ctb_size >= s->sps->width &&
2291 y_ctb + ctb_size >= s->sps->height)
2292 ff_hevc_hls_filter(s, x_ctb, y_ctb);
2298 * @return AVERROR_INVALIDDATA if the packet is not a valid NAL unit,
2299 * 0 if the unit should be skipped, 1 otherwise
2301 static int hls_nal_unit(HEVCContext *s)
2303 GetBitContext *gb = &s->HEVClc.gb;
2306 if (get_bits1(gb) != 0)
2307 return AVERROR_INVALIDDATA;
2309 s->nal_unit_type = get_bits(gb, 6);
2311 nuh_layer_id = get_bits(gb, 6);
2312 s->temporal_id = get_bits(gb, 3) - 1;
2313 if (s->temporal_id < 0)
2314 return AVERROR_INVALIDDATA;
2316 av_log(s->avctx, AV_LOG_DEBUG,
2317 "nal_unit_type: %d, nuh_layer_id: %dtemporal_id: %d\n",
2318 s->nal_unit_type, nuh_layer_id, s->temporal_id);
2320 return nuh_layer_id == 0;
2323 static void restore_tqb_pixels(HEVCContext *s)
2325 int min_pu_size = 1 << s->sps->log2_min_pu_size;
2328 for (c_idx = 0; c_idx < 3; c_idx++) {
2329 ptrdiff_t stride = s->frame->linesize[c_idx];
2330 int hshift = s->sps->hshift[c_idx];
2331 int vshift = s->sps->vshift[c_idx];
2332 for (y = 0; y < s->sps->min_pu_height; y++) {
2333 for (x = 0; x < s->sps->min_pu_width; x++) {
2334 if (s->is_pcm[y * s->sps->min_pu_width + x]) {
2336 int len = min_pu_size >> hshift;
2337 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)];
2338 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)];
2339 for (n = 0; n < (min_pu_size >> vshift); n++) {
2340 memcpy(dst, src, len);
2350 static int hevc_frame_start(HEVCContext *s)
2352 HEVCLocalContext *lc = &s->HEVClc;
2355 memset(s->horizontal_bs, 0, 2 * s->bs_width * (s->bs_height + 1));
2356 memset(s->vertical_bs, 0, 2 * s->bs_width * (s->bs_height + 1));
2357 memset(s->cbf_luma, 0, s->sps->min_tb_width * s->sps->min_tb_height);
2358 memset(s->is_pcm, 0, s->sps->min_pu_width * s->sps->min_pu_height);
2360 lc->start_of_tiles_x = 0;
2363 if (s->pps->tiles_enabled_flag)
2364 lc->end_of_tiles_x = s->pps->column_width[0] << s->sps->log2_ctb_size;
2366 ret = ff_hevc_set_new_ref(s, s->sps->sao_enabled ? &s->sao_frame : &s->frame,
2371 av_fast_malloc(&lc->edge_emu_buffer, &lc->edge_emu_buffer_size,
2372 (MAX_PB_SIZE + 7) * s->ref->frame->linesize[0]);
2373 if (!lc->edge_emu_buffer) {
2374 ret = AVERROR(ENOMEM);
2378 ret = ff_hevc_frame_rps(s);
2380 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2384 av_frame_unref(s->output_frame);
2385 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2389 ff_thread_finish_setup(s->avctx);
2395 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2400 static int decode_nal_unit(HEVCContext *s, const uint8_t *nal, int length)
2402 HEVCLocalContext *lc = &s->HEVClc;
2403 GetBitContext *gb = &lc->gb;
2404 int ctb_addr_ts, ret;
2406 ret = init_get_bits8(gb, nal, length);
2410 ret = hls_nal_unit(s);
2412 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit %d, skipping.\n",
2414 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2420 switch (s->nal_unit_type) {
2422 ret = ff_hevc_decode_nal_vps(s);
2427 ret = ff_hevc_decode_nal_sps(s);
2432 ret = ff_hevc_decode_nal_pps(s);
2436 case NAL_SEI_PREFIX:
2437 case NAL_SEI_SUFFIX:
2438 ret = ff_hevc_decode_nal_sei(s);
2449 case NAL_BLA_W_RADL:
2451 case NAL_IDR_W_RADL:
2458 ret = hls_slice_header(s);
2462 if (s->max_ra == INT_MAX) {
2463 if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
2467 s->max_ra = INT_MIN;
2471 if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
2472 s->poc <= s->max_ra) {
2476 if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
2477 s->max_ra = INT_MIN;
2480 if (s->sh.first_slice_in_pic_flag) {
2481 ret = hevc_frame_start(s);
2484 } else if (!s->ref) {
2485 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2486 return AVERROR_INVALIDDATA;
2489 if (!s->sh.dependent_slice_segment_flag &&
2490 s->sh.slice_type != I_SLICE) {
2491 ret = ff_hevc_slice_rpl(s);
2493 av_log(s->avctx, AV_LOG_WARNING,
2494 "Error constructing the reference lists for the current slice.\n");
2495 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2500 ctb_addr_ts = hls_slice_data(s);
2501 if (ctb_addr_ts >= (s->sps->ctb_width * s->sps->ctb_height)) {
2503 if ((s->pps->transquant_bypass_enable_flag ||
2504 (s->sps->pcm.loop_filter_disable_flag && s->sps->pcm_enabled_flag)) &&
2505 s->sps->sao_enabled)
2506 restore_tqb_pixels(s);
2509 if (ctb_addr_ts < 0)
2514 s->seq_decode = (s->seq_decode + 1) & 0xff;
2515 s->max_ra = INT_MAX;
2521 av_log(s->avctx, AV_LOG_INFO,
2522 "Skipping NAL unit %d\n", s->nal_unit_type);
2528 /* FIXME: This is adapted from ff_h264_decode_nal, avoiding duplication
2529 * between these functions would be nice. */
2530 static int extract_rbsp(const uint8_t *src, int length,
2536 #define STARTCODE_TEST \
2537 if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \
2538 if (src[i + 2] != 3) { \
2539 /* startcode, so we must be past the end */ \
2544 #if HAVE_FAST_UNALIGNED
2545 #define FIND_FIRST_ZERO \
2546 if (i > 0 && !src[i]) \
2551 for (i = 0; i + 1 < length; i += 9) {
2552 if (!((~AV_RN64A(src + i) &
2553 (AV_RN64A(src + i) - 0x0100010001000101ULL)) &
2554 0x8000800080008080ULL))
2561 for (i = 0; i + 1 < length; i += 5) {
2562 if (!((~AV_RN32A(src + i) &
2563 (AV_RN32A(src + i) - 0x01000101U)) &
2570 #endif /* HAVE_FAST_64BIT */
2572 for (i = 0; i + 1 < length; i += 2) {
2575 if (i > 0 && src[i - 1] == 0)
2579 #endif /* HAVE_FAST_UNALIGNED */
2581 if (i >= length - 1) { // no escaped 0
2587 av_fast_malloc(&nal->rbsp_buffer, &nal->rbsp_buffer_size,
2588 length + FF_INPUT_BUFFER_PADDING_SIZE);
2589 if (!nal->rbsp_buffer)
2590 return AVERROR(ENOMEM);
2592 dst = nal->rbsp_buffer;
2594 memcpy(dst, src, i);
2596 while (si + 2 < length) {
2597 // remove escapes (very rare 1:2^22)
2598 if (src[si + 2] > 3) {
2599 dst[di++] = src[si++];
2600 dst[di++] = src[si++];
2601 } else if (src[si] == 0 && src[si + 1] == 0) {
2602 if (src[si + 2] == 3) { // escape
2608 } else // next start code
2612 dst[di++] = src[si++];
2615 dst[di++] = src[si++];
2618 memset(dst + di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2625 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2627 int i, consumed, ret = 0;
2632 /* split the input packet into NAL units, so we know the upper bound on the
2633 * number of slices in the frame */
2635 while (length >= 4) {
2637 int extract_length = 0;
2641 for (i = 0; i < s->nal_length_size; i++)
2642 extract_length = (extract_length << 8) | buf[i];
2643 buf += s->nal_length_size;
2644 length -= s->nal_length_size;
2646 if (extract_length > length) {
2647 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit size.\n");
2648 ret = AVERROR_INVALIDDATA;
2657 if (buf[0] != 0 || buf[1] != 0 || buf[2] != 1) {
2658 ret = AVERROR_INVALIDDATA;
2664 extract_length = length;
2667 if (s->nals_allocated < s->nb_nals + 1) {
2668 int new_size = s->nals_allocated + 1;
2669 HEVCNAL *tmp = av_realloc_array(s->nals, new_size, sizeof(*tmp));
2671 ret = AVERROR(ENOMEM);
2675 memset(s->nals + s->nals_allocated, 0,
2676 (new_size - s->nals_allocated) * sizeof(*tmp));
2677 s->nals_allocated = new_size;
2679 nal = &s->nals[s->nb_nals++];
2681 consumed = extract_rbsp(buf, extract_length, nal);
2687 ret = init_get_bits8(&s->HEVClc.gb, nal->data, nal->size);
2692 if (s->nal_unit_type == NAL_EOB_NUT ||
2693 s->nal_unit_type == NAL_EOS_NUT)
2700 /* parse the NAL units */
2701 for (i = 0; i < s->nb_nals; i++) {
2702 int ret = decode_nal_unit(s, s->nals[i].data, s->nals[i].size);
2704 av_log(s->avctx, AV_LOG_WARNING,
2705 "Error parsing NAL unit #%d.\n", i);
2706 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2713 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2718 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2721 for (i = 0; i < 16; i++)
2722 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
2725 static int verify_md5(HEVCContext *s, AVFrame *frame)
2727 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
2728 int pixel_shift = desc->comp[0].depth_minus1 > 7;
2732 return AVERROR(EINVAL);
2734 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
2737 /* the checksums are LE, so we have to byteswap for >8bpp formats
2740 if (pixel_shift && !s->checksum_buf) {
2741 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
2742 FFMAX3(frame->linesize[0], frame->linesize[1],
2743 frame->linesize[2]));
2744 if (!s->checksum_buf)
2745 return AVERROR(ENOMEM);
2749 for (i = 0; frame->data[i]; i++) {
2750 int width = s->avctx->coded_width;
2751 int height = s->avctx->coded_height;
2752 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
2753 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
2756 av_md5_init(s->md5_ctx);
2757 for (j = 0; j < h; j++) {
2758 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
2761 s->dsp.bswap16_buf((uint16_t*)s->checksum_buf,
2762 (const uint16_t*)src, w);
2763 src = s->checksum_buf;
2766 av_md5_update(s->md5_ctx, src, w << pixel_shift);
2768 av_md5_final(s->md5_ctx, md5);
2770 if (!memcmp(md5, s->md5[i], 16)) {
2771 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
2772 print_md5(s->avctx, AV_LOG_DEBUG, md5);
2773 av_log (s->avctx, AV_LOG_DEBUG, "; ");
2775 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
2776 print_md5(s->avctx, AV_LOG_ERROR, md5);
2777 av_log (s->avctx, AV_LOG_ERROR, " != ");
2778 print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
2779 av_log (s->avctx, AV_LOG_ERROR, "\n");
2780 return AVERROR_INVALIDDATA;
2784 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2789 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
2793 HEVCContext *s = avctx->priv_data;
2796 ret = ff_hevc_output_frame(s, data, 1);
2805 ret = decode_nal_units(s, avpkt->data, avpkt->size);
2809 /* verify the SEI checksum */
2810 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
2812 ret = verify_md5(s, s->ref->frame);
2813 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
2814 ff_hevc_unref_frame(s, s->ref, ~0);
2820 if (s->is_decoded) {
2821 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
2825 if (s->output_frame->buf[0]) {
2826 av_frame_move_ref(data, s->output_frame);
2833 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
2835 int ret = ff_thread_ref_frame(&dst->tf, &src->tf);
2839 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
2840 if (!dst->tab_mvf_buf)
2842 dst->tab_mvf = src->tab_mvf;
2844 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
2845 if (!dst->rpl_tab_buf)
2847 dst->rpl_tab = src->rpl_tab;
2849 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
2853 dst->poc = src->poc;
2854 dst->ctb_count = src->ctb_count;
2855 dst->window = src->window;
2856 dst->flags = src->flags;
2857 dst->sequence = src->sequence;
2861 ff_hevc_unref_frame(s, dst, ~0);
2862 return AVERROR(ENOMEM);
2865 static av_cold int hevc_decode_free(AVCodecContext *avctx)
2867 HEVCContext *s = avctx->priv_data;
2868 HEVCLocalContext *lc = &s->HEVClc;
2873 av_freep(&lc->edge_emu_buffer);
2874 av_freep(&s->md5_ctx);
2876 av_frame_free(&s->tmp_frame);
2877 av_frame_free(&s->output_frame);
2879 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2880 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
2881 av_frame_free(&s->DPB[i].frame);
2884 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++)
2885 av_freep(&s->vps_list[i]);
2886 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++)
2887 av_buffer_unref(&s->sps_list[i]);
2888 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
2889 av_buffer_unref(&s->pps_list[i]);
2891 for (i = 0; i < s->nals_allocated; i++)
2892 av_freep(&s->nals[i].rbsp_buffer);
2894 s->nals_allocated = 0;
2899 static av_cold int hevc_init_context(AVCodecContext *avctx)
2901 HEVCContext *s = avctx->priv_data;
2906 s->tmp_frame = av_frame_alloc();
2910 s->output_frame = av_frame_alloc();
2911 if (!s->output_frame)
2914 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2915 s->DPB[i].frame = av_frame_alloc();
2916 if (!s->DPB[i].frame)
2918 s->DPB[i].tf.f = s->DPB[i].frame;
2921 s->max_ra = INT_MAX;
2923 s->md5_ctx = av_md5_alloc();
2927 ff_dsputil_init(&s->dsp, avctx);
2929 s->context_initialized = 1;
2934 hevc_decode_free(avctx);
2935 return AVERROR(ENOMEM);
2938 static int hevc_update_thread_context(AVCodecContext *dst,
2939 const AVCodecContext *src)
2941 HEVCContext *s = dst->priv_data;
2942 HEVCContext *s0 = src->priv_data;
2945 if (!s->context_initialized) {
2946 ret = hevc_init_context(dst);
2951 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2952 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
2953 if (s0->DPB[i].frame->buf[0]) {
2954 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
2960 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++) {
2961 av_buffer_unref(&s->sps_list[i]);
2962 if (s0->sps_list[i]) {
2963 s->sps_list[i] = av_buffer_ref(s0->sps_list[i]);
2964 if (!s->sps_list[i])
2965 return AVERROR(ENOMEM);
2969 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++) {
2970 av_buffer_unref(&s->pps_list[i]);
2971 if (s0->pps_list[i]) {
2972 s->pps_list[i] = av_buffer_ref(s0->pps_list[i]);
2973 if (!s->pps_list[i])
2974 return AVERROR(ENOMEM);
2978 if (s->sps != s0->sps)
2979 ret = set_sps(s, s0->sps);
2981 s->seq_decode = s0->seq_decode;
2982 s->seq_output = s0->seq_output;
2983 s->pocTid0 = s0->pocTid0;
2984 s->max_ra = s0->max_ra;
2986 s->is_nalff = s0->is_nalff;
2987 s->nal_length_size = s0->nal_length_size;
2990 s->seq_decode = (s->seq_decode + 1) & 0xff;
2991 s->max_ra = INT_MAX;
2997 static int hevc_decode_extradata(HEVCContext *s)
2999 AVCodecContext *avctx = s->avctx;
3003 bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
3005 if (avctx->extradata_size > 3 &&
3006 (avctx->extradata[0] || avctx->extradata[1] ||
3007 avctx->extradata[2] > 1)) {
3008 /* It seems the extradata is encoded as hvcC format.
3009 * Temporarily, we support configurationVersion==0 until 14496-15 3rd
3010 * is finalized. When finalized, configurationVersion will be 1 and we
3011 * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
3012 int i, j, num_arrays, nal_len_size;
3016 bytestream2_skip(&gb, 21);
3017 nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
3018 num_arrays = bytestream2_get_byte(&gb);
3020 /* nal units in the hvcC always have length coded with 2 bytes,
3021 * so put a fake nal_length_size = 2 while parsing them */
3022 s->nal_length_size = 2;
3024 /* Decode nal units from hvcC. */
3025 for (i = 0; i < num_arrays; i++) {
3026 int type = bytestream2_get_byte(&gb) & 0x3f;
3027 int cnt = bytestream2_get_be16(&gb);
3029 for (j = 0; j < cnt; j++) {
3030 // +2 for the nal size field
3031 int nalsize = bytestream2_peek_be16(&gb) + 2;
3032 if (bytestream2_get_bytes_left(&gb) < nalsize) {
3033 av_log(s->avctx, AV_LOG_ERROR,
3034 "Invalid NAL unit size in extradata.\n");
3035 return AVERROR_INVALIDDATA;
3038 ret = decode_nal_units(s, gb.buffer, nalsize);
3040 av_log(avctx, AV_LOG_ERROR,
3041 "Decoding nal unit %d %d from hvcC failed\n",
3045 bytestream2_skip(&gb, nalsize);
3049 /* Now store right nal length size, that will be used to parse
3051 s->nal_length_size = nal_len_size;
3054 ret = decode_nal_units(s, avctx->extradata, avctx->extradata_size);
3061 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3063 HEVCContext *s = avctx->priv_data;
3066 ff_init_cabac_states();
3068 avctx->internal->allocate_progress = 1;
3070 ret = hevc_init_context(avctx);
3074 if (avctx->extradata_size > 0 && avctx->extradata) {
3075 ret = hevc_decode_extradata(s);
3077 hevc_decode_free(avctx);
3085 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3087 HEVCContext *s = avctx->priv_data;
3090 memset(s, 0, sizeof(*s));
3092 ret = hevc_init_context(avctx);
3099 static void hevc_decode_flush(AVCodecContext *avctx)
3101 HEVCContext *s = avctx->priv_data;
3102 ff_hevc_flush_dpb(s);
3103 s->max_ra = INT_MAX;
3106 #define OFFSET(x) offsetof(HEVCContext, x)
3107 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3108 static const AVOption options[] = {
3109 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3110 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3114 static const AVClass hevc_decoder_class = {
3115 .class_name = "HEVC decoder",
3116 .item_name = av_default_item_name,
3118 .version = LIBAVUTIL_VERSION_INT,
3121 AVCodec ff_hevc_decoder = {
3123 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3124 .type = AVMEDIA_TYPE_VIDEO,
3125 .id = AV_CODEC_ID_HEVC,
3126 .priv_data_size = sizeof(HEVCContext),
3127 .priv_class = &hevc_decoder_class,
3128 .init = hevc_decode_init,
3129 .close = hevc_decode_free,
3130 .decode = hevc_decode_frame,
3131 .flush = hevc_decode_flush,
3132 .update_thread_context = hevc_update_thread_context,
3133 .init_thread_copy = hevc_init_thread_copy,
3134 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY |
3135 CODEC_CAP_FRAME_THREADS,