gosu 0.15.2 → 1.0.0.pre1

data/dependencies/SDL_sound/SDL_sound_modplug.c

@@ -0,0 +1,228 @@
+/**
+ * SDL_sound; An abstract sound format decoding API.
+ *
+ * Please see the file LICENSE.txt in the source's root directory.
+ *
+ *  This file written by Torbjörn Andersson.
+ */
+
+/*
+ * Module player for SDL_sound. This driver handles anything that ModPlug does.
+ *
+ * ModPlug can be found at https://sourceforge.net/projects/modplug-xmms
+ *
+ * An unofficial version of modplug with all C++ dependencies removed is also
+ *  available:  http://freecraft.net/snapshots/
+ *  (Look for something like "libmodplug-johns-*.tar.gz")
+ *  (update: this domain is gone.  --ryan.)
+ */
+
+#define __SDL_SOUND_INTERNAL__
+#include "SDL_sound_internal.h"
+
+#if SOUND_SUPPORTS_MODPLUG
+
+#include "libmodplug/modplug.h"
+
+static const char *extensions_modplug[] =
+{
+        /* The XMMS plugin is apparently able to load compressed modules as
+         * well, but libmodplug does not handle this.
+         */
+    "669",   /* Composer 669 / UNIS 669 module                              */
+    "AMF",   /* ASYLUM Music Format / Advanced Music Format(DSM)            */
+    "AMS",   /* AMS module                                                  */
+    "DBM",   /* DigiBooster Pro Module                                      */
+    "DMF",   /* DMF DELUSION DIGITAL MUSIC FILEFORMAT (X-Tracker)           */
+    "DSM",   /* DSIK Internal Format module                                 */
+    "FAR",   /* Farandole module                                            */
+    "IT",    /* Impulse Tracker IT file                                     */
+    "MDL",   /* DigiTracker module                                          */
+    "MED",   /* OctaMed MED file                                            */
+    "MOD",   /* ProTracker / NoiseTracker MOD/NST file                      */
+    "MT2",   /* MadTracker 2.0                                              */
+    "MTM",   /* MTM file                                                    */
+    "OKT",   /* Oktalyzer module                                            */
+    "PTM",   /* PTM PolyTracker module                                      */
+    "PSM",   /* PSM module                                                  */
+    "S3M",   /* ScreamTracker file                                          */
+    "STM",   /* ST 2.xx                                                     */
+    "ULT",   
+    "UMX",
+    "XM",    /* FastTracker II                                              */
+    "ABC",
+    "MID",
+    "MIDI",
+    NULL
+};
+
+
+
+static int MODPLUG_init(void)
+{
+    return ModPlug_Init();  /* success. */
+} /* MODPLUG_init */
+
+
+static void MODPLUG_quit(void)
+{
+    /* it's a no-op. */
+} /* MODPLUG_quit */
+
+
+/*
+ * Most MOD files I've seen have tended to be a few hundred KB, even if some
+ * of them were much smaller than that.
+ */
+#define CHUNK_SIZE 65536
+
+static int MODPLUG_open(Sound_Sample *sample, const char *ext)
+{
+    ModPlug_Settings settings;
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    ModPlugFile *module;
+    Uint8 *data;
+    size_t size;
+    Uint32 retval;
+    int has_extension = 0;
+    int i;
+
+    /*
+     * Apparently ModPlug's loaders are too forgiving. They gladly accept
+     *  streams that they shouldn't. For now, rely on file extension instead.
+     */
+    for (i = 0; extensions_modplug[i] != NULL; i++)
+    {
+        if (SDL_strcasecmp(ext, extensions_modplug[i]) == 0)
+        {
+            has_extension = 1;
+            break;
+        } /* if */
+    } /* for */
+
+    if (!has_extension)
+    {
+        SNDDBG(("MODPLUG: Unrecognized file type: %s\n", ext));
+        BAIL_MACRO("MODPLUG: Not a module file.", 0);
+    } /* if */
+    
+    /* ModPlug needs the entire stream in one big chunk. I don't like it,
+       but I don't think there's any way around it.  !!! FIXME: rework modplug? */
+    data = (Uint8 *) SDL_malloc(CHUNK_SIZE);
+    BAIL_IF_MACRO(data == NULL, ERR_OUT_OF_MEMORY, 0);
+    size = 0;
+
+    do
+    {
+        retval = SDL_RWread(internal->rw, &data[size], 1, CHUNK_SIZE);
+        size += retval;
+        if (retval == CHUNK_SIZE)
+        {
+            data = (Uint8 *) SDL_realloc(data, size + CHUNK_SIZE);
+            BAIL_IF_MACRO(data == NULL, ERR_OUT_OF_MEMORY, 0);
+        } /* if */
+    } while (retval > 0);
+
+    SDL_memcpy(&sample->actual, &sample->desired, sizeof (Sound_AudioInfo));
+    if (sample->actual.rate == 0) sample->actual.rate = 44100;
+    if (sample->actual.channels == 0) sample->actual.channels = 2;
+    if (sample->actual.format == 0) sample->actual.format = AUDIO_S16SYS;
+
+    settings.mChannels=sample->actual.channels;
+    settings.mFrequency=sample->actual.rate;
+    settings.mBits = sample->actual.format & 0xFF;
+
+    /* The settings will require some experimenting. I've borrowed some
+        of them from the XMMS ModPlug plugin. */
+    settings.mFlags = MODPLUG_ENABLE_OVERSAMPLING;
+    settings.mFlags |= MODPLUG_ENABLE_NOISE_REDUCTION |
+                       MODPLUG_ENABLE_MEGABASS |
+                       MODPLUG_ENABLE_SURROUND;
+
+    settings.mReverbDepth = 30;
+    settings.mReverbDelay = 100;
+    settings.mBassAmount = 40;
+    settings.mBassRange = 30;
+    settings.mSurroundDepth = 20;
+    settings.mSurroundDelay = 20;
+    settings.mChannels = 2;
+    settings.mBits = 16;
+    settings.mFrequency = 44100;
+    settings.mResamplingMode = MODPLUG_RESAMPLE_FIR;
+    settings.mLoopCount = 0;
+
+    /* The buffer may be a bit too large, but that doesn't matter. I think
+       it's safe to free it as soon as ModPlug_Load() is finished anyway. */
+    module = ModPlug_Load((void *) data, size, &settings);
+    SDL_free(data);
+    BAIL_IF_MACRO(module == NULL, "MODPLUG: Not a module file.", 0);
+
+    internal->total_time = ModPlug_GetLength(module);
+    internal->decoder_private = (void *) module;
+    sample->flags = SOUND_SAMPLEFLAG_CANSEEK;
+
+    SNDDBG(("MODPLUG: Accepting data stream\n"));
+    return 1; /* we'll handle this data. */
+} /* MODPLUG_open */
+
+
+static void MODPLUG_close(Sound_Sample *sample)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    ModPlugFile *module = (ModPlugFile *) internal->decoder_private;
+    ModPlug_Unload(module);
+} /* MODPLUG_close */
+
+
+static Uint32 MODPLUG_read(Sound_Sample *sample)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    ModPlugFile *module = (ModPlugFile *) internal->decoder_private;
+    int retval;
+    retval = ModPlug_Read(module, internal->buffer, internal->buffer_size);
+    if (retval == 0)
+        sample->flags |= SOUND_SAMPLEFLAG_EOF;
+    return retval;
+} /* MODPLUG_read */
+
+
+static int MODPLUG_rewind(Sound_Sample *sample)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    ModPlugFile *module = (ModPlugFile *) internal->decoder_private;
+    ModPlug_Seek(module, 0);
+    return 1;
+} /* MODPLUG_rewind */
+
+
+static int MODPLUG_seek(Sound_Sample *sample, Uint32 ms)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    ModPlugFile *module = (ModPlugFile *) internal->decoder_private;
+    ModPlug_Seek(module, ms);
+    return 1;
+} /* MODPLUG_seek */
+
+
+const Sound_DecoderFunctions __Sound_DecoderFunctions_MODPLUG =
+{
+    {
+        extensions_modplug,
+        "Play modules through ModPlug",
+        "Torbjörn Andersson <d91tan@Update.UU.SE>",
+        "http://modplug-xmms.sourceforge.net/"
+    },
+
+    MODPLUG_init,       /*   init() method */
+    MODPLUG_quit,       /*   quit() method */
+    MODPLUG_open,       /*   open() method */
+    MODPLUG_close,      /*  close() method */
+    MODPLUG_read,       /*   read() method */
+    MODPLUG_rewind,     /* rewind() method */
+    MODPLUG_seek        /*   seek() method */
+};
+
+#endif /* SOUND_SUPPORTS_MODPLUG */
+
+/* end of SDL_sound_modplug.c ... */
+

data/dependencies/SDL_sound/SDL_sound_mp3.c

@@ -0,0 +1,184 @@
+/**
+ * SDL_sound; An abstract sound format decoding API.
+ *
+ * Please see the file LICENSE.txt in the source's root directory.
+ *
+ *  This file written by Ryan C. Gordon.
+ */
+
+/*
+ * MP3 decoder for SDL_sound.
+ *
+ * !!! FIXME: write something here.
+ *
+ * dr_mp3 is here: https://github.com/mackron/dr_libs/
+ */
+
+#define __SDL_SOUND_INTERNAL__
+#include "SDL_sound_internal.h"
+
+#if SOUND_SUPPORTS_MP3
+
+#define DR_MP3_IMPLEMENTATION
+#define DR_MP3_NO_STDIO 1
+#define DRMP3_ASSERT(x) SDL_assert((x))
+#define DRMP3_MALLOC(sz) SDL_malloc((sz))
+#define DRMP3_REALLOC(p, sz) SDL_realloc((p), (sz))
+#define DRMP3_FREE(p) SDL_free((p))
+#define DRMP3_COPY_MEMORY(dst, src, sz) SDL_memcpy((dst), (src), (sz))
+#define DRMP3_ZERO_MEMORY(p, sz) SDL_memset((p), 0, (sz))
+
+#if !defined(__clang_analyzer__)
+#ifdef memset
+#undef memset
+#endif
+#ifdef memcpy
+#undef memcpy
+#endif
+#ifdef memmove
+#undef memmove
+#endif
+#define memset SDL_memset
+#define memcpy SDL_memcpy
+#define memmove SDL_memmove
+#endif
+
+#include "dr_mp3.h"
+
+static size_t mp3_read(void* pUserData, void* pBufferOut, size_t bytesToRead)
+{
+    Uint8 *ptr = (Uint8 *) pBufferOut;
+    Sound_Sample *sample = (Sound_Sample *) pUserData;
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    SDL_RWops *rwops = internal->rw;
+    size_t retval = 0;
+
+    /* !!! FIXME: dr_mp3 treats returning less than bytesToRead as EOF. So we can't EAGAIN. */
+    while (retval < bytesToRead)
+    {
+        const size_t rc = SDL_RWread(rwops, ptr, 1, bytesToRead);
+        if (rc == 0)
+        {
+            sample->flags |= SOUND_SAMPLEFLAG_EOF;
+            break;
+        } /* if */
+        else if (retval == -1)
+        {
+            sample->flags |= SOUND_SAMPLEFLAG_ERROR;
+            break;
+        } /* else if */
+        else
+        {
+            retval += rc;
+            ptr += rc;
+        } /* else */
+    } /* while */
+
+    return retval;
+} /* mp3_read */
+
+static drmp3_bool32 mp3_seek(void* pUserData, int offset, drmp3_seek_origin origin)
+{
+    const int whence = (origin == drmp3_seek_origin_start) ? RW_SEEK_SET : RW_SEEK_CUR;
+    Sound_Sample *sample = (Sound_Sample *) pUserData;
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    return (SDL_RWseek(internal->rw, offset, whence) != -1) ? DRMP3_TRUE : DRMP3_FALSE;
+} /* mp3_seek */
+
+
+static int MP3_init(void)
+{
+    return 1;  /* always succeeds. */
+} /* MP3_init */
+
+
+static void MP3_quit(void)
+{
+    /* it's a no-op. */
+} /* MP3_quit */
+
+static int MP3_open(Sound_Sample *sample, const char *ext)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    drmp3 *dr = (drmp3 *) SDL_calloc(1, sizeof (drmp3));
+
+    BAIL_IF_MACRO(!dr, ERR_OUT_OF_MEMORY, 0);
+    if (drmp3_init(dr, mp3_read, mp3_seek, sample, NULL) != DRMP3_TRUE)
+    {
+        SDL_free(dr);
+        BAIL_IF_MACRO(sample->flags & SOUND_SAMPLEFLAG_ERROR, ERR_IO_ERROR, 0);
+        BAIL_MACRO("MP3: Not an MPEG-1 layer 1-3 stream.", 0);
+    } /* if */
+
+    SNDDBG(("MP3: Accepting data stream.\n"));
+    sample->flags = SOUND_SAMPLEFLAG_CANSEEK;
+
+    sample->actual.channels = dr->channels;
+    sample->actual.rate = dr->sampleRate;
+    sample->actual.format = AUDIO_F32SYS;  /* dr_mp3 only does float. */
+
+    internal->total_time = -1;  /* !!! FIXME? */
+    internal->decoder_private = dr;
+
+    return 1;
+} /* MP3_open */
+
+static void MP3_close(Sound_Sample *sample)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    drmp3 *dr = (drmp3 *) internal->decoder_private;
+    drmp3_uninit(dr);
+    SDL_free(dr);
+} /* MP3_close */
+
+static Uint32 MP3_read(Sound_Sample *sample)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    const int channels = (int) sample->actual.channels;
+    drmp3 *dr = (drmp3 *) internal->decoder_private;
+    const drmp3_uint64 frames_to_read = (internal->buffer_size / channels) / sizeof (float);
+    const drmp3_uint64 rc = drmp3_read_f32(dr, frames_to_read, (float *) internal->buffer);
+    /* !!! FIXME: the mp3_read callback sets ERROR and EOF flags, but this only tells you about i/o errors, not corruption. */
+    return rc * channels * sizeof (float);
+} /* MP3_read */
+
+static int MP3_rewind(Sound_Sample *sample)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    drmp3 *dr = (drmp3 *) internal->decoder_private;
+    return (drmp3_seek_to_frame(dr, 0) == DRMP3_TRUE);
+} /* MP3_rewind */
+
+static int MP3_seek(Sound_Sample *sample, Uint32 ms)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    drmp3 *dr = (drmp3 *) internal->decoder_private;
+    const float frames_per_ms = ((float) sample->actual.rate) / 1000.0f;
+    const drmp3_uint64 frame_offset = (drmp3_uint64) (frames_per_ms * ((float) ms));
+    return (drmp3_seek_to_frame(dr, frame_offset) == DRMP3_TRUE);
+} /* MP3_seek */
+
+/* dr_mp3 will play layer 1 and 2 files, too */
+static const char *extensions_mp3[] = { "MP3", "MP2", "MP1", NULL };
+const Sound_DecoderFunctions __Sound_DecoderFunctions_MP3 =
+{
+    {
+        extensions_mp3,
+        "MPEG-1 Audio Layer I-III",
+        "Ryan C. Gordon <icculus@icculus.org>",
+        "https://icculus.org/SDL_sound/"
+    },
+
+    MP3_init,       /*   init() method */
+    MP3_quit,       /*   quit() method */
+    MP3_open,       /*   open() method */
+    MP3_close,      /*  close() method */
+    MP3_read,       /*   read() method */
+    MP3_rewind,     /* rewind() method */
+    MP3_seek        /*   seek() method */
+};
+
+#endif /* SOUND_SUPPORTS_MP3 */
+
+/* end of SDL_sound_mp3.c ... */
+

data/dependencies/SDL_sound/SDL_sound_raw.c

@@ -0,0 +1,164 @@
+/**
+ * SDL_sound; A sound processing toolkit.
+ *
+ * Please see the file LICENSE.txt in the source's root directory.
+ *
+ *  This file written by Ryan C. Gordon.
+ */
+
+/*
+ * RAW decoder for SDL_sound. This is as simple as it gets.
+ *
+ * This driver handles raw audio data. You must, regardless of where the
+ *  data is actually coming from, specify the string "RAW" in the extension
+ *  parameter of Sound_NewSample() (or, alternately, open a file with the
+ *  extension ".raw" in Sound_NewSampleFromFile()). The string is checked
+ *  case-insensitive. We need this check, because raw data, being raw, has
+ *  no headers or magic number we can use to determine if we should handle a
+ *  given file, so we needed some way to have this "decoder" discriminate.
+ *
+ * When calling Sound_NewSample*(), you must also specify a "desired"
+ *  audio format. The "actual" format will always match what you specify, so
+ *  there will be no conversion overhead, but these routines need to know how
+ *  to treat the bits, since it's all random garbage otherwise.
+ */
+
+#define __SDL_SOUND_INTERNAL__
+#include "SDL_sound_internal.h"
+
+#if SOUND_SUPPORTS_RAW
+
+static int RAW_init(void)
+{
+    return 1;  /* always succeeds. */
+} /* RAW_init */
+
+
+static void RAW_quit(void)
+{
+    /* it's a no-op. */
+} /* RAW_quit */
+
+
+static int RAW_open(Sound_Sample *sample, const char *ext)
+{
+    Sound_SampleInternal *internal = sample->opaque;
+    SDL_RWops *rw = internal->rw;
+    Uint32 pos, sample_rate;
+  
+        /*
+         * We check this explicitly, since we have no other way to
+         *  determine whether we should handle this data or not.
+         */
+    if (SDL_strcasecmp(ext, "RAW") != 0)
+        BAIL_MACRO("RAW: extension isn't explicitly \"RAW\".", 0);
+
+        /*
+         * You must also specify a desired format, so we know how to
+         *  treat the bits that are otherwise binary garbage.
+         */
+    if ( (sample->desired.channels < 1)  ||
+         (sample->desired.channels > 2)  ||
+         (sample->desired.rate == 0)     ||
+         (sample->desired.format == 0) )
+    {
+        BAIL_MACRO("RAW: invalid desired format.", 0);
+    } /* if */
+
+    SNDDBG(("RAW: Accepting data stream.\n"));
+
+        /*
+         * We never convert raw samples; what you ask for is what you get.
+         */
+    SDL_memcpy(&sample->actual, &sample->desired, sizeof (Sound_AudioInfo));
+    sample->flags = SOUND_SAMPLEFLAG_CANSEEK;
+
+    if ( (pos = SDL_RWseek(internal->rw, 0, SEEK_END) ) <= 0) {
+        BAIL_MACRO("RAW: cannot seek the end of the file \"RAW\".", 0);
+    }
+    if ( SDL_RWseek(internal->rw, 0, SEEK_SET) ) {
+        BAIL_MACRO("RAW: cannot reset file \"RAW\".", 0);
+    }
+
+    sample_rate =  (sample->actual.rate * sample->actual.channels
+      * ( (sample->actual.format & 0x0018) >> 3) );
+    internal->total_time = ( pos ) / sample_rate * 1000;
+    internal->total_time += (pos % sample_rate) * 1000 / sample_rate;
+
+    return 1; /* we'll handle this data. */
+} /* RAW_open */
+
+
+static void RAW_close(Sound_Sample *sample)
+{
+    /* we don't allocate anything that we need to free. That's easy, eh? */
+} /* RAW_close */
+
+
+static Uint32 RAW_read(Sound_Sample *sample)
+{
+    Uint32 retval;
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+
+        /*
+         * We don't actually do any decoding, so we read the raw data
+         *  directly into the internal buffer...
+         */
+    retval = SDL_RWread(internal->rw, internal->buffer,
+                        1, internal->buffer_size);
+
+        /* Make sure the read went smoothly... */
+    if (retval == 0)
+        sample->flags |= SOUND_SAMPLEFLAG_EOF;
+
+    else if (retval == -1)
+        sample->flags |= SOUND_SAMPLEFLAG_ERROR;
+
+        /* (next call this EAGAIN may turn into an EOF or error.) */
+    else if (retval < internal->buffer_size)
+        sample->flags |= SOUND_SAMPLEFLAG_EAGAIN;
+
+    return retval;
+} /* RAW_read */
+
+
+static int RAW_rewind(Sound_Sample *sample)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    BAIL_IF_MACRO(SDL_RWseek(internal->rw, 0, SEEK_SET) != 0, ERR_IO_ERROR, 0);
+    return 1;
+} /* RAW_rewind */
+
+
+static int RAW_seek(Sound_Sample *sample, Uint32 ms)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    int pos = (int) __Sound_convertMsToBytePos(&sample->actual, ms);
+    int err = (SDL_RWseek(internal->rw, pos, SEEK_SET) != pos);
+    BAIL_IF_MACRO(err, ERR_IO_ERROR, 0);
+    return 1;
+} /* RAW_seek */
+
+static const char *extensions_raw[] = { "RAW", NULL };
+const Sound_DecoderFunctions __Sound_DecoderFunctions_RAW =
+{
+    {
+        extensions_raw,
+        "Raw audio",
+        "Ryan C. Gordon <icculus@icculus.org>",
+        "https://icculus.org/SDL_sound/"
+    },
+
+    RAW_init,       /*   init() method */
+    RAW_quit,       /*   quit() method */
+    RAW_open,       /*   open() method */
+    RAW_close,      /*  close() method */
+    RAW_read,       /*   read() method */
+    RAW_rewind,     /* rewind() method */
+    RAW_seek        /*   seek() method */
+};
+
+#endif /* SOUND_SUPPORTS_RAW */
+
+/* end of SDL_sound_raw.c ... */
+