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"
47 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 };
50 * NOTE: Each function hls_foo correspond to the function foo in the
51 * specification (HLS stands for High Level Syntax).
58 /* free everything allocated by pic_arrays_init() */
59 static void pic_arrays_free(HEVCContext *s)
62 av_freep(&s->deblock);
64 av_freep(&s->skip_flag);
65 av_freep(&s->tab_ct_depth);
67 av_freep(&s->tab_ipm);
68 av_freep(&s->cbf_luma);
71 av_freep(&s->qp_y_tab);
72 av_freep(&s->tab_slice_address);
73 av_freep(&s->filter_slice_edges);
75 av_freep(&s->horizontal_bs);
76 av_freep(&s->vertical_bs);
78 av_freep(&s->sh.entry_point_offset);
79 av_freep(&s->sh.size);
80 av_freep(&s->sh.offset);
82 av_buffer_pool_uninit(&s->tab_mvf_pool);
83 av_buffer_pool_uninit(&s->rpl_tab_pool);
86 /* allocate arrays that depend on frame dimensions */
87 static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
89 int log2_min_cb_size = sps->log2_min_cb_size;
90 int width = sps->width;
91 int height = sps->height;
92 int pic_size_in_ctb = ((width >> log2_min_cb_size) + 1) *
93 ((height >> log2_min_cb_size) + 1);
94 int ctb_count = sps->ctb_width * sps->ctb_height;
95 int min_pu_size = sps->min_pu_width * sps->min_pu_height;
97 s->bs_width = (width >> 2) + 1;
98 s->bs_height = (height >> 2) + 1;
100 s->sao = av_mallocz_array(ctb_count, sizeof(*s->sao));
101 s->deblock = av_mallocz_array(ctb_count, sizeof(*s->deblock));
102 if (!s->sao || !s->deblock)
105 s->skip_flag = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
106 s->tab_ct_depth = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
107 if (!s->skip_flag || !s->tab_ct_depth)
110 s->cbf_luma = av_malloc_array(sps->min_tb_width, sps->min_tb_height);
111 s->tab_ipm = av_mallocz(min_pu_size);
112 s->is_pcm = av_malloc_array(sps->min_pu_width + 1, sps->min_pu_height + 1);
113 if (!s->tab_ipm || !s->cbf_luma || !s->is_pcm)
116 s->filter_slice_edges = av_mallocz(ctb_count);
117 s->tab_slice_address = av_malloc_array(pic_size_in_ctb,
118 sizeof(*s->tab_slice_address));
119 s->qp_y_tab = av_malloc_array(pic_size_in_ctb,
120 sizeof(*s->qp_y_tab));
121 if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address)
124 s->horizontal_bs = av_mallocz_array(s->bs_width, s->bs_height);
125 s->vertical_bs = av_mallocz_array(s->bs_width, s->bs_height);
126 if (!s->horizontal_bs || !s->vertical_bs)
129 s->tab_mvf_pool = av_buffer_pool_init(min_pu_size * sizeof(MvField),
131 s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab),
133 if (!s->tab_mvf_pool || !s->rpl_tab_pool)
140 return AVERROR(ENOMEM);
143 static int pred_weight_table(HEVCContext *s, GetBitContext *gb)
147 uint8_t luma_weight_l0_flag[16];
148 uint8_t chroma_weight_l0_flag[16];
149 uint8_t luma_weight_l1_flag[16];
150 uint8_t chroma_weight_l1_flag[16];
151 int luma_log2_weight_denom;
153 luma_log2_weight_denom = get_ue_golomb_long(gb);
154 if (luma_log2_weight_denom < 0 || luma_log2_weight_denom > 7) {
155 av_log(s->avctx, AV_LOG_ERROR, "luma_log2_weight_denom %d is invalid\n", luma_log2_weight_denom);
156 return AVERROR_INVALIDDATA;
158 s->sh.luma_log2_weight_denom = av_clip_uintp2(luma_log2_weight_denom, 3);
159 if (s->ps.sps->chroma_format_idc != 0) {
160 int64_t chroma_log2_weight_denom = luma_log2_weight_denom + (int64_t)get_se_golomb(gb);
161 if (chroma_log2_weight_denom < 0 || chroma_log2_weight_denom > 7) {
162 av_log(s->avctx, AV_LOG_ERROR, "chroma_log2_weight_denom %"PRId64" is invalid\n", chroma_log2_weight_denom);
163 return AVERROR_INVALIDDATA;
165 s->sh.chroma_log2_weight_denom = chroma_log2_weight_denom;
168 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
169 luma_weight_l0_flag[i] = get_bits1(gb);
170 if (!luma_weight_l0_flag[i]) {
171 s->sh.luma_weight_l0[i] = 1 << s->sh.luma_log2_weight_denom;
172 s->sh.luma_offset_l0[i] = 0;
175 if (s->ps.sps->chroma_format_idc != 0) {
176 for (i = 0; i < s->sh.nb_refs[L0]; i++)
177 chroma_weight_l0_flag[i] = get_bits1(gb);
179 for (i = 0; i < s->sh.nb_refs[L0]; i++)
180 chroma_weight_l0_flag[i] = 0;
182 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
183 if (luma_weight_l0_flag[i]) {
184 int delta_luma_weight_l0 = get_se_golomb(gb);
185 if ((int8_t)delta_luma_weight_l0 != delta_luma_weight_l0)
186 return AVERROR_INVALIDDATA;
187 s->sh.luma_weight_l0[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;
188 s->sh.luma_offset_l0[i] = get_se_golomb(gb);
190 if (chroma_weight_l0_flag[i]) {
191 for (j = 0; j < 2; j++) {
192 int delta_chroma_weight_l0 = get_se_golomb(gb);
193 int delta_chroma_offset_l0 = get_se_golomb(gb);
195 if ( (int8_t)delta_chroma_weight_l0 != delta_chroma_weight_l0
196 || delta_chroma_offset_l0 < -(1<<17) || delta_chroma_offset_l0 > (1<<17)) {
197 return AVERROR_INVALIDDATA;
200 s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
201 s->sh.chroma_offset_l0[i][j] = av_clip((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j])
202 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
205 s->sh.chroma_weight_l0[i][0] = 1 << s->sh.chroma_log2_weight_denom;
206 s->sh.chroma_offset_l0[i][0] = 0;
207 s->sh.chroma_weight_l0[i][1] = 1 << s->sh.chroma_log2_weight_denom;
208 s->sh.chroma_offset_l0[i][1] = 0;
211 if (s->sh.slice_type == HEVC_SLICE_B) {
212 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
213 luma_weight_l1_flag[i] = get_bits1(gb);
214 if (!luma_weight_l1_flag[i]) {
215 s->sh.luma_weight_l1[i] = 1 << s->sh.luma_log2_weight_denom;
216 s->sh.luma_offset_l1[i] = 0;
219 if (s->ps.sps->chroma_format_idc != 0) {
220 for (i = 0; i < s->sh.nb_refs[L1]; i++)
221 chroma_weight_l1_flag[i] = get_bits1(gb);
223 for (i = 0; i < s->sh.nb_refs[L1]; i++)
224 chroma_weight_l1_flag[i] = 0;
226 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
227 if (luma_weight_l1_flag[i]) {
228 int delta_luma_weight_l1 = get_se_golomb(gb);
229 if ((int8_t)delta_luma_weight_l1 != delta_luma_weight_l1)
230 return AVERROR_INVALIDDATA;
231 s->sh.luma_weight_l1[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;
232 s->sh.luma_offset_l1[i] = get_se_golomb(gb);
234 if (chroma_weight_l1_flag[i]) {
235 for (j = 0; j < 2; j++) {
236 int delta_chroma_weight_l1 = get_se_golomb(gb);
237 int delta_chroma_offset_l1 = get_se_golomb(gb);
239 if ( (int8_t)delta_chroma_weight_l1 != delta_chroma_weight_l1
240 || delta_chroma_offset_l1 < -(1<<17) || delta_chroma_offset_l1 > (1<<17)) {
241 return AVERROR_INVALIDDATA;
244 s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
245 s->sh.chroma_offset_l1[i][j] = av_clip((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j])
246 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
249 s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom;
250 s->sh.chroma_offset_l1[i][0] = 0;
251 s->sh.chroma_weight_l1[i][1] = 1 << s->sh.chroma_log2_weight_denom;
252 s->sh.chroma_offset_l1[i][1] = 0;
259 static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
261 const HEVCSPS *sps = s->ps.sps;
262 int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
263 int prev_delta_msb = 0;
264 unsigned int nb_sps = 0, nb_sh;
268 if (!sps->long_term_ref_pics_present_flag)
271 if (sps->num_long_term_ref_pics_sps > 0)
272 nb_sps = get_ue_golomb_long(gb);
273 nb_sh = get_ue_golomb_long(gb);
275 if (nb_sps > sps->num_long_term_ref_pics_sps)
276 return AVERROR_INVALIDDATA;
277 if (nb_sh + (uint64_t)nb_sps > FF_ARRAY_ELEMS(rps->poc))
278 return AVERROR_INVALIDDATA;
280 rps->nb_refs = nb_sh + nb_sps;
282 for (i = 0; i < rps->nb_refs; i++) {
285 uint8_t lt_idx_sps = 0;
287 if (sps->num_long_term_ref_pics_sps > 1)
288 lt_idx_sps = get_bits(gb, av_ceil_log2(sps->num_long_term_ref_pics_sps));
290 rps->poc[i] = sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
291 rps->used[i] = sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];
293 rps->poc[i] = get_bits(gb, sps->log2_max_poc_lsb);
294 rps->used[i] = get_bits1(gb);
297 rps->poc_msb_present[i] = get_bits1(gb);
298 if (rps->poc_msb_present[i]) {
299 int64_t delta = get_ue_golomb_long(gb);
302 if (i && i != nb_sps)
303 delta += prev_delta_msb;
305 poc = rps->poc[i] + s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
306 if (poc != (int32_t)poc)
307 return AVERROR_INVALIDDATA;
309 prev_delta_msb = delta;
316 static void export_stream_params(HEVCContext *s, const HEVCSPS *sps)
318 AVCodecContext *avctx = s->avctx;
319 const HEVCParamSets *ps = &s->ps;
320 const HEVCVPS *vps = (const HEVCVPS*)ps->vps_list[sps->vps_id]->data;
321 const HEVCWindow *ow = &sps->output_window;
322 unsigned int num = 0, den = 0;
324 avctx->pix_fmt = sps->pix_fmt;
325 avctx->coded_width = sps->width;
326 avctx->coded_height = sps->height;
327 avctx->width = sps->width - ow->left_offset - ow->right_offset;
328 avctx->height = sps->height - ow->top_offset - ow->bottom_offset;
329 avctx->has_b_frames = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics;
330 avctx->profile = sps->ptl.general_ptl.profile_idc;
331 avctx->level = sps->ptl.general_ptl.level_idc;
333 ff_set_sar(avctx, sps->vui.sar);
335 if (sps->vui.video_signal_type_present_flag)
336 avctx->color_range = sps->vui.video_full_range_flag ? AVCOL_RANGE_JPEG
339 avctx->color_range = AVCOL_RANGE_MPEG;
341 if (sps->vui.colour_description_present_flag) {
342 avctx->color_primaries = sps->vui.colour_primaries;
343 avctx->color_trc = sps->vui.transfer_characteristic;
344 avctx->colorspace = sps->vui.matrix_coeffs;
346 avctx->color_primaries = AVCOL_PRI_UNSPECIFIED;
347 avctx->color_trc = AVCOL_TRC_UNSPECIFIED;
348 avctx->colorspace = AVCOL_SPC_UNSPECIFIED;
351 if (vps->vps_timing_info_present_flag) {
352 num = vps->vps_num_units_in_tick;
353 den = vps->vps_time_scale;
354 } else if (sps->vui.vui_timing_info_present_flag) {
355 num = sps->vui.vui_num_units_in_tick;
356 den = sps->vui.vui_time_scale;
359 if (num != 0 && den != 0)
360 av_reduce(&avctx->framerate.den, &avctx->framerate.num,
363 if (s->sei.alternative_transfer.present &&
364 av_color_transfer_name(s->sei.alternative_transfer.preferred_transfer_characteristics) &&
365 s->sei.alternative_transfer.preferred_transfer_characteristics != AVCOL_TRC_UNSPECIFIED) {
366 avctx->color_trc = s->sei.alternative_transfer.preferred_transfer_characteristics;
370 static enum AVPixelFormat get_format(HEVCContext *s, const HEVCSPS *sps)
372 #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + \
373 CONFIG_HEVC_D3D11VA_HWACCEL * 2 + \
374 CONFIG_HEVC_NVDEC_HWACCEL + \
375 CONFIG_HEVC_VAAPI_HWACCEL + \
376 CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL + \
377 CONFIG_HEVC_VDPAU_HWACCEL)
378 enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
380 switch (sps->pix_fmt) {
381 case AV_PIX_FMT_YUV420P:
382 case AV_PIX_FMT_YUVJ420P:
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_VDPAU_HWACCEL
394 *fmt++ = AV_PIX_FMT_VDPAU;
396 #if CONFIG_HEVC_NVDEC_HWACCEL
397 *fmt++ = AV_PIX_FMT_CUDA;
399 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
400 *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX;
403 case AV_PIX_FMT_YUV420P10:
404 #if CONFIG_HEVC_DXVA2_HWACCEL
405 *fmt++ = AV_PIX_FMT_DXVA2_VLD;
407 #if CONFIG_HEVC_D3D11VA_HWACCEL
408 *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
409 *fmt++ = AV_PIX_FMT_D3D11;
411 #if CONFIG_HEVC_VAAPI_HWACCEL
412 *fmt++ = AV_PIX_FMT_VAAPI;
414 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
415 *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX;
417 #if CONFIG_HEVC_NVDEC_HWACCEL
418 *fmt++ = AV_PIX_FMT_CUDA;
421 case AV_PIX_FMT_YUV444P:
422 #if CONFIG_HEVC_VDPAU_HWACCEL
423 *fmt++ = AV_PIX_FMT_VDPAU;
425 #if CONFIG_HEVC_NVDEC_HWACCEL
426 *fmt++ = AV_PIX_FMT_CUDA;
429 case AV_PIX_FMT_YUV422P:
430 case AV_PIX_FMT_YUV422P10LE:
431 #if CONFIG_HEVC_VAAPI_HWACCEL
432 *fmt++ = AV_PIX_FMT_VAAPI;
435 case AV_PIX_FMT_YUV420P12:
436 case AV_PIX_FMT_YUV444P10:
437 case AV_PIX_FMT_YUV444P12:
438 #if CONFIG_HEVC_NVDEC_HWACCEL
439 *fmt++ = AV_PIX_FMT_CUDA;
444 *fmt++ = sps->pix_fmt;
445 *fmt = AV_PIX_FMT_NONE;
447 return ff_thread_get_format(s->avctx, pix_fmts);
450 static int set_sps(HEVCContext *s, const HEVCSPS *sps,
451 enum AVPixelFormat pix_fmt)
462 ret = pic_arrays_init(s, sps);
466 export_stream_params(s, sps);
468 s->avctx->pix_fmt = pix_fmt;
470 ff_hevc_pred_init(&s->hpc, sps->bit_depth);
471 ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
472 ff_videodsp_init (&s->vdsp, sps->bit_depth);
474 for (i = 0; i < 3; i++) {
475 av_freep(&s->sao_pixel_buffer_h[i]);
476 av_freep(&s->sao_pixel_buffer_v[i]);
479 if (sps->sao_enabled && !s->avctx->hwaccel) {
480 int c_count = (sps->chroma_format_idc != 0) ? 3 : 1;
483 for(c_idx = 0; c_idx < c_count; c_idx++) {
484 int w = sps->width >> sps->hshift[c_idx];
485 int h = sps->height >> sps->vshift[c_idx];
486 s->sao_pixel_buffer_h[c_idx] =
487 av_malloc((w * 2 * sps->ctb_height) <<
489 s->sao_pixel_buffer_v[c_idx] =
490 av_malloc((h * 2 * sps->ctb_width) <<
496 s->ps.vps = (HEVCVPS*) s->ps.vps_list[s->ps.sps->vps_id]->data;
506 static int hls_slice_header(HEVCContext *s)
508 GetBitContext *gb = &s->HEVClc->gb;
509 SliceHeader *sh = &s->sh;
513 sh->first_slice_in_pic_flag = get_bits1(gb);
514 if (s->ref && sh->first_slice_in_pic_flag) {
515 av_log(s->avctx, AV_LOG_ERROR, "Two slices reporting being the first in the same frame.\n");
516 return 1; // This slice will be skipped later, do not corrupt state
519 if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
520 s->seq_decode = (s->seq_decode + 1) & 0xff;
523 ff_hevc_clear_refs(s);
525 sh->no_output_of_prior_pics_flag = 0;
527 sh->no_output_of_prior_pics_flag = get_bits1(gb);
529 sh->pps_id = get_ue_golomb_long(gb);
530 if (sh->pps_id >= HEVC_MAX_PPS_COUNT || !s->ps.pps_list[sh->pps_id]) {
531 av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
532 return AVERROR_INVALIDDATA;
534 if (!sh->first_slice_in_pic_flag &&
535 s->ps.pps != (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data) {
536 av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
537 return AVERROR_INVALIDDATA;
539 s->ps.pps = (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data;
540 if (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos == 1)
541 sh->no_output_of_prior_pics_flag = 1;
543 if (s->ps.sps != (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data) {
544 const HEVCSPS *sps = (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data;
545 const HEVCSPS *last_sps = s->ps.sps;
546 enum AVPixelFormat pix_fmt;
548 if (last_sps && IS_IRAP(s) && s->nal_unit_type != HEVC_NAL_CRA_NUT) {
549 if (sps->width != last_sps->width || sps->height != last_sps->height ||
550 sps->temporal_layer[sps->max_sub_layers - 1].max_dec_pic_buffering !=
551 last_sps->temporal_layer[last_sps->max_sub_layers - 1].max_dec_pic_buffering)
552 sh->no_output_of_prior_pics_flag = 0;
554 ff_hevc_clear_refs(s);
556 ret = set_sps(s, sps, sps->pix_fmt);
560 pix_fmt = get_format(s, sps);
563 s->avctx->pix_fmt = pix_fmt;
565 s->seq_decode = (s->seq_decode + 1) & 0xff;
569 sh->dependent_slice_segment_flag = 0;
570 if (!sh->first_slice_in_pic_flag) {
571 int slice_address_length;
573 if (s->ps.pps->dependent_slice_segments_enabled_flag)
574 sh->dependent_slice_segment_flag = get_bits1(gb);
576 slice_address_length = av_ceil_log2(s->ps.sps->ctb_width *
577 s->ps.sps->ctb_height);
578 sh->slice_segment_addr = get_bitsz(gb, slice_address_length);
579 if (sh->slice_segment_addr >= s->ps.sps->ctb_width * s->ps.sps->ctb_height) {
580 av_log(s->avctx, AV_LOG_ERROR,
581 "Invalid slice segment address: %u.\n",
582 sh->slice_segment_addr);
583 return AVERROR_INVALIDDATA;
586 if (!sh->dependent_slice_segment_flag) {
587 sh->slice_addr = sh->slice_segment_addr;
591 sh->slice_segment_addr = sh->slice_addr = 0;
593 s->slice_initialized = 0;
596 if (!sh->dependent_slice_segment_flag) {
597 s->slice_initialized = 0;
599 for (i = 0; i < s->ps.pps->num_extra_slice_header_bits; i++)
600 skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
602 sh->slice_type = get_ue_golomb_long(gb);
603 if (!(sh->slice_type == HEVC_SLICE_I ||
604 sh->slice_type == HEVC_SLICE_P ||
605 sh->slice_type == HEVC_SLICE_B)) {
606 av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
608 return AVERROR_INVALIDDATA;
610 if (IS_IRAP(s) && sh->slice_type != HEVC_SLICE_I) {
611 av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
612 return AVERROR_INVALIDDATA;
615 // when flag is not present, picture is inferred to be output
616 sh->pic_output_flag = 1;
617 if (s->ps.pps->output_flag_present_flag)
618 sh->pic_output_flag = get_bits1(gb);
620 if (s->ps.sps->separate_colour_plane_flag)
621 sh->colour_plane_id = get_bits(gb, 2);
626 sh->pic_order_cnt_lsb = get_bits(gb, s->ps.sps->log2_max_poc_lsb);
627 poc = ff_hevc_compute_poc(s->ps.sps, s->pocTid0, sh->pic_order_cnt_lsb, s->nal_unit_type);
628 if (!sh->first_slice_in_pic_flag && poc != s->poc) {
629 av_log(s->avctx, AV_LOG_WARNING,
630 "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
631 if (s->avctx->err_recognition & AV_EF_EXPLODE)
632 return AVERROR_INVALIDDATA;
637 sh->short_term_ref_pic_set_sps_flag = get_bits1(gb);
638 pos = get_bits_left(gb);
639 if (!sh->short_term_ref_pic_set_sps_flag) {
640 ret = ff_hevc_decode_short_term_rps(gb, s->avctx, &sh->slice_rps, s->ps.sps, 1);
644 sh->short_term_rps = &sh->slice_rps;
646 int numbits, rps_idx;
648 if (!s->ps.sps->nb_st_rps) {
649 av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
650 return AVERROR_INVALIDDATA;
653 numbits = av_ceil_log2(s->ps.sps->nb_st_rps);
654 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
655 sh->short_term_rps = &s->ps.sps->st_rps[rps_idx];
657 sh->short_term_ref_pic_set_size = pos - get_bits_left(gb);
659 pos = get_bits_left(gb);
660 ret = decode_lt_rps(s, &sh->long_term_rps, gb);
662 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
663 if (s->avctx->err_recognition & AV_EF_EXPLODE)
664 return AVERROR_INVALIDDATA;
666 sh->long_term_ref_pic_set_size = pos - get_bits_left(gb);
668 if (s->ps.sps->sps_temporal_mvp_enabled_flag)
669 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
671 sh->slice_temporal_mvp_enabled_flag = 0;
673 s->sh.short_term_rps = NULL;
678 if (sh->first_slice_in_pic_flag && s->temporal_id == 0 &&
679 s->nal_unit_type != HEVC_NAL_TRAIL_N &&
680 s->nal_unit_type != HEVC_NAL_TSA_N &&
681 s->nal_unit_type != HEVC_NAL_STSA_N &&
682 s->nal_unit_type != HEVC_NAL_RADL_N &&
683 s->nal_unit_type != HEVC_NAL_RADL_R &&
684 s->nal_unit_type != HEVC_NAL_RASL_N &&
685 s->nal_unit_type != HEVC_NAL_RASL_R)
688 if (s->ps.sps->sao_enabled) {
689 sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
690 if (s->ps.sps->chroma_format_idc) {
691 sh->slice_sample_adaptive_offset_flag[1] =
692 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
695 sh->slice_sample_adaptive_offset_flag[0] = 0;
696 sh->slice_sample_adaptive_offset_flag[1] = 0;
697 sh->slice_sample_adaptive_offset_flag[2] = 0;
700 sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
701 if (sh->slice_type == HEVC_SLICE_P || sh->slice_type == HEVC_SLICE_B) {
704 sh->nb_refs[L0] = s->ps.pps->num_ref_idx_l0_default_active;
705 if (sh->slice_type == HEVC_SLICE_B)
706 sh->nb_refs[L1] = s->ps.pps->num_ref_idx_l1_default_active;
708 if (get_bits1(gb)) { // num_ref_idx_active_override_flag
709 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
710 if (sh->slice_type == HEVC_SLICE_B)
711 sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
713 if (sh->nb_refs[L0] > HEVC_MAX_REFS || sh->nb_refs[L1] > HEVC_MAX_REFS) {
714 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
715 sh->nb_refs[L0], sh->nb_refs[L1]);
716 return AVERROR_INVALIDDATA;
719 sh->rpl_modification_flag[0] = 0;
720 sh->rpl_modification_flag[1] = 0;
721 nb_refs = ff_hevc_frame_nb_refs(s);
723 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
724 return AVERROR_INVALIDDATA;
727 if (s->ps.pps->lists_modification_present_flag && nb_refs > 1) {
728 sh->rpl_modification_flag[0] = get_bits1(gb);
729 if (sh->rpl_modification_flag[0]) {
730 for (i = 0; i < sh->nb_refs[L0]; i++)
731 sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
734 if (sh->slice_type == HEVC_SLICE_B) {
735 sh->rpl_modification_flag[1] = get_bits1(gb);
736 if (sh->rpl_modification_flag[1] == 1)
737 for (i = 0; i < sh->nb_refs[L1]; i++)
738 sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
742 if (sh->slice_type == HEVC_SLICE_B)
743 sh->mvd_l1_zero_flag = get_bits1(gb);
745 if (s->ps.pps->cabac_init_present_flag)
746 sh->cabac_init_flag = get_bits1(gb);
748 sh->cabac_init_flag = 0;
750 sh->collocated_ref_idx = 0;
751 if (sh->slice_temporal_mvp_enabled_flag) {
752 sh->collocated_list = L0;
753 if (sh->slice_type == HEVC_SLICE_B)
754 sh->collocated_list = !get_bits1(gb);
756 if (sh->nb_refs[sh->collocated_list] > 1) {
757 sh->collocated_ref_idx = get_ue_golomb_long(gb);
758 if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
759 av_log(s->avctx, AV_LOG_ERROR,
760 "Invalid collocated_ref_idx: %d.\n",
761 sh->collocated_ref_idx);
762 return AVERROR_INVALIDDATA;
767 if ((s->ps.pps->weighted_pred_flag && sh->slice_type == HEVC_SLICE_P) ||
768 (s->ps.pps->weighted_bipred_flag && sh->slice_type == HEVC_SLICE_B)) {
769 int ret = pred_weight_table(s, gb);
774 sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
775 if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
776 av_log(s->avctx, AV_LOG_ERROR,
777 "Invalid number of merging MVP candidates: %d.\n",
778 sh->max_num_merge_cand);
779 return AVERROR_INVALIDDATA;
783 sh->slice_qp_delta = get_se_golomb(gb);
785 if (s->ps.pps->pic_slice_level_chroma_qp_offsets_present_flag) {
786 sh->slice_cb_qp_offset = get_se_golomb(gb);
787 sh->slice_cr_qp_offset = get_se_golomb(gb);
789 sh->slice_cb_qp_offset = 0;
790 sh->slice_cr_qp_offset = 0;
793 if (s->ps.pps->chroma_qp_offset_list_enabled_flag)
794 sh->cu_chroma_qp_offset_enabled_flag = get_bits1(gb);
796 sh->cu_chroma_qp_offset_enabled_flag = 0;
798 if (s->ps.pps->deblocking_filter_control_present_flag) {
799 int deblocking_filter_override_flag = 0;
801 if (s->ps.pps->deblocking_filter_override_enabled_flag)
802 deblocking_filter_override_flag = get_bits1(gb);
804 if (deblocking_filter_override_flag) {
805 sh->disable_deblocking_filter_flag = get_bits1(gb);
806 if (!sh->disable_deblocking_filter_flag) {
807 int beta_offset_div2 = get_se_golomb(gb);
808 int tc_offset_div2 = get_se_golomb(gb) ;
809 if (beta_offset_div2 < -6 || beta_offset_div2 > 6 ||
810 tc_offset_div2 < -6 || tc_offset_div2 > 6) {
811 av_log(s->avctx, AV_LOG_ERROR,
812 "Invalid deblock filter offsets: %d, %d\n",
813 beta_offset_div2, tc_offset_div2);
814 return AVERROR_INVALIDDATA;
816 sh->beta_offset = beta_offset_div2 * 2;
817 sh->tc_offset = tc_offset_div2 * 2;
820 sh->disable_deblocking_filter_flag = s->ps.pps->disable_dbf;
821 sh->beta_offset = s->ps.pps->beta_offset;
822 sh->tc_offset = s->ps.pps->tc_offset;
825 sh->disable_deblocking_filter_flag = 0;
830 if (s->ps.pps->seq_loop_filter_across_slices_enabled_flag &&
831 (sh->slice_sample_adaptive_offset_flag[0] ||
832 sh->slice_sample_adaptive_offset_flag[1] ||
833 !sh->disable_deblocking_filter_flag)) {
834 sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
836 sh->slice_loop_filter_across_slices_enabled_flag = s->ps.pps->seq_loop_filter_across_slices_enabled_flag;
838 } else if (!s->slice_initialized) {
839 av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
840 return AVERROR_INVALIDDATA;
843 sh->num_entry_point_offsets = 0;
844 if (s->ps.pps->tiles_enabled_flag || s->ps.pps->entropy_coding_sync_enabled_flag) {
845 unsigned num_entry_point_offsets = get_ue_golomb_long(gb);
846 // It would be possible to bound this tighter but this here is simpler
847 if (num_entry_point_offsets > get_bits_left(gb)) {
848 av_log(s->avctx, AV_LOG_ERROR, "num_entry_point_offsets %d is invalid\n", num_entry_point_offsets);
849 return AVERROR_INVALIDDATA;
852 sh->num_entry_point_offsets = num_entry_point_offsets;
853 if (sh->num_entry_point_offsets > 0) {
854 int offset_len = get_ue_golomb_long(gb) + 1;
856 if (offset_len < 1 || offset_len > 32) {
857 sh->num_entry_point_offsets = 0;
858 av_log(s->avctx, AV_LOG_ERROR, "offset_len %d is invalid\n", offset_len);
859 return AVERROR_INVALIDDATA;
862 av_freep(&sh->entry_point_offset);
863 av_freep(&sh->offset);
865 sh->entry_point_offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(unsigned));
866 sh->offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
867 sh->size = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
868 if (!sh->entry_point_offset || !sh->offset || !sh->size) {
869 sh->num_entry_point_offsets = 0;
870 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate memory\n");
871 return AVERROR(ENOMEM);
873 for (i = 0; i < sh->num_entry_point_offsets; i++) {
874 unsigned val = get_bits_long(gb, offset_len);
875 sh->entry_point_offset[i] = val + 1; // +1; // +1 to get the size
877 if (s->threads_number > 1 && (s->ps.pps->num_tile_rows > 1 || s->ps.pps->num_tile_columns > 1)) {
878 s->enable_parallel_tiles = 0; // TODO: you can enable tiles in parallel here
879 s->threads_number = 1;
881 s->enable_parallel_tiles = 0;
883 s->enable_parallel_tiles = 0;
886 if (s->ps.pps->slice_header_extension_present_flag) {
887 unsigned int length = get_ue_golomb_long(gb);
888 if (length*8LL > get_bits_left(gb)) {
889 av_log(s->avctx, AV_LOG_ERROR, "too many slice_header_extension_data_bytes\n");
890 return AVERROR_INVALIDDATA;
892 for (i = 0; i < length; i++)
893 skip_bits(gb, 8); // slice_header_extension_data_byte
896 // Inferred parameters
897 sh->slice_qp = 26U + s->ps.pps->pic_init_qp_minus26 + sh->slice_qp_delta;
898 if (sh->slice_qp > 51 ||
899 sh->slice_qp < -s->ps.sps->qp_bd_offset) {
900 av_log(s->avctx, AV_LOG_ERROR,
901 "The slice_qp %d is outside the valid range "
904 -s->ps.sps->qp_bd_offset);
905 return AVERROR_INVALIDDATA;
908 sh->slice_ctb_addr_rs = sh->slice_segment_addr;
910 if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) {
911 av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
912 return AVERROR_INVALIDDATA;
915 if (get_bits_left(gb) < 0) {
916 av_log(s->avctx, AV_LOG_ERROR,
917 "Overread slice header by %d bits\n", -get_bits_left(gb));
918 return AVERROR_INVALIDDATA;
921 s->HEVClc->first_qp_group = !s->sh.dependent_slice_segment_flag;
923 if (!s->ps.pps->cu_qp_delta_enabled_flag)
924 s->HEVClc->qp_y = s->sh.slice_qp;
926 s->slice_initialized = 1;
927 s->HEVClc->tu.cu_qp_offset_cb = 0;
928 s->HEVClc->tu.cu_qp_offset_cr = 0;
933 #define CTB(tab, x, y) ((tab)[(y) * s->ps.sps->ctb_width + (x)])
935 #define SET_SAO(elem, value) \
937 if (!sao_merge_up_flag && !sao_merge_left_flag) \
939 else if (sao_merge_left_flag) \
940 sao->elem = CTB(s->sao, rx-1, ry).elem; \
941 else if (sao_merge_up_flag) \
942 sao->elem = CTB(s->sao, rx, ry-1).elem; \
947 static void hls_sao_param(HEVCContext *s, int rx, int ry)
949 HEVCLocalContext *lc = s->HEVClc;
950 int sao_merge_left_flag = 0;
951 int sao_merge_up_flag = 0;
952 SAOParams *sao = &CTB(s->sao, rx, ry);
955 if (s->sh.slice_sample_adaptive_offset_flag[0] ||
956 s->sh.slice_sample_adaptive_offset_flag[1]) {
958 if (lc->ctb_left_flag)
959 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
961 if (ry > 0 && !sao_merge_left_flag) {
963 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
967 for (c_idx = 0; c_idx < (s->ps.sps->chroma_format_idc ? 3 : 1); c_idx++) {
968 int log2_sao_offset_scale = c_idx == 0 ? s->ps.pps->log2_sao_offset_scale_luma :
969 s->ps.pps->log2_sao_offset_scale_chroma;
971 if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
972 sao->type_idx[c_idx] = SAO_NOT_APPLIED;
977 sao->type_idx[2] = sao->type_idx[1];
978 sao->eo_class[2] = sao->eo_class[1];
980 SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
983 if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
986 for (i = 0; i < 4; i++)
987 SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
989 if (sao->type_idx[c_idx] == SAO_BAND) {
990 for (i = 0; i < 4; i++) {
991 if (sao->offset_abs[c_idx][i]) {
992 SET_SAO(offset_sign[c_idx][i],
993 ff_hevc_sao_offset_sign_decode(s));
995 sao->offset_sign[c_idx][i] = 0;
998 SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
999 } else if (c_idx != 2) {
1000 SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
1003 // Inferred parameters
1004 sao->offset_val[c_idx][0] = 0;
1005 for (i = 0; i < 4; i++) {
1006 sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i];
1007 if (sao->type_idx[c_idx] == SAO_EDGE) {
1009 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
1010 } else if (sao->offset_sign[c_idx][i]) {
1011 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
1013 sao->offset_val[c_idx][i + 1] *= 1 << log2_sao_offset_scale;
1021 static int hls_cross_component_pred(HEVCContext *s, int idx) {
1022 HEVCLocalContext *lc = s->HEVClc;
1023 int log2_res_scale_abs_plus1 = ff_hevc_log2_res_scale_abs(s, idx);
1025 if (log2_res_scale_abs_plus1 != 0) {
1026 int res_scale_sign_flag = ff_hevc_res_scale_sign_flag(s, idx);
1027 lc->tu.res_scale_val = (1 << (log2_res_scale_abs_plus1 - 1)) *
1028 (1 - 2 * res_scale_sign_flag);
1030 lc->tu.res_scale_val = 0;
1037 static int hls_transform_unit(HEVCContext *s, int x0, int y0,
1038 int xBase, int yBase, int cb_xBase, int cb_yBase,
1039 int log2_cb_size, int log2_trafo_size,
1040 int blk_idx, int cbf_luma, int *cbf_cb, int *cbf_cr)
1042 HEVCLocalContext *lc = s->HEVClc;
1043 const int log2_trafo_size_c = log2_trafo_size - s->ps.sps->hshift[1];
1046 if (lc->cu.pred_mode == MODE_INTRA) {
1047 int trafo_size = 1 << log2_trafo_size;
1048 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1050 s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
1053 if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
1054 (s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1055 int scan_idx = SCAN_DIAG;
1056 int scan_idx_c = SCAN_DIAG;
1057 int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
1058 (s->ps.sps->chroma_format_idc == 2 &&
1059 (cbf_cb[1] || cbf_cr[1]));
1061 if (s->ps.pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
1062 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
1063 if (lc->tu.cu_qp_delta != 0)
1064 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
1065 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
1066 lc->tu.is_cu_qp_delta_coded = 1;
1068 if (lc->tu.cu_qp_delta < -(26 + s->ps.sps->qp_bd_offset / 2) ||
1069 lc->tu.cu_qp_delta > (25 + s->ps.sps->qp_bd_offset / 2)) {
1070 av_log(s->avctx, AV_LOG_ERROR,
1071 "The cu_qp_delta %d is outside the valid range "
1074 -(26 + s->ps.sps->qp_bd_offset / 2),
1075 (25 + s->ps.sps->qp_bd_offset / 2));
1076 return AVERROR_INVALIDDATA;
1079 ff_hevc_set_qPy(s, cb_xBase, cb_yBase, log2_cb_size);
1082 if (s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
1083 !lc->cu.cu_transquant_bypass_flag && !lc->tu.is_cu_chroma_qp_offset_coded) {
1084 int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(s);
1085 if (cu_chroma_qp_offset_flag) {
1086 int cu_chroma_qp_offset_idx = 0;
1087 if (s->ps.pps->chroma_qp_offset_list_len_minus1 > 0) {
1088 cu_chroma_qp_offset_idx = ff_hevc_cu_chroma_qp_offset_idx(s);
1089 av_log(s->avctx, AV_LOG_ERROR,
1090 "cu_chroma_qp_offset_idx not yet tested.\n");
1092 lc->tu.cu_qp_offset_cb = s->ps.pps->cb_qp_offset_list[cu_chroma_qp_offset_idx];
1093 lc->tu.cu_qp_offset_cr = s->ps.pps->cr_qp_offset_list[cu_chroma_qp_offset_idx];
1095 lc->tu.cu_qp_offset_cb = 0;
1096 lc->tu.cu_qp_offset_cr = 0;
1098 lc->tu.is_cu_chroma_qp_offset_coded = 1;
1101 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
1102 if (lc->tu.intra_pred_mode >= 6 &&
1103 lc->tu.intra_pred_mode <= 14) {
1104 scan_idx = SCAN_VERT;
1105 } else if (lc->tu.intra_pred_mode >= 22 &&
1106 lc->tu.intra_pred_mode <= 30) {
1107 scan_idx = SCAN_HORIZ;
1110 if (lc->tu.intra_pred_mode_c >= 6 &&
1111 lc->tu.intra_pred_mode_c <= 14) {
1112 scan_idx_c = SCAN_VERT;
1113 } else if (lc->tu.intra_pred_mode_c >= 22 &&
1114 lc->tu.intra_pred_mode_c <= 30) {
1115 scan_idx_c = SCAN_HORIZ;
1119 lc->tu.cross_pf = 0;
1122 ff_hevc_hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
1123 if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) {
1124 int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]);
1125 int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]);
1126 lc->tu.cross_pf = (s->ps.pps->cross_component_prediction_enabled_flag && cbf_luma &&
1127 (lc->cu.pred_mode == MODE_INTER ||
1128 (lc->tu.chroma_mode_c == 4)));
1130 if (lc->tu.cross_pf) {
1131 hls_cross_component_pred(s, 0);
1133 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1134 if (lc->cu.pred_mode == MODE_INTRA) {
1135 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1136 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 1);
1139 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1140 log2_trafo_size_c, scan_idx_c, 1);
1142 if (lc->tu.cross_pf) {
1143 ptrdiff_t stride = s->frame->linesize[1];
1144 int hshift = s->ps.sps->hshift[1];
1145 int vshift = s->ps.sps->vshift[1];
1146 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1147 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1148 int size = 1 << log2_trafo_size_c;
1150 uint8_t *dst = &s->frame->data[1][(y0 >> vshift) * stride +
1151 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1152 for (i = 0; i < (size * size); i++) {
1153 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1155 s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
1159 if (lc->tu.cross_pf) {
1160 hls_cross_component_pred(s, 1);
1162 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1163 if (lc->cu.pred_mode == MODE_INTRA) {
1164 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1165 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 2);
1168 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1169 log2_trafo_size_c, scan_idx_c, 2);
1171 if (lc->tu.cross_pf) {
1172 ptrdiff_t stride = s->frame->linesize[2];
1173 int hshift = s->ps.sps->hshift[2];
1174 int vshift = s->ps.sps->vshift[2];
1175 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1176 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1177 int size = 1 << log2_trafo_size_c;
1179 uint8_t *dst = &s->frame->data[2][(y0 >> vshift) * stride +
1180 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1181 for (i = 0; i < (size * size); i++) {
1182 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1184 s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
1187 } else if (s->ps.sps->chroma_format_idc && blk_idx == 3) {
1188 int trafo_size_h = 1 << (log2_trafo_size + 1);
1189 int trafo_size_v = 1 << (log2_trafo_size + s->ps.sps->vshift[1]);
1190 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1191 if (lc->cu.pred_mode == MODE_INTRA) {
1192 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1193 trafo_size_h, trafo_size_v);
1194 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 1);
1197 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1198 log2_trafo_size, scan_idx_c, 1);
1200 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1201 if (lc->cu.pred_mode == MODE_INTRA) {
1202 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1203 trafo_size_h, trafo_size_v);
1204 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 2);
1207 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1208 log2_trafo_size, scan_idx_c, 2);
1211 } else if (s->ps.sps->chroma_format_idc && lc->cu.pred_mode == MODE_INTRA) {
1212 if (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3) {
1213 int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]);
1214 int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]);
1215 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size_h, trafo_size_v);
1216 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 1);
1217 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 2);
1218 if (s->ps.sps->chroma_format_idc == 2) {
1219 ff_hevc_set_neighbour_available(s, x0, y0 + (1 << log2_trafo_size_c),
1220 trafo_size_h, trafo_size_v);
1221 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 1);
1222 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 2);
1224 } else if (blk_idx == 3) {
1225 int trafo_size_h = 1 << (log2_trafo_size + 1);
1226 int trafo_size_v = 1 << (log2_trafo_size + s->ps.sps->vshift[1]);
1227 ff_hevc_set_neighbour_available(s, xBase, yBase,
1228 trafo_size_h, trafo_size_v);
1229 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1230 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1231 if (s->ps.sps->chroma_format_idc == 2) {
1232 ff_hevc_set_neighbour_available(s, xBase, yBase + (1 << (log2_trafo_size)),
1233 trafo_size_h, trafo_size_v);
1234 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 1);
1235 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 2);
1243 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1245 int cb_size = 1 << log2_cb_size;
1246 int log2_min_pu_size = s->ps.sps->log2_min_pu_size;
1248 int min_pu_width = s->ps.sps->min_pu_width;
1249 int x_end = FFMIN(x0 + cb_size, s->ps.sps->width);
1250 int y_end = FFMIN(y0 + cb_size, s->ps.sps->height);
1253 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1254 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1255 s->is_pcm[i + j * min_pu_width] = 2;
1258 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1259 int xBase, int yBase, int cb_xBase, int cb_yBase,
1260 int log2_cb_size, int log2_trafo_size,
1261 int trafo_depth, int blk_idx,
1262 const int *base_cbf_cb, const int *base_cbf_cr)
1264 HEVCLocalContext *lc = s->HEVClc;
1265 uint8_t split_transform_flag;
1270 cbf_cb[0] = base_cbf_cb[0];
1271 cbf_cb[1] = base_cbf_cb[1];
1272 cbf_cr[0] = base_cbf_cr[0];
1273 cbf_cr[1] = base_cbf_cr[1];
1275 if (lc->cu.intra_split_flag) {
1276 if (trafo_depth == 1) {
1277 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1278 if (s->ps.sps->chroma_format_idc == 3) {
1279 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[blk_idx];
1280 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[blk_idx];
1282 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1283 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1287 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[0];
1288 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1289 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1292 if (log2_trafo_size <= s->ps.sps->log2_max_trafo_size &&
1293 log2_trafo_size > s->ps.sps->log2_min_tb_size &&
1294 trafo_depth < lc->cu.max_trafo_depth &&
1295 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1296 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1298 int inter_split = s->ps.sps->max_transform_hierarchy_depth_inter == 0 &&
1299 lc->cu.pred_mode == MODE_INTER &&
1300 lc->cu.part_mode != PART_2Nx2N &&
1303 split_transform_flag = log2_trafo_size > s->ps.sps->log2_max_trafo_size ||
1304 (lc->cu.intra_split_flag && trafo_depth == 0) ||
1308 if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) {
1309 if (trafo_depth == 0 || cbf_cb[0]) {
1310 cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1311 if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1312 cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1316 if (trafo_depth == 0 || cbf_cr[0]) {
1317 cbf_cr[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1318 if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1319 cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1324 if (split_transform_flag) {
1325 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1326 const int x1 = x0 + trafo_size_split;
1327 const int y1 = y0 + trafo_size_split;
1329 #define SUBDIVIDE(x, y, idx) \
1331 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1332 log2_trafo_size - 1, trafo_depth + 1, idx, \
1338 SUBDIVIDE(x0, y0, 0);
1339 SUBDIVIDE(x1, y0, 1);
1340 SUBDIVIDE(x0, y1, 2);
1341 SUBDIVIDE(x1, y1, 3);
1345 int min_tu_size = 1 << s->ps.sps->log2_min_tb_size;
1346 int log2_min_tu_size = s->ps.sps->log2_min_tb_size;
1347 int min_tu_width = s->ps.sps->min_tb_width;
1350 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1351 cbf_cb[0] || cbf_cr[0] ||
1352 (s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1353 cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1356 ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1357 log2_cb_size, log2_trafo_size,
1358 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1361 // TODO: store cbf_luma somewhere else
1364 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1365 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1366 int x_tu = (x0 + j) >> log2_min_tu_size;
1367 int y_tu = (y0 + i) >> log2_min_tu_size;
1368 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1371 if (!s->sh.disable_deblocking_filter_flag) {
1372 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1373 if (s->ps.pps->transquant_bypass_enable_flag &&
1374 lc->cu.cu_transquant_bypass_flag)
1375 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1381 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1383 HEVCLocalContext *lc = s->HEVClc;
1385 int cb_size = 1 << log2_cb_size;
1386 ptrdiff_t stride0 = s->frame->linesize[0];
1387 ptrdiff_t stride1 = s->frame->linesize[1];
1388 ptrdiff_t stride2 = s->frame->linesize[2];
1389 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->ps.sps->pixel_shift)];
1390 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)];
1391 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)];
1393 int length = cb_size * cb_size * s->ps.sps->pcm.bit_depth +
1394 (((cb_size >> s->ps.sps->hshift[1]) * (cb_size >> s->ps.sps->vshift[1])) +
1395 ((cb_size >> s->ps.sps->hshift[2]) * (cb_size >> s->ps.sps->vshift[2]))) *
1396 s->ps.sps->pcm.bit_depth_chroma;
1397 const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1400 if (!s->sh.disable_deblocking_filter_flag)
1401 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1403 ret = init_get_bits(&gb, pcm, length);
1407 s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size, &gb, s->ps.sps->pcm.bit_depth);
1408 if (s->ps.sps->chroma_format_idc) {
1409 s->hevcdsp.put_pcm(dst1, stride1,
1410 cb_size >> s->ps.sps->hshift[1],
1411 cb_size >> s->ps.sps->vshift[1],
1412 &gb, s->ps.sps->pcm.bit_depth_chroma);
1413 s->hevcdsp.put_pcm(dst2, stride2,
1414 cb_size >> s->ps.sps->hshift[2],
1415 cb_size >> s->ps.sps->vshift[2],
1416 &gb, s->ps.sps->pcm.bit_depth_chroma);
1423 * 8.5.3.2.2.1 Luma sample unidirectional interpolation process
1425 * @param s HEVC decoding context
1426 * @param dst target buffer for block data at block position
1427 * @param dststride stride of the dst buffer
1428 * @param ref reference picture buffer at origin (0, 0)
1429 * @param mv motion vector (relative to block position) to get pixel data from
1430 * @param x_off horizontal position of block from origin (0, 0)
1431 * @param y_off vertical position of block from origin (0, 0)
1432 * @param block_w width of block
1433 * @param block_h height of block
1434 * @param luma_weight weighting factor applied to the luma prediction
1435 * @param luma_offset additive offset applied to the luma prediction value
1438 static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1439 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1440 int block_w, int block_h, int luma_weight, int luma_offset)
1442 HEVCLocalContext *lc = s->HEVClc;
1443 uint8_t *src = ref->data[0];
1444 ptrdiff_t srcstride = ref->linesize[0];
1445 int pic_width = s->ps.sps->width;
1446 int pic_height = s->ps.sps->height;
1449 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1450 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1451 int idx = ff_hevc_pel_weight[block_w];
1453 x_off += mv->x >> 2;
1454 y_off += mv->y >> 2;
1455 src += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1457 if (x_off < QPEL_EXTRA_BEFORE || y_off < QPEL_EXTRA_AFTER ||
1458 x_off >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1459 y_off >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1460 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1461 int offset = QPEL_EXTRA_BEFORE * srcstride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1462 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1464 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1465 edge_emu_stride, srcstride,
1466 block_w + QPEL_EXTRA,
1467 block_h + QPEL_EXTRA,
1468 x_off - QPEL_EXTRA_BEFORE, y_off - QPEL_EXTRA_BEFORE,
1469 pic_width, pic_height);
1470 src = lc->edge_emu_buffer + buf_offset;
1471 srcstride = edge_emu_stride;
1475 s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride, src, srcstride,
1476 block_h, mx, my, block_w);
1478 s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride, src, srcstride,
1479 block_h, s->sh.luma_log2_weight_denom,
1480 luma_weight, luma_offset, mx, my, block_w);
1484 * 8.5.3.2.2.1 Luma sample bidirectional interpolation process
1486 * @param s HEVC decoding context
1487 * @param dst target buffer for block data at block position
1488 * @param dststride stride of the dst buffer
1489 * @param ref0 reference picture0 buffer at origin (0, 0)
1490 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1491 * @param x_off horizontal position of block from origin (0, 0)
1492 * @param y_off vertical position of block from origin (0, 0)
1493 * @param block_w width of block
1494 * @param block_h height of block
1495 * @param ref1 reference picture1 buffer at origin (0, 0)
1496 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1497 * @param current_mv current motion vector structure
1499 static void luma_mc_bi(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1500 AVFrame *ref0, const Mv *mv0, int x_off, int y_off,
1501 int block_w, int block_h, AVFrame *ref1, const Mv *mv1, struct MvField *current_mv)
1503 HEVCLocalContext *lc = s->HEVClc;
1504 ptrdiff_t src0stride = ref0->linesize[0];
1505 ptrdiff_t src1stride = ref1->linesize[0];
1506 int pic_width = s->ps.sps->width;
1507 int pic_height = s->ps.sps->height;
1508 int mx0 = mv0->x & 3;
1509 int my0 = mv0->y & 3;
1510 int mx1 = mv1->x & 3;
1511 int my1 = mv1->y & 3;
1512 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1513 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1514 int x_off0 = x_off + (mv0->x >> 2);
1515 int y_off0 = y_off + (mv0->y >> 2);
1516 int x_off1 = x_off + (mv1->x >> 2);
1517 int y_off1 = y_off + (mv1->y >> 2);
1518 int idx = ff_hevc_pel_weight[block_w];
1520 uint8_t *src0 = ref0->data[0] + y_off0 * src0stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift);
1521 uint8_t *src1 = ref1->data[0] + y_off1 * src1stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift);
1523 if (x_off0 < QPEL_EXTRA_BEFORE || y_off0 < QPEL_EXTRA_AFTER ||
1524 x_off0 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1525 y_off0 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1526 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1527 int offset = QPEL_EXTRA_BEFORE * src0stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1528 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1530 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset,
1531 edge_emu_stride, src0stride,
1532 block_w + QPEL_EXTRA,
1533 block_h + QPEL_EXTRA,
1534 x_off0 - QPEL_EXTRA_BEFORE, y_off0 - QPEL_EXTRA_BEFORE,
1535 pic_width, pic_height);
1536 src0 = lc->edge_emu_buffer + buf_offset;
1537 src0stride = edge_emu_stride;
1540 if (x_off1 < QPEL_EXTRA_BEFORE || y_off1 < QPEL_EXTRA_AFTER ||
1541 x_off1 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1542 y_off1 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1543 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1544 int offset = QPEL_EXTRA_BEFORE * src1stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1545 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1547 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src1 - offset,
1548 edge_emu_stride, src1stride,
1549 block_w + QPEL_EXTRA,
1550 block_h + QPEL_EXTRA,
1551 x_off1 - QPEL_EXTRA_BEFORE, y_off1 - QPEL_EXTRA_BEFORE,
1552 pic_width, pic_height);
1553 src1 = lc->edge_emu_buffer2 + buf_offset;
1554 src1stride = edge_emu_stride;
1557 s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](lc->tmp, src0, src0stride,
1558 block_h, mx0, my0, block_w);
1560 s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1561 block_h, mx1, my1, block_w);
1563 s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1564 block_h, s->sh.luma_log2_weight_denom,
1565 s->sh.luma_weight_l0[current_mv->ref_idx[0]],
1566 s->sh.luma_weight_l1[current_mv->ref_idx[1]],
1567 s->sh.luma_offset_l0[current_mv->ref_idx[0]],
1568 s->sh.luma_offset_l1[current_mv->ref_idx[1]],
1574 * 8.5.3.2.2.2 Chroma sample uniprediction interpolation process
1576 * @param s HEVC decoding context
1577 * @param dst1 target buffer for block data at block position (U plane)
1578 * @param dst2 target buffer for block data at block position (V plane)
1579 * @param dststride stride of the dst1 and dst2 buffers
1580 * @param ref reference picture buffer at origin (0, 0)
1581 * @param mv motion vector (relative to block position) to get pixel data from
1582 * @param x_off horizontal position of block from origin (0, 0)
1583 * @param y_off vertical position of block from origin (0, 0)
1584 * @param block_w width of block
1585 * @param block_h height of block
1586 * @param chroma_weight weighting factor applied to the chroma prediction
1587 * @param chroma_offset additive offset applied to the chroma prediction value
1590 static void chroma_mc_uni(HEVCContext *s, uint8_t *dst0,
1591 ptrdiff_t dststride, uint8_t *src0, ptrdiff_t srcstride, int reflist,
1592 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int chroma_weight, int chroma_offset)
1594 HEVCLocalContext *lc = s->HEVClc;
1595 int pic_width = s->ps.sps->width >> s->ps.sps->hshift[1];
1596 int pic_height = s->ps.sps->height >> s->ps.sps->vshift[1];
1597 const Mv *mv = ¤t_mv->mv[reflist];
1598 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1599 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1600 int idx = ff_hevc_pel_weight[block_w];
1601 int hshift = s->ps.sps->hshift[1];
1602 int vshift = s->ps.sps->vshift[1];
1603 intptr_t mx = av_mod_uintp2(mv->x, 2 + hshift);
1604 intptr_t my = av_mod_uintp2(mv->y, 2 + vshift);
1605 intptr_t _mx = mx << (1 - hshift);
1606 intptr_t _my = my << (1 - vshift);
1608 x_off += mv->x >> (2 + hshift);
1609 y_off += mv->y >> (2 + vshift);
1610 src0 += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1612 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1613 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1614 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1615 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1616 int offset0 = EPEL_EXTRA_BEFORE * (srcstride + (1 << s->ps.sps->pixel_shift));
1617 int buf_offset0 = EPEL_EXTRA_BEFORE *
1618 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1619 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset0,
1620 edge_emu_stride, srcstride,
1621 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1622 x_off - EPEL_EXTRA_BEFORE,
1623 y_off - EPEL_EXTRA_BEFORE,
1624 pic_width, pic_height);
1626 src0 = lc->edge_emu_buffer + buf_offset0;
1627 srcstride = edge_emu_stride;
1630 s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1631 block_h, _mx, _my, block_w);
1633 s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1634 block_h, s->sh.chroma_log2_weight_denom,
1635 chroma_weight, chroma_offset, _mx, _my, block_w);
1639 * 8.5.3.2.2.2 Chroma sample bidirectional interpolation process
1641 * @param s HEVC decoding context
1642 * @param dst target buffer for block data at block position
1643 * @param dststride stride of the dst buffer
1644 * @param ref0 reference picture0 buffer at origin (0, 0)
1645 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1646 * @param x_off horizontal position of block from origin (0, 0)
1647 * @param y_off vertical position of block from origin (0, 0)
1648 * @param block_w width of block
1649 * @param block_h height of block
1650 * @param ref1 reference picture1 buffer at origin (0, 0)
1651 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1652 * @param current_mv current motion vector structure
1653 * @param cidx chroma component(cb, cr)
1655 static void chroma_mc_bi(HEVCContext *s, uint8_t *dst0, ptrdiff_t dststride, AVFrame *ref0, AVFrame *ref1,
1656 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int cidx)
1658 HEVCLocalContext *lc = s->HEVClc;
1659 uint8_t *src1 = ref0->data[cidx+1];
1660 uint8_t *src2 = ref1->data[cidx+1];
1661 ptrdiff_t src1stride = ref0->linesize[cidx+1];
1662 ptrdiff_t src2stride = ref1->linesize[cidx+1];
1663 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1664 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1665 int pic_width = s->ps.sps->width >> s->ps.sps->hshift[1];
1666 int pic_height = s->ps.sps->height >> s->ps.sps->vshift[1];
1667 Mv *mv0 = ¤t_mv->mv[0];
1668 Mv *mv1 = ¤t_mv->mv[1];
1669 int hshift = s->ps.sps->hshift[1];
1670 int vshift = s->ps.sps->vshift[1];
1672 intptr_t mx0 = av_mod_uintp2(mv0->x, 2 + hshift);
1673 intptr_t my0 = av_mod_uintp2(mv0->y, 2 + vshift);
1674 intptr_t mx1 = av_mod_uintp2(mv1->x, 2 + hshift);
1675 intptr_t my1 = av_mod_uintp2(mv1->y, 2 + vshift);
1676 intptr_t _mx0 = mx0 << (1 - hshift);
1677 intptr_t _my0 = my0 << (1 - vshift);
1678 intptr_t _mx1 = mx1 << (1 - hshift);
1679 intptr_t _my1 = my1 << (1 - vshift);
1681 int x_off0 = x_off + (mv0->x >> (2 + hshift));
1682 int y_off0 = y_off + (mv0->y >> (2 + vshift));
1683 int x_off1 = x_off + (mv1->x >> (2 + hshift));
1684 int y_off1 = y_off + (mv1->y >> (2 + vshift));
1685 int idx = ff_hevc_pel_weight[block_w];
1686 src1 += y_off0 * src1stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift);
1687 src2 += y_off1 * src2stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift);
1689 if (x_off0 < EPEL_EXTRA_BEFORE || y_off0 < EPEL_EXTRA_AFTER ||
1690 x_off0 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1691 y_off0 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1692 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1693 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->ps.sps->pixel_shift));
1694 int buf_offset1 = EPEL_EXTRA_BEFORE *
1695 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1697 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1698 edge_emu_stride, src1stride,
1699 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1700 x_off0 - EPEL_EXTRA_BEFORE,
1701 y_off0 - EPEL_EXTRA_BEFORE,
1702 pic_width, pic_height);
1704 src1 = lc->edge_emu_buffer + buf_offset1;
1705 src1stride = edge_emu_stride;
1708 if (x_off1 < EPEL_EXTRA_BEFORE || y_off1 < EPEL_EXTRA_AFTER ||
1709 x_off1 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1710 y_off1 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1711 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1712 int offset1 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->ps.sps->pixel_shift));
1713 int buf_offset1 = EPEL_EXTRA_BEFORE *
1714 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1716 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src2 - offset1,
1717 edge_emu_stride, src2stride,
1718 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1719 x_off1 - EPEL_EXTRA_BEFORE,
1720 y_off1 - EPEL_EXTRA_BEFORE,
1721 pic_width, pic_height);
1723 src2 = lc->edge_emu_buffer2 + buf_offset1;
1724 src2stride = edge_emu_stride;
1727 s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](lc->tmp, src1, src1stride,
1728 block_h, _mx0, _my0, block_w);
1730 s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1731 src2, src2stride, lc->tmp,
1732 block_h, _mx1, _my1, block_w);
1734 s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1735 src2, src2stride, lc->tmp,
1737 s->sh.chroma_log2_weight_denom,
1738 s->sh.chroma_weight_l0[current_mv->ref_idx[0]][cidx],
1739 s->sh.chroma_weight_l1[current_mv->ref_idx[1]][cidx],
1740 s->sh.chroma_offset_l0[current_mv->ref_idx[0]][cidx],
1741 s->sh.chroma_offset_l1[current_mv->ref_idx[1]][cidx],
1742 _mx1, _my1, block_w);
1745 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1746 const Mv *mv, int y0, int height)
1748 if (s->threads_type == FF_THREAD_FRAME ) {
1749 int y = FFMAX(0, (mv->y >> 2) + y0 + height + 9);
1751 ff_thread_await_progress(&ref->tf, y, 0);
1755 static void hevc_luma_mv_mvp_mode(HEVCContext *s, int x0, int y0, int nPbW,
1756 int nPbH, int log2_cb_size, int part_idx,
1757 int merge_idx, MvField *mv)
1759 HEVCLocalContext *lc = s->HEVClc;
1760 enum InterPredIdc inter_pred_idc = PRED_L0;
1763 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1765 if (s->sh.slice_type == HEVC_SLICE_B)
1766 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1768 if (inter_pred_idc != PRED_L1) {
1769 if (s->sh.nb_refs[L0])
1770 mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1772 mv->pred_flag = PF_L0;
1773 ff_hevc_hls_mvd_coding(s, x0, y0, 0);
1774 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1775 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1776 part_idx, merge_idx, mv, mvp_flag, 0);
1777 mv->mv[0].x += lc->pu.mvd.x;
1778 mv->mv[0].y += lc->pu.mvd.y;
1781 if (inter_pred_idc != PRED_L0) {
1782 if (s->sh.nb_refs[L1])
1783 mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1785 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1786 AV_ZERO32(&lc->pu.mvd);
1788 ff_hevc_hls_mvd_coding(s, x0, y0, 1);
1791 mv->pred_flag += PF_L1;
1792 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1793 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1794 part_idx, merge_idx, mv, mvp_flag, 1);
1795 mv->mv[1].x += lc->pu.mvd.x;
1796 mv->mv[1].y += lc->pu.mvd.y;
1800 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1802 int log2_cb_size, int partIdx, int idx)
1804 #define POS(c_idx, x, y) \
1805 &s->frame->data[c_idx][((y) >> s->ps.sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1806 (((x) >> s->ps.sps->hshift[c_idx]) << s->ps.sps->pixel_shift)]
1807 HEVCLocalContext *lc = s->HEVClc;
1809 struct MvField current_mv = {{{ 0 }}};
1811 int min_pu_width = s->ps.sps->min_pu_width;
1813 MvField *tab_mvf = s->ref->tab_mvf;
1814 RefPicList *refPicList = s->ref->refPicList;
1815 HEVCFrame *ref0 = NULL, *ref1 = NULL;
1816 uint8_t *dst0 = POS(0, x0, y0);
1817 uint8_t *dst1 = POS(1, x0, y0);
1818 uint8_t *dst2 = POS(2, x0, y0);
1819 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
1820 int min_cb_width = s->ps.sps->min_cb_width;
1821 int x_cb = x0 >> log2_min_cb_size;
1822 int y_cb = y0 >> log2_min_cb_size;
1826 int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1829 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1831 if (skip_flag || lc->pu.merge_flag) {
1832 if (s->sh.max_num_merge_cand > 1)
1833 merge_idx = ff_hevc_merge_idx_decode(s);
1837 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1838 partIdx, merge_idx, ¤t_mv);
1840 hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1841 partIdx, merge_idx, ¤t_mv);
1844 x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1845 y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1847 for (j = 0; j < nPbH >> s->ps.sps->log2_min_pu_size; j++)
1848 for (i = 0; i < nPbW >> s->ps.sps->log2_min_pu_size; i++)
1849 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1851 if (current_mv.pred_flag & PF_L0) {
1852 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1855 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1857 if (current_mv.pred_flag & PF_L1) {
1858 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1861 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1864 if (current_mv.pred_flag == PF_L0) {
1865 int x0_c = x0 >> s->ps.sps->hshift[1];
1866 int y0_c = y0 >> s->ps.sps->vshift[1];
1867 int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1868 int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1870 luma_mc_uni(s, dst0, s->frame->linesize[0], ref0->frame,
1871 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1872 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1873 s->sh.luma_offset_l0[current_mv.ref_idx[0]]);
1875 if (s->ps.sps->chroma_format_idc) {
1876 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref0->frame->data[1], ref0->frame->linesize[1],
1877 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1878 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]);
1879 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref0->frame->data[2], ref0->frame->linesize[2],
1880 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1881 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]);
1883 } else if (current_mv.pred_flag == PF_L1) {
1884 int x0_c = x0 >> s->ps.sps->hshift[1];
1885 int y0_c = y0 >> s->ps.sps->vshift[1];
1886 int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1887 int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1889 luma_mc_uni(s, dst0, s->frame->linesize[0], ref1->frame,
1890 ¤t_mv.mv[1], x0, y0, nPbW, nPbH,
1891 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1892 s->sh.luma_offset_l1[current_mv.ref_idx[1]]);
1894 if (s->ps.sps->chroma_format_idc) {
1895 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
1896 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1897 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]);
1899 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
1900 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1901 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]);
1903 } else if (current_mv.pred_flag == PF_BI) {
1904 int x0_c = x0 >> s->ps.sps->hshift[1];
1905 int y0_c = y0 >> s->ps.sps->vshift[1];
1906 int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1907 int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1909 luma_mc_bi(s, dst0, s->frame->linesize[0], ref0->frame,
1910 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1911 ref1->frame, ¤t_mv.mv[1], ¤t_mv);
1913 if (s->ps.sps->chroma_format_idc) {
1914 chroma_mc_bi(s, dst1, s->frame->linesize[1], ref0->frame, ref1->frame,
1915 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 0);
1917 chroma_mc_bi(s, dst2, s->frame->linesize[2], ref0->frame, ref1->frame,
1918 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1);
1926 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1927 int prev_intra_luma_pred_flag)
1929 HEVCLocalContext *lc = s->HEVClc;
1930 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1931 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1932 int min_pu_width = s->ps.sps->min_pu_width;
1933 int size_in_pus = pu_size >> s->ps.sps->log2_min_pu_size;
1934 int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
1935 int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
1937 int cand_up = (lc->ctb_up_flag || y0b) ?
1938 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1939 int cand_left = (lc->ctb_left_flag || x0b) ?
1940 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1942 int y_ctb = (y0 >> (s->ps.sps->log2_ctb_size)) << (s->ps.sps->log2_ctb_size);
1944 MvField *tab_mvf = s->ref->tab_mvf;
1945 int intra_pred_mode;
1949 // intra_pred_mode prediction does not cross vertical CTB boundaries
1950 if ((y0 - 1) < y_ctb)
1953 if (cand_left == cand_up) {
1954 if (cand_left < 2) {
1955 candidate[0] = INTRA_PLANAR;
1956 candidate[1] = INTRA_DC;
1957 candidate[2] = INTRA_ANGULAR_26;
1959 candidate[0] = cand_left;
1960 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1961 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1964 candidate[0] = cand_left;
1965 candidate[1] = cand_up;
1966 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1967 candidate[2] = INTRA_PLANAR;
1968 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1969 candidate[2] = INTRA_DC;
1971 candidate[2] = INTRA_ANGULAR_26;
1975 if (prev_intra_luma_pred_flag) {
1976 intra_pred_mode = candidate[lc->pu.mpm_idx];
1978 if (candidate[0] > candidate[1])
1979 FFSWAP(uint8_t, candidate[0], candidate[1]);
1980 if (candidate[0] > candidate[2])
1981 FFSWAP(uint8_t, candidate[0], candidate[2]);
1982 if (candidate[1] > candidate[2])
1983 FFSWAP(uint8_t, candidate[1], candidate[2]);
1985 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1986 for (i = 0; i < 3; i++)
1987 if (intra_pred_mode >= candidate[i])
1991 /* write the intra prediction units into the mv array */
1994 for (i = 0; i < size_in_pus; i++) {
1995 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1996 intra_pred_mode, size_in_pus);
1998 for (j = 0; j < size_in_pus; j++) {
1999 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag = PF_INTRA;
2003 return intra_pred_mode;
2006 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
2007 int log2_cb_size, int ct_depth)
2009 int length = (1 << log2_cb_size) >> s->ps.sps->log2_min_cb_size;
2010 int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
2011 int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
2014 for (y = 0; y < length; y++)
2015 memset(&s->tab_ct_depth[(y_cb + y) * s->ps.sps->min_cb_width + x_cb],
2019 static const uint8_t tab_mode_idx[] = {
2020 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
2021 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
2023 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
2026 HEVCLocalContext *lc = s->HEVClc;
2027 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
2028 uint8_t prev_intra_luma_pred_flag[4];
2029 int split = lc->cu.part_mode == PART_NxN;
2030 int pb_size = (1 << log2_cb_size) >> split;
2031 int side = split + 1;
2035 for (i = 0; i < side; i++)
2036 for (j = 0; j < side; j++)
2037 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
2039 for (i = 0; i < side; i++) {
2040 for (j = 0; j < side; j++) {
2041 if (prev_intra_luma_pred_flag[2 * i + j])
2042 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
2044 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
2046 lc->pu.intra_pred_mode[2 * i + j] =
2047 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
2048 prev_intra_luma_pred_flag[2 * i + j]);
2052 if (s->ps.sps->chroma_format_idc == 3) {
2053 for (i = 0; i < side; i++) {
2054 for (j = 0; j < side; j++) {
2055 lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
2056 if (chroma_mode != 4) {
2057 if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode])
2058 lc->pu.intra_pred_mode_c[2 * i + j] = 34;
2060 lc->pu.intra_pred_mode_c[2 * i + j] = intra_chroma_table[chroma_mode];
2062 lc->pu.intra_pred_mode_c[2 * i + j] = lc->pu.intra_pred_mode[2 * i + j];
2066 } else if (s->ps.sps->chroma_format_idc == 2) {
2068 lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
2069 if (chroma_mode != 4) {
2070 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
2073 mode_idx = intra_chroma_table[chroma_mode];
2075 mode_idx = lc->pu.intra_pred_mode[0];
2077 lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx];
2078 } else if (s->ps.sps->chroma_format_idc != 0) {
2079 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
2080 if (chroma_mode != 4) {
2081 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
2082 lc->pu.intra_pred_mode_c[0] = 34;
2084 lc->pu.intra_pred_mode_c[0] = intra_chroma_table[chroma_mode];
2086 lc->pu.intra_pred_mode_c[0] = lc->pu.intra_pred_mode[0];
2091 static void intra_prediction_unit_default_value(HEVCContext *s,
2095 HEVCLocalContext *lc = s->HEVClc;
2096 int pb_size = 1 << log2_cb_size;
2097 int size_in_pus = pb_size >> s->ps.sps->log2_min_pu_size;
2098 int min_pu_width = s->ps.sps->min_pu_width;
2099 MvField *tab_mvf = s->ref->tab_mvf;
2100 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
2101 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
2104 if (size_in_pus == 0)
2106 for (j = 0; j < size_in_pus; j++)
2107 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
2108 if (lc->cu.pred_mode == MODE_INTRA)
2109 for (j = 0; j < size_in_pus; j++)
2110 for (k = 0; k < size_in_pus; k++)
2111 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].pred_flag = PF_INTRA;
2114 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
2116 int cb_size = 1 << log2_cb_size;
2117 HEVCLocalContext *lc = s->HEVClc;
2118 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
2119 int length = cb_size >> log2_min_cb_size;
2120 int min_cb_width = s->ps.sps->min_cb_width;
2121 int x_cb = x0 >> log2_min_cb_size;
2122 int y_cb = y0 >> log2_min_cb_size;
2123 int idx = log2_cb_size - 2;
2124 int qp_block_mask = (1<<(s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2129 lc->cu.pred_mode = MODE_INTRA;
2130 lc->cu.part_mode = PART_2Nx2N;
2131 lc->cu.intra_split_flag = 0;
2133 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
2134 for (x = 0; x < 4; x++)
2135 lc->pu.intra_pred_mode[x] = 1;
2136 if (s->ps.pps->transquant_bypass_enable_flag) {
2137 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
2138 if (lc->cu.cu_transquant_bypass_flag)
2139 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2141 lc->cu.cu_transquant_bypass_flag = 0;
2143 if (s->sh.slice_type != HEVC_SLICE_I) {
2144 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
2146 x = y_cb * min_cb_width + x_cb;
2147 for (y = 0; y < length; y++) {
2148 memset(&s->skip_flag[x], skip_flag, length);
2151 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2153 x = y_cb * min_cb_width + x_cb;
2154 for (y = 0; y < length; y++) {
2155 memset(&s->skip_flag[x], 0, length);
2160 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2161 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2162 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2164 if (!s->sh.disable_deblocking_filter_flag)
2165 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2169 if (s->sh.slice_type != HEVC_SLICE_I)
2170 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2171 if (lc->cu.pred_mode != MODE_INTRA ||
2172 log2_cb_size == s->ps.sps->log2_min_cb_size) {
2173 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2174 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2175 lc->cu.pred_mode == MODE_INTRA;
2178 if (lc->cu.pred_mode == MODE_INTRA) {
2179 if (lc->cu.part_mode == PART_2Nx2N && s->ps.sps->pcm_enabled_flag &&
2180 log2_cb_size >= s->ps.sps->pcm.log2_min_pcm_cb_size &&
2181 log2_cb_size <= s->ps.sps->pcm.log2_max_pcm_cb_size) {
2182 pcm_flag = ff_hevc_pcm_flag_decode(s);
2185 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2186 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2187 if (s->ps.sps->pcm.loop_filter_disable_flag)
2188 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2193 intra_prediction_unit(s, x0, y0, log2_cb_size);
2196 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2197 switch (lc->cu.part_mode) {
2199 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2202 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0, idx);
2203 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2206 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2207 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2210 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0, idx);
2211 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2214 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2215 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2218 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0, idx - 2);
2219 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2222 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2223 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2226 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2227 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2228 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2229 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2235 int rqt_root_cbf = 1;
2237 if (lc->cu.pred_mode != MODE_INTRA &&
2238 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2239 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2242 const static int cbf[2] = { 0 };
2243 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2244 s->ps.sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2245 s->ps.sps->max_transform_hierarchy_depth_inter;
2246 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2248 log2_cb_size, 0, 0, cbf, cbf);
2252 if (!s->sh.disable_deblocking_filter_flag)
2253 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2258 if (s->ps.pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2259 ff_hevc_set_qPy(s, x0, y0, log2_cb_size);
2261 x = y_cb * min_cb_width + x_cb;
2262 for (y = 0; y < length; y++) {
2263 memset(&s->qp_y_tab[x], lc->qp_y, length);
2267 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2268 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2269 lc->qPy_pred = lc->qp_y;
2272 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct_depth);
2277 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2278 int log2_cb_size, int cb_depth)
2280 HEVCLocalContext *lc = s->HEVClc;
2281 const int cb_size = 1 << log2_cb_size;
2285 lc->ct_depth = cb_depth;
2286 if (x0 + cb_size <= s->ps.sps->width &&
2287 y0 + cb_size <= s->ps.sps->height &&
2288 log2_cb_size > s->ps.sps->log2_min_cb_size) {
2289 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2291 split_cu = (log2_cb_size > s->ps.sps->log2_min_cb_size);
2293 if (s->ps.pps->cu_qp_delta_enabled_flag &&
2294 log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth) {
2295 lc->tu.is_cu_qp_delta_coded = 0;
2296 lc->tu.cu_qp_delta = 0;
2299 if (s->sh.cu_chroma_qp_offset_enabled_flag &&
2300 log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_chroma_qp_offset_depth) {
2301 lc->tu.is_cu_chroma_qp_offset_coded = 0;
2305 int qp_block_mask = (1<<(s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2306 const int cb_size_split = cb_size >> 1;
2307 const int x1 = x0 + cb_size_split;
2308 const int y1 = y0 + cb_size_split;
2312 more_data = hls_coding_quadtree(s, x0, y0, log2_cb_size - 1, cb_depth + 1);
2316 if (more_data && x1 < s->ps.sps->width) {
2317 more_data = hls_coding_quadtree(s, x1, y0, log2_cb_size - 1, cb_depth + 1);
2321 if (more_data && y1 < s->ps.sps->height) {
2322 more_data = hls_coding_quadtree(s, x0, y1, log2_cb_size - 1, cb_depth + 1);
2326 if (more_data && x1 < s->ps.sps->width &&
2327 y1 < s->ps.sps->height) {
2328 more_data = hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1);
2333 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2334 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2335 lc->qPy_pred = lc->qp_y;
2338 return ((x1 + cb_size_split) < s->ps.sps->width ||
2339 (y1 + cb_size_split) < s->ps.sps->height);
2343 ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2346 if ((!((x0 + cb_size) %
2347 (1 << (s->ps.sps->log2_ctb_size))) ||
2348 (x0 + cb_size >= s->ps.sps->width)) &&
2350 (1 << (s->ps.sps->log2_ctb_size))) ||
2351 (y0 + cb_size >= s->ps.sps->height))) {
2352 int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s);
2353 return !end_of_slice_flag;
2362 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2365 HEVCLocalContext *lc = s->HEVClc;
2366 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2367 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2368 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2370 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2372 if (s->ps.pps->entropy_coding_sync_enabled_flag) {
2373 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2374 lc->first_qp_group = 1;
2375 lc->end_of_tiles_x = s->ps.sps->width;
2376 } else if (s->ps.pps->tiles_enabled_flag) {
2377 if (ctb_addr_ts && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
2378 int idxX = s->ps.pps->col_idxX[x_ctb >> s->ps.sps->log2_ctb_size];
2379 lc->end_of_tiles_x = x_ctb + (s->ps.pps->column_width[idxX] << s->ps.sps->log2_ctb_size);
2380 lc->first_qp_group = 1;
2383 lc->end_of_tiles_x = s->ps.sps->width;
2386 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->ps.sps->height);
2388 lc->boundary_flags = 0;
2389 if (s->ps.pps->tiles_enabled_flag) {
2390 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]])
2391 lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2392 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2393 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2394 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]])
2395 lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2396 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->ps.sps->ctb_width])
2397 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2399 if (ctb_addr_in_slice <= 0)
2400 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2401 if (ctb_addr_in_slice < s->ps.sps->ctb_width)
2402 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2405 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2406 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->ps.sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2407 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]]));
2408 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]]));
2411 static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
2413 HEVCContext *s = avctxt->priv_data;
2414 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2418 int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2421 if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) {
2422 av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n");
2423 return AVERROR_INVALIDDATA;
2426 if (s->sh.dependent_slice_segment_flag) {
2427 int prev_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2428 if (s->tab_slice_address[prev_rs] != s->sh.slice_addr) {
2429 av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n");
2430 return AVERROR_INVALIDDATA;
2434 while (more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2435 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2437 x_ctb = (ctb_addr_rs % ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2438 y_ctb = (ctb_addr_rs / ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2439 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2441 ret = ff_hevc_cabac_init(s, ctb_addr_ts);
2443 s->tab_slice_address[ctb_addr_rs] = -1;
2447 hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2449 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2450 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2451 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2453 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2454 if (more_data < 0) {
2455 s->tab_slice_address[ctb_addr_rs] = -1;
2461 ff_hevc_save_states(s, ctb_addr_ts);
2462 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2465 if (x_ctb + ctb_size >= s->ps.sps->width &&
2466 y_ctb + ctb_size >= s->ps.sps->height)
2467 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2472 static int hls_slice_data(HEVCContext *s)
2480 s->avctx->execute(s->avctx, hls_decode_entry, arg, ret , 1, sizeof(int));
2483 static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int job, int self_id)
2485 HEVCContext *s1 = avctxt->priv_data, *s;
2486 HEVCLocalContext *lc;
2487 int ctb_size = 1<< s1->ps.sps->log2_ctb_size;
2489 int *ctb_row_p = input_ctb_row;
2490 int ctb_row = ctb_row_p[job];
2491 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);
2492 int ctb_addr_ts = s1->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2493 int thread = ctb_row % s1->threads_number;
2496 s = s1->sList[self_id];
2500 ret = init_get_bits8(&lc->gb, s->data + s->sh.offset[ctb_row - 1], s->sh.size[ctb_row - 1]);
2503 ff_init_cabac_decoder(&lc->cc, s->data + s->sh.offset[(ctb_row)-1], s->sh.size[ctb_row - 1]);
2506 while(more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2507 int x_ctb = (ctb_addr_rs % s->ps.sps->ctb_width) << s->ps.sps->log2_ctb_size;
2508 int y_ctb = (ctb_addr_rs / s->ps.sps->ctb_width) << s->ps.sps->log2_ctb_size;
2510 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2512 ff_thread_await_progress2(s->avctx, ctb_row, thread, SHIFT_CTB_WPP);
2514 if (atomic_load(&s1->wpp_err)) {
2515 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2519 ret = ff_hevc_cabac_init(s, ctb_addr_ts);
2522 hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2523 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2525 if (more_data < 0) {
2532 ff_hevc_save_states(s, ctb_addr_ts);
2533 ff_thread_report_progress2(s->avctx, ctb_row, thread, 1);
2534 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2536 if (!more_data && (x_ctb+ctb_size) < s->ps.sps->width && ctb_row != s->sh.num_entry_point_offsets) {
2537 atomic_store(&s1->wpp_err, 1);
2538 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2542 if ((x_ctb+ctb_size) >= s->ps.sps->width && (y_ctb+ctb_size) >= s->ps.sps->height ) {
2543 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2544 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2547 ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2550 if(x_ctb >= s->ps.sps->width) {
2554 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2558 s->tab_slice_address[ctb_addr_rs] = -1;
2559 atomic_store(&s1->wpp_err, 1);
2560 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2564 static int hls_slice_data_wpp(HEVCContext *s, const H2645NAL *nal)
2566 const uint8_t *data = nal->data;
2567 int length = nal->size;
2568 HEVCLocalContext *lc = s->HEVClc;
2569 int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2570 int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2572 int64_t startheader, cmpt = 0;
2578 return AVERROR(ENOMEM);
2581 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) {
2582 av_log(s->avctx, AV_LOG_ERROR, "WPP ctb addresses are wrong (%d %d %d %d)\n",
2583 s->sh.slice_ctb_addr_rs, s->sh.num_entry_point_offsets,
2584 s->ps.sps->ctb_width, s->ps.sps->ctb_height
2586 res = AVERROR_INVALIDDATA;
2590 ff_alloc_entries(s->avctx, s->sh.num_entry_point_offsets + 1);
2593 for (i = 1; i < s->threads_number; i++) {
2594 s->sList[i] = av_malloc(sizeof(HEVCContext));
2595 memcpy(s->sList[i], s, sizeof(HEVCContext));
2596 s->HEVClcList[i] = av_mallocz(sizeof(HEVCLocalContext));
2597 s->sList[i]->HEVClc = s->HEVClcList[i];
2601 offset = (lc->gb.index >> 3);
2603 for (j = 0, cmpt = 0, startheader = offset + s->sh.entry_point_offset[0]; j < nal->skipped_bytes; j++) {
2604 if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) {
2610 for (i = 1; i < s->sh.num_entry_point_offsets; i++) {
2611 offset += (s->sh.entry_point_offset[i - 1] - cmpt);
2612 for (j = 0, cmpt = 0, startheader = offset
2613 + s->sh.entry_point_offset[i]; j < nal->skipped_bytes; j++) {
2614 if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) {
2619 s->sh.size[i - 1] = s->sh.entry_point_offset[i] - cmpt;
2620 s->sh.offset[i - 1] = offset;
2623 if (s->sh.num_entry_point_offsets != 0) {
2624 offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt;
2625 if (length < offset) {
2626 av_log(s->avctx, AV_LOG_ERROR, "entry_point_offset table is corrupted\n");
2627 res = AVERROR_INVALIDDATA;
2630 s->sh.size[s->sh.num_entry_point_offsets - 1] = length - offset;
2631 s->sh.offset[s->sh.num_entry_point_offsets - 1] = offset;
2636 for (i = 1; i < s->threads_number; i++) {
2637 s->sList[i]->HEVClc->first_qp_group = 1;
2638 s->sList[i]->HEVClc->qp_y = s->sList[0]->HEVClc->qp_y;
2639 memcpy(s->sList[i], s, sizeof(HEVCContext));
2640 s->sList[i]->HEVClc = s->HEVClcList[i];
2643 atomic_store(&s->wpp_err, 0);
2644 ff_reset_entries(s->avctx);
2646 for (i = 0; i <= s->sh.num_entry_point_offsets; i++) {
2651 if (s->ps.pps->entropy_coding_sync_enabled_flag)
2652 s->avctx->execute2(s->avctx, hls_decode_entry_wpp, arg, ret, s->sh.num_entry_point_offsets + 1);
2654 for (i = 0; i <= s->sh.num_entry_point_offsets; i++)
2662 static int set_side_data(HEVCContext *s)
2664 AVFrame *out = s->ref->frame;
2666 if (s->sei.frame_packing.present &&
2667 s->sei.frame_packing.arrangement_type >= 3 &&
2668 s->sei.frame_packing.arrangement_type <= 5 &&
2669 s->sei.frame_packing.content_interpretation_type > 0 &&
2670 s->sei.frame_packing.content_interpretation_type < 3) {
2671 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2673 return AVERROR(ENOMEM);
2675 switch (s->sei.frame_packing.arrangement_type) {
2677 if (s->sei.frame_packing.quincunx_subsampling)
2678 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2680 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2683 stereo->type = AV_STEREO3D_TOPBOTTOM;
2686 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2690 if (s->sei.frame_packing.content_interpretation_type == 2)
2691 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2693 if (s->sei.frame_packing.arrangement_type == 5) {
2694 if (s->sei.frame_packing.current_frame_is_frame0_flag)
2695 stereo->view = AV_STEREO3D_VIEW_LEFT;
2697 stereo->view = AV_STEREO3D_VIEW_RIGHT;
2701 if (s->sei.display_orientation.present &&
2702 (s->sei.display_orientation.anticlockwise_rotation ||
2703 s->sei.display_orientation.hflip || s->sei.display_orientation.vflip)) {
2704 double angle = s->sei.display_orientation.anticlockwise_rotation * 360 / (double) (1 << 16);
2705 AVFrameSideData *rotation = av_frame_new_side_data(out,
2706 AV_FRAME_DATA_DISPLAYMATRIX,
2707 sizeof(int32_t) * 9);
2709 return AVERROR(ENOMEM);
2711 av_display_rotation_set((int32_t *)rotation->data, angle);
2712 av_display_matrix_flip((int32_t *)rotation->data,
2713 s->sei.display_orientation.hflip,
2714 s->sei.display_orientation.vflip);
2717 // Decrement the mastering display flag when IRAP frame has no_rasl_output_flag=1
2718 // so the side data persists for the entire coded video sequence.
2719 if (s->sei.mastering_display.present > 0 &&
2720 IS_IRAP(s) && s->no_rasl_output_flag) {
2721 s->sei.mastering_display.present--;
2723 if (s->sei.mastering_display.present) {
2724 // HEVC uses a g,b,r ordering, which we convert to a more natural r,g,b
2725 const int mapping[3] = {2, 0, 1};
2726 const int chroma_den = 50000;
2727 const int luma_den = 10000;
2729 AVMasteringDisplayMetadata *metadata =
2730 av_mastering_display_metadata_create_side_data(out);
2732 return AVERROR(ENOMEM);
2734 for (i = 0; i < 3; i++) {
2735 const int j = mapping[i];
2736 metadata->display_primaries[i][0].num = s->sei.mastering_display.display_primaries[j][0];
2737 metadata->display_primaries[i][0].den = chroma_den;
2738 metadata->display_primaries[i][1].num = s->sei.mastering_display.display_primaries[j][1];
2739 metadata->display_primaries[i][1].den = chroma_den;
2741 metadata->white_point[0].num = s->sei.mastering_display.white_point[0];
2742 metadata->white_point[0].den = chroma_den;
2743 metadata->white_point[1].num = s->sei.mastering_display.white_point[1];
2744 metadata->white_point[1].den = chroma_den;
2746 metadata->max_luminance.num = s->sei.mastering_display.max_luminance;
2747 metadata->max_luminance.den = luma_den;
2748 metadata->min_luminance.num = s->sei.mastering_display.min_luminance;
2749 metadata->min_luminance.den = luma_den;
2750 metadata->has_luminance = 1;
2751 metadata->has_primaries = 1;
2753 av_log(s->avctx, AV_LOG_DEBUG, "Mastering Display Metadata:\n");
2754 av_log(s->avctx, AV_LOG_DEBUG,
2755 "r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f)\n",
2756 av_q2d(metadata->display_primaries[0][0]),
2757 av_q2d(metadata->display_primaries[0][1]),
2758 av_q2d(metadata->display_primaries[1][0]),
2759 av_q2d(metadata->display_primaries[1][1]),
2760 av_q2d(metadata->display_primaries[2][0]),
2761 av_q2d(metadata->display_primaries[2][1]),
2762 av_q2d(metadata->white_point[0]), av_q2d(metadata->white_point[1]));
2763 av_log(s->avctx, AV_LOG_DEBUG,
2764 "min_luminance=%f, max_luminance=%f\n",
2765 av_q2d(metadata->min_luminance), av_q2d(metadata->max_luminance));
2767 // Decrement the mastering display flag when IRAP frame has no_rasl_output_flag=1
2768 // so the side data persists for the entire coded video sequence.
2769 if (s->sei.content_light.present > 0 &&
2770 IS_IRAP(s) && s->no_rasl_output_flag) {
2771 s->sei.content_light.present--;
2773 if (s->sei.content_light.present) {
2774 AVContentLightMetadata *metadata =
2775 av_content_light_metadata_create_side_data(out);
2777 return AVERROR(ENOMEM);
2778 metadata->MaxCLL = s->sei.content_light.max_content_light_level;
2779 metadata->MaxFALL = s->sei.content_light.max_pic_average_light_level;
2781 av_log(s->avctx, AV_LOG_DEBUG, "Content Light Level Metadata:\n");
2782 av_log(s->avctx, AV_LOG_DEBUG, "MaxCLL=%d, MaxFALL=%d\n",
2783 metadata->MaxCLL, metadata->MaxFALL);
2786 if (s->sei.a53_caption.buf_ref) {
2787 HEVCSEIA53Caption *a53 = &s->sei.a53_caption;
2789 AVFrameSideData *sd = av_frame_new_side_data_from_buf(out, AV_FRAME_DATA_A53_CC, a53->buf_ref);
2791 av_buffer_unref(&a53->buf_ref);
2792 a53->buf_ref = NULL;
2794 s->avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
2800 static int hevc_frame_start(HEVCContext *s)
2802 HEVCLocalContext *lc = s->HEVClc;
2803 int pic_size_in_ctb = ((s->ps.sps->width >> s->ps.sps->log2_min_cb_size) + 1) *
2804 ((s->ps.sps->height >> s->ps.sps->log2_min_cb_size) + 1);
2807 memset(s->horizontal_bs, 0, s->bs_width * s->bs_height);
2808 memset(s->vertical_bs, 0, s->bs_width * s->bs_height);
2809 memset(s->cbf_luma, 0, s->ps.sps->min_tb_width * s->ps.sps->min_tb_height);
2810 memset(s->is_pcm, 0, (s->ps.sps->min_pu_width + 1) * (s->ps.sps->min_pu_height + 1));
2811 memset(s->tab_slice_address, -1, pic_size_in_ctb * sizeof(*s->tab_slice_address));
2814 s->first_nal_type = s->nal_unit_type;
2816 s->no_rasl_output_flag = IS_IDR(s) || IS_BLA(s) || (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos);
2818 if (s->ps.pps->tiles_enabled_flag)
2819 lc->end_of_tiles_x = s->ps.pps->column_width[0] << s->ps.sps->log2_ctb_size;
2821 ret = ff_hevc_set_new_ref(s, &s->frame, s->poc);
2825 ret = ff_hevc_frame_rps(s);
2827 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2831 s->ref->frame->key_frame = IS_IRAP(s);
2833 ret = set_side_data(s);
2837 s->frame->pict_type = 3 - s->sh.slice_type;
2840 ff_hevc_bump_frame(s);
2842 av_frame_unref(s->output_frame);
2843 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2847 if (!s->avctx->hwaccel)
2848 ff_thread_finish_setup(s->avctx);
2854 ff_hevc_unref_frame(s, s->ref, ~0);
2859 static int decode_nal_unit(HEVCContext *s, const H2645NAL *nal)
2861 HEVCLocalContext *lc = s->HEVClc;
2862 GetBitContext *gb = &lc->gb;
2863 int ctb_addr_ts, ret;
2866 s->nal_unit_type = nal->type;
2867 s->temporal_id = nal->temporal_id;
2869 switch (s->nal_unit_type) {
2871 if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2872 ret = s->avctx->hwaccel->decode_params(s->avctx,
2879 ret = ff_hevc_decode_nal_vps(gb, s->avctx, &s->ps);
2884 if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2885 ret = s->avctx->hwaccel->decode_params(s->avctx,
2892 ret = ff_hevc_decode_nal_sps(gb, s->avctx, &s->ps,
2893 s->apply_defdispwin);
2898 if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2899 ret = s->avctx->hwaccel->decode_params(s->avctx,
2906 ret = ff_hevc_decode_nal_pps(gb, s->avctx, &s->ps);
2910 case HEVC_NAL_SEI_PREFIX:
2911 case HEVC_NAL_SEI_SUFFIX:
2912 if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2913 ret = s->avctx->hwaccel->decode_params(s->avctx,
2920 ret = ff_hevc_decode_nal_sei(gb, s->avctx, &s->sei, &s->ps, s->nal_unit_type);
2924 case HEVC_NAL_TRAIL_R:
2925 case HEVC_NAL_TRAIL_N:
2926 case HEVC_NAL_TSA_N:
2927 case HEVC_NAL_TSA_R:
2928 case HEVC_NAL_STSA_N:
2929 case HEVC_NAL_STSA_R:
2930 case HEVC_NAL_BLA_W_LP:
2931 case HEVC_NAL_BLA_W_RADL:
2932 case HEVC_NAL_BLA_N_LP:
2933 case HEVC_NAL_IDR_W_RADL:
2934 case HEVC_NAL_IDR_N_LP:
2935 case HEVC_NAL_CRA_NUT:
2936 case HEVC_NAL_RADL_N:
2937 case HEVC_NAL_RADL_R:
2938 case HEVC_NAL_RASL_N:
2939 case HEVC_NAL_RASL_R:
2940 ret = hls_slice_header(s);
2944 ret = AVERROR_INVALIDDATA;
2950 (s->avctx->skip_frame >= AVDISCARD_BIDIR && s->sh.slice_type == HEVC_SLICE_B) ||
2951 (s->avctx->skip_frame >= AVDISCARD_NONINTRA && s->sh.slice_type != HEVC_SLICE_I) ||
2952 (s->avctx->skip_frame >= AVDISCARD_NONKEY && !IS_IRAP(s))) {
2956 if (s->sh.first_slice_in_pic_flag) {
2957 if (s->max_ra == INT_MAX) {
2958 if (s->nal_unit_type == HEVC_NAL_CRA_NUT || IS_BLA(s)) {
2962 s->max_ra = INT_MIN;
2966 if ((s->nal_unit_type == HEVC_NAL_RASL_R || s->nal_unit_type == HEVC_NAL_RASL_N) &&
2967 s->poc <= s->max_ra) {
2971 if (s->nal_unit_type == HEVC_NAL_RASL_R && s->poc > s->max_ra)
2972 s->max_ra = INT_MIN;
2976 ret = hevc_frame_start(s);
2979 } else if (!s->ref) {
2980 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2984 if (s->nal_unit_type != s->first_nal_type) {
2985 av_log(s->avctx, AV_LOG_ERROR,
2986 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2987 s->first_nal_type, s->nal_unit_type);
2988 return AVERROR_INVALIDDATA;
2991 if (!s->sh.dependent_slice_segment_flag &&
2992 s->sh.slice_type != HEVC_SLICE_I) {
2993 ret = ff_hevc_slice_rpl(s);
2995 av_log(s->avctx, AV_LOG_WARNING,
2996 "Error constructing the reference lists for the current slice.\n");
3001 if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) {
3002 ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0);
3007 if (s->avctx->hwaccel) {
3008 ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size);
3012 if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
3013 ctb_addr_ts = hls_slice_data_wpp(s, nal);
3015 ctb_addr_ts = hls_slice_data(s);
3016 if (ctb_addr_ts >= (s->ps.sps->ctb_width * s->ps.sps->ctb_height)) {
3020 if (ctb_addr_ts < 0) {
3026 case HEVC_NAL_EOS_NUT:
3027 case HEVC_NAL_EOB_NUT:
3028 s->seq_decode = (s->seq_decode + 1) & 0xff;
3029 s->max_ra = INT_MAX;
3032 case HEVC_NAL_FD_NUT:
3035 av_log(s->avctx, AV_LOG_INFO,
3036 "Skipping NAL unit %d\n", s->nal_unit_type);
3041 if (s->avctx->err_recognition & AV_EF_EXPLODE)
3046 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
3049 int eos_at_start = 1;
3052 s->last_eos = s->eos;
3056 /* split the input packet into NAL units, so we know the upper bound on the
3057 * number of slices in the frame */
3058 ret = ff_h2645_packet_split(&s->pkt, buf, length, s->avctx, s->is_nalff,
3059 s->nal_length_size, s->avctx->codec_id, 1, 0);
3061 av_log(s->avctx, AV_LOG_ERROR,
3062 "Error splitting the input into NAL units.\n");
3066 for (i = 0; i < s->pkt.nb_nals; i++) {
3067 if (s->pkt.nals[i].type == HEVC_NAL_EOB_NUT ||
3068 s->pkt.nals[i].type == HEVC_NAL_EOS_NUT) {
3079 /* decode the NAL units */
3080 for (i = 0; i < s->pkt.nb_nals; i++) {
3081 H2645NAL *nal = &s->pkt.nals[i];
3083 if (s->avctx->skip_frame >= AVDISCARD_ALL ||
3084 (s->avctx->skip_frame >= AVDISCARD_NONREF
3085 && ff_hevc_nal_is_nonref(nal->type)) || nal->nuh_layer_id > 0)
3088 ret = decode_nal_unit(s, nal);
3089 if (ret >= 0 && s->overlap > 2)
3090 ret = AVERROR_INVALIDDATA;
3092 av_log(s->avctx, AV_LOG_WARNING,
3093 "Error parsing NAL unit #%d.\n", i);
3099 if (s->ref && s->threads_type == FF_THREAD_FRAME)
3100 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
3105 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
3108 for (i = 0; i < 16; i++)
3109 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
3112 static int verify_md5(HEVCContext *s, AVFrame *frame)
3114 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
3119 return AVERROR(EINVAL);
3121 pixel_shift = desc->comp[0].depth > 8;
3123 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
3126 /* the checksums are LE, so we have to byteswap for >8bpp formats
3129 if (pixel_shift && !s->checksum_buf) {
3130 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
3131 FFMAX3(frame->linesize[0], frame->linesize[1],
3132 frame->linesize[2]));
3133 if (!s->checksum_buf)
3134 return AVERROR(ENOMEM);
3138 for (i = 0; frame->data[i]; i++) {
3139 int width = s->avctx->coded_width;
3140 int height = s->avctx->coded_height;
3141 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
3142 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
3145 av_md5_init(s->md5_ctx);
3146 for (j = 0; j < h; j++) {
3147 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
3150 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
3151 (const uint16_t *) src, w);
3152 src = s->checksum_buf;
3155 av_md5_update(s->md5_ctx, src, w << pixel_shift);
3157 av_md5_final(s->md5_ctx, md5);
3159 if (!memcmp(md5, s->sei.picture_hash.md5[i], 16)) {
3160 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
3161 print_md5(s->avctx, AV_LOG_DEBUG, md5);
3162 av_log (s->avctx, AV_LOG_DEBUG, "; ");
3164 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
3165 print_md5(s->avctx, AV_LOG_ERROR, md5);
3166 av_log (s->avctx, AV_LOG_ERROR, " != ");
3167 print_md5(s->avctx, AV_LOG_ERROR, s->sei.picture_hash.md5[i]);
3168 av_log (s->avctx, AV_LOG_ERROR, "\n");
3169 return AVERROR_INVALIDDATA;
3173 av_log(s->avctx, AV_LOG_DEBUG, "\n");
3178 static int hevc_decode_extradata(HEVCContext *s, uint8_t *buf, int length, int first)
3182 ret = ff_hevc_decode_extradata(buf, length, &s->ps, &s->sei, &s->is_nalff,
3183 &s->nal_length_size, s->avctx->err_recognition,
3184 s->apply_defdispwin, s->avctx);
3188 /* export stream parameters from the first SPS */
3189 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3190 if (first && s->ps.sps_list[i]) {
3191 const HEVCSPS *sps = (const HEVCSPS*)s->ps.sps_list[i]->data;
3192 export_stream_params(s, sps);
3200 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
3204 int new_extradata_size;
3205 uint8_t *new_extradata;
3206 HEVCContext *s = avctx->priv_data;
3209 ret = ff_hevc_output_frame(s, data, 1);
3217 new_extradata = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,
3218 &new_extradata_size);
3219 if (new_extradata && new_extradata_size > 0) {
3220 ret = hevc_decode_extradata(s, new_extradata, new_extradata_size, 0);
3226 ret = decode_nal_units(s, avpkt->data, avpkt->size);
3230 if (avctx->hwaccel) {
3231 if (s->ref && (ret = avctx->hwaccel->end_frame(avctx)) < 0) {
3232 av_log(avctx, AV_LOG_ERROR,
3233 "hardware accelerator failed to decode picture\n");
3234 ff_hevc_unref_frame(s, s->ref, ~0);
3238 /* verify the SEI checksum */
3239 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
3240 s->sei.picture_hash.is_md5) {
3241 ret = verify_md5(s, s->ref->frame);
3242 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
3243 ff_hevc_unref_frame(s, s->ref, ~0);
3248 s->sei.picture_hash.is_md5 = 0;
3250 if (s->is_decoded) {
3251 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
3255 if (s->output_frame->buf[0]) {
3256 av_frame_move_ref(data, s->output_frame);
3263 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
3267 ret = ff_thread_ref_frame(&dst->tf, &src->tf);
3271 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
3272 if (!dst->tab_mvf_buf)
3274 dst->tab_mvf = src->tab_mvf;
3276 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
3277 if (!dst->rpl_tab_buf)
3279 dst->rpl_tab = src->rpl_tab;
3281 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
3285 dst->poc = src->poc;
3286 dst->ctb_count = src->ctb_count;
3287 dst->flags = src->flags;
3288 dst->sequence = src->sequence;
3290 if (src->hwaccel_picture_private) {
3291 dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
3292 if (!dst->hwaccel_priv_buf)
3294 dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
3299 ff_hevc_unref_frame(s, dst, ~0);
3300 return AVERROR(ENOMEM);
3303 static av_cold int hevc_decode_free(AVCodecContext *avctx)
3305 HEVCContext *s = avctx->priv_data;
3310 av_freep(&s->md5_ctx);
3312 av_freep(&s->cabac_state);
3314 for (i = 0; i < 3; i++) {
3315 av_freep(&s->sao_pixel_buffer_h[i]);
3316 av_freep(&s->sao_pixel_buffer_v[i]);
3318 av_frame_free(&s->output_frame);
3320 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3321 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3322 av_frame_free(&s->DPB[i].frame);
3325 ff_hevc_ps_uninit(&s->ps);
3327 av_freep(&s->sh.entry_point_offset);
3328 av_freep(&s->sh.offset);
3329 av_freep(&s->sh.size);
3331 for (i = 1; i < s->threads_number; i++) {
3332 HEVCLocalContext *lc = s->HEVClcList[i];
3334 av_freep(&s->HEVClcList[i]);
3335 av_freep(&s->sList[i]);
3338 if (s->HEVClc == s->HEVClcList[0])
3340 av_freep(&s->HEVClcList[0]);
3342 ff_h2645_packet_uninit(&s->pkt);
3344 ff_hevc_reset_sei(&s->sei);
3349 static av_cold int hevc_init_context(AVCodecContext *avctx)
3351 HEVCContext *s = avctx->priv_data;
3356 s->HEVClc = av_mallocz(sizeof(HEVCLocalContext));
3359 s->HEVClcList[0] = s->HEVClc;
3362 s->cabac_state = av_malloc(HEVC_CONTEXTS);
3363 if (!s->cabac_state)
3366 s->output_frame = av_frame_alloc();
3367 if (!s->output_frame)
3370 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3371 s->DPB[i].frame = av_frame_alloc();
3372 if (!s->DPB[i].frame)
3374 s->DPB[i].tf.f = s->DPB[i].frame;
3377 s->max_ra = INT_MAX;
3379 s->md5_ctx = av_md5_alloc();
3383 ff_bswapdsp_init(&s->bdsp);
3385 s->context_initialized = 1;
3388 ff_hevc_reset_sei(&s->sei);
3393 hevc_decode_free(avctx);
3394 return AVERROR(ENOMEM);
3398 static int hevc_update_thread_context(AVCodecContext *dst,
3399 const AVCodecContext *src)
3401 HEVCContext *s = dst->priv_data;
3402 HEVCContext *s0 = src->priv_data;
3405 if (!s->context_initialized) {
3406 ret = hevc_init_context(dst);
3411 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3412 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3413 if (s0->DPB[i].frame->buf[0]) {
3414 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3420 if (s->ps.sps != s0->ps.sps)
3422 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++) {
3423 av_buffer_unref(&s->ps.vps_list[i]);
3424 if (s0->ps.vps_list[i]) {
3425 s->ps.vps_list[i] = av_buffer_ref(s0->ps.vps_list[i]);
3426 if (!s->ps.vps_list[i])
3427 return AVERROR(ENOMEM);
3431 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3432 av_buffer_unref(&s->ps.sps_list[i]);
3433 if (s0->ps.sps_list[i]) {
3434 s->ps.sps_list[i] = av_buffer_ref(s0->ps.sps_list[i]);
3435 if (!s->ps.sps_list[i])
3436 return AVERROR(ENOMEM);
3440 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++) {
3441 av_buffer_unref(&s->ps.pps_list[i]);
3442 if (s0->ps.pps_list[i]) {
3443 s->ps.pps_list[i] = av_buffer_ref(s0->ps.pps_list[i]);
3444 if (!s->ps.pps_list[i])
3445 return AVERROR(ENOMEM);
3449 if (s->ps.sps != s0->ps.sps)
3450 if ((ret = set_sps(s, s0->ps.sps, src->pix_fmt)) < 0)
3453 s->seq_decode = s0->seq_decode;
3454 s->seq_output = s0->seq_output;
3455 s->pocTid0 = s0->pocTid0;
3456 s->max_ra = s0->max_ra;
3458 s->no_rasl_output_flag = s0->no_rasl_output_flag;
3460 s->is_nalff = s0->is_nalff;
3461 s->nal_length_size = s0->nal_length_size;
3463 s->threads_number = s0->threads_number;
3464 s->threads_type = s0->threads_type;
3467 s->seq_decode = (s->seq_decode + 1) & 0xff;
3468 s->max_ra = INT_MAX;
3471 av_buffer_unref(&s->sei.a53_caption.buf_ref);
3472 if (s0->sei.a53_caption.buf_ref) {
3473 s->sei.a53_caption.buf_ref = av_buffer_ref(s0->sei.a53_caption.buf_ref);
3474 if (!s->sei.a53_caption.buf_ref)
3475 return AVERROR(ENOMEM);
3478 s->sei.frame_packing = s0->sei.frame_packing;
3479 s->sei.display_orientation = s0->sei.display_orientation;
3480 s->sei.mastering_display = s0->sei.mastering_display;
3481 s->sei.content_light = s0->sei.content_light;
3482 s->sei.alternative_transfer = s0->sei.alternative_transfer;
3488 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3490 HEVCContext *s = avctx->priv_data;
3493 ret = hevc_init_context(avctx);
3497 s->enable_parallel_tiles = 0;
3498 s->sei.picture_timing.picture_struct = 0;
3501 atomic_init(&s->wpp_err, 0);
3503 if(avctx->active_thread_type & FF_THREAD_SLICE)
3504 s->threads_number = avctx->thread_count;
3506 s->threads_number = 1;
3508 if (!avctx->internal->is_copy) {
3509 if (avctx->extradata_size > 0 && avctx->extradata) {
3510 ret = hevc_decode_extradata(s, avctx->extradata, avctx->extradata_size, 1);
3512 hevc_decode_free(avctx);
3518 if((avctx->active_thread_type & FF_THREAD_FRAME) && avctx->thread_count > 1)
3519 s->threads_type = FF_THREAD_FRAME;
3521 s->threads_type = FF_THREAD_SLICE;
3526 static void hevc_decode_flush(AVCodecContext *avctx)
3528 HEVCContext *s = avctx->priv_data;
3529 ff_hevc_flush_dpb(s);
3530 ff_hevc_reset_sei(&s->sei);
3531 s->max_ra = INT_MAX;
3535 #define OFFSET(x) offsetof(HEVCContext, x)
3536 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3538 static const AVOption options[] = {
3539 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3540 AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR },
3541 { "strict-displaywin", "stricly apply default display window size", OFFSET(apply_defdispwin),
3542 AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR },
3546 static const AVClass hevc_decoder_class = {
3547 .class_name = "HEVC decoder",
3548 .item_name = av_default_item_name,
3550 .version = LIBAVUTIL_VERSION_INT,
3553 AVCodec ff_hevc_decoder = {
3555 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3556 .type = AVMEDIA_TYPE_VIDEO,
3557 .id = AV_CODEC_ID_HEVC,
3558 .priv_data_size = sizeof(HEVCContext),
3559 .priv_class = &hevc_decoder_class,
3560 .init = hevc_decode_init,
3561 .close = hevc_decode_free,
3562 .decode = hevc_decode_frame,
3563 .flush = hevc_decode_flush,
3564 .update_thread_context = ONLY_IF_THREADS_ENABLED(hevc_update_thread_context),
3565 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
3566 AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS,
3567 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_EXPORTS_CROPPING |
3568 FF_CODEC_CAP_ALLOCATE_PROGRESS,
3569 .profiles = NULL_IF_CONFIG_SMALL(ff_hevc_profiles),
3570 .hw_configs = (const AVCodecHWConfigInternal*[]) {
3571 #if CONFIG_HEVC_DXVA2_HWACCEL
3572 HWACCEL_DXVA2(hevc),
3574 #if CONFIG_HEVC_D3D11VA_HWACCEL
3575 HWACCEL_D3D11VA(hevc),
3577 #if CONFIG_HEVC_D3D11VA2_HWACCEL
3578 HWACCEL_D3D11VA2(hevc),
3580 #if CONFIG_HEVC_NVDEC_HWACCEL
3581 HWACCEL_NVDEC(hevc),
3583 #if CONFIG_HEVC_VAAPI_HWACCEL
3584 HWACCEL_VAAPI(hevc),
3586 #if CONFIG_HEVC_VDPAU_HWACCEL
3587 HWACCEL_VDPAU(hevc),
3589 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
3590 HWACCEL_VIDEOTOOLBOX(hevc),