git.sesse.net Git - ffmpeg/blob - libavutil/hwcontext_qsv.c

   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  */
  18
  19 #include <stdint.h>
  20 #include <string.h>
  21
  22 #include <mfx/mfxvideo.h>
  23
  24 #include "config.h"
  25
  26 #if HAVE_PTHREADS
  27 #include <pthread.h>
  28 #endif
  29
  30 #if CONFIG_VAAPI
  31 #include "hwcontext_vaapi.h"
  32 #endif
  33 #if CONFIG_DXVA2
  34 #include "hwcontext_dxva2.h"
  35 #endif
  36
  37 #include "buffer.h"
  38 #include "common.h"
  39 #include "hwcontext.h"
  40 #include "hwcontext_internal.h"
  41 #include "hwcontext_qsv.h"
  42 #include "mem.h"
  43 #include "pixfmt.h"
  44 #include "pixdesc.h"
  45 #include "time.h"
  46
  47 typedef struct QSVDevicePriv {
  48     AVBufferRef *child_device_ctx;
  49 } QSVDevicePriv;
  50
  51 typedef struct QSVDeviceContext {
  52     mfxHDL              handle;
  53     mfxHandleType       handle_type;
  54     mfxVersion          ver;
  55     mfxIMPL             impl;
  56
  57     enum AVHWDeviceType child_device_type;
  58     enum AVPixelFormat  child_pix_fmt;
  59 } QSVDeviceContext;
  60
  61 typedef struct QSVFramesContext {
  62     mfxSession session_download;
  63     int session_download_init;
  64     mfxSession session_upload;
  65     int session_upload_init;
  66 #if HAVE_PTHREADS
  67     pthread_mutex_t session_lock;
  68     pthread_cond_t session_cond;
  69 #endif
  70
  71     AVBufferRef *child_frames_ref;
  72     mfxFrameSurface1 *surfaces_internal;
  73     int             nb_surfaces_used;
  74
  75     // used in the frame allocator for non-opaque surfaces
  76     mfxMemId *mem_ids;
  77     // used in the opaque alloc request for opaque surfaces
  78     mfxFrameSurface1 **surface_ptrs;
  79
  80     mfxExtOpaqueSurfaceAlloc opaque_alloc;
  81     mfxExtBuffer *ext_buffers[1];
  82 } QSVFramesContext;
  83
  84 static const struct {
  85     mfxHandleType handle_type;
  86     enum AVHWDeviceType device_type;
  87     enum AVPixelFormat  pix_fmt;
  88 } supported_handle_types[] = {
  89 #if CONFIG_VAAPI
  90     { MFX_HANDLE_VA_DISPLAY,          AV_HWDEVICE_TYPE_VAAPI, AV_PIX_FMT_VAAPI },
  91 #endif
  92 #if CONFIG_DXVA2
  93     { MFX_HANDLE_D3D9_DEVICE_MANAGER, AV_HWDEVICE_TYPE_DXVA2, AV_PIX_FMT_DXVA2_VLD },
  94 #endif
  95     { 0 },
  96 };
  97
  98 static const struct {
  99     enum AVPixelFormat pix_fmt;
 100     uint32_t           fourcc;
 101 } supported_pixel_formats[] = {
 102     { AV_PIX_FMT_NV12, MFX_FOURCC_NV12 },
 103     { AV_PIX_FMT_P010, MFX_FOURCC_P010 },
 104     { AV_PIX_FMT_PAL8, MFX_FOURCC_P8   },
 105 };
 106
 107 static uint32_t qsv_fourcc_from_pix_fmt(enum AVPixelFormat pix_fmt)
 108 {
 109     int i;
 110     for (i = 0; i < FF_ARRAY_ELEMS(supported_pixel_formats); i++) {
 111         if (supported_pixel_formats[i].pix_fmt == pix_fmt)
 112             return supported_pixel_formats[i].fourcc;
 113     }
 114     return 0;
 115 }
 116
 117 static int qsv_device_init(AVHWDeviceContext *ctx)
 118 {
 119     AVQSVDeviceContext *hwctx = ctx->hwctx;
 120     QSVDeviceContext       *s = ctx->internal->priv;
 121
 122     mfxStatus err;
 123     int i;
 124
 125     for (i = 0; supported_handle_types[i].handle_type; i++) {
 126         err = MFXVideoCORE_GetHandle(hwctx->session, supported_handle_types[i].handle_type,
 127                                      &s->handle);
 128         if (err == MFX_ERR_NONE) {
 129             s->handle_type       = supported_handle_types[i].handle_type;
 130             s->child_device_type = supported_handle_types[i].device_type;
 131             s->child_pix_fmt     = supported_handle_types[i].pix_fmt;
 132             break;
 133         }
 134     }
 135     if (!s->handle) {
 136         av_log(ctx, AV_LOG_VERBOSE, "No supported hw handle could be retrieved "
 137                "from the session\n");
 138     }
 139
 140     err = MFXQueryIMPL(hwctx->session, &s->impl);
 141     if (err == MFX_ERR_NONE)
 142         err = MFXQueryVersion(hwctx->session, &s->ver);
 143     if (err != MFX_ERR_NONE) {
 144         av_log(ctx, AV_LOG_ERROR, "Error querying the session attributes\n");
 145         return AVERROR_UNKNOWN;
 146     }
 147
 148     return 0;
 149 }
 150
 151 static void qsv_frames_uninit(AVHWFramesContext *ctx)
 152 {
 153     QSVFramesContext *s = ctx->internal->priv;
 154
 155     if (s->session_download) {
 156         MFXVideoVPP_Close(s->session_download);
 157         MFXClose(s->session_download);
 158     }
 159     s->session_download = NULL;
 160     s->session_download_init = 0;
 161
 162     if (s->session_upload) {
 163         MFXVideoVPP_Close(s->session_upload);
 164         MFXClose(s->session_upload);
 165     }
 166     s->session_upload = NULL;
 167     s->session_upload_init = 0;
 168
 169 #if HAVE_PTHREADS
 170     pthread_mutex_destroy(&s->session_lock);
 171     pthread_cond_destroy(&s->session_cond);
 172 #endif
 173
 174     av_freep(&s->mem_ids);
 175     av_freep(&s->surface_ptrs);
 176     av_freep(&s->surfaces_internal);
 177     av_buffer_unref(&s->child_frames_ref);
 178 }
 179
 180 static void qsv_pool_release_dummy(void *opaque, uint8_t *data)
 181 {
 182 }
 183
 184 static AVBufferRef *qsv_pool_alloc(void *opaque, int size)
 185 {
 186     AVHWFramesContext    *ctx = (AVHWFramesContext*)opaque;
 187     QSVFramesContext       *s = ctx->internal->priv;
 188     AVQSVFramesContext *hwctx = ctx->hwctx;
 189
 190     if (s->nb_surfaces_used < hwctx->nb_surfaces) {
 191         s->nb_surfaces_used++;
 192         return av_buffer_create((uint8_t*)(s->surfaces_internal + s->nb_surfaces_used - 1),
 193                                 sizeof(*hwctx->surfaces), qsv_pool_release_dummy, NULL, 0);
 194     }
 195
 196     return NULL;
 197 }
 198
 199 static int qsv_init_child_ctx(AVHWFramesContext *ctx)
 200 {
 201     AVQSVFramesContext     *hwctx = ctx->hwctx;
 202     QSVFramesContext           *s = ctx->internal->priv;
 203     QSVDeviceContext *device_priv = ctx->device_ctx->internal->priv;
 204
 205     AVBufferRef *child_device_ref = NULL;
 206     AVBufferRef *child_frames_ref = NULL;
 207
 208     AVHWDeviceContext *child_device_ctx;
 209     AVHWFramesContext *child_frames_ctx;
 210
 211     int i, ret = 0;
 212
 213     if (!device_priv->handle) {
 214         av_log(ctx, AV_LOG_ERROR,
 215                "Cannot create a non-opaque internal surface pool without "
 216                "a hardware handle\n");
 217         return AVERROR(EINVAL);
 218     }
 219
 220     child_device_ref = av_hwdevice_ctx_alloc(device_priv->child_device_type);
 221     if (!child_device_ref)
 222         return AVERROR(ENOMEM);
 223     child_device_ctx   = (AVHWDeviceContext*)child_device_ref->data;
 224
 225 #if CONFIG_VAAPI
 226     if (child_device_ctx->type == AV_HWDEVICE_TYPE_VAAPI) {
 227         AVVAAPIDeviceContext *child_device_hwctx = child_device_ctx->hwctx;
 228         child_device_hwctx->display = (VADisplay)device_priv->handle;
 229     }
 230 #endif
 231 #if CONFIG_DXVA2
 232     if (child_device_ctx->type == AV_HWDEVICE_TYPE_DXVA2) {
 233         AVDXVA2DeviceContext *child_device_hwctx = child_device_ctx->hwctx;
 234         child_device_hwctx->devmgr = (IDirect3DDeviceManager9*)device_priv->handle;
 235     }
 236 #endif
 237
 238     ret = av_hwdevice_ctx_init(child_device_ref);
 239     if (ret < 0) {
 240         av_log(ctx, AV_LOG_ERROR, "Error initializing a child device context\n");
 241         goto fail;
 242     }
 243
 244     child_frames_ref = av_hwframe_ctx_alloc(child_device_ref);
 245     if (!child_frames_ref) {
 246         ret = AVERROR(ENOMEM);
 247         goto fail;
 248     }
 249     child_frames_ctx = (AVHWFramesContext*)child_frames_ref->data;
 250
 251     child_frames_ctx->format            = device_priv->child_pix_fmt;
 252     child_frames_ctx->sw_format         = ctx->sw_format;
 253     child_frames_ctx->initial_pool_size = ctx->initial_pool_size;
 254     child_frames_ctx->width             = FFALIGN(ctx->width, 16);
 255     child_frames_ctx->height            = FFALIGN(ctx->height, 16);
 256
 257 #if CONFIG_DXVA2
 258     if (child_device_ctx->type == AV_HWDEVICE_TYPE_DXVA2) {
 259         AVDXVA2FramesContext *child_frames_hwctx = child_frames_ctx->hwctx;
 260         if (hwctx->frame_type & MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET)
 261             child_frames_hwctx->surface_type = DXVA2_VideoProcessorRenderTarget;
 262         else
 263             child_frames_hwctx->surface_type = DXVA2_VideoDecoderRenderTarget;
 264     }
 265 #endif
 266
 267     ret = av_hwframe_ctx_init(child_frames_ref);
 268     if (ret < 0) {
 269         av_log(ctx, AV_LOG_ERROR, "Error initializing a child frames context\n");
 270         goto fail;
 271     }
 272
 273 #if CONFIG_VAAPI
 274     if (child_device_ctx->type == AV_HWDEVICE_TYPE_VAAPI) {
 275         AVVAAPIFramesContext *child_frames_hwctx = child_frames_ctx->hwctx;
 276         for (i = 0; i < ctx->initial_pool_size; i++)
 277             s->surfaces_internal[i].Data.MemId = child_frames_hwctx->surface_ids + i;
 278         hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;
 279     }
 280 #endif
 281 #if CONFIG_DXVA2
 282     if (child_device_ctx->type == AV_HWDEVICE_TYPE_DXVA2) {
 283         AVDXVA2FramesContext *child_frames_hwctx = child_frames_ctx->hwctx;
 284         for (i = 0; i < ctx->initial_pool_size; i++)
 285             s->surfaces_internal[i].Data.MemId = (mfxMemId)child_frames_hwctx->surfaces[i];
 286         if (child_frames_hwctx->surface_type == DXVA2_VideoProcessorRenderTarget)
 287             hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET;
 288         else
 289             hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;
 290     }
 291 #endif
 292
 293     s->child_frames_ref       = child_frames_ref;
 294     child_frames_ref          = NULL;
 295
 296 fail:
 297     av_buffer_unref(&child_device_ref);
 298     av_buffer_unref(&child_frames_ref);
 299     return ret;
 300 }
 301
 302 static int qsv_init_surface(AVHWFramesContext *ctx, mfxFrameSurface1 *surf)
 303 {
 304     const AVPixFmtDescriptor *desc;
 305     uint32_t fourcc;
 306
 307     desc = av_pix_fmt_desc_get(ctx->sw_format);
 308     if (!desc)
 309         return AVERROR(EINVAL);
 310
 311     fourcc = qsv_fourcc_from_pix_fmt(ctx->sw_format);
 312     if (!fourcc)
 313         return AVERROR(EINVAL);
 314
 315     surf->Info.BitDepthLuma   = desc->comp[0].depth;
 316     surf->Info.BitDepthChroma = desc->comp[0].depth;
 317     surf->Info.Shift          = desc->comp[0].depth > 8;
 318
 319     if (desc->log2_chroma_w && desc->log2_chroma_h)
 320         surf->Info.ChromaFormat   = MFX_CHROMAFORMAT_YUV420;
 321     else if (desc->log2_chroma_w)
 322         surf->Info.ChromaFormat   = MFX_CHROMAFORMAT_YUV422;
 323     else
 324         surf->Info.ChromaFormat   = MFX_CHROMAFORMAT_YUV444;
 325
 326     surf->Info.FourCC         = fourcc;
 327     surf->Info.Width          = FFALIGN(ctx->width, 16);
 328     surf->Info.CropW          = ctx->width;
 329     surf->Info.Height         = FFALIGN(ctx->height, 16);
 330     surf->Info.CropH          = ctx->height;
 331     surf->Info.FrameRateExtN  = 25;
 332     surf->Info.FrameRateExtD  = 1;
 333     surf->Info.PicStruct      = MFX_PICSTRUCT_PROGRESSIVE;
 334
 335     return 0;
 336 }
 337
 338 static int qsv_init_pool(AVHWFramesContext *ctx, uint32_t fourcc)
 339 {
 340     QSVFramesContext              *s = ctx->internal->priv;
 341     AVQSVFramesContext *frames_hwctx = ctx->hwctx;
 342
 343     int i, ret = 0;
 344
 345     if (ctx->initial_pool_size <= 0) {
 346         av_log(ctx, AV_LOG_ERROR, "QSV requires a fixed frame pool size\n");
 347         return AVERROR(EINVAL);
 348     }
 349
 350     s->surfaces_internal = av_mallocz_array(ctx->initial_pool_size,
 351                                             sizeof(*s->surfaces_internal));
 352     if (!s->surfaces_internal)
 353         return AVERROR(ENOMEM);
 354
 355     for (i = 0; i < ctx->initial_pool_size; i++) {
 356         ret = qsv_init_surface(ctx, &s->surfaces_internal[i]);
 357         if (ret < 0)
 358             return ret;
 359     }
 360
 361     if (!(frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME)) {
 362         ret = qsv_init_child_ctx(ctx);
 363         if (ret < 0)
 364             return ret;
 365     }
 366
 367     ctx->internal->pool_internal = av_buffer_pool_init2(sizeof(mfxFrameSurface1),
 368                                                         ctx, qsv_pool_alloc, NULL);
 369     if (!ctx->internal->pool_internal)
 370         return AVERROR(ENOMEM);
 371
 372     frames_hwctx->surfaces    = s->surfaces_internal;
 373     frames_hwctx->nb_surfaces = ctx->initial_pool_size;
 374
 375     return 0;
 376 }
 377
 378 static mfxStatus frame_alloc(mfxHDL pthis, mfxFrameAllocRequest *req,
 379                              mfxFrameAllocResponse *resp)
 380 {
 381     AVHWFramesContext    *ctx = pthis;
 382     QSVFramesContext       *s = ctx->internal->priv;
 383     AVQSVFramesContext *hwctx = ctx->hwctx;
 384     mfxFrameInfo *i  = &req->Info;
 385     mfxFrameInfo *i1 = &hwctx->surfaces[0].Info;
 386
 387     if (!(req->Type & MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET) ||
 388         !(req->Type & (MFX_MEMTYPE_FROM_VPPIN | MFX_MEMTYPE_FROM_VPPOUT)) ||
 389         !(req->Type & MFX_MEMTYPE_EXTERNAL_FRAME))
 390         return MFX_ERR_UNSUPPORTED;
 391     if (i->Width  != i1->Width || i->Height != i1->Height ||
 392         i->FourCC != i1->FourCC || i->ChromaFormat != i1->ChromaFormat) {
 393         av_log(ctx, AV_LOG_ERROR, "Mismatching surface properties in an "
 394                "allocation request: %dx%d %d %d vs %dx%d %d %d\n",
 395                i->Width,  i->Height,  i->FourCC,  i->ChromaFormat,
 396                i1->Width, i1->Height, i1->FourCC, i1->ChromaFormat);
 397         return MFX_ERR_UNSUPPORTED;
 398     }
 399
 400     resp->mids           = s->mem_ids;
 401     resp->NumFrameActual = hwctx->nb_surfaces;
 402
 403     return MFX_ERR_NONE;
 404 }
 405
 406 static mfxStatus frame_free(mfxHDL pthis, mfxFrameAllocResponse *resp)
 407 {
 408     return MFX_ERR_NONE;
 409 }
 410
 411 static mfxStatus frame_lock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
 412 {
 413     return MFX_ERR_UNSUPPORTED;
 414 }
 415
 416 static mfxStatus frame_unlock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
 417 {
 418     return MFX_ERR_UNSUPPORTED;
 419 }
 420
 421 static mfxStatus frame_get_hdl(mfxHDL pthis, mfxMemId mid, mfxHDL *hdl)
 422 {
 423     *hdl = mid;
 424     return MFX_ERR_NONE;
 425 }
 426
 427 static int qsv_init_internal_session(AVHWFramesContext *ctx,
 428                                      mfxSession *session, int upload)
 429 {
 430     QSVFramesContext              *s = ctx->internal->priv;
 431     AVQSVFramesContext *frames_hwctx = ctx->hwctx;
 432     QSVDeviceContext   *device_priv  = ctx->device_ctx->internal->priv;
 433     int opaque = !!(frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME);
 434
 435     mfxFrameAllocator frame_allocator = {
 436         .pthis  = ctx,
 437         .Alloc  = frame_alloc,
 438         .Lock   = frame_lock,
 439         .Unlock = frame_unlock,
 440         .GetHDL = frame_get_hdl,
 441         .Free   = frame_free,
 442     };
 443
 444     mfxVideoParam par;
 445     mfxStatus err;
 446
 447     err = MFXInit(device_priv->impl, &device_priv->ver, session);
 448     if (err != MFX_ERR_NONE) {
 449         av_log(ctx, AV_LOG_ERROR, "Error initializing an internal session\n");
 450         return AVERROR_UNKNOWN;
 451     }
 452
 453     if (device_priv->handle) {
 454         err = MFXVideoCORE_SetHandle(*session, device_priv->handle_type,
 455                                      device_priv->handle);
 456         if (err != MFX_ERR_NONE)
 457             return AVERROR_UNKNOWN;
 458     }
 459
 460     if (!opaque) {
 461         err = MFXVideoCORE_SetFrameAllocator(*session, &frame_allocator);
 462         if (err != MFX_ERR_NONE)
 463             return AVERROR_UNKNOWN;
 464     }
 465
 466     memset(&par, 0, sizeof(par));
 467
 468     if (opaque) {
 469         par.ExtParam    = s->ext_buffers;
 470         par.NumExtParam = FF_ARRAY_ELEMS(s->ext_buffers);
 471         par.IOPattern   = upload ? MFX_IOPATTERN_OUT_OPAQUE_MEMORY :
 472                                    MFX_IOPATTERN_IN_OPAQUE_MEMORY;
 473     } else {
 474         par.IOPattern = upload ? MFX_IOPATTERN_OUT_VIDEO_MEMORY :
 475                                  MFX_IOPATTERN_IN_VIDEO_MEMORY;
 476     }
 477
 478     par.IOPattern |= upload ? MFX_IOPATTERN_IN_SYSTEM_MEMORY :
 479                               MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
 480     par.AsyncDepth = 1;
 481
 482     par.vpp.In = frames_hwctx->surfaces[0].Info;
 483
 484     /* Apparently VPP requires the frame rate to be set to some value, otherwise
 485      * init will fail (probably for the framerate conversion filter). Since we
 486      * are only doing data upload/download here, we just invent an arbitrary
 487      * value */
 488     par.vpp.In.FrameRateExtN = 25;
 489     par.vpp.In.FrameRateExtD = 1;
 490     par.vpp.Out = par.vpp.In;
 491
 492     err = MFXVideoVPP_Init(*session, &par);
 493     if (err != MFX_ERR_NONE) {
 494         av_log(ctx, AV_LOG_VERBOSE, "Error opening the internal VPP session."
 495                "Surface upload/download will not be possible\n");
 496         MFXClose(*session);
 497         *session = NULL;
 498     }
 499
 500     return 0;
 501 }
 502
 503 static int qsv_frames_init(AVHWFramesContext *ctx)
 504 {
 505     QSVFramesContext              *s = ctx->internal->priv;
 506     AVQSVFramesContext *frames_hwctx = ctx->hwctx;
 507
 508     int opaque = !!(frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME);
 509
 510     uint32_t fourcc;
 511     int i, ret;
 512
 513     fourcc = qsv_fourcc_from_pix_fmt(ctx->sw_format);
 514     if (!fourcc) {
 515         av_log(ctx, AV_LOG_ERROR, "Unsupported pixel format\n");
 516         return AVERROR(ENOSYS);
 517     }
 518
 519     if (!ctx->pool) {
 520         ret = qsv_init_pool(ctx, fourcc);
 521         if (ret < 0) {
 522             av_log(ctx, AV_LOG_ERROR, "Error creating an internal frame pool\n");
 523             return ret;
 524         }
 525     }
 526
 527     if (opaque) {
 528         s->surface_ptrs = av_mallocz_array(frames_hwctx->nb_surfaces,
 529                                            sizeof(*s->surface_ptrs));
 530         if (!s->surface_ptrs)
 531             return AVERROR(ENOMEM);
 532
 533         for (i = 0; i < frames_hwctx->nb_surfaces; i++)
 534             s->surface_ptrs[i] = frames_hwctx->surfaces + i;
 535
 536         s->opaque_alloc.In.Surfaces   = s->surface_ptrs;
 537         s->opaque_alloc.In.NumSurface = frames_hwctx->nb_surfaces;
 538         s->opaque_alloc.In.Type       = frames_hwctx->frame_type;
 539
 540         s->opaque_alloc.Out = s->opaque_alloc.In;
 541
 542         s->opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
 543         s->opaque_alloc.Header.BufferSz = sizeof(s->opaque_alloc);
 544
 545         s->ext_buffers[0] = (mfxExtBuffer*)&s->opaque_alloc;
 546     } else {
 547         s->mem_ids = av_mallocz_array(frames_hwctx->nb_surfaces, sizeof(*s->mem_ids));
 548         if (!s->mem_ids)
 549             return AVERROR(ENOMEM);
 550
 551         for (i = 0; i < frames_hwctx->nb_surfaces; i++)
 552             s->mem_ids[i] = frames_hwctx->surfaces[i].Data.MemId;
 553     }
 554
 555     s->session_download = NULL;
 556     s->session_upload   = NULL;
 557
 558     s->session_download_init = 0;
 559     s->session_upload_init   = 0;
 560
 561 #if HAVE_PTHREADS
 562     pthread_mutex_init(&s->session_lock, NULL);
 563     pthread_cond_init(&s->session_cond, NULL);
 564 #endif
 565
 566     return 0;
 567 }
 568
 569 static int qsv_get_buffer(AVHWFramesContext *ctx, AVFrame *frame)
 570 {
 571     frame->buf[0] = av_buffer_pool_get(ctx->pool);
 572     if (!frame->buf[0])
 573         return AVERROR(ENOMEM);
 574
 575     frame->data[3] = frame->buf[0]->data;
 576     frame->format  = AV_PIX_FMT_QSV;
 577     frame->width   = ctx->width;
 578     frame->height  = ctx->height;
 579
 580     return 0;
 581 }
 582
 583 static int qsv_transfer_get_formats(AVHWFramesContext *ctx,
 584                                     enum AVHWFrameTransferDirection dir,
 585                                     enum AVPixelFormat **formats)
 586 {
 587     enum AVPixelFormat *fmts;
 588
 589     fmts = av_malloc_array(2, sizeof(*fmts));
 590     if (!fmts)
 591         return AVERROR(ENOMEM);
 592
 593     fmts[0] = ctx->sw_format;
 594     fmts[1] = AV_PIX_FMT_NONE;
 595
 596     *formats = fmts;
 597
 598     return 0;
 599 }
 600
 601 static int qsv_frames_derive_from(AVHWFramesContext *dst_ctx,
 602                                   AVHWFramesContext *src_ctx, int flags)
 603 {
 604     AVQSVFramesContext *src_hwctx = src_ctx->hwctx;
 605     int i;
 606
 607     switch (dst_ctx->device_ctx->type) {
 608 #if CONFIG_VAAPI
 609     case AV_HWDEVICE_TYPE_VAAPI:
 610         {
 611             AVVAAPIFramesContext *dst_hwctx = dst_ctx->hwctx;
 612             dst_hwctx->surface_ids = av_mallocz_array(src_hwctx->nb_surfaces,
 613                                                       sizeof(*dst_hwctx->surface_ids));
 614             if (!dst_hwctx->surface_ids)
 615                 return AVERROR(ENOMEM);
 616             for (i = 0; i < src_hwctx->nb_surfaces; i++)
 617                 dst_hwctx->surface_ids[i] =
 618                     *(VASurfaceID*)src_hwctx->surfaces[i].Data.MemId;
 619             dst_hwctx->nb_surfaces = src_hwctx->nb_surfaces;
 620         }
 621         break;
 622 #endif
 623 #if CONFIG_DXVA2
 624     case AV_HWDEVICE_TYPE_DXVA2:
 625         {
 626             AVDXVA2FramesContext *dst_hwctx = dst_ctx->hwctx;
 627             dst_hwctx->surfaces = av_mallocz_array(src_hwctx->nb_surfaces,
 628                                                    sizeof(*dst_hwctx->surfaces));
 629             if (!dst_hwctx->surfaces)
 630                 return AVERROR(ENOMEM);
 631             for (i = 0; i < src_hwctx->nb_surfaces; i++)
 632                 dst_hwctx->surfaces[i] =
 633                     (IDirect3DSurface9*)src_hwctx->surfaces[i].Data.MemId;
 634             dst_hwctx->nb_surfaces = src_hwctx->nb_surfaces;
 635             if (src_hwctx->frame_type == MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET)
 636                 dst_hwctx->surface_type = DXVA2_VideoDecoderRenderTarget;
 637             else
 638                 dst_hwctx->surface_type = DXVA2_VideoProcessorRenderTarget;
 639         }
 640         break;
 641 #endif
 642     default:
 643         return AVERROR(ENOSYS);
 644     }
 645
 646     return 0;
 647 }
 648
 649 static int qsv_map_from(AVHWFramesContext *ctx,
 650                         AVFrame *dst, const AVFrame *src, int flags)
 651 {
 652     QSVFramesContext *s = ctx->internal->priv;
 653     mfxFrameSurface1 *surf = (mfxFrameSurface1*)src->data[3];
 654     AVHWFramesContext *child_frames_ctx;
 655     const AVPixFmtDescriptor *desc;
 656     uint8_t *child_data;
 657     AVFrame *dummy;
 658     int ret = 0;
 659
 660     if (!s->child_frames_ref)
 661         return AVERROR(ENOSYS);
 662     child_frames_ctx = (AVHWFramesContext*)s->child_frames_ref->data;
 663
 664     switch (child_frames_ctx->device_ctx->type) {
 665 #if CONFIG_VAAPI
 666     case AV_HWDEVICE_TYPE_VAAPI:
 667         child_data = (uint8_t*)(intptr_t)*(VASurfaceID*)surf->Data.MemId;
 668         break;
 669 #endif
 670 #if CONFIG_DXVA2
 671     case AV_HWDEVICE_TYPE_DXVA2:
 672         child_data = surf->Data.MemId;
 673         break;
 674 #endif
 675     default:
 676         return AVERROR(ENOSYS);
 677     }
 678
 679     if (dst->format == child_frames_ctx->format) {
 680         ret = ff_hwframe_map_create(s->child_frames_ref,
 681                                     dst, src, NULL, NULL);
 682         if (ret < 0)
 683             return ret;
 684
 685         dst->width   = src->width;
 686         dst->height  = src->height;
 687         dst->data[3] = child_data;
 688
 689         return 0;
 690     }
 691
 692     desc = av_pix_fmt_desc_get(dst->format);
 693     if (desc && desc->flags & AV_PIX_FMT_FLAG_HWACCEL) {
 694         // This only supports mapping to software.
 695         return AVERROR(ENOSYS);
 696     }
 697
 698     dummy = av_frame_alloc();
 699     if (!dummy)
 700         return AVERROR(ENOMEM);
 701
 702     dummy->buf[0]        = av_buffer_ref(src->buf[0]);
 703     dummy->hw_frames_ctx = av_buffer_ref(s->child_frames_ref);
 704     if (!dummy->buf[0] || !dummy->hw_frames_ctx)
 705         goto fail;
 706
 707     dummy->format        = child_frames_ctx->format;
 708     dummy->width         = src->width;
 709     dummy->height        = src->height;
 710     dummy->data[3]       = child_data;
 711
 712     ret = av_hwframe_map(dst, dummy, flags);
 713
 714 fail:
 715     av_frame_free(&dummy);
 716
 717     return ret;
 718 }
 719
 720 static int qsv_transfer_data_child(AVHWFramesContext *ctx, AVFrame *dst,
 721                                    const AVFrame *src)
 722 {
 723     QSVFramesContext *s = ctx->internal->priv;
 724     AVHWFramesContext *child_frames_ctx = (AVHWFramesContext*)s->child_frames_ref->data;
 725     int download = !!src->hw_frames_ctx;
 726     mfxFrameSurface1 *surf = (mfxFrameSurface1*)(download ? src->data[3] : dst->data[3]);
 727
 728     AVFrame *dummy;
 729     int ret;
 730
 731     dummy = av_frame_alloc();
 732     if (!dummy)
 733         return AVERROR(ENOMEM);
 734
 735     dummy->format        = child_frames_ctx->format;
 736     dummy->width         = src->width;
 737     dummy->height        = src->height;
 738     dummy->buf[0]        = download ? src->buf[0] : dst->buf[0];
 739     dummy->data[3]       = surf->Data.MemId;
 740     dummy->hw_frames_ctx = s->child_frames_ref;
 741
 742     ret = download ? av_hwframe_transfer_data(dst, dummy, 0) :
 743                      av_hwframe_transfer_data(dummy, src, 0);
 744
 745     dummy->buf[0]        = NULL;
 746     dummy->data[3]       = NULL;
 747     dummy->hw_frames_ctx = NULL;
 748
 749     av_frame_free(&dummy);
 750
 751     return ret;
 752 }
 753
 754 static int qsv_transfer_data_from(AVHWFramesContext *ctx, AVFrame *dst,
 755                                   const AVFrame *src)
 756 {
 757     QSVFramesContext  *s = ctx->internal->priv;
 758     mfxFrameSurface1 out = {{ 0 }};
 759     mfxFrameSurface1 *in = (mfxFrameSurface1*)src->data[3];
 760
 761     mfxSyncPoint sync = NULL;
 762     mfxStatus err;
 763     int ret = 0;
 764
 765     while (!s->session_download_init && !s->session_download && !ret) {
 766 #if HAVE_PTHREADS
 767         if (pthread_mutex_trylock(&s->session_lock) == 0) {
 768 #endif
 769             if (!s->session_download_init) {
 770                 ret = qsv_init_internal_session(ctx, &s->session_download, 0);
 771                 if (s->session_download)
 772                     s->session_download_init = 1;
 773             }
 774 #if HAVE_PTHREADS
 775             pthread_mutex_unlock(&s->session_lock);
 776             pthread_cond_signal(&s->session_cond);
 777         } else {
 778             pthread_mutex_lock(&s->session_lock);
 779             while (!s->session_download_init && !s->session_download) {
 780                 pthread_cond_wait(&s->session_cond, &s->session_lock);
 781             }
 782             pthread_mutex_unlock(&s->session_lock);
 783         }
 784 #endif
 785     }
 786
 787     if (ret < 0)
 788         return ret;
 789
 790     if (!s->session_download) {
 791         if (s->child_frames_ref)
 792             return qsv_transfer_data_child(ctx, dst, src);
 793
 794         av_log(ctx, AV_LOG_ERROR, "Surface download not possible\n");
 795         return AVERROR(ENOSYS);
 796     }
 797
 798     out.Info = in->Info;
 799     out.Data.PitchLow = dst->linesize[0];
 800     out.Data.Y        = dst->data[0];
 801     out.Data.U        = dst->data[1];
 802     out.Data.V        = dst->data[2];
 803     out.Data.A        = dst->data[3];
 804
 805     do {
 806         err = MFXVideoVPP_RunFrameVPPAsync(s->session_download, in, &out, NULL, &sync);
 807         if (err == MFX_WRN_DEVICE_BUSY)
 808             av_usleep(1);
 809     } while (err == MFX_WRN_DEVICE_BUSY);
 810
 811     if (err < 0 || !sync) {
 812         av_log(ctx, AV_LOG_ERROR, "Error downloading the surface\n");
 813         return AVERROR_UNKNOWN;
 814     }
 815
 816     do {
 817         err = MFXVideoCORE_SyncOperation(s->session_download, sync, 1000);
 818     } while (err == MFX_WRN_IN_EXECUTION);
 819     if (err < 0) {
 820         av_log(ctx, AV_LOG_ERROR, "Error synchronizing the operation: %d\n", err);
 821         return AVERROR_UNKNOWN;
 822     }
 823
 824     return 0;
 825 }
 826
 827 static int qsv_transfer_data_to(AVHWFramesContext *ctx, AVFrame *dst,
 828                                 const AVFrame *src)
 829 {
 830     QSVFramesContext   *s = ctx->internal->priv;
 831     mfxFrameSurface1   in = {{ 0 }};
 832     mfxFrameSurface1 *out = (mfxFrameSurface1*)dst->data[3];
 833
 834     mfxSyncPoint sync = NULL;
 835     mfxStatus err;
 836     int ret;
 837
 838     while (!s->session_upload_init && !s->session_upload && !ret) {
 839 #if HAVE_PTHREADS
 840         if (pthread_mutex_trylock(&s->session_lock) == 0) {
 841 #endif
 842             if (!s->session_upload_init) {
 843                 ret = qsv_init_internal_session(ctx, &s->session_upload, 1);
 844                 if (s->session_upload)
 845                     s->session_upload_init = 1;
 846             }
 847 #if HAVE_PTHREADS
 848             pthread_mutex_unlock(&s->session_lock);
 849             pthread_cond_signal(&s->session_cond);
 850         } else {
 851             pthread_mutex_lock(&s->session_lock);
 852             while (!s->session_upload_init && !s->session_upload) {
 853                 pthread_cond_wait(&s->session_cond, &s->session_lock);
 854             }
 855             pthread_mutex_unlock(&s->session_lock);
 856         }
 857 #endif
 858     }
 859     if (ret < 0)
 860         return ret;
 861
 862     if (!s->session_upload) {
 863         if (s->child_frames_ref)
 864             return qsv_transfer_data_child(ctx, dst, src);
 865
 866         av_log(ctx, AV_LOG_ERROR, "Surface upload not possible\n");
 867         return AVERROR(ENOSYS);
 868     }
 869
 870     in.Info = out->Info;
 871     in.Data.PitchLow = src->linesize[0];
 872     in.Data.Y        = src->data[0];
 873     in.Data.U        = src->data[1];
 874     in.Data.V        = src->data[2];
 875     in.Data.A        = src->data[3];
 876
 877     do {
 878         err = MFXVideoVPP_RunFrameVPPAsync(s->session_upload, &in, out, NULL, &sync);
 879         if (err == MFX_WRN_DEVICE_BUSY)
 880             av_usleep(1);
 881     } while (err == MFX_WRN_DEVICE_BUSY);
 882
 883     if (err < 0 || !sync) {
 884         av_log(ctx, AV_LOG_ERROR, "Error uploading the surface\n");
 885         return AVERROR_UNKNOWN;
 886     }
 887
 888     do {
 889         err = MFXVideoCORE_SyncOperation(s->session_upload, sync, 1000);
 890     } while (err == MFX_WRN_IN_EXECUTION);
 891     if (err < 0) {
 892         av_log(ctx, AV_LOG_ERROR, "Error synchronizing the operation\n");
 893         return AVERROR_UNKNOWN;
 894     }
 895
 896     return 0;
 897 }
 898
 899 static int qsv_frames_derive_to(AVHWFramesContext *dst_ctx,
 900                                 AVHWFramesContext *src_ctx, int flags)
 901 {
 902     QSVFramesContext *s = dst_ctx->internal->priv;
 903     AVQSVFramesContext *dst_hwctx = dst_ctx->hwctx;
 904     int i;
 905
 906     switch (src_ctx->device_ctx->type) {
 907 #if CONFIG_VAAPI
 908     case AV_HWDEVICE_TYPE_VAAPI:
 909         {
 910             AVVAAPIFramesContext *src_hwctx = src_ctx->hwctx;
 911             s->surfaces_internal = av_mallocz_array(src_hwctx->nb_surfaces,
 912                                                     sizeof(*s->surfaces_internal));
 913             if (!s->surfaces_internal)
 914                 return AVERROR(ENOMEM);
 915             for (i = 0; i < src_hwctx->nb_surfaces; i++) {
 916                 qsv_init_surface(dst_ctx, &s->surfaces_internal[i]);
 917                 s->surfaces_internal[i].Data.MemId = src_hwctx->surface_ids + i;
 918             }
 919             dst_hwctx->nb_surfaces = src_hwctx->nb_surfaces;
 920             dst_hwctx->frame_type  = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;
 921         }
 922         break;
 923 #endif
 924 #if CONFIG_DXVA2
 925     case AV_HWDEVICE_TYPE_DXVA2:
 926         {
 927             AVDXVA2FramesContext *src_hwctx = src_ctx->hwctx;
 928             s->surfaces_internal = av_mallocz_array(src_hwctx->nb_surfaces,
 929                                                     sizeof(*s->surfaces_internal));
 930             if (!s->surfaces_internal)
 931                 return AVERROR(ENOMEM);
 932             for (i = 0; i < src_hwctx->nb_surfaces; i++) {
 933                 qsv_init_surface(dst_ctx, &s->surfaces_internal[i]);
 934                 s->surfaces_internal[i].Data.MemId = (mfxMemId)src_hwctx->surfaces[i];
 935             }
 936             dst_hwctx->nb_surfaces = src_hwctx->nb_surfaces;
 937             if (src_hwctx->surface_type == DXVA2_VideoProcessorRenderTarget)
 938                 dst_hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET;
 939             else
 940                 dst_hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;
 941         }
 942         break;
 943 #endif
 944     default:
 945         return AVERROR(ENOSYS);
 946     }
 947
 948     dst_hwctx->surfaces = s->surfaces_internal;
 949
 950     return 0;
 951 }
 952
 953 static int qsv_map_to(AVHWFramesContext *dst_ctx,
 954                       AVFrame *dst, const AVFrame *src, int flags)
 955 {
 956     AVQSVFramesContext *hwctx = dst_ctx->hwctx;
 957     int i, err;
 958
 959     for (i = 0; i < hwctx->nb_surfaces; i++) {
 960 #if CONFIG_VAAPI
 961         if (*(VASurfaceID*)hwctx->surfaces[i].Data.MemId ==
 962             (VASurfaceID)(uintptr_t)src->data[3])
 963             break;
 964 #endif
 965 #if CONFIG_DXVA2
 966         if ((IDirect3DSurface9*)hwctx->surfaces[i].Data.MemId ==
 967             (IDirect3DSurface9*)(uintptr_t)src->data[3])
 968             break;
 969 #endif
 970     }
 971     if (i >= hwctx->nb_surfaces) {
 972         av_log(dst_ctx, AV_LOG_ERROR, "Trying to map from a surface which "
 973                "is not in the mapped frames context.\n");
 974         return AVERROR(EINVAL);
 975     }
 976
 977     err = ff_hwframe_map_create(dst->hw_frames_ctx,
 978                                 dst, src, NULL, NULL);
 979     if (err)
 980         return err;
 981
 982     dst->width   = src->width;
 983     dst->height  = src->height;
 984     dst->data[3] = (uint8_t*)&hwctx->surfaces[i];
 985
 986     return 0;
 987 }
 988
 989 static int qsv_frames_get_constraints(AVHWDeviceContext *ctx,
 990                                       const void *hwconfig,
 991                                       AVHWFramesConstraints *constraints)
 992 {
 993     int i;
 994
 995     constraints->valid_sw_formats = av_malloc_array(FF_ARRAY_ELEMS(supported_pixel_formats) + 1,
 996                                                     sizeof(*constraints->valid_sw_formats));
 997     if (!constraints->valid_sw_formats)
 998         return AVERROR(ENOMEM);
 999
1000     for (i = 0; i < FF_ARRAY_ELEMS(supported_pixel_formats); i++)
1001         constraints->valid_sw_formats[i] = supported_pixel_formats[i].pix_fmt;
1002     constraints->valid_sw_formats[FF_ARRAY_ELEMS(supported_pixel_formats)] = AV_PIX_FMT_NONE;
1003
1004     constraints->valid_hw_formats = av_malloc_array(2, sizeof(*constraints->valid_hw_formats));
1005     if (!constraints->valid_hw_formats)
1006         return AVERROR(ENOMEM);
1007
1008     constraints->valid_hw_formats[0] = AV_PIX_FMT_QSV;
1009     constraints->valid_hw_formats[1] = AV_PIX_FMT_NONE;
1010
1011     return 0;
1012 }
1013
1014 static void qsv_device_free(AVHWDeviceContext *ctx)
1015 {
1016     AVQSVDeviceContext *hwctx = ctx->hwctx;
1017     QSVDevicePriv       *priv = ctx->user_opaque;
1018
1019     if (hwctx->session)
1020         MFXClose(hwctx->session);
1021
1022     av_buffer_unref(&priv->child_device_ctx);
1023     av_freep(&priv);
1024 }
1025
1026 static mfxIMPL choose_implementation(const char *device)
1027 {
1028     static const struct {
1029         const char *name;
1030         mfxIMPL     impl;
1031     } impl_map[] = {
1032         { "auto",     MFX_IMPL_AUTO         },
1033         { "sw",       MFX_IMPL_SOFTWARE     },
1034         { "hw",       MFX_IMPL_HARDWARE     },
1035         { "auto_any", MFX_IMPL_AUTO_ANY     },
1036         { "hw_any",   MFX_IMPL_HARDWARE_ANY },
1037         { "hw2",      MFX_IMPL_HARDWARE2    },
1038         { "hw3",      MFX_IMPL_HARDWARE3    },
1039         { "hw4",      MFX_IMPL_HARDWARE4    },
1040     };
1041
1042     mfxIMPL impl = MFX_IMPL_AUTO_ANY;
1043     int i;
1044
1045     if (device) {
1046         for (i = 0; i < FF_ARRAY_ELEMS(impl_map); i++)
1047             if (!strcmp(device, impl_map[i].name)) {
1048                 impl = impl_map[i].impl;
1049                 break;
1050             }
1051         if (i == FF_ARRAY_ELEMS(impl_map))
1052             impl = strtol(device, NULL, 0);
1053     }
1054
1055     return impl;
1056 }
1057
1058 static int qsv_device_derive_from_child(AVHWDeviceContext *ctx,
1059                                         mfxIMPL implementation,
1060                                         AVHWDeviceContext *child_device_ctx,
1061                                         int flags)
1062 {
1063     AVQSVDeviceContext *hwctx = ctx->hwctx;
1064
1065     mfxVersion    ver = { { 3, 1 } };
1066     mfxHDL        handle;
1067     mfxHandleType handle_type;
1068     mfxStatus     err;
1069     int ret;
1070
1071     switch (child_device_ctx->type) {
1072 #if CONFIG_VAAPI
1073     case AV_HWDEVICE_TYPE_VAAPI:
1074         {
1075             AVVAAPIDeviceContext *child_device_hwctx = child_device_ctx->hwctx;
1076             handle_type = MFX_HANDLE_VA_DISPLAY;
1077             handle = (mfxHDL)child_device_hwctx->display;
1078         }
1079         break;
1080 #endif
1081 #if CONFIG_DXVA2
1082     case AV_HWDEVICE_TYPE_DXVA2:
1083         {
1084             AVDXVA2DeviceContext *child_device_hwctx = child_device_ctx->hwctx;
1085             handle_type = MFX_HANDLE_D3D9_DEVICE_MANAGER;
1086             handle = (mfxHDL)child_device_hwctx->devmgr;
1087         }
1088         break;
1089 #endif
1090     default:
1091         ret = AVERROR(ENOSYS);
1092         goto fail;
1093     }
1094
1095     err = MFXInit(implementation, &ver, &hwctx->session);
1096     if (err != MFX_ERR_NONE) {
1097         av_log(ctx, AV_LOG_ERROR, "Error initializing an MFX session: "
1098                "%d.\n", err);
1099         ret = AVERROR_UNKNOWN;
1100         goto fail;
1101     }
1102
1103     err = MFXQueryVersion(hwctx->session, &ver);
1104     if (err != MFX_ERR_NONE) {
1105         av_log(ctx, AV_LOG_ERROR, "Error querying an MFX session: %d.\n", err);
1106         ret = AVERROR_UNKNOWN;
1107         goto fail;
1108     }
1109
1110     av_log(ctx, AV_LOG_VERBOSE,
1111            "Initialize MFX session: API version is %d.%d, implementation version is %d.%d\n",
1112            MFX_VERSION_MAJOR, MFX_VERSION_MINOR, ver.Major, ver.Minor);
1113
1114     MFXClose(hwctx->session);
1115
1116     err = MFXInit(implementation, &ver, &hwctx->session);
1117     if (err != MFX_ERR_NONE) {
1118         av_log(ctx, AV_LOG_ERROR,
1119                "Error initializing an MFX session: %d.\n", err);
1120         ret = AVERROR_UNKNOWN;
1121         goto fail;
1122     }
1123
1124     err = MFXVideoCORE_SetHandle(hwctx->session, handle_type, handle);
1125     if (err != MFX_ERR_NONE) {
1126         av_log(ctx, AV_LOG_ERROR, "Error setting child device handle: "
1127                "%d\n", err);
1128         ret = AVERROR_UNKNOWN;
1129         goto fail;
1130     }
1131
1132     ret = MFXQueryVersion(hwctx->session,&ver);
1133     if (ret == MFX_ERR_NONE) {
1134         av_log(ctx, AV_LOG_VERBOSE, "MFX compile/runtime API: %d.%d/%d.%d\n",
1135                MFX_VERSION_MAJOR, MFX_VERSION_MINOR, ver.Major, ver.Minor);
1136     }
1137     return 0;
1138
1139 fail:
1140     if (hwctx->session)
1141         MFXClose(hwctx->session);
1142     return ret;
1143 }
1144
1145 static int qsv_device_derive(AVHWDeviceContext *ctx,
1146                              AVHWDeviceContext *child_device_ctx, int flags)
1147 {
1148     return qsv_device_derive_from_child(ctx, MFX_IMPL_HARDWARE_ANY,
1149                                         child_device_ctx, flags);
1150 }
1151
1152 static int qsv_device_create(AVHWDeviceContext *ctx, const char *device,
1153                              AVDictionary *opts, int flags)
1154 {
1155     QSVDevicePriv *priv;
1156     enum AVHWDeviceType child_device_type;
1157     AVHWDeviceContext *child_device;
1158     AVDictionaryEntry *e;
1159
1160     mfxIMPL impl;
1161     int ret;
1162
1163     priv = av_mallocz(sizeof(*priv));
1164     if (!priv)
1165         return AVERROR(ENOMEM);
1166
1167     ctx->user_opaque = priv;
1168     ctx->free        = qsv_device_free;
1169
1170     e = av_dict_get(opts, "child_device", NULL, 0);
1171
1172     if (CONFIG_VAAPI)
1173         child_device_type = AV_HWDEVICE_TYPE_VAAPI;
1174     else if (CONFIG_DXVA2)
1175         child_device_type = AV_HWDEVICE_TYPE_DXVA2;
1176     else {
1177         av_log(ctx, AV_LOG_ERROR, "No supported child device type is enabled\n");
1178         return AVERROR(ENOSYS);
1179     }
1180
1181     ret = av_hwdevice_ctx_create(&priv->child_device_ctx, child_device_type,
1182                                  e ? e->value : NULL, NULL, 0);
1183     if (ret < 0)
1184         return ret;
1185
1186     child_device = (AVHWDeviceContext*)priv->child_device_ctx->data;
1187
1188     impl = choose_implementation(device);
1189
1190     return qsv_device_derive_from_child(ctx, impl, child_device, 0);
1191 }
1192
1193 const HWContextType ff_hwcontext_type_qsv = {
1194     .type                   = AV_HWDEVICE_TYPE_QSV,
1195     .name                   = "QSV",
1196
1197     .device_hwctx_size      = sizeof(AVQSVDeviceContext),
1198     .device_priv_size       = sizeof(QSVDeviceContext),
1199     .frames_hwctx_size      = sizeof(AVQSVFramesContext),
1200     .frames_priv_size       = sizeof(QSVFramesContext),
1201
1202     .device_create          = qsv_device_create,
1203     .device_derive          = qsv_device_derive,
1204     .device_init            = qsv_device_init,
1205     .frames_get_constraints = qsv_frames_get_constraints,
1206     .frames_init            = qsv_frames_init,
1207     .frames_uninit          = qsv_frames_uninit,
1208     .frames_get_buffer      = qsv_get_buffer,
1209     .transfer_get_formats   = qsv_transfer_get_formats,
1210     .transfer_data_to       = qsv_transfer_data_to,
1211     .transfer_data_from     = qsv_transfer_data_from,
1212     .map_to                 = qsv_map_to,
1213     .map_from               = qsv_map_from,
1214     .frames_derive_to       = qsv_frames_derive_to,
1215     .frames_derive_from     = qsv_frames_derive_from,
1216
1217     .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_QSV, AV_PIX_FMT_NONE },
1218 };