apps/plugins/mikmod/playercode/virtch_common.c

   1 /*      MikMod sound library\r
   2         (c) 1998, 1999, 2000, 2001 Miodrag Vallat and others - see file AUTHORS\r
   3         for complete list.\r
   4 \r
   5         This library is free software; you can redistribute it and/or modify\r
   6         it under the terms of the GNU Library General Public License as\r
   7         published by the Free Software Foundation; either version 2 of\r
   8         the License, or (at your option) any later version.\r
   9  \r
  10         This program is distributed in the hope that it will be useful,\r
  11         but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  12         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  13         GNU Library General Public License for more details.\r
  14  \r
  15         You should have received a copy of the GNU Library General Public\r
  16         License along with this library; if not, write to the Free Software\r
  17         Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA\r
  18         02111-1307, USA.\r
  19 */\r
  20 \r
  21 /*==============================================================================\r
  22 \r
  23   $Id: virtch_common.c,v 1.2 2004/02/13 13:31:54 raph Exp $\r
  24 \r
  25   Common source parts between the two software mixers.\r
  26   This file is probably the ugliest part of libmikmod...\r
  27 \r
  28 ==============================================================================*/\r
  29 \r
  30 #ifndef _IN_VIRTCH_\r
  31 \r
  32 #include "mikmod_internals.h"\r
  33 \r
  34 extern BOOL  VC1_Init(void);\r
  35 extern BOOL  VC2_Init(void);\r
  36 static BOOL (*VC_Init_ptr)(void)=VC1_Init;\r
  37 extern void  VC1_Exit(void);\r
  38 extern void  VC2_Exit(void);\r
  39 static void (*VC_Exit_ptr)(void)=VC1_Exit;\r
  40 extern BOOL  VC1_SetNumVoices(void);\r
  41 extern BOOL  VC2_SetNumVoices(void);\r
  42 static BOOL (*VC_SetNumVoices_ptr)(void);\r
  43 extern ULONG VC1_SampleSpace(int);\r
  44 extern ULONG VC2_SampleSpace(int);\r
  45 static ULONG (*VC_SampleSpace_ptr)(int);\r
  46 extern ULONG VC1_SampleLength(int,SAMPLE*);\r
  47 extern ULONG VC2_SampleLength(int,SAMPLE*);\r
  48 static ULONG (*VC_SampleLength_ptr)(int,SAMPLE*);\r
  49 \r
  50 extern BOOL  VC1_PlayStart(void);\r
  51 extern BOOL  VC2_PlayStart(void);\r
  52 static BOOL (*VC_PlayStart_ptr)(void);\r
  53 extern void  VC1_PlayStop(void);\r
  54 extern void  VC2_PlayStop(void);\r
  55 static void (*VC_PlayStop_ptr)(void);\r
  56 \r
  57 extern SWORD VC1_SampleLoad(struct SAMPLOAD*,int);\r
  58 extern SWORD VC2_SampleLoad(struct SAMPLOAD*,int);\r
  59 static SWORD (*VC_SampleLoad_ptr)(struct SAMPLOAD*,int);\r
  60 extern void  VC1_SampleUnload(SWORD);\r
  61 extern void  VC2_SampleUnload(SWORD);\r
  62 static void (*VC_SampleUnload_ptr)(SWORD);\r
  63 \r
  64 extern ULONG VC1_WriteBytes(SBYTE*,ULONG);\r
  65 extern ULONG VC2_WriteBytes(SBYTE*,ULONG);\r
  66 static ULONG (*VC_WriteBytes_ptr)(SBYTE*,ULONG);\r
  67 extern ULONG VC1_SilenceBytes(SBYTE*,ULONG);\r
  68 extern ULONG VC2_SilenceBytes(SBYTE*,ULONG);\r
  69 static ULONG (*VC_SilenceBytes_ptr)(SBYTE*,ULONG);\r
  70 \r
  71 extern void  VC1_VoiceSetVolume(UBYTE,UWORD);\r
  72 extern void  VC2_VoiceSetVolume(UBYTE,UWORD);\r
  73 static void (*VC_VoiceSetVolume_ptr)(UBYTE,UWORD);\r
  74 extern UWORD VC1_VoiceGetVolume(UBYTE);\r
  75 extern UWORD VC2_VoiceGetVolume(UBYTE);\r
  76 static UWORD (*VC_VoiceGetVolume_ptr)(UBYTE);\r
  77 extern void  VC1_VoiceSetFrequency(UBYTE,ULONG);\r
  78 extern void  VC2_VoiceSetFrequency(UBYTE,ULONG);\r
  79 static void (*VC_VoiceSetFrequency_ptr)(UBYTE,ULONG);\r
  80 extern ULONG VC1_VoiceGetFrequency(UBYTE);\r
  81 extern ULONG VC2_VoiceGetFrequency(UBYTE);\r
  82 static ULONG (*VC_VoiceGetFrequency_ptr)(UBYTE);\r
  83 extern void  VC1_VoiceSetPanning(UBYTE,ULONG);\r
  84 extern void  VC2_VoiceSetPanning(UBYTE,ULONG);\r
  85 static void (*VC_VoiceSetPanning_ptr)(UBYTE,ULONG);\r
  86 extern ULONG VC1_VoiceGetPanning(UBYTE);\r
  87 extern ULONG VC2_VoiceGetPanning(UBYTE);\r
  88 static ULONG (*VC_VoiceGetPanning_ptr)(UBYTE);\r
  89 extern void  VC1_VoicePlay(UBYTE,SWORD,ULONG,ULONG,ULONG,ULONG,UWORD);\r
  90 extern void  VC2_VoicePlay(UBYTE,SWORD,ULONG,ULONG,ULONG,ULONG,UWORD);\r
  91 static void (*VC_VoicePlay_ptr)(UBYTE,SWORD,ULONG,ULONG,ULONG,ULONG,UWORD);\r
  92 \r
  93 extern void  VC1_VoiceStop(UBYTE);\r
  94 extern void  VC2_VoiceStop(UBYTE);\r
  95 static void (*VC_VoiceStop_ptr)(UBYTE);\r
  96 extern BOOL  VC1_VoiceStopped(UBYTE);\r
  97 extern BOOL  VC2_VoiceStopped(UBYTE);\r
  98 static BOOL (*VC_VoiceStopped_ptr)(UBYTE);\r
  99 extern SLONG VC1_VoiceGetPosition(UBYTE);\r
 100 extern SLONG VC2_VoiceGetPosition(UBYTE);\r
 101 static SLONG (*VC_VoiceGetPosition_ptr)(UBYTE);\r
 102 extern ULONG VC1_VoiceRealVolume(UBYTE);\r
 103 extern ULONG VC2_VoiceRealVolume(UBYTE);\r
 104 static ULONG (*VC_VoiceRealVolume_ptr)(UBYTE);\r
 105 \r
 106 #if defined __STDC__ || defined _MSC_VER\r
 107 #define VC_PROC0(suffix) \\r
 108 MIKMODAPI void VC_##suffix (void) { VC_##suffix##_ptr(); }\r
 109 \r
 110 #define VC_FUNC0(suffix,ret) \\r
 111 MIKMODAPI ret VC_##suffix (void) { return VC_##suffix##_ptr(); }\r
 112 \r
 113 #define VC_PROC1(suffix,typ1) \\r
 114 MIKMODAPI void VC_##suffix (typ1 a) { VC_##suffix##_ptr(a); }\r
 115 \r
 116 #define VC_FUNC1(suffix,ret,typ1) \\r
 117 MIKMODAPI ret VC_##suffix (typ1 a) { return VC_##suffix##_ptr(a); }\r
 118 \r
 119 #define VC_PROC2(suffix,typ1,typ2) \\r
 120 MIKMODAPI void VC_##suffix (typ1 a,typ2 b) { VC_##suffix##_ptr(a,b); }\r
 121 \r
 122 #define VC_FUNC2(suffix,ret,typ1,typ2) \\r
 123 MIKMODAPI ret VC_##suffix (typ1 a,typ2 b) { return VC_##suffix##_ptr(a,b); }\r
 124 #else\r
 125 #define VC_PROC0(suffix) \\r
 126 MIKMODAPI void VC_/**/suffix (void) { VC_/**/suffix/**/_ptr(); }\r
 127 \r
 128 #define VC_FUNC0(suffix,ret) \\r
 129 MIKMODAPI ret VC_/**/suffix (void) { return VC_/**/suffix/**/_ptr(); }\r
 130 \r
 131 #define VC_PROC1(suffix,typ1) \\r
 132 MIKMODAPI void VC_/**/suffix (typ1 a) { VC_/**/suffix/**/_ptr(a); }\r
 133 \r
 134 #define VC_FUNC1(suffix,ret,typ1) \\r
 135 MIKMODAPI ret VC_/**/suffix (typ1 a) { return VC_/**/suffix/**/_ptr(a); }\r
 136 \r
 137 #define VC_PROC2(suffix,typ1,typ2) \\r
 138 MIKMODAPI void VC_/**/suffix (typ1 a,typ2 b) { VC_/**/suffix/**/_ptr(a,b); }\r
 139 \r
 140 #define VC_FUNC2(suffix,ret,typ1,typ2) \\r
 141 MIKMODAPI ret VC_/**/suffix (typ1 a,typ2 b) { return VC_/**/suffix/**/_ptr(a,b); }\r
 142 #endif\r
 143 \r
 144 VC_FUNC0(Init,BOOL)\r
 145 VC_PROC0(Exit)\r
 146 VC_FUNC0(SetNumVoices,BOOL)\r
 147 VC_FUNC1(SampleSpace,ULONG,int)\r
 148 VC_FUNC2(SampleLength,ULONG,int,SAMPLE*)\r
 149 VC_FUNC0(PlayStart,BOOL)\r
 150 VC_PROC0(PlayStop)\r
 151 VC_FUNC2(SampleLoad,SWORD,struct SAMPLOAD*,int)\r
 152 VC_PROC1(SampleUnload,SWORD)\r
 153 VC_FUNC2(WriteBytes,ULONG,SBYTE*,ULONG)\r
 154 VC_FUNC2(SilenceBytes,ULONG,SBYTE*,ULONG)\r
 155 VC_PROC2(VoiceSetVolume,UBYTE,UWORD)\r
 156 VC_FUNC1(VoiceGetVolume,UWORD,UBYTE)\r
 157 VC_PROC2(VoiceSetFrequency,UBYTE,ULONG)\r
 158 VC_FUNC1(VoiceGetFrequency,ULONG,UBYTE)\r
 159 VC_PROC2(VoiceSetPanning,UBYTE,ULONG)\r
 160 VC_FUNC1(VoiceGetPanning,ULONG,UBYTE)\r
 161                 \r
 162 void  VC_VoicePlay(UBYTE a,SWORD b,ULONG c,ULONG d,ULONG e,ULONG f,UWORD g)\r
 163 { VC_VoicePlay_ptr(a,b,c,d,e,f,g); }\r
 164 \r
 165 VC_PROC1(VoiceStop,UBYTE)\r
 166 VC_FUNC1(VoiceStopped,BOOL,UBYTE)\r
 167 VC_FUNC1(VoiceGetPosition,SLONG,UBYTE)\r
 168 VC_FUNC1(VoiceRealVolume,ULONG,UBYTE)\r
 169                 \r
 170 void VC_SetupPointers(void)\r
 171 {\r
 172         if (md_mode&DMODE_HQMIXER) {\r
 173                 VC_Init_ptr=VC2_Init;\r
 174                 VC_Exit_ptr=VC2_Exit;\r
 175                 VC_SetNumVoices_ptr=VC2_SetNumVoices;\r
 176                 VC_SampleSpace_ptr=VC2_SampleSpace;\r
 177                 VC_SampleLength_ptr=VC2_SampleLength;\r
 178                 VC_PlayStart_ptr=VC2_PlayStart;\r
 179                 VC_PlayStop_ptr=VC2_PlayStop;\r
 180                 VC_SampleLoad_ptr=VC2_SampleLoad;\r
 181                 VC_SampleUnload_ptr=VC2_SampleUnload;\r
 182                 VC_WriteBytes_ptr=VC2_WriteBytes;\r
 183                 VC_SilenceBytes_ptr=VC2_SilenceBytes;\r
 184                 VC_VoiceSetVolume_ptr=VC2_VoiceSetVolume;\r
 185                 VC_VoiceGetVolume_ptr=VC2_VoiceGetVolume;\r
 186                 VC_VoiceSetFrequency_ptr=VC2_VoiceSetFrequency;\r
 187                 VC_VoiceGetFrequency_ptr=VC2_VoiceGetFrequency;\r
 188                 VC_VoiceSetPanning_ptr=VC2_VoiceSetPanning;\r
 189                 VC_VoiceGetPanning_ptr=VC2_VoiceGetPanning;\r
 190                 VC_VoicePlay_ptr=VC2_VoicePlay;\r
 191                 VC_VoiceStop_ptr=VC2_VoiceStop;\r
 192                 VC_VoiceStopped_ptr=VC2_VoiceStopped;\r
 193                 VC_VoiceGetPosition_ptr=VC2_VoiceGetPosition;\r
 194                 VC_VoiceRealVolume_ptr=VC2_VoiceRealVolume;\r
 195         } else {\r
 196                 VC_Init_ptr=VC1_Init;\r
 197                 VC_Exit_ptr=VC1_Exit;\r
 198                 VC_SetNumVoices_ptr=VC1_SetNumVoices;\r
 199                 VC_SampleSpace_ptr=VC1_SampleSpace;\r
 200                 VC_SampleLength_ptr=VC1_SampleLength;\r
 201                 VC_PlayStart_ptr=VC1_PlayStart;\r
 202                 VC_PlayStop_ptr=VC1_PlayStop;\r
 203                 VC_SampleLoad_ptr=VC1_SampleLoad;\r
 204                 VC_SampleUnload_ptr=VC1_SampleUnload;\r
 205                 VC_WriteBytes_ptr=VC1_WriteBytes;\r
 206                 VC_SilenceBytes_ptr=VC1_SilenceBytes;\r
 207                 VC_VoiceSetVolume_ptr=VC1_VoiceSetVolume;\r
 208                 VC_VoiceGetVolume_ptr=VC1_VoiceGetVolume;\r
 209                 VC_VoiceSetFrequency_ptr=VC1_VoiceSetFrequency;\r
 210                 VC_VoiceGetFrequency_ptr=VC1_VoiceGetFrequency;\r
 211                 VC_VoiceSetPanning_ptr=VC1_VoiceSetPanning;\r
 212                 VC_VoiceGetPanning_ptr=VC1_VoiceGetPanning;\r
 213                 VC_VoicePlay_ptr=VC1_VoicePlay;\r
 214                 VC_VoiceStop_ptr=VC1_VoiceStop;\r
 215                 VC_VoiceStopped_ptr=VC1_VoiceStopped;\r
 216                 VC_VoiceGetPosition_ptr=VC1_VoiceGetPosition;\r
 217                 VC_VoiceRealVolume_ptr=VC1_VoiceRealVolume;\r
 218         }\r
 219 }\r
 220 \r
 221 #else\r
 222 \r
 223 #ifndef _VIRTCH_COMMON_\r
 224 #define _VIRTCH_COMMON_\r
 225 \r
 226 static ULONG samples2bytes(ULONG samples)\r
 227 {\r
 228         if(vc_mode & DMODE_FLOAT) samples <<= 2;\r
 229         else if(vc_mode & DMODE_16BITS) samples <<= 1;\r
 230         if(vc_mode & DMODE_STEREO) samples <<= 1;\r
 231         return samples;\r
 232 }\r
 233 \r
 234 static ULONG bytes2samples(ULONG bytes)\r
 235 {\r
 236         if(vc_mode & DMODE_FLOAT) bytes >>= 2;\r
 237         else if(vc_mode & DMODE_16BITS) bytes >>= 1;\r
 238         if(vc_mode & DMODE_STEREO) bytes >>= 1;\r
 239         return bytes;\r
 240 }\r
 241 \r
 242 /* Fill the buffer with 'todo' bytes of silence (it depends on the mixing mode\r
 243    how the buffer is filled) */\r
 244 ULONG VC1_SilenceBytes(SBYTE* buf,ULONG todo)\r
 245 {\r
 246         todo=samples2bytes(bytes2samples(todo));\r
 247 \r
 248         /* clear the buffer to zero (16 bits signed) or 0x80 (8 bits unsigned) */\r
 249         if(vc_mode & DMODE_FLOAT)\r
 250                 memset(buf,0,todo);\r
 251         else if(vc_mode & DMODE_16BITS)\r
 252                 memset(buf,0,todo);\r
 253         else\r
 254                 memset(buf,0x80,todo);\r
 255 \r
 256         return todo;\r
 257 }\r
 258 \r
 259 void VC1_WriteSamples(SBYTE*,ULONG);\r
 260 \r
 261 /* Writes 'todo' mixed SBYTES (!!) to 'buf'. It returns the number of SBYTES\r
 262    actually written to 'buf' (which is rounded to number of samples that fit\r
 263    into 'todo' bytes). */\r
 264 ULONG VC1_WriteBytes(SBYTE* buf,ULONG todo)\r
 265 {\r
 266         if(!vc_softchn)\r
 267                 return VC1_SilenceBytes(buf,todo);\r
 268 \r
 269         todo = bytes2samples(todo);\r
 270         VC1_WriteSamples(buf,todo);\r
 271 \r
 272         return samples2bytes(todo);\r
 273 }\r
 274 \r
 275 void VC1_Exit(void)\r
 276 {\r
 277         if(vc_tickbuf) free(vc_tickbuf);\r
 278         if(vinf) free(vinf);\r
 279         if(Samples) free(Samples);\r
 280 \r
 281         vc_tickbuf = NULL;\r
 282         vinf = NULL;\r
 283         Samples = NULL;\r
 284         \r
 285         VC_SetupPointers();\r
 286 }\r
 287 \r
 288 UWORD VC1_VoiceGetVolume(UBYTE voice)\r
 289 {\r
 290         return vinf[voice].vol;\r
 291 }\r
 292 \r
 293 ULONG VC1_VoiceGetPanning(UBYTE voice)\r
 294 {\r
 295         return vinf[voice].pan;\r
 296 }\r
 297 \r
 298 void VC1_VoiceSetFrequency(UBYTE voice,ULONG frq)\r
 299 {\r
 300         vinf[voice].frq=frq;\r
 301 }\r
 302 \r
 303 ULONG VC1_VoiceGetFrequency(UBYTE voice)\r
 304 {\r
 305         return vinf[voice].frq;\r
 306 }\r
 307 \r
 308 void VC1_VoicePlay(UBYTE voice,SWORD handle,ULONG start,ULONG size,ULONG reppos,ULONG repend,UWORD flags)\r
 309 {\r
 310         vinf[voice].flags    = flags;\r
 311         vinf[voice].handle   = handle;\r
 312         vinf[voice].start    = start;\r
 313         vinf[voice].size     = size;\r
 314         vinf[voice].reppos   = reppos;\r
 315         vinf[voice].repend   = repend;\r
 316         vinf[voice].kick     = 1;\r
 317 }\r
 318 \r
 319 void VC1_VoiceStop(UBYTE voice)\r
 320 {\r
 321         vinf[voice].active = 0;\r
 322 }  \r
 323 \r
 324 BOOL VC1_VoiceStopped(UBYTE voice)\r
 325 {\r
 326         return(vinf[voice].active==0);\r
 327 }\r
 328 \r
 329 SLONG VC1_VoiceGetPosition(UBYTE voice)\r
 330 {\r
 331         return(vinf[voice].current>>FRACBITS);\r
 332 }\r
 333 \r
 334 void VC1_VoiceSetVolume(UBYTE voice,UWORD vol)\r
 335 {    \r
 336         /* protect against clicks if volume variation is too high */\r
 337         if(abs((int)vinf[voice].vol-(int)vol)>32)\r
 338                 vinf[voice].rampvol=CLICK_BUFFER;\r
 339         vinf[voice].vol=vol;\r
 340 }\r
 341 \r
 342 void VC1_VoiceSetPanning(UBYTE voice,ULONG pan)\r
 343 {\r
 344         /* protect against clicks if panning variation is too high */\r
 345         if(abs((int)vinf[voice].pan-(int)pan)>48)\r
 346                 vinf[voice].rampvol=CLICK_BUFFER;\r
 347         vinf[voice].pan=pan;\r
 348 }\r
 349 \r
 350 /*========== External mixer interface */\r
 351 \r
 352 void VC1_SampleUnload(SWORD handle)\r
 353 {\r
 354         if (handle<MAXSAMPLEHANDLES) {\r
 355                 if (Samples[handle])\r
 356                         free(Samples[handle]);\r
 357                 Samples[handle]=NULL;\r
 358         }\r
 359 }\r
 360 \r
 361 SWORD VC1_SampleLoad(struct SAMPLOAD* sload,int type)\r
 362 {\r
 363         SAMPLE *s = sload->sample;\r
 364         int handle;\r
 365         ULONG t, length,loopstart,loopend;\r
 366 \r
 367         if(type==MD_HARDWARE) return -1;\r
 368 \r
 369         /* Find empty slot to put sample address in */\r
 370         for(handle=0;handle<MAXSAMPLEHANDLES;handle++)\r
 371                 if(!Samples[handle]) break;\r
 372 \r
 373         if(handle==MAXSAMPLEHANDLES) {\r
 374                 _mm_errno = MMERR_OUT_OF_HANDLES;\r
 375                 return -1;\r
 376         }\r
 377         \r
 378         /* Reality check for loop settings */\r
 379         if (s->loopend > s->length)\r
 380                 s->loopend = s->length;\r
 381         if (s->loopstart >= s->loopend)\r
 382                 s->flags &= ~SF_LOOP;\r
 383 \r
 384         length    = s->length;\r
 385         loopstart = s->loopstart;\r
 386         loopend   = s->loopend;\r
 387 \r
 388         SL_SampleSigned(sload);\r
 389         SL_Sample8to16(sload);\r
 390 \r
 391         if(!(Samples[handle]=(SWORD*)_mm_malloc((length+20)<<1))) {\r
 392                 _mm_errno = MMERR_SAMPLE_TOO_BIG;\r
 393                 return -1;\r
 394         }\r
 395 \r
 396         /* read sample into buffer */\r
 397         if (SL_Load(Samples[handle],sload,length))\r
 398                 return -1;\r
 399 \r
 400         /* Unclick sample */\r
 401         if(s->flags & SF_LOOP) {\r
 402                 if(s->flags & SF_BIDI)\r
 403                         for(t=0;t<16;t++)\r
 404                                 Samples[handle][loopend+t]=Samples[handle][(loopend-t)-1];\r
 405                 else\r
 406                         for(t=0;t<16;t++)\r
 407                                 Samples[handle][loopend+t]=Samples[handle][t+loopstart];\r
 408         } else\r
 409                 for(t=0;t<16;t++)\r
 410                         Samples[handle][t+length]=0;\r
 411 \r
 412         return handle;\r
 413 }\r
 414 \r
 415 ULONG VC1_SampleSpace(int type)\r
 416 {\r
 417         (void)type;\r
 418         return vc_memory;\r
 419 }\r
 420 \r
 421 ULONG VC1_SampleLength(int type,SAMPLE* s)\r
 422 {\r
 423         (void)type;\r
 424         if (!s) return 0;\r
 425 \r
 426         return (s->length*((s->flags&SF_16BITS)?2:1))+16;\r
 427 }\r
 428 \r
 429 ULONG VC1_VoiceRealVolume(UBYTE voice)\r
 430 {\r
 431         ULONG i,s,size;\r
 432         int k,j;\r
 433         SWORD *smp;\r
 434         SLONG t;\r
 435 \r
 436         t = vinf[voice].current>>FRACBITS;\r
 437         if(!vinf[voice].active) return 0;\r
 438 \r
 439         s = vinf[voice].handle;\r
 440         size = vinf[voice].size;\r
 441 \r
 442         i=64; t-=64; k=0; j=0;\r
 443         if(i>size) i = size;\r
 444         if(t<0) t = 0;\r
 445         if(t+i > size) t = size-i;\r
 446 \r
 447         i &= ~1;  /* make sure it's EVEN. */\r
 448 \r
 449         smp = &Samples[s][t];\r
 450         for(;i;i--,smp++) {\r
 451                 if(k<*smp) k = *smp;\r
 452                 if(j>*smp) j = *smp;\r
 453         }\r
 454         return abs(k-j);\r
 455 }\r
 456 \r
 457 #endif\r
 458 \r
 459 #endif\r
 460 \r
 461 /* ex:set ts=4: */\r