FFmpeg: libavcodec/vaapi_h264.c Source File

FFmpeg

[フレーム]

libavcodec

vaapi_h264.c

Go to the documentation of this file.

1 /*

2 * H.264 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 "h264dec.h"

24 #include "h264_ps.h"

25 #include "hwaccel_internal.h"

26 #include "vaapi_decode.h"

28 /**

29 * @file

30 * This file implements the glue code between FFmpeg's and VA API's

31 * structures for H.264 decoding.

32 */

34 /**

35 * Initialize an empty VA API picture.

36 *

37 * VA API requires a fixed-size reference picture array.

38 */

39 static void init_vaapi_pic(VAPictureH264 *va_pic)

40 {

41 va_pic->picture_id = VA_INVALID_ID;

42 va_pic->flags = VA_PICTURE_H264_INVALID;

43 va_pic->TopFieldOrderCnt = 0;

44 va_pic->BottomFieldOrderCnt = 0;

45 }

47 /**

48 * Translate an FFmpeg Picture into its VA API form.

49 *

50 * @param[out] va_pic A pointer to VA API's own picture struct

51 * @param[in] pic A pointer to the FFmpeg picture struct to convert

52 * @param[in] pic_structure The picture field type (as defined in mpegvideo.h),

53 * supersedes pic's field type if nonzero.

54 */

55 static void fill_vaapi_pic(VAPictureH264 *va_pic,

56 const H264Picture *pic,

57 int pic_structure)

58 {

59 if (pic_structure == 0)

60 pic_structure = pic->reference;

61 pic_structure &= PICT_FRAME; /* PICT_TOP_FIELD|PICT_BOTTOM_FIELD */

63 va_pic->picture_id = ff_vaapi_get_surface_id(pic->f);

64 va_pic->frame_idx = pic->long_ref ? pic->pic_id : pic->frame_num;

66 va_pic->flags = 0;

67 if (pic_structure != PICT_FRAME)

68 va_pic->flags |= (pic_structure & PICT_TOP_FIELD) ? VA_PICTURE_H264_TOP_FIELD : VA_PICTURE_H264_BOTTOM_FIELD;

69 if (pic->reference)

70 va_pic->flags |= pic->long_ref ? VA_PICTURE_H264_LONG_TERM_REFERENCE : VA_PICTURE_H264_SHORT_TERM_REFERENCE;

72 va_pic->TopFieldOrderCnt = 0;

73 if (pic->field_poc[0] != INT_MAX)

74 va_pic->TopFieldOrderCnt = pic->field_poc[0];

76 va_pic->BottomFieldOrderCnt = 0;

77 if (pic->field_poc[1] != INT_MAX)

78 va_pic->BottomFieldOrderCnt = pic->field_poc[1];

79 }

81 /** Decoded Picture Buffer (DPB). */

82 typedef struct DPB {

83 int size; ///< Current number of reference frames in the DPB

84 int max_size; ///< Max number of reference frames. This is FF_ARRAY_ELEMS(VAPictureParameterBufferH264.ReferenceFrames)

85 VAPictureH264 *va_pics; ///< Pointer to VAPictureParameterBufferH264.ReferenceFrames array

86 } DPB;

88 /**

89 * Append picture to the decoded picture buffer, in a VA API form that

90 * merges the second field picture attributes with the first, if

91 * available. The decoded picture buffer's size must be large enough

92 * to receive the new VA API picture object.

93 */

94 static int dpb_add(DPB *dpb, const H264Picture *pic)

95 {

96 int i, pic_frame_idx, merged = 0;

98 if (dpb->size >= dpb->max_size)

99 return -1;

100

101 pic_frame_idx = pic->long_ref ? pic->pic_id : pic->frame_num;

102

103 for (i = 0; i < dpb->size; i++) {

104 VAPictureH264 * const va_pic = &dpb->va_pics[i];

105 int va_pic_long_ref = !!(va_pic->flags & VA_PICTURE_H264_LONG_TERM_REFERENCE);

106 if (va_pic->picture_id == ff_vaapi_get_surface_id(pic->f) &&

107 va_pic_long_ref == pic->long_ref &&

108 va_pic->frame_idx == pic_frame_idx) {

109 VAPictureH264 temp_va_pic;

110 fill_vaapi_pic(&temp_va_pic, pic, 0);

111

112 if ((temp_va_pic.flags ^ va_pic->flags) & (VA_PICTURE_H264_TOP_FIELD | VA_PICTURE_H264_BOTTOM_FIELD)) {

113 va_pic->flags |= temp_va_pic.flags & (VA_PICTURE_H264_TOP_FIELD | VA_PICTURE_H264_BOTTOM_FIELD);

114 /* Merge second field */

115 if (temp_va_pic.flags & VA_PICTURE_H264_TOP_FIELD) {

116 va_pic->TopFieldOrderCnt = temp_va_pic.TopFieldOrderCnt;

117 } else {

118 va_pic->BottomFieldOrderCnt = temp_va_pic.BottomFieldOrderCnt;

119 }

120 merged = 1;

121 }

122 }

123 }

124

125 if (merged)

126 return 0;

127

128 fill_vaapi_pic(&dpb->va_pics[dpb->size++], pic, 0);

129 return 0;

130 }

131

132 /** Fill in VA API reference frames array. */

133 static int fill_vaapi_ReferenceFrames(VAPictureParameterBufferH264 *pic_param,

134 const H264Context *h)

135 {

136 DPB dpb;

137 int i;

138

139 dpb.size = 0;

140 dpb.max_size = FF_ARRAY_ELEMS(pic_param->ReferenceFrames);

141 dpb.va_pics = pic_param->ReferenceFrames;

142 for (i = 0; i < dpb.max_size; i++)

143 init_vaapi_pic(&dpb.va_pics[i]);

144

145 for (i = 0; i < h->short_ref_count; i++) {

146 const H264Picture *pic = h->short_ref[i];

147 if (pic && pic->reference && dpb_add(&dpb, pic) < 0)

148 return -1;

149 }

150

151 for (i = 0; i < 16; i++) {

152 const H264Picture *pic = h->long_ref[i];

153 if (pic && pic->reference && dpb_add(&dpb, pic) < 0)

154 return -1;

155 }

156 return 0;

157 }

158

159 /**

160 * Fill in VA API reference picture lists from the FFmpeg reference

161 * picture list.

162 *

163 * @param[out] RefPicList VA API internal reference picture list

164 * @param[in] ref_list A pointer to the FFmpeg reference list

165 * @param[in] ref_count The number of reference pictures in ref_list

166 */

167 static void fill_vaapi_RefPicList(VAPictureH264 RefPicList[32],

168 const H264Ref *ref_list,

169 unsigned int ref_count)

170 {

171 unsigned int i, n = 0;

172 for (i = 0; i < ref_count; i++)

173 if (ref_list[i].reference)

174 fill_vaapi_pic(&RefPicList[n++], ref_list[i].parent,

175 ref_list[i].reference);

176

177 for (; n < 32; n++)

178 init_vaapi_pic(&RefPicList[n]);

179 }

180

181 /**

182 * Fill in prediction weight table.

183 *

184 * VA API requires a plain prediction weight table as it does not infer

185 * any value.

186 *

187 * @param[in] h A pointer to the current H.264 context

188 * @param[in] list The reference frame list index to use

189 * @param[out] luma_weight_flag VA API plain luma weight flag

190 * @param[out] luma_weight VA API plain luma weight table

191 * @param[out] luma_offset VA API plain luma offset table

192 * @param[out] chroma_weight_flag VA API plain chroma weight flag

193 * @param[out] chroma_weight VA API plain chroma weight table

194 * @param[out] chroma_offset VA API plain chroma offset table

195 */

196 static void fill_vaapi_plain_pred_weight_table(const H264Context *h,

197 int list,

198 unsigned char *luma_weight_flag,

199 short luma_weight[32],

200 short luma_offset[32],

201 unsigned char *chroma_weight_flag,

202 short chroma_weight[32][2],

203 short chroma_offset[32][2])

204 {

205 const H264SliceContext *sl = &h->slice_ctx[0];

206 unsigned int i, j;

207

208 *luma_weight_flag = sl->pwt.luma_weight_flag[list];

209 *chroma_weight_flag = sl->pwt.chroma_weight_flag[list];

210

211 for (i = 0; i < sl->ref_count[list]; i++) {

212 /* VA API also wants the inferred (default) values, not

213 only what is available in the bitstream (7.4.3.2). */

214 if (sl->pwt.luma_weight_flag[list]) {

215 luma_weight[i] = sl->pwt.luma_weight[i][list][0];

216 luma_offset[i] = sl->pwt.luma_weight[i][list][1];

217 } else {

218 luma_weight[i] = 1 << sl->pwt.luma_log2_weight_denom;

219 luma_offset[i] = 0;

220 }

221 for (j = 0; j < 2; j++) {

222 if (sl->pwt.chroma_weight_flag[list]) {

223 chroma_weight[i][j] = sl->pwt.chroma_weight[i][list][j][0];

224 chroma_offset[i][j] = sl->pwt.chroma_weight[i][list][j][1];

225 } else {

226 chroma_weight[i][j] = 1 << sl->pwt.chroma_log2_weight_denom;

227 chroma_offset[i][j] = 0;

228 }

229 }

230 }

231 }

232

233 /** Initialize and start decoding a frame with VA API. */

234 static int vaapi_h264_start_frame(AVCodecContext *avctx,

235 av_unused const AVBufferRef *buffer_ref,

236 av_unused const uint8_t *buffer,

237 av_unused uint32_t size)

238 {

239 const H264Context *h = avctx->priv_data;

240 VAAPIDecodePicture *pic = h->cur_pic_ptr->hwaccel_picture_private;

241 const PPS *pps = h->ps.pps;

242 const SPS *sps = h->ps.sps;

243 VAPictureParameterBufferH264 pic_param;

244 VAIQMatrixBufferH264 iq_matrix;

245 int err;

246

247 pic->output_surface = ff_vaapi_get_surface_id(h->cur_pic_ptr->f);

248

249 pic_param = (VAPictureParameterBufferH264) {

250 .picture_width_in_mbs_minus1 = h->mb_width - 1,

251 .picture_height_in_mbs_minus1 = h->mb_height - 1,

252 .bit_depth_luma_minus8 = sps->bit_depth_luma - 8,

253 .bit_depth_chroma_minus8 = sps->bit_depth_chroma - 8,

254 .num_ref_frames = sps->ref_frame_count,

255 .seq_fields.bits = {

256 .chroma_format_idc = sps->chroma_format_idc,

257 .residual_colour_transform_flag = sps->residual_color_transform_flag,

258 .gaps_in_frame_num_value_allowed_flag = sps->gaps_in_frame_num_allowed_flag,

259 .frame_mbs_only_flag = sps->frame_mbs_only_flag,

260 .mb_adaptive_frame_field_flag = sps->mb_aff,

261 .direct_8x8_inference_flag = sps->direct_8x8_inference_flag,

262 .MinLumaBiPredSize8x8 = sps->level_idc >= 31, /* A.3.3.2 */

263 .log2_max_frame_num_minus4 = sps->log2_max_frame_num - 4,

264 .pic_order_cnt_type = sps->poc_type,

265 .log2_max_pic_order_cnt_lsb_minus4 = sps->log2_max_poc_lsb - 4,

266 .delta_pic_order_always_zero_flag = sps->delta_pic_order_always_zero_flag,

267 },

268 .pic_init_qp_minus26 = pps->init_qp - 26,

269 .pic_init_qs_minus26 = pps->init_qs - 26,

270 .chroma_qp_index_offset = pps->chroma_qp_index_offset[0],

271 .second_chroma_qp_index_offset = pps->chroma_qp_index_offset[1],

272 .pic_fields.bits = {

273 .entropy_coding_mode_flag = pps->cabac,

274 .weighted_pred_flag = pps->weighted_pred,

275 .weighted_bipred_idc = pps->weighted_bipred_idc,

276 .transform_8x8_mode_flag = pps->transform_8x8_mode,

277 .field_pic_flag = h->picture_structure != PICT_FRAME,

278 .constrained_intra_pred_flag = pps->constrained_intra_pred,

279 .pic_order_present_flag = pps->pic_order_present,

280 .deblocking_filter_control_present_flag = pps->deblocking_filter_parameters_present,

281 .redundant_pic_cnt_present_flag = pps->redundant_pic_cnt_present,

282 .reference_pic_flag = h->nal_ref_idc != 0,

283 },

284 .frame_num = h->poc.frame_num,

285 };

286

287 fill_vaapi_pic(&pic_param.CurrPic, h->cur_pic_ptr, h->picture_structure);

288 err = fill_vaapi_ReferenceFrames(&pic_param, h);

289 if (err < 0)

290 goto fail;

291

292 err = ff_vaapi_decode_make_param_buffer(avctx, pic,

293 VAPictureParameterBufferType,

294 &pic_param, sizeof(pic_param));

295 if (err < 0)

296 goto fail;

297

298 memcpy(iq_matrix.ScalingList4x4,

299 pps->scaling_matrix4, sizeof(iq_matrix.ScalingList4x4));

300 memcpy(iq_matrix.ScalingList8x8[0],

301 pps->scaling_matrix8[0], sizeof(iq_matrix.ScalingList8x8[0]));

302 memcpy(iq_matrix.ScalingList8x8[1],

303 pps->scaling_matrix8[3], sizeof(iq_matrix.ScalingList8x8[0]));

304

305 err = ff_vaapi_decode_make_param_buffer(avctx, pic,

306 VAIQMatrixBufferType,

307 &iq_matrix, sizeof(iq_matrix));

308 if (err < 0)

309 goto fail;

310

311 return 0;

312

313 fail:

314 ff_vaapi_decode_cancel(avctx, pic);

315 return err;

316 }

317

318 /** End a hardware decoding based frame. */

319 static int vaapi_h264_end_frame(AVCodecContext *avctx)

320 {

321 const H264Context *h = avctx->priv_data;

322 VAAPIDecodePicture *pic = h->cur_pic_ptr->hwaccel_picture_private;

323 H264SliceContext *sl = &h->slice_ctx[0];

324 int ret;

325

326 ret = ff_vaapi_decode_issue(avctx, pic);

327 if (ret < 0)

328 goto finish;

329

330 ff_h264_draw_horiz_band(h, sl, 0, h->avctx->height);

331

332 finish:

333 return ret;

334 }

335

336 /** Decode the given H.264 slice with VA API. */

337 static int vaapi_h264_decode_slice(AVCodecContext *avctx,

338 const uint8_t *buffer,

339 uint32_t size)

340 {

341 const H264Context *h = avctx->priv_data;

342 VAAPIDecodePicture *pic = h->cur_pic_ptr->hwaccel_picture_private;

343 const H264SliceContext *sl = &h->slice_ctx[0];

344 VASliceParameterBufferH264 slice_param;

345 int err;

346

347 slice_param = (VASliceParameterBufferH264) {

348 .slice_data_size = size,

349 .slice_data_offset = 0,

350 .slice_data_flag = VA_SLICE_DATA_FLAG_ALL,

351 .slice_data_bit_offset = get_bits_count(&sl->gb),

352 .first_mb_in_slice = (sl->mb_y >> FIELD_OR_MBAFF_PICTURE(h)) * h->mb_width + sl->mb_x,

353 .slice_type = ff_h264_get_slice_type(sl),

354 .direct_spatial_mv_pred_flag = sl->slice_type == AV_PICTURE_TYPE_B ? sl->direct_spatial_mv_pred : 0,

355 .num_ref_idx_l0_active_minus1 = sl->list_count > 0 ? sl->ref_count[0] - 1 : 0,

356 .num_ref_idx_l1_active_minus1 = sl->list_count > 1 ? sl->ref_count[1] - 1 : 0,

357 .cabac_init_idc = sl->cabac_init_idc,

358 .slice_qp_delta = sl->qscale - h->ps.pps->init_qp,

359 .disable_deblocking_filter_idc = sl->deblocking_filter < 2 ? !sl->deblocking_filter : sl->deblocking_filter,

360 .slice_alpha_c0_offset_div2 = sl->slice_alpha_c0_offset / 2,

361 .slice_beta_offset_div2 = sl->slice_beta_offset / 2,

362 .luma_log2_weight_denom = sl->pwt.luma_log2_weight_denom,

363 .chroma_log2_weight_denom = sl->pwt.chroma_log2_weight_denom,

364 };

365

366 fill_vaapi_RefPicList(slice_param.RefPicList0, sl->ref_list[0],

367 sl->list_count > 0 ? sl->ref_count[0] : 0);

368 fill_vaapi_RefPicList(slice_param.RefPicList1, sl->ref_list[1],

369 sl->list_count > 1 ? sl->ref_count[1] : 0);

370

371 fill_vaapi_plain_pred_weight_table(h, 0,

372 &slice_param.luma_weight_l0_flag,

373 slice_param.luma_weight_l0,

374 slice_param.luma_offset_l0,

375 &slice_param.chroma_weight_l0_flag,

376 slice_param.chroma_weight_l0,

377 slice_param.chroma_offset_l0);

378 fill_vaapi_plain_pred_weight_table(h, 1,

379 &slice_param.luma_weight_l1_flag,

380 slice_param.luma_weight_l1,

381 slice_param.luma_offset_l1,

382 &slice_param.chroma_weight_l1_flag,

383 slice_param.chroma_weight_l1,

384 slice_param.chroma_offset_l1);

385

386 err = ff_vaapi_decode_make_slice_buffer(avctx, pic,

387 &slice_param, 1, sizeof(slice_param),

388 buffer, size);

389 if (err) {

390 ff_vaapi_decode_cancel(avctx, pic);

391 return err;

392 }

393

394 return 0;

395 }

396

397 const FFHWAccel ff_h264_vaapi_hwaccel = {

398 .p.name = "h264_vaapi",

399 .p.type = AVMEDIA_TYPE_VIDEO,

400 .p.id = AV_CODEC_ID_H264,

401 .p.pix_fmt = AV_PIX_FMT_VAAPI,

402 .start_frame = &vaapi_h264_start_frame,

403 .end_frame = &vaapi_h264_end_frame,

404 .decode_slice = &vaapi_h264_decode_slice,

405 .frame_priv_data_size = sizeof(VAAPIDecodePicture),

406 .init = &ff_vaapi_decode_init,

407 .uninit = &ff_vaapi_decode_uninit,

408 .frame_params = &ff_vaapi_common_frame_params,

409 .priv_data_size = sizeof(VAAPIDecodeContext),

410 .caps_internal = HWACCEL_CAP_ASYNC_SAFE,

411 };

PICT_FRAME

#define PICT_FRAME

Definition: mpegutils.h:33

ff_vaapi_get_surface_id

static VASurfaceID ff_vaapi_get_surface_id(AVFrame *pic)

Definition: vaapi_decode.h:30

H264Picture::f

AVFrame * f

Definition: h264dec.h:113

VAAPIDecodeContext

Definition: vaapi_decode.h:47

H264Ref

Definition: h264dec.h:167

vaapi_decode.h

get_bits_count

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:250

av_unused

#define av_unused

Definition: attributes.h:151

FFHWAccel::p

AVHWAccel p

The public AVHWAccel.

Definition: hwaccel_internal.h:38

VAAPIDecodePicture

Definition: vaapi_decode.h:35

H264SliceContext::ref_count

unsigned int ref_count[2]

num_ref_idx_l0/1_active_minus1 + 1

Definition: h264dec.h:268

vaapi_h264_start_frame

static int vaapi_h264_start_frame(AVCodecContext *avctx, av_unused const AVBufferRef *buffer_ref, av_unused const uint8_t *buffer, av_unused uint32_t size)

Initialize and start decoding a frame with VA API.

Definition: vaapi_h264.c:234

DPB

Decoded Picture Buffer (DPB).

Definition: vaapi_h264.c:82

RefPicList

Definition: hevcdec.h:194

fill_vaapi_RefPicList

static void fill_vaapi_RefPicList(VAPictureH264 RefPicList[32], const H264Ref *ref_list, unsigned int ref_count)

Fill in VA API reference picture lists from the FFmpeg reference picture list.

Definition: vaapi_h264.c:167

DPB::size

int size

Current number of reference frames in the DPB.

Definition: vaapi_h264.c:83

ff_h264_vaapi_hwaccel

const FFHWAccel ff_h264_vaapi_hwaccel

Definition: vaapi_h264.c:397

H264SliceContext::mb_x

int mb_x

Definition: h264dec.h:231

H264Picture::frame_num

int frame_num

frame_num (raw frame_num from slice header)

Definition: h264dec.h:134

H264SliceContext

Definition: h264dec.h:178

vaapi_h264_decode_slice

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

Decode the given H.264 slice with VA API.

Definition: vaapi_h264.c:337

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:34

finish

static void finish(void)

Definition: movenc.c:374

FFHWAccel

Definition: hwaccel_internal.h:34

fail

#define fail()

Definition: checkasm.h:206

DPB::max_size

int max_size

Max number of reference frames. This is FF_ARRAY_ELEMS(VAPictureParameterBufferH264....

Definition: vaapi_h264.c:84

H264SliceContext::deblocking_filter

int deblocking_filter

disable_deblocking_filter_idc with 1 <-> 0

Definition: h264dec.h:194

H264PredWeightTable::luma_log2_weight_denom

int luma_log2_weight_denom

Definition: h264_parse.h:72

H264SliceContext::direct_spatial_mv_pred

int direct_spatial_mv_pred

Definition: h264dec.h:252

VAAPIDecodePicture::output_surface

VASurfaceID output_surface

Definition: vaapi_decode.h:36

H264PredWeightTable::chroma_weight

int chroma_weight[48][2][2][2]

Definition: h264_parse.h:78

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

ff_vaapi_decode_init

int ff_vaapi_decode_init(AVCodecContext *avctx)

Definition: vaapi_decode.c:692

H264PredWeightTable::chroma_log2_weight_denom

int chroma_log2_weight_denom

Definition: h264_parse.h:73

ff_vaapi_common_frame_params

int ff_vaapi_common_frame_params(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx)

Definition: vaapi_decode.c:668

H264PredWeightTable::chroma_weight_flag

int chroma_weight_flag[2]

7.4.3.2 chroma_weight_lX_flag

Definition: h264_parse.h:75

PICT_TOP_FIELD

#define PICT_TOP_FIELD

Definition: mpegutils.h:31

H264SliceContext::slice_alpha_c0_offset

int slice_alpha_c0_offset

Definition: h264dec.h:195

ff_vaapi_decode_uninit

int ff_vaapi_decode_uninit(AVCodecContext *avctx)

Definition: vaapi_decode.c:738

fill_vaapi_plain_pred_weight_table

static void fill_vaapi_plain_pred_weight_table(const H264Context *h, int list, unsigned char *luma_weight_flag, short luma_weight[32], short luma_offset[32], unsigned char *chroma_weight_flag, short chroma_weight[32][2], short chroma_offset[32][2])

Fill in prediction weight table.

Definition: vaapi_h264.c:196

H264PredWeightTable::luma_weight

int luma_weight[48][2][2]

Definition: h264_parse.h:77

H264SliceContext::slice_type

int slice_type

Definition: h264dec.h:184

AV_CODEC_ID_H264

@ AV_CODEC_ID_H264

Definition: codec_id.h:79

ff_h264_draw_horiz_band

void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl, int y, int height)

Definition: h264dec.c:104

ff_vaapi_decode_issue

int ff_vaapi_decode_issue(AVCodecContext *avctx, VAAPIDecodePicture *pic)

Definition: vaapi_decode.c:166

HWACCEL_CAP_ASYNC_SAFE

#define HWACCEL_CAP_ASYNC_SAFE

Header providing the internals of AVHWAccel.

Definition: hwaccel_internal.h:31

hwaccel_internal.h

SPS

Sequence parameter set.

Definition: h264_ps.h:44

PPS

Picture parameter set.

Definition: h264_ps.h:110

list

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list

Definition: filter_design.txt:25

H264SliceContext::qscale

int qscale

Definition: h264dec.h:188

FIELD_OR_MBAFF_PICTURE

#define FIELD_OR_MBAFF_PICTURE(h)

Definition: h264dec.h:82

h264_ps.h

H264Picture::pic_id

int pic_id

pic_num (short -> no wrap version of pic_num, pic_num & max_pic_num; long -> long_pic_num)

Definition: h264dec.h:137

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:368

H264Picture::reference

int reference

Definition: h264dec.h:150

H264SliceContext::pwt

H264PredWeightTable pwt

Definition: h264dec.h:198

size

int size

Definition: twinvq_data.h:10344

ff_vaapi_decode_cancel

int ff_vaapi_decode_cancel(AVCodecContext *avctx, VAAPIDecodePicture *pic)

Definition: vaapi_decode.c:247

H264SliceContext::mb_y

int mb_y

Definition: h264dec.h:231

AV_PIX_FMT_VAAPI

@ AV_PIX_FMT_VAAPI

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

Definition: pixfmt.h:126

AVHWAccel::name

const char * name

Name of the hardware accelerated codec.

Definition: avcodec.h:1949

h264dec.h

uninit

static void uninit(AVBSFContext *ctx)

Definition: pcm_rechunk.c:68

H264Context

H264Context.

Definition: h264dec.h:338

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

Definition: cbs_h2645.c:256

vaapi_h264_end_frame

static int vaapi_h264_end_frame(AVCodecContext *avctx)

End a hardware decoding based frame.

Definition: vaapi_h264.c:319

H264SliceContext::list_count

unsigned int list_count

Definition: h264dec.h:269

ret

Definition: filter_design.txt:187

sps

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

Definition: cbs_h264_syntax_template.c:260

H264SliceContext::slice_beta_offset

int slice_beta_offset

Definition: h264dec.h:196

AVCodecContext

main external API structure.

Definition: avcodec.h:431

H264Picture::field_poc

int field_poc[2]

top/bottom POC

Definition: h264dec.h:132

AV_PICTURE_TYPE_B

@ AV_PICTURE_TYPE_B

Bi-dir predicted.

Definition: avutil.h:280

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

ff_vaapi_decode_make_slice_buffer

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

Definition: vaapi_decode.c:75

H264Picture

Definition: h264dec.h:112

fill_vaapi_pic

static void fill_vaapi_pic(VAPictureH264 *va_pic, const H264Picture *pic, int pic_structure)

Translate an FFmpeg Picture into its VA API form.

Definition: vaapi_h264.c:55

pps

uint64_t pps

Definition: dovi_rpuenc.c:36

H264SliceContext::ref_list

H264Ref ref_list[2][48]