Add GBRAP12 pixel format support
[ffmpeg.git] / libavutil / hwcontext_qsv.c
1 /*
2  * This file is part of Libav.
3  *
4  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18
19 #include <stdint.h>
20 #include <string.h>
21
22 #include <mfx/mfxvideo.h>
23
24 #include "config.h"
25
26 #if CONFIG_VAAPI
27 #include "hwcontext_vaapi.h"
28 #endif
29 #if CONFIG_DXVA2
30 #include "hwcontext_dxva2.h"
31 #endif
32
33 #include "buffer.h"
34 #include "common.h"
35 #include "hwcontext.h"
36 #include "hwcontext_internal.h"
37 #include "hwcontext_qsv.h"
38 #include "mem.h"
39 #include "pixfmt.h"
40 #include "pixdesc.h"
41 #include "time.h"
42
43 typedef struct QSVDevicePriv {
44     AVBufferRef *child_device_ctx;
45 } QSVDevicePriv;
46
47 typedef struct QSVDeviceContext {
48     mfxHDL              handle;
49     mfxHandleType       handle_type;
50     mfxVersion          ver;
51     mfxIMPL             impl;
52
53     enum AVHWDeviceType child_device_type;
54     enum AVPixelFormat  child_pix_fmt;
55 } QSVDeviceContext;
56
57 typedef struct QSVFramesContext {
58     mfxSession session_download;
59     mfxSession session_upload;
60
61     AVBufferRef *child_frames_ref;
62     mfxFrameSurface1 *surfaces_internal;
63     int             nb_surfaces_used;
64
65     // used in the frame allocator for non-opaque surfaces
66     mfxMemId *mem_ids;
67     // used in the opaque alloc request for opaque surfaces
68     mfxFrameSurface1 **surface_ptrs;
69
70     mfxExtOpaqueSurfaceAlloc opaque_alloc;
71     mfxExtBuffer *ext_buffers[1];
72 } QSVFramesContext;
73
74 static const struct {
75     mfxHandleType handle_type;
76     enum AVHWDeviceType device_type;
77     enum AVPixelFormat  pix_fmt;
78 } supported_handle_types[] = {
79 #if CONFIG_VAAPI
80     { MFX_HANDLE_VA_DISPLAY,          AV_HWDEVICE_TYPE_VAAPI, AV_PIX_FMT_VAAPI },
81 #endif
82 #if CONFIG_DXVA2
83     { MFX_HANDLE_D3D9_DEVICE_MANAGER, AV_HWDEVICE_TYPE_DXVA2, AV_PIX_FMT_DXVA2_VLD },
84 #endif
85     { 0 },
86 };
87
88 static const struct {
89     enum AVPixelFormat pix_fmt;
90     uint32_t           fourcc;
91 } supported_pixel_formats[] = {
92     { AV_PIX_FMT_NV12, MFX_FOURCC_NV12 },
93     { AV_PIX_FMT_P010, MFX_FOURCC_P010 },
94 };
95
96 static int qsv_device_init(AVHWDeviceContext *ctx)
97 {
98     AVQSVDeviceContext *hwctx = ctx->hwctx;
99     QSVDeviceContext       *s = ctx->internal->priv;
100
101     mfxStatus err;
102     int i;
103
104     for (i = 0; supported_handle_types[i].handle_type; i++) {
105         err = MFXVideoCORE_GetHandle(hwctx->session, supported_handle_types[i].handle_type,
106                                      &s->handle);
107         if (err == MFX_ERR_NONE) {
108             s->handle_type       = supported_handle_types[i].handle_type;
109             s->child_device_type = supported_handle_types[i].device_type;
110             s->child_pix_fmt     = supported_handle_types[i].pix_fmt;
111             break;
112         }
113     }
114     if (!s->handle) {
115         av_log(ctx, AV_LOG_VERBOSE, "No supported hw handle could be retrieved "
116                "from the session\n");
117     }
118
119     err = MFXQueryIMPL(hwctx->session, &s->impl);
120     if (err == MFX_ERR_NONE)
121         err = MFXQueryVersion(hwctx->session, &s->ver);
122     if (err != MFX_ERR_NONE) {
123         av_log(ctx, AV_LOG_ERROR, "Error querying the session attributes\n");
124         return AVERROR_UNKNOWN;
125     }
126
127     return 0;
128 }
129
130 static void qsv_frames_uninit(AVHWFramesContext *ctx)
131 {
132     QSVFramesContext *s = ctx->internal->priv;
133
134     if (s->session_download) {
135         MFXVideoVPP_Close(s->session_download);
136         MFXClose(s->session_download);
137     }
138     s->session_download = NULL;
139
140     if (s->session_upload) {
141         MFXVideoVPP_Close(s->session_upload);
142         MFXClose(s->session_upload);
143     }
144     s->session_upload = NULL;
145
146     av_freep(&s->mem_ids);
147     av_freep(&s->surface_ptrs);
148     av_freep(&s->surfaces_internal);
149     av_buffer_unref(&s->child_frames_ref);
150 }
151
152 static void qsv_pool_release_dummy(void *opaque, uint8_t *data)
153 {
154 }
155
156 static AVBufferRef *qsv_pool_alloc(void *opaque, int size)
157 {
158     AVHWFramesContext    *ctx = (AVHWFramesContext*)opaque;
159     QSVFramesContext       *s = ctx->internal->priv;
160     AVQSVFramesContext *hwctx = ctx->hwctx;
161
162     if (s->nb_surfaces_used < hwctx->nb_surfaces) {
163         s->nb_surfaces_used++;
164         return av_buffer_create((uint8_t*)(s->surfaces_internal + s->nb_surfaces_used - 1),
165                                 sizeof(*hwctx->surfaces), qsv_pool_release_dummy, NULL, 0);
166     }
167
168     return NULL;
169 }
170
171 static int qsv_init_child_ctx(AVHWFramesContext *ctx)
172 {
173     AVQSVFramesContext     *hwctx = ctx->hwctx;
174     QSVFramesContext           *s = ctx->internal->priv;
175     QSVDeviceContext *device_priv = ctx->device_ctx->internal->priv;
176
177     AVBufferRef *child_device_ref = NULL;
178     AVBufferRef *child_frames_ref = NULL;
179
180     AVHWDeviceContext *child_device_ctx;
181     AVHWFramesContext *child_frames_ctx;
182
183     int i, ret = 0;
184
185     if (!device_priv->handle) {
186         av_log(ctx, AV_LOG_ERROR,
187                "Cannot create a non-opaque internal surface pool without "
188                "a hardware handle\n");
189         return AVERROR(EINVAL);
190     }
191
192     child_device_ref = av_hwdevice_ctx_alloc(device_priv->child_device_type);
193     if (!child_device_ref)
194         return AVERROR(ENOMEM);
195     child_device_ctx   = (AVHWDeviceContext*)child_device_ref->data;
196
197 #if CONFIG_VAAPI
198     if (child_device_ctx->type == AV_HWDEVICE_TYPE_VAAPI) {
199         AVVAAPIDeviceContext *child_device_hwctx = child_device_ctx->hwctx;
200         child_device_hwctx->display = (VADisplay)device_priv->handle;
201     }
202 #endif
203 #if CONFIG_DXVA2
204     if (child_device_ctx->type == AV_HWDEVICE_TYPE_DXVA2) {
205         AVDXVA2DeviceContext *child_device_hwctx = child_device_ctx->hwctx;
206         child_device_hwctx->devmgr = (IDirect3DDeviceManager9*)device_priv->handle;
207     }
208 #endif
209
210     ret = av_hwdevice_ctx_init(child_device_ref);
211     if (ret < 0) {
212         av_log(ctx, AV_LOG_ERROR, "Error initializing a child device context\n");
213         goto fail;
214     }
215
216     child_frames_ref = av_hwframe_ctx_alloc(child_device_ref);
217     if (!child_frames_ref) {
218         ret = AVERROR(ENOMEM);
219         goto fail;
220     }
221     child_frames_ctx = (AVHWFramesContext*)child_frames_ref->data;
222
223     child_frames_ctx->format            = device_priv->child_pix_fmt;
224     child_frames_ctx->sw_format         = ctx->sw_format;
225     child_frames_ctx->initial_pool_size = ctx->initial_pool_size;
226     child_frames_ctx->width             = ctx->width;
227     child_frames_ctx->height            = ctx->height;
228
229 #if CONFIG_DXVA2
230     if (child_device_ctx->type == AV_HWDEVICE_TYPE_DXVA2) {
231         AVDXVA2FramesContext *child_frames_hwctx = child_frames_ctx->hwctx;
232         if (hwctx->frame_type & MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET)
233             child_frames_hwctx->surface_type = DXVA2_VideoProcessorRenderTarget;
234         else
235             child_frames_hwctx->surface_type = DXVA2_VideoDecoderRenderTarget;
236     }
237 #endif
238
239     ret = av_hwframe_ctx_init(child_frames_ref);
240     if (ret < 0) {
241         av_log(ctx, AV_LOG_ERROR, "Error initializing a child frames context\n");
242         goto fail;
243     }
244
245 #if CONFIG_VAAPI
246     if (child_device_ctx->type == AV_HWDEVICE_TYPE_VAAPI) {
247         AVVAAPIFramesContext *child_frames_hwctx = child_frames_ctx->hwctx;
248         for (i = 0; i < ctx->initial_pool_size; i++)
249             s->surfaces_internal[i].Data.MemId = child_frames_hwctx->surface_ids + i;
250         hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;
251     }
252 #endif
253 #if CONFIG_DXVA2
254     if (child_device_ctx->type == AV_HWDEVICE_TYPE_DXVA2) {
255         AVDXVA2FramesContext *child_frames_hwctx = child_frames_ctx->hwctx;
256         for (i = 0; i < ctx->initial_pool_size; i++)
257             s->surfaces_internal[i].Data.MemId = (mfxMemId)child_frames_hwctx->surfaces[i];
258         if (child_frames_hwctx->surface_type == DXVA2_VideoProcessorRenderTarget)
259             hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET;
260         else
261             hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;
262     }
263 #endif
264
265     s->child_frames_ref       = child_frames_ref;
266     child_frames_ref          = NULL;
267
268 fail:
269     av_buffer_unref(&child_device_ref);
270     av_buffer_unref(&child_frames_ref);
271     return ret;
272 }
273
274 static int qsv_init_pool(AVHWFramesContext *ctx, uint32_t fourcc)
275 {
276     QSVFramesContext              *s = ctx->internal->priv;
277     AVQSVFramesContext *frames_hwctx = ctx->hwctx;
278     const AVPixFmtDescriptor *desc;
279
280     int i, ret = 0;
281
282     desc = av_pix_fmt_desc_get(ctx->sw_format);
283     if (!desc)
284         return AVERROR_BUG;
285
286     if (ctx->initial_pool_size <= 0) {
287         av_log(ctx, AV_LOG_ERROR, "QSV requires a fixed frame pool size\n");
288         return AVERROR(EINVAL);
289     }
290
291     s->surfaces_internal = av_mallocz_array(ctx->initial_pool_size,
292                                             sizeof(*s->surfaces_internal));
293     if (!s->surfaces_internal)
294         return AVERROR(ENOMEM);
295
296     for (i = 0; i < ctx->initial_pool_size; i++) {
297         mfxFrameSurface1 *surf = &s->surfaces_internal[i];
298
299         surf->Info.BitDepthLuma   = desc->comp[0].depth;
300         surf->Info.BitDepthChroma = desc->comp[0].depth;
301         surf->Info.Shift          = desc->comp[0].depth > 8;
302
303         if (desc->log2_chroma_w && desc->log2_chroma_h)
304             surf->Info.ChromaFormat   = MFX_CHROMAFORMAT_YUV420;
305         else if (desc->log2_chroma_w)
306             surf->Info.ChromaFormat   = MFX_CHROMAFORMAT_YUV422;
307         else
308             surf->Info.ChromaFormat   = MFX_CHROMAFORMAT_YUV444;
309
310         surf->Info.FourCC         = fourcc;
311         surf->Info.Width          = ctx->width;
312         surf->Info.CropW          = ctx->width;
313         surf->Info.Height         = ctx->height;
314         surf->Info.CropH          = ctx->height;
315         surf->Info.FrameRateExtN  = 25;
316         surf->Info.FrameRateExtD  = 1;
317     }
318
319     if (!(frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME)) {
320         ret = qsv_init_child_ctx(ctx);
321         if (ret < 0)
322             return ret;
323     }
324
325     ctx->internal->pool_internal = av_buffer_pool_init2(sizeof(mfxFrameSurface1),
326                                                         ctx, qsv_pool_alloc, NULL);
327     if (!ctx->internal->pool_internal)
328         return AVERROR(ENOMEM);
329
330     frames_hwctx->surfaces    = s->surfaces_internal;
331     frames_hwctx->nb_surfaces = ctx->initial_pool_size;
332
333     return 0;
334 }
335
336 static mfxStatus frame_alloc(mfxHDL pthis, mfxFrameAllocRequest *req,
337                              mfxFrameAllocResponse *resp)
338 {
339     AVHWFramesContext    *ctx = pthis;
340     QSVFramesContext       *s = ctx->internal->priv;
341     AVQSVFramesContext *hwctx = ctx->hwctx;
342     mfxFrameInfo *i  = &req->Info;
343     mfxFrameInfo *i1 = &hwctx->surfaces[0].Info;
344
345     if (!(req->Type & MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET) ||
346         !(req->Type & (MFX_MEMTYPE_FROM_VPPIN | MFX_MEMTYPE_FROM_VPPOUT)) ||
347         !(req->Type & MFX_MEMTYPE_EXTERNAL_FRAME))
348         return MFX_ERR_UNSUPPORTED;
349     if (i->Width  != i1->Width || i->Height != i1->Height ||
350         i->FourCC != i1->FourCC || i->ChromaFormat != i1->ChromaFormat) {
351         av_log(ctx, AV_LOG_ERROR, "Mismatching surface properties in an "
352                "allocation request: %dx%d %d %d vs %dx%d %d %d\n",
353                i->Width,  i->Height,  i->FourCC,  i->ChromaFormat,
354                i1->Width, i1->Height, i1->FourCC, i1->ChromaFormat);
355         return MFX_ERR_UNSUPPORTED;
356     }
357
358     resp->mids           = s->mem_ids;
359     resp->NumFrameActual = hwctx->nb_surfaces;
360
361     return MFX_ERR_NONE;
362 }
363
364 static mfxStatus frame_free(mfxHDL pthis, mfxFrameAllocResponse *resp)
365 {
366     return MFX_ERR_NONE;
367 }
368
369 static mfxStatus frame_lock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
370 {
371     return MFX_ERR_UNSUPPORTED;
372 }
373
374 static mfxStatus frame_unlock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
375 {
376     return MFX_ERR_UNSUPPORTED;
377 }
378
379 static mfxStatus frame_get_hdl(mfxHDL pthis, mfxMemId mid, mfxHDL *hdl)
380 {
381     *hdl = mid;
382     return MFX_ERR_NONE;
383 }
384
385 static int qsv_init_internal_session(AVHWFramesContext *ctx,
386                                      mfxSession *session, int upload)
387 {
388     QSVFramesContext              *s = ctx->internal->priv;
389     AVQSVFramesContext *frames_hwctx = ctx->hwctx;
390     QSVDeviceContext   *device_priv  = ctx->device_ctx->internal->priv;
391     int opaque = !!(frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME);
392
393     mfxFrameAllocator frame_allocator = {
394         .pthis  = ctx,
395         .Alloc  = frame_alloc,
396         .Lock   = frame_lock,
397         .Unlock = frame_unlock,
398         .GetHDL = frame_get_hdl,
399         .Free   = frame_free,
400     };
401
402     mfxVideoParam par;
403     mfxStatus err;
404
405     err = MFXInit(device_priv->impl, &device_priv->ver, session);
406     if (err != MFX_ERR_NONE) {
407         av_log(ctx, AV_LOG_ERROR, "Error initializing an internal session\n");
408         return AVERROR_UNKNOWN;
409     }
410
411     if (device_priv->handle) {
412         err = MFXVideoCORE_SetHandle(*session, device_priv->handle_type,
413                                      device_priv->handle);
414         if (err != MFX_ERR_NONE)
415             return AVERROR_UNKNOWN;
416     }
417
418     if (!opaque) {
419         err = MFXVideoCORE_SetFrameAllocator(*session, &frame_allocator);
420         if (err != MFX_ERR_NONE)
421             return AVERROR_UNKNOWN;
422     }
423
424     memset(&par, 0, sizeof(par));
425
426     if (opaque) {
427         par.ExtParam    = s->ext_buffers;
428         par.NumExtParam = FF_ARRAY_ELEMS(s->ext_buffers);
429         par.IOPattern   = upload ? MFX_IOPATTERN_OUT_OPAQUE_MEMORY :
430                                    MFX_IOPATTERN_IN_OPAQUE_MEMORY;
431     } else {
432         par.IOPattern = upload ? MFX_IOPATTERN_OUT_VIDEO_MEMORY :
433                                  MFX_IOPATTERN_IN_VIDEO_MEMORY;
434     }
435
436     par.IOPattern |= upload ? MFX_IOPATTERN_IN_SYSTEM_MEMORY :
437                               MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
438     par.AsyncDepth = 1;
439
440     par.vpp.In = frames_hwctx->surfaces[0].Info;
441
442     /* Apparently VPP requires the frame rate to be set to some value, otherwise
443      * init will fail (probably for the framerate conversion filter). Since we
444      * are only doing data upload/download here, we just invent an arbitrary
445      * value */
446     par.vpp.In.FrameRateExtN = 25;
447     par.vpp.In.FrameRateExtD = 1;
448     par.vpp.Out = par.vpp.In;
449
450     err = MFXVideoVPP_Init(*session, &par);
451     if (err != MFX_ERR_NONE) {
452         av_log(ctx, AV_LOG_ERROR, "Error opening the internal VPP session\n");
453         return AVERROR_UNKNOWN;
454     }
455
456     return 0;
457 }
458
459 static int qsv_frames_init(AVHWFramesContext *ctx)
460 {
461     QSVFramesContext              *s = ctx->internal->priv;
462     AVQSVFramesContext *frames_hwctx = ctx->hwctx;
463
464     int opaque = !!(frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME);
465
466     uint32_t fourcc = 0;
467     int i, ret;
468
469     for (i = 0; i < FF_ARRAY_ELEMS(supported_pixel_formats); i++) {
470         if (supported_pixel_formats[i].pix_fmt == ctx->sw_format) {
471             fourcc = supported_pixel_formats[i].fourcc;
472             break;
473         }
474     }
475     if (!fourcc) {
476         av_log(ctx, AV_LOG_ERROR, "Unsupported pixel format\n");
477         return AVERROR(ENOSYS);
478     }
479
480     if (!ctx->pool) {
481         ret = qsv_init_pool(ctx, fourcc);
482         if (ret < 0) {
483             av_log(ctx, AV_LOG_ERROR, "Error creating an internal frame pool\n");
484             return ret;
485         }
486     }
487
488     if (opaque) {
489         s->surface_ptrs = av_mallocz_array(frames_hwctx->nb_surfaces,
490                                            sizeof(*s->surface_ptrs));
491         if (!s->surface_ptrs)
492             return AVERROR(ENOMEM);
493
494         for (i = 0; i < frames_hwctx->nb_surfaces; i++)
495             s->surface_ptrs[i] = frames_hwctx->surfaces + i;
496
497         s->opaque_alloc.In.Surfaces   = s->surface_ptrs;
498         s->opaque_alloc.In.NumSurface = frames_hwctx->nb_surfaces;
499         s->opaque_alloc.In.Type       = frames_hwctx->frame_type;
500
501         s->opaque_alloc.Out = s->opaque_alloc.In;
502
503         s->opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
504         s->opaque_alloc.Header.BufferSz = sizeof(s->opaque_alloc);
505
506         s->ext_buffers[0] = (mfxExtBuffer*)&s->opaque_alloc;
507     } else {
508         s->mem_ids = av_mallocz_array(frames_hwctx->nb_surfaces, sizeof(*s->mem_ids));
509         if (!s->mem_ids)
510             return AVERROR(ENOMEM);
511
512         for (i = 0; i < frames_hwctx->nb_surfaces; i++)
513             s->mem_ids[i] = frames_hwctx->surfaces[i].Data.MemId;
514     }
515
516     ret = qsv_init_internal_session(ctx, &s->session_download, 0);
517     if (ret < 0)
518         return ret;
519
520     ret = qsv_init_internal_session(ctx, &s->session_upload, 1);
521     if (ret < 0)
522         return ret;
523
524     return 0;
525 }
526
527 static int qsv_get_buffer(AVHWFramesContext *ctx, AVFrame *frame)
528 {
529     frame->buf[0] = av_buffer_pool_get(ctx->pool);
530     if (!frame->buf[0])
531         return AVERROR(ENOMEM);
532
533     frame->data[3] = frame->buf[0]->data;
534     frame->format  = AV_PIX_FMT_QSV;
535     frame->width   = ctx->width;
536     frame->height  = ctx->height;
537
538     return 0;
539 }
540
541 static int qsv_transfer_get_formats(AVHWFramesContext *ctx,
542                                     enum AVHWFrameTransferDirection dir,
543                                     enum AVPixelFormat **formats)
544 {
545     enum AVPixelFormat *fmts;
546
547     fmts = av_malloc_array(2, sizeof(*fmts));
548     if (!fmts)
549         return AVERROR(ENOMEM);
550
551     fmts[0] = ctx->sw_format;
552     fmts[1] = AV_PIX_FMT_NONE;
553
554     *formats = fmts;
555
556     return 0;
557 }
558
559 static int qsv_transfer_data_from(AVHWFramesContext *ctx, AVFrame *dst,
560                                   const AVFrame *src)
561 {
562     QSVFramesContext  *s = ctx->internal->priv;
563     mfxFrameSurface1 out = {{ 0 }};
564     mfxFrameSurface1 *in = (mfxFrameSurface1*)src->data[3];
565
566     mfxSyncPoint sync = NULL;
567     mfxStatus err;
568
569     out.Info = in->Info;
570     out.Data.PitchLow = dst->linesize[0];
571     out.Data.Y        = dst->data[0];
572     out.Data.U        = dst->data[1];
573     out.Data.V        = dst->data[2];
574     out.Data.A        = dst->data[3];
575
576     do {
577         err = MFXVideoVPP_RunFrameVPPAsync(s->session_download, in, &out, NULL, &sync);
578         if (err == MFX_WRN_DEVICE_BUSY)
579             av_usleep(1);
580     } while (err == MFX_WRN_DEVICE_BUSY);
581
582     if (err < 0 || !sync) {
583         av_log(ctx, AV_LOG_ERROR, "Error downloading the surface\n");
584         return AVERROR_UNKNOWN;
585     }
586
587     do {
588         err = MFXVideoCORE_SyncOperation(s->session_download, sync, 1000);
589     } while (err == MFX_WRN_IN_EXECUTION);
590     if (err < 0) {
591         av_log(ctx, AV_LOG_ERROR, "Error synchronizing the operation: %d\n", err);
592         return AVERROR_UNKNOWN;
593     }
594
595     return 0;
596 }
597
598 static int qsv_transfer_data_to(AVHWFramesContext *ctx, AVFrame *dst,
599                                 const AVFrame *src)
600 {
601     QSVFramesContext   *s = ctx->internal->priv;
602     mfxFrameSurface1   in = {{ 0 }};
603     mfxFrameSurface1 *out = (mfxFrameSurface1*)dst->data[3];
604
605     mfxSyncPoint sync = NULL;
606     mfxStatus err;
607
608     in.Info = out->Info;
609     in.Data.PitchLow = src->linesize[0];
610     in.Data.Y        = src->data[0];
611     in.Data.U        = src->data[1];
612     in.Data.V        = src->data[2];
613     in.Data.A        = src->data[3];
614
615     do {
616         err = MFXVideoVPP_RunFrameVPPAsync(s->session_upload, &in, out, NULL, &sync);
617         if (err == MFX_WRN_DEVICE_BUSY)
618             av_usleep(1);
619     } while (err == MFX_WRN_DEVICE_BUSY);
620
621     if (err < 0 || !sync) {
622         av_log(ctx, AV_LOG_ERROR, "Error uploading the surface\n");
623         return AVERROR_UNKNOWN;
624     }
625
626     do {
627         err = MFXVideoCORE_SyncOperation(s->session_upload, sync, 1000);
628     } while (err == MFX_WRN_IN_EXECUTION);
629     if (err < 0) {
630         av_log(ctx, AV_LOG_ERROR, "Error synchronizing the operation\n");
631         return AVERROR_UNKNOWN;
632     }
633
634     return 0;
635 }
636
637 static int qsv_frames_get_constraints(AVHWDeviceContext *ctx,
638                                       const void *hwconfig,
639                                       AVHWFramesConstraints *constraints)
640 {
641     int i;
642
643     constraints->valid_sw_formats = av_malloc_array(FF_ARRAY_ELEMS(supported_pixel_formats) + 1,
644                                                     sizeof(*constraints->valid_sw_formats));
645     if (!constraints->valid_sw_formats)
646         return AVERROR(ENOMEM);
647
648     for (i = 0; i < FF_ARRAY_ELEMS(supported_pixel_formats); i++)
649         constraints->valid_sw_formats[i] = supported_pixel_formats[i].pix_fmt;
650     constraints->valid_sw_formats[FF_ARRAY_ELEMS(supported_pixel_formats)] = AV_PIX_FMT_NONE;
651
652     constraints->valid_hw_formats = av_malloc_array(2, sizeof(*constraints->valid_hw_formats));
653     if (!constraints->valid_hw_formats)
654         return AVERROR(ENOMEM);
655
656     constraints->valid_hw_formats[0] = AV_PIX_FMT_QSV;
657     constraints->valid_hw_formats[1] = AV_PIX_FMT_NONE;
658
659     return 0;
660 }
661
662 static void qsv_device_free(AVHWDeviceContext *ctx)
663 {
664     AVQSVDeviceContext *hwctx = ctx->hwctx;
665     QSVDevicePriv       *priv = ctx->user_opaque;
666
667     if (hwctx->session)
668         MFXClose(hwctx->session);
669
670     av_buffer_unref(&priv->child_device_ctx);
671     av_freep(&priv);
672 }
673
674 static mfxIMPL choose_implementation(const char *device)
675 {
676     static const struct {
677         const char *name;
678         mfxIMPL     impl;
679     } impl_map[] = {
680         { "auto",     MFX_IMPL_AUTO         },
681         { "sw",       MFX_IMPL_SOFTWARE     },
682         { "hw",       MFX_IMPL_HARDWARE     },
683         { "auto_any", MFX_IMPL_AUTO_ANY     },
684         { "hw_any",   MFX_IMPL_HARDWARE_ANY },
685         { "hw2",      MFX_IMPL_HARDWARE2    },
686         { "hw3",      MFX_IMPL_HARDWARE3    },
687         { "hw4",      MFX_IMPL_HARDWARE4    },
688     };
689
690     mfxIMPL impl = MFX_IMPL_AUTO_ANY;
691     int i;
692
693     if (device) {
694         for (i = 0; i < FF_ARRAY_ELEMS(impl_map); i++)
695             if (!strcmp(device, impl_map[i].name)) {
696                 impl = impl_map[i].impl;
697                 break;
698             }
699         if (i == FF_ARRAY_ELEMS(impl_map))
700             impl = strtol(device, NULL, 0);
701     }
702
703     return impl;
704 }
705
706 static int qsv_device_create(AVHWDeviceContext *ctx, const char *device,
707                              AVDictionary *opts, int flags)
708 {
709     AVQSVDeviceContext *hwctx = ctx->hwctx;
710     QSVDevicePriv *priv;
711     enum AVHWDeviceType child_device_type;
712     AVDictionaryEntry *e;
713
714     mfxVersion    ver = { { 3, 1 } };
715     mfxIMPL       impl;
716     mfxHDL        handle;
717     mfxHandleType handle_type;
718     mfxStatus     err;
719     int ret;
720
721     priv = av_mallocz(sizeof(*priv));
722     if (!priv)
723         return AVERROR(ENOMEM);
724
725     ctx->user_opaque = priv;
726     ctx->free        = qsv_device_free;
727
728     e = av_dict_get(opts, "child_device", NULL, 0);
729
730     if (CONFIG_VAAPI)
731         child_device_type = AV_HWDEVICE_TYPE_VAAPI;
732     else if (CONFIG_DXVA2)
733         child_device_type = AV_HWDEVICE_TYPE_DXVA2;
734     else {
735         av_log(ctx, AV_LOG_ERROR, "No supported child device type is enabled\n");
736         return AVERROR(ENOSYS);
737     }
738
739     ret = av_hwdevice_ctx_create(&priv->child_device_ctx, child_device_type,
740                                  e ? e->value : NULL, NULL, 0);
741     if (ret < 0)
742         return ret;
743
744     {
745         AVHWDeviceContext      *child_device_ctx = (AVHWDeviceContext*)priv->child_device_ctx->data;
746 #if CONFIG_VAAPI
747         AVVAAPIDeviceContext *child_device_hwctx = child_device_ctx->hwctx;
748         handle_type = MFX_HANDLE_VA_DISPLAY;
749         handle = (mfxHDL)child_device_hwctx->display;
750 #elif CONFIG_DXVA2
751         AVDXVA2DeviceContext *child_device_hwctx = child_device_ctx->hwctx;
752         handle_type = MFX_HANDLE_D3D9_DEVICE_MANAGER;
753         handle = (mfxHDL)child_device_hwctx->devmgr;
754 #endif
755     }
756
757     impl = choose_implementation(device);
758
759     err = MFXInit(impl, &ver, &hwctx->session);
760     if (err != MFX_ERR_NONE) {
761         av_log(ctx, AV_LOG_ERROR, "Error initializing an MFX session\n");
762         return AVERROR_UNKNOWN;
763     }
764
765     err = MFXVideoCORE_SetHandle(hwctx->session, handle_type, handle);
766     if (err != MFX_ERR_NONE)
767         return AVERROR_UNKNOWN;
768
769     return 0;
770 }
771
772 const HWContextType ff_hwcontext_type_qsv = {
773     .type                   = AV_HWDEVICE_TYPE_QSV,
774     .name                   = "QSV",
775
776     .device_hwctx_size      = sizeof(AVQSVDeviceContext),
777     .device_priv_size       = sizeof(QSVDeviceContext),
778     .frames_hwctx_size      = sizeof(AVQSVFramesContext),
779     .frames_priv_size       = sizeof(QSVFramesContext),
780
781     .device_create          = qsv_device_create,
782     .device_init            = qsv_device_init,
783     .frames_get_constraints = qsv_frames_get_constraints,
784     .frames_init            = qsv_frames_init,
785     .frames_uninit          = qsv_frames_uninit,
786     .frames_get_buffer      = qsv_get_buffer,
787     .transfer_get_formats   = qsv_transfer_get_formats,
788     .transfer_data_to       = qsv_transfer_data_to,
789     .transfer_data_from     = qsv_transfer_data_from,
790
791     .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_QSV, AV_PIX_FMT_NONE },
792 };