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/attributes.h"
27 #include "libavutil/common.h"
28 #include "libavutil/display.h"
29 #include "libavutil/internal.h"
30 #include "libavutil/mastering_display_metadata.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"
41 #include "hevc_data.h"
42 #include "hevc_parse.h"
46 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 };
49 * NOTE: Each function hls_foo correspond to the function foo in the
50 * specification (HLS stands for High Level Syntax).
57 /* free everything allocated by pic_arrays_init() */
58 static void pic_arrays_free(HEVCContext *s)
61 av_freep(&s->deblock);
63 av_freep(&s->skip_flag);
64 av_freep(&s->tab_ct_depth);
66 av_freep(&s->tab_ipm);
67 av_freep(&s->cbf_luma);
70 av_freep(&s->qp_y_tab);
71 av_freep(&s->tab_slice_address);
72 av_freep(&s->filter_slice_edges);
74 av_freep(&s->horizontal_bs);
75 av_freep(&s->vertical_bs);
77 av_freep(&s->sh.entry_point_offset);
78 av_freep(&s->sh.size);
79 av_freep(&s->sh.offset);
81 av_buffer_pool_uninit(&s->tab_mvf_pool);
82 av_buffer_pool_uninit(&s->rpl_tab_pool);
85 /* allocate arrays that depend on frame dimensions */
86 static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
88 int log2_min_cb_size = sps->log2_min_cb_size;
89 int width = sps->width;
90 int height = sps->height;
91 int pic_size_in_ctb = ((width >> log2_min_cb_size) + 1) *
92 ((height >> log2_min_cb_size) + 1);
93 int ctb_count = sps->ctb_width * sps->ctb_height;
94 int min_pu_size = sps->min_pu_width * sps->min_pu_height;
96 s->bs_width = (width >> 2) + 1;
97 s->bs_height = (height >> 2) + 1;
99 s->sao = av_mallocz_array(ctb_count, sizeof(*s->sao));
100 s->deblock = av_mallocz_array(ctb_count, sizeof(*s->deblock));
101 if (!s->sao || !s->deblock)
104 s->skip_flag = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
105 s->tab_ct_depth = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
106 if (!s->skip_flag || !s->tab_ct_depth)
109 s->cbf_luma = av_malloc_array(sps->min_tb_width, sps->min_tb_height);
110 s->tab_ipm = av_mallocz(min_pu_size);
111 s->is_pcm = av_malloc_array(sps->min_pu_width + 1, sps->min_pu_height + 1);
112 if (!s->tab_ipm || !s->cbf_luma || !s->is_pcm)
115 s->filter_slice_edges = av_mallocz(ctb_count);
116 s->tab_slice_address = av_malloc_array(pic_size_in_ctb,
117 sizeof(*s->tab_slice_address));
118 s->qp_y_tab = av_malloc_array(pic_size_in_ctb,
119 sizeof(*s->qp_y_tab));
120 if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address)
123 s->horizontal_bs = av_mallocz_array(s->bs_width, s->bs_height);
124 s->vertical_bs = av_mallocz_array(s->bs_width, s->bs_height);
125 if (!s->horizontal_bs || !s->vertical_bs)
128 s->tab_mvf_pool = av_buffer_pool_init(min_pu_size * sizeof(MvField),
130 s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab),
132 if (!s->tab_mvf_pool || !s->rpl_tab_pool)
139 return AVERROR(ENOMEM);
142 static int pred_weight_table(HEVCContext *s, GetBitContext *gb)
146 uint8_t luma_weight_l0_flag[16];
147 uint8_t chroma_weight_l0_flag[16];
148 uint8_t luma_weight_l1_flag[16];
149 uint8_t chroma_weight_l1_flag[16];
150 int luma_log2_weight_denom;
152 luma_log2_weight_denom = get_ue_golomb_long(gb);
153 if (luma_log2_weight_denom < 0 || luma_log2_weight_denom > 7)
154 av_log(s->avctx, AV_LOG_ERROR, "luma_log2_weight_denom %d is invalid\n", luma_log2_weight_denom);
155 s->sh.luma_log2_weight_denom = av_clip_uintp2(luma_log2_weight_denom, 3);
156 if (s->ps.sps->chroma_format_idc != 0) {
157 int delta = get_se_golomb(gb);
158 s->sh.chroma_log2_weight_denom = av_clip_uintp2(s->sh.luma_log2_weight_denom + delta, 3);
161 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
162 luma_weight_l0_flag[i] = get_bits1(gb);
163 if (!luma_weight_l0_flag[i]) {
164 s->sh.luma_weight_l0[i] = 1 << s->sh.luma_log2_weight_denom;
165 s->sh.luma_offset_l0[i] = 0;
168 if (s->ps.sps->chroma_format_idc != 0) {
169 for (i = 0; i < s->sh.nb_refs[L0]; i++)
170 chroma_weight_l0_flag[i] = get_bits1(gb);
172 for (i = 0; i < s->sh.nb_refs[L0]; i++)
173 chroma_weight_l0_flag[i] = 0;
175 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
176 if (luma_weight_l0_flag[i]) {
177 int delta_luma_weight_l0 = get_se_golomb(gb);
178 s->sh.luma_weight_l0[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;
179 s->sh.luma_offset_l0[i] = get_se_golomb(gb);
181 if (chroma_weight_l0_flag[i]) {
182 for (j = 0; j < 2; j++) {
183 int delta_chroma_weight_l0 = get_se_golomb(gb);
184 int delta_chroma_offset_l0 = get_se_golomb(gb);
186 if ( (int8_t)delta_chroma_weight_l0 != delta_chroma_weight_l0
187 || delta_chroma_offset_l0 < -(1<<17) || delta_chroma_offset_l0 > (1<<17)) {
188 return AVERROR_INVALIDDATA;
191 s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
192 s->sh.chroma_offset_l0[i][j] = av_clip((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j])
193 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
196 s->sh.chroma_weight_l0[i][0] = 1 << s->sh.chroma_log2_weight_denom;
197 s->sh.chroma_offset_l0[i][0] = 0;
198 s->sh.chroma_weight_l0[i][1] = 1 << s->sh.chroma_log2_weight_denom;
199 s->sh.chroma_offset_l0[i][1] = 0;
202 if (s->sh.slice_type == HEVC_SLICE_B) {
203 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
204 luma_weight_l1_flag[i] = get_bits1(gb);
205 if (!luma_weight_l1_flag[i]) {
206 s->sh.luma_weight_l1[i] = 1 << s->sh.luma_log2_weight_denom;
207 s->sh.luma_offset_l1[i] = 0;
210 if (s->ps.sps->chroma_format_idc != 0) {
211 for (i = 0; i < s->sh.nb_refs[L1]; i++)
212 chroma_weight_l1_flag[i] = get_bits1(gb);
214 for (i = 0; i < s->sh.nb_refs[L1]; i++)
215 chroma_weight_l1_flag[i] = 0;
217 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
218 if (luma_weight_l1_flag[i]) {
219 int delta_luma_weight_l1 = get_se_golomb(gb);
220 s->sh.luma_weight_l1[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;
221 s->sh.luma_offset_l1[i] = get_se_golomb(gb);
223 if (chroma_weight_l1_flag[i]) {
224 for (j = 0; j < 2; j++) {
225 int delta_chroma_weight_l1 = get_se_golomb(gb);
226 int delta_chroma_offset_l1 = get_se_golomb(gb);
228 if ( (int8_t)delta_chroma_weight_l1 != delta_chroma_weight_l1
229 || delta_chroma_offset_l1 < -(1<<17) || delta_chroma_offset_l1 > (1<<17)) {
230 return AVERROR_INVALIDDATA;
233 s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
234 s->sh.chroma_offset_l1[i][j] = av_clip((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j])
235 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
238 s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom;
239 s->sh.chroma_offset_l1[i][0] = 0;
240 s->sh.chroma_weight_l1[i][1] = 1 << s->sh.chroma_log2_weight_denom;
241 s->sh.chroma_offset_l1[i][1] = 0;
248 static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
250 const HEVCSPS *sps = s->ps.sps;
251 int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
252 int prev_delta_msb = 0;
253 unsigned int nb_sps = 0, nb_sh;
257 if (!sps->long_term_ref_pics_present_flag)
260 if (sps->num_long_term_ref_pics_sps > 0)
261 nb_sps = get_ue_golomb_long(gb);
262 nb_sh = get_ue_golomb_long(gb);
264 if (nb_sps > sps->num_long_term_ref_pics_sps)
265 return AVERROR_INVALIDDATA;
266 if (nb_sh + (uint64_t)nb_sps > FF_ARRAY_ELEMS(rps->poc))
267 return AVERROR_INVALIDDATA;
269 rps->nb_refs = nb_sh + nb_sps;
271 for (i = 0; i < rps->nb_refs; i++) {
272 uint8_t delta_poc_msb_present;
275 uint8_t lt_idx_sps = 0;
277 if (sps->num_long_term_ref_pics_sps > 1)
278 lt_idx_sps = get_bits(gb, av_ceil_log2(sps->num_long_term_ref_pics_sps));
280 rps->poc[i] = sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
281 rps->used[i] = sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];
283 rps->poc[i] = get_bits(gb, sps->log2_max_poc_lsb);
284 rps->used[i] = get_bits1(gb);
287 delta_poc_msb_present = get_bits1(gb);
288 if (delta_poc_msb_present) {
289 int64_t delta = get_ue_golomb_long(gb);
292 if (i && i != nb_sps)
293 delta += prev_delta_msb;
295 poc = rps->poc[i] + s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
296 if (poc != (int32_t)poc)
297 return AVERROR_INVALIDDATA;
299 prev_delta_msb = delta;
306 static void export_stream_params(AVCodecContext *avctx, const HEVCParamSets *ps,
309 const HEVCVPS *vps = (const HEVCVPS*)ps->vps_list[sps->vps_id]->data;
310 const HEVCWindow *ow = &sps->output_window;
311 unsigned int num = 0, den = 0;
313 avctx->pix_fmt = sps->pix_fmt;
314 avctx->coded_width = sps->width;
315 avctx->coded_height = sps->height;
316 avctx->width = sps->width - ow->left_offset - ow->right_offset;
317 avctx->height = sps->height - ow->top_offset - ow->bottom_offset;
318 avctx->has_b_frames = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics;
319 avctx->profile = sps->ptl.general_ptl.profile_idc;
320 avctx->level = sps->ptl.general_ptl.level_idc;
322 ff_set_sar(avctx, sps->vui.sar);
324 if (sps->vui.video_signal_type_present_flag)
325 avctx->color_range = sps->vui.video_full_range_flag ? AVCOL_RANGE_JPEG
328 avctx->color_range = AVCOL_RANGE_MPEG;
330 if (sps->vui.colour_description_present_flag) {
331 avctx->color_primaries = sps->vui.colour_primaries;
332 avctx->color_trc = sps->vui.transfer_characteristic;
333 avctx->colorspace = sps->vui.matrix_coeffs;
335 avctx->color_primaries = AVCOL_PRI_UNSPECIFIED;
336 avctx->color_trc = AVCOL_TRC_UNSPECIFIED;
337 avctx->colorspace = AVCOL_SPC_UNSPECIFIED;
340 if (vps->vps_timing_info_present_flag) {
341 num = vps->vps_num_units_in_tick;
342 den = vps->vps_time_scale;
343 } else if (sps->vui.vui_timing_info_present_flag) {
344 num = sps->vui.vui_num_units_in_tick;
345 den = sps->vui.vui_time_scale;
348 if (num != 0 && den != 0)
349 av_reduce(&avctx->framerate.den, &avctx->framerate.num,
353 static enum AVPixelFormat get_format(HEVCContext *s, const HEVCSPS *sps)
355 #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + \
356 CONFIG_HEVC_D3D11VA_HWACCEL * 2 + \
357 CONFIG_HEVC_VAAPI_HWACCEL + \
358 CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL + \
359 CONFIG_HEVC_VDPAU_HWACCEL)
360 enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
362 switch (sps->pix_fmt) {
363 case AV_PIX_FMT_YUV420P:
364 case AV_PIX_FMT_YUVJ420P:
365 #if CONFIG_HEVC_DXVA2_HWACCEL
366 *fmt++ = AV_PIX_FMT_DXVA2_VLD;
368 #if CONFIG_HEVC_D3D11VA_HWACCEL
369 *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
370 *fmt++ = AV_PIX_FMT_D3D11;
372 #if CONFIG_HEVC_VAAPI_HWACCEL
373 *fmt++ = AV_PIX_FMT_VAAPI;
375 #if CONFIG_HEVC_VDPAU_HWACCEL
376 *fmt++ = AV_PIX_FMT_VDPAU;
378 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
379 *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX;
382 case AV_PIX_FMT_YUV420P10:
383 #if CONFIG_HEVC_DXVA2_HWACCEL
384 *fmt++ = AV_PIX_FMT_DXVA2_VLD;
386 #if CONFIG_HEVC_D3D11VA_HWACCEL
387 *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
388 *fmt++ = AV_PIX_FMT_D3D11;
390 #if CONFIG_HEVC_VAAPI_HWACCEL
391 *fmt++ = AV_PIX_FMT_VAAPI;
393 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
394 *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX;
399 *fmt++ = sps->pix_fmt;
400 *fmt = AV_PIX_FMT_NONE;
402 return ff_thread_get_format(s->avctx, pix_fmts);
405 static int set_sps(HEVCContext *s, const HEVCSPS *sps,
406 enum AVPixelFormat pix_fmt)
417 ret = pic_arrays_init(s, sps);
421 export_stream_params(s->avctx, &s->ps, sps);
423 s->avctx->pix_fmt = pix_fmt;
425 ff_hevc_pred_init(&s->hpc, sps->bit_depth);
426 ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
427 ff_videodsp_init (&s->vdsp, sps->bit_depth);
429 for (i = 0; i < 3; i++) {
430 av_freep(&s->sao_pixel_buffer_h[i]);
431 av_freep(&s->sao_pixel_buffer_v[i]);
434 if (sps->sao_enabled && !s->avctx->hwaccel) {
435 int c_count = (sps->chroma_format_idc != 0) ? 3 : 1;
438 for(c_idx = 0; c_idx < c_count; c_idx++) {
439 int w = sps->width >> sps->hshift[c_idx];
440 int h = sps->height >> sps->vshift[c_idx];
441 s->sao_pixel_buffer_h[c_idx] =
442 av_malloc((w * 2 * sps->ctb_height) <<
444 s->sao_pixel_buffer_v[c_idx] =
445 av_malloc((h * 2 * sps->ctb_width) <<
451 s->ps.vps = (HEVCVPS*) s->ps.vps_list[s->ps.sps->vps_id]->data;
461 static int hls_slice_header(HEVCContext *s)
463 GetBitContext *gb = &s->HEVClc->gb;
464 SliceHeader *sh = &s->sh;
468 sh->first_slice_in_pic_flag = get_bits1(gb);
469 if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
470 s->seq_decode = (s->seq_decode + 1) & 0xff;
473 ff_hevc_clear_refs(s);
475 sh->no_output_of_prior_pics_flag = 0;
477 sh->no_output_of_prior_pics_flag = get_bits1(gb);
479 sh->pps_id = get_ue_golomb_long(gb);
480 if (sh->pps_id >= HEVC_MAX_PPS_COUNT || !s->ps.pps_list[sh->pps_id]) {
481 av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
482 return AVERROR_INVALIDDATA;
484 if (!sh->first_slice_in_pic_flag &&
485 s->ps.pps != (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data) {
486 av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
487 return AVERROR_INVALIDDATA;
489 s->ps.pps = (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data;
490 if (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos == 1)
491 sh->no_output_of_prior_pics_flag = 1;
493 if (s->ps.sps != (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data) {
494 const HEVCSPS *sps = (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data;
495 const HEVCSPS *last_sps = s->ps.sps;
496 enum AVPixelFormat pix_fmt;
498 if (last_sps && IS_IRAP(s) && s->nal_unit_type != HEVC_NAL_CRA_NUT) {
499 if (sps->width != last_sps->width || sps->height != last_sps->height ||
500 sps->temporal_layer[sps->max_sub_layers - 1].max_dec_pic_buffering !=
501 last_sps->temporal_layer[last_sps->max_sub_layers - 1].max_dec_pic_buffering)
502 sh->no_output_of_prior_pics_flag = 0;
504 ff_hevc_clear_refs(s);
506 pix_fmt = get_format(s, sps);
510 ret = set_sps(s, sps, pix_fmt);
514 s->seq_decode = (s->seq_decode + 1) & 0xff;
518 sh->dependent_slice_segment_flag = 0;
519 if (!sh->first_slice_in_pic_flag) {
520 int slice_address_length;
522 if (s->ps.pps->dependent_slice_segments_enabled_flag)
523 sh->dependent_slice_segment_flag = get_bits1(gb);
525 slice_address_length = av_ceil_log2(s->ps.sps->ctb_width *
526 s->ps.sps->ctb_height);
527 sh->slice_segment_addr = get_bitsz(gb, slice_address_length);
528 if (sh->slice_segment_addr >= s->ps.sps->ctb_width * s->ps.sps->ctb_height) {
529 av_log(s->avctx, AV_LOG_ERROR,
530 "Invalid slice segment address: %u.\n",
531 sh->slice_segment_addr);
532 return AVERROR_INVALIDDATA;
535 if (!sh->dependent_slice_segment_flag) {
536 sh->slice_addr = sh->slice_segment_addr;
540 sh->slice_segment_addr = sh->slice_addr = 0;
542 s->slice_initialized = 0;
545 if (!sh->dependent_slice_segment_flag) {
546 s->slice_initialized = 0;
548 for (i = 0; i < s->ps.pps->num_extra_slice_header_bits; i++)
549 skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
551 sh->slice_type = get_ue_golomb_long(gb);
552 if (!(sh->slice_type == HEVC_SLICE_I ||
553 sh->slice_type == HEVC_SLICE_P ||
554 sh->slice_type == HEVC_SLICE_B)) {
555 av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
557 return AVERROR_INVALIDDATA;
559 if (IS_IRAP(s) && sh->slice_type != HEVC_SLICE_I) {
560 av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
561 return AVERROR_INVALIDDATA;
564 // when flag is not present, picture is inferred to be output
565 sh->pic_output_flag = 1;
566 if (s->ps.pps->output_flag_present_flag)
567 sh->pic_output_flag = get_bits1(gb);
569 if (s->ps.sps->separate_colour_plane_flag)
570 sh->colour_plane_id = get_bits(gb, 2);
575 sh->pic_order_cnt_lsb = get_bits(gb, s->ps.sps->log2_max_poc_lsb);
576 poc = ff_hevc_compute_poc(s->ps.sps, s->pocTid0, sh->pic_order_cnt_lsb, s->nal_unit_type);
577 if (!sh->first_slice_in_pic_flag && poc != s->poc) {
578 av_log(s->avctx, AV_LOG_WARNING,
579 "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
580 if (s->avctx->err_recognition & AV_EF_EXPLODE)
581 return AVERROR_INVALIDDATA;
586 sh->short_term_ref_pic_set_sps_flag = get_bits1(gb);
587 pos = get_bits_left(gb);
588 if (!sh->short_term_ref_pic_set_sps_flag) {
589 ret = ff_hevc_decode_short_term_rps(gb, s->avctx, &sh->slice_rps, s->ps.sps, 1);
593 sh->short_term_rps = &sh->slice_rps;
595 int numbits, rps_idx;
597 if (!s->ps.sps->nb_st_rps) {
598 av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
599 return AVERROR_INVALIDDATA;
602 numbits = av_ceil_log2(s->ps.sps->nb_st_rps);
603 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
604 sh->short_term_rps = &s->ps.sps->st_rps[rps_idx];
606 sh->short_term_ref_pic_set_size = pos - get_bits_left(gb);
608 pos = get_bits_left(gb);
609 ret = decode_lt_rps(s, &sh->long_term_rps, gb);
611 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
612 if (s->avctx->err_recognition & AV_EF_EXPLODE)
613 return AVERROR_INVALIDDATA;
615 sh->long_term_ref_pic_set_size = pos - get_bits_left(gb);
617 if (s->ps.sps->sps_temporal_mvp_enabled_flag)
618 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
620 sh->slice_temporal_mvp_enabled_flag = 0;
622 s->sh.short_term_rps = NULL;
627 if (sh->first_slice_in_pic_flag && s->temporal_id == 0 &&
628 s->nal_unit_type != HEVC_NAL_TRAIL_N &&
629 s->nal_unit_type != HEVC_NAL_TSA_N &&
630 s->nal_unit_type != HEVC_NAL_STSA_N &&
631 s->nal_unit_type != HEVC_NAL_RADL_N &&
632 s->nal_unit_type != HEVC_NAL_RADL_R &&
633 s->nal_unit_type != HEVC_NAL_RASL_N &&
634 s->nal_unit_type != HEVC_NAL_RASL_R)
637 if (s->ps.sps->sao_enabled) {
638 sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
639 if (s->ps.sps->chroma_format_idc) {
640 sh->slice_sample_adaptive_offset_flag[1] =
641 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
644 sh->slice_sample_adaptive_offset_flag[0] = 0;
645 sh->slice_sample_adaptive_offset_flag[1] = 0;
646 sh->slice_sample_adaptive_offset_flag[2] = 0;
649 sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
650 if (sh->slice_type == HEVC_SLICE_P || sh->slice_type == HEVC_SLICE_B) {
653 sh->nb_refs[L0] = s->ps.pps->num_ref_idx_l0_default_active;
654 if (sh->slice_type == HEVC_SLICE_B)
655 sh->nb_refs[L1] = s->ps.pps->num_ref_idx_l1_default_active;
657 if (get_bits1(gb)) { // num_ref_idx_active_override_flag
658 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
659 if (sh->slice_type == HEVC_SLICE_B)
660 sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
662 if (sh->nb_refs[L0] > HEVC_MAX_REFS || sh->nb_refs[L1] > HEVC_MAX_REFS) {
663 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
664 sh->nb_refs[L0], sh->nb_refs[L1]);
665 return AVERROR_INVALIDDATA;
668 sh->rpl_modification_flag[0] = 0;
669 sh->rpl_modification_flag[1] = 0;
670 nb_refs = ff_hevc_frame_nb_refs(s);
672 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
673 return AVERROR_INVALIDDATA;
676 if (s->ps.pps->lists_modification_present_flag && nb_refs > 1) {
677 sh->rpl_modification_flag[0] = get_bits1(gb);
678 if (sh->rpl_modification_flag[0]) {
679 for (i = 0; i < sh->nb_refs[L0]; i++)
680 sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
683 if (sh->slice_type == HEVC_SLICE_B) {
684 sh->rpl_modification_flag[1] = get_bits1(gb);
685 if (sh->rpl_modification_flag[1] == 1)
686 for (i = 0; i < sh->nb_refs[L1]; i++)
687 sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
691 if (sh->slice_type == HEVC_SLICE_B)
692 sh->mvd_l1_zero_flag = get_bits1(gb);
694 if (s->ps.pps->cabac_init_present_flag)
695 sh->cabac_init_flag = get_bits1(gb);
697 sh->cabac_init_flag = 0;
699 sh->collocated_ref_idx = 0;
700 if (sh->slice_temporal_mvp_enabled_flag) {
701 sh->collocated_list = L0;
702 if (sh->slice_type == HEVC_SLICE_B)
703 sh->collocated_list = !get_bits1(gb);
705 if (sh->nb_refs[sh->collocated_list] > 1) {
706 sh->collocated_ref_idx = get_ue_golomb_long(gb);
707 if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
708 av_log(s->avctx, AV_LOG_ERROR,
709 "Invalid collocated_ref_idx: %d.\n",
710 sh->collocated_ref_idx);
711 return AVERROR_INVALIDDATA;
716 if ((s->ps.pps->weighted_pred_flag && sh->slice_type == HEVC_SLICE_P) ||
717 (s->ps.pps->weighted_bipred_flag && sh->slice_type == HEVC_SLICE_B)) {
718 int ret = pred_weight_table(s, gb);
723 sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
724 if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
725 av_log(s->avctx, AV_LOG_ERROR,
726 "Invalid number of merging MVP candidates: %d.\n",
727 sh->max_num_merge_cand);
728 return AVERROR_INVALIDDATA;
732 sh->slice_qp_delta = get_se_golomb(gb);
734 if (s->ps.pps->pic_slice_level_chroma_qp_offsets_present_flag) {
735 sh->slice_cb_qp_offset = get_se_golomb(gb);
736 sh->slice_cr_qp_offset = get_se_golomb(gb);
738 sh->slice_cb_qp_offset = 0;
739 sh->slice_cr_qp_offset = 0;
742 if (s->ps.pps->chroma_qp_offset_list_enabled_flag)
743 sh->cu_chroma_qp_offset_enabled_flag = get_bits1(gb);
745 sh->cu_chroma_qp_offset_enabled_flag = 0;
747 if (s->ps.pps->deblocking_filter_control_present_flag) {
748 int deblocking_filter_override_flag = 0;
750 if (s->ps.pps->deblocking_filter_override_enabled_flag)
751 deblocking_filter_override_flag = get_bits1(gb);
753 if (deblocking_filter_override_flag) {
754 sh->disable_deblocking_filter_flag = get_bits1(gb);
755 if (!sh->disable_deblocking_filter_flag) {
756 int beta_offset_div2 = get_se_golomb(gb);
757 int tc_offset_div2 = get_se_golomb(gb) ;
758 if (beta_offset_div2 < -6 || beta_offset_div2 > 6 ||
759 tc_offset_div2 < -6 || tc_offset_div2 > 6) {
760 av_log(s->avctx, AV_LOG_ERROR,
761 "Invalid deblock filter offsets: %d, %d\n",
762 beta_offset_div2, tc_offset_div2);
763 return AVERROR_INVALIDDATA;
765 sh->beta_offset = beta_offset_div2 * 2;
766 sh->tc_offset = tc_offset_div2 * 2;
769 sh->disable_deblocking_filter_flag = s->ps.pps->disable_dbf;
770 sh->beta_offset = s->ps.pps->beta_offset;
771 sh->tc_offset = s->ps.pps->tc_offset;
774 sh->disable_deblocking_filter_flag = 0;
779 if (s->ps.pps->seq_loop_filter_across_slices_enabled_flag &&
780 (sh->slice_sample_adaptive_offset_flag[0] ||
781 sh->slice_sample_adaptive_offset_flag[1] ||
782 !sh->disable_deblocking_filter_flag)) {
783 sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
785 sh->slice_loop_filter_across_slices_enabled_flag = s->ps.pps->seq_loop_filter_across_slices_enabled_flag;
787 } else if (!s->slice_initialized) {
788 av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
789 return AVERROR_INVALIDDATA;
792 sh->num_entry_point_offsets = 0;
793 if (s->ps.pps->tiles_enabled_flag || s->ps.pps->entropy_coding_sync_enabled_flag) {
794 unsigned num_entry_point_offsets = get_ue_golomb_long(gb);
795 // It would be possible to bound this tighter but this here is simpler
796 if (num_entry_point_offsets > get_bits_left(gb)) {
797 av_log(s->avctx, AV_LOG_ERROR, "num_entry_point_offsets %d is invalid\n", num_entry_point_offsets);
798 return AVERROR_INVALIDDATA;
801 sh->num_entry_point_offsets = num_entry_point_offsets;
802 if (sh->num_entry_point_offsets > 0) {
803 int offset_len = get_ue_golomb_long(gb) + 1;
805 if (offset_len < 1 || offset_len > 32) {
806 sh->num_entry_point_offsets = 0;
807 av_log(s->avctx, AV_LOG_ERROR, "offset_len %d is invalid\n", offset_len);
808 return AVERROR_INVALIDDATA;
811 av_freep(&sh->entry_point_offset);
812 av_freep(&sh->offset);
814 sh->entry_point_offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(unsigned));
815 sh->offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
816 sh->size = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
817 if (!sh->entry_point_offset || !sh->offset || !sh->size) {
818 sh->num_entry_point_offsets = 0;
819 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate memory\n");
820 return AVERROR(ENOMEM);
822 for (i = 0; i < sh->num_entry_point_offsets; i++) {
823 unsigned val = get_bits_long(gb, offset_len);
824 sh->entry_point_offset[i] = val + 1; // +1; // +1 to get the size
826 if (s->threads_number > 1 && (s->ps.pps->num_tile_rows > 1 || s->ps.pps->num_tile_columns > 1)) {
827 s->enable_parallel_tiles = 0; // TODO: you can enable tiles in parallel here
828 s->threads_number = 1;
830 s->enable_parallel_tiles = 0;
832 s->enable_parallel_tiles = 0;
835 if (s->ps.pps->slice_header_extension_present_flag) {
836 unsigned int length = get_ue_golomb_long(gb);
837 if (length*8LL > get_bits_left(gb)) {
838 av_log(s->avctx, AV_LOG_ERROR, "too many slice_header_extension_data_bytes\n");
839 return AVERROR_INVALIDDATA;
841 for (i = 0; i < length; i++)
842 skip_bits(gb, 8); // slice_header_extension_data_byte
845 // Inferred parameters
846 sh->slice_qp = 26U + s->ps.pps->pic_init_qp_minus26 + sh->slice_qp_delta;
847 if (sh->slice_qp > 51 ||
848 sh->slice_qp < -s->ps.sps->qp_bd_offset) {
849 av_log(s->avctx, AV_LOG_ERROR,
850 "The slice_qp %d is outside the valid range "
853 -s->ps.sps->qp_bd_offset);
854 return AVERROR_INVALIDDATA;
857 sh->slice_ctb_addr_rs = sh->slice_segment_addr;
859 if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) {
860 av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
861 return AVERROR_INVALIDDATA;
864 if (get_bits_left(gb) < 0) {
865 av_log(s->avctx, AV_LOG_ERROR,
866 "Overread slice header by %d bits\n", -get_bits_left(gb));
867 return AVERROR_INVALIDDATA;
870 s->HEVClc->first_qp_group = !s->sh.dependent_slice_segment_flag;
872 if (!s->ps.pps->cu_qp_delta_enabled_flag)
873 s->HEVClc->qp_y = s->sh.slice_qp;
875 s->slice_initialized = 1;
876 s->HEVClc->tu.cu_qp_offset_cb = 0;
877 s->HEVClc->tu.cu_qp_offset_cr = 0;
882 #define CTB(tab, x, y) ((tab)[(y) * s->ps.sps->ctb_width + (x)])
884 #define SET_SAO(elem, value) \
886 if (!sao_merge_up_flag && !sao_merge_left_flag) \
888 else if (sao_merge_left_flag) \
889 sao->elem = CTB(s->sao, rx-1, ry).elem; \
890 else if (sao_merge_up_flag) \
891 sao->elem = CTB(s->sao, rx, ry-1).elem; \
896 static void hls_sao_param(HEVCContext *s, int rx, int ry)
898 HEVCLocalContext *lc = s->HEVClc;
899 int sao_merge_left_flag = 0;
900 int sao_merge_up_flag = 0;
901 SAOParams *sao = &CTB(s->sao, rx, ry);
904 if (s->sh.slice_sample_adaptive_offset_flag[0] ||
905 s->sh.slice_sample_adaptive_offset_flag[1]) {
907 if (lc->ctb_left_flag)
908 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
910 if (ry > 0 && !sao_merge_left_flag) {
912 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
916 for (c_idx = 0; c_idx < (s->ps.sps->chroma_format_idc ? 3 : 1); c_idx++) {
917 int log2_sao_offset_scale = c_idx == 0 ? s->ps.pps->log2_sao_offset_scale_luma :
918 s->ps.pps->log2_sao_offset_scale_chroma;
920 if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
921 sao->type_idx[c_idx] = SAO_NOT_APPLIED;
926 sao->type_idx[2] = sao->type_idx[1];
927 sao->eo_class[2] = sao->eo_class[1];
929 SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
932 if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
935 for (i = 0; i < 4; i++)
936 SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
938 if (sao->type_idx[c_idx] == SAO_BAND) {
939 for (i = 0; i < 4; i++) {
940 if (sao->offset_abs[c_idx][i]) {
941 SET_SAO(offset_sign[c_idx][i],
942 ff_hevc_sao_offset_sign_decode(s));
944 sao->offset_sign[c_idx][i] = 0;
947 SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
948 } else if (c_idx != 2) {
949 SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
952 // Inferred parameters
953 sao->offset_val[c_idx][0] = 0;
954 for (i = 0; i < 4; i++) {
955 sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i];
956 if (sao->type_idx[c_idx] == SAO_EDGE) {
958 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
959 } else if (sao->offset_sign[c_idx][i]) {
960 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
962 sao->offset_val[c_idx][i + 1] *= 1 << log2_sao_offset_scale;
970 static int hls_cross_component_pred(HEVCContext *s, int idx) {
971 HEVCLocalContext *lc = s->HEVClc;
972 int log2_res_scale_abs_plus1 = ff_hevc_log2_res_scale_abs(s, idx);
974 if (log2_res_scale_abs_plus1 != 0) {
975 int res_scale_sign_flag = ff_hevc_res_scale_sign_flag(s, idx);
976 lc->tu.res_scale_val = (1 << (log2_res_scale_abs_plus1 - 1)) *
977 (1 - 2 * res_scale_sign_flag);
979 lc->tu.res_scale_val = 0;
986 static int hls_transform_unit(HEVCContext *s, int x0, int y0,
987 int xBase, int yBase, int cb_xBase, int cb_yBase,
988 int log2_cb_size, int log2_trafo_size,
989 int blk_idx, int cbf_luma, int *cbf_cb, int *cbf_cr)
991 HEVCLocalContext *lc = s->HEVClc;
992 const int log2_trafo_size_c = log2_trafo_size - s->ps.sps->hshift[1];
995 if (lc->cu.pred_mode == MODE_INTRA) {
996 int trafo_size = 1 << log2_trafo_size;
997 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
999 s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
1002 if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
1003 (s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1004 int scan_idx = SCAN_DIAG;
1005 int scan_idx_c = SCAN_DIAG;
1006 int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
1007 (s->ps.sps->chroma_format_idc == 2 &&
1008 (cbf_cb[1] || cbf_cr[1]));
1010 if (s->ps.pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
1011 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
1012 if (lc->tu.cu_qp_delta != 0)
1013 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
1014 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
1015 lc->tu.is_cu_qp_delta_coded = 1;
1017 if (lc->tu.cu_qp_delta < -(26 + s->ps.sps->qp_bd_offset / 2) ||
1018 lc->tu.cu_qp_delta > (25 + s->ps.sps->qp_bd_offset / 2)) {
1019 av_log(s->avctx, AV_LOG_ERROR,
1020 "The cu_qp_delta %d is outside the valid range "
1023 -(26 + s->ps.sps->qp_bd_offset / 2),
1024 (25 + s->ps.sps->qp_bd_offset / 2));
1025 return AVERROR_INVALIDDATA;
1028 ff_hevc_set_qPy(s, cb_xBase, cb_yBase, log2_cb_size);
1031 if (s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
1032 !lc->cu.cu_transquant_bypass_flag && !lc->tu.is_cu_chroma_qp_offset_coded) {
1033 int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(s);
1034 if (cu_chroma_qp_offset_flag) {
1035 int cu_chroma_qp_offset_idx = 0;
1036 if (s->ps.pps->chroma_qp_offset_list_len_minus1 > 0) {
1037 cu_chroma_qp_offset_idx = ff_hevc_cu_chroma_qp_offset_idx(s);
1038 av_log(s->avctx, AV_LOG_ERROR,
1039 "cu_chroma_qp_offset_idx not yet tested.\n");
1041 lc->tu.cu_qp_offset_cb = s->ps.pps->cb_qp_offset_list[cu_chroma_qp_offset_idx];
1042 lc->tu.cu_qp_offset_cr = s->ps.pps->cr_qp_offset_list[cu_chroma_qp_offset_idx];
1044 lc->tu.cu_qp_offset_cb = 0;
1045 lc->tu.cu_qp_offset_cr = 0;
1047 lc->tu.is_cu_chroma_qp_offset_coded = 1;
1050 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
1051 if (lc->tu.intra_pred_mode >= 6 &&
1052 lc->tu.intra_pred_mode <= 14) {
1053 scan_idx = SCAN_VERT;
1054 } else if (lc->tu.intra_pred_mode >= 22 &&
1055 lc->tu.intra_pred_mode <= 30) {
1056 scan_idx = SCAN_HORIZ;
1059 if (lc->tu.intra_pred_mode_c >= 6 &&
1060 lc->tu.intra_pred_mode_c <= 14) {
1061 scan_idx_c = SCAN_VERT;
1062 } else if (lc->tu.intra_pred_mode_c >= 22 &&
1063 lc->tu.intra_pred_mode_c <= 30) {
1064 scan_idx_c = SCAN_HORIZ;
1068 lc->tu.cross_pf = 0;
1071 ff_hevc_hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
1072 if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) {
1073 int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]);
1074 int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]);
1075 lc->tu.cross_pf = (s->ps.pps->cross_component_prediction_enabled_flag && cbf_luma &&
1076 (lc->cu.pred_mode == MODE_INTER ||
1077 (lc->tu.chroma_mode_c == 4)));
1079 if (lc->tu.cross_pf) {
1080 hls_cross_component_pred(s, 0);
1082 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1083 if (lc->cu.pred_mode == MODE_INTRA) {
1084 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1085 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 1);
1088 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1089 log2_trafo_size_c, scan_idx_c, 1);
1091 if (lc->tu.cross_pf) {
1092 ptrdiff_t stride = s->frame->linesize[1];
1093 int hshift = s->ps.sps->hshift[1];
1094 int vshift = s->ps.sps->vshift[1];
1095 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1096 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1097 int size = 1 << log2_trafo_size_c;
1099 uint8_t *dst = &s->frame->data[1][(y0 >> vshift) * stride +
1100 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1101 for (i = 0; i < (size * size); i++) {
1102 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1104 s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
1108 if (lc->tu.cross_pf) {
1109 hls_cross_component_pred(s, 1);
1111 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1112 if (lc->cu.pred_mode == MODE_INTRA) {
1113 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1114 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 2);
1117 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1118 log2_trafo_size_c, scan_idx_c, 2);
1120 if (lc->tu.cross_pf) {
1121 ptrdiff_t stride = s->frame->linesize[2];
1122 int hshift = s->ps.sps->hshift[2];
1123 int vshift = s->ps.sps->vshift[2];
1124 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1125 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1126 int size = 1 << log2_trafo_size_c;
1128 uint8_t *dst = &s->frame->data[2][(y0 >> vshift) * stride +
1129 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1130 for (i = 0; i < (size * size); i++) {
1131 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1133 s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
1136 } else if (s->ps.sps->chroma_format_idc && blk_idx == 3) {
1137 int trafo_size_h = 1 << (log2_trafo_size + 1);
1138 int trafo_size_v = 1 << (log2_trafo_size + s->ps.sps->vshift[1]);
1139 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1140 if (lc->cu.pred_mode == MODE_INTRA) {
1141 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1142 trafo_size_h, trafo_size_v);
1143 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 1);
1146 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1147 log2_trafo_size, scan_idx_c, 1);
1149 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1150 if (lc->cu.pred_mode == MODE_INTRA) {
1151 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1152 trafo_size_h, trafo_size_v);
1153 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 2);
1156 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1157 log2_trafo_size, scan_idx_c, 2);
1160 } else if (s->ps.sps->chroma_format_idc && lc->cu.pred_mode == MODE_INTRA) {
1161 if (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3) {
1162 int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]);
1163 int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]);
1164 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size_h, trafo_size_v);
1165 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 1);
1166 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 2);
1167 if (s->ps.sps->chroma_format_idc == 2) {
1168 ff_hevc_set_neighbour_available(s, x0, y0 + (1 << log2_trafo_size_c),
1169 trafo_size_h, trafo_size_v);
1170 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 1);
1171 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 2);
1173 } else if (blk_idx == 3) {
1174 int trafo_size_h = 1 << (log2_trafo_size + 1);
1175 int trafo_size_v = 1 << (log2_trafo_size + s->ps.sps->vshift[1]);
1176 ff_hevc_set_neighbour_available(s, xBase, yBase,
1177 trafo_size_h, trafo_size_v);
1178 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1179 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1180 if (s->ps.sps->chroma_format_idc == 2) {
1181 ff_hevc_set_neighbour_available(s, xBase, yBase + (1 << (log2_trafo_size)),
1182 trafo_size_h, trafo_size_v);
1183 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 1);
1184 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 2);
1192 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1194 int cb_size = 1 << log2_cb_size;
1195 int log2_min_pu_size = s->ps.sps->log2_min_pu_size;
1197 int min_pu_width = s->ps.sps->min_pu_width;
1198 int x_end = FFMIN(x0 + cb_size, s->ps.sps->width);
1199 int y_end = FFMIN(y0 + cb_size, s->ps.sps->height);
1202 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1203 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1204 s->is_pcm[i + j * min_pu_width] = 2;
1207 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1208 int xBase, int yBase, int cb_xBase, int cb_yBase,
1209 int log2_cb_size, int log2_trafo_size,
1210 int trafo_depth, int blk_idx,
1211 const int *base_cbf_cb, const int *base_cbf_cr)
1213 HEVCLocalContext *lc = s->HEVClc;
1214 uint8_t split_transform_flag;
1219 cbf_cb[0] = base_cbf_cb[0];
1220 cbf_cb[1] = base_cbf_cb[1];
1221 cbf_cr[0] = base_cbf_cr[0];
1222 cbf_cr[1] = base_cbf_cr[1];
1224 if (lc->cu.intra_split_flag) {
1225 if (trafo_depth == 1) {
1226 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1227 if (s->ps.sps->chroma_format_idc == 3) {
1228 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[blk_idx];
1229 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[blk_idx];
1231 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1232 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1236 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[0];
1237 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1238 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1241 if (log2_trafo_size <= s->ps.sps->log2_max_trafo_size &&
1242 log2_trafo_size > s->ps.sps->log2_min_tb_size &&
1243 trafo_depth < lc->cu.max_trafo_depth &&
1244 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1245 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1247 int inter_split = s->ps.sps->max_transform_hierarchy_depth_inter == 0 &&
1248 lc->cu.pred_mode == MODE_INTER &&
1249 lc->cu.part_mode != PART_2Nx2N &&
1252 split_transform_flag = log2_trafo_size > s->ps.sps->log2_max_trafo_size ||
1253 (lc->cu.intra_split_flag && trafo_depth == 0) ||
1257 if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) {
1258 if (trafo_depth == 0 || cbf_cb[0]) {
1259 cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1260 if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1261 cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1265 if (trafo_depth == 0 || cbf_cr[0]) {
1266 cbf_cr[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1267 if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1268 cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1273 if (split_transform_flag) {
1274 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1275 const int x1 = x0 + trafo_size_split;
1276 const int y1 = y0 + trafo_size_split;
1278 #define SUBDIVIDE(x, y, idx) \
1280 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1281 log2_trafo_size - 1, trafo_depth + 1, idx, \
1287 SUBDIVIDE(x0, y0, 0);
1288 SUBDIVIDE(x1, y0, 1);
1289 SUBDIVIDE(x0, y1, 2);
1290 SUBDIVIDE(x1, y1, 3);
1294 int min_tu_size = 1 << s->ps.sps->log2_min_tb_size;
1295 int log2_min_tu_size = s->ps.sps->log2_min_tb_size;
1296 int min_tu_width = s->ps.sps->min_tb_width;
1299 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1300 cbf_cb[0] || cbf_cr[0] ||
1301 (s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1302 cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1305 ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1306 log2_cb_size, log2_trafo_size,
1307 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1310 // TODO: store cbf_luma somewhere else
1313 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1314 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1315 int x_tu = (x0 + j) >> log2_min_tu_size;
1316 int y_tu = (y0 + i) >> log2_min_tu_size;
1317 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1320 if (!s->sh.disable_deblocking_filter_flag) {
1321 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1322 if (s->ps.pps->transquant_bypass_enable_flag &&
1323 lc->cu.cu_transquant_bypass_flag)
1324 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1330 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1332 HEVCLocalContext *lc = s->HEVClc;
1334 int cb_size = 1 << log2_cb_size;
1335 ptrdiff_t stride0 = s->frame->linesize[0];
1336 ptrdiff_t stride1 = s->frame->linesize[1];
1337 ptrdiff_t stride2 = s->frame->linesize[2];
1338 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->ps.sps->pixel_shift)];
1339 uint8_t *dst1 = &s->frame->data[1][(y0 >> s->ps.sps->vshift[1]) * stride1 + ((x0 >> s->ps.sps->hshift[1]) << s->ps.sps->pixel_shift)];
1340 uint8_t *dst2 = &s->frame->data[2][(y0 >> s->ps.sps->vshift[2]) * stride2 + ((x0 >> s->ps.sps->hshift[2]) << s->ps.sps->pixel_shift)];
1342 int length = cb_size * cb_size * s->ps.sps->pcm.bit_depth +
1343 (((cb_size >> s->ps.sps->hshift[1]) * (cb_size >> s->ps.sps->vshift[1])) +
1344 ((cb_size >> s->ps.sps->hshift[2]) * (cb_size >> s->ps.sps->vshift[2]))) *
1345 s->ps.sps->pcm.bit_depth_chroma;
1346 const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1349 if (!s->sh.disable_deblocking_filter_flag)
1350 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1352 ret = init_get_bits(&gb, pcm, length);
1356 s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size, &gb, s->ps.sps->pcm.bit_depth);
1357 if (s->ps.sps->chroma_format_idc) {
1358 s->hevcdsp.put_pcm(dst1, stride1,
1359 cb_size >> s->ps.sps->hshift[1],
1360 cb_size >> s->ps.sps->vshift[1],
1361 &gb, s->ps.sps->pcm.bit_depth_chroma);
1362 s->hevcdsp.put_pcm(dst2, stride2,
1363 cb_size >> s->ps.sps->hshift[2],
1364 cb_size >> s->ps.sps->vshift[2],
1365 &gb, s->ps.sps->pcm.bit_depth_chroma);
1372 * 8.5.3.2.2.1 Luma sample unidirectional interpolation process
1374 * @param s HEVC decoding context
1375 * @param dst target buffer for block data at block position
1376 * @param dststride stride of the dst buffer
1377 * @param ref reference picture buffer at origin (0, 0)
1378 * @param mv motion vector (relative to block position) to get pixel data from
1379 * @param x_off horizontal position of block from origin (0, 0)
1380 * @param y_off vertical position of block from origin (0, 0)
1381 * @param block_w width of block
1382 * @param block_h height of block
1383 * @param luma_weight weighting factor applied to the luma prediction
1384 * @param luma_offset additive offset applied to the luma prediction value
1387 static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1388 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1389 int block_w, int block_h, int luma_weight, int luma_offset)
1391 HEVCLocalContext *lc = s->HEVClc;
1392 uint8_t *src = ref->data[0];
1393 ptrdiff_t srcstride = ref->linesize[0];
1394 int pic_width = s->ps.sps->width;
1395 int pic_height = s->ps.sps->height;
1398 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1399 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1400 int idx = ff_hevc_pel_weight[block_w];
1402 x_off += mv->x >> 2;
1403 y_off += mv->y >> 2;
1404 src += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1406 if (x_off < QPEL_EXTRA_BEFORE || y_off < QPEL_EXTRA_AFTER ||
1407 x_off >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1408 y_off >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1409 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1410 int offset = QPEL_EXTRA_BEFORE * srcstride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1411 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1413 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1414 edge_emu_stride, srcstride,
1415 block_w + QPEL_EXTRA,
1416 block_h + QPEL_EXTRA,
1417 x_off - QPEL_EXTRA_BEFORE, y_off - QPEL_EXTRA_BEFORE,
1418 pic_width, pic_height);
1419 src = lc->edge_emu_buffer + buf_offset;
1420 srcstride = edge_emu_stride;
1424 s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride, src, srcstride,
1425 block_h, mx, my, block_w);
1427 s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride, src, srcstride,
1428 block_h, s->sh.luma_log2_weight_denom,
1429 luma_weight, luma_offset, mx, my, block_w);
1433 * 8.5.3.2.2.1 Luma sample bidirectional interpolation process
1435 * @param s HEVC decoding context
1436 * @param dst target buffer for block data at block position
1437 * @param dststride stride of the dst buffer
1438 * @param ref0 reference picture0 buffer at origin (0, 0)
1439 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1440 * @param x_off horizontal position of block from origin (0, 0)
1441 * @param y_off vertical position of block from origin (0, 0)
1442 * @param block_w width of block
1443 * @param block_h height of block
1444 * @param ref1 reference picture1 buffer at origin (0, 0)
1445 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1446 * @param current_mv current motion vector structure
1448 static void luma_mc_bi(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1449 AVFrame *ref0, const Mv *mv0, int x_off, int y_off,
1450 int block_w, int block_h, AVFrame *ref1, const Mv *mv1, struct MvField *current_mv)
1452 HEVCLocalContext *lc = s->HEVClc;
1453 ptrdiff_t src0stride = ref0->linesize[0];
1454 ptrdiff_t src1stride = ref1->linesize[0];
1455 int pic_width = s->ps.sps->width;
1456 int pic_height = s->ps.sps->height;
1457 int mx0 = mv0->x & 3;
1458 int my0 = mv0->y & 3;
1459 int mx1 = mv1->x & 3;
1460 int my1 = mv1->y & 3;
1461 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1462 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1463 int x_off0 = x_off + (mv0->x >> 2);
1464 int y_off0 = y_off + (mv0->y >> 2);
1465 int x_off1 = x_off + (mv1->x >> 2);
1466 int y_off1 = y_off + (mv1->y >> 2);
1467 int idx = ff_hevc_pel_weight[block_w];
1469 uint8_t *src0 = ref0->data[0] + y_off0 * src0stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift);
1470 uint8_t *src1 = ref1->data[0] + y_off1 * src1stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift);
1472 if (x_off0 < QPEL_EXTRA_BEFORE || y_off0 < QPEL_EXTRA_AFTER ||
1473 x_off0 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1474 y_off0 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1475 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1476 int offset = QPEL_EXTRA_BEFORE * src0stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1477 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1479 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset,
1480 edge_emu_stride, src0stride,
1481 block_w + QPEL_EXTRA,
1482 block_h + QPEL_EXTRA,
1483 x_off0 - QPEL_EXTRA_BEFORE, y_off0 - QPEL_EXTRA_BEFORE,
1484 pic_width, pic_height);
1485 src0 = lc->edge_emu_buffer + buf_offset;
1486 src0stride = edge_emu_stride;
1489 if (x_off1 < QPEL_EXTRA_BEFORE || y_off1 < QPEL_EXTRA_AFTER ||
1490 x_off1 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1491 y_off1 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1492 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1493 int offset = QPEL_EXTRA_BEFORE * src1stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1494 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1496 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src1 - offset,
1497 edge_emu_stride, src1stride,
1498 block_w + QPEL_EXTRA,
1499 block_h + QPEL_EXTRA,
1500 x_off1 - QPEL_EXTRA_BEFORE, y_off1 - QPEL_EXTRA_BEFORE,
1501 pic_width, pic_height);
1502 src1 = lc->edge_emu_buffer2 + buf_offset;
1503 src1stride = edge_emu_stride;
1506 s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](lc->tmp, src0, src0stride,
1507 block_h, mx0, my0, block_w);
1509 s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1510 block_h, mx1, my1, block_w);
1512 s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1513 block_h, s->sh.luma_log2_weight_denom,
1514 s->sh.luma_weight_l0[current_mv->ref_idx[0]],
1515 s->sh.luma_weight_l1[current_mv->ref_idx[1]],
1516 s->sh.luma_offset_l0[current_mv->ref_idx[0]],
1517 s->sh.luma_offset_l1[current_mv->ref_idx[1]],
1523 * 8.5.3.2.2.2 Chroma sample uniprediction interpolation process
1525 * @param s HEVC decoding context
1526 * @param dst1 target buffer for block data at block position (U plane)
1527 * @param dst2 target buffer for block data at block position (V plane)
1528 * @param dststride stride of the dst1 and dst2 buffers
1529 * @param ref reference picture buffer at origin (0, 0)
1530 * @param mv motion vector (relative to block position) to get pixel data from
1531 * @param x_off horizontal position of block from origin (0, 0)
1532 * @param y_off vertical position of block from origin (0, 0)
1533 * @param block_w width of block
1534 * @param block_h height of block
1535 * @param chroma_weight weighting factor applied to the chroma prediction
1536 * @param chroma_offset additive offset applied to the chroma prediction value
1539 static void chroma_mc_uni(HEVCContext *s, uint8_t *dst0,
1540 ptrdiff_t dststride, uint8_t *src0, ptrdiff_t srcstride, int reflist,
1541 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int chroma_weight, int chroma_offset)
1543 HEVCLocalContext *lc = s->HEVClc;
1544 int pic_width = s->ps.sps->width >> s->ps.sps->hshift[1];
1545 int pic_height = s->ps.sps->height >> s->ps.sps->vshift[1];
1546 const Mv *mv = ¤t_mv->mv[reflist];
1547 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1548 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1549 int idx = ff_hevc_pel_weight[block_w];
1550 int hshift = s->ps.sps->hshift[1];
1551 int vshift = s->ps.sps->vshift[1];
1552 intptr_t mx = av_mod_uintp2(mv->x, 2 + hshift);
1553 intptr_t my = av_mod_uintp2(mv->y, 2 + vshift);
1554 intptr_t _mx = mx << (1 - hshift);
1555 intptr_t _my = my << (1 - vshift);
1557 x_off += mv->x >> (2 + hshift);
1558 y_off += mv->y >> (2 + vshift);
1559 src0 += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1561 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1562 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1563 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1564 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1565 int offset0 = EPEL_EXTRA_BEFORE * (srcstride + (1 << s->ps.sps->pixel_shift));
1566 int buf_offset0 = EPEL_EXTRA_BEFORE *
1567 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1568 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset0,
1569 edge_emu_stride, srcstride,
1570 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1571 x_off - EPEL_EXTRA_BEFORE,
1572 y_off - EPEL_EXTRA_BEFORE,
1573 pic_width, pic_height);
1575 src0 = lc->edge_emu_buffer + buf_offset0;
1576 srcstride = edge_emu_stride;
1579 s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1580 block_h, _mx, _my, block_w);
1582 s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1583 block_h, s->sh.chroma_log2_weight_denom,
1584 chroma_weight, chroma_offset, _mx, _my, block_w);
1588 * 8.5.3.2.2.2 Chroma sample bidirectional interpolation process
1590 * @param s HEVC decoding context
1591 * @param dst target buffer for block data at block position
1592 * @param dststride stride of the dst buffer
1593 * @param ref0 reference picture0 buffer at origin (0, 0)
1594 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1595 * @param x_off horizontal position of block from origin (0, 0)
1596 * @param y_off vertical position of block from origin (0, 0)
1597 * @param block_w width of block
1598 * @param block_h height of block
1599 * @param ref1 reference picture1 buffer at origin (0, 0)
1600 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1601 * @param current_mv current motion vector structure
1602 * @param cidx chroma component(cb, cr)
1604 static void chroma_mc_bi(HEVCContext *s, uint8_t *dst0, ptrdiff_t dststride, AVFrame *ref0, AVFrame *ref1,
1605 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int cidx)
1607 HEVCLocalContext *lc = s->HEVClc;
1608 uint8_t *src1 = ref0->data[cidx+1];
1609 uint8_t *src2 = ref1->data[cidx+1];
1610 ptrdiff_t src1stride = ref0->linesize[cidx+1];
1611 ptrdiff_t src2stride = ref1->linesize[cidx+1];
1612 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1613 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1614 int pic_width = s->ps.sps->width >> s->ps.sps->hshift[1];
1615 int pic_height = s->ps.sps->height >> s->ps.sps->vshift[1];
1616 Mv *mv0 = ¤t_mv->mv[0];
1617 Mv *mv1 = ¤t_mv->mv[1];
1618 int hshift = s->ps.sps->hshift[1];
1619 int vshift = s->ps.sps->vshift[1];
1621 intptr_t mx0 = av_mod_uintp2(mv0->x, 2 + hshift);
1622 intptr_t my0 = av_mod_uintp2(mv0->y, 2 + vshift);
1623 intptr_t mx1 = av_mod_uintp2(mv1->x, 2 + hshift);
1624 intptr_t my1 = av_mod_uintp2(mv1->y, 2 + vshift);
1625 intptr_t _mx0 = mx0 << (1 - hshift);
1626 intptr_t _my0 = my0 << (1 - vshift);
1627 intptr_t _mx1 = mx1 << (1 - hshift);
1628 intptr_t _my1 = my1 << (1 - vshift);
1630 int x_off0 = x_off + (mv0->x >> (2 + hshift));
1631 int y_off0 = y_off + (mv0->y >> (2 + vshift));
1632 int x_off1 = x_off + (mv1->x >> (2 + hshift));
1633 int y_off1 = y_off + (mv1->y >> (2 + vshift));
1634 int idx = ff_hevc_pel_weight[block_w];
1635 src1 += y_off0 * src1stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift);
1636 src2 += y_off1 * src2stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift);
1638 if (x_off0 < EPEL_EXTRA_BEFORE || y_off0 < EPEL_EXTRA_AFTER ||
1639 x_off0 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1640 y_off0 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1641 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1642 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->ps.sps->pixel_shift));
1643 int buf_offset1 = EPEL_EXTRA_BEFORE *
1644 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1646 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1647 edge_emu_stride, src1stride,
1648 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1649 x_off0 - EPEL_EXTRA_BEFORE,
1650 y_off0 - EPEL_EXTRA_BEFORE,
1651 pic_width, pic_height);
1653 src1 = lc->edge_emu_buffer + buf_offset1;
1654 src1stride = edge_emu_stride;
1657 if (x_off1 < EPEL_EXTRA_BEFORE || y_off1 < EPEL_EXTRA_AFTER ||
1658 x_off1 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1659 y_off1 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1660 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1661 int offset1 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->ps.sps->pixel_shift));
1662 int buf_offset1 = EPEL_EXTRA_BEFORE *
1663 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1665 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src2 - offset1,
1666 edge_emu_stride, src2stride,
1667 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1668 x_off1 - EPEL_EXTRA_BEFORE,
1669 y_off1 - EPEL_EXTRA_BEFORE,
1670 pic_width, pic_height);
1672 src2 = lc->edge_emu_buffer2 + buf_offset1;
1673 src2stride = edge_emu_stride;
1676 s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](lc->tmp, src1, src1stride,
1677 block_h, _mx0, _my0, block_w);
1679 s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1680 src2, src2stride, lc->tmp,
1681 block_h, _mx1, _my1, block_w);
1683 s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1684 src2, src2stride, lc->tmp,
1686 s->sh.chroma_log2_weight_denom,
1687 s->sh.chroma_weight_l0[current_mv->ref_idx[0]][cidx],
1688 s->sh.chroma_weight_l1[current_mv->ref_idx[1]][cidx],
1689 s->sh.chroma_offset_l0[current_mv->ref_idx[0]][cidx],
1690 s->sh.chroma_offset_l1[current_mv->ref_idx[1]][cidx],
1691 _mx1, _my1, block_w);
1694 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1695 const Mv *mv, int y0, int height)
1697 if (s->threads_type == FF_THREAD_FRAME ) {
1698 int y = FFMAX(0, (mv->y >> 2) + y0 + height + 9);
1700 ff_thread_await_progress(&ref->tf, y, 0);
1704 static void hevc_luma_mv_mvp_mode(HEVCContext *s, int x0, int y0, int nPbW,
1705 int nPbH, int log2_cb_size, int part_idx,
1706 int merge_idx, MvField *mv)
1708 HEVCLocalContext *lc = s->HEVClc;
1709 enum InterPredIdc inter_pred_idc = PRED_L0;
1712 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1714 if (s->sh.slice_type == HEVC_SLICE_B)
1715 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1717 if (inter_pred_idc != PRED_L1) {
1718 if (s->sh.nb_refs[L0])
1719 mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1721 mv->pred_flag = PF_L0;
1722 ff_hevc_hls_mvd_coding(s, x0, y0, 0);
1723 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1724 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1725 part_idx, merge_idx, mv, mvp_flag, 0);
1726 mv->mv[0].x += lc->pu.mvd.x;
1727 mv->mv[0].y += lc->pu.mvd.y;
1730 if (inter_pred_idc != PRED_L0) {
1731 if (s->sh.nb_refs[L1])
1732 mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1734 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1735 AV_ZERO32(&lc->pu.mvd);
1737 ff_hevc_hls_mvd_coding(s, x0, y0, 1);
1740 mv->pred_flag += PF_L1;
1741 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1742 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1743 part_idx, merge_idx, mv, mvp_flag, 1);
1744 mv->mv[1].x += lc->pu.mvd.x;
1745 mv->mv[1].y += lc->pu.mvd.y;
1749 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1751 int log2_cb_size, int partIdx, int idx)
1753 #define POS(c_idx, x, y) \
1754 &s->frame->data[c_idx][((y) >> s->ps.sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1755 (((x) >> s->ps.sps->hshift[c_idx]) << s->ps.sps->pixel_shift)]
1756 HEVCLocalContext *lc = s->HEVClc;
1758 struct MvField current_mv = {{{ 0 }}};
1760 int min_pu_width = s->ps.sps->min_pu_width;
1762 MvField *tab_mvf = s->ref->tab_mvf;
1763 RefPicList *refPicList = s->ref->refPicList;
1764 HEVCFrame *ref0 = NULL, *ref1 = NULL;
1765 uint8_t *dst0 = POS(0, x0, y0);
1766 uint8_t *dst1 = POS(1, x0, y0);
1767 uint8_t *dst2 = POS(2, x0, y0);
1768 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
1769 int min_cb_width = s->ps.sps->min_cb_width;
1770 int x_cb = x0 >> log2_min_cb_size;
1771 int y_cb = y0 >> log2_min_cb_size;
1775 int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1778 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1780 if (skip_flag || lc->pu.merge_flag) {
1781 if (s->sh.max_num_merge_cand > 1)
1782 merge_idx = ff_hevc_merge_idx_decode(s);
1786 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1787 partIdx, merge_idx, ¤t_mv);
1789 hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1790 partIdx, merge_idx, ¤t_mv);
1793 x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1794 y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1796 for (j = 0; j < nPbH >> s->ps.sps->log2_min_pu_size; j++)
1797 for (i = 0; i < nPbW >> s->ps.sps->log2_min_pu_size; i++)
1798 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1800 if (current_mv.pred_flag & PF_L0) {
1801 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1804 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1806 if (current_mv.pred_flag & PF_L1) {
1807 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1810 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1813 if (current_mv.pred_flag == PF_L0) {
1814 int x0_c = x0 >> s->ps.sps->hshift[1];
1815 int y0_c = y0 >> s->ps.sps->vshift[1];
1816 int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1817 int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1819 luma_mc_uni(s, dst0, s->frame->linesize[0], ref0->frame,
1820 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1821 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1822 s->sh.luma_offset_l0[current_mv.ref_idx[0]]);
1824 if (s->ps.sps->chroma_format_idc) {
1825 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref0->frame->data[1], ref0->frame->linesize[1],
1826 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1827 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]);
1828 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref0->frame->data[2], ref0->frame->linesize[2],
1829 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1830 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]);
1832 } else if (current_mv.pred_flag == PF_L1) {
1833 int x0_c = x0 >> s->ps.sps->hshift[1];
1834 int y0_c = y0 >> s->ps.sps->vshift[1];
1835 int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1836 int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1838 luma_mc_uni(s, dst0, s->frame->linesize[0], ref1->frame,
1839 ¤t_mv.mv[1], x0, y0, nPbW, nPbH,
1840 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1841 s->sh.luma_offset_l1[current_mv.ref_idx[1]]);
1843 if (s->ps.sps->chroma_format_idc) {
1844 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
1845 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1846 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]);
1848 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
1849 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1850 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]);
1852 } else if (current_mv.pred_flag == PF_BI) {
1853 int x0_c = x0 >> s->ps.sps->hshift[1];
1854 int y0_c = y0 >> s->ps.sps->vshift[1];
1855 int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1856 int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1858 luma_mc_bi(s, dst0, s->frame->linesize[0], ref0->frame,
1859 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1860 ref1->frame, ¤t_mv.mv[1], ¤t_mv);
1862 if (s->ps.sps->chroma_format_idc) {
1863 chroma_mc_bi(s, dst1, s->frame->linesize[1], ref0->frame, ref1->frame,
1864 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 0);
1866 chroma_mc_bi(s, dst2, s->frame->linesize[2], ref0->frame, ref1->frame,
1867 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1);
1875 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1876 int prev_intra_luma_pred_flag)
1878 HEVCLocalContext *lc = s->HEVClc;
1879 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1880 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1881 int min_pu_width = s->ps.sps->min_pu_width;
1882 int size_in_pus = pu_size >> s->ps.sps->log2_min_pu_size;
1883 int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
1884 int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
1886 int cand_up = (lc->ctb_up_flag || y0b) ?
1887 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1888 int cand_left = (lc->ctb_left_flag || x0b) ?
1889 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1891 int y_ctb = (y0 >> (s->ps.sps->log2_ctb_size)) << (s->ps.sps->log2_ctb_size);
1893 MvField *tab_mvf = s->ref->tab_mvf;
1894 int intra_pred_mode;
1898 // intra_pred_mode prediction does not cross vertical CTB boundaries
1899 if ((y0 - 1) < y_ctb)
1902 if (cand_left == cand_up) {
1903 if (cand_left < 2) {
1904 candidate[0] = INTRA_PLANAR;
1905 candidate[1] = INTRA_DC;
1906 candidate[2] = INTRA_ANGULAR_26;
1908 candidate[0] = cand_left;
1909 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1910 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1913 candidate[0] = cand_left;
1914 candidate[1] = cand_up;
1915 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1916 candidate[2] = INTRA_PLANAR;
1917 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1918 candidate[2] = INTRA_DC;
1920 candidate[2] = INTRA_ANGULAR_26;
1924 if (prev_intra_luma_pred_flag) {
1925 intra_pred_mode = candidate[lc->pu.mpm_idx];
1927 if (candidate[0] > candidate[1])
1928 FFSWAP(uint8_t, candidate[0], candidate[1]);
1929 if (candidate[0] > candidate[2])
1930 FFSWAP(uint8_t, candidate[0], candidate[2]);
1931 if (candidate[1] > candidate[2])
1932 FFSWAP(uint8_t, candidate[1], candidate[2]);
1934 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1935 for (i = 0; i < 3; i++)
1936 if (intra_pred_mode >= candidate[i])
1940 /* write the intra prediction units into the mv array */
1943 for (i = 0; i < size_in_pus; i++) {
1944 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1945 intra_pred_mode, size_in_pus);
1947 for (j = 0; j < size_in_pus; j++) {
1948 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag = PF_INTRA;
1952 return intra_pred_mode;
1955 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1956 int log2_cb_size, int ct_depth)
1958 int length = (1 << log2_cb_size) >> s->ps.sps->log2_min_cb_size;
1959 int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
1960 int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
1963 for (y = 0; y < length; y++)
1964 memset(&s->tab_ct_depth[(y_cb + y) * s->ps.sps->min_cb_width + x_cb],
1968 static const uint8_t tab_mode_idx[] = {
1969 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
1970 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
1972 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1975 HEVCLocalContext *lc = s->HEVClc;
1976 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1977 uint8_t prev_intra_luma_pred_flag[4];
1978 int split = lc->cu.part_mode == PART_NxN;
1979 int pb_size = (1 << log2_cb_size) >> split;
1980 int side = split + 1;
1984 for (i = 0; i < side; i++)
1985 for (j = 0; j < side; j++)
1986 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1988 for (i = 0; i < side; i++) {
1989 for (j = 0; j < side; j++) {
1990 if (prev_intra_luma_pred_flag[2 * i + j])
1991 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
1993 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
1995 lc->pu.intra_pred_mode[2 * i + j] =
1996 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1997 prev_intra_luma_pred_flag[2 * i + j]);
2001 if (s->ps.sps->chroma_format_idc == 3) {
2002 for (i = 0; i < side; i++) {
2003 for (j = 0; j < side; j++) {
2004 lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
2005 if (chroma_mode != 4) {
2006 if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode])
2007 lc->pu.intra_pred_mode_c[2 * i + j] = 34;
2009 lc->pu.intra_pred_mode_c[2 * i + j] = intra_chroma_table[chroma_mode];
2011 lc->pu.intra_pred_mode_c[2 * i + j] = lc->pu.intra_pred_mode[2 * i + j];
2015 } else if (s->ps.sps->chroma_format_idc == 2) {
2017 lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
2018 if (chroma_mode != 4) {
2019 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
2022 mode_idx = intra_chroma_table[chroma_mode];
2024 mode_idx = lc->pu.intra_pred_mode[0];
2026 lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx];
2027 } else if (s->ps.sps->chroma_format_idc != 0) {
2028 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
2029 if (chroma_mode != 4) {
2030 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
2031 lc->pu.intra_pred_mode_c[0] = 34;
2033 lc->pu.intra_pred_mode_c[0] = intra_chroma_table[chroma_mode];
2035 lc->pu.intra_pred_mode_c[0] = lc->pu.intra_pred_mode[0];
2040 static void intra_prediction_unit_default_value(HEVCContext *s,
2044 HEVCLocalContext *lc = s->HEVClc;
2045 int pb_size = 1 << log2_cb_size;
2046 int size_in_pus = pb_size >> s->ps.sps->log2_min_pu_size;
2047 int min_pu_width = s->ps.sps->min_pu_width;
2048 MvField *tab_mvf = s->ref->tab_mvf;
2049 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
2050 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
2053 if (size_in_pus == 0)
2055 for (j = 0; j < size_in_pus; j++)
2056 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
2057 if (lc->cu.pred_mode == MODE_INTRA)
2058 for (j = 0; j < size_in_pus; j++)
2059 for (k = 0; k < size_in_pus; k++)
2060 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].pred_flag = PF_INTRA;
2063 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
2065 int cb_size = 1 << log2_cb_size;
2066 HEVCLocalContext *lc = s->HEVClc;
2067 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
2068 int length = cb_size >> log2_min_cb_size;
2069 int min_cb_width = s->ps.sps->min_cb_width;
2070 int x_cb = x0 >> log2_min_cb_size;
2071 int y_cb = y0 >> log2_min_cb_size;
2072 int idx = log2_cb_size - 2;
2073 int qp_block_mask = (1<<(s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2078 lc->cu.pred_mode = MODE_INTRA;
2079 lc->cu.part_mode = PART_2Nx2N;
2080 lc->cu.intra_split_flag = 0;
2082 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
2083 for (x = 0; x < 4; x++)
2084 lc->pu.intra_pred_mode[x] = 1;
2085 if (s->ps.pps->transquant_bypass_enable_flag) {
2086 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
2087 if (lc->cu.cu_transquant_bypass_flag)
2088 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2090 lc->cu.cu_transquant_bypass_flag = 0;
2092 if (s->sh.slice_type != HEVC_SLICE_I) {
2093 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
2095 x = y_cb * min_cb_width + x_cb;
2096 for (y = 0; y < length; y++) {
2097 memset(&s->skip_flag[x], skip_flag, length);
2100 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2102 x = y_cb * min_cb_width + x_cb;
2103 for (y = 0; y < length; y++) {
2104 memset(&s->skip_flag[x], 0, length);
2109 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2110 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2111 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2113 if (!s->sh.disable_deblocking_filter_flag)
2114 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2118 if (s->sh.slice_type != HEVC_SLICE_I)
2119 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2120 if (lc->cu.pred_mode != MODE_INTRA ||
2121 log2_cb_size == s->ps.sps->log2_min_cb_size) {
2122 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2123 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2124 lc->cu.pred_mode == MODE_INTRA;
2127 if (lc->cu.pred_mode == MODE_INTRA) {
2128 if (lc->cu.part_mode == PART_2Nx2N && s->ps.sps->pcm_enabled_flag &&
2129 log2_cb_size >= s->ps.sps->pcm.log2_min_pcm_cb_size &&
2130 log2_cb_size <= s->ps.sps->pcm.log2_max_pcm_cb_size) {
2131 pcm_flag = ff_hevc_pcm_flag_decode(s);
2134 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2135 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2136 if (s->ps.sps->pcm.loop_filter_disable_flag)
2137 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2142 intra_prediction_unit(s, x0, y0, log2_cb_size);
2145 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2146 switch (lc->cu.part_mode) {
2148 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2151 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0, idx);
2152 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2155 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2156 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2159 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0, idx);
2160 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2163 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2164 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2167 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0, idx - 2);
2168 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2171 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2172 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2175 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2176 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2177 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2178 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2184 int rqt_root_cbf = 1;
2186 if (lc->cu.pred_mode != MODE_INTRA &&
2187 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2188 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2191 const static int cbf[2] = { 0 };
2192 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2193 s->ps.sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2194 s->ps.sps->max_transform_hierarchy_depth_inter;
2195 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2197 log2_cb_size, 0, 0, cbf, cbf);
2201 if (!s->sh.disable_deblocking_filter_flag)
2202 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2207 if (s->ps.pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2208 ff_hevc_set_qPy(s, x0, y0, log2_cb_size);
2210 x = y_cb * min_cb_width + x_cb;
2211 for (y = 0; y < length; y++) {
2212 memset(&s->qp_y_tab[x], lc->qp_y, length);
2216 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2217 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2218 lc->qPy_pred = lc->qp_y;
2221 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct_depth);
2226 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2227 int log2_cb_size, int cb_depth)
2229 HEVCLocalContext *lc = s->HEVClc;
2230 const int cb_size = 1 << log2_cb_size;
2234 lc->ct_depth = cb_depth;
2235 if (x0 + cb_size <= s->ps.sps->width &&
2236 y0 + cb_size <= s->ps.sps->height &&
2237 log2_cb_size > s->ps.sps->log2_min_cb_size) {
2238 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2240 split_cu = (log2_cb_size > s->ps.sps->log2_min_cb_size);
2242 if (s->ps.pps->cu_qp_delta_enabled_flag &&
2243 log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth) {
2244 lc->tu.is_cu_qp_delta_coded = 0;
2245 lc->tu.cu_qp_delta = 0;
2248 if (s->sh.cu_chroma_qp_offset_enabled_flag &&
2249 log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_chroma_qp_offset_depth) {
2250 lc->tu.is_cu_chroma_qp_offset_coded = 0;
2254 int qp_block_mask = (1<<(s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2255 const int cb_size_split = cb_size >> 1;
2256 const int x1 = x0 + cb_size_split;
2257 const int y1 = y0 + cb_size_split;
2261 more_data = hls_coding_quadtree(s, x0, y0, log2_cb_size - 1, cb_depth + 1);
2265 if (more_data && x1 < s->ps.sps->width) {
2266 more_data = hls_coding_quadtree(s, x1, y0, log2_cb_size - 1, cb_depth + 1);
2270 if (more_data && y1 < s->ps.sps->height) {
2271 more_data = hls_coding_quadtree(s, x0, y1, log2_cb_size - 1, cb_depth + 1);
2275 if (more_data && x1 < s->ps.sps->width &&
2276 y1 < s->ps.sps->height) {
2277 more_data = hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1);
2282 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2283 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2284 lc->qPy_pred = lc->qp_y;
2287 return ((x1 + cb_size_split) < s->ps.sps->width ||
2288 (y1 + cb_size_split) < s->ps.sps->height);
2292 ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2295 if ((!((x0 + cb_size) %
2296 (1 << (s->ps.sps->log2_ctb_size))) ||
2297 (x0 + cb_size >= s->ps.sps->width)) &&
2299 (1 << (s->ps.sps->log2_ctb_size))) ||
2300 (y0 + cb_size >= s->ps.sps->height))) {
2301 int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s);
2302 return !end_of_slice_flag;
2311 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2314 HEVCLocalContext *lc = s->HEVClc;
2315 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2316 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2317 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2319 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2321 if (s->ps.pps->entropy_coding_sync_enabled_flag) {
2322 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2323 lc->first_qp_group = 1;
2324 lc->end_of_tiles_x = s->ps.sps->width;
2325 } else if (s->ps.pps->tiles_enabled_flag) {
2326 if (ctb_addr_ts && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
2327 int idxX = s->ps.pps->col_idxX[x_ctb >> s->ps.sps->log2_ctb_size];
2328 lc->end_of_tiles_x = x_ctb + (s->ps.pps->column_width[idxX] << s->ps.sps->log2_ctb_size);
2329 lc->first_qp_group = 1;
2332 lc->end_of_tiles_x = s->ps.sps->width;
2335 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->ps.sps->height);
2337 lc->boundary_flags = 0;
2338 if (s->ps.pps->tiles_enabled_flag) {
2339 if (x_ctb > 0 && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs - 1]])
2340 lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2341 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2342 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2343 if (y_ctb > 0 && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs - s->ps.sps->ctb_width]])
2344 lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2345 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->ps.sps->ctb_width])
2346 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2348 if (ctb_addr_in_slice <= 0)
2349 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2350 if (ctb_addr_in_slice < s->ps.sps->ctb_width)
2351 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2354 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2355 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->ps.sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2356 lc->ctb_up_right_flag = ((y_ctb > 0) && (ctb_addr_in_slice+1 >= s->ps.sps->ctb_width) && (s->ps.pps->tile_id[ctb_addr_ts] == s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs+1 - s->ps.sps->ctb_width]]));
2357 lc->ctb_up_left_flag = ((x_ctb > 0) && (y_ctb > 0) && (ctb_addr_in_slice-1 >= s->ps.sps->ctb_width) && (s->ps.pps->tile_id[ctb_addr_ts] == s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs-1 - s->ps.sps->ctb_width]]));
2360 static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
2362 HEVCContext *s = avctxt->priv_data;
2363 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2367 int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2370 if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) {
2371 av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n");
2372 return AVERROR_INVALIDDATA;
2375 if (s->sh.dependent_slice_segment_flag) {
2376 int prev_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2377 if (s->tab_slice_address[prev_rs] != s->sh.slice_addr) {
2378 av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n");
2379 return AVERROR_INVALIDDATA;
2383 while (more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2384 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2386 x_ctb = (ctb_addr_rs % ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2387 y_ctb = (ctb_addr_rs / ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2388 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2390 ret = ff_hevc_cabac_init(s, ctb_addr_ts);
2392 s->tab_slice_address[ctb_addr_rs] = -1;
2396 hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2398 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2399 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2400 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2402 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2403 if (more_data < 0) {
2404 s->tab_slice_address[ctb_addr_rs] = -1;
2410 ff_hevc_save_states(s, ctb_addr_ts);
2411 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2414 if (x_ctb + ctb_size >= s->ps.sps->width &&
2415 y_ctb + ctb_size >= s->ps.sps->height)
2416 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2421 static int hls_slice_data(HEVCContext *s)
2429 s->avctx->execute(s->avctx, hls_decode_entry, arg, ret , 1, sizeof(int));
2432 static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int job, int self_id)
2434 HEVCContext *s1 = avctxt->priv_data, *s;
2435 HEVCLocalContext *lc;
2436 int ctb_size = 1<< s1->ps.sps->log2_ctb_size;
2438 int *ctb_row_p = input_ctb_row;
2439 int ctb_row = ctb_row_p[job];
2440 int ctb_addr_rs = s1->sh.slice_ctb_addr_rs + ctb_row * ((s1->ps.sps->width + ctb_size - 1) >> s1->ps.sps->log2_ctb_size);
2441 int ctb_addr_ts = s1->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2442 int thread = ctb_row % s1->threads_number;
2445 s = s1->sList[self_id];
2449 ret = init_get_bits8(&lc->gb, s->data + s->sh.offset[ctb_row - 1], s->sh.size[ctb_row - 1]);
2452 ff_init_cabac_decoder(&lc->cc, s->data + s->sh.offset[(ctb_row)-1], s->sh.size[ctb_row - 1]);
2455 while(more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2456 int x_ctb = (ctb_addr_rs % s->ps.sps->ctb_width) << s->ps.sps->log2_ctb_size;
2457 int y_ctb = (ctb_addr_rs / s->ps.sps->ctb_width) << s->ps.sps->log2_ctb_size;
2459 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2461 ff_thread_await_progress2(s->avctx, ctb_row, thread, SHIFT_CTB_WPP);
2463 if (atomic_load(&s1->wpp_err)) {
2464 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2468 ret = ff_hevc_cabac_init(s, ctb_addr_ts);
2471 hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2472 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2474 if (more_data < 0) {
2481 ff_hevc_save_states(s, ctb_addr_ts);
2482 ff_thread_report_progress2(s->avctx, ctb_row, thread, 1);
2483 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2485 if (!more_data && (x_ctb+ctb_size) < s->ps.sps->width && ctb_row != s->sh.num_entry_point_offsets) {
2486 atomic_store(&s1->wpp_err, 1);
2487 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2491 if ((x_ctb+ctb_size) >= s->ps.sps->width && (y_ctb+ctb_size) >= s->ps.sps->height ) {
2492 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2493 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2496 ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2499 if(x_ctb >= s->ps.sps->width) {
2503 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2507 s->tab_slice_address[ctb_addr_rs] = -1;
2508 atomic_store(&s1->wpp_err, 1);
2509 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2513 static int hls_slice_data_wpp(HEVCContext *s, const H2645NAL *nal)
2515 const uint8_t *data = nal->data;
2516 int length = nal->size;
2517 HEVCLocalContext *lc = s->HEVClc;
2518 int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2519 int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2521 int64_t startheader, cmpt = 0;
2527 return AVERROR(ENOMEM);
2530 if (s->sh.slice_ctb_addr_rs + s->sh.num_entry_point_offsets * s->ps.sps->ctb_width >= s->ps.sps->ctb_width * s->ps.sps->ctb_height) {
2531 av_log(s->avctx, AV_LOG_ERROR, "WPP ctb addresses are wrong (%d %d %d %d)\n",
2532 s->sh.slice_ctb_addr_rs, s->sh.num_entry_point_offsets,
2533 s->ps.sps->ctb_width, s->ps.sps->ctb_height
2535 res = AVERROR_INVALIDDATA;
2539 ff_alloc_entries(s->avctx, s->sh.num_entry_point_offsets + 1);
2542 for (i = 1; i < s->threads_number; i++) {
2543 s->sList[i] = av_malloc(sizeof(HEVCContext));
2544 memcpy(s->sList[i], s, sizeof(HEVCContext));
2545 s->HEVClcList[i] = av_mallocz(sizeof(HEVCLocalContext));
2546 s->sList[i]->HEVClc = s->HEVClcList[i];
2550 offset = (lc->gb.index >> 3);
2552 for (j = 0, cmpt = 0, startheader = offset + s->sh.entry_point_offset[0]; j < nal->skipped_bytes; j++) {
2553 if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) {
2559 for (i = 1; i < s->sh.num_entry_point_offsets; i++) {
2560 offset += (s->sh.entry_point_offset[i - 1] - cmpt);
2561 for (j = 0, cmpt = 0, startheader = offset
2562 + s->sh.entry_point_offset[i]; j < nal->skipped_bytes; j++) {
2563 if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) {
2568 s->sh.size[i - 1] = s->sh.entry_point_offset[i] - cmpt;
2569 s->sh.offset[i - 1] = offset;
2572 if (s->sh.num_entry_point_offsets != 0) {
2573 offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt;
2574 if (length < offset) {
2575 av_log(s->avctx, AV_LOG_ERROR, "entry_point_offset table is corrupted\n");
2576 res = AVERROR_INVALIDDATA;
2579 s->sh.size[s->sh.num_entry_point_offsets - 1] = length - offset;
2580 s->sh.offset[s->sh.num_entry_point_offsets - 1] = offset;
2585 for (i = 1; i < s->threads_number; i++) {
2586 s->sList[i]->HEVClc->first_qp_group = 1;
2587 s->sList[i]->HEVClc->qp_y = s->sList[0]->HEVClc->qp_y;
2588 memcpy(s->sList[i], s, sizeof(HEVCContext));
2589 s->sList[i]->HEVClc = s->HEVClcList[i];
2592 atomic_store(&s->wpp_err, 0);
2593 ff_reset_entries(s->avctx);
2595 for (i = 0; i <= s->sh.num_entry_point_offsets; i++) {
2600 if (s->ps.pps->entropy_coding_sync_enabled_flag)
2601 s->avctx->execute2(s->avctx, hls_decode_entry_wpp, arg, ret, s->sh.num_entry_point_offsets + 1);
2603 for (i = 0; i <= s->sh.num_entry_point_offsets; i++)
2611 static int set_side_data(HEVCContext *s)
2613 AVFrame *out = s->ref->frame;
2615 if (s->sei.frame_packing.present &&
2616 s->sei.frame_packing.arrangement_type >= 3 &&
2617 s->sei.frame_packing.arrangement_type <= 5 &&
2618 s->sei.frame_packing.content_interpretation_type > 0 &&
2619 s->sei.frame_packing.content_interpretation_type < 3) {
2620 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2622 return AVERROR(ENOMEM);
2624 switch (s->sei.frame_packing.arrangement_type) {
2626 if (s->sei.frame_packing.quincunx_subsampling)
2627 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2629 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2632 stereo->type = AV_STEREO3D_TOPBOTTOM;
2635 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2639 if (s->sei.frame_packing.content_interpretation_type == 2)
2640 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2643 if (s->sei.display_orientation.present &&
2644 (s->sei.display_orientation.anticlockwise_rotation ||
2645 s->sei.display_orientation.hflip || s->sei.display_orientation.vflip)) {
2646 double angle = s->sei.display_orientation.anticlockwise_rotation * 360 / (double) (1 << 16);
2647 AVFrameSideData *rotation = av_frame_new_side_data(out,
2648 AV_FRAME_DATA_DISPLAYMATRIX,
2649 sizeof(int32_t) * 9);
2651 return AVERROR(ENOMEM);
2653 av_display_rotation_set((int32_t *)rotation->data, angle);
2654 av_display_matrix_flip((int32_t *)rotation->data,
2655 s->sei.display_orientation.hflip,
2656 s->sei.display_orientation.vflip);
2659 // Decrement the mastering display flag when IRAP frame has no_rasl_output_flag=1
2660 // so the side data persists for the entire coded video sequence.
2661 if (s->sei.mastering_display.present > 0 &&
2662 IS_IRAP(s) && s->no_rasl_output_flag) {
2663 s->sei.mastering_display.present--;
2665 if (s->sei.mastering_display.present) {
2666 // HEVC uses a g,b,r ordering, which we convert to a more natural r,g,b
2667 const int mapping[3] = {2, 0, 1};
2668 const int chroma_den = 50000;
2669 const int luma_den = 10000;
2671 AVMasteringDisplayMetadata *metadata =
2672 av_mastering_display_metadata_create_side_data(out);
2674 return AVERROR(ENOMEM);
2676 for (i = 0; i < 3; i++) {
2677 const int j = mapping[i];
2678 metadata->display_primaries[i][0].num = s->sei.mastering_display.display_primaries[j][0];
2679 metadata->display_primaries[i][0].den = chroma_den;
2680 metadata->display_primaries[i][1].num = s->sei.mastering_display.display_primaries[j][1];
2681 metadata->display_primaries[i][1].den = chroma_den;
2683 metadata->white_point[0].num = s->sei.mastering_display.white_point[0];
2684 metadata->white_point[0].den = chroma_den;
2685 metadata->white_point[1].num = s->sei.mastering_display.white_point[1];
2686 metadata->white_point[1].den = chroma_den;
2688 metadata->max_luminance.num = s->sei.mastering_display.max_luminance;
2689 metadata->max_luminance.den = luma_den;
2690 metadata->min_luminance.num = s->sei.mastering_display.min_luminance;
2691 metadata->min_luminance.den = luma_den;
2692 metadata->has_luminance = 1;
2693 metadata->has_primaries = 1;
2695 av_log(s->avctx, AV_LOG_DEBUG, "Mastering Display Metadata:\n");
2696 av_log(s->avctx, AV_LOG_DEBUG,
2697 "r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f)\n",
2698 av_q2d(metadata->display_primaries[0][0]),
2699 av_q2d(metadata->display_primaries[0][1]),
2700 av_q2d(metadata->display_primaries[1][0]),
2701 av_q2d(metadata->display_primaries[1][1]),
2702 av_q2d(metadata->display_primaries[2][0]),
2703 av_q2d(metadata->display_primaries[2][1]),
2704 av_q2d(metadata->white_point[0]), av_q2d(metadata->white_point[1]));
2705 av_log(s->avctx, AV_LOG_DEBUG,
2706 "min_luminance=%f, max_luminance=%f\n",
2707 av_q2d(metadata->min_luminance), av_q2d(metadata->max_luminance));
2709 // Decrement the mastering display flag when IRAP frame has no_rasl_output_flag=1
2710 // so the side data persists for the entire coded video sequence.
2711 if (s->sei.content_light.present > 0 &&
2712 IS_IRAP(s) && s->no_rasl_output_flag) {
2713 s->sei.content_light.present--;
2715 if (s->sei.content_light.present) {
2716 AVContentLightMetadata *metadata =
2717 av_content_light_metadata_create_side_data(out);
2719 return AVERROR(ENOMEM);
2720 metadata->MaxCLL = s->sei.content_light.max_content_light_level;
2721 metadata->MaxFALL = s->sei.content_light.max_pic_average_light_level;
2723 av_log(s->avctx, AV_LOG_DEBUG, "Content Light Level Metadata:\n");
2724 av_log(s->avctx, AV_LOG_DEBUG, "MaxCLL=%d, MaxFALL=%d\n",
2725 metadata->MaxCLL, metadata->MaxFALL);
2728 if (s->sei.a53_caption.a53_caption) {
2729 AVFrameSideData* sd = av_frame_new_side_data(out,
2730 AV_FRAME_DATA_A53_CC,
2731 s->sei.a53_caption.a53_caption_size);
2733 memcpy(sd->data, s->sei.a53_caption.a53_caption, s->sei.a53_caption.a53_caption_size);
2734 av_freep(&s->sei.a53_caption.a53_caption);
2735 s->sei.a53_caption.a53_caption_size = 0;
2736 s->avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
2739 if (s->sei.alternative_transfer.present &&
2740 av_color_transfer_name(s->sei.alternative_transfer.preferred_transfer_characteristics) &&
2741 s->sei.alternative_transfer.preferred_transfer_characteristics != AVCOL_TRC_UNSPECIFIED) {
2742 s->avctx->color_trc = out->color_trc = s->sei.alternative_transfer.preferred_transfer_characteristics;
2748 static int hevc_frame_start(HEVCContext *s)
2750 HEVCLocalContext *lc = s->HEVClc;
2751 int pic_size_in_ctb = ((s->ps.sps->width >> s->ps.sps->log2_min_cb_size) + 1) *
2752 ((s->ps.sps->height >> s->ps.sps->log2_min_cb_size) + 1);
2755 memset(s->horizontal_bs, 0, s->bs_width * s->bs_height);
2756 memset(s->vertical_bs, 0, s->bs_width * s->bs_height);
2757 memset(s->cbf_luma, 0, s->ps.sps->min_tb_width * s->ps.sps->min_tb_height);
2758 memset(s->is_pcm, 0, (s->ps.sps->min_pu_width + 1) * (s->ps.sps->min_pu_height + 1));
2759 memset(s->tab_slice_address, -1, pic_size_in_ctb * sizeof(*s->tab_slice_address));
2762 s->first_nal_type = s->nal_unit_type;
2764 s->no_rasl_output_flag = IS_IDR(s) || IS_BLA(s) || (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos);
2766 if (s->ps.pps->tiles_enabled_flag)
2767 lc->end_of_tiles_x = s->ps.pps->column_width[0] << s->ps.sps->log2_ctb_size;
2769 ret = ff_hevc_set_new_ref(s, &s->frame, s->poc);
2773 ret = ff_hevc_frame_rps(s);
2775 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2779 s->ref->frame->key_frame = IS_IRAP(s);
2781 ret = set_side_data(s);
2785 s->frame->pict_type = 3 - s->sh.slice_type;
2788 ff_hevc_bump_frame(s);
2790 av_frame_unref(s->output_frame);
2791 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2795 if (!s->avctx->hwaccel)
2796 ff_thread_finish_setup(s->avctx);
2802 ff_hevc_unref_frame(s, s->ref, ~0);
2807 static int decode_nal_unit(HEVCContext *s, const H2645NAL *nal)
2809 HEVCLocalContext *lc = s->HEVClc;
2810 GetBitContext *gb = &lc->gb;
2811 int ctb_addr_ts, ret;
2814 s->nal_unit_type = nal->type;
2815 s->temporal_id = nal->temporal_id;
2817 switch (s->nal_unit_type) {
2819 ret = ff_hevc_decode_nal_vps(gb, s->avctx, &s->ps);
2824 ret = ff_hevc_decode_nal_sps(gb, s->avctx, &s->ps,
2825 s->apply_defdispwin);
2830 ret = ff_hevc_decode_nal_pps(gb, s->avctx, &s->ps);
2834 case HEVC_NAL_SEI_PREFIX:
2835 case HEVC_NAL_SEI_SUFFIX:
2836 ret = ff_hevc_decode_nal_sei(gb, s->avctx, &s->sei, &s->ps, s->nal_unit_type);
2840 case HEVC_NAL_TRAIL_R:
2841 case HEVC_NAL_TRAIL_N:
2842 case HEVC_NAL_TSA_N:
2843 case HEVC_NAL_TSA_R:
2844 case HEVC_NAL_STSA_N:
2845 case HEVC_NAL_STSA_R:
2846 case HEVC_NAL_BLA_W_LP:
2847 case HEVC_NAL_BLA_W_RADL:
2848 case HEVC_NAL_BLA_N_LP:
2849 case HEVC_NAL_IDR_W_RADL:
2850 case HEVC_NAL_IDR_N_LP:
2851 case HEVC_NAL_CRA_NUT:
2852 case HEVC_NAL_RADL_N:
2853 case HEVC_NAL_RADL_R:
2854 case HEVC_NAL_RASL_N:
2855 case HEVC_NAL_RASL_R:
2856 ret = hls_slice_header(s);
2860 if (s->sh.first_slice_in_pic_flag) {
2861 if (s->max_ra == INT_MAX) {
2862 if (s->nal_unit_type == HEVC_NAL_CRA_NUT || IS_BLA(s)) {
2866 s->max_ra = INT_MIN;
2870 if ((s->nal_unit_type == HEVC_NAL_RASL_R || s->nal_unit_type == HEVC_NAL_RASL_N) &&
2871 s->poc <= s->max_ra) {
2875 if (s->nal_unit_type == HEVC_NAL_RASL_R && s->poc > s->max_ra)
2876 s->max_ra = INT_MIN;
2879 ret = hevc_frame_start(s);
2882 } else if (!s->ref) {
2883 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2887 if (s->nal_unit_type != s->first_nal_type) {
2888 av_log(s->avctx, AV_LOG_ERROR,
2889 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2890 s->first_nal_type, s->nal_unit_type);
2891 return AVERROR_INVALIDDATA;
2894 if (!s->sh.dependent_slice_segment_flag &&
2895 s->sh.slice_type != HEVC_SLICE_I) {
2896 ret = ff_hevc_slice_rpl(s);
2898 av_log(s->avctx, AV_LOG_WARNING,
2899 "Error constructing the reference lists for the current slice.\n");
2904 if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) {
2905 ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0);
2910 if (s->avctx->hwaccel) {
2911 ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size);
2915 if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
2916 ctb_addr_ts = hls_slice_data_wpp(s, nal);
2918 ctb_addr_ts = hls_slice_data(s);
2919 if (ctb_addr_ts >= (s->ps.sps->ctb_width * s->ps.sps->ctb_height)) {
2923 if (ctb_addr_ts < 0) {
2929 case HEVC_NAL_EOS_NUT:
2930 case HEVC_NAL_EOB_NUT:
2931 s->seq_decode = (s->seq_decode + 1) & 0xff;
2932 s->max_ra = INT_MAX;
2935 case HEVC_NAL_FD_NUT:
2938 av_log(s->avctx, AV_LOG_INFO,
2939 "Skipping NAL unit %d\n", s->nal_unit_type);
2944 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2949 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2952 int eos_at_start = 1;
2955 s->last_eos = s->eos;
2958 /* split the input packet into NAL units, so we know the upper bound on the
2959 * number of slices in the frame */
2960 ret = ff_h2645_packet_split(&s->pkt, buf, length, s->avctx, s->is_nalff,
2961 s->nal_length_size, s->avctx->codec_id, 1);
2963 av_log(s->avctx, AV_LOG_ERROR,
2964 "Error splitting the input into NAL units.\n");
2968 for (i = 0; i < s->pkt.nb_nals; i++) {
2969 if (s->pkt.nals[i].type == HEVC_NAL_EOB_NUT ||
2970 s->pkt.nals[i].type == HEVC_NAL_EOS_NUT) {
2981 /* decode the NAL units */
2982 for (i = 0; i < s->pkt.nb_nals; i++) {
2983 ret = decode_nal_unit(s, &s->pkt.nals[i]);
2985 av_log(s->avctx, AV_LOG_WARNING,
2986 "Error parsing NAL unit #%d.\n", i);
2992 if (s->ref && s->threads_type == FF_THREAD_FRAME)
2993 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2998 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
3001 for (i = 0; i < 16; i++)
3002 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
3005 static int verify_md5(HEVCContext *s, AVFrame *frame)
3007 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
3012 return AVERROR(EINVAL);
3014 pixel_shift = desc->comp[0].depth > 8;
3016 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
3019 /* the checksums are LE, so we have to byteswap for >8bpp formats
3022 if (pixel_shift && !s->checksum_buf) {
3023 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
3024 FFMAX3(frame->linesize[0], frame->linesize[1],
3025 frame->linesize[2]));
3026 if (!s->checksum_buf)
3027 return AVERROR(ENOMEM);
3031 for (i = 0; frame->data[i]; i++) {
3032 int width = s->avctx->coded_width;
3033 int height = s->avctx->coded_height;
3034 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
3035 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
3038 av_md5_init(s->md5_ctx);
3039 for (j = 0; j < h; j++) {
3040 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
3043 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
3044 (const uint16_t *) src, w);
3045 src = s->checksum_buf;
3048 av_md5_update(s->md5_ctx, src, w << pixel_shift);
3050 av_md5_final(s->md5_ctx, md5);
3052 if (!memcmp(md5, s->sei.picture_hash.md5[i], 16)) {
3053 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
3054 print_md5(s->avctx, AV_LOG_DEBUG, md5);
3055 av_log (s->avctx, AV_LOG_DEBUG, "; ");
3057 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
3058 print_md5(s->avctx, AV_LOG_ERROR, md5);
3059 av_log (s->avctx, AV_LOG_ERROR, " != ");
3060 print_md5(s->avctx, AV_LOG_ERROR, s->sei.picture_hash.md5[i]);
3061 av_log (s->avctx, AV_LOG_ERROR, "\n");
3062 return AVERROR_INVALIDDATA;
3066 av_log(s->avctx, AV_LOG_DEBUG, "\n");
3071 static int hevc_decode_extradata(HEVCContext *s, uint8_t *buf, int length, int first)
3075 ret = ff_hevc_decode_extradata(buf, length, &s->ps, &s->sei, &s->is_nalff,
3076 &s->nal_length_size, s->avctx->err_recognition,
3077 s->apply_defdispwin, s->avctx);
3081 /* export stream parameters from the first SPS */
3082 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3083 if (first && s->ps.sps_list[i]) {
3084 const HEVCSPS *sps = (const HEVCSPS*)s->ps.sps_list[i]->data;
3085 export_stream_params(s->avctx, &s->ps, sps);
3093 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
3097 int new_extradata_size;
3098 uint8_t *new_extradata;
3099 HEVCContext *s = avctx->priv_data;
3102 ret = ff_hevc_output_frame(s, data, 1);
3110 new_extradata = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,
3111 &new_extradata_size);
3112 if (new_extradata && new_extradata_size > 0) {
3113 ret = hevc_decode_extradata(s, new_extradata, new_extradata_size, 0);
3119 ret = decode_nal_units(s, avpkt->data, avpkt->size);
3123 if (avctx->hwaccel) {
3124 if (s->ref && (ret = avctx->hwaccel->end_frame(avctx)) < 0) {
3125 av_log(avctx, AV_LOG_ERROR,
3126 "hardware accelerator failed to decode picture\n");
3127 ff_hevc_unref_frame(s, s->ref, ~0);
3131 /* verify the SEI checksum */
3132 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
3133 s->sei.picture_hash.is_md5) {
3134 ret = verify_md5(s, s->ref->frame);
3135 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
3136 ff_hevc_unref_frame(s, s->ref, ~0);
3141 s->sei.picture_hash.is_md5 = 0;
3143 if (s->is_decoded) {
3144 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
3148 if (s->output_frame->buf[0]) {
3149 av_frame_move_ref(data, s->output_frame);
3156 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
3160 ret = ff_thread_ref_frame(&dst->tf, &src->tf);
3164 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
3165 if (!dst->tab_mvf_buf)
3167 dst->tab_mvf = src->tab_mvf;
3169 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
3170 if (!dst->rpl_tab_buf)
3172 dst->rpl_tab = src->rpl_tab;
3174 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
3178 dst->poc = src->poc;
3179 dst->ctb_count = src->ctb_count;
3180 dst->flags = src->flags;
3181 dst->sequence = src->sequence;
3183 if (src->hwaccel_picture_private) {
3184 dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
3185 if (!dst->hwaccel_priv_buf)
3187 dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
3192 ff_hevc_unref_frame(s, dst, ~0);
3193 return AVERROR(ENOMEM);
3196 static av_cold int hevc_decode_free(AVCodecContext *avctx)
3198 HEVCContext *s = avctx->priv_data;
3203 av_freep(&s->md5_ctx);
3205 av_freep(&s->cabac_state);
3207 for (i = 0; i < 3; i++) {
3208 av_freep(&s->sao_pixel_buffer_h[i]);
3209 av_freep(&s->sao_pixel_buffer_v[i]);
3211 av_frame_free(&s->output_frame);
3213 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3214 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3215 av_frame_free(&s->DPB[i].frame);
3218 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++)
3219 av_buffer_unref(&s->ps.vps_list[i]);
3220 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++)
3221 av_buffer_unref(&s->ps.sps_list[i]);
3222 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++)
3223 av_buffer_unref(&s->ps.pps_list[i]);
3228 av_freep(&s->sh.entry_point_offset);
3229 av_freep(&s->sh.offset);
3230 av_freep(&s->sh.size);
3232 for (i = 1; i < s->threads_number; i++) {
3233 HEVCLocalContext *lc = s->HEVClcList[i];
3235 av_freep(&s->HEVClcList[i]);
3236 av_freep(&s->sList[i]);
3239 if (s->HEVClc == s->HEVClcList[0])
3241 av_freep(&s->HEVClcList[0]);
3243 ff_h2645_packet_uninit(&s->pkt);
3248 static av_cold int hevc_init_context(AVCodecContext *avctx)
3250 HEVCContext *s = avctx->priv_data;
3255 s->HEVClc = av_mallocz(sizeof(HEVCLocalContext));
3258 s->HEVClcList[0] = s->HEVClc;
3261 s->cabac_state = av_malloc(HEVC_CONTEXTS);
3262 if (!s->cabac_state)
3265 s->output_frame = av_frame_alloc();
3266 if (!s->output_frame)
3269 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3270 s->DPB[i].frame = av_frame_alloc();
3271 if (!s->DPB[i].frame)
3273 s->DPB[i].tf.f = s->DPB[i].frame;
3276 s->max_ra = INT_MAX;
3278 s->md5_ctx = av_md5_alloc();
3282 ff_bswapdsp_init(&s->bdsp);
3284 s->context_initialized = 1;
3287 ff_hevc_reset_sei(&s->sei);
3292 hevc_decode_free(avctx);
3293 return AVERROR(ENOMEM);
3296 static int hevc_update_thread_context(AVCodecContext *dst,
3297 const AVCodecContext *src)
3299 HEVCContext *s = dst->priv_data;
3300 HEVCContext *s0 = src->priv_data;
3303 if (!s->context_initialized) {
3304 ret = hevc_init_context(dst);
3309 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3310 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3311 if (s0->DPB[i].frame->buf[0]) {
3312 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3318 if (s->ps.sps != s0->ps.sps)
3320 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++) {
3321 av_buffer_unref(&s->ps.vps_list[i]);
3322 if (s0->ps.vps_list[i]) {
3323 s->ps.vps_list[i] = av_buffer_ref(s0->ps.vps_list[i]);
3324 if (!s->ps.vps_list[i])
3325 return AVERROR(ENOMEM);
3329 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3330 av_buffer_unref(&s->ps.sps_list[i]);
3331 if (s0->ps.sps_list[i]) {
3332 s->ps.sps_list[i] = av_buffer_ref(s0->ps.sps_list[i]);
3333 if (!s->ps.sps_list[i])
3334 return AVERROR(ENOMEM);
3338 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++) {
3339 av_buffer_unref(&s->ps.pps_list[i]);
3340 if (s0->ps.pps_list[i]) {
3341 s->ps.pps_list[i] = av_buffer_ref(s0->ps.pps_list[i]);
3342 if (!s->ps.pps_list[i])
3343 return AVERROR(ENOMEM);
3347 if (s->ps.sps != s0->ps.sps)
3348 if ((ret = set_sps(s, s0->ps.sps, src->pix_fmt)) < 0)
3351 s->seq_decode = s0->seq_decode;
3352 s->seq_output = s0->seq_output;
3353 s->pocTid0 = s0->pocTid0;
3354 s->max_ra = s0->max_ra;
3356 s->no_rasl_output_flag = s0->no_rasl_output_flag;
3358 s->is_nalff = s0->is_nalff;
3359 s->nal_length_size = s0->nal_length_size;
3361 s->threads_number = s0->threads_number;
3362 s->threads_type = s0->threads_type;
3365 s->seq_decode = (s->seq_decode + 1) & 0xff;
3366 s->max_ra = INT_MAX;
3369 s->sei.frame_packing = s0->sei.frame_packing;
3370 s->sei.display_orientation = s0->sei.display_orientation;
3371 s->sei.mastering_display = s0->sei.mastering_display;
3372 s->sei.content_light = s0->sei.content_light;
3373 s->sei.alternative_transfer = s0->sei.alternative_transfer;
3378 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3380 HEVCContext *s = avctx->priv_data;
3383 avctx->internal->allocate_progress = 1;
3385 ret = hevc_init_context(avctx);
3389 s->enable_parallel_tiles = 0;
3390 s->sei.picture_timing.picture_struct = 0;
3393 atomic_init(&s->wpp_err, 0);
3395 if(avctx->active_thread_type & FF_THREAD_SLICE)
3396 s->threads_number = avctx->thread_count;
3398 s->threads_number = 1;
3400 if (avctx->extradata_size > 0 && avctx->extradata) {
3401 ret = hevc_decode_extradata(s, avctx->extradata, avctx->extradata_size, 1);
3403 hevc_decode_free(avctx);
3408 if((avctx->active_thread_type & FF_THREAD_FRAME) && avctx->thread_count > 1)
3409 s->threads_type = FF_THREAD_FRAME;
3411 s->threads_type = FF_THREAD_SLICE;
3416 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3418 HEVCContext *s = avctx->priv_data;
3421 memset(s, 0, sizeof(*s));
3423 ret = hevc_init_context(avctx);
3430 static void hevc_decode_flush(AVCodecContext *avctx)
3432 HEVCContext *s = avctx->priv_data;
3433 ff_hevc_flush_dpb(s);
3434 s->max_ra = INT_MAX;
3438 #define OFFSET(x) offsetof(HEVCContext, x)
3439 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3441 static const AVOption options[] = {
3442 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3443 AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR },
3444 { "strict-displaywin", "stricly apply default display window size", OFFSET(apply_defdispwin),
3445 AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR },
3449 static const AVClass hevc_decoder_class = {
3450 .class_name = "HEVC decoder",
3451 .item_name = av_default_item_name,
3453 .version = LIBAVUTIL_VERSION_INT,
3456 AVCodec ff_hevc_decoder = {
3458 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3459 .type = AVMEDIA_TYPE_VIDEO,
3460 .id = AV_CODEC_ID_HEVC,
3461 .priv_data_size = sizeof(HEVCContext),
3462 .priv_class = &hevc_decoder_class,
3463 .init = hevc_decode_init,
3464 .close = hevc_decode_free,
3465 .decode = hevc_decode_frame,
3466 .flush = hevc_decode_flush,
3467 .update_thread_context = hevc_update_thread_context,
3468 .init_thread_copy = hevc_init_thread_copy,
3469 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
3470 AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS,
3471 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_EXPORTS_CROPPING,
3472 .profiles = NULL_IF_CONFIG_SMALL(ff_hevc_profiles),