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 hevc_luma_mv_mpv_mode(HEVCContext *s, int x0, int y0, int nPbW,
1580 int nPbH, int log2_cb_size, int part_idx,
1581 int merge_idx, MvField *mv)
1583 HEVCLocalContext *lc = s->HEVClc;
1584 enum InterPredIdc inter_pred_idc = PRED_L0;
1587 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1589 if (s->sh.slice_type == B_SLICE)
1590 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1592 if (inter_pred_idc != PRED_L1) {
1593 if (s->sh.nb_refs[L0])
1594 mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1596 mv->pred_flag = PF_L0;
1597 ff_hevc_hls_mvd_coding(s, x0, y0, 0);
1598 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1599 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1600 part_idx, merge_idx, mv, mvp_flag, 0);
1601 mv->mv[0].x += lc->pu.mvd.x;
1602 mv->mv[0].y += lc->pu.mvd.y;
1605 if (inter_pred_idc != PRED_L0) {
1606 if (s->sh.nb_refs[L1])
1607 mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1609 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1610 AV_ZERO32(&lc->pu.mvd);
1612 ff_hevc_hls_mvd_coding(s, x0, y0, 1);
1615 mv->pred_flag += PF_L1;
1616 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1617 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1618 part_idx, merge_idx, mv, mvp_flag, 1);
1619 mv->mv[1].x += lc->pu.mvd.x;
1620 mv->mv[1].y += lc->pu.mvd.y;
1624 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1626 int log2_cb_size, int partIdx, int idx)
1628 #define POS(c_idx, x, y) \
1629 &s->frame->data[c_idx][((y) >> s->sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1630 (((x) >> s->sps->hshift[c_idx]) << s->sps->pixel_shift)]
1631 HEVCLocalContext *lc = s->HEVClc;
1633 struct MvField current_mv = {{{ 0 }}};
1635 int min_pu_width = s->sps->min_pu_width;
1637 MvField *tab_mvf = s->ref->tab_mvf;
1638 RefPicList *refPicList = s->ref->refPicList;
1639 HEVCFrame *ref0, *ref1;
1640 uint8_t *dst0 = POS(0, x0, y0);
1641 uint8_t *dst1 = POS(1, x0, y0);
1642 uint8_t *dst2 = POS(2, x0, y0);
1643 int log2_min_cb_size = s->sps->log2_min_cb_size;
1644 int min_cb_width = s->sps->min_cb_width;
1645 int x_cb = x0 >> log2_min_cb_size;
1646 int y_cb = y0 >> log2_min_cb_size;
1650 int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1653 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1655 if (skip_flag || lc->pu.merge_flag) {
1656 if (s->sh.max_num_merge_cand > 1)
1657 merge_idx = ff_hevc_merge_idx_decode(s);
1661 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1662 partIdx, merge_idx, ¤t_mv);
1664 hevc_luma_mv_mpv_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1665 partIdx, merge_idx, ¤t_mv);
1668 x_pu = x0 >> s->sps->log2_min_pu_size;
1669 y_pu = y0 >> s->sps->log2_min_pu_size;
1671 for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1672 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1673 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1675 if (current_mv.pred_flag & PF_L0) {
1676 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1679 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1681 if (current_mv.pred_flag & PF_L1) {
1682 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1685 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1688 if (current_mv.pred_flag == PF_L0) {
1689 int x0_c = x0 >> s->sps->hshift[1];
1690 int y0_c = y0 >> s->sps->vshift[1];
1691 int nPbW_c = nPbW >> s->sps->hshift[1];
1692 int nPbH_c = nPbH >> s->sps->vshift[1];
1694 luma_mc_uni(s, dst0, s->frame->linesize[0], ref0->frame,
1695 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1696 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1697 s->sh.luma_offset_l0[current_mv.ref_idx[0]]);
1699 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref0->frame->data[1], ref0->frame->linesize[1],
1700 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1701 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]);
1702 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref0->frame->data[2], ref0->frame->linesize[2],
1703 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1704 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]);
1705 } else if (current_mv.pred_flag == PF_L1) {
1706 int x0_c = x0 >> s->sps->hshift[1];
1707 int y0_c = y0 >> s->sps->vshift[1];
1708 int nPbW_c = nPbW >> s->sps->hshift[1];
1709 int nPbH_c = nPbH >> s->sps->vshift[1];
1711 luma_mc_uni(s, dst0, s->frame->linesize[0], ref1->frame,
1712 ¤t_mv.mv[1], x0, y0, nPbW, nPbH,
1713 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1714 s->sh.luma_offset_l1[current_mv.ref_idx[1]]);
1716 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
1717 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1718 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]);
1720 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
1721 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1722 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]);
1723 } else if (current_mv.pred_flag == PF_BI) {
1724 int x0_c = x0 >> s->sps->hshift[1];
1725 int y0_c = y0 >> s->sps->vshift[1];
1726 int nPbW_c = nPbW >> s->sps->hshift[1];
1727 int nPbH_c = nPbH >> s->sps->vshift[1];
1729 luma_mc_bi(s, dst0, s->frame->linesize[0], ref0->frame,
1730 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1731 ref1->frame, ¤t_mv.mv[1], ¤t_mv);
1733 chroma_mc_bi(s, dst1, s->frame->linesize[1], ref0->frame, ref1->frame,
1734 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 0);
1736 chroma_mc_bi(s, dst2, s->frame->linesize[2], ref0->frame, ref1->frame,
1737 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1);
1744 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1745 int prev_intra_luma_pred_flag)
1747 HEVCLocalContext *lc = s->HEVClc;
1748 int x_pu = x0 >> s->sps->log2_min_pu_size;
1749 int y_pu = y0 >> s->sps->log2_min_pu_size;
1750 int min_pu_width = s->sps->min_pu_width;
1751 int size_in_pus = pu_size >> s->sps->log2_min_pu_size;
1752 int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1);
1753 int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1);
1755 int cand_up = (lc->ctb_up_flag || y0b) ?
1756 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1757 int cand_left = (lc->ctb_left_flag || x0b) ?
1758 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1760 int y_ctb = (y0 >> (s->sps->log2_ctb_size)) << (s->sps->log2_ctb_size);
1762 MvField *tab_mvf = s->ref->tab_mvf;
1763 int intra_pred_mode;
1767 // intra_pred_mode prediction does not cross vertical CTB boundaries
1768 if ((y0 - 1) < y_ctb)
1771 if (cand_left == cand_up) {
1772 if (cand_left < 2) {
1773 candidate[0] = INTRA_PLANAR;
1774 candidate[1] = INTRA_DC;
1775 candidate[2] = INTRA_ANGULAR_26;
1777 candidate[0] = cand_left;
1778 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1779 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1782 candidate[0] = cand_left;
1783 candidate[1] = cand_up;
1784 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1785 candidate[2] = INTRA_PLANAR;
1786 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1787 candidate[2] = INTRA_DC;
1789 candidate[2] = INTRA_ANGULAR_26;
1793 if (prev_intra_luma_pred_flag) {
1794 intra_pred_mode = candidate[lc->pu.mpm_idx];
1796 if (candidate[0] > candidate[1])
1797 FFSWAP(uint8_t, candidate[0], candidate[1]);
1798 if (candidate[0] > candidate[2])
1799 FFSWAP(uint8_t, candidate[0], candidate[2]);
1800 if (candidate[1] > candidate[2])
1801 FFSWAP(uint8_t, candidate[1], candidate[2]);
1803 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1804 for (i = 0; i < 3; i++)
1805 if (intra_pred_mode >= candidate[i])
1809 /* write the intra prediction units into the mv array */
1812 for (i = 0; i < size_in_pus; i++) {
1813 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1814 intra_pred_mode, size_in_pus);
1816 for (j = 0; j < size_in_pus; j++) {
1817 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag = PF_INTRA;
1821 return intra_pred_mode;
1824 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1825 int log2_cb_size, int ct_depth)
1827 int length = (1 << log2_cb_size) >> s->sps->log2_min_cb_size;
1828 int x_cb = x0 >> s->sps->log2_min_cb_size;
1829 int y_cb = y0 >> s->sps->log2_min_cb_size;
1832 for (y = 0; y < length; y++)
1833 memset(&s->tab_ct_depth[(y_cb + y) * s->sps->min_cb_width + x_cb],
1837 static const uint8_t tab_mode_idx[] = {
1838 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
1839 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
1841 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1844 HEVCLocalContext *lc = s->HEVClc;
1845 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1846 uint8_t prev_intra_luma_pred_flag[4];
1847 int split = lc->cu.part_mode == PART_NxN;
1848 int pb_size = (1 << log2_cb_size) >> split;
1849 int side = split + 1;
1853 for (i = 0; i < side; i++)
1854 for (j = 0; j < side; j++)
1855 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1857 for (i = 0; i < side; i++) {
1858 for (j = 0; j < side; j++) {
1859 if (prev_intra_luma_pred_flag[2 * i + j])
1860 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
1862 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
1864 lc->pu.intra_pred_mode[2 * i + j] =
1865 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1866 prev_intra_luma_pred_flag[2 * i + j]);
1870 if (s->sps->chroma_format_idc == 3) {
1871 for (i = 0; i < side; i++) {
1872 for (j = 0; j < side; j++) {
1873 lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1874 if (chroma_mode != 4) {
1875 if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode])
1876 lc->pu.intra_pred_mode_c[2 * i + j] = 34;
1878 lc->pu.intra_pred_mode_c[2 * i + j] = intra_chroma_table[chroma_mode];
1880 lc->pu.intra_pred_mode_c[2 * i + j] = lc->pu.intra_pred_mode[2 * i + j];
1884 } else if (s->sps->chroma_format_idc == 2) {
1886 lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1887 if (chroma_mode != 4) {
1888 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1891 mode_idx = intra_chroma_table[chroma_mode];
1893 mode_idx = lc->pu.intra_pred_mode[0];
1895 lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx];
1896 } else if (s->sps->chroma_format_idc != 0) {
1897 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1898 if (chroma_mode != 4) {
1899 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1900 lc->pu.intra_pred_mode_c[0] = 34;
1902 lc->pu.intra_pred_mode_c[0] = intra_chroma_table[chroma_mode];
1904 lc->pu.intra_pred_mode_c[0] = lc->pu.intra_pred_mode[0];
1909 static void intra_prediction_unit_default_value(HEVCContext *s,
1913 HEVCLocalContext *lc = s->HEVClc;
1914 int pb_size = 1 << log2_cb_size;
1915 int size_in_pus = pb_size >> s->sps->log2_min_pu_size;
1916 int min_pu_width = s->sps->min_pu_width;
1917 MvField *tab_mvf = s->ref->tab_mvf;
1918 int x_pu = x0 >> s->sps->log2_min_pu_size;
1919 int y_pu = y0 >> s->sps->log2_min_pu_size;
1922 if (size_in_pus == 0)
1924 for (j = 0; j < size_in_pus; j++)
1925 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
1926 if (lc->cu.pred_mode == MODE_INTRA)
1927 for (j = 0; j < size_in_pus; j++)
1928 for (k = 0; k < size_in_pus; k++)
1929 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].pred_flag = PF_INTRA;
1932 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
1934 int cb_size = 1 << log2_cb_size;
1935 HEVCLocalContext *lc = s->HEVClc;
1936 int log2_min_cb_size = s->sps->log2_min_cb_size;
1937 int length = cb_size >> log2_min_cb_size;
1938 int min_cb_width = s->sps->min_cb_width;
1939 int x_cb = x0 >> log2_min_cb_size;
1940 int y_cb = y0 >> log2_min_cb_size;
1941 int idx = log2_cb_size - 2;
1942 int qp_block_mask = (1<<(s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth)) - 1;
1947 lc->cu.pred_mode = MODE_INTRA;
1948 lc->cu.part_mode = PART_2Nx2N;
1949 lc->cu.intra_split_flag = 0;
1951 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
1952 for (x = 0; x < 4; x++)
1953 lc->pu.intra_pred_mode[x] = 1;
1954 if (s->pps->transquant_bypass_enable_flag) {
1955 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
1956 if (lc->cu.cu_transquant_bypass_flag)
1957 set_deblocking_bypass(s, x0, y0, log2_cb_size);
1959 lc->cu.cu_transquant_bypass_flag = 0;
1961 if (s->sh.slice_type != I_SLICE) {
1962 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
1964 x = y_cb * min_cb_width + x_cb;
1965 for (y = 0; y < length; y++) {
1966 memset(&s->skip_flag[x], skip_flag, length);
1969 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
1971 x = y_cb * min_cb_width + x_cb;
1972 for (y = 0; y < length; y++) {
1973 memset(&s->skip_flag[x], 0, length);
1978 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
1979 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
1980 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
1982 if (!s->sh.disable_deblocking_filter_flag)
1983 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1987 if (s->sh.slice_type != I_SLICE)
1988 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
1989 if (lc->cu.pred_mode != MODE_INTRA ||
1990 log2_cb_size == s->sps->log2_min_cb_size) {
1991 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
1992 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
1993 lc->cu.pred_mode == MODE_INTRA;
1996 if (lc->cu.pred_mode == MODE_INTRA) {
1997 if (lc->cu.part_mode == PART_2Nx2N && s->sps->pcm_enabled_flag &&
1998 log2_cb_size >= s->sps->pcm.log2_min_pcm_cb_size &&
1999 log2_cb_size <= s->sps->pcm.log2_max_pcm_cb_size) {
2000 pcm_flag = ff_hevc_pcm_flag_decode(s);
2003 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2004 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2005 if (s->sps->pcm.loop_filter_disable_flag)
2006 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2011 intra_prediction_unit(s, x0, y0, log2_cb_size);
2014 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2015 switch (lc->cu.part_mode) {
2017 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2020 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0, idx);
2021 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2024 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2025 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2028 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0, idx);
2029 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2032 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2033 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2036 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0, idx - 2);
2037 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2040 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2041 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2044 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2045 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2046 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2047 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2053 int rqt_root_cbf = 1;
2055 if (lc->cu.pred_mode != MODE_INTRA &&
2056 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2057 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2060 const static int cbf[2] = { 0 };
2061 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2062 s->sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2063 s->sps->max_transform_hierarchy_depth_inter;
2064 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2066 log2_cb_size, 0, 0, cbf, cbf);
2070 if (!s->sh.disable_deblocking_filter_flag)
2071 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2076 if (s->pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2077 ff_hevc_set_qPy(s, x0, y0, log2_cb_size);
2079 x = y_cb * min_cb_width + x_cb;
2080 for (y = 0; y < length; y++) {
2081 memset(&s->qp_y_tab[x], lc->qp_y, length);
2085 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2086 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2087 lc->qPy_pred = lc->qp_y;
2090 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct_depth);
2095 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2096 int log2_cb_size, int cb_depth)
2098 HEVCLocalContext *lc = s->HEVClc;
2099 const int cb_size = 1 << log2_cb_size;
2101 int qp_block_mask = (1<<(s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth)) - 1;
2104 lc->ct_depth = cb_depth;
2105 if (x0 + cb_size <= s->sps->width &&
2106 y0 + cb_size <= s->sps->height &&
2107 log2_cb_size > s->sps->log2_min_cb_size) {
2108 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2110 split_cu = (log2_cb_size > s->sps->log2_min_cb_size);
2112 if (s->pps->cu_qp_delta_enabled_flag &&
2113 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth) {
2114 lc->tu.is_cu_qp_delta_coded = 0;
2115 lc->tu.cu_qp_delta = 0;
2118 if (s->sh.cu_chroma_qp_offset_enabled_flag &&
2119 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_chroma_qp_offset_depth) {
2120 lc->tu.is_cu_chroma_qp_offset_coded = 0;
2124 const int cb_size_split = cb_size >> 1;
2125 const int x1 = x0 + cb_size_split;
2126 const int y1 = y0 + cb_size_split;
2130 more_data = hls_coding_quadtree(s, x0, y0, log2_cb_size - 1, cb_depth + 1);
2134 if (more_data && x1 < s->sps->width) {
2135 more_data = hls_coding_quadtree(s, x1, y0, log2_cb_size - 1, cb_depth + 1);
2139 if (more_data && y1 < s->sps->height) {
2140 more_data = hls_coding_quadtree(s, x0, y1, log2_cb_size - 1, cb_depth + 1);
2144 if (more_data && x1 < s->sps->width &&
2145 y1 < s->sps->height) {
2146 more_data = hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1);
2151 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2152 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2153 lc->qPy_pred = lc->qp_y;
2156 return ((x1 + cb_size_split) < s->sps->width ||
2157 (y1 + cb_size_split) < s->sps->height);
2161 ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2164 if ((!((x0 + cb_size) %
2165 (1 << (s->sps->log2_ctb_size))) ||
2166 (x0 + cb_size >= s->sps->width)) &&
2168 (1 << (s->sps->log2_ctb_size))) ||
2169 (y0 + cb_size >= s->sps->height))) {
2170 int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s);
2171 return !end_of_slice_flag;
2180 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2183 HEVCLocalContext *lc = s->HEVClc;
2184 int ctb_size = 1 << s->sps->log2_ctb_size;
2185 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2186 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2188 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2190 if (s->pps->entropy_coding_sync_enabled_flag) {
2191 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2192 lc->first_qp_group = 1;
2193 lc->end_of_tiles_x = s->sps->width;
2194 } else if (s->pps->tiles_enabled_flag) {
2195 if (ctb_addr_ts && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1]) {
2196 int idxX = s->pps->col_idxX[x_ctb >> s->sps->log2_ctb_size];
2197 lc->end_of_tiles_x = x_ctb + (s->pps->column_width[idxX] << s->sps->log2_ctb_size);
2198 lc->first_qp_group = 1;
2201 lc->end_of_tiles_x = s->sps->width;
2204 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->sps->height);
2206 lc->boundary_flags = 0;
2207 if (s->pps->tiles_enabled_flag) {
2208 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]])
2209 lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2210 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2211 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2212 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]])
2213 lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2214 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->sps->ctb_width])
2215 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2217 if (!ctb_addr_in_slice > 0)
2218 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2219 if (ctb_addr_in_slice < s->sps->ctb_width)
2220 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2223 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2224 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2225 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]]));
2226 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]]));
2229 static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
2231 HEVCContext *s = avctxt->priv_data;
2232 int ctb_size = 1 << s->sps->log2_ctb_size;
2236 int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2238 if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) {
2239 av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n");
2240 return AVERROR_INVALIDDATA;
2243 if (s->sh.dependent_slice_segment_flag) {
2244 int prev_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2245 if (s->tab_slice_address[prev_rs] != s->sh.slice_addr) {
2246 av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n");
2247 return AVERROR_INVALIDDATA;
2251 while (more_data && ctb_addr_ts < s->sps->ctb_size) {
2252 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2254 x_ctb = (ctb_addr_rs % ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2255 y_ctb = (ctb_addr_rs / ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2256 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2258 ff_hevc_cabac_init(s, ctb_addr_ts);
2260 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2262 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2263 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2264 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2266 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2267 if (more_data < 0) {
2268 s->tab_slice_address[ctb_addr_rs] = -1;
2274 ff_hevc_save_states(s, ctb_addr_ts);
2275 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2278 if (x_ctb + ctb_size >= s->sps->width &&
2279 y_ctb + ctb_size >= s->sps->height)
2280 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2285 static int hls_slice_data(HEVCContext *s)
2293 s->avctx->execute(s->avctx, hls_decode_entry, arg, ret , 1, sizeof(int));
2296 static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int job, int self_id)
2298 HEVCContext *s1 = avctxt->priv_data, *s;
2299 HEVCLocalContext *lc;
2300 int ctb_size = 1<< s1->sps->log2_ctb_size;
2302 int *ctb_row_p = input_ctb_row;
2303 int ctb_row = ctb_row_p[job];
2304 int ctb_addr_rs = s1->sh.slice_ctb_addr_rs + ctb_row * ((s1->sps->width + ctb_size - 1) >> s1->sps->log2_ctb_size);
2305 int ctb_addr_ts = s1->pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2306 int thread = ctb_row % s1->threads_number;
2309 s = s1->sList[self_id];
2313 ret = init_get_bits8(&lc->gb, s->data + s->sh.offset[ctb_row - 1], s->sh.size[ctb_row - 1]);
2317 ff_init_cabac_decoder(&lc->cc, s->data + s->sh.offset[(ctb_row)-1], s->sh.size[ctb_row - 1]);
2320 while(more_data && ctb_addr_ts < s->sps->ctb_size) {
2321 int x_ctb = (ctb_addr_rs % s->sps->ctb_width) << s->sps->log2_ctb_size;
2322 int y_ctb = (ctb_addr_rs / s->sps->ctb_width) << s->sps->log2_ctb_size;
2324 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2326 ff_thread_await_progress2(s->avctx, ctb_row, thread, SHIFT_CTB_WPP);
2328 if (avpriv_atomic_int_get(&s1->wpp_err)){
2329 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2333 ff_hevc_cabac_init(s, ctb_addr_ts);
2334 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2335 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2337 if (more_data < 0) {
2338 s->tab_slice_address[ctb_addr_rs] = -1;
2344 ff_hevc_save_states(s, ctb_addr_ts);
2345 ff_thread_report_progress2(s->avctx, ctb_row, thread, 1);
2346 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2348 if (!more_data && (x_ctb+ctb_size) < s->sps->width && ctb_row != s->sh.num_entry_point_offsets) {
2349 avpriv_atomic_int_set(&s1->wpp_err, 1);
2350 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2354 if ((x_ctb+ctb_size) >= s->sps->width && (y_ctb+ctb_size) >= s->sps->height ) {
2355 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2356 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2359 ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2362 if(x_ctb >= s->sps->width) {
2366 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2371 static int hls_slice_data_wpp(HEVCContext *s, const uint8_t *nal, int length)
2373 HEVCLocalContext *lc = s->HEVClc;
2374 int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2375 int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2377 int startheader, cmpt = 0;
2382 ff_alloc_entries(s->avctx, s->sh.num_entry_point_offsets + 1);
2385 for (i = 1; i < s->threads_number; i++) {
2386 s->sList[i] = av_malloc(sizeof(HEVCContext));
2387 memcpy(s->sList[i], s, sizeof(HEVCContext));
2388 s->HEVClcList[i] = av_mallocz(sizeof(HEVCLocalContext));
2389 s->sList[i]->HEVClc = s->HEVClcList[i];
2393 offset = (lc->gb.index >> 3);
2395 for (j = 0, cmpt = 0, startheader = offset + s->sh.entry_point_offset[0]; j < s->skipped_bytes; j++) {
2396 if (s->skipped_bytes_pos[j] >= offset && s->skipped_bytes_pos[j] < startheader) {
2402 for (i = 1; i < s->sh.num_entry_point_offsets; i++) {
2403 offset += (s->sh.entry_point_offset[i - 1] - cmpt);
2404 for (j = 0, cmpt = 0, startheader = offset
2405 + s->sh.entry_point_offset[i]; j < s->skipped_bytes; j++) {
2406 if (s->skipped_bytes_pos[j] >= offset && s->skipped_bytes_pos[j] < startheader) {
2411 s->sh.size[i - 1] = s->sh.entry_point_offset[i] - cmpt;
2412 s->sh.offset[i - 1] = offset;
2415 if (s->sh.num_entry_point_offsets != 0) {
2416 offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt;
2417 s->sh.size[s->sh.num_entry_point_offsets - 1] = length - offset;
2418 s->sh.offset[s->sh.num_entry_point_offsets - 1] = offset;
2423 for (i = 1; i < s->threads_number; i++) {
2424 s->sList[i]->HEVClc->first_qp_group = 1;
2425 s->sList[i]->HEVClc->qp_y = s->sList[0]->HEVClc->qp_y;
2426 memcpy(s->sList[i], s, sizeof(HEVCContext));
2427 s->sList[i]->HEVClc = s->HEVClcList[i];
2430 avpriv_atomic_int_set(&s->wpp_err, 0);
2431 ff_reset_entries(s->avctx);
2433 for (i = 0; i <= s->sh.num_entry_point_offsets; i++) {
2438 if (s->pps->entropy_coding_sync_enabled_flag)
2439 s->avctx->execute2(s->avctx, (void *) hls_decode_entry_wpp, arg, ret, s->sh.num_entry_point_offsets + 1);
2441 for (i = 0; i <= s->sh.num_entry_point_offsets; i++)
2449 * @return AVERROR_INVALIDDATA if the packet is not a valid NAL unit,
2450 * 0 if the unit should be skipped, 1 otherwise
2452 static int hls_nal_unit(HEVCContext *s)
2454 GetBitContext *gb = &s->HEVClc->gb;
2457 if (get_bits1(gb) != 0)
2458 return AVERROR_INVALIDDATA;
2460 s->nal_unit_type = get_bits(gb, 6);
2462 nuh_layer_id = get_bits(gb, 6);
2463 s->temporal_id = get_bits(gb, 3) - 1;
2464 if (s->temporal_id < 0)
2465 return AVERROR_INVALIDDATA;
2467 av_log(s->avctx, AV_LOG_DEBUG,
2468 "nal_unit_type: %d, nuh_layer_id: %d, temporal_id: %d\n",
2469 s->nal_unit_type, nuh_layer_id, s->temporal_id);
2471 return nuh_layer_id == 0;
2474 static int set_side_data(HEVCContext *s)
2476 AVFrame *out = s->ref->frame;
2478 if (s->sei_frame_packing_present &&
2479 s->frame_packing_arrangement_type >= 3 &&
2480 s->frame_packing_arrangement_type <= 5 &&
2481 s->content_interpretation_type > 0 &&
2482 s->content_interpretation_type < 3) {
2483 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2485 return AVERROR(ENOMEM);
2487 switch (s->frame_packing_arrangement_type) {
2489 if (s->quincunx_subsampling)
2490 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2492 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2495 stereo->type = AV_STEREO3D_TOPBOTTOM;
2498 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2502 if (s->content_interpretation_type == 2)
2503 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2506 if (s->sei_display_orientation_present &&
2507 (s->sei_anticlockwise_rotation || s->sei_hflip || s->sei_vflip)) {
2508 double angle = s->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
2509 AVFrameSideData *rotation = av_frame_new_side_data(out,
2510 AV_FRAME_DATA_DISPLAYMATRIX,
2511 sizeof(int32_t) * 9);
2513 return AVERROR(ENOMEM);
2515 av_display_rotation_set((int32_t *)rotation->data, angle);
2516 av_display_matrix_flip((int32_t *)rotation->data,
2517 s->sei_hflip, s->sei_vflip);
2523 static int hevc_frame_start(HEVCContext *s)
2525 HEVCLocalContext *lc = s->HEVClc;
2526 int pic_size_in_ctb = ((s->sps->width >> s->sps->log2_min_cb_size) + 1) *
2527 ((s->sps->height >> s->sps->log2_min_cb_size) + 1);
2530 memset(s->horizontal_bs, 0, s->bs_width * s->bs_height);
2531 memset(s->vertical_bs, 0, s->bs_width * s->bs_height);
2532 memset(s->cbf_luma, 0, s->sps->min_tb_width * s->sps->min_tb_height);
2533 memset(s->is_pcm, 0, (s->sps->min_pu_width + 1) * (s->sps->min_pu_height + 1));
2534 memset(s->tab_slice_address, -1, pic_size_in_ctb * sizeof(*s->tab_slice_address));
2537 s->first_nal_type = s->nal_unit_type;
2539 if (s->pps->tiles_enabled_flag)
2540 lc->end_of_tiles_x = s->pps->column_width[0] << s->sps->log2_ctb_size;
2542 ret = ff_hevc_set_new_ref(s, &s->frame, s->poc);
2546 ret = ff_hevc_frame_rps(s);
2548 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2552 s->ref->frame->key_frame = IS_IRAP(s);
2554 ret = set_side_data(s);
2558 s->frame->pict_type = 3 - s->sh.slice_type;
2561 ff_hevc_bump_frame(s);
2563 av_frame_unref(s->output_frame);
2564 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2568 ff_thread_finish_setup(s->avctx);
2573 if (s->ref && s->threads_type == FF_THREAD_FRAME)
2574 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2579 static int decode_nal_unit(HEVCContext *s, const uint8_t *nal, int length)
2581 HEVCLocalContext *lc = s->HEVClc;
2582 GetBitContext *gb = &lc->gb;
2583 int ctb_addr_ts, ret;
2585 ret = init_get_bits8(gb, nal, length);
2589 ret = hls_nal_unit(s);
2591 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit %d, skipping.\n",
2597 switch (s->nal_unit_type) {
2599 ret = ff_hevc_decode_nal_vps(s);
2604 ret = ff_hevc_decode_nal_sps(s);
2609 ret = ff_hevc_decode_nal_pps(s);
2613 case NAL_SEI_PREFIX:
2614 case NAL_SEI_SUFFIX:
2615 ret = ff_hevc_decode_nal_sei(s);
2626 case NAL_BLA_W_RADL:
2628 case NAL_IDR_W_RADL:
2635 ret = hls_slice_header(s);
2639 if (s->max_ra == INT_MAX) {
2640 if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
2644 s->max_ra = INT_MIN;
2648 if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
2649 s->poc <= s->max_ra) {
2653 if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
2654 s->max_ra = INT_MIN;
2657 if (s->sh.first_slice_in_pic_flag) {
2658 ret = hevc_frame_start(s);
2661 } else if (!s->ref) {
2662 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2666 if (s->nal_unit_type != s->first_nal_type) {
2667 av_log(s->avctx, AV_LOG_ERROR,
2668 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2669 s->first_nal_type, s->nal_unit_type);
2670 return AVERROR_INVALIDDATA;
2673 if (!s->sh.dependent_slice_segment_flag &&
2674 s->sh.slice_type != I_SLICE) {
2675 ret = ff_hevc_slice_rpl(s);
2677 av_log(s->avctx, AV_LOG_WARNING,
2678 "Error constructing the reference lists for the current slice.\n");
2683 if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
2684 ctb_addr_ts = hls_slice_data_wpp(s, nal, length);
2686 ctb_addr_ts = hls_slice_data(s);
2687 if (ctb_addr_ts >= (s->sps->ctb_width * s->sps->ctb_height)) {
2691 if (ctb_addr_ts < 0) {
2698 s->seq_decode = (s->seq_decode + 1) & 0xff;
2699 s->max_ra = INT_MAX;
2705 av_log(s->avctx, AV_LOG_INFO,
2706 "Skipping NAL unit %d\n", s->nal_unit_type);
2711 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2716 /* FIXME: This is adapted from ff_h264_decode_nal, avoiding duplication
2717 * between these functions would be nice. */
2718 int ff_hevc_extract_rbsp(HEVCContext *s, const uint8_t *src, int length,
2724 s->skipped_bytes = 0;
2725 #define STARTCODE_TEST \
2726 if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \
2727 if (src[i + 2] != 3) { \
2728 /* startcode, so we must be past the end */ \
2733 #if HAVE_FAST_UNALIGNED
2734 #define FIND_FIRST_ZERO \
2735 if (i > 0 && !src[i]) \
2740 for (i = 0; i + 1 < length; i += 9) {
2741 if (!((~AV_RN64A(src + i) &
2742 (AV_RN64A(src + i) - 0x0100010001000101ULL)) &
2743 0x8000800080008080ULL))
2750 for (i = 0; i + 1 < length; i += 5) {
2751 if (!((~AV_RN32A(src + i) &
2752 (AV_RN32A(src + i) - 0x01000101U)) &
2759 #endif /* HAVE_FAST_64BIT */
2761 for (i = 0; i + 1 < length; i += 2) {
2764 if (i > 0 && src[i - 1] == 0)
2768 #endif /* HAVE_FAST_UNALIGNED */
2770 if (i >= length - 1) { // no escaped 0
2776 av_fast_malloc(&nal->rbsp_buffer, &nal->rbsp_buffer_size,
2777 length + FF_INPUT_BUFFER_PADDING_SIZE);
2778 if (!nal->rbsp_buffer)
2779 return AVERROR(ENOMEM);
2781 dst = nal->rbsp_buffer;
2783 memcpy(dst, src, i);
2785 while (si + 2 < length) {
2786 // remove escapes (very rare 1:2^22)
2787 if (src[si + 2] > 3) {
2788 dst[di++] = src[si++];
2789 dst[di++] = src[si++];
2790 } else if (src[si] == 0 && src[si + 1] == 0) {
2791 if (src[si + 2] == 3) { // escape
2797 if (s->skipped_bytes_pos_size < s->skipped_bytes) {
2798 s->skipped_bytes_pos_size *= 2;
2799 av_reallocp_array(&s->skipped_bytes_pos,
2800 s->skipped_bytes_pos_size,
2801 sizeof(*s->skipped_bytes_pos));
2802 if (!s->skipped_bytes_pos)
2803 return AVERROR(ENOMEM);
2805 if (s->skipped_bytes_pos)
2806 s->skipped_bytes_pos[s->skipped_bytes-1] = di - 1;
2808 } else // next start code
2812 dst[di++] = src[si++];
2815 dst[di++] = src[si++];
2818 memset(dst + di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2825 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2827 int i, consumed, ret = 0;
2830 s->last_eos = s->eos;
2833 /* split the input packet into NAL units, so we know the upper bound on the
2834 * number of slices in the frame */
2836 while (length >= 4) {
2838 int extract_length = 0;
2842 for (i = 0; i < s->nal_length_size; i++)
2843 extract_length = (extract_length << 8) | buf[i];
2844 buf += s->nal_length_size;
2845 length -= s->nal_length_size;
2847 if (extract_length > length) {
2848 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit size.\n");
2849 ret = AVERROR_INVALIDDATA;
2853 /* search start code */
2854 while (buf[0] != 0 || buf[1] != 0 || buf[2] != 1) {
2858 av_log(s->avctx, AV_LOG_ERROR, "No start code is found.\n");
2859 ret = AVERROR_INVALIDDATA;
2869 extract_length = length;
2871 if (s->nals_allocated < s->nb_nals + 1) {
2872 int new_size = s->nals_allocated + 1;
2873 HEVCNAL *tmp = av_realloc_array(s->nals, new_size, sizeof(*tmp));
2875 ret = AVERROR(ENOMEM);
2879 memset(s->nals + s->nals_allocated, 0,
2880 (new_size - s->nals_allocated) * sizeof(*tmp));
2881 av_reallocp_array(&s->skipped_bytes_nal, new_size, sizeof(*s->skipped_bytes_nal));
2882 av_reallocp_array(&s->skipped_bytes_pos_size_nal, new_size, sizeof(*s->skipped_bytes_pos_size_nal));
2883 av_reallocp_array(&s->skipped_bytes_pos_nal, new_size, sizeof(*s->skipped_bytes_pos_nal));
2884 s->skipped_bytes_pos_size_nal[s->nals_allocated] = 1024; // initial buffer size
2885 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));
2886 s->nals_allocated = new_size;
2888 s->skipped_bytes_pos_size = s->skipped_bytes_pos_size_nal[s->nb_nals];
2889 s->skipped_bytes_pos = s->skipped_bytes_pos_nal[s->nb_nals];
2890 nal = &s->nals[s->nb_nals];
2892 consumed = ff_hevc_extract_rbsp(s, buf, extract_length, nal);
2894 s->skipped_bytes_nal[s->nb_nals] = s->skipped_bytes;
2895 s->skipped_bytes_pos_size_nal[s->nb_nals] = s->skipped_bytes_pos_size;
2896 s->skipped_bytes_pos_nal[s->nb_nals++] = s->skipped_bytes_pos;
2904 ret = init_get_bits8(&s->HEVClc->gb, nal->data, nal->size);
2909 if (s->nal_unit_type == NAL_EOB_NUT ||
2910 s->nal_unit_type == NAL_EOS_NUT)
2917 /* parse the NAL units */
2918 for (i = 0; i < s->nb_nals; i++) {
2920 s->skipped_bytes = s->skipped_bytes_nal[i];
2921 s->skipped_bytes_pos = s->skipped_bytes_pos_nal[i];
2923 ret = decode_nal_unit(s, s->nals[i].data, s->nals[i].size);
2925 av_log(s->avctx, AV_LOG_WARNING,
2926 "Error parsing NAL unit #%d.\n", i);
2932 if (s->ref && s->threads_type == FF_THREAD_FRAME)
2933 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2938 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2941 for (i = 0; i < 16; i++)
2942 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
2945 static int verify_md5(HEVCContext *s, AVFrame *frame)
2947 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
2952 return AVERROR(EINVAL);
2954 pixel_shift = desc->comp[0].depth_minus1 > 7;
2956 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
2959 /* the checksums are LE, so we have to byteswap for >8bpp formats
2962 if (pixel_shift && !s->checksum_buf) {
2963 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
2964 FFMAX3(frame->linesize[0], frame->linesize[1],
2965 frame->linesize[2]));
2966 if (!s->checksum_buf)
2967 return AVERROR(ENOMEM);
2971 for (i = 0; frame->data[i]; i++) {
2972 int width = s->avctx->coded_width;
2973 int height = s->avctx->coded_height;
2974 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
2975 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
2978 av_md5_init(s->md5_ctx);
2979 for (j = 0; j < h; j++) {
2980 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
2983 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
2984 (const uint16_t *) src, w);
2985 src = s->checksum_buf;
2988 av_md5_update(s->md5_ctx, src, w << pixel_shift);
2990 av_md5_final(s->md5_ctx, md5);
2992 if (!memcmp(md5, s->md5[i], 16)) {
2993 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
2994 print_md5(s->avctx, AV_LOG_DEBUG, md5);
2995 av_log (s->avctx, AV_LOG_DEBUG, "; ");
2997 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
2998 print_md5(s->avctx, AV_LOG_ERROR, md5);
2999 av_log (s->avctx, AV_LOG_ERROR, " != ");
3000 print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
3001 av_log (s->avctx, AV_LOG_ERROR, "\n");
3002 return AVERROR_INVALIDDATA;
3006 av_log(s->avctx, AV_LOG_DEBUG, "\n");
3011 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
3015 HEVCContext *s = avctx->priv_data;
3018 ret = ff_hevc_output_frame(s, data, 1);
3027 ret = decode_nal_units(s, avpkt->data, avpkt->size);
3031 /* verify the SEI checksum */
3032 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
3034 ret = verify_md5(s, s->ref->frame);
3035 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
3036 ff_hevc_unref_frame(s, s->ref, ~0);
3042 if (s->is_decoded) {
3043 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
3047 if (s->output_frame->buf[0]) {
3048 av_frame_move_ref(data, s->output_frame);
3055 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
3059 ret = ff_thread_ref_frame(&dst->tf, &src->tf);
3063 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
3064 if (!dst->tab_mvf_buf)
3066 dst->tab_mvf = src->tab_mvf;
3068 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
3069 if (!dst->rpl_tab_buf)
3071 dst->rpl_tab = src->rpl_tab;
3073 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
3077 dst->poc = src->poc;
3078 dst->ctb_count = src->ctb_count;
3079 dst->window = src->window;
3080 dst->flags = src->flags;
3081 dst->sequence = src->sequence;
3085 ff_hevc_unref_frame(s, dst, ~0);
3086 return AVERROR(ENOMEM);
3089 static av_cold int hevc_decode_free(AVCodecContext *avctx)
3091 HEVCContext *s = avctx->priv_data;
3096 av_freep(&s->md5_ctx);
3098 for(i=0; i < s->nals_allocated; i++) {
3099 av_freep(&s->skipped_bytes_pos_nal[i]);
3101 av_freep(&s->skipped_bytes_pos_size_nal);
3102 av_freep(&s->skipped_bytes_nal);
3103 av_freep(&s->skipped_bytes_pos_nal);
3105 av_freep(&s->cabac_state);
3107 av_frame_free(&s->tmp_frame);
3108 av_frame_free(&s->output_frame);
3110 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3111 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3112 av_frame_free(&s->DPB[i].frame);
3115 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++)
3116 av_buffer_unref(&s->vps_list[i]);
3117 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++)
3118 av_buffer_unref(&s->sps_list[i]);
3119 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
3120 av_buffer_unref(&s->pps_list[i]);
3125 av_buffer_unref(&s->current_sps);
3127 av_freep(&s->sh.entry_point_offset);
3128 av_freep(&s->sh.offset);
3129 av_freep(&s->sh.size);
3131 for (i = 1; i < s->threads_number; i++) {
3132 HEVCLocalContext *lc = s->HEVClcList[i];
3134 av_freep(&s->HEVClcList[i]);
3135 av_freep(&s->sList[i]);
3138 if (s->HEVClc == s->HEVClcList[0])
3140 av_freep(&s->HEVClcList[0]);
3142 for (i = 0; i < s->nals_allocated; i++)
3143 av_freep(&s->nals[i].rbsp_buffer);
3145 s->nals_allocated = 0;
3150 static av_cold int hevc_init_context(AVCodecContext *avctx)
3152 HEVCContext *s = avctx->priv_data;
3157 s->HEVClc = av_mallocz(sizeof(HEVCLocalContext));
3160 s->HEVClcList[0] = s->HEVClc;
3163 s->cabac_state = av_malloc(HEVC_CONTEXTS);
3164 if (!s->cabac_state)
3167 s->tmp_frame = av_frame_alloc();
3171 s->output_frame = av_frame_alloc();
3172 if (!s->output_frame)
3175 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3176 s->DPB[i].frame = av_frame_alloc();
3177 if (!s->DPB[i].frame)
3179 s->DPB[i].tf.f = s->DPB[i].frame;
3182 s->max_ra = INT_MAX;
3184 s->md5_ctx = av_md5_alloc();
3188 ff_bswapdsp_init(&s->bdsp);
3190 s->context_initialized = 1;
3196 hevc_decode_free(avctx);
3197 return AVERROR(ENOMEM);
3200 static int hevc_update_thread_context(AVCodecContext *dst,
3201 const AVCodecContext *src)
3203 HEVCContext *s = dst->priv_data;
3204 HEVCContext *s0 = src->priv_data;
3207 if (!s->context_initialized) {
3208 ret = hevc_init_context(dst);
3213 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3214 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3215 if (s0->DPB[i].frame->buf[0]) {
3216 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3222 if (s->sps != s0->sps)
3224 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++) {
3225 av_buffer_unref(&s->vps_list[i]);
3226 if (s0->vps_list[i]) {
3227 s->vps_list[i] = av_buffer_ref(s0->vps_list[i]);
3228 if (!s->vps_list[i])
3229 return AVERROR(ENOMEM);
3233 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++) {
3234 av_buffer_unref(&s->sps_list[i]);
3235 if (s0->sps_list[i]) {
3236 s->sps_list[i] = av_buffer_ref(s0->sps_list[i]);
3237 if (!s->sps_list[i])
3238 return AVERROR(ENOMEM);
3242 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++) {
3243 av_buffer_unref(&s->pps_list[i]);
3244 if (s0->pps_list[i]) {
3245 s->pps_list[i] = av_buffer_ref(s0->pps_list[i]);
3246 if (!s->pps_list[i])
3247 return AVERROR(ENOMEM);
3251 av_buffer_unref(&s->current_sps);
3252 if (s0->current_sps) {
3253 s->current_sps = av_buffer_ref(s0->current_sps);
3254 if (!s->current_sps)
3255 return AVERROR(ENOMEM);
3258 if (s->sps != s0->sps)
3259 if ((ret = set_sps(s, s0->sps)) < 0)
3262 s->seq_decode = s0->seq_decode;
3263 s->seq_output = s0->seq_output;
3264 s->pocTid0 = s0->pocTid0;
3265 s->max_ra = s0->max_ra;
3268 s->is_nalff = s0->is_nalff;
3269 s->nal_length_size = s0->nal_length_size;
3271 s->threads_number = s0->threads_number;
3272 s->threads_type = s0->threads_type;
3275 s->seq_decode = (s->seq_decode + 1) & 0xff;
3276 s->max_ra = INT_MAX;
3282 static int hevc_decode_extradata(HEVCContext *s)
3284 AVCodecContext *avctx = s->avctx;
3288 bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
3290 if (avctx->extradata_size > 3 &&
3291 (avctx->extradata[0] || avctx->extradata[1] ||
3292 avctx->extradata[2] > 1)) {
3293 /* It seems the extradata is encoded as hvcC format.
3294 * Temporarily, we support configurationVersion==0 until 14496-15 3rd
3295 * is finalized. When finalized, configurationVersion will be 1 and we
3296 * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
3297 int i, j, num_arrays, nal_len_size;
3301 bytestream2_skip(&gb, 21);
3302 nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
3303 num_arrays = bytestream2_get_byte(&gb);
3305 /* nal units in the hvcC always have length coded with 2 bytes,
3306 * so put a fake nal_length_size = 2 while parsing them */
3307 s->nal_length_size = 2;
3309 /* Decode nal units from hvcC. */
3310 for (i = 0; i < num_arrays; i++) {
3311 int type = bytestream2_get_byte(&gb) & 0x3f;
3312 int cnt = bytestream2_get_be16(&gb);
3314 for (j = 0; j < cnt; j++) {
3315 // +2 for the nal size field
3316 int nalsize = bytestream2_peek_be16(&gb) + 2;
3317 if (bytestream2_get_bytes_left(&gb) < nalsize) {
3318 av_log(s->avctx, AV_LOG_ERROR,
3319 "Invalid NAL unit size in extradata.\n");
3320 return AVERROR_INVALIDDATA;
3323 ret = decode_nal_units(s, gb.buffer, nalsize);
3325 av_log(avctx, AV_LOG_ERROR,
3326 "Decoding nal unit %d %d from hvcC failed\n",
3330 bytestream2_skip(&gb, nalsize);
3334 /* Now store right nal length size, that will be used to parse
3336 s->nal_length_size = nal_len_size;
3339 ret = decode_nal_units(s, avctx->extradata, avctx->extradata_size);
3346 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3348 HEVCContext *s = avctx->priv_data;
3351 ff_init_cabac_states();
3353 avctx->internal->allocate_progress = 1;
3355 ret = hevc_init_context(avctx);
3359 s->enable_parallel_tiles = 0;
3360 s->picture_struct = 0;
3362 if(avctx->active_thread_type & FF_THREAD_SLICE)
3363 s->threads_number = avctx->thread_count;
3365 s->threads_number = 1;
3367 if (avctx->extradata_size > 0 && avctx->extradata) {
3368 ret = hevc_decode_extradata(s);
3370 hevc_decode_free(avctx);
3375 if((avctx->active_thread_type & FF_THREAD_FRAME) && avctx->thread_count > 1)
3376 s->threads_type = FF_THREAD_FRAME;
3378 s->threads_type = FF_THREAD_SLICE;
3383 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3385 HEVCContext *s = avctx->priv_data;
3388 memset(s, 0, sizeof(*s));
3390 ret = hevc_init_context(avctx);
3397 static void hevc_decode_flush(AVCodecContext *avctx)
3399 HEVCContext *s = avctx->priv_data;
3400 ff_hevc_flush_dpb(s);
3401 s->max_ra = INT_MAX;
3404 #define OFFSET(x) offsetof(HEVCContext, x)
3405 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3407 static const AVProfile profiles[] = {
3408 { FF_PROFILE_HEVC_MAIN, "Main" },
3409 { FF_PROFILE_HEVC_MAIN_10, "Main 10" },
3410 { FF_PROFILE_HEVC_MAIN_STILL_PICTURE, "Main Still Picture" },
3411 { FF_PROFILE_HEVC_REXT, "Rext" },
3412 { FF_PROFILE_UNKNOWN },
3415 static const AVOption options[] = {
3416 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3417 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3418 { "strict-displaywin", "stricly apply default display window size", OFFSET(apply_defdispwin),
3419 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3423 static const AVClass hevc_decoder_class = {
3424 .class_name = "HEVC decoder",
3425 .item_name = av_default_item_name,
3427 .version = LIBAVUTIL_VERSION_INT,
3430 AVCodec ff_hevc_decoder = {
3432 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3433 .type = AVMEDIA_TYPE_VIDEO,
3434 .id = AV_CODEC_ID_HEVC,
3435 .priv_data_size = sizeof(HEVCContext),
3436 .priv_class = &hevc_decoder_class,
3437 .init = hevc_decode_init,
3438 .close = hevc_decode_free,
3439 .decode = hevc_decode_frame,
3440 .flush = hevc_decode_flush,
3441 .update_thread_context = hevc_update_thread_context,
3442 .init_thread_copy = hevc_init_thread_copy,
3443 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY |
3444 CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS,
3445 .profiles = NULL_IF_CONFIG_SMALL(profiles),