# HG changeset patch
# User Sam Lantinga <slouken@libsdl.org>
# Date 1219849803 0
# Node ID 204be4fc2726d1ce4a7725600d60c2229d99dea0
# Parent  dd25eabe441c8b2b6feb128988ea2fd2ccf43599
Final merge of Google Summer of Code 2008 work...

Port SDL 1.3 to the Nintendo DS
by Darren Alton, mentored by Sam Lantinga

diff -r dd25eabe441c -r 204be4fc2726 Makefile.ds
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Makefile.ds	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,129 @@
+
+#LibSDL 1.3 porting and enhancements by Darren Alton (lifning)
+#LibSDL 1.2.9 DS porting by Troy Davis(GPF)
+
+ifeq ($(strip $(DEVKITPRO)),)
+$(error "Please set DEVKITPRO in your environment (available from http://www.devkitpro.org). export DEVKITPRO=<path to>devkitPro")
+endif
+ifeq ($(strip $(DEVKITARM)),)
+DEVKITARM = $(DEVKITPRO)/devkitARM
+endif
+PATH := $(PATH):$(DEVKITARM)/bin
+
+CC = arm-eabi-gcc
+AR = arm-eabi-ar
+RANLIB = arm-eabi-ranlib
+
+#ifdef GL
+#DEFS += -DSDL_VIDEO_OPENGL=1
+#TARGET = libSDL_gl.a
+#else
+TARGET = libSDL.a
+#endif
+
+#CFLAGS=$(DEFS) -Iinclude
+CFLAGS	=	-mthumb -mthumb-interwork \
+		-march=armv5te -mtune=arm946e-s \
+		-O2 -Wall -Wwrite-strings -Wpointer-arith -Wconversion \
+		-DARM9 -D__NDS__ -I$(DEVKITPRO)/libnds/include -DENABLE_NDS -DNO_SIGNAL_H -DDISABLE_THREADS -DPACKAGE=\"SDL\" -DVERSION=\"1.3\" -DHAVE_ALLOCA_H=1 -DHAVE_ALLOCA=1 \
+		-Iinclude -Isrc -Isrc/audio -Isrc/cdrom -Isrc/endian -Isrc/events -Isrc/joystick -Isrc/thread/nds -Isrc/thread -Isrc/timer -Isrc/video
+
+#src/audio/disk/SDL_diskaudio.c \
+#src/audio/dummy/SDL_dummyaudio.c \
+
+SRCS = \
+src/SDL.c \
+src/SDL_compat.c \
+src/SDL_error.c \
+src/SDL_fatal.c \
+src/audio/nds/SDL_ndsaudio.c \
+src/audio/SDL_audio.c \
+src/audio/SDL_audiocvt.c \
+src/audio/SDL_audiodev.c \
+src/audio/SDL_audiotypecvt.c \
+src/audio/SDL_mixer.c \
+src/audio/SDL_mixer_m68k.c \
+src/audio/SDL_mixer_MMX.c \
+src/audio/SDL_mixer_MMX_VC.c \
+src/audio/SDL_wave.c \
+src/cdrom/dummy/SDL_syscdrom.c \
+src/cdrom/SDL_cdrom.c \
+src/cpuinfo/SDL_cpuinfo.c \
+src/events/SDL_events.c \
+src/events/SDL_keyboard.c \
+src/events/SDL_mouse.c \
+src/events/SDL_quit.c \
+src/events/SDL_windowevents.c \
+src/file/SDL_rwops.c \
+src/joystick/nds/SDL_sysjoystick.c \
+src/joystick/SDL_joystick.c \
+src/stdlib/SDL_getenv.c \
+src/stdlib/SDL_iconv.c \
+src/stdlib/SDL_malloc.c \
+src/stdlib/SDL_qsort.c \
+src/stdlib/SDL_stdlib.c \
+src/stdlib/SDL_string.c \
+src/thread/SDL_thread.c \
+src/thread/nds/SDL_syscond.c \
+src/thread/nds/SDL_sysmutex.c \
+src/thread/nds/SDL_syssem.c \
+src/thread/nds/SDL_systhread.c \
+src/timer/nds/SDL_systimer.c \
+src/timer/SDL_timer.c \
+src/video/nds/SDL_ndsevents.c \
+src/video/nds/SDL_ndsrender.c \
+src/video/nds/SDL_ndsvideo.c \
+src/video/dummy/SDL_nullevents.c \
+src/video/dummy/SDL_nullrender.c \
+src/video/dummy/SDL_nullvideo.c \
+src/video/SDL_blit_0.c \
+src/video/SDL_blit_1.c \
+src/video/SDL_blit_A.c \
+src/video/SDL_blit_auto.c \
+src/video/SDL_blit.c \
+src/video/SDL_blit_copy.c \
+src/video/SDL_blit_N.c \
+src/video/SDL_blit_slow.c \
+src/video/SDL_bmp.c \
+src/video/SDL_fill.c \
+src/video/SDL_gamma.c \
+src/video/SDL_pixels.c \
+src/video/SDL_rect.c \
+src/video/SDL_renderer_gl.c \
+src/video/SDL_renderer_sw.c \
+src/video/SDL_RLEaccel.c \
+src/video/SDL_stretch.c \
+src/video/SDL_surface.c \
+src/video/SDL_video.c \
+src/video/SDL_yuv_mmx.c \
+src/video/SDL_yuv_sw.c \
+
+OBJS = $(SRCS:.c=.o)
+
+TEST = \
+test/nds-test-progs/general/general.nds \
+test/nds-test-progs/sprite/sprite.nds \
+test/nds-test-progs/sprite2/sprite2.nds \
+
+
+all: $(TARGET)
+
+$(TARGET): copy_config \
+	$(OBJS)
+	$(AR) rc $(TARGET) $(OBJS)
+	-@ ($(RANLIB) $@ || true) >/dev/null 2>&1
+
+install: $(TARGET)
+	@cp libSDL.a $(DEVKITPRO)/libnds/lib/
+	@mkdir -p $(DEVKITPRO)/libnds/include/SDL/
+	@cp include/*.h $(DEVKITPRO)/libnds/include/SDL/
+
+nds_test:
+	$(MAKE) -C test/nds-test-progs
+
+copy_config:
+	@cp include/SDL_config.h.default include/SDL_config.h
+
+clean:
+	rm -f include/SDL_config.h $(OBJS)
+
diff -r dd25eabe441c -r 204be4fc2726 include/SDL_config.h.default
--- a/include/SDL_config.h.default	Wed Aug 27 13:37:19 2008 +0000
+++ b/include/SDL_config.h.default	Wed Aug 27 15:10:03 2008 +0000
@@ -26,7 +26,9 @@
 #include "SDL_platform.h"
 
 /* Add any platform that doesn't build using the configure system */
-#if defined(__DREAMCAST__)
+#if defined(__NINTENDODS__)
+#include "SDL_config_nintendods.h"
+#elif defined(__DREAMCAST__)
 #include "SDL_config_dreamcast.h"
 #elif defined(__MACOSX__)
 #include "SDL_config_macosx.h"
diff -r dd25eabe441c -r 204be4fc2726 include/SDL_config.h.in
--- a/include/SDL_config.h.in	Wed Aug 27 13:37:19 2008 +0000
+++ b/include/SDL_config.h.in	Wed Aug 27 15:10:03 2008 +0000
@@ -177,6 +177,7 @@
 #undef SDL_AUDIO_DRIVER_MMEAUDIO
 #undef SDL_AUDIO_DRIVER_NAS
 #undef SDL_AUDIO_DRIVER_NAS_DYNAMIC
+#undef SDL_AUDIO_DRIVER_NDS
 #undef SDL_AUDIO_DRIVER_OSS
 #undef SDL_AUDIO_DRIVER_OSS_SOUNDCARD_H
 #undef SDL_AUDIO_DRIVER_PAUDIO
@@ -211,6 +212,7 @@
 #undef SDL_JOYSTICK_IOKIT
 #undef SDL_JOYSTICK_LINUX
 #undef SDL_JOYSTICK_MINT
+#undef SDL_JOYSTICK_NDS
 #undef SDL_JOYSTICK_OS2
 #undef SDL_JOYSTICK_RISCOS
 #undef SDL_JOYSTICK_WINMM
@@ -233,6 +235,7 @@
 /* Enable various threading systems */
 #undef SDL_THREAD_BEOS
 #undef SDL_THREAD_DC
+#undef SDL_THREAD_NDS
 #undef SDL_THREAD_OS2
 #undef SDL_THREAD_PTH
 #undef SDL_THREAD_PTHREAD
@@ -246,6 +249,7 @@
 #undef SDL_TIMER_DC
 #undef SDL_TIMER_DUMMY
 #undef SDL_TIMER_MINT
+#undef SDL_TIMER_NDS
 #undef SDL_TIMER_OS2
 #undef SDL_TIMER_RISCOS
 #undef SDL_TIMER_UNIX
@@ -263,6 +267,7 @@
 #undef SDL_VIDEO_DRIVER_GEM
 #undef SDL_VIDEO_DRIVER_IPOD
 #undef SDL_VIDEO_DRIVER_NANOX
+#undef SDL_VIDEO_DRIVER_NDS
 #undef SDL_VIDEO_DRIVER_OS2FS
 #undef SDL_VIDEO_DRIVER_PHOTON
 #undef SDL_VIDEO_DRIVER_PS2GS
diff -r dd25eabe441c -r 204be4fc2726 include/SDL_config_nintendods.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/include/SDL_config_nintendods.h	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,119 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+#ifndef _SDL_config_nintendods_h
+#define _SDL_config_nintendods_h
+
+#include "SDL_platform.h"
+
+/* This is a set of defines to configure the SDL features */
+
+typedef signed char int8_t;
+typedef unsigned char uint8_t;
+typedef signed short int16_t;
+typedef unsigned short uint16_t;
+typedef signed int int32_t;
+typedef unsigned int uint32_t;
+typedef signed long long int64_t;
+typedef unsigned long long uint64_t;
+
+/* LiF: __PTRDIFF_TYPE__ was causing errors of conflicting typedefs with the
+   <stdint.h> shipping with devkitARM.  copied a similar ifdef from it. */
+#ifndef __PTRDIFF_TYPE__
+typedef unsigned long uintptr_t;
+#else
+typedef unsigned __PTRDIFF_TYPE__ uintptr_t;
+#endif
+
+
+#define SDL_HAS_64BIT_TYPE	1
+
+/* Useful headers */
+#define HAVE_SYS_TYPES_H	1
+#define HAVE_STDIO_H	1
+#define STDC_HEADERS	1
+#define HAVE_STRING_H	1
+#define HAVE_CTYPE_H	1
+
+/* C library functions */
+#define HAVE_MALLOC	1
+#define HAVE_CALLOC	1
+#define HAVE_REALLOC	1
+#define HAVE_FREE	1
+#define HAVE_ALLOCA	1
+#define HAVE_GETENV	1
+#define HAVE_PUTENV	1
+#define HAVE_QSORT	1
+#define HAVE_ABS	1
+#define HAVE_BCOPY	1
+#define HAVE_MEMSET	1
+#define HAVE_MEMCPY	1
+#define HAVE_MEMMOVE	1
+#define HAVE_MEMCMP	1
+#define HAVE_STRLEN	1
+#define HAVE_STRDUP	1
+#define HAVE_INDEX	1
+#define HAVE_RINDEX	1
+#define HAVE_STRCHR	1
+#define HAVE_STRRCHR	1
+#define HAVE_STRSTR	1
+#define HAVE_STRTOL	1
+#define HAVE_STRTOD	1
+#define HAVE_ATOI	1
+#define HAVE_ATOF	1
+#define HAVE_STRCMP	1
+#define HAVE_STRNCMP	1
+#define HAVE_STRICMP	1
+#define HAVE_STRCASECMP	1
+#define HAVE_SSCANF	1
+#define HAVE_SNPRINTF	1
+#define HAVE_VSNPRINTF	1
+
+/* DS isn't that sophisticated */
+#define LACKS_SYS_MMAN_H 1
+
+/* Enable various audio drivers */
+#define SDL_AUDIO_DRIVER_NDS	1
+/*#define SDL_AUDIO_DRIVER_DUMMY	1 TODO: uncomment this later*/
+
+/* DS doesn't have optical media */
+#define SDL_CDROM_DISABLED	1
+
+/* Enable various input drivers */
+#define SDL_JOYSTICK_NDS	1
+/*#define SDL_JOYSTICK_DUMMY	1 TODO: uncomment this later*/
+
+/* DS has no dynamic linking afaik */
+#define SDL_LOADSO_DISABLED	1
+
+/* Enable various threading systems */
+/*#define SDL_THREAD_NDS	1*/
+#define SDL_THREADS_DISABLED	1
+
+/* Enable various timer systems */
+#define SDL_TIMER_NDS	1
+
+/* Enable various video drivers */
+#define SDL_VIDEO_DRIVER_NDS	1
+/*#define SDL_VIDEO_DRIVER_DUMMY	1 TODO: uncomment this later*/
+
+#endif /* _SDL_config_nintendods_h */
diff -r dd25eabe441c -r 204be4fc2726 include/SDL_pixels.h
--- a/include/SDL_pixels.h	Wed Aug 27 13:37:19 2008 +0000
+++ b/include/SDL_pixels.h	Wed Aug 27 15:10:03 2008 +0000
@@ -146,12 +146,18 @@
     SDL_PIXELFORMAT_RGB555 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XRGB,
                                SDL_PACKEDLAYOUT_1555, 15, 2),
+    SDL_PIXELFORMAT_BGR555 =
+        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XBGR,
+                               SDL_PACKEDLAYOUT_1555, 15, 2),
     SDL_PIXELFORMAT_ARGB4444 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_ARGB,
                                SDL_PACKEDLAYOUT_4444, 16, 2),
     SDL_PIXELFORMAT_ARGB1555 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_ARGB,
                                SDL_PACKEDLAYOUT_1555, 16, 2),
+    SDL_PIXELFORMAT_ABGR1555 =
+        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_ABGR,
+                               SDL_PACKEDLAYOUT_1555, 16, 2),
     SDL_PIXELFORMAT_RGB565 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XRGB,
                                SDL_PACKEDLAYOUT_565, 16, 2),
diff -r dd25eabe441c -r 204be4fc2726 include/SDL_platform.h
--- a/include/SDL_platform.h	Wed Aug 27 13:37:19 2008 +0000
+++ b/include/SDL_platform.h	Wed Aug 27 15:10:03 2008 +0000
@@ -97,4 +97,9 @@
 #define __WIN32__	1
 #endif
 
+#if defined(__NDS__)
+#undef __NINTENDODS__
+#define __NINTENDODS__	1
+#endif
+
 #endif /* _SDL_platform_h */
diff -r dd25eabe441c -r 204be4fc2726 include/SDL_stdinc.h
--- a/include/SDL_stdinc.h	Wed Aug 27 13:37:19 2008 +0000
+++ b/include/SDL_stdinc.h	Wed Aug 27 15:10:03 2008 +0000
@@ -147,8 +147,12 @@
 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 */
 SDL_COMPILE_TIME_ASSERT(uint64, sizeof(Uint64) == 8);
 SDL_COMPILE_TIME_ASSERT(sint64, sizeof(Sint64) == 8);
+#endif
 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
 /* Check to make sure enums are the size of ints, for structure packing.
@@ -162,12 +166,14 @@
 #endif
 
 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
+#ifndef __NINTENDODS__          /* TODO: include/SDL_stdinc.h:174: error: size of array 'SDL_dummy_enum' is negative */
 typedef enum
 {
     DUMMY_ENUM_VALUE
 } SDL_DUMMY_ENUM;
 
 SDL_COMPILE_TIME_ASSERT(enum, sizeof(SDL_DUMMY_ENUM) == sizeof(int));
+#endif
 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
 #include "begin_code.h"
@@ -425,6 +431,9 @@
 #ifdef HAVE_WCSLEN
 #define SDL_wcslen      wcslen
 #else
+#if !defined(wchar_t) && defined(__NINTENDODS__)
+#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 dd25eabe441c -r 204be4fc2726 src/SDL_compat.c
--- a/src/SDL_compat.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/SDL_compat.c	Wed Aug 27 15:10:03 2008 +0000
@@ -693,6 +693,7 @@
         SDL_UpdateRects(screen, 1, &rect);
     }
 }
+
 void
 SDL_UpdateRects(SDL_Surface * screen, int numrects, SDL_Rect * rects)
 {
diff -r dd25eabe441c -r 204be4fc2726 src/SDL_error.c
--- a/src/SDL_error.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/SDL_error.c	Wed Aug 27 15:10:03 2008 +0000
@@ -180,8 +180,8 @@
                 case 's':
                     len =
                         SDL_snprintf(msg, maxlen, tmp,
-                                     SDL_LookupString(error->
-                                                      args[argi++].buf));
+                                     SDL_LookupString(error->args[argi++].
+                                                      buf));
                     msg += len;
                     maxlen -= len;
                     break;
diff -r dd25eabe441c -r 204be4fc2726 src/audio/SDL_audio.c
--- a/src/audio/SDL_audio.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/audio/SDL_audio.c	Wed Aug 27 15:10:03 2008 +0000
@@ -70,6 +70,7 @@
 extern AudioBootStrap DCAUD_bootstrap;
 extern AudioBootStrap MMEAUDIO_bootstrap;
 extern AudioBootStrap DART_bootstrap;
+extern AudioBootStrap NDSAUD_bootstrap;
 
 
 /* Available audio drivers */
@@ -145,6 +146,9 @@
 #if SDL_AUDIO_DRIVER_DART
     &DART_bootstrap,
 #endif
+#if SDL_AUDIO_DRIVER_NDS
+    &NDSAUD_bootstrap,
+#endif
     NULL
 };
 
@@ -167,31 +171,38 @@
 {
     return -1;
 }
+
 static void
 SDL_AudioThreadInit_Default(_THIS)
 {                               /* no-op. */
 }
+
 static void
 SDL_AudioWaitDevice_Default(_THIS)
 {                               /* no-op. */
 }
+
 static void
 SDL_AudioPlayDevice_Default(_THIS)
 {                               /* no-op. */
 }
+
 static Uint8 *
 SDL_AudioGetDeviceBuf_Default(_THIS)
 {
     return NULL;
 }
+
 static void
 SDL_AudioWaitDone_Default(_THIS)
 {                               /* no-op. */
 }
+
 static void
 SDL_AudioCloseDevice_Default(_THIS)
 {                               /* no-op. */
 }
+
 static void
 SDL_AudioDeinitialize_Default(void)
 {                               /* no-op. */
diff -r dd25eabe441c -r 204be4fc2726 src/audio/SDL_wave.c
--- a/src/audio/SDL_wave.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/audio/SDL_wave.c	Wed Aug 27 15:10:03 2008 +0000
@@ -462,8 +462,7 @@
         }
         /* 2 Uint32's for chunk header+len, plus the lenread */
         headerDiff += lenread + 2 * sizeof(Uint32);
-    }
-    while ((chunk.magic == FACT) || (chunk.magic == LIST));
+    } while ((chunk.magic == FACT) || (chunk.magic == LIST));
 
     /* Decode the audio data format */
     format = (WaveFMT *) chunk.data;
@@ -564,8 +563,7 @@
         *audio_buf = chunk.data;
         if (chunk.magic != DATA)
             headerDiff += lenread + 2 * sizeof(Uint32);
-    }
-    while (chunk.magic != DATA);
+    } while (chunk.magic != DATA);
     headerDiff += 2 * sizeof(Uint32);   /* for the data chunk and len */
 
     if (MS_ADPCM_encoded) {
diff -r dd25eabe441c -r 204be4fc2726 src/audio/alsa/SDL_alsa_audio.c
--- a/src/audio/alsa/SDL_alsa_audio.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/audio/alsa/SDL_alsa_audio.c	Wed Aug 27 15:10:03 2008 +0000
@@ -259,16 +259,19 @@
 {
     SWIZ6(Uint64);
 }
+
 static __inline__ void
 swizzle_alsa_channels_6_32bit(_THIS)
 {
     SWIZ6(Uint32);
 }
+
 static __inline__ void
 swizzle_alsa_channels_6_16bit(_THIS)
 {
     SWIZ6(Uint16);
 }
+
 static __inline__ void
 swizzle_alsa_channels_6_8bit(_THIS)
 {
diff -r dd25eabe441c -r 204be4fc2726 src/audio/bsd/SDL_bsdaudio.c
--- a/src/audio/bsd/SDL_bsdaudio.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/audio/bsd/SDL_bsdaudio.c	Wed Aug 27 15:10:03 2008 +0000
@@ -270,8 +270,7 @@
             || ((written < 0) && ((errno == 0) || (errno == EAGAIN)))) {
             SDL_Delay(1);       /* Let a little CPU time go by */
         }
-    }
-    while (p < written);
+    } while (p < written);
 
     /* If timer synchronization is enabled, set the next write frame */
     if (this->hidden->frame_ticks) {
diff -r dd25eabe441c -r 204be4fc2726 src/audio/dart/SDL_dart.c
--- a/src/audio/dart/SDL_dart.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/audio/dart/SDL_dart.c	Wed Aug 27 15:10:03 2008 +0000
@@ -62,8 +62,8 @@
                 pBufDesc->iBufferUsage = BUFFER_EMPTY;
                 // And notify DART feeder thread that it will have to work a bit.
                 if (pSDLAudioDevice)
-                    DosPostEventSem(pSDLAudioDevice->hidden->
-                                    hevAudioBufferPlayed);
+                    DosPostEventSem(pSDLAudioDevice->
+                                    hidden->hevAudioBufferPlayed);
             }
         }
     }
@@ -312,10 +312,11 @@
         (pMixBufferDesc) _this->hidden->pMixBuffers[iFreeBuf].ulUserParm;
     pBufDesc->iBufferUsage = BUFFER_USED;
     // Send it to DART to be queued
-    _this->hidden->MixSetupParms.pmixWrite(_this->hidden->MixSetupParms.
-                                           ulMixHandle,
-                                           &(_this->hidden->
-                                             pMixBuffers[iFreeBuf]), 1);
+    _this->hidden->MixSetupParms.pmixWrite(_this->hidden->
+                                           MixSetupParms.ulMixHandle,
+                                           &(_this->
+                                             hidden->pMixBuffers[iFreeBuf]),
+                                           1);
 
     _this->hidden->iLastPlayedBuf = iFreeBuf;
     iFreeBuf = (iFreeBuf + 1) % _this->hidden->iCurrNumBufs;
@@ -333,8 +334,8 @@
         if (_this->hidden) {
             iFreeBuf = _this->hidden->iNextFreeBuffer;
             pBufDesc =
-                (pMixBufferDesc) _this->hidden->pMixBuffers[iFreeBuf].
-                ulUserParm;
+                (pMixBufferDesc) _this->hidden->
+                pMixBuffers[iFreeBuf].ulUserParm;
 
             if (pBufDesc) {
                 if (pBufDesc->iBufferUsage == BUFFER_EMPTY) {
diff -r dd25eabe441c -r 204be4fc2726 src/audio/dma/SDL_dmaaudio.c
--- a/src/audio/dma/SDL_dmaaudio.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/audio/dma/SDL_dmaaudio.c	Wed Aug 27 15:10:03 2008 +0000
@@ -498,8 +498,7 @@
             this->enabled = 0;
             return (NULL);
         }
-    }
-    while (frame_ticks && (info.blocks < 1));
+    } while (frame_ticks && (info.blocks < 1));
 #ifdef DEBUG_AUDIO
     if (info.blocks > 1) {
         printf("Warning: audio underflow (%d frags)\n", info.blocks - 1);
diff -r dd25eabe441c -r 204be4fc2726 src/audio/esd/SDL_esdaudio.c
--- a/src/audio/esd/SDL_esdaudio.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/audio/esd/SDL_esdaudio.c	Wed Aug 27 15:10:03 2008 +0000
@@ -154,9 +154,8 @@
         if ((written < 0) && ((errno == 0) || (errno == EAGAIN))) {
             SDL_Delay(1);       /* Let a little CPU time go by */
         }
-    }
-    while ((written < 0) &&
-           ((errno == 0) || (errno == EAGAIN) || (errno == EINTR)));
+    } while ((written < 0) &&
+             ((errno == 0) || (errno == EAGAIN) || (errno == EINTR)));
 
     /* Set the next write frame */
     this->hidden->next_frame += this->hidden->frame_ticks;
diff -r dd25eabe441c -r 204be4fc2726 src/audio/nds/SDL_ndsaudio.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/audio/nds/SDL_ndsaudio.c	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,130 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+
+    This file written by Ryan C. Gordon (icculus@icculus.org)
+*/
+#include "SDL_config.h"
+
+/* Output audio to NDS */
+
+#include <nds.h>
+
+#include "SDL_audio.h"
+#include "../SDL_audio_c.h"
+#include "SDL_ndsaudio.h"
+
+static int
+NDSAUD_OpenDevice(_THIS, const char *devname, int iscapture)
+{
+    SDL_AudioFormat test_format = SDL_FirstAudioFormat(this->spec.format);
+    int valid_datatype = 0;
+
+    this->hidden = SDL_malloc(sizeof(*(this->hidden)));
+    if (!this->hidden) {
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+
+    while ((!valid_datatype) && (test_format)) {
+        this->spec.format = test_format;
+        switch (test_format) {
+        case AUDIO_S8:
+            /*case AUDIO_S16LSB: */
+            valid_datatype = 1;
+            break;
+        default:
+            test_format = SDL_NextAudioFormat();
+            break;
+        }
+    }
+
+    /* set the generic sound parameters */
+    setGenericSound(22050,      /* sample rate */
+                    127,        /* volume */
+                    64,         /* panning/balance */
+                    0);         /* sound format */
+
+    return 1;
+}
+
+static void
+NDSAUD_PlayDevice(_THIS)
+{
+    TransferSoundData *sound = SDL_malloc(sizeof(TransferSoundData));
+    if (!sound) {
+        SDL_OutOfMemory();
+    }
+
+    playGenericSound(this->hidden->mixbuf, this->hidden->mixlen);
+#if 0
+//    sound->data = this->hidden->mixbuf;/* pointer to raw audio data */
+//    sound->len = this->hidden->mixlen; /* size of raw data pointed to above */
+//    sound->rate = 22050; /* sample rate = 22050Hz */
+//    sound->vol = 127;    /* volume [0..127] for [min..max] */
+//    sound->pan = 64;     /* balance [0..127] for [left..right] */
+//    sound->format = 0;   /* 0 for 16-bit, 1 for 8-bit */
+//    playSound(sound);
+#endif
+}
+
+
+static Uint8 *
+NDSAUD_GetDeviceBuf(_THIS)
+{
+    return this->hidden->mixbuf;        /* is this right? */
+}
+
+static void
+NDSAUD_WaitDevice(_THIS)
+{
+    /* stub */
+}
+
+static void
+NDSAUD_CloseDevice(_THIS)
+{
+    /* stub */
+}
+
+static int
+NDSAUD_Init(SDL_AudioDriverImpl * impl)
+{
+    /* Set the function pointers */
+    impl->OpenDevice = NDSAUD_OpenDevice;
+    impl->PlayDevice = NDSAUD_PlayDevice;
+    impl->WaitDevice = NDSAUD_WaitDevice;
+    impl->GetDeviceBuf = NDSAUD_GetDeviceBuf;
+    impl->CloseDevice = NDSAUD_CloseDevice;
+
+    /* and the capabilities */
+    impl->HasCaptureSupport = 1;
+    impl->OnlyHasDefaultOutputDevice = 1;
+    impl->OnlyHasDefaultInputDevice = 1;
+
+    return 1;
+}
+
+AudioBootStrap NDSAUD_bootstrap = {
+    "nds", "SDL NDS audio driver", NDSAUD_Init, 0       /*1? */
+};
+
+/* vi: set ts=4 sw=4 expandtab: */
diff -r dd25eabe441c -r 204be4fc2726 src/audio/nds/SDL_ndsaudio.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/audio/nds/SDL_ndsaudio.h	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,44 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_ndsaudio_h
+#define _SDL_ndsaudio_h
+
+#include "../SDL_sysaudio.h"
+#include <nds/arm9/sound.h>
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData
+{
+    TransferSoundData *sound;
+    /* The file descriptor for the audio device */
+    Uint8 *mixbuf;
+    Uint32 mixlen;
+    Uint32 write_delay;
+    Uint32 initial_calls;
+};
+
+#endif /* _SDL_ndsaudio_h */
+/* vi: set ts=4 sw=4 expandtab: */
diff -r dd25eabe441c -r 204be4fc2726 src/audio/nto/SDL_nto_audio.c
--- a/src/audio/nto/SDL_nto_audio.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/audio/nto/SDL_nto_audio.c	Wed Aug 27 15:10:03 2008 +0000
@@ -154,8 +154,7 @@
             }
             break;
         }
-    }
-    while (1);
+    } while (1);
 }
 
 static void
@@ -213,8 +212,7 @@
             towrite -= written;
             pcmbuffer += written * this->spec.channels;
         }
-    }
-    while ((towrite > 0) && (this->enabled));
+    } while ((towrite > 0) && (this->enabled));
 
     /* If we couldn't write, assume fatal error for now */
     if (towrite != 0) {
diff -r dd25eabe441c -r 204be4fc2726 src/audio/paudio/SDL_paudio.c
--- a/src/audio/paudio/SDL_paudio.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/audio/paudio/SDL_paudio.c	Wed Aug 27 15:10:03 2008 +0000
@@ -208,9 +208,8 @@
         if ((written < 0) && ((errno == 0) || (errno == EAGAIN))) {
             SDL_Delay(1);       /* Let a little CPU time go by */
         }
-    }
-    while ((written < 0) &&
-           ((errno == 0) || (errno == EAGAIN) || (errno == EINTR)));
+    } while ((written < 0) &&
+             ((errno == 0) || (errno == EAGAIN) || (errno == EINTR)));
 
     /* If timer synchronization is enabled, set the next write frame */
     if (this->hidden->frame_ticks) {
diff -r dd25eabe441c -r 204be4fc2726 src/audio/ums/SDL_umsaudio.c
--- a/src/audio/ums/SDL_umsaudio.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/audio/ums/SDL_umsaudio.c	Wed Aug 27 15:10:03 2008 +0000
@@ -218,8 +218,7 @@
 #endif
             return;
         }
-    }
-    while (samplesToWrite > 0);
+    } while (samplesToWrite > 0);
 
     SDL_LockAudio();
     SDL_memcpy(&swpbuf, &this->hidden->playbuf, sizeof(UMSAudioTypes_Buffer));
@@ -326,8 +325,7 @@
         if (!success) {
             test_format = SDL_NextAudioFormat();
         }
-    }
-    while (!success && test_format);
+    } while (!success && test_format);
 
     if (success == 0) {
         SDL_SetError("Couldn't find any hardware audio formats");
diff -r dd25eabe441c -r 204be4fc2726 src/audio/windib/SDL_dibaudio.c
--- a/src/audio/windib/SDL_dibaudio.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/audio/windib/SDL_dibaudio.c	Wed Aug 27 15:10:03 2008 +0000
@@ -107,8 +107,8 @@
 Uint8 *
 WINWAVEOUT_GetDeviceBuf(_THIS)
 {
-    return (Uint8 *) (this->hidden->wavebuf[this->hidden->next_buffer].
-                      lpData);
+    return (Uint8 *) (this->hidden->
+                      wavebuf[this->hidden->next_buffer].lpData);
 }
 
 void
@@ -136,8 +136,7 @@
         if (left > 0) {
             SDL_Delay(100);
         }
-    }
-    while (left > 0);
+    } while (left > 0);
 }
 
 void
diff -r dd25eabe441c -r 204be4fc2726 src/audio/windx5/SDL_dx5audio.c
--- a/src/audio/windx5/SDL_dx5audio.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/audio/windx5/SDL_dx5audio.c	Wed Aug 27 15:10:03 2008 +0000
@@ -278,8 +278,9 @@
         IDirectSoundBuffer_Restore(this->hidden->mixbuf);
         result = IDirectSoundBuffer_Lock(this->hidden->mixbuf, cursor,
                                          this->hidden->mixlen,
-                                         (LPVOID *) & this->hidden->
-                                         locked_buf, &rawlen, NULL, &junk, 0);
+                                         (LPVOID *) & this->
+                                         hidden->locked_buf, &rawlen, NULL,
+                                         &junk, 0);
     }
     if (result != DS_OK) {
         SetDSerror("DirectSound Lock", result);
diff -r dd25eabe441c -r 204be4fc2726 src/cdrom/SDL_cdrom.c
--- a/src/cdrom/SDL_cdrom.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/cdrom/SDL_cdrom.c	Wed Aug 27 15:10:03 2008 +0000
@@ -44,6 +44,7 @@
     NULL,                       /* Eject */
     NULL,                       /* Close */
 };
+
 int SDL_numcds;
 
 int
diff -r dd25eabe441c -r 204be4fc2726 src/cdrom/aix/SDL_syscdrom.c
--- a/src/cdrom/aix/SDL_syscdrom.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/cdrom/aix/SDL_syscdrom.c	Wed Aug 27 15:10:03 2008 +0000
@@ -181,8 +181,7 @@
 #endif
             return;
         }
-    }
-    while (ret == 0);
+    } while (ret == 0);
 
 #ifdef DEBUG_CDROM
     fprintf(stderr, "Read %d vmount structures\n", ret);
@@ -211,8 +210,7 @@
         }
         ptr = (struct vmount *) ((char *) ptr + ptr->vmt_length);
         ret--;
-    }
-    while (ret > 0);
+    } while (ret > 0);
 
     free(buffer);
 }
@@ -247,8 +245,7 @@
                 }
             }
         }
-    }
-    while (ret == 0);
+    } while (ret == 0);
     ret = endfsent_r(&fsFile);
     if (ret != 0)
         return -1;
@@ -275,8 +272,7 @@
                 }
             }
         }
-    }
-    while (entry != NULL);
+    } while (entry != NULL);
     endfsent();
 #endif
 }
@@ -326,8 +322,7 @@
                 } else {
                     SDLcdrom = NULL;
                 }
-            }
-            while (SDLcdrom);
+            } while (SDLcdrom);
             SDL_stack_free(cdpath);
         }
 
diff -r dd25eabe441c -r 204be4fc2726 src/cdrom/beos/SDL_syscdrom.cc
--- a/src/cdrom/beos/SDL_syscdrom.cc	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/cdrom/beos/SDL_syscdrom.cc	Wed Aug 27 15:10:03 2008 +0000
@@ -193,8 +193,7 @@
                 } else {
                     SDLcdrom = NULL;
                 }
-            }
-            while (SDLcdrom);
+            } while (SDLcdrom);
             SDL_stack_free(cdpath);
         }
 
diff -r dd25eabe441c -r 204be4fc2726 src/cdrom/bsdi/SDL_syscdrom.c
--- a/src/cdrom/bsdi/SDL_syscdrom.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/cdrom/bsdi/SDL_syscdrom.c	Wed Aug 27 15:10:03 2008 +0000
@@ -286,8 +286,7 @@
                 } else {
                     SDLcdrom = NULL;
                 }
-            }
-            while (SDLcdrom);
+            } while (SDLcdrom);
             SDL_stack_free(cdpath);
         }
 
diff -r dd25eabe441c -r 204be4fc2726 src/cdrom/freebsd/SDL_syscdrom.c
--- a/src/cdrom/freebsd/SDL_syscdrom.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/cdrom/freebsd/SDL_syscdrom.c	Wed Aug 27 15:10:03 2008 +0000
@@ -176,8 +176,7 @@
                 } else {
                     SDLcdrom = NULL;
                 }
-            }
-            while (SDLcdrom);
+            } while (SDLcdrom);
             SDL_stack_free(cdpath);
         }
 
diff -r dd25eabe441c -r 204be4fc2726 src/cdrom/linux/SDL_syscdrom.c
--- a/src/cdrom/linux/SDL_syscdrom.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/cdrom/linux/SDL_syscdrom.c	Wed Aug 27 15:10:03 2008 +0000
@@ -312,8 +312,7 @@
                 } else {
                     SDLcdrom = NULL;
                 }
-            }
-            while (SDLcdrom);
+            } while (SDLcdrom);
             SDL_stack_free(cdpath);
         }
 
diff -r dd25eabe441c -r 204be4fc2726 src/cdrom/macosx/AudioFilePlayer.c
--- a/src/cdrom/macosx/AudioFilePlayer.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/cdrom/macosx/AudioFilePlayer.c	Wed Aug 27 15:10:03 2008 +0000
@@ -311,8 +311,7 @@
 
         /* Skip the chunk data */
         offset = chunk.ckSize;
-    }
-    while (chunk.ckID != 'SSND');
+    } while (chunk.ckID != 'SSND');
 
     /* Read the header of the SSND chunk. After this, we are positioned right
        at the start of the audio data. */
diff -r dd25eabe441c -r 204be4fc2726 src/cdrom/macosx/AudioFileReaderThread.c
--- a/src/cdrom/macosx/AudioFileReaderThread.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/cdrom/macosx/AudioFileReaderThread.c	Wed Aug 27 15:10:03 2008 +0000
@@ -335,9 +335,8 @@
         }
         /* construct pointer */
         char *writePtr = (char *) (theItem->GetFileBuffer(theItem) +
-                                   (theItem->
-                                    mWriteToFirstBuffer ? 0 : theItem->
-                                    mChunkSize));
+                                   (theItem->mWriteToFirstBuffer ? 0 :
+                                    theItem->mChunkSize));
 
         /* read data */
         result = theItem->Read(theItem, writePtr, &dataChunkSize);
@@ -486,8 +485,7 @@
     } else {
         *inOutDataSize = afm->mChunkSize;
         *inOutData =
-            afm->mReadFromFirstBuffer ? afm->mFileBuffer : (afm->
-                                                            mFileBuffer +
+            afm->mReadFromFirstBuffer ? afm->mFileBuffer : (afm->mFileBuffer +
                                                             afm->mChunkSize);
     }
 
diff -r dd25eabe441c -r 204be4fc2726 src/cdrom/macosx/CDPlayer.c
--- a/src/cdrom/macosx/CDPlayer.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/cdrom/macosx/CDPlayer.c	Wed Aug 27 15:10:03 2008 +0000
@@ -400,8 +400,7 @@
                 }
                 CFRelease(name);
             }
-        }
-        while (noErr == result);
+        } while (noErr == result);
         FSCloseIterator(iterator);
     }
 
diff -r dd25eabe441c -r 204be4fc2726 src/cdrom/openbsd/SDL_syscdrom.c
--- a/src/cdrom/openbsd/SDL_syscdrom.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/cdrom/openbsd/SDL_syscdrom.c	Wed Aug 27 15:10:03 2008 +0000
@@ -184,8 +184,7 @@
                 } else {
                     SDLcdrom = NULL;
                 }
-            }
-            while (SDLcdrom);
+            } while (SDLcdrom);
             SDL_stack_free(cdpath);
         }
 
diff -r dd25eabe441c -r 204be4fc2726 src/cdrom/osf/SDL_syscdrom.c
--- a/src/cdrom/osf/SDL_syscdrom.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/cdrom/osf/SDL_syscdrom.c	Wed Aug 27 15:10:03 2008 +0000
@@ -199,8 +199,7 @@
                 } else {
                     SDLcdrom = NULL;
                 }
-            }
-            while (SDLcdrom);
+            } while (SDLcdrom);
             SDL_stack_free(cdpath);
         }
 
diff -r dd25eabe441c -r 204be4fc2726 src/cdrom/qnx/SDL_syscdrom.c
--- a/src/cdrom/qnx/SDL_syscdrom.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/cdrom/qnx/SDL_syscdrom.c	Wed Aug 27 15:10:03 2008 +0000
@@ -184,8 +184,7 @@
                 } else {
                     SDLcdrom = NULL;
                 }
-            }
-            while (SDLcdrom);
+            } while (SDLcdrom);
             SDL_stack_free(cdpath);
         }
 
@@ -357,8 +356,7 @@
             devctlret = ENXIO;
             break;
         }
-    }
-    while ((devctlret == EAGAIN) || (devctlret == ESTALE));
+    } while ((devctlret == EAGAIN) || (devctlret == ESTALE));
 
     if (devctlret != 0) {
         if (devctlret == ENXIO) {
diff -r dd25eabe441c -r 204be4fc2726 src/events/SDL_events.c
--- a/src/events/SDL_events.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/events/SDL_events.c	Wed Aug 27 15:10:03 2008 +0000
@@ -73,6 +73,7 @@
         }
     }
 }
+
 void
 SDL_Unlock_EventThread(void)
 {
diff -r dd25eabe441c -r 204be4fc2726 src/events/default_cursor.h
--- a/src/events/default_cursor.h	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/events/default_cursor.h	Wed Aug 27 15:10:03 2008 +0000
@@ -51,6 +51,7 @@
     0x03, 0x00,
     0x00, 0x00
 };
+
 static unsigned char default_cmask[] = {
     0xC0, 0x00,
     0xE0, 0x00,
@@ -90,6 +91,7 @@
     0x03, 0x00,
     0x00, 0x00
 };
+
 static unsigned char default_cmask[] = {
     0x40, 0x00,
     0xE0, 0x00,
diff -r dd25eabe441c -r 204be4fc2726 src/file/SDL_rwops.c
--- a/src/file/SDL_rwops.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/file/SDL_rwops.c	Wed Aug 27 15:10:03 2008 +0000
@@ -28,6 +28,10 @@
 #include "SDL_endian.h"
 #include "SDL_rwops.h"
 
+#ifdef __NDS__
+/* include libfat headers for fatInitDefault(). */
+#include <fat.h>
+#endif /* __NDS__ */
 
 #ifdef __WIN32__
 
@@ -132,6 +136,7 @@
 
     return 0;                   /* ok */
 }
+
 static long SDLCALL
 win32_file_seek(SDL_RWops * context, long offset, int whence)
 {
@@ -173,6 +178,7 @@
     SDL_Error(SDL_EFSEEK);
     return -1;                  /* error */
 }
+
 static size_t SDLCALL
 win32_file_read(SDL_RWops * context, void *ptr, size_t size, size_t maxnum)
 {
@@ -226,6 +232,7 @@
     }
     return (total_read / size);
 }
+
 static size_t SDLCALL
 win32_file_write(SDL_RWops * context, const void *ptr, size_t size,
                  size_t num)
@@ -265,6 +272,7 @@
     nwritten = byte_written / size;
     return nwritten;
 }
+
 static int SDLCALL
 win32_file_close(SDL_RWops * context)
 {
@@ -298,6 +306,7 @@
         return (-1);
     }
 }
+
 static size_t SDLCALL
 stdio_read(SDL_RWops * context, void *ptr, size_t size, size_t maxnum)
 {
@@ -309,6 +318,7 @@
     }
     return (nread);
 }
+
 static size_t SDLCALL
 stdio_write(SDL_RWops * context, const void *ptr, size_t size, size_t num)
 {
@@ -320,6 +330,7 @@
     }
     return (nwrote);
 }
+
 static int SDLCALL
 stdio_close(SDL_RWops * context)
 {
@@ -368,6 +379,7 @@
     context->hidden.mem.here = newpos;
     return (context->hidden.mem.here - context->hidden.mem.base);
 }
+
 static size_t SDLCALL
 mem_read(SDL_RWops * context, void *ptr, size_t size, size_t maxnum)
 {
@@ -390,6 +402,7 @@
 
     return (total_bytes / size);
 }
+
 static size_t SDLCALL
 mem_write(SDL_RWops * context, const void *ptr, size_t size, size_t num)
 {
@@ -400,12 +413,14 @@
     context->hidden.mem.here += num * size;
     return (num);
 }
+
 static size_t SDLCALL
 mem_writeconst(SDL_RWops * context, const void *ptr, size_t size, size_t num)
 {
     SDL_SetError("Can't write to read-only memory");
     return (-1);
 }
+
 static int SDLCALL
 mem_close(SDL_RWops * context)
 {
@@ -463,6 +478,13 @@
 {
     SDL_RWops *rwops = NULL;
 
+#if 0
+/*#ifdef __NDS__*/
+    /* set it up so we can use stdio file function */
+    fatInitDefault();
+    printf("called fatInitDefault()");
+#endif /* __NDS__ */
+
     rwops = SDL_AllocRW();
     if (rwops != NULL) {
         rwops->seek = stdio_seek;
diff -r dd25eabe441c -r 204be4fc2726 src/joystick/darwin/SDL_sysjoystick.c
--- a/src/joystick/darwin/SDL_sysjoystick.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/joystick/darwin/SDL_sysjoystick.c	Wed Aug 27 15:10:03 2008 +0000
@@ -149,8 +149,8 @@
                 (*ppPlugInInterface)->QueryInterface(ppPlugInInterface,
                                                      CFUUIDGetUUIDBytes
                                                      (kIOHIDDeviceInterfaceID),
-                                                     (void *) &(pDevice->
-                                                                interface));
+                                                     (void *)
+                                                     &(pDevice->interface));
             if (S_OK != plugInResult)
                 HIDReportErrorNum
                     ("CouldnŐt query HID class device interface from plugInInterface",
diff -r dd25eabe441c -r 204be4fc2726 src/joystick/linux/SDL_sysjoystick.c
--- a/src/joystick/linux/SDL_sysjoystick.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/joystick/linux/SDL_sysjoystick.c	Wed Aug 27 15:10:03 2008 +0000
@@ -89,6 +89,7 @@
 static struct joystick_logical_mapping mp88xx_1_logical_axismap[] = {
     {0, 0}, {0, 1}, {0, 2}, {0, 3}, {0, 4}, {0, 5}
 };
+
 static struct joystick_logical_mapping mp88xx_1_logical_buttonmap[] = {
     {0, 0}, {0, 1}, {0, 2}, {0, 3}, {0, 4}, {0, 5}, {0, 6}, {0, 7}, {0, 8},
     {0, 9}, {0, 10}, {0, 11}
@@ -98,6 +99,7 @@
     {0, 0}, {0, 1}, {0, 2}, {1, 0}, {1, 1}, {0, 3},
     {1, 2}, {1, 3}, {0, 4}, {0, 5}, {1, 4}, {1, 5}
 };
+
 static struct joystick_logical_mapping mp88xx_2_logical_buttonmap[] = {
     {0, 0}, {0, 1}, {0, 2}, {0, 3}, {0, 4}, {0, 5}, {0, 6}, {0, 7}, {0, 8},
     {0, 9}, {0, 10}, {0, 11},
@@ -110,6 +112,7 @@
     {1, 2}, {1, 3}, {2, 0}, {2, 1}, {2, 2}, {2, 3},
     {0, 4}, {0, 5}, {1, 4}, {1, 5}, {2, 4}, {2, 5}
 };
+
 static struct joystick_logical_mapping mp88xx_3_logical_buttonmap[] = {
     {0, 0}, {0, 1}, {0, 2}, {0, 3}, {0, 4}, {0, 5}, {0, 6}, {0, 7}, {0, 8},
     {0, 9}, {0, 10}, {0, 11},
@@ -125,6 +128,7 @@
     {3, 0}, {3, 1}, {3, 2}, {3, 3}, {0, 4}, {0, 5},
     {1, 4}, {1, 5}, {2, 4}, {2, 5}, {3, 4}, {3, 5}
 };
+
 static struct joystick_logical_mapping mp88xx_4_logical_buttonmap[] = {
     {0, 0}, {0, 1}, {0, 2}, {0, 3}, {0, 4}, {0, 5}, {0, 6}, {0, 7}, {0, 8},
     {0, 9}, {0, 10}, {0, 11},
@@ -147,15 +151,18 @@
 static struct joystick_logical_layout mp88xx_1_logical_layout[] = {
     {6, 0, 0, 12}
 };
+
 static struct joystick_logical_layout mp88xx_2_logical_layout[] = {
     {6, 0, 0, 12},
     {6, 0, 0, 12}
 };
+
 static struct joystick_logical_layout mp88xx_3_logical_layout[] = {
     {6, 0, 0, 12},
     {6, 0, 0, 12},
     {6, 0, 0, 12}
 };
+
 static struct joystick_logical_layout mp88xx_4_logical_layout[] = {
     {6, 0, 0, 12},
     {6, 0, 0, 12},
@@ -953,8 +960,8 @@
 #endif /* USE_LOGICAL_JOYSTICKS */
 
         SDL_PrivateJoystickHat(stick, hat,
-                               position_map[the_hat->axis[1]][the_hat->
-                                                              axis[0]]);
+                               position_map[the_hat->
+                                            axis[1]][the_hat->axis[0]]);
     }
 }
 
@@ -1085,13 +1092,13 @@
                     code -= BTN_MISC;
 #ifndef NO_LOGICAL_JOYSTICKS
                     if (!LogicalJoystickButton(joystick,
-                                               joystick->hwdata->
-                                               key_map[code],
+                                               joystick->
+                                               hwdata->key_map[code],
                                                events[i].value))
 #endif
                         SDL_PrivateJoystickButton(joystick,
-                                                  joystick->hwdata->
-                                                  key_map[code],
+                                                  joystick->
+                                                  hwdata->key_map[code],
                                                   events[i].value);
                 }
                 break;
@@ -1113,12 +1120,12 @@
                         EV_AxisCorrect(joystick, code, events[i].value);
 #ifndef NO_LOGICAL_JOYSTICKS
                     if (!LogicalJoystickAxis(joystick,
-                                             joystick->hwdata->
-                                             abs_map[code], events[i].value))
+                                             joystick->hwdata->abs_map[code],
+                                             events[i].value))
 #endif
                         SDL_PrivateJoystickAxis(joystick,
-                                                joystick->hwdata->
-                                                abs_map[code],
+                                                joystick->
+                                                hwdata->abs_map[code],
                                                 events[i].value);
                     break;
                 }
diff -r dd25eabe441c -r 204be4fc2726 src/joystick/nds/SDL_sysjoystick.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/joystick/nds/SDL_sysjoystick.c	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,172 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+*/
+
+#include "SDL_config.h"
+
+#ifdef SDL_JOYSTICK_NDS
+
+/* This is the system specific header for the SDL joystick API */
+#include <nds.h>
+#include <stdio.h>              /* For the definition of NULL */
+
+#include "SDL_error.h"
+#include "SDL_events.h"
+#include "SDL_joystick.h"
+#include "SDL_sysjoystick.h"
+#include "SDL_joystick_c.h"
+
+#include "../../video/nds/SDL_ndsevents_c.h"
+
+/* Function to scan the system for joysticks.
+ * This function should set SDL_numjoysticks to the number of available
+ * 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)
+{
+    SDL_numjoysticks = 1;
+    
return (1);
+}
+
+/* Function to get the device-dependent name of a joystick */
+const char *
+SDL_SYS_JoystickName(int index)
+{
+    if (!index)
+        return "NDS builtin joypad";
+    SDL_SetError("No joystick available with that index");
+    return (NULL);
+}
+
+/* Function to open a joystick for use.
+   The joystick to open is specified by the index field of the joystick.
+   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)
+{
+    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.
+ */
+    void
+SDL_SYS_JoystickUpdate(SDL_Joystick * joystick)
+{
+    u32 keysd, keysu;
+    int magnitude = 16384;
+    
+        /*scanKeys(); */ 
+        keysd = keysDown();
+    keysu = keysUp();
+
+    if ((keysd & KEY_UP)) {
+        SDL_PrivateJoystickAxis(joystick, 1, -magnitude);
+    }
+    if ((keysd & KEY_DOWN)) {
+        SDL_PrivateJoystickAxis(joystick, 1, magnitude);
+    }
+    if ((keysd & KEY_LEFT)) {
+        SDL_PrivateJoystickAxis(joystick, 0, -magnitude);
+    }
+    if ((keysd & KEY_RIGHT)) {
+        SDL_PrivateJoystickAxis(joystick, 0, magnitude);
+    }
+    
if ((keysu & (KEY_UP | KEY_DOWN))) {
+        SDL_PrivateJoystickAxis(joystick, 1, 0);
+    }
+    
if ((keysu & (KEY_LEFT | KEY_RIGHT))) {
+        SDL_PrivateJoystickAxis(joystick, 0, 0);
+    }
+    
if ((keysd & KEY_A)) {
+        SDL_PrivateJoystickButton(joystick, 0, SDL_PRESSED);
+    }
+    
if ((keysd & KEY_B)) {
+        SDL_PrivateJoystickButton(joystick, 1, SDL_PRESSED);
+    }
+    
if ((keysd & KEY_X)) {
+        SDL_PrivateJoystickButton(joystick, 2, SDL_PRESSED);
+    }
+    
if ((keysd & KEY_Y)) {
+        SDL_PrivateJoystickButton(joystick, 3, SDL_PRESSED);
+    }
+    
if ((keysd & KEY_L)) {
+        SDL_PrivateJoystickButton(joystick, 4, SDL_PRESSED);
+    }
+    
if ((keysd & KEY_R)) {
+        SDL_PrivateJoystickButton(joystick, 5, SDL_PRESSED);
+    }
+    
if ((keysd & KEY_SELECT)) {
+        SDL_PrivateJoystickButton(joystick, 6, SDL_PRESSED);
+    }
+    
if ((keysd & KEY_START)) {
+        SDL_PrivateJoystickButton(joystick, 7, SDL_PRESSED);
+    }
+    
if ((keysu & KEY_A)) {
+        SDL_PrivateJoystickButton(joystick, 0, SDL_RELEASED);
+    }
+    
if ((keysu & KEY_B)) {
+        SDL_PrivateJoystickButton(joystick, 1, SDL_RELEASED);
+    }
+    
if ((keysu & KEY_X)) {
+        SDL_PrivateJoystickButton(joystick, 2, SDL_RELEASED);
+    }
+    
if ((keysu & KEY_Y)) {
+        SDL_PrivateJoystickButton(joystick, 3, SDL_RELEASED);
+    }
+    
if ((keysu & KEY_L)) {
+        SDL_PrivateJoystickButton(joystick, 4, SDL_RELEASED);
+    }
+    
if ((keysu & KEY_R)) {
+        SDL_PrivateJoystickButton(joystick, 5, SDL_RELEASED);
+    }
+    
if ((keysu & KEY_SELECT)) {
+        SDL_PrivateJoystickButton(joystick, 6, SDL_RELEASED);
+    }
+    
if ((keysu & KEY_START)) {
+        SDL_PrivateJoystickButton(joystick, 7, SDL_RELEASED);
+    }
+
}
+
+/* Function to close a joystick after use */
+void
+SDL_SYS_JoystickClose(SDL_Joystick * joystick)
+{
+}
+
+/* Function to perform any system-specific joystick related cleanup */
+void
+SDL_SYS_JoystickQuit(void)
+{
+}
+
+#endif /* SDL_JOYSTICK_NDS */
diff -r dd25eabe441c -r 204be4fc2726 src/loadso/macosx/SDL_dlcompat.c
--- a/src/loadso/macosx/SDL_dlcompat.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/loadso/macosx/SDL_dlcompat.c	Wed Aug 27 15:10:03 2008 +0000
@@ -616,8 +616,8 @@
                 || (LC_LOAD_WEAK_DYLIB == lc->cmd)) {
                 if ((wh = (struct mach_header *)
                      my_find_image((char
-                                    *) (((struct dylib_command *) lc)->
-                                        dylib.name.offset + (char *) lc)))) {
+                                    *) (((struct dylib_command *) lc)->dylib.
+                                        name.offset + (char *) lc)))) {
                     if (dyld_NSIsSymbolNameDefinedInImage(wh, symbol)) {
                         nssym = dyld_NSLookupSymbolInImage(wh,
                                                            symbol,
@@ -1067,6 +1067,7 @@
     return answer;
 
 }
+
 static void *
 dlsym_auto_underscore_intern(void *handle, const char *symbol)
 {
diff -r dd25eabe441c -r 204be4fc2726 src/main/beos/SDL_BeApp.cc
--- a/src/main/beos/SDL_BeApp.cc	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/main/beos/SDL_BeApp.cc	Wed Aug 27 15:10:03 2008 +0000
@@ -78,8 +78,7 @@
 
         do {
             SDL_Delay(10);
-        }
-        while ((be_app == NULL) || be_app->IsLaunching());
+        } while ((be_app == NULL) || be_app->IsLaunching());
 
         /* Mark the application active */
         SDL_BeAppActive = 0;
diff -r dd25eabe441c -r 204be4fc2726 src/stdlib/SDL_stdlib.c
--- a/src/stdlib/SDL_stdlib.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/stdlib/SDL_stdlib.c	Wed Aug 27 15:10:03 2008 +0000
@@ -135,6 +135,7 @@
     }
     /* *INDENT-ON* */
 }
+
 void
 __declspec(naked)
 _alldiv()
@@ -222,6 +223,7 @@
     }
     /* *INDENT-ON* */
 }
+
 void
 __declspec(naked)
 _aulldiv()
@@ -279,6 +281,7 @@
     }
     /* *INDENT-ON* */
 }
+
 void
 __declspec(naked)
 _allrem()
@@ -365,6 +368,7 @@
     }
     /* *INDENT-ON* */
 }
+
 void
 __declspec(naked)
 _aullrem()
@@ -423,6 +427,7 @@
     }
     /* *INDENT-ON* */
 }
+
 void
 __declspec(naked)
 _alldvrm()
@@ -532,6 +537,7 @@
     }
     /* *INDENT-ON* */
 }
+
 void
 __declspec(naked)
 _aulldvrm()
@@ -604,6 +610,7 @@
     }
     /* *INDENT-ON* */
 }
+
 void
 __declspec(naked)
 _allshl()
@@ -630,6 +637,7 @@
     }
     /* *INDENT-ON* */
 }
+
 void
 __declspec(naked)
 _aullshr()
diff -r dd25eabe441c -r 204be4fc2726 src/thread/SDL_thread_c.h
--- a/src/thread/SDL_thread_c.h	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/thread/SDL_thread_c.h	Wed Aug 27 15:10:03 2008 +0000
@@ -43,6 +43,8 @@
 #include "irix/SDL_systhread_c.h"
 #elif SDL_THREAD_WIN32
 #include "win32/SDL_systhread_c.h"
+#elif SDL_THREAD_NDS
+#include "nds/SDL_systhread_c.h"
 #else
 #error Need thread implementation for this platform
 #include "generic/SDL_systhread_c.h"
diff -r dd25eabe441c -r 204be4fc2726 src/thread/irix/SDL_syssem.c
--- a/src/thread/irix/SDL_syssem.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/thread/irix/SDL_syssem.c	Wed Aug 27 15:10:03 2008 +0000
@@ -55,9 +55,11 @@
 static struct sembuf op_trywait[2] = {
     {0, -1, (IPC_NOWAIT | SEM_UNDO)}    /* Decrement semaphore, no block */
 };
+
 static struct sembuf op_wait[2] = {
     {0, -1, SEM_UNDO}           /* Decrement semaphore */
 };
+
 static struct sembuf op_post[1] = {
     {0, 1, (IPC_NOWAIT | SEM_UNDO)}     /* Increment semaphore */
 };
@@ -170,8 +172,7 @@
             break;
         }
         SDL_Delay(1);
-    }
-    while (SDL_GetTicks() < timeout);
+    } while (SDL_GetTicks() < timeout);
 
     return retval;
 }
diff -r dd25eabe441c -r 204be4fc2726 src/thread/nds/SDL_syscond.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/thread/nds/SDL_syscond.c	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,229 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+*/
+
+#ifdef SAVE_RCSID
+static char rcsid =
+    "@(#) $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 */
+/*
+   This implementation borrows heavily from the BeOS condition variable
+   implementation, written by Christopher Tate and Owen Smith.  Thanks!
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "SDL_error.h"
+#include "SDL_thread.h"
+
+struct SDL_cond
+{
+    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 *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)
+{
+    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)
+{
+    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);
+    }
+
+    return 0;
+}
+
+/* Restart all threads that are waiting on the condition variable */
+int
+SDL_CondBroadcast(SDL_cond * cond)
+{
+    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;
+
+        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;
+}
+
+/* Wait on the condition variable for at most 'ms' milliseconds.
+   The mutex must be locked before entering this function!
+   The mutex is unlocked during the wait, and locked again after the wait.
+
+Typical use:
+
+Thread A:
+	SDL_LockMutex(lock);
+	while ( ! condition ) {
+		SDL_CondWait(cond);
+	}
+	SDL_UnlockMutex(lock);
+
+Thread B:
+	SDL_LockMutex(lock);
+	...
+	condition = true;
+	...
+	SDL_UnlockMutex(lock);
+ */
+int
+SDL_CondWaitTimeout(SDL_cond * cond, SDL_mutex * mutex, Uint32 ms)
+{
+    int retval;
+
+    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);
+
+    /* 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);
+    }
+
+    /* 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);
+
+    /* Lock the mutex, as is required by condition variable semantics */
+    SDL_LockMutex(mutex);
+
+    return retval;
+}
+
+/* Wait on the condition variable forever */
+int
+SDL_CondWait(SDL_cond * cond, SDL_mutex * mutex)
+{
+    return SDL_CondWaitTimeout(cond, mutex, SDL_MUTEX_MAXWAIT);
+}
diff -r dd25eabe441c -r 204be4fc2726 src/thread/nds/SDL_syscond_c.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/thread/nds/SDL_syscond_c.h	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,26 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+*/
+
+#ifdef SAVE_RCSID
+static char rcsid =
+    "@(#) $Id: SDL_syscond_c.h,v 1.2 2001/04/26 16:50:18 hercules Exp $";
+#endif
diff -r dd25eabe441c -r 204be4fc2726 src/thread/nds/SDL_sysmutex.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/thread/nds/SDL_sysmutex.c	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,142 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+*/
+
+#ifdef SAVE_RCSID
+static char rcsid =
+    "@(#) $Id: SDL_sysmutex.c,v 1.2 2001/04/26 16:50:18 hercules Exp $";
+#endif
+
+/* An implementation of mutexes using semaphores */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "SDL_error.h"
+#include "SDL_thread.h"
+#include "SDL_systhread_c.h"
+
+
+struct SDL_mutex
+{
+    int recursive;
+    Uint32 owner;
+    SDL_sem *sem;
+};
+
+/* Create a mutex */
+SDL_mutex *
+SDL_CreateMutex(void)
+{
+    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;
+}
+
+/* Free the mutex */
+void
+SDL_DestroyMutex(SDL_mutex * mutex)
+{
+    if (mutex) {
+        if (mutex->sem) {
+            SDL_DestroySemaphore(mutex->sem);
+        }
+        free(mutex);
+    }
+}
+
+/* Lock the semaphore */
+int
+SDL_mutexP(SDL_mutex * mutex)
+{
+#ifdef DISABLE_THREADS
+    return 0;
+#else
+    Uint32 this_thread;
+
+    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;
+    }
+
+    return 0;
+#endif /* DISABLE_THREADS */
+}
+
+/* Unlock the mutex */
+int
+SDL_mutexV(SDL_mutex * mutex)
+{
+#ifdef DISABLE_THREADS
+    return 0;
+#else
+    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 (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 dd25eabe441c -r 204be4fc2726 src/thread/nds/SDL_sysmutex_c.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/thread/nds/SDL_sysmutex_c.h	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,26 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+*/
+
+#ifdef SAVE_RCSID
+static char rcsid =
+    "@(#) $Id: SDL_sysmutex_c.h,v 1.2 2001/04/26 16:50:18 hercules Exp $";
+#endif
diff -r dd25eabe441c -r 204be4fc2726 src/thread/nds/SDL_syssem.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/thread/nds/SDL_syssem.c	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,228 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+*/
+
+#ifdef SAVE_RCSID
+static char rcsid =
+    "@(#) $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 */
+
+#include <stdlib.h>
+
+#include "SDL_error.h"
+#include "SDL_timer.h"
+#include "SDL_thread.h"
+#include "SDL_systhread_c.h"
+
+
+#ifdef DISABLE_THREADS
+
+SDL_sem *
+SDL_CreateSemaphore(Uint32 initial_value)
+{
+    SDL_SetError("SDL not configured with thread support");
+    return (SDL_sem *) 0;
+}
+
+void
+SDL_DestroySemaphore(SDL_sem * sem)
+{
+    return;
+}
+
+int
+SDL_SemTryWait(SDL_sem * sem)
+{
+    SDL_SetError("SDL not configured with thread support");
+    return -1;
+}
+
+int
+SDL_SemWaitTimeout(SDL_sem * sem, Uint32 timeout)
+{
+    SDL_SetError("SDL not configured with thread support");
+    return -1;
+}
+
+int
+SDL_SemWait(SDL_sem * sem)
+{
+    SDL_SetError("SDL not configured with thread support");
+    return -1;
+}
+
+Uint32
+SDL_SemValue(SDL_sem * sem)
+{
+    return 0;
+}
+
+int
+SDL_SemPost(SDL_sem * sem)
+{
+    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;
+};
+
+SDL_sem *
+SDL_CreateSemaphore(Uint32 initial_value)
+{
+    SDL_sem *sem;
+
+    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);
+    }
+
+    return (sem);
+}
+
+/* WARNING:
+   You cannot call this function when another thread is using the semaphore.
+*/
+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);
+    }
+}
+
+int
+SDL_SemTryWait(SDL_sem * sem)
+{
+    int retval;
+
+    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);
+
+    return retval;
+}
+
+int
+SDL_SemWaitTimeout(SDL_sem * sem, Uint32 timeout)
+{
+    int retval;
+
+    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);
+    }
+
+    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;
+}
+
+int
+SDL_SemWait(SDL_sem * sem)
+{
+    return SDL_SemWaitTimeout(sem, SDL_MUTEX_MAXWAIT);
+}
+
+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;
+}
+
+int
+SDL_SemPost(SDL_sem * sem)
+{
+    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);
+
+    return 0;
+}
+
+#endif /* DISABLE_THREADS */
diff -r dd25eabe441c -r 204be4fc2726 src/thread/nds/SDL_syssem_c.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/thread/nds/SDL_syssem_c.h	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,26 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+*/
+
+#ifdef SAVE_RCSID
+static char rcsid =
+    "@(#) $Id: SDL_syssem_c.h,v 1.2 2001/04/26 16:50:18 hercules Exp $";
+#endif
diff -r dd25eabe441c -r 204be4fc2726 src/thread/nds/SDL_systhread.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/thread/nds/SDL_systhread.c	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,63 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+*/
+
+#ifdef SAVE_RCSID
+static char rcsid =
+    "@(#) $Id: SDL_systhread.c,v 1.2 2001/04/26 16:50:18 hercules Exp $";
+#endif
+
+/* Thread management routines for SDL */
+
+#include "SDL_error.h"
+#include "SDL_thread.h"
+#include "SDL_systhread.h"
+
+int
+SDL_SYS_CreateThread(SDL_Thread * thread, void *args)
+{
+    SDL_SetError("Threads are not supported on this platform");
+    return (-1);
+}
+
+void
+SDL_SYS_SetupThread(void)
+{
+    return;
+}
+
+Uint32
+SDL_ThreadID(void)
+{
+    return (0);
+}
+
+void
+SDL_SYS_WaitThread(SDL_Thread * thread)
+{
+    return;
+}
+
+void
+SDL_SYS_KillThread(SDL_Thread * thread)
+{
+    return;
+}
diff -r dd25eabe441c -r 204be4fc2726 src/thread/nds/SDL_systhread_c.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/thread/nds/SDL_systhread_c.h	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,28 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+*/
+
+/* Stub until we implement threads on this platform */
+typedef int SYS_ThreadHandle;
+
+#ifndef DISABLE_THREADS
+#define DISABLE_THREADS
+#endif
diff -r dd25eabe441c -r 204be4fc2726 src/thread/pthread/SDL_syssem.c
--- a/src/thread/pthread/SDL_syssem.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/thread/pthread/SDL_syssem.c	Wed Aug 27 15:10:03 2008 +0000
@@ -125,8 +125,7 @@
             break;
         }
         SDL_Delay(1);
-    }
-    while (SDL_GetTicks() < timeout);
+    } while (SDL_GetTicks() < timeout);
 
     return retval;
 }
diff -r dd25eabe441c -r 204be4fc2726 src/thread/riscos/SDL_syssem.c
--- a/src/thread/riscos/SDL_syssem.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/thread/riscos/SDL_syssem.c	Wed Aug 27 15:10:03 2008 +0000
@@ -177,8 +177,7 @@
             break;
         }
         SDL_Delay(1);
-    }
-    while (SDL_GetTicks() < timeout);
+    } while (SDL_GetTicks() < timeout);
 
     return retval;
 }
diff -r dd25eabe441c -r 204be4fc2726 src/timer/nds/SDL_systimer.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/timer/nds/SDL_systimer.c	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,120 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifdef SDL_TIMER_NDS
+
+#include <nds.h>
+#include <nds/timers.h>
+
+#include "SDL_timer.h"
+#include "../SDL_timer_c.h"
+#include "../SDL_systimer.h"
+
+/* Data to handle a single periodic alarm */
+static int timer_alive = 0;
+static Uint32 timer_ticks;
+
+void
+SDL_StartTicks(void)
+{
+    if (!timer_alive) {
+        SDL_SYS_TimerInit();
+        SDL_SYS_StartTimer();
+    }
+
+    timer_ticks = 0;
+}
+
+Uint32
+SDL_GetTicks(void)
+{
+    return timer_ticks;
+}
+
+void
+SDL_Delay(Uint32 ms)
+{
+    Uint32 start = SDL_GetTicks();
+    while (timer_alive) {
+        if ((SDL_GetTicks() - start) >= ms)
+            break;
+    }
+}
+
+static int
+RunTimer(void *unused)
+{
+    while (timer_alive) {
+        if (SDL_timer_running) {
+        }
+        SDL_Delay(1);
+    }
+    return (0);
+}
+
+void
+NDS_TimerInterrupt(void)
+{
+    timer_ticks++;
+}
+
+/* This is only called if the event thread is not running */
+int
+SDL_SYS_TimerInit(void)
+{
+    timer_alive = 1;
+    timer_ticks = 0;
+    TIMER_CR(3) = TIMER_DIV_1024 | TIMER_IRQ_REQ;
+    TIMER_DATA(3) = TIMER_FREQ_1024(1000);
+    irqSet(IRQ_TIMER3, NDS_TimerInterrupt);
+    irqEnable(IRQ_TIMER3);
+    return 0;
+}
+
+void
+SDL_SYS_TimerQuit(void)
+{
+    if (timer_alive) {
+        TIMER_CR(3) = 0;
+    }
+    timer_alive = 0;
+    irqDisable(IRQ_TIMER3);
+}
+
+int
+SDL_SYS_StartTimer(void)
+{
+    TIMER_CR(3) |= TIMER_ENABLE;
+    return 0;
+}
+
+void
+SDL_SYS_StopTimer(void)
+{
+    TIMER_CR(3) &= ~TIMER_ENABLE;
+    return;
+}
+
+
+#endif /* SDL_TIMER_NDS */
+/* vi: set ts=4 sw=4 expandtab: */
diff -r dd25eabe441c -r 204be4fc2726 src/timer/riscos/SDL_systimer.c
--- a/src/timer/riscos/SDL_systimer.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/timer/riscos/SDL_systimer.c	Wed Aug 27 15:10:03 2008 +0000
@@ -130,8 +130,7 @@
             pthread_yield();
 #endif
 
-    }
-    while (1);
+    } while (1);
 }
 
 #if SDL_THREADS_DISABLED
diff -r dd25eabe441c -r 204be4fc2726 src/timer/unix/SDL_systimer.c
--- a/src/timer/unix/SDL_systimer.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/timer/unix/SDL_systimer.c	Wed Aug 27 15:10:03 2008 +0000
@@ -137,8 +137,7 @@
 
         was_error = select(0, NULL, NULL, NULL, &tv);
 #endif /* HAVE_NANOSLEEP */
-    }
-    while (was_error && (errno == EINTR));
+    } while (was_error && (errno == EINTR));
 #endif /* SDL_THREAD_PTH */
 }
 
diff -r dd25eabe441c -r 204be4fc2726 src/video/SDL_RLEaccel.c
--- a/src/video/SDL_RLEaccel.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/SDL_RLEaccel.c	Wed Aug 27 15:10:03 2008 +0000
@@ -1154,8 +1154,7 @@
                             ofs += run;
                         } else if (!ofs)
                             goto done;
-                    }
-                    while (ofs < w);
+                    } while (ofs < w);
 
                     /* skip padding */
                     srcbuf += (uintptr_t) srcbuf & 2;
@@ -1168,10 +1167,8 @@
                         run = ((Uint16 *) srcbuf)[1];
                         srcbuf += 4 * (run + 1);
                         ofs += run;
-                    }
-                    while (ofs < w);
-                }
-                while (--vskip);
+                    } while (ofs < w);
+                } while (--vskip);
             } else {
                 /* the 32/32 interleaved format */
                 vskip <<= 1;    /* opaque and translucent have same format */
@@ -1187,10 +1184,8 @@
                             ofs += run;
                         } else if (!ofs)
                             goto done;
-                    }
-                    while (ofs < w);
-                }
-                while (--vskip);
+                    } while (ofs < w);
+                } while (--vskip);
             }
         }
     }
@@ -1567,8 +1562,7 @@
                     runstart += len;
                     run -= len;
                 }
-            }
-            while (x < w);
+            } while (x < w);
 
             /* Make sure the next output address is 32-bit aligned */
             dst += (uintptr_t) dst & 2;
@@ -1604,8 +1598,7 @@
                 }
                 if (!blankline)
                     lastline = dst;
-            }
-            while (x < w);
+            } while (x < w);
 
             src += surface->pitch >> 2;
         }
@@ -1771,8 +1764,7 @@
             }
             if (!blankline)
                 lastline = dst;
-        }
-        while (x < w);
+        } while (x < w);
 
         srcbuf += surface->pitch;
     }
@@ -1911,8 +1903,7 @@
                 ofs += run;
             } else if (!ofs)
                 return (SDL_TRUE);
-        }
-        while (ofs < w);
+        } while (ofs < w);
 
         /* skip padding if needed */
         if (bpp == 2)
@@ -1929,8 +1920,7 @@
                 srcbuf += uncopy_transl(dst + ofs, srcbuf, run, df, sf);
                 ofs += run;
             }
-        }
-        while (ofs < w);
+        } while (ofs < w);
         dst += surface->pitch >> 2;
     }
     /* Make the compiler happy */
diff -r dd25eabe441c -r 204be4fc2726 src/video/SDL_blit_0.c
--- a/src/video/SDL_blit_0.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/SDL_blit_0.c	Wed Aug 27 15:10:03 2008 +0000
@@ -80,6 +80,7 @@
         }
     }
 }
+
 static void
 BlitBto2(SDL_BlitInfo * info)
 {
@@ -116,6 +117,7 @@
         dst += dstskip;
     }
 }
+
 static void
 BlitBto3(SDL_BlitInfo * info)
 {
@@ -154,6 +156,7 @@
         dst += dstskip;
     }
 }
+
 static void
 BlitBto4(SDL_BlitInfo * info)
 {
diff -r dd25eabe441c -r 204be4fc2726 src/video/SDL_blit_1.c
--- a/src/video/SDL_blit_1.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/SDL_blit_1.c	Wed Aug 27 15:10:03 2008 +0000
@@ -184,6 +184,7 @@
     }
 #endif /* USE_DUFFS_LOOP */
 }
+
 static void
 Blit1to3(SDL_BlitInfo * info)
 {
@@ -232,6 +233,7 @@
         dst += dstskip;
     }
 }
+
 static void
 Blit1to4(SDL_BlitInfo * info)
 {
diff -r dd25eabe441c -r 204be4fc2726 src/video/SDL_blit_A.c
--- a/src/video/SDL_blit_A.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/SDL_blit_A.c	Wed Aug 27 15:10:03 2008 +0000
@@ -283,8 +283,8 @@
         amult = alpha | (alpha << 8);
         amult = amult | (amult << 16);
         chanmask =
-            (0xff << df->Rshift) | (0xff << df->Gshift) | (0xff << df->
-                                                           Bshift);
+            (0xff << df->Rshift) | (0xff << df->
+                                    Gshift) | (0xff << df->Bshift);
         mm_alpha = _mm_set_pi32(0, amult & chanmask);   /* 0000AAAA -> mm_alpha, minus 1 chan */
         mm_alpha = _mm_unpacklo_pi8(mm_alpha, mm_zero); /* 0A0A0A0A -> mm_alpha, minus 1 chan */
         /* at this point mm_alpha can be 000A0A0A or 0A0A0A00 or another combo */
@@ -526,8 +526,8 @@
     /* Use zero for alpha if either surface doesn't have alpha */
     if (dstfmt->Amask) {
         amask =
-            ((srcfmt->Amask) ? RESHIFT(srcfmt->Ashift) : 0x10) << (dstfmt->
-                                                                   Ashift);
+            ((srcfmt->Amask) ? RESHIFT(srcfmt->
+                                       Ashift) : 0x10) << (dstfmt->Ashift);
     } else {
         amask =
             0x10101010 & ((dstfmt->Rmask | dstfmt->Gmask | dstfmt->Bmask) ^
diff -r dd25eabe441c -r 204be4fc2726 src/video/SDL_blit_N.c
--- a/src/video/SDL_blit_N.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/SDL_blit_N.c	Wed Aug 27 15:10:03 2008 +0000
@@ -141,8 +141,8 @@
     /* Use zero for alpha if either surface doesn't have alpha */
     if (dstfmt->Amask) {
         amask =
-            ((srcfmt->Amask) ? RESHIFT(srcfmt->Ashift) : 0x10) << (dstfmt->
-                                                                   Ashift);
+            ((srcfmt->Amask) ? RESHIFT(srcfmt->
+                                       Ashift) : 0x10) << (dstfmt->Ashift);
     } else {
         amask =
             0x10101010 & ((dstfmt->Rmask | dstfmt->Gmask | dstfmt->Bmask) ^
@@ -1435,6 +1435,7 @@
     0x00001ce6, 0xffff8100, 0x00001cee, 0xffffa100,
     0x00001cf6, 0xffffc200, 0x00001cff, 0xffffe200
 };
+
 static void
 Blit_RGB565_ARGB8888(SDL_BlitInfo * info)
 {
@@ -1572,6 +1573,7 @@
     0xffe61c00, 0x000081ff, 0xffee1c00, 0x0000a1ff,
     0xfff61c00, 0x0000c2ff, 0xffff1c00, 0x0000e2ff
 };
+
 static void
 Blit_RGB565_ABGR8888(SDL_BlitInfo * info)
 {
@@ -1709,6 +1711,7 @@
     0x001ce6ff, 0xff810000, 0x001ceeff, 0xffa10000,
     0x001cf6ff, 0xffc20000, 0x001cffff, 0xffe20000,
 };
+
 static void
 Blit_RGB565_RGBA8888(SDL_BlitInfo * info)
 {
@@ -1846,6 +1849,7 @@
     0xe61c0000, 0x0081ffff, 0xee1c0000, 0x00a1ffff,
     0xf61c0000, 0x00c2ffff, 0xff1c0000, 0x00e2ffff
 };
+
 static void
 Blit_RGB565_BGRA8888(SDL_BlitInfo * info)
 {
@@ -1930,6 +1934,7 @@
     }
 #endif /* USE_DUFFS_LOOP */
 }
+
 static void
 BlitNto1(SDL_BlitInfo * info)
 {
@@ -2340,6 +2345,7 @@
     /* Default for 8-bit RGB source, an invalid combination */
     {0, 0, 0, 0, 0, 0, 0, 0, NULL},
 };
+
 static const struct blit_table normal_blit_2[] = {
 #if SDL_ALTIVEC_BLITTERS
     /* has-altivec */
@@ -2366,10 +2372,12 @@
     /* Default for 16-bit RGB source, used if no other blitter matches */
     {0, 0, 0, 0, 0, 0, 0, 0, BlitNtoN, 0}
 };
+
 static const struct blit_table normal_blit_3[] = {
     /* Default for 24-bit RGB source, never optimized */
     {0, 0, 0, 0, 0, 0, 0, 0, BlitNtoN, 0}
 };
+
 static const struct blit_table normal_blit_4[] = {
 #if SDL_ALTIVEC_BLITTERS
     /* has-altivec | dont-use-prefetch */
@@ -2396,6 +2404,7 @@
     /* Default for 32-bit RGB source, used if no other blitter matches */
     {0, 0, 0, 0, 0, 0, 0, 0, BlitNtoN, 0}
 };
+
 static const struct blit_table *normal_blit[] = {
     normal_blit_1, normal_blit_2, normal_blit_3, normal_blit_4
 };
diff -r dd25eabe441c -r 204be4fc2726 src/video/SDL_gamma.c
--- a/src/video/SDL_gamma.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/SDL_gamma.c	Wed Aug 27 15:10:03 2008 +0000
@@ -70,6 +70,7 @@
         }
     }
 }
+
 static void
 CalculateGammaFromRamp(float *gamma, Uint16 * ramp)
 {
diff -r dd25eabe441c -r 204be4fc2726 src/video/SDL_pixels.c
--- a/src/video/SDL_pixels.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/SDL_pixels.c	Wed Aug 27 15:10:03 2008 +0000
@@ -168,12 +168,16 @@
         break;
     case 15:
         switch (Rmask) {
+        case 0x001F:
+            return SDL_PIXELFORMAT_BGR555;
         case 0x7C00:
             return SDL_PIXELFORMAT_RGB555;
         }
         break;
     case 16:
         switch (Rmask) {
+        case 0x001F:
+            return SDL_PIXELFORMAT_ABGR1555;
         case 0x0F00:
             return SDL_PIXELFORMAT_ARGB4444;
         case 0x7C00:
@@ -748,6 +752,7 @@
         map->info.table = NULL;
     }
 }
+
 int
 SDL_MapSurface(SDL_Surface * src, SDL_Surface * dst)
 {
diff -r dd25eabe441c -r 204be4fc2726 src/video/SDL_renderer_sw.c
--- a/src/video/SDL_renderer_sw.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/SDL_renderer_sw.c	Wed Aug 27 15:10:03 2008 +0000
@@ -388,8 +388,9 @@
                       void **pixels, int *pitch)
 {
     if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
-        return SDL_SW_QueryYUVTexturePixels((SDL_SW_YUVTexture *) texture->
-                                            driverdata, pixels, pitch);
+        return SDL_SW_QueryYUVTexturePixels((SDL_SW_YUVTexture *)
+                                            texture->driverdata, pixels,
+                                            pitch);
     } else {
         SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
 
@@ -464,8 +465,9 @@
                  const SDL_Rect * rect, const void *pixels, int pitch)
 {
     if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
-        return SDL_SW_UpdateYUVTexture((SDL_SW_YUVTexture *) texture->
-                                       driverdata, rect, pixels, pitch);
+        return SDL_SW_UpdateYUVTexture((SDL_SW_YUVTexture *)
+                                       texture->driverdata, rect, pixels,
+                                       pitch);
     } else {
         SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
         Uint8 *src, *dst;
@@ -492,9 +494,9 @@
                int *pitch)
 {
     if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
-        return SDL_SW_LockYUVTexture((SDL_SW_YUVTexture *) texture->
-                                     driverdata, rect, markDirty, pixels,
-                                     pitch);
+        return SDL_SW_LockYUVTexture((SDL_SW_YUVTexture *)
+                                     texture->driverdata, rect, markDirty,
+                                     pixels, pitch);
     } else {
         SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
 
@@ -535,10 +537,10 @@
 
     color = SDL_MapRGBA(data->surface.format, r, g, b, a);
 
-    if (data->renderer->
-        LockTexture(data->renderer, data->texture[data->current_texture],
-                    rect, 1, &data->surface.pixels,
-                    &data->surface.pitch) < 0) {
+    if (data->renderer->LockTexture(data->renderer,
+                                    data->texture[data->current_texture],
+                                    rect, 1, &data->surface.pixels,
+                                    &data->surface.pitch) < 0) {
         return -1;
     }
     data->surface.w = rect->w;
@@ -566,10 +568,10 @@
         SDL_AddDirtyRect(&data->dirty, dstrect);
     }
 
-    if (data->renderer->
-        LockTexture(data->renderer, data->texture[data->current_texture],
-                    dstrect, 1, &data->surface.pixels,
-                    &data->surface.pitch) < 0) {
+    if (data->renderer->LockTexture(data->renderer,
+                                    data->texture[data->current_texture],
+                                    dstrect, 1, &data->surface.pixels,
+                                    &data->surface.pitch) < 0) {
         return -1;
     }
 
diff -r dd25eabe441c -r 204be4fc2726 src/video/SDL_surface.c
--- a/src/video/SDL_surface.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/SDL_surface.c	Wed Aug 27 15:10:03 2008 +0000
@@ -409,9 +409,9 @@
         return 0;
     }
 
-    switch (surface->map->info.
-            flags & (SDL_COPY_MASK | SDL_COPY_BLEND | SDL_COPY_ADD |
-                     SDL_COPY_MOD)) {
+    switch (surface->map->
+            info.flags & (SDL_COPY_MASK | SDL_COPY_BLEND | SDL_COPY_ADD |
+                          SDL_COPY_MOD)) {
     case SDL_COPY_MASK:
         *blendMode = SDL_TEXTUREBLENDMODE_MASK;
         break;
diff -r dd25eabe441c -r 204be4fc2726 src/video/SDL_sysvideo.h
--- a/src/video/SDL_sysvideo.h	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/SDL_sysvideo.h	Wed Aug 27 15:10:03 2008 +0000
@@ -369,6 +369,9 @@
 #if SDL_VIDEO_DRIVER_DUMMY
 extern VideoBootStrap DUMMY_bootstrap;
 #endif
+#if SDL_VIDEO_DRIVER_NDS
+extern VideoBootStrap NDS_bootstrap;
+#endif
 
 #define SDL_CurrentDisplay	(_this->displays[_this->current_display])
 
diff -r dd25eabe441c -r 204be4fc2726 src/video/SDL_video.c
--- a/src/video/SDL_video.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/SDL_video.c	Wed Aug 27 15:10:03 2008 +0000
@@ -103,6 +103,9 @@
 #if SDL_VIDEO_DRIVER_OS2FS
     &OS2FSLib_bootstrap,
 #endif
+#if SDL_VIDEO_DRIVER_NDS
+    &NDS_bootstrap,
+#endif
 #if SDL_VIDEO_DRIVER_DUMMY
     &DUMMY_bootstrap,
 #endif
diff -r dd25eabe441c -r 204be4fc2726 src/video/ataricommon/SDL_atarigl.c
--- a/src/video/ataricommon/SDL_atarigl.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/ataricommon/SDL_atarigl.c	Wed Aug 27 15:10:03 2008 +0000
@@ -349,9 +349,9 @@
     }
 
     if (!
-        (_this->gl_data->
-         OSMesaMakeCurrent(gl_ctx, surface->pixels, type, surface->w,
-                           surface->h))) {
+        (_this->
+         gl_data->OSMesaMakeCurrent(gl_ctx, surface->pixels, type, surface->w,
+                                    surface->h))) {
         SDL_SetError("Can not make OpenGL context current");
         return -1;
     }
@@ -512,10 +512,10 @@
 
         gl_ctx =
             _this->gl_data->OSMesaCreateContextExt(osmesa_format,
-                                                   _this->gl_config.
-                                                   depth_size,
-                                                   _this->gl_config.
-                                                   stencil_size,
+                                                   _this->
+                                                   gl_config.depth_size,
+                                                   _this->
+                                                   gl_config.stencil_size,
                                                    newaccumsize, NULL);
 
         if (gl_ctx) {
diff -r dd25eabe441c -r 204be4fc2726 src/video/bwindow/SDL_sysvideo.cc
--- a/src/video/bwindow/SDL_sysvideo.cc	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/bwindow/SDL_sysvideo.cc	Wed Aug 27 15:10:03 2008 +0000
@@ -670,8 +670,8 @@
                         _this->gl_config.driver_loaded = 1;
                         SDL_strlcpy(_this->gl_config.driver_path,
                                     "libGL.so",
-                                    SDL_arraysize(_this->gl_config.
-                                                  driver_path));
+                                    SDL_arraysize(_this->
+                                                  gl_config.driver_path));
                     }
                 }
             }
diff -r dd25eabe441c -r 204be4fc2726 src/video/dc/SDL_dcevents.c
--- a/src/video/dc/SDL_dcevents.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/dc/SDL_dcevents.c	Wed Aug 27 15:10:03 2008 +0000
@@ -135,8 +135,7 @@
     for (i = 0; i < sizeof(sdl_shift); i++) {
         if ((shiftkeys >> i) & 1) {
             keysym.sym = sdl_shift[i];
-            SDL_PrivateKeyboard(((state->
-                                  shift_keys >> i) & 1) ? SDL_PRESSED :
+            SDL_PrivateKeyboard(((state->shift_keys >> i) & 1) ? SDL_PRESSED :
                                 SDL_RELEASED, &keysym);
         }
     }
@@ -146,8 +145,7 @@
             int key = sdl_key[i];
             if (key) {
                 keysym.sym = key;
-                SDL_PrivateKeyboard(state->
-                                    matrix[i] ? SDL_PRESSED :
+                SDL_PrivateKeyboard(state->matrix[i] ? SDL_PRESSED :
                                     SDL_RELEASED, &keysym);
             }
         }
diff -r dd25eabe441c -r 204be4fc2726 src/video/dc/SDL_dcvideo.c
--- a/src/video/dc/SDL_dcvideo.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/dc/SDL_dcvideo.c	Wed Aug 27 15:10:03 2008 +0000
@@ -158,6 +158,7 @@
 const static SDL_Rect RECT_800x600 = { 0, 0, 800, 600 }, RECT_640x480 = {
 0, 0, 640, 480}, RECT_320x240 = {
 0, 0, 320, 240};
+
 const static SDL_Rect *vid_modes[] = {
     &RECT_800x600,
     &RECT_640x480,
@@ -296,6 +297,7 @@
 {
     return (-1);
 }
+
 static void
 DC_FreeHWSurface(_THIS, SDL_Surface * surface)
 {
diff -r dd25eabe441c -r 204be4fc2726 src/video/directfb/SDL_DirectFB_events.c
--- a/src/video/directfb/SDL_DirectFB_events.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/directfb/SDL_DirectFB_events.c	Wed Aug 27 15:10:03 2008 +0000
@@ -383,33 +383,25 @@
             switch (evt.type) {
             case DIET_BUTTONPRESS:
                 posted += SDL_PrivateMouseButton(SDL_PRESSED,
-                                                 DirectFB_TranslateButton(evt.
-                                                                          button),
-                                                 0, 0);
+                                                 DirectFB_TranslateButton
+                                                 (evt.button), 0, 0);
                 break;
             case DIET_BUTTONRELEASE:
                 posted += SDL_PrivateMouseButton(SDL_RELEASED,
-                                                 DirectFB_TranslateButton(evt.
-                                                                          button),
-                                                 0, 0);
+                                                 DirectFB_TranslateButton
+                                                 (evt.button), 0, 0);
                 break;
             case DIET_KEYPRESS:
                 posted += SDL_PrivateKeyboard(SDL_PRESSED,
-                                              DirectFB_TranslateKey(evt.
-                                                                    key_id,
-                                                                    evt.
-                                                                    key_symbol,
-                                                                    mod,
-                                                                    &keysym));
+                                              DirectFB_TranslateKey
+                                              (evt.key_id, evt.key_symbol,
+                                               mod, &keysym));
                 break;
             case DIET_KEYRELEASE:
                 posted += SDL_PrivateKeyboard(SDL_RELEASED,
-                                              DirectFB_TranslateKey(evt.
-                                                                    key_id,
-                                                                    evt.
-                                                                    key_symbol,
-                                                                    mod,
-                                                                    &keysym));
+                                              DirectFB_TranslateKey
+                                              (evt.key_id, evt.key_symbol,
+                                               mod, &keysym));
                 break;
             case DIET_AXISMOTION:
                 if (evt.flags & DIEF_AXISREL) {
diff -r dd25eabe441c -r 204be4fc2726 src/video/directfb/SDL_DirectFB_mouse.c
--- a/src/video/directfb/SDL_DirectFB_mouse.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/directfb/SDL_DirectFB_mouse.c	Wed Aug 27 15:10:03 2008 +0000
@@ -85,14 +85,15 @@
     dsc.height = surface->h;
     dsc.pixelformat = DSPF_ARGB;
 
-    SDL_DFB_CHECKERR(devdata->dfb->
-                     CreateSurface(devdata->dfb, &dsc, &curdata->surf));
+    SDL_DFB_CHECKERR(devdata->
+                     dfb->CreateSurface(devdata->dfb, &dsc, &curdata->surf));
     curdata->hotx = hot_x;
     curdata->hoty = hot_y;
     cursor->driverdata = curdata;
 
-    SDL_DFB_CHECKERR(curdata->surf->
-                     Lock(curdata->surf, DSLF_WRITE, (void *) &dest, &pitch));
+    SDL_DFB_CHECKERR(curdata->
+                     surf->Lock(curdata->surf, DSLF_WRITE, (void *) &dest,
+                                &pitch));
 
     //FIXME: Implies a lot of things, e.g. rgba format for SDL_SURFACE ....
     p = surface->pixels;
@@ -131,18 +132,18 @@
         DFB_WindowData *windata = (DFB_WindowData *) window->driverdata;
 
         if (cursor)
-            SDL_DFB_CHECKERR(windata->window->
-                             SetCursorShape(windata->window, curdata->surf,
-                                            curdata->hotx, curdata->hoty));
+            SDL_DFB_CHECKERR(windata->window->SetCursorShape(windata->window,
+                                                             curdata->surf,
+                                                             curdata->hotx,
+                                                             curdata->hoty));
         //TODO: Check administrative 
-        SDL_DFB_CHECKERR(dispdata->layer->
-                         SetCooperativeLevel(dispdata->layer,
-                                             DLSCL_ADMINISTRATIVE));
-        SDL_DFB_CHECKERR(dispdata->layer->
-                         SetCursorOpacity(dispdata->layer,
-                                          cursor ? 0xC0 : 0x00));
-        SDL_DFB_CHECKERR(dispdata->layer->
-                         SetCooperativeLevel(dispdata->layer, DLSCL_SHARED));
+        SDL_DFB_CHECKERR(dispdata->layer->SetCooperativeLevel(dispdata->layer,
+                                                              DLSCL_ADMINISTRATIVE));
+        SDL_DFB_CHECKERR(dispdata->layer->SetCursorOpacity(dispdata->layer,
+                                                           cursor ? 0xC0 :
+                                                           0x00));
+        SDL_DFB_CHECKERR(dispdata->layer->SetCooperativeLevel(dispdata->layer,
+                                                              DLSCL_SHARED));
     }
 
     return 0;
@@ -181,8 +182,8 @@
     int cx, cy;
 
     SDL_DFB_CHECKERR(windata->window->GetPosition(windata->window, &cx, &cy));
-    SDL_DFB_CHECKERR(dispdata->layer->
-                     WarpCursor(dispdata->layer, cx + x, cy + y));
+    SDL_DFB_CHECKERR(dispdata->
+                     layer->WarpCursor(dispdata->layer, cx + x, cy + y));
 
   error:
     return;
diff -r dd25eabe441c -r 204be4fc2726 src/video/directfb/SDL_DirectFB_video.c
--- a/src/video/directfb/SDL_DirectFB_video.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/directfb/SDL_DirectFB_video.c	Wed Aug 27 15:10:03 2008 +0000
@@ -314,8 +314,8 @@
         SDL_DFB_CHECKERR(dfb->GetScreen(dfb, devdata->screenid[i], &screen));
 
         devdata->aux = i;
-        SDL_DFB_CHECKERR(screen->
-                         EnumDisplayLayers(screen, &cbLayers, devdata));
+        SDL_DFB_CHECKERR(screen->EnumDisplayLayers
+                         (screen, &cbLayers, devdata));
 #if (DIRECTFB_MAJOR_VERSION >= 1)
         screen->GetSize(screen, &tcw[i], &tch[i]);
 #else
@@ -338,12 +338,12 @@
 
     for (i = 0; i < devdata->numscreens; i++) {
         //SDL_DFB_CHECKERR( dfb->GetDisplayLayer (dfb, DLID_PRIMARY, &layer) );
-        SDL_DFB_CHECKERR(dfb->
-                         GetDisplayLayer(dfb, devdata->gralayer[i], &layer));
+        SDL_DFB_CHECKERR(dfb->GetDisplayLayer
+                         (dfb, devdata->gralayer[i], &layer));
         //SDL_DFB_CHECKERR( dfb->CreateInputEventBuffer (dfb, DICAPS_ALL, DFB_FALSE, &events) );
 
-        SDL_DFB_CHECKERR(layer->
-                         SetCooperativeLevel(layer, DLSCL_ADMINISTRATIVE));
+        SDL_DFB_CHECKERR(layer->SetCooperativeLevel
+                         (layer, DLSCL_ADMINISTRATIVE));
         layer->EnableCursor(layer, 1);
         SDL_DFB_CHECKERR(layer->SetCursorOpacity(layer, 0xC0));
         SDL_DFB_CHECKERR(layer->SetCooperativeLevel(layer, DLSCL_SHARED));
@@ -379,8 +379,8 @@
         /* Enumerate the available fullscreen modes */
         SDL_DFB_CALLOC(dispdata->modelist, DFB_MAX_MODES,
                        sizeof(SDL_DisplayMode));
-        SDL_DFB_CHECKERR(dfb->
-                         EnumVideoModes(dfb, EnumModesCallback, &display));
+        SDL_DFB_CHECKERR(dfb->EnumVideoModes
+                         (dfb, EnumModesCallback, &display));
 
         SDL_AddVideoDisplay(&display);
     }
@@ -433,13 +433,14 @@
         DFB_DisplayData *dispdata =
             (DFB_DisplayData *) _this->displays[i].driverdata;
         if (dispdata->layer) {
-            SDL_DFB_CHECK(dispdata->layer->
-                          SetCooperativeLevel(dispdata->layer,
-                                              DLSCL_ADMINISTRATIVE));
-            SDL_DFB_CHECK(dispdata->layer->
-                          SetCursorOpacity(dispdata->layer, 0x00));
-            SDL_DFB_CHECK(dispdata->layer->
-                          SetCooperativeLevel(dispdata->layer, DLSCL_SHARED));
+            SDL_DFB_CHECK(dispdata->
+                          layer->SetCooperativeLevel(dispdata->layer,
+                                                     DLSCL_ADMINISTRATIVE));
+            SDL_DFB_CHECK(dispdata->
+                          layer->SetCursorOpacity(dispdata->layer, 0x00));
+            SDL_DFB_CHECK(dispdata->
+                          layer->SetCooperativeLevel(dispdata->layer,
+                                                     DLSCL_SHARED));
         }
         SDL_DFB_RELEASE(dispdata->layer);
 
@@ -578,8 +579,8 @@
     DFBResult ret;
     DFB_WindowData *win;
 
-    SDL_DFB_CHECKERR(data->layer->
-                     SetCooperativeLevel(data->layer, DLSCL_ADMINISTRATIVE));
+    SDL_DFB_CHECKERR(data->layer->SetCooperativeLevel(data->layer,
+                                                      DLSCL_ADMINISTRATIVE));
 
     SDL_DFB_CHECKERR(data->layer->GetConfiguration(data->layer, &config));
     config.flags = DLCONF_WIDTH | DLCONF_HEIGHT;        // | DLCONF_BUFFERMODE;
@@ -604,8 +605,8 @@
     SDL_DFB_DEBUG("Trace\n");
     config.flags &= ~fail;
     SDL_DFB_CHECKERR(data->layer->SetConfiguration(data->layer, &config));
-    SDL_DFB_CHECKERR(data->layer->
-                     SetCooperativeLevel(data->layer, DLSCL_ADMINISTRATIVE));
+    SDL_DFB_CHECKERR(data->layer->SetCooperativeLevel(data->layer,
+                                                      DLSCL_ADMINISTRATIVE));
 
     /* Double check */
     SDL_DFB_CHECKERR(data->layer->GetConfiguration(data->layer, &rconfig));
@@ -674,11 +675,11 @@
     SDL_DFB_CALLOC(window->driverdata, 1, sizeof(DFB_WindowData));
     windata = (DFB_WindowData *) window->driverdata;
 
-    SDL_DFB_CHECKERR(devdata->dfb->
-                     SetCooperativeLevel(devdata->dfb, DFSCL_NORMAL));
-    SDL_DFB_CHECKERR(dispdata->layer->
-                     SetCooperativeLevel(dispdata->layer,
-                                         DLSCL_ADMINISTRATIVE));
+    SDL_DFB_CHECKERR(devdata->
+                     dfb->SetCooperativeLevel(devdata->dfb, DFSCL_NORMAL));
+    SDL_DFB_CHECKERR(dispdata->
+                     layer->SetCooperativeLevel(dispdata->layer,
+                                                DLSCL_ADMINISTRATIVE));
 
     /* Fill the window description. */
     if (window->x == SDL_WINDOWPOS_CENTERED) {
@@ -725,8 +726,8 @@
     desc.surface_caps = DSCAPS_DOUBLE | DSCAPS_TRIPLE / DSCAPS_PREMULTIPLIED;
 
     /* Create the window. */
-    SDL_DFB_CHECKERR(dispdata->layer->
-                     CreateWindow(dispdata->layer, &desc, &windata->window));
+    SDL_DFB_CHECKERR(dispdata->layer->CreateWindow(dispdata->layer, &desc,
+                                                   &windata->window));
 
     windata->window->GetOptions(windata->window, &wopts);
 #if (DIRECTFB_MAJOR_VERSION == 1) && (DIRECTFB_MINOR_VERSION >= 0)
@@ -744,12 +745,13 @@
 
     windata->window->SetOptions(windata->window, wopts);
     /* Get the window's surface. */
-    SDL_DFB_CHECKERR(windata->window->
-                     GetSurface(windata->window, &windata->surface));
+    SDL_DFB_CHECKERR(windata->
+                     window->GetSurface(windata->window, &windata->surface));
     windata->window->SetOpacity(windata->window, 0xFF);
-    SDL_DFB_CHECKERR(windata->window->
-                     CreateEventBuffer(windata->window,
-                                       &(windata->eventbuffer)));
+    SDL_DFB_CHECKERR(windata->window->CreateEventBuffer(windata->window,
+                                                        &
+                                                        (windata->
+                                                         eventbuffer)));
     SDL_DFB_CHECKERR(windata->window->
                      EnableEvents(windata->window,
                                   DWET_POSITION | DWET_SIZE | DWET_CLOSE |
@@ -812,6 +814,7 @@
     //return -1;
 
 }
+
 static void
 DirectFB_SetWindowPosition(_THIS, SDL_Window * window)
 {
@@ -886,6 +889,7 @@
     windata->window->SetOpacity(windata->window, 0);
 
 }
+
 static void
 DirectFB_RaiseWindow(_THIS, SDL_Window * window)
 {
@@ -907,6 +911,7 @@
     SDL_Unsupported();
 
 }
+
 static void
 DirectFB_MinimizeWindow(_THIS, SDL_Window * window)
 {
@@ -928,6 +933,7 @@
     SDL_Unsupported();
 
 }
+
 static void
 DirectFB_SetWindowGrab(_THIS, SDL_Window * window)
 {
@@ -1156,8 +1162,8 @@
         devdata->glFlush();
 
     SDL_DFB_CHECKERR(windata->gl_context->Unlock(windata->gl_context));
-    SDL_DFB_CHECKERR(windata->surface->
-                     Flip(windata->surface, &region, DSFLIP_ONSYNC));
+    SDL_DFB_CHECKERR(windata->
+                     surface->Flip(windata->surface, &region, DSFLIP_ONSYNC));
     SDL_DFB_CHECKERR(windata->gl_context->Lock(windata->gl_context));
 
     return;
diff -r dd25eabe441c -r 204be4fc2726 src/video/fbcon/SDL_fb3dfx.c
--- a/src/video/fbcon/SDL_fb3dfx.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/fbcon/SDL_fb3dfx.c	Wed Aug 27 15:10:03 2008 +0000
@@ -37,6 +37,7 @@
     /* wait until we're past the start */
     while ((tdfx_in32(TDFX_STATUS) & STATUS_RETRACE) == 0);
 }
+
 static void
 WaitIdle(_THIS)
 {
diff -r dd25eabe441c -r 204be4fc2726 src/video/fbcon/SDL_fbelo.c
--- a/src/video/fbcon/SDL_fbelo.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/fbcon/SDL_fbelo.c	Wed Aug 27 15:10:03 2008 +0000
@@ -268,8 +268,7 @@
         if (result == 0) {
             i--;
         }
-    }
-    while (!ok && (i > 0));
+    } while (!ok && (i > 0));
 
     return ok;
 }
diff -r dd25eabe441c -r 204be4fc2726 src/video/fbcon/SDL_fbevents.c
--- a/src/video/fbcon/SDL_fbevents.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/fbcon/SDL_fbevents.c	Wed Aug 27 15:10:03 2008 +0000
@@ -545,9 +545,8 @@
                 if (select(fd + 1, &fdset, 0, 0, &tv) < 1) {
                     break;
                 }
-            }
-            while ((read(fd, &ch, sizeof(ch)) == sizeof(ch)) &&
-                   ((ch == 0xFA) || (ch == 0xAA)));
+            } while ((read(fd, &ch, sizeof(ch)) == sizeof(ch)) &&
+                     ((ch == 0xFA) || (ch == 0xAA)));
 
             /* Experimental values (Logitech wheelmouse) */
 #ifdef DEBUG_MOUSE
@@ -970,6 +969,7 @@
     ioctl(keyboard_fd, KDSETMODE, KD_TEXT);
     ioctl(keyboard_fd, VT_UNLOCKSWITCH, 1);
 }
+
 static void
 switch_vt_done(_THIS)
 {
@@ -995,6 +995,7 @@
                          (SDL_APPACTIVE | SDL_APPINPUTFOCUS |
                           SDL_APPMOUSEFOCUS));
 }
+
 static void
 switch_vt(_THIS, unsigned short which)
 {
@@ -1113,8 +1114,7 @@
                 }
             }
         }
-    }
-    while (posted);
+    } while (posted);
 }
 
 void
diff -r dd25eabe441c -r 204be4fc2726 src/video/fbcon/SDL_fbmatrox.c
--- a/src/video/fbcon/SDL_fbmatrox.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/fbcon/SDL_fbmatrox.c	Wed Aug 27 15:10:03 2008 +0000
@@ -41,6 +41,7 @@
     count = mga_in32(0x1E20) + 2;
     while (mga_in32(0x1E20) < count);
 }
+
 static void
 WaitIdle(_THIS)
 {
diff -r dd25eabe441c -r 204be4fc2726 src/video/fbcon/SDL_fbriva.c
--- a/src/video/fbcon/SDL_fbriva.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/fbcon/SDL_fbriva.c	Wed Aug 27 15:10:03 2008 +0000
@@ -40,6 +40,7 @@
     while ((*port & 0x08));
     while (!(*port & 0x08));
 }
+
 static void
 NV3WaitIdle(_THIS)
 {
@@ -47,6 +48,7 @@
     while ((Rop->FifoFree < FifoEmptyCount) ||
            (*(mapped_io + PGRAPH_OFFSET + 0x000006B0) & 0x01));
 }
+
 static void
 NV4WaitIdle(_THIS)
 {
diff -r dd25eabe441c -r 204be4fc2726 src/video/fbcon/SDL_fbvideo.c
--- a/src/video/fbcon/SDL_fbvideo.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/fbcon/SDL_fbvideo.c	Wed Aug 27 15:10:03 2008 +0000
@@ -82,6 +82,7 @@
     {0, 0, 320, 240},
     {0, 0, 320, 200}
 };
+
 static const struct
 {
     int xres;
@@ -323,15 +324,13 @@
             blank = 1;
         else
             blank = 0;
-    }
-    while (blank);
+    } while (blank);
     /* remove whitespace at the begining of the string */
     i = 0;
     do {
         line[i] = c[i];
         i++;
-    }
-    while (c[i] != 0);
+    } while (c[i] != 0);
     return 1;
 }
 
@@ -347,8 +346,7 @@
             return 0;
         if (SDL_strncmp(line, "geometry", 8) == 0)
             break;
-    }
-    while (1);
+    } while (1);
 
     SDL_sscanf(line, "geometry %d %d %d %d %d", &vinfo->xres, &vinfo->yres,
                &vinfo->xres_virtual, &vinfo->yres_virtual,
@@ -394,8 +392,7 @@
             if (SDL_strncmp(option, "true", 4) == 0)
                 vinfo->vmode |= FB_VMODE_DOUBLE;
         }
-    }
-    while (SDL_strncmp(line, "endmode", 7) != 0);
+    } while (SDL_strncmp(line, "endmode", 7) != 0);
 
     return 1;
 }
@@ -826,6 +823,7 @@
     fprintf(stderr, "\talpha: %d/%d\n", vinfo->transp.length,
             vinfo->transp.offset);
 }
+
 static void
 print_finfo(struct fb_fix_screeninfo *finfo)
 {
@@ -1193,6 +1191,7 @@
     screen->hwdata = (struct private_hwdata *) &surfaces;
     return (0);
 }
+
 static void
 FB_FreeHWSurfaces(_THIS)
 {
@@ -1283,6 +1282,7 @@
     surface->hwdata = (struct private_hwdata *) bucket;
     return (0);
 }
+
 static void
 FB_FreeHWSurface(_THIS, SDL_Surface * surface)
 {
@@ -1352,6 +1352,7 @@
     }
     return (0);
 }
+
 static void
 FB_UnlockHWSurface(_THIS, SDL_Surface * surface)
 {
diff -r dd25eabe441c -r 204be4fc2726 src/video/gapi/SDL_gapivideo.c
--- a/src/video/gapi/SDL_gapivideo.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/gapi/SDL_gapivideo.c	Wed Aug 27 15:10:03 2008 +0000
@@ -340,8 +340,7 @@
                                                             gx.GXSuspend,
                                                             "?GXSuspend@@YAHXZ")
         LINK(GXResume, gx.GXResume, "?GXResume@@YAHXZ") LINK(GXSetViewport,
-                                                             gx.
-                                                             GXSetViewport,
+                                                             gx.GXSetViewport,
                                                              "?GXSetViewport@@YAHKKKK@Z")
         LINK(GXIsDisplayDRAMBuffer, gx.GXIsDisplayDRAMBuffer,
              "?GXIsDisplayDRAMBuffer@@YAHXZ")
@@ -807,6 +806,7 @@
 {
     return (-1);
 }
+
 static void
 GAPI_FreeHWSurface(_THIS, SDL_Surface * surface)
 {
diff -r dd25eabe441c -r 204be4fc2726 src/video/ipod/SDL_ipodvideo.c
--- a/src/video/ipod/SDL_ipodvideo.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/ipod/SDL_ipodvideo.c	Wed Aug 27 15:10:03 2008 +0000
@@ -526,8 +526,7 @@
         }
         if (dbgout)
             fprintf(dbgout, "\n");
-    }
-    while (posted);
+    } while (posted);
 }
 
 // enough space for 160x128x2
@@ -570,8 +569,7 @@
         do {
             if ((inl(lcd_base) & (unsigned int) 0x8000) == 0)
                 break;
-        }
-        while (M_timer_check(start, 1000) == 0);
+        } while (M_timer_check(start, 1000) == 0);
     }
 }
 
@@ -681,10 +679,10 @@
         do {
             if ((inl(0x70008A0C) & 0x80000000) == 0)
                 break;
-        }
-        while (C_timer_check(start, 1000) == 0);
+        } while (C_timer_check(start, 1000) == 0);
     }
 }
+
 static void
 C_lcd_cmd_data(int cmd, int data)
 {
@@ -780,10 +778,12 @@
                     ipod_scr[y * (lcd_width / 4) + x / 4] |=
                         (((Uint8 *) (SDL_VideoSurface->pixels))[y *
                                                                 SDL_VideoSurface->
-                                                                pitch
-                                                                +
-                                                                x] &
-                         3) << (2 * (x % 4));
+                                                                pitch +
+                                                                x] & 3) << (2
+                                                                            *
+                                                                            (x
+                                                                             %
+                                                                             4));
                 }
             }
         }
diff -r dd25eabe441c -r 204be4fc2726 src/video/nds/SDL_ndsevents.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/nds/SDL_ndsevents.c	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,54 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Being a null driver, there's no event stream. We just define stubs for
+   most of the API. */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <nds.h>
+
+#include "SDL.h"
+#include "../../events/SDL_sysevents.h"
+#include "../../events/SDL_events_c.h"
+
+#include "SDL_ndsvideo.h"
+#include "SDL_ndsevents_c.h"
+
+void
+NDS_PumpEvents(_THIS)
+{
+    scanKeys();
+    /* TODO: defer click-age */
+    if (keysDown() & KEY_TOUCH) {
+        SDL_SendMouseButton(0, SDL_PRESSED, 0);
+    } else if (keysUp() & KEY_TOUCH) {
+        SDL_SendMouseButton(0, SDL_RELEASED, 0);
+    }
+    if (keysHeld() & KEY_TOUCH) {
+        touchPosition t = touchReadXY();
+        SDL_SendMouseMotion(0, 0, t.px, t.py);
+    }
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
diff -r dd25eabe441c -r 204be4fc2726 src/video/nds/SDL_ndsevents_c.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/nds/SDL_ndsevents_c.h	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,28 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#include "SDL_ndsvideo.h"
+
+extern void NDS_PumpEvents(_THIS);
+
+/* vi: set ts=4 sw=4 expandtab: */
diff -r dd25eabe441c -r 204be4fc2726 src/video/nds/SDL_ndsrender.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/nds/SDL_ndsrender.c	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,660 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <nds.h>
+#include <nds/arm9/video.h>
+#include <nds/arm9/sprite.h>
+#include <nds/arm9/trig_lut.h>
+
+#include "SDL_config.h"
+
+#include "SDL_video.h"
+#include "../SDL_sysvideo.h"
+#include "../SDL_yuv_sw_c.h"
+#include "../SDL_renderer_sw.h"
+
+/* NDS sprite-related functions */
+#define SPRITE_DMA_CHANNEL 3
+#define SPRITE_ANGLE_MASK 0x01FF
+
+void
+NDS_OAM_Update(tOAM * oam, int sub)
+{
+    DC_FlushAll();
+    dmaCopyHalfWords(SPRITE_DMA_CHANNEL, oam->spriteBuffer,
+                     sub ? OAM_SUB : OAM, SPRITE_COUNT * sizeof(SpriteEntry));
+}
+
+void
+NDS_OAM_RotateSprite(SpriteRotation * spriteRotation, u16 angle)
+{
+    s16 s = SIN[angle & SPRITE_ANGLE_MASK] >> 4;
+    s16 c = COS[angle & SPRITE_ANGLE_MASK] >> 4;
+
+    spriteRotation->hdx = c;
+    spriteRotation->hdy = s;
+    spriteRotation->vdx = -s;
+    spriteRotation->vdy = c;
+}
+
+void
+NDS_OAM_Init(tOAM * oam, int sub)
+{
+    int i;
+    for (i = 0; i < SPRITE_COUNT; i++) {
+        oam->spriteBuffer[i].attribute[0] = ATTR0_DISABLED;
+        oam->spriteBuffer[i].attribute[1] = 0;
+        oam->spriteBuffer[i].attribute[2] = 0;
+    }
+    for (i = 0; i < MATRIX_COUNT; i++) {
+        NDS_OAM_RotateSprite(&(oam->matrixBuffer[i]), 0);
+    }
+    swiWaitForVBlank();
+    NDS_OAM_Update(oam, sub);
+}
+
+void
+NDS_OAM_HideSprite(SpriteEntry * spriteEntry)
+{
+    spriteEntry->isRotoscale = 0;
+    spriteEntry->isHidden = 1;
+}
+
+void
+NDS_OAM_ShowSprite(SpriteEntry * spriteEntry, int affine, int double_bound)
+{
+    if (affine) {
+        spriteEntry->isRotoscale = 1;
+        spriteEntry->rsDouble = double_bound;
+    } else {
+        spriteEntry->isHidden = 0;
+    }
+}
+
+
+/* SDL NDS renderer implementation */
+
+static SDL_Renderer *NDS_CreateRenderer(SDL_Window * window, Uint32 flags);
+static int NDS_ActivateRenderer(SDL_Renderer * renderer);
+static int NDS_DisplayModeChanged(SDL_Renderer * renderer);
+static int NDS_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture);
+static int NDS_QueryTexturePixels(SDL_Renderer * renderer,
+                                  SDL_Texture * texture, void **pixels,
+                                  int *pitch);
+static int NDS_SetTexturePalette(SDL_Renderer * renderer,
+                                 SDL_Texture * texture,
+                                 const SDL_Color * colors, int firstcolor,
+                                 int ncolors);
+static int NDS_GetTexturePalette(SDL_Renderer * renderer,
+                                 SDL_Texture * texture, SDL_Color * colors,
+                                 int firstcolor, int ncolors);
+static int NDS_SetTextureColorMod(SDL_Renderer * renderer,
+                                  SDL_Texture * texture);
+static int NDS_SetTextureAlphaMod(SDL_Renderer * renderer,
+                                  SDL_Texture * texture);
+static int NDS_SetTextureBlendMode(SDL_Renderer * renderer,
+                                   SDL_Texture * texture);
+static int NDS_SetTextureScaleMode(SDL_Renderer * renderer,
+                                   SDL_Texture * texture);
+static int NDS_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
+                             const SDL_Rect * rect, const void *pixels,
+                             int pitch);
+static int NDS_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
+                           const SDL_Rect * rect, int markDirty,
+                           void **pixels, int *pitch);
+static void NDS_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture);
+static void NDS_DirtyTexture(SDL_Renderer * renderer,
+                             SDL_Texture * texture, int numrects,
+                             const SDL_Rect * rects);
+static int NDS_RenderFill(SDL_Renderer * renderer, Uint8 r, Uint8 g,
+                          Uint8 b, Uint8 a, const SDL_Rect * rect);
+static int NDS_RenderCopy(SDL_Renderer * renderer,
+                          SDL_Texture * texture,
+                          const SDL_Rect * srcrect, const SDL_Rect * dstrect);
+static void NDS_RenderPresent(SDL_Renderer * renderer);
+static void NDS_DestroyTexture(SDL_Renderer * renderer,
+                               SDL_Texture * texture);
+static void NDS_DestroyRenderer(SDL_Renderer * renderer);
+
+
+SDL_RenderDriver NDS_RenderDriver = {
+    NDS_CreateRenderer,
+    {"nds",                     /* char* name */
+     (SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTDISCARD | SDL_RENDERER_PRESENTVSYNC),  /* u32 flags */
+     (SDL_TEXTUREMODULATE_NONE),        /* u32 mod_modes */
+     (SDL_TEXTUREBLENDMODE_MASK),       /* u32 blend_modes */
+     (SDL_TEXTURESCALEMODE_FAST),       /* u32 scale_modes */
+     3,                         /* u32 num_texture_formats */
+     {
+      SDL_PIXELFORMAT_INDEX8,
+      SDL_PIXELFORMAT_ABGR1555,
+      SDL_PIXELFORMAT_BGR555,
+      },                        /* u32 texture_formats[20] */
+     (256),                     /* int max_texture_width */
+     (256),                     /* int max_texture_height */
+     }
+};
+
+typedef struct
+{
+    bg_attribute *bg;           /* backgrounds */
+    tOAM oam_copy;              /* sprites */
+    u8 bg_taken[4];
+    int sub;
+} NDS_RenderData;
+
+typedef struct
+{
+    enum
+    { NDSTX_BG, NDSTX_SPR } type;       /* represented in a bg or sprite. */
+    int hw_index;               /* sprite: index in the OAM. /  bg: 2 or 3. */
+    struct
+    {
+        int hdx, hdy, vdx, vdy; /* affine transformation, used for scaling. */
+        int pitch, bpp;         /* some useful info */
+    } dim;
+    u16 *vram_pixels;           /* where the pixel data is stored (a pointer into VRAM) */
+    u16 *vram_palette;          /* where the palette data is stored if it's indexed. */
+    /*int size; */
+} NDS_TextureData;
+
+
+
+SDL_Renderer *
+NDS_CreateRenderer(SDL_Window * window, Uint32 flags)
+{
+    SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
+    SDL_DisplayMode *displayMode = &display->current_mode;
+    SDL_Renderer *renderer;
+    NDS_RenderData *data;
+    int i, n;
+    int bpp;
+    Uint32 Rmask, Gmask, Bmask, Amask;
+
+    if (!SDL_PixelFormatEnumToMasks(displayMode->format, &bpp,
+                                    &Rmask, &Gmask, &Bmask, &Amask)) {
+        SDL_SetError("Unknown display format");
+        return NULL;
+    }
+    switch (displayMode->format) {
+    case SDL_PIXELFORMAT_INDEX8:
+    case SDL_PIXELFORMAT_ABGR1555:
+    case SDL_PIXELFORMAT_BGR555:
+        /* okay */
+        break;
+    case SDL_PIXELFORMAT_RGB555:
+    case SDL_PIXELFORMAT_RGB565:
+    case SDL_PIXELFORMAT_ARGB1555:
+        /* we'll take these too for now */
+        break;
+    default:
+        SDL_SetError("Warning: wrong display format for NDS!\n");
+        break;
+    }
+
+    renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
+    if (!renderer) {
+        SDL_OutOfMemory();
+        return NULL;
+    }
+
+    data = (NDS_RenderData *) SDL_malloc(sizeof(*data));
+    if (!data) {
+        NDS_DestroyRenderer(renderer);
+        SDL_OutOfMemory();
+        return NULL;
+    }
+    SDL_zerop(data);
+
+    renderer->RenderFill = NDS_RenderFill;
+    renderer->RenderCopy = NDS_RenderCopy;
+    renderer->RenderPresent = NDS_RenderPresent;
+    renderer->DestroyRenderer = NDS_DestroyRenderer;
+    renderer->info.name = NDS_RenderDriver.info.name;
+    renderer->info.flags = 0;
+    renderer->window = window->id;
+    renderer->driverdata = data;
+    renderer->CreateTexture = NDS_CreateTexture;
+    renderer->QueryTexturePixels = NDS_QueryTexturePixels;
+    renderer->SetTexturePalette = NDS_SetTexturePalette;
+    renderer->GetTexturePalette = NDS_GetTexturePalette;
+    renderer->SetTextureColorMod = NDS_SetTextureColorMod;
+    renderer->SetTextureAlphaMod = NDS_SetTextureAlphaMod;
+    renderer->SetTextureBlendMode = NDS_SetTextureBlendMode;
+    renderer->SetTextureScaleMode = NDS_SetTextureScaleMode;
+    renderer->UpdateTexture = NDS_UpdateTexture;
+    renderer->LockTexture = NDS_LockTexture;
+    renderer->UnlockTexture = NDS_UnlockTexture;
+    renderer->DirtyTexture = NDS_DirtyTexture;
+    renderer->DestroyTexture = NDS_DestroyTexture;
+
+    renderer->info.mod_modes = NDS_RenderDriver.info.mod_modes;
+    renderer->info.blend_modes = NDS_RenderDriver.info.blend_modes;
+    renderer->info.scale_modes = NDS_RenderDriver.info.scale_modes;
+    renderer->info.num_texture_formats =
+        NDS_RenderDriver.info.num_texture_formats;
+    SDL_memcpy(renderer->info.texture_formats,
+               NDS_RenderDriver.info.texture_formats,
+               sizeof(renderer->info.texture_formats));
+    renderer->info.max_texture_width =
+        NDS_RenderDriver.info.max_texture_width;
+    renderer->info.max_texture_height =
+        NDS_RenderDriver.info.max_texture_height;
+
+    data->sub = 0;              /* TODO: this is hard-coded to the "main" screen.
+                                   figure out how to detect whether to set it to
+                                   "sub" screen.  window->id, perhaps? */
+    if (!data->sub) {
+        data->bg = &BACKGROUND;
+    } else {
+        data->bg = &BACKGROUND_SUB;
+    }
+    data->bg_taken[2] = data->bg_taken[3] = 0;
+
+    NDS_OAM_Init(&(data->oam_copy), data->sub); /* init sprites. */
+
+    return renderer;
+}
+
+static int
+NDS_ActivateRenderer(SDL_Renderer * renderer)
+{
+    NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata;
+
+    return 0;
+}
+
+static int
+NDS_DisplayModeChanged(SDL_Renderer * renderer)
+{
+    NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata;
+
+    return 0;
+}
+
+static int
+NDS_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
+{
+    NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata;
+    NDS_TextureData *txdat = NULL;
+    int i;
+    int bpp;
+    Uint32 Rmask, Gmask, Bmask, Amask;
+
+    if (!SDL_PixelFormatEnumToMasks
+        (texture->format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) {
+        SDL_SetError("Unknown texture format");
+        return -1;
+    }
+
+    /* conditional statements on w/h to place it as bg/sprite
+       depending on which one it fits. */
+    if (texture->w <= 64 && texture->h <= 64) {
+        int whichspr = -1;
+        printf("Tried to make a sprite.\n");
+        txdat->type = NDSTX_SPR;
+        for (i = 0; i < SPRITE_COUNT; ++i) {
+            if (data->oam_copy.spriteBuffer[i].attribute[0] & ATTR0_DISABLED) {
+                whichspr = i;
+                break;
+            }
+        }
+        if (whichspr >= 0) {
+            SpriteEntry *sprent = &(data->oam_copy.spriteBuffer[whichspr]);
+            int maxside = texture->w > texture->h ? texture->w : texture->h;
+            int pitch;
+
+            texture->driverdata = SDL_calloc(1, sizeof(NDS_TextureData));
+            txdat = (NDS_TextureData *) texture->driverdata;
+            if (!txdat) {
+                SDL_OutOfMemory();
+                return -1;
+            }
+
+            sprent->objMode = OBJMODE_BITMAP;
+            sprent->posX = 0;
+            sprent->posY = 0;
+            sprent->colMode = OBJCOLOR_16;      /* OBJCOLOR_256 for INDEX8 */
+
+            /* the first 32 sprites get transformation matrices.
+               first come, first served */
+            if (whichspr < MATRIX_COUNT) {
+                sprent->isRotoscale = 1;
+                sprent->rsMatrixIdx = whichspr;
+            }
+
+            /* containing shape (square or 2:1 rectangles) */
+            sprent->objShape = OBJSHAPE_SQUARE;
+            if (texture->w / 2 >= texture->h) {
+                sprent->objShape = OBJSHAPE_WIDE;
+            } else if (texture->h / 2 >= texture->w) {
+                sprent->objShape = OBJSHAPE_TALL;
+            }
+
+            /* size in pixels */
+            /* FIXME: "pitch" is hardcoded for 2bytes per pixel. */
+            sprent->objSize = OBJSIZE_64;
+            pitch = 128;
+            if (maxside <= 8) {
+                sprent->objSize = OBJSIZE_8;
+                pitch = 16;
+            } else if (maxside <= 16) {
+                sprent->objSize = OBJSIZE_16;
+                pitch = 32;
+            } else if (maxside <= 32) {
+                sprent->objSize = OBJSIZE_32;
+                pitch = 64;
+            }
+
+            /* FIXME: this is hard-coded and will obviously only work for one
+               sprite-texture.  tells it to look at the beginning of SPRITE_GFX
+               for its pixels. */
+            sprent->tileIdx = 0;
+
+            /* now for the texture data */
+            txdat->type = NDSTX_SPR;
+            txdat->hw_index = whichspr;
+            txdat->dim.hdx = 0x100;
+            txdat->dim.hdy = 0;
+            txdat->dim.vdx = 0;
+            txdat->dim.vdy = 0x100;
+            txdat->dim.pitch = pitch;
+            txdat->dim.bpp = bpp;
+            txdat->vram_pixels = (u16 *) (data->sub ? SPRITE_GFX_SUB : SPRITE_GFX);     /* FIXME: use tileIdx*boundary
+                                                                                           to point to proper location */
+        } else {
+            SDL_SetError("Out of NDS sprites.");
+        }
+    } else if (texture->w <= 256 && texture->h <= 256) {
+        int whichbg = -1, base = 0;
+        if (!data->bg_taken[2]) {
+            whichbg = 2;
+        } else if (!data->bg_taken[3]) {
+            whichbg = 3;
+            base = 4;
+        }
+        if (whichbg >= 0) {
+            texture->driverdata = SDL_calloc(1, sizeof(NDS_TextureData));
+            txdat = (NDS_TextureData *) texture->driverdata;
+            if (!txdat) {
+                SDL_OutOfMemory();
+                return -1;
+            }
+
+            /* this is hard-coded to being 256x256 ABGR1555 for now. */
+            data->bg->control[whichbg] = (bpp == 8) ?
+                BG_BMP8_256x256 : BG_BMP16_256x256;
+
+            data->bg->control[whichbg] |= BG_BMP_BASE(base);
+
+            data->bg->scroll[whichbg].x = 0;
+            data->bg->scroll[whichbg].y = 0;
+
+            txdat->type = NDSTX_BG;
+            txdat->hw_index = whichbg;
+            txdat->dim.hdx = 0x100;
+            txdat->dim.hdy = 0;
+            txdat->dim.vdx = 0;
+            txdat->dim.vdy = 0x100;
+            txdat->dim.pitch = 512;
+            txdat->dim.bpp = bpp;
+            txdat->vram_pixels = (u16 *) (data->sub ?
+                                          BG_BMP_RAM_SUB(base) :
+                                          BG_BMP_RAM(base));
+
+            /*txdat->size = txdat->dim.pitch * texture->h; */
+        } else {
+            SDL_SetError("Out of NDS backgrounds.");
+        }
+    } else {
+        SDL_SetError("Texture too big for NDS hardware.");
+    }
+
+    if (!texture->driverdata) {
+        return -1;
+    }
+
+    return 0;
+}
+
+static int
+NDS_QueryTexturePixels(SDL_Renderer * renderer, SDL_Texture * texture,
+                       void **pixels, int *pitch)
+{
+    NDS_TextureData *txdat = (NDS_TextureData *) texture->driverdata;
+    *pixels = txdat->vram_pixels;
+    *pitch = txdat->dim.pitch;
+    return 0;
+}
+
+static int
+NDS_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
+                  const SDL_Rect * rect, const void *pixels, int pitch)
+{
+    NDS_TextureData *txdat;
+    Uint8 *src, *dst;
+    int row;
+    size_t length;
+
+    txdat = (NDS_TextureData *) texture->driverdata;
+
+    src = (Uint8 *) pixels;
+    dst =
+        (Uint8 *) txdat->vram_pixels + rect->y * txdat->dim.pitch +
+        rect->x * ((txdat->dim.bpp + 1) / 8);
+    length = rect->w * ((txdat->dim.bpp + 1) / 8);
+
+    if (rect->w == texture->w) {
+        dmaCopy(src, dst, length * rect->h);
+    } else {
+        for (row = 0; row < rect->h; ++row) {
+            dmaCopy(src, dst, length);
+            src += pitch;
+            dst += txdat->dim.pitch;
+        }
+    }
+
+    return 0;
+}
+
+static int
+NDS_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
+                const SDL_Rect * rect, int markDirty, void **pixels,
+                int *pitch)
+{
+    NDS_TextureData *txdat = (NDS_TextureData *) texture->driverdata;
+
+    *pixels = (void *) ((u8 *) txdat->vram_pixels + rect->y
+                        * txdat->dim.pitch +
+                        rect->x * ((txdat->dim.bpp + 1) / 8));
+    *pitch = txdat->dim.pitch;
+
+    return 0;
+}
+
+static void
+NDS_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
+{
+    /* stub! */
+}
+
+static void
+NDS_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture,
+                 int numrects, const SDL_Rect * rects)
+{
+    /* stub! */
+}
+
+static int
+NDS_RenderFill(SDL_Renderer * renderer, Uint8 r, Uint8 g, Uint8 b,
+               Uint8 a, const SDL_Rect * rect)
+{
+    NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata;
+    SDL_Rect real_rect = *rect;
+    u16 color;
+    int i, j;
+
+    color = RGB8(r, g, b);      /* <-- macro in libnds that makes an ARGB1555 pixel */
+    /* TODO: make a single-color sprite and stretch it.
+       calculate the "HDX" width modifier of the sprite by:
+       let S be the actual sprite's width (like, 32 pixels for example)
+       let R be the rectangle's width (maybe 50 pixels)
+       HDX = (R<<8) / S;
+       (it's fixed point, hence the bit shift.  same goes for vertical.
+       be sure to use 32-bit int's for the bit shift before the division!)
+     */
+
+    return 0;
+}
+
+static int
+NDS_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
+               const SDL_Rect * srcrect, const SDL_Rect * dstrect)
+{
+    NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata;
+    NDS_TextureData *txdat = (NDS_TextureData *) texture->driverdata;
+    SDL_Window *window = SDL_GetWindowFromID(renderer->window);
+    SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
+    int i;
+    int bpp = SDL_BYTESPERPIXEL(texture->format);
+    int pitch = txdat->dim.pitch;
+
+    if (txdat->type == NDSTX_BG) {
+        bg_rotation *bgrot = (txdat->hw_index == 2) ?
+            &(data->bg->bg2_rotation) : &(data->bg->bg3_rotation);
+        bgrot->xdx = txdat->dim.hdx;
+        bgrot->xdy = txdat->dim.hdy;
+        bgrot->ydx = txdat->dim.vdx;
+        bgrot->ydy = txdat->dim.vdy;
+        bgrot->centerX = 0;
+        bgrot->centerY = 0;
+
+        data->bg->scroll[txdat->hw_index].x = dstrect->x;
+        data->bg->scroll[txdat->hw_index].y = dstrect->y;
+    } else {
+        /* sprites not fully implemented yet */
+        SpriteEntry *spr = &(data->oam_copy.spriteBuffer[txdat->hw_index]);
+        spr->posX = dstrect->x;
+        spr->posY = dstrect->y;
+        if (txdat->hw_index < MATRIX_COUNT && spr->isRotoscale) {
+            SpriteRotation *sprot =
+                &(data->oam_copy.matrixBuffer[txdat->hw_index]);
+            sprot->hdx = txdat->dim.hdx;
+            sprot->hdy = txdat->dim.hdy;
+            sprot->vdx = txdat->dim.vdx;
+            sprot->vdy = txdat->dim.vdy;
+        }
+    }
+
+    return 0;
+}
+
+
+static void
+NDS_RenderPresent(SDL_Renderer * renderer)
+{
+    NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata;
+    SDL_Window *window = SDL_GetWindowFromID(renderer->window);
+    SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
+
+    /* update sprites */
+    NDS_OAM_Update(&(data->oam_copy), data->sub);
+    /* vsync for NDS */
+    if (renderer->info.flags & SDL_RENDERER_PRESENTVSYNC) {
+        swiWaitForVBlank();
+    }
+}
+
+static void
+NDS_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
+{
+    NDS_TextureData *txdat = texture->driverdata;
+    /* free anything else allocated for texture */
+    SDL_free(txdat);
+}
+
+static void
+NDS_DestroyRenderer(SDL_Renderer * renderer)
+{
+    NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata;
+    SDL_Window *window = SDL_GetWindowFromID(renderer->window);
+    SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
+    int i;
+
+    if (data) {
+        /* free anything else relevant if anything else is allocated. */
+        SDL_free(data);
+    }
+    SDL_free(renderer);
+}
+
+static int
+NDS_SetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture,
+                      const SDL_Color * colors, int firstcolor, int ncolors)
+{
+    NDS_TextureData *txdat = (NDS_TextureData *) texture->driverdata;
+    /* set 8-bit modes in the background control registers
+       for backgrounds, BGn_CR |= BG_256_COLOR */
+
+    return 0;
+}
+
+static int
+NDS_GetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture,
+                      SDL_Color * colors, int firstcolor, int ncolors)
+{
+    NDS_TextureData *txdat = (NDS_TextureData *) texture->driverdata;
+    /* stub! */
+    return 0;
+}
+
+static int
+NDS_SetTextureColorMod(SDL_Renderer * renderer, SDL_Texture * texture)
+{
+    /* stub! */
+    return 0;
+}
+
+static int
+NDS_SetTextureAlphaMod(SDL_Renderer * renderer, SDL_Texture * texture)
+{
+    /* stub! */
+    return 0;
+}
+
+static int
+NDS_SetTextureBlendMode(SDL_Renderer * renderer, SDL_Texture * texture)
+{
+    /* stub! */
+    return 0;
+}
+
+static int
+NDS_SetTextureScaleMode(SDL_Renderer * renderer, SDL_Texture * texture)
+{
+    /* stub! (note: NDS hardware scaling is nearest neighbor.) */
+    return 0;
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
diff -r dd25eabe441c -r 204be4fc2726 src/video/nds/SDL_ndsrender_c.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/nds/SDL_ndsrender_c.h	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,28 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* SDL surface based renderer implementation */
+
+extern SDL_RenderDriver NDS_RenderDriver;
+
+/* vi: set ts=4 sw=4 expandtab: */
diff -r dd25eabe441c -r 204be4fc2726 src/video/nds/SDL_ndsvideo.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/nds/SDL_ndsvideo.c	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,168 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* SDL Nintendo DS video driver implementation
+ * based on dummy driver:
+ *  Initial work by Ryan C. Gordon (icculus@icculus.org). A good portion
+ *  of this was cut-and-pasted from Stephane Peter's work in the AAlib
+ *  SDL video driver.  Renamed to "DUMMY" by Sam Lantinga.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <nds.h>
+#include <nds/arm9/video.h>
+
+#include "SDL_video.h"
+#include "SDL_mouse.h"
+#include "../SDL_sysvideo.h"
+#include "../SDL_pixels_c.h"
+#include "../../events/SDL_events_c.h"
+
+#include "SDL_ndsvideo.h"
+#include "SDL_ndsevents_c.h"
+#include "SDL_ndsrender_c.h"
+
+#define NDSVID_DRIVER_NAME "nds"
+
+/* Initialization/Query functions */
+static int NDS_VideoInit(_THIS);
+static int NDS_SetDisplayMode(_THIS, SDL_DisplayMode * mode);
+static void NDS_VideoQuit(_THIS);
+
+
+/* SDL NDS driver bootstrap functions */
+static int
+NDS_Available(void)
+{
+    return (1);                 /* always here */
+}
+
+static void
+NDS_DeleteDevice(SDL_VideoDevice * device)
+{
+    SDL_free(device);
+}
+
+static SDL_VideoDevice *
+NDS_CreateDevice(int devindex)
+{
+    SDL_VideoDevice *device;
+
+    /* Initialize all variables that we clean on shutdown */
+    device = (SDL_VideoDevice *) SDL_calloc(1, sizeof(SDL_VideoDevice));
+    if (!device) {
+        SDL_OutOfMemory();
+        if (device) {
+            SDL_free(device);
+        }
+        return (0);
+    }
+
+    /* Set the function pointers */
+    device->VideoInit = NDS_VideoInit;
+    device->VideoQuit = NDS_VideoQuit;
+    device->SetDisplayMode = NDS_SetDisplayMode;
+    device->PumpEvents = NDS_PumpEvents;
+
+    device->num_displays = 2;   /* DS = dual screens */
+
+    device->free = NDS_DeleteDevice;
+
+    return device;
+}
+
+VideoBootStrap NDS_bootstrap = {
+    NDSVID_DRIVER_NAME, "SDL NDS video driver",
+    NDS_Available, NDS_CreateDevice
+};
+
+int
+NDS_VideoInit(_THIS)
+{
+    SDL_DisplayMode mode;
+    int i;
+
+    /* simple 256x192x16x60 for now */
+    mode.w = 256;
+    mode.h = 192;
+    mode.format = SDL_PIXELFORMAT_ABGR1555;
+    mode.refresh_rate = 60;
+    mode.driverdata = NULL;
+
+    SDL_AddBasicVideoDisplay(&mode);
+    SDL_AddRenderDriver(0, &NDS_RenderDriver);
+
+    SDL_zero(mode);
+    SDL_AddDisplayMode(0, &mode);
+
+    powerON(POWER_ALL_2D);
+    irqInit();
+    irqEnable(IRQ_VBLANK);
+    NDS_SetDisplayMode(_this, &mode);
+
+    return 0;
+}
+
+static int
+NDS_SetDisplayMode(_THIS, SDL_DisplayMode * mode)
+{
+    /* right now this function is just hard-coded for 256x192 ABGR1555 */
+    videoSetMode(MODE_5_2D | DISPLAY_BG2_ACTIVE | DISPLAY_BG3_ACTIVE | DISPLAY_BG_EXT_PALETTE | DISPLAY_SPR_1D_LAYOUT | DISPLAY_SPR_1D_BMP | DISPLAY_SPR_1D_BMP_SIZE_256 |      /* (try 128 if 256 is trouble.) */
+                 DISPLAY_SPR_ACTIVE | DISPLAY_SPR_EXT_PALETTE); /* display on main core
+                                                                   with lots of flags set for
+                                                                   flexibility/capacity to render */
+
+    /* hopefully these cover all the various things we might need to do */
+    vramSetBankA(VRAM_A_MAIN_BG_0x06000000);
+    vramSetBankB(VRAM_B_MAIN_BG_0x06020000);
+    vramSetBankC(VRAM_C_SUB_BG_0x06200000);
+    vramSetBankD(VRAM_D_MAIN_BG_0x06040000);    /* not a typo. vram d can't sub */
+    vramSetBankE(VRAM_E_MAIN_SPRITE);
+    vramSetBankF(VRAM_F_OBJ_EXT_PALETTE);
+    vramSetBankG(VRAM_G_BG_EXT_PALETTE);
+    vramSetBankH(VRAM_H_SUB_BG_EXT_PALETTE);
+    vramSetBankI(VRAM_I_SUB_SPRITE);
+
+    videoSetModeSub(MODE_0_2D | DISPLAY_BG0_ACTIVE);    /* debug text on sub
+                                                           TODO: this will change
+                                                           when multi-head is
+                                                           introduced in render */
+
+    return 0;
+}
+
+void
+NDS_VideoQuit(_THIS)
+{
+    videoSetMode(DISPLAY_SCREEN_OFF);
+    videoSetModeSub(DISPLAY_SCREEN_OFF);
+    vramSetMainBanks(VRAM_A_LCD, VRAM_B_LCD, VRAM_C_LCD, VRAM_D_LCD);
+    vramSetBankE(VRAM_E_LCD);
+    vramSetBankF(VRAM_F_LCD);
+    vramSetBankG(VRAM_G_LCD);
+    vramSetBankH(VRAM_H_LCD);
+    vramSetBankI(VRAM_I_LCD);
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
diff -r dd25eabe441c -r 204be4fc2726 src/video/nds/SDL_ndsvideo.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/nds/SDL_ndsvideo.h	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,31 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_ndsvideo_h
+#define _SDL_ndsvideo_h
+
+#include "../SDL_sysvideo.h"
+
+#endif /* _SDL_ndsvideo_h */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff -r dd25eabe441c -r 204be4fc2726 src/video/os2fslib/SDL_os2fslib.c
--- a/src/video/os2fslib/SDL_os2fslib.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/os2fslib/SDL_os2fslib.c	Wed Aug 27 15:10:03 2008 +0000
@@ -440,8 +440,8 @@
                     if ((!pVideo->hidden->pSDLSurface) ||
                         ((pVideo->hidden->pSDLSurface)
                          &&
-                         ((pVideo->hidden->pSDLSurface->
-                           flags & SDL_RESIZABLE) == 0)))
+                         ((pVideo->hidden->
+                           pSDLSurface->flags & SDL_RESIZABLE) == 0)))
                         FSLib_ToggleFSMode(hwnd, !FSLib_QueryFSMode(hwnd));
 #ifdef DEBUG_BUILD
                     else
@@ -552,11 +552,11 @@
                     {
 
                         iXScaleError =
-                            (pVideo->hidden->SrcBufferDesc.
-                             uiXResolution - 1) / swp.cx;
+                            (pVideo->hidden->SrcBufferDesc.uiXResolution -
+                             1) / swp.cx;
                         iYScaleError =
-                            (pVideo->hidden->SrcBufferDesc.
-                             uiYResolution - 1) / swp.cy;
+                            (pVideo->hidden->SrcBufferDesc.uiYResolution -
+                             1) / swp.cy;
                         if (iXScaleError < 0)
                             iXScaleError = 0;
                         if (iYScaleError < 0)
@@ -577,24 +577,22 @@
                         iTop =
                             (swp.cy -
                              rcl.yTop) *
-                            pVideo->hidden->SrcBufferDesc.
-                            uiYResolution / swp.cy - iYScaleError;
+                            pVideo->hidden->SrcBufferDesc.uiYResolution /
+                            swp.cy - iYScaleError;
                         iLeft =
                             rcl.xLeft *
-                            pVideo->hidden->SrcBufferDesc.
-                            uiXResolution / swp.cx - iXScaleError;
+                            pVideo->hidden->SrcBufferDesc.uiXResolution /
+                            swp.cx - iXScaleError;
                         iWidth =
                             ((rcl.xRight -
                               rcl.xLeft) *
-                             pVideo->hidden->SrcBufferDesc.
-                             uiXResolution + swp.cx - 1) / swp.cx +
-                            2 * iXScaleError;
+                             pVideo->hidden->SrcBufferDesc.uiXResolution +
+                             swp.cx - 1) / swp.cx + 2 * iXScaleError;
                         iHeight =
                             ((rcl.yTop -
                               rcl.yBottom) *
-                             pVideo->hidden->SrcBufferDesc.
-                             uiYResolution + swp.cy - 1) / swp.cy +
-                            2 * iYScaleError;
+                             pVideo->hidden->SrcBufferDesc.uiYResolution +
+                             swp.cy - 1) / swp.cy + 2 * iYScaleError;
 
                         iWidth += iXScaleError2;
                         iHeight += iYScaleError2;
@@ -606,20 +604,19 @@
                         if (iTop + iHeight >
                             pVideo->hidden->SrcBufferDesc.uiYResolution)
                             iHeight =
-                                pVideo->hidden->SrcBufferDesc.
-                                uiYResolution - iTop;
+                                pVideo->hidden->SrcBufferDesc.uiYResolution -
+                                iTop;
                         if (iLeft + iWidth >
                             pVideo->hidden->SrcBufferDesc.uiXResolution)
                             iWidth =
-                                pVideo->hidden->SrcBufferDesc.
-                                uiXResolution - iLeft;
+                                pVideo->hidden->SrcBufferDesc.uiXResolution -
+                                iLeft;
 
 #ifdef DEBUG_BUILD
                         printf
                             ("WM_PAINT : BitBlt: %d %d -> %d %d (Buf %d x %d)\n",
                              iTop, iLeft, iWidth, iHeight,
-                             pVideo->hidden->SrcBufferDesc.
-                             uiXResolution,
+                             pVideo->hidden->SrcBufferDesc.uiXResolution,
                              pVideo->hidden->SrcBufferDesc.uiYResolution);
                         fflush(stdout);
 #endif
@@ -693,15 +690,15 @@
                             WinQueryWindowPos(hwnd, &swp);
                             if ((!pVideo->hidden->pSDLSurface) ||
                                 ((pVideo->hidden->pSDLSurface) &&
-                                 (pVideo->hidden->pSDLSurface->
-                                  flags & SDL_RESIZABLE)
+                                 (pVideo->hidden->
+                                  pSDLSurface->flags & SDL_RESIZABLE)
                                  &&
                                  ((swp.cx !=
-                                   pVideo->hidden->SrcBufferDesc.
-                                   uiXResolution)
+                                   pVideo->hidden->
+                                   SrcBufferDesc.uiXResolution)
                                   || (swp.cy !=
-                                      pVideo->hidden->
-                                      SrcBufferDesc.uiYResolution))
+                                      pVideo->hidden->SrcBufferDesc.
+                                      uiYResolution))
                                  && (!FSLib_QueryFSMode(hwnd)))) {
                                 // Resizable surface and in resizing!
                                 // So, don't blit now!
@@ -718,14 +715,12 @@
                                 fflush(stdout);
 #endif
                                 FSLIB_BITBLT(hwnd,
-                                             pVideo->hidden->
-                                             pchSrcBuffer, 0,
+                                             pVideo->hidden->pchSrcBuffer, 0,
                                              0,
                                              pVideo->hidden->
-                                             SrcBufferDesc.
-                                             uiXResolution,
-                                             pVideo->hidden->
-                                             SrcBufferDesc.uiYResolution);
+                                             SrcBufferDesc.uiXResolution,
+                                             pVideo->hidden->SrcBufferDesc.
+                                             uiYResolution);
                             }
                         }
 #ifdef DEBUG_BUILD
@@ -773,8 +768,8 @@
                                           &swpClient);
                         ptl.x = 0;
                         ptl.y = 0;
-                        WinMapWindowPoints(pVideo->hidden->
-                                           hwndClient, HWND_DESKTOP, &ptl, 1);
+                        WinMapWindowPoints(pVideo->hidden->hwndClient,
+                                           HWND_DESKTOP, &ptl, 1);
                         pVideo->hidden->iSkipWMMOUSEMOVE++;     /* Don't take next WM_MOUSEMOVE into account!  */
                         WinSetPointerPos(HWND_DESKTOP,
                                          ptl.x + swpClient.cx / 2,
@@ -825,8 +820,8 @@
                                           &swpClient);
                         ptl.x = 0;
                         ptl.y = 0;
-                        WinMapWindowPoints(pVideo->hidden->
-                                           hwndClient, HWND_DESKTOP, &ptl, 1);
+                        WinMapWindowPoints(pVideo->hidden->hwndClient,
+                                           HWND_DESKTOP, &ptl, 1);
                         pVideo->hidden->iSkipWMMOUSEMOVE++;     /* Don't take next WM_MOUSEMOVE into account!  */
                         WinSetPointerPos(HWND_DESKTOP,
                                          ptl.x + swpClient.cx / 2,
@@ -867,8 +862,8 @@
                                           &swpClient);
                         ptl.x = 0;
                         ptl.y = 0;
-                        WinMapWindowPoints(pVideo->hidden->
-                                           hwndClient, HWND_DESKTOP, &ptl, 1);
+                        WinMapWindowPoints(pVideo->hidden->hwndClient,
+                                           HWND_DESKTOP, &ptl, 1);
                         pVideo->hidden->iSkipWMMOUSEMOVE++;     /* Don't take next WM_MOUSEMOVE into account!  */
                         WinSetPointerPos(HWND_DESKTOP,
                                          ptl.x + swpClient.cx / 2,
@@ -910,8 +905,8 @@
                                           &swpClient);
                         ptl.x = 0;
                         ptl.y = 0;
-                        WinMapWindowPoints(pVideo->hidden->
-                                           hwndClient, HWND_DESKTOP, &ptl, 1);
+                        WinMapWindowPoints(pVideo->hidden->hwndClient,
+                                           HWND_DESKTOP, &ptl, 1);
                         pVideo->hidden->iSkipWMMOUSEMOVE++;     /* Don't take next WM_MOUSEMOVE into account!  */
                         WinSetPointerPos(HWND_DESKTOP,
                                          ptl.x + swpClient.cx / 2,
@@ -1378,6 +1373,7 @@
     while (len-- > 0)
         *dst++ = ~*src++;
 }
+
 static void
 memxor(Uint8 * dst, Uint8 * src1, Uint8 * src2, int len)
 {
@@ -1635,6 +1631,7 @@
 {
     return (-1);
 }
+
 static void
 os2fslib_FreeHWSurface(_THIS, SDL_Surface * surface)
 {
@@ -2505,23 +2502,27 @@
         pResult = SDL_CreateRGBSurface(SDL_SWSURFACE,
                                        pModeInfoFound->uiXResolution,
                                        pModeInfoFound->uiYResolution,
-                                       pModeInfoFound->uiBPP,
-                                       ((unsigned int) pModeInfoFound->
-                                        PixelFormat.
-                                        ucRedMask) << pModeInfoFound->
-                                       PixelFormat.ucRedPosition,
-                                       ((unsigned int) pModeInfoFound->
-                                        PixelFormat.
-                                        ucGreenMask) << pModeInfoFound->
-                                       PixelFormat.ucGreenPosition,
-                                       ((unsigned int) pModeInfoFound->
-                                        PixelFormat.
-                                        ucBlueMask) << pModeInfoFound->
-                                       PixelFormat.ucBluePosition,
-                                       ((unsigned int) pModeInfoFound->
-                                        PixelFormat.
-                                        ucAlphaMask) << pModeInfoFound->
-                                       PixelFormat.ucAlphaPosition);
+                                       pModeInfoFound->uiBPP, ((unsigned int)
+                                                               pModeInfoFound->
+                                                               PixelFormat.
+                                                               ucRedMask)
+                                       << pModeInfoFound->PixelFormat.
+                                       ucRedPosition, ((unsigned int)
+                                                       pModeInfoFound->
+                                                       PixelFormat.
+                                                       ucGreenMask)
+                                       << pModeInfoFound->PixelFormat.
+                                       ucGreenPosition, ((unsigned int)
+                                                         pModeInfoFound->
+                                                         PixelFormat.
+                                                         ucBlueMask)
+                                       << pModeInfoFound->PixelFormat.
+                                       ucBluePosition, ((unsigned int)
+                                                        pModeInfoFound->
+                                                        PixelFormat.
+                                                        ucAlphaMask)
+                                       << pModeInfoFound->PixelFormat.
+                                       ucAlphaPosition);
 
         if (pResult == NULL) {
             DosReleaseMutexSem(_this->hidden->hmtxUseSrcBuffer);
@@ -2535,23 +2536,27 @@
 
         // Adjust pixel format mask!
         pResult->format->Rmask =
-            ((unsigned int) pModeInfoFound->PixelFormat.
-             ucRedMask) << pModeInfoFound->PixelFormat.ucRedPosition;
+            ((unsigned int) pModeInfoFound->
+             PixelFormat.ucRedMask) << pModeInfoFound->PixelFormat.
+            ucRedPosition;
         pResult->format->Rshift = pModeInfoFound->PixelFormat.ucRedPosition;
         pResult->format->Rloss = pModeInfoFound->PixelFormat.ucRedAdjust;
         pResult->format->Gmask =
-            ((unsigned int) pModeInfoFound->PixelFormat.
-             ucGreenMask) << pModeInfoFound->PixelFormat.ucGreenPosition;
+            ((unsigned int) pModeInfoFound->
+             PixelFormat.ucGreenMask) << pModeInfoFound->PixelFormat.
+            ucGreenPosition;
         pResult->format->Gshift = pModeInfoFound->PixelFormat.ucGreenPosition;
         pResult->format->Gloss = pModeInfoFound->PixelFormat.ucGreenAdjust;
         pResult->format->Bmask =
-            ((unsigned int) pModeInfoFound->PixelFormat.
-             ucBlueMask) << pModeInfoFound->PixelFormat.ucBluePosition;
+            ((unsigned int) pModeInfoFound->
+             PixelFormat.ucBlueMask) << pModeInfoFound->PixelFormat.
+            ucBluePosition;
         pResult->format->Bshift = pModeInfoFound->PixelFormat.ucBluePosition;
         pResult->format->Bloss = pModeInfoFound->PixelFormat.ucBlueAdjust;
         pResult->format->Amask =
-            ((unsigned int) pModeInfoFound->PixelFormat.
-             ucAlphaMask) << pModeInfoFound->PixelFormat.ucAlphaPosition;
+            ((unsigned int) pModeInfoFound->
+             PixelFormat.ucAlphaMask) << pModeInfoFound->PixelFormat.
+            ucAlphaPosition;
         pResult->format->Ashift = pModeInfoFound->PixelFormat.ucAlphaPosition;
         pResult->format->Aloss = pModeInfoFound->PixelFormat.ucAlphaAdjust;
 
@@ -2738,10 +2743,8 @@
                         for (i = 0; _this->hidden->pListModesResult[i]; i++) {
                             iNumOfSlots++;
                             if (iPlace == -1) {
-                                if ((_this->hidden->
-                                     pListModesResult[i]->w *
-                                     _this->hidden->
-                                     pListModesResult[i]->h) <
+                                if ((_this->hidden->pListModesResult[i]->w *
+                                     _this->hidden->pListModesResult[i]->h) <
                                     (pRect->w * pRect->h)) {
                                     iPlace = i;
                                 }
@@ -2754,14 +2757,10 @@
 //            printf("!!! From %d slots, it will be at %d\n", iNumOfSlots, iPlace);
 #endif
 
-                        pNewList =
-                            (SDL_Rect **) SDL_realloc(_this->
-                                                      hidden->
-                                                      pListModesResult,
-                                                      (iNumOfSlots
-                                                       +
-                                                       1) *
-                                                      sizeof(SDL_Rect *));
+                        pNewList = (SDL_Rect **)
+                            SDL_realloc(_this->hidden->pListModesResult,
+                                        (iNumOfSlots +
+                                         1) * sizeof(SDL_Rect *));
                         if (pNewList) {
                             for (i = iNumOfSlots; i > iPlace; i--)
                                 pNewList[i] = pNewList[i - 1];
@@ -2816,23 +2815,25 @@
     vformat->BytesPerPixel = (vformat->BitsPerPixel + 7) / 8;
 
     vformat->Rmask =
-        ((unsigned int) pDesktopMode->PixelFormat.ucRedMask) << pDesktopMode->
-        PixelFormat.ucRedPosition;
+        ((unsigned int) pDesktopMode->PixelFormat.
+         ucRedMask) << pDesktopMode->PixelFormat.ucRedPosition;
     vformat->Rshift = pDesktopMode->PixelFormat.ucRedPosition;
     vformat->Rloss = pDesktopMode->PixelFormat.ucRedAdjust;
     vformat->Gmask =
-        ((unsigned int) pDesktopMode->PixelFormat.
-         ucGreenMask) << pDesktopMode->PixelFormat.ucGreenPosition;
+        ((unsigned int) pDesktopMode->
+         PixelFormat.ucGreenMask) << pDesktopMode->PixelFormat.
+        ucGreenPosition;
     vformat->Gshift = pDesktopMode->PixelFormat.ucGreenPosition;
     vformat->Gloss = pDesktopMode->PixelFormat.ucGreenAdjust;
     vformat->Bmask =
-        ((unsigned int) pDesktopMode->PixelFormat.
-         ucBlueMask) << pDesktopMode->PixelFormat.ucBluePosition;
+        ((unsigned int) pDesktopMode->
+         PixelFormat.ucBlueMask) << pDesktopMode->PixelFormat.ucBluePosition;
     vformat->Bshift = pDesktopMode->PixelFormat.ucBluePosition;
     vformat->Bloss = pDesktopMode->PixelFormat.ucBlueAdjust;
     vformat->Amask =
-        ((unsigned int) pDesktopMode->PixelFormat.
-         ucAlphaMask) << pDesktopMode->PixelFormat.ucAlphaPosition;
+        ((unsigned int) pDesktopMode->
+         PixelFormat.ucAlphaMask) << pDesktopMode->PixelFormat.
+        ucAlphaPosition;
     vformat->Ashift = pDesktopMode->PixelFormat.ucAlphaPosition;
     vformat->Aloss = pDesktopMode->PixelFormat.ucAlphaAdjust;
 
@@ -2937,10 +2938,10 @@
                sizeof(_this->hidden->SrcBufferDesc));
     // Allocate new video buffer!
     _this->hidden->pchSrcBuffer =
-        (char *) SDL_malloc(_this->hidden->pAvailableFSLibVideoModes->
-                            uiScanLineSize *
-                            _this->hidden->pAvailableFSLibVideoModes->
-                            uiYResolution);
+        (char *) SDL_malloc(_this->hidden->
+                            pAvailableFSLibVideoModes->uiScanLineSize *
+                            _this->hidden->
+                            pAvailableFSLibVideoModes->uiYResolution);
     if (!_this->hidden->pchSrcBuffer) {
 #ifdef DEBUG_BUILD
         printf
diff -r dd25eabe441c -r 204be4fc2726 src/video/photon/SDL_ph_gl.c
--- a/src/video/photon/SDL_ph_gl.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/photon/SDL_ph_gl.c	Wed Aug 27 15:10:03 2008 +0000
@@ -315,11 +315,14 @@
         && (this->gl_config.accum_blue_size != 0)
         && (this->gl_config.accum_green_size != 0)) {
         qnxgl_attribs_slide = qnxgl_attrib_set_accum(qnxgl_attribs_slide,
-                                                     this->gl_config.
-                                                     accum_red_size +
-                                                     this->gl_config.
-                                                     accum_blue_size +
-                                                     this->gl_config.
+                                                     this->
+                                                     gl_config.accum_red_size
+                                                     +
+                                                     this->
+                                                     gl_config.accum_blue_size
+                                                     +
+                                                     this->
+                                                     gl_config.
                                                      accum_green_size +
                                                      this->gl_config.
                                                      accum_alpha_size);
diff -r dd25eabe441c -r 204be4fc2726 src/video/photon/SDL_ph_image.c
--- a/src/video/photon/SDL_ph_image.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/photon/SDL_ph_image.c	Wed Aug 27 15:10:03 2008 +0000
@@ -244,9 +244,8 @@
     }
 
     if ((screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) {
-        OCImage.FrameData1 =
-            (unsigned char *) PdGetOffscreenContextPtr(OCImage.
-                                                       offscreen_backcontext);
+        OCImage.FrameData1 = (unsigned char *)
+            PdGetOffscreenContextPtr(OCImage.offscreen_backcontext);
         if (OCImage.FrameData1 == NULL) {
             SDL_SetError
                 ("ph_SetupFullScreenImage(back): PdGetOffscreenContextPtr() function failed !\n");
diff -r dd25eabe441c -r 204be4fc2726 src/video/photon/SDL_phyuv.c
--- a/src/video/photon/SDL_phyuv.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/photon/SDL_phyuv.c	Wed Aug 27 15:10:03 2008 +0000
@@ -149,8 +149,8 @@
                                     &overlay->hwdata->caps);
         if (rtncode == 0) {
             if (overlay->hwdata->caps.format == format) {
-                if ((overlay->hwdata->caps.
-                     flags & Pg_SCALER_CAP_DST_CHROMA_KEY) ==
+                if ((overlay->hwdata->
+                     caps.flags & Pg_SCALER_CAP_DST_CHROMA_KEY) ==
                     Pg_SCALER_CAP_DST_CHROMA_KEY) {
                     overlay->hwdata->ischromakey = 1;
                 }
@@ -161,8 +161,7 @@
             break;
         }
         i++;
-    }
-    while (1);
+    } while (1);
 
 
     if (vidport == -1) {
diff -r dd25eabe441c -r 204be4fc2726 src/video/ps2gs/SDL_gsevents.c
--- a/src/video/ps2gs/SDL_gsevents.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/ps2gs/SDL_gsevents.c	Wed Aug 27 15:10:03 2008 +0000
@@ -479,9 +479,8 @@
                 if (select(fd + 1, &fdset, 0, 0, &tv) < 1) {
                     break;
                 }
-            }
-            while ((read(fd, &ch, sizeof(ch)) == sizeof(ch)) &&
-                   ((ch == 0xFA) || (ch == 0xAA)));
+            } while ((read(fd, &ch, sizeof(ch)) == sizeof(ch)) &&
+                     ((ch == 0xFA) || (ch == 0xAA)));
 
             /* Experimental values (Logitech wheelmouse) */
 #ifdef DEBUG_MOUSE
@@ -833,8 +832,7 @@
                 }
             }
         }
-    }
-    while (posted);
+    } while (posted);
 }
 
 void
diff -r dd25eabe441c -r 204be4fc2726 src/video/ps2gs/SDL_gsvideo.c
--- a/src/video/ps2gs/SDL_gsvideo.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/ps2gs/SDL_gsvideo.c	Wed Aug 27 15:10:03 2008 +0000
@@ -232,6 +232,7 @@
         0x0e,                   /* A+D */
         0,                      /* 2 */
 PS2_GS_TEX0_1, (1 << 5) + (1 << 6), PS2_GS_TEX1_1, 0, PS2_GS_TEXFLUSH};
+
 static unsigned long long scale_tags[] __attribute__ ((aligned(16))) = {
     5 | (1LL << 60),            /* GIFtag */
         0x0e,                   /* A+D */
@@ -573,11 +574,13 @@
 {
     return (-1);
 }
+
 static void
 GS_FreeHWSurface(_THIS, SDL_Surface * surface)
 {
     return;
 }
+
 static int
 GS_LockHWSurface(_THIS, SDL_Surface * surface)
 {
@@ -606,6 +609,7 @@
     }
     return (0);
 }
+
 static void
 GS_UnlockHWSurface(_THIS, SDL_Surface * surface)
 {
diff -r dd25eabe441c -r 204be4fc2726 src/video/riscos/SDL_riscosvideo.c
--- a/src/video/riscos/SDL_riscosvideo.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/riscos/SDL_riscosvideo.c	Wed Aug 27 15:10:03 2008 +0000
@@ -286,6 +286,7 @@
 {
     return (-1);
 }
+
 static void
 RISCOS_FreeHWSurface(_THIS, SDL_Surface * surface)
 {
diff -r dd25eabe441c -r 204be4fc2726 src/video/svga/SDL_svgaevents.c
--- a/src/video/svga/SDL_svgaevents.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/svga/SDL_svgaevents.c	Wed Aug 27 15:10:03 2008 +0000
@@ -207,8 +207,7 @@
         posted = 0;
         mouse_update();
         keyboard_update();
-    }
-    while (posted);
+    } while (posted);
 }
 
 void
diff -r dd25eabe441c -r 204be4fc2726 src/video/svga/SDL_svgavideo.c
--- a/src/video/svga/SDL_svgavideo.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/svga/SDL_svgavideo.c	Wed Aug 27 15:10:03 2008 +0000
@@ -467,6 +467,7 @@
 {
     return (-1);
 }
+
 static void
 SVGA_FreeHWSurface(_THIS, SDL_Surface * surface)
 {
@@ -480,6 +481,7 @@
     /* The waiting is done in SVGA_FlipHWSurface() */
     return (0);
 }
+
 static void
 SVGA_UnlockHWSurface(_THIS, SDL_Surface * surface)
 {
diff -r dd25eabe441c -r 204be4fc2726 src/video/vgl/SDL_vglevents.c
--- a/src/video/vgl/SDL_vglevents.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/vgl/SDL_vglevents.c	Wed Aug 27 15:10:03 2008 +0000
@@ -141,8 +141,7 @@
         posted = 0;
         handle_keyboard(this);
         handle_mouse(this);
-    }
-    while (posted != 0);
+    } while (posted != 0);
 }
 
 void
diff -r dd25eabe441c -r 204be4fc2726 src/video/vgl/SDL_vglvideo.c
--- a/src/video/vgl/SDL_vglvideo.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/vgl/SDL_vglvideo.c	Wed Aug 27 15:10:03 2008 +0000
@@ -409,6 +409,7 @@
 {
     return -1;
 }
+
 static void
 VGL_FreeHWSurface(_THIS, SDL_Surface * surface)
 {
@@ -424,6 +425,7 @@
     }
     return 0;
 }
+
 static void
 VGL_UnlockHWSurface(_THIS, SDL_Surface * surface)
 {
diff -r dd25eabe441c -r 204be4fc2726 src/video/win32/SDL_d3drender.c
--- a/src/video/win32/SDL_d3drender.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/win32/SDL_d3drender.c	Wed Aug 27 15:10:03 2008 +0000
@@ -596,8 +596,8 @@
     result =
         IDirect3DDevice9_UpdateTexture(renderdata->device,
                                        (IDirect3DBaseTexture9 *) temp,
-                                       (IDirect3DBaseTexture9 *) data->
-                                       texture);
+                                       (IDirect3DBaseTexture9 *)
+                                       data->texture);
     IDirect3DTexture9_Release(temp);
     if (FAILED(result)) {
         D3D_SetError("UpdateTexture()", result);
@@ -805,9 +805,8 @@
     }
 
     result =
-        IDirect3DDevice9_SetTexture(data->device, 0,
-                                    (IDirect3DBaseTexture9 *) texturedata->
-                                    texture);
+        IDirect3DDevice9_SetTexture(data->device, 0, (IDirect3DBaseTexture9 *)
+                                    texturedata->texture);
     if (FAILED(result)) {
         D3D_SetError("SetTexture()", result);
         return -1;
diff -r dd25eabe441c -r 204be4fc2726 src/video/win32/SDL_gdirender.c
--- a/src/video/win32/SDL_gdirender.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/win32/SDL_gdirender.c	Wed Aug 27 15:10:03 2008 +0000
@@ -620,9 +620,8 @@
         SelectPalette(data->memory_hdc, texturedata->hpal, TRUE);
         RealizePalette(data->memory_hdc);
     }
-    if (texture->
-        blendMode & (SDL_TEXTUREBLENDMODE_MASK | SDL_TEXTUREBLENDMODE_BLEND))
-    {
+    if (texture->blendMode &
+        (SDL_TEXTUREBLENDMODE_MASK | SDL_TEXTUREBLENDMODE_BLEND)) {
         BLENDFUNCTION blendFunc = {
             AC_SRC_OVER,
             0,
diff -r dd25eabe441c -r 204be4fc2726 src/video/win32/SDL_win32keyboard.c
--- a/src/video/win32/SDL_win32keyboard.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/win32/SDL_win32keyboard.c	Wed Aug 27 15:10:03 2008 +0000
@@ -41,6 +41,7 @@
     30, 48, 46, 32, 18, 33, 34, 35, 23, 36, 37, 38, 50, 49, 24,
     25, 16, 19, 31, 20, 22, 47, 17, 45, 21, 44
 };
+
 BYTE keypad_scancodes[10] = {
     82, 79, 80, 81, 75, 76, 77, 71, 72, 73
 };
diff -r dd25eabe441c -r 204be4fc2726 src/video/win32/SDL_win32opengl.c
--- a/src/video/win32/SDL_win32opengl.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/win32/SDL_win32opengl.c	Wed Aug 27 15:10:03 2008 +0000
@@ -500,8 +500,7 @@
     if (_this->gl_config.accelerated >= 0) {
         *iAttr++ = WGL_ACCELERATION_ARB;
         *iAttr++ =
-            (_this->gl_config.
-             accelerated ? WGL_GENERIC_ACCELERATION_ARB :
+            (_this->gl_config.accelerated ? WGL_GENERIC_ACCELERATION_ARB :
              WGL_NO_ACCELERATION_ARB);
     }
 
diff -r dd25eabe441c -r 204be4fc2726 src/video/wscons/SDL_wsconsevents.c
--- a/src/video/wscons/SDL_wsconsevents.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/wscons/SDL_wsconsevents.c	Wed Aug 27 15:10:03 2008 +0000
@@ -145,8 +145,7 @@
         posted = 0;
         updateMouse();
         updateKeyboard(this);
-    }
-    while (posted);
+    } while (posted);
 }
 
 void
diff -r dd25eabe441c -r 204be4fc2726 src/video/wscons/SDL_wsconsvideo.c
--- a/src/video/wscons/SDL_wsconsvideo.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/wscons/SDL_wsconsvideo.c	Wed Aug 27 15:10:03 2008 +0000
@@ -399,6 +399,7 @@
 {
     return -1;
 }
+
 static void
 WSCONS_FreeHWSurface(_THIS, SDL_Surface * surface)
 {
diff -r dd25eabe441c -r 204be4fc2726 src/video/x11/SDL_x11opengl.c
--- a/src/video/x11/SDL_x11opengl.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/x11/SDL_x11opengl.c	Wed Aug 27 15:10:03 2008 +0000
@@ -417,8 +417,8 @@
     SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
     Display *display = data->videodata->display;
     int screen =
-        ((SDL_DisplayData *) SDL_GetDisplayFromWindow(window)->driverdata)->
-        screen;
+        ((SDL_DisplayData *) SDL_GetDisplayFromWindow(window)->
+         driverdata)->screen;
     XWindowAttributes xattr;
     XVisualInfo v, *vinfo;
     int n;
diff -r dd25eabe441c -r 204be4fc2726 src/video/xbios/SDL_xbiosmodes.c
--- a/src/video/xbios/SDL_xbiosmodes.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/src/video/xbios/SDL_xbiosmodes.c	Wed Aug 27 15:10:03 2008 +0000
@@ -277,8 +277,8 @@
                     SDL_XBIOS_AddMode(_this, falcon_rgb_modes[i].width,
                                       falcon_rgb_modes[i].height,
                                       falcon_rgb_modes[i].bpp,
-                                      falcon_rgb_modes[i].
-                                      modecode & modecodemask, SDL_FALSE);
+                                      falcon_rgb_modes[i].modecode &
+                                      modecodemask, SDL_FALSE);
                 }
                 break;
             case MONITOR_VGA:
@@ -288,8 +288,8 @@
                     SDL_XBIOS_AddMode(_this, falcon_vga_modes[i].width,
                                       falcon_vga_modes[i].height,
                                       falcon_vga_modes[i].bpp,
-                                      falcon_vga_modes[i].
-                                      modecode & modecodemask, SDL_FALSE);
+                                      falcon_vga_modes[i].modecode &
+                                      modecodemask, SDL_FALSE);
                 }
                 break;
             }
diff -r dd25eabe441c -r 204be4fc2726 test/nds-test-progs/general/Makefile
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/nds-test-progs/general/Makefile	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,132 @@
+#---------------------------------------------------------------------------------
+.SUFFIXES:
+#---------------------------------------------------------------------------------
+
+ifeq ($(strip $(DEVKITARM)),)
+$(error "Please set DEVKITARM in your environment. export DEVKITARM=<path to>devkitARM")
+endif
+
+include $(DEVKITARM)/ds_rules
+
+#---------------------------------------------------------------------------------
+# TARGET is the name of the output
+# BUILD is the directory where object files & intermediate files will be placed
+# SOURCES is a list of directories containing source code
+# INCLUDES is a list of directories containing extra header files
+#---------------------------------------------------------------------------------
+TARGET		:=	$(shell basename $(CURDIR))
+BUILD		:=	build
+SOURCES		:=	source
+DATA		:=	data  
+INCLUDES	:=	include
+
+#---------------------------------------------------------------------------------
+# options for code generation
+#---------------------------------------------------------------------------------
+ARCH	:=	-mthumb -mthumb-interwork
+
+# note: arm9tdmi isn't the correct CPU arch, but anything newer and LD
+# *insists* it has a FPU or VFP, and it won't take no for an answer!
+CFLAGS	:=	-save-temps -g -Wall -O0\
+ 			-mcpu=arm9tdmi -mtune=arm9tdmi \
+			$(ARCH)
+
+CFLAGS	+=	$(INCLUDE) -DARM9 -D__NDS__
+CXXFLAGS	:= $(CFLAGS) -fno-rtti -fno-exceptions -fno-exceptions -fno-rtti
+
+ASFLAGS	:=	-g $(ARCH)
+LDFLAGS	=	-specs=ds_arm9.specs -g $(ARCH) -mno-fpu -Wl,-Map,$(notdir $*.map)
+
+#---------------------------------------------------------------------------------
+# any extra libraries we wish to link with the project
+#---------------------------------------------------------------------------------
+LIBS	:= -lSDL -lfat -lnds9
+ 
+ 
+#---------------------------------------------------------------------------------
+# list of directories containing libraries, this must be the top level containing
+# include and lib
+#---------------------------------------------------------------------------------
+LIBDIRS	:=	$(LIBNDS)
+ 
+#---------------------------------------------------------------------------------
+# no real need to edit anything past this point unless you need to add additional
+# rules for different file extensions
+#---------------------------------------------------------------------------------
+ifneq ($(BUILD),$(notdir $(CURDIR)))
+#---------------------------------------------------------------------------------
+ 
+export OUTPUT	:=	$(CURDIR)/$(TARGET)
+ 
+export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
+					$(foreach dir,$(DATA),$(CURDIR)/$(dir))
+
+export DEPSDIR	:=	$(CURDIR)/$(BUILD)
+
+CFILES		:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
+CPPFILES	:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
+SFILES		:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
+BINFILES	:=	$(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
+ 
+#---------------------------------------------------------------------------------
+# use CXX for linking C++ projects, CC for standard C
+#---------------------------------------------------------------------------------
+ifeq ($(strip $(CPPFILES)),)
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CC)
+#---------------------------------------------------------------------------------
+else
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CXX)
+#---------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------
+
+export OFILES	:=	$(addsuffix .o,$(BINFILES)) \
+					$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
+ 
+export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
+					$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
+					$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
+					-I$(CURDIR)/$(BUILD)
+ 
+export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/lib)
+ 
+.PHONY: $(BUILD) clean
+ 
+#---------------------------------------------------------------------------------
+$(BUILD):
+	@[ -d $@ ] || mkdir -p $@
+	@make --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
+ 
+#---------------------------------------------------------------------------------
+clean:
+	@echo clean ...
+	@rm -fr $(BUILD) $(TARGET).elf $(TARGET).nds $(TARGET).arm9 $(TARGET).ds.gba 
+ 
+ 
+#---------------------------------------------------------------------------------
+else
+ 
+DEPENDS	:=	$(OFILES:.o=.d)
+ 
+#---------------------------------------------------------------------------------
+# main targets
+#---------------------------------------------------------------------------------
+$(OUTPUT).ds.gba	: 	$(OUTPUT).nds
+$(OUTPUT).nds	: 	$(OUTPUT).arm9
+$(OUTPUT).arm9	:	$(OUTPUT).elf
+$(OUTPUT).elf	:	$(OFILES)
+ 
+#---------------------------------------------------------------------------------
+%.pcx.o	:	%.pcx
+#---------------------------------------------------------------------------------
+	@echo $(notdir $<)
+	@$(bin2o)
+ 
+ 
+-include $(DEPENDS)
+ 
+#---------------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------------
diff -r dd25eabe441c -r 204be4fc2726 test/nds-test-progs/general/source/main.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/nds-test-progs/general/source/main.c	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,96 @@
+
+#include <SDL/SDL.h>
+#if defined(NDS) || defined(__NDS__) || defined (__NDS)
+#include <nds.h>
+#include <fat.h>
+#else
+#define swiWaitForVBlank()
+#define consoleDemoInit()
+#define fatInitDefault()
+#define RGB15(r,g,b) SDL_MapRGB(screen->format,((r)<<3),((g)<<3),((b)<<3))
+#endif
+    void
+splash(SDL_Surface * screen, int s)
+{
+    SDL_Surface *logo;
+    SDL_Rect area = { 0, 0, 256, 192 };
+
+    logo = SDL_LoadBMP("sdl.bmp");
+    if (!logo) {
+        printf("Couldn't splash.\n");
+        return;
+    }
+    /*logo->flags &= ~SDL_PREALLOC; */
+    SDL_BlitSurface(logo, NULL, screen, &area);
+    SDL_Flip(screen);
+    while (s-- > 0) {
+        int i = 60;
+        while (--i)
+            swiWaitForVBlank();
+    }
+}
+
+
int
+main(void)
+{
+    SDL_Surface *screen;
+    SDL_Joystick *stick;
+    SDL_Event event;
+    SDL_Rect rect = { 0, 0, 256, 192 };
+    int i;
+
+    consoleDemoInit();
+    puts("Hello world!  Initializing FAT...");
+    fatInitDefault();
+    
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK) < 0) {
+        puts("# error initializing SDL");
+        puts(SDL_GetError());
+        return 1;
+    }
+    puts("* initialized SDL");
+    screen = SDL_SetVideoMode(256, 192, 15, SDL_SWSURFACE);
+    if (!screen) {
+        puts("# error setting video mode");
+        puts(SDL_GetError());
+        return 2;
+    }
+    screen->flags &= ~SDL_PREALLOC;
+    puts("* set video mode");
+    stick = SDL_JoystickOpen(0);
+    if (stick == NULL) {
+        puts("# error opening joystick");
+        puts(SDL_GetError());
+//              return 3;
+    }
+    puts("* opened joystick");
+
+    /*splash(screen, 3); */
+
+    SDL_FillRect(screen, &rect, RGB15(0, 0, 31) | 0x8000);
+    SDL_Flip(screen);
+
+    while (1)
+        while (SDL_PollEvent(&event))
+            switch (event.type) {
+            case SDL_JOYBUTTONDOWN:
+                SDL_FillRect(screen, &rect, (u16) rand() | 0x8000);
+                SDL_Flip(screen);
+                if (rect.w > 8) {
+                    rect.x += 4;
+                    rect.y += 3;
+                    rect.w -= 8;
+                    rect.h -= 6;
+                }
+                printf("button %d pressed at %d ticks\n",
+                       event.jbutton.which, SDL_GetTicks());
+                break;
+            case SDL_QUIT:
+                SDL_Quit();
+                return 0;
+            default:
+                break;
+            }
+    
return 0;
+
}
+
+
diff -r dd25eabe441c -r 204be4fc2726 test/nds-test-progs/sprite/Makefile
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/nds-test-progs/sprite/Makefile	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,132 @@
+#---------------------------------------------------------------------------------
+.SUFFIXES:
+#---------------------------------------------------------------------------------
+
+ifeq ($(strip $(DEVKITARM)),)
+$(error "Please set DEVKITARM in your environment. export DEVKITARM=<path to>devkitARM")
+endif
+
+include $(DEVKITARM)/ds_rules
+
+#---------------------------------------------------------------------------------
+# TARGET is the name of the output
+# BUILD is the directory where object files & intermediate files will be placed
+# SOURCES is a list of directories containing source code
+# INCLUDES is a list of directories containing extra header files
+#---------------------------------------------------------------------------------
+TARGET		:=	$(shell basename $(CURDIR))
+BUILD		:=	build
+SOURCES		:=	source
+DATA		:=	data  
+INCLUDES	:=	include
+
+#---------------------------------------------------------------------------------
+# options for code generation
+#---------------------------------------------------------------------------------
+ARCH	:=	-mthumb -mthumb-interwork
+
+# note: arm9tdmi isn't the correct CPU arch, but anything newer and LD
+# *insists* it has a FPU or VFP, and it won't take no for an answer!
+CFLAGS	:=	-save-temps -g -Wall -O0\
+ 			-mcpu=arm9tdmi -mtune=arm9tdmi \
+			$(ARCH)
+
+CFLAGS	+=	$(INCLUDE) -DARM9 -D__NDS__
+CXXFLAGS	:= $(CFLAGS) -fno-rtti -fno-exceptions -fno-exceptions -fno-rtti
+
+ASFLAGS	:=	-g $(ARCH)
+LDFLAGS	=	-specs=ds_arm9.specs -g $(ARCH) -mno-fpu -Wl,-Map,$(notdir $*.map)
+
+#---------------------------------------------------------------------------------
+# any extra libraries we wish to link with the project
+#---------------------------------------------------------------------------------
+LIBS	:= -lSDL -lfat -lnds9
+ 
+ 
+#---------------------------------------------------------------------------------
+# list of directories containing libraries, this must be the top level containing
+# include and lib
+#---------------------------------------------------------------------------------
+LIBDIRS	:=	$(LIBNDS)
+ 
+#---------------------------------------------------------------------------------
+# no real need to edit anything past this point unless you need to add additional
+# rules for different file extensions
+#---------------------------------------------------------------------------------
+ifneq ($(BUILD),$(notdir $(CURDIR)))
+#---------------------------------------------------------------------------------
+ 
+export OUTPUT	:=	$(CURDIR)/$(TARGET)
+ 
+export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
+					$(foreach dir,$(DATA),$(CURDIR)/$(dir))
+
+export DEPSDIR	:=	$(CURDIR)/$(BUILD)
+
+CFILES		:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
+CPPFILES	:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
+SFILES		:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
+BINFILES	:=	$(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
+ 
+#---------------------------------------------------------------------------------
+# use CXX for linking C++ projects, CC for standard C
+#---------------------------------------------------------------------------------
+ifeq ($(strip $(CPPFILES)),)
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CC)
+#---------------------------------------------------------------------------------
+else
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CXX)
+#---------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------
+
+export OFILES	:=	$(addsuffix .o,$(BINFILES)) \
+					$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
+ 
+export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
+					$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
+					$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
+					-I$(CURDIR)/$(BUILD)
+ 
+export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/lib)
+ 
+.PHONY: $(BUILD) clean
+ 
+#---------------------------------------------------------------------------------
+$(BUILD):
+	@[ -d $@ ] || mkdir -p $@
+	@make --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
+ 
+#---------------------------------------------------------------------------------
+clean:
+	@echo clean ...
+	@rm -fr $(BUILD) $(TARGET).elf $(TARGET).nds $(TARGET).arm9 $(TARGET).ds.gba 
+ 
+ 
+#---------------------------------------------------------------------------------
+else
+ 
+DEPENDS	:=	$(OFILES:.o=.d)
+ 
+#---------------------------------------------------------------------------------
+# main targets
+#---------------------------------------------------------------------------------
+$(OUTPUT).ds.gba	: 	$(OUTPUT).nds
+$(OUTPUT).nds	: 	$(OUTPUT).arm9
+$(OUTPUT).arm9	:	$(OUTPUT).elf
+$(OUTPUT).elf	:	$(OFILES)
+ 
+#---------------------------------------------------------------------------------
+%.pcx.o	:	%.pcx
+#---------------------------------------------------------------------------------
+	@echo $(notdir $<)
+	@$(bin2o)
+ 
+ 
+-include $(DEPENDS)
+ 
+#---------------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------------
diff -r dd25eabe441c -r 204be4fc2726 test/nds-test-progs/sprite/source/common.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/nds-test-progs/sprite/source/common.c	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,965 @@
+
+/* A simple test program framework */
+
+#include <stdio.h>
+
+#include "common.h"
+
+#define VIDEO_USAGE \
+"[--video driver] [--renderer driver] [--info all|video|modes|render|event] [--display %d] [--fullscreen | --windows N] [--title title] [--center | --position X,Y] [--geometry WxH] [--depth N] [--refresh R] [--vsync] [--noframe] [--resize] [--minimize] [--maximize] [--grab]"
+
+#define AUDIO_USAGE \
+"[--rate N] [--format U8|S8|U16|U16LE|U16BE|S16|S16LE|S16BE] [--channels N] [--samples N]"
+
+CommonState *
+CommonCreateState(char **argv, Uint32 flags)
+{
+    CommonState *state = SDL_calloc(1, sizeof(*state));
+    if (!state) {
+        SDL_OutOfMemory();
+        return NULL;
+    }
+
+    /* Initialize some defaults */
+    state->argv = argv;
+    state->flags = flags;
+    state->window_title = argv[0];
+    state->window_flags = SDL_WINDOW_SHOWN;
+    state->window_x = SDL_WINDOWPOS_UNDEFINED;
+    state->window_y = SDL_WINDOWPOS_UNDEFINED;
+    state->window_w = 256;
+    state->window_h = 192;
+    state->num_windows = 1;
+    state->audiospec.freq = 22050;
+    state->audiospec.format = AUDIO_S16;
+    state->audiospec.channels = 2;
+    state->audiospec.samples = 2048;
+    return state;
+}
+
+int
+CommonArg(CommonState * state, int index)
+{
+    char **argv = state->argv;
+
+    if (SDL_strcasecmp(argv[index], "--video") == 0) {
+        ++index;
+        if (!argv[index]) {
+            return -1;
+        }
+        state->videodriver = argv[index];
+        return 2;
+    }
+    if (SDL_strcasecmp(argv[index], "--renderer") == 0) {
+        ++index;
+        if (!argv[index]) {
+            return -1;
+        }
+        state->renderdriver = argv[index];
+        return 2;
+    }
+    if (SDL_strcasecmp(argv[index], "--info") == 0) {
+        ++index;
+        if (!argv[index]) {
+            return -1;
+        }
+        if (SDL_strcasecmp(argv[index], "all") == 0) {
+            state->verbose |=
+                (VERBOSE_VIDEO | VERBOSE_MODES | VERBOSE_RENDER |
+                 VERBOSE_EVENT);
+            return 2;
+        }
+        if (SDL_strcasecmp(argv[index], "video") == 0) {
+            state->verbose |= VERBOSE_VIDEO;
+            return 2;
+        }
+        if (SDL_strcasecmp(argv[index], "modes") == 0) {
+            state->verbose |= VERBOSE_MODES;
+            return 2;
+        }
+        if (SDL_strcasecmp(argv[index], "render") == 0) {
+            state->verbose |= VERBOSE_RENDER;
+            return 2;
+        }
+        if (SDL_strcasecmp(argv[index], "event") == 0) {
+            state->verbose |= VERBOSE_EVENT;
+            return 2;
+        }
+        return -1;
+    }
+    if (SDL_strcasecmp(argv[index], "--display") == 0) {
+        ++index;
+        if (!argv[index]) {
+            return -1;
+        }
+        state->display = SDL_atoi(argv[index]);
+        return 2;
+    }
+    if (SDL_strcasecmp(argv[index], "--fullscreen") == 0) {
+        state->window_flags |= SDL_WINDOW_FULLSCREEN;
+        state->num_windows = 1;
+        return 1;
+    }
+    if (SDL_strcasecmp(argv[index], "--windows") == 0) {
+        ++index;
+        if (!argv[index] || !SDL_isdigit(*argv[index])) {
+            return -1;
+        }
+        if (!(state->window_flags & SDL_WINDOW_FULLSCREEN)) {
+            state->num_windows = SDL_atoi(argv[index]);
+        }
+        return 2;
+    }
+    if (SDL_strcasecmp(argv[index], "--title") == 0) {
+        ++index;
+        if (!argv[index]) {
+            return -1;
+        }
+        state->window_title = argv[index];
+        return 2;
+    }
+    if (SDL_strcasecmp(argv[index], "--center") == 0) {
+        state->window_x = SDL_WINDOWPOS_CENTERED;
+        state->window_y = SDL_WINDOWPOS_CENTERED;
+        return 1;
+    }
+    if (SDL_strcasecmp(argv[index], "--position") == 0) {
+        char *x, *y;
+        ++index;
+        if (!argv[index]) {
+            return -1;
+        }
+        x = argv[index];
+        y = argv[index];
+        while (*y && *y != ',') {
+            ++y;
+        }
+        if (!*y) {
+            return -1;
+        }
+        *y++ = '\0';
+        state->window_x = SDL_atoi(x);
+        state->window_y = SDL_atoi(y);
+        return 2;
+    }
+    if (SDL_strcasecmp(argv[index], "--geometry") == 0) {
+        char *w, *h;
+        ++index;
+        if (!argv[index]) {
+            return -1;
+        }
+        w = argv[index];
+        h = argv[index];
+        while (*h && *h != 'x') {
+            ++h;
+        }
+        if (!*h) {
+            return -1;
+        }
+        *h++ = '\0';
+        state->window_w = SDL_atoi(w);
+        state->window_h = SDL_atoi(h);
+        return 2;
+    }
+    if (SDL_strcasecmp(argv[index], "--depth") == 0) {
+        ++index;
+        if (!argv[index]) {
+            return -1;
+        }
+        state->depth = SDL_atoi(argv[index]);
+        return 2;
+    }
+    if (SDL_strcasecmp(argv[index], "--refresh") == 0) {
+        ++index;
+        if (!argv[index]) {
+            return -1;
+        }
+        state->refresh_rate = SDL_atoi(argv[index]);
+        return 2;
+    }
+    if (SDL_strcasecmp(argv[index], "--vsync") == 0) {
+        state->render_flags |= SDL_RENDERER_PRESENTVSYNC;
+        return 1;
+    }
+    if (SDL_strcasecmp(argv[index], "--noframe") == 0) {
+        state->window_flags |= SDL_WINDOW_BORDERLESS;
+        return 1;
+    }
+    if (SDL_strcasecmp(argv[index], "--resize") == 0) {
+        state->window_flags |= SDL_WINDOW_RESIZABLE;
+        return 1;
+    }
+    if (SDL_strcasecmp(argv[index], "--minimize") == 0) {
+        state->window_flags |= SDL_WINDOW_MINIMIZED;
+        return 1;
+    }
+    if (SDL_strcasecmp(argv[index], "--maximize") == 0) {
+        state->window_flags |= SDL_WINDOW_MAXIMIZED;
+        return 1;
+    }
+    if (SDL_strcasecmp(argv[index], "--grab") == 0) {
+        state->window_flags |= SDL_WINDOW_INPUT_GRABBED;
+        return 1;
+    }
+    if (SDL_strcasecmp(argv[index], "--rate") == 0) {
+        ++index;
+        if (!argv[index]) {
+            return -1;
+        }
+        state->audiospec.freq = SDL_atoi(argv[index]);
+        return 2;
+    }
+    if (SDL_strcasecmp(argv[index], "--format") == 0) {
+        ++index;
+        if (!argv[index]) {
+            return -1;
+        }
+        if (SDL_strcasecmp(argv[index], "U8") == 0) {
+            state->audiospec.format = AUDIO_U8;
+            return 2;
+        }
+        if (SDL_strcasecmp(argv[index], "S8") == 0) {
+            state->audiospec.format = AUDIO_S8;
+            return 2;
+        }
+        if (SDL_strcasecmp(argv[index], "U16") == 0) {
+            state->audiospec.format = AUDIO_U16;
+            return 2;
+        }
+        if (SDL_strcasecmp(argv[index], "U16LE") == 0) {
+            state->audiospec.format = AUDIO_U16LSB;
+            return 2;
+        }
+        if (SDL_strcasecmp(argv[index], "U16BE") == 0) {
+            state->audiospec.format = AUDIO_U16MSB;
+            return 2;
+        }
+        if (SDL_strcasecmp(argv[index], "S16") == 0) {
+            state->audiospec.format = AUDIO_S16;
+            return 2;
+        }
+        if (SDL_strcasecmp(argv[index], "S16LE") == 0) {
+            state->audiospec.format = AUDIO_S16LSB;
+            return 2;
+        }
+        if (SDL_strcasecmp(argv[index], "S16BE") == 0) {
+            state->audiospec.format = AUDIO_S16MSB;
+            return 2;
+        }
+        return -1;
+    }
+    if (SDL_strcasecmp(argv[index], "--channels") == 0) {
+        ++index;
+        if (!argv[index]) {
+            return -1;
+        }
+        state->audiospec.channels = (Uint8) SDL_atoi(argv[index]);
+        return 2;
+    }
+    if (SDL_strcasecmp(argv[index], "--samples") == 0) {
+        ++index;
+        if (!argv[index]) {
+            return -1;
+        }
+        state->audiospec.samples = (Uint16) SDL_atoi(argv[index]);
+        return 2;
+    }
+    if ((SDL_strcasecmp(argv[index], "-h") == 0)
+        || (SDL_strcasecmp(argv[index], "--help") == 0)) {
+        /* Print the usage message */
+        return -1;
+    }
+    return 0;
+}
+
+const char *
+CommonUsage(CommonState * state)
+{
+    switch (state->flags & (SDL_INIT_VIDEO | SDL_INIT_AUDIO)) {
+    case SDL_INIT_VIDEO:
+        return VIDEO_USAGE;
+    case SDL_INIT_AUDIO:
+        return AUDIO_USAGE;
+    case (SDL_INIT_VIDEO | SDL_INIT_AUDIO):
+        return VIDEO_USAGE " " AUDIO_USAGE;
+    default:
+        return "";
+    }
+}
+
+static void
+PrintRendererFlag(Uint32 flag)
+{
+    switch (flag) {
+    case SDL_RENDERER_SINGLEBUFFER:
+        fprintf(stderr, "SingleBuffer");
+        break;
+    case SDL_RENDERER_PRESENTCOPY:
+        fprintf(stderr, "PresentCopy");
+        break;
+    case SDL_RENDERER_PRESENTFLIP2:
+        fprintf(stderr, "PresentFlip2");
+        break;
+    case SDL_RENDERER_PRESENTFLIP3:
+        fprintf(stderr, "PresentFlip3");
+        break;
+    case SDL_RENDERER_PRESENTDISCARD:
+        fprintf(stderr, "PresentDiscard");
+        break;
+    case SDL_RENDERER_PRESENTVSYNC:
+        fprintf(stderr, "PresentVSync");
+        break;
+    case SDL_RENDERER_ACCELERATED:
+        fprintf(stderr, "Accelerated");
+        break;
+    default:
+        fprintf(stderr, "0x%8.8x", flag);
+        break;
+    }
+}
+
+static void
+PrintBlendMode(Uint32 flag)
+{
+    switch (flag) {
+    case SDL_TEXTUREBLENDMODE_NONE:
+        fprintf(stderr, "None");
+        break;
+    case SDL_TEXTUREBLENDMODE_MASK:
+        fprintf(stderr, "Mask");
+        break;
+    case SDL_TEXTUREBLENDMODE_BLEND:
+        fprintf(stderr, "Blend");
+        break;
+    case SDL_TEXTUREBLENDMODE_ADD:
+        fprintf(stderr, "Add");
+        break;
+    case SDL_TEXTUREBLENDMODE_MOD:
+        fprintf(stderr, "Mod");
+        break;
+    default:
+        fprintf(stderr, "0x%8.8x", flag);
+        break;
+    }
+}
+
+static void
+PrintScaleMode(Uint32 flag)
+{
+    switch (flag) {
+    case SDL_TEXTURESCALEMODE_NONE:
+        fprintf(stderr, "None");
+        break;
+    case SDL_TEXTURESCALEMODE_FAST:
+        fprintf(stderr, "Fast");
+        break;
+    case SDL_TEXTURESCALEMODE_SLOW:
+        fprintf(stderr, "Slow");
+        break;
+    case SDL_TEXTURESCALEMODE_BEST:
+        fprintf(stderr, "Best");
+        break;
+    default:
+        fprintf(stderr, "0x%8.8x", flag);
+        break;
+    }
+}
+
+static void
+PrintPixelFormat(Uint32 format)
+{
+    switch (format) {
+    case SDL_PIXELFORMAT_UNKNOWN:
+        fprintf(stderr, "Unknwon");
+        break;
+    case SDL_PIXELFORMAT_INDEX1LSB:
+        fprintf(stderr, "Index1LSB");
+        break;
+    case SDL_PIXELFORMAT_INDEX1MSB:
+        fprintf(stderr, "Index1MSB");
+        break;
+    case SDL_PIXELFORMAT_INDEX4LSB:
+        fprintf(stderr, "Index4LSB");
+        break;
+    case SDL_PIXELFORMAT_INDEX4MSB:
+        fprintf(stderr, "Index4MSB");
+        break;
+    case SDL_PIXELFORMAT_INDEX8:
+        fprintf(stderr, "Index8");
+        break;
+    case SDL_PIXELFORMAT_RGB332:
+        fprintf(stderr, "RGB332");
+        break;
+    case SDL_PIXELFORMAT_RGB444:
+        fprintf(stderr, "RGB444");
+        break;
+    case SDL_PIXELFORMAT_RGB555:
+        fprintf(stderr, "RGB555");
+        break;
+    case SDL_PIXELFORMAT_ARGB4444:
+        fprintf(stderr, "ARGB4444");
+        break;
+    case SDL_PIXELFORMAT_ARGB1555:
+        fprintf(stderr, "ARGB1555");
+        break;
+    case SDL_PIXELFORMAT_RGB565:
+        fprintf(stderr, "RGB565");
+        break;
+    case SDL_PIXELFORMAT_RGB24:
+        fprintf(stderr, "RGB24");
+        break;
+    case SDL_PIXELFORMAT_BGR24:
+        fprintf(stderr, "BGR24");
+        break;
+    case SDL_PIXELFORMAT_RGB888:
+        fprintf(stderr, "RGB888");
+        break;
+    case SDL_PIXELFORMAT_BGR888:
+        fprintf(stderr, "BGR888");
+        break;
+    case SDL_PIXELFORMAT_ARGB8888:
+        fprintf(stderr, "ARGB8888");
+        break;
+    case SDL_PIXELFORMAT_RGBA8888:
+        fprintf(stderr, "RGBA8888");
+        break;
+    case SDL_PIXELFORMAT_ABGR8888:
+        fprintf(stderr, "ABGR8888");
+        break;
+    case SDL_PIXELFORMAT_BGRA8888:
+        fprintf(stderr, "BGRA8888");
+        break;
+    case SDL_PIXELFORMAT_ARGB2101010:
+        fprintf(stderr, "ARGB2101010");
+        break;
+    case SDL_PIXELFORMAT_YV12:
+        fprintf(stderr, "YV12");
+        break;
+    case SDL_PIXELFORMAT_IYUV:
+        fprintf(stderr, "IYUV");
+        break;
+    case SDL_PIXELFORMAT_YUY2:
+        fprintf(stderr, "YUY2");
+        break;
+    case SDL_PIXELFORMAT_UYVY:
+        fprintf(stderr, "UYVY");
+        break;
+    case SDL_PIXELFORMAT_YVYU:
+        fprintf(stderr, "YVYU");
+        break;
+    case SDL_PIXELFORMAT_ABGR1555:
+        fprintf(stderr, "ABGR1555");
+        break;
+    case SDL_PIXELFORMAT_BGR555:
+        fprintf(stderr, "BGR555");
+        break;
+    default:
+        fprintf(stderr, "0x%8.8x", format);
+        break;
+    }
+}
+
+static void
+PrintRenderer(SDL_RendererInfo * info)
+{
+    int i, count;
+
+    fprintf(stderr, "  Renderer %s:\n", info->name);
+
+    fprintf(stderr, "    Flags: 0x%8.8X", info->flags);
+    fprintf(stderr, " (");
+    count = 0;
+    for (i = 0; i < sizeof(info->flags) * 8; ++i) {
+        Uint32 flag = (1 << i);
+        if (info->flags & flag) {
+            if (count > 0) {
+                fprintf(stderr, " | ");
+            }
+            PrintRendererFlag(flag);
+            ++count;
+        }
+    }
+    fprintf(stderr, ")\n");
+
+    fprintf(stderr, "    Blend: 0x%8.8X", info->blend_modes);
+    fprintf(stderr, " (");
+    count = 0;
+    for (i = 0; i < sizeof(info->blend_modes) * 8; ++i) {
+        Uint32 flag = (1 << i);
+        if (info->blend_modes & flag) {
+            if (count > 0) {
+                fprintf(stderr, " | ");
+            }
+            PrintBlendMode(flag);
+            ++count;
+        }
+    }
+    fprintf(stderr, ")\n");
+
+    fprintf(stderr, "    Scale: 0x%8.8X", info->scale_modes);
+    fprintf(stderr, " (");
+    count = 0;
+    for (i = 0; i < sizeof(info->scale_modes) * 8; ++i) {
+        Uint32 flag = (1 << i);
+        if (info->scale_modes & flag) {
+            if (count > 0) {
+                fprintf(stderr, " | ");
+            }
+            PrintScaleMode(flag);
+            ++count;
+        }
+    }
+    fprintf(stderr, ")\n");
+
+    fprintf(stderr, "    Texture formats (%d): ", info->num_texture_formats);
+    for (i = 0; i < (int) info->num_texture_formats; ++i) {
+        if (i > 0) {
+            fprintf(stderr, ", ");
+        }
+        PrintPixelFormat(info->texture_formats[i]);
+    }
+    fprintf(stderr, "\n");
+
+    if (info->max_texture_width || info->max_texture_height) {
+        fprintf(stderr, "    Max Texture Size: %dx%d\n",
+                info->max_texture_width, info->max_texture_height);
+    }
+}
+
+SDL_bool
+CommonInit(CommonState * state)
+{
+    int i, j, m, n;
+    SDL_DisplayMode fullscreen_mode;
+
+    if (state->flags & SDL_INIT_VIDEO) {
+        if (state->verbose & VERBOSE_VIDEO) {
+            n = SDL_GetNumVideoDrivers();
+            if (n == 0) {
+                fprintf(stderr, "No built-in video drivers\n");
+            } else {
+                fprintf(stderr, "Built-in video drivers:");
+                for (i = 0; i < n; ++i) {
+                    if (i > 0) {
+                        fprintf(stderr, ",");
+                    }
+                    fprintf(stderr, " %s", SDL_GetVideoDriver(i));
+                }
+                fprintf(stderr, "\n");
+            }
+        }
+        if (SDL_VideoInit(state->videodriver, 0) < 0) {
+            fprintf(stderr, "Couldn't initialize video driver: %s\n",
+                    SDL_GetError());
+            return SDL_FALSE;
+        }
+        if (state->verbose & VERBOSE_VIDEO) {
+            fprintf(stderr, "Video driver: %s\n",
+                    SDL_GetCurrentVideoDriver());
+        }
+
+        if (state->verbose & VERBOSE_MODES) {
+            SDL_DisplayMode mode;
+            int bpp;
+            Uint32 Rmask, Gmask, Bmask, Amask;
+
+            n = SDL_GetNumVideoDisplays();
+            fprintf(stderr, "Number of displays: %d\n", n);
+            for (i = 0; i < n; ++i) {
+                fprintf(stderr, "Display %d:\n", i);
+                SDL_SelectVideoDisplay(i);
+
+                SDL_GetDesktopDisplayMode(&mode);
+                SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask, &Gmask,
+                                           &Bmask, &Amask);
+                fprintf(stderr,
+                        "  Current mode: %dx%d@%dHz, %d bits-per-pixel\n",
+                        mode.w, mode.h, mode.refresh_rate, bpp);
+                if (Rmask || Gmask || Bmask) {
+                    fprintf(stderr, "      Red Mask = 0x%.8x\n", Rmask);
+                    fprintf(stderr, "      Green Mask = 0x%.8x\n", Gmask);
+                    fprintf(stderr, "      Blue Mask = 0x%.8x\n", Bmask);
+                    if (Amask)
+                        fprintf(stderr, "      Alpha Mask = 0x%.8x\n", Amask);
+                }
+
+                /* Print available fullscreen video modes */
+                m = SDL_GetNumDisplayModes();
+                if (m == 0) {
+                    fprintf(stderr, "No available fullscreen video modes\n");
+                } else {
+                    fprintf(stderr, "  Fullscreen video modes:\n");
+                    for (j = 0; j < m; ++j) {
+                        SDL_GetDisplayMode(j, &mode);
+                        SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask,
+                                                   &Gmask, &Bmask, &Amask);
+                        fprintf(stderr,
+                                "    Mode %d: %dx%d@%dHz, %d bits-per-pixel\n",
+                                j, mode.w, mode.h, mode.refresh_rate, bpp);
+                        if (Rmask || Gmask || Bmask) {
+                            fprintf(stderr, "        Red Mask = 0x%.8x\n",
+                                    Rmask);
+                            fprintf(stderr, "        Green Mask = 0x%.8x\n",
+                                    Gmask);
+                            fprintf(stderr, "        Blue Mask = 0x%.8x\n",
+                                    Bmask);
+                            if (Amask)
+                                fprintf(stderr,
+                                        "        Alpha Mask = 0x%.8x\n",
+                                        Amask);
+                        }
+                    }
+                }
+            }
+        }
+
+        SDL_SelectVideoDisplay(state->display);
+        if (state->verbose & VERBOSE_RENDER) {
+            SDL_RendererInfo info;
+
+            n = SDL_GetNumRenderDrivers();
+            if (n == 0) {
+                fprintf(stderr, "No built-in render drivers\n");
+            } else {
+                fprintf(stderr, "Built-in render drivers:\n");
+                for (i = 0; i < n; ++i) {
+                    SDL_GetRenderDriverInfo(i, &info);
+                    PrintRenderer(&info);
+                }
+            }
+        }
+
+        switch (state->depth) {
+        case 8:
+            fullscreen_mode.format = SDL_PIXELFORMAT_INDEX8;
+            break;
+        case 15:
+            fullscreen_mode.format = SDL_PIXELFORMAT_BGR555;
+            break;
+        case 16:
+        default:
+            fullscreen_mode.format = SDL_PIXELFORMAT_ABGR1555;
+            break;
+/* NDS       default:
+            fullscreen_mode.format = SDL_PIXELFORMAT_RGB888;
+            break;*/
+        }
+        fullscreen_mode.w = state->window_w;
+        fullscreen_mode.h = state->window_h;
+        fullscreen_mode.refresh_rate = state->refresh_rate;
+        SDL_SetFullscreenDisplayMode(&fullscreen_mode);
+
+        state->windows =
+            (SDL_WindowID *) SDL_malloc(state->num_windows *
+                                        sizeof(*state->windows));
+        if (!state->windows) {
+            fprintf(stderr, "Out of memory!\n");
+            return SDL_FALSE;
+        }
+        for (i = 0; i < state->num_windows; ++i) {
+            char title[1024];
+
+            if (state->num_windows > 1) {
+                SDL_snprintf(title, SDL_arraysize(title), "%s %d",
+                             state->window_title, i + 1);
+            } else {
+                SDL_strlcpy(title, state->window_title, SDL_arraysize(title));
+            }
+            state->windows[i] =
+                SDL_CreateWindow(title, state->window_x, state->window_y,
+                                 state->window_w, state->window_h,
+                                 state->window_flags);
+            if (!state->windows[i]) {
+                fprintf(stderr, "Couldn't create window: %s\n",
+                        SDL_GetError());
+                return SDL_FALSE;
+            }
+
+            if (!state->skip_renderer
+                && (state->renderdriver
+                    || !(state->window_flags & SDL_WINDOW_OPENGL))) {
+                m = -1;
+                if (state->renderdriver) {
+                    SDL_RendererInfo info;
+                    n = SDL_GetNumRenderDrivers();
+                    for (j = 0; j < n; ++j) {
+                        SDL_GetRenderDriverInfo(j, &info);
+                        if (SDL_strcasecmp(info.name, state->renderdriver) ==
+                            0) {
+                            m = j;
+                            break;
+                        }
+                    }
+                    if (m == n) {
+                        fprintf(stderr,
+                                "Couldn't find render driver named %s",
+                                state->renderdriver);
+                        return SDL_FALSE;
+                    }
+                }
+                if (SDL_CreateRenderer
+                    (state->windows[i], m, state->render_flags) < 0) {
+                    fprintf(stderr, "Couldn't create renderer: %s\n",
+                            SDL_GetError());
+                    return SDL_FALSE;
+                }
+                if (state->verbose & VERBOSE_RENDER) {
+                    SDL_RendererInfo info;
+
+                    fprintf(stderr, "Current renderer:\n");
+                    SDL_GetRendererInfo(&info);
+                    PrintRenderer(&info);
+                }
+            }
+        }
+        SDL_SelectRenderer(state->windows[0]);
+    }
+
+    if (state->flags & SDL_INIT_AUDIO) {
+        if (state->verbose & VERBOSE_AUDIO) {
+            n = SDL_GetNumAudioDrivers();
+            if (n == 0) {
+                fprintf(stderr, "No built-in audio drivers\n");
+            } else {
+                fprintf(stderr, "Built-in audio drivers:");
+                for (i = 0; i < n; ++i) {
+                    if (i > 0) {
+                        fprintf(stderr, ",");
+                    }
+                    fprintf(stderr, " %s", SDL_GetAudioDriver(i));
+                }
+                fprintf(stderr, "\n");
+            }
+        }
+        if (SDL_AudioInit(state->audiodriver) < 0) {
+            fprintf(stderr, "Couldn't initialize audio driver: %s\n",
+                    SDL_GetError());
+            return SDL_FALSE;
+        }
+        if (state->verbose & VERBOSE_VIDEO) {
+            fprintf(stderr, "Audio driver: %s\n",
+                    SDL_GetCurrentAudioDriver());
+        }
+
+        if (SDL_OpenAudio(&state->audiospec, NULL) < 0) {
+            fprintf(stderr, "Couldn't open audio: %s\n", SDL_GetError());
+            return SDL_FALSE;
+        }
+    }
+
+    return SDL_TRUE;
+}
+
+static void
+PrintEvent(SDL_Event * event)
+{
+    fprintf(stderr, "SDL EVENT: ");
+    switch (event->type) {
+    case SDL_WINDOWEVENT:
+        switch (event->window.event) {
+        case SDL_WINDOWEVENT_SHOWN:
+            fprintf(stderr, "Window %d shown", event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_HIDDEN:
+            fprintf(stderr, "Window %d hidden", event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_EXPOSED:
+            fprintf(stderr, "Window %d exposed", event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_MOVED:
+            fprintf(stderr, "Window %d moved to %d,%d",
+                    event->window.windowID, event->window.data1,
+                    event->window.data2);
+            break;
+        case SDL_WINDOWEVENT_RESIZED:
+            fprintf(stderr, "Window %d resized to %dx%d",
+                    event->window.windowID, event->window.data1,
+                    event->window.data2);
+            break;
+        case SDL_WINDOWEVENT_MINIMIZED:
+            fprintf(stderr, "Window %d minimized", event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_MAXIMIZED:
+            fprintf(stderr, "Window %d maximized", event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_RESTORED:
+            fprintf(stderr, "Window %d restored", event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_ENTER:
+            fprintf(stderr, "Mouse entered window %d",
+                    event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_LEAVE:
+            fprintf(stderr, "Mouse left window %d", event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_FOCUS_GAINED:
+            fprintf(stderr, "Window %d gained keyboard focus",
+                    event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_FOCUS_LOST:
+            fprintf(stderr, "Window %d lost keyboard focus",
+                    event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_CLOSE:
+            fprintf(stderr, "Window %d closed", event->window.windowID);
+            break;
+        default:
+            fprintf(stderr, "Window %d got unknown event %d",
+                    event->window.windowID, event->window.event);
+            break;
+        }
+        break;
+    case SDL_KEYDOWN:
+        fprintf(stderr,
+                "Keyboard %d: key pressed  in window %d: scancode 0x%08X = %s, keycode 0x%08X = %s",
+                event->key.which, event->key.windowID,
+                event->key.keysym.scancode,
+                SDL_GetScancodeName(event->key.keysym.scancode),
+                event->key.keysym.sym, SDL_GetKeyName(event->key.keysym.sym));
+        break;
+    case SDL_KEYUP:
+        fprintf(stderr,
+                "Keyboard %d: key released in window %d: scancode 0x%08X = %s, keycode 0x%08X = %s",
+                event->key.which, event->key.windowID,
+                event->key.keysym.scancode,
+                SDL_GetScancodeName(event->key.keysym.scancode),
+                event->key.keysym.sym, SDL_GetKeyName(event->key.keysym.sym));
+        break;
+    case SDL_TEXTINPUT:
+        fprintf(stderr, "Keyboard %d: text input \"%s\" in window %d",
+                event->text.which, event->text.text, event->text.windowID);
+        break;
+    case SDL_MOUSEMOTION:
+        fprintf(stderr, "Mouse %d: moved to %d,%d (%d,%d) in window %d",
+                event->motion.which, event->motion.x, event->motion.y,
+                event->motion.xrel, event->motion.yrel,
+                event->motion.windowID);
+        break;
+    case SDL_MOUSEBUTTONDOWN:
+        fprintf(stderr, "Mouse %d: button %d pressed at %d,%d in window %d",
+                event->button.which, event->button.button, event->button.x,
+                event->button.y, event->button.windowID);
+        break;
+    case SDL_MOUSEBUTTONUP:
+        fprintf(stderr, "Mouse %d: button %d released at %d,%d in window %d",
+                event->button.which, event->button.button, event->button.x,
+                event->button.y, event->button.windowID);
+        break;
+    case SDL_MOUSEWHEEL:
+        fprintf(stderr,
+                "Mouse %d: wheel scrolled %d in x and %d in y in window %d",
+                event->wheel.which, event->wheel.x, event->wheel.y,
+                event->wheel.windowID);
+        break;
+    case SDL_JOYBALLMOTION:
+        fprintf(stderr, "Joystick %d: ball %d moved by %d,%d",
+                event->jball.which, event->jball.ball, event->jball.xrel,
+                event->jball.yrel);
+        break;
+    case SDL_JOYHATMOTION:
+        fprintf(stderr, "Joystick %d: hat %d moved to ", event->jhat.which,
+                event->jhat.hat);
+        switch (event->jhat.value) {
+        case SDL_HAT_CENTERED:
+            fprintf(stderr, "CENTER");
+            break;
+        case SDL_HAT_UP:
+            fprintf(stderr, "UP");
+            break;
+        case SDL_HAT_RIGHTUP:
+            fprintf(stderr, "RIGHTUP");
+            break;
+        case SDL_HAT_RIGHT:
+            fprintf(stderr, "RIGHT");
+            break;
+        case SDL_HAT_RIGHTDOWN:
+            fprintf(stderr, "RIGHTDOWN");
+            break;
+        case SDL_HAT_DOWN:
+            fprintf(stderr, "DOWN");
+            break;
+        case SDL_HAT_LEFTDOWN:
+            fprintf(stderr, "LEFTDOWN");
+            break;
+        case SDL_HAT_LEFT:
+            fprintf(stderr, "LEFT");
+            break;
+        case SDL_HAT_LEFTUP:
+            fprintf(stderr, "LEFTUP");
+            break;
+        default:
+            fprintf(stderr, "UNKNOWN");
+            break;
+        }
+        break;
+    case SDL_JOYBUTTONDOWN:
+        fprintf(stderr, "Joystick %d: button %d pressed",
+                event->jbutton.which, event->jbutton.button);
+        break;
+    case SDL_JOYBUTTONUP:
+        fprintf(stderr, "Joystick %d: button %d released",
+                event->jbutton.which, event->jbutton.button);
+        break;
+    case SDL_QUIT:
+        fprintf(stderr, "Quit requested");
+        break;
+    case SDL_USEREVENT:
+        fprintf(stderr, "User event %d", event->user.code);
+        break;
+    default:
+        fprintf(stderr, "Unknown event %d", event->type);
+        break;
+    }
+    fprintf(stderr, "\n");
+}
+
+void
+CommonEvent(CommonState * state, SDL_Event * event, int *done)
+{
+    if (state->verbose & VERBOSE_EVENT) {
+        PrintEvent(event);
+    }
+
+    switch (event->type) {
+    case SDL_WINDOWEVENT:
+        switch (event->window.event) {
+        case SDL_WINDOWEVENT_CLOSE:
+            *done = 1;
+            break;
+        }
+        break;
+    case SDL_KEYDOWN:
+        switch (event->key.keysym.sym) {
+            /* Add hotkeys here */
+        case SDLK_g:
+            if (event->key.keysym.mod & KMOD_CTRL) {
+                /* Ctrl-G toggle grab */
+            }
+            break;
+        case SDLK_ESCAPE:
+            *done = 1;
+            break;
+        default:
+            break;
+        }
+        break;
+    case SDL_QUIT:
+        *done = 1;
+        break;
+    }
+}
+
+void
+CommonQuit(CommonState * state)
+{
+    if (state->flags & SDL_INIT_VIDEO) {
+        SDL_VideoQuit();
+    }
+    if (state->flags & SDL_INIT_AUDIO) {
+        SDL_AudioQuit();
+    }
+    if (state->windows) {
+        SDL_free(state->windows);
+    }
+    SDL_free(state);
+}
diff -r dd25eabe441c -r 204be4fc2726 test/nds-test-progs/sprite/source/common.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/nds-test-progs/sprite/source/common.h	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,48 @@
+
+/* A simple test program framework */
+
+#include <SDL/SDL.h>
+
+#define VERBOSE_VIDEO   0x00000001
+#define VERBOSE_MODES   0x00000002
+#define VERBOSE_RENDER  0x00000004
+#define VERBOSE_EVENT   0x00000008
+#define VERBOSE_AUDIO   0x00000010
+
+typedef struct
+{
+    /* SDL init flags */
+    char **argv;
+    Uint32 flags;
+    Uint32 verbose;
+
+    /* Video info */
+    const char *videodriver;
+    int display;
+    const char *window_title;
+    Uint32 window_flags;
+    int window_x;
+    int window_y;
+    int window_w;
+    int window_h;
+    int depth;
+    int refresh_rate;
+    int num_windows;
+    SDL_WindowID *windows;
+
+    /* Renderer info */
+    const char *renderdriver;
+    Uint32 render_flags;
+    SDL_bool skip_renderer;
+
+    /* Audio info */
+    const char *audiodriver;
+    SDL_AudioSpec audiospec;
+} CommonState;
+
+extern CommonState *CommonCreateState(char **argv, Uint32 flags);
+extern int CommonArg(CommonState * state, int index);
+extern const char *CommonUsage(CommonState * state);
+extern SDL_bool CommonInit(CommonState * state);
+extern void CommonEvent(CommonState * state, SDL_Event * event, int *done);
+extern void CommonQuit(CommonState * state);
diff -r dd25eabe441c -r 204be4fc2726 test/nds-test-progs/sprite/source/testsprite.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/nds-test-progs/sprite/source/testsprite.c	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,316 @@
+/* Simple program:  Move N sprites around on the screen as fast as possible */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include <math.h>
+#include <fat.h>
+#include <SDL/SDL.h>
+
+#define NUM_SPRITES	10
+#define MAX_SPEED 	1
+
+SDL_Surface *sprite;
+int numsprites;
+SDL_Rect *sprite_rects;
+SDL_Rect *positions;
+SDL_Rect *velocities;
+int sprites_visible;
+int debug_flip;
+Uint16 sprite_w, sprite_h;
+
+/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
+static void
+quit(int rc)
+{
+    SDL_Quit();
+    exit(rc);
+}
+
+int
+LoadSprite(char *file)
+{
+    SDL_Surface *temp;
+
+    /* Load the sprite image */
+    sprite = SDL_LoadBMP(file);
+    if (sprite == NULL) {
+        fprintf(stderr, "Couldn't load %s: %s", file, SDL_GetError());
+        return (-1);
+    }
+
+    /* Set transparent pixel as the pixel at (0,0) */
+    if (sprite->format->palette) {
+        SDL_SetColorKey(sprite, (SDL_SRCCOLORKEY | SDL_RLEACCEL),
+                        *(Uint8 *) sprite->pixels);
+    }
+
+    /* Convert sprite to video format */
+    temp = SDL_DisplayFormat(sprite);
+    SDL_FreeSurface(sprite);
+    if (temp == NULL) {
+        fprintf(stderr, "Couldn't convert background: %s\n", SDL_GetError());
+        return (-1);
+    }
+    sprite = temp;
+
+    /* We're ready to roll. :) */
+    return (0);
+}
+
+void
+MoveSprites(SDL_Surface * screen, Uint32 background)
+{
+    int i, nupdates;
+    SDL_Rect area, *position, *velocity;
+
+    nupdates = 0;
+    /* Erase all the sprites if necessary */
+    if (sprites_visible) {
+        SDL_FillRect(screen, NULL, background);
+    }
+
+    /* Move the sprite, bounce at the wall, and draw */
+    for (i = 0; i < numsprites; ++i) {
+        position = &positions[i];
+        velocity = &velocities[i];
+        position->x += velocity->x;
+        if ((position->x < 0) || (position->x >= (screen->w - sprite_w))) {
+            velocity->x = -velocity->x;
+            position->x += velocity->x;
+        }
+        position->y += velocity->y;
+        if ((position->y < 0) || (position->y >= (screen->h - sprite_w))) {
+            velocity->y = -velocity->y;
+            position->y += velocity->y;
+        }
+
+        /* Blit the sprite onto the screen */
+        area = *position;
+        SDL_BlitSurface(sprite, NULL, screen, &area);
+        sprite_rects[nupdates++] = area;
+    }
+
+    if (debug_flip) {
+        if ((screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) {
+            static int t = 0;
+
+            Uint32 color = SDL_MapRGB(screen->format, 255, 0, 0);
+            SDL_Rect r;
+            r.x = t;
+/* (sin((float) t * 2 * 3.1459) + 1.0) / 2.0 * (screen->w - 20); */
+            r.y = 0;
+            r.w = 20;
+            r.h = screen->h;
+
+            SDL_FillRect(screen, &r, color);
+            t += 2;
+        }
+    }
+
+    /* Update the screen! */
+    if ((screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) {
+        SDL_Flip(screen);
+    } else {
+        SDL_UpdateRects(screen, nupdates, sprite_rects);
+    }
+    sprites_visible = 1;
+}
+
+/* This is a way of telling whether or not to use hardware surfaces */
+Uint32
+FastestFlags(Uint32 flags, int width, int height, int bpp)
+{
+    const SDL_VideoInfo *info;
+
+    /* Hardware acceleration is only used in fullscreen mode */
+    flags |= SDL_FULLSCREEN;
+
+    /* Check for various video capabilities */
+    info = SDL_GetVideoInfo();
+    if (info->blit_hw_CC && info->blit_fill) {
+        /* We use accelerated colorkeying and color filling */
+        flags |= SDL_HWSURFACE;
+    }
+    /* If we have enough video memory, and will use accelerated
+       blits directly to it, then use page flipping.
+     */
+    if ((flags & SDL_HWSURFACE) == SDL_HWSURFACE) {
+        /* Direct hardware blitting without double-buffering
+           causes really bad flickering.
+         */
+        if (info->video_mem * 1024 > (height * width * bpp / 8)) {
+            flags |= SDL_DOUBLEBUF;
+        } else {
+            flags &= ~SDL_HWSURFACE;
+        }
+    }
+
+    /* Return the flags */
+    return (flags);
+}
+
+int
+main(int argc, char *argv[])
+{
+    SDL_Surface *screen;
+    Uint8 *mem;
+    int width, height;
+    Uint8 video_bpp;
+    Uint32 videoflags;
+    Uint32 background;
+    int i, done;
+    SDL_Event event;
+    Uint32 then, now, frames;
+
+    consoleDemoInit();
+    puts("Hello world!  Initializing FAT...");
+    fatInitDefault();
+    /* Initialize SDL */
+    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
+        fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError());
+        return (1);
+    }
+    puts("* initialized SDL");
+
+    numsprites = NUM_SPRITES;
+    videoflags = SDL_SWSURFACE /*| SDL_ANYFORMAT */ ;
+    width = 256;
+    height = 192;
+    video_bpp = 15;
+    debug_flip = 0;
+    while (argc > 1) {
+        --argc;
+        if (strcmp(argv[argc - 1], "-width") == 0) {
+            width = atoi(argv[argc]);
+            --argc;
+        } else if (strcmp(argv[argc - 1], "-height") == 0) {
+            height = atoi(argv[argc]);
+            --argc;
+        } else if (strcmp(argv[argc - 1], "-bpp") == 0) {
+            video_bpp = atoi(argv[argc]);
+            videoflags &= ~SDL_ANYFORMAT;
+            --argc;
+        } else if (strcmp(argv[argc], "-fast") == 0) {
+            videoflags = FastestFlags(videoflags, width, height, video_bpp);
+        } else if (strcmp(argv[argc], "-hw") == 0) {
+            videoflags ^= SDL_HWSURFACE;
+        } else if (strcmp(argv[argc], "-flip") == 0) {
+            videoflags ^= SDL_DOUBLEBUF;
+        } else if (strcmp(argv[argc], "-debugflip") == 0) {
+            debug_flip ^= 1;
+        } else if (strcmp(argv[argc], "-fullscreen") == 0) {
+            videoflags ^= SDL_FULLSCREEN;
+        } else if (isdigit(argv[argc][0])) {
+            numsprites = atoi(argv[argc]);
+        } else {
+            fprintf(stderr,
+                    "Usage: %s [-bpp N] [-hw] [-flip] [-fast] [-fullscreen] [numsprites]\n",
+                    argv[0]);
+            quit(1);
+        }
+    }
+
+    /* Set video mode */
+    screen = SDL_SetVideoMode(width, height, video_bpp, videoflags);
+    if (!screen) {
+        fprintf(stderr, "Couldn't set %dx%d video mode: %s\n",
+                width, height, SDL_GetError());
+        quit(2);
+    }
+    screen->flags &= ~SDL_PREALLOC;
+    puts("* set video mode");
+
+    /* Load the sprite */
+    if (LoadSprite("icon.bmp") < 0) {
+        quit(1);
+    }
+    puts("* loaded sprite");
+
+    /* Allocate memory for the sprite info */
+    mem = (Uint8 *) malloc(4 * sizeof(SDL_Rect) * numsprites);
+    if (mem == NULL) {
+        SDL_FreeSurface(sprite);
+        fprintf(stderr, "Out of memory!\n");
+        quit(2);
+    }
+    sprite_rects = (SDL_Rect *) mem;
+    positions = sprite_rects;
+    sprite_rects += numsprites;
+    velocities = sprite_rects;
+    sprite_rects += numsprites;
+    sprite_w = sprite->w;
+    sprite_h = sprite->h;
+    srand(time(NULL));
+    for (i = 0; i < numsprites; ++i) {
+        positions[i].x = rand() % (screen->w - sprite_w);
+        positions[i].y = rand() % (screen->h - sprite_h);
+        positions[i].w = sprite->w;
+        positions[i].h = sprite->h;
+        velocities[i].x = 0;
+        velocities[i].y = 0;
+        while (!velocities[i].x && !velocities[i].y) {
+            velocities[i].x = (rand() % (MAX_SPEED * 2 + 1)) - MAX_SPEED;
+            velocities[i].y = (rand() % (MAX_SPEED * 2 + 1)) - MAX_SPEED;
+        }
+    }
+    background = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
+
+    /* Print out information about our surfaces */
+    printf("Screen is at %d bits per pixel\n", screen->format->BitsPerPixel);
+    if ((screen->flags & SDL_HWSURFACE) == SDL_HWSURFACE) {
+        printf("Screen is in video memory\n");
+    } else {
+        printf("Screen is in system memory\n");
+    }
+    if ((screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) {
+        printf("Screen has double-buffering enabled\n");
+    }
+    if ((sprite->flags & SDL_HWSURFACE) == SDL_HWSURFACE) {
+        printf("Sprite is in video memory\n");
+    } else {
+        printf("Sprite is in system memory\n");
+    }
+    /* Run a sample blit to trigger blit acceleration */
+    {
+        SDL_Rect dst;
+        dst.x = 0;
+        dst.y = 0;
+        dst.w = sprite->w;
+        dst.h = sprite->h;
+        SDL_BlitSurface(sprite, NULL, screen, &dst);
+        SDL_FillRect(screen, &dst, background);
+    }
+    if ((sprite->flags & SDL_HWACCEL) == SDL_HWACCEL) {
+        printf("Sprite blit uses hardware acceleration\n");
+    }
+    if ((sprite->flags & SDL_RLEACCEL) == SDL_RLEACCEL) {
+        printf("Sprite blit uses RLE acceleration\n");
+    }
+
+    /* Loop, blitting sprites and waiting for a keystroke */
+    frames = 0;
+    then = SDL_GetTicks();
+    done = 0;
+    sprites_visible = 0;
+    puts("hello!");
+    while (!done) {
+        /* Check for events */
+        ++frames;
+        printf(".");
+        swiWaitForVBlank();
+        MoveSprites(screen, background);
+    }
+    puts("goodbye!");
+    SDL_FreeSurface(sprite);
+    free(mem);
+
+    /* Print out some timing information */
+    now = SDL_GetTicks();
+    if (now > then) {
+        printf("%2.2f frames per second\n",
+               ((double) frames * 1000) / (now - then));
+    }
+    SDL_Quit();
+    return (0);
+}
diff -r dd25eabe441c -r 204be4fc2726 test/nds-test-progs/sprite2/Makefile
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/nds-test-progs/sprite2/Makefile	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,132 @@
+#---------------------------------------------------------------------------------
+.SUFFIXES:
+#---------------------------------------------------------------------------------
+
+ifeq ($(strip $(DEVKITARM)),)
+$(error "Please set DEVKITARM in your environment. export DEVKITARM=<path to>devkitARM")
+endif
+
+include $(DEVKITARM)/ds_rules
+
+#---------------------------------------------------------------------------------
+# TARGET is the name of the output
+# BUILD is the directory where object files & intermediate files will be placed
+# SOURCES is a list of directories containing source code
+# INCLUDES is a list of directories containing extra header files
+#---------------------------------------------------------------------------------
+TARGET		:=	$(shell basename $(CURDIR))
+BUILD		:=	build
+SOURCES		:=	source
+DATA		:=	data  
+INCLUDES	:=	include
+
+#---------------------------------------------------------------------------------
+# options for code generation
+#---------------------------------------------------------------------------------
+ARCH	:=	-mthumb -mthumb-interwork
+
+# note: arm9tdmi isn't the correct CPU arch, but anything newer and LD
+# *insists* it has a FPU or VFP, and it won't take no for an answer!
+CFLAGS	:=	-save-temps -g -Wall -O0\
+ 			-mcpu=arm9tdmi -mtune=arm9tdmi \
+			$(ARCH)
+
+CFLAGS	+=	$(INCLUDE) -DARM9 -D__NDS__
+CXXFLAGS	:= $(CFLAGS) -fno-rtti -fno-exceptions -fno-exceptions -fno-rtti
+
+ASFLAGS	:=	-g $(ARCH)
+LDFLAGS	=	-specs=ds_arm9.specs -g $(ARCH) -mno-fpu -Wl,-Map,$(notdir $*.map)
+
+#---------------------------------------------------------------------------------
+# any extra libraries we wish to link with the project
+#---------------------------------------------------------------------------------
+LIBS	:= -lSDL -lfat -lnds9
+ 
+ 
+#---------------------------------------------------------------------------------
+# list of directories containing libraries, this must be the top level containing
+# include and lib
+#---------------------------------------------------------------------------------
+LIBDIRS	:=	$(LIBNDS)
+ 
+#---------------------------------------------------------------------------------
+# no real need to edit anything past this point unless you need to add additional
+# rules for different file extensions
+#---------------------------------------------------------------------------------
+ifneq ($(BUILD),$(notdir $(CURDIR)))
+#---------------------------------------------------------------------------------
+ 
+export OUTPUT	:=	$(CURDIR)/$(TARGET)
+ 
+export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
+					$(foreach dir,$(DATA),$(CURDIR)/$(dir))
+
+export DEPSDIR	:=	$(CURDIR)/$(BUILD)
+
+CFILES		:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
+CPPFILES	:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
+SFILES		:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
+BINFILES	:=	$(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
+ 
+#---------------------------------------------------------------------------------
+# use CXX for linking C++ projects, CC for standard C
+#---------------------------------------------------------------------------------
+ifeq ($(strip $(CPPFILES)),)
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CC)
+#---------------------------------------------------------------------------------
+else
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CXX)
+#---------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------
+
+export OFILES	:=	$(addsuffix .o,$(BINFILES)) \
+					$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
+ 
+export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
+					$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
+					$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
+					-I$(CURDIR)/$(BUILD)
+ 
+export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/lib)
+ 
+.PHONY: $(BUILD) clean
+ 
+#---------------------------------------------------------------------------------
+$(BUILD):
+	@[ -d $@ ] || mkdir -p $@
+	@make --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
+ 
+#---------------------------------------------------------------------------------
+clean:
+	@echo clean ...
+	@rm -fr $(BUILD) $(TARGET).elf $(TARGET).nds $(TARGET).arm9 $(TARGET).ds.gba 
+ 
+ 
+#---------------------------------------------------------------------------------
+else
+ 
+DEPENDS	:=	$(OFILES:.o=.d)
+ 
+#---------------------------------------------------------------------------------
+# main targets
+#---------------------------------------------------------------------------------
+$(OUTPUT).ds.gba	: 	$(OUTPUT).nds
+$(OUTPUT).nds	: 	$(OUTPUT).arm9
+$(OUTPUT).arm9	:	$(OUTPUT).elf
+$(OUTPUT).elf	:	$(OFILES)
+ 
+#---------------------------------------------------------------------------------
+%.bin.o	:	%.bin
+#---------------------------------------------------------------------------------
+	@echo $(notdir $<)
+	@$(bin2o)
+ 
+ 
+-include $(DEPENDS)
+ 
+#---------------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------------
diff -r dd25eabe441c -r 204be4fc2726 test/nds-test-progs/sprite2/source/common.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/nds-test-progs/sprite2/source/common.c	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,965 @@
+
+/* A simple test program framework */
+
+#include <stdio.h>
+
+#include "common.h"
+
+#define VIDEO_USAGE \
+"[--video driver] [--renderer driver] [--info all|video|modes|render|event] [--display %d] [--fullscreen | --windows N] [--title title] [--center | --position X,Y] [--geometry WxH] [--depth N] [--refresh R] [--vsync] [--noframe] [--resize] [--minimize] [--maximize] [--grab]"
+
+#define AUDIO_USAGE \
+"[--rate N] [--format U8|S8|U16|U16LE|U16BE|S16|S16LE|S16BE] [--channels N] [--samples N]"
+
+CommonState *
+CommonCreateState(char **argv, Uint32 flags)
+{
+    CommonState *state = SDL_calloc(1, sizeof(*state));
+    if (!state) {
+        SDL_OutOfMemory();
+        return NULL;
+    }
+
+    /* Initialize some defaults */
+    state->argv = argv;
+    state->flags = flags;
+    state->window_title = argv[0];
+    state->window_flags = SDL_WINDOW_SHOWN;
+    state->window_x = SDL_WINDOWPOS_UNDEFINED;
+    state->window_y = SDL_WINDOWPOS_UNDEFINED;
+    state->window_w = 256;
+    state->window_h = 192;
+    state->num_windows = 1;
+    state->audiospec.freq = 22050;
+    state->audiospec.format = AUDIO_S16;
+    state->audiospec.channels = 2;
+    state->audiospec.samples = 2048;
+    return state;
+}
+
+int
+CommonArg(CommonState * state, int index)
+{
+    char **argv = state->argv;
+
+    if (SDL_strcasecmp(argv[index], "--video") == 0) {
+        ++index;
+        if (!argv[index]) {
+            return -1;
+        }
+        state->videodriver = argv[index];
+        return 2;
+    }
+    if (SDL_strcasecmp(argv[index], "--renderer") == 0) {
+        ++index;
+        if (!argv[index]) {
+            return -1;
+        }
+        state->renderdriver = argv[index];
+        return 2;
+    }
+    if (SDL_strcasecmp(argv[index], "--info") == 0) {
+        ++index;
+        if (!argv[index]) {
+            return -1;
+        }
+        if (SDL_strcasecmp(argv[index], "all") == 0) {
+            state->verbose |=
+                (VERBOSE_VIDEO | VERBOSE_MODES | VERBOSE_RENDER |
+                 VERBOSE_EVENT);
+            return 2;
+        }
+        if (SDL_strcasecmp(argv[index], "video") == 0) {
+            state->verbose |= VERBOSE_VIDEO;
+            return 2;
+        }
+        if (SDL_strcasecmp(argv[index], "modes") == 0) {
+            state->verbose |= VERBOSE_MODES;
+            return 2;
+        }
+        if (SDL_strcasecmp(argv[index], "render") == 0) {
+            state->verbose |= VERBOSE_RENDER;
+            return 2;
+        }
+        if (SDL_strcasecmp(argv[index], "event") == 0) {
+            state->verbose |= VERBOSE_EVENT;
+            return 2;
+        }
+        return -1;
+    }
+    if (SDL_strcasecmp(argv[index], "--display") == 0) {
+        ++index;
+        if (!argv[index]) {
+            return -1;
+        }
+        state->display = SDL_atoi(argv[index]);
+        return 2;
+    }
+    if (SDL_strcasecmp(argv[index], "--fullscreen") == 0) {
+        state->window_flags |= SDL_WINDOW_FULLSCREEN;
+        state->num_windows = 1;
+        return 1;
+    }
+    if (SDL_strcasecmp(argv[index], "--windows") == 0) {
+        ++index;
+        if (!argv[index] || !SDL_isdigit(*argv[index])) {
+            return -1;
+        }
+        if (!(state->window_flags & SDL_WINDOW_FULLSCREEN)) {
+            state->num_windows = SDL_atoi(argv[index]);
+        }
+        return 2;
+    }
+    if (SDL_strcasecmp(argv[index], "--title") == 0) {
+        ++index;
+        if (!argv[index]) {
+            return -1;
+        }
+        state->window_title = argv[index];
+        return 2;
+    }
+    if (SDL_strcasecmp(argv[index], "--center") == 0) {
+        state->window_x = SDL_WINDOWPOS_CENTERED;
+        state->window_y = SDL_WINDOWPOS_CENTERED;
+        return 1;
+    }
+    if (SDL_strcasecmp(argv[index], "--position") == 0) {
+        char *x, *y;
+        ++index;
+        if (!argv[index]) {
+            return -1;
+        }
+        x = argv[index];
+        y = argv[index];
+        while (*y && *y != ',') {
+            ++y;
+        }
+        if (!*y) {
+            return -1;
+        }
+        *y++ = '\0';
+        state->window_x = SDL_atoi(x);
+        state->window_y = SDL_atoi(y);
+        return 2;
+    }
+    if (SDL_strcasecmp(argv[index], "--geometry") == 0) {
+        char *w, *h;
+        ++index;
+        if (!argv[index]) {
+            return -1;
+        }
+        w = argv[index];
+        h = argv[index];
+        while (*h && *h != 'x') {
+            ++h;
+        }
+        if (!*h) {
+            return -1;
+        }
+        *h++ = '\0';
+        state->window_w = SDL_atoi(w);
+        state->window_h = SDL_atoi(h);
+        return 2;
+    }
+    if (SDL_strcasecmp(argv[index], "--depth") == 0) {
+        ++index;
+        if (!argv[index]) {
+            return -1;
+        }
+        state->depth = SDL_atoi(argv[index]);
+        return 2;
+    }
+    if (SDL_strcasecmp(argv[index], "--refresh") == 0) {
+        ++index;
+        if (!argv[index]) {
+            return -1;
+        }
+        state->refresh_rate = SDL_atoi(argv[index]);
+        return 2;
+    }
+    if (SDL_strcasecmp(argv[index], "--vsync") == 0) {
+        state->render_flags |= SDL_RENDERER_PRESENTVSYNC;
+        return 1;
+    }
+    if (SDL_strcasecmp(argv[index], "--noframe") == 0) {
+        state->window_flags |= SDL_WINDOW_BORDERLESS;
+        return 1;
+    }
+    if (SDL_strcasecmp(argv[index], "--resize") == 0) {
+        state->window_flags |= SDL_WINDOW_RESIZABLE;
+        return 1;
+    }
+    if (SDL_strcasecmp(argv[index], "--minimize") == 0) {
+        state->window_flags |= SDL_WINDOW_MINIMIZED;
+        return 1;
+    }
+    if (SDL_strcasecmp(argv[index], "--maximize") == 0) {
+        state->window_flags |= SDL_WINDOW_MAXIMIZED;
+        return 1;
+    }
+    if (SDL_strcasecmp(argv[index], "--grab") == 0) {
+        state->window_flags |= SDL_WINDOW_INPUT_GRABBED;
+        return 1;
+    }
+    if (SDL_strcasecmp(argv[index], "--rate") == 0) {
+        ++index;
+        if (!argv[index]) {
+            return -1;
+        }
+        state->audiospec.freq = SDL_atoi(argv[index]);
+        return 2;
+    }
+    if (SDL_strcasecmp(argv[index], "--format") == 0) {
+        ++index;
+        if (!argv[index]) {
+            return -1;
+        }
+        if (SDL_strcasecmp(argv[index], "U8") == 0) {
+            state->audiospec.format = AUDIO_U8;
+            return 2;
+        }
+        if (SDL_strcasecmp(argv[index], "S8") == 0) {
+            state->audiospec.format = AUDIO_S8;
+            return 2;
+        }
+        if (SDL_strcasecmp(argv[index], "U16") == 0) {
+            state->audiospec.format = AUDIO_U16;
+            return 2;
+        }
+        if (SDL_strcasecmp(argv[index], "U16LE") == 0) {
+            state->audiospec.format = AUDIO_U16LSB;
+            return 2;
+        }
+        if (SDL_strcasecmp(argv[index], "U16BE") == 0) {
+            state->audiospec.format = AUDIO_U16MSB;
+            return 2;
+        }
+        if (SDL_strcasecmp(argv[index], "S16") == 0) {
+            state->audiospec.format = AUDIO_S16;
+            return 2;
+        }
+        if (SDL_strcasecmp(argv[index], "S16LE") == 0) {
+            state->audiospec.format = AUDIO_S16LSB;
+            return 2;
+        }
+        if (SDL_strcasecmp(argv[index], "S16BE") == 0) {
+            state->audiospec.format = AUDIO_S16MSB;
+            return 2;
+        }
+        return -1;
+    }
+    if (SDL_strcasecmp(argv[index], "--channels") == 0) {
+        ++index;
+        if (!argv[index]) {
+            return -1;
+        }
+        state->audiospec.channels = (Uint8) SDL_atoi(argv[index]);
+        return 2;
+    }
+    if (SDL_strcasecmp(argv[index], "--samples") == 0) {
+        ++index;
+        if (!argv[index]) {
+            return -1;
+        }
+        state->audiospec.samples = (Uint16) SDL_atoi(argv[index]);
+        return 2;
+    }
+    if ((SDL_strcasecmp(argv[index], "-h") == 0)
+        || (SDL_strcasecmp(argv[index], "--help") == 0)) {
+        /* Print the usage message */
+        return -1;
+    }
+    return 0;
+}
+
+const char *
+CommonUsage(CommonState * state)
+{
+    switch (state->flags & (SDL_INIT_VIDEO | SDL_INIT_AUDIO)) {
+    case SDL_INIT_VIDEO:
+        return VIDEO_USAGE;
+    case SDL_INIT_AUDIO:
+        return AUDIO_USAGE;
+    case (SDL_INIT_VIDEO | SDL_INIT_AUDIO):
+        return VIDEO_USAGE " " AUDIO_USAGE;
+    default:
+        return "";
+    }
+}
+
+static void
+PrintRendererFlag(Uint32 flag)
+{
+    switch (flag) {
+    case SDL_RENDERER_SINGLEBUFFER:
+        fprintf(stderr, "SingleBuffer");
+        break;
+    case SDL_RENDERER_PRESENTCOPY:
+        fprintf(stderr, "PresentCopy");
+        break;
+    case SDL_RENDERER_PRESENTFLIP2:
+        fprintf(stderr, "PresentFlip2");
+        break;
+    case SDL_RENDERER_PRESENTFLIP3:
+        fprintf(stderr, "PresentFlip3");
+        break;
+    case SDL_RENDERER_PRESENTDISCARD:
+        fprintf(stderr, "PresentDiscard");
+        break;
+    case SDL_RENDERER_PRESENTVSYNC:
+        fprintf(stderr, "PresentVSync");
+        break;
+    case SDL_RENDERER_ACCELERATED:
+        fprintf(stderr, "Accelerated");
+        break;
+    default:
+        fprintf(stderr, "0x%8.8x", flag);
+        break;
+    }
+}
+
+static void
+PrintBlendMode(Uint32 flag)
+{
+    switch (flag) {
+    case SDL_TEXTUREBLENDMODE_NONE:
+        fprintf(stderr, "None");
+        break;
+    case SDL_TEXTUREBLENDMODE_MASK:
+        fprintf(stderr, "Mask");
+        break;
+    case SDL_TEXTUREBLENDMODE_BLEND:
+        fprintf(stderr, "Blend");
+        break;
+    case SDL_TEXTUREBLENDMODE_ADD:
+        fprintf(stderr, "Add");
+        break;
+    case SDL_TEXTUREBLENDMODE_MOD:
+        fprintf(stderr, "Mod");
+        break;
+    default:
+        fprintf(stderr, "0x%8.8x", flag);
+        break;
+    }
+}
+
+static void
+PrintScaleMode(Uint32 flag)
+{
+    switch (flag) {
+    case SDL_TEXTURESCALEMODE_NONE:
+        fprintf(stderr, "None");
+        break;
+    case SDL_TEXTURESCALEMODE_FAST:
+        fprintf(stderr, "Fast");
+        break;
+    case SDL_TEXTURESCALEMODE_SLOW:
+        fprintf(stderr, "Slow");
+        break;
+    case SDL_TEXTURESCALEMODE_BEST:
+        fprintf(stderr, "Best");
+        break;
+    default:
+        fprintf(stderr, "0x%8.8x", flag);
+        break;
+    }
+}
+
+static void
+PrintPixelFormat(Uint32 format)
+{
+    switch (format) {
+    case SDL_PIXELFORMAT_UNKNOWN:
+        fprintf(stderr, "Unknwon");
+        break;
+    case SDL_PIXELFORMAT_INDEX1LSB:
+        fprintf(stderr, "Index1LSB");
+        break;
+    case SDL_PIXELFORMAT_INDEX1MSB:
+        fprintf(stderr, "Index1MSB");
+        break;
+    case SDL_PIXELFORMAT_INDEX4LSB:
+        fprintf(stderr, "Index4LSB");
+        break;
+    case SDL_PIXELFORMAT_INDEX4MSB:
+        fprintf(stderr, "Index4MSB");
+        break;
+    case SDL_PIXELFORMAT_INDEX8:
+        fprintf(stderr, "Index8");
+        break;
+    case SDL_PIXELFORMAT_RGB332:
+        fprintf(stderr, "RGB332");
+        break;
+    case SDL_PIXELFORMAT_RGB444:
+        fprintf(stderr, "RGB444");
+        break;
+    case SDL_PIXELFORMAT_RGB555:
+        fprintf(stderr, "RGB555");
+        break;
+    case SDL_PIXELFORMAT_ARGB4444:
+        fprintf(stderr, "ARGB4444");
+        break;
+    case SDL_PIXELFORMAT_ARGB1555:
+        fprintf(stderr, "ARGB1555");
+        break;
+    case SDL_PIXELFORMAT_RGB565:
+        fprintf(stderr, "RGB565");
+        break;
+    case SDL_PIXELFORMAT_RGB24:
+        fprintf(stderr, "RGB24");
+        break;
+    case SDL_PIXELFORMAT_BGR24:
+        fprintf(stderr, "BGR24");
+        break;
+    case SDL_PIXELFORMAT_RGB888:
+        fprintf(stderr, "RGB888");
+        break;
+    case SDL_PIXELFORMAT_BGR888:
+        fprintf(stderr, "BGR888");
+        break;
+    case SDL_PIXELFORMAT_ARGB8888:
+        fprintf(stderr, "ARGB8888");
+        break;
+    case SDL_PIXELFORMAT_RGBA8888:
+        fprintf(stderr, "RGBA8888");
+        break;
+    case SDL_PIXELFORMAT_ABGR8888:
+        fprintf(stderr, "ABGR8888");
+        break;
+    case SDL_PIXELFORMAT_BGRA8888:
+        fprintf(stderr, "BGRA8888");
+        break;
+    case SDL_PIXELFORMAT_ARGB2101010:
+        fprintf(stderr, "ARGB2101010");
+        break;
+    case SDL_PIXELFORMAT_YV12:
+        fprintf(stderr, "YV12");
+        break;
+    case SDL_PIXELFORMAT_IYUV:
+        fprintf(stderr, "IYUV");
+        break;
+    case SDL_PIXELFORMAT_YUY2:
+        fprintf(stderr, "YUY2");
+        break;
+    case SDL_PIXELFORMAT_UYVY:
+        fprintf(stderr, "UYVY");
+        break;
+    case SDL_PIXELFORMAT_YVYU:
+        fprintf(stderr, "YVYU");
+        break;
+    case SDL_PIXELFORMAT_ABGR1555:
+        fprintf(stderr, "ABGR1555");
+        break;
+    case SDL_PIXELFORMAT_BGR555:
+        fprintf(stderr, "BGR555");
+        break;
+    default:
+        fprintf(stderr, "0x%8.8x", format);
+        break;
+    }
+}
+
+static void
+PrintRenderer(SDL_RendererInfo * info)
+{
+    int i, count;
+
+    fprintf(stderr, "  Renderer %s:\n", info->name);
+
+    fprintf(stderr, "    Flags: 0x%8.8X", info->flags);
+    fprintf(stderr, " (");
+    count = 0;
+    for (i = 0; i < sizeof(info->flags) * 8; ++i) {
+        Uint32 flag = (1 << i);
+        if (info->flags & flag) {
+            if (count > 0) {
+                fprintf(stderr, " | ");
+            }
+            PrintRendererFlag(flag);
+            ++count;
+        }
+    }
+    fprintf(stderr, ")\n");
+
+    fprintf(stderr, "    Blend: 0x%8.8X", info->blend_modes);
+    fprintf(stderr, " (");
+    count = 0;
+    for (i = 0; i < sizeof(info->blend_modes) * 8; ++i) {
+        Uint32 flag = (1 << i);
+        if (info->blend_modes & flag) {
+            if (count > 0) {
+                fprintf(stderr, " | ");
+            }
+            PrintBlendMode(flag);
+            ++count;
+        }
+    }
+    fprintf(stderr, ")\n");
+
+    fprintf(stderr, "    Scale: 0x%8.8X", info->scale_modes);
+    fprintf(stderr, " (");
+    count = 0;
+    for (i = 0; i < sizeof(info->scale_modes) * 8; ++i) {
+        Uint32 flag = (1 << i);
+        if (info->scale_modes & flag) {
+            if (count > 0) {
+                fprintf(stderr, " | ");
+            }
+            PrintScaleMode(flag);
+            ++count;
+        }
+    }
+    fprintf(stderr, ")\n");
+
+    fprintf(stderr, "    Texture formats (%d): ", info->num_texture_formats);
+    for (i = 0; i < (int) info->num_texture_formats; ++i) {
+        if (i > 0) {
+            fprintf(stderr, ", ");
+        }
+        PrintPixelFormat(info->texture_formats[i]);
+    }
+    fprintf(stderr, "\n");
+
+    if (info->max_texture_width || info->max_texture_height) {
+        fprintf(stderr, "    Max Texture Size: %dx%d\n",
+                info->max_texture_width, info->max_texture_height);
+    }
+}
+
+SDL_bool
+CommonInit(CommonState * state)
+{
+    int i, j, m, n;
+    SDL_DisplayMode fullscreen_mode;
+
+    if (state->flags & SDL_INIT_VIDEO) {
+        if (state->verbose & VERBOSE_VIDEO) {
+            n = SDL_GetNumVideoDrivers();
+            if (n == 0) {
+                fprintf(stderr, "No built-in video drivers\n");
+            } else {
+                fprintf(stderr, "Built-in video drivers:");
+                for (i = 0; i < n; ++i) {
+                    if (i > 0) {
+                        fprintf(stderr, ",");
+                    }
+                    fprintf(stderr, " %s", SDL_GetVideoDriver(i));
+                }
+                fprintf(stderr, "\n");
+            }
+        }
+        if (SDL_VideoInit(state->videodriver, 0) < 0) {
+            fprintf(stderr, "Couldn't initialize video driver: %s\n",
+                    SDL_GetError());
+            return SDL_FALSE;
+        }
+        if (state->verbose & VERBOSE_VIDEO) {
+            fprintf(stderr, "Video driver: %s\n",
+                    SDL_GetCurrentVideoDriver());
+        }
+
+        if (state->verbose & VERBOSE_MODES) {
+            SDL_DisplayMode mode;
+            int bpp;
+            Uint32 Rmask, Gmask, Bmask, Amask;
+
+            n = SDL_GetNumVideoDisplays();
+            fprintf(stderr, "Number of displays: %d\n", n);
+            for (i = 0; i < n; ++i) {
+                fprintf(stderr, "Display %d:\n", i);
+                SDL_SelectVideoDisplay(i);
+
+                SDL_GetDesktopDisplayMode(&mode);
+                SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask, &Gmask,
+                                           &Bmask, &Amask);
+                fprintf(stderr,
+                        "  Current mode: %dx%d@%dHz, %d bits-per-pixel\n",
+                        mode.w, mode.h, mode.refresh_rate, bpp);
+                if (Rmask || Gmask || Bmask) {
+                    fprintf(stderr, "      Red Mask = 0x%.8x\n", Rmask);
+                    fprintf(stderr, "      Green Mask = 0x%.8x\n", Gmask);
+                    fprintf(stderr, "      Blue Mask = 0x%.8x\n", Bmask);
+                    if (Amask)
+                        fprintf(stderr, "      Alpha Mask = 0x%.8x\n", Amask);
+                }
+
+                /* Print available fullscreen video modes */
+                m = SDL_GetNumDisplayModes();
+                if (m == 0) {
+                    fprintf(stderr, "No available fullscreen video modes\n");
+                } else {
+                    fprintf(stderr, "  Fullscreen video modes:\n");
+                    for (j = 0; j < m; ++j) {
+                        SDL_GetDisplayMode(j, &mode);
+                        SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask,
+                                                   &Gmask, &Bmask, &Amask);
+                        fprintf(stderr,
+                                "    Mode %d: %dx%d@%dHz, %d bits-per-pixel\n",
+                                j, mode.w, mode.h, mode.refresh_rate, bpp);
+                        if (Rmask || Gmask || Bmask) {
+                            fprintf(stderr, "        Red Mask = 0x%.8x\n",
+                                    Rmask);
+                            fprintf(stderr, "        Green Mask = 0x%.8x\n",
+                                    Gmask);
+                            fprintf(stderr, "        Blue Mask = 0x%.8x\n",
+                                    Bmask);
+                            if (Amask)
+                                fprintf(stderr,
+                                        "        Alpha Mask = 0x%.8x\n",
+                                        Amask);
+                        }
+                    }
+                }
+            }
+        }
+
+        SDL_SelectVideoDisplay(state->display);
+        if (state->verbose & VERBOSE_RENDER) {
+            SDL_RendererInfo info;
+
+            n = SDL_GetNumRenderDrivers();
+            if (n == 0) {
+                fprintf(stderr, "No built-in render drivers\n");
+            } else {
+                fprintf(stderr, "Built-in render drivers:\n");
+                for (i = 0; i < n; ++i) {
+                    SDL_GetRenderDriverInfo(i, &info);
+                    PrintRenderer(&info);
+                }
+            }
+        }
+
+        switch (state->depth) {
+        case 8:
+            fullscreen_mode.format = SDL_PIXELFORMAT_INDEX8;
+            break;
+        case 15:
+            fullscreen_mode.format = SDL_PIXELFORMAT_BGR555;
+            break;
+        case 16:
+        default:
+            fullscreen_mode.format = SDL_PIXELFORMAT_ABGR1555;
+            break;
+/* NDS       default:
+            fullscreen_mode.format = SDL_PIXELFORMAT_RGB888;
+            break;*/
+        }
+        fullscreen_mode.w = state->window_w;
+        fullscreen_mode.h = state->window_h;
+        fullscreen_mode.refresh_rate = state->refresh_rate;
+        SDL_SetFullscreenDisplayMode(&fullscreen_mode);
+
+        state->windows =
+            (SDL_WindowID *) SDL_malloc(state->num_windows *
+                                        sizeof(*state->windows));
+        if (!state->windows) {
+            fprintf(stderr, "Out of memory!\n");
+            return SDL_FALSE;
+        }
+        for (i = 0; i < state->num_windows; ++i) {
+            char title[1024];
+
+            if (state->num_windows > 1) {
+                SDL_snprintf(title, SDL_arraysize(title), "%s %d",
+                             state->window_title, i + 1);
+            } else {
+                SDL_strlcpy(title, state->window_title, SDL_arraysize(title));
+            }
+            state->windows[i] =
+                SDL_CreateWindow(title, state->window_x, state->window_y,
+                                 state->window_w, state->window_h,
+                                 state->window_flags);
+            if (!state->windows[i]) {
+                fprintf(stderr, "Couldn't create window: %s\n",
+                        SDL_GetError());
+                return SDL_FALSE;
+            }
+
+            if (!state->skip_renderer
+                && (state->renderdriver
+                    || !(state->window_flags & SDL_WINDOW_OPENGL))) {
+                m = -1;
+                if (state->renderdriver) {
+                    SDL_RendererInfo info;
+                    n = SDL_GetNumRenderDrivers();
+                    for (j = 0; j < n; ++j) {
+                        SDL_GetRenderDriverInfo(j, &info);
+                        if (SDL_strcasecmp(info.name, state->renderdriver) ==
+                            0) {
+                            m = j;
+                            break;
+                        }
+                    }
+                    if (m == n) {
+                        fprintf(stderr,
+                                "Couldn't find render driver named %s",
+                                state->renderdriver);
+                        return SDL_FALSE;
+                    }
+                }
+                if (SDL_CreateRenderer
+                    (state->windows[i], m, state->render_flags) < 0) {
+                    fprintf(stderr, "Couldn't create renderer: %s\n",
+                            SDL_GetError());
+                    return SDL_FALSE;
+                }
+                if (state->verbose & VERBOSE_RENDER) {
+                    SDL_RendererInfo info;
+
+                    fprintf(stderr, "Current renderer:\n");
+                    SDL_GetRendererInfo(&info);
+                    PrintRenderer(&info);
+                }
+            }
+        }
+        SDL_SelectRenderer(state->windows[0]);
+    }
+
+    if (state->flags & SDL_INIT_AUDIO) {
+        if (state->verbose & VERBOSE_AUDIO) {
+            n = SDL_GetNumAudioDrivers();
+            if (n == 0) {
+                fprintf(stderr, "No built-in audio drivers\n");
+            } else {
+                fprintf(stderr, "Built-in audio drivers:");
+                for (i = 0; i < n; ++i) {
+                    if (i > 0) {
+                        fprintf(stderr, ",");
+                    }
+                    fprintf(stderr, " %s", SDL_GetAudioDriver(i));
+                }
+                fprintf(stderr, "\n");
+            }
+        }
+        if (SDL_AudioInit(state->audiodriver) < 0) {
+            fprintf(stderr, "Couldn't initialize audio driver: %s\n",
+                    SDL_GetError());
+            return SDL_FALSE;
+        }
+        if (state->verbose & VERBOSE_VIDEO) {
+            fprintf(stderr, "Audio driver: %s\n",
+                    SDL_GetCurrentAudioDriver());
+        }
+
+        if (SDL_OpenAudio(&state->audiospec, NULL) < 0) {
+            fprintf(stderr, "Couldn't open audio: %s\n", SDL_GetError());
+            return SDL_FALSE;
+        }
+    }
+
+    return SDL_TRUE;
+}
+
+static void
+PrintEvent(SDL_Event * event)
+{
+    fprintf(stderr, "SDL EVENT: ");
+    switch (event->type) {
+    case SDL_WINDOWEVENT:
+        switch (event->window.event) {
+        case SDL_WINDOWEVENT_SHOWN:
+            fprintf(stderr, "Window %d shown", event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_HIDDEN:
+            fprintf(stderr, "Window %d hidden", event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_EXPOSED:
+            fprintf(stderr, "Window %d exposed", event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_MOVED:
+            fprintf(stderr, "Window %d moved to %d,%d",
+                    event->window.windowID, event->window.data1,
+                    event->window.data2);
+            break;
+        case SDL_WINDOWEVENT_RESIZED:
+            fprintf(stderr, "Window %d resized to %dx%d",
+                    event->window.windowID, event->window.data1,
+                    event->window.data2);
+            break;
+        case SDL_WINDOWEVENT_MINIMIZED:
+            fprintf(stderr, "Window %d minimized", event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_MAXIMIZED:
+            fprintf(stderr, "Window %d maximized", event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_RESTORED:
+            fprintf(stderr, "Window %d restored", event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_ENTER:
+            fprintf(stderr, "Mouse entered window %d",
+                    event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_LEAVE:
+            fprintf(stderr, "Mouse left window %d", event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_FOCUS_GAINED:
+            fprintf(stderr, "Window %d gained keyboard focus",
+                    event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_FOCUS_LOST:
+            fprintf(stderr, "Window %d lost keyboard focus",
+                    event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_CLOSE:
+            fprintf(stderr, "Window %d closed", event->window.windowID);
+            break;
+        default:
+            fprintf(stderr, "Window %d got unknown event %d",
+                    event->window.windowID, event->window.event);
+            break;
+        }
+        break;
+    case SDL_KEYDOWN:
+        fprintf(stderr,
+                "Keyboard %d: key pressed  in window %d: scancode 0x%08X = %s, keycode 0x%08X = %s",
+                event->key.which, event->key.windowID,
+                event->key.keysym.scancode,
+                SDL_GetScancodeName(event->key.keysym.scancode),
+                event->key.keysym.sym, SDL_GetKeyName(event->key.keysym.sym));
+        break;
+    case SDL_KEYUP:
+        fprintf(stderr,
+                "Keyboard %d: key released in window %d: scancode 0x%08X = %s, keycode 0x%08X = %s",
+                event->key.which, event->key.windowID,
+                event->key.keysym.scancode,
+                SDL_GetScancodeName(event->key.keysym.scancode),
+                event->key.keysym.sym, SDL_GetKeyName(event->key.keysym.sym));
+        break;
+    case SDL_TEXTINPUT:
+        fprintf(stderr, "Keyboard %d: text input \"%s\" in window %d",
+                event->text.which, event->text.text, event->text.windowID);
+        break;
+    case SDL_MOUSEMOTION:
+        fprintf(stderr, "Mouse %d: moved to %d,%d (%d,%d) in window %d",
+                event->motion.which, event->motion.x, event->motion.y,
+                event->motion.xrel, event->motion.yrel,
+                event->motion.windowID);
+        break;
+    case SDL_MOUSEBUTTONDOWN:
+        fprintf(stderr, "Mouse %d: button %d pressed at %d,%d in window %d",
+                event->button.which, event->button.button, event->button.x,
+                event->button.y, event->button.windowID);
+        break;
+    case SDL_MOUSEBUTTONUP:
+        fprintf(stderr, "Mouse %d: button %d released at %d,%d in window %d",
+                event->button.which, event->button.button, event->button.x,
+                event->button.y, event->button.windowID);
+        break;
+    case SDL_MOUSEWHEEL:
+        fprintf(stderr,
+                "Mouse %d: wheel scrolled %d in x and %d in y in window %d",
+                event->wheel.which, event->wheel.x, event->wheel.y,
+                event->wheel.windowID);
+        break;
+    case SDL_JOYBALLMOTION:
+        fprintf(stderr, "Joystick %d: ball %d moved by %d,%d",
+                event->jball.which, event->jball.ball, event->jball.xrel,
+                event->jball.yrel);
+        break;
+    case SDL_JOYHATMOTION:
+        fprintf(stderr, "Joystick %d: hat %d moved to ", event->jhat.which,
+                event->jhat.hat);
+        switch (event->jhat.value) {
+        case SDL_HAT_CENTERED:
+            fprintf(stderr, "CENTER");
+            break;
+        case SDL_HAT_UP:
+            fprintf(stderr, "UP");
+            break;
+        case SDL_HAT_RIGHTUP:
+            fprintf(stderr, "RIGHTUP");
+            break;
+        case SDL_HAT_RIGHT:
+            fprintf(stderr, "RIGHT");
+            break;
+        case SDL_HAT_RIGHTDOWN:
+            fprintf(stderr, "RIGHTDOWN");
+            break;
+        case SDL_HAT_DOWN:
+            fprintf(stderr, "DOWN");
+            break;
+        case SDL_HAT_LEFTDOWN:
+            fprintf(stderr, "LEFTDOWN");
+            break;
+        case SDL_HAT_LEFT:
+            fprintf(stderr, "LEFT");
+            break;
+        case SDL_HAT_LEFTUP:
+            fprintf(stderr, "LEFTUP");
+            break;
+        default:
+            fprintf(stderr, "UNKNOWN");
+            break;
+        }
+        break;
+    case SDL_JOYBUTTONDOWN:
+        fprintf(stderr, "Joystick %d: button %d pressed",
+                event->jbutton.which, event->jbutton.button);
+        break;
+    case SDL_JOYBUTTONUP:
+        fprintf(stderr, "Joystick %d: button %d released",
+                event->jbutton.which, event->jbutton.button);
+        break;
+    case SDL_QUIT:
+        fprintf(stderr, "Quit requested");
+        break;
+    case SDL_USEREVENT:
+        fprintf(stderr, "User event %d", event->user.code);
+        break;
+    default:
+        fprintf(stderr, "Unknown event %d", event->type);
+        break;
+    }
+    fprintf(stderr, "\n");
+}
+
+void
+CommonEvent(CommonState * state, SDL_Event * event, int *done)
+{
+    if (state->verbose & VERBOSE_EVENT) {
+        PrintEvent(event);
+    }
+
+    switch (event->type) {
+    case SDL_WINDOWEVENT:
+        switch (event->window.event) {
+        case SDL_WINDOWEVENT_CLOSE:
+            *done = 1;
+            break;
+        }
+        break;
+    case SDL_KEYDOWN:
+        switch (event->key.keysym.sym) {
+            /* Add hotkeys here */
+        case SDLK_g:
+            if (event->key.keysym.mod & KMOD_CTRL) {
+                /* Ctrl-G toggle grab */
+            }
+            break;
+        case SDLK_ESCAPE:
+            *done = 1;
+            break;
+        default:
+            break;
+        }
+        break;
+    case SDL_QUIT:
+        *done = 1;
+        break;
+    }
+}
+
+void
+CommonQuit(CommonState * state)
+{
+    if (state->flags & SDL_INIT_VIDEO) {
+        SDL_VideoQuit();
+    }
+    if (state->flags & SDL_INIT_AUDIO) {
+        SDL_AudioQuit();
+    }
+    if (state->windows) {
+        SDL_free(state->windows);
+    }
+    SDL_free(state);
+}
diff -r dd25eabe441c -r 204be4fc2726 test/nds-test-progs/sprite2/source/common.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/nds-test-progs/sprite2/source/common.h	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,48 @@
+
+/* A simple test program framework */
+
+#include <SDL/SDL.h>
+
+#define VERBOSE_VIDEO   0x00000001
+#define VERBOSE_MODES   0x00000002
+#define VERBOSE_RENDER  0x00000004
+#define VERBOSE_EVENT   0x00000008
+#define VERBOSE_AUDIO   0x00000010
+
+typedef struct
+{
+    /* SDL init flags */
+    char **argv;
+    Uint32 flags;
+    Uint32 verbose;
+
+    /* Video info */
+    const char *videodriver;
+    int display;
+    const char *window_title;
+    Uint32 window_flags;
+    int window_x;
+    int window_y;
+    int window_w;
+    int window_h;
+    int depth;
+    int refresh_rate;
+    int num_windows;
+    SDL_WindowID *windows;
+
+    /* Renderer info */
+    const char *renderdriver;
+    Uint32 render_flags;
+    SDL_bool skip_renderer;
+
+    /* Audio info */
+    const char *audiodriver;
+    SDL_AudioSpec audiospec;
+} CommonState;
+
+extern CommonState *CommonCreateState(char **argv, Uint32 flags);
+extern int CommonArg(CommonState * state, int index);
+extern const char *CommonUsage(CommonState * state);
+extern SDL_bool CommonInit(CommonState * state);
+extern void CommonEvent(CommonState * state, SDL_Event * event, int *done);
+extern void CommonQuit(CommonState * state);
diff -r dd25eabe441c -r 204be4fc2726 test/nds-test-progs/sprite2/source/testsprite2.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/nds-test-progs/sprite2/source/testsprite2.c	Wed Aug 27 15:10:03 2008 +0000
@@ -0,0 +1,330 @@
+/* Simple program:  Move N sprites around on the screen as fast as possible */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include <nds.h>
+#include <fat.h>
+#include "common.h"
+
+#include "icon_bmp_bin.h"
+
+#define NUM_SPRITES	10
+#define MAX_SPEED 	1
+
+static CommonState *state;
+static int num_sprites;
+static SDL_TextureID *sprites;
+static SDL_bool cycle_color;
+static SDL_bool cycle_alpha;
+static int cycle_direction = 1;
+static int current_alpha = 0;
+static int current_color = 0;
+static SDL_Rect *positions;
+static SDL_Rect *velocities;
+static int sprite_w, sprite_h;
+static SDL_TextureBlendMode blendMode = SDL_TEXTUREBLENDMODE_MASK;
+static SDL_TextureScaleMode scaleMode = SDL_TEXTURESCALEMODE_NONE;
+
+/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
+static void
+quit(int rc)
+{
+    if (sprites) {
+        SDL_free(sprites);
+    }
+    if (positions) {
+        SDL_free(positions);
+    }
+    if (velocities) {
+        SDL_free(velocities);
+    }
+    CommonQuit(state);
+    exit(rc);
+}
+
+int
+LoadSprite(char *file)
+{
+    int i;
+    SDL_Surface *temp;
+
+    /* Load the sprite image */
+    temp = SDL_LoadBMP(file);
+    if (temp == NULL) {
+        fprintf(stderr, "Couldn't load %s: %s", file, SDL_GetError());
+        return (-1);
+    }
+    sprite_w = temp->w;
+    sprite_h = temp->h;
+
+    /* Set transparent pixel as the pixel at (0,0) */
+    if (temp->format->palette) {
+        SDL_SetColorKey(temp, SDL_SRCCOLORKEY, *(Uint8 *) temp->pixels);
+    }
+
+    /* Create textures from the image */
+    for (i = 0; i < state->num_windows; ++i) {
+        SDL_SelectRenderer(state->windows[i]);
+        sprites[i] = SDL_CreateTextureFromSurface(0, temp);
+        if (!sprites[i]) {
+            fprintf(stderr, "Couldn't create texture: %s\n", SDL_GetError());
+            SDL_FreeSurface(temp);
+            return (-1);
+        }
+        SDL_SetTextureBlendMode(sprites[i], blendMode);
+        SDL_SetTextureScaleMode(sprites[i], scaleMode);
+    }
+    SDL_FreeSurface(temp);
+
+    /* We're ready to roll. :) */
+    return (0);
+}
+
+int
+LoadSprite2(const u8 * ptr, int size)
+{
+    int i;
+    SDL_Rect r = { 0, 0, 32, 32 };
+    for (i = 0; i < state->num_windows; ++i) {
+        SDL_SelectRenderer(state->windows[i]);
+        sprites[i] = SDL_CreateTexture(SDL_PIXELFORMAT_ABGR1555,
+                                       SDL_TEXTUREACCESS_STATIC, r.w, r.h);
+        if (!sprites[i]) {
+            fprintf(stderr, "Couldn't create texture: %s\n", SDL_GetError());
+            return -1;
+        }
+        SDL_UpdateTexture(sprites[i], &r, ptr, r.w * 2);
+        SDL_SetTextureBlendMode(sprites[i], blendMode);
+        SDL_SetTextureScaleMode(sprites[i], scaleMode);
+    }
+    return 0;
+}
+
+void
+MoveSprites(SDL_WindowID window, SDL_TextureID sprite)
+{
+    int i, n;
+    int window_w, window_h;
+    SDL_Rect area, *position, *velocity;
+
+    SDL_SelectRenderer(window);
+
+    /* Query the sizes */
+    SDL_GetWindowSize(window, &window_w, &window_h);
+
+    /* Cycle the color and alpha, if desired */
+    if (cycle_color) {
+        current_color += cycle_direction;
+        if (current_color < 0) {
+            current_color = 0;
+            cycle_direction = -cycle_direction;
+        }
+        if (current_color > 255) {
+            current_color = 255;
+            cycle_direction = -cycle_direction;
+        }
+        SDL_SetTextureColorMod(sprite, 255, (Uint8) current_color,
+                               (Uint8) current_color);
+    }
+    if (cycle_alpha) {
+        current_alpha += cycle_direction;
+        if (current_alpha < 0) {
+            current_alpha = 0;
+            cycle_direction = -cycle_direction;
+        }
+        if (current_alpha > 255) {
+            current_alpha = 255;
+            cycle_direction = -cycle_direction;
+        }
+        SDL_SetTextureAlphaMod(sprite, (Uint8) current_alpha);
+    }
+
+    /* Move the sprite, bounce at the wall, and draw */
+    n = 0;
+    SDL_RenderFill(0xA0, 0xA0, 0xA0, 0xFF, NULL);
+    for (i = 0; i < num_sprites; ++i) {
+        position = &positions[i];
+        velocity = &velocities[i];
+        position->x += velocity->x;
+        if ((position->x < 0) || (position->x >= (window_w - sprite_w))) {
+            velocity->x = -velocity->x;
+            position->x += velocity->x;
+        }
+        position->y += velocity->y;
+        if ((position->y < 0) || (position->y >= (window_h - sprite_w))) {
+            velocity->y = -velocity->y;
+            position->y += velocity->y;
+        }
+
+        /* Blit the sprite onto the screen */
+        SDL_RenderCopy(sprite, NULL, position);
+    }
+
+    /* Update the screen! */
+    SDL_RenderPresent();
+}
+
+int
+main(int argc, char *argv[])
+{
+    int i, done;
+    SDL_Event event;
+    Uint32 then, now, frames;
+
+    consoleDemoInit();
+    puts("Hello world!  Initializing FAT...");
+    fatInitDefault();
+
+    /* Initialize parameters */
+    num_sprites = NUM_SPRITES;
+
+    /* Initialize test framework */
+    state = CommonCreateState(argv, SDL_INIT_VIDEO);
+    if (!state) {
+        return 1;
+    }
+    for (i = 1; i < argc;) {
+        int consumed;
+
+        consumed = CommonArg(state, i);
+        if (consumed == 0) {
+            consumed = -1;
+            if (SDL_strcasecmp(argv[i], "--blend") == 0) {
+                if (argv[i + 1]) {
+                    if (SDL_strcasecmp(argv[i + 1], "none") == 0) {
+                        blendMode = SDL_TEXTUREBLENDMODE_NONE;
+                        consumed = 2;
+                    } else if (SDL_strcasecmp(argv[i + 1], "mask") == 0) {
+                        blendMode = SDL_TEXTUREBLENDMODE_MASK;
+                        consumed = 2;
+                    } else if (SDL_strcasecmp(argv[i + 1], "blend") == 0) {
+                        blendMode = SDL_TEXTUREBLENDMODE_BLEND;
+                        consumed = 2;
+                    } else if (SDL_strcasecmp(argv[i + 1], "add") == 0) {
+                        blendMode = SDL_TEXTUREBLENDMODE_ADD;
+                        consumed = 2;
+                    } else if (SDL_strcasecmp(argv[i + 1], "mod") == 0) {
+                        blendMode = SDL_TEXTUREBLENDMODE_MOD;
+                        consumed = 2;
+                    }
+                }
+            } else if (SDL_strcasecmp(argv[i], "--scale") == 0) {
+                if (argv[i + 1]) {
+                    if (SDL_strcasecmp(argv[i + 1], "none") == 0) {
+                        scaleMode = SDL_TEXTURESCALEMODE_NONE;
+                        consumed = 2;
+                    } else if (SDL_strcasecmp(argv[i + 1], "fast") == 0) {
+                        scaleMode = SDL_TEXTURESCALEMODE_FAST;
+                        consumed = 2;
+                    } else if (SDL_strcasecmp(argv[i + 1], "slow") == 0) {
+                        scaleMode = SDL_TEXTURESCALEMODE_SLOW;
+                        consumed = 2;
+                    } else if (SDL_strcasecmp(argv[i + 1], "best") == 0) {
+                        scaleMode = SDL_TEXTURESCALEMODE_BEST;
+                        consumed = 2;
+                    }
+                }
+            } else if (SDL_strcasecmp(argv[i], "--cyclecolor") == 0) {
+                cycle_color = SDL_TRUE;
+                consumed = 1;
+            } else if (SDL_strcasecmp(argv[i], "--cyclealpha") == 0) {
+                cycle_alpha = SDL_TRUE;
+                consumed = 1;
+            } else if (SDL_isdigit(*argv[i])) {
+                num_sprites = SDL_atoi(argv[i]);
+                consumed = 1;
+            }
+        }
+        if (consumed < 0) {
+            fprintf(stderr,
+                    "Usage: %s %s [--blend none|mask|blend|add|mod] [--scale none|fast|slow|best] [--cyclecolor] [--cyclealpha]\n",
+                    argv[0], CommonUsage(state));
+            quit(1);
+        }
+        i += consumed;
+    }
+    if (!CommonInit(state)) {
+        quit(2);
+    }
+
+    /* Create the windows, initialize the renderers, and load the textures */
+    sprites =
+        (SDL_TextureID *) SDL_malloc(state->num_windows * sizeof(*sprites));
+    if (!sprites) {
+        fprintf(stderr, "Out of memory!\n");
+        quit(2);
+    }
+    for (i = 0; i < state->num_windows; ++i) {
+        SDL_SelectRenderer(state->windows[i]);
+        SDL_RenderFill(0xA0, 0xA0, 0xA0, 0xFF, NULL);
+    }
+    if (LoadSprite2(icon_bmp_bin, icon_bmp_bin_size) < 0) {
+        printf("errored.\n");
+        quit(2);
+    }
+
+    /* Allocate memory for the sprite info */
+    positions = (SDL_Rect *) SDL_malloc(num_sprites * sizeof(SDL_Rect));
+    velocities = (SDL_Rect *) SDL_malloc(num_sprites * sizeof(SDL_Rect));
+    if (!positions || !velocities) {
+        fprintf(stderr, "Out of memory!\n");
+        quit(2);
+    }
+    srand(time(NULL));
+    if (scaleMode != SDL_TEXTURESCALEMODE_NONE) {
+        sprite_w += sprite_w / 2;
+        sprite_h += sprite_h / 2;
+    }
+    for (i = 0; i < num_sprites; ++i) {
+        positions[i].x = rand() % (state->window_w - sprite_w);
+        positions[i].y = rand() % (state->window_h - sprite_h);
+        positions[i].w = sprite_w;
+        positions[i].h = sprite_h;
+        velocities[i].x = 0;
+        velocities[i].y = 0;
+        while (!velocities[i].x && !velocities[i].y) {
+            velocities[i].x = (rand() % (MAX_SPEED * 2 + 1)) - MAX_SPEED;
+            velocities[i].y = (rand() % (MAX_SPEED * 2 + 1)) - MAX_SPEED;
+        }
+    }
+
+    /* Main render loop */
+    frames = 0;
+    then = SDL_GetTicks();
+    done = 0;
+    while (!done) {
+        /* Check for events */
+        ++frames;
+        while (SDL_PollEvent(&event)) {
+            CommonEvent(state, &event, &done);
+            switch (event.type) {
+            case SDL_WINDOWEVENT:
+                switch (event.window.event) {
+                case SDL_WINDOWEVENT_EXPOSED:
+                    SDL_SelectRenderer(event.window.windowID);
+                    SDL_RenderFill(0xA0, 0xA0, 0xA0, 0xFF, NULL);
+                    break;
+                }
+                break;
+            default:
+                break;
+            }
+        }
+        for (i = 0; i < state->num_windows; ++i) {
+            MoveSprites(state->windows[i], sprites[i]);
+        }
+    }
+
+    /* Print out some timing information */
+    now = SDL_GetTicks();
+    if (now > then) {
+        printf("%2.2f frames per second\n",
+               ((double) frames * 1000) / (now - then));
+    }
+
+    quit(0);
+    return 0;
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
diff -r dd25eabe441c -r 204be4fc2726 test/testblitspeed.c
--- a/test/testblitspeed.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/test/testblitspeed.c	Wed Aug 27 15:10:03 2008 +0000
@@ -397,8 +397,7 @@
         }
 
         now = SDL_GetTicks();
-    }
-    while (now < end);
+    } while (now < end);
 
     printf("Non-blitting crap accounted for %d percent of this run.\n",
            percent(testms - elasped, testms));
diff -r dd25eabe441c -r 204be4fc2726 test/testdyngl.c
--- a/test/testdyngl.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/test/testdyngl.c	Wed Aug 27 15:10:03 2008 +0000
@@ -185,8 +185,7 @@
         }
 
         SDL_Delay(20);
-    }
-    while (!done);
+    } while (!done);
 
     SDL_Quit();
     return 0;
diff -r dd25eabe441c -r 204be4fc2726 test/testpalette.c
--- a/test/testpalette.c	Wed Aug 27 13:37:19 2008 +0000
+++ b/test/testpalette.c	Wed Aug 27 15:10:03 2008 +0000
@@ -338,8 +338,7 @@
         /* update changed areas of the screen */
         SDL_UpdateRects(screen, NBOATS, updates);
         frames++;
-    }
-    while (fade_level > 0);
+    } while (fade_level > 0);
 
     printf("%d frames, %.2f fps\n",
            frames, 1000.0 * frames / (SDL_GetTicks() - start));