1/* 2 * HEVC video Decoder 3 * 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 8 * 9 * This file is part of FFmpeg. 10 * 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. 15 * 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. 20 * 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 24 */ 25 26#include "config_components.h" 27 28#include "libavutil/attributes.h" 29#include "libavutil/common.h" 30#include "libavutil/display.h" 31#include "libavutil/film_grain_params.h" 32#include "libavutil/internal.h" 33#include "libavutil/mastering_display_metadata.h" 34#include "libavutil/md5.h" 35#include "libavutil/opt.h" 36#include "libavutil/pixdesc.h" 37#include "libavutil/stereo3d.h" 38#include "libavutil/timecode.h" 39 40#include "bswapdsp.h" 41#include "bytestream.h" 42#include "cabac_functions.h" 43#include "codec_internal.h" 44#include "golomb.h" 45#include "hevc.h" 46#include "hevc_data.h" 47#include "hevc_parse.h" 48#include "hevcdec.h" 49#include "hwconfig.h" 50#include "internal.h" 51#include "profiles.h" 52#include "thread.h" 53#include "threadframe.h" 54 55static const uint8_t hevc_pel_weight[65] = { [2] = 0, [4] = 1, [6] = 2, [8] = 3, [12] = 4, [16] = 5, [24] = 6, [32] = 7, [48] = 8, [64] = 9 }; 56 57/** 58 * NOTE: Each function hls_foo correspond to the function foo in the 59 * specification (HLS stands for High Level Syntax). 60 */ 61 62/** 63 * Section 5.7 64 */ 65 66/* free everything allocated by pic_arrays_init() */ 67static void pic_arrays_free(HEVCContext *s) 68{ 69 av_freep(&s->sao); 70 av_freep(&s->deblock); 71 72 av_freep(&s->skip_flag); 73 av_freep(&s->tab_ct_depth); 74 75 av_freep(&s->tab_ipm); 76 av_freep(&s->cbf_luma); 77 av_freep(&s->is_pcm); 78 79 av_freep(&s->qp_y_tab); 80 av_freep(&s->tab_slice_address); 81 av_freep(&s->filter_slice_edges); 82 83 av_freep(&s->horizontal_bs); 84 av_freep(&s->vertical_bs); 85 86 av_freep(&s->sh.entry_point_offset); 87 av_freep(&s->sh.size); 88 av_freep(&s->sh.offset); 89 90 av_buffer_pool_uninit(&s->tab_mvf_pool); 91 av_buffer_pool_uninit(&s->rpl_tab_pool); 92} 93 94/* allocate arrays that depend on frame dimensions */ 95static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps) 96{ 97 int log2_min_cb_size = sps->log2_min_cb_size; 98 int width = sps->width; 99 int height = sps->height; 100 int pic_size_in_ctb = ((width >> log2_min_cb_size) + 1) * 101 ((height >> log2_min_cb_size) + 1); 102 int ctb_count = sps->ctb_width * sps->ctb_height; 103 int min_pu_size = sps->min_pu_width * sps->min_pu_height; 104 105 s->bs_width = (width >> 2) + 1; 106 s->bs_height = (height >> 2) + 1; 107 108 s->sao = av_calloc(ctb_count, sizeof(*s->sao)); 109 s->deblock = av_calloc(ctb_count, sizeof(*s->deblock)); 110 if (!s->sao || !s->deblock) 111 goto fail; 112 113 s->skip_flag = av_malloc_array(sps->min_cb_height, sps->min_cb_width); 114 s->tab_ct_depth = av_malloc_array(sps->min_cb_height, sps->min_cb_width); 115 if (!s->skip_flag || !s->tab_ct_depth) 116 goto fail; 117 118 s->cbf_luma = av_malloc_array(sps->min_tb_width, sps->min_tb_height); 119 s->tab_ipm = av_mallocz(min_pu_size); 120 s->is_pcm = av_malloc_array(sps->min_pu_width + 1, sps->min_pu_height + 1); 121 if (!s->tab_ipm || !s->cbf_luma || !s->is_pcm) 122 goto fail; 123 124 s->filter_slice_edges = av_mallocz(ctb_count); 125 s->tab_slice_address = av_malloc_array(pic_size_in_ctb, 126 sizeof(*s->tab_slice_address)); 127 s->qp_y_tab = av_malloc_array(pic_size_in_ctb, 128 sizeof(*s->qp_y_tab)); 129 if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address) 130 goto fail; 131 132 s->horizontal_bs = av_calloc(s->bs_width, s->bs_height); 133 s->vertical_bs = av_calloc(s->bs_width, s->bs_height); 134 if (!s->horizontal_bs || !s->vertical_bs) 135 goto fail; 136 137 s->tab_mvf_pool = av_buffer_pool_init(min_pu_size * sizeof(MvField), 138 av_buffer_allocz); 139 s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab), 140 av_buffer_allocz); 141 if (!s->tab_mvf_pool || !s->rpl_tab_pool) 142 goto fail; 143 144 return 0; 145 146fail: 147 pic_arrays_free(s); 148 return AVERROR(ENOMEM); 149} 150 151static int pred_weight_table(HEVCContext *s, GetBitContext *gb) 152{ 153 int i = 0; 154 int j = 0; 155 uint8_t luma_weight_l0_flag[16]; 156 uint8_t chroma_weight_l0_flag[16]; 157 uint8_t luma_weight_l1_flag[16]; 158 uint8_t chroma_weight_l1_flag[16]; 159 int luma_log2_weight_denom; 160 161 luma_log2_weight_denom = get_ue_golomb_long(gb); 162 if (luma_log2_weight_denom < 0 || luma_log2_weight_denom > 7) { 163 av_log(s->avctx, AV_LOG_ERROR, "luma_log2_weight_denom %d is invalid\n", luma_log2_weight_denom); 164 return AVERROR_INVALIDDATA; 165 } 166 s->sh.luma_log2_weight_denom = av_clip_uintp2(luma_log2_weight_denom, 3); 167 if (s->ps.sps->chroma_format_idc != 0) { 168 int64_t chroma_log2_weight_denom = luma_log2_weight_denom + (int64_t)get_se_golomb(gb); 169 if (chroma_log2_weight_denom < 0 || chroma_log2_weight_denom > 7) { 170 av_log(s->avctx, AV_LOG_ERROR, "chroma_log2_weight_denom %"PRId64" is invalid\n", chroma_log2_weight_denom); 171 return AVERROR_INVALIDDATA; 172 } 173 s->sh.chroma_log2_weight_denom = chroma_log2_weight_denom; 174 } 175 176 for (i = 0; i < s->sh.nb_refs[L0]; i++) { 177 luma_weight_l0_flag[i] = get_bits1(gb); 178 if (!luma_weight_l0_flag[i]) { 179 s->sh.luma_weight_l0[i] = 1 << s->sh.luma_log2_weight_denom; 180 s->sh.luma_offset_l0[i] = 0; 181 } 182 } 183 if (s->ps.sps->chroma_format_idc != 0) { 184 for (i = 0; i < s->sh.nb_refs[L0]; i++) 185 chroma_weight_l0_flag[i] = get_bits1(gb); 186 } else { 187 for (i = 0; i < s->sh.nb_refs[L0]; i++) 188 chroma_weight_l0_flag[i] = 0; 189 } 190 for (i = 0; i < s->sh.nb_refs[L0]; i++) { 191 if (luma_weight_l0_flag[i]) { 192 int delta_luma_weight_l0 = get_se_golomb(gb); 193 if ((int8_t)delta_luma_weight_l0 != delta_luma_weight_l0) 194 return AVERROR_INVALIDDATA; 195 s->sh.luma_weight_l0[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l0; 196 s->sh.luma_offset_l0[i] = get_se_golomb(gb); 197 } 198 if (chroma_weight_l0_flag[i]) { 199 for (j = 0; j < 2; j++) { 200 int delta_chroma_weight_l0 = get_se_golomb(gb); 201 int delta_chroma_offset_l0 = get_se_golomb(gb); 202 203 if ( (int8_t)delta_chroma_weight_l0 != delta_chroma_weight_l0 204 || delta_chroma_offset_l0 < -(1<<17) || delta_chroma_offset_l0 > (1<<17)) { 205 return AVERROR_INVALIDDATA; 206 } 207 208 s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0; 209 s->sh.chroma_offset_l0[i][j] = av_clip((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j]) 210 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127); 211 } 212 } else { 213 s->sh.chroma_weight_l0[i][0] = 1 << s->sh.chroma_log2_weight_denom; 214 s->sh.chroma_offset_l0[i][0] = 0; 215 s->sh.chroma_weight_l0[i][1] = 1 << s->sh.chroma_log2_weight_denom; 216 s->sh.chroma_offset_l0[i][1] = 0; 217 } 218 } 219 if (s->sh.slice_type == HEVC_SLICE_B) { 220 for (i = 0; i < s->sh.nb_refs[L1]; i++) { 221 luma_weight_l1_flag[i] = get_bits1(gb); 222 if (!luma_weight_l1_flag[i]) { 223 s->sh.luma_weight_l1[i] = 1 << s->sh.luma_log2_weight_denom; 224 s->sh.luma_offset_l1[i] = 0; 225 } 226 } 227 if (s->ps.sps->chroma_format_idc != 0) { 228 for (i = 0; i < s->sh.nb_refs[L1]; i++) 229 chroma_weight_l1_flag[i] = get_bits1(gb); 230 } else { 231 for (i = 0; i < s->sh.nb_refs[L1]; i++) 232 chroma_weight_l1_flag[i] = 0; 233 } 234 for (i = 0; i < s->sh.nb_refs[L1]; i++) { 235 if (luma_weight_l1_flag[i]) { 236 int delta_luma_weight_l1 = get_se_golomb(gb); 237 if ((int8_t)delta_luma_weight_l1 != delta_luma_weight_l1) 238 return AVERROR_INVALIDDATA; 239 s->sh.luma_weight_l1[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l1; 240 s->sh.luma_offset_l1[i] = get_se_golomb(gb); 241 } 242 if (chroma_weight_l1_flag[i]) { 243 for (j = 0; j < 2; j++) { 244 int delta_chroma_weight_l1 = get_se_golomb(gb); 245 int delta_chroma_offset_l1 = get_se_golomb(gb); 246 247 if ( (int8_t)delta_chroma_weight_l1 != delta_chroma_weight_l1 248 || delta_chroma_offset_l1 < -(1<<17) || delta_chroma_offset_l1 > (1<<17)) { 249 return AVERROR_INVALIDDATA; 250 } 251 252 s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1; 253 s->sh.chroma_offset_l1[i][j] = av_clip((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j]) 254 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127); 255 } 256 } else { 257 s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom; 258 s->sh.chroma_offset_l1[i][0] = 0; 259 s->sh.chroma_weight_l1[i][1] = 1 << s->sh.chroma_log2_weight_denom; 260 s->sh.chroma_offset_l1[i][1] = 0; 261 } 262 } 263 } 264 return 0; 265} 266 267static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb) 268{ 269 const HEVCSPS *sps = s->ps.sps; 270 int max_poc_lsb = 1 << sps->log2_max_poc_lsb; 271 int prev_delta_msb = 0; 272 unsigned int nb_sps = 0, nb_sh; 273 int i; 274 275 rps->nb_refs = 0; 276 if (!sps->long_term_ref_pics_present_flag) 277 return 0; 278 279 if (sps->num_long_term_ref_pics_sps > 0) 280 nb_sps = get_ue_golomb_long(gb); 281 nb_sh = get_ue_golomb_long(gb); 282 283 if (nb_sps > sps->num_long_term_ref_pics_sps) 284 return AVERROR_INVALIDDATA; 285 if (nb_sh + (uint64_t)nb_sps > FF_ARRAY_ELEMS(rps->poc)) 286 return AVERROR_INVALIDDATA; 287 288 rps->nb_refs = nb_sh + nb_sps; 289 290 for (i = 0; i < rps->nb_refs; i++) { 291 292 if (i < nb_sps) { 293 uint8_t lt_idx_sps = 0; 294 295 if (sps->num_long_term_ref_pics_sps > 1) 296 lt_idx_sps = get_bits(gb, av_ceil_log2(sps->num_long_term_ref_pics_sps)); 297 298 rps->poc[i] = sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps]; 299 rps->used[i] = sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps]; 300 } else { 301 rps->poc[i] = get_bits(gb, sps->log2_max_poc_lsb); 302 rps->used[i] = get_bits1(gb); 303 } 304 305 rps->poc_msb_present[i] = get_bits1(gb); 306 if (rps->poc_msb_present[i]) { 307 int64_t delta = get_ue_golomb_long(gb); 308 int64_t poc; 309 310 if (i && i != nb_sps) 311 delta += prev_delta_msb; 312 313 poc = rps->poc[i] + s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb; 314 if (poc != (int32_t)poc) 315 return AVERROR_INVALIDDATA; 316 rps->poc[i] = poc; 317 prev_delta_msb = delta; 318 } 319 } 320 321 return 0; 322} 323 324static void export_stream_params(HEVCContext *s, const HEVCSPS *sps) 325{ 326 AVCodecContext *avctx = s->avctx; 327 const HEVCParamSets *ps = &s->ps; 328 const HEVCVPS *vps = (const HEVCVPS*)ps->vps_list[sps->vps_id]->data; 329 const HEVCWindow *ow = &sps->output_window; 330 unsigned int num = 0, den = 0; 331 332 avctx->pix_fmt = sps->pix_fmt; 333 avctx->coded_width = sps->width; 334 avctx->coded_height = sps->height; 335 avctx->width = sps->width - ow->left_offset - ow->right_offset; 336 avctx->height = sps->height - ow->top_offset - ow->bottom_offset; 337 avctx->has_b_frames = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics; 338 avctx->profile = sps->ptl.general_ptl.profile_idc; 339 avctx->level = sps->ptl.general_ptl.level_idc; 340 341 ff_set_sar(avctx, sps->vui.sar); 342 343 if (sps->vui.video_signal_type_present_flag) 344 avctx->color_range = sps->vui.video_full_range_flag ? AVCOL_RANGE_JPEG 345 : AVCOL_RANGE_MPEG; 346 else 347 avctx->color_range = AVCOL_RANGE_MPEG; 348 349 if (sps->vui.colour_description_present_flag) { 350 avctx->color_primaries = sps->vui.colour_primaries; 351 avctx->color_trc = sps->vui.transfer_characteristic; 352 avctx->colorspace = sps->vui.matrix_coeffs; 353 } else { 354 avctx->color_primaries = AVCOL_PRI_UNSPECIFIED; 355 avctx->color_trc = AVCOL_TRC_UNSPECIFIED; 356 avctx->colorspace = AVCOL_SPC_UNSPECIFIED; 357 } 358 359 avctx->chroma_sample_location = AVCHROMA_LOC_UNSPECIFIED; 360 if (sps->chroma_format_idc == 1) { 361 if (sps->vui.chroma_loc_info_present_flag) { 362 if (sps->vui.chroma_sample_loc_type_top_field <= 5) 363 avctx->chroma_sample_location = sps->vui.chroma_sample_loc_type_top_field + 1; 364 } else 365 avctx->chroma_sample_location = AVCHROMA_LOC_LEFT; 366 } 367 368 if (vps->vps_timing_info_present_flag) { 369 num = vps->vps_num_units_in_tick; 370 den = vps->vps_time_scale; 371 } else if (sps->vui.vui_timing_info_present_flag) { 372 num = sps->vui.vui_num_units_in_tick; 373 den = sps->vui.vui_time_scale; 374 } 375 376 if (num != 0 && den != 0) 377 av_reduce(&avctx->framerate.den, &avctx->framerate.num, 378 num, den, 1 << 30); 379} 380 381static int export_stream_params_from_sei(HEVCContext *s) 382{ 383 AVCodecContext *avctx = s->avctx; 384 385 if (s->sei.a53_caption.buf_ref) 386 s->avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS; 387 388 if (s->sei.alternative_transfer.present && 389 av_color_transfer_name(s->sei.alternative_transfer.preferred_transfer_characteristics) && 390 s->sei.alternative_transfer.preferred_transfer_characteristics != AVCOL_TRC_UNSPECIFIED) { 391 avctx->color_trc = s->sei.alternative_transfer.preferred_transfer_characteristics; 392 } 393 394 if (s->sei.film_grain_characteristics.present) 395 avctx->properties |= FF_CODEC_PROPERTY_FILM_GRAIN; 396 397 return 0; 398} 399 400static enum AVPixelFormat get_format(HEVCContext *s, const HEVCSPS *sps) 401{ 402#define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + \ 403 CONFIG_HEVC_D3D11VA_HWACCEL * 2 + \ 404 CONFIG_HEVC_NVDEC_HWACCEL + \ 405 CONFIG_HEVC_VAAPI_HWACCEL + \ 406 CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL + \ 407 CONFIG_HEVC_VDPAU_HWACCEL) 408 enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts; 409 410 switch (sps->pix_fmt) { 411 case AV_PIX_FMT_YUV420P: 412 case AV_PIX_FMT_YUVJ420P: 413#if CONFIG_HEVC_DXVA2_HWACCEL 414 *fmt++ = AV_PIX_FMT_DXVA2_VLD; 415#endif 416#if CONFIG_HEVC_D3D11VA_HWACCEL 417 *fmt++ = AV_PIX_FMT_D3D11VA_VLD; 418 *fmt++ = AV_PIX_FMT_D3D11; 419#endif 420#if CONFIG_HEVC_VAAPI_HWACCEL 421 *fmt++ = AV_PIX_FMT_VAAPI; 422#endif 423#if CONFIG_HEVC_VDPAU_HWACCEL 424 *fmt++ = AV_PIX_FMT_VDPAU; 425#endif 426#if CONFIG_HEVC_NVDEC_HWACCEL 427 *fmt++ = AV_PIX_FMT_CUDA; 428#endif 429#if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL 430 *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX; 431#endif 432 break; 433 case AV_PIX_FMT_YUV420P10: 434#if CONFIG_HEVC_DXVA2_HWACCEL 435 *fmt++ = AV_PIX_FMT_DXVA2_VLD; 436#endif 437#if CONFIG_HEVC_D3D11VA_HWACCEL 438 *fmt++ = AV_PIX_FMT_D3D11VA_VLD; 439 *fmt++ = AV_PIX_FMT_D3D11; 440#endif 441#if CONFIG_HEVC_VAAPI_HWACCEL 442 *fmt++ = AV_PIX_FMT_VAAPI; 443#endif 444#if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL 445 *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX; 446#endif 447#if CONFIG_HEVC_VDPAU_HWACCEL 448 *fmt++ = AV_PIX_FMT_VDPAU; 449#endif 450#if CONFIG_HEVC_NVDEC_HWACCEL 451 *fmt++ = AV_PIX_FMT_CUDA; 452#endif 453 break; 454 case AV_PIX_FMT_YUV444P: 455#if CONFIG_HEVC_VDPAU_HWACCEL 456 *fmt++ = AV_PIX_FMT_VDPAU; 457#endif 458#if CONFIG_HEVC_NVDEC_HWACCEL 459 *fmt++ = AV_PIX_FMT_CUDA; 460#endif 461#if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL 462 *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX; 463#endif 464 break; 465 case AV_PIX_FMT_YUV422P: 466 case AV_PIX_FMT_YUV422P10LE: 467#if CONFIG_HEVC_VAAPI_HWACCEL 468 *fmt++ = AV_PIX_FMT_VAAPI; 469#endif 470#if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL 471 *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX; 472#endif 473 break; 474 case AV_PIX_FMT_YUV444P10: 475#if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL 476 *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX; 477#endif 478 case AV_PIX_FMT_YUV420P12: 479 case AV_PIX_FMT_YUV444P12: 480#if CONFIG_HEVC_VDPAU_HWACCEL 481 *fmt++ = AV_PIX_FMT_VDPAU; 482#endif 483#if CONFIG_HEVC_NVDEC_HWACCEL 484 *fmt++ = AV_PIX_FMT_CUDA; 485#endif 486 break; 487 } 488 489 *fmt++ = sps->pix_fmt; 490 *fmt = AV_PIX_FMT_NONE; 491 492 return ff_thread_get_format(s->avctx, pix_fmts); 493} 494 495static int set_sps(HEVCContext *s, const HEVCSPS *sps, 496 enum AVPixelFormat pix_fmt) 497{ 498 int ret, i; 499 500 pic_arrays_free(s); 501 s->ps.sps = NULL; 502 s->ps.vps = NULL; 503 504 if (!sps) 505 return 0; 506 507 ret = pic_arrays_init(s, sps); 508 if (ret < 0) 509 goto fail; 510 511 export_stream_params(s, sps); 512 513 s->avctx->pix_fmt = pix_fmt; 514 515 ff_hevc_pred_init(&s->hpc, sps->bit_depth); 516 ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth); 517 ff_videodsp_init (&s->vdsp, sps->bit_depth); 518 519 for (i = 0; i < 3; i++) { 520 av_freep(&s->sao_pixel_buffer_h[i]); 521 av_freep(&s->sao_pixel_buffer_v[i]); 522 } 523 524 if (sps->sao_enabled && !s->avctx->hwaccel) { 525 int c_count = (sps->chroma_format_idc != 0) ? 3 : 1; 526 int c_idx; 527 528 for(c_idx = 0; c_idx < c_count; c_idx++) { 529 int w = sps->width >> sps->hshift[c_idx]; 530 int h = sps->height >> sps->vshift[c_idx]; 531 s->sao_pixel_buffer_h[c_idx] = 532 av_malloc((w * 2 * sps->ctb_height) << 533 sps->pixel_shift); 534 s->sao_pixel_buffer_v[c_idx] = 535 av_malloc((h * 2 * sps->ctb_width) << 536 sps->pixel_shift); 537 if (!s->sao_pixel_buffer_h[c_idx] || 538 !s->sao_pixel_buffer_v[c_idx]) 539 goto fail; 540 } 541 } 542 543 s->ps.sps = sps; 544 s->ps.vps = (HEVCVPS*) s->ps.vps_list[s->ps.sps->vps_id]->data; 545 546 return 0; 547 548fail: 549 pic_arrays_free(s); 550 for (i = 0; i < 3; i++) { 551 av_freep(&s->sao_pixel_buffer_h[i]); 552 av_freep(&s->sao_pixel_buffer_v[i]); 553 } 554 s->ps.sps = NULL; 555 return ret; 556} 557 558static int hls_slice_header(HEVCContext *s) 559{ 560 GetBitContext *gb = &s->HEVClc->gb; 561 SliceHeader *sh = &s->sh; 562 int i, ret; 563 564 // Coded parameters 565 sh->first_slice_in_pic_flag = get_bits1(gb); 566 if (s->ref && sh->first_slice_in_pic_flag) { 567 av_log(s->avctx, AV_LOG_ERROR, "Two slices reporting being the first in the same frame.\n"); 568 return 1; // This slice will be skipped later, do not corrupt state 569 } 570 571 if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) { 572 s->seq_decode = (s->seq_decode + 1) & 0xff; 573 s->max_ra = INT_MAX; 574 if (IS_IDR(s)) 575 ff_hevc_clear_refs(s); 576 } 577 sh->no_output_of_prior_pics_flag = 0; 578 if (IS_IRAP(s)) 579 sh->no_output_of_prior_pics_flag = get_bits1(gb); 580 581 sh->pps_id = get_ue_golomb_long(gb); 582 if (sh->pps_id >= HEVC_MAX_PPS_COUNT || !s->ps.pps_list[sh->pps_id]) { 583 av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id); 584 return AVERROR_INVALIDDATA; 585 } 586 if (!sh->first_slice_in_pic_flag && 587 s->ps.pps != (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data) { 588 av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n"); 589 return AVERROR_INVALIDDATA; 590 } 591 s->ps.pps = (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data; 592 if (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos == 1) 593 sh->no_output_of_prior_pics_flag = 1; 594 595 if (s->ps.sps != (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data) { 596 const HEVCSPS *sps = (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data; 597 const HEVCSPS *last_sps = s->ps.sps; 598 enum AVPixelFormat pix_fmt; 599 600 if (last_sps && IS_IRAP(s) && s->nal_unit_type != HEVC_NAL_CRA_NUT) { 601 if (sps->width != last_sps->width || sps->height != last_sps->height || 602 sps->temporal_layer[sps->max_sub_layers - 1].max_dec_pic_buffering != 603 last_sps->temporal_layer[last_sps->max_sub_layers - 1].max_dec_pic_buffering) 604 sh->no_output_of_prior_pics_flag = 0; 605 } 606 ff_hevc_clear_refs(s); 607 608 ret = set_sps(s, sps, sps->pix_fmt); 609 if (ret < 0) 610 return ret; 611 612 pix_fmt = get_format(s, sps); 613 if (pix_fmt < 0) 614 return pix_fmt; 615 s->avctx->pix_fmt = pix_fmt; 616 617 s->seq_decode = (s->seq_decode + 1) & 0xff; 618 s->max_ra = INT_MAX; 619 } 620 621 ret = export_stream_params_from_sei(s); 622 if (ret < 0) 623 return ret; 624 625 sh->dependent_slice_segment_flag = 0; 626 if (!sh->first_slice_in_pic_flag) { 627 int slice_address_length; 628 629 if (s->ps.pps->dependent_slice_segments_enabled_flag) 630 sh->dependent_slice_segment_flag = get_bits1(gb); 631 if (sh->dependent_slice_segment_flag && !s->slice_initialized) { 632 av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n"); 633 return AVERROR_INVALIDDATA; 634 } 635 636 slice_address_length = av_ceil_log2(s->ps.sps->ctb_width * 637 s->ps.sps->ctb_height); 638 sh->slice_segment_addr = get_bitsz(gb, slice_address_length); 639 if (sh->slice_segment_addr >= s->ps.sps->ctb_width * s->ps.sps->ctb_height) { 640 av_log(s->avctx, AV_LOG_ERROR, 641 "Invalid slice segment address: %u.\n", 642 sh->slice_segment_addr); 643 return AVERROR_INVALIDDATA; 644 } 645 646 if (!sh->dependent_slice_segment_flag) { 647 sh->slice_addr = sh->slice_segment_addr; 648 s->slice_idx++; 649 } 650 } else { 651 sh->slice_segment_addr = sh->slice_addr = 0; 652 s->slice_idx = 0; 653 s->slice_initialized = 0; 654 } 655 656 if (!sh->dependent_slice_segment_flag) { 657 s->slice_initialized = 0; 658 659 for (i = 0; i < s->ps.pps->num_extra_slice_header_bits; i++) 660 skip_bits(gb, 1); // slice_reserved_undetermined_flag[] 661 662 sh->slice_type = get_ue_golomb_long(gb); 663 if (!(sh->slice_type == HEVC_SLICE_I || 664 sh->slice_type == HEVC_SLICE_P || 665 sh->slice_type == HEVC_SLICE_B)) { 666 av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n", 667 sh->slice_type); 668 return AVERROR_INVALIDDATA; 669 } 670 if (IS_IRAP(s) && sh->slice_type != HEVC_SLICE_I) { 671 av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n"); 672 return AVERROR_INVALIDDATA; 673 } 674 675 // when flag is not present, picture is inferred to be output 676 sh->pic_output_flag = 1; 677 if (s->ps.pps->output_flag_present_flag) 678 sh->pic_output_flag = get_bits1(gb); 679 680 if (s->ps.sps->separate_colour_plane_flag) 681 sh->colour_plane_id = get_bits(gb, 2); 682 683 if (!IS_IDR(s)) { 684 int poc, pos; 685 686 sh->pic_order_cnt_lsb = get_bits(gb, s->ps.sps->log2_max_poc_lsb); 687 poc = ff_hevc_compute_poc(s->ps.sps, s->pocTid0, sh->pic_order_cnt_lsb, s->nal_unit_type); 688 if (!sh->first_slice_in_pic_flag && poc != s->poc) { 689 av_log(s->avctx, AV_LOG_WARNING, 690 "Ignoring POC change between slices: %d -> %d\n", s->poc, poc); 691 if (s->avctx->err_recognition & AV_EF_EXPLODE) 692 return AVERROR_INVALIDDATA; 693 poc = s->poc; 694 } 695 s->poc = poc; 696 697 sh->short_term_ref_pic_set_sps_flag = get_bits1(gb); 698 pos = get_bits_left(gb); 699 if (!sh->short_term_ref_pic_set_sps_flag) { 700 ret = ff_hevc_decode_short_term_rps(gb, s->avctx, &sh->slice_rps, s->ps.sps, 1); 701 if (ret < 0) 702 return ret; 703 704 sh->short_term_rps = &sh->slice_rps; 705 } else { 706 int numbits, rps_idx; 707 708 if (!s->ps.sps->nb_st_rps) { 709 av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n"); 710 return AVERROR_INVALIDDATA; 711 } 712 713 numbits = av_ceil_log2(s->ps.sps->nb_st_rps); 714 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0; 715 sh->short_term_rps = &s->ps.sps->st_rps[rps_idx]; 716 } 717 sh->short_term_ref_pic_set_size = pos - get_bits_left(gb); 718 719 pos = get_bits_left(gb); 720 ret = decode_lt_rps(s, &sh->long_term_rps, gb); 721 if (ret < 0) { 722 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n"); 723 if (s->avctx->err_recognition & AV_EF_EXPLODE) 724 return AVERROR_INVALIDDATA; 725 } 726 sh->long_term_ref_pic_set_size = pos - get_bits_left(gb); 727 728 if (s->ps.sps->sps_temporal_mvp_enabled_flag) 729 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb); 730 else 731 sh->slice_temporal_mvp_enabled_flag = 0; 732 } else { 733 s->sh.short_term_rps = NULL; 734 s->poc = 0; 735 } 736 737 /* 8.3.1 */ 738 if (sh->first_slice_in_pic_flag && s->temporal_id == 0 && 739 s->nal_unit_type != HEVC_NAL_TRAIL_N && 740 s->nal_unit_type != HEVC_NAL_TSA_N && 741 s->nal_unit_type != HEVC_NAL_STSA_N && 742 s->nal_unit_type != HEVC_NAL_RADL_N && 743 s->nal_unit_type != HEVC_NAL_RADL_R && 744 s->nal_unit_type != HEVC_NAL_RASL_N && 745 s->nal_unit_type != HEVC_NAL_RASL_R) 746 s->pocTid0 = s->poc; 747 748 if (s->ps.sps->sao_enabled) { 749 sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb); 750 if (s->ps.sps->chroma_format_idc) { 751 sh->slice_sample_adaptive_offset_flag[1] = 752 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb); 753 } 754 } else { 755 sh->slice_sample_adaptive_offset_flag[0] = 0; 756 sh->slice_sample_adaptive_offset_flag[1] = 0; 757 sh->slice_sample_adaptive_offset_flag[2] = 0; 758 } 759 760 sh->nb_refs[L0] = sh->nb_refs[L1] = 0; 761 if (sh->slice_type == HEVC_SLICE_P || sh->slice_type == HEVC_SLICE_B) { 762 int nb_refs; 763 764 sh->nb_refs[L0] = s->ps.pps->num_ref_idx_l0_default_active; 765 if (sh->slice_type == HEVC_SLICE_B) 766 sh->nb_refs[L1] = s->ps.pps->num_ref_idx_l1_default_active; 767 768 if (get_bits1(gb)) { // num_ref_idx_active_override_flag 769 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1; 770 if (sh->slice_type == HEVC_SLICE_B) 771 sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1; 772 } 773 if (sh->nb_refs[L0] > HEVC_MAX_REFS || sh->nb_refs[L1] > HEVC_MAX_REFS) { 774 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n", 775 sh->nb_refs[L0], sh->nb_refs[L1]); 776 return AVERROR_INVALIDDATA; 777 } 778 779 sh->rpl_modification_flag[0] = 0; 780 sh->rpl_modification_flag[1] = 0; 781 nb_refs = ff_hevc_frame_nb_refs(s); 782 if (!nb_refs) { 783 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n"); 784 return AVERROR_INVALIDDATA; 785 } 786 787 if (s->ps.pps->lists_modification_present_flag && nb_refs > 1) { 788 sh->rpl_modification_flag[0] = get_bits1(gb); 789 if (sh->rpl_modification_flag[0]) { 790 for (i = 0; i < sh->nb_refs[L0]; i++) 791 sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs)); 792 } 793 794 if (sh->slice_type == HEVC_SLICE_B) { 795 sh->rpl_modification_flag[1] = get_bits1(gb); 796 if (sh->rpl_modification_flag[1] == 1) 797 for (i = 0; i < sh->nb_refs[L1]; i++) 798 sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs)); 799 } 800 } 801 802 if (sh->slice_type == HEVC_SLICE_B) 803 sh->mvd_l1_zero_flag = get_bits1(gb); 804 805 if (s->ps.pps->cabac_init_present_flag) 806 sh->cabac_init_flag = get_bits1(gb); 807 else 808 sh->cabac_init_flag = 0; 809 810 sh->collocated_ref_idx = 0; 811 if (sh->slice_temporal_mvp_enabled_flag) { 812 sh->collocated_list = L0; 813 if (sh->slice_type == HEVC_SLICE_B) 814 sh->collocated_list = !get_bits1(gb); 815 816 if (sh->nb_refs[sh->collocated_list] > 1) { 817 sh->collocated_ref_idx = get_ue_golomb_long(gb); 818 if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) { 819 av_log(s->avctx, AV_LOG_ERROR, 820 "Invalid collocated_ref_idx: %d.\n", 821 sh->collocated_ref_idx); 822 return AVERROR_INVALIDDATA; 823 } 824 } 825 } 826 827 if ((s->ps.pps->weighted_pred_flag && sh->slice_type == HEVC_SLICE_P) || 828 (s->ps.pps->weighted_bipred_flag && sh->slice_type == HEVC_SLICE_B)) { 829 int ret = pred_weight_table(s, gb); 830 if (ret < 0) 831 return ret; 832 } 833 834 sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb); 835 if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) { 836 av_log(s->avctx, AV_LOG_ERROR, 837 "Invalid number of merging MVP candidates: %d.\n", 838 sh->max_num_merge_cand); 839 return AVERROR_INVALIDDATA; 840 } 841 } 842 843 sh->slice_qp_delta = get_se_golomb(gb); 844 845 if (s->ps.pps->pic_slice_level_chroma_qp_offsets_present_flag) { 846 sh->slice_cb_qp_offset = get_se_golomb(gb); 847 sh->slice_cr_qp_offset = get_se_golomb(gb); 848 if (sh->slice_cb_qp_offset < -12 || sh->slice_cb_qp_offset > 12 || 849 sh->slice_cr_qp_offset < -12 || sh->slice_cr_qp_offset > 12) { 850 av_log(s->avctx, AV_LOG_ERROR, "Invalid slice cx qp offset.\n"); 851 return AVERROR_INVALIDDATA; 852 } 853 } else { 854 sh->slice_cb_qp_offset = 0; 855 sh->slice_cr_qp_offset = 0; 856 } 857 858 if (s->ps.pps->chroma_qp_offset_list_enabled_flag) 859 sh->cu_chroma_qp_offset_enabled_flag = get_bits1(gb); 860 else 861 sh->cu_chroma_qp_offset_enabled_flag = 0; 862 863 if (s->ps.pps->deblocking_filter_control_present_flag) { 864 int deblocking_filter_override_flag = 0; 865 866 if (s->ps.pps->deblocking_filter_override_enabled_flag) 867 deblocking_filter_override_flag = get_bits1(gb); 868 869 if (deblocking_filter_override_flag) { 870 sh->disable_deblocking_filter_flag = get_bits1(gb); 871 if (!sh->disable_deblocking_filter_flag) { 872 int beta_offset_div2 = get_se_golomb(gb); 873 int tc_offset_div2 = get_se_golomb(gb) ; 874 if (beta_offset_div2 < -6 || beta_offset_div2 > 6 || 875 tc_offset_div2 < -6 || tc_offset_div2 > 6) { 876 av_log(s->avctx, AV_LOG_ERROR, 877 "Invalid deblock filter offsets: %d, %d\n", 878 beta_offset_div2, tc_offset_div2); 879 return AVERROR_INVALIDDATA; 880 } 881 sh->beta_offset = beta_offset_div2 * 2; 882 sh->tc_offset = tc_offset_div2 * 2; 883 } 884 } else { 885 sh->disable_deblocking_filter_flag = s->ps.pps->disable_dbf; 886 sh->beta_offset = s->ps.pps->beta_offset; 887 sh->tc_offset = s->ps.pps->tc_offset; 888 } 889 } else { 890 sh->disable_deblocking_filter_flag = 0; 891 sh->beta_offset = 0; 892 sh->tc_offset = 0; 893 } 894 895 if (s->ps.pps->seq_loop_filter_across_slices_enabled_flag && 896 (sh->slice_sample_adaptive_offset_flag[0] || 897 sh->slice_sample_adaptive_offset_flag[1] || 898 !sh->disable_deblocking_filter_flag)) { 899 sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb); 900 } else { 901 sh->slice_loop_filter_across_slices_enabled_flag = s->ps.pps->seq_loop_filter_across_slices_enabled_flag; 902 } 903 } 904 905 sh->num_entry_point_offsets = 0; 906 if (s->ps.pps->tiles_enabled_flag || s->ps.pps->entropy_coding_sync_enabled_flag) { 907 unsigned num_entry_point_offsets = get_ue_golomb_long(gb); 908 // It would be possible to bound this tighter but this here is simpler 909 if (num_entry_point_offsets > get_bits_left(gb)) { 910 av_log(s->avctx, AV_LOG_ERROR, "num_entry_point_offsets %d is invalid\n", num_entry_point_offsets); 911 return AVERROR_INVALIDDATA; 912 } 913 914 sh->num_entry_point_offsets = num_entry_point_offsets; 915 if (sh->num_entry_point_offsets > 0) { 916 int offset_len = get_ue_golomb_long(gb) + 1; 917 918 if (offset_len < 1 || offset_len > 32) { 919 sh->num_entry_point_offsets = 0; 920 av_log(s->avctx, AV_LOG_ERROR, "offset_len %d is invalid\n", offset_len); 921 return AVERROR_INVALIDDATA; 922 } 923 924 av_freep(&sh->entry_point_offset); 925 av_freep(&sh->offset); 926 av_freep(&sh->size); 927 sh->entry_point_offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(unsigned)); 928 sh->offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int)); 929 sh->size = av_malloc_array(sh->num_entry_point_offsets, sizeof(int)); 930 if (!sh->entry_point_offset || !sh->offset || !sh->size) { 931 sh->num_entry_point_offsets = 0; 932 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate memory\n"); 933 return AVERROR(ENOMEM); 934 } 935 for (i = 0; i < sh->num_entry_point_offsets; i++) { 936 unsigned val = get_bits_long(gb, offset_len); 937 sh->entry_point_offset[i] = val + 1; // +1; // +1 to get the size 938 } 939 if (s->threads_number > 1 && (s->ps.pps->num_tile_rows > 1 || s->ps.pps->num_tile_columns > 1)) { 940 s->enable_parallel_tiles = 0; // TODO: you can enable tiles in parallel here 941 s->threads_number = 1; 942 } else 943 s->enable_parallel_tiles = 0; 944 } else 945 s->enable_parallel_tiles = 0; 946 } 947 948 if (s->ps.pps->slice_header_extension_present_flag) { 949 unsigned int length = get_ue_golomb_long(gb); 950 if (length*8LL > get_bits_left(gb)) { 951 av_log(s->avctx, AV_LOG_ERROR, "too many slice_header_extension_data_bytes\n"); 952 return AVERROR_INVALIDDATA; 953 } 954 for (i = 0; i < length; i++) 955 skip_bits(gb, 8); // slice_header_extension_data_byte 956 } 957 958 // Inferred parameters 959 sh->slice_qp = 26U + s->ps.pps->pic_init_qp_minus26 + sh->slice_qp_delta; 960 if (sh->slice_qp > 51 || 961 sh->slice_qp < -s->ps.sps->qp_bd_offset) { 962 av_log(s->avctx, AV_LOG_ERROR, 963 "The slice_qp %d is outside the valid range " 964 "[%d, 51].\n", 965 sh->slice_qp, 966 -s->ps.sps->qp_bd_offset); 967 return AVERROR_INVALIDDATA; 968 } 969 970 sh->slice_ctb_addr_rs = sh->slice_segment_addr; 971 972 if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) { 973 av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n"); 974 return AVERROR_INVALIDDATA; 975 } 976 977 if (get_bits_left(gb) < 0) { 978 av_log(s->avctx, AV_LOG_ERROR, 979 "Overread slice header by %d bits\n", -get_bits_left(gb)); 980 return AVERROR_INVALIDDATA; 981 } 982 983 s->HEVClc->first_qp_group = !s->sh.dependent_slice_segment_flag; 984 985 if (!s->ps.pps->cu_qp_delta_enabled_flag) 986 s->HEVClc->qp_y = s->sh.slice_qp; 987 988 s->slice_initialized = 1; 989 s->HEVClc->tu.cu_qp_offset_cb = 0; 990 s->HEVClc->tu.cu_qp_offset_cr = 0; 991 992 return 0; 993} 994 995#define CTB(tab, x, y) ((tab)[(y) * s->ps.sps->ctb_width + (x)]) 996 997#define SET_SAO(elem, value) \ 998do { \ 999 if (!sao_merge_up_flag && !sao_merge_left_flag) \ 1000 sao->elem = value; \ 1001 else if (sao_merge_left_flag) \ 1002 sao->elem = CTB(s->sao, rx-1, ry).elem; \ 1003 else if (sao_merge_up_flag) \ 1004 sao->elem = CTB(s->sao, rx, ry-1).elem; \ 1005 else \ 1006 sao->elem = 0; \ 1007} while (0) 1008 1009static void hls_sao_param(HEVCContext *s, int rx, int ry) 1010{ 1011 HEVCLocalContext *lc = s->HEVClc; 1012 int sao_merge_left_flag = 0; 1013 int sao_merge_up_flag = 0; 1014 SAOParams *sao = &CTB(s->sao, rx, ry); 1015 int c_idx, i; 1016 1017 if (s->sh.slice_sample_adaptive_offset_flag[0] || 1018 s->sh.slice_sample_adaptive_offset_flag[1]) { 1019 if (rx > 0) { 1020 if (lc->ctb_left_flag) 1021 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s); 1022 } 1023 if (ry > 0 && !sao_merge_left_flag) { 1024 if (lc->ctb_up_flag) 1025 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s); 1026 } 1027 } 1028 1029 for (c_idx = 0; c_idx < (s->ps.sps->chroma_format_idc ? 3 : 1); c_idx++) { 1030 int log2_sao_offset_scale = c_idx == 0 ? s->ps.pps->log2_sao_offset_scale_luma : 1031 s->ps.pps->log2_sao_offset_scale_chroma; 1032 1033 if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) { 1034 sao->type_idx[c_idx] = SAO_NOT_APPLIED; 1035 continue; 1036 } 1037 1038 if (c_idx == 2) { 1039 sao->type_idx[2] = sao->type_idx[1]; 1040 sao->eo_class[2] = sao->eo_class[1]; 1041 } else { 1042 SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s)); 1043 } 1044 1045 if (sao->type_idx[c_idx] == SAO_NOT_APPLIED) 1046 continue; 1047 1048 for (i = 0; i < 4; i++) 1049 SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s)); 1050 1051 if (sao->type_idx[c_idx] == SAO_BAND) { 1052 for (i = 0; i < 4; i++) { 1053 if (sao->offset_abs[c_idx][i]) { 1054 SET_SAO(offset_sign[c_idx][i], 1055 ff_hevc_sao_offset_sign_decode(s)); 1056 } else { 1057 sao->offset_sign[c_idx][i] = 0; 1058 } 1059 } 1060 SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s)); 1061 } else if (c_idx != 2) { 1062 SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s)); 1063 } 1064 1065 // Inferred parameters 1066 sao->offset_val[c_idx][0] = 0; 1067 for (i = 0; i < 4; i++) { 1068 sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i]; 1069 if (sao->type_idx[c_idx] == SAO_EDGE) { 1070 if (i > 1) 1071 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1]; 1072 } else if (sao->offset_sign[c_idx][i]) { 1073 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1]; 1074 } 1075 sao->offset_val[c_idx][i + 1] *= 1 << log2_sao_offset_scale; 1076 } 1077 } 1078} 1079 1080#undef SET_SAO 1081#undef CTB 1082 1083static int hls_cross_component_pred(HEVCContext *s, int idx) { 1084 HEVCLocalContext *lc = s->HEVClc; 1085 int log2_res_scale_abs_plus1 = ff_hevc_log2_res_scale_abs(s, idx); 1086 1087 if (log2_res_scale_abs_plus1 != 0) { 1088 int res_scale_sign_flag = ff_hevc_res_scale_sign_flag(s, idx); 1089 lc->tu.res_scale_val = (1 << (log2_res_scale_abs_plus1 - 1)) * 1090 (1 - 2 * res_scale_sign_flag); 1091 } else { 1092 lc->tu.res_scale_val = 0; 1093 } 1094 1095 1096 return 0; 1097} 1098 1099static int hls_transform_unit(HEVCContext *s, int x0, int y0, 1100 int xBase, int yBase, int cb_xBase, int cb_yBase, 1101 int log2_cb_size, int log2_trafo_size, 1102 int blk_idx, int cbf_luma, int *cbf_cb, int *cbf_cr) 1103{ 1104 HEVCLocalContext *lc = s->HEVClc; 1105 const int log2_trafo_size_c = log2_trafo_size - s->ps.sps->hshift[1]; 1106 int i; 1107 1108 if (lc->cu.pred_mode == MODE_INTRA) { 1109 int trafo_size = 1 << log2_trafo_size; 1110 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size); 1111 1112 s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0); 1113 } 1114 1115 if (cbf_luma || cbf_cb[0] || cbf_cr[0] || 1116 (s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) { 1117 int scan_idx = SCAN_DIAG; 1118 int scan_idx_c = SCAN_DIAG; 1119 int cbf_chroma = cbf_cb[0] || cbf_cr[0] || 1120 (s->ps.sps->chroma_format_idc == 2 && 1121 (cbf_cb[1] || cbf_cr[1])); 1122 1123 if (s->ps.pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) { 1124 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s); 1125 if (lc->tu.cu_qp_delta != 0) 1126 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1) 1127 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta; 1128 lc->tu.is_cu_qp_delta_coded = 1; 1129 1130 if (lc->tu.cu_qp_delta < -(26 + s->ps.sps->qp_bd_offset / 2) || 1131 lc->tu.cu_qp_delta > (25 + s->ps.sps->qp_bd_offset / 2)) { 1132 av_log(s->avctx, AV_LOG_ERROR, 1133 "The cu_qp_delta %d is outside the valid range " 1134 "[%d, %d].\n", 1135 lc->tu.cu_qp_delta, 1136 -(26 + s->ps.sps->qp_bd_offset / 2), 1137 (25 + s->ps.sps->qp_bd_offset / 2)); 1138 return AVERROR_INVALIDDATA; 1139 } 1140 1141 ff_hevc_set_qPy(s, cb_xBase, cb_yBase, log2_cb_size); 1142 } 1143 1144 if (s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma && 1145 !lc->cu.cu_transquant_bypass_flag && !lc->tu.is_cu_chroma_qp_offset_coded) { 1146 int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(s); 1147 if (cu_chroma_qp_offset_flag) { 1148 int cu_chroma_qp_offset_idx = 0; 1149 if (s->ps.pps->chroma_qp_offset_list_len_minus1 > 0) { 1150 cu_chroma_qp_offset_idx = ff_hevc_cu_chroma_qp_offset_idx(s); 1151 av_log(s->avctx, AV_LOG_ERROR, 1152 "cu_chroma_qp_offset_idx not yet tested.\n"); 1153 } 1154 lc->tu.cu_qp_offset_cb = s->ps.pps->cb_qp_offset_list[cu_chroma_qp_offset_idx]; 1155 lc->tu.cu_qp_offset_cr = s->ps.pps->cr_qp_offset_list[cu_chroma_qp_offset_idx]; 1156 } else { 1157 lc->tu.cu_qp_offset_cb = 0; 1158 lc->tu.cu_qp_offset_cr = 0; 1159 } 1160 lc->tu.is_cu_chroma_qp_offset_coded = 1; 1161 } 1162 1163 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) { 1164 if (lc->tu.intra_pred_mode >= 6 && 1165 lc->tu.intra_pred_mode <= 14) { 1166 scan_idx = SCAN_VERT; 1167 } else if (lc->tu.intra_pred_mode >= 22 && 1168 lc->tu.intra_pred_mode <= 30) { 1169 scan_idx = SCAN_HORIZ; 1170 } 1171 1172 if (lc->tu.intra_pred_mode_c >= 6 && 1173 lc->tu.intra_pred_mode_c <= 14) { 1174 scan_idx_c = SCAN_VERT; 1175 } else if (lc->tu.intra_pred_mode_c >= 22 && 1176 lc->tu.intra_pred_mode_c <= 30) { 1177 scan_idx_c = SCAN_HORIZ; 1178 } 1179 } 1180 1181 lc->tu.cross_pf = 0; 1182 1183 if (cbf_luma) 1184 ff_hevc_hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0); 1185 if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) { 1186 int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]); 1187 int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]); 1188 lc->tu.cross_pf = (s->ps.pps->cross_component_prediction_enabled_flag && cbf_luma && 1189 (lc->cu.pred_mode == MODE_INTER || 1190 (lc->tu.chroma_mode_c == 4))); 1191 1192 if (lc->tu.cross_pf) { 1193 hls_cross_component_pred(s, 0); 1194 } 1195 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) { 1196 if (lc->cu.pred_mode == MODE_INTRA) { 1197 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v); 1198 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 1); 1199 } 1200 if (cbf_cb[i]) 1201 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c), 1202 log2_trafo_size_c, scan_idx_c, 1); 1203 else 1204 if (lc->tu.cross_pf) { 1205 ptrdiff_t stride = s->frame->linesize[1]; 1206 int hshift = s->ps.sps->hshift[1]; 1207 int vshift = s->ps.sps->vshift[1]; 1208 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer; 1209 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2; 1210 int size = 1 << log2_trafo_size_c; 1211 1212 uint8_t *dst = &s->frame->data[1][(y0 >> vshift) * stride + 1213 ((x0 >> hshift) << s->ps.sps->pixel_shift)]; 1214 for (i = 0; i < (size * size); i++) { 1215 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3); 1216 } 1217 s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride); 1218 } 1219 } 1220 1221 if (lc->tu.cross_pf) { 1222 hls_cross_component_pred(s, 1); 1223 } 1224 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) { 1225 if (lc->cu.pred_mode == MODE_INTRA) { 1226 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v); 1227 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 2); 1228 } 1229 if (cbf_cr[i]) 1230 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c), 1231 log2_trafo_size_c, scan_idx_c, 2); 1232 else 1233 if (lc->tu.cross_pf) { 1234 ptrdiff_t stride = s->frame->linesize[2]; 1235 int hshift = s->ps.sps->hshift[2]; 1236 int vshift = s->ps.sps->vshift[2]; 1237 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer; 1238 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2; 1239 int size = 1 << log2_trafo_size_c; 1240 1241 uint8_t *dst = &s->frame->data[2][(y0 >> vshift) * stride + 1242 ((x0 >> hshift) << s->ps.sps->pixel_shift)]; 1243 for (i = 0; i < (size * size); i++) { 1244 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3); 1245 } 1246 s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride); 1247 } 1248 } 1249 } else if (s->ps.sps->chroma_format_idc && blk_idx == 3) { 1250 int trafo_size_h = 1 << (log2_trafo_size + 1); 1251 int trafo_size_v = 1 << (log2_trafo_size + s->ps.sps->vshift[1]); 1252 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) { 1253 if (lc->cu.pred_mode == MODE_INTRA) { 1254 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size), 1255 trafo_size_h, trafo_size_v); 1256 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 1); 1257 } 1258 if (cbf_cb[i]) 1259 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size), 1260 log2_trafo_size, scan_idx_c, 1); 1261 } 1262 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) { 1263 if (lc->cu.pred_mode == MODE_INTRA) { 1264 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size), 1265 trafo_size_h, trafo_size_v); 1266 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 2); 1267 } 1268 if (cbf_cr[i]) 1269 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size), 1270 log2_trafo_size, scan_idx_c, 2); 1271 } 1272 } 1273 } else if (s->ps.sps->chroma_format_idc && lc->cu.pred_mode == MODE_INTRA) { 1274 if (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3) { 1275 int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]); 1276 int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]); 1277 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size_h, trafo_size_v); 1278 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 1); 1279 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 2); 1280 if (s->ps.sps->chroma_format_idc == 2) { 1281 ff_hevc_set_neighbour_available(s, x0, y0 + (1 << log2_trafo_size_c), 1282 trafo_size_h, trafo_size_v); 1283 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 1); 1284 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 2); 1285 } 1286 } else if (blk_idx == 3) { 1287 int trafo_size_h = 1 << (log2_trafo_size + 1); 1288 int trafo_size_v = 1 << (log2_trafo_size + s->ps.sps->vshift[1]); 1289 ff_hevc_set_neighbour_available(s, xBase, yBase, 1290 trafo_size_h, trafo_size_v); 1291 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1); 1292 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2); 1293 if (s->ps.sps->chroma_format_idc == 2) { 1294 ff_hevc_set_neighbour_available(s, xBase, yBase + (1 << (log2_trafo_size)), 1295 trafo_size_h, trafo_size_v); 1296 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 1); 1297 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 2); 1298 } 1299 } 1300 } 1301 1302 return 0; 1303} 1304 1305static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size) 1306{ 1307 int cb_size = 1 << log2_cb_size; 1308 int log2_min_pu_size = s->ps.sps->log2_min_pu_size; 1309 1310 int min_pu_width = s->ps.sps->min_pu_width; 1311 int x_end = FFMIN(x0 + cb_size, s->ps.sps->width); 1312 int y_end = FFMIN(y0 + cb_size, s->ps.sps->height); 1313 int i, j; 1314 1315 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++) 1316 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++) 1317 s->is_pcm[i + j * min_pu_width] = 2; 1318} 1319 1320static int hls_transform_tree(HEVCContext *s, int x0, int y0, 1321 int xBase, int yBase, int cb_xBase, int cb_yBase, 1322 int log2_cb_size, int log2_trafo_size, 1323 int trafo_depth, int blk_idx, 1324 const int *base_cbf_cb, const int *base_cbf_cr) 1325{ 1326 HEVCLocalContext *lc = s->HEVClc; 1327 uint8_t split_transform_flag; 1328 int cbf_cb[2]; 1329 int cbf_cr[2]; 1330 int ret; 1331 1332 cbf_cb[0] = base_cbf_cb[0]; 1333 cbf_cb[1] = base_cbf_cb[1]; 1334 cbf_cr[0] = base_cbf_cr[0]; 1335 cbf_cr[1] = base_cbf_cr[1]; 1336 1337 if (lc->cu.intra_split_flag) { 1338 if (trafo_depth == 1) { 1339 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[blk_idx]; 1340 if (s->ps.sps->chroma_format_idc == 3) { 1341 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[blk_idx]; 1342 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[blk_idx]; 1343 } else { 1344 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0]; 1345 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0]; 1346 } 1347 } 1348 } else { 1349 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[0]; 1350 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0]; 1351 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0]; 1352 } 1353 1354 if (log2_trafo_size <= s->ps.sps->log2_max_trafo_size && 1355 log2_trafo_size > s->ps.sps->log2_min_tb_size && 1356 trafo_depth < lc->cu.max_trafo_depth && 1357 !(lc->cu.intra_split_flag && trafo_depth == 0)) { 1358 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size); 1359 } else { 1360 int inter_split = s->ps.sps->max_transform_hierarchy_depth_inter == 0 && 1361 lc->cu.pred_mode == MODE_INTER && 1362 lc->cu.part_mode != PART_2Nx2N && 1363 trafo_depth == 0; 1364 1365 split_transform_flag = log2_trafo_size > s->ps.sps->log2_max_trafo_size || 1366 (lc->cu.intra_split_flag && trafo_depth == 0) || 1367 inter_split; 1368 } 1369 1370 if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) { 1371 if (trafo_depth == 0 || cbf_cb[0]) { 1372 cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth); 1373 if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) { 1374 cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth); 1375 } 1376 } 1377 1378 if (trafo_depth == 0 || cbf_cr[0]) { 1379 cbf_cr[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth); 1380 if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) { 1381 cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth); 1382 } 1383 } 1384 } 1385 1386 if (split_transform_flag) { 1387 const int trafo_size_split = 1 << (log2_trafo_size - 1); 1388 const int x1 = x0 + trafo_size_split; 1389 const int y1 = y0 + trafo_size_split; 1390 1391#define SUBDIVIDE(x, y, idx) \ 1392do { \ 1393 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \ 1394 log2_trafo_size - 1, trafo_depth + 1, idx, \ 1395 cbf_cb, cbf_cr); \ 1396 if (ret < 0) \ 1397 return ret; \ 1398} while (0) 1399 1400 SUBDIVIDE(x0, y0, 0); 1401 SUBDIVIDE(x1, y0, 1); 1402 SUBDIVIDE(x0, y1, 2); 1403 SUBDIVIDE(x1, y1, 3); 1404 1405#undef SUBDIVIDE 1406 } else { 1407 int min_tu_size = 1 << s->ps.sps->log2_min_tb_size; 1408 int log2_min_tu_size = s->ps.sps->log2_min_tb_size; 1409 int min_tu_width = s->ps.sps->min_tb_width; 1410 int cbf_luma = 1; 1411 1412 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 || 1413 cbf_cb[0] || cbf_cr[0] || 1414 (s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) { 1415 cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth); 1416 } 1417 1418 ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase, 1419 log2_cb_size, log2_trafo_size, 1420 blk_idx, cbf_luma, cbf_cb, cbf_cr); 1421 if (ret < 0) 1422 return ret; 1423 // TODO: store cbf_luma somewhere else 1424 if (cbf_luma) { 1425 int i, j; 1426 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size) 1427 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) { 1428 int x_tu = (x0 + j) >> log2_min_tu_size; 1429 int y_tu = (y0 + i) >> log2_min_tu_size; 1430 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1; 1431 } 1432 } 1433 if (!s->sh.disable_deblocking_filter_flag) { 1434 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size); 1435 if (s->ps.pps->transquant_bypass_enable_flag && 1436 lc->cu.cu_transquant_bypass_flag) 1437 set_deblocking_bypass(s, x0, y0, log2_trafo_size); 1438 } 1439 } 1440 return 0; 1441} 1442 1443static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size) 1444{ 1445 HEVCLocalContext *lc = s->HEVClc; 1446 GetBitContext gb; 1447 int cb_size = 1 << log2_cb_size; 1448 ptrdiff_t stride0 = s->frame->linesize[0]; 1449 ptrdiff_t stride1 = s->frame->linesize[1]; 1450 ptrdiff_t stride2 = s->frame->linesize[2]; 1451 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->ps.sps->pixel_shift)]; 1452 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)]; 1453 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)]; 1454 1455 int length = cb_size * cb_size * s->ps.sps->pcm.bit_depth + 1456 (((cb_size >> s->ps.sps->hshift[1]) * (cb_size >> s->ps.sps->vshift[1])) + 1457 ((cb_size >> s->ps.sps->hshift[2]) * (cb_size >> s->ps.sps->vshift[2]))) * 1458 s->ps.sps->pcm.bit_depth_chroma; 1459 const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3); 1460 int ret; 1461 1462 if (!s->sh.disable_deblocking_filter_flag) 1463 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size); 1464 1465 ret = init_get_bits(&gb, pcm, length); 1466 if (ret < 0) 1467 return ret; 1468 1469 s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size, &gb, s->ps.sps->pcm.bit_depth); 1470 if (s->ps.sps->chroma_format_idc) { 1471 s->hevcdsp.put_pcm(dst1, stride1, 1472 cb_size >> s->ps.sps->hshift[1], 1473 cb_size >> s->ps.sps->vshift[1], 1474 &gb, s->ps.sps->pcm.bit_depth_chroma); 1475 s->hevcdsp.put_pcm(dst2, stride2, 1476 cb_size >> s->ps.sps->hshift[2], 1477 cb_size >> s->ps.sps->vshift[2], 1478 &gb, s->ps.sps->pcm.bit_depth_chroma); 1479 } 1480 1481 return 0; 1482} 1483 1484/** 1485 * 8.5.3.2.2.1 Luma sample unidirectional interpolation process 1486 * 1487 * @param s HEVC decoding context 1488 * @param dst target buffer for block data at block position 1489 * @param dststride stride of the dst buffer 1490 * @param ref reference picture buffer at origin (0, 0) 1491 * @param mv motion vector (relative to block position) to get pixel data from 1492 * @param x_off horizontal position of block from origin (0, 0) 1493 * @param y_off vertical position of block from origin (0, 0) 1494 * @param block_w width of block 1495 * @param block_h height of block 1496 * @param luma_weight weighting factor applied to the luma prediction 1497 * @param luma_offset additive offset applied to the luma prediction value 1498 */ 1499 1500static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride, 1501 AVFrame *ref, const Mv *mv, int x_off, int y_off, 1502 int block_w, int block_h, int luma_weight, int luma_offset) 1503{ 1504 HEVCLocalContext *lc = s->HEVClc; 1505 uint8_t *src = ref->data[0]; 1506 ptrdiff_t srcstride = ref->linesize[0]; 1507 int pic_width = s->ps.sps->width; 1508 int pic_height = s->ps.sps->height; 1509 int mx = mv->x & 3; 1510 int my = mv->y & 3; 1511 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) || 1512 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag); 1513 int idx = hevc_pel_weight[block_w]; 1514 1515 x_off += mv->x >> 2; 1516 y_off += mv->y >> 2; 1517 src += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift)); 1518 1519 if (x_off < QPEL_EXTRA_BEFORE || y_off < QPEL_EXTRA_AFTER || 1520 x_off >= pic_width - block_w - QPEL_EXTRA_AFTER || 1521 y_off >= pic_height - block_h - QPEL_EXTRA_AFTER || 1522 ref == s->frame) { 1523 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift; 1524 int offset = QPEL_EXTRA_BEFORE * srcstride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift); 1525 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift); 1526 1527 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset, 1528 edge_emu_stride, srcstride, 1529 block_w + QPEL_EXTRA, 1530 block_h + QPEL_EXTRA, 1531 x_off - QPEL_EXTRA_BEFORE, y_off - QPEL_EXTRA_BEFORE, 1532 pic_width, pic_height); 1533 src = lc->edge_emu_buffer + buf_offset; 1534 srcstride = edge_emu_stride; 1535 } 1536 1537 if (!weight_flag) 1538 s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride, src, srcstride, 1539 block_h, mx, my, block_w); 1540 else 1541 s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride, src, srcstride, 1542 block_h, s->sh.luma_log2_weight_denom, 1543 luma_weight, luma_offset, mx, my, block_w); 1544} 1545 1546/** 1547 * 8.5.3.2.2.1 Luma sample bidirectional interpolation process 1548 * 1549 * @param s HEVC decoding context 1550 * @param dst target buffer for block data at block position 1551 * @param dststride stride of the dst buffer 1552 * @param ref0 reference picture0 buffer at origin (0, 0) 1553 * @param mv0 motion vector0 (relative to block position) to get pixel data from 1554 * @param x_off horizontal position of block from origin (0, 0) 1555 * @param y_off vertical position of block from origin (0, 0) 1556 * @param block_w width of block 1557 * @param block_h height of block 1558 * @param ref1 reference picture1 buffer at origin (0, 0) 1559 * @param mv1 motion vector1 (relative to block position) to get pixel data from 1560 * @param current_mv current motion vector structure 1561 */ 1562 static void luma_mc_bi(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride, 1563 AVFrame *ref0, const Mv *mv0, int x_off, int y_off, 1564 int block_w, int block_h, AVFrame *ref1, const Mv *mv1, struct MvField *current_mv) 1565{ 1566 HEVCLocalContext *lc = s->HEVClc; 1567 ptrdiff_t src0stride = ref0->linesize[0]; 1568 ptrdiff_t src1stride = ref1->linesize[0]; 1569 int pic_width = s->ps.sps->width; 1570 int pic_height = s->ps.sps->height; 1571 int mx0 = mv0->x & 3; 1572 int my0 = mv0->y & 3; 1573 int mx1 = mv1->x & 3; 1574 int my1 = mv1->y & 3; 1575 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) || 1576 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag); 1577 int x_off0 = x_off + (mv0->x >> 2); 1578 int y_off0 = y_off + (mv0->y >> 2); 1579 int x_off1 = x_off + (mv1->x >> 2); 1580 int y_off1 = y_off + (mv1->y >> 2); 1581 int idx = hevc_pel_weight[block_w]; 1582 1583 uint8_t *src0 = ref0->data[0] + y_off0 * src0stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift); 1584 uint8_t *src1 = ref1->data[0] + y_off1 * src1stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift); 1585 1586 if (x_off0 < QPEL_EXTRA_BEFORE || y_off0 < QPEL_EXTRA_AFTER || 1587 x_off0 >= pic_width - block_w - QPEL_EXTRA_AFTER || 1588 y_off0 >= pic_height - block_h - QPEL_EXTRA_AFTER) { 1589 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift; 1590 int offset = QPEL_EXTRA_BEFORE * src0stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift); 1591 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift); 1592 1593 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset, 1594 edge_emu_stride, src0stride, 1595 block_w + QPEL_EXTRA, 1596 block_h + QPEL_EXTRA, 1597 x_off0 - QPEL_EXTRA_BEFORE, y_off0 - QPEL_EXTRA_BEFORE, 1598 pic_width, pic_height); 1599 src0 = lc->edge_emu_buffer + buf_offset; 1600 src0stride = edge_emu_stride; 1601 } 1602 1603 if (x_off1 < QPEL_EXTRA_BEFORE || y_off1 < QPEL_EXTRA_AFTER || 1604 x_off1 >= pic_width - block_w - QPEL_EXTRA_AFTER || 1605 y_off1 >= pic_height - block_h - QPEL_EXTRA_AFTER) { 1606 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift; 1607 int offset = QPEL_EXTRA_BEFORE * src1stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift); 1608 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift); 1609 1610 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src1 - offset, 1611 edge_emu_stride, src1stride, 1612 block_w + QPEL_EXTRA, 1613 block_h + QPEL_EXTRA, 1614 x_off1 - QPEL_EXTRA_BEFORE, y_off1 - QPEL_EXTRA_BEFORE, 1615 pic_width, pic_height); 1616 src1 = lc->edge_emu_buffer2 + buf_offset; 1617 src1stride = edge_emu_stride; 1618 } 1619 1620 s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](lc->tmp, src0, src0stride, 1621 block_h, mx0, my0, block_w); 1622 if (!weight_flag) 1623 s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp, 1624 block_h, mx1, my1, block_w); 1625 else 1626 s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp, 1627 block_h, s->sh.luma_log2_weight_denom, 1628 s->sh.luma_weight_l0[current_mv->ref_idx[0]], 1629 s->sh.luma_weight_l1[current_mv->ref_idx[1]], 1630 s->sh.luma_offset_l0[current_mv->ref_idx[0]], 1631 s->sh.luma_offset_l1[current_mv->ref_idx[1]], 1632 mx1, my1, block_w); 1633 1634} 1635 1636/** 1637 * 8.5.3.2.2.2 Chroma sample uniprediction interpolation process 1638 * 1639 * @param s HEVC decoding context 1640 * @param dst1 target buffer for block data at block position (U plane) 1641 * @param dst2 target buffer for block data at block position (V plane) 1642 * @param dststride stride of the dst1 and dst2 buffers 1643 * @param ref reference picture buffer at origin (0, 0) 1644 * @param mv motion vector (relative to block position) to get pixel data from 1645 * @param x_off horizontal position of block from origin (0, 0) 1646 * @param y_off vertical position of block from origin (0, 0) 1647 * @param block_w width of block 1648 * @param block_h height of block 1649 * @param chroma_weight weighting factor applied to the chroma prediction 1650 * @param chroma_offset additive offset applied to the chroma prediction value 1651 */ 1652 1653static void chroma_mc_uni(HEVCContext *s, uint8_t *dst0, 1654 ptrdiff_t dststride, uint8_t *src0, ptrdiff_t srcstride, int reflist, 1655 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int chroma_weight, int chroma_offset) 1656{ 1657 HEVCLocalContext *lc = s->HEVClc; 1658 int pic_width = s->ps.sps->width >> s->ps.sps->hshift[1]; 1659 int pic_height = s->ps.sps->height >> s->ps.sps->vshift[1]; 1660 const Mv *mv = ¤t_mv->mv[reflist]; 1661 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) || 1662 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag); 1663 int idx = hevc_pel_weight[block_w]; 1664 int hshift = s->ps.sps->hshift[1]; 1665 int vshift = s->ps.sps->vshift[1]; 1666 intptr_t mx = av_mod_uintp2(mv->x, 2 + hshift); 1667 intptr_t my = av_mod_uintp2(mv->y, 2 + vshift); 1668 intptr_t _mx = mx << (1 - hshift); 1669 intptr_t _my = my << (1 - vshift); 1670 int emu = src0 == s->frame->data[1] || src0 == s->frame->data[2]; 1671 1672 x_off += mv->x >> (2 + hshift); 1673 y_off += mv->y >> (2 + vshift); 1674 src0 += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift)); 1675 1676 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER || 1677 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER || 1678 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER || 1679 emu) { 1680 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift; 1681 int offset0 = EPEL_EXTRA_BEFORE * (srcstride + (1 << s->ps.sps->pixel_shift)); 1682 int buf_offset0 = EPEL_EXTRA_BEFORE * 1683 (edge_emu_stride + (1 << s->ps.sps->pixel_shift)); 1684 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset0, 1685 edge_emu_stride, srcstride, 1686 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA, 1687 x_off - EPEL_EXTRA_BEFORE, 1688 y_off - EPEL_EXTRA_BEFORE, 1689 pic_width, pic_height); 1690 1691 src0 = lc->edge_emu_buffer + buf_offset0; 1692 srcstride = edge_emu_stride; 1693 } 1694 if (!weight_flag) 1695 s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride, src0, srcstride, 1696 block_h, _mx, _my, block_w); 1697 else 1698 s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride, src0, srcstride, 1699 block_h, s->sh.chroma_log2_weight_denom, 1700 chroma_weight, chroma_offset, _mx, _my, block_w); 1701} 1702 1703/** 1704 * 8.5.3.2.2.2 Chroma sample bidirectional interpolation process 1705 * 1706 * @param s HEVC decoding context 1707 * @param dst target buffer for block data at block position 1708 * @param dststride stride of the dst buffer 1709 * @param ref0 reference picture0 buffer at origin (0, 0) 1710 * @param mv0 motion vector0 (relative to block position) to get pixel data from 1711 * @param x_off horizontal position of block from origin (0, 0) 1712 * @param y_off vertical position of block from origin (0, 0) 1713 * @param block_w width of block 1714 * @param block_h height of block 1715 * @param ref1 reference picture1 buffer at origin (0, 0) 1716 * @param mv1 motion vector1 (relative to block position) to get pixel data from 1717 * @param current_mv current motion vector structure 1718 * @param cidx chroma component(cb, cr) 1719 */ 1720static void chroma_mc_bi(HEVCContext *s, uint8_t *dst0, ptrdiff_t dststride, AVFrame *ref0, AVFrame *ref1, 1721 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int cidx) 1722{ 1723 HEVCLocalContext *lc = s->HEVClc; 1724 uint8_t *src1 = ref0->data[cidx+1]; 1725 uint8_t *src2 = ref1->data[cidx+1]; 1726 ptrdiff_t src1stride = ref0->linesize[cidx+1]; 1727 ptrdiff_t src2stride = ref1->linesize[cidx+1]; 1728 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) || 1729 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag); 1730 int pic_width = s->ps.sps->width >> s->ps.sps->hshift[1]; 1731 int pic_height = s->ps.sps->height >> s->ps.sps->vshift[1]; 1732 Mv *mv0 = ¤t_mv->mv[0]; 1733 Mv *mv1 = ¤t_mv->mv[1]; 1734 int hshift = s->ps.sps->hshift[1]; 1735 int vshift = s->ps.sps->vshift[1]; 1736 1737 intptr_t mx0 = av_mod_uintp2(mv0->x, 2 + hshift); 1738 intptr_t my0 = av_mod_uintp2(mv0->y, 2 + vshift); 1739 intptr_t mx1 = av_mod_uintp2(mv1->x, 2 + hshift); 1740 intptr_t my1 = av_mod_uintp2(mv1->y, 2 + vshift); 1741 intptr_t _mx0 = mx0 << (1 - hshift); 1742 intptr_t _my0 = my0 << (1 - vshift); 1743 intptr_t _mx1 = mx1 << (1 - hshift); 1744 intptr_t _my1 = my1 << (1 - vshift); 1745 1746 int x_off0 = x_off + (mv0->x >> (2 + hshift)); 1747 int y_off0 = y_off + (mv0->y >> (2 + vshift)); 1748 int x_off1 = x_off + (mv1->x >> (2 + hshift)); 1749 int y_off1 = y_off + (mv1->y >> (2 + vshift)); 1750 int idx = hevc_pel_weight[block_w]; 1751 src1 += y_off0 * src1stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift); 1752 src2 += y_off1 * src2stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift); 1753 1754 if (x_off0 < EPEL_EXTRA_BEFORE || y_off0 < EPEL_EXTRA_AFTER || 1755 x_off0 >= pic_width - block_w - EPEL_EXTRA_AFTER || 1756 y_off0 >= pic_height - block_h - EPEL_EXTRA_AFTER) { 1757 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift; 1758 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->ps.sps->pixel_shift)); 1759 int buf_offset1 = EPEL_EXTRA_BEFORE * 1760 (edge_emu_stride + (1 << s->ps.sps->pixel_shift)); 1761 1762 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1, 1763 edge_emu_stride, src1stride, 1764 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA, 1765 x_off0 - EPEL_EXTRA_BEFORE, 1766 y_off0 - EPEL_EXTRA_BEFORE, 1767 pic_width, pic_height); 1768 1769 src1 = lc->edge_emu_buffer + buf_offset1; 1770 src1stride = edge_emu_stride; 1771 } 1772 1773 if (x_off1 < EPEL_EXTRA_BEFORE || y_off1 < EPEL_EXTRA_AFTER || 1774 x_off1 >= pic_width - block_w - EPEL_EXTRA_AFTER || 1775 y_off1 >= pic_height - block_h - EPEL_EXTRA_AFTER) { 1776 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift; 1777 int offset1 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->ps.sps->pixel_shift)); 1778 int buf_offset1 = EPEL_EXTRA_BEFORE * 1779 (edge_emu_stride + (1 << s->ps.sps->pixel_shift)); 1780 1781 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src2 - offset1, 1782 edge_emu_stride, src2stride, 1783 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA, 1784 x_off1 - EPEL_EXTRA_BEFORE, 1785 y_off1 - EPEL_EXTRA_BEFORE, 1786 pic_width, pic_height); 1787 1788 src2 = lc->edge_emu_buffer2 + buf_offset1; 1789 src2stride = edge_emu_stride; 1790 } 1791 1792 s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](lc->tmp, src1, src1stride, 1793 block_h, _mx0, _my0, block_w); 1794 if (!weight_flag) 1795 s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1], 1796 src2, src2stride, lc->tmp, 1797 block_h, _mx1, _my1, block_w); 1798 else 1799 s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1], 1800 src2, src2stride, lc->tmp, 1801 block_h, 1802 s->sh.chroma_log2_weight_denom, 1803 s->sh.chroma_weight_l0[current_mv->ref_idx[0]][cidx], 1804 s->sh.chroma_weight_l1[current_mv->ref_idx[1]][cidx], 1805 s->sh.chroma_offset_l0[current_mv->ref_idx[0]][cidx], 1806 s->sh.chroma_offset_l1[current_mv->ref_idx[1]][cidx], 1807 _mx1, _my1, block_w); 1808} 1809 1810static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref, 1811 const Mv *mv, int y0, int height) 1812{ 1813 if (s->threads_type == FF_THREAD_FRAME ) { 1814 int y = FFMAX(0, (mv->y >> 2) + y0 + height + 9); 1815 1816 ff_thread_await_progress(&ref->tf, y, 0); 1817 } 1818} 1819 1820static void hevc_luma_mv_mvp_mode(HEVCContext *s, int x0, int y0, int nPbW, 1821 int nPbH, int log2_cb_size, int part_idx, 1822 int merge_idx, MvField *mv) 1823{ 1824 HEVCLocalContext *lc = s->HEVClc; 1825 enum InterPredIdc inter_pred_idc = PRED_L0; 1826 int mvp_flag; 1827 1828 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH); 1829 mv->pred_flag = 0; 1830 if (s->sh.slice_type == HEVC_SLICE_B) 1831 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH); 1832 1833 if (inter_pred_idc != PRED_L1) { 1834 if (s->sh.nb_refs[L0]) 1835 mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]); 1836 1837 mv->pred_flag = PF_L0; 1838 ff_hevc_hls_mvd_coding(s, x0, y0, 0); 1839 mvp_flag = ff_hevc_mvp_lx_flag_decode(s); 1840 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size, 1841 part_idx, merge_idx, mv, mvp_flag, 0); 1842 mv->mv[0].x += lc->pu.mvd.x; 1843 mv->mv[0].y += lc->pu.mvd.y; 1844 } 1845 1846 if (inter_pred_idc != PRED_L0) { 1847 if (s->sh.nb_refs[L1]) 1848 mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]); 1849 1850 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) { 1851 AV_ZERO32(&lc->pu.mvd); 1852 } else { 1853 ff_hevc_hls_mvd_coding(s, x0, y0, 1); 1854 } 1855 1856 mv->pred_flag += PF_L1; 1857 mvp_flag = ff_hevc_mvp_lx_flag_decode(s); 1858 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size, 1859 part_idx, merge_idx, mv, mvp_flag, 1); 1860 mv->mv[1].x += lc->pu.mvd.x; 1861 mv->mv[1].y += lc->pu.mvd.y; 1862 } 1863} 1864 1865static void hls_prediction_unit(HEVCContext *s, int x0, int y0, 1866 int nPbW, int nPbH, 1867 int log2_cb_size, int partIdx, int idx) 1868{ 1869#define POS(c_idx, x, y) \ 1870 &s->frame->data[c_idx][((y) >> s->ps.sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \ 1871 (((x) >> s->ps.sps->hshift[c_idx]) << s->ps.sps->pixel_shift)] 1872 HEVCLocalContext *lc = s->HEVClc; 1873 int merge_idx = 0; 1874 struct MvField current_mv = {{{ 0 }}}; 1875 1876 int min_pu_width = s->ps.sps->min_pu_width; 1877 1878 MvField *tab_mvf = s->ref->tab_mvf; 1879 RefPicList *refPicList = s->ref->refPicList; 1880 HEVCFrame *ref0 = NULL, *ref1 = NULL; 1881 uint8_t *dst0 = POS(0, x0, y0); 1882 uint8_t *dst1 = POS(1, x0, y0); 1883 uint8_t *dst2 = POS(2, x0, y0); 1884 int log2_min_cb_size = s->ps.sps->log2_min_cb_size; 1885 int min_cb_width = s->ps.sps->min_cb_width; 1886 int x_cb = x0 >> log2_min_cb_size; 1887 int y_cb = y0 >> log2_min_cb_size; 1888 int x_pu, y_pu; 1889 int i, j; 1890 1891 int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb); 1892 1893 if (!skip_flag) 1894 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s); 1895 1896 if (skip_flag || lc->pu.merge_flag) { 1897 if (s->sh.max_num_merge_cand > 1) 1898 merge_idx = ff_hevc_merge_idx_decode(s); 1899 else 1900 merge_idx = 0; 1901 1902 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size, 1903 partIdx, merge_idx, ¤t_mv); 1904 } else { 1905 hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size, 1906 partIdx, merge_idx, ¤t_mv); 1907 } 1908 1909 x_pu = x0 >> s->ps.sps->log2_min_pu_size; 1910 y_pu = y0 >> s->ps.sps->log2_min_pu_size; 1911 1912 for (j = 0; j < nPbH >> s->ps.sps->log2_min_pu_size; j++) 1913 for (i = 0; i < nPbW >> s->ps.sps->log2_min_pu_size; i++) 1914 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv; 1915 1916 if (current_mv.pred_flag & PF_L0) { 1917 ref0 = refPicList[0].ref[current_mv.ref_idx[0]]; 1918 if (!ref0 || !ref0->frame) 1919 return; 1920 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH); 1921 } 1922 if (current_mv.pred_flag & PF_L1) { 1923 ref1 = refPicList[1].ref[current_mv.ref_idx[1]]; 1924 if (!ref1 || !ref1->frame) 1925 return; 1926 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH); 1927 } 1928 1929 if (current_mv.pred_flag == PF_L0) { 1930 int x0_c = x0 >> s->ps.sps->hshift[1]; 1931 int y0_c = y0 >> s->ps.sps->vshift[1]; 1932 int nPbW_c = nPbW >> s->ps.sps->hshift[1]; 1933 int nPbH_c = nPbH >> s->ps.sps->vshift[1]; 1934 1935 luma_mc_uni(s, dst0, s->frame->linesize[0], ref0->frame, 1936 ¤t_mv.mv[0], x0, y0, nPbW, nPbH, 1937 s->sh.luma_weight_l0[current_mv.ref_idx[0]], 1938 s->sh.luma_offset_l0[current_mv.ref_idx[0]]); 1939 1940 if (s->ps.sps->chroma_format_idc) { 1941 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref0->frame->data[1], ref0->frame->linesize[1], 1942 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1943 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]); 1944 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref0->frame->data[2], ref0->frame->linesize[2], 1945 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1946 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]); 1947 } 1948 } else if (current_mv.pred_flag == PF_L1) { 1949 int x0_c = x0 >> s->ps.sps->hshift[1]; 1950 int y0_c = y0 >> s->ps.sps->vshift[1]; 1951 int nPbW_c = nPbW >> s->ps.sps->hshift[1]; 1952 int nPbH_c = nPbH >> s->ps.sps->vshift[1]; 1953 1954 luma_mc_uni(s, dst0, s->frame->linesize[0], ref1->frame, 1955 ¤t_mv.mv[1], x0, y0, nPbW, nPbH, 1956 s->sh.luma_weight_l1[current_mv.ref_idx[1]], 1957 s->sh.luma_offset_l1[current_mv.ref_idx[1]]); 1958 1959 if (s->ps.sps->chroma_format_idc) { 1960 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1], 1961 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1962 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]); 1963 1964 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2], 1965 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1966 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]); 1967 } 1968 } else if (current_mv.pred_flag == PF_BI) { 1969 int x0_c = x0 >> s->ps.sps->hshift[1]; 1970 int y0_c = y0 >> s->ps.sps->vshift[1]; 1971 int nPbW_c = nPbW >> s->ps.sps->hshift[1]; 1972 int nPbH_c = nPbH >> s->ps.sps->vshift[1]; 1973 1974 luma_mc_bi(s, dst0, s->frame->linesize[0], ref0->frame, 1975 ¤t_mv.mv[0], x0, y0, nPbW, nPbH, 1976 ref1->frame, ¤t_mv.mv[1], ¤t_mv); 1977 1978 if (s->ps.sps->chroma_format_idc) { 1979 chroma_mc_bi(s, dst1, s->frame->linesize[1], ref0->frame, ref1->frame, 1980 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 0); 1981 1982 chroma_mc_bi(s, dst2, s->frame->linesize[2], ref0->frame, ref1->frame, 1983 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1); 1984 } 1985 } 1986} 1987 1988/** 1989 * 8.4.1 1990 */ 1991static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size, 1992 int prev_intra_luma_pred_flag) 1993{ 1994 HEVCLocalContext *lc = s->HEVClc; 1995 int x_pu = x0 >> s->ps.sps->log2_min_pu_size; 1996 int y_pu = y0 >> s->ps.sps->log2_min_pu_size; 1997 int min_pu_width = s->ps.sps->min_pu_width; 1998 int size_in_pus = pu_size >> s->ps.sps->log2_min_pu_size; 1999 int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size); 2000 int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size); 2001 2002 int cand_up = (lc->ctb_up_flag || y0b) ? 2003 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC; 2004 int cand_left = (lc->ctb_left_flag || x0b) ? 2005 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC; 2006 2007 int y_ctb = (y0 >> (s->ps.sps->log2_ctb_size)) << (s->ps.sps->log2_ctb_size); 2008 2009 MvField *tab_mvf = s->ref->tab_mvf; 2010 int intra_pred_mode; 2011 int candidate[3]; 2012 int i, j; 2013 2014 // intra_pred_mode prediction does not cross vertical CTB boundaries 2015 if ((y0 - 1) < y_ctb) 2016 cand_up = INTRA_DC; 2017 2018 if (cand_left == cand_up) { 2019 if (cand_left < 2) { 2020 candidate[0] = INTRA_PLANAR; 2021 candidate[1] = INTRA_DC; 2022 candidate[2] = INTRA_ANGULAR_26; 2023 } else { 2024 candidate[0] = cand_left; 2025 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31); 2026 candidate[2] = 2 + ((cand_left - 2 + 1) & 31); 2027 } 2028 } else { 2029 candidate[0] = cand_left; 2030 candidate[1] = cand_up; 2031 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) { 2032 candidate[2] = INTRA_PLANAR; 2033 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) { 2034 candidate[2] = INTRA_DC; 2035 } else { 2036 candidate[2] = INTRA_ANGULAR_26; 2037 } 2038 } 2039 2040 if (prev_intra_luma_pred_flag) { 2041 intra_pred_mode = candidate[lc->pu.mpm_idx]; 2042 } else { 2043 if (candidate[0] > candidate[1]) 2044 FFSWAP(uint8_t, candidate[0], candidate[1]); 2045 if (candidate[0] > candidate[2]) 2046 FFSWAP(uint8_t, candidate[0], candidate[2]); 2047 if (candidate[1] > candidate[2]) 2048 FFSWAP(uint8_t, candidate[1], candidate[2]); 2049 2050 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode; 2051 for (i = 0; i < 3; i++) 2052 if (intra_pred_mode >= candidate[i]) 2053 intra_pred_mode++; 2054 } 2055 2056 /* write the intra prediction units into the mv array */ 2057 if (!size_in_pus) 2058 size_in_pus = 1; 2059 for (i = 0; i < size_in_pus; i++) { 2060 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu], 2061 intra_pred_mode, size_in_pus); 2062 2063 for (j = 0; j < size_in_pus; j++) { 2064 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag = PF_INTRA; 2065 } 2066 } 2067 2068 return intra_pred_mode; 2069} 2070 2071static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0, 2072 int log2_cb_size, int ct_depth) 2073{ 2074 int length = (1 << log2_cb_size) >> s->ps.sps->log2_min_cb_size; 2075 int x_cb = x0 >> s->ps.sps->log2_min_cb_size; 2076 int y_cb = y0 >> s->ps.sps->log2_min_cb_size; 2077 int y; 2078 2079 for (y = 0; y < length; y++) 2080 memset(&s->tab_ct_depth[(y_cb + y) * s->ps.sps->min_cb_width + x_cb], 2081 ct_depth, length); 2082} 2083 2084static const uint8_t tab_mode_idx[] = { 2085 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20, 2086 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31}; 2087 2088static void intra_prediction_unit(HEVCContext *s, int x0, int y0, 2089 int log2_cb_size) 2090{ 2091 HEVCLocalContext *lc = s->HEVClc; 2092 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 }; 2093 uint8_t prev_intra_luma_pred_flag[4]; 2094 int split = lc->cu.part_mode == PART_NxN; 2095 int pb_size = (1 << log2_cb_size) >> split; 2096 int side = split + 1; 2097 int chroma_mode; 2098 int i, j; 2099 2100 for (i = 0; i < side; i++) 2101 for (j = 0; j < side; j++) 2102 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s); 2103 2104 for (i = 0; i < side; i++) { 2105 for (j = 0; j < side; j++) { 2106 if (prev_intra_luma_pred_flag[2 * i + j]) 2107 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s); 2108 else 2109 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s); 2110 2111 lc->pu.intra_pred_mode[2 * i + j] = 2112 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size, 2113 prev_intra_luma_pred_flag[2 * i + j]); 2114 } 2115 } 2116 2117 if (s->ps.sps->chroma_format_idc == 3) { 2118 for (i = 0; i < side; i++) { 2119 for (j = 0; j < side; j++) { 2120 lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s); 2121 if (chroma_mode != 4) { 2122 if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode]) 2123 lc->pu.intra_pred_mode_c[2 * i + j] = 34; 2124 else 2125 lc->pu.intra_pred_mode_c[2 * i + j] = intra_chroma_table[chroma_mode]; 2126 } else { 2127 lc->pu.intra_pred_mode_c[2 * i + j] = lc->pu.intra_pred_mode[2 * i + j]; 2128 } 2129 } 2130 } 2131 } else if (s->ps.sps->chroma_format_idc == 2) { 2132 int mode_idx; 2133 lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s); 2134 if (chroma_mode != 4) { 2135 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode]) 2136 mode_idx = 34; 2137 else 2138 mode_idx = intra_chroma_table[chroma_mode]; 2139 } else { 2140 mode_idx = lc->pu.intra_pred_mode[0]; 2141 } 2142 lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx]; 2143 } else if (s->ps.sps->chroma_format_idc != 0) { 2144 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s); 2145 if (chroma_mode != 4) { 2146 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode]) 2147 lc->pu.intra_pred_mode_c[0] = 34; 2148 else 2149 lc->pu.intra_pred_mode_c[0] = intra_chroma_table[chroma_mode]; 2150 } else { 2151 lc->pu.intra_pred_mode_c[0] = lc->pu.intra_pred_mode[0]; 2152 } 2153 } 2154} 2155 2156static void intra_prediction_unit_default_value(HEVCContext *s, 2157 int x0, int y0, 2158 int log2_cb_size) 2159{ 2160 HEVCLocalContext *lc = s->HEVClc; 2161 int pb_size = 1 << log2_cb_size; 2162 int size_in_pus = pb_size >> s->ps.sps->log2_min_pu_size; 2163 int min_pu_width = s->ps.sps->min_pu_width; 2164 MvField *tab_mvf = s->ref->tab_mvf; 2165 int x_pu = x0 >> s->ps.sps->log2_min_pu_size; 2166 int y_pu = y0 >> s->ps.sps->log2_min_pu_size; 2167 int j, k; 2168 2169 if (size_in_pus == 0) 2170 size_in_pus = 1; 2171 for (j = 0; j < size_in_pus; j++) 2172 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus); 2173 if (lc->cu.pred_mode == MODE_INTRA) 2174 for (j = 0; j < size_in_pus; j++) 2175 for (k = 0; k < size_in_pus; k++) 2176 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].pred_flag = PF_INTRA; 2177} 2178 2179static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size) 2180{ 2181 int cb_size = 1 << log2_cb_size; 2182 HEVCLocalContext *lc = s->HEVClc; 2183 int log2_min_cb_size = s->ps.sps->log2_min_cb_size; 2184 int length = cb_size >> log2_min_cb_size; 2185 int min_cb_width = s->ps.sps->min_cb_width; 2186 int x_cb = x0 >> log2_min_cb_size; 2187 int y_cb = y0 >> log2_min_cb_size; 2188 int idx = log2_cb_size - 2; 2189 int qp_block_mask = (1<<(s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth)) - 1; 2190 int x, y, ret; 2191 2192 lc->cu.x = x0; 2193 lc->cu.y = y0; 2194 lc->cu.pred_mode = MODE_INTRA; 2195 lc->cu.part_mode = PART_2Nx2N; 2196 lc->cu.intra_split_flag = 0; 2197 2198 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0; 2199 for (x = 0; x < 4; x++) 2200 lc->pu.intra_pred_mode[x] = 1; 2201 if (s->ps.pps->transquant_bypass_enable_flag) { 2202 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s); 2203 if (lc->cu.cu_transquant_bypass_flag) 2204 set_deblocking_bypass(s, x0, y0, log2_cb_size); 2205 } else 2206 lc->cu.cu_transquant_bypass_flag = 0; 2207 2208 if (s->sh.slice_type != HEVC_SLICE_I) { 2209 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb); 2210 2211 x = y_cb * min_cb_width + x_cb; 2212 for (y = 0; y < length; y++) { 2213 memset(&s->skip_flag[x], skip_flag, length); 2214 x += min_cb_width; 2215 } 2216 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER; 2217 } else { 2218 x = y_cb * min_cb_width + x_cb; 2219 for (y = 0; y < length; y++) { 2220 memset(&s->skip_flag[x], 0, length); 2221 x += min_cb_width; 2222 } 2223 } 2224 2225 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) { 2226 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx); 2227 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size); 2228 2229 if (!s->sh.disable_deblocking_filter_flag) 2230 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size); 2231 } else { 2232 int pcm_flag = 0; 2233 2234 if (s->sh.slice_type != HEVC_SLICE_I) 2235 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s); 2236 if (lc->cu.pred_mode != MODE_INTRA || 2237 log2_cb_size == s->ps.sps->log2_min_cb_size) { 2238 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size); 2239 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN && 2240 lc->cu.pred_mode == MODE_INTRA; 2241 } 2242 2243 if (lc->cu.pred_mode == MODE_INTRA) { 2244 if (lc->cu.part_mode == PART_2Nx2N && s->ps.sps->pcm_enabled_flag && 2245 log2_cb_size >= s->ps.sps->pcm.log2_min_pcm_cb_size && 2246 log2_cb_size <= s->ps.sps->pcm.log2_max_pcm_cb_size) { 2247 pcm_flag = ff_hevc_pcm_flag_decode(s); 2248 } 2249 if (pcm_flag) { 2250 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size); 2251 ret = hls_pcm_sample(s, x0, y0, log2_cb_size); 2252 if (s->ps.sps->pcm.loop_filter_disable_flag) 2253 set_deblocking_bypass(s, x0, y0, log2_cb_size); 2254 2255 if (ret < 0) 2256 return ret; 2257 } else { 2258 intra_prediction_unit(s, x0, y0, log2_cb_size); 2259 } 2260 } else { 2261 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size); 2262 switch (lc->cu.part_mode) { 2263 case PART_2Nx2N: 2264 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx); 2265 break; 2266 case PART_2NxN: 2267 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0, idx); 2268 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx); 2269 break; 2270 case PART_Nx2N: 2271 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1); 2272 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1); 2273 break; 2274 case PART_2NxnU: 2275 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0, idx); 2276 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx); 2277 break; 2278 case PART_2NxnD: 2279 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx); 2280 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx); 2281 break; 2282 case PART_nLx2N: 2283 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0, idx - 2); 2284 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2); 2285 break; 2286 case PART_nRx2N: 2287 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2); 2288 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2); 2289 break; 2290 case PART_NxN: 2291 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1); 2292 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1); 2293 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1); 2294 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1); 2295 break; 2296 } 2297 } 2298 2299 if (!pcm_flag) { 2300 int rqt_root_cbf = 1; 2301 2302 if (lc->cu.pred_mode != MODE_INTRA && 2303 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) { 2304 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s); 2305 } 2306 if (rqt_root_cbf) { 2307 const static int cbf[2] = { 0 }; 2308 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ? 2309 s->ps.sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag : 2310 s->ps.sps->max_transform_hierarchy_depth_inter; 2311 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0, 2312 log2_cb_size, 2313 log2_cb_size, 0, 0, cbf, cbf); 2314 if (ret < 0) 2315 return ret; 2316 } else { 2317 if (!s->sh.disable_deblocking_filter_flag) 2318 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size); 2319 } 2320 } 2321 } 2322 2323 if (s->ps.pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0) 2324 ff_hevc_set_qPy(s, x0, y0, log2_cb_size); 2325 2326 x = y_cb * min_cb_width + x_cb; 2327 for (y = 0; y < length; y++) { 2328 memset(&s->qp_y_tab[x], lc->qp_y, length); 2329 x += min_cb_width; 2330 } 2331 2332 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 && 2333 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) { 2334 lc->qPy_pred = lc->qp_y; 2335 } 2336 2337 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct_depth); 2338 2339 return 0; 2340} 2341 2342static int hls_coding_quadtree(HEVCContext *s, int x0, int y0, 2343 int log2_cb_size, int cb_depth) 2344{ 2345 HEVCLocalContext *lc = s->HEVClc; 2346 const int cb_size = 1 << log2_cb_size; 2347 int ret; 2348 int split_cu; 2349 2350 lc->ct_depth = cb_depth; 2351 if (x0 + cb_size <= s->ps.sps->width && 2352 y0 + cb_size <= s->ps.sps->height && 2353 log2_cb_size > s->ps.sps->log2_min_cb_size) { 2354 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0); 2355 } else { 2356 split_cu = (log2_cb_size > s->ps.sps->log2_min_cb_size); 2357 } 2358 if (s->ps.pps->cu_qp_delta_enabled_flag && 2359 log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth) { 2360 lc->tu.is_cu_qp_delta_coded = 0; 2361 lc->tu.cu_qp_delta = 0; 2362 } 2363 2364 if (s->sh.cu_chroma_qp_offset_enabled_flag && 2365 log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_chroma_qp_offset_depth) { 2366 lc->tu.is_cu_chroma_qp_offset_coded = 0; 2367 } 2368 2369 if (split_cu) { 2370 int qp_block_mask = (1<<(s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth)) - 1; 2371 const int cb_size_split = cb_size >> 1; 2372 const int x1 = x0 + cb_size_split; 2373 const int y1 = y0 + cb_size_split; 2374 2375 int more_data = 0; 2376 2377 more_data = hls_coding_quadtree(s, x0, y0, log2_cb_size - 1, cb_depth + 1); 2378 if (more_data < 0) 2379 return more_data; 2380 2381 if (more_data && x1 < s->ps.sps->width) { 2382 more_data = hls_coding_quadtree(s, x1, y0, log2_cb_size - 1, cb_depth + 1); 2383 if (more_data < 0) 2384 return more_data; 2385 } 2386 if (more_data && y1 < s->ps.sps->height) { 2387 more_data = hls_coding_quadtree(s, x0, y1, log2_cb_size - 1, cb_depth + 1); 2388 if (more_data < 0) 2389 return more_data; 2390 } 2391 if (more_data && x1 < s->ps.sps->width && 2392 y1 < s->ps.sps->height) { 2393 more_data = hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1); 2394 if (more_data < 0) 2395 return more_data; 2396 } 2397 2398 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 && 2399 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) 2400 lc->qPy_pred = lc->qp_y; 2401 2402 if (more_data) 2403 return ((x1 + cb_size_split) < s->ps.sps->width || 2404 (y1 + cb_size_split) < s->ps.sps->height); 2405 else 2406 return 0; 2407 } else { 2408 ret = hls_coding_unit(s, x0, y0, log2_cb_size); 2409 if (ret < 0) 2410 return ret; 2411 if ((!((x0 + cb_size) % 2412 (1 << (s->ps.sps->log2_ctb_size))) || 2413 (x0 + cb_size >= s->ps.sps->width)) && 2414 (!((y0 + cb_size) % 2415 (1 << (s->ps.sps->log2_ctb_size))) || 2416 (y0 + cb_size >= s->ps.sps->height))) { 2417 int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s); 2418 return !end_of_slice_flag; 2419 } else { 2420 return 1; 2421 } 2422 } 2423 2424 return 0; 2425} 2426 2427static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb, 2428 int ctb_addr_ts) 2429{ 2430 HEVCLocalContext *lc = s->HEVClc; 2431 int ctb_size = 1 << s->ps.sps->log2_ctb_size; 2432 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts]; 2433 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr; 2434 2435 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr; 2436 2437 if (s->ps.pps->entropy_coding_sync_enabled_flag) { 2438 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0) 2439 lc->first_qp_group = 1; 2440 lc->end_of_tiles_x = s->ps.sps->width; 2441 } else if (s->ps.pps->tiles_enabled_flag) { 2442 if (ctb_addr_ts && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) { 2443 int idxX = s->ps.pps->col_idxX[x_ctb >> s->ps.sps->log2_ctb_size]; 2444 lc->end_of_tiles_x = x_ctb + (s->ps.pps->column_width[idxX] << s->ps.sps->log2_ctb_size); 2445 lc->first_qp_group = 1; 2446 } 2447 } else { 2448 lc->end_of_tiles_x = s->ps.sps->width; 2449 } 2450 2451 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->ps.sps->height); 2452 2453 lc->boundary_flags = 0; 2454 if (s->ps.pps->tiles_enabled_flag) { 2455 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]]) 2456 lc->boundary_flags |= BOUNDARY_LEFT_TILE; 2457 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1]) 2458 lc->boundary_flags |= BOUNDARY_LEFT_SLICE; 2459 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]]) 2460 lc->boundary_flags |= BOUNDARY_UPPER_TILE; 2461 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->ps.sps->ctb_width]) 2462 lc->boundary_flags |= BOUNDARY_UPPER_SLICE; 2463 } else { 2464 if (ctb_addr_in_slice <= 0) 2465 lc->boundary_flags |= BOUNDARY_LEFT_SLICE; 2466 if (ctb_addr_in_slice < s->ps.sps->ctb_width) 2467 lc->boundary_flags |= BOUNDARY_UPPER_SLICE; 2468 } 2469 2470 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE)); 2471 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->ps.sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE)); 2472 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]])); 2473 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]])); 2474} 2475 2476static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread) 2477{ 2478 HEVCContext *s = avctxt->priv_data; 2479 int ctb_size = 1 << s->ps.sps->log2_ctb_size; 2480 int more_data = 1; 2481 int x_ctb = 0; 2482 int y_ctb = 0; 2483 int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs]; 2484 int ret; 2485 2486 if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) { 2487 av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n"); 2488 return AVERROR_INVALIDDATA; 2489 } 2490 2491 if (s->sh.dependent_slice_segment_flag) { 2492 int prev_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1]; 2493 if (s->tab_slice_address[prev_rs] != s->sh.slice_addr) { 2494 av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n"); 2495 return AVERROR_INVALIDDATA; 2496 } 2497 } 2498 2499 while (more_data && ctb_addr_ts < s->ps.sps->ctb_size) { 2500 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts]; 2501 2502 x_ctb = (ctb_addr_rs % ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size; 2503 y_ctb = (ctb_addr_rs / ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size; 2504 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts); 2505 2506 ret = ff_hevc_cabac_init(s, ctb_addr_ts, 0); 2507 if (ret < 0) { 2508 s->tab_slice_address[ctb_addr_rs] = -1; 2509 return ret; 2510 } 2511 2512 hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size); 2513 2514 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset; 2515 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset; 2516 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag; 2517 2518 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0); 2519 if (more_data < 0) { 2520 s->tab_slice_address[ctb_addr_rs] = -1; 2521 return more_data; 2522 } 2523 2524 2525 ctb_addr_ts++; 2526 ff_hevc_save_states(s, ctb_addr_ts); 2527 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size); 2528 } 2529 2530 if (x_ctb + ctb_size >= s->ps.sps->width && 2531 y_ctb + ctb_size >= s->ps.sps->height) 2532 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size); 2533 2534 return ctb_addr_ts; 2535} 2536 2537static int hls_slice_data(HEVCContext *s) 2538{ 2539 int arg[2]; 2540 int ret[2]; 2541 2542 arg[0] = 0; 2543 arg[1] = 1; 2544 2545 s->avctx->execute(s->avctx, hls_decode_entry, arg, ret , 1, sizeof(int)); 2546 return ret[0]; 2547} 2548static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int job, int self_id) 2549{ 2550 HEVCContext *s1 = avctxt->priv_data, *s; 2551 HEVCLocalContext *lc; 2552 int ctb_size = 1<< s1->ps.sps->log2_ctb_size; 2553 int more_data = 1; 2554 int *ctb_row_p = input_ctb_row; 2555 int ctb_row = ctb_row_p[job]; 2556 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); 2557 int ctb_addr_ts = s1->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs]; 2558 int thread = ctb_row % s1->threads_number; 2559 int ret; 2560 2561 s = s1->sList[self_id]; 2562 lc = s->HEVClc; 2563 2564 if(ctb_row) { 2565 ret = init_get_bits8(&lc->gb, s->data + s->sh.offset[ctb_row - 1], s->sh.size[ctb_row - 1]); 2566 if (ret < 0) 2567 goto error; 2568 ff_init_cabac_decoder(&lc->cc, s->data + s->sh.offset[(ctb_row)-1], s->sh.size[ctb_row - 1]); 2569 } 2570 2571 while(more_data && ctb_addr_ts < s->ps.sps->ctb_size) { 2572 int x_ctb = (ctb_addr_rs % s->ps.sps->ctb_width) << s->ps.sps->log2_ctb_size; 2573 int y_ctb = (ctb_addr_rs / s->ps.sps->ctb_width) << s->ps.sps->log2_ctb_size; 2574 2575 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts); 2576 2577 ff_thread_await_progress2(s->avctx, ctb_row, thread, SHIFT_CTB_WPP); 2578 2579 if (atomic_load(&s1->wpp_err)) { 2580 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP); 2581 return 0; 2582 } 2583 2584 ret = ff_hevc_cabac_init(s, ctb_addr_ts, thread); 2585 if (ret < 0) 2586 goto error; 2587 hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size); 2588 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0); 2589 2590 if (more_data < 0) { 2591 ret = more_data; 2592 goto error; 2593 } 2594 2595 ctb_addr_ts++; 2596 2597 ff_hevc_save_states(s, ctb_addr_ts); 2598 ff_thread_report_progress2(s->avctx, ctb_row, thread, 1); 2599 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size); 2600 2601 if (!more_data && (x_ctb+ctb_size) < s->ps.sps->width && ctb_row != s->sh.num_entry_point_offsets) { 2602 atomic_store(&s1->wpp_err, 1); 2603 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP); 2604 return 0; 2605 } 2606 2607 if ((x_ctb+ctb_size) >= s->ps.sps->width && (y_ctb+ctb_size) >= s->ps.sps->height ) { 2608 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size); 2609 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP); 2610 return ctb_addr_ts; 2611 } 2612 ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts]; 2613 x_ctb+=ctb_size; 2614 2615 if(x_ctb >= s->ps.sps->width) { 2616 break; 2617 } 2618 } 2619 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP); 2620 2621 return 0; 2622error: 2623 s->tab_slice_address[ctb_addr_rs] = -1; 2624 atomic_store(&s1->wpp_err, 1); 2625 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP); 2626 return ret; 2627} 2628 2629static int hls_slice_data_wpp(HEVCContext *s, const H2645NAL *nal) 2630{ 2631 const uint8_t *data = nal->data; 2632 int length = nal->size; 2633 HEVCLocalContext *lc = s->HEVClc; 2634 int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int)); 2635 int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int)); 2636 int64_t offset; 2637 int64_t startheader, cmpt = 0; 2638 int i, j, res = 0; 2639 2640 if (!ret || !arg) { 2641 av_free(ret); 2642 av_free(arg); 2643 return AVERROR(ENOMEM); 2644 } 2645 2646 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) { 2647 av_log(s->avctx, AV_LOG_ERROR, "WPP ctb addresses are wrong (%d %d %d %d)\n", 2648 s->sh.slice_ctb_addr_rs, s->sh.num_entry_point_offsets, 2649 s->ps.sps->ctb_width, s->ps.sps->ctb_height 2650 ); 2651 res = AVERROR_INVALIDDATA; 2652 goto error; 2653 } 2654 2655 ff_alloc_entries(s->avctx, s->sh.num_entry_point_offsets + 1); 2656 2657 for (i = 1; i < s->threads_number; i++) { 2658 if (s->sList[i] && s->HEVClcList[i]) 2659 continue; 2660 av_freep(&s->sList[i]); 2661 av_freep(&s->HEVClcList[i]); 2662 s->sList[i] = av_malloc(sizeof(HEVCContext)); 2663 s->HEVClcList[i] = av_mallocz(sizeof(HEVCLocalContext)); 2664 if (!s->sList[i] || !s->HEVClcList[i]) { 2665 res = AVERROR(ENOMEM); 2666 goto error; 2667 } 2668 memcpy(s->sList[i], s, sizeof(HEVCContext)); 2669 s->sList[i]->HEVClc = s->HEVClcList[i]; 2670 } 2671 2672 offset = (lc->gb.index >> 3); 2673 2674 for (j = 0, cmpt = 0, startheader = offset + s->sh.entry_point_offset[0]; j < nal->skipped_bytes; j++) { 2675 if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) { 2676 startheader--; 2677 cmpt++; 2678 } 2679 } 2680 2681 for (i = 1; i < s->sh.num_entry_point_offsets; i++) { 2682 offset += (s->sh.entry_point_offset[i - 1] - cmpt); 2683 for (j = 0, cmpt = 0, startheader = offset 2684 + s->sh.entry_point_offset[i]; j < nal->skipped_bytes; j++) { 2685 if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) { 2686 startheader--; 2687 cmpt++; 2688 } 2689 } 2690 s->sh.size[i - 1] = s->sh.entry_point_offset[i] - cmpt; 2691 s->sh.offset[i - 1] = offset; 2692 2693 } 2694 if (s->sh.num_entry_point_offsets != 0) { 2695 offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt; 2696 if (length < offset) { 2697 av_log(s->avctx, AV_LOG_ERROR, "entry_point_offset table is corrupted\n"); 2698 res = AVERROR_INVALIDDATA; 2699 goto error; 2700 } 2701 s->sh.size[s->sh.num_entry_point_offsets - 1] = length - offset; 2702 s->sh.offset[s->sh.num_entry_point_offsets - 1] = offset; 2703 2704 } 2705 s->data = data; 2706 2707 for (i = 1; i < s->threads_number; i++) { 2708 s->sList[i]->HEVClc->first_qp_group = 1; 2709 s->sList[i]->HEVClc->qp_y = s->sList[0]->HEVClc->qp_y; 2710 memcpy(s->sList[i], s, sizeof(HEVCContext)); 2711 s->sList[i]->HEVClc = s->HEVClcList[i]; 2712 } 2713 2714 atomic_store(&s->wpp_err, 0); 2715 ff_reset_entries(s->avctx); 2716 2717 for (i = 0; i <= s->sh.num_entry_point_offsets; i++) { 2718 arg[i] = i; 2719 ret[i] = 0; 2720 } 2721 2722 if (s->ps.pps->entropy_coding_sync_enabled_flag) 2723 s->avctx->execute2(s->avctx, hls_decode_entry_wpp, arg, ret, s->sh.num_entry_point_offsets + 1); 2724 2725 for (i = 0; i <= s->sh.num_entry_point_offsets; i++) 2726 res += ret[i]; 2727error: 2728 av_free(ret); 2729 av_free(arg); 2730 return res; 2731} 2732 2733static int set_side_data(HEVCContext *s) 2734{ 2735 AVFrame *out = s->ref->frame; 2736 int ret; 2737 2738 if (s->sei.frame_packing.present && 2739 s->sei.frame_packing.arrangement_type >= 3 && 2740 s->sei.frame_packing.arrangement_type <= 5 && 2741 s->sei.frame_packing.content_interpretation_type > 0 && 2742 s->sei.frame_packing.content_interpretation_type < 3) { 2743 AVStereo3D *stereo = av_stereo3d_create_side_data(out); 2744 if (!stereo) 2745 return AVERROR(ENOMEM); 2746 2747 switch (s->sei.frame_packing.arrangement_type) { 2748 case 3: 2749 if (s->sei.frame_packing.quincunx_subsampling) 2750 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX; 2751 else 2752 stereo->type = AV_STEREO3D_SIDEBYSIDE; 2753 break; 2754 case 4: 2755 stereo->type = AV_STEREO3D_TOPBOTTOM; 2756 break; 2757 case 5: 2758 stereo->type = AV_STEREO3D_FRAMESEQUENCE; 2759 break; 2760 } 2761 2762 if (s->sei.frame_packing.content_interpretation_type == 2) 2763 stereo->flags = AV_STEREO3D_FLAG_INVERT; 2764 2765 if (s->sei.frame_packing.arrangement_type == 5) { 2766 if (s->sei.frame_packing.current_frame_is_frame0_flag) 2767 stereo->view = AV_STEREO3D_VIEW_LEFT; 2768 else 2769 stereo->view = AV_STEREO3D_VIEW_RIGHT; 2770 } 2771 } 2772 2773 if (s->sei.display_orientation.present && 2774 (s->sei.display_orientation.anticlockwise_rotation || 2775 s->sei.display_orientation.hflip || s->sei.display_orientation.vflip)) { 2776 double angle = s->sei.display_orientation.anticlockwise_rotation * 360 / (double) (1 << 16); 2777 AVFrameSideData *rotation = av_frame_new_side_data(out, 2778 AV_FRAME_DATA_DISPLAYMATRIX, 2779 sizeof(int32_t) * 9); 2780 if (!rotation) 2781 return AVERROR(ENOMEM); 2782 2783 /* av_display_rotation_set() expects the angle in the clockwise 2784 * direction, hence the first minus. 2785 * The below code applies the flips after the rotation, yet 2786 * the H.2645 specs require flipping to be applied first. 2787 * Because of R O(phi) = O(-phi) R (where R is flipping around 2788 * an arbitatry axis and O(phi) is the proper rotation by phi) 2789 * we can create display matrices as desired by negating 2790 * the degree once for every flip applied. */ 2791 angle = -angle * (1 - 2 * !!s->sei.display_orientation.hflip) 2792 * (1 - 2 * !!s->sei.display_orientation.vflip); 2793 av_display_rotation_set((int32_t *)rotation->data, angle); 2794 av_display_matrix_flip((int32_t *)rotation->data, 2795 s->sei.display_orientation.hflip, 2796 s->sei.display_orientation.vflip); 2797 } 2798 2799 // Decrement the mastering display flag when IRAP frame has no_rasl_output_flag=1 2800 // so the side data persists for the entire coded video sequence. 2801 if (s->sei.mastering_display.present > 0 && 2802 IS_IRAP(s) && s->no_rasl_output_flag) { 2803 s->sei.mastering_display.present--; 2804 } 2805 if (s->sei.mastering_display.present) { 2806 // HEVC uses a g,b,r ordering, which we convert to a more natural r,g,b 2807 const int mapping[3] = {2, 0, 1}; 2808 const int chroma_den = 50000; 2809 const int luma_den = 10000; 2810 int i; 2811 AVMasteringDisplayMetadata *metadata = 2812 av_mastering_display_metadata_create_side_data(out); 2813 if (!metadata) 2814 return AVERROR(ENOMEM); 2815 2816 for (i = 0; i < 3; i++) { 2817 const int j = mapping[i]; 2818 metadata->display_primaries[i][0].num = s->sei.mastering_display.display_primaries[j][0]; 2819 metadata->display_primaries[i][0].den = chroma_den; 2820 metadata->display_primaries[i][1].num = s->sei.mastering_display.display_primaries[j][1]; 2821 metadata->display_primaries[i][1].den = chroma_den; 2822 } 2823 metadata->white_point[0].num = s->sei.mastering_display.white_point[0]; 2824 metadata->white_point[0].den = chroma_den; 2825 metadata->white_point[1].num = s->sei.mastering_display.white_point[1]; 2826 metadata->white_point[1].den = chroma_den; 2827 2828 metadata->max_luminance.num = s->sei.mastering_display.max_luminance; 2829 metadata->max_luminance.den = luma_den; 2830 metadata->min_luminance.num = s->sei.mastering_display.min_luminance; 2831 metadata->min_luminance.den = luma_den; 2832 metadata->has_luminance = 1; 2833 metadata->has_primaries = 1; 2834 2835 av_log(s->avctx, AV_LOG_DEBUG, "Mastering Display Metadata:\n"); 2836 av_log(s->avctx, AV_LOG_DEBUG, 2837 "r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f)\n", 2838 av_q2d(metadata->display_primaries[0][0]), 2839 av_q2d(metadata->display_primaries[0][1]), 2840 av_q2d(metadata->display_primaries[1][0]), 2841 av_q2d(metadata->display_primaries[1][1]), 2842 av_q2d(metadata->display_primaries[2][0]), 2843 av_q2d(metadata->display_primaries[2][1]), 2844 av_q2d(metadata->white_point[0]), av_q2d(metadata->white_point[1])); 2845 av_log(s->avctx, AV_LOG_DEBUG, 2846 "min_luminance=%f, max_luminance=%f\n", 2847 av_q2d(metadata->min_luminance), av_q2d(metadata->max_luminance)); 2848 } 2849 // Decrement the mastering display flag when IRAP frame has no_rasl_output_flag=1 2850 // so the side data persists for the entire coded video sequence. 2851 if (s->sei.content_light.present > 0 && 2852 IS_IRAP(s) && s->no_rasl_output_flag) { 2853 s->sei.content_light.present--; 2854 } 2855 if (s->sei.content_light.present) { 2856 AVContentLightMetadata *metadata = 2857 av_content_light_metadata_create_side_data(out); 2858 if (!metadata) 2859 return AVERROR(ENOMEM); 2860 metadata->MaxCLL = s->sei.content_light.max_content_light_level; 2861 metadata->MaxFALL = s->sei.content_light.max_pic_average_light_level; 2862 2863 av_log(s->avctx, AV_LOG_DEBUG, "Content Light Level Metadata:\n"); 2864 av_log(s->avctx, AV_LOG_DEBUG, "MaxCLL=%d, MaxFALL=%d\n", 2865 metadata->MaxCLL, metadata->MaxFALL); 2866 } 2867 2868 if (s->sei.a53_caption.buf_ref) { 2869 HEVCSEIA53Caption *a53 = &s->sei.a53_caption; 2870 2871 AVFrameSideData *sd = av_frame_new_side_data_from_buf(out, AV_FRAME_DATA_A53_CC, a53->buf_ref); 2872 if (!sd) 2873 av_buffer_unref(&a53->buf_ref); 2874 a53->buf_ref = NULL; 2875 } 2876 2877 for (int i = 0; i < s->sei.unregistered.nb_buf_ref; i++) { 2878 HEVCSEIUnregistered *unreg = &s->sei.unregistered; 2879 2880 if (unreg->buf_ref[i]) { 2881 AVFrameSideData *sd = av_frame_new_side_data_from_buf(out, 2882 AV_FRAME_DATA_SEI_UNREGISTERED, 2883 unreg->buf_ref[i]); 2884 if (!sd) 2885 av_buffer_unref(&unreg->buf_ref[i]); 2886 unreg->buf_ref[i] = NULL; 2887 } 2888 } 2889 s->sei.unregistered.nb_buf_ref = 0; 2890 2891 if (s->sei.timecode.present) { 2892 uint32_t *tc_sd; 2893 char tcbuf[AV_TIMECODE_STR_SIZE]; 2894 AVFrameSideData *tcside = av_frame_new_side_data(out, AV_FRAME_DATA_S12M_TIMECODE, 2895 sizeof(uint32_t) * 4); 2896 if (!tcside) 2897 return AVERROR(ENOMEM); 2898 2899 tc_sd = (uint32_t*)tcside->data; 2900 tc_sd[0] = s->sei.timecode.num_clock_ts; 2901 2902 for (int i = 0; i < tc_sd[0]; i++) { 2903 int drop = s->sei.timecode.cnt_dropped_flag[i]; 2904 int hh = s->sei.timecode.hours_value[i]; 2905 int mm = s->sei.timecode.minutes_value[i]; 2906 int ss = s->sei.timecode.seconds_value[i]; 2907 int ff = s->sei.timecode.n_frames[i]; 2908 2909 tc_sd[i + 1] = av_timecode_get_smpte(s->avctx->framerate, drop, hh, mm, ss, ff); 2910 av_timecode_make_smpte_tc_string2(tcbuf, s->avctx->framerate, tc_sd[i + 1], 0, 0); 2911 av_dict_set(&out->metadata, "timecode", tcbuf, 0); 2912 } 2913 2914 s->sei.timecode.num_clock_ts = 0; 2915 } 2916 2917 if (s->sei.film_grain_characteristics.present) { 2918 HEVCSEIFilmGrainCharacteristics *fgc = &s->sei.film_grain_characteristics; 2919 AVFilmGrainParams *fgp = av_film_grain_params_create_side_data(out); 2920 if (!fgp) 2921 return AVERROR(ENOMEM); 2922 2923 fgp->type = AV_FILM_GRAIN_PARAMS_H274; 2924 fgp->seed = s->ref->poc; /* no poc_offset in HEVC */ 2925 2926 fgp->codec.h274.model_id = fgc->model_id; 2927 if (fgc->separate_colour_description_present_flag) { 2928 fgp->codec.h274.bit_depth_luma = fgc->bit_depth_luma; 2929 fgp->codec.h274.bit_depth_chroma = fgc->bit_depth_chroma; 2930 fgp->codec.h274.color_range = fgc->full_range + 1; 2931 fgp->codec.h274.color_primaries = fgc->color_primaries; 2932 fgp->codec.h274.color_trc = fgc->transfer_characteristics; 2933 fgp->codec.h274.color_space = fgc->matrix_coeffs; 2934 } else { 2935 const HEVCSPS *sps = s->ps.sps; 2936 const VUI *vui = &sps->vui; 2937 fgp->codec.h274.bit_depth_luma = sps->bit_depth; 2938 fgp->codec.h274.bit_depth_chroma = sps->bit_depth_chroma; 2939 if (vui->video_signal_type_present_flag) 2940 fgp->codec.h274.color_range = vui->video_full_range_flag + 1; 2941 else 2942 fgp->codec.h274.color_range = AVCOL_RANGE_UNSPECIFIED; 2943 if (vui->colour_description_present_flag) { 2944 fgp->codec.h274.color_primaries = vui->colour_primaries; 2945 fgp->codec.h274.color_trc = vui->transfer_characteristic; 2946 fgp->codec.h274.color_space = vui->matrix_coeffs; 2947 } else { 2948 fgp->codec.h274.color_primaries = AVCOL_PRI_UNSPECIFIED; 2949 fgp->codec.h274.color_trc = AVCOL_TRC_UNSPECIFIED; 2950 fgp->codec.h274.color_space = AVCOL_SPC_UNSPECIFIED; 2951 } 2952 } 2953 fgp->codec.h274.blending_mode_id = fgc->blending_mode_id; 2954 fgp->codec.h274.log2_scale_factor = fgc->log2_scale_factor; 2955 2956 memcpy(&fgp->codec.h274.component_model_present, &fgc->comp_model_present_flag, 2957 sizeof(fgp->codec.h274.component_model_present)); 2958 memcpy(&fgp->codec.h274.num_intensity_intervals, &fgc->num_intensity_intervals, 2959 sizeof(fgp->codec.h274.num_intensity_intervals)); 2960 memcpy(&fgp->codec.h274.num_model_values, &fgc->num_model_values, 2961 sizeof(fgp->codec.h274.num_model_values)); 2962 memcpy(&fgp->codec.h274.intensity_interval_lower_bound, &fgc->intensity_interval_lower_bound, 2963 sizeof(fgp->codec.h274.intensity_interval_lower_bound)); 2964 memcpy(&fgp->codec.h274.intensity_interval_upper_bound, &fgc->intensity_interval_upper_bound, 2965 sizeof(fgp->codec.h274.intensity_interval_upper_bound)); 2966 memcpy(&fgp->codec.h274.comp_model_value, &fgc->comp_model_value, 2967 sizeof(fgp->codec.h274.comp_model_value)); 2968 2969 fgc->present = fgc->persistence_flag; 2970 } 2971 2972 if (s->sei.dynamic_hdr_plus.info) { 2973 AVBufferRef *info_ref = av_buffer_ref(s->sei.dynamic_hdr_plus.info); 2974 if (!info_ref) 2975 return AVERROR(ENOMEM); 2976 2977 if (!av_frame_new_side_data_from_buf(out, AV_FRAME_DATA_DYNAMIC_HDR_PLUS, info_ref)) { 2978 av_buffer_unref(&info_ref); 2979 return AVERROR(ENOMEM); 2980 } 2981 } 2982 2983 if (s->rpu_buf) { 2984 AVFrameSideData *rpu = av_frame_new_side_data_from_buf(out, AV_FRAME_DATA_DOVI_RPU_BUFFER, s->rpu_buf); 2985 if (!rpu) 2986 return AVERROR(ENOMEM); 2987 2988 s->rpu_buf = NULL; 2989 } 2990 2991 if ((ret = ff_dovi_attach_side_data(&s->dovi_ctx, out)) < 0) 2992 return ret; 2993 2994 if (s->sei.dynamic_hdr_vivid.info) { 2995 AVBufferRef *info_ref = av_buffer_ref(s->sei.dynamic_hdr_vivid.info); 2996 if (!info_ref) 2997 return AVERROR(ENOMEM); 2998 2999 if (!av_frame_new_side_data_from_buf(out, AV_FRAME_DATA_DYNAMIC_HDR_VIVID, info_ref)) { 3000 av_buffer_unref(&info_ref); 3001 return AVERROR(ENOMEM); 3002 } 3003 } 3004 3005 return 0; 3006} 3007 3008static int hevc_frame_start(HEVCContext *s) 3009{ 3010 HEVCLocalContext *lc = s->HEVClc; 3011 int pic_size_in_ctb = ((s->ps.sps->width >> s->ps.sps->log2_min_cb_size) + 1) * 3012 ((s->ps.sps->height >> s->ps.sps->log2_min_cb_size) + 1); 3013 int ret; 3014 3015 memset(s->horizontal_bs, 0, s->bs_width * s->bs_height); 3016 memset(s->vertical_bs, 0, s->bs_width * s->bs_height); 3017 memset(s->cbf_luma, 0, s->ps.sps->min_tb_width * s->ps.sps->min_tb_height); 3018 memset(s->is_pcm, 0, (s->ps.sps->min_pu_width + 1) * (s->ps.sps->min_pu_height + 1)); 3019 memset(s->tab_slice_address, -1, pic_size_in_ctb * sizeof(*s->tab_slice_address)); 3020 3021 s->is_decoded = 0; 3022 s->first_nal_type = s->nal_unit_type; 3023 3024 s->no_rasl_output_flag = IS_IDR(s) || IS_BLA(s) || (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos); 3025 3026 if (s->ps.pps->tiles_enabled_flag) 3027 lc->end_of_tiles_x = s->ps.pps->column_width[0] << s->ps.sps->log2_ctb_size; 3028 3029 ret = ff_hevc_set_new_ref(s, &s->frame, s->poc); 3030 if (ret < 0) 3031 goto fail; 3032 3033 ret = ff_hevc_frame_rps(s); 3034 if (ret < 0) { 3035 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n"); 3036 goto fail; 3037 } 3038 3039 s->ref->frame->key_frame = IS_IRAP(s); 3040 3041 s->ref->needs_fg = s->sei.film_grain_characteristics.present && 3042 !(s->avctx->export_side_data & AV_CODEC_EXPORT_DATA_FILM_GRAIN) && 3043 !s->avctx->hwaccel; 3044 3045 if (s->ref->needs_fg) { 3046 s->ref->frame_grain->format = s->ref->frame->format; 3047 s->ref->frame_grain->width = s->ref->frame->width; 3048 s->ref->frame_grain->height = s->ref->frame->height; 3049 if ((ret = ff_thread_get_buffer(s->avctx, s->ref->frame_grain, 0)) < 0) 3050 goto fail; 3051 } 3052 3053 ret = set_side_data(s); 3054 if (ret < 0) 3055 goto fail; 3056 3057 s->frame->pict_type = 3 - s->sh.slice_type; 3058 3059 if (!IS_IRAP(s)) 3060 ff_hevc_bump_frame(s); 3061 3062 av_frame_unref(s->output_frame); 3063 ret = ff_hevc_output_frame(s, s->output_frame, 0); 3064 if (ret < 0) 3065 goto fail; 3066 3067 if (!s->avctx->hwaccel) 3068 ff_thread_finish_setup(s->avctx); 3069 3070 return 0; 3071 3072fail: 3073 if (s->ref) 3074 ff_hevc_unref_frame(s, s->ref, ~0); 3075 s->ref = NULL; 3076 return ret; 3077} 3078 3079static int hevc_frame_end(HEVCContext *s) 3080{ 3081 HEVCFrame *out = s->ref; 3082 const AVFrameSideData *sd; 3083 int ret; 3084 3085 if (out->needs_fg) { 3086 sd = av_frame_get_side_data(out->frame, AV_FRAME_DATA_FILM_GRAIN_PARAMS); 3087 av_assert0(out->frame_grain->buf[0] && sd); 3088 ret = ff_h274_apply_film_grain(out->frame_grain, out->frame, &s->h274db, 3089 (AVFilmGrainParams *) sd->data); 3090 3091 if (ret < 0) { 3092 av_log(s->avctx, AV_LOG_WARNING, "Failed synthesizing film " 3093 "grain, ignoring: %s\n", av_err2str(ret)); 3094 out->needs_fg = 0; 3095 } 3096 } 3097 3098 return 0; 3099} 3100 3101static int decode_nal_unit(HEVCContext *s, const H2645NAL *nal) 3102{ 3103 HEVCLocalContext *lc = s->HEVClc; 3104 GetBitContext *gb = &lc->gb; 3105 int ctb_addr_ts, ret; 3106 3107 *gb = nal->gb; 3108 s->nal_unit_type = nal->type; 3109 s->temporal_id = nal->temporal_id; 3110 3111 switch (s->nal_unit_type) { 3112 case HEVC_NAL_VPS: 3113 if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) { 3114 ret = s->avctx->hwaccel->decode_params(s->avctx, 3115 nal->type, 3116 nal->raw_data, 3117 nal->raw_size); 3118 if (ret < 0) 3119 goto fail; 3120 } 3121 ret = ff_hevc_decode_nal_vps(gb, s->avctx, &s->ps); 3122 if (ret < 0) 3123 goto fail; 3124 break; 3125 case HEVC_NAL_SPS: 3126 if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) { 3127 ret = s->avctx->hwaccel->decode_params(s->avctx, 3128 nal->type, 3129 nal->raw_data, 3130 nal->raw_size); 3131 if (ret < 0) 3132 goto fail; 3133 } 3134 ret = ff_hevc_decode_nal_sps(gb, s->avctx, &s->ps, 3135 s->apply_defdispwin); 3136 if (ret < 0) 3137 goto fail; 3138 break; 3139 case HEVC_NAL_PPS: 3140 if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) { 3141 ret = s->avctx->hwaccel->decode_params(s->avctx, 3142 nal->type, 3143 nal->raw_data, 3144 nal->raw_size); 3145 if (ret < 0) 3146 goto fail; 3147 } 3148 ret = ff_hevc_decode_nal_pps(gb, s->avctx, &s->ps); 3149 if (ret < 0) 3150 goto fail; 3151 break; 3152 case HEVC_NAL_SEI_PREFIX: 3153 case HEVC_NAL_SEI_SUFFIX: 3154 if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) { 3155 ret = s->avctx->hwaccel->decode_params(s->avctx, 3156 nal->type, 3157 nal->raw_data, 3158 nal->raw_size); 3159 if (ret < 0) 3160 goto fail; 3161 } 3162 ret = ff_hevc_decode_nal_sei(gb, s->avctx, &s->sei, &s->ps, s->nal_unit_type); 3163 if (ret < 0) 3164 goto fail; 3165 break; 3166 case HEVC_NAL_TRAIL_R: 3167 case HEVC_NAL_TRAIL_N: 3168 case HEVC_NAL_TSA_N: 3169 case HEVC_NAL_TSA_R: 3170 case HEVC_NAL_STSA_N: 3171 case HEVC_NAL_STSA_R: 3172 case HEVC_NAL_BLA_W_LP: 3173 case HEVC_NAL_BLA_W_RADL: 3174 case HEVC_NAL_BLA_N_LP: 3175 case HEVC_NAL_IDR_W_RADL: 3176 case HEVC_NAL_IDR_N_LP: 3177 case HEVC_NAL_CRA_NUT: 3178 case HEVC_NAL_RADL_N: 3179 case HEVC_NAL_RADL_R: 3180 case HEVC_NAL_RASL_N: 3181 case HEVC_NAL_RASL_R: 3182 ret = hls_slice_header(s); 3183 if (ret < 0) { 3184 // hls_slice_header() does not cleanup on failure thus the state now is inconsistant so we cannot use it on dependant slices 3185 s->slice_initialized = 0; 3186 return ret; 3187 } 3188 if (ret == 1) { 3189 ret = AVERROR_INVALIDDATA; 3190 goto fail; 3191 } 3192 3193 3194 if ( 3195 (s->avctx->skip_frame >= AVDISCARD_BIDIR && s->sh.slice_type == HEVC_SLICE_B) || 3196 (s->avctx->skip_frame >= AVDISCARD_NONINTRA && s->sh.slice_type != HEVC_SLICE_I) || 3197 (s->avctx->skip_frame >= AVDISCARD_NONKEY && !IS_IRAP(s))) { 3198 break; 3199 } 3200 3201 if (s->sh.first_slice_in_pic_flag) { 3202 if (s->max_ra == INT_MAX) { 3203 if (s->nal_unit_type == HEVC_NAL_CRA_NUT || IS_BLA(s)) { 3204 s->max_ra = s->poc; 3205 } else { 3206 if (IS_IDR(s)) 3207 s->max_ra = INT_MIN; 3208 } 3209 } 3210 3211 if ((s->nal_unit_type == HEVC_NAL_RASL_R || s->nal_unit_type == HEVC_NAL_RASL_N) && 3212 s->poc <= s->max_ra) { 3213 s->is_decoded = 0; 3214 break; 3215 } else { 3216 if (s->nal_unit_type == HEVC_NAL_RASL_R && s->poc > s->max_ra) 3217 s->max_ra = INT_MIN; 3218 } 3219 3220 s->overlap ++; 3221 ret = hevc_frame_start(s); 3222 if (ret < 0) 3223 return ret; 3224 } else if (!s->ref) { 3225 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n"); 3226 goto fail; 3227 } 3228 3229 if (s->nal_unit_type != s->first_nal_type) { 3230 av_log(s->avctx, AV_LOG_ERROR, 3231 "Non-matching NAL types of the VCL NALUs: %d %d\n", 3232 s->first_nal_type, s->nal_unit_type); 3233 return AVERROR_INVALIDDATA; 3234 } 3235 3236 if (!s->sh.dependent_slice_segment_flag && 3237 s->sh.slice_type != HEVC_SLICE_I) { 3238 ret = ff_hevc_slice_rpl(s); 3239 if (ret < 0) { 3240 av_log(s->avctx, AV_LOG_WARNING, 3241 "Error constructing the reference lists for the current slice.\n"); 3242 goto fail; 3243 } 3244 } 3245 3246 if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) { 3247 ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0); 3248 if (ret < 0) 3249 goto fail; 3250 } 3251 3252 if (s->avctx->hwaccel) { 3253 ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size); 3254 if (ret < 0) 3255 goto fail; 3256 } else { 3257 if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0) 3258 ctb_addr_ts = hls_slice_data_wpp(s, nal); 3259 else 3260 ctb_addr_ts = hls_slice_data(s); 3261 if (ctb_addr_ts >= (s->ps.sps->ctb_width * s->ps.sps->ctb_height)) { 3262 ret = hevc_frame_end(s); 3263 if (ret < 0) 3264 goto fail; 3265 s->is_decoded = 1; 3266 } 3267 3268 if (ctb_addr_ts < 0) { 3269 ret = ctb_addr_ts; 3270 goto fail; 3271 } 3272 } 3273 break; 3274 case HEVC_NAL_EOS_NUT: 3275 case HEVC_NAL_EOB_NUT: 3276 s->seq_decode = (s->seq_decode + 1) & 0xff; 3277 s->max_ra = INT_MAX; 3278 break; 3279 case HEVC_NAL_AUD: 3280 case HEVC_NAL_FD_NUT: 3281 case HEVC_NAL_UNSPEC62: 3282 break; 3283 default: 3284 av_log(s->avctx, AV_LOG_INFO, 3285 "Skipping NAL unit %d\n", s->nal_unit_type); 3286 } 3287 3288 return 0; 3289fail: 3290 if (s->avctx->err_recognition & AV_EF_EXPLODE) 3291 return ret; 3292 return 0; 3293} 3294 3295static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length) 3296{ 3297 int i, ret = 0; 3298 int eos_at_start = 1; 3299 3300 s->ref = NULL; 3301 s->last_eos = s->eos; 3302 s->eos = 0; 3303 s->overlap = 0; 3304 3305 /* split the input packet into NAL units, so we know the upper bound on the 3306 * number of slices in the frame */ 3307 ret = ff_h2645_packet_split(&s->pkt, buf, length, s->avctx, s->is_nalff, 3308 s->nal_length_size, s->avctx->codec_id, 1, 0); 3309 if (ret < 0) { 3310 av_log(s->avctx, AV_LOG_ERROR, 3311 "Error splitting the input into NAL units.\n"); 3312 return ret; 3313 } 3314 3315 for (i = 0; i < s->pkt.nb_nals; i++) { 3316 if (s->pkt.nals[i].type == HEVC_NAL_EOB_NUT || 3317 s->pkt.nals[i].type == HEVC_NAL_EOS_NUT) { 3318 if (eos_at_start) { 3319 s->last_eos = 1; 3320 } else { 3321 s->eos = 1; 3322 } 3323 } else { 3324 eos_at_start = 0; 3325 } 3326 } 3327 3328 /* 3329 * Check for RPU delimiter. 3330 * 3331 * Dolby Vision RPUs masquerade as unregistered NALs of type 62. 3332 * 3333 * We have to do this check here an create the rpu buffer, since RPUs are appended 3334 * to the end of an AU; they are the last non-EOB/EOS NAL in the AU. 3335 */ 3336 if (s->pkt.nb_nals > 1 && s->pkt.nals[s->pkt.nb_nals - 1].type == HEVC_NAL_UNSPEC62 && 3337 s->pkt.nals[s->pkt.nb_nals - 1].size > 2 && !s->pkt.nals[s->pkt.nb_nals - 1].nuh_layer_id 3338 && !s->pkt.nals[s->pkt.nb_nals - 1].temporal_id) { 3339 H2645NAL *nal = &s->pkt.nals[s->pkt.nb_nals - 1]; 3340 if (s->rpu_buf) { 3341 av_buffer_unref(&s->rpu_buf); 3342 av_log(s->avctx, AV_LOG_WARNING, "Multiple Dolby Vision RPUs found in one AU. Skipping previous.\n"); 3343 } 3344 3345 s->rpu_buf = av_buffer_alloc(nal->raw_size - 2); 3346 if (!s->rpu_buf) 3347 return AVERROR(ENOMEM); 3348 memcpy(s->rpu_buf->data, nal->raw_data + 2, nal->raw_size - 2); 3349 3350 ret = ff_dovi_rpu_parse(&s->dovi_ctx, nal->data + 2, nal->size - 2); 3351 if (ret < 0) { 3352 av_buffer_unref(&s->rpu_buf); 3353 av_log(s->avctx, AV_LOG_WARNING, "Error parsing DOVI NAL unit.\n"); 3354 /* ignore */ 3355 } 3356 } 3357 3358 /* decode the NAL units */ 3359 for (i = 0; i < s->pkt.nb_nals; i++) { 3360 H2645NAL *nal = &s->pkt.nals[i]; 3361 3362 if (s->avctx->skip_frame >= AVDISCARD_ALL || 3363 (s->avctx->skip_frame >= AVDISCARD_NONREF 3364 && ff_hevc_nal_is_nonref(nal->type)) || nal->nuh_layer_id > 0) 3365 continue; 3366 3367 ret = decode_nal_unit(s, nal); 3368 if (ret >= 0 && s->overlap > 2) 3369 ret = AVERROR_INVALIDDATA; 3370 if (ret < 0) { 3371 av_log(s->avctx, AV_LOG_WARNING, 3372 "Error parsing NAL unit #%d.\n", i); 3373 goto fail; 3374 } 3375 } 3376 3377fail: 3378 if (s->ref && s->threads_type == FF_THREAD_FRAME) 3379 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0); 3380 3381 return ret; 3382} 3383 3384static void print_md5(void *log_ctx, int level, uint8_t md5[16]) 3385{ 3386 int i; 3387 for (i = 0; i < 16; i++) 3388 av_log(log_ctx, level, "%02"PRIx8, md5[i]); 3389} 3390 3391static int verify_md5(HEVCContext *s, AVFrame *frame) 3392{ 3393 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format); 3394 int pixel_shift; 3395 int i, j; 3396 3397 if (!desc) 3398 return AVERROR(EINVAL); 3399 3400 pixel_shift = desc->comp[0].depth > 8; 3401 3402 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ", 3403 s->poc); 3404 3405 /* the checksums are LE, so we have to byteswap for >8bpp formats 3406 * on BE arches */ 3407#if HAVE_BIGENDIAN 3408 if (pixel_shift && !s->checksum_buf) { 3409 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size, 3410 FFMAX3(frame->linesize[0], frame->linesize[1], 3411 frame->linesize[2])); 3412 if (!s->checksum_buf) 3413 return AVERROR(ENOMEM); 3414 } 3415#endif 3416 3417 for (i = 0; frame->data[i]; i++) { 3418 int width = s->avctx->coded_width; 3419 int height = s->avctx->coded_height; 3420 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width; 3421 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height; 3422 uint8_t md5[16]; 3423 3424 av_md5_init(s->md5_ctx); 3425 for (j = 0; j < h; j++) { 3426 const uint8_t *src = frame->data[i] + j * frame->linesize[i]; 3427#if HAVE_BIGENDIAN 3428 if (pixel_shift) { 3429 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf, 3430 (const uint16_t *) src, w); 3431 src = s->checksum_buf; 3432 } 3433#endif 3434 av_md5_update(s->md5_ctx, src, w << pixel_shift); 3435 } 3436 av_md5_final(s->md5_ctx, md5); 3437 3438 if (!memcmp(md5, s->sei.picture_hash.md5[i], 16)) { 3439 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i); 3440 print_md5(s->avctx, AV_LOG_DEBUG, md5); 3441 av_log (s->avctx, AV_LOG_DEBUG, "; "); 3442 } else { 3443 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i); 3444 print_md5(s->avctx, AV_LOG_ERROR, md5); 3445 av_log (s->avctx, AV_LOG_ERROR, " != "); 3446 print_md5(s->avctx, AV_LOG_ERROR, s->sei.picture_hash.md5[i]); 3447 av_log (s->avctx, AV_LOG_ERROR, "\n"); 3448 return AVERROR_INVALIDDATA; 3449 } 3450 } 3451 3452 av_log(s->avctx, AV_LOG_DEBUG, "\n"); 3453 3454 return 0; 3455} 3456 3457static int hevc_decode_extradata(HEVCContext *s, uint8_t *buf, int length, int first) 3458{ 3459 int ret, i; 3460 3461 ret = ff_hevc_decode_extradata(buf, length, &s->ps, &s->sei, &s->is_nalff, 3462 &s->nal_length_size, s->avctx->err_recognition, 3463 s->apply_defdispwin, s->avctx); 3464 if (ret < 0) 3465 return ret; 3466 3467 /* export stream parameters from the first SPS */ 3468 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) { 3469 if (first && s->ps.sps_list[i]) { 3470 const HEVCSPS *sps = (const HEVCSPS*)s->ps.sps_list[i]->data; 3471 export_stream_params(s, sps); 3472 break; 3473 } 3474 } 3475 3476 /* export stream parameters from SEI */ 3477 ret = export_stream_params_from_sei(s); 3478 if (ret < 0) 3479 return ret; 3480 3481 return 0; 3482} 3483 3484static int hevc_decode_frame(AVCodecContext *avctx, AVFrame *rframe, 3485 int *got_output, AVPacket *avpkt) 3486{ 3487 int ret; 3488 uint8_t *sd; 3489 size_t sd_size; 3490 HEVCContext *s = avctx->priv_data; 3491 3492 if (!avpkt->size) { 3493 ret = ff_hevc_output_frame(s, rframe, 1); 3494 if (ret < 0) 3495 return ret; 3496 3497 *got_output = ret; 3498 return 0; 3499 } 3500 3501 sd = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, &sd_size); 3502 if (sd && sd_size > 0) { 3503 ret = hevc_decode_extradata(s, sd, sd_size, 0); 3504 if (ret < 0) 3505 return ret; 3506 } 3507 3508 sd = av_packet_get_side_data(avpkt, AV_PKT_DATA_DOVI_CONF, &sd_size); 3509 if (sd && sd_size > 0) 3510 ff_dovi_update_cfg(&s->dovi_ctx, (AVDOVIDecoderConfigurationRecord *) sd); 3511 3512 s->ref = NULL; 3513 ret = decode_nal_units(s, avpkt->data, avpkt->size); 3514 if (ret < 0) 3515 return ret; 3516 3517 if (avctx->hwaccel) { 3518 if (s->ref && (ret = avctx->hwaccel->end_frame(avctx)) < 0) { 3519 av_log(avctx, AV_LOG_ERROR, 3520 "hardware accelerator failed to decode picture\n"); 3521 ff_hevc_unref_frame(s, s->ref, ~0); 3522 return ret; 3523 } 3524 } else { 3525 /* verify the SEI checksum */ 3526 if (avctx->err_recognition & AV_EF_CRCCHECK && s->ref && s->is_decoded && 3527 s->sei.picture_hash.is_md5) { 3528 ret = verify_md5(s, s->ref->frame); 3529 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) { 3530 ff_hevc_unref_frame(s, s->ref, ~0); 3531 return ret; 3532 } 3533 } 3534 } 3535 s->sei.picture_hash.is_md5 = 0; 3536 3537 if (s->is_decoded) { 3538 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc); 3539 s->is_decoded = 0; 3540 } 3541 3542 if (s->output_frame->buf[0]) { 3543 av_frame_move_ref(rframe, s->output_frame); 3544 *got_output = 1; 3545 } 3546 3547 return avpkt->size; 3548} 3549 3550static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src) 3551{ 3552 int ret; 3553 3554 ret = ff_thread_ref_frame(&dst->tf, &src->tf); 3555 if (ret < 0) 3556 return ret; 3557 3558 if (src->needs_fg) { 3559 ret = av_frame_ref(dst->frame_grain, src->frame_grain); 3560 if (ret < 0) 3561 return ret; 3562 dst->needs_fg = 1; 3563 } 3564 3565 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf); 3566 if (!dst->tab_mvf_buf) 3567 goto fail; 3568 dst->tab_mvf = src->tab_mvf; 3569 3570 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf); 3571 if (!dst->rpl_tab_buf) 3572 goto fail; 3573 dst->rpl_tab = src->rpl_tab; 3574 3575 dst->rpl_buf = av_buffer_ref(src->rpl_buf); 3576 if (!dst->rpl_buf) 3577 goto fail; 3578 3579 dst->poc = src->poc; 3580 dst->ctb_count = src->ctb_count; 3581 dst->flags = src->flags; 3582 dst->sequence = src->sequence; 3583 3584 if (src->hwaccel_picture_private) { 3585 dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf); 3586 if (!dst->hwaccel_priv_buf) 3587 goto fail; 3588 dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data; 3589 } 3590 3591 return 0; 3592fail: 3593 ff_hevc_unref_frame(s, dst, ~0); 3594 return AVERROR(ENOMEM); 3595} 3596 3597static av_cold int hevc_decode_free(AVCodecContext *avctx) 3598{ 3599 HEVCContext *s = avctx->priv_data; 3600 int i; 3601 3602 pic_arrays_free(s); 3603 3604 ff_dovi_ctx_unref(&s->dovi_ctx); 3605 av_buffer_unref(&s->rpu_buf); 3606 3607 av_freep(&s->md5_ctx); 3608 3609 av_freep(&s->cabac_state); 3610 3611 for (i = 0; i < 3; i++) { 3612 av_freep(&s->sao_pixel_buffer_h[i]); 3613 av_freep(&s->sao_pixel_buffer_v[i]); 3614 } 3615 av_frame_free(&s->output_frame); 3616 3617 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) { 3618 ff_hevc_unref_frame(s, &s->DPB[i], ~0); 3619 av_frame_free(&s->DPB[i].frame); 3620 av_frame_free(&s->DPB[i].frame_grain); 3621 } 3622 3623 ff_hevc_ps_uninit(&s->ps); 3624 3625 av_freep(&s->sh.entry_point_offset); 3626 av_freep(&s->sh.offset); 3627 av_freep(&s->sh.size); 3628 3629 if (s->HEVClcList && s->sList) { 3630 for (i = 1; i < s->threads_number; i++) { 3631 av_freep(&s->HEVClcList[i]); 3632 av_freep(&s->sList[i]); 3633 } 3634 } 3635 av_freep(&s->HEVClc); 3636 av_freep(&s->HEVClcList); 3637 av_freep(&s->sList); 3638 3639 ff_h2645_packet_uninit(&s->pkt); 3640 3641 ff_hevc_reset_sei(&s->sei); 3642 3643 return 0; 3644} 3645 3646static av_cold int hevc_init_context(AVCodecContext *avctx) 3647{ 3648 HEVCContext *s = avctx->priv_data; 3649 int i; 3650 3651 s->avctx = avctx; 3652 3653 s->HEVClc = av_mallocz(sizeof(HEVCLocalContext)); 3654 s->HEVClcList = av_mallocz(sizeof(HEVCLocalContext*) * s->threads_number); 3655 s->sList = av_mallocz(sizeof(HEVCContext*) * s->threads_number); 3656 if (!s->HEVClc || !s->HEVClcList || !s->sList) 3657 return AVERROR(ENOMEM); 3658 s->HEVClcList[0] = s->HEVClc; 3659 s->sList[0] = s; 3660 3661 s->cabac_state = av_malloc(HEVC_CONTEXTS); 3662 if (!s->cabac_state) 3663 return AVERROR(ENOMEM); 3664 3665 s->output_frame = av_frame_alloc(); 3666 if (!s->output_frame) 3667 return AVERROR(ENOMEM); 3668 3669 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) { 3670 s->DPB[i].frame = av_frame_alloc(); 3671 if (!s->DPB[i].frame) 3672 return AVERROR(ENOMEM); 3673 s->DPB[i].tf.f = s->DPB[i].frame; 3674 3675 s->DPB[i].frame_grain = av_frame_alloc(); 3676 if (!s->DPB[i].frame_grain) 3677 return AVERROR(ENOMEM); 3678 } 3679 3680 s->max_ra = INT_MAX; 3681 3682 s->md5_ctx = av_md5_alloc(); 3683 if (!s->md5_ctx) 3684 return AVERROR(ENOMEM); 3685 3686 ff_bswapdsp_init(&s->bdsp); 3687 3688 s->dovi_ctx.logctx = avctx; 3689 s->eos = 0; 3690 3691 ff_hevc_reset_sei(&s->sei); 3692 3693 return 0; 3694} 3695 3696#if HAVE_THREADS 3697static int hevc_update_thread_context(AVCodecContext *dst, 3698 const AVCodecContext *src) 3699{ 3700 HEVCContext *s = dst->priv_data; 3701 HEVCContext *s0 = src->priv_data; 3702 int i, ret; 3703 3704 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) { 3705 ff_hevc_unref_frame(s, &s->DPB[i], ~0); 3706 if (s0->DPB[i].frame->buf[0]) { 3707 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]); 3708 if (ret < 0) 3709 return ret; 3710 } 3711 } 3712 3713 if (s->ps.sps != s0->ps.sps) 3714 s->ps.sps = NULL; 3715 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++) { 3716 ret = av_buffer_replace(&s->ps.vps_list[i], s0->ps.vps_list[i]); 3717 if (ret < 0) 3718 return ret; 3719 } 3720 3721 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) { 3722 ret = av_buffer_replace(&s->ps.sps_list[i], s0->ps.sps_list[i]); 3723 if (ret < 0) 3724 return ret; 3725 } 3726 3727 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++) { 3728 ret = av_buffer_replace(&s->ps.pps_list[i], s0->ps.pps_list[i]); 3729 if (ret < 0) 3730 return ret; 3731 } 3732 3733 if (s->ps.sps != s0->ps.sps) 3734 if ((ret = set_sps(s, s0->ps.sps, src->pix_fmt)) < 0) 3735 return ret; 3736 3737 s->seq_decode = s0->seq_decode; 3738 s->seq_output = s0->seq_output; 3739 s->pocTid0 = s0->pocTid0; 3740 s->max_ra = s0->max_ra; 3741 s->eos = s0->eos; 3742 s->no_rasl_output_flag = s0->no_rasl_output_flag; 3743 3744 s->is_nalff = s0->is_nalff; 3745 s->nal_length_size = s0->nal_length_size; 3746 3747 s->threads_number = s0->threads_number; 3748 s->threads_type = s0->threads_type; 3749 3750 if (s0->eos) { 3751 s->seq_decode = (s->seq_decode + 1) & 0xff; 3752 s->max_ra = INT_MAX; 3753 } 3754 3755 ret = av_buffer_replace(&s->sei.a53_caption.buf_ref, s0->sei.a53_caption.buf_ref); 3756 if (ret < 0) 3757 return ret; 3758 3759 for (i = 0; i < s->sei.unregistered.nb_buf_ref; i++) 3760 av_buffer_unref(&s->sei.unregistered.buf_ref[i]); 3761 s->sei.unregistered.nb_buf_ref = 0; 3762 3763 if (s0->sei.unregistered.nb_buf_ref) { 3764 ret = av_reallocp_array(&s->sei.unregistered.buf_ref, 3765 s0->sei.unregistered.nb_buf_ref, 3766 sizeof(*s->sei.unregistered.buf_ref)); 3767 if (ret < 0) 3768 return ret; 3769 3770 for (i = 0; i < s0->sei.unregistered.nb_buf_ref; i++) { 3771 s->sei.unregistered.buf_ref[i] = av_buffer_ref(s0->sei.unregistered.buf_ref[i]); 3772 if (!s->sei.unregistered.buf_ref[i]) 3773 return AVERROR(ENOMEM); 3774 s->sei.unregistered.nb_buf_ref++; 3775 } 3776 } 3777 3778 ret = av_buffer_replace(&s->sei.dynamic_hdr_plus.info, s0->sei.dynamic_hdr_plus.info); 3779 if (ret < 0) 3780 return ret; 3781 3782 ret = av_buffer_replace(&s->rpu_buf, s0->rpu_buf); 3783 if (ret < 0) 3784 return ret; 3785 3786 ret = ff_dovi_ctx_replace(&s->dovi_ctx, &s0->dovi_ctx); 3787 if (ret < 0) 3788 return ret; 3789 3790 ret = av_buffer_replace(&s->sei.dynamic_hdr_vivid.info, s0->sei.dynamic_hdr_vivid.info); 3791 if (ret < 0) 3792 return ret; 3793 3794 s->sei.frame_packing = s0->sei.frame_packing; 3795 s->sei.display_orientation = s0->sei.display_orientation; 3796 s->sei.mastering_display = s0->sei.mastering_display; 3797 s->sei.content_light = s0->sei.content_light; 3798 s->sei.alternative_transfer = s0->sei.alternative_transfer; 3799 3800 ret = export_stream_params_from_sei(s); 3801 if (ret < 0) 3802 return ret; 3803 3804 return 0; 3805} 3806#endif 3807 3808static av_cold int hevc_decode_init(AVCodecContext *avctx) 3809{ 3810 HEVCContext *s = avctx->priv_data; 3811 int ret; 3812 3813 if (avctx->active_thread_type & FF_THREAD_SLICE) { 3814 s->threads_number = avctx->thread_count; 3815 ret = ff_slice_thread_init_progress(avctx); 3816 if (ret < 0) 3817 return ret; 3818 } else 3819 s->threads_number = 1; 3820 3821 if((avctx->active_thread_type & FF_THREAD_FRAME) && avctx->thread_count > 1) 3822 s->threads_type = FF_THREAD_FRAME; 3823 else 3824 s->threads_type = FF_THREAD_SLICE; 3825 3826 ret = hevc_init_context(avctx); 3827 if (ret < 0) 3828 return ret; 3829 3830 s->enable_parallel_tiles = 0; 3831 s->sei.picture_timing.picture_struct = 0; 3832 s->eos = 1; 3833 3834 atomic_init(&s->wpp_err, 0); 3835 3836 if (!avctx->internal->is_copy) { 3837 if (avctx->extradata_size > 0 && avctx->extradata) { 3838 ret = hevc_decode_extradata(s, avctx->extradata, avctx->extradata_size, 1); 3839 if (ret < 0) { 3840 return ret; 3841 } 3842 } 3843 } 3844 3845 return 0; 3846} 3847 3848static void hevc_decode_flush(AVCodecContext *avctx) 3849{ 3850 HEVCContext *s = avctx->priv_data; 3851 ff_hevc_flush_dpb(s); 3852 ff_hevc_reset_sei(&s->sei); 3853 ff_dovi_ctx_flush(&s->dovi_ctx); 3854 av_buffer_unref(&s->rpu_buf); 3855 s->max_ra = INT_MAX; 3856 s->eos = 1; 3857} 3858 3859#define OFFSET(x) offsetof(HEVCContext, x) 3860#define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM) 3861 3862static const AVOption options[] = { 3863 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin), 3864 AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR }, 3865 { "strict-displaywin", "stricly apply default display window size", OFFSET(apply_defdispwin), 3866 AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR }, 3867 { NULL }, 3868}; 3869 3870static const AVClass hevc_decoder_class = { 3871 .class_name = "HEVC decoder", 3872 .item_name = av_default_item_name, 3873 .option = options, 3874 .version = LIBAVUTIL_VERSION_INT, 3875}; 3876 3877const FFCodec ff_hevc_decoder = { 3878 .p.name = "hevc", 3879 .p.long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"), 3880 .p.type = AVMEDIA_TYPE_VIDEO, 3881 .p.id = AV_CODEC_ID_HEVC, 3882 .priv_data_size = sizeof(HEVCContext), 3883 .p.priv_class = &hevc_decoder_class, 3884 .init = hevc_decode_init, 3885 .close = hevc_decode_free, 3886 FF_CODEC_DECODE_CB(hevc_decode_frame), 3887 .flush = hevc_decode_flush, 3888 .update_thread_context = ONLY_IF_THREADS_ENABLED(hevc_update_thread_context), 3889 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | 3890 AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS, 3891 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_EXPORTS_CROPPING | 3892 FF_CODEC_CAP_ALLOCATE_PROGRESS | FF_CODEC_CAP_INIT_CLEANUP, 3893 .p.profiles = NULL_IF_CONFIG_SMALL(ff_hevc_profiles), 3894 .hw_configs = (const AVCodecHWConfigInternal *const []) { 3895#if CONFIG_HEVC_DXVA2_HWACCEL 3896 HWACCEL_DXVA2(hevc), 3897#endif 3898#if CONFIG_HEVC_D3D11VA_HWACCEL 3899 HWACCEL_D3D11VA(hevc), 3900#endif 3901#if CONFIG_HEVC_D3D11VA2_HWACCEL 3902 HWACCEL_D3D11VA2(hevc), 3903#endif 3904#if CONFIG_HEVC_NVDEC_HWACCEL 3905 HWACCEL_NVDEC(hevc), 3906#endif 3907#if CONFIG_HEVC_VAAPI_HWACCEL 3908 HWACCEL_VAAPI(hevc), 3909#endif 3910#if CONFIG_HEVC_VDPAU_HWACCEL 3911 HWACCEL_VDPAU(hevc), 3912#endif 3913#if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL 3914 HWACCEL_VIDEOTOOLBOX(hevc), 3915#endif 3916 NULL 3917 }, 3918}; 3919