--- /dev/null
+/* MikMod sound library\r
+ (c) 1998, 1999, 2000 Miodrag Vallat and others - see file AUTHORS for\r
+ complete list.\r
+\r
+ This library is free software; you can redistribute it and/or modify\r
+ it under the terms of the GNU Library General Public License as\r
+ published by the Free Software Foundation; either version 2 of\r
+ the License, or (at your option) any later version.\r
+ \r
+ This program is distributed in the hope that it will be useful,\r
+ but WITHOUT ANY WARRANTY; without even the implied warranty of\r
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
+ GNU Library General Public License for more details.\r
+ \r
+ You should have received a copy of the GNU Library General Public\r
+ License along with this library; if not, write to the Free Software\r
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA\r
+ 02111-1307, USA.\r
+*/\r
+\r
+/*==============================================================================\r
+\r
+ $Id: virtch2.c,v 1.2 2004/02/13 13:31:54 raph Exp $\r
+\r
+ High-quality sample mixing routines, using a 32 bits mixing buffer,\r
+ interpolation, and sample smoothing to improve sound quality and remove\r
+ clicks.\r
+\r
+==============================================================================*/\r
+\r
+/*\r
+\r
+ Future Additions:\r
+ Low-Pass filter to remove annoying staticy buzz.\r
+\r
+*/\r
+\r
+#ifdef HAVE_CONFIG_H\r
+#include "config.h"\r
+#endif\r
+\r
+#ifdef HAVE_MEMORY_H\r
+#include <memory.h>\r
+#endif\r
+#include <string.h>\r
+\r
+#include "mikmod_internals.h"\r
+ \r
+/*\r
+ Constant Definitions\r
+ ====================\r
+\r
+ MAXVOL_FACTOR (was BITSHIFT in virtch.c)\r
+ Controls the maximum volume of the output data. All mixed data is\r
+ divided by this number after mixing, so larger numbers result in\r
+ quieter mixing. Smaller numbers will increase the likeliness of\r
+ distortion on loud modules.\r
+\r
+ REVERBERATION\r
+ Larger numbers result in shorter reverb duration. Longer reverb\r
+ durations can cause unwanted static and make the reverb sound more\r
+ like a crappy echo.\r
+\r
+ SAMPLING_SHIFT\r
+ Specified the shift multiplier which controls by how much the mixing\r
+ rate is multiplied while mixing. Higher values can improve quality by\r
+ smoothing the sound and reducing pops and clicks. Note, this is a shift\r
+ value, so a value of 2 becomes a mixing-rate multiplier of 4, and a\r
+ value of 3 = 8, etc.\r
+\r
+ FRACBITS\r
+ The number of bits per integer devoted to the fractional part of the\r
+ number. Generally, this number should not be changed for any reason.\r
+\r
+ !!! IMPORTANT !!! All values below MUST ALWAYS be greater than 0\r
+\r
+*/\r
+\r
+#define MAXVOL_FACTOR (1<<9)\r
+#define REVERBERATION 11000L\r
+\r
+#define SAMPLING_SHIFT 2\r
+#define SAMPLING_FACTOR (1UL<<SAMPLING_SHIFT)\r
+\r
+#define FRACBITS 28\r
+#define FRACMASK ((1UL<<FRACBITS)-1UL)\r
+\r
+#define TICKLSIZE 8192\r
+#define TICKWSIZE (TICKLSIZE * 2)\r
+#define TICKBSIZE (TICKWSIZE * 2)\r
+\r
+#define CLICK_SHIFT_BASE 6\r
+#define CLICK_SHIFT (CLICK_SHIFT_BASE + SAMPLING_SHIFT)\r
+#define CLICK_BUFFER (1L << CLICK_SHIFT)\r
+\r
+#ifndef MIN\r
+#define MIN(a,b) (((a)<(b)) ? (a) : (b))\r
+#endif\r
+\r
+typedef struct VINFO {\r
+ UBYTE kick; /* =1 -> sample has to be restarted */\r
+ UBYTE active; /* =1 -> sample is playing */\r
+ UWORD flags; /* 16/8 bits looping/one-shot */\r
+ SWORD handle; /* identifies the sample */\r
+ ULONG start; /* start index */\r
+ ULONG size; /* samplesize */\r
+ ULONG reppos; /* loop start */\r
+ ULONG repend; /* loop end */\r
+ ULONG frq; /* current frequency */\r
+ int vol; /* current volume */\r
+ int pan; /* current panning position */\r
+\r
+ int click;\r
+ int rampvol;\r
+ SLONG lastvalL,lastvalR;\r
+ int lvolsel,rvolsel; /* Volume factor in range 0-255 */\r
+ int oldlvol,oldrvol;\r
+\r
+ SLONGLONG current; /* current index in the sample */\r
+ SLONGLONG increment; /* increment value */\r
+} VINFO;\r
+\r
+static SWORD **Samples;\r
+static VINFO *vinf=NULL,*vnf;\r
+static long tickleft,samplesthatfit,vc_memory=0;\r
+static int vc_softchn;\r
+static SLONGLONG idxsize,idxlpos,idxlend;\r
+static SLONG *vc_tickbuf=NULL;\r
+static UWORD vc_mode;\r
+\r
+/* Reverb control variables */\r
+\r
+static int RVc1, RVc2, RVc3, RVc4, RVc5, RVc6, RVc7, RVc8;\r
+static ULONG RVRindex;\r
+\r
+/* For Mono or Left Channel */\r
+static SLONG *RVbufL1=NULL,*RVbufL2=NULL,*RVbufL3=NULL,*RVbufL4=NULL,\r
+ *RVbufL5=NULL,*RVbufL6=NULL,*RVbufL7=NULL,*RVbufL8=NULL;\r
+\r
+/* For Stereo only (Right Channel) */\r
+static SLONG *RVbufR1=NULL,*RVbufR2=NULL,*RVbufR3=NULL,*RVbufR4=NULL,\r
+ *RVbufR5=NULL,*RVbufR6=NULL,*RVbufR7=NULL,*RVbufR8=NULL;\r
+\r
+#ifdef NATIVE_64BIT_INT\r
+#define NATIVE SLONGLONG\r
+#else\r
+#define NATIVE SLONG\r
+#endif\r
+\r
+/*========== 32 bit sample mixers - only for 32 bit platforms */\r
+#ifndef NATIVE_64BIT_INT\r
+\r
+static SLONG Mix32MonoNormal(SWORD* srce,SLONG* dest,SLONG index,SLONG increment,SLONG todo)\r
+{\r
+ SWORD sample=0;\r
+ SLONG i,f;\r
+\r
+ while(todo--) {\r
+ i=index>>FRACBITS,f=index&FRACMASK;\r
+ sample=(((SLONG)(srce[i]*(FRACMASK+1L-f)) +\r
+ ((SLONG)srce[i+1]*f)) >> FRACBITS);\r
+ index+=increment;\r
+\r
+ if(vnf->rampvol) {\r
+ *dest++ += (long)(\r
+ ( ( (SLONG)(vnf->oldlvol*vnf->rampvol) +\r
+ (vnf->lvolsel*(CLICK_BUFFER-vnf->rampvol)) ) *\r
+ (SLONG)sample ) >> CLICK_SHIFT );\r
+ vnf->rampvol--;\r
+ } else\r
+ if(vnf->click) {\r
+ *dest++ += (long)(\r
+ ( ( ((SLONG)vnf->lvolsel*(CLICK_BUFFER-vnf->click)) *\r
+ (SLONG)sample ) +\r
+ (vnf->lastvalL*vnf->click) ) >> CLICK_SHIFT );\r
+ vnf->click--;\r
+ } else\r
+ *dest++ +=vnf->lvolsel*sample;\r
+ }\r
+ vnf->lastvalL=vnf->lvolsel * sample;\r
+\r
+ return index;\r
+}\r
+\r
+static SLONG Mix32StereoNormal(SWORD* srce,SLONG* dest,SLONG index,SLONG increment,ULONG todo)\r
+{\r
+ SWORD sample=0;\r
+ SLONG i,f;\r
+\r
+ while(todo--) {\r
+ i=index>>FRACBITS,f=index&FRACMASK;\r
+ sample=((((SLONG)srce[i]*(FRACMASK+1L-f)) +\r
+ ((SLONG)srce[i+1] * f)) >> FRACBITS);\r
+ index += increment;\r
+\r
+ if(vnf->rampvol) {\r
+ *dest++ += (long)(\r
+ ( ( ((SLONG)vnf->oldlvol*vnf->rampvol) +\r
+ (vnf->lvolsel*(CLICK_BUFFER-vnf->rampvol))\r
+ ) * (SLONG)sample ) >> CLICK_SHIFT );\r
+ *dest++ += (long)(\r
+ ( ( ((SLONG)vnf->oldrvol*vnf->rampvol) +\r
+ (vnf->rvolsel*(CLICK_BUFFER-vnf->rampvol))\r
+ ) * (SLONG)sample ) >> CLICK_SHIFT );\r
+ vnf->rampvol--;\r
+ } else\r
+ if(vnf->click) {\r
+ *dest++ += (long)(\r
+ ( ( (SLONG)(vnf->lvolsel*(CLICK_BUFFER-vnf->click)) *\r
+ (SLONG)sample ) + (vnf->lastvalL * vnf->click) )\r
+ >> CLICK_SHIFT );\r
+ *dest++ += (long)(\r
+ ( ( ((SLONG)vnf->rvolsel*(CLICK_BUFFER-vnf->click)) *\r
+ (SLONG)sample ) + (vnf->lastvalR * vnf->click) )\r
+ >> CLICK_SHIFT );\r
+ vnf->click--;\r
+ } else {\r
+ *dest++ +=vnf->lvolsel*sample;\r
+ *dest++ +=vnf->rvolsel*sample;\r
+ }\r
+ }\r
+ vnf->lastvalL=vnf->lvolsel*sample;\r
+ vnf->lastvalR=vnf->rvolsel*sample;\r
+\r
+ return index;\r
+}\r
+\r
+static SLONG Mix32StereoSurround(SWORD* srce,SLONG* dest,SLONG index,SLONG increment,ULONG todo)\r
+{\r
+ SWORD sample=0;\r
+ long whoop;\r
+ SLONG i, f;\r
+\r
+ while(todo--) {\r
+ i=index>>FRACBITS,f=index&FRACMASK;\r
+ sample=((((SLONG)srce[i]*(FRACMASK+1L-f)) +\r
+ ((SLONG)srce[i+1]*f)) >> FRACBITS);\r
+ index+=increment;\r
+\r
+ if(vnf->rampvol) {\r
+ whoop=(long)(\r
+ ( ( (SLONG)(vnf->oldlvol*vnf->rampvol) +\r
+ (vnf->lvolsel*(CLICK_BUFFER-vnf->rampvol)) ) *\r
+ (SLONG)sample) >> CLICK_SHIFT );\r
+ *dest++ +=whoop;\r
+ *dest++ -=whoop;\r
+ vnf->rampvol--;\r
+ } else\r
+ if(vnf->click) {\r
+ whoop = (long)(\r
+ ( ( ((SLONG)vnf->lvolsel*(CLICK_BUFFER-vnf->click)) *\r
+ (SLONG)sample) +\r
+ (vnf->lastvalL * vnf->click) ) >> CLICK_SHIFT );\r
+ *dest++ +=whoop;\r
+ *dest++ -=whoop;\r
+ vnf->click--;\r
+ } else {\r
+ *dest++ +=vnf->lvolsel*sample;\r
+ *dest++ -=vnf->lvolsel*sample;\r
+ }\r
+ }\r
+ vnf->lastvalL=vnf->lvolsel*sample;\r
+ vnf->lastvalR=vnf->lvolsel*sample;\r
+\r
+ return index;\r
+}\r
+#endif\r
+\r
+/*========== 64 bit mixers */\r
+\r
+static SLONGLONG MixMonoNormal(SWORD* srce,SLONG* dest,SLONGLONG index,SLONGLONG increment,SLONG todo)\r
+{\r
+ SWORD sample=0;\r
+ SLONGLONG i,f;\r
+\r
+ while(todo--) {\r
+ i=index>>FRACBITS,f=index&FRACMASK;\r
+ sample=(((SLONGLONG)(srce[i]*(FRACMASK+1L-f)) +\r
+ ((SLONGLONG)srce[i+1]*f)) >> FRACBITS);\r
+ index+=increment;\r
+\r
+ if(vnf->rampvol) {\r
+ *dest++ += (long)(\r
+ ( ( (SLONGLONG)(vnf->oldlvol*vnf->rampvol) +\r
+ (vnf->lvolsel*(CLICK_BUFFER-vnf->rampvol)) ) *\r
+ (SLONGLONG)sample ) >> CLICK_SHIFT );\r
+ vnf->rampvol--;\r
+ } else\r
+ if(vnf->click) {\r
+ *dest++ += (long)(\r
+ ( ( ((SLONGLONG)vnf->lvolsel*(CLICK_BUFFER-vnf->click)) *\r
+ (SLONGLONG)sample ) +\r
+ (vnf->lastvalL*vnf->click) ) >> CLICK_SHIFT );\r
+ vnf->click--;\r
+ } else\r
+ *dest++ +=vnf->lvolsel*sample;\r
+ }\r
+ vnf->lastvalL=vnf->lvolsel * sample;\r
+\r
+ return index;\r
+}\r
+\r
+static SLONGLONG MixStereoNormal(SWORD* srce,SLONG* dest,SLONGLONG index,SLONGLONG increment,ULONG todo)\r
+{\r
+ SWORD sample=0;\r
+ SLONGLONG i,f;\r
+\r
+ while(todo--) {\r
+ i=index>>FRACBITS,f=index&FRACMASK;\r
+ sample=((((SLONGLONG)srce[i]*(FRACMASK+1L-f)) +\r
+ ((SLONGLONG)srce[i+1] * f)) >> FRACBITS);\r
+ index += increment;\r
+\r
+ if(vnf->rampvol) {\r
+ *dest++ += (long)(\r
+ ( ( ((SLONGLONG)vnf->oldlvol*vnf->rampvol) +\r
+ (vnf->lvolsel*(CLICK_BUFFER-vnf->rampvol))\r
+ ) * (SLONGLONG)sample ) >> CLICK_SHIFT );\r
+ *dest++ += (long)(\r
+ ( ( ((SLONGLONG)vnf->oldrvol*vnf->rampvol) +\r
+ (vnf->rvolsel*(CLICK_BUFFER-vnf->rampvol))\r
+ ) * (SLONGLONG)sample ) >> CLICK_SHIFT );\r
+ vnf->rampvol--;\r
+ } else\r
+ if(vnf->click) {\r
+ *dest++ += (long)(\r
+ ( ( (SLONGLONG)(vnf->lvolsel*(CLICK_BUFFER-vnf->click)) *\r
+ (SLONGLONG)sample ) + (vnf->lastvalL * vnf->click) )\r
+ >> CLICK_SHIFT );\r
+ *dest++ += (long)(\r
+ ( ( ((SLONGLONG)vnf->rvolsel*(CLICK_BUFFER-vnf->click)) *\r
+ (SLONGLONG)sample ) + (vnf->lastvalR * vnf->click) )\r
+ >> CLICK_SHIFT );\r
+ vnf->click--;\r
+ } else {\r
+ *dest++ +=vnf->lvolsel*sample;\r
+ *dest++ +=vnf->rvolsel*sample;\r
+ }\r
+ }\r
+ vnf->lastvalL=vnf->lvolsel*sample;\r
+ vnf->lastvalR=vnf->rvolsel*sample;\r
+\r
+ return index;\r
+}\r
+\r
+static SLONGLONG MixStereoSurround(SWORD* srce,SLONG* dest,SLONGLONG index,SLONGLONG increment,ULONG todo)\r
+{\r
+ SWORD sample=0;\r
+ long whoop;\r
+ SLONGLONG i, f;\r
+\r
+ while(todo--) {\r
+ i=index>>FRACBITS,f=index&FRACMASK;\r
+ sample=((((SLONGLONG)srce[i]*(FRACMASK+1L-f)) +\r
+ ((SLONGLONG)srce[i+1]*f)) >> FRACBITS);\r
+ index+=increment;\r
+\r
+ if(vnf->rampvol) {\r
+ whoop=(long)(\r
+ ( ( (SLONGLONG)(vnf->oldlvol*vnf->rampvol) +\r
+ (vnf->lvolsel*(CLICK_BUFFER-vnf->rampvol)) ) *\r
+ (SLONGLONG)sample) >> CLICK_SHIFT );\r
+ *dest++ +=whoop;\r
+ *dest++ -=whoop;\r
+ vnf->rampvol--;\r
+ } else\r
+ if(vnf->click) {\r
+ whoop = (long)(\r
+ ( ( ((SLONGLONG)vnf->lvolsel*(CLICK_BUFFER-vnf->click)) *\r
+ (SLONGLONG)sample) +\r
+ (vnf->lastvalL * vnf->click) ) >> CLICK_SHIFT );\r
+ *dest++ +=whoop;\r
+ *dest++ -=whoop;\r
+ vnf->click--;\r
+ } else {\r
+ *dest++ +=vnf->lvolsel*sample;\r
+ *dest++ -=vnf->lvolsel*sample;\r
+ }\r
+ }\r
+ vnf->lastvalL=vnf->lvolsel*sample;\r
+ vnf->lastvalR=vnf->lvolsel*sample;\r
+\r
+ return index;\r
+}\r
+\r
+static void(*Mix32toFP)(float* dste,SLONG* srce,NATIVE count);\r
+static void(*Mix32to16)(SWORD* dste,SLONG* srce,NATIVE count);\r
+static void(*Mix32to8)(SBYTE* dste,SLONG* srce,NATIVE count);\r
+static void(*MixReverb)(SLONG* srce,NATIVE count);\r
+\r
+/* Reverb macros */\r
+#define COMPUTE_LOC(n) loc##n = RVRindex % RVc##n\r
+#define COMPUTE_LECHO(n) RVbufL##n [loc##n ]=speedup+((ReverbPct*RVbufL##n [loc##n ])>>7)\r
+#define COMPUTE_RECHO(n) RVbufR##n [loc##n ]=speedup+((ReverbPct*RVbufR##n [loc##n ])>>7)\r
+\r
+static void MixReverb_Normal(SLONG* srce,NATIVE count)\r
+{\r
+ NATIVE speedup;\r
+ int ReverbPct;\r
+ unsigned int loc1,loc2,loc3,loc4,loc5,loc6,loc7,loc8;\r
+\r
+ ReverbPct=58+(md_reverb*4);\r
+\r
+ COMPUTE_LOC(1); COMPUTE_LOC(2); COMPUTE_LOC(3); COMPUTE_LOC(4);\r
+ COMPUTE_LOC(5); COMPUTE_LOC(6); COMPUTE_LOC(7); COMPUTE_LOC(8);\r
+\r
+ while(count--) {\r
+ /* Compute the left channel echo buffers */\r
+ speedup = *srce >> 3;\r
+\r
+ COMPUTE_LECHO(1); COMPUTE_LECHO(2); COMPUTE_LECHO(3); COMPUTE_LECHO(4);\r
+ COMPUTE_LECHO(5); COMPUTE_LECHO(6); COMPUTE_LECHO(7); COMPUTE_LECHO(8);\r
+\r
+ /* Prepare to compute actual finalized data */\r
+ RVRindex++;\r
+\r
+ COMPUTE_LOC(1); COMPUTE_LOC(2); COMPUTE_LOC(3); COMPUTE_LOC(4);\r
+ COMPUTE_LOC(5); COMPUTE_LOC(6); COMPUTE_LOC(7); COMPUTE_LOC(8);\r
+\r
+ /* left channel */\r
+ *srce++ +=RVbufL1[loc1]-RVbufL2[loc2]+RVbufL3[loc3]-RVbufL4[loc4]+\r
+ RVbufL5[loc5]-RVbufL6[loc6]+RVbufL7[loc7]-RVbufL8[loc8];\r
+ }\r
+}\r
+\r
+static void MixReverb_Stereo(SLONG *srce,NATIVE count)\r
+{\r
+ NATIVE speedup;\r
+ int ReverbPct;\r
+ unsigned int loc1,loc2,loc3,loc4,loc5,loc6,loc7,loc8;\r
+\r
+ ReverbPct=58+(md_reverb*4);\r
+\r
+ COMPUTE_LOC(1); COMPUTE_LOC(2); COMPUTE_LOC(3); COMPUTE_LOC(4);\r
+ COMPUTE_LOC(5); COMPUTE_LOC(6); COMPUTE_LOC(7); COMPUTE_LOC(8);\r
+\r
+ while(count--) {\r
+ /* Compute the left channel echo buffers */\r
+ speedup = *srce >> 3;\r
+\r
+ COMPUTE_LECHO(1); COMPUTE_LECHO(2); COMPUTE_LECHO(3); COMPUTE_LECHO(4);\r
+ COMPUTE_LECHO(5); COMPUTE_LECHO(6); COMPUTE_LECHO(7); COMPUTE_LECHO(8);\r
+\r
+ /* Compute the right channel echo buffers */\r
+ speedup = srce[1] >> 3;\r
+\r
+ COMPUTE_RECHO(1); COMPUTE_RECHO(2); COMPUTE_RECHO(3); COMPUTE_RECHO(4);\r
+ COMPUTE_RECHO(5); COMPUTE_RECHO(6); COMPUTE_RECHO(7); COMPUTE_RECHO(8);\r
+\r
+ /* Prepare to compute actual finalized data */\r
+ RVRindex++;\r
+\r
+ COMPUTE_LOC(1); COMPUTE_LOC(2); COMPUTE_LOC(3); COMPUTE_LOC(4);\r
+ COMPUTE_LOC(5); COMPUTE_LOC(6); COMPUTE_LOC(7); COMPUTE_LOC(8);\r
+\r
+ /* left channel */\r
+ *srce++ +=RVbufL1[loc1]-RVbufL2[loc2]+RVbufL3[loc3]-RVbufL4[loc4]+ \r
+ RVbufL5[loc5]-RVbufL6[loc6]+RVbufL7[loc7]-RVbufL8[loc8];\r
+\r
+ /* right channel */\r
+ *srce++ +=RVbufR1[loc1]-RVbufR2[loc2]+RVbufR3[loc3]-RVbufR4[loc4]+\r
+ RVbufR5[loc5]-RVbufR6[loc6]+RVbufR7[loc7]-RVbufR8[loc8];\r
+ }\r
+}\r
+\r
+/* Mixing macros */\r
+#define EXTRACT_SAMPLE_FP(var,attenuation) var=*srce++*((1.0f / 32768.0f) / (MAXVOL_FACTOR*attenuation))\r
+#define CHECK_SAMPLE_FP(var,bound) var=(var>bound)?bound:(var<-bound)?-bound:var\r
+\r
+static void Mix32ToFP_Normal(float* dste,SLONG* srce,NATIVE count)\r
+{\r
+ float x1,x2,tmpx;\r
+ int i;\r
+\r
+ for(count/=SAMPLING_FACTOR;count;count--) {\r
+ tmpx=0.0f;\r
+\r
+ for(i=SAMPLING_FACTOR/2;i;i--) {\r
+ EXTRACT_SAMPLE_FP(x1,1.0f); EXTRACT_SAMPLE_FP(x2,1.0f);\r
+\r
+ CHECK_SAMPLE_FP(x1,1.0f); CHECK_SAMPLE_FP(x2,1.0f);\r
+\r
+ tmpx+=x1+x2;\r
+ }\r
+ *dste++ =tmpx*(1.0f/SAMPLING_FACTOR);\r
+ }\r
+}\r
+\r
+static void Mix32ToFP_Stereo(float* dste,SLONG* srce,NATIVE count)\r
+{\r
+ float x1,x2,x3,x4,tmpx,tmpy;\r
+ int i;\r
+\r
+ for(count/=SAMPLING_FACTOR;count;count--) {\r
+ tmpx=tmpy=0.0f;\r
+\r
+ for(i=SAMPLING_FACTOR/2;i;i--) {\r
+ EXTRACT_SAMPLE_FP(x1,1.0f); EXTRACT_SAMPLE_FP(x2,1.0f);\r
+ EXTRACT_SAMPLE_FP(x3,1.0f); EXTRACT_SAMPLE_FP(x4,1.0f);\r
+\r
+ CHECK_SAMPLE_FP(x1,1.0f); CHECK_SAMPLE_FP(x2,1.0f);\r
+ CHECK_SAMPLE_FP(x3,1.0f); CHECK_SAMPLE_FP(x4,1.0f);\r
+\r
+ tmpx+=x1+x3;\r
+ tmpy+=x2+x4;\r
+ }\r
+ *dste++ =tmpx*(1.0f/SAMPLING_FACTOR);\r
+ *dste++ =tmpy*(1.0f/SAMPLING_FACTOR);\r
+ }\r
+}\r
+\r
+/* Mixing macros */\r
+#define EXTRACT_SAMPLE(var,attenuation) var=*srce++/(MAXVOL_FACTOR*attenuation)\r
+#define CHECK_SAMPLE(var,bound) var=(var>=bound)?bound-1:(var<-bound)?-bound:var\r
+\r
+static void Mix32To16_Normal(SWORD* dste,SLONG* srce,NATIVE count)\r
+{\r
+ NATIVE x1,x2,tmpx;\r
+ int i;\r
+\r
+ for(count/=SAMPLING_FACTOR;count;count--) {\r
+ tmpx=0;\r
+\r
+ for(i=SAMPLING_FACTOR/2;i;i--) {\r
+ EXTRACT_SAMPLE(x1,1); EXTRACT_SAMPLE(x2,1);\r
+\r
+ CHECK_SAMPLE(x1,32768); CHECK_SAMPLE(x2,32768);\r
+\r
+ tmpx+=x1+x2;\r
+ }\r
+ *dste++ =tmpx/SAMPLING_FACTOR;\r
+ }\r
+}\r
+\r
+static void Mix32To16_Stereo(SWORD* dste,SLONG* srce,NATIVE count)\r
+{\r
+ NATIVE x1,x2,x3,x4,tmpx,tmpy;\r
+ int i;\r
+\r
+ for(count/=SAMPLING_FACTOR;count;count--) {\r
+ tmpx=tmpy=0;\r
+\r
+ for(i=SAMPLING_FACTOR/2;i;i--) {\r
+ EXTRACT_SAMPLE(x1,1); EXTRACT_SAMPLE(x2,1);\r
+ EXTRACT_SAMPLE(x3,1); EXTRACT_SAMPLE(x4,1);\r
+\r
+ CHECK_SAMPLE(x1,32768); CHECK_SAMPLE(x2,32768);\r
+ CHECK_SAMPLE(x3,32768); CHECK_SAMPLE(x4,32768);\r
+\r
+ tmpx+=x1+x3;\r
+ tmpy+=x2+x4;\r
+ }\r
+ *dste++ =tmpx/SAMPLING_FACTOR;\r
+ *dste++ =tmpy/SAMPLING_FACTOR;\r
+ }\r
+}\r
+\r
+static void Mix32To8_Normal(SBYTE* dste,SLONG* srce,NATIVE count)\r
+{\r
+ NATIVE x1,x2,tmpx;\r
+ int i;\r
+\r
+ for(count/=SAMPLING_FACTOR;count;count--) {\r
+ tmpx = 0;\r
+\r
+ for(i=SAMPLING_FACTOR/2;i;i--) {\r
+ EXTRACT_SAMPLE(x1,256); EXTRACT_SAMPLE(x2,256);\r
+\r
+ CHECK_SAMPLE(x1,128); CHECK_SAMPLE(x2,128);\r
+\r
+ tmpx+=x1+x2;\r
+ }\r
+ *dste++ =(tmpx/SAMPLING_FACTOR)+128;\r
+ }\r
+}\r
+\r
+static void Mix32To8_Stereo(SBYTE* dste,SLONG* srce,NATIVE count)\r
+{\r
+ NATIVE x1,x2,x3,x4,tmpx,tmpy;\r
+ int i;\r
+\r
+ for(count/=SAMPLING_FACTOR;count;count--) {\r
+ tmpx=tmpy=0;\r
+\r
+ for(i=SAMPLING_FACTOR/2;i;i--) {\r
+ EXTRACT_SAMPLE(x1,256); EXTRACT_SAMPLE(x2,256);\r
+ EXTRACT_SAMPLE(x3,256); EXTRACT_SAMPLE(x4,256);\r
+\r
+ CHECK_SAMPLE(x1,128); CHECK_SAMPLE(x2,128);\r
+ CHECK_SAMPLE(x3,128); CHECK_SAMPLE(x4,128);\r
+\r
+ tmpx+=x1+x3;\r
+ tmpy+=x2+x4;\r
+ }\r
+ *dste++ =(tmpx/SAMPLING_FACTOR)+128; \r
+ *dste++ =(tmpy/SAMPLING_FACTOR)+128; \r
+ }\r
+}\r
+\r
+static void AddChannel(SLONG* ptr,NATIVE todo)\r
+{\r
+ SLONGLONG end,done;\r
+ SWORD *s;\r
+\r
+ if(!(s=Samples[vnf->handle])) {\r
+ vnf->current = vnf->active = 0;\r
+ vnf->lastvalL = vnf->lastvalR = 0;\r
+ return;\r
+ }\r
+\r
+ /* update the 'current' index so the sample loops, or stops playing if it\r
+ reached the end of the sample */\r
+ while(todo>0) {\r
+ SLONGLONG endpos;\r
+\r
+ if(vnf->flags & SF_REVERSE) {\r
+ /* The sample is playing in reverse */\r
+ if((vnf->flags&SF_LOOP)&&(vnf->current<idxlpos)) {\r
+ /* the sample is looping and has reached the loopstart index */\r
+ if(vnf->flags & SF_BIDI) {\r
+ /* sample is doing bidirectional loops, so 'bounce' the\r
+ current index against the idxlpos */\r
+ vnf->current = idxlpos+(idxlpos-vnf->current);\r
+ vnf->flags &= ~SF_REVERSE;\r
+ vnf->increment = -vnf->increment;\r
+ } else\r
+ /* normal backwards looping, so set the current position to\r
+ loopend index */\r
+ vnf->current=idxlend-(idxlpos-vnf->current);\r
+ } else {\r
+ /* the sample is not looping, so check if it reached index 0 */\r
+ if(vnf->current < 0) {\r
+ /* playing index reached 0, so stop playing this sample */\r
+ vnf->current = vnf->active = 0;\r
+ break;\r
+ }\r
+ }\r
+ } else {\r
+ /* The sample is playing forward */\r
+ if((vnf->flags & SF_LOOP) &&\r
+ (vnf->current >= idxlend)) {\r
+ /* the sample is looping, check the loopend index */\r
+ if(vnf->flags & SF_BIDI) {\r
+ /* sample is doing bidirectional loops, so 'bounce' the\r
+ current index against the idxlend */\r
+ vnf->flags |= SF_REVERSE;\r
+ vnf->increment = -vnf->increment;\r
+ vnf->current = idxlend-(vnf->current-idxlend);\r
+ } else\r
+ /* normal backwards looping, so set the current position\r
+ to loopend index */\r
+ vnf->current=idxlpos+(vnf->current-idxlend);\r
+ } else {\r
+ /* sample is not looping, so check if it reached the last\r
+ position */\r
+ if(vnf->current >= idxsize) {\r
+ /* yes, so stop playing this sample */\r
+ vnf->current = vnf->active = 0;\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+ end=(vnf->flags&SF_REVERSE)?(vnf->flags&SF_LOOP)?idxlpos:0:\r
+ (vnf->flags&SF_LOOP)?idxlend:idxsize;\r
+\r
+ /* if the sample is not blocked... */\r
+ if((end==vnf->current)||(!vnf->increment))\r
+ done=0;\r
+ else {\r
+ done=MIN((end-vnf->current)/vnf->increment+1,todo);\r
+ if(done<0) done=0;\r
+ }\r
+\r
+ if(!done) {\r
+ vnf->active = 0;\r
+ break;\r
+ }\r
+\r
+ endpos=vnf->current+done*vnf->increment;\r
+\r
+ if(vnf->vol || vnf->rampvol) {\r
+#ifndef NATIVE_64BIT_INT\r
+ /* use the 32 bit mixers as often as we can (they're much faster) */\r
+ if((vnf->current<0x7fffffff)&&(endpos<0x7fffffff)) {\r
+ if(vc_mode & DMODE_STEREO) {\r
+ if((vnf->pan==PAN_SURROUND)&&(vc_mode&DMODE_SURROUND))\r
+ vnf->current=Mix32StereoSurround\r
+ (s,ptr,vnf->current,vnf->increment,done);\r
+ else\r
+ vnf->current=Mix32StereoNormal\r
+ (s,ptr,vnf->current,vnf->increment,done);\r
+ } else\r
+ vnf->current=Mix32MonoNormal\r
+ (s,ptr,vnf->current,vnf->increment,done);\r
+ } else\r
+#endif\r
+ {\r
+ if(vc_mode & DMODE_STEREO) {\r
+ if((vnf->pan==PAN_SURROUND)&&(vc_mode&DMODE_SURROUND))\r
+ vnf->current=MixStereoSurround\r
+ (s,ptr,vnf->current,vnf->increment,done);\r
+ else\r
+ vnf->current=MixStereoNormal\r
+ (s,ptr,vnf->current,vnf->increment,done);\r
+ } else\r
+ vnf->current=MixMonoNormal\r
+ (s,ptr,vnf->current,vnf->increment,done);\r
+ }\r
+ } else {\r
+ vnf->lastvalL = vnf->lastvalR = 0;\r
+ /* update sample position */\r
+ vnf->current=endpos;\r
+ }\r
+\r
+ todo -= done;\r
+ ptr +=(vc_mode & DMODE_STEREO)?(done<<1):done;\r
+ }\r
+}\r
+\r
+#define _IN_VIRTCH_\r
+\r
+#define VC1_SilenceBytes VC2_SilenceBytes\r
+#define VC1_WriteSamples VC2_WriteSamples\r
+#define VC1_WriteBytes VC2_WriteBytes\r
+#define VC1_Exit VC2_Exit\r
+#define VC1_VoiceSetVolume VC2_VoiceSetVolume\r
+#define VC1_VoiceGetVolume VC2_VoiceGetVolume\r
+#define VC1_VoiceSetPanning VC2_VoiceSetPanning\r
+#define VC1_VoiceGetPanning VC2_VoiceGetPanning\r
+#define VC1_VoiceSetFrequency VC2_VoiceSetFrequency\r
+#define VC1_VoiceGetFrequency VC2_VoiceGetFrequency\r
+#define VC1_VoicePlay VC2_VoicePlay\r
+#define VC1_VoiceStop VC2_VoiceStop\r
+#define VC1_VoiceStopped VC2_VoiceStopped\r
+#define VC1_VoiceGetPosition VC2_VoiceGetPosition\r
+#define VC1_SampleUnload VC2_SampleUnload\r
+#define VC1_SampleLoad VC2_SampleLoad\r
+#define VC1_SampleSpace VC2_SampleSpace\r
+#define VC1_SampleLength VC2_SampleLength\r
+#define VC1_VoiceRealVolume VC2_VoiceRealVolume\r
+\r
+#include "virtch_common.c"\r
+#undef _IN_VIRTCH_\r
+\r
+void VC2_WriteSamples(SBYTE* buf,ULONG todo)\r
+{\r
+ int left,portion=0;\r
+ SBYTE *buffer;\r
+ int t,pan,vol;\r
+\r
+ todo*=SAMPLING_FACTOR;\r
+\r
+ while(todo) {\r
+ if(!tickleft) {\r
+ if(vc_mode & DMODE_SOFT_MUSIC) md_player();\r
+ tickleft=(md_mixfreq*125L*SAMPLING_FACTOR)/(md_bpm*50L);\r
+ tickleft&=~(SAMPLING_FACTOR-1);\r
+ }\r
+ left = MIN(tickleft, todo);\r
+ buffer = buf;\r
+ tickleft -= left;\r
+ todo -= left;\r
+ buf += samples2bytes(left)/SAMPLING_FACTOR;\r
+\r
+ while(left) {\r
+ portion = MIN(left, samplesthatfit);\r
+ memset(vc_tickbuf,0,portion<<((vc_mode&DMODE_STEREO)?3:2));\r
+ for(t=0;t<vc_softchn;t++) {\r
+ vnf = &vinf[t];\r
+\r
+ if(vnf->kick) {\r
+ vnf->current=((SLONGLONG)(vnf->start))<<FRACBITS;\r
+ vnf->kick = 0;\r
+ vnf->active = 1;\r
+ vnf->click = CLICK_BUFFER;\r
+ vnf->rampvol = 0;\r
+ }\r
+\r
+ if(!vnf->frq) vnf->active = 0;\r
+\r
+ if(vnf->active) {\r
+ vnf->increment=((SLONGLONG)(vnf->frq)<<(FRACBITS-SAMPLING_SHIFT))\r
+ /md_mixfreq;\r
+ if(vnf->flags&SF_REVERSE) vnf->increment=-vnf->increment;\r
+ vol = vnf->vol; pan = vnf->pan;\r
+\r
+ vnf->oldlvol=vnf->lvolsel;vnf->oldrvol=vnf->rvolsel;\r
+ if(vc_mode & DMODE_STEREO) {\r
+ if(pan!=PAN_SURROUND) {\r
+ vnf->lvolsel=(vol*(PAN_RIGHT-pan))>>8;\r
+ vnf->rvolsel=(vol*pan)>>8;\r
+ } else {\r
+ vnf->lvolsel=vnf->rvolsel=(vol * 256L) / 480;\r
+ }\r
+ } else\r
+ vnf->lvolsel=vol;\r
+\r
+ idxsize=(vnf->size)?((SLONGLONG)(vnf->size)<<FRACBITS)-1:0;\r
+ idxlend=(vnf->repend)?((SLONGLONG)(vnf->repend)<<FRACBITS)-1:0;\r
+ idxlpos=(SLONGLONG)(vnf->reppos)<<FRACBITS;\r
+ AddChannel(vc_tickbuf,portion);\r
+ }\r
+ }\r
+\r
+ if(md_reverb) {\r
+ if(md_reverb>15) md_reverb=15;\r
+ MixReverb(vc_tickbuf,portion);\r
+ }\r
+\r
+ if(vc_mode & DMODE_FLOAT)\r
+ Mix32toFP((float*)buffer,vc_tickbuf,portion);\r
+ else if(vc_mode & DMODE_16BITS)\r
+ Mix32to16((SWORD*)buffer,vc_tickbuf,portion);\r
+ else\r
+ Mix32to8((SBYTE*)buffer,vc_tickbuf,portion);\r
+\r
+ buffer += samples2bytes(portion) / SAMPLING_FACTOR;\r
+ left -= portion;\r
+ }\r
+ }\r
+}\r
+\r
+BOOL VC2_Init(void)\r
+{\r
+ VC_SetupPointers();\r
+ \r
+ if (!(md_mode&DMODE_HQMIXER))\r
+ return VC1_Init();\r
+ \r
+ if(!(Samples=(SWORD**)_mm_calloc(MAXSAMPLEHANDLES,sizeof(SWORD*)))) {\r
+ _mm_errno = MMERR_INITIALIZING_MIXER;\r
+ return 1;\r
+ }\r
+ if(!vc_tickbuf)\r
+ if(!(vc_tickbuf=(SLONG*)_mm_malloc((TICKLSIZE+32)*sizeof(SLONG)))) {\r
+ _mm_errno = MMERR_INITIALIZING_MIXER;\r
+ return 1;\r
+ }\r
+\r
+ if(md_mode & DMODE_STEREO) {\r
+ Mix32toFP = Mix32ToFP_Stereo;\r
+ Mix32to16 = Mix32To16_Stereo;\r
+ Mix32to8 = Mix32To8_Stereo;\r
+ MixReverb = MixReverb_Stereo;\r
+ } else {\r
+ Mix32toFP = Mix32ToFP_Normal;\r
+ Mix32to16 = Mix32To16_Normal;\r
+ Mix32to8 = Mix32To8_Normal;\r
+ MixReverb = MixReverb_Normal;\r
+ }\r
+ md_mode |= DMODE_INTERP;\r
+ vc_mode = md_mode;\r
+ return 0;\r
+}\r
+\r
+BOOL VC2_PlayStart(void)\r
+{\r
+ md_mode|=DMODE_INTERP;\r
+\r
+ samplesthatfit = TICKLSIZE;\r
+ if(vc_mode & DMODE_STEREO) samplesthatfit >>= 1;\r
+ tickleft = 0;\r
+\r
+ RVc1 = (5000L * md_mixfreq) / (REVERBERATION * 10);\r
+ RVc2 = (5078L * md_mixfreq) / (REVERBERATION * 10);\r
+ RVc3 = (5313L * md_mixfreq) / (REVERBERATION * 10);\r
+ RVc4 = (5703L * md_mixfreq) / (REVERBERATION * 10);\r
+ RVc5 = (6250L * md_mixfreq) / (REVERBERATION * 10);\r
+ RVc6 = (6953L * md_mixfreq) / (REVERBERATION * 10);\r
+ RVc7 = (7813L * md_mixfreq) / (REVERBERATION * 10);\r
+ RVc8 = (8828L * md_mixfreq) / (REVERBERATION * 10);\r
+\r
+ if(!(RVbufL1=(SLONG*)_mm_calloc((RVc1+1),sizeof(SLONG)))) return 1;\r
+ if(!(RVbufL2=(SLONG*)_mm_calloc((RVc2+1),sizeof(SLONG)))) return 1;\r
+ if(!(RVbufL3=(SLONG*)_mm_calloc((RVc3+1),sizeof(SLONG)))) return 1;\r
+ if(!(RVbufL4=(SLONG*)_mm_calloc((RVc4+1),sizeof(SLONG)))) return 1;\r
+ if(!(RVbufL5=(SLONG*)_mm_calloc((RVc5+1),sizeof(SLONG)))) return 1;\r
+ if(!(RVbufL6=(SLONG*)_mm_calloc((RVc6+1),sizeof(SLONG)))) return 1;\r
+ if(!(RVbufL7=(SLONG*)_mm_calloc((RVc7+1),sizeof(SLONG)))) return 1;\r
+ if(!(RVbufL8=(SLONG*)_mm_calloc((RVc8+1),sizeof(SLONG)))) return 1;\r
+\r
+ if(!(RVbufR1=(SLONG*)_mm_calloc((RVc1+1),sizeof(SLONG)))) return 1;\r
+ if(!(RVbufR2=(SLONG*)_mm_calloc((RVc2+1),sizeof(SLONG)))) return 1;\r
+ if(!(RVbufR3=(SLONG*)_mm_calloc((RVc3+1),sizeof(SLONG)))) return 1;\r
+ if(!(RVbufR4=(SLONG*)_mm_calloc((RVc4+1),sizeof(SLONG)))) return 1;\r
+ if(!(RVbufR5=(SLONG*)_mm_calloc((RVc5+1),sizeof(SLONG)))) return 1;\r
+ if(!(RVbufR6=(SLONG*)_mm_calloc((RVc6+1),sizeof(SLONG)))) return 1;\r
+ if(!(RVbufR7=(SLONG*)_mm_calloc((RVc7+1),sizeof(SLONG)))) return 1;\r
+ if(!(RVbufR8=(SLONG*)_mm_calloc((RVc8+1),sizeof(SLONG)))) return 1;\r
+\r
+ RVRindex = 0;\r
+ return 0;\r
+}\r
+\r
+void VC2_PlayStop(void)\r
+{\r
+ if(RVbufL1) free(RVbufL1);\r
+ if(RVbufL2) free(RVbufL2);\r
+ if(RVbufL3) free(RVbufL3);\r
+ if(RVbufL4) free(RVbufL4);\r
+ if(RVbufL5) free(RVbufL5);\r
+ if(RVbufL6) free(RVbufL6);\r
+ if(RVbufL7) free(RVbufL7);\r
+ if(RVbufL8) free(RVbufL8);\r
+ if(RVbufR1) free(RVbufR1);\r
+ if(RVbufR2) free(RVbufR2);\r
+ if(RVbufR3) free(RVbufR3);\r
+ if(RVbufR4) free(RVbufR4);\r
+ if(RVbufR5) free(RVbufR5);\r
+ if(RVbufR6) free(RVbufR6);\r
+ if(RVbufR7) free(RVbufR7);\r
+ if(RVbufR8) free(RVbufR8);\r
+\r
+ RVbufL1=RVbufL2=RVbufL3=RVbufL4=RVbufL5=RVbufL6=RVbufL7=RVbufL8=NULL;\r
+ RVbufR1=RVbufR2=RVbufR3=RVbufR4=RVbufR5=RVbufR6=RVbufR7=RVbufR8=NULL;\r
+}\r
+\r
+BOOL VC2_SetNumVoices(void)\r
+{\r
+ int t;\r
+\r
+ md_mode|=DMODE_INTERP;\r
+\r
+ if(!(vc_softchn=md_softchn)) return 0;\r
+\r
+ if(vinf) free(vinf);\r
+ if(!(vinf=_mm_calloc(sizeof(VINFO),vc_softchn))) return 1;\r
+\r
+ for(t=0;t<vc_softchn;t++) {\r
+ vinf[t].frq=10000;\r
+ vinf[t].pan=(t&1)?PAN_LEFT:PAN_RIGHT;\r
+ }\r
+\r
+ return 0;\r
+}\r
+\r
+/* ex:set ts=4: */\r
projects / mikmod-rockbox.git / blobdiff