2 * This file is part of FFmpeg.
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.
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.
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
22 #include <mfx/mfxvideo.h>
27 #include "hwcontext_vaapi.h"
30 #include "hwcontext_dxva2.h"
35 #include "hwcontext.h"
36 #include "hwcontext_internal.h"
37 #include "hwcontext_qsv.h"
43 typedef struct QSVDevicePriv {
44 AVBufferRef *child_device_ctx;
47 typedef struct QSVDeviceContext {
49 mfxHandleType handle_type;
53 enum AVHWDeviceType child_device_type;
54 enum AVPixelFormat child_pix_fmt;
57 typedef struct QSVFramesContext {
58 mfxSession session_download;
59 mfxSession session_upload;
61 AVBufferRef *child_frames_ref;
62 mfxFrameSurface1 *surfaces_internal;
65 // used in the frame allocator for non-opaque surfaces
67 // used in the opaque alloc request for opaque surfaces
68 mfxFrameSurface1 **surface_ptrs;
70 mfxExtOpaqueSurfaceAlloc opaque_alloc;
71 mfxExtBuffer *ext_buffers[1];
75 mfxHandleType handle_type;
76 enum AVHWDeviceType device_type;
77 enum AVPixelFormat pix_fmt;
78 } supported_handle_types[] = {
80 { MFX_HANDLE_VA_DISPLAY, AV_HWDEVICE_TYPE_VAAPI, AV_PIX_FMT_VAAPI },
83 { MFX_HANDLE_D3D9_DEVICE_MANAGER, AV_HWDEVICE_TYPE_DXVA2, AV_PIX_FMT_DXVA2_VLD },
89 enum AVPixelFormat pix_fmt;
91 } supported_pixel_formats[] = {
92 { AV_PIX_FMT_NV12, MFX_FOURCC_NV12 },
93 { AV_PIX_FMT_P010, MFX_FOURCC_P010 },
94 { AV_PIX_FMT_PAL8, MFX_FOURCC_P8 },
97 static uint32_t qsv_fourcc_from_pix_fmt(enum AVPixelFormat pix_fmt)
100 for (i = 0; i < FF_ARRAY_ELEMS(supported_pixel_formats); i++) {
101 if (supported_pixel_formats[i].pix_fmt == pix_fmt)
102 return supported_pixel_formats[i].fourcc;
107 static int qsv_device_init(AVHWDeviceContext *ctx)
109 AVQSVDeviceContext *hwctx = ctx->hwctx;
110 QSVDeviceContext *s = ctx->internal->priv;
115 for (i = 0; supported_handle_types[i].handle_type; i++) {
116 err = MFXVideoCORE_GetHandle(hwctx->session, supported_handle_types[i].handle_type,
118 if (err == MFX_ERR_NONE) {
119 s->handle_type = supported_handle_types[i].handle_type;
120 s->child_device_type = supported_handle_types[i].device_type;
121 s->child_pix_fmt = supported_handle_types[i].pix_fmt;
126 av_log(ctx, AV_LOG_VERBOSE, "No supported hw handle could be retrieved "
127 "from the session\n");
130 err = MFXQueryIMPL(hwctx->session, &s->impl);
131 if (err == MFX_ERR_NONE)
132 err = MFXQueryVersion(hwctx->session, &s->ver);
133 if (err != MFX_ERR_NONE) {
134 av_log(ctx, AV_LOG_ERROR, "Error querying the session attributes\n");
135 return AVERROR_UNKNOWN;
141 static void qsv_frames_uninit(AVHWFramesContext *ctx)
143 QSVFramesContext *s = ctx->internal->priv;
145 if (s->session_download) {
146 MFXVideoVPP_Close(s->session_download);
147 MFXClose(s->session_download);
149 s->session_download = NULL;
151 if (s->session_upload) {
152 MFXVideoVPP_Close(s->session_upload);
153 MFXClose(s->session_upload);
155 s->session_upload = NULL;
157 av_freep(&s->mem_ids);
158 av_freep(&s->surface_ptrs);
159 av_freep(&s->surfaces_internal);
160 av_buffer_unref(&s->child_frames_ref);
163 static void qsv_pool_release_dummy(void *opaque, uint8_t *data)
167 static AVBufferRef *qsv_pool_alloc(void *opaque, int size)
169 AVHWFramesContext *ctx = (AVHWFramesContext*)opaque;
170 QSVFramesContext *s = ctx->internal->priv;
171 AVQSVFramesContext *hwctx = ctx->hwctx;
173 if (s->nb_surfaces_used < hwctx->nb_surfaces) {
174 s->nb_surfaces_used++;
175 return av_buffer_create((uint8_t*)(s->surfaces_internal + s->nb_surfaces_used - 1),
176 sizeof(*hwctx->surfaces), qsv_pool_release_dummy, NULL, 0);
182 static int qsv_init_child_ctx(AVHWFramesContext *ctx)
184 AVQSVFramesContext *hwctx = ctx->hwctx;
185 QSVFramesContext *s = ctx->internal->priv;
186 QSVDeviceContext *device_priv = ctx->device_ctx->internal->priv;
188 AVBufferRef *child_device_ref = NULL;
189 AVBufferRef *child_frames_ref = NULL;
191 AVHWDeviceContext *child_device_ctx;
192 AVHWFramesContext *child_frames_ctx;
196 if (!device_priv->handle) {
197 av_log(ctx, AV_LOG_ERROR,
198 "Cannot create a non-opaque internal surface pool without "
199 "a hardware handle\n");
200 return AVERROR(EINVAL);
203 child_device_ref = av_hwdevice_ctx_alloc(device_priv->child_device_type);
204 if (!child_device_ref)
205 return AVERROR(ENOMEM);
206 child_device_ctx = (AVHWDeviceContext*)child_device_ref->data;
209 if (child_device_ctx->type == AV_HWDEVICE_TYPE_VAAPI) {
210 AVVAAPIDeviceContext *child_device_hwctx = child_device_ctx->hwctx;
211 child_device_hwctx->display = (VADisplay)device_priv->handle;
215 if (child_device_ctx->type == AV_HWDEVICE_TYPE_DXVA2) {
216 AVDXVA2DeviceContext *child_device_hwctx = child_device_ctx->hwctx;
217 child_device_hwctx->devmgr = (IDirect3DDeviceManager9*)device_priv->handle;
221 ret = av_hwdevice_ctx_init(child_device_ref);
223 av_log(ctx, AV_LOG_ERROR, "Error initializing a child device context\n");
227 child_frames_ref = av_hwframe_ctx_alloc(child_device_ref);
228 if (!child_frames_ref) {
229 ret = AVERROR(ENOMEM);
232 child_frames_ctx = (AVHWFramesContext*)child_frames_ref->data;
234 child_frames_ctx->format = device_priv->child_pix_fmt;
235 child_frames_ctx->sw_format = ctx->sw_format;
236 child_frames_ctx->initial_pool_size = ctx->initial_pool_size;
237 child_frames_ctx->width = FFALIGN(ctx->width, 16);
238 child_frames_ctx->height = FFALIGN(ctx->height, 16);
241 if (child_device_ctx->type == AV_HWDEVICE_TYPE_DXVA2) {
242 AVDXVA2FramesContext *child_frames_hwctx = child_frames_ctx->hwctx;
243 if (hwctx->frame_type & MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET)
244 child_frames_hwctx->surface_type = DXVA2_VideoProcessorRenderTarget;
246 child_frames_hwctx->surface_type = DXVA2_VideoDecoderRenderTarget;
250 ret = av_hwframe_ctx_init(child_frames_ref);
252 av_log(ctx, AV_LOG_ERROR, "Error initializing a child frames context\n");
257 if (child_device_ctx->type == AV_HWDEVICE_TYPE_VAAPI) {
258 AVVAAPIFramesContext *child_frames_hwctx = child_frames_ctx->hwctx;
259 for (i = 0; i < ctx->initial_pool_size; i++)
260 s->surfaces_internal[i].Data.MemId = child_frames_hwctx->surface_ids + i;
261 hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;
265 if (child_device_ctx->type == AV_HWDEVICE_TYPE_DXVA2) {
266 AVDXVA2FramesContext *child_frames_hwctx = child_frames_ctx->hwctx;
267 for (i = 0; i < ctx->initial_pool_size; i++)
268 s->surfaces_internal[i].Data.MemId = (mfxMemId)child_frames_hwctx->surfaces[i];
269 if (child_frames_hwctx->surface_type == DXVA2_VideoProcessorRenderTarget)
270 hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET;
272 hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;
276 s->child_frames_ref = child_frames_ref;
277 child_frames_ref = NULL;
280 av_buffer_unref(&child_device_ref);
281 av_buffer_unref(&child_frames_ref);
285 static int qsv_init_surface(AVHWFramesContext *ctx, mfxFrameSurface1 *surf)
287 const AVPixFmtDescriptor *desc;
290 desc = av_pix_fmt_desc_get(ctx->sw_format);
292 return AVERROR(EINVAL);
294 fourcc = qsv_fourcc_from_pix_fmt(ctx->sw_format);
296 return AVERROR(EINVAL);
298 surf->Info.BitDepthLuma = desc->comp[0].depth;
299 surf->Info.BitDepthChroma = desc->comp[0].depth;
300 surf->Info.Shift = desc->comp[0].depth > 8;
302 if (desc->log2_chroma_w && desc->log2_chroma_h)
303 surf->Info.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
304 else if (desc->log2_chroma_w)
305 surf->Info.ChromaFormat = MFX_CHROMAFORMAT_YUV422;
307 surf->Info.ChromaFormat = MFX_CHROMAFORMAT_YUV444;
309 surf->Info.FourCC = fourcc;
310 surf->Info.Width = FFALIGN(ctx->width, 16);
311 surf->Info.CropW = ctx->width;
312 surf->Info.Height = FFALIGN(ctx->height, 16);
313 surf->Info.CropH = ctx->height;
314 surf->Info.FrameRateExtN = 25;
315 surf->Info.FrameRateExtD = 1;
316 surf->Info.PicStruct = MFX_PICSTRUCT_PROGRESSIVE;
321 static int qsv_init_pool(AVHWFramesContext *ctx, uint32_t fourcc)
323 QSVFramesContext *s = ctx->internal->priv;
324 AVQSVFramesContext *frames_hwctx = ctx->hwctx;
328 if (ctx->initial_pool_size <= 0) {
329 av_log(ctx, AV_LOG_ERROR, "QSV requires a fixed frame pool size\n");
330 return AVERROR(EINVAL);
333 s->surfaces_internal = av_mallocz_array(ctx->initial_pool_size,
334 sizeof(*s->surfaces_internal));
335 if (!s->surfaces_internal)
336 return AVERROR(ENOMEM);
338 for (i = 0; i < ctx->initial_pool_size; i++) {
339 ret = qsv_init_surface(ctx, &s->surfaces_internal[i]);
344 if (!(frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME)) {
345 ret = qsv_init_child_ctx(ctx);
350 ctx->internal->pool_internal = av_buffer_pool_init2(sizeof(mfxFrameSurface1),
351 ctx, qsv_pool_alloc, NULL);
352 if (!ctx->internal->pool_internal)
353 return AVERROR(ENOMEM);
355 frames_hwctx->surfaces = s->surfaces_internal;
356 frames_hwctx->nb_surfaces = ctx->initial_pool_size;
361 static mfxStatus frame_alloc(mfxHDL pthis, mfxFrameAllocRequest *req,
362 mfxFrameAllocResponse *resp)
364 AVHWFramesContext *ctx = pthis;
365 QSVFramesContext *s = ctx->internal->priv;
366 AVQSVFramesContext *hwctx = ctx->hwctx;
367 mfxFrameInfo *i = &req->Info;
368 mfxFrameInfo *i1 = &hwctx->surfaces[0].Info;
370 if (!(req->Type & MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET) ||
371 !(req->Type & (MFX_MEMTYPE_FROM_VPPIN | MFX_MEMTYPE_FROM_VPPOUT)) ||
372 !(req->Type & MFX_MEMTYPE_EXTERNAL_FRAME))
373 return MFX_ERR_UNSUPPORTED;
374 if (i->Width != i1->Width || i->Height != i1->Height ||
375 i->FourCC != i1->FourCC || i->ChromaFormat != i1->ChromaFormat) {
376 av_log(ctx, AV_LOG_ERROR, "Mismatching surface properties in an "
377 "allocation request: %dx%d %d %d vs %dx%d %d %d\n",
378 i->Width, i->Height, i->FourCC, i->ChromaFormat,
379 i1->Width, i1->Height, i1->FourCC, i1->ChromaFormat);
380 return MFX_ERR_UNSUPPORTED;
383 resp->mids = s->mem_ids;
384 resp->NumFrameActual = hwctx->nb_surfaces;
389 static mfxStatus frame_free(mfxHDL pthis, mfxFrameAllocResponse *resp)
394 static mfxStatus frame_lock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
396 return MFX_ERR_UNSUPPORTED;
399 static mfxStatus frame_unlock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
401 return MFX_ERR_UNSUPPORTED;
404 static mfxStatus frame_get_hdl(mfxHDL pthis, mfxMemId mid, mfxHDL *hdl)
410 static int qsv_init_internal_session(AVHWFramesContext *ctx,
411 mfxSession *session, int upload)
413 QSVFramesContext *s = ctx->internal->priv;
414 AVQSVFramesContext *frames_hwctx = ctx->hwctx;
415 QSVDeviceContext *device_priv = ctx->device_ctx->internal->priv;
416 int opaque = !!(frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME);
418 mfxFrameAllocator frame_allocator = {
420 .Alloc = frame_alloc,
422 .Unlock = frame_unlock,
423 .GetHDL = frame_get_hdl,
430 err = MFXInit(device_priv->impl, &device_priv->ver, session);
431 if (err != MFX_ERR_NONE) {
432 av_log(ctx, AV_LOG_ERROR, "Error initializing an internal session\n");
433 return AVERROR_UNKNOWN;
436 if (device_priv->handle) {
437 err = MFXVideoCORE_SetHandle(*session, device_priv->handle_type,
438 device_priv->handle);
439 if (err != MFX_ERR_NONE)
440 return AVERROR_UNKNOWN;
444 err = MFXVideoCORE_SetFrameAllocator(*session, &frame_allocator);
445 if (err != MFX_ERR_NONE)
446 return AVERROR_UNKNOWN;
449 memset(&par, 0, sizeof(par));
452 par.ExtParam = s->ext_buffers;
453 par.NumExtParam = FF_ARRAY_ELEMS(s->ext_buffers);
454 par.IOPattern = upload ? MFX_IOPATTERN_OUT_OPAQUE_MEMORY :
455 MFX_IOPATTERN_IN_OPAQUE_MEMORY;
457 par.IOPattern = upload ? MFX_IOPATTERN_OUT_VIDEO_MEMORY :
458 MFX_IOPATTERN_IN_VIDEO_MEMORY;
461 par.IOPattern |= upload ? MFX_IOPATTERN_IN_SYSTEM_MEMORY :
462 MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
465 par.vpp.In = frames_hwctx->surfaces[0].Info;
467 /* Apparently VPP requires the frame rate to be set to some value, otherwise
468 * init will fail (probably for the framerate conversion filter). Since we
469 * are only doing data upload/download here, we just invent an arbitrary
471 par.vpp.In.FrameRateExtN = 25;
472 par.vpp.In.FrameRateExtD = 1;
473 par.vpp.Out = par.vpp.In;
475 err = MFXVideoVPP_Init(*session, &par);
476 if (err != MFX_ERR_NONE) {
477 av_log(ctx, AV_LOG_VERBOSE, "Error opening the internal VPP session."
478 "Surface upload/download will not be possible\n");
486 static int qsv_frames_init(AVHWFramesContext *ctx)
488 QSVFramesContext *s = ctx->internal->priv;
489 AVQSVFramesContext *frames_hwctx = ctx->hwctx;
491 int opaque = !!(frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME);
496 fourcc = qsv_fourcc_from_pix_fmt(ctx->sw_format);
498 av_log(ctx, AV_LOG_ERROR, "Unsupported pixel format\n");
499 return AVERROR(ENOSYS);
503 ret = qsv_init_pool(ctx, fourcc);
505 av_log(ctx, AV_LOG_ERROR, "Error creating an internal frame pool\n");
511 s->surface_ptrs = av_mallocz_array(frames_hwctx->nb_surfaces,
512 sizeof(*s->surface_ptrs));
513 if (!s->surface_ptrs)
514 return AVERROR(ENOMEM);
516 for (i = 0; i < frames_hwctx->nb_surfaces; i++)
517 s->surface_ptrs[i] = frames_hwctx->surfaces + i;
519 s->opaque_alloc.In.Surfaces = s->surface_ptrs;
520 s->opaque_alloc.In.NumSurface = frames_hwctx->nb_surfaces;
521 s->opaque_alloc.In.Type = frames_hwctx->frame_type;
523 s->opaque_alloc.Out = s->opaque_alloc.In;
525 s->opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
526 s->opaque_alloc.Header.BufferSz = sizeof(s->opaque_alloc);
528 s->ext_buffers[0] = (mfxExtBuffer*)&s->opaque_alloc;
530 s->mem_ids = av_mallocz_array(frames_hwctx->nb_surfaces, sizeof(*s->mem_ids));
532 return AVERROR(ENOMEM);
534 for (i = 0; i < frames_hwctx->nb_surfaces; i++)
535 s->mem_ids[i] = frames_hwctx->surfaces[i].Data.MemId;
538 ret = qsv_init_internal_session(ctx, &s->session_download, 0);
542 ret = qsv_init_internal_session(ctx, &s->session_upload, 1);
549 static int qsv_get_buffer(AVHWFramesContext *ctx, AVFrame *frame)
551 frame->buf[0] = av_buffer_pool_get(ctx->pool);
553 return AVERROR(ENOMEM);
555 frame->data[3] = frame->buf[0]->data;
556 frame->format = AV_PIX_FMT_QSV;
557 frame->width = ctx->width;
558 frame->height = ctx->height;
563 static int qsv_transfer_get_formats(AVHWFramesContext *ctx,
564 enum AVHWFrameTransferDirection dir,
565 enum AVPixelFormat **formats)
567 enum AVPixelFormat *fmts;
569 fmts = av_malloc_array(2, sizeof(*fmts));
571 return AVERROR(ENOMEM);
573 fmts[0] = ctx->sw_format;
574 fmts[1] = AV_PIX_FMT_NONE;
581 static int qsv_frames_derive_from(AVHWFramesContext *dst_ctx,
582 AVHWFramesContext *src_ctx, int flags)
584 AVQSVFramesContext *src_hwctx = src_ctx->hwctx;
587 switch (dst_ctx->device_ctx->type) {
589 case AV_HWDEVICE_TYPE_VAAPI:
591 AVVAAPIFramesContext *dst_hwctx = dst_ctx->hwctx;
592 dst_hwctx->surface_ids = av_mallocz_array(src_hwctx->nb_surfaces,
593 sizeof(*dst_hwctx->surface_ids));
594 if (!dst_hwctx->surface_ids)
595 return AVERROR(ENOMEM);
596 for (i = 0; i < src_hwctx->nb_surfaces; i++)
597 dst_hwctx->surface_ids[i] =
598 *(VASurfaceID*)src_hwctx->surfaces[i].Data.MemId;
599 dst_hwctx->nb_surfaces = src_hwctx->nb_surfaces;
604 case AV_HWDEVICE_TYPE_DXVA2:
606 AVDXVA2FramesContext *dst_hwctx = dst_ctx->hwctx;
607 dst_hwctx->surfaces = av_mallocz_array(src_hwctx->nb_surfaces,
608 sizeof(*dst_hwctx->surfaces));
609 if (!dst_hwctx->surfaces)
610 return AVERROR(ENOMEM);
611 for (i = 0; i < src_hwctx->nb_surfaces; i++)
612 dst_hwctx->surfaces[i] =
613 (IDirect3DSurface9*)src_hwctx->surfaces[i].Data.MemId;
614 dst_hwctx->nb_surfaces = src_hwctx->nb_surfaces;
615 if (src_hwctx->frame_type == MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET)
616 dst_hwctx->surface_type = DXVA2_VideoDecoderRenderTarget;
618 dst_hwctx->surface_type = DXVA2_VideoProcessorRenderTarget;
623 return AVERROR(ENOSYS);
629 static int qsv_map_from(AVHWFramesContext *ctx,
630 AVFrame *dst, const AVFrame *src, int flags)
632 QSVFramesContext *s = ctx->internal->priv;
633 mfxFrameSurface1 *surf = (mfxFrameSurface1*)src->data[3];
634 AVHWFramesContext *child_frames_ctx;
635 const AVPixFmtDescriptor *desc;
640 if (!s->child_frames_ref)
641 return AVERROR(ENOSYS);
642 child_frames_ctx = (AVHWFramesContext*)s->child_frames_ref->data;
644 switch (child_frames_ctx->device_ctx->type) {
646 case AV_HWDEVICE_TYPE_VAAPI:
647 child_data = (uint8_t*)(intptr_t)*(VASurfaceID*)surf->Data.MemId;
651 case AV_HWDEVICE_TYPE_DXVA2:
652 child_data = surf->Data.MemId;
656 return AVERROR(ENOSYS);
659 if (dst->format == child_frames_ctx->format) {
660 ret = ff_hwframe_map_create(s->child_frames_ref,
661 dst, src, NULL, NULL);
665 dst->width = src->width;
666 dst->height = src->height;
667 dst->data[3] = child_data;
672 desc = av_pix_fmt_desc_get(dst->format);
673 if (desc && desc->flags & AV_PIX_FMT_FLAG_HWACCEL) {
674 // This only supports mapping to software.
675 return AVERROR(ENOSYS);
678 dummy = av_frame_alloc();
680 return AVERROR(ENOMEM);
682 dummy->buf[0] = av_buffer_ref(src->buf[0]);
683 dummy->hw_frames_ctx = av_buffer_ref(s->child_frames_ref);
684 if (!dummy->buf[0] || !dummy->hw_frames_ctx)
687 dummy->format = child_frames_ctx->format;
688 dummy->width = src->width;
689 dummy->height = src->height;
690 dummy->data[3] = child_data;
692 ret = av_hwframe_map(dst, dummy, flags);
695 av_frame_free(&dummy);
700 static int qsv_transfer_data_child(AVHWFramesContext *ctx, AVFrame *dst,
703 QSVFramesContext *s = ctx->internal->priv;
704 AVHWFramesContext *child_frames_ctx = (AVHWFramesContext*)s->child_frames_ref->data;
705 int download = !!src->hw_frames_ctx;
706 mfxFrameSurface1 *surf = (mfxFrameSurface1*)(download ? src->data[3] : dst->data[3]);
711 dummy = av_frame_alloc();
713 return AVERROR(ENOMEM);
715 dummy->format = child_frames_ctx->format;
716 dummy->width = src->width;
717 dummy->height = src->height;
718 dummy->buf[0] = download ? src->buf[0] : dst->buf[0];
719 dummy->data[3] = surf->Data.MemId;
720 dummy->hw_frames_ctx = s->child_frames_ref;
722 ret = download ? av_hwframe_transfer_data(dst, dummy, 0) :
723 av_hwframe_transfer_data(dummy, src, 0);
725 dummy->buf[0] = NULL;
726 dummy->data[3] = NULL;
727 dummy->hw_frames_ctx = NULL;
729 av_frame_free(&dummy);
734 static int qsv_transfer_data_from(AVHWFramesContext *ctx, AVFrame *dst,
737 QSVFramesContext *s = ctx->internal->priv;
738 mfxFrameSurface1 out = {{ 0 }};
739 mfxFrameSurface1 *in = (mfxFrameSurface1*)src->data[3];
741 mfxSyncPoint sync = NULL;
744 if (!s->session_download) {
745 if (s->child_frames_ref)
746 return qsv_transfer_data_child(ctx, dst, src);
748 av_log(ctx, AV_LOG_ERROR, "Surface download not possible\n");
749 return AVERROR(ENOSYS);
753 out.Data.PitchLow = dst->linesize[0];
754 out.Data.Y = dst->data[0];
755 out.Data.U = dst->data[1];
756 out.Data.V = dst->data[2];
757 out.Data.A = dst->data[3];
760 err = MFXVideoVPP_RunFrameVPPAsync(s->session_download, in, &out, NULL, &sync);
761 if (err == MFX_WRN_DEVICE_BUSY)
763 } while (err == MFX_WRN_DEVICE_BUSY);
765 if (err < 0 || !sync) {
766 av_log(ctx, AV_LOG_ERROR, "Error downloading the surface\n");
767 return AVERROR_UNKNOWN;
771 err = MFXVideoCORE_SyncOperation(s->session_download, sync, 1000);
772 } while (err == MFX_WRN_IN_EXECUTION);
774 av_log(ctx, AV_LOG_ERROR, "Error synchronizing the operation: %d\n", err);
775 return AVERROR_UNKNOWN;
781 static int qsv_transfer_data_to(AVHWFramesContext *ctx, AVFrame *dst,
784 QSVFramesContext *s = ctx->internal->priv;
785 mfxFrameSurface1 in = {{ 0 }};
786 mfxFrameSurface1 *out = (mfxFrameSurface1*)dst->data[3];
788 mfxSyncPoint sync = NULL;
791 if (!s->session_upload) {
792 if (s->child_frames_ref)
793 return qsv_transfer_data_child(ctx, dst, src);
795 av_log(ctx, AV_LOG_ERROR, "Surface upload not possible\n");
796 return AVERROR(ENOSYS);
800 in.Data.PitchLow = src->linesize[0];
801 in.Data.Y = src->data[0];
802 in.Data.U = src->data[1];
803 in.Data.V = src->data[2];
804 in.Data.A = src->data[3];
807 err = MFXVideoVPP_RunFrameVPPAsync(s->session_upload, &in, out, NULL, &sync);
808 if (err == MFX_WRN_DEVICE_BUSY)
810 } while (err == MFX_WRN_DEVICE_BUSY);
812 if (err < 0 || !sync) {
813 av_log(ctx, AV_LOG_ERROR, "Error uploading the surface\n");
814 return AVERROR_UNKNOWN;
818 err = MFXVideoCORE_SyncOperation(s->session_upload, sync, 1000);
819 } while (err == MFX_WRN_IN_EXECUTION);
821 av_log(ctx, AV_LOG_ERROR, "Error synchronizing the operation\n");
822 return AVERROR_UNKNOWN;
828 static int qsv_frames_derive_to(AVHWFramesContext *dst_ctx,
829 AVHWFramesContext *src_ctx, int flags)
831 QSVFramesContext *s = dst_ctx->internal->priv;
832 AVQSVFramesContext *dst_hwctx = dst_ctx->hwctx;
835 switch (src_ctx->device_ctx->type) {
837 case AV_HWDEVICE_TYPE_VAAPI:
839 AVVAAPIFramesContext *src_hwctx = src_ctx->hwctx;
840 s->surfaces_internal = av_mallocz_array(src_hwctx->nb_surfaces,
841 sizeof(*s->surfaces_internal));
842 if (!s->surfaces_internal)
843 return AVERROR(ENOMEM);
844 for (i = 0; i < src_hwctx->nb_surfaces; i++) {
845 qsv_init_surface(dst_ctx, &s->surfaces_internal[i]);
846 s->surfaces_internal[i].Data.MemId = src_hwctx->surface_ids + i;
848 dst_hwctx->nb_surfaces = src_hwctx->nb_surfaces;
849 dst_hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;
854 case AV_HWDEVICE_TYPE_DXVA2:
856 AVDXVA2FramesContext *src_hwctx = src_ctx->hwctx;
857 s->surfaces_internal = av_mallocz_array(src_hwctx->nb_surfaces,
858 sizeof(*s->surfaces_internal));
859 if (!s->surfaces_internal)
860 return AVERROR(ENOMEM);
861 for (i = 0; i < src_hwctx->nb_surfaces; i++) {
862 qsv_init_surface(dst_ctx, &s->surfaces_internal[i]);
863 s->surfaces_internal[i].Data.MemId = (mfxMemId)src_hwctx->surfaces[i];
865 dst_hwctx->nb_surfaces = src_hwctx->nb_surfaces;
866 if (src_hwctx->surface_type == DXVA2_VideoProcessorRenderTarget)
867 dst_hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET;
869 dst_hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;
874 return AVERROR(ENOSYS);
877 dst_hwctx->surfaces = s->surfaces_internal;
882 static int qsv_map_to(AVHWFramesContext *dst_ctx,
883 AVFrame *dst, const AVFrame *src, int flags)
885 AVQSVFramesContext *hwctx = dst_ctx->hwctx;
888 for (i = 0; i < hwctx->nb_surfaces; i++) {
890 if (*(VASurfaceID*)hwctx->surfaces[i].Data.MemId ==
891 (VASurfaceID)(uintptr_t)src->data[3])
895 if ((IDirect3DSurface9*)hwctx->surfaces[i].Data.MemId ==
896 (IDirect3DSurface9*)(uintptr_t)src->data[3])
900 if (i >= hwctx->nb_surfaces) {
901 av_log(dst_ctx, AV_LOG_ERROR, "Trying to map from a surface which "
902 "is not in the mapped frames context.\n");
903 return AVERROR(EINVAL);
906 err = ff_hwframe_map_create(dst->hw_frames_ctx,
907 dst, src, NULL, NULL);
911 dst->width = src->width;
912 dst->height = src->height;
913 dst->data[3] = (uint8_t*)&hwctx->surfaces[i];
918 static int qsv_frames_get_constraints(AVHWDeviceContext *ctx,
919 const void *hwconfig,
920 AVHWFramesConstraints *constraints)
924 constraints->valid_sw_formats = av_malloc_array(FF_ARRAY_ELEMS(supported_pixel_formats) + 1,
925 sizeof(*constraints->valid_sw_formats));
926 if (!constraints->valid_sw_formats)
927 return AVERROR(ENOMEM);
929 for (i = 0; i < FF_ARRAY_ELEMS(supported_pixel_formats); i++)
930 constraints->valid_sw_formats[i] = supported_pixel_formats[i].pix_fmt;
931 constraints->valid_sw_formats[FF_ARRAY_ELEMS(supported_pixel_formats)] = AV_PIX_FMT_NONE;
933 constraints->valid_hw_formats = av_malloc_array(2, sizeof(*constraints->valid_hw_formats));
934 if (!constraints->valid_hw_formats)
935 return AVERROR(ENOMEM);
937 constraints->valid_hw_formats[0] = AV_PIX_FMT_QSV;
938 constraints->valid_hw_formats[1] = AV_PIX_FMT_NONE;
943 static void qsv_device_free(AVHWDeviceContext *ctx)
945 AVQSVDeviceContext *hwctx = ctx->hwctx;
946 QSVDevicePriv *priv = ctx->user_opaque;
949 MFXClose(hwctx->session);
951 av_buffer_unref(&priv->child_device_ctx);
955 static mfxIMPL choose_implementation(const char *device)
957 static const struct {
961 { "auto", MFX_IMPL_AUTO },
962 { "sw", MFX_IMPL_SOFTWARE },
963 { "hw", MFX_IMPL_HARDWARE },
964 { "auto_any", MFX_IMPL_AUTO_ANY },
965 { "hw_any", MFX_IMPL_HARDWARE_ANY },
966 { "hw2", MFX_IMPL_HARDWARE2 },
967 { "hw3", MFX_IMPL_HARDWARE3 },
968 { "hw4", MFX_IMPL_HARDWARE4 },
971 mfxIMPL impl = MFX_IMPL_AUTO_ANY;
975 for (i = 0; i < FF_ARRAY_ELEMS(impl_map); i++)
976 if (!strcmp(device, impl_map[i].name)) {
977 impl = impl_map[i].impl;
980 if (i == FF_ARRAY_ELEMS(impl_map))
981 impl = strtol(device, NULL, 0);
987 static int qsv_device_derive_from_child(AVHWDeviceContext *ctx,
988 mfxIMPL implementation,
989 AVHWDeviceContext *child_device_ctx,
992 AVQSVDeviceContext *hwctx = ctx->hwctx;
994 mfxVersion ver = { { 3, 1 } };
996 mfxHandleType handle_type;
1000 switch (child_device_ctx->type) {
1002 case AV_HWDEVICE_TYPE_VAAPI:
1004 AVVAAPIDeviceContext *child_device_hwctx = child_device_ctx->hwctx;
1005 handle_type = MFX_HANDLE_VA_DISPLAY;
1006 handle = (mfxHDL)child_device_hwctx->display;
1011 case AV_HWDEVICE_TYPE_DXVA2:
1013 AVDXVA2DeviceContext *child_device_hwctx = child_device_ctx->hwctx;
1014 handle_type = MFX_HANDLE_D3D9_DEVICE_MANAGER;
1015 handle = (mfxHDL)child_device_hwctx->devmgr;
1020 ret = AVERROR(ENOSYS);
1024 err = MFXInit(implementation, &ver, &hwctx->session);
1025 if (err != MFX_ERR_NONE) {
1026 av_log(ctx, AV_LOG_ERROR, "Error initializing an MFX session: "
1028 ret = AVERROR_UNKNOWN;
1032 err = MFXQueryVersion(hwctx->session, &ver);
1033 if (err != MFX_ERR_NONE) {
1034 av_log(ctx, AV_LOG_ERROR, "Error querying an MFX session: %d.\n", err);
1035 ret = AVERROR_UNKNOWN;
1039 av_log(ctx, AV_LOG_VERBOSE,
1040 "Initialize MFX session: API version is %d.%d, implementation version is %d.%d\n",
1041 MFX_VERSION_MAJOR, MFX_VERSION_MINOR, ver.Major, ver.Minor);
1043 MFXClose(hwctx->session);
1045 err = MFXInit(implementation, &ver, &hwctx->session);
1046 if (err != MFX_ERR_NONE) {
1047 av_log(ctx, AV_LOG_ERROR,
1048 "Error initializing an MFX session: %d.\n", err);
1049 ret = AVERROR_UNKNOWN;
1053 err = MFXVideoCORE_SetHandle(hwctx->session, handle_type, handle);
1054 if (err != MFX_ERR_NONE) {
1055 av_log(ctx, AV_LOG_ERROR, "Error setting child device handle: "
1057 ret = AVERROR_UNKNOWN;
1061 ret = MFXQueryVersion(hwctx->session,&ver);
1062 if (ret == MFX_ERR_NONE) {
1063 av_log(ctx, AV_LOG_VERBOSE, "MFX compile/runtime API: %d.%d/%d.%d\n",
1064 MFX_VERSION_MAJOR, MFX_VERSION_MINOR, ver.Major, ver.Minor);
1070 MFXClose(hwctx->session);
1074 static int qsv_device_derive(AVHWDeviceContext *ctx,
1075 AVHWDeviceContext *child_device_ctx, int flags)
1077 return qsv_device_derive_from_child(ctx, MFX_IMPL_HARDWARE_ANY,
1078 child_device_ctx, flags);
1081 static int qsv_device_create(AVHWDeviceContext *ctx, const char *device,
1082 AVDictionary *opts, int flags)
1084 QSVDevicePriv *priv;
1085 enum AVHWDeviceType child_device_type;
1086 AVHWDeviceContext *child_device;
1087 AVDictionaryEntry *e;
1092 priv = av_mallocz(sizeof(*priv));
1094 return AVERROR(ENOMEM);
1096 ctx->user_opaque = priv;
1097 ctx->free = qsv_device_free;
1099 e = av_dict_get(opts, "child_device", NULL, 0);
1102 child_device_type = AV_HWDEVICE_TYPE_VAAPI;
1103 else if (CONFIG_DXVA2)
1104 child_device_type = AV_HWDEVICE_TYPE_DXVA2;
1106 av_log(ctx, AV_LOG_ERROR, "No supported child device type is enabled\n");
1107 return AVERROR(ENOSYS);
1110 ret = av_hwdevice_ctx_create(&priv->child_device_ctx, child_device_type,
1111 e ? e->value : NULL, NULL, 0);
1115 child_device = (AVHWDeviceContext*)priv->child_device_ctx->data;
1117 impl = choose_implementation(device);
1119 return qsv_device_derive_from_child(ctx, impl, child_device, 0);
1122 const HWContextType ff_hwcontext_type_qsv = {
1123 .type = AV_HWDEVICE_TYPE_QSV,
1126 .device_hwctx_size = sizeof(AVQSVDeviceContext),
1127 .device_priv_size = sizeof(QSVDeviceContext),
1128 .frames_hwctx_size = sizeof(AVQSVFramesContext),
1129 .frames_priv_size = sizeof(QSVFramesContext),
1131 .device_create = qsv_device_create,
1132 .device_derive = qsv_device_derive,
1133 .device_init = qsv_device_init,
1134 .frames_get_constraints = qsv_frames_get_constraints,
1135 .frames_init = qsv_frames_init,
1136 .frames_uninit = qsv_frames_uninit,
1137 .frames_get_buffer = qsv_get_buffer,
1138 .transfer_get_formats = qsv_transfer_get_formats,
1139 .transfer_data_to = qsv_transfer_data_to,
1140 .transfer_data_from = qsv_transfer_data_from,
1141 .map_to = qsv_map_to,
1142 .map_from = qsv_map_from,
1143 .frames_derive_to = qsv_frames_derive_to,
1144 .frames_derive_from = qsv_frames_derive_from,
1146 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_QSV, AV_PIX_FMT_NONE },