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

static void swapchain_cleanup(struct wined3d_swapchain *swapchain){    HRESULT hr;    UINT i;    TRACE("Destroying swapchain %p./n", swapchain);    wined3d_swapchain_set_gamma_ramp(swapchain, 0, &swapchain->orig_gamma);    /* Release the swapchain's draw buffers. Make sure swapchain->back_buffers[0]     * is the last buffer to be destroyed, FindContext() depends on that. */    if (swapchain->front_buffer)    {        wined3d_texture_set_swapchain(swapchain->front_buffer, NULL);        if (wined3d_texture_decref(swapchain->front_buffer))            WARN("Something's still holding the front buffer (%p)./n", swapchain->front_buffer);        swapchain->front_buffer = NULL;    }    if (swapchain->back_buffers)    {        i = swapchain->desc.backbuffer_count;        while (i--)        {            wined3d_texture_set_swapchain(swapchain->back_buffers[i], NULL);            if (wined3d_texture_decref(swapchain->back_buffers[i]))                WARN("Something's still holding back buffer %u (%p)./n", i, swapchain->back_buffers[i]);        }        HeapFree(GetProcessHeap(), 0, swapchain->back_buffers);        swapchain->back_buffers = NULL;    }    for (i = 0; i < swapchain->num_contexts; ++i)    {        context_destroy(swapchain->device, swapchain->context[i]);    }    HeapFree(GetProcessHeap(), 0, swapchain->context);    /* Restore the screen resolution if we rendered in fullscreen.     * This will restore the screen resolution to what it was before creating     * the swapchain. In case of d3d8 and d3d9 this will be the original     * desktop resolution. In case of d3d7 this will be a NOP because ddraw     * sets the resolution before starting up Direct3D, thus orig_width and     * orig_height will be equal to the modes in the presentation params. */    if (!swapchain->desc.windowed && swapchain->desc.auto_restore_display_mode)    {        if (FAILED(hr = wined3d_set_adapter_display_mode(swapchain->device->wined3d,                swapchain->device->adapter->ordinal, &swapchain->original_mode)))            ERR("Failed to restore display mode, hr %#x./n", hr);    }    if (swapchain->backup_dc)    {        TRACE("Destroying backup wined3d window %p, dc %p./n", swapchain->backup_wnd, swapchain->backup_dc);        wined3d_release_dc(swapchain->backup_wnd, swapchain->backup_dc);        DestroyWindow(swapchain->backup_wnd);    }}

static ULONG volume_resource_decref(struct wined3d_resource *resource){    struct wined3d_volume *volume = volume_from_resource(resource);    TRACE("Forwarding to container %p./n", volume->container);    return wined3d_texture_decref(volume->container);}

ULONG CDECL wined3d_volume_decref(struct wined3d_volume *volume){    ULONG refcount;    if (volume->container)    {        TRACE("Forwarding to container %p./n", volume->container);        return wined3d_texture_decref(volume->container);    }    refcount = InterlockedDecrement(&volume->resource.ref);    TRACE("%p decreasing refcount to %u./n", volume, refcount);    if (!refcount)    {        if (volume->pbo)            wined3d_volume_free_pbo(volume);        resource_cleanup(&volume->resource);        volume->resource.parent_ops->wined3d_object_destroyed(volume->resource.parent);        HeapFree(GetProcessHeap(), 0, volume);    }    return refcount;}

static ULONG WINAPI d3d8_surface_Release(IDirect3DSurface8 *iface){    struct d3d8_surface *surface = impl_from_IDirect3DSurface8(iface);    ULONG refcount;    TRACE("iface %p./n", iface);    if (surface->texture)    {        TRACE("Forwarding to %p./n", surface->texture);        return IDirect3DBaseTexture8_Release(&surface->texture->IDirect3DBaseTexture8_iface);    }    refcount = InterlockedDecrement(&surface->resource.refcount);    TRACE("%p decreasing refcount to %u./n", iface, refcount);    if (!refcount)    {        IDirect3DDevice8 *parent_device = surface->parent_device;        wined3d_mutex_lock();        if (surface->wined3d_rtv)            wined3d_rendertarget_view_decref(surface->wined3d_rtv);        wined3d_texture_decref(surface->wined3d_texture);        wined3d_mutex_unlock();        if (parent_device)            IDirect3DDevice8_Release(parent_device);    }    return refcount;}

static ULONG STDMETHODCALLTYPE d3d10_texture3d_Release(ID3D10Texture3D *iface){    struct d3d10_texture3d *texture = impl_from_ID3D10Texture3D(iface);    ULONG refcount = InterlockedDecrement(&texture->refcount);    TRACE("%p decreasing refcount to %u./n", texture, refcount);    if (!refcount)        wined3d_texture_decref(texture->wined3d_texture);    return refcount;}

static ULONG STDMETHODCALLTYPE d3d10_texture2d_Release(ID3D10Texture2D *iface){    struct d3d10_texture2d *This = impl_from_ID3D10Texture2D(iface);    ULONG refcount = InterlockedDecrement(&This->refcount);    TRACE("%p decreasing refcount to %u/n", This, refcount);    if (!refcount)        wined3d_texture_decref(This->wined3d_texture);    return refcount;}

static ULONG STDMETHODCALLTYPE d3d10_texture2d_Release(ID3D10Texture2D *iface){    struct d3d10_texture2d *This = impl_from_ID3D10Texture2D(iface);    ULONG refcount = InterlockedDecrement(&This->refcount);    TRACE("%p decreasing refcount to %u/n", This, refcount);    if (!refcount)    {        ID3D10Device1 *device = This->device;        wined3d_texture_decref(This->wined3d_texture);        /* Release the device last, it may cause the wined3d device to be         * destroyed. */        ID3D10Device1_Release(device);    }    return refcount;}

static ULONG WINAPI IDirect3DVolumeTexture8Impl_Release(IDirect3DVolumeTexture8 *iface){    IDirect3DVolumeTexture8Impl *This = impl_from_IDirect3DVolumeTexture8(iface);    ULONG ref = InterlockedDecrement(&This->ref);    TRACE("%p decreasing refcount to %u./n", iface, ref);    if (ref == 0) {        IDirect3DDevice8 *parentDevice = This->parentDevice;        wined3d_mutex_lock();        wined3d_texture_decref(This->wined3d_texture);        wined3d_mutex_unlock();        /* Release the device last, as it may cause the device to be destroyed. */        IDirect3DDevice8_Release(parentDevice);    }    return ref;}

static ULONG WINAPI d3d8_texture_3d_Release(IDirect3DVolumeTexture8 *iface){    struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);    ULONG ref = InterlockedDecrement(&texture->refcount);    TRACE("%p decreasing refcount to %u./n", iface, ref);    if (!ref)    {        IDirect3DDevice8 *parent_device = texture->parent_device;        wined3d_mutex_lock();        wined3d_texture_decref(texture->wined3d_texture);        wined3d_mutex_unlock();        /* Release the device last, as it may cause the device to be destroyed. */        IDirect3DDevice8_Release(parent_device);    }    return ref;}

static ULONG STDMETHODCALLTYPE d3d11_texture2d_Release(ID3D11Texture2D *iface){    struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface);    ULONG refcount = InterlockedDecrement(&texture->refcount);    TRACE("%p decreasing refcount to %u./n", texture, refcount);    if (!refcount)    {        ID3D11Device *device = texture->device;        wined3d_mutex_lock();        wined3d_texture_decref(texture->wined3d_texture);        wined3d_mutex_unlock();        /* Release the device last, it may cause the wined3d device to be         * destroyed. */        ID3D11Device_Release(device);    }    return refcount;}

static ULONG WINAPI d3d9_texture_cube_Release(IDirect3DCubeTexture9 *iface){    struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);    ULONG ref = InterlockedDecrement(&texture->resource.refcount);    TRACE("%p decreasing refcount to %u./n", iface, ref);    if (!ref)    {        IDirect3DDevice9Ex *parent_device = texture->parent_device;        TRACE("Releasing child %p./n", texture->wined3d_texture);        wined3d_mutex_lock();        wined3d_texture_decref(texture->wined3d_texture);        wined3d_mutex_unlock();        /* Release the device last, as it may cause the device to be destroyed. */        IDirect3DDevice9Ex_Release(parent_device);    }    return ref;}

static ULONG WINAPI d3d9_surface_Release(IDirect3DSurface9 *iface){    struct d3d9_surface *surface = impl_from_IDirect3DSurface9(iface);    ULONG refcount;    TRACE("iface %p./n", iface);    if (surface->texture)    {        TRACE("Forwarding to %p./n", surface->texture);        return IDirect3DBaseTexture9_Release(&surface->texture->IDirect3DBaseTexture9_iface);    }    if (!surface->resource.refcount)    {        ERR("Surface doesn't have any references./n");        return 0;    }    refcount = InterlockedDecrement(&surface->resource.refcount);    TRACE("%p decreasing refcount to %u./n", iface, refcount);    if (!refcount)    {        IDirect3DDevice9Ex *parent_device = surface->parent_device;        wined3d_mutex_lock();        if (surface->wined3d_rtv)            wined3d_rendertarget_view_decref(surface->wined3d_rtv);        wined3d_texture_decref(surface->wined3d_texture);        wined3d_mutex_unlock();        /* Release the device last, as it may cause the device to be destroyed. */        if (parent_device)            IDirect3DDevice9Ex_Release(parent_device);    }    return refcount;}

static ULONG WINAPI d3d8_texture_2d_Release(IDirect3DTexture8 *iface){    struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);    ULONG ref = InterlockedDecrement(&texture->resource.refcount);    TRACE("%p decreasing refcount to %u./n", iface, ref);    if (!ref)    {        IDirect3DDevice8 *parent_device = texture->parent_device;        struct d3d8_surface *surface;        wined3d_mutex_lock();        LIST_FOR_EACH_ENTRY(surface, &texture->rtv_list, struct d3d8_surface, rtv_entry)        {            wined3d_rendertarget_view_decref(surface->wined3d_rtv);        }        wined3d_texture_decref(texture->wined3d_texture);        wined3d_mutex_unlock();        /* Release the device last, as it may cause the device to be destroyed. */        IDirect3DDevice8_Release(parent_device);    }

static HRESULT d3d_texture2d_init(struct d3d_texture2d *texture, struct d3d_device *device,        const D3D11_TEXTURE2D_DESC *desc, const D3D11_SUBRESOURCE_DATA *data){    struct wined3d_resource_desc wined3d_desc;    unsigned int levels;    HRESULT hr;    texture->ID3D11Texture2D_iface.lpVtbl = &d3d11_texture2d_vtbl;    texture->ID3D10Texture2D_iface.lpVtbl = &d3d10_texture2d_vtbl;    texture->refcount = 1;    wined3d_mutex_lock();    wined3d_private_store_init(&texture->private_store);    texture->desc = *desc;    if (desc->ArraySize != 1)        FIXME("Array textures not implemented./n");    if (desc->SampleDesc.Count > 1)        FIXME("Multisampled textures not implemented./n");    wined3d_desc.resource_type = WINED3D_RTYPE_TEXTURE;    wined3d_desc.format = wined3dformat_from_dxgi_format(desc->Format);    wined3d_desc.multisample_type = desc->SampleDesc.Count > 1 ? desc->SampleDesc.Count : WINED3D_MULTISAMPLE_NONE;    wined3d_desc.multisample_quality = desc->SampleDesc.Quality;    wined3d_desc.usage = wined3d_usage_from_d3d11(desc->BindFlags, desc->Usage);    wined3d_desc.pool = WINED3D_POOL_DEFAULT;    wined3d_desc.width = desc->Width;    wined3d_desc.height = desc->Height;    wined3d_desc.depth = 1;    wined3d_desc.size = 0;    levels = desc->MipLevels ? desc->MipLevels : wined3d_log2i(max(desc->Width, desc->Height)) + 1;    if (FAILED(hr = wined3d_texture_create(device->wined3d_device, &wined3d_desc,            levels, 0, (struct wined3d_sub_resource_data *)data, texture,            &d3d_texture2d_wined3d_parent_ops, &texture->wined3d_texture)))    {        WARN("Failed to create wined3d texture, hr %#x./n", hr);        wined3d_private_store_cleanup(&texture->private_store);        wined3d_mutex_unlock();        return hr;    }    texture->desc.MipLevels = levels;    if (desc->MipLevels == 1 && desc->ArraySize == 1)    {        IWineDXGIDevice *wine_device;        if (FAILED(hr = ID3D10Device1_QueryInterface(&device->ID3D10Device1_iface, &IID_IWineDXGIDevice,                (void **)&wine_device)))        {            ERR("Device should implement IWineDXGIDevice./n");            wined3d_texture_decref(texture->wined3d_texture);            wined3d_mutex_unlock();            return E_FAIL;        }        hr = IWineDXGIDevice_create_surface(wine_device, wined3d_texture_get_resource(texture->wined3d_texture),                0, NULL, (IUnknown *)&texture->ID3D10Texture2D_iface, (void **)&texture->dxgi_surface);        IWineDXGIDevice_Release(wine_device);        if (FAILED(hr))        {            ERR("Failed to create DXGI surface, returning %#x/n", hr);            texture->dxgi_surface = NULL;            wined3d_texture_decref(texture->wined3d_texture);            wined3d_mutex_unlock();            return hr;        }    }    wined3d_mutex_unlock();    texture->device = &device->ID3D11Device_iface;    ID3D11Device_AddRef(texture->device);    return S_OK;}

static HRESULT STDMETHODCALLTYPE dxgi_device_CreateSurface(IWineDXGIDevice *iface,        const DXGI_SURFACE_DESC *desc, UINT surface_count, DXGI_USAGE usage,        const DXGI_SHARED_RESOURCE *shared_resource, IDXGISurface **surface){    struct wined3d_device_parent *device_parent;    struct wined3d_resource_desc surface_desc;    IWineDXGIDeviceParent *dxgi_device_parent;    HRESULT hr;    UINT i;    UINT j;    TRACE("iface %p, desc %p, surface_count %u, usage %#x, shared_resource %p, surface %p/n",            iface, desc, surface_count, usage, shared_resource, surface);    hr = IWineDXGIDevice_QueryInterface(iface, &IID_IWineDXGIDeviceParent, (void **)&dxgi_device_parent);    if (FAILED(hr))    {        ERR("Device should implement IWineD3DDeviceParent/n");        return E_FAIL;    }    device_parent = IWineDXGIDeviceParent_get_wined3d_device_parent(dxgi_device_parent);    FIXME("Implement DXGI<->wined3d usage conversion/n");    surface_desc.resource_type = WINED3D_RTYPE_SURFACE;    surface_desc.format = wined3dformat_from_dxgi_format(desc->Format);    wined3d_sample_desc_from_dxgi(&surface_desc.multisample_type,            &surface_desc.multisample_quality, &desc->SampleDesc);    surface_desc.usage = usage;    surface_desc.pool = WINED3D_POOL_DEFAULT;    surface_desc.width = desc->Width;    surface_desc.height = desc->Height;    surface_desc.depth = 1;    surface_desc.size = 0;    wined3d_mutex_lock();    memset(surface, 0, surface_count * sizeof(*surface));    for (i = 0; i < surface_count; ++i)    {        struct wined3d_texture *wined3d_texture;        IUnknown *parent;        if (FAILED(hr = device_parent->ops->create_swapchain_texture(device_parent,                NULL, &surface_desc, &wined3d_texture)))        {            ERR("Failed to create surface, hr %#x./n", hr);            goto fail;        }        parent = wined3d_texture_get_parent(wined3d_texture);        hr = IUnknown_QueryInterface(parent, &IID_IDXGISurface, (void **)&surface[i]);        wined3d_texture_decref(wined3d_texture);        if (FAILED(hr))        {            ERR("Surface should implement IDXGISurface/n");            goto fail;        }        TRACE("Created IDXGISurface %p (%u/%u)/n", surface[i], i + 1, surface_count);    }    wined3d_mutex_unlock();    IWineDXGIDeviceParent_Release(dxgi_device_parent);    return S_OK;fail:    wined3d_mutex_unlock();    for (j = 0; j < i; ++j)    {        IDXGISurface_Release(surface[i]);    }    IWineDXGIDeviceParent_Release(dxgi_device_parent);    return hr;}

//.........这里部分代码省略.........        {            ERR("Failed to allocate backbuffer array memory./n");            hr = E_OUTOFMEMORY;            goto err;        }        texture_desc.usage |= WINED3DUSAGE_RENDERTARGET;        for (i = 0; i < swapchain->desc.backbuffer_count; ++i)        {            TRACE("Creating back buffer %u./n", i);            if (FAILED(hr = device->device_parent->ops->create_swapchain_texture(device->device_parent,                    parent, &texture_desc, &swapchain->back_buffers[i])))            {                WARN("Failed to create back buffer %u, hr %#x./n", i, hr);                swapchain->desc.backbuffer_count = i;                goto err;            }            wined3d_texture_set_swapchain(swapchain->back_buffers[i], swapchain);        }    }    /* Swapchains share the depth/stencil buffer, so only create a single depthstencil surface. */    if (desc->enable_auto_depth_stencil && !(device->wined3d->flags & WINED3D_NO3D))    {        TRACE("Creating depth/stencil buffer./n");        if (!device->auto_depth_stencil_view)        {            struct wined3d_texture *ds;            struct wined3d_rendertarget_view_desc desc;            texture_desc.format = swapchain->desc.auto_depth_stencil_format;            texture_desc.usage = WINED3DUSAGE_DEPTHSTENCIL;            if (FAILED(hr = device->device_parent->ops->create_swapchain_texture(device->device_parent,                    device->device_parent, &texture_desc, &ds)))            {                WARN("Failed to create the auto depth/stencil surface, hr %#x./n", hr);                goto err;            }            desc.format_id = ds->resource.format->id;            desc.u.texture.level_idx = 0;            desc.u.texture.layer_idx = 0;            desc.u.texture.layer_count = 1;            hr = wined3d_rendertarget_view_create(&desc, &ds->resource, NULL, &wined3d_null_parent_ops,                    &device->auto_depth_stencil_view);            wined3d_texture_decref(ds);            if (FAILED(hr))            {                ERR("Failed to create rendertarget view, hr %#x./n", hr);                goto err;            }        }    }    wined3d_swapchain_get_gamma_ramp(swapchain, &swapchain->orig_gamma);    return WINED3D_OK;err:    if (displaymode_set)    {        if (FAILED(wined3d_set_adapter_display_mode(device->wined3d,                adapter->ordinal, &swapchain->original_mode)))            ERR("Failed to restore display mode./n");        ClipCursor(NULL);    }    if (swapchain->back_buffers)    {        for (i = 0; i < swapchain->desc.backbuffer_count; ++i)        {            if (swapchain->back_buffers[i])            {                wined3d_texture_set_swapchain(swapchain->back_buffers[i], NULL);                wined3d_texture_decref(swapchain->back_buffers[i]);            }        }        HeapFree(GetProcessHeap(), 0, swapchain->back_buffers);    }    if (swapchain->context)    {        if (swapchain->context[0])        {            context_release(swapchain->context[0]);            context_destroy(device, swapchain->context[0]);            swapchain->num_contexts = 0;        }        HeapFree(GetProcessHeap(), 0, swapchain->context);    }    if (swapchain->front_buffer)    {        wined3d_texture_set_swapchain(swapchain->front_buffer, NULL);        wined3d_texture_decref(swapchain->front_buffer);    }    return hr;}

//.........这里部分代码省略.........    {        src_rect.left = 0;        src_rect.top = 0;        src_rect.right = swapchain->desc.backbuffer_width;        src_rect.bottom = swapchain->desc.backbuffer_height;    }    if (dst_rect_in)        dst_rect = *dst_rect_in;    else        GetClientRect(swapchain->win_handle, &dst_rect);    if (!render_to_fbo && (dst_rect.left || dst_rect.top            || dst_rect.right != swapchain->desc.backbuffer_width            || dst_rect.bottom != swapchain->desc.backbuffer_height))        render_to_fbo = TRUE;    /* Rendering to a window of different size, presenting partial rectangles,     * or rendering to a different window needs help from FBO_blit or a textured     * draw. Render the swapchain to a FBO in the future.     *     * Note that FBO_blit from the backbuffer to the frontbuffer cannot solve     * all these issues - this fails if the window is smaller than the backbuffer.     */    if (!swapchain->render_to_fbo && render_to_fbo && wined3d_settings.offscreen_rendering_mode == ORM_FBO)    {        surface_load_location(back_buffer, context, WINED3D_LOCATION_TEXTURE_RGB);        surface_invalidate_location(back_buffer, WINED3D_LOCATION_DRAWABLE);        swapchain->render_to_fbo = TRUE;        swapchain_update_draw_bindings(swapchain);    }    else    {        surface_load_location(back_buffer, context, back_buffer->container->resource.draw_binding);    }    if (swapchain->render_to_fbo)    {        static unsigned int once;        if (swapchain->desc.swap_effect == WINED3D_SWAP_EFFECT_FLIP && !once++)            FIXME("WINED3D_SWAP_EFFECT_FLIP not implemented./n");        swapchain_blit(swapchain, context, &src_rect, &dst_rect);    }    if (swapchain->num_contexts > 1)        gl_info->gl_ops.gl.p_glFinish();    /* call wglSwapBuffers through the gl table to avoid confusing the Steam overlay */    gl_info->gl_ops.wgl.p_wglSwapBuffers(context->hdc); /* TODO: cycle through the swapchain buffers */    TRACE("SwapBuffers called, Starting new frame/n");    /* FPS support */    if (TRACE_ON(fps))    {        DWORD time = GetTickCount();        ++swapchain->frames;        /* every 1.5 seconds */        if (time - swapchain->prev_time > 1500)        {            TRACE_(fps)("%p @ approx %.2ffps/n",                    swapchain, 1000.0 * swapchain->frames / (time - swapchain->prev_time));            swapchain->prev_time = time;            swapchain->frames = 0;        }    }    front = surface_from_resource(wined3d_texture_get_sub_resource(swapchain->front_buffer, 0));    surface_validate_location(front, WINED3D_LOCATION_DRAWABLE);    surface_invalidate_location(front, ~WINED3D_LOCATION_DRAWABLE);    /* If the swapeffect is DISCARD, the back buffer is undefined. That means the SYSMEM     * and INTEXTURE copies can keep their old content if they have any defined content.     * If the swapeffect is COPY, the content remains the same.     *     * The FLIP swap effect is not implemented yet. We could mark WINED3D_LOCATION_DRAWABLE     * up to date and hope WGL flipped front and back buffers and read this data into     * the FBO. Don't bother about this for now. */    if (fb->depth_stencil)    {        struct wined3d_surface *ds = wined3d_rendertarget_view_get_surface(fb->depth_stencil);        if (ds && (swapchain->desc.flags & WINED3DPRESENTFLAG_DISCARD_DEPTHSTENCIL                || ds->flags & SFLAG_DISCARD))        {            surface_modify_ds_location(ds, WINED3D_LOCATION_DISCARDED,                    fb->depth_stencil->width, fb->depth_stencil->height);            if (ds == swapchain->device->onscreen_depth_stencil)            {                wined3d_texture_decref(swapchain->device->onscreen_depth_stencil->container);                swapchain->device->onscreen_depth_stencil = NULL;            }        }    }    context_release(context);}

static ULONG texture_resource_decref(struct wined3d_resource *resource){    return wined3d_texture_decref(wined3d_texture_from_resource(resource));}

ULONG CDECL wined3d_volume_decref(struct wined3d_volume *volume){    TRACE("Forwarding to container %p./n", volume->container);    return wined3d_texture_decref(volume->container);}