gosu 1.4.5.pre1 → 1.4.5

data/dependencies/SDL_sound/libmodplug/load_dbm.c

@@ -97,6 +97,7 @@ BOOL CSoundFile_ReadDBM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	const DBMFILEHEADER *pfh = (DBMFILEHEADER *)lpStream;
 	DWORD dwMemPos;
 	UINT nOrders, nSamples, nInstruments, nPatterns;
+	UINT i;
 	
 	if ((!lpStream) || (dwMemLength <= sizeof(DBMFILEHEADER)) || (!pfh->channels)
 	 || (pfh->dbm_id != bswapLE32(DBM_FILE_MAGIC)) || (!pfh->songs) || (pfh->song_id != bswapLE32(DBM_ID_SONG))
@@ -112,10 +113,10 @@ BOOL CSoundFile_ReadDBM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	_this->m_nChannels = bswapBE16(pfh->channels);
 	if (_this->m_nChannels < 4) _this->m_nChannels = 4;
 	if (_this->m_nChannels > 64) _this->m_nChannels = 64;
-	for (UINT iOrd=0; iOrd < nOrders; iOrd++)
+	for (i=0; i < nOrders; i++)
 	{
-		_this->Order[iOrd] = lpStream[dwMemPos+iOrd*2+1];
-		if (iOrd >= MAX_ORDERS-2) break;
+		_this->Order[i] = lpStream[dwMemPos+i*2+1];
+		if (i >= MAX_ORDERS-2) break;
 	}
 	dwMemPos += 2*nOrders;
 	while (dwMemPos + 10 < dwMemLength)
@@ -135,19 +136,19 @@ BOOL CSoundFile_ReadDBM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 			if (_this->m_nInstruments) continue;
 
 			if (nInstruments >= MAX_INSTRUMENTS) nInstruments = MAX_INSTRUMENTS-1;
-			for (UINT iIns=0; iIns<nInstruments; iIns++)
+			for (i=0; i<nInstruments; i++)
 			{
 				MODINSTRUMENT *psmp;
 				INSTRUMENTHEADER *penv;
 				DBMINSTRUMENT *pih;
-				UINT nsmp;
+				UINT nsmp, j;
 
 				if (chunk_pos + sizeof(DBMINSTRUMENT) > dwMemPos) break;
 				if ((penv = (INSTRUMENTHEADER *) SDL_calloc(1, sizeof (INSTRUMENTHEADER))) == NULL) break;
 				pih = (DBMINSTRUMENT *)(lpStream+chunk_pos);
 				nsmp = bswapBE16(pih->sampleno);
 				psmp = ((nsmp) && (nsmp < MAX_SAMPLES)) ? &_this->Ins[nsmp] : NULL;
-				_this->Headers[iIns+1] = penv;
+				_this->Headers[i+1] = penv;
 				penv->nFadeOut = 1024;	// ???
 				penv->nGlobalVol = 64;
 				penv->nPan = bswapBE16(pih->panning);
@@ -156,20 +157,21 @@ BOOL CSoundFile_ReadDBM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 				else
 					penv->nPan = 128;
 				penv->nPPC = 5*12;
-				for (UINT i=0; i<NOTE_MAX; i++)
+				for (j=0; j<NOTE_MAX; j++)
 				{
-					penv->Keyboard[i] = nsmp;
-					penv->NoteMap[i] = i+1;
+					penv->Keyboard[j] = nsmp;
+					penv->NoteMap[j] = j+1;
 				}
 				// Sample Info
 				if (psmp)
 				{
 					DWORD sflags = bswapBE16(pih->flags);
+					int f2t;
 					psmp->nVolume = bswapBE16(pih->volume) * 4;
 					if ((!psmp->nVolume) || (psmp->nVolume > 256)) psmp->nVolume = 256;
 					psmp->nGlobalVol = 64;
 					psmp->nC4Speed = bswapBE32(pih->finetune);
-					int f2t = CSoundFile_FrequencyToTranspose(psmp->nC4Speed);
+					f2t = CSoundFile_FrequencyToTranspose(psmp->nC4Speed);
 					psmp->RelativeTone = f2t >> 7;
 					psmp->nFineTune = f2t & 0x7F;
 					if ((pih->looplen) && (sflags & 3))
@@ -182,7 +184,7 @@ BOOL CSoundFile_ReadDBM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 					}
 				}
 				chunk_pos += sizeof(DBMINSTRUMENT);
-				_this->m_nInstruments = iIns+1;
+				_this->m_nInstruments = i+1;
 			}
 		} else
 		// Volume Envelopes
@@ -191,7 +193,7 @@ BOOL CSoundFile_ReadDBM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 			UINT nEnvelopes = lpStream[chunk_pos+1];
 			
 			chunk_pos += 2;
-			for (UINT iEnv=0; iEnv<nEnvelopes; iEnv++)
+			for (i=0; i<nEnvelopes; i++)
 			{
 				DBMENVELOPE *peh;
 				UINT nins;
@@ -202,6 +204,7 @@ BOOL CSoundFile_ReadDBM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 				if ((nins) && (nins < MAX_INSTRUMENTS) && (_this->Headers[nins]) && (peh->numpoints))
 				{
 					INSTRUMENTHEADER *penv = _this->Headers[nins];
+					UINT j;
 
 					if (peh->flags & 1) penv->dwFlags |= ENV_VOLUME;
 					if (peh->flags & 2) penv->dwFlags |= ENV_VOLSUSTAIN;
@@ -211,10 +214,10 @@ BOOL CSoundFile_ReadDBM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 					penv->nVolLoopStart = peh->loopbegin;
 					penv->nVolLoopEnd = peh->loopend;
 					penv->nVolSustainBegin = penv->nVolSustainEnd = peh->sustain1;
-					for (UINT i=0; i<penv->nVolEnv; i++)
+					for (j=0; j<penv->nVolEnv; j++)
 					{
-						penv->VolPoints[i] = bswapBE16(peh->volenv[i*2]);
-						penv->VolEnv[i] = (BYTE)bswapBE16(peh->volenv[i*2+1]);
+						penv->VolPoints[j] = bswapBE16(peh->volenv[j*2]);
+						penv->VolEnv[j] = (BYTE)bswapBE16(peh->volenv[j*2+1]);
 					}
 				}
 				chunk_pos += sizeof(DBMENVELOPE);
@@ -224,14 +227,14 @@ BOOL CSoundFile_ReadDBM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 		if (chunk_id == bswapLE32(DBM_ID_PATT))
 		{
 			if (nPatterns > MAX_PATTERNS) nPatterns = MAX_PATTERNS;
-			for (UINT iPat=0; iPat<nPatterns; iPat++)
+			for (i=0; i<nPatterns; i++)
 			{
 				DBMPATTERN *pph;
 				DWORD pksize;
 				UINT nRows;
 
 				// Skip duplicate chunks.
-				if (_this->Patterns[iPat]) break;
+				if (_this->Patterns[i]) break;
 
 				if (chunk_pos + sizeof(DBMPATTERN) > dwMemPos) break;
 				pph = (DBMPATTERN *)(lpStream+chunk_pos);
@@ -245,23 +248,23 @@ BOOL CSoundFile_ReadDBM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 					{
 						LPBYTE pkdata = (LPBYTE)pph->patterndata;
 						UINT row = 0;
-						UINT i = 0;
+						UINT n = 0;
 
-						_this->PatternSize[iPat] = nRows;
-						_this->Patterns[iPat] = m;
-						while ((i+3<pksize) && (row < nRows))
+						_this->PatternSize[i] = nRows;
+						_this->Patterns[i] = m;
+						while ((n+3<pksize) && (row < nRows))
 						{
-							UINT ch = pkdata[i++];
+							UINT ch = pkdata[n++];
 
 							if (ch)
 							{
-								BYTE b = pkdata[i++];
+								BYTE b = pkdata[n++];
 								ch--;
 								if (ch < _this->m_nChannels)
 								{
 									if (b & 0x01)
 									{
-										UINT note = pkdata[i++];
+										UINT note = pkdata[n++];
 
 										if (note == 0x1F) note = 0xFF; else
 										if ((note) && (note < 0xFE))
@@ -270,14 +273,14 @@ BOOL CSoundFile_ReadDBM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 										}
 										m[ch].note = note;
 									}
-									if (b & 0x02) m[ch].instr = pkdata[i++];
+									if (b & 0x02) m[ch].instr = pkdata[n++];
 									if (b & 0x3C)
 									{
 										UINT cmd1 = 0xFF, param1 = 0, cmd2 = 0xFF, param2 = 0;
-										if (b & 0x04) cmd1 = (UINT)pkdata[i++];
-										if (b & 0x08) param1 = pkdata[i++];
-										if (b & 0x10) cmd2 = (UINT)pkdata[i++];
-										if (b & 0x20) param2 = pkdata[i++];
+										if (b & 0x04) cmd1 = (UINT)pkdata[n++];
+										if (b & 0x08) param1 = pkdata[n++];
+										if (b & 0x10) cmd2 = (UINT)pkdata[n++];
+										if (b & 0x20) param2 = pkdata[n++];
 										if (cmd1 == 0x0C)
 										{
 											m[ch].volcmd = VOLCMD_VOLUME;
@@ -305,12 +308,12 @@ BOOL CSoundFile_ReadDBM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 									}
 								} else
 								{
-									if (b & 0x01) i++;
-									if (b & 0x02) i++;
-									if (b & 0x04) i++;
-									if (b & 0x08) i++;
-									if (b & 0x10) i++;
-									if (b & 0x20) i++;
+									if (b & 0x01) n++;
+									if (b & 0x02) n++;
+									if (b & 0x04) n++;
+									if (b & 0x08) n++;
+									if (b & 0x10) n++;
+									if (b & 0x20) n++;
 								}
 							} else
 							{
@@ -328,7 +331,7 @@ BOOL CSoundFile_ReadDBM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 		{
 			if (nSamples >= MAX_SAMPLES) nSamples = MAX_SAMPLES-1;
 			_this->m_nSamples = nSamples;
-			for (UINT iSmp=1; iSmp<=nSamples; iSmp++)
+			for (i=1; i<=nSamples; i++)
 			{
 				MODINSTRUMENT *pins;
 				DBMSAMPLE *psh;
@@ -340,7 +343,7 @@ BOOL CSoundFile_ReadDBM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 				chunk_pos += 8;
 				samplesize = bswapBE32(psh->samplesize);
 				sampleflags = bswapBE32(psh->flags);
-				pins = &_this->Ins[iSmp];
+				pins = &_this->Ins[i];
 				pins->nLength = samplesize;
 				if (sampleflags & 2)
 				{

data/dependencies/SDL_sound/libmodplug/load_dmf.c

@@ -83,6 +83,7 @@ BOOL CSoundFile_ReadDMF(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	DWORD dwMemPos;
 	BYTE infobyte[32];
 	BYTE smplflags[MAX_SAMPLES], hasSMPI = 0, hasSMPD = 0;
+	UINT i;
 
 	if ((!lpStream) || (dwMemLength < 1024)) return FALSE;
 	if ((pfh->id != 0x464d4444) || (!pfh->version) || (pfh->version & 0xF0)) return FALSE;
@@ -114,7 +115,7 @@ BOOL CSoundFile_ReadDMF(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 				UINT nseq = (sequ->seqsize - 4) >> 1;
 				if (nseq >= MAX_ORDERS-1) nseq = MAX_ORDERS-1;
 				if (sequ->loopstart < nseq) _this->m_nRestartPos = sequ->loopstart;
-				for (UINT i=0; i<nseq; i++) _this->Order[i] = (BYTE)sequ->sequ[i];
+				for (i=0; i<nseq; i++) _this->Order[i] = (BYTE)sequ->sequ[i];
 			}
 			dwMemPos += sequ->seqsize + 8;
 			break;
@@ -125,7 +126,7 @@ BOOL CSoundFile_ReadDMF(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 			if ((patt->patsize >= dwMemLength) || (dwMemPos + 8 > dwMemLength - patt->patsize)) goto dmfexit;
 			if (patt->patsize >= 4 && !_this->m_nChannels)
 			{
-				UINT numpat;
+				UINT numpat, c;
 				DWORD dwPos = dwMemPos + 11;
 				numpat = patt->numpat;
 				if (numpat > MAX_PATTERNS) numpat = MAX_PATTERNS;
@@ -133,38 +134,44 @@ BOOL CSoundFile_ReadDMF(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 				if (_this->m_nChannels < patt->firstpatinfo) _this->m_nChannels = patt->firstpatinfo;
 				if (_this->m_nChannels > 32) _this->m_nChannels = 32;
 				if (_this->m_nChannels < 4) _this->m_nChannels = 4;
-				for (UINT npat=0; npat<numpat; npat++)
+				for (c=0; c<numpat; c++)
 				{
 					const DMFTRACK *pt = (DMFTRACK *)(lpStream+dwPos);
+					MODCOMMAND *m;
+					UINT tracks, ticks, row;
+					UINT ttype, tempo, glbinfobyte, pbeat;
+					BOOL tempochange;
+					DWORD d;
 					if (dwPos + 8 >= dwMemLength) break;
-					UINT tracks = pt->tracks;
+					tracks = pt->tracks;
 					if (tracks > 32) tracks = 32;
-					UINT ticks = pt->ticks;
+					ticks = pt->ticks;
 					if (ticks > 256) ticks = 256;
 					if (ticks < 16) ticks = 16;
 					dwPos += 8;
 					if ((pt->jmpsize >= dwMemLength) || (dwPos + 4 > dwMemLength - pt->jmpsize)) break;
-					_this->PatternSize[npat] = (WORD)ticks;
-					MODCOMMAND *m = CSoundFile_AllocatePattern(_this->PatternSize[npat], _this->m_nChannels);
+					_this->PatternSize[c] = (WORD)ticks;
+					m = CSoundFile_AllocatePattern(_this->PatternSize[c], _this->m_nChannels);
 					if (!m) goto dmfexit;
-					_this->Patterns[npat] = m;
-					DWORD d = dwPos;
+					_this->Patterns[c] = m;
+					d = dwPos;
 					dwPos += pt->jmpsize;
-					UINT ttype = 1;
-					UINT tempo = 125;
-					UINT glbinfobyte = 0;
-					UINT pbeat = (pt->beat & 0xf0) ? pt->beat>>4 : 8;
-					BOOL tempochange = (pt->beat & 0xf0) ? TRUE : FALSE;
+					ttype = 1;
+					tempo = 125;
+					glbinfobyte = 0;
+					pbeat = (pt->beat & 0xf0) ? pt->beat>>4 : 8;
+					tempochange = (pt->beat & 0xf0) ? TRUE : FALSE;
 					SDL_memset(infobyte, 0, sizeof(infobyte));
-					for (UINT row=0; row<ticks; row++)
+					for (row=0; row<ticks; row++)
 					{
 						MODCOMMAND *p = &m[row*_this->m_nChannels];
 						// Parse track global effects
 						if (!glbinfobyte)
 						{
+							BYTE info, infoval;
 							if (d+1 > dwPos) break;
-							BYTE info = lpStream[d++];
-							BYTE infoval = 0;
+							info = lpStream[d++];
+							infoval = 0;
 							if ((info & 0x80) && (d < dwPos)) glbinfobyte = lpStream[d++];
 							info &= 0x7f;
 							if ((info) && (d < dwPos)) infoval = lpStream[d++];
@@ -179,12 +186,13 @@ BOOL CSoundFile_ReadDMF(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 							glbinfobyte--;
 						}
 						// Parse channels
-						for (UINT i=0; i<tracks; i++) if (!infobyte[i])
+						for (i=0; i<tracks; i++) if (!infobyte[i])
 						{
-							if (d+1 > dwPos) break;
 							MODCOMMAND cmd;
+							BYTE info;
+							if (d+1 > dwPos) break;
 							SDL_zero(cmd);
-							BYTE info = lpStream[d++];
+							info = lpStream[d++];
 							if (info & 0x80)
 							{
 								if (d+1 > dwPos) break;
@@ -214,10 +222,11 @@ BOOL CSoundFile_ReadDMF(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 							// Effect 1
 							if (info & 0x08)
 							{
+								BYTE efx, eval;
 								if (d+2 > dwPos) break;
 
-								BYTE efx = lpStream[d++];
-								BYTE eval = lpStream[d++];
+								efx = lpStream[d++];
+								eval = lpStream[d++];
 								switch(efx)
 								{
 								// 1: Key Off
@@ -234,10 +243,11 @@ BOOL CSoundFile_ReadDMF(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 							// Effect 2
 							if (info & 0x04)
 							{
+								BYTE efx, eval;
 								if (d+2 > dwPos) break;
 
-								BYTE efx = lpStream[d++];
-								BYTE eval = lpStream[d++];
+								efx = lpStream[d++];
+								eval = lpStream[d++];
 								switch(efx)
 								{
 								// 1: Finetune
@@ -263,10 +273,11 @@ BOOL CSoundFile_ReadDMF(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 							// Effect 3
 							if (info & 0x02)
 							{
+								BYTE efx, eval;
 								if (d+2 > dwPos) break;
 
-								BYTE efx = lpStream[d++];
-								BYTE eval = lpStream[d++];
+								efx = lpStream[d++];
+								eval = lpStream[d++];
 								switch(efx)
 								{
 								// 1: Vol Slide Up
@@ -303,27 +314,27 @@ BOOL CSoundFile_ReadDMF(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 						// Find free channel for tempo change
 						if (tempochange)
 						{
-							tempochange = FALSE;
 							UINT speed=6, modtempo=tempo;
 							UINT rpm = ((ttype) && (pbeat)) ? tempo*pbeat : (tempo+1)*15;
+							tempochange = FALSE;
 							for (speed=30; speed>1; speed--)
 							{
 								modtempo = rpm*speed/24;
 								if (modtempo <= 200) break;
 								if ((speed < 6) && (modtempo < 256)) break;
 							}
-							for (UINT ich=0; ich<_this->m_nChannels; ich++) if (!p[ich].command)
+							for (i=0; i<_this->m_nChannels; i++) if (!p[i].command)
 							{
 								if (speed)
 								{
-									p[ich].command = CMD_SPEED;
-									p[ich].param = (BYTE)speed;
+									p[i].command = CMD_SPEED;
+									p[i].param = (BYTE)speed;
 									speed = 0;
 								} else
 								if ((modtempo >= 32) && (modtempo < 256))
 								{
-									p[ich].command = CMD_TEMPO;
-									p[ich].param = (BYTE)modtempo;
+									p[i].command = CMD_TEMPO;
+									p[i].param = (BYTE)modtempo;
 									modtempo = 0;
 								} else
 								{
@@ -342,23 +353,26 @@ BOOL CSoundFile_ReadDMF(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 		// "SMPI": Sample Info
 		case 0x49504d53:
 			{
-				hasSMPI = 1;
 				const DMFSMPI *pds = (DMFSMPI *)(lpStream+dwMemPos);
+				hasSMPI = 1;
 				if ((pds->size >= dwMemLength) || (dwMemPos + 8 > dwMemLength - pds->size)) goto dmfexit;
 				if (pds->size >= 1)
 				{
 					DWORD dwPos = dwMemPos + 9;
 					_this->m_nSamples = pds->samples;
 					if (_this->m_nSamples >= MAX_SAMPLES) _this->m_nSamples = MAX_SAMPLES-1;
-					for (UINT iSmp=1; iSmp<=_this->m_nSamples; iSmp++)
+					for (i=1; i<=_this->m_nSamples; i++)
 					{
+						const DMFSAMPLE *psh;
+						MODINSTRUMENT *psmp;
+						UINT namelen;
 						if (dwPos >= dwMemPos + pds->size + 8) break;
-						const UINT namelen = lpStream[dwPos];
-						smplflags[iSmp] = 0;
+						namelen = lpStream[dwPos];
+						smplflags[i] = 0;
 						if (dwPos+namelen+1+sizeof(DMFSAMPLE) > dwMemPos+pds->size+8) break;
 						dwPos += namelen + 1;
-						const DMFSAMPLE *psh = (DMFSAMPLE *)(lpStream+dwPos);
-						MODINSTRUMENT *psmp = &_this->Ins[iSmp];
+						psh = (DMFSAMPLE *)(lpStream+dwPos);
+						psmp = &_this->Ins[i];
 						psmp->nLength = psh->len;
 						psmp->nLoopStart = psh->loopstart;
 						psmp->nLoopEnd = psh->loopend;
@@ -368,7 +382,7 @@ BOOL CSoundFile_ReadDMF(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 						psmp->uFlags = (psh->flags & 2) ? CHN_16BIT : 0;
 						if (psmp->uFlags & CHN_16BIT) psmp->nLength >>= 1;
 						if (psh->flags & 1) psmp->uFlags |= CHN_LOOP;
-						smplflags[iSmp] = psh->flags;
+						smplflags[i] = psh->flags;
 						dwPos += (pfh->version < 8) ? 22 : 30;
 					}
 				}
@@ -381,10 +395,10 @@ BOOL CSoundFile_ReadDMF(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 			{
 				DWORD dwPos = dwMemPos + 8;
 				UINT ismpd = 0;
-				for (UINT iSmp=1; iSmp<=_this->m_nSamples && !hasSMPD; iSmp++)
+				for (i=1; i<=_this->m_nSamples && !hasSMPD; i++)
 				{
-					ismpd++;
 					DWORD pksize;
+					ismpd++;
 					if (dwPos + 4 >= dwMemLength)
 					{
 						break;
@@ -395,12 +409,12 @@ BOOL CSoundFile_ReadDMF(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 					{
 						pksize = dwMemLength - dwPos;
 					}
-					if ((pksize) && (iSmp <= _this->m_nSamples))
+					if ((pksize) && (i <= _this->m_nSamples))
 					{
-						UINT flags = (_this->Ins[iSmp].uFlags & CHN_16BIT) ? RS_PCM16S : RS_PCM8S;
+						UINT flags = (_this->Ins[i].uFlags & CHN_16BIT) ? RS_PCM16S : RS_PCM8S;
 						if (hasSMPI && smplflags[ismpd] & 4)
-							flags = (_this->Ins[iSmp].uFlags & CHN_16BIT) ? RS_DMF16 : RS_DMF8;
-						CSoundFile_ReadSample(_this, &_this->Ins[iSmp], flags, (LPSTR)(lpStream+dwPos), pksize);
+							flags = (_this->Ins[i].uFlags & CHN_16BIT) ? RS_DMF16 : RS_DMF8;
+						CSoundFile_ReadSample(_this, &_this->Ins[i], flags, (LPSTR)(lpStream+dwPos), pksize);
 					}
 					dwPos += pksize;
 				}
@@ -521,7 +535,7 @@ int DMFUnpack(LPBYTE psample, LPBYTE ibuf, LPBYTE ibufmax, UINT maxlen)
 //----------------------------------------------------------------------
 {
 	DMF_HTREE tree;
-	UINT actnode;
+	UINT actnode,i;
 	BYTE value, sign, delta = 0;
 
 	SDL_memset(&tree, 0, sizeof(tree));
@@ -532,7 +546,7 @@ int DMFUnpack(LPBYTE psample, LPBYTE ibuf, LPBYTE ibufmax, UINT maxlen)
 
 	if (tree.ibuf >= ibufmax) return tree.ibuf - ibuf;
 
-	for (UINT i=0; i<maxlen; i++)
+	for (i=0; i<maxlen; i++)
 	{
 		if ((tree.ibuf >= tree.ibufmax) && (!tree.bitnum))
 		{
@@ -557,5 +571,3 @@ int DMFUnpack(LPBYTE psample, LPBYTE ibuf, LPBYTE ibufmax, UINT maxlen)
 	}
 	return tree.ibuf - ibuf;
 }
-
-

data/dependencies/SDL_sound/libmodplug/load_dsm.c

@@ -87,7 +87,7 @@ BOOL CSoundFile_ReadDSM(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 	DSMFILEHEADER *pfh = (DSMFILEHEADER *)lpStream;
 	DSMSONG *psong;
 	DWORD dwMemPos;
-	UINT nPat, nSmp;
+	UINT i, nPat, nSmp;
 
 	if ((!lpStream) || (dwMemLength < 1024) || (pfh->id_RIFF != DSMID_RIFF)
 	 || (pfh->riff_len + 8 > dwMemLength) || (pfh->riff_len < 1024)
@@ -106,16 +106,16 @@ BOOL CSoundFile_ReadDSM(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 	_this->m_nDefaultGlobalVolume = psong->globalvol << 2;
 	if ((!_this->m_nDefaultGlobalVolume) || (_this->m_nDefaultGlobalVolume > 256)) _this->m_nDefaultGlobalVolume = 256;
 	_this->m_nSongPreAmp = psong->mastervol & 0x7F;
-	for (UINT iOrd=0; iOrd<sizeof(psong->orders); iOrd++)
+	for (i=0; i<sizeof(psong->orders); i++)
 	{
-		_this->Order[iOrd] = (BYTE)((iOrd < psong->numord) ? psong->orders[iOrd] : 0xFF);
+		_this->Order[i] = (BYTE)((i < psong->numord) ? psong->orders[i] : 0xFF);
 	}
-	for (UINT iPan=0; iPan<16; iPan++)
+	for (i=0; i<16; i++)
 	{
-		_this->ChnSettings[iPan].nPan = 0x80;
-		if (psong->panpos[iPan] <= 0x80)
+		_this->ChnSettings[i].nPan = 0x80;
+		if (psong->panpos[i] <= 0x80)
 		{
-			_this->ChnSettings[iPan].nPan = psong->panpos[iPan] << 1;
+			_this->ChnSettings[i].nPan = psong->panpos[i] << 1;
 		}
 	}
 	nPat = 0;
@@ -127,15 +127,17 @@ BOOL CSoundFile_ReadDSM(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 		// Reading Patterns
 		if (ppatt->id_PATT == DSMID_PATT)
 		{
+			MODCOMMAND *m;
+			DWORD dwPos;
+			UINT row = 0;
 			dwMemPos += 8;
 			if (dwMemPos + ppatt->patt_len >= dwMemLength) break;
-			DWORD dwPos = dwMemPos;
+			dwPos = dwMemPos;
 			dwMemPos += ppatt->patt_len;
-			MODCOMMAND *m = CSoundFile_AllocatePattern(64, _this->m_nChannels);
+			m = CSoundFile_AllocatePattern(64, _this->m_nChannels);
 			if (!m) break;
 			_this->PatternSize[nPat] = 64;
 			_this->Patterns[nPat] = m;
-			UINT row = 0;
 			while ((row < 64) && (dwPos + 2 <= dwMemPos))
 			{
 				UINT flag = lpStream[dwPos++];
@@ -207,10 +209,13 @@ BOOL CSoundFile_ReadDSM(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 		// Reading Samples
 		if ((nSmp <= _this->m_nSamples) && (pins->id_INST == DSMID_INST))
 		{
+			MODINSTRUMENT *psmp;
+			DWORD dwPos;
+			UINT smptype;
 			if (dwMemPos + pins->inst_len >= dwMemLength - 8) break;
-			DWORD dwPos = dwMemPos + sizeof(DSMINST);
+			dwPos = dwMemPos + sizeof(DSMINST);
 			dwMemPos += 8 + pins->inst_len;
-			MODINSTRUMENT *psmp = &_this->Ins[nSmp];
+			psmp = &_this->Ins[nSmp];
 			psmp->nGlobalVol = 64;
 			psmp->nC4Speed = pins->c2spd;
 			psmp->uFlags = (WORD)((pins->flags & 1) ? CHN_LOOP : 0);
@@ -219,7 +224,7 @@ BOOL CSoundFile_ReadDSM(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
 			psmp->nLoopEnd = pins->loopend;
 			psmp->nVolume = (WORD)(pins->volume << 2);
 			if (psmp->nVolume > 256) psmp->nVolume = 256;
-			UINT smptype = (pins->flags & 2) ? RS_PCM8S : RS_PCM8U;
+			smptype = (pins->flags & 2) ? RS_PCM8S : RS_PCM8U;
 			CSoundFile_ReadSample(_this, psmp, smptype, (LPCSTR)(lpStream+dwPos), dwMemLength - dwPos);
 			nSmp++;
 		} else

data/dependencies/SDL_sound/libmodplug/load_far.c

@@ -57,9 +57,11 @@ BOOL CSoundFile_ReadFAR(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 {
 	const FARHEADER1 *pmh1 = (const FARHEADER1 *)lpStream;
 	const FARHEADER2 *pmh2;
+	MODINSTRUMENT *pins;
 	DWORD dwMemPos = sizeof(FARHEADER1);
-	UINT headerlen, stlen;
+	UINT headerlen, stlen, i;
 	BYTE samplemap[8];
+	WORD *patsiz;
 
 	if ((!lpStream) || (dwMemLength < 1024) || (bswapLE32(pmh1->id) != FARFILEMAGIC)
 	 || (pmh1->magic2[0] != 13) || (pmh1->magic2[1] != 10) || (pmh1->magic2[2] != 26)) return FALSE;
@@ -77,11 +79,11 @@ BOOL CSoundFile_ReadFAR(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	_this->m_nDefaultGlobalVolume = 256;
 
 	// Channel Setting
-	for (UINT nchpan=0; nchpan<16; nchpan++)
+	for (i=0; i<16; i++)
 	{
-		_this->ChnSettings[nchpan].dwFlags = 0;
-		_this->ChnSettings[nchpan].nPan = ((pmh1->panning[nchpan] & 0x0F) << 4) + 8;
-		_this->ChnSettings[nchpan].nVolume = 64;
+		_this->ChnSettings[i].dwFlags = 0;
+		_this->ChnSettings[i].nPan = ((pmh1->panning[i] & 0x0F) << 4) + 8;
+		_this->ChnSettings[i].nVolume = 64;
 	}
 	// Reading comment
 	if (stlen)
@@ -93,27 +95,30 @@ BOOL CSoundFile_ReadFAR(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	pmh2 = (const FARHEADER2 *)(lpStream + dwMemPos);
 	dwMemPos += sizeof(FARHEADER2);
 	if (dwMemPos >= dwMemLength) return TRUE;
-	for (UINT iorder=0; iorder<MAX_ORDERS; iorder++)
+	for (i=0; i<MAX_ORDERS; i++)
 	{
-		_this->Order[iorder] = (iorder <= pmh2->snglen) ? pmh2->orders[iorder] : 0xFF;
+		_this->Order[i] = (i <= pmh2->snglen) ? pmh2->orders[i] : 0xFF;
 	}
 	_this->m_nRestartPos = pmh2->loopto;
 	// Reading Patterns	
 	dwMemPos += headerlen - (869 + stlen);
 	if (dwMemPos >= dwMemLength) return TRUE;
 
-	WORD *patsiz = (WORD *)pmh2->patsiz;
-	for (UINT ipat=0; ipat<256; ipat++) if (patsiz[ipat])
+	patsiz = (WORD *)pmh2->patsiz;
+	for (i=0; i<256; i++) if (patsiz[i])
 	{
-		UINT patlen = bswapLE16(patsiz[ipat]);
-		if ((ipat >= MAX_PATTERNS) || (patlen < 2))
+		MODCOMMAND *m;
+		const BYTE *p;
+		UINT len, max, rows, patbrk, patlen;
+		patlen = bswapLE16(patsiz[i]);
+		if ((i >= MAX_PATTERNS) || (patlen < 2))
 		{
 			dwMemPos += patlen;
 			continue;
 		}
 		if (dwMemPos + patlen >= dwMemLength) return TRUE;
-		UINT max  = (patlen - 2) & ~3;
-		UINT rows = (patlen - 2) >> 6;
+		max  = (patlen - 2) & ~3;
+		rows = (patlen - 2) >> 6;
 		if (!rows)
 		{
 			dwMemPos += patlen;
@@ -122,12 +127,12 @@ BOOL CSoundFile_ReadFAR(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 		if (rows > 256) rows = 256;
 		if (rows < 16) rows = 16;
 		if (max > rows*16*4) max = rows*16*4;
-		_this->PatternSize[ipat] = rows;
-		if ((_this->Patterns[ipat] = CSoundFile_AllocatePattern(rows, _this->m_nChannels)) == NULL) return TRUE;
-		MODCOMMAND *m = _this->Patterns[ipat];
-		UINT patbrk = lpStream[dwMemPos];
-		const BYTE *p = lpStream + dwMemPos + 2;
-		for (UINT len=0; len<max; len += 4, m++)
+		_this->PatternSize[i] = rows;
+		if ((_this->Patterns[i] = CSoundFile_AllocatePattern(rows, _this->m_nChannels)) == NULL) return TRUE;
+		m = _this->Patterns[i];
+		patbrk = lpStream[dwMemPos];
+		p = lpStream + dwMemPos + 2;
+		for (len=0; len<max; len += 4, m++)
 		{
 			BYTE note = p[len];
 			BYTE ins = p[len+1];
@@ -214,14 +219,16 @@ BOOL CSoundFile_ReadFAR(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	if (dwMemPos + 8 >= dwMemLength) return TRUE;
 	SDL_memcpy(samplemap, lpStream+dwMemPos, 8);
 	dwMemPos += 8;
-	MODINSTRUMENT *pins = &_this->Ins[1];
-	for (UINT ismp=0; ismp<64; ismp++, pins++) if (samplemap[ismp >> 3] & (1 << (ismp & 7)))
+	pins = &_this->Ins[1];
+	for (i=0; i<64; i++, pins++) if (samplemap[i >> 3] & (1 << (i & 7)))
 	{
+		const FARSAMPLE *pfs;
+		DWORD length;
 		if (dwMemPos + sizeof(FARSAMPLE) > dwMemLength) return TRUE;
-		const FARSAMPLE *pfs = (const FARSAMPLE*)(lpStream + dwMemPos);
+		pfs = (const FARSAMPLE*)(lpStream + dwMemPos);
 		dwMemPos += sizeof(FARSAMPLE);
-		_this->m_nSamples = ismp + 1;
-		const DWORD length = bswapLE32(pfs->length); /* endian fix - Toad */
+		_this->m_nSamples = i + 1;
+		length = bswapLE32(pfs->length); /* endian fix - Toad */
 		pins->nLength = length;
 		pins->nLoopStart = bswapLE32(pfs->reppos);
 		pins->nLoopEnd = bswapLE32(pfs->repend);