ball/audio.c

   1 /*
   2  * Copyright (C) 2003 Robert Kooima
   3  *
   4  * NEVERBALL is  free software; you can redistribute  it and/or modify
   5  * it under the  terms of the GNU General  Public License as published
   6  * by the Free  Software Foundation; either version 2  of the License,
   7  * or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT  ANY  WARRANTY;  without   even  the  implied  warranty  of
  11  * MERCHANTABILITY or  FITNESS FOR A PARTICULAR PURPOSE.   See the GNU
  12  * General Public License for more details.
  13  */
  14
  15 #include <SDL.h>
  16 #include <SDL_mixer.h>
  17 #include <string.h>
  18
  19 #include "config.h"
  20 #include "audio.h"
  21
  22 /*---------------------------------------------------------------------------*/
  23
  24 static int audio_state = 0;
  25
  26 static Mix_Music *song;
  27 static Mix_Chunk *buff[AUD_COUNT];
  28 static int        chan[AUD_COUNT];
  29
  30 #define CH_STATE 0
  31 #define CH_MENU  1
  32 #define CH_GRAB  2
  33 #define CH_TICK  3
  34 #define CH_BUMP  4
  35 #define CH_VOICE 5
  36 #define CH_COUNT 6
  37
  38 /*---------------------------------------------------------------------------*/
  39
  40 static void chunk_load(int i, const char *filename, int channel)
  41 {
  42     buff[i] = Mix_LoadWAV(config_data(filename));
  43     chan[i] = channel;
  44 }
  45
  46 static void chunk_free(int i)
  47 {
  48     if (buff[i])
  49     {
  50         Mix_FreeChunk(buff[i]);
  51         buff[i] = NULL;
  52     }
  53 }
  54
  55 /*---------------------------------------------------------------------------*/
  56
  57 void audio_init(void)
  58 {
  59     int r = config_get_d(CONFIG_AUDIO_RATE);
  60     int b = config_get_d(CONFIG_AUDIO_BUFF);
  61
  62     if (audio_state == 0)
  63     {
  64         if (Mix_OpenAudio(r, MIX_DEFAULT_FORMAT, 1, b) == 0)
  65         {
  66             chunk_load(AUD_MENU,   "snd/menu.wav",   CH_MENU);
  67             chunk_load(AUD_START,  "snd/select.ogg", CH_VOICE);
  68             chunk_load(AUD_READY,  "snd/ready.ogg",  CH_VOICE);
  69             chunk_load(AUD_SET,    "snd/set.ogg",    CH_VOICE);
  70             chunk_load(AUD_GO,     "snd/go.ogg",     CH_VOICE);
  71             chunk_load(AUD_BALL,   "snd/ball.ogg",   CH_GRAB);
  72             chunk_load(AUD_BUMP,   "snd/bump.ogg",   CH_BUMP);
  73             chunk_load(AUD_COIN,   "snd/coin.wav",   CH_GRAB);
  74             chunk_load(AUD_TICK,   "snd/tick.ogg",   CH_TICK);
  75             chunk_load(AUD_TOCK,   "snd/tock.ogg",   CH_TICK);
  76             chunk_load(AUD_SWITCH, "snd/switch.wav", CH_STATE);
  77             chunk_load(AUD_JUMP,   "snd/jump.ogg",   CH_STATE);
  78             chunk_load(AUD_GOAL,   "snd/goal.wav",   CH_STATE);
  79             chunk_load(AUD_SCORE,  "snd/record.ogg", CH_VOICE);
  80             chunk_load(AUD_FALL,   "snd/fall.ogg",   CH_VOICE);
  81             chunk_load(AUD_TIME,   "snd/time.ogg",   CH_VOICE);
  82             chunk_load(AUD_OVER,   "snd/over.ogg",   CH_VOICE);
  83
  84             audio_state = 1;
  85
  86             audio_volume(config_get_d(CONFIG_SOUND_VOLUME),
  87                          config_get_d(CONFIG_MUSIC_VOLUME));
  88         }
  89         else
  90         {
  91             fprintf(stderr, "Sound disabled\n");
  92             audio_state = 0;
  93         }
  94     }
  95 }
  96
  97 void audio_play(int i, float v)
  98 {
  99     if (audio_state == 1 && buff[i])
 100     {
 101         Mix_VolumeChunk(buff[i], (int) (v * MIX_MAX_VOLUME));
 102         Mix_PlayChannel(chan[i], buff[i], 0);
 103     }
 104 }
 105
 106 void audio_free(void)
 107 {
 108     if (audio_state == 1)
 109     {
 110         Mix_CloseAudio();
 111
 112         chunk_free(AUD_OVER);
 113         chunk_free(AUD_TIME);
 114         chunk_free(AUD_FALL);
 115         chunk_free(AUD_SCORE);
 116         chunk_free(AUD_GOAL);
 117         chunk_free(AUD_JUMP);
 118         chunk_free(AUD_SWITCH);
 119         chunk_free(AUD_TOCK);
 120         chunk_free(AUD_TICK);
 121         chunk_free(AUD_COIN);
 122         chunk_free(AUD_BUMP);
 123         chunk_free(AUD_BALL);
 124         chunk_free(AUD_GO);
 125         chunk_free(AUD_SET);
 126         chunk_free(AUD_READY);
 127         chunk_free(AUD_START);
 128         chunk_free(AUD_MENU);
 129
 130         audio_state = 0;
 131     }
 132 }
 133
 134 /*---------------------------------------------------------------------------*/
 135
 136 static const char *current = NULL;
 137 static const char *next    = NULL;
 138
 139 static float fade_volume = 1.0f;
 140 static float fade_rate   = 0.0f;
 141
 142 void audio_music_play(const char *filename)
 143 {
 144     if (audio_state)
 145     {
 146         audio_music_stop();
 147
 148         if ((config_get_d(CONFIG_MUSIC_VOLUME) > 0) &&
 149             (song = Mix_LoadMUS(config_data(filename))))
 150         {
 151             Mix_PlayMusic(song, -1);
 152             current = filename;
 153         }
 154     }
 155 }
 156
 157 void audio_music_queue(const char *filename)
 158 {
 159     if (audio_state)
 160     {
 161         if (!current || strcmp(filename, current) != 0)
 162         {
 163             Mix_VolumeMusic(0);
 164             fade_volume = 0.0f;
 165
 166             audio_music_play(filename);
 167             current = filename;
 168
 169             Mix_PauseMusic();
 170         }
 171     }
 172 }
 173
 174 void audio_music_stop(void)
 175 {
 176     if (audio_state)
 177     {
 178         if (Mix_PlayingMusic())
 179             Mix_HaltMusic();
 180
 181         if (song)
 182             Mix_FreeMusic(song);
 183
 184         song = NULL;
 185     }
 186 }
 187
 188 /*---------------------------------------------------------------------------*/
 189 /*
 190  * SDL_mixer already provides music fading.  Unfortunately, it halts playback
 191  * at the end of a fade.  We need to be able to fade music back in from the
 192  * point where it stopped.  So, we reinvent this wheel.
 193  */
 194
 195 void audio_timer(float dt)
 196 {
 197     if (audio_state)
 198     {
 199         if (fade_rate > 0.0f || fade_rate < 0.0f)
 200             fade_volume += dt / fade_rate;
 201
 202         if (fade_volume < 0.0f)
 203         {
 204             fade_volume = 0.0f;
 205
 206             if (next == NULL)
 207             {
 208                 fade_rate = 0.0f;
 209                 if (Mix_PlayingMusic())
 210                     Mix_PauseMusic();
 211             }
 212             else
 213             {
 214                 fade_rate = -fade_rate;
 215                 audio_music_queue(next);
 216             }
 217
 218         }
 219
 220         if (fade_volume > 1.0f)
 221         {
 222             fade_rate   = 0.0f;
 223             fade_volume = 1.0f;
 224         }
 225
 226         if (Mix_PausedMusic() && fade_rate > 0.0f)
 227             Mix_ResumeMusic();
 228
 229         if (Mix_PlayingMusic())
 230             Mix_VolumeMusic(config_get_d(CONFIG_MUSIC_VOLUME) *
 231                             (int) (fade_volume * MIX_MAX_VOLUME) / 10);
 232     }
 233 }
 234
 235 void audio_music_fade_out(float t)
 236 {
 237     fade_rate = -t;
 238     next = NULL;
 239 }
 240
 241 void audio_music_fade_in(float t)
 242 {
 243     fade_rate = +t;
 244     next = NULL;
 245 }
 246
 247 void audio_music_fade_to(float t, const char *filename)
 248 {
 249     if (fade_volume > 0)
 250     {
 251         if (!current || strcmp(filename, current) != 0)
 252         {
 253             next = filename;
 254             fade_rate = -t;
 255         }
 256         else fade_rate = t;
 257     }
 258     else
 259     {
 260         audio_music_queue(filename);
 261         audio_music_fade_in(t);
 262     }
 263 }
 264
 265 void audio_volume(int s, int m)
 266 {
 267     if (audio_state)
 268     {
 269         Mix_Volume(-1, s * MIX_MAX_VOLUME / 10);
 270         Mix_VolumeMusic(m * MIX_MAX_VOLUME / 10);
 271     }
 272 }
 273
 274 /*---------------------------------------------------------------------------*/