[patch] the patch

quake2-icculus-0.16.1-mixer.patch (text/plain), 12.64 KB, created by Victor Gaydov on 2010-01-07 16:34:29 UTC

diff -Nrup ../quake2-r0.16.1/Makefile ./Makefile
--- ../quake2-r0.16.1/Makefile	2005-01-02 06:47:10.000000000 +0300
+++ ./Makefile	2010-01-06 23:45:42.000000000 +0300
@@ -30,6 +30,7 @@ BUILD_AA=NO		# build the ascii soft rend
 BUILD_QMAX=NO		# build the fancier GL graphics
 BUILD_RETEXTURE=NO	# build a version supporting retextured graphics
 BUILD_REDBLUE=NO	# build a red-blue 3d glasses renderer...
+BUILD_SDL_MIXER=NO	# build sdl mixer music player
 STATICSDL=NO
 SDLDIR=/usr/local/lib
 
@@ -488,8 +489,15 @@ QUAKE2_LNX_OBJS += $(BUILDDIR)/client/sn
 endif
 endif
 
+ifneq ($(BUILD_SDL_MIXER),YES)
+SDL_CD = cd_sdl
+else
+SDL_CD = cd_sdl_mixer
+SDLLDFLAGS += -lSDL_mixer
+endif
+
 QUAKE2_SDL_OBJS = \
-	$(BUILDDIR)/client/cd_sdl.o \
+	$(BUILDDIR)/client/$(SDL_CD).o \
 	$(BUILDDIR)/client/snd_sdl.o
 
 ifeq ($(ARCH),i386)
@@ -655,7 +663,7 @@ $(BUILDDIR)/client/snd_alsa.o :  $(LINUX
 $(BUILDDIR)/client/snd_linux.o :  $(LINUX_DIR)/snd_linux.c
 	$(DO_CC)
 
-$(BUILDDIR)/client/cd_sdl.o :     $(LINUX_DIR)/cd_sdl.c
+$(BUILDDIR)/client/$(SDL_CD).o :  $(LINUX_DIR)/$(SDL_CD).c
 	$(DO_CC) $(SDLCFLAGS)
 
 $(BUILDDIR)/client/snd_sdl.o :     $(LINUX_DIR)/snd_sdl.c
diff -Nrup ../quake2-r0.16.1/src/linux/cd_sdl_mixer.c ./src/linux/cd_sdl_mixer.c
--- ../quake2-r0.16.1/src/linux/cd_sdl_mixer.c	1970-01-01 03:00:00.000000000 +0300
+++ ./src/linux/cd_sdl_mixer.c	2010-01-07 19:26:42.000000000 +0300
@@ -0,0 +1,503 @@
+
+// Quake is a trademark of Id Software, Inc., (c) 1996 Id Software, Inc. All
+// rights reserved.
+
+/* This file substitutes CD tracks playing with reading
+ * appropriate files from music directory (~/.quake2/music or DEFAULT_BASEDIR/music).
+ * Tracks are playing using SDL Mixer library and can be in any format
+ * that the library supports. We initialize SDL Mixer in snd_sdl.c
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <string.h>
+#include <time.h>
+#include <errno.h>
+#include <dirent.h>
+
+#include "SDL.h"
+#include "SDL/SDL_mixer.h"
+
+#include "../client/client.h"
+
+#define MAX_TRACK 100
+
+
+static qboolean cdValid = false;
+static qboolean	playing = false;
+static qboolean	wasPlaying = false;
+static qboolean	wasRandom = false;
+static qboolean	initialized = false;
+static qboolean	sdl_initialized = false;
+static qboolean	enabled = true;
+static qboolean playLooping = false;
+static qboolean playRandom = false;
+static float	cdvolume;
+static byte 	remap[MAX_TRACK + 1];
+static byte		playTrack;
+static byte		maxTrack;
+static Mix_Music *music;
+
+static DIR *cddir = 0;
+static char *tracks[MAX_TRACK + 1];
+static int random_num[MAX_TRACK + 1];
+static int random_cur;
+
+cvar_t *cd_volume;
+cvar_t *cd_nocd;
+cvar_t *cd_dev;
+
+
+void CDAudio_Pause(void);
+
+static void CDAudio_Eject(void)
+{
+}
+
+static void CDAudio_CloseDoor(void)
+{
+}
+
+static void CDAudio_StopHook(void)
+{
+	playing = false;
+}
+
+static void CDAudio_FreeAudioDiskInfo(void)
+{
+	int num = 0;
+	for (; num < MAX_TRACK; num++) {
+		free(tracks[num]);
+		tracks[num] = 0;
+	}
+}
+
+static int CDAudio_GetAudioDiskInfo(void)
+{
+	struct dirent *track;
+
+	cdValid = false;
+
+	if (!cddir)
+		return -1;
+
+	int len = strlen(cd_dev->string);
+
+	if (maxTrack)
+		CDAudio_FreeAudioDiskInfo();
+
+	maxTrack = 0;
+
+	while ((track = readdir(cddir))) {
+		int num;
+		if (sscanf(track->d_name, "track%d", &num) == 1 && num >= 1 && num <= MAX_TRACK) {
+			if (num > maxTrack)
+				maxTrack = num;
+			if (!tracks[num]) {
+				tracks[num] = malloc(len + NAME_MAX + 32);
+				sprintf(tracks[num], "%s/%s", cd_dev->string, track->d_name);
+			} else {
+				Com_Printf("CDAudio: Warning: conflicting files: %s, %s. Choosing first.\n",
+					tracks[num], track->d_name);
+			}
+		}
+	}
+
+	if (maxTrack) {
+		cdValid = 1;
+		return 0;
+	}
+
+	return -1;
+}
+
+void CDAudio_Play(int track, qboolean looping)
+{
+	if (cddir == 0 || !enabled)
+		return;
+	
+	if (!cdValid)
+	{
+		CDAudio_GetAudioDiskInfo();
+		if (!cdValid)
+			return;
+	}
+
+	track = remap[track];
+
+	if (track < 1 || track > MAX_TRACK)
+	{
+		Com_Printf("CDAudio: Bad track number %u.\n", track);
+		return;
+	}
+
+	if (!tracks[track]) {
+		Com_Printf("CDAudio: No file for track %u found.\n", track);
+		return;
+	}
+
+	if (playing)
+	{
+		if (playTrack == track)
+			return;
+
+		Mix_HaltMusic();
+	}
+
+	if (music)
+		Mix_FreeMusic(music);
+
+	music = Mix_LoadMUS(tracks[track]);
+	if (music == NULL) 
+	{
+		Com_Printf("Unable to load track file: %s\n", Mix_GetError());
+		return;
+	}
+
+	if (Mix_PlayMusic(music, looping ? -1 : 1) == -1) 
+	{
+		Com_Printf("Unable to play file: %s\n", Mix_GetError());
+		return;
+	}
+
+	playLooping = looping;
+	playRandom = wasRandom;
+	wasRandom = false;
+	playTrack = track;
+	playing = true;
+
+	if (cd_volume->value == 0.0)
+		CDAudio_Pause ();
+}
+
+void CDAudio_RandomPlay(void)
+{
+	if (cddir == 0 || !enabled)
+		return;
+
+	if (!random_num[random_cur]) {
+		static byte seen[MAX_TRACK + 1];
+		int i = 0;
+
+		memset(seen, 0, MAX_TRACK + 1);
+		srand(time(0));
+
+		while (i < maxTrack) {
+			float f = ((float)rand()) / ((float)RAND_MAX + 1.0);
+			int track = (int)(MAX_TRACK  * f) + 1;
+
+			if (tracks[track] && !seen[track]) {
+				random_num[i] = track;
+				seen[track]++;
+				i++;
+			}
+		}
+		random_cur = 0;
+		random_num[maxTrack] = 0;
+	}
+
+	wasRandom = true;
+	CDAudio_Play(random_num[random_cur++], false);
+}
+
+void CDAudio_Stop(void)
+{
+	if (cddir == 0 || !enabled)
+		return;
+	
+	if (!playing)
+		return;
+
+	if (music) {
+		Mix_HaltMusic();
+		Mix_FreeMusic(music);
+		music = 0;
+	}
+
+	wasPlaying = false;
+	playing = false;
+	playRandom = false;
+}
+
+void CDAudio_Pause(void)
+{
+
+	if (cddir == 0 || !enabled)
+		return;
+
+	if (!playing)
+		return;
+
+	Mix_PauseMusic();
+	wasPlaying = playing;
+	playing = false;
+}
+
+void CDAudio_Resume(void)
+{
+	if (cddir == 0 || !enabled)
+		return;
+	
+	if (!cdValid)
+		return;
+
+	if (!wasPlaying)
+		return;
+
+	Mix_ResumeMusic();
+	playing = true;
+}
+
+static void CD_f (void)
+{
+	char	*command;
+	int		ret;
+	int		n;
+
+	if (Cmd_Argc() < 2)
+		return;
+
+	command = Cmd_Argv (1);
+
+	if (Q_strcasecmp(command, "on") == 0)
+	{
+		enabled = true;
+		return;
+	}
+
+	if (Q_strcasecmp(command, "off") == 0)
+	{
+		if (playing)
+			CDAudio_Stop();
+		enabled = false;
+		return;
+	}
+
+	if (Q_strcasecmp(command, "reset") == 0)
+	{
+		enabled = true;
+		if (playing)
+			CDAudio_Stop();
+		for (n = 1; n <= MAX_TRACK; n++)
+			remap[n] = n;
+		CDAudio_GetAudioDiskInfo();
+		return;
+	}
+
+	if (Q_strcasecmp(command, "remap") == 0)
+	{
+		ret = Cmd_Argc() - 2;
+		if (ret <= 0)
+		{
+			for (n = 1; n <= MAX_TRACK; n++)
+				if (remap[n] != n)
+					Com_Printf("  %u -> %u\n", n, remap[n]);
+			return;
+		}
+		for (n = 1; n <= ret; n++)
+			remap[n] = atoi(Cmd_Argv (n+1));
+		return;
+	}
+
+	if (Q_strcasecmp(command, "close") == 0)
+	{
+		CDAudio_CloseDoor();
+		return;
+	}
+
+	if (!cdValid)
+	{
+		CDAudio_GetAudioDiskInfo();
+		if (!cdValid)
+		{
+			Com_Printf("No music found.\n");
+			return;
+		}
+	}
+
+	if (Q_strcasecmp(command, "play") == 0)
+	{
+		CDAudio_Play((byte)atoi(Cmd_Argv (2)), false);
+		return;
+	}
+
+	if (Q_strcasecmp(command, "loop") == 0)
+	{
+		CDAudio_Play((byte)atoi(Cmd_Argv (2)), true);
+		return;
+	}
+
+	if (Q_strcasecmp(command, "random") == 0)
+	{
+		CDAudio_RandomPlay();
+		return;
+	}
+
+	if (Q_strcasecmp(command, "stop") == 0)
+	{
+		CDAudio_Stop();
+		return;
+	}
+
+	if (Q_strcasecmp(command, "pause") == 0)
+	{
+		CDAudio_Pause();
+		return;
+	}
+
+	if (Q_strcasecmp(command, "resume") == 0)
+	{
+		CDAudio_Resume();
+		return;
+	}
+
+	if (Q_strcasecmp(command, "eject") == 0)
+	{
+		if (playing)
+			CDAudio_Stop();
+		CDAudio_Eject();
+		cdValid = false;
+		return;
+	}
+
+	if (Q_strcasecmp(command, "info") == 0)
+	{
+		Com_Printf("%u tracks\n", maxTrack);
+		if (playing)
+			Com_Printf("Currently %s track %u\n", playLooping ? "looping" : "playing", playTrack);
+		else if (wasPlaying)
+			Com_Printf("Paused %s track %u\n", playLooping ? "looping" : "playing", playTrack);
+		Com_Printf("Volume is %f\n", cdvolume);
+		return;
+	}
+}
+
+void CDAudio_Update(void)
+{
+	if (cddir == 0 || !enabled)
+		return;
+
+	if(cd_nocd->value)
+	{
+		CDAudio_Stop();
+		return;
+	}
+
+	if (cd_volume && cd_volume->value != cdvolume)
+	{
+		if (cdvolume)
+		{
+			Cvar_SetValue ("cd_volume", 0.0);
+			cdvolume = cd_volume->value;
+			CDAudio_Pause ();
+		}
+		else
+		{
+			Cvar_SetValue ("cd_volume", 1.0);
+			cdvolume = cd_volume->value;
+			CDAudio_Resume ();
+		}
+		Mix_Volume(-1, cd_volume->value);
+	}
+
+	if (!playing && playRandom)
+		CDAudio_RandomPlay();
+}
+
+int CDAudio_Init(void)
+{
+	int i;
+	cvar_t			*cv;
+
+	if (initialized)
+		return 0;
+
+	cv = Cvar_Get ("nocdaudio", "0", CVAR_NOSET);
+	if (cv->value)
+		return -1;
+
+	cd_nocd = Cvar_Get ("cd_nocd", "0", CVAR_ARCHIVE );
+	if ( cd_nocd->value)
+		return -1;
+
+	if (!SDL_WasInit(SDL_INIT_AUDIO)) {
+		Com_Printf("CDAudio_Init: SDL audio was not initialized.\n");
+		return -1;
+	}
+	if (!Mix_QuerySpec(0, 0, 0)) {
+		Com_Printf("CDAudio_Init: SDL Mixer was not initialized.\n");
+		return -1;
+	}
+
+	cd_volume = Cvar_Get ("cd_volume", "1", CVAR_ARCHIVE);
+	cd_dev = Cvar_Get("cd_dir", 0, CVAR_ARCHIVE);
+
+	if (!cd_dev) {
+		char *value = 0, *home = getenv("HOME");
+
+		if (home) {
+			value = malloc(strlen(home) + 64);
+			sprintf(value, "%s/.quake2/music", home);
+			if (access(value, R_OK))
+				home = 0;
+		}
+
+		if (!home) {
+			if (!value)
+				value = malloc(strlen(DEFAULT_BASEDIR) + 64);
+			sprintf(value, DEFAULT_BASEDIR "/music");
+		}
+
+		cd_dev = Cvar_Set("cd_dir", value);
+		free(value);
+	}
+
+	cddir = opendir(cd_dev->string);
+
+	if (cddir == 0) {
+	  Com_Printf("CDAudio_Init: open of \"%s\" failed (%i)\n", cd_dev->string, errno);
+	  return -1;
+	}
+
+	for (i = 1; i <= MAX_TRACK; i++)
+		remap[i] = i;
+	initialized = true;
+	enabled = true;
+
+	Mix_HookMusicFinished(CDAudio_StopHook);
+
+	if (CDAudio_GetAudioDiskInfo())
+	{
+		Com_Printf("CDAudio_Init: No music found.\n");
+		cdValid = false;
+	}
+
+	Cmd_AddCommand ("cd", CD_f);
+	Com_Printf("SDL Mixer audio initialized.\n");
+
+	return 0;
+}
+
+void CDAudio_Activate (qboolean active)
+{
+	if (active)
+		CDAudio_Resume ();
+	else
+		CDAudio_Pause ();
+}
+
+void CDAudio_Shutdown(void)
+{
+	if (!initialized)
+		return;
+	CDAudio_Stop();
+	CDAudio_FreeAudioDiskInfo();
+	closedir(cddir);
+	cddir = 0;
+	initialized = false;
+	if (sdl_initialized)
+		SDL_Quit();
+}
+
diff -Nrup ../quake2-r0.16.1/src/linux/snd_sdl.c ./src/linux/snd_sdl.c
--- ../quake2-r0.16.1/src/linux/snd_sdl.c	2002-02-09 23:29:38.000000000 +0300
+++ ./src/linux/snd_sdl.c	2010-01-07 18:05:00.000000000 +0300
@@ -26,29 +26,37 @@
 */
 
 #include "SDL.h"
+#include "SDL/SDL_mixer.h"
 
 #include "../client/client.h"
 #include "../client/snd_loc.h"
 
 static int  snd_inited;
 static dma_t *shm;
+static char *buff = 0;
+static int buff_size = 0;
 
 static void
 paint_audio (void *unused, Uint8 * stream, int len)
 {
-	if (shm) {
-		shm->buffer = stream;
-		shm->samplepos += len / (shm->samplebits / 4);
-		// Check for samplepos overflow?
-		S_PaintChannels (shm->samplepos);
-	}
+	if (!shm)
+		return;
+
+	if (buff_size < len * 4)
+		buff = realloc(buff, (buff_size = len * 4));
+
+	shm->buffer = buff;
+    shm->samplepos += len / (shm->samplebits / 4);
+
+	S_PaintChannels(shm->samplepos);
+	SDL_MixAudio(stream, buff, len, SDL_MIX_MAXVOLUME * 0.9);
 }
 
 qboolean
 SNDDMA_Init (void)
 {
 	SDL_AudioSpec desired, obtained;
-	int desired_bits, freq;
+	int desired_bits, freq, nchannels;
 	
 	if (SDL_WasInit(SDL_INIT_EVERYTHING) == 0) {
 		if (SDL_Init(SDL_INIT_AUDIO) < 0) {
@@ -100,10 +108,16 @@ SNDDMA_Init (void)
 	desired.callback = paint_audio;
 	
 	/* Open the audio device */
-	if (SDL_OpenAudio (&desired, &obtained) < 0) {
-		Com_Printf ("Couldn't open SDL audio: %s\n", SDL_GetError ());
+	if(Mix_OpenAudio(desired.freq, desired.format, desired.channels, desired.samples) != 0)
+	{
+		Com_Printf("SNDDMA_Init: Unable to initialize SDL Mixer: %s\n", Mix_GetError());
 		return 0;
 	}
+	Mix_SetPostMix(desired.callback, 0);
+
+	obtained = desired;
+	Mix_QuerySpec(&obtained.freq, &obtained.format, &nchannels);
+	obtained.channels = nchannels;
 
 	/* Make sure we can support the audio format */
 	switch (obtained.format) {
@@ -121,16 +135,10 @@ SNDDMA_Init (void)
 			}
 			/* Unsupported, fall through */ ;
 		default:
-			/* Not supported -- force SDL to do our bidding */
-			SDL_CloseAudio ();
-			if (SDL_OpenAudio (&desired, NULL) < 0) {
-				Com_Printf ("Couldn't open SDL audio: %s\n", SDL_GetError ());
-				return 0;
-			}
-			memcpy (&obtained, &desired, sizeof (desired));
-			break;
+			/* Not supported */
+			Com_Printf ("SNDDMA_Init: SDL audio format unsupported.\n", SDL_GetError ());
+			return 0;
 	}
-	SDL_PauseAudio (0);
 
 	/* Fill the audio DMA information block */
 	shm = &dma;