ryujinx/SDL
1
0
Fork 0
mirror of https://github.com/Ryujinx/SDL.git synced 2025-05-02 14:36:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

Updated source to match SDL function prototype style

Browse source
This commit is contained in:
Sam Lantinga 2023-05-23 10:59:03 -07:00
parent 92f72682e7
commit 3f1fd5abff
243 changed files with 1218 additions and 2364 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
src/SDL.c
View file

@ -442,8 +442,7 @@ void SDL_QuitSubSystem(Uint32 flags)
#endif #endif
} }
Uint32 Uint32 SDL_WasInit(Uint32 flags)
SDL_WasInit(Uint32 flags)
{ {
int i; int i;
int num_subsystems = SDL_arraysize(SDL_SubsystemRefCount); int num_subsystems = SDL_arraysize(SDL_SubsystemRefCount);
@ -531,22 +530,19 @@ void SDL_GetVersion(SDL_version *ver)
} }
/* Get the library source revision */ /* Get the library source revision */
const char * const char *SDL_GetRevision(void)
SDL_GetRevision(void)
{ {
return SDL_REVISION; return SDL_REVISION;
} }
/* Get the library source revision number */ /* Get the library source revision number */
int int SDL_GetRevisionNumber(void)
SDL_GetRevisionNumber(void)
{ {
return 0; /* doesn't make sense without Mercurial. */ return 0; /* doesn't make sense without Mercurial. */
} }
/* Get the name of the platform */ /* Get the name of the platform */
const char * const char *SDL_GetPlatform(void)
SDL_GetPlatform(void)
{ {
#if __AIX__ #if __AIX__
return "AIX"; return "AIX";
@ -619,8 +615,7 @@ SDL_GetPlatform(void)
#endif #endif
} }
SDL_bool SDL_bool SDL_IsTablet(void)
SDL_IsTablet(void)
{ {
#if __ANDROID__ #if __ANDROID__
extern SDL_bool SDL_IsAndroidTablet(void); extern SDL_bool SDL_IsAndroidTablet(void);
@ -638,9 +633,7 @@ SDL_IsTablet(void)
#if (!defined(HAVE_LIBC) || defined(__WATCOMC__)) && !defined(SDL_STATIC_LIB) #if (!defined(HAVE_LIBC) || defined(__WATCOMC__)) && !defined(SDL_STATIC_LIB)
/* Need to include DllMain() on Watcom C for some reason.. */ /* Need to include DllMain() on Watcom C for some reason.. */
BOOL APIENTRY BOOL APIENTRY _DllMainCRTStartup(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
_DllMainCRTStartup(HANDLE hModule,
DWORD ul_reason_for_call, LPVOID lpReserved)
{ {
switch (ul_reason_for_call) { switch (ul_reason_for_call) {
case DLL_PROCESS_ATTACH: case DLL_PROCESS_ATTACH:

4
src/SDL_assert.c
View file

@ -326,9 +326,7 @@ static SDL_assert_state SDLCALL SDL_PromptAssertion(const SDL_assert_data *data,
return state; return state;
} }
SDL_assert_state SDL_assert_state SDL_ReportAssertion(SDL_assert_data *data, const char *func, const char *file, int line)
SDL_ReportAssertion(SDL_assert_data *data, const char *func, const char *file,
int line)
{ {
SDL_assert_state state = SDL_ASSERTION_IGNORE; SDL_assert_state state = SDL_ASSERTION_IGNORE;
static int assertion_running = 0; static int assertion_running = 0;

6
src/SDL_dataqueue.c
View file

@ -50,8 +50,7 @@ static void SDL_FreeDataQueueList(SDL_DataQueuePacket *packet)
} }
} }
SDL_DataQueue * SDL_DataQueue *SDL_NewDataQueue(const size_t _packetlen, const size_t initialslack)
SDL_NewDataQueue(const size_t _packetlen, const size_t initialslack)
{ {
SDL_DataQueue *queue = (SDL_DataQueue *)SDL_calloc(1, sizeof(SDL_DataQueue)); SDL_DataQueue *queue = (SDL_DataQueue *)SDL_calloc(1, sizeof(SDL_DataQueue));
@ -316,8 +315,7 @@ SDL_CountDataQueue(SDL_DataQueue *queue)
return retval; return retval;
} }
SDL_mutex * SDL_mutex *SDL_GetDataQueueMutex(SDL_DataQueue *queue)
SDL_GetDataQueueMutex(SDL_DataQueue *queue)
{ {
return queue ? queue->lock : NULL; return queue ? queue->lock : NULL;
} }

6
src/SDL_error.c
View file

@ -61,8 +61,7 @@ int SDL_SetError(SDL_PRINTF_FORMAT_STRING const char *fmt, ...)
} }
/* Available for backwards compatibility */ /* Available for backwards compatibility */
const char * const char *SDL_GetError(void)
SDL_GetError(void)
{ {
const SDL_error *error = SDL_GetErrBuf(); const SDL_error *error = SDL_GetErrBuf();
return error->error ? error->str : ""; return error->error ? error->str : "";
@ -108,8 +107,7 @@ int main(int argc, char *argv[])
} }
#endif #endif
char * char *SDL_GetErrorMsg(char *errstr, int maxlen)
SDL_GetErrorMsg(char *errstr, int maxlen)
{ {
const SDL_error *error = SDL_GetErrBuf(); const SDL_error *error = SDL_GetErrBuf();

19
src/SDL_hints.c
View file

@ -45,9 +45,7 @@ typedef struct SDL_Hint
static SDL_Hint *SDL_hints; static SDL_Hint *SDL_hints;
SDL_bool SDL_bool SDL_SetHintWithPriority(const char *name, const char *value, SDL_HintPriority priority)
SDL_SetHintWithPriority(const char *name, const char *value,
SDL_HintPriority priority)
{ {
const char *env; const char *env;
SDL_Hint *hint; SDL_Hint *hint;
@ -97,8 +95,7 @@ SDL_SetHintWithPriority(const char *name, const char *value,
return SDL_TRUE; return SDL_TRUE;
} }
SDL_bool SDL_bool SDL_ResetHint(const char *name)
SDL_ResetHint(const char *name)
{ {
const char *env; const char *env;
SDL_Hint *hint; SDL_Hint *hint;
@ -154,14 +151,12 @@ void SDL_ResetHints(void)
} }
} }
SDL_bool SDL_bool SDL_SetHint(const char *name, const char *value)
SDL_SetHint(const char *name, const char *value)
{ {
return SDL_SetHintWithPriority(name, value, SDL_HINT_NORMAL); return SDL_SetHintWithPriority(name, value, SDL_HINT_NORMAL);
} }
const char * const char *SDL_GetHint(const char *name)
SDL_GetHint(const char *name)
{ {
const char *env; const char *env;
SDL_Hint *hint; SDL_Hint *hint;
@ -178,8 +173,7 @@ SDL_GetHint(const char *name)
return env; return env;
} }
SDL_bool SDL_bool SDL_GetStringBoolean(const char *value, SDL_bool default_value)
SDL_GetStringBoolean(const char *value, SDL_bool default_value)
{ {
if (value == NULL || !*value) { if (value == NULL || !*value) {
return default_value; return default_value;
@ -190,8 +184,7 @@ SDL_GetStringBoolean(const char *value, SDL_bool default_value)
return SDL_TRUE; return SDL_TRUE;
} }
SDL_bool SDL_bool SDL_GetHintBoolean(const char *name, SDL_bool default_value)
SDL_GetHintBoolean(const char *name, SDL_bool default_value)
{ {
const char *hint = SDL_GetHint(name); const char *hint = SDL_GetHint(name);
return SDL_GetStringBoolean(hint, default_value); return SDL_GetStringBoolean(hint, default_value);

3
src/SDL_log.c
View file

@ -154,8 +154,7 @@ void SDL_LogSetPriority(int category, SDL_LogPriority priority)
} }
} }
SDL_LogPriority SDL_LogPriority SDL_LogGetPriority(int category)
SDL_LogGetPriority(int category)
{ {
SDL_LogLevel *entry; SDL_LogLevel *entry;

12
src/atomic/SDL_atomic.c
View file

@ -124,8 +124,7 @@ static SDL_INLINE void leaveLock(void *a)
} }
#endif #endif
SDL_bool SDL_bool SDL_AtomicCAS(SDL_atomic_t *a, int oldval, int newval)
SDL_AtomicCAS(SDL_atomic_t *a, int oldval, int newval)
{ {
#ifdef HAVE_MSC_ATOMICS #ifdef HAVE_MSC_ATOMICS
SDL_COMPILE_TIME_ASSERT(atomic_cas, sizeof(long) == sizeof(a->value)); SDL_COMPILE_TIME_ASSERT(atomic_cas, sizeof(long) == sizeof(a->value));
@ -154,8 +153,7 @@ SDL_AtomicCAS(SDL_atomic_t *a, int oldval, int newval)
#endif #endif
} }
SDL_bool SDL_bool SDL_AtomicCASPtr(void **a, void *oldval, void *newval)
SDL_AtomicCASPtr(void **a, void *oldval, void *newval)
{ {
#if defined(HAVE_MSC_ATOMICS) #if defined(HAVE_MSC_ATOMICS)
return _InterlockedCompareExchangePointer(a, newval, oldval) == oldval; return _InterlockedCompareExchangePointer(a, newval, oldval) == oldval;
@ -205,8 +203,7 @@ int SDL_AtomicSet(SDL_atomic_t *a, int v)
#endif #endif
} }
void * void *SDL_AtomicSetPtr(void **a, void *v)
SDL_AtomicSetPtr(void **a, void *v)
{ {
#if defined(HAVE_MSC_ATOMICS) #if defined(HAVE_MSC_ATOMICS)
return _InterlockedExchangePointer(a, v); return _InterlockedExchangePointer(a, v);
@ -272,8 +269,7 @@ int SDL_AtomicGet(SDL_atomic_t *a)
#endif #endif
} }
void * void *SDL_AtomicGetPtr(void **a)
SDL_AtomicGetPtr(void **a)
{ {
#ifdef HAVE_ATOMIC_LOAD_N #ifdef HAVE_ATOMIC_LOAD_N
return __atomic_load_n(a, __ATOMIC_SEQ_CST); return __atomic_load_n(a, __ATOMIC_SEQ_CST);

3
src/atomic/SDL_spinlock.c
View file

@ -61,8 +61,7 @@ extern __inline int _SDL_xchg_watcom(volatile int *a, int v);
/* *INDENT-ON* */ /* clang-format on */ /* *INDENT-ON* */ /* clang-format on */
/* This function is where all the magic happens... */ /* This function is where all the magic happens... */
SDL_bool SDL_bool SDL_AtomicTryLock(SDL_SpinLock *lock)
SDL_AtomicTryLock(SDL_SpinLock *lock)
{ {
#if SDL_ATOMIC_DISABLED #if SDL_ATOMIC_DISABLED
/* Terrible terrible damage */ /* Terrible terrible damage */

33
src/audio/SDL_audio.c
View file

@ -603,8 +603,7 @@ int SDL_QueueAudio(SDL_AudioDeviceID devid, const void *data, Uint32 len)
return rc; return rc;
} }
Uint32 Uint32 SDL_DequeueAudio(SDL_AudioDeviceID devid, void *data, Uint32 len)
SDL_DequeueAudio(SDL_AudioDeviceID devid, void *data, Uint32 len)
{ {
SDL_AudioDevice *device = get_audio_device(devid); SDL_AudioDevice *device = get_audio_device(devid);
Uint32 rc; Uint32 rc;
@ -622,8 +621,7 @@ SDL_DequeueAudio(SDL_AudioDeviceID devid, void *data, Uint32 len)
return rc; return rc;
} }
Uint32 Uint32 SDL_GetQueuedAudioSize(SDL_AudioDeviceID devid)
SDL_GetQueuedAudioSize(SDL_AudioDeviceID devid)
{ {
Uint32 retval = 0; Uint32 retval = 0;
SDL_AudioDevice *device = get_audio_device(devid); SDL_AudioDevice *device = get_audio_device(devid);
@ -904,8 +902,7 @@ int SDL_GetNumAudioDrivers(void)
return SDL_arraysize(bootstrap) - 1; return SDL_arraysize(bootstrap) - 1;
} }
const char * const char *SDL_GetAudioDriver(int index)
SDL_GetAudioDriver(int index)
{ {
if (index >= 0 && index < SDL_GetNumAudioDrivers()) { if (index >= 0 && index < SDL_GetNumAudioDrivers()) {
return bootstrap[index]->name; return bootstrap[index]->name;
@ -1012,8 +1009,7 @@ int SDL_AudioInit(const char *driver_name)
/* /*
* Get the current audio driver name * Get the current audio driver name
*/ */
const char * const char *SDL_GetCurrentAudioDriver()
SDL_GetCurrentAudioDriver()
{ {
return current_audio.name; return current_audio.name;
} }
@ -1073,8 +1069,7 @@ int SDL_GetNumAudioDevices(int iscapture)
return retval; return retval;
} }
const char * const char *SDL_GetAudioDeviceName(int index, int iscapture)
SDL_GetAudioDeviceName(int index, int iscapture)
{ {
SDL_AudioDeviceItem *item; SDL_AudioDeviceItem *item;
int i; int i;
@ -1191,8 +1186,7 @@ static void close_audio_device(SDL_AudioDevice *device)
SDL_free(device); SDL_free(device);
} }
static Uint16 static Uint16 GetDefaultSamplesFromFreq(int freq)
GetDefaultSamplesFromFreq(int freq)
{ {
/* Pick a default of ~46 ms at desired frequency */ /* Pick a default of ~46 ms at desired frequency */
/* !!! FIXME: remove this when the non-Po2 resampling is in. */ /* !!! FIXME: remove this when the non-Po2 resampling is in. */
@ -1560,8 +1554,7 @@ int SDL_OpenAudio(SDL_AudioSpec *desired, SDL_AudioSpec *obtained)
return (id == 0) ? -1 : 0; return (id == 0) ? -1 : 0;
} }
SDL_AudioDeviceID SDL_AudioDeviceID SDL_OpenAudioDevice(const char *device, int iscapture,
SDL_OpenAudioDevice(const char *device, int iscapture,
const SDL_AudioSpec *desired, SDL_AudioSpec *obtained, const SDL_AudioSpec *desired, SDL_AudioSpec *obtained,
int allowed_changes) int allowed_changes)
{ {
@ -1569,8 +1562,7 @@ SDL_OpenAudioDevice(const char *device, int iscapture,
allowed_changes, 2); allowed_changes, 2);
} }
SDL_AudioStatus SDL_AudioStatus SDL_GetAudioDeviceStatus(SDL_AudioDeviceID devid)
SDL_GetAudioDeviceStatus(SDL_AudioDeviceID devid)
{ {
SDL_AudioDevice *device = get_audio_device(devid); SDL_AudioDevice *device = get_audio_device(devid);
SDL_AudioStatus status = SDL_AUDIO_STOPPED; SDL_AudioStatus status = SDL_AUDIO_STOPPED;
@ -1584,8 +1576,7 @@ SDL_GetAudioDeviceStatus(SDL_AudioDeviceID devid)
return status; return status;
} }
SDL_AudioStatus SDL_AudioStatus SDL_GetAudioStatus(void)
SDL_GetAudioStatus(void)
{ {
return SDL_GetAudioDeviceStatus(1); return SDL_GetAudioDeviceStatus(1);
} }
@ -1697,8 +1688,7 @@ static SDL_AudioFormat format_list[NUM_FORMATS][NUM_FORMATS] = {
AUDIO_S16LSB, AUDIO_U16MSB, AUDIO_U16LSB, AUDIO_U8, AUDIO_S8 }, AUDIO_S16LSB, AUDIO_U16MSB, AUDIO_U16LSB, AUDIO_U8, AUDIO_S8 },
}; };
SDL_AudioFormat SDL_AudioFormat SDL_FirstAudioFormat(SDL_AudioFormat format)
SDL_FirstAudioFormat(SDL_AudioFormat format)
{ {
for (format_idx = 0; format_idx < NUM_FORMATS; ++format_idx) { for (format_idx = 0; format_idx < NUM_FORMATS; ++format_idx) {
if (format_list[format_idx][0] == format) { if (format_list[format_idx][0] == format) {
@ -1709,8 +1699,7 @@ SDL_FirstAudioFormat(SDL_AudioFormat format)
return SDL_NextAudioFormat(); return SDL_NextAudioFormat();
} }
SDL_AudioFormat SDL_AudioFormat SDL_NextAudioFormat(void)
SDL_NextAudioFormat(void)
{ {
if ((format_idx == NUM_FORMATS) || (format_idx_sub == NUM_FORMATS)) { if ((format_idx == NUM_FORMATS) || (format_idx_sub == NUM_FORMATS)) {
return 0; return 0;

3
src/audio/SDL_audiocvt.c
View file

@ -1005,8 +1005,7 @@ static void SDL_CleanupAudioStreamResampler(SDL_AudioStream *stream)
SDL_free(stream->resampler_state); SDL_free(stream->resampler_state);
} }
SDL_AudioStream * SDL_AudioStream *SDL_NewAudioStream(const SDL_AudioFormat src_format,
SDL_NewAudioStream(const SDL_AudioFormat src_format,
const Uint8 src_channels, const Uint8 src_channels,
const int src_rate, const int src_rate,
const SDL_AudioFormat dst_format, const SDL_AudioFormat dst_format,

3
src/audio/SDL_wave.c
View file

@ -2077,8 +2077,7 @@ static int WaveLoad(SDL_RWops *src, WaveFile *file, SDL_AudioSpec *spec, Uint8 *
return 0; return 0;
} }
SDL_AudioSpec * SDL_AudioSpec *SDL_LoadWAV_RW(SDL_RWops *src, int freesrc, SDL_AudioSpec *spec, Uint8 **audio_buf, Uint32 *audio_len)
SDL_LoadWAV_RW(SDL_RWops *src, int freesrc, SDL_AudioSpec *spec, Uint8 **audio_buf, Uint32 *audio_len)
{ {
int result; int result;
WaveFile file; WaveFile file;

36
src/audio/arts/SDL_artsaudio.c
View file

@ -86,8 +86,7 @@ static struct
#undef SDL_ARTS_SYM #undef SDL_ARTS_SYM
static void static void UnloadARTSLibrary()
UnloadARTSLibrary()
{ {
if (arts_handle != NULL) { if (arts_handle != NULL) {
SDL_UnloadObject(arts_handle); SDL_UnloadObject(arts_handle);
@ -95,8 +94,7 @@ UnloadARTSLibrary()
} }
} }
static int static int LoadARTSLibrary(void)
LoadARTSLibrary(void)
{ {
int i, retval = -1; int i, retval = -1;
@ -121,14 +119,12 @@ LoadARTSLibrary(void)
#else #else
static void static void UnloadARTSLibrary()
UnloadARTSLibrary()
{ {
return; return;
} }
static int static int LoadARTSLibrary(void)
LoadARTSLibrary(void)
{ {
return 0; return 0;
} }
@ -136,8 +132,7 @@ LoadARTSLibrary(void)
#endif /* SDL_AUDIO_DRIVER_ARTS_DYNAMIC */ #endif /* SDL_AUDIO_DRIVER_ARTS_DYNAMIC */
/* This function waits until it is possible to write a full sound buffer */ /* This function waits until it is possible to write a full sound buffer */
static void static void ARTS_WaitDevice(_THIS)
ARTS_WaitDevice(_THIS)
{ {
Sint32 ticks; Sint32 ticks;
@ -163,8 +158,7 @@ ARTS_WaitDevice(_THIS)
} }
} }
static void static void ARTS_PlayDevice(_THIS)
ARTS_PlayDevice(_THIS)
{ {
/* Write the audio data */ /* Write the audio data */
int written = SDL_NAME(arts_write) (this->hidden->stream, int written = SDL_NAME(arts_write) (this->hidden->stream,
@ -185,15 +179,13 @@ ARTS_PlayDevice(_THIS)
#endif #endif
} }
static Uint8 * static Uint8 *ARTS_GetDeviceBuf(_THIS)
ARTS_GetDeviceBuf(_THIS)
{ {
return (this->hidden->mixbuf); return (this->hidden->mixbuf);
} }
static void static void ARTS_CloseDevice(_THIS)
ARTS_CloseDevice(_THIS)
{ {
if (this->hidden->stream) { if (this->hidden->stream) {
SDL_NAME(arts_close_stream) (this->hidden->stream); SDL_NAME(arts_close_stream) (this->hidden->stream);
@ -203,8 +195,7 @@ ARTS_CloseDevice(_THIS)
SDL_free(this->hidden); SDL_free(this->hidden);
} }
static int static int ARTS_Suspend(void)
ARTS_Suspend(void)
{ {
const Uint32 abortms = SDL_GetTicks() + 3000; /* give up after 3 secs */ const Uint32 abortms = SDL_GetTicks() + 3000; /* give up after 3 secs */
while ( (!SDL_NAME(arts_suspended)()) && !SDL_TICKS_PASSED(SDL_GetTicks(), abortms) ) { while ( (!SDL_NAME(arts_suspended)()) && !SDL_TICKS_PASSED(SDL_GetTicks(), abortms) ) {
@ -215,8 +206,7 @@ ARTS_Suspend(void)
return SDL_NAME(arts_suspended)(); return SDL_NAME(arts_suspended)();
} }
static int static int ARTS_OpenDevice(_THIS, const char *devname)
ARTS_OpenDevice(_THIS, const char *devname)
{ {
int rc = 0; int rc = 0;
int bits, frag_spec = 0; int bits, frag_spec = 0;
@ -304,15 +294,13 @@ ARTS_OpenDevice(_THIS, const char *devname)
} }
static void static void ARTS_Deinitialize(void)
ARTS_Deinitialize(void)
{ {
UnloadARTSLibrary(); UnloadARTSLibrary();
} }
static SDL_bool static SDL_bool ARTS_Init(SDL_AudioDriverImpl * impl)
ARTS_Init(SDL_AudioDriverImpl * impl)
{ {
if (LoadARTSLibrary() < 0) { if (LoadARTSLibrary() < 0) {
return SDL_FALSE; return SDL_FALSE;

36
src/audio/esd/SDL_esdaudio.c
View file

@ -64,8 +64,7 @@ static struct
#undef SDL_ESD_SYM #undef SDL_ESD_SYM
static void static void UnloadESDLibrary()
UnloadESDLibrary()
{ {
if (esd_handle != NULL) { if (esd_handle != NULL) {
SDL_UnloadObject(esd_handle); SDL_UnloadObject(esd_handle);
@ -73,8 +72,7 @@ UnloadESDLibrary()
} }
} }
static int static int LoadESDLibrary(void)
LoadESDLibrary(void)
{ {
int i, retval = -1; int i, retval = -1;
@ -98,14 +96,12 @@ LoadESDLibrary(void)
#else #else
static void static void UnloadESDLibrary()
UnloadESDLibrary()
{ {
return; return;
} }
static int static int LoadESDLibrary(void)
LoadESDLibrary(void)
{ {
return 0; return 0;
} }
@ -114,8 +110,7 @@ LoadESDLibrary(void)
/* This function waits until it is possible to write a full sound buffer */ /* This function waits until it is possible to write a full sound buffer */
static void static void ESD_WaitDevice(_THIS)
ESD_WaitDevice(_THIS)
{ {
Sint32 ticks; Sint32 ticks;
@ -140,8 +135,7 @@ ESD_WaitDevice(_THIS)
} }
} }
static void static void ESD_PlayDevice(_THIS)
ESD_PlayDevice(_THIS)
{ {
int written = 0; int written = 0;
@ -164,14 +158,12 @@ ESD_PlayDevice(_THIS)
} }
} }
static Uint8 * static Uint8 *ESD_GetDeviceBuf(_THIS)
ESD_GetDeviceBuf(_THIS)
{ {
return (this->hidden->mixbuf); return (this->hidden->mixbuf);
} }
static void static void ESD_CloseDevice(_THIS)
ESD_CloseDevice(_THIS)
{ {
if (this->hidden->audio_fd >= 0) { if (this->hidden->audio_fd >= 0) {
SDL_NAME(esd_close) (this->hidden->audio_fd); SDL_NAME(esd_close) (this->hidden->audio_fd);
@ -181,8 +173,7 @@ ESD_CloseDevice(_THIS)
} }
/* Try to get the name of the program */ /* Try to get the name of the program */
static char * static char *get_progname(void)
get_progname(void)
{ {
char *progname = NULL; char *progname = NULL;
#ifdef __LINUX__ #ifdef __LINUX__
@ -207,8 +198,7 @@ get_progname(void)
} }
static int static int ESD_OpenDevice(_THIS, const char *devname)
ESD_OpenDevice(_THIS, const char *devname)
{ {
esd_format_t format = (ESD_STREAM | ESD_PLAY); esd_format_t format = (ESD_STREAM | ESD_PLAY);
SDL_AudioFormat test_format = 0; SDL_AudioFormat test_format = 0;
@ -286,14 +276,12 @@ ESD_OpenDevice(_THIS, const char *devname)
return 0; return 0;
} }
static void static void ESD_Deinitialize(void)
ESD_Deinitialize(void)
{ {
UnloadESDLibrary(); UnloadESDLibrary();
} }
static SDL_bool static SDL_bool ESD_Init(SDL_AudioDriverImpl * impl)
ESD_Init(SDL_AudioDriverImpl * impl)
{ {
if (LoadESDLibrary() < 0) { if (LoadESDLibrary() < 0) {
return SDL_FALSE; return SDL_FALSE;

33
src/audio/fusionsound/SDL_fsaudio.c
View file

@ -77,8 +77,7 @@ static struct
#undef SDL_FS_SYM #undef SDL_FS_SYM
static void static void UnloadFusionSoundLibrary()
UnloadFusionSoundLibrary()
{ {
if (fs_handle != NULL) { if (fs_handle != NULL) {
SDL_UnloadObject(fs_handle); SDL_UnloadObject(fs_handle);
@ -86,8 +85,7 @@ UnloadFusionSoundLibrary()
} }
} }
static int static int LoadFusionSoundLibrary(void)
LoadFusionSoundLibrary(void)
{ {
int i, retval = -1; int i, retval = -1;
@ -112,14 +110,12 @@ LoadFusionSoundLibrary(void)
#else #else
static void static void UnloadFusionSoundLibrary()
UnloadFusionSoundLibrary()
{ {
return; return;
} }
static int static int LoadFusionSoundLibrary(void)
LoadFusionSoundLibrary(void)
{ {
return 0; return 0;
} }
@ -127,15 +123,13 @@ LoadFusionSoundLibrary(void)
#endif /* SDL_AUDIO_DRIVER_FUSIONSOUND_DYNAMIC */ #endif /* SDL_AUDIO_DRIVER_FUSIONSOUND_DYNAMIC */
/* This function waits until it is possible to write a full sound buffer */ /* This function waits until it is possible to write a full sound buffer */
static void static void SDL_FS_WaitDevice(_THIS)
SDL_FS_WaitDevice(_THIS)
{ {
this->hidden->stream->Wait(this->hidden->stream, this->hidden->stream->Wait(this->hidden->stream,
this->hidden->mixsamples); this->hidden->mixsamples);
} }
static void static void SDL_FS_PlayDevice(_THIS)
SDL_FS_PlayDevice(_THIS)
{ {
DirectResult ret; DirectResult ret;
@ -152,15 +146,13 @@ SDL_FS_PlayDevice(_THIS)
} }
static Uint8 * static Uint8 *SDL_FS_GetDeviceBuf(_THIS)
SDL_FS_GetDeviceBuf(_THIS)
{ {
return (this->hidden->mixbuf); return (this->hidden->mixbuf);
} }
static void static void SDL_FS_CloseDevice(_THIS)
SDL_FS_CloseDevice(_THIS)
{ {
if (this->hidden->stream) { if (this->hidden->stream) {
this->hidden->stream->Release(this->hidden->stream); this->hidden->stream->Release(this->hidden->stream);
@ -173,8 +165,7 @@ SDL_FS_CloseDevice(_THIS)
} }
static int static int SDL_FS_OpenDevice(_THIS, const char *devname)
SDL_FS_OpenDevice(_THIS, const char *devname)
{ {
int bytes; int bytes;
SDL_AudioFormat test_format; SDL_AudioFormat test_format;
@ -269,15 +260,13 @@ SDL_FS_OpenDevice(_THIS, const char *devname)
} }
static void static void SDL_FS_Deinitialize(void)
SDL_FS_Deinitialize(void)
{ {
UnloadFusionSoundLibrary(); UnloadFusionSoundLibrary();
} }
static SDL_bool static SDL_bool SDL_FS_Init(SDL_AudioDriverImpl * impl)
SDL_FS_Init(SDL_AudioDriverImpl * impl)
{ {
if (LoadFusionSoundLibrary() < 0) { if (LoadFusionSoundLibrary() < 0) {
return SDL_FALSE; return SDL_FALSE;

13
src/audio/nacl/SDL_naclaudio.c
View file

@ -45,7 +45,8 @@
static void nacl_audio_callback(void* samples, uint32_t buffer_size, PP_TimeDelta latency, void* data); static void nacl_audio_callback(void* samples, uint32_t buffer_size, PP_TimeDelta latency, void* data);
/* FIXME: Make use of latency if needed */ /* FIXME: Make use of latency if needed */
static void nacl_audio_callback(void* stream, uint32_t buffer_size, PP_TimeDelta latency, void* data) { static void nacl_audio_callback(void* stream, uint32_t buffer_size, PP_TimeDelta latency, void* data)
{
const int len = (int) buffer_size; const int len = (int) buffer_size;
SDL_AudioDevice* _this = (SDL_AudioDevice*) data; SDL_AudioDevice* _this = (SDL_AudioDevice*) data;
SDL_AudioCallback callback = _this->callbackspec.callback; SDL_AudioCallback callback = _this->callbackspec.callback;
@ -85,7 +86,8 @@ static void nacl_audio_callback(void* stream, uint32_t buffer_size, PP_TimeDelta
SDL_UnlockMutex(_this->mixer_lock); SDL_UnlockMutex(_this->mixer_lock);
} }
static void NACLAUDIO_CloseDevice(SDL_AudioDevice *device) { static void NACLAUDIO_CloseDevice(SDL_AudioDevice *device)
{
const PPB_Core *core = PSInterfaceCore(); const PPB_Core *core = PSInterfaceCore();
const PPB_Audio *ppb_audio = PSInterfaceAudio(); const PPB_Audio *ppb_audio = PSInterfaceAudio();
SDL_PrivateAudioData *hidden = (SDL_PrivateAudioData *) device->hidden; SDL_PrivateAudioData *hidden = (SDL_PrivateAudioData *) device->hidden;
@ -94,8 +96,8 @@ static void NACLAUDIO_CloseDevice(SDL_AudioDevice *device) {
core->ReleaseResource(hidden->audio); core->ReleaseResource(hidden->audio);
} }
static int static int NACLAUDIO_OpenDevice(_THIS, const char *devname)
NACLAUDIO_OpenDevice(_THIS, const char *devname) { {
PP_Instance instance = PSGetInstanceId(); PP_Instance instance = PSGetInstanceId();
const PPB_Audio *ppb_audio = PSInterfaceAudio(); const PPB_Audio *ppb_audio = PSInterfaceAudio();
const PPB_AudioConfig *ppb_audiocfg = PSInterfaceAudioConfig(); const PPB_AudioConfig *ppb_audiocfg = PSInterfaceAudioConfig();
@ -128,8 +130,7 @@ NACLAUDIO_OpenDevice(_THIS, const char *devname) {
return 0; return 0;
} }
static SDL_bool static SDL_bool NACLAUDIO_Init(SDL_AudioDriverImpl * impl)
NACLAUDIO_Init(SDL_AudioDriverImpl * impl)
{ {
if (PSGetInstanceId() == 0) { if (PSGetInstanceId() == 0) {
return SDL_FALSE; return SDL_FALSE;

51
src/audio/nas/SDL_nasaudio.c
View file

@ -56,8 +56,7 @@ static AuEventHandlerRec *(*NAS_AuRegisterEventHandler)
static const char *nas_library = SDL_AUDIO_DRIVER_NAS_DYNAMIC; static const char *nas_library = SDL_AUDIO_DRIVER_NAS_DYNAMIC;
static void *nas_handle = NULL; static void *nas_handle = NULL;
static int static int load_nas_sym(const char *fn, void **addr)
load_nas_sym(const char *fn, void **addr)
{ {
*addr = SDL_LoadFunction(nas_handle, fn); *addr = SDL_LoadFunction(nas_handle, fn);
if (*addr == NULL) { if (*addr == NULL) {
@ -73,8 +72,7 @@ load_nas_sym(const char *fn, void **addr)
#define SDL_NAS_SYM(x) NAS_##x = x #define SDL_NAS_SYM(x) NAS_##x = x
#endif #endif
static int static int load_nas_syms(void)
load_nas_syms(void)
{ {
SDL_NAS_SYM(AuCloseServer); SDL_NAS_SYM(AuCloseServer);
SDL_NAS_SYM(AuNextEvent); SDL_NAS_SYM(AuNextEvent);
@ -94,8 +92,7 @@ load_nas_syms(void)
#ifdef SDL_AUDIO_DRIVER_NAS_DYNAMIC #ifdef SDL_AUDIO_DRIVER_NAS_DYNAMIC
static void static void UnloadNASLibrary(void)
UnloadNASLibrary(void)
{ {
if (nas_handle != NULL) { if (nas_handle != NULL) {
SDL_UnloadObject(nas_handle); SDL_UnloadObject(nas_handle);
@ -103,8 +100,7 @@ UnloadNASLibrary(void)
} }
} }
static int static int LoadNASLibrary(void)
LoadNASLibrary(void)
{ {
int retval = 0; int retval = 0;
if (nas_handle == NULL) { if (nas_handle == NULL) {
@ -130,13 +126,11 @@ LoadNASLibrary(void)
#else #else
static void static void UnloadNASLibrary(void)
UnloadNASLibrary(void)
{ {
} }
static int static int LoadNASLibrary(void)
LoadNASLibrary(void)
{ {
load_nas_syms(); load_nas_syms();
return 0; return 0;
@ -145,8 +139,7 @@ LoadNASLibrary(void)
#endif /* SDL_AUDIO_DRIVER_NAS_DYNAMIC */ #endif /* SDL_AUDIO_DRIVER_NAS_DYNAMIC */
/* This function waits until it is possible to write a full sound buffer */ /* This function waits until it is possible to write a full sound buffer */
static void static void NAS_WaitDevice(_THIS)
NAS_WaitDevice(_THIS)
{ {
while (this->hidden->buf_free < this->hidden->mixlen) { while (this->hidden->buf_free < this->hidden->mixlen) {
AuEvent ev; AuEvent ev;
@ -155,8 +148,7 @@ NAS_WaitDevice(_THIS)
} }
} }
static void static void NAS_PlayDevice(_THIS)
NAS_PlayDevice(_THIS)
{ {
while (this->hidden->mixlen > this->hidden->buf_free) { while (this->hidden->mixlen > this->hidden->buf_free) {
/* /*
@ -182,14 +174,12 @@ NAS_PlayDevice(_THIS)
#endif #endif
} }
static Uint8 * static Uint8 *NAS_GetDeviceBuf(_THIS)
NAS_GetDeviceBuf(_THIS)
{ {
return (this->hidden->mixbuf); return (this->hidden->mixbuf);
} }
static int static int NAS_CaptureFromDevice(_THIS, void *buffer, int buflen)
NAS_CaptureFromDevice(_THIS, void *buffer, int buflen)
{ {
struct SDL_PrivateAudioData *h = this->hidden; struct SDL_PrivateAudioData *h = this->hidden;
int retval; int retval;
@ -210,8 +200,7 @@ NAS_CaptureFromDevice(_THIS, void *buffer, int buflen)
return retval; return retval;
} }
static void static void NAS_FlushCapture(_THIS)
NAS_FlushCapture(_THIS)
{ {
struct SDL_PrivateAudioData *h = this->hidden; struct SDL_PrivateAudioData *h = this->hidden;
AuUint32 total = 0; AuUint32 total = 0;
@ -227,8 +216,7 @@ NAS_FlushCapture(_THIS)
} while ((br == sizeof(buf)) && (total < this->spec.size)); } while ((br == sizeof(buf)) && (total < this->spec.size));
} }
static void static void NAS_CloseDevice(_THIS)
NAS_CloseDevice(_THIS)
{ {
if (this->hidden->aud) { if (this->hidden->aud) {
NAS_AuCloseServer(this->hidden->aud); NAS_AuCloseServer(this->hidden->aud);
@ -237,8 +225,7 @@ NAS_CloseDevice(_THIS)
SDL_free(this->hidden); SDL_free(this->hidden);
} }
static AuBool static AuBool event_handler(AuServer * aud, AuEvent * ev, AuEventHandlerRec * hnd)
event_handler(AuServer * aud, AuEvent * ev, AuEventHandlerRec * hnd)
{ {
SDL_AudioDevice *this = (SDL_AudioDevice *) hnd->data; SDL_AudioDevice *this = (SDL_AudioDevice *) hnd->data;
struct SDL_PrivateAudioData *h = this->hidden; struct SDL_PrivateAudioData *h = this->hidden;
@ -281,8 +268,7 @@ event_handler(AuServer * aud, AuEvent * ev, AuEventHandlerRec * hnd)
return AuTrue; return AuTrue;
} }
static AuDeviceID static AuDeviceID find_device(_THIS)
find_device(_THIS)
{ {
/* These "Au" things are all macros, not functions... */ /* These "Au" things are all macros, not functions... */
struct SDL_PrivateAudioData *h = this->hidden; struct SDL_PrivateAudioData *h = this->hidden;
@ -310,8 +296,7 @@ find_device(_THIS)
return AuNone; return AuNone;
} }
static int static int NAS_OpenDevice(_THIS, const char *devname)
NAS_OpenDevice(_THIS, const char *devname)
{ {
AuElement elms[3]; AuElement elms[3];
int buffer_size; int buffer_size;
@ -414,14 +399,12 @@ NAS_OpenDevice(_THIS, const char *devname)
return 0; return 0;
} }
static void static void NAS_Deinitialize(void)
NAS_Deinitialize(void)
{ {
UnloadNASLibrary(); UnloadNASLibrary();
} }
static SDL_bool static SDL_bool NAS_Init(SDL_AudioDriverImpl * impl)
NAS_Init(SDL_AudioDriverImpl * impl)
{ {
if (LoadNASLibrary() < 0) { if (LoadNASLibrary() < 0) {
return SDL_FALSE; return SDL_FALSE;

24
src/audio/paudio/SDL_paudio.c
View file

@ -69,8 +69,7 @@ static char devsettings[][3] = {
{'\0', '\0', '\0'} {'\0', '\0', '\0'}
}; };
static int static int OpenUserDefinedDevice(char *path, int maxlen, int flags)
OpenUserDefinedDevice(char *path, int maxlen, int flags)
{ {
const char *audiodev; const char *audiodev;
int fd; int fd;
@ -90,8 +89,7 @@ OpenUserDefinedDevice(char *path, int maxlen, int flags)
return fd; return fd;
} }
static int static int OpenAudioPath(char *path, int maxlen, int flags, int classic)
OpenAudioPath(char *path, int maxlen, int flags, int classic)
{ {
struct stat sb; struct stat sb;
int cycle = 0; int cycle = 0;
@ -123,8 +121,7 @@ OpenAudioPath(char *path, int maxlen, int flags, int classic)
} }
/* This function waits until it is possible to write a full sound buffer */ /* This function waits until it is possible to write a full sound buffer */
static void static void PAUDIO_WaitDevice(_THIS)
PAUDIO_WaitDevice(_THIS)
{ {
fd_set fdset; fd_set fdset;
@ -176,8 +173,7 @@ PAUDIO_WaitDevice(_THIS)
} }
} }
static void static void PAUDIO_PlayDevice(_THIS)
PAUDIO_PlayDevice(_THIS)
{ {
int written = 0; int written = 0;
const Uint8 *mixbuf = this->hidden->mixbuf; const Uint8 *mixbuf = this->hidden->mixbuf;
@ -206,14 +202,12 @@ PAUDIO_PlayDevice(_THIS)
#endif #endif
} }
static Uint8 * static Uint8 *PAUDIO_GetDeviceBuf(_THIS)
PAUDIO_GetDeviceBuf(_THIS)
{ {
return this->hidden->mixbuf; return this->hidden->mixbuf;
} }
static void static void PAUDIO_CloseDevice(_THIS)
PAUDIO_CloseDevice(_THIS)
{ {
if (this->hidden->audio_fd >= 0) { if (this->hidden->audio_fd >= 0) {
close(this->hidden->audio_fd); close(this->hidden->audio_fd);
@ -222,8 +216,7 @@ PAUDIO_CloseDevice(_THIS)
SDL_free(this->hidden); SDL_free(this->hidden);
} }
static int static int PAUDIO_OpenDevice(_THIS, const char *devname)
PAUDIO_OpenDevice(_THIS, const char *devname)
{ {
const char *workaround = SDL_getenv("SDL_DSP_NOSELECT"); const char *workaround = SDL_getenv("SDL_DSP_NOSELECT");
char audiodev[1024]; char audiodev[1024];
@ -462,8 +455,7 @@ PAUDIO_OpenDevice(_THIS, const char *devname)
return 0; return 0;
} }
static SDL_bool static SDL_bool PAUDIO_Init(SDL_AudioDriverImpl * impl)
PAUDIO_Init(SDL_AudioDriverImpl * impl)
{ {
/* !!! FIXME: not right for device enum? */ /* !!! FIXME: not right for device enum? */
int fd = OpenAudioPath(NULL, 0, OPEN_FLAGS, 0); int fd = OpenAudioPath(NULL, 0, OPEN_FLAGS, 0);

33
src/audio/qsa/SDL_qsa_audio.c
View file

@ -74,15 +74,13 @@ uint32_t qsa_playback_devices;
QSA_Device qsa_capture_device[QSA_MAX_DEVICES]; QSA_Device qsa_capture_device[QSA_MAX_DEVICES];
uint32_t qsa_capture_devices; uint32_t qsa_capture_devices;
static SDL_INLINE int static int QSA_SetError(const char *fn, int status)
QSA_SetError(const char *fn, int status)
{ {
return SDL_SetError("QSA: %s() failed: %s", fn, snd_strerror(status)); return SDL_SetError("QSA: %s() failed: %s", fn, snd_strerror(status));
} }
/* !!! FIXME: does this need to be here? Does the SDL version not work? */ /* !!! FIXME: does this need to be here? Does the SDL version not work? */
static void static void QSA_ThreadInit(_THIS)
QSA_ThreadInit(_THIS)
{ {
/* Increase default 10 priority to 25 to avoid jerky sound */ /* Increase default 10 priority to 25 to avoid jerky sound */
struct sched_param param; struct sched_param param;
@ -93,8 +91,7 @@ QSA_ThreadInit(_THIS)
} }
/* PCM channel parameters initialize function */ /* PCM channel parameters initialize function */
static void static void QSA_InitAudioParams(snd_pcm_channel_params_t * cpars)
QSA_InitAudioParams(snd_pcm_channel_params_t * cpars)
{ {
SDL_zerop(cpars); SDL_zerop(cpars);
cpars->channel = SND_PCM_CHANNEL_PLAYBACK; cpars->channel = SND_PCM_CHANNEL_PLAYBACK;
@ -111,8 +108,7 @@ QSA_InitAudioParams(snd_pcm_channel_params_t * cpars)
} }
/* This function waits until it is possible to write a full sound buffer */ /* This function waits until it is possible to write a full sound buffer */
static void static void QSA_WaitDevice(_THIS)
QSA_WaitDevice(_THIS)
{ {
int result; int result;
@ -137,8 +133,7 @@ QSA_WaitDevice(_THIS)
} }
} }
static void static void QSA_PlayDevice(_THIS)
QSA_PlayDevice(_THIS)
{ {
snd_pcm_channel_status_t cstatus; snd_pcm_channel_status_t cstatus;
int written; int written;
@ -230,14 +225,12 @@ QSA_PlayDevice(_THIS)
} }
} }
static Uint8 * static Uint8 *QSA_GetDeviceBuf(_THIS)
QSA_GetDeviceBuf(_THIS)
{ {
return this->hidden->pcm_buf; return this->hidden->pcm_buf;
} }
static void static void QSA_CloseDevice(_THIS)
QSA_CloseDevice(_THIS)
{ {
if (this->hidden->audio_handle != NULL) { if (this->hidden->audio_handle != NULL) {
if (!this->iscapture) { if (!this->iscapture) {
@ -256,8 +249,7 @@ QSA_CloseDevice(_THIS)
SDL_free(this->hidden); SDL_free(this->hidden);
} }
static int static int QSA_OpenDevice(_THIS, const char *devname)
QSA_OpenDevice(_THIS, const char *devname)
{ {
const QSA_Device *device = (const QSA_Device *) this->handle; const QSA_Device *device = (const QSA_Device *) this->handle;
SDL_bool iscapture = this->iscapture; SDL_bool iscapture = this->iscapture;
@ -435,8 +427,7 @@ QSA_OpenDevice(_THIS, const char *devname)
return 0; return 0;
} }
static void static void QSA_DetectDevices(void)
QSA_DetectDevices(void)
{ {
uint32_t it; uint32_t it;
uint32_t cards; uint32_t cards;
@ -581,8 +572,7 @@ QSA_DetectDevices(void)
} }
} }
static void static void QSA_Deinitialize(void)
QSA_Deinitialize(void)
{ {
/* Clear devices array on shutdown */ /* Clear devices array on shutdown */
/* !!! FIXME: we zero these on init...any reason to do it here? */ /* !!! FIXME: we zero these on init...any reason to do it here? */
@ -592,8 +582,7 @@ QSA_Deinitialize(void)
qsa_capture_devices = 0; qsa_capture_devices = 0;
} }
static SDL_bool static SDL_bool QSA_Init(SDL_AudioDriverImpl * impl)
QSA_Init(SDL_AudioDriverImpl * impl)
{ {
/* Clear devices array */ /* Clear devices array */
SDL_zeroa(qsa_playback_device); SDL_zeroa(qsa_playback_device);

27
src/audio/sun/SDL_sunaudio.c
View file

@ -55,15 +55,13 @@
static Uint8 snd2au(int sample); static Uint8 snd2au(int sample);
/* Audio driver bootstrap functions */ /* Audio driver bootstrap functions */
static void static void SUNAUDIO_DetectDevices(void)
SUNAUDIO_DetectDevices(void)
{ {
SDL_EnumUnixAudioDevices(1, (int (*)(int)) NULL); SDL_EnumUnixAudioDevices(1, (int (*)(int)) NULL);
} }
#ifdef DEBUG_AUDIO #ifdef DEBUG_AUDIO
void void CheckUnderflow(_THIS)
CheckUnderflow(_THIS)
{ {
#ifdef AUDIO_GETBUFINFO #ifdef AUDIO_GETBUFINFO
audio_info_t info; audio_info_t info;
@ -78,8 +76,7 @@ CheckUnderflow(_THIS)
} }
#endif #endif
static void static void SUNAUDIO_WaitDevice(_THIS)
SUNAUDIO_WaitDevice(_THIS)
{ {
#ifdef AUDIO_GETBUFINFO #ifdef AUDIO_GETBUFINFO
#define SLEEP_FUDGE 10 /* 10 ms scheduling fudge factor */ #define SLEEP_FUDGE 10 /* 10 ms scheduling fudge factor */
@ -102,8 +99,7 @@ SUNAUDIO_WaitDevice(_THIS)
#endif #endif
} }
static void static void SUNAUDIO_PlayDevice(_THIS)
SUNAUDIO_PlayDevice(_THIS)
{ {
/* Write the audio data */ /* Write the audio data */
if (this->hidden->ulaw_only) { if (this->hidden->ulaw_only) {
@ -170,14 +166,12 @@ SUNAUDIO_PlayDevice(_THIS)
} }
} }
static Uint8 * static Uint8 *SUNAUDIO_GetDeviceBuf(_THIS)
SUNAUDIO_GetDeviceBuf(_THIS)
{ {
return (this->hidden->mixbuf); return (this->hidden->mixbuf);
} }
static void static void SUNAUDIO_CloseDevice(_THIS)
SUNAUDIO_CloseDevice(_THIS)
{ {
SDL_free(this->hidden->ulaw_buf); SDL_free(this->hidden->ulaw_buf);
if (this->hidden->audio_fd >= 0) { if (this->hidden->audio_fd >= 0) {
@ -187,8 +181,7 @@ SUNAUDIO_CloseDevice(_THIS)
SDL_free(this->hidden); SDL_free(this->hidden);
} }
static int static int SUNAUDIO_OpenDevice(_THIS, const char *devname)
SUNAUDIO_OpenDevice(_THIS, const char *devname)
{ {
#ifdef AUDIO_SETINFO #ifdef AUDIO_SETINFO
int enc; int enc;
@ -359,8 +352,7 @@ SUNAUDIO_OpenDevice(_THIS, const char *devname)
/* provided "as is" without express or implied warranty. */ /* provided "as is" without express or implied warranty. */
/************************************************************************/ /************************************************************************/
static Uint8 static Uint8 snd2au(int sample)
snd2au(int sample)
{ {
int mask; int mask;
@ -394,8 +386,7 @@ snd2au(int sample)
return (mask & sample); return (mask & sample);
} }
static SDL_bool static SDL_bool SUNAUDIO_Init(SDL_AudioDriverImpl * impl)
SUNAUDIO_Init(SDL_AudioDriverImpl * impl)
{ {
/* Set the function pointers */ /* Set the function pointers */
impl->DetectDevices = SUNAUDIO_DetectDevices; impl->DetectDevices = SUNAUDIO_DetectDevices;

41
src/audio/winmm/SDL_winmm.c
View file

@ -97,16 +97,13 @@ static void DetectWave##typ##Devs(void) { \
DETECT_DEV_IMPL(SDL_FALSE, Out, WAVEOUTCAPS) DETECT_DEV_IMPL(SDL_FALSE, Out, WAVEOUTCAPS)
DETECT_DEV_IMPL(SDL_TRUE, In, WAVEINCAPS) DETECT_DEV_IMPL(SDL_TRUE, In, WAVEINCAPS)
static void static void WINMM_DetectDevices(void)
WINMM_DetectDevices(void)
{ {
DetectWaveInDevs(); DetectWaveInDevs();
DetectWaveOutDevs(); DetectWaveOutDevs();
} }
static void CALLBACK static void CALLBACK CaptureSound(HWAVEIN hwi, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
CaptureSound(HWAVEIN hwi, UINT uMsg, DWORD_PTR dwInstance,
DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{ {
SDL_AudioDevice *this = (SDL_AudioDevice *) dwInstance; SDL_AudioDevice *this = (SDL_AudioDevice *) dwInstance;
@ -120,9 +117,7 @@ CaptureSound(HWAVEIN hwi, UINT uMsg, DWORD_PTR dwInstance,
/* The Win32 callback for filling the WAVE device */ /* The Win32 callback for filling the WAVE device */
static void CALLBACK static void CALLBACK FillSound(HWAVEOUT hwo, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
FillSound(HWAVEOUT hwo, UINT uMsg, DWORD_PTR dwInstance,
DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{ {
SDL_AudioDevice *this = (SDL_AudioDevice *) dwInstance; SDL_AudioDevice *this = (SDL_AudioDevice *) dwInstance;
@ -134,8 +129,7 @@ FillSound(HWAVEOUT hwo, UINT uMsg, DWORD_PTR dwInstance,
ReleaseSemaphore(this->hidden->audio_sem, 1, NULL); ReleaseSemaphore(this->hidden->audio_sem, 1, NULL);
} }
static int static int SetMMerror(const char *function, MMRESULT code)
SetMMerror(const char *function, MMRESULT code)
{ {
int len; int len;
char errbuf[MAXERRORLENGTH]; char errbuf[MAXERRORLENGTH];
@ -151,22 +145,19 @@ SetMMerror(const char *function, MMRESULT code)
return SDL_SetError("%s", errbuf); return SDL_SetError("%s", errbuf);
} }
static void static void WINMM_WaitDevice(_THIS)
WINMM_WaitDevice(_THIS)
{ {
/* Wait for an audio chunk to finish */ /* Wait for an audio chunk to finish */
WaitForSingleObject(this->hidden->audio_sem, INFINITE); WaitForSingleObject(this->hidden->audio_sem, INFINITE);
} }
static Uint8 * static Uint8 *WINMM_GetDeviceBuf(_THIS)
WINMM_GetDeviceBuf(_THIS)
{ {
return (Uint8 *) (this->hidden-> return (Uint8 *) (this->hidden->
wavebuf[this->hidden->next_buffer].lpData); wavebuf[this->hidden->next_buffer].lpData);
} }
static void static void WINMM_PlayDevice(_THIS)
WINMM_PlayDevice(_THIS)
{ {
/* Queue it up */ /* Queue it up */
waveOutWrite(this->hidden->hout, waveOutWrite(this->hidden->hout,
@ -175,8 +166,7 @@ WINMM_PlayDevice(_THIS)
this->hidden->next_buffer = (this->hidden->next_buffer + 1) % NUM_BUFFERS; this->hidden->next_buffer = (this->hidden->next_buffer + 1) % NUM_BUFFERS;
} }
static int static int WINMM_CaptureFromDevice(_THIS, void *buffer, int buflen)
WINMM_CaptureFromDevice(_THIS, void *buffer, int buflen)
{ {
const int nextbuf = this->hidden->next_buffer; const int nextbuf = this->hidden->next_buffer;
MMRESULT result; MMRESULT result;
@ -202,8 +192,7 @@ WINMM_CaptureFromDevice(_THIS, void *buffer, int buflen)
return this->spec.size; return this->spec.size;
} }
static void static void WINMM_FlushCapture(_THIS)
WINMM_FlushCapture(_THIS)
{ {
/* Wait for an audio chunk to finish */ /* Wait for an audio chunk to finish */
if (WaitForSingleObject(this->hidden->audio_sem, 0) == WAIT_OBJECT_0) { if (WaitForSingleObject(this->hidden->audio_sem, 0) == WAIT_OBJECT_0) {
@ -216,8 +205,7 @@ WINMM_FlushCapture(_THIS)
} }
} }
static void static void WINMM_CloseDevice(_THIS)
WINMM_CloseDevice(_THIS)
{ {
int i; int i;
@ -258,8 +246,7 @@ WINMM_CloseDevice(_THIS)
SDL_free(this->hidden); SDL_free(this->hidden);
} }
static SDL_bool static SDL_bool PrepWaveFormat(_THIS, UINT devId, WAVEFORMATEX *pfmt, const int iscapture)
PrepWaveFormat(_THIS, UINT devId, WAVEFORMATEX *pfmt, const int iscapture)
{ {
SDL_zerop(pfmt); SDL_zerop(pfmt);
@ -282,8 +269,7 @@ PrepWaveFormat(_THIS, UINT devId, WAVEFORMATEX *pfmt, const int iscapture)
} }
} }
static int static int WINMM_OpenDevice(_THIS, const char *devname)
WINMM_OpenDevice(_THIS, const char *devname)
{ {
SDL_AudioFormat test_format; SDL_AudioFormat test_format;
SDL_bool iscapture = this->iscapture; SDL_bool iscapture = this->iscapture;
@ -431,8 +417,7 @@ WINMM_OpenDevice(_THIS, const char *devname)
return 0; /* Ready to go! */ return 0; /* Ready to go! */
} }
static SDL_bool static SDL_bool WINMM_Init(SDL_AudioDriverImpl * impl)
WINMM_Init(SDL_AudioDriverImpl * impl)
{ {
/* Set the function pointers */ /* Set the function pointers */
impl->DetectDevices = WINMM_DetectDevices; impl->DetectDevices = WINMM_DetectDevices;

3
src/core/freebsd/SDL_evdev_kbd_freebsd.c
View file

@ -221,8 +221,7 @@ static void kbd_register_emerg_cleanup(SDL_EVDEV_keyboard_state *kbd)
} }
} }
SDL_EVDEV_keyboard_state * SDL_EVDEV_keyboard_state *SDL_EVDEV_kbd_init(void)
SDL_EVDEV_kbd_init(void)
{ {
SDL_EVDEV_keyboard_state *kbd; SDL_EVDEV_keyboard_state *kbd;
struct mouse_info mData; struct mouse_info mData;

24
src/core/linux/SDL_dbus.c
View file

@ -193,8 +193,7 @@ void SDL_DBus_Quit(void)
inhibit_handle = NULL; inhibit_handle = NULL;
} }
SDL_DBusContext * SDL_DBusContext *SDL_DBus_GetContext(void)
SDL_DBus_GetContext(void)
{ {
if (dbus_handle == NULL || !dbus.session_conn) { if (dbus_handle == NULL || !dbus.session_conn) {
SDL_DBus_Init(); SDL_DBus_Init();
@ -246,8 +245,7 @@ static SDL_bool SDL_DBus_CallMethodInternal(DBusConnection *conn, const char *no
return retval; return retval;
} }
SDL_bool SDL_bool SDL_DBus_CallMethodOnConnection(DBusConnection *conn, const char *node, const char *path, const char *interface, const char *method, ...)
SDL_DBus_CallMethodOnConnection(DBusConnection *conn, const char *node, const char *path, const char *interface, const char *method, ...)
{ {
SDL_bool retval; SDL_bool retval;
va_list ap; va_list ap;
@ -257,8 +255,7 @@ SDL_DBus_CallMethodOnConnection(DBusConnection *conn, const char *node, const ch
return retval; return retval;
} }
SDL_bool SDL_bool SDL_DBus_CallMethod(const char *node, const char *path, const char *interface, const char *method, ...)
SDL_DBus_CallMethod(const char *node, const char *path, const char *interface, const char *method, ...)
{ {
SDL_bool retval; SDL_bool retval;
va_list ap; va_list ap;
@ -315,8 +312,7 @@ static SDL_bool SDL_DBus_CallWithBasicReply(DBusConnection *conn, DBusMessage *m
return retval; return retval;
} }
SDL_bool SDL_bool SDL_DBus_CallVoidMethodOnConnection(DBusConnection *conn, const char *node, const char *path, const char *interface, const char *method, ...)
SDL_DBus_CallVoidMethodOnConnection(DBusConnection *conn, const char *node, const char *path, const char *interface, const char *method, ...)
{ {
SDL_bool retval; SDL_bool retval;
va_list ap; va_list ap;
@ -326,8 +322,7 @@ SDL_DBus_CallVoidMethodOnConnection(DBusConnection *conn, const char *node, cons
return retval; return retval;
} }
SDL_bool SDL_bool SDL_DBus_CallVoidMethod(const char *node, const char *path, const char *interface, const char *method, ...)
SDL_DBus_CallVoidMethod(const char *node, const char *path, const char *interface, const char *method, ...)
{ {
SDL_bool retval; SDL_bool retval;
va_list ap; va_list ap;
@ -337,8 +332,7 @@ SDL_DBus_CallVoidMethod(const char *node, const char *path, const char *interfac
return retval; return retval;
} }
SDL_bool SDL_bool SDL_DBus_QueryPropertyOnConnection(DBusConnection *conn, const char *node, const char *path, const char *interface, const char *property, const int expectedtype, void *result)
SDL_DBus_QueryPropertyOnConnection(DBusConnection *conn, const char *node, const char *path, const char *interface, const char *property, const int expectedtype, void *result)
{ {
SDL_bool retval = SDL_FALSE; SDL_bool retval = SDL_FALSE;
@ -355,8 +349,7 @@ SDL_DBus_QueryPropertyOnConnection(DBusConnection *conn, const char *node, const
return retval; return retval;
} }
SDL_bool SDL_bool SDL_DBus_QueryProperty(const char *node, const char *path, const char *interface, const char *property, const int expectedtype, void *result)
SDL_DBus_QueryProperty(const char *node, const char *path, const char *interface, const char *property, const int expectedtype, void *result)
{ {
return SDL_DBus_QueryPropertyOnConnection(dbus.session_conn, node, path, interface, property, expectedtype, result); return SDL_DBus_QueryPropertyOnConnection(dbus.session_conn, node, path, interface, property, expectedtype, result);
} }
@ -407,8 +400,7 @@ failed:
return SDL_FALSE; return SDL_FALSE;
} }
SDL_bool SDL_bool SDL_DBus_ScreensaverInhibit(SDL_bool inhibit)
SDL_DBus_ScreensaverInhibit(SDL_bool inhibit)
{ {
const char *default_inhibit_reason = "Playing a game"; const char *default_inhibit_reason = "Playing a game";

6
src/core/linux/SDL_evdev_kbd.c
View file

@ -296,8 +296,7 @@ static void kbd_register_emerg_cleanup(SDL_EVDEV_keyboard_state *kbd)
} }
} }
SDL_EVDEV_keyboard_state * SDL_EVDEV_keyboard_state *SDL_EVDEV_kbd_init(void)
SDL_EVDEV_kbd_init(void)
{ {
SDL_EVDEV_keyboard_state *kbd; SDL_EVDEV_keyboard_state *kbd;
char flag_state; char flag_state;
@ -805,8 +804,7 @@ void SDL_EVDEV_kbd_keycode(SDL_EVDEV_keyboard_state *state, unsigned int keycode
#elif !defined(SDL_INPUT_FBSDKBIO) /* !SDL_INPUT_LINUXKD */ #elif !defined(SDL_INPUT_FBSDKBIO) /* !SDL_INPUT_LINUXKD */
SDL_EVDEV_keyboard_state * SDL_EVDEV_keyboard_state *SDL_EVDEV_kbd_init(void)
SDL_EVDEV_kbd_init(void)
{ {
return NULL; return NULL;
} }

9
src/core/linux/SDL_fcitx.c
View file

@ -83,8 +83,7 @@ static char *GetAppName()
return SDL_strdup("SDL_App"); return SDL_strdup("SDL_App");
} }
static size_t static size_t Fcitx_GetPreeditString(SDL_DBusContext *dbus,
Fcitx_GetPreeditString(SDL_DBusContext *dbus,
DBusMessage *msg, DBusMessage *msg,
char **ret, char **ret,
Sint32 *start_pos, Sint32 *start_pos,
@ -369,8 +368,7 @@ static Uint32 Fcitx_ModState(void)
return fcitx_mods; return fcitx_mods;
} }
SDL_bool SDL_bool SDL_Fcitx_Init()
SDL_Fcitx_Init()
{ {
fcitx_client.dbus = SDL_DBus_GetContext(); fcitx_client.dbus = SDL_DBus_GetContext();
@ -406,8 +404,7 @@ void SDL_Fcitx_Reset(void)
FcitxClientICCallMethod(&fcitx_client, "CloseIC"); FcitxClientICCallMethod(&fcitx_client, "CloseIC");
} }
SDL_bool SDL_bool SDL_Fcitx_ProcessKeyEvent(Uint32 keysym, Uint32 keycode, Uint8 state)
SDL_Fcitx_ProcessKeyEvent(Uint32 keysym, Uint32 keycode, Uint8 state)
{ {
Uint32 mod_state = Fcitx_ModState(); Uint32 mod_state = Fcitx_ModState();
Uint32 handled = SDL_FALSE; Uint32 handled = SDL_FALSE;

14
src/core/linux/SDL_ibus.c
View file

@ -555,8 +555,7 @@ static SDL_bool IBus_CheckConnection(SDL_DBusContext *dbus)
return SDL_FALSE; return SDL_FALSE;
} }
SDL_bool SDL_bool SDL_IBus_Init(void)
SDL_IBus_Init(void)
{ {
SDL_bool result = SDL_FALSE; SDL_bool result = SDL_FALSE;
SDL_DBusContext *dbus = SDL_DBus_GetContext(); SDL_DBusContext *dbus = SDL_DBus_GetContext();
@ -671,8 +670,7 @@ void SDL_IBus_Reset(void)
IBus_SimpleMessage("Reset"); IBus_SimpleMessage("Reset");
} }
SDL_bool SDL_bool SDL_IBus_ProcessKeyEvent(Uint32 keysym, Uint32 keycode, Uint8 state)
SDL_IBus_ProcessKeyEvent(Uint32 keysym, Uint32 keycode, Uint8 state)
{ {
Uint32 result = 0; Uint32 result = 0;
SDL_DBusContext *dbus = SDL_DBus_GetContext(); SDL_DBusContext *dbus = SDL_DBus_GetContext();
@ -717,16 +715,16 @@ void SDL_IBus_UpdateTextRect(const SDL_Rect *rect)
} }
SDL_GetWindowPosition(focused_win, &x, &y); SDL_GetWindowPosition(focused_win, &x, &y);
#if SDL_VIDEO_DRIVER_X11 #if SDL_VIDEO_DRIVER_X11
if (info.subsystem == SDL_SYSWM_X11) { if (info.subsystem == SDL_SYSWM_X11) {
SDL_DisplayData *displaydata = (SDL_DisplayData *) SDL_GetDisplayForWindow(focused_win)->driverdata; SDL_DisplayData *displaydata = (SDL_DisplayData *) SDL_GetDisplayForWindow(focused_win)->driverdata;
Display *x_disp = info.info.x11.display; Display *x_disp = info.info.x11.display;
Window x_win = info.info.x11.window; Window x_win = info.info.x11.window;
int x_screen = displaydata->screen; int x_screen = displaydata->screen;
Window unused; Window unused;
X11_XTranslateCoordinates(x_disp, x_win, RootWindow(x_disp, x_screen), 0, 0, &x, &y, &unused); X11_XTranslateCoordinates(x_disp, x_win, RootWindow(x_disp, x_screen), 0, 0, &x, &y, &unused);
} }
#endif #endif

6
src/core/linux/SDL_ime.c
View file

@ -83,8 +83,7 @@ static void InitIME()
#endif /* HAVE_IBUS_IBUS_H */ #endif /* HAVE_IBUS_IBUS_H */
} }
SDL_bool SDL_bool SDL_IME_Init(void)
SDL_IME_Init(void)
{ {
InitIME(); InitIME();
@ -127,8 +126,7 @@ void SDL_IME_Reset(void)
} }
} }
SDL_bool SDL_bool SDL_IME_ProcessKeyEvent(Uint32 keysym, Uint32 keycode, Uint8 state)
SDL_IME_ProcessKeyEvent(Uint32 keysym, Uint32 keycode, Uint8 state)
{ {
if (SDL_IME_ProcessKeyEvent_Real) { if (SDL_IME_ProcessKeyEvent_Real) {
return SDL_IME_ProcessKeyEvent_Real(keysym, keycode, state); return SDL_IME_ProcessKeyEvent_Real(keysym, keycode, state);

6
src/core/linux/SDL_udev.c
View file

@ -222,8 +222,7 @@ void SDL_UDEV_Scan(void)
_this->syms.udev_enumerate_unref(enumerate); _this->syms.udev_enumerate_unref(enumerate);
} }
SDL_bool SDL_bool SDL_UDEV_GetProductInfo(const char *device_path, Uint16 *vendor, Uint16 *product, Uint16 *version)
SDL_UDEV_GetProductInfo(const char *device_path, Uint16 *vendor, Uint16 *product, Uint16 *version)
{ {
struct udev_enumerate *enumerate = NULL; struct udev_enumerate *enumerate = NULL;
struct udev_list_entry *devs = NULL; struct udev_list_entry *devs = NULL;
@ -550,8 +549,7 @@ void SDL_UDEV_DelCallback(SDL_UDEV_Callback cb)
} }
} }
const SDL_UDEV_Symbols * const SDL_UDEV_Symbols *SDL_UDEV_GetUdevSyms(void)
SDL_UDEV_GetUdevSyms(void)
{ {
if (SDL_UDEV_Init() < 0) { if (SDL_UDEV_Init() < 0) {
SDL_SetError("Could not initialize UDEV"); SDL_SetError("Could not initialize UDEV");

3
src/core/windows/SDL_immdevice.c
View file

@ -505,8 +505,7 @@ int SDL_IMMDevice_GetDefaultAudioInfo(char **name, SDL_AudioSpec *spec, int isca
return 0; return 0;
} }
SDL_AudioFormat SDL_AudioFormat WaveFormatToSDLFormat(WAVEFORMATEX *waveformat)
WaveFormatToSDLFormat(WAVEFORMATEX *waveformat)
{ {
if ((waveformat->wFormatTag == WAVE_FORMAT_IEEE_FLOAT) && (waveformat->wBitsPerSample == 32)) { if ((waveformat->wFormatTag == WAVE_FORMAT_IEEE_FLOAT) && (waveformat->wBitsPerSample == 32)) {
return AUDIO_F32SYS; return AUDIO_F32SYS;

9
src/core/windows/SDL_windows.c
View file

@ -122,8 +122,7 @@ void WIN_CoUninitialize(void)
} }
#ifndef __WINRT__ #ifndef __WINRT__
void * void *WIN_LoadComBaseFunction(const char *name)
WIN_LoadComBaseFunction(const char *name)
{ {
static SDL_bool s_bLoaded; static SDL_bool s_bLoaded;
static HMODULE s_hComBase; static HMODULE s_hComBase;
@ -248,8 +247,7 @@ has the same problem.)
WASAPI doesn't need this. This is just for DirectSound/WinMM. WASAPI doesn't need this. This is just for DirectSound/WinMM.
*/ */
char * char *WIN_LookupAudioDeviceName(const WCHAR *name, const GUID *guid)
WIN_LookupAudioDeviceName(const WCHAR *name, const GUID *guid)
{ {
#if defined(__WINRT__) || defined(__XBOXONE__) || defined(__XBOXSERIES__) #if defined(__WINRT__) || defined(__XBOXONE__) || defined(__XBOXSERIES__)
return WIN_StringToUTF8(name); /* No registry access on WinRT/UWP and Xbox, go with what we've got. */ return WIN_StringToUTF8(name); /* No registry access on WinRT/UWP and Xbox, go with what we've got. */
@ -370,8 +368,7 @@ int SDL_Direct3D9GetAdapterIndex(int displayIndex)
return 0; /* D3DADAPTER_DEFAULT */ return 0; /* D3DADAPTER_DEFAULT */
} }
SDL_bool SDL_bool SDL_DXGIGetOutputInfo(int displayIndex, int *adapterIndex, int *outputIndex)
SDL_DXGIGetOutputInfo(int displayIndex, int *adapterIndex, int *outputIndex)
{ {
(void)displayIndex; (void)displayIndex;
if (adapterIndex) { if (adapterIndex) {

54
src/cpuinfo/SDL_cpuinfo.c
View file

@ -991,92 +991,77 @@ SDL_bool SDL_HasRDTSC(void)
return CPU_FEATURE_AVAILABLE(CPU_HAS_RDTSC); return CPU_FEATURE_AVAILABLE(CPU_HAS_RDTSC);
} }
SDL_bool SDL_bool SDL_HasAltiVec(void)
SDL_HasAltiVec(void)
{ {
return CPU_FEATURE_AVAILABLE(CPU_HAS_ALTIVEC); return CPU_FEATURE_AVAILABLE(CPU_HAS_ALTIVEC);
} }
SDL_bool SDL_bool SDL_HasMMX(void)
SDL_HasMMX(void)
{ {
return CPU_FEATURE_AVAILABLE(CPU_HAS_MMX); return CPU_FEATURE_AVAILABLE(CPU_HAS_MMX);
} }
SDL_bool SDL_bool SDL_Has3DNow(void)
SDL_Has3DNow(void)
{ {
return CPU_FEATURE_AVAILABLE(CPU_HAS_3DNOW); return CPU_FEATURE_AVAILABLE(CPU_HAS_3DNOW);
} }
SDL_bool SDL_bool SDL_HasSSE(void)
SDL_HasSSE(void)
{ {
return CPU_FEATURE_AVAILABLE(CPU_HAS_SSE); return CPU_FEATURE_AVAILABLE(CPU_HAS_SSE);
} }
SDL_bool SDL_bool SDL_HasSSE2(void)
SDL_HasSSE2(void)
{ {
return CPU_FEATURE_AVAILABLE(CPU_HAS_SSE2); return CPU_FEATURE_AVAILABLE(CPU_HAS_SSE2);
} }
SDL_bool SDL_bool SDL_HasSSE3(void)
SDL_HasSSE3(void)
{ {
return CPU_FEATURE_AVAILABLE(CPU_HAS_SSE3); return CPU_FEATURE_AVAILABLE(CPU_HAS_SSE3);
} }
SDL_bool SDL_bool SDL_HasSSE41(void)
SDL_HasSSE41(void)
{ {
return CPU_FEATURE_AVAILABLE(CPU_HAS_SSE41); return CPU_FEATURE_AVAILABLE(CPU_HAS_SSE41);
} }
SDL_bool SDL_bool SDL_HasSSE42(void)
SDL_HasSSE42(void)
{ {
return CPU_FEATURE_AVAILABLE(CPU_HAS_SSE42); return CPU_FEATURE_AVAILABLE(CPU_HAS_SSE42);
} }
SDL_bool SDL_bool SDL_HasAVX(void)
SDL_HasAVX(void)
{ {
return CPU_FEATURE_AVAILABLE(CPU_HAS_AVX); return CPU_FEATURE_AVAILABLE(CPU_HAS_AVX);
} }
SDL_bool SDL_bool SDL_HasAVX2(void)
SDL_HasAVX2(void)
{ {
return CPU_FEATURE_AVAILABLE(CPU_HAS_AVX2); return CPU_FEATURE_AVAILABLE(CPU_HAS_AVX2);
} }
SDL_bool SDL_bool SDL_HasAVX512F(void)
SDL_HasAVX512F(void)
{ {
return CPU_FEATURE_AVAILABLE(CPU_HAS_AVX512F); return CPU_FEATURE_AVAILABLE(CPU_HAS_AVX512F);
} }
SDL_bool SDL_bool SDL_HasARMSIMD(void)
SDL_HasARMSIMD(void)
{ {
return CPU_FEATURE_AVAILABLE(CPU_HAS_ARM_SIMD); return CPU_FEATURE_AVAILABLE(CPU_HAS_ARM_SIMD);
} }
SDL_bool SDL_bool SDL_HasNEON(void)
SDL_HasNEON(void)
{ {
return CPU_FEATURE_AVAILABLE(CPU_HAS_NEON); return CPU_FEATURE_AVAILABLE(CPU_HAS_NEON);
} }
SDL_bool SDL_bool SDL_HasLSX(void)
SDL_HasLSX(void)
{ {
return CPU_FEATURE_AVAILABLE(CPU_HAS_LSX); return CPU_FEATURE_AVAILABLE(CPU_HAS_LSX);
} }
SDL_bool SDL_bool SDL_HasLASX(void)
SDL_HasLASX(void)
{ {
return CPU_FEATURE_AVAILABLE(CPU_HAS_LASX); return CPU_FEATURE_AVAILABLE(CPU_HAS_LASX);
} }
@ -1155,8 +1140,7 @@ int SDL_GetSystemRAM(void)
return SDL_SystemRAM; return SDL_SystemRAM;
} }
size_t size_t SDL_SIMDGetAlignment(void)
SDL_SIMDGetAlignment(void)
{ {
if (SDL_SIMDAlignment == 0xFFFFFFFF) { if (SDL_SIMDAlignment == 0xFFFFFFFF) {
SDL_GetCPUFeatures(); /* make sure this has been calculated */ SDL_GetCPUFeatures(); /* make sure this has been calculated */
@ -1165,8 +1149,7 @@ SDL_SIMDGetAlignment(void)
return SDL_SIMDAlignment; return SDL_SIMDAlignment;
} }
void * void *SDL_SIMDAlloc(const size_t len)
SDL_SIMDAlloc(const size_t len)
{ {
const size_t alignment = SDL_SIMDGetAlignment(); const size_t alignment = SDL_SIMDGetAlignment();
const size_t padding = (alignment - (len % alignment)) % alignment; const size_t padding = (alignment - (len % alignment)) % alignment;
@ -1190,8 +1173,7 @@ SDL_SIMDAlloc(const size_t len)
return retval; return retval;
} }
void * void *SDL_SIMDRealloc(void *mem, const size_t len)
SDL_SIMDRealloc(void *mem, const size_t len)
{ {
const size_t alignment = SDL_SIMDGetAlignment(); const size_t alignment = SDL_SIMDGetAlignment();
const size_t padding = (alignment - (len % alignment)) % alignment; const size_t padding = (alignment - (len % alignment)) % alignment;

3
src/dynapi/SDL_dynapi.c
View file

@ -350,8 +350,7 @@ static Sint32 initialize_jumptable(Uint32 apiver, void *table, Uint32 tablesize)
typedef Sint32(SDLCALL *SDL_DYNAPI_ENTRYFN)(Uint32 apiver, void *table, Uint32 tablesize); typedef Sint32(SDLCALL *SDL_DYNAPI_ENTRYFN)(Uint32 apiver, void *table, Uint32 tablesize);
extern DECLSPEC Sint32 SDLCALL SDL_DYNAPI_entry(Uint32, void *, Uint32); extern DECLSPEC Sint32 SDLCALL SDL_DYNAPI_entry(Uint32, void *, Uint32);
Sint32 Sint32 SDL_DYNAPI_entry(Uint32 apiver, void *table, Uint32 tablesize)
SDL_DYNAPI_entry(Uint32 apiver, void *table, Uint32 tablesize)
{ {
return initialize_jumptable(apiver, table, tablesize); return initialize_jumptable(apiver, table, tablesize);
} }

33
src/events/SDL_keyboard.c
View file

@ -640,8 +640,7 @@ static const char *SDL_scancode_names[SDL_NUM_SCANCODES] = {
}; };
/* Taken from SDL_iconv() */ /* Taken from SDL_iconv() */
char * char *SDL_UCS4ToUTF8(Uint32 ch, char *dst)
SDL_UCS4ToUTF8(Uint32 ch, char *dst)
{ {
Uint8 *p = (Uint8 *)dst; Uint8 *p = (Uint8 *)dst;
if (ch <= 0x7F) { if (ch <= 0x7F) {
@ -756,8 +755,7 @@ void SDL_SetScancodeName(SDL_Scancode scancode, const char *name)
SDL_scancode_names[scancode] = name; SDL_scancode_names[scancode] = name;
} }
SDL_Window * SDL_Window *SDL_GetKeyboardFocus(void)
SDL_GetKeyboardFocus(void)
{ {
SDL_Keyboard *keyboard = &SDL_keyboard; SDL_Keyboard *keyboard = &SDL_keyboard;
@ -1011,8 +1009,7 @@ void SDL_ReleaseAutoReleaseKeys(void)
} }
} }
SDL_bool SDL_bool SDL_HardwareKeyboardKeyPressed(void)
SDL_HardwareKeyboardKeyPressed(void)
{ {
SDL_Keyboard *keyboard = &SDL_keyboard; SDL_Keyboard *keyboard = &SDL_keyboard;
SDL_Scancode scancode; SDL_Scancode scancode;
@ -1089,8 +1086,7 @@ void SDL_KeyboardQuit(void)
{ {
} }
const Uint8 * const Uint8 *SDL_GetKeyboardState(int *numkeys)
SDL_GetKeyboardState(int *numkeys)
{ {
SDL_Keyboard *keyboard = &SDL_keyboard; SDL_Keyboard *keyboard = &SDL_keyboard;
@ -1100,8 +1096,7 @@ SDL_GetKeyboardState(int *numkeys)
return keyboard->keystate; return keyboard->keystate;
} }
SDL_Keymod SDL_Keymod SDL_GetModState(void)
SDL_GetModState(void)
{ {
SDL_Keyboard *keyboard = &SDL_keyboard; SDL_Keyboard *keyboard = &SDL_keyboard;
@ -1126,8 +1121,7 @@ void SDL_ToggleModState(const SDL_Keymod modstate, const SDL_bool toggle)
} }
} }
SDL_Keycode SDL_Keycode SDL_GetKeyFromScancode(SDL_Scancode scancode)
SDL_GetKeyFromScancode(SDL_Scancode scancode)
{ {
SDL_Keyboard *keyboard = &SDL_keyboard; SDL_Keyboard *keyboard = &SDL_keyboard;
@ -1139,8 +1133,7 @@ SDL_GetKeyFromScancode(SDL_Scancode scancode)
return keyboard->keymap[scancode]; return keyboard->keymap[scancode];
} }
SDL_Keycode SDL_Keycode SDL_GetDefaultKeyFromScancode(SDL_Scancode scancode)
SDL_GetDefaultKeyFromScancode(SDL_Scancode scancode)
{ {
if (((int)scancode) < SDL_SCANCODE_UNKNOWN || scancode >= SDL_NUM_SCANCODES) { if (((int)scancode) < SDL_SCANCODE_UNKNOWN || scancode >= SDL_NUM_SCANCODES) {
SDL_InvalidParamError("scancode"); SDL_InvalidParamError("scancode");
@ -1150,8 +1143,7 @@ SDL_GetDefaultKeyFromScancode(SDL_Scancode scancode)
return SDL_default_keymap[scancode]; return SDL_default_keymap[scancode];
} }
SDL_Scancode SDL_Scancode SDL_GetScancodeFromKey(SDL_Keycode key)
SDL_GetScancodeFromKey(SDL_Keycode key)
{ {
SDL_Keyboard *keyboard = &SDL_keyboard; SDL_Keyboard *keyboard = &SDL_keyboard;
SDL_Scancode scancode; SDL_Scancode scancode;
@ -1165,8 +1157,7 @@ SDL_GetScancodeFromKey(SDL_Keycode key)
return SDL_SCANCODE_UNKNOWN; return SDL_SCANCODE_UNKNOWN;
} }
const char * const char *SDL_GetScancodeName(SDL_Scancode scancode)
SDL_GetScancodeName(SDL_Scancode scancode)
{ {
const char *name; const char *name;
if (((int)scancode) < SDL_SCANCODE_UNKNOWN || scancode >= SDL_NUM_SCANCODES) { if (((int)scancode) < SDL_SCANCODE_UNKNOWN || scancode >= SDL_NUM_SCANCODES) {
@ -1204,8 +1195,7 @@ SDL_Scancode SDL_GetScancodeFromName(const char *name)
return SDL_SCANCODE_UNKNOWN; return SDL_SCANCODE_UNKNOWN;
} }
const char * const char *SDL_GetKeyName(SDL_Keycode key)
SDL_GetKeyName(SDL_Keycode key)
{ {
static char name[8]; static char name[8];
char *end; char *end;
@ -1242,8 +1232,7 @@ SDL_GetKeyName(SDL_Keycode key)
} }
} }
SDL_Keycode SDL_Keycode SDL_GetKeyFromName(const char *name)
SDL_GetKeyFromName(const char *name)
{ {
SDL_Keycode key; SDL_Keycode key;

3
src/events/SDL_keysym_to_scancode.c
View file

@ -387,8 +387,7 @@ static const struct {
}; };
/* *INDENT-ON* */ /* clang-format on */ /* *INDENT-ON* */ /* clang-format on */
SDL_Scancode SDL_Scancode SDL_GetScancodeFromKeySym(Uint32 keysym, Uint32 keycode)
SDL_GetScancodeFromKeySym(Uint32 keysym, Uint32 keycode)
{ {
int i; int i;
Uint32 linux_keycode = 0; Uint32 linux_keycode = 0;

36
src/events/SDL_mouse.c
View file

@ -226,8 +226,7 @@ void SDL_SetDefaultCursor(SDL_Cursor *cursor)
} }
} }
SDL_Mouse * SDL_Mouse *SDL_GetMouse(void)
SDL_GetMouse(void)
{ {
return &SDL_mouse; return &SDL_mouse;
} }
@ -245,8 +244,7 @@ static Uint32 GetButtonState(SDL_Mouse *mouse, SDL_bool include_touch)
return buttonstate; return buttonstate;
} }
SDL_Window * SDL_Window *SDL_GetMouseFocus(void)
SDL_GetMouseFocus(void)
{ {
SDL_Mouse *mouse = SDL_GetMouse(); SDL_Mouse *mouse = SDL_GetMouse();
@ -261,8 +259,7 @@ SDL_GetMouseFocus(void)
* -flibit * -flibit
*/ */
#if 0 #if 0
void void SDL_ResetMouse(void)
SDL_ResetMouse(void)
{ {
SDL_Mouse *mouse = SDL_GetMouse(); SDL_Mouse *mouse = SDL_GetMouse();
Uint32 buttonState = GetButtonState(mouse, SDL_FALSE); Uint32 buttonState = GetButtonState(mouse, SDL_FALSE);
@ -946,8 +943,7 @@ void SDL_MouseQuit(void)
SDL_MouseRelativeWarpMotionChanged, mouse); SDL_MouseRelativeWarpMotionChanged, mouse);
} }
Uint32 Uint32 SDL_GetMouseState(int *x, int *y)
SDL_GetMouseState(int *x, int *y)
{ {
SDL_Mouse *mouse = SDL_GetMouse(); SDL_Mouse *mouse = SDL_GetMouse();
@ -960,8 +956,7 @@ SDL_GetMouseState(int *x, int *y)
return GetButtonState(mouse, SDL_TRUE); return GetButtonState(mouse, SDL_TRUE);
} }
Uint32 Uint32 SDL_GetRelativeMouseState(int *x, int *y)
SDL_GetRelativeMouseState(int *x, int *y)
{ {
SDL_Mouse *mouse = SDL_GetMouse(); SDL_Mouse *mouse = SDL_GetMouse();
@ -976,8 +971,7 @@ SDL_GetRelativeMouseState(int *x, int *y)
return GetButtonState(mouse, SDL_TRUE); return GetButtonState(mouse, SDL_TRUE);
} }
Uint32 Uint32 SDL_GetGlobalMouseState(int *x, int *y)
SDL_GetGlobalMouseState(int *x, int *y)
{ {
SDL_Mouse *mouse = SDL_GetMouse(); SDL_Mouse *mouse = SDL_GetMouse();
@ -1133,8 +1127,7 @@ int SDL_SetRelativeMouseMode(SDL_bool enabled)
return 0; return 0;
} }
SDL_bool SDL_bool SDL_GetRelativeMouseMode()
SDL_GetRelativeMouseMode()
{ {
SDL_Mouse *mouse = SDL_GetMouse(); SDL_Mouse *mouse = SDL_GetMouse();
@ -1219,8 +1212,7 @@ int SDL_CaptureMouse(SDL_bool enabled)
return SDL_UpdateMouseCapture(SDL_FALSE); return SDL_UpdateMouseCapture(SDL_FALSE);
} }
SDL_Cursor * SDL_Cursor *SDL_CreateCursor(const Uint8 *data, const Uint8 *mask,
SDL_CreateCursor(const Uint8 *data, const Uint8 *mask,
int w, int h, int hot_x, int hot_y) int w, int h, int hot_x, int hot_y)
{ {
SDL_Surface *surface; SDL_Surface *surface;
@ -1268,8 +1260,7 @@ SDL_CreateCursor(const Uint8 *data, const Uint8 *mask,
return cursor; return cursor;
} }
SDL_Cursor * SDL_Cursor *SDL_CreateColorCursor(SDL_Surface *surface, int hot_x, int hot_y)
SDL_CreateColorCursor(SDL_Surface *surface, int hot_x, int hot_y)
{ {
SDL_Mouse *mouse = SDL_GetMouse(); SDL_Mouse *mouse = SDL_GetMouse();
SDL_Surface *temp = NULL; SDL_Surface *temp = NULL;
@ -1311,8 +1302,7 @@ SDL_CreateColorCursor(SDL_Surface *surface, int hot_x, int hot_y)
return cursor; return cursor;
} }
SDL_Cursor * SDL_Cursor *SDL_CreateSystemCursor(SDL_SystemCursor id)
SDL_CreateSystemCursor(SDL_SystemCursor id)
{ {
SDL_Mouse *mouse = SDL_GetMouse(); SDL_Mouse *mouse = SDL_GetMouse();
SDL_Cursor *cursor; SDL_Cursor *cursor;
@ -1379,8 +1369,7 @@ void SDL_SetCursor(SDL_Cursor *cursor)
} }
} }
SDL_Cursor * SDL_Cursor *SDL_GetCursor(void)
SDL_GetCursor(void)
{ {
SDL_Mouse *mouse = SDL_GetMouse(); SDL_Mouse *mouse = SDL_GetMouse();
@ -1390,8 +1379,7 @@ SDL_GetCursor(void)
return mouse->cur_cursor; return mouse->cur_cursor;
} }
SDL_Cursor * SDL_Cursor *SDL_GetDefaultCursor(void)
SDL_GetDefaultCursor(void)
{ {
SDL_Mouse *mouse = SDL_GetMouse(); SDL_Mouse *mouse = SDL_GetMouse();

15
src/events/SDL_touch.c
View file

@ -50,8 +50,7 @@ int SDL_GetNumTouchDevices(void)
return SDL_num_touch; return SDL_num_touch;
} }
SDL_TouchID SDL_TouchID SDL_GetTouchDevice(int index)
SDL_GetTouchDevice(int index)
{ {
if (index < 0 || index >= SDL_num_touch) { if (index < 0 || index >= SDL_num_touch) {
SDL_SetError("Unknown touch device index %d", index); SDL_SetError("Unknown touch device index %d", index);
@ -60,8 +59,7 @@ SDL_GetTouchDevice(int index)
return SDL_touchDevices[index]->id; return SDL_touchDevices[index]->id;
} }
const char * const char *SDL_GetTouchName(int index)
SDL_GetTouchName(int index)
{ {
if (index < 0 || index >= SDL_num_touch) { if (index < 0 || index >= SDL_num_touch) {
SDL_SetError("Unknown touch device"); SDL_SetError("Unknown touch device");
@ -84,8 +82,7 @@ static int SDL_GetTouchIndex(SDL_TouchID id)
return -1; return -1;
} }
SDL_Touch * SDL_Touch *SDL_GetTouch(SDL_TouchID id)
SDL_GetTouch(SDL_TouchID id)
{ {
int index = SDL_GetTouchIndex(id); int index = SDL_GetTouchIndex(id);
if (index < 0 || index >= SDL_num_touch) { if (index < 0 || index >= SDL_num_touch) {
@ -100,8 +97,7 @@ SDL_GetTouch(SDL_TouchID id)
return SDL_touchDevices[index]; return SDL_touchDevices[index];
} }
SDL_TouchDeviceType SDL_TouchDeviceType SDL_GetTouchDeviceType(SDL_TouchID id)
SDL_GetTouchDeviceType(SDL_TouchID id)
{ {
SDL_Touch *touch = SDL_GetTouch(id); SDL_Touch *touch = SDL_GetTouch(id);
if (touch) { if (touch) {
@ -139,8 +135,7 @@ int SDL_GetNumTouchFingers(SDL_TouchID touchID)
return 0; return 0;
} }
SDL_Finger * SDL_Finger *SDL_GetTouchFinger(SDL_TouchID touchID, int index)
SDL_GetTouchFinger(SDL_TouchID touchID, int index)
{ {
SDL_Touch *touch = SDL_GetTouch(touchID); SDL_Touch *touch = SDL_GetTouch(touchID);
if (touch == NULL) { if (touch == NULL) {

51
src/file/SDL_rwops.c
View file

@ -522,8 +522,7 @@ static int SDLCALL mem_close(SDL_RWops *context)
/* Functions to create SDL_RWops structures from various data sources */ /* Functions to create SDL_RWops structures from various data sources */
SDL_RWops * SDL_RWops *SDL_RWFromFile(const char *file, const char *mode)
SDL_RWFromFile(const char *file, const char *mode)
{ {
SDL_RWops *rwops = NULL; SDL_RWops *rwops = NULL;
if (file == NULL || !*file || mode == NULL || !*mode) { if (file == NULL || !*file || mode == NULL || !*mode) {
@ -616,8 +615,7 @@ SDL_RWFromFile(const char *file, const char *mode)
} }
#ifdef HAVE_STDIO_H #ifdef HAVE_STDIO_H
SDL_RWops * SDL_RWops *SDL_RWFromFP(FILE * fp, SDL_bool autoclose)
SDL_RWFromFP(FILE * fp, SDL_bool autoclose)
{ {
SDL_RWops *rwops = NULL; SDL_RWops *rwops = NULL;
@ -635,16 +633,14 @@ SDL_RWFromFP(FILE * fp, SDL_bool autoclose)
return rwops; return rwops;
} }
#else #else
SDL_RWops * SDL_RWops *SDL_RWFromFP(void * fp, SDL_bool autoclose)
SDL_RWFromFP(void * fp, SDL_bool autoclose)
{ {
SDL_SetError("SDL not compiled with stdio support"); SDL_SetError("SDL not compiled with stdio support");
return NULL; return NULL;
} }
#endif /* HAVE_STDIO_H */ #endif /* HAVE_STDIO_H */
SDL_RWops * SDL_RWops *SDL_RWFromMem(void *mem, int size)
SDL_RWFromMem(void *mem, int size)
{ {
SDL_RWops *rwops = NULL; SDL_RWops *rwops = NULL;
if (mem == NULL) { if (mem == NULL) {
@ -671,8 +667,7 @@ SDL_RWFromMem(void *mem, int size)
return rwops; return rwops;
} }
SDL_RWops * SDL_RWops *SDL_RWFromConstMem(const void *mem, int size)
SDL_RWFromConstMem(const void *mem, int size)
{ {
SDL_RWops *rwops = NULL; SDL_RWops *rwops = NULL;
if (mem == NULL) { if (mem == NULL) {
@ -699,8 +694,7 @@ SDL_RWFromConstMem(const void *mem, int size)
return rwops; return rwops;
} }
SDL_RWops * SDL_RWops *SDL_AllocRW(void)
SDL_AllocRW(void)
{ {
SDL_RWops *area; SDL_RWops *area;
@ -719,8 +713,7 @@ void SDL_FreeRW(SDL_RWops *area)
} }
/* Load all the data from an SDL data stream */ /* Load all the data from an SDL data stream */
void * void *SDL_LoadFile_RW(SDL_RWops *src, size_t *datasize, int freesrc)
SDL_LoadFile_RW(SDL_RWops *src, size_t *datasize, int freesrc)
{ {
static const Sint64 FILE_CHUNK_SIZE = 1024; static const Sint64 FILE_CHUNK_SIZE = 1024;
Sint64 size; Sint64 size;
@ -771,26 +764,22 @@ done:
return data; return data;
} }
void * void *SDL_LoadFile(const char *file, size_t *datasize)
SDL_LoadFile(const char *file, size_t *datasize)
{ {
return SDL_LoadFile_RW(SDL_RWFromFile(file, "rb"), datasize, 1); return SDL_LoadFile_RW(SDL_RWFromFile(file, "rb"), datasize, 1);
} }
Sint64 Sint64 SDL_RWsize(SDL_RWops *context)
SDL_RWsize(SDL_RWops *context)
{ {
return context->size(context); return context->size(context);
} }
Sint64 Sint64 SDL_RWseek(SDL_RWops *context, Sint64 offset, int whence)
SDL_RWseek(SDL_RWops *context, Sint64 offset, int whence)
{ {
return context->seek(context, offset, whence); return context->seek(context, offset, whence);
} }
Sint64 Sint64 SDL_RWtell(SDL_RWops *context)
SDL_RWtell(SDL_RWops *context)
{ {
return context->seek(context, 0, RW_SEEK_CUR); return context->seek(context, 0, RW_SEEK_CUR);
} }
@ -822,8 +811,7 @@ Uint8 SDL_ReadU8(SDL_RWops *src)
return value; return value;
} }
Uint16 Uint16 SDL_ReadLE16(SDL_RWops *src)
SDL_ReadLE16(SDL_RWops *src)
{ {
Uint16 value = 0; Uint16 value = 0;
@ -831,8 +819,7 @@ SDL_ReadLE16(SDL_RWops *src)
return SDL_SwapLE16(value); return SDL_SwapLE16(value);
} }
Uint16 Uint16 SDL_ReadBE16(SDL_RWops *src)
SDL_ReadBE16(SDL_RWops *src)
{ {
Uint16 value = 0; Uint16 value = 0;
@ -840,8 +827,7 @@ SDL_ReadBE16(SDL_RWops *src)
return SDL_SwapBE16(value); return SDL_SwapBE16(value);
} }
Uint32 Uint32 SDL_ReadLE32(SDL_RWops *src)
SDL_ReadLE32(SDL_RWops *src)
{ {
Uint32 value = 0; Uint32 value = 0;
@ -849,8 +835,7 @@ SDL_ReadLE32(SDL_RWops *src)
return SDL_SwapLE32(value); return SDL_SwapLE32(value);
} }
Uint32 Uint32 SDL_ReadBE32(SDL_RWops *src)
SDL_ReadBE32(SDL_RWops *src)
{ {
Uint32 value = 0; Uint32 value = 0;
@ -858,8 +843,7 @@ SDL_ReadBE32(SDL_RWops *src)
return SDL_SwapBE32(value); return SDL_SwapBE32(value);
} }
Uint64 Uint64 SDL_ReadLE64(SDL_RWops *src)
SDL_ReadLE64(SDL_RWops *src)
{ {
Uint64 value = 0; Uint64 value = 0;
@ -867,8 +851,7 @@ SDL_ReadLE64(SDL_RWops *src)
return SDL_SwapLE64(value); return SDL_SwapLE64(value);
} }
Uint64 Uint64 SDL_ReadBE64(SDL_RWops *src)
SDL_ReadBE64(SDL_RWops *src)
{ {
Uint64 value = 0; Uint64 value = 0;

23
src/file/n3ds/SDL_rwopsromfs.c
View file

@ -23,21 +23,20 @@
#include "SDL_error.h" #include "SDL_error.h"
/* Checks if the mode is a kind of reading */ /* Checks if the mode is a kind of reading */
SDL_FORCE_INLINE SDL_bool IsReadMode(const char *mode); static SDL_bool IsReadMode(const char *mode);
/* Checks if the file starts with the given prefix */ /* Checks if the file starts with the given prefix */
SDL_FORCE_INLINE SDL_bool HasPrefix(const char *file, const char *prefix); static SDL_bool HasPrefix(const char *file, const char *prefix);
SDL_FORCE_INLINE FILE *TryOpenFile(const char *file, const char *mode); static FILE *TryOpenFile(const char *file, const char *mode);
SDL_FORCE_INLINE FILE *TryOpenInRomfs(const char *file, const char *mode); static FILE *TryOpenInRomfs(const char *file, const char *mode);
/* Nintendo 3DS applications may embed resources in the executable. The /* Nintendo 3DS applications may embed resources in the executable. The
resources are stored in a special read-only partition prefixed with resources are stored in a special read-only partition prefixed with
'romfs:/'. As such, when opening a file, we should first try the romfs 'romfs:/'. As such, when opening a file, we should first try the romfs
unless sdmc is specifically mentionned. unless sdmc is specifically mentionned.
*/ */
FILE * FILE *N3DS_FileOpen(const char *file, const char *mode)
N3DS_FileOpen(const char *file, const char *mode)
{ {
/* romfs are read-only */ /* romfs are read-only */
if (!IsReadMode(mode)) { if (!IsReadMode(mode)) {
@ -52,20 +51,17 @@ N3DS_FileOpen(const char *file, const char *mode)
return TryOpenFile(file, mode); return TryOpenFile(file, mode);
} }
SDL_FORCE_INLINE SDL_bool static SDL_bool IsReadMode(const char *mode)
IsReadMode(const char *mode)
{ {
return SDL_strchr(mode, 'r') != NULL; return SDL_strchr(mode, 'r') != NULL;
} }
SDL_FORCE_INLINE SDL_bool static SDL_bool HasPrefix(const char *file, const char *prefix)
HasPrefix(const char *file, const char *prefix)
{ {
return SDL_strncmp(prefix, file, SDL_strlen(prefix)) == 0; return SDL_strncmp(prefix, file, SDL_strlen(prefix)) == 0;
} }
SDL_FORCE_INLINE FILE * static FILE *TryOpenFile(const char *file, const char *mode)
TryOpenFile(const char *file, const char *mode)
{ {
FILE *fp = NULL; FILE *fp = NULL;
@ -77,8 +73,7 @@ TryOpenFile(const char *file, const char *mode)
return fp; return fp;
} }
SDL_FORCE_INLINE FILE * static FILE *TryOpenInRomfs(const char *file, const char *mode)
TryOpenInRomfs(const char *file, const char *mode)
{ {
FILE *fp = NULL; FILE *fp = NULL;
char *prefixed_filepath = NULL; char *prefixed_filepath = NULL;

6
src/filesystem/android/SDL_sysfilesystem.c
View file

@ -32,16 +32,14 @@
#include "SDL_system.h" #include "SDL_system.h"
char * char *SDL_GetBasePath(void)
SDL_GetBasePath(void)
{ {
/* The current working directory is / on Android */ /* The current working directory is / on Android */
SDL_Unsupported(); SDL_Unsupported();
return NULL; return NULL;
} }
char * char *SDL_GetPrefPath(const char *org, const char *app)
SDL_GetPrefPath(const char *org, const char *app)
{ {
const char *path = SDL_AndroidGetInternalStoragePath(); const char *path = SDL_AndroidGetInternalStoragePath();
if (path) { if (path) {

6
src/filesystem/cocoa/SDL_sysfilesystem.m
View file

@ -33,8 +33,7 @@
#include "SDL_stdinc.h" #include "SDL_stdinc.h"
#include "SDL_filesystem.h" #include "SDL_filesystem.h"
char * char *SDL_GetBasePath(void)
SDL_GetBasePath(void)
{ {
@autoreleasepool { @autoreleasepool {
NSBundle *bundle = [NSBundle mainBundle]; NSBundle *bundle = [NSBundle mainBundle];
@ -68,8 +67,7 @@ SDL_GetBasePath(void)
} }
} }
char * char *SDL_GetPrefPath(const char *org, const char *app)
SDL_GetPrefPath(const char *org, const char *app)
{ {
@autoreleasepool { @autoreleasepool {
char *retval = NULL; char *retval = NULL;

6
src/filesystem/dummy/SDL_sysfilesystem.c
View file

@ -28,15 +28,13 @@
#include "SDL_error.h" #include "SDL_error.h"
#include "SDL_filesystem.h" #include "SDL_filesystem.h"
char * char *SDL_GetBasePath(void)
SDL_GetBasePath(void)
{ {
SDL_Unsupported(); SDL_Unsupported();
return NULL; return NULL;
} }
char * char *SDL_GetPrefPath(const char *org, const char *app)
SDL_GetPrefPath(const char *org, const char *app)
{ {
SDL_Unsupported(); SDL_Unsupported();
return NULL; return NULL;

6
src/filesystem/emscripten/SDL_sysfilesystem.c
View file

@ -32,15 +32,13 @@
#include <emscripten/emscripten.h> #include <emscripten/emscripten.h>
char * char *SDL_GetBasePath(void)
SDL_GetBasePath(void)
{ {
char *retval = "/"; char *retval = "/";
return SDL_strdup(retval); return SDL_strdup(retval);
} }
char * char *SDL_GetPrefPath(const char *org, const char *app)
SDL_GetPrefPath(const char *org, const char *app)
{ {
const char *append = "/libsdl/"; const char *append = "/libsdl/";
char *retval; char *retval;

6
src/filesystem/haiku/SDL_sysfilesystem.cc
View file

@ -34,8 +34,7 @@
#include "SDL_stdinc.h" #include "SDL_stdinc.h"
#include "SDL_filesystem.h" #include "SDL_filesystem.h"
char * char *SDL_GetBasePath(void)
SDL_GetBasePath(void)
{ {
image_info info; image_info info;
int32 cookie = 0; int32 cookie = 0;
@ -69,8 +68,7 @@ SDL_GetBasePath(void)
} }
char * char *SDL_GetPrefPath(const char *org, const char *app)
SDL_GetPrefPath(const char *org, const char *app)
{ {
// !!! FIXME: is there a better way to do this? // !!! FIXME: is there a better way to do this?
const char *home = SDL_getenv("HOME"); const char *home = SDL_getenv("HOME");

6
src/filesystem/n3ds/SDL_sysfilesystem.c
View file

@ -35,15 +35,13 @@
SDL_FORCE_INLINE char *MakePrefPath(const char *app); SDL_FORCE_INLINE char *MakePrefPath(const char *app);
SDL_FORCE_INLINE int CreatePrefPathDir(const char *pref); SDL_FORCE_INLINE int CreatePrefPathDir(const char *pref);
char * char *SDL_GetBasePath(void)
SDL_GetBasePath(void)
{ {
char *base_path = SDL_strdup("romfs:/"); char *base_path = SDL_strdup("romfs:/");
return base_path; return base_path;
} }
char * char *SDL_GetPrefPath(const char *org, const char *app)
SDL_GetPrefPath(const char *org, const char *app)
{ {
char *pref_path = NULL; char *pref_path = NULL;
if (app == NULL) { if (app == NULL) {

6
src/filesystem/nacl/SDL_sysfilesystem.c
View file

@ -24,15 +24,13 @@
#ifdef SDL_FILESYSTEM_NACL #ifdef SDL_FILESYSTEM_NACL
char * char *SDL_GetBasePath(void)
SDL_GetBasePath(void)
{ {
SDL_Unsupported(); SDL_Unsupported();
return NULL; return NULL;
} }
char * char *SDL_GetPrefPath(const char *org, const char *app)
SDL_GetPrefPath(const char *org, const char *app)
{ {
SDL_Unsupported(); SDL_Unsupported();
return NULL; return NULL;

6
src/filesystem/os2/SDL_sysfilesystem.c
View file

@ -36,8 +36,7 @@
#include <os2.h> #include <os2.h>
char * char *SDL_GetBasePath(void)
SDL_GetBasePath(void)
{ {
PTIB tib; PTIB tib;
PPIB pib; PPIB pib;
@ -71,8 +70,7 @@ SDL_GetBasePath(void)
return OS2_SysToUTF8(acBuf); return OS2_SysToUTF8(acBuf);
} }
char * char *SDL_GetPrefPath(const char *org, const char *app)
SDL_GetPrefPath(const char *org, const char *app)
{ {
PSZ pszPath; PSZ pszPath;
CHAR acBuf[CCHMAXPATH]; CHAR acBuf[CCHMAXPATH];

6
src/filesystem/ps2/SDL_sysfilesystem.c
View file

@ -31,8 +31,7 @@
#include "SDL_error.h" #include "SDL_error.h"
#include "SDL_filesystem.h" #include "SDL_filesystem.h"
char * char *SDL_GetBasePath(void)
SDL_GetBasePath(void)
{ {
char *retval; char *retval;
size_t len; size_t len;
@ -78,8 +77,7 @@ static void recursive_mkdir(const char *dir)
mkdir(tmp, S_IRWXU); mkdir(tmp, S_IRWXU);
} }
char * char *SDL_GetPrefPath(const char *org, const char *app)
SDL_GetPrefPath(const char *org, const char *app)
{ {
char *retval = NULL; char *retval = NULL;
size_t len; size_t len;

6
src/filesystem/psp/SDL_sysfilesystem.c
View file

@ -31,8 +31,7 @@
#include "SDL_error.h" #include "SDL_error.h"
#include "SDL_filesystem.h" #include "SDL_filesystem.h"
char * char *SDL_GetBasePath(void)
SDL_GetBasePath(void)
{ {
char *retval = NULL; char *retval = NULL;
size_t len; size_t len;
@ -46,8 +45,7 @@ SDL_GetBasePath(void)
return retval; return retval;
} }
char * char *SDL_GetPrefPath(const char *org, const char *app)
SDL_GetPrefPath(const char *org, const char *app)
{ {
char *retval = NULL; char *retval = NULL;
size_t len; size_t len;

6
src/filesystem/riscos/SDL_sysfilesystem.c
View file

@ -129,8 +129,7 @@ static _kernel_oserror *createDirectoryRecursive(char *path)
return _kernel_swi(OS_File, &regs, &regs); return _kernel_swi(OS_File, &regs, &regs);
} }
char * char *SDL_GetBasePath(void)
SDL_GetBasePath(void)
{ {
_kernel_swi_regs regs; _kernel_swi_regs regs;
_kernel_oserror *error; _kernel_oserror *error;
@ -157,8 +156,7 @@ SDL_GetBasePath(void)
return retval; return retval;
} }
char * char *SDL_GetPrefPath(const char *org, const char *app)
SDL_GetPrefPath(const char *org, const char *app)
{ {
char *canon, *dir, *retval; char *canon, *dir, *retval;
size_t len; size_t len;

9
src/filesystem/unix/SDL_sysfilesystem.c
View file

@ -45,8 +45,7 @@
/* QNX's /proc/self/exefile is a text file and not a symlink. */ /* QNX's /proc/self/exefile is a text file and not a symlink. */
#if !defined(__QNXNTO__) #if !defined(__QNXNTO__)
static char * static char *readSymLink(const char *path)
readSymLink(const char *path)
{ {
char *retval = NULL; char *retval = NULL;
ssize_t len = 64; ssize_t len = 64;
@ -129,8 +128,7 @@ static char *search_path_for_binary(const char *bin)
} }
#endif #endif
char * char *SDL_GetBasePath(void)
SDL_GetBasePath(void)
{ {
char *retval = NULL; char *retval = NULL;
@ -271,8 +269,7 @@ SDL_GetBasePath(void)
return retval; return retval;
} }
char * char *SDL_GetPrefPath(const char *org, const char *app)
SDL_GetPrefPath(const char *org, const char *app)
{ {
/* /*
* We use XDG's base directory spec, even if you're not on Linux. * We use XDG's base directory spec, even if you're not on Linux.

6
src/filesystem/vita/SDL_sysfilesystem.c
View file

@ -39,16 +39,14 @@
#include "SDL_filesystem.h" #include "SDL_filesystem.h"
#include "SDL_rwops.h" #include "SDL_rwops.h"
char * char *SDL_GetBasePath(void)
SDL_GetBasePath(void)
{ {
const char *basepath = "app0:/"; const char *basepath = "app0:/";
char *retval = SDL_strdup(basepath); char *retval = SDL_strdup(basepath);
return retval; return retval;
} }
char * char *SDL_GetPrefPath(const char *org, const char *app)
SDL_GetPrefPath(const char *org, const char *app)
{ {
const char *envr = "ux0:/data/"; const char *envr = "ux0:/data/";
char *retval = NULL; char *retval = NULL;

12
src/filesystem/windows/SDL_sysfilesystem.c
View file

@ -32,8 +32,7 @@
#include "SDL_stdinc.h" #include "SDL_stdinc.h"
#include "SDL_filesystem.h" #include "SDL_filesystem.h"
char * char *SDL_GetBasePath(void)
SDL_GetBasePath(void)
{ {
DWORD buflen = 128; DWORD buflen = 128;
WCHAR *path = NULL; WCHAR *path = NULL;
@ -83,8 +82,7 @@ SDL_GetBasePath(void)
return retval; return retval;
} }
char * char *SDL_GetPrefPath(const char *org, const char *app)
SDL_GetPrefPath(const char *org, const char *app)
{ {
/* /*
* Vista and later has a new API for this, but SHGetFolderPath works there, * Vista and later has a new API for this, but SHGetFolderPath works there,
@ -175,15 +173,13 @@ SDL_GetPrefPath(const char *org, const char *app)
#ifdef SDL_FILESYSTEM_XBOX #ifdef SDL_FILESYSTEM_XBOX
#include "SDL_filesystem.h" #include "SDL_filesystem.h"
#include "SDL_error.h" #include "SDL_error.h"
char * char *SDL_GetBasePath(void)
SDL_GetBasePath(void)
{ {
SDL_Unsupported(); SDL_Unsupported();
return NULL; return NULL;
} }
char * char *SDL_GetPrefPath(const char *org, const char *app)
SDL_GetPrefPath(const char *org, const char *app)
{ {
SDL_Unsupported(); SDL_Unsupported();
return NULL; return NULL;

15
src/haptic/SDL_haptic.c
View file

@ -85,8 +85,7 @@ int SDL_NumHaptics(void)
/* /*
* Gets the name of a Haptic device by index. * Gets the name of a Haptic device by index.
*/ */
const char * const char *SDL_HapticName(int device_index)
SDL_HapticName(int device_index)
{ {
if ((device_index < 0) || (device_index >= SDL_NumHaptics())) { if ((device_index < 0) || (device_index >= SDL_NumHaptics())) {
SDL_SetError("Haptic: There are %d haptic devices available", SDL_SetError("Haptic: There are %d haptic devices available",
@ -99,8 +98,7 @@ SDL_HapticName(int device_index)
/* /*
* Opens a Haptic device. * Opens a Haptic device.
*/ */
SDL_Haptic * SDL_Haptic *SDL_HapticOpen(int device_index)
SDL_HapticOpen(int device_index)
{ {
SDL_Haptic *haptic; SDL_Haptic *haptic;
SDL_Haptic *hapticlist; SDL_Haptic *hapticlist;
@ -211,8 +209,7 @@ int SDL_MouseIsHaptic(void)
/* /*
* Returns the haptic device if mouse is haptic or NULL elsewise. * Returns the haptic device if mouse is haptic or NULL elsewise.
*/ */
SDL_Haptic * SDL_Haptic *SDL_HapticOpenFromMouse(void)
SDL_HapticOpenFromMouse(void)
{ {
int device_index; int device_index;
@ -257,8 +254,7 @@ int SDL_JoystickIsHaptic(SDL_Joystick *joystick)
/* /*
* Opens a haptic device from a joystick. * Opens a haptic device from a joystick.
*/ */
SDL_Haptic * SDL_Haptic *SDL_HapticOpenFromJoystick(SDL_Joystick *joystick)
SDL_HapticOpenFromJoystick(SDL_Joystick *joystick)
{ {
SDL_Haptic *haptic; SDL_Haptic *haptic;
SDL_Haptic *hapticlist; SDL_Haptic *hapticlist;
@ -415,8 +411,7 @@ int SDL_HapticNumEffectsPlaying(SDL_Haptic *haptic)
/* /*
* Returns supported effects by the device. * Returns supported effects by the device.
*/ */
unsigned int unsigned int SDL_HapticQuery(SDL_Haptic *haptic)
SDL_HapticQuery(SDL_Haptic *haptic)
{ {
if (!ValidHaptic(haptic)) { if (!ValidHaptic(haptic)) {
return 0; /* same as if no effects were supported */ return 0; /* same as if no effects were supported */

3
src/haptic/android/SDL_syshaptic.c
View file

@ -89,8 +89,7 @@ static SDL_hapticlist_item *HapticByDevId(int device_id)
return NULL; return NULL;
} }
const char * const char *SDL_SYS_HapticName(int index)
SDL_SYS_HapticName(int index)
{ {
SDL_hapticlist_item *item = HapticByOrder(index); SDL_hapticlist_item *item = HapticByOrder(index);
if (item == NULL) { if (item == NULL) {

3
src/haptic/darwin/SDL_syshaptic.c
View file

@ -319,8 +319,7 @@ int MacHaptic_MaybeRemoveDevice(io_object_t device)
/* /*
* Return the name of a haptic device, does not need to be opened. * Return the name of a haptic device, does not need to be opened.
*/ */
const char * const char *SDL_SYS_HapticName(int index)
SDL_SYS_HapticName(int index)
{ {
SDL_hapticlist_item *item; SDL_hapticlist_item *item;
item = HapticByDevIndex(index); item = HapticByDevIndex(index);

3
src/haptic/dummy/SDL_syshaptic.c
View file

@ -40,8 +40,7 @@ int SDL_SYS_NumHaptics(void)
return 0; return 0;
} }
const char * const char *SDL_SYS_HapticName(int index)
SDL_SYS_HapticName(int index)
{ {
SDL_SYS_LogicError(); SDL_SYS_LogicError();
return NULL; return NULL;

3
src/haptic/linux/SDL_syshaptic.c
View file

@ -351,8 +351,7 @@ static const char *SDL_SYS_HapticNameFromFD(int fd)
/* /*
* Return the name of a haptic device, does not need to be opened. * Return the name of a haptic device, does not need to be opened.
*/ */
const char * const char *SDL_SYS_HapticName(int index)
SDL_SYS_HapticName(int index)
{ {
SDL_hapticlist_item *item; SDL_hapticlist_item *item;
int fd; int fd;

3
src/haptic/windows/SDL_windowshaptic.c
View file

@ -136,8 +136,7 @@ static SDL_hapticlist_item *HapticByDevIndex(int device_index)
/* /*
* Return the name of a haptic device, does not need to be opened. * Return the name of a haptic device, does not need to be opened.
*/ */
const char * const char *SDL_SYS_HapticName(int index)
SDL_SYS_HapticName(int index)
{ {
SDL_hapticlist_item *item = HapticByDevIndex(index); SDL_hapticlist_item *item = HapticByDevIndex(index);
return item->name; return item->name;

27
src/hidapi/SDL_hidapi.c
View file

@ -198,14 +198,12 @@ static int SDL_inotify_init1(void)
} }
#endif #endif
static int static int StrHasPrefix(const char *string, const char *prefix)
StrHasPrefix(const char *string, const char *prefix)
{ {
return SDL_strncmp(string, prefix, SDL_strlen(prefix)) == 0; return SDL_strncmp(string, prefix, SDL_strlen(prefix)) == 0;
} }
static int static int StrIsInteger(const char *string)
StrIsInteger(const char *string)
{ {
const char *p; const char *p;
@ -223,8 +221,7 @@ StrIsInteger(const char *string)
} }
#endif /* HAVE_INOTIFY */ #endif /* HAVE_INOTIFY */
static void static void HIDAPI_InitializeDiscovery()
HIDAPI_InitializeDiscovery()
{ {
SDL_HIDAPI_discovery.m_bInitialized = SDL_TRUE; SDL_HIDAPI_discovery.m_bInitialized = SDL_TRUE;
SDL_HIDAPI_discovery.m_unDeviceChangeCounter = 1; SDL_HIDAPI_discovery.m_unDeviceChangeCounter = 1;
@ -363,8 +360,7 @@ HIDAPI_InitializeDiscovery()
} }
} }
static void static void HIDAPI_UpdateDiscovery()
HIDAPI_UpdateDiscovery()
{ {
if (!SDL_HIDAPI_discovery.m_bInitialized) { if (!SDL_HIDAPI_discovery.m_bInitialized) {
HIDAPI_InitializeDiscovery(); HIDAPI_InitializeDiscovery();
@ -481,8 +477,7 @@ HIDAPI_UpdateDiscovery()
} }
} }
static void static void HIDAPI_ShutdownDiscovery()
HIDAPI_ShutdownDiscovery()
{ {
if (!SDL_HIDAPI_discovery.m_bInitialized) { if (!SDL_HIDAPI_discovery.m_bInitialized) {
return; return;
@ -813,8 +808,7 @@ static struct
#ifndef __FreeBSD__ #ifndef __FreeBSD__
/* this is awkwardly inlined, so we need to re-implement it here /* this is awkwardly inlined, so we need to re-implement it here
* so we can override the libusb_control_transfer call */ * so we can override the libusb_control_transfer call */
static int static int SDL_libusb_get_string_descriptor(libusb_device_handle *dev,
SDL_libusb_get_string_descriptor(libusb_device_handle *dev,
uint8_t descriptor_index, uint16_t lang_id, uint8_t descriptor_index, uint16_t lang_id,
unsigned char *data, int length) unsigned char *data, int length)
{ {
@ -965,8 +959,7 @@ static char device_magic;
#if HAVE_PLATFORM_BACKEND || HAVE_DRIVER_BACKEND || defined(HAVE_LIBUSB) #if HAVE_PLATFORM_BACKEND || HAVE_DRIVER_BACKEND || defined(HAVE_LIBUSB)
static SDL_hid_device * static SDL_hid_device *CreateHIDDeviceWrapper(void *device, const struct hidapi_backend *backend)
CreateHIDDeviceWrapper(void *device, const struct hidapi_backend *backend)
{ {
SDL_hid_device *wrapper = (SDL_hid_device *)SDL_malloc(sizeof(*wrapper)); SDL_hid_device *wrapper = (SDL_hid_device *)SDL_malloc(sizeof(*wrapper));
wrapper->magic = &device_magic; wrapper->magic = &device_magic;
@ -977,8 +970,7 @@ CreateHIDDeviceWrapper(void *device, const struct hidapi_backend *backend)
#endif /* HAVE_PLATFORM_BACKEND || HAVE_DRIVER_BACKEND || HAVE_LIBUSB */ #endif /* HAVE_PLATFORM_BACKEND || HAVE_DRIVER_BACKEND || HAVE_LIBUSB */
static void static void DeleteHIDDeviceWrapper(SDL_hid_device *device)
DeleteHIDDeviceWrapper(SDL_hid_device *device)
{ {
device->magic = NULL; device->magic = NULL;
SDL_free(device); SDL_free(device);
@ -1006,8 +998,7 @@ DeleteHIDDeviceWrapper(SDL_hid_device *device)
pDst->var = NULL; \ pDst->var = NULL; \
} }
static void static void CopyHIDDeviceInfo(struct SDL_hid_device_info *pSrc, struct SDL_hid_device_info *pDst)
CopyHIDDeviceInfo(struct SDL_hid_device_info *pSrc, struct SDL_hid_device_info *pDst)
{ {
COPY_IF_EXISTS(path) COPY_IF_EXISTS(path)
pDst->vendor_id = pSrc->vendor_id; pDst->vendor_id = pSrc->vendor_id;

6
src/joystick/darwin/SDL_iokitjoystick.c
View file

@ -701,15 +701,13 @@ static void DARWIN_JoystickDetect(void)
} }
} }
const char * const char *DARWIN_JoystickGetDeviceName(int device_index)
DARWIN_JoystickGetDeviceName(int device_index)
{ {
recDevice *device = GetDeviceForIndex(device_index); recDevice *device = GetDeviceForIndex(device_index);
return device ? device->product : "UNKNOWN"; return device ? device->product : "UNKNOWN";
} }
const char * const char *DARWIN_JoystickGetDevicePath(int device_index)
DARWIN_JoystickGetDevicePath(int device_index)
{ {
return NULL; return NULL;
} }

3
src/joystick/hidapi/SDL_hidapi_switch.c
View file

@ -1764,8 +1764,7 @@ static void HandleSimpleControllerState(SDL_Joystick *joystick, SDL_DriverSwitch
ctx->m_lastSimpleState = *packet; ctx->m_lastSimpleState = *packet;
} }
static void static void SendSensorUpdate(SDL_Joystick *joystick, SDL_DriverSwitch_Context *ctx, SDL_SensorType type, Uint64 timestamp_us, const Sint16 *values)
SendSensorUpdate(SDL_Joystick *joystick, SDL_DriverSwitch_Context *ctx, SDL_SensorType type, Uint64 timestamp_us, const Sint16 *values)
{ {
float data[3]; float data[3];

9
src/joystick/hidapi/SDL_hidapijoystick.c
View file

@ -1163,8 +1163,7 @@ static SDL_bool HIDAPI_IsEquivalentToDevice(Uint16 vendor_id, Uint16 product_id,
return SDL_FALSE; return SDL_FALSE;
} }
SDL_bool SDL_bool HIDAPI_IsDeviceTypePresent(SDL_GameControllerType type)
HIDAPI_IsDeviceTypePresent(SDL_GameControllerType type)
{ {
SDL_HIDAPI_Device *device; SDL_HIDAPI_Device *device;
SDL_bool result = SDL_FALSE; SDL_bool result = SDL_FALSE;
@ -1245,8 +1244,7 @@ SDL_bool HIDAPI_IsDevicePresent(Uint16 vendor_id, Uint16 product_id, Uint16 vers
return result; return result;
} }
SDL_JoystickType SDL_JoystickType HIDAPI_GetJoystickTypeFromGUID(SDL_JoystickGUID guid)
HIDAPI_GetJoystickTypeFromGUID(SDL_JoystickGUID guid)
{ {
SDL_HIDAPI_Device *device; SDL_HIDAPI_Device *device;
SDL_JoystickType type = SDL_JOYSTICK_TYPE_UNKNOWN; SDL_JoystickType type = SDL_JOYSTICK_TYPE_UNKNOWN;
@ -1263,8 +1261,7 @@ HIDAPI_GetJoystickTypeFromGUID(SDL_JoystickGUID guid)
return type; return type;
} }
SDL_GameControllerType SDL_GameControllerType HIDAPI_GetGameControllerTypeFromGUID(SDL_JoystickGUID guid)
HIDAPI_GetGameControllerTypeFromGUID(SDL_JoystickGUID guid)
{ {
SDL_HIDAPI_Device *device; SDL_HIDAPI_Device *device;
SDL_GameControllerType type = SDL_CONTROLLER_TYPE_UNKNOWN; SDL_GameControllerType type = SDL_CONTROLLER_TYPE_UNKNOWN;

6
src/joystick/iphoneos/SDL_mfijoystick.m
View file

@ -1726,8 +1726,7 @@ static GCControllerDirectionPad *GetDirectionalPadForController(GCController *co
static char elementName[256]; static char elementName[256];
const char * const char *IOS_GameControllerGetAppleSFSymbolsNameForButton(SDL_GameController *gamecontroller, SDL_GameControllerButton button)
IOS_GameControllerGetAppleSFSymbolsNameForButton(SDL_GameController *gamecontroller, SDL_GameControllerButton button)
{ {
elementName[0] = '\0'; elementName[0] = '\0';
#if defined(SDL_JOYSTICK_MFI) && defined(ENABLE_PHYSICAL_INPUT_PROFILE) #if defined(SDL_JOYSTICK_MFI) && defined(ENABLE_PHYSICAL_INPUT_PROFILE)
@ -1842,8 +1841,7 @@ IOS_GameControllerGetAppleSFSymbolsNameForButton(SDL_GameController *gamecontrol
return elementName; return elementName;
} }
const char * const char *IOS_GameControllerGetAppleSFSymbolsNameForAxis(SDL_GameController *gamecontroller, SDL_GameControllerAxis axis)
IOS_GameControllerGetAppleSFSymbolsNameForAxis(SDL_GameController *gamecontroller, SDL_GameControllerAxis axis)
{ {
elementName[0] = '\0'; elementName[0] = '\0';
#if defined(SDL_JOYSTICK_MFI) && defined(ENABLE_PHYSICAL_INPUT_PROFILE) #if defined(SDL_JOYSTICK_MFI) && defined(ENABLE_PHYSICAL_INPUT_PROFILE)

12
src/joystick/windows/SDL_dinputjoystick.c
View file

@ -593,8 +593,7 @@ err:
#undef CHECK #undef CHECK
} }
SDL_bool SDL_bool SDL_DINPUT_JoystickPresent(Uint16 vendor_id, Uint16 product_id, Uint16 version_number)
SDL_DINPUT_JoystickPresent(Uint16 vendor_id, Uint16 product_id, Uint16 version_number)
{ {
Joystick_PresentData data; Joystick_PresentData data;
@ -945,8 +944,7 @@ int SDL_DINPUT_JoystickRumble(SDL_Joystick *joystick, Uint16 low_frequency_rumbl
return 0; return 0;
} }
Uint32 Uint32 SDL_DINPUT_JoystickGetCapabilities(SDL_Joystick *joystick)
SDL_DINPUT_JoystickGetCapabilities(SDL_Joystick *joystick)
{ {
Uint32 result = 0; Uint32 result = 0;
@ -1177,8 +1175,7 @@ void SDL_DINPUT_JoystickDetect(JoyStick_DeviceData **pContext)
{ {
} }
SDL_bool SDL_bool SDL_DINPUT_JoystickPresent(Uint16 vendor, Uint16 product, Uint16 version)
SDL_DINPUT_JoystickPresent(Uint16 vendor, Uint16 product, Uint16 version)
{ {
return SDL_FALSE; return SDL_FALSE;
} }
@ -1193,8 +1190,7 @@ int SDL_DINPUT_JoystickRumble(SDL_Joystick *joystick, Uint16 low_frequency_rumbl
return SDL_Unsupported(); return SDL_Unsupported();
} }
Uint32 Uint32 SDL_DINPUT_JoystickGetCapabilities(SDL_Joystick *joystick)
SDL_DINPUT_JoystickGetCapabilities(SDL_Joystick *joystick)
{ {
return 0; return 0;
} }

9
src/joystick/windows/SDL_rawinputjoystick.c
View file

@ -883,14 +883,12 @@ static int RAWINPUT_JoystickGetCount(void)
return SDL_RAWINPUT_numjoysticks; return SDL_RAWINPUT_numjoysticks;
} }
SDL_bool SDL_bool RAWINPUT_IsEnabled()
RAWINPUT_IsEnabled()
{ {
return SDL_RAWINPUT_inited; return SDL_RAWINPUT_inited;
} }
SDL_bool SDL_bool RAWINPUT_IsDevicePresent(Uint16 vendor_id, Uint16 product_id, Uint16 version, const char *name)
RAWINPUT_IsDevicePresent(Uint16 vendor_id, Uint16 product_id, Uint16 version, const char *name)
{ {
SDL_RAWINPUT_Device *device; SDL_RAWINPUT_Device *device;
@ -1874,8 +1872,7 @@ static void RAWINPUT_JoystickClose(SDL_Joystick *joystick)
} }
} }
SDL_bool SDL_bool RAWINPUT_RegisterNotifications(HWND hWnd)
RAWINPUT_RegisterNotifications(HWND hWnd)
{ {
RAWINPUTDEVICE rid[SDL_arraysize(subscribed_devices)]; RAWINPUTDEVICE rid[SDL_arraysize(subscribed_devices)];
int i; int i;

6
src/joystick/windows/SDL_xinputjoystick.c
View file

@ -497,8 +497,7 @@ int SDL_XINPUT_JoystickRumble(SDL_Joystick *joystick, Uint16 low_frequency_rumbl
return 0; return 0;
} }
Uint32 Uint32 SDL_XINPUT_JoystickGetCapabilities(SDL_Joystick *joystick)
SDL_XINPUT_JoystickGetCapabilities(SDL_Joystick *joystick)
{ {
return SDL_JOYCAP_RUMBLE; return SDL_JOYCAP_RUMBLE;
} }
@ -583,8 +582,7 @@ int SDL_XINPUT_JoystickRumble(SDL_Joystick *joystick, Uint16 low_frequency_rumbl
return SDL_Unsupported(); return SDL_Unsupported();
} }
Uint32 Uint32 SDL_XINPUT_JoystickGetCapabilities(SDL_Joystick *joystick)
SDL_XINPUT_JoystickGetCapabilities(SDL_Joystick *joystick)
{ {
return 0; return 0;
} }

6
src/loadso/dlopen/SDL_sysloadso.c
View file

@ -34,8 +34,7 @@
#include "../../video/uikit/SDL_uikitvideo.h" #include "../../video/uikit/SDL_uikitvideo.h"
#endif #endif
void * void *SDL_LoadObject(const char *sofile)
SDL_LoadObject(const char *sofile)
{ {
void *handle; void *handle;
const char *loaderror; const char *loaderror;
@ -55,8 +54,7 @@ SDL_LoadObject(const char *sofile)
return handle; return handle;
} }
void * void *SDL_LoadFunction(void *handle, const char *name)
SDL_LoadFunction(void *handle, const char *name)
{ {
void *symbol = dlsym(handle, name); void *symbol = dlsym(handle, name);
if (symbol == NULL) { if (symbol == NULL) {

6
src/loadso/dummy/SDL_sysloadso.c
View file

@ -27,16 +27,14 @@
#include "SDL_loadso.h" #include "SDL_loadso.h"
void * void *SDL_LoadObject(const char *sofile)
SDL_LoadObject(const char *sofile)
{ {
const char *loaderror = "SDL_LoadObject() not implemented"; const char *loaderror = "SDL_LoadObject() not implemented";
SDL_SetError("Failed loading %s: %s", sofile, loaderror); SDL_SetError("Failed loading %s: %s", sofile, loaderror);
return NULL; return NULL;
} }
void * void *SDL_LoadFunction(void *handle, const char *name)
SDL_LoadFunction(void *handle, const char *name)
{ {
const char *loaderror = "SDL_LoadFunction() not implemented"; const char *loaderror = "SDL_LoadFunction() not implemented";
SDL_SetError("Failed loading %s: %s", name, loaderror); SDL_SetError("Failed loading %s: %s", name, loaderror);

9
src/loadso/os2/SDL_sysloadso.c
View file

@ -32,8 +32,7 @@
#define INCL_DOSERRORS #define INCL_DOSERRORS
#include <os2.h> #include <os2.h>
void * void *SDL_LoadObject(const char *sofile)
SDL_LoadObject(const char *sofile)
{ {
ULONG ulRC; ULONG ulRC;
HMODULE hModule; HMODULE hModule;
@ -65,8 +64,7 @@ SDL_LoadObject(const char *sofile)
return (void *)hModule; return (void *)hModule;
} }
void * void *SDL_LoadFunction(void *handle, const char *name)
SDL_LoadFunction(void *handle, const char *name)
{ {
ULONG ulRC; ULONG ulRC;
PFN pFN; PFN pFN;
@ -90,8 +88,7 @@ SDL_LoadFunction(void *handle, const char *name)
return (void *)pFN; return (void *)pFN;
} }
void void SDL_UnloadObject(void *handle)
SDL_UnloadObject(void *handle)
{ {
if (handle != NULL) { if (handle != NULL) {
DosFreeModule((HMODULE)handle); DosFreeModule((HMODULE)handle);

6
src/loadso/windows/SDL_sysloadso.c
View file

@ -29,8 +29,7 @@
#include "SDL_loadso.h" #include "SDL_loadso.h"
void * void *SDL_LoadObject(const char *sofile)
SDL_LoadObject(const char *sofile)
{ {
void *handle; void *handle;
LPTSTR tstr; LPTSTR tstr;
@ -61,8 +60,7 @@ SDL_LoadObject(const char *sofile)
return handle; return handle;
} }
void * void *SDL_LoadFunction(void *handle, const char *name)
SDL_LoadFunction(void *handle, const char *name)
{ {
void *symbol = (void *)GetProcAddress((HMODULE)handle, name); void *symbol = (void *)GetProcAddress((HMODULE)handle, name);
if (symbol == NULL) { if (symbol == NULL) {

3
src/locale/SDL_locale.c
View file

@ -87,8 +87,7 @@ static SDL_Locale *build_locales_from_csv_string(char *csv)
return retval; return retval;
} }
SDL_Locale * SDL_Locale *SDL_GetPreferredLocales(void)
SDL_GetPreferredLocales(void)
{ {
char locbuf[128]; /* enough for 21 "xx_YY," language strings. */ char locbuf[128]; /* enough for 21 "xx_YY," language strings. */
const char *hint = SDL_GetHint(SDL_HINT_PREFERRED_LOCALES); const char *hint = SDL_GetHint(SDL_HINT_PREFERRED_LOCALES);

3
src/locale/haiku/SDL_syslocale.cc
View file

@ -26,8 +26,7 @@
#include "../../SDL_internal.h" #include "../../SDL_internal.h"
#include "../SDL_syslocale.h" #include "../SDL_syslocale.h"
void void SDL_SYS_GetPreferredLocales(char *buf, size_t buflen)
SDL_SYS_GetPreferredLocales(char *buf, size_t buflen)
{ {
BLocaleRoster *roster = BLocaleRoster::Default(); BLocaleRoster *roster = BLocaleRoster::Default();
roster->Refresh(); roster->Refresh();

9
src/main/haiku/SDL_BeApp.cc
View file

@ -105,8 +105,7 @@ static int StartBeApp(void *unused)
} }
static int static int StartBeLooper()
StartBeLooper()
{ {
if (!be_app) { if (!be_app) {
SDL_AppThread = SDL_CreateThreadInternal(StartBeApp, "SDLApplication", 0, NULL); SDL_AppThread = SDL_CreateThreadInternal(StartBeApp, "SDLApplication", 0, NULL);
@ -141,8 +140,7 @@ StartBeLooper()
/* Initialize the Be Application, if it's not already started */ /* Initialize the Be Application, if it's not already started */
int int SDL_InitBeApp(void)
SDL_InitBeApp(void)
{ {
/* Create the BApplication that handles appserver interaction */ /* Create the BApplication that handles appserver interaction */
if (SDL_BeAppActive <= 0) { if (SDL_BeAppActive <= 0) {
@ -160,8 +158,7 @@ SDL_InitBeApp(void)
} }
/* Quit the Be Application, if there's nothing left to do */ /* Quit the Be Application, if there's nothing left to do */
void void SDL_QuitBeApp(void)
SDL_QuitBeApp(void)
{ {
/* Decrement the application reference count */ /* Decrement the application reference count */
--SDL_BeAppActive; --SDL_BeAppActive;

21
src/main/nacl/SDL_nacl_main.c
View file

@ -33,20 +33,19 @@
extern void NACL_SetScreenResolution(int width, int height, Uint32 format); extern void NACL_SetScreenResolution(int width, int height, Uint32 format);
int int nacl_main(int argc, char *argv[])
nacl_main(int argc, char *argv[])
{ {
int status; int status;
PSEvent* ps_event; PSEvent* ps_event;
PP_Resource event; PP_Resource event;
struct PP_Rect rect; struct PP_Rect rect;
int ready = 0; int ready = 0;
const PPB_View *ppb_view = PSInterfaceView(); const PPB_View *ppb_view = PSInterfaceView();
/* This is started in a worker thread by ppapi_simple! */ /* This is started in a worker thread by ppapi_simple! */
/* Wait for the first PSE_INSTANCE_DIDCHANGEVIEW event before starting the app */ /* Wait for the first PSE_INSTANCE_DIDCHANGEVIEW event before starting the app */
PSEventSetFilter(PSE_INSTANCE_DIDCHANGEVIEW); PSEventSetFilter(PSE_INSTANCE_DIDCHANGEVIEW);
while (!ready) { while (!ready) {
/* Process all waiting events without blocking */ /* Process all waiting events without blocking */
@ -65,13 +64,13 @@ nacl_main(int argc, char *argv[])
PSEventRelease(ps_event); PSEventRelease(ps_event);
} }
} }
/* Do a default httpfs mount on /, /* Do a default httpfs mount on /,
* apps can override this by unmounting / * apps can override this by unmounting /
* and remounting with the desired configuration * and remounting with the desired configuration
*/ */
nacl_io_init_ppapi(PSGetInstanceId(), PSGetInterface); nacl_io_init_ppapi(PSGetInstanceId(), PSGetInterface);
umount("/"); umount("/");
mount( mount(
"", /* source */ "", /* source */
@ -79,7 +78,7 @@ nacl_main(int argc, char *argv[])
"httpfs", /* filesystemtype */ "httpfs", /* filesystemtype */
0, /* mountflags */ 0, /* mountflags */
""); /* data specific to the html5fs type */ ""); /* data specific to the html5fs type */
/* Everything is ready, start the user main function */ /* Everything is ready, start the user main function */
SDL_SetMainReady(); SDL_SetMainReady();
status = SDL_main(argc, argv); status = SDL_main(argc, argv);

3
src/misc/haiku/SDL_sysurl.cc
View file

@ -22,8 +22,7 @@
#include "../SDL_sysurl.h" #include "../SDL_sysurl.h"
#include <Url.h> #include <Url.h>
int int SDL_SYS_OpenURL(const char *url)
SDL_SYS_OpenURL(const char *url)
{ {
BUrl burl(url); BUrl burl(url);
const status_t rc = burl.OpenWithPreferredApplication(false); const status_t rc = burl.OpenWithPreferredApplication(false);

3
src/power/SDL_power.c
View file

@ -85,8 +85,7 @@ static SDL_GetPowerInfo_Impl implementations[] = {
}; };
#endif #endif
SDL_PowerState SDL_PowerState SDL_GetPowerInfo(int *seconds, int *percent)
SDL_GetPowerInfo(int *seconds, int *percent)
{ {
#ifndef SDL_POWER_DISABLED #ifndef SDL_POWER_DISABLED
const int total = sizeof(implementations) / sizeof(implementations[0]); const int total = sizeof(implementations) / sizeof(implementations[0]);

3
src/power/android/SDL_syspower.c
View file

@ -28,8 +28,7 @@
#include "../../core/android/SDL_android.h" #include "../../core/android/SDL_android.h"
SDL_bool SDL_bool SDL_GetPowerInfo_Android(SDL_PowerState *state, int *seconds, int *percent)
SDL_GetPowerInfo_Android(SDL_PowerState *state, int *seconds, int *percent)
{ {
int battery; int battery;
int plugged; int plugged;

3
src/power/emscripten/SDL_syspower.c
View file

@ -27,8 +27,7 @@
#include "SDL_power.h" #include "SDL_power.h"
SDL_bool SDL_bool SDL_GetPowerInfo_Emscripten(SDL_PowerState *state, int *seconds, int *percent)
SDL_GetPowerInfo_Emscripten(SDL_PowerState *state, int *seconds, int *percent)
{ {
EmscriptenBatteryEvent batteryState; EmscriptenBatteryEvent batteryState;
int haveBattery = 0; int haveBattery = 0;

3
src/power/haiku/SDL_syspower.c
View file

@ -42,8 +42,7 @@
#include "SDL_power.h" #include "SDL_power.h"
SDL_bool SDL_bool SDL_GetPowerInfo_Haiku(SDL_PowerState *state, int *seconds, int *percent)
SDL_GetPowerInfo_Haiku(SDL_PowerState *state, int *seconds, int *percent)
{ {
const int fd = open("/dev/misc/apm", O_RDONLY | O_CLOEXEC); const int fd = open("/dev/misc/apm", O_RDONLY | O_CLOEXEC);
SDL_bool need_details = SDL_FALSE; SDL_bool need_details = SDL_FALSE;

14
src/power/linux/SDL_syspower.c
View file

@ -229,9 +229,7 @@ static void check_proc_acpi_ac_adapter(const char *node, SDL_bool *have_ac)
} }
} }
SDL_bool SDL_bool SDL_GetPowerInfo_Linux_proc_acpi(SDL_PowerState *state, int *seconds, int *percent)
SDL_GetPowerInfo_Linux_proc_acpi(SDL_PowerState *state,
int *seconds, int *percent)
{ {
struct dirent *dent = NULL; struct dirent *dent = NULL;
DIR *dirp = NULL; DIR *dirp = NULL;
@ -314,9 +312,7 @@ static SDL_bool int_string(char *str, int *val)
} }
/* http://lxr.linux.no/linux+v2.6.29/drivers/char/apm-emulation.c */ /* http://lxr.linux.no/linux+v2.6.29/drivers/char/apm-emulation.c */
SDL_bool SDL_bool SDL_GetPowerInfo_Linux_proc_apm(SDL_PowerState *state, int *seconds, int *percent)
SDL_GetPowerInfo_Linux_proc_apm(SDL_PowerState *state,
int *seconds, int *percent)
{ {
SDL_bool need_details = SDL_FALSE; SDL_bool need_details = SDL_FALSE;
int ac_status = 0; int ac_status = 0;
@ -422,8 +418,7 @@ SDL_GetPowerInfo_Linux_proc_apm(SDL_PowerState *state,
return SDL_TRUE; return SDL_TRUE;
} }
SDL_bool SDL_bool SDL_GetPowerInfo_Linux_sys_class_power_supply(SDL_PowerState *state, int *seconds, int *percent)
SDL_GetPowerInfo_Linux_sys_class_power_supply(SDL_PowerState *state, int *seconds, int *percent)
{ {
const char *base = sys_class_power_supply_path; const char *base = sys_class_power_supply_path;
struct dirent *dent; struct dirent *dent;
@ -612,8 +607,7 @@ static void check_upower_device(DBusConnection *conn, const char *path, SDL_Powe
} }
#endif #endif
SDL_bool SDL_bool SDL_GetPowerInfo_Linux_org_freedesktop_upower(SDL_PowerState *state, int *seconds, int *percent)
SDL_GetPowerInfo_Linux_org_freedesktop_upower(SDL_PowerState *state, int *seconds, int *percent)
{ {
SDL_bool retval = SDL_FALSE; SDL_bool retval = SDL_FALSE;

3
src/power/macosx/SDL_syspower.c
View file

@ -138,8 +138,7 @@ static void checkps(CFDictionaryRef dict, SDL_bool *have_ac, SDL_bool *have_batt
#undef GETVAL #undef GETVAL
#undef STRMATCH #undef STRMATCH
SDL_bool SDL_bool SDL_GetPowerInfo_MacOSX(SDL_PowerState *state, int *seconds, int *percent)
SDL_GetPowerInfo_MacOSX(SDL_PowerState *state, int *seconds, int *percent)
{ {
CFTypeRef blob = IOPSCopyPowerSourcesInfo(); CFTypeRef blob = IOPSCopyPowerSourcesInfo();

9
src/power/n3ds/SDL_syspower.c
View file

@ -35,8 +35,7 @@ SDL_FORCE_INLINE int GetBatteryPercentage(void);
#define BATTERY_PERCENT_REG 0xB #define BATTERY_PERCENT_REG 0xB
#define BATTERY_PERCENT_REG_SIZE 2 #define BATTERY_PERCENT_REG_SIZE 2
SDL_bool SDL_bool SDL_GetPowerInfo_N3DS(SDL_PowerState *state, int *seconds, int *percent)
SDL_GetPowerInfo_N3DS(SDL_PowerState *state, int *seconds, int *percent)
{ {
*state = GetPowerState(); *state = GetPowerState();
*percent = GetBatteryPercentage(); *percent = GetBatteryPercentage();
@ -45,8 +44,7 @@ SDL_GetPowerInfo_N3DS(SDL_PowerState *state, int *seconds, int *percent)
return SDL_TRUE; return SDL_TRUE;
} }
SDL_FORCE_INLINE SDL_PowerState static SDL_PowerState GetPowerState(void)
GetPowerState(void)
{ {
bool is_plugged; bool is_plugged;
u8 is_charging; u8 is_charging;
@ -66,8 +64,7 @@ GetPowerState(void)
return SDL_POWERSTATE_ON_BATTERY; return SDL_POWERSTATE_ON_BATTERY;
} }
SDL_FORCE_INLINE int static int ReadStateFromPTMU(bool *is_plugged, u8 *is_charging)
ReadStateFromPTMU(bool *is_plugged, u8 *is_charging)
{ {
if (R_FAILED(ptmuInit())) { if (R_FAILED(ptmuInit())) {
return SDL_SetError("Failed to initialise PTMU service"); return SDL_SetError("Failed to initialise PTMU service");

4
src/power/psp/SDL_syspower.c
View file

@ -27,9 +27,7 @@
#include "SDL_power.h" #include "SDL_power.h"
#include <psppower.h> #include <psppower.h>
SDL_bool SDL_bool SDL_GetPowerInfo_PSP(SDL_PowerState *state, int *seconds, int *percent)
SDL_GetPowerInfo_PSP(SDL_PowerState *state, int *seconds,
int *percent)
{ {
int battery = scePowerIsBatteryExist(); int battery = scePowerIsBatteryExist();
int plugged = scePowerIsPowerOnline(); int plugged = scePowerIsPowerOnline();

3
src/power/uikit/SDL_syspower.m
View file

@ -52,8 +52,7 @@ void SDL_UIKit_UpdateBatteryMonitoring(void)
} }
#endif /* !TARGET_OS_TV */ #endif /* !TARGET_OS_TV */
SDL_bool SDL_bool SDL_GetPowerInfo_UIKit(SDL_PowerState *state, int *seconds, int *percent)
SDL_GetPowerInfo_UIKit(SDL_PowerState *state, int *seconds, int *percent)
{ {
#if TARGET_OS_TV #if TARGET_OS_TV
*state = SDL_POWERSTATE_NO_BATTERY; *state = SDL_POWERSTATE_NO_BATTERY;

4
src/power/vita/SDL_syspower.c
View file

@ -27,9 +27,7 @@
#include "SDL_power.h" #include "SDL_power.h"
#include <psp2/power.h> #include <psp2/power.h>
SDL_bool SDL_bool SDL_GetPowerInfo_VITA(SDL_PowerState *state, int *seconds, int *percent)
SDL_GetPowerInfo_VITA(SDL_PowerState *state, int *seconds,
int *percent)
{ {
int battery = 1; int battery = 1;
int plugged = scePowerIsPowerOnline(); int plugged = scePowerIsPowerOnline();

3
src/power/windows/SDL_syspower.c
View file

@ -27,8 +27,7 @@
#include "SDL_power.h" #include "SDL_power.h"
SDL_bool SDL_bool SDL_GetPowerInfo_Windows(SDL_PowerState *state, int *seconds, int *percent)
SDL_GetPowerInfo_Windows(SDL_PowerState *state, int *seconds, int *percent)
{ {
SYSTEM_POWER_STATUS status; SYSTEM_POWER_STATUS status;
SDL_bool need_details = SDL_FALSE; SDL_bool need_details = SDL_FALSE;

3
src/power/winrt/SDL_syspower.cpp
View file

@ -26,8 +26,7 @@
#include "SDL_power.h" #include "SDL_power.h"
extern "C" extern "C"
SDL_bool SDL_bool SDL_GetPowerInfo_WinRT(SDL_PowerState * state, int *seconds, int *percent)
SDL_GetPowerInfo_WinRT(SDL_PowerState * state, int *seconds, int *percent)
{ {
/* TODO, WinRT: Battery info is available on at least one WinRT platform (Windows Phone 8). Implement SDL_GetPowerInfo_WinRT as appropriate. */ /* TODO, WinRT: Battery info is available on at least one WinRT platform (Windows Phone 8). Implement SDL_GetPowerInfo_WinRT as appropriate. */
/* Notes: /* Notes:

64
src/render/SDL_render.c
View file

@ -283,8 +283,7 @@ int SDL_RenderFlush(SDL_Renderer *renderer)
return FlushRenderCommands(renderer); return FlushRenderCommands(renderer);
} }
void * void *SDL_AllocateRenderVertices(SDL_Renderer *renderer, const size_t numbytes, const size_t alignment, size_t *offset)
SDL_AllocateRenderVertices(SDL_Renderer *renderer, const size_t numbytes, const size_t alignment, size_t *offset)
{ {
const size_t needed = renderer->vertex_data_used + numbytes + alignment; const size_t needed = renderer->vertex_data_used + numbytes + alignment;
const size_t current_offset = renderer->vertex_data_used; const size_t current_offset = renderer->vertex_data_used;
@ -934,8 +933,7 @@ static void SDL_CalculateSimulatedVSyncInterval(SDL_Renderer *renderer, SDL_Wind
} }
#endif /* !SDL_RENDER_DISABLED */ #endif /* !SDL_RENDER_DISABLED */
SDL_Renderer * SDL_Renderer *SDL_CreateRenderer(SDL_Window *window, int index, Uint32 flags)
SDL_CreateRenderer(SDL_Window *window, int index, Uint32 flags)
{ {
#if !SDL_RENDER_DISABLED #if !SDL_RENDER_DISABLED
SDL_Renderer *renderer = NULL; SDL_Renderer *renderer = NULL;
@ -1103,8 +1101,7 @@ error:
#endif #endif
} }
SDL_Renderer * SDL_Renderer *SDL_CreateSoftwareRenderer(SDL_Surface *surface)
SDL_CreateSoftwareRenderer(SDL_Surface *surface)
{ {
#if !SDL_RENDER_DISABLED && SDL_VIDEO_RENDER_SW #if !SDL_RENDER_DISABLED && SDL_VIDEO_RENDER_SW
SDL_Renderer *renderer; SDL_Renderer *renderer;
@ -1133,14 +1130,12 @@ SDL_CreateSoftwareRenderer(SDL_Surface *surface)
#endif /* !SDL_RENDER_DISABLED */ #endif /* !SDL_RENDER_DISABLED */
} }
SDL_Renderer * SDL_Renderer *SDL_GetRenderer(SDL_Window *window)
SDL_GetRenderer(SDL_Window *window)
{ {
return (SDL_Renderer *)SDL_GetWindowData(window, SDL_WINDOWRENDERDATA); return (SDL_Renderer *)SDL_GetWindowData(window, SDL_WINDOWRENDERDATA);
} }
SDL_Window * SDL_Window *SDL_RenderGetWindow(SDL_Renderer *renderer)
SDL_RenderGetWindow(SDL_Renderer *renderer)
{ {
CHECK_RENDERER_MAGIC(renderer, NULL); CHECK_RENDERER_MAGIC(renderer, NULL);
return renderer->window; return renderer->window;
@ -1239,8 +1234,7 @@ static SDL_ScaleMode SDL_GetScaleMode(void)
} }
} }
SDL_Texture * SDL_Texture *SDL_CreateTexture(SDL_Renderer *renderer, Uint32 format, int access, int w, int h)
SDL_CreateTexture(SDL_Renderer *renderer, Uint32 format, int access, int w, int h)
{ {
SDL_Texture *texture; SDL_Texture *texture;
SDL_bool texture_is_fourcc_and_target; SDL_bool texture_is_fourcc_and_target;
@ -1350,8 +1344,7 @@ SDL_CreateTexture(SDL_Renderer *renderer, Uint32 format, int access, int w, int
return texture; return texture;
} }
SDL_Texture * SDL_Texture *SDL_CreateTextureFromSurface(SDL_Renderer *renderer, SDL_Surface *surface)
SDL_CreateTextureFromSurface(SDL_Renderer *renderer, SDL_Surface *surface)
{ {
const SDL_PixelFormat *fmt; const SDL_PixelFormat *fmt;
SDL_bool needAlpha; SDL_bool needAlpha;
@ -1648,8 +1641,7 @@ int SDL_SetTextureUserData(SDL_Texture *texture, void *userdata)
return 0; return 0;
} }
void * void *SDL_GetTextureUserData(SDL_Texture *texture)
SDL_GetTextureUserData(SDL_Texture *texture)
{ {
CHECK_TEXTURE_MAGIC(texture, NULL); CHECK_TEXTURE_MAGIC(texture, NULL);
@ -2173,8 +2165,7 @@ void SDL_UnlockTexture(SDL_Texture *texture)
texture->locked_surface = NULL; texture->locked_surface = NULL;
} }
SDL_bool SDL_bool SDL_RenderTargetSupported(SDL_Renderer *renderer)
SDL_RenderTargetSupported(SDL_Renderer *renderer)
{ {
if (renderer == NULL || !renderer->SetRenderTarget) { if (renderer == NULL || !renderer->SetRenderTarget) {
return SDL_FALSE; return SDL_FALSE;
@ -2261,8 +2252,7 @@ int SDL_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
return FlushRenderCommandsIfNotBatching(renderer); return FlushRenderCommandsIfNotBatching(renderer);
} }
SDL_Texture * SDL_Texture *SDL_GetRenderTarget(SDL_Renderer *renderer)
SDL_GetRenderTarget(SDL_Renderer *renderer)
{ {
CHECK_RENDERER_MAGIC(renderer, NULL); CHECK_RENDERER_MAGIC(renderer, NULL);
@ -2428,9 +2418,7 @@ int SDL_RenderSetIntegerScale(SDL_Renderer *renderer, SDL_bool enable)
return UpdateLogicalSize(renderer, SDL_TRUE); return UpdateLogicalSize(renderer, SDL_TRUE);
} }
SDL_bool SDL_bool SDL_RenderGetIntegerScale(SDL_Renderer *renderer)
SDLCALL
SDL_RenderGetIntegerScale(SDL_Renderer *renderer)
{ {
CHECK_RENDERER_MAGIC(renderer, SDL_FALSE); CHECK_RENDERER_MAGIC(renderer, SDL_FALSE);
@ -2515,8 +2503,7 @@ void SDL_RenderGetClipRect(SDL_Renderer *renderer, SDL_Rect *rect)
} }
} }
SDL_bool SDL_bool SDL_RenderIsClipEnabled(SDL_Renderer *renderer)
SDL_RenderIsClipEnabled(SDL_Renderer *renderer)
{ {
CHECK_RENDERER_MAGIC(renderer, SDL_FALSE) CHECK_RENDERER_MAGIC(renderer, SDL_FALSE)
return renderer->clipping_enabled; return renderer->clipping_enabled;
@ -4382,8 +4369,7 @@ int SDL_GL_UnbindTexture(SDL_Texture *texture)
return SDL_Unsupported(); return SDL_Unsupported();
} }
void * void *SDL_RenderGetMetalLayer(SDL_Renderer *renderer)
SDL_RenderGetMetalLayer(SDL_Renderer *renderer)
{ {
CHECK_RENDERER_MAGIC(renderer, NULL); CHECK_RENDERER_MAGIC(renderer, NULL);
@ -4394,8 +4380,7 @@ SDL_RenderGetMetalLayer(SDL_Renderer *renderer)
return NULL; return NULL;
} }
void * void *SDL_RenderGetMetalCommandEncoder(SDL_Renderer *renderer)
SDL_RenderGetMetalCommandEncoder(SDL_Renderer *renderer)
{ {
CHECK_RENDERER_MAGIC(renderer, NULL); CHECK_RENDERER_MAGIC(renderer, NULL);
@ -4446,8 +4431,7 @@ static SDL_BlendMode SDL_GetLongBlendMode(SDL_BlendMode blendMode)
return blendMode; return blendMode;
} }
SDL_BlendMode SDL_BlendMode SDL_ComposeCustomBlendMode(SDL_BlendFactor srcColorFactor, SDL_BlendFactor dstColorFactor,
SDL_ComposeCustomBlendMode(SDL_BlendFactor srcColorFactor, SDL_BlendFactor dstColorFactor,
SDL_BlendOperation colorOperation, SDL_BlendOperation colorOperation,
SDL_BlendFactor srcAlphaFactor, SDL_BlendFactor dstAlphaFactor, SDL_BlendFactor srcAlphaFactor, SDL_BlendFactor dstAlphaFactor,
SDL_BlendOperation alphaOperation) SDL_BlendOperation alphaOperation)
@ -4457,43 +4441,37 @@ SDL_ComposeCustomBlendMode(SDL_BlendFactor srcColorFactor, SDL_BlendFactor dstCo
return SDL_GetShortBlendMode(blendMode); return SDL_GetShortBlendMode(blendMode);
} }
SDL_BlendFactor SDL_BlendFactor SDL_GetBlendModeSrcColorFactor(SDL_BlendMode blendMode)
SDL_GetBlendModeSrcColorFactor(SDL_BlendMode blendMode)
{ {
blendMode = SDL_GetLongBlendMode(blendMode); blendMode = SDL_GetLongBlendMode(blendMode);
return (SDL_BlendFactor)(((Uint32)blendMode >> 4) & 0xF); return (SDL_BlendFactor)(((Uint32)blendMode >> 4) & 0xF);
} }
SDL_BlendFactor SDL_BlendFactor SDL_GetBlendModeDstColorFactor(SDL_BlendMode blendMode)
SDL_GetBlendModeDstColorFactor(SDL_BlendMode blendMode)
{ {
blendMode = SDL_GetLongBlendMode(blendMode); blendMode = SDL_GetLongBlendMode(blendMode);
return (SDL_BlendFactor)(((Uint32)blendMode >> 8) & 0xF); return (SDL_BlendFactor)(((Uint32)blendMode >> 8) & 0xF);
} }
SDL_BlendOperation SDL_BlendOperation SDL_GetBlendModeColorOperation(SDL_BlendMode blendMode)
SDL_GetBlendModeColorOperation(SDL_BlendMode blendMode)
{ {
blendMode = SDL_GetLongBlendMode(blendMode); blendMode = SDL_GetLongBlendMode(blendMode);
return (SDL_BlendOperation)(((Uint32)blendMode >> 0) & 0xF); return (SDL_BlendOperation)(((Uint32)blendMode >> 0) & 0xF);
} }
SDL_BlendFactor SDL_BlendFactor SDL_GetBlendModeSrcAlphaFactor(SDL_BlendMode blendMode)
SDL_GetBlendModeSrcAlphaFactor(SDL_BlendMode blendMode)
{ {
blendMode = SDL_GetLongBlendMode(blendMode); blendMode = SDL_GetLongBlendMode(blendMode);
return (SDL_BlendFactor)(((Uint32)blendMode >> 20) & 0xF); return (SDL_BlendFactor)(((Uint32)blendMode >> 20) & 0xF);
} }
SDL_BlendFactor SDL_BlendFactor SDL_GetBlendModeDstAlphaFactor(SDL_BlendMode blendMode)
SDL_GetBlendModeDstAlphaFactor(SDL_BlendMode blendMode)
{ {
blendMode = SDL_GetLongBlendMode(blendMode); blendMode = SDL_GetLongBlendMode(blendMode);
return (SDL_BlendFactor)(((Uint32)blendMode >> 24) & 0xF); return (SDL_BlendFactor)(((Uint32)blendMode >> 24) & 0xF);
} }
SDL_BlendOperation SDL_BlendOperation SDL_GetBlendModeAlphaOperation(SDL_BlendMode blendMode)
SDL_GetBlendModeAlphaOperation(SDL_BlendMode blendMode)
{ {
blendMode = SDL_GetLongBlendMode(blendMode); blendMode = SDL_GetLongBlendMode(blendMode);
return (SDL_BlendOperation)(((Uint32)blendMode >> 16) & 0xF); return (SDL_BlendOperation)(((Uint32)blendMode >> 16) & 0xF);

3
src/render/SDL_yuv_sw.c
View file

@ -28,8 +28,7 @@
#include "../video/SDL_yuv_c.h" #include "../video/SDL_yuv_c.h"
#include "SDL_cpuinfo.h" #include "SDL_cpuinfo.h"
SDL_SW_YUVTexture * SDL_SW_YUVTexture *SDL_SW_CreateYUVTexture(Uint32 format, int w, int h)
SDL_SW_CreateYUVTexture(Uint32 format, int w, int h)
{ {
SDL_SW_YUVTexture *swdata; SDL_SW_YUVTexture *swdata;

6
src/render/direct3d/SDL_render_d3d.c
View file

@ -1546,8 +1546,7 @@ static int D3D_SetVSync(SDL_Renderer *renderer, const int vsync)
return 0; return 0;
} }
SDL_Renderer * SDL_Renderer *D3D_CreateRenderer(SDL_Window *window, Uint32 flags)
D3D_CreateRenderer(SDL_Window *window, Uint32 flags)
{ {
SDL_Renderer *renderer; SDL_Renderer *renderer;
D3D_RenderData *data; D3D_RenderData *data;
@ -1736,8 +1735,7 @@ SDL_RenderDriver D3D_RenderDriver = {
#if defined(__WIN32__) || defined(__WINGDK__) #if defined(__WIN32__) || defined(__WINGDK__)
/* This function needs to always exist on Windows, for the Dynamic API. */ /* This function needs to always exist on Windows, for the Dynamic API. */
IDirect3DDevice9 * IDirect3DDevice9 *SDL_RenderGetD3D9Device(SDL_Renderer *renderer)
SDL_RenderGetD3D9Device(SDL_Renderer *renderer)
{ {
IDirect3DDevice9 *device = NULL; IDirect3DDevice9 *device = NULL;

9
src/render/direct3d11/SDL_render_d3d11.c
View file

@ -200,8 +200,7 @@ static const GUID SDL_IID_ID3D11DeviceContext1 = { 0xbb2c6faa, 0xb5fb, 0x4082, {
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
#endif #endif
Uint32 Uint32 D3D11_DXGIFormatToSDLPixelFormat(DXGI_FORMAT dxgiFormat)
D3D11_DXGIFormatToSDLPixelFormat(DXGI_FORMAT dxgiFormat)
{ {
switch (dxgiFormat) { switch (dxgiFormat) {
case DXGI_FORMAT_B8G8R8A8_UNORM: case DXGI_FORMAT_B8G8R8A8_UNORM:
@ -2300,8 +2299,7 @@ static int D3D11_SetVSync(SDL_Renderer *renderer, const int vsync)
} }
#endif #endif
SDL_Renderer * SDL_Renderer *D3D11_CreateRenderer(SDL_Window *window, Uint32 flags)
D3D11_CreateRenderer(SDL_Window *window, Uint32 flags)
{ {
SDL_Renderer *renderer; SDL_Renderer *renderer;
D3D11_RenderData *data; D3D11_RenderData *data;
@ -2413,8 +2411,7 @@ SDL_RenderDriver D3D11_RenderDriver = {
#if defined(__WIN32__) || defined(__WINGDK__) #if defined(__WIN32__) || defined(__WINGDK__)
/* This function needs to always exist on Windows, for the Dynamic API. */ /* This function needs to always exist on Windows, for the Dynamic API. */
ID3D11Device * ID3D11Device *SDL_RenderGetD3D11Device(SDL_Renderer *renderer)
SDL_RenderGetD3D11Device(SDL_Renderer *renderer)
{ {
ID3D11Device *device = NULL; ID3D11Device *device = NULL;

6
src/render/direct3d12/SDL_render_d3d12.c
View file

@ -276,8 +276,7 @@ UINT D3D12_Align(UINT location, UINT alignment)
return (location + (alignment - 1)) & ~(alignment - 1); return (location + (alignment - 1)) & ~(alignment - 1);
} }
Uint32 Uint32 D3D12_DXGIFormatToSDLPixelFormat(DXGI_FORMAT dxgiFormat)
D3D12_DXGIFormatToSDLPixelFormat(DXGI_FORMAT dxgiFormat)
{ {
switch (dxgiFormat) { switch (dxgiFormat) {
case DXGI_FORMAT_B8G8R8A8_UNORM: case DXGI_FORMAT_B8G8R8A8_UNORM:
@ -2949,8 +2948,7 @@ static int D3D12_SetVSync(SDL_Renderer *renderer, const int vsync)
return 0; return 0;
} }
SDL_Renderer * SDL_Renderer *D3D12_CreateRenderer(SDL_Window *window, Uint32 flags)
D3D12_CreateRenderer(SDL_Window *window, Uint32 flags)
{ {
SDL_Renderer *renderer; SDL_Renderer *renderer;
D3D12_RenderData *data; D3D12_RenderData *data;

130
src/render/metal/SDL_render_metal.m
View file

@ -159,8 +159,7 @@ typedef struct METAL_ShaderPipelines
@implementation METAL_TextureData @implementation METAL_TextureData
@end @end
static int static int IsMetalAvailable(const SDL_SysWMinfo *syswm)
IsMetalAvailable(const SDL_SysWMinfo *syswm)
{ {
if (syswm->subsystem != SDL_SYSWM_COCOA && syswm->subsystem != SDL_SYSWM_UIKIT) { if (syswm->subsystem != SDL_SYSWM_COCOA && syswm->subsystem != SDL_SYSWM_UIKIT) {
return SDL_SetError("Metal render target only supports Cocoa and UIKit video targets at the moment."); return SDL_SetError("Metal render target only supports Cocoa and UIKit video targets at the moment.");
@ -179,8 +178,7 @@ IsMetalAvailable(const SDL_SysWMinfo *syswm)
static const MTLBlendOperation invalidBlendOperation = (MTLBlendOperation)0xFFFFFFFF; static const MTLBlendOperation invalidBlendOperation = (MTLBlendOperation)0xFFFFFFFF;
static const MTLBlendFactor invalidBlendFactor = (MTLBlendFactor)0xFFFFFFFF; static const MTLBlendFactor invalidBlendFactor = (MTLBlendFactor)0xFFFFFFFF;
static MTLBlendOperation static MTLBlendOperation GetBlendOperation(SDL_BlendOperation operation)
GetBlendOperation(SDL_BlendOperation operation)
{ {
switch (operation) { switch (operation) {
case SDL_BLENDOPERATION_ADD: return MTLBlendOperationAdd; case SDL_BLENDOPERATION_ADD: return MTLBlendOperationAdd;
@ -192,8 +190,7 @@ GetBlendOperation(SDL_BlendOperation operation)
} }
} }
static MTLBlendFactor static MTLBlendFactor GetBlendFactor(SDL_BlendFactor factor)
GetBlendFactor(SDL_BlendFactor factor)
{ {
switch (factor) { switch (factor) {
case SDL_BLENDFACTOR_ZERO: return MTLBlendFactorZero; case SDL_BLENDFACTOR_ZERO: return MTLBlendFactorZero;
@ -210,8 +207,7 @@ GetBlendFactor(SDL_BlendFactor factor)
} }
} }
static NSString * static NSString *GetVertexFunctionName(SDL_MetalVertexFunction function)
GetVertexFunctionName(SDL_MetalVertexFunction function)
{ {
switch (function) { switch (function) {
case SDL_METAL_VERTEX_SOLID: return @"SDL_Solid_vertex"; case SDL_METAL_VERTEX_SOLID: return @"SDL_Solid_vertex";
@ -220,8 +216,7 @@ GetVertexFunctionName(SDL_MetalVertexFunction function)
} }
} }
static NSString * static NSString *GetFragmentFunctionName(SDL_MetalFragmentFunction function)
GetFragmentFunctionName(SDL_MetalFragmentFunction function)
{ {
switch (function) { switch (function) {
case SDL_METAL_FRAGMENT_SOLID: return @"SDL_Solid_fragment"; case SDL_METAL_FRAGMENT_SOLID: return @"SDL_Solid_fragment";
@ -233,9 +228,7 @@ GetFragmentFunctionName(SDL_MetalFragmentFunction function)
} }
} }
static id<MTLRenderPipelineState> static id<MTLRenderPipelineState> MakePipelineState(METAL_RenderData *data, METAL_PipelineCache *cache, NSString *blendlabel, SDL_BlendMode blendmode)
MakePipelineState(METAL_RenderData *data, METAL_PipelineCache *cache,
NSString *blendlabel, SDL_BlendMode blendmode)
{ {
MTLRenderPipelineDescriptor *mtlpipedesc; MTLRenderPipelineDescriptor *mtlpipedesc;
MTLVertexDescriptor *vertdesc; MTLVertexDescriptor *vertdesc;
@ -328,8 +321,7 @@ MakePipelineState(METAL_RenderData *data, METAL_PipelineCache *cache,
} }
} }
static void static void MakePipelineCache(METAL_RenderData *data, METAL_PipelineCache *cache, const char *label,
MakePipelineCache(METAL_RenderData *data, METAL_PipelineCache *cache, const char *label,
MTLPixelFormat rtformat, SDL_MetalVertexFunction vertfn, SDL_MetalFragmentFunction fragfn) MTLPixelFormat rtformat, SDL_MetalVertexFunction vertfn, SDL_MetalFragmentFunction fragfn)
{ {
SDL_zerop(cache); SDL_zerop(cache);
@ -348,8 +340,7 @@ MakePipelineCache(METAL_RenderData *data, METAL_PipelineCache *cache, const char
MakePipelineState(data, cache, @" (blend=mul)", SDL_BLENDMODE_MUL); MakePipelineState(data, cache, @" (blend=mul)", SDL_BLENDMODE_MUL);
} }
static void static void DestroyPipelineCache(METAL_PipelineCache *cache)
DestroyPipelineCache(METAL_PipelineCache *cache)
{ {
if (cache != NULL) { if (cache != NULL) {
for (int i = 0; i < cache->count; i++) { for (int i = 0; i < cache->count; i++) {
@ -360,8 +351,7 @@ DestroyPipelineCache(METAL_PipelineCache *cache)
} }
} }
void static void MakeShaderPipelines(METAL_RenderData *data, METAL_ShaderPipelines *pipelines, MTLPixelFormat rtformat)
MakeShaderPipelines(METAL_RenderData *data, METAL_ShaderPipelines *pipelines, MTLPixelFormat rtformat)
{ {
SDL_zerop(pipelines); SDL_zerop(pipelines);
@ -374,8 +364,7 @@ MakeShaderPipelines(METAL_RenderData *data, METAL_ShaderPipelines *pipelines, MT
MakePipelineCache(data, &pipelines->caches[SDL_METAL_FRAGMENT_NV21], "SDL NV21 pipeline", rtformat, SDL_METAL_VERTEX_COPY, SDL_METAL_FRAGMENT_NV21); MakePipelineCache(data, &pipelines->caches[SDL_METAL_FRAGMENT_NV21], "SDL NV21 pipeline", rtformat, SDL_METAL_VERTEX_COPY, SDL_METAL_FRAGMENT_NV21);
} }
static METAL_ShaderPipelines * static METAL_ShaderPipelines *ChooseShaderPipelines(METAL_RenderData *data, MTLPixelFormat rtformat)
ChooseShaderPipelines(METAL_RenderData *data, MTLPixelFormat rtformat)
{ {
METAL_ShaderPipelines *allpipelines = data.allpipelines; METAL_ShaderPipelines *allpipelines = data.allpipelines;
int count = data.pipelinescount; int count = data.pipelinescount;
@ -401,8 +390,7 @@ ChooseShaderPipelines(METAL_RenderData *data, MTLPixelFormat rtformat)
return &data.allpipelines[count]; return &data.allpipelines[count];
} }
static void static void DestroyAllPipelines(METAL_ShaderPipelines *allpipelines, int count)
DestroyAllPipelines(METAL_ShaderPipelines *allpipelines, int count)
{ {
if (allpipelines != NULL) { if (allpipelines != NULL) {
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
@ -415,8 +403,7 @@ DestroyAllPipelines(METAL_ShaderPipelines *allpipelines, int count)
} }
} }
static inline id<MTLRenderPipelineState> static inline id<MTLRenderPipelineState> ChoosePipelineState(METAL_RenderData *data, METAL_ShaderPipelines *pipelines, SDL_MetalFragmentFunction fragfn, SDL_BlendMode blendmode)
ChoosePipelineState(METAL_RenderData *data, METAL_ShaderPipelines *pipelines, SDL_MetalFragmentFunction fragfn, SDL_BlendMode blendmode)
{ {
METAL_PipelineCache *cache = &pipelines->caches[fragfn]; METAL_PipelineCache *cache = &pipelines->caches[fragfn];
@ -429,8 +416,7 @@ ChoosePipelineState(METAL_RenderData *data, METAL_ShaderPipelines *pipelines, SD
return MakePipelineState(data, cache, [NSString stringWithFormat:@" (blend=custom 0x%x)", blendmode], blendmode); return MakePipelineState(data, cache, [NSString stringWithFormat:@" (blend=custom 0x%x)", blendmode], blendmode);
} }
static SDL_bool static SDL_bool METAL_ActivateRenderCommandEncoder(SDL_Renderer * renderer, MTLLoadAction load, MTLClearColor *clear_color, id<MTLBuffer> vertex_buffer)
METAL_ActivateRenderCommandEncoder(SDL_Renderer * renderer, MTLLoadAction load, MTLClearColor *clear_color, id<MTLBuffer> vertex_buffer)
{ {
METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata; METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata;
@ -497,13 +483,11 @@ METAL_ActivateRenderCommandEncoder(SDL_Renderer * renderer, MTLLoadAction load,
return SDL_TRUE; return SDL_TRUE;
} }
static void static void METAL_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)
METAL_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)
{ {
} }
static int static int METAL_GetOutputSize(SDL_Renderer * renderer, int *w, int *h)
METAL_GetOutputSize(SDL_Renderer * renderer, int *w, int *h)
{ @autoreleasepool { { @autoreleasepool {
METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata; METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata;
if (w) { if (w) {
@ -515,8 +499,7 @@ METAL_GetOutputSize(SDL_Renderer * renderer, int *w, int *h)
return 0; return 0;
}} }}
static SDL_bool static SDL_bool METAL_SupportsBlendMode(SDL_Renderer * renderer, SDL_BlendMode blendMode)
METAL_SupportsBlendMode(SDL_Renderer * renderer, SDL_BlendMode blendMode)
{ {
SDL_BlendFactor srcColorFactor = SDL_GetBlendModeSrcColorFactor(blendMode); SDL_BlendFactor srcColorFactor = SDL_GetBlendModeSrcColorFactor(blendMode);
SDL_BlendFactor srcAlphaFactor = SDL_GetBlendModeSrcAlphaFactor(blendMode); SDL_BlendFactor srcAlphaFactor = SDL_GetBlendModeSrcAlphaFactor(blendMode);
@ -536,8 +519,7 @@ METAL_SupportsBlendMode(SDL_Renderer * renderer, SDL_BlendMode blendMode)
return SDL_TRUE; return SDL_TRUE;
} }
static int static int METAL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
METAL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{ @autoreleasepool { { @autoreleasepool {
METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata; METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata;
MTLPixelFormat pixfmt; MTLPixelFormat pixfmt;
@ -645,8 +627,7 @@ METAL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
return 0; return 0;
}} }}
static void static void METAL_UploadTextureData(id<MTLTexture> texture, SDL_Rect rect, int slice,
METAL_UploadTextureData(id<MTLTexture> texture, SDL_Rect rect, int slice,
const void * pixels, int pitch) const void * pixels, int pitch)
{ {
[texture replaceRegion:MTLRegionMake2D(rect.x, rect.y, rect.w, rect.h) [texture replaceRegion:MTLRegionMake2D(rect.x, rect.y, rect.w, rect.h)
@ -657,8 +638,7 @@ METAL_UploadTextureData(id<MTLTexture> texture, SDL_Rect rect, int slice,
bytesPerImage:0]; bytesPerImage:0];
} }
static MTLStorageMode static MTLStorageMode METAL_GetStorageMode(id<MTLResource> resource)
METAL_GetStorageMode(id<MTLResource> resource)
{ {
/* iOS 8 does not have this method. */ /* iOS 8 does not have this method. */
if ([resource respondsToSelector:@selector(storageMode)]) { if ([resource respondsToSelector:@selector(storageMode)]) {
@ -667,8 +647,7 @@ METAL_GetStorageMode(id<MTLResource> resource)
return MTLStorageModeShared; return MTLStorageModeShared;
} }
static int static int METAL_UpdateTextureInternal(SDL_Renderer * renderer, METAL_TextureData *texturedata,
METAL_UpdateTextureInternal(SDL_Renderer * renderer, METAL_TextureData *texturedata,
id<MTLTexture> texture, SDL_Rect rect, int slice, id<MTLTexture> texture, SDL_Rect rect, int slice,
const void * pixels, int pitch) const void * pixels, int pitch)
{ {
@ -736,8 +715,7 @@ METAL_UpdateTextureInternal(SDL_Renderer * renderer, METAL_TextureData *textured
return 0; return 0;
} }
static int static int METAL_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
METAL_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, const void *pixels, int pitch) const SDL_Rect * rect, const void *pixels, int pitch)
{ @autoreleasepool { { @autoreleasepool {
METAL_TextureData *texturedata = (__bridge METAL_TextureData *)texture->driverdata; METAL_TextureData *texturedata = (__bridge METAL_TextureData *)texture->driverdata;
@ -782,8 +760,7 @@ METAL_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
}} }}
#if SDL_HAVE_YUV #if SDL_HAVE_YUV
static int static int METAL_UpdateTextureYUV(SDL_Renderer * renderer, SDL_Texture * texture,
METAL_UpdateTextureYUV(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, const SDL_Rect * rect,
const Uint8 *Yplane, int Ypitch, const Uint8 *Yplane, int Ypitch,
const Uint8 *Uplane, int Upitch, const Uint8 *Uplane, int Upitch,
@ -814,8 +791,7 @@ METAL_UpdateTextureYUV(SDL_Renderer * renderer, SDL_Texture * texture,
return 0; return 0;
}} }}
static int static int METAL_UpdateTextureNV(SDL_Renderer * renderer, SDL_Texture * texture,
METAL_UpdateTextureNV(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, const SDL_Rect * rect,
const Uint8 *Yplane, int Ypitch, const Uint8 *Yplane, int Ypitch,
const Uint8 *UVplane, int UVpitch) const Uint8 *UVplane, int UVpitch)
@ -842,8 +818,7 @@ METAL_UpdateTextureNV(SDL_Renderer * renderer, SDL_Texture * texture,
}} }}
#endif #endif
static int static int METAL_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
METAL_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, void **pixels, int *pitch) const SDL_Rect * rect, void **pixels, int *pitch)
{ @autoreleasepool { { @autoreleasepool {
METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata; METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata;
@ -877,8 +852,7 @@ METAL_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
return 0; return 0;
}} }}
static void static void METAL_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
METAL_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{ @autoreleasepool { { @autoreleasepool {
METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata; METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata;
METAL_TextureData *texturedata = (__bridge METAL_TextureData *)texture->driverdata; METAL_TextureData *texturedata = (__bridge METAL_TextureData *)texture->driverdata;
@ -961,8 +935,7 @@ METAL_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
texturedata.hasdata = YES; texturedata.hasdata = YES;
}} }}
static void static void METAL_SetTextureScaleMode(SDL_Renderer * renderer, SDL_Texture * texture, SDL_ScaleMode scaleMode)
METAL_SetTextureScaleMode(SDL_Renderer * renderer, SDL_Texture * texture, SDL_ScaleMode scaleMode)
{ @autoreleasepool { { @autoreleasepool {
METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata; METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata;
METAL_TextureData *texturedata = (__bridge METAL_TextureData *)texture->driverdata; METAL_TextureData *texturedata = (__bridge METAL_TextureData *)texture->driverdata;
@ -974,8 +947,7 @@ METAL_SetTextureScaleMode(SDL_Renderer * renderer, SDL_Texture * texture, SDL_Sc
} }
}} }}
static int static int METAL_SetRenderTarget(SDL_Renderer * renderer, SDL_Texture * texture)
METAL_SetRenderTarget(SDL_Renderer * renderer, SDL_Texture * texture)
{ @autoreleasepool { { @autoreleasepool {
METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata; METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata;
@ -996,8 +968,7 @@ METAL_SetRenderTarget(SDL_Renderer * renderer, SDL_Texture * texture)
}} }}
static int static int METAL_QueueSetViewport(SDL_Renderer * renderer, SDL_RenderCommand *cmd)
METAL_QueueSetViewport(SDL_Renderer * renderer, SDL_RenderCommand *cmd)
{ {
float projection[4][4]; /* Prepare an orthographic projection */ float projection[4][4]; /* Prepare an orthographic projection */
const int w = cmd->data.viewport.rect.w; const int w = cmd->data.viewport.rect.w;
@ -1021,8 +992,7 @@ METAL_QueueSetViewport(SDL_Renderer * renderer, SDL_RenderCommand *cmd)
return 0; return 0;
} }
static int static int METAL_QueueSetDrawColor(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
METAL_QueueSetDrawColor(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
{ {
const size_t vertlen = sizeof(float) * 4; const size_t vertlen = sizeof(float) * 4;
float *verts = (float *) SDL_AllocateRenderVertices(renderer, vertlen, DEVICE_ALIGN(16), &cmd->data.color.first); float *verts = (float *) SDL_AllocateRenderVertices(renderer, vertlen, DEVICE_ALIGN(16), &cmd->data.color.first);
@ -1040,8 +1010,7 @@ METAL_QueueSetDrawColor(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
return 0; return 0;
} }
static int static int METAL_QueueDrawPoints(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FPoint * points, int count)
METAL_QueueDrawPoints(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FPoint * points, int count)
{ {
const SDL_Color color = { const SDL_Color color = {
cmd->data.draw.r, cmd->data.draw.r,
@ -1065,8 +1034,7 @@ METAL_QueueDrawPoints(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL
return 0; return 0;
} }
static int static int METAL_QueueDrawLines(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FPoint * points, int count)
METAL_QueueDrawLines(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FPoint * points, int count)
{ {
const SDL_Color color = { const SDL_Color color = {
cmd->data.draw.r, cmd->data.draw.r,
@ -1119,8 +1087,7 @@ METAL_QueueDrawLines(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_
return 0; return 0;
} }
static int static int METAL_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
METAL_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
const float *xy, int xy_stride, const SDL_Color *color, int color_stride, const float *uv, int uv_stride, const float *xy, int xy_stride, const SDL_Color *color, int color_stride, const float *uv, int uv_stride,
int num_vertices, const void *indices, int num_indices, int size_indices, int num_vertices, const void *indices, int num_indices, int size_indices,
float scale_x, float scale_y) float scale_x, float scale_y)
@ -1181,8 +1148,7 @@ typedef struct
size_t color_offset; size_t color_offset;
} METAL_DrawStateCache; } METAL_DrawStateCache;
static SDL_bool static SDL_bool SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const SDL_MetalFragmentFunction shader,
SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const SDL_MetalFragmentFunction shader,
const size_t constants_offset, id<MTLBuffer> mtlbufvertex, METAL_DrawStateCache *statecache) const size_t constants_offset, id<MTLBuffer> mtlbufvertex, METAL_DrawStateCache *statecache)
{ {
METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata; METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata;
@ -1262,8 +1228,7 @@ SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const SDL_Met
return SDL_TRUE; return SDL_TRUE;
} }
static SDL_bool static SDL_bool SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const size_t constants_offset,
SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const size_t constants_offset,
id<MTLBuffer> mtlbufvertex, METAL_DrawStateCache *statecache) id<MTLBuffer> mtlbufvertex, METAL_DrawStateCache *statecache)
{ {
METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata; METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata;
@ -1295,8 +1260,7 @@ SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const size_t
return SDL_TRUE; return SDL_TRUE;
} }
static int static int METAL_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
METAL_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
{ @autoreleasepool { { @autoreleasepool {
METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata; METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata;
id<MTLBuffer> mtlbufvertex = nil; id<MTLBuffer> mtlbufvertex = nil;
@ -1437,8 +1401,7 @@ METAL_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *ver
return 0; return 0;
}} }}
static int static int METAL_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
METAL_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
Uint32 pixel_format, void * pixels, int pitch) Uint32 pixel_format, void * pixels, int pitch)
{ @autoreleasepool { { @autoreleasepool {
METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata; METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata;
@ -1490,8 +1453,7 @@ METAL_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
return status; return status;
}} }}
static int static int METAL_RenderPresent(SDL_Renderer * renderer)
METAL_RenderPresent(SDL_Renderer * renderer)
{ @autoreleasepool { { @autoreleasepool {
METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata; METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata;
SDL_bool ready = SDL_TRUE; SDL_bool ready = SDL_TRUE;
@ -1528,15 +1490,13 @@ METAL_RenderPresent(SDL_Renderer * renderer)
return 0; return 0;
}} }}
static void static void METAL_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
METAL_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{ @autoreleasepool { { @autoreleasepool {
CFBridgingRelease(texture->driverdata); CFBridgingRelease(texture->driverdata);
texture->driverdata = NULL; texture->driverdata = NULL;
}} }}
static void static void METAL_DestroyRenderer(SDL_Renderer * renderer)
METAL_DestroyRenderer(SDL_Renderer * renderer)
{ @autoreleasepool { { @autoreleasepool {
if (renderer->driverdata) { if (renderer->driverdata) {
METAL_RenderData *data = CFBridgingRelease(renderer->driverdata); METAL_RenderData *data = CFBridgingRelease(renderer->driverdata);
@ -1557,15 +1517,13 @@ METAL_DestroyRenderer(SDL_Renderer * renderer)
SDL_free(renderer); SDL_free(renderer);
}} }}
static void * static void *METAL_GetMetalLayer(SDL_Renderer * renderer)
METAL_GetMetalLayer(SDL_Renderer * renderer)
{ @autoreleasepool { { @autoreleasepool {
METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata; METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata;
return (__bridge void*)data.mtllayer; return (__bridge void*)data.mtllayer;
}} }}
static void * static void *METAL_GetMetalCommandEncoder(SDL_Renderer * renderer)
METAL_GetMetalCommandEncoder(SDL_Renderer * renderer)
{ @autoreleasepool { { @autoreleasepool {
// note that data.mtlcmdencoder can be nil if METAL_ActivateRenderCommandEncoder fails. // note that data.mtlcmdencoder can be nil if METAL_ActivateRenderCommandEncoder fails.
// Before SDL 2.0.18, it might have returned a non-nil encoding that might not have been // Before SDL 2.0.18, it might have returned a non-nil encoding that might not have been
@ -1576,8 +1534,7 @@ METAL_GetMetalCommandEncoder(SDL_Renderer * renderer)
return (__bridge void*)data.mtlcmdencoder; return (__bridge void*)data.mtlcmdencoder;
}} }}
static int static int METAL_SetVSync(SDL_Renderer * renderer, const int vsync)
METAL_SetVSync(SDL_Renderer * renderer, const int vsync)
{ {
#if (defined(__MACOSX__) && defined(MAC_OS_X_VERSION_10_13)) || TARGET_OS_MACCATALYST #if (defined(__MACOSX__) && defined(MAC_OS_X_VERSION_10_13)) || TARGET_OS_MACCATALYST
if (@available(macOS 10.13, *)) { if (@available(macOS 10.13, *)) {
@ -1623,8 +1580,7 @@ static SDL_MetalView GetWindowView(SDL_Window *window)
return nil; return nil;
} }
static SDL_Renderer * static SDL_Renderer *METAL_CreateRenderer(SDL_Window * window, Uint32 flags)
METAL_CreateRenderer(SDL_Window * window, Uint32 flags)
{ @autoreleasepool { { @autoreleasepool {
SDL_Renderer *renderer = NULL; SDL_Renderer *renderer = NULL;
METAL_RenderData *data = NULL; METAL_RenderData *data = NULL;

3
src/render/opengl/SDL_shaders_gl.c
View file

@ -490,8 +490,7 @@ static void DestroyShaderProgram(GL_ShaderContext *ctx, GL_ShaderData *data)
ctx->glDeleteObjectARB(data->program); ctx->glDeleteObjectARB(data->program);
} }
GL_ShaderContext * GL_ShaderContext *GL_CreateShaderContext(void)
GL_CreateShaderContext(void)
{ {
GL_ShaderContext *ctx; GL_ShaderContext *ctx;
SDL_bool shaders_supported; SDL_bool shaders_supported;

3
src/render/psp/SDL_render_psp.c
View file

@ -1291,8 +1291,7 @@ static int PSP_SetVSync(SDL_Renderer *renderer, const int vsync)
return 0; return 0;
} }
SDL_Renderer * SDL_Renderer *PSP_CreateRenderer(SDL_Window *window, Uint32 flags)
PSP_CreateRenderer(SDL_Window *window, Uint32 flags)
{ {
SDL_Renderer *renderer; SDL_Renderer *renderer;

3
src/render/software/SDL_render_sw.c
View file

@ -986,8 +986,7 @@ static void SW_DestroyRenderer(SDL_Renderer *renderer)
SDL_free(renderer); SDL_free(renderer);
} }
SDL_Renderer * SDL_Renderer *SW_CreateRendererForSurface(SDL_Surface *surface)
SW_CreateRendererForSurface(SDL_Surface *surface)
{ {
SDL_Renderer *renderer; SDL_Renderer *renderer;
SW_RenderData *data; SW_RenderData *data;

3
src/render/software/SDL_rotate.c
View file

@ -488,8 +488,7 @@ When using the NONE and MOD modes, color and alpha modulation must be applied be
*/ */
SDL_Surface * SDL_Surface *SDLgfx_rotateSurface(SDL_Surface *src, double angle, int smooth, int flipx, int flipy,
SDLgfx_rotateSurface(SDL_Surface *src, double angle, int smooth, int flipx, int flipy,
const SDL_Rect *rect_dest, double cangle, double sangle, const SDL_FPoint *center) const SDL_Rect *rect_dest, double cangle, double sangle, const SDL_FPoint *center)
{ {
SDL_Surface *rz_dst; SDL_Surface *rz_dst;

3
src/render/vitagxm/SDL_render_vita_gxm.c
View file

@ -211,8 +211,7 @@ static int VITA_GXM_SetVSync(SDL_Renderer *renderer, const int vsync)
return 0; return 0;
} }
SDL_Renderer * SDL_Renderer *VITA_GXM_CreateRenderer(SDL_Window *window, Uint32 flags)
VITA_GXM_CreateRenderer(SDL_Window *window, Uint32 flags)
{ {
SDL_Renderer *renderer; SDL_Renderer *renderer;
VITA_GXM_RenderData *data; VITA_GXM_RenderData *data;

12
src/render/vitagxm/SDL_render_vita_gxm_memory.c
View file

@ -25,8 +25,7 @@
#include "SDL_render_vita_gxm_memory.h" #include "SDL_render_vita_gxm_memory.h"
void * void *vita_mem_alloc(unsigned int type, unsigned int size, unsigned int alignment, unsigned int attribs, SceUID *uid)
vita_mem_alloc(unsigned int type, unsigned int size, unsigned int alignment, unsigned int attribs, SceUID *uid)
{ {
void *mem; void *mem;
@ -63,8 +62,7 @@ void vita_mem_free(SceUID uid)
sceKernelFreeMemBlock(uid); sceKernelFreeMemBlock(uid);
} }
void * void *vita_gpu_mem_alloc(VITA_GXM_RenderData *data, unsigned int size)
vita_gpu_mem_alloc(VITA_GXM_RenderData *data, unsigned int size)
{ {
void *mem; void *mem;
@ -122,8 +120,7 @@ void vita_gpu_mem_destroy(VITA_GXM_RenderData *data)
} }
} }
void * void *vita_mem_vertex_usse_alloc(unsigned int size, SceUID *uid, unsigned int *usse_offset)
vita_mem_vertex_usse_alloc(unsigned int size, SceUID *uid, unsigned int *usse_offset)
{ {
void *mem = NULL; void *mem = NULL;
@ -150,8 +147,7 @@ void vita_mem_vertex_usse_free(SceUID uid)
sceKernelFreeMemBlock(uid); sceKernelFreeMemBlock(uid);
} }
void * void *vita_mem_fragment_usse_alloc(unsigned int size, SceUID *uid, unsigned int *usse_offset)
vita_mem_fragment_usse_alloc(unsigned int size, SceUID *uid, unsigned int *usse_offset)
{ {
void *mem = NULL; void *mem = NULL;

12
src/render/vitagxm/SDL_render_vita_gxm_tools.c
View file

@ -81,8 +81,7 @@ static void patcher_host_free(void *user_data, void *mem)
SDL_free(mem); SDL_free(mem);
} }
void * void *pool_malloc(VITA_GXM_RenderData *data, unsigned int size)
pool_malloc(VITA_GXM_RenderData *data, unsigned int size)
{ {
if ((data->pool_index + size) < VITA_GXM_POOL_SIZE) { if ((data->pool_index + size) < VITA_GXM_POOL_SIZE) {
@ -94,8 +93,7 @@ pool_malloc(VITA_GXM_RenderData *data, unsigned int size)
return NULL; return NULL;
} }
void * void *pool_memalign(VITA_GXM_RenderData *data, unsigned int size, unsigned int alignment)
pool_memalign(VITA_GXM_RenderData *data, unsigned int size, unsigned int alignment)
{ {
unsigned int new_index = (data->pool_index + alignment - 1) & ~(alignment - 1); unsigned int new_index = (data->pool_index + alignment - 1) & ~(alignment - 1);
if ((new_index + size) < VITA_GXM_POOL_SIZE) { if ((new_index + size) < VITA_GXM_POOL_SIZE) {
@ -959,8 +957,7 @@ gxm_texture_get_format(const gxm_texture *texture)
return sceGxmTextureGetFormat(&texture->gxm_tex); return sceGxmTextureGetFormat(&texture->gxm_tex);
} }
void * void *gxm_texture_get_datap(const gxm_texture *texture)
gxm_texture_get_datap(const gxm_texture *texture)
{ {
return sceGxmTextureGetData(&texture->gxm_tex); return sceGxmTextureGetData(&texture->gxm_tex);
} }
@ -985,8 +982,7 @@ static SceGxmColorFormat tex_format_to_color_format(SceGxmTextureFormat format)
} }
} }
gxm_texture * gxm_texture *create_gxm_texture(VITA_GXM_RenderData *data, unsigned int w, unsigned int h, SceGxmTextureFormat format, unsigned int isRenderTarget, unsigned int *return_w, unsigned int *return_h, unsigned int *return_pitch, float *return_wscale)
create_gxm_texture(VITA_GXM_RenderData *data, unsigned int w, unsigned int h, SceGxmTextureFormat format, unsigned int isRenderTarget, unsigned int *return_w, unsigned int *return_h, unsigned int *return_pitch, float *return_wscale)
{ {
gxm_texture *texture = SDL_calloc(1, sizeof(gxm_texture)); gxm_texture *texture = SDL_calloc(1, sizeof(gxm_texture));
int aligned_w = ALIGN(w, 8); int aligned_w = ALIGN(w, 8);

9
src/stdlib/SDL_getenv.c
View file

@ -168,8 +168,7 @@ int SDL_setenv(const char *name, const char *value, int overwrite)
/* Retrieve a variable named "name" from the environment */ /* Retrieve a variable named "name" from the environment */
#if defined(HAVE_GETENV) #if defined(HAVE_GETENV)
char * char *SDL_getenv(const char *name)
SDL_getenv(const char *name)
{ {
#if defined(__ANDROID__) #if defined(__ANDROID__)
/* Make sure variables from the application manifest are available */ /* Make sure variables from the application manifest are available */
@ -184,8 +183,7 @@ SDL_getenv(const char *name)
return getenv(name); return getenv(name);
} }
#elif defined(__WIN32__) || defined(__WINGDK__) #elif defined(__WIN32__) || defined(__WINGDK__)
char * char *SDL_getenv(const char *name)
SDL_getenv(const char *name)
{ {
size_t bufferlen; size_t bufferlen;
@ -211,8 +209,7 @@ SDL_getenv(const char *name)
return SDL_envmem; return SDL_envmem;
} }
#else #else
char * char *SDL_getenv(const char *name)
SDL_getenv(const char *name)
{ {
size_t len, i; size_t len, i;
char *value; char *value;

Some files were not shown because too many files have changed in this diff Show more