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