system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-09-15 03:19:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

wined3d: Use the global memory allocation helpers.

Browse source 
Signed-off-by: Henri Verbeet <hverbeet@codeweavers.com>
Signed-off-by: Alexandre Julliard <julliard@winehq.org>
This commit is contained in:
Henri Verbeet 2018-02-14 10:09:59 +03:30 committed by Alexandre Julliard
parent 4e37d1c01d
commit f08342f573
25 changed files with 439 additions and 453 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

136
dlls/wined3d/arb_program_shader.c
View file

@ -3880,7 +3880,7 @@ static void clone_sig(struct wined3d_shader_signature *new, const struct wined3d
char *name;
new->element_count = sig->element_count;
new->elements = wined3d_calloc(new->element_count, sizeof(*new->elements));
new->elements = heap_calloc(new->element_count, sizeof(*new->elements));
for (i = 0; i < sig->element_count; ++i)
{
new->elements[i] = sig->elements[i];
@ -3889,7 +3889,7 @@ static void clone_sig(struct wined3d_shader_signature *new, const struct wined3d
continue;
/* Clone the semantic string */
name = HeapAlloc(GetProcessHeap(), 0, strlen(sig->elements[i].semantic_name) + 1);
name = heap_alloc(strlen(sig->elements[i].semantic_name) + 1);
strcpy(name, sig->elements[i].semantic_name);
new->elements[i].semantic_name = name;
}
@ -3906,7 +3906,7 @@ static DWORD find_input_signature(struct shader_arb_priv *priv, const struct win
TRACE("Found existing signature %u\n", found_sig->idx);
return found_sig->idx;
}
found_sig = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*found_sig));
found_sig = heap_alloc_zero(sizeof(*found_sig));
clone_sig(&found_sig->sig, sig);
found_sig->idx = priv->ps_sig_number++;
TRACE("New signature stored and assigned number %u\n", found_sig->idx);
@ -4258,7 +4258,7 @@ static struct arb_ps_compiled_shader *find_arb_pshader(struct wined3d_shader *sh
{
struct shader_arb_priv *priv = device->shader_priv;
shader->backend_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data));
shader->backend_data = heap_alloc_zero(sizeof(*shader_data));
shader_data = shader->backend_data;
shader_data->clamp_consts = shader->reg_maps.shader_version.major == 1;
@ -4294,8 +4294,10 @@ static struct arb_ps_compiled_shader *find_arb_pshader(struct wined3d_shader *sh
new_size = shader_data->shader_array_size + max(1, shader_data->shader_array_size / 2);
new_array = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, shader_data->gl_shaders,
new_size * sizeof(*shader_data->gl_shaders));
} else {
new_array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data->gl_shaders));
}
else
{
new_array = heap_alloc_zero(sizeof(*shader_data->gl_shaders));
new_size = 1;
}
@ -4353,7 +4355,7 @@ static struct arb_vs_compiled_shader *find_arb_vshader(struct wined3d_shader *sh
{
const struct wined3d_shader_reg_maps *reg_maps = &shader->reg_maps;
shader->backend_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data));
shader->backend_data = heap_alloc_zero(sizeof(*shader_data));
shader_data = shader->backend_data;
if ((gl_info->quirks & WINED3D_QUIRK_ARB_VS_OFFSET_LIMIT)
@ -4393,8 +4395,10 @@ static struct arb_vs_compiled_shader *find_arb_vshader(struct wined3d_shader *sh
new_size = shader_data->shader_array_size + max(1, shader_data->shader_array_size / 2);
new_array = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, shader_data->gl_shaders,
new_size * sizeof(*shader_data->gl_shaders));
} else {
new_array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data->gl_shaders));
}
else
{
new_array = heap_alloc_zero(sizeof(*shader_data->gl_shaders));
new_size = 1;
}
@ -4762,8 +4766,8 @@ static void shader_arb_destroy(struct wined3d_shader *shader)
context_release(context);
}
HeapFree(GetProcessHeap(), 0, shader_data->gl_shaders);
HeapFree(GetProcessHeap(), 0, shader_data);
heap_free(shader_data->gl_shaders);
heap_free(shader_data);
shader->backend_data = NULL;
}
else
@ -4786,8 +4790,8 @@ static void shader_arb_destroy(struct wined3d_shader *shader)
context_release(context);
}
HeapFree(GetProcessHeap(), 0, shader_data->gl_shaders);
HeapFree(GetProcessHeap(), 0, shader_data);
heap_free(shader_data->gl_shaders);
heap_free(shader_data);
shader->backend_data = NULL;
}
}
@ -4801,15 +4805,18 @@ static int sig_tree_compare(const void *key, const struct wine_rb_entry *entry)
static HRESULT shader_arb_alloc(struct wined3d_device *device, const struct wined3d_vertex_pipe_ops *vertex_pipe,
const struct fragment_pipeline *fragment_pipe)
{
struct shader_arb_priv *priv = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*priv));
const struct wined3d_d3d_info *d3d_info = &device->adapter->d3d_info;
struct fragment_caps fragment_caps;
void *vertex_priv, *fragment_priv;
const struct wined3d_d3d_info *d3d_info = &device->adapter->d3d_info;
struct shader_arb_priv *priv;
if (!(priv = heap_alloc_zero(sizeof(*priv))))
return E_OUTOFMEMORY;
if (!(vertex_priv = vertex_pipe->vp_alloc(&arb_program_shader_backend, priv)))
{
ERR("Failed to initialize vertex pipe.\n");
HeapFree(GetProcessHeap(), 0, priv);
heap_free(priv);
return E_FAIL;
}
@ -4817,7 +4824,7 @@ static HRESULT shader_arb_alloc(struct wined3d_device *device, const struct wine
{
ERR("Failed to initialize fragment pipe.\n");
vertex_pipe->vp_free(device);
HeapFree(GetProcessHeap(), 0, priv);
heap_free(priv);
return E_FAIL;
}
@ -4847,10 +4854,10 @@ static void release_signature(struct wine_rb_entry *entry, void *context)
for (i = 0; i < sig->sig.element_count; ++i)
{
HeapFree(GetProcessHeap(), 0, (char *)sig->sig.elements[i].semantic_name);
heap_free((char *)sig->sig.elements[i].semantic_name);
}
HeapFree(GetProcessHeap(), 0, sig->sig.elements);
HeapFree(GetProcessHeap(), 0, sig);
heap_free(sig->sig.elements);
heap_free(sig);
}
/* Context activation is done by the caller. */
@ -4861,7 +4868,7 @@ static void shader_arb_free(struct wined3d_device *device)
wine_rb_destroy(&priv->signature_tree, release_signature, NULL);
priv->fragment_pipe->free_private(device);
priv->vertex_pipe->vp_free(device);
HeapFree(GetProcessHeap(), 0, device->shader_priv);
heap_free(device->shader_priv);
}
static BOOL shader_arb_allocate_context_data(struct wined3d_context *context)
@ -5329,39 +5336,38 @@ static void get_loop_control_const(const struct wined3d_shader_instruction *ins,
static void record_instruction(struct list *list, const struct wined3d_shader_instruction *ins)
{
unsigned int i;
struct wined3d_shader_dst_param *dst_param;
struct wined3d_shader_src_param *src_param = NULL, *rel_addr;
struct recorded_instruction *rec = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*rec));
if(!rec)
struct wined3d_shader_dst_param *dst_param;
struct recorded_instruction *rec;
unsigned int i;
if (!(rec = heap_alloc_zero(sizeof(*rec))))
{
ERR("Out of memory\n");
return;
}
rec->ins = *ins;
dst_param = HeapAlloc(GetProcessHeap(), 0, sizeof(*dst_param));
if(!dst_param) goto free;
if (!(dst_param = heap_alloc(sizeof(*dst_param))))
goto free;
*dst_param = *ins->dst;
if (ins->dst->reg.idx[0].rel_addr)
{
rel_addr = HeapAlloc(GetProcessHeap(), 0, sizeof(*rel_addr));
if (!rel_addr)
if (!(rel_addr = heap_alloc(sizeof(*rel_addr))))
goto free;
*rel_addr = *ins->dst->reg.idx[0].rel_addr;
dst_param->reg.idx[0].rel_addr = rel_addr;
}
rec->ins.dst = dst_param;
if (!(src_param = wined3d_calloc(ins->src_count, sizeof(*src_param))))
if (!(src_param = heap_calloc(ins->src_count, sizeof(*src_param))))
goto free;
for (i = 0; i < ins->src_count; ++i)
{
src_param[i] = ins->src[i];
if (ins->src[i].reg.idx[0].rel_addr)
{
rel_addr = HeapAlloc(GetProcessHeap(), 0, sizeof(*rel_addr));
if (!rel_addr)
if (!(rel_addr = heap_alloc(sizeof(*rel_addr))))
goto free;
*rel_addr = *ins->src[i].reg.idx[0].rel_addr;
src_param[i].reg.idx[0].rel_addr = rel_addr;
@ -5373,20 +5379,20 @@ static void record_instruction(struct list *list, const struct wined3d_shader_in
free:
ERR("Out of memory\n");
if(dst_param)
if (dst_param)
{
HeapFree(GetProcessHeap(), 0, (void *)dst_param->reg.idx[0].rel_addr);
HeapFree(GetProcessHeap(), 0, dst_param);
heap_free((void *)dst_param->reg.idx[0].rel_addr);
heap_free(dst_param);
}
if(src_param)
if (src_param)
{
for(i = 0; i < ins->src_count; i++)
for (i = 0; i < ins->src_count; ++i)
{
HeapFree(GetProcessHeap(), 0, (void *)src_param[i].reg.idx[0].rel_addr);
heap_free((void *)src_param[i].reg.idx[0].rel_addr);
}
HeapFree(GetProcessHeap(), 0, src_param);
heap_free(src_param);
}
HeapFree(GetProcessHeap(), 0, rec);
heap_free(rec);
}
static void free_recorded_instruction(struct list *list)
@ -5399,18 +5405,18 @@ static void free_recorded_instruction(struct list *list)
list_remove(&rec_ins->entry);
if (rec_ins->ins.dst)
{
HeapFree(GetProcessHeap(), 0, (void *)rec_ins->ins.dst->reg.idx[0].rel_addr);
HeapFree(GetProcessHeap(), 0, (void *)rec_ins->ins.dst);
heap_free((void *)rec_ins->ins.dst->reg.idx[0].rel_addr);
heap_free((void *)rec_ins->ins.dst);
}
if (rec_ins->ins.src)
{
for (i = 0; i < rec_ins->ins.src_count; ++i)
{
HeapFree(GetProcessHeap(), 0, (void *)rec_ins->ins.src[i].reg.idx[0].rel_addr);
heap_free((void *)rec_ins->ins.src[i].reg.idx[0].rel_addr);
}
HeapFree(GetProcessHeap(), 0, (void *)rec_ins->ins.src);
heap_free((void *)rec_ins->ins.src);
}
HeapFree(GetProcessHeap(), 0, rec_ins);
heap_free(rec_ins);
}
}
@ -5424,7 +5430,7 @@ static void pop_control_frame(const struct wined3d_shader_instruction *ins)
struct list *e = list_head(&priv->control_frames);
control_frame = LIST_ENTRY(e, struct control_frame, entry);
list_remove(&control_frame->entry);
HeapFree(GetProcessHeap(), 0, control_frame);
heap_free(control_frame);
priv->loop_depth--;
}
else if (ins->handler_idx == WINED3DSIH_ENDIF)
@ -5433,7 +5439,7 @@ static void pop_control_frame(const struct wined3d_shader_instruction *ins)
struct list *e = list_head(&priv->control_frames);
control_frame = LIST_ENTRY(e, struct control_frame, entry);
list_remove(&control_frame->entry);
HeapFree(GetProcessHeap(), 0, control_frame);
heap_free(control_frame);
}
}
@ -5447,7 +5453,7 @@ static void shader_arb_handle_instruction(const struct wined3d_shader_instructio
if(ins->handler_idx == WINED3DSIH_LOOP || ins->handler_idx == WINED3DSIH_REP)
{
control_frame = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*control_frame));
control_frame = heap_alloc_zero(sizeof(*control_frame));
list_add_head(&priv->control_frames, &control_frame->entry);
if(ins->handler_idx == WINED3DSIH_LOOP) control_frame->type = LOOP;
@ -5544,13 +5550,13 @@ static void shader_arb_handle_instruction(const struct wined3d_shader_instructio
shader_addline(buffer, "#end loop/rep\n");
free_recorded_instruction(&copy);
HeapFree(GetProcessHeap(), 0, control_frame);
heap_free(control_frame);
return; /* Instruction is handled */
}
else
{
/* This is a nested loop. Proceed to the normal recording function */
HeapFree(GetProcessHeap(), 0, control_frame);
heap_free(control_frame);
}
}
}
@ -5564,7 +5570,7 @@ static void shader_arb_handle_instruction(const struct wined3d_shader_instructio
/* boolean if */
if(ins->handler_idx == WINED3DSIH_IF)
{
control_frame = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*control_frame));
control_frame = heap_alloc_zero(sizeof(*control_frame));
list_add_head(&priv->control_frames, &control_frame->entry);
control_frame->type = IF;
@ -5584,7 +5590,7 @@ static void shader_arb_handle_instruction(const struct wined3d_shader_instructio
else if(ins->handler_idx == WINED3DSIH_IFC)
{
/* IF(bool) and if_cond(a, b) use the same ELSE and ENDIF tokens */
control_frame = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*control_frame));
control_frame = heap_alloc_zero(sizeof(*control_frame));
control_frame->type = IFC;
control_frame->no.ifc = priv->num_ifcs++;
list_add_head(&priv->control_frames, &control_frame->entry);
@ -5619,7 +5625,7 @@ static void shader_arb_handle_instruction(const struct wined3d_shader_instructio
shader_addline(buffer, "#} endif\n");
if(control_frame->muting) priv->muted = FALSE;
list_remove(&control_frame->entry);
HeapFree(GetProcessHeap(), 0, control_frame);
heap_free(control_frame);
return; /* Instruction is handled */
}
/* In case of an ifc, generate a HW shader instruction */
@ -5719,7 +5725,7 @@ static void *arbfp_alloc(const struct wined3d_shader_backend_ops *shader_backend
* or not. */
if (shader_backend == &arb_program_shader_backend)
priv = shader_priv;
else if (!(priv = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*priv))))
else if (!(priv = heap_alloc_zero(sizeof(*priv))))
return NULL;
wine_rb_init(&priv->fragment_shaders, wined3d_ffp_frag_program_key_compare);
@ -5736,7 +5742,7 @@ static void arbfp_free_ffpshader(struct wine_rb_entry *entry, void *context)
GL_EXTCALL(glDeleteProgramsARB(1, &entry_arb->shader));
checkGLcall("glDeleteProgramsARB(1, &entry_arb->shader)");
HeapFree(GetProcessHeap(), 0, entry_arb);
heap_free(entry_arb);
}
/* Context activation is done by the caller. */
@ -5748,9 +5754,7 @@ static void arbfp_free(struct wined3d_device *device)
priv->use_arbfp_fixed_func = FALSE;
if (device->shader_backend != &arb_program_shader_backend)
{
HeapFree(GetProcessHeap(), 0, device->fragment_priv);
}
heap_free(device->fragment_priv);
}
static void arbfp_get_caps(const struct wined3d_gl_info *gl_info, struct fragment_caps *caps)
@ -6573,8 +6577,9 @@ static void fragment_prog_arbfp(struct wined3d_context *context, const struct wi
desc = (const struct arbfp_ffp_desc *)find_ffp_frag_shader(&priv->fragment_shaders, &settings);
if (!desc)
{
struct arbfp_ffp_desc *new_desc = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_desc));
if (!new_desc)
struct arbfp_ffp_desc *new_desc;
if (!(new_desc = heap_alloc(sizeof(*new_desc))))
{
ERR("Out of memory\n");
return;
@ -6899,7 +6904,7 @@ static void arbfp_free_blit_shader(struct wine_rb_entry *entry, void *ctx)
GL_EXTCALL(glDeleteProgramsARB(1, &entry_arb->shader));
checkGLcall("glDeleteProgramsARB(1, &entry_arb->shader)");
HeapFree(GetProcessHeap(), 0, entry_arb);
heap_free(entry_arb);
}
/* Context activation is done by the caller. */
@ -6920,7 +6925,7 @@ static void arbfp_blitter_destroy(struct wined3d_blitter *blitter, struct wined3
if (arbfp_blitter->palette_texture)
gl_info->gl_ops.gl.p_glDeleteTextures(1, &arbfp_blitter->palette_texture);
HeapFree(GetProcessHeap(), 0, arbfp_blitter);
heap_free(arbfp_blitter);
}
static BOOL gen_planar_yuv_read(struct wined3d_string_buffer *buffer, const struct arbfp_blit_type *type,
@ -7647,8 +7652,7 @@ static HRESULT arbfp_blit_set(struct wined3d_arbfp_blitter *blitter, struct wine
return E_NOTIMPL;
}
desc = HeapAlloc(GetProcessHeap(), 0, sizeof(*desc));
if (!desc)
if (!(desc = heap_alloc(sizeof(*desc))))
goto err_out;
desc->type = type;
@ -7661,7 +7665,7 @@ err_out:
checkGLcall("GL_EXTCALL(glDeleteProgramsARB(1, &shader))");
GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, 0));
checkGLcall("glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, 0)");
HeapFree(GetProcessHeap(), 0, desc);
heap_free(desc);
return E_OUTOFMEMORY;
}
}
@ -7918,7 +7922,7 @@ void wined3d_arbfp_blitter_create(struct wined3d_blitter **next, const struct wi
if (!gl_info->supported[WINED3D_GL_LEGACY_CONTEXT])
return;
if (!(blitter = HeapAlloc(GetProcessHeap(), 0, sizeof(*blitter))))
if (!(blitter = heap_alloc(sizeof(*blitter))))
{
ERR("Failed to allocate blitter.\n");
return;

18
dlls/wined3d/ati_fragment_shader.c
View file

@ -1025,8 +1025,9 @@ static void set_tex_op_atifs(struct wined3d_context *context, const struct wined
desc = (const struct atifs_ffp_desc *)find_ffp_frag_shader(&priv->fragment_shaders, &settings);
if (!desc)
{
struct atifs_ffp_desc *new_desc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*new_desc));
if (!new_desc)
struct atifs_ffp_desc *new_desc;
if (!(new_desc = heap_alloc_zero(sizeof(*new_desc))))
{
ERR("Out of memory\n");
return;
@ -1320,7 +1321,7 @@ static void *atifs_alloc(const struct wined3d_shader_backend_ops *shader_backend
{
struct atifs_private_data *priv;
if (!(priv = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*priv))))
if (!(priv = heap_alloc_zero(sizeof(*priv))))
return NULL;
wine_rb_init(&priv->fragment_shaders, wined3d_ffp_frag_program_key_compare);
@ -1335,7 +1336,7 @@ static void atifs_free_ffpshader(struct wine_rb_entry *entry, void *cb_ctx)
GL_EXTCALL(glDeleteFragmentShaderATI(entry_ati->shader));
checkGLcall("glDeleteFragmentShaderATI(entry->shader)");
HeapFree(GetProcessHeap(), 0, entry_ati);
heap_free(entry_ati);
}
/* Context activation is done by the caller. */
@ -1345,7 +1346,7 @@ static void atifs_free(struct wined3d_device *device)
wine_rb_destroy(&priv->fragment_shaders, atifs_free_ffpshader, &device->adapter->gl_info);
HeapFree(GetProcessHeap(), 0, priv);
heap_free(priv);
device->fragment_priv = NULL;
}
@ -1358,8 +1359,9 @@ static BOOL atifs_color_fixup_supported(struct color_fixup_desc fixup)
static BOOL atifs_alloc_context_data(struct wined3d_context *context)
{
struct atifs_context_private_data *priv = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*priv));
if (!priv)
struct atifs_context_private_data *priv;
if (!(priv = heap_alloc_zero(sizeof(*priv))))
return FALSE;
context->fragment_pipe_data = priv;
return TRUE;
@ -1367,7 +1369,7 @@ static BOOL atifs_alloc_context_data(struct wined3d_context *context)
static void atifs_free_context_data(struct wined3d_context *context)
{
HeapFree(GetProcessHeap(), 0, context->fragment_pipe_data);
heap_free(context->fragment_pipe_data);
}
const struct fragment_pipeline atifs_fragment_pipeline = {

29
dlls/wined3d/buffer.c
View file

@ -302,8 +302,8 @@ static BOOL buffer_process_converted_attribute(struct wined3d_buffer *buffer,
*/
TRACE("Reconverting because converted attributes occur, and the stride changed.\n");
buffer->stride = *stride_this_run;
HeapFree(GetProcessHeap(), HEAP_ZERO_MEMORY, buffer->conversion_map);
buffer->conversion_map = wined3d_calloc(buffer->stride, sizeof(*buffer->conversion_map));
heap_free(buffer->conversion_map);
buffer->conversion_map = heap_calloc(buffer->stride, sizeof(*buffer->conversion_map));
ret = TRUE;
}
}
@ -385,7 +385,7 @@ static BOOL buffer_find_decl(struct wined3d_buffer *This, const struct wined3d_s
TRACE("No fixup required.\n");
if(This->conversion_map)
{
HeapFree(GetProcessHeap(), 0, This->conversion_map);
heap_free(This->conversion_map);
This->conversion_map = NULL;
This->stride = 0;
return TRUE;
@ -474,8 +474,9 @@ static BOOL buffer_find_decl(struct wined3d_buffer *This, const struct wined3d_s
if (!stride_this_run && This->conversion_map)
{
/* Sanity test */
if (!ret) ERR("no converted attributes found, old conversion map exists, and no declaration change?\n");
HeapFree(GetProcessHeap(), 0, This->conversion_map);
if (!ret)
ERR("no converted attributes found, old conversion map exists, and no declaration change?\n");
heap_free(This->conversion_map);
This->conversion_map = NULL;
This->stride = 0;
}
@ -563,7 +564,7 @@ static void buffer_conversion_upload(struct wined3d_buffer *buffer, struct wined
/* Now for each vertex in the buffer that needs conversion. */
vertex_count = buffer->resource.size / buffer->stride;
if (!(data = HeapAlloc(GetProcessHeap(), 0, buffer->resource.size)))
if (!(data = heap_alloc(buffer->resource.size)))
{
ERR("Out of memory.\n");
return;
@ -601,7 +602,7 @@ static void buffer_conversion_upload(struct wined3d_buffer *buffer, struct wined
wined3d_buffer_upload_ranges(buffer, context, data, 0, buffer->modified_areas, buffer->maps);
HeapFree(GetProcessHeap(), 0, data);
heap_free(data);
}
static BOOL wined3d_buffer_prepare_location(struct wined3d_buffer *buffer,
@ -753,7 +754,7 @@ static void buffer_unload(struct wined3d_resource *resource)
context_release(context);
HeapFree(GetProcessHeap(), 0, buffer->conversion_map);
heap_free(buffer->conversion_map);
buffer->conversion_map = NULL;
buffer->stride = 0;
buffer->conversion_stride = 0;
@ -780,11 +781,11 @@ static void wined3d_buffer_destroy_object(void *object)
buffer_destroy_buffer_object(buffer, context);
context_release(context);
HeapFree(GetProcessHeap(), 0, buffer->conversion_map);
heap_free(buffer->conversion_map);
}
HeapFree(GetProcessHeap(), 0, buffer->maps);
HeapFree(GetProcessHeap(), 0, buffer);
heap_free(buffer->maps);
heap_free(buffer);
}
ULONG CDECL wined3d_buffer_decref(struct wined3d_buffer *buffer)
@ -1396,7 +1397,7 @@ static HRESULT buffer_init(struct wined3d_buffer *buffer, struct wined3d_device
buffer->flags |= WINED3D_BUFFER_USE_BO;
}
if (!(buffer->maps = HeapAlloc(GetProcessHeap(), 0, sizeof(*buffer->maps))))
if (!(buffer->maps = heap_alloc(sizeof(*buffer->maps))))
{
ERR("Out of memory.\n");
buffer_unload(&buffer->resource);
@ -1423,14 +1424,14 @@ HRESULT CDECL wined3d_buffer_create(struct wined3d_device *device, const struct
TRACE("device %p, desc %p, data %p, parent %p, parent_ops %p, buffer %p.\n",
device, desc, data, parent, parent_ops, buffer);
if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
if (FAILED(hr = buffer_init(object, device, desc->byte_width, desc->usage, WINED3DFMT_UNKNOWN,
desc->access, desc->bind_flags, data, parent, parent_ops)))
{
WARN("Failed to initialize buffer, hr %#x.\n", hr);
HeapFree(GetProcessHeap(), 0, object);
heap_free(object);
return hr;
}
object->desc = *desc;

68
dlls/wined3d/context.c
View file

@ -523,8 +523,7 @@ static struct fbo_entry *context_create_fbo_entry(const struct wined3d_context *
unsigned int object_count = gl_info->limits.buffers + 1;
struct fbo_entry *entry;
entry = HeapAlloc(GetProcessHeap(), 0,
FIELD_OFFSET(struct fbo_entry, key.objects[object_count]));
entry = heap_alloc(FIELD_OFFSET(struct fbo_entry, key.objects[object_count]));
memset(&entry->key, 0, FIELD_OFFSET(struct wined3d_fbo_entry_key, objects[object_count]));
context_generate_fbo_key(context, &entry->key, render_targets, depth_stencil, color_location, ds_location);
entry->flags = 0;
@ -574,7 +573,7 @@ static void context_destroy_fbo_entry(struct wined3d_context *context, struct fb
}
--context->fbo_entry_count;
list_remove(&entry->entry);
HeapFree(GetProcessHeap(), 0, entry);
heap_free(entry);
}
/* Context activation is done by the caller. */
@ -1435,11 +1434,11 @@ static void context_destroy_gl_resources(struct wined3d_context *context)
checkGLcall("context cleanup");
}
HeapFree(GetProcessHeap(), 0, context->free_so_statistics_queries);
HeapFree(GetProcessHeap(), 0, context->free_pipeline_statistics_queries);
HeapFree(GetProcessHeap(), 0, context->free_timestamp_queries);
HeapFree(GetProcessHeap(), 0, context->free_occlusion_queries);
HeapFree(GetProcessHeap(), 0, context->free_fences);
heap_free(context->free_so_statistics_queries);
heap_free(context->free_pipeline_statistics_queries);
heap_free(context->free_timestamp_queries);
heap_free(context->free_occlusion_queries);
heap_free(context->free_fences);
context_restore_pixel_format(context);
if (restore_ctx)
@ -1491,8 +1490,8 @@ BOOL context_set_current(struct wined3d_context *ctx)
{
TRACE("Switching away from destroyed context %p.\n", old);
context_destroy_gl_resources(old);
HeapFree(GetProcessHeap(), 0, (void *)old->gl_info);
HeapFree(GetProcessHeap(), 0, old);
heap_free((void *)old->gl_info);
heap_free(old);
}
else
{
@ -1863,35 +1862,33 @@ struct wined3d_context *context_create(struct wined3d_swapchain *swapchain,
wined3d_from_cs(device->cs);
ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ret));
if (!ret)
if (!(ret = heap_alloc_zero(sizeof(*ret))))
return NULL;
if (!(ret->blit_targets = wined3d_calloc(gl_info->limits.buffers, sizeof(*ret->blit_targets))))
if (!(ret->blit_targets = heap_calloc(gl_info->limits.buffers, sizeof(*ret->blit_targets))))
goto out;
if (!(ret->draw_buffers = wined3d_calloc(gl_info->limits.buffers, sizeof(*ret->draw_buffers))))
if (!(ret->draw_buffers = heap_calloc(gl_info->limits.buffers, sizeof(*ret->draw_buffers))))
goto out;
ret->fbo_key = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
FIELD_OFFSET(struct wined3d_fbo_entry_key, objects[gl_info->limits.buffers + 1]));
if (!ret->fbo_key)
if (!(ret->fbo_key = heap_alloc_zero(FIELD_OFFSET(struct wined3d_fbo_entry_key,
objects[gl_info->limits.buffers + 1]))))
goto out;
ret->free_timestamp_query_size = 4;
if (!(ret->free_timestamp_queries = wined3d_calloc(ret->free_timestamp_query_size,
if (!(ret->free_timestamp_queries = heap_calloc(ret->free_timestamp_query_size,
sizeof(*ret->free_timestamp_queries))))
goto out;
list_init(&ret->timestamp_queries);
ret->free_occlusion_query_size = 4;
if (!(ret->free_occlusion_queries = wined3d_calloc(ret->free_occlusion_query_size,
if (!(ret->free_occlusion_queries = heap_calloc(ret->free_occlusion_query_size,
sizeof(*ret->free_occlusion_queries))))
goto out;
list_init(&ret->occlusion_queries);
ret->free_fence_size = 4;
if (!(ret->free_fences = wined3d_calloc(ret->free_fence_size, sizeof(*ret->free_fences))))
if (!(ret->free_fences = heap_calloc(ret->free_fence_size, sizeof(*ret->free_fences))))
goto out;
list_init(&ret->fences);
@ -1947,7 +1944,7 @@ struct wined3d_context *context_create(struct wined3d_swapchain *swapchain,
}
}
if (!(ret->texture_type = wined3d_calloc(gl_info->limits.combined_samplers,
if (!(ret->texture_type = heap_calloc(gl_info->limits.combined_samplers,
sizeof(*ret->texture_type))))
goto out;
@ -2248,14 +2245,14 @@ out:
wined3d_release_dc(swapchain->win_handle, ret->hdc);
device->shader_backend->shader_free_context_data(ret);
device->adapter->fragment_pipe->free_context_data(ret);
HeapFree(GetProcessHeap(), 0, ret->texture_type);
HeapFree(GetProcessHeap(), 0, ret->free_fences);
HeapFree(GetProcessHeap(), 0, ret->free_occlusion_queries);
HeapFree(GetProcessHeap(), 0, ret->free_timestamp_queries);
HeapFree(GetProcessHeap(), 0, ret->fbo_key);
HeapFree(GetProcessHeap(), 0, ret->draw_buffers);
HeapFree(GetProcessHeap(), 0, ret->blit_targets);
HeapFree(GetProcessHeap(), 0, ret);
heap_free(ret->texture_type);
heap_free(ret->free_fences);
heap_free(ret->free_occlusion_queries);
heap_free(ret->free_timestamp_queries);
heap_free(ret->fbo_key);
heap_free(ret->draw_buffers);
heap_free(ret->blit_targets);
heap_free(ret);
return NULL;
}
@ -2288,7 +2285,7 @@ void context_destroy(struct wined3d_device *device, struct wined3d_context *cont
{
/* Make a copy of gl_info for context_destroy_gl_resources use, the one
in wined3d_adapter may go away in the meantime */
struct wined3d_gl_info *gl_info = HeapAlloc(GetProcessHeap(), 0, sizeof(*gl_info));
struct wined3d_gl_info *gl_info = heap_alloc(sizeof(*gl_info));
*gl_info = *context->gl_info;
context->gl_info = gl_info;
context->destroyed = 1;
@ -2297,12 +2294,13 @@ void context_destroy(struct wined3d_device *device, struct wined3d_context *cont
device->shader_backend->shader_free_context_data(context);
device->adapter->fragment_pipe->free_context_data(context);
HeapFree(GetProcessHeap(), 0, context->texture_type);
HeapFree(GetProcessHeap(), 0, context->fbo_key);
HeapFree(GetProcessHeap(), 0, context->draw_buffers);
HeapFree(GetProcessHeap(), 0, context->blit_targets);
heap_free(context->texture_type);
heap_free(context->fbo_key);
heap_free(context->draw_buffers);
heap_free(context->blit_targets);
device_context_remove(device, context);
if (destroy) HeapFree(GetProcessHeap(), 0, context);
if (destroy)
heap_free(context);
}
const DWORD *context_get_tex_unit_mapping(const struct wined3d_context *context,

32
dlls/wined3d/cs.c
View file

@ -1697,7 +1697,7 @@ static void wined3d_cs_exec_set_light(struct wined3d_cs *cs, const void *data)
if (!(light_info = wined3d_state_get_light(&cs->state, light_idx)))
{
TRACE("Adding new light.\n");
if (!(light_info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*light_info))))
if (!(light_info = heap_alloc_zero(sizeof(*light_info))))
{
ERR("Failed to allocate light info.\n");
return;
@ -2459,9 +2459,9 @@ static void *wined3d_cs_st_require_space(struct wined3d_cs *cs, size_t size, enu
new_size = max(size, cs->data_size * 2);
if (!cs->end)
new_data = HeapReAlloc(GetProcessHeap(), 0, cs->data, new_size);
new_data = heap_realloc(cs->data, new_size);
else
new_data = HeapAlloc(GetProcessHeap(), 0, new_size);
new_data = heap_alloc(new_size);
if (!new_data)
return NULL;
@ -2494,7 +2494,7 @@ static void wined3d_cs_st_submit(struct wined3d_cs *cs, enum wined3d_cs_queue_id
if (cs->data == data)
cs->start = cs->end = start;
else if (!start)
HeapFree(GetProcessHeap(), 0, data);
heap_free(data);
}
static void wined3d_cs_st_finish(struct wined3d_cs *cs, enum wined3d_cs_queue_id queue_id)
@ -2728,15 +2728,15 @@ struct wined3d_cs *wined3d_cs_create(struct wined3d_device *device)
const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
struct wined3d_cs *cs;
if (!(cs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*cs))))
if (!(cs = heap_alloc_zero(sizeof(*cs))))
return NULL;
cs->ops = &wined3d_cs_st_ops;
cs->device = device;
if (!(cs->fb.render_targets = wined3d_calloc(gl_info->limits.buffers, sizeof(*cs->fb.render_targets))))
if (!(cs->fb.render_targets = heap_calloc(gl_info->limits.buffers, sizeof(*cs->fb.render_targets))))
{
HeapFree(GetProcessHeap(), 0, cs);
heap_free(cs);
return NULL;
}
@ -2744,7 +2744,7 @@ struct wined3d_cs *wined3d_cs_create(struct wined3d_device *device)
WINED3D_STATE_NO_REF | WINED3D_STATE_INIT_DEFAULT);
cs->data_size = WINED3D_INITIAL_CS_SIZE;
if (!(cs->data = HeapAlloc(GetProcessHeap(), 0, cs->data_size)))
if (!(cs->data = heap_alloc(cs->data_size)))
goto fail;
if (wined3d_settings.cs_multithreaded
@ -2755,7 +2755,7 @@ struct wined3d_cs *wined3d_cs_create(struct wined3d_device *device)
if (!(cs->event = CreateEventW(NULL, FALSE, FALSE, NULL)))
{
ERR("Failed to create command stream event.\n");
HeapFree(GetProcessHeap(), 0, cs->data);
heap_free(cs->data);
goto fail;
}
@ -2764,7 +2764,7 @@ struct wined3d_cs *wined3d_cs_create(struct wined3d_device *device)
{
ERR("Failed to get wined3d module handle.\n");
CloseHandle(cs->event);
HeapFree(GetProcessHeap(), 0, cs->data);
heap_free(cs->data);
goto fail;
}
@ -2773,7 +2773,7 @@ struct wined3d_cs *wined3d_cs_create(struct wined3d_device *device)
ERR("Failed to create wined3d command stream thread.\n");
FreeLibrary(cs->wined3d_module);
CloseHandle(cs->event);
HeapFree(GetProcessHeap(), 0, cs->data);
heap_free(cs->data);
goto fail;
}
}
@ -2782,8 +2782,8 @@ struct wined3d_cs *wined3d_cs_create(struct wined3d_device *device)
fail:
state_cleanup(&cs->state);
HeapFree(GetProcessHeap(), 0, cs->fb.render_targets);
HeapFree(GetProcessHeap(), 0, cs);
heap_free(cs->fb.render_targets);
heap_free(cs);
return NULL;
}
@ -2798,7 +2798,7 @@ void wined3d_cs_destroy(struct wined3d_cs *cs)
}
state_cleanup(&cs->state);
HeapFree(GetProcessHeap(), 0, cs->fb.render_targets);
HeapFree(GetProcessHeap(), 0, cs->data);
HeapFree(GetProcessHeap(), 0, cs);
heap_free(cs->fb.render_targets);
heap_free(cs->data);
heap_free(cs);
}

42
dlls/wined3d/device.c
View file

@ -149,11 +149,7 @@ BOOL device_context_add(struct wined3d_device *device, struct wined3d_context *c
TRACE("Adding context %p.\n", context);
if (!device->contexts) new_array = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_array));
else new_array = HeapReAlloc(GetProcessHeap(), 0, device->contexts,
sizeof(*new_array) * (device->context_count + 1));
if (!new_array)
if (!(new_array = heap_realloc(device->contexts, sizeof(*new_array) * (device->context_count + 1))))
{
ERR("Failed to grow the context array.\n");
return FALSE;
@ -189,14 +185,13 @@ void device_context_remove(struct wined3d_device *device, struct wined3d_context
if (!--device->context_count)
{
HeapFree(GetProcessHeap(), 0, device->contexts);
heap_free(device->contexts);
device->contexts = NULL;
return;
}
memmove(&device->contexts[i], &device->contexts[i + 1], (device->context_count - i) * sizeof(*device->contexts));
new_array = HeapReAlloc(GetProcessHeap(), 0, device->contexts, device->context_count * sizeof(*device->contexts));
if (!new_array)
if (!(new_array = heap_realloc(device->contexts, device->context_count * sizeof(*device->contexts))))
{
ERR("Failed to shrink context array. Oh well.\n");
return;
@ -491,7 +486,7 @@ ULONG CDECL wined3d_device_decref(struct wined3d_device *device)
for (i = 0; i < ARRAY_SIZE(device->multistate_funcs); ++i)
{
HeapFree(GetProcessHeap(), 0, device->multistate_funcs[i]);
heap_free(device->multistate_funcs[i]);
device->multistate_funcs[i] = NULL;
}
@ -518,7 +513,7 @@ ULONG CDECL wined3d_device_decref(struct wined3d_device *device)
wined3d_decref(device->wined3d);
device->wined3d = NULL;
HeapFree(GetProcessHeap(), 0, device);
heap_free(device);
TRACE("Freed device %p.\n", device);
}
@ -1066,7 +1061,7 @@ HRESULT CDECL wined3d_device_init_3d(struct wined3d_device *device,
if (device->wined3d->flags & WINED3D_NO3D)
return WINED3DERR_INVALIDCALL;
if (!(device->fb.render_targets = wined3d_calloc(gl_info->limits.buffers, sizeof(*device->fb.render_targets))))
if (!(device->fb.render_targets = heap_calloc(gl_info->limits.buffers, sizeof(*device->fb.render_targets))))
return E_OUTOFMEMORY;
/* Setup the implicit swapchain. This also initializes a context. */
@ -1099,7 +1094,7 @@ HRESULT CDECL wined3d_device_init_3d(struct wined3d_device *device,
}
device->swapchain_count = 1;
if (!(device->swapchains = wined3d_calloc(device->swapchain_count, sizeof(*device->swapchains))))
if (!(device->swapchains = heap_calloc(device->swapchain_count, sizeof(*device->swapchains))))
{
ERR("Out of memory!\n");
goto err_out;
@ -1129,13 +1124,13 @@ HRESULT CDECL wined3d_device_init_3d(struct wined3d_device *device,
return WINED3D_OK;
err_out:
HeapFree(GetProcessHeap(), 0, device->swapchains);
heap_free(device->swapchains);
device->swapchain_count = 0;
if (device->back_buffer_view)
wined3d_rendertarget_view_decref(device->back_buffer_view);
if (swapchain)
wined3d_swapchain_decref(swapchain);
HeapFree(GetProcessHeap(), 0, device->fb.render_targets);
heap_free(device->fb.render_targets);
return hr;
}
@ -1159,7 +1154,7 @@ HRESULT CDECL wined3d_device_init_gdi(struct wined3d_device *device,
}
device->swapchain_count = 1;
if (!(device->swapchains = wined3d_calloc(device->swapchain_count, sizeof(*device->swapchains))))
if (!(device->swapchains = heap_calloc(device->swapchain_count, sizeof(*device->swapchains))))
{
ERR("Out of memory!\n");
goto err_out;
@ -1169,7 +1164,7 @@ HRESULT CDECL wined3d_device_init_gdi(struct wined3d_device *device,
if (!(device->blitter = wined3d_cpu_blitter_create()))
{
ERR("Failed to create CPU blitter.\n");
HeapFree(GetProcessHeap(), 0, device->swapchains);
heap_free(device->swapchains);
device->swapchain_count = 0;
goto err_out;
}
@ -1246,11 +1241,11 @@ HRESULT CDECL wined3d_device_uninit_3d(struct wined3d_device *device)
FIXME("Something's still holding the implicit swapchain.\n");
}
HeapFree(GetProcessHeap(), 0, device->swapchains);
heap_free(device->swapchains);
device->swapchains = NULL;
device->swapchain_count = 0;
HeapFree(GetProcessHeap(), 0, device->fb.render_targets);
heap_free(device->fb.render_targets);
device->fb.render_targets = NULL;
device->d3d_initialized = FALSE;
@ -1271,7 +1266,7 @@ HRESULT CDECL wined3d_device_uninit_gdi(struct wined3d_device *device)
FIXME("Something's still holding the implicit swapchain.\n");
}
HeapFree(GetProcessHeap(), 0, device->swapchains);
heap_free(device->swapchains);
device->swapchains = NULL;
device->swapchain_count = 0;
return WINED3D_OK;
@ -1589,8 +1584,7 @@ HRESULT CDECL wined3d_device_set_light(struct wined3d_device *device,
if (!(object = wined3d_state_get_light(device->update_state, light_idx)))
{
TRACE("Adding new light\n");
object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
if (!object)
if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
list_add_head(&device->update_state->light_map[hash_idx], &object->entry);
@ -4608,7 +4602,7 @@ HRESULT CDECL wined3d_device_set_cursor_properties(struct wined3d_device *device
/* 32-bit user32 cursors ignore the alpha channel if it's all
* zeroes, and use the mask instead. Fill the mask with all ones
* to ensure we still get a fully transparent cursor. */
if (!(mask_bits = HeapAlloc(GetProcessHeap(), 0, mask_size)))
if (!(mask_bits = heap_alloc(mask_size)))
return E_OUTOFMEMORY;
memset(mask_bits, 0xff, mask_size);
@ -4633,7 +4627,7 @@ HRESULT CDECL wined3d_device_set_cursor_properties(struct wined3d_device *device
if (device->bCursorVisible)
SetCursor(cursor);
HeapFree(GetProcessHeap(), 0, mask_bits);
heap_free(mask_bits);
}
TRACE("New cursor dimensions are %ux%u.\n", cursor_width, cursor_height);
@ -5208,7 +5202,7 @@ HRESULT device_init(struct wined3d_device *device, struct wined3d *wined3d,
err:
for (i = 0; i < ARRAY_SIZE(device->multistate_funcs); ++i)
{
HeapFree(GetProcessHeap(), 0, device->multistate_funcs[i]);
heap_free(device->multistate_funcs[i]);
}
wine_rb_destroy(&device->samplers, NULL, NULL);
wined3d_decref(device->wined3d);

37
dlls/wined3d/directx.c
View file

@ -448,8 +448,8 @@ UINT64 adapter_adjust_memory(struct wined3d_adapter *adapter, INT64 amount)
static void wined3d_adapter_cleanup(struct wined3d_adapter *adapter)
{
HeapFree(GetProcessHeap(), 0, adapter->gl_info.formats);
HeapFree(GetProcessHeap(), 0, adapter->cfgs);
heap_free(adapter->gl_info.formats);
heap_free(adapter->cfgs);
}
ULONG CDECL wined3d_incref(struct wined3d *wined3d)
@ -475,7 +475,7 @@ ULONG CDECL wined3d_decref(struct wined3d *wined3d)
{
wined3d_adapter_cleanup(&wined3d->adapters[i]);
}
HeapFree(GetProcessHeap(), 0, wined3d);
heap_free(wined3d);
}
return refcount;
@ -4638,11 +4638,11 @@ HRESULT CDECL wined3d_find_closest_matching_adapter_mode(const struct wined3d *w
return E_FAIL;
}
if (!(modes = wined3d_calloc(mode_count, sizeof(*modes))))
if (!(modes = heap_calloc(mode_count, sizeof(*modes))))
return E_OUTOFMEMORY;
if (!(matching_modes = wined3d_calloc(mode_count, sizeof(*matching_modes))))
if (!(matching_modes = heap_calloc(mode_count, sizeof(*matching_modes))))
{
HeapFree(GetProcessHeap(), 0, modes);
heap_free(modes);
return E_OUTOFMEMORY;
}
@ -4651,8 +4651,8 @@ HRESULT CDECL wined3d_find_closest_matching_adapter_mode(const struct wined3d *w
if (FAILED(hr = wined3d_enum_adapter_modes(wined3d, adapter_idx,
mode->format_id, WINED3D_SCANLINE_ORDERING_UNKNOWN, i, &modes[i])))
{
HeapFree(GetProcessHeap(), 0, matching_modes);
HeapFree(GetProcessHeap(), 0, modes);
heap_free(matching_modes);
heap_free(modes);
return hr;
}
matching_modes[i] = &modes[i];
@ -4688,8 +4688,8 @@ HRESULT CDECL wined3d_find_closest_matching_adapter_mode(const struct wined3d *w
if (FAILED(hr = wined3d_get_adapter_display_mode(wined3d, adapter_idx,
&current_mode, NULL)))
{
HeapFree(GetProcessHeap(), 0, matching_modes);
HeapFree(GetProcessHeap(), 0, modes);
heap_free(matching_modes);
heap_free(modes);
return hr;
}
mode->width = current_mode.width;
@ -4711,8 +4711,8 @@ HRESULT CDECL wined3d_find_closest_matching_adapter_mode(const struct wined3d *w
*mode = *matching_modes[j];
HeapFree(GetProcessHeap(), 0, matching_modes);
HeapFree(GetProcessHeap(), 0, modes);
heap_free(matching_modes);
heap_free(modes);
TRACE("Returning %ux%u@%u %s %#x.\n", mode->width, mode->height,
mode->refresh_rate, debug_d3dformat(mode->format_id),
@ -6191,8 +6191,7 @@ HRESULT CDECL wined3d_device_create(struct wined3d *wined3d, UINT adapter_idx, e
if (wined3d->adapter_count && adapter_idx >= wined3d->adapter_count)
return WINED3DERR_INVALIDCALL;
object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
if (!object)
if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
hr = device_init(object, wined3d, adapter_idx, device_type,
@ -6200,7 +6199,7 @@ HRESULT CDECL wined3d_device_create(struct wined3d *wined3d, UINT adapter_idx, e
if (FAILED(hr))
{
WARN("Failed to initialize device, hr %#x.\n", hr);
HeapFree(GetProcessHeap(), 0, object);
heap_free(object);
return hr;
}
@ -6440,7 +6439,7 @@ static void wined3d_adapter_init_fb_cfgs(struct wined3d_adapter *adapter, HDC dc
attribute = WGL_NUMBER_PIXEL_FORMATS_ARB;
GL_EXTCALL(wglGetPixelFormatAttribivARB(dc, 0, 0, 1, &attribute, &cfg_count));
adapter->cfgs = wined3d_calloc(cfg_count, sizeof(*adapter->cfgs));
adapter->cfgs = heap_calloc(cfg_count, sizeof(*adapter->cfgs));
attribs[attrib_count++] = WGL_RED_BITS_ARB;
attribs[attrib_count++] = WGL_GREEN_BITS_ARB;
attribs[attrib_count++] = WGL_BLUE_BITS_ARB;
@ -6505,7 +6504,7 @@ static void wined3d_adapter_init_fb_cfgs(struct wined3d_adapter *adapter, HDC dc
int cfg_count;
cfg_count = DescribePixelFormat(dc, 0, 0, 0);
adapter->cfgs = wined3d_calloc(cfg_count, sizeof(*adapter->cfgs));
adapter->cfgs = heap_calloc(cfg_count, sizeof(*adapter->cfgs));
for (i = 0, adapter->cfg_count = 0; i < cfg_count; ++i)
{
@ -6666,7 +6665,7 @@ static BOOL wined3d_adapter_init(struct wined3d_adapter *adapter, UINT ordinal,
{
WARN("No suitable pixel formats found.\n");
wined3d_caps_gl_ctx_destroy(&caps_gl_ctx);
HeapFree(GetProcessHeap(), 0, adapter->cfgs);
heap_free(adapter->cfgs);
return FALSE;
}
@ -6674,7 +6673,7 @@ static BOOL wined3d_adapter_init(struct wined3d_adapter *adapter, UINT ordinal,
{
ERR("Failed to initialize GL format info.\n");
wined3d_caps_gl_ctx_destroy(&caps_gl_ctx);
HeapFree(GetProcessHeap(), 0, adapter->cfgs);
heap_free(adapter->cfgs);
return FALSE;
}

144
dlls/wined3d/glsl_shader.c
View file

@ -474,7 +474,7 @@ void print_glsl_info_log(const struct wined3d_gl_info *gl_info, GLuint id, BOOL
{
const char *ptr, *line;
log = HeapAlloc(GetProcessHeap(), 0, length);
log = heap_alloc(length);
/* The info log is supposed to be zero-terminated, but at least some
* versions of fglrx don't terminate the string properly. The reported
* length does include the terminator, so explicitly set it to zero
@ -496,7 +496,7 @@ void print_glsl_info_log(const struct wined3d_gl_info *gl_info, GLuint id, BOOL
FIXME("Info log received from GLSL shader #%u:\n", id);
while ((line = get_info_log_line(&ptr))) FIXME(" %.*s", (int)(ptr - line), line);
}
HeapFree(GetProcessHeap(), 0, log);
heap_free(log);
}
}
@ -528,7 +528,7 @@ static void shader_glsl_dump_program_source(const struct wined3d_gl_info *gl_inf
char *source = NULL;
GL_EXTCALL(glGetProgramiv(program, GL_ATTACHED_SHADERS, &shader_count));
if (!(shaders = wined3d_calloc(shader_count, sizeof(*shaders))))
if (!(shaders = heap_calloc(shader_count, sizeof(*shaders))))
{
ERR("Failed to allocate shader array memory.\n");
return;
@ -544,13 +544,12 @@ static void shader_glsl_dump_program_source(const struct wined3d_gl_info *gl_inf
if (source_size < tmp)
{
HeapFree(GetProcessHeap(), 0, source);
heap_free(source);
source = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, tmp);
if (!source)
if (!(source = heap_alloc_zero(tmp)))
{
ERR("Failed to allocate %d bytes for shader source.\n", tmp);
HeapFree(GetProcessHeap(), 0, shaders);
heap_free(shaders);
return;
}
source_size = tmp;
@ -569,8 +568,8 @@ static void shader_glsl_dump_program_source(const struct wined3d_gl_info *gl_inf
FIXME("\n");
}
HeapFree(GetProcessHeap(), 0, source);
HeapFree(GetProcessHeap(), 0, shaders);
heap_free(source);
heap_free(shaders);
}
/* Context activation is done by the caller. */
@ -944,16 +943,16 @@ static void shader_glsl_init_transform_feedback(const struct wined3d_context *co
shader_glsl_generate_transform_feedback_varyings(so_desc, buffer, NULL, &count, NULL, &length, mode);
if (!(varyings = wined3d_calloc(count, sizeof(*varyings))))
if (!(varyings = heap_calloc(count, sizeof(*varyings))))
{
ERR("Out of memory.\n");
string_buffer_release(&priv->string_buffers, buffer);
return;
}
if (!(strings = wined3d_calloc(length, sizeof(*strings))))
if (!(strings = heap_calloc(length, sizeof(*strings))))
{
ERR("Out of memory.\n");
HeapFree(GetProcessHeap(), 0, varyings);
heap_free(varyings);
string_buffer_release(&priv->string_buffers, buffer);
return;
}
@ -962,8 +961,8 @@ static void shader_glsl_init_transform_feedback(const struct wined3d_context *co
GL_EXTCALL(glTransformFeedbackVaryings(program_id, count, varyings, mode));
checkGLcall("glTransformFeedbackVaryings");
HeapFree(GetProcessHeap(), 0, varyings);
HeapFree(GetProcessHeap(), 0, strings);
heap_free(varyings);
heap_free(strings);
string_buffer_release(&priv->string_buffers, buffer);
}
@ -6849,7 +6848,7 @@ static void delete_glsl_program_entry(struct shader_glsl_priv *priv, const struc
list_remove(&entry->ps.shader_entry);
if (entry->cs.id)
list_remove(&entry->cs.shader_entry);
HeapFree(GetProcessHeap(), 0, entry);
heap_free(entry);
}
static void shader_glsl_setup_vs3_output(struct shader_glsl_priv *priv,
@ -6868,7 +6867,7 @@ static void shader_glsl_setup_vs3_output(struct shader_glsl_priv *priv,
unsigned int i, j;
char reg_mask[6];
set = wined3d_calloc(max_varyings, sizeof(*set));
set = heap_calloc(max_varyings, sizeof(*set));
for (i = 0; i < input_signature->element_count; ++i)
{
@ -6952,7 +6951,7 @@ static void shader_glsl_setup_vs3_output(struct shader_glsl_priv *priv,
shader_addline(buffer, "%s.%s = vec%u(0.0);\n", destination->buffer, reg_mask, size);
}
HeapFree(GetProcessHeap(), 0, set);
heap_free(set);
string_buffer_release(&priv->string_buffers, destination);
}
@ -8293,8 +8292,7 @@ static GLuint find_glsl_pshader(const struct wined3d_context *context,
if (!shader->backend_data)
{
shader->backend_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data));
if (!shader->backend_data)
if (!(shader->backend_data = heap_alloc_zero(sizeof(*shader_data))))
{
ERR("Failed to allocate backend data.\n");
return 0;
@ -8318,16 +8316,16 @@ static GLuint find_glsl_pshader(const struct wined3d_context *context,
}
TRACE("No matching GL shader found for shader %p, compiling a new shader.\n", shader);
if(shader_data->shader_array_size == shader_data->num_gl_shaders) {
if (shader_data->shader_array_size == shader_data->num_gl_shaders)
{
if (shader_data->num_gl_shaders)
{
new_size = shader_data->shader_array_size + max(1, shader_data->shader_array_size / 2);
new_array = HeapReAlloc(GetProcessHeap(), 0, shader_data->gl_shaders.ps,
new_size * sizeof(*gl_shaders));
new_array = heap_realloc(shader_data->gl_shaders.ps, new_size * sizeof(*gl_shaders));
}
else
{
new_array = HeapAlloc(GetProcessHeap(), 0, sizeof(*gl_shaders));
new_array = heap_alloc(sizeof(*gl_shaders));
new_size = 1;
}
@ -8385,8 +8383,7 @@ static GLuint find_glsl_vshader(const struct wined3d_context *context, struct sh
if (!shader->backend_data)
{
shader->backend_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data));
if (!shader->backend_data)
if (!(shader->backend_data = heap_alloc_zero(sizeof(*shader_data))))
{
ERR("Failed to allocate backend data.\n");
return 0;
@ -8407,16 +8404,16 @@ static GLuint find_glsl_vshader(const struct wined3d_context *context, struct sh
TRACE("No matching GL shader found for shader %p, compiling a new shader.\n", shader);
if(shader_data->shader_array_size == shader_data->num_gl_shaders) {
if (shader_data->shader_array_size == shader_data->num_gl_shaders)
{
if (shader_data->num_gl_shaders)
{
new_size = shader_data->shader_array_size + max(1, shader_data->shader_array_size / 2);
new_array = HeapReAlloc(GetProcessHeap(), 0, shader_data->gl_shaders.vs,
new_size * sizeof(*gl_shaders));
new_array = heap_realloc(shader_data->gl_shaders.vs, new_size * sizeof(*gl_shaders));
}
else
{
new_array = HeapAlloc(GetProcessHeap(), 0, sizeof(*gl_shaders));
new_array = heap_alloc(sizeof(*gl_shaders));
new_size = 1;
}
@ -8448,7 +8445,7 @@ static GLuint find_glsl_hull_shader(const struct wined3d_context *context,
if (!shader->backend_data)
{
if (!(shader->backend_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data))))
if (!(shader->backend_data = heap_alloc_zero(sizeof(*shader_data))))
{
ERR("Failed to allocate backend data.\n");
return 0;
@ -8466,9 +8463,8 @@ static GLuint find_glsl_hull_shader(const struct wined3d_context *context,
TRACE("No matching GL shader found for shader %p, compiling a new shader.\n", shader);
assert(!shader_data->gl_shaders.hs);
new_array = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_array));
new_size = 1;
if (!new_array)
if (!(new_array = heap_alloc(sizeof(*new_array))))
{
ERR("Failed to allocate GL shaders array.\n");
return 0;
@ -8494,7 +8490,7 @@ static GLuint find_glsl_domain_shader(const struct wined3d_context *context,
if (!shader->backend_data)
{
if (!(shader->backend_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data))))
if (!(shader->backend_data = heap_alloc_zero(sizeof(*shader_data))))
{
ERR("Failed to allocate backend data.\n");
return 0;
@ -8514,12 +8510,11 @@ static GLuint find_glsl_domain_shader(const struct wined3d_context *context,
if (shader_data->num_gl_shaders)
{
new_size = shader_data->shader_array_size + 1;
new_array = HeapReAlloc(GetProcessHeap(), 0, shader_data->gl_shaders.ds,
new_size * sizeof(*new_array));
new_array = heap_realloc(shader_data->gl_shaders.ds, new_size * sizeof(*new_array));
}
else
{
new_array = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_array));
new_array = heap_alloc(sizeof(*new_array));
new_size = 1;
}
@ -8550,7 +8545,7 @@ static GLuint find_glsl_geometry_shader(const struct wined3d_context *context,
if (!shader->backend_data)
{
if (!(shader->backend_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data))))
if (!(shader->backend_data = heap_alloc_zero(sizeof(*shader_data))))
{
ERR("Failed to allocate backend data.\n");
return 0;
@ -8570,12 +8565,11 @@ static GLuint find_glsl_geometry_shader(const struct wined3d_context *context,
if (shader_data->num_gl_shaders)
{
new_size = shader_data->shader_array_size + 1;
new_array = HeapReAlloc(GetProcessHeap(), 0, shader_data->gl_shaders.gs,
new_size * sizeof(*new_array));
new_array = heap_realloc(shader_data->gl_shaders.gs, new_size * sizeof(*new_array));
}
else
{
new_array = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_array));
new_array = heap_alloc(sizeof(*new_array));
new_size = 1;
}
@ -9721,7 +9715,7 @@ static struct glsl_ffp_vertex_shader *shader_glsl_find_ffp_vertex_shader(struct
if ((entry = wine_rb_get(&priv->ffp_vertex_shaders, settings)))
return WINE_RB_ENTRY_VALUE(entry, struct glsl_ffp_vertex_shader, desc.entry);
if (!(shader = HeapAlloc(GetProcessHeap(), 0, sizeof(*shader))))
if (!(shader = heap_alloc(sizeof(*shader))))
return NULL;
shader->desc.settings = *settings;
@ -9742,7 +9736,7 @@ static struct glsl_ffp_fragment_shader *shader_glsl_find_ffp_fragment_shader(str
if ((desc = find_ffp_frag_shader(&priv->ffp_fragment_shaders, args)))
return CONTAINING_RECORD(desc, struct glsl_ffp_fragment_shader, entry);
if (!(glsl_desc = HeapAlloc(GetProcessHeap(), 0, sizeof(*glsl_desc))))
if (!(glsl_desc = heap_alloc(sizeof(*glsl_desc))))
return NULL;
glsl_desc->entry.settings = *args;
@ -9914,26 +9908,26 @@ static HRESULT shader_glsl_compile_compute_shader(struct shader_glsl_priv *priv,
struct glsl_shader_prog_link *entry;
GLuint shader_id, program_id;
if (!(entry = HeapAlloc(GetProcessHeap(), 0, sizeof(*entry))))
if (!(entry = heap_alloc(sizeof(*entry))))
{
ERR("Out of memory.\n");
return E_OUTOFMEMORY;
}
if (!(shader->backend_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data))))
if (!(shader->backend_data = heap_alloc_zero(sizeof(*shader_data))))
{
ERR("Failed to allocate backend data.\n");
HeapFree(GetProcessHeap(), 0, entry);
heap_free(entry);
return E_OUTOFMEMORY;
}
shader_data = shader->backend_data;
gl_shaders = shader_data->gl_shaders.cs;
if (!(shader_data->gl_shaders.cs = HeapAlloc(GetProcessHeap(), 0, sizeof(*gl_shaders))))
if (!(shader_data->gl_shaders.cs = heap_alloc(sizeof(*gl_shaders))))
{
ERR("Failed to allocate GL shader array.\n");
HeapFree(GetProcessHeap(), 0, entry);
HeapFree(GetProcessHeap(), 0, shader->backend_data);
heap_free(entry);
heap_free(shader->backend_data);
shader->backend_data = NULL;
return E_OUTOFMEMORY;
}
@ -10166,7 +10160,7 @@ static void set_glsl_shader_program(const struct wined3d_context *context, const
TRACE("Created new GLSL shader program %u.\n", program_id);
/* Create the entry */
entry = HeapAlloc(GetProcessHeap(), 0, sizeof(struct glsl_shader_prog_link));
entry = heap_alloc(sizeof(*entry));
entry->id = program_id;
entry->vs.id = vs_id;
entry->hs.id = hs_id;
@ -10610,7 +10604,7 @@ static void shader_glsl_destroy(struct wined3d_shader *shader)
if (!shader_data || !shader_data->num_gl_shaders)
{
HeapFree(GetProcessHeap(), 0, shader_data);
heap_free(shader_data);
shader->backend_data = NULL;
return;
}
@ -10637,7 +10631,7 @@ static void shader_glsl_destroy(struct wined3d_shader *shader)
GL_EXTCALL(glDeleteShader(gl_shaders[i].id));
checkGLcall("glDeleteShader");
}
HeapFree(GetProcessHeap(), 0, shader_data->gl_shaders.ps);
heap_free(shader_data->gl_shaders.ps);
LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, linked_programs,
struct glsl_shader_prog_link, ps.shader_entry)
@ -10659,7 +10653,7 @@ static void shader_glsl_destroy(struct wined3d_shader *shader)
GL_EXTCALL(glDeleteShader(gl_shaders[i].id));
checkGLcall("glDeleteShader");
}
HeapFree(GetProcessHeap(), 0, shader_data->gl_shaders.vs);
heap_free(shader_data->gl_shaders.vs);
LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, linked_programs,
struct glsl_shader_prog_link, vs.shader_entry)
@ -10681,7 +10675,7 @@ static void shader_glsl_destroy(struct wined3d_shader *shader)
GL_EXTCALL(glDeleteShader(gl_shaders[i].id));
checkGLcall("glDeleteShader");
}
HeapFree(GetProcessHeap(), 0, shader_data->gl_shaders.hs);
heap_free(shader_data->gl_shaders.hs);
LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, linked_programs,
struct glsl_shader_prog_link, hs.shader_entry)
@ -10703,7 +10697,7 @@ static void shader_glsl_destroy(struct wined3d_shader *shader)
GL_EXTCALL(glDeleteShader(gl_shaders[i].id));
checkGLcall("glDeleteShader");
}
HeapFree(GetProcessHeap(), 0, shader_data->gl_shaders.ds);
heap_free(shader_data->gl_shaders.ds);
LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, linked_programs,
struct glsl_shader_prog_link, ds.shader_entry)
@ -10725,7 +10719,7 @@ static void shader_glsl_destroy(struct wined3d_shader *shader)
GL_EXTCALL(glDeleteShader(gl_shaders[i].id));
checkGLcall("glDeleteShader");
}
HeapFree(GetProcessHeap(), 0, shader_data->gl_shaders.gs);
heap_free(shader_data->gl_shaders.gs);
LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, linked_programs,
struct glsl_shader_prog_link, gs.shader_entry)
@ -10747,7 +10741,7 @@ static void shader_glsl_destroy(struct wined3d_shader *shader)
GL_EXTCALL(glDeleteShader(gl_shaders[i].id));
checkGLcall("glDeleteShader");
}
HeapFree(GetProcessHeap(), 0, shader_data->gl_shaders.cs);
heap_free(shader_data->gl_shaders.cs);
LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, linked_programs,
struct glsl_shader_prog_link, cs.shader_entry)
@ -10765,7 +10759,7 @@ static void shader_glsl_destroy(struct wined3d_shader *shader)
}
}
HeapFree(GetProcessHeap(), 0, shader->backend_data);
heap_free(shader->backend_data);
shader->backend_data = NULL;
context_release(context);
@ -10803,9 +10797,9 @@ static BOOL constant_heap_init(struct constant_heap *heap, unsigned int constant
SIZE_T size = (constant_count + 1) * sizeof(*heap->entries)
+ constant_count * sizeof(*heap->contained)
+ constant_count * sizeof(*heap->positions);
void *mem = HeapAlloc(GetProcessHeap(), 0, size);
void *mem;
if (!mem)
if (!(mem = heap_alloc(size)))
{
ERR("Failed to allocate memory\n");
return FALSE;
@ -10823,24 +10817,27 @@ static BOOL constant_heap_init(struct constant_heap *heap, unsigned int constant
static void constant_heap_free(struct constant_heap *heap)
{
HeapFree(GetProcessHeap(), 0, heap->entries);
heap_free(heap->entries);
}
static HRESULT shader_glsl_alloc(struct wined3d_device *device, const struct wined3d_vertex_pipe_ops *vertex_pipe,
const struct fragment_pipeline *fragment_pipe)
{
const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
struct shader_glsl_priv *priv = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct shader_glsl_priv));
SIZE_T stack_size = wined3d_log2i(max(WINED3D_MAX_VS_CONSTS_F, WINED3D_MAX_PS_CONSTS_F)) + 1;
const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
struct fragment_caps fragment_caps;
void *vertex_priv, *fragment_priv;
struct shader_glsl_priv *priv;
if (!(priv = heap_alloc_zero(sizeof(*priv))))
return E_OUTOFMEMORY;
string_buffer_list_init(&priv->string_buffers);
if (!(vertex_priv = vertex_pipe->vp_alloc(&glsl_shader_backend, priv)))
{
ERR("Failed to initialize vertex pipe.\n");
HeapFree(GetProcessHeap(), 0, priv);
heap_free(priv);
return E_FAIL;
}
@ -10848,7 +10845,7 @@ static HRESULT shader_glsl_alloc(struct wined3d_device *device, const struct win
{
ERR("Failed to initialize fragment pipe.\n");
vertex_pipe->vp_free(device);
HeapFree(GetProcessHeap(), 0, priv);
heap_free(priv);
return E_FAIL;
}
@ -10858,7 +10855,7 @@ static HRESULT shader_glsl_alloc(struct wined3d_device *device, const struct win
goto fail;
}
if (!(priv->stack = wined3d_calloc(stack_size, sizeof(*priv->stack))))
if (!(priv->stack = heap_calloc(stack_size, sizeof(*priv->stack))))
{
ERR("Failed to allocate memory.\n");
goto fail;
@ -10894,11 +10891,11 @@ static HRESULT shader_glsl_alloc(struct wined3d_device *device, const struct win
fail:
constant_heap_free(&priv->pconst_heap);
constant_heap_free(&priv->vconst_heap);
HeapFree(GetProcessHeap(), 0, priv->stack);
heap_free(priv->stack);
string_buffer_free(&priv->shader_buffer);
fragment_pipe->free_private(device);
vertex_pipe->vp_free(device);
HeapFree(GetProcessHeap(), 0, priv);
heap_free(priv);
return E_OUTOFMEMORY;
}
@ -10910,20 +10907,21 @@ static void shader_glsl_free(struct wined3d_device *device)
wine_rb_destroy(&priv->program_lookup, NULL, NULL);
constant_heap_free(&priv->pconst_heap);
constant_heap_free(&priv->vconst_heap);
HeapFree(GetProcessHeap(), 0, priv->stack);
heap_free(priv->stack);
string_buffer_list_cleanup(&priv->string_buffers);
string_buffer_free(&priv->shader_buffer);
priv->fragment_pipe->free_private(device);
priv->vertex_pipe->vp_free(device);
HeapFree(GetProcessHeap(), 0, device->shader_priv);
heap_free(device->shader_priv);
device->shader_priv = NULL;
}
static BOOL shader_glsl_allocate_context_data(struct wined3d_context *context)
{
struct glsl_context_data *ctx_data;
if (!(ctx_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ctx_data))))
if (!(ctx_data = heap_alloc_zero(sizeof(*ctx_data))))
return FALSE;
ctx_data->vertex_color_clamp = GL_FIXED_ONLY_ARB;
context->shader_backend_data = ctx_data;
@ -10932,7 +10930,7 @@ static BOOL shader_glsl_allocate_context_data(struct wined3d_context *context)
static void shader_glsl_free_context_data(struct wined3d_context *context)
{
HeapFree(GetProcessHeap(), 0, context->shader_backend_data);
heap_free(context->shader_backend_data);
}
static void shader_glsl_init_context_state(struct wined3d_context *context)
@ -11372,7 +11370,7 @@ static void shader_glsl_free_ffp_vertex_shader(struct wine_rb_entry *entry, void
delete_glsl_program_entry(ctx->priv, ctx->gl_info, program);
}
ctx->gl_info->gl_ops.ext.p_glDeleteShader(shader->id);
HeapFree(GetProcessHeap(), 0, shader);
heap_free(shader);
}
/* Context activation is done by the caller. */
@ -11869,7 +11867,7 @@ static void shader_glsl_free_ffp_fragment_shader(struct wine_rb_entry *entry, vo
delete_glsl_program_entry(ctx->priv, ctx->gl_info, program);
}
ctx->gl_info->gl_ops.ext.p_glDeleteShader(shader->id);
HeapFree(GetProcessHeap(), 0, shader);
heap_free(shader);
}
/* Context activation is done by the caller. */

7
dlls/wined3d/palette.c
View file

@ -35,7 +35,7 @@ ULONG CDECL wined3d_palette_incref(struct wined3d_palette *palette)
static void wined3d_palette_destroy_object(void *object)
{
HeapFree(GetProcessHeap(), 0, object);
heap_free(object);
}
ULONG CDECL wined3d_palette_decref(struct wined3d_palette *palette)
@ -160,14 +160,13 @@ HRESULT CDECL wined3d_palette_create(struct wined3d_device *device, DWORD flags,
TRACE("device %p, flags %#x, entry_count %u, entries %p, palette %p.\n",
device, flags, entry_count, entries, palette);
object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
if (!object)
if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
if (FAILED(hr = wined3d_palette_init(object, device, flags, entry_count, entries)))
{
WARN("Failed to initialize palette, hr %#x.\n", hr);
HeapFree(GetProcessHeap(), 0, object);
heap_free(object);
return hr;
}

32
dlls/wined3d/query.c
View file

@ -286,7 +286,7 @@ static void wined3d_fence_free(struct wined3d_fence *fence)
void wined3d_fence_destroy(struct wined3d_fence *fence)
{
wined3d_fence_free(fence);
HeapFree(GetProcessHeap(), 0, fence);
heap_free(fence);
}
static HRESULT wined3d_fence_init(struct wined3d_fence *fence, const struct wined3d_gl_info *gl_info)
@ -308,12 +308,12 @@ HRESULT wined3d_fence_create(struct wined3d_device *device, struct wined3d_fence
TRACE("device %p, fence %p.\n", device, fence);
if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
if (FAILED(hr = wined3d_fence_init(object, gl_info)))
{
HeapFree(GetProcessHeap(), 0, object);
heap_free(object);
return hr;
}
@ -918,7 +918,7 @@ static void wined3d_event_query_ops_destroy(struct wined3d_query *query)
struct wined3d_event_query *event_query = wined3d_event_query_from_query(query);
wined3d_fence_free(&event_query->fence);
HeapFree(GetProcessHeap(), 0, event_query);
heap_free(event_query);
}
static const struct wined3d_query_ops event_query_ops =
@ -939,13 +939,13 @@ static HRESULT wined3d_event_query_create(struct wined3d_device *device,
TRACE("device %p, type %#x, parent %p, parent_ops %p, query %p.\n",
device, type, parent, parent_ops, query);
if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
if (FAILED(hr = wined3d_fence_init(&object->fence, gl_info)))
{
WARN("Event queries not supported.\n");
HeapFree(GetProcessHeap(), 0, object);
heap_free(object);
return hr;
}
@ -964,7 +964,7 @@ static void wined3d_occlusion_query_ops_destroy(struct wined3d_query *query)
if (oq->context)
context_free_occlusion_query(oq);
HeapFree(GetProcessHeap(), 0, oq);
heap_free(oq);
}
static const struct wined3d_query_ops occlusion_query_ops =
@ -990,7 +990,7 @@ static HRESULT wined3d_occlusion_query_create(struct wined3d_device *device,
return WINED3DERR_NOTAVAILABLE;
}
if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
wined3d_query_init(&object->query, device, type, &object->samples,
@ -1008,7 +1008,7 @@ static void wined3d_timestamp_query_ops_destroy(struct wined3d_query *query)
if (tq->context)
context_free_timestamp_query(tq);
HeapFree(GetProcessHeap(), 0, tq);
heap_free(tq);
}
static const struct wined3d_query_ops timestamp_query_ops =
@ -1034,7 +1034,7 @@ static HRESULT wined3d_timestamp_query_create(struct wined3d_device *device,
return WINED3DERR_NOTAVAILABLE;
}
if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
wined3d_query_init(&object->query, device, type, &object->timestamp,
@ -1048,7 +1048,7 @@ static HRESULT wined3d_timestamp_query_create(struct wined3d_device *device,
static void wined3d_timestamp_disjoint_query_ops_destroy(struct wined3d_query *query)
{
HeapFree(GetProcessHeap(), 0, query);
heap_free(query);
}
static const struct wined3d_query_ops timestamp_disjoint_query_ops =
@ -1074,7 +1074,7 @@ static HRESULT wined3d_timestamp_disjoint_query_create(struct wined3d_device *de
return WINED3DERR_NOTAVAILABLE;
}
if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
if (type == WINED3D_QUERY_TYPE_TIMESTAMP_DISJOINT)
@ -1104,7 +1104,7 @@ static void wined3d_so_statistics_query_ops_destroy(struct wined3d_query *query)
if (pq->context)
context_free_so_statistics_query(pq);
HeapFree(GetProcessHeap(), 0, pq);
heap_free(pq);
}
static const struct wined3d_query_ops so_statistics_query_ops =
@ -1141,7 +1141,7 @@ static HRESULT wined3d_so_statistics_query_create(struct wined3d_device *device,
return WINED3DERR_NOTAVAILABLE;
}
if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
wined3d_query_init(&object->query, device, type, &object->statistics,
@ -1159,7 +1159,7 @@ static void wined3d_pipeline_query_ops_destroy(struct wined3d_query *query)
struct wined3d_pipeline_statistics_query *pq = wined3d_pipeline_statistics_query_from_query(query);
if (pq->context)
context_free_pipeline_statistics_query(pq);
HeapFree(GetProcessHeap(), 0, pq);
heap_free(pq);
}
static const struct wined3d_query_ops pipeline_query_ops =
@ -1185,7 +1185,7 @@ static HRESULT wined3d_pipeline_query_create(struct wined3d_device *device,
return WINED3DERR_NOTAVAILABLE;
}
if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
wined3d_query_init(&object->query, device, type, &object->statistics,

4
dlls/wined3d/resource.c
View file

@ -374,7 +374,7 @@ BOOL wined3d_resource_allocate_sysmem(struct wined3d_resource *resource)
SIZE_T align = RESOURCE_ALIGNMENT - 1 + sizeof(*p);
void *mem;
if (!(mem = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, resource->size + align)))
if (!(mem = heap_alloc_zero(resource->size + align)))
return FALSE;
p = (void **)(((ULONG_PTR)mem + align) & ~(RESOURCE_ALIGNMENT - 1)) - 1;
@ -392,7 +392,7 @@ void wined3d_resource_free_sysmem(struct wined3d_resource *resource)
if (!p)
return;
HeapFree(GetProcessHeap(), 0, *(--p));
heap_free(*(--p));
resource->heap_memory = NULL;
}

4
dlls/wined3d/sampler.c
View file

@ -47,7 +47,7 @@ static void wined3d_sampler_destroy_object(void *object)
context_release(context);
}
HeapFree(GetProcessHeap(), 0, sampler);
heap_free(sampler);
}
ULONG CDECL wined3d_sampler_decref(struct wined3d_sampler *sampler)
@ -144,7 +144,7 @@ HRESULT CDECL wined3d_sampler_create(struct wined3d_device *device, const struct
|| desc->mip_filter > WINED3D_TEXF_LINEAR)
return WINED3DERR_INVALIDCALL;
if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
wined3d_sampler_init(object, device, desc, parent, parent_ops);

138
dlls/wined3d/shader.c
View file

@ -428,7 +428,7 @@ void string_buffer_clear(struct wined3d_string_buffer *buffer)
BOOL string_buffer_init(struct wined3d_string_buffer *buffer)
{
buffer->buffer_size = 32;
if (!(buffer->buffer = HeapAlloc(GetProcessHeap(), 0, buffer->buffer_size)))
if (!(buffer->buffer = heap_alloc(buffer->buffer_size)))
{
ERR("Failed to allocate shader buffer memory.\n");
return FALSE;
@ -440,7 +440,7 @@ BOOL string_buffer_init(struct wined3d_string_buffer *buffer)
void string_buffer_free(struct wined3d_string_buffer *buffer)
{
HeapFree(GetProcessHeap(), 0, buffer->buffer);
heap_free(buffer->buffer);
}
BOOL string_buffer_resize(struct wined3d_string_buffer *buffer, int rc)
@ -450,7 +450,7 @@ BOOL string_buffer_resize(struct wined3d_string_buffer *buffer, int rc)
while (rc > 0 && (unsigned int)rc >= new_buffer_size - buffer->content_size)
new_buffer_size *= 2;
if (!(new_buffer = HeapReAlloc(GetProcessHeap(), 0, buffer->buffer, new_buffer_size)))
if (!(new_buffer = heap_realloc(buffer->buffer, new_buffer_size)))
{
ERR("Failed to grow buffer.\n");
buffer->buffer[buffer->content_size] = '\0';
@ -498,11 +498,11 @@ struct wined3d_string_buffer *string_buffer_get(struct wined3d_string_buffer_lis
if (list_empty(&list->list))
{
buffer = HeapAlloc(GetProcessHeap(), 0, sizeof(*buffer));
buffer = heap_alloc(sizeof(*buffer));
if (!buffer || !string_buffer_init(buffer))
{
ERR("Couldn't allocate buffer for temporary string.\n");
HeapFree(GetProcessHeap(), 0, buffer);
heap_free(buffer);
return NULL;
}
}
@ -559,7 +559,7 @@ void string_buffer_list_cleanup(struct wined3d_string_buffer_list *list)
LIST_FOR_EACH_ENTRY_SAFE(buffer, buffer_next, &list->list, struct wined3d_string_buffer, entry)
{
string_buffer_free(buffer);
HeapFree(GetProcessHeap(), 0, buffer);
heap_free(buffer);
}
list_init(&list->list);
}
@ -585,7 +585,7 @@ static void shader_delete_constant_list(struct list *clist)
struct wined3d_shader_lconst *constant, *constant_next;
LIST_FOR_EACH_ENTRY_SAFE(constant, constant_next, clist, struct wined3d_shader_lconst, entry)
HeapFree(GetProcessHeap(), 0, constant);
heap_free(constant);
list_init(clist);
}
@ -826,7 +826,7 @@ static void shader_record_sample(struct wined3d_shader_reg_maps *reg_maps,
if (!map->size)
{
if (!(entries = wined3d_calloc(4, sizeof(*entries))))
if (!(entries = heap_calloc(4, sizeof(*entries))))
{
ERR("Failed to allocate sampler map entries.\n");
return;
@ -839,7 +839,7 @@ static void shader_record_sample(struct wined3d_shader_reg_maps *reg_maps,
size_t new_size = map->size * 2;
if (sizeof(*entries) * new_size <= sizeof(*entries) * map->size
|| !(entries = HeapReAlloc(GetProcessHeap(), 0, entries, sizeof(*entries) * new_size)))
|| !(entries = heap_realloc(entries, sizeof(*entries) * new_size)))
{
ERR("Failed to resize sampler map entries.\n");
return;
@ -925,10 +925,9 @@ static HRESULT shader_record_shader_phase(struct wined3d_shader *shader,
if (shader->u.hs.phases.control_point)
{
FIXME("Multiple control point phases.\n");
HeapFree(GetProcessHeap(), 0, shader->u.hs.phases.control_point);
heap_free(shader->u.hs.phases.control_point);
}
if (!(shader->u.hs.phases.control_point = HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY, sizeof(*shader->u.hs.phases.control_point))))
if (!(shader->u.hs.phases.control_point = heap_alloc_zero(sizeof(*shader->u.hs.phases.control_point))))
return E_OUTOFMEMORY;
phase = shader->u.hs.phases.control_point;
break;
@ -1011,7 +1010,7 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const st
shader_set_limits(shader);
if (!(reg_maps->constf = wined3d_calloc(((min(shader->limits->constant_float, constf_size) + 31) / 32),
if (!(reg_maps->constf = heap_calloc(((min(shader->limits->constant_float, constf_size) + 31) / 32),
sizeof(*reg_maps->constf))))
{
ERR("Failed to allocate constant map memory.\n");
@ -1156,7 +1155,7 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const st
{
struct wined3d_shader_indexable_temp *reg;
if (!(reg = HeapAlloc(GetProcessHeap(), 0, sizeof(*reg))))
if (!(reg = heap_alloc(sizeof(*reg))))
return E_OUTOFMEMORY;
*reg = ins.declaration.indexable_temp;
@ -1336,9 +1335,11 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const st
}
else if (ins.handler_idx == WINED3DSIH_DEF)
{
struct wined3d_shader_lconst *lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(*lconst));
struct wined3d_shader_lconst *lconst;
float *value;
if (!lconst) return E_OUTOFMEMORY;
if (!(lconst = heap_alloc(sizeof(*lconst))))
return E_OUTOFMEMORY;
lconst->idx = ins.dst[0].reg.idx[0].offset;
memcpy(lconst->value, ins.src[0].reg.u.immconst_data, 4 * sizeof(DWORD));
@ -1367,8 +1368,10 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const st
}
else if (ins.handler_idx == WINED3DSIH_DEFI)
{
struct wined3d_shader_lconst *lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(*lconst));
if (!lconst) return E_OUTOFMEMORY;
struct wined3d_shader_lconst *lconst;
if (!(lconst = heap_alloc(sizeof(*lconst))))
return E_OUTOFMEMORY;
lconst->idx = ins.dst[0].reg.idx[0].offset;
memcpy(lconst->value, ins.src[0].reg.u.immconst_data, 4 * sizeof(DWORD));
@ -1378,8 +1381,10 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const st
}
else if (ins.handler_idx == WINED3DSIH_DEFB)
{
struct wined3d_shader_lconst *lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(*lconst));
if (!lconst) return E_OUTOFMEMORY;
struct wined3d_shader_lconst *lconst;
if (!(lconst = heap_alloc(sizeof(*lconst))))
return E_OUTOFMEMORY;
lconst->idx = ins.dst[0].reg.idx[0].offset;
memcpy(lconst->value, ins.src[0].reg.u.immconst_data, sizeof(DWORD));
@ -1759,7 +1764,7 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const st
struct wined3d_shader_signature_element *e;
unsigned int i;
if (!(input_signature->elements = wined3d_calloc(count, sizeof(*input_signature->elements))))
if (!(input_signature->elements = heap_calloc(count, sizeof(*input_signature->elements))))
return E_OUTOFMEMORY;
input_signature->element_count = count;
@ -1800,7 +1805,7 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const st
unsigned int count = wined3d_popcount(reg_maps->output_registers);
struct wined3d_shader_signature_element *e;
if (!(output_signature->elements = wined3d_calloc(count, sizeof(*output_signature->elements))))
if (!(output_signature->elements = heap_calloc(count, sizeof(*output_signature->elements))))
return E_OUTOFMEMORY;
output_signature->element_count = count;
@ -1820,14 +1825,14 @@ static void shader_cleanup_reg_maps(struct wined3d_shader_reg_maps *reg_maps)
{
struct wined3d_shader_indexable_temp *reg, *reg_next;
HeapFree(GetProcessHeap(), 0, reg_maps->constf);
HeapFree(GetProcessHeap(), 0, reg_maps->sampler_map.entries);
heap_free(reg_maps->constf);
heap_free(reg_maps->sampler_map.entries);
LIST_FOR_EACH_ENTRY_SAFE(reg, reg_next, &reg_maps->indexable_temps, struct wined3d_shader_indexable_temp, entry)
HeapFree(GetProcessHeap(), 0, reg);
heap_free(reg);
list_init(&reg_maps->indexable_temps);
HeapFree(GetProcessHeap(), 0, reg_maps->tgsm);
heap_free(reg_maps->tgsm);
}
unsigned int shader_find_free_input_register(const struct wined3d_shader_reg_maps *reg_maps, unsigned int max)
@ -3084,22 +3089,22 @@ static void shader_cleanup(struct wined3d_shader *shader)
{
if (shader->reg_maps.shader_version.type == WINED3D_SHADER_TYPE_HULL)
{
HeapFree(GetProcessHeap(), 0, shader->u.hs.phases.control_point);
HeapFree(GetProcessHeap(), 0, shader->u.hs.phases.fork);
HeapFree(GetProcessHeap(), 0, shader->u.hs.phases.join);
heap_free(shader->u.hs.phases.control_point);
heap_free(shader->u.hs.phases.fork);
heap_free(shader->u.hs.phases.join);
}
else if (shader->reg_maps.shader_version.type == WINED3D_SHADER_TYPE_GEOMETRY)
{
HeapFree(GetProcessHeap(), 0, shader->u.gs.so_desc.elements);
heap_free(shader->u.gs.so_desc.elements);
}
HeapFree(GetProcessHeap(), 0, shader->patch_constant_signature.elements);
HeapFree(GetProcessHeap(), 0, shader->output_signature.elements);
HeapFree(GetProcessHeap(), 0, shader->input_signature.elements);
HeapFree(GetProcessHeap(), 0, shader->signature_strings);
heap_free(shader->patch_constant_signature.elements);
heap_free(shader->output_signature.elements);
heap_free(shader->input_signature.elements);
heap_free(shader->signature_strings);
shader->device->shader_backend->shader_destroy(shader);
shader_cleanup_reg_maps(&shader->reg_maps);
HeapFree(GetProcessHeap(), 0, shader->function);
heap_free(shader->function);
shader_delete_constant_list(&shader->constantsF);
shader_delete_constant_list(&shader->constantsB);
shader_delete_constant_list(&shader->constantsI);
@ -3163,13 +3168,13 @@ static HRESULT shader_none_alloc(struct wined3d_device *device, const struct win
void *vertex_priv, *fragment_priv;
struct shader_none_priv *priv;
if (!(priv = HeapAlloc(GetProcessHeap(), 0, sizeof(*priv))))
if (!(priv = heap_alloc(sizeof(*priv))))
return E_OUTOFMEMORY;
if (!(vertex_priv = vertex_pipe->vp_alloc(&none_shader_backend, priv)))
{
ERR("Failed to initialize vertex pipe.\n");
HeapFree(GetProcessHeap(), 0, priv);
heap_free(priv);
return E_FAIL;
}
@ -3177,7 +3182,7 @@ static HRESULT shader_none_alloc(struct wined3d_device *device, const struct win
{
ERR("Failed to initialize fragment pipe.\n");
vertex_pipe->vp_free(device);
HeapFree(GetProcessHeap(), 0, priv);
heap_free(priv);
return E_FAIL;
}
@ -3199,7 +3204,7 @@ static void shader_none_free(struct wined3d_device *device)
priv->fragment_pipe->free_private(device);
priv->vertex_pipe->vp_free(device);
HeapFree(GetProcessHeap(), 0, priv);
heap_free(priv);
}
static BOOL shader_none_allocate_context_data(struct wined3d_context *context)
@ -3353,7 +3358,7 @@ static void wined3d_shader_init_object(void *object)
static void wined3d_shader_destroy_object(void *object)
{
shader_cleanup(object);
HeapFree(GetProcessHeap(), 0, object);
heap_free(object);
}
ULONG CDECL wined3d_shader_decref(struct wined3d_shader *shader)
@ -3420,9 +3425,10 @@ HRESULT CDECL wined3d_shader_set_local_constants_float(struct wined3d_shader *sh
for (i = start_idx; i < end_idx; ++i)
{
struct wined3d_shader_lconst *lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(*lconst));
struct wined3d_shader_lconst *lconst;
float *value;
if (!lconst)
if (!(lconst = heap_alloc(sizeof(*lconst))))
return E_OUTOFMEMORY;
lconst->idx = i;
@ -3554,7 +3560,7 @@ static HRESULT shader_signature_copy(struct wined3d_shader_signature *dst,
ptr = *signature_strings;
dst->element_count = src->element_count;
if (!(dst->elements = wined3d_calloc(dst->element_count, sizeof(*dst->elements))))
if (!(dst->elements = heap_calloc(dst->element_count, sizeof(*dst->elements))))
return E_OUTOFMEMORY;
for (i = 0; i < src->element_count; ++i)
@ -3606,26 +3612,26 @@ static HRESULT shader_init(struct wined3d_shader *shader, struct wined3d_device
return hr;
if (FAILED(hr = shader_signature_calculate_strings_length(&desc->patch_constant_signature, &total)))
return hr;
if (total && !(shader->signature_strings = HeapAlloc(GetProcessHeap(), 0, total)))
if (total && !(shader->signature_strings = heap_alloc(total)))
return E_OUTOFMEMORY;
ptr = shader->signature_strings;
if (FAILED(hr = shader_signature_copy(&shader->input_signature, &desc->input_signature, &ptr)))
{
HeapFree(GetProcessHeap(), 0, shader->signature_strings);
heap_free(shader->signature_strings);
return hr;
}
if (FAILED(hr = shader_signature_copy(&shader->output_signature, &desc->output_signature, &ptr)))
{
HeapFree(GetProcessHeap(), 0, shader->input_signature.elements);
HeapFree(GetProcessHeap(), 0, shader->signature_strings);
heap_free(shader->input_signature.elements);
heap_free(shader->signature_strings);
return hr;
}
if (FAILED(hr = shader_signature_copy(&shader->patch_constant_signature, &desc->patch_constant_signature, &ptr)))
{
HeapFree(GetProcessHeap(), 0, shader->output_signature.elements);
HeapFree(GetProcessHeap(), 0, shader->input_signature.elements);
HeapFree(GetProcessHeap(), 0, shader->signature_strings);
heap_free(shader->output_signature.elements);
heap_free(shader->input_signature.elements);
heap_free(shader->signature_strings);
return hr;
}
@ -3662,7 +3668,7 @@ static HRESULT shader_init(struct wined3d_shader *shader, struct wined3d_device
byte_code_size = (ptr - desc->byte_code) * sizeof(*ptr);
}
if (!(shader->function = HeapAlloc(GetProcessHeap(), 0, byte_code_size)))
if (!(shader->function = heap_alloc(byte_code_size)))
{
shader_cleanup(shader);
return E_OUTOFMEMORY;
@ -3720,12 +3726,12 @@ static HRESULT geometry_shader_init(struct wined3d_shader *shader, struct wined3
struct wined3d_stream_output_element *elements = NULL;
HRESULT hr;
if (so_desc && !(elements = wined3d_calloc(so_desc->element_count, sizeof(*elements))))
if (so_desc && !(elements = heap_calloc(so_desc->element_count, sizeof(*elements))))
return E_OUTOFMEMORY;
if (FAILED(hr = shader_init(shader, device, desc, 0, WINED3D_SHADER_TYPE_GEOMETRY, parent, parent_ops)))
{
HeapFree(GetProcessHeap(), 0, elements);
heap_free(elements);
return hr;
}
@ -4102,13 +4108,13 @@ HRESULT CDECL wined3d_shader_create_cs(struct wined3d_device *device, const stru
TRACE("device %p, desc %p, parent %p, parent_ops %p, shader %p.\n",
device, desc, parent, parent_ops, shader);
if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
if (FAILED(hr = shader_init(object, device, desc, 0, WINED3D_SHADER_TYPE_COMPUTE, parent, parent_ops)))
{
WARN("Failed to initialize compute shader, hr %#x.\n", hr);
HeapFree(GetProcessHeap(), 0, object);
heap_free(object);
return hr;
}
@ -4127,13 +4133,13 @@ HRESULT CDECL wined3d_shader_create_ds(struct wined3d_device *device, const stru
TRACE("device %p, desc %p, parent %p, parent_ops %p, shader %p.\n",
device, desc, parent, parent_ops, shader);
if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
if (FAILED(hr = shader_init(object, device, desc, 0, WINED3D_SHADER_TYPE_DOMAIN, parent, parent_ops)))
{
WARN("Failed to initialize domain shader, hr %#x.\n", hr);
HeapFree(GetProcessHeap(), 0, object);
heap_free(object);
return hr;
}
@ -4153,13 +4159,13 @@ HRESULT CDECL wined3d_shader_create_gs(struct wined3d_device *device, const stru
TRACE("device %p, desc %p, so_desc %p, parent %p, parent_ops %p, shader %p.\n",
device, desc, so_desc, parent, parent_ops, shader);
if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
if (FAILED(hr = geometry_shader_init(object, device, desc, so_desc, parent, parent_ops)))
{
WARN("Failed to initialize geometry shader, hr %#x.\n", hr);
HeapFree(GetProcessHeap(), 0, object);
heap_free(object);
return hr;
}
@ -4178,13 +4184,13 @@ HRESULT CDECL wined3d_shader_create_hs(struct wined3d_device *device, const stru
TRACE("device %p, desc %p, parent %p, parent_ops %p, shader %p.\n",
device, desc, parent, parent_ops, shader);
if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
if (FAILED(hr = shader_init(object, device, desc, 0, WINED3D_SHADER_TYPE_HULL, parent, parent_ops)))
{
WARN("Failed to initialize hull shader, hr %#x.\n", hr);
HeapFree(GetProcessHeap(), 0, object);
heap_free(object);
return hr;
}
@ -4203,14 +4209,13 @@ HRESULT CDECL wined3d_shader_create_ps(struct wined3d_device *device, const stru
TRACE("device %p, desc %p, parent %p, parent_ops %p, shader %p.\n",
device, desc, parent, parent_ops, shader);
object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
if (!object)
if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
if (FAILED(hr = pixel_shader_init(object, device, desc, parent, parent_ops)))
{
WARN("Failed to initialize pixel shader, hr %#x.\n", hr);
HeapFree(GetProcessHeap(), 0, object);
heap_free(object);
return hr;
}
@ -4229,14 +4234,13 @@ HRESULT CDECL wined3d_shader_create_vs(struct wined3d_device *device, const stru
TRACE("device %p, desc %p, parent %p, parent_ops %p, shader %p.\n",
device, desc, parent, parent_ops, shader);
object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
if (!object)
if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
if (FAILED(hr = vertex_shader_init(object, device, desc, parent, parent_ops)))
{
WARN("Failed to initialize vertex shader, hr %#x.\n", hr);
HeapFree(GetProcessHeap(), 0, object);
heap_free(object);
return hr;
}

6
dlls/wined3d/shader_sm1.c
View file

@ -549,7 +549,7 @@ static void *shader_sm1_init(const DWORD *byte_code, size_t byte_code_size,
return NULL;
}
if (!(priv = HeapAlloc(GetProcessHeap(), 0, sizeof(*priv))))
if (!(priv = heap_alloc(sizeof(*priv))))
return NULL;
if (output_signature->element_count)
@ -569,7 +569,7 @@ static void *shader_sm1_init(const DWORD *byte_code, size_t byte_code_size,
default:
FIXME("Unrecognized shader type %#x.\n", *byte_code >> 16);
HeapFree(GetProcessHeap(), 0, priv);
heap_free(priv);
return NULL;
}
priv->shader_version.major = WINED3D_SM1_VERSION_MAJOR(*byte_code);
@ -582,7 +582,7 @@ static void *shader_sm1_init(const DWORD *byte_code, size_t byte_code_size,
static void shader_sm1_free(void *data)
{
HeapFree(GetProcessHeap(), 0, data);
heap_free(data);
}
static void shader_sm1_read_header(void *data, const DWORD **ptr, struct wined3d_shader_version *shader_version)

8
dlls/wined3d/shader_sm4.c
View file

@ -1242,7 +1242,7 @@ static void *shader_sm4_init(const DWORD *byte_code, size_t byte_code_size,
return NULL;
}
if (!(priv = HeapAlloc(GetProcessHeap(), 0, sizeof(*priv))))
if (!(priv = heap_alloc(sizeof(*priv))))
{
ERR("Failed to allocate private data\n");
return NULL;
@ -1311,9 +1311,9 @@ static void shader_sm4_free(void *data)
list_move_head(&priv->src_free, &priv->src);
LIST_FOR_EACH_ENTRY_SAFE(e1, e2, &priv->src_free, struct wined3d_shader_src_param_entry, entry)
{
HeapFree(GetProcessHeap(), 0, e1);
heap_free(e1);
}
HeapFree(GetProcessHeap(), 0, priv);
heap_free(priv);
}
static struct wined3d_shader_src_param *get_src_param(struct wined3d_sm4_data *priv)
@ -1328,7 +1328,7 @@ static struct wined3d_shader_src_param *get_src_param(struct wined3d_sm4_data *p
}
else
{
if (!(e = HeapAlloc(GetProcessHeap(), 0, sizeof(*e))))
if (!(e = heap_alloc(sizeof(*e))))
return NULL;
elem = &e->entry;
}

23
dlls/wined3d/state.c
View file

@ -49,7 +49,7 @@ ULONG CDECL wined3d_blend_state_incref(struct wined3d_blend_state *state)
static void wined3d_blend_state_destroy_object(void *object)
{
HeapFree(GetProcessHeap(), 0, object);
heap_free(object);
}
ULONG CDECL wined3d_blend_state_decref(struct wined3d_blend_state *state)
@ -84,7 +84,7 @@ HRESULT CDECL wined3d_blend_state_create(struct wined3d_device *device,
TRACE("device %p, desc %p, parent %p, parent_ops %p, state %p.\n",
device, desc, parent, parent_ops, state);
if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
object->refcount = 1;
@ -110,7 +110,7 @@ ULONG CDECL wined3d_rasterizer_state_incref(struct wined3d_rasterizer_state *sta
static void wined3d_rasterizer_state_destroy_object(void *object)
{
HeapFree(GetProcessHeap(), 0, object);
heap_free(object);
}
ULONG CDECL wined3d_rasterizer_state_decref(struct wined3d_rasterizer_state *state)
@ -145,7 +145,7 @@ HRESULT CDECL wined3d_rasterizer_state_create(struct wined3d_device *device,
TRACE("device %p, desc %p, parent %p, parent_ops %p, state %p.\n",
device, desc, parent, parent_ops, state);
if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
object->refcount = 1;
@ -6170,7 +6170,7 @@ HRESULT compile_state_table(struct StateEntry *StateTable, APPLYSTATEFUNC **dev_
break;
case 1:
StateTable[cur[i].state].apply = multistate_apply_2;
if (!(dev_multistate_funcs[cur[i].state] = wined3d_calloc(2, sizeof(**dev_multistate_funcs))))
if (!(dev_multistate_funcs[cur[i].state] = heap_calloc(2, sizeof(**dev_multistate_funcs))))
goto out_of_mem;
dev_multistate_funcs[cur[i].state][0] = multistate_funcs[cur[i].state][0];
@ -6178,13 +6178,9 @@ HRESULT compile_state_table(struct StateEntry *StateTable, APPLYSTATEFUNC **dev_
break;
case 2:
StateTable[cur[i].state].apply = multistate_apply_3;
funcs_array = HeapReAlloc(GetProcessHeap(),
0,
dev_multistate_funcs[cur[i].state],
sizeof(**dev_multistate_funcs) * 3);
if (!funcs_array) {
if (!(funcs_array = heap_realloc(dev_multistate_funcs[cur[i].state],
sizeof(**dev_multistate_funcs) * 3)))
goto out_of_mem;
}
dev_multistate_funcs[cur[i].state] = funcs_array;
dev_multistate_funcs[cur[i].state][2] = multistate_funcs[cur[i].state][2];
@ -6210,8 +6206,9 @@ HRESULT compile_state_table(struct StateEntry *StateTable, APPLYSTATEFUNC **dev_
return WINED3D_OK;
out_of_mem:
for (i = 0; i <= STATE_HIGHEST; ++i) {
HeapFree(GetProcessHeap(), 0, dev_multistate_funcs[i]);
for (i = 0; i <= STATE_HIGHEST; ++i)
{
heap_free(dev_multistate_funcs[i]);
}
memset(dev_multistate_funcs, 0, (STATE_HIGHEST + 1)*sizeof(*dev_multistate_funcs));

11
dlls/wined3d/stateblock.c
View file

@ -404,7 +404,7 @@ static void stateblock_init_lights(struct wined3d_stateblock *stateblock, struct
LIST_FOR_EACH_ENTRY(src_light, &light_map[i], struct wined3d_light_info, entry)
{
struct wined3d_light_info *dst_light = HeapAlloc(GetProcessHeap(), 0, sizeof(*dst_light));
struct wined3d_light_info *dst_light = heap_alloc(sizeof(*dst_light));
*dst_light = *src_light;
list_add_tail(&stateblock->state.light_map[i], &dst_light->entry);
@ -539,7 +539,7 @@ void state_cleanup(struct wined3d_state *state)
{
struct wined3d_light_info *light = LIST_ENTRY(e1, struct wined3d_light_info, entry);
list_remove(&light->entry);
HeapFree(GetProcessHeap(), 0, light);
heap_free(light);
}
}
}
@ -553,7 +553,7 @@ ULONG CDECL wined3d_stateblock_decref(struct wined3d_stateblock *stateblock)
if (!refcount)
{
state_cleanup(&stateblock->state);
HeapFree(GetProcessHeap(), 0, stateblock);
heap_free(stateblock);
}
return refcount;
@ -1372,15 +1372,14 @@ HRESULT CDECL wined3d_stateblock_create(struct wined3d_device *device,
TRACE("device %p, type %#x, stateblock %p.\n",
device, type, stateblock);
object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
if (!object)
if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
hr = stateblock_init(object, device, type);
if (FAILED(hr))
{
WARN("Failed to initialize stateblock, hr %#x.\n", hr);
HeapFree(GetProcessHeap(), 0, object);
heap_free(object);
return hr;
}

36
dlls/wined3d/surface.c
View file

@ -571,7 +571,7 @@ static void surface_download_data(struct wined3d_surface *surface, const struct
WARN_(d3d_perf)("Downloading all miplevel layers to get the surface data for a single sub-resource.\n");
if (!(temporary_mem = wined3d_calloc(texture->layer_count, sub_resource->size)))
if (!(temporary_mem = heap_calloc(texture->layer_count, sub_resource->size)))
{
ERR("Out of memory.\n");
return;
@ -593,7 +593,7 @@ static void surface_download_data(struct wined3d_surface *surface, const struct
wined3d_texture_get_level_pow2_width(texture, surface->texture_level),
wined3d_texture_get_level_pow2_height(texture, surface->texture_level),
&src_row_pitch, &src_slice_pitch);
if (!(temporary_mem = HeapAlloc(GetProcessHeap(), 0, src_slice_pitch)))
if (!(temporary_mem = heap_alloc(src_slice_pitch)))
{
ERR("Out of memory.\n");
return;
@ -622,7 +622,7 @@ static void surface_download_data(struct wined3d_surface *surface, const struct
wined3d_texture_get_level_height(texture, surface->texture_level),
&src_row_pitch, &src_slice_pitch);
if (!(temporary_mem = HeapAlloc(GetProcessHeap(), 0, src_slice_pitch)))
if (!(temporary_mem = heap_alloc(src_slice_pitch)))
{
ERR("Failed to allocate memory.\n");
return;
@ -751,7 +751,7 @@ static void surface_download_data(struct wined3d_surface *surface, const struct
checkGLcall("glBindBuffer");
}
HeapFree(GetProcessHeap(), 0, temporary_mem);
heap_free(temporary_mem);
}
/* This call just uploads data, the caller is responsible for binding the
@ -1016,7 +1016,7 @@ void surface_set_compatible_renderbuffer(struct wined3d_surface *surface, const
gl_info->fbo_ops.glRenderbufferStorage(GL_RENDERBUFFER,
surface->container->resource.format->glInternal, width, height);
entry = HeapAlloc(GetProcessHeap(), 0, sizeof(*entry));
entry = heap_alloc(sizeof(*entry));
entry->width = width;
entry->height = height;
entry->id = renderbuffer;
@ -1470,7 +1470,7 @@ static void read_from_framebuffer(struct wined3d_surface *surface,
/* glReadPixels returns the image upside down, and there is no way to
* prevent this. Flip the lines in software. */
if (!(row = HeapAlloc(GetProcessHeap(), 0, row_pitch)))
if (!(row = heap_alloc(row_pitch)))
goto error;
if (data.buffer_object)
@ -1491,7 +1491,7 @@ static void read_from_framebuffer(struct wined3d_surface *surface,
top += row_pitch;
bottom -= row_pitch;
}
HeapFree(GetProcessHeap(), 0, row);
heap_free(row);
if (data.buffer_object)
GL_EXTCALL(glUnmapBuffer(GL_PIXEL_PACK_BUFFER));
@ -2317,7 +2317,7 @@ static BOOL surface_load_texture(struct wined3d_surface *surface,
src_mem = context_map_bo_address(context, &data, src_slice_pitch,
GL_PIXEL_UNPACK_BUFFER, WINED3D_MAP_READONLY);
if (!(dst_mem = HeapAlloc(GetProcessHeap(), 0, dst_slice_pitch)))
if (!(dst_mem = heap_alloc(dst_slice_pitch)))
{
ERR("Out of memory (%u).\n", dst_slice_pitch);
context_release(context);
@ -2341,7 +2341,7 @@ static BOOL surface_load_texture(struct wined3d_surface *surface,
src_mem = context_map_bo_address(context, &data, src_slice_pitch,
GL_PIXEL_UNPACK_BUFFER, WINED3D_MAP_READONLY);
if (!(dst_mem = HeapAlloc(GetProcessHeap(), 0, dst_slice_pitch)))
if (!(dst_mem = heap_alloc(dst_slice_pitch)))
{
ERR("Out of memory (%u).\n", dst_slice_pitch);
context_release(context);
@ -2361,7 +2361,7 @@ static BOOL surface_load_texture(struct wined3d_surface *surface,
wined3d_surface_upload_data(surface, gl_info, &format, &src_rect,
src_row_pitch, &dst_point, srgb, wined3d_const_bo_address(&data));
HeapFree(GetProcessHeap(), 0, dst_mem);
heap_free(dst_mem);
return TRUE;
}
@ -2437,7 +2437,7 @@ static void fbo_blitter_destroy(struct wined3d_blitter *blitter, struct wined3d_
if ((next = blitter->next))
next->ops->blitter_destroy(next, context);
HeapFree(GetProcessHeap(), 0, blitter);
heap_free(blitter);
}
static void fbo_blitter_clear(struct wined3d_blitter *blitter, struct wined3d_device *device,
@ -2511,7 +2511,7 @@ void wined3d_fbo_blitter_create(struct wined3d_blitter **next, const struct wine
if ((wined3d_settings.offscreen_rendering_mode != ORM_FBO) || !gl_info->fbo_ops.glBlitFramebuffer)
return;
if (!(blitter = HeapAlloc(GetProcessHeap(), 0, sizeof(*blitter))))
if (!(blitter = heap_alloc(sizeof(*blitter))))
return;
TRACE("Created blitter %p.\n", blitter);
@ -2529,7 +2529,7 @@ static void raw_blitter_destroy(struct wined3d_blitter *blitter, struct wined3d_
if ((next = blitter->next))
next->ops->blitter_destroy(next, context);
HeapFree(GetProcessHeap(), 0, blitter);
heap_free(blitter);
}
/* Context activation is done by the caller. */
@ -2643,7 +2643,7 @@ void wined3d_raw_blitter_create(struct wined3d_blitter **next, const struct wine
if (!gl_info->supported[ARB_COPY_IMAGE])
return;
if (!(blitter = HeapAlloc(GetProcessHeap(), 0, sizeof(*blitter))))
if (!(blitter = heap_alloc(sizeof(*blitter))))
return;
TRACE("Created blitter %p.\n", blitter);
@ -2661,7 +2661,7 @@ static void ffp_blitter_destroy(struct wined3d_blitter *blitter, struct wined3d_
if ((next = blitter->next))
next->ops->blitter_destroy(next, context);
HeapFree(GetProcessHeap(), 0, blitter);
heap_free(blitter);
}
static BOOL ffp_blit_supported(enum wined3d_blit_op blit_op, const struct wined3d_context *context,
@ -2938,7 +2938,7 @@ void wined3d_ffp_blitter_create(struct wined3d_blitter **next, const struct wine
{
struct wined3d_blitter *blitter;
if (!(blitter = HeapAlloc(GetProcessHeap(), 0, sizeof(*blitter))))
if (!(blitter = heap_alloc(sizeof(*blitter))))
return;
TRACE("Created blitter %p.\n", blitter);
@ -2956,7 +2956,7 @@ static void cpu_blitter_destroy(struct wined3d_blitter *blitter, struct wined3d_
if ((next = blitter->next))
next->ops->blitter_destroy(next, context);
HeapFree(GetProcessHeap(), 0, blitter);
heap_free(blitter);
}
static HRESULT surface_cpu_blt_compressed(const BYTE *src_data, BYTE *dst_data,
@ -3749,7 +3749,7 @@ struct wined3d_blitter *wined3d_cpu_blitter_create(void)
{
struct wined3d_blitter *blitter;
if (!(blitter = HeapAlloc(GetProcessHeap(), 0, sizeof(*blitter))))
if (!(blitter = heap_alloc(sizeof(*blitter))))
return NULL;
TRACE("Created blitter %p.\n", blitter);

22
dlls/wined3d/swapchain.c
View file

@ -61,7 +61,7 @@ static void swapchain_cleanup(struct wined3d_swapchain *swapchain)
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);
heap_free(swapchain->back_buffers);
swapchain->back_buffers = NULL;
}
@ -120,7 +120,7 @@ ULONG CDECL wined3d_swapchain_decref(struct wined3d_swapchain *swapchain)
swapchain_cleanup(swapchain);
swapchain->parent_ops->wined3d_object_destroyed(swapchain->parent);
HeapFree(GetProcessHeap(), 0, swapchain);
heap_free(swapchain);
}
return refcount;
@ -885,8 +885,7 @@ static HRESULT swapchain_init(struct wined3d_swapchain *swapchain, struct wined3
if (!(device->wined3d->flags & WINED3D_NO3D))
{
swapchain->context = HeapAlloc(GetProcessHeap(), 0, sizeof(*swapchain->context));
if (!swapchain->context)
if (!(swapchain->context = heap_alloc(sizeof(*swapchain->context))))
{
ERR("Failed to create the context array.\n");
hr = E_OUTOFMEMORY;
@ -905,7 +904,7 @@ static HRESULT swapchain_init(struct wined3d_swapchain *swapchain, struct wined3
if (swapchain->desc.backbuffer_count > 0)
{
if (!(swapchain->back_buffers = wined3d_calloc(swapchain->desc.backbuffer_count,
if (!(swapchain->back_buffers = heap_calloc(swapchain->desc.backbuffer_count,
sizeof(*swapchain->back_buffers))))
{
ERR("Failed to allocate backbuffer array memory.\n");
@ -987,7 +986,7 @@ err:
wined3d_texture_decref(swapchain->back_buffers[i]);
}
}
HeapFree(GetProcessHeap(), 0, swapchain->back_buffers);
heap_free(swapchain->back_buffers);
}
wined3d_cs_destroy_object(swapchain->device->cs, wined3d_swapchain_destroy_object, swapchain);
@ -1011,15 +1010,14 @@ HRESULT CDECL wined3d_swapchain_create(struct wined3d_device *device, struct win
TRACE("device %p, desc %p, parent %p, parent_ops %p, swapchain %p.\n",
device, desc, parent, parent_ops, swapchain);
object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
if (!object)
if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
hr = swapchain_init(object, device, desc, parent, parent_ops);
if (FAILED(hr))
{
WARN("Failed to initialize swapchain, hr %#x.\n", hr);
HeapFree(GetProcessHeap(), 0, object);
heap_free(object);
return hr;
}
@ -1043,14 +1041,14 @@ static struct wined3d_context *swapchain_create_context(struct wined3d_swapchain
}
context_release(ctx);
if (!(ctx_array = wined3d_calloc(swapchain->num_contexts + 1, sizeof(*ctx_array))))
if (!(ctx_array = heap_calloc(swapchain->num_contexts + 1, sizeof(*ctx_array))))
{
ERR("Out of memory when trying to allocate a new context array\n");
context_destroy(swapchain->device, ctx);
return NULL;
}
memcpy(ctx_array, swapchain->context, sizeof(*ctx_array) * swapchain->num_contexts);
HeapFree(GetProcessHeap(), 0, swapchain->context);
heap_free(swapchain->context);
ctx_array[swapchain->num_contexts] = ctx;
swapchain->context = ctx_array;
swapchain->num_contexts++;
@ -1067,7 +1065,7 @@ void swapchain_destroy_contexts(struct wined3d_swapchain *swapchain)
{
context_destroy(swapchain->device, swapchain->context[i]);
}
HeapFree(GetProcessHeap(), 0, swapchain->context);
heap_free(swapchain->context);
swapchain->num_contexts = 0;
swapchain->context = NULL;
}

26
dlls/wined3d/texture.c
View file

@ -962,7 +962,7 @@ static void wined3d_texture_cleanup_sync(struct wined3d_texture *texture)
static void wined3d_texture_destroy_object(void *object)
{
wined3d_texture_cleanup(object);
HeapFree(GetProcessHeap(), 0, object);
heap_free(object);
}
ULONG CDECL wined3d_texture_decref(struct wined3d_texture *texture)
@ -1752,7 +1752,7 @@ static void texture2d_cleanup_sub_resources(struct wined3d_texture *texture)
TRACE("Deleting renderbuffer %u.\n", entry->id);
context_gl_resource_released(device, entry->id, TRUE);
gl_info->fbo_ops.glDeleteRenderbuffers(1, &entry->id);
HeapFree(GetProcessHeap(), 0, entry);
heap_free(entry);
}
if (surface->dc)
@ -1769,7 +1769,7 @@ static void texture2d_cleanup_sub_resources(struct wined3d_texture *texture)
}
if (context)
context_release(context);
HeapFree(GetProcessHeap(), 0, texture->sub_resources[0].u.surface);
heap_free(texture->sub_resources[0].u.surface);
}
static const struct wined3d_texture_ops texture2d_ops =
@ -1854,7 +1854,7 @@ static void wined3d_texture_unload(struct wined3d_resource *resource)
context_gl_resource_released(device, entry->id, TRUE);
gl_info->fbo_ops.glDeleteRenderbuffers(1, &entry->id);
list_remove(&entry->entry);
HeapFree(GetProcessHeap(), 0, entry);
heap_free(entry);
}
list_init(&surface->renderbuffers);
surface->current_renderbuffer = NULL;
@ -2223,7 +2223,7 @@ static HRESULT texture_init(struct wined3d_texture *texture, const struct wined3
texture->resource.map_binding = WINED3D_LOCATION_BUFFER;
if (level_count > ~(SIZE_T)0 / layer_count
|| !(surfaces = wined3d_calloc(level_count * layer_count, sizeof(*surfaces))))
|| !(surfaces = heap_calloc(level_count * layer_count, sizeof(*surfaces))))
{
wined3d_texture_cleanup_sync(texture);
return E_OUTOFMEMORY;
@ -2344,7 +2344,7 @@ static void texture3d_upload_data(struct wined3d_texture *texture, unsigned int
dst_row_pitch = update_w * format->conv_byte_count;
dst_slice_pitch = dst_row_pitch * update_h;
converted_mem = wined3d_calloc(update_d, dst_slice_pitch);
converted_mem = heap_calloc(update_d, dst_slice_pitch);
format->upload(data->addr, converted_mem, row_pitch, slice_pitch,
dst_row_pitch, dst_slice_pitch, update_w, update_h, update_d);
mem = converted_mem;
@ -2372,7 +2372,7 @@ static void texture3d_upload_data(struct wined3d_texture *texture, unsigned int
checkGLcall("glBindBuffer");
}
HeapFree(GetProcessHeap(), 0, converted_mem);
heap_free(converted_mem);
}
/* Context activation is done by the caller. */
@ -2423,7 +2423,7 @@ static void texture3d_srgb_transfer(struct wined3d_texture *texture, unsigned in
* for DEFAULT pool surfaces. */
WARN_(d3d_perf)("Performing slow rgb/srgb volume transfer.\n");
data.buffer_object = 0;
if (!(data.addr = HeapAlloc(GetProcessHeap(), 0, sub_resource->size)))
if (!(data.addr = heap_alloc(sub_resource->size)))
return;
wined3d_texture_get_pitch(texture, sub_resource_idx, &row_pitch, &slice_pitch);
@ -2433,7 +2433,7 @@ static void texture3d_srgb_transfer(struct wined3d_texture *texture, unsigned in
texture3d_upload_data(texture, sub_resource_idx, context,
NULL, wined3d_const_bo_address(&data), row_pitch, slice_pitch);
HeapFree(GetProcessHeap(), 0, data.addr);
heap_free(data.addr);
}
/* Context activation is done by the caller. */
@ -2988,8 +2988,8 @@ HRESULT CDECL wined3d_texture_create(struct wined3d_device *device, const struct
}
}
if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
FIELD_OFFSET(struct wined3d_texture, sub_resources[level_count * layer_count]))))
if (!(object = heap_alloc_zero(FIELD_OFFSET(struct wined3d_texture,
sub_resources[level_count * layer_count]))))
return E_OUTOFMEMORY;
switch (desc->resource_type)
@ -3011,7 +3011,7 @@ HRESULT CDECL wined3d_texture_create(struct wined3d_device *device, const struct
if (FAILED(hr))
{
WARN("Failed to initialize texture, returning %#x.\n", hr);
HeapFree(GetProcessHeap(), 0, object);
heap_free(object);
return hr;
}
@ -3028,7 +3028,7 @@ HRESULT CDECL wined3d_texture_create(struct wined3d_device *device, const struct
{
WARN("Invalid sub-resource data specified for sub-resource %u.\n", i);
wined3d_texture_cleanup_sync(object);
HeapFree(GetProcessHeap(), 0, object);
heap_free(object);
return E_INVALIDARG;
}
}

8
dlls/wined3d/utils.c
View file

@ -1828,7 +1828,7 @@ static BOOL init_format_base_info(struct wined3d_gl_info *gl_info)
unsigned int i, j;
gl_info->format_count = WINED3D_FORMAT_COUNT;
if (!(gl_info->formats = wined3d_calloc(gl_info->format_count
if (!(gl_info->formats = heap_calloc(gl_info->format_count
+ ARRAY_SIZE(typeless_depth_stencil_formats), sizeof(*gl_info->formats))))
{
ERR("Failed to allocate memory.\n");
@ -1922,7 +1922,7 @@ static BOOL init_format_base_info(struct wined3d_gl_info *gl_info)
return TRUE;
fail:
HeapFree(GetProcessHeap(), 0, gl_info->formats);
heap_free(gl_info->formats);
return FALSE;
}
@ -3806,7 +3806,7 @@ BOOL wined3d_adapter_init_format_info(struct wined3d_adapter *adapter, struct wi
return TRUE;
fail:
HeapFree(GetProcessHeap(), 0, gl_info->formats);
heap_free(gl_info->formats);
gl_info->formats = NULL;
return FALSE;
}
@ -6159,7 +6159,7 @@ BOOL wined3d_array_reserve(void **elements, SIZE_T *capacity, SIZE_T count, SIZE
new_capacity = count;
if (!*elements)
new_elements = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, new_capacity * size);
new_elements = heap_alloc_zero(new_capacity * size);
else
new_elements = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, *elements, new_capacity * size);
if (!new_elements)

19
dlls/wined3d/vertexdeclaration.c
View file

@ -54,8 +54,8 @@ static void wined3d_vertex_declaration_destroy_object(void *object)
{
struct wined3d_vertex_declaration *declaration = object;
HeapFree(GetProcessHeap(), 0, declaration->elements);
HeapFree(GetProcessHeap(), 0, declaration);
heap_free(declaration->elements);
heap_free(declaration);
}
ULONG CDECL wined3d_vertex_declaration_decref(struct wined3d_vertex_declaration *declaration)
@ -188,7 +188,7 @@ static HRESULT vertexdeclaration_init(struct wined3d_vertex_declaration *declara
declaration->parent = parent;
declaration->parent_ops = parent_ops;
declaration->device = device;
if (!(declaration->elements = wined3d_calloc(element_count, sizeof(*declaration->elements))))
if (!(declaration->elements = heap_calloc(element_count, sizeof(*declaration->elements))))
{
ERR("Failed to allocate elements memory.\n");
return E_OUTOFMEMORY;
@ -223,7 +223,7 @@ static HRESULT vertexdeclaration_init(struct wined3d_vertex_declaration *declara
{
FIXME("The application tries to use an unsupported format (%s), returning E_FAIL.\n",
debug_d3dformat(elements[i].format));
HeapFree(GetProcessHeap(), 0, declaration->elements);
heap_free(declaration->elements);
return E_FAIL;
}
@ -247,7 +247,7 @@ static HRESULT vertexdeclaration_init(struct wined3d_vertex_declaration *declara
if (e->offset & 0x3)
{
WARN("Declaration element %u is not 4 byte aligned(%u), returning E_FAIL.\n", i, e->offset);
HeapFree(GetProcessHeap(), 0, declaration->elements);
heap_free(declaration->elements);
return E_FAIL;
}
@ -270,15 +270,14 @@ HRESULT CDECL wined3d_vertex_declaration_create(struct wined3d_device *device,
TRACE("device %p, elements %p, element_count %u, parent %p, parent_ops %p, declaration %p.\n",
device, elements, element_count, parent, parent_ops, declaration);
object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
if(!object)
if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
hr = vertexdeclaration_init(object, device, elements, element_count, parent, parent_ops);
if (FAILED(hr))
{
WARN("Failed to initialize vertex declaration, hr %#x.\n", hr);
HeapFree(GetProcessHeap(), 0, object);
heap_free(object);
return hr;
}
@ -346,7 +345,7 @@ static unsigned int convert_fvf_to_declaration(const struct wined3d_gl_info *gl_
has_psize + has_diffuse + has_specular + num_textures;
state.gl_info = gl_info;
if (!(state.elements = wined3d_calloc(size, sizeof(*state.elements))))
if (!(state.elements = heap_calloc(size, sizeof(*state.elements))))
return ~0u;
state.offset = 0;
state.idx = 0;
@ -445,6 +444,6 @@ HRESULT CDECL wined3d_vertex_declaration_create_from_fvf(struct wined3d_device *
if (size == ~0U) return E_OUTOFMEMORY;
hr = wined3d_vertex_declaration_create(device, elements, size, parent, parent_ops, declaration);
HeapFree(GetProcessHeap(), 0, elements);
heap_free(elements);
return hr;
}

18
dlls/wined3d/view.c
View file

@ -337,7 +337,7 @@ static void wined3d_rendertarget_view_destroy_object(void *object)
context_release(context);
}
HeapFree(GetProcessHeap(), 0, view);
heap_free(view);
}
ULONG CDECL wined3d_rendertarget_view_decref(struct wined3d_rendertarget_view *view)
@ -600,12 +600,12 @@ HRESULT CDECL wined3d_rendertarget_view_create(const struct wined3d_view_desc *d
TRACE("desc %p, resource %p, parent %p, parent_ops %p, view %p.\n",
desc, resource, parent, parent_ops, view);
if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
if (FAILED(hr = wined3d_rendertarget_view_init(object, desc, resource, parent, parent_ops)))
{
HeapFree(GetProcessHeap(), 0, object);
heap_free(object);
WARN("Failed to initialise view, hr %#x.\n", hr);
return hr;
}
@ -660,7 +660,7 @@ static void wined3d_shader_resource_view_destroy_object(void *object)
context_release(context);
}
HeapFree(GetProcessHeap(), 0, view);
heap_free(view);
}
ULONG CDECL wined3d_shader_resource_view_decref(struct wined3d_shader_resource_view *view)
@ -776,12 +776,12 @@ HRESULT CDECL wined3d_shader_resource_view_create(const struct wined3d_view_desc
TRACE("desc %p, resource %p, parent %p, parent_ops %p, view %p.\n",
desc, resource, parent, parent_ops, view);
if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
if (FAILED(hr = wined3d_shader_resource_view_init(object, desc, resource, parent, parent_ops)))
{
HeapFree(GetProcessHeap(), 0, object);
heap_free(object);
WARN("Failed to initialise view, hr %#x.\n", hr);
return hr;
}
@ -952,7 +952,7 @@ static void wined3d_unordered_access_view_destroy_object(void *object)
context_release(context);
}
HeapFree(GetProcessHeap(), 0, view);
heap_free(view);
}
ULONG CDECL wined3d_unordered_access_view_decref(struct wined3d_unordered_access_view *view)
@ -1144,12 +1144,12 @@ HRESULT CDECL wined3d_unordered_access_view_create(const struct wined3d_view_des
TRACE("desc %p, resource %p, parent %p, parent_ops %p, view %p.\n",
desc, resource, parent, parent_ops, view);
if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
if (FAILED(hr = wined3d_unordered_access_view_init(object, desc, resource, parent, parent_ops)))
{
HeapFree(GetProcessHeap(), 0, object);
heap_free(object);
WARN("Failed to initialise view, hr %#x.\n", hr);
return hr;
}

16
dlls/wined3d/wined3d_main.c
View file

@ -99,8 +99,7 @@ struct wined3d * CDECL wined3d_create(DWORD flags)
struct wined3d *object;
HRESULT hr;
object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, FIELD_OFFSET(struct wined3d, adapters[1]));
if (!object)
if (!(object = heap_alloc_zero(FIELD_OFFSET(struct wined3d, adapters[1]))))
{
ERR("Failed to allocate wined3d object memory.\n");
return NULL;
@ -113,7 +112,7 @@ struct wined3d * CDECL wined3d_create(DWORD flags)
if (FAILED(hr))
{
WARN("Failed to initialize wined3d object, hr %#x.\n", hr);
HeapFree(GetProcessHeap(), 0, object);
heap_free(object);
return NULL;
}
@ -281,9 +280,10 @@ static BOOL wined3d_dll_init(HINSTANCE hInstDLL)
{
size_t len = strlen(buffer) + 1;
wined3d_settings.logo = HeapAlloc(GetProcessHeap(), 0, len);
if (!wined3d_settings.logo) ERR("Failed to allocate logo path memory.\n");
else memcpy(wined3d_settings.logo, buffer, len);
if (!(wined3d_settings.logo = heap_alloc(len)))
ERR("Failed to allocate logo path memory.\n");
else
memcpy(wined3d_settings.logo, buffer, len);
}
if (!get_config_key_dword(hkey, appkey, "MultisampleTextures", &wined3d_settings.multisample_textures))
ERR_(winediag)("Setting multisample textures to %#x.\n", wined3d_settings.multisample_textures);
@ -350,9 +350,9 @@ static BOOL wined3d_dll_destroy(HINSTANCE hInstDLL)
* these entries. */
WARN("Leftover wndproc table entry %p.\n", &wndproc_table.entries[i]);
}
HeapFree(GetProcessHeap(), 0, wndproc_table.entries);
heap_free(wndproc_table.entries);
HeapFree(GetProcessHeap(), 0, wined3d_settings.logo);
heap_free(wined3d_settings.logo);
UnregisterClassA(WINED3D_OPENGL_WINDOW_CLASS_NAME, hInstDLL);
DeleteCriticalSection(&wined3d_wndproc_cs);

8
dlls/wined3d/wined3d_private.h
View file

@ -48,6 +48,7 @@
#include "winternl.h"
#include "ddk/d3dkmthk.h"
#include "wine/debug.h"
#include "wine/heap.h"
#include "wine/unicode.h"
#include "objbase.h"
@ -4294,13 +4295,6 @@ static inline BOOL wined3d_format_is_typeless(const struct wined3d_format *forma
return format->id == format->typeless_id && format->id != WINED3DFMT_UNKNOWN;
}
static inline void *wined3d_calloc(SIZE_T count, SIZE_T size)
{
if (count > ~(SIZE_T)0 / size)
return NULL;
return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, count * size);
}
static inline BOOL use_vs(const struct wined3d_state *state)
{
/* Check state->vertex_declaration to allow this to be used before the