[Scummvm-cvs-logs] CVS: scummvm/backends/midi/mt32 mt32.cpp,1.1,1.2 partial.cpp,1.2,1.3 partial.h,1.1,1.2 structures.h,1.2,1.3 synth.cpp,1.5,1.6 synth.h,1.1,1.2
Torbjörn Andersson
eriktorbjorn at users.sourceforge.net
Fri Oct 22 08:44:59 CEST 2004
Update of /cvsroot/scummvm/scummvm/backends/midi/mt32
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv10181
Modified Files:
mt32.cpp partial.cpp partial.h structures.h synth.cpp synth.h
Log Message:
Replaced the Bit* data types with ScummVM's int* and uint* types. The
64-bit type has been renamed int64 and uint64. As a consequence, bug
#1051999 (the MinGW compilation problems) is now fixed.
Index: mt32.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/backends/midi/mt32/mt32.cpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- mt32.cpp 21 Oct 2004 22:37:30 -0000 1.1
+++ mt32.cpp 22 Oct 2004 15:39:27 -0000 1.2
@@ -120,7 +120,7 @@
}
void MidiDriver_MT32::generate_samples(int16 *data, int len) {
- _synth->MT32_CallBack((Bit8u *)data, len, _mixer->getMusicVolume());
+ _synth->MT32_CallBack((uint8 *)data, len, _mixer->getMusicVolume());
}
Index: partial.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/backends/midi/mt32/partial.cpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- partial.cpp 21 Oct 2004 23:03:09 -0000 1.2
+++ partial.cpp 22 Oct 2004 15:39:27 -0000 1.3
@@ -25,7 +25,7 @@
#include "backends/midi/mt32/synth.h"
#include "backends/midi/mt32/partial.h"
-INLINE void CPartialMT32::generateSamples(Bit16s * partialBuf, long length) {
+INLINE void CPartialMT32::generateSamples(int16 * partialBuf, long length) {
if (!isActive) return;
if (alreadyOutputed) return;
@@ -36,11 +36,11 @@
int r;
int i;
- Bit32s envval, ampval, filtval;
+ int32 envval, ampval, filtval;
soundaddr *pOff = &partCache->partialOff;
int noteval = partCache->keyedval;
for(i=0;i<length;i++) {
- Bit32s ptemp = 0;
+ int32 ptemp = 0;
if(partCache->envs[AMPENV].sustaining) {
ampval = partCache->ampEnvCache;
@@ -135,7 +135,7 @@
rb = romfile[taddr+1];
dist = rb-ra;
- r = (ra + ((dist * (Bit32s)(pOff->pcmoffs.pcmoffset>>8)) >>8));
+ r = (ra + ((dist * (int32)(pOff->pcmoffs.pcmoffset>>8)) >>8));
} else {
@@ -189,7 +189,7 @@
divis = divtable[noteval]>>15;
- if(pOff->pcmoffs.pcmplace>=divis) pOff->pcmoffs.pcmplace = (Bit16u)(pOff->pcmoffs.pcmplace-divis);
+ if(pOff->pcmoffs.pcmplace>=divis) pOff->pcmoffs.pcmplace = (uint16)(pOff->pcmoffs.pcmplace-divis);
toff = pOff->pcmoffs.pcmplace;
minorplace = pOff->pcmoffs.pcmoffset >> 14;
@@ -198,7 +198,7 @@
if(ampval>0) {
- filtval = getFiltEnvelope((Bit16s)ptemp,partCache,tmppoly);
+ filtval = getFiltEnvelope((int16)ptemp,partCache,tmppoly);
//LOG_MSG("Filtval: %d", filtval);
@@ -282,7 +282,7 @@
//Very exact filter
//ptemp[t] = (int)iir_filter((float)ptemp[t],&partCache->history[t],filtcoeff[filtval][tcache->filtEnv.resonance]);
if(filtval>((FILTERGRAN*15)/16)) filtval = ((FILTERGRAN*15)/16);
- ptemp = (Bit32s)(usefilter)((float)ptemp,&partCache->history[0],filtcoeff[filtval][(int)tcache->filtEnv.resonance], tcache->filtEnv.resonance);
+ ptemp = (int32)(usefilter)((float)ptemp,&partCache->history[0],filtcoeff[filtval][(int)tcache->filtEnv.resonance], tcache->filtEnv.resonance);
} else ptemp = 0;
//ptemp[t] = Moog1(ptemp[t],&partCache->history[t],(float)filtval/8192.0,tcache->filtEnv.resonance);
@@ -304,7 +304,7 @@
*/
// Fix delta code
- __int64 tdelta = (__int64)delta;
+ int64 tdelta = (int64)delta;
tdelta = (tdelta * tcache->fineshift)>>12;
tdelta = (tdelta * pdep)>>12;
tdelta = (tdelta * lfoat)>>12;
@@ -321,23 +321,23 @@
partCache->envs[PITCHENV].envpos++;
partCache->envs[FILTENV].envpos++;
- *partialBuf++ = (Bit16s)ptemp;
+ *partialBuf++ = (int16)ptemp;
}
}
-INLINE void CPartialMT32::mixBuffers(Bit16s * buf1, Bit16s *buf2, int len) {
+INLINE void CPartialMT32::mixBuffers(int16 * buf1, int16 *buf2, int len) {
// Early exit if no need to mix
if(tibrePair==NULL) return;
#if USE_MMX == 0
int i;
for(i=0;i<len;i++) {
- Bit32s tmp1 = buf1[i];
- Bit32s tmp2 = buf2[i];
+ int32 tmp1 = buf1[i];
+ int32 tmp2 = buf2[i];
tmp1 += tmp2;
- buf1[i] = (Bit16s)tmp1;
+ buf1[i] = (int16)tmp1;
}
#else
len = (len>>2)+4;
@@ -366,7 +366,7 @@
#endif
}
-INLINE void CPartialMT32::mixBuffersRingMix(Bit16s * buf1, Bit16s *buf2, int len) {
+INLINE void CPartialMT32::mixBuffersRingMix(int16 * buf1, int16 *buf2, int len) {
#if USE_MMX != 2
int i;
for(i=0;i<len;i++) {
@@ -376,9 +376,9 @@
a = (a * b) + a;
if(a>1.0) a = 1.0;
if(a<-1.0) a = -1.0;
- buf1[i] = (Bit16s)(a * 8192.0);
+ buf1[i] = (int16)(a * 8192.0);
- //buf1[i] = (Bit16s)(((Bit32s)buf1[i] * (Bit32s)buf2[i]) >> 10) + buf1[i];
+ //buf1[i] = (int16)(((int32)buf1[i] * (int32)buf2[i]) >> 10) + buf1[i];
}
#else
len = (len>>2)+4;
@@ -409,7 +409,7 @@
#endif
}
-INLINE void CPartialMT32::mixBuffersRing(Bit16s * buf1, Bit16s *buf2, int len) {
+INLINE void CPartialMT32::mixBuffersRing(int16 * buf1, int16 *buf2, int len) {
#if USE_MMX != 2
int i;
for(i=0;i<len;i++) {
@@ -419,8 +419,8 @@
a *= b;
if(a>1.0) a = 1.0;
if(a<-1.0) a = -1.0;
- buf1[i] = (Bit16s)(a * 8192.0);
- //buf1[i] = (Bit16s)(((Bit32s)buf1[i] * (Bit32s)buf2[i]) >> 10);
+ buf1[i] = (int16)(a * 8192.0);
+ //buf1[i] = (int16)(((int32)buf1[i] * (int32)buf2[i]) >> 10);
}
#else
len = (len>>2)+4;
@@ -449,7 +449,7 @@
#endif
}
-INLINE void CPartialMT32::mixBuffersStereo(Bit16s *buf1, Bit16s *buf2, Bit16s *outBuf, int len) {
+INLINE void CPartialMT32::mixBuffersStereo(int16 *buf1, int16 *buf2, int16 *outBuf, int len) {
int i,m;
m=0;
for(i=0;i<len;i++) {
@@ -461,7 +461,7 @@
}
-bool CPartialMT32::produceOutput(Bit16s * partialBuf, long length) {
+bool CPartialMT32::produceOutput(int16 * partialBuf, long length) {
if (!isActive) return false;
if (alreadyOutputed) return false;
int i;
@@ -488,7 +488,7 @@
fwrite(myBuffer + i, 1, 2, fo);
fclose(fo);
*/
- Bit16s * p1buf, * p2buf;
+ int16 * p1buf, * p2buf;
if((partNum==0) || ((partNum==1) && (tibrePair==NULL))) {
p1buf = &myBuffer[0];
@@ -526,20 +526,20 @@
int m;
m = 0;
- Bit16s leftvol, rightvol;
+ int16 leftvol, rightvol;
if (!tmppoly->isRy) {
leftvol = tmppoly->pansetptr->leftvol;
rightvol = tmppoly->pansetptr->rightvol;
} else {
- leftvol = (Bit16s)drumPan[tmppoly->pcmnum][0];
- rightvol = (Bit16s)drumPan[tmppoly->pcmnum][1];
+ leftvol = (int16)drumPan[tmppoly->pcmnum][0];
+ rightvol = (int16)drumPan[tmppoly->pcmnum][1];
}
#if USE_MMX == 0
for(i=0;i<length;i++) {
- partialBuf[m] = (Bit16s)(((Bit32s)p1buf[i] * (Bit32s)leftvol) >> 16);
+ partialBuf[m] = (int16)(((int32)p1buf[i] * (int32)leftvol) >> 16);
m++;
- partialBuf[m] = (Bit16s)(((Bit32s)p1buf[i] * (Bit32s)rightvol) >> 16);
+ partialBuf[m] = (int16)(((int32)p1buf[i] * (int32)rightvol) >> 16);
m++;
}
#else
Index: partial.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/backends/midi/mt32/partial.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- partial.h 21 Oct 2004 22:37:30 -0000 1.1
+++ partial.h 22 Oct 2004 15:39:27 -0000 1.2
@@ -36,14 +36,14 @@
- Bit16s myBuffer[2048];
+ int16 myBuffer[2048];
// For temporary output of paired buffer
- Bit16s pairBuffer[2048];
+ int16 pairBuffer[2048];
- void mixBuffers(Bit16s * buf1, Bit16s * buf2, int len);
- void mixBuffersRingMix(Bit16s * buf1, Bit16s * buf2, int len);
- void mixBuffersRing(Bit16s * buf1, Bit16s * buf2, int len);
- void mixBuffersStereo(Bit16s * buf1, Bit16s * buf2, Bit16s * outBuf, int len);
+ void mixBuffers(int16 * buf1, int16 * buf2, int len);
+ void mixBuffersRingMix(int16 * buf1, int16 * buf2, int len);
+ void mixBuffersRing(int16 * buf1, int16 * buf2, int len);
+ void mixBuffersStereo(int16 * buf1, int16 * buf2, int16 * outBuf, int len);
public:
@@ -59,7 +59,7 @@
bool isActive;
bool alreadyOutputed;
int ownerChan;
- Bit64s age;
+ int64 age;
int timbreNum;
dpoly *tmppoly;
@@ -103,10 +103,10 @@
// Returns true only if data written to buffer
// This function (unline the one below it) returns processed stereo samples
// made from combining this single partial with its pair, if it has one.
- bool produceOutput(Bit16s * partialBuf, long length);
+ bool produceOutput(int16 * partialBuf, long length);
// This function produces mono sample output of the specific partial
- void generateSamples(Bit16s * partialBuf, long length);
+ void generateSamples(int16 * partialBuf, long length);
};
Index: structures.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/backends/midi/mt32/structures.h,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- structures.h 22 Oct 2004 09:38:11 -0000 1.2
+++ structures.h 22 Oct 2004 15:39:27 -0000 1.3
@@ -27,21 +27,12 @@
#include "common/scummsys.h"
#if defined(_MSC_VER)
-typedef unsigned __int64 Bit64u;
-typedef signed __int64 Bit64s;
+typedef unsigned __int64 uint64;
+typedef signed __int64 int64;
#else
-typedef unsigned long long Bit64u;
-typedef signed long long Bit64s;
+typedef unsigned long long uint64;
+typedef signed long long int64;
#endif
-typedef unsigned int Bit32u;
-typedef signed int Bit32s;
-typedef unsigned short int Bit16u;
-typedef signed short int Bit16s;
-typedef unsigned char Bit8u;
-typedef signed char Bit8s;
-
-// The occurences of __int64 should be changed to Bit64s
-#define __int64 Bit64u
#define INLINE
@@ -266,7 +257,7 @@
return 0;
}
-static inline void atti386_produceOutput1(int tmplen, Bit16s myvolume, Bit16s *useBuf, Bit16s *snd)
+static inline void atti386_produceOutput1(int tmplen, int16 myvolume, int16 *useBuf, int16 *snd)
{
__asm__ __volatile__(
"movl %0, %%ecx \n" \
@@ -298,7 +289,7 @@
}
// FIXME: This is buggy
-static inline void atti386_produceOutput2(Bit32u len, Bit16s *snd, float *sndbufl, float *sndbufr, float *multFactor)
+static inline void atti386_produceOutput2(uint32 len, int16 *snd, float *sndbufl, float *sndbufr, float *multFactor)
{
__asm__ __volatile__(
"movl %4, %%ecx \n" \
@@ -339,7 +330,7 @@
: "eax", "ecx", "edi", "esi", "mm1", "mm2", "xmm1", "memory");
}
-static inline void atti386_mixBuffers(Bit16s * buf1, Bit16s *buf2, int len)
+static inline void atti386_mixBuffers(int16 * buf1, int16 *buf2, int len)
{
__asm__ __volatile__(
"movl %0, %%ecx \n" \
@@ -360,7 +351,7 @@
: "ecx", "edi", "esi", "mm1", "mm2", "memory");
}
-static inline void atti386_mixBuffersRingMix(Bit16s * buf1, Bit16s *buf2, int len)
+static inline void atti386_mixBuffersRingMix(int16 * buf1, int16 *buf2, int len)
{
__asm__ __volatile__(
"movl %0, %%ecx \n" \
@@ -383,7 +374,7 @@
: "ecx", "edi", "esi", "mm1", "mm2", "mm3", "memory");
}
-static inline void atti386_mixBuffersRing(Bit16s * buf1, Bit16s *buf2, int len)
+static inline void atti386_mixBuffersRing(int16 * buf1, int16 *buf2, int len)
{
__asm__ __volatile__(
"movl %0, %%ecx \n" \
@@ -404,8 +395,8 @@
: "ecx", "edi", "esi", "mm1", "mm2", "memory");
}
-static inline void atti386_PartProductOutput(int quadlen, Bit16s leftvol, Bit16s rightvol,
- Bit16s *partialBuf, Bit16s *p1buf)
+static inline void atti386_PartProductOutput(int quadlen, int16 leftvol, int16 rightvol,
+ int16 *partialBuf, int16 *p1buf)
{
__asm__ __volatile__(
"movl %0, %%ecx \n" \
@@ -583,43 +574,43 @@
#pragma pack()
struct partialFormat {
- Bit32u addr;
- Bit16u len;
+ uint32 addr;
+ uint16 len;
bool loop;
float tune;
- Bit32s ampval;
+ int32 ampval;
};
struct partialTable {
- Bit32u addr;
- Bit32u len;
- Bit32u pcmnum;
- Bit32s ampval;
+ uint32 addr;
+ uint32 len;
+ uint32 pcmnum;
+ int32 ampval;
bool loop;
- Bit32s aggSound; // This variable is for the last 9 PCM samples, which are actually loop combinations
+ int32 aggSound; // This variable is for the last 9 PCM samples, which are actually loop combinations
};
union soundaddr {
- Bit32u pcmabs;
+ uint32 pcmabs;
struct offsets {
#if defined(SCUMM_LITTLE_ENDIAN)
- Bit16u pcmoffset;
- Bit16u pcmplace;
+ uint16 pcmoffset;
+ uint16 pcmplace;
#else
- Bit16u pcmplace;
- Bit16u pcmoffset;
+ uint16 pcmplace;
+ uint16 pcmoffset;
#endif
} pcmoffs;
};
struct volset {
- Bit16s leftvol;
- Bit16s rightvol;
- Bit16s leftvol2;
- Bit16s rightvol2;
+ int16 leftvol;
+ int16 rightvol;
+ int16 leftvol2;
+ int16 rightvol2;
};
struct patchCache {
@@ -638,7 +629,7 @@
int lfodepth;
int lforate;
- Bit32u lfoperiod;
+ uint32 lfoperiod;
int modsense;
int keydir;
@@ -668,13 +659,13 @@
timbreParam::partialParam::tvaParam ampEnv;
timbreParam::partialParam::tvfParam filtEnv;
- Bit32s ampsustain;
- Bit32s pitchsustain;
- Bit32s filtsustain;
+ int32 ampsustain;
+ int32 pitchsustain;
+ int32 filtsustain;
- Bit32u partCount;
+ uint32 partCount;
- Bit8u padding[64]; //Used to pad the patch cache to 4096 bytes. This replaces an imul with a shl 12
+ uint8 padding[64]; //Used to pad the patch cache to 4096 bytes. This replaces an imul with a shl 12
};
@@ -686,9 +677,9 @@
bool partActive[4];
bool isRy;
- Bit32u *bendptr;
- Bit32u drumbend;
- Bit32s *volumeptr;
+ uint32 *bendptr;
+ uint32 drumbend;
+ int32 *volumeptr;
volset *pansetptr;
int pcmnum;
@@ -696,10 +687,10 @@
int freqnum;
int vel;
- Bit32u partCount;
+ uint32 partCount;
soundaddr pcmoff;
- Bit32u pcmdelta;
+ uint32 pcmdelta;
struct partialStatus {
@@ -716,29 +707,29 @@
int pulsewidth;
struct envstatus {
- Bit32s envpos;
- Bit32s envstat;
- Bit32s envbase;
- Bit32s envdist;
- Bit32s envsize;
+ int32 envpos;
+ int32 envstat;
+ int32 envbase;
+ int32 envdist;
+ int32 envsize;
bool sustaining;
bool decaying;
bool notdecayed;
- Bit32u decay;
- Bit32s prevlevel;
+ uint32 decay;
+ int32 prevlevel;
- Bit32s counter;
- Bit32s count;
+ int32 counter;
+ int32 count;
} envs[4];
- Bit32u lfopos;
+ uint32 lfopos;
soundaddr partialOff;
soundaddr wgOff;
- Bit32u ampEnvCache;
- Bit32u pitchEnvCache;
+ uint32 ampEnvCache;
+ uint32 pitchEnvCache;
bool isDecayed;
bool PCMDone;
@@ -772,8 +763,8 @@
bool pedalhold;
bool firstsamp;
- Bit32u P1Mix;
- Bit32u P2Mix;
+ uint32 P1Mix;
+ uint32 P2Mix;
bool sustain;
};
Index: synth.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/backends/midi/mt32/synth.cpp,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -d -r1.5 -r1.6
--- synth.cpp 22 Oct 2004 10:24:48 -0000 1.5
+++ synth.cpp 22 Oct 2004 15:39:27 -0000 1.6
@@ -372,7 +372,7 @@
#define SYSEX_SIZE 512
// These are all the filters I tried without much success
-Bit16s Moog1(Bit16s wg, float *hist, float usefilt, float res) {
+int16 Moog1(int16 wg, float *hist, float usefilt, float res) {
float f, p, q; //filter coefficients
float t1, t2; //temporary buffers
@@ -404,10 +404,10 @@
hist[4] = hist[4] - hist[4] * hist[4] * hist[4] * 0.166667f; //clipping
hist[0] = in;
//LOG_MSG("In %d Hist: %f", wg, hist[4]*32767);
- return (Bit16s)(hist[4]*32767.0);
+ return (int16)(hist[4]*32767.0);
}
-Bit16s Moog2(Bit16s wg, float *hist, float usefilt, float resonance) {
+int16 Moog2(int16 wg, float *hist, float usefilt, float resonance) {
float res = resonance / 30.0;
double f = usefilt;
@@ -424,10 +424,10 @@
hist[7] = hist[2];
hist[4] = hist[3] + 0.3 * hist[0] + (invf) * hist[4]; // Pole 4
hist[0] = hist[3];
- return (Bit16s)(hist[4]*32767.0);
+ return (int16)(hist[4]*32767.0);
}
-Bit16s simpleLowpass(Bit16s wg, float *hist, float usefilt, float resonance) {
+int16 simpleLowpass(int16 wg, float *hist, float usefilt, float resonance) {
float in = (float)wg/32767.0;
float res_lp = resonance / 31.0;
@@ -1012,11 +1012,11 @@
#if FILTER_64BIT == 1
// 64-bit version
-long iir_filter(long input, __int64 *hist1_ptr, __int64 *coef_ptr)
+long iir_filter(long input, int64 *hist1_ptr, int64 *coef_ptr)
{
unsigned int i;
- __int64 *hist2_ptr;
- __int64 output,new_hist,history1,history2;
+ int64 *hist2_ptr;
+ int64 output,new_hist,history1,history2;
hist2_ptr = hist1_ptr + 1; // next history
@@ -1084,17 +1084,17 @@
partialFormat PCM[54];
partialTable PCMList[128];
-Bit32u PCMReassign[55];
-Bit32s PCMLoopTable[55];
+uint32 PCMReassign[55];
+int32 PCMLoopTable[55];
timbreParam drums[30];
-Bit16s romfile[PCMSIZE+GRAN]; // 256K
-static Bit16s chantable[32]; // 64 bytes
-static Bit16s miditable[9]; // 18 bytes
+int16 romfile[PCMSIZE+GRAN]; // 256K
+static int16 chantable[32]; // 64 bytes
+static int16 miditable[9]; // 18 bytes
static CPartialMT32 *partTable[MAXPARTIALS];
-static Bit32s PartialReserveTable[32];
+static int32 PartialReserveTable[32];
// For debuging partial allocation
//static FILE *pInfo;
@@ -1105,89 +1105,89 @@
int status[32];
};
-static Bit32s activeChannels;
+static int32 activeChannels;
// Some optimization stuff
-Bit32s divtable[256]; // 1K
-Bit32s smalldivtable[256]; // 1K
-static Bit16s freqtable[256]; // 512 bytes
-static Bit32u sqrtable[101]; // 404 bytes
-static Bit32s keytable[256]; // 1K
-static Bit32u wavtable[256]; // 1K
-Bit32u wavtabler[64][256]; // 64K
-Bit32u looptabler[16][16][256]; // 256K
-static Bit32u drumdelta[256]; // 1K
-Bit16s sintable[65536]; // 128K
-static Bit32s ptable[101]; // 404 bytes
-static Bit32s lfotable[101]; // 404 bytes
-Bit32s penvtable[16][128]; // 8K
-static Bit32s fildeptable[5][128]; // 3K
-static Bit32s timekeytable[5][128]; // 3K
-static Bit32s filveltable[128][128]; // 64K
-static Bit32s veltkeytable[5][128]; // 3K
-Bit32s pulsetable[101]; // 400 bytes
-Bit32s pulseoffset[101]; // 400 bytes
-Bit32s sawtable[128][128]; // 64K
-static Bit32s restable[201]; // 804 bytes
-//static Bit32s biastable[13]; // 56 bytes
-static Bit32s ampbiastable[16][128]; // 8K
-static Bit32s fbiastable[16][128]; // 8K
+int32 divtable[256]; // 1K
+int32 smalldivtable[256]; // 1K
+static int16 freqtable[256]; // 512 bytes
+static uint32 sqrtable[101]; // 404 bytes
+static int32 keytable[256]; // 1K
+static uint32 wavtable[256]; // 1K
+uint32 wavtabler[64][256]; // 64K
+uint32 looptabler[16][16][256]; // 256K
+static uint32 drumdelta[256]; // 1K
+int16 sintable[65536]; // 128K
+static int32 ptable[101]; // 404 bytes
+static int32 lfotable[101]; // 404 bytes
+int32 penvtable[16][128]; // 8K
+static int32 fildeptable[5][128]; // 3K
+static int32 timekeytable[5][128]; // 3K
+static int32 filveltable[128][128]; // 64K
+static int32 veltkeytable[5][128]; // 3K
+int32 pulsetable[101]; // 400 bytes
+int32 pulseoffset[101]; // 400 bytes
+int32 sawtable[128][128]; // 64K
+static int32 restable[201]; // 804 bytes
+//static int32 biastable[13]; // 56 bytes
+static int32 ampbiastable[16][128]; // 8K
+static int32 fbiastable[16][128]; // 8K
static int filttable[2][128][256]; // 256K
static int nfilttable[128][128][128]; // 64K
float filtcoeff[FILTERGRAN][32][16]; // 512K - hmmm
#if FILTER_64BIT == 1
-static __int64 filtcoefffix[FILTERGRAN][32][16];
+static int64 filtcoefffix[FILTERGRAN][32][16];
#endif
#if FILTER_INT == 1
-static Bit32s filtcoefffix[FILTERGRAN][32][16];
+static int32 filtcoefffix[FILTERGRAN][32][16];
#endif
static float revtable[8]; // 16 bytes
-static Bit32s finetable[201]; // 804 bytes
-Bit32u lfoptable[101][128]; // 32K
-Bit32s ampveltable[128][64]; // 32K
-Bit32s pwveltable[15][128];
-static Bit32s envtimetable[101]; // 404 bytes
-static Bit32s decaytimetable[101]; // 404 bytes
-static Bit32s lasttimetable[101]; // 404 bytes
-Bit32s amptable[129]; // 516 bytes
-static Bit32s voltable[129]; // 516 bytes
+static int32 finetable[201]; // 804 bytes
+uint32 lfoptable[101][128]; // 32K
+int32 ampveltable[128][64]; // 32K
+int32 pwveltable[15][128];
+static int32 envtimetable[101]; // 404 bytes
+static int32 decaytimetable[101]; // 404 bytes
+static int32 lasttimetable[101]; // 404 bytes
+int32 amptable[129]; // 516 bytes
+static int32 voltable[129]; // 516 bytes
static float padjtable[51]; // 204 bytes
-static Bit32s bendtable[49]; // 195 bytes
+static int32 bendtable[49]; // 195 bytes
float ResonFactor[32];
float ResonInv[32];
-Bit16s smallnoise[441]; // 4410 bytes at 44Khz
-Bit32s samplepos = 0;
+int16 smallnoise[441]; // 4410 bytes at 44Khz
+int32 samplepos = 0;
-Bit16s* waveforms[4][256]; // 2K
-Bit32u waveformsize[4][256];
-Bit16s tmpforms[4][65536]; // 128K
-Bit16s finalforms[4][8192]; // 64K
+int16* waveforms[4][256]; // 2K
+uint32 waveformsize[4][256];
+int16 tmpforms[4][65536]; // 128K
+int16 finalforms[4][8192]; // 64K
// Corresponding drum patches as matched to keyboard
-Bit8s DrumTable[42] = {
+int8 DrumTable[42] = {
0, 0, 10, 1, 11, 5, 4, 6, 4, 29, 3, 7, 3, 2, 8, 2, 9, -1, -1, 22,
-1, 12, -1, -1, -1, 18, 19, 13, 14, 15, 16, 17, 20, 21, 27, 24,
26, 25, 28, -1, 23, -1 };
// Pan-pot position of drums
-Bit16s drmPanTable[42] = {
+int16 drmPanTable[42] = {
64, 64, 72, 64, 48, 72, 24, 72, 24, 72, 48, 72, 48, 96, 72, 96, 48, 1, 1, 40,
1, 64, 1, 1, 1, 104, 88, 48, 40, 32, 64, 80, 104 , 104, 40, 88,
40, 40, 32, 1, 16, 1 };
-Bit8u PartialStruct[13] = {
+uint8 PartialStruct[13] = {
0, 0, 2, 2, 1, 3,
3, 0, 3, 0, 2, 1, 3 };
-Bit8u PartMixStruct[13] = {
+uint8 PartMixStruct[13] = {
0, 1, 0, 1, 1, 0,
1, 3, 3, 2, 2, 2, 2 };
-Bit8u InitInstr[8] = {
+uint8 InitInstr[8] = {
68, 48, 95, 78, 41, 3, 110, 122};
-Bit8s LoopPatterns[16][16] = {
+int8 LoopPatterns[16][16] = {
{ 2,3,4,5,6,7,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 },
{ 8,9,10,11,12,13,14,15,16,-1,-1,-1,-1,-1,-1,-1 },
{ 17,18,19,20,21,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 },
@@ -1207,7 +1207,7 @@
};
-Bit32s LoopPatternTuning[16][16] = {
+int32 LoopPatternTuning[16][16] = {
{ 0x1294A,0x1294A,0x1294A,0x1294A,0x1294A,0x1294A,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 },
{ 0x1294A,0x1294A,0x1294A,0x1294A,0x1294A,0x1294A,0x1294A,0x1294A, 0x1294A,-1,-1,-1,-1,-1,-1,-1 },
{ 0x1294A,0x1294A,0x1294A,0x1294A,0x1294A,0x1294A,0x1294A,0x1294A, 0x1294A,-1,-1,-1,-1,-1,-1,-1 },
@@ -1229,7 +1229,7 @@
// These are division constants for the TVF depth key follow
-Bit32u depexp[5] = {3000,950,485,255,138};
+uint32 depexp[5] = {3000,950,485,255,138};
//Amplitude time velocity follow exponential coefficients
double tvcatconst[5] = {0.0, 0.002791309, 0.005942882, 0.012652792, 0.026938637};
@@ -1250,18 +1250,18 @@
revmodel *newReverb;
bool usingSIMD;
-Bit16s mastervolume;
+int16 mastervolume;
-Bit32u curRevMode;
-Bit32u curRevTime;
-Bit32u curRevLevel;
+uint32 curRevMode;
+uint32 curRevTime;
+uint32 curRevLevel;
-Bit32u partialsPlayed; // Variable containing the whole count of partials played
-Bit32u avgPartials; // Tally of average number of partials a second
-Bit32s partialChan[9]; // The count of partials played per channel
+uint32 partialsPlayed; // Variable containing the whole count of partials played
+uint32 avgPartials; // Tally of average number of partials a second
+int32 partialChan[9]; // The count of partials played per channel
#if SAVECUSTOM == 1
-Bit32u filenum = 0;
+uint32 filenum = 0;
#endif
/*
@@ -1280,7 +1280,7 @@
-void InitReverb(Bit32u newRevMode, Bit32u newRevTime, Bit32u sampRate) {
+void InitReverb(uint32 newRevMode, uint32 newRevTime, uint32 sampRate) {
if(newReverb != NULL) delete newReverb;
newReverb = new revmodel();
@@ -1352,8 +1352,8 @@
patchCache pcache[4];
- Bit32u bend;
- Bit32s volume;
+ uint32 bend;
+ int32 volume;
dpoly polyTable[MAXPOLY];
@@ -1378,8 +1378,8 @@
bool sustain;
bool init;
- Bit32u P1Mix;
- Bit32u P2Mix;
+ uint32 P1Mix;
+ uint32 P2Mix;
bool holdpedal;
@@ -1406,11 +1406,11 @@
int FixKeyfollow(int srckey, int *dir);
int FixBiaslevel(int srcpnt, int *dir);
- //Bit32s getPitchEnvelope(dpoly::partialStatus *pStat, dpoly *poly, bool inDecay);
- //Bit32s getAmpEnvelope(dpoly::partialStatus *pStat, dpoly *poly, bool inDecay);
- //Bit32s getFiltEnvelope(Bit16s wg, dpoly::partialStatus *pStat, dpoly *poly, bool inDecay);
+ //int32 getPitchEnvelope(dpoly::partialStatus *pStat, dpoly *poly, bool inDecay);
+ //int32 getAmpEnvelope(dpoly::partialStatus *pStat, dpoly *poly, bool inDecay);
+ //int32 getFiltEnvelope(int16 wg, dpoly::partialStatus *pStat, dpoly *poly, bool inDecay);
- //void StartDecay(int envnum, Bit32s startval, dpoly::partialStatus *pStat, dpoly *poly);
+ //void StartDecay(int envnum, int32 startval, dpoly::partialStatus *pStat, dpoly *poly);
};
@@ -1441,7 +1441,7 @@
}
-INLINE void StartDecay(int envnum, Bit32s startval, dpoly::partialStatus *pStat, dpoly *poly) {
+INLINE void StartDecay(int envnum, int32 startval, dpoly::partialStatus *pStat, dpoly *poly) {
patchCache *tcache = pStat->tcache;
dpoly::partialStatus::envstatus *tStat = &pStat->envs[envnum];
@@ -1476,8 +1476,8 @@
-INLINE Bit32s getAmpEnvelope(dpoly::partialStatus *pStat, dpoly *poly) {
- Bit32s tc;
+INLINE int32 getAmpEnvelope(dpoly::partialStatus *pStat, dpoly *poly) {
+ int32 tc;
patchCache *tcache = pStat->tcache;
dpoly::partialStatus::envstatus *tStat = &pStat->envs[AMPENV];
@@ -1563,7 +1563,7 @@
PastCalc:
- tc = (tc * (Bit32s)tcache->amplevel) >> 7;
+ tc = (tc * (int32)tcache->amplevel) >> 7;
}
@@ -1619,11 +1619,11 @@
}
-INLINE Bit32s getPitchEnvelope(dpoly::partialStatus *pStat, dpoly *poly) {
+INLINE int32 getPitchEnvelope(dpoly::partialStatus *pStat, dpoly *poly) {
patchCache *tcache = pStat->tcache;
dpoly::partialStatus::envstatus *tStat = &pStat->envs[PITCHENV];
- Bit32s tc;
+ int32 tc;
pStat->pitchsustain = false;
if(tStat->decaying) {
@@ -1671,12 +1671,12 @@
}
-INLINE Bit32s getFiltEnvelope(Bit16s wg, dpoly::partialStatus *pStat, dpoly *poly) {
+INLINE int32 getFiltEnvelope(int16 wg, dpoly::partialStatus *pStat, dpoly *poly) {
int reshigh;
//float *hist = pStat->history;
- //__int64 *hist = pStat->history;
+ //int64 *hist = pStat->history;
//long *hist = pStat->history;
int filt,cutoff,depth,keyfollow, realfollow;
@@ -1767,7 +1767,7 @@
reshigh = (reshigh * depth) >> 7;
- Bit32s tmp;
+ int32 tmp;
cutoff *= keyfollow;
cutoff /= realfollow;
@@ -1980,9 +1980,9 @@
// Calculate and cache pitch stuff
pcache[t].pitchshift = (timSrc.partial[t].wg.coarse+mt32ram.params.pSettings[patchnum].keyShift);
- Bit32s pFine, tFine, fShift;
- pFine = (Bit32s)timSrc.partial[t].wg.fine;
- tFine = (Bit32s)mt32ram.params.pSettings[patchnum].fineTune;
+ int32 pFine, tFine, fShift;
+ pFine = (int32)timSrc.partial[t].wg.fine;
+ tFine = (int32)mt32ram.params.pSettings[patchnum].fineTune;
fShift = ((pFine - 50) + (tFine - 50)) + 100;
pcache[t].fineshift = finetable[fShift];
@@ -2067,16 +2067,16 @@
//LOG(LOG_ERROR|LOG_MISC,"Pan %d",panpot);
}
-INLINE Bit16s RingMod(Bit16s p1, Bit16s p2, bool useFirst) {
+INLINE int16 RingMod(int16 p1, int16 p2, bool useFirst) {
if(useFirst) {
- //return (Bit16s)( ( ((float)p1/32767.0) * ((float)p2/32767.0) ) * 32767);
- return (Bit16s)( ((Bit32s)p1 * (Bit32s)p2) >> 15);
+ //return (int16)( ( ((float)p1/32767.0) * ((float)p2/32767.0) ) * 32767);
+ return (int16)( ((int32)p1 * (int32)p2) >> 15);
} else {
// An interesting undocumented feature of the MT-32
// Putting ring mod on a muted partial introduces noise to the ring modulator
// Dune 2 makes use of this
- return (Bit16s)( ((Bit32s)smallnoise[samplepos/100] * (Bit32s)p2) >> 15);
+ return (int16)( ((int32)smallnoise[samplepos/100] * (int32)p2) >> 15);
}
}
@@ -2522,7 +2522,7 @@
}*/
// Then kill those with the lowest channel priority --- oldest at the moment
bool found;
- Bit64s prior, priornum;
+ int64 prior, priornum;
dpoly *killPoly;
found = true;
while(found) {
@@ -2562,7 +2562,7 @@
// Kill off the oldest partials within this channel
- Bit64s oldest, oldlist;
+ int64 oldest, oldlist;
while(needed>0) {
oldest = -1;
@@ -2945,7 +2945,7 @@
square=0;
saw = 0;
bool odd = true;
- for(Bit32s sinus=1;(sinus*freq)<(SETRATE);sinus++) {
+ for(int32 sinus=1;(sinus*freq)<(SETRATE);sinus++) {
float sinusval = (((1.0/((float)sinus))*(sin(((float)sinus)*sa))));
saw=saw + sinusval;
}
@@ -2977,7 +2977,7 @@
waveformsize[3][f] = fa*4;
for (int i = 0; i < 4; ++i) {
- waveforms[i][f] = (Bit16s *)malloc(waveformsize[i][f]);
+ waveforms[i][f] = (int16 *)malloc(waveformsize[i][f]);
memcpy(waveforms[i][f], &tmpforms[i][0],waveformsize[i][f]);
// TODO / FIXME: The following code is not endian safe!
out = fp.write(waveforms[i][f],waveformsize[i][f]);
@@ -2987,7 +2987,7 @@
waveformsize[3][f] = divtable[f]>>12;
for (int i = 0; i < 4; ++i) {
- waveforms[i][f] = (Bit16s *)malloc(waveformsize[i][f]);
+ waveforms[i][f] = (int16 *)malloc(waveformsize[i][f]);
for (uint j = 0; j < waveformsize[i][f]/2; ++j)
waveforms[i][f][j] = fp.readSint16LE();
}
@@ -3086,7 +3086,7 @@
// 64-bit variant
#if FILTER_64BIT == 1
for(int co=0;co<9;co++) {
- filtcoefffix[j][res][co] = (__int64)(filtcoeff[j][res][co] * pow(2,20));
+ filtcoefffix[j][res][co] = (int64)(filtcoeff[j][res][co] * pow(2,20));
}
#endif
@@ -3136,7 +3136,7 @@
float fldep = fabs((float)dep) / 7.0;
fldep = pow((float)fldep,(float)2.5);
if(dep<0) fldep = fldep * -1.0;
- pwveltable[dep+7][velt] = Bit32s((fldep * (float)velt * 100) / 128.0);
+ pwveltable[dep+7][velt] = int32((fldep * (float)velt * 100) / 128.0);
}
}
@@ -3238,7 +3238,7 @@
int myRand;
myRand = rand();
myRand = ((myRand - 16383) * WGAMP) >> 18;
- smallnoise[lf] = (Bit16s)myRand;
+ smallnoise[lf] = (int16)myRand;
}
for(lf=0;lf<=100;lf++) {
@@ -3284,7 +3284,7 @@
/*
// I am certain of this: Verified by hand LFO log */
- lfotable[lf] = (Bit32s)(((float)SETRATE) / (pow((float)1.088883372,(float)lf) * 0.021236044));
+ lfotable[lf] = (int32)(((float)SETRATE) / (pow((float)1.088883372,(float)lf) * 0.021236044));
//LOG_MSG("lf %d = lfo %d pulsetable %d", lf, lfotable[lf], pulsetable[lf]);
}
@@ -3392,7 +3392,7 @@
// Benchmark 3DNow, Floating point, and SSE filters
/*
- Bit32u bench;
+ uint32 bench;
__time64_t start, end;
float histval[50];
@@ -3481,11 +3481,11 @@
dumbfire = sa /2 ;
//This works pretty good
- tmpforms[2][fa>>4] += (Bit16s)(cos(dumbfire) * -ampsize);
- tmpforms[3][fa>>3] += (Bit16s)(cos(sa-PI) * -ampsize);
+ tmpforms[2][fa>>4] += (int16)(cos(dumbfire) * -ampsize);
+ tmpforms[3][fa>>3] += (int16)(cos(sa-PI) * -ampsize);
- tmpforms[0][fa>>4] += (Bit16s)(saw * -ampsize);
- tmpforms[1][fa>>4] += (Bit16s)(saw * ampsize);
+ tmpforms[0][fa>>4] += (int16)(saw * -ampsize);
+ tmpforms[1][fa>>4] += (int16)(saw * ampsize);
fa++;
sa+=sd;
@@ -3526,13 +3526,13 @@
if (isOpen) return false;
int i;
// Initalize patch information
- Bit8u sysexBuf[SYSEX_SIZE];
- Bit16u syslen = 0;
+ uint8 sysexBuf[SYSEX_SIZE];
+ uint16 syslen = 0;
bool inSys = false;
File fp;
- Bit8u c;
+ uint8 c;
myProp = useProp;
@@ -3692,10 +3692,10 @@
char tbuf[512];
char *cp;
fPatch.gets(tbuf,sizeof(tbuf));
- Bit32u patchstart = 0; //axtoi(tbuf);
- Bit32u patchend = 0;
- Bit32u patchcount = 0;
- //Bit16s *romaddr = &romfile[0];
+ uint32 patchstart = 0; //axtoi(tbuf);
+ uint32 patchend = 0;
+ uint32 patchcount = 0;
+ //int16 *romaddr = &romfile[0];
while (!fPatch.eof()) {
fPatch.gets(tbuf,sizeof(tbuf));
cp = strtok(tbuf," \n\r");
@@ -3836,9 +3836,9 @@
//exit(0);
}
i=0;
- //Bit32s maxamp = 0;
+ //int32 maxamp = 0;
while (!fIn.eof()) {
- Bit16s s, c1;
+ int16 s, c1;
s = fIn.readByte();
c1 = fIn.readByte();
@@ -3865,7 +3865,7 @@
}
//if( (e & 0x1) != 0) printf("Last bit = %d\n", e & 0x1);
- //Bit16s e = ( ((s & 0x7f) << 4) | ((c1 & 0x40) << 6) | ((s & 0x80) << 6) | ((c1 & 0x3f))) << 2;
+ //int16 e = ( ((s & 0x7f) << 4) | ((c1 & 0x40) << 6) | ((s & 0x80) << 6) | ((c1 & 0x3f))) << 2;
if(e<0) e = -32767 - e;
int ut = abs(e);
int dif = 0x7fff - ut;
@@ -3911,11 +3911,11 @@
if (e>0) vol = -vol;
- romfile[i] = (Bit16s)vol;
+ romfile[i] = (int16)vol;
#ifdef MT32OUT
- tmpc = (Bit16s)vol & 0xff; fOutb.write(&tmpc, 1);
- tmpc = (Bit16s)vol >> 8; fOutb.write(&tmpc, 1);
+ tmpc = (int16)vol & 0xff; fOutb.write(&tmpc, 1);
+ tmpc = (int16)vol >> 8; fOutb.write(&tmpc, 1);
#endif
i++;
@@ -4005,7 +4005,7 @@
}
-void CSynthMT32::PlayMsg(Bit32u msg) {
+void CSynthMT32::PlayMsg(uint32 msg) {
#ifdef NOMANSLAND
@@ -4038,7 +4038,7 @@
int patch;
- Bit32u bend;
+ uint32 bend;
//LOG_MSG("Midi code: 0x%x",msg);
switch (code) {
@@ -4125,23 +4125,23 @@
//midiOutShortMsg(m_out, msg);
}
-void CSynthMT32::PlaySysex(Bit8u * sysex,Bit32u len) {
+void CSynthMT32::PlaySysex(uint8 * sysex,uint32 len) {
#ifdef NOMANSLAND
- Bit32u addr;
- Bit32u *header;
+ uint32 addr;
+ uint32 *header;
unsigned int off;
int m;
- header = (Bit32u *)(sysex+1);
+ header = (uint32 *)(sysex+1);
//int dummy = 0;
- Bit32s lens = len;
+ int32 lens = len;
// For some reason commands in IMuseInternal::initMT32 do not have prefix byte
if(READ_LE_UINT32(header) != 0x12161041) {
if(READ_LE_UINT32(sysex) == 0x12161041) {
- header = (Bit32u *)sysex;
+ header = (uint32 *)sysex;
sysex--; // We don't access sysex[0], so it's safe
}
}
@@ -4250,7 +4250,7 @@
//LOG_MSG("Reverb time: %d", mt32ram.params.system.reverbTime);
//LOG_MSG("Reverb level: %d", mt32ram.params.system.reverbLevel);
- if(((Bit32u)mt32ram.params.system.reverbMode != curRevMode) || ((Bit32u)mt32ram.params.system.reverbTime!=curRevTime)) {
+ if(((uint32)mt32ram.params.system.reverbMode != curRevMode) || ((uint32)mt32ram.params.system.reverbTime!=curRevTime)) {
if(myProp.UseDefault) {
InitReverb(mt32ram.params.system.reverbMode, mt32ram.params.system.reverbTime,SETRATE);
curRevLevel = mt32ram.params.system.reverbLevel;
@@ -4275,7 +4275,7 @@
rset = mt32ram.params.system.chanAssign;
//LOG_MSG("Chan assign: 1=%d 2=%d 3=%d 4=%d 5=%d 6=%d 7=%d 8=%d 9=%d", rset[0], rset[1], rset[2], rset[3], rset[4], rset[5], rset[6], rset[7], rset[8]);
//LOG_MSG("Master volume: %d",mt32ram.params.system.masterVol);
- Bit16s tv = (Bit16s)((float)mt32ram.params.system.masterVol * 327.0);
+ int16 tv = (int16)((float)mt32ram.params.system.masterVol * 327.0);
mastervolume = tv;
}
@@ -4288,7 +4288,7 @@
}
if ((addr & 0xff0000) == 0x7f0000) {
//LOG_MSG("MT-32 Reset");
- for (Bit32u m1=0;m1<MAXPARTIALS;m1++) partTable[m1]->isActive = false;
+ for (uint32 m1=0;m1<MAXPARTIALS;m1++) partTable[m1]->isActive = false;
memcpy(&mt32ram, &mt32default, sizeof(mt32ram));
isEnabled = false;
@@ -4356,7 +4356,7 @@
-static Bit16s tmpBuffer[4096];
+static int16 tmpBuffer[4096];
static float sndbufl[4096];
static float sndbufr[4096];
static float outbufl[4096];
@@ -4366,13 +4366,13 @@
static float multFactor[4] = { 32767.0, 32767.0, 32767.0, 32767.0 };
#endif
-void CSynthMT32::MT32_CallBack(Bit8u * stream,Bit32u len, int volume) {
+void CSynthMT32::MT32_CallBack(uint8 * stream,uint32 len, int volume) {
#ifdef NOMANSLAND
- Bit32s i,m;
- Bit16s *snd, *useBuf;
- Bit32u outlen;
- snd = (Bit16s *)stream;
+ int32 i,m;
+ int16 *snd, *useBuf;
+ uint32 outlen;
+ snd = (int16 *)stream;
memset(stream,0,len*4);
if(!isEnabled) return;
useBuf = snd;
@@ -4399,12 +4399,12 @@
if(partTable[i]->produceOutput(tmpBuffer,outlen)==true) {
#if USE_MMX == 0
- Bit16s *tmpoff = snd;
+ int16 *tmpoff = snd;
int q = 0;
- for(m=0;m<(Bit32s)outlen;m++) {
- tmpoff[q] += (Bit16s)(((Bit32s)tmpBuffer[q] * (Bit32s)mastervolume)>>15);
+ for(m=0;m<(int32)outlen;m++) {
+ tmpoff[q] += (int16)(((int32)tmpBuffer[q] * (int32)mastervolume)>>15);
q++;
- tmpoff[q] += (Bit16s)(((Bit32s)tmpBuffer[q] * (Bit32s)mastervolume)>>15);
+ tmpoff[q] += (int16)(((int32)tmpBuffer[q] * (int32)mastervolume)>>15);
q++;
}
@@ -4449,7 +4449,7 @@
if(!usingSIMD) {
#endif
m=0;
- for(i=0;i<(Bit32s)len;i++) {
+ for(i=0;i<(int32)len;i++) {
sndbufl[i] = (float)snd[m] / 32767.0;
m++;
sndbufr[i] = (float)snd[m] / 32767.0;
@@ -4457,10 +4457,10 @@
}
newReverb->processreplace(sndbufl, sndbufr, outbufl, outbufr, len, 1);
m=0;
- for(i=0;i<(Bit32s)len;i++) {
- snd[m] = (Bit16s)(outbufl[i] * 32767.0);
+ for(i=0;i<(int32)len;i++) {
+ snd[m] = (int16)(outbufl[i] * 32767.0);
m++;
- snd[m] = (Bit16s)(outbufr[i] * 32767.0);
+ snd[m] = (int16)(outbufr[i] * 32767.0);
m++;
}
#if USE_MMX == 3
Index: synth.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/backends/midi/mt32/synth.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- synth.h 21 Oct 2004 22:37:30 -0000 1.1
+++ synth.h 22 Oct 2004 15:39:28 -0000 1.2
@@ -103,32 +103,32 @@
extern iir_filter_type usefilter;
extern partialFormat PCM[54];
-extern Bit16s romfile[262656];
-extern Bit32s divtable[256];
-extern Bit32s smalldivtable[256];
-extern Bit32u wavtabler[64][256];
-extern Bit32u looptabler[16][16][256];
-extern Bit16s sintable[65536];
-extern Bit32s penvtable[16][128];
-extern Bit32s pulsetable[101];
-extern Bit32s pulseoffset[101];
-extern Bit32s sawtable[128][128];
+extern int16 romfile[262656];
+extern int32 divtable[256];
+extern int32 smalldivtable[256];
+extern uint32 wavtabler[64][256];
+extern uint32 looptabler[16][16][256];
+extern int16 sintable[65536];
+extern int32 penvtable[16][128];
+extern int32 pulsetable[101];
+extern int32 pulseoffset[101];
+extern int32 sawtable[128][128];
extern float filtcoeff[FILTERGRAN][32][16];
-extern Bit32u lfoptable[101][128];
-extern Bit32s ampveltable[128][64];
-extern Bit32s amptable[129];
-extern Bit16s smallnoise[441];
-extern Bit32s samplepos;
-extern Bit16s* waveforms[4][256];
-extern Bit32u waveformsize[4][256];
-extern Bit8s LoopPatterns[16][16];
+extern uint32 lfoptable[101][128];
+extern int32 ampveltable[128][64];
+extern int32 amptable[129];
+extern int16 smallnoise[441];
+extern int32 samplepos;
+extern int16* waveforms[4][256];
+extern uint32 waveformsize[4][256];
+extern int8 LoopPatterns[16][16];
extern int drumPan[30][2];
extern float ResonFactor[32];
extern float ResonInv[32];
-extern Bit32s getPitchEnvelope(dpoly::partialStatus *pStat, dpoly *poly);
-extern Bit32s getAmpEnvelope(dpoly::partialStatus *pStat, dpoly *poly);
-extern Bit32s getFiltEnvelope(Bit16s wg, dpoly::partialStatus *pStat, dpoly *poly);
+extern int32 getPitchEnvelope(dpoly::partialStatus *pStat, dpoly *poly);
+extern int32 getAmpEnvelope(dpoly::partialStatus *pStat, dpoly *poly);
+extern int32 getFiltEnvelope(int16 wg, dpoly::partialStatus *pStat, dpoly *poly);
class CSynthMT32 {
private:
@@ -152,10 +152,10 @@
void Close(void);
// Sends a 4-byte MIDI message to the MT-32 for immediate playback
- void PlayMsg(Bit32u msg);
+ void PlayMsg(uint32 msg);
// Sends a string of Sysex commands to the MT-32 for immediate interpretation
- void PlaySysex(Bit8u * sysex, Bit32u len);
+ void PlaySysex(uint8 * sysex, uint32 len);
// Save the system state to a sysex file specified by filename
int DumpSysex(char *filename);
@@ -163,7 +163,7 @@
// This callback routine is used to have the MT-32 generate samples to the specified
// output stream. The length is in whole samples, not bytes. (I.E. in 16-bit stereo,
// one sample is 4 bytes)
- void MT32_CallBack(Bit8u * stream, Bit32u len, int volume);
+ void MT32_CallBack(uint8 * stream, uint32 len, int volume);
};
More information about the Scummvm-git-logs
mailing list