FFmpeg: libavcodec/vaapi_vc1.c Source File

FFmpeg

[フレーム]

libavcodec

vaapi_vc1.c

Go to the documentation of this file.

1 /*

2 * VC-1 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 "config_components.h"

25 #include "hwconfig.h"

26 #include "mpegvideodec.h"

27 #include "vaapi_decode.h"

28 #include "vc1.h"

29 #include "vc1data.h"

31 /** Translate FFmpeg MV modes to VA API */

32 static int get_VAMvModeVC1(enum MVModes mv_mode)

33 {

34 switch (mv_mode) {

35 case MV_PMODE_1MV_HPEL_BILIN: return VAMvMode1MvHalfPelBilinear;

36 case MV_PMODE_1MV: return VAMvMode1Mv;

37 case MV_PMODE_1MV_HPEL: return VAMvMode1MvHalfPel;

38 case MV_PMODE_MIXED_MV: return VAMvModeMixedMv;

39 case MV_PMODE_INTENSITY_COMP: return VAMvModeIntensityCompensation;

40 }

41 return 0;

42 }

44 /** Check whether the MVTYPEMB bitplane is present */

45 static inline int vc1_has_MVTYPEMB_bitplane(const VC1Context *v)

46 {

47 if (v->mv_type_is_raw)

48 return 0;

49 return v->fcm == PROGRESSIVE &&

50 (v->s.pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) &&

51 (v->mv_mode == MV_PMODE_MIXED_MV ||

52 (v->mv_mode == MV_PMODE_INTENSITY_COMP &&

53 v->mv_mode2 == MV_PMODE_MIXED_MV));

54 }

56 /** Check whether the SKIPMB bitplane is present */

57 static inline int vc1_has_SKIPMB_bitplane(const VC1Context *v)

58 {

59 if (v->skip_is_raw)

60 return 0;

61 return (v->fcm == PROGRESSIVE || v->fcm == ILACE_FRAME) &&

62 ((v->s.pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) ||

63 (v->s.pict_type == AV_PICTURE_TYPE_B && !v->bi_type));

64 }

66 /** Check whether the DIRECTMB bitplane is present */

67 static inline int vc1_has_DIRECTMB_bitplane(const VC1Context *v)

68 {

69 if (v->dmb_is_raw)

70 return 0;

71 return (v->fcm == PROGRESSIVE || v->fcm == ILACE_FRAME) &&

72 (v->s.pict_type == AV_PICTURE_TYPE_B && !v->bi_type);

73 }

75 /** Check whether the ACPRED bitplane is present */

76 static inline int vc1_has_ACPRED_bitplane(const VC1Context *v)

77 {

78 if (v->acpred_is_raw)

79 return 0;

80 return v->profile == PROFILE_ADVANCED &&

81 (v->s.pict_type == AV_PICTURE_TYPE_I ||

82 (v->s.pict_type == AV_PICTURE_TYPE_B && v->bi_type));

83 }

85 /** Check whether the OVERFLAGS bitplane is present */

86 static inline int vc1_has_OVERFLAGS_bitplane(const VC1Context *v)

87 {

88 if (v->overflg_is_raw)

89 return 0;

90 return v->profile == PROFILE_ADVANCED &&

91 (v->s.pict_type == AV_PICTURE_TYPE_I ||

92 (v->s.pict_type == AV_PICTURE_TYPE_B && v->bi_type)) &&

93 (v->overlap && v->pq <= 8) &&

94 v->condover == CONDOVER_SELECT;

95 }

97 /** Check whether the FIELDTX bitplane is present */

98 static inline int vc1_has_FIELDTX_bitplane(const VC1Context *v)

99 {

100 if (v->fieldtx_is_raw)

101 return 0;

102 return v->fcm == ILACE_FRAME &&

103 (v->s.pict_type == AV_PICTURE_TYPE_I ||

104 (v->s.pict_type == AV_PICTURE_TYPE_B && v->bi_type));

105 }

106

107 /** Check whether the FORWARDMB bitplane is present */

108 static inline int vc1_has_FORWARDMB_bitplane(const VC1Context *v)

109 {

110 if (v->fmb_is_raw)

111 return 0;

112 return v->fcm == ILACE_FIELD &&

113 (v->s.pict_type == AV_PICTURE_TYPE_B && !v->bi_type);

114 }

115

116 /** Reconstruct bitstream PTYPE (7.1.1.4, index into Table-35) */

117 static int vc1_get_PTYPE(const VC1Context *v)

118 {

119 const MpegEncContext *s = &v->s;

120 switch (s->pict_type) {

121 case AV_PICTURE_TYPE_I: return 0;

122 case AV_PICTURE_TYPE_P: return v->p_frame_skipped ? 4 : 1;

123 case AV_PICTURE_TYPE_B: return v->bi_type ? 3 : 2;

124 }

125 return 0;

126 }

127

128 /** Reconstruct bitstream FPTYPE (9.1.1.42, index into Table-105) */

129 static int vc1_get_FPTYPE(const VC1Context *v)

130 {

131 const MpegEncContext *s = &v->s;

132 switch (s->pict_type) {

133 case AV_PICTURE_TYPE_I: return 0;

134 case AV_PICTURE_TYPE_P: return 3;

135 case AV_PICTURE_TYPE_B: return v->bi_type ? 7 : 4;

136 }

137 return 0;

138 }

139

140 /** Reconstruct bitstream MVMODE (7.1.1.32) */

141 static inline VAMvModeVC1 vc1_get_MVMODE(const VC1Context *v)

142 {

143 if ((v->fcm == PROGRESSIVE || v->fcm == ILACE_FIELD) &&

144 ((v->s.pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) ||

145 (v->s.pict_type == AV_PICTURE_TYPE_B && !v->bi_type)))

146 return get_VAMvModeVC1(v->mv_mode);

147 return 0;

148 }

149

150 /** Reconstruct bitstream MVMODE2 (7.1.1.33) */

151 static inline VAMvModeVC1 vc1_get_MVMODE2(const VC1Context *v)

152 {

153 if ((v->fcm == PROGRESSIVE || v->fcm == ILACE_FIELD) &&

154 (v->s.pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) &&

155 v->mv_mode == MV_PMODE_INTENSITY_COMP)

156 return get_VAMvModeVC1(v->mv_mode2);

157 return 0;

158 }

159

160 av_unused static inline int vc1_get_INTCOMPFIELD(const VC1Context *v)

161 {

162 if ((v->s.pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) &&

163 v->fcm == ILACE_FIELD &&

164 v->mv_mode == MV_PMODE_INTENSITY_COMP)

165 switch (v->intcompfield) {

166 case 1: return 1;

167 case 2: return 2;

168 case 3: return 0;

169 }

170 return 0;

171 }

172

173 static inline int vc1_get_LUMSCALE(const VC1Context *v)

174 {

175 if (v->s.pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) {

176 if ((v->fcm == PROGRESSIVE && v->mv_mode == MV_PMODE_INTENSITY_COMP) ||

177 (v->fcm == ILACE_FRAME && v->intcomp))

178 return v->lumscale;

179 else if (v->fcm == ILACE_FIELD && v->mv_mode == MV_PMODE_INTENSITY_COMP)

180 switch (v->intcompfield) {

181 case 1: return v->lumscale;

182 case 2: return v->lumscale2;

183 case 3: return v->lumscale;

184 }

185 }

186 return 0;

187 }

188

189 static inline int vc1_get_LUMSHIFT(const VC1Context *v)

190 {

191 if (v->s.pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) {

192 if ((v->fcm == PROGRESSIVE && v->mv_mode == MV_PMODE_INTENSITY_COMP) ||

193 (v->fcm == ILACE_FRAME && v->intcomp))

194 return v->lumshift;

195 else if (v->fcm == ILACE_FIELD && v->mv_mode == MV_PMODE_INTENSITY_COMP)

196 switch (v->intcompfield) {

197 case 1: return v->lumshift;

198 case 2: return v->lumshift2;

199 case 3: return v->lumshift;

200 }

201 }

202 return 0;

203 }

204

205 av_unused static inline int vc1_get_LUMSCALE2(const VC1Context *v)

206 {

207 if ((v->s.pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) &&

208 v->fcm == ILACE_FIELD &&

209 v->mv_mode == MV_PMODE_INTENSITY_COMP &&

210 v->intcompfield == 3)

211 return v->lumscale2;

212 return 0;

213 }

214

215 av_unused static inline int vc1_get_LUMSHIFT2(const VC1Context *v)

216 {

217 if ((v->s.pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) &&

218 v->fcm == ILACE_FIELD &&

219 v->mv_mode == MV_PMODE_INTENSITY_COMP &&

220 v->intcompfield == 3)

221 return v->lumshift2;

222 return 0;

223 }

224

225 /** Reconstruct bitstream TTFRM (7.1.1.41, Table-53) */

226 static inline int vc1_get_TTFRM(const VC1Context *v)

227 {

228 switch (v->ttfrm) {

229 case TT_8X8: return 0;

230 case TT_8X4: return 1;

231 case TT_4X8: return 2;

232 case TT_4X4: return 3;

233 }

234 return 0;

235 }

236

237 /** Pack FFmpeg bitplanes into a VABitPlaneBuffer element */

238 static inline void vc1_pack_bitplanes(uint8_t *bitplane, int n, const uint8_t *ff_bp[3], int x, int y, int stride)

239 {

240 const int bitplane_index = n / 2;

241 const int ff_bp_index = y * stride + x;

242 uint8_t v = 0;

243 if (ff_bp[0])

244 v = ff_bp[0][ff_bp_index];

245 if (ff_bp[1])

246 v |= ff_bp[1][ff_bp_index] << 1;

247 if (ff_bp[2])

248 v |= ff_bp[2][ff_bp_index] << 2;

249 bitplane[bitplane_index] = (bitplane[bitplane_index] << 4) | v;

250 }

251

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

253 {

254 const VC1Context *v = avctx->priv_data;

255 const MpegEncContext *s = &v->s;

256 VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;

257 VAPictureParameterBufferVC1 pic_param;

258 int err;

259

260 pic->output_surface = ff_vaapi_get_surface_id(s->current_picture_ptr->f);

261

262 pic_param = (VAPictureParameterBufferVC1) {

263 .forward_reference_picture = VA_INVALID_ID,

264 .backward_reference_picture = VA_INVALID_ID,

265 .inloop_decoded_picture = VA_INVALID_ID,

266 .sequence_fields.bits = {

267 .pulldown = v->broadcast,

268 .interlace = v->interlace,

269 .tfcntrflag = v->tfcntrflag,

270 .finterpflag = v->finterpflag,

271 .psf = v->psf,

272 .multires = v->multires,

273 .overlap = v->overlap,

274 .syncmarker = v->resync_marker,

275 .rangered = v->rangered,

276 .max_b_frames = s->avctx->max_b_frames,

277 .profile = v->profile,

278 },

279 .coded_width = s->avctx->coded_width,

280 .coded_height = s->avctx->coded_height,

281 .entrypoint_fields.bits = {

282 .broken_link = v->broken_link,

283 .closed_entry = v->closed_entry,

284 .panscan_flag = v->panscanflag,

285 .loopfilter = s->loop_filter,

286 },

287 .conditional_overlap_flag = v->condover,

288 .fast_uvmc_flag = v->fastuvmc,

289 .range_mapping_fields.bits = {

290 .luma_flag = v->range_mapy_flag,

291 .luma = v->range_mapy,

292 .chroma_flag = v->range_mapuv_flag,

293 .chroma = v->range_mapuv,

294 },

295 .b_picture_fraction = v->bfraction_lut_index,

296 .cbp_table = (v->fcm == PROGRESSIVE ? v->cbptab : v->icbptab),

297 .mb_mode_table = v->mbmodetab,

298 .range_reduction_frame = v->rangeredfrm,

299 .rounding_control = v->rnd,

300 .post_processing = v->postproc,

301 .picture_resolution_index = v->respic,

302 .picture_fields.bits = {

303 .picture_type = (v->fcm == ILACE_FIELD ? vc1_get_FPTYPE(v) : vc1_get_PTYPE(v)),

304 .frame_coding_mode = v->fcm,

305 .top_field_first = v->tff,

306 .is_first_field = !v->second_field,

307 .intensity_compensation = v->intcomp,

308 },

309 .luma_scale = vc1_get_LUMSCALE(v),

310 .luma_shift = vc1_get_LUMSHIFT(v),

311 #if VA_CHECK_VERSION(1, 1, 0)

312 .luma_scale2 = vc1_get_LUMSCALE2(v),

313 .luma_shift2 = vc1_get_LUMSHIFT2(v),

314 .intensity_compensation_field = vc1_get_INTCOMPFIELD(v),

315 #endif

316 .raw_coding.flags = {

317 .mv_type_mb = v->mv_type_is_raw,

318 .direct_mb = v->dmb_is_raw,

319 .skip_mb = v->skip_is_raw,

320 .field_tx = v->fieldtx_is_raw,

321 .forward_mb = v->fmb_is_raw,

322 .ac_pred = v->acpred_is_raw,

323 .overflags = v->overflg_is_raw,

324 },

325 .bitplane_present.flags = {

326 .bp_mv_type_mb = vc1_has_MVTYPEMB_bitplane(v),

327 .bp_direct_mb = vc1_has_DIRECTMB_bitplane(v),

328 .bp_skip_mb = vc1_has_SKIPMB_bitplane(v),

329 .bp_field_tx = vc1_has_FIELDTX_bitplane(v),

330 .bp_forward_mb = vc1_has_FORWARDMB_bitplane(v),

331 .bp_ac_pred = vc1_has_ACPRED_bitplane(v),

332 .bp_overflags = vc1_has_OVERFLAGS_bitplane(v),

333 },

334 .reference_fields.bits = {

335 .reference_distance_flag = v->refdist_flag,

336 .reference_distance = v->refdist,

337 .num_reference_pictures = v->numref,

338 .reference_field_pic_indicator = v->reffield,

339 },

340 .mv_fields.bits = {

341 .mv_mode = vc1_get_MVMODE(v),

342 .mv_mode2 = vc1_get_MVMODE2(v),

343 .mv_table = (v->fcm == PROGRESSIVE ? s->mv_table_index : v->imvtab),

344 .two_mv_block_pattern_table = v->twomvbptab,

345 .four_mv_switch = v->fourmvswitch,

346 .four_mv_block_pattern_table = v->fourmvbptab,

347 .extended_mv_flag = v->extended_mv,

348 .extended_mv_range = v->mvrange,

349 .extended_dmv_flag = v->extended_dmv,

350 .extended_dmv_range = v->dmvrange,

351 },

352 .pic_quantizer_fields.bits = {

353 .dquant = v->dquant,

354 .quantizer = v->quantizer_mode,

355 .half_qp = v->halfpq,

356 .pic_quantizer_scale = v->pq,

357 .pic_quantizer_type = v->pquantizer,

358 .dq_frame = v->dquantfrm,

359 .dq_profile = v->dqprofile,

360 .dq_sb_edge = v->dqprofile == DQPROFILE_SINGLE_EDGE ? v->dqsbedge : 0,

361 .dq_db_edge = v->dqprofile == DQPROFILE_DOUBLE_EDGES ? v->dqsbedge : 0,

362 .dq_binary_level = v->dqbilevel,

363 .alt_pic_quantizer = v->altpq,

364 },

365 .transform_fields.bits = {

366 .variable_sized_transform_flag = v->vstransform,

367 .mb_level_transform_type_flag = v->ttmbf,

368 .frame_level_transform_type = vc1_get_TTFRM(v),

369 .transform_ac_codingset_idx1 = v->c_ac_table_index,

370 .transform_ac_codingset_idx2 = v->y_ac_table_index,

371 .intra_transform_dc_table = v->s.dc_table_index,

372 },

373 };

374

375 switch (s->pict_type) {

376 case AV_PICTURE_TYPE_B:

377 pic_param.backward_reference_picture = ff_vaapi_get_surface_id(s->next_picture.f);

378 // fall-through

379 case AV_PICTURE_TYPE_P:

380 pic_param.forward_reference_picture = ff_vaapi_get_surface_id(s->last_picture.f);

381 break;

382 }

383

384 err = ff_vaapi_decode_make_param_buffer(avctx, pic,

385 VAPictureParameterBufferType,

386 &pic_param, sizeof(pic_param));

387 if (err)

388 goto fail;

389

390 if (pic_param.bitplane_present.value & 0x7f) {

391 uint8_t *bitplane;

392 const uint8_t *ff_bp[3];

393 int x, y, n;

394 size_t size = (s->mb_width * s->mb_height + 1) / 2;

395

396 bitplane = av_mallocz(size);

397 if (!bitplane) {

398 err = AVERROR(ENOMEM);

399 goto fail;

400 }

401

402 switch (s->pict_type) {

403 case AV_PICTURE_TYPE_P:

404 ff_bp[0] = pic_param.bitplane_present.flags.bp_direct_mb ? v->direct_mb_plane : NULL;

405 ff_bp[1] = pic_param.bitplane_present.flags.bp_skip_mb ? s->mbskip_table : NULL;

406 ff_bp[2] = pic_param.bitplane_present.flags.bp_mv_type_mb ? v->mv_type_mb_plane : NULL;

407 break;

408 case AV_PICTURE_TYPE_B:

409 if (!v->bi_type) {

410 ff_bp[0] = pic_param.bitplane_present.flags.bp_direct_mb ? v->direct_mb_plane : NULL;

411 ff_bp[1] = pic_param.bitplane_present.flags.bp_skip_mb ? s->mbskip_table : NULL;

412 ff_bp[2] = pic_param.bitplane_present.flags.bp_forward_mb ? v->forward_mb_plane : NULL;

413 break;

414 }

415 /* fall-through (BI-type) */

416 case AV_PICTURE_TYPE_I:

417 ff_bp[0] = pic_param.bitplane_present.flags.bp_field_tx ? v->fieldtx_plane : NULL;

418 ff_bp[1] = pic_param.bitplane_present.flags.bp_ac_pred ? v->acpred_plane : NULL;

419 ff_bp[2] = pic_param.bitplane_present.flags.bp_overflags ? v->over_flags_plane : NULL;

420 break;

421 default:

422 ff_bp[0] = NULL;

423 ff_bp[1] = NULL;

424 ff_bp[2] = NULL;

425 break;

426 }

427

428 n = 0;

429 for (y = 0; y < s->mb_height; y++)

430 for (x = 0; x < s->mb_width; x++, n++)

431 vc1_pack_bitplanes(bitplane, n, ff_bp, x, y, s->mb_stride);

432 if (n & 1) /* move last nibble to the high order */

433 bitplane[n/2] <<= 4;

434

435 err = ff_vaapi_decode_make_param_buffer(avctx, pic,

436 VABitPlaneBufferType,

437 bitplane, size);

438 av_free(bitplane);

439 if (err)

440 goto fail;

441 }

442 return 0;

443

444 fail:

445 ff_vaapi_decode_cancel(avctx, pic);

446 return err;

447 }

448

449 static int vaapi_vc1_end_frame(AVCodecContext *avctx)

450 {

451 VC1Context *v = avctx->priv_data;

452 MpegEncContext *s = &v->s;

453 VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;

454 int ret;

455

456 ret = ff_vaapi_decode_issue(avctx, pic);

457 if (ret < 0)

458 goto fail;

459

460 fail:

461 return ret;

462 }

463

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

465 {

466 const VC1Context *v = avctx->priv_data;

467 const MpegEncContext *s = &v->s;

468 VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;

469 VASliceParameterBufferVC1 slice_param;

470 int mb_height;

471 int err;

472

473 /* Current bit buffer is beyond any marker for VC-1, so skip it */

474 if (avctx->codec_id == AV_CODEC_ID_VC1 && IS_MARKER(AV_RB32(buffer))) {

475 buffer += 4;

476 size -= 4;

477 }

478

479 if (v->fcm == ILACE_FIELD)

480 mb_height = avctx->coded_height + 31 >> 5;

481 else

482 mb_height = avctx->coded_height + 15 >> 4;

483

484 slice_param = (VASliceParameterBufferVC1) {

485 .slice_data_size = size,

486 .slice_data_offset = 0,

487 .slice_data_flag = VA_SLICE_DATA_FLAG_ALL,

488 .macroblock_offset = get_bits_count(&s->gb),

489 .slice_vertical_position = s->mb_y % mb_height,

490 };

491

492 err = ff_vaapi_decode_make_slice_buffer(avctx, pic,

493 &slice_param, sizeof(slice_param),

494 buffer, size);

495 if (err < 0) {

496 ff_vaapi_decode_cancel(avctx, pic);

497 return err;

498 }

499

500 return 0;

501 }

502

503 #if CONFIG_WMV3_VAAPI_HWACCEL

504 const AVHWAccel ff_wmv3_vaapi_hwaccel = {

505 .name = "wmv3_vaapi",

506 .type = AVMEDIA_TYPE_VIDEO,

507 .id = AV_CODEC_ID_WMV3,

508 .pix_fmt = AV_PIX_FMT_VAAPI,

509 .start_frame = &vaapi_vc1_start_frame,

510 .end_frame = &vaapi_vc1_end_frame,

511 .decode_slice = &vaapi_vc1_decode_slice,

512 .frame_priv_data_size = sizeof(VAAPIDecodePicture),

513 .init = &ff_vaapi_decode_init,

514 .uninit = &ff_vaapi_decode_uninit,

515 .frame_params = &ff_vaapi_common_frame_params,

516 .priv_data_size = sizeof(VAAPIDecodeContext),

517 .caps_internal = HWACCEL_CAP_ASYNC_SAFE,

518 };

519 #endif

520

521 const AVHWAccel ff_vc1_vaapi_hwaccel = {

522 .name = "vc1_vaapi",

523 .type = AVMEDIA_TYPE_VIDEO,

524 .id = AV_CODEC_ID_VC1,

525 .pix_fmt = AV_PIX_FMT_VAAPI,

526 .start_frame = &vaapi_vc1_start_frame,

527 .end_frame = &vaapi_vc1_end_frame,

528 .decode_slice = &vaapi_vc1_decode_slice,

529 .frame_priv_data_size = sizeof(VAAPIDecodePicture),

530 .init = &ff_vaapi_decode_init,

531 .uninit = &ff_vaapi_decode_uninit,

532 .frame_params = &ff_vaapi_common_frame_params,

533 .priv_data_size = sizeof(VAAPIDecodeContext),

534 .caps_internal = HWACCEL_CAP_ASYNC_SAFE,

535 };

hwconfig.h

VC1Context::lumscale2

uint8_t lumscale2

for interlaced field P picture

Definition: vc1.h:335

VC1Context::mbmodetab

int mbmodetab

Definition: vc1.h:367

VC1Context

The VC1 Context.

Definition: vc1.h:173

AVERROR

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 all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

PROGRESSIVE

@ PROGRESSIVE

in the bitstream is reported as 00b

Definition: vc1.h:149

ff_vaapi_get_surface_id

static VASurfaceID ff_vaapi_get_surface_id(AVFrame *pic)

Definition: vaapi_decode.h:30

VC1Context::condover

uint8_t condover

Definition: vc1.h:324

DQPROFILE_DOUBLE_EDGES

@ DQPROFILE_DOUBLE_EDGES

Definition: vc1.h:49

VC1Context::intcomp

int intcomp

Definition: vc1.h:334

VC1Context::overlap

int overlap

overlapped transforms in use

Definition: vc1.h:224

VC1Context::dqprofile

uint8_t dqprofile

Definition: vc1.h:244

VC1Context::interlace

int interlace

Progressive/interlaced (RPTFTM syntax element)

Definition: vc1.h:199

VAAPIDecodeContext

Definition: vaapi_decode.h:50

VC1Context::altpq

uint8_t altpq

Current/alternate frame quantizer scale.

Definition: vc1.h:236

vc1.h

ILACE_FRAME

@ ILACE_FRAME

in the bitstream is reported as 10b

Definition: vc1.h:150

vaapi_decode.h

vc1_has_MVTYPEMB_bitplane

static int vc1_has_MVTYPEMB_bitplane(const VC1Context *v)

Check whether the MVTYPEMB bitplane is present.

Definition: vaapi_vc1.c:45

get_bits_count

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:256

av_unused

#define av_unused

Definition: attributes.h:131

VAAPIDecodePicture

Definition: vaapi_decode.h:39

MV_PMODE_1MV_HPEL_BILIN

@ MV_PMODE_1MV_HPEL_BILIN

Definition: vc1.h:79

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

VC1Context::reffield

int reffield

if numref = 0 (1 reference) then reffield decides which

Definition: vc1.h:355

VC1Context::fastuvmc

int fastuvmc

Rounding of qpel vector to hpel ? (not in Simple)

Definition: vc1.h:220

MV_PMODE_INTENSITY_COMP

@ MV_PMODE_INTENSITY_COMP

Definition: vc1.h:83

VC1Context::imvtab

int imvtab

Definition: vc1.h:369

VC1Context::dmvrange

uint8_t dmvrange

Frame decoding info for interlaced picture.

Definition: vc1.h:332

VC1Context::closed_entry

uint8_t closed_entry

Closed entry point flag (CLOSED_ENTRY syntax element)

Definition: vc1.h:393

VC1Context::twomvbptab

int twomvbptab

Definition: vc1.h:370

VC1Context::fieldtx_is_raw

int fieldtx_is_raw

Definition: vc1.h:344

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

MpegEncContext::pict_type

int pict_type

AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...

Definition: mpegvideo.h:202

ILACE_FIELD

@ ILACE_FIELD

in the bitstream is reported as 11b

Definition: vc1.h:151

VC1Context::multires

int multires

frame-level RESPIC syntax element present

Definition: vc1.h:184

fail

#define fail()

Definition: checkasm.h:134

vaapi_vc1_start_frame

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

Definition: vaapi_vc1.c:252

vc1_get_PTYPE

static int vc1_get_PTYPE(const VC1Context *v)

Reconstruct bitstream PTYPE (7.1.1.4, index into Table-35)

Definition: vaapi_vc1.c:117

vc1_get_MVMODE

static VAMvModeVC1 vc1_get_MVMODE(const VC1Context *v)

Reconstruct bitstream MVMODE (7.1.1.32)

Definition: vaapi_vc1.c:141

VC1Context::numref

int numref

number of past field pictures used as reference

Definition: vc1.h:353

ff_vc1_vaapi_hwaccel

const AVHWAccel ff_vc1_vaapi_hwaccel

Definition: vaapi_vc1.c:521

AVCodecContext::coded_height

int coded_height

Definition: avcodec.h:613

vc1_has_FIELDTX_bitplane

static int vc1_has_FIELDTX_bitplane(const VC1Context *v)

Check whether the FIELDTX bitplane is present.

Definition: vaapi_vc1.c:98

VC1Context::c_ac_table_index

int c_ac_table_index

AC coding set indexes.

Definition: vc1.h:252

VC1Context::dquant

int dquant

How qscale varies with MBs, 2 bits (not in Simple)

Definition: vc1.h:222

VAAPIDecodePicture::output_surface

VASurfaceID output_surface

Definition: vaapi_decode.h:40

VC1Context::refdist

int refdist

distance of the current picture from reference

Definition: vc1.h:352

mpegvideodec.h

#define s(width, name)

Definition: cbs_vp9.c:256

ff_vaapi_decode_init

int ff_vaapi_decode_init(AVCodecContext *avctx)

Definition: vaapi_decode.c:655

VC1Context::range_mapuv_flag

uint8_t range_mapuv_flag

Definition: vc1.h:326

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

DQPROFILE_SINGLE_EDGE

@ DQPROFILE_SINGLE_EDGE

Definition: vc1.h:50

TT_8X4

@ TT_8X4

Definition: vc1.h:115

vc1_has_SKIPMB_bitplane

static int vc1_has_SKIPMB_bitplane(const VC1Context *v)

Check whether the SKIPMB bitplane is present.

Definition: vaapi_vc1.c:57

PROFILE_ADVANCED

@ PROFILE_ADVANCED

Definition: vc1_common.h:52

VC1Context::rangered

int rangered

RANGEREDFRM (range reduction) syntax element present at frame level.

Definition: vc1.h:187

ff_vaapi_decode_uninit

int ff_vaapi_decode_uninit(AVCodecContext *avctx)

Definition: vaapi_decode.c:701

VC1Context::rnd

int rnd

rounding control

Definition: vc1.h:296

MVModes

MV modes for P-frames.

Definition: vc1.h:78

AVCodecContext::codec_id

enum AVCodecID codec_id

Definition: avcodec.h:436

vaapi_vc1_end_frame

static int vaapi_vc1_end_frame(AVCodecContext *avctx)

Definition: vaapi_vc1.c:449

ff_vaapi_decode_issue

int ff_vaapi_decode_issue(AVCodecContext *avctx, VAAPIDecodePicture *pic)

Definition: vaapi_decode.c:153

VC1Context::mv_mode

uint8_t mv_mode

Frame decoding info for all profiles.

Definition: vc1.h:231

VC1Context::dqsbedge

uint8_t dqsbedge

Definition: vc1.h:245

VC1Context::pq

uint8_t pq

Definition: vc1.h:236

AV_CODEC_ID_WMV3

@ AV_CODEC_ID_WMV3

Definition: codec_id.h:123

VC1Context::skip_is_raw

int skip_is_raw

skip mb plane is not coded

Definition: vc1.h:290

NULL

#define NULL

Definition: coverity.c:32

VC1Context::range_mapy_flag

uint8_t range_mapy_flag

Definition: vc1.h:325

VC1Context::lumscale

uint8_t lumscale

Luma compensation parameters.

Definition: vc1.h:267

VC1Context::panscanflag

int panscanflag

NUMPANSCANWIN, TOPLEFT{X,Y}, BOTRIGHT{X,Y} present.

Definition: vc1.h:201

VC1Context::mvrange

uint8_t mvrange

Ranges:

Definition: vc1.h:280

VC1Context::range_mapuv

uint8_t range_mapuv

Definition: vc1.h:328

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:274

VC1Context::fmb_is_raw

int fmb_is_raw

forward mb plane is raw

Definition: vc1.h:289

IS_MARKER

#define IS_MARKER(state)

Definition: dca_parser.c:51

vc1_pack_bitplanes

static void vc1_pack_bitplanes(uint8_t *bitplane, int n, const uint8_t *ff_bp[3], int x, int y, int stride)

Pack FFmpeg bitplanes into a VABitPlaneBuffer element.

Definition: vaapi_vc1.c:238

VC1Context::resync_marker

int resync_marker

could this stream contain resync markers

Definition: vc1.h:398

get_VAMvModeVC1

static int get_VAMvModeVC1(enum MVModes mv_mode)

Translate FFmpeg MV modes to VA API.

Definition: vaapi_vc1.c:32

VC1Context::cbptab

int cbptab

Definition: vc1.h:297

VC1Context::halfpq

uint8_t halfpq

Uniform quant over image and qp+.5.

Definition: vc1.h:271

VC1Context::ttmbf

uint8_t ttmbf

Transform type flag.

Definition: vc1.h:256

VC1Context::refdist_flag

int refdist_flag

REFDIST syntax element present in II, IP, PI or PP field picture headers.

Definition: vc1.h:202

ff_wmv3_vaapi_hwaccel

const AVHWAccel ff_wmv3_vaapi_hwaccel

vc1_has_DIRECTMB_bitplane

static int vc1_has_DIRECTMB_bitplane(const VC1Context *v)

Check whether the DIRECTMB bitplane is present.

Definition: vaapi_vc1.c:67

VC1Context::intcompfield

int intcompfield

which of the two fields to be intensity compensated

Definition: vc1.h:357

VC1Context::mv_mode2

uint8_t mv_mode2

Secondary MV coding mode (B-frames)

Definition: vc1.h:232

VC1Context::ttfrm

int ttfrm

Transform type info present at frame level.

Definition: vc1.h:255

MV_PMODE_MIXED_MV

@ MV_PMODE_MIXED_MV

Definition: vc1.h:82

size

int size

Definition: twinvq_data.h:10344

vc1_get_LUMSHIFT2

static av_unused int vc1_get_LUMSHIFT2(const VC1Context *v)

Definition: vaapi_vc1.c:215

AV_RB32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32

Definition: bytestream.h:96

vc1_get_INTCOMPFIELD

static av_unused int vc1_get_INTCOMPFIELD(const VC1Context *v)

Definition: vaapi_vc1.c:160

VC1Context::fourmvswitch

int fourmvswitch

Definition: vc1.h:333

VC1Context::rangeredfrm

uint8_t rangeredfrm

Frame decoding info for S/M profiles only.

Definition: vc1.h:301

ff_vaapi_decode_cancel

int ff_vaapi_decode_cancel(AVCodecContext *avctx, VAAPIDecodePicture *pic)

Definition: vaapi_decode.c:227

VC1Context::respic

uint8_t respic

Frame-level flag for resized images.

Definition: vc1.h:272

MV_PMODE_1MV_HPEL

@ MV_PMODE_1MV_HPEL

Definition: vc1.h:81

vc1_get_FPTYPE

static int vc1_get_FPTYPE(const VC1Context *v)

Reconstruct bitstream FPTYPE (9.1.1.42, index into Table-105)

Definition: vaapi_vc1.c:129

vc1data.h

VC1Context::broken_link

uint8_t broken_link

Broken link flag (BROKEN_LINK syntax element)

Definition: vc1.h:392

VC1Context::tfcntrflag

int tfcntrflag

TFCNTR present.

Definition: vc1.h:200

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

vc1_get_TTFRM

static int vc1_get_TTFRM(const VC1Context *v)

Reconstruct bitstream TTFRM (7.1.1.41, Table-53)

Definition: vaapi_vc1.c:226

vc1_get_LUMSCALE2

static av_unused int vc1_get_LUMSCALE2(const VC1Context *v)

Definition: vaapi_vc1.c:205

VC1Context::s

MpegEncContext s

Definition: vc1.h:174

HWACCEL_CAP_ASYNC_SAFE

#define HWACCEL_CAP_ASYNC_SAFE

Definition: hwconfig.h:26

VC1Context::extended_mv

int extended_mv

Ext MV in P/B (not in Simple)

Definition: vc1.h:221

vc1_get_LUMSCALE

static int vc1_get_LUMSCALE(const VC1Context *v)

Definition: vaapi_vc1.c:173

av_mallocz

void * av_mallocz(size_t size)

Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...

Definition: mem.c:254

MpegEncContext::dc_table_index

int dc_table_index

Definition: mpegvideo.h:413

AV_CODEC_ID_VC1

@ AV_CODEC_ID_VC1

Definition: codec_id.h:122

stride

#define stride

Definition: h264pred_template.c:537

VC1Context::second_field

int second_field

Definition: vc1.h:351

ret

Definition: filter_design.txt:187

VC1Context::y_ac_table_index

int y_ac_table_index

Luma index from AC2FRM element.

Definition: vc1.h:253

VC1Context::overflg_is_raw

int overflg_is_raw

Definition: vc1.h:323

VC1Context::pquantizer

uint8_t pquantizer

Uniform (over sequence) quantizer in use.

Definition: vc1.h:281

AVCodecContext

main external API structure.

Definition: avcodec.h:426

VC1Context::p_frame_skipped

int p_frame_skipped

Definition: vc1.h:382

VC1Context::bfraction_lut_index

uint8_t bfraction_lut_index

Index for BFRACTION value (see Table 40, reproduced into ff_vc1_bfraction_lut[])

Definition: vc1.h:391

vc1_has_ACPRED_bitplane

static int vc1_has_ACPRED_bitplane(const VC1Context *v)

Check whether the ACPRED bitplane is present.

Definition: vaapi_vc1.c:76

AV_PICTURE_TYPE_B

@ AV_PICTURE_TYPE_B

Bi-dir predicted.

Definition: avutil.h:276

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

VC1Context::tff

uint8_t tff

Definition: vc1.h:310

vc1_get_LUMSHIFT

static int vc1_get_LUMSHIFT(const VC1Context *v)

Definition: vaapi_vc1.c:189

VC1Context::fourmvbptab

int fourmvbptab

Definition: vc1.h:371

VC1Context::profile

int profile