void CL_PlayBackgroundTrack (void)
{
char name[MAX_QPATH];
int track;
//fileHandle_t f;
//BC investigate whether these lines are needed!!
//if (!cl.refresh_prepped)
// return;
// using a named audio track intead of numbered
if (strlen(cl.configstrings[CS_CDTRACK]) > 2)
{
sprintf(name, va("music/%s.ogg", cl.configstrings[CS_CDTRACK]) );
if (FS_LoadFile(name, NULL) != -1)
{
//BC add looping track.
//check if the intro name exists. If not, then just use the looping track.
char introname[MAX_QPATH];
sprintf(introname, va("music/%s_intro.ogg", cl.configstrings[CS_CDTRACK]) );
if (FS_LoadFile(introname, NULL) <= -1)
strcpy (introname, name);
CDAudio_Stop();
S_StartBackgroundTrack(introname, name);
return;
}
}
track = atoi(cl.configstrings[CS_CDTRACK]);
if (track == 0)
{ // Stop any playing track
CDAudio_Stop();
S_StopBackgroundTrack();
return;
}
// If an OGG file exists play it, otherwise fall back to CD audio
sprintf(name, va("music/track%02i.ogg", CL_MissionPackCDTrack(track)) );
if ( (FS_LoadFile(name, NULL) != -1) && cl_ogg_music->value )
{
S_StartBackgroundTrack(name, name);
}
else
{
CDAudio_Play(track, true);
}
}
void CDAudio_Update()
{
if(!cd_id || !enabled) return;
if(cd_volume && cd_volume->value != cdvolume)
{
if(cdvolume)
{
Cvar_SetValue("cd_volume",0.0);
CDAudio_Pause();
}
else
{
Cvar_SetValue("cd_volume",1.0);
CDAudio_Resume();
}
cdvolume = cd_volume->value;
return;
}
if(cd_nocd->value)
{
CDAudio_Stop();
return;
}
if(playLooping &&
(SDL_CDStatus(cd_id) != CD_PLAYING) &&
(SDL_CDStatus(cd_id) != CD_PAUSED))
{
CDAudio_Play(lastTrack,true);
}
}
void CDAudio_Play(byte track, bool looping)
{
CDAudio_Stop();
char fname[256];
sprintf (fname, "%s/%s/cdtracks/track", host_parms.basedir, (mod_path == NULL) ? GAMENAME_DIR : mod_path);
if (track < 100){
sprintf(fname, "%s0", fname);
if (track < 10){
sprintf(fname, "%s0", fname);
}
}
sprintf(fname,"%s%d",fname,track);
char tmp[256];
sprintf(tmp,"%s.ogg",fname);
FILE* fd = fopen(tmp,"rb");
if (fd == NULL){
sprintf(tmp,"%s.mp3",fname);
FILE* fd = fopen(tmp,"rb");
}
if (fd == NULL) return;
DecodedMusic* memblock = (DecodedMusic*)malloc(sizeof(DecodedMusic));
memblock->handle = fd;
memblock->pauseTrigger = false;
memblock->closeTrigger = false;
memblock->isPlaying = true;
memblock->loop = looping;
BGM = memblock;
sceKernelSignalSema(Audio_Mutex, 1);
}
void CDA_Stop (void)
{
#ifdef UQE_FMOD_CDAUDIO
if(SND_InitialisedCD == false || SND_MusicChannel.inuse == false)
return;
if(SND_MusicChannel.channel)
{
result = FMOD_Channel_Stop(SND_MusicChannel.channel);
FMOD_ERROR(result, true, false);
}
if(fmod_musicCD_subsound)
{
result = FMOD_Sound_Release(fmod_musicCD_subsound);
FMOD_ERROR(result, true, false);
}
if(fmod_musicCD)
{
result = FMOD_Sound_Release(fmod_musicCD);
FMOD_ERROR(result, true, false);
}
SND_MusicChannel.inuse = false;
#else
CDAudio_Stop();
#endif
}
void CDAudio_Play(byte track, qboolean looping)
{
CDstatus cd_stat;
if(!cd_id || !enabled) return;
if(!cdValid)
{
if(!CD_INDRIVE(cd_stat=SDL_CDStatus(cd_id)) ||(!cd_id->numtracks)) return;
cdValid = true;
}
if((track < 1) || (track >= cd_id->numtracks))
{
Con_DPrintf("CDAudio: Bad track number: %d\n",track);
return;
}
track--; /* Convert track from person to SDL value */
if(cd_stat == CD_PLAYING)
{
if(cd_id->cur_track == track) return;
CDAudio_Stop();
}
if(SDL_CDPlay(cd_id,cd_id->track[track].offset,
cd_id->track[track].length))
{
Con_DPrintf("CDAudio_Play: Unable to play track: %d\n",track+1);
return;
}
playLooping = looping;
}
void CDAudio_Shutdown()
{
if(!cd_id) return;
CDAudio_Stop();
SDL_CDClose(cd_id);
cd_id = NULL;
}
void CDAudio_Shutdown(void)
{
if (!initialized)
return;
free(trackData);
CDAudio_Stop();
}
void CDAudio_Shutdown(void)
{
if (!initialized)
return;
CDAudio_Stop();
CDAudio_WaitForFinish();
if (pDSBufCDNotify)
{
pDSBufCDNotify->lpVtbl->Release(pDSBufCDNotify);
pDSBufCDNotify = NULL;
}
if (pDSBufCD)
{
pDSBufCD->lpVtbl->Stop(pDSBufCD);
pDSBufCD->lpVtbl->Release(pDSBufCD);
pDSBufCD = NULL;
}
if (cdPlayingFinishedEvent)
{
CloseHandle(cdPlayingFinishedEvent);
cdPlayingFinishedEvent = NULL;
}
if (cdStopEvent)
{
CloseHandle(cdStopEvent);
cdStopEvent = NULL;
}
}
/*
============
CDAudio_MessageHandler
============
*/
LONG CDAudio_MessageHandler (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if (lParam != wDeviceID)
return 1;
switch (wParam)
{
case MCI_NOTIFY_SUCCESSFUL:
if (playing)
{
playing = false;
if (playLooping)
CDAudio_Play (SRC_COMMAND, playTrack, true);
}
break;
case MCI_NOTIFY_ABORTED:
case MCI_NOTIFY_SUPERSEDED:
break;
case MCI_NOTIFY_FAILURE:
Con_DPrintf ("MCI_NOTIFY_FAILURE\n");
CDAudio_Stop (SRC_COMMAND);
cdValid = false;
break;
default:
Con_DPrintf ("Unexpected MM_MCINOTIFY type (%i)\n", wParam);
return 1;
}
return 0;
}
/*
===============
SCR_BeginLoadingPlaque
================
*/
void SCR_BeginLoadingPlaque (void)
{
S_StopAllSounds (true);
CDAudio_Stop (); // Stop the CD music
if (cls.state != ca_connected)
return;
if (cls.signon != SIGNONS)
return;
// redraw with no console and the loading plaque
Con_ClearNotify ();
// remove all center prints
con_lastcenterstring[0] = 0;
scr_centerstring[0] = 0;
scr_centertime_off = 0;
scr_con_current = 0;
scr_drawloading = true;
Sbar_Changed ();
SCR_UpdateScreen ();
scr_drawloading = false;
scr_disabled_for_loading = true;
scr_disabled_time = realtime;
SCR_SetTimeout (SCR_DEFTIMEOUT);
}
void CL_PlayBackgroundTrack(void)
{
char name[MAX_QPATH];
int track;
Com_DPrintf("CL_PlayBackgroundTrack\n"); // debug
if (!cl.refresh_prepped)
return;
// using a named audio track intead of numbered
if (strlen(cl.configstrings[CS_CDTRACK]) > 2)
{
Com_sprintf(name, sizeof(name), "music/%s.ogg", cl.configstrings[CS_CDTRACK]);
if (FS_LoadFile(name, NULL) != -1)
{
#ifdef CD_AUDIO
CDAudio_Stop();
#endif
S_StartBackgroundTrack(name, name);
return;
}
}
track = atoi(cl.configstrings[CS_CDTRACK]);
if (track == 0)
{ // Stop any playing track
Com_DPrintf("CL_PlayBackgroundTrack: stopping\n"); // debug
#ifdef CD_AUDIO
CDAudio_Stop();
#endif
S_StopBackgroundTrack();
return;
}
// If an OGG file exists play it, otherwise fall back to CD audio
Com_sprintf(name, sizeof(name), "music/track%02i.ogg", CL_MissionPackCDTrack(track));
if ((FS_LoadFile(name, NULL) != -1) && cl_ogg_music->value) {
Com_DPrintf("CL_PlayBackgroundTrack: playing track %s\n", name); // debug
S_StartBackgroundTrack(name, name);
}
#ifdef CD_AUDIO
else
CDAudio_Play(track, true);
#endif
}
void CDAudio_Shutdown(void)
{
if (!initialized)
return;
CDAudio_Stop();
if (mciSendCommand(wDeviceID, MCI_CLOSE, MCI_WAIT, (DWORD)NULL))
Com_DPrintf("CDAudio_Shutdown: MCI_CLOSE failed\n");
}
void CDAudio_Shutdown(void)
{
if (!initialized)
return;
CDAudio_Stop();
close(cdfile);
cdfile = -1;
}
void
CDAudio_Shutdown(void)
{
if (!initialized)
return;
CDAudio_Stop();
CDDrv_CloseDevice();
initialized = false;
}
void CDAudio_Play(byte track, qboolean looping)
{
HANDLE playingThread;
char filename[MAX_PATH];
struct ThreadArgList_t *tal;
if (!enabled)
return;
if (!cdValid)
{
CDAudio_GetAudioDiskInfo();
if (!cdValid)
return;
}
track = remap[track];
if (track < 1 || track > maxTrack)
{
Con_DPrintf("CDAudio: Bad track number %u.\n", track);
return;
}
if (playing)
{
if (playTrack == track)
return;
CDAudio_Stop();
}
tal = malloc(sizeof(struct ThreadArgList_t));
tal->playLooping = looping;
tal->playTrack = track;
sprintf(filename, "%s\\Track%03d.ogg", com_gamedir, track);
if (!OpenOGG(filename, tal))
{
sprintf(filename, "%s\\sound\\cdtracks\\Track%03d.ogg", com_gamedir, track);
if (!OpenOGG(filename, tal))
{
Con_DPrintf("CDAudio: Cannot open Vorbis file \"%s\"", filename);
return;
}
}
playLooping = looping;
playTrack = track;
playing = true;
// force volume update
cdvolume = -1;
playingThread = (HANDLE)_beginthreadex(NULL, 0, PlayingThreadProc, tal, CREATE_SUSPENDED, NULL);
SetThreadPriority(playingThread, THREAD_PRIORITY_TIME_CRITICAL);
ResumeThread(playingThread);
}
// Manoel Kasimier - begin
void cd_cvar_check(void)
{
if (!cd_enabled.value)
{
cd_enabled.value = 1;
if (playing)
CDAudio_Stop();
cd_enabled.value = 0;
}
}
void CDAudio_Shutdown(void)
{
if (!initialized)
return;
CDAudio_Stop();
if (hw_vol_works)
CD_SetVolume (&orig_vol);
close(cdfile);
cdfile = -1;
}
void CDAudio_Shutdown (void)
{
if (!initialized)
return;
CDAudio_SysSetVolume (saved_vol);
CDAudio_Stop();
CDAudio_SysShutdown();
initialized = false;
}
void CDAudio_Shutdown(void)
{
if (!initialized)
return;
if (playing) // Manoel Kasimier
CDAudio_Stop();
if (CD_ID != -1) // Manoel Kasimier
auxSetVolume(CD_ID,CD_OrigVolume); // Manoel Kasimier
if (mciSendCommand(wDeviceID, MCI_CLOSE, MCI_WAIT, (DWORD)NULL))
Con_DPrintf("CDAudio_Shutdown: MCI_CLOSE failed\n");
}
// r1: bumped to 256k.
void EXPORT FS_Read (void *buffer, int len, FILE *f)
{
int block, remaining;
size_t read;
byte *buf;
#ifdef CD_AUDIO
int tries = 0;
#endif
Q_assert (len != 0);
buf = (byte *)buffer;
// read in chunks for progress bar
remaining = len;
while (remaining)
{
block = remaining;
if (block > MAX_READ)
block = MAX_READ;
read = fread (buf, block, 1, f);
if (read == 0)
{
// we might have been trying to read from a CD
#ifdef CD_AUDIO
if (!tries)
{
tries = 1;
CDAudio_Stop();
}
else
#endif
{
if (ferror (f))
{
Com_Error (ERR_FATAL, "FS_Read(%d): Read error on '%s'. Did you forget to empty the filesystem cache after modifying a file?", len, current_filename);
}
else
{
Com_Printf ("WARNING: Incomplete read of %d bytes from '%s'. Did you forget to empty the filesystem cache after modifying a file?\n", LOG_WARNING, len, current_filename);
return;
}
}
}
// do some progress bar thing here...
remaining -= block;
buf += block;
}
}
void CDAudio_Shutdown(void)
{
if (!cd_handle)
return;
CDAudio_Stop();
// cd hardware volume: no SDL support at present.
// if (hw_vol_works)
// CD_SetVolume (NULL);
SDL_CDClose(cd_handle);
cd_handle = NULL;
cd_dev = -1;
SDL_QuitSubSystem(SDL_INIT_CDROM);
}
void
CDAudio_Play ( int track, qboolean looping )
{
CDstatus cd_stat;
lastTrack = track + 1;
if ( !cd_id || !enabled )
{
return;
}
cd_stat = SDL_CDStatus( cd_id );
if ( !cdValid )
{
if ( !CD_INDRIVE( cd_stat ) || ( !cd_id->numtracks ) )
{
return;
}
cdValid = true;
}
if ( ( track < 1 ) || ( track >= cd_id->numtracks ) )
{
Com_DPrintf( "CDAudio: Bad track number: %d\n", track );
return;
}
track--;
if ( cd_stat == CD_PLAYING )
{
if ( cd_id->cur_track == track )
{
return;
}
CDAudio_Stop();
}
if ( SDL_CDPlay( cd_id, cd_id->track [ track ].offset,
cd_id->track [ track ].length ) )
{
Com_DPrintf( "CDAudio_Play: Unable to play track: %d (%s)\n", track + 1, SDL_GetError() );
return;
}
playLooping = looping;
}
void CDAudio_Shutdown()
{
if(!cd_id) return;
CDAudio_Stop();
SDL_CDClose(cd_id);
cd_id = NULL;
if (SDL_WasInit(SDL_INIT_EVERYTHING) == SDL_INIT_CDROM)
SDL_Quit();
else
SDL_QuitSubSystem(SDL_INIT_CDROM);
initialized = false;
}
void CL_PlayBackgroundTrack (void)
{
char name[MAX_QPATH];
int track;
//fileHandle_t f;
if (!cl.refresh_prepped)
return;
// using a named audio track intead of numbered
if (strlen(cl.configstrings[CS_CDTRACK]) > 2)
{
sprintf(name, va("music/%s.ogg", cl.configstrings[CS_CDTRACK]) );
if (FS_LoadFile(name, NULL) != -1)
{
CDAudio_Stop();
S_StartBackgroundTrack(name, name);
return;
}
}
track = atoi(cl.configstrings[CS_CDTRACK]);
if (track == 0)
{ // Stop any playing track
CDAudio_Stop();
S_StopBackgroundTrack();
return;
}
// If an OGG file exists play it, otherwise fall back to CD audio
sprintf(name, va("music/track%02i.ogg", CL_MissionPackCDTrack(track)) );
if ( (FS_LoadFile(name, NULL) != -1) && cl_ogg_music->value )
S_StartBackgroundTrack(name, name);
else
CDAudio_Play(track, true);
}
void CDAudio_Update(void)
{
if ( cd_nocd->value != !enabled )
{
if ( cd_nocd->value )
{
CDAudio_Stop();
enabled = false;
}
else
{
enabled = true;
CDAudio_Resume ();
}
}
}
void
SCR_BeginLoadingPlaque(void)
{
S_StopAllSounds();
cl.sound_prepped = false; /* don't play ambients */
#ifdef CDA
CDAudio_Stop();
#endif
#ifdef OGG
OGG_Stop();
#endif
if (cls.disable_screen)
{
return;
}
if (developer->value)
{
return;
}
if (cls.state == ca_disconnected)
{
/* if at console, don't bring up the plaque */
return;
}
if (cls.key_dest == key_console)
{
return;
}
if (cl.cinematictime > 0)
{
scr_draw_loading = 2; /* clear to balack first */
}
else
{
scr_draw_loading = 1;
}
SCR_UpdateScreen();
SCR_StopCinematic();
cls.disable_screen = Sys_Milliseconds();
cls.disable_servercount = cl.servercount;
}
int CDAudio_SysPlay (int track)
{
DWORD dwReturn;
MCI_PLAY_PARMS mciPlayParms;
MCI_STATUS_PARMS mciStatusParms;
// don't try to play a non-audio track
mciStatusParms.dwItem = MCI_CDA_STATUS_TYPE_TRACK;
mciStatusParms.dwTrack = track;
dwReturn = mciSendCommand(wDeviceID, MCI_STATUS, MCI_STATUS_ITEM | MCI_TRACK | MCI_WAIT, (DWORD_PTR) (LPVOID) &mciStatusParms);
if (dwReturn)
{
Con_Printf("CDAudio_SysPlay: MCI_STATUS failed (%x)\n", (unsigned)dwReturn);
return -1;
}
if (mciStatusParms.dwReturn != MCI_CDA_TRACK_AUDIO)
{
Con_Printf("CDAudio_SysPlay: track %i is not audio\n", track);
return -1;
}
if (cdPlaying)
CDAudio_Stop();
// get the length of the track to be played
mciStatusParms.dwItem = MCI_STATUS_LENGTH;
mciStatusParms.dwTrack = track;
dwReturn = mciSendCommand(wDeviceID, MCI_STATUS, MCI_STATUS_ITEM | MCI_TRACK | MCI_WAIT, (DWORD_PTR) (LPVOID) &mciStatusParms);
if (dwReturn)
{
Con_Printf("CDAudio_SysPlay: MCI_STATUS failed (%x)\n", (unsigned)dwReturn);
return -1;
}
mciPlayParms.dwFrom = MCI_MAKE_TMSF(track, 0, 0, 0);
mciPlayParms.dwTo = (mciStatusParms.dwReturn << 8) | track;
mciPlayParms.dwCallback = (DWORD_PTR)mainwindow;
dwReturn = mciSendCommand(wDeviceID, MCI_PLAY, MCI_NOTIFY | MCI_FROM | MCI_TO, (DWORD_PTR)(LPVOID) &mciPlayParms);
if (dwReturn)
{
Con_Printf("CDAudio_SysPlay: MCI_PLAY failed (%x)\n", (unsigned)dwReturn);
return -1;
}
return 0;
}
void
CDAudio_Update ()
{
static int cnt = 0;
if ( !cd_id || !enabled )
{
return;
}
if ( cd_volume && ( cd_volume->value != cdvolume ) )
{
if ( cdvolume )
{
Cvar_SetValue( "cd_volume", 0.0 );
CDAudio_Pause();
}
else
{
Cvar_SetValue( "cd_volume", 1.0 );
CDAudio_Resume();
}
cdvolume = cd_volume->value;
return;
}
/* this causes too much overhead to be executed every frame */
if ( ++cnt == 16 )
{
cnt = 0;
if ( cd_nocd->value )
{
CDAudio_Stop();
return;
}
if ( playLooping &&
( SDL_CDStatus( cd_id ) != CD_PLAYING ) &&
( SDL_CDStatus( cd_id ) != CD_PAUSED ) )
{
CDAudio_Play( lastTrack, true );
}
}
}
int CDAudio_SysPlay (int track)
{
struct cdrom_tocentry entry;
struct cdrom_ti ti;
if (cdfile == -1)
return -1;
// don't try to play a non-audio track
entry.cdte_track = track;
entry.cdte_format = CDROM_MSF;
if (ioctl(cdfile, CDROMREADTOCENTRY, &entry) == -1)
{
Con_Print("ioctl CDROMREADTOCENTRY failed\n");
return -1;
}
if (entry.cdte_ctrl == CDROM_DATA_TRACK)
{
Con_Printf("CDAudio: track %i is not audio\n", track);
return -1;
}
if (cdPlaying)
CDAudio_Stop();
ti.cdti_trk0 = track;
ti.cdti_trk1 = track;
ti.cdti_ind0 = 1;
ti.cdti_ind1 = 99;
if (ioctl(cdfile, CDROMPLAYTRKIND, &ti) == -1)
{
Con_Print("ioctl CDROMPLAYTRKIND failed\n");
return -1;
}
if (ioctl(cdfile, CDROMRESUME) == -1)
{
Con_Print("ioctl CDROMRESUME failed\n");
return -1;
}
return 0;
}
/*
=================
FS_FRead
Properly handles partial reads of size up to count times
No error if it can't read
=================
*/
int FS_FRead(void *buffer, int size, int count, FILE *f)
{
int loops, remaining, r;
byte *buf;
qboolean tried = false;
// Read
loops = count;
//remaining = size;
buf = (byte *)buffer;
while (loops)
{ // Read in chunks
remaining = size;
while (remaining)
{
r = fread(buf, 1, remaining, f);
if (r == 0)
{
if (!tried)
{ // We might have been trying to read from a CD
#ifdef CD_AUDIO
CDAudio_Stop();
#endif
tried = true;
}
else {
// Com_Printf("FS_FRead: 0 bytes read\n");
return size - remaining;
}
}
else if (r == -1)
Com_Error(ERR_FATAL, "FS_FRead: -1 bytes read");
remaining -= r;
buf += r;
}
loops--;
}
return size;
}
