# HG changeset patch # User Darren Alton # Date 1213238329 0 # Node ID c3e7c0698cbb2bae81a133f26b4b7b74186e627d # Parent 6e4669f4db498927d84dfe127ad005957d997c3b some changes to the dummy driver for debug purposes that should be reverted. most importantly, commenting out a check for an env. var. diff -r 6e4669f4db49 -r c3e7c0698cbb include/SDL_config_nintendods.h --- a/include/SDL_config_nintendods.h Tue Jun 10 06:57:57 2008 +0000 +++ b/include/SDL_config_nintendods.h Thu Jun 12 02:38:49 2008 +0000 @@ -111,7 +111,6 @@ #define SDL_TIMERS_DISABLED 1 /* Enable various video drivers */ -#define SDL_VIDEO_DRIVER_NDS 1 +#define SDL_VIDEO_DRIVER_DUMMY 1 #endif /* _SDL_config_nintendods_h */ - diff -r 6e4669f4db49 -r c3e7c0698cbb include/SDL_stdinc.h --- a/include/SDL_stdinc.h Tue Jun 10 06:57:57 2008 +0000 +++ b/include/SDL_stdinc.h Thu Jun 12 02:38:49 2008 +0000 @@ -147,9 +147,9 @@ SDL_COMPILE_TIME_ASSERT(sint16, sizeof(Sint16) == 2); SDL_COMPILE_TIME_ASSERT(uint32, sizeof(Uint32) == 4); SDL_COMPILE_TIME_ASSERT(sint32, sizeof(Sint32) == 4); -#ifndef __NINTENDODS__ /* TODO: figure out why the following happens: -include/SDL_stdinc.h:150: error: size of array 'SDL_dummy_uint64' is negative -include/SDL_stdinc.h:151: error: size of array 'SDL_dummy_sint64' is negative */ +#ifndef __NINTENDODS__ /* TODO: figure out why the following happens: + include/SDL_stdinc.h:150: error: size of array 'SDL_dummy_uint64' is negative + include/SDL_stdinc.h:151: error: size of array 'SDL_dummy_sint64' is negative */ SDL_COMPILE_TIME_ASSERT(uint64, sizeof(Uint64) == 8); SDL_COMPILE_TIME_ASSERT(sint64, sizeof(Sint64) == 8); #endif @@ -166,7 +166,7 @@ #endif #ifndef DOXYGEN_SHOULD_IGNORE_THIS -#ifndef __NINTENDODS__ /* TODO: include/SDL_stdinc.h:174: error: size of array 'SDL_dummy_enum' is negative */ +#ifndef __NINTENDODS__ /* TODO: include/SDL_stdinc.h:174: error: size of array 'SDL_dummy_enum' is negative */ typedef enum { DUMMY_ENUM_VALUE @@ -432,7 +432,7 @@ #define SDL_wcslen wcslen #else #if !defined(wchar_t) && defined(__NINTENDODS__) -#define wchar_t short /* TODO: figure out why libnds doesn't have this */ +#define wchar_t short /* TODO: figure out why libnds doesn't have this */ #endif extern DECLSPEC size_t SDLCALL SDL_wcslen(const wchar_t * string); #endif diff -r 6e4669f4db49 -r c3e7c0698cbb src/joystick/nds/SDL_sysjoystick.c --- a/src/joystick/nds/SDL_sysjoystick.c Tue Jun 10 06:57:57 2008 +0000 +++ b/src/joystick/nds/SDL_sysjoystick.c Thu Jun 12 02:38:49 2008 +0000 @@ -22,13 +22,13 @@ #ifdef SAVE_RCSID static char rcsid = - "@(#) $Id: SDL_sysjoystick.c,v 1.2 2001/04/26 16:50:17 hercules Exp $"; + "@(#) $Id: SDL_sysjoystick.c,v 1.2 2001/04/26 16:50:17 hercules Exp $"; #endif /* This is the system specific header for the SDL joystick API */ #include //#include -#include /* For the definition of NULL */ +#include /* For the definition of NULL */ #include "SDL_error.h" #include "SDL_joystick.h" @@ -42,21 +42,23 @@ * joysticks. Joystick 0 should be the system default joystick. * It should return 0, or -1 on an unrecoverable fatal error. */ -int SDL_SYS_JoystickInit(void) +int +SDL_SYS_JoystickInit(void) { - SDL_numjoysticks = 1; - //keysInit(); - - return(1); + SDL_numjoysticks = 1; + + //keysInit(); + return (1); } /* Function to get the device-dependent name of a joystick */ -const char *SDL_SYS_JoystickName(int index) +const char * +SDL_SYS_JoystickName(int index) { - if(!index) - return "NDS builtin joypad"; - SDL_SetError("No joystick available with that index"); - return (NULL); + if (!index) + return "NDS builtin joypad"; + SDL_SetError("No joystick available with that index"); + return (NULL); } /* Function to open a joystick for use. @@ -64,91 +66,175 @@ This should fill the nbuttons and naxes fields of the joystick structure. It returns 0, or -1 if there is an error. */ -int SDL_SYS_JoystickOpen(SDL_Joystick *joystick) +int +SDL_SYS_JoystickOpen(SDL_Joystick * joystick) { - joystick->nbuttons=8; - joystick->nhats=0; - joystick->nballs=0; - joystick->naxes=2; - return 0; + joystick->nbuttons = 8; + joystick->nhats = 0; + joystick->nballs = 0; + joystick->naxes = 2; + return 0; } + - /* Function to update the state of a joystick - called as a device poll. * This function shouldn't update the joystick structure directly, * but instead should call SDL_PrivateJoystick*() to deliver events * and update joystick device state. */ - -int prevbutton=0; -int prevkey=0; +int prevbutton = 0; +int prevkey = 0; -int dc=NULL;int ldc=0; -u32 keysd,keysu=NULL; -void SDL_SYS_JoystickUpdate(SDL_Joystick *joystick) -{ - //dc=keysd; - //if (dc != NULL) - //{ - //fprintf(stderr,"heartbeat= %d\n",REG_VCOUNT); - //swiWaitForVBlank(); - //scanKeys(); - //keysd = keysDown(); - //keysu = keysUp(); - //ldc=keysd; - - //} - /*if (prevkey !=NULL && prevbutton !=NULL) - { - scanKeys(); - } - */ - - //scanKeys(); - keysd = keysDown(); - keysu = keysUp(); - - - short ax=0,v=0,h=0; - if((keysd&KEY_UP)) {ax=1;v=-10;SDL_PrivateJoystickAxis(joystick,ax,v);prevkey=KEY_UP;}//fprintf(stderr,"KEY_UP\n");} - if((keysd&KEY_DOWN)) {ax=1;v=10;SDL_PrivateJoystickAxis(joystick,ax,v);prevkey=KEY_DOWN;}//fprintf(stderr,"KEY_DOWN\n");} - if((keysd&KEY_LEFT)) {ax=0;h=-10;SDL_PrivateJoystickAxis(joystick,ax,h);prevkey=KEY_LEFT;}//fprintf(stderr,"KEY_LEFT\n");} - if((keysd&KEY_RIGHT)) {ax=0;h=10;SDL_PrivateJoystickAxis(joystick,ax,h);prevkey=KEY_RIGHT;}//fprintf(stderr,"KEY_RIGHT\n");} - - if((keysu&KEY_UP)) {ax=1;v=0;SDL_PrivateJoystickAxis(joystick,ax,v);prevkey=NULL;}//fprintf(stderr,"KEY_UP\n");} - if((keysu&KEY_DOWN)) {ax=1;v=0;SDL_PrivateJoystickAxis(joystick,ax,v);prevkey=NULL;}//fprintf(stderr,"KEY_DOWN\n");} - if((keysu&KEY_LEFT)) {ax=0;h=0;SDL_PrivateJoystickAxis(joystick,ax,h);prevkey=NULL;}//fprintf(stderr,"KEY_LEFT\n");} - if((keysu&KEY_RIGHT)) {ax=0;h=0;SDL_PrivateJoystickAxis(joystick,ax,h);prevkey=NULL;}//fprintf(stderr,"KEY_RIGHT\n");} - - if((keysd&KEY_A)) {SDL_PrivateJoystickButton(joystick,0,SDL_PRESSED);prevbutton=KEY_A;} - if((keysd&KEY_B)) {SDL_PrivateJoystickButton(joystick,1,SDL_PRESSED);prevbutton=KEY_B;} - if((keysd&KEY_X)) {SDL_PrivateJoystickButton(joystick,2,SDL_PRESSED);prevbutton=KEY_X;} - if((keysd&KEY_Y)) {SDL_PrivateJoystickButton(joystick,3,SDL_PRESSED);prevbutton=KEY_Y;} - if((keysd&KEY_SELECT)) {SDL_PrivateJoystickButton(joystick,6,SDL_PRESSED);prevbutton=KEY_SELECT;} - if((keysd&KEY_START)) {SDL_PrivateJoystickButton(joystick,7,SDL_PRESSED);prevbutton=KEY_START;} - if((keysd&KEY_L)) {SDL_PrivateJoystickButton(joystick,4,SDL_PRESSED);prevbutton=KEY_L;} - if((keysd&KEY_R)) {SDL_PrivateJoystickButton(joystick,5,SDL_PRESSED);prevbutton=KEY_R;} - - if((keysu&KEY_A)) {SDL_PrivateJoystickButton(joystick,0,SDL_RELEASED);prevbutton=NULL;} - if((keysu&KEY_B)) {SDL_PrivateJoystickButton(joystick,1,SDL_RELEASED);prevbutton=NULL;} - if((keysu&KEY_X)) {SDL_PrivateJoystickButton(joystick,2,SDL_RELEASED);prevbutton=NULL;} - if((keysu&KEY_Y)) {SDL_PrivateJoystickButton(joystick,3,SDL_RELEASED);prevbutton=NULL;} - if((keysu&KEY_SELECT)) {SDL_PrivateJoystickButton(joystick,6,SDL_RELEASED);prevbutton=NULL;} - if((keysu&KEY_START)) {SDL_PrivateJoystickButton(joystick,7,SDL_RELEASED);prevbutton=NULL;} - if((keysu&KEY_L)) {SDL_PrivateJoystickButton(joystick,4,SDL_RELEASED);prevbutton=NULL;} - if((keysu&KEY_R)) {SDL_PrivateJoystickButton(joystick,5,SDL_RELEASED);prevbutton=NULL;} - - - -} +int dc = NULL; +int ldc = 0; +u32 keysd, keysu = NULL; +void +SDL_SYS_JoystickUpdate(SDL_Joystick * joystick) +{ + + //dc=keysd; + //if (dc != NULL) + //{ + //fprintf(stderr,"heartbeat= %d\n",REG_VCOUNT); + //swiWaitForVBlank(); + //scanKeys(); + //keysd = keysDown(); + //keysu = keysUp(); + //ldc=keysd; + + //} + /*if (prevkey !=NULL && prevbutton !=NULL) + { + scanKeys(); + } + */ + + //scanKeys(); + keysd = keysDown(); + keysu = keysUp(); + short ax = 0, v = 0, h = 0; + if ((keysd & KEY_UP)) { + ax = 1; + v = -10; + SDL_PrivateJoystickAxis(joystick, ax, v); + prevkey = KEY_UP; + } //fprintf(stderr,"KEY_UP\n");} + if ((keysd & KEY_DOWN)) { + ax = 1; + v = 10; + SDL_PrivateJoystickAxis(joystick, ax, v); + prevkey = KEY_DOWN; + } //fprintf(stderr,"KEY_DOWN\n");} + if ((keysd & KEY_LEFT)) { + ax = 0; + h = -10; + SDL_PrivateJoystickAxis(joystick, ax, h); + prevkey = KEY_LEFT; + } //fprintf(stderr,"KEY_LEFT\n");} + if ((keysd & KEY_RIGHT)) { + ax = 0; + h = 10; + SDL_PrivateJoystickAxis(joystick, ax, h); + prevkey = KEY_RIGHT; + } //fprintf(stderr,"KEY_RIGHT\n");} + if ((keysu & KEY_UP)) { + ax = 1; + v = 0; + SDL_PrivateJoystickAxis(joystick, ax, v); + prevkey = NULL; + } //fprintf(stderr,"KEY_UP\n");} + if ((keysu & KEY_DOWN)) { + ax = 1; + v = 0; + SDL_PrivateJoystickAxis(joystick, ax, v); + prevkey = NULL; + } //fprintf(stderr,"KEY_DOWN\n");} + if ((keysu & KEY_LEFT)) { + ax = 0; + h = 0; + SDL_PrivateJoystickAxis(joystick, ax, h); + prevkey = NULL; + } //fprintf(stderr,"KEY_LEFT\n");} + if ((keysu & KEY_RIGHT)) { + ax = 0; + h = 0; + SDL_PrivateJoystickAxis(joystick, ax, h); + prevkey = NULL; + } //fprintf(stderr,"KEY_RIGHT\n");} + if ((keysd & KEY_A)) { + SDL_PrivateJoystickButton(joystick, 0, SDL_PRESSED); + prevbutton = KEY_A; + } + if ((keysd & KEY_B)) { + SDL_PrivateJoystickButton(joystick, 1, SDL_PRESSED); + prevbutton = KEY_B; + } + if ((keysd & KEY_X)) { + SDL_PrivateJoystickButton(joystick, 2, SDL_PRESSED); + prevbutton = KEY_X; + } + if ((keysd & KEY_Y)) { + SDL_PrivateJoystickButton(joystick, 3, SDL_PRESSED); + prevbutton = KEY_Y; + } + if ((keysd & KEY_SELECT)) { + SDL_PrivateJoystickButton(joystick, 6, SDL_PRESSED); + prevbutton = KEY_SELECT; + } + if ((keysd & KEY_START)) { + SDL_PrivateJoystickButton(joystick, 7, SDL_PRESSED); + prevbutton = KEY_START; + } + if ((keysd & KEY_L)) { + SDL_PrivateJoystickButton(joystick, 4, SDL_PRESSED); + prevbutton = KEY_L; + } + if ((keysd & KEY_R)) { + SDL_PrivateJoystickButton(joystick, 5, SDL_PRESSED); + prevbutton = KEY_R; + } + if ((keysu & KEY_A)) { + SDL_PrivateJoystickButton(joystick, 0, SDL_RELEASED); + prevbutton = NULL; + } + if ((keysu & KEY_B)) { + SDL_PrivateJoystickButton(joystick, 1, SDL_RELEASED); + prevbutton = NULL; + } + if ((keysu & KEY_X)) { + SDL_PrivateJoystickButton(joystick, 2, SDL_RELEASED); + prevbutton = NULL; + } + if ((keysu & KEY_Y)) { + SDL_PrivateJoystickButton(joystick, 3, SDL_RELEASED); + prevbutton = NULL; + } + if ((keysu & KEY_SELECT)) { + SDL_PrivateJoystickButton(joystick, 6, SDL_RELEASED); + prevbutton = NULL; + } + if ((keysu & KEY_START)) { + SDL_PrivateJoystickButton(joystick, 7, SDL_RELEASED); + prevbutton = NULL; + } + if ((keysu & KEY_L)) { + SDL_PrivateJoystickButton(joystick, 4, SDL_RELEASED); + prevbutton = NULL; + } + if ((keysu & KEY_R)) { + SDL_PrivateJoystickButton(joystick, 5, SDL_RELEASED); + prevbutton = NULL; + } + } /* Function to close a joystick after use */ -void SDL_SYS_JoystickClose(SDL_Joystick *joystick) +void +SDL_SYS_JoystickClose(SDL_Joystick * joystick) { } /* Function to perform any system-specific joystick related cleanup */ -void SDL_SYS_JoystickQuit(void) +void +SDL_SYS_JoystickQuit(void) { } - diff -r 6e4669f4db49 -r c3e7c0698cbb src/thread/nds/SDL_syscond.c --- a/src/thread/nds/SDL_syscond.c Tue Jun 10 06:57:57 2008 +0000 +++ b/src/thread/nds/SDL_syscond.c Thu Jun 12 02:38:49 2008 +0000 @@ -22,7 +22,7 @@ #ifdef SAVE_RCSID static char rcsid = - "@(#) $Id: SDL_syscond.c,v 1.2 2001/04/26 16:50:18 hercules Exp $"; + "@(#) $Id: SDL_syscond.c,v 1.2 2001/04/26 16:50:18 hercules Exp $"; #endif /* An implementation of condition variables using semaphores and mutexes */ @@ -39,107 +39,111 @@ struct SDL_cond { - SDL_mutex *lock; - int waiting; - int signals; - SDL_sem *wait_sem; - SDL_sem *wait_done; + SDL_mutex *lock; + int waiting; + int signals; + SDL_sem *wait_sem; + SDL_sem *wait_done; }; /* Create a condition variable */ -SDL_cond * SDL_CreateCond(void) +SDL_cond * +SDL_CreateCond(void) { - SDL_cond *cond; + SDL_cond *cond; - cond = (SDL_cond *) malloc(sizeof(SDL_cond)); - if ( cond ) { - cond->lock = SDL_CreateMutex(); - cond->wait_sem = SDL_CreateSemaphore(0); - cond->wait_done = SDL_CreateSemaphore(0); - cond->waiting = cond->signals = 0; - if ( ! cond->lock || ! cond->wait_sem || ! cond->wait_done ) { - SDL_DestroyCond(cond); - cond = NULL; - } - } else { - SDL_OutOfMemory(); - } - return(cond); + cond = (SDL_cond *) malloc(sizeof(SDL_cond)); + if (cond) { + cond->lock = SDL_CreateMutex(); + cond->wait_sem = SDL_CreateSemaphore(0); + cond->wait_done = SDL_CreateSemaphore(0); + cond->waiting = cond->signals = 0; + if (!cond->lock || !cond->wait_sem || !cond->wait_done) { + SDL_DestroyCond(cond); + cond = NULL; + } + } else { + SDL_OutOfMemory(); + } + return (cond); } /* Destroy a condition variable */ -void SDL_DestroyCond(SDL_cond *cond) +void +SDL_DestroyCond(SDL_cond * cond) { - if ( cond ) { - if ( cond->wait_sem ) { - SDL_DestroySemaphore(cond->wait_sem); - } - if ( cond->wait_done ) { - SDL_DestroySemaphore(cond->wait_done); - } - if ( cond->lock ) { - SDL_DestroyMutex(cond->lock); - } - free(cond); - } + if (cond) { + if (cond->wait_sem) { + SDL_DestroySemaphore(cond->wait_sem); + } + if (cond->wait_done) { + SDL_DestroySemaphore(cond->wait_done); + } + if (cond->lock) { + SDL_DestroyMutex(cond->lock); + } + free(cond); + } } /* Restart one of the threads that are waiting on the condition variable */ -int SDL_CondSignal(SDL_cond *cond) +int +SDL_CondSignal(SDL_cond * cond) { - if ( ! cond ) { - SDL_SetError("Passed a NULL condition variable"); - return -1; - } + if (!cond) { + SDL_SetError("Passed a NULL condition variable"); + return -1; + } - /* If there are waiting threads not already signalled, then - signal the condition and wait for the thread to respond. - */ - SDL_LockMutex(cond->lock); - if ( cond->waiting > cond->signals ) { - ++cond->signals; - SDL_SemPost(cond->wait_sem); - SDL_UnlockMutex(cond->lock); - SDL_SemWait(cond->wait_done); - } else { - SDL_UnlockMutex(cond->lock); - } + /* If there are waiting threads not already signalled, then + signal the condition and wait for the thread to respond. + */ + SDL_LockMutex(cond->lock); + if (cond->waiting > cond->signals) { + ++cond->signals; + SDL_SemPost(cond->wait_sem); + SDL_UnlockMutex(cond->lock); + SDL_SemWait(cond->wait_done); + } else { + SDL_UnlockMutex(cond->lock); + } - return 0; + return 0; } /* Restart all threads that are waiting on the condition variable */ -int SDL_CondBroadcast(SDL_cond *cond) +int +SDL_CondBroadcast(SDL_cond * cond) { - if ( ! cond ) { - SDL_SetError("Passed a NULL condition variable"); - return -1; - } + if (!cond) { + SDL_SetError("Passed a NULL condition variable"); + return -1; + } - /* If there are waiting threads not already signalled, then - signal the condition and wait for the thread to respond. - */ - SDL_LockMutex(cond->lock); - if ( cond->waiting > cond->signals ) { - int i, num_waiting; + /* If there are waiting threads not already signalled, then + signal the condition and wait for the thread to respond. + */ + SDL_LockMutex(cond->lock); + if (cond->waiting > cond->signals) { + int i, num_waiting; - num_waiting = (cond->waiting - cond->signals); - cond->signals = cond->waiting; - for ( i=0; iwait_sem); - } - /* Now all released threads are blocked here, waiting for us. - Collect them all (and win fabulous prizes!) :-) - */ - SDL_UnlockMutex(cond->lock); - for ( i=0; iwait_done); - } - } else { - SDL_UnlockMutex(cond->lock); - } + num_waiting = (cond->waiting - cond->signals); + cond->signals = cond->waiting; + for (i = 0; i < num_waiting; ++i) { + SDL_SemPost(cond->wait_sem); + } + /* Now all released threads are blocked here, waiting for us. + Collect them all (and win fabulous prizes!) :-) + */ + SDL_UnlockMutex(cond->lock); + for (i = 0; i < num_waiting; ++i) { + SDL_SemWait(cond->wait_done); + } + } else { + SDL_UnlockMutex(cond->lock); + } - return 0; + return 0; } /* Wait on the condition variable for at most 'ms' milliseconds. @@ -162,62 +166,64 @@ ... SDL_UnlockMutex(lock); */ -int SDL_CondWaitTimeout(SDL_cond *cond, SDL_mutex *mutex, Uint32 ms) +int +SDL_CondWaitTimeout(SDL_cond * cond, SDL_mutex * mutex, Uint32 ms) { - int retval; + int retval; - if ( ! cond ) { - SDL_SetError("Passed a NULL condition variable"); - return -1; - } + if (!cond) { + SDL_SetError("Passed a NULL condition variable"); + return -1; + } - /* Obtain the protection mutex, and increment the number of waiters. - This allows the signal mechanism to only perform a signal if there - are waiting threads. - */ - SDL_LockMutex(cond->lock); - ++cond->waiting; - SDL_UnlockMutex(cond->lock); + /* Obtain the protection mutex, and increment the number of waiters. + This allows the signal mechanism to only perform a signal if there + are waiting threads. + */ + SDL_LockMutex(cond->lock); + ++cond->waiting; + SDL_UnlockMutex(cond->lock); - /* Unlock the mutex, as is required by condition variable semantics */ - SDL_UnlockMutex(mutex); + /* Unlock the mutex, as is required by condition variable semantics */ + SDL_UnlockMutex(mutex); - /* Wait for a signal */ - if ( ms == SDL_MUTEX_MAXWAIT ) { - retval = SDL_SemWait(cond->wait_sem); - } else { - retval = SDL_SemWaitTimeout(cond->wait_sem, ms); - } + /* Wait for a signal */ + if (ms == SDL_MUTEX_MAXWAIT) { + retval = SDL_SemWait(cond->wait_sem); + } else { + retval = SDL_SemWaitTimeout(cond->wait_sem, ms); + } - /* Let the signaler know we have completed the wait, otherwise - the signaler can race ahead and get the condition semaphore - if we are stopped between the mutex unlock and semaphore wait, - giving a deadlock. See the following URL for details: - http://www-classic.be.com/aboutbe/benewsletter/volume_III/Issue40.html - */ - SDL_LockMutex(cond->lock); - if ( cond->signals > 0 ) { - /* If we timed out, we need to eat a condition signal */ - if ( retval > 0 ) { - SDL_SemWait(cond->wait_sem); - } - /* We always notify the signal thread that we are done */ - SDL_SemPost(cond->wait_done); + /* Let the signaler know we have completed the wait, otherwise + the signaler can race ahead and get the condition semaphore + if we are stopped between the mutex unlock and semaphore wait, + giving a deadlock. See the following URL for details: + http://www-classic.be.com/aboutbe/benewsletter/volume_III/Issue40.html + */ + SDL_LockMutex(cond->lock); + if (cond->signals > 0) { + /* If we timed out, we need to eat a condition signal */ + if (retval > 0) { + SDL_SemWait(cond->wait_sem); + } + /* We always notify the signal thread that we are done */ + SDL_SemPost(cond->wait_done); - /* Signal handshake complete */ - --cond->signals; - } - --cond->waiting; - SDL_UnlockMutex(cond->lock); + /* Signal handshake complete */ + --cond->signals; + } + --cond->waiting; + SDL_UnlockMutex(cond->lock); - /* Lock the mutex, as is required by condition variable semantics */ - SDL_LockMutex(mutex); + /* Lock the mutex, as is required by condition variable semantics */ + SDL_LockMutex(mutex); - return retval; + return retval; } /* Wait on the condition variable forever */ -int SDL_CondWait(SDL_cond *cond, SDL_mutex *mutex) +int +SDL_CondWait(SDL_cond * cond, SDL_mutex * mutex) { - return SDL_CondWaitTimeout(cond, mutex, SDL_MUTEX_MAXWAIT); + return SDL_CondWaitTimeout(cond, mutex, SDL_MUTEX_MAXWAIT); } diff -r 6e4669f4db49 -r c3e7c0698cbb src/thread/nds/SDL_syscond_c.h --- a/src/thread/nds/SDL_syscond_c.h Tue Jun 10 06:57:57 2008 +0000 +++ b/src/thread/nds/SDL_syscond_c.h Thu Jun 12 02:38:49 2008 +0000 @@ -22,6 +22,5 @@ #ifdef SAVE_RCSID static char rcsid = - "@(#) $Id: SDL_syscond_c.h,v 1.2 2001/04/26 16:50:18 hercules Exp $"; + "@(#) $Id: SDL_syscond_c.h,v 1.2 2001/04/26 16:50:18 hercules Exp $"; #endif - diff -r 6e4669f4db49 -r c3e7c0698cbb src/thread/nds/SDL_sysmutex.c --- a/src/thread/nds/SDL_sysmutex.c Tue Jun 10 06:57:57 2008 +0000 +++ b/src/thread/nds/SDL_sysmutex.c Thu Jun 12 02:38:49 2008 +0000 @@ -22,7 +22,7 @@ #ifdef SAVE_RCSID static char rcsid = - "@(#) $Id: SDL_sysmutex.c,v 1.2 2001/04/26 16:50:18 hercules Exp $"; + "@(#) $Id: SDL_sysmutex.c,v 1.2 2001/04/26 16:50:18 hercules Exp $"; #endif /* An implementation of mutexes using semaphores */ @@ -35,103 +35,108 @@ #include "SDL_systhread_c.h" -struct SDL_mutex { - int recursive; - Uint32 owner; - SDL_sem *sem; +struct SDL_mutex +{ + int recursive; + Uint32 owner; + SDL_sem *sem; }; /* Create a mutex */ -SDL_mutex *SDL_CreateMutex(void) +SDL_mutex * +SDL_CreateMutex(void) { - SDL_mutex *mutex; + SDL_mutex *mutex; - /* Allocate mutex memory */ - mutex = (SDL_mutex *)malloc(sizeof(*mutex)); - if ( mutex ) { - /* Create the mutex semaphore, with initial value 1 */ - mutex->sem = SDL_CreateSemaphore(1); - mutex->recursive = 0; - mutex->owner = 0; - if ( ! mutex->sem ) { - free(mutex); - mutex = NULL; - } - } else { - SDL_OutOfMemory(); - } - return mutex; + /* Allocate mutex memory */ + mutex = (SDL_mutex *) malloc(sizeof(*mutex)); + if (mutex) { + /* Create the mutex semaphore, with initial value 1 */ + mutex->sem = SDL_CreateSemaphore(1); + mutex->recursive = 0; + mutex->owner = 0; + if (!mutex->sem) { + free(mutex); + mutex = NULL; + } + } else { + SDL_OutOfMemory(); + } + return mutex; } /* Free the mutex */ -void SDL_DestroyMutex(SDL_mutex *mutex) +void +SDL_DestroyMutex(SDL_mutex * mutex) { - if ( mutex ) { - if ( mutex->sem ) { - SDL_DestroySemaphore(mutex->sem); - } - free(mutex); - } + if (mutex) { + if (mutex->sem) { + SDL_DestroySemaphore(mutex->sem); + } + free(mutex); + } } /* Lock the semaphore */ -int SDL_mutexP(SDL_mutex *mutex) +int +SDL_mutexP(SDL_mutex * mutex) { #ifdef DISABLE_THREADS - return 0; + return 0; #else - Uint32 this_thread; + Uint32 this_thread; - if ( mutex == NULL ) { - SDL_SetError("Passed a NULL mutex"); - return -1; - } + if (mutex == NULL) { + SDL_SetError("Passed a NULL mutex"); + return -1; + } - this_thread = SDL_ThreadID(); - if ( mutex->owner == this_thread ) { - ++mutex->recursive; - } else { - /* The order of operations is important. - We set the locking thread id after we obtain the lock - so unlocks from other threads will fail. - */ - SDL_SemWait(mutex->sem); - mutex->owner = this_thread; - mutex->recursive = 0; - } + this_thread = SDL_ThreadID(); + if (mutex->owner == this_thread) { + ++mutex->recursive; + } else { + /* The order of operations is important. + We set the locking thread id after we obtain the lock + so unlocks from other threads will fail. + */ + SDL_SemWait(mutex->sem); + mutex->owner = this_thread; + mutex->recursive = 0; + } - return 0; + return 0; #endif /* DISABLE_THREADS */ } /* Unlock the mutex */ -int SDL_mutexV(SDL_mutex *mutex) +int +SDL_mutexV(SDL_mutex * mutex) { #ifdef DISABLE_THREADS - return 0; + return 0; #else - if ( mutex == NULL ) { - SDL_SetError("Passed a NULL mutex"); - return -1; - } + if (mutex == NULL) { + SDL_SetError("Passed a NULL mutex"); + return -1; + } - /* If we don't own the mutex, we can't unlock it */ - if ( SDL_ThreadID() != mutex->owner ) { - SDL_SetError("mutex not owned by this thread"); - return -1; - } + /* If we don't own the mutex, we can't unlock it */ + if (SDL_ThreadID() != mutex->owner) { + SDL_SetError("mutex not owned by this thread"); + return -1; + } - if ( mutex->recursive ) { - --mutex->recursive; - } else { - /* The order of operations is important. - First reset the owner so another thread doesn't lock - the mutex and set the ownership before we reset it, - then release the lock semaphore. - */ - mutex->owner = 0; - SDL_SemPost(mutex->sem); - } - return 0; + if (mutex->recursive) { + --mutex->recursive; + } else { + /* The order of operations is important. + First reset the owner so another thread doesn't lock + the mutex and set the ownership before we reset it, + then release the lock semaphore. + */ + mutex->owner = 0; + SDL_SemPost(mutex->sem); + } + return 0; #endif /* DISABLE_THREADS */ } diff -r 6e4669f4db49 -r c3e7c0698cbb src/thread/nds/SDL_sysmutex_c.h --- a/src/thread/nds/SDL_sysmutex_c.h Tue Jun 10 06:57:57 2008 +0000 +++ b/src/thread/nds/SDL_sysmutex_c.h Thu Jun 12 02:38:49 2008 +0000 @@ -22,6 +22,5 @@ #ifdef SAVE_RCSID static char rcsid = - "@(#) $Id: SDL_sysmutex_c.h,v 1.2 2001/04/26 16:50:18 hercules Exp $"; + "@(#) $Id: SDL_sysmutex_c.h,v 1.2 2001/04/26 16:50:18 hercules Exp $"; #endif - diff -r 6e4669f4db49 -r c3e7c0698cbb src/thread/nds/SDL_syssem.c --- a/src/thread/nds/SDL_syssem.c Tue Jun 10 06:57:57 2008 +0000 +++ b/src/thread/nds/SDL_syssem.c Thu Jun 12 02:38:49 2008 +0000 @@ -22,7 +22,7 @@ #ifdef SAVE_RCSID static char rcsid = - "@(#) $Id: SDL_syssem.c,v 1.2 2001/04/26 16:50:18 hercules Exp $"; + "@(#) $Id: SDL_syssem.c,v 1.2 2001/04/26 16:50:18 hercules Exp $"; #endif /* An implementation of semaphores using mutexes and condition variables */ @@ -37,178 +37,192 @@ #ifdef DISABLE_THREADS -SDL_sem *SDL_CreateSemaphore(Uint32 initial_value) +SDL_sem * +SDL_CreateSemaphore(Uint32 initial_value) { - SDL_SetError("SDL not configured with thread support"); - return (SDL_sem *)0; + SDL_SetError("SDL not configured with thread support"); + return (SDL_sem *) 0; } -void SDL_DestroySemaphore(SDL_sem *sem) +void +SDL_DestroySemaphore(SDL_sem * sem) { - return; + return; } -int SDL_SemTryWait(SDL_sem *sem) +int +SDL_SemTryWait(SDL_sem * sem) { - SDL_SetError("SDL not configured with thread support"); - return -1; + SDL_SetError("SDL not configured with thread support"); + return -1; } -int SDL_SemWaitTimeout(SDL_sem *sem, Uint32 timeout) +int +SDL_SemWaitTimeout(SDL_sem * sem, Uint32 timeout) { - SDL_SetError("SDL not configured with thread support"); - return -1; + SDL_SetError("SDL not configured with thread support"); + return -1; } -int SDL_SemWait(SDL_sem *sem) +int +SDL_SemWait(SDL_sem * sem) { - SDL_SetError("SDL not configured with thread support"); - return -1; + SDL_SetError("SDL not configured with thread support"); + return -1; } -Uint32 SDL_SemValue(SDL_sem *sem) +Uint32 +SDL_SemValue(SDL_sem * sem) { - return 0; + return 0; } -int SDL_SemPost(SDL_sem *sem) +int +SDL_SemPost(SDL_sem * sem) { - SDL_SetError("SDL not configured with thread support"); - return -1; + SDL_SetError("SDL not configured with thread support"); + return -1; } #else struct SDL_semaphore { - Uint32 count; - Uint32 waiters_count; - SDL_mutex *count_lock; - SDL_cond *count_nonzero; + Uint32 count; + Uint32 waiters_count; + SDL_mutex *count_lock; + SDL_cond *count_nonzero; }; -SDL_sem *SDL_CreateSemaphore(Uint32 initial_value) +SDL_sem * +SDL_CreateSemaphore(Uint32 initial_value) { - SDL_sem *sem; + SDL_sem *sem; - sem = (SDL_sem *)malloc(sizeof(*sem)); - if ( ! sem ) { - SDL_OutOfMemory(); - return(0); - } - sem->count = initial_value; - sem->waiters_count = 0; + sem = (SDL_sem *) malloc(sizeof(*sem)); + if (!sem) { + SDL_OutOfMemory(); + return (0); + } + sem->count = initial_value; + sem->waiters_count = 0; - sem->count_lock = SDL_CreateMutex(); - sem->count_nonzero = SDL_CreateCond(); - if ( ! sem->count_lock || ! sem->count_nonzero ) { - SDL_DestroySemaphore(sem); - return(0); - } + sem->count_lock = SDL_CreateMutex(); + sem->count_nonzero = SDL_CreateCond(); + if (!sem->count_lock || !sem->count_nonzero) { + SDL_DestroySemaphore(sem); + return (0); + } - return(sem); + return (sem); } /* WARNING: You cannot call this function when another thread is using the semaphore. */ -void SDL_DestroySemaphore(SDL_sem *sem) +void +SDL_DestroySemaphore(SDL_sem * sem) { - if ( sem ) { - sem->count = 0xFFFFFFFF; - while ( sem->waiters_count > 0) { - SDL_CondSignal(sem->count_nonzero); - SDL_Delay(10); - } - SDL_DestroyCond(sem->count_nonzero); - SDL_mutexP(sem->count_lock); - SDL_mutexV(sem->count_lock); - SDL_DestroyMutex(sem->count_lock); - free(sem); - } + if (sem) { + sem->count = 0xFFFFFFFF; + while (sem->waiters_count > 0) { + SDL_CondSignal(sem->count_nonzero); + SDL_Delay(10); + } + SDL_DestroyCond(sem->count_nonzero); + SDL_mutexP(sem->count_lock); + SDL_mutexV(sem->count_lock); + SDL_DestroyMutex(sem->count_lock); + free(sem); + } } -int SDL_SemTryWait(SDL_sem *sem) +int +SDL_SemTryWait(SDL_sem * sem) { - int retval; + int retval; - if ( ! sem ) { - SDL_SetError("Passed a NULL semaphore"); - return -1; - } + if (!sem) { + SDL_SetError("Passed a NULL semaphore"); + return -1; + } - retval = SDL_MUTEX_TIMEDOUT; - SDL_LockMutex(sem->count_lock); - if ( sem->count > 0 ) { - --sem->count; - retval = 0; - } - SDL_UnlockMutex(sem->count_lock); + retval = SDL_MUTEX_TIMEDOUT; + SDL_LockMutex(sem->count_lock); + if (sem->count > 0) { + --sem->count; + retval = 0; + } + SDL_UnlockMutex(sem->count_lock); - return retval; + return retval; } -int SDL_SemWaitTimeout(SDL_sem *sem, Uint32 timeout) +int +SDL_SemWaitTimeout(SDL_sem * sem, Uint32 timeout) { - int retval; + int retval; - if ( ! sem ) { - SDL_SetError("Passed a NULL semaphore"); - return -1; - } + if (!sem) { + SDL_SetError("Passed a NULL semaphore"); + return -1; + } - /* A timeout of 0 is an easy case */ - if ( timeout == 0 ) { - return SDL_SemTryWait(sem); - } + /* A timeout of 0 is an easy case */ + if (timeout == 0) { + return SDL_SemTryWait(sem); + } - SDL_LockMutex(sem->count_lock); - ++sem->waiters_count; - retval = 0; - while ( (sem->count == 0) && (retval != SDL_MUTEX_TIMEDOUT) ) { - retval = SDL_CondWaitTimeout(sem->count_nonzero, - sem->count_lock, timeout); - } - --sem->waiters_count; - --sem->count; - SDL_UnlockMutex(sem->count_lock); + SDL_LockMutex(sem->count_lock); + ++sem->waiters_count; + retval = 0; + while ((sem->count == 0) && (retval != SDL_MUTEX_TIMEDOUT)) { + retval = SDL_CondWaitTimeout(sem->count_nonzero, + sem->count_lock, timeout); + } + --sem->waiters_count; + --sem->count; + SDL_UnlockMutex(sem->count_lock); - return retval; + return retval; } -int SDL_SemWait(SDL_sem *sem) +int +SDL_SemWait(SDL_sem * sem) { - return SDL_SemWaitTimeout(sem, SDL_MUTEX_MAXWAIT); + return SDL_SemWaitTimeout(sem, SDL_MUTEX_MAXWAIT); } -Uint32 SDL_SemValue(SDL_sem *sem) +Uint32 +SDL_SemValue(SDL_sem * sem) { - Uint32 value; - - value = 0; - if ( sem ) { - SDL_LockMutex(sem->count_lock); - value = sem->count; - SDL_UnlockMutex(sem->count_lock); - } - return value; + Uint32 value; + + value = 0; + if (sem) { + SDL_LockMutex(sem->count_lock); + value = sem->count; + SDL_UnlockMutex(sem->count_lock); + } + return value; } -int SDL_SemPost(SDL_sem *sem) +int +SDL_SemPost(SDL_sem * sem) { - if ( ! sem ) { - SDL_SetError("Passed a NULL semaphore"); - return -1; - } + if (!sem) { + SDL_SetError("Passed a NULL semaphore"); + return -1; + } - SDL_LockMutex(sem->count_lock); - if ( sem->waiters_count > 0 ) { - SDL_CondSignal(sem->count_nonzero); - } - ++sem->count; - SDL_UnlockMutex(sem->count_lock); + SDL_LockMutex(sem->count_lock); + if (sem->waiters_count > 0) { + SDL_CondSignal(sem->count_nonzero); + } + ++sem->count; + SDL_UnlockMutex(sem->count_lock); - return 0; + return 0; } #endif /* DISABLE_THREADS */ diff -r 6e4669f4db49 -r c3e7c0698cbb src/thread/nds/SDL_syssem_c.h --- a/src/thread/nds/SDL_syssem_c.h Tue Jun 10 06:57:57 2008 +0000 +++ b/src/thread/nds/SDL_syssem_c.h Thu Jun 12 02:38:49 2008 +0000 @@ -22,6 +22,5 @@ #ifdef SAVE_RCSID static char rcsid = - "@(#) $Id: SDL_syssem_c.h,v 1.2 2001/04/26 16:50:18 hercules Exp $"; + "@(#) $Id: SDL_syssem_c.h,v 1.2 2001/04/26 16:50:18 hercules Exp $"; #endif - diff -r 6e4669f4db49 -r c3e7c0698cbb src/thread/nds/SDL_systhread.c --- a/src/thread/nds/SDL_systhread.c Tue Jun 10 06:57:57 2008 +0000 +++ b/src/thread/nds/SDL_systhread.c Thu Jun 12 02:38:49 2008 +0000 @@ -22,7 +22,7 @@ #ifdef SAVE_RCSID static char rcsid = - "@(#) $Id: SDL_systhread.c,v 1.2 2001/04/26 16:50:18 hercules Exp $"; + "@(#) $Id: SDL_systhread.c,v 1.2 2001/04/26 16:50:18 hercules Exp $"; #endif /* Thread management routines for SDL */ @@ -31,29 +31,33 @@ #include "SDL_thread.h" #include "SDL_systhread.h" -int SDL_SYS_CreateThread(SDL_Thread *thread, void *args) +int +SDL_SYS_CreateThread(SDL_Thread * thread, void *args) { - SDL_SetError("Threads are not supported on this platform"); - return(-1); + SDL_SetError("Threads are not supported on this platform"); + return (-1); } -void SDL_SYS_SetupThread(void) +void +SDL_SYS_SetupThread(void) { - return; + return; } -Uint32 SDL_ThreadID(void) +Uint32 +SDL_ThreadID(void) { - return(0); + return (0); } -void SDL_SYS_WaitThread(SDL_Thread *thread) +void +SDL_SYS_WaitThread(SDL_Thread * thread) { - return; + return; } -void SDL_SYS_KillThread(SDL_Thread *thread) +void +SDL_SYS_KillThread(SDL_Thread * thread) { - return; + return; } - diff -r 6e4669f4db49 -r c3e7c0698cbb src/video/dummy/SDL_nullrender.c --- a/src/video/dummy/SDL_nullrender.c Tue Jun 10 06:57:57 2008 +0000 +++ b/src/video/dummy/SDL_nullrender.c Thu Jun 12 02:38:49 2008 +0000 @@ -174,12 +174,18 @@ (SDL_DUMMY_RenderData *) renderer->driverdata; /* Send the data to the display */ - if (SDL_getenv("SDL_VIDEO_DUMMY_SAVE_FRAMES")) { + /*if (SDL_getenv("SDL_VIDEO_DUMMY_SAVE_FRAMES")) */ { char file[128]; SDL_snprintf(file, sizeof(file), "SDL_window%d-%8.8d.bmp", renderer->window, ++frame_number); SDL_SaveBMP(data->screens[data->current_screen], file); } + /*{ + int i; + for (i = 0; i < 256 * 192; ++i) + ((Uint16 *)0x6800000)[i] + = ((Uint16 *)(data->screens[data->current_screen]->pixels))[i]; + }*/ /* Update the flipping chain, if any */ if (renderer->info.flags & SDL_RENDERER_PRESENTFLIP2) { diff -r 6e4669f4db49 -r c3e7c0698cbb src/video/dummy/SDL_nullvideo.c --- a/src/video/dummy/SDL_nullvideo.c Tue Jun 10 06:57:57 2008 +0000 +++ b/src/video/dummy/SDL_nullvideo.c Thu Jun 12 02:38:49 2008 +0000 @@ -63,7 +63,7 @@ return (1); } - return (0); + return (1); } static void diff -r 6e4669f4db49 -r c3e7c0698cbb src/video/nds/SDL_ndsrender.c --- a/src/video/nds/SDL_ndsrender.c Tue Jun 10 06:57:57 2008 +0000 +++ b/src/video/nds/SDL_ndsrender.c Thu Jun 12 02:38:49 2008 +0000 @@ -35,20 +35,20 @@ /* SDL surface based renderer implementation */ static SDL_Renderer *SDL_NDS_CreateRenderer(SDL_Window * window, - Uint32 flags); + Uint32 flags); static int SDL_NDS_RenderFill(SDL_Renderer * renderer, Uint8 r, Uint8 g, - Uint8 b, Uint8 a, const SDL_Rect * rect); + Uint8 b, Uint8 a, const SDL_Rect * rect); static int SDL_NDS_RenderCopy(SDL_Renderer * renderer, - SDL_Texture * texture, - const SDL_Rect * srcrect, - const SDL_Rect * dstrect); + SDL_Texture * texture, + const SDL_Rect * srcrect, + const SDL_Rect * dstrect); static void SDL_NDS_RenderPresent(SDL_Renderer * renderer); static void SDL_NDS_DestroyRenderer(SDL_Renderer * renderer); SDL_RenderDriver SDL_NDS_RenderDriver = { SDL_NDS_CreateRenderer, - { "nds", SDL_RENDERER_PRESENTCOPY } + {"nds", SDL_RENDERER_PRESENTCOPY} /* (SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY | SDL_RENDERER_PRESENTFLIP2 | SDL_RENDERER_PRESENTFLIP3 | SDL_RENDERER_PRESENTDISCARD),*/ @@ -73,14 +73,15 @@ Uint32 Rmask = 0x7C00, Gmask = 0x03E0, Bmask = 0x001F, Amask = 0x8000; printf("SDL_NDS_CreateRenderer(window, 0x%x)\n", flags); - printf(" window: (%d,%d), %dx%d\n", window->x, window->y, window->w, window->h); + printf(" window: (%d,%d), %dx%d\n", window->x, window->y, window->w, + window->h); /* hard coded this to ARGB1555 for now - if (!SDL_PixelFormatEnumToMasks - (displayMode->format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) { - SDL_SetError("Unknown display format"); - return NULL; - }*/ + if (!SDL_PixelFormatEnumToMasks + (displayMode->format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) { + SDL_SetError("Unknown display format"); + return NULL; + } */ renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer)); if (!renderer) { @@ -118,7 +119,8 @@ } for (i = 0; i < n; ++i) { data->screens[i] = - SDL_CreateRGBSurface(0, 256, 192, bpp, Rmask, Gmask, Bmask, Amask); + SDL_CreateRGBSurface(0, 256, 192, bpp, Rmask, Gmask, Bmask, + Amask); if (!data->screens[i]) { SDL_NDS_DestroyRenderer(renderer); return NULL; @@ -131,17 +133,11 @@ #if 0 #define blarg (data->screens[0]) printf("hello?\n"); - if(!data || !(data->screens) || !blarg) { + if (!data || !(data->screens) || !blarg) { printf("they're null.\n"); } else { printf("not null.\n"); - printf("%d\n%d\n%d\n%d\n%x\n%x\n%x\n%x\n", - blarg->w, blarg->h, blarg->pitch, - blarg->format->BitsPerPixel, - blarg->format->Rmask, - blarg->format->Gmask, - blarg->format->Bmask, - (u32)(blarg->pixels)); /* ARGH WHY DOESN'T THIS PRINT AT ALL? */ + printf("%d\n%d\n%d\n%d\n%x\n%x\n%x\n%x\n", blarg->w, blarg->h, blarg->pitch, blarg->format->BitsPerPixel, blarg->format->Rmask, blarg->format->Gmask, blarg->format->Bmask, (u32) (blarg->pixels)); /* ARGH WHY DOESN'T THIS PRINT AT ALL? */ printf("hurr\n"); } #undef blarg @@ -151,7 +147,7 @@ static int SDL_NDS_RenderFill(SDL_Renderer * renderer, Uint8 r, Uint8 g, Uint8 b, - Uint8 a, const SDL_Rect * rect) + Uint8 a, const SDL_Rect * rect) { SDL_NDS_RenderData *data = (SDL_NDS_RenderData *) renderer->driverdata; SDL_Surface *target = data->screens[data->current_screen]; @@ -164,26 +160,29 @@ } /* this is mainly for testing stuff to put a surface where I can see it */ -void sdlds_surf2vram(SDL_Surface *s) { +void +sdlds_surf2vram(SDL_Surface * s) +{ int i; - for(i = 0; i < 256*192; ++i) { - ((u16*)VRAM_A)[i] = ((u16*)(s->pixels))[i]; + for (i = 0; i < 256 * 192; ++i) { + ((u16 *) VRAM_A)[i] = ((u16 *) (s->pixels))[i]; } } static int SDL_NDS_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, - const SDL_Rect * srcrect, const SDL_Rect * dstrect) + const SDL_Rect * srcrect, const SDL_Rect * dstrect) { - SDL_NDS_RenderData *data = - (SDL_NDS_RenderData *) renderer->driverdata; + SDL_NDS_RenderData *data = (SDL_NDS_RenderData *) renderer->driverdata; SDL_Window *window = SDL_GetWindowFromID(renderer->window); SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); printf("SDL_NDS_RenderCopy(renderer, texture, srcrect, dstrect)\n"); printf(" renderer: %s\n", renderer->info.name); printf(" texture: %dx%d\n", texture->w, texture->h); - printf(" srcrect: (%d,%d), %dx%d\n", srcrect->x, srcrect->y, srcrect->w, srcrect->h); - printf(" dstrect: (%d,%d), %dx%d\n", dstrect->x, dstrect->y, dstrect->w, dstrect->h); + printf(" srcrect: (%d,%d), %dx%d\n", srcrect->x, srcrect->y, srcrect->w, + srcrect->h); + printf(" dstrect: (%d,%d), %dx%d\n", dstrect->x, dstrect->y, dstrect->w, + dstrect->h); if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { SDL_Surface *target = data->screens[data->current_screen]; @@ -201,37 +200,38 @@ SDL_Rect real_dstrect = *dstrect; printf("Rmask %x Gmask %x Bmask %x Amask %x\n" "width %d, height %d, pitch %d\nbpp %d, pixels %x\n", - surface->format->Rmask, surface->format->Gmask, - surface->format->Bmask, surface->format->Amask, - surface->w, surface->h, surface->pitch, - surface->format->BitsPerPixel, (u32)(surface->pixels)); + surface->format->Rmask, surface->format->Gmask, + surface->format->Bmask, surface->format->Amask, + surface->w, surface->h, surface->pitch, + surface->format->BitsPerPixel, (u32) (surface->pixels)); sdlds_surf2vram(surface); return SDL_LowerBlit(surface, &real_srcrect, target, &real_dstrect); } #if 0 /* previous attempt to copy it directly to vram */ - SDL_Surface *surface = (SDL_Surface *) texture->driverdata; - int sx = srcrect->x, sy = srcrect->y, sw = srcrect->w, sh = srcrect->h; - int dx = dstrect->x, dy = dstrect->y, dw = dstrect->w, dh = dstrect->h; - int si,sj, di,dj; - /*printf("DEBUG: still alive!\n");*/ - for(sj=0, dj=0; sjpixels)[(sj+sy)*(surface->w) + si+sx]; - } + SDL_Surface *surface = (SDL_Surface *) texture->driverdata; + int sx = srcrect->x, sy = srcrect->y, sw = srcrect->w, sh = srcrect->h; + int dx = dstrect->x, dy = dstrect->y, dw = dstrect->w, dh = dstrect->h; + int si, sj, di, dj; + /*printf("DEBUG: still alive!\n"); */ + for (sj = 0, dj = 0; sj < sh && dj < dh; ++sj, ++dj) { + for (si = 0, di = 0; si < sw && di < dw; ++si, ++di) { + ((uint16 *) VRAM_A)[(dj + dy) * 256 + di + dx] + = ((Uint16 *) surface->pixels)[(sj + sy) * (surface->w) + si + + sx]; } - /*printf("DEBUG: still alive!\n");*/ } - return 0; + /*printf("DEBUG: still alive!\n"); */ +} + +return 0; #endif } static void SDL_NDS_RenderPresent(SDL_Renderer * renderer) { - SDL_NDS_RenderData *data = - (SDL_NDS_RenderData *) renderer->driverdata; + SDL_NDS_RenderData *data = (SDL_NDS_RenderData *) renderer->driverdata; printf("SDL_NDS_RenderPresent(renderer)\n"); printf(" renderer: %s\n", renderer->info.name); @@ -240,18 +240,25 @@ #if 0 /*testing to see if rectangles drawn get copied right*/ { - SDL_Rect ra; - ra.x=0; ra.y=0; ra.w=256; ra.h=192; - SDL_FillRect(data->screens[data->current_screen], &ra, 0x250); - ra.x=32; ra.y=32; ra.w=192; ra.h=128; - SDL_FillRect(data->screens[data->current_screen], &ra, - SDL_MapRGBA(data->screens[data->current_screen]->format, - 255,255,255,255)); - } + SDL_Rect ra; + ra.x = 0; + ra.y = 0; + ra.w = 256; + ra.h = 192; + SDL_FillRect(data->screens[data->current_screen], &ra, 0x250); + ra.x = 32; + ra.y = 32; + ra.w = 192; + ra.h = 128; + SDL_FillRect(data->screens[data->current_screen], &ra, + SDL_MapRGBA(data->screens[data->current_screen]->format, + 255, 255, 255, 255)); + } /*okay so this works but why not when I do it in the main()? for some reason the screen I get from screen=SDL_SetVideoMode(...) doesn't get copied to renderer->driverdata? */ - for(i = 0; i < 30; ++i) swiWaitForVBlank(); /* delay for debug purpose */ + for (i = 0; i < 30; ++i) + swiWaitForVBlank(); /* delay for debug purpose */ #endif sdlds_surf2vram(data->screens[data->current_screen]); diff -r 6e4669f4db49 -r c3e7c0698cbb src/video/nds/SDL_ndsvideo.c --- a/src/video/nds/SDL_ndsvideo.c Tue Jun 10 06:57:57 2008 +0000 +++ b/src/video/nds/SDL_ndsvideo.c Thu Jun 12 02:38:49 2008 +0000 @@ -63,7 +63,7 @@ NDS_Available(void) { const char *envr = SDL_getenv("SDL_VIDEODRIVER"); - printf("NDS_Available()\n"); + printf("NDS_Available()\n"); return (1); } @@ -77,7 +77,7 @@ NDS_CreateDevice(int devindex) { SDL_VideoDevice *device; - printf("NDS_CreateDevice(%d)\n", devindex); + printf("NDS_CreateDevice(%d)\n", devindex); /* Initialize all variables that we clean on shutdown */ device = (SDL_VideoDevice *) SDL_calloc(1, sizeof(SDL_VideoDevice)); @@ -95,7 +95,7 @@ device->SetDisplayMode = NDS_SetDisplayMode; device->PumpEvents = NDS_PumpEvents; - device->num_displays = 2; /* DS = dual screens */ + device->num_displays = 2; /* DS = dual screens */ device->free = NDS_DeleteDevice; @@ -114,7 +114,8 @@ int i; /* simple 256x192x16x60 for now */ - mode.w = 256; mode.h = 192; + mode.w = 256; + mode.h = 192; mode.format = SDL_PIXELFORMAT_ARGB1555; mode.refresh_rate = 60; mode.driverdata = NULL; @@ -125,43 +126,49 @@ SDL_zero(mode); SDL_AddDisplayMode(0, &mode); - /* hackish stuff to get things up and running for now, and for a console */ - powerON(POWER_ALL); - videoSetMode(MODE_FB0); - videoSetModeSub(MODE_0_2D | DISPLAY_BG0_ACTIVE); /* debug text on sub */ - vramSetBankA(VRAM_A_LCD); - vramSetBankC(VRAM_C_SUB_BG); - irqInit(); - irqEnable(IRQ_VBLANK); + /* hackish stuff to get things up and running for now, and for a console */ + powerON(POWER_ALL); + videoSetMode(MODE_FB0); + videoSetModeSub(MODE_0_2D | DISPLAY_BG0_ACTIVE); /* debug text on sub */ + vramSetBankA(VRAM_A_LCD); + vramSetBankC(VRAM_C_SUB_BG); + irqInit(); + irqEnable(IRQ_VBLANK); /* set up console for debug text 'n stuff */ - SUB_BG0_CR = BG_MAP_BASE(31); BG_PALETTE_SUB[255] = RGB15(31,31,31); - consoleInitDefault((u16*)SCREEN_BASE_BLOCK_SUB(31), - (u16*)CHAR_BASE_BLOCK_SUB(0), 16); - for(i = 0; i < 256*192; ++i) { - ((u16*)VRAM_A)[i] = i; - } - for(i = 0; i < 60; ++i) swiWaitForVBlank(); - /*NDS_SetDisplayMode(_this, &mode);*/ + SUB_BG0_CR = BG_MAP_BASE(31); + BG_PALETTE_SUB[255] = RGB15(31, 31, 31); + consoleInitDefault((u16 *) SCREEN_BASE_BLOCK_SUB(31), + (u16 *) CHAR_BASE_BLOCK_SUB(0), 16); + for (i = 0; i < 256 * 192; ++i) { + ((u16 *) VRAM_A)[i] = i; + } + for (i = 0; i < 60; ++i) + swiWaitForVBlank(); + + /*NDS_SetDisplayMode(_this, &mode); */ return 0; } static int NDS_SetDisplayMode(_THIS, SDL_DisplayMode * mode) { - /* right now this function is just hard-coded for 256x192 ARGB1555 */ + /* right now this function is just hard-coded for 256x192 ARGB1555 */ #if 0 - videoSetMode(MODE_5_2D | DISPLAY_BG3_ACTIVE); /* display on main core */ - videoSetModeSub(MODE_0_2D | DISPLAY_BG0_ACTIVE); /* debug text on sub */ + videoSetMode(MODE_5_2D | DISPLAY_BG3_ACTIVE); /* display on main core */ + videoSetModeSub(MODE_0_2D | DISPLAY_BG0_ACTIVE); /* debug text on sub */ vramSetMainBanks(VRAM_A_MAIN_BG_0x06000000, VRAM_B_LCD, VRAM_C_SUB_BG, VRAM_D_LCD); /* maps well to the 256x192 screen anyway. note: need VRAM_B for bigger */ BG3_CR = BG_BMP16_256x256; /* affine transformation matrix. nothing too fancy here */ - BG3_XDX = 0x100; BG3_XDY = 0; - BG3_YDX = 0; BG3_YDY = 0x100; - /* x/y position */ - BG3_CX = 0; BG3_CY = 0; + BG3_XDX = 0x100; + BG3_XDY = 0; + BG3_YDX = 0; + BG3_YDY = 0x100; + /* x/y position */ + BG3_CX = 0; + BG3_CY = 0; #endif return 0; }