marrub
/
spingle
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
spingle/source/bgmusic.c

384 lines
8.3 KiB
C
Raw Permalink Blame History

/*
* Background music handling for Quakespasm (adapted from uHexen2)
* Handles streaming music as raw sound samples and runs the midi driver
*
* Copyright (C) 1999-2005 Id Software, Inc.
* Copyright (C) 2010-2018 O.Sezer <sezero@users.sourceforge.net>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
#include "q_defs.h"
#include "snd_codec.h"
#include "bgmusic.h"
#include "cdaudio.h"
#define MUSIC_DIRNAME "music"
bool bgm_loop;
cvar_t bgm_extmusic = {"bgm_extmusic", "1", CVAR_ARCHIVE};
static bool no_extmusic = false;
static float old_volume = -1.0f;
typedef struct music_handler_s
{
uint32_t type;
const char *ext;
} music_handler_t;
static music_handler_t music_handlers[] =
{
#if USE_CODEC_FLAC
{ CODECTYPE_FLAC, "flac" },
#endif
#if USE_CODEC_OPUS
{ CODECTYPE_OPUS, "opus" },
#endif
#if USE_CODEC_VORBIS
{ CODECTYPE_VORBIS, "ogg" },
#endif
#if USE_CODEC_MOD
{ CODECTYPE_MOD, "it" },
{ CODECTYPE_MOD, "s3m" },
{ CODECTYPE_MOD, "xm" },
{ CODECTYPE_MOD, "mod" },
{ CODECTYPE_UMX, "umx" },
#endif
{ CODECTYPE_NONE, NULL }
};
static snd_stream_t *bgmstream = NULL;
static void BGM_Play_f(void)
{
if(Cmd_Argc() == 2)
{
BGM_Play(Cmd_Argv(1));
}
else
{
Con_Printf("music <musicfile>\n");
return;
}
}
static void BGM_Pause_f(void)
{
BGM_Pause();
}
static void BGM_Resume_f(void)
{
BGM_Resume();
}
static void BGM_Loop_f(void)
{
if(Cmd_Argc() == 2)
{
if(q_strcasecmp(Cmd_Argv(1), "0") == 0 ||
q_strcasecmp(Cmd_Argv(1), "off") == 0)
bgm_loop = false;
else if(q_strcasecmp(Cmd_Argv(1), "1") == 0 ||
q_strcasecmp(Cmd_Argv(1), "on") == 0)
bgm_loop = true;
else if(q_strcasecmp(Cmd_Argv(1), "toggle") == 0)
bgm_loop = !bgm_loop;
}
if(bgm_loop)
Con_Printf("Music will be looped\n");
else
Con_Printf("Music will not be looped\n");
}
static void BGM_Stop_f(void)
{
BGM_Stop();
}
void BGM_Init(void)
{
Cvar_RegisterVariable(&bgm_extmusic);
Cmd_AddCommand("music", BGM_Play_f);
Cmd_AddCommand("music_pause", BGM_Pause_f);
Cmd_AddCommand("music_resume", BGM_Resume_f);
Cmd_AddCommand("music_loop", BGM_Loop_f);
Cmd_AddCommand("music_stop", BGM_Stop_f);
if(COM_CheckParm("-noextmusic") != 0)
no_extmusic = true;
bgm_loop = true;
CDAudio_Init();
}
void BGM_Shutdown(void)
{
BGM_Stop();
/* sever our connections to
* midi_drv and snd_codec */
CDAudio_Shutdown();
}
static void BGM_Play_noext(const char *filename, uint32_t allowed_types)
{
char tmp[MAX_QPATH];
music_handler_t *handler;
for(handler = music_handlers; handler->type != CODECTYPE_NONE; handler++)
{
if(!(handler->type & allowed_types))
continue;
q_snprintf(tmp, sizeof(tmp), "%s/%s.%s", MUSIC_DIRNAME, filename, handler->ext);
bgmstream = S_CodecOpenStreamType(tmp, handler->type);
if(bgmstream)
return;
}
Con_Printf("Couldn't handle music file %s\n", filename);
}
void BGM_Play(const char *filename)
{
char tmp[MAX_QPATH];
const char *ext;
music_handler_t *handler;
BGM_Stop();
if(!filename || !*filename)
{
Con_DPrintf("null music file name\n");
return;
}
ext = COM_FileGetExtension(filename);
if(! *ext) /* try all things */
{
BGM_Play_noext(filename, ANY_CODECTYPE);
return;
}
for(handler = music_handlers; handler->type != CODECTYPE_NONE; handler++)
{
if(!q_strcasecmp(ext, handler->ext))
break;
}
if(handler->type == CODECTYPE_NONE)
{
Con_Printf("Unhandled extension for %s\n", filename);
return;
}
q_snprintf(tmp, sizeof(tmp), "%s/%s", MUSIC_DIRNAME, filename);
bgmstream = S_CodecOpenStreamType(tmp, handler->type);
if(bgmstream)
return; /* success */
Con_Printf("Couldn't handle music file %s\n", filename);
}
void BGM_PlayCDTrack(byte track, bool looping)
{
/* instead of searching by the order of music_handlers, do so by
* the order of searchpath priority: the file from the searchpath
* with the highest path_id is most likely from our own gamedir
* itself. This way, if a mod has track02 as a *.mp3 file, which
* is below *.ogg in the music_handler order, the mp3 will still
* have priority over track02.ogg from, say, id1.
*/
char tmp[MAX_QPATH];
const char *ext;
uint32_t path_id, prev_id, type;
music_handler_t *handler;
BGM_Stop();
if(CDAudio_Play(track, looping) == 0)
return; /* success */
if(no_extmusic || !bgm_extmusic.value)
return;
prev_id = 0;
type = 0;
ext = NULL;
for(handler = music_handlers; handler->type != CODECTYPE_NONE; handler++)
{
if(!CDRIPTYPE(handler->type))
continue;
printf("%s\n", handler->ext);
q_snprintf(tmp, sizeof(tmp), "%s/track%02i.%s", MUSIC_DIRNAME, track, handler->ext);
if(!COM_FileExists(tmp, &path_id))
continue;
if(path_id > prev_id)
{
prev_id = path_id;
type = handler->type;
ext = handler->ext;
}
}
if(ext == NULL)
Con_Printf("Couldn't find a cdrip for track %" PRIi32 "\n", (int32_t)track);
else
{
q_snprintf(tmp, sizeof(tmp), "%s/track%02i.%s", MUSIC_DIRNAME, track, ext);
bgmstream = S_CodecOpenStreamType(tmp, type);
if(! bgmstream)
Con_Printf("Couldn't handle music file %s\n", tmp);
}
}
void BGM_Stop(void)
{
if(bgmstream)
{
bgmstream->status = STREAM_NONE;
S_CodecCloseStream(bgmstream);
bgmstream = NULL;
s_rawend = 0;
}
CDAudio_Stop();
}
void BGM_Pause(void)
{
if(bgmstream)
{
if(bgmstream->status == STREAM_PLAY)
bgmstream->status = STREAM_PAUSE;
}
CDAudio_Pause();
}
void BGM_Resume(void)
{
if(bgmstream)
{
if(bgmstream->status == STREAM_PAUSE)
bgmstream->status = STREAM_PLAY;
}
CDAudio_Resume();
}
static void BGM_UpdateStream(void)
{
bool did_rewind = false;
int32_t res; /* Number of bytes read. */
int32_t bufferSamples;
int32_t fileSamples;
int32_t fileBytes;
byte raw[16384];
if(bgmstream->status != STREAM_PLAY)
return;
/* don't bother playing anything if musicvolume is 0 */
if(bgmvolume.value <= 0)
return;
/* see how many samples should be copied into the raw buffer */
if(s_rawend < paintedtime)
s_rawend = paintedtime;
while(s_rawend < paintedtime + MAX_RAW_SAMPLES)
{
bufferSamples = MAX_RAW_SAMPLES - (s_rawend - paintedtime);
/* decide how much data needs to be read from the file */
fileSamples = bufferSamples * bgmstream->info.rate / shm->speed;
if(!fileSamples)
return;
/* our max buffer size */
fileBytes = fileSamples * (bgmstream->info.width * bgmstream->info.channels);
if(fileBytes > (int32_t) sizeof(raw))
{
fileBytes = (int32_t) sizeof(raw);
fileSamples = fileBytes /
(bgmstream->info.width * bgmstream->info.channels);
}
/* Read */
res = S_CodecReadStream(bgmstream, fileBytes, raw);
if(res < fileBytes)
{
fileBytes = res;
fileSamples = res / (bgmstream->info.width * bgmstream->info.channels);
}
if(res > 0) /* data: add to raw buffer */
{
S_RawSamples(fileSamples, bgmstream->info.rate,
bgmstream->info.width,
bgmstream->info.channels,
raw, bgmvolume.value);
did_rewind = false;
}
else if(res == 0) /* EOF */
{
if(bgm_loop)
{
if(did_rewind)
{
Con_Printf("Stream keeps returning EOF.\n");
BGM_Stop();
return;
}
res = S_CodecRewindStream(bgmstream);
if(res != 0)
{
Con_Printf("Stream seek error (%" PRIi32 "), stopping.\n", res);
BGM_Stop();
return;
}
did_rewind = true;
}
else
{
BGM_Stop();
return;
}
}
else /* res < 0: some read error */
{
Con_Printf("Stream read error (%" PRIi32 "), stopping.\n", res);
BGM_Stop();
return;
}
}
}
void BGM_Update(void)
{
if(old_volume != bgmvolume.value)
{
if(bgmvolume.value < 0)
Cvar_SetQuick(&bgmvolume, "0");
else if(bgmvolume.value > 1)
Cvar_SetQuick(&bgmvolume, "1");
old_volume = bgmvolume.value;
}
if(bgmstream)
BGM_UpdateStream();
CDAudio_Update();
}
Reference in New Issue View Git Blame Copy Permalink