576 lines
15 KiB
C
576 lines
15 KiB
C
/*
|
|
* This file is part of the MLV Library.
|
|
*
|
|
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
|
|
*
|
|
*
|
|
* This Library is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This Library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this Library. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "memory_debug.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
|
|
#define DEBUG_MEMORY_MSG(x) { fprintf(stderr,"Memory Debug : %s \n",(x)); }
|
|
|
|
#include "memory_management.h"
|
|
|
|
int memory_debug_n;
|
|
SDL_EventFilter memory_debug_filter;
|
|
SDL_Event memory_debug_event;
|
|
|
|
Memory_debug_statistics memory_debug_statistics;
|
|
|
|
void init_memory_debug(){
|
|
memory_debug_statistics.nb_create_surface = 0;
|
|
memory_debug_statistics.nb_free_surface = 0;
|
|
memory_debug_statistics.nb_init_sdl = 0;
|
|
memory_debug_statistics.nb_close_sdl = 0;
|
|
memory_debug_statistics.nb_create_semaphore = 0;
|
|
memory_debug_statistics.nb_free_semaphore = 0;
|
|
memory_debug_statistics.nb_malloc = 0;
|
|
memory_debug_statistics.nb_free = 0;
|
|
memory_debug_statistics.nb_free_wave = 0;
|
|
memory_debug_statistics.nb_load_wave = 0;
|
|
memory_debug_statistics.nb_open_font = 0;
|
|
memory_debug_statistics.nb_close_font = 0;
|
|
memory_debug_statistics.nb_init_ttf = 0;
|
|
memory_debug_statistics.nb_quit_ttf = 0;
|
|
}
|
|
|
|
void print_memory_statistics(){
|
|
fprintf(stderr,"--------------------------STATISTICS---------------------\n");
|
|
fprintf(stderr,"Memory Debug : nb_create_surface : %i \n", memory_debug_statistics.nb_create_surface);
|
|
fprintf(stderr,"Memory Debug : nb_free_surface : %i \n", memory_debug_statistics.nb_free_surface);
|
|
fprintf(stderr,"Memory Debug : nb_init_sdl : %i \n", memory_debug_statistics.nb_init_sdl);
|
|
fprintf(stderr,"Memory Debug : nb_close_sdl : %i \n", memory_debug_statistics.nb_close_sdl);
|
|
fprintf(stderr,"Memory Debug : nb_create_semaphore : %i \n", memory_debug_statistics.nb_create_semaphore);
|
|
fprintf(stderr,"Memory Debug : nb_free_semaphore : %i \n", memory_debug_statistics.nb_free_semaphore);
|
|
fprintf(stderr,"Memory Debug : nb_malloc : %i \n", memory_debug_statistics.nb_malloc);
|
|
fprintf(stderr,"Memory Debug : nb_calloc : %i \n", memory_debug_statistics.nb_calloc);
|
|
fprintf(stderr,"Memory Debug : nb_free : %i \n", memory_debug_statistics.nb_free);
|
|
fprintf(stderr,"Memory Debug : nb_free_wave : %i \n", memory_debug_statistics.nb_free_wave);
|
|
fprintf(stderr,"Memory Debug : nb_load_wave : %i \n", memory_debug_statistics.nb_load_wave);
|
|
fprintf(stderr,"Memory Debug : nb_open_font : %i \n", memory_debug_statistics.nb_open_font);
|
|
fprintf(stderr,"Memory Debug : nb_close_font : %i \n", memory_debug_statistics.nb_close_font);
|
|
fprintf(stderr,"Memory Debug : nb_init_ttf : %i \n", memory_debug_statistics.nb_init_ttf);
|
|
fprintf(stderr,"Memory Debug : nb_quit_ttf : %i \n", memory_debug_statistics.nb_quit_ttf);
|
|
fprintf(stderr,"----------------------END-STATISTICS---------------------\n");
|
|
}
|
|
|
|
typedef enum {
|
|
MEMORY_DEBUG_CREATE_SURFACE,
|
|
MEMORY_DEBUG_FREE_SURFACE,
|
|
MEMORY_DEBUG_INIT_SDL,
|
|
MEMORY_DEBUG_CLOSE_SDL,
|
|
MEMORY_DEBUG_CREATE_SEMAPHORE,
|
|
MEMORY_DEBUG_FREE_SEMAPHORE,
|
|
MEMORY_DEBUG_MALLOC,
|
|
MEMORY_DEBUG_CALLOC,
|
|
MEMORY_DEBUG_FREE,
|
|
MEMORY_DEBUG_FREE_WAVE,
|
|
MEMORY_DEBUG_LOAD_WAVE,
|
|
MEMORY_DEBUG_OPEN_FONT,
|
|
MEMORY_DEBUG_CLOSE_FONT,
|
|
MEMORY_DEBUG_QUIT_TTF,
|
|
MEMORY_DEBUG_INIT_TTF
|
|
} Memory_debug_statistics_type;
|
|
|
|
void update_memory_statistics( Memory_debug_statistics_type type ){
|
|
switch( type ){
|
|
case MEMORY_DEBUG_CREATE_SURFACE :
|
|
{
|
|
memory_debug_statistics.nb_create_surface++;
|
|
}
|
|
break;
|
|
case MEMORY_DEBUG_FREE_SURFACE :
|
|
{
|
|
memory_debug_statistics.nb_free_surface++;
|
|
}
|
|
break;
|
|
case MEMORY_DEBUG_INIT_SDL :
|
|
{
|
|
memory_debug_statistics.nb_init_sdl++;
|
|
}
|
|
break;
|
|
case MEMORY_DEBUG_CLOSE_SDL :
|
|
{
|
|
memory_debug_statistics.nb_close_sdl++;
|
|
}
|
|
break;
|
|
case MEMORY_DEBUG_CREATE_SEMAPHORE :
|
|
{
|
|
memory_debug_statistics.nb_create_semaphore++;
|
|
}
|
|
break;
|
|
case MEMORY_DEBUG_FREE_SEMAPHORE :
|
|
{
|
|
memory_debug_statistics.nb_free_semaphore ++;
|
|
}
|
|
break;
|
|
case MEMORY_DEBUG_MALLOC :
|
|
{
|
|
memory_debug_statistics.nb_malloc ++;
|
|
}
|
|
break;
|
|
case MEMORY_DEBUG_CALLOC :
|
|
{
|
|
memory_debug_statistics.nb_calloc ++;
|
|
}
|
|
break;
|
|
case MEMORY_DEBUG_FREE :
|
|
{
|
|
memory_debug_statistics.nb_free ++;
|
|
}
|
|
break;
|
|
case MEMORY_DEBUG_FREE_WAVE :
|
|
{
|
|
memory_debug_statistics.nb_free_wave ++;
|
|
}
|
|
break;
|
|
case MEMORY_DEBUG_LOAD_WAVE :
|
|
{
|
|
memory_debug_statistics.nb_load_wave ++;
|
|
}
|
|
break;
|
|
case MEMORY_DEBUG_OPEN_FONT :
|
|
{
|
|
memory_debug_statistics.nb_open_font ++;
|
|
}
|
|
break;
|
|
case MEMORY_DEBUG_CLOSE_FONT :
|
|
{
|
|
memory_debug_statistics.nb_close_font ++;
|
|
}
|
|
break;
|
|
case MEMORY_DEBUG_QUIT_TTF :
|
|
{
|
|
memory_debug_statistics.nb_quit_ttf ++;
|
|
}
|
|
break;
|
|
case MEMORY_DEBUG_INIT_TTF :
|
|
{
|
|
memory_debug_statistics.nb_init_ttf ++;
|
|
}
|
|
break;
|
|
default:;
|
|
}
|
|
}
|
|
|
|
void close_memory_debug(){
|
|
}
|
|
|
|
void filledCircleColor( SDL_Surface* screen, int x, int y, int radius, Uint32 color){
|
|
}
|
|
|
|
void circleColor( SDL_Surface* screen, int x, int y, int radius, Uint32 color){
|
|
}
|
|
|
|
void ellipseColor( SDL_Surface* screen, int x, int y, int radius_x, int radius_y, Uint32 color ){
|
|
}
|
|
|
|
void filledEllipseColor( SDL_Surface* screen, int x, int y, int radius_x, int radius_y, Uint32 color){
|
|
}
|
|
|
|
void polygonColor( SDL_Surface* screen, Sint16* vx, Sint16* vy, int npoints, Uint32 color){
|
|
}
|
|
|
|
void filledPolygonColor( SDL_Surface* screen, Sint16* vx, Sint16* vy, int npoints, Uint32 color){
|
|
}
|
|
|
|
void rectangleColor( SDL_Surface* screen, int x, int y, int width, int height, Uint32 color){
|
|
}
|
|
|
|
void boxColor( SDL_Surface* screen, int x, int y, int width, int height, Uint32 color){
|
|
}
|
|
|
|
void lineColor( SDL_Surface* screen, int x1, int y1, int x2, int y2, Uint32 color){
|
|
}
|
|
|
|
void pixelColor( SDL_Surface* screen, int x, int y, Uint32 color){
|
|
}
|
|
|
|
void stringColor( SDL_Surface* screen, int x, int y, const char *text, Uint32 color){
|
|
}
|
|
|
|
int SDL_BlitSurface( SDL_Surface* src, SDL_Rect* rectangle_src, SDL_Surface* dst, SDL_Rect* rectangle_dest){
|
|
return 0;
|
|
}
|
|
|
|
|
|
int memory_debug_modulo;
|
|
|
|
int SDL_PollEvent( SDL_Event* event ){
|
|
memory_debug_n = (memory_debug_n+1)%memory_debug_modulo;
|
|
switch( memory_debug_n ){
|
|
case 0:
|
|
{
|
|
DEBUG_MEMORY_MSG("Pas d'evenement")
|
|
return 0;
|
|
}
|
|
case 1: ;
|
|
{
|
|
DEBUG_MEMORY_MSG("souris deplace 10 10")
|
|
event->type=SDL_MOUSEMOTION;
|
|
event->motion.which = 0;
|
|
event->motion.state = SDL_RELEASED;
|
|
event->motion.x = 10;
|
|
event->motion.y = 10;
|
|
event->motion.xrel = -90;
|
|
event->motion.yrel = -90;
|
|
};
|
|
break;
|
|
case 2: ;
|
|
{
|
|
DEBUG_MEMORY_MSG("bouton gauche souris tape")
|
|
event->type=SDL_MOUSEBUTTONDOWN;
|
|
event->button.which = 0;
|
|
event->button.button = SDL_BUTTON_LEFT;
|
|
event->button.state = SDL_PRESSED;
|
|
event->button.x = 10;
|
|
event->button.y = 10;
|
|
};
|
|
break;
|
|
case 3: ;
|
|
{
|
|
DEBUG_MEMORY_MSG("bouton gauche souris relache")
|
|
event->type=SDL_MOUSEBUTTONUP;
|
|
event->button.which = 0;
|
|
event->button.button = SDL_BUTTON_LEFT;
|
|
event->button.state = SDL_RELEASED;
|
|
event->button.x = 10;
|
|
event->button.y = 10;
|
|
};
|
|
break;
|
|
case 4: ;
|
|
{
|
|
DEBUG_MEMORY_MSG("souris deplace 100")
|
|
event->type=SDL_MOUSEMOTION;
|
|
event->motion.which = 0;
|
|
event->motion.state = SDL_RELEASED;
|
|
event->motion.x = 100;
|
|
event->motion.y = 100;
|
|
event->motion.xrel = 90;
|
|
event->motion.yrel = 90;
|
|
};
|
|
break;
|
|
case 5: ;
|
|
{
|
|
DEBUG_MEMORY_MSG("bouton gauche souris tape")
|
|
event->type=SDL_MOUSEBUTTONDOWN;
|
|
event->button.which = 0;
|
|
event->button.button = SDL_BUTTON_LEFT;
|
|
event->button.state = SDL_PRESSED;
|
|
event->button.x = 100;
|
|
event->button.y = 100;
|
|
};
|
|
break;
|
|
case 6: ;
|
|
{
|
|
DEBUG_MEMORY_MSG("bouton gausche souris relache")
|
|
event->type=SDL_MOUSEBUTTONUP;
|
|
event->button.which = 0;
|
|
event->button.button = SDL_BUTTON_LEFT;
|
|
event->button.state = SDL_RELEASED;
|
|
event->button.x = 100;
|
|
event->button.y = 100;
|
|
};
|
|
break;
|
|
case 7:
|
|
{
|
|
DEBUG_MEMORY_MSG("a tape")
|
|
event->type=SDL_KEYDOWN;
|
|
event->key.type=SDL_KEYDOWN;
|
|
event->key.which=0;
|
|
event->key.state=SDL_PRESSED;
|
|
event->key.keysym.scancode = 0;
|
|
event->key.keysym.sym=SDLK_a;
|
|
event->key.keysym.mod=KMOD_NONE;
|
|
event->key.keysym.unicode=97;
|
|
};
|
|
break;
|
|
case 8: ;
|
|
{
|
|
DEBUG_MEMORY_MSG("a relache")
|
|
event->type=SDL_KEYUP;
|
|
event->key.type=SDL_KEYUP;
|
|
event->key.which=0;
|
|
event->key.state=SDL_RELEASED;
|
|
event->key.keysym.scancode = 0;
|
|
event->key.keysym.sym=SDLK_a;
|
|
event->key.keysym.mod=KMOD_NONE;
|
|
event->key.keysym.unicode=97;
|
|
};
|
|
break;
|
|
case 9: ;
|
|
{
|
|
DEBUG_MEMORY_MSG("b tape")
|
|
event->type=SDL_KEYDOWN;
|
|
event->key.type=SDL_KEYDOWN;
|
|
event->key.which=0;
|
|
event->key.state=SDL_PRESSED;
|
|
event->key.keysym.scancode = 0;
|
|
event->key.keysym.sym=SDLK_b;
|
|
event->key.keysym.mod=KMOD_NONE;
|
|
event->key.keysym.unicode=98;
|
|
};
|
|
break;
|
|
case 10: ;
|
|
{
|
|
DEBUG_MEMORY_MSG("b relache")
|
|
event->type=SDL_KEYUP;
|
|
event->key.type=SDL_KEYUP;
|
|
event->key.which=0;
|
|
event->key.state=SDL_RELEASED;
|
|
event->key.keysym.scancode = 0;
|
|
event->key.keysym.sym=SDLK_b;
|
|
event->key.keysym.mod=KMOD_NONE;
|
|
event->key.keysym.unicode=98;
|
|
};
|
|
break;
|
|
case 11: ;
|
|
{
|
|
DEBUG_MEMORY_MSG("return tape")
|
|
event->type=SDL_KEYDOWN;
|
|
event->key.type=SDL_KEYDOWN;
|
|
event->key.which=0;
|
|
event->key.state=SDL_PRESSED;
|
|
event->key.keysym.scancode = 0;
|
|
event->key.keysym.sym=SDLK_RETURN;
|
|
event->key.keysym.mod=KMOD_NONE;
|
|
event->key.keysym.unicode=13;
|
|
};
|
|
break;
|
|
case 12: ;
|
|
{
|
|
DEBUG_MEMORY_MSG("Return relache")
|
|
event->type=SDL_KEYUP;
|
|
event->key.type=SDL_KEYUP;
|
|
event->key.which=0;
|
|
event->key.state=SDL_RELEASED;
|
|
event->key.keysym.scancode = 0;
|
|
event->key.keysym.sym=SDLK_RETURN;
|
|
event->key.keysym.mod=KMOD_NONE;
|
|
event->key.keysym.unicode=13;
|
|
};
|
|
break;
|
|
case 13:
|
|
{
|
|
DEBUG_MEMORY_MSG("Evenement User")
|
|
(*event)=memory_debug_event;
|
|
};
|
|
break;
|
|
default: ;
|
|
}
|
|
return memory_debug_filter( event );
|
|
}
|
|
|
|
void SDL_SetAlpha(SDL_Surface* surface, int prop1, int prop2){
|
|
}
|
|
|
|
|
|
SDL_Surface* SDL_LoadBMP( const char* path ){
|
|
update_memory_statistics( MEMORY_DEBUG_CREATE_SURFACE );
|
|
return (SDL_Surface*) malloc( sizeof(SDL_Surface) );
|
|
}
|
|
|
|
SDL_Surface* SDL_CreateRGBSurface( int prop1, int w, int h, int resol, int r, int g, int b, int prop2 ){
|
|
update_memory_statistics( MEMORY_DEBUG_CREATE_SURFACE );
|
|
return (SDL_Surface*) malloc( sizeof(SDL_Surface) );
|
|
}
|
|
|
|
void SDL_FreeSurface( SDL_Surface* surface ){
|
|
update_memory_statistics( MEMORY_DEBUG_FREE_SURFACE );
|
|
free( surface );
|
|
}
|
|
|
|
SDL_Surface* rotozoomSurface( SDL_Surface* surface, double rotation, double zoom, int antialias){
|
|
update_memory_statistics( MEMORY_DEBUG_CREATE_SURFACE );
|
|
return (SDL_Surface*) malloc( sizeof(SDL_Surface) );
|
|
}
|
|
|
|
|
|
SDL_Surface* rotozoomSurfaceXY( SDL_Surface* surface, double rotation, double zoomx, double zoomy, int antialias){
|
|
update_memory_statistics( MEMORY_DEBUG_CREATE_SURFACE );
|
|
return (SDL_Surface*) malloc( sizeof(SDL_Surface) );
|
|
}
|
|
|
|
char* memory_debug_sdl_init;
|
|
|
|
int SDL_Init( int flags ){
|
|
memory_debug_n = 0;
|
|
memory_debug_modulo = 14;
|
|
update_memory_statistics( MEMORY_DEBUG_INIT_SDL );
|
|
memory_debug_sdl_init = (char*) malloc( sizeof(char) );
|
|
return 0;
|
|
}
|
|
|
|
void SDL_Quit(){
|
|
update_memory_statistics( MEMORY_DEBUG_CLOSE_SDL );
|
|
free(memory_debug_sdl_init);
|
|
}
|
|
|
|
char* SDL_GetError(){
|
|
return "TOTO";
|
|
}
|
|
|
|
SDL_Surface* SDL_SetVideoMode( int w, int h, int bits, int flags ){
|
|
update_memory_statistics( MEMORY_DEBUG_CREATE_SURFACE );
|
|
return (SDL_Surface*) malloc( sizeof( SDL_Surface ) );
|
|
}
|
|
|
|
void SDL_WM_SetCaption( const char* wind, const char* icon ){
|
|
}
|
|
|
|
void SDL_SetEventFilter( SDL_EventFilter filter ){
|
|
memory_debug_filter = filter;
|
|
}
|
|
|
|
void SDL_Flip( SDL_Surface* surface ){
|
|
}
|
|
|
|
int SDL_SemWait( SDL_sem* semaphore ){
|
|
return 0;
|
|
}
|
|
|
|
int SDL_SemPost( SDL_sem* semaphore ){
|
|
return 0;
|
|
}
|
|
|
|
SDL_sem* SDL_CreateSemaphore( int valeur ){
|
|
update_memory_statistics( MEMORY_DEBUG_CREATE_SEMAPHORE );
|
|
return (SDL_sem*) malloc( sizeof( SDL_sem ) );
|
|
}
|
|
|
|
void SDL_DestroySemaphore( SDL_sem* semaphore ){
|
|
update_memory_statistics( MEMORY_DEBUG_FREE_SEMAPHORE );
|
|
free(semaphore);
|
|
}
|
|
|
|
void SDL_EnableUNICODE( int flags ){
|
|
}
|
|
|
|
int SDL_PushEvent( SDL_Event* event ){
|
|
memory_debug_event = (*event);
|
|
memory_debug_n = memory_debug_modulo - 2 ;
|
|
return 0;
|
|
}
|
|
|
|
int SDL_GetTicks(){
|
|
return 1;
|
|
}
|
|
|
|
void SDL_Delay( int milliseconds ){
|
|
}
|
|
|
|
void* memory_debug_malloc(size_t size, int line, char* file ){
|
|
update_memory_statistics( MEMORY_DEBUG_MALLOC );
|
|
fprintf(stderr, "Memory Debug : malloc ligne : %i, fichier : %s \n", line, file );
|
|
return malloc( size );
|
|
}
|
|
|
|
void* memory_debug_calloc( size_t nmemb, size_t size, int line, char* file ){
|
|
update_memory_statistics( MEMORY_DEBUG_CALLOC );
|
|
fprintf(stderr, "Memory Debug : calloc ligne : %i, fichier : %s \n", line, file );
|
|
return calloc( nmemb, size );
|
|
}
|
|
|
|
void memory_debug_free( void* ptr, int line, char* file ){
|
|
update_memory_statistics( MEMORY_DEBUG_FREE );
|
|
fprintf(stderr, "Memory Debug : free ligne : %i, fichier : %s \n", line, file );
|
|
free( ptr );
|
|
}
|
|
|
|
|
|
void SDL_LockAudio(){
|
|
}
|
|
|
|
void SDL_UnlockAudio(){
|
|
}
|
|
|
|
void SDL_MixAudio(Uint8 *dst, Uint8 *src, Uint32 len, int volume){
|
|
}
|
|
|
|
SDL_AudioSpec* SDL_LoadWAV(const char *file, SDL_AudioSpec *spec, Uint8 **audio_buf, Uint32 *audio_len){
|
|
update_memory_statistics( MEMORY_DEBUG_LOAD_WAVE );
|
|
(*audio_buf) = (Uint8*) malloc( 10000 * sizeof( Uint8 ) );
|
|
(*audio_len) = 10000 * sizeof(Uint8);
|
|
return spec;
|
|
}
|
|
|
|
void SDL_FreeWAV(Uint8 *audio_buf){
|
|
update_memory_statistics( MEMORY_DEBUG_FREE_WAVE );
|
|
free( audio_buf );
|
|
}
|
|
|
|
void SDL_PauseAudio(int pause_on){
|
|
}
|
|
|
|
int SDL_OpenAudio(SDL_AudioSpec *desired, SDL_AudioSpec *obtained){
|
|
return 0;
|
|
}
|
|
|
|
void SDL_CloseAudio(){
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int SDL_SetColorKey(SDL_Surface *surface, Uint32 flag, Uint32 key){
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
int TTF_SizeUTF8(TTF_Font *font, const char *text, int *w, int *h){
|
|
return 0;
|
|
}
|
|
|
|
|
|
char* memory_debug_ttf_init;
|
|
|
|
int TTF_Init(void){
|
|
update_memory_statistics( MEMORY_DEBUG_INIT_TTF );
|
|
memory_debug_ttf_init = (char*) malloc( sizeof(char) );
|
|
return 0;
|
|
}
|
|
|
|
void TTF_Quit(void){
|
|
update_memory_statistics( MEMORY_DEBUG_QUIT_TTF );
|
|
free( memory_debug_ttf_init );
|
|
}
|
|
|
|
TTF_Font * TTF_OpenFont(const char *file, int ptsize){
|
|
update_memory_statistics( MEMORY_DEBUG_OPEN_FONT );
|
|
return (TTF_Font*) malloc( sizeof(TTF_Font) );
|
|
}
|
|
|
|
void TTF_SetFontStyle(TTF_Font *font, int style){
|
|
}
|
|
|
|
void TTF_CloseFont(TTF_Font *font){
|
|
update_memory_statistics( MEMORY_DEBUG_CLOSE_FONT );
|
|
free( font );
|
|
}
|
|
|
|
SDL_Surface * TTF_RenderUTF8_Solid(TTF_Font *font, const char *text, SDL_Color fg){
|
|
update_memory_statistics( MEMORY_DEBUG_CREATE_SURFACE );
|
|
return (SDL_Surface*) malloc( sizeof(SDL_Surface) );
|
|
}
|
|
|
|
|