4 * Copyright (C) 2012 - 2013 Guillaume Martres
5 * Copyright (C) 2012 - 2013 Mickael Raulet
6 * Copyright (C) 2012 - 2013 Gildas Cocherel
7 * Copyright (C) 2012 - 2013 Wassim Hamidouche
9 * This file is part of FFmpeg.
11 * FFmpeg is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
16 * FFmpeg is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with FFmpeg; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavutil/atomic.h"
27 #include "libavutil/attributes.h"
28 #include "libavutil/common.h"
29 #include "libavutil/display.h"
30 #include "libavutil/internal.h"
31 #include "libavutil/md5.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/pixdesc.h"
34 #include "libavutil/stereo3d.h"
37 #include "bytestream.h"
38 #include "cabac_functions.h"
42 const uint8_t ff_hevc_pel_weight[65] = { [2] = 0, [4] = 1, [6] = 2, [8] = 3, [12] = 4, [16] = 5, [24] = 6, [32] = 7, [48] = 8, [64] = 9 };
45 * NOTE: Each function hls_foo correspond to the function foo in the
46 * specification (HLS stands for High Level Syntax).
53 /* free everything allocated by pic_arrays_init() */
54 static void pic_arrays_free(HEVCContext *s)
57 av_freep(&s->deblock);
59 av_freep(&s->skip_flag);
60 av_freep(&s->tab_ct_depth);
62 av_freep(&s->tab_ipm);
63 av_freep(&s->cbf_luma);
66 av_freep(&s->qp_y_tab);
67 av_freep(&s->tab_slice_address);
68 av_freep(&s->filter_slice_edges);
70 av_freep(&s->horizontal_bs);
71 av_freep(&s->vertical_bs);
73 av_freep(&s->sh.entry_point_offset);
74 av_freep(&s->sh.size);
75 av_freep(&s->sh.offset);
77 av_buffer_pool_uninit(&s->tab_mvf_pool);
78 av_buffer_pool_uninit(&s->rpl_tab_pool);
81 /* allocate arrays that depend on frame dimensions */
82 static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
84 int log2_min_cb_size = sps->log2_min_cb_size;
85 int width = sps->width;
86 int height = sps->height;
87 int pic_size_in_ctb = ((width >> log2_min_cb_size) + 1) *
88 ((height >> log2_min_cb_size) + 1);
89 int ctb_count = sps->ctb_width * sps->ctb_height;
90 int min_pu_size = sps->min_pu_width * sps->min_pu_height;
92 s->bs_width = (width >> 2) + 1;
93 s->bs_height = (height >> 2) + 1;
95 s->sao = av_mallocz_array(ctb_count, sizeof(*s->sao));
96 s->deblock = av_mallocz_array(ctb_count, sizeof(*s->deblock));
97 if (!s->sao || !s->deblock)
100 s->skip_flag = av_malloc(sps->min_cb_height * sps->min_cb_width);
101 s->tab_ct_depth = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
102 if (!s->skip_flag || !s->tab_ct_depth)
105 s->cbf_luma = av_malloc_array(sps->min_tb_width, sps->min_tb_height);
106 s->tab_ipm = av_mallocz(min_pu_size);
107 s->is_pcm = av_malloc((sps->min_pu_width + 1) * (sps->min_pu_height + 1));
108 if (!s->tab_ipm || !s->cbf_luma || !s->is_pcm)
111 s->filter_slice_edges = av_malloc(ctb_count);
112 s->tab_slice_address = av_malloc_array(pic_size_in_ctb,
113 sizeof(*s->tab_slice_address));
114 s->qp_y_tab = av_malloc_array(pic_size_in_ctb,
115 sizeof(*s->qp_y_tab));
116 if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address)
119 s->horizontal_bs = av_mallocz_array(s->bs_width, s->bs_height);
120 s->vertical_bs = av_mallocz_array(s->bs_width, s->bs_height);
121 if (!s->horizontal_bs || !s->vertical_bs)
124 s->tab_mvf_pool = av_buffer_pool_init(min_pu_size * sizeof(MvField),
126 s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab),
128 if (!s->tab_mvf_pool || !s->rpl_tab_pool)
135 return AVERROR(ENOMEM);
138 static void pred_weight_table(HEVCContext *s, GetBitContext *gb)
142 uint8_t luma_weight_l0_flag[16];
143 uint8_t chroma_weight_l0_flag[16];
144 uint8_t luma_weight_l1_flag[16];
145 uint8_t chroma_weight_l1_flag[16];
147 s->sh.luma_log2_weight_denom = get_ue_golomb_long(gb);
148 if (s->sps->chroma_format_idc != 0) {
149 int delta = get_se_golomb(gb);
150 s->sh.chroma_log2_weight_denom = av_clip(s->sh.luma_log2_weight_denom + delta, 0, 7);
153 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
154 luma_weight_l0_flag[i] = get_bits1(gb);
155 if (!luma_weight_l0_flag[i]) {
156 s->sh.luma_weight_l0[i] = 1 << s->sh.luma_log2_weight_denom;
157 s->sh.luma_offset_l0[i] = 0;
160 if (s->sps->chroma_format_idc != 0) {
161 for (i = 0; i < s->sh.nb_refs[L0]; i++)
162 chroma_weight_l0_flag[i] = get_bits1(gb);
164 for (i = 0; i < s->sh.nb_refs[L0]; i++)
165 chroma_weight_l0_flag[i] = 0;
167 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
168 if (luma_weight_l0_flag[i]) {
169 int delta_luma_weight_l0 = get_se_golomb(gb);
170 s->sh.luma_weight_l0[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;
171 s->sh.luma_offset_l0[i] = get_se_golomb(gb);
173 if (chroma_weight_l0_flag[i]) {
174 for (j = 0; j < 2; j++) {
175 int delta_chroma_weight_l0 = get_se_golomb(gb);
176 int delta_chroma_offset_l0 = get_se_golomb(gb);
177 s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
178 s->sh.chroma_offset_l0[i][j] = av_clip((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j])
179 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
182 s->sh.chroma_weight_l0[i][0] = 1 << s->sh.chroma_log2_weight_denom;
183 s->sh.chroma_offset_l0[i][0] = 0;
184 s->sh.chroma_weight_l0[i][1] = 1 << s->sh.chroma_log2_weight_denom;
185 s->sh.chroma_offset_l0[i][1] = 0;
188 if (s->sh.slice_type == B_SLICE) {
189 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
190 luma_weight_l1_flag[i] = get_bits1(gb);
191 if (!luma_weight_l1_flag[i]) {
192 s->sh.luma_weight_l1[i] = 1 << s->sh.luma_log2_weight_denom;
193 s->sh.luma_offset_l1[i] = 0;
196 if (s->sps->chroma_format_idc != 0) {
197 for (i = 0; i < s->sh.nb_refs[L1]; i++)
198 chroma_weight_l1_flag[i] = get_bits1(gb);
200 for (i = 0; i < s->sh.nb_refs[L1]; i++)
201 chroma_weight_l1_flag[i] = 0;
203 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
204 if (luma_weight_l1_flag[i]) {
205 int delta_luma_weight_l1 = get_se_golomb(gb);
206 s->sh.luma_weight_l1[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;
207 s->sh.luma_offset_l1[i] = get_se_golomb(gb);
209 if (chroma_weight_l1_flag[i]) {
210 for (j = 0; j < 2; j++) {
211 int delta_chroma_weight_l1 = get_se_golomb(gb);
212 int delta_chroma_offset_l1 = get_se_golomb(gb);
213 s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
214 s->sh.chroma_offset_l1[i][j] = av_clip((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j])
215 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
218 s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom;
219 s->sh.chroma_offset_l1[i][0] = 0;
220 s->sh.chroma_weight_l1[i][1] = 1 << s->sh.chroma_log2_weight_denom;
221 s->sh.chroma_offset_l1[i][1] = 0;
227 static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
229 const HEVCSPS *sps = s->sps;
230 int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
231 int prev_delta_msb = 0;
232 unsigned int nb_sps = 0, nb_sh;
236 if (!sps->long_term_ref_pics_present_flag)
239 if (sps->num_long_term_ref_pics_sps > 0)
240 nb_sps = get_ue_golomb_long(gb);
241 nb_sh = get_ue_golomb_long(gb);
243 if (nb_sh + (uint64_t)nb_sps > FF_ARRAY_ELEMS(rps->poc))
244 return AVERROR_INVALIDDATA;
246 rps->nb_refs = nb_sh + nb_sps;
248 for (i = 0; i < rps->nb_refs; i++) {
249 uint8_t delta_poc_msb_present;
252 uint8_t lt_idx_sps = 0;
254 if (sps->num_long_term_ref_pics_sps > 1)
255 lt_idx_sps = get_bits(gb, av_ceil_log2(sps->num_long_term_ref_pics_sps));
257 rps->poc[i] = sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
258 rps->used[i] = sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];
260 rps->poc[i] = get_bits(gb, sps->log2_max_poc_lsb);
261 rps->used[i] = get_bits1(gb);
264 delta_poc_msb_present = get_bits1(gb);
265 if (delta_poc_msb_present) {
266 int delta = get_ue_golomb_long(gb);
268 if (i && i != nb_sps)
269 delta += prev_delta_msb;
271 rps->poc[i] += s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
272 prev_delta_msb = delta;
279 static int get_buffer_sao(HEVCContext *s, AVFrame *frame, const HEVCSPS *sps)
283 frame->width = s->avctx->coded_width + 2;
284 frame->height = s->avctx->coded_height + 2;
285 if ((ret = ff_get_buffer(s->avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
287 for (i = 0; frame->data[i]; i++) {
288 int offset = frame->linesize[i] + (1 << sps->pixel_shift);
289 frame->data[i] += offset;
291 frame->width = s->avctx->coded_width;
292 frame->height = s->avctx->coded_height;
297 static int set_sps(HEVCContext *s, const HEVCSPS *sps)
300 unsigned int num = 0, den = 0;
303 ret = pic_arrays_init(s, sps);
307 s->avctx->coded_width = sps->width;
308 s->avctx->coded_height = sps->height;
309 s->avctx->width = sps->output_width;
310 s->avctx->height = sps->output_height;
311 s->avctx->pix_fmt = sps->pix_fmt;
312 s->avctx->has_b_frames = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics;
314 ff_set_sar(s->avctx, sps->vui.sar);
316 if (sps->vui.video_signal_type_present_flag)
317 s->avctx->color_range = sps->vui.video_full_range_flag ? AVCOL_RANGE_JPEG
320 s->avctx->color_range = AVCOL_RANGE_MPEG;
322 if (sps->vui.colour_description_present_flag) {
323 s->avctx->color_primaries = sps->vui.colour_primaries;
324 s->avctx->color_trc = sps->vui.transfer_characteristic;
325 s->avctx->colorspace = sps->vui.matrix_coeffs;
327 s->avctx->color_primaries = AVCOL_PRI_UNSPECIFIED;
328 s->avctx->color_trc = AVCOL_TRC_UNSPECIFIED;
329 s->avctx->colorspace = AVCOL_SPC_UNSPECIFIED;
332 ff_hevc_pred_init(&s->hpc, sps->bit_depth);
333 ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
334 ff_videodsp_init (&s->vdsp, sps->bit_depth);
336 if (sps->sao_enabled) {
337 av_frame_unref(s->tmp_frame);
338 ret = get_buffer_sao(s, s->tmp_frame, sps);
339 s->sao_frame = s->tmp_frame;
343 s->vps = (HEVCVPS*) s->vps_list[s->sps->vps_id]->data;
345 if (s->vps->vps_timing_info_present_flag) {
346 num = s->vps->vps_num_units_in_tick;
347 den = s->vps->vps_time_scale;
348 } else if (sps->vui.vui_timing_info_present_flag) {
349 num = sps->vui.vui_num_units_in_tick;
350 den = sps->vui.vui_time_scale;
353 if (num != 0 && den != 0)
354 av_reduce(&s->avctx->framerate.den, &s->avctx->framerate.num,
365 static int hls_slice_header(HEVCContext *s)
367 GetBitContext *gb = &s->HEVClc->gb;
368 SliceHeader *sh = &s->sh;
372 sh->first_slice_in_pic_flag = get_bits1(gb);
373 if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
374 s->seq_decode = (s->seq_decode + 1) & 0xff;
377 ff_hevc_clear_refs(s);
379 sh->no_output_of_prior_pics_flag = 0;
381 sh->no_output_of_prior_pics_flag = get_bits1(gb);
383 sh->pps_id = get_ue_golomb_long(gb);
384 if (sh->pps_id >= MAX_PPS_COUNT || !s->pps_list[sh->pps_id]) {
385 av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
386 return AVERROR_INVALIDDATA;
388 if (!sh->first_slice_in_pic_flag &&
389 s->pps != (HEVCPPS*)s->pps_list[sh->pps_id]->data) {
390 av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
391 return AVERROR_INVALIDDATA;
393 s->pps = (HEVCPPS*)s->pps_list[sh->pps_id]->data;
394 if (s->nal_unit_type == NAL_CRA_NUT && s->last_eos == 1)
395 sh->no_output_of_prior_pics_flag = 1;
397 if (s->sps != (HEVCSPS*)s->sps_list[s->pps->sps_id]->data) {
398 const HEVCSPS* last_sps = s->sps;
399 s->sps = (HEVCSPS*)s->sps_list[s->pps->sps_id]->data;
400 if (last_sps && IS_IRAP(s) && s->nal_unit_type != NAL_CRA_NUT) {
401 if (s->sps->width != last_sps->width || s->sps->height != last_sps->height ||
402 s->sps->temporal_layer[s->sps->max_sub_layers - 1].max_dec_pic_buffering !=
403 last_sps->temporal_layer[last_sps->max_sub_layers - 1].max_dec_pic_buffering)
404 sh->no_output_of_prior_pics_flag = 0;
406 ff_hevc_clear_refs(s);
407 ret = set_sps(s, s->sps);
411 s->seq_decode = (s->seq_decode + 1) & 0xff;
415 s->avctx->profile = s->sps->ptl.general_ptl.profile_idc;
416 s->avctx->level = s->sps->ptl.general_ptl.level_idc;
418 sh->dependent_slice_segment_flag = 0;
419 if (!sh->first_slice_in_pic_flag) {
420 int slice_address_length;
422 if (s->pps->dependent_slice_segments_enabled_flag)
423 sh->dependent_slice_segment_flag = get_bits1(gb);
425 slice_address_length = av_ceil_log2(s->sps->ctb_width *
427 sh->slice_segment_addr = get_bits(gb, slice_address_length);
428 if (sh->slice_segment_addr >= s->sps->ctb_width * s->sps->ctb_height) {
429 av_log(s->avctx, AV_LOG_ERROR,
430 "Invalid slice segment address: %u.\n",
431 sh->slice_segment_addr);
432 return AVERROR_INVALIDDATA;
435 if (!sh->dependent_slice_segment_flag) {
436 sh->slice_addr = sh->slice_segment_addr;
440 sh->slice_segment_addr = sh->slice_addr = 0;
442 s->slice_initialized = 0;
445 if (!sh->dependent_slice_segment_flag) {
446 s->slice_initialized = 0;
448 for (i = 0; i < s->pps->num_extra_slice_header_bits; i++)
449 skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
451 sh->slice_type = get_ue_golomb_long(gb);
452 if (!(sh->slice_type == I_SLICE ||
453 sh->slice_type == P_SLICE ||
454 sh->slice_type == B_SLICE)) {
455 av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
457 return AVERROR_INVALIDDATA;
459 if (IS_IRAP(s) && sh->slice_type != I_SLICE) {
460 av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
461 return AVERROR_INVALIDDATA;
464 // when flag is not present, picture is inferred to be output
465 sh->pic_output_flag = 1;
466 if (s->pps->output_flag_present_flag)
467 sh->pic_output_flag = get_bits1(gb);
469 if (s->sps->separate_colour_plane_flag)
470 sh->colour_plane_id = get_bits(gb, 2);
473 int short_term_ref_pic_set_sps_flag, poc;
475 sh->pic_order_cnt_lsb = get_bits(gb, s->sps->log2_max_poc_lsb);
476 poc = ff_hevc_compute_poc(s, sh->pic_order_cnt_lsb);
477 if (!sh->first_slice_in_pic_flag && poc != s->poc) {
478 av_log(s->avctx, AV_LOG_WARNING,
479 "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
480 if (s->avctx->err_recognition & AV_EF_EXPLODE)
481 return AVERROR_INVALIDDATA;
486 short_term_ref_pic_set_sps_flag = get_bits1(gb);
487 if (!short_term_ref_pic_set_sps_flag) {
488 ret = ff_hevc_decode_short_term_rps(s, &sh->slice_rps, s->sps, 1);
492 sh->short_term_rps = &sh->slice_rps;
494 int numbits, rps_idx;
496 if (!s->sps->nb_st_rps) {
497 av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
498 return AVERROR_INVALIDDATA;
501 numbits = av_ceil_log2(s->sps->nb_st_rps);
502 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
503 sh->short_term_rps = &s->sps->st_rps[rps_idx];
506 ret = decode_lt_rps(s, &sh->long_term_rps, gb);
508 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
509 if (s->avctx->err_recognition & AV_EF_EXPLODE)
510 return AVERROR_INVALIDDATA;
513 if (s->sps->sps_temporal_mvp_enabled_flag)
514 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
516 sh->slice_temporal_mvp_enabled_flag = 0;
518 s->sh.short_term_rps = NULL;
523 if (s->temporal_id == 0 &&
524 s->nal_unit_type != NAL_TRAIL_N &&
525 s->nal_unit_type != NAL_TSA_N &&
526 s->nal_unit_type != NAL_STSA_N &&
527 s->nal_unit_type != NAL_RADL_N &&
528 s->nal_unit_type != NAL_RADL_R &&
529 s->nal_unit_type != NAL_RASL_N &&
530 s->nal_unit_type != NAL_RASL_R)
533 if (s->sps->sao_enabled) {
534 sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
535 sh->slice_sample_adaptive_offset_flag[1] =
536 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
538 sh->slice_sample_adaptive_offset_flag[0] = 0;
539 sh->slice_sample_adaptive_offset_flag[1] = 0;
540 sh->slice_sample_adaptive_offset_flag[2] = 0;
543 sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
544 if (sh->slice_type == P_SLICE || sh->slice_type == B_SLICE) {
547 sh->nb_refs[L0] = s->pps->num_ref_idx_l0_default_active;
548 if (sh->slice_type == B_SLICE)
549 sh->nb_refs[L1] = s->pps->num_ref_idx_l1_default_active;
551 if (get_bits1(gb)) { // num_ref_idx_active_override_flag
552 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
553 if (sh->slice_type == B_SLICE)
554 sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
556 if (sh->nb_refs[L0] > MAX_REFS || sh->nb_refs[L1] > MAX_REFS) {
557 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
558 sh->nb_refs[L0], sh->nb_refs[L1]);
559 return AVERROR_INVALIDDATA;
562 sh->rpl_modification_flag[0] = 0;
563 sh->rpl_modification_flag[1] = 0;
564 nb_refs = ff_hevc_frame_nb_refs(s);
566 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
567 return AVERROR_INVALIDDATA;
570 if (s->pps->lists_modification_present_flag && nb_refs > 1) {
571 sh->rpl_modification_flag[0] = get_bits1(gb);
572 if (sh->rpl_modification_flag[0]) {
573 for (i = 0; i < sh->nb_refs[L0]; i++)
574 sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
577 if (sh->slice_type == B_SLICE) {
578 sh->rpl_modification_flag[1] = get_bits1(gb);
579 if (sh->rpl_modification_flag[1] == 1)
580 for (i = 0; i < sh->nb_refs[L1]; i++)
581 sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
585 if (sh->slice_type == B_SLICE)
586 sh->mvd_l1_zero_flag = get_bits1(gb);
588 if (s->pps->cabac_init_present_flag)
589 sh->cabac_init_flag = get_bits1(gb);
591 sh->cabac_init_flag = 0;
593 sh->collocated_ref_idx = 0;
594 if (sh->slice_temporal_mvp_enabled_flag) {
595 sh->collocated_list = L0;
596 if (sh->slice_type == B_SLICE)
597 sh->collocated_list = !get_bits1(gb);
599 if (sh->nb_refs[sh->collocated_list] > 1) {
600 sh->collocated_ref_idx = get_ue_golomb_long(gb);
601 if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
602 av_log(s->avctx, AV_LOG_ERROR,
603 "Invalid collocated_ref_idx: %d.\n",
604 sh->collocated_ref_idx);
605 return AVERROR_INVALIDDATA;
610 if ((s->pps->weighted_pred_flag && sh->slice_type == P_SLICE) ||
611 (s->pps->weighted_bipred_flag && sh->slice_type == B_SLICE)) {
612 pred_weight_table(s, gb);
615 sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
616 if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
617 av_log(s->avctx, AV_LOG_ERROR,
618 "Invalid number of merging MVP candidates: %d.\n",
619 sh->max_num_merge_cand);
620 return AVERROR_INVALIDDATA;
624 sh->slice_qp_delta = get_se_golomb(gb);
626 if (s->pps->pic_slice_level_chroma_qp_offsets_present_flag) {
627 sh->slice_cb_qp_offset = get_se_golomb(gb);
628 sh->slice_cr_qp_offset = get_se_golomb(gb);
630 sh->slice_cb_qp_offset = 0;
631 sh->slice_cr_qp_offset = 0;
634 if (s->pps->chroma_qp_offset_list_enabled_flag)
635 sh->cu_chroma_qp_offset_enabled_flag = get_bits1(gb);
637 sh->cu_chroma_qp_offset_enabled_flag = 0;
639 if (s->pps->deblocking_filter_control_present_flag) {
640 int deblocking_filter_override_flag = 0;
642 if (s->pps->deblocking_filter_override_enabled_flag)
643 deblocking_filter_override_flag = get_bits1(gb);
645 if (deblocking_filter_override_flag) {
646 sh->disable_deblocking_filter_flag = get_bits1(gb);
647 if (!sh->disable_deblocking_filter_flag) {
648 sh->beta_offset = get_se_golomb(gb) * 2;
649 sh->tc_offset = get_se_golomb(gb) * 2;
652 sh->disable_deblocking_filter_flag = s->pps->disable_dbf;
653 sh->beta_offset = s->pps->beta_offset;
654 sh->tc_offset = s->pps->tc_offset;
657 sh->disable_deblocking_filter_flag = 0;
662 if (s->pps->seq_loop_filter_across_slices_enabled_flag &&
663 (sh->slice_sample_adaptive_offset_flag[0] ||
664 sh->slice_sample_adaptive_offset_flag[1] ||
665 !sh->disable_deblocking_filter_flag)) {
666 sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
668 sh->slice_loop_filter_across_slices_enabled_flag = s->pps->seq_loop_filter_across_slices_enabled_flag;
670 } else if (!s->slice_initialized) {
671 av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
672 return AVERROR_INVALIDDATA;
675 sh->num_entry_point_offsets = 0;
676 if (s->pps->tiles_enabled_flag || s->pps->entropy_coding_sync_enabled_flag) {
677 sh->num_entry_point_offsets = get_ue_golomb_long(gb);
678 if (sh->num_entry_point_offsets > 0) {
679 int offset_len = get_ue_golomb_long(gb) + 1;
680 int segments = offset_len >> 4;
681 int rest = (offset_len & 15);
682 av_freep(&sh->entry_point_offset);
683 av_freep(&sh->offset);
685 sh->entry_point_offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
686 sh->offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
687 sh->size = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
688 if (!sh->entry_point_offset || !sh->offset || !sh->size) {
689 sh->num_entry_point_offsets = 0;
690 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate memory\n");
691 return AVERROR(ENOMEM);
693 for (i = 0; i < sh->num_entry_point_offsets; i++) {
695 for (j = 0; j < segments; j++) {
697 val += get_bits(gb, 16);
701 val += get_bits(gb, rest);
703 sh->entry_point_offset[i] = val + 1; // +1; // +1 to get the size
705 if (s->threads_number > 1 && (s->pps->num_tile_rows > 1 || s->pps->num_tile_columns > 1)) {
706 s->enable_parallel_tiles = 0; // TODO: you can enable tiles in parallel here
707 s->threads_number = 1;
709 s->enable_parallel_tiles = 0;
711 s->enable_parallel_tiles = 0;
714 if (s->pps->slice_header_extension_present_flag) {
715 unsigned int length = get_ue_golomb_long(gb);
716 if (length*8LL > get_bits_left(gb)) {
717 av_log(s->avctx, AV_LOG_ERROR, "too many slice_header_extension_data_bytes\n");
718 return AVERROR_INVALIDDATA;
720 for (i = 0; i < length; i++)
721 skip_bits(gb, 8); // slice_header_extension_data_byte
724 // Inferred parameters
725 sh->slice_qp = 26U + s->pps->pic_init_qp_minus26 + sh->slice_qp_delta;
726 if (sh->slice_qp > 51 ||
727 sh->slice_qp < -s->sps->qp_bd_offset) {
728 av_log(s->avctx, AV_LOG_ERROR,
729 "The slice_qp %d is outside the valid range "
732 -s->sps->qp_bd_offset);
733 return AVERROR_INVALIDDATA;
736 sh->slice_ctb_addr_rs = sh->slice_segment_addr;
738 if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) {
739 av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
740 return AVERROR_INVALIDDATA;
743 if (get_bits_left(gb) < 0) {
744 av_log(s->avctx, AV_LOG_ERROR,
745 "Overread slice header by %d bits\n", -get_bits_left(gb));
746 return AVERROR_INVALIDDATA;
749 s->HEVClc->first_qp_group = !s->sh.dependent_slice_segment_flag;
751 if (!s->pps->cu_qp_delta_enabled_flag)
752 s->HEVClc->qp_y = s->sh.slice_qp;
754 s->slice_initialized = 1;
755 s->HEVClc->tu.cu_qp_offset_cb = 0;
756 s->HEVClc->tu.cu_qp_offset_cr = 0;
761 #define CTB(tab, x, y) ((tab)[(y) * s->sps->ctb_width + (x)])
763 #define SET_SAO(elem, value) \
765 if (!sao_merge_up_flag && !sao_merge_left_flag) \
767 else if (sao_merge_left_flag) \
768 sao->elem = CTB(s->sao, rx-1, ry).elem; \
769 else if (sao_merge_up_flag) \
770 sao->elem = CTB(s->sao, rx, ry-1).elem; \
775 static void hls_sao_param(HEVCContext *s, int rx, int ry)
777 HEVCLocalContext *lc = s->HEVClc;
778 int sao_merge_left_flag = 0;
779 int sao_merge_up_flag = 0;
780 SAOParams *sao = &CTB(s->sao, rx, ry);
783 if (s->sh.slice_sample_adaptive_offset_flag[0] ||
784 s->sh.slice_sample_adaptive_offset_flag[1]) {
786 if (lc->ctb_left_flag)
787 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
789 if (ry > 0 && !sao_merge_left_flag) {
791 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
795 for (c_idx = 0; c_idx < 3; c_idx++) {
796 int log2_sao_offset_scale = c_idx == 0 ? s->pps->log2_sao_offset_scale_luma :
797 s->pps->log2_sao_offset_scale_chroma;
799 if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
800 sao->type_idx[c_idx] = SAO_NOT_APPLIED;
805 sao->type_idx[2] = sao->type_idx[1];
806 sao->eo_class[2] = sao->eo_class[1];
808 SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
811 if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
814 for (i = 0; i < 4; i++)
815 SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
817 if (sao->type_idx[c_idx] == SAO_BAND) {
818 for (i = 0; i < 4; i++) {
819 if (sao->offset_abs[c_idx][i]) {
820 SET_SAO(offset_sign[c_idx][i],
821 ff_hevc_sao_offset_sign_decode(s));
823 sao->offset_sign[c_idx][i] = 0;
826 SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
827 } else if (c_idx != 2) {
828 SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
831 // Inferred parameters
832 sao->offset_val[c_idx][0] = 0;
833 for (i = 0; i < 4; i++) {
834 sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i];
835 if (sao->type_idx[c_idx] == SAO_EDGE) {
837 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
838 } else if (sao->offset_sign[c_idx][i]) {
839 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
841 sao->offset_val[c_idx][i + 1] <<= log2_sao_offset_scale;
849 static int hls_cross_component_pred(HEVCContext *s, int idx) {
850 HEVCLocalContext *lc = s->HEVClc;
851 int log2_res_scale_abs_plus1 = ff_hevc_log2_res_scale_abs(s, idx);
853 if (log2_res_scale_abs_plus1 != 0) {
854 int res_scale_sign_flag = ff_hevc_res_scale_sign_flag(s, idx);
855 lc->tu.res_scale_val = (1 << (log2_res_scale_abs_plus1 - 1)) *
856 (1 - 2 * res_scale_sign_flag);
858 lc->tu.res_scale_val = 0;
865 static int hls_transform_unit(HEVCContext *s, int x0, int y0,
866 int xBase, int yBase, int cb_xBase, int cb_yBase,
867 int log2_cb_size, int log2_trafo_size,
868 int blk_idx, int cbf_luma, int *cbf_cb, int *cbf_cr)
870 HEVCLocalContext *lc = s->HEVClc;
871 const int log2_trafo_size_c = log2_trafo_size - s->sps->hshift[1];
874 if (lc->cu.pred_mode == MODE_INTRA) {
875 int trafo_size = 1 << log2_trafo_size;
876 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
878 s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
881 if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
882 (s->sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
883 int scan_idx = SCAN_DIAG;
884 int scan_idx_c = SCAN_DIAG;
885 int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
886 (s->sps->chroma_format_idc == 2 &&
887 (cbf_cb[1] || cbf_cr[1]));
889 if (s->pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
890 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
891 if (lc->tu.cu_qp_delta != 0)
892 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
893 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
894 lc->tu.is_cu_qp_delta_coded = 1;
896 if (lc->tu.cu_qp_delta < -(26 + s->sps->qp_bd_offset / 2) ||
897 lc->tu.cu_qp_delta > (25 + s->sps->qp_bd_offset / 2)) {
898 av_log(s->avctx, AV_LOG_ERROR,
899 "The cu_qp_delta %d is outside the valid range "
902 -(26 + s->sps->qp_bd_offset / 2),
903 (25 + s->sps->qp_bd_offset / 2));
904 return AVERROR_INVALIDDATA;
907 ff_hevc_set_qPy(s, cb_xBase, cb_yBase, log2_cb_size);
910 if (s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
911 !lc->cu.cu_transquant_bypass_flag && !lc->tu.is_cu_chroma_qp_offset_coded) {
912 int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(s);
913 if (cu_chroma_qp_offset_flag) {
914 int cu_chroma_qp_offset_idx = 0;
915 if (s->pps->chroma_qp_offset_list_len_minus1 > 0) {
916 cu_chroma_qp_offset_idx = ff_hevc_cu_chroma_qp_offset_idx(s);
917 av_log(s->avctx, AV_LOG_ERROR,
918 "cu_chroma_qp_offset_idx not yet tested.\n");
920 lc->tu.cu_qp_offset_cb = s->pps->cb_qp_offset_list[cu_chroma_qp_offset_idx];
921 lc->tu.cu_qp_offset_cr = s->pps->cr_qp_offset_list[cu_chroma_qp_offset_idx];
923 lc->tu.cu_qp_offset_cb = 0;
924 lc->tu.cu_qp_offset_cr = 0;
926 lc->tu.is_cu_chroma_qp_offset_coded = 1;
929 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
930 if (lc->tu.intra_pred_mode >= 6 &&
931 lc->tu.intra_pred_mode <= 14) {
932 scan_idx = SCAN_VERT;
933 } else if (lc->tu.intra_pred_mode >= 22 &&
934 lc->tu.intra_pred_mode <= 30) {
935 scan_idx = SCAN_HORIZ;
938 if (lc->tu.intra_pred_mode_c >= 6 &&
939 lc->tu.intra_pred_mode_c <= 14) {
940 scan_idx_c = SCAN_VERT;
941 } else if (lc->tu.intra_pred_mode_c >= 22 &&
942 lc->tu.intra_pred_mode_c <= 30) {
943 scan_idx_c = SCAN_HORIZ;
950 ff_hevc_hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
951 if (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3) {
952 int trafo_size_h = 1 << (log2_trafo_size_c + s->sps->hshift[1]);
953 int trafo_size_v = 1 << (log2_trafo_size_c + s->sps->vshift[1]);
954 lc->tu.cross_pf = (s->pps->cross_component_prediction_enabled_flag && cbf_luma &&
955 (lc->cu.pred_mode == MODE_INTER ||
956 (lc->tu.chroma_mode_c == 4)));
958 if (lc->tu.cross_pf) {
959 hls_cross_component_pred(s, 0);
961 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
962 if (lc->cu.pred_mode == MODE_INTRA) {
963 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
964 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 1);
967 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
968 log2_trafo_size_c, scan_idx_c, 1);
970 if (lc->tu.cross_pf) {
971 ptrdiff_t stride = s->frame->linesize[1];
972 int hshift = s->sps->hshift[1];
973 int vshift = s->sps->vshift[1];
974 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
975 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
976 int size = 1 << log2_trafo_size_c;
978 uint8_t *dst = &s->frame->data[1][(y0 >> vshift) * stride +
979 ((x0 >> hshift) << s->sps->pixel_shift)];
980 for (i = 0; i < (size * size); i++) {
981 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
983 s->hevcdsp.transform_add[log2_trafo_size_c-2](dst, coeffs, stride);
987 if (lc->tu.cross_pf) {
988 hls_cross_component_pred(s, 1);
990 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
991 if (lc->cu.pred_mode == MODE_INTRA) {
992 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
993 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 2);
996 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
997 log2_trafo_size_c, scan_idx_c, 2);
999 if (lc->tu.cross_pf) {
1000 ptrdiff_t stride = s->frame->linesize[2];
1001 int hshift = s->sps->hshift[2];
1002 int vshift = s->sps->vshift[2];
1003 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1004 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1005 int size = 1 << log2_trafo_size_c;
1007 uint8_t *dst = &s->frame->data[2][(y0 >> vshift) * stride +
1008 ((x0 >> hshift) << s->sps->pixel_shift)];
1009 for (i = 0; i < (size * size); i++) {
1010 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1012 s->hevcdsp.transform_add[log2_trafo_size_c-2](dst, coeffs, stride);
1015 } else if (blk_idx == 3) {
1016 int trafo_size_h = 1 << (log2_trafo_size + 1);
1017 int trafo_size_v = 1 << (log2_trafo_size + s->sps->vshift[1]);
1018 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1019 if (lc->cu.pred_mode == MODE_INTRA) {
1020 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1021 trafo_size_h, trafo_size_v);
1022 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 1);
1025 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1026 log2_trafo_size, scan_idx_c, 1);
1028 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1029 if (lc->cu.pred_mode == MODE_INTRA) {
1030 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1031 trafo_size_h, trafo_size_v);
1032 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 2);
1035 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1036 log2_trafo_size, scan_idx_c, 2);
1039 } else if (lc->cu.pred_mode == MODE_INTRA) {
1040 if (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3) {
1041 int trafo_size_h = 1 << (log2_trafo_size_c + s->sps->hshift[1]);
1042 int trafo_size_v = 1 << (log2_trafo_size_c + s->sps->vshift[1]);
1043 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size_h, trafo_size_v);
1044 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 1);
1045 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 2);
1046 if (s->sps->chroma_format_idc == 2) {
1047 ff_hevc_set_neighbour_available(s, x0, y0 + (1 << log2_trafo_size_c),
1048 trafo_size_h, trafo_size_v);
1049 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 1);
1050 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 2);
1052 } else if (blk_idx == 3) {
1053 int trafo_size_h = 1 << (log2_trafo_size + 1);
1054 int trafo_size_v = 1 << (log2_trafo_size + s->sps->vshift[1]);
1055 ff_hevc_set_neighbour_available(s, xBase, yBase,
1056 trafo_size_h, trafo_size_v);
1057 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1058 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1059 if (s->sps->chroma_format_idc == 2) {
1060 ff_hevc_set_neighbour_available(s, xBase, yBase + (1 << (log2_trafo_size)),
1061 trafo_size_h, trafo_size_v);
1062 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 1);
1063 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 2);
1071 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1073 int cb_size = 1 << log2_cb_size;
1074 int log2_min_pu_size = s->sps->log2_min_pu_size;
1076 int min_pu_width = s->sps->min_pu_width;
1077 int x_end = FFMIN(x0 + cb_size, s->sps->width);
1078 int y_end = FFMIN(y0 + cb_size, s->sps->height);
1081 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1082 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1083 s->is_pcm[i + j * min_pu_width] = 2;
1086 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1087 int xBase, int yBase, int cb_xBase, int cb_yBase,
1088 int log2_cb_size, int log2_trafo_size,
1089 int trafo_depth, int blk_idx,
1090 const int *base_cbf_cb, const int *base_cbf_cr)
1092 HEVCLocalContext *lc = s->HEVClc;
1093 uint8_t split_transform_flag;
1098 cbf_cb[0] = base_cbf_cb[0];
1099 cbf_cb[1] = base_cbf_cb[1];
1100 cbf_cr[0] = base_cbf_cr[0];
1101 cbf_cr[1] = base_cbf_cr[1];
1103 if (lc->cu.intra_split_flag) {
1104 if (trafo_depth == 1) {
1105 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1106 if (s->sps->chroma_format_idc == 3) {
1107 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[blk_idx];
1108 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[blk_idx];
1110 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1111 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1115 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[0];
1116 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1117 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1120 if (log2_trafo_size <= s->sps->log2_max_trafo_size &&
1121 log2_trafo_size > s->sps->log2_min_tb_size &&
1122 trafo_depth < lc->cu.max_trafo_depth &&
1123 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1124 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1126 int inter_split = s->sps->max_transform_hierarchy_depth_inter == 0 &&
1127 lc->cu.pred_mode == MODE_INTER &&
1128 lc->cu.part_mode != PART_2Nx2N &&
1131 split_transform_flag = log2_trafo_size > s->sps->log2_max_trafo_size ||
1132 (lc->cu.intra_split_flag && trafo_depth == 0) ||
1136 if (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3) {
1137 if (trafo_depth == 0 || cbf_cb[0]) {
1138 cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1139 if (s->sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1140 cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1144 if (trafo_depth == 0 || cbf_cr[0]) {
1145 cbf_cr[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1146 if (s->sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1147 cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1152 if (split_transform_flag) {
1153 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1154 const int x1 = x0 + trafo_size_split;
1155 const int y1 = y0 + trafo_size_split;
1157 #define SUBDIVIDE(x, y, idx) \
1159 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1160 log2_trafo_size - 1, trafo_depth + 1, idx, \
1166 SUBDIVIDE(x0, y0, 0);
1167 SUBDIVIDE(x1, y0, 1);
1168 SUBDIVIDE(x0, y1, 2);
1169 SUBDIVIDE(x1, y1, 3);
1173 int min_tu_size = 1 << s->sps->log2_min_tb_size;
1174 int log2_min_tu_size = s->sps->log2_min_tb_size;
1175 int min_tu_width = s->sps->min_tb_width;
1178 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1179 cbf_cb[0] || cbf_cr[0] ||
1180 (s->sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1181 cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1184 ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1185 log2_cb_size, log2_trafo_size,
1186 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1189 // TODO: store cbf_luma somewhere else
1192 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1193 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1194 int x_tu = (x0 + j) >> log2_min_tu_size;
1195 int y_tu = (y0 + i) >> log2_min_tu_size;
1196 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1199 if (!s->sh.disable_deblocking_filter_flag) {
1200 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1201 if (s->pps->transquant_bypass_enable_flag &&
1202 lc->cu.cu_transquant_bypass_flag)
1203 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1209 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1211 HEVCLocalContext *lc = s->HEVClc;
1213 int cb_size = 1 << log2_cb_size;
1214 int stride0 = s->frame->linesize[0];
1215 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->sps->pixel_shift)];
1216 int stride1 = s->frame->linesize[1];
1217 uint8_t *dst1 = &s->frame->data[1][(y0 >> s->sps->vshift[1]) * stride1 + ((x0 >> s->sps->hshift[1]) << s->sps->pixel_shift)];
1218 int stride2 = s->frame->linesize[2];
1219 uint8_t *dst2 = &s->frame->data[2][(y0 >> s->sps->vshift[2]) * stride2 + ((x0 >> s->sps->hshift[2]) << s->sps->pixel_shift)];
1221 int length = cb_size * cb_size * s->sps->pcm.bit_depth +
1222 (((cb_size >> s->sps->hshift[1]) * (cb_size >> s->sps->vshift[1])) +
1223 ((cb_size >> s->sps->hshift[2]) * (cb_size >> s->sps->vshift[2]))) *
1224 s->sps->pcm.bit_depth_chroma;
1225 const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1228 if (!s->sh.disable_deblocking_filter_flag)
1229 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1231 ret = init_get_bits(&gb, pcm, length);
1235 s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size, &gb, s->sps->pcm.bit_depth);
1236 s->hevcdsp.put_pcm(dst1, stride1,
1237 cb_size >> s->sps->hshift[1],
1238 cb_size >> s->sps->vshift[1],
1239 &gb, s->sps->pcm.bit_depth_chroma);
1240 s->hevcdsp.put_pcm(dst2, stride2,
1241 cb_size >> s->sps->hshift[2],
1242 cb_size >> s->sps->vshift[2],
1243 &gb, s->sps->pcm.bit_depth_chroma);
1248 * 8.5.3.2.2.1 Luma sample unidirectional interpolation process
1250 * @param s HEVC decoding context
1251 * @param dst target buffer for block data at block position
1252 * @param dststride stride of the dst buffer
1253 * @param ref reference picture buffer at origin (0, 0)
1254 * @param mv motion vector (relative to block position) to get pixel data from
1255 * @param x_off horizontal position of block from origin (0, 0)
1256 * @param y_off vertical position of block from origin (0, 0)
1257 * @param block_w width of block
1258 * @param block_h height of block
1259 * @param luma_weight weighting factor applied to the luma prediction
1260 * @param luma_offset additive offset applied to the luma prediction value
1263 static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1264 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1265 int block_w, int block_h, int luma_weight, int luma_offset)
1267 HEVCLocalContext *lc = s->HEVClc;
1268 uint8_t *src = ref->data[0];
1269 ptrdiff_t srcstride = ref->linesize[0];
1270 int pic_width = s->sps->width;
1271 int pic_height = s->sps->height;
1274 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1275 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1276 int idx = ff_hevc_pel_weight[block_w];
1278 x_off += mv->x >> 2;
1279 y_off += mv->y >> 2;
1280 src += y_off * srcstride + (x_off << s->sps->pixel_shift);
1282 if (x_off < QPEL_EXTRA_BEFORE || y_off < QPEL_EXTRA_AFTER ||
1283 x_off >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1284 y_off >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1285 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1286 int offset = QPEL_EXTRA_BEFORE * srcstride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1287 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1289 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1290 edge_emu_stride, srcstride,
1291 block_w + QPEL_EXTRA,
1292 block_h + QPEL_EXTRA,
1293 x_off - QPEL_EXTRA_BEFORE, y_off - QPEL_EXTRA_BEFORE,
1294 pic_width, pic_height);
1295 src = lc->edge_emu_buffer + buf_offset;
1296 srcstride = edge_emu_stride;
1300 s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride, src, srcstride,
1301 block_h, mx, my, block_w);
1303 s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride, src, srcstride,
1304 block_h, s->sh.luma_log2_weight_denom,
1305 luma_weight, luma_offset, mx, my, block_w);
1309 * 8.5.3.2.2.1 Luma sample bidirectional interpolation process
1311 * @param s HEVC decoding context
1312 * @param dst target buffer for block data at block position
1313 * @param dststride stride of the dst buffer
1314 * @param ref0 reference picture0 buffer at origin (0, 0)
1315 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1316 * @param x_off horizontal position of block from origin (0, 0)
1317 * @param y_off vertical position of block from origin (0, 0)
1318 * @param block_w width of block
1319 * @param block_h height of block
1320 * @param ref1 reference picture1 buffer at origin (0, 0)
1321 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1322 * @param current_mv current motion vector structure
1324 static void luma_mc_bi(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1325 AVFrame *ref0, const Mv *mv0, int x_off, int y_off,
1326 int block_w, int block_h, AVFrame *ref1, const Mv *mv1, struct MvField *current_mv)
1328 HEVCLocalContext *lc = s->HEVClc;
1329 ptrdiff_t src0stride = ref0->linesize[0];
1330 ptrdiff_t src1stride = ref1->linesize[0];
1331 int pic_width = s->sps->width;
1332 int pic_height = s->sps->height;
1333 int mx0 = mv0->x & 3;
1334 int my0 = mv0->y & 3;
1335 int mx1 = mv1->x & 3;
1336 int my1 = mv1->y & 3;
1337 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1338 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1339 int x_off0 = x_off + (mv0->x >> 2);
1340 int y_off0 = y_off + (mv0->y >> 2);
1341 int x_off1 = x_off + (mv1->x >> 2);
1342 int y_off1 = y_off + (mv1->y >> 2);
1343 int idx = ff_hevc_pel_weight[block_w];
1345 uint8_t *src0 = ref0->data[0] + y_off0 * src0stride + (int)((unsigned)x_off0 << s->sps->pixel_shift);
1346 uint8_t *src1 = ref1->data[0] + y_off1 * src1stride + (int)((unsigned)x_off1 << s->sps->pixel_shift);
1348 if (x_off0 < QPEL_EXTRA_BEFORE || y_off0 < QPEL_EXTRA_AFTER ||
1349 x_off0 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1350 y_off0 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1351 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1352 int offset = QPEL_EXTRA_BEFORE * src0stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1353 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1355 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset,
1356 edge_emu_stride, src0stride,
1357 block_w + QPEL_EXTRA,
1358 block_h + QPEL_EXTRA,
1359 x_off0 - QPEL_EXTRA_BEFORE, y_off0 - QPEL_EXTRA_BEFORE,
1360 pic_width, pic_height);
1361 src0 = lc->edge_emu_buffer + buf_offset;
1362 src0stride = edge_emu_stride;
1365 if (x_off1 < QPEL_EXTRA_BEFORE || y_off1 < QPEL_EXTRA_AFTER ||
1366 x_off1 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1367 y_off1 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1368 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1369 int offset = QPEL_EXTRA_BEFORE * src1stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1370 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1372 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src1 - offset,
1373 edge_emu_stride, src1stride,
1374 block_w + QPEL_EXTRA,
1375 block_h + QPEL_EXTRA,
1376 x_off1 - QPEL_EXTRA_BEFORE, y_off1 - QPEL_EXTRA_BEFORE,
1377 pic_width, pic_height);
1378 src1 = lc->edge_emu_buffer2 + buf_offset;
1379 src1stride = edge_emu_stride;
1382 s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](lc->tmp, src0, src0stride,
1383 block_h, mx0, my0, block_w);
1385 s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1386 block_h, mx1, my1, block_w);
1388 s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1389 block_h, s->sh.luma_log2_weight_denom,
1390 s->sh.luma_weight_l0[current_mv->ref_idx[0]],
1391 s->sh.luma_weight_l1[current_mv->ref_idx[1]],
1392 s->sh.luma_offset_l0[current_mv->ref_idx[0]],
1393 s->sh.luma_offset_l1[current_mv->ref_idx[1]],
1399 * 8.5.3.2.2.2 Chroma sample uniprediction interpolation process
1401 * @param s HEVC decoding context
1402 * @param dst1 target buffer for block data at block position (U plane)
1403 * @param dst2 target buffer for block data at block position (V plane)
1404 * @param dststride stride of the dst1 and dst2 buffers
1405 * @param ref reference picture buffer at origin (0, 0)
1406 * @param mv motion vector (relative to block position) to get pixel data from
1407 * @param x_off horizontal position of block from origin (0, 0)
1408 * @param y_off vertical position of block from origin (0, 0)
1409 * @param block_w width of block
1410 * @param block_h height of block
1411 * @param chroma_weight weighting factor applied to the chroma prediction
1412 * @param chroma_offset additive offset applied to the chroma prediction value
1415 static void chroma_mc_uni(HEVCContext *s, uint8_t *dst0,
1416 ptrdiff_t dststride, uint8_t *src0, ptrdiff_t srcstride, int reflist,
1417 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int chroma_weight, int chroma_offset)
1419 HEVCLocalContext *lc = s->HEVClc;
1420 int pic_width = s->sps->width >> s->sps->hshift[1];
1421 int pic_height = s->sps->height >> s->sps->vshift[1];
1422 const Mv *mv = ¤t_mv->mv[reflist];
1423 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1424 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1425 int idx = ff_hevc_pel_weight[block_w];
1426 int hshift = s->sps->hshift[1];
1427 int vshift = s->sps->vshift[1];
1428 intptr_t mx = mv->x & ((1 << (2 + hshift)) - 1);
1429 intptr_t my = mv->y & ((1 << (2 + vshift)) - 1);
1430 intptr_t _mx = mx << (1 - hshift);
1431 intptr_t _my = my << (1 - vshift);
1433 x_off += mv->x >> (2 + hshift);
1434 y_off += mv->y >> (2 + vshift);
1435 src0 += y_off * srcstride + (x_off << s->sps->pixel_shift);
1437 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1438 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1439 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1440 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1441 int offset0 = EPEL_EXTRA_BEFORE * (srcstride + (1 << s->sps->pixel_shift));
1442 int buf_offset0 = EPEL_EXTRA_BEFORE *
1443 (edge_emu_stride + (1 << s->sps->pixel_shift));
1444 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset0,
1445 edge_emu_stride, srcstride,
1446 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1447 x_off - EPEL_EXTRA_BEFORE,
1448 y_off - EPEL_EXTRA_BEFORE,
1449 pic_width, pic_height);
1451 src0 = lc->edge_emu_buffer + buf_offset0;
1452 srcstride = edge_emu_stride;
1455 s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1456 block_h, _mx, _my, block_w);
1458 s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1459 block_h, s->sh.chroma_log2_weight_denom,
1460 chroma_weight, chroma_offset, _mx, _my, block_w);
1464 * 8.5.3.2.2.2 Chroma sample bidirectional interpolation process
1466 * @param s HEVC decoding context
1467 * @param dst target buffer for block data at block position
1468 * @param dststride stride of the dst buffer
1469 * @param ref0 reference picture0 buffer at origin (0, 0)
1470 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1471 * @param x_off horizontal position of block from origin (0, 0)
1472 * @param y_off vertical position of block from origin (0, 0)
1473 * @param block_w width of block
1474 * @param block_h height of block
1475 * @param ref1 reference picture1 buffer at origin (0, 0)
1476 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1477 * @param current_mv current motion vector structure
1478 * @param cidx chroma component(cb, cr)
1480 static void chroma_mc_bi(HEVCContext *s, uint8_t *dst0, ptrdiff_t dststride, AVFrame *ref0, AVFrame *ref1,
1481 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int cidx)
1483 HEVCLocalContext *lc = s->HEVClc;
1484 uint8_t *src1 = ref0->data[cidx+1];
1485 uint8_t *src2 = ref1->data[cidx+1];
1486 ptrdiff_t src1stride = ref0->linesize[cidx+1];
1487 ptrdiff_t src2stride = ref1->linesize[cidx+1];
1488 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1489 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1490 int pic_width = s->sps->width >> s->sps->hshift[1];
1491 int pic_height = s->sps->height >> s->sps->vshift[1];
1492 Mv *mv0 = ¤t_mv->mv[0];
1493 Mv *mv1 = ¤t_mv->mv[1];
1494 int hshift = s->sps->hshift[1];
1495 int vshift = s->sps->vshift[1];
1497 intptr_t mx0 = mv0->x & ((1 << (2 + hshift)) - 1);
1498 intptr_t my0 = mv0->y & ((1 << (2 + vshift)) - 1);
1499 intptr_t mx1 = mv1->x & ((1 << (2 + hshift)) - 1);
1500 intptr_t my1 = mv1->y & ((1 << (2 + vshift)) - 1);
1501 intptr_t _mx0 = mx0 << (1 - hshift);
1502 intptr_t _my0 = my0 << (1 - vshift);
1503 intptr_t _mx1 = mx1 << (1 - hshift);
1504 intptr_t _my1 = my1 << (1 - vshift);
1506 int x_off0 = x_off + (mv0->x >> (2 + hshift));
1507 int y_off0 = y_off + (mv0->y >> (2 + vshift));
1508 int x_off1 = x_off + (mv1->x >> (2 + hshift));
1509 int y_off1 = y_off + (mv1->y >> (2 + vshift));
1510 int idx = ff_hevc_pel_weight[block_w];
1511 src1 += y_off0 * src1stride + (int)((unsigned)x_off0 << s->sps->pixel_shift);
1512 src2 += y_off1 * src2stride + (int)((unsigned)x_off1 << s->sps->pixel_shift);
1514 if (x_off0 < EPEL_EXTRA_BEFORE || y_off0 < EPEL_EXTRA_AFTER ||
1515 x_off0 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1516 y_off0 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1517 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1518 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->sps->pixel_shift));
1519 int buf_offset1 = EPEL_EXTRA_BEFORE *
1520 (edge_emu_stride + (1 << s->sps->pixel_shift));
1522 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1523 edge_emu_stride, src1stride,
1524 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1525 x_off0 - EPEL_EXTRA_BEFORE,
1526 y_off0 - EPEL_EXTRA_BEFORE,
1527 pic_width, pic_height);
1529 src1 = lc->edge_emu_buffer + buf_offset1;
1530 src1stride = edge_emu_stride;
1533 if (x_off1 < EPEL_EXTRA_BEFORE || y_off1 < EPEL_EXTRA_AFTER ||
1534 x_off1 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1535 y_off1 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1536 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1537 int offset1 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->sps->pixel_shift));
1538 int buf_offset1 = EPEL_EXTRA_BEFORE *
1539 (edge_emu_stride + (1 << s->sps->pixel_shift));
1541 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src2 - offset1,
1542 edge_emu_stride, src2stride,
1543 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1544 x_off1 - EPEL_EXTRA_BEFORE,
1545 y_off1 - EPEL_EXTRA_BEFORE,
1546 pic_width, pic_height);
1548 src2 = lc->edge_emu_buffer2 + buf_offset1;
1549 src2stride = edge_emu_stride;
1552 s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](lc->tmp, src1, src1stride,
1553 block_h, _mx0, _my0, block_w);
1555 s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1556 src2, src2stride, lc->tmp,
1557 block_h, _mx1, _my1, block_w);
1559 s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1560 src2, src2stride, lc->tmp,
1562 s->sh.chroma_log2_weight_denom,
1563 s->sh.chroma_weight_l0[current_mv->ref_idx[0]][cidx],
1564 s->sh.chroma_weight_l1[current_mv->ref_idx[1]][cidx],
1565 s->sh.chroma_offset_l0[current_mv->ref_idx[0]][cidx],
1566 s->sh.chroma_offset_l1[current_mv->ref_idx[1]][cidx],
1567 _mx1, _my1, block_w);
1570 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1571 const Mv *mv, int y0, int height)
1573 int y = FFMAX(0, (mv->y >> 2) + y0 + height + 9);
1575 if (s->threads_type == FF_THREAD_FRAME )
1576 ff_thread_await_progress(&ref->tf, y, 0);
1579 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1581 int log2_cb_size, int partIdx, int idx)
1583 #define POS(c_idx, x, y) \
1584 &s->frame->data[c_idx][((y) >> s->sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1585 (((x) >> s->sps->hshift[c_idx]) << s->sps->pixel_shift)]
1586 HEVCLocalContext *lc = s->HEVClc;
1588 struct MvField current_mv = {{{ 0 }}};
1590 int min_pu_width = s->sps->min_pu_width;
1592 MvField *tab_mvf = s->ref->tab_mvf;
1593 RefPicList *refPicList = s->ref->refPicList;
1594 HEVCFrame *ref0, *ref1;
1595 uint8_t *dst0 = POS(0, x0, y0);
1596 uint8_t *dst1 = POS(1, x0, y0);
1597 uint8_t *dst2 = POS(2, x0, y0);
1598 int log2_min_cb_size = s->sps->log2_min_cb_size;
1599 int min_cb_width = s->sps->min_cb_width;
1600 int x_cb = x0 >> log2_min_cb_size;
1601 int y_cb = y0 >> log2_min_cb_size;
1605 int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1608 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1610 if (skip_flag || lc->pu.merge_flag) {
1611 if (s->sh.max_num_merge_cand > 1)
1612 merge_idx = ff_hevc_merge_idx_decode(s);
1616 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1617 partIdx, merge_idx, ¤t_mv);
1619 enum InterPredIdc inter_pred_idc = PRED_L0;
1622 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1623 current_mv.pred_flag = 0;
1624 if (s->sh.slice_type == B_SLICE)
1625 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1627 if (inter_pred_idc != PRED_L1) {
1628 if (s->sh.nb_refs[L0]) {
1629 current_mv.ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1631 current_mv.pred_flag = PF_L0;
1632 ff_hevc_hls_mvd_coding(s, x0, y0, 0);
1633 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1634 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1635 partIdx, merge_idx, ¤t_mv,
1637 current_mv.mv[0].x += lc->pu.mvd.x;
1638 current_mv.mv[0].y += lc->pu.mvd.y;
1641 if (inter_pred_idc != PRED_L0) {
1642 if (s->sh.nb_refs[L1]) {
1643 current_mv.ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1646 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1647 AV_ZERO32(&lc->pu.mvd);
1649 ff_hevc_hls_mvd_coding(s, x0, y0, 1);
1652 current_mv.pred_flag += PF_L1;
1653 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1654 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1655 partIdx, merge_idx, ¤t_mv,
1657 current_mv.mv[1].x += lc->pu.mvd.x;
1658 current_mv.mv[1].y += lc->pu.mvd.y;
1662 x_pu = x0 >> s->sps->log2_min_pu_size;
1663 y_pu = y0 >> s->sps->log2_min_pu_size;
1665 for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1666 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1667 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1669 if (current_mv.pred_flag & PF_L0) {
1670 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1673 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1675 if (current_mv.pred_flag & PF_L1) {
1676 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1679 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1682 if (current_mv.pred_flag == PF_L0) {
1683 int x0_c = x0 >> s->sps->hshift[1];
1684 int y0_c = y0 >> s->sps->vshift[1];
1685 int nPbW_c = nPbW >> s->sps->hshift[1];
1686 int nPbH_c = nPbH >> s->sps->vshift[1];
1688 luma_mc_uni(s, dst0, s->frame->linesize[0], ref0->frame,
1689 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1690 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1691 s->sh.luma_offset_l0[current_mv.ref_idx[0]]);
1693 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref0->frame->data[1], ref0->frame->linesize[1],
1694 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1695 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]);
1696 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref0->frame->data[2], ref0->frame->linesize[2],
1697 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1698 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]);
1699 } else if (current_mv.pred_flag == PF_L1) {
1700 int x0_c = x0 >> s->sps->hshift[1];
1701 int y0_c = y0 >> s->sps->vshift[1];
1702 int nPbW_c = nPbW >> s->sps->hshift[1];
1703 int nPbH_c = nPbH >> s->sps->vshift[1];
1705 luma_mc_uni(s, dst0, s->frame->linesize[0], ref1->frame,
1706 ¤t_mv.mv[1], x0, y0, nPbW, nPbH,
1707 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1708 s->sh.luma_offset_l1[current_mv.ref_idx[1]]);
1710 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
1711 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1712 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]);
1714 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
1715 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1716 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]);
1717 } else if (current_mv.pred_flag == PF_BI) {
1718 int x0_c = x0 >> s->sps->hshift[1];
1719 int y0_c = y0 >> s->sps->vshift[1];
1720 int nPbW_c = nPbW >> s->sps->hshift[1];
1721 int nPbH_c = nPbH >> s->sps->vshift[1];
1723 luma_mc_bi(s, dst0, s->frame->linesize[0], ref0->frame,
1724 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1725 ref1->frame, ¤t_mv.mv[1], ¤t_mv);
1727 chroma_mc_bi(s, dst1, s->frame->linesize[1], ref0->frame, ref1->frame,
1728 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 0);
1730 chroma_mc_bi(s, dst2, s->frame->linesize[2], ref0->frame, ref1->frame,
1731 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1);
1738 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1739 int prev_intra_luma_pred_flag)
1741 HEVCLocalContext *lc = s->HEVClc;
1742 int x_pu = x0 >> s->sps->log2_min_pu_size;
1743 int y_pu = y0 >> s->sps->log2_min_pu_size;
1744 int min_pu_width = s->sps->min_pu_width;
1745 int size_in_pus = pu_size >> s->sps->log2_min_pu_size;
1746 int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1);
1747 int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1);
1749 int cand_up = (lc->ctb_up_flag || y0b) ?
1750 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1751 int cand_left = (lc->ctb_left_flag || x0b) ?
1752 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1754 int y_ctb = (y0 >> (s->sps->log2_ctb_size)) << (s->sps->log2_ctb_size);
1756 MvField *tab_mvf = s->ref->tab_mvf;
1757 int intra_pred_mode;
1761 // intra_pred_mode prediction does not cross vertical CTB boundaries
1762 if ((y0 - 1) < y_ctb)
1765 if (cand_left == cand_up) {
1766 if (cand_left < 2) {
1767 candidate[0] = INTRA_PLANAR;
1768 candidate[1] = INTRA_DC;
1769 candidate[2] = INTRA_ANGULAR_26;
1771 candidate[0] = cand_left;
1772 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1773 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1776 candidate[0] = cand_left;
1777 candidate[1] = cand_up;
1778 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1779 candidate[2] = INTRA_PLANAR;
1780 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1781 candidate[2] = INTRA_DC;
1783 candidate[2] = INTRA_ANGULAR_26;
1787 if (prev_intra_luma_pred_flag) {
1788 intra_pred_mode = candidate[lc->pu.mpm_idx];
1790 if (candidate[0] > candidate[1])
1791 FFSWAP(uint8_t, candidate[0], candidate[1]);
1792 if (candidate[0] > candidate[2])
1793 FFSWAP(uint8_t, candidate[0], candidate[2]);
1794 if (candidate[1] > candidate[2])
1795 FFSWAP(uint8_t, candidate[1], candidate[2]);
1797 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1798 for (i = 0; i < 3; i++)
1799 if (intra_pred_mode >= candidate[i])
1803 /* write the intra prediction units into the mv array */
1806 for (i = 0; i < size_in_pus; i++) {
1807 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1808 intra_pred_mode, size_in_pus);
1810 for (j = 0; j < size_in_pus; j++) {
1811 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag = PF_INTRA;
1815 return intra_pred_mode;
1818 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1819 int log2_cb_size, int ct_depth)
1821 int length = (1 << log2_cb_size) >> s->sps->log2_min_cb_size;
1822 int x_cb = x0 >> s->sps->log2_min_cb_size;
1823 int y_cb = y0 >> s->sps->log2_min_cb_size;
1826 for (y = 0; y < length; y++)
1827 memset(&s->tab_ct_depth[(y_cb + y) * s->sps->min_cb_width + x_cb],
1831 static const uint8_t tab_mode_idx[] = {
1832 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
1833 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
1835 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1838 HEVCLocalContext *lc = s->HEVClc;
1839 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1840 uint8_t prev_intra_luma_pred_flag[4];
1841 int split = lc->cu.part_mode == PART_NxN;
1842 int pb_size = (1 << log2_cb_size) >> split;
1843 int side = split + 1;
1847 for (i = 0; i < side; i++)
1848 for (j = 0; j < side; j++)
1849 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1851 for (i = 0; i < side; i++) {
1852 for (j = 0; j < side; j++) {
1853 if (prev_intra_luma_pred_flag[2 * i + j])
1854 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
1856 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
1858 lc->pu.intra_pred_mode[2 * i + j] =
1859 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1860 prev_intra_luma_pred_flag[2 * i + j]);
1864 if (s->sps->chroma_format_idc == 3) {
1865 for (i = 0; i < side; i++) {
1866 for (j = 0; j < side; j++) {
1867 lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1868 if (chroma_mode != 4) {
1869 if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode])
1870 lc->pu.intra_pred_mode_c[2 * i + j] = 34;
1872 lc->pu.intra_pred_mode_c[2 * i + j] = intra_chroma_table[chroma_mode];
1874 lc->pu.intra_pred_mode_c[2 * i + j] = lc->pu.intra_pred_mode[2 * i + j];
1878 } else if (s->sps->chroma_format_idc == 2) {
1880 lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1881 if (chroma_mode != 4) {
1882 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1885 mode_idx = intra_chroma_table[chroma_mode];
1887 mode_idx = lc->pu.intra_pred_mode[0];
1889 lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx];
1890 } else if (s->sps->chroma_format_idc != 0) {
1891 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1892 if (chroma_mode != 4) {
1893 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1894 lc->pu.intra_pred_mode_c[0] = 34;
1896 lc->pu.intra_pred_mode_c[0] = intra_chroma_table[chroma_mode];
1898 lc->pu.intra_pred_mode_c[0] = lc->pu.intra_pred_mode[0];
1903 static void intra_prediction_unit_default_value(HEVCContext *s,
1907 HEVCLocalContext *lc = s->HEVClc;
1908 int pb_size = 1 << log2_cb_size;
1909 int size_in_pus = pb_size >> s->sps->log2_min_pu_size;
1910 int min_pu_width = s->sps->min_pu_width;
1911 MvField *tab_mvf = s->ref->tab_mvf;
1912 int x_pu = x0 >> s->sps->log2_min_pu_size;
1913 int y_pu = y0 >> s->sps->log2_min_pu_size;
1916 if (size_in_pus == 0)
1918 for (j = 0; j < size_in_pus; j++)
1919 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
1920 if (lc->cu.pred_mode == MODE_INTRA)
1921 for (j = 0; j < size_in_pus; j++)
1922 for (k = 0; k < size_in_pus; k++)
1923 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].pred_flag = PF_INTRA;
1926 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
1928 int cb_size = 1 << log2_cb_size;
1929 HEVCLocalContext *lc = s->HEVClc;
1930 int log2_min_cb_size = s->sps->log2_min_cb_size;
1931 int length = cb_size >> log2_min_cb_size;
1932 int min_cb_width = s->sps->min_cb_width;
1933 int x_cb = x0 >> log2_min_cb_size;
1934 int y_cb = y0 >> log2_min_cb_size;
1935 int idx = log2_cb_size - 2;
1936 int qp_block_mask = (1<<(s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth)) - 1;
1941 lc->cu.pred_mode = MODE_INTRA;
1942 lc->cu.part_mode = PART_2Nx2N;
1943 lc->cu.intra_split_flag = 0;
1945 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
1946 for (x = 0; x < 4; x++)
1947 lc->pu.intra_pred_mode[x] = 1;
1948 if (s->pps->transquant_bypass_enable_flag) {
1949 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
1950 if (lc->cu.cu_transquant_bypass_flag)
1951 set_deblocking_bypass(s, x0, y0, log2_cb_size);
1953 lc->cu.cu_transquant_bypass_flag = 0;
1955 if (s->sh.slice_type != I_SLICE) {
1956 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
1958 x = y_cb * min_cb_width + x_cb;
1959 for (y = 0; y < length; y++) {
1960 memset(&s->skip_flag[x], skip_flag, length);
1963 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
1965 x = y_cb * min_cb_width + x_cb;
1966 for (y = 0; y < length; y++) {
1967 memset(&s->skip_flag[x], 0, length);
1972 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
1973 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
1974 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
1976 if (!s->sh.disable_deblocking_filter_flag)
1977 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1981 if (s->sh.slice_type != I_SLICE)
1982 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
1983 if (lc->cu.pred_mode != MODE_INTRA ||
1984 log2_cb_size == s->sps->log2_min_cb_size) {
1985 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
1986 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
1987 lc->cu.pred_mode == MODE_INTRA;
1990 if (lc->cu.pred_mode == MODE_INTRA) {
1991 if (lc->cu.part_mode == PART_2Nx2N && s->sps->pcm_enabled_flag &&
1992 log2_cb_size >= s->sps->pcm.log2_min_pcm_cb_size &&
1993 log2_cb_size <= s->sps->pcm.log2_max_pcm_cb_size) {
1994 pcm_flag = ff_hevc_pcm_flag_decode(s);
1997 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
1998 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
1999 if (s->sps->pcm.loop_filter_disable_flag)
2000 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2005 intra_prediction_unit(s, x0, y0, log2_cb_size);
2008 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2009 switch (lc->cu.part_mode) {
2011 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2014 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0, idx);
2015 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2018 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2019 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2022 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0, idx);
2023 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2026 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2027 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2030 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0, idx - 2);
2031 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2034 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2035 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2038 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2039 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2040 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2041 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2047 int rqt_root_cbf = 1;
2049 if (lc->cu.pred_mode != MODE_INTRA &&
2050 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2051 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2054 const static int cbf[2] = { 0 };
2055 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2056 s->sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2057 s->sps->max_transform_hierarchy_depth_inter;
2058 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2060 log2_cb_size, 0, 0, cbf, cbf);
2064 if (!s->sh.disable_deblocking_filter_flag)
2065 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2070 if (s->pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2071 ff_hevc_set_qPy(s, x0, y0, log2_cb_size);
2073 x = y_cb * min_cb_width + x_cb;
2074 for (y = 0; y < length; y++) {
2075 memset(&s->qp_y_tab[x], lc->qp_y, length);
2079 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2080 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2081 lc->qPy_pred = lc->qp_y;
2084 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct_depth);
2089 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2090 int log2_cb_size, int cb_depth)
2092 HEVCLocalContext *lc = s->HEVClc;
2093 const int cb_size = 1 << log2_cb_size;
2095 int qp_block_mask = (1<<(s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth)) - 1;
2098 lc->ct_depth = cb_depth;
2099 if (x0 + cb_size <= s->sps->width &&
2100 y0 + cb_size <= s->sps->height &&
2101 log2_cb_size > s->sps->log2_min_cb_size) {
2102 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2104 split_cu = (log2_cb_size > s->sps->log2_min_cb_size);
2106 if (s->pps->cu_qp_delta_enabled_flag &&
2107 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth) {
2108 lc->tu.is_cu_qp_delta_coded = 0;
2109 lc->tu.cu_qp_delta = 0;
2112 if (s->sh.cu_chroma_qp_offset_enabled_flag &&
2113 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_chroma_qp_offset_depth) {
2114 lc->tu.is_cu_chroma_qp_offset_coded = 0;
2118 const int cb_size_split = cb_size >> 1;
2119 const int x1 = x0 + cb_size_split;
2120 const int y1 = y0 + cb_size_split;
2124 more_data = hls_coding_quadtree(s, x0, y0, log2_cb_size - 1, cb_depth + 1);
2128 if (more_data && x1 < s->sps->width) {
2129 more_data = hls_coding_quadtree(s, x1, y0, log2_cb_size - 1, cb_depth + 1);
2133 if (more_data && y1 < s->sps->height) {
2134 more_data = hls_coding_quadtree(s, x0, y1, log2_cb_size - 1, cb_depth + 1);
2138 if (more_data && x1 < s->sps->width &&
2139 y1 < s->sps->height) {
2140 more_data = hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1);
2145 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2146 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2147 lc->qPy_pred = lc->qp_y;
2150 return ((x1 + cb_size_split) < s->sps->width ||
2151 (y1 + cb_size_split) < s->sps->height);
2155 ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2158 if ((!((x0 + cb_size) %
2159 (1 << (s->sps->log2_ctb_size))) ||
2160 (x0 + cb_size >= s->sps->width)) &&
2162 (1 << (s->sps->log2_ctb_size))) ||
2163 (y0 + cb_size >= s->sps->height))) {
2164 int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s);
2165 return !end_of_slice_flag;
2174 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2177 HEVCLocalContext *lc = s->HEVClc;
2178 int ctb_size = 1 << s->sps->log2_ctb_size;
2179 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2180 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2182 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2184 if (s->pps->entropy_coding_sync_enabled_flag) {
2185 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2186 lc->first_qp_group = 1;
2187 lc->end_of_tiles_x = s->sps->width;
2188 } else if (s->pps->tiles_enabled_flag) {
2189 if (ctb_addr_ts && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1]) {
2190 int idxX = s->pps->col_idxX[x_ctb >> s->sps->log2_ctb_size];
2191 lc->end_of_tiles_x = x_ctb + (s->pps->column_width[idxX] << s->sps->log2_ctb_size);
2192 lc->first_qp_group = 1;
2195 lc->end_of_tiles_x = s->sps->width;
2198 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->sps->height);
2200 lc->boundary_flags = 0;
2201 if (s->pps->tiles_enabled_flag) {
2202 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]])
2203 lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2204 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2205 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2206 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]])
2207 lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2208 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->sps->ctb_width])
2209 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2211 if (!ctb_addr_in_slice > 0)
2212 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2213 if (ctb_addr_in_slice < s->sps->ctb_width)
2214 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2217 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2218 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2219 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]]));
2220 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]]));
2223 static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
2225 HEVCContext *s = avctxt->priv_data;
2226 int ctb_size = 1 << s->sps->log2_ctb_size;
2230 int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2232 if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) {
2233 av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n");
2234 return AVERROR_INVALIDDATA;
2237 if (s->sh.dependent_slice_segment_flag) {
2238 int prev_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2239 if (s->tab_slice_address[prev_rs] != s->sh.slice_addr) {
2240 av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n");
2241 return AVERROR_INVALIDDATA;
2245 while (more_data && ctb_addr_ts < s->sps->ctb_size) {
2246 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2248 x_ctb = (ctb_addr_rs % ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2249 y_ctb = (ctb_addr_rs / ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2250 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2252 ff_hevc_cabac_init(s, ctb_addr_ts);
2254 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2256 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2257 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2258 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2260 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2261 if (more_data < 0) {
2262 s->tab_slice_address[ctb_addr_rs] = -1;
2268 ff_hevc_save_states(s, ctb_addr_ts);
2269 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2272 if (x_ctb + ctb_size >= s->sps->width &&
2273 y_ctb + ctb_size >= s->sps->height)
2274 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2279 static int hls_slice_data(HEVCContext *s)
2287 s->avctx->execute(s->avctx, hls_decode_entry, arg, ret , 1, sizeof(int));
2290 static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int job, int self_id)
2292 HEVCContext *s1 = avctxt->priv_data, *s;
2293 HEVCLocalContext *lc;
2294 int ctb_size = 1<< s1->sps->log2_ctb_size;
2296 int *ctb_row_p = input_ctb_row;
2297 int ctb_row = ctb_row_p[job];
2298 int ctb_addr_rs = s1->sh.slice_ctb_addr_rs + ctb_row * ((s1->sps->width + ctb_size - 1) >> s1->sps->log2_ctb_size);
2299 int ctb_addr_ts = s1->pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2300 int thread = ctb_row % s1->threads_number;
2303 s = s1->sList[self_id];
2307 ret = init_get_bits8(&lc->gb, s->data + s->sh.offset[ctb_row - 1], s->sh.size[ctb_row - 1]);
2311 ff_init_cabac_decoder(&lc->cc, s->data + s->sh.offset[(ctb_row)-1], s->sh.size[ctb_row - 1]);
2314 while(more_data && ctb_addr_ts < s->sps->ctb_size) {
2315 int x_ctb = (ctb_addr_rs % s->sps->ctb_width) << s->sps->log2_ctb_size;
2316 int y_ctb = (ctb_addr_rs / s->sps->ctb_width) << s->sps->log2_ctb_size;
2318 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2320 ff_thread_await_progress2(s->avctx, ctb_row, thread, SHIFT_CTB_WPP);
2322 if (avpriv_atomic_int_get(&s1->wpp_err)){
2323 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2327 ff_hevc_cabac_init(s, ctb_addr_ts);
2328 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2329 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2331 if (more_data < 0) {
2332 s->tab_slice_address[ctb_addr_rs] = -1;
2338 ff_hevc_save_states(s, ctb_addr_ts);
2339 ff_thread_report_progress2(s->avctx, ctb_row, thread, 1);
2340 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2342 if (!more_data && (x_ctb+ctb_size) < s->sps->width && ctb_row != s->sh.num_entry_point_offsets) {
2343 avpriv_atomic_int_set(&s1->wpp_err, 1);
2344 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2348 if ((x_ctb+ctb_size) >= s->sps->width && (y_ctb+ctb_size) >= s->sps->height ) {
2349 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2350 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2353 ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2356 if(x_ctb >= s->sps->width) {
2360 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2365 static int hls_slice_data_wpp(HEVCContext *s, const uint8_t *nal, int length)
2367 HEVCLocalContext *lc = s->HEVClc;
2368 int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2369 int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2371 int startheader, cmpt = 0;
2376 ff_alloc_entries(s->avctx, s->sh.num_entry_point_offsets + 1);
2379 for (i = 1; i < s->threads_number; i++) {
2380 s->sList[i] = av_malloc(sizeof(HEVCContext));
2381 memcpy(s->sList[i], s, sizeof(HEVCContext));
2382 s->HEVClcList[i] = av_mallocz(sizeof(HEVCLocalContext));
2383 s->sList[i]->HEVClc = s->HEVClcList[i];
2387 offset = (lc->gb.index >> 3);
2389 for (j = 0, cmpt = 0, startheader = offset + s->sh.entry_point_offset[0]; j < s->skipped_bytes; j++) {
2390 if (s->skipped_bytes_pos[j] >= offset && s->skipped_bytes_pos[j] < startheader) {
2396 for (i = 1; i < s->sh.num_entry_point_offsets; i++) {
2397 offset += (s->sh.entry_point_offset[i - 1] - cmpt);
2398 for (j = 0, cmpt = 0, startheader = offset
2399 + s->sh.entry_point_offset[i]; j < s->skipped_bytes; j++) {
2400 if (s->skipped_bytes_pos[j] >= offset && s->skipped_bytes_pos[j] < startheader) {
2405 s->sh.size[i - 1] = s->sh.entry_point_offset[i] - cmpt;
2406 s->sh.offset[i - 1] = offset;
2409 if (s->sh.num_entry_point_offsets != 0) {
2410 offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt;
2411 s->sh.size[s->sh.num_entry_point_offsets - 1] = length - offset;
2412 s->sh.offset[s->sh.num_entry_point_offsets - 1] = offset;
2417 for (i = 1; i < s->threads_number; i++) {
2418 s->sList[i]->HEVClc->first_qp_group = 1;
2419 s->sList[i]->HEVClc->qp_y = s->sList[0]->HEVClc->qp_y;
2420 memcpy(s->sList[i], s, sizeof(HEVCContext));
2421 s->sList[i]->HEVClc = s->HEVClcList[i];
2424 avpriv_atomic_int_set(&s->wpp_err, 0);
2425 ff_reset_entries(s->avctx);
2427 for (i = 0; i <= s->sh.num_entry_point_offsets; i++) {
2432 if (s->pps->entropy_coding_sync_enabled_flag)
2433 s->avctx->execute2(s->avctx, (void *) hls_decode_entry_wpp, arg, ret, s->sh.num_entry_point_offsets + 1);
2435 for (i = 0; i <= s->sh.num_entry_point_offsets; i++)
2443 * @return AVERROR_INVALIDDATA if the packet is not a valid NAL unit,
2444 * 0 if the unit should be skipped, 1 otherwise
2446 static int hls_nal_unit(HEVCContext *s)
2448 GetBitContext *gb = &s->HEVClc->gb;
2451 if (get_bits1(gb) != 0)
2452 return AVERROR_INVALIDDATA;
2454 s->nal_unit_type = get_bits(gb, 6);
2456 nuh_layer_id = get_bits(gb, 6);
2457 s->temporal_id = get_bits(gb, 3) - 1;
2458 if (s->temporal_id < 0)
2459 return AVERROR_INVALIDDATA;
2461 av_log(s->avctx, AV_LOG_DEBUG,
2462 "nal_unit_type: %d, nuh_layer_id: %d, temporal_id: %d\n",
2463 s->nal_unit_type, nuh_layer_id, s->temporal_id);
2465 return nuh_layer_id == 0;
2468 static int set_side_data(HEVCContext *s)
2470 AVFrame *out = s->ref->frame;
2472 if (s->sei_frame_packing_present &&
2473 s->frame_packing_arrangement_type >= 3 &&
2474 s->frame_packing_arrangement_type <= 5 &&
2475 s->content_interpretation_type > 0 &&
2476 s->content_interpretation_type < 3) {
2477 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2479 return AVERROR(ENOMEM);
2481 switch (s->frame_packing_arrangement_type) {
2483 if (s->quincunx_subsampling)
2484 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2486 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2489 stereo->type = AV_STEREO3D_TOPBOTTOM;
2492 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2496 if (s->content_interpretation_type == 2)
2497 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2500 if (s->sei_display_orientation_present &&
2501 (s->sei_anticlockwise_rotation || s->sei_hflip || s->sei_vflip)) {
2502 double angle = s->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
2503 AVFrameSideData *rotation = av_frame_new_side_data(out,
2504 AV_FRAME_DATA_DISPLAYMATRIX,
2505 sizeof(int32_t) * 9);
2507 return AVERROR(ENOMEM);
2509 av_display_rotation_set((int32_t *)rotation->data, angle);
2510 av_display_matrix_flip((int32_t *)rotation->data,
2511 s->sei_hflip, s->sei_vflip);
2517 static int hevc_frame_start(HEVCContext *s)
2519 HEVCLocalContext *lc = s->HEVClc;
2520 int pic_size_in_ctb = ((s->sps->width >> s->sps->log2_min_cb_size) + 1) *
2521 ((s->sps->height >> s->sps->log2_min_cb_size) + 1);
2524 memset(s->horizontal_bs, 0, s->bs_width * s->bs_height);
2525 memset(s->vertical_bs, 0, s->bs_width * s->bs_height);
2526 memset(s->cbf_luma, 0, s->sps->min_tb_width * s->sps->min_tb_height);
2527 memset(s->is_pcm, 0, (s->sps->min_pu_width + 1) * (s->sps->min_pu_height + 1));
2528 memset(s->tab_slice_address, -1, pic_size_in_ctb * sizeof(*s->tab_slice_address));
2531 s->first_nal_type = s->nal_unit_type;
2533 if (s->pps->tiles_enabled_flag)
2534 lc->end_of_tiles_x = s->pps->column_width[0] << s->sps->log2_ctb_size;
2536 ret = ff_hevc_set_new_ref(s, &s->frame, s->poc);
2540 ret = ff_hevc_frame_rps(s);
2542 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2546 s->ref->frame->key_frame = IS_IRAP(s);
2548 ret = set_side_data(s);
2552 s->frame->pict_type = 3 - s->sh.slice_type;
2555 ff_hevc_bump_frame(s);
2557 av_frame_unref(s->output_frame);
2558 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2562 ff_thread_finish_setup(s->avctx);
2567 if (s->ref && s->threads_type == FF_THREAD_FRAME)
2568 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2573 static int decode_nal_unit(HEVCContext *s, const uint8_t *nal, int length)
2575 HEVCLocalContext *lc = s->HEVClc;
2576 GetBitContext *gb = &lc->gb;
2577 int ctb_addr_ts, ret;
2579 ret = init_get_bits8(gb, nal, length);
2583 ret = hls_nal_unit(s);
2585 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit %d, skipping.\n",
2591 switch (s->nal_unit_type) {
2593 ret = ff_hevc_decode_nal_vps(s);
2598 ret = ff_hevc_decode_nal_sps(s);
2603 ret = ff_hevc_decode_nal_pps(s);
2607 case NAL_SEI_PREFIX:
2608 case NAL_SEI_SUFFIX:
2609 ret = ff_hevc_decode_nal_sei(s);
2620 case NAL_BLA_W_RADL:
2622 case NAL_IDR_W_RADL:
2629 ret = hls_slice_header(s);
2633 if (s->max_ra == INT_MAX) {
2634 if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
2638 s->max_ra = INT_MIN;
2642 if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
2643 s->poc <= s->max_ra) {
2647 if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
2648 s->max_ra = INT_MIN;
2651 if (s->sh.first_slice_in_pic_flag) {
2652 ret = hevc_frame_start(s);
2655 } else if (!s->ref) {
2656 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2660 if (s->nal_unit_type != s->first_nal_type) {
2661 av_log(s->avctx, AV_LOG_ERROR,
2662 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2663 s->first_nal_type, s->nal_unit_type);
2664 return AVERROR_INVALIDDATA;
2667 if (!s->sh.dependent_slice_segment_flag &&
2668 s->sh.slice_type != I_SLICE) {
2669 ret = ff_hevc_slice_rpl(s);
2671 av_log(s->avctx, AV_LOG_WARNING,
2672 "Error constructing the reference lists for the current slice.\n");
2677 if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
2678 ctb_addr_ts = hls_slice_data_wpp(s, nal, length);
2680 ctb_addr_ts = hls_slice_data(s);
2681 if (ctb_addr_ts >= (s->sps->ctb_width * s->sps->ctb_height)) {
2685 if (ctb_addr_ts < 0) {
2692 s->seq_decode = (s->seq_decode + 1) & 0xff;
2693 s->max_ra = INT_MAX;
2699 av_log(s->avctx, AV_LOG_INFO,
2700 "Skipping NAL unit %d\n", s->nal_unit_type);
2705 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2710 /* FIXME: This is adapted from ff_h264_decode_nal, avoiding duplication
2711 * between these functions would be nice. */
2712 int ff_hevc_extract_rbsp(HEVCContext *s, const uint8_t *src, int length,
2718 s->skipped_bytes = 0;
2719 #define STARTCODE_TEST \
2720 if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \
2721 if (src[i + 2] != 3) { \
2722 /* startcode, so we must be past the end */ \
2727 #if HAVE_FAST_UNALIGNED
2728 #define FIND_FIRST_ZERO \
2729 if (i > 0 && !src[i]) \
2734 for (i = 0; i + 1 < length; i += 9) {
2735 if (!((~AV_RN64A(src + i) &
2736 (AV_RN64A(src + i) - 0x0100010001000101ULL)) &
2737 0x8000800080008080ULL))
2744 for (i = 0; i + 1 < length; i += 5) {
2745 if (!((~AV_RN32A(src + i) &
2746 (AV_RN32A(src + i) - 0x01000101U)) &
2753 #endif /* HAVE_FAST_64BIT */
2755 for (i = 0; i + 1 < length; i += 2) {
2758 if (i > 0 && src[i - 1] == 0)
2762 #endif /* HAVE_FAST_UNALIGNED */
2764 if (i >= length - 1) { // no escaped 0
2770 av_fast_malloc(&nal->rbsp_buffer, &nal->rbsp_buffer_size,
2771 length + FF_INPUT_BUFFER_PADDING_SIZE);
2772 if (!nal->rbsp_buffer)
2773 return AVERROR(ENOMEM);
2775 dst = nal->rbsp_buffer;
2777 memcpy(dst, src, i);
2779 while (si + 2 < length) {
2780 // remove escapes (very rare 1:2^22)
2781 if (src[si + 2] > 3) {
2782 dst[di++] = src[si++];
2783 dst[di++] = src[si++];
2784 } else if (src[si] == 0 && src[si + 1] == 0) {
2785 if (src[si + 2] == 3) { // escape
2791 if (s->skipped_bytes_pos_size < s->skipped_bytes) {
2792 s->skipped_bytes_pos_size *= 2;
2793 av_reallocp_array(&s->skipped_bytes_pos,
2794 s->skipped_bytes_pos_size,
2795 sizeof(*s->skipped_bytes_pos));
2796 if (!s->skipped_bytes_pos)
2797 return AVERROR(ENOMEM);
2799 if (s->skipped_bytes_pos)
2800 s->skipped_bytes_pos[s->skipped_bytes-1] = di - 1;
2802 } else // next start code
2806 dst[di++] = src[si++];
2809 dst[di++] = src[si++];
2812 memset(dst + di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2819 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2821 int i, consumed, ret = 0;
2824 s->last_eos = s->eos;
2827 /* split the input packet into NAL units, so we know the upper bound on the
2828 * number of slices in the frame */
2830 while (length >= 4) {
2832 int extract_length = 0;
2836 for (i = 0; i < s->nal_length_size; i++)
2837 extract_length = (extract_length << 8) | buf[i];
2838 buf += s->nal_length_size;
2839 length -= s->nal_length_size;
2841 if (extract_length > length) {
2842 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit size.\n");
2843 ret = AVERROR_INVALIDDATA;
2847 /* search start code */
2848 while (buf[0] != 0 || buf[1] != 0 || buf[2] != 1) {
2852 av_log(s->avctx, AV_LOG_ERROR, "No start code is found.\n");
2853 ret = AVERROR_INVALIDDATA;
2863 extract_length = length;
2865 if (s->nals_allocated < s->nb_nals + 1) {
2866 int new_size = s->nals_allocated + 1;
2867 HEVCNAL *tmp = av_realloc_array(s->nals, new_size, sizeof(*tmp));
2869 ret = AVERROR(ENOMEM);
2873 memset(s->nals + s->nals_allocated, 0,
2874 (new_size - s->nals_allocated) * sizeof(*tmp));
2875 av_reallocp_array(&s->skipped_bytes_nal, new_size, sizeof(*s->skipped_bytes_nal));
2876 av_reallocp_array(&s->skipped_bytes_pos_size_nal, new_size, sizeof(*s->skipped_bytes_pos_size_nal));
2877 av_reallocp_array(&s->skipped_bytes_pos_nal, new_size, sizeof(*s->skipped_bytes_pos_nal));
2878 s->skipped_bytes_pos_size_nal[s->nals_allocated] = 1024; // initial buffer size
2879 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));
2880 s->nals_allocated = new_size;
2882 s->skipped_bytes_pos_size = s->skipped_bytes_pos_size_nal[s->nb_nals];
2883 s->skipped_bytes_pos = s->skipped_bytes_pos_nal[s->nb_nals];
2884 nal = &s->nals[s->nb_nals];
2886 consumed = ff_hevc_extract_rbsp(s, buf, extract_length, nal);
2888 s->skipped_bytes_nal[s->nb_nals] = s->skipped_bytes;
2889 s->skipped_bytes_pos_size_nal[s->nb_nals] = s->skipped_bytes_pos_size;
2890 s->skipped_bytes_pos_nal[s->nb_nals++] = s->skipped_bytes_pos;
2898 ret = init_get_bits8(&s->HEVClc->gb, nal->data, nal->size);
2903 if (s->nal_unit_type == NAL_EOB_NUT ||
2904 s->nal_unit_type == NAL_EOS_NUT)
2911 /* parse the NAL units */
2912 for (i = 0; i < s->nb_nals; i++) {
2914 s->skipped_bytes = s->skipped_bytes_nal[i];
2915 s->skipped_bytes_pos = s->skipped_bytes_pos_nal[i];
2917 ret = decode_nal_unit(s, s->nals[i].data, s->nals[i].size);
2919 av_log(s->avctx, AV_LOG_WARNING,
2920 "Error parsing NAL unit #%d.\n", i);
2926 if (s->ref && s->threads_type == FF_THREAD_FRAME)
2927 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2932 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2935 for (i = 0; i < 16; i++)
2936 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
2939 static int verify_md5(HEVCContext *s, AVFrame *frame)
2941 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
2946 return AVERROR(EINVAL);
2948 pixel_shift = desc->comp[0].depth_minus1 > 7;
2950 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
2953 /* the checksums are LE, so we have to byteswap for >8bpp formats
2956 if (pixel_shift && !s->checksum_buf) {
2957 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
2958 FFMAX3(frame->linesize[0], frame->linesize[1],
2959 frame->linesize[2]));
2960 if (!s->checksum_buf)
2961 return AVERROR(ENOMEM);
2965 for (i = 0; frame->data[i]; i++) {
2966 int width = s->avctx->coded_width;
2967 int height = s->avctx->coded_height;
2968 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
2969 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
2972 av_md5_init(s->md5_ctx);
2973 for (j = 0; j < h; j++) {
2974 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
2977 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
2978 (const uint16_t *) src, w);
2979 src = s->checksum_buf;
2982 av_md5_update(s->md5_ctx, src, w << pixel_shift);
2984 av_md5_final(s->md5_ctx, md5);
2986 if (!memcmp(md5, s->md5[i], 16)) {
2987 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
2988 print_md5(s->avctx, AV_LOG_DEBUG, md5);
2989 av_log (s->avctx, AV_LOG_DEBUG, "; ");
2991 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
2992 print_md5(s->avctx, AV_LOG_ERROR, md5);
2993 av_log (s->avctx, AV_LOG_ERROR, " != ");
2994 print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
2995 av_log (s->avctx, AV_LOG_ERROR, "\n");
2996 return AVERROR_INVALIDDATA;
3000 av_log(s->avctx, AV_LOG_DEBUG, "\n");
3005 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
3009 HEVCContext *s = avctx->priv_data;
3012 ret = ff_hevc_output_frame(s, data, 1);
3021 ret = decode_nal_units(s, avpkt->data, avpkt->size);
3025 /* verify the SEI checksum */
3026 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
3028 ret = verify_md5(s, s->ref->frame);
3029 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
3030 ff_hevc_unref_frame(s, s->ref, ~0);
3036 if (s->is_decoded) {
3037 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
3041 if (s->output_frame->buf[0]) {
3042 av_frame_move_ref(data, s->output_frame);
3049 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
3053 ret = ff_thread_ref_frame(&dst->tf, &src->tf);
3057 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
3058 if (!dst->tab_mvf_buf)
3060 dst->tab_mvf = src->tab_mvf;
3062 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
3063 if (!dst->rpl_tab_buf)
3065 dst->rpl_tab = src->rpl_tab;
3067 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
3071 dst->poc = src->poc;
3072 dst->ctb_count = src->ctb_count;
3073 dst->window = src->window;
3074 dst->flags = src->flags;
3075 dst->sequence = src->sequence;
3079 ff_hevc_unref_frame(s, dst, ~0);
3080 return AVERROR(ENOMEM);
3083 static av_cold int hevc_decode_free(AVCodecContext *avctx)
3085 HEVCContext *s = avctx->priv_data;
3090 av_freep(&s->md5_ctx);
3092 for(i=0; i < s->nals_allocated; i++) {
3093 av_freep(&s->skipped_bytes_pos_nal[i]);
3095 av_freep(&s->skipped_bytes_pos_size_nal);
3096 av_freep(&s->skipped_bytes_nal);
3097 av_freep(&s->skipped_bytes_pos_nal);
3099 av_freep(&s->cabac_state);
3101 av_frame_free(&s->tmp_frame);
3102 av_frame_free(&s->output_frame);
3104 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3105 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3106 av_frame_free(&s->DPB[i].frame);
3109 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++)
3110 av_buffer_unref(&s->vps_list[i]);
3111 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++)
3112 av_buffer_unref(&s->sps_list[i]);
3113 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
3114 av_buffer_unref(&s->pps_list[i]);
3119 av_buffer_unref(&s->current_sps);
3121 av_freep(&s->sh.entry_point_offset);
3122 av_freep(&s->sh.offset);
3123 av_freep(&s->sh.size);
3125 for (i = 1; i < s->threads_number; i++) {
3126 HEVCLocalContext *lc = s->HEVClcList[i];
3128 av_freep(&s->HEVClcList[i]);
3129 av_freep(&s->sList[i]);
3132 if (s->HEVClc == s->HEVClcList[0])
3134 av_freep(&s->HEVClcList[0]);
3136 for (i = 0; i < s->nals_allocated; i++)
3137 av_freep(&s->nals[i].rbsp_buffer);
3139 s->nals_allocated = 0;
3144 static av_cold int hevc_init_context(AVCodecContext *avctx)
3146 HEVCContext *s = avctx->priv_data;
3151 s->HEVClc = av_mallocz(sizeof(HEVCLocalContext));
3154 s->HEVClcList[0] = s->HEVClc;
3157 s->cabac_state = av_malloc(HEVC_CONTEXTS);
3158 if (!s->cabac_state)
3161 s->tmp_frame = av_frame_alloc();
3165 s->output_frame = av_frame_alloc();
3166 if (!s->output_frame)
3169 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3170 s->DPB[i].frame = av_frame_alloc();
3171 if (!s->DPB[i].frame)
3173 s->DPB[i].tf.f = s->DPB[i].frame;
3176 s->max_ra = INT_MAX;
3178 s->md5_ctx = av_md5_alloc();
3182 ff_bswapdsp_init(&s->bdsp);
3184 s->context_initialized = 1;
3190 hevc_decode_free(avctx);
3191 return AVERROR(ENOMEM);
3194 static int hevc_update_thread_context(AVCodecContext *dst,
3195 const AVCodecContext *src)
3197 HEVCContext *s = dst->priv_data;
3198 HEVCContext *s0 = src->priv_data;
3201 if (!s->context_initialized) {
3202 ret = hevc_init_context(dst);
3207 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3208 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3209 if (s0->DPB[i].frame->buf[0]) {
3210 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3216 if (s->sps != s0->sps)
3218 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++) {
3219 av_buffer_unref(&s->vps_list[i]);
3220 if (s0->vps_list[i]) {
3221 s->vps_list[i] = av_buffer_ref(s0->vps_list[i]);
3222 if (!s->vps_list[i])
3223 return AVERROR(ENOMEM);
3227 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++) {
3228 av_buffer_unref(&s->sps_list[i]);
3229 if (s0->sps_list[i]) {
3230 s->sps_list[i] = av_buffer_ref(s0->sps_list[i]);
3231 if (!s->sps_list[i])
3232 return AVERROR(ENOMEM);
3236 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++) {
3237 av_buffer_unref(&s->pps_list[i]);
3238 if (s0->pps_list[i]) {
3239 s->pps_list[i] = av_buffer_ref(s0->pps_list[i]);
3240 if (!s->pps_list[i])
3241 return AVERROR(ENOMEM);
3245 av_buffer_unref(&s->current_sps);
3246 if (s0->current_sps) {
3247 s->current_sps = av_buffer_ref(s0->current_sps);
3248 if (!s->current_sps)
3249 return AVERROR(ENOMEM);
3252 if (s->sps != s0->sps)
3253 if ((ret = set_sps(s, s0->sps)) < 0)
3256 s->seq_decode = s0->seq_decode;
3257 s->seq_output = s0->seq_output;
3258 s->pocTid0 = s0->pocTid0;
3259 s->max_ra = s0->max_ra;
3262 s->is_nalff = s0->is_nalff;
3263 s->nal_length_size = s0->nal_length_size;
3265 s->threads_number = s0->threads_number;
3266 s->threads_type = s0->threads_type;
3269 s->seq_decode = (s->seq_decode + 1) & 0xff;
3270 s->max_ra = INT_MAX;
3276 static int hevc_decode_extradata(HEVCContext *s)
3278 AVCodecContext *avctx = s->avctx;
3282 bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
3284 if (avctx->extradata_size > 3 &&
3285 (avctx->extradata[0] || avctx->extradata[1] ||
3286 avctx->extradata[2] > 1)) {
3287 /* It seems the extradata is encoded as hvcC format.
3288 * Temporarily, we support configurationVersion==0 until 14496-15 3rd
3289 * is finalized. When finalized, configurationVersion will be 1 and we
3290 * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
3291 int i, j, num_arrays, nal_len_size;
3295 bytestream2_skip(&gb, 21);
3296 nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
3297 num_arrays = bytestream2_get_byte(&gb);
3299 /* nal units in the hvcC always have length coded with 2 bytes,
3300 * so put a fake nal_length_size = 2 while parsing them */
3301 s->nal_length_size = 2;
3303 /* Decode nal units from hvcC. */
3304 for (i = 0; i < num_arrays; i++) {
3305 int type = bytestream2_get_byte(&gb) & 0x3f;
3306 int cnt = bytestream2_get_be16(&gb);
3308 for (j = 0; j < cnt; j++) {
3309 // +2 for the nal size field
3310 int nalsize = bytestream2_peek_be16(&gb) + 2;
3311 if (bytestream2_get_bytes_left(&gb) < nalsize) {
3312 av_log(s->avctx, AV_LOG_ERROR,
3313 "Invalid NAL unit size in extradata.\n");
3314 return AVERROR_INVALIDDATA;
3317 ret = decode_nal_units(s, gb.buffer, nalsize);
3319 av_log(avctx, AV_LOG_ERROR,
3320 "Decoding nal unit %d %d from hvcC failed\n",
3324 bytestream2_skip(&gb, nalsize);
3328 /* Now store right nal length size, that will be used to parse
3330 s->nal_length_size = nal_len_size;
3333 ret = decode_nal_units(s, avctx->extradata, avctx->extradata_size);
3340 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3342 HEVCContext *s = avctx->priv_data;
3345 ff_init_cabac_states();
3347 avctx->internal->allocate_progress = 1;
3349 ret = hevc_init_context(avctx);
3353 s->enable_parallel_tiles = 0;
3354 s->picture_struct = 0;
3356 if(avctx->active_thread_type & FF_THREAD_SLICE)
3357 s->threads_number = avctx->thread_count;
3359 s->threads_number = 1;
3361 if (avctx->extradata_size > 0 && avctx->extradata) {
3362 ret = hevc_decode_extradata(s);
3364 hevc_decode_free(avctx);
3369 if((avctx->active_thread_type & FF_THREAD_FRAME) && avctx->thread_count > 1)
3370 s->threads_type = FF_THREAD_FRAME;
3372 s->threads_type = FF_THREAD_SLICE;
3377 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3379 HEVCContext *s = avctx->priv_data;
3382 memset(s, 0, sizeof(*s));
3384 ret = hevc_init_context(avctx);
3391 static void hevc_decode_flush(AVCodecContext *avctx)
3393 HEVCContext *s = avctx->priv_data;
3394 ff_hevc_flush_dpb(s);
3395 s->max_ra = INT_MAX;
3398 #define OFFSET(x) offsetof(HEVCContext, x)
3399 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3401 static const AVProfile profiles[] = {
3402 { FF_PROFILE_HEVC_MAIN, "Main" },
3403 { FF_PROFILE_HEVC_MAIN_10, "Main 10" },
3404 { FF_PROFILE_HEVC_MAIN_STILL_PICTURE, "Main Still Picture" },
3405 { FF_PROFILE_HEVC_REXT, "Rext" },
3406 { FF_PROFILE_UNKNOWN },
3409 static const AVOption options[] = {
3410 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3411 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3412 { "strict-displaywin", "stricly apply default display window size", OFFSET(apply_defdispwin),
3413 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3417 static const AVClass hevc_decoder_class = {
3418 .class_name = "HEVC decoder",
3419 .item_name = av_default_item_name,
3421 .version = LIBAVUTIL_VERSION_INT,
3424 AVCodec ff_hevc_decoder = {
3426 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3427 .type = AVMEDIA_TYPE_VIDEO,
3428 .id = AV_CODEC_ID_HEVC,
3429 .priv_data_size = sizeof(HEVCContext),
3430 .priv_class = &hevc_decoder_class,
3431 .init = hevc_decode_init,
3432 .close = hevc_decode_free,
3433 .decode = hevc_decode_frame,
3434 .flush = hevc_decode_flush,
3435 .update_thread_context = hevc_update_thread_context,
3436 .init_thread_copy = hevc_init_thread_copy,
3437 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY |
3438 CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS,
3439 .profiles = NULL_IF_CONFIG_SMALL(profiles),