gosu 1.3.0 → 1.4.0

data/dependencies/SDL_sound/libmodplug/load_psm.c

@@ -4,6 +4,7 @@
  * Authors: Olivier Lapicque <olivierl@jps.net>
 */
 
+
 ///////////////////////////////////////////////////
 //
 // PSM module loader
@@ -80,7 +81,9 @@ typedef struct _PSMSAMPLE
 	BYTE reserved6[19];
 } PSMSAMPLE;
 
-void swap_PSMSAMPLE(PSMSAMPLE* p){
+#pragma pack()
+
+static void swap_PSMSAMPLE(PSMSAMPLE* p){
 	p->smpid = bswapLE32(p->smpid);
 	p->length = bswapLE32(p->length);
 	p->loopstart = bswapLE32(p->loopstart);
@@ -88,29 +91,29 @@ void swap_PSMSAMPLE(PSMSAMPLE* p){
 	p->samplerate = bswapLE32(p->samplerate);
 }
 
-#pragma pack()
-
 
 BOOL CSoundFile_ReadPSM(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 //-----------------------------------------------------------
 {
-	PSMCHUNK *pfh = (PSMCHUNK *)lpStream;
+	PSMCHUNK pfh;
 	DWORD dwMemPos, dwSongPos;
-	DWORD smpnames[MAX_SAMPLES];
+//	DWORD smpnames[MAX_SAMPLES];
 	DWORD patptrs[MAX_PATTERNS];
 	BYTE samplemap[MAX_SAMPLES];
 	UINT nPatterns;
-	
+
+	if (dwMemLength < 256) return FALSE;
+
+	SDL_memcpy(&pfh, lpStream, sizeof(PSMCHUNK));
 	// Swap chunk
-	swap_PSMCHUNK(pfh);
+	swap_PSMCHUNK(&pfh);
 	
 	// Chunk0: "PSM ",filesize,"FILE"
-	if (dwMemLength < 256) return FALSE;
-	if (pfh->id == PSM_ID_OLD)
+	if (pfh.id == PSM_ID_OLD)
 	{
 		return FALSE;
 	}
-	if ((pfh->id != PSM_ID_NEW) || (pfh->len+12 > dwMemLength) || (pfh->listid != IFFID_FILE)) return FALSE;
+	if ((pfh.id != PSM_ID_NEW) || (pfh.len+12 > dwMemLength) || (pfh.listid != IFFID_FILE)) return FALSE;
 	_this->m_nType = MOD_TYPE_PSM;
 	_this->m_nChannels = 16;
 	_this->m_nSamples = 0;
@@ -124,13 +127,14 @@ BOOL CSoundFile_ReadPSM(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 	}
 	while (dwMemPos+8 < dwMemLength)
 	{
-		PSMCHUNK *pchunk = (PSMCHUNK *)(lpStream+dwMemPos);
-		swap_PSMCHUNK(pchunk);
-		if ((pchunk->len >= dwMemLength - 8) || (dwMemPos + pchunk->len + 8 > dwMemLength)) break;
+		PSMCHUNK pchunk;
+		SDL_memcpy(&pchunk, lpStream+dwMemPos, sizeof(PSMCHUNK));
+		swap_PSMCHUNK(&pchunk);
+		if ((pchunk.len >= dwMemLength - 8) || (dwMemPos + pchunk.len + 8 > dwMemLength)) break;
 		dwMemPos += 8;
 		PUCHAR pdata = (PUCHAR)(lpStream+dwMemPos);
-		ULONG len = pchunk->len;
-		if (len) switch(pchunk->id)
+		ULONG len = pchunk.len;
+		if (len) switch(pchunk.id)
 		{
 		// "PBOD": Pattern
 		case IFFID_PBOD:
@@ -152,19 +156,20 @@ BOOL CSoundFile_ReadPSM(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 			{
 				_this->m_nSamples++;
 				MODINSTRUMENT *pins = &_this->Ins[_this->m_nSamples];
-				PSMSAMPLE *psmp = (PSMSAMPLE *)pdata;
-				swap_PSMSAMPLE(psmp);
-				smpnames[_this->m_nSamples] = psmp->smpid;
+				PSMSAMPLE psmp;
+				SDL_memcpy(&psmp, pdata, sizeof(PSMSAMPLE));
+				swap_PSMSAMPLE(&psmp);
+			//	smpnames[_this->m_nSamples] = psmp.smpid;
 				samplemap[_this->m_nSamples-1] = (BYTE)_this->m_nSamples;
 				// Init sample
 				pins->nGlobalVol = 0x40;
-				pins->nC4Speed = psmp->samplerate;
-				pins->nLength = psmp->length;
-				pins->nLoopStart = psmp->loopstart;
-				pins->nLoopEnd = psmp->loopend;
+				pins->nC4Speed = psmp.samplerate;
+				pins->nLength = psmp.length;
+				pins->nLoopStart = psmp.loopstart;
+				pins->nLoopEnd = psmp.loopend;
 				pins->nPan = 128;
-				pins->nVolume = (psmp->defvol+1) * 2;
-				pins->uFlags = (psmp->flags & 0x80) ? CHN_LOOP : 0;
+				pins->nVolume = (psmp.defvol+1) * 2;
+				pins->uFlags = (psmp.flags & 0x80) ? CHN_LOOP : 0;
 				if (pins->nLoopStart > 0) pins->nLoopStart--;
 				// Point to sample data
 				pdata += 0x60;
@@ -180,10 +185,10 @@ BOOL CSoundFile_ReadPSM(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 			}
 			break;
 		}
-		dwMemPos += pchunk->len;
+		dwMemPos += pchunk.len;
 	}
 	// Step #1: convert song structure
-	PSMSONGHDR *pSong = (PSMSONGHDR *)(lpStream+dwSongPos+8);
+	const PSMSONGHDR *pSong = (const PSMSONGHDR *)(lpStream+dwSongPos+8);
 	if ((!dwSongPos) || (pSong->channels < 2) || (pSong->channels > 32)) return TRUE;
 	_this->m_nChannels = pSong->channels;
 	// Valid song header -> convert attached chunks
@@ -192,13 +197,14 @@ BOOL CSoundFile_ReadPSM(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 		dwMemPos = dwSongPos + 8 + 11; // sizeof(PSMCHUNK)+sizeof(PSMSONGHDR)
 		while (dwMemPos + 8 < dwSongEnd)
 		{
-			PSMCHUNK *pchunk = (PSMCHUNK *)(lpStream+dwMemPos);
-			swap_PSMCHUNK(pchunk);
+			PSMCHUNK pchunk;
+			SDL_memcpy(&pchunk, lpStream+dwMemPos, sizeof(PSMCHUNK));
+			swap_PSMCHUNK(&pchunk);
 			dwMemPos += 8;
-			if ((pchunk->len > dwSongEnd) || (dwMemPos + pchunk->len > dwSongEnd)) break;
+			if ((pchunk.len > dwSongEnd) || (dwMemPos + pchunk.len > dwSongEnd)) break;
 			PUCHAR pdata = (PUCHAR)(lpStream+dwMemPos);
-			ULONG len = pchunk->len;
-			switch(pchunk->id)
+			ULONG len = pchunk.len;
+			switch(pchunk.id)
 			{
 			case IFFID_OPLH:
 				if (len >= 0x20)
@@ -211,7 +217,7 @@ BOOL CSoundFile_ReadPSM(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 						DWORD dwName = *(DWORD *)(pdata+pos);
 						for (UINT i=0; i<nPatterns; i++)
 						{
-							DWORD dwPatName = ((PSMPATTERN *)(lpStream+patptrs[i]+8))->name;
+							DWORD dwPatName = ((const PSMPATTERN *)(lpStream+patptrs[i]+8))->name;
 							if (dwName == dwPatName)
 							{
 								bFound = TRUE;
@@ -232,7 +238,7 @@ BOOL CSoundFile_ReadPSM(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 						DWORD dwName = *(DWORD *)(pdata+pos);
 						for (UINT i=0; i<nPatterns; i++)
 						{
-							DWORD dwPatName = ((PSMPATTERN *)(lpStream+patptrs[i]+8))->name;
+							DWORD dwPatName = ((const PSMPATTERN *)(lpStream+patptrs[i]+8))->name;
 							if (dwName == dwPatName)
 							{
 								_this->Order[iOrd++] = i;
@@ -244,70 +250,73 @@ BOOL CSoundFile_ReadPSM(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 				}
 				break;
 			}
-			dwMemPos += pchunk->len;
+			dwMemPos += pchunk.len;
 		}
 	}
 
 	// Step #2: convert patterns
 	for (UINT nPat=0; nPat<nPatterns; nPat++)
 	{
-		PSMPATTERN *pPsmPat = (PSMPATTERN *)(lpStream+patptrs[nPat]+8);
-		swap_PSMPATTERN(pPsmPat);
-		ULONG len = *(DWORD *)(lpStream+patptrs[nPat]+4) - 12;
-		UINT nRows = pPsmPat->rows;
-		if (len > pPsmPat->size) len = pPsmPat->size;
+		PSMPATTERN pPsmPat;
+		PSMCHUNK pchunk;
+		SDL_memcpy(&pPsmPat, lpStream+patptrs[nPat]+8, sizeof(PSMPATTERN));
+		swap_PSMPATTERN(&pPsmPat);
+		SDL_memcpy(&pchunk, lpStream+patptrs[nPat], sizeof(PSMCHUNK));
+		swap_PSMCHUNK(&pchunk);
+
+		ULONG len = pchunk.len - 12;
+		UINT nRows = pPsmPat.rows;
+		if (len > pPsmPat.size) len = pPsmPat.size;
 		if ((nRows < 64) || (nRows > 256)) nRows = 64;
 		_this->PatternSize[nPat] = nRows;
 		if ((_this->Patterns[nPat] = CSoundFile_AllocatePattern(nRows, _this->m_nChannels)) == NULL) break;
 		MODCOMMAND *m = _this->Patterns[nPat];
-		BYTE *p = pPsmPat->data;
+		const BYTE *p = lpStream + patptrs[nPat] + 20;
+		MODCOMMAND *sp, dummy;
 		UINT pos = 0;
 		UINT row = 0;
-		UINT oldch = 0;
-		BOOL bNewRow = FALSE;
-		while ((row < nRows) && (pos+1 < len))
+		UINT rowlim;
+		UINT flags, ch;
+		rowlim = bswapLE16(pPsmPat.reserved1)-2;
+		while ((row < nRows) && (pos+3 < len))
 		{
-			UINT flags = p[pos++];
-			UINT ch = p[pos++];
-			
-			if (((flags & 0xf0) == 0x10) && (ch <= oldch) /*&& (!bNewRow)*/)
-			{
-				if ((pos+1<len) && (!(p[pos] & 0x0f)) && (p[pos+1] < _this->m_nChannels))
-				{
-					row++;
-					m += _this->m_nChannels;
-					oldch = ch;
-					continue;
-				}
-			}
-			if ((pos >= len) || (row >= nRows)) break;
-			if (!(flags & 0xf0))
-			{
-				row++;
+			if ((pos+1) >= rowlim) {
+				pos = rowlim;
+				rowlim = (((int)p[pos+1])<<8)
+					| ((int)p[pos+0]);
 				m += _this->m_nChannels;
-				bNewRow = TRUE;
-				oldch = ch;
-				continue;
+				row++;
+				rowlim += pos;
+				pos += 2;
 			}
-			bNewRow = FALSE;
-			if (ch >= _this->m_nChannels)
-			{
-				ch = 0;
+			if (row >= nRows) continue;
+
+			flags = p[pos++];
+			ch = p[pos++];
+			if (ch >= _this->m_nChannels) {
+				sp = &dummy;
+			} else {
+				sp = &m[ch];
 			}
 			// Note + Instr
-			if ((flags & 0x40) && (pos+1 < len))
+			if ((flags & 0x80) && (pos+1 < len))
 			{
 				UINT note = p[pos++];
+				note = (note>>4)*12+(note&0x0f)+12+1;
+				if (note > 0x80) note = 0;
+				sp->note = note;
+			}
+			if ((flags & 0x40) && (pos+1 < len))
+			{
 				UINT nins = p[pos++];
-				if ((note) && (note < 0x80)) note = (note>>4)*12+(note&0x0f)+12+1;
-				m[ch].instr = samplemap[nins];
-				m[ch].note = note;
+				if (nins < MAX_SAMPLES)
+					sp->instr = samplemap[nins];
 			}
 			// Volume
 			if ((flags & 0x20) && (pos < len))
 			{
-				m[ch].volcmd = VOLCMD_VOLUME;
-				m[ch].vol = p[pos++] / 2;
+				sp->volcmd = VOLCMD_VOLUME;
+				sp->vol = p[pos++] / 2;
 			}
 			// Effect
 			if ((flags & 0x10) && (pos+1 < len))
@@ -318,13 +327,29 @@ BOOL CSoundFile_ReadPSM(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 				switch(command)
 				{
 				// 01: fine volslide up
-				case 0x01:	command = CMD_VOLUMESLIDE; param |= 0x0f; break;
+				case 0x01:	command = CMD_VOLUMESLIDE; param |= 0x0f;
+						if (param == 15) param=31;
+						break;
+				// 02: volslide up
+				case 0x02:	command = CMD_VOLUMESLIDE; param>>=1; param<<=4; break;
+				// 03: fine volslide down
+				case 0x03:	command = CMD_VOLUMESLIDE; param>>=4; param |= 0xf0;
+						if (param == 240) param=241;
+						break;
 				// 04: fine volslide down
 				case 0x04:	command = CMD_VOLUMESLIDE; param>>=4; param |= 0xf0; break;
 				// 0C: portamento up
 				case 0x0C:	command = CMD_PORTAMENTOUP; param = (param+1)/2; break;
 				// 0E: portamento down
 				case 0x0E:	command = CMD_PORTAMENTODOWN; param = (param+1)/2; break;
+				// 0F: tone portamento
+				case 0x0F:	command = CMD_TONEPORTAMENTO; param = param/4; break;
+				// 15: vibrato
+				case 0x15:	command = CMD_VIBRATO; break;
+				// 29: sample offset
+				case 0x29:	pos += 2; break;
+				// 2A: retrigger note
+				case 0x2A:	command = CMD_RETRIG; break;
 				// 33: Position Jump
 				case 0x33:	command = CMD_POSITIONJUMP; break;
 				// 34: Pattern break
@@ -337,14 +362,12 @@ BOOL CSoundFile_ReadPSM(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 				default:
 					command = param = 0;
 				}
-				m[ch].command = (BYTE)command;
-				m[ch].param = (BYTE)param;
+				sp->command = (BYTE)command;
+				sp->param = (BYTE)param;
 			}
-			oldch = ch;
 		}
 	}
 
 	// Done (finally!)
 	return TRUE;
 }
-

data/dependencies/SDL_sound/libmodplug/load_ptm.c

@@ -69,7 +69,7 @@ BOOL CSoundFile_ReadPTM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 
 	if ((!lpStream) || (dwMemLength < sizeof(PTMFILEHEADER))) return FALSE;
 	PTMFILEHEADER pfh;
-    SDL_memcpy(&pfh, lpStream, sizeof (pfh));
+	SDL_memcpy(&pfh, lpStream, sizeof (pfh));
 
 	pfh.norders = bswapLE16(pfh.norders);
 	pfh.nsamples = bswapLE16(pfh.nsamples);
@@ -104,6 +104,7 @@ BOOL CSoundFile_ReadPTM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	{
 		MODINSTRUMENT *pins = &_this->Ins[ismp+1];
 		PTMSAMPLE *psmp = (PTMSAMPLE *)(lpStream+dwMemPos);
+
 		pins->nGlobalVol = 64;
 		pins->nPan = 128;
 		pins->nVolume = psmp->volume << 2;
@@ -149,48 +150,49 @@ BOOL CSoundFile_ReadPTM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 			if (b)
 			{
 				UINT nChn = b & 0x1F;
+				MODCOMMAND *selm = &m[nChn < _this->m_nChannels ? nChn : 0];
 
 				if (b & 0x20)
 				{
 					if (dwMemPos + 2 > dwMemLength) break;
-					m[nChn].note = lpStream[dwMemPos++];
-					m[nChn].instr = lpStream[dwMemPos++];
+					selm->note = lpStream[dwMemPos++];
+					selm->instr = lpStream[dwMemPos++];
 				}
 				if (b & 0x40)
 				{
 					if (dwMemPos + 2 > dwMemLength) break;
-					m[nChn].command = lpStream[dwMemPos++];
-					m[nChn].param = lpStream[dwMemPos++];
-					if ((m[nChn].command == 0x0E) && ((m[nChn].param & 0xF0) == 0x80))
+					selm->command = lpStream[dwMemPos++];
+					selm->param = lpStream[dwMemPos++];
+					if ((selm->command == 0x0E) && ((selm->param & 0xF0) == 0x80))
 					{
-						m[nChn].command = CMD_S3MCMDEX;
+						selm->command = CMD_S3MCMDEX;
 					} else
-					if (m[nChn].command < 0x10)
+					if (selm->command < 0x10)
 					{
-						CSoundFile_ConvertModCommand(_this, &m[nChn]);
+						CSoundFile_ConvertModCommand(_this, selm);
 					} else
 					{
-						switch(m[nChn].command)
+						switch(selm->command)
 						{
 						case 16:
-							m[nChn].command = CMD_GLOBALVOLUME;
+							selm->command = CMD_GLOBALVOLUME;
 							break;
 						case 17:
-							m[nChn].command = CMD_RETRIG;
+							selm->command = CMD_RETRIG;
 							break;
 						case 18:
-							m[nChn].command = CMD_FINEVIBRATO;
+							selm->command = CMD_FINEVIBRATO;
 							break;
 						default:
-							m[nChn].command = 0;
+							selm->command = 0;
 						}
 					}
 				}
 				if (b & 0x80)
 				{
 					if (dwMemPos >= dwMemLength) break;
-					m[nChn].volcmd = VOLCMD_VOLUME;
-					m[nChn].vol = lpStream[dwMemPos++];
+					selm->volcmd = VOLCMD_VOLUME;
+					selm->vol = lpStream[dwMemPos++];
 				}
 			} else
 			{
@@ -201,4 +203,3 @@ BOOL CSoundFile_ReadPTM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	}
 	return TRUE;
 }
-

data/dependencies/SDL_sound/libmodplug/load_s3m.c

@@ -6,9 +6,8 @@
 */
 
 #include "libmodplug.h"
-#include "tables.h"
 
-//////////////////////////////////////////////////////
+////////////////////////////////////////////////////////
 // ScreamTracker S3M file support
 
 #pragma pack(1)
@@ -34,7 +33,6 @@ typedef struct tagS3MSAMPLESTRUCT
 	CHAR scrs[4];
 } S3MSAMPLESTRUCT;
 
-
 typedef struct tagS3MFILEHEADER
 {
 	CHAR name[28];
@@ -58,6 +56,7 @@ typedef struct tagS3MFILEHEADER
 	WORD special;
 	BYTE channels[32];
 } S3MFILEHEADER;
+#pragma pack()
 
 
 void CSoundFile_S3MConvert(MODCOMMAND *m, BOOL bIT)
@@ -106,7 +105,6 @@ static DWORD boundInput(DWORD input, DWORD smin, DWORD smax)
 	return(input);
 }
 
-
 BOOL CSoundFile_ReadS3M(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLength)
 //---------------------------------------------------------------
 {
@@ -118,7 +116,7 @@ BOOL CSoundFile_ReadS3M(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 
 	if ((!lpStream) || (dwMemLength <= sizeof(S3MFILEHEADER)+sizeof(S3MSAMPLESTRUCT)+64)) return FALSE;
 	S3MFILEHEADER psfh;
-    SDL_memcpy(&psfh, lpStream, sizeof (psfh));
+	SDL_memcpy(&psfh, lpStream, sizeof (psfh));
 
 	psfh.reserved1 = bswapLE16(psfh.reserved1);
 	psfh.ordnum = bswapLE16(psfh.ordnum);
@@ -169,6 +167,7 @@ BOOL CSoundFile_ReadS3M(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	if (iord > MAX_ORDERS) iord = MAX_ORDERS;
 	if (iord)
 	{
+		if (dwMemPos + iord > dwMemLength) return FALSE;
 		SDL_memcpy(_this->Order, lpStream+dwMemPos, iord);
 		dwMemPos += iord;
 	}
@@ -186,6 +185,8 @@ BOOL CSoundFile_ReadS3M(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 
 	if (nins+npat)
 	{
+		if (2*(nins+npat) + dwMemPos > dwMemLength) return FALSE;
+
 		SDL_memcpy(ptr, lpStream+dwMemPos, 2*(nins+npat));
 		dwMemPos += 2*(nins+npat);
 		for (UINT j = 0; j < (nins+npat); ++j) {
@@ -193,6 +194,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;
 			for (UINT i=0; i<32; i++) if (chnpan[i] & 0x20)
 			{
@@ -315,11 +318,10 @@ BOOL CSoundFile_ReadS3M(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 		if (inspack[iRaw-1] == 4) flags = RS_ADPCM4;
 		dwMemPos = insfile[iRaw];
 		if (dwMemPos < dwMemLength)
-			dwMemPos += CSoundFile_ReadSample(_this, &_this->Ins[iRaw], flags, (LPSTR)(lpStream + dwMemPos), dwMemLength - dwMemPos);
+			CSoundFile_ReadSample(_this, &_this->Ins[iRaw], flags, (LPSTR)(lpStream + dwMemPos), dwMemLength - dwMemPos);
 	}
 	_this->m_nMinPeriod = 64;
 	_this->m_nMaxPeriod = 32767;
 	if (psfh.flags & 0x10) _this->m_dwSongFlags |= SONG_AMIGALIMITS;
 	return TRUE;
 }
-

data/dependencies/SDL_sound/libmodplug/load_stm.c

@@ -61,8 +61,8 @@ BOOL CSoundFile_ReadSTM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	
 	if ((!lpStream) || (dwMemLength < sizeof(STMHEADER))) return FALSE;
 	if ((phdr->filetype != 2) || (phdr->unused != 0x1A)
-	 || ((SDL_strncasecmp(phdr->trackername, "!SCREAM!", 8))
-	  && (SDL_strncasecmp(phdr->trackername, "BMOD2STM", 8)))) return FALSE;
+	 || ((SDL_strncmp(phdr->trackername, "!Scream!", 8))
+	  && (SDL_strncmp(phdr->trackername, "BMOD2STM", 8)))) return FALSE;
 	// Read STM header
 	_this->m_nType = MOD_TYPE_STM;
 	_this->m_nSamples = 31;
@@ -101,6 +101,7 @@ BOOL CSoundFile_ReadSTM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	dwMemPos = sizeof(STMHEADER);
 	for (UINT nOrd=0; nOrd<MAX_ORDERS; nOrd++) if (_this->Order[nOrd] >= 99) _this->Order[nOrd] = 0xFF;
 	UINT nPatterns = phdr->numpat;
+	if (nPatterns > MAX_PATTERNS) nPatterns = MAX_PATTERNS;
 	for (UINT nPat=0; nPat<nPatterns; nPat++)
 	{
 		if (dwMemPos + 64*4*4 > dwMemLength) return TRUE;

data/dependencies/SDL_sound/libmodplug/load_ult.c

@@ -137,11 +137,12 @@ BOOL CSoundFile_ReadUlt(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 			UINT row = 0;
 			while (row < 64)
 			{
-				if (dwMemPos + 6 > dwMemLength) return TRUE;
+				if (dwMemPos + 5 > dwMemLength) 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;
@@ -203,4 +204,3 @@ BOOL CSoundFile_ReadUlt(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	}
 	return TRUE;
 }
-