FFmpeg: libavcodec/vaapi_hevc.c Source File

FFmpeg

[フレーム]

libavcodec

vaapi_hevc.c

Go to the documentation of this file.

1 /*

2 * HEVC HW decode acceleration through VA API

3 *

5 *

6 * This file is part of FFmpeg.

7 *

8 * FFmpeg is free software; you can redistribute it and/or

9 * modify it under the terms of the GNU Lesser General Public

10 * License as published by the Free Software Foundation; either

11 * version 2.1 of the License, or (at your option) any later version.

12 *

13 * FFmpeg is distributed in the hope that it will be useful,

14 * but WITHOUT ANY WARRANTY; without even the implied warranty of

15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

16 * Lesser General Public License for more details.

17 *

18 * You should have received a copy of the GNU Lesser General Public

19 * License along with FFmpeg; if not, write to the Free Software

20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

21 */

23 #include <va/va.h>

24 #include <va/va_dec_hevc.h>

26 #include "avcodec.h"

27 #include "hevcdec.h"

28 #include "hwconfig.h"

29 #include "vaapi_decode.h"

30 #include "vaapi_hevc.h"

31 #include "h265_profile_level.h"

33 typedef struct VAAPIDecodePictureHEVC {

34 #if VA_CHECK_VERSION(1, 2, 0)

35 VAPictureParameterBufferHEVCExtension pic_param;

36 VASliceParameterBufferHEVCExtension last_slice_param;

37 #else

38 VAPictureParameterBufferHEVC pic_param;

39 VASliceParameterBufferHEVC last_slice_param;

40 #endif

41 const uint8_t *last_buffer;

42 size_t last_size;

44 VAAPIDecodePicture pic;

45 } VAAPIDecodePictureHEVC;

47 static void init_vaapi_pic(VAPictureHEVC *va_pic)

48 {

49 va_pic->picture_id = VA_INVALID_ID;

50 va_pic->flags = VA_PICTURE_HEVC_INVALID;

51 va_pic->pic_order_cnt = 0;

52 }

54 static void fill_vaapi_pic(VAPictureHEVC *va_pic, const HEVCFrame *pic, int rps_type)

55 {

56 va_pic->picture_id = ff_vaapi_get_surface_id(pic->frame);

57 va_pic->pic_order_cnt = pic->poc;

58 va_pic->flags = rps_type;

60 if (pic->flags & HEVC_FRAME_FLAG_LONG_REF)

61 va_pic->flags |= VA_PICTURE_HEVC_LONG_TERM_REFERENCE;

63 if (pic->frame->interlaced_frame) {

64 va_pic->flags |= VA_PICTURE_HEVC_FIELD_PIC;

66 if (!pic->frame->top_field_first)

67 va_pic->flags |= VA_PICTURE_HEVC_BOTTOM_FIELD;

68 }

69 }

71 static int find_frame_rps_type(const HEVCContext *h, const HEVCFrame *pic)

72 {

73 VASurfaceID pic_surf = ff_vaapi_get_surface_id(pic->frame);

74 int i;

76 for (i = 0; i < h->rps[ST_CURR_BEF].nb_refs; i++) {

77 if (pic_surf == ff_vaapi_get_surface_id(h->rps[ST_CURR_BEF].ref[i]->frame))

78 return VA_PICTURE_HEVC_RPS_ST_CURR_BEFORE;

79 }

81 for (i = 0; i < h->rps[ST_CURR_AFT].nb_refs; i++) {

82 if (pic_surf == ff_vaapi_get_surface_id(h->rps[ST_CURR_AFT].ref[i]->frame))

83 return VA_PICTURE_HEVC_RPS_ST_CURR_AFTER;

84 }

86 for (i = 0; i < h->rps[LT_CURR].nb_refs; i++) {

87 if (pic_surf == ff_vaapi_get_surface_id(h->rps[LT_CURR].ref[i]->frame))

88 return VA_PICTURE_HEVC_RPS_LT_CURR;

89 }

91 return 0;

92 }

94 static void fill_vaapi_reference_frames(const HEVCContext *h, VAPictureParameterBufferHEVC *pp)

95 {

96 const HEVCFrame *current_picture = h->ref;

97 int i, j, rps_type;

99 for (i = 0, j = 0; i < FF_ARRAY_ELEMS(pp->ReferenceFrames); i++) {

100 const HEVCFrame *frame = NULL;

101

102 while (!frame && j < FF_ARRAY_ELEMS(h->DPB)) {

103 if (&h->DPB[j] != current_picture && (h->DPB[j].flags & (HEVC_FRAME_FLAG_LONG_REF | HEVC_FRAME_FLAG_SHORT_REF)))

104 frame = &h->DPB[j];

105 j++;

106 }

107

108 init_vaapi_pic(&pp->ReferenceFrames[i]);

109

110 if (frame) {

111 rps_type = find_frame_rps_type(h, frame);

112 fill_vaapi_pic(&pp->ReferenceFrames[i], frame, rps_type);

113 }

114 }

115 }

116

117 static int vaapi_hevc_start_frame(AVCodecContext *avctx,

118 av_unused const uint8_t *buffer,

119 av_unused uint32_t size)

120 {

121 const HEVCContext *h = avctx->priv_data;

122 VAAPIDecodePictureHEVC *pic = h->ref->hwaccel_picture_private;

123 const HEVCSPS *sps = h->ps.sps;

124 const HEVCPPS *pps = h->ps.pps;

125

126 const ScalingList *scaling_list = NULL;

127 int pic_param_size, err, i;

128

129 VAPictureParameterBufferHEVC *pic_param = (VAPictureParameterBufferHEVC *)&pic->pic_param;

130

131 pic->pic.output_surface = ff_vaapi_get_surface_id(h->ref->frame);

132

133 *pic_param = (VAPictureParameterBufferHEVC) {

134 .pic_width_in_luma_samples = sps->width,

135 .pic_height_in_luma_samples = sps->height,

136 .log2_min_luma_coding_block_size_minus3 = sps->log2_min_cb_size - 3,

137 .sps_max_dec_pic_buffering_minus1 = sps->temporal_layer[sps->max_sub_layers - 1].max_dec_pic_buffering - 1,

138 .log2_diff_max_min_luma_coding_block_size = sps->log2_diff_max_min_coding_block_size,

139 .log2_min_transform_block_size_minus2 = sps->log2_min_tb_size - 2,

140 .log2_diff_max_min_transform_block_size = sps->log2_max_trafo_size - sps->log2_min_tb_size,

141 .max_transform_hierarchy_depth_inter = sps->max_transform_hierarchy_depth_inter,

142 .max_transform_hierarchy_depth_intra = sps->max_transform_hierarchy_depth_intra,

143 .num_short_term_ref_pic_sets = sps->nb_st_rps,

144 .num_long_term_ref_pic_sps = sps->num_long_term_ref_pics_sps,

145 .num_ref_idx_l0_default_active_minus1 = pps->num_ref_idx_l0_default_active - 1,

146 .num_ref_idx_l1_default_active_minus1 = pps->num_ref_idx_l1_default_active - 1,

147 .init_qp_minus26 = pps->pic_init_qp_minus26,

148 .pps_cb_qp_offset = pps->cb_qp_offset,

149 .pps_cr_qp_offset = pps->cr_qp_offset,

150 .pcm_sample_bit_depth_luma_minus1 = sps->pcm.bit_depth - 1,

151 .pcm_sample_bit_depth_chroma_minus1 = sps->pcm.bit_depth_chroma - 1,

152 .log2_min_pcm_luma_coding_block_size_minus3 = sps->pcm.log2_min_pcm_cb_size - 3,

153 .log2_diff_max_min_pcm_luma_coding_block_size = sps->pcm.log2_max_pcm_cb_size - sps->pcm.log2_min_pcm_cb_size,

154 .diff_cu_qp_delta_depth = pps->diff_cu_qp_delta_depth,

155 .pps_beta_offset_div2 = pps->beta_offset / 2,

156 .pps_tc_offset_div2 = pps->tc_offset / 2,

157 .log2_parallel_merge_level_minus2 = pps->log2_parallel_merge_level - 2,

158 .bit_depth_luma_minus8 = sps->bit_depth - 8,

159 .bit_depth_chroma_minus8 = sps->bit_depth - 8,

160 .log2_max_pic_order_cnt_lsb_minus4 = sps->log2_max_poc_lsb - 4,

161 .num_extra_slice_header_bits = pps->num_extra_slice_header_bits,

162 .pic_fields.bits = {

163 .chroma_format_idc = sps->chroma_format_idc,

164 .tiles_enabled_flag = pps->tiles_enabled_flag,

165 .separate_colour_plane_flag = sps->separate_colour_plane_flag,

166 .pcm_enabled_flag = sps->pcm_enabled_flag,

167 .scaling_list_enabled_flag = sps->scaling_list_enable_flag,

168 .transform_skip_enabled_flag = pps->transform_skip_enabled_flag,

169 .amp_enabled_flag = sps->amp_enabled_flag,

170 .strong_intra_smoothing_enabled_flag = sps->sps_strong_intra_smoothing_enable_flag,

171 .sign_data_hiding_enabled_flag = pps->sign_data_hiding_flag,

172 .constrained_intra_pred_flag = pps->constrained_intra_pred_flag,

173 .cu_qp_delta_enabled_flag = pps->cu_qp_delta_enabled_flag,

174 .weighted_pred_flag = pps->weighted_pred_flag,

175 .weighted_bipred_flag = pps->weighted_bipred_flag,

176 .transquant_bypass_enabled_flag = pps->transquant_bypass_enable_flag,

177 .entropy_coding_sync_enabled_flag = pps->entropy_coding_sync_enabled_flag,

178 .pps_loop_filter_across_slices_enabled_flag = pps->seq_loop_filter_across_slices_enabled_flag,

179 .loop_filter_across_tiles_enabled_flag = pps->loop_filter_across_tiles_enabled_flag,

180 .pcm_loop_filter_disabled_flag = sps->pcm.loop_filter_disable_flag,

181 },

182 .slice_parsing_fields.bits = {

183 .lists_modification_present_flag = pps->lists_modification_present_flag,

184 .long_term_ref_pics_present_flag = sps->long_term_ref_pics_present_flag,

185 .sps_temporal_mvp_enabled_flag = sps->sps_temporal_mvp_enabled_flag,

186 .cabac_init_present_flag = pps->cabac_init_present_flag,

187 .output_flag_present_flag = pps->output_flag_present_flag,

188 .dependent_slice_segments_enabled_flag = pps->dependent_slice_segments_enabled_flag,

189 .pps_slice_chroma_qp_offsets_present_flag = pps->pic_slice_level_chroma_qp_offsets_present_flag,

190 .sample_adaptive_offset_enabled_flag = sps->sao_enabled,

191 .deblocking_filter_override_enabled_flag = pps->deblocking_filter_override_enabled_flag,

192 .pps_disable_deblocking_filter_flag = pps->disable_dbf,

193 .slice_segment_header_extension_present_flag = pps->slice_header_extension_present_flag,

194 .RapPicFlag = IS_IRAP(h),

195 .IdrPicFlag = IS_IDR(h),

196 .IntraPicFlag = IS_IRAP(h),

197 },

198 };

199

200 fill_vaapi_pic(&pic_param->CurrPic, h->ref, 0);

201 fill_vaapi_reference_frames(h, pic_param);

202

203 if (pps->tiles_enabled_flag) {

204 pic_param->num_tile_columns_minus1 = pps->num_tile_columns - 1;

205 pic_param->num_tile_rows_minus1 = pps->num_tile_rows - 1;

206

207 for (i = 0; i < pps->num_tile_columns; i++)

208 pic_param->column_width_minus1[i] = pps->column_width[i] - 1;

209

210 for (i = 0; i < pps->num_tile_rows; i++)

211 pic_param->row_height_minus1[i] = pps->row_height[i] - 1;

212 }

213

214 if (h->sh.short_term_ref_pic_set_sps_flag == 0 && h->sh.short_term_rps) {

215 pic_param->st_rps_bits = h->sh.short_term_ref_pic_set_size;

216 } else {

217 pic_param->st_rps_bits = 0;

218 }

219

220 #if VA_CHECK_VERSION(1, 2, 0)

221 if (avctx->profile == FF_PROFILE_HEVC_REXT) {

222 pic->pic_param.rext = (VAPictureParameterBufferHEVCRext) {

223 .range_extension_pic_fields.bits = {

224 .transform_skip_rotation_enabled_flag = sps->transform_skip_rotation_enabled_flag,

225 .transform_skip_context_enabled_flag = sps->transform_skip_context_enabled_flag,

226 .implicit_rdpcm_enabled_flag = sps->implicit_rdpcm_enabled_flag,

227 .explicit_rdpcm_enabled_flag = sps->explicit_rdpcm_enabled_flag,

228 .extended_precision_processing_flag = sps->extended_precision_processing_flag,

229 .intra_smoothing_disabled_flag = sps->intra_smoothing_disabled_flag,

230 .high_precision_offsets_enabled_flag = sps->high_precision_offsets_enabled_flag,

231 .persistent_rice_adaptation_enabled_flag = sps->persistent_rice_adaptation_enabled_flag,

232 .cabac_bypass_alignment_enabled_flag = sps->cabac_bypass_alignment_enabled_flag,

233 .cross_component_prediction_enabled_flag = pps->cross_component_prediction_enabled_flag,

234 .chroma_qp_offset_list_enabled_flag = pps->chroma_qp_offset_list_enabled_flag,

235 },

236 .diff_cu_chroma_qp_offset_depth = pps->diff_cu_chroma_qp_offset_depth,

237 .chroma_qp_offset_list_len_minus1 = pps->chroma_qp_offset_list_len_minus1,

238 .log2_sao_offset_scale_luma = pps->log2_sao_offset_scale_luma,

239 .log2_sao_offset_scale_chroma = pps->log2_sao_offset_scale_chroma,

240 .log2_max_transform_skip_block_size_minus2 = pps->log2_max_transform_skip_block_size - 2,

241 };

242

243 for (i = 0; i < 6; i++)

244 pic->pic_param.rext.cb_qp_offset_list[i] = pps->cb_qp_offset_list[i];

245 for (i = 0; i < 6; i++)

246 pic->pic_param.rext.cr_qp_offset_list[i] = pps->cr_qp_offset_list[i];

247 }

248 #endif

249 pic_param_size = avctx->profile == FF_PROFILE_HEVC_REXT ?

250 sizeof(pic->pic_param) : sizeof(VAPictureParameterBufferHEVC);

251

252 err = ff_vaapi_decode_make_param_buffer(avctx, &pic->pic,

253 VAPictureParameterBufferType,

254 &pic->pic_param, pic_param_size);

255 if (err < 0)

256 goto fail;

257

258 if (pps->scaling_list_data_present_flag)

259 scaling_list = &pps->scaling_list;

260 else if (sps->scaling_list_enable_flag)

261 scaling_list = &sps->scaling_list;

262

263 if (scaling_list) {

264 VAIQMatrixBufferHEVC iq_matrix;

265 int j;

266

267 for (i = 0; i < 6; i++) {

268 for (j = 0; j < 16; j++)

269 iq_matrix.ScalingList4x4[i][j] = scaling_list->sl[0][i][j];

270 for (j = 0; j < 64; j++) {

271 iq_matrix.ScalingList8x8[i][j] = scaling_list->sl[1][i][j];

272 iq_matrix.ScalingList16x16[i][j] = scaling_list->sl[2][i][j];

273 if (i < 2)

274 iq_matrix.ScalingList32x32[i][j] = scaling_list->sl[3][i * 3][j];

275 }

276 iq_matrix.ScalingListDC16x16[i] = scaling_list->sl_dc[0][i];

277 if (i < 2)

278 iq_matrix.ScalingListDC32x32[i] = scaling_list->sl_dc[1][i * 3];

279 }

280

281 err = ff_vaapi_decode_make_param_buffer(avctx, &pic->pic,

282 VAIQMatrixBufferType,

283 &iq_matrix, sizeof(iq_matrix));

284 if (err < 0)

285 goto fail;

286 }

287

288 return 0;

289

290 fail:

291 ff_vaapi_decode_cancel(avctx, &pic->pic);

292 return err;

293 }

294

295 static int vaapi_hevc_end_frame(AVCodecContext *avctx)

296 {

297 const HEVCContext *h = avctx->priv_data;

298 VAAPIDecodePictureHEVC *pic = h->ref->hwaccel_picture_private;

299 VASliceParameterBufferHEVC *last_slice_param = (VASliceParameterBufferHEVC *)&pic->last_slice_param;

300 int ret;

301

302 int slice_param_size = avctx->profile == FF_PROFILE_HEVC_REXT ?

303 sizeof(pic->last_slice_param) : sizeof(VASliceParameterBufferHEVC);

304

305 if (pic->last_size) {

306 last_slice_param->LongSliceFlags.fields.LastSliceOfPic = 1;

307 ret = ff_vaapi_decode_make_slice_buffer(avctx, &pic->pic,

308 &pic->last_slice_param, slice_param_size,

309 pic->last_buffer, pic->last_size);

310 if (ret < 0)

311 goto fail;

312 }

313

314

315 ret = ff_vaapi_decode_issue(avctx, &pic->pic);

316 if (ret < 0)

317 goto fail;

318

319 return 0;

320 fail:

321 ff_vaapi_decode_cancel(avctx, &pic->pic);

322 return ret;

323 }

324

325 static void fill_pred_weight_table(AVCodecContext *avctx,

326 const HEVCContext *h,

327 const SliceHeader *sh,

328 VASliceParameterBufferHEVC *slice_param)

329 {

330 int i;

331 #if VA_CHECK_VERSION(1, 2, 0)

332 int is_rext = avctx->profile >= FF_PROFILE_HEVC_REXT;

333 #else

334 int is_rext = 0;

335 if (avctx->profile >= FF_PROFILE_HEVC_REXT)

336 av_log(avctx, AV_LOG_WARNING, "Please consider to update to VAAPI 1.2.0 "

337 "or above, which can support REXT related setting correctly.\n");

338 #endif

339

340 memset(slice_param->delta_luma_weight_l0, 0, sizeof(slice_param->delta_luma_weight_l0));

341 memset(slice_param->delta_luma_weight_l1, 0, sizeof(slice_param->delta_luma_weight_l1));

342 memset(slice_param->luma_offset_l0, 0, sizeof(slice_param->luma_offset_l0));

343 memset(slice_param->luma_offset_l1, 0, sizeof(slice_param->luma_offset_l1));

344 memset(slice_param->delta_chroma_weight_l0, 0, sizeof(slice_param->delta_chroma_weight_l0));

345 memset(slice_param->delta_chroma_weight_l1, 0, sizeof(slice_param->delta_chroma_weight_l1));

346 memset(slice_param->ChromaOffsetL0, 0, sizeof(slice_param->ChromaOffsetL0));

347 memset(slice_param->ChromaOffsetL1, 0, sizeof(slice_param->ChromaOffsetL1));

348

349 slice_param->delta_chroma_log2_weight_denom = 0;

350 slice_param->luma_log2_weight_denom = 0;

351

352 if (sh->slice_type == HEVC_SLICE_I ||

353 (sh->slice_type == HEVC_SLICE_P && !h->ps.pps->weighted_pred_flag) ||

354 (sh->slice_type == HEVC_SLICE_B && !h->ps.pps->weighted_bipred_flag))

355 return;

356

357 slice_param->luma_log2_weight_denom = sh->luma_log2_weight_denom;

358

359 if (h->ps.sps->chroma_format_idc) {

360 slice_param->delta_chroma_log2_weight_denom = sh->chroma_log2_weight_denom - sh->luma_log2_weight_denom;

361 }

362

363 for (i = 0; i < 15 && i < sh->nb_refs[L0]; i++) {

364 slice_param->delta_luma_weight_l0[i] = sh->luma_weight_l0[i] - (1 << sh->luma_log2_weight_denom);

365 slice_param->delta_chroma_weight_l0[i][0] = sh->chroma_weight_l0[i][0] - (1 << sh->chroma_log2_weight_denom);

366 slice_param->delta_chroma_weight_l0[i][1] = sh->chroma_weight_l0[i][1] - (1 << sh->chroma_log2_weight_denom);

367 if (!is_rext) {

368 slice_param->luma_offset_l0[i] = sh->luma_offset_l0[i];

369 slice_param->ChromaOffsetL0[i][0] = sh->chroma_offset_l0[i][0];

370 slice_param->ChromaOffsetL0[i][1] = sh->chroma_offset_l0[i][1];

371 }

372 }

373

374 if (sh->slice_type == HEVC_SLICE_B) {

375 for (i = 0; i < 15 && i < sh->nb_refs[L1]; i++) {

376 slice_param->delta_luma_weight_l1[i] = sh->luma_weight_l1[i] - (1 << sh->luma_log2_weight_denom);

377 slice_param->delta_chroma_weight_l1[i][0] = sh->chroma_weight_l1[i][0] - (1 << sh->chroma_log2_weight_denom);

378 slice_param->delta_chroma_weight_l1[i][1] = sh->chroma_weight_l1[i][1] - (1 << sh->chroma_log2_weight_denom);

379 if (!is_rext) {

380 slice_param->luma_offset_l1[i] = sh->luma_offset_l1[i];

381 slice_param->ChromaOffsetL1[i][0] = sh->chroma_offset_l1[i][0];

382 slice_param->ChromaOffsetL1[i][1] = sh->chroma_offset_l1[i][1];

383 }

384 }

385 }

386 }

387

388 static uint8_t get_ref_pic_index(const HEVCContext *h, const HEVCFrame *frame)

389 {

390 VAAPIDecodePictureHEVC *pic = h->ref->hwaccel_picture_private;

391 VAPictureParameterBufferHEVC *pp = (VAPictureParameterBufferHEVC *)&pic->pic_param;

392 uint8_t i;

393

394 if (!frame)

395 return 0xff;

396

397 for (i = 0; i < FF_ARRAY_ELEMS(pp->ReferenceFrames); i++) {

398 VASurfaceID pid = pp->ReferenceFrames[i].picture_id;

399 int poc = pp->ReferenceFrames[i].pic_order_cnt;

400 if (pid != VA_INVALID_ID && pid == ff_vaapi_get_surface_id(frame->frame) && poc == frame->poc)

401 return i;

402 }

403

404 return 0xff;

405 }

406

407 static int vaapi_hevc_decode_slice(AVCodecContext *avctx,

408 const uint8_t *buffer,

409 uint32_t size)

410 {

411 const HEVCContext *h = avctx->priv_data;

412 const SliceHeader *sh = &h->sh;

413 VAAPIDecodePictureHEVC *pic = h->ref->hwaccel_picture_private;

414 VASliceParameterBufferHEVC *last_slice_param = (VASliceParameterBufferHEVC *)&pic->last_slice_param;

415

416 int slice_param_size = avctx->profile == FF_PROFILE_HEVC_REXT ?

417 sizeof(pic->last_slice_param) : sizeof(VASliceParameterBufferHEVC);

418

419 int nb_list = (sh->slice_type == HEVC_SLICE_B) ?

420 2 : (sh->slice_type == HEVC_SLICE_I ? 0 : 1);

421

422 int err, i, list_idx;

423

424 if (!sh->first_slice_in_pic_flag) {

425 err = ff_vaapi_decode_make_slice_buffer(avctx, &pic->pic,

426 &pic->last_slice_param, slice_param_size,

427 pic->last_buffer, pic->last_size);

428 pic->last_buffer = NULL;

429 pic->last_size = 0;

430 if (err) {

431 ff_vaapi_decode_cancel(avctx, &pic->pic);

432 return err;

433 }

434 }

435

436 *last_slice_param = (VASliceParameterBufferHEVC) {

437 .slice_data_size = size,

438 .slice_data_offset = 0,

439 .slice_data_flag = VA_SLICE_DATA_FLAG_ALL,

440 /* Add 1 to the bits count here to account for the byte_alignment bit, which

441 * always is at least one bit and not accounted for otherwise. */

442 .slice_data_byte_offset = (get_bits_count(&h->HEVClc->gb) + 1 + 7) / 8,

443 .slice_segment_address = sh->slice_segment_addr,

444 .slice_qp_delta = sh->slice_qp_delta,

445 .slice_cb_qp_offset = sh->slice_cb_qp_offset,

446 .slice_cr_qp_offset = sh->slice_cr_qp_offset,

447 .slice_beta_offset_div2 = sh->beta_offset / 2,

448 .slice_tc_offset_div2 = sh->tc_offset / 2,

449 .collocated_ref_idx = sh->slice_temporal_mvp_enabled_flag ? sh->collocated_ref_idx : 0xFF,

450 .five_minus_max_num_merge_cand = sh->slice_type == HEVC_SLICE_I ? 0 : 5 - sh->max_num_merge_cand,

451 .num_ref_idx_l0_active_minus1 = sh->nb_refs[L0] ? sh->nb_refs[L0] - 1 : 0,

452 .num_ref_idx_l1_active_minus1 = sh->nb_refs[L1] ? sh->nb_refs[L1] - 1 : 0,

453

454 .LongSliceFlags.fields = {

455 .dependent_slice_segment_flag = sh->dependent_slice_segment_flag,

456 .slice_type = sh->slice_type,

457 .color_plane_id = sh->colour_plane_id,

458 .mvd_l1_zero_flag = sh->mvd_l1_zero_flag,

459 .cabac_init_flag = sh->cabac_init_flag,

460 .slice_temporal_mvp_enabled_flag = sh->slice_temporal_mvp_enabled_flag,

461 .slice_deblocking_filter_disabled_flag = sh->disable_deblocking_filter_flag,

462 .collocated_from_l0_flag = sh->collocated_list == L0 ? 1 : 0,

463 .slice_loop_filter_across_slices_enabled_flag = sh->slice_loop_filter_across_slices_enabled_flag,

464 .slice_sao_luma_flag = sh->slice_sample_adaptive_offset_flag[0],

465 .slice_sao_chroma_flag = sh->slice_sample_adaptive_offset_flag[1],

466 },

467 };

468

469 memset(last_slice_param->RefPicList, 0xFF, sizeof(last_slice_param->RefPicList));

470

471 for (list_idx = 0; list_idx < nb_list; list_idx++) {

472 RefPicList *rpl = &h->ref->refPicList[list_idx];

473

474 for (i = 0; i < rpl->nb_refs; i++)

475 last_slice_param->RefPicList[list_idx][i] = get_ref_pic_index(h, rpl->ref[i]);

476 }

477

478 fill_pred_weight_table(avctx, h, sh, last_slice_param);

479

480 #if VA_CHECK_VERSION(1, 2, 0)

481 if (avctx->profile == FF_PROFILE_HEVC_REXT) {

482 pic->last_slice_param.rext = (VASliceParameterBufferHEVCRext) {

483 .slice_ext_flags.bits = {

484 .cu_chroma_qp_offset_enabled_flag = sh->cu_chroma_qp_offset_enabled_flag,

485 },

486 };

487 for (i = 0; i < 15 && i < sh->nb_refs[L0]; i++) {

488 pic->last_slice_param.rext.luma_offset_l0[i] = sh->luma_offset_l0[i];

489 pic->last_slice_param.rext.ChromaOffsetL0[i][0] = sh->chroma_offset_l0[i][0];

490 pic->last_slice_param.rext.ChromaOffsetL0[i][1] = sh->chroma_offset_l0[i][1];

491 }

492

493 for (i = 0; i < 15 && i < sh->nb_refs[L0]; i++) {

494 pic->last_slice_param.rext.luma_offset_l0[i] = sh->luma_offset_l0[i];

495 pic->last_slice_param.rext.ChromaOffsetL0[i][0] = sh->chroma_offset_l0[i][0];

496 pic->last_slice_param.rext.ChromaOffsetL0[i][1] = sh->chroma_offset_l0[i][1];

497 }

498

499 if (sh->slice_type == HEVC_SLICE_B) {

500 for (i = 0; i < 15 && i < sh->nb_refs[L1]; i++) {

501 pic->last_slice_param.rext.luma_offset_l1[i] = sh->luma_offset_l1[i];

502 pic->last_slice_param.rext.ChromaOffsetL1[i][0] = sh->chroma_offset_l1[i][0];

503 pic->last_slice_param.rext.ChromaOffsetL1[i][1] = sh->chroma_offset_l1[i][1];

504 }

505 }

506 }

507 #endif

508

509 pic->last_buffer = buffer;

510 pic->last_size = size;

511

512 return 0;

513 }

514

515 static int ptl_convert(const PTLCommon *general_ptl, H265RawProfileTierLevel *h265_raw_ptl)

516 {

517 h265_raw_ptl->general_profile_space = general_ptl->profile_space;

518 h265_raw_ptl->general_tier_flag = general_ptl->tier_flag;

519 h265_raw_ptl->general_profile_idc = general_ptl->profile_idc;

520

521 memcpy(h265_raw_ptl->general_profile_compatibility_flag,

522 general_ptl->profile_compatibility_flag, 32 * sizeof(uint8_t));

523

524 #define copy_field(name) h265_raw_ptl->general_ ## name = general_ptl->name

525 copy_field(progressive_source_flag);

526 copy_field(interlaced_source_flag);

527 copy_field(non_packed_constraint_flag);

528 copy_field(frame_only_constraint_flag);

529 copy_field(max_12bit_constraint_flag);

530 copy_field(max_10bit_constraint_flag);

531 copy_field(max_8bit_constraint_flag);

532 copy_field(max_422chroma_constraint_flag);

533 copy_field(max_420chroma_constraint_flag);

534 copy_field(max_monochrome_constraint_flag);

535 copy_field(intra_constraint_flag);

536 copy_field(one_picture_only_constraint_flag);

537 copy_field(lower_bit_rate_constraint_flag);

538 copy_field(max_14bit_constraint_flag);

539 copy_field(inbld_flag);

540 copy_field(level_idc);

541 #undef copy_field

542

543 return 0;

544 }

545

546 /*

547 * Find exact va_profile for HEVC Range Extension

548 */

549 VAProfile ff_vaapi_parse_hevc_rext_profile(AVCodecContext *avctx)

550 {

551 const HEVCContext *h = avctx->priv_data;

552 const HEVCSPS *sps = h->ps.sps;

553 const PTL *ptl = &sps->ptl;

554 const PTLCommon *general_ptl = &ptl->general_ptl;

555 const H265ProfileDescriptor *profile;

556 H265RawProfileTierLevel h265_raw_ptl = {0};

557

558 /* convert PTLCommon to H265RawProfileTierLevel */

559 ptl_convert(general_ptl, &h265_raw_ptl);

560

561 profile = ff_h265_get_profile(&h265_raw_ptl);

562 if (!profile) {

563 av_log(avctx, AV_LOG_WARNING, "HEVC profile is not found.\n");

564 goto end;

565 } else {

566 av_log(avctx, AV_LOG_VERBOSE, "HEVC profile %s is found.\n", profile->name);

567 }

568

569 #if VA_CHECK_VERSION(1, 2, 0)

570 if (!strcmp(profile->name, "Main 12") ||

571 !strcmp(profile->name, "Main 12 Intra"))

572 return VAProfileHEVCMain12;

573 else if (!strcmp(profile->name, "Main 4:2:2 10") ||

574 !strcmp(profile->name, "Main 4:2:2 10 Intra"))

575 return VAProfileHEVCMain422_10;

576 else if (!strcmp(profile->name, "Main 4:2:2 12") ||

577 !strcmp(profile->name, "Main 4:2:2 12 Intra"))

578 return VAProfileHEVCMain422_12;

579 else if (!strcmp(profile->name, "Main 4:4:4") ||

580 !strcmp(profile->name, "Main 4:4:4 Intra"))

581 return VAProfileHEVCMain444;

582 else if (!strcmp(profile->name, "Main 4:4:4 10") ||

583 !strcmp(profile->name, "Main 4:4:4 10 Intra"))

584 return VAProfileHEVCMain444_10;

585 else if (!strcmp(profile->name, "Main 4:4:4 12") ||

586 !strcmp(profile->name, "Main 4:4:4 12 Intra"))

587 return VAProfileHEVCMain444_12;

588 #else

589 av_log(avctx, AV_LOG_WARNING, "HEVC profile %s is "

590 "not supported with this VA version.\n", profile->name);

591 #endif

592

593 end:

594 if (avctx->hwaccel_flags & AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH) {

595 // Default to selecting Main profile if profile mismatch is allowed

596 return VAProfileHEVCMain;

597 } else

598 return VAProfileNone;

599 }

600

601 const AVHWAccel ff_hevc_vaapi_hwaccel = {

602 .name = "hevc_vaapi",

603 .type = AVMEDIA_TYPE_VIDEO,

604 .id = AV_CODEC_ID_HEVC,

605 .pix_fmt = AV_PIX_FMT_VAAPI,

606 .start_frame = vaapi_hevc_start_frame,

607 .end_frame = vaapi_hevc_end_frame,

608 .decode_slice = vaapi_hevc_decode_slice,

609 .frame_priv_data_size = sizeof(VAAPIDecodePictureHEVC),

610 .init = ff_vaapi_decode_init,

611 .uninit = ff_vaapi_decode_uninit,

612 .frame_params = ff_vaapi_common_frame_params,

613 .priv_data_size = sizeof(VAAPIDecodeContext),

614 .caps_internal = HWACCEL_CAP_ASYNC_SAFE,

615 };

hwconfig.h

FF_PROFILE_HEVC_REXT

#define FF_PROFILE_HEVC_REXT

Definition: avcodec.h:1656

SliceHeader::beta_offset

int beta_offset

beta_offset_div2 * 2

Definition: hevcdec.h:300

F H1 F F H1 F F F F H1<-F-------F-------F v v v H2 H3 H2 ^ ^ ^ F-------F-------F-> H1<-F-------F-------F|||||||||F H1 F|||||||||F H1 Funavailable fullpel samples(outside the picture for example) shall be equalto the closest available fullpel sampleSmaller pel interpolation:--------------------------if diag_mc is set then points which lie on a line between 2 vertically, horizontally or diagonally adjacent halfpel points shall be interpolatedlinearly with rounding to nearest and halfway values rounded up.points which lie on 2 diagonals at the same time should only use the onediagonal not containing the fullpel point F--> O q O<--h1-> O q O<--F v \/v \/v O O O O O O O|/|\|q q q q q|/|\|O O O O O O O ^/\ ^/\ ^ h2--> O q O<--h3-> O q O<--h2 v \/v \/v O O O O O O O|\|/|q q q q q|\|/|O O O O O O O ^/\ ^/\ ^ F--> O q O<--h1-> O q O<--Fthe remaining points shall be bilinearly interpolated from theup to 4 surrounding halfpel and fullpel points, again rounding should be tonearest and halfway values rounded upcompliant Snow decoders MUST support 1-1/8 pel luma and 1/2-1/16 pel chromainterpolation at leastOverlapped block motion compensation:-------------------------------------FIXMELL band prediction:===================Each sample in the LL0 subband is predicted by the median of the left, top andleft+top-topleft samples, samples outside the subband shall be considered tobe 0. To reverse this prediction in the decoder apply the following.for(y=0;y< height;y++){ for(x=0;x< width;x++){ sample[y][x]+=median(sample[y-1][x], sample[y][x-1], sample[y-1][x]+sample[y][x-1]-sample[y-1][x-1]);}}sample[-1][ *]=sample[ *][-1]=0;width, height here are the width and height of the LL0 subband not of the finalvideoDequantization:===============FIXMEWavelet Transform:==================Snow supports 2 wavelet transforms, the symmetric biorthogonal 5/3 integertransform and an integer approximation of the symmetric biorthogonal 9/7daubechies wavelet.2D IDWT(inverse discrete wavelet transform) --------------------------------------------The 2D IDWT applies a 2D filter recursively, each time combining the4 lowest frequency subbands into a single subband until only 1 subbandremains.The 2D filter is done by first applying a 1D filter in the vertical directionand then applying it in the horizontal one. --------------- --------------- --------------- ---------------|LL0|HL0|||||||||||||---+---|HL1||L0|H0|HL1||LL1|HL1|||||LH0|HH0|||||||||||||-------+-------|-> L1 H1 LH1 HH1 LH1 HH1 LH1 HH1 L1

Definition: snow.txt:554

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

HEVCFrame::flags

uint8_t flags

A combination of HEVC_FRAME_FLAG_*.

Definition: hevcdec.h:429

SliceHeader::chroma_offset_l1

int16_t chroma_offset_l1[16][2]

Definition: hevcdec.h:324

ff_vaapi_get_surface_id

static VASurfaceID ff_vaapi_get_surface_id(AVFrame *pic)

Definition: vaapi_decode.h:30

vaapi_hevc_end_frame

static int vaapi_hevc_end_frame(AVCodecContext *avctx)

Definition: vaapi_hevc.c:295

VAAPIDecodeContext

Definition: vaapi_decode.h:50

vaapi_decode.h

ff_h265_get_profile

const H265ProfileDescriptor * ff_h265_get_profile(const H265RawProfileTierLevel *ptl)

Definition: h265_profile_level.c:123

get_bits_count

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:256

ff_hevc_vaapi_hwaccel

const AVHWAccel ff_hevc_vaapi_hwaccel

Definition: vaapi_hevc.c:601

av_unused

#define av_unused

Definition: attributes.h:131

VAAPIDecodePicture

Definition: vaapi_decode.h:39

ff_vaapi_decode_make_slice_buffer

int ff_vaapi_decode_make_slice_buffer(AVCodecContext *avctx, VAAPIDecodePicture *pic, const void *params_data, size_t params_size, const void *slice_data, size_t slice_size)

Definition: vaapi_decode.c:61

level_idc

int level_idc

Definition: h264_levels.c:25

AVFrame::top_field_first

int top_field_first

If the content is interlaced, is top field displayed first.

Definition: frame.h:491

SliceHeader::slice_temporal_mvp_enabled_flag

uint8_t slice_temporal_mvp_enabled_flag

Definition: hevcdec.h:280

AV_LOG_VERBOSE

#define AV_LOG_VERBOSE

Detailed information.

Definition: log.h:196

PTLCommon::profile_space

uint8_t profile_space

Definition: hevc_ps.h:80

SliceHeader::slice_loop_filter_across_slices_enabled_flag

uint8_t slice_loop_filter_across_slices_enabled_flag

Definition: hevcdec.h:289

RefPicList

Definition: hevcdec.h:241

H265ProfileDescriptor

Definition: h265_profile_level.h:47

PTLCommon::profile_compatibility_flag

uint8_t profile_compatibility_flag[32]

Definition: hevc_ps.h:83

ptl_convert

static int ptl_convert(const PTLCommon *general_ptl, H265RawProfileTierLevel *h265_raw_ptl)

Definition: vaapi_hevc.c:515

AVHWAccel

Definition: avcodec.h:2076

ff_vaapi_decode_make_param_buffer

int ff_vaapi_decode_make_param_buffer(AVCodecContext *avctx, VAAPIDecodePicture *pic, int type, const void *data, size_t size)

Definition: vaapi_decode.c:32

HEVC_FRAME_FLAG_LONG_REF

#define HEVC_FRAME_FLAG_LONG_REF

Definition: hevcdec.h:395

fail

#define fail()

Definition: checkasm.h:134

SliceHeader::luma_log2_weight_denom

uint8_t luma_log2_weight_denom

Definition: hevcdec.h:312

fill_vaapi_pic

static void fill_vaapi_pic(VAPictureHEVC *va_pic, const HEVCFrame *pic, int rps_type)

Definition: vaapi_hevc.c:54

RefPicList::nb_refs

int nb_refs

Definition: hevcdec.h:245

SliceHeader::slice_segment_addr

unsigned int slice_segment_addr

address (in raster order) of the first block in the current slice

Definition: hevcdec.h:256

VAAPIDecodePicture::output_surface

VASurfaceID output_surface

Definition: vaapi_decode.h:40

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

ptl

const H265RawProfileTierLevel * ptl

Definition: h265_levels.c:170

SliceHeader::cabac_init_flag

uint8_t cabac_init_flag

Definition: hevcdec.h:287

PTLCommon

Definition: hevc_ps.h:79

ff_vaapi_decode_init

int ff_vaapi_decode_init(AVCodecContext *avctx)

Definition: vaapi_decode.c:655

SliceHeader::luma_offset_l1

int16_t luma_offset_l1[16]

Definition: hevcdec.h:323

H265RawProfileTierLevel::general_profile_idc

uint8_t general_profile_idc

Definition: cbs_h265.h:38

ff_vaapi_common_frame_params

int ff_vaapi_common_frame_params(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx)

Definition: vaapi_decode.c:631

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts_bsf.c:365

vaapi_hevc_decode_slice

static int vaapi_hevc_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)

Definition: vaapi_hevc.c:407

fill_vaapi_reference_frames

static void fill_vaapi_reference_frames(const HEVCContext *h, VAPictureParameterBufferHEVC *pp)

Definition: vaapi_hevc.c:94

find_frame_rps_type

static int find_frame_rps_type(const HEVCContext *h, const HEVCFrame *pic)

Definition: vaapi_hevc.c:71

IS_IDR

#define IS_IDR(s)

Definition: hevcdec.h:75

HEVC_FRAME_FLAG_SHORT_REF

#define HEVC_FRAME_FLAG_SHORT_REF

Definition: hevcdec.h:394

RefPicList::ref

struct HEVCFrame * ref[HEVC_MAX_REFS]

Definition: hevcdec.h:242

vaapi_hevc_start_frame

static int vaapi_hevc_start_frame(AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size)

Definition: vaapi_hevc.c:117

ff_vaapi_decode_uninit

int ff_vaapi_decode_uninit(AVCodecContext *avctx)

Definition: vaapi_decode.c:701

HEVC_SLICE_I

@ HEVC_SLICE_I

Definition: hevc.h:98

PTLCommon::profile_idc

uint8_t profile_idc

Definition: hevc_ps.h:82

ScalingList

Definition: hevc_ps.h:133

SliceHeader::collocated_list

uint8_t collocated_list

Definition: hevcdec.h:290

SliceHeader::luma_offset_l0

int16_t luma_offset_l0[16]

Definition: hevcdec.h:320

SliceHeader::chroma_weight_l1

int16_t chroma_weight_l1[16][2]

Definition: hevcdec.h:317

PTLCommon::tier_flag

uint8_t tier_flag

Definition: hevc_ps.h:81

ff_vaapi_decode_issue

int ff_vaapi_decode_issue(AVCodecContext *avctx, VAAPIDecodePicture *pic)

Definition: vaapi_decode.c:153

if(ret)

Definition: filter_design.txt:179

HEVC_SLICE_B

@ HEVC_SLICE_B

Definition: hevc.h:96

NULL

#define NULL

Definition: coverity.c:32

get_ref_pic_index

static uint8_t get_ref_pic_index(const HEVCContext *h, const HEVCFrame *frame)

Definition: vaapi_hevc.c:388

AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH

#define AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH

Hardware acceleration should still be attempted for decoding when the codec profile does not match th...

Definition: avcodec.h:2260

#define L0

Definition: hevcdec.h:57

VAAPIDecodePictureHEVC

Definition: vaapi_hevc.c:33

PTL

Definition: hevc_ps.h:102

init_vaapi_pic

static void init_vaapi_pic(VAPictureHEVC *va_pic)

Definition: vaapi_hevc.c:47

VAAPIDecodePictureHEVC::last_size

size_t last_size

Definition: vaapi_hevc.c:42

SliceHeader::nb_refs

unsigned int nb_refs[2]

Definition: hevcdec.h:282

H265RawProfileTierLevel::general_tier_flag

uint8_t general_tier_flag

Definition: cbs_h265.h:37

IS_IRAP

#define IS_IRAP(s)

Definition: hevcdec.h:78

SliceHeader::colour_plane_id

uint8_t colour_plane_id

RPS coded in the slice header itself is stored here.

Definition: hevcdec.h:267

SliceHeader::dependent_slice_segment_flag

uint8_t dependent_slice_segment_flag

Definition: hevcdec.h:265

SliceHeader::first_slice_in_pic_flag

uint8_t first_slice_in_pic_flag

Definition: hevcdec.h:264

pps

static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)

Definition: cbs_h264_syntax_template.c:404

hevcdec.h

for

for(k=2;k<=8;++k)

Definition: h264pred_template.c:425

size

int size

Definition: twinvq_data.h:10344

SliceHeader::collocated_ref_idx

unsigned int collocated_ref_idx

Definition: hevcdec.h:292

h265_profile_level.h

vaapi_hevc.h

SliceHeader::max_num_merge_cand

unsigned int max_num_merge_cand

5 - 5_minus_max_num_merge_cand

Definition: hevcdec.h:303

ff_vaapi_decode_cancel

int ff_vaapi_decode_cancel(AVCodecContext *avctx, VAAPIDecodePicture *pic)

Definition: vaapi_decode.c:227

SliceHeader::chroma_weight_l0

int16_t chroma_weight_l0[16][2]

Definition: hevcdec.h:316

VAAPIDecodePictureHEVC::last_slice_param

VASliceParameterBufferHEVC last_slice_param

Definition: vaapi_hevc.c:39

SliceHeader::chroma_log2_weight_denom

int16_t chroma_log2_weight_denom

Definition: hevcdec.h:313

AV_PIX_FMT_VAAPI

@ AV_PIX_FMT_VAAPI

Hardware acceleration through VA-API, data[3] contains a VASurfaceID.

Definition: pixfmt.h:119

AVHWAccel::name

const char * name

Name of the hardware accelerated codec.

Definition: avcodec.h:2082

SliceHeader::slice_cb_qp_offset

int slice_cb_qp_offset

Definition: hevcdec.h:295

SliceHeader

Definition: hevcdec.h:252

AVFrame::interlaced_frame

int interlaced_frame

The content of the picture is interlaced.

Definition: frame.h:486

HEVCFrame::frame

AVFrame * frame

Definition: hevcdec.h:402

SliceHeader::slice_sample_adaptive_offset_flag

uint8_t slice_sample_adaptive_offset_flag[3]

Definition: hevcdec.h:284

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:269

HEVCFrame

Definition: hevcdec.h:401

VAAPIDecodePictureHEVC::last_buffer

const uint8_t * last_buffer

Definition: vaapi_hevc.c:41

AVCodecContext::hwaccel_flags

int hwaccel_flags

Bit set of AV_HWACCEL_FLAG_* flags, which affect hardware accelerated decoding (if active).

Definition: avcodec.h:1937

SliceHeader::mvd_l1_zero_flag

uint8_t mvd_l1_zero_flag

Definition: hevcdec.h:285

AV_CODEC_ID_HEVC

@ AV_CODEC_ID_HEVC

Definition: codec_id.h:226

VAAPIDecodePictureHEVC::pic_param

VAPictureParameterBufferHEVC pic_param

Definition: vaapi_hevc.c:38

HEVC_SLICE_P

@ HEVC_SLICE_P

Definition: hevc.h:97

HWACCEL_CAP_ASYNC_SAFE

#define HWACCEL_CAP_ASYNC_SAFE

Definition: hwconfig.h:26

copy_field

#define copy_field(name)

SliceHeader::chroma_offset_l0

int16_t chroma_offset_l0[16][2]

Definition: hevcdec.h:321

profile

int profile

Definition: mxfenc.c:2009

H265RawProfileTierLevel

Definition: cbs_h265.h:35

HEVCFrame::poc

int poc

Definition: hevcdec.h:410

H265RawProfileTierLevel::general_profile_space

uint8_t general_profile_space

Definition: cbs_h265.h:36

avcodec.h

H265RawProfileTierLevel::general_profile_compatibility_flag

uint8_t general_profile_compatibility_flag[32]

Definition: cbs_h265.h:40

ret

Definition: filter_design.txt:187

frame

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame

Definition: filter_design.txt:264

ST_CURR_BEF

@ ST_CURR_BEF

Definition: hevcdec.h:81

SliceHeader::disable_deblocking_filter_flag

uint8_t disable_deblocking_filter_flag

slice_header_disable_deblocking_filter_flag

Definition: hevcdec.h:288

sps

static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)

Definition: cbs_h264_syntax_template.c:260

SliceHeader::luma_weight_l0

int16_t luma_weight_l0[16]

Definition: hevcdec.h:315

SliceHeader::slice_type

enum HEVCSliceType slice_type

Definition: hevcdec.h:260

LT_CURR

@ LT_CURR

Definition: hevcdec.h:84

AVCodecContext

main external API structure.

Definition: avcodec.h:426

buffer

the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer

Definition: filter_design.txt:49

fill_pred_weight_table

static void fill_pred_weight_table(AVCodecContext *avctx, const HEVCContext *h, const SliceHeader *sh, VASliceParameterBufferHEVC *slice_param)

Definition: vaapi_hevc.c:325

SliceHeader::slice_cr_qp_offset

int slice_cr_qp_offset

Definition: hevcdec.h:296

HEVCContext

Definition: hevcdec.h:490

AVCodecContext::profile

int profile

profile