ddraw: Use the global memory allocation helpers.
Signed-off-by: Henri Verbeet <hverbeet@codeweavers.com> Signed-off-by: Alexandre Julliard <julliard@winehq.org>
This commit is contained in:
parent
529168ecf7
commit
9cc7c6e99f
|
@ -72,7 +72,7 @@ static ULONG WINAPI ddraw_clipper_Release(IDirectDrawClipper *iface)
|
|||
{
|
||||
if (clipper->region)
|
||||
DeleteObject(clipper->region);
|
||||
HeapFree(GetProcessHeap(), 0, clipper);
|
||||
heap_free(clipper);
|
||||
}
|
||||
|
||||
return refcount;
|
||||
|
|
|
@ -376,7 +376,7 @@ static void ddraw_destroy_swapchain(struct ddraw *ddraw)
|
|||
{
|
||||
wined3d_vertex_declaration_decref(ddraw->decls[i].decl);
|
||||
}
|
||||
HeapFree(GetProcessHeap(), 0, ddraw->decls);
|
||||
heap_free(ddraw->decls);
|
||||
ddraw->numConvertedDecls = 0;
|
||||
|
||||
if (FAILED(wined3d_device_uninit_3d(ddraw->wined3d_device)))
|
||||
|
@ -442,7 +442,7 @@ static void ddraw_destroy(struct ddraw *This)
|
|||
This->d3ddevice->ddraw = NULL;
|
||||
|
||||
/* Now free the object */
|
||||
HeapFree(GetProcessHeap(), 0, This);
|
||||
heap_free(This);
|
||||
}
|
||||
|
||||
/*****************************************************************************
|
||||
|
@ -600,8 +600,7 @@ static HRESULT ddraw_attach_d3d_device(struct ddraw *ddraw,
|
|||
}
|
||||
|
||||
ddraw->declArraySize = 2;
|
||||
ddraw->decls = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ddraw->decls) * ddraw->declArraySize);
|
||||
if (!ddraw->decls)
|
||||
if (!(ddraw->decls = heap_alloc_zero(ddraw->declArraySize * sizeof(*ddraw->decls))))
|
||||
{
|
||||
ERR("Error allocating an array for the converted vertex decls.\n");
|
||||
ddraw->declArraySize = 0;
|
||||
|
@ -2390,8 +2389,8 @@ static HRESULT WINAPI ddraw7_EnumDisplayModes(IDirectDraw7 *iface, DWORD Flags,
|
|||
if (!cb)
|
||||
return DDERR_INVALIDPARAMS;
|
||||
|
||||
enum_modes = HeapAlloc(GetProcessHeap(), 0, sizeof(*enum_modes) * enum_mode_array_size);
|
||||
if (!enum_modes) return DDERR_OUTOFMEMORY;
|
||||
if (!(enum_modes = heap_alloc(enum_mode_array_size * sizeof(*enum_modes))))
|
||||
return DDERR_OUTOFMEMORY;
|
||||
|
||||
wined3d_mutex_lock();
|
||||
|
||||
|
@ -2455,7 +2454,7 @@ static HRESULT WINAPI ddraw7_EnumDisplayModes(IDirectDraw7 *iface, DWORD Flags,
|
|||
if(cb(&callback_sd, Context) == DDENUMRET_CANCEL)
|
||||
{
|
||||
TRACE("Application asked to terminate the enumeration\n");
|
||||
HeapFree(GetProcessHeap(), 0, enum_modes);
|
||||
heap_free(enum_modes);
|
||||
wined3d_mutex_unlock();
|
||||
return DD_OK;
|
||||
}
|
||||
|
@ -2465,11 +2464,9 @@ static HRESULT WINAPI ddraw7_EnumDisplayModes(IDirectDraw7 *iface, DWORD Flags,
|
|||
struct wined3d_display_mode *new_enum_modes;
|
||||
|
||||
enum_mode_array_size *= 2;
|
||||
new_enum_modes = HeapReAlloc(GetProcessHeap(), 0, enum_modes,
|
||||
sizeof(*new_enum_modes) * enum_mode_array_size);
|
||||
if (!new_enum_modes)
|
||||
if (!(new_enum_modes = heap_realloc(enum_modes, enum_mode_array_size * sizeof(*new_enum_modes))))
|
||||
{
|
||||
HeapFree(GetProcessHeap(), 0, enum_modes);
|
||||
heap_free(enum_modes);
|
||||
wined3d_mutex_unlock();
|
||||
return DDERR_OUTOFMEMORY;
|
||||
}
|
||||
|
@ -2481,7 +2478,7 @@ static HRESULT WINAPI ddraw7_EnumDisplayModes(IDirectDraw7 *iface, DWORD Flags,
|
|||
}
|
||||
|
||||
TRACE("End of enumeration\n");
|
||||
HeapFree(GetProcessHeap(), 0, enum_modes);
|
||||
heap_free(enum_modes);
|
||||
wined3d_mutex_unlock();
|
||||
|
||||
return DD_OK;
|
||||
|
@ -3319,8 +3316,7 @@ HRESULT WINAPI DirectDrawCreateClipper(DWORD flags, IDirectDrawClipper **clipper
|
|||
|
||||
wined3d_mutex_lock();
|
||||
|
||||
object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
|
||||
if (!object)
|
||||
if (!(object = heap_alloc_zero(sizeof(*object))))
|
||||
{
|
||||
wined3d_mutex_unlock();
|
||||
return E_OUTOFMEMORY;
|
||||
|
@ -3330,7 +3326,7 @@ HRESULT WINAPI DirectDrawCreateClipper(DWORD flags, IDirectDrawClipper **clipper
|
|||
if (FAILED(hr))
|
||||
{
|
||||
WARN("Failed to initialize clipper, hr %#x.\n", hr);
|
||||
HeapFree(GetProcessHeap(), 0, object);
|
||||
heap_free(object);
|
||||
wined3d_mutex_unlock();
|
||||
return hr;
|
||||
}
|
||||
|
@ -3430,8 +3426,7 @@ static HRESULT WINAPI ddraw7_CreatePalette(IDirectDraw7 *iface, DWORD Flags,
|
|||
return DDERR_NOCOOPERATIVELEVELSET;
|
||||
}
|
||||
|
||||
object = HeapAlloc(GetProcessHeap(), 0, sizeof(*object));
|
||||
if (!object)
|
||||
if (!(object = heap_alloc(sizeof(*object))))
|
||||
{
|
||||
ERR("Out of memory when allocating memory for a palette implementation\n");
|
||||
wined3d_mutex_unlock();
|
||||
|
@ -3442,7 +3437,7 @@ static HRESULT WINAPI ddraw7_CreatePalette(IDirectDraw7 *iface, DWORD Flags,
|
|||
if (FAILED(hr))
|
||||
{
|
||||
WARN("Failed to initialize palette, hr %#x.\n", hr);
|
||||
HeapFree(GetProcessHeap(), 0, object);
|
||||
heap_free(object);
|
||||
wined3d_mutex_unlock();
|
||||
return hr;
|
||||
}
|
||||
|
@ -3838,10 +3833,10 @@ static HRESULT WINAPI d3d3_CreateLight(IDirect3D3 *iface, IDirect3DLight **light
|
|||
|
||||
TRACE("iface %p, light %p, outer_unknown %p.\n", iface, light, outer_unknown);
|
||||
|
||||
if (outer_unknown) return CLASS_E_NOAGGREGATION;
|
||||
if (outer_unknown)
|
||||
return CLASS_E_NOAGGREGATION;
|
||||
|
||||
object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
|
||||
if (!object)
|
||||
if (!(object = heap_alloc_zero(sizeof(*object))))
|
||||
{
|
||||
ERR("Failed to allocate light memory.\n");
|
||||
return DDERR_OUTOFMEMORY;
|
||||
|
@ -3988,8 +3983,7 @@ static HRESULT WINAPI d3d3_CreateViewport(IDirect3D3 *iface, IDirect3DViewport3
|
|||
|
||||
if (outer_unknown) return CLASS_E_NOAGGREGATION;
|
||||
|
||||
object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
|
||||
if (!object)
|
||||
if (!(object = heap_alloc_zero(sizeof(*object))))
|
||||
{
|
||||
ERR("Failed to allocate viewport memory.\n");
|
||||
return DDERR_OUTOFMEMORY;
|
||||
|
@ -4704,11 +4698,12 @@ struct wined3d_vertex_declaration *ddraw_find_decl(struct ddraw *This, DWORD fvf
|
|||
fvf, This, &ddraw_null_wined3d_parent_ops, &pDecl);
|
||||
if (hr != S_OK) return NULL;
|
||||
|
||||
if(This->declArraySize == This->numConvertedDecls) {
|
||||
int grow = max(This->declArraySize / 2, 8);
|
||||
convertedDecls = HeapReAlloc(GetProcessHeap(), 0, convertedDecls,
|
||||
sizeof(convertedDecls[0]) * (This->numConvertedDecls + grow));
|
||||
if (!convertedDecls)
|
||||
if (This->declArraySize == This->numConvertedDecls)
|
||||
{
|
||||
unsigned int grow = max(This->declArraySize / 2, 8);
|
||||
|
||||
if (!(convertedDecls = heap_realloc(convertedDecls,
|
||||
(This->numConvertedDecls + grow) * sizeof(*convertedDecls))))
|
||||
{
|
||||
wined3d_vertex_declaration_decref(pDecl);
|
||||
return NULL;
|
||||
|
@ -4824,7 +4819,7 @@ static HRESULT CDECL device_parent_surface_created(struct wined3d_device_parent
|
|||
return DD_OK;
|
||||
}
|
||||
|
||||
if (!(ddraw_surface = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ddraw_surface))))
|
||||
if (!(ddraw_surface = heap_alloc_zero(sizeof(*ddraw_surface))))
|
||||
{
|
||||
ERR("Failed to allocate surface memory.\n");
|
||||
return DDERR_OUTOFVIDEOMEMORY;
|
||||
|
|
|
@ -25,6 +25,7 @@
|
|||
#define NONAMELESSSTRUCT
|
||||
#define NONAMELESSUNION
|
||||
#include "wine/debug.h"
|
||||
#include "wine/heap.h"
|
||||
|
||||
#include "winbase.h"
|
||||
#include "wingdi.h"
|
||||
|
|
|
@ -322,7 +322,7 @@ static ULONG WINAPI d3d_device_inner_Release(IUnknown *iface)
|
|||
This->ddraw->d3ddevice = NULL;
|
||||
|
||||
/* Now free the structure */
|
||||
HeapFree(GetProcessHeap(), 0, This);
|
||||
heap_free(This);
|
||||
wined3d_mutex_unlock();
|
||||
}
|
||||
|
||||
|
@ -663,8 +663,7 @@ static HRESULT WINAPI d3d_device1_CreateExecuteBuffer(IDirect3DDevice *iface,
|
|||
return CLASS_E_NOAGGREGATION;
|
||||
|
||||
/* Allocate the new Execute Buffer */
|
||||
object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
|
||||
if(!object)
|
||||
if (!(object = heap_alloc_zero(sizeof(*object))))
|
||||
{
|
||||
ERR("Failed to allocate execute buffer memory.\n");
|
||||
return DDERR_OUTOFMEMORY;
|
||||
|
@ -674,7 +673,7 @@ static HRESULT WINAPI d3d_device1_CreateExecuteBuffer(IDirect3DDevice *iface,
|
|||
if (FAILED(hr))
|
||||
{
|
||||
WARN("Failed to initialize execute buffer, hr %#x.\n", hr);
|
||||
HeapFree(GetProcessHeap(), 0, object);
|
||||
heap_free(object);
|
||||
return hr;
|
||||
}
|
||||
|
||||
|
@ -1274,7 +1273,7 @@ static HRESULT WINAPI d3d_device1_EnumTextureFormats(IDirect3DDevice *iface,
|
|||
static HRESULT WINAPI d3d_device1_CreateMatrix(IDirect3DDevice *iface, D3DMATRIXHANDLE *D3DMatHandle)
|
||||
{
|
||||
struct d3d_device *device = impl_from_IDirect3DDevice(iface);
|
||||
D3DMATRIX *Matrix;
|
||||
D3DMATRIX *matrix;
|
||||
DWORD h;
|
||||
|
||||
TRACE("iface %p, matrix_handle %p.\n", iface, D3DMatHandle);
|
||||
|
@ -1282,8 +1281,7 @@ static HRESULT WINAPI d3d_device1_CreateMatrix(IDirect3DDevice *iface, D3DMATRIX
|
|||
if(!D3DMatHandle)
|
||||
return DDERR_INVALIDPARAMS;
|
||||
|
||||
Matrix = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(D3DMATRIX));
|
||||
if(!Matrix)
|
||||
if (!(matrix = heap_alloc_zero(sizeof(*matrix))))
|
||||
{
|
||||
ERR("Out of memory when allocating a D3DMATRIX\n");
|
||||
return DDERR_OUTOFMEMORY;
|
||||
|
@ -1291,11 +1289,11 @@ static HRESULT WINAPI d3d_device1_CreateMatrix(IDirect3DDevice *iface, D3DMATRIX
|
|||
|
||||
wined3d_mutex_lock();
|
||||
|
||||
h = ddraw_allocate_handle(&device->handle_table, Matrix, DDRAW_HANDLE_MATRIX);
|
||||
h = ddraw_allocate_handle(&device->handle_table, matrix, DDRAW_HANDLE_MATRIX);
|
||||
if (h == DDRAW_INVALID_HANDLE)
|
||||
{
|
||||
ERR("Failed to allocate a matrix handle.\n");
|
||||
HeapFree(GetProcessHeap(), 0, Matrix);
|
||||
heap_free(matrix);
|
||||
wined3d_mutex_unlock();
|
||||
return DDERR_OUTOFMEMORY;
|
||||
}
|
||||
|
@ -1446,7 +1444,7 @@ static HRESULT WINAPI d3d_device1_DeleteMatrix(IDirect3DDevice *iface, D3DMATRIX
|
|||
|
||||
wined3d_mutex_unlock();
|
||||
|
||||
HeapFree(GetProcessHeap(), 0, m);
|
||||
heap_free(m);
|
||||
|
||||
return D3D_OK;
|
||||
}
|
||||
|
@ -2218,11 +2216,11 @@ static HRESULT WINAPI d3d_device3_Vertex(IDirect3DDevice3 *iface, void *vertex)
|
|||
|
||||
device->buffer_size = device->buffer_size ? device->buffer_size * 2 : device->vertex_size * 3;
|
||||
old_buffer = device->sysmem_vertex_buffer;
|
||||
device->sysmem_vertex_buffer = HeapAlloc(GetProcessHeap(), 0, device->buffer_size);
|
||||
device->sysmem_vertex_buffer = heap_alloc(device->buffer_size);
|
||||
if (old_buffer)
|
||||
{
|
||||
memcpy(device->sysmem_vertex_buffer, old_buffer, device->nb_vertices * device->vertex_size);
|
||||
HeapFree(GetProcessHeap(), 0, old_buffer);
|
||||
heap_free(old_buffer);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -7020,8 +7018,7 @@ HRESULT d3d_device_create(struct ddraw *ddraw, struct ddraw_surface *target, IUn
|
|||
return DDERR_INVALIDPARAMS;
|
||||
}
|
||||
|
||||
object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
|
||||
if (!object)
|
||||
if (!(object = heap_alloc_zero(sizeof(*object))))
|
||||
{
|
||||
ERR("Failed to allocate device memory.\n");
|
||||
return DDERR_OUTOFMEMORY;
|
||||
|
@ -7030,7 +7027,7 @@ HRESULT d3d_device_create(struct ddraw *ddraw, struct ddraw_surface *target, IUn
|
|||
if (FAILED(hr = d3d_device_init(object, ddraw, target, rt_iface, version, outer_unknown)))
|
||||
{
|
||||
WARN("Failed to initialize device, hr %#x.\n", hr);
|
||||
HeapFree(GetProcessHeap(), 0, object);
|
||||
heap_free(object);
|
||||
return hr;
|
||||
}
|
||||
|
||||
|
|
|
@ -508,7 +508,7 @@ static ULONG WINAPI d3d_execute_buffer_Release(IDirect3DExecuteBuffer *iface)
|
|||
if (!ref)
|
||||
{
|
||||
if (buffer->need_free)
|
||||
HeapFree(GetProcessHeap(), 0, buffer->desc.lpData);
|
||||
heap_free(buffer->desc.lpData);
|
||||
if (buffer->index_buffer)
|
||||
wined3d_buffer_decref(buffer->index_buffer);
|
||||
if (buffer->dst_vertex_buffer)
|
||||
|
@ -516,7 +516,7 @@ static ULONG WINAPI d3d_execute_buffer_Release(IDirect3DExecuteBuffer *iface)
|
|||
wined3d_buffer_decref(buffer->src_vertex_buffer);
|
||||
wined3d_buffer_decref(buffer->dst_vertex_buffer);
|
||||
}
|
||||
HeapFree(GetProcessHeap(), 0, buffer);
|
||||
heap_free(buffer);
|
||||
}
|
||||
|
||||
return ref;
|
||||
|
@ -791,8 +791,7 @@ HRESULT d3d_execute_buffer_init(struct d3d_execute_buffer *execute_buffer,
|
|||
if (!execute_buffer->desc.lpData && execute_buffer->desc.dwBufferSize)
|
||||
{
|
||||
execute_buffer->need_free = TRUE;
|
||||
execute_buffer->desc.lpData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, execute_buffer->desc.dwBufferSize);
|
||||
if (!execute_buffer->desc.lpData)
|
||||
if (!(execute_buffer->desc.lpData = heap_alloc_zero(execute_buffer->desc.dwBufferSize)))
|
||||
{
|
||||
ERR("Failed to allocate execute buffer data.\n");
|
||||
return DDERR_OUTOFMEMORY;
|
||||
|
|
|
@ -133,7 +133,7 @@ static ULONG WINAPI d3d_light_Release(IDirect3DLight *iface)
|
|||
|
||||
if (!ref)
|
||||
{
|
||||
HeapFree(GetProcessHeap(), 0, light);
|
||||
heap_free(light);
|
||||
return 0;
|
||||
}
|
||||
return ref;
|
||||
|
|
|
@ -92,8 +92,7 @@ static void ddraw_enumerate_secondary_devices(struct wined3d *wined3d, LPDDENUMC
|
|||
/* Handle table functions */
|
||||
BOOL ddraw_handle_table_init(struct ddraw_handle_table *t, UINT initial_size)
|
||||
{
|
||||
t->entries = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, initial_size * sizeof(*t->entries));
|
||||
if (!t->entries)
|
||||
if (!(t->entries = heap_alloc_zero(initial_size * sizeof(*t->entries))))
|
||||
{
|
||||
ERR("Failed to allocate handle table memory.\n");
|
||||
return FALSE;
|
||||
|
@ -107,7 +106,7 @@ BOOL ddraw_handle_table_init(struct ddraw_handle_table *t, UINT initial_size)
|
|||
|
||||
void ddraw_handle_table_destroy(struct ddraw_handle_table *t)
|
||||
{
|
||||
HeapFree(GetProcessHeap(), 0, t->entries);
|
||||
heap_free(t->entries);
|
||||
memset(t, 0, sizeof(*t));
|
||||
}
|
||||
|
||||
|
@ -136,9 +135,9 @@ DWORD ddraw_allocate_handle(struct ddraw_handle_table *t, void *object, enum ddr
|
|||
{
|
||||
/* Grow the table */
|
||||
UINT new_size = t->table_size + (t->table_size >> 1);
|
||||
struct ddraw_handle_entry *new_entries = HeapReAlloc(GetProcessHeap(),
|
||||
0, t->entries, new_size * sizeof(*t->entries));
|
||||
if (!new_entries)
|
||||
struct ddraw_handle_entry *new_entries;
|
||||
|
||||
if (!(new_entries = heap_realloc(t->entries, new_size * sizeof(*t->entries))))
|
||||
{
|
||||
ERR("Failed to grow the handle table.\n");
|
||||
return DDRAW_INVALID_HANDLE;
|
||||
|
@ -298,8 +297,7 @@ DDRAW_Create(const GUID *guid,
|
|||
flags = WINED3D_LEGACY_FFP_LIGHTING;
|
||||
|
||||
/* DirectDraw creation comes here */
|
||||
ddraw = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ddraw));
|
||||
if (!ddraw)
|
||||
if (!(ddraw = heap_alloc_zero(sizeof(*ddraw))))
|
||||
{
|
||||
ERR("Out of memory when creating DirectDraw\n");
|
||||
return E_OUTOFMEMORY;
|
||||
|
@ -309,7 +307,7 @@ DDRAW_Create(const GUID *guid,
|
|||
if (FAILED(hr))
|
||||
{
|
||||
WARN("Failed to initialize ddraw object, hr %#x.\n", hr);
|
||||
HeapFree(GetProcessHeap(), 0, ddraw);
|
||||
heap_free(ddraw);
|
||||
return hr;
|
||||
}
|
||||
|
||||
|
@ -670,7 +668,7 @@ static ULONG WINAPI ddraw_class_factory_Release(IClassFactory *iface)
|
|||
TRACE("%p decreasing refcount to %u.\n", factory, ref);
|
||||
|
||||
if (!ref)
|
||||
HeapFree(GetProcessHeap(), 0, factory);
|
||||
heap_free(factory);
|
||||
|
||||
return ref;
|
||||
}
|
||||
|
@ -754,8 +752,8 @@ HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, void **out)
|
|||
return CLASS_E_CLASSNOTAVAILABLE;
|
||||
}
|
||||
|
||||
factory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*factory));
|
||||
if (factory == NULL) return E_OUTOFMEMORY;
|
||||
if (!(factory = heap_alloc_zero(sizeof(*factory))))
|
||||
return E_OUTOFMEMORY;
|
||||
|
||||
factory->IClassFactory_iface.lpVtbl = &IClassFactory_Vtbl;
|
||||
factory->ref = 1;
|
||||
|
|
|
@ -150,7 +150,7 @@ static ULONG WINAPI d3d_material3_Release(IDirect3DMaterial3 *iface)
|
|||
wined3d_mutex_unlock();
|
||||
}
|
||||
|
||||
HeapFree(GetProcessHeap(), 0, material);
|
||||
heap_free(material);
|
||||
}
|
||||
|
||||
return ref;
|
||||
|
@ -502,8 +502,7 @@ struct d3d_material *d3d_material_create(struct ddraw *ddraw)
|
|||
{
|
||||
struct d3d_material *material;
|
||||
|
||||
material = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*material));
|
||||
if (!material)
|
||||
if (!(material = heap_alloc_zero(sizeof(*material))))
|
||||
return NULL;
|
||||
|
||||
material->IDirect3DMaterial3_iface.lpVtbl = &d3d_material3_vtbl;
|
||||
|
|
|
@ -100,7 +100,7 @@ static ULONG WINAPI ddraw_palette_Release(IDirectDrawPalette *iface)
|
|||
IUnknown_Release(palette->ifaceToRelease);
|
||||
wined3d_mutex_unlock();
|
||||
|
||||
HeapFree(GetProcessHeap(), 0, palette);
|
||||
heap_free(palette);
|
||||
}
|
||||
|
||||
return ref;
|
||||
|
|
|
@ -1505,7 +1505,7 @@ static HRESULT ddraw_surface_blt_clipped(struct ddraw_surface *dst_surface, cons
|
|||
return hr;
|
||||
}
|
||||
|
||||
if (!(clip_list = HeapAlloc(GetProcessHeap(), 0, clip_list_size)))
|
||||
if (!(clip_list = heap_alloc(clip_list_size)))
|
||||
{
|
||||
WARN("Failed to allocate clip list.\n");
|
||||
return E_OUTOFMEMORY;
|
||||
|
@ -1515,7 +1515,7 @@ static HRESULT ddraw_surface_blt_clipped(struct ddraw_surface *dst_surface, cons
|
|||
&dst_rect, clip_list, &clip_list_size)))
|
||||
{
|
||||
WARN("Failed to get clip list, hr %#x.\n", hr);
|
||||
HeapFree(GetProcessHeap(), 0, clip_list);
|
||||
heap_free(clip_list);
|
||||
return hr;
|
||||
}
|
||||
|
||||
|
@ -1549,7 +1549,7 @@ static HRESULT ddraw_surface_blt_clipped(struct ddraw_surface *dst_surface, cons
|
|||
}
|
||||
}
|
||||
|
||||
HeapFree(GetProcessHeap(), 0, clip_list);
|
||||
heap_free(clip_list);
|
||||
return hr;
|
||||
}
|
||||
|
||||
|
@ -5750,7 +5750,7 @@ static void STDMETHODCALLTYPE ddraw_surface_wined3d_object_destroyed(void *paren
|
|||
|
||||
wined3d_private_store_cleanup(&surface->private_store);
|
||||
|
||||
HeapFree(GetProcessHeap(), 0, surface);
|
||||
heap_free(surface);
|
||||
}
|
||||
|
||||
static const struct wined3d_parent_ops ddraw_surface_wined3d_parent_ops =
|
||||
|
@ -5762,7 +5762,7 @@ static void STDMETHODCALLTYPE ddraw_texture_wined3d_object_destroyed(void *paren
|
|||
{
|
||||
TRACE("parent %p.\n", parent);
|
||||
|
||||
HeapFree(GetProcessHeap(), 0, parent);
|
||||
heap_free(parent);
|
||||
}
|
||||
|
||||
static const struct wined3d_parent_ops ddraw_texture_wined3d_parent_ops =
|
||||
|
@ -5804,7 +5804,7 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_
|
|||
if (!surface)
|
||||
return E_POINTER;
|
||||
|
||||
if (!(texture = HeapAlloc(GetProcessHeap(), 0, sizeof(*texture))))
|
||||
if (!(texture = heap_alloc(sizeof(*texture))))
|
||||
return E_OUTOFMEMORY;
|
||||
|
||||
texture->version = version;
|
||||
|
@ -5819,28 +5819,28 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_
|
|||
if (!(desc->dwFlags & DDSD_BACKBUFFERCOUNT) || !desc->u5.dwBackBufferCount)
|
||||
{
|
||||
WARN("Tried to create a flippable surface without any back buffers.\n");
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return DDERR_INVALIDCAPS;
|
||||
}
|
||||
|
||||
if (!(desc->ddsCaps.dwCaps & DDSCAPS_COMPLEX))
|
||||
{
|
||||
WARN("Tried to create a flippable surface without DDSCAPS_COMPLEX.\n");
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return DDERR_INVALIDCAPS;
|
||||
}
|
||||
|
||||
if (desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
|
||||
{
|
||||
WARN("Tried to create a flippable cubemap.\n");
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return DDERR_INVALIDPARAMS;
|
||||
}
|
||||
|
||||
if (desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE)
|
||||
{
|
||||
FIXME("Flippable textures not implemented.\n");
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return DDERR_INVALIDCAPS;
|
||||
}
|
||||
}
|
||||
|
@ -5850,7 +5850,7 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_
|
|||
{
|
||||
WARN("Tried to specify a back buffer count for a non-flippable surface.\n");
|
||||
hr = desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP ? DDERR_INVALIDPARAMS : DDERR_INVALIDCAPS;
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return hr;
|
||||
}
|
||||
}
|
||||
|
@ -5860,21 +5860,21 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_
|
|||
if (desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE)
|
||||
{
|
||||
WARN("Tried to create a primary surface with DDSCAPS_TEXTURE.\n");
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return DDERR_INVALIDCAPS;
|
||||
}
|
||||
|
||||
if ((desc->ddsCaps.dwCaps & DDSCAPS_COMPLEX) && !(desc->ddsCaps.dwCaps & DDSCAPS_FLIP))
|
||||
{
|
||||
WARN("Tried to create a flippable primary surface without both DDSCAPS_FLIP and DDSCAPS_COMPLEX.\n");
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return DDERR_INVALIDCAPS;
|
||||
}
|
||||
|
||||
if ((desc->ddsCaps.dwCaps & DDSCAPS_FLIP) && !(ddraw->cooperative_level & DDSCL_EXCLUSIVE))
|
||||
{
|
||||
WARN("Tried to create a flippable primary surface without DDSCL_EXCLUSIVE.\n");
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return DDERR_NOEXCLUSIVEMODE;
|
||||
}
|
||||
}
|
||||
|
@ -5884,7 +5884,7 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_
|
|||
== (DDSCAPS_VIDEOMEMORY | DDSCAPS_SYSTEMMEMORY))
|
||||
{
|
||||
WARN("Tried to create a surface in both system and video memory.\n");
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return DDERR_INVALIDCAPS;
|
||||
}
|
||||
|
||||
|
@ -5892,7 +5892,7 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_
|
|||
&& !(desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE))
|
||||
{
|
||||
WARN("Caps %#x require DDSCAPS_TEXTURE.\n", desc->ddsCaps.dwCaps);
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return DDERR_INVALIDCAPS;
|
||||
}
|
||||
|
||||
|
@ -5900,7 +5900,7 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_
|
|||
&& !(desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP))
|
||||
{
|
||||
WARN("Cube map faces requested without cube map flag.\n");
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return DDERR_INVALIDCAPS;
|
||||
}
|
||||
|
||||
|
@ -5908,7 +5908,7 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_
|
|||
&& !(desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES))
|
||||
{
|
||||
WARN("Cube map without faces requested.\n");
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return DDERR_INVALIDPARAMS;
|
||||
}
|
||||
|
||||
|
@ -5921,14 +5921,14 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_
|
|||
if (!(desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE))
|
||||
{
|
||||
WARN("DDSCAPS2_TEXTUREMANAGE used without DDSCAPS_TEXTURE, returning DDERR_INVALIDCAPS.\n");
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return DDERR_INVALIDCAPS;
|
||||
}
|
||||
if (desc->ddsCaps.dwCaps & (DDSCAPS_VIDEOMEMORY | DDSCAPS_SYSTEMMEMORY))
|
||||
{
|
||||
WARN("DDSCAPS2_TEXTUREMANAGE used width DDSCAPS_VIDEOMEMORY "
|
||||
"or DDSCAPS_SYSTEMMEMORY, returning DDERR_INVALIDCAPS.\n");
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return DDERR_INVALIDCAPS;
|
||||
}
|
||||
}
|
||||
|
@ -5936,7 +5936,7 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_
|
|||
if (FAILED(hr = wined3d_get_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &mode, NULL)))
|
||||
{
|
||||
ERR("Failed to get display mode, hr %#x.\n", hr);
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return hr_ddraw_from_wined3d(hr);
|
||||
}
|
||||
|
||||
|
@ -5953,7 +5953,7 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_
|
|||
if (wined3d_desc.format == WINED3DFMT_UNKNOWN)
|
||||
{
|
||||
WARN("Unsupported / unknown pixelformat.\n");
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return DDERR_INVALIDPIXELFORMAT;
|
||||
}
|
||||
|
||||
|
@ -5963,7 +5963,7 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_
|
|||
if (!(desc->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE))
|
||||
{
|
||||
WARN("No width / height specified.\n");
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return DDERR_INVALIDPARAMS;
|
||||
}
|
||||
|
||||
|
@ -5974,7 +5974,7 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_
|
|||
|
||||
if (!desc->dwWidth || !desc->dwHeight)
|
||||
{
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return DDERR_INVALIDPARAMS;
|
||||
}
|
||||
|
||||
|
@ -5999,7 +5999,7 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_
|
|||
&swapchain_desc, NULL, ddraw_reset_enum_callback, TRUE)))
|
||||
{
|
||||
ERR("Failed to reset device.\n");
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return hr_ddraw_from_wined3d(hr);
|
||||
}
|
||||
|
||||
|
@ -6033,7 +6033,7 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_
|
|||
/* Mipmap count is given, should not be 0. */
|
||||
if (!desc->u2.dwMipMapCount)
|
||||
{
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return DDERR_INVALIDPARAMS;
|
||||
}
|
||||
}
|
||||
|
@ -6094,7 +6094,7 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_
|
|||
== (DDSCAPS_OVERLAY | DDSCAPS_SYSTEMMEMORY))
|
||||
{
|
||||
WARN("System memory overlays are not allowed.\n");
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return DDERR_NOOVERLAYHW;
|
||||
}
|
||||
|
||||
|
@ -6132,21 +6132,21 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_
|
|||
if (wined3d_desc.access & WINED3D_RESOURCE_ACCESS_GPU)
|
||||
{
|
||||
WARN("User memory surfaces should not be GPU accessible.\n");
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return DDERR_INVALIDCAPS;
|
||||
}
|
||||
|
||||
if (version < 4)
|
||||
{
|
||||
WARN("User memory surfaces not supported before version 4.\n");
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return DDERR_INVALIDPARAMS;
|
||||
}
|
||||
|
||||
if (!desc->lpSurface)
|
||||
{
|
||||
WARN("NULL surface memory pointer specified.\n");
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return DDERR_INVALIDPARAMS;
|
||||
}
|
||||
|
||||
|
@ -6155,14 +6155,14 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_
|
|||
if (version != 4 && (desc->dwFlags & DDSD_PITCH))
|
||||
{
|
||||
WARN("Pitch specified on a compressed user memory surface.\n");
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return DDERR_INVALIDPARAMS;
|
||||
}
|
||||
|
||||
if (!(desc->dwFlags & (DDSD_LINEARSIZE | DDSD_PITCH)))
|
||||
{
|
||||
WARN("Compressed user memory surfaces should explicitly specify the linear size.\n");
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return DDERR_INVALIDPARAMS;
|
||||
}
|
||||
|
||||
|
@ -6171,7 +6171,7 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_
|
|||
wined3d_desc.format, wined3d_desc.width) * ((desc->dwHeight + 3) / 4))
|
||||
{
|
||||
WARN("Invalid linear size %u specified.\n", desc->u1.dwLinearSize);
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return DDERR_INVALIDPARAMS;
|
||||
}
|
||||
}
|
||||
|
@ -6180,7 +6180,7 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_
|
|||
if (!(desc->dwFlags & DDSD_PITCH))
|
||||
{
|
||||
WARN("User memory surfaces should explicitly specify the pitch.\n");
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return DDERR_INVALIDPARAMS;
|
||||
}
|
||||
|
||||
|
@ -6188,7 +6188,7 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_
|
|||
wined3d_desc.format, wined3d_desc.width) || desc->u1.lPitch & 3)
|
||||
{
|
||||
WARN("Invalid pitch %u specified.\n", desc->u1.lPitch);
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return DDERR_INVALIDPARAMS;
|
||||
}
|
||||
|
||||
|
@ -6206,7 +6206,7 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_
|
|||
&& desc->ddckCKSrcBlt.dwColorSpaceLowValue != desc->ddckCKSrcBlt.dwColorSpaceHighValue))
|
||||
{
|
||||
WARN("Range color keys not supported, returning DDERR_NOCOLORKEYHW.\n");
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return DDERR_NOCOLORKEYHW;
|
||||
}
|
||||
|
||||
|
@ -6233,7 +6233,7 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_
|
|||
&ddraw_texture_wined3d_parent_ops, &wined3d_texture)))
|
||||
{
|
||||
WARN("Failed to create wined3d texture, hr %#x.\n", hr);
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
return hr_ddraw_from_wined3d(hr);
|
||||
}
|
||||
|
||||
|
@ -6330,7 +6330,7 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_
|
|||
attach = &last->complex_array[0];
|
||||
for (i = 0; i < count; ++i)
|
||||
{
|
||||
if (!(texture = HeapAlloc(GetProcessHeap(), 0, sizeof(*texture))))
|
||||
if (!(texture = heap_alloc(sizeof(*texture))))
|
||||
{
|
||||
hr = E_OUTOFMEMORY;
|
||||
goto fail;
|
||||
|
@ -6352,7 +6352,7 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_
|
|||
WINED3D_TEXTURE_CREATE_GET_DC_LENIENT, NULL, texture,
|
||||
&ddraw_texture_wined3d_parent_ops, &wined3d_texture)))
|
||||
{
|
||||
HeapFree(GetProcessHeap(), 0, texture);
|
||||
heap_free(texture);
|
||||
hr = hr_ddraw_from_wined3d(hr);
|
||||
goto fail;
|
||||
}
|
||||
|
|
|
@ -102,7 +102,7 @@ static ULONG WINAPI d3d_vertex_buffer7_Release(IDirect3DVertexBuffer7 *iface)
|
|||
if (buffer->version == 7)
|
||||
IDirectDraw7_Release(&buffer->ddraw->IDirectDraw7_iface);
|
||||
|
||||
HeapFree(GetProcessHeap(), 0, buffer);
|
||||
heap_free(buffer);
|
||||
}
|
||||
|
||||
return ref;
|
||||
|
@ -451,8 +451,7 @@ HRESULT d3d_vertex_buffer_create(struct d3d_vertex_buffer **vertex_buf,
|
|||
TRACE(" FVF %#x\n", desc->dwFVF);
|
||||
TRACE(" dwNumVertices %u\n", desc->dwNumVertices);
|
||||
|
||||
buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*buffer));
|
||||
if (!buffer)
|
||||
if (!(buffer = heap_alloc_zero(sizeof(*buffer))))
|
||||
return DDERR_OUTOFMEMORY;
|
||||
|
||||
buffer->IDirect3DVertexBuffer7_iface.lpVtbl = &d3d_vertex_buffer7_vtbl;
|
||||
|
@ -489,7 +488,7 @@ end:
|
|||
if (hr == D3D_OK)
|
||||
*vertex_buf = buffer;
|
||||
else
|
||||
HeapFree(GetProcessHeap(), 0, buffer);
|
||||
heap_free(buffer);
|
||||
|
||||
return hr;
|
||||
}
|
||||
|
|
|
@ -221,7 +221,7 @@ static ULONG WINAPI d3d_viewport_Release(IDirect3DViewport3 *iface)
|
|||
TRACE("%p decreasing refcount to %u.\n", viewport, ref);
|
||||
|
||||
if (!ref)
|
||||
HeapFree(GetProcessHeap(), 0, viewport);
|
||||
heap_free(viewport);
|
||||
|
||||
return ref;
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue