Script Library: sdl-h.r

Script Library: 1247 scripts
sdl-h.r

REBOL [
    title: "SDL library interface"
    file: %sdl-h.r
    author: "Marco Antoniazzi"
    email: [luce80 AT libero DOT it]
    date: 10-08-2012
    version: 0.8.1
    needs: {
        - SDL shared library version 1.12 or newer in the same directory (or adjust first lines)
        - a CD in the CD tray to run the example
    }
    comment: {ONLY A FEW FUNCTIONs TESTED !!!! Use example code to test others.
        See REBOL-NOTEs in example code at the start and end for rebol-specific implementation issues.
        Some of the SDL functions and structures need callback functions pointers that sadly Rebol can't handle.
    }
    Purpose: "Code to bind SDL shared library to Rebol."
    History: [
        0.0.1 [06-11-2011 "First version"]
        0.8.0 [12-11-2011 "Example completed"]
        0.8.1 [10-08-2012 "Minor changes and fixes"]
    ]
    Category: [library music sound graphics]
    library: [
        level: 'intermediate
        platform: 'all
        type: 'module
        domain: [sound graphics external-library]
        tested-under: [View 2.7.8.3.1 2.7.8.4.3]
        support: none
        license: none
        see-also: none
    ]
]

    ;;;
    ;;;REBOL-NOTE: use this function to access pointers
    ;;;
    int-ptr: does [make struct! [value [integer!]] none]
    
    ;;;
    ;;;REBOL-NOTE: use this function to map data to a struct!
    ;;;
    addr-to-struct: func [
        "returns the given struct! initialized with content of given address"
        addr [integer!] struct [struct!] /local int-ptr tstruct
        ][
        int-ptr: make struct! [value [integer!]] reduce [addr]
        tstruct: make struct! compose/deep/only [ptr [struct! (first struct)]] none
        change third tstruct third int-ptr
        change third struct third tstruct/ptr
        struct
    ]

    lib: switch/default System/version/4 [
        2 [%libSDL-1.2.dylib]   ;OSX
        3 [%SDL.dll]    ;Windows
    ] [%libSDL-1.2.so.0]

    if not SDL-lib: load/library lib [alert "SDL library not found. Quit" quit]

{
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2009 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--libsdl--org
}

{*
 *  @file SDL_endian.h
 *  Functions for reading and writing endian-specific values
 }
{* @name SDL_ENDIANs
 *  The two types of endianness 
 }
SDL_LIL_ENDIAN: 1234
SDL_BIG_ENDIAN: 4321

SDL_BYTEORDER: does [either 'little = get-modes system:// 'endian [SDL_LIL_ENDIAN][SDL_BIG_ENDIAN]]

{* @name SDL_INIT Flags
 *  These are the flags which may be passed to SDL_Init() -- you should
 *  specify the subsystems which you will be using in your application.
 }
SDL_INIT_TIMER:     1
SDL_INIT_AUDIO:     16
SDL_INIT_VIDEO:     32
SDL_INIT_CDROM:     256
SDL_INIT_JOYSTICK:  512
SDL_INIT_NOPARACHUTE:   1048576 {*< Don't catch fatal signals }
SDL_INIT_EVENTTHREAD:   16777216    {*< Not supported on all OS's }
SDL_INIT_EVERYTHING:    65535

{* This function loads the SDL dynamically linked library and initializes 
 *  the subsystems specified by 'flags' (and those satisfying dependencies)
 *  Unless the SDL_INIT_NOPARACHUTE flag is set, it will install cleanup
 *  signal handlers for some commonly ignored fatal signals (like SIGSEGV)
 }
SDL_Init: make routine! [ flags [integer!] return: [integer!] ] SDL-lib "SDL_Init" 

 {* This function initializes specific SDL subsystems }
SDL_InitSubSystem: make routine! [ flags [integer!] return: [integer!] ] SDL-lib "SDL_InitSubSystem" 

 {* This function cleans up specific SDL subsystems }
SDL_QuitSubSystem: make routine! [ flags [integer!] return: [integer!] ] SDL-lib "SDL_QuitSubSystem" 

 {* This function returns mask of the specified subsystems which have
 *  been initialized.
 *  If 'flags' is 0, it returns a mask of all initialized subsystems.
 }
SDL_WasInit: make routine! [ flags [integer!] return: [integer!] ] SDL-lib "SDL_WasInit" 

 {* This function cleans up all initialized subsystems and unloads the
 *  dynamically linked library.  You should call it upon all exit conditions.
 }
SDL_Quit: make routine! [return: [integer!] ] SDL-lib "SDL_Quit" 

{*
 *  @file SDL_active.h
 *  Include file for SDL application focus event handling 
 }

{* @name The available application states }

SDL_APPMOUSEFOCUS:  1       {*< The app has mouse coverage }
SDL_APPINPUTFOCUS:  2       {*< The app has input focus }
SDL_APPACTIVE:      4       {*< The application is active }


{* 
 * This function returns the current state of the application, which is a
 * bitwise combination of SDL_APPMOUSEFOCUS, SDL_APPINPUTFOCUS, and
 * SDL_APPACTIVE.  If SDL_APPACTIVE is set, then the user is able to
 * see your application, otherwise it has been iconified or disabled.
 }
SDL_GetAppState: make routine! [ a [integer!] return: [char!] ] SDL-lib "SDL_GetAppState" 

{*
 *  @file SDL_audio.h
 *  Access to the raw audio mixing buffer for the SDL library
 }

{*
 * When filling in the desired audio spec structure,
 * - 'desired->freq' should be the desired audio frequency in samples-per-second.
 * - 'desired->format' should be the desired audio format.
 * - 'desired->samples' is the desired size of the audio buffer, in samples.
 *     This number should be a power of two, and may be adjusted by the audio
 *     driver to a value more suitable for the hardware.  Good values seem to
 *     range between 512 and 8096 inclusive, depending on the application and
 *     CPU speed.  Smaller values yield faster response time, but can lead
 *     to underflow if the application is doing heavy processing and cannot
 *     fill the audio buffer in time.  A stereo sample consists of both right
 *     and left channels in LR ordering.
 *     Note that the number of samples is directly related to time by the
 *     following formula:  ms = (samples*1000)/freq
 * - 'desired->size' is the size in bytes of the audio buffer, and is
 *     calculated by SDL_OpenAudio().
 * - 'desired->silence' is the value used to set the buffer to silence,
 *     and is calculated by SDL_OpenAudio().
 * - 'desired->callback' should be set to a function that will be called
 *     when the audio device is ready for more data.  It is passed a pointer
 *     to the audio buffer, and the length in bytes of the audio buffer.
 *     This function usually runs in a separate thread, and so you should
 *     protect data structures that it accesses by calling SDL_LockAudio()
 *     and SDL_UnlockAudio() in your code.
 * - 'desired->userdata' is passed as the first parameter to your callback
 *     function.
 *
 * @note The calculated values in this structure are calculated by SDL_OpenAudio()
 *
 }
SDL_AudioSpec: make struct! [
  freq [integer!] {*< DSP frequency -- samples per second }
  format [short] {*< Audio data format }
  channels [char!] {*< Number of channels: 1 mono, 2 stereo }
  silence [char!] {*< Audio buffer silence value (calculated) }
  samples [short] {*< Audio buffer size in samples (power of 2) }
  padding [short] {*< Necessary for some compile environments }
  size [integer!] {*< Audio buffer size in bytes (calculated) }
 {*
     *  This function is called when the audio device needs more data.
     *
     *  @param[out] stream  A pointer to the audio data buffer
     *  @param[in]  len The length of the audio buffer in bytes.
     *
     *  Once the callback returns, the buffer will no longer be valid.
     *  Stereo samples are stored in a LRLRLR ordering.
     }
  callback [integer!]
  userdata [integer!]
] none ;

{*
 *  @name Audio format flags
 *  defaults to LSB byte order
 }

AUDIO_U8:   8   {*< Unsigned 8-bit samples }
AUDIO_S8:   32776   {*< Signed 8-bit samples }
AUDIO_U16LSB:   16  {*< Unsigned 16-bit samples }
AUDIO_S16LSB:   32784   {*< Signed 16-bit samples }
AUDIO_U16MSB:   4112    {*< As above, but big-endian byte order }
AUDIO_S16MSB:   36880   {*< As above, but big-endian byte order }
AUDIO_U16:  AUDIO_U16LSB
AUDIO_S16:  AUDIO_S16LSB

{*
 *  @name Native audio byte ordering
 }
either SDL_BYTEORDER = SDL_LIL_ENDIAN [
AUDIO_U16SYS:   AUDIO_U16LSB
AUDIO_S16SYS:   AUDIO_S16LSB
][
AUDIO_U16SYS:   AUDIO_U16MSB
AUDIO_S16SYS:   AUDIO_S16MSB
]

{* A structure to hold a set of audio conversion filters and buffers }
SDL_AudioCVT_: SDL_AudioCVT: make struct! [
  needed [integer!] {*< Set to 1 if conversion possible }
  src_format [short] {*< Source audio format }
  dst_format [short] {*< Target audio format }
  rate_incr [double] {*< Rate conversion increment }
  buf [integer!] {*< Buffer to hold entire audio data }
  len [integer!] {*< Length of original audio buffer }
  len_cvt [integer!] {*< Length of converted audio buffer }
  len_mult [integer!] {*< buffer must be len*len_mult big }
  len_ratio [double] {*< Given len, final size is len*len_ratio }
  filters [integer!] {void (SDLCALL *filters[10])(struct SDL_AudioCVT *cvt, Uint16 format);}
  filter_index [integer!] {*< Current audio conversion function }
] none ;

{*
 * @name Audio Init and Quit
 * These functions are used internally, and should not be used unless you
 * have a specific need to specify the audio driver you want to use.
 * You should normally use SDL_Init() or SDL_InitSubSystem().
 }
SDL_AudioInit: make routine! [ driver_name [string!] return: [integer!] ] SDL-lib "SDL_AudioInit" 
SDL_AudioQuit: make routine! [ return: [integer!] ] SDL-lib "SDL_AudioQuit" 

{*
 * This function fills the given character buffer with the name of the
 * current audio driver, and returns a pointer to it if the audio driver has
 * been initialized.  It returns NULL if no driver has been initialized.
 }
SDL_AudioDriverName: make routine! [ namebuf [string!] maxlen [integer!] return: [string!] ] SDL-lib "SDL_AudioDriverName" 

 {*
 * This function opens the audio device with the desired parameters, and
 * returns 0 if successful, placing the actual hardware parameters in the
 * structure pointed to by 'obtained'.  If 'obtained' is NULL, the audio
 * data passed to the callback function will be guaranteed to be in the
 * requested format, and will be automatically converted to the hardware
 * audio format if necessary.  This function returns -1 if it failed 
 * to open the audio device, or couldn't set up the audio thread.
 *
 * The audio device starts out playing silence when it's opened, and should
 * be enabled for playing by calling SDL_PauseAudio(0) when you are ready
 * for your audio callback function to be called.  Since the audio driver
 * may modify the requested size of the audio buffer, you should allocate
 * any local mixing buffers after you open the audio device.
 *
 * @sa SDL_AudioSpec
 }
SDL_OpenAudio: make routine! [ desired [struct! []] obtained [integer!] return: [integer!] ] SDL-lib "SDL_OpenAudio" 

SDL_AUDIO_STOPPED: 0
SDL_AUDIO_PLAYING: 1
SDL_AUDIO_PAUSED: 2

SDL_audiostatus: integer!;

{* Get the current audio state }
SDL_GetAudioStatus: make routine! [ return: [SDL_audiostatus] ] SDL-lib "SDL_GetAudioStatus" 

{*
 * This function pauses and unpauses the audio callback processing.
 * It should be called with a parameter of 0 after opening the audio
 * device to start playing sound.  This is so you can safely initialize
 * data for your callback function after opening the audio device.
 * Silence will be written to the audio device during the pause.
 }
SDL_PauseAudio: make routine! [ pause_on [integer!] return: [integer!] ] SDL-lib "SDL_PauseAudio" 

 {*
 * This function loads a WAVE from the data source, automatically freeing
 * that source if 'freesrc' is non-zero.  For example, to load a WAVE file,
 * you could do:
 *  @code SDL_LoadWAV_RW(SDL_RWFromFile("sample.wav", "rb"), 1, ...); @endcode
 *
 * If this function succeeds, it returns the given SDL_AudioSpec,
 * filled with the audio data format of the wave data, and sets
 * 'audio_buf' to a malloc()'d buffer containing the audio data,
 * and sets 'audio_len' to the length of that audio buffer, in bytes.
 * You need to free the audio buffer with SDL_FreeWAV() when you are 
 * done with it.
 *
 * This function returns NULL and sets the SDL error message if the 
 * wave file cannot be opened, uses an unknown data format, or is 
 * corrupt.  Currently raw and MS-ADPCM WAVE files are supported.
 }
SDL_LoadWAV_RW: make routine! [ src [integer!] freesrc [integer!] spec [struct! []] audio_buf [struct! []] audio_len [struct! []] return: [integer!] ] SDL-lib "SDL_LoadWAV_RW" 

{* Compatibility convenience function -- loads a WAV from a file }
SDL_LoadWAV: func [file  spec  audio_buf  audio_len] [
    SDL_LoadWAV_RW SDL_RWFromFile file "rb" 1 spec audio_buf audio_len
]

{*
 * This function frees data previously allocated with SDL_LoadWAV_RW()
 }
SDL_FreeWAV: make routine! [ audio_buf [integer!] return: [integer!] ] SDL-lib "SDL_FreeWAV" 

 {*
 * This function takes a source format and rate and a destination format
 * and rate, and initializes the 'cvt' structure with information needed
 * by SDL_ConvertAudio() to convert a buffer of audio data from one format
 * to the other.
 *
 * @return This function returns 0, or -1 if there was an error.
 }
SDL_BuildAudioCVT: make routine! [ cvt [integer!]
 src_format [short] src_channels [char!] src_rate [integer!]
 dst_format [short] dst_channels [char!] dst_rate [integer!] return: [integer!] ] SDL-lib "SDL_BuildAudioCVT" 

 {*
 * Once you have initialized the 'cvt' structure using SDL_BuildAudioCVT(),
 * created an audio buffer cvt->buf, and filled it with cvt->len bytes of
 * audio data in the source format, this function will convert it in-place
 * to the desired format.
 * The data conversion may expand the size of the audio data, so the buffer
 * cvt->buf should be allocated after the cvt structure is initialized by
 * SDL_BuildAudioCVT(), and should be cvt->len*cvt->len_mult bytes long.
 }
SDL_ConvertAudio: make routine! [ cvt [integer!] return: [integer!] ] SDL-lib "SDL_ConvertAudio" 

SDL_MIX_MAXVOLUME: 128
{*
 * This takes two audio buffers of the playing audio format and mixes
 * them, performing addition, volume adjustment, and overflow clipping.
 * The volume ranges from 0 - 128, and should be set to SDL_MIX_MAXVOLUME
 * for full audio volume.  Note this does not change hardware volume.
 * This is provided for convenience -- you can mix your own audio data.
 }
SDL_MixAudio: make routine! [ dst [integer!] src [integer!] len [integer!] volume [integer!] return: [integer!] ] SDL-lib "SDL_MixAudio" 

 {*
 * @name Audio Locks
 * The lock manipulated by these functions protects the callback function.
 * During a LockAudio/UnlockAudio pair, you can be guaranteed that the
 * callback function is not running.  Do not call these from the callback
 * function or you will cause deadlock.
 }
 
SDL_LockAudio: make routine! [ return: [integer!] ] SDL-lib "SDL_LockAudio" 
SDL_UnlockAudio: make routine! [ return: [integer!] ] SDL-lib "SDL_UnlockAudio" 

{*
 * This function shuts down audio processing and closes the audio device.
 }
SDL_CloseAudio: make routine! [ return: [integer!] ] SDL-lib "SDL_CloseAudio" 

{*
 *  @file SDL_cdrom.h
 *  This is the CD-audio control API for Simple DirectMedia Layer
 }
{*
 *  @file SDL_cdrom.h
 *  In order to use these functions, SDL_Init() must have been called
 *  with the SDL_INIT_CDROM flag.  This causes SDL to scan the system
 *  for CD-ROM drives, and load appropriate drivers.
 }

{* The maximum number of CD-ROM tracks on a disk }
SDL_MAX_TRACKS: 99

{* @name Track Types
 *  The types of CD-ROM track possible
 }
SDL_AUDIO_TRACK:    0
SDL_DATA_TRACK: 4

{* The possible states which a CD-ROM drive can be in. }
CD_TRAYEMPTY: 0
CD_STOPPED: 1
CD_PLAYING: 2
CD_PAUSED: 3
CD_ERROR: -1

CDstatus: integer!;

{* Given a status, returns true if there's a disk in the drive }
CD_INDRIVE: func [status] [ status > 0 ]

SDL_CDtrack: make struct! [
  id [char!] {*< Track number }
  type [char!] {*< Data or audio track }
  unused [short] {}
  length [integer!] {*< Length, in frames, of this track }
  offset [integer!] {*< Offset, in frames, from start of disk }
] none ;

{* This structure is only current as of the last call to SDL_CDStatus() }
SDL_CD: make struct! [;[save]
  id [integer!] {*< Private drive identifier }
  status [CDstatus] {*< Current drive status}

 {* The rest of this structure is only valid if there's a CD in drive }
 
  numtracks [integer!] {*< Number of tracks on disk }
  cur_track [integer!] {*< Current track position }
  cur_frame [integer!] {*< Current frame offset within current track }
  ;tracks {[100]} ;REBOL-NOTE: see below
 
] none ;

SDL_CD-spec: copy first SDL_CD
use [trk n] [
    for n 0 (SDL_MAX_TRACKS + 1) 1 [
        trk: copy first SDL_CDtrack
        forskip trk 3 [
            change trk to-word rejoin ['track- n '- first trk]
        ]
        insert tail SDL_CD-spec trk
    ]
]
SDL_CD: make struct! SDL_CD-spec none

{REBOL-NOTE: use this func to access tracks' info. Usage: print cdrom/(track- i 'length) }
track-: func [i [integer!] memb [word!]] [to-word rejoin ['track- i '- memb]]

{* @name Frames / MSF Conversion Functions
 *  Conversion functions from frames to Minute/Second/Frames and vice versa
 }
CD_FPS: 75
FRAMES_TO_MSF: func [fr M [word!] S [word!] F [word!] /local value] [                   
    value: fr                           
    set F value // CD_FPS   
    value: value / CD_FPS                       
    set S value // 60                       
    value: to-integer value / 60                            
    set M value                         
]
MSF_TO_FRAMES: func [M  S  F]     [M * 60 * CD_FPS + S * CD_FPS + F]  

{ CD-audio API functions: }
{*
 *  Returns the number of CD-ROM drives on the system, or -1 if
 *  SDL_Init() has not been called with the SDL_INIT_CDROM flag.
 }
SDL_CDNumDrives: make routine! [ return: [integer!] ] SDL-lib "SDL_CDNumDrives" 

{*
 *  Returns a human-readable, system-dependent identifier for the CD-ROM.
 *  Example:
 *   - "/dev/cdrom"
 *   - "E:"
 *   - "/dev/disk/ide/1/master"
 }
SDL_CDName: make routine! [ drive [integer!] return: [string!] ] SDL-lib "SDL_CDName" 

{*
 *  Opens a CD-ROM drive for access.  It returns a drive handle on success,
 *  or NULL if the drive was invalid or busy.  This newly opened CD-ROM
 *  becomes the default CD used when other CD functions are passed a NULL
 *  CD-ROM handle.
 *  Drives are numbered starting with 0.  Drive 0 is the system default CD-ROM.
 }
SDL_CDOpen: make routine! [ drive [integer!] return: [integer!] ] SDL-lib "SDL_CDOpen" 

{*
 *  This function returns the current status of the given drive.
 *  If the drive has a CD in it, the table of contents of the CD and current
 *  play position of the CD will be stored in the SDL_CD structure.
 }
SDL_CDStatus: make routine! [ cdrom [integer!] return: [CDstatus] ] SDL-lib "SDL_CDStatus" 

 {*
 *  Play the given CD starting at 'start_track' and 'start_frame' for 'ntracks'
 *  tracks and 'nframes' frames.  If both 'ntrack' and 'nframe' are 0, play 
 *  until the end of the CD.  This function will skip data tracks.
 *  This function should only be called after calling SDL_CDStatus() to 
 *  get track information about the CD.
 *  For example:
 *      @code
 *  ; Play entire CD:
 *  if ( CD_INDRIVE(SDL_CDStatus(cdrom)) )
 *      SDL_CDPlayTracks(cdrom, 0, 0, 0, 0);
 *  ; Play last track:
 *  if ( CD_INDRIVE(SDL_CDStatus(cdrom)) ) {
 *      SDL_CDPlayTracks(cdrom, cdrom->numtracks-1, 0, 0, 0);
 *  }
 *  ; Play first and second track and 10 seconds of third track:
 *  if ( CD_INDRIVE(SDL_CDStatus(cdrom)) )
 *      SDL_CDPlayTracks(cdrom, 0, 0, 2, 10);
 *      @endcode
 *
 *  @return This function returns 0, or -1 if there was an error.
 }
SDL_CDPlayTracks: make routine! [ cdrom [integer!]
 start_track [integer!] start_frame [integer!] ntracks [integer!] nframes [integer!] return: [integer!] ] SDL-lib "SDL_CDPlayTracks" 

{*
 *  Play the given CD starting at 'start' frame for 'length' frames.
 *  @return It returns 0, or -1 if there was an error.
 }
SDL_CDPlay: make routine! [ cdrom [integer!] start [integer!] length [integer!] return: [integer!] ] SDL-lib "SDL_CDPlay" 

 {* Pause play
 *  @return returns 0, or -1 on error
 }
SDL_CDPause: make routine! [ cdrom [integer!] return: [integer!] ] SDL-lib "SDL_CDPause" 

 {* Resume play
 *  @return returns 0, or -1 on error
 }
SDL_CDResume: make routine! [ cdrom [integer!] return: [integer!] ] SDL-lib "SDL_CDResume" 

 {* Stop play
 *  @return returns 0, or -1 on error
 }
SDL_CDStop: make routine! [ cdrom [integer!] return: [integer!] ] SDL-lib "SDL_CDStop" 

 {* Eject CD-ROM
 *  @return returns 0, or -1 on error
 }
SDL_CDEject: make routine! [ cdrom [integer!] return: [integer!] ] SDL-lib "SDL_CDEject" 

 {* Closes the handle for the CD-ROM drive }
SDL_CDClose: make routine! [ cdrom [integer!] return: [integer!] ] SDL-lib "SDL_CDClose" 

SDL_HAS_64BIT_TYPE: 1

{ Enable various audio drivers }
{ #undef SDL_AUDIO_DRIVER_ALSA }
{ #undef SDL_AUDIO_DRIVER_ALSA_DYNAMIC }
{ #undef SDL_AUDIO_DRIVER_ARTS }
{ #undef SDL_AUDIO_DRIVER_ARTS_DYNAMIC }
{ #undef SDL_AUDIO_DRIVER_BAUDIO }
{ #undef SDL_AUDIO_DRIVER_BSD }
{ #undef SDL_AUDIO_DRIVER_COREAUDIO }
{ #undef SDL_AUDIO_DRIVER_DART }
{ #undef SDL_AUDIO_DRIVER_DC }
SDL_AUDIO_DRIVER_DISK: 1
SDL_AUDIO_DRIVER_DUMMY: 1
{ #undef SDL_AUDIO_DRIVER_DMEDIA }
SDL_AUDIO_DRIVER_DSOUND: 1
{ #undef SDL_AUDIO_DRIVER_PULSE }
{ #undef SDL_AUDIO_DRIVER_PULSE_DYNAMIC }
{ #undef SDL_AUDIO_DRIVER_ESD }
{ #undef SDL_AUDIO_DRIVER_ESD_DYNAMIC }
{ #undef SDL_AUDIO_DRIVER_MINT }
{ #undef SDL_AUDIO_DRIVER_MMEAUDIO }
{ #undef SDL_AUDIO_DRIVER_NAS }
{ #undef SDL_AUDIO_DRIVER_NAS_DYNAMIC }
{ #undef SDL_AUDIO_DRIVER_OSS }
{ #undef SDL_AUDIO_DRIVER_OSS_SOUNDCARD_H }
{ #undef SDL_AUDIO_DRIVER_PAUD }
{ #undef SDL_AUDIO_DRIVER_QNXNTO }
{ #undef SDL_AUDIO_DRIVER_SNDMGR }
{ #undef SDL_AUDIO_DRIVER_SUNAUDIO }
SDL_AUDIO_DRIVER_WAVEOUT: 1

switch system/version/4 [
{ Enable various cdrom drivers }
{ #undef SDL_CDROM_AIX }
{ #undef SDL_CDROM_BEOS }
{ #undef SDL_CDROM_BSDI }
{ #undef SDL_CDROM_DC }
{ #undef SDL_CDROM_DUMMY }
{ #undef SDL_CDROM_FREEBSD }
{ #undef SDL_CDROM_LINUX }
{ #undef SDL_CDROM_MACOS }
 2 [SDL_CDROM_MACOSX: 1]
{ #undef SDL_CDROM_MINT }
{ #undef SDL_CDROM_OPENBSD }
{ #undef SDL_CDROM_OS2 }
{ #undef SDL_CDROM_OSF }
{ #undef SDL_CDROM_QNX }
 3 [SDL_CDROM_WIN32: 1]
]
switch system/version/4 [
{ Enable various input drivers }
{ #undef SDL_INPUT_LINUXEV }
{ #undef SDL_INPUT_TSLIB }
{ #undef SDL_JOYSTICK_BEOS }
{ #undef SDL_JOYSTICK_DC }
{ #undef SDL_JOYSTICK_DUMMY }
{ #undef SDL_JOYSTICK_IOKIT }
{ #undef SDL_JOYSTICK_LINUX }
 2 [SDL_JOYSTICK_MACOS: 1]
{ #undef SDL_JOYSTICK_MINT }
{ #undef SDL_JOYSTICK_OS2 }
{ #undef SDL_JOYSTICK_RISCOS }
 3 [SDL_JOYSTICK_WINMM: 1]
{ #undef SDL_JOYSTICK_USBHID }
{ #undef SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H }
]
switch system/version/4 [
{ Enable various shared object loading systems }
{ #undef SDL_LOADSO_BEOS }
{ #undef SDL_LOADSO_DLCOMPAT }
{ #undef SDL_LOADSO_DLOPEN }
{ #undef SDL_LOADSO_DUMMY }
{ #undef SDL_LOADSO_LDG }
 2 [SDL_LOADSO_MACOS: 1]
{ #undef SDL_LOADSO_OS2 }
 3 [SDL_LOADSO_WIN32: 1]
]
switch system/version/4 [
{ Enable various threading systems }
{ #undef SDL_THREAD_BEOS }
{ #undef SDL_THREAD_DC }
{ #undef SDL_THREAD_OS2 }
{ #undef SDL_THREAD_PTH }
{ #undef SDL_THREAD_PTHREAD }
{ #undef SDL_THREAD_PTHREAD_RECURSIVE_MUTEX }
{ #undef SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP }
{ #undef SDL_THREAD_SPROC }
 3 [SDL_THREAD_WIN32: 1]
]
switch system/version/4 [
{ Enable various timer systems }
{ #undef SDL_TIMER_BEOS }
{ #undef SDL_TIMER_DC }
{ #undef SDL_TIMER_DUMMY }
 2 [SDL_TIMER_MACOS: 1]
{ #undef SDL_TIMER_MINT }
{ #undef SDL_TIMER_OS2 }
{ #undef SDL_TIMER_RISCOS }
 4 [SDL_TIMER_UNIX: 1]
 3 [SDL_TIMER_WIN32: 1]
{ #undef SDL_TIMER_WINCE }
]
{ Enable various video drivers }
{ #undef SDL_VIDEO_DRIVER_AALIB }
{ #undef SDL_VIDEO_DRIVER_BWINDOW }
{ #undef SDL_VIDEO_DRIVER_CACA }
{ #undef SDL_VIDEO_DRIVER_DC }
SDL_VIDEO_DRIVER_DDRAW: 1
{ #undef SDL_VIDEO_DRIVER_DGA }
{ #undef SDL_VIDEO_DRIVER_DIRECTFB }
{ #undef SDL_VIDEO_DRIVER_DRAWSPROCKET }
SDL_VIDEO_DRIVER_DUMMY: 1
{ #undef SDL_VIDEO_DRIVER_FBCON }
{ #undef SDL_VIDEO_DRIVER_GAPI }
{ #undef SDL_VIDEO_DRIVER_GEM }
{ #undef SDL_VIDEO_DRIVER_GGI }
{ #undef SDL_VIDEO_DRIVER_IPOD }
{ #undef SDL_VIDEO_DRIVER_NANOX }
{ #undef SDL_VIDEO_DRIVER_OS2FS }
{ #undef SDL_VIDEO_DRIVER_PHOTON }
{ #undef SDL_VIDEO_DRIVER_PICOGUI }
{ #undef SDL_VIDEO_DRIVER_PS2GS }
{ #undef SDL_VIDEO_DRIVER_PS3 }
{ #undef SDL_VIDEO_DRIVER_QTOPIA }
{ #undef SDL_VIDEO_DRIVER_QUARTZ }
{ #undef SDL_VIDEO_DRIVER_RISCOS }
{ #undef SDL_VIDEO_DRIVER_SVGALIB }
{ #undef SDL_VIDEO_DRIVER_TOOLBOX }
{ #undef SDL_VIDEO_DRIVER_VGL }
SDL_VIDEO_DRIVER_WINDIB: 1
{ #undef SDL_VIDEO_DRIVER_WSCONS }
{ #undef SDL_VIDEO_DRIVER_X11 }
{ #undef SDL_VIDEO_DRIVER_X11_DGAMOUSE }
{ #undef SDL_VIDEO_DRIVER_X11_DYNAMIC }
{ #undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT }
{ #undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR }
{ #undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XRENDER }
{ #undef SDL_VIDEO_DRIVER_X11_VIDMODE }
{ #undef SDL_VIDEO_DRIVER_X11_XINERAMA }
{ #undef SDL_VIDEO_DRIVER_X11_XME }
{ #undef SDL_VIDEO_DRIVER_X11_XRANDR }
{ #undef SDL_VIDEO_DRIVER_X11_XV }
{ #undef SDL_VIDEO_DRIVER_XBIOS }

{ Enable OpenGL support }
SDL_VIDEO_OPENGL: 1
{ #undef SDL_VIDEO_OPENGL_GLX }
SDL_VIDEO_OPENGL_WGL: 1
{ #undef SDL_VIDEO_OPENGL_OSMESA }
{ #undef SDL_VIDEO_OPENGL_OSMESA_DYNAMIC }

{ Disable screensaver }
SDL_VIDEO_DISABLE_SCREENSAVER: 1

{ Enable assembly routines }
SDL_ASSEMBLY_ROUTINES: 1
SDL_HERMES_BLITTERS: 1
{ #undef SDL_ALTIVEC_BLITTERS }

{* This function returns true if the CPU has the RDTSC instruction }
SDL_HasRDTSC: make routine! [ return: [SDL_bool] ] SDL-lib "SDL_HasRDTSC" 

 {* This function returns true if the CPU has MMX features }
SDL_HasMMX: make routine! [ return: [SDL_bool] ] SDL-lib "SDL_HasMMX" 

 {* This function returns true if the CPU has MMX Ext. features }
SDL_HasMMXExt: make routine! [ return: [SDL_bool] ] SDL-lib "SDL_HasMMXExt" 

 {* This function returns true if the CPU has 3DNow features }
SDL_Has3DNow: make routine! [ return: [SDL_bool] ] SDL-lib "SDL_Has3DNow" 

 {* This function returns true if the CPU has 3DNow! Ext. features }
SDL_Has3DNowExt: make routine! [ return: [SDL_bool] ] SDL-lib "SDL_Has3DNowExt" 

 {* This function returns true if the CPU has SSE features }
SDL_HasSSE: make routine! [ return: [SDL_bool] ] SDL-lib "SDL_HasSSE" 

 {* This function returns true if the CPU has SSE2 features }
SDL_HasSSE2: make routine! [ return: [SDL_bool] ] SDL-lib "SDL_HasSSE2" 

 {* This function returns true if the CPU has AltiVec features }
SDL_HasAltiVec: make routine! [ return: [SDL_bool] ] SDL-lib "SDL_HasAltiVec" 

{*
 *  @name SDL_Swap Functions
 *  Use inline functions for compilers that support them, and static
 *  functions for those that do not.  Because these functions become
 *  static for compilers that do not support inline functions, this
 *  header should only be included in files that actually use them.
 }
SDL_Swap16: func [x] [
    (shift/left x 8) or (shift x 8)
]

SDL_Swap32: func [x] [
    ((shift/left x 24) or ((shift/left x 8) and 16711680) or ((shift x 8) and 65280) or (shift x 24))
]

either SDL_HAS_64BIT_TYPE > 0 [
 SDL_Swap64: func [x /local hi  lo] [

    { Separate into high and low 32-bit values and swap them }
    lo: x and -1
    x: shift x 32
    hi: x and -1
    x: SDL_Swap32 lo
    x: shift/left x 32
    x: x or SDL_Swap32 hi
 ]
] [

{ This is mainly to keep compilers from complaining in SDL code.
 * If there is no real 64-bit datatype, then compilers will complain about
 * the fake 64-bit datatype that SDL provides when it compiles user code.
 }
SDL_Swap64: func [X] [X]
]


{*
 *  @name SDL_SwapLE and SDL_SwapBE Functions
 *  Byteswap item from the specified endianness to the native endianness
 }

either SDL_BYTEORDER = SDL_LIL_ENDIAN [
SDL_SwapLE16: func [X] [X]
SDL_SwapLE32: func [X] [X]
SDL_SwapLE64: func [X] [X]
SDL_SwapBE16: func [X] [SDL_Swap16 X] 
SDL_SwapBE32: func [X] [SDL_Swap32 X] 
SDL_SwapBE64: func [X] [SDL_Swap64 X] 
][
SDL_SwapLE16: func [X] [SDL_Swap16 X] 
SDL_SwapLE32: func [X] [SDL_Swap32 X] 
SDL_SwapLE64: func [X] [SDL_Swap64 X] 
SDL_SwapBE16: func [X] [X]
SDL_SwapBE32: func [X] [X]
SDL_SwapBE64: func [X] [X]
]

{*
 *  @file SDL_error.h
 *  Simple error message routines for SDL
 }
{* 
 *  @name Public functions
 }
SDL_SetError: make routine! [ fmt [string!] return: [integer!] ] SDL-lib "SDL_SetError" {,...} 
SDL_GetError: make routine! [ return: [string!] ] SDL-lib "SDL_GetError" 
SDL_ClearError: make routine! [ return: [integer!] ] SDL-lib "SDL_ClearError" 

{*
 *  @name Private functions
 *  @internal Private error message function - used internally
 }
SDL_OutOfMemory: func [] [SDL_Error SDL_ENOMEM] 
SDL_Unsupported: func [] [SDL_Error SDL_UNSUPPORTED] 

SDL_ENOMEM: 0
SDL_EFREAD: 1
SDL_EFWRITE: 2
SDL_EFSEEK: 3
SDL_UNSUPPORTED: 4
SDL_LASTERROR: 5

SDL_errorcode: integer!

SDL_Error: make routine! [ code [SDL_errorcode] return: [integer!] ] SDL-lib "SDL_Error" 


{* What we really want is a mapping of every raw key on the keyboard.
 *  To support international keyboards, we use the range 161 - 255
 *  as international virtual keycodes.  We'll follow in the footsteps of X11...
 *  @brief The names of the keys
 }
 {* @name ASCII mapped keysyms
         *  The keyboard syms have been cleverly chosen to map to ASCII
         }
 
SDLK_UNKNOWN: 0
SDLK_FIRST: 0
SDLK_BACKSPACE: 8
SDLK_TAB: 9
SDLK_CLEAR: 12
SDLK_RETURN: 13
SDLK_PAUSE: 19
SDLK_ESCAPE: 27
SDLK_SPACE: 32
SDLK_EXCLAIM: 33
SDLK_QUOTEDBL: 34
SDLK_HASH: 35
SDLK_DOLLAR: 36
SDLK_AMPERSAND: 38
SDLK_QUOTE: 39
SDLK_LEFTPAREN: 40
SDLK_RIGHTPAREN: 41
SDLK_ASTERISK: 42
SDLK_PLUS: 43
SDLK_COMMA: 44
SDLK_MINUS: 45
SDLK_PERIOD: 46
SDLK_SLASH: 47
SDLK_0: 48
SDLK_1: 49
SDLK_2: 50
SDLK_3: 51
SDLK_4: 52
SDLK_5: 53
SDLK_6: 54
SDLK_7: 55
SDLK_8: 56
SDLK_9: 57
SDLK_COLON: 58
SDLK_SEMICOLON: 59
SDLK_LESS: 60
SDLK_EQUALS: 61
SDLK_GREATER: 62
SDLK_QUESTION: 63
SDLK_AT: 64
 { 
       Skip uppercase letters
     }
SDLK_LEFTBRACKET: 91
SDLK_BACKSLASH: 92
SDLK_RIGHTBRACKET: 93
SDLK_CARET: 94
SDLK_UNDERSCORE: 95
SDLK_BACKQUOTE: 96
SDLK_a: 97
SDLK_b: 98
SDLK_c: 99
SDLK_d: 100
SDLK_e: 101
SDLK_f: 102
SDLK_g: 103
SDLK_h: 104
SDLK_i: 105
SDLK_j: 106
SDLK_k: 107
SDLK_l: 108
SDLK_m: 109
SDLK_n: 110
SDLK_o: 111
SDLK_p: 112
SDLK_q: 113
SDLK_r: 114
SDLK_s: 115
SDLK_t: 116
SDLK_u: 117
SDLK_v: 118
SDLK_w: 119
SDLK_x: 120
SDLK_y: 121
SDLK_z: 122
SDLK_DELETE: 127
 { End of ASCII mapped keysyms }
 
 {* @name International keyboard syms }
SDLK_WORLD_0: 160 { 160 }
SDLK_WORLD_1: 161
SDLK_WORLD_2: 162
SDLK_WORLD_3: 163
SDLK_WORLD_4: 164
SDLK_WORLD_5: 165
SDLK_WORLD_6: 166
SDLK_WORLD_7: 167
SDLK_WORLD_8: 168
SDLK_WORLD_9: 169
SDLK_WORLD_10: 170
SDLK_WORLD_11: 171
SDLK_WORLD_12: 172
SDLK_WORLD_13: 173
SDLK_WORLD_14: 174
SDLK_WORLD_15: 175
SDLK_WORLD_16: 176
SDLK_WORLD_17: 177
SDLK_WORLD_18: 178
SDLK_WORLD_19: 179
SDLK_WORLD_20: 180
SDLK_WORLD_21: 181
SDLK_WORLD_22: 182
SDLK_WORLD_23: 183
SDLK_WORLD_24: 184
SDLK_WORLD_25: 185
SDLK_WORLD_26: 186
SDLK_WORLD_27: 187
SDLK_WORLD_28: 188
SDLK_WORLD_29: 189
SDLK_WORLD_30: 190
SDLK_WORLD_31: 191
SDLK_WORLD_32: 192
SDLK_WORLD_33: 193
SDLK_WORLD_34: 194
SDLK_WORLD_35: 195
SDLK_WORLD_36: 196
SDLK_WORLD_37: 197
SDLK_WORLD_38: 198
SDLK_WORLD_39: 199
SDLK_WORLD_40: 200
SDLK_WORLD_41: 201
SDLK_WORLD_42: 202
SDLK_WORLD_43: 203
SDLK_WORLD_44: 204
SDLK_WORLD_45: 205
SDLK_WORLD_46: 206
SDLK_WORLD_47: 207
SDLK_WORLD_48: 208
SDLK_WORLD_49: 209
SDLK_WORLD_50: 210
SDLK_WORLD_51: 211
SDLK_WORLD_52: 212
SDLK_WORLD_53: 213
SDLK_WORLD_54: 214
SDLK_WORLD_55: 215
SDLK_WORLD_56: 216
SDLK_WORLD_57: 217
SDLK_WORLD_58: 218
SDLK_WORLD_59: 219
SDLK_WORLD_60: 220
SDLK_WORLD_61: 221
SDLK_WORLD_62: 222
SDLK_WORLD_63: 223
SDLK_WORLD_64: 224
SDLK_WORLD_65: 225
SDLK_WORLD_66: 226
SDLK_WORLD_67: 227
SDLK_WORLD_68: 228
SDLK_WORLD_69: 229
SDLK_WORLD_70: 230
SDLK_WORLD_71: 231
SDLK_WORLD_72: 232
SDLK_WORLD_73: 233
SDLK_WORLD_74: 234
SDLK_WORLD_75: 235
SDLK_WORLD_76: 236
SDLK_WORLD_77: 237
SDLK_WORLD_78: 238
SDLK_WORLD_79: 239
SDLK_WORLD_80: 240
SDLK_WORLD_81: 241
SDLK_WORLD_82: 242
SDLK_WORLD_83: 243
SDLK_WORLD_84: 244
SDLK_WORLD_85: 245
SDLK_WORLD_86: 246
SDLK_WORLD_87: 247
SDLK_WORLD_88: 248
SDLK_WORLD_89: 249
SDLK_WORLD_90: 250
SDLK_WORLD_91: 251
SDLK_WORLD_92: 252
SDLK_WORLD_93: 253
SDLK_WORLD_94: 254
SDLK_WORLD_95: 255 { 255 }
 
 {* @name Numeric keypad }
 
SDLK_KP0: 256
SDLK_KP1: 257
SDLK_KP2: 258
SDLK_KP3: 259
SDLK_KP4: 260
SDLK_KP5: 261
SDLK_KP6: 262
SDLK_KP7: 263
SDLK_KP8: 264
SDLK_KP9: 265
SDLK_KP_PERIOD: 266
SDLK_KP_DIVIDE: 267
SDLK_KP_MULTIPLY: 268
SDLK_KP_MINUS: 269
SDLK_KP_PLUS: 270
SDLK_KP_ENTER: 271
SDLK_KP_EQUALS: 272
 
 {* @name Arrows + Home/End pad }
 
SDLK_UP: 273
SDLK_DOWN: 274
SDLK_RIGHT: 275
SDLK_LEFT: 276
SDLK_INSERT: 277
SDLK_HOME: 278
SDLK_END: 279
SDLK_PAGEUP: 280
SDLK_PAGEDOWN: 281
 
 {* @name Function keys }
 
SDLK_F1: 282
SDLK_F2: 283
SDLK_F3: 284
SDLK_F4: 285
SDLK_F5: 286
SDLK_F6: 287
SDLK_F7: 288
SDLK_F8: 289
SDLK_F9: 290
SDLK_F10: 291
SDLK_F11: 292
SDLK_F12: 293
SDLK_F13: 294
SDLK_F14: 295
SDLK_F15: 296
 
 {* @name Key state modifier keys }
 
SDLK_NUMLOCK: 300
SDLK_CAPSLOCK: 301
SDLK_SCROLLOCK: 302
SDLK_RSHIFT: 303
SDLK_LSHIFT: 304
SDLK_RCTRL: 305
SDLK_LCTRL: 306
SDLK_RALT: 307
SDLK_LALT: 308
SDLK_RMETA: 309
SDLK_LMETA: 310
SDLK_LSUPER: 311 {*< Left "Windows" key }
SDLK_RSUPER: 312 {*< Right "Windows" key }
SDLK_MODE: 313 {*< "Alt Gr" key }
SDLK_COMPOSE: 314 {*< Multi-key compose key }
 
 {* @name Miscellaneous function keys }
 
SDLK_HELP: 315
SDLK_PRINT: 316
SDLK_SYSREQ: 317
SDLK_BREAK: 318
SDLK_MENU: 319
SDLK_POWER: 320 {*< Power Macintosh power key }
SDLK_EURO: 321 {*< Some european keyboards }
SDLK_UNDO: 322 {*< Atari keyboard has Undo }

 { Add any other keys here }

SDLK_LAST: 323

SDLKey: integer!;

{* Enumeration of valid key mods (possibly OR'd together) }
KMOD_NONE: 0
KMOD_LSHIFT: 1
KMOD_RSHIFT: 2
KMOD_LCTRL: 64
KMOD_RCTRL: 128
KMOD_LALT: 256
KMOD_RALT: 512
KMOD_LMETA: 1024
KMOD_RMETA: 2048
KMOD_NUM: 4096
KMOD_CAPS: 8192
KMOD_MODE: 16384
KMOD_RESERVED: 32768

SDLMod: integer!;

KMOD_CTRL:    KMOD_LCTRL or KMOD_RCTRL 
KMOD_SHIFT:   KMOD_LSHIFT or KMOD_RSHIFT 
KMOD_ALT:     KMOD_LALT or KMOD_RALT 
KMOD_META:    KMOD_LMETA or KMOD_RMETA 


{* Keysym structure
 *
 *  - The scancode is hardware dependent, and should not be used by general
 *    applications.  If no hardware scancode is available, it will be 0.
 *
 *  - The 'unicode' translated character is only available when character
 *    translation is enabled by the SDL_EnableUNICODE() API.  If non-zero,
 *    this is a UNICODE character corresponding to the keypress.  If the
 *    high 9 bits of the character are 0, then this maps to the equivalent
 *    ASCII character:
 *      @code
 *  char ch;
 *  if ( (keysym.unicode & 65408) == 0 ) {
 *      ch = keysym.unicode & 127;
 *  } else {
 *      An international character..
 *  }
 *      @endcode
 }
SDL_keysym_: SDL_keysym: make struct! [
  scancode [char!] {*< hardware specific scancode }
  sym [SDLKey] {*< SDL virtual keysym }
  mod [SDLMod] {*< current key modifiers }
  unicode [short] {*< translated character }
] none ;

{* This is the mask which refers to all hotkey bindings }
SDL_ALL_HOTKEYS:        -1


{*
 * Enable/Disable UNICODE translation of keyboard input.
 *
 * This translation has some overhead, so translation defaults off.
 *
 * @param[in] enable
 * If 'enable' is 1, translation is enabled.
 * If 'enable' is 0, translation is disabled.
 * If 'enable' is -1, the translation state is not changed.
 *
 * @return It returns the previous state of keyboard translation.
 }
SDL_EnableUNICODE: make routine! [ enable [integer!] return: [integer!] ] SDL-lib "SDL_EnableUNICODE" 

SDL_DEFAULT_REPEAT_DELAY:   500
SDL_DEFAULT_REPEAT_INTERVAL:    30
{*
 * Enable/Disable keyboard repeat.  Keyboard repeat defaults to off.
 *
 *  @param[in] delay
 *  'delay' is the initial delay in ms between the time when a key is
 *  pressed, and keyboard repeat begins.
 *
 *  @param[in] interval
 *  'interval' is the time in ms between keyboard repeat events.
 *
 *  If 'delay' is set to 0, keyboard repeat is disabled.
 }
SDL_EnableKeyRepeat: make routine! [ delay [integer!] interval [integer!] return: [integer!] ] SDL-lib "SDL_EnableKeyRepeat" 
SDL_GetKeyRepeat: make routine! [ delay [struct! []] interval [struct! []] return: [integer!] ] SDL-lib "SDL_GetKeyRepeat" 

{*
 * Get a snapshot of the current state of the keyboard.
 * Returns an array of keystates, indexed by the SDLK_* syms.
 * Usage:
 *  @code
 *  Uint8 *keystate = SDL_GetKeyState(NULL);
 *  if ( keystate[SDLK_RETURN] ) ;... \<RETURN> is pressed.
 *  @endcode
 }
SDL_GetKeyState: make routine! [ numkeys [struct! []] return: [struct! []] ] SDL-lib "SDL_GetKeyState" 

 {*
 * Get the current key modifier state
 }
SDL_GetModState: make routine! [ return: [SDLMod] ] SDL-lib "SDL_GetModState" 

 {*
 * Set the current key modifier state.
 * This does not change the keyboard state, only the key modifier flags.
 }
SDL_SetModState: make routine! [ modstate [SDLMod] return: [integer!] ] SDL-lib "SDL_SetModState" 

 {*
 * Get the name of an SDL virtual keysym
 }
SDL_GetKeyName: make routine! [ key [SDLKey] return: [string!] ] SDL-lib "SDL_GetKeyName" 

{* @name Useful data types }

SDL_Rect_: SDL_Rect: make struct! [
  x [short]  y [short]
  w [short]  h [short]
] none ;

SDL_Colour: SDL_Color_: SDL_Color: make struct! [
  r [char!]
  g [char!]
  b [char!]
  unused [char!]
] none ;
;alias 'SDL_Color "SDL_Colour"

SDL_Palette_: SDL_Palette: make struct! [
  ncolors [integer!]
  colors [integer!]
] none ;

{* Everything in the pixel format structure is read-only }
SDL_PixelFormat_: SDL_PixelFormat: make struct! [
  palette [integer!]
  BitsPerPixel [char!]
  BytesPerPixel [char!]
  Rloss [char!]
  Gloss [char!]
  Bloss [char!]
  Aloss [char!]
  Rshift [char!]
  Gshift [char!]
  Bshift [char!]
  Ashift [char!]
  Rmask [integer!]
  Gmask [integer!]
  Bmask [integer!]
  Amask [integer!]

 {* RGB color key information }
  colorkey [integer!]
 {* Alpha value information (per-surface alpha) }
  alpha [char!]
] none ;

{* This structure should be treated as read-only, except for 'pixels',
 *  which, if not NULL, contains the raw pixel data for the surface.
 }
SDL_Surface_: SDL_Surface: make struct! [
  flags [integer!] {*< Read-only }
  format [integer!] {*< Read-only }
  w [integer!]  h [integer!] {*< Read-only }
  pitch [short] {*< Read-only }
  pixels [integer!] {*< Read-write }
  offset [integer!] {*< Private }

 {* Hardware-specific surface info }
  hwdata [integer!]

 {* clipping information }
  clip_rect [struct! [
  x [short]  y [short]
  w [short]  h [short]
]] {*< Read-only }
  unused1 [integer!] {*< for binary compatibility }

 {* Allow recursive locks }
  locked [integer!] {*< Private }

 {* info for fast blit mapping to other surfaces }
 map [integer!] {*< Private }

 {* format version, bumped at every change to invalidate blit maps }
  format_version [integer!] {*< Private }

 {* Reference count -- used when freeing surface }
  refcount [integer!] {*< Read-mostly }
] none ;

{* @name SDL_Surface Flags
 *  These are the currently supported flags for the SDL_surface
 }
{* Available for SDL_CreateRGBSurface() or SDL_SetVideoMode() }

SDL_SWSURFACE:  0   {*< Surface is in system memory }
SDL_HWSURFACE:  1   {*< Surface is in video memory }
SDL_ASYNCBLIT:  4   {*< Use asynchronous blits if possible }

{*
 *  @file SDL_events.h
 *  Include file for SDL event handling
 }
{* @name General keyboard/mouse state definitions }
SDL_RELEASED:   0
SDL_PRESSED:    1

{* Event enumerations }

SDL_NOEVENT: 0 {*< Unused (do not remove) }
SDL_ACTIVEEVENT: 1 {*< Application loses/gains visibility }
SDL_KEYDOWN: 2 {*< Keys pressed }
SDL_KEYUP: 3 {*< Keys released }
SDL_MOUSEMOTION: 4 {*< Mouse moved }
SDL_MOUSEBUTTONDOWN: 5 {*< Mouse button pressed }
SDL_MOUSEBUTTONUP: 6 {*< Mouse button released }
SDL_JOYAXISMOTION: 7 {*< Joystick axis motion }
SDL_JOYBALLMOTION: 8 {*< Joystick trackball motion }
SDL_JOYHATMOTION: 9 {*< Joystick hat position change }
SDL_JOYBUTTONDOWN: 10 {*< Joystick button pressed }
SDL_JOYBUTTONUP: 11 {*< Joystick button released }
SDL_QUIT: 12 {*< User-requested quit }
SDL_SYSWMEVENT: 13 {*< System specific event }
SDL_EVENT_RESERVEDA: 14 {*< Reserved for future use.. }
SDL_EVENT_RESERVEDB: 15 {*< Reserved for future use.. }
SDL_VIDEORESIZE: 16 {*< User resized video mode }
SDL_VIDEOEXPOSE: 17 {*< Screen needs to be redrawn }
SDL_EVENT_RESERVED2: 18 {*< Reserved for future use.. }
SDL_EVENT_RESERVED3: 19 {*< Reserved for future use.. }
SDL_EVENT_RESERVED4: 20 {*< Reserved for future use.. }
SDL_EVENT_RESERVED5: 21 {*< Reserved for future use.. }
SDL_EVENT_RESERVED6: 22 {*< Reserved for future use.. }
SDL_EVENT_RESERVED7: 23 {*< Reserved for future use.. }
 {* Events SDL_USEREVENT through SDL_MAXEVENTS-1 are for your use }
SDL_USEREVENT: 24
 {* This last event is only for bounding internal arrays
    *  It is the number of bits in the event mask datatype -- Uint32
        }
SDL_NUMEVENTS: 32

SDL_EventType: integer!;

{* @name Predefined event masks }

SDL_EVENTMASK: func [X] [shift/left 1 X]

 SDL_ACTIVEEVENTMASK: SDL_EVENTMASK SDL_ACTIVEEVENT  
 SDL_KEYDOWNMASK: SDL_EVENTMASK SDL_KEYDOWN  
 SDL_KEYUPMASK: SDL_EVENTMASK SDL_KEYUP  
 SDL_KEYEVENTMASK: (SDL_EVENTMASK SDL_KEYDOWN) or SDL_EVENTMASK SDL_KEYUP  
 SDL_MOUSEMOTIONMASK: SDL_EVENTMASK SDL_MOUSEMOTION  
 SDL_MOUSEBUTTONDOWNMASK: SDL_EVENTMASK SDL_MOUSEBUTTONDOWN  
 SDL_MOUSEBUTTONUPMASK: SDL_EVENTMASK SDL_MOUSEBUTTONUP  
 SDL_MOUSEEVENTMASK: (SDL_EVENTMASK SDL_MOUSEMOTION) or (SDL_EVENTMASK SDL_MOUSEBUTTONDOWN) or (SDL_EVENTMASK SDL_MOUSEBUTTONUP)  
 SDL_JOYAXISMOTIONMASK: SDL_EVENTMASK SDL_JOYAXISMOTION  
 SDL_JOYBALLMOTIONMASK: SDL_EVENTMASK SDL_JOYBALLMOTION  
 SDL_JOYHATMOTIONMASK: SDL_EVENTMASK SDL_JOYHATMOTION  
 SDL_JOYBUTTONDOWNMASK: SDL_EVENTMASK SDL_JOYBUTTONDOWN  
 SDL_JOYBUTTONUPMASK: SDL_EVENTMASK SDL_JOYBUTTONUP 
 SDL_JOYEVENTMASK: (SDL_EVENTMASK SDL_JOYAXISMOTION) or (SDL_EVENTMASK SDL_JOYBALLMOTION) or (SDL_EVENTMASK SDL_JOYHATMOTION) or (SDL_EVENTMASK SDL_JOYBUTTONDOWN) or (SDL_EVENTMASK SDL_JOYBUTTONUP)  
 SDL_VIDEORESIZEMASK: SDL_EVENTMASK SDL_VIDEORESIZE  
 SDL_VIDEOEXPOSEMASK: SDL_EVENTMASK SDL_VIDEOEXPOSE  
 SDL_QUITMASK: SDL_EVENTMASK SDL_QUIT  
 SDL_SYSWMEVENTMASK: SDL_EVENTMASK SDL_SYSWMEVENT 
SDL_EventMask: integer!
SDL_ALLEVENTS:      -1

{* Application visibility event structure }
SDL_ActiveEvent_: make struct! [
  type [char!] {*< SDL_ACTIVEEVENT }
  gain [char!] {*< Whether given states were gained or lost (1/0) }
  state [char!] {*< A mask of the focus states }
] none ;

{* Keyboard event structure }
SDL_KeyboardEvent_: SDL_KeyboardEvent: make struct! [
  type [char!] {*< SDL_KEYDOWN or SDL_KEYUP }
  which [char!] {*< The keyboard device index }
  state [char!] {*< SDL_PRESSED or SDL_RELEASED }
  ;keysym [struct! [
      keysym-scancode [char!] {*< hardware specific scancode }
      keysym-pad [integer!] {REBOL-NOTE: it's necessary to add this...}
      keysym-sym [SDLKey] {*< SDL virtual keysym }
      keysym-mod [SDLMod] {*< current key modifiers }
      keysym-unicode [short] {*< translated character }
    ;]
 ;]
] none ;

{* Mouse motion event structure }
SDL_MouseMotionEvent_: SDL_MouseMotionEvent: make struct! [
  type [char!] {*< SDL_MOUSEMOTION }
  which [char!] {*< The mouse device index }
  state [char!] {*< The current button state }
  x [short]  y [short] {*< The X/Y coordinates of the mouse }
  xrel [short] {*< The relative motion in the X direction }
  yrel [short] {*< The relative motion in the Y direction }
] none ;

{* Mouse button event structure }
SDL_MouseButtonEvent_: SDL_MouseButtonEvent: make struct! [
  type [char!] {*< SDL_MOUSEBUTTONDOWN or SDL_MOUSEBUTTONUP }
  which [char!] {*< The mouse device index }
  button [char!] {*< The mouse button index }
  state [char!] {*< SDL_PRESSED or SDL_RELEASED }
  x [short]  y [short] {*< The X/Y coordinates of the mouse at press time }
] none ;

{* Joystick axis motion event structure }
SDL_JoyAxisEvent_: SDL_JoyAxisEvent: make struct! [
  type [char!] {*< SDL_JOYAXISMOTION }
  which [char!] {*< The joystick device index }
  axis [char!] {*< The joystick axis index }
  value [short] {*< The axis value (range: -32768 to 32767) }
] none ;

{* Joystick trackball motion event structure }
SDL_JoyBallEvent_: SDL_JoyBallEvent: make struct! [
  type [char!] {*< SDL_JOYBALLMOTION }
  which [char!] {*< The joystick device index }
  ball [char!] {*< The joystick trackball index }
  xrel [short] {*< The relative motion in the X direction }
  yrel [short] {*< The relative motion in the Y direction }
] none ;

{* Joystick hat position change event structure }
SDL_JoyHatEvent_: SDL_JoyHatEvent: make struct! [
  type [char!] {*< SDL_JOYHATMOTION }
  which [char!] {*< The joystick device index }
  hat [char!] {*< The joystick hat index }
  value [char!] {*< The hat position value:
             *   SDL_HAT_LEFTUP   SDL_HAT_UP       SDL_HAT_RIGHTUP
             *   SDL_HAT_LEFT     SDL_HAT_CENTERED SDL_HAT_RIGHT
             *   SDL_HAT_LEFTDOWN SDL_HAT_DOWN     SDL_HAT_RIGHTDOWN
             *  Note that zero means the POV is centered.
             }
] none ;

{* Joystick button event structure }
SDL_JoyButtonEvent_: SDL_JoyButtonEvent: make struct! [
  type [char!] {*< SDL_JOYBUTTONDOWN or SDL_JOYBUTTONUP }
  which [char!] {*< The joystick device index }
  button [char!] {*< The joystick button index }
  state [char!] {*< SDL_PRESSED or SDL_RELEASED }
] none ;

{* The "window resized" event
 *  When you get this event, you are responsible for setting a new video
 *  mode with the new width and height.
 }
SDL_ResizeEvent_: SDL_ResizeEvent: make struct! [
  type [char!] {*< SDL_VIDEORESIZE }
  w [integer!] {*< New width }
  h [integer!] {*< New height }
] none ;

{* The "screen redraw" event }
SDL_ExposeEvent_: SDL_ExposeEvent: make struct! [
  type [char!] {*< SDL_VIDEOEXPOSE }
] none ;

{* The "quit requested" event }
SDL_QuitEvent_: SDL_QuitEvent: make struct! [
  type [char!] {*< SDL_QUIT }
] none ;

{* A user-defined event type }
SDL_UserEvent_: SDL_UserEvent: make struct! [
  type [char!] {*< SDL_USEREVENT through SDL_NUMEVENTS-1 }
  code [integer!] {*< User defined event code }
  data1 [integer!] {*< User defined data pointer }
  data2 [integer!] {*< User defined data pointer }
] none ;

{* If you want to use this event, you should include SDL_syswm.h }
{struct SDL_SysWMmsg;
typedef struct SDL_SysWMmsg SDL_SysWMmsg;}
SDL_SysWMEvent_: SDL_SysWMEvent: make struct! [
  type [char!]
  msg [integer!]
] none ;

{* General event structure }
SDL_Event_: SDL_Event: make struct! [
  type [char!]
  active [struct! [
  type [char!] {*< SDL_ACTIVEEVENT }
  gain [char!] {*< Whether given states were gained or lost (1/0) }
  state [char!] {*< A mask of the focus states }
]]
  key [struct! [
  type [char!] {*< SDL_KEYDOWN or SDL_KEYUP }
  which [char!] {*< The keyboard device index }
  state [char!] {*< SDL_PRESSED or SDL_RELEASED }
  keysym [struct! [
      scancode [char!] {*< hardware specific scancode }
      sym [SDLKey] {*< SDL virtual keysym }
      mod [SDLMod] {*< current key modifiers }
      unicode [short] {*< translated character }
    ]
 ]
]]
  motion [struct! [
  type [char!] {*< SDL_MOUSEMOTION }
  which [char!] {*< The mouse device index }
  state [char!] {*< The current button state }
  x [short]  y [short] {*< The X/Y coordinates of the mouse }
  xrel [short] {*< The relative motion in the X direction }
  yrel [short] {*< The relative motion in the Y direction }
]]
  button [struct! [
  type [char!] {*< SDL_MOUSEBUTTONDOWN or SDL_MOUSEBUTTONUP }
  which [char!] {*< The mouse device index }
  button [char!] {*< The mouse button index }
  state [char!] {*< SDL_PRESSED or SDL_RELEASED }
  x [short]  y [short] {*< The X/Y coordinates of the mouse at press time }
]]
  jaxis [struct! [
  type [char!] {*< SDL_JOYAXISMOTION }
  which [char!] {*< The joystick device index }
  axis [char!] {*< The joystick axis index }
  value [short] {*< The axis value (range: -32768 to 32767) }
]]
  jball [struct! [
  type [char!] {*< SDL_JOYBALLMOTION }
  which [char!] {*< The joystick device index }
  ball [char!] {*< The joystick trackball index }
  xrel [short] {*< The relative motion in the X direction }
  yrel [short] {*< The relative motion in the Y direction }
]]
  jhat [struct! [
  type [char!] {*< SDL_JOYHATMOTION }
  which [char!] {*< The joystick device index }
  hat [char!] {*< The joystick hat index }
  value [char!] {*< The hat position value:
             *   SDL_HAT_LEFTUP   SDL_HAT_UP       SDL_HAT_RIGHTUP
             *   SDL_HAT_LEFT     SDL_HAT_CENTERED SDL_HAT_RIGHT
             *   SDL_HAT_LEFTDOWN SDL_HAT_DOWN     SDL_HAT_RIGHTDOWN
             *  Note that zero means the POV is centered.
             }
]]
  jbutton [struct! [
  type [char!] {*< SDL_JOYBUTTONDOWN or SDL_JOYBUTTONUP }
  which [char!] {*< The joystick device index }
  button [char!] {*< The joystick button index }
  state [char!] {*< SDL_PRESSED or SDL_RELEASED }
]]
  resize [struct! [
  type [char!] {*< SDL_VIDEORESIZE }
  w [integer!] {*< New width }
  h [integer!] {*< New height }
]]
  expose [struct! [
  type [char!] {*< SDL_VIDEOEXPOSE }
]]
  quit [struct! [
  type [char!] {*< SDL_QUIT }
]]
  user [struct! [
  type [char!] {*< SDL_USEREVENT through SDL_NUMEVENTS-1 }
  code [integer!] {*< User defined event code }
  data1 [integer!] {*< User defined data pointer }
  data2 [integer!] {*< User defined data pointer }
]]
  syswm [struct! [
  type [char!]
  msg [integer!]
]]
] none ;

{* General event structure }
SDL_Event_: SDL_Event: make struct! [
  type [char!]
  subtype [integer!]
  data1 [integer!]
  data2 [integer!]
] none

{* Pumps the event loop, gathering events from the input devices.
 *  This function updates the event queue and internal input device state.
 *  This should only be run in the thread that sets the video mode.
 }
SDL_PumpEvents: make routine! [ return: [integer!] ] SDL-lib "SDL_PumpEvents" 

SDL_ADDEVENT: 0
SDL_PEEKEVENT: 1
SDL_GETEVENT: 2

SDL_eventaction: integer!;

{*
 *  Checks the event queue for messages and optionally returns them.
 *
 *  If 'action' is SDL_ADDEVENT, up to 'numevents' events will be added to
 *  the back of the event queue.
 *  If 'action' is SDL_PEEKEVENT, up to 'numevents' events at the front
 *  of the event queue, matching 'mask', will be returned and will not
 *  be removed from the queue.
 *  If 'action' is SDL_GETEVENT, up to 'numevents' events at the front 
 *  of the event queue, matching 'mask', will be returned and will be
 *  removed from the queue.
 *
 *  @return
 *  This function returns the number of events actually stored, or -1
 *  if there was an error.
 *
 *  This function is thread-safe.
 }
SDL_PeepEvents: make routine! [ events [integer!] numevents [integer!]
 action [SDL_eventaction] mask [integer!] return: [integer!] ] SDL-lib "SDL_PeepEvents" 

 {* Polls for currently pending events, and returns 1 if there are any pending
 *  events, or 0 if there are none available.  If 'event' is not NULL, the next
 *  event is removed from the queue and stored in that area.
 }
SDL_PollEvent: make routine! [ event [struct! []] return: [integer!] ] SDL-lib "SDL_PollEvent" 

 {* Waits indefinitely for the next available event, returning 1, or 0 if there
 *  was an error while waiting for events.  If 'event' is not NULL, the next
 *  event is removed from the queue and stored in that area.
 }
SDL_WaitEvent: make routine! [ event [integer!] return: [integer!] ] SDL-lib "SDL_WaitEvent" 

 {* Add an event to the event queue.
 *  This function returns 0 on success, or -1 if the event queue was full
 *  or there was some other error.
 }
SDL_PushEvent: make routine! [ event [integer!] return: [integer!] ] SDL-lib "SDL_PushEvent" 

{* @name Event Filtering }

{typedef int (SDLCALL *SDL_EventFilter)(const SDL_Event *event);}
SDL_EventFilter: integer!
{*
 *  This function sets up a filter to process all events before they
 *  change internal state and are posted to the internal event queue.
 *
 *  The filter is protypted as:
 *      @code typedef int (SDLCALL *SDL_EventFilter)(const SDL_Event *event); @endcode
 *
 * If the filter returns 1, then the event will be added to the internal queue.
 * If it returns 0, then the event will be dropped from the queue, but the 
 * internal state will still be updated.  This allows selective filtering of
 * dynamically arriving events.
 *
 * @warning  Be very careful of what you do in the event filter function, as 
 *           it may run in a different thread!
 *
 * There is one caveat when dealing with the SDL_QUITEVENT event type.  The
 * event filter is only called when the window manager desires to close the
 * application window.  If the event filter returns 1, then the window will
 * be closed, otherwise the window will remain open if possible.
 * If the quit event is generated by an interrupt signal, it will bypass the
 * internal queue and be delivered to the application at the next event poll.
 }
SDL_SetEventFilter: make routine! [ filter [SDL_EventFilter] return: [integer!] ] SDL-lib "SDL_SetEventFilter" 

 {*
 *  Return the current event filter - can be used to "chain" filters.
 *  If there is no event filter set, this function returns NULL.
 }
SDL_GetEventFilter: make routine! [ return: [SDL_EventFilter] ] SDL-lib "SDL_GetEventFilter" 

{* @name Event State }
SDL_QUERY:  -1
SDL_IGNORE:  0
SDL_DISABLE:     0
SDL_ENABLE:  1

{*
* This function allows you to set the state of processing certain events.
* If 'state' is set to SDL_IGNORE, that event will be automatically dropped
* from the event queue and will not event be filtered.
* If 'state' is set to SDL_ENABLE, that event will be processed normally.
* If 'state' is set to SDL_QUERY, SDL_EventState() will return the 
* current processing state of the specified event.
}
SDL_EventState: make routine! [ type [char!] state [integer!] return: [char!] ] SDL-lib "SDL_EventState" 

{* @file SDL_joystick.h
 *  @note In order to use these functions, SDL_Init() must have been called
 *        with the SDL_INIT_JOYSTICK flag.  This causes SDL to scan the system
 *        for joysticks, and load appropriate drivers.
 }

{* The joystick structure used to identify an SDL joystick }
{struct _SDL_Joystick;
typedef struct _SDL_Joystick SDL_Joystick;}

{*
 * Count the number of joysticks attached to the system
 }
SDL_NumJoysticks: make routine! [ return: [integer!] ] SDL-lib "SDL_NumJoysticks" 

 {*
 * Get the implementation dependent name of a joystick.
 *
 * This can be called before any joysticks are opened.
 * If no name can be found, this function returns NULL.
 }
SDL_JoystickName: make routine! [ device_index [integer!] return: [string!] ] SDL-lib "SDL_JoystickName" 

 {*
 * Open a joystick for use.
 *
 * @param[in] device_index
 * The index passed as an argument refers to
 * the N'th joystick on the system.  This index is the value which will
 * identify this joystick in future joystick events.
 *
 * @return This function returns a joystick identifier, or NULL if an error occurred.
 }
SDL_JoystickOpen: make routine! [ device_index [integer!] return: [integer!] ] SDL-lib "SDL_JoystickOpen" 

{*
 * Returns 1 if the joystick has been opened, or 0 if it has not.
 }
SDL_JoystickOpened: make routine! [ device_index [integer!] return: [integer!] ] SDL-lib "SDL_JoystickOpened" 

 {*
 * Get the device index of an opened joystick.
 }
SDL_JoystickIndex: make routine! [ joystick [integer!] return: [integer!] ] SDL-lib "SDL_JoystickIndex" 

 {*
 * Get the number of general axis controls on a joystick
 }
SDL_JoystickNumAxes: make routine! [ joystick [integer!] return: [integer!] ] SDL-lib "SDL_JoystickNumAxes" 

{*
 * Get the number of trackballs on a joystick
 *
 * Joystick trackballs have only relative motion events associated
 * with them and their state cannot be polled.
 }
SDL_JoystickNumBalls: make routine! [ joystick [integer!] return: [integer!] ] SDL-lib "SDL_JoystickNumBalls" 

 {*
 * Get the number of POV hats on a joystick
 }
SDL_JoystickNumHats: make routine! [ joystick [integer!] return: [integer!] ] SDL-lib "SDL_JoystickNumHats" 

 {*
 * Get the number of buttons on a joystick
 }
SDL_JoystickNumButtons: make routine! [ joystick [integer!] return: [integer!] ] SDL-lib "SDL_JoystickNumButtons" 

{*
 * Update the current state of the open joysticks.
 *
 * This is called automatically by the event loop if any joystick
 * events are enabled.
 }
SDL_JoystickUpdate: make routine! [ return: [integer!] ] SDL-lib "SDL_JoystickUpdate" 

 {*
 * Enable/disable joystick event polling.
 *
 * If joystick events are disabled, you must call SDL_JoystickUpdate()
 * yourself and check the state of the joystick when you want joystick
 * information.
 *
 * @param[in] state The state can be one of SDL_QUERY, SDL_ENABLE or SDL_IGNORE.
 }
SDL_JoystickEventState: make routine! [ state [integer!] return: [integer!] ] SDL-lib "SDL_JoystickEventState" 

{*
 * Get the current state of an axis control on a joystick
 *
 * @param[in] axis The axis indices start at index 0.
 *
 * @return The state is a value ranging from -32768 to 32767.
 }
SDL_JoystickGetAxis: make routine! [ joystick [struct! []] axis [integer!] return: [short] ] SDL-lib "SDL_JoystickGetAxis" 

{*
 *  @name Hat Positions
 *  The return value of SDL_JoystickGetHat() is one of the following positions:
 }

SDL_HAT_CENTERED:   0
SDL_HAT_UP:     1
SDL_HAT_RIGHT:      2
SDL_HAT_DOWN:       4
SDL_HAT_LEFT:       8
SDL_HAT_RIGHTUP:  SDL_HAT_RIGHT + SDL_HAT_UP 
SDL_HAT_RIGHTDOWN:  SDL_HAT_RIGHT + SDL_HAT_DOWN 
SDL_HAT_LEFTUP:  SDL_HAT_LEFT + SDL_HAT_UP 
SDL_HAT_LEFTDOWN:  SDL_HAT_LEFT + SDL_HAT_DOWN 

{* 
 *  Get the current state of a POV hat on a joystick
 *
 *  @param[in] hat The hat indices start at index 0.
 }
SDL_JoystickGetHat: make routine! [ joystick [integer!] hat [integer!] return: [char!] ] SDL-lib "SDL_JoystickGetHat" 

 {*
 * Get the ball axis change since the last poll
 *
 * @param[in] ball The ball indices start at index 0.
 *
 * @return This returns 0, or -1 if you passed it invalid parameters.
 }
SDL_JoystickGetBall: make routine! [ joystick [integer!] ball [integer!] dx [integer!] dy [integer!] return: [integer!] ] SDL-lib "SDL_JoystickGetBall" 

 {*
 * Get the current state of a button on a joystick
 *
 * @param[in] button The button indices start at index 0.
 }
SDL_JoystickGetButton: make routine! [ joystick [integer!] button [integer!] return: [char!] ] SDL-lib "SDL_JoystickGetButton" 

 {*
 * Close a joystick previously opened with SDL_JoystickOpen()
 }
SDL_JoystickClose: make routine! [ joystick [integer!] return: [integer!] ] SDL-lib "SDL_JoystickClose" 

{* @file SDL_loadso.h
 *  Some things to keep in mind:                                        
 *  - These functions only work on C function names.  Other languages may
 *    have name mangling and intrinsic language support that varies from
 *    compiler to compiler.
 *  - Make sure you declare your function pointers with the same calling
 *    convention as the actual library function.  Your code will crash
 *    mysteriously if you do not do this.
 *  - Avoid namespace collisions.  If you load a symbol from the library,
 *    it is not defined whether or not it goes into the global symbol
 *    namespace for the application.  If it does and it conflicts with
 *    symbols in your code or other shared libraries, you will not get
 *    the results you expect. :)
 }
{*
 * This function dynamically loads a shared object and returns a pointer
 * to the object handle (or NULL if there was an error).
 * The 'sofile' parameter is a system dependent name of the object file.
 }
SDL_LoadObject: make routine! [ sofile [string!] return: [integer!] ] SDL-lib "SDL_LoadObject" 

 {*
 * Given an object handle, this function looks up the address of the
 * named function in the shared object and returns it.  This address
 * is no longer valid after calling SDL_UnloadObject().
 }
SDL_LoadFunction: make routine! [ handle [integer!] name [string!] return: [integer!] ] SDL-lib "SDL_LoadFunction" 

 {* Unload a shared object from memory }
SDL_UnloadObject: make routine! [ handle [integer!] return: [integer!] ] SDL-lib "SDL_UnloadObject" 

{* @file SDL_main.h
 *  Redefine main() on Win32 and MacOS so that it is called by winmain.c
 }
{* The application's main() function must be called with C linkage,
 *  and should be declared like this:
 *      @code
 *      #ifdef __cplusplus
 *      extern "C"
 *      #endif
 *  int main(int argc, char *argv[])
 *  {
 *  }
 *      @endcode
 }

{* The prototype for the application's main() function }
;SDL_main: make routine! [ argc [integer!] argv [string!] return: [C_LINKAGE] ] SDL-lib "SDL_main" 

{* This should be called from your WinMain() function, if any }
;SDL_SetModuleHandle: make routine! [ hInst [integer!] return: [integer!] ] SDL-lib "SDL_SetModuleHandle" 
 {* This can also be called, but is no longer necessary }
;SDL_RegisterApp: make routine! [ name [string!] style [integer!] hInst [integer!] return: [integer!] ] SDL-lib "SDL_RegisterApp" 
 {* This can also be called, but is no longer necessary (SDL_Quit calls it) }
;SDL_UnregisterApp: make routine! [ return: [integer!] ] SDL-lib "SDL_UnregisterApp" 

{* Forward declaration so we don't need to include QuickDraw.h }
{struct QDGlobals;}

{* This should be called from your main() function, if any }
;SDL_InitQuickDraw: make routine! [ the_qd [integer!] return: [integer!] ] SDL-lib "SDL_InitQuickDraw" 

{typedef struct WMcursor WMcursor;} {*< Implementation dependent }
SDL_Cursor_: SDL_Cursor: make struct! [
  area [struct! [
  x [short]  y [short]
  w [short]  h [short]
]] {*< The area of the mouse cursor }
  hot_x [short]  hot_y [short] {*< The "tip" of the cursor }
  data [integer!] {*< B/W cursor data }
  mask [integer!] {*< B/W cursor mask }
  save [struct! []] {[2]}{*< Place to save cursor area }
  wm_cursor [integer!] {*< Window-manager cursor }
] none ;

{*
 * Retrieve the current state of the mouse.
 * The current button state is returned as a button bitmask, which can
 * be tested using the SDL_BUTTON(X) macros, and x and y are set to the
 * current mouse cursor position.  You can pass NULL for either x or y.
 }
SDL_GetMouseState: make routine! [ x [integer!] y [integer!] return: [char!] ] SDL-lib "SDL_GetMouseState" 

 {*
 * Retrieve the current state of the mouse.
 * The current button state is returned as a button bitmask, which can
 * be tested using the SDL_BUTTON(X) macros, and x and y are set to the
 * mouse deltas since the last call to SDL_GetRelativeMouseState().
 }
SDL_GetRelativeMouseState: make routine! [ x [integer!] y [integer!] return: [char!] ] SDL-lib "SDL_GetRelativeMouseState" 

 {*
 * Set the position of the mouse cursor (generates a mouse motion event)
 }
SDL_WarpMouse: make routine! [ x [short] y [short] return: [integer!] ] SDL-lib "SDL_WarpMouse" 

 {*
 * Create a cursor using the specified data and mask (in MSB format).
 * The cursor width must be a multiple of 8 bits.
 *
 * The cursor is created in black and white according to the following:
 * data  mask    resulting pixel on screen
 *  0     1       White
 *  1     1       Black
 *  0     0       Transparent
 *  1     0       Inverted color if possible, black if not.
 *
 * Cursors created with this function must be freed with SDL_FreeCursor().
 }
SDL_CreateCursor: make routine! [
 data [integer!] mask [integer!] w [integer!] h [integer!] hot_x [integer!] hot_y [integer!] return: [integer!] ] SDL-lib "SDL_CreateCursor" 

 {*
 * Set the currently active cursor to the specified one.
 * If the cursor is currently visible, the change will be immediately 
 * represented on the display.
 }
SDL_SetCursor: make routine! [ cursor [integer!] return: [integer!] ] SDL-lib "SDL_SetCursor" 

 {*
 * Returns the currently active cursor.
 }
SDL_GetCursor: make routine! [ return: [integer!] ] SDL-lib "SDL_GetCursor" 

 {*
 * Deallocates a cursor created with SDL_CreateCursor().
 }
SDL_FreeCursor: make routine! [ cursor [integer!] return: [integer!] ] SDL-lib "SDL_FreeCursor" 

 {*
 * Toggle whether or not the cursor is shown on the screen.
 * The cursor start off displayed, but can be turned off.
 * SDL_ShowCursor() returns 1 if the cursor was being displayed
 * before the call, or 0 if it was not.  You can query the current
 * state by passing a 'toggle' value of -1.
 }
SDL_ShowCursor: make routine! [ toggle [integer!] return: [integer!] ] SDL-lib "SDL_ShowCursor" 

{* Used as a mask when testing buttons in buttonstate
 *  Button 1:   Left mouse button
 *  Button 2:   Middle mouse button
 *  Button 3:   Right mouse button
 *  Button 4:   Mouse wheel up   (may also be a real button)
 *  Button 5:   Mouse wheel down (may also be a real button)
 }
SDL_BUTTON: func [X] [shift/left 1 X - 1]
SDL_BUTTON_LEFT:     1
SDL_BUTTON_MIDDLE:   2
SDL_BUTTON_RIGHT:    3
SDL_BUTTON_WHEELUP:  4
SDL_BUTTON_WHEELDOWN:    5
SDL_BUTTON_X1:       6
SDL_BUTTON_X2:       7
SDL_BUTTON_LMASK: SDL_BUTTON SDL_BUTTON_LEFT 
SDL_BUTTON_MMASK: SDL_BUTTON SDL_BUTTON_MIDDLE 
SDL_BUTTON_RMASK: SDL_BUTTON SDL_BUTTON_RIGHT 
SDL_BUTTON_X1MASK: SDL_BUTTON SDL_BUTTON_X1 
SDL_BUTTON_X2MASK: SDL_BUTTON SDL_BUTTON_X2 

{* @file SDL_mutex.h
 *  Functions to provide thread synchronization primitives
 *
 *  @note These are independent of the other SDL routines.
 }
{* Synchronization functions which can time out return this value
 *  if they time out.
 }
SDL_MUTEX_TIMEDOUT: 1

{* This is the timeout value which corresponds to never time out }
SDL_MUTEX_MAXWAIT: -1

{ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }
{* @name Mutex functions                                        } 
{ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }

{* The SDL mutex structure, defined in SDL_mutex.c }
{struct SDL_mutex;
typedef struct SDL_mutex SDL_mutex;}

{* Create a mutex, initialized unlocked }
SDL_CreateMutex: make routine! [ return: [integer!] ] SDL-lib "SDL_CreateMutex" 

SDL_LockMutex: func [m] [SDL_mutexP m] 
{* Lock the mutex
 *  @return 0, or -1 on error
 }
SDL_mutexP: make routine! [ mutex [integer!] return: [integer!] ] SDL-lib "SDL_mutexP" 

SDL_UnlockMutex: func [m] [SDL_mutexV m] 
{* Unlock the mutex
 *  @return 0, or -1 on error
 *
 *  It is an error to unlock a mutex that has not been locked by
 *  the current thread, and doing so results in undefined behavior.
 }
SDL_mutexV: make routine! [ mutex [integer!] return: [integer!] ] SDL-lib "SDL_mutexV" 

 {* Destroy a mutex }
SDL_DestroyMutex: make routine! [ mutex [integer!] return: [integer!] ] SDL-lib "SDL_DestroyMutex" 

{ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }
{* @name Semaphore functions                                    } 
{ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }

{* The SDL semaphore structure, defined in SDL_sem.c }
{struct SDL_semaphore;
typedef struct SDL_semaphore SDL_sem;}

{* Create a semaphore, initialized with value, returns NULL on failure. }
SDL_CreateSemaphore: make routine! [ initial_value [integer!] return: [integer!] ] SDL-lib "SDL_CreateSemaphore" 

 {* Destroy a semaphore }
SDL_DestroySemaphore: make routine! [ sem [integer!] return: [integer!] ] SDL-lib "SDL_DestroySemaphore" 

 {*
 * This function suspends the calling thread until the semaphore pointed 
 * to by sem has a positive count. It then atomically decreases the semaphore
 * count.
 }
SDL_SemWait: make routine! [ sem [integer!] return: [integer!] ] SDL-lib "SDL_SemWait" 

 {* Non-blocking variant of SDL_SemWait().
 *  @return 0 if the wait succeeds,
 *  SDL_MUTEX_TIMEDOUT if the wait would block, and -1 on error.
 }
SDL_SemTryWait: make routine! [ sem [integer!] return: [integer!] ] SDL-lib "SDL_SemTryWait" 

{* Variant of SDL_SemWait() with a timeout in milliseconds, returns 0 if
 *  the wait succeeds, SDL_MUTEX_TIMEDOUT if the wait does not succeed in
 *  the allotted time, and -1 on error.
 *
 *  On some platforms this function is implemented by looping with a delay
 *  of 1 ms, and so should be avoided if possible.
 }
SDL_SemWaitTimeout: make routine! [ sem [integer!] ms [integer!] return: [integer!] ] SDL-lib "SDL_SemWaitTimeout" 

{* Atomically increases the semaphore's count (not blocking).
 *  @return 0, or -1 on error.
 }
SDL_SemPost: make routine! [ sem [integer!] return: [integer!] ] SDL-lib "SDL_SemPost" 

 {* Returns the current count of the semaphore }
SDL_SemValue: make routine! [ sem [integer!] return: [integer!] ] SDL-lib "SDL_SemValue" 

{ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }
{* @name Condition_variable_functions                           } 
{ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }

{* The SDL condition variable structure, defined in SDL_cond.c }
{struct SDL_cond;
typedef struct SDL_cond SDL_cond;}

{* Create a condition variable }
SDL_CreateCond: make routine! [ return: [integer!] ] SDL-lib "SDL_CreateCond" 

 {* Destroy a condition variable }
SDL_DestroyCond: make routine! [ cond [integer!] return: [integer!] ] SDL-lib "SDL_DestroyCond" 

 {* Restart one of the threads that are waiting on the condition variable,
 *  @return 0 or -1 on error.
 }
SDL_CondSignal: make routine! [ cond [integer!] return: [integer!] ] SDL-lib "SDL_CondSignal" 

 {* Restart all threads that are waiting on the condition variable,
 *  @return 0 or -1 on error.
 }
SDL_CondBroadcast: make routine! [ cond [integer!] return: [integer!] ] SDL-lib "SDL_CondBroadcast" 

 {* Wait on the condition variable, unlocking the provided mutex.
 *  The mutex must be locked before entering this function!
 *  The mutex is re-locked once the condition variable is signaled.
 *  @return 0 when it is signaled, or -1 on error.
 }
SDL_CondWait: make routine! [ cond [integer!] mut [integer!] return: [integer!] ] SDL-lib "SDL_CondWait" 

{* Waits for at most 'ms' milliseconds, and returns 0 if the condition
 *  variable is signaled, SDL_MUTEX_TIMEDOUT if the condition is not
 *  signaled in the allotted time, and -1 on error.
 *  On some platforms this function is implemented by looping with a delay
 *  of 1 ms, and so should be avoided if possible.
 }
SDL_CondWaitTimeout: make routine! [ cond [integer!] mutex [integer!] ms [integer!] return: [integer!] ] SDL-lib "SDL_CondWaitTimeout" 

SDL_NAME: func [X] [join "SDL_##" X]

{* @file SDL_quit.h
 *  Include file for SDL quit event handling
 }
{* @file SDL_quit.h
 *  An SDL_QUITEVENT is generated when the user tries to close the application
 *  window.  If it is ignored or filtered out, the window will remain open.
 *  If it is not ignored or filtered, it is queued normally and the window
 *  is allowed to close.  When the window is closed, screen updates will 
 *  complete, but have no effect.
 *
 *  SDL_Init() installs signal handlers for SIGINT (keyboard interrupt)
 *  and SIGTERM (system termination request), if handlers do not already
 *  exist, that generate SDL_QUITEVENT events as well.  There is no way
 *  to determine the cause of an SDL_QUITEVENT, but setting a signal
 *  handler in your application will override the default generation of
 *  quit events for that signal.
 }

{* @file SDL_quit.h
 *  There are no functions directly affecting the quit event 
 }
SDL_QuitRequested: func [] [SDL_PumpEvents    SDL_PeepEvents NULL 0 SDL_PEEKEVENT SDL_QUITMASK]  

{* @file SDL_rwops.h
 *  This file provides a general interface for SDL to read and write
 *  data sources.  It can easily be extended to files, memory, etc.
 }
{* This is the read/write operation structure -- very basic }

HAVE_STDIO_H: false

{typedef struct SDL_RWops ^{
    /** Seek to 'offset' relative to whence, one of stdio's whence values:
     *  SEEK_SET, SEEK_CUR, SEEK_END
     *  Returns the final offset in the data source.
     */
    int (SDLCALL *seek)(struct SDL_RWops *context, int offset, int whence);

    /* Read up to 'maxnum' objects each of size 'size' from the data
     *  source to the area pointed at by 'ptr'.
     *  Returns the number of objects read, or -1 if the read failed.
     */
    int (SDLCALL *read)(struct SDL_RWops *context, void *ptr, int size, int maxnum);

    /* Write exactly 'num' objects each of size 'objsize' from the area
     *  pointed at by 'ptr' to data source.
     *  Returns 'num', or -1 if the write failed.
     */
    int (SDLCALL *write)(struct SDL_RWops *context, const void *ptr, int size, int num);

    /* Close and free an allocated SDL_FSops structure */
    int (SDLCALL *close)(struct SDL_RWops *context);

    Uint32 type;
    union ^{
#if defined(__WIN32__) && !defined(__SYMBIAN32__)
        struct ^{
        int   append;
        void *h;
        struct ^{
            void *data;
            int size;
            int left;
        ^} buffer;
        ^} win32io;
#endif
#ifdef HAVE_STDIO_H 
        struct ^{
        int autoclose;
        FILE *fp;
        ^} stdio;
#endif
        struct ^{
        Uint8 *base;
        Uint8 *here;
        Uint8 *stop;
        ^} mem;
        struct ^{
        void *data1;
        ^} unknown;
    ^} hidden;

^} SDL_RWops;

}
{* @name Functions to create SDL_RWops structures from various data sources }
SDL_RWFromFile: make routine! [ file [string!] mode [string!] return: [integer!] ] SDL-lib "SDL_RWFromFile" 

if HAVE_STDIO_H [
SDL_RWFromFP: make routine! [ fp [integer!] autoclose [integer!] return: [integer!] ] SDL-lib "SDL_RWFromFP" 
]

SDL_RWFromMem: make routine! [ mem [integer!] size [integer!] return: [integer!] ] SDL-lib "SDL_RWFromMem" 
SDL_RWFromConstMem: make routine! [ mem [integer!] size [integer!] return: [integer!] ] SDL-lib "SDL_RWFromConstMem" 
SDL_AllocRW: make routine! [ return: [integer!] ] SDL-lib "SDL_AllocRW" 
SDL_FreeRW: make routine! [ area [integer!] return: [integer!] ] SDL-lib "SDL_FreeRW" 

{* @name Seek Reference Points }
RW_SEEK_SET:    0   {*< Seek from the beginning of data }
RW_SEEK_CUR:    1   {*< Seek relative to current read point }
RW_SEEK_END:    2   {*< Seek relative to the end of data }

{* @name Macros to easily read and write from an SDL_RWops structure }
SDL_RWseek: func [ctx  offset  whence]  [ctx/seek ctx  offset  whence]
SDL_RWtell: func [ctx] [ctx/seek ctx 0 RW_SEEK_CUR]
SDL_RWread: func [ctx ptr size n] [ctx/read ctx ptr size n]
SDL_RWwrite: func [ctx ptr size n] [ctx/write ctx ptr size n]
SDL_RWclose: func [ctx] [ctx/close ctx]

{* @name Read an item of the specified endianness and return in native format }
SDL_ReadLE16: make routine! [ src [integer!] return: [short] ] SDL-lib "SDL_ReadLE16" 
SDL_ReadBE16: make routine! [ src [integer!] return: [short] ] SDL-lib "SDL_ReadBE16" 
SDL_ReadLE32: make routine! [ src [integer!] return: [integer!] ] SDL-lib "SDL_ReadLE32" 
SDL_ReadBE32: make routine! [ src [integer!] return: [integer!] ] SDL-lib "SDL_ReadBE32" 
SDL_ReadLE64: make routine! [ src [integer!] return: [decimal!] ] SDL-lib "SDL_ReadLE64" 
SDL_ReadBE64: make routine! [ src [integer!] return: [decimal!] ] SDL-lib "SDL_ReadBE64" 
 
 {* @name Write an item of native format to the specified endianness }
 
SDL_WriteLE16: make routine! [ dst [integer!] value [short] return: [integer!] ] SDL-lib "SDL_WriteLE16" 
SDL_WriteBE16: make routine! [ dst [integer!] value [short] return: [integer!] ] SDL-lib "SDL_WriteBE16" 
SDL_WriteLE32: make routine! [ dst [integer!] value [integer!] return: [integer!] ] SDL-lib "SDL_WriteLE32" 
SDL_WriteBE32: make routine! [ dst [integer!] value [integer!] return: [integer!] ] SDL-lib "SDL_WriteBE32" 
SDL_WriteLE64: make routine! [ dst [integer!] value [decimal!] return: [integer!] ] SDL-lib "SDL_WriteLE64" 
SDL_WriteBE64: make routine! [ dst [integer!] value [decimal!] return: [integer!] ] SDL-lib "SDL_WriteBE64" 

{* The number of elements in an array }
SDL_arraysize: func [array] [(length? array) / length? first array]
SDL_TABLESIZE: func [table] [SDL_arraysize table] 

{* @name Basic data types }
SDL_FALSE: 0
SDL_TRUE: 1

SDL_bool: integer!;
{
typedef int8_t      Sint8;
typedef uint8_t     Uint8;
typedef int16_t     Sint16;
typedef uint16_t    Uint16;
typedef int32_t     Sint32;
typedef uint32_t    Uint32;
}

{#ifdef SDL_HAS_64BIT_TYPE
typedef int64_t     Sint64;
#ifndef SYMBIAN32_GCCE
typedef uint64_t    Uint64;
#endif
#else}
{ This is really just a hack to prevent the compiler from complaining }
{typedef struct {
    Uint32 hi;
    Uint32 lo;
} Uint64, Sint64;
#endif
}

{* @name Make sure the types really have the right sizes }

{#define SDL_COMPILE_TIME_ASSERT(name, x)               \
       typedef int SDL_dummy_ ## name[(x) * 2 - 1]

SDL_COMPILE_TIME_ASSERT(uint8, sizeof(Uint8) == 1);
SDL_COMPILE_TIME_ASSERT(sint8, sizeof(Sint8) == 1);
SDL_COMPILE_TIME_ASSERT(uint16, sizeof(Uint16) == 2);
SDL_COMPILE_TIME_ASSERT(sint16, sizeof(Sint16) == 2);
SDL_COMPILE_TIME_ASSERT(uint32, sizeof(Uint32) == 4);
SDL_COMPILE_TIME_ASSERT(sint32, sizeof(Sint32) == 4);
SDL_COMPILE_TIME_ASSERT(uint64, sizeof(Uint64) == 8);
SDL_COMPILE_TIME_ASSERT(sint64, sizeof(Sint64) == 8);}

size_t: integer!
{SDL_malloc: make routine! [ size [size_t] return: [integer!] ] SDL-lib "SDL_malloc" 
SDL_calloc: make routine! [ nmemb [size_t] size [size_t] return: [integer!] ] SDL-lib "SDL_calloc" 
SDL_realloc: make routine! [ mem [integer!] size [size_t] return: [integer!] ] SDL-lib "SDL_realloc" 
SDL_free: make routine! [ mem [integer!] return: [integer!] ] SDL-lib "SDL_free" 
SDL_stack_alloc: func [type  count]      [SDL_malloc (length? type) * count]  
SDL_stack_free: func [data] [SDL_free data] }

if system/version/4 = 3 [
SDL_getenv: make routine! [ name [string!] return: [string!] ] SDL-lib "SDL_getenv" 
SDL_putenv: make routine! [ variable [string!] return: [integer!] ] SDL-lib "SDL_putenv" 
]

{SDL_qsort: make routine! [ base [integer!] nmemb [size_t] size [size_t]
 compare [integer!] return: [integer!] ] SDL-lib "SDL_qsort"  ;int (*compare)(const void *, const void *));}

SDL_abs: :abs
SDL_min: :min
SDL_max: :max 
SDL_isdigit: func [X] [found? find charset "1234567890" any [X "-"]]
SDL_isspace: func [X] [found? find charset " ^-^/" any [X "-"]]
SDL_toupper: :uppercase
SDL_tolower: :lowercase
;SDL_memset: make routine! [ dst [integer!] c [integer!] len [size_t] return: [integer!] ] SDL-lib "SDL_memset" 
;SDL_memset4: :SDL_memset
{
#define SDL_memset4(dst, val, len)      \
do ^{                       \
    unsigned _count = (len);        \
    unsigned _n = (_count + 3) / 4;     \
    Uint32 *_p = SDL_static_cast(Uint32 *, dst);    \
    Uint32 _val = (val);            \
    if (len == 0) break;            \
        switch (_count % 4) ^{          \
        case 0: do {    *_p++ = _val;       \
        case 3:         *_p++ = _val;       \
        case 2:         *_p++ = _val;       \
        case 1:         *_p++ = _val;       \
        } while ( --_n );       \
    ^}                  \
^} while(0)


SDL_memcpy: make routine! [ dst [integer!] src [integer!] len [size_t] return: [integer!] ] SDL-lib "SDL_memcpy" 
SDL_memcpy4: func [dst src len] [SDL_memcpy dst src len * 4] 
SDL_revcpy: make routine! [ dst [integer!] src [integer!] len [size_t] return: [integer!] ] SDL-lib "SDL_revcpy" 

SDL_memmove: func [dst src len] [
 either dst < src [
  SDL_memcpy dst src len
 ] [
 SDL_revcpy dst src len
 ]
] 
}
;SDL_memcmp: make routine! [ s1 [integer!] s2 [integer!] len [size_t] return: [integer!] ] SDL-lib "SDL_memcmp" 
;SDL_strlen: make routine! [ string [string!] return: [size_t] ] SDL-lib "SDL_strlen" 
SDL_strlcpy: make routine! [ dst [string!] src [string!] maxlen [size_t] return: [size_t] ] SDL-lib "SDL_strlcpy" 
SDL_strlcat: make routine! [ dst [string!] src [string!] maxlen [size_t] return: [size_t] ] SDL-lib "SDL_strlcat" 
{
SDL_strdup: make routine! [ string [string!] return: [string!] ] SDL-lib "SDL_strdup" 
SDL_strrev: make routine! [ string [string!] return: [string!] ] SDL-lib "SDL_strrev" 
SDL_strupr: make routine! [ string [string!] return: [string!] ] SDL-lib "SDL_strupr" 
SDL_strlwr: make routine! [ string [string!] return: [string!] ] SDL-lib "SDL_strlwr" 
SDL_strchr: make routine! [ string [string!] c [integer!] return: [string!] ] SDL-lib "SDL_strchr" 
SDL_strrchr: make routine! [ string [string!] c [integer!] return: [string!] ] SDL-lib "SDL_strrchr" 
SDL_strstr: make routine! [ haystack [string!] needle [string!] return: [string!] ] SDL-lib "SDL_strstr" 
SDL_ltoa: make routine! [ value [integer!] string [string!] radix [integer!] return: [string!] ] SDL-lib "SDL_ltoa"
SDL_itoa: :SDL_ltoa 
SDL_ultoa: make routine! [ value [integer!] string [string!] radix [integer!] return: [string!] ] SDL-lib "SDL_ultoa" 
SDL_uitoa: :SDL_ultoa
SDL_strtol: make routine! [ string [string!] endp [string!] base [integer!] return: [integer!] ] SDL-lib "SDL_strtol" 
SDL_strtoul: make routine! [ string [string!] endp [string!] base [integer!] return: [integer!] ] SDL-lib "SDL_strtoul" 


if SDL_HAS_64BIT_TYPE > 0 [
SDL_lltoa: make routine! [ value [decimal!] string [string!] radix [integer!] return: [string!] ] SDL-lib "SDL_lltoa" 
SDL_ulltoa: make routine! [ value [decimal!] string [string!] radix [integer!] return: [string!] ] SDL-lib "SDL_ulltoa" 
SDL_strtoll: make routine! [ string [string!] endp [string!] base [integer!] return: [decimal!] ] SDL-lib "SDL_strtoll" 
SDL_strtoull: make routine! [ string [string!] endp [string!] base [integer!] return: [decimal!] ] SDL-lib "SDL_strtoull" 
] 
SDL_atoi: func [X] [SDL_strtol X 0 0] 
SDL_strtod: make routine! [ string [string!] endp [string!] return: [double] ] SDL-lib "SDL_strtod" 
SDL_atof: func [X] [SDL_strtod X 0] 
SDL_strcmp: make routine! [ str1 [string!] str2 [string!] return: [integer!] ] SDL-lib "SDL_strcmp" 
SDL_strncmp: make routine! [ str1 [string!] str2 [string!] maxlen [size_t] return: [integer!] ] SDL-lib "SDL_strncmp" 
SDL_strcasecmp: make routine! [ str1 [string!] str2 [string!] return: [integer!] ] SDL-lib "SDL_strcasecmp" 
SDL_strncasecmp: make routine! [ str1 [string!] str2 [string!] maxlen [size_t] return: [integer!] ] SDL-lib "SDL_strncasecmp" 
SDL_sscanf: make routine! [ text [string!] fmt [string!] return: [integer!] ] SDL-lib "SDL_sscanf" {,...} 
SDL_snprintf: make routine! [ text [string!] maxlen [size_t] fmt [string!] return: [integer!] ] SDL-lib "SDL_snprintf" {,...} 
SDL_vsnprintf: make routine! [ text [string!] maxlen [size_t] fmt [string!] ap [va_list] return: [integer!] ] SDL-lib "SDL_vsnprintf" 
}

{* @file SDL_version.h
 *  This header defines the current SDL version
 }

{* @name Version Number
 *  Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL
 }

SDL_MAJOR_VERSION:  1
SDL_MINOR_VERSION:  2
SDL_PATCHLEVEL:     14

SDL_version_: SDL_version: make struct! [
  major [char!]
  minor [char!]
  patch [char!]
] none ;

{*
 * This macro can be used to fill a version structure with the compile-time
 * version of the SDL library.
 }
SDL_VERSION: func [X]
[                                   
     X/major: SDL_MAJOR_VERSION                 
     X/minor: SDL_MINOR_VERSION                 
     X/patch: SDL_PATCHLEVEL                    
]

{* This macro turns the version numbers into a numeric value:
 *  (1,2,3) -> (1203)
 *  This assumes that there will never be more than 100 patchlevels
 }
SDL_VERSIONNUM: func [X Y Z] [X * 1000 + Y * 100 + Z]

{* This is the version number macro for the current SDL version }
SDL_COMPILEDVERSION: does [SDL_VERSIONNUM SDL_MAJOR_VERSION  SDL_MINOR_VERSION  SDL_PATCHLEVEL] 

{* This macro will evaluate to true if compiled with SDL at least X.Y.Z }
SDL_VERSION_ATLEAST: func [X  Y  Z]   [SDL_COMPILEDVERSION >= (SDL_VERSIONNUM X  Y  Z)]  

{* This function gets the version of the dynamically linked SDL library.
 *  it should NOT be used to fill a version structure, instead you should
 *  use the SDL_Version() macro.
 }
SDL_Linked_Version: make routine! [ return: [integer!] ] SDL-lib "SDL_Linked_Version" 

{* @name SDL_ICONV Error Codes
 *  The SDL implementation of iconv() returns these error codes 
 }
SDL_ICONV_ERROR:        -1
SDL_ICONV_E2BIG:        -2
SDL_ICONV_EILSEQ:   -3
SDL_ICONV_EINVAL:   -4

{
typedef struct _SDL_iconv_t *SDL_iconv_t;}
if system/version/4 = 3 [
SDL_iconv_open: make routine! [ tocode [string!] fromcode [string!] return: [integer!] ] SDL-lib "SDL_iconv_open" 
SDL_iconv_close: make routine! [ cd [integer!] return: [integer!] ] SDL-lib "SDL_iconv_close" 
]
SDL_iconv: make routine! [ cd [integer!] inbuf [integer!] inbytesleft [integer!] outbuf [integer!] outbytesleft [integer!] return: [size_t] ] SDL-lib "SDL_iconv" 
{* This function converts a string between encodings in one pass, returning a
 *  string that must be freed with SDL_free() or NULL on error.
 }
SDL_iconv_string: make routine! [ tocode [string!] fromcode [string!] inbuf [string!] inbytesleft [size_t] return: [string!] ] SDL-lib "SDL_iconv_string" 
SDL_iconv_utf8_locale: func [S] [SDL_iconv_string ""  "UTF-8"  S  SDL_strlen S + 1 ]
SDL_iconv_utf8_ucs2: func [S] [SDL_iconv_string "UCS-2"  "UTF-8"  S  SDL_strlen S + 1 ]
SDL_iconv_utf8_ucs4: func [S] [SDL_iconv_string "UCS-4"  "UTF-8"  S  SDL_strlen S + 1 ]

{
/* @file SDL_syswm.h
 *  Your application has access to a special type of event 'SDL_SYSWMEVENT',
 *  which contains window-manager specific information and arrives whenever
 *  an unhandled window event occurs.  This event is ignored by default, but
 *  you can enable it with SDL_EventState()
 */
#ifdef SDL_PROTOTYPES_ONLY
struct SDL_SysWMinfo;
typedef struct SDL_SysWMinfo SDL_SysWMinfo;
#else

/* This is the structure for custom window manager events */
#if defined(SDL_VIDEO_DRIVER_X11)
#if defined(__APPLE__) && defined(__MACH__)
/* conflicts with Quickdraw.h */
#define Cursor X11Cursor
#endif

#include <X11/Xlib.h>
#include <X11/Xatom.h>

#if defined(__APPLE__) && defined(__MACH__)
/* matches the re-define above */
#undef Cursor
#endif

/* These are the various supported subsystems under UNIX */
typedef enum ^{
    SDL_SYSWM_X11
^} SDL_SYSWM_TYPE;

/* The UNIX custom event structure */
struct SDL_SysWMmsg ^{
    SDL_version version;
    SDL_SYSWM_TYPE subsystem;
    union ^{
        XEvent xevent;
    ^} event;
^};

/* The UNIX custom window manager information structure.
 *  When this structure is returned, it holds information about which
 *  low level system it is using, and will be one of SDL_SYSWM_TYPE.
 */
typedef struct SDL_SysWMinfo ^{
    SDL_version version;
    SDL_SYSWM_TYPE subsystem;
    union ^{
        struct ^{
            Display *display;   /*< The X11 display */
            Window window;      /*< The X11 display window */
        /* These locking functions should be called around
                 *  any X11 functions using the display variable, 
                 *  but not the gfxdisplay variable.
                 *  They lock the event thread, so should not be
         *  called around event functions or from event filters.
         */
                
        void (*lock_func)();
        void (*unlock_func)();
                

        /* @name Introduced in SDL 1.0.2 */
                
            Window fswindow;    /*< The X11 fullscreen window */
            Window wmwindow;    /*< The X11 managed input window */
                

        /* @name Introduced in SDL 1.2.12 */
                
        Display *gfxdisplay;    /*< The X11 display to which rendering is done */
                
        ^} x11;
    ^} info;
^} SDL_SysWMinfo;

#elif defined(SDL_VIDEO_DRIVER_NANOX)
#include <microwin/nano-X.h>

/* The generic custom event structure */
struct SDL_SysWMmsg ^{
    SDL_version version;
    int data;
^};

/* The windows custom window manager information structure */
typedef struct SDL_SysWMinfo ^{
    SDL_version version ;
    GR_WINDOW_ID window ;   /* The display window */
^} SDL_SysWMinfo;

#elif defined(SDL_VIDEO_DRIVER_WINDIB) || defined(SDL_VIDEO_DRIVER_DDRAW) || defined(SDL_VIDEO_DRIVER_GAPI)
#define WIN32_LEAN_AND_MEAN
#include <windows.h>

/* The windows custom event structure */
struct SDL_SysWMmsg ^{
    SDL_version version;
    HWND hwnd;          /*< The window for the message */
    UINT msg;           /*< The type of message */
    WPARAM wParam;          /*< WORD message parameter */
    LPARAM lParam;          /*< LONG message parameter */
^};

/* The windows custom window manager information structure */
typedef struct SDL_SysWMinfo ^{
    SDL_version version;
    HWND window;            /*< The Win32 display window */
    HGLRC hglrc;            /*< The OpenGL context, if any */
^} SDL_SysWMinfo;


#else
}

{ The generic custom event structure }
SDL_SysWMmsg: make struct! [
  version [struct! [
  major [char!]
  minor [char!]
  patch [char!]
]]
  data [integer!]
] none ;

{ The generic custom window manager information structure }
SDL_SysWMinfo_: SDL_SysWMinfo: make struct! [
  version [struct! [
  major [char!]
  minor [char!]
  patch [char!]
]]
  data [integer!]
] none ;

{
#endif /* video driver type */

#endif /* SDL_PROTOTYPES_ONLY */

}



{*
 * This function gives you custom hooks into the window manager information.
 * It fills the structure pointed to by 'info' with custom information and
 * returns 1 if the function is implemented.  If it's not implemented, or
 * the version member of the 'info' structure is invalid, it returns 0. 
 *
 * You typically use this function like this:
 * @code
 * SDL_SysWMInfo info;
 * SDL_VERSION(&info.version);
 * if ( SDL_GetWMInfo(&info) ) { ... }
 * @endcode
 }
SDL_GetWMInfo: make routine! [ info [integer!] return: [integer!] ] SDL-lib "SDL_GetWMInfo" 

{* The SDL thread structure, defined in SDL_thread.c }
{struct SDL_Thread;
typedef struct SDL_Thread SDL_Thread;}

{* Create a thread }
{*
 *  We compile SDL into a DLL on OS/2. This means, that it's the DLL which
 *  creates a new thread for the calling process with the SDL_CreateThread()
 *  API. There is a problem with this, that only the RTL of the SDL.DLL will
 *  be initialized for those threads, and not the RTL of the calling application!
 *  To solve this, we make a little hack here.
 *  We'll always use the caller's _beginthread() and _endthread() APIs to
 *  start a new thread. This way, if it's the SDL.DLL which uses this API,
 *  then the RTL of SDL.DLL will be used to create the new thread, and if it's
 *  the application, then the RTL of the application will be used.
 *  So, in short:
 *  Always use the _beginthread() and _endthread() of the calling runtime library!
 }
SDL_CreateThread: make routine! [ fn [integer!] data [integer!] return: [integer!] ] SDL-lib "SDL_CreateThread" 

{* Get the 32-bit thread identifier for the current thread }
SDL_ThreadID: make routine! [ return: [integer!] ] SDL-lib "SDL_ThreadID" 

 {* Get the 32-bit thread identifier for the specified thread,
 *  equivalent to SDL_ThreadID() if the specified thread is NULL.
 }
SDL_GetThreadID: make routine! [ thread [integer!] return: [integer!] ] SDL-lib "SDL_GetThreadID" 

 {* Wait for a thread to finish.
 *  The return code for the thread function is placed in the area
 *  pointed to by 'status', if 'status' is not NULL.
 }
SDL_WaitThread: make routine! [ thread [integer!] status [integer!] return: [integer!] ] SDL-lib "SDL_WaitThread" 

 {* Forcefully kill a thread without worrying about its state }
SDL_KillThread: make routine! [ thread [integer!] return: [integer!] ] SDL-lib "SDL_KillThread" 

{* @file SDL_timer.h
 *  Header for the SDL time management routines
 }
{* This is the OS scheduler timeslice, in milliseconds }
SDL_TIMESLICE:      10

{* This is the maximum resolution of the SDL timer on all platforms }
TIMER_RESOLUTION:   10  {*< Experimentally determined }

{*
 * Get the number of milliseconds since the SDL library initialization.
 * Note that this value wraps if the program runs for more than ~49 days.
 } 
SDL_GetTicks: make routine! [ return: [integer!] ] SDL-lib "SDL_GetTicks" 

 {* Wait a specified number of milliseconds before returning }
SDL_Delay: make routine! [ ms [integer!] return: [integer!] ] SDL-lib "SDL_Delay" 

{* Function prototype for the timer callback function }
{typedef Uint32 (SDLCALL *SDL_TimerCallback)(Uint32 interval);}

{*
 * Set a callback to run after the specified number of milliseconds has
 * elapsed. The callback function is passed the current timer interval
 * and returns the next timer interval.  If the returned value is the 
 * same as the one passed in, the periodic alarm continues, otherwise a
 * new alarm is scheduled.  If the callback returns 0, the periodic alarm
 * is cancelled.
 *
 * To cancel a currently running timer, call SDL_SetTimer(0, NULL);
 *
 * The timer callback function may run in a different thread than your
 * main code, and so shouldn't call any functions from within itself.
 *
 * The maximum resolution of this timer is 10 ms, which means that if
 * you request a 16 ms timer, your callback will run approximately 20 ms
 * later on an unloaded system.  If you wanted to set a flag signaling
 * a frame update at 30 frames per second (every 33 ms), you might set a 
 * timer for 30 ms:
 *   @code SDL_SetTimer((33/10)*10, flag_update); @endcode
 *
 * If you use this function, you need to pass SDL_INIT_TIMER to SDL_Init().
 *
 * Under UNIX, you should not use raise or use SIGALRM and this function
 * in the same program, as it is implemented using setitimer().  You also
 * should not use this function in multi-threaded applications as signals
 * to multi-threaded apps have undefined behavior in some implementations.
 *
 * This function returns 0 if successful, or -1 if there was an error.
 }
SDL_SetTimer: make routine! [ interval [integer!] callback [integer!] return: [integer!] ] SDL-lib "SDL_SetTimer" 

{* @name New timer API
 * New timer API, supports multiple timers
 * Written by Stephane Peter <%megastep--lokigames--com>
 }
{*
 * Function prototype for the new timer callback function.
 * The callback function is passed the current timer interval and returns
 * the next timer interval.  If the returned value is the same as the one
 * passed in, the periodic alarm continues, otherwise a new alarm is
 * scheduled.  If the callback returns 0, the periodic alarm is cancelled.
 }
{typedef Uint32 (SDLCALL *SDL_NewTimerCallback)(Uint32 interval, void *param);}

{* Definition of the timer ID type }
{typedef struct _SDL_TimerID *SDL_TimerID;}

{* Add a new timer to the pool of timers already running.
 *  Returns a timer ID, or NULL when an error occurs.
 }
SDL_AddTimer: make routine! [ interval [integer!] callback [integer!] param [integer!] return: [integer!] ] SDL-lib "SDL_AddTimer" 

 {*
 * Remove one of the multiple timers knowing its ID.
 * Returns a boolean value indicating success.
 }
SDL_RemoveTimer: make routine! [ t [integer!] return: [SDL_bool] ] SDL-lib "SDL_RemoveTimer" 

{* @name Transparency definitions
 *  These define alpha as the opacity of a surface
 }

SDL_ALPHA_OPAQUE: 255
SDL_ALPHA_TRANSPARENT: 0


{* Available for SDL_SetVideoMode() }
SDL_ANYFORMAT:  268435456   {*< Allow any video depth/pixel-format }
SDL_HWPALETTE:  536870912   {*< Surface has exclusive palette }
SDL_DOUBLEBUF:  1073741824  {*< Set up double-buffered video mode }
SDL_FULLSCREEN: -2147483648 {*< Surface is a full screen display }
SDL_OPENGL:      2      {*< Create an OpenGL rendering context }
SDL_OPENGLBLIT: 10  {*< Create an OpenGL rendering context and use it for blitting }
SDL_RESIZABLE:  16  {*< This video mode may be resized }
SDL_NOFRAME:    32  {*< No window caption or edge frame }

{* Used internally (read-only) }
SDL_HWACCEL:    256 {*< Blit uses hardware acceleration }
SDL_SRCCOLORKEY:    4096    {*< Blit uses a source color key }
SDL_RLEACCELOK: 8192    {*< Private flag }
SDL_RLEACCEL:   16384   {*< Surface is RLE encoded }
SDL_SRCALPHA:   65536   {*< Blit uses source alpha blending }
SDL_PREALLOC:   16777216    {*< Surface uses preallocated memory }

{* Evaluates to true if the surface needs to be locked before access }
SDL_MUSTLOCK: func [surface] [any[surface/offset ((surface/flags and (SDL_HWSURFACE or SDL_ASYNCBLIT or SDL_RLEACCEL)) )]]

{* typedef for private surface blitting functions }
{typedef int (*SDL_blit)(struct SDL_Surface *src, SDL_Rect *srcrect,
            struct SDL_Surface *dst, SDL_Rect *dstrect);}

{* Useful for determining the video hardware capabilities }
SDL_hw_available: 1 {*< Flag: Can you create hardware surfaces? }
SDL_wm_available: 2 {*< Flag: Can you talk to a window manager? }
SDL_UnusedBits1:  0 {6 bits}
SDL_UnusedBits2:  256
SDL_blit_hw:      512 {*< Flag: Accelerated blits HW --> HW }
SDL_blit_hw_CC:   1024 {*< Flag: Accelerated blits with Colorkey }
SDL_blit_hw_A:    2048 {*< Flag: Accelerated blits with Alpha }
SDL_blit_sw:      4096 {*< Flag: Accelerated blits SW --> HW }
SDL_blit_sw_CC:   8192 {*< Flag: Accelerated blits with Colorkey }
SDL_blit_sw_A:    16384 {*< Flag: Accelerated blits with Alpha }
SDL_blit_fill:    327768 {*< Flag: Accelerated color fill }
SDL_VideoInfo_: SDL_VideoInfo: make struct! [
  Bits [short]
  UnusedBits3 [short] {:16;}
  video_mem [integer!] {*< The total amount of video memory (in K) }
  vfmt [integer!] {*< Value: The format of the video surface }
  current_w [integer!] {*< Value: The current video mode width }
  current_h [integer!] {*< Value: The current video mode height }
] none ;

{* @name Overlay Formats
 *  The most common video overlay formats.
 *  For an explanation of these pixel formats, see:
 *  http:;www.webartz.com/fourcc/indexyuv.htm
 *
 *  For information on the relationship between color spaces, see:
 *  http:;www.neuro.sfc.keio.ac.jp/~aly/polygon/info/color-space-faq.html
 }
SDL_YV12_OVERLAY:  842094169    {*< Planar mode: Y + V + U  (3 planes) }
SDL_IYUV_OVERLAY:  1448433993   {*< Planar mode: Y + U + V  (3 planes) }
SDL_YUY2_OVERLAY:  844715353    {*< Packed mode: Y0+U0+Y1+V0 (1 plane) }
SDL_UYVY_OVERLAY:  1498831189   {*< Packed mode: U0+Y0+V0+Y1 (1 plane) }
SDL_YVYU_OVERLAY:  1431918169   {*< Packed mode: Y0+V0+Y1+U0 (1 plane) }

{* The YUV hardware video overlay }
SDL_Overlay_: SDL_Overlay: make struct! [
  format [integer!] {*< Read-only }
  w [integer!]  h [integer!] {*< Read-only }
  planes [integer!] {*< Read-only }
  pitches [integer!] {*< Read-only }
  pixels [integer!] {*< Read-write }

 {* @name Hardware-specific surface info }
  hwfuncs [integer!]
  hwdata [integer!]

 {* @name Special flags }
 {Uint32 hw_overlay :1;} {*< Flag: This overlay hardware accelerated? }
 {Uint32 UnusedBits :31;}
  hw_overlay [integer!]
 
] none ;

{* Public enumeration for setting the OpenGL window attributes. }
SDL_GL_RED_SIZE: 0
SDL_GL_GREEN_SIZE: 1
SDL_GL_BLUE_SIZE: 2
SDL_GL_ALPHA_SIZE: 3
SDL_GL_BUFFER_SIZE: 4
SDL_GL_DOUBLEBUFFER: 5
SDL_GL_DEPTH_SIZE: 6
SDL_GL_STENCIL_SIZE: 7
SDL_GL_ACCUM_RED_SIZE: 8
SDL_GL_ACCUM_GREEN_SIZE: 9
SDL_GL_ACCUM_BLUE_SIZE: 10
SDL_GL_ACCUM_ALPHA_SIZE: 11
SDL_GL_STEREO: 12
SDL_GL_MULTISAMPLEBUFFERS: 13
SDL_GL_MULTISAMPLESAMPLES: 14
SDL_GL_ACCELERATED_VISUAL: 15
SDL_GL_SWAP_CONTROL: 16

SDL_GLattr: integer!;

{* @name flags for SDL_SetPalette() }
SDL_LOGPAL: 1
SDL_PHYSPAL: 2

{*
 * @name Video Init and Quit
 * These functions are used internally, and should not be used unless you
 * have a specific need to specify the video driver you want to use.
 * You should normally use SDL_Init() or SDL_InitSubSystem().
 }
{*
 * Initializes the video subsystem. Sets up a connection
 * to the window manager, etc, and determines the current video mode and
 * pixel format, but does not initialize a window or graphics mode.
 * Note that event handling is activated by this routine.
 *
 * If you use both sound and video in your application, you need to call
 * SDL_Init() before opening the sound device, otherwise under Win32 DirectX,
 * you won't be able to set full-screen display modes.
 }
SDL_VideoInit: make routine! [ driver_name [string!] flags [integer!] return: [integer!] ] SDL-lib "SDL_VideoInit" 
SDL_VideoQuit: make routine! [ return: [integer!] ] SDL-lib "SDL_VideoQuit" 
 
 {*
 * This function fills the given character buffer with the name of the
 * video driver, and returns a pointer to it if the video driver has
 * been initialized.  It returns NULL if no driver has been initialized.
 }
SDL_VideoDriverName: make routine! [ namebuf [string!] maxlen [integer!] return: [string!] ] SDL-lib "SDL_VideoDriverName" 

 {*
 * This function returns a pointer to the current display surface.
 * If SDL is doing format conversion on the display surface, this
 * function returns the publicly visible surface, not the real video
 * surface.
 }
SDL_GetVideoSurface: make routine! [ return: [integer!] ] SDL-lib "SDL_GetVideoSurface" 

 {*
 * This function returns a read-only pointer to information about the
 * video hardware.  If this is called before SDL_SetVideoMode(), the 'vfmt'
 * member of the returned structure will contain the pixel format of the
 * "best" video mode.
 }
SDL_GetVideoInfo: make routine! [ return: [integer!] ] SDL-lib "SDL_GetVideoInfo" 

 {*
 * Check to see if a particular video mode is supported.
 * It returns 0 if the requested mode is not supported under any bit depth,
 * or returns the bits-per-pixel of the closest available mode with the
 * given width and height.  If this bits-per-pixel is different from the
 * one used when setting the video mode, SDL_SetVideoMode() will succeed,
 * but will emulate the requested bits-per-pixel with a shadow surface.
 *
 * The arguments to SDL_VideoModeOK() are the same ones you would pass to
 * SDL_SetVideoMode()
 }
SDL_VideoModeOK: make routine! [ width [integer!] height [integer!] bpp [integer!] flags [integer!] return: [integer!] ] SDL-lib "SDL_VideoModeOK" 

{*
 * Return a pointer to an array of available screen dimensions for the
 * given format and video flags, sorted largest to smallest.  Returns 
 * NULL if there are no dimensions available for a particular format, 
 * or (SDL_Rect **)-1 if any dimension is okay for the given format.
 *
 * If 'format' is NULL, the mode list will be for the format given 
 * by SDL_GetVideoInfo()->vfmt
 }
SDL_ListModes: make routine! [ format [integer!] flags [integer!] return: [integer!] ] SDL-lib "SDL_ListModes" 

{*
 * Set up a video mode with the specified width, height and bits-per-pixel.
 *
 * If 'bpp' is 0, it is treated as the current display bits per pixel.
 *
 * If SDL_ANYFORMAT is set in 'flags', the SDL library will try to set the
 * requested bits-per-pixel, but will return whatever video pixel format is
 * available.  The default is to emulate the requested pixel format if it
 * is not natively available.
 *
 * If SDL_HWSURFACE is set in 'flags', the video surface will be placed in
 * video memory, if possible, and you may have to call SDL_LockSurface()
 * in order to access the raw framebuffer.  Otherwise, the video surface
 * will be created in system memory.
 *
 * If SDL_ASYNCBLIT is set in 'flags', SDL will try to perform rectangle
 * updates asynchronously, but you must always lock before accessing pixels.
 * SDL will wait for updates to complete before returning from the lock.
 *
 * If SDL_HWPALETTE is set in 'flags', the SDL library will guarantee
 * that the colors set by SDL_SetColors() will be the colors you get.
 * Otherwise, in 8-bit mode, SDL_SetColors() may not be able to set all
 * of the colors exactly the way they are requested, and you should look
 * at the video surface structure to determine the actual palette.
 * If SDL cannot guarantee that the colors you request can be set, 
 * i.e. if the colormap is shared, then the video surface may be created
 * under emulation in system memory, overriding the SDL_HWSURFACE flag.
 *
 * If SDL_FULLSCREEN is set in 'flags', the SDL library will try to set
 * a fullscreen video mode.  The default is to create a windowed mode
 * if the current graphics system has a window manager.
 * If the SDL library is able to set a fullscreen video mode, this flag 
 * will be set in the surface that is returned.
 *
 * If SDL_DOUBLEBUF is set in 'flags', the SDL library will try to set up
 * two surfaces in video memory and swap between them when you call 
 * SDL_Flip().  This is usually slower than the normal single-buffering
 * scheme, but prevents "tearing" artifacts caused by modifying video 
 * memory while the monitor is refreshing.  It should only be used by 
 * applications that redraw the entire screen on every update.
 *
 * If SDL_RESIZABLE is set in 'flags', the SDL library will allow the
 * window manager, if any, to resize the window at runtime.  When this
 * occurs, SDL will send a SDL_VIDEORESIZE event to you application,
 * and you must respond to the event by re-calling SDL_SetVideoMode()
 * with the requested size (or another size that suits the application).
 *
 * If SDL_NOFRAME is set in 'flags', the SDL library will create a window
 * without any title bar or frame decoration.  Fullscreen video modes have
 * this flag set automatically.
 *
 * This function returns the video framebuffer surface, or NULL if it fails.
 *
 * If you rely on functionality provided by certain video flags, check the
 * flags of the returned surface to make sure that functionality is available.
 * SDL will fall back to reduced functionality if the exact flags you wanted
 * are not available.
 }
SDL_SetVideoMode: make routine! [
 width [integer!] height [integer!] bpp [integer!] flags [integer!] return: [integer!] ] SDL-lib "SDL_SetVideoMode" 

{* @name SDL_Update Functions
 * These functions should not be called while 'screen' is locked.
 }
{*
 * Makes sure the given list of rectangles is updated on the given screen.
 }
SDL_UpdateRects: make routine! [
 screen [integer!] numrects [integer!] rects [integer!] return: [integer!] ] SDL-lib "SDL_UpdateRects" 
 {*
 * If 'x', 'y', 'w' and 'h' are all 0, SDL_UpdateRect will update the entire
 * screen.
 }
SDL_UpdateRect: make routine! [
 screen [integer!] x [integer!] y [integer!] w [integer!] h [integer!] return: [integer!] ] SDL-lib "SDL_UpdateRect" 
 
 {*
 * On hardware that supports double-buffering, this function sets up a flip
 * and returns.  The hardware will wait for vertical retrace, and then swap
 * video buffers before the next video surface blit or lock will return.
 * On hardware that doesn not support double-buffering, this is equivalent
 * to calling SDL_UpdateRect(screen, 0, 0, 0, 0);
 * The SDL_DOUBLEBUF flag must have been passed to SDL_SetVideoMode() when
 * setting the video mode for this function to perform hardware flipping.
 * This function returns 0 if successful, or -1 if there was an error.
 }
SDL_Flip: make routine! [ screen [integer!] return: [integer!] ] SDL-lib "SDL_Flip" 

{*
 * Set the gamma correction for each of the color channels.
 * The gamma values range (approximately) between 0.1 and 10.0
 * 
 * If this function isn't supported directly by the hardware, it will
 * be emulated using gamma ramps, if available.  If successful, this
 * function returns 0, otherwise it returns -1.
 }
SDL_SetGamma: make routine! [ red [float] green [float] blue [float] return: [integer!] ] SDL-lib "SDL_SetGamma" 

 {*
 * Set the gamma translation table for the red, green, and blue channels
 * of the video hardware.  Each table is an array of 256 16-bit quantities,
 * representing a mapping between the input and output for that channel.
 * The input is the index into the array, and the output is the 16-bit
 * gamma value at that index, scaled to the output color precision.
 * 
 * You may pass NULL for any of the channels to leave it unchanged.
 * If the call succeeds, it will return 0.  If the display driver or
 * hardware does not support gamma translation, or otherwise fails,
 * this function will return -1.
 }
SDL_SetGammaRamp: make routine! [ red [integer!] green [integer!] blue [integer!] return: [integer!] ] SDL-lib "SDL_SetGammaRamp" 

 {*
 * Retrieve the current values of the gamma translation tables.
 * 
 * You must pass in valid pointers to arrays of 256 16-bit quantities.
 * Any of the pointers may be NULL to ignore that channel.
 * If the call succeeds, it will return 0.  If the display driver or
 * hardware does not support gamma translation, or otherwise fails,
 * this function will return -1.
 }
SDL_GetGammaRamp: make routine! [ red [integer!] green [integer!] blue [integer!] return: [integer!] ] SDL-lib "SDL_GetGammaRamp" 

{*
 * Sets a portion of the colormap for the given 8-bit surface.  If 'surface'
 * is not a palettized surface, this function does nothing, returning 0.
 * If all of the colors were set as passed to SDL_SetColors(), it will
 * return 1.  If not all the color entries were set exactly as given,
 * it will return 0, and you should look at the surface palette to
 * determine the actual color palette.
 *
 * When 'surface' is the surface associated with the current display, the
 * display colormap will be updated with the requested colors.  If 
 * SDL_HWPALETTE was set in SDL_SetVideoMode() flags, SDL_SetColors()
 * will always return 1, and the palette is guaranteed to be set the way
 * you desire, even if the window colormap has to be warped or run under
 * emulation.
 }
SDL_SetColors: make routine! [ surface [integer!]
 colors [integer!] firstcolor [integer!] ncolors [integer!] return: [integer!] ] SDL-lib "SDL_SetColors" 

 {*
 * Sets a portion of the colormap for a given 8-bit surface.
 * 'flags' is one or both of:
 * SDL_LOGPAL  -- set logical palette, which controls how blits are mapped
 *                to/from the surface,
 * SDL_PHYSPAL -- set physical palette, which controls how pixels look on
 *                the screen
 * Only screens have physical palettes. Separate change of physical/logical
 * palettes is only possible if the screen has SDL_HWPALETTE set.
 *
 * The return value is 1 if all colours could be set as requested, and 0
 * otherwise.
 *
 * SDL_SetColors() is equivalent to calling this function with
 *     flags = (SDL_LOGPAL|SDL_PHYSPAL).
 }
SDL_SetPalette: make routine! [ surface [integer!] flags [integer!]
 colors [integer!] firstcolor [integer!]
 ncolors [integer!] return: [integer!] ] SDL-lib "SDL_SetPalette" 

{*
 * Maps an RGB triple to an opaque pixel value for a given pixel format
 }
SDL_MapRGB: make routine! [
 format [integer!]
 r [char!] g [char!] b [char!] return: [integer!] ] SDL-lib "SDL_MapRGB" 

 {*
 * Maps an RGBA quadruple to a pixel value for a given pixel format
 }
SDL_MapRGBA: make routine! [
 format [integer!]
 r [char!] g [char!] b [char!] a [char!] return: [integer!] ] SDL-lib "SDL_MapRGBA" 

{*
 * Maps a pixel value into the RGB components for a given pixel format
 }
SDL_GetRGB: make routine! [ pixel [integer!]
 fmt [struct! []]
 r [struct! []] g [struct! []] b [struct! []] return: [integer!] ] SDL-lib "SDL_GetRGB" 

 {*
 * Maps a pixel value into the RGBA components for a given pixel format
 }
SDL_GetRGBA: make routine! [ pixel [integer!]
 fmt [struct! []]
 r [struct! []] g [struct! []] b [struct! []] a [struct! []] return: [integer!] ] SDL-lib "SDL_GetRGBA" 

{* @sa SDL_CreateRGBSurface }
{*
 * Allocate and free an RGB surface (must be called after SDL_SetVideoMode)
 * If the depth is 4 or 8 bits, an empty palette is allocated for the surface.
 * If the depth is greater than 8 bits, the pixel format is set using the
 * flags '[RGB]mask'.
 * If the function runs out of memory, it will return NULL.
 *
 * The 'flags' tell what kind of surface to create.
 * SDL_SWSURFACE means that the surface should be created in system memory.
 * SDL_HWSURFACE means that the surface should be created in video memory,
 * with the same format as the display surface.  This is useful for surfaces
 * that will not change much, to take advantage of hardware acceleration
 * when being blitted to the display surface.
 * SDL_ASYNCBLIT means that SDL will try to perform asynchronous blits with
 * this surface, but you must always lock it before accessing the pixels.
 * SDL will wait for current blits to finish before returning from the lock.
 * SDL_SRCCOLORKEY indicates that the surface will be used for colorkey blits.
 * If the hardware supports acceleration of colorkey blits between
 * two surfaces in video memory, SDL will try to place the surface in
 * video memory. If this isn't possible or if there is no hardware
 * acceleration available, the surface will be placed in system memory.
 * SDL_SRCALPHA means that the surface will be used for alpha blits and 
 * if the hardware supports hardware acceleration of alpha blits between
 * two surfaces in video memory, to place the surface in video memory
 * if possible, otherwise it will be placed in system memory.
 * If the surface is created in video memory, blits will be _much_ faster,
 * but the surface format must be identical to the video surface format,
 * and the only way to access the pixels member of the surface is to use
 * the SDL_LockSurface() and SDL_UnlockSurface() calls.
 * If the requested surface actually resides in video memory, SDL_HWSURFACE
 * will be set in the flags member of the returned surface.  If for some
 * reason the surface could not be placed in video memory, it will not have
 * the SDL_HWSURFACE flag set, and will be created in system memory instead.
 }
SDL_CreateRGBSurface: make routine! [
 flags [integer!] width [integer!] height [integer!] depth [integer!]
 Rmask [integer!] Gmask [integer!] Bmask [integer!] Amask [integer!] return: [integer!] ] SDL-lib "SDL_CreateRGBSurface" 
 {* @sa SDL_CreateRGBSurface }
SDL_CreateRGBSurfaceFrom: make routine! [ pixels [integer!]
 width [integer!] height [integer!] depth [integer!] pitch [integer!]
 Rmask [integer!] Gmask [integer!] Bmask [integer!] Amask [integer!] return: [integer!] ] SDL-lib "SDL_CreateRGBSurfaceFrom" 
SDL_FreeSurface: make routine! [ surface [integer!] return: [integer!] ] SDL-lib "SDL_FreeSurface" 

SDL_AllocSurface:    :SDL_CreateRGBSurface

{*
 * SDL_LockSurface() sets up a surface for directly accessing the pixels.
 * Between calls to SDL_LockSurface()/SDL_UnlockSurface(), you can write
 * to and read from 'surface->pixels', using the pixel format stored in 
 * 'surface->format'.  Once you are done accessing the surface, you should 
 * use SDL_UnlockSurface() to release it.
 *
 * Not all surfaces require locking.  If SDL_MUSTLOCK(surface) evaluates
 * to 0, then you can read and write to the surface at any time, and the
 * pixel format of the surface will not change.  In particular, if the
 * SDL_HWSURFACE flag is not given when calling SDL_SetVideoMode(), you
 * will not need to lock the display surface before accessing it.
 * 
 * No operating system or library calls should be made between lock/unlock
 * pairs, as critical system locks may be held during this time.
 *
 * SDL_LockSurface() returns 0, or -1 if the surface couldn't be locked.
 }
SDL_LockSurface: make routine! [ surface [integer!] return: [integer!] ] SDL-lib "SDL_LockSurface" 
SDL_UnlockSurface: make routine! [ surface [integer!] return: [integer!] ] SDL-lib "SDL_UnlockSurface" 

 {*
 * Load a surface from a seekable SDL data source (memory or file.)
 * If 'freesrc' is non-zero, the source will be closed after being read.
 * Returns the new surface, or NULL if there was an error.
 * The new surface should be freed with SDL_FreeSurface().
 }
SDL_LoadBMP_RW: make routine! [ src [integer!] freesrc [integer!] return: [integer!] ] SDL-lib "SDL_LoadBMP_RW" 

{* Convenience macro -- load a surface from a file }
SDL_LoadBMP: func [file] [SDL_LoadBMP_RW SDL_RWFromFile file "rb" 1]

{*
 * Save a surface to a seekable SDL data source (memory or file.)
 * If 'freedst' is non-zero, the source will be closed after being written.
 * Returns 0 if successful or -1 if there was an error.
 }
SDL_SaveBMP_RW: make routine! [
 surface [integer!] dst [integer!] freedst [integer!] return: [integer!] ] SDL-lib "SDL_SaveBMP_RW" 

{* Convenience macro -- save a surface to a file }
SDL_SaveBMP: func [surface file] [SDL_SaveBMP_RW surface SDL_RWFromFile file "wb" 1]

{*
 * Sets the color key (transparent pixel) in a blittable surface.
 * If 'flag' is SDL_SRCCOLORKEY (optionally OR'd with SDL_RLEACCEL), 
 * 'key' will be the transparent pixel in the source image of a blit.
 * SDL_RLEACCEL requests RLE acceleration for the surface if present,
 * and removes RLE acceleration if absent.
 * If 'flag' is 0, this function clears any current color key.
 * This function returns 0, or -1 if there was an error.
 }
SDL_SetColorKey: make routine! [
 surface [integer!] flag [integer!] key [integer!] return: [integer!] ] SDL-lib "SDL_SetColorKey" 

 {*
 * This function sets the alpha value for the entire surface, as opposed to
 * using the alpha component of each pixel. This value measures the range
 * of transparency of the surface, 0 being completely transparent to 255
 * being completely opaque. An 'alpha' value of 255 causes blits to be
 * opaque, the source pixels copied to the destination (the default). Note
 * that per-surface alpha can be combined with colorkey transparency.
 *
 * If 'flag' is 0, alpha blending is disabled for the surface.
 * If 'flag' is SDL_SRCALPHA, alpha blending is enabled for the surface.
 * OR:ing the flag with SDL_RLEACCEL requests RLE acceleration for the
 * surface; if SDL_RLEACCEL is not specified, the RLE accel will be removed.
 *
 * The 'alpha' parameter is ignored for surfaces that have an alpha channel.
 }
SDL_SetAlpha: make routine! [ surface [integer!] flag [integer!] alpha [char!] return: [integer!] ] SDL-lib "SDL_SetAlpha" 

 {*
 * Sets the clipping rectangle for the destination surface in a blit.
 *
 * If the clip rectangle is NULL, clipping will be disabled.
 * If the clip rectangle doesn't intersect the surface, the function will
 * return SDL_FALSE and blits will be completely clipped.  Otherwise the
 * function returns SDL_TRUE and blits to the surface will be clipped to
 * the intersection of the surface area and the clipping rectangle.
 *
 * Note that blits are automatically clipped to the edges of the source
 * and destination surfaces.
 }
SDL_SetClipRect: make routine! [ surface [integer!] rect [integer!] return: [SDL_bool] ] SDL-lib "SDL_SetClipRect" 

{*
 * Gets the clipping rectangle for the destination surface in a blit.
 * 'rect' must be a pointer to a valid rectangle which will be filled
 * with the correct values.
 }
SDL_GetClipRect: make routine! [ surface [integer!] rect [integer!] return: [integer!] ] SDL-lib "SDL_GetClipRect" 

 {*
 * Creates a new surface of the specified format, and then copies and maps 
 * the given surface to it so the blit of the converted surface will be as 
 * fast as possible.  If this function fails, it returns NULL.
 *
 * The 'flags' parameter is passed to SDL_CreateRGBSurface() and has those 
 * semantics.  You can also pass SDL_RLEACCEL in the flags parameter and
 * SDL will try to RLE accelerate colorkey and alpha blits in the resulting
 * surface.
 *
 * This function is used internally by SDL_DisplayFormat().
 }
SDL_ConvertSurface: make routine! [
 src [integer!] fmt [integer!] flags [integer!] return: [integer!] ] SDL-lib "SDL_ConvertSurface" 

{*
 * This performs a fast blit from the source surface to the destination
 * surface.  It assumes that the source and destination rectangles are
 * the same size.  If either 'srcrect' or 'dstrect' are NULL, the entire
 * surface (src or dst) is copied.  The final blit rectangles are saved
 * in 'srcrect' and 'dstrect' after all clipping is performed.
 * If the blit is successful, it returns 0, otherwise it returns -1.
 *
 * The blit function should not be called on a locked surface.
 *
 * The blit semantics for surfaces with and without alpha and colorkey
 * are defined as follows:
 *
 * RGBA->RGB:
 *     SDL_SRCALPHA set:
 *  alpha-blend (using alpha-channel).
 *  SDL_SRCCOLORKEY ignored.
 *     SDL_SRCALPHA not set:
 *  copy RGB.
 *  if SDL_SRCCOLORKEY set, only copy the pixels matching the
 *  RGB values of the source colour key, ignoring alpha in the
 *  comparison.
 * 
 * RGB->RGBA:
 *     SDL_SRCALPHA set:
 *  alpha-blend (using the source per-surface alpha value);
 *  set destination alpha to opaque.
 *     SDL_SRCALPHA not set:
 *  copy RGB, set destination alpha to source per-surface alpha value.
 *     both:
 *  if SDL_SRCCOLORKEY set, only copy the pixels matching the
 *  source colour key.
 * 
 * RGBA->RGBA:
 *     SDL_SRCALPHA set:
 *  alpha-blend (using the source alpha channel) the RGB values;
 *  leave destination alpha untouched. [Note: is this correct?]
 *  SDL_SRCCOLORKEY ignored.
 *     SDL_SRCALPHA not set:
 *  copy all of RGBA to the destination.
 *  if SDL_SRCCOLORKEY set, only copy the pixels matching the
 *  RGB values of the source colour key, ignoring alpha in the
 *  comparison.
 * 
 * RGB->RGB: 
 *     SDL_SRCALPHA set:
 *  alpha-blend (using the source per-surface alpha value).
 *     SDL_SRCALPHA not set:
 *  copy RGB.
 *     both:
 *  if SDL_SRCCOLORKEY set, only copy the pixels matching the
 *  source colour key.
 *
 * If either of the surfaces were in video memory, and the blit returns -2,
 * the video memory was lost, so it should be reloaded with artwork and 
 * re-blitted:
 * @code
 *  while ( SDL_BlitSurface(image, imgrect, screen, dstrect) == -2 ) {
 *      while ( SDL_LockSurface(image) < 0 )
 *          Sleep(10);
 *      -- Write image pixels to image->pixels --
 *      SDL_UnlockSurface(image);
 *  }
 * @endcode
 *
 * This happens under DirectX 5.0 when the system switches away from your
 * fullscreen application.  The lock will also fail until you have access
 * to the video memory again.
 *
 * You should call SDL_BlitSurface() unless you know exactly how SDL
 * blitting works internally and how to use the other blit functions.
 }

{* This is the public blit function, SDL_BlitSurface(), and it performs
 *  rectangle validation and clipping before passing it to SDL_LowerBlit()
 }
SDL_UpperBlit: make routine! [
 src [integer!] srcrect [integer!]
 dst [integer!] dstrect [integer!] return: [integer!] ] SDL-lib "SDL_UpperBlit" 
 {* This is a semi-private blit function and it performs low-level surface
 *  blitting only.
 }
SDL_LowerBlit: make routine! [
 src [integer!] srcrect [integer!]
 dst [integer!] dstrect [integer!] return: [integer!] ] SDL-lib "SDL_LowerBlit" 

SDL_BlitSurface: :SDL_UpperBlit

{*
 * This function performs a fast fill of the given rectangle with 'color'
 * The given rectangle is clipped to the destination surface clip area
 * and the final fill rectangle is saved in the passed in pointer.
 * If 'dstrect' is NULL, the whole surface will be filled with 'color'
 * The color should be a pixel of the format used by the surface, and 
 * can be generated by the SDL_MapRGB() function.
 * This function returns 0 on success, or -1 on error.
 }
SDL_FillRect: make routine! [
 dst [integer!] dstrect [integer!] color [integer!] return: [integer!] ] SDL-lib "SDL_FillRect" 

 {*
 * This function takes a surface and copies it to a new surface of the
 * pixel format and colors of the video framebuffer, suitable for fast
 * blitting onto the display surface.  It calls SDL_ConvertSurface()
 *
 * If you want to take advantage of hardware colorkey or alpha blit
 * acceleration, you should set the colorkey and alpha value before
 * calling this function.
 *
 * If the conversion fails or runs out of memory, it returns NULL
 }
SDL_DisplayFormat: make routine! [ surface [integer!] return: [integer!] ] SDL-lib "SDL_DisplayFormat" 

{*
 * This function takes a surface and copies it to a new surface of the
 * pixel format and colors of the video framebuffer (if possible),
 * suitable for fast alpha blitting onto the display surface.
 * The new surface will always have an alpha channel.
 *
 * If you want to take advantage of hardware colorkey or alpha blit
 * acceleration, you should set the colorkey and alpha value before
 * calling this function.
 *
 * If the conversion fails or runs out of memory, it returns NULL
 }
SDL_DisplayFormatAlpha: make routine! [ surface [integer!] return: [integer!] ] SDL-lib "SDL_DisplayFormatAlpha" 

 { * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }
 {* @name YUV video surface overlay functions                                } 
 { * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }

 {* This function creates a video output overlay
 *  Calling the returned surface an overlay is something of a misnomer because
 *  the contents of the display surface underneath the area where the overlay
 *  is shown is undefined - it may be overwritten with the converted YUV data.
 }
SDL_CreateYUVOverlay: make routine! [ width [integer!] height [integer!]
 format [integer!] display [integer!] return: [integer!] ] SDL-lib "SDL_CreateYUVOverlay" 

 {* Lock an overlay for direct access, and unlock it when you are done }
SDL_LockYUVOverlay: make routine! [ overlay [integer!] return: [integer!] ] SDL-lib "SDL_LockYUVOverlay" 
SDL_UnlockYUVOverlay: make routine! [ overlay [integer!] return: [integer!] ] SDL-lib "SDL_UnlockYUVOverlay" 

{* Blit a video overlay to the display surface.
 *  The contents of the video surface underneath the blit destination are
 *  not defined.  
 *  The width and height of the destination rectangle may be different from
 *  that of the overlay, but currently only 2x scaling is supported.
 }
SDL_DisplayYUVOverlay: make routine! [ overlay [integer!] dstrect [integer!] return: [integer!] ] SDL-lib "SDL_DisplayYUVOverlay" 

 {* Free a video overlay }
SDL_FreeYUVOverlay: make routine! [ overlay [integer!] return: [integer!] ] SDL-lib "SDL_FreeYUVOverlay" 

{ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }
{* @name OpenGL support functions.                                          } 
{ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }
{*
 * Dynamically load an OpenGL library, or the default one if path is NULL
 *
 * If you do this, you need to retrieve all of the GL functions used in
 * your program from the dynamic library using SDL_GL_GetProcAddress().
 }
SDL_GL_LoadLibrary: make routine! [ path [string!] return: [integer!] ] SDL-lib "SDL_GL_LoadLibrary" 

{*
 * Get the address of a GL function
 }
SDL_GL_GetProcAddress: make routine! [ proc [string!] return: [integer!] ] SDL-lib "SDL_GL_GetProcAddress" 

 {*
 * Set an attribute of the OpenGL subsystem before intialization.
 }
SDL_GL_SetAttribute: make routine! [ attr [SDL_GLattr] value [integer!] return: [integer!] ] SDL-lib "SDL_GL_SetAttribute" 

{*
 * Get an attribute of the OpenGL subsystem from the windowing
 * interface, such as glX. This is of course different from getting
 * the values from SDL's internal OpenGL subsystem, which only
 * stores the values you request before initialization.
 *
 * Developers should track the values they pass into SDL_GL_SetAttribute
 * themselves if they want to retrieve these values.
 }
SDL_GL_GetAttribute: make routine! [ attr [SDL_GLattr] value [integer!] return: [integer!] ] SDL-lib "SDL_GL_GetAttribute" 

 {*
 * Swap the OpenGL buffers, if double-buffering is supported.
 }
SDL_GL_SwapBuffers: make routine! [ return: [integer!] ] SDL-lib "SDL_GL_SwapBuffers" 

 {* @name OpenGL Internal Functions
 * Internal functions that should not be called unless you have read
 * and understood the source code for these functions.
 }
 
SDL_GL_UpdateRects: make routine! [ numrects [integer!] rects [integer!] return: [integer!] ] SDL-lib "SDL_GL_UpdateRects" 
SDL_GL_Lock: make routine! [ return: [integer!] ] SDL-lib "SDL_GL_Lock" 
SDL_GL_Unlock: make routine! [ return: [integer!] ] SDL-lib "SDL_GL_Unlock" 

{ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }
{* @name Window Manager Functions                                           }
{* These functions allow interaction with the window manager, if any.       } 
{ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }

{*
 * Sets the title and icon text of the display window (UTF-8 encoded)
 }
SDL_WM_SetCaption: make routine! [ title [string!] icon [string!] return: [integer!] ] SDL-lib "SDL_WM_SetCaption" 
{*
 * Gets the title and icon text of the display window (UTF-8 encoded)
 }
SDL_WM_GetCaption: make routine! [ title [struct! []] icon [struct! []] return: [integer!] ] SDL-lib "SDL_WM_GetCaption" 

{*
 * Sets the icon for the display window.
 * This function must be called before the first call to SDL_SetVideoMode().
 * It takes an icon surface, and a mask in MSB format.
 * If 'mask' is NULL, the entire icon surface will be used as the icon.
 }
SDL_WM_SetIcon: make routine! [ icon [integer!] mask [integer!] return: [integer!] ] SDL-lib "SDL_WM_SetIcon" 

 {*
 * This function iconifies the window, and returns 1 if it succeeded.
 * If the function succeeds, it generates an SDL_APPACTIVE loss event.
 * This function is a noop and returns 0 in non-windowed environments.
 }
SDL_WM_IconifyWindow: make routine! [ return: [integer!] ] SDL-lib "SDL_WM_IconifyWindow" 

{*
 * Toggle fullscreen mode without changing the contents of the screen.
 * If the display surface does not require locking before accessing
 * the pixel information, then the memory pointers will not change.
 *
 * If this function was able to toggle fullscreen mode (change from 
 * running in a window to fullscreen, or vice-versa), it will return 1.
 * If it is not implemented, or fails, it returns 0.
 *
 * The next call to SDL_SetVideoMode() will set the mode fullscreen
 * attribute based on the flags parameter - if SDL_FULLSCREEN is not
 * set, then the display will be windowed by default where supported.
 *
 * This is currently only implemented in the X11 video driver.
 }
SDL_WM_ToggleFullScreen: make routine! [ surface [integer!] return: [integer!] ] SDL-lib "SDL_WM_ToggleFullScreen" 

SDL_GRAB_QUERY: -1
SDL_GRAB_OFF: 0
SDL_GRAB_ON: 1
 {*< Used internally }
SDL_GRAB_FULLSCREEN: 2 {*< Used internally }
 {*< Used internally }
SDL_GrabMode: integer!;
{*
 * This function allows you to set and query the input grab state of
 * the application.  It returns the new input grab state.
 *
 * Grabbing means that the mouse is confined to the application window,
 * and nearly all keyboard input is passed directly to the application,
 * and not interpreted by a window manager, if any.
 }
SDL_WM_GrabInput: make routine! [ mode [SDL_GrabMode] return: [SDL_GrabMode] ] SDL-lib "SDL_WM_GrabInput" 

 {* @internal Not in public API at the moment - do not use! }
SDL_SoftStretch: make routine! [ src [integer!] srcrect [integer!]
 dst [integer!] dstrect [integer!] return: [integer!] ] SDL-lib "SDL_SoftStretch" 


;comment[ ;uncomment this and comment next line to comment example code
context [

    {===============================================================================================}

    { Test the SDL CD-ROM audio functions }

    { Call this instead of exit(), so we can clean up SDL: atexit() is evil. }
    quit*: func [rc] 
    [
        SDL_Quit
        halt
        quit/return rc 
    ]

    PrintStatus: func [driveindex &cdrom /local cdrom status status_str m s f] 
    [
        status: SDL_CDStatus &cdrom 
        cdrom: addr-to-struct &cdrom SDL_CD ;REBOL-NOTE: function defined at the beginning
        switch (status) reduce [
            CD_TRAYEMPTY
                [status_str: "tray empty"]
                
            CD_STOPPED
                [status_str: "stopped"]
                
            CD_PLAYING
                [status_str: "playing"]
                
            CD_PAUSED
                [status_str: "paused"]
                
            CD_ERROR
                [status_str: "error state"]
                
        ]
        print ["Drive" driveindex "status:" status_str] 
        if ( status >= CD_PLAYING ) [
            
            FRAMES_TO_MSF cdrom/cur_frame 'm 's 'f 
            print rejoin ["Currently playing track " to-integer cdrom/(track- cdrom/cur_track 'id) ", " m ":" round/to s 0.01]  
        ]
    ]

    ListTracks: func [&cdrom /local cdrom i m s f trtype]
    [
        SDL_CDStatus &cdrom 
        cdrom: addr-to-struct &cdrom SDL_CD
        print ["Drive tracks:" cdrom/numtracks] 
        for  i 0 (cdrom/numtracks - 1) 1 [
            FRAMES_TO_MSF cdrom/(track- i 'length) 'm 's 'f 
            if ( f > 0 ) [
                s: s + 1
            ]
            switch/default to-integer cdrom/(track- i 'type) reduce
            [
                SDL_AUDIO_TRACK
                [trtype: "audio"]           

                SDL_DATA_TRACK
                [trtype: "data"]
            ][          
                [trtype: "unknown"]
            ]
            print rejoin ["^-Track (index " i ") " to-integer cdrom/(track- i 'id) ": " m ":" round/to s 0.01 " / " cdrom/(track- i 'length) " [" trtype " track]"]
        ]
    ]

    do PrintUsage: does
    [
        print "Usage:"
        print "Write one of:"
        print " -drive <number>"
        print " -status"
        print " -list"
        print " -play first_track first_frame num_tracks num_frames"
        print " -pause"
        print " -resume"
        print " -stop"
        print " -eject"
        print " -sleep <milliseconds>"
        print " -quit"
    ]

    ; main
    do
    [
        drive: 0
        i: 0
        cdrom: 0 ;SDL_CD *

        { Initialize SDL first }
        if ( (SDL_Init SDL_INIT_CDROM) < 0 ) [
            print ["Couldn't initialize SDL:" SDL_GetError]
            halt
            ;return 1 
        ]

        { Find out how many CD-ROM drives are connected to the system }
        if ( SDL_CDNumDrives = 0 ) [
            print "No CD-ROM devices detected" 
            quit* 0
        ]
        print ["Drives available:" SDL_CDNumDrives]   
        for i 0 (SDL_CDNumDrives - 1) 1 [
            print rejoin ["Drive " i {: "} SDL_CDName i {"}]
        ]
        { Open the CD-ROM }
        drive: 0
        cdrom: SDL_CDOpen drive 
        if cdrom = 0   [
            print ["Couldn't open drive" drive ":" SDL_GetError]   
            quit* 2 
        ]
        print "Current drive: 0"
        
        { Find out which function to perform }
        until [
            prin "?:" ;REBOL-NOTE: prompt
            argv: input
            argv: parse argv none
            
            case [
                (argv/1 = "-drive") and SDL_isdigit argv/2 [
                    drive: to-integer argv/2
                    cdrom: SDL_CDOpen drive 
                    if cdrom = 0   [
                        print ["Couldn't open drive" drive ":" SDL_GetError]   
                        quit* 2 
                    ]
                ]
                ( argv/1 = "-status") [
                    PrintStatus drive cdrom
                ]
                ( argv/1 = "-list") [
                    ListTracks cdrom
                ]
                ( argv/1 = "-play") [
                    use [
                    strack sframe
                    ntrack nframe
                    ][
                    i: 2
                    strack: 0
                    if ( SDL_isdigit argv/:i ) [
                        strack: to-integer argv/:i i: i + 1
                    ]
                    sframe: 0
                    if ( SDL_isdigit argv/:i ) [
                        sframe: to-integer argv/:i i: i + 1
                    ]
                    ntrack: 0
                    if ( SDL_isdigit argv/:i ) [
                        ntrack: to-integer argv/:i i: i + 1
                    ]
                    nframe: 0
                    if ( SDL_isdigit argv/:i ) [
                        nframe: to-integer argv/:i i: i + 1
                    ]
                    either ( CD_INDRIVE SDL_CDStatus cdrom ) [
                        if ( SDL_CDPlayTracks cdrom strack sframe
                                    ntrack nframe) < 0 [
                            print rejoin [
                    "Couldn't play tracks " strack "/" sframe " for " ntrack "/" nframe ": " SDL_GetError
                            ]
                        ]
                    ] [
                        print "No CD in drive!"
                    ]
                    ] ;use
                ]
                ( argv/1 = "-pause" ) [
                    if ( SDL_CDPause cdrom) < 0 [
                        print ["Couldn't pause CD:" SDL_GetError]
                    ]
                ]
                ( argv/1 = "-resume") [
                    if ( SDL_CDResume cdrom) < 0 [
                        print ["Couldn't resume CD:" SDL_GetError]
                    ]
                ]
                ( argv/1 = "-stop") [
                    if ( SDL_CDStop cdrom) < 0 [
                        print ["Couldn't stop CD:" SDL_GetError]
                    ]
                ]
                ( argv/1 = "-eject") [
                    if ( SDL_CDEject cdrom ) < 0 [
                        print ["Couldn't eject CD:" SDL_GetError]
                    ]
                ]
                ( argv/1 = "-sleep") and SDL_isdigit argv/2 [
                    SDL_Delay argv/2
                    print ["Delayed" argv/2 "milliseconds"]
                ]
                ( argv/1 = "-quit" ) [
                ]
                (true) [
                    PrintUsage
                ]
            ] ;{case} 

            argv/1 = "-quit"
        ] ; until
        PrintStatus drive cdrom 
        SDL_CDClose cdrom 

        SDL_Quit  

        0 
    ]
    free SDL-lib
    halt
]
Notes
email address(es) have been munged to protect them from spam harvesters. If you are a Library member, you can log on and view this script without the munging.
(megastep:lokigames:com)
(slouken:libsdl:org)