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; }