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

static HRESULT WINAPI d3d8_GetAdapterDisplayMode(IDirect3D8 *iface, UINT adapter, D3DDISPLAYMODE *mode){    struct d3d8 *d3d8 = impl_from_IDirect3D8(iface);    struct wined3d_display_mode wined3d_mode;    HRESULT hr;    TRACE("iface %p, adapter %u, mode %p./n",            iface, adapter, mode);    wined3d_mutex_lock();    hr = wined3d_get_adapter_display_mode(d3d8->wined3d, adapter, &wined3d_mode, NULL);    wined3d_mutex_unlock();    if (SUCCEEDED(hr))    {        mode->Width = wined3d_mode.width;        mode->Height = wined3d_mode.height;        mode->RefreshRate = wined3d_mode.refresh_rate;        mode->Format = d3dformat_from_wined3dformat(wined3d_mode.format_id);    }    return hr;}

static HRESULT WINAPI IDirect3DVolume9Impl_GetDesc(IDirect3DVolume9 *iface, D3DVOLUME_DESC *desc){    IDirect3DVolume9Impl *This = (IDirect3DVolume9Impl *)iface;    struct wined3d_resource_desc wined3d_desc;    struct wined3d_resource *wined3d_resource;    TRACE("iface %p, desc %p./n", iface, desc);    wined3d_mutex_lock();    wined3d_resource = IWineD3DVolume_GetResource(This->wineD3DVolume);    wined3d_resource_get_desc(wined3d_resource, &wined3d_desc);    wined3d_mutex_unlock();    desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format);    desc->Type = wined3d_desc.resource_type;    desc->Usage = wined3d_desc.usage;    desc->Pool = wined3d_desc.pool;    desc->Width = wined3d_desc.width;    desc->Height = wined3d_desc.height;    desc->Depth = wined3d_desc.depth;    return D3D_OK;}

IDirect3D8* WINAPI DECLSPEC_HOTPATCH Direct3DCreate8(UINT SDKVersion) {    IDirect3D8Impl* object;    TRACE("SDKVersion = %x/n", SDKVersion);    wined3d_mutex_lock();    object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3D8Impl));    object->lpVtbl = &Direct3D8_Vtbl;    object->ref = 1;    object->WineD3D = WineDirect3DCreate(8, (IUnknown *)object);    TRACE("Created Direct3D object @ %p, WineObj @ %p/n", object, object->WineD3D);    wined3d_mutex_unlock();    if (!object->WineD3D)    {        HeapFree( GetProcessHeap(), 0, object );        object = NULL;    }    return (IDirect3D8*) object;}

static HRESULT WINAPI d3d8_vertexbuffer_GetDesc(IDirect3DVertexBuffer8 *iface,        D3DVERTEXBUFFER_DESC *desc){    struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);    struct wined3d_resource_desc wined3d_desc;    struct wined3d_resource *wined3d_resource;    TRACE("iface %p, desc %p./n", iface, desc);    wined3d_mutex_lock();    wined3d_resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);    wined3d_resource_get_desc(wined3d_resource, &wined3d_desc);    wined3d_mutex_unlock();    desc->Format = D3DFMT_VERTEXDATA;    desc->Type = D3DRTYPE_VERTEXBUFFER;    desc->Usage = buffer->usage;    desc->Pool = d3dpool_from_wined3daccess(wined3d_desc.access, wined3d_desc.usage);    desc->Size = wined3d_desc.size;    desc->FVF = buffer->fvf;    return D3D_OK;}

HRESULT pixelshader_init(IDirect3DPixelShader9Impl *shader, IDirect3DDevice9Impl *device, const DWORD *byte_code){    HRESULT hr;    shader->ref = 1;    shader->lpVtbl = &Direct3DPixelShader9_Vtbl;    wined3d_mutex_lock();    hr = IWineD3DDevice_CreatePixelShader(device->WineD3DDevice, byte_code,            NULL, &shader->wineD3DPixelShader, (IUnknown *)shader,            &d3d9_pixelshader_wined3d_parent_ops);    wined3d_mutex_unlock();    if (FAILED(hr))    {        WARN("Failed to created wined3d pixel shader, hr %#x./n", hr);        return hr;    }    shader->parentDevice = (IDirect3DDevice9Ex *)device;    IDirect3DDevice9Ex_AddRef(shader->parentDevice);    return D3D_OK;}

static HRESULT WINAPI IDirect3DSwapChain8Impl_GetBackBuffer(IDirect3DSwapChain8 *iface,        UINT iBackBuffer, D3DBACKBUFFER_TYPE Type, IDirect3DSurface8 **ppBackBuffer){    IDirect3DSwapChain8Impl *This = impl_from_IDirect3DSwapChain8(iface);    struct wined3d_surface *wined3d_surface = NULL;    HRESULT hr;    TRACE("iface %p, backbuffer_idx %u, backbuffer_type %#x, backbuffer %p./n",            iface, iBackBuffer, Type, ppBackBuffer);    wined3d_mutex_lock();    hr = wined3d_swapchain_get_back_buffer(This->wined3d_swapchain,            iBackBuffer, (enum wined3d_backbuffer_type)Type, &wined3d_surface);    if (SUCCEEDED(hr) && wined3d_surface)    {        *ppBackBuffer = wined3d_surface_get_parent(wined3d_surface);        IDirect3DSurface8_AddRef(*ppBackBuffer);        wined3d_surface_decref(wined3d_surface);    }    wined3d_mutex_unlock();    return hr;}

/***************************************************************************** * IDirect3DVertexBuffer7::GetVertexBufferDesc * * Returns the description of a vertex buffer * * Params: *  Desc: Address to write the description to * * Returns *  DDERR_INVALIDPARAMS if Desc is NULL *  D3D_OK on success * *****************************************************************************/static HRESULT WINAPI IDirect3DVertexBufferImpl_GetVertexBufferDesc(IDirect3DVertexBuffer7 *iface,        D3DVERTEXBUFFERDESC *Desc){    IDirect3DVertexBufferImpl *This = impl_from_IDirect3DVertexBuffer7(iface);    struct wined3d_resource_desc wined3d_desc;    struct wined3d_resource *wined3d_resource;    TRACE("iface %p, desc %p./n", iface, Desc);    if(!Desc) return DDERR_INVALIDPARAMS;    wined3d_mutex_lock();    wined3d_resource = wined3d_buffer_get_resource(This->wineD3DVertexBuffer);    wined3d_resource_get_desc(wined3d_resource, &wined3d_desc);    wined3d_mutex_unlock();    /* Now fill the Desc structure */    Desc->dwCaps = This->Caps;    Desc->dwFVF = This->fvf;    Desc->dwNumVertices = wined3d_desc.size / get_flexible_vertex_size(This->fvf);    return D3D_OK;}

/***************************************************************************** * IDirect3DVertexBuffer7::Optimize * * Converts an unoptimized vertex buffer into an optimized buffer * * Params: *  D3DDevice: Device for which this buffer is optimized *  Flags: Not used, should be set to 0 * * Returns *  D3D_OK, because it's a stub * *****************************************************************************/static HRESULT WINAPI IDirect3DVertexBufferImpl_Optimize(IDirect3DVertexBuffer7 *iface,        IDirect3DDevice7 *D3DDevice, DWORD Flags){    IDirect3DVertexBufferImpl *This = impl_from_IDirect3DVertexBuffer7(iface);    static BOOL hide = FALSE;    TRACE("iface %p, device %p, flags %#x./n", iface, D3DDevice, Flags);    if (!hide)    {        FIXME("iface %p, device %p, flags %#x stub!/n", iface, D3DDevice, Flags);        hide = TRUE;    }    /* We could forward this call to WineD3D and take advantage     * of it once we use OpenGL vertex buffers     */    wined3d_mutex_lock();    This->Caps |= D3DVBCAPS_OPTIMIZED;    wined3d_mutex_unlock();    return DD_OK;}

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 ULONG WINAPI d3d8_texture_2d_AddRef(IDirect3DTexture8 *iface){    struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);    ULONG ref = InterlockedIncrement(&texture->resource.refcount);    TRACE("%p increasing refcount to %u./n", iface, ref);    if (ref == 1)    {        struct d3d8_surface *surface;        IDirect3DDevice8_AddRef(texture->parent_device);        wined3d_mutex_lock();        LIST_FOR_EACH_ENTRY(surface, &texture->rtv_list, struct d3d8_surface, rtv_entry)        {            wined3d_rendertarget_view_incref(surface->wined3d_rtv);        }        wined3d_texture_incref(texture->wined3d_texture);        wined3d_mutex_unlock();    }    return ref;}

static HRESULT WINAPI d3d8_texture_3d_GetVolumeLevel(IDirect3DVolumeTexture8 *iface,        UINT level, IDirect3DVolume8 **volume){    struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);    struct wined3d_resource *sub_resource;    struct d3d8_volume *volume_impl;    TRACE("iface %p, level %u, volume %p./n", iface, level, volume);    wined3d_mutex_lock();    if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))    {        wined3d_mutex_unlock();        return D3DERR_INVALIDCALL;    }    volume_impl = wined3d_resource_get_parent(sub_resource);    *volume = &volume_impl->IDirect3DVolume8_iface;    IDirect3DVolume8_AddRef(*volume);    wined3d_mutex_unlock();    return D3D_OK;}

static HRESULT WINAPI d3d8_indexbuffer_Lock(IDirect3DIndexBuffer8 *iface, UINT offset, UINT size,        BYTE **data, DWORD flags){    struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);    struct wined3d_resource *wined3d_resource;    struct wined3d_map_desc wined3d_map_desc;    struct wined3d_box wined3d_box = {0};    HRESULT hr;    TRACE("iface %p, offset %u, size %u, data %p, flags %#x./n",            iface, offset, size, data, flags);    wined3d_box.left = offset;    wined3d_box.right = offset + size;    wined3d_mutex_lock();    wined3d_resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);    hr = wined3d_resource_map(wined3d_resource, 0, &wined3d_map_desc, &wined3d_box,            wined3dmapflags_from_d3dmapflags(flags, buffer->usage));    wined3d_mutex_unlock();    *data = wined3d_map_desc.data;    return hr;}

static void STDMETHODCALLTYPE d3d11_texture2d_GetDesc(ID3D11Texture2D *iface, D3D11_TEXTURE2D_DESC *desc){    struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface);    struct wined3d_resource_desc wined3d_desc;    TRACE("iface %p, desc %p./n", iface, desc);    *desc = texture->desc;    wined3d_mutex_lock();    wined3d_resource_get_desc(wined3d_texture_get_resource(texture->wined3d_texture), &wined3d_desc);    wined3d_mutex_unlock();    /* FIXME: Resizing swapchain buffers can cause these to change. We'd like     * to get everything from wined3d, but e.g. bind flags don't exist as such     * there (yet). */    desc->Width = wined3d_desc.width;    desc->Height = wined3d_desc.height;    desc->Format = dxgi_format_from_wined3dformat(wined3d_desc.format);    desc->SampleDesc.Count = wined3d_desc.multisample_type == WINED3D_MULTISAMPLE_NONE        ? 1 : wined3d_desc.multisample_type;    desc->SampleDesc.Quality = wined3d_desc.multisample_quality;}

static HRESULT WINAPI d3d9_texture_3d_LockBox(IDirect3DVolumeTexture9 *iface,        UINT level, D3DLOCKED_BOX *locked_box, const D3DBOX *box, DWORD flags){    struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);    struct wined3d_resource *sub_resource;    struct d3d9_volume *volume_impl;    HRESULT hr;    TRACE("iface %p, level %u, locked_box %p, box %p, flags %#x./n",            iface, level, locked_box, box, flags);    wined3d_mutex_lock();    if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))        hr = D3DERR_INVALIDCALL;    else    {        volume_impl = wined3d_resource_get_parent(sub_resource);        hr = IDirect3DVolume9_LockBox(&volume_impl->IDirect3DVolume9_iface, locked_box, box, flags);    }    wined3d_mutex_unlock();    return hr;}

static HRESULT WINAPI d3d9_volume_GetDesc(IDirect3DVolume9 *iface, D3DVOLUME_DESC *desc){    struct d3d9_volume *volume = impl_from_IDirect3DVolume9(iface);    struct wined3d_resource_desc wined3d_desc;    struct wined3d_resource *wined3d_resource;    TRACE("iface %p, desc %p./n", iface, desc);    wined3d_mutex_lock();    wined3d_resource = wined3d_volume_get_resource(volume->wined3d_volume);    wined3d_resource_get_desc(wined3d_resource, &wined3d_desc);    wined3d_mutex_unlock();    desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format);    desc->Type = wined3d_desc.resource_type;    desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK;    desc->Pool = wined3d_desc.pool;    desc->Width = wined3d_desc.width;    desc->Height = wined3d_desc.height;    desc->Depth = wined3d_desc.depth;    return D3D_OK;}

static HRESULT WINAPI IDirect3DCubeTexture8Impl_GetCubeMapSurface(IDirect3DCubeTexture8 *iface,        D3DCUBEMAP_FACES face, UINT level, IDirect3DSurface8 **surface){    IDirect3DCubeTexture8Impl *texture = impl_from_IDirect3DCubeTexture8(iface);    struct wined3d_resource *sub_resource;    UINT sub_resource_idx;    TRACE("iface %p, face %#x, level %u, surface %p./n", iface, face, level, surface);    wined3d_mutex_lock();    sub_resource_idx = IWineD3DCubeTexture_GetLevelCount(texture->wineD3DCubeTexture) * face + level;    if (!(sub_resource = IWineD3DCubeTexture_GetSubResource(texture->wineD3DCubeTexture, sub_resource_idx)))    {        wined3d_mutex_unlock();        return D3DERR_INVALIDCALL;    }    *surface = wined3d_resource_get_parent(sub_resource);    IDirect3DSurface8_AddRef(*surface);    wined3d_mutex_unlock();    return D3D_OK;}

static HRESULT WINAPI d3d9_texture_2d_LockRect(IDirect3DTexture9 *iface,        UINT level, D3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags){    struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);    struct wined3d_resource *sub_resource;    struct d3d9_surface *surface_impl;    HRESULT hr;    TRACE("iface %p, level %u, locked_rect %p, rect %p, flags %#x./n",            iface, level, locked_rect, rect, flags);    wined3d_mutex_lock();    if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))        hr = D3DERR_INVALIDCALL;    else    {        surface_impl = wined3d_resource_get_parent(sub_resource);        hr = IDirect3DSurface9_LockRect(&surface_impl->IDirect3DSurface9_iface, locked_rect, rect, flags);    }    wined3d_mutex_unlock();    return hr;}

static HRESULT WINAPI d3d9_texture_2d_GetSurfaceLevel(IDirect3DTexture9 *iface,        UINT level, IDirect3DSurface9 **surface){    struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);    struct wined3d_resource *sub_resource;    struct d3d9_surface *surface_impl;    TRACE("iface %p, level %u, surface %p./n", iface, level, surface);    wined3d_mutex_lock();    if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))    {        wined3d_mutex_unlock();        return D3DERR_INVALIDCALL;    }    surface_impl = wined3d_resource_get_parent(sub_resource);    *surface = &surface_impl->IDirect3DSurface9_iface;    IDirect3DSurface9_AddRef(*surface);    wined3d_mutex_unlock();    return D3D_OK;}

static HRESULT WINAPI IDirect3DCubeTexture9Impl_LockRect(IDirect3DCubeTexture9 *iface,        D3DCUBEMAP_FACES face, UINT level, D3DLOCKED_RECT *locked_rect, const RECT *rect,        DWORD flags){    IDirect3DCubeTexture9Impl *texture = impl_from_IDirect3DCubeTexture9(iface);    struct wined3d_resource *sub_resource;    UINT sub_resource_idx;    HRESULT hr;    TRACE("iface %p, face %#x, level %u, locked_rect %p, rect %p, flags %#x./n",            iface, face, level, locked_rect, rect, flags);    wined3d_mutex_lock();    sub_resource_idx = wined3d_texture_get_level_count(texture->wined3d_texture) * face + level;    if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx)))        hr = D3DERR_INVALIDCALL;    else        hr = IDirect3DSurface9_LockRect((IDirect3DSurface9 *)wined3d_resource_get_parent(sub_resource),                locked_rect, rect, flags);    wined3d_mutex_unlock();    return hr;}

static HRESULT WINAPI d3d9_texture_cube_GetLevelDesc(IDirect3DCubeTexture9 *iface, UINT level, D3DSURFACE_DESC *desc){    struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);    struct wined3d_resource *sub_resource;    HRESULT hr = D3D_OK;    DWORD level_count;    TRACE("iface %p, level %u, desc %p./n", iface, level, desc);    wined3d_mutex_lock();    level_count = wined3d_texture_get_level_count(texture->wined3d_texture);    if (level >= level_count)    {        wined3d_mutex_unlock();        return D3DERR_INVALIDCALL;    }    if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))        hr = D3DERR_INVALIDCALL;    else    {        struct wined3d_resource_desc wined3d_desc;        wined3d_resource_get_desc(sub_resource, &wined3d_desc);        desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format);        desc->Type = wined3d_desc.resource_type;        desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK;        desc->Pool = wined3d_desc.pool;        desc->MultiSampleType = wined3d_desc.multisample_type;        desc->MultiSampleQuality = wined3d_desc.multisample_quality;        desc->Width = wined3d_desc.width;        desc->Height = wined3d_desc.height;    }    wined3d_mutex_unlock();    return hr;}

static HRESULT WINAPI d3d9_swapchain_GetBackBuffer(IDirect3DSwapChain9Ex *iface,        UINT backbuffer_idx, D3DBACKBUFFER_TYPE backbuffer_type, IDirect3DSurface9 **backbuffer){    struct d3d9_swapchain *swapchain = impl_from_IDirect3DSwapChain9Ex(iface);    struct wined3d_resource *wined3d_resource;    struct wined3d_texture *wined3d_texture;    struct d3d9_surface *surface_impl;    HRESULT hr = D3D_OK;    TRACE("iface %p, backbuffer_idx %u, backbuffer_type %#x, backbuffer %p./n",            iface, backbuffer_idx, backbuffer_type, backbuffer);    /* backbuffer_type is ignored by native. */    if (!backbuffer)    {        WARN("The output pointer is NULL, returning D3DERR_INVALIDCALL./n");        return D3DERR_INVALIDCALL;    }    wined3d_mutex_lock();    if ((wined3d_texture = wined3d_swapchain_get_back_buffer(swapchain->wined3d_swapchain, backbuffer_idx)))    {        wined3d_resource = wined3d_texture_get_sub_resource(wined3d_texture, 0);        surface_impl = wined3d_resource_get_parent(wined3d_resource);        *backbuffer = &surface_impl->IDirect3DSurface9_iface;        IDirect3DSurface9_AddRef(*backbuffer);    }    else    {        /* Do not set *backbuffer = NULL, see tests/device.c, test_swapchain(). */        hr = D3DERR_INVALIDCALL;    }    wined3d_mutex_unlock();    return hr;}

HRESULT d3d_get_private_data(struct wined3d_private_store *store,        REFGUID guid, UINT *data_size, void *data){    const struct wined3d_private_data *stored_data;    DWORD size_in;    if (!data_size)        return E_INVALIDARG;    wined3d_mutex_lock();    if (!(stored_data = wined3d_private_store_get_private_data(store, guid)))    {        *data_size = 0;        wined3d_mutex_unlock();        return DXGI_ERROR_NOT_FOUND;    }    size_in = *data_size;    *data_size = stored_data->size;    if (!data)    {        wined3d_mutex_unlock();        return S_OK;    }    if (size_in < stored_data->size)    {        wined3d_mutex_unlock();        return DXGI_ERROR_MORE_DATA;    }    if (stored_data->flags & WINED3DSPD_IUNKNOWN)        IUnknown_AddRef(stored_data->content.object);    memcpy(data, stored_data->content.data, stored_data->size);    wined3d_mutex_unlock();    return S_OK;}

HRESULT d3d9_resource_get_private_data(struct d3d9_resource *resource, const GUID *guid,        void *data, DWORD *data_size){    const struct wined3d_private_data *stored_data;    DWORD size_in;    HRESULT hr;    wined3d_mutex_lock();    stored_data = wined3d_private_store_get_private_data(&resource->private_store, guid);    if (!stored_data)    {        hr = D3DERR_NOTFOUND;        goto done;    }    size_in = *data_size;    *data_size = stored_data->size;    if (!data)    {        hr = D3D_OK;        goto done;    }    if (size_in < stored_data->size)    {        hr = D3DERR_MOREDATA;        goto done;    }    if (stored_data->flags & WINED3DSPD_IUNKNOWN)        IUnknown_AddRef(stored_data->content.object);    memcpy(data, stored_data->content.data, stored_data->size);    hr = D3D_OK;done:    wined3d_mutex_unlock();    return hr;}

static HRESULT WINAPI IDirect3D8Impl_CheckDeviceFormat(LPDIRECT3D8 iface, UINT Adapter,        D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, DWORD Usage, D3DRESOURCETYPE RType,        D3DFORMAT CheckFormat){    IDirect3D8Impl *This = impl_from_IDirect3D8(iface);    HRESULT hr;    WINED3DRESOURCETYPE WineD3DRType;    TRACE("iface %p, adapter %u, device_type %#x, adapter_format %#x, usage %#x, resource_type %#x, format %#x./n",            iface, Adapter, DeviceType, AdapterFormat, Usage, RType, CheckFormat);    if(CheckFormat == D3DFMT_R8G8B8)    {        /* See comment in dlls/d3d9/directx.c, IDirect3D9Impl_CheckDeviceFormat for details */        WARN("D3DFMT_R8G8B8 is not available on windows, returning D3DERR_NOTAVAILABLE/n");        return D3DERR_NOTAVAILABLE;    }    switch(RType) {        case D3DRTYPE_VERTEXBUFFER:        case D3DRTYPE_INDEXBUFFER:            WineD3DRType = WINED3DRTYPE_BUFFER;            break;        default:            WineD3DRType = RType;            break;    }    wined3d_mutex_lock();    hr = wined3d_check_device_format(This->WineD3D, Adapter, DeviceType, wined3dformat_from_d3dformat(AdapterFormat),            Usage, WineD3DRType, wined3dformat_from_d3dformat(CheckFormat), SURFACE_OPENGL);    wined3d_mutex_unlock();    return hr;}

static HRESULT STDMETHODCALLTYPE dxgi_swapchain_ResizeBuffers(IDXGISwapChain *iface,        UINT buffer_count, UINT width, UINT height, DXGI_FORMAT format, UINT flags){    struct dxgi_swapchain *swapchain = impl_from_IDXGISwapChain(iface);    struct wined3d_swapchain_desc wined3d_desc;    struct wined3d_texture *texture;    IUnknown *parent;    unsigned int i;    HRESULT hr;    TRACE("iface %p, buffer_count %u, width %u, height %u, format %s, flags %#x./n",          iface, buffer_count, width, height, debug_dxgi_format(format), flags);    if (flags)        FIXME("Ignoring flags %#x./n", flags);    wined3d_mutex_lock();    wined3d_swapchain_get_desc(swapchain->wined3d_swapchain, &wined3d_desc);    for (i = 0; i < wined3d_desc.backbuffer_count; ++i)    {        texture = wined3d_swapchain_get_back_buffer(swapchain->wined3d_swapchain, i);        parent = wined3d_texture_get_parent(texture);        IUnknown_AddRef(parent);        if (IUnknown_Release(parent))        {            wined3d_mutex_unlock();            return DXGI_ERROR_INVALID_CALL;        }    }    if (format != DXGI_FORMAT_UNKNOWN)        wined3d_desc.backbuffer_format = wined3dformat_from_dxgi_format(format);    hr = wined3d_swapchain_resize_buffers(swapchain->wined3d_swapchain, buffer_count, width, height,                                          wined3d_desc.backbuffer_format, wined3d_desc.multisample_type, wined3d_desc.multisample_quality);    wined3d_mutex_unlock();    return hr;}

/***************************************************************************** * IDirect3DVertexBuffer7::Lock * * Locks the vertex buffer and returns a pointer to the vertex data * Locking vertex buffers is similar to locking surfaces, because Windows * uses surfaces to store vertex data internally (According to the DX sdk) * * Params: *  Flags: Locking flags. Relevant here are DDLOCK_READONLY, DDLOCK_WRITEONLY, *         DDLOCK_DISCARDCONTENTS and DDLOCK_NOOVERWRITE. *  Data:  Returns a pointer to the vertex data *  Size:  Returns the size of the buffer if not NULL * * Returns: *  D3D_OK on success *  DDERR_INVALIDPARAMS if Data is NULL *  D3DERR_VERTEXBUFFEROPTIMIZED if called on an optimized buffer(WineD3D) * *****************************************************************************/static HRESULT WINAPI d3d_vertex_buffer7_Lock(IDirect3DVertexBuffer7 *iface,        DWORD flags, void **data, DWORD *data_size){    struct d3d_vertex_buffer *buffer = impl_from_IDirect3DVertexBuffer7(iface);    struct wined3d_resource_desc wined3d_desc;    struct wined3d_resource *wined3d_resource;    HRESULT hr;    DWORD wined3d_flags = 0;    TRACE("iface %p, flags %#x, data %p, data_size %p./n", iface, flags, data, data_size);    /* Writeonly: Pointless. Event: Unsupported by native according to the sdk     * nosyslock: Not applicable     */    if (!(flags & DDLOCK_WAIT))        wined3d_flags |= WINED3D_MAP_DONOTWAIT;    if (flags & DDLOCK_READONLY)        wined3d_flags |= WINED3D_MAP_READONLY;    if (flags & DDLOCK_NOOVERWRITE)        wined3d_flags |= WINED3D_MAP_NOOVERWRITE;    if (flags & DDLOCK_DISCARDCONTENTS)        wined3d_flags |= WINED3D_MAP_DISCARD;    wined3d_mutex_lock();    if (data_size)    {        /* Get the size, for returning it, and for locking */        wined3d_resource = wined3d_buffer_get_resource(buffer->wineD3DVertexBuffer);        wined3d_resource_get_desc(wined3d_resource, &wined3d_desc);        *data_size = wined3d_desc.size;    }    hr = wined3d_buffer_map(buffer->wineD3DVertexBuffer, 0, 0, (BYTE **)data, wined3d_flags);    wined3d_mutex_unlock();    return hr;}

static HRESULT STDMETHODCALLTYPE d3d10_texture2d_Map(ID3D10Texture2D *iface, UINT sub_resource_idx,        D3D10_MAP map_type, UINT map_flags, D3D10_MAPPED_TEXTURE2D *mapped_texture){    struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);    struct wined3d_map_desc wined3d_map_desc;    HRESULT hr;    TRACE("iface %p, sub_resource_idx %u, map_type %u, map_flags %#x, mapped_texture %p./n",            iface, sub_resource_idx, map_type, map_flags, mapped_texture);    if (map_flags)        FIXME("Ignoring map_flags %#x./n", map_flags);    wined3d_mutex_lock();    if (SUCCEEDED(hr = wined3d_texture_map(texture->wined3d_texture, sub_resource_idx,            &wined3d_map_desc, NULL, wined3d_map_flags_from_d3d10_map_type(map_type))))    {        mapped_texture->pData = wined3d_map_desc.data;        mapped_texture->RowPitch = wined3d_map_desc.row_pitch;    }    wined3d_mutex_unlock();    return hr;}

static HRESULT WINAPI IDirect3DSurface9Impl_GetDesc(IDirect3DSurface9 *iface, D3DSURFACE_DESC *desc){    IDirect3DSurface9Impl *This = impl_from_IDirect3DSurface9(iface);    struct wined3d_resource_desc wined3d_desc;    struct wined3d_resource *wined3d_resource;    TRACE("iface %p, desc %p./n", iface, desc);    wined3d_mutex_lock();    wined3d_resource = wined3d_surface_get_resource(This->wined3d_surface);    wined3d_resource_get_desc(wined3d_resource, &wined3d_desc);    wined3d_mutex_unlock();    desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format);    desc->Type = wined3d_desc.resource_type;    desc->Usage = wined3d_desc.usage;    desc->Pool = wined3d_desc.pool;    desc->MultiSampleType = wined3d_desc.multisample_type;    desc->MultiSampleQuality = wined3d_desc.multisample_quality;    desc->Width = wined3d_desc.width;    desc->Height = wined3d_desc.height;    return D3D_OK;}

HRESULT volumetexture_init(IDirect3DVolumeTexture8Impl *texture, IDirect3DDevice8Impl *device,        UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool){    HRESULT hr;    texture->IDirect3DVolumeTexture8_iface.lpVtbl = &Direct3DVolumeTexture8_Vtbl;    texture->ref = 1;    wined3d_mutex_lock();    hr = wined3d_texture_create_3d(device->wined3d_device, width, height, depth, levels,            usage & WINED3DUSAGE_MASK, wined3dformat_from_d3dformat(format), pool, texture,            &d3d8_volumetexture_wined3d_parent_ops, &texture->wined3d_texture);    wined3d_mutex_unlock();    if (FAILED(hr))    {        WARN("Failed to create wined3d volume texture, hr %#x./n", hr);        return hr;    }    texture->parentDevice = &device->IDirect3DDevice8_iface;    IDirect3DDevice8_AddRef(texture->parentDevice);    return D3D_OK;}