[libav.git] / libavutil / hwcontext_dxva2.c

/*
 * This file is part of Libav.
 *
 * Libav is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * Libav is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with Libav; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <windows.h>

#if !defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600
#undef _WIN32_WINNT
#define _WIN32_WINNT 0x0600
#endif
#define DXVA2API_USE_BITFIELDS
#define COBJMACROS

#include <d3d9.h>
#include <dxva2api.h>
#include <initguid.h>

#include "common.h"
#include "hwcontext.h"
#include "hwcontext_dxva2.h"
#include "hwcontext_internal.h"
#include "imgutils.h"
#include "pixdesc.h"
#include "pixfmt.h"

typedef IDirect3D9* WINAPI pDirect3DCreate9(UINT);
typedef HRESULT WINAPI pCreateDeviceManager9(UINT *, IDirect3DDeviceManager9 **);

typedef struct DXVA2Mapping {
    uint32_t palette_dummy[256];
} DXVA2Mapping;

typedef struct DXVA2FramesContext {
    IDirect3DSurface9 **surfaces_internal;
    int              nb_surfaces_used;

    HANDLE  device_handle;
    IDirectXVideoAccelerationService *service;

    D3DFORMAT format;
} DXVA2FramesContext;

typedef struct DXVA2DevicePriv {
    HMODULE d3dlib;
    HMODULE dxva2lib;

    HANDLE device_handle;

    IDirect3D9       *d3d9;
    IDirect3DDevice9 *d3d9device;
} DXVA2DevicePriv;

static const struct {
    D3DFORMAT d3d_format;
    enum AVPixelFormat pix_fmt;
} supported_formats[] = {
    { MKTAG('N', 'V', '1', '2'), AV_PIX_FMT_NV12 },
    { MKTAG('P', '0', '1', '0'), AV_PIX_FMT_P010 },
    { D3DFMT_P8,                 AV_PIX_FMT_PAL8 },
};

DEFINE_GUID(video_decoder_service,   0xfc51a551, 0xd5e7, 0x11d9, 0xaf, 0x55, 0x00, 0x05, 0x4e, 0x43, 0xff, 0x02);
DEFINE_GUID(video_processor_service, 0xfc51a552, 0xd5e7, 0x11d9, 0xaf, 0x55, 0x00, 0x05, 0x4e, 0x43, 0xff, 0x02);

static void dxva2_frames_uninit(AVHWFramesContext *ctx)
{
    AVDXVA2DeviceContext *device_hwctx = ctx->device_ctx->hwctx;
    AVDXVA2FramesContext *frames_hwctx = ctx->hwctx;
    DXVA2FramesContext *s = ctx->internal->priv;
    int i;

    if (frames_hwctx->decoder_to_release)
        IDirectXVideoDecoder_Release(frames_hwctx->decoder_to_release);

    if (s->surfaces_internal) {
        for (i = 0; i < frames_hwctx->nb_surfaces; i++) {
            if (s->surfaces_internal[i])
                IDirect3DSurface9_Release(s->surfaces_internal[i]);
        }
    }
    av_freep(&s->surfaces_internal);

    if (s->service) {
        IDirectXVideoAccelerationService_Release(s->service);
        s->service = NULL;
    }

    if (s->device_handle != INVALID_HANDLE_VALUE) {
        IDirect3DDeviceManager9_CloseDeviceHandle(device_hwctx->devmgr, s->device_handle);
        s->device_handle = INVALID_HANDLE_VALUE;
    }
}

static AVBufferRef *dxva2_pool_alloc(void *opaque, int size)
{
    AVHWFramesContext      *ctx = (AVHWFramesContext*)opaque;
    DXVA2FramesContext       *s = ctx->internal->priv;
    AVDXVA2FramesContext *hwctx = ctx->hwctx;

    if (s->nb_surfaces_used < hwctx->nb_surfaces) {
        s->nb_surfaces_used++;
        return av_buffer_create((uint8_t*)s->surfaces_internal[s->nb_surfaces_used - 1],
                                sizeof(*hwctx->surfaces), NULL, 0, 0);
    }

    return NULL;
}

static int dxva2_init_pool(AVHWFramesContext *ctx)
{
    AVDXVA2FramesContext *frames_hwctx = ctx->hwctx;
    AVDXVA2DeviceContext *device_hwctx = ctx->device_ctx->hwctx;
    DXVA2FramesContext              *s = ctx->internal->priv;
    int decode = (frames_hwctx->surface_type == DXVA2_VideoDecoderRenderTarget);

    int i;
    HRESULT hr;

    if (ctx->initial_pool_size <= 0)
        return 0;

    hr = IDirect3DDeviceManager9_OpenDeviceHandle(device_hwctx->devmgr, &s->device_handle);
    if (FAILED(hr)) {
        av_log(ctx, AV_LOG_ERROR, "Failed to open device handle\n");
        return AVERROR_UNKNOWN;
    }

    hr = IDirect3DDeviceManager9_GetVideoService(device_hwctx->devmgr,
                                                 s->device_handle,
                                                 decode ? &video_decoder_service : &video_processor_service,
                                                 (void **)&s->service);
    if (FAILED(hr)) {
        av_log(ctx, AV_LOG_ERROR, "Failed to create the video service\n");
        return AVERROR_UNKNOWN;
    }

    for (i = 0; i < FF_ARRAY_ELEMS(supported_formats); i++) {
        if (ctx->sw_format == supported_formats[i].pix_fmt) {
            s->format = supported_formats[i].d3d_format;
            break;
        }
    }
    if (i == FF_ARRAY_ELEMS(supported_formats)) {
        av_log(ctx, AV_LOG_ERROR, "Unsupported pixel format: %s\n",
               av_get_pix_fmt_name(ctx->sw_format));
        return AVERROR(EINVAL);
    }

    s->surfaces_internal = av_mallocz_array(ctx->initial_pool_size,
                                            sizeof(*s->surfaces_internal));
    if (!s->surfaces_internal)
        return AVERROR(ENOMEM);

    hr = IDirectXVideoAccelerationService_CreateSurface(s->service,
                                                        ctx->width, ctx->height,
                                                        ctx->initial_pool_size - 1,
                                                        s->format, D3DPOOL_DEFAULT, 0,
                                                        frames_hwctx->surface_type,
                                                        s->surfaces_internal, NULL);
    if (FAILED(hr)) {
        av_log(ctx, AV_LOG_ERROR, "Could not create the surfaces\n");
        return AVERROR_UNKNOWN;
    }

    ctx->internal->pool_internal = av_buffer_pool_init2(sizeof(*s->surfaces_internal),
                                                        ctx, dxva2_pool_alloc, NULL);
    if (!ctx->internal->pool_internal)
        return AVERROR(ENOMEM);

    frames_hwctx->surfaces    = s->surfaces_internal;
    frames_hwctx->nb_surfaces = ctx->initial_pool_size;

    return 0;
}

static int dxva2_frames_init(AVHWFramesContext *ctx)
{
    AVDXVA2FramesContext *hwctx = ctx->hwctx;
    DXVA2FramesContext       *s = ctx->internal->priv;
    int ret;

    if (hwctx->surface_type != DXVA2_VideoDecoderRenderTarget &&
        hwctx->surface_type != DXVA2_VideoProcessorRenderTarget) {
        av_log(ctx, AV_LOG_ERROR, "Unknown surface type: %lu\n",
               hwctx->surface_type);
        return AVERROR(EINVAL);
    }

    s->device_handle = INVALID_HANDLE_VALUE;

    /* init the frame pool if the caller didn't provide one */
    if (!ctx->pool) {
        ret = dxva2_init_pool(ctx);
        if (ret < 0) {
            av_log(ctx, AV_LOG_ERROR, "Error creating an internal frame pool\n");
            return ret;
        }
    }

    return 0;
}

static int dxva2_get_buffer(AVHWFramesContext *ctx, AVFrame *frame)
{
    frame->buf[0] = av_buffer_pool_get(ctx->pool);
    if (!frame->buf[0])
        return AVERROR(ENOMEM);

    frame->data[3] = frame->buf[0]->data;
    frame->format  = AV_PIX_FMT_DXVA2_VLD;
    frame->width   = ctx->width;
    frame->height  = ctx->height;

    return 0;
}

static int dxva2_transfer_get_formats(AVHWFramesContext *ctx,
                                      enum AVHWFrameTransferDirection dir,
                                      enum AVPixelFormat **formats)
{
    enum AVPixelFormat *fmts;

    fmts = av_malloc_array(2, sizeof(*fmts));
    if (!fmts)
        return AVERROR(ENOMEM);

    fmts[0] = ctx->sw_format;
    fmts[1] = AV_PIX_FMT_NONE;

    *formats = fmts;

    return 0;
}

static void dxva2_unmap_frame(AVHWFramesContext *ctx, HWMapDescriptor *hwmap)
{
    IDirect3DSurface9 *surface = (IDirect3DSurface9*)hwmap->source->data[3];
    IDirect3DSurface9_UnlockRect(surface);
    av_freep(&hwmap->priv);
}

static int dxva2_map_frame(AVHWFramesContext *ctx, AVFrame *dst, const AVFrame *src,
                           int flags)
{
    IDirect3DSurface9 *surface = (IDirect3DSurface9*)src->data[3];
    DXVA2Mapping      *map;
    D3DSURFACE_DESC    surfaceDesc;
    D3DLOCKED_RECT     LockedRect;
    HRESULT            hr;
    int i, err, nb_planes;

    nb_planes = av_pix_fmt_count_planes(dst->format);

    hr = IDirect3DSurface9_GetDesc(surface, &surfaceDesc);
    if (FAILED(hr)) {
        av_log(ctx, AV_LOG_ERROR, "Error getting a surface description\n");
        return AVERROR_UNKNOWN;
    }

    hr = IDirect3DSurface9_LockRect(surface, &LockedRect, NULL,
                                    flags & AV_HWFRAME_MAP_READ ? D3DLOCK_READONLY : D3DLOCK_DISCARD);
    if (FAILED(hr)) {
        av_log(ctx, AV_LOG_ERROR, "Unable to lock DXVA2 surface\n");
        return AVERROR_UNKNOWN;
    }

    map = av_mallocz(sizeof(*map));
    if (!map)
        goto fail;

    err = ff_hwframe_map_create(src->hw_frames_ctx, dst, src,
                                dxva2_unmap_frame, map);
    if (err < 0) {
        av_freep(&map);
        goto fail;
    }

    for (i = 0; i < nb_planes; i++)
        dst->linesize[i] = LockedRect.Pitch;

    av_image_fill_pointers(dst->data, dst->format, surfaceDesc.Height,
                           (uint8_t*)LockedRect.pBits, dst->linesize);

    if (dst->format == AV_PIX_FMT_PAL8)
        dst->data[1] = (uint8_t*)map->palette_dummy;

    return 0;
fail:
    IDirect3DSurface9_UnlockRect(surface);
    return err;
}

static int dxva2_transfer_data(AVHWFramesContext *ctx, AVFrame *dst,
                               const AVFrame *src)
{
    int download = !!src->hw_frames_ctx;

    AVFrame *map;
    int ret, i;

    map = av_frame_alloc();
    if (!map)
        return AVERROR(ENOMEM);
    map->format = dst->format;

    ret = dxva2_map_frame(ctx, map, download ? src : dst,
                          download ? AV_HWFRAME_MAP_READ : AV_HWFRAME_MAP_WRITE);
    if (ret < 0)
        goto fail;

    if (download) {
        ptrdiff_t src_linesize[4], dst_linesize[4];
        for (i = 0; i < 4; i++) {
            dst_linesize[i] = dst->linesize[i];
            src_linesize[i] = map->linesize[i];
        }
        av_image_copy_uc_from(dst->data, dst_linesize, map->data, src_linesize,
                              ctx->sw_format, src->width, src->height);
    } else {
        av_image_copy(map->data, map->linesize, src->data, src->linesize,
                      ctx->sw_format, src->width, src->height);
    }

fail:
    av_frame_free(&map);
    return ret;
}

static int dxva2_map_from(AVHWFramesContext *ctx,
                          AVFrame *dst, const AVFrame *src, int flags)
{
    int err;

    if (dst->format != AV_PIX_FMT_NONE && dst->format != ctx->sw_format)
        return AVERROR(ENOSYS);
    dst->format = ctx->sw_format;

    err = dxva2_map_frame(ctx, dst, src, flags);
    if (err < 0)
        return err;

    err = av_frame_copy_props(dst, src);
    if (err < 0)
        return err;

    return 0;
}

static void dxva2_device_free(AVHWDeviceContext *ctx)
{
    AVDXVA2DeviceContext *hwctx = ctx->hwctx;
    DXVA2DevicePriv       *priv = ctx->user_opaque;

    if (hwctx->devmgr && priv->device_handle != INVALID_HANDLE_VALUE)
        IDirect3DDeviceManager9_CloseDeviceHandle(hwctx->devmgr, priv->device_handle);

    if (hwctx->devmgr)
        IDirect3DDeviceManager9_Release(hwctx->devmgr);

    if (priv->d3d9device)
        IDirect3DDevice9_Release(priv->d3d9device);

    if (priv->d3d9)
        IDirect3D9_Release(priv->d3d9);

    if (priv->d3dlib)
        FreeLibrary(priv->d3dlib);

    if (priv->dxva2lib)
        FreeLibrary(priv->dxva2lib);

    av_freep(&ctx->user_opaque);
}

static int dxva2_device_create(AVHWDeviceContext *ctx, const char *device,
                               AVDictionary *opts, int flags)
{
    AVDXVA2DeviceContext *hwctx = ctx->hwctx;
    DXVA2DevicePriv *priv;

    pDirect3DCreate9 *createD3D = NULL;
    pCreateDeviceManager9 *createDeviceManager = NULL;
    D3DPRESENT_PARAMETERS d3dpp = {0};
    D3DDISPLAYMODE        d3ddm;
    unsigned resetToken = 0;
    UINT adapter = D3DADAPTER_DEFAULT;
    HRESULT hr;

    if (device)
        adapter = atoi(device);

    priv = av_mallocz(sizeof(*priv));
    if (!priv)
        return AVERROR(ENOMEM);

    ctx->user_opaque = priv;
    ctx->free        = dxva2_device_free;

    priv->device_handle = INVALID_HANDLE_VALUE;

    priv->d3dlib = LoadLibrary("d3d9.dll");
    if (!priv->d3dlib) {
        av_log(ctx, AV_LOG_ERROR, "Failed to load D3D9 library\n");
        return AVERROR_UNKNOWN;
    }
    priv->dxva2lib = LoadLibrary("dxva2.dll");
    if (!priv->dxva2lib) {
        av_log(ctx, AV_LOG_ERROR, "Failed to load DXVA2 library\n");
        return AVERROR_UNKNOWN;
    }

    createD3D = (pDirect3DCreate9 *)GetProcAddress(priv->d3dlib, "Direct3DCreate9");
    if (!createD3D) {
        av_log(ctx, AV_LOG_ERROR, "Failed to locate Direct3DCreate9\n");
        return AVERROR_UNKNOWN;
    }
    createDeviceManager = (pCreateDeviceManager9 *)GetProcAddress(priv->dxva2lib,
                                                                  "DXVA2CreateDirect3DDeviceManager9");
    if (!createDeviceManager) {
        av_log(ctx, AV_LOG_ERROR, "Failed to locate DXVA2CreateDirect3DDeviceManager9\n");
        return AVERROR_UNKNOWN;
    }

    priv->d3d9 = createD3D(D3D_SDK_VERSION);
    if (!priv->d3d9) {
        av_log(ctx, AV_LOG_ERROR, "Failed to create IDirect3D object\n");
        return AVERROR_UNKNOWN;
    }

    IDirect3D9_GetAdapterDisplayMode(priv->d3d9, adapter, &d3ddm);
    d3dpp.Windowed         = TRUE;
    d3dpp.BackBufferWidth  = 640;
    d3dpp.BackBufferHeight = 480;
    d3dpp.BackBufferCount  = 0;
    d3dpp.BackBufferFormat = d3ddm.Format;
    d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
    d3dpp.Flags            = D3DPRESENTFLAG_VIDEO;

    hr = IDirect3D9_CreateDevice(priv->d3d9, adapter, D3DDEVTYPE_HAL, GetShellWindow(),
                                 D3DCREATE_SOFTWARE_VERTEXPROCESSING | D3DCREATE_MULTITHREADED | D3DCREATE_FPU_PRESERVE,
                                 &d3dpp, &priv->d3d9device);
    if (FAILED(hr)) {
        av_log(ctx, AV_LOG_ERROR, "Failed to create Direct3D device\n");
        return AVERROR_UNKNOWN;
    }

    hr = createDeviceManager(&resetToken, &hwctx->devmgr);
    if (FAILED(hr)) {
        av_log(ctx, AV_LOG_ERROR, "Failed to create Direct3D device manager\n");
        return AVERROR_UNKNOWN;
    }

    hr = IDirect3DDeviceManager9_ResetDevice(hwctx->devmgr, priv->d3d9device, resetToken);
    if (FAILED(hr)) {
        av_log(ctx, AV_LOG_ERROR, "Failed to bind Direct3D device to device manager\n");
        return AVERROR_UNKNOWN;
    }

    hr = IDirect3DDeviceManager9_OpenDeviceHandle(hwctx->devmgr, &priv->device_handle);
    if (FAILED(hr)) {
        av_log(ctx, AV_LOG_ERROR, "Failed to open device handle\n");
        return AVERROR_UNKNOWN;
    }

    return 0;
}

const HWContextType ff_hwcontext_type_dxva2 = {
    .type                 = AV_HWDEVICE_TYPE_DXVA2,
    .name                 = "DXVA2",

    .device_hwctx_size    = sizeof(AVDXVA2DeviceContext),
    .frames_hwctx_size    = sizeof(AVDXVA2FramesContext),
    .frames_priv_size     = sizeof(DXVA2FramesContext),

    .device_create        = dxva2_device_create,
    .frames_init          = dxva2_frames_init,
    .frames_uninit        = dxva2_frames_uninit,
    .frames_get_buffer    = dxva2_get_buffer,
    .transfer_get_formats = dxva2_transfer_get_formats,
    .transfer_data_to     = dxva2_transfer_data,
    .transfer_data_from   = dxva2_transfer_data,
    .map_from             = dxva2_map_from,

    .pix_fmts             = (const enum AVPixelFormat[]){ AV_PIX_FMT_DXVA2_VLD, AV_PIX_FMT_NONE },
};
Commit	Line	Data
c46db38c AK	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 DXVA2API_USE_BITFIELDS
	26	#define COBJMACROS
	27
	28	#include <d3d9.h>
	29	#include <dxva2api.h>
	30	#include <initguid.h>
	31
	32	#include "common.h"
	33	#include "hwcontext.h"
	34	#include "hwcontext_dxva2.h"
	35	#include "hwcontext_internal.h"
	36	#include "imgutils.h"
	37	#include "pixdesc.h"
	38	#include "pixfmt.h"
	39
8e70385a AK	40	typedef IDirect3D9* WINAPI pDirect3DCreate9(UINT);
	41	typedef HRESULT WINAPI pCreateDeviceManager9(UINT , IDirect3DDeviceManager9 *);
	42
10065d93 AK	43	typedef struct DXVA2Mapping {
	44	uint32_t palette_dummy[256];
	45	} DXVA2Mapping;
	46
c46db38c AK	47	typedef struct DXVA2FramesContext {
	48	IDirect3DSurface9 **surfaces_internal;
	49	int nb_surfaces_used;
	50
	51	HANDLE device_handle;
	52	IDirectXVideoAccelerationService *service;
	53
	54	D3DFORMAT format;
	55	} DXVA2FramesContext;
	56
8e70385a AK	57	typedef struct DXVA2DevicePriv {
	58	HMODULE d3dlib;
	59	HMODULE dxva2lib;
	60
	61	HANDLE device_handle;
	62
	63	IDirect3D9 *d3d9;
	64	IDirect3DDevice9 *d3d9device;
	65	} DXVA2DevicePriv;
	66
c46db38c AK	67	static const struct {
	68	D3DFORMAT d3d_format;
	69	enum AVPixelFormat pix_fmt;
	70	} supported_formats[] = {
	71	{ MKTAG('N', 'V', '1', '2'), AV_PIX_FMT_NV12 },
2ef87815	72	{ MKTAG('P', '0', '1', '0'), AV_PIX_FMT_P010 },
10065d93	73	{ D3DFMT_P8, AV_PIX_FMT_PAL8 },
c46db38c AK	74	};
	75
	76	DEFINE_GUID(video_decoder_service, 0xfc51a551, 0xd5e7, 0x11d9, 0xaf, 0x55, 0x00, 0x05, 0x4e, 0x43, 0xff, 0x02);
	77	DEFINE_GUID(video_processor_service, 0xfc51a552, 0xd5e7, 0x11d9, 0xaf, 0x55, 0x00, 0x05, 0x4e, 0x43, 0xff, 0x02);
	78
	79	static void dxva2_frames_uninit(AVHWFramesContext *ctx)
	80	{
	81	AVDXVA2DeviceContext *device_hwctx = ctx->device_ctx->hwctx;
	82	AVDXVA2FramesContext *frames_hwctx = ctx->hwctx;
	83	DXVA2FramesContext *s = ctx->internal->priv;
	84	int i;
	85
	86	if (frames_hwctx->decoder_to_release)
	87	IDirectXVideoDecoder_Release(frames_hwctx->decoder_to_release);
	88
	89	if (s->surfaces_internal) {
	90	for (i = 0; i < frames_hwctx->nb_surfaces; i++) {
	91	if (s->surfaces_internal[i])
	92	IDirect3DSurface9_Release(s->surfaces_internal[i]);
	93	}
	94	}
	95	av_freep(&s->surfaces_internal);
	96
	97	if (s->service) {
	98	IDirectXVideoAccelerationService_Release(s->service);
	99	s->service = NULL;
	100	}
	101
	102	if (s->device_handle != INVALID_HANDLE_VALUE) {
	103	IDirect3DDeviceManager9_CloseDeviceHandle(device_hwctx->devmgr, s->device_handle);
	104	s->device_handle = INVALID_HANDLE_VALUE;
	105	}
	106	}
	107
	108	static AVBufferRef dxva2_pool_alloc(void opaque, int size)
	109	{
	110	AVHWFramesContext ctx = (AVHWFramesContext)opaque;
	111	DXVA2FramesContext *s = ctx->internal->priv;
	112	AVDXVA2FramesContext *hwctx = ctx->hwctx;
	113
	114	if (s->nb_surfaces_used < hwctx->nb_surfaces) {
	115	s->nb_surfaces_used++;
	116	return av_buffer_create((uint8_t*)s->surfaces_internal[s->nb_surfaces_used - 1],
	117	sizeof(*hwctx->surfaces), NULL, 0, 0);
	118	}
	119
	120	return NULL;
	121	}
	122
	123	static int dxva2_init_pool(AVHWFramesContext *ctx)
	124	{
	125	AVDXVA2FramesContext *frames_hwctx = ctx->hwctx;
	126	AVDXVA2DeviceContext *device_hwctx = ctx->device_ctx->hwctx;
	127	DXVA2FramesContext *s = ctx->internal->priv;
	128	int decode = (frames_hwctx->surface_type == DXVA2_VideoDecoderRenderTarget);
	129
	130	int i;
	131	HRESULT hr;
	132
	133	if (ctx->initial_pool_size <= 0)
	134	return 0;
	135
	136	hr = IDirect3DDeviceManager9_OpenDeviceHandle(device_hwctx->devmgr, &s->device_handle);
	137	if (FAILED(hr)) {
138	av_log(ctx, AV_LOG_ERROR, "Failed to open device handle\n");
139	return AVERROR_UNKNOWN;
140	}
141
142	hr = IDirect3DDeviceManager9_GetVideoService(device_hwctx->devmgr,
143	s->device_handle,
144	decode ? &video_decoder_service : &video_processor_service,
145	(void **)&s->service);
146	if (FAILED(hr)) {
147	av_log(ctx, AV_LOG_ERROR, "Failed to create the video service\n");
148	return AVERROR_UNKNOWN;
149	}
150
151	for (i = 0; i < FF_ARRAY_ELEMS(supported_formats); i++) {
152	if (ctx->sw_format == supported_formats[i].pix_fmt) {
153	s->format = supported_formats[i].d3d_format;
154	break;
155	}
156	}
157	if (i == FF_ARRAY_ELEMS(supported_formats)) {
158	av_log(ctx, AV_LOG_ERROR, "Unsupported pixel format: %s\n",
159	av_get_pix_fmt_name(ctx->sw_format));
160	return AVERROR(EINVAL);
161	}
162
163	s->surfaces_internal = av_mallocz_array(ctx->initial_pool_size,
164	sizeof(*s->surfaces_internal));
165	if (!s->surfaces_internal)
166	return AVERROR(ENOMEM);
167
168	hr = IDirectXVideoAccelerationService_CreateSurface(s->service,
169	ctx->width, ctx->height,
170	ctx->initial_pool_size - 1,
171	s->format, D3DPOOL_DEFAULT, 0,
172	frames_hwctx->surface_type,
173	s->surfaces_internal, NULL);
174	if (FAILED(hr)) {
175	av_log(ctx, AV_LOG_ERROR, "Could not create the surfaces\n");
176	return AVERROR_UNKNOWN;
177	}
178
179	ctx->internal->pool_internal = av_buffer_pool_init2(sizeof(*s->surfaces_internal),
180	ctx, dxva2_pool_alloc, NULL);
181	if (!ctx->internal->pool_internal)
182	return AVERROR(ENOMEM);
183
184	frames_hwctx->surfaces = s->surfaces_internal;
185	frames_hwctx->nb_surfaces = ctx->initial_pool_size;
186
187	return 0;
188	}
189
190	static int dxva2_frames_init(AVHWFramesContext *ctx)
191	{
192	AVDXVA2FramesContext *hwctx = ctx->hwctx;
193	DXVA2FramesContext *s = ctx->internal->priv;
194	int ret;
195
196	if (hwctx->surface_type != DXVA2_VideoDecoderRenderTarget &&
197	hwctx->surface_type != DXVA2_VideoProcessorRenderTarget) {
198	av_log(ctx, AV_LOG_ERROR, "Unknown surface type: %lu\n",
199	hwctx->surface_type);
200	return AVERROR(EINVAL);
201	}
202
203	s->device_handle = INVALID_HANDLE_VALUE;
204
205	/* init the frame pool if the caller didn't provide one */
206	if (!ctx->pool) {
207	ret = dxva2_init_pool(ctx);
208	if (ret < 0) {
209	av_log(ctx, AV_LOG_ERROR, "Error creating an internal frame pool\n");
210	return ret;
211	}
212	}
213
214	return 0;
215	}
216
217	static int dxva2_get_buffer(AVHWFramesContext ctx, AVFrame frame)
218	{
219	frame->buf[0] = av_buffer_pool_get(ctx->pool);
220	if (!frame->buf[0])
221	return AVERROR(ENOMEM);
222
223	frame->data[3] = frame->buf[0]->data;
224	frame->format = AV_PIX_FMT_DXVA2_VLD;
225	frame->width = ctx->width;
226	frame->height = ctx->height;
227
228	return 0;
229	}
230
231	static int dxva2_transfer_get_formats(AVHWFramesContext *ctx,
232	enum AVHWFrameTransferDirection dir,
233	enum AVPixelFormat **formats)
234	{
235	enum AVPixelFormat *fmts;
236
237	fmts = av_malloc_array(2, sizeof(*fmts));
238	if (!fmts)
239	return AVERROR(ENOMEM);
240
241	fmts[0] = ctx->sw_format;
242	fmts[1] = AV_PIX_FMT_NONE;
243
244	*formats = fmts;
245
246	return 0;
247	}
248
91097376 AK	249	static void dxva2_unmap_frame(AVHWFramesContext ctx, HWMapDescriptor hwmap)
	250	{
	251	IDirect3DSurface9 surface = (IDirect3DSurface9)hwmap->source->data[3];
	252	IDirect3DSurface9_UnlockRect(surface);
10065d93	253	av_freep(&hwmap->priv);
91097376 AK	254	}
	255
	256	static int dxva2_map_frame(AVHWFramesContext ctx, AVFrame dst, const AVFrame *src,
	257	int flags)
c46db38c	258	{
91097376	259	IDirect3DSurface9 surface = (IDirect3DSurface9)src->data[3];
10065d93	260	DXVA2Mapping *map;
c46db38c AK	261	D3DSURFACE_DESC surfaceDesc;
	262	D3DLOCKED_RECT LockedRect;
	263	HRESULT hr;
91097376	264	int i, err, nb_planes;
c46db38c	265
91097376	266	nb_planes = av_pix_fmt_count_planes(dst->format);
c46db38c AK	267
	268	hr = IDirect3DSurface9_GetDesc(surface, &surfaceDesc);
	269	if (FAILED(hr)) {
	270	av_log(ctx, AV_LOG_ERROR, "Error getting a surface description\n");
	271	return AVERROR_UNKNOWN;
	272	}
	273
	274	hr = IDirect3DSurface9_LockRect(surface, &LockedRect, NULL,
91097376	275	flags & AV_HWFRAME_MAP_READ ? D3DLOCK_READONLY : D3DLOCK_DISCARD);
c46db38c AK	276	if (FAILED(hr)) {
	277	av_log(ctx, AV_LOG_ERROR, "Unable to lock DXVA2 surface\n");
	278	return AVERROR_UNKNOWN;
	279	}
	280
10065d93 AK	281	map = av_mallocz(sizeof(*map));
	282	if (!map)
	283	goto fail;
	284
91097376	285	err = ff_hwframe_map_create(src->hw_frames_ctx, dst, src,
10065d93 AK	286	dxva2_unmap_frame, map);
	287	if (err < 0) {
	288	av_freep(&map);
91097376	289	goto fail;
10065d93	290	}
91097376 AK	291
	292	for (i = 0; i < nb_planes; i++)
	293	dst->linesize[i] = LockedRect.Pitch;
	294
	295	av_image_fill_pointers(dst->data, dst->format, surfaceDesc.Height,
	296	(uint8_t*)LockedRect.pBits, dst->linesize);
	297
10065d93 AK	298	if (dst->format == AV_PIX_FMT_PAL8)
	299	dst->data[1] = (uint8_t*)map->palette_dummy;
	300
91097376 AK	301	return 0;
	302	fail:
	303	IDirect3DSurface9_UnlockRect(surface);
	304	return err;
	305	}
	306
	307	static int dxva2_transfer_data(AVHWFramesContext ctx, AVFrame dst,
	308	const AVFrame *src)
	309	{
	310	int download = !!src->hw_frames_ctx;
	311
	312	AVFrame *map;
	313	int ret, i;
2ef87815	314
91097376 AK	315	map = av_frame_alloc();
	316	if (!map)
	317	return AVERROR(ENOMEM);
	318	map->format = dst->format;
	319
	320	ret = dxva2_map_frame(ctx, map, download ? src : dst,
	321	download ? AV_HWFRAME_MAP_READ : AV_HWFRAME_MAP_WRITE);
	322	if (ret < 0)
	323	goto fail;
2ef87815	324
c46db38c	325	if (download) {
91097376	326	ptrdiff_t src_linesize[4], dst_linesize[4];
f01f7a78	327	for (i = 0; i < 4; i++) {
91097376 AK	328	dst_linesize[i] = dst->linesize[i];
91097376 AK	329	src_linesize[i] = map->linesize[i];
f01f7a78	330	}
91097376	331	av_image_copy_uc_from(dst->data, dst_linesize, map->data, src_linesize,
f01f7a78	332	ctx->sw_format, src->width, src->height);
c46db38c	333	} else {
91097376	334	av_image_copy(map->data, map->linesize, src->data, src->linesize,
2ef87815	335	ctx->sw_format, src->width, src->height);
c46db38c AK	336	}
c46db38c AK	337
91097376 AK	338	fail:
	339	av_frame_free(&map);
	340	return ret;
	341	}
	342
	343	static int dxva2_map_from(AVHWFramesContext *ctx,
	344	AVFrame dst, const AVFrame src, int flags)
	345	{
	346	int err;
	347
0d3176e3 AK	348	if (dst->format != AV_PIX_FMT_NONE && dst->format != ctx->sw_format)
	349	return AVERROR(ENOSYS);
	350	dst->format = ctx->sw_format;
	351
91097376 AK	352	err = dxva2_map_frame(ctx, dst, src, flags);
	353	if (err < 0)
	354	return err;
	355
	356	err = av_frame_copy_props(dst, src);
	357	if (err < 0)
	358	return err;
c46db38c AK	359
	360	return 0;
	361	}
	362
8e70385a AK	363	static void dxva2_device_free(AVHWDeviceContext *ctx)
	364	{
	365	AVDXVA2DeviceContext *hwctx = ctx->hwctx;
	366	DXVA2DevicePriv *priv = ctx->user_opaque;
	367
	368	if (hwctx->devmgr && priv->device_handle != INVALID_HANDLE_VALUE)
	369	IDirect3DDeviceManager9_CloseDeviceHandle(hwctx->devmgr, priv->device_handle);
	370
	371	if (hwctx->devmgr)
	372	IDirect3DDeviceManager9_Release(hwctx->devmgr);
	373
	374	if (priv->d3d9device)
	375	IDirect3DDevice9_Release(priv->d3d9device);
	376
	377	if (priv->d3d9)
	378	IDirect3D9_Release(priv->d3d9);
	379
	380	if (priv->d3dlib)
	381	FreeLibrary(priv->d3dlib);
	382
	383	if (priv->dxva2lib)
	384	FreeLibrary(priv->dxva2lib);
	385
	386	av_freep(&ctx->user_opaque);
	387	}
	388
	389	static int dxva2_device_create(AVHWDeviceContext ctx, const char device,
	390	AVDictionary *opts, int flags)
	391	{
	392	AVDXVA2DeviceContext *hwctx = ctx->hwctx;
	393	DXVA2DevicePriv *priv;
	394
	395	pDirect3DCreate9 *createD3D = NULL;
	396	pCreateDeviceManager9 *createDeviceManager = NULL;
	397	D3DPRESENT_PARAMETERS d3dpp = {0};
	398	D3DDISPLAYMODE d3ddm;
	399	unsigned resetToken = 0;
	400	UINT adapter = D3DADAPTER_DEFAULT;
	401	HRESULT hr;
	402
	403	if (device)
	404	adapter = atoi(device);
	405
	406	priv = av_mallocz(sizeof(*priv));
	407	if (!priv)
	408	return AVERROR(ENOMEM);
	409
	410	ctx->user_opaque = priv;
	411	ctx->free = dxva2_device_free;
	412
	413	priv->device_handle = INVALID_HANDLE_VALUE;
	414
	415	priv->d3dlib = LoadLibrary("d3d9.dll");
	416	if (!priv->d3dlib) {
	417	av_log(ctx, AV_LOG_ERROR, "Failed to load D3D9 library\n");
	418	return AVERROR_UNKNOWN;
	419	}
	420	priv->dxva2lib = LoadLibrary("dxva2.dll");
	421	if (!priv->dxva2lib) {
	422	av_log(ctx, AV_LOG_ERROR, "Failed to load DXVA2 library\n");
	423	return AVERROR_UNKNOWN;
	424	}
	425
	426	createD3D = (pDirect3DCreate9 *)GetProcAddress(priv->d3dlib, "Direct3DCreate9");
427	if (!createD3D) {
428	av_log(ctx, AV_LOG_ERROR, "Failed to locate Direct3DCreate9\n");
429	return AVERROR_UNKNOWN;
430	}
431	createDeviceManager = (pCreateDeviceManager9 *)GetProcAddress(priv->dxva2lib,
432	"DXVA2CreateDirect3DDeviceManager9");
433	if (!createDeviceManager) {
434	av_log(ctx, AV_LOG_ERROR, "Failed to locate DXVA2CreateDirect3DDeviceManager9\n");
435	return AVERROR_UNKNOWN;
436	}
437
438	priv->d3d9 = createD3D(D3D_SDK_VERSION);
439	if (!priv->d3d9) {
440	av_log(ctx, AV_LOG_ERROR, "Failed to create IDirect3D object\n");
441	return AVERROR_UNKNOWN;
442	}
443
444	IDirect3D9_GetAdapterDisplayMode(priv->d3d9, adapter, &d3ddm);
445	d3dpp.Windowed = TRUE;
446	d3dpp.BackBufferWidth = 640;
447	d3dpp.BackBufferHeight = 480;
448	d3dpp.BackBufferCount = 0;
449	d3dpp.BackBufferFormat = d3ddm.Format;
450	d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
451	d3dpp.Flags = D3DPRESENTFLAG_VIDEO;
452
453	hr = IDirect3D9_CreateDevice(priv->d3d9, adapter, D3DDEVTYPE_HAL, GetShellWindow(),
454	D3DCREATE_SOFTWARE_VERTEXPROCESSING \| D3DCREATE_MULTITHREADED \| D3DCREATE_FPU_PRESERVE,
455	&d3dpp, &priv->d3d9device);
456	if (FAILED(hr)) {
457	av_log(ctx, AV_LOG_ERROR, "Failed to create Direct3D device\n");
458	return AVERROR_UNKNOWN;
459	}
460
461	hr = createDeviceManager(&resetToken, &hwctx->devmgr);
462	if (FAILED(hr)) {
463	av_log(ctx, AV_LOG_ERROR, "Failed to create Direct3D device manager\n");
464	return AVERROR_UNKNOWN;
465	}
466
467	hr = IDirect3DDeviceManager9_ResetDevice(hwctx->devmgr, priv->d3d9device, resetToken);
468	if (FAILED(hr)) {
469	av_log(ctx, AV_LOG_ERROR, "Failed to bind Direct3D device to device manager\n");
470	return AVERROR_UNKNOWN;
471	}
472
473	hr = IDirect3DDeviceManager9_OpenDeviceHandle(hwctx->devmgr, &priv->device_handle);
474	if (FAILED(hr)) {
475	av_log(ctx, AV_LOG_ERROR, "Failed to open device handle\n");
476	return AVERROR_UNKNOWN;
477	}
478
479	return 0;
480	}
481
c46db38c AK	482	const HWContextType ff_hwcontext_type_dxva2 = {
	483	.type = AV_HWDEVICE_TYPE_DXVA2,
	484	.name = "DXVA2",
	485
	486	.device_hwctx_size = sizeof(AVDXVA2DeviceContext),
	487	.frames_hwctx_size = sizeof(AVDXVA2FramesContext),
	488	.frames_priv_size = sizeof(DXVA2FramesContext),
	489
8e70385a	490	.device_create = dxva2_device_create,
c46db38c AK	491	.frames_init = dxva2_frames_init,
	492	.frames_uninit = dxva2_frames_uninit,
	493	.frames_get_buffer = dxva2_get_buffer,
	494	.transfer_get_formats = dxva2_transfer_get_formats,
	495	.transfer_data_to = dxva2_transfer_data,
	496	.transfer_data_from = dxva2_transfer_data,
91097376	497	.map_from = dxva2_map_from,
c46db38c AK	498
	499	.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_DXVA2_VLD, AV_PIX_FMT_NONE },
	500	};