[PATCH 5/5] d3drm: Use the global memory allocation helpers.

[Henri Verbeet]

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com>
---
 dlls/d3drm/d3drm.c         |   4 +-
 dlls/d3drm/d3drm_main.c    |  13 +++---
 dlls/d3drm/d3drm_private.h |   1 +
 dlls/d3drm/device.c        |   4 +-
 dlls/d3drm/face.c          |   4 +-
 dlls/d3drm/frame.c         |  52 +++++++++++------------
 dlls/d3drm/light.c         |   4 +-
 dlls/d3drm/material.c      |   4 +-
 dlls/d3drm/meshbuilder.c   | 103 +++++++++++++++++++++------------------------
 dlls/d3drm/texture.c       |   4 +-
 dlls/d3drm/viewport.c      |   4 +-
 11 files changed, 94 insertions(+), 103 deletions(-)

diff --git a/dlls/d3drm/d3drm.c b/dlls/d3drm/d3drm.c
index 3bc2f69..3ea1632 100644
--- a/dlls/d3drm/d3drm.c
+++ b/dlls/d3drm/d3drm.c
@@ -213,7 +213,7 @@ static inline struct d3drm *impl_from_IDirect3DRM3(IDirect3DRM3 *iface)
 
 static void d3drm_destroy(struct d3drm *d3drm)
 {
-    HeapFree(GetProcessHeap(), 0, d3drm);
+    heap_free(d3drm);
     TRACE("d3drm object %p is being destroyed.\n", d3drm);
 }
 
@@ -2308,7 +2308,7 @@ HRESULT WINAPI Direct3DRMCreate(IDirect3DRM **d3drm)
 
     TRACE("d3drm %p.\n", d3drm);
 
-    if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+    if (!(object = heap_alloc_zero(sizeof(*object))))
         return E_OUTOFMEMORY;
 
     object->IDirect3DRM_iface.lpVtbl = &d3drm1_vtbl;
diff --git a/dlls/d3drm/d3drm_main.c b/dlls/d3drm/d3drm_main.c
index 1bef534..1abfe6f 100644
--- a/dlls/d3drm/d3drm_main.c
+++ b/dlls/d3drm/d3drm_main.c
@@ -62,8 +62,7 @@ HRESULT d3drm_object_add_destroy_callback(struct d3drm_object *object, D3DRMOBJE
     if (!cb)
         return D3DRMERR_BADVALUE;
 
-    callback = HeapAlloc(GetProcessHeap(), 0, sizeof(*callback));
-    if (!callback)
+    if (!(callback = heap_alloc(sizeof(*callback))))
         return E_OUTOFMEMORY;
 
     callback->cb = cb;
@@ -85,7 +84,7 @@ HRESULT d3drm_object_delete_destroy_callback(struct d3drm_object *object, D3DRMO
         if (callback->cb == cb && callback->ctx == ctx)
         {
             list_remove(&callback->entry);
-            HeapFree(GetProcessHeap(), 0, callback);
+            heap_free(callback);
             break;
         }
     }
@@ -140,13 +139,13 @@ HRESULT d3drm_object_set_name(struct d3drm_object *object, const char *name)
 {
     DWORD req_size;
 
-    HeapFree(GetProcessHeap(), 0, object->name);
+    heap_free(object->name);
     object->name = NULL;
 
     if (name)
     {
         req_size = strlen(name) + 1;
-        if (!(object->name = HeapAlloc(GetProcessHeap(), 0, req_size)))
+        if (!(object->name = heap_alloc(req_size)))
             return E_OUTOFMEMORY;
         memcpy(object->name, name, req_size);
     }
@@ -162,9 +161,9 @@ void d3drm_object_cleanup(IDirect3DRMObject *iface, struct d3drm_object *object)
     {
         callback->cb(iface, callback->ctx);
         list_remove(&callback->entry);
-        HeapFree(GetProcessHeap(), 0, callback);
+        heap_free(callback);
     }
 
-    HeapFree(GetProcessHeap(), 0, object->name);
+    heap_free(object->name);
     object->name = NULL;
 }
diff --git a/dlls/d3drm/d3drm_private.h b/dlls/d3drm/d3drm_private.h
index 65e0016..0f24f80 100644
--- a/dlls/d3drm/d3drm_private.h
+++ b/dlls/d3drm/d3drm_private.h
@@ -30,6 +30,7 @@
 #include "d3drmwin.h"
 #include "rmxfguid.h"
 #include "wine/debug.h"
+#include "wine/heap.h"
 #include "wine/list.h"
 
 #ifndef ARRAY_SIZE
diff --git a/dlls/d3drm/device.c b/dlls/d3drm/device.c
index c537674..2aa7e48 100644
--- a/dlls/d3drm/device.c
+++ b/dlls/d3drm/device.c
@@ -61,7 +61,7 @@ void d3drm_device_destroy(struct d3drm_device *device)
         IDirectDraw_Release(device->ddraw);
         IDirect3DRM_Release(device->d3drm);
     }
-    HeapFree(GetProcessHeap(), 0, device);
+    heap_free(device);
 }
 
 static inline struct d3drm_device *impl_from_IDirect3DRMWinDevice(IDirect3DRMWinDevice *iface)
@@ -1641,7 +1641,7 @@ HRESULT d3drm_device_create(struct d3drm_device **device, IDirect3DRM *d3drm)
 
     TRACE("device %p, d3drm %p.\n", device, d3drm);
 
-    if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+    if (!(object = heap_alloc_zero(sizeof(*object))))
         return E_OUTOFMEMORY;
 
     object->IDirect3DRMDevice_iface.lpVtbl = &d3drm_device1_vtbl;
diff --git a/dlls/d3drm/face.c b/dlls/d3drm/face.c
index 95e6e58..324b1de 100644
--- a/dlls/d3drm/face.c
+++ b/dlls/d3drm/face.c
@@ -82,7 +82,7 @@ static ULONG WINAPI d3drm_face1_Release(IDirect3DRMFace *iface)
     if (!refcount)
     {
         d3drm_object_cleanup((IDirect3DRMObject *)iface, &face->obj);
-        HeapFree(GetProcessHeap(), 0, face);
+        heap_free(face);
     }
 
     return refcount;
@@ -627,7 +627,7 @@ HRESULT d3drm_face_create(struct d3drm_face **face)
 
     TRACE("face %p.\n", face);
 
-    if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+    if (!(object = heap_alloc_zero(sizeof(*object))))
         return E_OUTOFMEMORY;
 
     object->IDirect3DRMFace_iface.lpVtbl = &d3drm_face1_vtbl;
diff --git a/dlls/d3drm/frame.c b/dlls/d3drm/frame.c
index aa7633b..11105db 100644
--- a/dlls/d3drm/frame.c
+++ b/dlls/d3drm/frame.c
@@ -141,8 +141,8 @@ static ULONG WINAPI d3drm_frame_array_Release(IDirect3DRMFrameArray *iface)
         {
             IDirect3DRMFrame_Release(array->frames[i]);
         }
-        HeapFree(GetProcessHeap(), 0, array->frames);
-        HeapFree(GetProcessHeap(), 0, array);
+        heap_free(array->frames);
+        heap_free(array);
     }
 
     return refcount;
@@ -193,7 +193,7 @@ static struct d3drm_frame_array *d3drm_frame_array_create(unsigned int frame_cou
     struct d3drm_frame_array *array;
     unsigned int i;
 
-    if (!(array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*array))))
+    if (!(array = heap_alloc_zero(sizeof(*array))))
         return NULL;
 
     array->IDirect3DRMFrameArray_iface.lpVtbl = &d3drm_frame_array_vtbl;
@@ -202,9 +202,9 @@ static struct d3drm_frame_array *d3drm_frame_array_create(unsigned int frame_cou
 
     if (frame_count)
     {
-        if (!(array->frames = HeapAlloc(GetProcessHeap(), 0, frame_count * sizeof(*array->frames))))
+        if (!(array->frames = heap_calloc(frame_count, sizeof(*array->frames))))
         {
-            HeapFree(GetProcessHeap(), 0, array);
+            heap_free(array);
             return NULL;
         }
 
@@ -259,8 +259,8 @@ static ULONG WINAPI d3drm_visual_array_Release(IDirect3DRMVisualArray *iface)
         {
             IDirect3DRMVisual_Release(array->visuals[i]);
         }
-        HeapFree(GetProcessHeap(), 0, array->visuals);
-        HeapFree(GetProcessHeap(), 0, array);
+        heap_free(array->visuals);
+        heap_free(array);
     }
 
     return refcount;
@@ -311,7 +311,7 @@ static struct d3drm_visual_array *d3drm_visual_array_create(unsigned int visual_
     struct d3drm_visual_array *array;
     unsigned int i;
 
-    if (!(array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*array))))
+    if (!(array = heap_alloc_zero(sizeof(*array))))
         return NULL;
 
     array->IDirect3DRMVisualArray_iface.lpVtbl = &d3drm_visual_array_vtbl;
@@ -320,9 +320,9 @@ static struct d3drm_visual_array *d3drm_visual_array_create(unsigned int visual_
 
     if (visual_count)
     {
-        if (!(array->visuals = HeapAlloc(GetProcessHeap(), 0, visual_count * sizeof(*array->visuals))))
+        if (!(array->visuals = heap_calloc(visual_count, sizeof(*array->visuals))))
         {
-            HeapFree(GetProcessHeap(), 0, array);
+            heap_free(array);
             return NULL;
         }
 
@@ -378,8 +378,8 @@ static ULONG WINAPI d3drm_light_array_Release(IDirect3DRMLightArray *iface)
         {
             IDirect3DRMLight_Release(array->lights[i]);
         }
-        HeapFree(GetProcessHeap(), 0, array->lights);
-        HeapFree(GetProcessHeap(), 0, array);
+        heap_free(array->lights);
+        heap_free(array);
     }
 
     return refcount;
@@ -430,7 +430,7 @@ static struct d3drm_light_array *d3drm_light_array_create(unsigned int light_cou
     struct d3drm_light_array *array;
     unsigned int i;
 
-    if (!(array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*array))))
+    if (!(array = heap_alloc_zero(sizeof(*array))))
         return NULL;
 
     array->IDirect3DRMLightArray_iface.lpVtbl = &d3drm_light_array_vtbl;
@@ -439,9 +439,9 @@ static struct d3drm_light_array *d3drm_light_array_create(unsigned int light_cou
 
     if (light_count)
     {
-        if (!(array->lights = HeapAlloc(GetProcessHeap(), 0, light_count * sizeof(*array->lights))))
+        if (!(array->lights = heap_calloc(light_count, sizeof(*array->lights))))
         {
-            HeapFree(GetProcessHeap(), 0, array);
+            heap_free(array);
             return NULL;
         }
 
@@ -548,19 +548,19 @@ static ULONG WINAPI d3drm_frame3_Release(IDirect3DRMFrame3 *iface)
         {
             IDirect3DRMFrame3_Release(frame->children[i]);
         }
-        HeapFree(GetProcessHeap(), 0, frame->children);
+        heap_free(frame->children);
         for (i = 0; i < frame->nb_visuals; ++i)
         {
             IDirect3DRMVisual_Release(frame->visuals[i]);
         }
-        HeapFree(GetProcessHeap(), 0, frame->visuals);
+        heap_free(frame->visuals);
         for (i = 0; i < frame->nb_lights; ++i)
         {
             IDirect3DRMLight_Release(frame->lights[i]);
         }
-        HeapFree(GetProcessHeap(), 0, frame->lights);
+        heap_free(frame->lights);
         IDirect3DRM_Release(frame->d3drm);
-        HeapFree(GetProcessHeap(), 0, frame);
+        heap_free(frame);
     }
 
     return refcount;
@@ -2940,7 +2940,7 @@ HRESULT d3drm_frame_create(struct d3drm_frame **frame, IUnknown *parent_frame, I
 
     TRACE("frame %p, parent_frame %p, d3drm %p.\n", frame, parent_frame, d3drm);
 
-    if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+    if (!(object = heap_alloc_zero(sizeof(*object))))
         return E_OUTOFMEMORY;
 
     object->IDirect3DRMFrame_iface.lpVtbl = &d3drm_frame1_vtbl;
@@ -2961,7 +2961,7 @@ HRESULT d3drm_frame_create(struct d3drm_frame **frame, IUnknown *parent_frame, I
 
         if (FAILED(hr = IDirect3DRMFrame_QueryInterface(parent_frame, &IID_IDirect3DRMFrame3, (void **)&p)))
         {
-            HeapFree(GetProcessHeap(), 0, object);
+            heap_free(object);
             return hr;
         }
         IDirect3DRMFrame_Release(parent_frame);
@@ -3038,10 +3038,10 @@ static ULONG WINAPI d3drm_animation2_Release(IDirect3DRMAnimation2 *iface)
     {
         d3drm_object_cleanup((IDirect3DRMObject *)&animation->IDirect3DRMAnimation_iface, &animation->obj);
         IDirect3DRM_Release(animation->d3drm);
-        HeapFree(GetProcessHeap(), 0, animation->rotate.keys);
-        HeapFree(GetProcessHeap(), 0, animation->scale.keys);
-        HeapFree(GetProcessHeap(), 0, animation->position.keys);
-        HeapFree(GetProcessHeap(), 0, animation);
+        heap_free(animation->rotate.keys);
+        heap_free(animation->scale.keys);
+        heap_free(animation->position.keys);
+        heap_free(animation);
     }
 
     return refcount;
@@ -3692,7 +3692,7 @@ HRESULT d3drm_animation_create(struct d3drm_animation **animation, IDirect3DRM *
 
     TRACE("animation %p, d3drm %p.\n", animation, d3drm);
 
-    if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+    if (!(object = heap_alloc_zero(sizeof(*object))))
         return E_OUTOFMEMORY;
 
     object->IDirect3DRMAnimation_iface.lpVtbl = &d3drm_animation1_vtbl;
diff --git a/dlls/d3drm/light.c b/dlls/d3drm/light.c
index 855209f..e31c026 100644
--- a/dlls/d3drm/light.c
+++ b/dlls/d3drm/light.c
@@ -70,7 +70,7 @@ static ULONG WINAPI d3drm_light_Release(IDirect3DRMLight *iface)
     {
         d3drm_object_cleanup((IDirect3DRMObject *)iface, &light->obj);
         IDirect3DRM_Release(light->d3drm);
-        HeapFree(GetProcessHeap(), 0, light);
+        heap_free(light);
     }
 
     return refcount;
@@ -378,7 +378,7 @@ HRESULT d3drm_light_create(struct d3drm_light **light, IDirect3DRM *d3drm)
 
     TRACE("light %p.\n", light);
 
-    if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+    if (!(object = heap_alloc_zero(sizeof(*object))))
         return E_OUTOFMEMORY;
 
     object->IDirect3DRMLight_iface.lpVtbl = &d3drm_light_vtbl;
diff --git a/dlls/d3drm/material.c b/dlls/d3drm/material.c
index d13b0dd..62acb5a 100644
--- a/dlls/d3drm/material.c
+++ b/dlls/d3drm/material.c
@@ -71,7 +71,7 @@ static ULONG WINAPI d3drm_material_Release(IDirect3DRMMaterial2 *iface)
     {
         d3drm_object_cleanup((IDirect3DRMObject *)iface, &material->obj);
         IDirect3DRM_Release(material->d3drm);
-        HeapFree(GetProcessHeap(), 0, material);
+        heap_free(material);
     }
 
     return refcount;
@@ -286,7 +286,7 @@ HRESULT d3drm_material_create(struct d3drm_material **material, IDirect3DRM *d3d
 
     TRACE("material %p, d3drm %p.\n", material, d3drm);
 
-    if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+    if (!(object = heap_alloc_zero(sizeof(*object))))
         return E_OUTOFMEMORY;
 
     object->IDirect3DRMMaterial2_iface.lpVtbl = &d3drm_material_vtbl;
diff --git a/dlls/d3drm/meshbuilder.c b/dlls/d3drm/meshbuilder.c
index c95cb46..0090555 100644
--- a/dlls/d3drm/meshbuilder.c
+++ b/dlls/d3drm/meshbuilder.c
@@ -279,12 +279,7 @@ BOOL d3drm_array_reserve(void **elements, SIZE_T *capacity, SIZE_T element_count
     if (new_capacity < element_count)
         new_capacity = max_capacity;
 
-    if (*elements)
-        new_elements = HeapReAlloc(GetProcessHeap(), 0, *elements, new_capacity * element_size);
-    else
-        new_elements = HeapAlloc(GetProcessHeap(), 0, new_capacity * element_size);
-
-    if (!new_elements)
+    if (!(new_elements = heap_realloc(*elements, new_capacity * element_size)))
         return FALSE;
 
     *elements = new_elements;
@@ -317,19 +312,19 @@ static void clean_mesh_builder_data(struct d3drm_mesh_builder *mesh_builder)
     DWORD i;
 
     IDirect3DRMMeshBuilder3_SetName(&mesh_builder->IDirect3DRMMeshBuilder3_iface, NULL);
-    HeapFree(GetProcessHeap(), 0, mesh_builder->vertices);
+    heap_free(mesh_builder->vertices);
     mesh_builder->vertices = NULL;
     mesh_builder->nb_vertices = 0;
     mesh_builder->vertices_size = 0;
-    HeapFree(GetProcessHeap(), 0, mesh_builder->normals);
+    heap_free(mesh_builder->normals);
     mesh_builder->normals = NULL;
     mesh_builder->nb_normals = 0;
     mesh_builder->normals_size = 0;
-    HeapFree(GetProcessHeap(), 0, mesh_builder->pFaceData);
+    heap_free(mesh_builder->pFaceData);
     mesh_builder->pFaceData = NULL;
     mesh_builder->face_data_size = 0;
     mesh_builder->nb_faces = 0;
-    HeapFree(GetProcessHeap(), 0, mesh_builder->pCoords2d);
+    heap_free(mesh_builder->pCoords2d);
     mesh_builder->pCoords2d = NULL;
     mesh_builder->nb_coords2d = 0;
     for (i = 0; i < mesh_builder->nb_materials; i++)
@@ -340,9 +335,9 @@ static void clean_mesh_builder_data(struct d3drm_mesh_builder *mesh_builder)
             IDirect3DRMTexture3_Release(mesh_builder->materials[i].texture);
     }
     mesh_builder->nb_materials = 0;
-    HeapFree(GetProcessHeap(), 0, mesh_builder->materials);
+    heap_free(mesh_builder->materials);
     mesh_builder->materials = NULL;
-    HeapFree(GetProcessHeap(), 0, mesh_builder->material_indices);
+    heap_free(mesh_builder->material_indices);
     mesh_builder->material_indices = NULL;
 }
 
@@ -401,7 +396,7 @@ static ULONG WINAPI d3drm_mesh_builder2_Release(IDirect3DRMMeshBuilder2 *iface)
         if (mesh_builder->texture)
             IDirect3DRMTexture3_Release(mesh_builder->texture);
         IDirect3DRM_Release(mesh_builder->d3drm);
-        HeapFree(GetProcessHeap(), 0, mesh_builder);
+        heap_free(mesh_builder);
     }
 
     return refcount;
@@ -1050,13 +1045,14 @@ HRESULT load_mesh_data(IDirect3DRMMeshBuilder3 *iface, IDirectXFileData *pData,
         return hr;
     if (size)
     {
-        char *name = HeapAlloc(GetProcessHeap(), 0, size);
-        if (!name)
+        char *name;
+
+        if (!(name = heap_alloc(size)))
             return E_OUTOFMEMORY;
 
         if (SUCCEEDED(hr = IDirectXFileData_GetName(pData, name, &size)))
             IDirect3DRMMeshBuilder3_SetName(iface, name);
-        HeapFree(GetProcessHeap(), 0, name);
+        heap_free(name);
         if (hr != DXFILE_OK)
             return hr;
     }
@@ -1084,12 +1080,12 @@ HRESULT load_mesh_data(IDirect3DRMMeshBuilder3 *iface, IDirectXFileData *pData,
     }
     memcpy(mesh_builder->vertices, ptr + sizeof(DWORD), mesh_builder->nb_vertices * sizeof(D3DVECTOR));
 
-    faces_vertex_idx_ptr = faces_vertex_idx_data = HeapAlloc(GetProcessHeap(), 0, faces_vertex_idx_size);
+    faces_vertex_idx_ptr = faces_vertex_idx_data = heap_alloc(faces_vertex_idx_size);
     memcpy(faces_vertex_idx_data, ptr + sizeof(DWORD) + mesh_builder->nb_vertices * sizeof(D3DVECTOR) + sizeof(DWORD),
             faces_vertex_idx_size);
 
     /* Each vertex index will have its normal index counterpart so just allocate twice the size */
-    mesh_builder->pFaceData = HeapAlloc(GetProcessHeap(), 0, faces_vertex_idx_size * 2);
+    mesh_builder->pFaceData = heap_alloc(faces_vertex_idx_size * 2);
     faces_data_ptr = (DWORD*)mesh_builder->pFaceData;
 
     while (1)
@@ -1141,8 +1137,9 @@ HRESULT load_mesh_data(IDirect3DRMMeshBuilder3 *iface, IDirectXFileData *pData,
             memcpy(mesh_builder->normals, ptr + sizeof(DWORD), mesh_builder->nb_normals * sizeof(D3DVECTOR));
 
             faces_normal_idx_size = size - (2 * sizeof(DWORD) + mesh_builder->nb_normals * sizeof(D3DVECTOR));
-            faces_normal_idx_ptr = faces_normal_idx_data = HeapAlloc(GetProcessHeap(), 0, faces_normal_idx_size);
-            memcpy(faces_normal_idx_data, ptr + sizeof(DWORD) + mesh_builder->nb_normals * sizeof(D3DVECTOR) + sizeof(DWORD), faces_normal_idx_size);
+            faces_normal_idx_ptr = faces_normal_idx_data = heap_alloc(faces_normal_idx_size);
+            memcpy(faces_normal_idx_data, ptr + sizeof(DWORD) + mesh_builder->nb_normals * sizeof(D3DVECTOR)
+                    + sizeof(DWORD), faces_normal_idx_size);
         }
         else if (IsEqualGUID(guid, &TID_D3DRMMeshTextureCoords))
         {
@@ -1154,7 +1151,7 @@ HRESULT load_mesh_data(IDirect3DRMMeshBuilder3 *iface, IDirectXFileData *pData,
 
             TRACE("MeshTextureCoords: nb_coords2d = %d\n", mesh_builder->nb_coords2d);
 
-            mesh_builder->pCoords2d = HeapAlloc(GetProcessHeap(), 0, mesh_builder->nb_coords2d * sizeof(*mesh_builder->pCoords2d));
+            mesh_builder->pCoords2d = heap_calloc(mesh_builder->nb_coords2d, sizeof(*mesh_builder->pCoords2d));
             memcpy(mesh_builder->pCoords2d, ptr + sizeof(DWORD), mesh_builder->nb_coords2d * sizeof(*mesh_builder->pCoords2d));
         }
         else if (IsEqualGUID(guid, &TID_D3DRMMeshMaterialList))
@@ -1182,15 +1179,15 @@ HRESULT load_mesh_data(IDirect3DRMMeshBuilder3 *iface, IDirectXFileData *pData,
             if (size != data_size)
                 WARN("Returned size %u does not match expected one %u\n", size, data_size);
 
-            mesh_builder->material_indices = HeapAlloc(GetProcessHeap(), 0, sizeof(*mesh_builder->material_indices) * nb_face_indices);
-            if (!mesh_builder->material_indices)
+            if (!(mesh_builder->material_indices = heap_calloc(nb_face_indices,
+                    sizeof(*mesh_builder->material_indices))))
                 goto end;
-            memcpy(mesh_builder->material_indices, ptr + 2 * sizeof(DWORD), sizeof(*mesh_builder->material_indices) * nb_face_indices),
+            memcpy(mesh_builder->material_indices, ptr + 2 * sizeof(DWORD),
+                    nb_face_indices * sizeof(*mesh_builder->material_indices));
 
-            mesh_builder->materials = HeapAlloc(GetProcessHeap(), 0, sizeof(*mesh_builder->materials) * nb_materials);
-            if (!mesh_builder->materials)
+            if (!(mesh_builder->materials = heap_calloc(nb_materials, sizeof(*mesh_builder->materials))))
             {
-                HeapFree(GetProcessHeap(), 0, mesh_builder->material_indices);
+                heap_free(mesh_builder->material_indices);
                 goto end;
             }
             mesh_builder->nb_materials = nb_materials;
@@ -1442,8 +1439,8 @@ HRESULT load_mesh_data(IDirect3DRMMeshBuilder3 *iface, IDirectXFileData *pData,
     if (!mesh_builder->pCoords2d)
     {
         mesh_builder->nb_coords2d = mesh_builder->nb_vertices;
-        mesh_builder->pCoords2d = HeapAlloc(GetProcessHeap(), 0, mesh_builder->nb_coords2d * sizeof(*mesh_builder->pCoords2d));
-        for (i = 0; i < mesh_builder->nb_coords2d; i++)
+        mesh_builder->pCoords2d = heap_calloc(mesh_builder->nb_coords2d, sizeof(*mesh_builder->pCoords2d));
+        for (i = 0; i < mesh_builder->nb_coords2d; ++i)
         {
             mesh_builder->pCoords2d[i].u = 0.0f;
             mesh_builder->pCoords2d[i].v = 0.0f;
@@ -1456,8 +1453,8 @@ HRESULT load_mesh_data(IDirect3DRMMeshBuilder3 *iface, IDirectXFileData *pData,
 
 end:
 
-    HeapFree(GetProcessHeap(), 0, faces_normal_idx_data);
-    HeapFree(GetProcessHeap(), 0, faces_vertex_idx_data);
+    heap_free(faces_normal_idx_data);
+    heap_free(faces_vertex_idx_data);
 
     return ret;
 }
@@ -1970,8 +1967,7 @@ static HRESULT WINAPI d3drm_mesh_builder3_CreateMesh(IDirect3DRMMeshBuilder3 *if
         int k;
         D3DRMVERTEX* vertices;
 
-        vertices = HeapAlloc(GetProcessHeap(), 0, mesh_builder->nb_vertices * sizeof(D3DRMVERTEX));
-        if (!vertices)
+        if (!(vertices = heap_calloc(mesh_builder->nb_vertices, sizeof(*vertices))))
         {
             IDirect3DRMMesh_Release(*mesh);
             return E_OUTOFMEMORY;
@@ -1979,7 +1975,7 @@ static HRESULT WINAPI d3drm_mesh_builder3_CreateMesh(IDirect3DRMMeshBuilder3 *if
         for (i = 0; i < mesh_builder->nb_vertices; i++)
             vertices[i].position = mesh_builder->vertices[i];
         hr = IDirect3DRMMesh_SetVertices(*mesh, 0, 0, mesh_builder->nb_vertices, vertices);
-        HeapFree(GetProcessHeap(), 0, vertices);
+        heap_free(vertices);
 
         /* Groups are in reverse order compared to materials list in X file */
         for (k = mesh_builder->nb_materials - 1; k >= 0; k--)
@@ -1992,17 +1988,15 @@ static HRESULT WINAPI d3drm_mesh_builder3_CreateMesh(IDirect3DRMMeshBuilder3 *if
             unsigned nb_vertices = 0;
             unsigned nb_faces = 0;
 
-            used_vertices = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, mesh_builder->face_data_size * sizeof(*used_vertices));
-            if (!used_vertices)
+            if (!(used_vertices = heap_calloc(mesh_builder->face_data_size, sizeof(*used_vertices))))
             {
                 IDirect3DRMMesh_Release(*mesh);
                 return E_OUTOFMEMORY;
             }
 
-            face_data = HeapAlloc(GetProcessHeap(), 0, mesh_builder->face_data_size * sizeof(*face_data));
-            if (!face_data)
+            if (!(face_data = heap_calloc(mesh_builder->face_data_size, sizeof(*face_data))))
             {
-                HeapFree(GetProcessHeap(), 0, used_vertices);
+                heap_free(used_vertices);
                 IDirect3DRMMesh_Release(*mesh);
                 return E_OUTOFMEMORY;
             }
@@ -2056,8 +2050,8 @@ static HRESULT WINAPI d3drm_mesh_builder3_CreateMesh(IDirect3DRMMeshBuilder3 *if
                     nb_vertices++;
 
             hr = IDirect3DRMMesh_AddGroup(*mesh, nb_vertices, nb_faces, vertex_per_face, face_data, &group);
-            HeapFree(GetProcessHeap(), 0, used_vertices);
-            HeapFree(GetProcessHeap(), 0, face_data);
+            heap_free(used_vertices);
+            heap_free(face_data);
             if (SUCCEEDED(hr))
                 hr = IDirect3DRMMesh_SetGroupColor(*mesh, group, mesh_builder->materials[k].color);
             if (SUCCEEDED(hr))
@@ -2347,7 +2341,7 @@ HRESULT d3drm_mesh_builder_create(struct d3drm_mesh_builder **mesh_builder, IDir
 
     TRACE("mesh_builder %p.\n", mesh_builder);
 
-    if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+    if (!(object = heap_alloc_zero(sizeof(*object))))
         return E_OUTOFMEMORY;
 
     object->IDirect3DRMMeshBuilder2_iface.lpVtbl = &d3drm_mesh_builder2_vtbl;
@@ -2408,15 +2402,15 @@ static ULONG WINAPI d3drm_mesh_Release(IDirect3DRMMesh *iface)
         IDirect3DRM_Release(mesh->d3drm);
         for (i = 0; i < mesh->nb_groups; ++i)
         {
-            HeapFree(GetProcessHeap(), 0, mesh->groups[i].vertices);
-            HeapFree(GetProcessHeap(), 0, mesh->groups[i].face_data);
+            heap_free(mesh->groups[i].vertices);
+            heap_free(mesh->groups[i].face_data);
             if (mesh->groups[i].material)
                 IDirect3DRMMaterial2_Release(mesh->groups[i].material);
             if (mesh->groups[i].texture)
                 IDirect3DRMTexture3_Release(mesh->groups[i].texture);
         }
-        HeapFree(GetProcessHeap(), 0, mesh->groups);
-        HeapFree(GetProcessHeap(), 0, mesh);
+        heap_free(mesh->groups);
+        heap_free(mesh);
     }
 
     return refcount;
@@ -2537,8 +2531,7 @@ static HRESULT WINAPI d3drm_mesh_AddGroup(IDirect3DRMMesh *iface, unsigned verte
 
     group = mesh->groups + mesh->nb_groups;
 
-    group->vertices = HeapAlloc(GetProcessHeap(), 0, vertex_count * sizeof(D3DRMVERTEX));
-    if (!group->vertices)
+    if (!(group->vertices = heap_calloc(vertex_count, sizeof(*group->vertices))))
         return E_OUTOFMEMORY;
     group->nb_vertices = vertex_count;
     group->nb_faces = face_count;
@@ -2563,14 +2556,12 @@ static HRESULT WINAPI d3drm_mesh_AddGroup(IDirect3DRMMesh *iface, unsigned verte
         }
     }
 
-    group->face_data = HeapAlloc(GetProcessHeap(), 0, group->face_data_size * sizeof(unsigned));
-    if (!group->face_data)
+    if (!(group->face_data = heap_calloc(group->face_data_size, sizeof(*group->face_data))))
     {
-        HeapFree(GetProcessHeap(), 0 , group->vertices);
+        heap_free(group->vertices);
         return E_OUTOFMEMORY;
     }
-
-    memcpy(group->face_data, face_data, group->face_data_size * sizeof(unsigned));
+    memcpy(group->face_data, face_data, group->face_data_size * sizeof(*face_data));
 
     group->material = NULL;
     group->texture = NULL;
@@ -2849,7 +2840,7 @@ HRESULT d3drm_mesh_create(struct d3drm_mesh **mesh, IDirect3DRM *d3drm)
 
     TRACE("mesh %p, d3drm %p.\n", mesh, d3drm);
 
-    if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+    if (!(object = heap_alloc_zero(sizeof(*object))))
         return E_OUTOFMEMORY;
 
     object->IDirect3DRMMesh_iface.lpVtbl = &d3drm_mesh_vtbl;
@@ -2903,7 +2894,7 @@ static ULONG WINAPI d3drm_wrap_Release(IDirect3DRMWrap *iface)
     if (!refcount)
     {
         d3drm_object_cleanup((IDirect3DRMObject *)iface, &wrap->obj);
-        HeapFree(GetProcessHeap(), 0, wrap);
+        heap_free(wrap);
     }
 
     return refcount;
@@ -3035,7 +3026,7 @@ HRESULT d3drm_wrap_create(struct d3drm_wrap **wrap, IDirect3DRM *d3drm)
 
     TRACE("wrap %p, d3drm %p.\n", wrap, d3drm);
 
-    if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+    if (!(object = heap_alloc_zero(sizeof(*object))))
         return E_OUTOFMEMORY;
 
     object->IDirect3DRMWrap_iface.lpVtbl = &d3drm_wrap_vtbl;
diff --git a/dlls/d3drm/texture.c b/dlls/d3drm/texture.c
index d03fee7..fd56e76 100644
--- a/dlls/d3drm/texture.c
+++ b/dlls/d3drm/texture.c
@@ -49,7 +49,7 @@ static void d3drm_texture_destroy(struct d3drm_texture *texture)
         IDirect3DRM_Release(texture->d3drm);
     if (texture->surface)
         IDirectDrawSurface_Release(texture->surface);
-    HeapFree(GetProcessHeap(), 0, texture);
+    heap_free(texture);
 }
 
 static BOOL d3drm_validate_image(D3DRMIMAGE *image)
@@ -1119,7 +1119,7 @@ HRESULT d3drm_texture_create(struct d3drm_texture **texture, IDirect3DRM *d3drm)
 
     TRACE("texture %p.\n", texture);
 
-    if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+    if (!(object = heap_alloc_zero(sizeof(*object))))
         return E_OUTOFMEMORY;
 
     object->IDirect3DRMTexture_iface.lpVtbl = &d3drm_texture1_vtbl;
diff --git a/dlls/d3drm/viewport.c b/dlls/d3drm/viewport.c
index a85d00f..37c70c8 100644
--- a/dlls/d3drm/viewport.c
+++ b/dlls/d3drm/viewport.c
@@ -75,7 +75,7 @@ static void d3drm_viewport_destroy(struct d3drm_viewport *viewport)
         IDirect3DRM_Release(viewport->d3drm);
     }
 
-    HeapFree(GetProcessHeap(), 0, viewport);
+    heap_free(viewport);
 }
 
 static HRESULT WINAPI d3drm_viewport2_QueryInterface(IDirect3DRMViewport2 *iface, REFIID riid, void **out)
@@ -1022,7 +1022,7 @@ HRESULT d3drm_viewport_create(struct d3drm_viewport **viewport, IDirect3DRM *d3d
 
     TRACE("viewport %p, d3drm %p.\n", viewport, d3drm);
 
-    if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+    if (!(object = heap_alloc_zero(sizeof(*object))))
         return E_OUTOFMEMORY;
 
     object->IDirect3DRMViewport_iface.lpVtbl = &d3drm_viewport1_vtbl;
-- 
2.1.4