TakeV/dxx-rebirth
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

* Huge SDL_mixer refactoring; sound backend now selectable at runtime, in D1X & D2X

Browse source 
* Sound system now uses a set of function pointers (digi.c) as a single interface to either SDL or SDL_mixer
* Ported jukebox functionality to D2X
This commit is contained in:
md2211 2007-09-18 13:37:39 +00:00
parent 7ab0e53e2d
commit 324c0df6a1
18 changed files with 1093 additions and 549 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
CHANGELOG.txt
View file

@ -1,5 +1,11 @@
D2X-Rebirth Changelog
20070918
--------
SConstruct, main/inferno.c, main/digi.h, arch/sdl/include/digi_audio.h, arch/sdl/include/digi_mixer_music.h, arch/sdl/include/digi_mixer.h, arch/sdl/digi.c, arch/sdl/digi_mixer.c, arch/sdl/digi_mixer_music.c, arch/sdl/digi_audio.c : huge refactoring of sound system using function pointers, to allow sound backend selection at runtime and provide a common interface (digi.c)
include/args.h, main/args.c : handle SDL_mixer-specific args
arch/sdl/jukebox.c, arch/sdl/jukebox.c, include/dl_list.h, misc/dl_list.c : added jukebox functionality
20070913
--------
main/game.c, main/gamecntl.c, main/multi.c, main/network.c: Code Re-formatting; Preventing Redundancy in Restricted-game joining; Dumping refused player back to Join-menu; Expanded Game-help screen

30
SConstruct
View file

@ -79,6 +79,8 @@ common_sources = [
'arch/sdl/mouse.c',
'arch/sdl/rbaudio.c',
'arch/sdl/timer.c',
'arch/sdl/digi.c',
'arch/sdl/digi_audio.c',
'iff/iff.c',
'libmve/decoder8.c',
'libmve/decoder16.c',
@ -159,6 +161,7 @@ common_sources = [
'main/weapon.c',
'mem/mem.c',
'misc/args.c',
'misc/dl_list.c',
'misc/error.c',
'misc/hash.c',
'misc/ignorecase.c',
@ -247,18 +250,16 @@ arch_linux_sources = [
'arch/linux/ukali.c',
]
# choosing a sound implementation for *nix
common_sound_hmp2mid = [ 'misc/hmp2mid.c' ]
arch_unix_sound_sdlmixer = [ 'arch/sdl/mixdigi.c', 'arch/sdl/mixmusic.c' ]
arch_unix_sound_old = [ 'arch/sdl/digi.c' ]
#arch_linux_sound_old = ['arch/linux/hmiplay.c' ]
# SDL_mixer sound implementation
arch_sdlmixer = [
'misc/hmp2mid.c',
'arch/sdl/digi_mixer.c',
'arch/sdl/digi_mixer_music.c',
'arch/sdl/jukebox.c'
]
if (sdlmixer == 1):
common_sources += common_sound_hmp2mid
arch_unix_sources += arch_unix_sound_sdlmixer
else:
arch_unix_sources += arch_unix_sound_old
# arch_linux_sources += arch_linux_sound_old
arch_linux_sources += arch_sdlmixer
# for windows
arch_win32_sources = [
@ -318,12 +319,19 @@ env.ParseConfig('sdl-config --libs')
env.Append(CPPFLAGS = ['-Wall', '-funsigned-char'])
env.Append(CPPDEFINES = [('D2XMAJOR', '\\"' + str(D2XMAJOR) + '\\"'), ('D2XMINOR', '\\"' + str(D2XMINOR) + '\\"')])
#env.Append(CPPDEFINES = [('VERSION', '\\"' + str(VERSION) + '\\"')])
env.Append(CPPDEFINES = [('USE_SDLMIXER', sdlmixer)])
#env.Append(CPPDEFINES = [('USE_SDLMIXER', sdlmixer)])
env.Append(CPPDEFINES = ['NMONO', 'PIGGY_USE_PAGING', 'NETWORK', 'HAVE_NETIPX_IPX_H', 'NEWDEMO', '_REENTRANT'])
env.Append(CPPPATH = ['include', 'main', 'arch/include'])
generic_libs = ['SDL', 'physfs']
sdlmixerlib = ['SDL_mixer']
if sdlmixer:
env.Append(CPPDEFINES = ['USE_SDLMIXER'])
if (D2XMICRO):
env.Append(CPPDEFINES = [('D2XMICRO', '\\"' + str(D2XMICRO) + '\\"')])
# Get traditional compiler environment variables
if os.environ.has_key('CC'):
env['CC'] = os.environ['CC']

28
arch/include/digi_audio.h Normal file
View file

@ -0,0 +1,28 @@
#ifndef __DIGI_AUDIO__
#define __DIGI_AUDIO__
#include "fix.h"
int digi_audio_init();
void digi_audio_reset();
void digi_audio_close();
void digi_audio_stop_all_channels();
int digi_audio_start_sound(short, fix, int, int, int, int, int );
int digi_audio_find_channel(int );
int digi_audio_is_sound_playing(int );
void digi_audio_set_max_channels(int );
int digi_audio_get_max_channels();
int digi_audio_is_channel_playing(int );
void digi_audio_set_channel_volume(int, int );
void digi_audio_set_channel_pan(int, int );
void digi_audio_stop_sound(int );
void digi_audio_end_sound(int );
void digi_audio_play_midi_song( char *, char *, char *, int );
void digi_audio_set_digi_volume(int);
void digi_audio_set_midi_volume(int);
void digi_audio_stop_current_song();
void digi_audio_pause_midi();
void digi_audio_resume_midi();
void digi_audio_debug();
#endif

28
arch/include/digi_mixer.h Normal file
View file

@ -0,0 +1,28 @@
#ifndef __DIGI_MIXER__
#define __DIGI_MIXER__
#include "fix.h"
int digi_mixer_init();
void digi_mixer_close();
int digi_mixer_start_sound(short, fix, int, int, int, int, int);
void digi_mixer_set_channel_volume(int, int);
void digi_mixer_set_channel_pan(int, int);
void digi_mixer_stop_sound(int);
void digi_mixer_end_sound(int);
int digi_mixer_find_channel(int);
int digi_mixer_is_sound_playing(int);
int digi_mixer_is_channel_playing(int);
void digi_mixer_reset();
void digi_set_max_channels(int);
int digi_get_max_channels();
void digi_mixer_stop_all_channels();
void digi_mixer_play_midi_song(char *, char *, char *, int);
void digi_mixer_set_midi_volume(int);
void digi_mixer_set_digi_volume(int);
void digi_mixer_stop_current_song();
void digi_mixer_pause_midi();
void digi_mixer_resume_midi();
void digi_mixer_debug();
#endif

5
arch/include/mixmusic.h → arch/include/digi_mixer_music.h
View file

@ -7,8 +7,9 @@
#ifndef _SDLMIXER_MUSIC_H
#define _SDLMIXER_MUSIC_H
void mix_play_music(char *filename, int loop);
void mix_set_music_volume(int vol);
void mix_play_music(char *, int);
void mix_play_file(char *, char *, int);
void mix_set_music_volume(int);
void mix_stop_music();
#endif

15
arch/include/jukebox.h Normal file
View file

@ -0,0 +1,15 @@
#ifndef __JUKEBOX_H__
#define __JUKEBOX_H__
void jukebox_load();
void jukebox_play();
void jukebox_stop();
void jukebox_stop_hook();
void jukebox_next();
void jukebox_prev();
char *jukebox_current();
int jukebox_is_loaded();
int jukebox_is_playing();
void jukebox_list();
#endif

562
arch/sdl/digi.c
View file

@ -1,9 +1,6 @@
/* $Id: digi.c,v 1.1.1.1 2006/03/17 19:53:41 zicodxx Exp $ */
/*
*
* SDL digital audio support
*
*
* Digital audio support
* Library-independent stub for dynamic selection of sound system
*/
#ifdef HAVE_CONFIG_H
@ -14,470 +11,127 @@
#include <stdio.h>
#include <string.h>
#include <SDL/SDL.h>
#include <digi.h>
#include <digi_audio.h>
#include "pstypes.h"
#include "error.h"
#include "mono.h"
#include "fix.h"
#include "vecmat.h"
#include "gr.h" // needed for piggy.h
#include "piggy.h"
#include "digi.h"
#include "sounds.h"
#include "wall.h"
#include "newdemo.h"
#include "kconfig.h"
//edited 05/17/99 Matt Mueller - added ifndef NO_ASM
//added on 980905 by adb to add inline fixmul for mixer on i386
#ifndef NO_ASM
#ifdef __i386__
#define do_fixmul(x,y) \
({ \
int _ax, _dx; \
asm("imull %2\n\tshrdl %3,%1,%0" \
: "=a"(_ax), "=d"(_dx) \
: "rm"(y), "i"(16), "0"(x)); \
_ax; \
})
extern inline fix fixmul(fix x, fix y) { return do_fixmul(x,y); }
#endif
#endif
//end edit by adb
//end edit -MM
//changed on 980905 by adb to increase number of concurrent sounds
#define MAX_SOUND_SLOTS 32
//end changes by adb
#ifdef GP2X
#define SOUND_BUFFER_SIZE 64
#else
#define SOUND_BUFFER_SIZE 512
#ifdef USE_SDLMIXER
#include <digi_mixer.h>
#endif
#define MIN_VOLUME 10
/* Sound system function pointers */
/* This table is used to add two sound values together and pin
* the value to avoid overflow. (used with permission from ARDI)
* DPH: Taken from SDL/src/SDL_mixer.c.
*/
static const Uint8 mix8[] =
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03,
0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,
0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24,
0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A,
0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45,
0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50,
0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B,
0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71,
0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C,
0x7D, 0x7E, 0x7F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92,
0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D,
0x9E, 0x9F, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3,
0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE,
0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9,
0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4,
0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA,
0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5,
0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
};
int (*fptr_init)() = NULL;
void (*fptr_close)() = NULL;
void (*fptr_reset)() = NULL;
void (*fptr_set_channel_volume)(int, int) = NULL;
void (*fptr_set_channel_pan)(int, int) = NULL;
//added/changed on 980905 by adb to make sfx volume work, on 990221 by adb changed F1_0 to F1_0 / 2
#define SOUND_MAX_VOLUME (F1_0 / 2)
int (*fptr_start_sound)(short, fix, int, int, int, int, int) = NULL;
void (*fptr_stop_sound)(int) = NULL;
void (*fptr_end_sound)(int) = NULL;
int (*fptr_find_channel)(int) = NULL;
int (*fptr_is_sound_playing)(int) = NULL;
int (*fptr_is_channel_playing)(int) = NULL;
void (*fptr_stop_all_channels)() = NULL;
void (*fptr_set_digi_volume)(int) = NULL;
void (*fptr_play_midi_song)(char *, char *, char *, int) = NULL;
void (*fptr_set_midi_volume)(int) = NULL;
void (*fptr_stop_current_song)() = NULL;
void (*fptr_pause_midi)() = NULL;
void (*fptr_resume_midi)() = NULL;
void digi_select_system(int n) {
switch (n) {
#ifdef USE_SDLMIXER
case SDLMIXER_SYSTEM:
printf("Using SDL_mixer library\n");
fptr_init = digi_mixer_init;
fptr_close = digi_mixer_close;
fptr_reset = digi_mixer_reset;
fptr_set_channel_volume = digi_mixer_set_channel_volume;
fptr_set_channel_pan = digi_mixer_set_channel_pan;
fptr_start_sound = digi_mixer_start_sound;
fptr_stop_sound = digi_mixer_stop_sound;
fptr_end_sound = digi_mixer_end_sound;
fptr_find_channel = digi_mixer_find_channel;
fptr_is_sound_playing = digi_mixer_is_sound_playing;
fptr_is_channel_playing = digi_mixer_is_channel_playing;
fptr_stop_all_channels = digi_mixer_stop_all_channels;
fptr_play_midi_song = digi_mixer_play_midi_song;
fptr_stop_current_song = digi_mixer_stop_current_song;
fptr_pause_midi = digi_mixer_pause_midi;
fptr_resume_midi = digi_mixer_resume_midi;
fptr_set_midi_volume = digi_mixer_set_midi_volume;
fptr_set_digi_volume = digi_mixer_set_digi_volume;
break;
#endif
case SDLAUDIO_SYSTEM:
default:
printf("Using plain old SDL audio\n");
fptr_init = digi_audio_init;
fptr_close = digi_audio_close;
fptr_reset = digi_audio_reset;
fptr_set_channel_volume = digi_audio_set_channel_volume;
fptr_set_channel_pan = digi_audio_set_channel_pan;
fptr_start_sound = digi_audio_start_sound;
fptr_stop_sound = digi_audio_stop_sound;
fptr_end_sound = digi_audio_end_sound;
fptr_find_channel = digi_audio_find_channel;
fptr_is_sound_playing = digi_audio_is_sound_playing;
fptr_is_channel_playing = digi_audio_is_channel_playing;
fptr_stop_all_channels = digi_audio_stop_all_channels;
fptr_play_midi_song = digi_audio_play_midi_song;
fptr_stop_current_song = digi_audio_stop_current_song;
fptr_pause_midi = digi_audio_pause_midi;
fptr_resume_midi = digi_audio_resume_midi;
fptr_set_midi_volume = digi_audio_set_midi_volume;
fptr_set_digi_volume = digi_audio_set_digi_volume;
break;
}
}
/* Common digi functions */
int digi_sample_rate = SAMPLE_RATE_22K;
int digi_volume = SOUND_MAX_VOLUME;
//end edit by adb
int midi_volume = SOUND_MAX_VOLUME;
static int digi_initialised = 0;
struct sound_slot {
int soundno;
int playing; // Is there a sample playing on this channel?
int looped; // Play this sample looped?
fix pan; // 0 = far left, 1 = far right
fix volume; // 0 = nothing, 1 = fully on
//changed on 980905 by adb from char * to unsigned char *
unsigned char *samples;
//end changes by adb
unsigned int length; // Length of the sample
unsigned int position; // Position we are at at the moment.
int soundobj; // Which soundobject is on this channel
int persistent; // This can't be pre-empted
} SoundSlots[MAX_SOUND_SLOTS];
static SDL_AudioSpec WaveSpec;
static int digi_max_channels = 16;
static int next_channel = 0;
/* Audio mixing callback */
//changed on 980905 by adb to cleanup, add pan support and optimize mixer
static void audio_mixcallback(void *userdata, Uint8 *stream, int len)
{
Uint8 *streamend = stream + len;
struct sound_slot *sl;
if (!digi_initialised)
return;
memset(stream, 0x80, len); // fix "static" sound bug on Mac OS X
for (sl = SoundSlots; sl < SoundSlots + MAX_SOUND_SLOTS; sl++) {
if (sl->playing) {
Uint8 *sldata = sl->samples + sl->position, *slend = sl->samples + sl->length;
Uint8 *sp = stream, s;
signed char v;
fix vl, vr;
int x;
if ((x = sl->pan) & 0x8000) {
vl = 0x20000 - x * 2;
vr = 0x10000;
} else {
vl = 0x10000;
vr = x * 2;
}
vl = fixmul(vl, (x = sl->volume));
vr = fixmul(vr, x);
while (sp < streamend) {
if (sldata == slend) {
if (!sl->looped) {
sl->playing = 0;
break;
}
sldata = sl->samples;
}
v = *(sldata++) - 0x80;
s = *sp;
*(sp++) = mix8[ s + fixmul(v, vl) + 0x80 ];
s = *sp;
*(sp++) = mix8[ s + fixmul(v, vr) + 0x80 ];
}
sl->position = sldata - sl->samples;
}
}
}
//end changes by adb
/* Initialise audio devices. */
int digi_init()
{
if (SDL_InitSubSystem(SDL_INIT_AUDIO)<0) {
Error("SDL audio initialisation failed: %s.",SDL_GetError());
}
WaveSpec.freq = GameArg.SndDigiSampleRate;
//added/changed by Sam Lantinga on 12/01/98 for new SDL version
WaveSpec.format = AUDIO_U8;
WaveSpec.channels = 2;
//end this section addition/change - SL
WaveSpec.samples = SOUND_BUFFER_SIZE;
WaveSpec.callback = audio_mixcallback;
if ( SDL_OpenAudio(&WaveSpec, NULL) < 0 ) {
//edited on 10/05/98 by Matt Mueller - should keep running, just with no sound.
Warning("\nError: Couldn't open audio: %s\n", SDL_GetError());
//killed exit(2);
return 1;
//end edit -MM
}
SDL_PauseAudio(0);
atexit(digi_close);
digi_initialised = 1;
return 0;
void digi_set_volume(int dvolume, int mvolume) {
digi_volume = dvolume;
midi_volume = mvolume;
if (fptr_set_digi_volume) digi_set_digi_volume(dvolume);
if (fptr_set_midi_volume) digi_set_midi_volume(mvolume);
}
/* Toggle audio */
void digi_reset() { }
void digi_set_sample_rate(int r) { digi_sample_rate = r; }
/* Shut down audio */
void digi_close()
{
if (!digi_initialised) return;
digi_initialised = 0;
#ifdef __MINGW32__
SDL_Delay(500); // CloseAudio hangs if it's called too soon after opening?
#endif
SDL_CloseAudio();
}
/* Stub functions */
void digi_stop_all_channels()
{
int i;
int digi_init() { return fptr_init(); }
void digi_close() { fptr_close(); }
void digi_reset() { fptr_reset(); }
for (i = 0; i < MAX_SOUND_SLOTS; i++)
digi_stop_sound(i);
}
void digi_set_channel_volume(int channel, int volume) { fptr_set_channel_volume(channel, volume); }
void digi_set_channel_pan(int channel, int pan) { fptr_set_channel_pan(channel, pan); }
int digi_start_sound(short soundnum, fix volume, int pan, int looping, int loop_start, int loop_end, int soundobj) { return fptr_start_sound(soundnum, volume, pan, looping, loop_start, loop_end, soundobj); }
void digi_stop_sound(int channel) { fptr_stop_sound(channel); }
void digi_end_sound(int channel) { fptr_end_sound(channel); }
extern void digi_end_soundobj(int channel);
extern int SoundQ_channel;
extern void SoundQ_end();
int verify_sound_channel_free(int channel);
int digi_find_channel(int soundno) { return fptr_find_channel(soundno); }
int digi_is_sound_playing(int soundno) { return fptr_is_sound_playing(soundno); }
int digi_is_channel_playing(int channel) { return fptr_is_channel_playing(channel); }
void digi_stop_all_channels() { fptr_stop_all_channels(); }
void digi_set_max_channels(int n) { }
int digi_get_max_channels() { return 0; }
void digi_set_digi_volume(int dvolume) { fptr_set_digi_volume(dvolume); }
// Volume 0-F1_0
int digi_start_sound(short soundnum, fix volume, int pan, int looping, int loop_start, int loop_end, int soundobj)
{
int i, starting_channel;
void digi_play_midi_song(char * filename, char * melodic_bank, char * drum_bank, int loop ) { fptr_play_midi_song(filename, melodic_bank, drum_bank, loop); }
void digi_set_midi_volume(int mvolume) { fptr_set_midi_volume(mvolume); }
void digi_stop_current_song() { fptr_stop_current_song(); }
void digi_pause_midi() { fptr_pause_midi(); }
void digi_resume_midi() { fptr_resume_midi(); }
if (!digi_initialised) return -1;
if (soundnum < 0) return -1;
Assert(GameSounds[soundnum].data != (void *)-1);
starting_channel = next_channel;
while(1)
{
if (!SoundSlots[next_channel].playing)
break;
if (!SoundSlots[next_channel].persistent)
break; // use this channel!
next_channel++;
if (next_channel >= digi_max_channels)
next_channel = 0;
if (next_channel == starting_channel)
{
mprintf((1, "OUT OF SOUND CHANNELS!!!\n"));
return -1;
}
}
if (SoundSlots[next_channel].playing)
{
SoundSlots[next_channel].playing = 0;
if (SoundSlots[next_channel].soundobj > -1)
{
digi_end_soundobj(SoundSlots[next_channel].soundobj);
}
if (SoundQ_channel == next_channel)
SoundQ_end();
}
#ifndef NDEBUG
verify_sound_channel_free(next_channel);
#endif
SoundSlots[next_channel].soundno = soundnum;
SoundSlots[next_channel].samples = GameSounds[soundnum].data;
SoundSlots[next_channel].length = GameSounds[soundnum].length;
SoundSlots[next_channel].volume = fixmul(digi_volume, volume);
SoundSlots[next_channel].pan = pan;
SoundSlots[next_channel].position = 0;
SoundSlots[next_channel].looped = looping;
SoundSlots[next_channel].playing = 1;
SoundSlots[next_channel].soundobj = soundobj;
SoundSlots[next_channel].persistent = 0;
if ((soundobj > -1) || (looping) || (volume > F1_0))
SoundSlots[next_channel].persistent = 1;
i = next_channel;
next_channel++;
if (next_channel >= digi_max_channels)
next_channel = 0;
return i;
}
// Returns the channel a sound number is playing on, or
// -1 if none.
int digi_find_channel(int soundno)
{
if (!digi_initialised)
return -1;
if (soundno < 0 )
return -1;
if (GameSounds[soundno].data == NULL)
{
Int3();
return -1;
}
//FIXME: not implemented
return -1;
}
//added on 980905 by adb from original source to make sfx volume work
void digi_set_digi_volume( int dvolume )
{
dvolume = fixmuldiv( dvolume, SOUND_MAX_VOLUME, 0x7fff);
if ( dvolume > SOUND_MAX_VOLUME )
digi_volume = SOUND_MAX_VOLUME;
else if ( dvolume < 0 )
digi_volume = 0;
else
digi_volume = dvolume;
if ( !digi_initialised ) return;
digi_sync_sounds();
}
//end edit by adb
void digi_set_volume( int dvolume, int mvolume )
{
digi_set_digi_volume(dvolume);
digi_set_midi_volume(mvolume);
// mprintf(( 1, "Volume: 0x%x and 0x%x\n", digi_volume, midi_volume ));
}
int digi_is_sound_playing(int soundno)
{
int i;
soundno = digi_xlat_sound(soundno);
for (i = 0; i < MAX_SOUND_SLOTS; i++)
//changed on 980905 by adb: added SoundSlots[i].playing &&
if (SoundSlots[i].playing && SoundSlots[i].soundno == soundno)
//end changes by adb
return 1;
return 0;
}
//added on 980905 by adb to make sound channel setting work
void digi_set_max_channels(int n) {
digi_max_channels = n;
if ( digi_max_channels < 1 )
digi_max_channels = 1;
if (digi_max_channels > MAX_SOUND_SLOTS)
digi_max_channels = MAX_SOUND_SLOTS;
if ( !digi_initialised ) return;
digi_stop_all_channels();
}
int digi_get_max_channels() {
return digi_max_channels;
}
// end edit by adb
int digi_is_channel_playing(int channel)
{
if (!digi_initialised)
return 0;
return SoundSlots[channel].playing;
}
void digi_set_channel_volume(int channel, int volume)
{
if (!digi_initialised)
return;
if (!SoundSlots[channel].playing)
return;
SoundSlots[channel].volume = fixmuldiv(volume, digi_volume, F1_0);
}
void digi_set_channel_pan(int channel, int pan)
{
if (!digi_initialised)
return;
if (!SoundSlots[channel].playing)
return;
SoundSlots[channel].pan = pan;
}
void digi_stop_sound(int channel)
{
SoundSlots[channel].playing=0;
SoundSlots[channel].soundobj = -1;
SoundSlots[channel].persistent = 0;
}
void digi_end_sound(int channel)
{
if (!digi_initialised)
return;
if (!SoundSlots[channel].playing)
return;
SoundSlots[channel].soundobj = -1;
SoundSlots[channel].persistent = 0;
}
#ifndef _WIN32
// MIDI stuff follows.
void digi_set_midi_volume( int mvolume ) { }
void digi_play_midi_song( char * filename, char * melodic_bank, char * drum_bank, int loop ) {}
void digi_stop_current_song()
{
#ifdef HMIPLAY
char buf[10];
sprintf(buf,"s");
send_ipc(buf);
#endif
}
void digi_pause_midi() {}
void digi_resume_midi() {}
#endif
#ifndef NDEBUG
void digi_debug()
{
int i;
int n_voices = 0;
if (!digi_initialised)
return;
for (i = 0; i < digi_max_channels; i++)
{
if (digi_is_channel_playing(i))
n_voices++;
}
mprintf_at((0, 2, 0, "DIGI: Active Sound Channels: %d/%d (HMI says %d/32) ", n_voices, digi_max_channels, -1));
//mprintf_at((0, 3, 0, "DIGI: Number locked sounds: %d ", digi_total_locks ));
}
#endif

473
arch/sdl/digi_audio.c Normal file
View file

@ -0,0 +1,473 @@
/* $Id: digi.c,v 1.1.1.1 2006/03/17 19:53:41 zicodxx Exp $ */
/*
*
* SDL digital audio support
*
*
*/
#ifdef HAVE_CONFIG_H
#include <conf.h>
#endif
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <SDL/SDL.h>
#include <digi_audio.h>
#include "pstypes.h"
#include "error.h"
#include "mono.h"
#include "fix.h"
#include "vecmat.h"
#include "gr.h"
#include "piggy.h"
#include "digi.h"
#include "sounds.h"
#include "wall.h"
#include "newdemo.h"
#include "kconfig.h"
//edited 05/17/99 Matt Mueller - added ifndef NO_ASM
//added on 980905 by adb to add inline fixmul for mixer on i386
#ifndef NO_ASM
#ifdef __i386__
#define do_fixmul(x,y) \
({ \
int _ax, _dx; \
asm("imull %2\n\tshrdl %3,%1,%0" \
: "=a"(_ax), "=d"(_dx) \
: "rm"(y), "i"(16), "0"(x)); \
_ax; \
})
extern inline fix fixmul(fix x, fix y) { return do_fixmul(x,y); }
#endif
#endif
//end edit by adb
//end edit -MM
//changed on 980905 by adb to increase number of concurrent sounds
#define MAX_SOUND_SLOTS 32
//end changes by adb
#ifdef GP2X
#define SOUND_BUFFER_SIZE 64
#else
#define SOUND_BUFFER_SIZE 512
#endif
#define MIN_VOLUME 10
/* This table is used to add two sound values together and pin
* the value to avoid overflow. (used with permission from ARDI)
* DPH: Taken from SDL/src/SDL_mixer.c.
*/
static const Uint8 mix8[] =
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03,
0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,
0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24,
0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A,
0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45,
0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50,
0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B,
0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71,
0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C,
0x7D, 0x7E, 0x7F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92,
0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D,
0x9E, 0x9F, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3,
0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE,
0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9,
0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4,
0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA,
0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5,
0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
};
static int digi_initialised = 0;
struct sound_slot {
int soundno;
int playing; // Is there a sample playing on this channel?
int looped; // Play this sample looped?
fix pan; // 0 = far left, 1 = far right
fix volume; // 0 = nothing, 1 = fully on
//changed on 980905 by adb from char * to unsigned char *
unsigned char *samples;
//end changes by adb
unsigned int length; // Length of the sample
unsigned int position; // Position we are at at the moment.
int soundobj; // Which soundobject is on this channel
int persistent; // This can't be pre-empted
} SoundSlots[MAX_SOUND_SLOTS];
static SDL_AudioSpec WaveSpec;
static int digi_max_channels = 16;
static int next_channel = 0;
void digi_stop_sound(int channel);
int digi_xlat_sound(int soundno);
/* Audio mixing callback */
//changed on 980905 by adb to cleanup, add pan support and optimize mixer
static void audio_mixcallback(void *userdata, Uint8 *stream, int len)
{
Uint8 *streamend = stream + len;
struct sound_slot *sl;
if (!digi_initialised)
return;
memset(stream, 0x80, len); // fix "static" sound bug on Mac OS X
for (sl = SoundSlots; sl < SoundSlots + MAX_SOUND_SLOTS; sl++) {
if (sl->playing) {
Uint8 *sldata = sl->samples + sl->position, *slend = sl->samples + sl->length;
Uint8 *sp = stream, s;
signed char v;
fix vl, vr;
int x;
if ((x = sl->pan) & 0x8000) {
vl = 0x20000 - x * 2;
vr = 0x10000;
} else {
vl = 0x10000;
vr = x * 2;
}
vl = fixmul(vl, (x = sl->volume));
vr = fixmul(vr, x);
while (sp < streamend) {
if (sldata == slend) {
if (!sl->looped) {
sl->playing = 0;
break;
}
sldata = sl->samples;
}
v = *(sldata++) - 0x80;
s = *sp;
*(sp++) = mix8[ s + fixmul(v, vl) + 0x80 ];
s = *sp;
*(sp++) = mix8[ s + fixmul(v, vr) + 0x80 ];
}
sl->position = sldata - sl->samples;
}
}
}
//end changes by adb
/* Initialise audio devices. */
int digi_audio_init()
{
if (SDL_InitSubSystem(SDL_INIT_AUDIO)<0) {
Error("SDL audio initialisation failed: %s.",SDL_GetError());
}
WaveSpec.freq = digi_sample_rate;
//added/changed by Sam Lantinga on 12/01/98 for new SDL version
WaveSpec.format = AUDIO_U8;
WaveSpec.channels = 2;
//end this section addition/change - SL
WaveSpec.samples = SOUND_BUFFER_SIZE;
WaveSpec.callback = audio_mixcallback;
if ( SDL_OpenAudio(&WaveSpec, NULL) < 0 ) {
//edited on 10/05/98 by Matt Mueller - should keep running, just with no sound.
Warning("\nError: Couldn't open audio: %s\n", SDL_GetError());
//killed exit(2);
return 1;
//end edit -MM
}
SDL_PauseAudio(0);
atexit(digi_close);
digi_initialised = 1;
return 0;
}
/* Toggle audio */
void digi_audio_reset() { }
/* Shut down audio */
void digi_audio_close()
{
if (!digi_initialised) return;
digi_initialised = 0;
#ifdef __MINGW32__
SDL_Delay(500); // CloseAudio hangs if it's called too soon after opening?
#endif
SDL_CloseAudio();
}
void digi_audio_stop_all_channels()
{
int i;
for (i = 0; i < MAX_SOUND_SLOTS; i++)
digi_audio_stop_sound(i);
}
extern void digi_end_soundobj(int channel);
extern int SoundQ_channel;
extern void SoundQ_end();
int verify_sound_channel_free(int channel);
// Volume 0-F1_0
int digi_audio_start_sound(short soundnum, fix volume, int pan, int looping, int loop_start, int loop_end, int soundobj)
{
int i, starting_channel;
if (!digi_initialised) return -1;
if (soundnum < 0) return -1;
Assert(GameSounds[soundnum].data != (void *)-1);
starting_channel = next_channel;
while(1)
{
if (!SoundSlots[next_channel].playing)
break;
if (!SoundSlots[next_channel].persistent)
break; // use this channel!
next_channel++;
if (next_channel >= digi_max_channels)
next_channel = 0;
if (next_channel == starting_channel)
{
mprintf((1, "OUT OF SOUND CHANNELS!!!\n"));
return -1;
}
}
if (SoundSlots[next_channel].playing)
{
SoundSlots[next_channel].playing = 0;
if (SoundSlots[next_channel].soundobj > -1)
{
digi_end_soundobj(SoundSlots[next_channel].soundobj);
}
if (SoundQ_channel == next_channel)
SoundQ_end();
}
#ifndef NDEBUG
verify_sound_channel_free(next_channel);
#endif
SoundSlots[next_channel].soundno = soundnum;
SoundSlots[next_channel].samples = GameSounds[soundnum].data;
SoundSlots[next_channel].length = GameSounds[soundnum].length;
SoundSlots[next_channel].volume = fixmul(digi_volume, volume);
SoundSlots[next_channel].pan = pan;
SoundSlots[next_channel].position = 0;
SoundSlots[next_channel].looped = looping;
SoundSlots[next_channel].playing = 1;
SoundSlots[next_channel].soundobj = soundobj;
SoundSlots[next_channel].persistent = 0;
if ((soundobj > -1) || (looping) || (volume > F1_0))
SoundSlots[next_channel].persistent = 1;
i = next_channel;
next_channel++;
if (next_channel >= digi_max_channels)
next_channel = 0;
return i;
}
// Returns the channel a sound number is playing on, or
// -1 if none.
int digi_audio_find_channel(int soundno)
{
if (!digi_initialised)
return -1;
if (soundno < 0 )
return -1;
if (GameSounds[soundno].data == NULL)
{
Int3();
return -1;
}
//FIXME: not implemented
return -1;
}
//added on 980905 by adb from original source to make sfx volume work
void digi_audio_set_digi_volume( int dvolume )
{
dvolume = fixmuldiv( dvolume, SOUND_MAX_VOLUME, 0x7fff);
if ( dvolume > SOUND_MAX_VOLUME )
digi_volume = SOUND_MAX_VOLUME;
else if ( dvolume < 0 )
digi_volume = 0;
else
digi_volume = dvolume;
if ( !digi_initialised ) return;
digi_sync_sounds();
}
//end edit by adb
int digi_audio_is_sound_playing(int soundno)
{
int i;
soundno = digi_xlat_sound(soundno);
for (i = 0; i < MAX_SOUND_SLOTS; i++)
//changed on 980905 by adb: added SoundSlots[i].playing &&
if (SoundSlots[i].playing && SoundSlots[i].soundno == soundno)
//end changes by adb
return 1;
return 0;
}
//added on 980905 by adb to make sound channel setting work
void digi_audio_set_max_channels(int n) {
digi_max_channels = n;
if ( digi_max_channels < 1 )
digi_max_channels = 1;
if (digi_max_channels > MAX_SOUND_SLOTS)
digi_max_channels = MAX_SOUND_SLOTS;
if ( !digi_initialised ) return;
digi_stop_all_channels();
}
int digi_audio_get_max_channels() {
return digi_max_channels;
}
// end edit by adb
int digi_audio_is_channel_playing(int channel)
{
if (!digi_initialised)
return 0;
return SoundSlots[channel].playing;
}
void digi_audio_set_channel_volume(int channel, int volume)
{
if (!digi_initialised)
return;
if (!SoundSlots[channel].playing)
return;
SoundSlots[channel].volume = fixmuldiv(volume, digi_volume, F1_0);
}
void digi_audio_set_channel_pan(int channel, int pan)
{
if (!digi_initialised)
return;
if (!SoundSlots[channel].playing)
return;
SoundSlots[channel].pan = pan;
}
void digi_audio_stop_sound(int channel)
{
SoundSlots[channel].playing=0;
SoundSlots[channel].soundobj = -1;
SoundSlots[channel].persistent = 0;
}
void digi_audio_end_sound(int channel)
{
if (!digi_initialised)
return;
if (!SoundSlots[channel].playing)
return;
SoundSlots[channel].soundobj = -1;
SoundSlots[channel].persistent = 0;
}
#ifndef _WIN32
// MIDI stuff follows.
void digi_audio_set_midi_volume( int mvolume ) { }
void digi_audio_play_midi_song( char * filename, char * melodic_bank, char * drum_bank, int loop ) {}
void digi_audio_stop_current_song()
{
#ifdef HMIPLAY
char buf[10];
sprintf(buf,"s");
send_ipc(buf);
#endif
}
void digi_audio_pause_midi() {}
void digi_audio_resume_midi() {}
#endif
#ifndef NDEBUG
void digi_audio_debug()
{
int i;
int n_voices = 0;
if (!digi_initialised)
return;
for (i = 0; i < digi_max_channels; i++)
{
if (digi_is_channel_playing(i))
n_voices++;
}
mprintf_at((0, 2, 0, "DIGI: Active Sound Channels: %d/%d (HMI says %d/32) ", n_voices, digi_max_channels, -1));
//mprintf_at((0, 3, 0, "DIGI: Number locked sounds: %d ", digi_total_locks ));
}
#endif

146
arch/sdl/mixdigi.c → arch/sdl/digi_mixer.c
View file

@ -20,27 +20,23 @@
#include <SDL/SDL_audio.h>
#include <SDL/SDL_mixer.h>
#include "mixmusic.h"
#include "pstypes.h"
#include "error.h"
#include "mono.h"
#include "sounds.h"
#include "digi.h"
#include "digi_mixer.h"
#include "digi_mixer_music.h"
#include "jukebox.h"
#include "fix.h"
#include "gr.h" // needed for piggy.h
#include "piggy.h"
#include "digi.h"
#include "sounds.h"
#include "wall.h"
#include "newdemo.h"
#include "kconfig.h"
#define MIX_DIGI_DEBUG 0
#define MIX_OUTPUT_FREQUENCY 44100 // in 2006, we can afford it!
#define MIX_OUTPUT_FORMAT AUDIO_S16
#define MIX_OUTPUT_CHANNELS 2
//MD2211 - added 2006/12/12 to correctly remember music volume
static int midi_volume = F1_0;
//edited 05/17/99 Matt Mueller - added ifndef NO_ASM
//added on 980905 by adb to add inline fixmul for mixer on i386
#ifndef NO_ASM
@ -60,26 +56,22 @@ extern inline fix fixmul(fix x, fix y) { return do_fixmul(x,y); }
//end edit -MM
#define MAX_SOUND_SLOTS 64
#define SOUND_BUFFER_SIZE 2048
#define MIN_VOLUME 0
//added/changed on 980905 by adb to make sfx volume work, on 990221 by adb changed F1_0 to F1_0 / 2
#define SOUND_MAX_VOLUME (F1_0 / 2)
int digi_volume = SOUND_MAX_VOLUME;
//end edit by adb
#define SOUND_BUFFER_SIZE 4096
#define MIN_VOLUME 10
static int digi_initialised = 0;
static int digi_max_channels = MAX_SOUND_SLOTS;
inline int fix2byte(fix f) { return (f / 256) % 256; }
Mix_Chunk SoundChunks[MAX_SOUNDS];
/* Initialise audio */
int digi_init() {
int digi_mixer_init() {
digi_sample_rate = SAMPLE_RATE_44K;
if (MIX_DIGI_DEBUG) printf("digi_init %d (SDL_Mixer)\n", MAX_SOUNDS);
if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) Error("SDL audio initialisation failed: %s.", SDL_GetError());
if (Mix_OpenAudio(MIX_OUTPUT_FREQUENCY, MIX_OUTPUT_FORMAT, MIX_OUTPUT_CHANNELS, SOUND_BUFFER_SIZE)) {
if (Mix_OpenAudio(digi_sample_rate, MIX_OUTPUT_FORMAT, MIX_OUTPUT_CHANNELS, SOUND_BUFFER_SIZE)) {
//edited on 10/05/98 by Matt Mueller - should keep running, just with no sound.
printf("\nError: Couldn't open audio: %s\n", SDL_GetError());
return 1;
@ -88,13 +80,18 @@ int digi_init() {
Mix_AllocateChannels(digi_max_channels);
Mix_Pause(0);
// Attempt to load jukebox
jukebox_load();
//jukebox_list();
atexit(digi_close);
digi_initialised = 1;
return 0;
}
/* Shut down audio */
void digi_close() {
void digi_mixer_close() {
if (!digi_initialised) return;
digi_initialised = 0;
Mix_CloseAudio();
@ -109,14 +106,14 @@ void mixdigi_convert_sound(int i) {
SDL_AudioCVT cvt;
Uint8 *data = GameSounds[i].data;
Uint32 dlen = GameSounds[i].length;
int freq = GameArg.SndDigiSampleRate; //FIXME: assuming 22 KHz for now, but Descent 2 supports multiple sampling rates
int freq = GameArg.SndDigiSampleRate;
//int bits = GameSounds[i].bits;
if (SoundChunks[i].abuf) return; //proceed only if not converted yet
if (data) {
if (MIX_DIGI_DEBUG) printf("converting %d (%d)\n", i, dlen);
SDL_BuildAudioCVT(&cvt, AUDIO_U8, 1, freq, MIX_OUTPUT_FORMAT, MIX_OUTPUT_CHANNELS, MIX_OUTPUT_FREQUENCY);
SDL_BuildAudioCVT(&cvt, AUDIO_U8, 1, freq, MIX_OUTPUT_FORMAT, MIX_OUTPUT_CHANNELS, digi_sample_rate);
cvt.buf = malloc(dlen * cvt.len_mult);
cvt.len = dlen;
@ -126,12 +123,12 @@ void mixdigi_convert_sound(int i) {
SoundChunks[i].abuf = cvt.buf;
SoundChunks[i].alen = dlen * cvt.len_mult;
SoundChunks[i].allocated = 1;
SoundChunks[i].volume = 128; // Max volume (SDL) = 128
SoundChunks[i].volume = 128; // Max volume = 128
}
}
// Volume 0-F1_0
int digi_start_sound(short soundnum, fix volume, int pan, int looping, int loop_start, int loop_end, int soundobj)
int digi_mixer_start_sound(short soundnum, fix volume, int pan, int looping, int loop_start, int loop_end, int soundobj)
{
if (!digi_initialised) return -1;
Assert(GameSounds[soundnum].data != (void *)-1);
@ -151,94 +148,87 @@ int digi_start_sound(short soundnum, fix volume, int pan, int looping, int loop_
return channel;
}
void digi_set_channel_volume(int channel, int volume) {
if (MIX_DIGI_DEBUG) printf("digi_set_channel_volume %d %d\n", channel, volume);
void digi_mixer_set_channel_volume(int channel, int volume) {
if (!digi_initialised) return;
int mix_vol = fix2byte(volume);
Mix_SetDistance(channel, 255-mix_vol);
}
void digi_set_channel_pan(int channel, int pan) {
void digi_mixer_set_channel_pan(int channel, int pan) {
int mix_pan = fix2byte(pan);
Mix_SetPanning(channel, 255-mix_pan, mix_pan);
}
void digi_stop_sound(int channel) {
void digi_mixer_stop_sound(int channel) {
if (!digi_initialised) return;
if (MIX_DIGI_DEBUG) printf("digi_stop_sound %d\n", channel);
Mix_HaltChannel(channel);
}
void digi_end_sound(int channel) {
digi_stop_sound(channel);
void digi_mixer_end_sound(int channel) {
digi_mixer_stop_sound(channel);
}
void digi_set_digi_volume( int dvolume )
void digi_mixer_set_digi_volume( int dvolume )
{
digi_volume = dvolume;
if (!digi_initialised) return;
if (MIX_DIGI_DEBUG) printf("digi_set_digi_volume %d\n", dvolume);
int mix_vol = fix2byte(dvolume);
Mix_Volume(-1, mix_vol);
Mix_Volume(-1, fix2byte(dvolume));
}
//added on 980905 by adb from original source to make sfx volume work
/*
void digi_set_digi_volume( int dvolume )
{
dvolume = fixmuldiv( dvolume, SOUND_MAX_VOLUME, 0x7fff);
if ( dvolume > SOUND_MAX_VOLUME )
digi_volume = SOUND_MAX_VOLUME;
else if ( dvolume < 0 )
digi_volume = 0;
else
digi_volume = dvolume;
if ( !digi_initialised ) return;
digi_sync_sounds();
}
*/
//end edit by adb
void digi_set_volume( int dvolume, int mvolume ) {
if (MIX_DIGI_DEBUG) printf("digi_set_volume %d %d\n", dvolume, mvolume);
digi_set_digi_volume(dvolume);
digi_set_midi_volume(mvolume);
void digi_mixer_set_midi_volume( int mvolume ) {
midi_volume = mvolume;
if (!digi_initialised) return;
mix_set_music_volume(mvolume);
}
int digi_find_channel(int soundno) { return 0; }
int digi_is_sound_playing(int soundno) { return 0; }
int digi_is_channel_playing(int channel) { return 0; }
void digi_reset() {}
void digi_stop_all_channels() {}
void digi_mixer_set_volume( int dvolume, int mvolume ) {
digi_mixer_set_digi_volume(dvolume);
digi_mixer_set_midi_volume(mvolume);
}
int digi_mixer_find_channel(int soundno) { return 0; }
int digi_mixer_is_sound_playing(int soundno) { return 0; }
int digi_mixer_is_channel_playing(int channel) { return 0; }
void digi_mixer_reset() {}
void digi_mixer_stop_all_channels() {}
extern void digi_end_soundobj(int channel);
int verify_sound_channel_free(int channel);
//added on 980905 by adb to make sound channel setting work
void digi_set_max_channels(int n) { digi_max_channels = n; }
int digi_get_max_channels() { return digi_max_channels; }
void digi_mixer_set_max_channels(int n) { }
int digi_mixer_get_max_channels() { return digi_max_channels; }
// end edit by adb
// MIDI stuff follows.
#ifndef _WIN32
void digi_set_midi_volume( int mvolume ) {
midi_volume = mvolume;
mix_set_music_volume(mvolume);
}
void digi_play_midi_song( char * filename, char * melodic_bank, char * drum_bank, int loop ) {
void digi_mixer_play_midi_song(char * filename, char * melodic_bank, char * drum_bank, int loop ) {
mix_set_music_volume(midi_volume);
mix_play_music(filename, loop);
// quick hack to check if filename begins with "game" -- MD2211
if (jukebox_is_loaded() && strstr(filename, "game") == filename) {
// use jukebox
jukebox_play();
}
else {
// standard song playback
mix_play_music(filename, loop);
}
}
void digi_stop_current_song() {
mix_stop_music();
void digi_mixer_stop_current_song() {
jukebox_stop(); //stops jukebox as well as standard music
}
#endif
void digi_pause_midi() {}
void digi_resume_midi() {}
void digi_mixer_pause_midi() {}
void digi_mixer_resume_midi() {}
#ifndef NDEBUG
void digi_debug() {}
void digi_mixer_debug() {}
#endif

31
arch/sdl/mixmusic.c → arch/sdl/digi_mixer_music.c
View file

@ -66,6 +66,10 @@ void convert_hmp(char *filename, char *mid_filename) {
}
}
/*
* Plays a music given its name (regular game songs)
*/
void mix_play_music(char *filename, int loop) {
loop *= -1;
@ -152,6 +156,33 @@ void mix_play_music(char *filename, int loop) {
}
}
/*
* Plays a music file from an absolute path (used by jukebox)
*/
void mix_play_file(char *basedir, char *filename, int loop) {
int fn_buf_len = strlen(basedir) + strlen(filename) + 1;
char real_filename[fn_buf_len];
sprintf(real_filename, "%s%s", basedir, filename); // build absolute path
if ((current_music = Mix_LoadMUS(real_filename))) {
if (Mix_PlayingMusic()) {
// Fade-in effect sounds cleaner if we're already playing something
Mix_FadeInMusic(current_music, loop, MUSIC_FADE_TIME);
}
else {
Mix_PlayMusic(current_music, loop);
}
Mix_HookMusicFinished(music_done);
}
else {
fprintf(stderr, "Music %s could not be loaded%s\n", filename, basedir);
Mix_HaltMusic();
}
}
void mix_set_music_volume(int vol) {
printf("mix_set_music_volume %d\n", vol);
Mix_VolumeMusic(vol);

158
arch/sdl/jukebox.c Normal file
View file

@ -0,0 +1,158 @@
/*
* DXX Rebirth "jukebox" code
* MD 2211 <md2211@users.sourceforge.net>, 2007
*/
#include <sys/types.h>
#include <sys/dir.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "args.h"
#include "dl_list.h"
#include "hudmsg.h"
#include "digi_mixer_music.h"
#include "jukebox.h"
#define JUKEBOX_ARG "-jukebox"
#define MUSIC_HUDMSG_MAXLEN 40
#define JUKEBOX_HUDMSG_PLAYING "Now playing:"
#define JUKEBOX_HUDMSG_STOPPED "Jukebox stopped"
static int jukebox_loaded = 0;
static int jukebox_playing = 0;
static char *jukebox_path;
static dl_list *JukeboxSongs;
char hud_msg_buf[MUSIC_HUDMSG_MAXLEN+4];
char *select_prev_song(dl_list *list) {
char *ret;
if (dl_is_empty(list)) {
ret = NULL;
}
else {
if (list->first == list->current) {
list->current = list->last;
}
else {
dl_backward(list);
}
ret = (char *) list->current->data;
}
return ret;
}
char *select_next_song(dl_list *list) {
char *ret;
if (dl_is_empty(list)) {
ret = NULL;
}
else {
if (list->last == list->current) {
list->current = list->first;
}
else {
dl_forward(list);
}
ret = (char *) list->current->data;
}
return ret;
}
/* Filter for scandir(); selects MP3 and OGG, files, rejects the rest */
int file_select_all(const struct dirent *entry) {
char *fn = (char *) entry->d_name;
char *ext = strrchr(fn, '.');
int ext_ok = (ext != NULL && (!strcmp(ext, ".mp3") || !strcmp(ext, ".ogg")));
return strcmp(fn, ".") && strcmp(entry->d_name, "..") && ext_ok;
}
/* Loads music file names from a given directory */
void jukebox_load() {
int count, i, t;
struct dirent **files;
int (*file_select)(const struct dirent *) = file_select_all;
if (!jukebox_loaded) {
t = FindArg(JUKEBOX_ARG);
if (t > 0) {
jukebox_path = Args[t+1];
JukeboxSongs = dl_init();
count = scandir(jukebox_path, &files, file_select, alphasort);
printf("Jukebox: %d music file(s) found in %s\n", count, jukebox_path);
for (i=0; i<count; i++) dl_add(JukeboxSongs, files[i]->d_name);
jukebox_loaded = 1;
}
}
else { printf("Jukebox already loaded\n"); }
}
void jukebox_play() {
if (!jukebox_loaded) return;
char *music_filename = (char *) JukeboxSongs->current->data;
mix_play_file(jukebox_path, music_filename, 0);
// Formatting a pretty message
if (strlen(music_filename) >= MUSIC_HUDMSG_MAXLEN) {
strncpy(hud_msg_buf, music_filename, MUSIC_HUDMSG_MAXLEN);
strcpy(hud_msg_buf+MUSIC_HUDMSG_MAXLEN, "...");
hud_msg_buf[MUSIC_HUDMSG_MAXLEN+3] = '\0';
} else {
strcpy(hud_msg_buf, music_filename);
}
hud_message(MSGC_GAME_FEEDBACK, "%s %s", JUKEBOX_HUDMSG_PLAYING, hud_msg_buf);
jukebox_playing = 1;
}
void jukebox_stop() {
if (!jukebox_loaded) return;
mix_stop_music();
hud_message(MSGC_GAME_FEEDBACK, JUKEBOX_HUDMSG_STOPPED);
jukebox_playing = 0;
}
void jukebox_stop_hook() {
if (!jukebox_loaded) return;
if (jukebox_playing) jukebox_next();
}
void jukebox_next() {
if (!jukebox_loaded) return;
select_next_song(JukeboxSongs);
if (jukebox_playing) jukebox_play();
}
void jukebox_prev() {
if (!jukebox_loaded) return;
select_prev_song(JukeboxSongs);
if (jukebox_playing) jukebox_play();
}
char *jukebox_current() {
return JukeboxSongs->current->data;
}
int jukebox_is_loaded() { return jukebox_loaded; }
int jukebox_is_playing() { return jukebox_playing; }
void jukebox_list() {
dl_item *curr;
if (!jukebox_loaded) return;
if (dl_is_empty(JukeboxSongs)) {
printf("* No songs have been found\n");
}
else {
for (curr = JukeboxSongs->first; curr != NULL; curr = curr->next) {
printf("* %s\n", (char *) curr->data);
}
}
}

3
include/args.h
View file

@ -62,6 +62,9 @@ typedef struct Arg
int SndNoMusic;
int SndDigiSampleRate;
int SndEnableRedbook;
int SndSdlMixer;
char *SndExternalMusic;
char *SndJukebox;
float GfxAspectX;
float GfxAspectY;
int GfxGaugeHudMode;

30
include/dl_list.h Normal file
View file

@ -0,0 +1,30 @@
/*
* Doubly-linked list implementation
* MD 2211 <md2211@users.sourceforge.net>, 2007
*/
#ifndef __DL_LIST__
#define __DL_LIST__
struct dl_list_elem {
void *data;
struct dl_list_elem *prev;
struct dl_list_elem *next;
};
typedef struct dl_list_elem dl_item;
typedef struct {
struct dl_list_elem *first;
struct dl_list_elem *last;
struct dl_list_elem *current;
} dl_list;
dl_list *dl_init();
void dl_add(dl_list *, void *);
void dl_remove(dl_list *, dl_item *);
int dl_is_empty(dl_list *);
int dl_forward(dl_list *);
int dl_backward(dl_list *);
#endif

19
main/digi.h
View file

@ -42,9 +42,6 @@ typedef struct digi_sound {
} digi_sound;
#endif
#define SAMPLE_RATE_11K 11025
#define SAMPLE_RATE_22K 22050
#ifdef __DJGPP__
@ -125,4 +122,20 @@ extern void digi_stop_looping_sound();
// Plays a queued voice sound.
extern void digi_start_sound_queued( short soundnum, fix volume );
// Following declarations are for the runtime switching system
#define SAMPLE_RATE_11K 11025
#define SAMPLE_RATE_22K 22050
#define SAMPLE_RATE_44K 44100
#define SDLMIXER_SYSTEM 1
#define SDLAUDIO_SYSTEM 2
#define SOUND_MAX_VOLUME F1_0 // was (F1_0 / 2)
extern int digi_volume;
extern int midi_volume;
extern int digi_sample_rate;
void digi_select_system(int);
#endif

23
main/gamecntl.c
View file

@ -99,6 +99,8 @@ COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION. ALL RIGHTS RESERVED.
#include "rbaudio.h"
#include "switch.h"
#include "escort.h"
//MD2211
#include "jukebox.h"
//#define TEST_TIMER 1 //if this is set, do checking on timer
@ -1259,6 +1261,27 @@ int HandleSystemKey(int key)
break;
#endif
#ifdef USE_SDLMIXER
/*
* Jukebox hotkeys -- MD2211, 2007
* ==============================================
*/
case KEY_ALTED + KEY_SHIFTED + KEY_F9:
jukebox_play();
break;
case KEY_ALTED + KEY_SHIFTED + KEY_F10:
jukebox_stop();
break;
case KEY_ALTED + KEY_SHIFTED + KEY_F11:
jukebox_prev();
break;
case KEY_ALTED + KEY_SHIFTED + KEY_F12:
jukebox_next();
break;
#endif
//added 8/23/99 by Matt Mueller for hot key res/fullscreen changing, and menu access
#if 0
case KEY_CTRLED+KEY_SHIFTED+KEY_PADMULTIPLY:

15
main/inferno.c
View file

@ -354,8 +354,15 @@ int main(int argc, char *argv[])
key_init();
if (!GameArg.SndNoSound)
if (!GameArg.SndNoSound) {
digi_select_system(
GameArg.SndSdlMixer || GameArg.SndExternalMusic || GameArg.SndJukebox ?
SDLMIXER_SYSTEM : SDLAUDIO_SYSTEM
);
digi_init();
}
printf("trace 2\n");
if (!GameArg.CtlNoMouse)
d_mouse_init();
@ -395,13 +402,19 @@ int main(int argc, char *argv[])
con_printf(CON_DEBUG, "Initializing font system...\n" );
gamefont_init(); // must load after palette data loaded.
printf("trace 3\n");
con_printf( CON_DEBUG, "Initializing movie libraries...\n" );
init_movies(); //init movie libraries
printf("trace 4\n");
show_titles();
set_screen_mode(SCREEN_MENU);
printf("trace 5\n");
con_printf( CON_DEBUG , "\nDoing bm_init..." );
#ifdef EDITOR
if (!bm_init_use_tbl())

6
misc/args.c
View file

@ -235,6 +235,12 @@ void ReadCmdArgs(void)
else
GameArg.SndEnableRedbook = 0;
#ifdef USE_SDLMIXER
GameArg.SndSdlMixer = FindArg("-sdlmixer");
GameArg.SndJukebox = (t = FindArg("-jukebox") ? Args[t+1] : NULL);
GameArg.SndExternalMusic = (t = FindArg("-music_ext") ? Args[t+1] : NULL);
#endif
// Graphics Options
if ((t=FindResArg("aspect", &y, &x)))

64
misc/dl_list.c Normal file
View file

@ -0,0 +1,64 @@
/*
* Doubly-linked list implementation with position marker
* MD 2211 <md2211@users.sourceforge.net>, 2007
*/
#include <stdlib.h>
#include "dl_list.h"
dl_list *dl_init() {
dl_list *list = malloc(sizeof(dl_list));
list->first = NULL;
list->last = NULL;
list->current = NULL;
return list;
}
void dl_add(dl_list *list, void *data) {
dl_item *item;
item = malloc(sizeof(dl_item));
item->data = data;
item->prev = list->last;
item->next = NULL;
if (list->last != NULL) {
list->last->next = item;
}
if (list->first == NULL) {
list->first = item;
list->current = item;
}
list->last = item;
}
void dl_remove(dl_list *list, dl_item *item) {
if (list->current == item) list->current = item->prev;
if (list->first == item) list->first = item->next;
else item->prev->next = item->next;
if (list->last == item) list->last = item->prev;
else item->next->prev = item->prev;
free(item);
}
int dl_is_empty(dl_list *list) {
return (list->first == NULL);
}
int dl_forward(dl_list *list) {
if (!dl_is_empty(list) && list->current->next != NULL) {
list->current = list->current->next;
return 1;
}
else return 0;
}
int dl_backward(dl_list *list) {
if (!dl_is_empty(list) && list->current->prev != NULL) {
list->current = list->current->prev;
return 1;
}
else return 0;
}