FFmpeg: libavfilter/vaapi_vpp.c Source File

FFmpeg

[フレーム]

libavfilter

vaapi_vpp.c

Go to the documentation of this file.

1 /*

2 * This file is part of FFmpeg.

3 *

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

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

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

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

8 *

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

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

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

12 * Lesser General Public License for more details.

13 *

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

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

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

17 */

19 #include <string.h>

21 #include "libavutil/avassert.h"

22 #include "libavutil/mem.h"

23 #include "libavutil/pixdesc.h"

25 #include "filters.h"

26 #include "formats.h"

27 #include "vaapi_vpp.h"

29 int ff_vaapi_vpp_query_formats(const AVFilterContext *avctx,

30 AVFilterFormatsConfig **cfg_in,

31 AVFilterFormatsConfig **cfg_out)

32 {

33 static const enum AVPixelFormat pix_fmts[] = {

34 AV_PIX_FMT_VAAPI, AV_PIX_FMT_NONE,

35 };

36 int err;

38 err = ff_set_common_formats_from_list2(avctx, cfg_in, cfg_out, pix_fmts);

39 if (err < 0)

40 return err;

42 return 0;

43 }

45 void ff_vaapi_vpp_pipeline_uninit(AVFilterContext *avctx)

46 {

47 VAAPIVPPContext *ctx = avctx->priv;

48 int i;

49 for (i = 0; i < ctx->nb_filter_buffers; i++) {

50 if (ctx->filter_buffers[i] != VA_INVALID_ID) {

51 vaDestroyBuffer(ctx->hwctx->display, ctx->filter_buffers[i]);

52 ctx->filter_buffers[i] = VA_INVALID_ID;

53 }

54 }

55 ctx->nb_filter_buffers = 0;

57 if (ctx->va_context != VA_INVALID_ID) {

58 vaDestroyContext(ctx->hwctx->display, ctx->va_context);

59 ctx->va_context = VA_INVALID_ID;

60 }

62 if (ctx->va_config != VA_INVALID_ID) {

63 vaDestroyConfig(ctx->hwctx->display, ctx->va_config);

64 ctx->va_config = VA_INVALID_ID;

65 }

67 av_buffer_unref(&ctx->device_ref);

68 ctx->hwctx = NULL;

69 }

71 int ff_vaapi_vpp_config_input(AVFilterLink *inlink)

72 {

73 FilterLink *l = ff_filter_link(inlink);

74 AVFilterContext *avctx = inlink->dst;

75 VAAPIVPPContext *ctx = avctx->priv;

77 if (ctx->pipeline_uninit)

78 ctx->pipeline_uninit(avctx);

80 if (!l->hw_frames_ctx) {

81 av_log(avctx, AV_LOG_ERROR, "A hardware frames reference is "

82 "required to associate the processing device.\n");

83 return AVERROR(EINVAL);

84 }

86 ctx->input_frames_ref = av_buffer_ref(l->hw_frames_ctx);

87 if (!ctx->input_frames_ref) {

88 av_log(avctx, AV_LOG_ERROR, "A input frames reference create "

89 "failed.\n");

90 return AVERROR(ENOMEM);

91 }

92 ctx->input_frames = (AVHWFramesContext*)ctx->input_frames_ref->data;

94 return 0;

95 }

97 int ff_vaapi_vpp_config_output(AVFilterLink *outlink)

98 {

99 FilterLink *outl = ff_filter_link(outlink);

100 AVFilterContext *avctx = outlink->src;

101 AVFilterLink *inlink = avctx->inputs[0];

102 FilterLink *inl = ff_filter_link(inlink);

103 VAAPIVPPContext *ctx = avctx->priv;

104 AVVAAPIHWConfig *hwconfig = NULL;

105 AVHWFramesConstraints *constraints = NULL;

106 AVHWFramesContext *output_frames;

107 AVVAAPIFramesContext *va_frames;

108 VAStatus vas;

109 int err, i;

110

111 if (ctx->pipeline_uninit)

112 ctx->pipeline_uninit(avctx);

113

114 if (!ctx->output_width)

115 ctx->output_width = avctx->inputs[0]->w;

116 if (!ctx->output_height)

117 ctx->output_height = avctx->inputs[0]->h;

118

119 outlink->w = ctx->output_width;

120 outlink->h = ctx->output_height;

121

122 if (ctx->passthrough) {

123 if (inl->hw_frames_ctx)

124 outl->hw_frames_ctx = av_buffer_ref(inl->hw_frames_ctx);

125 av_log(ctx, AV_LOG_VERBOSE, "Using VAAPI filter passthrough mode.\n");

126

127 return 0;

128 }

129

130 av_assert0(ctx->input_frames);

131 ctx->device_ref = av_buffer_ref(ctx->input_frames->device_ref);

132 if (!ctx->device_ref) {

133 av_log(avctx, AV_LOG_ERROR, "A device reference create "

134 "failed.\n");

135 return AVERROR(ENOMEM);

136 }

137 ctx->hwctx = ((AVHWDeviceContext*)ctx->device_ref->data)->hwctx;

138

139 av_assert0(ctx->va_config == VA_INVALID_ID);

140 vas = vaCreateConfig(ctx->hwctx->display, VAProfileNone,

141 VAEntrypointVideoProc, NULL, 0, &ctx->va_config);

142 if (vas != VA_STATUS_SUCCESS) {

143 av_log(avctx, AV_LOG_ERROR, "Failed to create processing pipeline "

144 "config: %d (%s).\n", vas, vaErrorStr(vas));

145 err = AVERROR(EIO);

146 goto fail;

147 }

148

149 hwconfig = av_hwdevice_hwconfig_alloc(ctx->device_ref);

150 if (!hwconfig) {

151 err = AVERROR(ENOMEM);

152 goto fail;

153 }

154 hwconfig->config_id = ctx->va_config;

155

156 constraints = av_hwdevice_get_hwframe_constraints(ctx->device_ref,

157 hwconfig);

158 if (!constraints) {

159 err = AVERROR(ENOMEM);

160 goto fail;

161 }

162

163 if (ctx->output_format == AV_PIX_FMT_NONE)

164 ctx->output_format = ctx->input_frames->sw_format;

165 if (constraints->valid_sw_formats) {

166 for (i = 0; constraints->valid_sw_formats[i] != AV_PIX_FMT_NONE; i++) {

167 if (ctx->output_format == constraints->valid_sw_formats[i])

168 break;

169 }

170 if (constraints->valid_sw_formats[i] == AV_PIX_FMT_NONE) {

171 av_log(avctx, AV_LOG_ERROR, "Hardware does not support output "

172 "format %s.\n", av_get_pix_fmt_name(ctx->output_format));

173 err = AVERROR(EINVAL);

174 goto fail;

175 }

176 }

177

178 if (ctx->output_width < constraints->min_width ||

179 ctx->output_height < constraints->min_height ||

180 ctx->output_width > constraints->max_width ||

181 ctx->output_height > constraints->max_height) {

182 av_log(avctx, AV_LOG_ERROR, "Hardware does not support scaling to "

183 "size %dx%d (constraints: width %d-%d height %d-%d).\n",

184 ctx->output_width, ctx->output_height,

185 constraints->min_width, constraints->max_width,

186 constraints->min_height, constraints->max_height);

187 err = AVERROR(EINVAL);

188 goto fail;

189 }

190

191 outl->hw_frames_ctx = av_hwframe_ctx_alloc(ctx->device_ref);

192 if (!outl->hw_frames_ctx) {

193 av_log(avctx, AV_LOG_ERROR, "Failed to create HW frame context "

194 "for output.\n");

195 err = AVERROR(ENOMEM);

196 goto fail;

197 }

198

199 output_frames = (AVHWFramesContext*)outl->hw_frames_ctx->data;

200

201 output_frames->format = AV_PIX_FMT_VAAPI;

202 output_frames->sw_format = ctx->output_format;

203 output_frames->width = ctx->output_width;

204 output_frames->height = ctx->output_height;

205

206 if (CONFIG_VAAPI_1)

207 output_frames->initial_pool_size = 0;

208 else

209 output_frames->initial_pool_size = 4;

210

211 err = ff_filter_init_hw_frames(avctx, outlink, 10);

212 if (err < 0)

213 goto fail;

214

215 err = av_hwframe_ctx_init(outl->hw_frames_ctx);

216 if (err < 0) {

217 av_log(avctx, AV_LOG_ERROR, "Failed to initialise VAAPI frame "

218 "context for output: %d\n", err);

219 goto fail;

220 }

221

222 va_frames = output_frames->hwctx;

223

224 av_assert0(ctx->va_context == VA_INVALID_ID);

225 av_assert0(output_frames->initial_pool_size ||

226 (va_frames->surface_ids == NULL && va_frames->nb_surfaces == 0));

227 vas = vaCreateContext(ctx->hwctx->display, ctx->va_config,

228 ctx->output_width, ctx->output_height,

229 VA_PROGRESSIVE,

230 va_frames->surface_ids, va_frames->nb_surfaces,

231 &ctx->va_context);

232 if (vas != VA_STATUS_SUCCESS) {

233 av_log(avctx, AV_LOG_ERROR, "Failed to create processing pipeline "

234 "context: %d (%s).\n", vas, vaErrorStr(vas));

235 return AVERROR(EIO);

236 }

237

238 if (ctx->build_filter_params) {

239 err = ctx->build_filter_params(avctx);

240 if (err < 0)

241 goto fail;

242 }

243

244 av_freep(&hwconfig);

245 av_hwframe_constraints_free(&constraints);

246 return 0;

247

248 fail:

249 av_buffer_unref(&outl->hw_frames_ctx);

250 av_freep(&hwconfig);

251 av_hwframe_constraints_free(&constraints);

252 return err;

253 }

254

255 typedef struct VAAPIColourProperties {

256 VAProcColorStandardType va_color_standard;

257

258 enum AVColorPrimaries color_primaries;

259 enum AVColorTransferCharacteristic color_trc;

260 enum AVColorSpace colorspace;

261

262 uint8_t va_chroma_sample_location;

263 uint8_t va_color_range;

264

265 enum AVColorRange color_range;

266 enum AVChromaLocation chroma_sample_location;

267 } VAAPIColourProperties;

268

269 static const VAAPIColourProperties vaapi_colour_standard_map[] = {

270 { VAProcColorStandardBT601, 5, 6, 5 },

271 { VAProcColorStandardBT601, 6, 6, 6 },

272 { VAProcColorStandardBT709, 1, 1, 1 },

273 { VAProcColorStandardBT470M, 4, 4, 4 },

274 { VAProcColorStandardBT470BG, 5, 5, 5 },

275 { VAProcColorStandardSMPTE170M, 6, 6, 6 },

276 { VAProcColorStandardSMPTE240M, 7, 7, 7 },

277 { VAProcColorStandardGenericFilm, 8, 1, 1 },

278 #if VA_CHECK_VERSION(1, 1, 0)

279 { VAProcColorStandardSRGB, 1, 13, 0 },

280 { VAProcColorStandardXVYCC601, 1, 11, 5 },

281 { VAProcColorStandardXVYCC709, 1, 11, 1 },

282 { VAProcColorStandardBT2020, 9, 14, 9 },

283 #endif

284 };

285

286 static void vaapi_vpp_fill_colour_standard(VAAPIColourProperties *props,

287 VAProcColorStandardType *vacs,

288 int nb_vacs)

289 {

290 const VAAPIColourProperties *t;

291 int i, j, score, best_score, worst_score;

292 VAProcColorStandardType best_standard;

293

294 #if VA_CHECK_VERSION(1, 3, 0)

295 // If the driver supports explicit use of the standard values then just

296 // use them and avoid doing any mapping. (The driver may not support

297 // some particular code point, but it still has enough information to

298 // make a better fallback choice than we do in that case.)

299 for (i = 0; i < nb_vacs; i++) {

300 if (vacs[i] == VAProcColorStandardExplicit) {

301 props->va_color_standard = VAProcColorStandardExplicit;

302 return;

303 }

304 }

305 #endif

306

307 // Give scores to the possible options and choose the lowest one.

308 // An exact match will score zero and therefore always be chosen, as

309 // will a partial match where all unmatched elements are explicitly

310 // unspecified. If no options match at all then just pass "none" to

311 // the driver and let it make its own choice.

312 best_standard = VAProcColorStandardNone;

313 best_score = -1;

314 worst_score = 4 * (props->colorspace != AVCOL_SPC_UNSPECIFIED &&

315 props->colorspace != AVCOL_SPC_RGB) +

316 2 * (props->color_trc != AVCOL_TRC_UNSPECIFIED) +

317 (props->color_primaries != AVCOL_PRI_UNSPECIFIED);

318

319 if (worst_score == 0) {

320 // No properties are specified, so we aren't going to be able to

321 // make a useful choice.

322 props->va_color_standard = VAProcColorStandardNone;

323 return;

324 }

325

326 for (i = 0; i < nb_vacs; i++) {

327 for (j = 0; j < FF_ARRAY_ELEMS(vaapi_colour_standard_map); j++) {

328 t = &vaapi_colour_standard_map[j];

329 if (t->va_color_standard != vacs[i])

330 continue;

331

332 score = 0;

333 if (props->colorspace != AVCOL_SPC_UNSPECIFIED &&

334 props->colorspace != AVCOL_SPC_RGB)

335 score += 4 * (props->colorspace != t->colorspace);

336 if (props->color_trc != AVCOL_TRC_UNSPECIFIED)

337 score += 2 * (props->color_trc != t->color_trc);

338 if (props->color_primaries != AVCOL_PRI_UNSPECIFIED)

339 score += (props->color_primaries != t->color_primaries);

340

341 // Only include choices which matched something.

342 if (score < worst_score &&

343 (best_score == -1 || score < best_score)) {

344 best_score = score;

345 best_standard = t->va_color_standard;

346 }

347 }

348 }

349 props->va_color_standard = best_standard;

350 }

351

352 static void vaapi_vpp_fill_chroma_sample_location(VAAPIColourProperties *props)

353 {

354 #if VA_CHECK_VERSION(1, 1, 0)

355 static const struct {

356 enum AVChromaLocation av;

357 uint8_t va;

358 } csl_map[] = {

359 { AVCHROMA_LOC_UNSPECIFIED, VA_CHROMA_SITING_UNKNOWN },

360 { AVCHROMA_LOC_LEFT, VA_CHROMA_SITING_VERTICAL_CENTER |

361 VA_CHROMA_SITING_HORIZONTAL_LEFT },

362 { AVCHROMA_LOC_CENTER, VA_CHROMA_SITING_VERTICAL_CENTER |

363 VA_CHROMA_SITING_HORIZONTAL_CENTER },

364 { AVCHROMA_LOC_TOPLEFT, VA_CHROMA_SITING_VERTICAL_TOP |

365 VA_CHROMA_SITING_HORIZONTAL_LEFT },

366 { AVCHROMA_LOC_TOP, VA_CHROMA_SITING_VERTICAL_TOP |

367 VA_CHROMA_SITING_HORIZONTAL_CENTER },

368 { AVCHROMA_LOC_BOTTOMLEFT, VA_CHROMA_SITING_VERTICAL_BOTTOM |

369 VA_CHROMA_SITING_HORIZONTAL_LEFT },

370 { AVCHROMA_LOC_BOTTOM, VA_CHROMA_SITING_VERTICAL_BOTTOM |

371 VA_CHROMA_SITING_HORIZONTAL_CENTER },

372 };

373 int i;

374

375 for (i = 0; i < FF_ARRAY_ELEMS(csl_map); i++) {

376 if (props->chroma_sample_location == csl_map[i].av) {

377 props->va_chroma_sample_location = csl_map[i].va;

378 return;

379 }

380 }

381 props->va_chroma_sample_location = VA_CHROMA_SITING_UNKNOWN;

382 #else

383 props->va_chroma_sample_location = 0;

384 #endif

385 }

386

387 static void vaapi_vpp_fill_colour_range(VAAPIColourProperties *props)

388 {

389 #if VA_CHECK_VERSION(1, 1, 0)

390 switch (props->color_range) {

391 case AVCOL_RANGE_MPEG:

392 props->va_color_range = VA_SOURCE_RANGE_REDUCED;

393 break;

394 case AVCOL_RANGE_JPEG:

395 props->va_color_range = VA_SOURCE_RANGE_FULL;

396 break;

397 case AVCOL_RANGE_UNSPECIFIED:

398 default:

399 props->va_color_range = VA_SOURCE_RANGE_UNKNOWN;

400 }

401 #else

402 props->va_color_range = 0;

403 #endif

404 }

405

406 static void vaapi_vpp_fill_colour_properties(AVFilterContext *avctx,

407 VAAPIColourProperties *props,

408 VAProcColorStandardType *vacs,

409 int nb_vacs)

410 {

411 vaapi_vpp_fill_colour_standard(props, vacs, nb_vacs);

412 vaapi_vpp_fill_chroma_sample_location(props);

413 vaapi_vpp_fill_colour_range(props);

414

415 av_log(avctx, AV_LOG_DEBUG, "Mapped colour properties %s %s/%s/%s %s "

416 "to VA standard %d chroma siting %#x range %#x.\n",

417 av_color_range_name(props->color_range),

418 av_color_space_name(props->colorspace),

419 av_color_primaries_name(props->color_primaries),

420 av_color_transfer_name(props->color_trc),

421 av_chroma_location_name(props->chroma_sample_location),

422 props->va_color_standard,

423 props->va_chroma_sample_location, props->va_color_range);

424 }

425

426 static int vaapi_vpp_frame_is_rgb(const AVFrame *frame)

427 {

428 const AVHWFramesContext *hwfc;

429 const AVPixFmtDescriptor *desc;

430 av_assert0(frame->format == AV_PIX_FMT_VAAPI &&

431 frame->hw_frames_ctx);

432 hwfc = (const AVHWFramesContext*)frame->hw_frames_ctx->data;

433 desc = av_pix_fmt_desc_get(hwfc->sw_format);

434 av_assert0(desc);

435 return !!(desc->flags & AV_PIX_FMT_FLAG_RGB);

436 }

437

438 static int vaapi_vpp_colour_properties(AVFilterContext *avctx,

439 VAProcPipelineParameterBuffer *params,

440 const AVFrame *input_frame,

441 AVFrame *output_frame)

442 {

443 VAAPIVPPContext *ctx = avctx->priv;

444 VAAPIColourProperties input_props, output_props;

445 VAProcPipelineCaps caps;

446 VAStatus vas;

447

448 vas = vaQueryVideoProcPipelineCaps(ctx->hwctx->display, ctx->va_context,

449 ctx->filter_buffers, ctx->nb_filter_buffers,

450 &caps);

451 if (vas != VA_STATUS_SUCCESS) {

452 av_log(avctx, AV_LOG_ERROR, "Failed to query capabilities for "

453 "colour standard support: %d (%s).\n", vas, vaErrorStr(vas));

454 return AVERROR_EXTERNAL;

455 }

456

457 input_props = (VAAPIColourProperties) {

458 .colorspace = vaapi_vpp_frame_is_rgb(input_frame)

459 ? AVCOL_SPC_RGB : input_frame->colorspace,

460 .color_primaries = input_frame->color_primaries,

461 .color_trc = input_frame->color_trc,

462 .color_range = input_frame->color_range,

463 .chroma_sample_location = input_frame->chroma_location,

464 };

465

466 vaapi_vpp_fill_colour_properties(avctx, &input_props,

467 caps.input_color_standards,

468 caps.num_input_color_standards);

469

470 output_props = (VAAPIColourProperties) {

471 .colorspace = vaapi_vpp_frame_is_rgb(output_frame)

472 ? AVCOL_SPC_RGB : output_frame->colorspace,

473 .color_primaries = output_frame->color_primaries,

474 .color_trc = output_frame->color_trc,

475 .color_range = output_frame->color_range,

476 .chroma_sample_location = output_frame->chroma_location,

477 };

478 vaapi_vpp_fill_colour_properties(avctx, &output_props,

479 caps.output_color_standards,

480 caps.num_output_color_standards);

481

482 // If the properties weren't filled completely in the output frame and

483 // we chose a fixed standard then fill the known values in here.

484 #if VA_CHECK_VERSION(1, 3, 0)

485 if (output_props.va_color_standard != VAProcColorStandardExplicit)

486 #endif

487 {

488 const VAAPIColourProperties *output_standard = NULL;

489 int i;

490

491 for (i = 0; i < FF_ARRAY_ELEMS(vaapi_colour_standard_map); i++) {

492 if (output_props.va_color_standard ==

493 vaapi_colour_standard_map[i].va_color_standard) {

494 output_standard = &vaapi_colour_standard_map[i];

495 break;

496 }

497 }

498 if (output_standard) {

499 output_frame->colorspace = vaapi_vpp_frame_is_rgb(output_frame)

500 ? AVCOL_SPC_RGB : output_standard->colorspace;

501 output_frame->color_primaries = output_standard->color_primaries;

502 output_frame->color_trc = output_standard->color_trc;

503 }

504 }

505

506 params->surface_color_standard = input_props.va_color_standard;

507 params->output_color_standard = output_props.va_color_standard;

508

509 #if VA_CHECK_VERSION(1, 1, 0)

510 params->input_color_properties = (VAProcColorProperties) {

511 .chroma_sample_location = input_props.va_chroma_sample_location,

512 .color_range = input_props.va_color_range,

513 #if VA_CHECK_VERSION(1, 3, 0)

514 .colour_primaries = input_props.color_primaries,

515 .transfer_characteristics = input_props.color_trc,

516 .matrix_coefficients = input_props.colorspace,

517 #endif

518 };

519 params->output_color_properties = (VAProcColorProperties) {

520 .chroma_sample_location = output_props.va_chroma_sample_location,

521 .color_range = output_props.va_color_range,

522 #if VA_CHECK_VERSION(1, 3, 0)

523 .colour_primaries = output_props.color_primaries,

524 .transfer_characteristics = output_props.color_trc,

525 .matrix_coefficients = output_props.colorspace,

526 #endif

527 };

528 #endif

529

530 return 0;

531 }

532

533 int ff_vaapi_vpp_init_params(AVFilterContext *avctx,

534 VAProcPipelineParameterBuffer *params,

535 const AVFrame *input_frame,

536 AVFrame *output_frame)

537 {

538 VAAPIVPPContext *ctx = avctx->priv;

539 int err;

540

541 ctx->input_region = (VARectangle) {

542 .x = input_frame->crop_left,

543 .y = input_frame->crop_top,

544 .width = input_frame->width -

545 (input_frame->crop_left + input_frame->crop_right),

546 .height = input_frame->height -

547 (input_frame->crop_top + input_frame->crop_bottom),

548 };

549 output_frame->crop_top = 0;

550 output_frame->crop_bottom = 0;

551 output_frame->crop_left = 0;

552 output_frame->crop_right = 0;

553

554 *params = (VAProcPipelineParameterBuffer) {

555 .surface = ff_vaapi_vpp_get_surface_id(input_frame),

556 .surface_region = &ctx->input_region,

557 .output_region = NULL,

558 .output_background_color = VAAPI_VPP_BACKGROUND_BLACK,

559 .pipeline_flags = 0,

560 .filter_flags = VA_FRAME_PICTURE,

561

562 // Filter and reference data filled by the filter itself.

563

564 #if VA_CHECK_VERSION(1, 1, 0)

565 .rotation_state = VA_ROTATION_NONE,

566 .mirror_state = VA_MIRROR_NONE,

567 #endif

568 };

569

570 err = vaapi_vpp_colour_properties(avctx, params,

571 input_frame, output_frame);

572 if (err < 0)

573 return err;

574

575 av_log(avctx, AV_LOG_DEBUG, "Filter frame from surface %#x to %#x.\n",

576 ff_vaapi_vpp_get_surface_id(input_frame),

577 ff_vaapi_vpp_get_surface_id(output_frame));

578

579 return 0;

580 }

581

582 int ff_vaapi_vpp_make_param_buffers(AVFilterContext *avctx,

583 int type,

584 const void *data,

585 size_t size,

586 int count)

587 {

588 VAStatus vas;

589 VABufferID buffer;

590 VAAPIVPPContext *ctx = avctx->priv;

591

592 av_assert0(ctx->nb_filter_buffers + 1 <= VAProcFilterCount);

593

594 vas = vaCreateBuffer(ctx->hwctx->display, ctx->va_context,

595 type, size, count, (void*)data, &buffer);

596 if (vas != VA_STATUS_SUCCESS) {

597 av_log(avctx, AV_LOG_ERROR, "Failed to create parameter "

598 "buffer (type %d): %d (%s).\n",

599 type, vas, vaErrorStr(vas));

600 return AVERROR(EIO);

601 }

602

603 ctx->filter_buffers[ctx->nb_filter_buffers++] = buffer;

604

605 av_log(avctx, AV_LOG_DEBUG, "Param buffer (type %d, %zu bytes, count %d) "

606 "is %#x.\n", type, size, count, buffer);

607 return 0;

608 }

609

610 static int vaapi_vpp_render_single_pipeline_buffer(AVFilterContext *avctx,

611 VAProcPipelineParameterBuffer *params,

612 VABufferID *params_id)

613 {

614 VAAPIVPPContext *ctx = avctx->priv;

615 VAStatus vas;

616

617 vas = vaCreateBuffer(ctx->hwctx->display, ctx->va_context,

618 VAProcPipelineParameterBufferType,

619 sizeof(*params), 1, params, params_id);

620 if (vas != VA_STATUS_SUCCESS) {

621 av_log(avctx, AV_LOG_ERROR, "Failed to create parameter buffer: "

622 "%d (%s).\n", vas, vaErrorStr(vas));

623 *params_id = VA_INVALID_ID;

624

625 return AVERROR(EIO);

626 }

627 av_log(avctx, AV_LOG_DEBUG, "Pipeline parameter buffer is %#x.\n", *params_id);

628

629 vas = vaRenderPicture(ctx->hwctx->display, ctx->va_context, params_id, 1);

630 if (vas != VA_STATUS_SUCCESS) {

631 av_log(avctx, AV_LOG_ERROR, "Failed to render parameter buffer: "

632 "%d (%s).\n", vas, vaErrorStr(vas));

633 return AVERROR(EIO);

634 }

635

636 return 0;

637 }

638

639 int ff_vaapi_vpp_render_pictures(AVFilterContext *avctx,

640 VAProcPipelineParameterBuffer *params_list,

641 int cout,

642 AVFrame *output_frame)

643 {

644 VAAPIVPPContext *ctx = avctx->priv;

645 VABufferID *params_ids;

646 VAStatus vas;

647 int err;

648

649 params_ids = (VABufferID *)av_malloc_array(cout, sizeof(VABufferID));

650 if (!params_ids)

651 return AVERROR(ENOMEM);

652

653 for (int i = 0; i < cout; i++)

654 params_ids[i] = VA_INVALID_ID;

655

656 vas = vaBeginPicture(ctx->hwctx->display,

657 ctx->va_context, ff_vaapi_vpp_get_surface_id(output_frame));

658 if (vas != VA_STATUS_SUCCESS) {

659 av_log(avctx, AV_LOG_ERROR, "Failed to attach new picture: "

660 "%d (%s).\n", vas, vaErrorStr(vas));

661 err = AVERROR(EIO);

662 goto fail;

663 }

664

665 for (int i = 0; i < cout; i++) {

666 err = vaapi_vpp_render_single_pipeline_buffer(avctx, &params_list[i], &params_ids[i]);

667 if (err)

668 goto fail_after_begin;

669 }

670

671 vas = vaEndPicture(ctx->hwctx->display, ctx->va_context);

672 if (vas != VA_STATUS_SUCCESS) {

673 av_log(avctx, AV_LOG_ERROR, "Failed to start picture processing: "

674 "%d (%s).\n", vas, vaErrorStr(vas));

675 err = AVERROR(EIO);

676 goto fail_after_render;

677 }

678

679 if (CONFIG_VAAPI_1 || ctx->hwctx->driver_quirks &

680 AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS) {

681 for (int i = 0; i < cout && params_ids[i] != VA_INVALID_ID; i++) {

682 vas = vaDestroyBuffer(ctx->hwctx->display, params_ids[i]);

683 if (vas != VA_STATUS_SUCCESS) {

684 av_log(avctx, AV_LOG_ERROR, "Failed to free parameter buffer: "

685 "%d (%s).\n", vas, vaErrorStr(vas));

686 // And ignore.

687 }

688 }

689 }

690

691 av_freep(&params_ids);

692 return 0;

693

694 // We want to make sure that if vaBeginPicture has been called, we also

695 // call vaRenderPicture and vaEndPicture. These calls may well fail or

696 // do something else nasty, but once we're in this failure case there

697 // isn't much else we can do.

698 fail_after_begin:

699 vaRenderPicture(ctx->hwctx->display, ctx->va_context, &params_ids[0], 1);

700 fail_after_render:

701 vaEndPicture(ctx->hwctx->display, ctx->va_context);

702 fail:

703 av_freep(&params_ids);

704 return err;

705 }

706

707 int ff_vaapi_vpp_render_picture(AVFilterContext *avctx,

708 VAProcPipelineParameterBuffer *params,

709 AVFrame *output_frame)

710 {

711 return ff_vaapi_vpp_render_pictures(avctx, params, 1, output_frame);

712 }

713

714 void ff_vaapi_vpp_ctx_init(AVFilterContext *avctx)

715 {

716 int i;

717 VAAPIVPPContext *ctx = avctx->priv;

718

719 ctx->va_config = VA_INVALID_ID;

720 ctx->va_context = VA_INVALID_ID;

721 ctx->valid_ids = 1;

722

723 for (i = 0; i < VAProcFilterCount; i++)

724 ctx->filter_buffers[i] = VA_INVALID_ID;

725 ctx->nb_filter_buffers = 0;

726 }

727

728 void ff_vaapi_vpp_ctx_uninit(AVFilterContext *avctx)

729 {

730 VAAPIVPPContext *ctx = avctx->priv;

731 if (ctx->valid_ids && ctx->pipeline_uninit)

732 ctx->pipeline_uninit(avctx);

733

734 av_buffer_unref(&ctx->input_frames_ref);

735 av_buffer_unref(&ctx->device_ref);

736 }

AVFrame::color_trc

enum AVColorTransferCharacteristic color_trc

Definition: frame.h:682

ff_vaapi_vpp_pipeline_uninit

void ff_vaapi_vpp_pipeline_uninit(AVFilterContext *avctx)

Definition: vaapi_vpp.c:45

ff_vaapi_vpp_ctx_init

void ff_vaapi_vpp_ctx_init(AVFilterContext *avctx)

Definition: vaapi_vpp.c:714

vaapi_vpp_frame_is_rgb

static int vaapi_vpp_frame_is_rgb(const AVFrame *frame)

Definition: vaapi_vpp.c:426

ff_vaapi_vpp_get_surface_id

static VASurfaceID ff_vaapi_vpp_get_surface_id(const AVFrame *frame)

Definition: vaapi_vpp.h:30

AVFrame::color_range

enum AVColorRange color_range

MPEG vs JPEG YUV range.

Definition: frame.h:678

AVPixelFormat

Pixel format.

Definition: pixfmt.h:71

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

AVVAAPIHWConfig

VAAPI hardware pipeline configuration details.

Definition: hwcontext_vaapi.h:110

AVColorTransferCharacteristic

Color Transfer Characteristic.

Definition: pixfmt.h:661

ff_vaapi_vpp_render_picture

int ff_vaapi_vpp_render_picture(AVFilterContext *avctx, VAProcPipelineParameterBuffer *params, AVFrame *output_frame)

Definition: vaapi_vpp.c:707

av_hwdevice_hwconfig_alloc

void * av_hwdevice_hwconfig_alloc(AVBufferRef *ref)

Allocate a HW-specific configuration structure for a given HW device.

Definition: hwcontext.c:570

av_pix_fmt_desc_get

const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)

Definition: pixdesc.c:3447

AVBufferRef::data

uint8_t * data

The data buffer.

Definition: buffer.h:90

AVCHROMA_LOC_BOTTOM

@ AVCHROMA_LOC_BOTTOM

Definition: pixfmt.h:793

AVHWFramesContext::format

enum AVPixelFormat format

The pixel format identifying the underlying HW surface type.

Definition: hwcontext.h:200

inlink

The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink

Definition: filter_design.txt:212

AVFrame::color_primaries

enum AVColorPrimaries color_primaries

Definition: frame.h:680

AVFrame::colorspace

enum AVColorSpace colorspace

YUV colorspace type.

Definition: frame.h:689

av_hwframe_ctx_init

int av_hwframe_ctx_init(AVBufferRef *ref)

Finalize the context before use.

Definition: hwcontext.c:337

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:427

pixdesc.h

AVFrame::width

int width

Definition: frame.h:499

AVCOL_RANGE_JPEG

@ AVCOL_RANGE_JPEG

Full range content.

Definition: pixfmt.h:767

av_hwframe_ctx_alloc

AVBufferRef * av_hwframe_ctx_alloc(AVBufferRef *device_ref_in)

Allocate an AVHWFramesContext tied to a given device context.

Definition: hwcontext.c:263

AVCOL_TRC_UNSPECIFIED

@ AVCOL_TRC_UNSPECIFIED

Definition: pixfmt.h:664

data

const char data[16]

Definition: mxf.c:149

ff_vaapi_vpp_render_pictures

int ff_vaapi_vpp_render_pictures(AVFilterContext *avctx, VAProcPipelineParameterBuffer *params_list, int cout, AVFrame *output_frame)

Definition: vaapi_vpp.c:639

AV_LOG_VERBOSE

#define AV_LOG_VERBOSE

Detailed information.

Definition: log.h:226

AVCOL_SPC_RGB

@ AVCOL_SPC_RGB

order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1

Definition: pixfmt.h:691

AVColorPrimaries

Chromaticity coordinates of the source primaries.

Definition: pixfmt.h:636

av_buffer_ref

AVBufferRef * av_buffer_ref(const AVBufferRef *buf)

Create a new reference to an AVBuffer.

Definition: buffer.c:103

AVHWFramesContext::width

int width

The allocated dimensions of the frames in this pool.

Definition: hwcontext.h:220

av_hwdevice_get_hwframe_constraints

AVHWFramesConstraints * av_hwdevice_get_hwframe_constraints(AVBufferRef *ref, const void *hwconfig)

Get the constraints on HW frames given a device and the HW-specific configuration to be used with tha...

Definition: hwcontext.c:581

AVFilterLink

A link between two filters.

Definition: avfilter.h:395

av_chroma_location_name

const char * av_chroma_location_name(enum AVChromaLocation location)

Definition: pixdesc.c:3844

ff_vaapi_vpp_query_formats

int ff_vaapi_vpp_query_formats(const AVFilterContext *avctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)

Definition: vaapi_vpp.c:29

FilterLink

Link properties exposed to filter code, but not external callers.

Definition: filters.h:128

VAAPIColourProperties::color_primaries

enum AVColorPrimaries color_primaries

Definition: vaapi_vpp.c:258

AVHWFramesConstraints

This struct describes the constraints on hardware frames attached to a given device with a hardware-s...

Definition: hwcontext.h:444

formats.h

AVVAAPIHWConfig::config_id

VAConfigID config_id

ID of a VAAPI pipeline configuration.

Definition: hwcontext_vaapi.h:114

AVFrame::chroma_location

enum AVChromaLocation chroma_location

Definition: frame.h:691

AVVAAPIFramesContext::surface_ids

VASurfaceID * surface_ids

The surfaces IDs of all surfaces in the pool after creation.

Definition: hwcontext_vaapi.h:101

av_color_space_name

const char * av_color_space_name(enum AVColorSpace space)

Definition: pixdesc.c:3823

AVFilterContext::priv

void * priv

private data for use by the filter

Definition: avfilter.h:289

fail

#define fail()

Definition: checkasm.h:206

AVHWFramesConstraints::min_width

int min_width

The minimum size of frames in this hw_frames_ctx.

Definition: hwcontext.h:462

type

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type

Definition: writing_filters.txt:86

AVHWDeviceContext

This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.

Definition: hwcontext.h:63

avassert.h

AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS

@ AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS

The driver does not destroy parameter buffers when they are used by vaRenderPicture().

Definition: hwcontext_vaapi.h:47

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

AVHWFramesContext::height

int height

Definition: hwcontext.h:220

AVHWFramesConstraints::valid_sw_formats

enum AVPixelFormat * valid_sw_formats

A list of possible values for sw_format in the hw_frames_ctx, terminated by AV_PIX_FMT_NONE.

Definition: hwcontext.h:456

av_hwframe_constraints_free

void av_hwframe_constraints_free(AVHWFramesConstraints **constraints)

Free an AVHWFrameConstraints structure.

Definition: hwcontext.c:606

VAAPIColourProperties::colorspace

enum AVColorSpace colorspace

Definition: vaapi_vpp.c:260

AVCHROMA_LOC_TOP

@ AVCHROMA_LOC_TOP

Definition: pixfmt.h:791

VAAPIColourProperties::color_range

enum AVColorRange color_range

Definition: vaapi_vpp.c:265

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:41

filters.h

pix_fmts

static enum AVPixelFormat pix_fmts[]

Definition: libkvazaar.c:298

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:231

ctx

AVFormatContext * ctx

Definition: movenc.c:49

ff_vaapi_vpp_make_param_buffers

int ff_vaapi_vpp_make_param_buffers(AVFilterContext *avctx, int type, const void *data, size_t size, int count)

Definition: vaapi_vpp.c:582

vaapi_vpp_fill_chroma_sample_location

static void vaapi_vpp_fill_chroma_sample_location(VAAPIColourProperties *props)

Definition: vaapi_vpp.c:352

AVFrame::crop_right

size_t crop_right

Definition: frame.h:753

AVCOL_PRI_UNSPECIFIED

@ AVCOL_PRI_UNSPECIFIED

Definition: pixfmt.h:639

if(ret)

Definition: filter_design.txt:179

av_color_range_name

const char * av_color_range_name(enum AVColorRange range)

Definition: pixdesc.c:3763

NULL

#define NULL

Definition: coverity.c:32

AVHWFramesContext::sw_format

enum AVPixelFormat sw_format

The pixel format identifying the actual data layout of the hardware frames.

Definition: hwcontext.h:213

av_buffer_unref

void av_buffer_unref(AVBufferRef **buf)

Free a given reference and automatically free the buffer if there are no more references to it.

Definition: buffer.c:139

AVCHROMA_LOC_LEFT

@ AVCHROMA_LOC_LEFT

MPEG-2/4 4:2:0, H.264 default for 4:2:0.

Definition: pixfmt.h:788

vaapi_vpp_colour_properties

static int vaapi_vpp_colour_properties(AVFilterContext *avctx, VAProcPipelineParameterBuffer *params, const AVFrame *input_frame, AVFrame *output_frame)

Definition: vaapi_vpp.c:438

AVCHROMA_LOC_TOPLEFT

@ AVCHROMA_LOC_TOPLEFT

ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.

Definition: pixfmt.h:790

AVFilterContext::inputs

AVFilterLink ** inputs

array of pointers to input links

Definition: avfilter.h:282

av_color_primaries_name

const char * av_color_primaries_name(enum AVColorPrimaries primaries)

Definition: pixdesc.c:3781

ff_vaapi_vpp_config_input

int ff_vaapi_vpp_config_input(AVFilterLink *inlink)

Definition: vaapi_vpp.c:71

vaapi_colour_standard_map

static const VAAPIColourProperties vaapi_colour_standard_map[]

Definition: vaapi_vpp.c:269

ff_vaapi_vpp_ctx_uninit

void ff_vaapi_vpp_ctx_uninit(AVFilterContext *avctx)

Definition: vaapi_vpp.c:728

AVCOL_RANGE_UNSPECIFIED

@ AVCOL_RANGE_UNSPECIFIED

Definition: pixfmt.h:733

AVFilterFormatsConfig

Lists of formats / etc.

Definition: avfilter.h:121

ff_filter_link

static FilterLink * ff_filter_link(AVFilterLink *link)

Definition: filters.h:198

AVFrame::crop_bottom

size_t crop_bottom

Definition: frame.h:751

AVFrame::crop_left

size_t crop_left

Definition: frame.h:752

vaapi_vpp.h

height

#define height

Definition: dsp.h:89

AV_PIX_FMT_FLAG_RGB

#define AV_PIX_FMT_FLAG_RGB

The pixel format contains RGB-like data (as opposed to YUV/grayscale).

Definition: pixdesc.h:136

size

int size

Definition: twinvq_data.h:10344

AVCHROMA_LOC_UNSPECIFIED

@ AVCHROMA_LOC_UNSPECIFIED

Definition: pixfmt.h:787

AVFilterLink::src

AVFilterContext * src

source filter

Definition: avfilter.h:396

output_frame

static int output_frame(H264Context *h, AVFrame *dst, H264Picture *srcp)

Definition: h264dec.c:861

AVERROR_EXTERNAL

#define AVERROR_EXTERNAL

Generic error in an external library.

Definition: error.h:59

AVHWFramesConstraints::max_width

int max_width

The maximum size of frames in this hw_frames_ctx.

Definition: hwcontext.h:469

AV_PIX_FMT_VAAPI

@ AV_PIX_FMT_VAAPI

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

Definition: pixfmt.h:126

FilterLink::hw_frames_ctx

AVBufferRef * hw_frames_ctx

For hwaccel pixel formats, this should be a reference to the AVHWFramesContext describing the frames.

Definition: filters.h:195

AVChromaLocation

Location of chroma samples.

Definition: pixfmt.h:786

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

Definition: cbs_h2645.c:256

AVFilterLink::w

int w

agreed upon image width

Definition: avfilter.h:407

av_malloc_array

#define av_malloc_array(a, b)

Definition: tableprint_vlc.h:32

AVColorSpace

YUV colorspace type.

Definition: pixfmt.h:690

AVCOL_SPC_UNSPECIFIED

@ AVCOL_SPC_UNSPECIFIED

Definition: pixfmt.h:693

AVCOL_RANGE_MPEG

@ AVCOL_RANGE_MPEG

Narrow or limited range content.

Definition: pixfmt.h:750

VAAPIColourProperties::va_color_range

uint8_t va_color_range

Definition: vaapi_vpp.c:263

AVHWFramesContext

This struct describes a set or pool of "hardware" frames (i.e.

Definition: hwcontext.h:118

VAAPIVPPContext

Definition: vaapi_vpp.h:38

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

AVHWFramesContext::hwctx

void * hwctx

The format-specific data, allocated and freed automatically along with this context.

Definition: hwcontext.h:153

AVHWFramesConstraints::max_height

int max_height

Definition: hwcontext.h:470

vaapi_vpp_fill_colour_range

static void vaapi_vpp_fill_colour_range(VAAPIColourProperties *props)

Definition: vaapi_vpp.c:387

AVFrame::height

int height

Definition: frame.h:499

ff_set_common_formats_from_list2

int ff_set_common_formats_from_list2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, const int *fmts)

Definition: formats.c:1085

vaapi_vpp_fill_colour_properties

static void vaapi_vpp_fill_colour_properties(AVFilterContext *avctx, VAAPIColourProperties *props, VAProcColorStandardType *vacs, int nb_vacs)

Definition: vaapi_vpp.c:406

ff_vaapi_vpp_config_output

int ff_vaapi_vpp_config_output(AVFilterLink *outlink)

Definition: vaapi_vpp.c:97

AVHWFramesConstraints::min_height

int min_height

Definition: hwcontext.h:463

AVFilterLink::h

int h

agreed upon image height

Definition: avfilter.h:408

AVVAAPIFramesContext::nb_surfaces

int nb_surfaces

Definition: hwcontext_vaapi.h:102

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

AVCHROMA_LOC_CENTER

@ AVCHROMA_LOC_CENTER

MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.

Definition: pixfmt.h:789

AV_PIX_FMT_NONE

@ AV_PIX_FMT_NONE

Definition: pixfmt.h:72

VAAPIColourProperties::va_color_standard

VAProcColorStandardType va_color_standard

Definition: vaapi_vpp.c:256

VAAPIColourProperties::va_chroma_sample_location