Skip to content

Commit f9ca657

Browse files
sezerosezero
committed
avoid unaligned loads / stores
1 parent d1b97ed commit f9ca657

15 files changed

Lines changed: 217 additions & 224 deletions

‎src/libmodplug/sndfile.h‎

Lines changed: 18 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -804,9 +804,6 @@ class MODPLUG_EXPORT CSoundFile
804804
};
805805

806806

807-
// inline DWORD BigEndian(DWORD x) { return ((x & 0xFF) << 24) | ((x & 0xFF00) << 8) | ((x & 0xFF0000) >> 8) | ((x & 0xFF000000) >> 24); }
808-
// inline WORD BigEndianW(WORD x) { return (WORD)(((x >> 8) & 0xFF) | ((x << 8) & 0xFF00)); }
809-
810807

811808
//////////////////////////////////////////////////////////
812809
// WAVE format information
@@ -958,6 +955,24 @@ int _muldiv(long a, long b, long c);
958955
int _muldivr(long a, long b, long c);
959956

960957

958+
// Functions to read 16 and 32 bits endian-specific data and return in native format:
959+
960+
inline WORD READ_LE16(LPCBYTE b) {
961+
return (WORD)b[0] | ((WORD)b[1] << 8);
962+
}
963+
964+
inline WORD READ_BE16(LPCBYTE b) {
965+
return (WORD)b[1] | ((WORD)b[0] << 8);
966+
}
967+
968+
inline DWORD READ_LE32(LPCBYTE b) {
969+
return (DWORD)b[0] | ((DWORD)b[1] << 8) | ((DWORD)b[2] << 16) | ((DWORD)b[3] << 24);
970+
}
971+
972+
inline DWORD READ_BE32(LPCBYTE b) {
973+
return (DWORD)b[3] | ((DWORD)b[2] << 8) | ((DWORD)b[1] << 16) | ((DWORD)b[0] << 24);
974+
}
975+
961976
// Byte swapping functions from the GNU C Library and libsdl
962977

963978
/* Swap bytes in 16 bit value. */

‎src/load_amf.cpp‎

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -56,7 +56,7 @@ VOID AMF_Unpack(MODCOMMAND *pPat, const BYTE *pTrack, UINT nRows, UINT nChannels
5656
//-------------------------------------------------------------------------------
5757
{
5858
UINT lastinstr = 0;
59-
UINT nTrkSize = bswapLE16(*(USHORT *)pTrack);
59+
UINT nTrkSize = READ_LE16(pTrack);
6060
nTrkSize += (UINT)pTrack[2] << 16;
6161
pTrack += 3;
6262
while (nTrkSize--)
@@ -203,9 +203,9 @@ BOOL CSoundFile::ReadAMF(LPCBYTE lpStream, const DWORD dwMemLength)
203203
psmp->nGlobalVol = 64;
204204
if (psmp->nVolume > 0x40) psmp->nVolume = 0x40;
205205
psmp->nVolume <<= 2;
206-
psmp->nLength = bswapLE32(*((LPDWORD)(lpStream+dwMemPos+25)));
207-
psmp->nLoopStart = bswapLE32(*((LPDWORD)(lpStream+dwMemPos+29)));
208-
psmp->nLoopEnd = psmp->nLoopStart + bswapLE32(*((LPDWORD)(lpStream+dwMemPos+33)));
206+
psmp->nLength = READ_LE32(lpStream+dwMemPos+25);
207+
psmp->nLoopStart = READ_LE32(lpStream+dwMemPos+29);
208+
psmp->nLoopEnd = psmp->nLoopStart + READ_LE32(lpStream+dwMemPos+33);
209209
if ((psmp->nLoopEnd > psmp->nLoopStart) && (psmp->nLoopEnd <= psmp->nLength))
210210
{
211211
psmp->uFlags = CHN_LOOP;
@@ -319,7 +319,7 @@ BOOL CSoundFile::ReadAMF(LPCBYTE lpStream, const DWORD dwMemLength)
319319
if (pfh->version >= 14)
320320
{
321321
if (dwMemPos + m_nChannels * sizeof(USHORT) + 2 > dwMemLength) return FALSE;
322-
PatternSize[iOrd] = bswapLE16(*(USHORT *)(lpStream+dwMemPos));
322+
PatternSize[iOrd] = READ_LE16(lpStream+dwMemPos);
323323
dwMemPos += 2;
324324
} else
325325
{
@@ -348,12 +348,12 @@ BOOL CSoundFile::ReadAMF(LPCBYTE lpStream, const DWORD dwMemLength)
348348
pins->nVolume = psh->volume * 4;
349349
if (pfh->version >= 11)
350350
{
351-
pins->nLoopStart = bswapLE32(*(DWORD *)(lpStream+dwMemPos));
352-
pins->nLoopEnd = bswapLE32(*(DWORD *)(lpStream+dwMemPos+4));
351+
pins->nLoopStart = READ_LE32(lpStream+dwMemPos);
352+
pins->nLoopEnd = READ_LE32(lpStream+dwMemPos+4);
353353
dwMemPos += 8;
354354
} else
355355
{
356-
pins->nLoopStart = bswapLE16(*(WORD *)(lpStream+dwMemPos));
356+
pins->nLoopStart = READ_LE16(lpStream+dwMemPos);
357357
pins->nLoopEnd = pins->nLength;
358358
dwMemPos += 2;
359359
}
@@ -383,7 +383,7 @@ BOOL CSoundFile::ReadAMF(LPCBYTE lpStream, const DWORD dwMemLength)
383383
memset(pTrackData, 0, sizeof(BYTE *) * realtrackcnt);
384384
for (UINT iTrack=0; iTrack<realtrackcnt; iTrack++) if (dwMemPos <= dwMemLength - 3)
385385
{
386-
UINT nTrkSize = bswapLE16(*(USHORT *)(lpStream+dwMemPos));
386+
UINT nTrkSize = READ_LE16(lpStream+dwMemPos);
387387
nTrkSize += (UINT)lpStream[dwMemPos+2] << 16;
388388
if (dwMemPos + nTrkSize * 3 + 3 <= dwMemLength)
389389
{

‎src/load_ams.cpp‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -118,7 +118,7 @@ BOOL CSoundFile::ReadAMS(LPCBYTE lpStream, DWORD dwMemLength)
118118
}
119119
// Read Song Comments
120120
if (dwMemPos + 2 > dwMemLength) return TRUE;
121-
tmp = *((WORD *)(lpStream+dwMemPos));
121+
tmp = READ_LE16(lpStream+dwMemPos);
122122
dwMemPos += 2;
123123
if (tmp >= dwMemLength || dwMemPos > dwMemLength - tmp) return TRUE;
124124
if (tmp)
@@ -133,14 +133,14 @@ BOOL CSoundFile::ReadAMS(LPCBYTE lpStream, DWORD dwMemLength)
133133
if (2*pfh->orders >= dwMemLength || dwMemPos > dwMemLength - 2*pfh->orders) return TRUE;
134134
for (UINT iOrd=0; iOrd<pfh->orders; iOrd++, dwMemPos += 2)
135135
{
136-
UINT n = *((WORD *)(lpStream+dwMemPos));
136+
UINT n = READ_LE16(lpStream+dwMemPos);
137137
Order[iOrd] = (BYTE)n;
138138
}
139139
// Read Patterns
140140
for (UINT iPat=0; iPat<pfh->patterns; iPat++)
141141
{
142142
if (dwMemPos + 4 >= dwMemLength) return TRUE;
143-
UINT len = *((DWORD *)(lpStream + dwMemPos));
143+
UINT len = READ_LE32(lpStream + dwMemPos);
144144
dwMemPos += 4;
145145
if ((len >= dwMemLength) || (dwMemPos > dwMemLength - len)) return TRUE;
146146
PatternSize[iPat] = 64;
@@ -466,7 +466,7 @@ BOOL CSoundFile::ReadAMS2(LPCBYTE lpStream, DWORD dwMemLength)
466466
if (dwMemPos + chnnamlen + 256 >= dwMemLength) return TRUE;
467467
}
468468
// packed comments (ignored)
469-
UINT songtextlen = *((LPDWORD)(lpStream+dwMemPos));
469+
UINT songtextlen = READ_LE32(lpStream+dwMemPos);
470470
dwMemPos += songtextlen;
471471
if (dwMemPos + 256 >= dwMemLength) return TRUE;
472472
}
@@ -487,7 +487,7 @@ BOOL CSoundFile::ReadAMS2(LPCBYTE lpStream, DWORD dwMemLength)
487487
for (UINT ipat=0; ipat<psh->patterns; ipat++)
488488
{
489489
if (dwMemPos+8 >= dwMemLength) return TRUE;
490-
UINT packedlen = *((LPDWORD)(lpStream+dwMemPos));
490+
UINT packedlen = READ_LE32(lpStream+dwMemPos);
491491
UINT numrows = 1 + (UINT)(lpStream[dwMemPos+4]);
492492
//UINT patchn = 1 + (UINT)(lpStream[dwMemPos+5] & 0x1F);
493493
//UINT patcmds = 1 + (UINT)(lpStream[dwMemPos+5] >> 5);
@@ -579,7 +579,7 @@ static BOOL AMSUnpackCheck(const BYTE *lpStream, DWORD dwMemLength, MODINSTRUMEN
579579
// -----------------------------------------------------------------------------------
580580
{
581581
if (dwMemLength < 9) return FALSE;
582-
DWORD packedbytes = *((DWORD *)(lpStream + 4));
582+
DWORD packedbytes = READ_LE32(lpStream + 4);
583583

584584
DWORD samplebytes = ins->nLength;
585585
if (samplebytes > MAX_SAMPLE_LENGTH) samplebytes = MAX_SAMPLE_LENGTH;

‎src/load_dmf.cpp‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -106,7 +106,7 @@ BOOL CSoundFile::ReadDMF(const BYTE *lpStream, DWORD dwMemLength)
106106
#endif
107107
while (dwMemPos < dwMemLength - 7)
108108
{
109-
DWORD id = *((LPDWORD)(lpStream+dwMemPos));
109+
DWORD id = READ_LE32(lpStream+dwMemPos);
110110

111111
switch(id)
112112
{
@@ -456,10 +456,10 @@ BOOL CSoundFile::ReadDMF(const BYTE *lpStream, DWORD dwMemLength)
456456
#endif
457457
break;
458458
}
459-
pksize = *((LPDWORD)(lpStream+dwPos));
459+
pksize = READ_LE32(lpStream+dwPos);
460460
#ifdef DMFLOG
461461
Log("sample %d: pos=0x%X pksize=%d ", iSmp, dwPos, pksize);
462-
Log("len=%d flags=0x%X [%08X]\n", Ins[iSmp].nLength, smplflags[ismpd], *((LPDWORD)(lpStream+dwPos+4)));
462+
Log("len=%d flags=0x%X [%08X]\n", Ins[iSmp].nLength, smplflags[ismpd], READ_LE32(lpStream+dwPos+4));
463463
#endif
464464
dwPos += 4;
465465
if (pksize > dwMemLength - dwPos)

‎src/load_it.cpp‎

Lines changed: 15 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -259,7 +259,7 @@ BOOL CSoundFile::ReadIT(const BYTE *lpStream, DWORD dwMemLength)
259259
// Reading IT Extra Info
260260
if (dwMemPos + 2 < dwMemLength)
261261
{
262-
UINT nflt = bswapLE16(*((WORD *)(lpStream + dwMemPos)));
262+
UINT nflt = READ_LE16(lpStream + dwMemPos);
263263
dwMemPos += 2;
264264
if (dwMemPos + nflt * 8 < dwMemLength) dwMemPos += nflt * 8;
265265
}
@@ -273,9 +273,9 @@ BOOL CSoundFile::ReadIT(const BYTE *lpStream, DWORD dwMemLength)
273273
}
274274
}
275275
// Read pattern names: "PNAM"
276-
if ((dwMemPos + 8 < dwMemLength) && (bswapLE32(*((DWORD *)(lpStream+dwMemPos))) == 0x4d414e50))
276+
if ((dwMemPos + 8 < dwMemLength) && (READ_LE32(lpStream+dwMemPos) == 0x4d414e50))
277277
{
278-
UINT len = bswapLE32(*((DWORD *)(lpStream+dwMemPos+4)));
278+
UINT len = READ_LE32(lpStream+dwMemPos+4);
279279
dwMemPos += 8;
280280
if ((dwMemPos + len <= dwMemLength) && (len <= MAX_PATTERNS*MAX_PATTERNNAME) && (len >= MAX_PATTERNNAME))
281281
{
@@ -291,9 +291,9 @@ BOOL CSoundFile::ReadIT(const BYTE *lpStream, DWORD dwMemLength)
291291
// 4-channels minimum
292292
m_nChannels = 4;
293293
// Read channel names: "CNAM"
294-
if ((dwMemPos + 8 < dwMemLength) && (bswapLE32(*((DWORD *)(lpStream+dwMemPos))) == 0x4d414e43))
294+
if ((dwMemPos + 8 < dwMemLength) && (READ_LE32(lpStream+dwMemPos) == 0x4d414e43))
295295
{
296-
UINT len = bswapLE32(*((DWORD *)(lpStream+dwMemPos+4)));
296+
UINT len = READ_LE32(lpStream+dwMemPos+4);
297297
dwMemPos += 8;
298298
if ((dwMemPos + len <= dwMemLength) && (len <= 64*MAX_CHANNELNAME))
299299
{
@@ -319,8 +319,8 @@ BOOL CSoundFile::ReadIT(const BYTE *lpStream, DWORD dwMemLength)
319319
{
320320
memset(chnmask, 0, sizeof(chnmask));
321321
if ((!patpos[patchk]) || ((DWORD)patpos[patchk] >= dwMemLength - 4)) continue;
322-
UINT len = bswapLE16(*((WORD *)(lpStream+patpos[patchk])));
323-
UINT rows = bswapLE16(*((WORD *)(lpStream+patpos[patchk]+2)));
322+
UINT len = READ_LE16(lpStream+patpos[patchk]);
323+
UINT rows = READ_LE16(lpStream+patpos[patchk]+2);
324324
if ((rows < 4) || (rows > 256)) continue;
325325
if (8+len > dwMemLength || patpos[patchk] > dwMemLength - (8+len)) continue;
326326
UINT i = 0;
@@ -451,8 +451,8 @@ BOOL CSoundFile::ReadIT(const BYTE *lpStream, DWORD dwMemLength)
451451
continue;
452452
}
453453

454-
UINT len = bswapLE16(*((WORD *)(lpStream+patpos[npat])));
455-
UINT rows = bswapLE16(*((WORD *)(lpStream+patpos[npat]+2)));
454+
UINT len = READ_LE16(lpStream+patpos[npat]);
455+
UINT rows = READ_LE16(lpStream+patpos[npat]+2);
456456
if ((rows < 4) || (rows > 256)) continue;
457457
if (8+len > dwMemLength || patpos[npat] > dwMemLength - (8+len)) continue;
458458
PatternSize[npat] = rows;
@@ -1233,7 +1233,7 @@ DWORD ITUnpack8Bit(signed char *pSample, DWORD dwLen, LPBYTE lpMemFile, DWORD dw
12331233
if (!wCount)
12341234
{
12351235
wCount = 0x8000;
1236-
// wHdr = bswapLE16(*((LPWORD)pSrc));
1236+
// wHdr = READ_LE16(pSrc);
12371237
pSrc += 2;
12381238
bLeft = 9;
12391239
bTemp = bTemp2 = 0;
@@ -1320,7 +1320,7 @@ DWORD ITUnpack16Bit(signed char *pSample, DWORD dwLen, LPBYTE lpMemFile, DWORD d
13201320
if (!wCount)
13211321
{
13221322
wCount = 0x4000;
1323-
// wHdr = bswapLE16(*((LPWORD)pSrc));
1323+
// wHdr = READ_LE16(pSrc);
13241324
pSrc += 2;
13251325
bLeft = 17;
13261326
wTemp = wTemp2 = 0;
@@ -1482,13 +1482,13 @@ UINT CSoundFile::LoadMixPlugins(const void *pData, UINT nLen)
14821482
DWORD nPluginSize;
14831483
UINT nPlugin;
14841484

1485-
nPluginSize = bswapLE32(*(DWORD *)(p+nPos+4));
1485+
nPluginSize = READ_LE32(p+nPos+4);
14861486
if (nPluginSize > nLen-nPos-8) break;;
1487-
if ((bswapLE32(*(DWORD *)(p+nPos))) == 0x58464843)
1487+
if (READ_LE32(p+nPos) == 0x58464843)
14881488
{
14891489
for (UINT ch=0; ch<64; ch++) if (ch*4 < nPluginSize)
14901490
{
1491-
ChnSettings[ch].nMixPlugin = bswapLE32(*(DWORD *)(p+nPos+8+ch*4));
1491+
ChnSettings[ch].nMixPlugin = READ_LE32(p+nPos+8+ch*4);
14921492
}
14931493
} else
14941494
{
@@ -1500,7 +1500,7 @@ UINT CSoundFile::LoadMixPlugins(const void *pData, UINT nLen)
15001500
nPlugin = (p[nPos+2]-'0')*10 + (p[nPos+3]-'0');
15011501
if ((nPlugin < MAX_MIXPLUGINS) && (nPluginSize >= sizeof(SNDMIXPLUGININFO)+4))
15021502
{
1503-
DWORD dwExtra = bswapLE32(*(DWORD *)(p+nPos+8+sizeof(SNDMIXPLUGININFO)));
1503+
DWORD dwExtra = READ_LE32(p+nPos+8+sizeof(SNDMIXPLUGININFO));
15041504
m_MixPlugins[nPlugin].Info = *(const SNDMIXPLUGININFO *)(p+nPos+8);
15051505
m_MixPlugins[nPlugin].Info.dwPluginId1 = bswapLE32(m_MixPlugins[nPlugin].Info.dwPluginId1);
15061506
m_MixPlugins[nPlugin].Info.dwPluginId2 = bswapLE32(m_MixPlugins[nPlugin].Info.dwPluginId2);

‎src/load_med.cpp‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -755,9 +755,9 @@ BOOL CSoundFile::ReadMed(const BYTE *lpStream, DWORD dwMemLength)
755755
{
756756
while (trktagofs < dwMemLength - 8)
757757
{
758-
DWORD ntag = bswapBE32(*(DWORD *)(lpStream + trktagofs));
758+
DWORD ntag = READ_BE32(lpStream + trktagofs);
759759
if (ntag == MMDTAG_END) break;
760-
DWORD tagdata = bswapBE32(*(DWORD *)(lpStream + trktagofs + 4));
760+
DWORD tagdata = READ_BE32(lpStream + trktagofs + 4);
761761
switch(ntag)
762762
{
763763
case MMDTAG_TRK_NAMELEN: trknamelen = tagdata; break;
@@ -894,7 +894,7 @@ BOOL CSoundFile::ReadMed(const BYTE *lpStream, DWORD dwMemLength)
894894
DWORD cmdexttable = bswapBE32(pbi->cmdexttable);
895895
if (cmdexttable < dwMemLength - 4)
896896
{
897-
cmdexttable = bswapBE32(*(DWORD *)(lpStream + cmdexttable));
897+
cmdexttable = READ_BE32(lpStream + cmdexttable);
898898
if ((cmdexttable) && (cmdexttable <= dwMemLength - lines*tracks))
899899
{
900900
pcmdext = (BYTE *)(lpStream + cmdexttable);

‎src/load_mod.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -187,7 +187,7 @@ static BOOL IsValidName(LPCSTR s, int length, CHAR minChar)
187187

188188
static BOOL IsMagic(LPCSTR s1, LPCSTR s2)
189189
{
190-
return ((*(DWORD *)s1) == (*(DWORD *)s2)) ? TRUE : FALSE;
190+
return memcmp(s1, s2, 4) ? FALSE : TRUE;
191191
}
192192

193193
BOOL CSoundFile::ReadMod(const BYTE *lpStream, DWORD dwMemLength)

‎src/load_mt2.cpp‎

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -225,7 +225,7 @@ BOOL CSoundFile::ReadMT2(LPCBYTE lpStream, DWORD dwMemLength)
225225
m_szNames[0][31] = 0;
226226
dwMemPos = sizeof(MT2FILEHEADER);
227227
if (dwMemPos+2 > dwMemLength) return TRUE;
228-
nDrumDataLen = *(WORD *)(lpStream + dwMemPos);
228+
nDrumDataLen = READ_LE16(lpStream + dwMemPos);
229229
dwDrumDataPos = dwMemPos + 2;
230230
if (nDrumDataLen >= 2) pdd = (MT2DRUMSDATA *)(lpStream+dwDrumDataPos);
231231
dwMemPos += 2 + nDrumDataLen;
@@ -236,9 +236,9 @@ BOOL CSoundFile::ReadMT2(LPCBYTE lpStream, DWORD dwMemLength)
236236
Log("Drum Data: %d bytes @%04X\n", nDrumDataLen, dwDrumDataPos);
237237
#endif
238238
if (dwMemPos >= dwMemLength-12) return TRUE;
239-
if (!*(DWORD *)(lpStream+dwMemPos)) dwMemPos += 4;
240-
if (!*(DWORD *)(lpStream+dwMemPos)) dwMemPos += 4;
241-
nExtraDataLen = *(DWORD *)(lpStream+dwMemPos);
239+
if (!READ_LE32(lpStream+dwMemPos)) dwMemPos += 4;
240+
if (!READ_LE32(lpStream+dwMemPos)) dwMemPos += 4;
241+
nExtraDataLen = READ_LE32(lpStream+dwMemPos);
242242
dwExtraDataPos = dwMemPos + 4;
243243
dwMemPos += 4;
244244
#ifdef MT2DEBUG
@@ -247,8 +247,8 @@ BOOL CSoundFile::ReadMT2(LPCBYTE lpStream, DWORD dwMemLength)
247247
if (dwMemPos + nExtraDataLen >= dwMemLength) return TRUE;
248248
while (dwMemPos+8 < dwExtraDataPos + nExtraDataLen)
249249
{
250-
DWORD dwId = *(DWORD *)(lpStream+dwMemPos);
251-
DWORD dwLen = *(DWORD *)(lpStream+dwMemPos+4);
250+
DWORD dwId = READ_LE32(lpStream+dwMemPos);
251+
DWORD dwLen = READ_LE32(lpStream+dwMemPos+4);
252252
dwMemPos += 8;
253253
if (dwLen >= dwMemLength || dwMemPos > dwMemLength - dwLen) return TRUE;
254254
#ifdef MT2DEBUG
@@ -374,7 +374,7 @@ BOOL CSoundFile::ReadMT2(LPCBYTE lpStream, DWORD dwMemLength)
374374
for (UINT iDrm=0; iDrm<pdd->wDrumPatterns; iDrm++)
375375
{
376376
if (dwMemPos > dwMemLength-2) return TRUE;
377-
UINT nLines = *(WORD *)(lpStream+dwMemPos);
377+
UINT nLines = READ_LE16(lpStream+dwMemPos);
378378
#ifdef MT2DEBUG
379379
if (nLines != 64) Log("Drum Pattern %d: %d Lines @%04X\n", iDrm, nLines, dwMemPos);
380380
#endif
@@ -401,7 +401,7 @@ BOOL CSoundFile::ReadMT2(LPCBYTE lpStream, DWORD dwMemLength)
401401
if (pma->dwFlags & (1 << iEnv))
402402
{
403403
#ifdef MT2DEBUG
404-
UINT nPoints = *(DWORD *)(lpStream+dwMemPos);
404+
UINT nPoints = READ_LE32(lpStream+dwMemPos);
405405
Log(" Env[%d/%d] %04X @%04X: %d points\n", iAuto, nAutoCount, 1 << iEnv, dwMemPos-8, nPoints);
406406
#endif
407407
dwMemPos += 260;
@@ -656,7 +656,7 @@ BOOL CSoundFile::ReadMT2(LPCBYTE lpStream, DWORD dwMemLength)
656656
} else
657657
if (dwMemPos < dwMemLength-4)
658658
{
659-
UINT nNameLen = *(DWORD *)(lpStream+dwMemPos);
659+
UINT nNameLen = READ_LE32(lpStream+dwMemPos);
660660
dwMemPos += nNameLen + 16;
661661
}
662662
if (dwMemPos >= dwMemLength-4) break;

‎src/load_psm.cpp‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -215,7 +215,7 @@ BOOL CSoundFile::ReadPSM(LPCBYTE lpStream, DWORD dwMemLength)
215215
m_nChannels = pSong->channels;
216216
// Valid song header -> convert attached chunks
217217
{
218-
DWORD dwSongEnd = dwSongPos + 8 + *(DWORD *)(lpStream+dwSongPos+4);
218+
DWORD dwSongEnd = dwSongPos + 8 + READ_LE32(lpStream+dwSongPos+4);
219219
dwMemPos = dwSongPos + 8 + 11; // sizeof(PSMCHUNK)+sizeof(PSMSONGHDR)
220220
while (dwMemPos + 8 < dwSongEnd)
221221
{
@@ -235,10 +235,10 @@ BOOL CSoundFile::ReadPSM(LPCBYTE lpStream, DWORD dwMemLength)
235235
{
236236
BOOL bFound = FALSE;
237237
pos -= 5;
238-
DWORD dwName = *(DWORD *)(pdata+pos);
238+
DWORD dwName = READ_LE32(pdata+pos);
239239
for (UINT i=0; i<nPatterns; i++)
240240
{
241-
DWORD dwPatName = ((const PSMPATTERN *)(lpStream+patptrs[i]+8))->name;
241+
DWORD dwPatName = READ_LE32(lpStream+patptrs[i]+12);
242242
if (dwName == dwPatName)
243243
{
244244
bFound = TRUE;
@@ -256,10 +256,10 @@ BOOL CSoundFile::ReadPSM(LPCBYTE lpStream, DWORD dwMemLength)
256256
UINT iOrd = 0;
257257
while ((pos+5<len) && (iOrd < MAX_ORDERS))
258258
{
259-
DWORD dwName = *(DWORD *)(pdata+pos);
259+
DWORD dwName = READ_LE32(pdata+pos);
260260
for (UINT i=0; i<nPatterns; i++)
261261
{
262-
DWORD dwPatName = ((const PSMPATTERN *)(lpStream+patptrs[i]+8))->name;
262+
DWORD dwPatName = READ_LE32(lpStream+patptrs[i]+12);
263263
if (dwName == dwPatName)
264264
{
265265
Order[iOrd++] = i;

‎src/load_s3m.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -341,7 +341,7 @@ BOOL CSoundFile::ReadS3M(const BYTE *lpStream, DWORD dwMemLength)
341341
{
342342
UINT nInd = ((DWORD)ptr[nins+iPat]) << 4;
343343
if (nInd + 0x40 > dwMemLength) continue;
344-
WORD len = bswapLE16(*((WORD *)(lpStream+nInd)));
344+
WORD len = READ_LE16(lpStream+nInd);
345345
nInd += 2;
346346
PatternSize[iPat] = 64;
347347
if ((!len) || (nInd + len > dwMemLength - 6)

0 commit comments

Comments
 (0)