gosu 1.4.5.pre1 → 1.4.5

data/dependencies/SDL_sound/libmodplug/load_s3m.c

@@ -109,14 +109,15 @@ static DWORD boundInput(DWORD input, DWORD smin, DWORD smax)
 BOOL CSoundFile_ReadS3M(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLength)
 //---------------------------------------------------------------
 {
-	UINT insnum,patnum,nins,npat;
+	S3MFILEHEADER psfh;
+	UINT insnum,patnum,nins,npat,iord;
 	DWORD insfile[MAX_SAMPLES];
 	WORD ptr[256];
 	DWORD dwMemPos;
 	BYTE insflags[MAX_SAMPLES], inspack[MAX_SAMPLES];
+	UINT i, j;
 
 	if ((!lpStream) || (dwMemLength <= sizeof(S3MFILEHEADER)+sizeof(S3MSAMPLESTRUCT)+64)) return FALSE;
-	S3MFILEHEADER psfh;
 	SDL_memcpy(&psfh, lpStream, sizeof (psfh));
 
 	psfh.reserved1 = bswapLE16(psfh.reserved1);
@@ -146,24 +147,25 @@ BOOL CSoundFile_ReadS3M(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	_this->m_nSongPreAmp = psfh.mastervol & 0x7F;
 	// Channels
 	_this->m_nChannels = 4;
-	for (UINT ich=0; ich<32; ich++)
+	for (i=0; i<32; i++)
 	{
-		_this->ChnSettings[ich].nPan = 128;
-		_this->ChnSettings[ich].nVolume = 64;
+		_this->ChnSettings[i].nPan = 128;
+		_this->ChnSettings[i].nVolume = 64;
 
-		_this->ChnSettings[ich].dwFlags = CHN_MUTE;
-		if (psfh.channels[ich] != 0xFF)
+		_this->ChnSettings[i].dwFlags = CHN_MUTE;
+		if (psfh.channels[i] != 0xFF)
 		{
-			_this->m_nChannels = ich+1;
-			UINT b = psfh.channels[ich] & 0x0F;
-			_this->ChnSettings[ich].nPan = (b & 8) ? 0xC0 : 0x40;
-			_this->ChnSettings[ich].dwFlags = 0;
+			UINT b;
+			_this->m_nChannels = i+1;
+			b = psfh.channels[i] & 0x0F;
+			_this->ChnSettings[i].nPan = (b & 8) ? 0xC0 : 0x40;
+			_this->ChnSettings[i].dwFlags = 0;
 		}
 	}
 	if (_this->m_nChannels < 4) _this->m_nChannels = 4;
 	if ((psfh.cwtv < 0x1320) || (psfh.flags & 0x40)) _this->m_dwSongFlags |= SONG_FASTVOLSLIDES;
 	// Reading pattern order
-	UINT iord = psfh.ordnum;
+	iord = psfh.ordnum;
 	if (iord<1) iord = 1;
 	if (iord > MAX_ORDERS) iord = MAX_ORDERS;
 	if (dwMemPos + iord + 1 >= dwMemLength) return FALSE;
@@ -190,14 +192,14 @@ BOOL CSoundFile_ReadS3M(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 		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) {
+		for (j = 0; j < (nins+npat); ++j) {
 		        ptr[j] = bswapLE16(ptr[j]);
 		}
 		if (psfh.panning_present == 252)
 		{
 			const BYTE *chnpan = lpStream+dwMemPos;
 			if (dwMemPos > dwMemLength - 32) return FALSE;
-			for (UINT i=0; i<32; i++) if (chnpan[i] & 0x20)
+			for (i=0; i<32; i++) if (chnpan[i] & 0x20)
 			{
 				_this->ChnSettings[i].nPan = ((chnpan[i] & 0x0F) << 4) + 8;
 			}
@@ -206,60 +208,64 @@ BOOL CSoundFile_ReadS3M(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	if (!_this->m_nChannels) return TRUE;
 	// Reading instrument headers
 	SDL_memset(insfile, 0, sizeof(insfile));
-	for (UINT iSmp=1; iSmp<=insnum; iSmp++)
+	for (i=1; i<=insnum; i++)
 	{
-		UINT nInd = ((DWORD)ptr[iSmp-1])*16;
+		UINT nInd = ((DWORD)ptr[i-1])*16;
+		S3MSAMPLESTRUCT pSmp;
 		if ((!nInd) || (nInd + 0x50 > dwMemLength)) {
 			// initialize basic variables.
-			insflags[iSmp-1] = 0;
-			inspack[iSmp-1] = 0;
+			insflags[i-1] = 0;
+			inspack[i-1] = 0;
 			continue;
 		}
-		S3MSAMPLESTRUCT pSmp;
 		SDL_memcpy(&pSmp, lpStream+nInd, 0x50);
-		insflags[iSmp-1] = pSmp.flags;
-		inspack[iSmp-1] = pSmp.pack;
+		insflags[i-1] = pSmp.flags;
+		inspack[i-1] = pSmp.pack;
 		if ((pSmp.type==1) && (pSmp.scrs[2]=='R') && (pSmp.scrs[3]=='S'))
 		{
-			_this->Ins[iSmp].nLength = boundInput(bswapLE32(pSmp.length), 4, MAX_SAMPLE_LENGTH);
-			_this->Ins[iSmp].nLoopStart = boundInput(bswapLE32(pSmp.loopbegin), 4, _this->Ins[iSmp].nLength - 1);
-			_this->Ins[iSmp].nLoopEnd = boundInput(bswapLE32(pSmp.loopend), 4, _this->Ins[iSmp].nLength);
-			_this->Ins[iSmp].nVolume = boundInput(pSmp.vol, 0, 64) << 2;
-			_this->Ins[iSmp].nGlobalVol = 64;
-			if (pSmp.flags&1) _this->Ins[iSmp].uFlags |= CHN_LOOP;
-			UINT j = bswapLE32(pSmp.finetune);
+			_this->Ins[i].nLength = boundInput(bswapLE32(pSmp.length), 4, MAX_SAMPLE_LENGTH);
+			_this->Ins[i].nLoopStart = boundInput(bswapLE32(pSmp.loopbegin), 4, _this->Ins[i].nLength - 1);
+			_this->Ins[i].nLoopEnd = boundInput(bswapLE32(pSmp.loopend), 4, _this->Ins[i].nLength);
+			_this->Ins[i].nVolume = boundInput(pSmp.vol, 0, 64) << 2;
+			_this->Ins[i].nGlobalVol = 64;
+			if (pSmp.flags&1) _this->Ins[i].uFlags |= CHN_LOOP;
+			j = bswapLE32(pSmp.finetune);
 			if (!j) j = 8363;
 			if (j < 1024) j = 1024;
-			_this->Ins[iSmp].nC4Speed = j;
-			insfile[iSmp] = (pSmp.hmem << 20) + (bswapLE16(pSmp.memseg) << 4);
+			_this->Ins[i].nC4Speed = j;
+			insfile[i] = (pSmp.hmem << 20) + (bswapLE16(pSmp.memseg) << 4);
 			// offset is invalid - ignore this sample.
-			if (insfile[iSmp] > dwMemLength) insfile[iSmp] = 0;
-			else if (insfile[iSmp]) {
+			if (insfile[i] > dwMemLength) insfile[i] = 0;
+			else if (insfile[i]) {
 				// ignore duplicate samples.
-				for (int z=iSmp-1; z>=0; z--)
-					if (insfile[iSmp] == insfile[z])
-						insfile[iSmp] = 0;
+				int z = i - 1;
+				for (; z>=0; z--)
+					if (insfile[i] == insfile[z])
+						insfile[i] = 0;
 			}
-			if ((_this->Ins[iSmp].nLoopStart >= _this->Ins[iSmp].nLoopEnd) || (_this->Ins[iSmp].nLoopEnd - _this->Ins[iSmp].nLoopStart < 8))
-				_this->Ins[iSmp].nLoopStart = _this->Ins[iSmp].nLoopEnd = 0;
-			_this->Ins[iSmp].nPan = 0x80;
+			if ((_this->Ins[i].nLoopStart >= _this->Ins[i].nLoopEnd) || (_this->Ins[i].nLoopEnd - _this->Ins[i].nLoopStart < 8))
+				_this->Ins[i].nLoopStart = _this->Ins[i].nLoopEnd = 0;
+			_this->Ins[i].nPan = 0x80;
 		}
 	}
 	// Reading patterns
-	for (UINT iPat=0; iPat<patnum; iPat++)
+	for (i=0; i<patnum; i++)
 	{
-		UINT nInd = ((DWORD)ptr[nins+iPat]) << 4;
+		LPBYTE src;
+		MODCOMMAND *p;
+		UINT nInd = ((DWORD)ptr[nins+i]) << 4;
+		UINT row = 0;
+		WORD len;
 		if (nInd + 0x40 > dwMemLength) continue;
-		WORD len = bswapLE16(*((WORD *)(lpStream+nInd)));
+		len = bswapLE16(*((WORD *)(lpStream+nInd)));
 		nInd += 2;
-		_this->PatternSize[iPat] = 64;
+		_this->PatternSize[i] = 64;
 		if ((!len) || (nInd + len > dwMemLength - 6)
-		 || ((_this->Patterns[iPat] = CSoundFile_AllocatePattern(64, _this->m_nChannels)) == NULL)) continue;
-		LPBYTE src = (LPBYTE)(lpStream+nInd);
+		 || ((_this->Patterns[i] = CSoundFile_AllocatePattern(64, _this->m_nChannels)) == NULL)) continue;
+		src = (LPBYTE)(lpStream+nInd);
 		// Unpacking pattern
-		MODCOMMAND *p = _this->Patterns[iPat];
-		UINT row = 0;
-		UINT j = 0;
+		p = _this->Patterns[i];
+		j = 0;
 		while (j < len)
 		{
 			BYTE b = src[j++];
@@ -310,15 +316,15 @@ BOOL CSoundFile_ReadS3M(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 		}
 	}
 	// Reading samples
-	for (UINT iRaw=1; iRaw<=insnum; iRaw++) if ((_this->Ins[iRaw].nLength) && (insfile[iRaw]))
+	for (i=1; i<=insnum; i++) if ((_this->Ins[i].nLength) && (insfile[i]))
 	{
 		UINT flags = (psfh.version == 1) ? RS_PCM8S : RS_PCM8U;
-		if (insflags[iRaw-1] & 4) flags += 5;
-		if (insflags[iRaw-1] & 2) flags |= RSF_STEREO;
-		if (inspack[iRaw-1] == 4) flags = RS_ADPCM4;
-		dwMemPos = insfile[iRaw];
+		if (insflags[i-1] & 4) flags += 5;
+		if (insflags[i-1] & 2) flags |= RSF_STEREO;
+		if (inspack[i-1] == 4) flags = RS_ADPCM4;
+		dwMemPos = insfile[i];
 		if (dwMemPos < dwMemLength)
-			CSoundFile_ReadSample(_this, &_this->Ins[iRaw], flags, (LPSTR)(lpStream + dwMemPos), dwMemLength - dwMemPos);
+			CSoundFile_ReadSample(_this, &_this->Ins[i], flags, (LPSTR)(lpStream + dwMemPos), dwMemLength - dwMemPos);
 	}
 	_this->m_nMinPeriod = 64;
 	_this->m_nMaxPeriod = 32767;

data/dependencies/SDL_sound/libmodplug/load_stm.c

@@ -58,6 +58,8 @@ BOOL CSoundFile_ReadSTM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 {
 	const STMHEADER *phdr = (STMHEADER *)lpStream;
 	DWORD dwMemPos = 0;
+	UINT nPatterns;
+	UINT j;
 	
 	if ((!lpStream) || (dwMemLength < sizeof(STMHEADER))) return FALSE;
 	if ((phdr->filetype != 2) || (phdr->unused != 0x1A)
@@ -77,17 +79,17 @@ BOOL CSoundFile_ReadSTM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	if (_this->m_nDefaultGlobalVolume > 256) _this->m_nDefaultGlobalVolume = 256;
 	SDL_memcpy(_this->Order, phdr->patorder, 128);
 	// Setting up channels
-	for (UINT nSet=0; nSet<4; nSet++)
+	for (j=0; j<4; j++)
 	{
-		_this->ChnSettings[nSet].dwFlags = 0;
-		_this->ChnSettings[nSet].nVolume = 64;
-		_this->ChnSettings[nSet].nPan = (nSet & 1) ? 0x40 : 0xC0;
+		_this->ChnSettings[j].dwFlags = 0;
+		_this->ChnSettings[j].nVolume = 64;
+		_this->ChnSettings[j].nPan = (j & 1) ? 0x40 : 0xC0;
 	}
 	// Reading samples
-	for (UINT nIns=0; nIns<31; nIns++)
+	for (j=0; j<31; j++)
 	{
-		MODINSTRUMENT *pIns = &_this->Ins[nIns+1];
-		const STMSAMPLE *pStm = &phdr->sample[nIns];  // STM sample data
+		MODINSTRUMENT *pIns = &_this->Ins[j+1];
+		const STMSAMPLE *pStm = &phdr->sample[j];  // STM sample data
 		pIns->nC4Speed = bswapLE16(pStm->c2spd);
 		pIns->nGlobalVol = 64;
 		pIns->nVolume = pStm->volume << 2;
@@ -99,17 +101,20 @@ BOOL CSoundFile_ReadSTM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 		if ((pIns->nLoopEnd > pIns->nLoopStart) && (pIns->nLoopEnd != 0xFFFF)) pIns->uFlags |= CHN_LOOP;
 	}
 	dwMemPos = sizeof(STMHEADER);
-	for (UINT nOrd=0; nOrd<MAX_ORDERS; nOrd++) if (_this->Order[nOrd] >= 99) _this->Order[nOrd] = 0xFF;
-	UINT nPatterns = phdr->numpat;
+	for (j=0; j<MAX_ORDERS; j++) if (_this->Order[j] >= 99) _this->Order[j] = 0xFF;
+	nPatterns = phdr->numpat;
 	if (nPatterns > MAX_PATTERNS) nPatterns = MAX_PATTERNS;
-	for (UINT nPat=0; nPat<nPatterns; nPat++)
+	for (j=0; j<nPatterns; j++)
 	{
+		MODCOMMAND *m;
+		const STMNOTE *p;
+		UINT n;
 		if (dwMemPos + 64*4*4 > dwMemLength) return TRUE;
-		_this->PatternSize[nPat] = 64;
-		if ((_this->Patterns[nPat] = CSoundFile_AllocatePattern(64, _this->m_nChannels)) == NULL) return TRUE;
-		MODCOMMAND *m = _this->Patterns[nPat];
-		const STMNOTE *p = (const STMNOTE *)(lpStream + dwMemPos);
-		for (UINT n=0; n<64*4; n++, p++, m++)
+		_this->PatternSize[j] = 64;
+		if ((_this->Patterns[j] = CSoundFile_AllocatePattern(64, _this->m_nChannels)) == NULL) return TRUE;
+		m = _this->Patterns[j];
+		p = (const STMNOTE *)(lpStream + dwMemPos);
+		for (n=0; n<64*4; n++, p++, m++)
 		{
 			UINT note,ins,vol,cmd;
 			// extract the various information from the 4 bytes that
@@ -162,13 +167,13 @@ BOOL CSoundFile_ReadSTM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 		dwMemPos += 64*4*4;
 	}
 	// Reading Samples
-	for (UINT nSmp=1; nSmp<=31; nSmp++)
+	for (j=1; j<=31; j++)
 	{
-		MODINSTRUMENT *pIns = &_this->Ins[nSmp];
+		MODINSTRUMENT *pIns = &_this->Ins[j];
 		dwMemPos = (dwMemPos + 15) & (~15);
 		if (pIns->nLength)
 		{
-			UINT nPos = ((UINT)phdr->sample[nSmp-1].reserved) << 4;
+			UINT nPos = ((UINT)phdr->sample[j-1].reserved) << 4;
 			if ((nPos >= sizeof(STMHEADER)) && (nPos+pIns->nLength <= dwMemLength)) dwMemPos = nPos;
 			if (dwMemPos < dwMemLength)
 			{

data/dependencies/SDL_sound/libmodplug/load_ult.c

@@ -43,8 +43,9 @@ BOOL CSoundFile_ReadUlt(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 {
 	ULTHEADER *pmh = (ULTHEADER *)lpStream;
 	ULTSAMPLE *pus;
-	UINT nos, nop;
+	UINT nos, nop, j;
 	DWORD dwMemPos = 0;
+	UINT smpsize = 64;
 
 	// try to read module header
 	if ((!lpStream) || (dwMemLength < 0x100)) return FALSE;
@@ -65,13 +66,13 @@ BOOL CSoundFile_ReadUlt(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	nos = lpStream[dwMemPos++];
 	_this->m_nSamples = nos;
 	if (_this->m_nSamples >= MAX_SAMPLES) _this->m_nSamples = MAX_SAMPLES-1;
-	UINT smpsize = 64;
 	if (pmh->id[14] >= '4')	smpsize += 2;
 	if (dwMemPos + nos*smpsize + 256 + 2 > dwMemLength) return TRUE;
-	for (UINT ins=1; ins<=nos; ins++, dwMemPos+=smpsize) if (ins<=_this->m_nSamples)
+	for (j=1; j<=nos; j++, dwMemPos+=smpsize) if (j<=_this->m_nSamples)
 	{
+		MODINSTRUMENT *pins;
 		pus	= (ULTSAMPLE *)(lpStream+dwMemPos);
-		MODINSTRUMENT *pins = &_this->Ins[ins];
+		pins = &_this->Ins[j];
 		pins->nLoopStart = pus->loopstart;
 		pins->nLoopEnd = pus->loopend;
 		pins->nLength = pus->sizeend - pus->sizestart;
@@ -98,48 +99,50 @@ BOOL CSoundFile_ReadUlt(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	dwMemPos += 2;
 	if (_this->m_nChannels > 32) _this->m_nChannels = 32;
 	// Default channel settings
-	for (UINT nSet=0; nSet<_this->m_nChannels; nSet++)
+	for (j=0; j<_this->m_nChannels; j++)
 	{
-		_this->ChnSettings[nSet].nVolume = 64;
-		_this->ChnSettings[nSet].nPan = (nSet & 1) ? 0x40 : 0xC0;
+		_this->ChnSettings[j].nVolume = 64;
+		_this->ChnSettings[j].nPan = (j & 1) ? 0x40 : 0xC0;
 	}
 	// read pan position table for v1.5 and higher
 	if(pmh->id[14]>='3')
 	{
 		if (dwMemPos + _this->m_nChannels > dwMemLength) return TRUE;
-		for(UINT t=0; t<_this->m_nChannels; t++)
+		for(j=0; j<_this->m_nChannels; j++)
 		{
-			_this->ChnSettings[t].nPan = (lpStream[dwMemPos++] << 4) + 8;
-			if (_this->ChnSettings[t].nPan > 256) _this->ChnSettings[t].nPan = 256;
+			_this->ChnSettings[j].nPan = (lpStream[dwMemPos++] << 4) + 8;
+			if (_this->ChnSettings[j].nPan > 256) _this->ChnSettings[j].nPan = 256;
 		}
 	}
 	// Allocating Patterns
-	for (UINT nAllocPat=0; nAllocPat<nop; nAllocPat++)
+	for (j=0; j<nop; j++)
 	{
-		if (nAllocPat < MAX_PATTERNS)
+		if (j < MAX_PATTERNS)
 		{
-			_this->PatternSize[nAllocPat] = 64;
-			_this->Patterns[nAllocPat] = CSoundFile_AllocatePattern(64, _this->m_nChannels);
+			_this->PatternSize[j] = 64;
+			_this->Patterns[j] = CSoundFile_AllocatePattern(64, _this->m_nChannels);
 		}
 	}
 	// Reading Patterns
-	for (UINT nChn=0; nChn<_this->m_nChannels; nChn++)
+	for (j=0; j<_this->m_nChannels; j++)
 	{
-		for (UINT nPat=0; nPat<nop; nPat++)
+		UINT nPat=0;
+		for ( ; nPat<nop; nPat++)
 		{
 			MODCOMMAND *pat = NULL;
+			UINT row = 0;
 
 			if (nPat < MAX_PATTERNS)
 			{
 				pat = _this->Patterns[nPat];
-				if (pat) pat += nChn;
+				if (pat) pat += j;
 			}
-			UINT row = 0;
 			while (row < 64)
 			{
+				UINT rep, note, instr, eff, dat1, dat2, cmd1, cmd2;
 				if (dwMemPos > dwMemLength - 5) return TRUE;
-				UINT rep = 1;
-				UINT note = lpStream[dwMemPos++];
+				rep = 1;
+				note = lpStream[dwMemPos++];
 				if (note == 0xFC)
 				{
 					rep = lpStream[dwMemPos];
@@ -148,12 +151,12 @@ BOOL CSoundFile_ReadUlt(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 					if (dwMemPos > dwMemLength - 4) return TRUE;
 				}
 
-				UINT instr = lpStream[dwMemPos++];
-				UINT eff = lpStream[dwMemPos++];
-				UINT dat1 = lpStream[dwMemPos++];
-				UINT dat2 = lpStream[dwMemPos++];
-				UINT cmd1 = eff & 0x0F;
-				UINT cmd2 = eff >> 4;
+				instr = lpStream[dwMemPos++];
+				eff = lpStream[dwMemPos++];
+				dat1 = lpStream[dwMemPos++];
+				dat2 = lpStream[dwMemPos++];
+				cmd1 = eff & 0x0F;
+				cmd2 = eff >> 4;
 				if (cmd1 == 0x0C) dat1 >>= 2; else
 				if (cmd1 == 0x0B) { cmd1 = dat1 = 0; }
 				if (cmd2 == 0x0C) dat2 >>= 2; else
@@ -197,11 +200,12 @@ BOOL CSoundFile_ReadUlt(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 		}
 	}
 	// Reading Instruments
-	for (UINT smp=1; smp<=_this->m_nSamples; smp++) if (_this->Ins[smp].nLength)
+	for (j=1; j<=_this->m_nSamples; j++) if (_this->Ins[j].nLength)
 	{
+		UINT flags;
 		if (dwMemPos >= dwMemLength) return TRUE;
-		UINT flags = (_this->Ins[smp].uFlags & CHN_16BIT) ? RS_PCM16S : RS_PCM8S;
-		dwMemPos += CSoundFile_ReadSample(_this, &_this->Ins[smp], flags, (LPSTR)(lpStream+dwMemPos), dwMemLength - dwMemPos);
+		flags = (_this->Ins[j].uFlags & CHN_16BIT) ? RS_PCM16S : RS_PCM8S;
+		dwMemPos += CSoundFile_ReadSample(_this, &_this->Ins[j], flags, (LPSTR)(lpStream+dwMemPos), dwMemLength - dwMemPos);
 	}
 	return TRUE;
 }