1 files changed, 4 insertions, 1 deletions

diff --git a/core/multimedia/opieplayer/modplug/sndfile.cpp b/core/multimedia/opieplayer/modplug/sndfile.cpp
index 1d0d610..799555c 100644
--- a/core/multimedia/opieplayer/modplug/sndfile.cpp
+++ b/core/multimedia/opieplayer/modplug/sndfile.cpp
@@ -1646,193 +1646,196 @@ DWORD CSoundFile::TransposeToFrequency(int transp, int ftune)
         fscale
         fstp st(1)
         fmul st(1), st(0)
         faddp st(1), st(0)
         fistp freq
         }
         UINT derr = freq % 11025;
         if (derr <= 8) freq -= derr;
         if (derr >= 11015) freq += 11025-derr;
         derr = freq % 1000;
         if (derr <= 5) freq -= derr;
         if (derr >= 995) freq += 1000-derr;
         return freq;
 #endif
 }
 
 
 // returns 12*128*log2(freq/8363)
 int CSoundFile::FrequencyToTranspose(DWORD freq)
 //----------------------------------------------
 {
         //---GCCFIX:  Removed assembly.
         return int(1536*(log(freq/8363)/log(2)));
         
 #ifdef WIN32
         const float _f1_8363 = 1.0f / 8363.0f;
         const float _factor = 128 * 12;
         LONG result;
         
         if (!freq) return 0;
         _asm {
         fld _factor
         fild freq
         fld _f1_8363
         fmulp st(1), st(0)
         fyl2x
         fistp result
         }
         return result;
 #endif
 }
 
 
 void CSoundFile::FrequencyToTranspose(MODINSTRUMENT *psmp)
 //--------------------------------------------------------
 {
         int f2t = FrequencyToTranspose(psmp->nC4Speed);
         int transp = f2t >> 7;
         int ftune = f2t & 0x7F;
         if (ftune > 80)
         {
                 transp++;
                 ftune -= 128;
         }
         if (transp > 127) transp = 127;
         if (transp < -127) transp = -127;
         psmp->RelativeTone = transp;
         psmp->nFineTune = ftune;
 }
 
 
 void CSoundFile::CheckCPUUsage(UINT nCPU)
 //---------------------------------------
 {
         if (nCPU > 100) nCPU = 100;
         gnCPUUsage = nCPU;
         if (nCPU < 90)
         {
                 m_dwSongFlags &= ~SONG_CPUVERYHIGH;
         } else
         if ((m_dwSongFlags & SONG_CPUVERYHIGH) && (nCPU >= 94))
         {
                 UINT i=MAX_CHANNELS;
                 while (i >= 8)
                 {
                         i--;
                         if (Chn[i].nLength)
                         {
                                 Chn[i].nLength = Chn[i].nPos = 0;
                                 nCPU -= 2;
                                 if (nCPU < 94) break;
                         }
                 }
         } else
         if (nCPU > 90)
         {
                 m_dwSongFlags |= SONG_CPUVERYHIGH;
         }
 }
 
 
 BOOL CSoundFile::SetPatternName(UINT nPat, LPCSTR lpszName)
 //---------------------------------------------------------
 {
         char szName[MAX_PATTERNNAME] = "";   // changed from CHAR
         if (nPat >= MAX_PATTERNS) return FALSE;
-        if (lpszName) lstrcpyn(szName, lpszName, MAX_PATTERNNAME);
+        if (lpszName)
+                lstrcpyn(szName, lpszName, MAX_PATTERNNAME);
+        else
+                return FALSE;
         szName[MAX_PATTERNNAME-1] = 0;
         if (!m_lpszPatternNames) m_nPatternNames = 0;
         if (nPat >= m_nPatternNames)
         {
                 if (!lpszName[0]) return TRUE;
                 UINT len = (nPat+1)*MAX_PATTERNNAME;
                 char *p = new char[len];   // changed from CHAR
                 if (!p) return FALSE;
                 memset(p, 0, len);
                 if (m_lpszPatternNames)
                 {
                         memcpy(p, m_lpszPatternNames, m_nPatternNames * MAX_PATTERNNAME);
                         delete m_lpszPatternNames;
                         m_lpszPatternNames = NULL;
                 }
                 m_lpszPatternNames = p;
                 m_nPatternNames = nPat + 1;
         }
         memcpy(m_lpszPatternNames + nPat * MAX_PATTERNNAME, szName, MAX_PATTERNNAME);
         return TRUE;
 }
 
 
 BOOL CSoundFile::GetPatternName(UINT nPat, LPSTR lpszName, UINT cbSize) const
 //---------------------------------------------------------------------------
 {
         if ((!lpszName) || (!cbSize)) return FALSE;
         lpszName[0] = 0;
         if (cbSize > MAX_PATTERNNAME) cbSize = MAX_PATTERNNAME;
         if ((m_lpszPatternNames) && (nPat < m_nPatternNames))
         {
                 memcpy(lpszName, m_lpszPatternNames + nPat * MAX_PATTERNNAME, cbSize);
                 lpszName[cbSize-1] = 0;
                 return TRUE;
         }
         return FALSE;
 }
 
 
 #ifndef FASTSOUNDLIB
 
 UINT CSoundFile::DetectUnusedSamples(BOOL *pbIns)
 //-----------------------------------------------
 {
         UINT nExt = 0;
 
         if (!pbIns) return 0;
         if (m_nInstruments)
         {
                 memset(pbIns, 0, MAX_SAMPLES * sizeof(BOOL));
                 for (UINT ipat=0; ipat<MAX_PATTERNS; ipat++)
                 {
                         MODCOMMAND *p = Patterns[ipat];
                         if (p)
                         {
                                 UINT jmax = PatternSize[ipat] * m_nChannels;
                                 for (UINT j=0; j<jmax; j++, p++)
                                 {
                                         if ((p->note) && (p->note <= 120))
                                         {
                                                 if ((p->instr) && (p->instr < MAX_INSTRUMENTS))
                                                 {
                                                         INSTRUMENTHEADER *penv = Headers[p->instr];
                                                         if (penv)
                                                         {
                                                                 UINT n = penv->Keyboard[p->note-1];
                                                                 if (n < MAX_SAMPLES) pbIns[n] = TRUE;
                                                         }
                                                 } else
                                                 {
                                                         for (UINT k=1; k<=m_nInstruments; k++)
                                                         {
                                                                 INSTRUMENTHEADER *penv = Headers[k];
                                                                 if (penv)
                                                                 {
                                                                         UINT n = penv->Keyboard[p->note-1];
                                                                         if (n < MAX_SAMPLES) pbIns[n] = TRUE;
                                                                 }
                                                         }
                                                 }
                                         }
                                 }
                         }
                 }
                 for (UINT ichk=1; ichk<=m_nSamples; ichk++)
                 {
                         if ((!pbIns[ichk]) && (Ins[ichk].pSample)) nExt++;
                 }
         }
         return nExt;
 }
 
 
 BOOL CSoundFile::RemoveSelectedSamples(BOOL *pbIns)
 //-------------------------------------------------
 {