diff --git a/VB6_Wrapper/vb6_sdl_binds.c b/VB6_Wrapper/vb6_sdl_binds.c
index 4c93a33a..de7a57eb 100644
--- a/VB6_Wrapper/vb6_sdl_binds.c
+++ b/VB6_Wrapper/vb6_sdl_binds.c
@@ -44,44 +44,44 @@ extern DECLSPEC int SDL_Init(Uint32 flags);
 extern DECLSPEC void SDL_Quit();
 extern DECLSPEC const char * SDL_GetError(void);
 
-__declspec(dllexport) int SDLCALLCC SDL_InitAudio(void)
+__declspec(dllexport) int MIXCALLCC SDL_InitAudio(void)
 {
     return SDL_Init(SDL_INIT_AUDIO);
 }
 
-__declspec(dllexport) void SDLCALLCC SDL_QuitVB6(void)
+__declspec(dllexport) void MIXCALLCC SDL_QuitVB6(void)
 {
     SDL_Quit();
 }
 
-__declspec(dllexport) int SDLCALLCC Mix_InitVB6(void)
+__declspec(dllexport) int MIXCALLCC Mix_InitVB6(void)
 {
     return Mix_Init(0);
 }
 
-__declspec(dllexport) int SDLCALLCC Mix_OpenAudioVB6(int frequency, int format, int channels, int chunksize)
+__declspec(dllexport) int MIXCALLCC Mix_OpenAudioVB6(int frequency, int format, int channels, int chunksize)
 {
     return Mix_OpenAudio(frequency, (Uint16)format, channels, chunksize);
 }
 
-__declspec(dllexport) Mix_Chunk * SDLCALLCC Mix_LoadWAV_VB6(const char*file)
+__declspec(dllexport) Mix_Chunk * MIXCALLCC Mix_LoadWAV_VB6(const char*file)
 {
     return Mix_LoadWAV_RW(SDL_RWFromFile(file, "rb"), 1);
 }
 
-__declspec(dllexport) const char* SDLCALLCC SDL_GetErrorVB6(void)
+__declspec(dllexport) const char* MIXCALLCC SDL_GetErrorVB6(void)
 {
     return SDL_GetError();
 }
 
 /* SDL RWops*/
 
-__declspec(dllexport) SDL_RWops * SDLCALLCC SDL_RWFromFileVB6(const char *file, const char *mode)
+__declspec(dllexport) SDL_RWops * MIXCALLCC SDL_RWFromFileVB6(const char *file, const char *mode)
 {
     return SDL_RWFromFileVB6(file, mode);
 }
 
-__declspec(dllexport) SDL_RWops * SDLCALLCC SDL_RWFromMemVB6(void *mem, int size)
+__declspec(dllexport) SDL_RWops * MIXCALLCC SDL_RWFromMemVB6(void *mem, int size)
 {
     return SDL_RWFromMem(mem, size);
 }
@@ -91,42 +91,42 @@ __declspec(dllexport) SDL_RWops * SDL_AllocRWVB6(void)
     return SDL_AllocRW();
 }
 
-__declspec(dllexport) void SDLCALLCC SDL_FreeRWVB6(SDL_RWops * area)
+__declspec(dllexport) void MIXCALLCC SDL_FreeRWVB6(SDL_RWops * area)
 {
     SDL_FreeRW(area);
 }
 
-__declspec(dllexport) int SDLCALLCC SDL_RWsizeVB6(SDL_RWops * ctx)
+__declspec(dllexport) int MIXCALLCC SDL_RWsizeVB6(SDL_RWops * ctx)
 {
     return (int)(ctx)->size(ctx);
 }
 
-__declspec(dllexport) int SDLCALLCC SDL_RWseekVB6(SDL_RWops * ctx, int offset, int whence)
+__declspec(dllexport) int MIXCALLCC SDL_RWseekVB6(SDL_RWops * ctx, int offset, int whence)
 {
     return (int)(ctx)->seek(ctx, offset, whence);
 }
 
-__declspec(dllexport) int SDLCALLCC SDL_RWtellVB6(SDL_RWops * ctx)
+__declspec(dllexport) int MIXCALLCC SDL_RWtellVB6(SDL_RWops * ctx)
 {
     return (int)(ctx)->seek(ctx, 0, RW_SEEK_CUR);
 }
 
-__declspec(dllexport) int SDLCALLCC SDL_RWreadVB6(SDL_RWops * ctx, void*ptr, int size, int maxnum)
+__declspec(dllexport) int MIXCALLCC SDL_RWreadVB6(SDL_RWops * ctx, void*ptr, int size, int maxnum)
 {
     return (int)(ctx)->read(ctx, ptr, size, maxnum);
 }
 
-__declspec(dllexport) int SDLCALLCC SDL_RWwriteVB6(SDL_RWops * ctx, void* ptr, int size, int maxnum)
+__declspec(dllexport) int MIXCALLCC SDL_RWwriteVB6(SDL_RWops * ctx, void* ptr, int size, int maxnum)
 {
     return (int)(ctx)->write(ctx, ptr, size, maxnum);
 }
 
-__declspec(dllexport) int SDLCALLCC SDL_RWcloseVB6(SDL_RWops * ctx)
+__declspec(dllexport) int MIXCALLCC SDL_RWcloseVB6(SDL_RWops * ctx)
 {
     return (int)(ctx)->close(ctx);
 }
 
-__declspec(dllexport) const char* SDLCALLCC MIX_ADLMIDI_getBankName(int bankID)
+__declspec(dllexport) const char* MIXCALLCC MIX_ADLMIDI_getBankName(int bankID)
 {
     return Mix_ADLMIDI_getBankNames()[bankID];
 }
diff --git a/include/SDL_mixer.h b/include/SDL_mixer.h
index 05b63d00..301c2542 100644
--- a/include/SDL_mixer.h
+++ b/include/SDL_mixer.h
@@ -38,13 +38,11 @@
 #define MIXSDLCALL
 
 #if defined(FORCE_STDCALLS) && defined(_WIN32)
-#   ifdef SDLCALL
-#       undef SDLCALL
-#   endif
-#   define SDLCALL   __stdcall
-#   define SDLCALLCC __stdcall
+#   define MIXCALL   __stdcall
+#   define MIXCALLCC __stdcall
 #else
-#   define SDLCALLCC
+#   define MIXCALL SDLCALL
+#   define MIXCALLCC
 #endif
 
 #ifndef MIXERX_DEPRECATED
@@ -117,7 +115,7 @@ extern "C" {
    it should NOT be used to fill a version structure, instead you should
    use the SDL_MIXER_VERSION() macro.
  */
-extern DECLSPEC const SDL_version * SDLCALL Mix_Linked_Version(void);
+extern DECLSPEC const SDL_version * MIXCALL Mix_Linked_Version(void);
 
 typedef enum
 {
@@ -133,10 +131,10 @@ typedef enum
    one or more flags from MIX_InitFlags OR'd together.
    It returns the flags successfully initialized, or 0 on failure.
  */
-extern DECLSPEC int SDLCALL Mix_Init(int flags);
+extern DECLSPEC int MIXCALL Mix_Init(int flags);
 
 /* Unloads libraries loaded with Mix_Init */
-extern DECLSPEC void SDLCALL Mix_Quit(void);
+extern DECLSPEC void MIXCALL Mix_Quit(void);
 
 
 /* The default mixer has 8 simultaneous mixing channels */
@@ -262,25 +260,25 @@ typedef enum {
 typedef struct _Mix_Music Mix_Music;
 
 /* Open the mixer with a certain audio format */
-extern DECLSPEC int SDLCALL Mix_OpenAudio(int frequency, Uint16 format, int channels, int chunksize);
+extern DECLSPEC int MIXCALL Mix_OpenAudio(int frequency, Uint16 format, int channels, int chunksize);
 
 /* Open the mixer with specific device and certain audio format */
-extern DECLSPEC int SDLCALL Mix_OpenAudioDevice(int frequency, Uint16 format, int channels, int chunksize, const char* device, int allowed_changes);
+extern DECLSPEC int MIXCALL Mix_OpenAudioDevice(int frequency, Uint16 format, int channels, int chunksize, const char* device, int allowed_changes);
 
 /* Pause or resume the audio streaming */
-extern DECLSPEC void SDLCALL Mix_PauseAudio(int pause_on);
+extern DECLSPEC void MIXCALL Mix_PauseAudio(int pause_on);
 
 /* Dynamically change the number of channels managed by the mixer.
    If decreasing the number of channels, the upper channels are
    stopped.
    This function returns the new number of allocated channels.
  */
-extern DECLSPEC int SDLCALL Mix_AllocateChannels(int numchans);
+extern DECLSPEC int MIXCALL Mix_AllocateChannels(int numchans);
 
 /* Find out what the actual audio device parameters are.
    This function returns 1 if the audio has been opened, 0 otherwise.
  */
-extern DECLSPEC int SDLCALL Mix_QuerySpec(int *frequency,Uint16 *format,int *channels);
+extern DECLSPEC int MIXCALL Mix_QuerySpec(int *frequency,Uint16 *format,int *channels);
 
 /* Load a wave file or a music (.mod .s3m .it .xm) file
     IMPORTANT: To choice a track number of NSF, GBM, HES, etc file,
@@ -289,48 +287,48 @@ extern DECLSPEC int SDLCALL Mix_QuerySpec(int *frequency,Uint16 *format,int *cha
                Where xxx - actual number of chip track, (from 0 to N-1)
                Examples: "file.nsf|12", "file.hes|2"
 */
-extern DECLSPEC Mix_Chunk * SDLCALL Mix_LoadWAV_RW(SDL_RWops *src, int freesrc);
+extern DECLSPEC Mix_Chunk * MIXCALL Mix_LoadWAV_RW(SDL_RWops *src, int freesrc);
 #define Mix_LoadWAV(file)   Mix_LoadWAV_RW(SDL_RWFromFile(file, "rb"), 1)
-extern DECLSPEC Mix_Music * SDLCALL Mix_LoadMUS(const char *file);
+extern DECLSPEC Mix_Music * MIXCALL Mix_LoadMUS(const char *file);
 
 /* Set the displayable filename used in cases of memory-read files */
-extern DECLSPEC void SDLCALL Mix_SetMusicFileName(Mix_Music *music, const char *file);
+extern DECLSPEC void MIXCALL Mix_SetMusicFileName(Mix_Music *music, const char *file);
 
 /* Load a music file from an SDL_RWop object
  * Matt Campbell (matt@campbellhome.dhs.org) April 2000 */
-extern DECLSPEC Mix_Music * SDLCALL Mix_LoadMUS_RW(SDL_RWops *src, int freesrc);
+extern DECLSPEC Mix_Music * MIXCALL Mix_LoadMUS_RW(SDL_RWops *src, int freesrc);
 
 /* Load a music file from an SDL_RWop object with custom arguments (trackID for GME or settings for a MIDI playing)
  * Arguments are taking no effect for file formats which are not supports extra arguments.
   */
-extern DECLSPEC Mix_Music *SDLCALL Mix_LoadMUS_RW_ARG(SDL_RWops *src, int freesrc, const char *args);
+extern DECLSPEC Mix_Music *MIXCALL Mix_LoadMUS_RW_ARG(SDL_RWops *src, int freesrc, const char *args);
 
 /* Load a music file from an SDL_RWop object with custom trackID for GME.
  * trackID argument takes no effect for non-NSF,HES,GBM,etc. file formats.
  * Default value should be 0
  */
-extern DECLSPEC Mix_Music *SDLCALL Mix_LoadMUS_RW_GME(SDL_RWops *src, int freesrc, int trackID);
+extern DECLSPEC Mix_Music *MIXCALL Mix_LoadMUS_RW_GME(SDL_RWops *src, int freesrc, int trackID);
 
 /* Load a music file from an SDL_RWop object assuming a specific format */
-extern DECLSPEC Mix_Music * SDLCALL Mix_LoadMUSType_RW(SDL_RWops *src, Mix_MusicType type, int freesrc);
+extern DECLSPEC Mix_Music * MIXCALL Mix_LoadMUSType_RW(SDL_RWops *src, Mix_MusicType type, int freesrc);
 
 /* Load a music file from an SDL_RWop object assuming a specific format
    with custom arguments (trackID for GME or settings for a MIDI playing) */
-extern DECLSPEC Mix_Music * SDLCALL Mix_LoadMUSType_RW_ARG(SDL_RWops *src, Mix_MusicType type, int freesrc, const char *args);
+extern DECLSPEC Mix_Music * MIXCALL Mix_LoadMUSType_RW_ARG(SDL_RWops *src, Mix_MusicType type, int freesrc, const char *args);
 
 /* Load a wave file of the mixer format from a memory buffer */
-extern DECLSPEC Mix_Chunk * SDLCALL Mix_QuickLoad_WAV(Uint8 *mem);
+extern DECLSPEC Mix_Chunk * MIXCALL Mix_QuickLoad_WAV(Uint8 *mem);
 
 /* Load raw audio data of the mixer format from a memory buffer */
-extern DECLSPEC Mix_Chunk * SDLCALL Mix_QuickLoad_RAW(Uint8 *mem, Uint32 len);
+extern DECLSPEC Mix_Chunk * MIXCALL Mix_QuickLoad_RAW(Uint8 *mem, Uint32 len);
 
 /* Free an audio chunk previously loaded */
-extern DECLSPEC void SDLCALL Mix_FreeChunk(Mix_Chunk *chunk);
-extern DECLSPEC void SDLCALL Mix_FreeMusic(Mix_Music *music);
+extern DECLSPEC void MIXCALL Mix_FreeChunk(Mix_Chunk *chunk);
+extern DECLSPEC void MIXCALL Mix_FreeMusic(Mix_Music *music);
 
 /* Set the music to be self-destroyed once playback has get finished.
  Works only on multi-stream sub-system. */
-extern DECLSPEC int SDLCALL Mix_SetFreeOnStop(Mix_Music *music, int free_on_stop);
+extern DECLSPEC int MIXCALL Mix_SetFreeOnStop(Mix_Music *music, int free_on_stop);
 
 /* Get a list of chunk/music decoders that this build of SDL_mixer provides.
    This list can change between builds AND runs of the program, if external
@@ -351,49 +349,49 @@ extern DECLSPEC int SDLCALL Mix_SetFreeOnStop(Mix_Music *music, int free_on_stop
    These return values are static, read-only data; do not modify or free it.
    The pointers remain valid until you call Mix_CloseAudio().
 */
-extern DECLSPEC int SDLCALL Mix_GetNumChunkDecoders(void);
-extern DECLSPEC const char * SDLCALL Mix_GetChunkDecoder(int index);
-extern DECLSPEC SDL_bool SDLCALL Mix_HasChunkDecoder(const char *name);
-extern DECLSPEC int SDLCALL Mix_GetNumMusicDecoders(void);
-extern DECLSPEC const char * SDLCALL Mix_GetMusicDecoder(int index);
-extern DECLSPEC SDL_bool SDLCALL Mix_HasMusicDecoder(const char *name);
+extern DECLSPEC int MIXCALL Mix_GetNumChunkDecoders(void);
+extern DECLSPEC const char * MIXCALL Mix_GetChunkDecoder(int index);
+extern DECLSPEC SDL_bool MIXCALL Mix_HasChunkDecoder(const char *name);
+extern DECLSPEC int MIXCALL Mix_GetNumMusicDecoders(void);
+extern DECLSPEC const char * MIXCALL Mix_GetMusicDecoder(int index);
+extern DECLSPEC SDL_bool MIXCALL Mix_HasMusicDecoder(const char *name);
 
 /* Find out the music format of a mixer music, or the currently playing
    music, if 'music' is NULL.
 */
-extern DECLSPEC Mix_MusicType SDLCALL Mix_GetMusicType(const Mix_Music *music);
+extern DECLSPEC Mix_MusicType MIXCALL Mix_GetMusicType(const Mix_Music *music);
 
 /* Get music title from meta-tag if possible. If title tag is empty, filename will be returned */
-extern DECLSPEC const char *SDLCALL Mix_GetMusicTitle(const Mix_Music *music);
+extern DECLSPEC const char *MIXCALL Mix_GetMusicTitle(const Mix_Music *music);
 /* Get music title from meta-tag if possible */
-extern DECLSPEC const char *SDLCALL Mix_GetMusicTitleTag(const Mix_Music *music);
+extern DECLSPEC const char *MIXCALL Mix_GetMusicTitleTag(const Mix_Music *music);
 /* Get music artist from meta-tag if possible */
-extern DECLSPEC const char *SDLCALL Mix_GetMusicArtistTag(const Mix_Music *music);
+extern DECLSPEC const char *MIXCALL Mix_GetMusicArtistTag(const Mix_Music *music);
 /* Get music album from meta-tag if possible */
-extern DECLSPEC const char *SDLCALL Mix_GetMusicAlbumTag(const Mix_Music *music);
+extern DECLSPEC const char *MIXCALL Mix_GetMusicAlbumTag(const Mix_Music *music);
 /* Get music copyright from meta-tag if possible */
-extern DECLSPEC const char *SDLCALL Mix_GetMusicCopyrightTag(const Mix_Music *music);
+extern DECLSPEC const char *MIXCALL Mix_GetMusicCopyrightTag(const Mix_Music *music);
 
 /* Set a function that is called after all mixing is performed.
    This can be used to provide real-time visual display of the audio stream
    or add a custom mixer filter for the stream data.
 */
-extern DECLSPEC void SDLCALL Mix_SetPostMix(void (SDLCALL *mix_func)(void *udata, Uint8 *stream, int len), void *arg);
+extern DECLSPEC void MIXCALL Mix_SetPostMix(void (SDLCALL *mix_func)(void *udata, Uint8 *stream, int len), void *arg);
 
 /* Add your own music player or additional mixer function.
    If 'mix_func' is NULL, the default music player is re-enabled.
  */
-extern DECLSPEC void SDLCALL Mix_HookMusic(void (SDLCALL *mix_func)(void *udata, Uint8 *stream, int len), void *arg);
+extern DECLSPEC void MIXCALL Mix_HookMusic(void (SDLCALL *mix_func)(void *udata, Uint8 *stream, int len), void *arg);
 
 /* Add your own callback for when the music has finished playing or when it is
  * stopped from a call to Mix_HaltMusic.
  */
-extern DECLSPEC void SDLCALL Mix_HookMusicFinished(void (SDLCALL *music_finished)(void));
-extern DECLSPEC void SDLCALL Mix_HookMusicStreamFinishedAny(void (SDLCALL *music_finished)(void));
-extern DECLSPEC void SDLCALL Mix_HookMusicStreamFinished(Mix_Music *music, void (SDLCALL *music_finished)(Mix_Music*, void*), void *user_data);/*Mixer-X*/
+extern DECLSPEC void MIXCALL Mix_HookMusicFinished(void (SDLCALL *music_finished)(void));
+extern DECLSPEC void MIXCALL Mix_HookMusicStreamFinishedAny(void (SDLCALL *music_finished)(void));
+extern DECLSPEC void MIXCALL Mix_HookMusicStreamFinished(Mix_Music *music, void (SDLCALL *music_finished)(Mix_Music*, void*), void *user_data);/*Mixer-X*/
 
 /* Get a pointer to the user data for the current music hook */
-extern DECLSPEC void * SDLCALL Mix_GetMusicHookData(void);
+extern DECLSPEC void * MIXCALL Mix_GetMusicHookData(void);
 
 /*
  * Add your own callback when a channel has finished playing. NULL
@@ -403,7 +401,7 @@ extern DECLSPEC void * SDLCALL Mix_GetMusicHookData(void);
  *  inside the audio callback, or SDL_mixer will explicitly lock the audio
  *  before calling your callback.
  */
-extern DECLSPEC void SDLCALL Mix_ChannelFinished(void (SDLCALL *channel_finished)(int channel));
+extern DECLSPEC void MIXCALL Mix_ChannelFinished(void (SDLCALL *channel_finished)(int channel));
 
 
 /* Special Effects API by ryan c. gordon. (icculus@icculus.org) */
@@ -517,7 +515,7 @@ typedef void (SDLCALL *Mix_MusicEffectDone_t)(Mix_Music *mus, void *udata); /*MI
  * returns zero if error (no such channel), nonzero if added.
  *  Error messages can be retrieved from Mix_GetError().
  */
-extern DECLSPEC int SDLCALL Mix_RegisterEffect(int chan, Mix_EffectFunc_t f, Mix_EffectDone_t d, void *arg);
+extern DECLSPEC int MIXCALL Mix_RegisterEffect(int chan, Mix_EffectFunc_t f, Mix_EffectDone_t d, void *arg);
 
 
 /* You may not need to call this explicitly, unless you need to stop an
@@ -529,7 +527,7 @@ extern DECLSPEC int SDLCALL Mix_RegisterEffect(int chan, Mix_EffectFunc_t f, Mix
  * returns zero if error (no such channel or effect), nonzero if removed.
  *  Error messages can be retrieved from Mix_GetError().
  */
-extern DECLSPEC int SDLCALL Mix_UnregisterEffect(int channel, Mix_EffectFunc_t f);
+extern DECLSPEC int MIXCALL Mix_UnregisterEffect(int channel, Mix_EffectFunc_t f);
 
 
 /* You may not need to call this explicitly, unless you need to stop all
@@ -544,7 +542,7 @@ extern DECLSPEC int SDLCALL Mix_UnregisterEffect(int channel, Mix_EffectFunc_t f
  * returns zero if error (no such channel), nonzero if all effects removed.
  *  Error messages can be retrieved from Mix_GetError().
  */
-extern DECLSPEC int SDLCALL Mix_UnregisterAllEffects(int channel);
+extern DECLSPEC int MIXCALL Mix_UnregisterAllEffects(int channel);
 
 
 /* The function is like the Mix_RegisterEffect(), but works exclusively for music
@@ -557,7 +555,7 @@ extern DECLSPEC int SDLCALL Mix_UnregisterAllEffects(int channel);
  * returns zero if error (no such music), nonzero if added.
  *  Error messages can be retrieved from Mix_GetError().
  */
-extern DECLSPEC int SDLCALL Mix_RegisterMusicEffect(Mix_Music *mus,
+extern DECLSPEC int MIXCALL Mix_RegisterMusicEffect(Mix_Music *mus,
                                                     Mix_MusicEffectFunc_t f,
                                                     Mix_MusicEffectDone_t d,
                                                     void *arg); /*MIXER-X*/
@@ -568,7 +566,7 @@ extern DECLSPEC int SDLCALL Mix_RegisterMusicEffect(Mix_Music *mus,
  * returns zero if error (no such channel or effect), nonzero if removed.
  *  Error messages can be retrieved from Mix_GetError().
  */
-extern DECLSPEC int SDLCALL Mix_UnregisterMusicEffect(Mix_Music *mus,
+extern DECLSPEC int MIXCALL Mix_UnregisterMusicEffect(Mix_Music *mus,
                                                       Mix_MusicEffectFunc_t f); /*MIXER-X*/
 
 /* You may not need to call this explicitly, unless you need to stop all
@@ -580,7 +578,7 @@ extern DECLSPEC int SDLCALL Mix_UnregisterMusicEffect(Mix_Music *mus,
  * returns zero if error (no such channel), nonzero if all effects removed.
  *  Error messages can be retrieved from Mix_GetError().
  */
-extern DECLSPEC int SDLCALL Mix_UnregisterAllMusicEffects(Mix_Music *mus); /*MIXER-X*/
+extern DECLSPEC int MIXCALL Mix_UnregisterAllMusicEffects(Mix_Music *mus); /*MIXER-X*/
 
 
 #define MIX_EFFECTSMAXSPEED  "MIX_EFFECTSMAXSPEED"
@@ -620,7 +618,7 @@ extern DECLSPEC int SDLCALL Mix_UnregisterAllMusicEffects(Mix_Music *mus); /*MIX
  *  mode is a no-op, but this call will return successful in that case.
  *  Error messages can be retrieved from Mix_GetError().
  */
-extern DECLSPEC int SDLCALL Mix_SetPanning(int channel, Uint8 left, Uint8 right);
+extern DECLSPEC int MIXCALL Mix_SetPanning(int channel, Uint8 left, Uint8 right);
 
 
 /* Set the position of a channel. (angle) is an integer from 0 to 360, that
@@ -660,7 +658,7 @@ extern DECLSPEC int SDLCALL Mix_SetPanning(int channel, Uint8 left, Uint8 right)
  *  nonzero if position effect is enabled.
  *  Error messages can be retrieved from Mix_GetError().
  */
-extern DECLSPEC int SDLCALL Mix_SetPosition(int channel, Sint16 angle, Uint8 distance);
+extern DECLSPEC int MIXCALL Mix_SetPosition(int channel, Sint16 angle, Uint8 distance);
 
 
 /* Set the "distance" of a channel. (distance) is an integer from 0 to 255
@@ -690,7 +688,7 @@ extern DECLSPEC int SDLCALL Mix_SetPosition(int channel, Sint16 angle, Uint8 dis
  *  nonzero if position effect is enabled.
  *  Error messages can be retrieved from Mix_GetError().
  */
-extern DECLSPEC int SDLCALL Mix_SetDistance(int channel, Uint8 distance);
+extern DECLSPEC int MIXCALL Mix_SetDistance(int channel, Uint8 distance);
 
 
 /*
@@ -714,7 +712,7 @@ extern DECLSPEC int SDLCALL Mix_SetDistance(int channel, Uint8 distance);
  *  nonzero if reversing effect is enabled.
  *  Error messages can be retrieved from Mix_GetError().
  */
-extern no_parse_DECLSPEC int SDLCALL Mix_SetReverb(int channel, Uint8 echo);
+extern no_parse_DECLSPEC int MIXCALL Mix_SetReverb(int channel, Uint8 echo);
 #endif
 
 /* Causes a channel to reverse its stereo. This is handy if the user has his
@@ -737,7 +735,7 @@ extern no_parse_DECLSPEC int SDLCALL Mix_SetReverb(int channel, Uint8 echo);
  *  mode is a no-op, but this call will return successful in that case.
  *  Error messages can be retrieved from Mix_GetError().
  */
-extern DECLSPEC int SDLCALL Mix_SetReverseStereo(int channel, int flip);
+extern DECLSPEC int MIXCALL Mix_SetReverseStereo(int channel, int flip);
 
 
 /* Set the panning of a music. The left and right channels are specified
@@ -761,7 +759,7 @@ extern DECLSPEC int SDLCALL Mix_SetReverseStereo(int channel, int flip);
  *  mode is a no-op, but this call will return successful in that case.
  *  Error messages can be retrieved from Mix_GetError().
  */
-extern DECLSPEC int SDLCALL Mix_SetMusicEffectPanning(Mix_Music *mus, Uint8 left, Uint8 right); /*MIXER-X*/
+extern DECLSPEC int MIXCALL Mix_SetMusicEffectPanning(Mix_Music *mus, Uint8 left, Uint8 right); /*MIXER-X*/
 
 
 /* Set the position of a music. (angle) is an integer from 0 to 360, that
@@ -798,7 +796,7 @@ extern DECLSPEC int SDLCALL Mix_SetMusicEffectPanning(Mix_Music *mus, Uint8 left
  *  nonzero if position effect is enabled.
  *  Error messages can be retrieved from Mix_GetError().
  */
-extern DECLSPEC int SDLCALL Mix_SetMusicEffectPosition(Mix_Music *mus, Sint16 angle, Uint8 distance); /*MIXER-X*/
+extern DECLSPEC int MIXCALL Mix_SetMusicEffectPosition(Mix_Music *mus, Sint16 angle, Uint8 distance); /*MIXER-X*/
 
 /* Set the "distance" of a music. (distance) is an integer from 0 to 255
  *  that specifies the location of the sound in relation to the listener.
@@ -823,7 +821,7 @@ extern DECLSPEC int SDLCALL Mix_SetMusicEffectPosition(Mix_Music *mus, Sint16 an
  *  nonzero if position effect is enabled.
  *  Error messages can be retrieved from Mix_GetError().
  */
-extern DECLSPEC int SDLCALL Mix_SetMusicEffectDistance(Mix_Music *mus, Uint8 distance); /*MIXER-X*/
+extern DECLSPEC int MIXCALL Mix_SetMusicEffectDistance(Mix_Music *mus, Uint8 distance); /*MIXER-X*/
 
 /* Causes a music to reverse its stereo. This is handy if the user has his
  *  speakers hooked up backwards, or you would like to have a minor bit of
@@ -841,7 +839,7 @@ extern DECLSPEC int SDLCALL Mix_SetMusicEffectDistance(Mix_Music *mus, Uint8 dis
  *  mode is a no-op, but this call will return successful in that case.
  *  Error messages can be retrieved from Mix_GetError().
  */
-extern DECLSPEC int SDLCALL Mix_SetMusicEffectReverseStereo(Mix_Music *mus, int flip); /*MIXER-X*/
+extern DECLSPEC int MIXCALL Mix_SetMusicEffectReverseStereo(Mix_Music *mus, int flip); /*MIXER-X*/
 
 /* end of effects API. --ryan. */
 
@@ -850,7 +848,7 @@ extern DECLSPEC int SDLCALL Mix_SetMusicEffectReverseStereo(Mix_Music *mus, int
    them dynamically to the next sample if requested with a -1 value below.
    Returns the number of reserved channels.
  */
-extern DECLSPEC int SDLCALL Mix_ReserveChannels(int num);
+extern DECLSPEC int MIXCALL Mix_ReserveChannels(int num);
 
 /* Channel grouping functions */
 
@@ -860,21 +858,21 @@ extern DECLSPEC int SDLCALL Mix_ReserveChannels(int num);
    represent the group of all the channels).
    Returns true if everything was OK.
  */
-extern DECLSPEC int SDLCALL Mix_GroupChannel(int which, int tag);
+extern DECLSPEC int MIXCALL Mix_GroupChannel(int which, int tag);
 /* Assign several consecutive channels to a group */
-extern DECLSPEC int SDLCALL Mix_GroupChannels(int from, int to, int tag);
+extern DECLSPEC int MIXCALL Mix_GroupChannels(int from, int to, int tag);
 /* Finds the first available channel in a group of channels,
    returning -1 if none are available.
  */
-extern DECLSPEC int SDLCALL Mix_GroupAvailable(int tag);
+extern DECLSPEC int MIXCALL Mix_GroupAvailable(int tag);
 /* Returns the number of channels in a group. This is also a subtle
    way to get the total number of channels when 'tag' is -1
  */
-extern DECLSPEC int SDLCALL Mix_GroupCount(int tag);
+extern DECLSPEC int MIXCALL Mix_GroupCount(int tag);
 /* Finds the "oldest" sample playing in a group of channels */
-extern DECLSPEC int SDLCALL Mix_GroupOldest(int tag);
+extern DECLSPEC int MIXCALL Mix_GroupOldest(int tag);
 /* Finds the "most recent" (i.e. last) sample playing in a group of channels */
-extern DECLSPEC int SDLCALL Mix_GroupNewer(int tag);
+extern DECLSPEC int MIXCALL Mix_GroupNewer(int tag);
 
 /* Play an audio chunk on a specific channel.
    If the specified channel is -1, play on the first free channel.
@@ -884,15 +882,15 @@ extern DECLSPEC int SDLCALL Mix_GroupNewer(int tag);
 */
 #define Mix_PlayChannel(channel,chunk,loops) Mix_PlayChannelTimed(channel,chunk,loops,-1)
 /* The same as above, but the sound is played at most 'ticks' milliseconds */
-extern DECLSPEC int SDLCALL Mix_PlayChannelTimed(int channel, Mix_Chunk *chunk, int loops, int ticks);
-extern DECLSPEC int SDLCALL Mix_PlayMusic(Mix_Music *music, int loops);
+extern DECLSPEC int MIXCALL Mix_PlayChannelTimed(int channel, Mix_Chunk *chunk, int loops, int ticks);
+extern DECLSPEC int MIXCALL Mix_PlayMusic(Mix_Music *music, int loops);
 #define Mix_PlayChannelVol(channel,chunk,loops,vol) Mix_PlayChannelTimedVolume(channel,chunk,loops,-1,vol)/*MIXER-X*/
-extern DECLSPEC int SDLCALL Mix_PlayChannelTimedVolume(int which, Mix_Chunk *chunk, int loops, int ticks, int volume);/*MIXER-X*/
+extern DECLSPEC int MIXCALL Mix_PlayChannelTimedVolume(int which, Mix_Chunk *chunk, int loops, int ticks, int volume);/*MIXER-X*/
 
 /* returns a pointer to the single-music mixer that can be used as a callback */
-extern DECLSPEC Mix_CommonMixer_t SDLCALL Mix_GetMusicMixer(void);
+extern DECLSPEC Mix_CommonMixer_t MIXCALL Mix_GetMusicMixer(void);
 /* returns a pointer to the multi-music mixer that can be used as a callback */
-extern DECLSPEC Mix_CommonMixer_t SDLCALL Mix_GetMultiMusicMixer(void);
+extern DECLSPEC Mix_CommonMixer_t MIXCALL Mix_GetMultiMusicMixer(void);
 
 /* returns a pointer to the general mixer of music and channels that can be used as a callback
  *
@@ -903,20 +901,20 @@ extern DECLSPEC Mix_CommonMixer_t SDLCALL Mix_GetMultiMusicMixer(void);
  * CAUTION: using this callback, don't use Mix_GeneralMusicMixer() and Mix_GeneralMultiMusicMixeR() at all
  * they both already used in this mixer internally.
  */
-extern DECLSPEC Mix_CommonMixer_t SDLCALL Mix_GetGeneralMixer(void);
+extern DECLSPEC Mix_CommonMixer_t MIXCALL Mix_GetGeneralMixer(void);
 
 /* Fade in music or a channel over "ms" milliseconds, same semantics as the "Play" functions */
-extern DECLSPEC int SDLCALL Mix_FadeInMusic(Mix_Music *music, int loops, int ms);
-extern DECLSPEC int SDLCALL Mix_FadeInMusicPos(Mix_Music *music, int loops, int ms, double position);
+extern DECLSPEC int MIXCALL Mix_FadeInMusic(Mix_Music *music, int loops, int ms);
+extern DECLSPEC int MIXCALL Mix_FadeInMusicPos(Mix_Music *music, int loops, int ms, double position);
 #define Mix_FadeInChannel(channel,chunk,loops,ms) Mix_FadeInChannelTimed(channel,chunk,loops,ms,-1)
-extern DECLSPEC int SDLCALL Mix_FadeInChannelTimed(int channel, Mix_Chunk *chunk, int loops, int ms, int ticks);
+extern DECLSPEC int MIXCALL Mix_FadeInChannelTimed(int channel, Mix_Chunk *chunk, int loops, int ms, int ticks);
 #define Mix_FadeInChannelVolume(channel,chunk,loops,ms,vol) Mix_FadeInChannelTimedVolume(channel,chunk,loops,ms,-1,vol)/*MIXER-X*/
-extern DECLSPEC int SDLCALL Mix_FadeInChannelTimedVolume(int which, Mix_Chunk *chunk, int loops, int ms, int ticks, int volume);/*MIXER-X*/
+extern DECLSPEC int MIXCALL Mix_FadeInChannelTimedVolume(int which, Mix_Chunk *chunk, int loops, int ms, int ticks, int volume);/*MIXER-X*/
 
 /* Multi-Music */
-extern DECLSPEC int SDLCALL Mix_PlayMusicStream(Mix_Music *music, int loops); /*MIXER-X*/
-extern DECLSPEC int SDLCALL Mix_FadeInMusicStream(Mix_Music *music, int loops, int ms); /*MIXER-X*/
-extern DECLSPEC int SDLCALL Mix_FadeInMusicStreamPos(Mix_Music *music, int loops, int ms, double position); /*MIXER-X*/
+extern DECLSPEC int MIXCALL Mix_PlayMusicStream(Mix_Music *music, int loops); /*MIXER-X*/
+extern DECLSPEC int MIXCALL Mix_FadeInMusicStream(Mix_Music *music, int loops, int ms); /*MIXER-X*/
+extern DECLSPEC int MIXCALL Mix_FadeInMusicStreamPos(Mix_Music *music, int loops, int ms, double position); /*MIXER-X*/
 
 
 /* Set the volume in the range of 0-128 of a specific channel or chunk.
@@ -924,110 +922,110 @@ extern DECLSPEC int SDLCALL Mix_FadeInMusicStreamPos(Mix_Music *music, int loops
    Returns the original volume.
    If the specified volume is -1, just return the current volume.
 */
-extern DECLSPEC int SDLCALL Mix_Volume(int channel, int volume);
-extern DECLSPEC int SDLCALL Mix_VolumeChunk(Mix_Chunk *chunk, int volume);
-extern DECLSPEC int SDLCALL Mix_VolumeMusicStream(Mix_Music *music, int volume);
+extern DECLSPEC int MIXCALL Mix_Volume(int channel, int volume);
+extern DECLSPEC int MIXCALL Mix_VolumeChunk(Mix_Chunk *chunk, int volume);
+extern DECLSPEC int MIXCALL Mix_VolumeMusicStream(Mix_Music *music, int volume);
 /* MIXERX_DEPRECATED("Use Mix_VolumeMusicStream(Mix_Music*,int) instead") */
-extern DECLSPEC int SDLCALL Mix_VolumeMusic(int volume);
+extern DECLSPEC int MIXCALL Mix_VolumeMusic(int volume);
 /* Get the current volume value in the range of 0-128 of a music stream */
-extern DECLSPEC int SDLCALL Mix_GetMusicVolume(Mix_Music *music);
-extern DECLSPEC int SDLCALL Mix_GetVolumeMusicStream(Mix_Music *music);
+extern DECLSPEC int MIXCALL Mix_GetMusicVolume(Mix_Music *music);
+extern DECLSPEC int MIXCALL Mix_GetVolumeMusicStream(Mix_Music *music);
 
-extern DECLSPEC void SDLCALL Mix_VolumeMusicGeneral(int volume);
-extern DECLSPEC int SDLCALL Mix_GetVolumeMusicGeneral(void);
+extern DECLSPEC void MIXCALL Mix_VolumeMusicGeneral(int volume);
+extern DECLSPEC int MIXCALL Mix_GetVolumeMusicGeneral(void);
 
 /* Halt playing of a particular channel */
-extern DECLSPEC int SDLCALL Mix_HaltChannel(int channel);
-extern DECLSPEC int SDLCALL Mix_HaltGroup(int tag);
-extern DECLSPEC int SDLCALL Mix_HaltMusicStream(Mix_Music *music);
+extern DECLSPEC int MIXCALL Mix_HaltChannel(int channel);
+extern DECLSPEC int MIXCALL Mix_HaltGroup(int tag);
+extern DECLSPEC int MIXCALL Mix_HaltMusicStream(Mix_Music *music);
 /* MIXERX_DEPRECATED("Use Mix_HaltMusicStream(Mix_Music*) instead") */
-extern DECLSPEC int SDLCALL Mix_HaltMusic(void);
+extern DECLSPEC int MIXCALL Mix_HaltMusic(void);
 
 /* Change the expiration delay for a particular channel.
    The sample will stop playing after the 'ticks' milliseconds have elapsed,
    or remove the expiration if 'ticks' is -1
 */
-extern DECLSPEC int SDLCALL Mix_ExpireChannel(int channel, int ticks);
+extern DECLSPEC int MIXCALL Mix_ExpireChannel(int channel, int ticks);
 
 /* Halt a channel, fading it out progressively till it's silent
    The ms parameter indicates the number of milliseconds the fading
    will take.
  */
-extern DECLSPEC int SDLCALL Mix_FadeOutChannel(int which, int ms);
-extern DECLSPEC int SDLCALL Mix_FadeOutGroup(int tag, int ms);
-extern DECLSPEC int SDLCALL Mix_FadeOutMusicStream(Mix_Music *music, int ms);
+extern DECLSPEC int MIXCALL Mix_FadeOutChannel(int which, int ms);
+extern DECLSPEC int MIXCALL Mix_FadeOutGroup(int tag, int ms);
+extern DECLSPEC int MIXCALL Mix_FadeOutMusicStream(Mix_Music *music, int ms);
 /* MIXERX_DEPRECATED("Use Mix_FadeOutMusicStream(Mix_Music*,int) instead") */
-extern DECLSPEC int SDLCALL Mix_FadeOutMusic(int ms);
+extern DECLSPEC int MIXCALL Mix_FadeOutMusic(int ms);
 
-extern DECLSPEC int SDLCALL Mix_CrossFadeMusicStream(Mix_Music *old_music, Mix_Music *new_music, int loops, int ms, int free_old);
-extern DECLSPEC int SDLCALL Mix_CrossFadeMusicStreamPos(Mix_Music *old_music, Mix_Music *new_music, int loops, int ms, double pos, int free_old);
+extern DECLSPEC int MIXCALL Mix_CrossFadeMusicStream(Mix_Music *old_music, Mix_Music *new_music, int loops, int ms, int free_old);
+extern DECLSPEC int MIXCALL Mix_CrossFadeMusicStreamPos(Mix_Music *old_music, Mix_Music *new_music, int loops, int ms, double pos, int free_old);
 
 /* Query the fading status of a channel */
-extern DECLSPEC Mix_Fading SDLCALL Mix_FadingMusicStream(Mix_Music *music);
+extern DECLSPEC Mix_Fading MIXCALL Mix_FadingMusicStream(Mix_Music *music);
 /* MIXERX_DEPRECATED("Use Mix_FadingMusicStream(Mix_Music*) instead") */
-extern DECLSPEC Mix_Fading SDLCALL Mix_FadingMusic(void);
-extern DECLSPEC Mix_Fading SDLCALL Mix_FadingChannel(int which);
+extern DECLSPEC Mix_Fading MIXCALL Mix_FadingMusic(void);
+extern DECLSPEC Mix_Fading MIXCALL Mix_FadingChannel(int which);
 
 /* Pause/Resume a particular channel */
-extern DECLSPEC void SDLCALL Mix_Pause(int channel);
-extern DECLSPEC void SDLCALL Mix_Resume(int channel);
-extern DECLSPEC int SDLCALL Mix_Paused(int channel);
+extern DECLSPEC void MIXCALL Mix_Pause(int channel);
+extern DECLSPEC void MIXCALL Mix_Resume(int channel);
+extern DECLSPEC int MIXCALL Mix_Paused(int channel);
 
 /* Pause/Resume the music stream */
-extern DECLSPEC void SDLCALL Mix_PauseMusicStream(Mix_Music *music);
-extern DECLSPEC void SDLCALL Mix_ResumeMusicStream(Mix_Music *music);
-extern DECLSPEC void SDLCALL Mix_RewindMusicStream(Mix_Music *music);
-extern DECLSPEC int SDLCALL Mix_PausedMusicStream(Mix_Music *music);
-extern DECLSPEC void SDLCALL Mix_PauseMusicStreamAll(void);
-extern DECLSPEC void SDLCALL Mix_ResumeMusicStreamAll(void);
+extern DECLSPEC void MIXCALL Mix_PauseMusicStream(Mix_Music *music);
+extern DECLSPEC void MIXCALL Mix_ResumeMusicStream(Mix_Music *music);
+extern DECLSPEC void MIXCALL Mix_RewindMusicStream(Mix_Music *music);
+extern DECLSPEC int MIXCALL Mix_PausedMusicStream(Mix_Music *music);
+extern DECLSPEC void MIXCALL Mix_PauseMusicStreamAll(void);
+extern DECLSPEC void MIXCALL Mix_ResumeMusicStreamAll(void);
 
 /* Pause/Resume the music stream (Deprecated calls) */
 /* MIXERX_DEPRECATED("Use Mix_PauseMusicStream(Mix_Music*) instead") */
-extern DECLSPEC void SDLCALL Mix_PauseMusic(void);
+extern DECLSPEC void MIXCALL Mix_PauseMusic(void);
 /* MIXERX_DEPRECATED("Use Mix_ResumeMusicStream(Mix_Music*) instead") */
-extern DECLSPEC void SDLCALL Mix_ResumeMusic(void);
+extern DECLSPEC void MIXCALL Mix_ResumeMusic(void);
 /* MIXERX_DEPRECATED("Use Mix_RewindMusicStream(Mix_Music*) instead") */
-extern DECLSPEC void SDLCALL Mix_RewindMusic(void);
+extern DECLSPEC void MIXCALL Mix_RewindMusic(void);
 /* MIXERX_DEPRECATED("Use Mix_PausedMusicStream(Mix_Music*) instead") */
-extern DECLSPEC int SDLCALL Mix_PausedMusic(void);
+extern DECLSPEC int MIXCALL Mix_PausedMusic(void);
 
 /* Jump to a given order in mod music.
    Returns 0 if successful, or -1 if failed or isn't implemented.
    Only for MOD music formats.
  */
-extern DECLSPEC int SDLCALL Mix_ModMusicJumpToOrder(int order);
-extern DECLSPEC int SDLCALL Mix_ModMusicStreamJumpToOrder(Mix_Music *music, int order);
+extern DECLSPEC int MIXCALL Mix_ModMusicJumpToOrder(int order);
+extern DECLSPEC int MIXCALL Mix_ModMusicStreamJumpToOrder(Mix_Music *music, int order);
 /* Set the current position in the music stream.
    This returns 0 if successful, or -1 if it failed or isn't implemented.
    This function is only implemented for MOD music formats (set pattern
    order number) and for WAV, OGG, FLAC, MP3_MAD, MP3_MPG, and MODPLUG music
    (set position in seconds), at the moment.
 */
-extern DECLSPEC int SDLCALL Mix_SetMusicPositionStream(Mix_Music *music, double position);
+extern DECLSPEC int MIXCALL Mix_SetMusicPositionStream(Mix_Music *music, double position);
 
 MIXERX_DEPRECATED("Use Mix_SetMusicPositionStream(Mix_Music*, double) instead")
-extern DECLSPEC int SDLCALL Mix_SetMusicStreamPosition(Mix_Music *music, double position);
+extern DECLSPEC int MIXCALL Mix_SetMusicStreamPosition(Mix_Music *music, double position);
 /*
     Deprecated analogue of Mix_SetMusicStreamPosition() which lacks Mix_Music* argument
 */
 /* MIXERX_DEPRECATED("Use Mix_SetMusicStreamPosition(Mix_Music*, double) instead") */
-extern DECLSPEC int SDLCALL Mix_SetMusicPosition(double position);
+extern DECLSPEC int MIXCALL Mix_SetMusicPosition(double position);
 /*
     Get the time current position of music stream
     returns -1.0 if this feature is not supported for some codec
  */
-extern DECLSPEC double SDLCALL Mix_GetMusicPosition(Mix_Music *music);
+extern DECLSPEC double MIXCALL Mix_GetMusicPosition(Mix_Music *music);
 
 /* Return music duration in seconds.
    If NULL is passed, returns duration of current playing music.
    Returns -1 on error.
  */
-extern DECLSPEC double SDLCALL Mix_MusicDuration(Mix_Music *music);
+extern DECLSPEC double MIXCALL Mix_MusicDuration(Mix_Music *music);
 /*
     Same as Mix_MusicDuration()
  */
 /* MIXERX_DEPRECATED("Use Mix_MusicDuration(Mix_Music*) instead") */
-extern DECLSPEC double SDLCALL Mix_GetMusicTotalTime(Mix_Music *music);
+extern DECLSPEC double MIXCALL Mix_GetMusicTotalTime(Mix_Music *music);
 
 /*
     Set the current tempo multiplier in the music stream.
@@ -1035,196 +1033,196 @@ extern DECLSPEC double SDLCALL Mix_GetMusicTotalTime(Mix_Music *music);
     This function is only implemented for ADLMIDI, OPNMIDI MIDI synthesizers,
     GME chiptune formats, and for XMP library
  */
-extern DECLSPEC int SDLCALL Mix_SetMusicTempo(Mix_Music *music, double tempo);
+extern DECLSPEC int MIXCALL Mix_SetMusicTempo(Mix_Music *music, double tempo);
 
 /*
     Get the current tempo multiplier of the music stream
  */
-extern DECLSPEC double SDLCALL Mix_GetMusicTempo(Mix_Music *music);
+extern DECLSPEC double MIXCALL Mix_GetMusicTempo(Mix_Music *music);
 
 /*
     Get the count of concurrently playing tracks at the song (MIDI, Tracker,.etc.)
  */
-extern DECLSPEC int SDLCALL Mix_GetMusicTracks(Mix_Music *music);
+extern DECLSPEC int MIXCALL Mix_GetMusicTracks(Mix_Music *music);
 
 /*
     Mute one of playing tracks at the song
  */
-extern DECLSPEC int SDLCALL Mix_SetMusicTrackMute(Mix_Music *music, int track, int mute);
+extern DECLSPEC int MIXCALL Mix_SetMusicTrackMute(Mix_Music *music, int track, int mute);
 
 /*
     Get the loop start time position of music stream
     returns -1.0 if this feature is not used for this music or not supported for some codec
  */
-extern DECLSPEC double SDLCALL Mix_GetMusicLoopStartTime(Mix_Music *music);
+extern DECLSPEC double MIXCALL Mix_GetMusicLoopStartTime(Mix_Music *music);
 /*
     Get the loop end time position of music stream
     returns -1.0 if this feature is not used for this music or not supported for some codec
  */
-extern DECLSPEC double SDLCALL Mix_GetMusicLoopEndTime(Mix_Music *music);
+extern DECLSPEC double MIXCALL Mix_GetMusicLoopEndTime(Mix_Music *music);
 /*
     Get the loop time length of music stream
     returns -1.0 if this feature is not used for this music or not supported for some codec
  */
-extern DECLSPEC double SDLCALL Mix_GetMusicLoopLengthTime(Mix_Music *music);
+extern DECLSPEC double MIXCALL Mix_GetMusicLoopLengthTime(Mix_Music *music);
 
 
 /* Check the status of a specific channel.
    If the specified channel is -1, check all channels.
 */
-extern DECLSPEC int SDLCALL Mix_Playing(int channel);
-extern DECLSPEC int SDLCALL Mix_PlayingMusicStream(Mix_Music *music);
+extern DECLSPEC int MIXCALL Mix_Playing(int channel);
+extern DECLSPEC int MIXCALL Mix_PlayingMusicStream(Mix_Music *music);
 /* MIXERX_DEPRECATED("Use Mix_PlayingMusicStream(Mix_Music*) instead") */
-extern DECLSPEC int SDLCALL Mix_PlayingMusic(void);
+extern DECLSPEC int MIXCALL Mix_PlayingMusic(void);
 
 /* Stop music and set external music playback command */
-extern DECLSPEC int SDLCALL Mix_SetMusicCMD(const char *command);
+extern DECLSPEC int MIXCALL Mix_SetMusicCMD(const char *command);
 
 /* Synchro value is set by MikMod from modules while playing */
-extern DECLSPEC int SDLCALL Mix_SetSynchroValue(int value);
-extern DECLSPEC int SDLCALL Mix_GetSynchroValue(void);
+extern DECLSPEC int MIXCALL Mix_SetSynchroValue(int value);
+extern DECLSPEC int MIXCALL Mix_GetSynchroValue(void);
 
 /* Set/Get/Iterate SoundFonts paths to use by supported MIDI backends */
-extern DECLSPEC int SDLCALL Mix_SetSoundFonts(const char *paths);
-extern DECLSPEC const char* SDLCALL Mix_GetSoundFonts(void);
-extern DECLSPEC int SDLCALL Mix_EachSoundFont(int (SDLCALL *function)(const char*, void*), void *data);
-extern DECLSPEC int SDLCALL Mix_EachSoundFontEx(const char* cpaths, int (SDLCALL *function)(const char*, void*), void *data);
+extern DECLSPEC int MIXCALL Mix_SetSoundFonts(const char *paths);
+extern DECLSPEC const char* MIXCALL Mix_GetSoundFonts(void);
+extern DECLSPEC int MIXCALL Mix_EachSoundFont(int (SDLCALL *function)(const char*, void*), void *data);
+extern DECLSPEC int MIXCALL Mix_EachSoundFontEx(const char* cpaths, int (SDLCALL *function)(const char*, void*), void *data);
 
 /* Set/Get full path of Timidity config file (e.g. /etc/timidity.cfg) */
-extern DECLSPEC int SDLCALL Mix_SetTimidityCfg(const char *path);
-extern DECLSPEC const char* SDLCALL Mix_GetTimidityCfg(void);
+extern DECLSPEC int MIXCALL Mix_SetTimidityCfg(const char *path);
+extern DECLSPEC const char* MIXCALL Mix_GetTimidityCfg(void);
 
 /* Get the Mix_Chunk currently associated with a mixer channel
     Returns NULL if it's an invalid channel, or there's no chunk associated.
 */
-extern DECLSPEC Mix_Chunk * SDLCALL Mix_GetChunk(int channel);
+extern DECLSPEC Mix_Chunk * MIXCALL Mix_GetChunk(int channel);
 
 /* Setup the mixer without taking over the callback, using an existing spec.
    These Only initialize or free the Mixer internals */
-extern DECLSPEC int SDLCALL Mix_InitMixer(const SDL_AudioSpec *spec, SDL_bool skip_init_check);
-extern DECLSPEC void SDLCALL Mix_FreeMixer(void);
+extern DECLSPEC int MIXCALL Mix_InitMixer(const SDL_AudioSpec *spec, SDL_bool skip_init_check);
+extern DECLSPEC void MIXCALL Mix_FreeMixer(void);
 
 /* Close the mixer, halting all playing audio */
-extern DECLSPEC void SDLCALL Mix_CloseAudio(void);
+extern DECLSPEC void MIXCALL Mix_CloseAudio(void);
 
 /* ADLMIDI Setup functions */
 /* Get count of available hardcoded banks */
-extern DECLSPEC int    SDLCALL Mix_ADLMIDI_getTotalBanks(void);
+extern DECLSPEC int    MIXCALL Mix_ADLMIDI_getTotalBanks(void);
 /* Get array of the bank names */
-extern DECLSPEC const char *const *SDLCALL Mix_ADLMIDI_getBankNames(void);
+extern DECLSPEC const char *const *MIXCALL Mix_ADLMIDI_getBankNames(void);
 /* Get bank ID */
-extern DECLSPEC int  SDLCALL Mix_ADLMIDI_getBankID(void);
+extern DECLSPEC int  MIXCALL Mix_ADLMIDI_getBankID(void);
 /* Set bank ID (Applying on stop/play) */
-extern DECLSPEC void SDLCALL Mix_ADLMIDI_setBankID(int bnk);
+extern DECLSPEC void MIXCALL Mix_ADLMIDI_setBankID(int bnk);
 /* Get state of deep vibrato */
-extern DECLSPEC int  SDLCALL Mix_ADLMIDI_getTremolo(void);
+extern DECLSPEC int  MIXCALL Mix_ADLMIDI_getTremolo(void);
 /* Set deep tremolo mode (0 off, 1 on) (Applying on stop/play) */
-extern DECLSPEC void SDLCALL Mix_ADLMIDI_setTremolo(int tr);
+extern DECLSPEC void MIXCALL Mix_ADLMIDI_setTremolo(int tr);
 /* Get state of deep vibrato */
-extern DECLSPEC int  SDLCALL Mix_ADLMIDI_getVibrato(void);
+extern DECLSPEC int  MIXCALL Mix_ADLMIDI_getVibrato(void);
 /* Set deep vibrato mode (0 off, 1 on) (Applying on stop/play) */
-extern DECLSPEC void SDLCALL Mix_ADLMIDI_setVibrato(int vib);
+extern DECLSPEC void MIXCALL Mix_ADLMIDI_setVibrato(int vib);
 /* Get state of scalable modulation mode */
-extern DECLSPEC int  SDLCALL Mix_ADLMIDI_getScaleMod(void);
+extern DECLSPEC int  MIXCALL Mix_ADLMIDI_getScaleMod(void);
 /* Set scalable modulation mode (0 off, 1 on) (Applying on stop/play) */
-extern DECLSPEC void SDLCALL Mix_ADLMIDI_setScaleMod(int sc);
+extern DECLSPEC void MIXCALL Mix_ADLMIDI_setScaleMod(int sc);
 /* Get state of adlib drums mode */
 MIXERX_DEPRECATED("This function is no more useful, rhythm-mode is now fully automated")
-extern DECLSPEC int  SDLCALL Mix_ADLMIDI_getAdLibMode(void);
+extern DECLSPEC int  MIXCALL Mix_ADLMIDI_getAdLibMode(void);
 /* Set adlib drums mode mode (0 off, 1 on) (Applying on stop/play) */
 MIXERX_DEPRECATED("This function is no more useful, rhythm-mode is now fully automated")
-extern DECLSPEC void SDLCALL Mix_ADLMIDI_setAdLibMode(int tr);
+extern DECLSPEC void MIXCALL Mix_ADLMIDI_setAdLibMode(int tr);
 /* Get state of logarithmic mode */
 MIXERX_DEPRECATED("This function is no longer has effect. Please use the Mix_ADLMIDI_getVolumeModel()")
-extern DECLSPEC int  SDLCALL Mix_ADLMIDI_getLogarithmicVolumes(void);
+extern DECLSPEC int  MIXCALL Mix_ADLMIDI_getLogarithmicVolumes(void);
 /* Set logarithmic volumes mode in the generic/CMF volume models (0 off, 1 on) (Applying on stop/play) */
 MIXERX_DEPRECATED("This function is no longer has effect. Please use the Mix_ADLMIDI_setVolumeModel()")
-extern DECLSPEC void SDLCALL Mix_ADLMIDI_setLogarithmicVolumes(int lv);
+extern DECLSPEC void MIXCALL Mix_ADLMIDI_setLogarithmicVolumes(int lv);
 /* Get current volume model ID */
-extern DECLSPEC int  SDLCALL Mix_ADLMIDI_getVolumeModel(void);
+extern DECLSPEC int  MIXCALL Mix_ADLMIDI_getVolumeModel(void);
 /* Change current volumes model (Applying on stop/play) */
-extern DECLSPEC void SDLCALL Mix_ADLMIDI_setVolumeModel(int vm);
+extern DECLSPEC void MIXCALL Mix_ADLMIDI_setVolumeModel(int vm);
 /* Get full range mode for CC74-Brightness controller */
-extern DECLSPEC int  SDLCALL Mix_ADLMIDI_getFullRangeBrightness(void);
+extern DECLSPEC int  MIXCALL Mix_ADLMIDI_getFullRangeBrightness(void);
 /* Set full range mode for CC74-Brightness controller */
-extern DECLSPEC void SDLCALL Mix_ADLMIDI_setFullRangeBrightness(int frb);
+extern DECLSPEC void MIXCALL Mix_ADLMIDI_setFullRangeBrightness(int frb);
 /* Get the automatic arpeggio enabled or disabled setting */
-extern DECLSPEC int  SDLCALL Mix_ADLMIDI_getAutoArpeggio();
+extern DECLSPEC int  MIXCALL Mix_ADLMIDI_getAutoArpeggio();
 /* Set the automatic arpeggio enabled or disabled */
-extern DECLSPEC void SDLCALL Mix_ADLMIDI_setAutoArpeggio(int aa_en);
+extern DECLSPEC void MIXCALL Mix_ADLMIDI_setAutoArpeggio(int aa_en);
 /* Get full panning stereo mode */
-extern DECLSPEC int  SDLCALL Mix_ADLMIDI_getFullPanStereo(void);
+extern DECLSPEC int  MIXCALL Mix_ADLMIDI_getFullPanStereo(void);
 /* Set full panning stereo mode */
-extern DECLSPEC void SDLCALL Mix_ADLMIDI_setFullPanStereo(int fp);
+extern DECLSPEC void MIXCALL Mix_ADLMIDI_setFullPanStereo(int fp);
 /* Get the current OPL3 Emulator for ADLMIDI */
-extern DECLSPEC int  SDLCALL Mix_ADLMIDI_getEmulator(void);
+extern DECLSPEC int  MIXCALL Mix_ADLMIDI_getEmulator(void);
 /* Select the OPL3 Emulator for ADLMIDI */
-extern DECLSPEC void SDLCALL Mix_ADLMIDI_setEmulator(int emu);
+extern DECLSPEC void MIXCALL Mix_ADLMIDI_setEmulator(int emu);
 /* Get the setup of count of virtual chips */
-extern DECLSPEC int  SDLCALL Mix_ADLMIDI_getChipsCount(void);
+extern DECLSPEC int  MIXCALL Mix_ADLMIDI_getChipsCount(void);
 /* Set count of virtual chips (integer between 1 and 100, or -1 to restore default setup) */
-extern DECLSPEC void SDLCALL Mix_ADLMIDI_setChipsCount(int chips);
+extern DECLSPEC void MIXCALL Mix_ADLMIDI_setChipsCount(int chips);
 /* Reset all ADLMIDI properties to default state */
-extern DECLSPEC void SDLCALL Mix_ADLMIDI_setSetDefaults(void);
+extern DECLSPEC void MIXCALL Mix_ADLMIDI_setSetDefaults(void);
 
 /* Sets WOPL bank file for ADLMIDI playing device, affects on MIDI file reopen */
-extern DECLSPEC void SDLCALL Mix_ADLMIDI_setCustomBankFile(const char *bank_wonl_path);
+extern DECLSPEC void MIXCALL Mix_ADLMIDI_setCustomBankFile(const char *bank_wonl_path);
 
 /* Reset all OPNMIDI properties to default state */
-extern DECLSPEC void SDLCALL Mix_OPNMIDI_setSetDefaults(void);
+extern DECLSPEC void MIXCALL Mix_OPNMIDI_setSetDefaults(void);
 /* Get current volume model ID */
-extern DECLSPEC int  SDLCALL Mix_OPNMIDI_getVolumeModel(void);
+extern DECLSPEC int  MIXCALL Mix_OPNMIDI_getVolumeModel(void);
 /* Change current volumes model (Applying on stop/play) */
-extern DECLSPEC void SDLCALL Mix_OPNMIDI_setVolumeModel(int vm);
+extern DECLSPEC void MIXCALL Mix_OPNMIDI_setVolumeModel(int vm);
 /* Get full range mode for CC74-Brightness controller */
-extern DECLSPEC int  SDLCALL Mix_OPNMIDI_getFullRangeBrightness(void);
+extern DECLSPEC int  MIXCALL Mix_OPNMIDI_getFullRangeBrightness(void);
 /* Set full range mode for CC74-Brightness controller */
-extern DECLSPEC void SDLCALL Mix_OPNMIDI_setFullRangeBrightness(int frb);
+extern DECLSPEC void MIXCALL Mix_OPNMIDI_setFullRangeBrightness(int frb);
 /* Get the automatic arpeggio enabled or disabled setting */
-extern DECLSPEC int  SDLCALL Mix_OPNMIDI_getAutoArpeggio();
+extern DECLSPEC int  MIXCALL Mix_OPNMIDI_getAutoArpeggio();
 /* Set the automatic arpeggio enabled or disabled */
-extern DECLSPEC void SDLCALL Mix_OPNMIDI_setAutoArpeggio(int aa_en);
+extern DECLSPEC void MIXCALL Mix_OPNMIDI_setAutoArpeggio(int aa_en);
 /* Get full panning stereo mode */
-extern DECLSPEC int  SDLCALL Mix_OPNMIDI_getFullPanStereo(void);
+extern DECLSPEC int  MIXCALL Mix_OPNMIDI_getFullPanStereo(void);
 /* Set full panning stereo mode */
-extern DECLSPEC void SDLCALL Mix_OPNMIDI_setFullPanStereo(int fp);
+extern DECLSPEC void MIXCALL Mix_OPNMIDI_setFullPanStereo(int fp);
 /* Get the OPN2 Emulator for OPNMIDI */
-extern DECLSPEC int  SDLCALL Mix_OPNMIDI_getEmulator(void);
+extern DECLSPEC int  MIXCALL Mix_OPNMIDI_getEmulator(void);
 /* Select the OPN2 Emulator for OPNMIDI */
-extern DECLSPEC void SDLCALL Mix_OPNMIDI_setEmulator(int emu);
+extern DECLSPEC void MIXCALL Mix_OPNMIDI_setEmulator(int emu);
 /* Get the setup of count of virtual chips */
-extern DECLSPEC int  SDLCALL Mix_OPNMIDI_getChipsCount(void);
+extern DECLSPEC int  MIXCALL Mix_OPNMIDI_getChipsCount(void);
 /* Set count of virtual chips (integer between 1 and 100, or -1 to restore default setup) */
-extern DECLSPEC void SDLCALL Mix_OPNMIDI_setChipsCount(int chips);
+extern DECLSPEC void MIXCALL Mix_OPNMIDI_setChipsCount(int chips);
 /* Sets WOPN bank file for OPNMIDI playing device, affects on MIDI file reopen */
-extern DECLSPEC void SDLCALL Mix_OPNMIDI_setCustomBankFile(const char *bank_wonp_path);
+extern DECLSPEC void MIXCALL Mix_OPNMIDI_setCustomBankFile(const char *bank_wonp_path);
 
 /* Get type of MIDI player library currently in use */
-extern DECLSPEC int  SDLCALL Mix_GetMidiPlayer(void);
+extern DECLSPEC int  MIXCALL Mix_GetMidiPlayer(void);
 
 /* Get type of MIDI player library prepared for next opening of MIDI file */
-extern DECLSPEC int  SDLCALL Mix_GetNextMidiPlayer(void);
+extern DECLSPEC int  MIXCALL Mix_GetNextMidiPlayer(void);
 
 /* Set the MIDI playing library (ADLMIDI, Timidity, Native MIDI (if available) and FluidSynth) */
-extern DECLSPEC int  SDLCALL Mix_SetMidiPlayer(int player);
+extern DECLSPEC int  MIXCALL Mix_SetMidiPlayer(int player);
 
 /* Disables support of MIDI file arguments */
-extern DECLSPEC void SDLCALL Mix_SetLockMIDIArgs(int lock_midiargs);
+extern DECLSPEC void MIXCALL Mix_SetLockMIDIArgs(int lock_midiargs);
 
 
 /*  DEPRECATED FUNCTIONS */
 
 MIXERX_DEPRECATED("Use Mix_SetTimidityCfg(path) instead")
-extern DECLSPEC void SDLCALL Mix_Timidity_addToPathList(const char *path);
+extern DECLSPEC void MIXCALL Mix_Timidity_addToPathList(const char *path);
 
 MIXERX_DEPRECATED("Use Mix_GetMidiPlayer() instead")
-extern DECLSPEC int  SDLCALL Mix_GetMidiDevice(void);
+extern DECLSPEC int  MIXCALL Mix_GetMidiDevice(void);
 
 MIXERX_DEPRECATED("Use Mix_GetNextMidiPlayer() instead")
-extern DECLSPEC int  SDLCALL Mix_GetNextMidiDevice(void);
+extern DECLSPEC int  MIXCALL Mix_GetNextMidiDevice(void);
 
 MIXERX_DEPRECATED("Use Mix_SetMidiPlayer() instead")
-extern DECLSPEC int  SDLCALL Mix_SetMidiDevice(int player);
+extern DECLSPEC int  MIXCALL Mix_SetMidiDevice(int player);
 
 /*  DEPRECATED FUNCTIONS, END */
 
diff --git a/src/effect_position.c b/src/effect_position.c
index 00c50559..cec1800e 100644
--- a/src/effect_position.c
+++ b/src/effect_position.c
@@ -2186,9 +2186,9 @@ static void set_amplitudes(Uint8 *speaker_amplitude, int channels, int angle, in
     speaker_amplitude[5] = 255;
 }
 
-DECLSPEC int SDLCALL Mix_SetPosition(int channel, Sint16 angle, Uint8 distance);
+DECLSPEC int MIXCALL Mix_SetPosition(int channel, Sint16 angle, Uint8 distance);
 
-int SDLCALLCC Mix_SetPanning(int channel, Uint8 left, Uint8 right)
+int MIXCALLCC Mix_SetPanning(int channel, Uint8 left, Uint8 right)
 {
     Mix_EffectFunc_t f = NULL;
     int channels;
@@ -2253,7 +2253,7 @@ int SDLCALLCC Mix_SetPanning(int channel, Uint8 left, Uint8 right)
 }
 
 
-int SDLCALLCC Mix_SetDistance(int channel, Uint8 distance)
+int MIXCALLCC Mix_SetDistance(int channel, Uint8 distance)
 {
     Mix_EffectFunc_t f = NULL;
     Uint16 format;
@@ -2299,7 +2299,7 @@ int SDLCALLCC Mix_SetDistance(int channel, Uint8 distance)
 }
 
 
-int SDLCALLCC Mix_SetPosition(int channel, Sint16 angle, Uint8 distance)
+int MIXCALLCC Mix_SetPosition(int channel, Sint16 angle, Uint8 distance)
 {
     Uint8 speaker_amplitude[6];
     Mix_EffectFunc_t f = NULL;
@@ -2387,9 +2387,9 @@ int SDLCALLCC Mix_SetPosition(int channel, Sint16 angle, Uint8 distance)
 
 
 
-DECLSPEC int SDLCALL Mix_SetMusicEffectPosition(Mix_Music *mus, Sint16 angle, Uint8 distance);
+DECLSPEC int MIXCALL Mix_SetMusicEffectPosition(Mix_Music *mus, Sint16 angle, Uint8 distance);
 
-int SDLCALLCC Mix_SetMusicEffectPanning(Mix_Music *mus, Uint8 left, Uint8 right)
+int MIXCALLCC Mix_SetMusicEffectPanning(Mix_Music *mus, Uint8 left, Uint8 right)
 {
     Mix_MusicEffectFunc_t f = NULL;
     int channels;
@@ -2453,7 +2453,7 @@ int SDLCALLCC Mix_SetMusicEffectPanning(Mix_Music *mus, Uint8 left, Uint8 right)
     return(retval);
 }
 
-int SDLCALLCC Mix_SetMusicEffectDistance(Mix_Music *mus, Uint8 distance)
+int MIXCALLCC Mix_SetMusicEffectDistance(Mix_Music *mus, Uint8 distance)
 {
     Mix_MusicEffectFunc_t f = NULL;
     Uint16 format;
@@ -2498,7 +2498,7 @@ int SDLCALLCC Mix_SetMusicEffectDistance(Mix_Music *mus, Uint8 distance)
     return(retval);
 }
 
-int SDLCALLCC Mix_SetMusicEffectPosition(Mix_Music *mus, Sint16 angle, Uint8 distance)
+int MIXCALLCC Mix_SetMusicEffectPosition(Mix_Music *mus, Sint16 angle, Uint8 distance)
 {
     Mix_MusicEffectFunc_t f = NULL;
     Uint16 format;
diff --git a/src/effect_stereoreverse.c b/src/effect_stereoreverse.c
index b45a15d7..65b974cf 100644
--- a/src/effect_stereoreverse.c
+++ b/src/effect_stereoreverse.c
@@ -101,7 +101,7 @@ static void SDLCALL _Eff_reversestereo8(int chan, void *stream, int len, void *u
     }
 }
 
-int SDLCALLCC Mix_SetReverseStereo(int channel, int flip)
+int MIXCALLCC Mix_SetReverseStereo(int channel, int flip)
 {
     Mix_EffectFunc_t f = NULL;
     int channels;
@@ -148,7 +148,7 @@ MUS_FUNCTION(_Eff_reversestereo32)
 #undef MUS_FUNCTION
 
 
-int SDLCALLCC Mix_SetMusicEffectReverseStereo(Mix_Music *mus, int flip)
+int MIXCALLCC Mix_SetMusicEffectReverseStereo(Mix_Music *mus, int flip)
 {
     Mix_MusicEffectFunc_t f = NULL;
     int channels;
diff --git a/src/mixer.c b/src/mixer.c
index c37d2ef0..3ffb1502 100644
--- a/src/mixer.c
+++ b/src/mixer.c
@@ -89,12 +89,12 @@ static const char **chunk_decoders = NULL;
 static int num_decoders = 0;
 
 
-int SDLCALLCC Mix_GetNumChunkDecoders(void)
+int MIXCALLCC Mix_GetNumChunkDecoders(void)
 {
     return(num_decoders);
 }
 
-const char * SDLCALLCC Mix_GetChunkDecoder(int index)
+const char * MIXCALLCC Mix_GetChunkDecoder(int index)
 {
     if ((index < 0) || (index >= num_decoders)) {
         return NULL;
@@ -102,7 +102,7 @@ const char * SDLCALLCC Mix_GetChunkDecoder(int index)
     return(chunk_decoders[index]);
 }
 
-SDL_bool SDLCALLCC Mix_HasChunkDecoder(const char *name)
+SDL_bool MIXCALLCC Mix_HasChunkDecoder(const char *name)
 {
     int index;
     for (index = 0; index < num_decoders; ++index) {
@@ -134,14 +134,14 @@ void add_chunk_decoder(const char *decoder)
 }
 
 /* rcg06192001 get linked library's version. */
-const SDL_version * SDLCALLCC Mix_Linked_Version(void)
+const SDL_version * MIXCALLCC Mix_Linked_Version(void)
 {
     static SDL_version linked_version;
     SDL_MIXER_VERSION(&linked_version);
     return(&linked_version);
 }
 
-int SDLCALLCC Mix_Init(int flags)
+int MIXCALLCC Mix_Init(int flags)
 {
     int result = 0;
 
@@ -407,7 +407,7 @@ is_already_initialized(const SDL_AudioSpec *spec)
    Allows the calling to use their spec and audio callback.
    The caller must manage AudioOpen and CloseAudio externally.
 */
-int SDLCALLCC Mix_InitMixer(const SDL_AudioSpec *spec, SDL_bool skip_init_check)
+int MIXCALLCC Mix_InitMixer(const SDL_AudioSpec *spec, SDL_bool skip_init_check)
 {
     int i;
 
@@ -459,7 +459,7 @@ int SDLCALLCC Mix_InitMixer(const SDL_AudioSpec *spec, SDL_bool skip_init_check)
 }
 
 /* Open the mixer with a certain desired audio format and initialize internals */
-int SDLCALLCC Mix_OpenAudioDevice(int frequency, Uint16 format, int nchannels, int chunksize,
+int MIXCALLCC Mix_OpenAudioDevice(int frequency, Uint16 format, int nchannels, int chunksize,
                         const char* device, int allowed_changes)
 {
     SDL_AudioSpec desired;
@@ -497,7 +497,7 @@ int SDLCALLCC Mix_OpenAudioDevice(int frequency, Uint16 format, int nchannels, i
 }
 
 /* Open the mixer with a certain desired audio format */
-int SDLCALLCC Mix_OpenAudio(int frequency, Uint16 format, int nchannels, int chunksize)
+int MIXCALLCC Mix_OpenAudio(int frequency, Uint16 format, int nchannels, int chunksize)
 {
     return Mix_OpenAudioDevice(frequency, format, nchannels, chunksize, NULL,
                                 SDL_AUDIO_ALLOW_FREQUENCY_CHANGE |
@@ -505,7 +505,7 @@ int SDLCALLCC Mix_OpenAudio(int frequency, Uint16 format, int nchannels, int chu
 }
 
 /* Pause or resume the audio streaming */
-void SDLCALLCC Mix_PauseAudio(int pause_on)
+void MIXCALLCC Mix_PauseAudio(int pause_on)
 {
     SDL_PauseAudioDevice(audio_device, pause_on);
     Mix_LockAudio();
@@ -518,7 +518,7 @@ void SDLCALLCC Mix_PauseAudio(int pause_on)
    If decreasing the number of channels, the upper channels are
    stopped.
  */
-int SDLCALLCC Mix_AllocateChannels(int numchans)
+int MIXCALLCC Mix_AllocateChannels(int numchans)
 {
     if (numchans<0 || numchans==num_channels)
         return(num_channels);
@@ -556,7 +556,7 @@ int SDLCALLCC Mix_AllocateChannels(int numchans)
 }
 
 /* Return the actual mixer parameters */
-int SDLCALLCC Mix_QuerySpec(int *frequency, Uint16 *format, int *channels)
+int MIXCALLCC Mix_QuerySpec(int *frequency, Uint16 *format, int *channels)
 {
     if (audio_opened) {
         if (frequency) {
@@ -723,7 +723,7 @@ static SDL_AudioSpec *Mix_LoadMusic_RW(SDL_RWops *src, int freesrc, SDL_AudioSpe
 }
 
 /* Load a wave file */
-Mix_Chunk * SDLCALLCC Mix_LoadWAV_RW(SDL_RWops *src, int freesrc)
+Mix_Chunk * MIXCALLCC Mix_LoadWAV_RW(SDL_RWops *src, int freesrc)
 {
     Uint8 magic[4];
     Mix_Chunk *chunk;
@@ -829,7 +829,7 @@ Mix_Chunk * SDLCALLCC Mix_LoadWAV_RW(SDL_RWops *src, int freesrc)
 }
 
 /* Load a wave file of the mixer format from a memory buffer */
-Mix_Chunk * SDLCALLCC Mix_QuickLoad_WAV(Uint8 *mem)
+Mix_Chunk * MIXCALLCC Mix_QuickLoad_WAV(Uint8 *mem)
 {
     Mix_Chunk *chunk;
     Uint8 magic[4];
@@ -864,7 +864,7 @@ Mix_Chunk * SDLCALLCC Mix_QuickLoad_WAV(Uint8 *mem)
 }
 
 /* Load raw audio data of the mixer format from a memory buffer */
-Mix_Chunk * SDLCALLCC Mix_QuickLoad_RAW(Uint8 *mem, Uint32 len)
+Mix_Chunk * MIXCALLCC Mix_QuickLoad_RAW(Uint8 *mem, Uint32 len)
 {
     Mix_Chunk *chunk;
 
@@ -891,7 +891,7 @@ Mix_Chunk * SDLCALLCC Mix_QuickLoad_RAW(Uint8 *mem, Uint32 len)
 }
 
 /* Free an audio chunk previously loaded */
-void SDLCALLCC Mix_FreeChunk(Mix_Chunk *chunk)
+void MIXCALLCC Mix_FreeChunk(Mix_Chunk *chunk)
 {
     int i;
 
@@ -920,7 +920,7 @@ void SDLCALLCC Mix_FreeChunk(Mix_Chunk *chunk)
    This can be used to provide real-time visual display of the audio stream
    or add a custom mixer filter for the stream data.
 */
-void SDLCALLCC Mix_SetPostMix(void (SDLCALL *mix_func)
+void MIXCALLCC Mix_SetPostMix(void (SDLCALL *mix_func)
                     (void *udata, Uint8 *stream, int len), void *arg)
 {
     Mix_LockAudio();
@@ -931,19 +931,19 @@ void SDLCALLCC Mix_SetPostMix(void (SDLCALL *mix_func)
 
 
 /* returns a pointer to the single-music mixer that can be used as a callback */
-Mix_CommonMixer_t SDLCALLCC Mix_GetMusicMixer(void)
+Mix_CommonMixer_t MIXCALLCC Mix_GetMusicMixer(void)
 {
     return mix_music;
 }
 
 /* returns a pointer to the multi-music mixer that can be used as a callback */
-Mix_CommonMixer_t SDLCALLCC Mix_GetMultiMusicMixer(void)
+Mix_CommonMixer_t MIXCALLCC Mix_GetMultiMusicMixer(void)
 {
     return mix_multi_music;
 }
 
 /* returns a pointer to the general mixer of music and channels that can be used as a callback */
-Mix_CommonMixer_t SDLCALLCC Mix_GetGeneralMixer(void)
+Mix_CommonMixer_t MIXCALLCC Mix_GetGeneralMixer(void)
 {
     return mix_channels;
 }
@@ -951,7 +951,7 @@ Mix_CommonMixer_t SDLCALLCC Mix_GetGeneralMixer(void)
 /* Add your own music player or mixer function.
    If 'mix_func' is NULL, the default music player is re-enabled.
  */
-void SDLCALLCC Mix_HookMusic(void (SDLCALL *mix_func)(void *udata, Uint8 *stream, int len),
+void MIXCALLCC Mix_HookMusic(void (SDLCALL *mix_func)(void *udata, Uint8 *stream, int len),
                                                                 void *arg)
 {
     Mix_LockAudio();
@@ -967,12 +967,12 @@ void SDLCALLCC Mix_HookMusic(void (SDLCALL *mix_func)(void *udata, Uint8 *stream
     Mix_UnlockAudio();
 }
 
-void * SDLCALLCC Mix_GetMusicHookData(void)
+void * MIXCALLCC Mix_GetMusicHookData(void)
 {
     return(music_data);
 }
 
-void SDLCALLCC Mix_ChannelFinished(void (SDLCALL *channel_finished)(int channel))
+void MIXCALLCC Mix_ChannelFinished(void (SDLCALL *channel_finished)(int channel))
 {
     Mix_LockAudio();
     channel_done_callback = channel_finished;
@@ -984,7 +984,7 @@ void SDLCALLCC Mix_ChannelFinished(void (SDLCALL *channel_finished)(int channel)
    them dynamically to the next sample if requested with a -1 value below.
    Returns the number of reserved channels.
  */
-int SDLCALLCC Mix_ReserveChannels(int num)
+int MIXCALLCC Mix_ReserveChannels(int num)
 {
     if (num > num_channels)
         num = num_channels;
@@ -1009,7 +1009,7 @@ static int checkchunkintegral(Mix_Chunk *chunk)
    'volume' is the initial volume on play begining. -1 means the volume will not be changed.
    Returns which channel was used to play the sound.
 */
-int SDLCALLCC Mix_PlayChannelTimedVolume(int which, Mix_Chunk *chunk, int loops, int ticks, int volume)
+int MIXCALLCC Mix_PlayChannelTimedVolume(int which, Mix_Chunk *chunk, int loops, int ticks, int volume)
 {
     int i;
 
@@ -1045,7 +1045,7 @@ int SDLCALLCC Mix_PlayChannelTimedVolume(int which, Mix_Chunk *chunk, int loops,
 
         /* Queue up the audio data for this channel */
         if (which >= 0 && which < num_channels) {
-            Uint32 sdl_ticks = SDL_GetTicks();            
+            Uint32 sdl_ticks = SDL_GetTicks();
             mix_channel[which].samples = chunk->abuf;
             mix_channel[which].playing = (int)chunk->alen;
             mix_channel[which].looping = loops;
@@ -1071,13 +1071,13 @@ int SDLCALLCC Mix_PlayChannelTimedVolume(int which, Mix_Chunk *chunk, int loops,
    if there is no limit.
    Returns which channel was used to play the sound.
 */
-int SDLCALLCC Mix_PlayChannelTimed(int which, Mix_Chunk *chunk, int loops, int ticks)
+int MIXCALLCC Mix_PlayChannelTimed(int which, Mix_Chunk *chunk, int loops, int ticks)
 {
     return Mix_PlayChannelTimedVolume(which, chunk, loops, ticks, -1);
 }
 
 /* Change the expiration delay for a channel */
-int SDLCALLCC Mix_ExpireChannel(int which, int ticks)
+int MIXCALLCC Mix_ExpireChannel(int which, int ticks)
 {
     int status = 0;
 
@@ -1096,7 +1096,7 @@ int SDLCALLCC Mix_ExpireChannel(int which, int ticks)
 }
 
 /* Fade in a sound on a channel, over ms milliseconds */
-int SDLCALLCC Mix_FadeInChannelTimedVolume(int which, Mix_Chunk *chunk, int loops, int ms, int ticks, int volume)
+int MIXCALLCC Mix_FadeInChannelTimedVolume(int which, Mix_Chunk *chunk, int loops, int ms, int ticks, int volume)
 {
     int i;
 
@@ -1130,7 +1130,7 @@ int SDLCALLCC Mix_FadeInChannelTimedVolume(int which, Mix_Chunk *chunk, int loop
 
         /* Queue up the audio data for this channel */
         if (which >= 0 && which < num_channels) {
-            Uint32 sdl_ticks = SDL_GetTicks();            
+            Uint32 sdl_ticks = SDL_GetTicks();
             mix_channel[which].samples = chunk->abuf;
             mix_channel[which].playing = (int)chunk->alen;
             mix_channel[which].looping = loops;
@@ -1157,13 +1157,13 @@ int SDLCALLCC Mix_FadeInChannelTimedVolume(int which, Mix_Chunk *chunk, int loop
 }
 
 /* Fade in a sound on a channel, over ms milliseconds */
-int SDLCALLCC Mix_FadeInChannelTimed(int which, Mix_Chunk *chunk, int loops, int ms, int ticks)
+int MIXCALLCC Mix_FadeInChannelTimed(int which, Mix_Chunk *chunk, int loops, int ms, int ticks)
 {
     return Mix_FadeInChannelTimedVolume(which, chunk, loops, ms, ticks, -1);
 }
 
 /* Set volume of a particular channel */
-int SDLCALLCC Mix_Volume(int which, int volume)
+int MIXCALLCC Mix_Volume(int which, int volume)
 {
     int i;
     int prev_volume = 0;
@@ -1185,7 +1185,7 @@ int SDLCALLCC Mix_Volume(int which, int volume)
     return(prev_volume);
 }
 /* Set volume of a particular chunk */
-int SDLCALLCC Mix_VolumeChunk(Mix_Chunk *chunk, int volume)
+int MIXCALLCC Mix_VolumeChunk(Mix_Chunk *chunk, int volume)
 {
     int prev_volume;
 
@@ -1203,7 +1203,7 @@ int SDLCALLCC Mix_VolumeChunk(Mix_Chunk *chunk, int volume)
 }
 
 /* Halt playing of a particular channel */
-int SDLCALLCC Mix_HaltChannel(int which)
+int MIXCALLCC Mix_HaltChannel(int which)
 {
     int i;
 
@@ -1228,7 +1228,7 @@ int SDLCALLCC Mix_HaltChannel(int which)
 }
 
 /* Halt playing of a particular group of channels */
-int SDLCALLCC Mix_HaltGroup(int tag)
+int MIXCALLCC Mix_HaltGroup(int tag)
 {
     int i;
 
@@ -1241,7 +1241,7 @@ int SDLCALLCC Mix_HaltGroup(int tag)
 }
 
 /* Fade out a channel and then stop it automatically */
-int SDLCALLCC Mix_FadeOutChannel(int which, int ms)
+int MIXCALLCC Mix_FadeOutChannel(int which, int ms)
 {
     int status;
 
@@ -1278,7 +1278,7 @@ int SDLCALLCC Mix_FadeOutChannel(int which, int ms)
 }
 
 /* Halt playing of a particular group of channels */
-int SDLCALLCC Mix_FadeOutGroup(int tag, int ms)
+int MIXCALLCC Mix_FadeOutGroup(int tag, int ms)
 {
     int i;
     int status = 0;
@@ -1290,7 +1290,7 @@ int SDLCALLCC Mix_FadeOutGroup(int tag, int ms)
     return(status);
 }
 
-Mix_Fading SDLCALLCC Mix_FadingChannel(int which)
+Mix_Fading MIXCALLCC Mix_FadingChannel(int which)
 {
     if (which < 0 || which >= num_channels) {
         return MIX_NO_FADING;
@@ -1301,7 +1301,7 @@ Mix_Fading SDLCALLCC Mix_FadingChannel(int which)
 /* Check the status of a specific channel.
    If the specified mix_channel is -1, check all mix channels.
 */
-int SDLCALLCC Mix_Playing(int which)
+int MIXCALLCC Mix_Playing(int which)
 {
     int status;
 
@@ -1327,7 +1327,7 @@ int SDLCALLCC Mix_Playing(int which)
 }
 
 /* rcg06072001 Get the chunk associated with a channel. */
-Mix_Chunk * SDLCALLCC Mix_GetChunk(int channel)
+Mix_Chunk * MIXCALLCC Mix_GetChunk(int channel)
 {
     Mix_Chunk *retval = NULL;
 
@@ -1343,7 +1343,7 @@ Mix_Chunk * SDLCALLCC Mix_GetChunk(int channel)
    Doesn't call SDL_CloseAudioDevice, which is the responsbility
    of the external application.
 */
-void SDLCALLCC Mix_FreeMixer(void)
+void MIXCALLCC Mix_FreeMixer(void)
 {
     int i;
 
@@ -1370,7 +1370,7 @@ void SDLCALLCC Mix_FreeMixer(void)
 }
 
 /* Close the audio device, stop, and free all our mixer elements */
-void SDLCALLCC Mix_CloseAudio(void)
+void MIXCALLCC Mix_CloseAudio(void)
 {
     if (audio_device) {
         SDL_CloseAudioDevice(audio_device);
@@ -1380,7 +1380,7 @@ void SDLCALLCC Mix_CloseAudio(void)
 }
 
 /* Pause a particular channel (or all) */
-void SDLCALLCC Mix_Pause(int which)
+void MIXCALLCC Mix_Pause(int which)
 {
     Uint32 sdl_ticks = SDL_GetTicks();
     if (which == -1) {
@@ -1399,7 +1399,7 @@ void SDLCALLCC Mix_Pause(int which)
 }
 
 /* Resume a paused channel */
-void SDLCALLCC Mix_Resume(int which)
+void MIXCALLCC Mix_Resume(int which)
 {
     Uint32 sdl_ticks = SDL_GetTicks();
 
@@ -1424,7 +1424,7 @@ void SDLCALLCC Mix_Resume(int which)
     Mix_UnlockAudio();
 }
 
-int SDLCALLCC Mix_Paused(int which)
+int MIXCALLCC Mix_Paused(int which)
 {
     if (which < 0) {
         int status = 0;
@@ -1443,7 +1443,7 @@ int SDLCALLCC Mix_Paused(int which)
 }
 
 /* Change the group of a channel */
-int SDLCALLCC Mix_GroupChannel(int which, int tag)
+int MIXCALLCC Mix_GroupChannel(int which, int tag)
 {
     if (which < 0 || which > num_channels)
         return(0);
@@ -1455,7 +1455,7 @@ int SDLCALLCC Mix_GroupChannel(int which, int tag)
 }
 
 /* Assign several consecutive channels to a group */
-int SDLCALLCC Mix_GroupChannels(int from, int to, int tag)
+int MIXCALLCC Mix_GroupChannels(int from, int to, int tag)
 {
     int status = 0;
     for(; from <= to; ++ from) {
@@ -1465,7 +1465,7 @@ int SDLCALLCC Mix_GroupChannels(int from, int to, int tag)
 }
 
 /* Finds the first available channel in a group of channels */
-int SDLCALLCC Mix_GroupAvailable(int tag)
+int MIXCALLCC Mix_GroupAvailable(int tag)
 {
     int i;
     for(i=0; i < num_channels; i ++) {
@@ -1476,7 +1476,7 @@ int SDLCALLCC Mix_GroupAvailable(int tag)
     return(-1);
 }
 
-int SDLCALLCC Mix_GroupCount(int tag)
+int MIXCALLCC Mix_GroupCount(int tag)
 {
     int count = 0;
     int i;
@@ -1488,7 +1488,7 @@ int SDLCALLCC Mix_GroupCount(int tag)
 }
 
 /* Finds the "oldest" sample playing in a group of channels */
-int SDLCALLCC Mix_GroupOldest(int tag)
+int MIXCALLCC Mix_GroupOldest(int tag)
 {
     int chan = -1;
     Uint32 mintime = SDL_GetTicks();
@@ -1504,7 +1504,7 @@ int SDLCALLCC Mix_GroupOldest(int tag)
 }
 
 /* Finds the "most recent" (i.e. last) sample playing in a group of channels */
-int SDLCALLCC Mix_GroupNewer(int tag)
+int MIXCALLCC Mix_GroupNewer(int tag)
 {
     int chan = -1;
     Uint32 maxtime = 0;
@@ -1650,7 +1650,7 @@ int _Mix_RegisterEffect_locked(int channel, Mix_EffectFunc_t f,
     return _Mix_register_effect(e, f, d, arg);
 }
 
-int SDLCALLCC Mix_RegisterEffect(int channel, Mix_EffectFunc_t f,
+int MIXCALLCC Mix_RegisterEffect(int channel, Mix_EffectFunc_t f,
             Mix_EffectDone_t d, void *arg)
 {
     int retval;
@@ -1679,7 +1679,7 @@ int _Mix_UnregisterEffect_locked(int channel, Mix_EffectFunc_t f)
     return _Mix_remove_effect(channel, e, f);
 }
 
-int SDLCALLCC Mix_UnregisterEffect(int channel, Mix_EffectFunc_t f)
+int MIXCALLCC Mix_UnregisterEffect(int channel, Mix_EffectFunc_t f)
 {
     int retval;
     Mix_LockAudio();
@@ -1706,7 +1706,7 @@ int _Mix_UnregisterAllEffects_locked(int channel)
     return _Mix_remove_all_effects(channel, e);
 }
 
-int SDLCALLCC Mix_UnregisterAllEffects(int channel)
+int MIXCALLCC Mix_UnregisterAllEffects(int channel)
 {
     int retval;
     Mix_LockAudio();
diff --git a/src/mixer_x_deprecated.c b/src/mixer_x_deprecated.c
index 3e6e8695..710414e3 100644
--- a/src/mixer_x_deprecated.c
+++ b/src/mixer_x_deprecated.c
@@ -26,37 +26,37 @@
     There are kept to don't break ABI with existing apps.
 */
 
-void SDLCALLCC Mix_Timidity_addToPathList(const char *path)
+void MIXCALLCC Mix_Timidity_addToPathList(const char *path)
 {
     Mix_SetTimidityCfg(path);
 }
 
-int SDLCALLCC Mix_GetMidiDevice()
+int MIXCALLCC Mix_GetMidiDevice()
 {
     return Mix_GetMidiPlayer();
 }
 
-int SDLCALLCC Mix_GetNextMidiDevice()
+int MIXCALLCC Mix_GetNextMidiDevice()
 {
     return Mix_GetNextMidiPlayer();
 }
 
-int SDLCALLCC Mix_SetMidiDevice(int player)
+int MIXCALLCC Mix_SetMidiDevice(int player)
 {
     return Mix_SetMidiPlayer(player);
 }
 
-int SDLCALLCC Mix_ADLMIDI_getAdLibMode()
+int MIXCALLCC Mix_ADLMIDI_getAdLibMode()
 {
     return -1;
 }
 
-void SDLCALLCC Mix_ADLMIDI_setAdLibMode(int ald)
+void MIXCALLCC Mix_ADLMIDI_setAdLibMode(int ald)
 {
     (void)ald;
 }
 
-int SDLCALLCC Mix_ADLMIDI_getLogarithmicVolumes()
+int MIXCALLCC Mix_ADLMIDI_getLogarithmicVolumes()
 {
 #ifdef MUSIC_MID_ADLMIDI
     return (Mix_ADLMIDI_getVolumeModel() == ADLMIDI_VM_NATIVE);
@@ -65,7 +65,7 @@ int SDLCALLCC Mix_ADLMIDI_getLogarithmicVolumes()
 #endif
 }
 
-void SDLCALLCC Mix_ADLMIDI_setLogarithmicVolumes(int vm)
+void MIXCALLCC Mix_ADLMIDI_setLogarithmicVolumes(int vm)
 {
 #ifdef MUSIC_MID_ADLMIDI
     Mix_ADLMIDI_setVolumeModel(vm ? ADLMIDI_VM_NATIVE : ADLMIDI_VM_AUTO);
@@ -74,7 +74,7 @@ void SDLCALLCC Mix_ADLMIDI_setLogarithmicVolumes(int vm)
 #endif
 }
 
-int SDLCALLCC Mix_SetMusicStreamPosition(Mix_Music *music, double position)
+int MIXCALLCC Mix_SetMusicStreamPosition(Mix_Music *music, double position)
 {
     return Mix_SetMusicPositionStream(music, position);
 }
diff --git a/src/music.c b/src/music.c
index 99ed26b7..522e6fdb 100644
--- a/src/music.c
+++ b/src/music.c
@@ -398,7 +398,7 @@ int _Mix_RegisterMusicEffect_locked(Mix_Music *mus, Mix_MusicEffectFunc_t f,
     return _Mix_register_mus_effect(e, f, d, arg);
 }
 
-int SDLCALLCC Mix_RegisterMusicEffect(Mix_Music *mus, Mix_MusicEffectFunc_t f,
+int MIXCALLCC Mix_RegisterMusicEffect(Mix_Music *mus, Mix_MusicEffectFunc_t f,
             Mix_MusicEffectDone_t d, void *arg)
 {
     int retval;
@@ -423,7 +423,7 @@ int _Mix_UnregisterMusicEffect_locked(Mix_Music *mus, Mix_MusicEffectFunc_t f)
     return _Mix_remove_mus_effect(mus, e, f);
 }
 
-int SDLCALLCC Mix_UnregisterMusicEffect(Mix_Music *mus, Mix_MusicEffectFunc_t f)
+int MIXCALLCC Mix_UnregisterMusicEffect(Mix_Music *mus, Mix_MusicEffectFunc_t f)
 {
     int retval;
     Mix_LockAudio();
@@ -446,7 +446,7 @@ int _Mix_UnregisterAllMusicEffects_locked(Mix_Music *mus)
     return _Mix_remove_all_mus_effects(mus, e);
 }
 
-int SDLCALLCC Mix_UnregisterAllMusicEffects(Mix_Music *mus)
+int MIXCALLCC Mix_UnregisterAllMusicEffects(Mix_Music *mus)
 {
     int retval;
     Mix_LockAudio();
@@ -639,12 +639,12 @@ Mix_MusicInterface *get_music_interface(int index)
     return s_music_interfaces[index];
 }
 
-int SDLCALLCC Mix_GetNumMusicDecoders(void)
+int MIXCALLCC Mix_GetNumMusicDecoders(void)
 {
     return(num_decoders);
 }
 
-const char *SDLCALLCC Mix_GetMusicDecoder(int index)
+const char *MIXCALLCC Mix_GetMusicDecoder(int index)
 {
     if ((index < 0) || (index >= num_decoders)) {
         return NULL;
@@ -652,7 +652,7 @@ const char *SDLCALLCC Mix_GetMusicDecoder(int index)
     return(music_decoders[index]);
 }
 
-SDL_bool SDLCALLCC Mix_HasMusicDecoder(const char *name)
+SDL_bool MIXCALLCC Mix_HasMusicDecoder(const char *name)
 {
     int index;
     for (index = 0; index < num_decoders; ++index) {
@@ -698,21 +698,21 @@ static void (SDLCALL *music_finished_hook)(void) = NULL;
 /* Support for hooking when the any multi-music has finished */
 static void (SDLCALL *music_finished_hook_mm)(void) = NULL;
 
-void SDLCALLCC Mix_HookMusicFinished(void (SDLCALL *music_finished)(void))
+void MIXCALLCC Mix_HookMusicFinished(void (SDLCALL *music_finished)(void))
 {
     Mix_LockAudio();
     music_finished_hook = music_finished;
     Mix_UnlockAudio();
 }
 
-void SDLCALLCC Mix_HookMusicStreamFinishedAny(void (SDLCALL *music_finished)(void))
+void MIXCALLCC Mix_HookMusicStreamFinishedAny(void (SDLCALL *music_finished)(void))
 {
     Mix_LockAudio();
     music_finished_hook_mm = music_finished;
     Mix_UnlockAudio();
 }
 
-void SDLCALLCC Mix_HookMusicStreamFinished(Mix_Music *music, void (SDLCALL *music_finished)(Mix_Music*, void*), void *user_data)
+void MIXCALLCC Mix_HookMusicStreamFinished(Mix_Music *music, void (SDLCALL *music_finished)(Mix_Music*, void*), void *user_data)
 {
     Mix_LockAudio();
     music->music_finished_hook = music_finished;
@@ -1646,7 +1646,7 @@ static int split_path_and_params(const char *path, char **file, char **args)
 }
 
 /* Load a music file */
-Mix_Music * SDLCALLCC Mix_LoadMUS(const char *file)
+Mix_Music * MIXCALLCC Mix_LoadMUS(const char *file)
 {
     size_t i;
     void *context;
@@ -1768,7 +1768,7 @@ Mix_Music * SDLCALLCC Mix_LoadMUS(const char *file)
     return ret;
 }
 
-void SDLCALLCC Mix_SetMusicFileName(Mix_Music *music, const char *file)
+void MIXCALLCC Mix_SetMusicFileName(Mix_Music *music, const char *file)
 {
     if (music) {
         const char *p = get_last_dirsep(file);
@@ -1776,17 +1776,17 @@ void SDLCALLCC Mix_SetMusicFileName(Mix_Music *music, const char *file)
     }
 }
 
-Mix_Music * SDLCALLCC Mix_LoadMUS_RW(SDL_RWops *src, int freesrc)
+Mix_Music * MIXCALLCC Mix_LoadMUS_RW(SDL_RWops *src, int freesrc)
 {
     return Mix_LoadMUSType_RW(src, MUS_NONE, freesrc);
 }
 
-Mix_Music *SDLCALLCC Mix_LoadMUS_RW_ARG(SDL_RWops *src, int freesrc, const char *args)
+Mix_Music *MIXCALLCC Mix_LoadMUS_RW_ARG(SDL_RWops *src, int freesrc, const char *args)
 {
     return Mix_LoadMUSType_RW_ARG(src, MUS_NONE, freesrc, args);
 }
 
-Mix_Music *SDLCALLCC Mix_LoadMUS_RW_GME(SDL_RWops *src, int freesrc, int trackID)
+Mix_Music *MIXCALLCC Mix_LoadMUS_RW_GME(SDL_RWops *src, int freesrc, int trackID)
 {
     char music_args[25];
     music_args[0] = '\0';
@@ -1794,12 +1794,12 @@ Mix_Music *SDLCALLCC Mix_LoadMUS_RW_GME(SDL_RWops *src, int freesrc, int trackID
     return Mix_LoadMUSType_RW_ARG(src, MUS_NONE, freesrc, music_args);
 }
 
-Mix_Music * SDLCALLCC Mix_LoadMUSType_RW(SDL_RWops *src, Mix_MusicType type, int freesrc)
+Mix_Music * MIXCALLCC Mix_LoadMUSType_RW(SDL_RWops *src, Mix_MusicType type, int freesrc)
 {
     return Mix_LoadMUSType_RW_ARG(src, type, freesrc, "");
 }
 
-Mix_Music * SDLCALLCC Mix_LoadMUSType_RW_ARG(SDL_RWops *src, Mix_MusicType type, int freesrc, const char *args)
+Mix_Music * MIXCALLCC Mix_LoadMUSType_RW_ARG(SDL_RWops *src, Mix_MusicType type, int freesrc, const char *args)
 {
     size_t i;
     void *context;
@@ -1891,7 +1891,7 @@ Mix_Music * SDLCALLCC Mix_LoadMUSType_RW_ARG(SDL_RWops *src, Mix_MusicType type,
 }
 
 /* Free a music chunk previously loaded */
-void SDLCALLCC Mix_FreeMusic(Mix_Music *music)
+void MIXCALLCC Mix_FreeMusic(Mix_Music *music)
 {
     if (music) {
         /* Stop the music if it's currently playing */
@@ -1923,7 +1923,7 @@ void SDLCALLCC Mix_FreeMusic(Mix_Music *music)
 }
 
 /* Set the music to be self-destroyed once playback has get finished. */
-int SDLCALLCC Mix_SetFreeOnStop(Mix_Music *music, int free_on_stop)
+int MIXCALLCC Mix_SetFreeOnStop(Mix_Music *music, int free_on_stop)
 {
     int ret = 0;
 
@@ -1948,7 +1948,7 @@ int SDLCALLCC Mix_SetFreeOnStop(Mix_Music *music, int free_on_stop)
 /* Find out the music format of a mixer music, or the currently playing
    music, if 'music' is NULL.
 */
-Mix_MusicType SDLCALLCC Mix_GetMusicType(const Mix_Music *music)
+Mix_MusicType MIXCALLCC Mix_GetMusicType(const Mix_Music *music)
 {
     Mix_MusicType type = MUS_NONE;
 
@@ -1980,13 +1980,13 @@ static const char * get_music_tag_internal(const Mix_Music *music, Mix_MusicMeta
     return tag;
 }
 
-const char *SDLCALLCC Mix_GetMusicTitleTag(const Mix_Music *music)
+const char *MIXCALLCC Mix_GetMusicTitleTag(const Mix_Music *music)
 {
     return get_music_tag_internal(music, MIX_META_TITLE);
 }
 
 /* Get music title from meta-tag if possible */
-const char *SDLCALLCC Mix_GetMusicTitle(const Mix_Music *music)
+const char *MIXCALLCC Mix_GetMusicTitle(const Mix_Music *music)
 {
     const char *tag = Mix_GetMusicTitleTag(music);
     if (SDL_strlen(tag) > 0) {
@@ -2001,17 +2001,17 @@ const char *SDLCALLCC Mix_GetMusicTitle(const Mix_Music *music)
     return "";
 }
 
-const char *SDLCALLCC Mix_GetMusicArtistTag(const Mix_Music *music)
+const char *MIXCALLCC Mix_GetMusicArtistTag(const Mix_Music *music)
 {
     return get_music_tag_internal(music, MIX_META_ARTIST);
 }
 
-const char *SDLCALLCC Mix_GetMusicAlbumTag(const Mix_Music *music)
+const char *MIXCALLCC Mix_GetMusicAlbumTag(const Mix_Music *music)
 {
     return get_music_tag_internal(music, MIX_META_ALBUM);
 }
 
-const char *SDLCALLCC Mix_GetMusicCopyrightTag(const Mix_Music *music)
+const char *MIXCALLCC Mix_GetMusicCopyrightTag(const Mix_Music *music)
 {
     return get_music_tag_internal(music, MIX_META_COPYRIGHT);
 }
@@ -2066,7 +2066,7 @@ static int music_internal_play(Mix_Music *music, int play_count, double position
     return(retval);
 }
 
-int SDLCALLCC Mix_FadeInMusicPos(Mix_Music *music, int loops, int ms, double position)
+int MIXCALLCC Mix_FadeInMusicPos(Mix_Music *music, int loops, int ms, double position)
 {
     int retval, reverse_fade = 0;
 
@@ -2132,11 +2132,11 @@ int SDLCALLCC Mix_FadeInMusicPos(Mix_Music *music, int loops, int ms, double pos
 
     return(retval);
 }
-int SDLCALLCC Mix_FadeInMusic(Mix_Music *music, int loops, int ms)
+int MIXCALLCC Mix_FadeInMusic(Mix_Music *music, int loops, int ms)
 {
     return Mix_FadeInMusicPos(music, loops, ms, 0.0);
 }
-int SDLCALLCC Mix_PlayMusic(Mix_Music *music, int loops)
+int MIXCALLCC Mix_PlayMusic(Mix_Music *music, int loops)
 {
     return Mix_FadeInMusicPos(music, loops, 0, 0.0);
 }
@@ -2183,7 +2183,7 @@ static int music_internal_play_stream(Mix_Music *music, int play_count, double p
     }
     return(retval);
 }
-int SDLCALLCC Mix_FadeInMusicStreamPos(Mix_Music *music, int loops, int ms, double position)
+int MIXCALLCC Mix_FadeInMusicStreamPos(Mix_Music *music, int loops, int ms, double position)
 {
     int retval, reverse_fade = 0;
 
@@ -2261,18 +2261,18 @@ int SDLCALLCC Mix_FadeInMusicStreamPos(Mix_Music *music, int loops, int ms, doub
 
     return(retval);
 }
-int SDLCALLCC Mix_PlayMusicStream(Mix_Music *music, int loops)
+int MIXCALLCC Mix_PlayMusicStream(Mix_Music *music, int loops)
 {
     return Mix_FadeInMusicStreamPos(music, loops, 0, 0.0);
 }
-int SDLCALLCC Mix_FadeInMusicStream(Mix_Music *music, int loops, int ms)
+int MIXCALLCC Mix_FadeInMusicStream(Mix_Music *music, int loops, int ms)
 {
     return Mix_FadeInMusicStreamPos(music, loops, ms, 0.0);
 }
 
 
 /* Jump to a given order in mod music. */
-int SDLCALLCC Mix_ModMusicJumpToOrder(int order)
+int MIXCALLCC Mix_ModMusicJumpToOrder(int order)
 {
     int retval = -1;
 
@@ -2290,7 +2290,7 @@ int SDLCALLCC Mix_ModMusicJumpToOrder(int order)
 
     return retval;
 }
-int SDLCALLCC Mix_ModMusicStreamJumpToOrder(Mix_Music *music, int order)
+int MIXCALLCC Mix_ModMusicStreamJumpToOrder(Mix_Music *music, int order)
 {
     int retval = -1;
 
@@ -2317,7 +2317,7 @@ int music_internal_position(Mix_Music *music, double position)
     }
     return -1;
 }
-int SDLCALLCC Mix_SetMusicPositionStream(Mix_Music *music, double position)
+int MIXCALLCC Mix_SetMusicPositionStream(Mix_Music *music, double position)
 {
     int retval;
 
@@ -2342,7 +2342,7 @@ int SDLCALLCC Mix_SetMusicPositionStream(Mix_Music *music, double position)
 }
 
 /* Deprecated call, kept for ABI compatibility */
-int SDLCALLCC Mix_SetMusicPosition(double position)
+int MIXCALLCC Mix_SetMusicPosition(double position)
 {
     return Mix_SetMusicPositionStream(NULL, position);
 }
@@ -2355,7 +2355,7 @@ static double music_internal_position_get(Mix_Music *music)
     }
     return -1;
 }
-double SDLCALLCC Mix_GetMusicPosition(Mix_Music *music)
+double MIXCALLCC Mix_GetMusicPosition(Mix_Music *music)
 {
     double retval;
 
@@ -2382,7 +2382,7 @@ static double music_internal_duration(Mix_Music *music)
         return -1;
     }
 }
-double SDLCALLCC Mix_MusicDuration(Mix_Music *music)
+double MIXCALLCC Mix_MusicDuration(Mix_Music *music)
 {
     double retval;
 
@@ -2401,7 +2401,7 @@ double SDLCALLCC Mix_MusicDuration(Mix_Music *music)
 }
 
 /* Old name call, kept for ABI compatibility */
-double SDLCALLCC Mix_GetMusicTotalTime(Mix_Music *music)
+double MIXCALLCC Mix_GetMusicTotalTime(Mix_Music *music)
 {
     return Mix_MusicDuration(music);
 }
@@ -2414,7 +2414,7 @@ int music_internal_set_tempo(Mix_Music *music, double tempo)
     }
     return -1;
 }
-int SDLCALLCC Mix_SetMusicTempo(Mix_Music *music, double tempo)
+int MIXCALLCC Mix_SetMusicTempo(Mix_Music *music, double tempo)
 {
     int retval;
 
@@ -2446,7 +2446,7 @@ static double music_internal_tempo(Mix_Music *music)
     }
     return -1.0;
 }
-double SDLCALLCC Mix_GetMusicTempo(Mix_Music *music)
+double MIXCALLCC Mix_GetMusicTempo(Mix_Music *music)
 {
     double retval;
 
@@ -2472,7 +2472,7 @@ static int music_internal_tracks(Mix_Music *music)
     }
     return -1;
 }
-int SDLCALLCC Mix_GetMusicTracks(Mix_Music *music)
+int MIXCALLCC Mix_GetMusicTracks(Mix_Music *music)
 {
     int retval;
 
@@ -2498,7 +2498,7 @@ int music_internal_set_track_mute(Mix_Music *music, int track, int mute)
     }
     return -1;
 }
-int SDLCALLCC Mix_SetMusicTrackMute(Mix_Music *music, int track, int mute)
+int MIXCALLCC Mix_SetMusicTrackMute(Mix_Music *music, int track, int mute)
 {
     int retval;
 
@@ -2531,7 +2531,7 @@ static double music_internal_loop_start(Mix_Music *music)
     }
     return -1;
 }
-double SDLCALLCC Mix_GetMusicLoopStartTime(Mix_Music *music)
+double MIXCALLCC Mix_GetMusicLoopStartTime(Mix_Music *music)
 {
     double retval;
 
@@ -2557,7 +2557,7 @@ static double music_internal_loop_end(Mix_Music *music)
     }
     return -1;
 }
-double SDLCALLCC Mix_GetMusicLoopEndTime(Mix_Music *music)
+double MIXCALLCC Mix_GetMusicLoopEndTime(Mix_Music *music)
 {
     double retval;
 
@@ -2583,7 +2583,7 @@ static double music_internal_loop_length(Mix_Music *music)
     }
     return -1;
 }
-double SDLCALLCC Mix_GetMusicLoopLengthTime(Mix_Music *music)
+double MIXCALLCC Mix_GetMusicLoopLengthTime(Mix_Music *music)
 {
     double retval;
 
@@ -2629,7 +2629,7 @@ static void music_internal_volume(Mix_Music *music, int volume)
         music->interface->SetVolume(music->context, volume);
     }
 }
-int SDLCALLCC Mix_VolumeMusicStream(Mix_Music *music, int volume)
+int MIXCALLCC Mix_VolumeMusicStream(Mix_Music *music, int volume)
 {
     int prev_volume;
 
@@ -2657,12 +2657,12 @@ int SDLCALLCC Mix_VolumeMusicStream(Mix_Music *music, int volume)
     Mix_UnlockAudio();
     return(prev_volume);
 }
-int SDLCALLCC Mix_VolumeMusic(int volume)
+int MIXCALLCC Mix_VolumeMusic(int volume)
 {
     return Mix_VolumeMusicStream(NULL, volume);
 }
 
-int SDLCALLCC Mix_GetMusicVolume(Mix_Music *music)
+int MIXCALLCC Mix_GetMusicVolume(Mix_Music *music)
 {
     int prev_volume;
 
@@ -2677,12 +2677,12 @@ int SDLCALLCC Mix_GetMusicVolume(Mix_Music *music)
     return prev_volume;
 }
 
-int SDLCALLCC Mix_GetVolumeMusicStream(Mix_Music *music)
+int MIXCALLCC Mix_GetVolumeMusicStream(Mix_Music *music)
 {
     return Mix_GetMusicVolume(music);
 }
 
-void SDLCALLCC Mix_VolumeMusicGeneral(int volume)
+void MIXCALLCC Mix_VolumeMusicGeneral(int volume)
 {
     Mix_LockAudio();
     if (volume < 0) {
@@ -2695,7 +2695,7 @@ void SDLCALLCC Mix_VolumeMusicGeneral(int volume)
     Mix_UnlockAudio();
 }
 
-int SDLCALLCC Mix_GetVolumeMusicGeneral(void)
+int MIXCALLCC Mix_GetVolumeMusicGeneral(void)
 {
     return music_general_volume;
 }
@@ -2720,7 +2720,7 @@ static void music_internal_halt(Mix_Music *music)
         music_playing = NULL;
     }
 }
-int SDLCALLCC Mix_HaltMusicStream(Mix_Music *music)
+int MIXCALLCC Mix_HaltMusicStream(Mix_Music *music)
 {
     int is_multi_music;
 
@@ -2762,13 +2762,13 @@ int SDLCALLCC Mix_HaltMusicStream(Mix_Music *music)
 
     return(0);
 }
-int SDLCALLCC Mix_HaltMusic(void)
+int MIXCALLCC Mix_HaltMusic(void)
 {
     return Mix_HaltMusicStream(NULL);
 }
 
 /* Progressively stop the music */
-int SDLCALLCC Mix_FadeOutMusicStream(Mix_Music *music, int ms)
+int MIXCALLCC Mix_FadeOutMusicStream(Mix_Music *music, int ms)
 {
     int retval = 0;
 
@@ -2809,11 +2809,11 @@ int SDLCALLCC Mix_FadeOutMusicStream(Mix_Music *music, int ms)
 
     return(retval);
 }
-int SDLCALLCC Mix_FadeOutMusic(int ms)
+int MIXCALLCC Mix_FadeOutMusic(int ms)
 {
     return Mix_FadeOutMusicStream(NULL, ms);
 }
-int SDLCALLCC Mix_CrossFadeMusicStreamPos(Mix_Music *old_music, Mix_Music *new_music, int loops, int ms, double pos, int free_old)
+int MIXCALLCC Mix_CrossFadeMusicStreamPos(Mix_Music *old_music, Mix_Music *new_music, int loops, int ms, double pos, int free_old)
 {
     int retval1, retval2;
 
@@ -2827,12 +2827,12 @@ int SDLCALLCC Mix_CrossFadeMusicStreamPos(Mix_Music *old_music, Mix_Music *new_m
         return(-1);
     }
 }
-int SDLCALLCC Mix_CrossFadeMusicStream(Mix_Music *old_music, Mix_Music *new_music, int loops, int ms, int free_old)
+int MIXCALLCC Mix_CrossFadeMusicStream(Mix_Music *old_music, Mix_Music *new_music, int loops, int ms, int free_old)
 {
     return Mix_CrossFadeMusicStreamPos(old_music, new_music, loops, ms, 0.0, free_old);
 }
 
-Mix_Fading SDLCALLCC Mix_FadingMusicStream(Mix_Music *music)
+Mix_Fading MIXCALLCC Mix_FadingMusicStream(Mix_Music *music)
 {
     Mix_Fading fading = MIX_NO_FADING;
 
@@ -2846,13 +2846,13 @@ Mix_Fading SDLCALLCC Mix_FadingMusicStream(Mix_Music *music)
 
     return(fading);
 }
-Mix_Fading SDLCALLCC Mix_FadingMusic(void)
+Mix_Fading MIXCALLCC Mix_FadingMusic(void)
 {
     return Mix_FadingMusicStream(NULL);
 }
 
 /* Pause/Resume the music stream */
-void SDLCALLCC Mix_PauseMusicStream(Mix_Music *music)
+void MIXCALLCC Mix_PauseMusicStream(Mix_Music *music)
 {
     Mix_LockAudio();
     if (music) {
@@ -2872,12 +2872,12 @@ void SDLCALLCC Mix_PauseMusicStream(Mix_Music *music)
     }
     Mix_UnlockAudio();
 }
-void SDLCALLCC Mix_PauseMusic(void)
+void MIXCALLCC Mix_PauseMusic(void)
 {
     Mix_PauseMusicStream(NULL);
 }
 
-void SDLCALLCC Mix_ResumeMusicStream(Mix_Music *music)
+void MIXCALLCC Mix_ResumeMusicStream(Mix_Music *music)
 {
     Mix_LockAudio();
     if (music) {
@@ -2898,29 +2898,29 @@ void SDLCALLCC Mix_ResumeMusicStream(Mix_Music *music)
 
     Mix_UnlockAudio();
 }
-void SDLCALLCC Mix_ResumeMusic(void)
+void MIXCALLCC Mix_ResumeMusic(void)
 {
     Mix_ResumeMusicStream(NULL);
 }
-void SDLCALLCC Mix_PauseMusicStreamAll(void)
+void MIXCALLCC Mix_PauseMusicStreamAll(void)
 {
     _Mix_MultiMusic_PauseAll();
 }
-void SDLCALLCC Mix_ResumeMusicStreamAll(void)
+void MIXCALLCC Mix_ResumeMusicStreamAll(void)
 {
     _Mix_MultiMusic_ResumeAll();
 }
 
-void SDLCALLCC Mix_RewindMusicStream(Mix_Music *music)
+void MIXCALLCC Mix_RewindMusicStream(Mix_Music *music)
 {
     Mix_SetMusicPositionStream(music, 0.0);
 }
-void SDLCALLCC Mix_RewindMusic(void)
+void MIXCALLCC Mix_RewindMusic(void)
 {
     Mix_SetMusicPositionStream(NULL, 0.0);
 }
 
-int SDLCALLCC Mix_PausedMusicStream(Mix_Music *music)
+int MIXCALLCC Mix_PausedMusicStream(Mix_Music *music)
 {
     (void)music;
 
@@ -2931,7 +2931,7 @@ int SDLCALLCC Mix_PausedMusicStream(Mix_Music *music)
     return (music_active == SDL_FALSE);/*isPaused;*/
 }
 
-int SDLCALLCC Mix_PausedMusic(void)
+int MIXCALLCC Mix_PausedMusic(void)
 {
     return (music_active == SDL_FALSE);
 }
@@ -2948,7 +2948,7 @@ static SDL_bool music_internal_playing(Mix_Music *music)
     }
     return music->playing;
 }
-int SDLCALLCC Mix_PlayingMusicStream(Mix_Music *music)
+int MIXCALLCC Mix_PlayingMusicStream(Mix_Music *music)
 {
     SDL_bool playing;
 
@@ -2963,13 +2963,13 @@ int SDLCALLCC Mix_PlayingMusicStream(Mix_Music *music)
     return playing ? 1 : 0;
 }
 /* Deprecated call, kept for ABI compatibility */
-int SDLCALLCC Mix_PlayingMusic(void)
+int MIXCALLCC Mix_PlayingMusic(void)
 {
     return Mix_PlayingMusicStream(NULL);
 }
 
 /* Set the external music playback command */
-int SDLCALLCC Mix_SetMusicCMD(const char *command)
+int MIXCALLCC Mix_SetMusicCMD(const char *command)
 {
     Mix_HaltMusicStream(music_playing);
     _Mix_MultiMusic_HaltAll();
@@ -2988,14 +2988,14 @@ int SDLCALLCC Mix_SetMusicCMD(const char *command)
     return 0;
 }
 
-int SDLCALLCC Mix_SetSynchroValue(int i)
+int MIXCALLCC Mix_SetSynchroValue(int i)
 {
     /* Not supported by any players at this time */
     (void) i;
     return -1;
 }
 
-int SDLCALLCC Mix_GetSynchroValue(void)
+int MIXCALLCC Mix_GetSynchroValue(void)
 {
     /* Not supported by any players at this time */
     return(-1);
@@ -3057,7 +3057,7 @@ void unload_music(void)
     }
 }
 
-int SDLCALLCC Mix_SetTimidityCfg(const char *path)
+int MIXCALLCC Mix_SetTimidityCfg(const char *path)
 {
     if (timidity_cfg) {
         SDL_free(timidity_cfg);
@@ -3074,12 +3074,12 @@ int SDLCALLCC Mix_SetTimidityCfg(const char *path)
     return 0;
 }
 
-const char* SDLCALLCC Mix_GetTimidityCfg(void)
+const char* MIXCALLCC Mix_GetTimidityCfg(void)
 {
     return timidity_cfg;
 }
 
-int SDLCALLCC Mix_SetSoundFonts(const char *paths)
+int MIXCALLCC Mix_SetSoundFonts(const char *paths)
 {
     if (soundfont_paths) {
         SDL_free(soundfont_paths);
@@ -3095,7 +3095,7 @@ int SDLCALLCC Mix_SetSoundFonts(const char *paths)
     return 1;
 }
 
-const char* SDLCALLCC Mix_GetSoundFonts(void)
+const char* MIXCALLCC Mix_GetSoundFonts(void)
 {
     const char *env_paths = SDL_getenv("SDL_SOUNDFONTS");
     SDL_bool force_env_paths = SDL_GetHintBoolean("SDL_FORCE_SOUNDFONTS", SDL_FALSE);
@@ -3129,12 +3129,12 @@ const char* SDLCALLCC Mix_GetSoundFonts(void)
     return NULL;
 }
 
-int SDLCALLCC Mix_EachSoundFont(int (SDLCALL *function)(const char*, void*), void *data)
+int MIXCALLCC Mix_EachSoundFont(int (SDLCALL *function)(const char*, void*), void *data)
 {
     return Mix_EachSoundFontEx(Mix_GetSoundFonts(), function, data);
 }
 
-int SDLCALLCC Mix_EachSoundFontEx(const char* cpaths, int (SDLCALL *function)(const char*, void*), void *data)
+int MIXCALLCC Mix_EachSoundFontEx(const char* cpaths, int (SDLCALL *function)(const char*, void*), void *data)
 {
     char *context, *path, *paths;
     int soundfonts_found = 0;
@@ -3168,17 +3168,17 @@ int SDLCALLCC Mix_EachSoundFontEx(const char* cpaths, int (SDLCALL *function)(co
 }
 
 
-int SDLCALLCC Mix_GetMidiPlayer()
+int MIXCALLCC Mix_GetMidiPlayer()
 {
     return mididevice_current;
 }
 
-int SDLCALLCC Mix_GetNextMidiPlayer()
+int MIXCALLCC Mix_GetNextMidiPlayer()
 {
     return mididevice_current;
 }
 
-int SDLCALLCC Mix_SetMidiPlayer(int player)
+int MIXCALLCC Mix_SetMidiPlayer(int player)
 {
 #ifdef MUSIC_USE_MIDI
     switch (player) {
@@ -3213,7 +3213,7 @@ int SDLCALLCC Mix_SetMidiPlayer(int player)
 #endif
 }
 
-void SDLCALLCC Mix_SetLockMIDIArgs(int lock_midiargs)
+void MIXCALLCC Mix_SetLockMIDIArgs(int lock_midiargs)
 {
     mididevice_args_lock = lock_midiargs;
 }
@@ -3222,7 +3222,7 @@ void SDLCALLCC Mix_SetLockMIDIArgs(int lock_midiargs)
 
 /* ADLMIDI module setup calls */
 
-int SDLCALLCC Mix_ADLMIDI_getTotalBanks(void)
+int MIXCALLCC Mix_ADLMIDI_getTotalBanks(void)
 {
 #ifdef MUSIC_MID_ADLMIDI
     return _Mix_ADLMIDI_getTotalBanks();
@@ -3230,7 +3230,7 @@ int SDLCALLCC Mix_ADLMIDI_getTotalBanks(void)
     return 0;
 }
 
-const char *const * SDLCALLCC Mix_ADLMIDI_getBankNames()
+const char *const * MIXCALLCC Mix_ADLMIDI_getBankNames()
 {
 #ifdef MUSIC_MID_ADLMIDI
     return _Mix_ADLMIDI_getBankNames();
@@ -3240,7 +3240,7 @@ const char *const * SDLCALLCC Mix_ADLMIDI_getBankNames()
 #endif
 }
 
-int SDLCALLCC Mix_ADLMIDI_getBankID(void)
+int MIXCALLCC Mix_ADLMIDI_getBankID(void)
 {
 #ifdef MUSIC_MID_ADLMIDI
     return _Mix_ADLMIDI_getBankID();
@@ -3249,7 +3249,7 @@ int SDLCALLCC Mix_ADLMIDI_getBankID(void)
 #endif
 }
 
-void SDLCALLCC Mix_ADLMIDI_setBankID(int bnk)
+void MIXCALLCC Mix_ADLMIDI_setBankID(int bnk)
 {
 #ifdef MUSIC_MID_ADLMIDI
     _Mix_ADLMIDI_setBankID(bnk);
@@ -3258,7 +3258,7 @@ void SDLCALLCC Mix_ADLMIDI_setBankID(int bnk)
 #endif
 }
 
-int SDLCALLCC Mix_ADLMIDI_getTremolo(void)
+int MIXCALLCC Mix_ADLMIDI_getTremolo(void)
 {
 #ifdef MUSIC_MID_ADLMIDI
     return _Mix_ADLMIDI_getTremolo();
@@ -3266,7 +3266,7 @@ int SDLCALLCC Mix_ADLMIDI_getTremolo(void)
     return -1;
 #endif
 }
-void SDLCALLCC Mix_ADLMIDI_setTremolo(int tr)
+void MIXCALLCC Mix_ADLMIDI_setTremolo(int tr)
 {
 #ifdef MUSIC_MID_ADLMIDI
     _Mix_ADLMIDI_setTremolo(tr);
@@ -3275,7 +3275,7 @@ void SDLCALLCC Mix_ADLMIDI_setTremolo(int tr)
 #endif
 }
 
-int SDLCALLCC Mix_ADLMIDI_getVibrato(void)
+int MIXCALLCC Mix_ADLMIDI_getVibrato(void)
 {
 #ifdef MUSIC_MID_ADLMIDI
     return _Mix_ADLMIDI_getVibrato();
@@ -3284,7 +3284,7 @@ int SDLCALLCC Mix_ADLMIDI_getVibrato(void)
 #endif
 }
 
-void SDLCALLCC Mix_ADLMIDI_setVibrato(int vib)
+void MIXCALLCC Mix_ADLMIDI_setVibrato(int vib)
 {
 #ifdef MUSIC_MID_ADLMIDI
     _Mix_ADLMIDI_setVibrato(vib);
@@ -3293,7 +3293,7 @@ void SDLCALLCC Mix_ADLMIDI_setVibrato(int vib)
 #endif
 }
 
-int SDLCALLCC Mix_ADLMIDI_getScaleMod(void)
+int MIXCALLCC Mix_ADLMIDI_getScaleMod(void)
 {
 #ifdef MUSIC_MID_ADLMIDI
     return _Mix_ADLMIDI_getScaleMod();
@@ -3302,7 +3302,7 @@ int SDLCALLCC Mix_ADLMIDI_getScaleMod(void)
 #endif
 }
 
-void SDLCALLCC Mix_ADLMIDI_setScaleMod(int sc)
+void MIXCALLCC Mix_ADLMIDI_setScaleMod(int sc)
 {
 #ifdef MUSIC_MID_ADLMIDI
     _Mix_ADLMIDI_setScaleMod(sc);
@@ -3311,7 +3311,7 @@ void SDLCALLCC Mix_ADLMIDI_setScaleMod(int sc)
 #endif
 }
 
-int SDLCALLCC Mix_ADLMIDI_getVolumeModel(void)
+int MIXCALLCC Mix_ADLMIDI_getVolumeModel(void)
 {
 #ifdef MUSIC_MID_ADLMIDI
     return _Mix_ADLMIDI_getVolumeModel();
@@ -3320,7 +3320,7 @@ int SDLCALLCC Mix_ADLMIDI_getVolumeModel(void)
 #endif
 }
 
-void SDLCALLCC Mix_ADLMIDI_setVolumeModel(int vm)
+void MIXCALLCC Mix_ADLMIDI_setVolumeModel(int vm)
 {
 #ifdef MUSIC_MID_ADLMIDI
     _Mix_ADLMIDI_setVolumeModel(vm);
@@ -3329,7 +3329,7 @@ void SDLCALLCC Mix_ADLMIDI_setVolumeModel(int vm)
 #endif
 }
 
-int SDLCALLCC Mix_ADLMIDI_getFullRangeBrightness(void)
+int MIXCALLCC Mix_ADLMIDI_getFullRangeBrightness(void)
 {
 #ifdef MUSIC_MID_ADLMIDI
     return _Mix_ADLMIDI_getFullRangeBrightness();
@@ -3338,7 +3338,7 @@ int SDLCALLCC Mix_ADLMIDI_getFullRangeBrightness(void)
 #endif
 }
 
-void SDLCALLCC Mix_ADLMIDI_setFullRangeBrightness(int frb)
+void MIXCALLCC Mix_ADLMIDI_setFullRangeBrightness(int frb)
 {
 #ifdef MUSIC_MID_ADLMIDI
     _Mix_ADLMIDI_setFullRangeBrightness(frb);
@@ -3347,7 +3347,7 @@ void SDLCALLCC Mix_ADLMIDI_setFullRangeBrightness(int frb)
 #endif
 }
 
-int SDLCALLCC Mix_ADLMIDI_getAutoArpeggio(void)
+int MIXCALLCC Mix_ADLMIDI_getAutoArpeggio(void)
 {
 #ifdef MUSIC_MID_ADLMIDI
     return _Mix_ADLMIDI_getAutoArpeggio();
@@ -3356,7 +3356,7 @@ int SDLCALLCC Mix_ADLMIDI_getAutoArpeggio(void)
 #endif
 }
 
-void SDLCALLCC Mix_ADLMIDI_setAutoArpeggio(int aa_en)
+void MIXCALLCC Mix_ADLMIDI_setAutoArpeggio(int aa_en)
 {
 #ifdef MUSIC_MID_ADLMIDI
     _Mix_ADLMIDI_setAutoArpeggio(aa_en);
@@ -3365,7 +3365,7 @@ void SDLCALLCC Mix_ADLMIDI_setAutoArpeggio(int aa_en)
 #endif
 }
 
-int SDLCALLCC Mix_ADLMIDI_getFullPanStereo(void)
+int MIXCALLCC Mix_ADLMIDI_getFullPanStereo(void)
 {
 #ifdef MUSIC_MID_ADLMIDI
     return _Mix_ADLMIDI_getFullPanStereo();
@@ -3374,7 +3374,7 @@ int SDLCALLCC Mix_ADLMIDI_getFullPanStereo(void)
 #endif
 }
 
-void SDLCALLCC Mix_ADLMIDI_setFullPanStereo(int fp)
+void MIXCALLCC Mix_ADLMIDI_setFullPanStereo(int fp)
 {
 #ifdef MUSIC_MID_ADLMIDI
     _Mix_ADLMIDI_setFullPanStereo(fp);
@@ -3383,7 +3383,7 @@ void SDLCALLCC Mix_ADLMIDI_setFullPanStereo(int fp)
 #endif
 }
 
-int SDLCALLCC Mix_ADLMIDI_getEmulator(void)
+int MIXCALLCC Mix_ADLMIDI_getEmulator(void)
 {
 #ifdef MUSIC_MID_ADLMIDI
     return _Mix_ADLMIDI_getEmulator();
@@ -3392,7 +3392,7 @@ int SDLCALLCC Mix_ADLMIDI_getEmulator(void)
 #endif
 }
 
-void SDLCALLCC Mix_ADLMIDI_setEmulator(int emu)
+void MIXCALLCC Mix_ADLMIDI_setEmulator(int emu)
 {
 #ifdef MUSIC_MID_ADLMIDI
     _Mix_ADLMIDI_setEmulator(emu);
@@ -3401,7 +3401,7 @@ void SDLCALLCC Mix_ADLMIDI_setEmulator(int emu)
 #endif
 }
 
-int SDLCALLCC Mix_ADLMIDI_getChipsCount(void)
+int MIXCALLCC Mix_ADLMIDI_getChipsCount(void)
 {
 #ifdef MUSIC_MID_ADLMIDI
     return _Mix_ADLMIDI_getChipsCount();
@@ -3410,7 +3410,7 @@ int SDLCALLCC Mix_ADLMIDI_getChipsCount(void)
 #endif
 }
 
-void SDLCALLCC Mix_ADLMIDI_setChipsCount(int chips)
+void MIXCALLCC Mix_ADLMIDI_setChipsCount(int chips)
 {
 #ifdef MUSIC_MID_ADLMIDI
     _Mix_ADLMIDI_setChipsCount(chips);
@@ -3419,14 +3419,14 @@ void SDLCALLCC Mix_ADLMIDI_setChipsCount(int chips)
 #endif
 }
 
-void SDLCALLCC Mix_ADLMIDI_setSetDefaults(void)
+void MIXCALLCC Mix_ADLMIDI_setSetDefaults(void)
 {
 #ifdef MUSIC_MID_ADLMIDI
     _Mix_ADLMIDI_setSetDefaults();
 #endif
 }
 
-void SDLCALLCC Mix_ADLMIDI_setCustomBankFile(const char *bank_wonl_path)
+void MIXCALLCC Mix_ADLMIDI_setCustomBankFile(const char *bank_wonl_path)
 {
 #ifdef MUSIC_MID_ADLMIDI
     _Mix_ADLMIDI_setCustomBankFile(bank_wonl_path);
@@ -3439,7 +3439,7 @@ void SDLCALLCC Mix_ADLMIDI_setCustomBankFile(const char *bank_wonl_path)
 
 /* OPNMIDI module setup calls */
 
-int SDLCALLCC Mix_OPNMIDI_getVolumeModel(void)
+int MIXCALLCC Mix_OPNMIDI_getVolumeModel(void)
 {
 #ifdef MUSIC_MID_OPNMIDI
     return _Mix_OPNMIDI_getVolumeModel();
@@ -3448,7 +3448,7 @@ int SDLCALLCC Mix_OPNMIDI_getVolumeModel(void)
 #endif
 }
 
-void SDLCALLCC Mix_OPNMIDI_setVolumeModel(int vm)
+void MIXCALLCC Mix_OPNMIDI_setVolumeModel(int vm)
 {
 #ifdef MUSIC_MID_OPNMIDI
     _Mix_OPNMIDI_setVolumeModel(vm);
@@ -3457,7 +3457,7 @@ void SDLCALLCC Mix_OPNMIDI_setVolumeModel(int vm)
 #endif
 }
 
-int SDLCALLCC Mix_OPNMIDI_getFullRangeBrightness(void)
+int MIXCALLCC Mix_OPNMIDI_getFullRangeBrightness(void)
 {
 #ifdef MUSIC_MID_OPNMIDI
     return _Mix_OPNMIDI_getFullRangeBrightness();
@@ -3466,7 +3466,7 @@ int SDLCALLCC Mix_OPNMIDI_getFullRangeBrightness(void)
 #endif
 }
 
-void SDLCALLCC Mix_OPNMIDI_setFullRangeBrightness(int frb)
+void MIXCALLCC Mix_OPNMIDI_setFullRangeBrightness(int frb)
 {
 #ifdef MUSIC_MID_OPNMIDI
     _Mix_OPNMIDI_setFullRangeBrightness(frb);
@@ -3475,7 +3475,7 @@ void SDLCALLCC Mix_OPNMIDI_setFullRangeBrightness(int frb)
 #endif
 }
 
-int SDLCALLCC Mix_OPNMIDI_getAutoArpeggio(void)
+int MIXCALLCC Mix_OPNMIDI_getAutoArpeggio(void)
 {
 #ifdef MUSIC_MID_OPNMIDI
     return _Mix_OPNMIDI_getAutoArpeggio();
@@ -3484,7 +3484,7 @@ int SDLCALLCC Mix_OPNMIDI_getAutoArpeggio(void)
 #endif
 }
 
-void SDLCALLCC Mix_OPNMIDI_setAutoArpeggio(int aa_en)
+void MIXCALLCC Mix_OPNMIDI_setAutoArpeggio(int aa_en)
 {
 #ifdef MUSIC_MID_OPNMIDI
     _Mix_OPNMIDI_setAutoArpeggio(aa_en);
@@ -3493,7 +3493,7 @@ void SDLCALLCC Mix_OPNMIDI_setAutoArpeggio(int aa_en)
 #endif
 }
 
-int SDLCALLCC Mix_OPNMIDI_getFullPanStereo(void)
+int MIXCALLCC Mix_OPNMIDI_getFullPanStereo(void)
 {
 #ifdef MUSIC_MID_OPNMIDI
     return _Mix_OPNMIDI_getFullPanStereo();
@@ -3502,7 +3502,7 @@ int SDLCALLCC Mix_OPNMIDI_getFullPanStereo(void)
 #endif
 }
 
-void SDLCALLCC Mix_OPNMIDI_setFullPanStereo(int fp)
+void MIXCALLCC Mix_OPNMIDI_setFullPanStereo(int fp)
 {
 #ifdef MUSIC_MID_OPNMIDI
     _Mix_OPNMIDI_setFullPanStereo(fp);
@@ -3511,7 +3511,7 @@ void SDLCALLCC Mix_OPNMIDI_setFullPanStereo(int fp)
 #endif
 }
 
-int SDLCALLCC Mix_OPNMIDI_getEmulator(void)
+int MIXCALLCC Mix_OPNMIDI_getEmulator(void)
 {
 #ifdef MUSIC_MID_OPNMIDI
     return _Mix_OPNMIDI_getEmulator();
@@ -3520,7 +3520,7 @@ int SDLCALLCC Mix_OPNMIDI_getEmulator(void)
 #endif
 }
 
-void SDLCALLCC Mix_OPNMIDI_setEmulator(int emu)
+void MIXCALLCC Mix_OPNMIDI_setEmulator(int emu)
 {
 #ifdef MUSIC_MID_OPNMIDI
     _Mix_OPNMIDI_setEmulator(emu);
@@ -3529,7 +3529,7 @@ void SDLCALLCC Mix_OPNMIDI_setEmulator(int emu)
 #endif
 }
 
-int SDLCALLCC Mix_OPNMIDI_getChipsCount(void)
+int MIXCALLCC Mix_OPNMIDI_getChipsCount(void)
 {
 #ifdef MUSIC_MID_OPNMIDI
     return _Mix_OPNMIDI_getChipsCount();
@@ -3538,7 +3538,7 @@ int SDLCALLCC Mix_OPNMIDI_getChipsCount(void)
 #endif
 }
 
-void SDLCALLCC Mix_OPNMIDI_setChipsCount(int chips)
+void MIXCALLCC Mix_OPNMIDI_setChipsCount(int chips)
 {
 #ifdef MUSIC_MID_OPNMIDI
     _Mix_OPNMIDI_setChipsCount(chips);
@@ -3547,14 +3547,14 @@ void SDLCALLCC Mix_OPNMIDI_setChipsCount(int chips)
 #endif
 }
 
-void SDLCALLCC Mix_OPNMIDI_setSetDefaults(void)
+void MIXCALLCC Mix_OPNMIDI_setSetDefaults(void)
 {
 #ifdef MUSIC_MID_OPNMIDI
     _Mix_OPNMIDI_setSetDefaults();
 #endif
 }
 
-void SDLCALLCC Mix_OPNMIDI_setCustomBankFile(const char *bank_wonp_path)
+void MIXCALLCC Mix_OPNMIDI_setCustomBankFile(const char *bank_wonp_path)
 {
 #ifdef MUSIC_MID_OPNMIDI
     _Mix_OPNMIDI_setCustomBankFile(bank_wonp_path);