void SdlAudio::BGM_Play(std::string const& file, int volume, int /* pitch */, int fadein) {
if (file.empty() || file == "(OFF)")
{
BGM_Stop();
return;
}
std::string const path = FileFinder::FindMusic(file);
if (path.empty()) {
//HACK: Polish RTP translation replaced (OFF) reserved string with (Brak)
if (file != "(Brak)")
Output::Warning("Music not found: %s", file.c_str());
BGM_Stop();
return;
}
SDL_RWops *rw = SDL_RWFromFile(path.c_str(), "rb");
#if SDL_MIXER_MAJOR_VERSION>1
bgm.reset(Mix_LoadMUS_RW(rw, 1), &Mix_FreeMusic);
#else
bgm.reset(Mix_LoadMUS_RW(rw), &Mix_FreeMusic);
#endif
if (!bgm) {
Output::Warning("Couldn't load %s BGM.\n%s\n", file.c_str(), Mix_GetError());
return;
}
#if SDL_MAJOR_VERSION>1
// SDL2_mixer produces noise when playing wav.
// Workaround: Use Mix_LoadWAV
// https://bugzilla.libsdl.org/show_bug.cgi?id=2094
if (bgs_playing) {
BGS_Stop();
}
if (Mix_GetMusicType(bgm.get()) == MUS_WAV) {
BGM_Stop();
BGS_Play(file, volume, 0, fadein);
return;
}
#endif
BGM_Volume(volume);
if (!me_stopped_bgm &&
#ifdef _WIN32
(Mix_GetMusicType(bgm.get()) == MUS_MID && WindowsUtils::GetWindowsVersion() >= 6
? Mix_PlayMusic(bgm.get(), -1) : Mix_FadeInMusic(bgm.get(), -1, fadein))
#else
Mix_FadeInMusic(bgm.get(), -1, fadein)
#endif
== -1) {
Output::Warning("Couldn't play %s BGM.\n%s\n", file.c_str(), Mix_GetError());
return;
}
}
void BGM_Shutdown (void)
{
BGM_Stop();
/* sever our connections to
* midi_drv and snd_codec */
music_handlers = NULL;
}
Psp2Audio::~Psp2Audio() {
// Just to be sure to clean up before exiting
SE_Stop();
BGM_Stop();
// Closing BGM streaming thread
termStream = true;
sceKernelWaitThreadEnd(BGM_Thread, NULL, NULL);
if (BGM != NULL){
free(BGM->audiobuf);
audio_decoder.reset();
free(BGM);
}
// Starting exit procedure for sfx threads
mustExit = true;
sceKernelSignalSema(SFX_Mutex, 1);
for (int i=0;i<AUDIO_CHANNELS;i++){
sceKernelWaitThreadEnd(sfx_threads[i], NULL, NULL);
}
sfx_exited = 0;
// Deleting mutexs
sceKernelDeleteSema(BGM_Mutex);
sceKernelDeleteSema(SFX_Mutex);
sceKernelDeleteSema(SFX_Mutex_ID);
}
void BGM_PlayCDtrack (byte track, qboolean 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, data1.
*/
char tmp[MAX_QPATH];
const char *ext;
unsigned int path_id, prev_id, type;
music_handler_t *handler;
BGM_Stop();
if (CDAudio_Play(track, looping) == 0)
return; /* success */
if (music_handlers == NULL)
return;
if (no_extmusic || !bgm_extmusic.value)
return;
prev_id = 0;
type = 0;
ext = NULL;
handler = music_handlers;
while (handler)
{
if (! handler->is_available)
goto _next;
if (! CDRIPTYPE(handler->type))
goto _next;
q_snprintf(tmp, sizeof(tmp), "%s/track%02d.%s",
MUSIC_DIRNAME, (int)track, handler->ext);
if (! FS_FileExists(tmp, &path_id))
goto _next;
if (path_id > prev_id)
{
prev_id = path_id;
type = handler->type;
ext = handler->ext;
}
_next:
handler = handler->next;
}
if (ext == NULL)
Con_Printf("Couldn't find a cdrip for track %d\n", (int)track);
else
{
q_snprintf(tmp, sizeof(tmp), "%s/track%02d.%s",
MUSIC_DIRNAME, (int)track, ext);
bgmstream = S_CodecOpenStreamType(tmp, type);
if (! bgmstream)
Con_Printf("Couldn't handle music file %s\n", tmp);
}
}
void BGM_Play (const char *filename)
{
char tmp[MAX_QPATH];
const char *ext;
music_handler_t *handler;
BGM_Stop();
if (music_handlers == NULL)
return;
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;
}
handler = music_handlers;
while (handler)
{
if (handler->is_available &&
!q_strcasecmp(ext, handler->ext))
break;
handler = handler->next;
}
if (!handler)
{
Con_Printf("Unhandled extension for %s\n", filename);
return;
}
q_snprintf(tmp, sizeof(tmp), "%s/%s", handler->dir, filename);
switch (handler->player)
{
case BGM_MIDIDRV:
/* not supported in quake */
break;
case BGM_STREAMER:
bgmstream = S_CodecOpenStreamType(tmp, handler->type);
if (bgmstream)
return; /* success */
break;
case BGM_NONE:
default:
break;
}
Con_Printf("Couldn't handle music file %s\n", filename);
}
void Audio::BGM_Play(std::string const& file, int volume, int pitch)
{
BGM_Stop();
alSourceRewind(*bgmSource_);
alSourcei(*bgmSource_, AL_BUFFER, getMusic(file));
alSourcef(*bgmSource_, AL_GAIN, volume * 0.01f);
alSourcei(*bgmSource_, AL_PITCH, pitch * 0.01f);
alSourcei(*bgmSource_, AL_LOOPING, AL_TRUE);
alSourcePlay(*bgmSource_);
}
void SdlAudio::BGM_Fade(int fade) {
#ifdef _WIN32
// FIXME: Because of design change in Vista and higher reducing Midi volume
// alters volume of whole application and mutes it forever when restarted.
// Fading out midi music was disabled for Windows.
if (Mix_GetMusicType(bgm.get()) == MUS_MID &&
WindowsUtils::GetWindowsVersion() >= 6) {
BGM_Stop();
return;
}
#endif
Mix_FadeOutMusic(fade);
me_stopped_bgm = false;
}
static void BGM_UpdateStream (void)
{
int res; /* Number of bytes read. */
int bufferSamples;
int fileSamples;
int 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 > (int) sizeof(raw))
{
fileBytes = (int) 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);
}
else if (res == 0) /* EOF */
{
if (bgmloop)
{
if (S_CodecRewindStream(bgmstream) < 0)
{
BGM_Stop();
return;
}
}
else
{
BGM_Stop();
return;
}
}
else /* res < 0: some read error */
{
Con_Printf("Stream read error (%i), stopping.\n", res);
BGM_Stop();
return;
}
}
}
void BGM_PlayMIDIorMusic (const char *filename)
{
/* 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 egyp1 as a mp3 or a midi, which
* is below *.ogg in the music_handler order, the mp3 or midi will
* still have priority over egyp1.ogg from, say, data1.
*/
char tmp[MAX_QPATH];
const char *ext, *dir;
unsigned int path_id, prev_id, type;
qboolean try_midi_stream;
music_handler_t *handler;
if (music_handlers == NULL)
return;
BGM_Stop();
if (!filename || !*filename)
{
Con_DPrintf("null music file name\n");
return;
}
ext = COM_FileGetExtension(filename);
if (*ext != '\0')
{
BGM_Play(filename);
return;
}
prev_id = 0;
type = 0;
dir = ext = NULL;
handler = music_handlers;
try_midi_stream = false;
while (handler)
{
if (! handler->is_available)
goto _next;
if (! MIDITYPE(handler->type) &&
(no_extmusic || !bgm_extmusic.value))
goto _next;
q_snprintf(tmp, sizeof(tmp), "%s/%s.%s",
handler->dir, filename, handler->ext);
if (! FS_FileExists(tmp, &path_id))
{
if (handler->type == MIDIDRIVER_MID)
break;
goto _next;
}
if (path_id > prev_id)
{
prev_id = path_id;
type = handler->type;
ext = handler->ext;
dir = handler->dir;
if (handler->type == MIDIDRIVER_MID)
{
if (handler->next &&
handler->next->is_available)
try_midi_stream = true;
break;
}
}
_next:
handler = handler->next;
}
if (ext == NULL)
Con_Printf("Couldn't handle music file %s\n", filename);
else
{
q_snprintf(tmp, sizeof(tmp), "%s/%s.%s", dir, filename, ext);
switch (type)
{
case MIDIDRIVER_MID:
if (BGM_Play_mididrv(tmp) == 0)
return; /* success */
/* BGM_MIDIDRV is followed by CODECTYPE_MID streamer.
* Even if the midi driver failed, we may still have
* a chance with the streamer if it's available... */
if (!try_midi_stream)
break;
type = CODECTYPE_MID;
default:
bgmstream = S_CodecOpenStreamType(tmp, type);
if (bgmstream)
return; /* success */
}
Con_Printf("Couldn't handle music file %s\n", tmp);
}
}
void BGM_Play (const char *filename)
{
char tmp[MAX_QPATH];
const char *ext;
music_handler_t *handler;
BGM_Stop();
if (music_handlers == NULL)
return;
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;
}
/* use the filename as is */
handler = music_handlers;
while (handler)
{
if (handler->is_available &&
!q_strcasecmp(ext, handler->ext))
break;
handler = handler->next;
}
if (!handler)
{
Con_Printf("Unhandled extension for %s\n", filename);
return;
}
q_snprintf(tmp, sizeof(tmp), "%s/%s", handler->dir, filename);
switch (handler->player)
{
case BGM_MIDIDRV:
if (BGM_Play_mididrv(tmp) == 0)
return; /* success */
/* BGM_MIDIDRV is followed by CODECTYPE_MID streamer.
* Even if the midi driver failed, we may still have
* a chance with the streamer if it's available... */
if (! (handler->next && handler->next->is_available))
break;
handler = handler->next;
case BGM_STREAMER:
bgmstream = S_CodecOpenStreamType(tmp, handler->type);
if (bgmstream)
return; /* success */
break;
case BGM_NONE:
default:
break;
}
Con_Printf("Couldn't handle music file %s\n", filename);
}
static void BGM_Stop_f (void)
{
BGM_Stop();
}
void Psp2Audio::BGM_Play(std::string const& file, int volume, int pitch, int fadein) {
// If a BGM is currently playing, we kill it
BGM_Stop();
sceKernelWaitSema(BGM_Mutex, 1, NULL);
if (BGM != NULL){
free(BGM->audiobuf);
free(BGM->audiobuf2);
audio_decoder.reset();
free(BGM);
BGM = NULL;
}
// Opening file
FILE* stream = FileFinder::fopenUTF8(file, "rb");
if (!stream) {
Output::Warning("Couldn't open music file %s", file.c_str());
sceKernelSignalSema(BGM_Mutex, 1);
return;
}
// Trying to use internal decoder
audio_decoder = AudioDecoder::Create(stream, file);
if (audio_decoder == NULL){
fclose(stream);
Output::Warning("Unsupported music format (%s)", file.c_str());
sceKernelSignalSema(BGM_Mutex, 1);
return;
}
// Initializing internal audio decoder
int audiotype;
fseek(stream, 0, SEEK_SET);
if (!audio_decoder->Open(stream)) Output::Error("An error occured in audio decoder (%s)", audio_decoder->GetError().c_str());
audio_decoder->SetLooping(true);
AudioDecoder::Format int_format;
int samplerate;
audio_decoder->SetFormat(48000, AudioDecoder::Format::S16, 2);
audio_decoder->GetFormat(samplerate, int_format, audiotype);
if (samplerate != 48000) Output::Warning("Cannot resample music file. Music will be distorted.");
// Initializing music block
DecodedMusic* myFile = (DecodedMusic*)malloc(sizeof(DecodedMusic));
// Check for file audiocodec
if (audiotype == 2) myFile->isStereo = true;
else myFile->isStereo = false;
// Setting audiobuffer size
myFile->audiobuf = (uint8_t*)malloc(AUDIO_BUFSIZE);
myFile->audiobuf2 = (uint8_t*)malloc(AUDIO_BUFSIZE);
myFile->cur_audiobuf = myFile->audiobuf;
//Setting default streaming values
myFile->handle = stream;
myFile->endedOnce = false;
// Passing new music block to the audio thread
BGM = myFile;
// Music settings
audio_decoder->SetFade(0, volume, fadein);
audio_decoder->SetPitch(pitch);
BGM->tick = DisplayUi->GetTicks();
BGM->vol = volume;
// Starting BGM
BGM->isNewTrack = true;
BGM->isPlaying = true;
sceKernelSignalSema(BGM_Mutex, 1);
}
