Signed-off-by: Henri Verbeet hverbeet@codeweavers.com --- dlls/wined3d/arb_program_shader.c | 136 ++++++++++++++++++----------------- dlls/wined3d/ati_fragment_shader.c | 18 ++--- dlls/wined3d/buffer.c | 29 ++++---- dlls/wined3d/context.c | 68 +++++++++--------- dlls/wined3d/cs.c | 32 ++++----- dlls/wined3d/device.c | 42 +++++------ dlls/wined3d/directx.c | 37 +++++----- dlls/wined3d/glsl_shader.c | 144 ++++++++++++++++++------------------- dlls/wined3d/palette.c | 7 +- dlls/wined3d/query.c | 32 ++++----- dlls/wined3d/resource.c | 4 +- dlls/wined3d/sampler.c | 4 +- dlls/wined3d/shader.c | 138 ++++++++++++++++++----------------- dlls/wined3d/shader_sm1.c | 6 +- dlls/wined3d/shader_sm4.c | 8 +-- dlls/wined3d/state.c | 23 +++--- dlls/wined3d/stateblock.c | 11 ++- dlls/wined3d/surface.c | 36 +++++----- dlls/wined3d/swapchain.c | 22 +++--- dlls/wined3d/texture.c | 26 +++---- dlls/wined3d/utils.c | 8 +-- dlls/wined3d/vertexdeclaration.c | 19 +++-- dlls/wined3d/view.c | 18 ++--- dlls/wined3d/wined3d_main.c | 16 ++--- dlls/wined3d/wined3d_private.h | 8 +-- 25 files changed, 439 insertions(+), 453 deletions(-)
diff --git a/dlls/wined3d/arb_program_shader.c b/dlls/wined3d/arb_program_shader.c index a8c4abb..0d21f24 100644 --- a/dlls/wined3d/arb_program_shader.c +++ b/dlls/wined3d/arb_program_shader.c @@ -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(©); - 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; diff --git a/dlls/wined3d/ati_fragment_shader.c b/dlls/wined3d/ati_fragment_shader.c index 2fd94bc..9d6837a 100644 --- a/dlls/wined3d/ati_fragment_shader.c +++ b/dlls/wined3d/ati_fragment_shader.c @@ -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 = { diff --git a/dlls/wined3d/buffer.c b/dlls/wined3d/buffer.c index f907ece..c1dfc56 100644 --- a/dlls/wined3d/buffer.c +++ b/dlls/wined3d/buffer.c @@ -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; diff --git a/dlls/wined3d/context.c b/dlls/wined3d/context.c index e3e4834..8c2ea86 100644 --- a/dlls/wined3d/context.c +++ b/dlls/wined3d/context.c @@ -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, diff --git a/dlls/wined3d/cs.c b/dlls/wined3d/cs.c index ed249f4..2f77c7b 100644 --- a/dlls/wined3d/cs.c +++ b/dlls/wined3d/cs.c @@ -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); } diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c index 3961f55..e412272 100644 --- a/dlls/wined3d/device.c +++ b/dlls/wined3d/device.c @@ -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); diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index 924cc72..a1e679b 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -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, ¤t_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; }
diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c index 6f59cf1..6cc030a 100644 --- a/dlls/wined3d/glsl_shader.c +++ b/dlls/wined3d/glsl_shader.c @@ -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. */ diff --git a/dlls/wined3d/palette.c b/dlls/wined3d/palette.c index ed77604..2436100 100644 --- a/dlls/wined3d/palette.c +++ b/dlls/wined3d/palette.c @@ -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; }
diff --git a/dlls/wined3d/query.c b/dlls/wined3d/query.c index 1bdaaf0..9828fc2 100644 --- a/dlls/wined3d/query.c +++ b/dlls/wined3d/query.c @@ -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, diff --git a/dlls/wined3d/resource.c b/dlls/wined3d/resource.c index 76f877cb..22c2f48 100644 --- a/dlls/wined3d/resource.c +++ b/dlls/wined3d/resource.c @@ -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; }
diff --git a/dlls/wined3d/sampler.c b/dlls/wined3d/sampler.c index 8c8d24c..82fbe2c 100644 --- a/dlls/wined3d/sampler.c +++ b/dlls/wined3d/sampler.c @@ -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); diff --git a/dlls/wined3d/shader.c b/dlls/wined3d/shader.c index 424025c..66e1bbf 100644 --- a/dlls/wined3d/shader.c +++ b/dlls/wined3d/shader.c @@ -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, ®_maps->indexable_temps, struct wined3d_shader_indexable_temp, entry) - HeapFree(GetProcessHeap(), 0, reg); + heap_free(reg); list_init(®_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; }
diff --git a/dlls/wined3d/shader_sm1.c b/dlls/wined3d/shader_sm1.c index 40c9e79..0c6bb93 100644 --- a/dlls/wined3d/shader_sm1.c +++ b/dlls/wined3d/shader_sm1.c @@ -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) diff --git a/dlls/wined3d/shader_sm4.c b/dlls/wined3d/shader_sm4.c index 3963cbc..8eac746 100644 --- a/dlls/wined3d/shader_sm4.c +++ b/dlls/wined3d/shader_sm4.c @@ -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; } diff --git a/dlls/wined3d/state.c b/dlls/wined3d/state.c index aa1a2ae..407ad62 100644 --- a/dlls/wined3d/state.c +++ b/dlls/wined3d/state.c @@ -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)); diff --git a/dlls/wined3d/stateblock.c b/dlls/wined3d/stateblock.c index 9d61360..4c28eb5 100644 --- a/dlls/wined3d/stateblock.c +++ b/dlls/wined3d/stateblock.c @@ -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; }
diff --git a/dlls/wined3d/surface.c b/dlls/wined3d/surface.c index 00bc4e4..1f5a98a 100644 --- a/dlls/wined3d/surface.c +++ b/dlls/wined3d/surface.c @@ -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); diff --git a/dlls/wined3d/swapchain.c b/dlls/wined3d/swapchain.c index fb89099..c20a692 100644 --- a/dlls/wined3d/swapchain.c +++ b/dlls/wined3d/swapchain.c @@ -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; } diff --git a/dlls/wined3d/texture.c b/dlls/wined3d/texture.c index dd6a2dd..029b042 100644 --- a/dlls/wined3d/texture.c +++ b/dlls/wined3d/texture.c @@ -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; } } diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index 960909f..5d97bc8 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -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) diff --git a/dlls/wined3d/vertexdeclaration.c b/dlls/wined3d/vertexdeclaration.c index 4fa6d54..3d1518d 100644 --- a/dlls/wined3d/vertexdeclaration.c +++ b/dlls/wined3d/vertexdeclaration.c @@ -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; } diff --git a/dlls/wined3d/view.c b/dlls/wined3d/view.c index b06dacc..05167f4 100644 --- a/dlls/wined3d/view.c +++ b/dlls/wined3d/view.c @@ -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; } diff --git a/dlls/wined3d/wined3d_main.c b/dlls/wined3d/wined3d_main.c index d3d3f2d..814a78a 100644 --- a/dlls/wined3d/wined3d_main.c +++ b/dlls/wined3d/wined3d_main.c @@ -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); diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 8201536..5065731 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -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
-
Henri Verbeet