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 FFmpeg.
11 * FFmpeg 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 * FFmpeg 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 FFmpeg; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavutil/atomic.h"
27 #include "libavutil/attributes.h"
28 #include "libavutil/common.h"
29 #include "libavutil/display.h"
30 #include "libavutil/internal.h"
31 #include "libavutil/md5.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/pixdesc.h"
34 #include "libavutil/stereo3d.h"
37 #include "bytestream.h"
38 #include "cabac_functions.h"
42 const uint8_t ff_hevc_pel_weight[65] = { [2] = 0, [4] = 1, [6] = 2, [8] = 3, [12] = 4, [16] = 5, [24] = 6, [32] = 7, [48] = 8, [64] = 9 };
45 * NOTE: Each function hls_foo correspond to the function foo in the
46 * specification (HLS stands for High Level Syntax).
53 /* free everything allocated by pic_arrays_init() */
54 static void pic_arrays_free(HEVCContext *s)
57 av_freep(&s->deblock);
59 av_freep(&s->skip_flag);
60 av_freep(&s->tab_ct_depth);
62 av_freep(&s->tab_ipm);
63 av_freep(&s->cbf_luma);
66 av_freep(&s->qp_y_tab);
67 av_freep(&s->tab_slice_address);
68 av_freep(&s->filter_slice_edges);
70 av_freep(&s->horizontal_bs);
71 av_freep(&s->vertical_bs);
73 av_freep(&s->sh.entry_point_offset);
74 av_freep(&s->sh.size);
75 av_freep(&s->sh.offset);
77 av_buffer_pool_uninit(&s->tab_mvf_pool);
78 av_buffer_pool_uninit(&s->rpl_tab_pool);
81 /* allocate arrays that depend on frame dimensions */
82 static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
84 int log2_min_cb_size = sps->log2_min_cb_size;
85 int width = sps->width;
86 int height = sps->height;
87 int pic_size_in_ctb = ((width >> log2_min_cb_size) + 1) *
88 ((height >> log2_min_cb_size) + 1);
89 int ctb_count = sps->ctb_width * sps->ctb_height;
90 int min_pu_size = sps->min_pu_width * sps->min_pu_height;
92 s->bs_width = (width >> 2) + 1;
93 s->bs_height = (height >> 2) + 1;
95 s->sao = av_mallocz_array(ctb_count, sizeof(*s->sao));
96 s->deblock = av_mallocz_array(ctb_count, sizeof(*s->deblock));
97 if (!s->sao || !s->deblock)
100 s->skip_flag = av_malloc(sps->min_cb_height * sps->min_cb_width);
101 s->tab_ct_depth = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
102 if (!s->skip_flag || !s->tab_ct_depth)
105 s->cbf_luma = av_malloc_array(sps->min_tb_width, sps->min_tb_height);
106 s->tab_ipm = av_mallocz(min_pu_size);
107 s->is_pcm = av_malloc((sps->min_pu_width + 1) * (sps->min_pu_height + 1));
108 if (!s->tab_ipm || !s->cbf_luma || !s->is_pcm)
111 s->filter_slice_edges = av_malloc(ctb_count);
112 s->tab_slice_address = av_malloc_array(pic_size_in_ctb,
113 sizeof(*s->tab_slice_address));
114 s->qp_y_tab = av_malloc_array(pic_size_in_ctb,
115 sizeof(*s->qp_y_tab));
116 if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address)
119 s->horizontal_bs = av_mallocz_array(s->bs_width, s->bs_height);
120 s->vertical_bs = av_mallocz_array(s->bs_width, s->bs_height);
121 if (!s->horizontal_bs || !s->vertical_bs)
124 s->tab_mvf_pool = av_buffer_pool_init(min_pu_size * sizeof(MvField),
126 s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab),
128 if (!s->tab_mvf_pool || !s->rpl_tab_pool)
135 return AVERROR(ENOMEM);
138 static void pred_weight_table(HEVCContext *s, GetBitContext *gb)
142 uint8_t luma_weight_l0_flag[16];
143 uint8_t chroma_weight_l0_flag[16];
144 uint8_t luma_weight_l1_flag[16];
145 uint8_t chroma_weight_l1_flag[16];
147 s->sh.luma_log2_weight_denom = get_ue_golomb_long(gb);
148 if (s->sps->chroma_format_idc != 0) {
149 int delta = get_se_golomb(gb);
150 s->sh.chroma_log2_weight_denom = av_clip(s->sh.luma_log2_weight_denom + delta, 0, 7);
153 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
154 luma_weight_l0_flag[i] = get_bits1(gb);
155 if (!luma_weight_l0_flag[i]) {
156 s->sh.luma_weight_l0[i] = 1 << s->sh.luma_log2_weight_denom;
157 s->sh.luma_offset_l0[i] = 0;
160 if (s->sps->chroma_format_idc != 0) {
161 for (i = 0; i < s->sh.nb_refs[L0]; i++)
162 chroma_weight_l0_flag[i] = get_bits1(gb);
164 for (i = 0; i < s->sh.nb_refs[L0]; i++)
165 chroma_weight_l0_flag[i] = 0;
167 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
168 if (luma_weight_l0_flag[i]) {
169 int delta_luma_weight_l0 = get_se_golomb(gb);
170 s->sh.luma_weight_l0[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;
171 s->sh.luma_offset_l0[i] = get_se_golomb(gb);
173 if (chroma_weight_l0_flag[i]) {
174 for (j = 0; j < 2; j++) {
175 int delta_chroma_weight_l0 = get_se_golomb(gb);
176 int delta_chroma_offset_l0 = get_se_golomb(gb);
177 s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
178 s->sh.chroma_offset_l0[i][j] = av_clip((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j])
179 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
182 s->sh.chroma_weight_l0[i][0] = 1 << s->sh.chroma_log2_weight_denom;
183 s->sh.chroma_offset_l0[i][0] = 0;
184 s->sh.chroma_weight_l0[i][1] = 1 << s->sh.chroma_log2_weight_denom;
185 s->sh.chroma_offset_l0[i][1] = 0;
188 if (s->sh.slice_type == B_SLICE) {
189 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
190 luma_weight_l1_flag[i] = get_bits1(gb);
191 if (!luma_weight_l1_flag[i]) {
192 s->sh.luma_weight_l1[i] = 1 << s->sh.luma_log2_weight_denom;
193 s->sh.luma_offset_l1[i] = 0;
196 if (s->sps->chroma_format_idc != 0) {
197 for (i = 0; i < s->sh.nb_refs[L1]; i++)
198 chroma_weight_l1_flag[i] = get_bits1(gb);
200 for (i = 0; i < s->sh.nb_refs[L1]; i++)
201 chroma_weight_l1_flag[i] = 0;
203 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
204 if (luma_weight_l1_flag[i]) {
205 int delta_luma_weight_l1 = get_se_golomb(gb);
206 s->sh.luma_weight_l1[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;
207 s->sh.luma_offset_l1[i] = get_se_golomb(gb);
209 if (chroma_weight_l1_flag[i]) {
210 for (j = 0; j < 2; j++) {
211 int delta_chroma_weight_l1 = get_se_golomb(gb);
212 int delta_chroma_offset_l1 = get_se_golomb(gb);
213 s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
214 s->sh.chroma_offset_l1[i][j] = av_clip((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j])
215 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
218 s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom;
219 s->sh.chroma_offset_l1[i][0] = 0;
220 s->sh.chroma_weight_l1[i][1] = 1 << s->sh.chroma_log2_weight_denom;
221 s->sh.chroma_offset_l1[i][1] = 0;
227 static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
229 const HEVCSPS *sps = s->sps;
230 int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
231 int prev_delta_msb = 0;
232 unsigned int nb_sps = 0, nb_sh;
236 if (!sps->long_term_ref_pics_present_flag)
239 if (sps->num_long_term_ref_pics_sps > 0)
240 nb_sps = get_ue_golomb_long(gb);
241 nb_sh = get_ue_golomb_long(gb);
243 if (nb_sh + (uint64_t)nb_sps > FF_ARRAY_ELEMS(rps->poc))
244 return AVERROR_INVALIDDATA;
246 rps->nb_refs = nb_sh + nb_sps;
248 for (i = 0; i < rps->nb_refs; i++) {
249 uint8_t delta_poc_msb_present;
252 uint8_t lt_idx_sps = 0;
254 if (sps->num_long_term_ref_pics_sps > 1)
255 lt_idx_sps = get_bits(gb, av_ceil_log2(sps->num_long_term_ref_pics_sps));
257 rps->poc[i] = sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
258 rps->used[i] = sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];
260 rps->poc[i] = get_bits(gb, sps->log2_max_poc_lsb);
261 rps->used[i] = get_bits1(gb);
264 delta_poc_msb_present = get_bits1(gb);
265 if (delta_poc_msb_present) {
266 int delta = get_ue_golomb_long(gb);
268 if (i && i != nb_sps)
269 delta += prev_delta_msb;
271 rps->poc[i] += s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
272 prev_delta_msb = delta;
279 static int get_buffer_sao(HEVCContext *s, AVFrame *frame, const HEVCSPS *sps)
283 frame->width = s->avctx->width + 2;
284 frame->height = s->avctx->height + 2;
285 if ((ret = ff_get_buffer(s->avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
287 for (i = 0; frame->data[i]; i++) {
288 int offset = frame->linesize[i] + (1 << sps->pixel_shift);
289 frame->data[i] += offset;
291 frame->width = s->avctx->width;
292 frame->height = s->avctx->height;
297 static int set_sps(HEVCContext *s, const HEVCSPS *sps)
300 unsigned int num = 0, den = 0;
303 ret = pic_arrays_init(s, sps);
307 s->avctx->coded_width = sps->width;
308 s->avctx->coded_height = sps->height;
309 s->avctx->width = sps->output_width;
310 s->avctx->height = sps->output_height;
311 s->avctx->pix_fmt = sps->pix_fmt;
312 s->avctx->has_b_frames = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics;
314 ff_set_sar(s->avctx, sps->vui.sar);
316 if (sps->vui.video_signal_type_present_flag)
317 s->avctx->color_range = sps->vui.video_full_range_flag ? AVCOL_RANGE_JPEG
320 s->avctx->color_range = AVCOL_RANGE_MPEG;
322 if (sps->vui.colour_description_present_flag) {
323 s->avctx->color_primaries = sps->vui.colour_primaries;
324 s->avctx->color_trc = sps->vui.transfer_characteristic;
325 s->avctx->colorspace = sps->vui.matrix_coeffs;
327 s->avctx->color_primaries = AVCOL_PRI_UNSPECIFIED;
328 s->avctx->color_trc = AVCOL_TRC_UNSPECIFIED;
329 s->avctx->colorspace = AVCOL_SPC_UNSPECIFIED;
332 ff_hevc_pred_init(&s->hpc, sps->bit_depth);
333 ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
334 ff_videodsp_init (&s->vdsp, sps->bit_depth);
336 if (sps->sao_enabled) {
337 av_frame_unref(s->tmp_frame);
338 ret = get_buffer_sao(s, s->tmp_frame, sps);
339 s->sao_frame = s->tmp_frame;
343 s->vps = (HEVCVPS*) s->vps_list[s->sps->vps_id]->data;
345 if (s->vps->vps_timing_info_present_flag) {
346 num = s->vps->vps_num_units_in_tick;
347 den = s->vps->vps_time_scale;
348 } else if (sps->vui.vui_timing_info_present_flag) {
349 num = sps->vui.vui_num_units_in_tick;
350 den = sps->vui.vui_time_scale;
353 if (num != 0 && den != 0)
354 av_reduce(&s->avctx->time_base.num, &s->avctx->time_base.den,
365 static int hls_slice_header(HEVCContext *s)
367 GetBitContext *gb = &s->HEVClc->gb;
368 SliceHeader *sh = &s->sh;
372 sh->first_slice_in_pic_flag = get_bits1(gb);
373 if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
374 s->seq_decode = (s->seq_decode + 1) & 0xff;
377 ff_hevc_clear_refs(s);
379 sh->no_output_of_prior_pics_flag = 0;
381 sh->no_output_of_prior_pics_flag = get_bits1(gb);
383 sh->pps_id = get_ue_golomb_long(gb);
384 if (sh->pps_id >= MAX_PPS_COUNT || !s->pps_list[sh->pps_id]) {
385 av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
386 return AVERROR_INVALIDDATA;
388 if (!sh->first_slice_in_pic_flag &&
389 s->pps != (HEVCPPS*)s->pps_list[sh->pps_id]->data) {
390 av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
391 return AVERROR_INVALIDDATA;
393 s->pps = (HEVCPPS*)s->pps_list[sh->pps_id]->data;
394 if (s->nal_unit_type == NAL_CRA_NUT && s->last_eos == 1)
395 sh->no_output_of_prior_pics_flag = 1;
397 if (s->sps != (HEVCSPS*)s->sps_list[s->pps->sps_id]->data) {
398 const HEVCSPS* last_sps = s->sps;
399 s->sps = (HEVCSPS*)s->sps_list[s->pps->sps_id]->data;
400 if (last_sps && IS_IRAP(s) && s->nal_unit_type != NAL_CRA_NUT) {
401 if (s->sps->width != last_sps->width || s->sps->height != last_sps->height ||
402 s->sps->temporal_layer[s->sps->max_sub_layers - 1].max_dec_pic_buffering !=
403 last_sps->temporal_layer[last_sps->max_sub_layers - 1].max_dec_pic_buffering)
404 sh->no_output_of_prior_pics_flag = 0;
406 ff_hevc_clear_refs(s);
407 ret = set_sps(s, s->sps);
411 s->seq_decode = (s->seq_decode + 1) & 0xff;
415 s->avctx->profile = s->sps->ptl.general_ptl.profile_idc;
416 s->avctx->level = s->sps->ptl.general_ptl.level_idc;
418 sh->dependent_slice_segment_flag = 0;
419 if (!sh->first_slice_in_pic_flag) {
420 int slice_address_length;
422 if (s->pps->dependent_slice_segments_enabled_flag)
423 sh->dependent_slice_segment_flag = get_bits1(gb);
425 slice_address_length = av_ceil_log2(s->sps->ctb_width *
427 sh->slice_segment_addr = get_bits(gb, slice_address_length);
428 if (sh->slice_segment_addr >= s->sps->ctb_width * s->sps->ctb_height) {
429 av_log(s->avctx, AV_LOG_ERROR,
430 "Invalid slice segment address: %u.\n",
431 sh->slice_segment_addr);
432 return AVERROR_INVALIDDATA;
435 if (!sh->dependent_slice_segment_flag) {
436 sh->slice_addr = sh->slice_segment_addr;
440 sh->slice_segment_addr = sh->slice_addr = 0;
442 s->slice_initialized = 0;
445 if (!sh->dependent_slice_segment_flag) {
446 s->slice_initialized = 0;
448 for (i = 0; i < s->pps->num_extra_slice_header_bits; i++)
449 skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
451 sh->slice_type = get_ue_golomb_long(gb);
452 if (!(sh->slice_type == I_SLICE ||
453 sh->slice_type == P_SLICE ||
454 sh->slice_type == B_SLICE)) {
455 av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
457 return AVERROR_INVALIDDATA;
459 if (IS_IRAP(s) && sh->slice_type != I_SLICE) {
460 av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
461 return AVERROR_INVALIDDATA;
464 // when flag is not present, picture is inferred to be output
465 sh->pic_output_flag = 1;
466 if (s->pps->output_flag_present_flag)
467 sh->pic_output_flag = get_bits1(gb);
469 if (s->sps->separate_colour_plane_flag)
470 sh->colour_plane_id = get_bits(gb, 2);
473 int short_term_ref_pic_set_sps_flag, poc;
475 sh->pic_order_cnt_lsb = get_bits(gb, s->sps->log2_max_poc_lsb);
476 poc = ff_hevc_compute_poc(s, sh->pic_order_cnt_lsb);
477 if (!sh->first_slice_in_pic_flag && poc != s->poc) {
478 av_log(s->avctx, AV_LOG_WARNING,
479 "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
480 if (s->avctx->err_recognition & AV_EF_EXPLODE)
481 return AVERROR_INVALIDDATA;
486 short_term_ref_pic_set_sps_flag = get_bits1(gb);
487 if (!short_term_ref_pic_set_sps_flag) {
488 ret = ff_hevc_decode_short_term_rps(s, &sh->slice_rps, s->sps, 1);
492 sh->short_term_rps = &sh->slice_rps;
494 int numbits, rps_idx;
496 if (!s->sps->nb_st_rps) {
497 av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
498 return AVERROR_INVALIDDATA;
501 numbits = av_ceil_log2(s->sps->nb_st_rps);
502 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
503 sh->short_term_rps = &s->sps->st_rps[rps_idx];
506 ret = decode_lt_rps(s, &sh->long_term_rps, gb);
508 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
509 if (s->avctx->err_recognition & AV_EF_EXPLODE)
510 return AVERROR_INVALIDDATA;
513 if (s->sps->sps_temporal_mvp_enabled_flag)
514 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
516 sh->slice_temporal_mvp_enabled_flag = 0;
518 s->sh.short_term_rps = NULL;
523 if (s->temporal_id == 0 &&
524 s->nal_unit_type != NAL_TRAIL_N &&
525 s->nal_unit_type != NAL_TSA_N &&
526 s->nal_unit_type != NAL_STSA_N &&
527 s->nal_unit_type != NAL_RADL_N &&
528 s->nal_unit_type != NAL_RADL_R &&
529 s->nal_unit_type != NAL_RASL_N &&
530 s->nal_unit_type != NAL_RASL_R)
533 if (s->sps->sao_enabled) {
534 sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
535 sh->slice_sample_adaptive_offset_flag[1] =
536 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
538 sh->slice_sample_adaptive_offset_flag[0] = 0;
539 sh->slice_sample_adaptive_offset_flag[1] = 0;
540 sh->slice_sample_adaptive_offset_flag[2] = 0;
543 sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
544 if (sh->slice_type == P_SLICE || sh->slice_type == B_SLICE) {
547 sh->nb_refs[L0] = s->pps->num_ref_idx_l0_default_active;
548 if (sh->slice_type == B_SLICE)
549 sh->nb_refs[L1] = s->pps->num_ref_idx_l1_default_active;
551 if (get_bits1(gb)) { // num_ref_idx_active_override_flag
552 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
553 if (sh->slice_type == B_SLICE)
554 sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
556 if (sh->nb_refs[L0] > MAX_REFS || sh->nb_refs[L1] > MAX_REFS) {
557 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
558 sh->nb_refs[L0], sh->nb_refs[L1]);
559 return AVERROR_INVALIDDATA;
562 sh->rpl_modification_flag[0] = 0;
563 sh->rpl_modification_flag[1] = 0;
564 nb_refs = ff_hevc_frame_nb_refs(s);
566 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
567 return AVERROR_INVALIDDATA;
570 if (s->pps->lists_modification_present_flag && nb_refs > 1) {
571 sh->rpl_modification_flag[0] = get_bits1(gb);
572 if (sh->rpl_modification_flag[0]) {
573 for (i = 0; i < sh->nb_refs[L0]; i++)
574 sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
577 if (sh->slice_type == B_SLICE) {
578 sh->rpl_modification_flag[1] = get_bits1(gb);
579 if (sh->rpl_modification_flag[1] == 1)
580 for (i = 0; i < sh->nb_refs[L1]; i++)
581 sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
585 if (sh->slice_type == B_SLICE)
586 sh->mvd_l1_zero_flag = get_bits1(gb);
588 if (s->pps->cabac_init_present_flag)
589 sh->cabac_init_flag = get_bits1(gb);
591 sh->cabac_init_flag = 0;
593 sh->collocated_ref_idx = 0;
594 if (sh->slice_temporal_mvp_enabled_flag) {
595 sh->collocated_list = L0;
596 if (sh->slice_type == B_SLICE)
597 sh->collocated_list = !get_bits1(gb);
599 if (sh->nb_refs[sh->collocated_list] > 1) {
600 sh->collocated_ref_idx = get_ue_golomb_long(gb);
601 if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
602 av_log(s->avctx, AV_LOG_ERROR,
603 "Invalid collocated_ref_idx: %d.\n",
604 sh->collocated_ref_idx);
605 return AVERROR_INVALIDDATA;
610 if ((s->pps->weighted_pred_flag && sh->slice_type == P_SLICE) ||
611 (s->pps->weighted_bipred_flag && sh->slice_type == B_SLICE)) {
612 pred_weight_table(s, gb);
615 sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
616 if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
617 av_log(s->avctx, AV_LOG_ERROR,
618 "Invalid number of merging MVP candidates: %d.\n",
619 sh->max_num_merge_cand);
620 return AVERROR_INVALIDDATA;
624 sh->slice_qp_delta = get_se_golomb(gb);
626 if (s->pps->pic_slice_level_chroma_qp_offsets_present_flag) {
627 sh->slice_cb_qp_offset = get_se_golomb(gb);
628 sh->slice_cr_qp_offset = get_se_golomb(gb);
630 sh->slice_cb_qp_offset = 0;
631 sh->slice_cr_qp_offset = 0;
634 if (s->pps->chroma_qp_offset_list_enabled_flag)
635 sh->cu_chroma_qp_offset_enabled_flag = get_bits1(gb);
637 sh->cu_chroma_qp_offset_enabled_flag = 0;
639 if (s->pps->deblocking_filter_control_present_flag) {
640 int deblocking_filter_override_flag = 0;
642 if (s->pps->deblocking_filter_override_enabled_flag)
643 deblocking_filter_override_flag = get_bits1(gb);
645 if (deblocking_filter_override_flag) {
646 sh->disable_deblocking_filter_flag = get_bits1(gb);
647 if (!sh->disable_deblocking_filter_flag) {
648 sh->beta_offset = get_se_golomb(gb) * 2;
649 sh->tc_offset = get_se_golomb(gb) * 2;
652 sh->disable_deblocking_filter_flag = s->pps->disable_dbf;
653 sh->beta_offset = s->pps->beta_offset;
654 sh->tc_offset = s->pps->tc_offset;
657 sh->disable_deblocking_filter_flag = 0;
662 if (s->pps->seq_loop_filter_across_slices_enabled_flag &&
663 (sh->slice_sample_adaptive_offset_flag[0] ||
664 sh->slice_sample_adaptive_offset_flag[1] ||
665 !sh->disable_deblocking_filter_flag)) {
666 sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
668 sh->slice_loop_filter_across_slices_enabled_flag = s->pps->seq_loop_filter_across_slices_enabled_flag;
670 } else if (!s->slice_initialized) {
671 av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
672 return AVERROR_INVALIDDATA;
675 sh->num_entry_point_offsets = 0;
676 if (s->pps->tiles_enabled_flag || s->pps->entropy_coding_sync_enabled_flag) {
677 sh->num_entry_point_offsets = get_ue_golomb_long(gb);
678 if (sh->num_entry_point_offsets > 0) {
679 int offset_len = get_ue_golomb_long(gb) + 1;
680 int segments = offset_len >> 4;
681 int rest = (offset_len & 15);
682 av_freep(&sh->entry_point_offset);
683 av_freep(&sh->offset);
685 sh->entry_point_offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
686 sh->offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
687 sh->size = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
688 if (!sh->entry_point_offset || !sh->offset || !sh->size) {
689 sh->num_entry_point_offsets = 0;
690 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate memory\n");
691 return AVERROR(ENOMEM);
693 for (i = 0; i < sh->num_entry_point_offsets; i++) {
695 for (j = 0; j < segments; j++) {
697 val += get_bits(gb, 16);
701 val += get_bits(gb, rest);
703 sh->entry_point_offset[i] = val + 1; // +1; // +1 to get the size
705 if (s->threads_number > 1 && (s->pps->num_tile_rows > 1 || s->pps->num_tile_columns > 1)) {
706 s->enable_parallel_tiles = 0; // TODO: you can enable tiles in parallel here
707 s->threads_number = 1;
709 s->enable_parallel_tiles = 0;
711 s->enable_parallel_tiles = 0;
714 if (s->pps->slice_header_extension_present_flag) {
715 unsigned int length = get_ue_golomb_long(gb);
716 if (length*8LL > get_bits_left(gb)) {
717 av_log(s->avctx, AV_LOG_ERROR, "too many slice_header_extension_data_bytes\n");
718 return AVERROR_INVALIDDATA;
720 for (i = 0; i < length; i++)
721 skip_bits(gb, 8); // slice_header_extension_data_byte
724 // Inferred parameters
725 sh->slice_qp = 26U + s->pps->pic_init_qp_minus26 + sh->slice_qp_delta;
726 if (sh->slice_qp > 51 ||
727 sh->slice_qp < -s->sps->qp_bd_offset) {
728 av_log(s->avctx, AV_LOG_ERROR,
729 "The slice_qp %d is outside the valid range "
732 -s->sps->qp_bd_offset);
733 return AVERROR_INVALIDDATA;
736 sh->slice_ctb_addr_rs = sh->slice_segment_addr;
738 if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) {
739 av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
740 return AVERROR_INVALIDDATA;
743 s->HEVClc->first_qp_group = !s->sh.dependent_slice_segment_flag;
745 if (!s->pps->cu_qp_delta_enabled_flag)
746 s->HEVClc->qp_y = s->sh.slice_qp;
748 s->slice_initialized = 1;
749 s->HEVClc->tu.cu_qp_offset_cb = 0;
750 s->HEVClc->tu.cu_qp_offset_cr = 0;
755 #define CTB(tab, x, y) ((tab)[(y) * s->sps->ctb_width + (x)])
757 #define SET_SAO(elem, value) \
759 if (!sao_merge_up_flag && !sao_merge_left_flag) \
761 else if (sao_merge_left_flag) \
762 sao->elem = CTB(s->sao, rx-1, ry).elem; \
763 else if (sao_merge_up_flag) \
764 sao->elem = CTB(s->sao, rx, ry-1).elem; \
769 static void hls_sao_param(HEVCContext *s, int rx, int ry)
771 HEVCLocalContext *lc = s->HEVClc;
772 int sao_merge_left_flag = 0;
773 int sao_merge_up_flag = 0;
774 SAOParams *sao = &CTB(s->sao, rx, ry);
777 if (s->sh.slice_sample_adaptive_offset_flag[0] ||
778 s->sh.slice_sample_adaptive_offset_flag[1]) {
780 if (lc->ctb_left_flag)
781 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
783 if (ry > 0 && !sao_merge_left_flag) {
785 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
789 for (c_idx = 0; c_idx < 3; c_idx++) {
790 int log2_sao_offset_scale = c_idx == 0 ? s->pps->log2_sao_offset_scale_luma :
791 s->pps->log2_sao_offset_scale_chroma;
793 if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
794 sao->type_idx[c_idx] = SAO_NOT_APPLIED;
799 sao->type_idx[2] = sao->type_idx[1];
800 sao->eo_class[2] = sao->eo_class[1];
802 SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
805 if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
808 for (i = 0; i < 4; i++)
809 SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
811 if (sao->type_idx[c_idx] == SAO_BAND) {
812 for (i = 0; i < 4; i++) {
813 if (sao->offset_abs[c_idx][i]) {
814 SET_SAO(offset_sign[c_idx][i],
815 ff_hevc_sao_offset_sign_decode(s));
817 sao->offset_sign[c_idx][i] = 0;
820 SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
821 } else if (c_idx != 2) {
822 SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
825 // Inferred parameters
826 sao->offset_val[c_idx][0] = 0;
827 for (i = 0; i < 4; i++) {
828 sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i];
829 if (sao->type_idx[c_idx] == SAO_EDGE) {
831 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
832 } else if (sao->offset_sign[c_idx][i]) {
833 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
835 sao->offset_val[c_idx][i + 1] <<= log2_sao_offset_scale;
843 static int hls_cross_component_pred(HEVCContext *s, int idx) {
844 HEVCLocalContext *lc = s->HEVClc;
845 int log2_res_scale_abs_plus1 = ff_hevc_log2_res_scale_abs(s, idx);
847 if (log2_res_scale_abs_plus1 != 0) {
848 int res_scale_sign_flag = ff_hevc_res_scale_sign_flag(s, idx);
849 lc->tu.res_scale_val = (1 << (log2_res_scale_abs_plus1 - 1)) *
850 (1 - 2 * res_scale_sign_flag);
852 lc->tu.res_scale_val = 0;
859 static int hls_transform_unit(HEVCContext *s, int x0, int y0,
860 int xBase, int yBase, int cb_xBase, int cb_yBase,
861 int log2_cb_size, int log2_trafo_size,
862 int trafo_depth, int blk_idx,
863 int cbf_luma, int *cbf_cb, int *cbf_cr)
865 HEVCLocalContext *lc = s->HEVClc;
866 const int log2_trafo_size_c = log2_trafo_size - s->sps->hshift[1];
869 if (lc->cu.pred_mode == MODE_INTRA) {
870 int trafo_size = 1 << log2_trafo_size;
871 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
873 s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
876 if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
877 (s->sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
878 int scan_idx = SCAN_DIAG;
879 int scan_idx_c = SCAN_DIAG;
880 int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
881 (s->sps->chroma_format_idc == 2 &&
882 (cbf_cb[1] || cbf_cr[1]));
884 if (s->pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
885 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
886 if (lc->tu.cu_qp_delta != 0)
887 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
888 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
889 lc->tu.is_cu_qp_delta_coded = 1;
891 if (lc->tu.cu_qp_delta < -(26 + s->sps->qp_bd_offset / 2) ||
892 lc->tu.cu_qp_delta > (25 + s->sps->qp_bd_offset / 2)) {
893 av_log(s->avctx, AV_LOG_ERROR,
894 "The cu_qp_delta %d is outside the valid range "
897 -(26 + s->sps->qp_bd_offset / 2),
898 (25 + s->sps->qp_bd_offset / 2));
899 return AVERROR_INVALIDDATA;
902 ff_hevc_set_qPy(s, cb_xBase, cb_yBase, log2_cb_size);
905 if (s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
906 !lc->cu.cu_transquant_bypass_flag && !lc->tu.is_cu_chroma_qp_offset_coded) {
907 int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(s);
908 if (cu_chroma_qp_offset_flag) {
909 int cu_chroma_qp_offset_idx = 0;
910 if (s->pps->chroma_qp_offset_list_len_minus1 > 0) {
911 cu_chroma_qp_offset_idx = ff_hevc_cu_chroma_qp_offset_idx(s);
912 av_log(s->avctx, AV_LOG_ERROR,
913 "cu_chroma_qp_offset_idx not yet tested.\n");
915 lc->tu.cu_qp_offset_cb = s->pps->cb_qp_offset_list[cu_chroma_qp_offset_idx];
916 lc->tu.cu_qp_offset_cr = s->pps->cr_qp_offset_list[cu_chroma_qp_offset_idx];
918 lc->tu.cu_qp_offset_cb = 0;
919 lc->tu.cu_qp_offset_cr = 0;
921 lc->tu.is_cu_chroma_qp_offset_coded = 1;
924 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
925 if (lc->tu.intra_pred_mode >= 6 &&
926 lc->tu.intra_pred_mode <= 14) {
927 scan_idx = SCAN_VERT;
928 } else if (lc->tu.intra_pred_mode >= 22 &&
929 lc->tu.intra_pred_mode <= 30) {
930 scan_idx = SCAN_HORIZ;
933 if (lc->tu.intra_pred_mode_c >= 6 &&
934 lc->tu.intra_pred_mode_c <= 14) {
935 scan_idx_c = SCAN_VERT;
936 } else if (lc->tu.intra_pred_mode_c >= 22 &&
937 lc->tu.intra_pred_mode_c <= 30) {
938 scan_idx_c = SCAN_HORIZ;
945 ff_hevc_hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
946 if (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3) {
947 int trafo_size_h = 1 << (log2_trafo_size_c + s->sps->hshift[1]);
948 int trafo_size_v = 1 << (log2_trafo_size_c + s->sps->vshift[1]);
949 lc->tu.cross_pf = (s->pps->cross_component_prediction_enabled_flag && cbf_luma &&
950 (lc->cu.pred_mode == MODE_INTER ||
951 (lc->tu.chroma_mode_c == 4)));
953 if (lc->tu.cross_pf) {
954 hls_cross_component_pred(s, 0);
956 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
957 if (lc->cu.pred_mode == MODE_INTRA) {
958 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
959 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 1);
962 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
963 log2_trafo_size_c, scan_idx_c, 1);
965 if (lc->tu.cross_pf) {
966 ptrdiff_t stride = s->frame->linesize[1];
967 int hshift = s->sps->hshift[1];
968 int vshift = s->sps->vshift[1];
969 int16_t *coeffs_y = lc->tu.coeffs[0];
970 int16_t *coeffs = lc->tu.coeffs[1];
971 int size = 1 << log2_trafo_size_c;
973 uint8_t *dst = &s->frame->data[1][(y0 >> vshift) * stride +
974 ((x0 >> hshift) << s->sps->pixel_shift)];
975 for (i = 0; i < (size * size); i++) {
976 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
978 s->hevcdsp.transform_add[log2_trafo_size-2](dst, coeffs, stride);
982 if (lc->tu.cross_pf) {
983 hls_cross_component_pred(s, 1);
985 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
986 if (lc->cu.pred_mode == MODE_INTRA) {
987 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
988 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 2);
991 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
992 log2_trafo_size_c, scan_idx_c, 2);
994 if (lc->tu.cross_pf) {
995 ptrdiff_t stride = s->frame->linesize[2];
996 int hshift = s->sps->hshift[2];
997 int vshift = s->sps->vshift[2];
998 int16_t *coeffs_y = lc->tu.coeffs[0];
999 int16_t *coeffs = lc->tu.coeffs[1];
1000 int size = 1 << log2_trafo_size_c;
1002 uint8_t *dst = &s->frame->data[2][(y0 >> vshift) * stride +
1003 ((x0 >> hshift) << s->sps->pixel_shift)];
1004 for (i = 0; i < (size * size); i++) {
1005 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1007 s->hevcdsp.transform_add[log2_trafo_size-2](dst, coeffs, stride);
1010 } else if (blk_idx == 3) {
1011 int trafo_size_h = 1 << (log2_trafo_size + 1);
1012 int trafo_size_v = 1 << (log2_trafo_size + s->sps->vshift[1]);
1013 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1014 if (lc->cu.pred_mode == MODE_INTRA) {
1015 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1016 trafo_size_h, trafo_size_v);
1017 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 1);
1020 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1021 log2_trafo_size, scan_idx_c, 1);
1023 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1024 if (lc->cu.pred_mode == MODE_INTRA) {
1025 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1026 trafo_size_h, trafo_size_v);
1027 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 2);
1030 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1031 log2_trafo_size, scan_idx_c, 2);
1034 } else if (lc->cu.pred_mode == MODE_INTRA) {
1035 if (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3) {
1036 int trafo_size_h = 1 << (log2_trafo_size_c + s->sps->hshift[1]);
1037 int trafo_size_v = 1 << (log2_trafo_size_c + s->sps->vshift[1]);
1038 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size_h, trafo_size_v);
1039 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 1);
1040 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 2);
1041 if (s->sps->chroma_format_idc == 2) {
1042 ff_hevc_set_neighbour_available(s, x0, y0 + (1 << log2_trafo_size_c),
1043 trafo_size_h, trafo_size_v);
1044 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 1);
1045 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 2);
1047 } else if (blk_idx == 3) {
1048 int trafo_size_h = 1 << (log2_trafo_size + 1);
1049 int trafo_size_v = 1 << (log2_trafo_size + s->sps->vshift[1]);
1050 ff_hevc_set_neighbour_available(s, xBase, yBase,
1051 trafo_size_h, trafo_size_v);
1052 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1053 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1054 if (s->sps->chroma_format_idc == 2) {
1055 ff_hevc_set_neighbour_available(s, xBase, yBase + (1 << (log2_trafo_size)),
1056 trafo_size_h, trafo_size_v);
1057 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 1);
1058 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 2);
1066 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1068 int cb_size = 1 << log2_cb_size;
1069 int log2_min_pu_size = s->sps->log2_min_pu_size;
1071 int min_pu_width = s->sps->min_pu_width;
1072 int x_end = FFMIN(x0 + cb_size, s->sps->width);
1073 int y_end = FFMIN(y0 + cb_size, s->sps->height);
1076 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1077 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1078 s->is_pcm[i + j * min_pu_width] = 2;
1081 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1082 int xBase, int yBase, int cb_xBase, int cb_yBase,
1083 int log2_cb_size, int log2_trafo_size,
1084 int trafo_depth, int blk_idx,
1085 const int *base_cbf_cb, const int *base_cbf_cr)
1087 HEVCLocalContext *lc = s->HEVClc;
1088 uint8_t split_transform_flag;
1093 cbf_cb[0] = base_cbf_cb[0];
1094 cbf_cb[1] = base_cbf_cb[1];
1095 cbf_cr[0] = base_cbf_cr[0];
1096 cbf_cr[1] = base_cbf_cr[1];
1098 if (lc->cu.intra_split_flag) {
1099 if (trafo_depth == 1) {
1100 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1101 if (s->sps->chroma_format_idc == 3) {
1102 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[blk_idx];
1103 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[blk_idx];
1105 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1106 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1110 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[0];
1111 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1112 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1115 if (log2_trafo_size <= s->sps->log2_max_trafo_size &&
1116 log2_trafo_size > s->sps->log2_min_tb_size &&
1117 trafo_depth < lc->cu.max_trafo_depth &&
1118 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1119 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1121 int inter_split = s->sps->max_transform_hierarchy_depth_inter == 0 &&
1122 lc->cu.pred_mode == MODE_INTER &&
1123 lc->cu.part_mode != PART_2Nx2N &&
1126 split_transform_flag = log2_trafo_size > s->sps->log2_max_trafo_size ||
1127 (lc->cu.intra_split_flag && trafo_depth == 0) ||
1131 if (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3) {
1132 if (trafo_depth == 0 || cbf_cb[0]) {
1133 cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1134 if (s->sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1135 cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1137 } else if (trafo_depth == 0) {
1142 if (trafo_depth == 0 || cbf_cr[0]) {
1143 cbf_cr[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1144 if (s->sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1145 cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1147 } else if (trafo_depth == 0) {
1153 if (split_transform_flag) {
1154 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1155 const int x1 = x0 + trafo_size_split;
1156 const int y1 = y0 + trafo_size_split;
1158 #define SUBDIVIDE(x, y, idx) \
1160 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1161 log2_trafo_size - 1, trafo_depth + 1, idx, \
1167 SUBDIVIDE(x0, y0, 0);
1168 SUBDIVIDE(x1, y0, 1);
1169 SUBDIVIDE(x0, y1, 2);
1170 SUBDIVIDE(x1, y1, 3);
1174 int min_tu_size = 1 << s->sps->log2_min_tb_size;
1175 int log2_min_tu_size = s->sps->log2_min_tb_size;
1176 int min_tu_width = s->sps->min_tb_width;
1179 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1180 cbf_cb[0] || cbf_cr[0] ||
1181 (s->sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1182 cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1185 ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1186 log2_cb_size, log2_trafo_size, trafo_depth,
1187 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1190 // TODO: store cbf_luma somewhere else
1193 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1194 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1195 int x_tu = (x0 + j) >> log2_min_tu_size;
1196 int y_tu = (y0 + i) >> log2_min_tu_size;
1197 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1200 if (!s->sh.disable_deblocking_filter_flag) {
1201 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1202 if (s->pps->transquant_bypass_enable_flag &&
1203 lc->cu.cu_transquant_bypass_flag)
1204 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1210 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1212 HEVCLocalContext *lc = s->HEVClc;
1214 int cb_size = 1 << log2_cb_size;
1215 int stride0 = s->frame->linesize[0];
1216 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->sps->pixel_shift)];
1217 int stride1 = s->frame->linesize[1];
1218 uint8_t *dst1 = &s->frame->data[1][(y0 >> s->sps->vshift[1]) * stride1 + ((x0 >> s->sps->hshift[1]) << s->sps->pixel_shift)];
1219 int stride2 = s->frame->linesize[2];
1220 uint8_t *dst2 = &s->frame->data[2][(y0 >> s->sps->vshift[2]) * stride2 + ((x0 >> s->sps->hshift[2]) << s->sps->pixel_shift)];
1222 int length = cb_size * cb_size * s->sps->pcm.bit_depth +
1223 (((cb_size >> s->sps->hshift[1]) * (cb_size >> s->sps->vshift[1])) +
1224 ((cb_size >> s->sps->hshift[2]) * (cb_size >> s->sps->vshift[2]))) *
1225 s->sps->pcm.bit_depth_chroma;
1226 const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1229 if (!s->sh.disable_deblocking_filter_flag)
1230 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1232 ret = init_get_bits(&gb, pcm, length);
1236 s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size, &gb, s->sps->pcm.bit_depth);
1237 s->hevcdsp.put_pcm(dst1, stride1,
1238 cb_size >> s->sps->hshift[1],
1239 cb_size >> s->sps->vshift[1],
1240 &gb, s->sps->pcm.bit_depth_chroma);
1241 s->hevcdsp.put_pcm(dst2, stride2,
1242 cb_size >> s->sps->hshift[2],
1243 cb_size >> s->sps->vshift[2],
1244 &gb, s->sps->pcm.bit_depth_chroma);
1249 * 8.5.3.2.2.1 Luma sample unidirectional interpolation process
1251 * @param s HEVC decoding context
1252 * @param dst target buffer for block data at block position
1253 * @param dststride stride of the dst buffer
1254 * @param ref reference picture buffer at origin (0, 0)
1255 * @param mv motion vector (relative to block position) to get pixel data from
1256 * @param x_off horizontal position of block from origin (0, 0)
1257 * @param y_off vertical position of block from origin (0, 0)
1258 * @param block_w width of block
1259 * @param block_h height of block
1260 * @param luma_weight weighting factor applied to the luma prediction
1261 * @param luma_offset additive offset applied to the luma prediction value
1264 static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1265 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1266 int block_w, int block_h, int luma_weight, int luma_offset)
1268 HEVCLocalContext *lc = s->HEVClc;
1269 uint8_t *src = ref->data[0];
1270 ptrdiff_t srcstride = ref->linesize[0];
1271 int pic_width = s->sps->width;
1272 int pic_height = s->sps->height;
1275 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1276 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1277 int idx = ff_hevc_pel_weight[block_w];
1279 x_off += mv->x >> 2;
1280 y_off += mv->y >> 2;
1281 src += y_off * srcstride + (x_off << s->sps->pixel_shift);
1283 if (x_off < QPEL_EXTRA_BEFORE || y_off < QPEL_EXTRA_AFTER ||
1284 x_off >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1285 y_off >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1286 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1287 int offset = QPEL_EXTRA_BEFORE * srcstride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1288 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1290 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1291 edge_emu_stride, srcstride,
1292 block_w + QPEL_EXTRA,
1293 block_h + QPEL_EXTRA,
1294 x_off - QPEL_EXTRA_BEFORE, y_off - QPEL_EXTRA_BEFORE,
1295 pic_width, pic_height);
1296 src = lc->edge_emu_buffer + buf_offset;
1297 srcstride = edge_emu_stride;
1301 s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride, src, srcstride,
1302 block_h, mx, my, block_w);
1304 s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride, src, srcstride,
1305 block_h, s->sh.luma_log2_weight_denom,
1306 luma_weight, luma_offset, mx, my, block_w);
1310 * 8.5.3.2.2.1 Luma sample bidirectional interpolation process
1312 * @param s HEVC decoding context
1313 * @param dst target buffer for block data at block position
1314 * @param dststride stride of the dst buffer
1315 * @param ref0 reference picture0 buffer at origin (0, 0)
1316 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1317 * @param x_off horizontal position of block from origin (0, 0)
1318 * @param y_off vertical position of block from origin (0, 0)
1319 * @param block_w width of block
1320 * @param block_h height of block
1321 * @param ref1 reference picture1 buffer at origin (0, 0)
1322 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1323 * @param current_mv current motion vector structure
1325 static void luma_mc_bi(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1326 AVFrame *ref0, const Mv *mv0, int x_off, int y_off,
1327 int block_w, int block_h, AVFrame *ref1, const Mv *mv1, struct MvField *current_mv)
1329 HEVCLocalContext *lc = s->HEVClc;
1330 DECLARE_ALIGNED(16, int16_t, tmp[MAX_PB_SIZE * MAX_PB_SIZE]);
1331 ptrdiff_t src0stride = ref0->linesize[0];
1332 ptrdiff_t src1stride = ref1->linesize[0];
1333 int pic_width = s->sps->width;
1334 int pic_height = s->sps->height;
1335 int mx0 = mv0->x & 3;
1336 int my0 = mv0->y & 3;
1337 int mx1 = mv1->x & 3;
1338 int my1 = mv1->y & 3;
1339 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1340 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1341 int x_off0 = x_off + (mv0->x >> 2);
1342 int y_off0 = y_off + (mv0->y >> 2);
1343 int x_off1 = x_off + (mv1->x >> 2);
1344 int y_off1 = y_off + (mv1->y >> 2);
1345 int idx = ff_hevc_pel_weight[block_w];
1347 uint8_t *src0 = ref0->data[0] + y_off0 * src0stride + (int)((unsigned)x_off0 << s->sps->pixel_shift);
1348 uint8_t *src1 = ref1->data[0] + y_off1 * src1stride + (int)((unsigned)x_off1 << s->sps->pixel_shift);
1350 if (x_off0 < QPEL_EXTRA_BEFORE || y_off0 < QPEL_EXTRA_AFTER ||
1351 x_off0 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1352 y_off0 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1353 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1354 int offset = QPEL_EXTRA_BEFORE * src0stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1355 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1357 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset,
1358 edge_emu_stride, src0stride,
1359 block_w + QPEL_EXTRA,
1360 block_h + QPEL_EXTRA,
1361 x_off0 - QPEL_EXTRA_BEFORE, y_off0 - QPEL_EXTRA_BEFORE,
1362 pic_width, pic_height);
1363 src0 = lc->edge_emu_buffer + buf_offset;
1364 src0stride = edge_emu_stride;
1367 if (x_off1 < QPEL_EXTRA_BEFORE || y_off1 < QPEL_EXTRA_AFTER ||
1368 x_off1 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1369 y_off1 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1370 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1371 int offset = QPEL_EXTRA_BEFORE * src1stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1372 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1374 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src1 - offset,
1375 edge_emu_stride, src1stride,
1376 block_w + QPEL_EXTRA,
1377 block_h + QPEL_EXTRA,
1378 x_off1 - QPEL_EXTRA_BEFORE, y_off1 - QPEL_EXTRA_BEFORE,
1379 pic_width, pic_height);
1380 src1 = lc->edge_emu_buffer2 + buf_offset;
1381 src1stride = edge_emu_stride;
1384 s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](tmp, MAX_PB_SIZE, src0, src0stride,
1385 block_h, mx0, my0, block_w);
1387 s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, tmp, MAX_PB_SIZE,
1388 block_h, mx1, my1, block_w);
1390 s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, tmp, MAX_PB_SIZE,
1391 block_h, s->sh.luma_log2_weight_denom,
1392 s->sh.luma_weight_l0[current_mv->ref_idx[0]],
1393 s->sh.luma_weight_l1[current_mv->ref_idx[1]],
1394 s->sh.luma_offset_l0[current_mv->ref_idx[0]],
1395 s->sh.luma_offset_l1[current_mv->ref_idx[1]],
1401 * 8.5.3.2.2.2 Chroma sample uniprediction interpolation process
1403 * @param s HEVC decoding context
1404 * @param dst1 target buffer for block data at block position (U plane)
1405 * @param dst2 target buffer for block data at block position (V plane)
1406 * @param dststride stride of the dst1 and dst2 buffers
1407 * @param ref reference picture buffer at origin (0, 0)
1408 * @param mv motion vector (relative to block position) to get pixel data from
1409 * @param x_off horizontal position of block from origin (0, 0)
1410 * @param y_off vertical position of block from origin (0, 0)
1411 * @param block_w width of block
1412 * @param block_h height of block
1413 * @param chroma_weight weighting factor applied to the chroma prediction
1414 * @param chroma_offset additive offset applied to the chroma prediction value
1417 static void chroma_mc_uni(HEVCContext *s, uint8_t *dst0,
1418 ptrdiff_t dststride, uint8_t *src0, ptrdiff_t srcstride, int reflist,
1419 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int chroma_weight, int chroma_offset)
1421 HEVCLocalContext *lc = s->HEVClc;
1422 int pic_width = s->sps->width >> s->sps->hshift[1];
1423 int pic_height = s->sps->height >> s->sps->vshift[1];
1424 const Mv *mv = ¤t_mv->mv[reflist];
1425 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1426 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1427 int idx = ff_hevc_pel_weight[block_w];
1428 int hshift = s->sps->hshift[1];
1429 int vshift = s->sps->vshift[1];
1430 intptr_t mx = mv->x & ((1 << (2 + hshift)) - 1);
1431 intptr_t my = mv->y & ((1 << (2 + vshift)) - 1);
1432 intptr_t _mx = mx << (1 - hshift);
1433 intptr_t _my = my << (1 - vshift);
1435 x_off += mv->x >> (2 + hshift);
1436 y_off += mv->y >> (2 + vshift);
1437 src0 += y_off * srcstride + (x_off << s->sps->pixel_shift);
1439 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1440 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1441 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1442 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1443 int offset0 = EPEL_EXTRA_BEFORE * (srcstride + (1 << s->sps->pixel_shift));
1444 int buf_offset0 = EPEL_EXTRA_BEFORE *
1445 (edge_emu_stride + (1 << s->sps->pixel_shift));
1446 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset0,
1447 edge_emu_stride, srcstride,
1448 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1449 x_off - EPEL_EXTRA_BEFORE,
1450 y_off - EPEL_EXTRA_BEFORE,
1451 pic_width, pic_height);
1453 src0 = lc->edge_emu_buffer + buf_offset0;
1454 srcstride = edge_emu_stride;
1457 s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1458 block_h, _mx, _my, block_w);
1460 s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1461 block_h, s->sh.chroma_log2_weight_denom,
1462 chroma_weight, chroma_offset, _mx, _my, block_w);
1466 * 8.5.3.2.2.2 Chroma sample bidirectional interpolation process
1468 * @param s HEVC decoding context
1469 * @param dst target buffer for block data at block position
1470 * @param dststride stride of the dst buffer
1471 * @param ref0 reference picture0 buffer at origin (0, 0)
1472 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1473 * @param x_off horizontal position of block from origin (0, 0)
1474 * @param y_off vertical position of block from origin (0, 0)
1475 * @param block_w width of block
1476 * @param block_h height of block
1477 * @param ref1 reference picture1 buffer at origin (0, 0)
1478 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1479 * @param current_mv current motion vector structure
1480 * @param cidx chroma component(cb, cr)
1482 static void chroma_mc_bi(HEVCContext *s, uint8_t *dst0, ptrdiff_t dststride, AVFrame *ref0, AVFrame *ref1,
1483 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int cidx)
1485 DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1486 int tmpstride = MAX_PB_SIZE;
1487 HEVCLocalContext *lc = s->HEVClc;
1488 uint8_t *src1 = ref0->data[cidx+1];
1489 uint8_t *src2 = ref1->data[cidx+1];
1490 ptrdiff_t src1stride = ref0->linesize[cidx+1];
1491 ptrdiff_t src2stride = ref1->linesize[cidx+1];
1492 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1493 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1494 int pic_width = s->sps->width >> s->sps->hshift[1];
1495 int pic_height = s->sps->height >> s->sps->vshift[1];
1496 Mv *mv0 = ¤t_mv->mv[0];
1497 Mv *mv1 = ¤t_mv->mv[1];
1498 int hshift = s->sps->hshift[1];
1499 int vshift = s->sps->vshift[1];
1501 intptr_t mx0 = mv0->x & ((1 << (2 + hshift)) - 1);
1502 intptr_t my0 = mv0->y & ((1 << (2 + vshift)) - 1);
1503 intptr_t mx1 = mv1->x & ((1 << (2 + hshift)) - 1);
1504 intptr_t my1 = mv1->y & ((1 << (2 + vshift)) - 1);
1505 intptr_t _mx0 = mx0 << (1 - hshift);
1506 intptr_t _my0 = my0 << (1 - vshift);
1507 intptr_t _mx1 = mx1 << (1 - hshift);
1508 intptr_t _my1 = my1 << (1 - vshift);
1510 int x_off0 = x_off + (mv0->x >> (2 + hshift));
1511 int y_off0 = y_off + (mv0->y >> (2 + vshift));
1512 int x_off1 = x_off + (mv1->x >> (2 + hshift));
1513 int y_off1 = y_off + (mv1->y >> (2 + vshift));
1514 int idx = ff_hevc_pel_weight[block_w];
1515 src1 += y_off0 * src1stride + (int)((unsigned)x_off0 << s->sps->pixel_shift);
1516 src2 += y_off1 * src2stride + (int)((unsigned)x_off1 << s->sps->pixel_shift);
1518 if (x_off0 < EPEL_EXTRA_BEFORE || y_off0 < EPEL_EXTRA_AFTER ||
1519 x_off0 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1520 y_off0 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1521 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1522 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->sps->pixel_shift));
1523 int buf_offset1 = EPEL_EXTRA_BEFORE *
1524 (edge_emu_stride + (1 << s->sps->pixel_shift));
1526 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1527 edge_emu_stride, src1stride,
1528 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1529 x_off0 - EPEL_EXTRA_BEFORE,
1530 y_off0 - EPEL_EXTRA_BEFORE,
1531 pic_width, pic_height);
1533 src1 = lc->edge_emu_buffer + buf_offset1;
1534 src1stride = edge_emu_stride;
1537 if (x_off1 < EPEL_EXTRA_BEFORE || y_off1 < EPEL_EXTRA_AFTER ||
1538 x_off1 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1539 y_off1 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1540 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1541 int offset1 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->sps->pixel_shift));
1542 int buf_offset1 = EPEL_EXTRA_BEFORE *
1543 (edge_emu_stride + (1 << s->sps->pixel_shift));
1545 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src2 - offset1,
1546 edge_emu_stride, src2stride,
1547 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1548 x_off1 - EPEL_EXTRA_BEFORE,
1549 y_off1 - EPEL_EXTRA_BEFORE,
1550 pic_width, pic_height);
1552 src2 = lc->edge_emu_buffer2 + buf_offset1;
1553 src2stride = edge_emu_stride;
1556 s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](tmp, tmpstride, src1, src1stride,
1557 block_h, _mx0, _my0, block_w);
1559 s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1560 src2, src2stride, tmp, tmpstride,
1561 block_h, _mx1, _my1, block_w);
1563 s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1564 src2, src2stride, tmp, tmpstride,
1566 s->sh.chroma_log2_weight_denom,
1567 s->sh.chroma_weight_l0[current_mv->ref_idx[0]][cidx],
1568 s->sh.chroma_weight_l1[current_mv->ref_idx[1]][cidx],
1569 s->sh.chroma_offset_l0[current_mv->ref_idx[0]][cidx],
1570 s->sh.chroma_offset_l1[current_mv->ref_idx[1]][cidx],
1571 _mx1, _my1, block_w);
1574 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1575 const Mv *mv, int y0, int height)
1577 int y = (mv->y >> 2) + y0 + height + 9;
1579 if (s->threads_type == FF_THREAD_FRAME )
1580 ff_thread_await_progress(&ref->tf, y, 0);
1583 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1585 int log2_cb_size, int partIdx, int idx)
1587 #define POS(c_idx, x, y) \
1588 &s->frame->data[c_idx][((y) >> s->sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1589 (((x) >> s->sps->hshift[c_idx]) << s->sps->pixel_shift)]
1590 HEVCLocalContext *lc = s->HEVClc;
1592 struct MvField current_mv = {{{ 0 }}};
1594 int min_pu_width = s->sps->min_pu_width;
1596 MvField *tab_mvf = s->ref->tab_mvf;
1597 RefPicList *refPicList = s->ref->refPicList;
1598 HEVCFrame *ref0, *ref1;
1599 uint8_t *dst0 = POS(0, x0, y0);
1600 uint8_t *dst1 = POS(1, x0, y0);
1601 uint8_t *dst2 = POS(2, x0, y0);
1602 int log2_min_cb_size = s->sps->log2_min_cb_size;
1603 int min_cb_width = s->sps->min_cb_width;
1604 int x_cb = x0 >> log2_min_cb_size;
1605 int y_cb = y0 >> log2_min_cb_size;
1611 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
1612 if (s->sh.max_num_merge_cand > 1)
1613 merge_idx = ff_hevc_merge_idx_decode(s);
1617 ff_hevc_luma_mv_merge_mode(s, x0, y0,
1620 log2_cb_size, partIdx,
1621 merge_idx, ¤t_mv);
1622 x_pu = x0 >> s->sps->log2_min_pu_size;
1623 y_pu = y0 >> s->sps->log2_min_pu_size;
1625 for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1626 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1627 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1628 } else { /* MODE_INTER */
1629 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1630 if (lc->pu.merge_flag) {
1631 if (s->sh.max_num_merge_cand > 1)
1632 merge_idx = ff_hevc_merge_idx_decode(s);
1636 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1637 partIdx, merge_idx, ¤t_mv);
1638 x_pu = x0 >> s->sps->log2_min_pu_size;
1639 y_pu = y0 >> s->sps->log2_min_pu_size;
1641 for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1642 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1643 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1645 enum InterPredIdc inter_pred_idc = PRED_L0;
1646 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1647 current_mv.pred_flag = 0;
1648 if (s->sh.slice_type == B_SLICE)
1649 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1651 if (inter_pred_idc != PRED_L1) {
1652 if (s->sh.nb_refs[L0]) {
1653 ref_idx[0] = ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1654 current_mv.ref_idx[0] = ref_idx[0];
1656 current_mv.pred_flag = PF_L0;
1657 ff_hevc_hls_mvd_coding(s, x0, y0, 0);
1658 mvp_flag[0] = ff_hevc_mvp_lx_flag_decode(s);
1659 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1660 partIdx, merge_idx, ¤t_mv,
1662 current_mv.mv[0].x += lc->pu.mvd.x;
1663 current_mv.mv[0].y += lc->pu.mvd.y;
1666 if (inter_pred_idc != PRED_L0) {
1667 if (s->sh.nb_refs[L1]) {
1668 ref_idx[1] = ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1669 current_mv.ref_idx[1] = ref_idx[1];
1672 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1673 AV_ZERO32(&lc->pu.mvd);
1675 ff_hevc_hls_mvd_coding(s, x0, y0, 1);
1678 current_mv.pred_flag += PF_L1;
1679 mvp_flag[1] = ff_hevc_mvp_lx_flag_decode(s);
1680 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1681 partIdx, merge_idx, ¤t_mv,
1683 current_mv.mv[1].x += lc->pu.mvd.x;
1684 current_mv.mv[1].y += lc->pu.mvd.y;
1687 x_pu = x0 >> s->sps->log2_min_pu_size;
1688 y_pu = y0 >> s->sps->log2_min_pu_size;
1690 for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1691 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1692 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1696 if (current_mv.pred_flag & PF_L0) {
1697 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1700 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1702 if (current_mv.pred_flag & PF_L1) {
1703 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1706 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1709 if (current_mv.pred_flag == PF_L0) {
1710 int x0_c = x0 >> s->sps->hshift[1];
1711 int y0_c = y0 >> s->sps->vshift[1];
1712 int nPbW_c = nPbW >> s->sps->hshift[1];
1713 int nPbH_c = nPbH >> s->sps->vshift[1];
1715 luma_mc_uni(s, dst0, s->frame->linesize[0], ref0->frame,
1716 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1717 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1718 s->sh.luma_offset_l0[current_mv.ref_idx[0]]);
1720 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref0->frame->data[1], ref0->frame->linesize[1],
1721 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1722 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]);
1723 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref0->frame->data[2], ref0->frame->linesize[2],
1724 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1725 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]);
1726 } else if (current_mv.pred_flag == PF_L1) {
1727 int x0_c = x0 >> s->sps->hshift[1];
1728 int y0_c = y0 >> s->sps->vshift[1];
1729 int nPbW_c = nPbW >> s->sps->hshift[1];
1730 int nPbH_c = nPbH >> s->sps->vshift[1];
1732 luma_mc_uni(s, dst0, s->frame->linesize[0], ref1->frame,
1733 ¤t_mv.mv[1], x0, y0, nPbW, nPbH,
1734 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1735 s->sh.luma_offset_l1[current_mv.ref_idx[1]]);
1737 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
1738 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1739 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]);
1741 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
1742 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1743 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]);
1744 } else if (current_mv.pred_flag == PF_BI) {
1745 int x0_c = x0 >> s->sps->hshift[1];
1746 int y0_c = y0 >> s->sps->vshift[1];
1747 int nPbW_c = nPbW >> s->sps->hshift[1];
1748 int nPbH_c = nPbH >> s->sps->vshift[1];
1750 luma_mc_bi(s, dst0, s->frame->linesize[0], ref0->frame,
1751 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1752 ref1->frame, ¤t_mv.mv[1], ¤t_mv);
1754 chroma_mc_bi(s, dst1, s->frame->linesize[1], ref0->frame, ref1->frame,
1755 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 0);
1757 chroma_mc_bi(s, dst2, s->frame->linesize[2], ref0->frame, ref1->frame,
1758 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1);
1765 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1766 int prev_intra_luma_pred_flag)
1768 HEVCLocalContext *lc = s->HEVClc;
1769 int x_pu = x0 >> s->sps->log2_min_pu_size;
1770 int y_pu = y0 >> s->sps->log2_min_pu_size;
1771 int min_pu_width = s->sps->min_pu_width;
1772 int size_in_pus = pu_size >> s->sps->log2_min_pu_size;
1773 int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1);
1774 int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1);
1776 int cand_up = (lc->ctb_up_flag || y0b) ?
1777 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1778 int cand_left = (lc->ctb_left_flag || x0b) ?
1779 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1781 int y_ctb = (y0 >> (s->sps->log2_ctb_size)) << (s->sps->log2_ctb_size);
1783 MvField *tab_mvf = s->ref->tab_mvf;
1784 int intra_pred_mode;
1788 // intra_pred_mode prediction does not cross vertical CTB boundaries
1789 if ((y0 - 1) < y_ctb)
1792 if (cand_left == cand_up) {
1793 if (cand_left < 2) {
1794 candidate[0] = INTRA_PLANAR;
1795 candidate[1] = INTRA_DC;
1796 candidate[2] = INTRA_ANGULAR_26;
1798 candidate[0] = cand_left;
1799 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1800 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1803 candidate[0] = cand_left;
1804 candidate[1] = cand_up;
1805 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1806 candidate[2] = INTRA_PLANAR;
1807 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1808 candidate[2] = INTRA_DC;
1810 candidate[2] = INTRA_ANGULAR_26;
1814 if (prev_intra_luma_pred_flag) {
1815 intra_pred_mode = candidate[lc->pu.mpm_idx];
1817 if (candidate[0] > candidate[1])
1818 FFSWAP(uint8_t, candidate[0], candidate[1]);
1819 if (candidate[0] > candidate[2])
1820 FFSWAP(uint8_t, candidate[0], candidate[2]);
1821 if (candidate[1] > candidate[2])
1822 FFSWAP(uint8_t, candidate[1], candidate[2]);
1824 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1825 for (i = 0; i < 3; i++)
1826 if (intra_pred_mode >= candidate[i])
1830 /* write the intra prediction units into the mv array */
1833 for (i = 0; i < size_in_pus; i++) {
1834 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1835 intra_pred_mode, size_in_pus);
1837 for (j = 0; j < size_in_pus; j++) {
1838 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag = PF_INTRA;
1842 return intra_pred_mode;
1845 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1846 int log2_cb_size, int ct_depth)
1848 int length = (1 << log2_cb_size) >> s->sps->log2_min_cb_size;
1849 int x_cb = x0 >> s->sps->log2_min_cb_size;
1850 int y_cb = y0 >> s->sps->log2_min_cb_size;
1853 for (y = 0; y < length; y++)
1854 memset(&s->tab_ct_depth[(y_cb + y) * s->sps->min_cb_width + x_cb],
1858 static const uint8_t tab_mode_idx[] = {
1859 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
1860 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
1862 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1865 HEVCLocalContext *lc = s->HEVClc;
1866 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1867 uint8_t prev_intra_luma_pred_flag[4];
1868 int split = lc->cu.part_mode == PART_NxN;
1869 int pb_size = (1 << log2_cb_size) >> split;
1870 int side = split + 1;
1874 for (i = 0; i < side; i++)
1875 for (j = 0; j < side; j++)
1876 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1878 for (i = 0; i < side; i++) {
1879 for (j = 0; j < side; j++) {
1880 if (prev_intra_luma_pred_flag[2 * i + j])
1881 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
1883 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
1885 lc->pu.intra_pred_mode[2 * i + j] =
1886 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1887 prev_intra_luma_pred_flag[2 * i + j]);
1891 if (s->sps->chroma_format_idc == 3) {
1892 for (i = 0; i < side; i++) {
1893 for (j = 0; j < side; j++) {
1894 lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1895 if (chroma_mode != 4) {
1896 if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode])
1897 lc->pu.intra_pred_mode_c[2 * i + j] = 34;
1899 lc->pu.intra_pred_mode_c[2 * i + j] = intra_chroma_table[chroma_mode];
1901 lc->pu.intra_pred_mode_c[2 * i + j] = lc->pu.intra_pred_mode[2 * i + j];
1905 } else if (s->sps->chroma_format_idc == 2) {
1907 lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1908 if (chroma_mode != 4) {
1909 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1912 mode_idx = intra_chroma_table[chroma_mode];
1914 mode_idx = lc->pu.intra_pred_mode[0];
1916 lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx];
1917 } else if (s->sps->chroma_format_idc != 0) {
1918 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1919 if (chroma_mode != 4) {
1920 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1921 lc->pu.intra_pred_mode_c[0] = 34;
1923 lc->pu.intra_pred_mode_c[0] = intra_chroma_table[chroma_mode];
1925 lc->pu.intra_pred_mode_c[0] = lc->pu.intra_pred_mode[0];
1930 static void intra_prediction_unit_default_value(HEVCContext *s,
1934 HEVCLocalContext *lc = s->HEVClc;
1935 int pb_size = 1 << log2_cb_size;
1936 int size_in_pus = pb_size >> s->sps->log2_min_pu_size;
1937 int min_pu_width = s->sps->min_pu_width;
1938 MvField *tab_mvf = s->ref->tab_mvf;
1939 int x_pu = x0 >> s->sps->log2_min_pu_size;
1940 int y_pu = y0 >> s->sps->log2_min_pu_size;
1943 if (size_in_pus == 0)
1945 for (j = 0; j < size_in_pus; j++)
1946 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
1947 if (lc->cu.pred_mode == MODE_INTRA)
1948 for (j = 0; j < size_in_pus; j++)
1949 for (k = 0; k < size_in_pus; k++)
1950 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].pred_flag = PF_INTRA;
1953 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
1955 int cb_size = 1 << log2_cb_size;
1956 HEVCLocalContext *lc = s->HEVClc;
1957 int log2_min_cb_size = s->sps->log2_min_cb_size;
1958 int length = cb_size >> log2_min_cb_size;
1959 int min_cb_width = s->sps->min_cb_width;
1960 int x_cb = x0 >> log2_min_cb_size;
1961 int y_cb = y0 >> log2_min_cb_size;
1962 int idx = log2_cb_size - 2;
1963 int qp_block_mask = (1<<(s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth)) - 1;
1968 lc->cu.rqt_root_cbf = 1;
1969 lc->cu.pred_mode = MODE_INTRA;
1970 lc->cu.part_mode = PART_2Nx2N;
1971 lc->cu.intra_split_flag = 0;
1972 lc->cu.pcm_flag = 0;
1974 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
1975 for (x = 0; x < 4; x++)
1976 lc->pu.intra_pred_mode[x] = 1;
1977 if (s->pps->transquant_bypass_enable_flag) {
1978 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
1979 if (lc->cu.cu_transquant_bypass_flag)
1980 set_deblocking_bypass(s, x0, y0, log2_cb_size);
1982 lc->cu.cu_transquant_bypass_flag = 0;
1984 if (s->sh.slice_type != I_SLICE) {
1985 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
1987 x = y_cb * min_cb_width + x_cb;
1988 for (y = 0; y < length; y++) {
1989 memset(&s->skip_flag[x], skip_flag, length);
1992 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
1994 x = y_cb * min_cb_width + x_cb;
1995 for (y = 0; y < length; y++) {
1996 memset(&s->skip_flag[x], 0, length);
2001 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2002 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2003 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2005 if (!s->sh.disable_deblocking_filter_flag)
2006 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2008 if (s->sh.slice_type != I_SLICE)
2009 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2010 if (lc->cu.pred_mode != MODE_INTRA ||
2011 log2_cb_size == s->sps->log2_min_cb_size) {
2012 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2013 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2014 lc->cu.pred_mode == MODE_INTRA;
2017 if (lc->cu.pred_mode == MODE_INTRA) {
2018 if (lc->cu.part_mode == PART_2Nx2N && s->sps->pcm_enabled_flag &&
2019 log2_cb_size >= s->sps->pcm.log2_min_pcm_cb_size &&
2020 log2_cb_size <= s->sps->pcm.log2_max_pcm_cb_size) {
2021 lc->cu.pcm_flag = ff_hevc_pcm_flag_decode(s);
2023 if (lc->cu.pcm_flag) {
2024 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2025 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2026 if (s->sps->pcm.loop_filter_disable_flag)
2027 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2032 intra_prediction_unit(s, x0, y0, log2_cb_size);
2035 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2036 switch (lc->cu.part_mode) {
2038 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2041 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0, idx);
2042 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2045 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2046 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2049 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0, idx);
2050 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2053 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2054 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2057 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0, idx - 2);
2058 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2061 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2062 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2065 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2066 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2067 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2068 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2073 if (!lc->cu.pcm_flag) {
2074 if (lc->cu.pred_mode != MODE_INTRA &&
2075 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2076 lc->cu.rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2078 if (lc->cu.rqt_root_cbf) {
2079 const static int cbf[2] = { 0 };
2080 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2081 s->sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2082 s->sps->max_transform_hierarchy_depth_inter;
2083 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2085 log2_cb_size, 0, 0, cbf, cbf);
2089 if (!s->sh.disable_deblocking_filter_flag)
2090 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2095 if (s->pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2096 ff_hevc_set_qPy(s, x0, y0, log2_cb_size);
2098 x = y_cb * min_cb_width + x_cb;
2099 for (y = 0; y < length; y++) {
2100 memset(&s->qp_y_tab[x], lc->qp_y, length);
2104 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2105 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2106 lc->qPy_pred = lc->qp_y;
2109 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct.depth);
2114 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2115 int log2_cb_size, int cb_depth)
2117 HEVCLocalContext *lc = s->HEVClc;
2118 const int cb_size = 1 << log2_cb_size;
2120 int qp_block_mask = (1<<(s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth)) - 1;
2123 lc->ct.depth = cb_depth;
2124 if (x0 + cb_size <= s->sps->width &&
2125 y0 + cb_size <= s->sps->height &&
2126 log2_cb_size > s->sps->log2_min_cb_size) {
2127 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2129 split_cu = (log2_cb_size > s->sps->log2_min_cb_size);
2131 if (s->pps->cu_qp_delta_enabled_flag &&
2132 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth) {
2133 lc->tu.is_cu_qp_delta_coded = 0;
2134 lc->tu.cu_qp_delta = 0;
2137 if (s->sh.cu_chroma_qp_offset_enabled_flag &&
2138 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_chroma_qp_offset_depth) {
2139 lc->tu.is_cu_chroma_qp_offset_coded = 0;
2143 const int cb_size_split = cb_size >> 1;
2144 const int x1 = x0 + cb_size_split;
2145 const int y1 = y0 + cb_size_split;
2149 more_data = hls_coding_quadtree(s, x0, y0, log2_cb_size - 1, cb_depth + 1);
2153 if (more_data && x1 < s->sps->width) {
2154 more_data = hls_coding_quadtree(s, x1, y0, log2_cb_size - 1, cb_depth + 1);
2158 if (more_data && y1 < s->sps->height) {
2159 more_data = hls_coding_quadtree(s, x0, y1, log2_cb_size - 1, cb_depth + 1);
2163 if (more_data && x1 < s->sps->width &&
2164 y1 < s->sps->height) {
2165 more_data = hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1);
2170 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2171 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2172 lc->qPy_pred = lc->qp_y;
2175 return ((x1 + cb_size_split) < s->sps->width ||
2176 (y1 + cb_size_split) < s->sps->height);
2180 ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2183 if ((!((x0 + cb_size) %
2184 (1 << (s->sps->log2_ctb_size))) ||
2185 (x0 + cb_size >= s->sps->width)) &&
2187 (1 << (s->sps->log2_ctb_size))) ||
2188 (y0 + cb_size >= s->sps->height))) {
2189 int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s);
2190 return !end_of_slice_flag;
2199 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2202 HEVCLocalContext *lc = s->HEVClc;
2203 int ctb_size = 1 << s->sps->log2_ctb_size;
2204 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2205 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2207 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2209 if (s->pps->entropy_coding_sync_enabled_flag) {
2210 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2211 lc->first_qp_group = 1;
2212 lc->end_of_tiles_x = s->sps->width;
2213 } else if (s->pps->tiles_enabled_flag) {
2214 if (ctb_addr_ts && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1]) {
2215 int idxX = s->pps->col_idxX[x_ctb >> s->sps->log2_ctb_size];
2216 lc->end_of_tiles_x = x_ctb + (s->pps->column_width[idxX] << s->sps->log2_ctb_size);
2217 lc->first_qp_group = 1;
2220 lc->end_of_tiles_x = s->sps->width;
2223 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->sps->height);
2225 lc->boundary_flags = 0;
2226 if (s->pps->tiles_enabled_flag) {
2227 if (x_ctb > 0 && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs-1]])
2228 lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2229 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2230 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2231 if (y_ctb > 0 && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs - s->sps->ctb_width]])
2232 lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2233 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->sps->ctb_width])
2234 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2236 if (!ctb_addr_in_slice > 0)
2237 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2238 if (ctb_addr_in_slice < s->sps->ctb_width)
2239 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2241 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2242 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2243 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]]));
2244 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]]));
2247 static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
2249 HEVCContext *s = avctxt->priv_data;
2250 int ctb_size = 1 << s->sps->log2_ctb_size;
2254 int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2256 if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) {
2257 av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n");
2258 return AVERROR_INVALIDDATA;
2261 if (s->sh.dependent_slice_segment_flag) {
2262 int prev_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2263 if (s->tab_slice_address[prev_rs] != s->sh.slice_addr) {
2264 av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n");
2265 return AVERROR_INVALIDDATA;
2269 while (more_data && ctb_addr_ts < s->sps->ctb_size) {
2270 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2272 x_ctb = (ctb_addr_rs % ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2273 y_ctb = (ctb_addr_rs / ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2274 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2276 ff_hevc_cabac_init(s, ctb_addr_ts);
2278 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2280 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2281 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2282 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2284 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2285 if (more_data < 0) {
2286 s->tab_slice_address[ctb_addr_rs] = -1;
2292 ff_hevc_save_states(s, ctb_addr_ts);
2293 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2296 if (x_ctb + ctb_size >= s->sps->width &&
2297 y_ctb + ctb_size >= s->sps->height)
2298 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2303 static int hls_slice_data(HEVCContext *s)
2311 s->avctx->execute(s->avctx, hls_decode_entry, arg, ret , 1, sizeof(int));
2314 static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int job, int self_id)
2316 HEVCContext *s1 = avctxt->priv_data, *s;
2317 HEVCLocalContext *lc;
2318 int ctb_size = 1<< s1->sps->log2_ctb_size;
2320 int *ctb_row_p = input_ctb_row;
2321 int ctb_row = ctb_row_p[job];
2322 int ctb_addr_rs = s1->sh.slice_ctb_addr_rs + ctb_row * ((s1->sps->width + ctb_size - 1) >> s1->sps->log2_ctb_size);
2323 int ctb_addr_ts = s1->pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2324 int thread = ctb_row % s1->threads_number;
2327 s = s1->sList[self_id];
2331 ret = init_get_bits8(&lc->gb, s->data + s->sh.offset[ctb_row - 1], s->sh.size[ctb_row - 1]);
2335 ff_init_cabac_decoder(&lc->cc, s->data + s->sh.offset[(ctb_row)-1], s->sh.size[ctb_row - 1]);
2338 while(more_data && ctb_addr_ts < s->sps->ctb_size) {
2339 int x_ctb = (ctb_addr_rs % s->sps->ctb_width) << s->sps->log2_ctb_size;
2340 int y_ctb = (ctb_addr_rs / s->sps->ctb_width) << s->sps->log2_ctb_size;
2342 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2344 ff_thread_await_progress2(s->avctx, ctb_row, thread, SHIFT_CTB_WPP);
2346 if (avpriv_atomic_int_get(&s1->wpp_err)){
2347 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2351 ff_hevc_cabac_init(s, ctb_addr_ts);
2352 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2353 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2355 if (more_data < 0) {
2356 s->tab_slice_address[ctb_addr_rs] = -1;
2362 ff_hevc_save_states(s, ctb_addr_ts);
2363 ff_thread_report_progress2(s->avctx, ctb_row, thread, 1);
2364 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2366 if (!more_data && (x_ctb+ctb_size) < s->sps->width && ctb_row != s->sh.num_entry_point_offsets) {
2367 avpriv_atomic_int_set(&s1->wpp_err, 1);
2368 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2372 if ((x_ctb+ctb_size) >= s->sps->width && (y_ctb+ctb_size) >= s->sps->height ) {
2373 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2374 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2377 ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2380 if(x_ctb >= s->sps->width) {
2384 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2389 static int hls_slice_data_wpp(HEVCContext *s, const uint8_t *nal, int length)
2391 HEVCLocalContext *lc = s->HEVClc;
2392 int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2393 int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2395 int startheader, cmpt = 0;
2400 ff_alloc_entries(s->avctx, s->sh.num_entry_point_offsets + 1);
2403 for (i = 1; i < s->threads_number; i++) {
2404 s->sList[i] = av_malloc(sizeof(HEVCContext));
2405 memcpy(s->sList[i], s, sizeof(HEVCContext));
2406 s->HEVClcList[i] = av_mallocz(sizeof(HEVCLocalContext));
2407 s->sList[i]->HEVClc = s->HEVClcList[i];
2411 offset = (lc->gb.index >> 3);
2413 for (j = 0, cmpt = 0, startheader = offset + s->sh.entry_point_offset[0]; j < s->skipped_bytes; j++) {
2414 if (s->skipped_bytes_pos[j] >= offset && s->skipped_bytes_pos[j] < startheader) {
2420 for (i = 1; i < s->sh.num_entry_point_offsets; i++) {
2421 offset += (s->sh.entry_point_offset[i - 1] - cmpt);
2422 for (j = 0, cmpt = 0, startheader = offset
2423 + s->sh.entry_point_offset[i]; j < s->skipped_bytes; j++) {
2424 if (s->skipped_bytes_pos[j] >= offset && s->skipped_bytes_pos[j] < startheader) {
2429 s->sh.size[i - 1] = s->sh.entry_point_offset[i] - cmpt;
2430 s->sh.offset[i - 1] = offset;
2433 if (s->sh.num_entry_point_offsets != 0) {
2434 offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt;
2435 s->sh.size[s->sh.num_entry_point_offsets - 1] = length - offset;
2436 s->sh.offset[s->sh.num_entry_point_offsets - 1] = offset;
2441 for (i = 1; i < s->threads_number; i++) {
2442 s->sList[i]->HEVClc->first_qp_group = 1;
2443 s->sList[i]->HEVClc->qp_y = s->sList[0]->HEVClc->qp_y;
2444 memcpy(s->sList[i], s, sizeof(HEVCContext));
2445 s->sList[i]->HEVClc = s->HEVClcList[i];
2448 avpriv_atomic_int_set(&s->wpp_err, 0);
2449 ff_reset_entries(s->avctx);
2451 for (i = 0; i <= s->sh.num_entry_point_offsets; i++) {
2456 if (s->pps->entropy_coding_sync_enabled_flag)
2457 s->avctx->execute2(s->avctx, (void *) hls_decode_entry_wpp, arg, ret, s->sh.num_entry_point_offsets + 1);
2459 for (i = 0; i <= s->sh.num_entry_point_offsets; i++)
2467 * @return AVERROR_INVALIDDATA if the packet is not a valid NAL unit,
2468 * 0 if the unit should be skipped, 1 otherwise
2470 static int hls_nal_unit(HEVCContext *s)
2472 GetBitContext *gb = &s->HEVClc->gb;
2475 if (get_bits1(gb) != 0)
2476 return AVERROR_INVALIDDATA;
2478 s->nal_unit_type = get_bits(gb, 6);
2480 nuh_layer_id = get_bits(gb, 6);
2481 s->temporal_id = get_bits(gb, 3) - 1;
2482 if (s->temporal_id < 0)
2483 return AVERROR_INVALIDDATA;
2485 av_log(s->avctx, AV_LOG_DEBUG,
2486 "nal_unit_type: %d, nuh_layer_id: %dtemporal_id: %d\n",
2487 s->nal_unit_type, nuh_layer_id, s->temporal_id);
2489 return nuh_layer_id == 0;
2492 static int set_side_data(HEVCContext *s)
2494 AVFrame *out = s->ref->frame;
2496 if (s->sei_frame_packing_present &&
2497 s->frame_packing_arrangement_type >= 3 &&
2498 s->frame_packing_arrangement_type <= 5 &&
2499 s->content_interpretation_type > 0 &&
2500 s->content_interpretation_type < 3) {
2501 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2503 return AVERROR(ENOMEM);
2505 switch (s->frame_packing_arrangement_type) {
2507 if (s->quincunx_subsampling)
2508 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2510 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2513 stereo->type = AV_STEREO3D_TOPBOTTOM;
2516 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2520 if (s->content_interpretation_type == 2)
2521 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2524 if (s->sei_display_orientation_present &&
2525 (s->sei_anticlockwise_rotation || s->sei_hflip || s->sei_vflip)) {
2526 double angle = s->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
2527 AVFrameSideData *rotation = av_frame_new_side_data(out,
2528 AV_FRAME_DATA_DISPLAYMATRIX,
2529 sizeof(int32_t) * 9);
2531 return AVERROR(ENOMEM);
2533 av_display_rotation_set((int32_t *)rotation->data, angle);
2534 av_display_matrix_flip((int32_t *)rotation->data,
2535 s->sei_vflip, s->sei_hflip);
2541 static int hevc_frame_start(HEVCContext *s)
2543 HEVCLocalContext *lc = s->HEVClc;
2544 int pic_size_in_ctb = ((s->sps->width >> s->sps->log2_min_cb_size) + 1) *
2545 ((s->sps->height >> s->sps->log2_min_cb_size) + 1);
2548 memset(s->horizontal_bs, 0, s->bs_width * s->bs_height);
2549 memset(s->vertical_bs, 0, s->bs_width * s->bs_height);
2550 memset(s->cbf_luma, 0, s->sps->min_tb_width * s->sps->min_tb_height);
2551 memset(s->is_pcm, 0, (s->sps->min_pu_width + 1) * (s->sps->min_pu_height + 1));
2552 memset(s->tab_slice_address, -1, pic_size_in_ctb * sizeof(*s->tab_slice_address));
2555 s->first_nal_type = s->nal_unit_type;
2557 if (s->pps->tiles_enabled_flag)
2558 lc->end_of_tiles_x = s->pps->column_width[0] << s->sps->log2_ctb_size;
2560 ret = ff_hevc_set_new_ref(s, &s->frame, s->poc);
2564 ret = ff_hevc_frame_rps(s);
2566 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2570 s->ref->frame->key_frame = IS_IRAP(s);
2572 ret = set_side_data(s);
2576 s->frame->pict_type = 3 - s->sh.slice_type;
2579 ff_hevc_bump_frame(s);
2581 av_frame_unref(s->output_frame);
2582 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2586 ff_thread_finish_setup(s->avctx);
2591 if (s->ref && s->threads_type == FF_THREAD_FRAME)
2592 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2597 static int decode_nal_unit(HEVCContext *s, const uint8_t *nal, int length)
2599 HEVCLocalContext *lc = s->HEVClc;
2600 GetBitContext *gb = &lc->gb;
2601 int ctb_addr_ts, ret;
2603 ret = init_get_bits8(gb, nal, length);
2607 ret = hls_nal_unit(s);
2609 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit %d, skipping.\n",
2615 switch (s->nal_unit_type) {
2617 ret = ff_hevc_decode_nal_vps(s);
2622 ret = ff_hevc_decode_nal_sps(s);
2627 ret = ff_hevc_decode_nal_pps(s);
2631 case NAL_SEI_PREFIX:
2632 case NAL_SEI_SUFFIX:
2633 ret = ff_hevc_decode_nal_sei(s);
2644 case NAL_BLA_W_RADL:
2646 case NAL_IDR_W_RADL:
2653 ret = hls_slice_header(s);
2657 if (s->max_ra == INT_MAX) {
2658 if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
2662 s->max_ra = INT_MIN;
2666 if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
2667 s->poc <= s->max_ra) {
2671 if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
2672 s->max_ra = INT_MIN;
2675 if (s->sh.first_slice_in_pic_flag) {
2676 ret = hevc_frame_start(s);
2679 } else if (!s->ref) {
2680 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2684 if (s->nal_unit_type != s->first_nal_type) {
2685 av_log(s->avctx, AV_LOG_ERROR,
2686 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2687 s->first_nal_type, s->nal_unit_type);
2688 return AVERROR_INVALIDDATA;
2691 if (!s->sh.dependent_slice_segment_flag &&
2692 s->sh.slice_type != I_SLICE) {
2693 ret = ff_hevc_slice_rpl(s);
2695 av_log(s->avctx, AV_LOG_WARNING,
2696 "Error constructing the reference lists for the current slice.\n");
2701 if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
2702 ctb_addr_ts = hls_slice_data_wpp(s, nal, length);
2704 ctb_addr_ts = hls_slice_data(s);
2705 if (ctb_addr_ts >= (s->sps->ctb_width * s->sps->ctb_height)) {
2709 if (ctb_addr_ts < 0) {
2716 s->seq_decode = (s->seq_decode + 1) & 0xff;
2717 s->max_ra = INT_MAX;
2723 av_log(s->avctx, AV_LOG_INFO,
2724 "Skipping NAL unit %d\n", s->nal_unit_type);
2729 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2734 /* FIXME: This is adapted from ff_h264_decode_nal, avoiding duplication
2735 * between these functions would be nice. */
2736 int ff_hevc_extract_rbsp(HEVCContext *s, const uint8_t *src, int length,
2742 s->skipped_bytes = 0;
2743 #define STARTCODE_TEST \
2744 if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \
2745 if (src[i + 2] != 3) { \
2746 /* startcode, so we must be past the end */ \
2751 #if HAVE_FAST_UNALIGNED
2752 #define FIND_FIRST_ZERO \
2753 if (i > 0 && !src[i]) \
2758 for (i = 0; i + 1 < length; i += 9) {
2759 if (!((~AV_RN64A(src + i) &
2760 (AV_RN64A(src + i) - 0x0100010001000101ULL)) &
2761 0x8000800080008080ULL))
2768 for (i = 0; i + 1 < length; i += 5) {
2769 if (!((~AV_RN32A(src + i) &
2770 (AV_RN32A(src + i) - 0x01000101U)) &
2777 #endif /* HAVE_FAST_64BIT */
2779 for (i = 0; i + 1 < length; i += 2) {
2782 if (i > 0 && src[i - 1] == 0)
2786 #endif /* HAVE_FAST_UNALIGNED */
2788 if (i >= length - 1) { // no escaped 0
2794 av_fast_malloc(&nal->rbsp_buffer, &nal->rbsp_buffer_size,
2795 length + FF_INPUT_BUFFER_PADDING_SIZE);
2796 if (!nal->rbsp_buffer)
2797 return AVERROR(ENOMEM);
2799 dst = nal->rbsp_buffer;
2801 memcpy(dst, src, i);
2803 while (si + 2 < length) {
2804 // remove escapes (very rare 1:2^22)
2805 if (src[si + 2] > 3) {
2806 dst[di++] = src[si++];
2807 dst[di++] = src[si++];
2808 } else if (src[si] == 0 && src[si + 1] == 0) {
2809 if (src[si + 2] == 3) { // escape
2815 if (s->skipped_bytes_pos_size < s->skipped_bytes) {
2816 s->skipped_bytes_pos_size *= 2;
2817 av_reallocp_array(&s->skipped_bytes_pos,
2818 s->skipped_bytes_pos_size,
2819 sizeof(*s->skipped_bytes_pos));
2820 if (!s->skipped_bytes_pos)
2821 return AVERROR(ENOMEM);
2823 if (s->skipped_bytes_pos)
2824 s->skipped_bytes_pos[s->skipped_bytes-1] = di - 1;
2826 } else // next start code
2830 dst[di++] = src[si++];
2833 dst[di++] = src[si++];
2836 memset(dst + di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2843 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2845 int i, consumed, ret = 0;
2848 s->last_eos = s->eos;
2851 /* split the input packet into NAL units, so we know the upper bound on the
2852 * number of slices in the frame */
2854 while (length >= 4) {
2856 int extract_length = 0;
2860 for (i = 0; i < s->nal_length_size; i++)
2861 extract_length = (extract_length << 8) | buf[i];
2862 buf += s->nal_length_size;
2863 length -= s->nal_length_size;
2865 if (extract_length > length) {
2866 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit size.\n");
2867 ret = AVERROR_INVALIDDATA;
2871 /* search start code */
2872 while (buf[0] != 0 || buf[1] != 0 || buf[2] != 1) {
2876 av_log(s->avctx, AV_LOG_ERROR, "No start code is found.\n");
2877 ret = AVERROR_INVALIDDATA;
2887 extract_length = length;
2889 if (s->nals_allocated < s->nb_nals + 1) {
2890 int new_size = s->nals_allocated + 1;
2891 HEVCNAL *tmp = av_realloc_array(s->nals, new_size, sizeof(*tmp));
2893 ret = AVERROR(ENOMEM);
2897 memset(s->nals + s->nals_allocated, 0,
2898 (new_size - s->nals_allocated) * sizeof(*tmp));
2899 av_reallocp_array(&s->skipped_bytes_nal, new_size, sizeof(*s->skipped_bytes_nal));
2900 av_reallocp_array(&s->skipped_bytes_pos_size_nal, new_size, sizeof(*s->skipped_bytes_pos_size_nal));
2901 av_reallocp_array(&s->skipped_bytes_pos_nal, new_size, sizeof(*s->skipped_bytes_pos_nal));
2902 s->skipped_bytes_pos_size_nal[s->nals_allocated] = 1024; // initial buffer size
2903 s->skipped_bytes_pos_nal[s->nals_allocated] = av_malloc_array(s->skipped_bytes_pos_size_nal[s->nals_allocated], sizeof(*s->skipped_bytes_pos));
2904 s->nals_allocated = new_size;
2906 s->skipped_bytes_pos_size = s->skipped_bytes_pos_size_nal[s->nb_nals];
2907 s->skipped_bytes_pos = s->skipped_bytes_pos_nal[s->nb_nals];
2908 nal = &s->nals[s->nb_nals];
2910 consumed = ff_hevc_extract_rbsp(s, buf, extract_length, nal);
2912 s->skipped_bytes_nal[s->nb_nals] = s->skipped_bytes;
2913 s->skipped_bytes_pos_size_nal[s->nb_nals] = s->skipped_bytes_pos_size;
2914 s->skipped_bytes_pos_nal[s->nb_nals++] = s->skipped_bytes_pos;
2922 ret = init_get_bits8(&s->HEVClc->gb, nal->data, nal->size);
2927 if (s->nal_unit_type == NAL_EOB_NUT ||
2928 s->nal_unit_type == NAL_EOS_NUT)
2935 /* parse the NAL units */
2936 for (i = 0; i < s->nb_nals; i++) {
2938 s->skipped_bytes = s->skipped_bytes_nal[i];
2939 s->skipped_bytes_pos = s->skipped_bytes_pos_nal[i];
2941 ret = decode_nal_unit(s, s->nals[i].data, s->nals[i].size);
2943 av_log(s->avctx, AV_LOG_WARNING,
2944 "Error parsing NAL unit #%d.\n", i);
2950 if (s->ref && s->threads_type == FF_THREAD_FRAME)
2951 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2956 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2959 for (i = 0; i < 16; i++)
2960 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
2963 static int verify_md5(HEVCContext *s, AVFrame *frame)
2965 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
2970 return AVERROR(EINVAL);
2972 pixel_shift = desc->comp[0].depth_minus1 > 7;
2974 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
2977 /* the checksums are LE, so we have to byteswap for >8bpp formats
2980 if (pixel_shift && !s->checksum_buf) {
2981 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
2982 FFMAX3(frame->linesize[0], frame->linesize[1],
2983 frame->linesize[2]));
2984 if (!s->checksum_buf)
2985 return AVERROR(ENOMEM);
2989 for (i = 0; frame->data[i]; i++) {
2990 int width = s->avctx->coded_width;
2991 int height = s->avctx->coded_height;
2992 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
2993 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
2996 av_md5_init(s->md5_ctx);
2997 for (j = 0; j < h; j++) {
2998 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
3001 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
3002 (const uint16_t *) src, w);
3003 src = s->checksum_buf;
3006 av_md5_update(s->md5_ctx, src, w << pixel_shift);
3008 av_md5_final(s->md5_ctx, md5);
3010 if (!memcmp(md5, s->md5[i], 16)) {
3011 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
3012 print_md5(s->avctx, AV_LOG_DEBUG, md5);
3013 av_log (s->avctx, AV_LOG_DEBUG, "; ");
3015 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
3016 print_md5(s->avctx, AV_LOG_ERROR, md5);
3017 av_log (s->avctx, AV_LOG_ERROR, " != ");
3018 print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
3019 av_log (s->avctx, AV_LOG_ERROR, "\n");
3020 return AVERROR_INVALIDDATA;
3024 av_log(s->avctx, AV_LOG_DEBUG, "\n");
3029 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
3033 HEVCContext *s = avctx->priv_data;
3036 ret = ff_hevc_output_frame(s, data, 1);
3045 ret = decode_nal_units(s, avpkt->data, avpkt->size);
3049 /* verify the SEI checksum */
3050 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
3052 ret = verify_md5(s, s->ref->frame);
3053 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
3054 ff_hevc_unref_frame(s, s->ref, ~0);
3060 if (s->is_decoded) {
3061 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
3065 if (s->output_frame->buf[0]) {
3066 av_frame_move_ref(data, s->output_frame);
3073 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
3077 ret = ff_thread_ref_frame(&dst->tf, &src->tf);
3081 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
3082 if (!dst->tab_mvf_buf)
3084 dst->tab_mvf = src->tab_mvf;
3086 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
3087 if (!dst->rpl_tab_buf)
3089 dst->rpl_tab = src->rpl_tab;
3091 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
3095 dst->poc = src->poc;
3096 dst->ctb_count = src->ctb_count;
3097 dst->window = src->window;
3098 dst->flags = src->flags;
3099 dst->sequence = src->sequence;
3103 ff_hevc_unref_frame(s, dst, ~0);
3104 return AVERROR(ENOMEM);
3107 static av_cold int hevc_decode_free(AVCodecContext *avctx)
3109 HEVCContext *s = avctx->priv_data;
3114 av_freep(&s->md5_ctx);
3116 for(i=0; i < s->nals_allocated; i++) {
3117 av_freep(&s->skipped_bytes_pos_nal[i]);
3119 av_freep(&s->skipped_bytes_pos_size_nal);
3120 av_freep(&s->skipped_bytes_nal);
3121 av_freep(&s->skipped_bytes_pos_nal);
3123 av_freep(&s->cabac_state);
3125 av_frame_free(&s->tmp_frame);
3126 av_frame_free(&s->output_frame);
3128 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3129 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3130 av_frame_free(&s->DPB[i].frame);
3133 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++)
3134 av_buffer_unref(&s->vps_list[i]);
3135 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++)
3136 av_buffer_unref(&s->sps_list[i]);
3137 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
3138 av_buffer_unref(&s->pps_list[i]);
3143 av_buffer_unref(&s->current_sps);
3145 av_freep(&s->sh.entry_point_offset);
3146 av_freep(&s->sh.offset);
3147 av_freep(&s->sh.size);
3149 for (i = 1; i < s->threads_number; i++) {
3150 HEVCLocalContext *lc = s->HEVClcList[i];
3152 av_freep(&s->HEVClcList[i]);
3153 av_freep(&s->sList[i]);
3156 if (s->HEVClc == s->HEVClcList[0])
3158 av_freep(&s->HEVClcList[0]);
3160 for (i = 0; i < s->nals_allocated; i++)
3161 av_freep(&s->nals[i].rbsp_buffer);
3163 s->nals_allocated = 0;
3168 static av_cold int hevc_init_context(AVCodecContext *avctx)
3170 HEVCContext *s = avctx->priv_data;
3175 s->HEVClc = av_mallocz(sizeof(HEVCLocalContext));
3178 s->HEVClcList[0] = s->HEVClc;
3181 s->cabac_state = av_malloc(HEVC_CONTEXTS);
3182 if (!s->cabac_state)
3185 s->tmp_frame = av_frame_alloc();
3189 s->output_frame = av_frame_alloc();
3190 if (!s->output_frame)
3193 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3194 s->DPB[i].frame = av_frame_alloc();
3195 if (!s->DPB[i].frame)
3197 s->DPB[i].tf.f = s->DPB[i].frame;
3200 s->max_ra = INT_MAX;
3202 s->md5_ctx = av_md5_alloc();
3206 ff_bswapdsp_init(&s->bdsp);
3208 s->context_initialized = 1;
3214 hevc_decode_free(avctx);
3215 return AVERROR(ENOMEM);
3218 static int hevc_update_thread_context(AVCodecContext *dst,
3219 const AVCodecContext *src)
3221 HEVCContext *s = dst->priv_data;
3222 HEVCContext *s0 = src->priv_data;
3225 if (!s->context_initialized) {
3226 ret = hevc_init_context(dst);
3231 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3232 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3233 if (s0->DPB[i].frame->buf[0]) {
3234 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3240 if (s->sps != s0->sps)
3242 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++) {
3243 av_buffer_unref(&s->vps_list[i]);
3244 if (s0->vps_list[i]) {
3245 s->vps_list[i] = av_buffer_ref(s0->vps_list[i]);
3246 if (!s->vps_list[i])
3247 return AVERROR(ENOMEM);
3251 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++) {
3252 av_buffer_unref(&s->sps_list[i]);
3253 if (s0->sps_list[i]) {
3254 s->sps_list[i] = av_buffer_ref(s0->sps_list[i]);
3255 if (!s->sps_list[i])
3256 return AVERROR(ENOMEM);
3260 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++) {
3261 av_buffer_unref(&s->pps_list[i]);
3262 if (s0->pps_list[i]) {
3263 s->pps_list[i] = av_buffer_ref(s0->pps_list[i]);
3264 if (!s->pps_list[i])
3265 return AVERROR(ENOMEM);
3269 av_buffer_unref(&s->current_sps);
3270 if (s0->current_sps) {
3271 s->current_sps = av_buffer_ref(s0->current_sps);
3272 if (!s->current_sps)
3273 return AVERROR(ENOMEM);
3276 if (s->sps != s0->sps)
3277 if ((ret = set_sps(s, s0->sps)) < 0)
3280 s->seq_decode = s0->seq_decode;
3281 s->seq_output = s0->seq_output;
3282 s->pocTid0 = s0->pocTid0;
3283 s->max_ra = s0->max_ra;
3286 s->is_nalff = s0->is_nalff;
3287 s->nal_length_size = s0->nal_length_size;
3289 s->threads_number = s0->threads_number;
3290 s->threads_type = s0->threads_type;
3293 s->seq_decode = (s->seq_decode + 1) & 0xff;
3294 s->max_ra = INT_MAX;
3300 static int hevc_decode_extradata(HEVCContext *s)
3302 AVCodecContext *avctx = s->avctx;
3306 bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
3308 if (avctx->extradata_size > 3 &&
3309 (avctx->extradata[0] || avctx->extradata[1] ||
3310 avctx->extradata[2] > 1)) {
3311 /* It seems the extradata is encoded as hvcC format.
3312 * Temporarily, we support configurationVersion==0 until 14496-15 3rd
3313 * is finalized. When finalized, configurationVersion will be 1 and we
3314 * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
3315 int i, j, num_arrays, nal_len_size;
3319 bytestream2_skip(&gb, 21);
3320 nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
3321 num_arrays = bytestream2_get_byte(&gb);
3323 /* nal units in the hvcC always have length coded with 2 bytes,
3324 * so put a fake nal_length_size = 2 while parsing them */
3325 s->nal_length_size = 2;
3327 /* Decode nal units from hvcC. */
3328 for (i = 0; i < num_arrays; i++) {
3329 int type = bytestream2_get_byte(&gb) & 0x3f;
3330 int cnt = bytestream2_get_be16(&gb);
3332 for (j = 0; j < cnt; j++) {
3333 // +2 for the nal size field
3334 int nalsize = bytestream2_peek_be16(&gb) + 2;
3335 if (bytestream2_get_bytes_left(&gb) < nalsize) {
3336 av_log(s->avctx, AV_LOG_ERROR,
3337 "Invalid NAL unit size in extradata.\n");
3338 return AVERROR_INVALIDDATA;
3341 ret = decode_nal_units(s, gb.buffer, nalsize);
3343 av_log(avctx, AV_LOG_ERROR,
3344 "Decoding nal unit %d %d from hvcC failed\n",
3348 bytestream2_skip(&gb, nalsize);
3352 /* Now store right nal length size, that will be used to parse
3354 s->nal_length_size = nal_len_size;
3357 ret = decode_nal_units(s, avctx->extradata, avctx->extradata_size);
3364 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3366 HEVCContext *s = avctx->priv_data;
3369 ff_init_cabac_states();
3371 avctx->internal->allocate_progress = 1;
3373 ret = hevc_init_context(avctx);
3377 s->enable_parallel_tiles = 0;
3378 s->picture_struct = 0;
3380 if(avctx->active_thread_type & FF_THREAD_SLICE)
3381 s->threads_number = avctx->thread_count;
3383 s->threads_number = 1;
3385 if (avctx->extradata_size > 0 && avctx->extradata) {
3386 ret = hevc_decode_extradata(s);
3388 hevc_decode_free(avctx);
3393 if((avctx->active_thread_type & FF_THREAD_FRAME) && avctx->thread_count > 1)
3394 s->threads_type = FF_THREAD_FRAME;
3396 s->threads_type = FF_THREAD_SLICE;
3401 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3403 HEVCContext *s = avctx->priv_data;
3406 memset(s, 0, sizeof(*s));
3408 ret = hevc_init_context(avctx);
3415 static void hevc_decode_flush(AVCodecContext *avctx)
3417 HEVCContext *s = avctx->priv_data;
3418 ff_hevc_flush_dpb(s);
3419 s->max_ra = INT_MAX;
3422 #define OFFSET(x) offsetof(HEVCContext, x)
3423 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3425 static const AVProfile profiles[] = {
3426 { FF_PROFILE_HEVC_MAIN, "Main" },
3427 { FF_PROFILE_HEVC_MAIN_10, "Main 10" },
3428 { FF_PROFILE_HEVC_MAIN_STILL_PICTURE, "Main Still Picture" },
3429 { FF_PROFILE_HEVC_REXT, "Rext" },
3430 { FF_PROFILE_UNKNOWN },
3433 static const AVOption options[] = {
3434 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3435 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3436 { "strict-displaywin", "stricly apply default display window size", OFFSET(apply_defdispwin),
3437 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3441 static const AVClass hevc_decoder_class = {
3442 .class_name = "HEVC decoder",
3443 .item_name = av_default_item_name,
3445 .version = LIBAVUTIL_VERSION_INT,
3448 AVCodec ff_hevc_decoder = {
3450 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3451 .type = AVMEDIA_TYPE_VIDEO,
3452 .id = AV_CODEC_ID_HEVC,
3453 .priv_data_size = sizeof(HEVCContext),
3454 .priv_class = &hevc_decoder_class,
3455 .init = hevc_decode_init,
3456 .close = hevc_decode_free,
3457 .decode = hevc_decode_frame,
3458 .flush = hevc_decode_flush,
3459 .update_thread_context = hevc_update_thread_context,
3460 .init_thread_copy = hevc_init_thread_copy,
3461 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY |
3462 CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS,
3463 .profiles = NULL_IF_CONFIG_SMALL(profiles),