gosu 1.4.5.pre1 → 1.4.5

data/dependencies/SDL_sound/libmodplug/load_mt2.c

@@ -200,6 +200,7 @@ BOOL CSoundFile_ReadMT2(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 	const MT2DRUMSDATA *pdd;
 	const MT2INSTRUMENT *InstrMap[255];
 	const MT2SAMPLE *SampleMap[256];
+	UINT i, j;
 
 	if ((!lpStream) || (dwMemLength < sizeof(MT2FILEHEADER) + 4)
 	 || (pfh->dwMT20 != 0x3032544D)
@@ -215,9 +216,9 @@ BOOL CSoundFile_ReadMT2(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 	{
 		_this->m_nDefaultTempo = 110250 / pfh->wSamplesPerTick;
 	}
-	for (UINT iOrd=0; iOrd<MAX_ORDERS; iOrd++)
+	for (j=0; j<MAX_ORDERS; j++)
 	{
-		_this->Order[iOrd] = (BYTE)((iOrd < pfh->nOrders) ? pfh->Orders[iOrd] : 0xFF);
+		_this->Order[j] = (BYTE)((j < pfh->nOrders) ? pfh->Orders[j] : 0xFF);
 	}
 	dwMemPos = sizeof(MT2FILEHEADER);
 	if (dwMemPos+2 > dwMemLength) return TRUE;
@@ -253,21 +254,24 @@ BOOL CSoundFile_ReadMT2(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 	}
 	// Load Patterns
 	dwMemPos = dwExtraDataPos + nExtraDataLen;
-	for (UINT iPat=0; iPat<pfh->wPatterns; iPat++) if (dwMemPos < dwMemLength-6)
+	for (j=0; j<pfh->wPatterns; j++) if (dwMemPos < dwMemLength-6)
 	{
 		const MT2PATTERN *pmp = (MT2PATTERN *)(lpStream+dwMemPos);
 		UINT wDataLen = (pmp->wDataLen + 1) & ~1;
+		UINT nLines;
 		dwMemPos += 6;
 		if (dwMemPos > dwMemLength - wDataLen || wDataLen > dwMemLength) break;
 
-		UINT nLines = pmp->wLines;
-		if ((iPat < MAX_PATTERNS) && (nLines > 0) && (nLines <= 256))
+		nLines = pmp->wLines;
+		if ((j < MAX_PATTERNS) && (nLines > 0) && (nLines <= 256))
 		{
-			_this->PatternSize[iPat] = nLines;
-			_this->Patterns[iPat] = CSoundFile_AllocatePattern(nLines, _this->m_nChannels);
-			if (!_this->Patterns[iPat]) return TRUE;
-			MODCOMMAND *m = _this->Patterns[iPat];
-			UINT len = wDataLen;
+			MODCOMMAND *m;
+			UINT len;
+			_this->PatternSize[j] = nLines;
+			_this->Patterns[j] = CSoundFile_AllocatePattern(nLines, _this->m_nChannels);
+			if (!_this->Patterns[j]) return TRUE;
+			m = _this->Patterns[j];
+			len = wDataLen;
 			if (len <= 4) return TRUE;
 
 			if (pfh->fulFlags & 1) // Packed Patterns
@@ -323,10 +327,11 @@ BOOL CSoundFile_ReadMT2(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 	// Skip Drum Patterns
 	if (pdd)
 	{
-		for (UINT iDrm=0; iDrm<pdd->wDrumPatterns; iDrm++)
+		for (j=0; j<pdd->wDrumPatterns; j++)
 		{
+			UINT nLines;
 			if (dwMemPos > dwMemLength-2) return TRUE;
-			UINT nLines = *(WORD *)(lpStream+dwMemPos);
+			nLines = *(WORD *)(lpStream+dwMemPos);
 			dwMemPos += 2 + nLines * 32;
 		}
 	}
@@ -337,14 +342,15 @@ BOOL CSoundFile_ReadMT2(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 		if (pfh->fulFlags & 0x10) nAutoCount++; // Master Automation
 		if ((pfh->fulFlags & 0x08) && (pdd)) nAutoCount += 8; // Drums Automation
 		nAutoCount *= pfh->wPatterns;
-		for (UINT iAuto=0; iAuto<nAutoCount; iAuto++)
+		for (j=0; j<nAutoCount; j++)
 		{
+			const MT2AUTOMATION *pma;
 			if (dwMemPos+12 >= dwMemLength) return TRUE;
-			const MT2AUTOMATION *pma = (MT2AUTOMATION *)(lpStream+dwMemPos);
+			pma = (MT2AUTOMATION *)(lpStream+dwMemPos);
 			dwMemPos += (pfh->wVersion <= 0x201) ? 4 : 8;
-			for (UINT iEnv=0; iEnv<14; iEnv++)
+			for (i=0; i<14; i++)
 			{
-				if (pma->dwFlags & (1 << iEnv))
+				if (pma->dwFlags & (1 << i))
 				{
 					dwMemPos += 260;
 				}
@@ -354,20 +360,22 @@ BOOL CSoundFile_ReadMT2(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 	// Load Instruments
 	SDL_memset(InstrMap, 0, sizeof(InstrMap));
 	_this->m_nInstruments = (pfh->wInstruments < MAX_INSTRUMENTS) ? pfh->wInstruments : MAX_INSTRUMENTS-1;
-	for (UINT iIns=1; iIns<=255; iIns++)
+	for (j=1; j<=255; j++)
 	{
+		const MT2INSTRUMENT *pmi;
+		INSTRUMENTHEADER *penv;
 		if (dwMemPos+36 > dwMemLength) return TRUE;
-		const MT2INSTRUMENT *pmi = (MT2INSTRUMENT *)(lpStream+dwMemPos);
-		INSTRUMENTHEADER *penv = NULL;
-		if (iIns <= _this->m_nInstruments)
+		pmi = (MT2INSTRUMENT *)(lpStream+dwMemPos);
+		penv = NULL;
+		if (j <= _this->m_nInstruments)
 		{
 			penv = (INSTRUMENTHEADER *) SDL_calloc(1,sizeof(INSTRUMENTHEADER));
-			_this->Headers[iIns] = penv;
+			_this->Headers[j] = penv;
 			if (penv)
 			{
 				penv->nGlobalVol = 64;
 				penv->nPan = 128;
-				for (UINT i=0; i<NOTE_MAX; i++)
+				for (i=0; i<NOTE_MAX; i++)
 				{
 					penv->NoteMap[i] = i+1;
 				}
@@ -377,15 +385,15 @@ BOOL CSoundFile_ReadMT2(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 		if (pmi->dwDataLen > 0)
 		{
 			if (dwMemPos + sizeof(MT2INSTRUMENT) - 4 > dwMemLength) return TRUE;
-			InstrMap[iIns-1] = pmi;
+			InstrMap[j-1] = pmi;
 			if (penv && pmi->dwDataLen >= sizeof(MT2INSTRUMENT) - 40)
 			{
+				MT2ENVELOPE *pehdr[4];
+				WORD *pedata[4];
 				penv->nFadeOut = pmi->wFadeOut;
 				penv->nNNA = pmi->wNNA & 3;
 				penv->nDCT = (pmi->wNNA>>8) & 3;
 				penv->nDNA = (pmi->wNNA>>12) & 3;
-				MT2ENVELOPE *pehdr[4];
-				WORD *pedata[4];
 				if (pfh->wVersion <= 0x201)
 				{
 					DWORD dwEnvPos = dwMemPos + sizeof(MT2INSTRUMENT) - 4;
@@ -400,7 +408,7 @@ BOOL CSoundFile_ReadMT2(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 				{
 					DWORD dwEnvPos = dwMemPos + sizeof(MT2INSTRUMENT);
 					if (dwEnvPos > dwMemLength) return TRUE;
-					for (UINT i=0; i<4; i++)
+					for (i=0; i<4; i++)
 					{
 						if (pmi->wEnvFlags1 & (1<<i))
 						{
@@ -420,12 +428,12 @@ BOOL CSoundFile_ReadMT2(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 
 				}
 				// Load envelopes
-				for (UINT iEnv=0; iEnv<4; iEnv++) if (pehdr[iEnv])
+				for (i=0; i<4; i++) if (pehdr[i])
 				{
-					const MT2ENVELOPE *pme = pehdr[iEnv];
+					const MT2ENVELOPE *pme = pehdr[i];
 					WORD *pEnvPoints = NULL;
 					BYTE *pEnvData = NULL;
-					switch(iEnv)
+					switch(i)
 					{
 					// Volume Envelope
 					case 0:
@@ -455,7 +463,7 @@ BOOL CSoundFile_ReadMT2(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 
 					// Pitch/Filter envelope
 					default:
-						if (pme->nFlags & 1) penv->dwFlags |= (iEnv==3) ? (ENV_PITCH|ENV_FILTER) : ENV_PITCH;
+						if (pme->nFlags & 1) penv->dwFlags |= (i==3) ? (ENV_PITCH|ENV_FILTER) : ENV_PITCH;
 						if (pme->nFlags & 2) penv->dwFlags |= ENV_PITCHSUSTAIN;
 						if (pme->nFlags & 4) penv->dwFlags |= ENV_PITCHLOOP;
 						penv->nPitchEnv = (pme->nPoints > 16) ? 16 : pme->nPoints;
@@ -466,13 +474,14 @@ BOOL CSoundFile_ReadMT2(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 						pEnvData = penv->PitchEnv;
 					}
 					// Envelope data
-					if ((pEnvPoints) && (pEnvData) && (pedata[iEnv]))
+					if ((pEnvPoints) && (pEnvData) && (pedata[i]))
 					{
-						WORD *psrc = pedata[iEnv];
-						for (UINT i=0; i<16; i++)
+						WORD *psrc = pedata[i];
+						UINT k = 0;
+						for (; k<16; k++)
 						{
-							pEnvPoints[i] = psrc[i*2];
-							pEnvData[i] = (BYTE)psrc[i*2+1];
+							pEnvPoints[k] = psrc[k*2];
+							pEnvData[k] = (BYTE)psrc[k*2+1];
 						}
 					}
 				}
@@ -486,17 +495,18 @@ BOOL CSoundFile_ReadMT2(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 	}
 	SDL_memset(SampleMap, 0, sizeof(SampleMap));
 	_this->m_nSamples = (pfh->wSamples < MAX_SAMPLES) ? pfh->wSamples : MAX_SAMPLES-1;
-	for (UINT iSmp=1; iSmp<=256; iSmp++)
+	for (j=1; j<=256; j++)
 	{
+		const MT2SAMPLE *pms;
 		if (dwMemPos > dwMemLength - 36) return TRUE;
-		const MT2SAMPLE *pms = (MT2SAMPLE *)(lpStream+dwMemPos);
+		pms = (MT2SAMPLE *)(lpStream+dwMemPos);
 		if (pms->dwDataLen > dwMemLength - (dwMemPos+36)) return TRUE;
 		if (pms->dwDataLen > 0)
 		{
-			SampleMap[iSmp-1] = pms;
-			if (iSmp < MAX_SAMPLES)
+			SampleMap[j-1] = pms;
+			if (j < MAX_SAMPLES)
 			{
-				MODINSTRUMENT *psmp = &_this->Ins[iSmp];
+				MODINSTRUMENT *psmp = &_this->Ins[j];
 				psmp->nGlobalVol = 64;
 				if (dwMemPos+sizeof(MT2SAMPLE) > dwMemLength) return TRUE;
 				psmp->nVolume = (pms->wVolume >> 7);
@@ -519,22 +529,23 @@ BOOL CSoundFile_ReadMT2(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 			dwMemPos += 36;
 		}
 	}
-	for (UINT iMap=0; iMap<255; iMap++) if (InstrMap[iMap])
+	for (j=0; j<255; j++) if (InstrMap[j])
 	{
-		const MT2INSTRUMENT *pmi = InstrMap[iMap];
+		const MT2INSTRUMENT *pmi = InstrMap[j];
 		INSTRUMENTHEADER *penv = NULL;
-		if (iMap<_this->m_nInstruments) penv = _this->Headers[iMap+1];
-		for (UINT iGrp=0; iGrp<pmi->wSamples; iGrp++)
+		if (j<_this->m_nInstruments) penv = _this->Headers[j+1];
+		for (i=0; i<pmi->wSamples; i++)
 		{
 			if (penv && dwMemPos < dwMemLength && dwMemPos < dwMemLength - 8)
 			{
 				const MT2GROUP *pmg = (MT2GROUP *)(lpStream+dwMemPos);
-				for (UINT i=0; i<96; i++)
+				UINT k = 0;
+				for (; k<96; k++)
 				{
-					if (pmi->GroupsMapping[i] == iGrp)
+					if (pmi->GroupsMapping[k] == i)
 					{
 						UINT nSmp = pmg->nSmpNo+1;
-						penv->Keyboard[i+12] = (BYTE)nSmp;
+						penv->Keyboard[k+12] = (BYTE)nSmp;
 						if (nSmp <= _this->m_nSamples)
 						{
 							_this->Ins[nSmp].nVibType = pmi->bVibType;
@@ -548,10 +559,10 @@ BOOL CSoundFile_ReadMT2(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 			dwMemPos += 8;
 		}
 	}
-	for (UINT iData=0; iData<256; iData++) if ((iData < _this->m_nSamples) && (SampleMap[iData]))
+	for (j=0; j<256; j++) if ((j < _this->m_nSamples) && (SampleMap[j]))
 	{
-		const MT2SAMPLE *pms = SampleMap[iData];
-		MODINSTRUMENT *psmp = &_this->Ins[iData+1];
+		const MT2SAMPLE *pms = SampleMap[j];
+		MODINSTRUMENT *psmp = &_this->Ins[j+1];
 		if (!(pms->nFlags & 5))
 		{
 			if (psmp->nLength > 0 && dwMemPos < dwMemLength)

data/dependencies/SDL_sound/libmodplug/load_mtm.c

@@ -45,7 +45,10 @@ BOOL CSoundFile_ReadMTM(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 //-----------------------------------------------------------
 {
 	MTMHEADER *pmh = (MTMHEADER *)lpStream;
+	LPCBYTE pTracks;
+	LPWORD pSeq;
 	DWORD dwMemPos = 66;
+	UINT i, j;
 
 	if ((!lpStream) || (dwMemLength < 0x100)) return FALSE;
 	if ((SDL_strncmp(pmh->id, "MTM", 3)) || (pmh->numchannels > 32)
@@ -60,12 +63,13 @@ BOOL CSoundFile_ReadMTM(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 	_this->m_nSamples = pmh->numsamples;
 	_this->m_nChannels = pmh->numchannels;
 	// Reading instruments
-	for	(UINT i=1; i<=_this->m_nSamples; i++)
+	for	(i=1; i<=_this->m_nSamples; i++)
 	{
 		MTMSAMPLE *pms = (MTMSAMPLE *)(lpStream + dwMemPos);
+		DWORD len;
 		_this->Ins[i].nVolume = pms->volume << 2;
 		_this->Ins[i].nGlobalVol = 64;
-		DWORD len = pms->length;
+		len = pms->length;
 		if ((len > 4) && (len <= MAX_SAMPLE_LENGTH))
 		{
 			_this->Ins[i].nLength = len;
@@ -89,32 +93,34 @@ BOOL CSoundFile_ReadMTM(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 		dwMemPos += 37;
 	}
 	// Setting Channel Pan Position
-	for (UINT ich=0; ich<_this->m_nChannels; ich++)
+	for (i=0; i<_this->m_nChannels; i++)
 	{
-		_this->ChnSettings[ich].nPan = ((pmh->panpos[ich] & 0x0F) << 4) + 8;
-		_this->ChnSettings[ich].nVolume = 64;
+		_this->ChnSettings[i].nPan = ((pmh->panpos[i] & 0x0F) << 4) + 8;
+		_this->ChnSettings[i].nVolume = 64;
 	}
 	// Reading pattern order
 	SDL_memcpy(_this->Order, lpStream + dwMemPos, pmh->lastorder+1);
 	dwMemPos += 128;
 	// Reading Patterns
-	LPCBYTE pTracks = lpStream + dwMemPos;
+	pTracks = lpStream + dwMemPos;
 	dwMemPos += 192 * pmh->numtracks;
-	LPWORD pSeq = (LPWORD)(lpStream + dwMemPos);
-	for (UINT pat=0; pat<=pmh->lastpattern; pat++)
+	pSeq = (LPWORD)(lpStream + dwMemPos);
+	for (j=0; j<=pmh->lastpattern; j++)
 	{
-		_this->PatternSize[pat] = 64;
-		if ((_this->Patterns[pat] = CSoundFile_AllocatePattern(64, _this->m_nChannels)) == NULL) break;
-		for (UINT n=0; n<32; n++) if ((pSeq[n]) && (pSeq[n] <= pmh->numtracks) && (n < _this->m_nChannels))
+		UINT n;
+		_this->PatternSize[j] = 64;
+		if ((_this->Patterns[j] = CSoundFile_AllocatePattern(64, _this->m_nChannels)) == NULL) break;
+		for (n=0; n<32; n++) if ((pSeq[n]) && (pSeq[n] <= pmh->numtracks) && (n < _this->m_nChannels))
 		{
 			LPCBYTE p = pTracks + 192 * (pSeq[n]-1);
-			MODCOMMAND *m = _this->Patterns[pat] + n;
-			for (UINT i=0; i<64; i++, m+=_this->m_nChannels, p+=3)
+			MODCOMMAND *m = _this->Patterns[j] + n;
+			for (i=0; i<64; i++, m+=_this->m_nChannels, p+=3)
 			{
+				UINT cmd, param;
 				if (p[0] & 0xFC) m->note = (p[0] >> 2) + 37;
 				m->instr = ((p[0] & 0x03) << 4) | (p[1] >> 4);
-				UINT cmd = p[1] & 0x0F;
-				UINT param = p[2];
+				cmd = p[1] & 0x0F;
+				param = p[2];
 				if (cmd == 0x0A)
 				{
 					if (param & 0xF0) param &= 0xF0; else param &= 0x0F;
@@ -129,10 +135,10 @@ BOOL CSoundFile_ReadMTM(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 	dwMemPos += 64*(pmh->lastpattern+1);
 	dwMemPos += pmh->commentsize;
 	// Reading Samples
-	for (UINT ismp=1; ismp<=_this->m_nSamples; ismp++)
+	for (i=1; i<=_this->m_nSamples; i++)
 	{
 		if (dwMemPos >= dwMemLength) break;
-		dwMemPos += CSoundFile_ReadSample(_this, &_this->Ins[ismp], (_this->Ins[ismp].uFlags & CHN_16BIT) ? RS_PCM16U : RS_PCM8U,
+		dwMemPos += CSoundFile_ReadSample(_this, &_this->Ins[i], (_this->Ins[i].uFlags & CHN_16BIT) ? RS_PCM16U : RS_PCM8U,
 								(LPSTR)(lpStream + dwMemPos), dwMemLength - dwMemPos);
 	}
 	_this->m_nMinPeriod = 64;

data/dependencies/SDL_sound/libmodplug/load_okt.c

@@ -48,7 +48,8 @@ BOOL CSoundFile_ReadOKT(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 {
 	const OKTFILEHEADER *pfh = (OKTFILEHEADER *)lpStream;
 	DWORD dwMemPos = sizeof(OKTFILEHEADER), dwSize;
-	UINT nsamples = 0, norders = 0;//, npatterns = 0
+	UINT nsamples = 0, norders = 0, npat = 0, nsmp = 1;//, npatterns = 0
+	UINT i;
 
 	if ((!lpStream) || (dwMemLength < 1024)) return FALSE;
 	if ((bswapBE32(pfh->okta) != MAGIC('O','K','T','A'))
@@ -65,13 +66,13 @@ BOOL CSoundFile_ReadOKT(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	_this->m_nSamples = nsamples;
 	if (_this->m_nSamples >= MAX_SAMPLES) _this->m_nSamples = MAX_SAMPLES-1;
 	// Reading samples
-	for (UINT smp=1; smp <= nsamples; smp++)
+	for (i=1; i <= nsamples; i++)
 	{
 		if (dwMemPos >= dwMemLength - sizeof(OKTSAMPLE)) return TRUE;
-		if (smp < MAX_SAMPLES)
+		if (i < MAX_SAMPLES)
 		{
 			const OKTSAMPLE *psmp = (const OKTSAMPLE *)(lpStream + dwMemPos);
-			MODINSTRUMENT *pins = &_this->Ins[smp];
+			MODINSTRUMENT *pins = &_this->Ins[i];
 
 			pins->uFlags = 0;
 			pins->nLength = bswapBE32(psmp->length) & ~1;
@@ -121,15 +122,14 @@ BOOL CSoundFile_ReadOKT(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 		UINT orderlen = norders;
 		if (orderlen >= MAX_ORDERS) orderlen = MAX_ORDERS-1;
 		if (dwMemPos + 8 + orderlen > dwMemLength) return TRUE;
-		for (UINT i=0; i<orderlen; i++) _this->Order[i] = lpStream[dwMemPos+8+i];
-		for (UINT j=orderlen; j>1; j--) { if (_this->Order[j-1]) break; _this->Order[j-1] = 0xFF; }
+		for (i=0; i<orderlen; i++) _this->Order[i] = lpStream[dwMemPos+8+i];
+		for (i=orderlen; i>1; i--) { if (_this->Order[i-1]) break; _this->Order[i-1] = 0xFF; }
 
 		dwSize = readBE32(lpStream + dwMemPos + 4);
 		if (dwSize > dwMemLength - 8 || dwMemPos > dwMemLength - dwSize - 8) return TRUE;
 		dwMemPos += dwSize + 8;
 	}
 	// PBOD
-	UINT npat = 0;
 	while ((dwMemPos < dwMemLength - 10) && (readBE32(lpStream + dwMemPos) == MAGIC('P','B','O','D')))
 	{
 		DWORD dwPos = dwMemPos + 10;
@@ -137,22 +137,26 @@ BOOL CSoundFile_ReadOKT(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 		if (!rows) rows = 64;
 		if (npat < MAX_PATTERNS)
 		{
+			MODCOMMAND *m;
+			UINT imax;
 			if ((_this->Patterns[npat] = CSoundFile_AllocatePattern(rows, _this->m_nChannels)) == NULL) return TRUE;
-			MODCOMMAND *m = _this->Patterns[npat];
+			m = _this->Patterns[npat];
 			_this->PatternSize[npat] = rows;
-			UINT imax = _this->m_nChannels*rows;
-			for (UINT i=0; i<imax; i++, m++, dwPos+=4)
+			imax = _this->m_nChannels*rows;
+			for (i=0; i<imax; i++, m++, dwPos+=4)
 			{
+				const BYTE *p;
+				UINT note, command, param;
 				if (dwPos+4 > dwMemLength) break;
-				const BYTE *p = lpStream+dwPos;
-				UINT note = p[0];
+				p = lpStream+dwPos;
+				note = p[0];
 				if (note)
 				{
 					m->note = note + 48;
 					m->instr = p[1] + 1;
 				}
-				UINT command = p[2];
-				UINT param = p[3];
+				command = p[2];
+				param = p[3];
 				m->param = param;
 				switch(command)
 				{
@@ -208,7 +212,6 @@ BOOL CSoundFile_ReadOKT(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 		dwMemPos += dwSize + 8;
 	}
 	// SBOD
-	UINT nsmp = 1;
 	while ((dwMemPos < dwMemLength-10) && (readBE32(lpStream + dwMemPos) == MAGIC('S','B','O','D')))
 	{
 		if (nsmp < MAX_SAMPLES) CSoundFile_ReadSample(_this, &_this->Ins[nsmp], RS_PCM8S, (LPSTR)(lpStream+dwMemPos+8), dwMemLength-dwMemPos-8);
@@ -220,4 +223,3 @@ BOOL CSoundFile_ReadOKT(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	}
 	return TRUE;
 }
-

data/dependencies/SDL_sound/libmodplug/load_psm.c

@@ -101,6 +101,8 @@ BOOL CSoundFile_ReadPSM(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 	DWORD patptrs[MAX_PATTERNS];
 	BYTE samplemap[MAX_SAMPLES];
 	UINT nPatterns = 0;
+	const PSMSONGHDR *pSong;
+	UINT j;
 
 	if (dwMemLength < 256) return FALSE;
 
@@ -120,20 +122,22 @@ BOOL CSoundFile_ReadPSM(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 	nPatterns = 0;
 	dwMemPos = 12;
 	dwSongPos = 0;
-	for (UINT iChPan=0; iChPan<16; iChPan++)
+	for (j=0; j<16; j++)
 	{
-		UINT pan = (((iChPan & 3) == 1) || ((iChPan&3)==2)) ? 0xC0 : 0x40;
-		_this->ChnSettings[iChPan].nPan = pan;
+		UINT pan = (((j & 3) == 1) || ((j&3)==2)) ? 0xC0 : 0x40;
+		_this->ChnSettings[j].nPan = pan;
 	}
 	while (dwMemPos+8 < dwMemLength)
 	{
 		PSMCHUNK pchunk;
+		PUCHAR pdata;
+		ULONG len;
 		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;
+		pdata = (PUCHAR)(lpStream+dwMemPos);
+		len = pchunk.len;
 		if (len) switch(pchunk.id)
 		{
 		// "PBOD": Pattern
@@ -154,9 +158,10 @@ BOOL CSoundFile_ReadPSM(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 		case IFFID_DSMP:
 			if ((len >= sizeof(PSMSAMPLE)) && (_this->m_nSamples+1 < MAX_SAMPLES))
 			{
-				_this->m_nSamples++;
-				MODINSTRUMENT *pins = &_this->Ins[_this->m_nSamples];
+				MODINSTRUMENT *pins;
 				PSMSAMPLE psmp;
+				_this->m_nSamples++;
+				pins = &_this->Ins[_this->m_nSamples];
 				SDL_memcpy(&psmp, pdata, sizeof(PSMSAMPLE));
 				swap_PSMSAMPLE(&psmp);
 			//	smpnames[_this->m_nSamples] = psmp.smpid;
@@ -188,7 +193,7 @@ BOOL CSoundFile_ReadPSM(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 		dwMemPos += pchunk.len;
 	}
 	// Step #1: convert song structure
-	const PSMSONGHDR *pSong = (const PSMSONGHDR *)(lpStream+dwSongPos+8);
+	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
@@ -198,26 +203,30 @@ BOOL CSoundFile_ReadPSM(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 		while (dwMemPos + 8 < dwSongEnd)
 		{
 			PSMCHUNK pchunk;
+			PUCHAR pdata;
+			ULONG len;
 			SDL_memcpy(&pchunk, lpStream+dwMemPos, sizeof(PSMCHUNK));
 			swap_PSMCHUNK(&pchunk);
 			dwMemPos += 8;
 			if ((pchunk.len > dwSongEnd) || (dwMemPos + pchunk.len > dwSongEnd)) break;
-			PUCHAR pdata = (PUCHAR)(lpStream+dwMemPos);
-			ULONG len = pchunk.len;
+			pdata = (PUCHAR)(lpStream+dwMemPos);
+			len = pchunk.len;
 			switch(pchunk.id)
 			{
 			case IFFID_OPLH:
 				if (len >= 0x20)
 				{
 					UINT pos = len - 3;
+					UINT i = 0;
 					while (pos > 5)
 					{
 						BOOL bFound = FALSE;
+						DWORD dwName;
 						pos -= 5;
-						DWORD dwName = *(DWORD *)(pdata+pos);
-						for (UINT i=0; i<nPatterns; i++)
+						dwName = *(DWORD *)(pdata+pos);
+						for (j=0; j<nPatterns; j++)
 						{
-							DWORD dwPatName = ((const PSMPATTERN *)(lpStream+patptrs[i]+8))->name;
+							DWORD dwPatName = ((const PSMPATTERN *)(lpStream+patptrs[j]+8))->name;
 							if (dwName == dwPatName)
 							{
 								bFound = TRUE;
@@ -232,16 +241,15 @@ BOOL CSoundFile_ReadPSM(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 							break;
 						}
 					}
-					UINT iOrd = 0;
-					while ((pos+5<len) && (iOrd < MAX_ORDERS))
+					while ((pos+5<len) && (i < MAX_ORDERS))
 					{
 						DWORD dwName = *(DWORD *)(pdata+pos);
-						for (UINT i=0; i<nPatterns; i++)
+						for (j=0; j<nPatterns; j++)
 						{
-							DWORD dwPatName = ((const PSMPATTERN *)(lpStream+patptrs[i]+8))->name;
+							DWORD dwPatName = ((const PSMPATTERN *)(lpStream+patptrs[j]+8))->name;
 							if (dwName == dwPatName)
 							{
-								_this->Order[iOrd++] = i;
+								_this->Order[i++] = j;
 								break;
 							}
 						}
@@ -255,28 +263,32 @@ BOOL CSoundFile_ReadPSM(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 	}
 
 	// Step #2: convert patterns
-	for (UINT nPat=0; nPat<nPatterns; nPat++)
+	for (j=0; j<nPatterns; j++)
 	{
 		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];
-		const BYTE *p = lpStream + patptrs[nPat] + 20;
+		ULONG len;
+		UINT nRows;
+		MODCOMMAND *m;
+		const BYTE *p;
 		MODCOMMAND *sp, dummy;
 		UINT pos = 0;
 		UINT row = 0;
 		UINT rowlim;
 		UINT flags, ch;
+		SDL_memcpy(&pPsmPat, lpStream+patptrs[j]+8, sizeof(PSMPATTERN));
+		swap_PSMPATTERN(&pPsmPat);
+		SDL_memcpy(&pchunk, lpStream+patptrs[j], sizeof(PSMCHUNK));
+		swap_PSMCHUNK(&pchunk);
+
+		len = pchunk.len - 12;
+		nRows = pPsmPat.rows;
+		if (len > pPsmPat.size) len = pPsmPat.size;
+		if ((nRows < 64) || (nRows > 256)) nRows = 64;
+		_this->PatternSize[j] = nRows;
+		if ((_this->Patterns[j] = CSoundFile_AllocatePattern(nRows, _this->m_nChannels)) == NULL) break;
+		m = _this->Patterns[j];
+		p = lpStream + patptrs[j] + 20;
 		rowlim = bswapLE16(pPsmPat.reserved1)-2;
 		while ((row < nRows) && (pos+3 < len))
 		{

data/dependencies/SDL_sound/libmodplug/load_ptm.c

@@ -64,11 +64,12 @@ static uint32_t BS2WORD(uint16_t w[2]) {
 BOOL CSoundFile_ReadPTM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLength)
 //---------------------------------------------------------------
 {
+	PTMFILEHEADER pfh;
 	DWORD dwMemPos;
 	UINT nOrders;
+	UINT j;
 
 	if ((!lpStream) || (dwMemLength < sizeof(PTMFILEHEADER))) return FALSE;
-	PTMFILEHEADER pfh;
 	SDL_memcpy(&pfh, lpStream, sizeof (pfh));
 
 	pfh.norders = bswapLE16(pfh.norders);
@@ -78,7 +79,7 @@ BOOL CSoundFile_ReadPTM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	pfh.fileflags = bswapLE16(pfh.fileflags);
 	pfh.reserved2 = bswapLE16(pfh.reserved2);
 	pfh.ptmf_id = bswapLE32(pfh.ptmf_id);
-	for (UINT j=0; j<128; j++)
+	for (j=0; j<128; j++)
         {
 	        pfh.patseg[j] = bswapLE16(pfh.patseg[j]);
 	}
@@ -95,14 +96,14 @@ BOOL CSoundFile_ReadPTM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	dwMemPos = SIZEOF_PTMFILEHEADER;
 	nOrders = (pfh.norders < MAX_ORDERS) ? pfh.norders : MAX_ORDERS-1;
 	SDL_memcpy(_this->Order, pfh.orders, nOrders);
-	for (UINT ipan=0; ipan<_this->m_nChannels; ipan++)
+	for (j=0; j<_this->m_nChannels; j++)
 	{
-		_this->ChnSettings[ipan].nVolume = 64;
-		_this->ChnSettings[ipan].nPan = ((pfh.chnpan[ipan] & 0x0F) << 4) + 4;
+		_this->ChnSettings[j].nVolume = 64;
+		_this->ChnSettings[j].nPan = ((pfh.chnpan[j] & 0x0F) << 4) + 4;
 	}
-	for (UINT ismp=0; ismp<_this->m_nSamples; ismp++, dwMemPos += SIZEOF_PTMSAMPLE)
+	for (j=0; j<_this->m_nSamples; j++, dwMemPos += SIZEOF_PTMSAMPLE)
 	{
-		MODINSTRUMENT *pins = &_this->Ins[ismp+1];
+		MODINSTRUMENT *pins = &_this->Ins[j+1];
 		PTMSAMPLE *psmp = (PTMSAMPLE *)(lpStream+dwMemPos);
 
 		pins->nGlobalVol = 64;
@@ -113,10 +114,11 @@ BOOL CSoundFile_ReadPTM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 		if ((psmp->sampletype & 3) == 1)
 		{
 			UINT smpflg = RS_PCM8D;
+			DWORD samplepos;
 			pins->nLength = BS2WORD(psmp->length);
 			pins->nLoopStart = BS2WORD(psmp->loopbeg);
 			pins->nLoopEnd = BS2WORD(psmp->loopend);
-			DWORD samplepos = BS2WORD(psmp->fileofs);
+			samplepos = BS2WORD(psmp->fileofs);
 			if (psmp->sampletype & 4) pins->uFlags |= CHN_LOOP;
 			if (psmp->sampletype & 8) pins->uFlags |= CHN_PINGPONGLOOP;
 			if (psmp->sampletype & 16)
@@ -134,15 +136,17 @@ BOOL CSoundFile_ReadPTM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 		}
 	}
 	// Reading Patterns
-	for (UINT ipat=0; ipat<pfh.npatterns; ipat++)
+	for (j=0; j<pfh.npatterns; j++)
 	{
-		dwMemPos = ((UINT)pfh.patseg[ipat]) << 4;
+		MODCOMMAND *m;
+		UINT row;
+		dwMemPos = ((UINT)pfh.patseg[j]) << 4;
 		if ((!dwMemPos) || (dwMemPos >= dwMemLength)) continue;
-		_this->PatternSize[ipat] = 64;
-		if ((_this->Patterns[ipat] = CSoundFile_AllocatePattern(64, _this->m_nChannels)) == NULL) break;
+		_this->PatternSize[j] = 64;
+		if ((_this->Patterns[j] = CSoundFile_AllocatePattern(64, _this->m_nChannels)) == NULL) break;
 		//
-		MODCOMMAND *m = _this->Patterns[ipat];
-		for (UINT row=0; ((row < 64) && (dwMemPos < dwMemLength)); )
+		m = _this->Patterns[j];
+		for (row=0; ((row < 64) && (dwMemPos < dwMemLength)); )
 		{
 			UINT b = lpStream[dwMemPos++];