gosu 1.4.1 → 1.4.3

data/dependencies/SDL_sound/libmodplug/load_s3m.c

@@ -92,6 +92,7 @@ void CSoundFile_S3MConvert(MODCOMMAND *m, BOOL bIT)
 	case 'X':	command = CMD_PANNING8; break;
 	case 'Y':	command = CMD_PANBRELLO; break;
 	case 'Z':	command = CMD_MIDI; break;
+	case '\\':  command = CMD_MIDI; break;
 	default:	command = 0;
 	}
 	m->command = command;
@@ -165,6 +166,7 @@ BOOL CSoundFile_ReadS3M(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	UINT iord = psfh.ordnum;
 	if (iord<1) iord = 1;
 	if (iord > MAX_ORDERS) iord = MAX_ORDERS;
+	if (dwMemPos + iord + 1 >= dwMemLength) return FALSE;
 	if (iord)
 	{
 		if (dwMemPos + iord > dwMemLength) return FALSE;
@@ -185,8 +187,7 @@ BOOL CSoundFile_ReadS3M(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 
 	if (nins+npat)
 	{
-		if (2*(nins+npat) + dwMemPos > dwMemLength) return FALSE;
-
+		if (dwMemPos + 2*(nins+npat) >= dwMemLength) return FALSE;
 		SDL_memcpy(ptr, lpStream+dwMemPos, 2*(nins+npat));
 		dwMemPos += 2*(nins+npat);
 		for (UINT j = 0; j < (nins+npat); ++j) {
@@ -194,9 +195,8 @@ BOOL CSoundFile_ReadS3M(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 		}
 		if (psfh.panning_present == 252)
 		{
-			if (dwMemPos + 32 > dwMemLength) return FALSE;
-
 			const BYTE *chnpan = lpStream+dwMemPos;
+			if (dwMemPos > dwMemLength - 32) return FALSE;
 			for (UINT i=0; i<32; i++) if (chnpan[i] & 0x20)
 			{
 				_this->ChnSettings[i].nPan = ((chnpan[i] & 0x0F) << 4) + 8;

data/dependencies/SDL_sound/libmodplug/load_ult.c

@@ -128,7 +128,7 @@ BOOL CSoundFile_ReadUlt(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 		for (UINT nPat=0; nPat<nop; nPat++)
 		{
 			MODCOMMAND *pat = NULL;
-			
+
 			if (nPat < MAX_PATTERNS)
 			{
 				pat = _this->Patterns[nPat];
@@ -137,16 +137,17 @@ BOOL CSoundFile_ReadUlt(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 			UINT row = 0;
 			while (row < 64)
 			{
-				if (dwMemPos + 5 > dwMemLength) return TRUE;
+				if (dwMemPos > dwMemLength - 5) return TRUE;
 				UINT rep = 1;
 				UINT note = lpStream[dwMemPos++];
 				if (note == 0xFC)
 				{
-					if (dwMemPos + 7 > dwMemLength) return TRUE;
 					rep = lpStream[dwMemPos];
 					note = lpStream[dwMemPos+1];
 					dwMemPos += 2;
+					if (dwMemPos > dwMemLength - 4) return TRUE;
 				}
+
 				UINT instr = lpStream[dwMemPos++];
 				UINT eff = lpStream[dwMemPos++];
 				UINT dat1 = lpStream[dwMemPos++];

data/dependencies/SDL_sound/libmodplug/load_xm.c

@@ -188,11 +188,11 @@ BOOL CSoundFile_ReadXM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLengt
 					UINT vol = 0;
 					if (b & 0x80)
 					{
-						if ((b & 1)  && j < packsize) p->note = src[j++];
-						if ((b & 2)  && j < packsize) p->instr = src[j++];
-						if ((b & 4)  && j < packsize) vol = src[j++];
-						if ((b & 8)  && j < packsize) p->command = src[j++];
-						if ((b & 16) && j < packsize) p->param = src[j++];
+						if (b & 1) p->note = j < packsize ? src[j++] : 0;
+						if (b & 2) p->instr = j < packsize ? src[j++] : 0;
+						if (b & 4) vol = j < packsize ? src[j++] : 0;
+						if (b & 8) p->command = j < packsize ? src[j++] : 0;
+						if (b & 16) p->param = j < packsize ? src[j++] : 0;
 					} else
 					{
 						if (j + 5 > packsize) break;

data/dependencies/SDL_sound/libmodplug/snd_fx.c

@@ -420,7 +420,14 @@ void CSoundFile_NoteChange(CSoundFile *_this, UINT nChn, int note, BOOL bPorta,
 	if (note >= 0x80)	// 0xFE or invalid note => key off
 	{
 		// Key Off
-		CSoundFile_KeyOff(_this, nChn);
+		if (note < 0xFD && _this->m_nType == MOD_TYPE_IT)
+		{
+			if (_this->m_nInstruments)
+				pChn->dwFlags |= CHN_NOTEFADE;
+		} else
+		{
+			CSoundFile_KeyOff(_this, nChn);
+		}
 		// Note Cut
 		if (note == 0xFE)
 		{

data/dependencies/SDL_sound/libmodplug/sndfile.c

@@ -14,8 +14,8 @@ extern BOOL MMCMP_Unpack(LPCBYTE *ppMemFile, LPDWORD pdwMemLength);
 extern void AMSUnpack(const char *psrc, UINT inputlen, char *pdest, UINT dmax, char packcharacter);
 extern WORD MDLReadBits(DWORD *bitbuf, UINT *bitnum, LPBYTE *ibuf, CHAR n);
 extern int DMFUnpack(LPBYTE psample, LPBYTE ibuf, LPBYTE ibufmax, UINT maxlen);
-extern void ITUnpack8Bit(signed char *pSample, DWORD dwLen, LPBYTE lpMemFile, DWORD dwMemLength, BOOL b215);
-extern void ITUnpack16Bit(signed char *pSample, DWORD dwLen, LPBYTE lpMemFile, DWORD dwMemLength, BOOL b215);
+extern DWORD ITUnpack8Bit(signed char *pSample, DWORD dwLen, LPBYTE lpMemFile, DWORD dwMemLength, DWORD channels, BOOL b215);
+extern DWORD ITUnpack16Bit(signed char *pSample, DWORD dwLen, LPBYTE lpMemFile, DWORD dwMemLength, DWORD channels, BOOL b215);
 
 
 static void CSoundFile_UpdateSettings(CSoundFile *_this, const ModPlug_Settings *settings)
@@ -665,9 +665,26 @@ UINT CSoundFile_ReadSample(CSoundFile *_this, MODINSTRUMENT *pIns, UINT nFlags,
 		len = dwMemLength;
 		if (len < 4) break;
 		if ((nFlags == RS_IT2148) || (nFlags == RS_IT2158))
-			ITUnpack8Bit(pIns->pSample, pIns->nLength, (LPBYTE)lpMemFile, dwMemLength, (nFlags == RS_IT2158));
+			ITUnpack8Bit(pIns->pSample, pIns->nLength, (LPBYTE)lpMemFile, dwMemLength, 1, (nFlags == RS_IT2158));
 		else
-			ITUnpack16Bit(pIns->pSample, pIns->nLength, (LPBYTE)lpMemFile, dwMemLength, (nFlags == RS_IT21516));
+			ITUnpack16Bit(pIns->pSample, pIns->nLength, (LPBYTE)lpMemFile, dwMemLength, 1, (nFlags == RS_IT21516));
+		break;
+
+	case RS_IT2148 | RSF_STEREO:
+	case RS_IT21416 | RSF_STEREO:
+	case RS_IT2158 | RSF_STEREO:
+	case RS_IT21516 | RSF_STEREO:
+		len = dwMemLength;
+		if (len < 4) break;
+		if ((nFlags == (RS_IT2148 | RSF_STEREO)) || (nFlags == (RS_IT2158 | RSF_STEREO)))
+		{
+			DWORD offset = ITUnpack8Bit(pIns->pSample, pIns->nLength, (LPBYTE)lpMemFile, dwMemLength, 2, (nFlags == (RS_IT2158 | RSF_STEREO)));
+			ITUnpack8Bit(pIns->pSample + 1, pIns->nLength, (LPBYTE)lpMemFile + offset, dwMemLength - offset, 2, (nFlags == (RS_IT2158 | RSF_STEREO)));
+		} else
+		{
+			DWORD offset = ITUnpack16Bit(pIns->pSample, pIns->nLength, (LPBYTE)lpMemFile, dwMemLength, 2, (nFlags == (RS_IT21516 | RSF_STEREO)));
+			ITUnpack16Bit(pIns->pSample + 2, pIns->nLength, (LPBYTE)lpMemFile + offset, dwMemLength - offset, 2, (nFlags == (RS_IT21516 | RSF_STEREO)));
+		}
 		break;
 
 #ifndef MODPLUG_BASIC_SUPPORT

data/dependencies/SDL_sound/stb_vorbis.h

@@ -608,21 +608,6 @@ enum STBVorbisError
 
 #include <limits.h>
 
-/* we need alloca() regardless of STB_VORBIS_NO_CRT,
- * because there is not a corresponding 'dealloca' */
-#if !defined(alloca)
-# if defined(HAVE_ALLOCA_H)
-#  include <alloca.h>
-# elif defined(__GNUC__)
-#  define alloca __builtin_alloca
-# elif defined(_MSC_VER)
-#  include <malloc.h>
-#  define alloca _alloca
-# elif defined(__WATCOMC__)
-#  include <malloc.h>
-# endif
-#endif
-
 #ifndef STB_FORCEINLINE
     #if defined(_MSC_VER)
         #define STB_FORCEINLINE __forceinline
@@ -646,7 +631,7 @@ enum STBVorbisError
 #include <crtdbg.h>
 #define CHECK(f)   _CrtIsValidHeapPointer(f->channel_buffers[1])
 #else
-#define CHECK(f)   ((void) 0)
+#define CHECK(f)   do {} while(0)
 #endif
 
 #define MAX_BLOCKSIZE_LOG  13   // from specification
@@ -937,6 +922,9 @@ struct stb_vorbis
    int channel_buffer_start;
    int channel_buffer_end;
 
+  // hack: decode work buffer (used in inverse_mdct and decode_residues)
+   void *work_buffer;
+
   // temporary buffers
    void *temp_lengths;
    void *temp_codewords;
@@ -971,8 +959,8 @@ static int error(vorb *f, enum STBVorbisError e)
 
 #define array_size_required(count,size)  (count*(sizeof(void *)+(size)))
 
-#define temp_alloc(f,size)              (f->alloc.alloc_buffer ? setup_temp_malloc(f,size) : alloca(size))
-#define temp_free(f,p)                  (void)0
+#define temp_alloc(f,size)              (f->alloc.alloc_buffer ? setup_temp_malloc(f,size) : f->work_buffer)
+#define temp_free(f,p)                  do {} while (0)
 #define temp_alloc_save(f)              ((f)->temp_offset)
 #define temp_alloc_restore(f,p)         ((f)->temp_offset = (p))
 
@@ -4297,6 +4285,9 @@ static int start_decoder(vorb *f)
       // check if there's enough temp memory so we don't error later
       if (f->setup_offset + sizeof(*f) + f->temp_memory_required > (unsigned) f->temp_offset)
          return error(f, VORBIS_outofmem);
+   } else {
+      f->work_buffer = setup_malloc(f, f->temp_memory_required);
+      if (f->work_buffer == NULL) return error(f, VORBIS_outofmem);
    }
 
    // @TODO: stb_vorbis_seek_start expects first_audio_page_offset to point to a page
@@ -4376,6 +4367,7 @@ static void vorbis_deinit(stb_vorbis *p)
       setup_free(p, p->bit_reverse[i]);
    }
    if (!p->alloc.alloc_buffer) {
+      setup_free(p, p->work_buffer);
       setup_temp_free(p, &p->temp_lengths, 0);
       setup_temp_free(p, &p->temp_codewords, 0);
       setup_temp_free(p, &p->temp_values, 0);

data/dependencies/mojoAL/mojoal.c

@@ -230,6 +230,12 @@ static int has_neon = 0;
 #endif
 #endif
 
+/* no threads in Emscripten (at the moment...!) */
+#if defined(__EMSCRIPTEN__) && !defined(__EMSCRIPTEN_PTHREADS__)
+#define init_api_lock() 1
+#define grab_api_lock()
+#define ungrab_api_lock()
+#else
 static SDL_mutex *api_lock = NULL;
 
 static int init_api_lock(void)
@@ -264,6 +270,7 @@ static void ungrab_api_lock(void)
     const int rc = SDL_UnlockMutex(api_lock);
     SDL_assert(rc == 0);
 }
+#endif
 
 #define ENTRYPOINT(rettype,fn,params,args) \
     rettype fn params { rettype retval; grab_api_lock(); retval = _##fn args ; ungrab_api_lock(); return retval; }
@@ -417,6 +424,23 @@ typedef struct BufferQueue
     SDL_atomic_t num_items;  /* counts just_queued+head/tail */
 } BufferQueue;
 
+#define pitch_framesize 1024
+#define pitch_framesize2 512
+typedef struct PitchState
+{
+    /* !!! FIXME: this is a wild amount of memory for pitch-shifting! */
+    ALfloat infifo[pitch_framesize];
+    ALfloat outfifo[pitch_framesize];
+    ALfloat workspace[2*pitch_framesize];
+    ALfloat lastphase[pitch_framesize2+1];
+    ALfloat sumphase[pitch_framesize2+1];
+    ALfloat outputaccum[2*pitch_framesize];
+    ALfloat synmagn[pitch_framesize2+1];
+    ALfloat synfreq[pitch_framesize2+1];
+    ALint rover;
+} PitchState;
+
+
 typedef struct ALsource ALsource;
 
 SIMDALIGNEDSTRUCT ALsource
@@ -452,6 +476,7 @@ SIMDALIGNEDSTRUCT ALsource
     ALboolean offset_latched;  /* AL_SEC_OFFSET, etc, say set values apply to next alSourcePlay if not currently playing! */
     ALint queue_channels;
     ALsizei queue_frequency;
+    PitchState *pitchstate;
     ALsource *playlist_next;  /* linked list that contains currently-playing sources! Only touched by mixer thread! */
 };
 
@@ -1124,8 +1149,222 @@ static void mix_float32_c2_neon(const ALfloat * restrict panning, const float *
 #endif
 
 
-static void mix_buffer(const ALbuffer *buffer, const ALfloat * restrict panning, const float * restrict data, float * restrict stream, const ALsizei mixframes)
+/****************************************************************************
+*
+* pitch_fft and pitch_shift are modified versions of code from:
+*
+*    http://blogs.zynaptiq.com/bernsee/pitch-shifting-using-the-ft/
+*
+*   The original code has this copyright/license:
+*
+*****************************************************************************
+*
+* COPYRIGHT 1999-2015 Stephan M. Bernsee <s.bernsee [AT] zynaptiq [DOT] com>
+*
+* 						The Wide Open License (WOL)
+*
+* Permission to use, copy, modify, distribute and sell this software and its
+* documentation for any purpose is hereby granted without fee, provided that
+* the above copyright notice and this license appear in all source copies. 
+* THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY OF
+* ANY KIND. See http://www.dspguru.com/wol.htm for more information.
+*
+*****************************************************************************/ 
+
+/* FFT routine, (C)1996 S.M.Bernsee. */
+static void pitch_fft(float *fftBuffer, int fftFrameSize, int sign)
+{
+    float wr, wi, arg, *p1, *p2, temp;
+    float tr, ti, ur, ui, *p1r, *p1i, *p2r, *p2i;
+    int i, bitm, j, le, le2, k;
+
+    for (i = 2; i < 2*fftFrameSize-2; i += 2) {
+        for (bitm = 2, j = 0; bitm < 2*fftFrameSize; bitm <<= 1) {
+            if (i & bitm) j++;
+            j <<= 1;
+        }
+        if (i < j) {
+            p1 = fftBuffer+i; p2 = fftBuffer+j;
+            temp = *p1; *(p1++) = *p2;
+            *(p2++) = temp; temp = *p1;
+            *p1 = *p2; *p2 = temp;
+        }
+    }
+    const int endval = (int)(SDL_log(fftFrameSize)/SDL_log(2.)+.5);   /* !!! FIXME: precalc this. */
+    for (k = 0, le = 2; k < endval; k++) {
+        le <<= 1;
+        le2 = le>>1;
+        ur = 1.0;
+        ui = 0.0;
+        arg = M_PI / (le2>>1);
+        wr = SDL_cos(arg);
+        wi = sign*SDL_sin(arg);
+        for (j = 0; j < le2; j += 2) {
+            p1r = fftBuffer+j; p1i = p1r+1;
+            p2r = p1r+le2; p2i = p2r+1;
+            for (i = j; i < 2*fftFrameSize; i += le) {
+                tr = *p2r * ur - *p2i * ui;
+                ti = *p2r * ui + *p2i * ur;
+                *p2r = *p1r - tr; *p2i = *p1i - ti;
+                *p1r += tr; *p1i += ti;
+                p1r += le; p1i += le;
+                p2r += le; p2i += le;
+            }
+            tr = ur*wr - ui*wi;
+            ui = ur*wi + ui*wr;
+            ur = tr;
+        }
+    }
+}
+
+static void pitch_shift(ALsource *src, const ALbuffer *buffer, int numSampsToProcess, const float *indata, float *outdata)
 {
+    const float pitchShift = src->pitch;
+    const float sampleRate = (float) buffer->frequency;
+    const int osamp = 4;
+    const int stepSize = pitch_framesize / osamp;
+    const int inFifoLatency = pitch_framesize - stepSize;
+    const double freqPerBin = sampleRate / (double)pitch_framesize;
+    const double expct = 2.0 * M_PI * ((double)stepSize / (double)pitch_framesize);
+
+    double magn, phase, tmp, window, real, imag;
+    int i,k, qpd, index;
+    PitchState *state = src->pitchstate;
+
+    SDL_assert(state != NULL);
+
+    if (state->rover == 0) state->rover = inFifoLatency;
+
+    /* main processing loop */
+    for (i = 0; i < numSampsToProcess; i++){
+
+        /* As long as we have not yet collected enough data just read in */
+        state->infifo[state->rover] = indata[i];
+        outdata[i] = state->outfifo[state->rover-inFifoLatency];
+        state->rover++;
+
+        /* now we have enough data for processing */
+        if (state->rover >= pitch_framesize) {
+            state->rover = inFifoLatency;
+
+            /* do windowing and re,im interleave */
+            for (k = 0; k < pitch_framesize;k++) {
+                window = -.5*SDL_cos(2.*M_PI*(double)k/(double)pitch_framesize)+.5;
+                state->workspace[2*k] = state->infifo[k] * window;
+                state->workspace[2*k+1] = 0.;
+            }
+
+
+            /* ***************** ANALYSIS ******************* */
+            /* do transform */
+            pitch_fft(state->workspace, pitch_framesize, -1);
+
+            /* this is the analysis step */
+            for (k = 0; k <= pitch_framesize2; k++) {
+
+                /* de-interlace FFT buffer */
+                real = state->workspace[2*k];
+                imag = state->workspace[2*k+1];
+
+                /* compute magnitude and phase */
+                magn = 2.*SDL_sqrt(real*real + imag*imag);
+                phase = SDL_atan2(imag,real);
+
+                /* compute phase difference */
+                tmp = phase - state->lastphase[k];
+                state->lastphase[k] = phase;
+
+                /* subtract expected phase difference */
+                tmp -= (double)k*expct;
+
+                /* map delta phase into +/- Pi interval */
+                qpd = tmp/M_PI;
+                if (qpd >= 0) qpd += qpd&1;
+                else qpd -= qpd&1;
+                tmp -= M_PI*(double)qpd;
+
+                /* get deviation from bin frequency from the +/- Pi interval */
+                tmp = osamp*tmp/(2.*M_PI);
+
+                /* compute the k-th partials' true frequency */
+                tmp = (double)k*freqPerBin + tmp*freqPerBin;
+
+                /* store magnitude and true frequency in analysis arrays */
+                state->workspace[2*k] = magn;
+                state->workspace[2*k+1] = tmp;
+
+            }
+
+            /* ***************** PROCESSING ******************* */
+            /* this does the actual pitch shifting */
+            SDL_memset(state->synmagn, '\0', sizeof (state->synmagn));
+            for (k = 0; k <= pitch_framesize2; k++) {
+                index = k*pitchShift;
+                if (index <= pitch_framesize2) { 
+                    state->synmagn[index] += state->workspace[2*k];
+                    state->synfreq[index] = state->workspace[2*k+1] * pitchShift;
+                } 
+            }
+            
+            /* ***************** SYNTHESIS ******************* */
+            /* this is the synthesis step */
+            for (k = 0; k <= pitch_framesize2; k++) {
+
+                /* get magnitude and true frequency from synthesis arrays */
+                magn = state->synmagn[k];
+                tmp = state->synfreq[k];
+
+                /* subtract bin mid frequency */
+                tmp -= (double)k*freqPerBin;
+
+                /* get bin deviation from freq deviation */
+                tmp /= freqPerBin;
+
+                /* take osamp into account */
+                tmp = 2.*M_PI*tmp/osamp;
+
+                /* add the overlap phase advance back in */
+                tmp += (double)k*expct;
+
+                /* accumulate delta phase to get bin phase */
+                state->sumphase[k] += tmp;
+                phase = state->sumphase[k];
+
+                /* get real and imag part and re-interleave */
+                state->workspace[2*k] = magn*SDL_cos(phase);
+                state->workspace[2*k+1] = magn*SDL_sin(phase);
+            } 
+
+            /* zero negative frequencies */
+            for (k = pitch_framesize+2; k < 2*pitch_framesize; k++) state->workspace[k] = 0.;
+
+            /* do inverse transform */
+            pitch_fft(state->workspace, pitch_framesize, 1);
+
+            /* do windowing and add to output accumulator */ 
+            for(k=0; k < pitch_framesize; k++) {
+                window = -.5*SDL_cos(2.*M_PI*(double)k/(double)pitch_framesize)+.5;
+                state->outputaccum[k] += 2.*window*state->workspace[2*k]/(pitch_framesize2*osamp);
+            }
+            for (k = 0; k < stepSize; k++) state->outfifo[k] = state->outputaccum[k];
+
+            /* shift accumulator */
+            SDL_memmove(state->outputaccum, state->outputaccum+stepSize, pitch_framesize*sizeof(float));
+
+            /* move input FIFO */
+            for (k = 0; k < inFifoLatency; k++) state->infifo[k] = state->infifo[k+stepSize];
+        }
+    }
+}
+
+static void mix_buffer(ALsource *src, const ALbuffer *buffer, const ALfloat * restrict panning, const float * restrict data, float * restrict stream, const ALsizei mixframes)
+{
+    if ((src->pitch != 1.0f) && (src->pitchstate != NULL)) {
+        float *pitched = (float *) alloca(mixframes * buffer->channels * sizeof (float));
+        pitch_shift(src, buffer, mixframes * buffer->channels, data, pitched);
+        data = pitched;
+    }
+
     const ALfloat left = panning[0];
     const ALfloat right = panning[1];
     FIXME("currently expects output to be stereo");
@@ -1194,7 +1433,7 @@ static ALboolean mix_source_buffer(ALCcontext *ctx, ALsource *src, BufferQueueIt
                 const int mixbufframes = mixbuflen / bufferframesize;
                 const int getframes = SDL_min(remainingmixframes, mixbufframes);
                 SDL_AudioStreamGet(src->stream, mixbuf, getframes * bufferframesize);
-                mix_buffer(buffer, src->panning, mixbuf, *stream, getframes);
+                mix_buffer(src, buffer, src->panning, mixbuf, *stream, getframes);
                 *len -= getframes * deviceframesize;
                 *stream += getframes * ctx->device->channels;
                 remainingmixframes -= getframes;
@@ -1202,7 +1441,7 @@ static ALboolean mix_source_buffer(ALCcontext *ctx, ALsource *src, BufferQueueIt
         } else {
             const int framesavail = (buffer->len - src->offset) / bufferframesize;
             const int mixframes = SDL_min(framesneeded, framesavail);
-            mix_buffer(buffer, src->panning, data, *stream, mixframes);
+            mix_buffer(src, buffer, src->panning, data, *stream, mixframes);
             src->offset += mixframes * bufferframesize;
             *len -= mixframes * deviceframesize;
             *stream += mixframes * ctx->device->channels;
@@ -3433,6 +3672,19 @@ static ALboolean _alIsSource(const ALuint name)
 }
 ENTRYPOINT(ALboolean,alIsSource,(ALuint name),(name))
 
+static void source_set_pitch(ALCcontext *ctx, ALsource *src, const ALfloat pitch)
+{
+    /* only allocate pitchstate if the pitch every changes, because it's a lot of
+       RAM and we leave it allocated to the source until forever once needed */
+    if ((pitch != 1.0f) && (src->pitchstate == NULL)) {
+        src->pitchstate = (PitchState *) SDL_calloc(1, sizeof (PitchState));
+        if (src->pitchstate == NULL) {
+            set_al_error(ctx, AL_OUT_OF_MEMORY);
+        }
+    }
+    src->pitch = pitch;
+}
+
 static void _alSourcefv(const ALuint name, const ALenum param, const ALfloat *values)
 {
     ALCcontext *ctx = get_current_context();
@@ -3449,7 +3701,7 @@ static void _alSourcefv(const ALuint name, const ALenum param, const ALfloat *va
         case AL_REFERENCE_DISTANCE: src->reference_distance = *values; break;
         case AL_ROLLOFF_FACTOR: src->rolloff_factor = *values; break;
         case AL_MAX_DISTANCE: src->max_distance = *values; break;
-        case AL_PITCH: src->pitch = *values; break;
+        case AL_PITCH: source_set_pitch(ctx, src, *values); break;
         case AL_CONE_INNER_ANGLE: src->cone_inner_angle = *values; break;
         case AL_CONE_OUTER_ANGLE: src->cone_outer_angle = *values; break;
         case AL_CONE_OUTER_GAIN: src->cone_outer_gain = *values; break;
@@ -3654,7 +3906,7 @@ static void _alGetSourcefv(const ALuint name, const ALenum param, ALfloat *value
         case AL_REFERENCE_DISTANCE: *values = src->reference_distance; break;
         case AL_ROLLOFF_FACTOR: *values = src->rolloff_factor; break;
         case AL_MAX_DISTANCE: *values = src->max_distance; break;
-        case AL_PITCH: *values = src->pitch; break;
+        case AL_PITCH: source_set_pitch(ctx, src, *values); break;
         case AL_CONE_INNER_ANGLE: *values = src->cone_inner_angle; break;
         case AL_CONE_OUTER_ANGLE: *values = src->cone_outer_angle; break;
         case AL_CONE_OUTER_GAIN:  *values = src->cone_outer_gain; break;
@@ -3955,7 +4207,7 @@ static float source_get_offset(ALsource *src, ALenum param)
             int proc_buf = SDL_AtomicGet(&src->buffer_queue_processed.num_items);
             offset = (proc_buf * item->buffer->len + src->offset);
         }
-    } else {
+    } else if (src->buffer) {
         framesize = (int) (src->buffer->channels * sizeof (float));
         freq = (int) src->buffer->frequency;
         offset = src->offset;
@@ -4482,12 +4734,14 @@ static void _alBufferData(const ALuint name, const ALenum alfmt, const ALvoid *d
     if (rc == 1) {  /* conversion necessary */
         rc = SDL_ConvertAudio(&sdlcvt);
         SDL_assert(rc == 0);  /* this shouldn't fail. */
+        #if 0   /* !!! FIXME: need realloc_simd_aligned. */
         if (sdlcvt.len_cvt < (size * sdlcvt.len_mult)) {  /* maybe shrink buffer */
             void *ptr = SDL_realloc(sdlcvt.buf, sdlcvt.len_cvt);
             if (ptr) {
                 sdlcvt.buf = (Uint8 *) ptr;
             }
         }
+        #endif
     }
 
     free_simd_aligned((void *) buffer->data);  /* nuke any previous data. */