gosu 1.4.5.pre1 → 1.4.5

data/dependencies/SDL_sound/libmodplug/load_mdl.c

@@ -122,17 +122,18 @@ static void UnpackMDLTrack(MODCOMMAND *pat, UINT nChannels, UINT nRows, UINT nTr
 
 		case 0x03:
 			{
+				UINT volume, commands, command1, command2, param1, param2;
 				cmd.note = (xx & 0x01) ? (pos < len ? lpTracks[pos++] : 0) : 0;
 				cmd.instr = (xx & 0x02) ? (pos < len ? lpTracks[pos++] : 0) : 0;
 				cmd.volcmd = cmd.vol = 0;
 				cmd.command = cmd.param = 0;
 				if ((cmd.note < NOTE_MAX-12) && (cmd.note)) cmd.note += 12;
-				UINT volume = (xx & 0x04) ? (pos < len ? lpTracks[pos++] : 0) : 0;
-				UINT commands = (xx & 0x08) ? (pos < len ? lpTracks[pos++] : 0) : 0;
-				UINT command1 = commands & 0x0F;
-				UINT command2 = commands & 0xF0;
-				UINT param1 = (xx & 0x10) ? (pos < len ? lpTracks[pos++] : 0) : 0;
-				UINT param2 = (xx & 0x20) ? (pos < len ? lpTracks[pos++] : 0) : 0;
+				volume = (xx & 0x04) ? (pos < len ? lpTracks[pos++] : 0) : 0;
+				commands = (xx & 0x08) ? (pos < len ? lpTracks[pos++] : 0) : 0;
+				command1 = commands & 0x0F;
+				command2 = commands & 0xF0;
+				param1 = (xx & 0x10) ? (pos < len ? lpTracks[pos++] : 0) : 0;
+				param2 = (xx & 0x20) ? (pos < len ? lpTracks[pos++] : 0) : 0;
 				if ((command1 == 0x0E) && ((param1 & 0xF0) == 0xF0) && (!command2))
 				{
 					param1 = ((param1 & 0x0F) << 8) | param2;
@@ -180,10 +181,11 @@ BOOL CSoundFile_ReadMDL(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	BYTE inspanenv[MAX_INSTRUMENTS];
 	LPCBYTE pvolenv, ppanenv, ppitchenv;
 	UINT nvolenv, npanenv, npitchenv;
+	UINT hdrLen;
 
 	if ((!lpStream) || (dwMemLength < 1024)) return FALSE;
 	if ((pmsh->id != 0x4C444D44) || ((pmsh->version & 0xF0) > 0x10)) return FALSE;
-	const UINT hdrLen = (pmsh->version>0)? 59 : 57;
+	hdrLen = (pmsh->version>0)? 59 : 57;
 	SDL_memset(patterntracks, 0, sizeof(patterntracks));
 	SDL_memset(smpinfo, 0, sizeof(smpinfo));
 	SDL_memset(insvolenv, 0, sizeof(insvolenv));
@@ -245,8 +247,9 @@ BOOL CSoundFile_ReadMDL(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 					if (_this->m_nChannels < 32) _this->m_nChannels = 32;
 					ch = 32;
 				} else {
+					const MDLPATTERNDATA *pmpd;
 					if (dwPos+18 >= dwMemLength) break;
-					const MDLPATTERNDATA *pmpd = (const MDLPATTERNDATA *)(lpStream + dwPos);
+					pmpd = (const MDLPATTERNDATA *)(lpStream + dwPos);
 					if (pmpd->channels > 32) break;
 					_this->PatternSize[i] = pmpd->lastrow+1;
 					if (_this->m_nChannels < pmpd->channels) _this->m_nChannels = pmpd->channels;
@@ -283,9 +286,10 @@ BOOL CSoundFile_ReadMDL(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 				if (_this->m_nInstruments < nins) _this->m_nInstruments = nins;
 				if (!_this->Headers[nins])
 				{
+					INSTRUMENTHEADER *penv;
 					UINT note = 12;
 					if ((_this->Headers[nins] = (INSTRUMENTHEADER *) SDL_calloc(1, sizeof (INSTRUMENTHEADER))) == NULL) break;
-					INSTRUMENTHEADER *penv = _this->Headers[nins];
+					penv = _this->Headers[nins];
 					if (dwPos > dwMemLength - 34) break;
 					penv->nGlobalVol = 64;
 					penv->nPPC = 5*12;
@@ -357,9 +361,10 @@ BOOL CSoundFile_ReadMDL(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 			for (i=0; i<nsamples; i++, dwPos += hdrLen)
 			{
 				UINT nins = lpStream[dwPos];
+				MODINSTRUMENT *pins;
 				if ((nins >= MAX_SAMPLES) || (!nins)) continue;
 				if (_this->m_nSamples < nins) _this->m_nSamples = nins;
-				MODINSTRUMENT *pins = &_this->Ins[nins];
+				pins = &_this->Ins[nins];
 				pp = lpStream + dwPos + 41;
 				pins->nC4Speed = pp[0] | (pp[1] << 8); pp += 2;
 				if (pmsh->version > 0) {
@@ -412,10 +417,11 @@ BOOL CSoundFile_ReadMDL(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	// Unpack Patterns
 	if ((dwTrackPos) && (npatterns) && (_this->m_nChannels) && (ntracks))
 	{
-		for (UINT ipat=0; ipat<npatterns; ipat++)
+		for (i=0; i<npatterns; i++)
 		{
-			if ((_this->Patterns[ipat] = CSoundFile_AllocatePattern(_this->PatternSize[ipat], _this->m_nChannels)) == NULL) break;
-			for (UINT chn=0; chn<_this->m_nChannels; chn++) if ((patterntracks[ipat*32+chn]) && (patterntracks[ipat*32+chn] <= ntracks))
+			UINT chn;
+			if ((_this->Patterns[i] = CSoundFile_AllocatePattern(_this->PatternSize[i], _this->m_nChannels)) == NULL) break;
+			for (chn=0; chn<_this->m_nChannels; chn++) if ((patterntracks[i*32+chn]) && (patterntracks[i*32+chn] <= ntracks))
 			{
 			    const BYTE *lpTracks = lpStream + dwTrackPos;
 			    UINT len = 0;
@@ -423,11 +429,11 @@ BOOL CSoundFile_ReadMDL(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 				len = lpTracks[0] | (lpTracks[1] << 8);
 
 			    if (len < dwMemLength-dwTrackPos) {
-				MODCOMMAND *m = _this->Patterns[ipat] + chn;
-				UINT nTrack = patterntracks[ipat*32+chn];
+				MODCOMMAND *m = _this->Patterns[i] + chn;
+				UINT nTrack = patterntracks[i*32+chn];
 
 				lpTracks += 2;
-				for (UINT ntrk=1; ntrk<nTrack && lpTracks < (dwMemLength + lpStream - len - 2); ntrk++)
+				for (j=1; j<nTrack && lpTracks < (dwMemLength + lpStream - len - 2); j++)
 				{
 					lpTracks += len;
 					len = lpTracks[0] | (lpTracks[1] << 8);
@@ -436,31 +442,32 @@ BOOL CSoundFile_ReadMDL(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 
 				if ( len > dwMemLength - (lpTracks - lpStream) ) len = 0;
 
-				UnpackMDLTrack(m, _this->m_nChannels, _this->PatternSize[ipat], nTrack, lpTracks, len);
+				UnpackMDLTrack(m, _this->m_nChannels, _this->PatternSize[i], nTrack, lpTracks, len);
 			    }
 			}
 		}
 	}
 	// Set up envelopes
-	for (UINT iIns=1; iIns<=_this->m_nInstruments; iIns++) if (_this->Headers[iIns])
+	for (i=1; i<=_this->m_nInstruments; i++) if (_this->Headers[i])
 	{
-		INSTRUMENTHEADER *penv = _this->Headers[iIns];
+		INSTRUMENTHEADER *penv = _this->Headers[i];
 		// Setup volume envelope
-		if ((nvolenv) && (pvolenv) && (insvolenv[iIns]))
+		if ((nvolenv) && (pvolenv) && (insvolenv[i]))
 		{
 			LPCBYTE pve = pvolenv;
-			for (UINT nve=0; nve<nvolenv; nve++, pve+=33) if (pve[0]+1 == insvolenv[iIns])
+			UINT nve;
+			for (nve=0; nve<nvolenv; nve++, pve+=33) if (pve[0]+1 == insvolenv[i])
 			{
 				WORD vtick = 1;
 				penv->nVolEnv = 15;
-				for (UINT iv=0; iv<15; iv++)
+				for (j=0; j<15; j++)
 				{
-					if (iv) vtick += pve[iv*2+1];
-					penv->VolPoints[iv] = vtick;
-					penv->VolEnv[iv] = pve[iv*2+2];
-					if (!pve[iv*2+1])
+					if (j) vtick += pve[j*2+1];
+					penv->VolPoints[j] = vtick;
+					penv->VolEnv[j] = pve[j*2+2];
+					if (!pve[j*2+1])
 					{
-						penv->nVolEnv = iv+1;
+						penv->nVolEnv = j+1;
 						break;
 					}
 				}
@@ -472,21 +479,22 @@ BOOL CSoundFile_ReadMDL(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 			}
 		}
 		// Setup panning envelope
-		if ((npanenv) && (ppanenv) && (inspanenv[iIns]))
+		if ((npanenv) && (ppanenv) && (inspanenv[i]))
 		{
 			LPCBYTE ppe = ppanenv;
-			for (UINT npe=0; npe<npanenv; npe++, ppe+=33) if (ppe[0]+1 == inspanenv[iIns])
+			UINT npe;
+			for (npe=0; npe<npanenv; npe++, ppe+=33) if (ppe[0]+1 == inspanenv[i])
 			{
 				WORD vtick = 1;
 				penv->nPanEnv = 15;
-				for (UINT iv=0; iv<15; iv++)
+				for (j=0; j<15; j++)
 				{
-					if (iv) vtick += ppe[iv*2+1];
-					penv->PanPoints[iv] = vtick;
-					penv->PanEnv[iv] = ppe[iv*2+2];
-					if (!ppe[iv*2+1])
+					if (j) vtick += ppe[j*2+1];
+					penv->PanPoints[j] = vtick;
+					penv->PanEnv[j] = ppe[j*2+2];
+					if (!ppe[j*2+1])
 					{
-						penv->nPanEnv = iv+1;
+						penv->nPanEnv = j+1;
 						break;
 					}
 				}

data/dependencies/SDL_sound/libmodplug/load_med.c

@@ -466,16 +466,17 @@ BOOL CSoundFile_ReadMed(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	const MMD2SONGHEADER *pmsh2;
 	const MMD0EXP *pmex;
 	DWORD dwBlockArr, dwSmplArr, dwExpData, wNumBlocks;
+	DWORD dwSong;
 	LPDWORD pdwTable;
-	CHAR version;
-	UINT deftempo;
+	UINT deftempo, j;
+	int version;
 	int playtransp = 0;
 
 	if ((!lpStream) || (dwMemLength < 0x200)) return FALSE;
 	pmmh = (MEDMODULEHEADER *)lpStream;
 	if (((pmmh->id & 0x00FFFFFF) != 0x444D4D) || (!pmmh->song)) return FALSE;
 	// Check for 'MMDx'
-	DWORD dwSong = bswapBE32(pmmh->song);
+	dwSong = bswapBE32(pmmh->song);
 	if ((dwSong >= dwMemLength) || (dwSong + sizeof(MMD0SONGHEADER) >= dwMemLength)) return FALSE;
 	version = (signed char)((pmmh->id >> 24) & 0xFF);
 	if ((version < '0') || (version > '3')) return FALSE;
@@ -528,15 +529,15 @@ BOOL CSoundFile_ReadMed(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	}
 	_this->m_nDefaultTempo = deftempo;
 	// Reading Samples
-	for (UINT iSHdr=0; iSHdr<_this->m_nSamples; iSHdr++)
+	for (j=0; j<_this->m_nSamples; j++)
 	{
-		MODINSTRUMENT *pins = &_this->Ins[iSHdr+1];
-		pins->nLoopStart = bswapBE16(pmsh->sample[iSHdr].rep) << 1;
-		pins->nLoopEnd = pins->nLoopStart + (bswapBE16(pmsh->sample[iSHdr].replen) << 1);
-		pins->nVolume = (pmsh->sample[iSHdr].svol << 2);
+		MODINSTRUMENT *pins = &_this->Ins[j+1];
+		pins->nLoopStart = bswapBE16(pmsh->sample[j].rep) << 1;
+		pins->nLoopEnd = pins->nLoopStart + (bswapBE16(pmsh->sample[j].replen) << 1);
+		pins->nVolume = (pmsh->sample[j].svol << 2);
 		pins->nGlobalVol = 64;
 		if (pins->nVolume > 256) pins->nVolume = 256;
-		pins->RelativeTone = -12 * pmsh->sample[iSHdr].strans;
+		pins->RelativeTone = -12 * pmsh->sample[j].strans;
 		pins->nPan = 128;
 		if (pins->nLoopEnd) pins->uFlags |= CHN_LOOP;
 	}
@@ -554,18 +555,22 @@ BOOL CSoundFile_ReadMed(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	{
 		UINT nOrders, nSections;
 		UINT nTrks = bswapBE16(pmsh2->numtracks);
+		DWORD playseqtable;
+		UINT numplayseqs;
+		DWORD sectiontable;
 		if ((nTrks >= 4) && (nTrks <= 32)) _this->m_nChannels = nTrks;
-		DWORD playseqtable = bswapBE32(pmsh2->playseqtable);
-		UINT numplayseqs = bswapBE16(pmsh2->numpseqs);
+		playseqtable = bswapBE32(pmsh2->playseqtable);
+		numplayseqs = bswapBE16(pmsh2->numpseqs);
 		if (!numplayseqs) numplayseqs = 1;
 		nOrders = 0;
 		nSections = bswapBE16(pmsh2->numsections);
-		DWORD sectiontable = bswapBE32(pmsh2->sectiontable);
+		sectiontable = bswapBE32(pmsh2->sectiontable);
 		if ((!nSections) || (!sectiontable) || (sectiontable >= dwMemLength-2)) nSections = 1;
 		nOrders = 0;
-		for (UINT iSection=0; iSection<nSections; iSection++)
+		for (j=0; j<nSections; j++)
 		{
 			UINT nplayseq = 0;
+			UINT pseq = 0;
 			if ((sectiontable) && (sectiontable < dwMemLength-2))
 			{
 				nplayseq = lpStream[sectiontable+1];
@@ -574,7 +579,6 @@ BOOL CSoundFile_ReadMed(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 			{
 				nSections = 0;
 			}
-			UINT pseq = 0;
 
 			if ((playseqtable) && (playseqtable < dwMemLength - 4) && ((nplayseq+1)*4 < dwMemLength - playseqtable))
 			{
@@ -584,10 +588,10 @@ BOOL CSoundFile_ReadMed(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 				(pseq < dwMemLength - sizeof(MMD2PLAYSEQ)))
 			{
 				const MMD2PLAYSEQ *pmps = (MMD2PLAYSEQ *)(lpStream + pseq);
-				UINT n = bswapBE16(pmps->length);
+				UINT i, n = bswapBE16(pmps->length);
 				if (n < (dwMemLength - (pseq + sizeof(*pmps)) + sizeof(pmps->seq)) / sizeof(pmps->seq[0]))
 				{
-					for (UINT i=0; i<n; i++)
+					for (i=0; i<n; i++)
 					{
 						UINT seqval = pmps->seq[i] >> 8;
 						if ((seqval < wNumBlocks) && (nOrders < MAX_ORDERS-1))
@@ -607,25 +611,28 @@ BOOL CSoundFile_ReadMed(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 		// Channel Split
 		if ((_this->m_nChannels == 4) && (pmsh->flags & MMD_FLAG_8CHANNEL))
 		{
-			for (UINT i8ch=0; i8ch<4; i8ch++)
+			for (j=0; j<4; j++)
 			{
-				if (pmex->channelsplit[i8ch]) _this->m_nChannels++;
+				if (pmex->channelsplit[j]) _this->m_nChannels++;
 			}
 		}
 	}
 	// Reading samples
 	if (dwSmplArr > dwMemLength - 4*_this->m_nSamples) return TRUE;
 	pdwTable = (LPDWORD)(lpStream + dwSmplArr);
-	for (UINT iSmp=0; iSmp<_this->m_nSamples; iSmp++) if (pdwTable[iSmp])
+	for (j=0; j<_this->m_nSamples; j++) if (pdwTable[j])
 	{
-		UINT dwPos = bswapBE32(pdwTable[iSmp]);
+		MMDSAMPLEHEADER *psdh;
+		LPSTR psdata;
+		UINT dwPos = bswapBE32(pdwTable[j]);
+		UINT len, flags, stype, bLimit;
 		if ((dwPos >= dwMemLength) || (dwPos + sizeof(MMDSAMPLEHEADER) >= dwMemLength)) continue;
-		MMDSAMPLEHEADER *psdh = (MMDSAMPLEHEADER *)(lpStream + dwPos);
-		UINT len = bswapBE32(psdh->length);
+		psdh = (MMDSAMPLEHEADER *)(lpStream + dwPos);
+		len = bswapBE32(psdh->length);
 		if ((len > MAX_SAMPLE_LENGTH) || (dwPos + len + 6 > dwMemLength)) len = 0;
-		UINT flags = RS_PCM8S, stype = bswapBE16(psdh->type);
-		LPSTR psdata = (LPSTR)(lpStream + dwPos + 6);
-		UINT bLimit = dwMemLength - dwPos - 6;
+		flags = RS_PCM8S, stype = bswapBE16(psdh->type);
+		psdata = (LPSTR)(lpStream + dwPos + 6);
+		bLimit = dwMemLength - dwPos - 6;
 		if (stype & 0x80)
 		{
 			psdata += (stype & 0x20) ? 14 : 6;
@@ -634,7 +641,7 @@ BOOL CSoundFile_ReadMed(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 		{
 			if (stype & 0x10)
 			{
-				_this->Ins[iSmp+1].uFlags |= CHN_16BIT;
+				_this->Ins[j+1].uFlags |= CHN_16BIT;
 				len /= 2;
 				flags = (stype & 0x20) ? RS_STPCM16M : RS_PCM16M;
 			} else
@@ -643,8 +650,8 @@ BOOL CSoundFile_ReadMed(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 			}
 			if (stype & 0x20) len /= 2;
 		}
-		_this->Ins[iSmp+1].nLength = len;
-		CSoundFile_ReadSample(_this, &_this->Ins[iSmp+1], flags, psdata, bLimit);
+		_this->Ins[j+1].nLength = len;
+		CSoundFile_ReadSample(_this, &_this->Ins[j+1], flags, psdata, bLimit);
 	}
 	// Reading patterns (blocks)
 	if (wNumBlocks > MAX_PATTERNS) wNumBlocks = MAX_PATTERNS;
@@ -652,26 +659,29 @@ BOOL CSoundFile_ReadMed(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 		(dwBlockArr > dwMemLength - 4*wNumBlocks)) return TRUE;
 	pdwTable = (LPDWORD)(lpStream + dwBlockArr);
 	playtransp += (version == '3') ? 24 : 48;
-	for (UINT iBlk=0; iBlk<wNumBlocks; iBlk++)
+	for (j=0; j<wNumBlocks; j++)
 	{
-		UINT dwPos = bswapBE32(pdwTable[iBlk]);
-		if ((!dwPos) || (dwPos >= dwMemLength) || (dwPos >= dwMemLength - 8)) continue;
+		UINT dwPos = bswapBE32(pdwTable[j]);
 		UINT lines = 64, tracks = 4;
+		if ((!dwPos) || (dwPos >= dwMemLength) || (dwPos >= dwMemLength - 8)) continue;
 		if (version == '0')
 		{
 			const MMD0BLOCK *pmb = (const MMD0BLOCK *)(lpStream + dwPos);
+			MODCOMMAND *p;
+			LPBYTE s;
+			UINT x, y, maxlen;
 			lines = pmb->lines + 1;
 			tracks = pmb->numtracks;
 			if (!tracks) tracks = _this->m_nChannels;
-			if ((_this->Patterns[iBlk] = CSoundFile_AllocatePattern(lines, _this->m_nChannels)) == NULL) continue;
-			_this->PatternSize[iBlk] = lines;
-			MODCOMMAND *p = _this->Patterns[iBlk];
-			LPBYTE s = (LPBYTE)(lpStream + dwPos + 2);
-			UINT maxlen = tracks*lines*3;
+			if ((_this->Patterns[j] = CSoundFile_AllocatePattern(lines, _this->m_nChannels)) == NULL) continue;
+			_this->PatternSize[j] = lines;
+			p = _this->Patterns[j];
+			s = (LPBYTE)(lpStream + dwPos + 2);
+			maxlen = tracks*lines*3;
 			if (maxlen + dwPos > dwMemLength - 2) break;
-			for (UINT y=0; y<lines; y++)
+			for (y=0; y<lines; y++)
 			{
-				for (UINT x=0; x<tracks; x++, s+=3) if (x < _this->m_nChannels)
+				for (x=0; x<tracks; x++, s+=3) if (x < _this->m_nChannels)
 				{
 					BYTE note = s[0] & 0x3F;
 					BYTE instr = s[1] >> 4;
@@ -681,23 +691,27 @@ BOOL CSoundFile_ReadMed(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 					p->instr = instr;
 					p->command = s[1] & 0x0F;
 					p->param = s[2];
-					// if (!iBlk) Log("%02X.%02X.%02X | ", s[0], s[1], s[2]);
+					// if (!j) Log("%02X.%02X.%02X | ", s[0], s[1], s[2]);
 					MedConvert(p, pmsh);
 					p++;
 				}
-				//if (!iBlk) Log("\n");
+				//if (!j) Log("\n");
 			}
 		} else
 		{
 			const MMD1BLOCK *pmb = (MMD1BLOCK *)(lpStream + dwPos);
 			const MMD1BLOCKINFO *pbi = NULL;
 			BYTE *pcmdext = NULL;
+			MODCOMMAND *p;
+			LPBYTE s;
+			DWORD dwBlockInfo;
+			UINT x, y, maxlen;
 			lines = (pmb->lines >> 8) + 1;
 			tracks = pmb->numtracks >> 8;
 			if (!tracks) tracks = _this->m_nChannels;
-			if ((_this->Patterns[iBlk] = CSoundFile_AllocatePattern(lines, _this->m_nChannels)) == NULL) continue;
-			_this->PatternSize[iBlk] = (WORD)lines;
-			DWORD dwBlockInfo = bswapBE32(pmb->info);
+			if ((_this->Patterns[j] = CSoundFile_AllocatePattern(lines, _this->m_nChannels)) == NULL) continue;
+			_this->PatternSize[j] = (WORD)lines;
+			dwBlockInfo = bswapBE32(pmb->info);
 			if ((dwBlockInfo) && (dwBlockInfo < dwMemLength - sizeof(MMD1BLOCKINFO)))
 			{
 				pbi = (MMD1BLOCKINFO *)(lpStream + dwBlockInfo);
@@ -713,7 +727,7 @@ BOOL CSoundFile_ReadMed(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 						SDL_memcpy(blockname, lpStream + nameofs, namelen);
 						blockname[namelen] = '\0';
 
-						CSoundFile_SetPatternName(_this, iBlk, blockname);
+						CSoundFile_SetPatternName(_this, j, blockname);
 					}
 				}
 				if (pbi->cmdexttable)
@@ -729,13 +743,13 @@ BOOL CSoundFile_ReadMed(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 					}
 				}
 			}
-			MODCOMMAND *p = _this->Patterns[iBlk];
-			LPBYTE s = (LPBYTE)(lpStream + dwPos + 8);
-			UINT maxlen = tracks*lines*4;
+			p = _this->Patterns[j];
+			s = (LPBYTE)(lpStream + dwPos + 8);
+			maxlen = tracks*lines*4;
 			if (maxlen + dwPos > dwMemLength - 8) break;
-			for (UINT y=0; y<lines; y++)
+			for (y=0; y<lines; y++)
 			{
-				for (UINT x=0; x<tracks; x++, s+=4) if (x < _this->m_nChannels)
+				for (x=0; x<tracks; x++, s+=4) if (x < _this->m_nChannels)
 				{
 					BYTE note = s[0];
 					if ((note) && (note <= 132))
@@ -757,10 +771,10 @@ BOOL CSoundFile_ReadMed(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 		}
 	}
 	// Setup channel pan positions
-	for (UINT iCh=0; iCh<_this->m_nChannels; iCh++)
+	for (j=0; j<_this->m_nChannels; j++)
 	{
-		_this->ChnSettings[iCh].nPan = (((iCh&3) == 1) || ((iCh&3) == 2)) ? 0xC0 : 0x40;
-		_this->ChnSettings[iCh].nVolume = 64;
+		_this->ChnSettings[j].nPan = (((j&3) == 1) || ((j&3) == 2)) ? 0xC0 : 0x40;
+		_this->ChnSettings[j].nVolume = 64;
 	}
 	return TRUE;
 }

data/dependencies/SDL_sound/libmodplug/load_mod.c

@@ -102,7 +102,9 @@ BOOL CSoundFile_ReadMod(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
         char s[1024];          // changed from CHAR
 	DWORD dwMemPos, dwTotalSampleLen;
 	PMODMAGIC pMagic;
-	UINT nErr;
+	UINT nbp, nbpbuggy, nbpbuggy2, norders;
+	UINT i, nErr;
+	DWORD dwWowTest, dwErrCheck;
 
 	if ((!lpStream) || (dwMemLength < 0x600)) return FALSE;
 	dwMemPos = 20;
@@ -131,7 +133,7 @@ BOOL CSoundFile_ReadMod(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	// Load Samples
 	nErr = 0;
 	dwTotalSampleLen = 0;
-	for	(UINT i=1; i<=_this->m_nSamples; i++)
+	for	(i=1; i<=_this->m_nSamples; i++)
 	{
 		PMODSAMPLE pms = (PMODSAMPLE)(lpStream+dwMemPos);
 		MODINSTRUMENT *psmp = &_this->Ins[i];
@@ -192,8 +194,6 @@ BOOL CSoundFile_ReadMod(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	SDL_memset(_this->Order, 0,sizeof(_this->Order));
 	SDL_memcpy(_this->Order, pMagic->Orders, 128);
 
-	UINT nbp, nbpbuggy, nbpbuggy2, norders;
-
 	norders = pMagic->nOrders;
 	if ((!norders) || (norders > 0x80))
 	{
@@ -203,23 +203,23 @@ BOOL CSoundFile_ReadMod(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	nbpbuggy = 0;
 	nbpbuggy2 = 0;
 	nbp = 0;
-	for (UINT iord=0; iord<128; iord++)
+	for (i=0; i<128; i++)
 	{
-		UINT i = _this->Order[iord];
-		if ((i < 0x80) && (nbp <= i))
+		UINT j = _this->Order[i];
+		if ((j < 0x80) && (nbp <= j))
 		{
-			nbp = i+1;
-			if (iord<norders) nbpbuggy = nbp;
+			nbp = j+1;
+			if (i<norders) nbpbuggy = nbp;
 		}
-		if (i >= nbpbuggy2) nbpbuggy2 = i+1;
+		if (j >= nbpbuggy2) nbpbuggy2 = j+1;
 	}
-	for (UINT iend=norders; iend<MAX_ORDERS; iend++) _this->Order[iend] = 0xFF;
+	for (i=norders; i<MAX_ORDERS; i++) _this->Order[i] = 0xFF;
 	norders--;
 	_this->m_nRestartPos = pMagic->nRestartPos;
 	if (_this->m_nRestartPos >= 0x78) _this->m_nRestartPos = 0;
 	if (_this->m_nRestartPos + 1 >= (UINT)norders) _this->m_nRestartPos = 0;
 	if (!nbp) return FALSE;
-	DWORD dwWowTest = dwTotalSampleLen+dwMemPos;
+	dwWowTest = dwTotalSampleLen+dwMemPos;
 	if ((IsMagic(pMagic->Magic, "M.K.")) && (dwWowTest + nbp*8*256 == dwMemLength)) _this->m_nChannels = 8;
 	if ((nbp != nbpbuggy) && (dwWowTest + nbp*_this->m_nChannels*256 != dwMemLength))
 	{
@@ -239,25 +239,28 @@ BOOL CSoundFile_ReadMod(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 	_this->m_nMinPeriod = 14 << 2;
 	_this->m_nMaxPeriod = 3424 << 2;
 	// Setting channels pan
-	for (UINT ich=0; ich<_this->m_nChannels; ich++)
+	for (i=0; i<_this->m_nChannels; i++)
 	{
-		_this->ChnSettings[ich].nVolume = 64;
+		_this->ChnSettings[i].nVolume = 64;
 		if (_this->gdwSoundSetup & SNDMIX_MAXDEFAULTPAN)
-			_this->ChnSettings[ich].nPan = (((ich&3)==1) || ((ich&3)==2)) ? 256 : 0;
+			_this->ChnSettings[i].nPan = (((i&3)==1) || ((i&3)==2)) ? 256 : 0;
 		else
-			_this->ChnSettings[ich].nPan = (((ich&3)==1) || ((ich&3)==2)) ? 0xC0 : 0x40;
+			_this->ChnSettings[i].nPan = (((i&3)==1) || ((i&3)==2)) ? 0xC0 : 0x40;
 	}
 	// Reading channels
-	for (UINT ipat=0; ipat<nbp; ipat++)
+	for (i=0; i<nbp; i++)
 	{
-		if (ipat < MAX_PATTERNS)
+		if (i < MAX_PATTERNS)
 		{
-			if ((_this->Patterns[ipat] = CSoundFile_AllocatePattern(64, _this->m_nChannels)) == NULL) break;
-			_this->PatternSize[ipat] = 64;
+			MODCOMMAND *m;
+			LPCBYTE p;
+			UINT j;
+			if ((_this->Patterns[i] = CSoundFile_AllocatePattern(64, _this->m_nChannels)) == NULL) break;
+			_this->PatternSize[i] = 64;
 			if (dwMemPos + _this->m_nChannels*256 >= dwMemLength) break;
-			MODCOMMAND *m = _this->Patterns[ipat];
-			LPCBYTE p = lpStream + dwMemPos;
-			for (UINT j=_this->m_nChannels*64; j; m++,p+=4,j--)
+			m = _this->Patterns[i];
+			p = lpStream + dwMemPos;
+			for (j=_this->m_nChannels*64; j; m++,p+=4,j--)
 			{
 				BYTE A0=p[0], A1=p[1], A2=p[2], A3=p[3];
 				UINT n = ((((UINT)A0 & 0x0F) << 8) | (A1));
@@ -271,11 +274,12 @@ BOOL CSoundFile_ReadMod(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 		dwMemPos += _this->m_nChannels*256;
 	}
 	// Reading instruments
-	DWORD dwErrCheck = 0;
-	for (UINT ismp=1; ismp<=_this->m_nSamples; ismp++) if (_this->Ins[ismp].nLength)
+	dwErrCheck = 0;
+	for (i=1; i<=_this->m_nSamples; i++) if (_this->Ins[i].nLength)
 	{
 		LPSTR p = (LPSTR)(lpStream+dwMemPos);
 		UINT flags = 0;
+		DWORD dwSize;
 		if (dwMemPos + 5 >= dwMemLength) break;
 		if (!SDL_strncmp(p, "ADPCM", 5))
 		{
@@ -283,7 +287,7 @@ BOOL CSoundFile_ReadMod(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLeng
 			p += 5;
 			dwMemPos += 5;
 		}
-		DWORD dwSize = CSoundFile_ReadSample(_this, &_this->Ins[ismp], flags, p, dwMemLength - dwMemPos);
+		dwSize = CSoundFile_ReadSample(_this, &_this->Ins[i], flags, p, dwMemLength - dwMemPos);
 		if (dwSize)
 		{
 			dwMemPos += dwSize;