alice.mosphere.at / sdl-gpu
this repo has no description
0
fork

Configure Feed

Select the types of activity you want to include in your feed.

Redefined malloc and free (as SDL_malloc and SDL_free) for stb-image so that I can safely let SDL handle the pixel memory. Also replaced all internal mallocs and frees in SDL_gpu for consistency.

grimfang4@gmail.com 58e07309 162dfb4c

+119 -98
+14 -14
src/SDL_gpu.c
··· 218 218 if(_gpu_error_code_stack == NULL) 219 219 { 220 220 unsigned int i; 221 - _gpu_error_code_stack = (GPU_ErrorObject*)malloc(sizeof(GPU_ErrorObject)*_gpu_error_code_stack_size); 221 + _gpu_error_code_stack = (GPU_ErrorObject*)SDL_malloc(sizeof(GPU_ErrorObject)*_gpu_error_code_stack_size); 222 222 223 223 for(i = 0; i < _gpu_error_code_stack_size; i++) 224 224 { 225 - _gpu_error_code_stack[i].function = (char*)malloc(GPU_ERROR_FUNCTION_STRING_MAX+1); 226 - _gpu_error_code_stack[i].details = (char*)malloc(GPU_ERROR_DETAILS_STRING_MAX+1); 225 + _gpu_error_code_stack[i].function = (char*)SDL_malloc(GPU_ERROR_FUNCTION_STRING_MAX+1); 226 + _gpu_error_code_stack[i].details = (char*)SDL_malloc(GPU_ERROR_DETAILS_STRING_MAX+1); 227 227 } 228 228 _gpu_num_error_codes = 0; 229 229 } ··· 234 234 if(_gpu_window_mappings == NULL) 235 235 { 236 236 _gpu_window_mappings_size = GPU_INITIAL_WINDOW_MAPPINGS_SIZE; 237 - _gpu_window_mappings = (GPU_WindowMapping*)malloc(_gpu_window_mappings_size * sizeof(GPU_WindowMapping)); 237 + _gpu_window_mappings = (GPU_WindowMapping*)SDL_malloc(_gpu_window_mappings_size * sizeof(GPU_WindowMapping)); 238 238 _gpu_num_window_mappings = 0; 239 239 } 240 240 } ··· 271 271 { 272 272 GPU_WindowMapping* new_array; 273 273 _gpu_window_mappings_size *= 2; 274 - new_array = (GPU_WindowMapping*)malloc(_gpu_window_mappings_size * sizeof(GPU_WindowMapping)); 274 + new_array = (GPU_WindowMapping*)SDL_malloc(_gpu_window_mappings_size * sizeof(GPU_WindowMapping)); 275 275 memcpy(new_array, _gpu_window_mappings, _gpu_num_window_mappings * sizeof(GPU_WindowMapping)); 276 - free(_gpu_window_mappings); 276 + SDL_free(_gpu_window_mappings); 277 277 _gpu_window_mappings = new_array; 278 278 } 279 279 ··· 563 563 // Free the error stack 564 564 for(i = 0; i < _gpu_error_code_stack_size; i++) 565 565 { 566 - free(_gpu_error_code_stack[i].function); 566 + SDL_free(_gpu_error_code_stack[i].function); 567 567 _gpu_error_code_stack[i].function = NULL; 568 - free(_gpu_error_code_stack[i].details); 568 + SDL_free(_gpu_error_code_stack[i].details); 569 569 _gpu_error_code_stack[i].details = NULL; 570 570 } 571 - free(_gpu_error_code_stack); 571 + SDL_free(_gpu_error_code_stack); 572 572 _gpu_error_code_stack = NULL; 573 573 _gpu_num_error_codes = 0; 574 574 ··· 595 595 // Free the error stack 596 596 for(i = 0; i < _gpu_error_code_stack_size; i++) 597 597 { 598 - free(_gpu_error_code_stack[i].function); 598 + SDL_free(_gpu_error_code_stack[i].function); 599 599 _gpu_error_code_stack[i].function = NULL; 600 - free(_gpu_error_code_stack[i].details); 600 + SDL_free(_gpu_error_code_stack[i].details); 601 601 _gpu_error_code_stack[i].details = NULL; 602 602 } 603 - free(_gpu_error_code_stack); 603 + SDL_free(_gpu_error_code_stack); 604 604 _gpu_error_code_stack = NULL; 605 605 _gpu_num_error_codes = 0; 606 606 ··· 880 880 return NULL; 881 881 int data_bytes = SDL_RWseek(rwops, 0, SEEK_END); 882 882 SDL_RWseek(rwops, 0, SEEK_SET); 883 - unsigned char* c_data = (unsigned char*)malloc(data_bytes); 883 + unsigned char* c_data = (unsigned char*)SDL_malloc(data_bytes); 884 884 SDL_RWread(rwops, c_data, 1, data_bytes); 885 885 data = stbi_load_from_memory(c_data, data_bytes, &width, &height, &channels, 0); 886 - free(c_data); 886 + SDL_free(c_data); 887 887 SDL_FreeRW(rwops); 888 888 } 889 889 else
+10
src/externals/stb_image/stb_image.c
··· 1 1 2 2 #define STB_IMAGE_IMPLEMENTATION 3 + 4 + // Make stb-image use SDL's allocator so we can let SDL handle the memory that stb allocates. 5 + // To do this, we'll redefine malloc and free. 6 + #include "SDL.h" 7 + #include <stdlib.h> 8 + #undef malloc 9 + #undef free 10 + #define malloc SDL_malloc 11 + #define free SDL_free 12 + 3 13 #include "stb_image.h"
+11
src/externals/stb_image/stb_image_write.c
··· 1 1 2 2 #define STB_IMAGE_WRITE_IMPLEMENTATION 3 + 4 + // stbi_write_png_to_mem() returns a malloc'ed array, 5 + // so let's do the same thing as done with stb_image.c so it is more compatible with SDL's allocator. 6 + #include "SDL.h" 7 + #include <stdlib.h> 8 + #undef malloc 9 + #undef free 10 + #define malloc SDL_malloc 11 + #define free SDL_free 12 + 13 + 3 14 #include "stb_image_write.h"
+3 -3
src/renderer_GLES_1.c
··· 27 27 28 28 GPU_Renderer* GPU_CreateRenderer_GLES_1(GPU_RendererID request) 29 29 { 30 - GPU_Renderer* renderer = (GPU_Renderer*)malloc(sizeof(GPU_Renderer)); 30 + GPU_Renderer* renderer = (GPU_Renderer*)SDL_malloc(sizeof(GPU_Renderer)); 31 31 if(renderer == NULL) 32 32 return NULL; 33 33 ··· 40 40 41 41 renderer->current_context_target = NULL; 42 42 43 - renderer->impl = (GPU_RendererImpl*)malloc(sizeof(GPU_RendererImpl)); 43 + renderer->impl = (GPU_RendererImpl*)SDL_malloc(sizeof(GPU_RendererImpl)); 44 44 memset(renderer->impl, 0, sizeof(GPU_RendererImpl)); 45 45 SET_COMMON_FUNCTIONS(renderer->impl); 46 46 ··· 52 52 if(renderer == NULL) 53 53 return; 54 54 55 - free(renderer); 55 + SDL_free(renderer); 56 56 } 57 57 58 58 #endif
+3 -3
src/renderer_GLES_2.c
··· 32 32 33 33 GPU_Renderer* GPU_CreateRenderer_GLES_2(GPU_RendererID request) 34 34 { 35 - GPU_Renderer* renderer = (GPU_Renderer*)malloc(sizeof(GPU_Renderer)); 35 + GPU_Renderer* renderer = (GPU_Renderer*)SDL_malloc(sizeof(GPU_Renderer)); 36 36 if(renderer == NULL) 37 37 return NULL; 38 38 ··· 45 45 46 46 renderer->current_context_target = NULL; 47 47 48 - renderer->impl = (GPU_RendererImpl*)malloc(sizeof(GPU_RendererImpl)); 48 + renderer->impl = (GPU_RendererImpl*)SDL_malloc(sizeof(GPU_RendererImpl)); 49 49 memset(renderer->impl, 0, sizeof(GPU_RendererImpl)); 50 50 SET_COMMON_FUNCTIONS(renderer->impl); 51 51 ··· 57 57 if(renderer == NULL) 58 58 return; 59 59 60 - free(renderer); 60 + SDL_free(renderer); 61 61 } 62 62 63 63
+66 -66
src/renderer_GL_common.inl
··· 392 392 393 393 //GPU_LogError("Growing to %d vertices\n", new_max_num_vertices); 394 394 // Resize the blit buffer 395 - new_buffer = (float*)malloc(new_max_num_vertices * GPU_BLIT_BUFFER_STRIDE); 395 + new_buffer = (float*)SDL_malloc(new_max_num_vertices * GPU_BLIT_BUFFER_STRIDE); 396 396 memcpy(new_buffer, cdata->blit_buffer, cdata->blit_buffer_num_vertices * GPU_BLIT_BUFFER_STRIDE); 397 - free(cdata->blit_buffer); 397 + SDL_free(cdata->blit_buffer); 398 398 cdata->blit_buffer = new_buffer; 399 399 cdata->blit_buffer_max_num_vertices = new_max_num_vertices; 400 400 ··· 437 437 438 438 //GPU_LogError("Growing to %d indices\n", new_max_num_vertices); 439 439 // Resize the index buffer 440 - new_indices = (unsigned short*)malloc(new_max_num_vertices * sizeof(unsigned short)); 440 + new_indices = (unsigned short*)SDL_malloc(new_max_num_vertices * sizeof(unsigned short)); 441 441 memcpy(new_indices, cdata->index_buffer, cdata->index_buffer_num_vertices * sizeof(unsigned short)); 442 - free(cdata->index_buffer); 442 + SDL_free(cdata->index_buffer); 443 443 cdata->index_buffer = new_indices; 444 444 cdata->index_buffer_max_num_vertices = new_max_num_vertices; 445 445 ··· 950 950 int index_buffer_storage_size; 951 951 952 952 created = 1; 953 - target = (GPU_Target*)malloc(sizeof(GPU_Target)); 953 + target = (GPU_Target*)SDL_malloc(sizeof(GPU_Target)); 954 954 memset(target, 0, sizeof(GPU_Target)); 955 955 target->refcount = 1; 956 956 target->is_alias = 0; 957 - target->data = (GPU_TARGET_DATA*)malloc(sizeof(GPU_TARGET_DATA)); 957 + target->data = (GPU_TARGET_DATA*)SDL_malloc(sizeof(GPU_TARGET_DATA)); 958 958 memset(target->data, 0, sizeof(GPU_TARGET_DATA)); 959 959 ((GPU_TARGET_DATA*)target->data)->refcount = 1; 960 960 target->image = NULL; 961 - target->context = (GPU_Context*)malloc(sizeof(GPU_Context)); 961 + target->context = (GPU_Context*)SDL_malloc(sizeof(GPU_Context)); 962 962 memset(target->context, 0, sizeof(GPU_Context)); 963 - cdata = (GPU_CONTEXT_DATA*)malloc(sizeof(GPU_CONTEXT_DATA)); 963 + cdata = (GPU_CONTEXT_DATA*)SDL_malloc(sizeof(GPU_CONTEXT_DATA)); 964 964 memset(cdata, 0, sizeof(GPU_CONTEXT_DATA)); 965 965 target->context->data = cdata; 966 966 target->context->context = NULL; ··· 971 971 cdata->blit_buffer_max_num_vertices = GPU_BLIT_BUFFER_INIT_MAX_NUM_VERTICES; 972 972 cdata->blit_buffer_num_vertices = 0; 973 973 blit_buffer_storage_size = GPU_BLIT_BUFFER_INIT_MAX_NUM_VERTICES*GPU_BLIT_BUFFER_STRIDE; 974 - cdata->blit_buffer = (float*)malloc(blit_buffer_storage_size); 974 + cdata->blit_buffer = (float*)SDL_malloc(blit_buffer_storage_size); 975 975 cdata->index_buffer_max_num_vertices = GPU_BLIT_BUFFER_INIT_MAX_NUM_VERTICES; 976 976 cdata->index_buffer_num_vertices = 0; 977 977 index_buffer_storage_size = GPU_BLIT_BUFFER_INIT_MAX_NUM_VERTICES*sizeof(unsigned short); 978 - cdata->index_buffer = (unsigned short*)malloc(index_buffer_storage_size); 978 + cdata->index_buffer = (unsigned short*)SDL_malloc(index_buffer_storage_size); 979 979 } 980 980 else 981 981 { ··· 990 990 { 991 991 if(created) 992 992 { 993 - free(cdata->blit_buffer); 994 - free(cdata->index_buffer); 995 - free(target->context->data); 996 - free(target->context); 997 - free(target->data); 998 - free(target); 993 + SDL_free(cdata->blit_buffer); 994 + SDL_free(cdata->index_buffer); 995 + SDL_free(target->context->data); 996 + SDL_free(target->context); 997 + SDL_free(target->data); 998 + SDL_free(target); 999 999 } 1000 1000 return NULL; 1001 1001 } ··· 1023 1023 { 1024 1024 if(created) 1025 1025 { 1026 - free(cdata->blit_buffer); 1027 - free(cdata->index_buffer); 1028 - free(target->context->data); 1029 - free(target->context); 1030 - free(target->data); 1031 - free(target); 1026 + SDL_free(cdata->blit_buffer); 1027 + SDL_free(cdata->index_buffer); 1028 + SDL_free(target->context->data); 1029 + SDL_free(target->context); 1030 + SDL_free(target->data); 1031 + SDL_free(target); 1032 1032 } 1033 1033 return NULL; 1034 1034 } ··· 1324 1324 if(target == NULL) 1325 1325 return NULL; 1326 1326 1327 - result = (GPU_Target*)malloc(sizeof(GPU_Target)); 1327 + result = (GPU_Target*)SDL_malloc(sizeof(GPU_Target)); 1328 1328 1329 1329 // Copy the members 1330 1330 *result = *target; ··· 1783 1783 glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE); 1784 1784 #endif 1785 1785 1786 - result = (GPU_Image*)malloc(sizeof(GPU_Image)); 1786 + result = (GPU_Image*)SDL_malloc(sizeof(GPU_Image)); 1787 1787 result->refcount = 1; 1788 - data = (GPU_IMAGE_DATA*)malloc(sizeof(GPU_IMAGE_DATA)); 1788 + data = (GPU_IMAGE_DATA*)SDL_malloc(sizeof(GPU_IMAGE_DATA)); 1789 1789 data->refcount = 1; 1790 1790 result->target = NULL; 1791 1791 result->renderer = renderer; ··· 1859 1859 // Initialize texture using a blank buffer 1860 1860 if(zero_buffer_size < (unsigned int)(w*h*result->bytes_per_pixel)) 1861 1861 { 1862 - free(zero_buffer); 1862 + SDL_free(zero_buffer); 1863 1863 zero_buffer_size = w*h*result->bytes_per_pixel; 1864 - zero_buffer = (unsigned char*)malloc(zero_buffer_size); 1864 + zero_buffer = (unsigned char*)SDL_malloc(zero_buffer_size); 1865 1865 memset(zero_buffer, 0, zero_buffer_size); 1866 1866 } 1867 1867 ··· 2017 2017 2018 2018 // Finally create the image 2019 2019 2020 - data = (GPU_IMAGE_DATA*)malloc(sizeof(GPU_IMAGE_DATA)); 2020 + data = (GPU_IMAGE_DATA*)SDL_malloc(sizeof(GPU_IMAGE_DATA)); 2021 2021 data->refcount = 1; 2022 2022 data->handle = handle; 2023 2023 data->owns_handle = take_ownership; 2024 2024 data->format = gl_format; 2025 2025 2026 2026 2027 - result = (GPU_Image*)malloc(sizeof(GPU_Image)); 2027 + result = (GPU_Image*)SDL_malloc(sizeof(GPU_Image)); 2028 2028 result->refcount = 1; 2029 2029 result->target = NULL; 2030 2030 result->renderer = renderer; ··· 2082 2082 if(image == NULL) 2083 2083 return NULL; 2084 2084 2085 - result = (GPU_Image*)malloc(sizeof(GPU_Image)); 2085 + result = (GPU_Image*)SDL_malloc(sizeof(GPU_Image)); 2086 2086 // Copy the members 2087 2087 *result = *image; 2088 2088 ··· 2164 2164 bytes_per_pixel = 4; 2165 2165 if(target->image != NULL) 2166 2166 bytes_per_pixel = target->image->bytes_per_pixel; 2167 - data = (unsigned char*)malloc(target->base_w * target->base_h * bytes_per_pixel); 2167 + data = (unsigned char*)SDL_malloc(target->base_w * target->base_h * bytes_per_pixel); 2168 2168 2169 2169 // This can take regions of pixels, so using base_w and base_h with an image target should be fine. 2170 2170 if(!readTargetPixels(renderer, target, ((GPU_TARGET_DATA*)target->data)->format, data)) 2171 2171 { 2172 - free(data); 2172 + SDL_free(data); 2173 2173 return NULL; 2174 2174 } 2175 2175 2176 2176 // Flip the data vertically (OpenGL framebuffer is read upside down) 2177 2177 pitch = target->base_w * bytes_per_pixel; 2178 - copy = (unsigned char*)malloc(pitch); 2178 + copy = (unsigned char*)SDL_malloc(pitch); 2179 2179 2180 2180 for(y = 0; y < target->base_h/2; y++) 2181 2181 { ··· 2185 2185 memcpy(top, bottom, pitch); 2186 2186 memcpy(bottom, copy, pitch); 2187 2187 } 2188 - free(copy); 2188 + SDL_free(copy); 2189 2189 2190 2190 return data; 2191 2191 } ··· 2197 2197 if(image->target != NULL && isCurrentTarget(renderer, image->target)) 2198 2198 renderer->impl->FlushBlitBuffer(renderer); 2199 2199 2200 - data = (unsigned char*)malloc(image->texture_w * image->texture_h * image->bytes_per_pixel); 2200 + data = (unsigned char*)SDL_malloc(image->texture_w * image->texture_h * image->bytes_per_pixel); 2201 2201 2202 2202 // FIXME: Sometimes the texture is stored and read in RGBA even when I specify RGB. getRawImageData() might need to return the stored format or Bpp. 2203 2203 if(!readImagePixels(renderer, image, ((GPU_IMAGE_DATA*)image->data)->format, data)) 2204 2204 { 2205 - free(data); 2205 + SDL_free(data); 2206 2206 return NULL; 2207 2207 } 2208 2208 ··· 2249 2249 else 2250 2250 { 2251 2251 GPU_PushErrorCode("GPU_SaveImage", GPU_ERROR_DATA_ERROR, "Could not detect output file format from file name"); 2252 - free(data); 2252 + SDL_free(data); 2253 2253 return 0; 2254 2254 } 2255 2255 } ··· 2271 2271 break; 2272 2272 } 2273 2273 2274 - free(data); 2274 + SDL_free(data); 2275 2275 return result; 2276 2276 } 2277 2277 ··· 2565 2565 2566 2566 //GPU_LogError("AllocFormat(): %d, Masks: %X %X %X %X\n", glFormat, Rmask, Gmask, Bmask, Amask); 2567 2567 2568 - result = (SDL_PixelFormat*)malloc(sizeof(SDL_PixelFormat)); 2568 + result = (SDL_PixelFormat*)SDL_malloc(sizeof(SDL_PixelFormat)); 2569 2569 memset(result, 0, sizeof(SDL_PixelFormat)); 2570 2570 2571 2571 result->BitsPerPixel = 8*channels; ··· 2625 2625 2626 2626 static void FreeFormat(SDL_PixelFormat* format) 2627 2627 { 2628 - free(format); 2628 + SDL_free(format); 2629 2629 } 2630 2630 2631 2631 // Returns NULL on failure. Returns the original surface if no copy is needed. Returns a new surface converted to the right format otherwise. ··· 2701 2701 { 2702 2702 surface = SDL_ConvertSurface(newSurface, dst_fmt, 0); 2703 2703 SDL_FreeSurface(newSurface); 2704 - free(blob); 2704 + SDL_free(blob); 2705 2705 } 2706 2706 else 2707 2707 surface = SDL_ConvertSurface(surface, dst_fmt, 0); ··· 2812 2812 result = CreateUninitializedImage(renderer, image->texture_w, image->texture_h, image->format); 2813 2813 if(result == NULL) 2814 2814 { 2815 - free(texture_data); 2815 + SDL_free(texture_data); 2816 2816 GPU_PushErrorCode("GPU_CopyImage", GPU_ERROR_BACKEND_ERROR, "Failed to create new image."); 2817 2817 return NULL; 2818 2818 } ··· 2848 2848 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); 2849 2849 #endif 2850 2850 2851 - free(texture_data); 2851 + SDL_free(texture_data); 2852 2852 } 2853 2853 break; 2854 2854 default: ··· 3197 3197 { 3198 3198 if(data->owns_handle) 3199 3199 glDeleteTextures( 1, &data->handle); 3200 - free(data); 3200 + SDL_free(data); 3201 3201 } 3202 3202 3203 - free(image); 3203 + SDL_free(image); 3204 3204 } 3205 3205 3206 3206 ··· 3236 3236 if(status != GL_FRAMEBUFFER_COMPLETE) 3237 3237 return NULL; 3238 3238 3239 - result = (GPU_Target*)malloc(sizeof(GPU_Target)); 3239 + result = (GPU_Target*)SDL_malloc(sizeof(GPU_Target)); 3240 3240 memset(result, 0, sizeof(GPU_Target)); 3241 3241 result->refcount = 1; 3242 - data = (GPU_TARGET_DATA*)malloc(sizeof(GPU_TARGET_DATA)); 3242 + data = (GPU_TARGET_DATA*)SDL_malloc(sizeof(GPU_TARGET_DATA)); 3243 3243 data->refcount = 1; 3244 3244 result->data = data; 3245 3245 data->handle = handle; ··· 3291 3291 if(target == renderer->current_context_target) 3292 3292 renderer->current_context_target = NULL; 3293 3293 3294 - free(cdata->blit_buffer); 3295 - free(cdata->index_buffer); 3294 + SDL_free(cdata->blit_buffer); 3295 + SDL_free(cdata->index_buffer); 3296 3296 3297 3297 #ifdef SDL_GPU_USE_SDL2 3298 3298 if(target->context->context != 0) ··· 3302 3302 // Remove all of the window mappings that refer to this target 3303 3303 GPU_RemoveWindowMappingByTarget(target); 3304 3304 3305 - free(target->context->data); 3306 - free(target->context); 3305 + SDL_free(target->context->data); 3306 + SDL_free(target->context); 3307 3307 3308 3308 // Does the renderer data need to be freed too? 3309 3309 data = ((GPU_TARGET_DATA*)target->data); 3310 3310 3311 - free(data); 3312 - free(target); 3311 + SDL_free(data); 3312 + SDL_free(target); 3313 3313 3314 3314 return; 3315 3315 } ··· 3329 3329 if(data->refcount > 1) 3330 3330 { 3331 3331 data->refcount--; 3332 - free(target); 3332 + SDL_free(target); 3333 3333 return; 3334 3334 } 3335 3335 ··· 3345 3345 { 3346 3346 GPU_CONTEXT_DATA* cdata = (GPU_CONTEXT_DATA*)target->context->data; 3347 3347 3348 - free(cdata->blit_buffer); 3349 - free(cdata->index_buffer); 3348 + SDL_free(cdata->blit_buffer); 3349 + SDL_free(cdata->index_buffer); 3350 3350 3351 3351 #ifdef SDL_GPU_USE_BUFFER_PIPELINE 3352 3352 glDeleteBuffers(2, cdata->blit_VBO); ··· 3364 3364 // Remove all of the window mappings that refer to this target 3365 3365 GPU_RemoveWindowMappingByTarget(target); 3366 3366 3367 - free(target->context->data); 3368 - free(target->context); 3367 + SDL_free(target->context->data); 3368 + SDL_free(target->context); 3369 3369 target->context = NULL; 3370 3370 } 3371 3371 3372 - free(data); 3373 - free(target); 3372 + SDL_free(data); 3373 + SDL_free(target); 3374 3374 } 3375 3375 3376 3376 ··· 5217 5217 { 5218 5218 // Read in the shader source code 5219 5219 Uint32 size = GetShaderSourceSize_RW(shader_source); 5220 - char* source_string = (char*)malloc(size+1); 5220 + char* source_string = (char*)SDL_malloc(size+1); 5221 5221 int result = GetShaderSource_RW(shader_source, source_string); 5222 5222 Uint32 result2; 5223 5223 (void)renderer; ··· 5226 5226 { 5227 5227 GPU_PushErrorCode("GPU_CompileShader", GPU_ERROR_DATA_ERROR, "Failed to read shader source"); 5228 5228 snprintf(shader_message, 256, "Failed to read shader source.\n"); 5229 - free(source_string); 5229 + SDL_free(source_string); 5230 5230 return 0; 5231 5231 } 5232 5232 5233 5233 result2 = compile_shader_source(shader_type, source_string); 5234 - free(source_string); 5234 + SDL_free(source_string); 5235 5235 5236 5236 return result2; 5237 5237 } ··· 6027 6027 // Make sure we have enough room for converted per-vertex data 6028 6028 if(a->per_vertex_storage_size < needed_size) 6029 6029 { 6030 - free(a->per_vertex_storage); 6031 - a->per_vertex_storage = malloc(needed_size); 6030 + SDL_free(a->per_vertex_storage); 6031 + a->per_vertex_storage = SDL_malloc(needed_size); 6032 6032 a->per_vertex_storage_size = needed_size; 6033 6033 } 6034 6034 } 6035 6035 else if(a->per_vertex_storage_size > 0) 6036 6036 { 6037 - free(a->per_vertex_storage); 6037 + SDL_free(a->per_vertex_storage); 6038 6038 a->per_vertex_storage = NULL; 6039 6039 a->per_vertex_storage_size = 0; 6040 6040 }
+3 -3
src/renderer_OpenGL_1.c
··· 27 27 28 28 GPU_Renderer* GPU_CreateRenderer_OpenGL_1(GPU_RendererID request) 29 29 { 30 - GPU_Renderer* renderer = (GPU_Renderer*)malloc(sizeof(GPU_Renderer)); 30 + GPU_Renderer* renderer = (GPU_Renderer*)SDL_malloc(sizeof(GPU_Renderer)); 31 31 if(renderer == NULL) 32 32 return NULL; 33 33 ··· 40 40 41 41 renderer->current_context_target = NULL; 42 42 43 - renderer->impl = (GPU_RendererImpl*)malloc(sizeof(GPU_RendererImpl)); 43 + renderer->impl = (GPU_RendererImpl*)SDL_malloc(sizeof(GPU_RendererImpl)); 44 44 memset(renderer->impl, 0, sizeof(GPU_RendererImpl)); 45 45 SET_COMMON_FUNCTIONS(renderer->impl); 46 46 ··· 52 52 if(renderer == NULL) 53 53 return; 54 54 55 - free(renderer); 55 + SDL_free(renderer); 56 56 } 57 57 58 58 #endif
+3 -3
src/renderer_OpenGL_1_BASE.c
··· 25 25 26 26 GPU_Renderer* GPU_CreateRenderer_OpenGL_1_BASE(GPU_RendererID request) 27 27 { 28 - GPU_Renderer* renderer = (GPU_Renderer*)malloc(sizeof(GPU_Renderer)); 28 + GPU_Renderer* renderer = (GPU_Renderer*)SDL_malloc(sizeof(GPU_Renderer)); 29 29 if(renderer == NULL) 30 30 return NULL; 31 31 ··· 38 38 39 39 renderer->current_context_target = NULL; 40 40 41 - renderer->impl = (GPU_RendererImpl*)malloc(sizeof(GPU_RendererImpl)); 41 + renderer->impl = (GPU_RendererImpl*)SDL_malloc(sizeof(GPU_RendererImpl)); 42 42 memset(renderer->impl, 0, sizeof(GPU_RendererImpl)); 43 43 SET_COMMON_FUNCTIONS(renderer->impl); 44 44 ··· 50 50 if(renderer == NULL) 51 51 return; 52 52 53 - free(renderer); 53 + SDL_free(renderer); 54 54 } 55 55 56 56 #endif
+3 -3
src/renderer_OpenGL_2.c
··· 25 25 26 26 GPU_Renderer* GPU_CreateRenderer_OpenGL_2(GPU_RendererID request) 27 27 { 28 - GPU_Renderer* renderer = (GPU_Renderer*)malloc(sizeof(GPU_Renderer)); 28 + GPU_Renderer* renderer = (GPU_Renderer*)SDL_malloc(sizeof(GPU_Renderer)); 29 29 if(renderer == NULL) 30 30 return NULL; 31 31 ··· 38 38 39 39 renderer->current_context_target = NULL; 40 40 41 - renderer->impl = (GPU_RendererImpl*)malloc(sizeof(GPU_RendererImpl)); 41 + renderer->impl = (GPU_RendererImpl*)SDL_malloc(sizeof(GPU_RendererImpl)); 42 42 memset(renderer->impl, 0, sizeof(GPU_RendererImpl)); 43 43 SET_COMMON_FUNCTIONS(renderer->impl); 44 44 ··· 50 50 if(renderer == NULL) 51 51 return; 52 52 53 - free(renderer); 53 + SDL_free(renderer); 54 54 } 55 55 56 56
+3 -3
src/renderer_OpenGL_3.c
··· 25 25 26 26 GPU_Renderer* GPU_CreateRenderer_OpenGL_3(GPU_RendererID request) 27 27 { 28 - GPU_Renderer* renderer = (GPU_Renderer*)malloc(sizeof(GPU_Renderer)); 28 + GPU_Renderer* renderer = (GPU_Renderer*)SDL_malloc(sizeof(GPU_Renderer)); 29 29 if(renderer == NULL) 30 30 return NULL; 31 31 ··· 38 38 39 39 renderer->current_context_target = NULL; 40 40 41 - renderer->impl = (GPU_RendererImpl*)malloc(sizeof(GPU_RendererImpl)); 41 + renderer->impl = (GPU_RendererImpl*)SDL_malloc(sizeof(GPU_RendererImpl)); 42 42 memset(renderer->impl, 0, sizeof(GPU_RendererImpl)); 43 43 SET_COMMON_FUNCTIONS(renderer->impl); 44 44 ··· 50 50 if(renderer == NULL) 51 51 return; 52 52 53 - free(renderer); 53 + SDL_free(renderer); 54 54 } 55 55 56 56