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;
1607 int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1610 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1612 if (skip_flag || lc->pu.merge_flag) {
1613 if (s->sh.max_num_merge_cand > 1)
1614 merge_idx = ff_hevc_merge_idx_decode(s);
1618 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1619 partIdx, merge_idx, ¤t_mv);
1620 x_pu = x0 >> s->sps->log2_min_pu_size;
1621 y_pu = y0 >> s->sps->log2_min_pu_size;
1623 for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1624 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1625 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1627 enum InterPredIdc inter_pred_idc = PRED_L0;
1628 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1629 current_mv.pred_flag = 0;
1630 if (s->sh.slice_type == B_SLICE)
1631 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1633 if (inter_pred_idc != PRED_L1) {
1634 if (s->sh.nb_refs[L0]) {
1635 ref_idx[0] = ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1636 current_mv.ref_idx[0] = ref_idx[0];
1639 current_mv.pred_flag = PF_L0;
1640 ff_hevc_hls_mvd_coding(s, x0, y0, 0);
1641 mvp_flag[0] = ff_hevc_mvp_lx_flag_decode(s);
1642 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1643 partIdx, merge_idx, ¤t_mv,
1645 current_mv.mv[0].x += lc->pu.mvd.x;
1646 current_mv.mv[0].y += lc->pu.mvd.y;
1649 if (inter_pred_idc != PRED_L0) {
1650 if (s->sh.nb_refs[L1]) {
1651 ref_idx[1] = ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1652 current_mv.ref_idx[1] = ref_idx[1];
1655 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1656 AV_ZERO32(&lc->pu.mvd);
1658 ff_hevc_hls_mvd_coding(s, x0, y0, 1);
1661 current_mv.pred_flag += PF_L1;
1662 mvp_flag[1] = ff_hevc_mvp_lx_flag_decode(s);
1663 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1664 partIdx, merge_idx, ¤t_mv,
1666 current_mv.mv[1].x += lc->pu.mvd.x;
1667 current_mv.mv[1].y += lc->pu.mvd.y;
1670 x_pu = x0 >> s->sps->log2_min_pu_size;
1671 y_pu = y0 >> s->sps->log2_min_pu_size;
1673 for(j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1674 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1675 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1678 if (current_mv.pred_flag & PF_L0) {
1679 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1682 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1684 if (current_mv.pred_flag & PF_L1) {
1685 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1688 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1691 if (current_mv.pred_flag == PF_L0) {
1692 int x0_c = x0 >> s->sps->hshift[1];
1693 int y0_c = y0 >> s->sps->vshift[1];
1694 int nPbW_c = nPbW >> s->sps->hshift[1];
1695 int nPbH_c = nPbH >> s->sps->vshift[1];
1697 luma_mc_uni(s, dst0, s->frame->linesize[0], ref0->frame,
1698 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1699 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1700 s->sh.luma_offset_l0[current_mv.ref_idx[0]]);
1702 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref0->frame->data[1], ref0->frame->linesize[1],
1703 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1704 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]);
1705 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref0->frame->data[2], ref0->frame->linesize[2],
1706 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1707 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]);
1708 } else if (current_mv.pred_flag == PF_L1) {
1709 int x0_c = x0 >> s->sps->hshift[1];
1710 int y0_c = y0 >> s->sps->vshift[1];
1711 int nPbW_c = nPbW >> s->sps->hshift[1];
1712 int nPbH_c = nPbH >> s->sps->vshift[1];
1714 luma_mc_uni(s, dst0, s->frame->linesize[0], ref1->frame,
1715 ¤t_mv.mv[1], x0, y0, nPbW, nPbH,
1716 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1717 s->sh.luma_offset_l1[current_mv.ref_idx[1]]);
1719 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
1720 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1721 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]);
1723 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
1724 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1725 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]);
1726 } else if (current_mv.pred_flag == PF_BI) {
1727 int x0_c = x0 >> s->sps->hshift[1];
1728 int y0_c = y0 >> s->sps->vshift[1];
1729 int nPbW_c = nPbW >> s->sps->hshift[1];
1730 int nPbH_c = nPbH >> s->sps->vshift[1];
1732 luma_mc_bi(s, dst0, s->frame->linesize[0], ref0->frame,
1733 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1734 ref1->frame, ¤t_mv.mv[1], ¤t_mv);
1736 chroma_mc_bi(s, dst1, s->frame->linesize[1], ref0->frame, ref1->frame,
1737 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 0);
1739 chroma_mc_bi(s, dst2, s->frame->linesize[2], ref0->frame, ref1->frame,
1740 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1);
1747 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1748 int prev_intra_luma_pred_flag)
1750 HEVCLocalContext *lc = s->HEVClc;
1751 int x_pu = x0 >> s->sps->log2_min_pu_size;
1752 int y_pu = y0 >> s->sps->log2_min_pu_size;
1753 int min_pu_width = s->sps->min_pu_width;
1754 int size_in_pus = pu_size >> s->sps->log2_min_pu_size;
1755 int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1);
1756 int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1);
1758 int cand_up = (lc->ctb_up_flag || y0b) ?
1759 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1760 int cand_left = (lc->ctb_left_flag || x0b) ?
1761 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1763 int y_ctb = (y0 >> (s->sps->log2_ctb_size)) << (s->sps->log2_ctb_size);
1765 MvField *tab_mvf = s->ref->tab_mvf;
1766 int intra_pred_mode;
1770 // intra_pred_mode prediction does not cross vertical CTB boundaries
1771 if ((y0 - 1) < y_ctb)
1774 if (cand_left == cand_up) {
1775 if (cand_left < 2) {
1776 candidate[0] = INTRA_PLANAR;
1777 candidate[1] = INTRA_DC;
1778 candidate[2] = INTRA_ANGULAR_26;
1780 candidate[0] = cand_left;
1781 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1782 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1785 candidate[0] = cand_left;
1786 candidate[1] = cand_up;
1787 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1788 candidate[2] = INTRA_PLANAR;
1789 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1790 candidate[2] = INTRA_DC;
1792 candidate[2] = INTRA_ANGULAR_26;
1796 if (prev_intra_luma_pred_flag) {
1797 intra_pred_mode = candidate[lc->pu.mpm_idx];
1799 if (candidate[0] > candidate[1])
1800 FFSWAP(uint8_t, candidate[0], candidate[1]);
1801 if (candidate[0] > candidate[2])
1802 FFSWAP(uint8_t, candidate[0], candidate[2]);
1803 if (candidate[1] > candidate[2])
1804 FFSWAP(uint8_t, candidate[1], candidate[2]);
1806 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1807 for (i = 0; i < 3; i++)
1808 if (intra_pred_mode >= candidate[i])
1812 /* write the intra prediction units into the mv array */
1815 for (i = 0; i < size_in_pus; i++) {
1816 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1817 intra_pred_mode, size_in_pus);
1819 for (j = 0; j < size_in_pus; j++) {
1820 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag = PF_INTRA;
1824 return intra_pred_mode;
1827 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1828 int log2_cb_size, int ct_depth)
1830 int length = (1 << log2_cb_size) >> s->sps->log2_min_cb_size;
1831 int x_cb = x0 >> s->sps->log2_min_cb_size;
1832 int y_cb = y0 >> s->sps->log2_min_cb_size;
1835 for (y = 0; y < length; y++)
1836 memset(&s->tab_ct_depth[(y_cb + y) * s->sps->min_cb_width + x_cb],
1840 static const uint8_t tab_mode_idx[] = {
1841 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
1842 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
1844 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1847 HEVCLocalContext *lc = s->HEVClc;
1848 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1849 uint8_t prev_intra_luma_pred_flag[4];
1850 int split = lc->cu.part_mode == PART_NxN;
1851 int pb_size = (1 << log2_cb_size) >> split;
1852 int side = split + 1;
1856 for (i = 0; i < side; i++)
1857 for (j = 0; j < side; j++)
1858 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1860 for (i = 0; i < side; i++) {
1861 for (j = 0; j < side; j++) {
1862 if (prev_intra_luma_pred_flag[2 * i + j])
1863 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
1865 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
1867 lc->pu.intra_pred_mode[2 * i + j] =
1868 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1869 prev_intra_luma_pred_flag[2 * i + j]);
1873 if (s->sps->chroma_format_idc == 3) {
1874 for (i = 0; i < side; i++) {
1875 for (j = 0; j < side; j++) {
1876 lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1877 if (chroma_mode != 4) {
1878 if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode])
1879 lc->pu.intra_pred_mode_c[2 * i + j] = 34;
1881 lc->pu.intra_pred_mode_c[2 * i + j] = intra_chroma_table[chroma_mode];
1883 lc->pu.intra_pred_mode_c[2 * i + j] = lc->pu.intra_pred_mode[2 * i + j];
1887 } else if (s->sps->chroma_format_idc == 2) {
1889 lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1890 if (chroma_mode != 4) {
1891 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1894 mode_idx = intra_chroma_table[chroma_mode];
1896 mode_idx = lc->pu.intra_pred_mode[0];
1898 lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx];
1899 } else if (s->sps->chroma_format_idc != 0) {
1900 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1901 if (chroma_mode != 4) {
1902 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1903 lc->pu.intra_pred_mode_c[0] = 34;
1905 lc->pu.intra_pred_mode_c[0] = intra_chroma_table[chroma_mode];
1907 lc->pu.intra_pred_mode_c[0] = lc->pu.intra_pred_mode[0];
1912 static void intra_prediction_unit_default_value(HEVCContext *s,
1916 HEVCLocalContext *lc = s->HEVClc;
1917 int pb_size = 1 << log2_cb_size;
1918 int size_in_pus = pb_size >> s->sps->log2_min_pu_size;
1919 int min_pu_width = s->sps->min_pu_width;
1920 MvField *tab_mvf = s->ref->tab_mvf;
1921 int x_pu = x0 >> s->sps->log2_min_pu_size;
1922 int y_pu = y0 >> s->sps->log2_min_pu_size;
1925 if (size_in_pus == 0)
1927 for (j = 0; j < size_in_pus; j++)
1928 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
1929 if (lc->cu.pred_mode == MODE_INTRA)
1930 for (j = 0; j < size_in_pus; j++)
1931 for (k = 0; k < size_in_pus; k++)
1932 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].pred_flag = PF_INTRA;
1935 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
1937 int cb_size = 1 << log2_cb_size;
1938 HEVCLocalContext *lc = s->HEVClc;
1939 int log2_min_cb_size = s->sps->log2_min_cb_size;
1940 int length = cb_size >> log2_min_cb_size;
1941 int min_cb_width = s->sps->min_cb_width;
1942 int x_cb = x0 >> log2_min_cb_size;
1943 int y_cb = y0 >> log2_min_cb_size;
1944 int idx = log2_cb_size - 2;
1945 int qp_block_mask = (1<<(s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth)) - 1;
1950 lc->cu.pred_mode = MODE_INTRA;
1951 lc->cu.part_mode = PART_2Nx2N;
1952 lc->cu.intra_split_flag = 0;
1954 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
1955 for (x = 0; x < 4; x++)
1956 lc->pu.intra_pred_mode[x] = 1;
1957 if (s->pps->transquant_bypass_enable_flag) {
1958 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
1959 if (lc->cu.cu_transquant_bypass_flag)
1960 set_deblocking_bypass(s, x0, y0, log2_cb_size);
1962 lc->cu.cu_transquant_bypass_flag = 0;
1964 if (s->sh.slice_type != I_SLICE) {
1965 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
1967 x = y_cb * min_cb_width + x_cb;
1968 for (y = 0; y < length; y++) {
1969 memset(&s->skip_flag[x], skip_flag, length);
1972 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
1974 x = y_cb * min_cb_width + x_cb;
1975 for (y = 0; y < length; y++) {
1976 memset(&s->skip_flag[x], 0, length);
1981 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
1982 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
1983 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
1985 if (!s->sh.disable_deblocking_filter_flag)
1986 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1990 if (s->sh.slice_type != I_SLICE)
1991 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
1992 if (lc->cu.pred_mode != MODE_INTRA ||
1993 log2_cb_size == s->sps->log2_min_cb_size) {
1994 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
1995 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
1996 lc->cu.pred_mode == MODE_INTRA;
1999 if (lc->cu.pred_mode == MODE_INTRA) {
2000 if (lc->cu.part_mode == PART_2Nx2N && s->sps->pcm_enabled_flag &&
2001 log2_cb_size >= s->sps->pcm.log2_min_pcm_cb_size &&
2002 log2_cb_size <= s->sps->pcm.log2_max_pcm_cb_size) {
2003 pcm_flag = ff_hevc_pcm_flag_decode(s);
2006 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2007 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2008 if (s->sps->pcm.loop_filter_disable_flag)
2009 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2014 intra_prediction_unit(s, x0, y0, log2_cb_size);
2017 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2018 switch (lc->cu.part_mode) {
2020 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2023 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0, idx);
2024 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2027 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2028 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2031 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0, idx);
2032 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2035 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2036 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2039 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0, idx - 2);
2040 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2043 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2044 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2047 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2048 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2049 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2050 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2056 int rqt_root_cbf = 1;
2058 if (lc->cu.pred_mode != MODE_INTRA &&
2059 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2060 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2063 const static int cbf[2] = { 0 };
2064 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2065 s->sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2066 s->sps->max_transform_hierarchy_depth_inter;
2067 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2069 log2_cb_size, 0, 0, cbf, cbf);
2073 if (!s->sh.disable_deblocking_filter_flag)
2074 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2079 if (s->pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2080 ff_hevc_set_qPy(s, x0, y0, log2_cb_size);
2082 x = y_cb * min_cb_width + x_cb;
2083 for (y = 0; y < length; y++) {
2084 memset(&s->qp_y_tab[x], lc->qp_y, length);
2088 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2089 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2090 lc->qPy_pred = lc->qp_y;
2093 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct_depth);
2098 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2099 int log2_cb_size, int cb_depth)
2101 HEVCLocalContext *lc = s->HEVClc;
2102 const int cb_size = 1 << log2_cb_size;
2104 int qp_block_mask = (1<<(s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth)) - 1;
2107 lc->ct_depth = cb_depth;
2108 if (x0 + cb_size <= s->sps->width &&
2109 y0 + cb_size <= s->sps->height &&
2110 log2_cb_size > s->sps->log2_min_cb_size) {
2111 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2113 split_cu = (log2_cb_size > s->sps->log2_min_cb_size);
2115 if (s->pps->cu_qp_delta_enabled_flag &&
2116 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth) {
2117 lc->tu.is_cu_qp_delta_coded = 0;
2118 lc->tu.cu_qp_delta = 0;
2121 if (s->sh.cu_chroma_qp_offset_enabled_flag &&
2122 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_chroma_qp_offset_depth) {
2123 lc->tu.is_cu_chroma_qp_offset_coded = 0;
2127 const int cb_size_split = cb_size >> 1;
2128 const int x1 = x0 + cb_size_split;
2129 const int y1 = y0 + cb_size_split;
2133 more_data = hls_coding_quadtree(s, x0, y0, log2_cb_size - 1, cb_depth + 1);
2137 if (more_data && x1 < s->sps->width) {
2138 more_data = hls_coding_quadtree(s, x1, y0, log2_cb_size - 1, cb_depth + 1);
2142 if (more_data && y1 < s->sps->height) {
2143 more_data = hls_coding_quadtree(s, x0, y1, log2_cb_size - 1, cb_depth + 1);
2147 if (more_data && x1 < s->sps->width &&
2148 y1 < s->sps->height) {
2149 more_data = hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1);
2154 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2155 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2156 lc->qPy_pred = lc->qp_y;
2159 return ((x1 + cb_size_split) < s->sps->width ||
2160 (y1 + cb_size_split) < s->sps->height);
2164 ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2167 if ((!((x0 + cb_size) %
2168 (1 << (s->sps->log2_ctb_size))) ||
2169 (x0 + cb_size >= s->sps->width)) &&
2171 (1 << (s->sps->log2_ctb_size))) ||
2172 (y0 + cb_size >= s->sps->height))) {
2173 int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s);
2174 return !end_of_slice_flag;
2183 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2186 HEVCLocalContext *lc = s->HEVClc;
2187 int ctb_size = 1 << s->sps->log2_ctb_size;
2188 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2189 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2191 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2193 if (s->pps->entropy_coding_sync_enabled_flag) {
2194 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2195 lc->first_qp_group = 1;
2196 lc->end_of_tiles_x = s->sps->width;
2197 } else if (s->pps->tiles_enabled_flag) {
2198 if (ctb_addr_ts && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1]) {
2199 int idxX = s->pps->col_idxX[x_ctb >> s->sps->log2_ctb_size];
2200 lc->end_of_tiles_x = x_ctb + (s->pps->column_width[idxX] << s->sps->log2_ctb_size);
2201 lc->first_qp_group = 1;
2204 lc->end_of_tiles_x = s->sps->width;
2207 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->sps->height);
2209 lc->boundary_flags = 0;
2210 if (s->pps->tiles_enabled_flag) {
2211 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]])
2212 lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2213 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2214 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2215 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]])
2216 lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2217 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->sps->ctb_width])
2218 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2220 if (!ctb_addr_in_slice > 0)
2221 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2222 if (ctb_addr_in_slice < s->sps->ctb_width)
2223 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2226 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2227 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2228 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]]));
2229 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]]));
2232 static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
2234 HEVCContext *s = avctxt->priv_data;
2235 int ctb_size = 1 << s->sps->log2_ctb_size;
2239 int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2241 if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) {
2242 av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n");
2243 return AVERROR_INVALIDDATA;
2246 if (s->sh.dependent_slice_segment_flag) {
2247 int prev_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2248 if (s->tab_slice_address[prev_rs] != s->sh.slice_addr) {
2249 av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n");
2250 return AVERROR_INVALIDDATA;
2254 while (more_data && ctb_addr_ts < s->sps->ctb_size) {
2255 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2257 x_ctb = (ctb_addr_rs % ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2258 y_ctb = (ctb_addr_rs / ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2259 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2261 ff_hevc_cabac_init(s, ctb_addr_ts);
2263 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2265 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2266 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2267 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2269 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2270 if (more_data < 0) {
2271 s->tab_slice_address[ctb_addr_rs] = -1;
2277 ff_hevc_save_states(s, ctb_addr_ts);
2278 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2281 if (x_ctb + ctb_size >= s->sps->width &&
2282 y_ctb + ctb_size >= s->sps->height)
2283 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2288 static int hls_slice_data(HEVCContext *s)
2296 s->avctx->execute(s->avctx, hls_decode_entry, arg, ret , 1, sizeof(int));
2299 static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int job, int self_id)
2301 HEVCContext *s1 = avctxt->priv_data, *s;
2302 HEVCLocalContext *lc;
2303 int ctb_size = 1<< s1->sps->log2_ctb_size;
2305 int *ctb_row_p = input_ctb_row;
2306 int ctb_row = ctb_row_p[job];
2307 int ctb_addr_rs = s1->sh.slice_ctb_addr_rs + ctb_row * ((s1->sps->width + ctb_size - 1) >> s1->sps->log2_ctb_size);
2308 int ctb_addr_ts = s1->pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2309 int thread = ctb_row % s1->threads_number;
2312 s = s1->sList[self_id];
2316 ret = init_get_bits8(&lc->gb, s->data + s->sh.offset[ctb_row - 1], s->sh.size[ctb_row - 1]);
2320 ff_init_cabac_decoder(&lc->cc, s->data + s->sh.offset[(ctb_row)-1], s->sh.size[ctb_row - 1]);
2323 while(more_data && ctb_addr_ts < s->sps->ctb_size) {
2324 int x_ctb = (ctb_addr_rs % s->sps->ctb_width) << s->sps->log2_ctb_size;
2325 int y_ctb = (ctb_addr_rs / s->sps->ctb_width) << s->sps->log2_ctb_size;
2327 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2329 ff_thread_await_progress2(s->avctx, ctb_row, thread, SHIFT_CTB_WPP);
2331 if (avpriv_atomic_int_get(&s1->wpp_err)){
2332 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2336 ff_hevc_cabac_init(s, ctb_addr_ts);
2337 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2338 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2340 if (more_data < 0) {
2341 s->tab_slice_address[ctb_addr_rs] = -1;
2347 ff_hevc_save_states(s, ctb_addr_ts);
2348 ff_thread_report_progress2(s->avctx, ctb_row, thread, 1);
2349 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2351 if (!more_data && (x_ctb+ctb_size) < s->sps->width && ctb_row != s->sh.num_entry_point_offsets) {
2352 avpriv_atomic_int_set(&s1->wpp_err, 1);
2353 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2357 if ((x_ctb+ctb_size) >= s->sps->width && (y_ctb+ctb_size) >= s->sps->height ) {
2358 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2359 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2362 ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2365 if(x_ctb >= s->sps->width) {
2369 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2374 static int hls_slice_data_wpp(HEVCContext *s, const uint8_t *nal, int length)
2376 HEVCLocalContext *lc = s->HEVClc;
2377 int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2378 int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2380 int startheader, cmpt = 0;
2385 ff_alloc_entries(s->avctx, s->sh.num_entry_point_offsets + 1);
2388 for (i = 1; i < s->threads_number; i++) {
2389 s->sList[i] = av_malloc(sizeof(HEVCContext));
2390 memcpy(s->sList[i], s, sizeof(HEVCContext));
2391 s->HEVClcList[i] = av_mallocz(sizeof(HEVCLocalContext));
2392 s->sList[i]->HEVClc = s->HEVClcList[i];
2396 offset = (lc->gb.index >> 3);
2398 for (j = 0, cmpt = 0, startheader = offset + s->sh.entry_point_offset[0]; j < s->skipped_bytes; j++) {
2399 if (s->skipped_bytes_pos[j] >= offset && s->skipped_bytes_pos[j] < startheader) {
2405 for (i = 1; i < s->sh.num_entry_point_offsets; i++) {
2406 offset += (s->sh.entry_point_offset[i - 1] - cmpt);
2407 for (j = 0, cmpt = 0, startheader = offset
2408 + s->sh.entry_point_offset[i]; j < s->skipped_bytes; j++) {
2409 if (s->skipped_bytes_pos[j] >= offset && s->skipped_bytes_pos[j] < startheader) {
2414 s->sh.size[i - 1] = s->sh.entry_point_offset[i] - cmpt;
2415 s->sh.offset[i - 1] = offset;
2418 if (s->sh.num_entry_point_offsets != 0) {
2419 offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt;
2420 s->sh.size[s->sh.num_entry_point_offsets - 1] = length - offset;
2421 s->sh.offset[s->sh.num_entry_point_offsets - 1] = offset;
2426 for (i = 1; i < s->threads_number; i++) {
2427 s->sList[i]->HEVClc->first_qp_group = 1;
2428 s->sList[i]->HEVClc->qp_y = s->sList[0]->HEVClc->qp_y;
2429 memcpy(s->sList[i], s, sizeof(HEVCContext));
2430 s->sList[i]->HEVClc = s->HEVClcList[i];
2433 avpriv_atomic_int_set(&s->wpp_err, 0);
2434 ff_reset_entries(s->avctx);
2436 for (i = 0; i <= s->sh.num_entry_point_offsets; i++) {
2441 if (s->pps->entropy_coding_sync_enabled_flag)
2442 s->avctx->execute2(s->avctx, (void *) hls_decode_entry_wpp, arg, ret, s->sh.num_entry_point_offsets + 1);
2444 for (i = 0; i <= s->sh.num_entry_point_offsets; i++)
2452 * @return AVERROR_INVALIDDATA if the packet is not a valid NAL unit,
2453 * 0 if the unit should be skipped, 1 otherwise
2455 static int hls_nal_unit(HEVCContext *s)
2457 GetBitContext *gb = &s->HEVClc->gb;
2460 if (get_bits1(gb) != 0)
2461 return AVERROR_INVALIDDATA;
2463 s->nal_unit_type = get_bits(gb, 6);
2465 nuh_layer_id = get_bits(gb, 6);
2466 s->temporal_id = get_bits(gb, 3) - 1;
2467 if (s->temporal_id < 0)
2468 return AVERROR_INVALIDDATA;
2470 av_log(s->avctx, AV_LOG_DEBUG,
2471 "nal_unit_type: %d, nuh_layer_id: %d, temporal_id: %d\n",
2472 s->nal_unit_type, nuh_layer_id, s->temporal_id);
2474 return nuh_layer_id == 0;
2477 static int set_side_data(HEVCContext *s)
2479 AVFrame *out = s->ref->frame;
2481 if (s->sei_frame_packing_present &&
2482 s->frame_packing_arrangement_type >= 3 &&
2483 s->frame_packing_arrangement_type <= 5 &&
2484 s->content_interpretation_type > 0 &&
2485 s->content_interpretation_type < 3) {
2486 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2488 return AVERROR(ENOMEM);
2490 switch (s->frame_packing_arrangement_type) {
2492 if (s->quincunx_subsampling)
2493 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2495 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2498 stereo->type = AV_STEREO3D_TOPBOTTOM;
2501 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2505 if (s->content_interpretation_type == 2)
2506 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2509 if (s->sei_display_orientation_present &&
2510 (s->sei_anticlockwise_rotation || s->sei_hflip || s->sei_vflip)) {
2511 double angle = s->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
2512 AVFrameSideData *rotation = av_frame_new_side_data(out,
2513 AV_FRAME_DATA_DISPLAYMATRIX,
2514 sizeof(int32_t) * 9);
2516 return AVERROR(ENOMEM);
2518 av_display_rotation_set((int32_t *)rotation->data, angle);
2519 av_display_matrix_flip((int32_t *)rotation->data,
2520 s->sei_hflip, s->sei_vflip);
2526 static int hevc_frame_start(HEVCContext *s)
2528 HEVCLocalContext *lc = s->HEVClc;
2529 int pic_size_in_ctb = ((s->sps->width >> s->sps->log2_min_cb_size) + 1) *
2530 ((s->sps->height >> s->sps->log2_min_cb_size) + 1);
2533 memset(s->horizontal_bs, 0, s->bs_width * s->bs_height);
2534 memset(s->vertical_bs, 0, s->bs_width * s->bs_height);
2535 memset(s->cbf_luma, 0, s->sps->min_tb_width * s->sps->min_tb_height);
2536 memset(s->is_pcm, 0, (s->sps->min_pu_width + 1) * (s->sps->min_pu_height + 1));
2537 memset(s->tab_slice_address, -1, pic_size_in_ctb * sizeof(*s->tab_slice_address));
2540 s->first_nal_type = s->nal_unit_type;
2542 if (s->pps->tiles_enabled_flag)
2543 lc->end_of_tiles_x = s->pps->column_width[0] << s->sps->log2_ctb_size;
2545 ret = ff_hevc_set_new_ref(s, &s->frame, s->poc);
2549 ret = ff_hevc_frame_rps(s);
2551 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2555 s->ref->frame->key_frame = IS_IRAP(s);
2557 ret = set_side_data(s);
2561 s->frame->pict_type = 3 - s->sh.slice_type;
2564 ff_hevc_bump_frame(s);
2566 av_frame_unref(s->output_frame);
2567 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2571 ff_thread_finish_setup(s->avctx);
2576 if (s->ref && s->threads_type == FF_THREAD_FRAME)
2577 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2582 static int decode_nal_unit(HEVCContext *s, const uint8_t *nal, int length)
2584 HEVCLocalContext *lc = s->HEVClc;
2585 GetBitContext *gb = &lc->gb;
2586 int ctb_addr_ts, ret;
2588 ret = init_get_bits8(gb, nal, length);
2592 ret = hls_nal_unit(s);
2594 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit %d, skipping.\n",
2600 switch (s->nal_unit_type) {
2602 ret = ff_hevc_decode_nal_vps(s);
2607 ret = ff_hevc_decode_nal_sps(s);
2612 ret = ff_hevc_decode_nal_pps(s);
2616 case NAL_SEI_PREFIX:
2617 case NAL_SEI_SUFFIX:
2618 ret = ff_hevc_decode_nal_sei(s);
2629 case NAL_BLA_W_RADL:
2631 case NAL_IDR_W_RADL:
2638 ret = hls_slice_header(s);
2642 if (s->max_ra == INT_MAX) {
2643 if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
2647 s->max_ra = INT_MIN;
2651 if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
2652 s->poc <= s->max_ra) {
2656 if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
2657 s->max_ra = INT_MIN;
2660 if (s->sh.first_slice_in_pic_flag) {
2661 ret = hevc_frame_start(s);
2664 } else if (!s->ref) {
2665 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2669 if (s->nal_unit_type != s->first_nal_type) {
2670 av_log(s->avctx, AV_LOG_ERROR,
2671 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2672 s->first_nal_type, s->nal_unit_type);
2673 return AVERROR_INVALIDDATA;
2676 if (!s->sh.dependent_slice_segment_flag &&
2677 s->sh.slice_type != I_SLICE) {
2678 ret = ff_hevc_slice_rpl(s);
2680 av_log(s->avctx, AV_LOG_WARNING,
2681 "Error constructing the reference lists for the current slice.\n");
2686 if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
2687 ctb_addr_ts = hls_slice_data_wpp(s, nal, length);
2689 ctb_addr_ts = hls_slice_data(s);
2690 if (ctb_addr_ts >= (s->sps->ctb_width * s->sps->ctb_height)) {
2694 if (ctb_addr_ts < 0) {
2701 s->seq_decode = (s->seq_decode + 1) & 0xff;
2702 s->max_ra = INT_MAX;
2708 av_log(s->avctx, AV_LOG_INFO,
2709 "Skipping NAL unit %d\n", s->nal_unit_type);
2714 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2719 /* FIXME: This is adapted from ff_h264_decode_nal, avoiding duplication
2720 * between these functions would be nice. */
2721 int ff_hevc_extract_rbsp(HEVCContext *s, const uint8_t *src, int length,
2727 s->skipped_bytes = 0;
2728 #define STARTCODE_TEST \
2729 if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \
2730 if (src[i + 2] != 3) { \
2731 /* startcode, so we must be past the end */ \
2736 #if HAVE_FAST_UNALIGNED
2737 #define FIND_FIRST_ZERO \
2738 if (i > 0 && !src[i]) \
2743 for (i = 0; i + 1 < length; i += 9) {
2744 if (!((~AV_RN64A(src + i) &
2745 (AV_RN64A(src + i) - 0x0100010001000101ULL)) &
2746 0x8000800080008080ULL))
2753 for (i = 0; i + 1 < length; i += 5) {
2754 if (!((~AV_RN32A(src + i) &
2755 (AV_RN32A(src + i) - 0x01000101U)) &
2762 #endif /* HAVE_FAST_64BIT */
2764 for (i = 0; i + 1 < length; i += 2) {
2767 if (i > 0 && src[i - 1] == 0)
2771 #endif /* HAVE_FAST_UNALIGNED */
2773 if (i >= length - 1) { // no escaped 0
2779 av_fast_malloc(&nal->rbsp_buffer, &nal->rbsp_buffer_size,
2780 length + FF_INPUT_BUFFER_PADDING_SIZE);
2781 if (!nal->rbsp_buffer)
2782 return AVERROR(ENOMEM);
2784 dst = nal->rbsp_buffer;
2786 memcpy(dst, src, i);
2788 while (si + 2 < length) {
2789 // remove escapes (very rare 1:2^22)
2790 if (src[si + 2] > 3) {
2791 dst[di++] = src[si++];
2792 dst[di++] = src[si++];
2793 } else if (src[si] == 0 && src[si + 1] == 0) {
2794 if (src[si + 2] == 3) { // escape
2800 if (s->skipped_bytes_pos_size < s->skipped_bytes) {
2801 s->skipped_bytes_pos_size *= 2;
2802 av_reallocp_array(&s->skipped_bytes_pos,
2803 s->skipped_bytes_pos_size,
2804 sizeof(*s->skipped_bytes_pos));
2805 if (!s->skipped_bytes_pos)
2806 return AVERROR(ENOMEM);
2808 if (s->skipped_bytes_pos)
2809 s->skipped_bytes_pos[s->skipped_bytes-1] = di - 1;
2811 } else // next start code
2815 dst[di++] = src[si++];
2818 dst[di++] = src[si++];
2821 memset(dst + di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2828 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2830 int i, consumed, ret = 0;
2833 s->last_eos = s->eos;
2836 /* split the input packet into NAL units, so we know the upper bound on the
2837 * number of slices in the frame */
2839 while (length >= 4) {
2841 int extract_length = 0;
2845 for (i = 0; i < s->nal_length_size; i++)
2846 extract_length = (extract_length << 8) | buf[i];
2847 buf += s->nal_length_size;
2848 length -= s->nal_length_size;
2850 if (extract_length > length) {
2851 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit size.\n");
2852 ret = AVERROR_INVALIDDATA;
2856 /* search start code */
2857 while (buf[0] != 0 || buf[1] != 0 || buf[2] != 1) {
2861 av_log(s->avctx, AV_LOG_ERROR, "No start code is found.\n");
2862 ret = AVERROR_INVALIDDATA;
2872 extract_length = length;
2874 if (s->nals_allocated < s->nb_nals + 1) {
2875 int new_size = s->nals_allocated + 1;
2876 HEVCNAL *tmp = av_realloc_array(s->nals, new_size, sizeof(*tmp));
2878 ret = AVERROR(ENOMEM);
2882 memset(s->nals + s->nals_allocated, 0,
2883 (new_size - s->nals_allocated) * sizeof(*tmp));
2884 av_reallocp_array(&s->skipped_bytes_nal, new_size, sizeof(*s->skipped_bytes_nal));
2885 av_reallocp_array(&s->skipped_bytes_pos_size_nal, new_size, sizeof(*s->skipped_bytes_pos_size_nal));
2886 av_reallocp_array(&s->skipped_bytes_pos_nal, new_size, sizeof(*s->skipped_bytes_pos_nal));
2887 s->skipped_bytes_pos_size_nal[s->nals_allocated] = 1024; // initial buffer size
2888 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));
2889 s->nals_allocated = new_size;
2891 s->skipped_bytes_pos_size = s->skipped_bytes_pos_size_nal[s->nb_nals];
2892 s->skipped_bytes_pos = s->skipped_bytes_pos_nal[s->nb_nals];
2893 nal = &s->nals[s->nb_nals];
2895 consumed = ff_hevc_extract_rbsp(s, buf, extract_length, nal);
2897 s->skipped_bytes_nal[s->nb_nals] = s->skipped_bytes;
2898 s->skipped_bytes_pos_size_nal[s->nb_nals] = s->skipped_bytes_pos_size;
2899 s->skipped_bytes_pos_nal[s->nb_nals++] = s->skipped_bytes_pos;
2907 ret = init_get_bits8(&s->HEVClc->gb, nal->data, nal->size);
2912 if (s->nal_unit_type == NAL_EOB_NUT ||
2913 s->nal_unit_type == NAL_EOS_NUT)
2920 /* parse the NAL units */
2921 for (i = 0; i < s->nb_nals; i++) {
2923 s->skipped_bytes = s->skipped_bytes_nal[i];
2924 s->skipped_bytes_pos = s->skipped_bytes_pos_nal[i];
2926 ret = decode_nal_unit(s, s->nals[i].data, s->nals[i].size);
2928 av_log(s->avctx, AV_LOG_WARNING,
2929 "Error parsing NAL unit #%d.\n", i);
2935 if (s->ref && s->threads_type == FF_THREAD_FRAME)
2936 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2941 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2944 for (i = 0; i < 16; i++)
2945 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
2948 static int verify_md5(HEVCContext *s, AVFrame *frame)
2950 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
2955 return AVERROR(EINVAL);
2957 pixel_shift = desc->comp[0].depth_minus1 > 7;
2959 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
2962 /* the checksums are LE, so we have to byteswap for >8bpp formats
2965 if (pixel_shift && !s->checksum_buf) {
2966 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
2967 FFMAX3(frame->linesize[0], frame->linesize[1],
2968 frame->linesize[2]));
2969 if (!s->checksum_buf)
2970 return AVERROR(ENOMEM);
2974 for (i = 0; frame->data[i]; i++) {
2975 int width = s->avctx->coded_width;
2976 int height = s->avctx->coded_height;
2977 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
2978 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
2981 av_md5_init(s->md5_ctx);
2982 for (j = 0; j < h; j++) {
2983 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
2986 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
2987 (const uint16_t *) src, w);
2988 src = s->checksum_buf;
2991 av_md5_update(s->md5_ctx, src, w << pixel_shift);
2993 av_md5_final(s->md5_ctx, md5);
2995 if (!memcmp(md5, s->md5[i], 16)) {
2996 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
2997 print_md5(s->avctx, AV_LOG_DEBUG, md5);
2998 av_log (s->avctx, AV_LOG_DEBUG, "; ");
3000 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
3001 print_md5(s->avctx, AV_LOG_ERROR, md5);
3002 av_log (s->avctx, AV_LOG_ERROR, " != ");
3003 print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
3004 av_log (s->avctx, AV_LOG_ERROR, "\n");
3005 return AVERROR_INVALIDDATA;
3009 av_log(s->avctx, AV_LOG_DEBUG, "\n");
3014 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
3018 HEVCContext *s = avctx->priv_data;
3021 ret = ff_hevc_output_frame(s, data, 1);
3030 ret = decode_nal_units(s, avpkt->data, avpkt->size);
3034 /* verify the SEI checksum */
3035 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
3037 ret = verify_md5(s, s->ref->frame);
3038 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
3039 ff_hevc_unref_frame(s, s->ref, ~0);
3045 if (s->is_decoded) {
3046 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
3050 if (s->output_frame->buf[0]) {
3051 av_frame_move_ref(data, s->output_frame);
3058 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
3062 ret = ff_thread_ref_frame(&dst->tf, &src->tf);
3066 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
3067 if (!dst->tab_mvf_buf)
3069 dst->tab_mvf = src->tab_mvf;
3071 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
3072 if (!dst->rpl_tab_buf)
3074 dst->rpl_tab = src->rpl_tab;
3076 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
3080 dst->poc = src->poc;
3081 dst->ctb_count = src->ctb_count;
3082 dst->window = src->window;
3083 dst->flags = src->flags;
3084 dst->sequence = src->sequence;
3088 ff_hevc_unref_frame(s, dst, ~0);
3089 return AVERROR(ENOMEM);
3092 static av_cold int hevc_decode_free(AVCodecContext *avctx)
3094 HEVCContext *s = avctx->priv_data;
3099 av_freep(&s->md5_ctx);
3101 for(i=0; i < s->nals_allocated; i++) {
3102 av_freep(&s->skipped_bytes_pos_nal[i]);
3104 av_freep(&s->skipped_bytes_pos_size_nal);
3105 av_freep(&s->skipped_bytes_nal);
3106 av_freep(&s->skipped_bytes_pos_nal);
3108 av_freep(&s->cabac_state);
3110 av_frame_free(&s->tmp_frame);
3111 av_frame_free(&s->output_frame);
3113 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3114 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3115 av_frame_free(&s->DPB[i].frame);
3118 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++)
3119 av_buffer_unref(&s->vps_list[i]);
3120 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++)
3121 av_buffer_unref(&s->sps_list[i]);
3122 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
3123 av_buffer_unref(&s->pps_list[i]);
3128 av_buffer_unref(&s->current_sps);
3130 av_freep(&s->sh.entry_point_offset);
3131 av_freep(&s->sh.offset);
3132 av_freep(&s->sh.size);
3134 for (i = 1; i < s->threads_number; i++) {
3135 HEVCLocalContext *lc = s->HEVClcList[i];
3137 av_freep(&s->HEVClcList[i]);
3138 av_freep(&s->sList[i]);
3141 if (s->HEVClc == s->HEVClcList[0])
3143 av_freep(&s->HEVClcList[0]);
3145 for (i = 0; i < s->nals_allocated; i++)
3146 av_freep(&s->nals[i].rbsp_buffer);
3148 s->nals_allocated = 0;
3153 static av_cold int hevc_init_context(AVCodecContext *avctx)
3155 HEVCContext *s = avctx->priv_data;
3160 s->HEVClc = av_mallocz(sizeof(HEVCLocalContext));
3163 s->HEVClcList[0] = s->HEVClc;
3166 s->cabac_state = av_malloc(HEVC_CONTEXTS);
3167 if (!s->cabac_state)
3170 s->tmp_frame = av_frame_alloc();
3174 s->output_frame = av_frame_alloc();
3175 if (!s->output_frame)
3178 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3179 s->DPB[i].frame = av_frame_alloc();
3180 if (!s->DPB[i].frame)
3182 s->DPB[i].tf.f = s->DPB[i].frame;
3185 s->max_ra = INT_MAX;
3187 s->md5_ctx = av_md5_alloc();
3191 ff_bswapdsp_init(&s->bdsp);
3193 s->context_initialized = 1;
3199 hevc_decode_free(avctx);
3200 return AVERROR(ENOMEM);
3203 static int hevc_update_thread_context(AVCodecContext *dst,
3204 const AVCodecContext *src)
3206 HEVCContext *s = dst->priv_data;
3207 HEVCContext *s0 = src->priv_data;
3210 if (!s->context_initialized) {
3211 ret = hevc_init_context(dst);
3216 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3217 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3218 if (s0->DPB[i].frame->buf[0]) {
3219 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3225 if (s->sps != s0->sps)
3227 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++) {
3228 av_buffer_unref(&s->vps_list[i]);
3229 if (s0->vps_list[i]) {
3230 s->vps_list[i] = av_buffer_ref(s0->vps_list[i]);
3231 if (!s->vps_list[i])
3232 return AVERROR(ENOMEM);
3236 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++) {
3237 av_buffer_unref(&s->sps_list[i]);
3238 if (s0->sps_list[i]) {
3239 s->sps_list[i] = av_buffer_ref(s0->sps_list[i]);
3240 if (!s->sps_list[i])
3241 return AVERROR(ENOMEM);
3245 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++) {
3246 av_buffer_unref(&s->pps_list[i]);
3247 if (s0->pps_list[i]) {
3248 s->pps_list[i] = av_buffer_ref(s0->pps_list[i]);
3249 if (!s->pps_list[i])
3250 return AVERROR(ENOMEM);
3254 av_buffer_unref(&s->current_sps);
3255 if (s0->current_sps) {
3256 s->current_sps = av_buffer_ref(s0->current_sps);
3257 if (!s->current_sps)
3258 return AVERROR(ENOMEM);
3261 if (s->sps != s0->sps)
3262 if ((ret = set_sps(s, s0->sps)) < 0)
3265 s->seq_decode = s0->seq_decode;
3266 s->seq_output = s0->seq_output;
3267 s->pocTid0 = s0->pocTid0;
3268 s->max_ra = s0->max_ra;
3271 s->is_nalff = s0->is_nalff;
3272 s->nal_length_size = s0->nal_length_size;
3274 s->threads_number = s0->threads_number;
3275 s->threads_type = s0->threads_type;
3278 s->seq_decode = (s->seq_decode + 1) & 0xff;
3279 s->max_ra = INT_MAX;
3285 static int hevc_decode_extradata(HEVCContext *s)
3287 AVCodecContext *avctx = s->avctx;
3291 bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
3293 if (avctx->extradata_size > 3 &&
3294 (avctx->extradata[0] || avctx->extradata[1] ||
3295 avctx->extradata[2] > 1)) {
3296 /* It seems the extradata is encoded as hvcC format.
3297 * Temporarily, we support configurationVersion==0 until 14496-15 3rd
3298 * is finalized. When finalized, configurationVersion will be 1 and we
3299 * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
3300 int i, j, num_arrays, nal_len_size;
3304 bytestream2_skip(&gb, 21);
3305 nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
3306 num_arrays = bytestream2_get_byte(&gb);
3308 /* nal units in the hvcC always have length coded with 2 bytes,
3309 * so put a fake nal_length_size = 2 while parsing them */
3310 s->nal_length_size = 2;
3312 /* Decode nal units from hvcC. */
3313 for (i = 0; i < num_arrays; i++) {
3314 int type = bytestream2_get_byte(&gb) & 0x3f;
3315 int cnt = bytestream2_get_be16(&gb);
3317 for (j = 0; j < cnt; j++) {
3318 // +2 for the nal size field
3319 int nalsize = bytestream2_peek_be16(&gb) + 2;
3320 if (bytestream2_get_bytes_left(&gb) < nalsize) {
3321 av_log(s->avctx, AV_LOG_ERROR,
3322 "Invalid NAL unit size in extradata.\n");
3323 return AVERROR_INVALIDDATA;
3326 ret = decode_nal_units(s, gb.buffer, nalsize);
3328 av_log(avctx, AV_LOG_ERROR,
3329 "Decoding nal unit %d %d from hvcC failed\n",
3333 bytestream2_skip(&gb, nalsize);
3337 /* Now store right nal length size, that will be used to parse
3339 s->nal_length_size = nal_len_size;
3342 ret = decode_nal_units(s, avctx->extradata, avctx->extradata_size);
3349 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3351 HEVCContext *s = avctx->priv_data;
3354 ff_init_cabac_states();
3356 avctx->internal->allocate_progress = 1;
3358 ret = hevc_init_context(avctx);
3362 s->enable_parallel_tiles = 0;
3363 s->picture_struct = 0;
3365 if(avctx->active_thread_type & FF_THREAD_SLICE)
3366 s->threads_number = avctx->thread_count;
3368 s->threads_number = 1;
3370 if (avctx->extradata_size > 0 && avctx->extradata) {
3371 ret = hevc_decode_extradata(s);
3373 hevc_decode_free(avctx);
3378 if((avctx->active_thread_type & FF_THREAD_FRAME) && avctx->thread_count > 1)
3379 s->threads_type = FF_THREAD_FRAME;
3381 s->threads_type = FF_THREAD_SLICE;
3386 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3388 HEVCContext *s = avctx->priv_data;
3391 memset(s, 0, sizeof(*s));
3393 ret = hevc_init_context(avctx);
3400 static void hevc_decode_flush(AVCodecContext *avctx)
3402 HEVCContext *s = avctx->priv_data;
3403 ff_hevc_flush_dpb(s);
3404 s->max_ra = INT_MAX;
3407 #define OFFSET(x) offsetof(HEVCContext, x)
3408 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3410 static const AVProfile profiles[] = {
3411 { FF_PROFILE_HEVC_MAIN, "Main" },
3412 { FF_PROFILE_HEVC_MAIN_10, "Main 10" },
3413 { FF_PROFILE_HEVC_MAIN_STILL_PICTURE, "Main Still Picture" },
3414 { FF_PROFILE_HEVC_REXT, "Rext" },
3415 { FF_PROFILE_UNKNOWN },
3418 static const AVOption options[] = {
3419 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3420 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3421 { "strict-displaywin", "stricly apply default display window size", OFFSET(apply_defdispwin),
3422 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3426 static const AVClass hevc_decoder_class = {
3427 .class_name = "HEVC decoder",
3428 .item_name = av_default_item_name,
3430 .version = LIBAVUTIL_VERSION_INT,
3433 AVCodec ff_hevc_decoder = {
3435 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3436 .type = AVMEDIA_TYPE_VIDEO,
3437 .id = AV_CODEC_ID_HEVC,
3438 .priv_data_size = sizeof(HEVCContext),
3439 .priv_class = &hevc_decoder_class,
3440 .init = hevc_decode_init,
3441 .close = hevc_decode_free,
3442 .decode = hevc_decode_frame,
3443 .flush = hevc_decode_flush,
3444 .update_thread_context = hevc_update_thread_context,
3445 .init_thread_copy = hevc_init_thread_copy,
3446 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY |
3447 CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS,
3448 .profiles = NULL_IF_CONFIG_SMALL(profiles),