git.sesse.net Git - ffmpeg/blob - libavutil/hwcontext_d3d11va.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 <windows.h>
  20
  21 #if !defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600
  22 #undef _WIN32_WINNT
  23 #define _WIN32_WINNT 0x0600
  24 #endif
  25 #define COBJMACROS
  26
  27 #include <initguid.h>
  28 #include <d3d11.h>
  29 #include <dxgi1_2.h>
  30
  31 #include "avassert.h"
  32 #include "common.h"
  33 #include "hwcontext.h"
  34 #include "hwcontext_d3d11va.h"
  35 #include "hwcontext_internal.h"
  36 #include "imgutils.h"
  37 #include "pixdesc.h"
  38 #include "pixfmt.h"
  39
  40 typedef HRESULT(WINAPI *PFN_CREATE_DXGI_FACTORY)(REFIID riid, void **ppFactory);
  41
  42 typedef struct D3D11VAFramesContext {
  43     int nb_surfaces_used;
  44
  45     DXGI_FORMAT format;
  46
  47     ID3D11Texture2D *staging_texture;
  48 } D3D11VAFramesContext;
  49
  50 static const struct {
  51     DXGI_FORMAT d3d_format;
  52     enum AVPixelFormat pix_fmt;
  53 } supported_formats[] = {
  54     { DXGI_FORMAT_NV12, AV_PIX_FMT_NV12 },
  55     { DXGI_FORMAT_P010, AV_PIX_FMT_P010 },
  56 };
  57
  58 static void d3d11va_default_lock(void *ctx)
  59 {
  60     WaitForSingleObjectEx(ctx, INFINITE, FALSE);
  61 }
  62
  63 static void d3d11va_default_unlock(void *ctx)
  64 {
  65     ReleaseMutex(ctx);
  66 }
  67
  68 static void d3d11va_frames_uninit(AVHWFramesContext *ctx)
  69 {
  70     AVD3D11VAFramesContext *frames_hwctx = ctx->hwctx;
  71     D3D11VAFramesContext *s = ctx->internal->priv;
  72
  73     if (frames_hwctx->texture)
  74         ID3D11Texture2D_Release(frames_hwctx->texture);
  75
  76     if (s->staging_texture)
  77         ID3D11Texture2D_Release(s->staging_texture);
  78 }
  79
  80 static void free_texture(void *opaque, uint8_t *data)
  81 {
  82     ID3D11Texture2D_Release((ID3D11Texture2D *)opaque);
  83 }
  84
  85 static AVBufferRef *wrap_texture_buf(ID3D11Texture2D *tex, int index)
  86 {
  87     AVBufferRef *buf;
  88     AVD3D11FrameDescriptor *desc = av_mallocz(sizeof(*desc));
  89     if (!desc) {
  90         ID3D11Texture2D_Release(tex);
  91         return NULL;
  92     }
  93
  94     desc->texture = tex;
  95     desc->index   = index;
  96
  97     buf = av_buffer_create((uint8_t *)desc, sizeof(desc), free_texture, tex, 0);
  98     if (!buf) {
  99         ID3D11Texture2D_Release(tex);
 100         av_free(desc);
 101         return NULL;
 102     }
 103
 104     return buf;
 105 }
 106
 107 static AVBufferRef *d3d11va_alloc_single(AVHWFramesContext *ctx)
 108 {
 109     D3D11VAFramesContext       *s = ctx->internal->priv;
 110     AVD3D11VAFramesContext *hwctx = ctx->hwctx;
 111     AVD3D11VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
 112     HRESULT hr;
 113     ID3D11Texture2D *tex;
 114     D3D11_TEXTURE2D_DESC texDesc = {
 115         .Width      = ctx->width,
 116         .Height     = ctx->height,
 117         .MipLevels  = 1,
 118         .Format     = s->format,
 119         .SampleDesc = { .Count = 1 },
 120         .ArraySize  = 1,
 121         .Usage      = D3D11_USAGE_DEFAULT,
 122         .BindFlags  = hwctx->BindFlags,
 123         .MiscFlags  = hwctx->MiscFlags,
 124     };
 125
 126     hr = ID3D11Device_CreateTexture2D(device_hwctx->device, &texDesc, NULL, &tex);
 127     if (FAILED(hr)) {
 128         av_log(ctx, AV_LOG_ERROR, "Could not create the texture (%lx)\n", (long)hr);
 129         return NULL;
 130     }
 131
 132     return wrap_texture_buf(tex, 0);
 133 }
 134
 135 static AVBufferRef *d3d11va_pool_alloc(void *opaque, int size)
 136 {
 137     AVHWFramesContext        *ctx = (AVHWFramesContext*)opaque;
 138     D3D11VAFramesContext       *s = ctx->internal->priv;
 139     AVD3D11VAFramesContext *hwctx = ctx->hwctx;
 140     D3D11_TEXTURE2D_DESC  texDesc;
 141
 142     if (!hwctx->texture)
 143         return d3d11va_alloc_single(ctx);
 144
 145     ID3D11Texture2D_GetDesc(hwctx->texture, &texDesc);
 146
 147     if (s->nb_surfaces_used >= texDesc.ArraySize) {
 148         av_log(ctx, AV_LOG_ERROR, "Static surface pool size exceeded.\n");
 149         return NULL;
 150     }
 151
 152     ID3D11Texture2D_AddRef(hwctx->texture);
 153     return wrap_texture_buf(hwctx->texture, s->nb_surfaces_used++);
 154 }
 155
 156 static int d3d11va_frames_init(AVHWFramesContext *ctx)
 157 {
 158     AVD3D11VAFramesContext *hwctx        = ctx->hwctx;
 159     AVD3D11VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
 160     D3D11VAFramesContext              *s = ctx->internal->priv;
 161
 162     int i;
 163     HRESULT hr;
 164     D3D11_TEXTURE2D_DESC texDesc;
 165
 166     for (i = 0; i < FF_ARRAY_ELEMS(supported_formats); i++) {
 167         if (ctx->sw_format == supported_formats[i].pix_fmt) {
 168             s->format = supported_formats[i].d3d_format;
 169             break;
 170         }
 171     }
 172     if (i == FF_ARRAY_ELEMS(supported_formats)) {
 173         av_log(ctx, AV_LOG_ERROR, "Unsupported pixel format: %s\n",
 174                av_get_pix_fmt_name(ctx->sw_format));
 175         return AVERROR(EINVAL);
 176     }
 177
 178     texDesc = (D3D11_TEXTURE2D_DESC){
 179         .Width      = ctx->width,
 180         .Height     = ctx->height,
 181         .MipLevels  = 1,
 182         .Format     = s->format,
 183         .SampleDesc = { .Count = 1 },
 184         .ArraySize  = ctx->initial_pool_size,
 185         .Usage      = D3D11_USAGE_DEFAULT,
 186         .BindFlags  = hwctx->BindFlags,
 187         .MiscFlags  = hwctx->MiscFlags,
 188     };
 189
 190     if (hwctx->texture) {
 191         D3D11_TEXTURE2D_DESC texDesc2;
 192         ID3D11Texture2D_GetDesc(hwctx->texture, &texDesc2);
 193
 194         if (texDesc.Width != texDesc2.Width ||
 195             texDesc.Height != texDesc2.Height ||
 196             texDesc.Format != texDesc2.Format) {
 197             av_log(ctx, AV_LOG_ERROR, "User-provided texture has mismatching parameters\n");
 198             return AVERROR(EINVAL);
 199         }
 200     } else if (texDesc.ArraySize > 0) {
 201         hr = ID3D11Device_CreateTexture2D(device_hwctx->device, &texDesc, NULL, &hwctx->texture);
 202         if (FAILED(hr)) {
 203             av_log(ctx, AV_LOG_ERROR, "Could not create the texture (%lx)\n", (long)hr);
 204             return AVERROR_UNKNOWN;
 205         }
 206     }
 207
 208     texDesc.ArraySize       = 1;
 209     texDesc.Usage           = D3D11_USAGE_STAGING;
 210     texDesc.BindFlags       = 0;
 211     texDesc.CPUAccessFlags  = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE;
 212     texDesc.MiscFlags       = 0;
 213     hr = ID3D11Device_CreateTexture2D(device_hwctx->device, &texDesc, NULL, &s->staging_texture);
 214     if (FAILED(hr)) {
 215         av_log(ctx, AV_LOG_ERROR, "Could not create the staging texture (%lx)\n", (long)hr);
 216         return AVERROR_UNKNOWN;
 217     }
 218
 219     ctx->internal->pool_internal = av_buffer_pool_init2(sizeof(AVD3D11FrameDescriptor),
 220                                                         ctx, d3d11va_pool_alloc, NULL);
 221     if (!ctx->internal->pool_internal)
 222         return AVERROR(ENOMEM);
 223
 224     return 0;
 225 }
 226
 227 static int d3d11va_get_buffer(AVHWFramesContext *ctx, AVFrame *frame)
 228 {
 229     AVD3D11FrameDescriptor *desc;
 230
 231     frame->buf[0] = av_buffer_pool_get(ctx->pool);
 232     if (!frame->buf[0])
 233         return AVERROR(ENOMEM);
 234
 235     desc = (AVD3D11FrameDescriptor *)frame->buf[0]->data;
 236
 237     frame->data[0] = (uint8_t *)desc->texture;
 238     frame->data[1] = (uint8_t *)desc->index;
 239     frame->format  = AV_PIX_FMT_D3D11;
 240     frame->width   = ctx->width;
 241     frame->height  = ctx->height;
 242
 243     return 0;
 244 }
 245
 246 static int d3d11va_transfer_get_formats(AVHWFramesContext *ctx,
 247                                         enum AVHWFrameTransferDirection dir,
 248                                         enum AVPixelFormat **formats)
 249 {
 250     enum AVPixelFormat *fmts;
 251
 252     fmts = av_malloc_array(2, sizeof(*fmts));
 253     if (!fmts)
 254         return AVERROR(ENOMEM);
 255
 256     fmts[0] = ctx->sw_format;
 257     fmts[1] = AV_PIX_FMT_NONE;
 258
 259     *formats = fmts;
 260
 261     return 0;
 262 }
 263
 264 static void fill_texture_ptrs(uint8_t *data[4], int linesize[4],
 265                               AVHWFramesContext *ctx,
 266                               D3D11_TEXTURE2D_DESC *desc,
 267                               D3D11_MAPPED_SUBRESOURCE *map)
 268 {
 269     int i;
 270
 271     for (i = 0; i < 4; i++)
 272         linesize[i] = map->RowPitch;
 273
 274     av_image_fill_pointers(data, ctx->sw_format, desc->Height,
 275                            (uint8_t*)map->pData, linesize);
 276 }
 277
 278 static int d3d11va_transfer_data(AVHWFramesContext *ctx, AVFrame *dst,
 279                                  const AVFrame *src)
 280 {
 281     AVD3D11VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
 282     D3D11VAFramesContext              *s = ctx->internal->priv;
 283     int download = src->format == AV_PIX_FMT_D3D11;
 284     const AVFrame *frame = download ? src : dst;
 285     const AVFrame *other = download ? dst : src;
 286     // (The interface types are compatible.)
 287     ID3D11Resource *texture = (ID3D11Resource *)(ID3D11Texture2D *)frame->data[0];
 288     int index = (intptr_t)frame->data[1];
 289     ID3D11Resource *staging = (ID3D11Resource *)s->staging_texture;
 290     int w = FFMIN(dst->width,  src->width);
 291     int h = FFMIN(dst->height, src->height);
 292     uint8_t *map_data[4];
 293     int map_linesize[4];
 294     D3D11_TEXTURE2D_DESC desc;
 295     D3D11_MAPPED_SUBRESOURCE map;
 296     HRESULT hr;
 297
 298     if (frame->hw_frames_ctx->data != (uint8_t *)ctx || other->format != ctx->sw_format)
 299         return AVERROR(EINVAL);
 300
 301     device_hwctx->lock(device_hwctx->lock_ctx);
 302
 303     ID3D11Texture2D_GetDesc(s->staging_texture, &desc);
 304
 305     if (download) {
 306         ID3D11DeviceContext_CopySubresourceRegion(device_hwctx->device_context,
 307                                                   staging, 0, 0, 0, 0,
 308                                                   texture, index, NULL);
 309
 310         hr = ID3D11DeviceContext_Map(device_hwctx->device_context,
 311                                      staging, 0, D3D11_MAP_READ, 0, &map);
 312         if (FAILED(hr))
 313             goto map_failed;
 314
 315         fill_texture_ptrs(map_data, map_linesize, ctx, &desc, &map);
 316
 317         av_image_copy(dst->data, dst->linesize, map_data, map_linesize,
 318                       ctx->sw_format, w, h);
 319
 320         ID3D11DeviceContext_Unmap(device_hwctx->device_context, staging, 0);
 321     } else {
 322         hr = ID3D11DeviceContext_Map(device_hwctx->device_context,
 323                                      staging, 0, D3D11_MAP_WRITE, 0, &map);
 324         if (FAILED(hr))
 325             goto map_failed;
 326
 327         fill_texture_ptrs(map_data, map_linesize, ctx, &desc, &map);
 328
 329         av_image_copy(map_data, map_linesize, src->data, src->linesize,
 330                       ctx->sw_format, w, h);
 331
 332         ID3D11DeviceContext_Unmap(device_hwctx->device_context, staging, 0);
 333
 334         ID3D11DeviceContext_CopySubresourceRegion(device_hwctx->device_context,
 335                                                   texture, index, 0, 0, 0,
 336                                                   staging, 0, NULL);
 337     }
 338
 339     device_hwctx->unlock(device_hwctx->lock_ctx);
 340     return 0;
 341
 342 map_failed:
 343     av_log(ctx, AV_LOG_ERROR, "Unable to lock D3D11VA surface (%lx)\n", (long)hr);
 344     device_hwctx->unlock(device_hwctx->lock_ctx);
 345     return AVERROR_UNKNOWN;
 346 }
 347
 348 static int d3d11va_device_init(AVHWDeviceContext *hwdev)
 349 {
 350     AVD3D11VADeviceContext *device_hwctx = hwdev->hwctx;
 351     HRESULT hr;
 352
 353     if (!device_hwctx->lock) {
 354         device_hwctx->lock_ctx = CreateMutex(NULL, 0, NULL);
 355         if (device_hwctx->lock_ctx == INVALID_HANDLE_VALUE) {
 356             av_log(NULL, AV_LOG_ERROR, "Failed to create a mutex\n");
 357             return AVERROR(EINVAL);
 358         }
 359         device_hwctx->lock   = d3d11va_default_lock;
 360         device_hwctx->unlock = d3d11va_default_unlock;
 361     }
 362
 363     if (!device_hwctx->device_context) {
 364         ID3D11Device_GetImmediateContext(device_hwctx->device, &device_hwctx->device_context);
 365         if (!device_hwctx->device_context)
 366             return AVERROR_UNKNOWN;
 367     }
 368
 369     if (!device_hwctx->video_device) {
 370         hr = ID3D11DeviceContext_QueryInterface(device_hwctx->device, &IID_ID3D11VideoDevice,
 371                                                 (void **)&device_hwctx->video_device);
 372         if (FAILED(hr))
 373             return AVERROR_UNKNOWN;
 374     }
 375
 376     if (!device_hwctx->video_context) {
 377         hr = ID3D11DeviceContext_QueryInterface(device_hwctx->device_context, &IID_ID3D11VideoContext,
 378                                                 (void **)&device_hwctx->video_context);
 379         if (FAILED(hr))
 380             return AVERROR_UNKNOWN;
 381     }
 382
 383     return 0;
 384 }
 385
 386 static void d3d11va_device_uninit(AVHWDeviceContext *hwdev)
 387 {
 388     AVD3D11VADeviceContext *device_hwctx = hwdev->hwctx;
 389
 390     if (device_hwctx->device)
 391         ID3D11Device_Release(device_hwctx->device);
 392
 393     if (device_hwctx->device_context)
 394         ID3D11DeviceContext_Release(device_hwctx->device_context);
 395
 396     if (device_hwctx->video_device)
 397         ID3D11VideoDevice_Release(device_hwctx->video_device);
 398
 399     if (device_hwctx->video_context)
 400         ID3D11VideoContext_Release(device_hwctx->video_context);
 401
 402     if (device_hwctx->lock == d3d11va_default_lock)
 403         CloseHandle(device_hwctx->lock_ctx);
 404 }
 405
 406 static int d3d11va_device_create(AVHWDeviceContext *ctx, const char *device,
 407                                  AVDictionary *opts, int flags)
 408 {
 409     AVD3D11VADeviceContext *device_hwctx = ctx->hwctx;
 410     HANDLE d3dlib;
 411
 412     HRESULT hr;
 413     PFN_D3D11_CREATE_DEVICE createD3D;
 414     IDXGIAdapter           *pAdapter = NULL;
 415     ID3D10Multithread      *pMultithread;
 416     UINT creationFlags = D3D11_CREATE_DEVICE_VIDEO_SUPPORT;
 417
 418     if (device) {
 419         PFN_CREATE_DXGI_FACTORY mCreateDXGIFactory;
 420         HMODULE dxgilib = LoadLibrary("dxgi.dll");
 421         if (!dxgilib)
 422             return AVERROR_UNKNOWN;
 423
 424         mCreateDXGIFactory = (PFN_CREATE_DXGI_FACTORY) GetProcAddress(dxgilib, "CreateDXGIFactory");
 425         if (mCreateDXGIFactory) {
 426             IDXGIFactory2 *pDXGIFactory;
 427             hr = mCreateDXGIFactory(&IID_IDXGIFactory2, (void **)&pDXGIFactory);
 428             if (SUCCEEDED(hr)) {
 429                 int adapter = atoi(device);
 430                 if (FAILED(IDXGIFactory2_EnumAdapters(pDXGIFactory, adapter, &pAdapter)))
 431                     pAdapter = NULL;
 432                 IDXGIFactory2_Release(pDXGIFactory);
 433             }
 434         }
 435         FreeLibrary(dxgilib);
 436     }
 437
 438     // We let this "leak" - this is fine, as unloading has no great benefit, and
 439     // Windows will mark a DLL as loaded forever if its internal refcount overflows
 440     // from too many LoadLibrary calls.
 441     d3dlib = LoadLibrary("d3d11.dll");
 442     if (!d3dlib) {
 443         av_log(ctx, AV_LOG_ERROR, "Failed to load D3D11 library\n");
 444         return AVERROR_UNKNOWN;
 445     }
 446
 447     createD3D = (PFN_D3D11_CREATE_DEVICE) GetProcAddress(d3dlib, "D3D11CreateDevice");
 448     if (!createD3D) {
 449         av_log(ctx, AV_LOG_ERROR, "Failed to locate D3D11CreateDevice\n");
 450         return AVERROR_UNKNOWN;
 451     }
 452
 453     hr = createD3D(pAdapter, pAdapter ? D3D_DRIVER_TYPE_UNKNOWN : D3D_DRIVER_TYPE_HARDWARE, NULL, creationFlags, NULL, 0,
 454                    D3D11_SDK_VERSION, &device_hwctx->device, NULL, NULL);
 455     if (pAdapter)
 456         IDXGIAdapter_Release(pAdapter);
 457     if (FAILED(hr)) {
 458         av_log(ctx, AV_LOG_ERROR, "Failed to create Direct3D device (%lx)\n", (long)hr);
 459         return AVERROR_UNKNOWN;
 460     }
 461
 462     hr = ID3D11Device_QueryInterface(device_hwctx->device, &IID_ID3D10Multithread, (void **)&pMultithread);
 463     if (SUCCEEDED(hr)) {
 464         ID3D10Multithread_SetMultithreadProtected(pMultithread, TRUE);
 465         ID3D10Multithread_Release(pMultithread);
 466     }
 467
 468     return 0;
 469 }
 470
 471 const HWContextType ff_hwcontext_type_d3d11va = {
 472     .type                 = AV_HWDEVICE_TYPE_D3D11VA,
 473     .name                 = "D3D11VA",
 474
 475     .device_hwctx_size    = sizeof(AVD3D11VADeviceContext),
 476     .frames_hwctx_size    = sizeof(AVD3D11VAFramesContext),
 477     .frames_priv_size     = sizeof(D3D11VAFramesContext),
 478
 479     .device_create        = d3d11va_device_create,
 480     .device_init          = d3d11va_device_init,
 481     .device_uninit        = d3d11va_device_uninit,
 482     .frames_init          = d3d11va_frames_init,
 483     .frames_uninit        = d3d11va_frames_uninit,
 484     .frames_get_buffer    = d3d11va_get_buffer,
 485     .transfer_get_formats = d3d11va_transfer_get_formats,
 486     .transfer_data_to     = d3d11va_transfer_data,
 487     .transfer_data_from   = d3d11va_transfer_data,
 488
 489     .pix_fmts             = (const enum AVPixelFormat[]){ AV_PIX_FMT_D3D11, AV_PIX_FMT_NONE },
 490 };