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