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_mallocz(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];
146 int luma_log2_weight_denom;
148 luma_log2_weight_denom = get_ue_golomb_long(gb);
149 if (luma_log2_weight_denom < 0 || luma_log2_weight_denom > 7)
150 av_log(s->avctx, AV_LOG_ERROR, "luma_log2_weight_denom %d is invalid\n", luma_log2_weight_denom);
151 s->sh.luma_log2_weight_denom = av_clip_c(luma_log2_weight_denom, 0, 7);
152 if (s->sps->chroma_format_idc != 0) {
153 int delta = get_se_golomb(gb);
154 s->sh.chroma_log2_weight_denom = av_clip(s->sh.luma_log2_weight_denom + delta, 0, 7);
157 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
158 luma_weight_l0_flag[i] = get_bits1(gb);
159 if (!luma_weight_l0_flag[i]) {
160 s->sh.luma_weight_l0[i] = 1 << s->sh.luma_log2_weight_denom;
161 s->sh.luma_offset_l0[i] = 0;
164 if (s->sps->chroma_format_idc != 0) {
165 for (i = 0; i < s->sh.nb_refs[L0]; i++)
166 chroma_weight_l0_flag[i] = get_bits1(gb);
168 for (i = 0; i < s->sh.nb_refs[L0]; i++)
169 chroma_weight_l0_flag[i] = 0;
171 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
172 if (luma_weight_l0_flag[i]) {
173 int delta_luma_weight_l0 = get_se_golomb(gb);
174 s->sh.luma_weight_l0[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;
175 s->sh.luma_offset_l0[i] = get_se_golomb(gb);
177 if (chroma_weight_l0_flag[i]) {
178 for (j = 0; j < 2; j++) {
179 int delta_chroma_weight_l0 = get_se_golomb(gb);
180 int delta_chroma_offset_l0 = get_se_golomb(gb);
181 s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
182 s->sh.chroma_offset_l0[i][j] = av_clip((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j])
183 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
186 s->sh.chroma_weight_l0[i][0] = 1 << s->sh.chroma_log2_weight_denom;
187 s->sh.chroma_offset_l0[i][0] = 0;
188 s->sh.chroma_weight_l0[i][1] = 1 << s->sh.chroma_log2_weight_denom;
189 s->sh.chroma_offset_l0[i][1] = 0;
192 if (s->sh.slice_type == B_SLICE) {
193 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
194 luma_weight_l1_flag[i] = get_bits1(gb);
195 if (!luma_weight_l1_flag[i]) {
196 s->sh.luma_weight_l1[i] = 1 << s->sh.luma_log2_weight_denom;
197 s->sh.luma_offset_l1[i] = 0;
200 if (s->sps->chroma_format_idc != 0) {
201 for (i = 0; i < s->sh.nb_refs[L1]; i++)
202 chroma_weight_l1_flag[i] = get_bits1(gb);
204 for (i = 0; i < s->sh.nb_refs[L1]; i++)
205 chroma_weight_l1_flag[i] = 0;
207 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
208 if (luma_weight_l1_flag[i]) {
209 int delta_luma_weight_l1 = get_se_golomb(gb);
210 s->sh.luma_weight_l1[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;
211 s->sh.luma_offset_l1[i] = get_se_golomb(gb);
213 if (chroma_weight_l1_flag[i]) {
214 for (j = 0; j < 2; j++) {
215 int delta_chroma_weight_l1 = get_se_golomb(gb);
216 int delta_chroma_offset_l1 = get_se_golomb(gb);
217 s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
218 s->sh.chroma_offset_l1[i][j] = av_clip((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j])
219 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
222 s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom;
223 s->sh.chroma_offset_l1[i][0] = 0;
224 s->sh.chroma_weight_l1[i][1] = 1 << s->sh.chroma_log2_weight_denom;
225 s->sh.chroma_offset_l1[i][1] = 0;
231 static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
233 const HEVCSPS *sps = s->sps;
234 int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
235 int prev_delta_msb = 0;
236 unsigned int nb_sps = 0, nb_sh;
240 if (!sps->long_term_ref_pics_present_flag)
243 if (sps->num_long_term_ref_pics_sps > 0)
244 nb_sps = get_ue_golomb_long(gb);
245 nb_sh = get_ue_golomb_long(gb);
247 if (nb_sh + (uint64_t)nb_sps > FF_ARRAY_ELEMS(rps->poc))
248 return AVERROR_INVALIDDATA;
250 rps->nb_refs = nb_sh + nb_sps;
252 for (i = 0; i < rps->nb_refs; i++) {
253 uint8_t delta_poc_msb_present;
256 uint8_t lt_idx_sps = 0;
258 if (sps->num_long_term_ref_pics_sps > 1)
259 lt_idx_sps = get_bits(gb, av_ceil_log2(sps->num_long_term_ref_pics_sps));
261 rps->poc[i] = sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
262 rps->used[i] = sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];
264 rps->poc[i] = get_bits(gb, sps->log2_max_poc_lsb);
265 rps->used[i] = get_bits1(gb);
268 delta_poc_msb_present = get_bits1(gb);
269 if (delta_poc_msb_present) {
270 int delta = get_ue_golomb_long(gb);
272 if (i && i != nb_sps)
273 delta += prev_delta_msb;
275 rps->poc[i] += s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
276 prev_delta_msb = delta;
283 static int get_buffer_sao(HEVCContext *s, AVFrame *frame, const HEVCSPS *sps)
287 frame->width = s->avctx->coded_width + 2;
288 frame->height = s->avctx->coded_height + 2;
289 if ((ret = ff_get_buffer(s->avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
291 for (i = 0; frame->data[i]; i++) {
292 int offset = frame->linesize[i] + (1 << sps->pixel_shift);
293 frame->data[i] += offset;
295 frame->width = s->avctx->coded_width;
296 frame->height = s->avctx->coded_height;
301 static int set_sps(HEVCContext *s, const HEVCSPS *sps)
304 unsigned int num = 0, den = 0;
307 ret = pic_arrays_init(s, sps);
311 s->avctx->coded_width = sps->width;
312 s->avctx->coded_height = sps->height;
313 s->avctx->width = sps->output_width;
314 s->avctx->height = sps->output_height;
315 s->avctx->pix_fmt = sps->pix_fmt;
316 s->avctx->has_b_frames = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics;
318 ff_set_sar(s->avctx, sps->vui.sar);
320 if (sps->vui.video_signal_type_present_flag)
321 s->avctx->color_range = sps->vui.video_full_range_flag ? AVCOL_RANGE_JPEG
324 s->avctx->color_range = AVCOL_RANGE_MPEG;
326 if (sps->vui.colour_description_present_flag) {
327 s->avctx->color_primaries = sps->vui.colour_primaries;
328 s->avctx->color_trc = sps->vui.transfer_characteristic;
329 s->avctx->colorspace = sps->vui.matrix_coeffs;
331 s->avctx->color_primaries = AVCOL_PRI_UNSPECIFIED;
332 s->avctx->color_trc = AVCOL_TRC_UNSPECIFIED;
333 s->avctx->colorspace = AVCOL_SPC_UNSPECIFIED;
336 ff_hevc_pred_init(&s->hpc, sps->bit_depth);
337 ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
338 ff_videodsp_init (&s->vdsp, sps->bit_depth);
340 if (sps->sao_enabled) {
341 av_frame_unref(s->tmp_frame);
342 ret = get_buffer_sao(s, s->tmp_frame, sps);
343 s->sao_frame = s->tmp_frame;
347 s->vps = (HEVCVPS*) s->vps_list[s->sps->vps_id]->data;
349 if (s->vps->vps_timing_info_present_flag) {
350 num = s->vps->vps_num_units_in_tick;
351 den = s->vps->vps_time_scale;
352 } else if (sps->vui.vui_timing_info_present_flag) {
353 num = sps->vui.vui_num_units_in_tick;
354 den = sps->vui.vui_time_scale;
357 if (num != 0 && den != 0)
358 av_reduce(&s->avctx->framerate.den, &s->avctx->framerate.num,
369 static int hls_slice_header(HEVCContext *s)
371 GetBitContext *gb = &s->HEVClc->gb;
372 SliceHeader *sh = &s->sh;
376 sh->first_slice_in_pic_flag = get_bits1(gb);
377 if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
378 s->seq_decode = (s->seq_decode + 1) & 0xff;
381 ff_hevc_clear_refs(s);
383 sh->no_output_of_prior_pics_flag = 0;
385 sh->no_output_of_prior_pics_flag = get_bits1(gb);
387 sh->pps_id = get_ue_golomb_long(gb);
388 if (sh->pps_id >= MAX_PPS_COUNT || !s->pps_list[sh->pps_id]) {
389 av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
390 return AVERROR_INVALIDDATA;
392 if (!sh->first_slice_in_pic_flag &&
393 s->pps != (HEVCPPS*)s->pps_list[sh->pps_id]->data) {
394 av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
395 return AVERROR_INVALIDDATA;
397 s->pps = (HEVCPPS*)s->pps_list[sh->pps_id]->data;
398 if (s->nal_unit_type == NAL_CRA_NUT && s->last_eos == 1)
399 sh->no_output_of_prior_pics_flag = 1;
401 if (s->sps != (HEVCSPS*)s->sps_list[s->pps->sps_id]->data) {
402 const HEVCSPS* last_sps = s->sps;
403 s->sps = (HEVCSPS*)s->sps_list[s->pps->sps_id]->data;
404 if (last_sps && IS_IRAP(s) && s->nal_unit_type != NAL_CRA_NUT) {
405 if (s->sps->width != last_sps->width || s->sps->height != last_sps->height ||
406 s->sps->temporal_layer[s->sps->max_sub_layers - 1].max_dec_pic_buffering !=
407 last_sps->temporal_layer[last_sps->max_sub_layers - 1].max_dec_pic_buffering)
408 sh->no_output_of_prior_pics_flag = 0;
410 ff_hevc_clear_refs(s);
411 ret = set_sps(s, s->sps);
415 s->seq_decode = (s->seq_decode + 1) & 0xff;
419 s->avctx->profile = s->sps->ptl.general_ptl.profile_idc;
420 s->avctx->level = s->sps->ptl.general_ptl.level_idc;
422 sh->dependent_slice_segment_flag = 0;
423 if (!sh->first_slice_in_pic_flag) {
424 int slice_address_length;
426 if (s->pps->dependent_slice_segments_enabled_flag)
427 sh->dependent_slice_segment_flag = get_bits1(gb);
429 slice_address_length = av_ceil_log2(s->sps->ctb_width *
431 sh->slice_segment_addr = get_bits(gb, slice_address_length);
432 if (sh->slice_segment_addr >= s->sps->ctb_width * s->sps->ctb_height) {
433 av_log(s->avctx, AV_LOG_ERROR,
434 "Invalid slice segment address: %u.\n",
435 sh->slice_segment_addr);
436 return AVERROR_INVALIDDATA;
439 if (!sh->dependent_slice_segment_flag) {
440 sh->slice_addr = sh->slice_segment_addr;
444 sh->slice_segment_addr = sh->slice_addr = 0;
446 s->slice_initialized = 0;
449 if (!sh->dependent_slice_segment_flag) {
450 s->slice_initialized = 0;
452 for (i = 0; i < s->pps->num_extra_slice_header_bits; i++)
453 skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
455 sh->slice_type = get_ue_golomb_long(gb);
456 if (!(sh->slice_type == I_SLICE ||
457 sh->slice_type == P_SLICE ||
458 sh->slice_type == B_SLICE)) {
459 av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
461 return AVERROR_INVALIDDATA;
463 if (IS_IRAP(s) && sh->slice_type != I_SLICE) {
464 av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
465 return AVERROR_INVALIDDATA;
468 // when flag is not present, picture is inferred to be output
469 sh->pic_output_flag = 1;
470 if (s->pps->output_flag_present_flag)
471 sh->pic_output_flag = get_bits1(gb);
473 if (s->sps->separate_colour_plane_flag)
474 sh->colour_plane_id = get_bits(gb, 2);
477 int short_term_ref_pic_set_sps_flag, poc;
479 sh->pic_order_cnt_lsb = get_bits(gb, s->sps->log2_max_poc_lsb);
480 poc = ff_hevc_compute_poc(s, sh->pic_order_cnt_lsb);
481 if (!sh->first_slice_in_pic_flag && poc != s->poc) {
482 av_log(s->avctx, AV_LOG_WARNING,
483 "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
484 if (s->avctx->err_recognition & AV_EF_EXPLODE)
485 return AVERROR_INVALIDDATA;
490 short_term_ref_pic_set_sps_flag = get_bits1(gb);
491 if (!short_term_ref_pic_set_sps_flag) {
492 ret = ff_hevc_decode_short_term_rps(s, &sh->slice_rps, s->sps, 1);
496 sh->short_term_rps = &sh->slice_rps;
498 int numbits, rps_idx;
500 if (!s->sps->nb_st_rps) {
501 av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
502 return AVERROR_INVALIDDATA;
505 numbits = av_ceil_log2(s->sps->nb_st_rps);
506 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
507 sh->short_term_rps = &s->sps->st_rps[rps_idx];
510 ret = decode_lt_rps(s, &sh->long_term_rps, gb);
512 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
513 if (s->avctx->err_recognition & AV_EF_EXPLODE)
514 return AVERROR_INVALIDDATA;
517 if (s->sps->sps_temporal_mvp_enabled_flag)
518 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
520 sh->slice_temporal_mvp_enabled_flag = 0;
522 s->sh.short_term_rps = NULL;
527 if (s->temporal_id == 0 &&
528 s->nal_unit_type != NAL_TRAIL_N &&
529 s->nal_unit_type != NAL_TSA_N &&
530 s->nal_unit_type != NAL_STSA_N &&
531 s->nal_unit_type != NAL_RADL_N &&
532 s->nal_unit_type != NAL_RADL_R &&
533 s->nal_unit_type != NAL_RASL_N &&
534 s->nal_unit_type != NAL_RASL_R)
537 if (s->sps->sao_enabled) {
538 sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
539 sh->slice_sample_adaptive_offset_flag[1] =
540 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
542 sh->slice_sample_adaptive_offset_flag[0] = 0;
543 sh->slice_sample_adaptive_offset_flag[1] = 0;
544 sh->slice_sample_adaptive_offset_flag[2] = 0;
547 sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
548 if (sh->slice_type == P_SLICE || sh->slice_type == B_SLICE) {
551 sh->nb_refs[L0] = s->pps->num_ref_idx_l0_default_active;
552 if (sh->slice_type == B_SLICE)
553 sh->nb_refs[L1] = s->pps->num_ref_idx_l1_default_active;
555 if (get_bits1(gb)) { // num_ref_idx_active_override_flag
556 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
557 if (sh->slice_type == B_SLICE)
558 sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
560 if (sh->nb_refs[L0] > MAX_REFS || sh->nb_refs[L1] > MAX_REFS) {
561 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
562 sh->nb_refs[L0], sh->nb_refs[L1]);
563 return AVERROR_INVALIDDATA;
566 sh->rpl_modification_flag[0] = 0;
567 sh->rpl_modification_flag[1] = 0;
568 nb_refs = ff_hevc_frame_nb_refs(s);
570 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
571 return AVERROR_INVALIDDATA;
574 if (s->pps->lists_modification_present_flag && nb_refs > 1) {
575 sh->rpl_modification_flag[0] = get_bits1(gb);
576 if (sh->rpl_modification_flag[0]) {
577 for (i = 0; i < sh->nb_refs[L0]; i++)
578 sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
581 if (sh->slice_type == B_SLICE) {
582 sh->rpl_modification_flag[1] = get_bits1(gb);
583 if (sh->rpl_modification_flag[1] == 1)
584 for (i = 0; i < sh->nb_refs[L1]; i++)
585 sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
589 if (sh->slice_type == B_SLICE)
590 sh->mvd_l1_zero_flag = get_bits1(gb);
592 if (s->pps->cabac_init_present_flag)
593 sh->cabac_init_flag = get_bits1(gb);
595 sh->cabac_init_flag = 0;
597 sh->collocated_ref_idx = 0;
598 if (sh->slice_temporal_mvp_enabled_flag) {
599 sh->collocated_list = L0;
600 if (sh->slice_type == B_SLICE)
601 sh->collocated_list = !get_bits1(gb);
603 if (sh->nb_refs[sh->collocated_list] > 1) {
604 sh->collocated_ref_idx = get_ue_golomb_long(gb);
605 if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
606 av_log(s->avctx, AV_LOG_ERROR,
607 "Invalid collocated_ref_idx: %d.\n",
608 sh->collocated_ref_idx);
609 return AVERROR_INVALIDDATA;
614 if ((s->pps->weighted_pred_flag && sh->slice_type == P_SLICE) ||
615 (s->pps->weighted_bipred_flag && sh->slice_type == B_SLICE)) {
616 pred_weight_table(s, gb);
619 sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
620 if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
621 av_log(s->avctx, AV_LOG_ERROR,
622 "Invalid number of merging MVP candidates: %d.\n",
623 sh->max_num_merge_cand);
624 return AVERROR_INVALIDDATA;
628 sh->slice_qp_delta = get_se_golomb(gb);
630 if (s->pps->pic_slice_level_chroma_qp_offsets_present_flag) {
631 sh->slice_cb_qp_offset = get_se_golomb(gb);
632 sh->slice_cr_qp_offset = get_se_golomb(gb);
634 sh->slice_cb_qp_offset = 0;
635 sh->slice_cr_qp_offset = 0;
638 if (s->pps->chroma_qp_offset_list_enabled_flag)
639 sh->cu_chroma_qp_offset_enabled_flag = get_bits1(gb);
641 sh->cu_chroma_qp_offset_enabled_flag = 0;
643 if (s->pps->deblocking_filter_control_present_flag) {
644 int deblocking_filter_override_flag = 0;
646 if (s->pps->deblocking_filter_override_enabled_flag)
647 deblocking_filter_override_flag = get_bits1(gb);
649 if (deblocking_filter_override_flag) {
650 sh->disable_deblocking_filter_flag = get_bits1(gb);
651 if (!sh->disable_deblocking_filter_flag) {
652 sh->beta_offset = get_se_golomb(gb) * 2;
653 sh->tc_offset = get_se_golomb(gb) * 2;
656 sh->disable_deblocking_filter_flag = s->pps->disable_dbf;
657 sh->beta_offset = s->pps->beta_offset;
658 sh->tc_offset = s->pps->tc_offset;
661 sh->disable_deblocking_filter_flag = 0;
666 if (s->pps->seq_loop_filter_across_slices_enabled_flag &&
667 (sh->slice_sample_adaptive_offset_flag[0] ||
668 sh->slice_sample_adaptive_offset_flag[1] ||
669 !sh->disable_deblocking_filter_flag)) {
670 sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
672 sh->slice_loop_filter_across_slices_enabled_flag = s->pps->seq_loop_filter_across_slices_enabled_flag;
674 } else if (!s->slice_initialized) {
675 av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
676 return AVERROR_INVALIDDATA;
679 sh->num_entry_point_offsets = 0;
680 if (s->pps->tiles_enabled_flag || s->pps->entropy_coding_sync_enabled_flag) {
681 sh->num_entry_point_offsets = get_ue_golomb_long(gb);
682 if (sh->num_entry_point_offsets > 0) {
683 int offset_len = get_ue_golomb_long(gb) + 1;
684 int segments = offset_len >> 4;
685 int rest = (offset_len & 15);
686 av_freep(&sh->entry_point_offset);
687 av_freep(&sh->offset);
689 sh->entry_point_offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
690 sh->offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
691 sh->size = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
692 if (!sh->entry_point_offset || !sh->offset || !sh->size) {
693 sh->num_entry_point_offsets = 0;
694 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate memory\n");
695 return AVERROR(ENOMEM);
697 for (i = 0; i < sh->num_entry_point_offsets; i++) {
699 for (j = 0; j < segments; j++) {
701 val += get_bits(gb, 16);
705 val += get_bits(gb, rest);
707 sh->entry_point_offset[i] = val + 1; // +1; // +1 to get the size
709 if (s->threads_number > 1 && (s->pps->num_tile_rows > 1 || s->pps->num_tile_columns > 1)) {
710 s->enable_parallel_tiles = 0; // TODO: you can enable tiles in parallel here
711 s->threads_number = 1;
713 s->enable_parallel_tiles = 0;
715 s->enable_parallel_tiles = 0;
718 if (s->pps->slice_header_extension_present_flag) {
719 unsigned int length = get_ue_golomb_long(gb);
720 if (length*8LL > get_bits_left(gb)) {
721 av_log(s->avctx, AV_LOG_ERROR, "too many slice_header_extension_data_bytes\n");
722 return AVERROR_INVALIDDATA;
724 for (i = 0; i < length; i++)
725 skip_bits(gb, 8); // slice_header_extension_data_byte
728 // Inferred parameters
729 sh->slice_qp = 26U + s->pps->pic_init_qp_minus26 + sh->slice_qp_delta;
730 if (sh->slice_qp > 51 ||
731 sh->slice_qp < -s->sps->qp_bd_offset) {
732 av_log(s->avctx, AV_LOG_ERROR,
733 "The slice_qp %d is outside the valid range "
736 -s->sps->qp_bd_offset);
737 return AVERROR_INVALIDDATA;
740 sh->slice_ctb_addr_rs = sh->slice_segment_addr;
742 if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) {
743 av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
744 return AVERROR_INVALIDDATA;
747 if (get_bits_left(gb) < 0) {
748 av_log(s->avctx, AV_LOG_ERROR,
749 "Overread slice header by %d bits\n", -get_bits_left(gb));
750 return AVERROR_INVALIDDATA;
753 s->HEVClc->first_qp_group = !s->sh.dependent_slice_segment_flag;
755 if (!s->pps->cu_qp_delta_enabled_flag)
756 s->HEVClc->qp_y = s->sh.slice_qp;
758 s->slice_initialized = 1;
759 s->HEVClc->tu.cu_qp_offset_cb = 0;
760 s->HEVClc->tu.cu_qp_offset_cr = 0;
765 #define CTB(tab, x, y) ((tab)[(y) * s->sps->ctb_width + (x)])
767 #define SET_SAO(elem, value) \
769 if (!sao_merge_up_flag && !sao_merge_left_flag) \
771 else if (sao_merge_left_flag) \
772 sao->elem = CTB(s->sao, rx-1, ry).elem; \
773 else if (sao_merge_up_flag) \
774 sao->elem = CTB(s->sao, rx, ry-1).elem; \
779 static void hls_sao_param(HEVCContext *s, int rx, int ry)
781 HEVCLocalContext *lc = s->HEVClc;
782 int sao_merge_left_flag = 0;
783 int sao_merge_up_flag = 0;
784 SAOParams *sao = &CTB(s->sao, rx, ry);
787 if (s->sh.slice_sample_adaptive_offset_flag[0] ||
788 s->sh.slice_sample_adaptive_offset_flag[1]) {
790 if (lc->ctb_left_flag)
791 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
793 if (ry > 0 && !sao_merge_left_flag) {
795 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
799 for (c_idx = 0; c_idx < 3; c_idx++) {
800 int log2_sao_offset_scale = c_idx == 0 ? s->pps->log2_sao_offset_scale_luma :
801 s->pps->log2_sao_offset_scale_chroma;
803 if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
804 sao->type_idx[c_idx] = SAO_NOT_APPLIED;
809 sao->type_idx[2] = sao->type_idx[1];
810 sao->eo_class[2] = sao->eo_class[1];
812 SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
815 if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
818 for (i = 0; i < 4; i++)
819 SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
821 if (sao->type_idx[c_idx] == SAO_BAND) {
822 for (i = 0; i < 4; i++) {
823 if (sao->offset_abs[c_idx][i]) {
824 SET_SAO(offset_sign[c_idx][i],
825 ff_hevc_sao_offset_sign_decode(s));
827 sao->offset_sign[c_idx][i] = 0;
830 SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
831 } else if (c_idx != 2) {
832 SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
835 // Inferred parameters
836 sao->offset_val[c_idx][0] = 0;
837 for (i = 0; i < 4; i++) {
838 sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i];
839 if (sao->type_idx[c_idx] == SAO_EDGE) {
841 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
842 } else if (sao->offset_sign[c_idx][i]) {
843 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
845 sao->offset_val[c_idx][i + 1] <<= log2_sao_offset_scale;
853 static int hls_cross_component_pred(HEVCContext *s, int idx) {
854 HEVCLocalContext *lc = s->HEVClc;
855 int log2_res_scale_abs_plus1 = ff_hevc_log2_res_scale_abs(s, idx);
857 if (log2_res_scale_abs_plus1 != 0) {
858 int res_scale_sign_flag = ff_hevc_res_scale_sign_flag(s, idx);
859 lc->tu.res_scale_val = (1 << (log2_res_scale_abs_plus1 - 1)) *
860 (1 - 2 * res_scale_sign_flag);
862 lc->tu.res_scale_val = 0;
869 static int hls_transform_unit(HEVCContext *s, int x0, int y0,
870 int xBase, int yBase, int cb_xBase, int cb_yBase,
871 int log2_cb_size, int log2_trafo_size,
872 int blk_idx, int cbf_luma, int *cbf_cb, int *cbf_cr)
874 HEVCLocalContext *lc = s->HEVClc;
875 const int log2_trafo_size_c = log2_trafo_size - s->sps->hshift[1];
878 if (lc->cu.pred_mode == MODE_INTRA) {
879 int trafo_size = 1 << log2_trafo_size;
880 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
882 s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
885 if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
886 (s->sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
887 int scan_idx = SCAN_DIAG;
888 int scan_idx_c = SCAN_DIAG;
889 int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
890 (s->sps->chroma_format_idc == 2 &&
891 (cbf_cb[1] || cbf_cr[1]));
893 if (s->pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
894 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
895 if (lc->tu.cu_qp_delta != 0)
896 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
897 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
898 lc->tu.is_cu_qp_delta_coded = 1;
900 if (lc->tu.cu_qp_delta < -(26 + s->sps->qp_bd_offset / 2) ||
901 lc->tu.cu_qp_delta > (25 + s->sps->qp_bd_offset / 2)) {
902 av_log(s->avctx, AV_LOG_ERROR,
903 "The cu_qp_delta %d is outside the valid range "
906 -(26 + s->sps->qp_bd_offset / 2),
907 (25 + s->sps->qp_bd_offset / 2));
908 return AVERROR_INVALIDDATA;
911 ff_hevc_set_qPy(s, cb_xBase, cb_yBase, log2_cb_size);
914 if (s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
915 !lc->cu.cu_transquant_bypass_flag && !lc->tu.is_cu_chroma_qp_offset_coded) {
916 int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(s);
917 if (cu_chroma_qp_offset_flag) {
918 int cu_chroma_qp_offset_idx = 0;
919 if (s->pps->chroma_qp_offset_list_len_minus1 > 0) {
920 cu_chroma_qp_offset_idx = ff_hevc_cu_chroma_qp_offset_idx(s);
921 av_log(s->avctx, AV_LOG_ERROR,
922 "cu_chroma_qp_offset_idx not yet tested.\n");
924 lc->tu.cu_qp_offset_cb = s->pps->cb_qp_offset_list[cu_chroma_qp_offset_idx];
925 lc->tu.cu_qp_offset_cr = s->pps->cr_qp_offset_list[cu_chroma_qp_offset_idx];
927 lc->tu.cu_qp_offset_cb = 0;
928 lc->tu.cu_qp_offset_cr = 0;
930 lc->tu.is_cu_chroma_qp_offset_coded = 1;
933 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
934 if (lc->tu.intra_pred_mode >= 6 &&
935 lc->tu.intra_pred_mode <= 14) {
936 scan_idx = SCAN_VERT;
937 } else if (lc->tu.intra_pred_mode >= 22 &&
938 lc->tu.intra_pred_mode <= 30) {
939 scan_idx = SCAN_HORIZ;
942 if (lc->tu.intra_pred_mode_c >= 6 &&
943 lc->tu.intra_pred_mode_c <= 14) {
944 scan_idx_c = SCAN_VERT;
945 } else if (lc->tu.intra_pred_mode_c >= 22 &&
946 lc->tu.intra_pred_mode_c <= 30) {
947 scan_idx_c = SCAN_HORIZ;
954 ff_hevc_hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
955 if (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3) {
956 int trafo_size_h = 1 << (log2_trafo_size_c + s->sps->hshift[1]);
957 int trafo_size_v = 1 << (log2_trafo_size_c + s->sps->vshift[1]);
958 lc->tu.cross_pf = (s->pps->cross_component_prediction_enabled_flag && cbf_luma &&
959 (lc->cu.pred_mode == MODE_INTER ||
960 (lc->tu.chroma_mode_c == 4)));
962 if (lc->tu.cross_pf) {
963 hls_cross_component_pred(s, 0);
965 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
966 if (lc->cu.pred_mode == MODE_INTRA) {
967 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
968 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 1);
971 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
972 log2_trafo_size_c, scan_idx_c, 1);
974 if (lc->tu.cross_pf) {
975 ptrdiff_t stride = s->frame->linesize[1];
976 int hshift = s->sps->hshift[1];
977 int vshift = s->sps->vshift[1];
978 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
979 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
980 int size = 1 << log2_trafo_size_c;
982 uint8_t *dst = &s->frame->data[1][(y0 >> vshift) * stride +
983 ((x0 >> hshift) << s->sps->pixel_shift)];
984 for (i = 0; i < (size * size); i++) {
985 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
987 s->hevcdsp.transform_add[log2_trafo_size_c-2](dst, coeffs, stride);
991 if (lc->tu.cross_pf) {
992 hls_cross_component_pred(s, 1);
994 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
995 if (lc->cu.pred_mode == MODE_INTRA) {
996 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
997 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 2);
1000 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1001 log2_trafo_size_c, scan_idx_c, 2);
1003 if (lc->tu.cross_pf) {
1004 ptrdiff_t stride = s->frame->linesize[2];
1005 int hshift = s->sps->hshift[2];
1006 int vshift = s->sps->vshift[2];
1007 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1008 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1009 int size = 1 << log2_trafo_size_c;
1011 uint8_t *dst = &s->frame->data[2][(y0 >> vshift) * stride +
1012 ((x0 >> hshift) << s->sps->pixel_shift)];
1013 for (i = 0; i < (size * size); i++) {
1014 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1016 s->hevcdsp.transform_add[log2_trafo_size_c-2](dst, coeffs, stride);
1019 } else if (blk_idx == 3) {
1020 int trafo_size_h = 1 << (log2_trafo_size + 1);
1021 int trafo_size_v = 1 << (log2_trafo_size + s->sps->vshift[1]);
1022 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1023 if (lc->cu.pred_mode == MODE_INTRA) {
1024 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1025 trafo_size_h, trafo_size_v);
1026 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 1);
1029 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1030 log2_trafo_size, scan_idx_c, 1);
1032 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1033 if (lc->cu.pred_mode == MODE_INTRA) {
1034 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1035 trafo_size_h, trafo_size_v);
1036 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 2);
1039 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1040 log2_trafo_size, scan_idx_c, 2);
1043 } else if (lc->cu.pred_mode == MODE_INTRA) {
1044 if (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3) {
1045 int trafo_size_h = 1 << (log2_trafo_size_c + s->sps->hshift[1]);
1046 int trafo_size_v = 1 << (log2_trafo_size_c + s->sps->vshift[1]);
1047 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size_h, trafo_size_v);
1048 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 1);
1049 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 2);
1050 if (s->sps->chroma_format_idc == 2) {
1051 ff_hevc_set_neighbour_available(s, x0, y0 + (1 << log2_trafo_size_c),
1052 trafo_size_h, trafo_size_v);
1053 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 1);
1054 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 2);
1056 } else if (blk_idx == 3) {
1057 int trafo_size_h = 1 << (log2_trafo_size + 1);
1058 int trafo_size_v = 1 << (log2_trafo_size + s->sps->vshift[1]);
1059 ff_hevc_set_neighbour_available(s, xBase, yBase,
1060 trafo_size_h, trafo_size_v);
1061 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1062 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1063 if (s->sps->chroma_format_idc == 2) {
1064 ff_hevc_set_neighbour_available(s, xBase, yBase + (1 << (log2_trafo_size)),
1065 trafo_size_h, trafo_size_v);
1066 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 1);
1067 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 2);
1075 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1077 int cb_size = 1 << log2_cb_size;
1078 int log2_min_pu_size = s->sps->log2_min_pu_size;
1080 int min_pu_width = s->sps->min_pu_width;
1081 int x_end = FFMIN(x0 + cb_size, s->sps->width);
1082 int y_end = FFMIN(y0 + cb_size, s->sps->height);
1085 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1086 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1087 s->is_pcm[i + j * min_pu_width] = 2;
1090 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1091 int xBase, int yBase, int cb_xBase, int cb_yBase,
1092 int log2_cb_size, int log2_trafo_size,
1093 int trafo_depth, int blk_idx,
1094 const int *base_cbf_cb, const int *base_cbf_cr)
1096 HEVCLocalContext *lc = s->HEVClc;
1097 uint8_t split_transform_flag;
1102 cbf_cb[0] = base_cbf_cb[0];
1103 cbf_cb[1] = base_cbf_cb[1];
1104 cbf_cr[0] = base_cbf_cr[0];
1105 cbf_cr[1] = base_cbf_cr[1];
1107 if (lc->cu.intra_split_flag) {
1108 if (trafo_depth == 1) {
1109 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1110 if (s->sps->chroma_format_idc == 3) {
1111 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[blk_idx];
1112 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[blk_idx];
1114 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1115 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1119 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[0];
1120 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1121 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1124 if (log2_trafo_size <= s->sps->log2_max_trafo_size &&
1125 log2_trafo_size > s->sps->log2_min_tb_size &&
1126 trafo_depth < lc->cu.max_trafo_depth &&
1127 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1128 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1130 int inter_split = s->sps->max_transform_hierarchy_depth_inter == 0 &&
1131 lc->cu.pred_mode == MODE_INTER &&
1132 lc->cu.part_mode != PART_2Nx2N &&
1135 split_transform_flag = log2_trafo_size > s->sps->log2_max_trafo_size ||
1136 (lc->cu.intra_split_flag && trafo_depth == 0) ||
1140 if (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3) {
1141 if (trafo_depth == 0 || cbf_cb[0]) {
1142 cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1143 if (s->sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1144 cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1148 if (trafo_depth == 0 || cbf_cr[0]) {
1149 cbf_cr[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1150 if (s->sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1151 cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1156 if (split_transform_flag) {
1157 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1158 const int x1 = x0 + trafo_size_split;
1159 const int y1 = y0 + trafo_size_split;
1161 #define SUBDIVIDE(x, y, idx) \
1163 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1164 log2_trafo_size - 1, trafo_depth + 1, idx, \
1170 SUBDIVIDE(x0, y0, 0);
1171 SUBDIVIDE(x1, y0, 1);
1172 SUBDIVIDE(x0, y1, 2);
1173 SUBDIVIDE(x1, y1, 3);
1177 int min_tu_size = 1 << s->sps->log2_min_tb_size;
1178 int log2_min_tu_size = s->sps->log2_min_tb_size;
1179 int min_tu_width = s->sps->min_tb_width;
1182 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1183 cbf_cb[0] || cbf_cr[0] ||
1184 (s->sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1185 cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1188 ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1189 log2_cb_size, log2_trafo_size,
1190 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1193 // TODO: store cbf_luma somewhere else
1196 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1197 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1198 int x_tu = (x0 + j) >> log2_min_tu_size;
1199 int y_tu = (y0 + i) >> log2_min_tu_size;
1200 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1203 if (!s->sh.disable_deblocking_filter_flag) {
1204 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1205 if (s->pps->transquant_bypass_enable_flag &&
1206 lc->cu.cu_transquant_bypass_flag)
1207 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1213 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1215 HEVCLocalContext *lc = s->HEVClc;
1217 int cb_size = 1 << log2_cb_size;
1218 int stride0 = s->frame->linesize[0];
1219 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->sps->pixel_shift)];
1220 int stride1 = s->frame->linesize[1];
1221 uint8_t *dst1 = &s->frame->data[1][(y0 >> s->sps->vshift[1]) * stride1 + ((x0 >> s->sps->hshift[1]) << s->sps->pixel_shift)];
1222 int stride2 = s->frame->linesize[2];
1223 uint8_t *dst2 = &s->frame->data[2][(y0 >> s->sps->vshift[2]) * stride2 + ((x0 >> s->sps->hshift[2]) << s->sps->pixel_shift)];
1225 int length = cb_size * cb_size * s->sps->pcm.bit_depth +
1226 (((cb_size >> s->sps->hshift[1]) * (cb_size >> s->sps->vshift[1])) +
1227 ((cb_size >> s->sps->hshift[2]) * (cb_size >> s->sps->vshift[2]))) *
1228 s->sps->pcm.bit_depth_chroma;
1229 const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1232 if (!s->sh.disable_deblocking_filter_flag)
1233 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1235 ret = init_get_bits(&gb, pcm, length);
1239 s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size, &gb, s->sps->pcm.bit_depth);
1240 s->hevcdsp.put_pcm(dst1, stride1,
1241 cb_size >> s->sps->hshift[1],
1242 cb_size >> s->sps->vshift[1],
1243 &gb, s->sps->pcm.bit_depth_chroma);
1244 s->hevcdsp.put_pcm(dst2, stride2,
1245 cb_size >> s->sps->hshift[2],
1246 cb_size >> s->sps->vshift[2],
1247 &gb, s->sps->pcm.bit_depth_chroma);
1252 * 8.5.3.2.2.1 Luma sample unidirectional interpolation process
1254 * @param s HEVC decoding context
1255 * @param dst target buffer for block data at block position
1256 * @param dststride stride of the dst buffer
1257 * @param ref reference picture buffer at origin (0, 0)
1258 * @param mv motion vector (relative to block position) to get pixel data from
1259 * @param x_off horizontal position of block from origin (0, 0)
1260 * @param y_off vertical position of block from origin (0, 0)
1261 * @param block_w width of block
1262 * @param block_h height of block
1263 * @param luma_weight weighting factor applied to the luma prediction
1264 * @param luma_offset additive offset applied to the luma prediction value
1267 static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1268 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1269 int block_w, int block_h, int luma_weight, int luma_offset)
1271 HEVCLocalContext *lc = s->HEVClc;
1272 uint8_t *src = ref->data[0];
1273 ptrdiff_t srcstride = ref->linesize[0];
1274 int pic_width = s->sps->width;
1275 int pic_height = s->sps->height;
1278 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1279 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1280 int idx = ff_hevc_pel_weight[block_w];
1282 x_off += mv->x >> 2;
1283 y_off += mv->y >> 2;
1284 src += y_off * srcstride + (x_off << s->sps->pixel_shift);
1286 if (x_off < QPEL_EXTRA_BEFORE || y_off < QPEL_EXTRA_AFTER ||
1287 x_off >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1288 y_off >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1289 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1290 int offset = QPEL_EXTRA_BEFORE * srcstride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1291 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1293 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1294 edge_emu_stride, srcstride,
1295 block_w + QPEL_EXTRA,
1296 block_h + QPEL_EXTRA,
1297 x_off - QPEL_EXTRA_BEFORE, y_off - QPEL_EXTRA_BEFORE,
1298 pic_width, pic_height);
1299 src = lc->edge_emu_buffer + buf_offset;
1300 srcstride = edge_emu_stride;
1304 s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride, src, srcstride,
1305 block_h, mx, my, block_w);
1307 s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride, src, srcstride,
1308 block_h, s->sh.luma_log2_weight_denom,
1309 luma_weight, luma_offset, mx, my, block_w);
1313 * 8.5.3.2.2.1 Luma sample bidirectional interpolation process
1315 * @param s HEVC decoding context
1316 * @param dst target buffer for block data at block position
1317 * @param dststride stride of the dst buffer
1318 * @param ref0 reference picture0 buffer at origin (0, 0)
1319 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1320 * @param x_off horizontal position of block from origin (0, 0)
1321 * @param y_off vertical position of block from origin (0, 0)
1322 * @param block_w width of block
1323 * @param block_h height of block
1324 * @param ref1 reference picture1 buffer at origin (0, 0)
1325 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1326 * @param current_mv current motion vector structure
1328 static void luma_mc_bi(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1329 AVFrame *ref0, const Mv *mv0, int x_off, int y_off,
1330 int block_w, int block_h, AVFrame *ref1, const Mv *mv1, struct MvField *current_mv)
1332 HEVCLocalContext *lc = s->HEVClc;
1333 ptrdiff_t src0stride = ref0->linesize[0];
1334 ptrdiff_t src1stride = ref1->linesize[0];
1335 int pic_width = s->sps->width;
1336 int pic_height = s->sps->height;
1337 int mx0 = mv0->x & 3;
1338 int my0 = mv0->y & 3;
1339 int mx1 = mv1->x & 3;
1340 int my1 = mv1->y & 3;
1341 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1342 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1343 int x_off0 = x_off + (mv0->x >> 2);
1344 int y_off0 = y_off + (mv0->y >> 2);
1345 int x_off1 = x_off + (mv1->x >> 2);
1346 int y_off1 = y_off + (mv1->y >> 2);
1347 int idx = ff_hevc_pel_weight[block_w];
1349 uint8_t *src0 = ref0->data[0] + y_off0 * src0stride + (int)((unsigned)x_off0 << s->sps->pixel_shift);
1350 uint8_t *src1 = ref1->data[0] + y_off1 * src1stride + (int)((unsigned)x_off1 << s->sps->pixel_shift);
1352 if (x_off0 < QPEL_EXTRA_BEFORE || y_off0 < QPEL_EXTRA_AFTER ||
1353 x_off0 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1354 y_off0 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1355 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1356 int offset = QPEL_EXTRA_BEFORE * src0stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1357 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1359 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset,
1360 edge_emu_stride, src0stride,
1361 block_w + QPEL_EXTRA,
1362 block_h + QPEL_EXTRA,
1363 x_off0 - QPEL_EXTRA_BEFORE, y_off0 - QPEL_EXTRA_BEFORE,
1364 pic_width, pic_height);
1365 src0 = lc->edge_emu_buffer + buf_offset;
1366 src0stride = edge_emu_stride;
1369 if (x_off1 < QPEL_EXTRA_BEFORE || y_off1 < QPEL_EXTRA_AFTER ||
1370 x_off1 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1371 y_off1 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1372 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1373 int offset = QPEL_EXTRA_BEFORE * src1stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1374 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1376 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src1 - offset,
1377 edge_emu_stride, src1stride,
1378 block_w + QPEL_EXTRA,
1379 block_h + QPEL_EXTRA,
1380 x_off1 - QPEL_EXTRA_BEFORE, y_off1 - QPEL_EXTRA_BEFORE,
1381 pic_width, pic_height);
1382 src1 = lc->edge_emu_buffer2 + buf_offset;
1383 src1stride = edge_emu_stride;
1386 s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](lc->tmp, src0, src0stride,
1387 block_h, mx0, my0, block_w);
1389 s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1390 block_h, mx1, my1, block_w);
1392 s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1393 block_h, s->sh.luma_log2_weight_denom,
1394 s->sh.luma_weight_l0[current_mv->ref_idx[0]],
1395 s->sh.luma_weight_l1[current_mv->ref_idx[1]],
1396 s->sh.luma_offset_l0[current_mv->ref_idx[0]],
1397 s->sh.luma_offset_l1[current_mv->ref_idx[1]],
1403 * 8.5.3.2.2.2 Chroma sample uniprediction interpolation process
1405 * @param s HEVC decoding context
1406 * @param dst1 target buffer for block data at block position (U plane)
1407 * @param dst2 target buffer for block data at block position (V plane)
1408 * @param dststride stride of the dst1 and dst2 buffers
1409 * @param ref reference picture buffer at origin (0, 0)
1410 * @param mv motion vector (relative to block position) to get pixel data from
1411 * @param x_off horizontal position of block from origin (0, 0)
1412 * @param y_off vertical position of block from origin (0, 0)
1413 * @param block_w width of block
1414 * @param block_h height of block
1415 * @param chroma_weight weighting factor applied to the chroma prediction
1416 * @param chroma_offset additive offset applied to the chroma prediction value
1419 static void chroma_mc_uni(HEVCContext *s, uint8_t *dst0,
1420 ptrdiff_t dststride, uint8_t *src0, ptrdiff_t srcstride, int reflist,
1421 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int chroma_weight, int chroma_offset)
1423 HEVCLocalContext *lc = s->HEVClc;
1424 int pic_width = s->sps->width >> s->sps->hshift[1];
1425 int pic_height = s->sps->height >> s->sps->vshift[1];
1426 const Mv *mv = ¤t_mv->mv[reflist];
1427 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1428 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1429 int idx = ff_hevc_pel_weight[block_w];
1430 int hshift = s->sps->hshift[1];
1431 int vshift = s->sps->vshift[1];
1432 intptr_t mx = mv->x & ((1 << (2 + hshift)) - 1);
1433 intptr_t my = mv->y & ((1 << (2 + vshift)) - 1);
1434 intptr_t _mx = mx << (1 - hshift);
1435 intptr_t _my = my << (1 - vshift);
1437 x_off += mv->x >> (2 + hshift);
1438 y_off += mv->y >> (2 + vshift);
1439 src0 += y_off * srcstride + (x_off << s->sps->pixel_shift);
1441 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1442 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1443 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1444 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1445 int offset0 = EPEL_EXTRA_BEFORE * (srcstride + (1 << s->sps->pixel_shift));
1446 int buf_offset0 = EPEL_EXTRA_BEFORE *
1447 (edge_emu_stride + (1 << s->sps->pixel_shift));
1448 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset0,
1449 edge_emu_stride, srcstride,
1450 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1451 x_off - EPEL_EXTRA_BEFORE,
1452 y_off - EPEL_EXTRA_BEFORE,
1453 pic_width, pic_height);
1455 src0 = lc->edge_emu_buffer + buf_offset0;
1456 srcstride = edge_emu_stride;
1459 s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1460 block_h, _mx, _my, block_w);
1462 s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1463 block_h, s->sh.chroma_log2_weight_denom,
1464 chroma_weight, chroma_offset, _mx, _my, block_w);
1468 * 8.5.3.2.2.2 Chroma sample bidirectional interpolation process
1470 * @param s HEVC decoding context
1471 * @param dst target buffer for block data at block position
1472 * @param dststride stride of the dst buffer
1473 * @param ref0 reference picture0 buffer at origin (0, 0)
1474 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1475 * @param x_off horizontal position of block from origin (0, 0)
1476 * @param y_off vertical position of block from origin (0, 0)
1477 * @param block_w width of block
1478 * @param block_h height of block
1479 * @param ref1 reference picture1 buffer at origin (0, 0)
1480 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1481 * @param current_mv current motion vector structure
1482 * @param cidx chroma component(cb, cr)
1484 static void chroma_mc_bi(HEVCContext *s, uint8_t *dst0, ptrdiff_t dststride, AVFrame *ref0, AVFrame *ref1,
1485 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int cidx)
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](lc->tmp, 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, lc->tmp,
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, lc->tmp,
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 = FFMAX(0, (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 hevc_luma_mv_mpv_mode(HEVCContext *s, int x0, int y0, int nPbW,
1584 int nPbH, int log2_cb_size, int part_idx,
1585 int merge_idx, MvField *mv)
1587 HEVCLocalContext *lc = s->HEVClc;
1588 enum InterPredIdc inter_pred_idc = PRED_L0;
1591 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1593 if (s->sh.slice_type == B_SLICE)
1594 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1596 if (inter_pred_idc != PRED_L1) {
1597 if (s->sh.nb_refs[L0])
1598 mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1600 mv->pred_flag = PF_L0;
1601 ff_hevc_hls_mvd_coding(s, x0, y0, 0);
1602 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1603 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1604 part_idx, merge_idx, mv, mvp_flag, 0);
1605 mv->mv[0].x += lc->pu.mvd.x;
1606 mv->mv[0].y += lc->pu.mvd.y;
1609 if (inter_pred_idc != PRED_L0) {
1610 if (s->sh.nb_refs[L1])
1611 mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1613 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1614 AV_ZERO32(&lc->pu.mvd);
1616 ff_hevc_hls_mvd_coding(s, x0, y0, 1);
1619 mv->pred_flag += PF_L1;
1620 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1621 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1622 part_idx, merge_idx, mv, mvp_flag, 1);
1623 mv->mv[1].x += lc->pu.mvd.x;
1624 mv->mv[1].y += lc->pu.mvd.y;
1628 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1630 int log2_cb_size, int partIdx, int idx)
1632 #define POS(c_idx, x, y) \
1633 &s->frame->data[c_idx][((y) >> s->sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1634 (((x) >> s->sps->hshift[c_idx]) << s->sps->pixel_shift)]
1635 HEVCLocalContext *lc = s->HEVClc;
1637 struct MvField current_mv = {{{ 0 }}};
1639 int min_pu_width = s->sps->min_pu_width;
1641 MvField *tab_mvf = s->ref->tab_mvf;
1642 RefPicList *refPicList = s->ref->refPicList;
1643 HEVCFrame *ref0 = NULL, *ref1 = NULL;
1644 uint8_t *dst0 = POS(0, x0, y0);
1645 uint8_t *dst1 = POS(1, x0, y0);
1646 uint8_t *dst2 = POS(2, x0, y0);
1647 int log2_min_cb_size = s->sps->log2_min_cb_size;
1648 int min_cb_width = s->sps->min_cb_width;
1649 int x_cb = x0 >> log2_min_cb_size;
1650 int y_cb = y0 >> log2_min_cb_size;
1654 int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1657 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1659 if (skip_flag || lc->pu.merge_flag) {
1660 if (s->sh.max_num_merge_cand > 1)
1661 merge_idx = ff_hevc_merge_idx_decode(s);
1665 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1666 partIdx, merge_idx, ¤t_mv);
1668 hevc_luma_mv_mpv_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1669 partIdx, merge_idx, ¤t_mv);
1672 x_pu = x0 >> s->sps->log2_min_pu_size;
1673 y_pu = y0 >> s->sps->log2_min_pu_size;
1675 for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1676 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1677 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1679 if (current_mv.pred_flag & PF_L0) {
1680 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1683 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1685 if (current_mv.pred_flag & PF_L1) {
1686 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1689 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1692 if (current_mv.pred_flag == PF_L0) {
1693 int x0_c = x0 >> s->sps->hshift[1];
1694 int y0_c = y0 >> s->sps->vshift[1];
1695 int nPbW_c = nPbW >> s->sps->hshift[1];
1696 int nPbH_c = nPbH >> s->sps->vshift[1];
1698 luma_mc_uni(s, dst0, s->frame->linesize[0], ref0->frame,
1699 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1700 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1701 s->sh.luma_offset_l0[current_mv.ref_idx[0]]);
1703 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref0->frame->data[1], ref0->frame->linesize[1],
1704 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1705 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]);
1706 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref0->frame->data[2], ref0->frame->linesize[2],
1707 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1708 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]);
1709 } else if (current_mv.pred_flag == PF_L1) {
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], ref1->frame,
1716 ¤t_mv.mv[1], x0, y0, nPbW, nPbH,
1717 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1718 s->sh.luma_offset_l1[current_mv.ref_idx[1]]);
1720 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
1721 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1722 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]);
1724 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
1725 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1726 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]);
1727 } else if (current_mv.pred_flag == PF_BI) {
1728 int x0_c = x0 >> s->sps->hshift[1];
1729 int y0_c = y0 >> s->sps->vshift[1];
1730 int nPbW_c = nPbW >> s->sps->hshift[1];
1731 int nPbH_c = nPbH >> s->sps->vshift[1];
1733 luma_mc_bi(s, dst0, s->frame->linesize[0], ref0->frame,
1734 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1735 ref1->frame, ¤t_mv.mv[1], ¤t_mv);
1737 chroma_mc_bi(s, dst1, s->frame->linesize[1], ref0->frame, ref1->frame,
1738 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 0);
1740 chroma_mc_bi(s, dst2, s->frame->linesize[2], ref0->frame, ref1->frame,
1741 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1);
1748 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1749 int prev_intra_luma_pred_flag)
1751 HEVCLocalContext *lc = s->HEVClc;
1752 int x_pu = x0 >> s->sps->log2_min_pu_size;
1753 int y_pu = y0 >> s->sps->log2_min_pu_size;
1754 int min_pu_width = s->sps->min_pu_width;
1755 int size_in_pus = pu_size >> s->sps->log2_min_pu_size;
1756 int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1);
1757 int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1);
1759 int cand_up = (lc->ctb_up_flag || y0b) ?
1760 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1761 int cand_left = (lc->ctb_left_flag || x0b) ?
1762 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1764 int y_ctb = (y0 >> (s->sps->log2_ctb_size)) << (s->sps->log2_ctb_size);
1766 MvField *tab_mvf = s->ref->tab_mvf;
1767 int intra_pred_mode;
1771 // intra_pred_mode prediction does not cross vertical CTB boundaries
1772 if ((y0 - 1) < y_ctb)
1775 if (cand_left == cand_up) {
1776 if (cand_left < 2) {
1777 candidate[0] = INTRA_PLANAR;
1778 candidate[1] = INTRA_DC;
1779 candidate[2] = INTRA_ANGULAR_26;
1781 candidate[0] = cand_left;
1782 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1783 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1786 candidate[0] = cand_left;
1787 candidate[1] = cand_up;
1788 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1789 candidate[2] = INTRA_PLANAR;
1790 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1791 candidate[2] = INTRA_DC;
1793 candidate[2] = INTRA_ANGULAR_26;
1797 if (prev_intra_luma_pred_flag) {
1798 intra_pred_mode = candidate[lc->pu.mpm_idx];
1800 if (candidate[0] > candidate[1])
1801 FFSWAP(uint8_t, candidate[0], candidate[1]);
1802 if (candidate[0] > candidate[2])
1803 FFSWAP(uint8_t, candidate[0], candidate[2]);
1804 if (candidate[1] > candidate[2])
1805 FFSWAP(uint8_t, candidate[1], candidate[2]);
1807 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1808 for (i = 0; i < 3; i++)
1809 if (intra_pred_mode >= candidate[i])
1813 /* write the intra prediction units into the mv array */
1816 for (i = 0; i < size_in_pus; i++) {
1817 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1818 intra_pred_mode, size_in_pus);
1820 for (j = 0; j < size_in_pus; j++) {
1821 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag = PF_INTRA;
1825 return intra_pred_mode;
1828 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1829 int log2_cb_size, int ct_depth)
1831 int length = (1 << log2_cb_size) >> s->sps->log2_min_cb_size;
1832 int x_cb = x0 >> s->sps->log2_min_cb_size;
1833 int y_cb = y0 >> s->sps->log2_min_cb_size;
1836 for (y = 0; y < length; y++)
1837 memset(&s->tab_ct_depth[(y_cb + y) * s->sps->min_cb_width + x_cb],
1841 static const uint8_t tab_mode_idx[] = {
1842 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
1843 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
1845 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1848 HEVCLocalContext *lc = s->HEVClc;
1849 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1850 uint8_t prev_intra_luma_pred_flag[4];
1851 int split = lc->cu.part_mode == PART_NxN;
1852 int pb_size = (1 << log2_cb_size) >> split;
1853 int side = split + 1;
1857 for (i = 0; i < side; i++)
1858 for (j = 0; j < side; j++)
1859 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1861 for (i = 0; i < side; i++) {
1862 for (j = 0; j < side; j++) {
1863 if (prev_intra_luma_pred_flag[2 * i + j])
1864 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
1866 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
1868 lc->pu.intra_pred_mode[2 * i + j] =
1869 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1870 prev_intra_luma_pred_flag[2 * i + j]);
1874 if (s->sps->chroma_format_idc == 3) {
1875 for (i = 0; i < side; i++) {
1876 for (j = 0; j < side; j++) {
1877 lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1878 if (chroma_mode != 4) {
1879 if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode])
1880 lc->pu.intra_pred_mode_c[2 * i + j] = 34;
1882 lc->pu.intra_pred_mode_c[2 * i + j] = intra_chroma_table[chroma_mode];
1884 lc->pu.intra_pred_mode_c[2 * i + j] = lc->pu.intra_pred_mode[2 * i + j];
1888 } else if (s->sps->chroma_format_idc == 2) {
1890 lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1891 if (chroma_mode != 4) {
1892 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1895 mode_idx = intra_chroma_table[chroma_mode];
1897 mode_idx = lc->pu.intra_pred_mode[0];
1899 lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx];
1900 } else if (s->sps->chroma_format_idc != 0) {
1901 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1902 if (chroma_mode != 4) {
1903 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1904 lc->pu.intra_pred_mode_c[0] = 34;
1906 lc->pu.intra_pred_mode_c[0] = intra_chroma_table[chroma_mode];
1908 lc->pu.intra_pred_mode_c[0] = lc->pu.intra_pred_mode[0];
1913 static void intra_prediction_unit_default_value(HEVCContext *s,
1917 HEVCLocalContext *lc = s->HEVClc;
1918 int pb_size = 1 << log2_cb_size;
1919 int size_in_pus = pb_size >> s->sps->log2_min_pu_size;
1920 int min_pu_width = s->sps->min_pu_width;
1921 MvField *tab_mvf = s->ref->tab_mvf;
1922 int x_pu = x0 >> s->sps->log2_min_pu_size;
1923 int y_pu = y0 >> s->sps->log2_min_pu_size;
1926 if (size_in_pus == 0)
1928 for (j = 0; j < size_in_pus; j++)
1929 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
1930 if (lc->cu.pred_mode == MODE_INTRA)
1931 for (j = 0; j < size_in_pus; j++)
1932 for (k = 0; k < size_in_pus; k++)
1933 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].pred_flag = PF_INTRA;
1936 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
1938 int cb_size = 1 << log2_cb_size;
1939 HEVCLocalContext *lc = s->HEVClc;
1940 int log2_min_cb_size = s->sps->log2_min_cb_size;
1941 int length = cb_size >> log2_min_cb_size;
1942 int min_cb_width = s->sps->min_cb_width;
1943 int x_cb = x0 >> log2_min_cb_size;
1944 int y_cb = y0 >> log2_min_cb_size;
1945 int idx = log2_cb_size - 2;
1946 int qp_block_mask = (1<<(s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth)) - 1;
1951 lc->cu.pred_mode = MODE_INTRA;
1952 lc->cu.part_mode = PART_2Nx2N;
1953 lc->cu.intra_split_flag = 0;
1955 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
1956 for (x = 0; x < 4; x++)
1957 lc->pu.intra_pred_mode[x] = 1;
1958 if (s->pps->transquant_bypass_enable_flag) {
1959 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
1960 if (lc->cu.cu_transquant_bypass_flag)
1961 set_deblocking_bypass(s, x0, y0, log2_cb_size);
1963 lc->cu.cu_transquant_bypass_flag = 0;
1965 if (s->sh.slice_type != I_SLICE) {
1966 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
1968 x = y_cb * min_cb_width + x_cb;
1969 for (y = 0; y < length; y++) {
1970 memset(&s->skip_flag[x], skip_flag, length);
1973 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
1975 x = y_cb * min_cb_width + x_cb;
1976 for (y = 0; y < length; y++) {
1977 memset(&s->skip_flag[x], 0, length);
1982 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
1983 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
1984 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
1986 if (!s->sh.disable_deblocking_filter_flag)
1987 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1991 if (s->sh.slice_type != I_SLICE)
1992 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
1993 if (lc->cu.pred_mode != MODE_INTRA ||
1994 log2_cb_size == s->sps->log2_min_cb_size) {
1995 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
1996 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
1997 lc->cu.pred_mode == MODE_INTRA;
2000 if (lc->cu.pred_mode == MODE_INTRA) {
2001 if (lc->cu.part_mode == PART_2Nx2N && s->sps->pcm_enabled_flag &&
2002 log2_cb_size >= s->sps->pcm.log2_min_pcm_cb_size &&
2003 log2_cb_size <= s->sps->pcm.log2_max_pcm_cb_size) {
2004 pcm_flag = ff_hevc_pcm_flag_decode(s);
2007 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2008 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2009 if (s->sps->pcm.loop_filter_disable_flag)
2010 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2015 intra_prediction_unit(s, x0, y0, log2_cb_size);
2018 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2019 switch (lc->cu.part_mode) {
2021 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2024 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0, idx);
2025 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2028 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2029 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2032 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0, idx);
2033 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2036 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2037 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2040 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0, idx - 2);
2041 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2044 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2045 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2048 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2049 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2050 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2051 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2057 int rqt_root_cbf = 1;
2059 if (lc->cu.pred_mode != MODE_INTRA &&
2060 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2061 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2064 const static int cbf[2] = { 0 };
2065 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2066 s->sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2067 s->sps->max_transform_hierarchy_depth_inter;
2068 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2070 log2_cb_size, 0, 0, cbf, cbf);
2074 if (!s->sh.disable_deblocking_filter_flag)
2075 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2080 if (s->pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2081 ff_hevc_set_qPy(s, x0, y0, log2_cb_size);
2083 x = y_cb * min_cb_width + x_cb;
2084 for (y = 0; y < length; y++) {
2085 memset(&s->qp_y_tab[x], lc->qp_y, length);
2089 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2090 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2091 lc->qPy_pred = lc->qp_y;
2094 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct_depth);
2099 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2100 int log2_cb_size, int cb_depth)
2102 HEVCLocalContext *lc = s->HEVClc;
2103 const int cb_size = 1 << log2_cb_size;
2107 lc->ct_depth = cb_depth;
2108 if (x0 + cb_size <= s->sps->width &&
2109 y0 + cb_size <= s->sps->height &&
2110 log2_cb_size > s->sps->log2_min_cb_size) {
2111 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2113 split_cu = (log2_cb_size > s->sps->log2_min_cb_size);
2115 if (s->pps->cu_qp_delta_enabled_flag &&
2116 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth) {
2117 lc->tu.is_cu_qp_delta_coded = 0;
2118 lc->tu.cu_qp_delta = 0;
2121 if (s->sh.cu_chroma_qp_offset_enabled_flag &&
2122 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_chroma_qp_offset_depth) {
2123 lc->tu.is_cu_chroma_qp_offset_coded = 0;
2127 int qp_block_mask = (1<<(s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth)) - 1;
2128 const int cb_size_split = cb_size >> 1;
2129 const int x1 = x0 + cb_size_split;
2130 const int y1 = y0 + cb_size_split;
2134 more_data = hls_coding_quadtree(s, x0, y0, log2_cb_size - 1, cb_depth + 1);
2138 if (more_data && x1 < s->sps->width) {
2139 more_data = hls_coding_quadtree(s, x1, y0, log2_cb_size - 1, cb_depth + 1);
2143 if (more_data && y1 < s->sps->height) {
2144 more_data = hls_coding_quadtree(s, x0, y1, log2_cb_size - 1, cb_depth + 1);
2148 if (more_data && x1 < s->sps->width &&
2149 y1 < s->sps->height) {
2150 more_data = hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1);
2155 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2156 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2157 lc->qPy_pred = lc->qp_y;
2160 return ((x1 + cb_size_split) < s->sps->width ||
2161 (y1 + cb_size_split) < s->sps->height);
2165 ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2168 if ((!((x0 + cb_size) %
2169 (1 << (s->sps->log2_ctb_size))) ||
2170 (x0 + cb_size >= s->sps->width)) &&
2172 (1 << (s->sps->log2_ctb_size))) ||
2173 (y0 + cb_size >= s->sps->height))) {
2174 int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s);
2175 return !end_of_slice_flag;
2184 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2187 HEVCLocalContext *lc = s->HEVClc;
2188 int ctb_size = 1 << s->sps->log2_ctb_size;
2189 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2190 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2192 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2194 if (s->pps->entropy_coding_sync_enabled_flag) {
2195 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2196 lc->first_qp_group = 1;
2197 lc->end_of_tiles_x = s->sps->width;
2198 } else if (s->pps->tiles_enabled_flag) {
2199 if (ctb_addr_ts && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1]) {
2200 int idxX = s->pps->col_idxX[x_ctb >> s->sps->log2_ctb_size];
2201 lc->end_of_tiles_x = x_ctb + (s->pps->column_width[idxX] << s->sps->log2_ctb_size);
2202 lc->first_qp_group = 1;
2205 lc->end_of_tiles_x = s->sps->width;
2208 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->sps->height);
2210 lc->boundary_flags = 0;
2211 if (s->pps->tiles_enabled_flag) {
2212 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]])
2213 lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2214 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2215 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2216 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]])
2217 lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2218 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->sps->ctb_width])
2219 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2221 if (!ctb_addr_in_slice > 0)
2222 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2223 if (ctb_addr_in_slice < s->sps->ctb_width)
2224 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2227 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2228 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2229 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]]));
2230 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]]));
2233 static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
2235 HEVCContext *s = avctxt->priv_data;
2236 int ctb_size = 1 << s->sps->log2_ctb_size;
2240 int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2242 if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) {
2243 av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n");
2244 return AVERROR_INVALIDDATA;
2247 if (s->sh.dependent_slice_segment_flag) {
2248 int prev_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2249 if (s->tab_slice_address[prev_rs] != s->sh.slice_addr) {
2250 av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n");
2251 return AVERROR_INVALIDDATA;
2255 while (more_data && ctb_addr_ts < s->sps->ctb_size) {
2256 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2258 x_ctb = (ctb_addr_rs % ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2259 y_ctb = (ctb_addr_rs / ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2260 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2262 ff_hevc_cabac_init(s, ctb_addr_ts);
2264 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2266 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2267 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2268 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2270 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2271 if (more_data < 0) {
2272 s->tab_slice_address[ctb_addr_rs] = -1;
2278 ff_hevc_save_states(s, ctb_addr_ts);
2279 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2282 if (x_ctb + ctb_size >= s->sps->width &&
2283 y_ctb + ctb_size >= s->sps->height)
2284 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2289 static int hls_slice_data(HEVCContext *s)
2297 s->avctx->execute(s->avctx, hls_decode_entry, arg, ret , 1, sizeof(int));
2300 static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int job, int self_id)
2302 HEVCContext *s1 = avctxt->priv_data, *s;
2303 HEVCLocalContext *lc;
2304 int ctb_size = 1<< s1->sps->log2_ctb_size;
2306 int *ctb_row_p = input_ctb_row;
2307 int ctb_row = ctb_row_p[job];
2308 int ctb_addr_rs = s1->sh.slice_ctb_addr_rs + ctb_row * ((s1->sps->width + ctb_size - 1) >> s1->sps->log2_ctb_size);
2309 int ctb_addr_ts = s1->pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2310 int thread = ctb_row % s1->threads_number;
2313 s = s1->sList[self_id];
2317 ret = init_get_bits8(&lc->gb, s->data + s->sh.offset[ctb_row - 1], s->sh.size[ctb_row - 1]);
2321 ff_init_cabac_decoder(&lc->cc, s->data + s->sh.offset[(ctb_row)-1], s->sh.size[ctb_row - 1]);
2324 while(more_data && ctb_addr_ts < s->sps->ctb_size) {
2325 int x_ctb = (ctb_addr_rs % s->sps->ctb_width) << s->sps->log2_ctb_size;
2326 int y_ctb = (ctb_addr_rs / s->sps->ctb_width) << s->sps->log2_ctb_size;
2328 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2330 ff_thread_await_progress2(s->avctx, ctb_row, thread, SHIFT_CTB_WPP);
2332 if (avpriv_atomic_int_get(&s1->wpp_err)){
2333 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2337 ff_hevc_cabac_init(s, ctb_addr_ts);
2338 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2339 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2341 if (more_data < 0) {
2342 s->tab_slice_address[ctb_addr_rs] = -1;
2348 ff_hevc_save_states(s, ctb_addr_ts);
2349 ff_thread_report_progress2(s->avctx, ctb_row, thread, 1);
2350 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2352 if (!more_data && (x_ctb+ctb_size) < s->sps->width && ctb_row != s->sh.num_entry_point_offsets) {
2353 avpriv_atomic_int_set(&s1->wpp_err, 1);
2354 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2358 if ((x_ctb+ctb_size) >= s->sps->width && (y_ctb+ctb_size) >= s->sps->height ) {
2359 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2360 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2363 ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2366 if(x_ctb >= s->sps->width) {
2370 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2375 static int hls_slice_data_wpp(HEVCContext *s, const uint8_t *nal, int length)
2377 HEVCLocalContext *lc = s->HEVClc;
2378 int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2379 int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2381 int startheader, cmpt = 0;
2386 ff_alloc_entries(s->avctx, s->sh.num_entry_point_offsets + 1);
2389 for (i = 1; i < s->threads_number; i++) {
2390 s->sList[i] = av_malloc(sizeof(HEVCContext));
2391 memcpy(s->sList[i], s, sizeof(HEVCContext));
2392 s->HEVClcList[i] = av_mallocz(sizeof(HEVCLocalContext));
2393 s->sList[i]->HEVClc = s->HEVClcList[i];
2397 offset = (lc->gb.index >> 3);
2399 for (j = 0, cmpt = 0, startheader = offset + s->sh.entry_point_offset[0]; j < s->skipped_bytes; j++) {
2400 if (s->skipped_bytes_pos[j] >= offset && s->skipped_bytes_pos[j] < startheader) {
2406 for (i = 1; i < s->sh.num_entry_point_offsets; i++) {
2407 offset += (s->sh.entry_point_offset[i - 1] - cmpt);
2408 for (j = 0, cmpt = 0, startheader = offset
2409 + s->sh.entry_point_offset[i]; j < s->skipped_bytes; j++) {
2410 if (s->skipped_bytes_pos[j] >= offset && s->skipped_bytes_pos[j] < startheader) {
2415 s->sh.size[i - 1] = s->sh.entry_point_offset[i] - cmpt;
2416 s->sh.offset[i - 1] = offset;
2419 if (s->sh.num_entry_point_offsets != 0) {
2420 offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt;
2421 s->sh.size[s->sh.num_entry_point_offsets - 1] = length - offset;
2422 s->sh.offset[s->sh.num_entry_point_offsets - 1] = offset;
2427 for (i = 1; i < s->threads_number; i++) {
2428 s->sList[i]->HEVClc->first_qp_group = 1;
2429 s->sList[i]->HEVClc->qp_y = s->sList[0]->HEVClc->qp_y;
2430 memcpy(s->sList[i], s, sizeof(HEVCContext));
2431 s->sList[i]->HEVClc = s->HEVClcList[i];
2434 avpriv_atomic_int_set(&s->wpp_err, 0);
2435 ff_reset_entries(s->avctx);
2437 for (i = 0; i <= s->sh.num_entry_point_offsets; i++) {
2442 if (s->pps->entropy_coding_sync_enabled_flag)
2443 s->avctx->execute2(s->avctx, (void *) hls_decode_entry_wpp, arg, ret, s->sh.num_entry_point_offsets + 1);
2445 for (i = 0; i <= s->sh.num_entry_point_offsets; i++)
2453 * @return AVERROR_INVALIDDATA if the packet is not a valid NAL unit,
2454 * 0 if the unit should be skipped, 1 otherwise
2456 static int hls_nal_unit(HEVCContext *s)
2458 GetBitContext *gb = &s->HEVClc->gb;
2461 if (get_bits1(gb) != 0)
2462 return AVERROR_INVALIDDATA;
2464 s->nal_unit_type = get_bits(gb, 6);
2466 nuh_layer_id = get_bits(gb, 6);
2467 s->temporal_id = get_bits(gb, 3) - 1;
2468 if (s->temporal_id < 0)
2469 return AVERROR_INVALIDDATA;
2471 av_log(s->avctx, AV_LOG_DEBUG,
2472 "nal_unit_type: %d, nuh_layer_id: %d, temporal_id: %d\n",
2473 s->nal_unit_type, nuh_layer_id, s->temporal_id);
2475 return nuh_layer_id == 0;
2478 static int set_side_data(HEVCContext *s)
2480 AVFrame *out = s->ref->frame;
2482 if (s->sei_frame_packing_present &&
2483 s->frame_packing_arrangement_type >= 3 &&
2484 s->frame_packing_arrangement_type <= 5 &&
2485 s->content_interpretation_type > 0 &&
2486 s->content_interpretation_type < 3) {
2487 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2489 return AVERROR(ENOMEM);
2491 switch (s->frame_packing_arrangement_type) {
2493 if (s->quincunx_subsampling)
2494 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2496 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2499 stereo->type = AV_STEREO3D_TOPBOTTOM;
2502 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2506 if (s->content_interpretation_type == 2)
2507 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2510 if (s->sei_display_orientation_present &&
2511 (s->sei_anticlockwise_rotation || s->sei_hflip || s->sei_vflip)) {
2512 double angle = s->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
2513 AVFrameSideData *rotation = av_frame_new_side_data(out,
2514 AV_FRAME_DATA_DISPLAYMATRIX,
2515 sizeof(int32_t) * 9);
2517 return AVERROR(ENOMEM);
2519 av_display_rotation_set((int32_t *)rotation->data, angle);
2520 av_display_matrix_flip((int32_t *)rotation->data,
2521 s->sei_hflip, s->sei_vflip);
2527 static int hevc_frame_start(HEVCContext *s)
2529 HEVCLocalContext *lc = s->HEVClc;
2530 int pic_size_in_ctb = ((s->sps->width >> s->sps->log2_min_cb_size) + 1) *
2531 ((s->sps->height >> s->sps->log2_min_cb_size) + 1);
2534 memset(s->horizontal_bs, 0, s->bs_width * s->bs_height);
2535 memset(s->vertical_bs, 0, s->bs_width * s->bs_height);
2536 memset(s->cbf_luma, 0, s->sps->min_tb_width * s->sps->min_tb_height);
2537 memset(s->is_pcm, 0, (s->sps->min_pu_width + 1) * (s->sps->min_pu_height + 1));
2538 memset(s->tab_slice_address, -1, pic_size_in_ctb * sizeof(*s->tab_slice_address));
2541 s->first_nal_type = s->nal_unit_type;
2543 if (s->pps->tiles_enabled_flag)
2544 lc->end_of_tiles_x = s->pps->column_width[0] << s->sps->log2_ctb_size;
2546 ret = ff_hevc_set_new_ref(s, &s->frame, s->poc);
2550 ret = ff_hevc_frame_rps(s);
2552 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2556 s->ref->frame->key_frame = IS_IRAP(s);
2558 ret = set_side_data(s);
2562 s->frame->pict_type = 3 - s->sh.slice_type;
2565 ff_hevc_bump_frame(s);
2567 av_frame_unref(s->output_frame);
2568 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2572 ff_thread_finish_setup(s->avctx);
2577 if (s->ref && s->threads_type == FF_THREAD_FRAME)
2578 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2583 static int decode_nal_unit(HEVCContext *s, const uint8_t *nal, int length)
2585 HEVCLocalContext *lc = s->HEVClc;
2586 GetBitContext *gb = &lc->gb;
2587 int ctb_addr_ts, ret;
2589 ret = init_get_bits8(gb, nal, length);
2593 ret = hls_nal_unit(s);
2595 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit %d, skipping.\n",
2601 switch (s->nal_unit_type) {
2603 ret = ff_hevc_decode_nal_vps(s);
2608 ret = ff_hevc_decode_nal_sps(s);
2613 ret = ff_hevc_decode_nal_pps(s);
2617 case NAL_SEI_PREFIX:
2618 case NAL_SEI_SUFFIX:
2619 ret = ff_hevc_decode_nal_sei(s);
2630 case NAL_BLA_W_RADL:
2632 case NAL_IDR_W_RADL:
2639 ret = hls_slice_header(s);
2643 if (s->max_ra == INT_MAX) {
2644 if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
2648 s->max_ra = INT_MIN;
2652 if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
2653 s->poc <= s->max_ra) {
2657 if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
2658 s->max_ra = INT_MIN;
2661 if (s->sh.first_slice_in_pic_flag) {
2662 ret = hevc_frame_start(s);
2665 } else if (!s->ref) {
2666 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2670 if (s->nal_unit_type != s->first_nal_type) {
2671 av_log(s->avctx, AV_LOG_ERROR,
2672 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2673 s->first_nal_type, s->nal_unit_type);
2674 return AVERROR_INVALIDDATA;
2677 if (!s->sh.dependent_slice_segment_flag &&
2678 s->sh.slice_type != I_SLICE) {
2679 ret = ff_hevc_slice_rpl(s);
2681 av_log(s->avctx, AV_LOG_WARNING,
2682 "Error constructing the reference lists for the current slice.\n");
2687 if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
2688 ctb_addr_ts = hls_slice_data_wpp(s, nal, length);
2690 ctb_addr_ts = hls_slice_data(s);
2691 if (ctb_addr_ts >= (s->sps->ctb_width * s->sps->ctb_height)) {
2695 if (ctb_addr_ts < 0) {
2702 s->seq_decode = (s->seq_decode + 1) & 0xff;
2703 s->max_ra = INT_MAX;
2709 av_log(s->avctx, AV_LOG_INFO,
2710 "Skipping NAL unit %d\n", s->nal_unit_type);
2715 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2720 /* FIXME: This is adapted from ff_h264_decode_nal, avoiding duplication
2721 * between these functions would be nice. */
2722 int ff_hevc_extract_rbsp(HEVCContext *s, const uint8_t *src, int length,
2728 s->skipped_bytes = 0;
2729 #define STARTCODE_TEST \
2730 if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \
2731 if (src[i + 2] != 3) { \
2732 /* startcode, so we must be past the end */ \
2737 #if HAVE_FAST_UNALIGNED
2738 #define FIND_FIRST_ZERO \
2739 if (i > 0 && !src[i]) \
2744 for (i = 0; i + 1 < length; i += 9) {
2745 if (!((~AV_RN64A(src + i) &
2746 (AV_RN64A(src + i) - 0x0100010001000101ULL)) &
2747 0x8000800080008080ULL))
2754 for (i = 0; i + 1 < length; i += 5) {
2755 if (!((~AV_RN32A(src + i) &
2756 (AV_RN32A(src + i) - 0x01000101U)) &
2763 #endif /* HAVE_FAST_64BIT */
2765 for (i = 0; i + 1 < length; i += 2) {
2768 if (i > 0 && src[i - 1] == 0)
2772 #endif /* HAVE_FAST_UNALIGNED */
2774 if (i >= length - 1) { // no escaped 0
2780 av_fast_malloc(&nal->rbsp_buffer, &nal->rbsp_buffer_size,
2781 length + FF_INPUT_BUFFER_PADDING_SIZE);
2782 if (!nal->rbsp_buffer)
2783 return AVERROR(ENOMEM);
2785 dst = nal->rbsp_buffer;
2787 memcpy(dst, src, i);
2789 while (si + 2 < length) {
2790 // remove escapes (very rare 1:2^22)
2791 if (src[si + 2] > 3) {
2792 dst[di++] = src[si++];
2793 dst[di++] = src[si++];
2794 } else if (src[si] == 0 && src[si + 1] == 0) {
2795 if (src[si + 2] == 3) { // escape
2801 if (s->skipped_bytes_pos_size < s->skipped_bytes) {
2802 s->skipped_bytes_pos_size *= 2;
2803 av_reallocp_array(&s->skipped_bytes_pos,
2804 s->skipped_bytes_pos_size,
2805 sizeof(*s->skipped_bytes_pos));
2806 if (!s->skipped_bytes_pos)
2807 return AVERROR(ENOMEM);
2809 if (s->skipped_bytes_pos)
2810 s->skipped_bytes_pos[s->skipped_bytes-1] = di - 1;
2812 } else // next start code
2816 dst[di++] = src[si++];
2819 dst[di++] = src[si++];
2822 memset(dst + di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2829 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2831 int i, consumed, ret = 0;
2834 s->last_eos = s->eos;
2837 /* split the input packet into NAL units, so we know the upper bound on the
2838 * number of slices in the frame */
2840 while (length >= 4) {
2842 int extract_length = 0;
2846 for (i = 0; i < s->nal_length_size; i++)
2847 extract_length = (extract_length << 8) | buf[i];
2848 buf += s->nal_length_size;
2849 length -= s->nal_length_size;
2851 if (extract_length > length) {
2852 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit size.\n");
2853 ret = AVERROR_INVALIDDATA;
2857 /* search start code */
2858 while (buf[0] != 0 || buf[1] != 0 || buf[2] != 1) {
2862 av_log(s->avctx, AV_LOG_ERROR, "No start code is found.\n");
2863 ret = AVERROR_INVALIDDATA;
2873 extract_length = length;
2875 if (s->nals_allocated < s->nb_nals + 1) {
2876 int new_size = s->nals_allocated + 1;
2877 HEVCNAL *tmp = av_realloc_array(s->nals, new_size, sizeof(*tmp));
2879 ret = AVERROR(ENOMEM);
2883 memset(s->nals + s->nals_allocated, 0,
2884 (new_size - s->nals_allocated) * sizeof(*tmp));
2885 av_reallocp_array(&s->skipped_bytes_nal, new_size, sizeof(*s->skipped_bytes_nal));
2886 av_reallocp_array(&s->skipped_bytes_pos_size_nal, new_size, sizeof(*s->skipped_bytes_pos_size_nal));
2887 av_reallocp_array(&s->skipped_bytes_pos_nal, new_size, sizeof(*s->skipped_bytes_pos_nal));
2888 s->skipped_bytes_pos_size_nal[s->nals_allocated] = 1024; // initial buffer size
2889 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));
2890 s->nals_allocated = new_size;
2892 s->skipped_bytes_pos_size = s->skipped_bytes_pos_size_nal[s->nb_nals];
2893 s->skipped_bytes_pos = s->skipped_bytes_pos_nal[s->nb_nals];
2894 nal = &s->nals[s->nb_nals];
2896 consumed = ff_hevc_extract_rbsp(s, buf, extract_length, nal);
2898 s->skipped_bytes_nal[s->nb_nals] = s->skipped_bytes;
2899 s->skipped_bytes_pos_size_nal[s->nb_nals] = s->skipped_bytes_pos_size;
2900 s->skipped_bytes_pos_nal[s->nb_nals++] = s->skipped_bytes_pos;
2908 ret = init_get_bits8(&s->HEVClc->gb, nal->data, nal->size);
2913 if (s->nal_unit_type == NAL_EOB_NUT ||
2914 s->nal_unit_type == NAL_EOS_NUT)
2921 /* parse the NAL units */
2922 for (i = 0; i < s->nb_nals; i++) {
2924 s->skipped_bytes = s->skipped_bytes_nal[i];
2925 s->skipped_bytes_pos = s->skipped_bytes_pos_nal[i];
2927 ret = decode_nal_unit(s, s->nals[i].data, s->nals[i].size);
2929 av_log(s->avctx, AV_LOG_WARNING,
2930 "Error parsing NAL unit #%d.\n", i);
2936 if (s->ref && s->threads_type == FF_THREAD_FRAME)
2937 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2942 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2945 for (i = 0; i < 16; i++)
2946 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
2949 static int verify_md5(HEVCContext *s, AVFrame *frame)
2951 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
2956 return AVERROR(EINVAL);
2958 pixel_shift = desc->comp[0].depth_minus1 > 7;
2960 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
2963 /* the checksums are LE, so we have to byteswap for >8bpp formats
2966 if (pixel_shift && !s->checksum_buf) {
2967 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
2968 FFMAX3(frame->linesize[0], frame->linesize[1],
2969 frame->linesize[2]));
2970 if (!s->checksum_buf)
2971 return AVERROR(ENOMEM);
2975 for (i = 0; frame->data[i]; i++) {
2976 int width = s->avctx->coded_width;
2977 int height = s->avctx->coded_height;
2978 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
2979 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
2982 av_md5_init(s->md5_ctx);
2983 for (j = 0; j < h; j++) {
2984 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
2987 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
2988 (const uint16_t *) src, w);
2989 src = s->checksum_buf;
2992 av_md5_update(s->md5_ctx, src, w << pixel_shift);
2994 av_md5_final(s->md5_ctx, md5);
2996 if (!memcmp(md5, s->md5[i], 16)) {
2997 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
2998 print_md5(s->avctx, AV_LOG_DEBUG, md5);
2999 av_log (s->avctx, AV_LOG_DEBUG, "; ");
3001 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
3002 print_md5(s->avctx, AV_LOG_ERROR, md5);
3003 av_log (s->avctx, AV_LOG_ERROR, " != ");
3004 print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
3005 av_log (s->avctx, AV_LOG_ERROR, "\n");
3006 return AVERROR_INVALIDDATA;
3010 av_log(s->avctx, AV_LOG_DEBUG, "\n");
3015 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
3019 HEVCContext *s = avctx->priv_data;
3022 ret = ff_hevc_output_frame(s, data, 1);
3031 ret = decode_nal_units(s, avpkt->data, avpkt->size);
3035 /* verify the SEI checksum */
3036 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
3038 ret = verify_md5(s, s->ref->frame);
3039 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
3040 ff_hevc_unref_frame(s, s->ref, ~0);
3046 if (s->is_decoded) {
3047 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
3051 if (s->output_frame->buf[0]) {
3052 av_frame_move_ref(data, s->output_frame);
3059 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
3063 ret = ff_thread_ref_frame(&dst->tf, &src->tf);
3067 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
3068 if (!dst->tab_mvf_buf)
3070 dst->tab_mvf = src->tab_mvf;
3072 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
3073 if (!dst->rpl_tab_buf)
3075 dst->rpl_tab = src->rpl_tab;
3077 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
3081 dst->poc = src->poc;
3082 dst->ctb_count = src->ctb_count;
3083 dst->window = src->window;
3084 dst->flags = src->flags;
3085 dst->sequence = src->sequence;
3089 ff_hevc_unref_frame(s, dst, ~0);
3090 return AVERROR(ENOMEM);
3093 static av_cold int hevc_decode_free(AVCodecContext *avctx)
3095 HEVCContext *s = avctx->priv_data;
3100 av_freep(&s->md5_ctx);
3102 for(i=0; i < s->nals_allocated; i++) {
3103 av_freep(&s->skipped_bytes_pos_nal[i]);
3105 av_freep(&s->skipped_bytes_pos_size_nal);
3106 av_freep(&s->skipped_bytes_nal);
3107 av_freep(&s->skipped_bytes_pos_nal);
3109 av_freep(&s->cabac_state);
3111 av_frame_free(&s->tmp_frame);
3112 av_frame_free(&s->output_frame);
3114 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3115 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3116 av_frame_free(&s->DPB[i].frame);
3119 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++)
3120 av_buffer_unref(&s->vps_list[i]);
3121 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++)
3122 av_buffer_unref(&s->sps_list[i]);
3123 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
3124 av_buffer_unref(&s->pps_list[i]);
3129 av_buffer_unref(&s->current_sps);
3131 av_freep(&s->sh.entry_point_offset);
3132 av_freep(&s->sh.offset);
3133 av_freep(&s->sh.size);
3135 for (i = 1; i < s->threads_number; i++) {
3136 HEVCLocalContext *lc = s->HEVClcList[i];
3138 av_freep(&s->HEVClcList[i]);
3139 av_freep(&s->sList[i]);
3142 if (s->HEVClc == s->HEVClcList[0])
3144 av_freep(&s->HEVClcList[0]);
3146 for (i = 0; i < s->nals_allocated; i++)
3147 av_freep(&s->nals[i].rbsp_buffer);
3149 s->nals_allocated = 0;
3154 static av_cold int hevc_init_context(AVCodecContext *avctx)
3156 HEVCContext *s = avctx->priv_data;
3161 s->HEVClc = av_mallocz(sizeof(HEVCLocalContext));
3164 s->HEVClcList[0] = s->HEVClc;
3167 s->cabac_state = av_malloc(HEVC_CONTEXTS);
3168 if (!s->cabac_state)
3171 s->tmp_frame = av_frame_alloc();
3175 s->output_frame = av_frame_alloc();
3176 if (!s->output_frame)
3179 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3180 s->DPB[i].frame = av_frame_alloc();
3181 if (!s->DPB[i].frame)
3183 s->DPB[i].tf.f = s->DPB[i].frame;
3186 s->max_ra = INT_MAX;
3188 s->md5_ctx = av_md5_alloc();
3192 ff_bswapdsp_init(&s->bdsp);
3194 s->context_initialized = 1;
3200 hevc_decode_free(avctx);
3201 return AVERROR(ENOMEM);
3204 static int hevc_update_thread_context(AVCodecContext *dst,
3205 const AVCodecContext *src)
3207 HEVCContext *s = dst->priv_data;
3208 HEVCContext *s0 = src->priv_data;
3211 if (!s->context_initialized) {
3212 ret = hevc_init_context(dst);
3217 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3218 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3219 if (s0->DPB[i].frame->buf[0]) {
3220 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3226 if (s->sps != s0->sps)
3228 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++) {
3229 av_buffer_unref(&s->vps_list[i]);
3230 if (s0->vps_list[i]) {
3231 s->vps_list[i] = av_buffer_ref(s0->vps_list[i]);
3232 if (!s->vps_list[i])
3233 return AVERROR(ENOMEM);
3237 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++) {
3238 av_buffer_unref(&s->sps_list[i]);
3239 if (s0->sps_list[i]) {
3240 s->sps_list[i] = av_buffer_ref(s0->sps_list[i]);
3241 if (!s->sps_list[i])
3242 return AVERROR(ENOMEM);
3246 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++) {
3247 av_buffer_unref(&s->pps_list[i]);
3248 if (s0->pps_list[i]) {
3249 s->pps_list[i] = av_buffer_ref(s0->pps_list[i]);
3250 if (!s->pps_list[i])
3251 return AVERROR(ENOMEM);
3255 av_buffer_unref(&s->current_sps);
3256 if (s0->current_sps) {
3257 s->current_sps = av_buffer_ref(s0->current_sps);
3258 if (!s->current_sps)
3259 return AVERROR(ENOMEM);
3262 if (s->sps != s0->sps)
3263 if ((ret = set_sps(s, s0->sps)) < 0)
3266 s->seq_decode = s0->seq_decode;
3267 s->seq_output = s0->seq_output;
3268 s->pocTid0 = s0->pocTid0;
3269 s->max_ra = s0->max_ra;
3272 s->is_nalff = s0->is_nalff;
3273 s->nal_length_size = s0->nal_length_size;
3275 s->threads_number = s0->threads_number;
3276 s->threads_type = s0->threads_type;
3279 s->seq_decode = (s->seq_decode + 1) & 0xff;
3280 s->max_ra = INT_MAX;
3286 static int hevc_decode_extradata(HEVCContext *s)
3288 AVCodecContext *avctx = s->avctx;
3292 bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
3294 if (avctx->extradata_size > 3 &&
3295 (avctx->extradata[0] || avctx->extradata[1] ||
3296 avctx->extradata[2] > 1)) {
3297 /* It seems the extradata is encoded as hvcC format.
3298 * Temporarily, we support configurationVersion==0 until 14496-15 3rd
3299 * is finalized. When finalized, configurationVersion will be 1 and we
3300 * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
3301 int i, j, num_arrays, nal_len_size;
3305 bytestream2_skip(&gb, 21);
3306 nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
3307 num_arrays = bytestream2_get_byte(&gb);
3309 /* nal units in the hvcC always have length coded with 2 bytes,
3310 * so put a fake nal_length_size = 2 while parsing them */
3311 s->nal_length_size = 2;
3313 /* Decode nal units from hvcC. */
3314 for (i = 0; i < num_arrays; i++) {
3315 int type = bytestream2_get_byte(&gb) & 0x3f;
3316 int cnt = bytestream2_get_be16(&gb);
3318 for (j = 0; j < cnt; j++) {
3319 // +2 for the nal size field
3320 int nalsize = bytestream2_peek_be16(&gb) + 2;
3321 if (bytestream2_get_bytes_left(&gb) < nalsize) {
3322 av_log(s->avctx, AV_LOG_ERROR,
3323 "Invalid NAL unit size in extradata.\n");
3324 return AVERROR_INVALIDDATA;
3327 ret = decode_nal_units(s, gb.buffer, nalsize);
3329 av_log(avctx, AV_LOG_ERROR,
3330 "Decoding nal unit %d %d from hvcC failed\n",
3334 bytestream2_skip(&gb, nalsize);
3338 /* Now store right nal length size, that will be used to parse
3340 s->nal_length_size = nal_len_size;
3343 ret = decode_nal_units(s, avctx->extradata, avctx->extradata_size);
3350 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3352 HEVCContext *s = avctx->priv_data;
3355 ff_init_cabac_states();
3357 avctx->internal->allocate_progress = 1;
3359 ret = hevc_init_context(avctx);
3363 s->enable_parallel_tiles = 0;
3364 s->picture_struct = 0;
3366 if(avctx->active_thread_type & FF_THREAD_SLICE)
3367 s->threads_number = avctx->thread_count;
3369 s->threads_number = 1;
3371 if (avctx->extradata_size > 0 && avctx->extradata) {
3372 ret = hevc_decode_extradata(s);
3374 hevc_decode_free(avctx);
3379 if((avctx->active_thread_type & FF_THREAD_FRAME) && avctx->thread_count > 1)
3380 s->threads_type = FF_THREAD_FRAME;
3382 s->threads_type = FF_THREAD_SLICE;
3387 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3389 HEVCContext *s = avctx->priv_data;
3392 memset(s, 0, sizeof(*s));
3394 ret = hevc_init_context(avctx);
3401 static void hevc_decode_flush(AVCodecContext *avctx)
3403 HEVCContext *s = avctx->priv_data;
3404 ff_hevc_flush_dpb(s);
3405 s->max_ra = INT_MAX;
3408 #define OFFSET(x) offsetof(HEVCContext, x)
3409 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3411 static const AVProfile profiles[] = {
3412 { FF_PROFILE_HEVC_MAIN, "Main" },
3413 { FF_PROFILE_HEVC_MAIN_10, "Main 10" },
3414 { FF_PROFILE_HEVC_MAIN_STILL_PICTURE, "Main Still Picture" },
3415 { FF_PROFILE_HEVC_REXT, "Rext" },
3416 { FF_PROFILE_UNKNOWN },
3419 static const AVOption options[] = {
3420 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3421 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3422 { "strict-displaywin", "stricly apply default display window size", OFFSET(apply_defdispwin),
3423 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3427 static const AVClass hevc_decoder_class = {
3428 .class_name = "HEVC decoder",
3429 .item_name = av_default_item_name,
3431 .version = LIBAVUTIL_VERSION_INT,
3434 AVCodec ff_hevc_decoder = {
3436 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3437 .type = AVMEDIA_TYPE_VIDEO,
3438 .id = AV_CODEC_ID_HEVC,
3439 .priv_data_size = sizeof(HEVCContext),
3440 .priv_class = &hevc_decoder_class,
3441 .init = hevc_decode_init,
3442 .close = hevc_decode_free,
3443 .decode = hevc_decode_frame,
3444 .flush = hevc_decode_flush,
3445 .update_thread_context = hevc_update_thread_context,
3446 .init_thread_copy = hevc_init_thread_copy,
3447 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY |
3448 CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS,
3449 .profiles = NULL_IF_CONFIG_SMALL(profiles),