qboolean CDAudio_Play_real (int track, qboolean looping, qboolean complain)
{
if(track < 1)
{
if(complain)
Con_Print("Could not load BGM track.\n");
return false;
}
if (!cdValid)
{
CDAudio_GetAudioDiskInfo();
if (!cdValid)
{
if(complain)
Con_DPrint ("No CD in player.\n");
return false;
}
}
if (track > maxTrack)
{
if(complain)
Con_DPrintf("CDAudio: Bad track number %u.\n", track);
return false;
}
if (CDAudio_SysPlay(track) == -1)
return false;
if(cdaudio.integer != 3)
Con_DPrintf ("CD track %u playing...\n", track);
return true;
}
int CDAudio_Init (void)
{
int i;
if (!COM_CheckParm("-cdaudio"))
return -1;
if ((i = COM_CheckParm("-cddev")) != 0 && i < com_argc - 1)
strlcpy (cd_dev, com_argv[i + 1], sizeof(cd_dev));
if ((cdfile = open(cd_dev, O_RDONLY)) == -1) {
Com_Printf ("CDAudio_Init: open of \"%s\" failed (%i)\n", cd_dev, errno);
cdfile = -1;
return -1;
}
for (i = 0; i < 100; i++)
remap[i] = i;
initialized = true;
enabled = true;
if (CDAudio_GetAudioDiskInfo())
{
Com_Printf ("CDAudio_Init: No CD in player.\n");
cdValid = false;
}
Cmd_AddCommand ("cd", CD_f);
Com_Printf ("CD Audio Initialized\n");
return 0;
}
int CDAudio_Startup (void)
{
if (COM_CheckParm("-nocdaudio"))
return -1;
CDAudio_SysStartup ();
if (CDAudio_GetAudioDiskInfo())
{
Con_Print("CDAudio_Init: No CD in player.\n");
cdValid = false;
}
saved_vol = CDAudio_SysGetVolume ();
if (saved_vol < 0.0f)
{
Con_Print ("Can't get initial CD volume\n");
saved_vol = 1.0f;
}
else
Con_Printf ("Initial CD volume: %g\n", saved_vol);
initialized = true;
Con_Print("CD Audio Initialized\n");
return 0;
}
int
CDAudio_Init(void)
{
int i, err;
#ifdef NQ_HACK
// FIXME - not a valid client state in QW?
if (cls.state == ca_dedicated)
return -1;
#endif
if (COM_CheckParm("-nocdaudio"))
return -1;
Cmd_AddCommand("cd", CD_f);
err = CDDrv_InitDevice();
if (err)
return err;
for (i = 0; i < 100; i++)
remap[i] = i;
initialized = true;
enabled = true;
Con_Printf("CD Audio Initialized\n");
if (CDAudio_GetAudioDiskInfo()) {
Con_Printf("CDAudio_Init: No CD in player.\n");
cdValid = false;
}
Cvar_RegisterVariable(&bgmvolume);
return 0;
}
/**************************************************************************
*
* function: UpdateCD
*
* description:
* sets CD volume (may have changed) and initiates play evey 2 seconds
* in case the song has elapsed
*
**************************************************************************/
void I_UpdateCD (void)
{
#ifndef NOSDLCD
static Uint32 lastchk = 0;
if (!cdEnabled || !cdrom)
return;
I_SetVolumeCD(cd_volume.value);
if (cdPlaying && lastchk < SDL_GetTicks())
{
lastchk = SDL_GetTicks() + 2000; //two seconds between chks
if (CDAudio_GetAudioDiskInfo()==-1)
{
cdPlaying = SDL_FALSE;
return;
}
if (cdStatus != CD_PLAYING && cdStatus != CD_PAUSED)
{
cdPlaying = SDL_FALSE;
if (playLooping)
I_PlayCD(playTrack, true);
}
}
#endif
}
void I_UpdateCD()
{
if (!enabled)
return;
I_SetVolumeCD(cd_volume.value);
if (playing && lastchk < SDL_GetTicks())
{
lastchk = SDL_GetTicks() + 2000; //two seconds between chks
if (CDAudio_GetAudioDiskInfo())
{
playing = false;
return;
}
if (cdStatus != CD_PLAYING &&
cdStatus != CD_PAUSED)
{
playing = false;
if (playLooping)
I_PlayCD(playTrack, true);
}
}
return;
}
int CDAudio_Init(void)
{
DWORD dwReturn;
MCI_OPEN_PARMS mciOpenParms;
MCI_SET_PARMS mciSetParms;
int n;
if (cls.state == ca_dedicated)
return -1;
if (COM_CheckParm("-nocdaudio"))
return -1;
Cmd_AddCommand ("cd", CD_f);
Cvar_RegisterVariable(&bgmvolume, NULL);
Cvar_RegisterVariable(&bgmtype, NULL);
mciOpenParms.lpstrDeviceType = "cdaudio";
dwReturn = mciSendCommand(0, MCI_OPEN, MCI_OPEN_TYPE | MCI_OPEN_SHAREABLE, (DWORD_PTR) (LPVOID) &mciOpenParms);
if (dwReturn)
{
Con_DPrintf("CDAudio_Init: MCI_OPEN failed (%u)\n", (unsigned int)dwReturn);
return -1;
}
wDeviceID = mciOpenParms.wDeviceID;
// Set the time format to track/minute/second/frame (TMSF).
mciSetParms.dwTimeFormat = MCI_FORMAT_TMSF;
dwReturn = mciSendCommand(wDeviceID, MCI_SET, MCI_SET_TIME_FORMAT, (DWORD_PTR) (LPVOID) &mciSetParms);
if (dwReturn)
{
Con_DPrintf("CDAudio_Init: MCI_SET_TIME_FORMAT failed (%u)\n", (unsigned int)dwReturn);
mciSendCommand(wDeviceID, MCI_CLOSE, 0, (DWORD_PTR)NULL);
return -1;
}
for (n = 0; n < 100; n++)
remap[n] = n;
initialized = true;
enabled = true;
old_cdvolume = bgmvolume.value;
if (CDAudio_GetAudioDiskInfo())
{
Con_Printf("No CD in drive\n");
cdValid = false;
}
#ifdef USE_AUX_API
CD_FindCDAux();
#endif /* USE_AUX_API */
Con_Printf("CD Audio initialized\n");
return 0;
}
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);
}
void I_InitCD()
{
int i;
const char *cdName;
// Don't start music on a dedicated server
if (M_CheckParm("-dedicated"))
return ;
// Has been checked in d_main.c, but doesn't hurt here
if (M_CheckParm("-nocd"))
return ;
CONS_Printf(" Initializing CD audio...\n");
// Initialize SDL first
if (SDL_Init(SDL_INIT_CDROM) < 0) {
CONS_Printf(" Couldn't initialize SDL CD: %s\n", SDL_GetError());
return;
}
// Open drive
cdrom = SDL_CDOpen(0);
cdName = SDL_CDName(0);
if (cdrom == NULL) {
if (cdName == NULL)
{
CONS_Printf(" Couldn't open default CD-ROM drive: %s\n",
SDL_GetError());
}
else
{
CONS_Printf(" Couldn't open default CD-ROM drive %s: %s\n",
cdName, SDL_GetError());
}
return;
}
for (i = 0; i < MAX_CD_TRACKS; i++)
cdRemap[i] = i;
initialized = true;
enabled = true;
CDAudio_GetAudioDiskInfo();
COM.AddCommand("cd", Command_Cd_f);
CONS_Printf(" CD audio initialized.\n");
return ;
}
/**************************************************************************
*
* function: InitCD
*
* description:
* Initialize the first CD drive SDL detects and add console command 'cd'
*
**************************************************************************/
void I_InitCD (void)
{
#ifndef NOSDLCD
INT32 i;
// Has been checked in d_main.c, but doesn't hurt here
if (M_CheckParm ("-nocd"))
return;
CONS_Printf("I_InitCD: Init CD audio\n");
// Initialize SDL first
if (SDL_InitSubSystem(SDL_INIT_CDROM) < 0)
{
CONS_Printf("Couldn't initialize SDL CDROM: %s\n",SDL_GetError());
return;
}
// Open drive
cdrom = SDL_CDOpen(0);
if (!cdrom)
{
const char *cdName = SDL_CDName(0);
if (!cdName)
{
CONS_Printf("Couldn't open default CD-ROM drive: %s\n",
SDL_GetError());
}
else
{
CONS_Printf("Couldn't open default CD-ROM drive %s: %s\n",
cdName, SDL_GetError());
}
//return;
}
for (i = 0; i < MAX_CD_TRACKS; i++)
cdRemap[i] = (Uint8)i;
cdaudio_started = true;
if (cdrom) cdEnabled = true;
if (CDAudio_GetAudioDiskInfo()==-1)
{
CONS_Printf("I_InitCD: No CD in player.\n");
cdValid = SDL_FALSE;
}
COM_AddCommand ("cd", Command_Cd_f);
CONS_Printf("CD audio Initialized\n");
#endif
}
int CDAudio_Init(void)
{
DWORD dwReturn;
MCI_OPEN_PARMS mciOpenParms;
MCI_SET_PARMS mciSetParms;
int n;
if (cls.state == ca_dedicated)
{
return -1;
}
if (COM_CheckParm("-nocdaudio"))
{
return -1;
}
mciOpenParms.lpstrDeviceType = "cdaudio";
if (dwReturn = mciSendCommand(0, MCI_OPEN, MCI_OPEN_TYPE | MCI_OPEN_SHAREABLE, (DWORD)(LPVOID) &mciOpenParms))
{
Con_Printf("CDAudio_Init: MCI_OPEN failed (%i)\n", dwReturn);
return -1;
}
wDeviceID = mciOpenParms.wDeviceID;
// Set the time format to track/minute/second/frame (TMSF).
mciSetParms.dwTimeFormat = MCI_FORMAT_TMSF;
if (dwReturn = mciSendCommand(wDeviceID, MCI_SET, MCI_SET_TIME_FORMAT, (DWORD)(LPVOID) &mciSetParms))
{
Con_Printf("MCI_SET_TIME_FORMAT failed (%i)\n", dwReturn);
mciSendCommand(wDeviceID, MCI_CLOSE, 0, (DWORD)NULL);
return -1;
}
for (n = 0; n < 100; n++)
{
remap[n] = n;
}
initialized = true;
enabled = true;
if (CDAudio_GetAudioDiskInfo())
{
Con_Printf("CDAudio_Init: No CD in player.\n");
cdValid = false;
}
Cmd_AddCommand("cd", CD_f);
Con_Printf("CD Audio Initialized\n");
return 0;
}
void I_PlayCD (UINT8 track, UINT8 looping)
{
#ifdef NOSDLCD
(void)track;
(void)looping;
#else
if (!cdrom || !cdEnabled)
return;
if (!cdValid)
{
CDAudio_GetAudioDiskInfo();
if (!cdValid)
return;
}
track = cdRemap[track];
if (track < 1 || track > maxTrack)
{
CONS_Printf("I_PlayCD: Bad track number %u.\n", track);
return;
}
// don't try to play a non-audio track
if (cdrom->track[track].type == SDL_DATA_TRACK)
{
CONS_Printf("I_PlayCD: track %u is not audio\n", track);
return;
}
if (cdPlaying)
{
if (playTrack == track)
return;
I_StopCD();
}
if (SDL_CDPlayTracks(cdrom, track, 0, 1, 0))
{
CONS_Printf("Error playing track %d: %s\n",
track, SDL_GetError());
return;
}
playLooping = looping;
playTrack = (Uint8)track;
cdPlaying = true;
if (cd_volume.value == 0)
I_PauseCD();
#endif
}
int
CDAudio_Init (void)
{
int i;
#if 0
if (cls.state == ca_dedicated)
return -1;
#endif
if (COM_CheckParm ("-nocdaudio"))
return -1;
if ((i = COM_CheckParm ("-cddev")) != 0 && i < com_argc - 1) {
strncpy (cd_dev, com_argv[i + 1], sizeof (cd_dev));
cd_dev[sizeof (cd_dev) - 1] = 0;
}
if ((cdfile = open (cd_dev, O_RDONLY | O_NONBLOCK)) == -1) {
Con_Printf ("CDAudio_Init: open of \"%s\" failed (%i)\n", cd_dev,
errno);
cdfile = -1;
return -1;
}
for (i = 0; i < 100; i++)
remap[i] = i;
initialized = true;
enabled = true;
if (CDAudio_GetAudioDiskInfo ()) {
Con_Printf ("CDAudio_Init: No CD in player.\n");
cdValid = false;
}
Cmd_AddCommand ("cd", CD_f, "Control the CD player.\n"
"Commands:\n"
"eject - Eject the CD.\n"
"info - Reports information on the CD.\n"
"loop (track number) - Loops the specified track.\n"
"remap (track1) (track2) ... - Remap the current track order.\n"
"reset - Causes the CD audio to re-initialize.\n"
"resume - Will resume playback after pause.\n"
"off - Shuts down the CD audio system..\n"
"on - Re-enables the CD audio system after a cd off command.\n"
"pause - Pause the CD playback.\n"
"play (track number) - Plays the specified track one time.\n"
"stop - Stops the currently playing track.");
Con_Printf ("CD Audio Initialized\n");
return 0;
}
int CDAudio_Init(void)
{
DWORD dwReturn;
MCI_OPEN_PARMS mciOpenParms;
MCI_SET_PARMS mciSetParms;
int n;
if (initialized)
return 0;
cd_nocd = Cvar_Get ("cd_nocd", "0", CVAR_ARCHIVE );
cd_loopcount = Cvar_Get ("cd_loopcount", "4", 0);
cd_looptrack = Cvar_Get ("cd_looptrack", "11", 0);
cd_shuffle = Cvar_Get ("cd_shuffle", "0", CVAR_ARCHIVE ); // NeVo
if ( cd_nocd->value)
return -1;
mciOpenParms.lpstrDeviceType = "cdaudio";
if (dwReturn = mciSendCommand(0, MCI_OPEN, MCI_OPEN_TYPE | MCI_OPEN_SHAREABLE, (DWORD) (LPVOID) &mciOpenParms))
{
Com_Printf("CDAudio_Init: MCI_OPEN failed (%i)\n", dwReturn);
return -1;
}
wDeviceID = mciOpenParms.wDeviceID;
// Set the time format to track/minute/second/frame (TMSF).
mciSetParms.dwTimeFormat = MCI_FORMAT_TMSF;
if (dwReturn = mciSendCommand(wDeviceID, MCI_SET, MCI_SET_TIME_FORMAT, (DWORD)(LPVOID) &mciSetParms))
{
Com_Printf("MCI_SET_TIME_FORMAT failed (%i)\n", dwReturn);
mciSendCommand(wDeviceID, MCI_CLOSE, 0, (DWORD)NULL);
return -1;
}
for (n = 0; n < 100; n++)
remap[n] = n;
initialized = 1;
enabled = 1;
if (CDAudio_GetAudioDiskInfo())
{
// Com_Printf("CDAudio_Init: No CD in player.\n");
cdValid = 0;
enabled = 0;
}
Cmd_AddCommand ("cd", CD_f);
Com_Printf("CD Audio Initialized\n");
return 0;
}
void I_PlayCD(int track, bool looping)
{
if (cdrom == NULL || !enabled)
return;
if (!cdValid)
{
CDAudio_GetAudioDiskInfo();
if (!cdValid)
return;
}
track = cdRemap[track];
if (track < 1 || track > maxTrack)
{
CONS_Printf("I_PlayCD: Bad track number %u.\n", track);
return;
}
// don't try to play a non-audio track
if (cdrom->track[track].type == SDL_DATA_TRACK)
{
CONS_Printf("I_PlayCD: track %i is not audio\n", track);
return;
}
if (playing)
{
if (playTrack == track)
return;
I_StopCD();
}
if (SDL_CDPlayTracks(cdrom, track, 0, 1, 0))
{
CONS_Printf("Error playing track %d: %s\n",
track, SDL_GetError());
return;
}
playLooping = looping;
playTrack = track;
playing = true;
if (cd_volume.value == 0)
{
I_PauseCD();
}
}
int CDAudio_Init(void)
{
int i;
cvar_t *cv;
extern uid_t saved_euid;
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;
cd_volume = Cvar_Get ("cd_volume", "1", CVAR_ARCHIVE);
cd_dev = Cvar_Get("cd_dev", "/dev/cdrom", CVAR_ARCHIVE);
seteuid(saved_euid);
cdfile = open(cd_dev->string, O_RDONLY | O_NONBLOCK | O_EXCL);
seteuid(getuid());
if (cdfile == -1) {
Com_Printf("CDAudio_Init: open of \"%s\" failed (%i)\n", cd_dev->string, errno);
cdfile = -1;
return -1;
}
for (i = 0; i < 100; i++)
remap[i] = i;
initialized = true;
enabled = true;
if (CDAudio_GetAudioDiskInfo())
{
Com_Printf("CDAudio_Init: No CD in player.\n");
cdValid = false;
}
Cmd_AddCommand ("cd", CD_f);
Com_Printf("CD Audio Initialized\n");
return 0;
}
int CDAudio_Init(void)
{
int i;
if (safemode || COM_CheckParm("-nocdaudio"))
return -1;
if ((i = COM_CheckParm("-cddev")) != 0 && i < com_argc - 1)
cd_dev = com_argv[i + 1];
if ((cdfile = open(cd_dev, O_RDONLY | O_NONBLOCK)) == -1)
{
Con_Printf("%s: open of \"%s\" failed (%i)\n", __thisfunc__, cd_dev, errno);
cdfile = -1;
return -1;
}
for (i = 0; i < 100; i++)
remap[i] = i;
initialized = true;
enabled = true;
old_cdvolume = bgmvolume.value;
Con_Printf("CDAudio initialized (using BSD ioctls)\n");
if (CDAudio_GetAudioDiskInfo())
{
Con_Printf("%s: No CD in drive\n", __thisfunc__);
cdValid = false;
}
Cmd_AddCommand ("cd", CD_f);
hw_vol_works = CD_GetVolume (&orig_vol);
if (hw_vol_works)
hw_vol_works = CDAudio_SetVolume (&bgmvolume);
return 0;
}
void
CDAudio_Play(byte track, qboolean looping)
{
int err;
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 (!CDDrv_IsAudioTrack(track)) {
Con_Printf("CDAudio: track %i is not audio\n", track);
return;
}
if (playing) {
if (playTrack == track)
return;
CDAudio_Stop();
}
err = CDDrv_PlayTrack(track);
if (!err) {
playLooping = looping;
playTrack = track;
playing = true;
}
if (cdvolume == 0.0)
CDAudio_Pause();
}
int CDAudio_Init(void)
{
WAVEFORMATEX format;
DSBUFFERDESC dsbuf;
DWORD dwSize;
char* lpData;
int n;
if (cls.state == ca_dedicated)
return -1;
if (COM_CheckParm("-nocdaudio"))
return -1;
if (!dsound_init)
{
Con_Printf("CDAudio_Init: DirectSound not initialized.\n");
return -1;
}
memset (&format, 0, sizeof(format));
format.wFormatTag = WAVE_FORMAT_PCM;
format.nChannels = 2;
format.wBitsPerSample = 16;
format.nSamplesPerSec = 44100;
format.nBlockAlign = format.nChannels * format.wBitsPerSample / 8;
format.cbSize = 0;
format.nAvgBytesPerSec = format.nSamplesPerSec * format.nBlockAlign;
memset (&dsbuf, 0, sizeof(dsbuf));
dsbuf.dwSize = sizeof(DSBUFFERDESC);
dsbuf.dwFlags = DSBCAPS_GLOBALFOCUS | DSBCAPS_CTRLVOLUME | DSBCAPS_CTRLPOSITIONNOTIFY;
dsbuf.dwBufferBytes = format.nAvgBytesPerSec;
dsbuf.lpwfxFormat = &format;
if (DS_OK != pDS->lpVtbl->CreateSoundBuffer(pDS, &dsbuf, &pDSBufCD, NULL))
{
Con_Printf("CDAudio_Init: CreateSoundBuffer failed.\n");
return -1;
}
pDSBufCD->lpVtbl->QueryInterface(pDSBufCD, &IID_IDirectSoundNotify, &pDSBufCDNotify);
gCDBufSize = dsbuf.dwBufferBytes;
cdPlayingFinishedEvent = CreateEvent(NULL, TRUE, TRUE, NULL);
cdStopEvent = CreateEvent(NULL, TRUE, TRUE, NULL);
for (n = 0; n < 100; n++)
remap[n] = n;
initialized = true;
enabled = true;
if (CDAudio_GetAudioDiskInfo())
{
Con_Printf("CDAudio_Init: No tracks found.\n");
cdValid = false;
}
Cmd_AddCommand ("cd", CD_f);
Con_Printf("CD Audio Initialized\n");
return 0;
}
static void Command_Cd_f()
{
const char *command;
int ret, n;
if (!initialized)
return;
if (COM.Argc() < 2) {
CONS_Printf("cd [on] [off] [remap] [reset] [open]\n"
" [info] [play <track>] [resume]\n"
" [stop] [pause] [loop <track>]\n");
return;
}
command = COM.Argv(1);
if (!strncmp(command, "on", 2)) {
enabled = true;
return;
}
if (!strncmp(command, "off", 3)) {
I_StopCD();
enabled = false;
return;
}
if (!strncmp(command, "remap", 5)) {
ret = COM.Argc() - 2;
if (ret <= 0) {
for (n = 1; n < MAX_CD_TRACKS; n++)
if (cdRemap[n] != n)
CONS_Printf(" %u -> %u\n", n, cdRemap[n]);
return;
}
for (n = 1; n <= ret; n++)
cdRemap[n] = atoi(COM.Argv(n+1));
return;
}
if (!strncmp(command, "reset", 5)) {
enabled = true;
I_StopCD();
for (n = 0; n < MAX_CD_TRACKS; n++)
cdRemap[n] = n;
CDAudio_GetAudioDiskInfo();
return;
}
if (!cdValid)
{
CDAudio_GetAudioDiskInfo();
if (!cdValid)
return;
}
if (!strncmp(command, "open", 4)) {
I_EjectCD();
cdValid = false;
return;
}
if (!strncmp(command, "info", 4)) {
CONS_Printf("%u tracks\n", maxTrack);
if (playing)
CONS_Printf("Currently %s track %u\n", playLooping ? "looping" : "playing", playTrack);
else if (wasPlaying)
CONS_Printf("Paused %s track %u\n", playLooping ? "looping" : "playing", playTrack);
CONS_Printf("Volume is %d\n", cdvolume);
return;
}
if (!strncmp(command, "play", 4)) {
I_PlayCD((byte)atoi(COM.Argv(2)), false);
return;
}
if (!strncmp(command, "loop", 4)) {
I_PlayCD((byte)atoi(COM.Argv(2)), true);
return;
}
if (!strncmp(command, "stop", 4)) {
I_StopCD();
return;
}
if (!strncmp(command, "pause", 5)) {
I_PauseCD();
return;
}
if (!strncmp(command, "resume", 6)) {
I_ResumeCD();
return;
}
CONS_Printf("Invalid command \"cd %s\"\n", COM.Argv(1));
}
void CDAudio_Play(byte track, qboolean looping)
{
struct cdrom_tocentry entry;
struct cdrom_ti ti;
if (cdfile == -1 || !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;
}
// 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_DPrintf("ioctl cdromreadtocentry failed\n");
return;
}
if (entry.cdte_ctrl == CDROM_DATA_TRACK)
{
Con_Printf("CDAudio: track %i is not audio\n", track);
return;
}
if (playing)
{
if (playTrack == track)
return;
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_DPrintf("ioctl cdromplaytrkind failed\n");
return;
}
if ( ioctl(cdfile, CDROMRESUME) == -1 )
Con_DPrintf("ioctl cdromresume failed\n");
playLooping = looping;
playTrack = track;
playing = true;
if (cdvolume == 0.0)
CDAudio_Pause ();
}
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 = 0; n < 100; n++)
remap[n] = n;
CDAudio_GetAudioDiskInfo();
return;
}
if (Q_strcasecmp(command, "remap") == 0)
{
ret = Cmd_Argc() - 2;
if (ret <= 0)
{
for (n = 1; n < 100; n++)
if (remap[n] != n)
Con_Printf(" %u -> %u\n", n, remap[n]);
return;
}
for (n = 1; n <= ret; n++)
remap[n] = Q_atoi(Cmd_Argv (n+1));
return;
}
if (Q_strcasecmp(command, "close") == 0)
{
CDAudio_CloseDoor();
return;
}
if (!cdValid)
{
CDAudio_GetAudioDiskInfo();
if (!cdValid)
{
Con_Printf("No CD in player.\n");
return;
}
}
if (Q_strcasecmp(command, "play") == 0)
{
CDAudio_Play((byte)Q_atoi(Cmd_Argv (2)), false);
return;
}
if (Q_strcasecmp(command, "loop") == 0)
{
CDAudio_Play((byte)Q_atoi(Cmd_Argv (2)), true);
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)
{
Con_Printf("%u tracks\n", maxTrack);
if (playing)
Con_Printf("Currently %s track %u\n", playLooping ? "looping" : "playing", playTrack);
else if (wasPlaying)
Con_Printf("Paused %s track %u\n", playLooping ? "looping" : "playing", playTrack);
Con_Printf("Volume is %f\n", cdvolume);
return;
}
}
void CDAudio_Play2(int track, qboolean looping)
{
DWORD dwReturn;
MCI_PLAY_PARMS mciPlayParms;
MCI_STATUS_PARMS mciStatusParms;
if (!enabled)
return;
if (!cdValid)
{
CDAudio_GetAudioDiskInfo();
if (!cdValid)
return;
}
track = remap[track];
if (track < 1 || track > maxTrack)
{
CDAudio_Stop();
return;
}
// 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) (LPVOID) &mciStatusParms);
if (dwReturn)
{
Com_DPrintf("MCI_STATUS failed (%i)\n", dwReturn);
return;
}
if (mciStatusParms.dwReturn != MCI_CDA_TRACK_AUDIO)
{
Com_Printf("CDAudio: track %i is not audio\n", track);
return;
}
// 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) (LPVOID) &mciStatusParms);
if (dwReturn)
{
Com_DPrintf("MCI_STATUS failed (%i)\n", dwReturn);
return;
}
if (playing)
{
if (playTrack == track)
return;
CDAudio_Stop();
}
mciPlayParms.dwFrom = MCI_MAKE_TMSF(track, 0, 0, 0);
mciPlayParms.dwTo = (mciStatusParms.dwReturn << 8) | track;
mciPlayParms.dwCallback = (DWORD)cl_hwnd;
dwReturn = mciSendCommand(wDeviceID, MCI_PLAY, MCI_NOTIFY | MCI_FROM | MCI_TO, (DWORD)(LPVOID) &mciPlayParms);
if (dwReturn)
{
Com_DPrintf("CDAudio: MCI_PLAY failed (%i)\n", dwReturn);
return;
}
playLooping = looping;
playTrack = track;
playing = true;
if ( Cvar_VariableValue( "cd_nocd" ) )
CDAudio_Pause ();
}
static void CD_f (void)
{
const char *command;
int ret, n;
if (Cmd_Argc() < 2)
{
Con_Printf("commands:");
Con_Printf("on, off, reset, remap, \n");
Con_Printf("play, stop, loop, pause, resume\n");
Con_Printf("eject, info\n");
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 = 0; n < 100; n++)
remap[n] = n;
CDAudio_GetAudioDiskInfo();
return;
}
if (q_strcasecmp(command, "remap") == 0)
{
ret = Cmd_Argc () - 2;
if (ret <= 0)
{
for (n = 1; n < 100; n++)
if (remap[n] != n)
Con_Printf (" %u -> %u\n", n, remap[n]);
return;
}
for (n = 1; n <= ret; n++)
remap[n] = atoi(Cmd_Argv (n + 1));
return;
}
if (!cdValid)
{
CDAudio_GetAudioDiskInfo ();
if (!cdValid)
{
Con_Printf("No CD in player.\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, "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)
{
int current_min, current_sec, current_frame;
int length_min, length_sec, length_frame;
Con_Printf ("%u tracks\n", cd_handle->numtracks);
if (playing)
Con_Printf ("Currently %s track %u\n", playLooping ? "looping" : "playing", playTrack);
else if (wasPlaying)
Con_Printf ("Paused %s track %u\n", playLooping ? "looping" : "playing", playTrack);
if (playing || wasPlaying)
{
SDL_CDStatus(cd_handle);
FRAMES_TO_MSF(cd_handle->cur_frame, ¤t_min, ¤t_sec, ¤t_frame);
FRAMES_TO_MSF(cd_handle->track[playTrack-1].length, &length_min, &length_sec, &length_frame);
Con_Printf ("Current position: %d:%02d.%02d (of %d:%02d.%02d)\n",
current_min, current_sec, current_frame * 60 / CD_FPS,
length_min, length_sec, length_frame * 60 / CD_FPS);
}
Con_Printf ("Volume is %f\n", bgmvolume.value);
return;
}
}
static int CDAudio_GetAudioDiskInfo(void)
{
#if defined(__FreeBSD__)
struct ioc_toc_header tochdr;
#else
struct cdrom_tochdr tochdr;
#endif
cdValid = false;
#if defined(__FreeBSD__)
if ( ioctl(cdfile, CDIOREADTOCHEADER, &tochdr) == -1 )
{
Com_DPrintf("ioctl cdioreadtocheader failed\n");
#else
if ( ioctl(cdfile, CDROMREADTOCHDR, &tochdr) == -1 )
{
Com_DPrintf("ioctl cdromreadtochdr failed\n");
#endif
return -1;
}
#if defined(__FreeBSD__)
if (tochdr.starting_track < 1)
#else
if (tochdr.cdth_trk0 < 1)
#endif
{
Com_DPrintf("CDAudio: no music tracks\n");
return -1;
}
cdValid = true;
#if defined(__FreeBSD__)
maxTrack = tochdr.ending_track;
#else
maxTrack = tochdr.cdth_trk1;
#endif
return 0;
}
void CDAudio_Play(int track, qboolean looping)
{
#if defined(__FreeBSD__)
struct ioc_read_toc_entry entry;
struct cd_toc_entry toc_buffer;
struct ioc_play_track ti;
#else
struct cdrom_tocentry entry;
struct cdrom_ti ti;
#endif
if (cdfile == -1 || !enabled)
return;
if (!cdValid)
{
CDAudio_GetAudioDiskInfo();
if (!cdValid)
return;
}
track = remap[track];
if (track < 1 || track > maxTrack)
{
Com_DPrintf("CDAudio: Bad track number %u.\n", track);
return;
}
#if defined(__FreeBSD__)
#define CDROM_DATA_TRACK 4
bzero((char *)&toc_buffer, sizeof(toc_buffer));
entry.data_len = sizeof(toc_buffer);
entry.data = &toc_buffer;
// don't try to play a non-audio track
entry.starting_track = track;
entry.address_format = CD_MSF_FORMAT;
if ( ioctl(cdfile, CDIOREADTOCENTRYS, &entry) == -1 )
{
Com_DPrintf("ioctl cdromreadtocentry failed\n");
return;
}
if (toc_buffer.control == CDROM_DATA_TRACK)
#else
// don't try to play a non-audio track
entry.cdte_track = track;
entry.cdte_format = CDROM_LBA;
if ( ioctl(cdfile, CDROMREADTOCENTRY, &entry) == -1 )
{
Com_DPrintf("ioctl cdromreadtocentry failed\n");
return;
}
if (entry.cdte_ctrl == CDROM_DATA_TRACK)
#endif
{
Com_Printf("CDAudio: track %i is not audio\n", track);
return;
}
if (playing)
{
if (playTrack == track)
return;
CDAudio_Stop();
}
#if defined(__FreeBSD__)
ti.start_track = track;
ti.end_track = track;
ti.start_index = 1;
ti.end_index = 99;
#else
ti.cdti_trk0 = track;
ti.cdti_trk1 = track;
ti.cdti_ind0 = 0;
ti.cdti_ind1 = 0;
#endif
#if defined(__FreeBSD__)
if ( ioctl(cdfile, CDIOCPLAYTRACKS, &ti) == -1 )
#else
if ( ioctl(cdfile, CDROMPLAYTRKIND, &ti) == -1 )
#endif
{
Com_DPrintf("ioctl cdromplaytrkind failed\n");
return;
}
#if defined(__FreeBSD__)
if ( ioctl(cdfile, CDIOCRESUME) == -1 )
#else
if ( ioctl(cdfile, CDROMRESUME) == -1 )
#endif
Com_DPrintf("ioctl cdromresume failed\n");
playLooping = looping;
playTrack = track;
playing = true;
if (cd_volume->value == 0.0)
CDAudio_Pause ();
}
void CDAudio_Stop(void)
{
if (cdfile == -1 || !enabled)
return;
if (!playing)
return;
#if defined(__FreeBSD__)
if ( ioctl(cdfile, CDIOCSTOP) == -1 )
Com_DPrintf("ioctl cdiocstop failed (%d)\n", errno);
#else
if ( ioctl(cdfile, CDROMSTOP) == -1 )
Com_DPrintf("ioctl cdromstop failed (%d)\n", errno);
#endif
wasPlaying = false;
playing = false;
}
void CDAudio_Pause(void)
{
if (cdfile == -1 || !enabled)
return;
if (!playing)
return;
#if defined(__FreeBSD__)
if ( ioctl(cdfile, CDIOCPAUSE) == -1 )
Com_DPrintf("ioctl cdiocpause failed\n");
#else
if ( ioctl(cdfile, CDROMPAUSE) == -1 )
Com_DPrintf("ioctl cdrompause failed\n");
#endif
wasPlaying = playing;
playing = false;
}
void CDAudio_Resume(void)
{
if (cdfile == -1 || !enabled)
return;
if (!cdValid)
return;
if (!wasPlaying)
return;
#if defined(__FreeBSD__)
if ( ioctl(cdfile, CDIOCRESUME) == -1 )
Com_DPrintf("ioctl cdiocresume failed\n");
#else
if ( ioctl(cdfile, CDROMRESUME) == -1 )
Com_DPrintf("ioctl cdromresume failed\n");
#endif
playing = true;
}
static void CD_f (void)
{
char *command;
int ret;
int n;
if (Cmd_Argc() < 2)
return;
command = Cmd_Argv (1);
if (Q_stricmp(command, "on") == 0)
{
enabled = true;
return;
}
if (Q_stricmp(command, "off") == 0)
{
if (playing)
CDAudio_Stop();
enabled = false;
return;
}
if (Q_stricmp(command, "reset") == 0)
{
enabled = true;
if (playing)
CDAudio_Stop();
for (n = 0; n < 100; n++)
remap[n] = n;
CDAudio_GetAudioDiskInfo();
return;
}
if (Q_stricmp(command, "remap") == 0)
{
ret = Cmd_Argc() - 2;
if (ret <= 0)
{
for (n = 1; n < 100; 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_stricmp(command, "close") == 0)
{
CDAudio_CloseDoor();
return;
}
if (!cdValid)
{
CDAudio_GetAudioDiskInfo();
if (!cdValid)
{
Com_Printf("No CD in player.\n");
return;
}
}
if (Q_stricmp(command, "play") == 0)
{
CDAudio_Play((byte)atoi(Cmd_Argv (2)), false);
return;
}
if (Q_stricmp(command, "loop") == 0)
{
CDAudio_Play((byte)atoi(Cmd_Argv (2)), true);
return;
}
if (Q_stricmp(command, "stop") == 0)
{
CDAudio_Stop();
return;
}
if (Q_stricmp(command, "pause") == 0)
{
CDAudio_Pause();
return;
}
if (Q_stricmp(command, "resume") == 0)
{
CDAudio_Resume();
return;
}
if (Q_stricmp(command, "eject") == 0)
{
if (playing)
CDAudio_Stop();
CDAudio_Eject();
cdValid = false;
return;
}
if (Q_stricmp(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;
}
}
static void CD_f (void)
{
const char *command;
#ifdef MAXTRACKS
int ret;
int n;
#endif
command = Cmd_Argv (1);
if (strcasecmp(command, "remap") != 0)
Host_StartVideo();
if (strcasecmp(command, "on") == 0)
{
enabled = true;
return;
}
if (strcasecmp(command, "off") == 0)
{
CDAudio_Stop();
enabled = false;
return;
}
if (strcasecmp(command, "reset") == 0)
{
enabled = true;
CDAudio_Stop();
#ifdef MAXTRACKS
for (n = 0; n < MAXTRACKS; n++)
*remap[n] = 0; // empty string, that is, unremapped
#endif
CDAudio_GetAudioDiskInfo();
return;
}
if (strcasecmp(command, "rescan") == 0)
{
CDAudio_Shutdown();
CDAudio_Startup();
return;
}
if (strcasecmp(command, "remap") == 0)
{
#ifdef MAXTRACKS
ret = Cmd_Argc() - 2;
if (ret <= 0)
{
for (n = 1; n < MAXTRACKS; n++)
if (*remap[n])
Con_Printf(" %u -> %s\n", n, remap[n]);
return;
}
for (n = 1; n <= ret; n++)
strlcpy(remap[n], Cmd_Argv (n+1), sizeof(*remap));
#endif
return;
}
if (strcasecmp(command, "close") == 0)
{
CDAudio_CloseDoor();
return;
}
if (strcasecmp(command, "play") == 0)
{
if (music_playlist_index.integer >= 0)
return;
CDAudio_Play_byName(Cmd_Argv (2), false, true, 0);
return;
}
if (strcasecmp(command, "loop") == 0)
{
if (music_playlist_index.integer >= 0)
return;
CDAudio_Play_byName(Cmd_Argv (2), true, true, 0);
return;
}
if (strcasecmp(command, "stop") == 0)
{
if (music_playlist_index.integer >= 0)
return;
CDAudio_Stop();
return;
}
if (strcasecmp(command, "pause") == 0)
{
if (music_playlist_index.integer >= 0)
return;
CDAudio_Pause();
return;
}
if (strcasecmp(command, "resume") == 0)
{
if (music_playlist_index.integer >= 0)
return;
CDAudio_Resume();
return;
}
if (strcasecmp(command, "eject") == 0)
{
if (faketrack == -1)
CDAudio_Stop();
CDAudio_Eject();
cdValid = false;
return;
}
if (strcasecmp(command, "info") == 0)
{
CDAudio_GetAudioDiskInfo ();
if (cdValid)
Con_Printf("%u tracks on CD.\n", maxTrack);
else
Con_Print ("No CD in player.\n");
if (cdPlaying)
Con_Printf("Currently %s track %u\n", cdPlayLooping ? "looping" : "playing", cdPlayTrack);
else if (wasPlaying)
Con_Printf("Paused %s track %u\n", cdPlayLooping ? "looping" : "playing", cdPlayTrack);
if (cdvolume >= 0)
Con_Printf("Volume is %f\n", cdvolume);
else
Con_Printf("Can't get CD volume\n");
return;
}
Con_Printf("CD commands:\n");
Con_Printf("cd on - enables CD audio system\n");
Con_Printf("cd off - stops and disables CD audio system\n");
Con_Printf("cd reset - resets CD audio system (clears track remapping and re-reads disc information)\n");
Con_Printf("cd rescan - rescans disks in drives (to use another disc)\n");
Con_Printf("cd remap <remap1> [remap2] [remap3] [...] - chooses (possibly emulated) CD tracks to play when a map asks for a particular track, this has many uses\n");
Con_Printf("cd close - closes CD tray\n");
Con_Printf("cd eject - stops playing music and opens CD tray to allow you to change disc\n");
Con_Printf("cd play <tracknumber> - plays selected track in remapping table\n");
Con_Printf("cd loop <tracknumber> - plays and repeats selected track in remapping table\n");
Con_Printf("cd stop - stops playing current CD track\n");
Con_Printf("cd pause - pauses CD playback\n");
Con_Printf("cd resume - unpauses CD playback\n");
Con_Printf("cd info - prints basic disc information (number of tracks, currently playing track, volume level)\n");
}
void CDAudio_Play_byName (const char *trackname, qboolean looping, qboolean tryreal, float startposition)
{
unsigned int track;
sfx_t* sfx;
char filename[MAX_QPATH];
Host_StartVideo();
if (!enabled)
return;
if(tryreal && strspn(trackname, "0123456789") == strlen(trackname))
{
track = (unsigned char) atoi(trackname);
#ifdef MAXTRACKS
if(track > 0 && track < MAXTRACKS)
if(*remap[track])
{
if(strspn(remap[track], "0123456789") == strlen(remap[track]))
{
trackname = remap[track];
}
else
{
// ignore remappings to fake tracks if we're going to play a real track
switch(cdaudio.integer)
{
case 0: // we never access CD
case 1: // we have a replacement
trackname = remap[track];
break;
case 2: // we only use fake track replacement if CD track is invalid
CDAudio_GetAudioDiskInfo();
if(!cdValid || track > maxTrack)
trackname = remap[track];
break;
case 3: // we always play from CD - ignore this remapping then
case 4: // we randomize anyway
break;
}
}
}
#endif
}
if(tryreal && strspn(trackname, "0123456789") == strlen(trackname))
{
track = (unsigned char) atoi(trackname);
if (track < 1)
{
Con_DPrintf("CDAudio: Bad track number %u.\n", track);
return;
}
}
else
track = 0;
// div0: I assume this code was intentionally there. Maybe turn it into a cvar?
if (cdPlaying && cdPlayTrack == track && faketrack == -1)
return;
CDAudio_Stop ();
if(track >= 1)
{
if(cdaudio.integer == 3) // only play real CD tracks at all
{
if(CDAudio_Play_real(track, looping, true))
goto success;
return;
}
if(cdaudio.integer == 2) // prefer real CD track over fake
{
if(CDAudio_Play_real(track, looping, false))
goto success;
}
}
if(cdaudio.integer == 4) // only play real CD tracks, EVEN instead of fake tracks!
{
if(CDAudio_Play_real(track, looping, false))
goto success;
if(cdValid && maxTrack > 0)
{
track = 1 + (rand() % maxTrack);
if(CDAudio_Play_real(track, looping, true))
goto success;
}
else
{
Con_DPrint ("No CD in player.\n");
}
return;
}
// Try playing a fake track (sound file) first
if(track >= 1)
{
dpsnprintf(filename, sizeof(filename), "sound/cdtracks/track%03u.wav", track);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "sound/cdtracks/track%03u.ogg", track);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "music/track%03u.ogg", track);// added by motorsep
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "music/cdtracks/track%03u.ogg", track);// added by motorsep
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "sound/cdtracks/track%02u.wav", track);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "sound/cdtracks/track%02u.ogg", track);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "music/track%02u.ogg", track);// added by motorsep
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "music/cdtracks/track%02u.ogg", track);// added by motorsep
}
else
{
dpsnprintf(filename, sizeof(filename), "%s", trackname);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "%s.wav", trackname);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "%s.ogg", trackname);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "sound/%s", trackname);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "sound/%s.wav", trackname);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "sound/%s.ogg", trackname);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "sound/cdtracks/%s", trackname);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "sound/cdtracks/%s.wav", trackname);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "sound/cdtracks/%s.ogg", trackname);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "music/%s.ogg", trackname); // added by motorsep
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "music/cdtracks/%s.ogg", trackname); // added by motorsep
}
if (FS_FileExists(filename) && (sfx = S_PrecacheSound (filename, false, true)))
{
faketrack = S_StartSound_StartPosition (-1, 0, sfx, vec3_origin, cdvolume, 0, startposition);
if (faketrack != -1)
{
if (looping)
S_SetChannelFlag (faketrack, CHANNELFLAG_FORCELOOP, true);
S_SetChannelFlag (faketrack, CHANNELFLAG_FULLVOLUME, true);
S_SetChannelFlag (faketrack, CHANNELFLAG_LOCALSOUND, true); // not pausable
if(track >= 1)
{
if(cdaudio.integer != 0) // we don't need these messages if only fake tracks can be played anyway
Con_DPrintf ("Fake CD track %u playing...\n", track);
}
else
Con_DPrintf ("BGM track %s playing...\n", trackname);
}
}
// If we can't play a fake CD track, try the real one
if (faketrack == -1)
{
if(cdaudio.integer == 0 || track < 1)
{
Con_Print("Could not load BGM track.\n");
return;
}
else
{
if(!CDAudio_Play_real(track, looping, true))
return;
}
}
success:
cdPlayLooping = looping;
cdPlayTrack = track;
cdPlaying = true;
if (cdvolume == 0.0 || bgmvolume.value == 0)
CDAudio_Pause ();
}
int CDAudio_Init(void)
{
int i, x, sdl_num_drives;
if (safemode || COM_CheckParm("-nocdaudio"))
return -1;
if (SDL_InitSubSystem(SDL_INIT_CDROM) < 0)
{
Con_Printf("Couldn't init SDL cdrom: %s\n", SDL_GetError());
return -1;
}
sdl_num_drives = SDL_CDNumDrives ();
Con_Printf ("SDL detected %d CD-ROM drive%c\n", sdl_num_drives,
sdl_num_drives == 1 ? ' ' : 's');
if (sdl_num_drives < 1)
return -1;
if ((i = COM_CheckParm("-cddev")) != 0 && i < com_argc - 1)
{
for (x = 0; x < sdl_num_drives; x++)
{
if (!q_strcasecmp(SDL_CDName(x), com_argv[i+1]))
{
cd_dev = x;
break;
}
}
if (cd_dev == -1)
{
Con_Printf("SDL couldn't find cdrom device %s\n", com_argv[i+1]);
return -1;
}
}
if (cd_dev == -1)
cd_dev = 0; // default drive
cd_handle = SDL_CDOpen(cd_dev);
if (!cd_handle)
{
Con_Printf ("%s: Unable to open CD-ROM drive %s (%s)\n",
__thisfunc__, SDL_CDName(cd_dev), SDL_GetError());
return -1;
}
for (i = 0; i < 100; i++)
remap[i] = i;
enabled = true;
old_cdvolume = bgmvolume.value;
Con_Printf("CDAudio initialized (SDL, using %s)\n", SDL_CDName(cd_dev));
if (CDAudio_GetAudioDiskInfo())
{
Con_Printf("%s: No CD in drive\n", __thisfunc__);
cdValid = false;
}
Cmd_AddCommand ("cd", CD_f);
// cd hardware volume: no SDL support at present.
hw_vol_works = CD_GetVolume (NULL);
if (hw_vol_works)
hw_vol_works = CDAudio_SetVolume (&bgmvolume);
return 0;
}
static int CDAudio_GetAudioDiskInfo(void)
{
#if defined(__FreeBSD__)
struct ioc_toc_header tochdr;
#endif
#ifdef __linux__
struct cdrom_tochdr tochdr;
#endif
cdValid = false;
#if defined(__FreeBSD__)
if ( ioctl(cdfile, CDIOREADTOCHEADER, &tochdr) == -1 )
{
Com_DPrintf("ioctl cdioreadtocheader failed\n");
#endif
#ifdef __linux__
if ( ioctl(cdfile, CDROMREADTOCHDR, &tochdr) == -1 )
{
Com_DPrintf("ioctl cdromreadtochdr failed\n");
#endif
return -1;
}
#if defined(__FreeBSD__)
if (tochdr.starting_track < 1)
#endif
#ifdef __linux__
if (tochdr.cdth_trk0 < 1)
#endif
{
Com_DPrintf("CDAudio: no music tracks\n");
return -1;
}
cdValid = true;
#if defined(__FreeBSD__)
maxTrack = tochdr.ending_track;
#endif
#ifdef __linux__
maxTrack = tochdr.cdth_trk1;
#endif
return 0;
}
void CDAudio_Play(int track, qboolean looping)
{
#if defined(__FreeBSD__)
struct ioc_read_toc_entry entry;
struct cd_toc_entry toc_buffer;
struct ioc_play_track ti;
#endif
#if defined(__linux__)
struct cdrom_tocentry entry;
struct cdrom_ti ti;
#endif
if (cdfile == -1 || !enabled)
return;
if (!cdValid)
{
CDAudio_GetAudioDiskInfo();
if (!cdValid)
return;
}
track = remap[track];
if (track < 1 || track > maxTrack)
{
Com_DPrintf("CDAudio: Bad track number %u.\n", track);
return;
}
#if defined(__FreeBSD__)
#define CDROM_DATA_TRACK 4
bzero((char *)&toc_buffer, sizeof(toc_buffer));
entry.data_len = sizeof(toc_buffer);
entry.data = &toc_buffer;
// don't try to play a non-audio track
entry.starting_track = track;
entry.address_format = CD_MSF_FORMAT;
if ( ioctl(cdfile, CDIOREADTOCENTRYS, &entry) == -1 )
{
Com_DPrintf("ioctl cdromreadtocentry failed\n");
return;
}
if (toc_buffer.control == CDROM_DATA_TRACK)
#endif
#if defined(__linux__)
// don't try to play a non-audio track
entry.cdte_track = track;
entry.cdte_format = CDROM_LBA;
if ( ioctl(cdfile, CDROMREADTOCENTRY, &entry) == -1 )
{
Com_DPrintf("ioctl cdromreadtocentry failed\n");
return;
}
if (entry.cdte_ctrl == CDROM_DATA_TRACK)
#endif
{
Com_Printf("CDAudio: track %i is not audio\n", track);
return;
}
if (playing)
{
if (playTrack == track)
return;
CDAudio_Stop();
}
#if defined(__FreeBSD__)
ti.start_track = track;
ti.end_track = track;
ti.start_index = 1;
ti.end_index = 99;
#endif
#if defined(__linux__)
ti.cdti_trk0 = track;
ti.cdti_trk1 = track;
ti.cdti_ind0 = 0;
ti.cdti_ind1 = 0;
#endif
#if defined(__FreeBSD__)
if ( ioctl(cdfile, CDIOCPLAYTRACKS, &ti) == -1 )
#endif
#if defined(__linux__)
if ( ioctl(cdfile, CDROMPLAYTRKIND, &ti) == -1 )
#endif
{
Com_DPrintf("ioctl cdromplaytrkind failed\n");
return;
}
#if defined(__FreeBSD__)
if ( ioctl(cdfile, CDIOCRESUME) == -1 )
#endif
#if defined(__linux__)
if ( ioctl(cdfile, CDROMRESUME) == -1 )
#endif
Com_DPrintf("ioctl cdromresume failed\n");
playLooping = looping;
playTrack = track;
playing = true;
if (cd_volume->value == 0.0)
CDAudio_Pause ();
}
void CDAudio_RandomPlay(void)
{
int track, i = 0, free_tracks = 0, remap_track;
float f;
byte* track_bools;
#if defined(__FreeBSD__)
struct ioc_read_toc_entry entry;
struct cd_toc_entry toc_buffer;
struct ioc_play_track ti;
#endif
#if defined(__linux__)
struct cdrom_tocentry entry;
struct cdrom_ti ti;
#endif
if (cdfile == -1 || !enabled)
return;
track_bools = (byte*)malloc(maxTrack * sizeof(byte));
if (track_bools == 0)
return;
//create array of available audio tracknumbers
for (; i < maxTrack; i++)
{
#if defined(__FreeBSD__)
#define CDROM_DATA_TRACK 4
bzero((char *)&toc_buffer, sizeof(toc_buffer));
entry.data_len = sizeof(toc_buffer);
entry.data = &toc_buffer;
entry.starting_track = remap[i];
entry.address_format = CD_LBA_FORMAT;
if ( ioctl(cdfile, CDIOREADTOCENTRYS, &entry) == -1 )
{
track_bools[i] = 0;
}
else
track_bools[i] = (entry.data->control != CDROM_DATA_TRACK);
#endif
#if defined(__linux__)
entry.cdte_track = remap[i];
entry.cdte_format = CDROM_LBA;
if ( ioctl(cdfile, CDROMREADTOCENTRY, &entry) == -1 )
{
track_bools[i] = 0;
}
else
track_bools[i] = (entry.cdte_ctrl != CDROM_DATA_TRACK);
#endif
free_tracks += track_bools[i];
}
if (!free_tracks)
{
Com_DPrintf("CDAudio_RandomPlay: Unable to find and play a random audio track, insert an audio cd please");
goto free_end;
}
//choose random audio track
do
{
do
{
f = ((float)rand()) / ((float)RAND_MAX + 1.0);
track = (int)(maxTrack * f);
}
while(!track_bools[track]);
remap_track = remap[track];
if (playing)
{
if (playTrack == remap_track)
{
goto free_end;
}
CDAudio_Stop();
}
#if defined(__FreeBSD__)
#define CDROMPLAYTRKIND 0x5304
ti.start_track = remap_track;
ti.end_track = remap_track;
ti.start_index = 0;
ti.end_index = 0;
#endif
#if defined(__linux__)
ti.cdti_trk0 = remap_track;
ti.cdti_trk1 = remap_track;
ti.cdti_ind0 = 0;
ti.cdti_ind1 = 0;
#endif
if ( ioctl(cdfile, CDROMPLAYTRKIND, &ti) == -1 )
{
track_bools[track] = 0;
free_tracks--;
}
else
{
playLooping = true;
playTrack = remap_track;
playing = true;
break;
}
}
while (free_tracks > 0);
free_end:
free((void*)track_bools);
}
void CDAudio_Play(byte track, qboolean looping)
{
int len_m, len_s, len_f;
if (!cd_handle || !enabled)
return;
if (!cdValid)
{
CDAudio_GetAudioDiskInfo();
if (!cdValid)
return;
}
track = remap[track];
if (track < 1 || track > cd_handle->numtracks)
{
Con_Printf ("%s: Bad track number %d.\n", __thisfunc__, track);
return;
}
if (cd_handle->track[track-1].type == SDL_DATA_TRACK)
{
Con_Printf ("%s: track %d is not audio\n", __thisfunc__, track);
return;
}
if (playing)
{
if (playTrack == track)
return;
CDAudio_Stop ();
}
if (SDL_CDPlay(cd_handle, cd_handle->track[track-1].offset, cd_handle->track[track-1].length) < 0)
{
// ok, check for status now
int cd_status = SDL_CDStatus(cd_handle);
if (cd_status > 0)
Con_Printf ("%s: Unable to play %d: %s\n", __thisfunc__, track, SDL_GetError ());
return;
}
playLooping = looping;
playTrack = track;
playing = true;
FRAMES_TO_MSF(cd_handle->track[track-1].length, &len_m, &len_s, &len_f);
endOfTrack = realtime + ((double)len_m * 60.0) + (double)len_s + (double)len_f / (double)CD_FPS;
/*
* Add the pregap for the next track. This means that disc-at-once CDs
* won't loop smoothly, but they wouldn't anyway so it doesn't really
* matter. SDL doesn't give us pregap information anyway, so you'll
* just have to live with it.
*/
endOfTrack += 2.0;
pausetime = -1.0;
if (!hw_vol_works && bgmvolume.value == 0.0)
CDAudio_Pause ();
}
