1 /* MikMod sound library
\r
2 (c) 1998, 1999, 2000, 2001 Miodrag Vallat and others - see file AUTHORS
\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
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
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
21 /*==============================================================================
\r
23 $Id: virtch_common.c,v 1.2 2004/02/13 13:31:54 raph Exp $
\r
25 Common source parts between the two software mixers.
\r
26 This file is probably the ugliest part of libmikmod...
\r
28 ==============================================================================*/
\r
32 #include "mikmod_internals.h"
\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
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
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
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
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
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
106 #if defined __STDC__ || defined _MSC_VER
\r
107 #define VC_PROC0(suffix) \
\r
108 MIKMODAPI void VC_##suffix (void) { VC_##suffix##_ptr(); }
\r
110 #define VC_FUNC0(suffix,ret) \
\r
111 MIKMODAPI ret VC_##suffix (void) { return VC_##suffix##_ptr(); }
\r
113 #define VC_PROC1(suffix,typ1) \
\r
114 MIKMODAPI void VC_##suffix (typ1 a) { VC_##suffix##_ptr(a); }
\r
116 #define VC_FUNC1(suffix,ret,typ1) \
\r
117 MIKMODAPI ret VC_##suffix (typ1 a) { return VC_##suffix##_ptr(a); }
\r
119 #define VC_PROC2(suffix,typ1,typ2) \
\r
120 MIKMODAPI void VC_##suffix (typ1 a,typ2 b) { VC_##suffix##_ptr(a,b); }
\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
125 #define VC_PROC0(suffix) \
\r
126 MIKMODAPI void VC_/**/suffix (void) { VC_/**/suffix/**/_ptr(); }
\r
128 #define VC_FUNC0(suffix,ret) \
\r
129 MIKMODAPI ret VC_/**/suffix (void) { return VC_/**/suffix/**/_ptr(); }
\r
131 #define VC_PROC1(suffix,typ1) \
\r
132 MIKMODAPI void VC_/**/suffix (typ1 a) { VC_/**/suffix/**/_ptr(a); }
\r
134 #define VC_FUNC1(suffix,ret,typ1) \
\r
135 MIKMODAPI ret VC_/**/suffix (typ1 a) { return VC_/**/suffix/**/_ptr(a); }
\r
137 #define VC_PROC2(suffix,typ1,typ2) \
\r
138 MIKMODAPI void VC_/**/suffix (typ1 a,typ2 b) { VC_/**/suffix/**/_ptr(a,b); }
\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
144 VC_FUNC0(Init,BOOL)
\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
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
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
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
170 void VC_SetupPointers(void)
\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
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
223 #ifndef _VIRTCH_COMMON_
\r
224 #define _VIRTCH_COMMON_
\r
226 static ULONG samples2bytes(ULONG samples)
\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
234 static ULONG bytes2samples(ULONG bytes)
\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
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
246 todo=samples2bytes(bytes2samples(todo));
\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
254 memset(buf,0x80,todo);
\r
259 void VC1_WriteSamples(SBYTE*,ULONG);
\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
267 return VC1_SilenceBytes(buf,todo);
\r
269 todo = bytes2samples(todo);
\r
270 VC1_WriteSamples(buf,todo);
\r
272 return samples2bytes(todo);
\r
275 void VC1_Exit(void)
\r
277 if(vc_tickbuf) free(vc_tickbuf);
\r
278 if(vinf) free(vinf);
\r
279 if(Samples) free(Samples);
\r
285 VC_SetupPointers();
\r
288 UWORD VC1_VoiceGetVolume(UBYTE voice)
\r
290 return vinf[voice].vol;
\r
293 ULONG VC1_VoiceGetPanning(UBYTE voice)
\r
295 return vinf[voice].pan;
\r
298 void VC1_VoiceSetFrequency(UBYTE voice,ULONG frq)
\r
300 vinf[voice].frq=frq;
\r
303 ULONG VC1_VoiceGetFrequency(UBYTE voice)
\r
305 return vinf[voice].frq;
\r
308 void VC1_VoicePlay(UBYTE voice,SWORD handle,ULONG start,ULONG size,ULONG reppos,ULONG repend,UWORD flags)
\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
319 void VC1_VoiceStop(UBYTE voice)
\r
321 vinf[voice].active = 0;
\r
324 BOOL VC1_VoiceStopped(UBYTE voice)
\r
326 return(vinf[voice].active==0);
\r
329 SLONG VC1_VoiceGetPosition(UBYTE voice)
\r
331 return(vinf[voice].current>>FRACBITS);
\r
334 void VC1_VoiceSetVolume(UBYTE voice,UWORD vol)
\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
342 void VC1_VoiceSetPanning(UBYTE voice,ULONG pan)
\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
350 /*========== External mixer interface */
\r
352 void VC1_SampleUnload(SWORD handle)
\r
354 if (handle<MAXSAMPLEHANDLES) {
\r
355 if (Samples[handle])
\r
356 free(Samples[handle]);
\r
357 Samples[handle]=NULL;
\r
361 SWORD VC1_SampleLoad(struct SAMPLOAD* sload,int type)
\r
363 SAMPLE *s = sload->sample;
\r
365 ULONG t, length,loopstart,loopend;
\r
367 if(type==MD_HARDWARE) return -1;
\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
373 if(handle==MAXSAMPLEHANDLES) {
\r
374 _mm_errno = MMERR_OUT_OF_HANDLES;
\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
384 length = s->length;
\r
385 loopstart = s->loopstart;
\r
386 loopend = s->loopend;
\r
388 SL_SampleSigned(sload);
\r
389 SL_Sample8to16(sload);
\r
391 if(!(Samples[handle]=(SWORD*)_mm_malloc((length+20)<<1))) {
\r
392 _mm_errno = MMERR_SAMPLE_TOO_BIG;
\r
396 /* read sample into buffer */
\r
397 if (SL_Load(Samples[handle],sload,length))
\r
400 /* Unclick sample */
\r
401 if(s->flags & SF_LOOP) {
\r
402 if(s->flags & SF_BIDI)
\r
404 Samples[handle][loopend+t]=Samples[handle][(loopend-t)-1];
\r
407 Samples[handle][loopend+t]=Samples[handle][t+loopstart];
\r
410 Samples[handle][t+length]=0;
\r
415 ULONG VC1_SampleSpace(int type)
\r
421 ULONG VC1_SampleLength(int type,SAMPLE* s)
\r
426 return (s->length*((s->flags&SF_16BITS)?2:1))+16;
\r
429 ULONG VC1_VoiceRealVolume(UBYTE voice)
\r
436 t = vinf[voice].current>>FRACBITS;
\r
437 if(!vinf[voice].active) return 0;
\r
439 s = vinf[voice].handle;
\r
440 size = vinf[voice].size;
\r
442 i=64; t-=64; k=0; j=0;
\r
443 if(i>size) i = size;
\r
445 if(t+i > size) t = size-i;
\r
447 i &= ~1; /* make sure it's EVEN. */
\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