自学教程：C++ IDirect3DSurface9_Release函数代码示例

static voidD3D_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 intD3D_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 intD3D_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 intD3D_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;}

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

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 gbooleangst_dx9screencapsrc_stop (GstBaseSrc * bsrc){  GstDX9ScreenCapSrc *src = GST_DX9SCREENCAPSRC (bsrc);  if (src->surface) {    IDirect3DSurface9_Release (src->surface);    src->surface = NULL;  }  return TRUE;}

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