static void dxva2_destroy_decoder(struct lavc_ctx *s)
{
DXVA2Context *ctx = s->hwdec_priv;
int i;
if (ctx->surfaces) {
for (i = 0; i < ctx->num_surfaces; i++) {
if (ctx->surfaces[i])
IDirect3DSurface9_Release(ctx->surfaces[i]);
}
}
av_freep(&ctx->surfaces);
av_freep(&ctx->surface_infos);
ctx->num_surfaces = 0;
ctx->surface_age = 0;
if (ctx->decoder) {
IDirectXVideoDecoder_Release(ctx->decoder);
ctx->decoder = NULL;
}
}
static void
D3D_DestroyRenderer(SDL_Renderer * renderer)
{
D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
if (data) {
/* Release the render target */
if (data->defaultRenderTarget) {
IDirect3DSurface9_Release(data->defaultRenderTarget);
data->defaultRenderTarget = NULL;
}
if (data->currentRenderTarget != NULL) {
IDirect3DSurface9_Release(data->currentRenderTarget);
data->currentRenderTarget = NULL;
}
if (data->device) {
IDirect3DDevice9_Release(data->device);
}
if (data->d3d) {
IDirect3D9_Release(data->d3d);
ID3DXMatrixStack_Release(data->matrixStack);
SDL_UnloadObject(data->d3dDLL);
}
SDL_free(data);
}
SDL_free(renderer);
}
/**
\fn cleanup
\brief cleanup all display dependant stuff, called again before switching zoom and at exit
*/
bool dxvaRender::cleanup()
{
ADM_info("D3D cleanup\n");
if(scaler)
{
delete scaler;
scaler=NULL;
}
if(mySurface)
{
IDirect3DSurface9_Release(mySurface);
mySurface=NULL;
}
if(myYV12Surface)
{
IDirect3DSurface9_Release(myYV12Surface);
myYV12Surface=NULL;
}
#ifndef REUSE_DEVICE
if(d3dDevice)
{
IDirect3DDevice9_Release(d3dDevice);
d3dDevice=NULL;
}
#endif
if(videoBuffer)
{
delete [] videoBuffer;
videoBuffer=NULL;
}
return true;
}
/** @brief Destroy D3D Offscreen and Backbuffer surfaces.
*/
static void destroy_d3d_surfaces(void)
{
mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d>destroy_d3d_surfaces called.\n");
/* Let's destroy the old (if any) D3D Surfaces */
if (priv->locked_rect.pBits)
IDirect3DSurface9_UnlockRect(priv->d3d_surface);
priv->locked_rect.pBits = NULL;
if (priv->d3d_surface)
IDirect3DSurface9_Release(priv->d3d_surface);
priv->d3d_surface = NULL;
/* kill the OSD texture and its shadow copy */
if (priv->d3d_texture_osd)
IDirect3DTexture9_Release(priv->d3d_texture_osd);
priv->d3d_texture_osd = NULL;
if (priv->d3d_texture_system)
IDirect3DTexture9_Release(priv->d3d_texture_system);
priv->d3d_texture_system = NULL;
if (priv->d3d_backbuf)
IDirect3DSurface9_Release(priv->d3d_backbuf);
priv->d3d_backbuf = NULL;
}
static void device_state_release(struct device_state *state)
{
unsigned int i;
for (i = 0; i < state->num_render_targets; i++)
{
if (state->render_targets[i])
IDirect3DSurface9_Release(state->render_targets[i]);
}
HeapFree(GetProcessHeap(), 0, state->render_targets);
if (state->depth_stencil) IDirect3DSurface9_Release(state->depth_stencil);
}
static int
D3D_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
Uint32 format, void * pixels, int pitch)
{
D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
D3DSURFACE_DESC desc;
LPDIRECT3DSURFACE9 backBuffer;
LPDIRECT3DSURFACE9 surface;
RECT d3drect;
D3DLOCKED_RECT locked;
HRESULT result;
result = IDirect3DDevice9_GetBackBuffer(data->device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backBuffer);
if (FAILED(result)) {
return D3D_SetError("GetBackBuffer()", result);
}
result = IDirect3DSurface9_GetDesc(backBuffer, &desc);
if (FAILED(result)) {
IDirect3DSurface9_Release(backBuffer);
return D3D_SetError("GetDesc()", result);
}
result = IDirect3DDevice9_CreateOffscreenPlainSurface(data->device, desc.Width, desc.Height, desc.Format, D3DPOOL_SYSTEMMEM, &surface, NULL);
if (FAILED(result)) {
IDirect3DSurface9_Release(backBuffer);
return D3D_SetError("CreateOffscreenPlainSurface()", result);
}
result = IDirect3DDevice9_GetRenderTargetData(data->device, backBuffer, surface);
if (FAILED(result)) {
IDirect3DSurface9_Release(surface);
IDirect3DSurface9_Release(backBuffer);
return D3D_SetError("GetRenderTargetData()", result);
}
d3drect.left = rect->x;
d3drect.right = rect->x + rect->w;
d3drect.top = rect->y;
d3drect.bottom = rect->y + rect->h;
result = IDirect3DSurface9_LockRect(surface, &locked, &d3drect, D3DLOCK_READONLY);
if (FAILED(result)) {
IDirect3DSurface9_Release(surface);
IDirect3DSurface9_Release(backBuffer);
return D3D_SetError("LockRect()", result);
}
SDL_ConvertPixels(rect->w, rect->h,
D3DFMTToPixelFormat(desc.Format), locked.pBits, locked.Pitch,
format, pixels, pitch);
IDirect3DSurface9_UnlockRect(surface);
IDirect3DSurface9_Release(surface);
IDirect3DSurface9_Release(backBuffer);
return 0;
}
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 int
D3D_SetRenderTarget(SDL_Renderer * renderer, SDL_Texture * texture)
{
D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
D3D_TextureData *texturedata;
HRESULT result;
D3D_ActivateRenderer(renderer);
/* Release the previous render target if it wasn't the default one */
if (data->currentRenderTarget != NULL) {
IDirect3DSurface9_Release(data->currentRenderTarget);
data->currentRenderTarget = NULL;
}
if (texture == NULL) {
IDirect3DDevice9_SetRenderTarget(data->device, 0, data->defaultRenderTarget);
return 0;
}
texturedata = (D3D_TextureData *) texture->driverdata;
result = IDirect3DTexture9_GetSurfaceLevel(texturedata->texture, 0, &data->currentRenderTarget);
if(FAILED(result)) {
D3D_SetError("GetSurfaceLevel()", result);
return -1;
}
result = IDirect3DDevice9_SetRenderTarget(data->device, 0, data->currentRenderTarget);
if(FAILED(result)) {
D3D_SetError("SetRenderTarget()", result);
return -1;
}
return 0;
}
static int
D3D_Reset(SDL_Renderer * renderer)
{
D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
HRESULT result;
/* Release the default render target before reset */
if (data->defaultRenderTarget) {
IDirect3DSurface9_Release(data->defaultRenderTarget);
data->defaultRenderTarget = NULL;
}
result = IDirect3DDevice9_Reset(data->device, &data->pparams);
if (FAILED(result)) {
if (result == D3DERR_DEVICELOST) {
/* Don't worry about it, we'll reset later... */
return 0;
} else {
return D3D_SetError("Reset()", result);
}
}
IDirect3DDevice9_SetVertexShader(data->device, NULL);
IDirect3DDevice9_SetFVF(data->device,
D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1);
IDirect3DDevice9_SetRenderState(data->device, D3DRS_CULLMODE,
D3DCULL_NONE);
IDirect3DDevice9_SetRenderState(data->device, D3DRS_LIGHTING, FALSE);
IDirect3DDevice9_GetRenderTarget(data->device, 0, &data->defaultRenderTarget);
return 0;
}
ULONG WINAPI D3D9CB_DestroyDepthStencilSurface(IWineD3DSurface *pSurface) {
IDirect3DSurface9Impl* surfaceParent;
TRACE("(%p) call back\n", pSurface);
IWineD3DSurface_GetParent(pSurface, (IUnknown **) &surfaceParent);
surfaceParent->isImplicit = FALSE;
/* Surface had refcount of 0 GetParent addrefed to 1, so 1 Release is enough */
return IDirect3DSurface9_Release((IDirect3DSurface9*) surfaceParent);
}
static void DxDestroyVideoDecoder(vlc_va_dxva2_t *va)
{
if (va->decoder)
IDirectXVideoDecoder_Release(va->decoder);
va->decoder = NULL;
for (unsigned i = 0; i < va->surface_count; i++)
IDirect3DSurface9_Release(va->surface[i].d3d);
va->surface_count = 0;
}
HRESULT STDMETHODCALLTYPE IDirect3DDevice9_EndScene_Hook(IDirect3DDevice9* This) {
static unsigned count = 0;
auto ticks = []() {
LARGE_INTEGER value;
QueryPerformanceCounter(&value);
return KSCONVERT_PERFORMANCE_TIME(frequency, value);
}();
static auto start = [This, &ticks]() {
IDirect3DSurface9* renderTarget;
IDirect3DDevice9_GetRenderTarget(This, 0, &renderTarget);
IDirect3DSurface9_GetDesc(renderTarget, &desc);
IDirect3DSurface9_Release(renderTarget);
// quick hack, first 'ticks - start' is 1.
return ticks++;
}();
fps = static_cast<unsigned>(static_cast<ULONGLONG>(++count) * NANOSECONDS / (ticks - start));
FramePtr frame = Frame;
if (frame) {
IDirect3DSurface9* offsecreen;
check(TEXT("CreateOffscreenPlainSurface"), IDirect3DDevice9_CreateOffscreenPlainSurface(This, desc.Width, desc.Height, desc.Format, D3DPOOL_SYSTEMMEM, &offsecreen, nullptr));
{
IDirect3DSurface9* target;
check(TEXT("GetRenderTarget"), IDirect3DDevice9_GetRenderTarget(This, 0, &target));
#if 0
if (desc.MultiSampleType != D3DMULTISAMPLE_NONE) {
IDirect3DSurface9* resolved;
check(TEXT("CreateRenderTarget"), IDirect3DDevice9_CreateRenderTarget(This, desc.Width, desc.Height, desc.Format, D3DMULTISAMPLE_NONE, 0, false, &resolved, nullptr));
check(TEXT("StretchRect"), IDirect3DDevice9_StretchRect(This, target, nullptr, resolved, nullptr, D3DTEXF_NONE));
IDirect3DSurface9_Release(target);
target = resolved;
}
#endif
check(TEXT("GetRenderTargetData"), IDirect3DDevice9_GetRenderTargetData(This, target, offsecreen));
IDirect3DSurface9_Release(target);
}
frame(ticks, offsecreen);
IDirect3DSurface9_Release(offsecreen);
}
return IDirect3DDevice9_EndScene_Orig(This);
}
void video_device_release_dx9(video_canvas_t *canvas)
{
if (canvas->d3dsurface) {
IDirect3DSurface9_Release(canvas->d3dsurface);
canvas->d3dsurface = NULL;
}
if (canvas->d3ddev) {
IDirect3DDevice9_Release(canvas->d3ddev);
canvas->d3ddev = NULL;
}
}
static void dxva2_release_img(void *arg)
{
struct dxva2_surface *surface = arg;
if (surface->surface)
IDirect3DSurface9_Release(surface->surface);
if (surface->decoder)
IDirectXVideoDecoder_Release(surface->decoder);
talloc_free(surface);
}
static void hb_dx_destroy_video_decoder( hb_va_dxva2_t *dxva2 )
{
if( dxva2->decoder )
IDirectXVideoDecoder_Release( dxva2->decoder );
dxva2->decoder = NULL;
unsigned i;
for( i = 0; i<dxva2->surface_count; i++ )
IDirect3DSurface9_Release( dxva2->surface[i].d3d );
dxva2->surface_count = 0;
}
static void test_surface_get_container(IDirect3DDevice9 *device_ptr)
{
IDirect3DTexture9 *texture_ptr = 0;
IDirect3DSurface9 *surface_ptr = 0;
void *container_ptr;
HRESULT hr;
hr = IDirect3DDevice9_CreateTexture(device_ptr, 128, 128, 1, 0,
D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &texture_ptr, 0);
ok(SUCCEEDED(hr) && texture_ptr != NULL, "CreateTexture returned: hr %#lx, texture_ptr %p. "
"Expected hr %#lx, texture_ptr != %p\n", hr, texture_ptr, D3D_OK, NULL);
if (!texture_ptr || FAILED(hr)) goto cleanup;
hr = IDirect3DTexture9_GetSurfaceLevel(texture_ptr, 0, &surface_ptr);
ok(SUCCEEDED(hr) && surface_ptr != NULL, "GetSurfaceLevel returned: hr %#lx, surface_ptr %p. "
"Expected hr %#lx, surface_ptr != %p\n", hr, surface_ptr, D3D_OK, NULL);
if (!surface_ptr || FAILED(hr)) goto cleanup;
/* These should work... */
container_ptr = (void *)0x1337c0d3;
hr = IDirect3DSurface9_GetContainer(surface_ptr, &IID_IUnknown, &container_ptr);
ok(SUCCEEDED(hr) && container_ptr == texture_ptr, "GetContainer returned: hr %#lx, container_ptr %p. "
"Expected hr %#lx, container_ptr %p\n", hr, container_ptr, S_OK, texture_ptr);
if (container_ptr && container_ptr != (void *)0x1337c0d3) IUnknown_Release((IUnknown *)container_ptr);
container_ptr = (void *)0x1337c0d3;
hr = IDirect3DSurface9_GetContainer(surface_ptr, &IID_IDirect3DResource9, &container_ptr);
ok(SUCCEEDED(hr) && container_ptr == texture_ptr, "GetContainer returned: hr %#lx, container_ptr %p. "
"Expected hr %#lx, container_ptr %p\n", hr, container_ptr, S_OK, texture_ptr);
if (container_ptr && container_ptr != (void *)0x1337c0d3) IUnknown_Release((IUnknown *)container_ptr);
container_ptr = (void *)0x1337c0d3;
hr = IDirect3DSurface9_GetContainer(surface_ptr, &IID_IDirect3DBaseTexture9, &container_ptr);
ok(SUCCEEDED(hr) && container_ptr == texture_ptr, "GetContainer returned: hr %#lx, container_ptr %p. "
"Expected hr %#lx, container_ptr %p\n", hr, container_ptr, S_OK, texture_ptr);
if (container_ptr && container_ptr != (void *)0x1337c0d3) IUnknown_Release((IUnknown *)container_ptr);
container_ptr = (void *)0x1337c0d3;
hr = IDirect3DSurface9_GetContainer(surface_ptr, &IID_IDirect3DTexture9, &container_ptr);
ok(SUCCEEDED(hr) && container_ptr == texture_ptr, "GetContainer returned: hr %#lx, container_ptr %p. "
"Expected hr %#lx, container_ptr %p\n", hr, container_ptr, S_OK, texture_ptr);
if (container_ptr && container_ptr != (void *)0x1337c0d3) IUnknown_Release((IUnknown *)container_ptr);
/* ...and this one shouldn't. This should return E_NOINTERFACE and set container_ptr to NULL */
container_ptr = (void *)0x1337c0d3;
hr = IDirect3DSurface9_GetContainer(surface_ptr, &IID_IDirect3DSurface9, &container_ptr);
ok(hr == E_NOINTERFACE && container_ptr == NULL, "GetContainer returned: hr %#lx, container_ptr %p. "
"Expected hr %#lx, container_ptr %p\n", hr, container_ptr, E_NOINTERFACE, NULL);
if (container_ptr && container_ptr != (void *)0x1337c0d3) IUnknown_Release((IUnknown *)container_ptr);
cleanup:
if (texture_ptr) IDirect3DTexture9_Release(texture_ptr);
if (surface_ptr) IDirect3DSurface9_Release(surface_ptr);
}
static void DxDestroyVideoDecoder(vlc_va_t *va)
{
directx_sys_t *dx_sys = &va->sys->dx_sys;
if (dx_sys->decoder)
{
IDirectXVideoDecoder_Release(dx_sys->decoder);
dx_sys->decoder = NULL;
for (unsigned i = 0; i < dx_sys->va_pool.surface_count; i++)
IDirect3DSurface9_Release(dx_sys->hw_surface[i]);
}
}
static void test_cube_texture_levels(IDirect3DDevice9 *device_ptr)
{
IDirect3DCubeTexture9 *texture_ptr;
DWORD levels;
D3DSURFACE_DESC desc;
HRESULT hr;
IDirect3DSurface9 *surface;
hr = IDirect3DDevice9_CreateCubeTexture(device_ptr, 64, 0, 0, D3DFMT_X8R8G8B8,
D3DPOOL_DEFAULT, &texture_ptr, NULL);
if (FAILED(hr))
{
skip("Couldn't create cube texture\n");
return;
}
levels = IDirect3DCubeTexture9_GetLevelCount(texture_ptr);
ok(levels == 7, "Got %u levels, expected 7\n", levels);
hr = IDirect3DCubeTexture9_GetLevelDesc(texture_ptr, levels - 1, &desc);
ok(hr == D3D_OK, "IDirect3DCubeTexture9_GetLevelDesc returned %#x\n", hr);
hr = IDirect3DCubeTexture9_GetLevelDesc(texture_ptr, levels, &desc);
ok(hr == D3DERR_INVALIDCALL, "IDirect3DCubeTexture9_GetLevelDesc returned %#x\n", hr);
hr = IDirect3DCubeTexture9_GetLevelDesc(texture_ptr, levels + 1, &desc);
ok(hr == D3DERR_INVALIDCALL, "IDirect3DCubeTexture9_GetLevelDesc returned %#x\n", hr);
hr = IDirect3DCubeTexture9_GetCubeMapSurface(texture_ptr, D3DCUBEMAP_FACE_POSITIVE_X,
0, &surface);
ok(hr == D3D_OK, "IDirect3DCubeTexture9_GetCubeMapSurface returned %#x\n", hr);
if (SUCCEEDED(hr)) IDirect3DSurface9_Release(surface);
hr = IDirect3DCubeTexture9_GetCubeMapSurface(texture_ptr, D3DCUBEMAP_FACE_NEGATIVE_Z + 1,
0, &surface);
ok(hr == D3DERR_INVALIDCALL, "IDirect3DCubeTexture9_GetCubeMapSurface returned %#x\n", hr);
if (SUCCEEDED(hr)) IDirect3DSurface9_Release(surface);
hr = IDirect3DCubeTexture9_GetCubeMapSurface(texture_ptr, D3DCUBEMAP_FACE_POSITIVE_X - 1,
0, &surface);
ok(hr == D3DERR_INVALIDCALL, "IDirect3DCubeTexture9_GetCubeMapSurface returned %#x\n", hr);
if (SUCCEEDED(hr)) IDirect3DSurface9_Release(surface);
IDirect3DCubeTexture9_Release(texture_ptr);
}
static void device_state_restore(IDirect3DDevice9 *device, struct device_state *state)
{
unsigned int i;
for (i = 0; i < state->num_render_targets; i++)
{
IDirect3DDevice9_SetRenderTarget(device, i, state->render_targets[i]);
if (state->render_targets[i])
IDirect3DSurface9_Release(state->render_targets[i]);
state->render_targets[i] = NULL;
}
IDirect3DDevice9_SetDepthStencilSurface(device, state->depth_stencil);
if (state->depth_stencil)
{
IDirect3DSurface9_Release(state->depth_stencil);
state->depth_stencil = NULL;
}
IDirect3DDevice9_SetViewport(device, &state->viewport);
}
static gboolean
gst_dx9screencapsrc_stop (GstBaseSrc * bsrc)
{
GstDX9ScreenCapSrc *src = GST_DX9SCREENCAPSRC (bsrc);
if (src->surface) {
IDirect3DSurface9_Release (src->surface);
src->surface = NULL;
}
return TRUE;
}
static void Close(vlc_object_t *obj)
{
filter_t *filter = (filter_t *)obj;
filter_sys_t *sys = filter->p_sys;
IDirect3DSurface9_Release( sys->hw_surface );
IDirectXVideoProcessor_Release( sys->processor );
IDirect3DDevice9_Release( sys->d3ddev );
FreeLibrary( sys->hdecoder_dll );
FreeLibrary( sys->d3d9_dll );
free(sys);
}
/**
* It destroys the pool of picture and its resources.
*/
static void Direct3DDestroyPool(vout_display_t *vd)
{
vout_display_sys_t *sys = vd->sys;
if (sys->pool) {
picture_resource_t *rsc = &sys->resource;
IDirect3DSurface9_Release(rsc->p_sys->surface);
if (rsc->p_sys->fallback)
picture_Release(rsc->p_sys->fallback);
picture_pool_Delete(sys->pool);
}
sys->pool = NULL;
}
/**
* It destroys the pool of picture and its resources.
*/
static void Direct3DDestroyPool(vout_display_t *vd)
{
vout_display_sys_t *sys = vd->sys;
if (sys->pool) {
picture_sys_t *picsys = sys->picsys;
IDirect3DSurface9_Release(picsys->surface);
if (picsys->fallback)
picture_Release(picsys->fallback);
picture_pool_Delete(sys->pool);
}
sys->pool = NULL;
}
static void dxva2_release_img(void *ptr)
{
DXVA2SurfaceWrapper *w = ptr;
DXVA2Context *ctx = w->ctx;
int i;
for (i = 0; i < ctx->num_surfaces; i++) {
if (ctx->surfaces[i] == w->surface) {
ctx->surface_infos[i].used = 0;
break;
}
}
IDirect3DSurface9_Release(w->surface);
IDirectXVideoDecoder_Release(w->decoder);
av_free(w);
}
CR_API void crTextureFree(CrTexture* self)
{
CrTextureImpl* impl = (CrTextureImpl*)self;
if(nullptr == self)
return;
if(nullptr != impl->d3dtex) {
IDirect3DTexture9_Release(impl->d3dtex);
}
if(nullptr != impl->d3dsurf) {
IDirect3DSurface9_Release(impl->d3dsurf);
}
crMem()->free(self, "CrTexture");
}
static void dxva2_release_buffer(void *opaque, uint8_t *data)
{
DXVA2SurfaceWrapper *w = opaque;
DXVA2Context *ctx = w->ctx;
int i;
for (i = 0; i < ctx->num_surfaces; i++) {
if (ctx->surfaces[i] == w->surface) {
ctx->surface_infos[i].used = 0;
break;
}
}
av_log(NULL, AV_LOG_DEBUG, "dxva2_release_buffer:%d\n",i);
IDirect3DSurface9_Release(w->surface);
IDirectXVideoDecoder_Release(w->decoder);
av_free(w);
}
static void
gst_dx9screencapsrc_dispose (GObject * object)
{
GstDX9ScreenCapSrc *src = GST_DX9SCREENCAPSRC (object);
if (src->surface) {
GST_ERROR_OBJECT (object,
"DX9 surface was not freed in _stop, freeing in _dispose!");
IDirect3DSurface9_Release (src->surface);
src->surface = NULL;
}
if (src->d3d9_device) {
IDirect3DDevice9_Release (src->d3d9_device);
src->d3d9_device = NULL;
}
if (!IDirect3D9_Release (g_d3d9))
g_d3d9 = NULL;
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void dxva2_destroy_decoder(AVCodecContext *s)
{
return ; //storm //will core
InputStream *ist = s->opaque;
DXVA2Context *ctx = ist->hwaccel_ctx;
int i;
if (ctx->surfaces) {
for (i = 0; i < ctx->num_surfaces; i++) {
if (ctx->surfaces[i])
IDirect3DSurface9_Release(ctx->surfaces[i]);
}
}
av_freep(&ctx->surfaces);
av_freep(&ctx->surface_infos);
ctx->num_surfaces = 0;
ctx->surface_age = 0;
if (ctx->decoder) {
IDirectXVideoDecoder_Release(ctx->decoder);
ctx->decoder = NULL;
}
}
static void dxva2_destroy_decoder(AVCodecContext *s)
{
HwAccelContext *hac = s->opaque;
DXVA2Context *ctx = hac->hwaccel_ctx;
int i;
av_log(NULL, AV_LOG_DEBUG, "dxva2_destroy_decoder\n");
if (ctx->surfaces) {
for (i = 0; i < ctx->num_surfaces; i++) {
if (ctx->surfaces[i])
IDirect3DSurface9_Release(ctx->surfaces[i]);
}
}
av_freep(&ctx->surfaces);
av_freep(&ctx->surface_infos);
ctx->num_surfaces = 0;
ctx->surface_age = 0;
if (ctx->decoder) {
IDirectXVideoDecoder_Release(ctx->decoder);
ctx->decoder = NULL;
}
}
/**
* It copies picture surface into a texture and setup the associated d3d_region_t.
*/
static int Direct3DImportPicture(vout_display_t *vd,
d3d_region_t *region,
LPDIRECT3DSURFACE9 source)
{
vout_display_sys_t *sys = vd->sys;
HRESULT hr;
if (!source) {
msg_Dbg(vd, "no surface to render ?");
return VLC_EGENERIC;
}
/* retrieve texture top-level surface */
LPDIRECT3DSURFACE9 destination;
hr = IDirect3DTexture9_GetSurfaceLevel(sys->d3dtex, 0, &destination);
if (FAILED(hr)) {
msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
return VLC_EGENERIC;
}
/* Copy picture surface into texture surface
* color space conversion happen here */
hr = IDirect3DDevice9_StretchRect(sys->d3ddev, source, NULL, destination, NULL, D3DTEXF_LINEAR);
IDirect3DSurface9_Release(destination);
if (FAILED(hr)) {
msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
return VLC_EGENERIC;
}
/* */
region->texture = sys->d3dtex;
Direct3DSetupVertices(region->vertex,
vd->sys->rect_src,
vd->sys->rect_src_clipped,
vd->sys->rect_dest_clipped, 255);
return VLC_SUCCESS;
}
