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"
35 #include "libavutil/timecode.h"
38 #include "bytestream.h"
39 #include "cabac_functions.h"
42 #include "hevc_data.h"
43 #include "hevc_parse.h"
48 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 };
51 * NOTE: Each function hls_foo correspond to the function foo in the
52 * specification (HLS stands for High Level Syntax).
59 /* free everything allocated by pic_arrays_init() */
60 static void pic_arrays_free(HEVCContext *s)
63 av_freep(&s->deblock);
65 av_freep(&s->skip_flag);
66 av_freep(&s->tab_ct_depth);
68 av_freep(&s->tab_ipm);
69 av_freep(&s->cbf_luma);
72 av_freep(&s->qp_y_tab);
73 av_freep(&s->tab_slice_address);
74 av_freep(&s->filter_slice_edges);
76 av_freep(&s->horizontal_bs);
77 av_freep(&s->vertical_bs);
79 av_freep(&s->sh.entry_point_offset);
80 av_freep(&s->sh.size);
81 av_freep(&s->sh.offset);
83 av_buffer_pool_uninit(&s->tab_mvf_pool);
84 av_buffer_pool_uninit(&s->rpl_tab_pool);
87 /* allocate arrays that depend on frame dimensions */
88 static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
90 int log2_min_cb_size = sps->log2_min_cb_size;
91 int width = sps->width;
92 int height = sps->height;
93 int pic_size_in_ctb = ((width >> log2_min_cb_size) + 1) *
94 ((height >> log2_min_cb_size) + 1);
95 int ctb_count = sps->ctb_width * sps->ctb_height;
96 int min_pu_size = sps->min_pu_width * sps->min_pu_height;
98 s->bs_width = (width >> 2) + 1;
99 s->bs_height = (height >> 2) + 1;
101 s->sao = av_mallocz_array(ctb_count, sizeof(*s->sao));
102 s->deblock = av_mallocz_array(ctb_count, sizeof(*s->deblock));
103 if (!s->sao || !s->deblock)
106 s->skip_flag = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
107 s->tab_ct_depth = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
108 if (!s->skip_flag || !s->tab_ct_depth)
111 s->cbf_luma = av_malloc_array(sps->min_tb_width, sps->min_tb_height);
112 s->tab_ipm = av_mallocz(min_pu_size);
113 s->is_pcm = av_malloc_array(sps->min_pu_width + 1, sps->min_pu_height + 1);
114 if (!s->tab_ipm || !s->cbf_luma || !s->is_pcm)
117 s->filter_slice_edges = av_mallocz(ctb_count);
118 s->tab_slice_address = av_malloc_array(pic_size_in_ctb,
119 sizeof(*s->tab_slice_address));
120 s->qp_y_tab = av_malloc_array(pic_size_in_ctb,
121 sizeof(*s->qp_y_tab));
122 if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address)
125 s->horizontal_bs = av_mallocz_array(s->bs_width, s->bs_height);
126 s->vertical_bs = av_mallocz_array(s->bs_width, s->bs_height);
127 if (!s->horizontal_bs || !s->vertical_bs)
130 s->tab_mvf_pool = av_buffer_pool_init(min_pu_size * sizeof(MvField),
132 s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab),
134 if (!s->tab_mvf_pool || !s->rpl_tab_pool)
141 return AVERROR(ENOMEM);
144 static int pred_weight_table(HEVCContext *s, GetBitContext *gb)
148 uint8_t luma_weight_l0_flag[16];
149 uint8_t chroma_weight_l0_flag[16];
150 uint8_t luma_weight_l1_flag[16];
151 uint8_t chroma_weight_l1_flag[16];
152 int luma_log2_weight_denom;
154 luma_log2_weight_denom = get_ue_golomb_long(gb);
155 if (luma_log2_weight_denom < 0 || luma_log2_weight_denom > 7) {
156 av_log(s->avctx, AV_LOG_ERROR, "luma_log2_weight_denom %d is invalid\n", luma_log2_weight_denom);
157 return AVERROR_INVALIDDATA;
159 s->sh.luma_log2_weight_denom = av_clip_uintp2(luma_log2_weight_denom, 3);
160 if (s->ps.sps->chroma_format_idc != 0) {
161 int64_t chroma_log2_weight_denom = luma_log2_weight_denom + (int64_t)get_se_golomb(gb);
162 if (chroma_log2_weight_denom < 0 || chroma_log2_weight_denom > 7) {
163 av_log(s->avctx, AV_LOG_ERROR, "chroma_log2_weight_denom %"PRId64" is invalid\n", chroma_log2_weight_denom);
164 return AVERROR_INVALIDDATA;
166 s->sh.chroma_log2_weight_denom = chroma_log2_weight_denom;
169 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
170 luma_weight_l0_flag[i] = get_bits1(gb);
171 if (!luma_weight_l0_flag[i]) {
172 s->sh.luma_weight_l0[i] = 1 << s->sh.luma_log2_weight_denom;
173 s->sh.luma_offset_l0[i] = 0;
176 if (s->ps.sps->chroma_format_idc != 0) {
177 for (i = 0; i < s->sh.nb_refs[L0]; i++)
178 chroma_weight_l0_flag[i] = get_bits1(gb);
180 for (i = 0; i < s->sh.nb_refs[L0]; i++)
181 chroma_weight_l0_flag[i] = 0;
183 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
184 if (luma_weight_l0_flag[i]) {
185 int delta_luma_weight_l0 = get_se_golomb(gb);
186 if ((int8_t)delta_luma_weight_l0 != delta_luma_weight_l0)
187 return AVERROR_INVALIDDATA;
188 s->sh.luma_weight_l0[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;
189 s->sh.luma_offset_l0[i] = get_se_golomb(gb);
191 if (chroma_weight_l0_flag[i]) {
192 for (j = 0; j < 2; j++) {
193 int delta_chroma_weight_l0 = get_se_golomb(gb);
194 int delta_chroma_offset_l0 = get_se_golomb(gb);
196 if ( (int8_t)delta_chroma_weight_l0 != delta_chroma_weight_l0
197 || delta_chroma_offset_l0 < -(1<<17) || delta_chroma_offset_l0 > (1<<17)) {
198 return AVERROR_INVALIDDATA;
201 s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
202 s->sh.chroma_offset_l0[i][j] = av_clip((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j])
203 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
206 s->sh.chroma_weight_l0[i][0] = 1 << s->sh.chroma_log2_weight_denom;
207 s->sh.chroma_offset_l0[i][0] = 0;
208 s->sh.chroma_weight_l0[i][1] = 1 << s->sh.chroma_log2_weight_denom;
209 s->sh.chroma_offset_l0[i][1] = 0;
212 if (s->sh.slice_type == HEVC_SLICE_B) {
213 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
214 luma_weight_l1_flag[i] = get_bits1(gb);
215 if (!luma_weight_l1_flag[i]) {
216 s->sh.luma_weight_l1[i] = 1 << s->sh.luma_log2_weight_denom;
217 s->sh.luma_offset_l1[i] = 0;
220 if (s->ps.sps->chroma_format_idc != 0) {
221 for (i = 0; i < s->sh.nb_refs[L1]; i++)
222 chroma_weight_l1_flag[i] = get_bits1(gb);
224 for (i = 0; i < s->sh.nb_refs[L1]; i++)
225 chroma_weight_l1_flag[i] = 0;
227 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
228 if (luma_weight_l1_flag[i]) {
229 int delta_luma_weight_l1 = get_se_golomb(gb);
230 if ((int8_t)delta_luma_weight_l1 != delta_luma_weight_l1)
231 return AVERROR_INVALIDDATA;
232 s->sh.luma_weight_l1[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;
233 s->sh.luma_offset_l1[i] = get_se_golomb(gb);
235 if (chroma_weight_l1_flag[i]) {
236 for (j = 0; j < 2; j++) {
237 int delta_chroma_weight_l1 = get_se_golomb(gb);
238 int delta_chroma_offset_l1 = get_se_golomb(gb);
240 if ( (int8_t)delta_chroma_weight_l1 != delta_chroma_weight_l1
241 || delta_chroma_offset_l1 < -(1<<17) || delta_chroma_offset_l1 > (1<<17)) {
242 return AVERROR_INVALIDDATA;
245 s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
246 s->sh.chroma_offset_l1[i][j] = av_clip((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j])
247 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
250 s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom;
251 s->sh.chroma_offset_l1[i][0] = 0;
252 s->sh.chroma_weight_l1[i][1] = 1 << s->sh.chroma_log2_weight_denom;
253 s->sh.chroma_offset_l1[i][1] = 0;
260 static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
262 const HEVCSPS *sps = s->ps.sps;
263 int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
264 int prev_delta_msb = 0;
265 unsigned int nb_sps = 0, nb_sh;
269 if (!sps->long_term_ref_pics_present_flag)
272 if (sps->num_long_term_ref_pics_sps > 0)
273 nb_sps = get_ue_golomb_long(gb);
274 nb_sh = get_ue_golomb_long(gb);
276 if (nb_sps > sps->num_long_term_ref_pics_sps)
277 return AVERROR_INVALIDDATA;
278 if (nb_sh + (uint64_t)nb_sps > FF_ARRAY_ELEMS(rps->poc))
279 return AVERROR_INVALIDDATA;
281 rps->nb_refs = nb_sh + nb_sps;
283 for (i = 0; i < rps->nb_refs; i++) {
286 uint8_t lt_idx_sps = 0;
288 if (sps->num_long_term_ref_pics_sps > 1)
289 lt_idx_sps = get_bits(gb, av_ceil_log2(sps->num_long_term_ref_pics_sps));
291 rps->poc[i] = sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
292 rps->used[i] = sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];
294 rps->poc[i] = get_bits(gb, sps->log2_max_poc_lsb);
295 rps->used[i] = get_bits1(gb);
298 rps->poc_msb_present[i] = get_bits1(gb);
299 if (rps->poc_msb_present[i]) {
300 int64_t delta = get_ue_golomb_long(gb);
303 if (i && i != nb_sps)
304 delta += prev_delta_msb;
306 poc = rps->poc[i] + s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
307 if (poc != (int32_t)poc)
308 return AVERROR_INVALIDDATA;
310 prev_delta_msb = delta;
317 static void export_stream_params(HEVCContext *s, const HEVCSPS *sps)
319 AVCodecContext *avctx = s->avctx;
320 const HEVCParamSets *ps = &s->ps;
321 const HEVCVPS *vps = (const HEVCVPS*)ps->vps_list[sps->vps_id]->data;
322 const HEVCWindow *ow = &sps->output_window;
323 unsigned int num = 0, den = 0;
325 avctx->pix_fmt = sps->pix_fmt;
326 avctx->coded_width = sps->width;
327 avctx->coded_height = sps->height;
328 avctx->width = sps->width - ow->left_offset - ow->right_offset;
329 avctx->height = sps->height - ow->top_offset - ow->bottom_offset;
330 avctx->has_b_frames = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics;
331 avctx->profile = sps->ptl.general_ptl.profile_idc;
332 avctx->level = sps->ptl.general_ptl.level_idc;
334 ff_set_sar(avctx, sps->vui.sar);
336 if (sps->vui.video_signal_type_present_flag)
337 avctx->color_range = sps->vui.video_full_range_flag ? AVCOL_RANGE_JPEG
340 avctx->color_range = AVCOL_RANGE_MPEG;
342 if (sps->vui.colour_description_present_flag) {
343 avctx->color_primaries = sps->vui.colour_primaries;
344 avctx->color_trc = sps->vui.transfer_characteristic;
345 avctx->colorspace = sps->vui.matrix_coeffs;
347 avctx->color_primaries = AVCOL_PRI_UNSPECIFIED;
348 avctx->color_trc = AVCOL_TRC_UNSPECIFIED;
349 avctx->colorspace = AVCOL_SPC_UNSPECIFIED;
352 avctx->chroma_sample_location = AVCHROMA_LOC_UNSPECIFIED;
353 if (sps->chroma_format_idc == 1) {
354 if (sps->vui.chroma_loc_info_present_flag) {
355 if (sps->vui.chroma_sample_loc_type_top_field <= 5)
356 avctx->chroma_sample_location = sps->vui.chroma_sample_loc_type_top_field + 1;
358 avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
361 if (vps->vps_timing_info_present_flag) {
362 num = vps->vps_num_units_in_tick;
363 den = vps->vps_time_scale;
364 } else if (sps->vui.vui_timing_info_present_flag) {
365 num = sps->vui.vui_num_units_in_tick;
366 den = sps->vui.vui_time_scale;
369 if (num != 0 && den != 0)
370 av_reduce(&avctx->framerate.den, &avctx->framerate.num,
374 static int export_stream_params_from_sei(HEVCContext *s)
376 AVCodecContext *avctx = s->avctx;
378 if (s->sei.a53_caption.buf_ref)
379 s->avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
381 if (s->sei.alternative_transfer.present &&
382 av_color_transfer_name(s->sei.alternative_transfer.preferred_transfer_characteristics) &&
383 s->sei.alternative_transfer.preferred_transfer_characteristics != AVCOL_TRC_UNSPECIFIED) {
384 avctx->color_trc = s->sei.alternative_transfer.preferred_transfer_characteristics;
390 static enum AVPixelFormat get_format(HEVCContext *s, const HEVCSPS *sps)
392 #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + \
393 CONFIG_HEVC_D3D11VA_HWACCEL * 2 + \
394 CONFIG_HEVC_NVDEC_HWACCEL + \
395 CONFIG_HEVC_VAAPI_HWACCEL + \
396 CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL + \
397 CONFIG_HEVC_VDPAU_HWACCEL)
398 enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
400 switch (sps->pix_fmt) {
401 case AV_PIX_FMT_YUV420P:
402 case AV_PIX_FMT_YUVJ420P:
403 #if CONFIG_HEVC_DXVA2_HWACCEL
404 *fmt++ = AV_PIX_FMT_DXVA2_VLD;
406 #if CONFIG_HEVC_D3D11VA_HWACCEL
407 *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
408 *fmt++ = AV_PIX_FMT_D3D11;
410 #if CONFIG_HEVC_VAAPI_HWACCEL
411 *fmt++ = AV_PIX_FMT_VAAPI;
413 #if CONFIG_HEVC_VDPAU_HWACCEL
414 *fmt++ = AV_PIX_FMT_VDPAU;
416 #if CONFIG_HEVC_NVDEC_HWACCEL
417 *fmt++ = AV_PIX_FMT_CUDA;
419 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
420 *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX;
423 case AV_PIX_FMT_YUV420P10:
424 #if CONFIG_HEVC_DXVA2_HWACCEL
425 *fmt++ = AV_PIX_FMT_DXVA2_VLD;
427 #if CONFIG_HEVC_D3D11VA_HWACCEL
428 *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
429 *fmt++ = AV_PIX_FMT_D3D11;
431 #if CONFIG_HEVC_VAAPI_HWACCEL
432 *fmt++ = AV_PIX_FMT_VAAPI;
434 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
435 *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX;
437 #if CONFIG_HEVC_VDPAU_HWACCEL
438 *fmt++ = AV_PIX_FMT_VDPAU;
440 #if CONFIG_HEVC_NVDEC_HWACCEL
441 *fmt++ = AV_PIX_FMT_CUDA;
444 case AV_PIX_FMT_YUV444P:
445 #if CONFIG_HEVC_VDPAU_HWACCEL
446 *fmt++ = AV_PIX_FMT_VDPAU;
448 #if CONFIG_HEVC_NVDEC_HWACCEL
449 *fmt++ = AV_PIX_FMT_CUDA;
452 case AV_PIX_FMT_YUV422P:
453 case AV_PIX_FMT_YUV422P10LE:
454 #if CONFIG_HEVC_VAAPI_HWACCEL
455 *fmt++ = AV_PIX_FMT_VAAPI;
458 case AV_PIX_FMT_YUV420P12:
459 case AV_PIX_FMT_YUV444P10:
460 case AV_PIX_FMT_YUV444P12:
461 #if CONFIG_HEVC_VDPAU_HWACCEL
462 *fmt++ = AV_PIX_FMT_VDPAU;
464 #if CONFIG_HEVC_NVDEC_HWACCEL
465 *fmt++ = AV_PIX_FMT_CUDA;
470 *fmt++ = sps->pix_fmt;
471 *fmt = AV_PIX_FMT_NONE;
473 return ff_thread_get_format(s->avctx, pix_fmts);
476 static int set_sps(HEVCContext *s, const HEVCSPS *sps,
477 enum AVPixelFormat pix_fmt)
488 ret = pic_arrays_init(s, sps);
492 export_stream_params(s, sps);
494 s->avctx->pix_fmt = pix_fmt;
496 ff_hevc_pred_init(&s->hpc, sps->bit_depth);
497 ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
498 ff_videodsp_init (&s->vdsp, sps->bit_depth);
500 for (i = 0; i < 3; i++) {
501 av_freep(&s->sao_pixel_buffer_h[i]);
502 av_freep(&s->sao_pixel_buffer_v[i]);
505 if (sps->sao_enabled && !s->avctx->hwaccel) {
506 int c_count = (sps->chroma_format_idc != 0) ? 3 : 1;
509 for(c_idx = 0; c_idx < c_count; c_idx++) {
510 int w = sps->width >> sps->hshift[c_idx];
511 int h = sps->height >> sps->vshift[c_idx];
512 s->sao_pixel_buffer_h[c_idx] =
513 av_malloc((w * 2 * sps->ctb_height) <<
515 s->sao_pixel_buffer_v[c_idx] =
516 av_malloc((h * 2 * sps->ctb_width) <<
522 s->ps.vps = (HEVCVPS*) s->ps.vps_list[s->ps.sps->vps_id]->data;
532 static int hls_slice_header(HEVCContext *s)
534 GetBitContext *gb = &s->HEVClc->gb;
535 SliceHeader *sh = &s->sh;
539 sh->first_slice_in_pic_flag = get_bits1(gb);
540 if (s->ref && sh->first_slice_in_pic_flag) {
541 av_log(s->avctx, AV_LOG_ERROR, "Two slices reporting being the first in the same frame.\n");
542 return 1; // This slice will be skipped later, do not corrupt state
545 if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
546 s->seq_decode = (s->seq_decode + 1) & 0xff;
549 ff_hevc_clear_refs(s);
551 sh->no_output_of_prior_pics_flag = 0;
553 sh->no_output_of_prior_pics_flag = get_bits1(gb);
555 sh->pps_id = get_ue_golomb_long(gb);
556 if (sh->pps_id >= HEVC_MAX_PPS_COUNT || !s->ps.pps_list[sh->pps_id]) {
557 av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
558 return AVERROR_INVALIDDATA;
560 if (!sh->first_slice_in_pic_flag &&
561 s->ps.pps != (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data) {
562 av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
563 return AVERROR_INVALIDDATA;
565 s->ps.pps = (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data;
566 if (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos == 1)
567 sh->no_output_of_prior_pics_flag = 1;
569 if (s->ps.sps != (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data) {
570 const HEVCSPS *sps = (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data;
571 const HEVCSPS *last_sps = s->ps.sps;
572 enum AVPixelFormat pix_fmt;
574 if (last_sps && IS_IRAP(s) && s->nal_unit_type != HEVC_NAL_CRA_NUT) {
575 if (sps->width != last_sps->width || sps->height != last_sps->height ||
576 sps->temporal_layer[sps->max_sub_layers - 1].max_dec_pic_buffering !=
577 last_sps->temporal_layer[last_sps->max_sub_layers - 1].max_dec_pic_buffering)
578 sh->no_output_of_prior_pics_flag = 0;
580 ff_hevc_clear_refs(s);
582 ret = set_sps(s, sps, sps->pix_fmt);
586 pix_fmt = get_format(s, sps);
589 s->avctx->pix_fmt = pix_fmt;
591 s->seq_decode = (s->seq_decode + 1) & 0xff;
595 ret = export_stream_params_from_sei(s);
599 sh->dependent_slice_segment_flag = 0;
600 if (!sh->first_slice_in_pic_flag) {
601 int slice_address_length;
603 if (s->ps.pps->dependent_slice_segments_enabled_flag)
604 sh->dependent_slice_segment_flag = get_bits1(gb);
606 slice_address_length = av_ceil_log2(s->ps.sps->ctb_width *
607 s->ps.sps->ctb_height);
608 sh->slice_segment_addr = get_bitsz(gb, slice_address_length);
609 if (sh->slice_segment_addr >= s->ps.sps->ctb_width * s->ps.sps->ctb_height) {
610 av_log(s->avctx, AV_LOG_ERROR,
611 "Invalid slice segment address: %u.\n",
612 sh->slice_segment_addr);
613 return AVERROR_INVALIDDATA;
616 if (!sh->dependent_slice_segment_flag) {
617 sh->slice_addr = sh->slice_segment_addr;
621 sh->slice_segment_addr = sh->slice_addr = 0;
623 s->slice_initialized = 0;
626 if (!sh->dependent_slice_segment_flag) {
627 s->slice_initialized = 0;
629 for (i = 0; i < s->ps.pps->num_extra_slice_header_bits; i++)
630 skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
632 sh->slice_type = get_ue_golomb_long(gb);
633 if (!(sh->slice_type == HEVC_SLICE_I ||
634 sh->slice_type == HEVC_SLICE_P ||
635 sh->slice_type == HEVC_SLICE_B)) {
636 av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
638 return AVERROR_INVALIDDATA;
640 if (IS_IRAP(s) && sh->slice_type != HEVC_SLICE_I) {
641 av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
642 return AVERROR_INVALIDDATA;
645 // when flag is not present, picture is inferred to be output
646 sh->pic_output_flag = 1;
647 if (s->ps.pps->output_flag_present_flag)
648 sh->pic_output_flag = get_bits1(gb);
650 if (s->ps.sps->separate_colour_plane_flag)
651 sh->colour_plane_id = get_bits(gb, 2);
656 sh->pic_order_cnt_lsb = get_bits(gb, s->ps.sps->log2_max_poc_lsb);
657 poc = ff_hevc_compute_poc(s->ps.sps, s->pocTid0, sh->pic_order_cnt_lsb, s->nal_unit_type);
658 if (!sh->first_slice_in_pic_flag && poc != s->poc) {
659 av_log(s->avctx, AV_LOG_WARNING,
660 "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
661 if (s->avctx->err_recognition & AV_EF_EXPLODE)
662 return AVERROR_INVALIDDATA;
667 sh->short_term_ref_pic_set_sps_flag = get_bits1(gb);
668 pos = get_bits_left(gb);
669 if (!sh->short_term_ref_pic_set_sps_flag) {
670 ret = ff_hevc_decode_short_term_rps(gb, s->avctx, &sh->slice_rps, s->ps.sps, 1);
674 sh->short_term_rps = &sh->slice_rps;
676 int numbits, rps_idx;
678 if (!s->ps.sps->nb_st_rps) {
679 av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
680 return AVERROR_INVALIDDATA;
683 numbits = av_ceil_log2(s->ps.sps->nb_st_rps);
684 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
685 sh->short_term_rps = &s->ps.sps->st_rps[rps_idx];
687 sh->short_term_ref_pic_set_size = pos - get_bits_left(gb);
689 pos = get_bits_left(gb);
690 ret = decode_lt_rps(s, &sh->long_term_rps, gb);
692 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
693 if (s->avctx->err_recognition & AV_EF_EXPLODE)
694 return AVERROR_INVALIDDATA;
696 sh->long_term_ref_pic_set_size = pos - get_bits_left(gb);
698 if (s->ps.sps->sps_temporal_mvp_enabled_flag)
699 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
701 sh->slice_temporal_mvp_enabled_flag = 0;
703 s->sh.short_term_rps = NULL;
708 if (sh->first_slice_in_pic_flag && s->temporal_id == 0 &&
709 s->nal_unit_type != HEVC_NAL_TRAIL_N &&
710 s->nal_unit_type != HEVC_NAL_TSA_N &&
711 s->nal_unit_type != HEVC_NAL_STSA_N &&
712 s->nal_unit_type != HEVC_NAL_RADL_N &&
713 s->nal_unit_type != HEVC_NAL_RADL_R &&
714 s->nal_unit_type != HEVC_NAL_RASL_N &&
715 s->nal_unit_type != HEVC_NAL_RASL_R)
718 if (s->ps.sps->sao_enabled) {
719 sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
720 if (s->ps.sps->chroma_format_idc) {
721 sh->slice_sample_adaptive_offset_flag[1] =
722 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
725 sh->slice_sample_adaptive_offset_flag[0] = 0;
726 sh->slice_sample_adaptive_offset_flag[1] = 0;
727 sh->slice_sample_adaptive_offset_flag[2] = 0;
730 sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
731 if (sh->slice_type == HEVC_SLICE_P || sh->slice_type == HEVC_SLICE_B) {
734 sh->nb_refs[L0] = s->ps.pps->num_ref_idx_l0_default_active;
735 if (sh->slice_type == HEVC_SLICE_B)
736 sh->nb_refs[L1] = s->ps.pps->num_ref_idx_l1_default_active;
738 if (get_bits1(gb)) { // num_ref_idx_active_override_flag
739 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
740 if (sh->slice_type == HEVC_SLICE_B)
741 sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
743 if (sh->nb_refs[L0] > HEVC_MAX_REFS || sh->nb_refs[L1] > HEVC_MAX_REFS) {
744 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
745 sh->nb_refs[L0], sh->nb_refs[L1]);
746 return AVERROR_INVALIDDATA;
749 sh->rpl_modification_flag[0] = 0;
750 sh->rpl_modification_flag[1] = 0;
751 nb_refs = ff_hevc_frame_nb_refs(s);
753 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
754 return AVERROR_INVALIDDATA;
757 if (s->ps.pps->lists_modification_present_flag && nb_refs > 1) {
758 sh->rpl_modification_flag[0] = get_bits1(gb);
759 if (sh->rpl_modification_flag[0]) {
760 for (i = 0; i < sh->nb_refs[L0]; i++)
761 sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
764 if (sh->slice_type == HEVC_SLICE_B) {
765 sh->rpl_modification_flag[1] = get_bits1(gb);
766 if (sh->rpl_modification_flag[1] == 1)
767 for (i = 0; i < sh->nb_refs[L1]; i++)
768 sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
772 if (sh->slice_type == HEVC_SLICE_B)
773 sh->mvd_l1_zero_flag = get_bits1(gb);
775 if (s->ps.pps->cabac_init_present_flag)
776 sh->cabac_init_flag = get_bits1(gb);
778 sh->cabac_init_flag = 0;
780 sh->collocated_ref_idx = 0;
781 if (sh->slice_temporal_mvp_enabled_flag) {
782 sh->collocated_list = L0;
783 if (sh->slice_type == HEVC_SLICE_B)
784 sh->collocated_list = !get_bits1(gb);
786 if (sh->nb_refs[sh->collocated_list] > 1) {
787 sh->collocated_ref_idx = get_ue_golomb_long(gb);
788 if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
789 av_log(s->avctx, AV_LOG_ERROR,
790 "Invalid collocated_ref_idx: %d.\n",
791 sh->collocated_ref_idx);
792 return AVERROR_INVALIDDATA;
797 if ((s->ps.pps->weighted_pred_flag && sh->slice_type == HEVC_SLICE_P) ||
798 (s->ps.pps->weighted_bipred_flag && sh->slice_type == HEVC_SLICE_B)) {
799 int ret = pred_weight_table(s, gb);
804 sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
805 if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
806 av_log(s->avctx, AV_LOG_ERROR,
807 "Invalid number of merging MVP candidates: %d.\n",
808 sh->max_num_merge_cand);
809 return AVERROR_INVALIDDATA;
813 sh->slice_qp_delta = get_se_golomb(gb);
815 if (s->ps.pps->pic_slice_level_chroma_qp_offsets_present_flag) {
816 sh->slice_cb_qp_offset = get_se_golomb(gb);
817 sh->slice_cr_qp_offset = get_se_golomb(gb);
819 sh->slice_cb_qp_offset = 0;
820 sh->slice_cr_qp_offset = 0;
823 if (s->ps.pps->chroma_qp_offset_list_enabled_flag)
824 sh->cu_chroma_qp_offset_enabled_flag = get_bits1(gb);
826 sh->cu_chroma_qp_offset_enabled_flag = 0;
828 if (s->ps.pps->deblocking_filter_control_present_flag) {
829 int deblocking_filter_override_flag = 0;
831 if (s->ps.pps->deblocking_filter_override_enabled_flag)
832 deblocking_filter_override_flag = get_bits1(gb);
834 if (deblocking_filter_override_flag) {
835 sh->disable_deblocking_filter_flag = get_bits1(gb);
836 if (!sh->disable_deblocking_filter_flag) {
837 int beta_offset_div2 = get_se_golomb(gb);
838 int tc_offset_div2 = get_se_golomb(gb) ;
839 if (beta_offset_div2 < -6 || beta_offset_div2 > 6 ||
840 tc_offset_div2 < -6 || tc_offset_div2 > 6) {
841 av_log(s->avctx, AV_LOG_ERROR,
842 "Invalid deblock filter offsets: %d, %d\n",
843 beta_offset_div2, tc_offset_div2);
844 return AVERROR_INVALIDDATA;
846 sh->beta_offset = beta_offset_div2 * 2;
847 sh->tc_offset = tc_offset_div2 * 2;
850 sh->disable_deblocking_filter_flag = s->ps.pps->disable_dbf;
851 sh->beta_offset = s->ps.pps->beta_offset;
852 sh->tc_offset = s->ps.pps->tc_offset;
855 sh->disable_deblocking_filter_flag = 0;
860 if (s->ps.pps->seq_loop_filter_across_slices_enabled_flag &&
861 (sh->slice_sample_adaptive_offset_flag[0] ||
862 sh->slice_sample_adaptive_offset_flag[1] ||
863 !sh->disable_deblocking_filter_flag)) {
864 sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
866 sh->slice_loop_filter_across_slices_enabled_flag = s->ps.pps->seq_loop_filter_across_slices_enabled_flag;
868 } else if (!s->slice_initialized) {
869 av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
870 return AVERROR_INVALIDDATA;
873 sh->num_entry_point_offsets = 0;
874 if (s->ps.pps->tiles_enabled_flag || s->ps.pps->entropy_coding_sync_enabled_flag) {
875 unsigned num_entry_point_offsets = get_ue_golomb_long(gb);
876 // It would be possible to bound this tighter but this here is simpler
877 if (num_entry_point_offsets > get_bits_left(gb)) {
878 av_log(s->avctx, AV_LOG_ERROR, "num_entry_point_offsets %d is invalid\n", num_entry_point_offsets);
879 return AVERROR_INVALIDDATA;
882 sh->num_entry_point_offsets = num_entry_point_offsets;
883 if (sh->num_entry_point_offsets > 0) {
884 int offset_len = get_ue_golomb_long(gb) + 1;
886 if (offset_len < 1 || offset_len > 32) {
887 sh->num_entry_point_offsets = 0;
888 av_log(s->avctx, AV_LOG_ERROR, "offset_len %d is invalid\n", offset_len);
889 return AVERROR_INVALIDDATA;
892 av_freep(&sh->entry_point_offset);
893 av_freep(&sh->offset);
895 sh->entry_point_offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(unsigned));
896 sh->offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
897 sh->size = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
898 if (!sh->entry_point_offset || !sh->offset || !sh->size) {
899 sh->num_entry_point_offsets = 0;
900 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate memory\n");
901 return AVERROR(ENOMEM);
903 for (i = 0; i < sh->num_entry_point_offsets; i++) {
904 unsigned val = get_bits_long(gb, offset_len);
905 sh->entry_point_offset[i] = val + 1; // +1; // +1 to get the size
907 if (s->threads_number > 1 && (s->ps.pps->num_tile_rows > 1 || s->ps.pps->num_tile_columns > 1)) {
908 s->enable_parallel_tiles = 0; // TODO: you can enable tiles in parallel here
909 s->threads_number = 1;
911 s->enable_parallel_tiles = 0;
913 s->enable_parallel_tiles = 0;
916 if (s->ps.pps->slice_header_extension_present_flag) {
917 unsigned int length = get_ue_golomb_long(gb);
918 if (length*8LL > get_bits_left(gb)) {
919 av_log(s->avctx, AV_LOG_ERROR, "too many slice_header_extension_data_bytes\n");
920 return AVERROR_INVALIDDATA;
922 for (i = 0; i < length; i++)
923 skip_bits(gb, 8); // slice_header_extension_data_byte
926 // Inferred parameters
927 sh->slice_qp = 26U + s->ps.pps->pic_init_qp_minus26 + sh->slice_qp_delta;
928 if (sh->slice_qp > 51 ||
929 sh->slice_qp < -s->ps.sps->qp_bd_offset) {
930 av_log(s->avctx, AV_LOG_ERROR,
931 "The slice_qp %d is outside the valid range "
934 -s->ps.sps->qp_bd_offset);
935 return AVERROR_INVALIDDATA;
938 sh->slice_ctb_addr_rs = sh->slice_segment_addr;
940 if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) {
941 av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
942 return AVERROR_INVALIDDATA;
945 if (get_bits_left(gb) < 0) {
946 av_log(s->avctx, AV_LOG_ERROR,
947 "Overread slice header by %d bits\n", -get_bits_left(gb));
948 return AVERROR_INVALIDDATA;
951 s->HEVClc->first_qp_group = !s->sh.dependent_slice_segment_flag;
953 if (!s->ps.pps->cu_qp_delta_enabled_flag)
954 s->HEVClc->qp_y = s->sh.slice_qp;
956 s->slice_initialized = 1;
957 s->HEVClc->tu.cu_qp_offset_cb = 0;
958 s->HEVClc->tu.cu_qp_offset_cr = 0;
963 #define CTB(tab, x, y) ((tab)[(y) * s->ps.sps->ctb_width + (x)])
965 #define SET_SAO(elem, value) \
967 if (!sao_merge_up_flag && !sao_merge_left_flag) \
969 else if (sao_merge_left_flag) \
970 sao->elem = CTB(s->sao, rx-1, ry).elem; \
971 else if (sao_merge_up_flag) \
972 sao->elem = CTB(s->sao, rx, ry-1).elem; \
977 static void hls_sao_param(HEVCContext *s, int rx, int ry)
979 HEVCLocalContext *lc = s->HEVClc;
980 int sao_merge_left_flag = 0;
981 int sao_merge_up_flag = 0;
982 SAOParams *sao = &CTB(s->sao, rx, ry);
985 if (s->sh.slice_sample_adaptive_offset_flag[0] ||
986 s->sh.slice_sample_adaptive_offset_flag[1]) {
988 if (lc->ctb_left_flag)
989 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
991 if (ry > 0 && !sao_merge_left_flag) {
993 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
997 for (c_idx = 0; c_idx < (s->ps.sps->chroma_format_idc ? 3 : 1); c_idx++) {
998 int log2_sao_offset_scale = c_idx == 0 ? s->ps.pps->log2_sao_offset_scale_luma :
999 s->ps.pps->log2_sao_offset_scale_chroma;
1001 if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
1002 sao->type_idx[c_idx] = SAO_NOT_APPLIED;
1007 sao->type_idx[2] = sao->type_idx[1];
1008 sao->eo_class[2] = sao->eo_class[1];
1010 SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
1013 if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
1016 for (i = 0; i < 4; i++)
1017 SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
1019 if (sao->type_idx[c_idx] == SAO_BAND) {
1020 for (i = 0; i < 4; i++) {
1021 if (sao->offset_abs[c_idx][i]) {
1022 SET_SAO(offset_sign[c_idx][i],
1023 ff_hevc_sao_offset_sign_decode(s));
1025 sao->offset_sign[c_idx][i] = 0;
1028 SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
1029 } else if (c_idx != 2) {
1030 SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
1033 // Inferred parameters
1034 sao->offset_val[c_idx][0] = 0;
1035 for (i = 0; i < 4; i++) {
1036 sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i];
1037 if (sao->type_idx[c_idx] == SAO_EDGE) {
1039 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
1040 } else if (sao->offset_sign[c_idx][i]) {
1041 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
1043 sao->offset_val[c_idx][i + 1] *= 1 << log2_sao_offset_scale;
1051 static int hls_cross_component_pred(HEVCContext *s, int idx) {
1052 HEVCLocalContext *lc = s->HEVClc;
1053 int log2_res_scale_abs_plus1 = ff_hevc_log2_res_scale_abs(s, idx);
1055 if (log2_res_scale_abs_plus1 != 0) {
1056 int res_scale_sign_flag = ff_hevc_res_scale_sign_flag(s, idx);
1057 lc->tu.res_scale_val = (1 << (log2_res_scale_abs_plus1 - 1)) *
1058 (1 - 2 * res_scale_sign_flag);
1060 lc->tu.res_scale_val = 0;
1067 static int hls_transform_unit(HEVCContext *s, int x0, int y0,
1068 int xBase, int yBase, int cb_xBase, int cb_yBase,
1069 int log2_cb_size, int log2_trafo_size,
1070 int blk_idx, int cbf_luma, int *cbf_cb, int *cbf_cr)
1072 HEVCLocalContext *lc = s->HEVClc;
1073 const int log2_trafo_size_c = log2_trafo_size - s->ps.sps->hshift[1];
1076 if (lc->cu.pred_mode == MODE_INTRA) {
1077 int trafo_size = 1 << log2_trafo_size;
1078 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1080 s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
1083 if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
1084 (s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1085 int scan_idx = SCAN_DIAG;
1086 int scan_idx_c = SCAN_DIAG;
1087 int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
1088 (s->ps.sps->chroma_format_idc == 2 &&
1089 (cbf_cb[1] || cbf_cr[1]));
1091 if (s->ps.pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
1092 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
1093 if (lc->tu.cu_qp_delta != 0)
1094 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
1095 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
1096 lc->tu.is_cu_qp_delta_coded = 1;
1098 if (lc->tu.cu_qp_delta < -(26 + s->ps.sps->qp_bd_offset / 2) ||
1099 lc->tu.cu_qp_delta > (25 + s->ps.sps->qp_bd_offset / 2)) {
1100 av_log(s->avctx, AV_LOG_ERROR,
1101 "The cu_qp_delta %d is outside the valid range "
1104 -(26 + s->ps.sps->qp_bd_offset / 2),
1105 (25 + s->ps.sps->qp_bd_offset / 2));
1106 return AVERROR_INVALIDDATA;
1109 ff_hevc_set_qPy(s, cb_xBase, cb_yBase, log2_cb_size);
1112 if (s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
1113 !lc->cu.cu_transquant_bypass_flag && !lc->tu.is_cu_chroma_qp_offset_coded) {
1114 int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(s);
1115 if (cu_chroma_qp_offset_flag) {
1116 int cu_chroma_qp_offset_idx = 0;
1117 if (s->ps.pps->chroma_qp_offset_list_len_minus1 > 0) {
1118 cu_chroma_qp_offset_idx = ff_hevc_cu_chroma_qp_offset_idx(s);
1119 av_log(s->avctx, AV_LOG_ERROR,
1120 "cu_chroma_qp_offset_idx not yet tested.\n");
1122 lc->tu.cu_qp_offset_cb = s->ps.pps->cb_qp_offset_list[cu_chroma_qp_offset_idx];
1123 lc->tu.cu_qp_offset_cr = s->ps.pps->cr_qp_offset_list[cu_chroma_qp_offset_idx];
1125 lc->tu.cu_qp_offset_cb = 0;
1126 lc->tu.cu_qp_offset_cr = 0;
1128 lc->tu.is_cu_chroma_qp_offset_coded = 1;
1131 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
1132 if (lc->tu.intra_pred_mode >= 6 &&
1133 lc->tu.intra_pred_mode <= 14) {
1134 scan_idx = SCAN_VERT;
1135 } else if (lc->tu.intra_pred_mode >= 22 &&
1136 lc->tu.intra_pred_mode <= 30) {
1137 scan_idx = SCAN_HORIZ;
1140 if (lc->tu.intra_pred_mode_c >= 6 &&
1141 lc->tu.intra_pred_mode_c <= 14) {
1142 scan_idx_c = SCAN_VERT;
1143 } else if (lc->tu.intra_pred_mode_c >= 22 &&
1144 lc->tu.intra_pred_mode_c <= 30) {
1145 scan_idx_c = SCAN_HORIZ;
1149 lc->tu.cross_pf = 0;
1152 ff_hevc_hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
1153 if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) {
1154 int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]);
1155 int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]);
1156 lc->tu.cross_pf = (s->ps.pps->cross_component_prediction_enabled_flag && cbf_luma &&
1157 (lc->cu.pred_mode == MODE_INTER ||
1158 (lc->tu.chroma_mode_c == 4)));
1160 if (lc->tu.cross_pf) {
1161 hls_cross_component_pred(s, 0);
1163 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1164 if (lc->cu.pred_mode == MODE_INTRA) {
1165 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1166 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 1);
1169 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1170 log2_trafo_size_c, scan_idx_c, 1);
1172 if (lc->tu.cross_pf) {
1173 ptrdiff_t stride = s->frame->linesize[1];
1174 int hshift = s->ps.sps->hshift[1];
1175 int vshift = s->ps.sps->vshift[1];
1176 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1177 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1178 int size = 1 << log2_trafo_size_c;
1180 uint8_t *dst = &s->frame->data[1][(y0 >> vshift) * stride +
1181 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1182 for (i = 0; i < (size * size); i++) {
1183 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1185 s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
1189 if (lc->tu.cross_pf) {
1190 hls_cross_component_pred(s, 1);
1192 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1193 if (lc->cu.pred_mode == MODE_INTRA) {
1194 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1195 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 2);
1198 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1199 log2_trafo_size_c, scan_idx_c, 2);
1201 if (lc->tu.cross_pf) {
1202 ptrdiff_t stride = s->frame->linesize[2];
1203 int hshift = s->ps.sps->hshift[2];
1204 int vshift = s->ps.sps->vshift[2];
1205 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1206 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1207 int size = 1 << log2_trafo_size_c;
1209 uint8_t *dst = &s->frame->data[2][(y0 >> vshift) * stride +
1210 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1211 for (i = 0; i < (size * size); i++) {
1212 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1214 s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
1217 } else if (s->ps.sps->chroma_format_idc && blk_idx == 3) {
1218 int trafo_size_h = 1 << (log2_trafo_size + 1);
1219 int trafo_size_v = 1 << (log2_trafo_size + s->ps.sps->vshift[1]);
1220 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1221 if (lc->cu.pred_mode == MODE_INTRA) {
1222 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1223 trafo_size_h, trafo_size_v);
1224 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 1);
1227 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1228 log2_trafo_size, scan_idx_c, 1);
1230 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1231 if (lc->cu.pred_mode == MODE_INTRA) {
1232 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1233 trafo_size_h, trafo_size_v);
1234 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 2);
1237 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1238 log2_trafo_size, scan_idx_c, 2);
1241 } else if (s->ps.sps->chroma_format_idc && lc->cu.pred_mode == MODE_INTRA) {
1242 if (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3) {
1243 int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]);
1244 int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]);
1245 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size_h, trafo_size_v);
1246 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 1);
1247 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 2);
1248 if (s->ps.sps->chroma_format_idc == 2) {
1249 ff_hevc_set_neighbour_available(s, x0, y0 + (1 << log2_trafo_size_c),
1250 trafo_size_h, trafo_size_v);
1251 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 1);
1252 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 2);
1254 } else if (blk_idx == 3) {
1255 int trafo_size_h = 1 << (log2_trafo_size + 1);
1256 int trafo_size_v = 1 << (log2_trafo_size + s->ps.sps->vshift[1]);
1257 ff_hevc_set_neighbour_available(s, xBase, yBase,
1258 trafo_size_h, trafo_size_v);
1259 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1260 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1261 if (s->ps.sps->chroma_format_idc == 2) {
1262 ff_hevc_set_neighbour_available(s, xBase, yBase + (1 << (log2_trafo_size)),
1263 trafo_size_h, trafo_size_v);
1264 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 1);
1265 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 2);
1273 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1275 int cb_size = 1 << log2_cb_size;
1276 int log2_min_pu_size = s->ps.sps->log2_min_pu_size;
1278 int min_pu_width = s->ps.sps->min_pu_width;
1279 int x_end = FFMIN(x0 + cb_size, s->ps.sps->width);
1280 int y_end = FFMIN(y0 + cb_size, s->ps.sps->height);
1283 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1284 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1285 s->is_pcm[i + j * min_pu_width] = 2;
1288 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1289 int xBase, int yBase, int cb_xBase, int cb_yBase,
1290 int log2_cb_size, int log2_trafo_size,
1291 int trafo_depth, int blk_idx,
1292 const int *base_cbf_cb, const int *base_cbf_cr)
1294 HEVCLocalContext *lc = s->HEVClc;
1295 uint8_t split_transform_flag;
1300 cbf_cb[0] = base_cbf_cb[0];
1301 cbf_cb[1] = base_cbf_cb[1];
1302 cbf_cr[0] = base_cbf_cr[0];
1303 cbf_cr[1] = base_cbf_cr[1];
1305 if (lc->cu.intra_split_flag) {
1306 if (trafo_depth == 1) {
1307 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1308 if (s->ps.sps->chroma_format_idc == 3) {
1309 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[blk_idx];
1310 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[blk_idx];
1312 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1313 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1317 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[0];
1318 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1319 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1322 if (log2_trafo_size <= s->ps.sps->log2_max_trafo_size &&
1323 log2_trafo_size > s->ps.sps->log2_min_tb_size &&
1324 trafo_depth < lc->cu.max_trafo_depth &&
1325 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1326 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1328 int inter_split = s->ps.sps->max_transform_hierarchy_depth_inter == 0 &&
1329 lc->cu.pred_mode == MODE_INTER &&
1330 lc->cu.part_mode != PART_2Nx2N &&
1333 split_transform_flag = log2_trafo_size > s->ps.sps->log2_max_trafo_size ||
1334 (lc->cu.intra_split_flag && trafo_depth == 0) ||
1338 if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) {
1339 if (trafo_depth == 0 || cbf_cb[0]) {
1340 cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1341 if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1342 cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1346 if (trafo_depth == 0 || cbf_cr[0]) {
1347 cbf_cr[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1348 if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1349 cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1354 if (split_transform_flag) {
1355 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1356 const int x1 = x0 + trafo_size_split;
1357 const int y1 = y0 + trafo_size_split;
1359 #define SUBDIVIDE(x, y, idx) \
1361 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1362 log2_trafo_size - 1, trafo_depth + 1, idx, \
1368 SUBDIVIDE(x0, y0, 0);
1369 SUBDIVIDE(x1, y0, 1);
1370 SUBDIVIDE(x0, y1, 2);
1371 SUBDIVIDE(x1, y1, 3);
1375 int min_tu_size = 1 << s->ps.sps->log2_min_tb_size;
1376 int log2_min_tu_size = s->ps.sps->log2_min_tb_size;
1377 int min_tu_width = s->ps.sps->min_tb_width;
1380 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1381 cbf_cb[0] || cbf_cr[0] ||
1382 (s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1383 cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1386 ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1387 log2_cb_size, log2_trafo_size,
1388 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1391 // TODO: store cbf_luma somewhere else
1394 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1395 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1396 int x_tu = (x0 + j) >> log2_min_tu_size;
1397 int y_tu = (y0 + i) >> log2_min_tu_size;
1398 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1401 if (!s->sh.disable_deblocking_filter_flag) {
1402 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1403 if (s->ps.pps->transquant_bypass_enable_flag &&
1404 lc->cu.cu_transquant_bypass_flag)
1405 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1411 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1413 HEVCLocalContext *lc = s->HEVClc;
1415 int cb_size = 1 << log2_cb_size;
1416 ptrdiff_t stride0 = s->frame->linesize[0];
1417 ptrdiff_t stride1 = s->frame->linesize[1];
1418 ptrdiff_t stride2 = s->frame->linesize[2];
1419 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->ps.sps->pixel_shift)];
1420 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)];
1421 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)];
1423 int length = cb_size * cb_size * s->ps.sps->pcm.bit_depth +
1424 (((cb_size >> s->ps.sps->hshift[1]) * (cb_size >> s->ps.sps->vshift[1])) +
1425 ((cb_size >> s->ps.sps->hshift[2]) * (cb_size >> s->ps.sps->vshift[2]))) *
1426 s->ps.sps->pcm.bit_depth_chroma;
1427 const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1430 if (!s->sh.disable_deblocking_filter_flag)
1431 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1433 ret = init_get_bits(&gb, pcm, length);
1437 s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size, &gb, s->ps.sps->pcm.bit_depth);
1438 if (s->ps.sps->chroma_format_idc) {
1439 s->hevcdsp.put_pcm(dst1, stride1,
1440 cb_size >> s->ps.sps->hshift[1],
1441 cb_size >> s->ps.sps->vshift[1],
1442 &gb, s->ps.sps->pcm.bit_depth_chroma);
1443 s->hevcdsp.put_pcm(dst2, stride2,
1444 cb_size >> s->ps.sps->hshift[2],
1445 cb_size >> s->ps.sps->vshift[2],
1446 &gb, s->ps.sps->pcm.bit_depth_chroma);
1453 * 8.5.3.2.2.1 Luma sample unidirectional interpolation process
1455 * @param s HEVC decoding context
1456 * @param dst target buffer for block data at block position
1457 * @param dststride stride of the dst buffer
1458 * @param ref reference picture buffer at origin (0, 0)
1459 * @param mv motion vector (relative to block position) to get pixel data from
1460 * @param x_off horizontal position of block from origin (0, 0)
1461 * @param y_off vertical position of block from origin (0, 0)
1462 * @param block_w width of block
1463 * @param block_h height of block
1464 * @param luma_weight weighting factor applied to the luma prediction
1465 * @param luma_offset additive offset applied to the luma prediction value
1468 static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1469 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1470 int block_w, int block_h, int luma_weight, int luma_offset)
1472 HEVCLocalContext *lc = s->HEVClc;
1473 uint8_t *src = ref->data[0];
1474 ptrdiff_t srcstride = ref->linesize[0];
1475 int pic_width = s->ps.sps->width;
1476 int pic_height = s->ps.sps->height;
1479 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1480 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1481 int idx = ff_hevc_pel_weight[block_w];
1483 x_off += mv->x >> 2;
1484 y_off += mv->y >> 2;
1485 src += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1487 if (x_off < QPEL_EXTRA_BEFORE || y_off < QPEL_EXTRA_AFTER ||
1488 x_off >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1489 y_off >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1490 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1491 int offset = QPEL_EXTRA_BEFORE * srcstride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1492 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1494 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1495 edge_emu_stride, srcstride,
1496 block_w + QPEL_EXTRA,
1497 block_h + QPEL_EXTRA,
1498 x_off - QPEL_EXTRA_BEFORE, y_off - QPEL_EXTRA_BEFORE,
1499 pic_width, pic_height);
1500 src = lc->edge_emu_buffer + buf_offset;
1501 srcstride = edge_emu_stride;
1505 s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride, src, srcstride,
1506 block_h, mx, my, block_w);
1508 s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride, src, srcstride,
1509 block_h, s->sh.luma_log2_weight_denom,
1510 luma_weight, luma_offset, mx, my, block_w);
1514 * 8.5.3.2.2.1 Luma sample bidirectional interpolation process
1516 * @param s HEVC decoding context
1517 * @param dst target buffer for block data at block position
1518 * @param dststride stride of the dst buffer
1519 * @param ref0 reference picture0 buffer at origin (0, 0)
1520 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1521 * @param x_off horizontal position of block from origin (0, 0)
1522 * @param y_off vertical position of block from origin (0, 0)
1523 * @param block_w width of block
1524 * @param block_h height of block
1525 * @param ref1 reference picture1 buffer at origin (0, 0)
1526 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1527 * @param current_mv current motion vector structure
1529 static void luma_mc_bi(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1530 AVFrame *ref0, const Mv *mv0, int x_off, int y_off,
1531 int block_w, int block_h, AVFrame *ref1, const Mv *mv1, struct MvField *current_mv)
1533 HEVCLocalContext *lc = s->HEVClc;
1534 ptrdiff_t src0stride = ref0->linesize[0];
1535 ptrdiff_t src1stride = ref1->linesize[0];
1536 int pic_width = s->ps.sps->width;
1537 int pic_height = s->ps.sps->height;
1538 int mx0 = mv0->x & 3;
1539 int my0 = mv0->y & 3;
1540 int mx1 = mv1->x & 3;
1541 int my1 = mv1->y & 3;
1542 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1543 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1544 int x_off0 = x_off + (mv0->x >> 2);
1545 int y_off0 = y_off + (mv0->y >> 2);
1546 int x_off1 = x_off + (mv1->x >> 2);
1547 int y_off1 = y_off + (mv1->y >> 2);
1548 int idx = ff_hevc_pel_weight[block_w];
1550 uint8_t *src0 = ref0->data[0] + y_off0 * src0stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift);
1551 uint8_t *src1 = ref1->data[0] + y_off1 * src1stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift);
1553 if (x_off0 < QPEL_EXTRA_BEFORE || y_off0 < QPEL_EXTRA_AFTER ||
1554 x_off0 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1555 y_off0 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1556 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1557 int offset = QPEL_EXTRA_BEFORE * src0stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1558 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1560 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset,
1561 edge_emu_stride, src0stride,
1562 block_w + QPEL_EXTRA,
1563 block_h + QPEL_EXTRA,
1564 x_off0 - QPEL_EXTRA_BEFORE, y_off0 - QPEL_EXTRA_BEFORE,
1565 pic_width, pic_height);
1566 src0 = lc->edge_emu_buffer + buf_offset;
1567 src0stride = edge_emu_stride;
1570 if (x_off1 < QPEL_EXTRA_BEFORE || y_off1 < QPEL_EXTRA_AFTER ||
1571 x_off1 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1572 y_off1 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1573 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1574 int offset = QPEL_EXTRA_BEFORE * src1stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1575 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1577 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src1 - offset,
1578 edge_emu_stride, src1stride,
1579 block_w + QPEL_EXTRA,
1580 block_h + QPEL_EXTRA,
1581 x_off1 - QPEL_EXTRA_BEFORE, y_off1 - QPEL_EXTRA_BEFORE,
1582 pic_width, pic_height);
1583 src1 = lc->edge_emu_buffer2 + buf_offset;
1584 src1stride = edge_emu_stride;
1587 s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](lc->tmp, src0, src0stride,
1588 block_h, mx0, my0, block_w);
1590 s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1591 block_h, mx1, my1, block_w);
1593 s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1594 block_h, s->sh.luma_log2_weight_denom,
1595 s->sh.luma_weight_l0[current_mv->ref_idx[0]],
1596 s->sh.luma_weight_l1[current_mv->ref_idx[1]],
1597 s->sh.luma_offset_l0[current_mv->ref_idx[0]],
1598 s->sh.luma_offset_l1[current_mv->ref_idx[1]],
1604 * 8.5.3.2.2.2 Chroma sample uniprediction interpolation process
1606 * @param s HEVC decoding context
1607 * @param dst1 target buffer for block data at block position (U plane)
1608 * @param dst2 target buffer for block data at block position (V plane)
1609 * @param dststride stride of the dst1 and dst2 buffers
1610 * @param ref reference picture buffer at origin (0, 0)
1611 * @param mv motion vector (relative to block position) to get pixel data from
1612 * @param x_off horizontal position of block from origin (0, 0)
1613 * @param y_off vertical position of block from origin (0, 0)
1614 * @param block_w width of block
1615 * @param block_h height of block
1616 * @param chroma_weight weighting factor applied to the chroma prediction
1617 * @param chroma_offset additive offset applied to the chroma prediction value
1620 static void chroma_mc_uni(HEVCContext *s, uint8_t *dst0,
1621 ptrdiff_t dststride, uint8_t *src0, ptrdiff_t srcstride, int reflist,
1622 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int chroma_weight, int chroma_offset)
1624 HEVCLocalContext *lc = s->HEVClc;
1625 int pic_width = s->ps.sps->width >> s->ps.sps->hshift[1];
1626 int pic_height = s->ps.sps->height >> s->ps.sps->vshift[1];
1627 const Mv *mv = ¤t_mv->mv[reflist];
1628 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1629 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1630 int idx = ff_hevc_pel_weight[block_w];
1631 int hshift = s->ps.sps->hshift[1];
1632 int vshift = s->ps.sps->vshift[1];
1633 intptr_t mx = av_mod_uintp2(mv->x, 2 + hshift);
1634 intptr_t my = av_mod_uintp2(mv->y, 2 + vshift);
1635 intptr_t _mx = mx << (1 - hshift);
1636 intptr_t _my = my << (1 - vshift);
1638 x_off += mv->x >> (2 + hshift);
1639 y_off += mv->y >> (2 + vshift);
1640 src0 += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1642 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1643 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1644 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1645 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1646 int offset0 = EPEL_EXTRA_BEFORE * (srcstride + (1 << s->ps.sps->pixel_shift));
1647 int buf_offset0 = EPEL_EXTRA_BEFORE *
1648 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1649 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset0,
1650 edge_emu_stride, srcstride,
1651 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1652 x_off - EPEL_EXTRA_BEFORE,
1653 y_off - EPEL_EXTRA_BEFORE,
1654 pic_width, pic_height);
1656 src0 = lc->edge_emu_buffer + buf_offset0;
1657 srcstride = edge_emu_stride;
1660 s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1661 block_h, _mx, _my, block_w);
1663 s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1664 block_h, s->sh.chroma_log2_weight_denom,
1665 chroma_weight, chroma_offset, _mx, _my, block_w);
1669 * 8.5.3.2.2.2 Chroma sample bidirectional interpolation process
1671 * @param s HEVC decoding context
1672 * @param dst target buffer for block data at block position
1673 * @param dststride stride of the dst buffer
1674 * @param ref0 reference picture0 buffer at origin (0, 0)
1675 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1676 * @param x_off horizontal position of block from origin (0, 0)
1677 * @param y_off vertical position of block from origin (0, 0)
1678 * @param block_w width of block
1679 * @param block_h height of block
1680 * @param ref1 reference picture1 buffer at origin (0, 0)
1681 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1682 * @param current_mv current motion vector structure
1683 * @param cidx chroma component(cb, cr)
1685 static void chroma_mc_bi(HEVCContext *s, uint8_t *dst0, ptrdiff_t dststride, AVFrame *ref0, AVFrame *ref1,
1686 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int cidx)
1688 HEVCLocalContext *lc = s->HEVClc;
1689 uint8_t *src1 = ref0->data[cidx+1];
1690 uint8_t *src2 = ref1->data[cidx+1];
1691 ptrdiff_t src1stride = ref0->linesize[cidx+1];
1692 ptrdiff_t src2stride = ref1->linesize[cidx+1];
1693 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1694 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1695 int pic_width = s->ps.sps->width >> s->ps.sps->hshift[1];
1696 int pic_height = s->ps.sps->height >> s->ps.sps->vshift[1];
1697 Mv *mv0 = ¤t_mv->mv[0];
1698 Mv *mv1 = ¤t_mv->mv[1];
1699 int hshift = s->ps.sps->hshift[1];
1700 int vshift = s->ps.sps->vshift[1];
1702 intptr_t mx0 = av_mod_uintp2(mv0->x, 2 + hshift);
1703 intptr_t my0 = av_mod_uintp2(mv0->y, 2 + vshift);
1704 intptr_t mx1 = av_mod_uintp2(mv1->x, 2 + hshift);
1705 intptr_t my1 = av_mod_uintp2(mv1->y, 2 + vshift);
1706 intptr_t _mx0 = mx0 << (1 - hshift);
1707 intptr_t _my0 = my0 << (1 - vshift);
1708 intptr_t _mx1 = mx1 << (1 - hshift);
1709 intptr_t _my1 = my1 << (1 - vshift);
1711 int x_off0 = x_off + (mv0->x >> (2 + hshift));
1712 int y_off0 = y_off + (mv0->y >> (2 + vshift));
1713 int x_off1 = x_off + (mv1->x >> (2 + hshift));
1714 int y_off1 = y_off + (mv1->y >> (2 + vshift));
1715 int idx = ff_hevc_pel_weight[block_w];
1716 src1 += y_off0 * src1stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift);
1717 src2 += y_off1 * src2stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift);
1719 if (x_off0 < EPEL_EXTRA_BEFORE || y_off0 < EPEL_EXTRA_AFTER ||
1720 x_off0 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1721 y_off0 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1722 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1723 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->ps.sps->pixel_shift));
1724 int buf_offset1 = EPEL_EXTRA_BEFORE *
1725 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1727 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1728 edge_emu_stride, src1stride,
1729 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1730 x_off0 - EPEL_EXTRA_BEFORE,
1731 y_off0 - EPEL_EXTRA_BEFORE,
1732 pic_width, pic_height);
1734 src1 = lc->edge_emu_buffer + buf_offset1;
1735 src1stride = edge_emu_stride;
1738 if (x_off1 < EPEL_EXTRA_BEFORE || y_off1 < EPEL_EXTRA_AFTER ||
1739 x_off1 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1740 y_off1 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1741 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1742 int offset1 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->ps.sps->pixel_shift));
1743 int buf_offset1 = EPEL_EXTRA_BEFORE *
1744 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1746 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src2 - offset1,
1747 edge_emu_stride, src2stride,
1748 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1749 x_off1 - EPEL_EXTRA_BEFORE,
1750 y_off1 - EPEL_EXTRA_BEFORE,
1751 pic_width, pic_height);
1753 src2 = lc->edge_emu_buffer2 + buf_offset1;
1754 src2stride = edge_emu_stride;
1757 s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](lc->tmp, src1, src1stride,
1758 block_h, _mx0, _my0, block_w);
1760 s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1761 src2, src2stride, lc->tmp,
1762 block_h, _mx1, _my1, block_w);
1764 s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1765 src2, src2stride, lc->tmp,
1767 s->sh.chroma_log2_weight_denom,
1768 s->sh.chroma_weight_l0[current_mv->ref_idx[0]][cidx],
1769 s->sh.chroma_weight_l1[current_mv->ref_idx[1]][cidx],
1770 s->sh.chroma_offset_l0[current_mv->ref_idx[0]][cidx],
1771 s->sh.chroma_offset_l1[current_mv->ref_idx[1]][cidx],
1772 _mx1, _my1, block_w);
1775 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1776 const Mv *mv, int y0, int height)
1778 if (s->threads_type == FF_THREAD_FRAME ) {
1779 int y = FFMAX(0, (mv->y >> 2) + y0 + height + 9);
1781 ff_thread_await_progress(&ref->tf, y, 0);
1785 static void hevc_luma_mv_mvp_mode(HEVCContext *s, int x0, int y0, int nPbW,
1786 int nPbH, int log2_cb_size, int part_idx,
1787 int merge_idx, MvField *mv)
1789 HEVCLocalContext *lc = s->HEVClc;
1790 enum InterPredIdc inter_pred_idc = PRED_L0;
1793 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1795 if (s->sh.slice_type == HEVC_SLICE_B)
1796 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1798 if (inter_pred_idc != PRED_L1) {
1799 if (s->sh.nb_refs[L0])
1800 mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1802 mv->pred_flag = PF_L0;
1803 ff_hevc_hls_mvd_coding(s, x0, y0, 0);
1804 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1805 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1806 part_idx, merge_idx, mv, mvp_flag, 0);
1807 mv->mv[0].x += lc->pu.mvd.x;
1808 mv->mv[0].y += lc->pu.mvd.y;
1811 if (inter_pred_idc != PRED_L0) {
1812 if (s->sh.nb_refs[L1])
1813 mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1815 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1816 AV_ZERO32(&lc->pu.mvd);
1818 ff_hevc_hls_mvd_coding(s, x0, y0, 1);
1821 mv->pred_flag += PF_L1;
1822 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1823 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1824 part_idx, merge_idx, mv, mvp_flag, 1);
1825 mv->mv[1].x += lc->pu.mvd.x;
1826 mv->mv[1].y += lc->pu.mvd.y;
1830 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1832 int log2_cb_size, int partIdx, int idx)
1834 #define POS(c_idx, x, y) \
1835 &s->frame->data[c_idx][((y) >> s->ps.sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1836 (((x) >> s->ps.sps->hshift[c_idx]) << s->ps.sps->pixel_shift)]
1837 HEVCLocalContext *lc = s->HEVClc;
1839 struct MvField current_mv = {{{ 0 }}};
1841 int min_pu_width = s->ps.sps->min_pu_width;
1843 MvField *tab_mvf = s->ref->tab_mvf;
1844 RefPicList *refPicList = s->ref->refPicList;
1845 HEVCFrame *ref0 = NULL, *ref1 = NULL;
1846 uint8_t *dst0 = POS(0, x0, y0);
1847 uint8_t *dst1 = POS(1, x0, y0);
1848 uint8_t *dst2 = POS(2, x0, y0);
1849 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
1850 int min_cb_width = s->ps.sps->min_cb_width;
1851 int x_cb = x0 >> log2_min_cb_size;
1852 int y_cb = y0 >> log2_min_cb_size;
1856 int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1859 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1861 if (skip_flag || lc->pu.merge_flag) {
1862 if (s->sh.max_num_merge_cand > 1)
1863 merge_idx = ff_hevc_merge_idx_decode(s);
1867 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1868 partIdx, merge_idx, ¤t_mv);
1870 hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1871 partIdx, merge_idx, ¤t_mv);
1874 x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1875 y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1877 for (j = 0; j < nPbH >> s->ps.sps->log2_min_pu_size; j++)
1878 for (i = 0; i < nPbW >> s->ps.sps->log2_min_pu_size; i++)
1879 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1881 if (current_mv.pred_flag & PF_L0) {
1882 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1885 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1887 if (current_mv.pred_flag & PF_L1) {
1888 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1891 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1894 if (current_mv.pred_flag == PF_L0) {
1895 int x0_c = x0 >> s->ps.sps->hshift[1];
1896 int y0_c = y0 >> s->ps.sps->vshift[1];
1897 int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1898 int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1900 luma_mc_uni(s, dst0, s->frame->linesize[0], ref0->frame,
1901 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1902 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1903 s->sh.luma_offset_l0[current_mv.ref_idx[0]]);
1905 if (s->ps.sps->chroma_format_idc) {
1906 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref0->frame->data[1], ref0->frame->linesize[1],
1907 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1908 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]);
1909 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref0->frame->data[2], ref0->frame->linesize[2],
1910 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1911 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]);
1913 } else if (current_mv.pred_flag == PF_L1) {
1914 int x0_c = x0 >> s->ps.sps->hshift[1];
1915 int y0_c = y0 >> s->ps.sps->vshift[1];
1916 int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1917 int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1919 luma_mc_uni(s, dst0, s->frame->linesize[0], ref1->frame,
1920 ¤t_mv.mv[1], x0, y0, nPbW, nPbH,
1921 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1922 s->sh.luma_offset_l1[current_mv.ref_idx[1]]);
1924 if (s->ps.sps->chroma_format_idc) {
1925 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
1926 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1927 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]);
1929 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
1930 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1931 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]);
1933 } else if (current_mv.pred_flag == PF_BI) {
1934 int x0_c = x0 >> s->ps.sps->hshift[1];
1935 int y0_c = y0 >> s->ps.sps->vshift[1];
1936 int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1937 int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1939 luma_mc_bi(s, dst0, s->frame->linesize[0], ref0->frame,
1940 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1941 ref1->frame, ¤t_mv.mv[1], ¤t_mv);
1943 if (s->ps.sps->chroma_format_idc) {
1944 chroma_mc_bi(s, dst1, s->frame->linesize[1], ref0->frame, ref1->frame,
1945 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 0);
1947 chroma_mc_bi(s, dst2, s->frame->linesize[2], ref0->frame, ref1->frame,
1948 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1);
1956 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1957 int prev_intra_luma_pred_flag)
1959 HEVCLocalContext *lc = s->HEVClc;
1960 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1961 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1962 int min_pu_width = s->ps.sps->min_pu_width;
1963 int size_in_pus = pu_size >> s->ps.sps->log2_min_pu_size;
1964 int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
1965 int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
1967 int cand_up = (lc->ctb_up_flag || y0b) ?
1968 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1969 int cand_left = (lc->ctb_left_flag || x0b) ?
1970 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1972 int y_ctb = (y0 >> (s->ps.sps->log2_ctb_size)) << (s->ps.sps->log2_ctb_size);
1974 MvField *tab_mvf = s->ref->tab_mvf;
1975 int intra_pred_mode;
1979 // intra_pred_mode prediction does not cross vertical CTB boundaries
1980 if ((y0 - 1) < y_ctb)
1983 if (cand_left == cand_up) {
1984 if (cand_left < 2) {
1985 candidate[0] = INTRA_PLANAR;
1986 candidate[1] = INTRA_DC;
1987 candidate[2] = INTRA_ANGULAR_26;
1989 candidate[0] = cand_left;
1990 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1991 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1994 candidate[0] = cand_left;
1995 candidate[1] = cand_up;
1996 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1997 candidate[2] = INTRA_PLANAR;
1998 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1999 candidate[2] = INTRA_DC;
2001 candidate[2] = INTRA_ANGULAR_26;
2005 if (prev_intra_luma_pred_flag) {
2006 intra_pred_mode = candidate[lc->pu.mpm_idx];
2008 if (candidate[0] > candidate[1])
2009 FFSWAP(uint8_t, candidate[0], candidate[1]);
2010 if (candidate[0] > candidate[2])
2011 FFSWAP(uint8_t, candidate[0], candidate[2]);
2012 if (candidate[1] > candidate[2])
2013 FFSWAP(uint8_t, candidate[1], candidate[2]);
2015 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
2016 for (i = 0; i < 3; i++)
2017 if (intra_pred_mode >= candidate[i])
2021 /* write the intra prediction units into the mv array */
2024 for (i = 0; i < size_in_pus; i++) {
2025 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
2026 intra_pred_mode, size_in_pus);
2028 for (j = 0; j < size_in_pus; j++) {
2029 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag = PF_INTRA;
2033 return intra_pred_mode;
2036 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
2037 int log2_cb_size, int ct_depth)
2039 int length = (1 << log2_cb_size) >> s->ps.sps->log2_min_cb_size;
2040 int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
2041 int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
2044 for (y = 0; y < length; y++)
2045 memset(&s->tab_ct_depth[(y_cb + y) * s->ps.sps->min_cb_width + x_cb],
2049 static const uint8_t tab_mode_idx[] = {
2050 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
2051 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
2053 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
2056 HEVCLocalContext *lc = s->HEVClc;
2057 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
2058 uint8_t prev_intra_luma_pred_flag[4];
2059 int split = lc->cu.part_mode == PART_NxN;
2060 int pb_size = (1 << log2_cb_size) >> split;
2061 int side = split + 1;
2065 for (i = 0; i < side; i++)
2066 for (j = 0; j < side; j++)
2067 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
2069 for (i = 0; i < side; i++) {
2070 for (j = 0; j < side; j++) {
2071 if (prev_intra_luma_pred_flag[2 * i + j])
2072 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
2074 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
2076 lc->pu.intra_pred_mode[2 * i + j] =
2077 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
2078 prev_intra_luma_pred_flag[2 * i + j]);
2082 if (s->ps.sps->chroma_format_idc == 3) {
2083 for (i = 0; i < side; i++) {
2084 for (j = 0; j < side; j++) {
2085 lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
2086 if (chroma_mode != 4) {
2087 if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode])
2088 lc->pu.intra_pred_mode_c[2 * i + j] = 34;
2090 lc->pu.intra_pred_mode_c[2 * i + j] = intra_chroma_table[chroma_mode];
2092 lc->pu.intra_pred_mode_c[2 * i + j] = lc->pu.intra_pred_mode[2 * i + j];
2096 } else if (s->ps.sps->chroma_format_idc == 2) {
2098 lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
2099 if (chroma_mode != 4) {
2100 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
2103 mode_idx = intra_chroma_table[chroma_mode];
2105 mode_idx = lc->pu.intra_pred_mode[0];
2107 lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx];
2108 } else if (s->ps.sps->chroma_format_idc != 0) {
2109 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
2110 if (chroma_mode != 4) {
2111 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
2112 lc->pu.intra_pred_mode_c[0] = 34;
2114 lc->pu.intra_pred_mode_c[0] = intra_chroma_table[chroma_mode];
2116 lc->pu.intra_pred_mode_c[0] = lc->pu.intra_pred_mode[0];
2121 static void intra_prediction_unit_default_value(HEVCContext *s,
2125 HEVCLocalContext *lc = s->HEVClc;
2126 int pb_size = 1 << log2_cb_size;
2127 int size_in_pus = pb_size >> s->ps.sps->log2_min_pu_size;
2128 int min_pu_width = s->ps.sps->min_pu_width;
2129 MvField *tab_mvf = s->ref->tab_mvf;
2130 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
2131 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
2134 if (size_in_pus == 0)
2136 for (j = 0; j < size_in_pus; j++)
2137 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
2138 if (lc->cu.pred_mode == MODE_INTRA)
2139 for (j = 0; j < size_in_pus; j++)
2140 for (k = 0; k < size_in_pus; k++)
2141 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].pred_flag = PF_INTRA;
2144 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
2146 int cb_size = 1 << log2_cb_size;
2147 HEVCLocalContext *lc = s->HEVClc;
2148 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
2149 int length = cb_size >> log2_min_cb_size;
2150 int min_cb_width = s->ps.sps->min_cb_width;
2151 int x_cb = x0 >> log2_min_cb_size;
2152 int y_cb = y0 >> log2_min_cb_size;
2153 int idx = log2_cb_size - 2;
2154 int qp_block_mask = (1<<(s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2159 lc->cu.pred_mode = MODE_INTRA;
2160 lc->cu.part_mode = PART_2Nx2N;
2161 lc->cu.intra_split_flag = 0;
2163 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
2164 for (x = 0; x < 4; x++)
2165 lc->pu.intra_pred_mode[x] = 1;
2166 if (s->ps.pps->transquant_bypass_enable_flag) {
2167 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
2168 if (lc->cu.cu_transquant_bypass_flag)
2169 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2171 lc->cu.cu_transquant_bypass_flag = 0;
2173 if (s->sh.slice_type != HEVC_SLICE_I) {
2174 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
2176 x = y_cb * min_cb_width + x_cb;
2177 for (y = 0; y < length; y++) {
2178 memset(&s->skip_flag[x], skip_flag, length);
2181 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2183 x = y_cb * min_cb_width + x_cb;
2184 for (y = 0; y < length; y++) {
2185 memset(&s->skip_flag[x], 0, length);
2190 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2191 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2192 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2194 if (!s->sh.disable_deblocking_filter_flag)
2195 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2199 if (s->sh.slice_type != HEVC_SLICE_I)
2200 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2201 if (lc->cu.pred_mode != MODE_INTRA ||
2202 log2_cb_size == s->ps.sps->log2_min_cb_size) {
2203 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2204 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2205 lc->cu.pred_mode == MODE_INTRA;
2208 if (lc->cu.pred_mode == MODE_INTRA) {
2209 if (lc->cu.part_mode == PART_2Nx2N && s->ps.sps->pcm_enabled_flag &&
2210 log2_cb_size >= s->ps.sps->pcm.log2_min_pcm_cb_size &&
2211 log2_cb_size <= s->ps.sps->pcm.log2_max_pcm_cb_size) {
2212 pcm_flag = ff_hevc_pcm_flag_decode(s);
2215 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2216 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2217 if (s->ps.sps->pcm.loop_filter_disable_flag)
2218 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2223 intra_prediction_unit(s, x0, y0, log2_cb_size);
2226 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2227 switch (lc->cu.part_mode) {
2229 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2232 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0, idx);
2233 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2236 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2237 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2240 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0, idx);
2241 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2244 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2245 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2248 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0, idx - 2);
2249 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2252 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2253 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2256 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2257 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2258 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2259 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2265 int rqt_root_cbf = 1;
2267 if (lc->cu.pred_mode != MODE_INTRA &&
2268 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2269 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2272 const static int cbf[2] = { 0 };
2273 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2274 s->ps.sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2275 s->ps.sps->max_transform_hierarchy_depth_inter;
2276 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2278 log2_cb_size, 0, 0, cbf, cbf);
2282 if (!s->sh.disable_deblocking_filter_flag)
2283 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2288 if (s->ps.pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2289 ff_hevc_set_qPy(s, x0, y0, log2_cb_size);
2291 x = y_cb * min_cb_width + x_cb;
2292 for (y = 0; y < length; y++) {
2293 memset(&s->qp_y_tab[x], lc->qp_y, length);
2297 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2298 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2299 lc->qPy_pred = lc->qp_y;
2302 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct_depth);
2307 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2308 int log2_cb_size, int cb_depth)
2310 HEVCLocalContext *lc = s->HEVClc;
2311 const int cb_size = 1 << log2_cb_size;
2315 lc->ct_depth = cb_depth;
2316 if (x0 + cb_size <= s->ps.sps->width &&
2317 y0 + cb_size <= s->ps.sps->height &&
2318 log2_cb_size > s->ps.sps->log2_min_cb_size) {
2319 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2321 split_cu = (log2_cb_size > s->ps.sps->log2_min_cb_size);
2323 if (s->ps.pps->cu_qp_delta_enabled_flag &&
2324 log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth) {
2325 lc->tu.is_cu_qp_delta_coded = 0;
2326 lc->tu.cu_qp_delta = 0;
2329 if (s->sh.cu_chroma_qp_offset_enabled_flag &&
2330 log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_chroma_qp_offset_depth) {
2331 lc->tu.is_cu_chroma_qp_offset_coded = 0;
2335 int qp_block_mask = (1<<(s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2336 const int cb_size_split = cb_size >> 1;
2337 const int x1 = x0 + cb_size_split;
2338 const int y1 = y0 + cb_size_split;
2342 more_data = hls_coding_quadtree(s, x0, y0, log2_cb_size - 1, cb_depth + 1);
2346 if (more_data && x1 < s->ps.sps->width) {
2347 more_data = hls_coding_quadtree(s, x1, y0, log2_cb_size - 1, cb_depth + 1);
2351 if (more_data && y1 < s->ps.sps->height) {
2352 more_data = hls_coding_quadtree(s, x0, y1, log2_cb_size - 1, cb_depth + 1);
2356 if (more_data && x1 < s->ps.sps->width &&
2357 y1 < s->ps.sps->height) {
2358 more_data = hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1);
2363 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2364 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2365 lc->qPy_pred = lc->qp_y;
2368 return ((x1 + cb_size_split) < s->ps.sps->width ||
2369 (y1 + cb_size_split) < s->ps.sps->height);
2373 ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2376 if ((!((x0 + cb_size) %
2377 (1 << (s->ps.sps->log2_ctb_size))) ||
2378 (x0 + cb_size >= s->ps.sps->width)) &&
2380 (1 << (s->ps.sps->log2_ctb_size))) ||
2381 (y0 + cb_size >= s->ps.sps->height))) {
2382 int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s);
2383 return !end_of_slice_flag;
2392 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2395 HEVCLocalContext *lc = s->HEVClc;
2396 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2397 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2398 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2400 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2402 if (s->ps.pps->entropy_coding_sync_enabled_flag) {
2403 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2404 lc->first_qp_group = 1;
2405 lc->end_of_tiles_x = s->ps.sps->width;
2406 } else if (s->ps.pps->tiles_enabled_flag) {
2407 if (ctb_addr_ts && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
2408 int idxX = s->ps.pps->col_idxX[x_ctb >> s->ps.sps->log2_ctb_size];
2409 lc->end_of_tiles_x = x_ctb + (s->ps.pps->column_width[idxX] << s->ps.sps->log2_ctb_size);
2410 lc->first_qp_group = 1;
2413 lc->end_of_tiles_x = s->ps.sps->width;
2416 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->ps.sps->height);
2418 lc->boundary_flags = 0;
2419 if (s->ps.pps->tiles_enabled_flag) {
2420 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]])
2421 lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2422 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2423 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2424 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]])
2425 lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2426 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->ps.sps->ctb_width])
2427 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2429 if (ctb_addr_in_slice <= 0)
2430 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2431 if (ctb_addr_in_slice < s->ps.sps->ctb_width)
2432 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2435 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2436 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->ps.sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2437 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]]));
2438 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]]));
2441 static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
2443 HEVCContext *s = avctxt->priv_data;
2444 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2448 int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2451 if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) {
2452 av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n");
2453 return AVERROR_INVALIDDATA;
2456 if (s->sh.dependent_slice_segment_flag) {
2457 int prev_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2458 if (s->tab_slice_address[prev_rs] != s->sh.slice_addr) {
2459 av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n");
2460 return AVERROR_INVALIDDATA;
2464 while (more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2465 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2467 x_ctb = (ctb_addr_rs % ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2468 y_ctb = (ctb_addr_rs / ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2469 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2471 ret = ff_hevc_cabac_init(s, ctb_addr_ts);
2473 s->tab_slice_address[ctb_addr_rs] = -1;
2477 hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2479 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2480 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2481 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2483 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2484 if (more_data < 0) {
2485 s->tab_slice_address[ctb_addr_rs] = -1;
2491 ff_hevc_save_states(s, ctb_addr_ts);
2492 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2495 if (x_ctb + ctb_size >= s->ps.sps->width &&
2496 y_ctb + ctb_size >= s->ps.sps->height)
2497 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2502 static int hls_slice_data(HEVCContext *s)
2510 s->avctx->execute(s->avctx, hls_decode_entry, arg, ret , 1, sizeof(int));
2513 static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int job, int self_id)
2515 HEVCContext *s1 = avctxt->priv_data, *s;
2516 HEVCLocalContext *lc;
2517 int ctb_size = 1<< s1->ps.sps->log2_ctb_size;
2519 int *ctb_row_p = input_ctb_row;
2520 int ctb_row = ctb_row_p[job];
2521 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);
2522 int ctb_addr_ts = s1->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2523 int thread = ctb_row % s1->threads_number;
2526 s = s1->sList[self_id];
2530 ret = init_get_bits8(&lc->gb, s->data + s->sh.offset[ctb_row - 1], s->sh.size[ctb_row - 1]);
2533 ff_init_cabac_decoder(&lc->cc, s->data + s->sh.offset[(ctb_row)-1], s->sh.size[ctb_row - 1]);
2536 while(more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2537 int x_ctb = (ctb_addr_rs % s->ps.sps->ctb_width) << s->ps.sps->log2_ctb_size;
2538 int y_ctb = (ctb_addr_rs / s->ps.sps->ctb_width) << s->ps.sps->log2_ctb_size;
2540 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2542 ff_thread_await_progress2(s->avctx, ctb_row, thread, SHIFT_CTB_WPP);
2544 if (atomic_load(&s1->wpp_err)) {
2545 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2549 ret = ff_hevc_cabac_init(s, ctb_addr_ts);
2552 hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2553 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2555 if (more_data < 0) {
2562 ff_hevc_save_states(s, ctb_addr_ts);
2563 ff_thread_report_progress2(s->avctx, ctb_row, thread, 1);
2564 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2566 if (!more_data && (x_ctb+ctb_size) < s->ps.sps->width && ctb_row != s->sh.num_entry_point_offsets) {
2567 atomic_store(&s1->wpp_err, 1);
2568 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2572 if ((x_ctb+ctb_size) >= s->ps.sps->width && (y_ctb+ctb_size) >= s->ps.sps->height ) {
2573 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2574 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2577 ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2580 if(x_ctb >= s->ps.sps->width) {
2584 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2588 s->tab_slice_address[ctb_addr_rs] = -1;
2589 atomic_store(&s1->wpp_err, 1);
2590 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2594 static int hls_slice_data_wpp(HEVCContext *s, const H2645NAL *nal)
2596 const uint8_t *data = nal->data;
2597 int length = nal->size;
2598 HEVCLocalContext *lc = s->HEVClc;
2599 int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2600 int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2602 int64_t startheader, cmpt = 0;
2608 return AVERROR(ENOMEM);
2611 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) {
2612 av_log(s->avctx, AV_LOG_ERROR, "WPP ctb addresses are wrong (%d %d %d %d)\n",
2613 s->sh.slice_ctb_addr_rs, s->sh.num_entry_point_offsets,
2614 s->ps.sps->ctb_width, s->ps.sps->ctb_height
2616 res = AVERROR_INVALIDDATA;
2620 ff_alloc_entries(s->avctx, s->sh.num_entry_point_offsets + 1);
2623 for (i = 1; i < s->threads_number; i++) {
2624 s->sList[i] = av_malloc(sizeof(HEVCContext));
2625 memcpy(s->sList[i], s, sizeof(HEVCContext));
2626 s->HEVClcList[i] = av_mallocz(sizeof(HEVCLocalContext));
2627 s->sList[i]->HEVClc = s->HEVClcList[i];
2631 offset = (lc->gb.index >> 3);
2633 for (j = 0, cmpt = 0, startheader = offset + s->sh.entry_point_offset[0]; j < nal->skipped_bytes; j++) {
2634 if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) {
2640 for (i = 1; i < s->sh.num_entry_point_offsets; i++) {
2641 offset += (s->sh.entry_point_offset[i - 1] - cmpt);
2642 for (j = 0, cmpt = 0, startheader = offset
2643 + s->sh.entry_point_offset[i]; j < nal->skipped_bytes; j++) {
2644 if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) {
2649 s->sh.size[i - 1] = s->sh.entry_point_offset[i] - cmpt;
2650 s->sh.offset[i - 1] = offset;
2653 if (s->sh.num_entry_point_offsets != 0) {
2654 offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt;
2655 if (length < offset) {
2656 av_log(s->avctx, AV_LOG_ERROR, "entry_point_offset table is corrupted\n");
2657 res = AVERROR_INVALIDDATA;
2660 s->sh.size[s->sh.num_entry_point_offsets - 1] = length - offset;
2661 s->sh.offset[s->sh.num_entry_point_offsets - 1] = offset;
2666 for (i = 1; i < s->threads_number; i++) {
2667 s->sList[i]->HEVClc->first_qp_group = 1;
2668 s->sList[i]->HEVClc->qp_y = s->sList[0]->HEVClc->qp_y;
2669 memcpy(s->sList[i], s, sizeof(HEVCContext));
2670 s->sList[i]->HEVClc = s->HEVClcList[i];
2673 atomic_store(&s->wpp_err, 0);
2674 ff_reset_entries(s->avctx);
2676 for (i = 0; i <= s->sh.num_entry_point_offsets; i++) {
2681 if (s->ps.pps->entropy_coding_sync_enabled_flag)
2682 s->avctx->execute2(s->avctx, hls_decode_entry_wpp, arg, ret, s->sh.num_entry_point_offsets + 1);
2684 for (i = 0; i <= s->sh.num_entry_point_offsets; i++)
2692 static int set_side_data(HEVCContext *s)
2694 AVFrame *out = s->ref->frame;
2696 if (s->sei.frame_packing.present &&
2697 s->sei.frame_packing.arrangement_type >= 3 &&
2698 s->sei.frame_packing.arrangement_type <= 5 &&
2699 s->sei.frame_packing.content_interpretation_type > 0 &&
2700 s->sei.frame_packing.content_interpretation_type < 3) {
2701 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2703 return AVERROR(ENOMEM);
2705 switch (s->sei.frame_packing.arrangement_type) {
2707 if (s->sei.frame_packing.quincunx_subsampling)
2708 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2710 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2713 stereo->type = AV_STEREO3D_TOPBOTTOM;
2716 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2720 if (s->sei.frame_packing.content_interpretation_type == 2)
2721 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2723 if (s->sei.frame_packing.arrangement_type == 5) {
2724 if (s->sei.frame_packing.current_frame_is_frame0_flag)
2725 stereo->view = AV_STEREO3D_VIEW_LEFT;
2727 stereo->view = AV_STEREO3D_VIEW_RIGHT;
2731 if (s->sei.display_orientation.present &&
2732 (s->sei.display_orientation.anticlockwise_rotation ||
2733 s->sei.display_orientation.hflip || s->sei.display_orientation.vflip)) {
2734 double angle = s->sei.display_orientation.anticlockwise_rotation * 360 / (double) (1 << 16);
2735 AVFrameSideData *rotation = av_frame_new_side_data(out,
2736 AV_FRAME_DATA_DISPLAYMATRIX,
2737 sizeof(int32_t) * 9);
2739 return AVERROR(ENOMEM);
2741 av_display_rotation_set((int32_t *)rotation->data, angle);
2742 av_display_matrix_flip((int32_t *)rotation->data,
2743 s->sei.display_orientation.hflip,
2744 s->sei.display_orientation.vflip);
2747 // Decrement the mastering display flag when IRAP frame has no_rasl_output_flag=1
2748 // so the side data persists for the entire coded video sequence.
2749 if (s->sei.mastering_display.present > 0 &&
2750 IS_IRAP(s) && s->no_rasl_output_flag) {
2751 s->sei.mastering_display.present--;
2753 if (s->sei.mastering_display.present) {
2754 // HEVC uses a g,b,r ordering, which we convert to a more natural r,g,b
2755 const int mapping[3] = {2, 0, 1};
2756 const int chroma_den = 50000;
2757 const int luma_den = 10000;
2759 AVMasteringDisplayMetadata *metadata =
2760 av_mastering_display_metadata_create_side_data(out);
2762 return AVERROR(ENOMEM);
2764 for (i = 0; i < 3; i++) {
2765 const int j = mapping[i];
2766 metadata->display_primaries[i][0].num = s->sei.mastering_display.display_primaries[j][0];
2767 metadata->display_primaries[i][0].den = chroma_den;
2768 metadata->display_primaries[i][1].num = s->sei.mastering_display.display_primaries[j][1];
2769 metadata->display_primaries[i][1].den = chroma_den;
2771 metadata->white_point[0].num = s->sei.mastering_display.white_point[0];
2772 metadata->white_point[0].den = chroma_den;
2773 metadata->white_point[1].num = s->sei.mastering_display.white_point[1];
2774 metadata->white_point[1].den = chroma_den;
2776 metadata->max_luminance.num = s->sei.mastering_display.max_luminance;
2777 metadata->max_luminance.den = luma_den;
2778 metadata->min_luminance.num = s->sei.mastering_display.min_luminance;
2779 metadata->min_luminance.den = luma_den;
2780 metadata->has_luminance = 1;
2781 metadata->has_primaries = 1;
2783 av_log(s->avctx, AV_LOG_DEBUG, "Mastering Display Metadata:\n");
2784 av_log(s->avctx, AV_LOG_DEBUG,
2785 "r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f)\n",
2786 av_q2d(metadata->display_primaries[0][0]),
2787 av_q2d(metadata->display_primaries[0][1]),
2788 av_q2d(metadata->display_primaries[1][0]),
2789 av_q2d(metadata->display_primaries[1][1]),
2790 av_q2d(metadata->display_primaries[2][0]),
2791 av_q2d(metadata->display_primaries[2][1]),
2792 av_q2d(metadata->white_point[0]), av_q2d(metadata->white_point[1]));
2793 av_log(s->avctx, AV_LOG_DEBUG,
2794 "min_luminance=%f, max_luminance=%f\n",
2795 av_q2d(metadata->min_luminance), av_q2d(metadata->max_luminance));
2797 // Decrement the mastering display flag when IRAP frame has no_rasl_output_flag=1
2798 // so the side data persists for the entire coded video sequence.
2799 if (s->sei.content_light.present > 0 &&
2800 IS_IRAP(s) && s->no_rasl_output_flag) {
2801 s->sei.content_light.present--;
2803 if (s->sei.content_light.present) {
2804 AVContentLightMetadata *metadata =
2805 av_content_light_metadata_create_side_data(out);
2807 return AVERROR(ENOMEM);
2808 metadata->MaxCLL = s->sei.content_light.max_content_light_level;
2809 metadata->MaxFALL = s->sei.content_light.max_pic_average_light_level;
2811 av_log(s->avctx, AV_LOG_DEBUG, "Content Light Level Metadata:\n");
2812 av_log(s->avctx, AV_LOG_DEBUG, "MaxCLL=%d, MaxFALL=%d\n",
2813 metadata->MaxCLL, metadata->MaxFALL);
2816 if (s->sei.a53_caption.buf_ref) {
2817 HEVCSEIA53Caption *a53 = &s->sei.a53_caption;
2819 AVFrameSideData *sd = av_frame_new_side_data_from_buf(out, AV_FRAME_DATA_A53_CC, a53->buf_ref);
2821 av_buffer_unref(&a53->buf_ref);
2822 a53->buf_ref = NULL;
2825 for (int i = 0; i < s->sei.unregistered.nb_buf_ref; i++) {
2826 HEVCSEIUnregistered *unreg = &s->sei.unregistered;
2828 if (unreg->buf_ref[i]) {
2829 AVFrameSideData *sd = av_frame_new_side_data_from_buf(out,
2830 AV_FRAME_DATA_SEI_UNREGISTERED,
2833 av_buffer_unref(&unreg->buf_ref[i]);
2834 unreg->buf_ref[i] = NULL;
2837 s->sei.unregistered.nb_buf_ref = 0;
2839 if (s->sei.timecode.present) {
2841 char tcbuf[AV_TIMECODE_STR_SIZE];
2842 AVFrameSideData *tcside = av_frame_new_side_data(out, AV_FRAME_DATA_S12M_TIMECODE,
2843 sizeof(uint32_t) * 4);
2845 return AVERROR(ENOMEM);
2847 tc_sd = (uint32_t*)tcside->data;
2848 tc_sd[0] = s->sei.timecode.num_clock_ts;
2850 for (int i = 0; i < tc_sd[0]; i++) {
2851 int drop = s->sei.timecode.cnt_dropped_flag[i];
2852 int hh = s->sei.timecode.hours_value[i];
2853 int mm = s->sei.timecode.minutes_value[i];
2854 int ss = s->sei.timecode.seconds_value[i];
2855 int ff = s->sei.timecode.n_frames[i];
2857 tc_sd[i + 1] = av_timecode_get_smpte(s->avctx->framerate, drop, hh, mm, ss, ff);
2858 av_timecode_make_smpte_tc_string2(tcbuf, s->avctx->framerate, tc_sd[i + 1], 0, 0);
2859 av_dict_set(&out->metadata, "timecode", tcbuf, 0);
2862 s->sei.timecode.num_clock_ts = 0;
2868 static int hevc_frame_start(HEVCContext *s)
2870 HEVCLocalContext *lc = s->HEVClc;
2871 int pic_size_in_ctb = ((s->ps.sps->width >> s->ps.sps->log2_min_cb_size) + 1) *
2872 ((s->ps.sps->height >> s->ps.sps->log2_min_cb_size) + 1);
2875 memset(s->horizontal_bs, 0, s->bs_width * s->bs_height);
2876 memset(s->vertical_bs, 0, s->bs_width * s->bs_height);
2877 memset(s->cbf_luma, 0, s->ps.sps->min_tb_width * s->ps.sps->min_tb_height);
2878 memset(s->is_pcm, 0, (s->ps.sps->min_pu_width + 1) * (s->ps.sps->min_pu_height + 1));
2879 memset(s->tab_slice_address, -1, pic_size_in_ctb * sizeof(*s->tab_slice_address));
2882 s->first_nal_type = s->nal_unit_type;
2884 s->no_rasl_output_flag = IS_IDR(s) || IS_BLA(s) || (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos);
2886 if (s->ps.pps->tiles_enabled_flag)
2887 lc->end_of_tiles_x = s->ps.pps->column_width[0] << s->ps.sps->log2_ctb_size;
2889 ret = ff_hevc_set_new_ref(s, &s->frame, s->poc);
2893 ret = ff_hevc_frame_rps(s);
2895 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2899 s->ref->frame->key_frame = IS_IRAP(s);
2901 ret = set_side_data(s);
2905 s->frame->pict_type = 3 - s->sh.slice_type;
2908 ff_hevc_bump_frame(s);
2910 av_frame_unref(s->output_frame);
2911 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2915 if (!s->avctx->hwaccel)
2916 ff_thread_finish_setup(s->avctx);
2922 ff_hevc_unref_frame(s, s->ref, ~0);
2927 static int decode_nal_unit(HEVCContext *s, const H2645NAL *nal)
2929 HEVCLocalContext *lc = s->HEVClc;
2930 GetBitContext *gb = &lc->gb;
2931 int ctb_addr_ts, ret;
2934 s->nal_unit_type = nal->type;
2935 s->temporal_id = nal->temporal_id;
2937 switch (s->nal_unit_type) {
2939 if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2940 ret = s->avctx->hwaccel->decode_params(s->avctx,
2947 ret = ff_hevc_decode_nal_vps(gb, s->avctx, &s->ps);
2952 if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2953 ret = s->avctx->hwaccel->decode_params(s->avctx,
2960 ret = ff_hevc_decode_nal_sps(gb, s->avctx, &s->ps,
2961 s->apply_defdispwin);
2966 if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2967 ret = s->avctx->hwaccel->decode_params(s->avctx,
2974 ret = ff_hevc_decode_nal_pps(gb, s->avctx, &s->ps);
2978 case HEVC_NAL_SEI_PREFIX:
2979 case HEVC_NAL_SEI_SUFFIX:
2980 if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2981 ret = s->avctx->hwaccel->decode_params(s->avctx,
2988 ret = ff_hevc_decode_nal_sei(gb, s->avctx, &s->sei, &s->ps, s->nal_unit_type);
2992 case HEVC_NAL_TRAIL_R:
2993 case HEVC_NAL_TRAIL_N:
2994 case HEVC_NAL_TSA_N:
2995 case HEVC_NAL_TSA_R:
2996 case HEVC_NAL_STSA_N:
2997 case HEVC_NAL_STSA_R:
2998 case HEVC_NAL_BLA_W_LP:
2999 case HEVC_NAL_BLA_W_RADL:
3000 case HEVC_NAL_BLA_N_LP:
3001 case HEVC_NAL_IDR_W_RADL:
3002 case HEVC_NAL_IDR_N_LP:
3003 case HEVC_NAL_CRA_NUT:
3004 case HEVC_NAL_RADL_N:
3005 case HEVC_NAL_RADL_R:
3006 case HEVC_NAL_RASL_N:
3007 case HEVC_NAL_RASL_R:
3008 ret = hls_slice_header(s);
3012 ret = AVERROR_INVALIDDATA;
3018 (s->avctx->skip_frame >= AVDISCARD_BIDIR && s->sh.slice_type == HEVC_SLICE_B) ||
3019 (s->avctx->skip_frame >= AVDISCARD_NONINTRA && s->sh.slice_type != HEVC_SLICE_I) ||
3020 (s->avctx->skip_frame >= AVDISCARD_NONKEY && !IS_IRAP(s))) {
3024 if (s->sh.first_slice_in_pic_flag) {
3025 if (s->max_ra == INT_MAX) {
3026 if (s->nal_unit_type == HEVC_NAL_CRA_NUT || IS_BLA(s)) {
3030 s->max_ra = INT_MIN;
3034 if ((s->nal_unit_type == HEVC_NAL_RASL_R || s->nal_unit_type == HEVC_NAL_RASL_N) &&
3035 s->poc <= s->max_ra) {
3039 if (s->nal_unit_type == HEVC_NAL_RASL_R && s->poc > s->max_ra)
3040 s->max_ra = INT_MIN;
3044 ret = hevc_frame_start(s);
3047 } else if (!s->ref) {
3048 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
3052 if (s->nal_unit_type != s->first_nal_type) {
3053 av_log(s->avctx, AV_LOG_ERROR,
3054 "Non-matching NAL types of the VCL NALUs: %d %d\n",
3055 s->first_nal_type, s->nal_unit_type);
3056 return AVERROR_INVALIDDATA;
3059 if (!s->sh.dependent_slice_segment_flag &&
3060 s->sh.slice_type != HEVC_SLICE_I) {
3061 ret = ff_hevc_slice_rpl(s);
3063 av_log(s->avctx, AV_LOG_WARNING,
3064 "Error constructing the reference lists for the current slice.\n");
3069 if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) {
3070 ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0);
3075 if (s->avctx->hwaccel) {
3076 ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size);
3080 if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
3081 ctb_addr_ts = hls_slice_data_wpp(s, nal);
3083 ctb_addr_ts = hls_slice_data(s);
3084 if (ctb_addr_ts >= (s->ps.sps->ctb_width * s->ps.sps->ctb_height)) {
3088 if (ctb_addr_ts < 0) {
3094 case HEVC_NAL_EOS_NUT:
3095 case HEVC_NAL_EOB_NUT:
3096 s->seq_decode = (s->seq_decode + 1) & 0xff;
3097 s->max_ra = INT_MAX;
3100 case HEVC_NAL_FD_NUT:
3103 av_log(s->avctx, AV_LOG_INFO,
3104 "Skipping NAL unit %d\n", s->nal_unit_type);
3109 if (s->avctx->err_recognition & AV_EF_EXPLODE)
3114 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
3117 int eos_at_start = 1;
3120 s->last_eos = s->eos;
3124 /* split the input packet into NAL units, so we know the upper bound on the
3125 * number of slices in the frame */
3126 ret = ff_h2645_packet_split(&s->pkt, buf, length, s->avctx, s->is_nalff,
3127 s->nal_length_size, s->avctx->codec_id, 1, 0);
3129 av_log(s->avctx, AV_LOG_ERROR,
3130 "Error splitting the input into NAL units.\n");
3134 for (i = 0; i < s->pkt.nb_nals; i++) {
3135 if (s->pkt.nals[i].type == HEVC_NAL_EOB_NUT ||
3136 s->pkt.nals[i].type == HEVC_NAL_EOS_NUT) {
3147 /* decode the NAL units */
3148 for (i = 0; i < s->pkt.nb_nals; i++) {
3149 H2645NAL *nal = &s->pkt.nals[i];
3151 if (s->avctx->skip_frame >= AVDISCARD_ALL ||
3152 (s->avctx->skip_frame >= AVDISCARD_NONREF
3153 && ff_hevc_nal_is_nonref(nal->type)) || nal->nuh_layer_id > 0)
3156 ret = decode_nal_unit(s, nal);
3157 if (ret >= 0 && s->overlap > 2)
3158 ret = AVERROR_INVALIDDATA;
3160 av_log(s->avctx, AV_LOG_WARNING,
3161 "Error parsing NAL unit #%d.\n", i);
3167 if (s->ref && s->threads_type == FF_THREAD_FRAME)
3168 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
3173 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
3176 for (i = 0; i < 16; i++)
3177 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
3180 static int verify_md5(HEVCContext *s, AVFrame *frame)
3182 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
3187 return AVERROR(EINVAL);
3189 pixel_shift = desc->comp[0].depth > 8;
3191 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
3194 /* the checksums are LE, so we have to byteswap for >8bpp formats
3197 if (pixel_shift && !s->checksum_buf) {
3198 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
3199 FFMAX3(frame->linesize[0], frame->linesize[1],
3200 frame->linesize[2]));
3201 if (!s->checksum_buf)
3202 return AVERROR(ENOMEM);
3206 for (i = 0; frame->data[i]; i++) {
3207 int width = s->avctx->coded_width;
3208 int height = s->avctx->coded_height;
3209 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
3210 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
3213 av_md5_init(s->md5_ctx);
3214 for (j = 0; j < h; j++) {
3215 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
3218 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
3219 (const uint16_t *) src, w);
3220 src = s->checksum_buf;
3223 av_md5_update(s->md5_ctx, src, w << pixel_shift);
3225 av_md5_final(s->md5_ctx, md5);
3227 if (!memcmp(md5, s->sei.picture_hash.md5[i], 16)) {
3228 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
3229 print_md5(s->avctx, AV_LOG_DEBUG, md5);
3230 av_log (s->avctx, AV_LOG_DEBUG, "; ");
3232 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
3233 print_md5(s->avctx, AV_LOG_ERROR, md5);
3234 av_log (s->avctx, AV_LOG_ERROR, " != ");
3235 print_md5(s->avctx, AV_LOG_ERROR, s->sei.picture_hash.md5[i]);
3236 av_log (s->avctx, AV_LOG_ERROR, "\n");
3237 return AVERROR_INVALIDDATA;
3241 av_log(s->avctx, AV_LOG_DEBUG, "\n");
3246 static int hevc_decode_extradata(HEVCContext *s, uint8_t *buf, int length, int first)
3250 ret = ff_hevc_decode_extradata(buf, length, &s->ps, &s->sei, &s->is_nalff,
3251 &s->nal_length_size, s->avctx->err_recognition,
3252 s->apply_defdispwin, s->avctx);
3256 /* export stream parameters from the first SPS */
3257 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3258 if (first && s->ps.sps_list[i]) {
3259 const HEVCSPS *sps = (const HEVCSPS*)s->ps.sps_list[i]->data;
3260 export_stream_params(s, sps);
3265 /* export stream parameters from SEI */
3266 ret = export_stream_params_from_sei(s);
3273 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
3277 int new_extradata_size;
3278 uint8_t *new_extradata;
3279 HEVCContext *s = avctx->priv_data;
3282 ret = ff_hevc_output_frame(s, data, 1);
3290 new_extradata = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,
3291 &new_extradata_size);
3292 if (new_extradata && new_extradata_size > 0) {
3293 ret = hevc_decode_extradata(s, new_extradata, new_extradata_size, 0);
3299 ret = decode_nal_units(s, avpkt->data, avpkt->size);
3303 if (avctx->hwaccel) {
3304 if (s->ref && (ret = avctx->hwaccel->end_frame(avctx)) < 0) {
3305 av_log(avctx, AV_LOG_ERROR,
3306 "hardware accelerator failed to decode picture\n");
3307 ff_hevc_unref_frame(s, s->ref, ~0);
3311 /* verify the SEI checksum */
3312 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
3313 s->sei.picture_hash.is_md5) {
3314 ret = verify_md5(s, s->ref->frame);
3315 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
3316 ff_hevc_unref_frame(s, s->ref, ~0);
3321 s->sei.picture_hash.is_md5 = 0;
3323 if (s->is_decoded) {
3324 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
3328 if (s->output_frame->buf[0]) {
3329 av_frame_move_ref(data, s->output_frame);
3336 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
3340 ret = ff_thread_ref_frame(&dst->tf, &src->tf);
3344 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
3345 if (!dst->tab_mvf_buf)
3347 dst->tab_mvf = src->tab_mvf;
3349 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
3350 if (!dst->rpl_tab_buf)
3352 dst->rpl_tab = src->rpl_tab;
3354 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
3358 dst->poc = src->poc;
3359 dst->ctb_count = src->ctb_count;
3360 dst->flags = src->flags;
3361 dst->sequence = src->sequence;
3363 if (src->hwaccel_picture_private) {
3364 dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
3365 if (!dst->hwaccel_priv_buf)
3367 dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
3372 ff_hevc_unref_frame(s, dst, ~0);
3373 return AVERROR(ENOMEM);
3376 static av_cold int hevc_decode_free(AVCodecContext *avctx)
3378 HEVCContext *s = avctx->priv_data;
3383 av_freep(&s->md5_ctx);
3385 av_freep(&s->cabac_state);
3387 for (i = 0; i < 3; i++) {
3388 av_freep(&s->sao_pixel_buffer_h[i]);
3389 av_freep(&s->sao_pixel_buffer_v[i]);
3391 av_frame_free(&s->output_frame);
3393 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3394 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3395 av_frame_free(&s->DPB[i].frame);
3398 ff_hevc_ps_uninit(&s->ps);
3400 av_freep(&s->sh.entry_point_offset);
3401 av_freep(&s->sh.offset);
3402 av_freep(&s->sh.size);
3404 for (i = 1; i < s->threads_number; i++) {
3405 HEVCLocalContext *lc = s->HEVClcList[i];
3407 av_freep(&s->HEVClcList[i]);
3408 av_freep(&s->sList[i]);
3411 if (s->HEVClc == s->HEVClcList[0])
3413 av_freep(&s->HEVClcList[0]);
3415 ff_h2645_packet_uninit(&s->pkt);
3417 ff_hevc_reset_sei(&s->sei);
3422 static av_cold int hevc_init_context(AVCodecContext *avctx)
3424 HEVCContext *s = avctx->priv_data;
3429 s->HEVClc = av_mallocz(sizeof(HEVCLocalContext));
3432 s->HEVClcList[0] = s->HEVClc;
3435 s->cabac_state = av_malloc(HEVC_CONTEXTS);
3436 if (!s->cabac_state)
3439 s->output_frame = av_frame_alloc();
3440 if (!s->output_frame)
3443 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3444 s->DPB[i].frame = av_frame_alloc();
3445 if (!s->DPB[i].frame)
3447 s->DPB[i].tf.f = s->DPB[i].frame;
3450 s->max_ra = INT_MAX;
3452 s->md5_ctx = av_md5_alloc();
3456 ff_bswapdsp_init(&s->bdsp);
3458 s->context_initialized = 1;
3461 ff_hevc_reset_sei(&s->sei);
3466 hevc_decode_free(avctx);
3467 return AVERROR(ENOMEM);
3471 static int hevc_update_thread_context(AVCodecContext *dst,
3472 const AVCodecContext *src)
3474 HEVCContext *s = dst->priv_data;
3475 HEVCContext *s0 = src->priv_data;
3478 if (!s->context_initialized) {
3479 ret = hevc_init_context(dst);
3484 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3485 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3486 if (s0->DPB[i].frame->buf[0]) {
3487 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3493 if (s->ps.sps != s0->ps.sps)
3495 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++) {
3496 ret = av_buffer_replace(&s->ps.vps_list[i], s0->ps.vps_list[i]);
3501 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3502 ret = av_buffer_replace(&s->ps.sps_list[i], s0->ps.sps_list[i]);
3507 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++) {
3508 ret = av_buffer_replace(&s->ps.pps_list[i], s0->ps.pps_list[i]);
3513 if (s->ps.sps != s0->ps.sps)
3514 if ((ret = set_sps(s, s0->ps.sps, src->pix_fmt)) < 0)
3517 s->seq_decode = s0->seq_decode;
3518 s->seq_output = s0->seq_output;
3519 s->pocTid0 = s0->pocTid0;
3520 s->max_ra = s0->max_ra;
3522 s->no_rasl_output_flag = s0->no_rasl_output_flag;
3524 s->is_nalff = s0->is_nalff;
3525 s->nal_length_size = s0->nal_length_size;
3527 s->threads_number = s0->threads_number;
3528 s->threads_type = s0->threads_type;
3531 s->seq_decode = (s->seq_decode + 1) & 0xff;
3532 s->max_ra = INT_MAX;
3535 ret = av_buffer_replace(&s->sei.a53_caption.buf_ref, s0->sei.a53_caption.buf_ref);
3539 for (i = 0; i < s->sei.unregistered.nb_buf_ref; i++)
3540 av_buffer_unref(&s->sei.unregistered.buf_ref[i]);
3541 s->sei.unregistered.nb_buf_ref = 0;
3543 if (s0->sei.unregistered.nb_buf_ref) {
3544 ret = av_reallocp_array(&s->sei.unregistered.buf_ref,
3545 s0->sei.unregistered.nb_buf_ref,
3546 sizeof(*s->sei.unregistered.buf_ref));
3550 for (i = 0; i < s0->sei.unregistered.nb_buf_ref; i++) {
3551 s->sei.unregistered.buf_ref[i] = av_buffer_ref(s0->sei.unregistered.buf_ref[i]);
3552 if (!s->sei.unregistered.buf_ref[i])
3553 return AVERROR(ENOMEM);
3554 s->sei.unregistered.nb_buf_ref++;
3558 s->sei.frame_packing = s0->sei.frame_packing;
3559 s->sei.display_orientation = s0->sei.display_orientation;
3560 s->sei.mastering_display = s0->sei.mastering_display;
3561 s->sei.content_light = s0->sei.content_light;
3562 s->sei.alternative_transfer = s0->sei.alternative_transfer;
3564 ret = export_stream_params_from_sei(s);
3572 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3574 HEVCContext *s = avctx->priv_data;
3577 ret = hevc_init_context(avctx);
3581 s->enable_parallel_tiles = 0;
3582 s->sei.picture_timing.picture_struct = 0;
3585 atomic_init(&s->wpp_err, 0);
3587 if(avctx->active_thread_type & FF_THREAD_SLICE)
3588 s->threads_number = avctx->thread_count;
3590 s->threads_number = 1;
3592 if (!avctx->internal->is_copy) {
3593 if (avctx->extradata_size > 0 && avctx->extradata) {
3594 ret = hevc_decode_extradata(s, avctx->extradata, avctx->extradata_size, 1);
3596 hevc_decode_free(avctx);
3602 if((avctx->active_thread_type & FF_THREAD_FRAME) && avctx->thread_count > 1)
3603 s->threads_type = FF_THREAD_FRAME;
3605 s->threads_type = FF_THREAD_SLICE;
3610 static void hevc_decode_flush(AVCodecContext *avctx)
3612 HEVCContext *s = avctx->priv_data;
3613 ff_hevc_flush_dpb(s);
3614 ff_hevc_reset_sei(&s->sei);
3615 s->max_ra = INT_MAX;
3619 #define OFFSET(x) offsetof(HEVCContext, x)
3620 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3622 static const AVOption options[] = {
3623 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3624 AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR },
3625 { "strict-displaywin", "stricly apply default display window size", OFFSET(apply_defdispwin),
3626 AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR },
3630 static const AVClass hevc_decoder_class = {
3631 .class_name = "HEVC decoder",
3632 .item_name = av_default_item_name,
3634 .version = LIBAVUTIL_VERSION_INT,
3637 AVCodec ff_hevc_decoder = {
3639 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3640 .type = AVMEDIA_TYPE_VIDEO,
3641 .id = AV_CODEC_ID_HEVC,
3642 .priv_data_size = sizeof(HEVCContext),
3643 .priv_class = &hevc_decoder_class,
3644 .init = hevc_decode_init,
3645 .close = hevc_decode_free,
3646 .decode = hevc_decode_frame,
3647 .flush = hevc_decode_flush,
3648 .update_thread_context = ONLY_IF_THREADS_ENABLED(hevc_update_thread_context),
3649 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
3650 AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS,
3651 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_EXPORTS_CROPPING |
3652 FF_CODEC_CAP_ALLOCATE_PROGRESS,
3653 .profiles = NULL_IF_CONFIG_SMALL(ff_hevc_profiles),
3654 .hw_configs = (const AVCodecHWConfigInternal*[]) {
3655 #if CONFIG_HEVC_DXVA2_HWACCEL
3656 HWACCEL_DXVA2(hevc),
3658 #if CONFIG_HEVC_D3D11VA_HWACCEL
3659 HWACCEL_D3D11VA(hevc),
3661 #if CONFIG_HEVC_D3D11VA2_HWACCEL
3662 HWACCEL_D3D11VA2(hevc),
3664 #if CONFIG_HEVC_NVDEC_HWACCEL
3665 HWACCEL_NVDEC(hevc),
3667 #if CONFIG_HEVC_VAAPI_HWACCEL
3668 HWACCEL_VAAPI(hevc),
3670 #if CONFIG_HEVC_VDPAU_HWACCEL
3671 HWACCEL_VDPAU(hevc),
3673 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
3674 HWACCEL_VIDEOTOOLBOX(hevc),