gosu 1.3.0 → 1.4.3

data/dependencies/SDL_sound/SDL_sound.c

@@ -19,6 +19,7 @@
 /* The various decoder drivers... */
 
 /* All these externs may be missing; we check SOUND_SUPPORTS_xxx before use. */
+extern const Sound_DecoderFunctions __Sound_DecoderFunctions_MIDI;
 extern const Sound_DecoderFunctions __Sound_DecoderFunctions_MODPLUG;
 extern const Sound_DecoderFunctions __Sound_DecoderFunctions_MP3;
 extern const Sound_DecoderFunctions __Sound_DecoderFunctions_WAV;
@@ -29,17 +30,19 @@ extern const Sound_DecoderFunctions __Sound_DecoderFunctions_VOC;
 extern const Sound_DecoderFunctions __Sound_DecoderFunctions_RAW;
 extern const Sound_DecoderFunctions __Sound_DecoderFunctions_SHN;
 extern const Sound_DecoderFunctions __Sound_DecoderFunctions_FLAC;
-extern const Sound_DecoderFunctions __Sound_DecoderFunctions_QuickTime;
 extern const Sound_DecoderFunctions __Sound_DecoderFunctions_CoreAudio;
 
 typedef struct
 {
-    int available;
+    SDL_bool available;
     const Sound_DecoderFunctions *funcs;
 } decoder_element;
 
 static decoder_element decoders[] =
 {
+#if SOUND_SUPPORTS_MIDI
+    { 0, &__Sound_DecoderFunctions_MIDI },
+#endif
 #if SOUND_SUPPORTS_MODPLUG
     { 0, &__Sound_DecoderFunctions_MODPLUG },
 #endif
@@ -81,17 +84,14 @@ static decoder_element decoders[] =
 
 /* General SDL_sound state ... */
 
-typedef struct __SOUND_ERRMSGTYPE__
+static SDL_TLSID tlsid_errmsg = 0;
+
+typedef struct
 {
-    Uint32 tid;
-    int error_available;
+    SDL_bool error_available;
     char error_string[128];
-    struct __SOUND_ERRMSGTYPE__ *next;
 } ErrMsg;
 
-static ErrMsg *error_msgs = NULL;
-static SDL_mutex *errorlist_mutex = NULL;
-
 static Sound_Sample *sample_list = NULL;  /* this is a linked list. */
 static SDL_mutex *samplelist_mutex = NULL;
 
@@ -120,7 +120,6 @@ int Sound_Init(void)
     BAIL_IF_MACRO(initialized, ERR_IS_INITIALIZED, 0);
 
     sample_list = NULL;
-    error_msgs = NULL;
 
     available_decoders = (const Sound_DecoderInfo **)
                             SDL_calloc(total, sizeof (Sound_DecoderInfo *));
@@ -128,7 +127,8 @@ int Sound_Init(void)
 
     SDL_InitSubSystem(SDL_INIT_AUDIO);
 
-    errorlist_mutex = SDL_CreateMutex();
+    tlsid_errmsg = SDL_TLSCreate();
+
     samplelist_mutex = SDL_CreateMutex();
 
     for (i = 0; decoders[i].funcs != NULL; i++)
@@ -148,8 +148,6 @@ int Sound_Init(void)
 
 int Sound_Quit(void)
 {
-    ErrMsg *err;
-    ErrMsg *nexterr = NULL;
     size_t i;
 
     BAIL_IF_MACRO(!initialized, ERR_NOT_INITIALIZED, 0);
@@ -176,17 +174,7 @@ int Sound_Quit(void)
         SDL_free((void *) available_decoders);
     available_decoders = NULL;
 
-    /* clean up error state for each thread... */
-    SDL_LockMutex(errorlist_mutex);
-    for (err = error_msgs; err != NULL; err = nexterr)
-    {
-        nexterr = err->next;
-        SDL_free(err);
-    } /* for */
-    error_msgs = NULL;
-    SDL_UnlockMutex(errorlist_mutex);
-    SDL_DestroyMutex(errorlist_mutex);
-    errorlist_mutex = NULL;
+    tlsid_errmsg = 0;
 
     return 1;
 } /* Sound_Quit */
@@ -200,27 +188,8 @@ const Sound_DecoderInfo **Sound_AvailableDecoders(void)
 
 static ErrMsg *findErrorForCurrentThread(void)
 {
-    ErrMsg *i;
-    Uint32 tid;
-
-    if (error_msgs != NULL)
-    {
-        tid = SDL_ThreadID();
-
-        SDL_LockMutex(errorlist_mutex);
-        for (i = error_msgs; i != NULL; i = i->next)
-        {
-            if (i->tid == tid)
-            {
-                SDL_UnlockMutex(errorlist_mutex);
-                return i;
-            } /* if */
-        } /* for */
-        SDL_UnlockMutex(errorlist_mutex);
-    } /* if */
-
-    return NULL;   /* no error available. */
-} /* findErrorForCurrentThread */
+    return (ErrMsg *) SDL_TLSGet(tlsid_errmsg);
+}
 
 
 const char *Sound_GetError(void)
@@ -235,7 +204,7 @@ const char *Sound_GetError(void)
     if ((err != NULL) && (err->error_available))
     {
         retval = err->error_string;
-        err->error_available = 0;
+        err->error_available = SDL_FALSE;
     } /* if */
 
     return retval;
@@ -244,15 +213,14 @@ const char *Sound_GetError(void)
 
 void Sound_ClearError(void)
 {
-    ErrMsg *err;
+    Sound_GetError();  /* this will set error_available to SDL_FALSE */
+} /* Sound_ClearError */
 
-    if (!initialized)
-        return;
 
-    err = findErrorForCurrentThread();
-    if (err != NULL)
-        err->error_available = 0;
-} /* Sound_ClearError */
+static void SDLCALL free_errmsg(void *errmsg)
+{
+    SDL_free(errmsg);
+} /* free_errmsg */
 
 
 /*
@@ -265,8 +233,7 @@ void __Sound_SetError(const char *str)
     if (str == NULL)
         return;
 
-    SNDDBG(("__Sound_SetError(\"%s\");%s\n", str,
-              (initialized) ? "" : " [NOT INITIALIZED!]"));
+    SNDDBG(("__Sound_SetError(\"%s\");%s\n", str, (initialized) ? "" : " [NOT INITIALIZED!]"));
 
     if (!initialized)
         return;
@@ -278,15 +245,10 @@ void __Sound_SetError(const char *str)
         if (err == NULL)
             return;   /* uhh...? */
 
-        err->tid = SDL_ThreadID();
-
-        SDL_LockMutex(errorlist_mutex);
-        err->next = error_msgs;
-        error_msgs = err;
-        SDL_UnlockMutex(errorlist_mutex);
+        SDL_TLSSet(tlsid_errmsg, err, free_errmsg);
     } /* if */
 
-    err->error_available = 1;
+    err->error_available = SDL_TRUE;
     SDL_strlcpy(err->error_string, str, sizeof (err->error_string));
 } /* __Sound_SetError */
 
@@ -348,8 +310,7 @@ static Sound_Sample *alloc_sample(SDL_RWops *rw, Sound_AudioInfo *desired,
 #if (defined DEBUG_CHATTER)
 static SDL_INLINE const char *fmt_to_str(Uint16 fmt)
 {
-    switch(fmt)
-    {
+    switch(fmt) {
         case AUDIO_U8:
             return "U8";
         case AUDIO_S8:
@@ -371,7 +332,6 @@ static SDL_INLINE const char *fmt_to_str(Uint16 fmt)
         case AUDIO_F32MSB:
             return "F32MSB";
     } /* switch */
-
     return "Unknown";
 } /* fmt_to_str */
 #endif
@@ -389,14 +349,14 @@ static int init_sample(const Sound_DecoderFunctions *funcs,
 {
     Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
     Sound_AudioInfo desired;
-    int pos = SDL_RWtell(internal->rw);
+    const Sint64 pos = SDL_RWtell(internal->rw);
 
         /* fill in the funcs for this decoder... */
     sample->decoder = &funcs->info;
     internal->funcs = funcs;
     if (!funcs->open(sample, ext))
     {
-        SDL_RWseek(internal->rw, pos, SEEK_SET);  /* set for next try... */
+        SDL_RWseek(internal->rw, pos, RW_SEEK_SET);     /* set for next try... */
         return 0;
     } /* if */
 
@@ -423,7 +383,7 @@ static int init_sample(const Sound_DecoderFunctions *funcs,
     {
         __Sound_SetError(SDL_GetError());
         funcs->close(sample);
-        SDL_RWseek(internal->rw, pos, SEEK_SET);  /* set for next try... */
+        SDL_RWseek(internal->rw, pos, RW_SEEK_SET);     /* set for next try... */
         return 0;
     } /* if */
 
@@ -433,7 +393,7 @@ static int init_sample(const Sound_DecoderFunctions *funcs,
         if (rc == NULL)
         {
             funcs->close(sample);
-            SDL_RWseek(internal->rw, pos, SEEK_SET);  /* set for next try... */
+            SDL_RWseek(internal->rw, pos, RW_SEEK_SET); /* set for next try... */
             return 0;
         } /* if */
 
@@ -517,7 +477,7 @@ Sound_Sample *Sound_NewSample(SDL_RWops *rw, const char *ext,
                 /* skip if we would have tried decoder above... */
             while (*decoderExt)
             {
-                if (SDL_strcasecmp(*decoderExt, ext) == 0)
+                if (ext && SDL_strcasecmp(*decoderExt, ext) == 0)
                 {
                     should_try = 0;
                     break;
@@ -791,5 +751,79 @@ Sint32 Sound_GetDuration(Sound_Sample *sample)
     return internal->total_time;
 } /* Sound_GetDuration */
 
+
+/* Utility functions ... */
+
+/* The following uses the implementation suggested by
+ * the standard document, assumes RAND_MAX == 32767 */
+static unsigned long __Sound_seed = 1;
+int __Sound_rand(void)
+{
+    __Sound_seed = __Sound_seed * 1103515245 + 12345;
+    return (__Sound_seed / 65536) % 32768;
+}
+void __Sound_srand(unsigned int seed)
+{
+    __Sound_seed = seed;
+}
+
+#if !defined(HAVE_SDL_STRTOKR)
+/* Adapted from _PDCLIB_strtok() of PDClib library at
+ * https://github.com/DevSolar/pdclib.git
+ *
+ * The code was under CC0 license:
+ * https://creativecommons.org/publicdomain/zero/1.0/legalcode
+ */
+char *__Sound_strtokr(char *s1, const char *s2, char **ptr)
+{
+    const char *p = s2;
+
+    if (!s2 || !ptr || (!s1 && !*ptr)) return NULL;
+
+    if (s1 != NULL) {  /* new string */
+        *ptr = s1;
+    } else { /* old string continued */
+        if (*ptr == NULL) {
+        /* No old string, no new string, nothing to do */
+            return NULL;
+        }
+        s1 = *ptr;
+    }
+
+    /* skip leading s2 characters */
+    while (*p && *s1) {
+        if (*s1 == *p) {
+        /* found separator; skip and start over */
+            ++s1;
+            p = s2;
+            continue;
+        }
+        ++p;
+    }
+
+    if (! *s1) { /* no more to parse */
+        *ptr = s1;
+        return NULL;
+    }
+
+    /* skipping non-s2 characters */
+    *ptr = s1;
+    while (**ptr) {
+        p = s2;
+        while (*p) {
+            if (**ptr == *p++) {
+            /* found separator; overwrite with '\0', position *ptr, return */
+                *((*ptr)++) = '\0';
+                return s1;
+            }
+        }
+        ++(*ptr);
+    }
+
+    /* parsed to end of string */
+    return s1;
+}
+#endif
+
 /* end of SDL_sound.c ... */
 

data/dependencies/SDL_sound/SDL_sound.h

@@ -62,16 +62,16 @@ extern "C" {
 
 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
-#ifdef SDL_SOUND_DLL_EXPORTS
+#if defined(SDL_SOUND_DLL_EXPORTS) && (defined(_WIN32) || defined(__OS2__))
 #  define SNDDECLSPEC __declspec(dllexport)
-#elif (__GNUC__ >= 3)
+#elif ((defined(__GNUC__) && (__GNUC__ >= 4)) || defined(__clang__)) && !(defined(_WIN32) || defined(__OS2__))
 #  define SNDDECLSPEC __attribute__((visibility("default")))
 #else
 #  define SNDDECLSPEC
 #endif
 
-#define SOUND_VER_MAJOR 1
-#define SOUND_VER_MINOR 9
+#define SOUND_VER_MAJOR 2
+#define SOUND_VER_MINOR 0
 #define SOUND_VER_PATCH 0
 #endif
 
@@ -696,8 +696,8 @@ SNDDECLSPEC int SDLCALL Sound_Rewind(Sound_Sample *sample);
  *
  * This function can be emulated in the application with Sound_Rewind()
  *  and predecoding a specific amount of the sample, but this can be
- *  extremely inefficient. Sound_Seek() accelerates the seek on a
- *  with decoder-specific code.
+ *  extremely inefficient. Sound_Seek() accelerates the seek with
+ *  decoder-specific code.
  *
  * If this function fails, the sample should continue to function as if
  *  this call was never made. If there was an unrecoverable error,

data/dependencies/SDL_sound/SDL_sound_aiff.c

@@ -38,8 +38,8 @@ typedef struct S_AIFF_FMT_T
 {
     Uint32 type;
 
-    Uint32 total_bytes;
-    Uint32 data_starting_offset;
+    Sint64 total_bytes;
+    Sint64 data_starting_offset;
 
     void (*free)(struct S_AIFF_FMT_T *fmt);
     Uint32 (*read_sample)(Sound_Sample *sample);
@@ -49,7 +49,7 @@ typedef struct S_AIFF_FMT_T
 
 #if 0
 /*
-   this is ripped from wav.c as ann example of format-specific data.
+   this is ripped from wav.c as an example of format-specific data.
    please replace with something more appropriate when the need arises.
 */
     union
@@ -177,8 +177,7 @@ static int read_comm_chunk(SDL_RWops *rw, comm_t *comm)
         return 0;
     comm->numChannels = SDL_SwapBE16(comm->numChannels);
 
-    if (SDL_RWread(rw, &comm->numSampleFrames,
-                   sizeof (comm->numSampleFrames), 1) != 1)
+    if (SDL_RWread(rw, &comm->numSampleFrames, sizeof (comm->numSampleFrames), 1) != 1)
         return 0;
     comm->numSampleFrames = SDL_SwapBE32(comm->numSampleFrames);
 
@@ -245,7 +244,7 @@ static int read_ssnd_chunk(SDL_RWops *rw, ssnd_t *ssnd)
     ssnd->blockSize = SDL_SwapBE32(ssnd->blockSize);
 
     /* Leave the SDL_RWops position indicator at the start of the samples */
-    if (SDL_RWseek(rw, (int) ssnd->offset, SEEK_CUR) == -1)
+    if (SDL_RWseek(rw, ssnd->offset, RW_SEEK_CUR) == -1)
         return 0;
 
     return 1;
@@ -262,8 +261,7 @@ static Uint32 read_sample_fmt_normal(Sound_Sample *sample)
     Uint32 retval;
     Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
     aiff_t *a = (aiff_t *) internal->decoder_private;
-    Uint32 max = (internal->buffer_size < (Uint32) a->bytesLeft) ?
-                    internal->buffer_size : (Uint32) a->bytesLeft;
+    const Uint32 max = SDL_min(internal->buffer_size, (Uint32) a->bytesLeft);
 
     SDL_assert(max > 0);
 
@@ -279,7 +277,7 @@ static Uint32 read_sample_fmt_normal(Sound_Sample *sample)
     if ((retval == 0) || (a->bytesLeft == 0))
         sample->flags |= SOUND_SAMPLEFLAG_EOF;
 
-    else if (retval == -1)
+    else if (retval == -1) /** FIXME: this error check is broken **/
         sample->flags |= SOUND_SAMPLEFLAG_ERROR;
 
         /* (next call this EAGAIN may turn into an EOF or error.) */
@@ -301,10 +299,10 @@ static int seek_sample_fmt_normal(Sound_Sample *sample, Uint32 ms)
 {
     Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
     aiff_t *a = (aiff_t *) internal->decoder_private;
-    fmt_t *fmt = &a->fmt;
-    int offset = __Sound_convertMsToBytePos(&sample->actual, ms);
-    int pos = (int) (fmt->data_starting_offset + offset);
-    int rc = SDL_RWseek(internal->rw, pos, SEEK_SET);
+    const fmt_t *fmt = &a->fmt;
+    const Uint32 offset = __Sound_convertMsToBytePos(&sample->actual, ms);
+    const Sint64 pos = (Sint64) (fmt->data_starting_offset + offset);
+    const Sint64 rc = SDL_RWseek(internal->rw, pos, RW_SEEK_SET);
     BAIL_IF_MACRO(rc != pos, ERR_IO_ERROR, 0);
     a->bytesLeft = fmt->total_bytes - offset;
     return 1;  /* success. */
@@ -334,9 +332,9 @@ static int read_fmt_normal(SDL_RWops *rw, fmt_t *fmt)
  * Everything else...                                                        *
  *****************************************************************************/
 
-static int AIFF_init(void)
+static SDL_bool AIFF_init(void)
 {
-    return 1;  /* always succeeds. */
+    return SDL_TRUE;  /* always succeeds. */
 } /* AIFF_init */
 
 
@@ -360,7 +358,7 @@ static int find_chunk(SDL_RWops *rw, Uint32 id)
         BAIL_IF_MACRO(SDL_RWread(rw, &siz, sizeof (siz), 1) != 1, NULL, 0);
         siz = SDL_SwapBE32(siz);
         SDL_assert(siz > 0);
-        BAIL_IF_MACRO(SDL_RWseek(rw, siz, SEEK_CUR) == -1, NULL, 0);
+        BAIL_IF_MACRO(SDL_RWseek(rw, siz, RW_SEEK_CUR) == -1, NULL, 0);
     } /* while */
 
     return 0;  /* shouldn't hit this, but just in case... */
@@ -380,14 +378,11 @@ static int read_fmt(SDL_RWops *rw, comm_t *c, fmt_t *fmt)
 
         /* add other types here. */
 
-        default:
-            SNDDBG(("AIFF: Format %lu is unknown.\n",
-                    (unsigned int) fmt->type));
-            BAIL_MACRO("AIFF: Unsupported format", 0);
     } /* switch */
 
-    SDL_assert(0);  /* shouldn't hit this point. */
-    return 0;
+    SNDDBG(("AIFF: Format %u is unknown.\n",
+            (unsigned int) fmt->type));
+    BAIL_MACRO("AIFF: Unsupported format", 0);
 } /* read_fmt */
 
 
@@ -396,8 +391,8 @@ static int AIFF_open(Sound_Sample *sample, const char *ext)
     Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
     SDL_RWops *rw = internal->rw;
     Uint32 chunk_id;
-    int bytes_per_sample;
-    long pos;
+    Uint32 bytes_per_sample;
+    Sint64 pos;
     comm_t c;
     ssnd_t s;
     aiff_t *a;
@@ -416,14 +411,11 @@ static int AIFF_open(Sound_Sample *sample, const char *ext)
     BAIL_IF_MACRO(!read_comm_chunk(rw, &c),
                   "AIFF: Can't read common chunk.", 0);
 
+    BAIL_IF_MACRO(c.numChannels == 0, "AIFF: no channels specified.", 0);
+
     sample->actual.channels = (Uint8) c.numChannels;
     sample->actual.rate = c.sampleRate;
 
-    /* Really, sample->total_time = (c.numSampleFrames*1000) c.sampleRate */
-    internal->total_time = (c.numSampleFrames / c.sampleRate) * 1000;
-    internal->total_time += (c.numSampleFrames % c.sampleRate)
-                             *  1000 / c.sampleRate;
-
     if (c.sampleSize <= 8)
     {
         sample->actual.format = AUDIO_S8;
@@ -450,7 +442,7 @@ static int AIFF_open(Sound_Sample *sample, const char *ext)
         return 0;
     } /* if */
 
-    SDL_RWseek(rw, pos, SEEK_SET);    /* if the seek fails, let it go... */
+    SDL_RWseek(rw, pos, RW_SEEK_SET);   /* if the seek fails, let it go... */
 
     if (!find_chunk(rw, ssndID))
     {
@@ -464,6 +456,14 @@ static int AIFF_open(Sound_Sample *sample, const char *ext)
         BAIL_MACRO("AIFF: Can't read sound data chunk.", 0);
     } /* if */
 
+    if (c.numSampleFrames == 0)
+        c.numSampleFrames = (s.ckDataSize - 8) / bytes_per_sample;
+
+    /* Really, sample->total_time = (c.numSampleFrames*1000) c.sampleRate */
+    internal->total_time = (c.numSampleFrames / c.sampleRate) * 1000;
+    internal->total_time += (c.numSampleFrames % c.sampleRate) *  1000 / c.sampleRate;
+
+
     a->fmt.total_bytes = a->bytesLeft = bytes_per_sample * c.numSampleFrames;
     a->fmt.data_starting_offset = SDL_RWtell(rw);
     internal->decoder_private = (void *) a;
@@ -496,8 +496,8 @@ static int AIFF_rewind(Sound_Sample *sample)
 {
     Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
     aiff_t *a = (aiff_t *) internal->decoder_private;
-    fmt_t *fmt = &a->fmt;
-    int rc = SDL_RWseek(internal->rw, fmt->data_starting_offset, SEEK_SET);
+    const fmt_t *fmt = &a->fmt;
+    const Sint64 rc = SDL_RWseek(internal->rw, fmt->data_starting_offset, RW_SEEK_SET);
     BAIL_IF_MACRO(rc != fmt->data_starting_offset, ERR_IO_ERROR, 0);
     a->bytesLeft = fmt->total_bytes;
     return fmt->rewind_sample(sample);

data/dependencies/SDL_sound/SDL_sound_au.c

@@ -18,9 +18,9 @@
 #if SOUND_SUPPORTS_AU
 
 /* no init/deinit needed */
-static int AU_init(void)
+static SDL_bool AU_init(void)
 {
-    return 1;
+    return SDL_TRUE;
 } /* AU_init */
 
 static void AU_quit(void)
@@ -63,7 +63,7 @@ struct audec
 {
     Uint32 total;
     Uint32 remaining;
-    Uint32 start_offset;
+    Sint64 start_offset;
     int encoding;
 };
 
@@ -109,7 +109,7 @@ static int AU_open(Sound_Sample *sample, const char *ext)
 {
     Sound_SampleInternal *internal = sample->opaque;
     SDL_RWops *rw = internal->rw;
-    int skip, hsize, i, bytes_per_second;
+    int hsize, i, bytes_per_second;
     struct au_file_hdr hdr;
     struct audec *dec;
     char c;
@@ -163,7 +163,7 @@ static int AU_open(Sound_Sample *sample, const char *ext)
         } /* for */
     } /* if */
 
-    else if (SDL_strcasecmp(ext, "au") == 0)
+    else if (ext && SDL_strcasecmp(ext, "au") == 0)
     {
         /*
          * A number of files in the wild have the .au extension but no valid
@@ -173,9 +173,9 @@ static int AU_open(Sound_Sample *sample, const char *ext)
 
         SNDDBG(("AU: Invalid header, assuming raw 8kHz µ-law.\n"));
         /* if seeking fails, we lose 24 samples. big deal */
-        SDL_RWseek(rw, -HDR_SIZE, SEEK_CUR);
+        SDL_RWseek(rw, -HDR_SIZE, RW_SEEK_CUR);
         dec->encoding = AU_ENC_ULAW_8;
-        dec->remaining = (Uint32)-1; 		/* no limit */
+        dec->remaining = (Uint32)-1;		/* no limit */
         sample->actual.format = AUDIO_S16SYS;
         sample->actual.rate = 8000;
         sample->actual.channels = 1;
@@ -271,7 +271,7 @@ static Uint32 AU_read(Sound_Sample *sample)
     ret = SDL_RWread(internal->rw, buf, 1, maxlen);
     if (ret == 0)
         sample->flags |= SOUND_SAMPLEFLAG_EOF;
-    else if (ret == -1)
+    else if (ret == -1) /** FIXME: this error check is broken **/
         sample->flags |= SOUND_SAMPLEFLAG_ERROR;
     else
     {
@@ -297,7 +297,7 @@ static int AU_rewind(Sound_Sample *sample)
 {
     Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
     struct audec *dec = (struct audec *) internal->decoder_private;
-    int rc = SDL_RWseek(internal->rw, dec->start_offset, SEEK_SET);
+    const Sint64 rc = SDL_RWseek(internal->rw, dec->start_offset, RW_SEEK_SET);
     BAIL_IF_MACRO(rc != dec->start_offset, ERR_IO_ERROR, 0);
     dec->remaining = dec->total;
     return 1;
@@ -308,15 +308,15 @@ static int AU_seek(Sound_Sample *sample, Uint32 ms)
 {
     Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
     struct audec *dec = (struct audec *) internal->decoder_private;
-    int offset = __Sound_convertMsToBytePos(&sample->actual, ms);
-    int rc;
-    int pos;
+    Sint64 offset = __Sound_convertMsToBytePos(&sample->actual, ms);
+    Sint64 rc;
+    Sint64 pos;
 
     if (dec->encoding == AU_ENC_ULAW_8)
         offset >>= 1;  /* halve the byte offset for compression. */
 
-    pos = (int) (dec->start_offset + offset);
-    rc = SDL_RWseek(internal->rw, pos, SEEK_SET);
+    pos = (dec->start_offset + offset);
+    rc = SDL_RWseek(internal->rw, pos, RW_SEEK_SET);
     BAIL_IF_MACRO(rc != pos, ERR_IO_ERROR, 0);
     dec->remaining = dec->total - offset;
     return 1;

data/dependencies/SDL_sound/SDL_sound_coreaudio.c

@@ -23,9 +23,9 @@ typedef struct CoreAudioFileContainer
 } CoreAudioFileContainer;
 
 
-static int CoreAudio_init(void)
+static SDL_bool CoreAudio_init(void)
 {
-    return 1;  /* always succeeds. */
+    return SDL_TRUE;  /* always succeeds. */
 } /* CoreAudio_init */
 
 
@@ -193,11 +193,10 @@ static const char* CoreAudio_FourCCToString(int32_t error_code)
 SInt64 CoreAudio_SizeCallback(void* inClientData)
 {
 	SDL_RWops* rw_ops = (SDL_RWops*)inClientData;
-	SInt64 current_position = SDL_RWtell(rw_ops);
-	SInt64 end_position = SDL_RWseek(rw_ops, 0, SEEK_END);
-	SDL_RWseek(rw_ops, current_position, SEEK_SET);
+	const Sint64 current_position = SDL_RWtell(rw_ops);
+	const Sint64 end_position = SDL_RWseek(rw_ops, 0, RW_SEEK_END);
+	SDL_RWseek(rw_ops, current_position, RW_SEEK_SET);
 //	fprintf(stderr, "CoreAudio_SizeCallback:%d\n", end_position);
-
 	return end_position;
 }
 
@@ -210,7 +209,7 @@ OSStatus CoreAudio_ReadCallback(
 )
 {
 	SDL_RWops* rw_ops = (SDL_RWops*)inClientData;
-	SDL_RWseek(rw_ops, inPosition, SEEK_SET);
+	SDL_RWseek(rw_ops, inPosition, RW_SEEK_SET);
 	size_t bytes_actually_read = SDL_RWread(rw_ops, data_buffer, 1, requestCount);
 	// Not sure how to test for a read error with SDL_RWops
 //	fprintf(stderr, "CoreAudio_ReadCallback:%d, %d\n", requestCount, bytes_actually_read);