Added AI by Ricardo Cruz. This also adds mouse controls.
[crow/jumpnbump.git] / sdl / sound.c
1 /*
2  * sound.c
3  * Copyright (C) 1998 Brainchild Design - http://brainchilddesign.com/
4  * 
5  * Copyright (C) 2001 Chuck Mason <cemason@users.sourceforge.net>
6  *
7  * Copyright (C) 2002 Florian Schulze <crow@icculus.org>
8  *
9  * This file is part of Jump'n'Bump.
10  *
11  * Jump'n'Bump is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  *
16  * Jump'n'Bump is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
24  */
25
26 #include "globals.h"
27 #include <limits.h>
28 #ifndef _MSC_VER
29 #include <unistd.h>
30 #endif
31 #include "SDL.h"
32
33 #ifndef NO_SDL_MIXER
34 #include "SDL_mixer.h"
35
36 static Mix_Music *current_music = (Mix_Music *) NULL;
37 #endif
38
39 sfx_data sounds[NUM_SFX];
40
41 static int SAMPLECOUNT = 512;
42
43 #define MAX_CHANNELS    32
44
45 typedef struct {
46         /* loop flag */
47         int loop;
48         /* The channel step amount... */
49         unsigned int step;
50         /* ... and a 0.16 bit remainder of last step. */
51         unsigned int stepremainder;
52         unsigned int samplerate;
53         /* The channel data pointers, start and end. */
54         signed short* data;
55         signed short* startdata;
56         signed short* enddata;
57         /* Hardware left and right channel volume lookup. */
58         int leftvol;
59         int rightvol;
60 } channel_info_t;
61
62 channel_info_t channelinfo[MAX_CHANNELS];
63
64 /* Sample rate in samples/second */
65 int audio_rate = 44100;
66 int global_sfx_volume = 0;
67 /*
68 // This function loops all active (internal) sound
69 //  channels, retrieves a given number of samples
70 //  from the raw sound data, modifies it according
71 //  to the current (internal) channel parameters,
72 //  mixes the per channel samples into the given
73 //  mixing buffer, and clamping it to the allowed
74 //  range.
75 //
76 // This function currently supports only 16bit.
77 */
78
79 static void stopchan(int i)
80 {
81         if (channelinfo[i].data) {
82                 memset(&channelinfo[i], 0, sizeof(channel_info_t));
83         }
84 }
85
86
87 /*
88 // This function adds a sound to the
89 //  list of currently active sounds,
90 //  which is maintained as a given number
91 //  (eight, usually) of internal channels.
92 // Returns a handle.
93 */
94 int addsfx(signed short *data, int len, int loop, int samplerate, int channel)
95 {
96         stopchan(channel);
97
98         /* We will handle the new SFX. */
99         /* Set pointer to raw data. */
100         channelinfo[channel].data = data;
101         channelinfo[channel].startdata = data;
102       
103         /* Set pointer to end of raw data. */
104         channelinfo[channel].enddata = channelinfo[channel].data + len - 1;
105         channelinfo[channel].samplerate = samplerate;
106
107         channelinfo[channel].loop = loop;
108         channelinfo[channel].stepremainder = 0;
109
110         return channel;
111 }
112
113
114 static void updateSoundParams(int slot, int volume)
115 {
116         int rightvol;
117         int leftvol;
118
119         /*
120         // Set stepping
121         // MWM 2000-12-24: Calculates proportion of channel samplerate
122         // to global samplerate for mixing purposes.
123         // Patched to shift left *then* divide, to minimize roundoff errors
124         // as well as to use SAMPLERATE as defined above, not to assume 11025 Hz
125         */
126         channelinfo[slot].step = ((channelinfo[slot].samplerate<<16)/audio_rate);
127
128         leftvol = volume;
129         rightvol= volume;  
130
131         /* Sanity check, clamp volume. */
132         if (rightvol < 0)
133                 rightvol = 0;
134         if (rightvol > 127)
135                 rightvol = 127;
136     
137         if (leftvol < 0)
138                 leftvol = 0;
139         if (leftvol > 127)
140                 leftvol = 127;
141     
142         channelinfo[slot].leftvol = leftvol;
143         channelinfo[slot].rightvol = rightvol;
144 }
145
146
147 void mix_sound(void *unused, Uint8 *stream, int len)
148 {
149         /* Mix current sound data. */
150         /* Data, from raw sound, for right and left. */
151         register int sample;
152         register int    dl;
153         register int    dr;
154
155         /* Pointers in audio stream, left, right, end. */
156         signed short*   leftout;
157         signed short*   rightout;
158         signed short*   leftend;
159         /* Step in stream, left and right, thus two. */
160         int       step;
161
162         /* Mixing channel index. */
163         int       chan;
164
165         /* Left and right channel */
166         /*  are in audio stream, alternating. */
167         leftout = (signed short *)stream;
168         rightout = ((signed short *)stream)+1;
169         step = 2;
170
171         /* Determine end, for left channel only */
172         /*  (right channel is implicit). */
173         leftend = leftout + (len/4)*step;
174
175         /* Mix sounds into the mixing buffer. */
176         /* Loop over step*SAMPLECOUNT, */
177         /*  that is 512 values for two channels. */
178         while (leftout != leftend) {
179                 /* Reset left/right value. */
180                 dl = *leftout * 256;
181                 dr = *rightout * 256;
182
183                 /* Love thy L2 chache - made this a loop. */
184                 /* Now more channels could be set at compile time */
185                 /*  as well. Thus loop those  channels. */
186                 for ( chan = 0; chan < MAX_CHANNELS; chan++ ) {
187                         /* Check channel, if active. */
188                         if (channelinfo[chan].data) {
189                                 /* Get the raw data from the channel. */
190                                 /* no filtering */
191                                 /* sample = *channelinfo[chan].data; */
192                                 /* linear filtering */
193                                 sample = (int)(((int)channelinfo[chan].data[0] * (int)(0x10000 - channelinfo[chan].stepremainder))
194                                         + ((int)channelinfo[chan].data[1] * (int)(channelinfo[chan].stepremainder))) >> 16;
195
196                                 /* Add left and right part */
197                                 /*  for this channel (sound) */
198                                 /*  to the current data. */
199                                 /* Adjust volume accordingly. */
200                                 dl += sample * (channelinfo[chan].leftvol * global_sfx_volume) / 128;
201                                 dr += sample * (channelinfo[chan].rightvol * global_sfx_volume) / 128;
202                                 /* Increment index ??? */
203                                 channelinfo[chan].stepremainder += channelinfo[chan].step;
204                                 /* MSB is next sample??? */
205                                 channelinfo[chan].data += channelinfo[chan].stepremainder >> 16;
206                                 /* Limit to LSB??? */
207                                 channelinfo[chan].stepremainder &= 0xffff;
208
209                                 /* Check whether we are done. */
210                                 if (channelinfo[chan].data >= channelinfo[chan].enddata) {
211                                         if (channelinfo[chan].loop) {
212                                                 channelinfo[chan].data = channelinfo[chan].startdata;
213                                         } else {
214                                                 stopchan(chan);
215                                         }
216                                 }
217                         }
218                 }
219   
220                 /* Clamp to range. Left hardware channel. */
221                 /* Has been char instead of short. */
222                 /* if (dl > 127) *leftout = 127; */
223                 /* else if (dl < -128) *leftout = -128; */
224                 /* else *leftout = dl; */
225
226                 dl = dl / 256;
227                 dr = dr / 256;
228
229                 if (dl > SHRT_MAX)
230                         *leftout = SHRT_MAX;
231                 else if (dl < SHRT_MIN)
232                         *leftout = SHRT_MIN;
233                 else
234                         *leftout = (signed short)dl;
235
236                 /* Same for right hardware channel. */
237                 if (dr > SHRT_MAX)
238                         *rightout = SHRT_MAX;
239                 else if (dr < SHRT_MIN)
240                         *rightout = SHRT_MIN;
241                 else
242                         *rightout = (signed short)dr;
243
244                 /* Increment current pointers in stream */
245                 leftout += step;
246                 rightout += step;
247         }
248 }
249
250 /* misc handling */
251
252 char dj_init(void)
253 {
254         Uint16 audio_format = MIX_DEFAULT_FORMAT;
255         int audio_channels = 2;
256         int audio_buffers = 4096;
257
258         open_screen();
259
260         if (main_info.no_sound)
261                 return 0;
262
263         audio_buffers = SAMPLECOUNT*audio_rate/11025;
264
265         memset(channelinfo, 0, sizeof(channelinfo));
266         memset(sounds, 0, sizeof(sounds));
267
268 #ifndef NO_SDL_MIXER
269         if (Mix_OpenAudio(audio_rate, audio_format, audio_channels, audio_buffers) < 0) {
270                 fprintf(stderr, "Couldn't open audio: %s\n", SDL_GetError());
271                 main_info.no_sound = 1;
272                 return 1;
273         }
274
275         Mix_QuerySpec(&audio_rate, &audio_format, &audio_channels);
276         printf("Opened audio at %dHz %dbit %s, %d bytes audio buffer\n", audio_rate, (audio_format & 0xFF), (audio_channels > 1) ? "stereo" : "mono", audio_buffers);
277
278         Mix_SetMusicCMD(getenv("MUSIC_CMD"));
279
280         Mix_SetPostMix(mix_sound, NULL);
281 #else
282         main_info.no_sound = 1;
283         return 1;
284 #endif
285
286         return 0;
287 }
288
289 void dj_deinit(void)
290 {
291         if (main_info.no_sound)
292                 return;
293
294 #ifndef NO_SDL_MIXER
295         Mix_HaltMusic();
296         if (current_music)
297                 Mix_FreeMusic(current_music);
298         current_music = NULL;
299
300         Mix_CloseAudio();
301 #endif
302
303         SDL_Quit();
304 }
305
306 void dj_start(void)
307 {
308 }
309
310 void dj_stop(void)
311 {
312 }
313
314 char dj_autodetect_sd(void)
315 {
316         return 0;
317 }
318
319 char dj_set_stereo(char flag)
320 {
321         return 0;
322 }
323
324 void dj_set_auto_mix(char flag)
325 {
326 }
327
328 unsigned short dj_set_mixing_freq(unsigned short freq)
329 {
330         return freq;
331 }
332
333 void dj_set_dma_time(unsigned short time)
334 {
335 }
336
337 void dj_set_nosound(char flag)
338 {
339 }
340
341 /* mix handling */
342
343 void dj_mix(void)
344 {
345 }
346
347 /* sfx handling */
348
349 char dj_set_num_sfx_channels(char num_channels)
350 {
351         return num_channels;
352 }
353
354 void dj_set_sfx_volume(char volume)
355 {
356         if (main_info.no_sound)
357                 return;
358
359         SDL_LockAudio();
360         global_sfx_volume = volume*2;
361         SDL_UnlockAudio();
362 }
363
364 void dj_play_sfx(unsigned char sfx_num, unsigned short freq, char volume, char panning, unsigned short delay, char channel)
365 {
366         int slot;
367
368         if (main_info.music_no_sound || main_info.no_sound)
369                 return;
370
371         if (channel<0) {
372                 for (slot=0; slot<MAX_CHANNELS; slot++)
373                         if (channelinfo[slot].data==NULL)
374                                 break;
375                 if (slot>=MAX_CHANNELS)
376                         return;
377         } else
378                 slot = channel;
379
380         SDL_LockAudio();
381         addsfx((short *)sounds[sfx_num].buf, sounds[sfx_num].length, sounds[sfx_num].loop, freq, slot);
382         updateSoundParams(slot, volume*2);
383         SDL_UnlockAudio();
384 }
385
386 char dj_get_sfx_settings(unsigned char sfx_num, sfx_data *data)
387 {
388         if (main_info.no_sound)
389                 return 0;
390
391         memcpy(data, &sounds[sfx_num], sizeof(sfx_data));
392         return 0;
393 }
394
395 char dj_set_sfx_settings(unsigned char sfx_num, sfx_data *data)
396 {
397         if (main_info.no_sound)
398                 return 0;
399
400         memcpy(&sounds[sfx_num], data, sizeof(sfx_data));
401         return 0;
402 }
403
404 void dj_set_sfx_channel_volume(char channel_num, char volume)
405 {
406         if (main_info.no_sound)
407                 return;
408
409         SDL_LockAudio();
410         updateSoundParams(channel_num, volume*2);
411         SDL_UnlockAudio();
412 }
413
414 void dj_stop_sfx_channel(char channel_num)
415 {
416         if (main_info.no_sound)
417                 return;
418
419         SDL_LockAudio();
420         stopchan(channel_num);
421         SDL_UnlockAudio();
422 }
423
424 char dj_load_sfx(unsigned char * file_handle, char *filename, int file_length, char sfx_type, unsigned char sfx_num)
425 {
426         unsigned int i;
427         unsigned char *src;
428         unsigned short *dest;
429         
430         if (main_info.no_sound)
431                 return 0;
432
433         sounds[sfx_num].buf = malloc(file_length);
434
435         memcpy(sounds[sfx_num].buf, file_handle, file_length);
436
437         sounds[sfx_num].length = file_length / 2;
438         src = sounds[sfx_num].buf;
439         dest = (unsigned short *)sounds[sfx_num].buf;
440         for (i=0; i<sounds[sfx_num].length; i++)
441         {
442                 unsigned short temp;
443                 temp = src[0] + (src[1] << 8);
444                 *dest = temp;
445                 src += 2;
446                 dest++;
447         }
448         return 0;
449 }
450
451 void dj_free_sfx(unsigned char sfx_num)
452 {
453         if (main_info.no_sound)
454                 return;
455
456         free(sounds[sfx_num].buf);
457         memset(&sounds[sfx_num], 0, sizeof(sfx_data));
458 }
459
460 /* mod handling */
461
462 char dj_ready_mod(char mod_num)
463 {
464 #ifndef NO_SDL_MIXER
465         FILE *tmp;
466 # if ((defined _MSC_VER) || (defined __MINGW32__))
467         char filename[] = "jnb.tmpmusic.mod";
468 # else
469         char filename[] = "/tmp/jnb.tmpmusic.mod";
470 # endif
471         unsigned char *fp;
472         int len;
473
474         if (main_info.no_sound)
475                 return 0;
476
477         switch (mod_num) {
478         case MOD_MENU:
479                 fp = dat_open("jump.mod");
480                 len = dat_filelen("jump.mod");
481                 break;
482         case MOD_GAME:
483                 fp = dat_open("bump.mod");
484                 len = dat_filelen("bump.mod");
485                 break;
486         case MOD_SCORES:
487                 fp = dat_open("scores.mod");
488                 len = dat_filelen("scores.mod");
489                 break;
490         default:
491                 fprintf(stderr, "bogus parameter to dj_ready_mod()\n");
492                 fp = NULL;
493                 len = 0;
494                 break;
495         }
496
497         if (Mix_PlayingMusic())
498                 Mix_FadeOutMusic(1500);
499
500         if (current_music) {
501                 Mix_FreeMusic(current_music);
502                 current_music = NULL;
503         }
504
505         if (fp == NULL) {
506                 return 0;
507         }
508
509         tmp = fopen(filename, "wb");
510         if (tmp) {
511         fwrite(fp, len, 1, tmp);
512                 fflush(tmp);
513                 fclose(tmp);
514         }
515
516         current_music = Mix_LoadMUS(filename);
517         unlink(filename);
518         if (current_music == NULL) {
519                 fprintf(stderr, "Couldn't load music: %s\n", SDL_GetError());
520                 return 0;
521         }
522
523 #endif
524
525         return 0;
526 }
527
528 char dj_start_mod(void)
529 {
530 #ifndef NO_SDL_MIXER
531         if (main_info.no_sound)
532                 return 0;
533
534         Mix_VolumeMusic(0);
535         Mix_PlayMusic(current_music, -1);
536 #endif
537
538         return 0;
539 }
540
541 void dj_stop_mod(void)
542 {
543 #ifndef NO_SDL_MIXER
544         if (main_info.no_sound)
545                 return;
546
547         Mix_HaltMusic();
548 #endif
549 }
550
551 void dj_set_mod_volume(char volume)
552 {
553 #ifndef NO_SDL_MIXER
554         if (main_info.no_sound)
555                 return;
556
557         Mix_VolumeMusic(volume);
558 #endif
559 }
560
561 char dj_load_mod(unsigned char * file_handle, char *filename, char mod_num)
562 {
563         return 0;
564 }
565
566 void dj_free_mod(char mod_num)
567 {
568 }