static void CLQ1_ParseCDTrack( QMsg& message ) {
byte cdtrack = message.ReadByte();
message.ReadByte(); // looptrack
if ( ( clc.demoplaying || clc.demorecording ) && ( cls.qh_forcetrack != -1 ) ) {
CDAudio_Play( ( byte )cls.qh_forcetrack, true );
} else {
CDAudio_Play( cdtrack, true );
}
}
int CDAudio_SysUpdate (void)
{
struct cdrom_subchnl subchnl;
static time_t lastchk = 0;
if (cdPlaying && lastchk < time(NULL) && cdfile != -1)
{
lastchk = time(NULL) + 2; //two seconds between chks
subchnl.cdsc_format = CDROM_MSF;
if (ioctl(cdfile, CDROMSUBCHNL, &subchnl) == -1)
{
Con_Print("ioctl CDROMSUBCHNL failed\n");
cdPlaying = false;
return -1;
}
if (subchnl.cdsc_audiostatus != CDROM_AUDIO_PLAY &&
subchnl.cdsc_audiostatus != CDROM_AUDIO_PAUSED)
{
cdPlaying = false;
if (cdPlayLooping)
CDAudio_Play(cdPlayTrack, true);
}
else
cdPlayTrack = subchnl.cdsc_trk;
}
return 0;
}
/*
============
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;
}
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 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);
}
}
/*
================
CL_ParseConfigString
================
*/
void CL_ParseConfigString(void)
{
int i;
char * s;
i = MSG_ReadShort(&net_message);
if (i < 0 || i >= MAX_CONFIGSTRINGS)
{
Com_Error(ERR_DROP, "configstring > MAX_CONFIGSTRINGS");
}
s = MSG_ReadString(&net_message);
strcpy(cl.configstrings[i], s);
// do something apropriate
if (i >= CS_LIGHTS && i < CS_LIGHTS + MAX_LIGHTSTYLES)
{
CL_SetLightstyle(i - CS_LIGHTS);
}
else if (i == CS_CDTRACK)
{
if (cl.refresh_prepped)
{
CDAudio_Play(atoi(cl.configstrings[CS_CDTRACK]), true);
}
}
else if (i >= CS_MODELS && i < CS_MODELS + MAX_MODELS)
{
if (cl.refresh_prepped)
{
cl.model_draw[i - CS_MODELS] = re.RegisterModel(cl.configstrings[i]);
if (cl.configstrings[i][0] == '*')
cl.model_clip[i - CS_MODELS] = CM_InlineModel(cl.configstrings[i]);
else
cl.model_clip[i - CS_MODELS] = NULL;
}
}
else if (i >= CS_SOUNDS && i < CS_SOUNDS + MAX_MODELS)
{
if (cl.refresh_prepped)
cl.sound_precache[i - CS_SOUNDS] = S_RegisterSound(cl.configstrings[i]);
}
else if (i >= CS_IMAGES && i < CS_IMAGES + MAX_MODELS)
{
if (cl.refresh_prepped)
cl.image_precache[i - CS_IMAGES] = re.RegisterPic(cl.configstrings[i]);
}
else if (i >= CS_PLAYERSKINS && i < CS_PLAYERSKINS + MAX_CLIENTS)
{
if (cl.refresh_prepped)
CL_ParseClientinfo(i - CS_PLAYERSKINS);
}
}
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 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_Update(void)
{
static time_t lastchk;
if (!enabled)
return;
if (playing && lastchk < time(NULL)) {
lastchk = time(NULL) + 2; //two seconds between chks
if (!CDDrv_IsPlaying(playTrack)) {
playing = false;
if (playLooping)
CDAudio_Play(playTrack, true);
}
}
}
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 DoDeathSpecial(short SpriteNum)
{
SPRITEp sp = &sprite[SpriteNum];
USERp u = User[SpriteNum];
static BOOL alreadydid = FALSE;
DoMatchEverything(NULL, sp->lotag, ON);
#ifndef SW_SHAREWARE
if(gs.MusicOn && !alreadydid)
{
CDAudio_Stop();
CDAudio_Play(RedBookSong[Level], TRUE);
alreadydid = TRUE;
}
#endif
BossSpriteNum[0] = -2;
return(0);
}
void CDAudio_Update(void)
{
struct ioc_read_subchannel subchnl;
struct cd_sub_channel_info data;
static time_t lastchk;
if (cdfile == -1 || !enabled)
return;
if (old_cdvolume != bgmvolume.value)
CDAudio_SetVolume (&bgmvolume);
if (playing && lastchk < time(NULL))
{
lastchk = time(NULL) + 2; //two seconds between chks
memset (&subchnl, 0, sizeof(subchnl));
subchnl.data = &data;
subchnl.data_len = sizeof(data);
subchnl.address_format = CD_MSF_FORMAT;
subchnl.data_format = CD_CURRENT_POSITION;
subchnl.track = playTrack;
if (ioctl(cdfile, CDIOCREADSUBCHANNEL, &subchnl) == -1 )
{
IOCTL_FAILURE(CDIOCREADSUBCHANNEL);
playing = false;
return;
}
if (data.header.audio_status != CD_AS_PLAY_IN_PROGRESS &&
data.header.audio_status != CD_AS_PLAY_PAUSED)
{
playing = false;
if (playLooping)
CDAudio_Play(playTrack, true);
}
else
{
playTrack = data.what.position.track_number;
}
}
}
void CDAudio_Update(void)
{
struct cdrom_subchnl subchnl;
static time_t lastchk;
if (!enabled)
return;
if (bgmvolume.value != cdvolume)
{
if (cdvolume)
{
Cvar_SetValue ("bgmvolume", 0.0);
cdvolume = bgmvolume.value;
CDAudio_Pause ();
}
else
{
Cvar_SetValue ("bgmvolume", 1.0);
cdvolume = bgmvolume.value;
CDAudio_Resume ();
}
}
if (playing && lastchk < time(NULL)) {
lastchk = time(NULL) + 2; //two seconds between chks
subchnl.cdsc_format = CDROM_MSF;
if (ioctl(cdfile, CDROMSUBCHNL, &subchnl) == -1 ) {
Con_DPrintf("ioctl cdromsubchnl failed\n");
playing = false;
return;
}
if (subchnl.cdsc_audiostatus != CDROM_AUDIO_PLAY &&
subchnl.cdsc_audiostatus != CDROM_AUDIO_PAUSED) {
playing = false;
if (playLooping)
CDAudio_Play(playTrack, true);
}
}
}
void CDA_Start (int track, qboolean loop, qboolean notify)
{
#ifdef UQE_FMOD_CDAUDIO
if (SND_InitialisedCD == false)
return;
if(SND_MusicChannel.inuse == true)
FMOD_MusicStop();
if(loop == true)
{
SND_MusicChannel.looping = true;
result = FMOD_Sound_SetMode(fmod_musicCD, FMOD_LOOP_NORMAL);
FMOD_ERROR(result, true, false);
}
else
{
SND_MusicChannel.looping = false;
result = FMOD_Sound_SetMode(fmod_musicCD, FMOD_LOOP_OFF);
FMOD_ERROR(result, true, false);
}
// fmod track numbers starts at zero
result = FMOD_Sound_GetSubSound(fmod_musicCD, track-1, &fmod_musicCD_subsound);
FMOD_ERROR(result, notify, false);
result = FMOD_System_GetChannel(fmod_system, 0, &SND_MusicChannel.channel);
FMOD_ERROR(result, true, false);
result = FMOD_System_PlaySound(fmod_system, FMOD_CHANNEL_REUSE, fmod_musicCD_subsound, FALSE, &SND_MusicChannel.channel);
FMOD_ERROR(result, notify, false);
SND_MusicChannel.inuse = true;
#else
CDAudio_Play((byte)track, loop);
#endif
}
void CDAudio_Update()
{
if(!cd_id || !enabled) return;
if(bgmvolume.value != cdvolume)
{
if(cdvolume)
{
Cvar_SetValue("bgmvolume",0.0);
CDAudio_Pause();
}
else
{
Cvar_SetValue("bgmvolume",1.0);
CDAudio_Resume();
}
cdvolume = bgmvolume.value;
return;
}
if(playLooping && (SDL_CDStatus(cd_id) != CD_PLAYING)
&& (SDL_CDStatus(cd_id) != CD_PAUSED))
CDAudio_Play(cd_id->cur_track+1,true);
}
void CDAudio_Update(void)
{
CDstatus curstat;
if (!cd_handle || !enabled)
return;
if (old_cdvolume != bgmvolume.value)
CDAudio_SetVolume (&bgmvolume);
if (playing && realtime > endOfTrack)
{
// curstat = cd_handle->status;
curstat = SDL_CDStatus(cd_handle);
if (curstat != CD_PLAYING && curstat != CD_PAUSED)
{
playing = false;
endOfTrack = -1.0;
if (playLooping)
CDAudio_Play(playTrack, true);
}
}
}
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 CL_PlayBackgroundTrack (void)
{
CDAudio_Play (atoi(cl.configstrings[CS_CDTRACK]), true);
}
// Call before entering a new level, or after changing dlls
void CLQ2_PrepRefresh() {
if ( !cl.q2_configstrings[ Q2CS_MODELS + 1 ][ 0 ] ) {
return; // no map loaded
}
// let the render dll load the map
char mapname[ 32 ];
String::Cpy( mapname, cl.q2_configstrings[ Q2CS_MODELS + 1 ] + 5 ); // skip "maps/"
mapname[ String::Length( mapname ) - 4 ] = 0; // cut off ".bsp"
// register models, pics, and skins
common->Printf( "Map: %s\r", mapname );
SCR_UpdateScreen();
R_BeginRegistrationAndLoadWorld( mapname );
common->Printf( " \r" );
// precache status bar pics
common->Printf( "pics\r" );
SCR_UpdateScreen();
SCRQ2_InitHudShaders();
SCR_TouchPics();
common->Printf( " \r" );
CLQ2_RegisterTEntModels();
clq2_num_weaponmodels = 1;
String::Cpy( clq2_weaponmodels[ 0 ], "weapon.md2" );
for ( int i = 1; i < MAX_MODELS_Q2 && cl.q2_configstrings[ Q2CS_MODELS + i ][ 0 ]; i++ ) {
char name[ MAX_QPATH ];
String::Cpy( name, cl.q2_configstrings[ Q2CS_MODELS + i ] );
name[ 37 ] = 0; // never go beyond one line
if ( name[ 0 ] != '*' ) {
common->Printf( "%s\r", name );
}
SCR_UpdateScreen();
if ( name[ 0 ] == '#' ) {
// special player weapon model
if ( clq2_num_weaponmodels < MAX_CLIENTWEAPONMODELS_Q2 ) {
String::NCpy( clq2_weaponmodels[ clq2_num_weaponmodels ], cl.q2_configstrings[ Q2CS_MODELS + i ] + 1,
sizeof ( clq2_weaponmodels[ clq2_num_weaponmodels ] ) - 1 );
clq2_num_weaponmodels++;
}
} else {
cl.model_draw[ i ] = R_RegisterModel( cl.q2_configstrings[ Q2CS_MODELS + i ] );
if ( name[ 0 ] == '*' ) {
cl.model_clip[ i ] = CM_InlineModel( String::Atoi( cl.q2_configstrings[ Q2CS_MODELS + i ] + 1 ) );
} else {
cl.model_clip[ i ] = 0;
}
}
if ( name[ 0 ] != '*' ) {
common->Printf( " \r" );
}
}
common->Printf( "images\r" );
SCR_UpdateScreen();
for ( int i = 1; i < MAX_IMAGES_Q2 && cl.q2_configstrings[ Q2CS_IMAGES + i ][ 0 ]; i++ ) {
cl.q2_image_precache[ i ] = CLQ2_RegisterPicShader( cl.q2_configstrings[ Q2CS_IMAGES + i ] );
}
common->Printf( " \r" );
for ( int i = 0; i < MAX_CLIENTS_Q2; i++ ) {
if ( !cl.q2_configstrings[ Q2CS_PLAYERSKINS + i ][ 0 ] ) {
continue;
}
common->Printf( "client %i\r", i );
SCR_UpdateScreen();
CLQ2_ParseClientinfo( i );
common->Printf( " \r" );
}
CLQ2_LoadClientinfo( &cl.q2_baseclientinfo, "unnamed\\male/grunt" );
// set sky textures and speed
common->Printf( "sky\r" );
SCR_UpdateScreen();
float rotate = String::Atof( cl.q2_configstrings[ Q2CS_SKYROTATE ] );
vec3_t axis;
sscanf( cl.q2_configstrings[ Q2CS_SKYAXIS ], "%f %f %f",
&axis[ 0 ], &axis[ 1 ], &axis[ 2 ] );
R_SetSky( cl.q2_configstrings[ Q2CS_SKY ], rotate, axis );
common->Printf( " \r" );
R_EndRegistration();
// clear any lines of console text
Con_ClearNotify();
SCR_UpdateScreen();
cl.q2_refresh_prepped = true;
// start the cd track
CDAudio_Play( String::Atoi( cl.q2_configstrings[ Q2CS_CDTRACK ] ), 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 = 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;
}
}
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;
}
}
void
CL_ParseConfigString(void)
{
int i, length;
char *s;
char olds[MAX_QPATH];
i = MSG_ReadShort(&net_message);
if ((i < 0) || (i >= MAX_CONFIGSTRINGS))
{
Com_Error(ERR_DROP, "configstring > MAX_CONFIGSTRINGS");
}
s = MSG_ReadString(&net_message);
Q_strlcpy(olds, cl.configstrings[i], sizeof(olds));
length = strlen(s);
if (length > sizeof(cl.configstrings) - sizeof(cl.configstrings[0])*i - 1)
{
Com_Error(ERR_DROP, "CL_ParseConfigString: oversize configstring");
}
strcpy(cl.configstrings[i], s);
/* do something apropriate */
if ((i >= CS_LIGHTS) && (i < CS_LIGHTS + MAX_LIGHTSTYLES))
{
CL_SetLightstyle(i - CS_LIGHTS);
}
else if (i == CS_CDTRACK)
{
if (cl.refresh_prepped)
{
#ifdef CDA
CDAudio_Play((int)strtol(cl.configstrings[CS_CDTRACK],
(char **)NULL, 10), true);
#endif
#ifdef OGG
/* OGG/Vorbis */
if ((int)strtol(cl.configstrings[CS_CDTRACK], (char **)NULL, 10) < 10)
{
char tmp[3] = "0";
OGG_ParseCmd(strcat(tmp, cl.configstrings[CS_CDTRACK]));
}
else
{
OGG_ParseCmd(cl.configstrings[CS_CDTRACK]);
}
#endif
}
}
else if ((i >= CS_MODELS) && (i < CS_MODELS + MAX_MODELS))
{
if (cl.refresh_prepped)
{
cl.model_draw[i - CS_MODELS] = R_RegisterModel(cl.configstrings[i]);
if (cl.configstrings[i][0] == '*')
{
cl.model_clip[i - CS_MODELS] = CM_InlineModel(cl.configstrings[i]);
}
else
{
cl.model_clip[i - CS_MODELS] = NULL;
}
}
}
else if ((i >= CS_SOUNDS) && (i < CS_SOUNDS + MAX_MODELS))
{
if (cl.refresh_prepped)
{
cl.sound_precache[i - CS_SOUNDS] =
S_RegisterSound(cl.configstrings[i]);
}
}
else if ((i >= CS_IMAGES) && (i < CS_IMAGES + MAX_MODELS))
{
if (cl.refresh_prepped)
{
cl.image_precache[i - CS_IMAGES] = Draw_FindPic(cl.configstrings[i]);
}
}
else if ((i >= CS_PLAYERSKINS) && (i < CS_PLAYERSKINS + MAX_CLIENTS))
{
if (cl.refresh_prepped && strcmp(olds, s))
{
CL_ParseClientinfo(i - CS_PLAYERSKINS);
}
}
}
void CLNQ_ParseServerMessage (void)
{
int cmd;
int i;
qbool message_with_datagram; // hack to fix glitches when receiving a packet
// without a datagram
nq_player_teleported = false; // OMG, it's a hack!
message_with_datagram = false;
cl_entframecount++;
if (cl_shownet.value == 1)
Com_Printf ("%i ", net_message.cursize);
else if (cl_shownet.value == 2)
Com_Printf ("------------------\n");
cl.onground = false; // unless the server says otherwise
//
// parse the message
//
//MSG_BeginReading ();
while (1)
{
if (msg_badread)
Host_Error ("CL_ParseServerMessage: Bad server message");
cmd = MSG_ReadByte ();
if (cmd == -1)
{
SHOWNET("END OF MESSAGE");
if (!message_with_datagram) {
cl_entframecount--;
}
else
{
VectorCopy (nq_mviewangles[0], nq_mviewangles[1]);
VectorCopy (nq_mviewangles_temp, nq_mviewangles[0]);
}
return; // end of message
}
// if the high bit of the command byte is set, it is a fast update
if (cmd & 128)
{
SHOWNET("fast update");
NQD_ParseUpdate (cmd&127);
continue;
}
if (cmd < num_svc_strings)
SHOWNET(svc_strings[cmd]);
// other commands
switch (cmd)
{
default:
Host_Error ("CL_ParseServerMessage: Illegible server message");
break;
case svc_nop:
break;
case nq_svc_time:
nq_mtime[1] = nq_mtime[0];
nq_mtime[0] = MSG_ReadFloat ();
cl.servertime = nq_mtime[0];
message_with_datagram = true;
break;
case nq_svc_clientdata:
i = MSG_ReadShort ();
NQD_ParseClientdata (i);
break;
case nq_svc_version:
i = MSG_ReadLong ();
if (i != NQ_PROTOCOL_VERSION)
Host_Error ("CL_ParseServerMessage: Server is protocol %i instead of %i\n", i, NQ_PROTOCOL_VERSION);
break;
case svc_disconnect:
Com_Printf ("\n======== End of demo ========\n\n");
CL_NextDemo ();
Host_EndGame ();
Host_Abort ();
break;
case svc_print:
NQD_ParsePrint ();
break;
case svc_centerprint:
SCR_CenterPrint (MSG_ReadString ());
break;
case svc_stufftext:
NQD_ParseStufftext ();
break;
case svc_damage:
V_ParseDamage ();
break;
case svc_serverdata:
NQD_ParseServerData ();
break;
case svc_setangle:
for (i=0 ; i<3 ; i++)
nq_last_fixangle[i] = cl.simangles[i] = cl.viewangles[i] = MSG_ReadAngle ();
break;
case svc_setview:
nq_viewentity = MSG_ReadShort ();
if (nq_viewentity <= nq_maxclients)
cl.playernum = nq_viewentity - 1;
else {
// just let cl.playernum stay where it was
}
break;
case svc_lightstyle:
i = MSG_ReadByte ();
if (i >= MAX_LIGHTSTYLES)
Sys_Error ("svc_lightstyle > MAX_LIGHTSTYLES");
strlcpy (cl_lightstyle[i].map, MSG_ReadString(), sizeof(cl_lightstyle[0].map));
cl_lightstyle[i].length = strlen(cl_lightstyle[i].map);
break;
case svc_sound:
NQD_ParseStartSoundPacket();
break;
case svc_stopsound:
i = MSG_ReadShort();
S_StopSound(i>>3, i&7);
break;
case nq_svc_updatename:
Sbar_Changed ();
i = MSG_ReadByte ();
if (i >= nq_maxclients)
Host_Error ("CL_ParseServerMessage: svc_updatename > NQ_MAX_CLIENTS");
strlcpy (cl.players[i].name, MSG_ReadString(), sizeof(cl.players[i].name));
break;
case svc_updatefrags:
Sbar_Changed ();
i = MSG_ReadByte ();
if (i >= nq_maxclients)
Host_Error ("CL_ParseServerMessage: svc_updatefrags > NQ_MAX_CLIENTS");
cl.players[i].frags = MSG_ReadShort();
break;
case nq_svc_updatecolors:
NQD_ParseUpdatecolors ();
break;
case nq_svc_particle:
CL_ParseParticleEffect ();
break;
case svc_spawnbaseline:
i = MSG_ReadShort ();
if (i >= NQ_MAX_EDICTS)
Host_Error ("svc_spawnbaseline: ent > MAX_EDICTS");
NQD_BumpEntityCount (i);
CL_ParseBaseline (&cl_entities[i].baseline);
break;
case svc_spawnstatic:
CL_ParseStatic ();
break;
case svc_temp_entity:
CL_ParseTEnt ();
break;
case svc_setpause:
if (MSG_ReadByte() != 0)
cl.paused |= PAUSED_SERVER;
else
cl.paused &= ~PAUSED_SERVER;
if (cl.paused)
CDAudio_Pause ();
else
CDAudio_Resume ();
break;
case nq_svc_signonnum:
i = MSG_ReadByte ();
if (i <= nq_signon)
Host_Error ("Received signon %i when at %i", i, nq_signon);
nq_signon = i;
CLNQ_SignonReply ();
break;
case svc_killedmonster:
cl.stats[STAT_MONSTERS]++;
break;
case svc_foundsecret:
cl.stats[STAT_SECRETS]++;
break;
case svc_updatestat:
i = MSG_ReadByte ();
if (i < 0 || i >= MAX_CL_STATS)
Sys_Error ("svc_updatestat: %i is invalid", i);
cl.stats[i] = MSG_ReadLong ();;
break;
case svc_spawnstaticsound:
CL_ParseStaticSound ();
break;
case svc_cdtrack:
cl.cdtrack = MSG_ReadByte ();
MSG_ReadByte(); // loop track (unused)
if (nq_forcecdtrack != -1)
CDAudio_Play ((byte)nq_forcecdtrack, true);
else
CDAudio_Play ((byte)cl.cdtrack, true);
break;
case svc_intermission:
cl.intermission = 1;
cl.completed_time = cl.time;
VectorCopy (nq_last_fixangle, cl.simangles);
break;
case svc_finale:
cl.intermission = 2;
cl.completed_time = cl.time;
SCR_CenterPrint (MSG_ReadString ());
VectorCopy (nq_last_fixangle, cl.simangles);
break;
case nq_svc_cutscene:
cl.intermission = 3;
cl.completed_time = cl.time;
SCR_CenterPrint (MSG_ReadString ());
VectorCopy (nq_last_fixangle, cl.simangles);
break;
case svc_sellscreen:
break;
}
}
}
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 unsigned int __stdcall PlayingThreadProc(void *arglist)
{
struct ThreadArgList_t *tal = arglist;
DSBPOSITIONNOTIFY notifies[BUFFER_PARTS];
HANDLE events[BUFFER_PARTS+1]; // +1 for StopEvent
HANDLE endevents[2];
char *ptr;
int i;
DWORD dummy, fillpart;
DWORD part_size;
HRESULT hr;
qboolean more_data;
qboolean trackPlayedToEnd = false;
CDAudio_WaitForFinish();
ResetEvent(cdPlayingFinishedEvent);
ResetEvent(cdStopEvent);
part_size = gCDBufSize / BUFFER_PARTS;
for (i=0; i<BUFFER_PARTS; i++)
{
events[i] = CreateEvent(NULL, FALSE, FALSE, NULL);
notifies[i].dwOffset = i * part_size;
notifies[i].hEventNotify = events[i];
}
events[i] = cdStopEvent;
pDSBufCD->lpVtbl->GetStatus(pDSBufCD, &dummy);
if (dummy & DSBSTATUS_BUFFERLOST)
pDSBufCD->lpVtbl->Restore(pDSBufCD);
pDSBufCDNotify->lpVtbl->SetNotificationPositions(pDSBufCDNotify, BUFFER_PARTS, notifies);
if (FAILED(pDSBufCD->lpVtbl->Lock(pDSBufCD, 0, 0, &ptr, &dummy, NULL, NULL, DSBLOCK_ENTIREBUFFER)))
{
Con_DPrintf("CDAudio: cannot lock sound buffer.\n");
return -1;
}
if (!PaintSoundOGG(tal, ptr, (BUFFER_PARTS-1)*part_size))
SetEvent(cdStopEvent);
pDSBufCD->lpVtbl->Unlock(pDSBufCD, ptr, dummy, NULL, 0);
pDSBufCD->lpVtbl->SetCurrentPosition(pDSBufCD, 0);
pDSBufCD->lpVtbl->Play(pDSBufCD, 0, 0, DSBPLAY_LOOPING);
while(true)
{
fillpart = WaitForMultipleObjects(BUFFER_PARTS+1, events, FALSE, 2000);
if (fillpart >= WAIT_OBJECT_0 && fillpart < WAIT_OBJECT_0 + BUFFER_PARTS)
{
fillpart = (fillpart - WAIT_OBJECT_0 + BUFFER_PARTS - 1) % BUFFER_PARTS;
hr = pDSBufCD->lpVtbl->Lock(pDSBufCD, part_size * fillpart, part_size, &ptr, &dummy, NULL, NULL, 0);
if (hr == DSERR_BUFFERLOST)
{
pDSBufCD->lpVtbl->Restore(pDSBufCD);
pDSBufCD->lpVtbl->Lock(pDSBufCD, part_size * fillpart, part_size, &ptr, &dummy, NULL, NULL, 0);
}
more_data = PaintSoundOGG(tal, ptr, part_size);
pDSBufCD->lpVtbl->Unlock(pDSBufCD, ptr, dummy, NULL, 0);
if (!more_data)
{
endevents[0] = events[fillpart];
endevents[1] = cdStopEvent;
if (WaitForMultipleObjects(2, endevents, FALSE, 2000) == WAIT_OBJECT_0)
trackPlayedToEnd = true;
break;
}
}
else
break;
}
pDSBufCD->lpVtbl->Stop(pDSBufCD);
pDSBufCDNotify->lpVtbl->SetNotificationPositions(pDSBufCDNotify, 0, NULL);
for (i=0; i<BUFFER_PARTS; i++)
CloseHandle(events[i]);
CloseOGG(tal);
playing = false;
free(arglist);
SetEvent(cdPlayingFinishedEvent);
if (trackPlayedToEnd && playLooping)
CDAudio_Play(playTrack, true);
return 0;
}
/*
=====================
CL_ParseServerMessage
=====================
*/
void
CL_ParseServerMessage(void)
{
unsigned int bits;
int i, cmd, prevcmd;
int playernum, version, stylenum, signon, statnum;
int stopsound, entitynum, channel;
byte colors;
player_info_t *player;
lightstyle_t *style;
const char *stylemap, *name;
//
// if recording demos, copy the message out
//
if (cl_shownet.value == 1)
Con_Printf("%i ", net_message.cursize);
else if (cl_shownet.value == 2)
Con_Printf("------------------\n");
cl.onground = false; // unless the server says otherwise
//
// parse the message
//
prevcmd = svc_bad;
MSG_BeginReading();
while (1) {
if (msg_badread)
Host_Error("%s: Bad server message", __func__);
cmd = MSG_ReadByte();
if (cmd == -1) {
SHOWNET("END OF MESSAGE");
return; // end of message
}
// if the high bit of the command byte is set, it is a fast update
if (cmd & 128) {
SHOWNET("fast update");
CL_ParseUpdate(cmd & 127);
continue;
}
SHOWNET(svc_strings[cmd]);
// other commands
switch (cmd) {
case svc_nop:
break;
case svc_time:
cl.mtime[1] = cl.mtime[0];
cl.mtime[0] = MSG_ReadFloat();
break;
case svc_clientdata:
CL_ParseClientdata();
break;
case svc_version:
version = MSG_ReadLong();
if (!Protocol_Known(version))
Host_Error("%s: Server returned unknown protocol version %i",
__func__, version);
cl.protocol = version;
break;
case svc_disconnect:
Host_EndGame("Server disconnected\n");
case svc_print:
Con_Printf("%s", MSG_ReadString());
break;
case svc_centerprint:
SCR_CenterPrint(MSG_ReadString());
break;
case svc_stufftext:
Cbuf_AddText("%s", MSG_ReadString());
break;
case svc_damage:
V_ParseDamage();
break;
case svc_serverinfo:
CL_ParseServerInfo();
vid.recalc_refdef = true; // leave intermission full screen
break;
case svc_setangle:
for (i = 0; i < 3; i++)
cl.viewangles[i] = MSG_ReadAngle();
break;
case svc_setview:
cl.viewentity = MSG_ReadShort();
break;
case svc_lightstyle:
stylenum = MSG_ReadByte();
if (stylenum >= MAX_LIGHTSTYLES)
Sys_Error("svc_lightstyle > MAX_LIGHTSTYLES");
stylemap = MSG_ReadString();
style = cl_lightstyle + stylenum;
snprintf(style->map, MAX_STYLESTRING, "%s", stylemap);
style->length = strlen(style->map);
break;
case svc_sound:
CL_ParseStartSoundPacket();
break;
case svc_stopsound:
stopsound = MSG_ReadShort(); /* 3-bit channel encoded in lsb */
entitynum = stopsound >> 3;
channel = stopsound & 7;
S_StopSound(entitynum, channel);
break;
case svc_updatename:
Sbar_Changed();
playernum = MSG_ReadByte();
if (playernum >= cl.maxclients)
Host_Error("%s: svc_updatename > MAX_SCOREBOARD", __func__);
name = MSG_ReadString();
player = cl.players + playernum;
snprintf(player->name, MAX_SCOREBOARDNAME, "%s", name);
break;
case svc_updatefrags:
Sbar_Changed();
playernum = MSG_ReadByte();
if (playernum >= cl.maxclients)
Host_Error("%s: svc_updatefrags > MAX_SCOREBOARD", __func__);
player = cl.players + playernum;
player->frags = MSG_ReadShort();
break;
case svc_updatecolors:
Sbar_Changed();
playernum = MSG_ReadByte();
if (playernum >= cl.maxclients)
Host_Error("%s: svc_updatecolors > MAX_SCOREBOARD", __func__);
colors = MSG_ReadByte();
player = cl.players + playernum;
player->topcolor = (colors & 0xf0) >> 4;
player->bottomcolor = colors & 0x0f;
/* FIXME - is this the right check for current player? */
if (playernum == cl.viewentity)
cl_color.value = colors;
CL_NewTranslation(playernum);
break;
case svc_particle:
R_ParseParticleEffect();
break;
case svc_spawnbaseline:
entitynum = MSG_ReadShort();
// must use CL_EntityNum() to force cl.num_entities up
CL_ParseBaseline(CL_EntityNum(entitynum), 0);
break;
case svc_fitz_spawnbaseline2:
/* FIXME - check here that protocol is FITZ? => Host_Error() */
entitynum = MSG_ReadShort();
bits = MSG_ReadByte();
// must use CL_EntityNum() to force cl.num_entities up
CL_ParseBaseline(CL_EntityNum(entitynum), bits);
break;
case svc_spawnstatic:
CL_ParseStatic(0);
break;
case svc_fitz_spawnstatic2:
/* FIXME - check here that protocol is FITZ? => Host_Error() */
bits = MSG_ReadByte();
CL_ParseStatic(bits);
break;
case svc_temp_entity:
CL_ParseTEnt();
break;
case svc_setpause:
cl.paused = MSG_ReadByte();
if (cl.paused)
CDAudio_Pause();
else
CDAudio_Resume();
break;
case svc_signonnum:
signon = MSG_ReadByte();
if (signon <= cls.signon)
Host_Error("Received signon %d when at %d", signon, cls.signon);
cls.signon = signon;
CL_SignonReply();
break;
case svc_killedmonster:
cl.stats[STAT_MONSTERS]++;
break;
case svc_foundsecret:
cl.stats[STAT_SECRETS]++;
break;
case svc_updatestat:
statnum = MSG_ReadByte();
if (statnum < 0 || statnum >= MAX_CL_STATS)
Sys_Error("svc_updatestat: %d is invalid", statnum);
cl.stats[statnum] = MSG_ReadLong();
break;
case svc_spawnstaticsound:
CL_ParseStaticSound();
break;
case svc_fitz_spawnstaticsound2:
/* FIXME - check here that protocol is FITZ? => Host_Error() */
CL_ParseFitzStaticSound2();
break;
case svc_cdtrack:
cl.cdtrack = MSG_ReadByte();
cl.looptrack = MSG_ReadByte();
if ((cls.demoplayback || cls.demorecording)
&& (cls.forcetrack != -1))
CDAudio_Play((byte)cls.forcetrack, true);
else
CDAudio_Play((byte)cl.cdtrack, true);
break;
case svc_intermission:
cl.intermission = 1;
cl.completed_time = cl.time;
vid.recalc_refdef = true; // go to full screen
break;
case svc_finale:
cl.intermission = 2;
cl.completed_time = cl.time;
vid.recalc_refdef = true; // go to full screen
SCR_CenterPrint(MSG_ReadString());
break;
case svc_cutscene:
cl.intermission = 3;
cl.completed_time = cl.time;
vid.recalc_refdef = true; // go to full screen
SCR_CenterPrint(MSG_ReadString());
break;
case svc_sellscreen:
Cmd_ExecuteString("help", src_command);
break;
/* Various FITZ protocol messages - FIXME - !protocol => Host_Error */
case svc_fitz_skybox:
MSG_ReadString(); // FIXME - TODO
break;
case svc_fitz_bf:
Cmd_ExecuteString("bf", src_command);
break;
case svc_fitz_fog:
/* FIXME - TODO */
MSG_ReadByte(); // density
MSG_ReadByte(); // red
MSG_ReadByte(); // green
MSG_ReadByte(); // blue
MSG_ReadShort(); // time
break;
default:
Host_Error("%s: Illegible server message. Previous was %s",
__func__, svc_strings[prevcmd]);
}
prevcmd = cmd;
}
}
void CL_ParseServerMessage (void)
{
int cmd;
int i;
//
// if recording demos, copy the message out
//
if (cl_shownet.value == 1)
Con_Printf ("%i ",net_message.cursize);
else if (cl_shownet.value == 2)
Con_Printf ("------------------\n");
cl.onground = false; // unless the server says otherwise
//
// parse the message
//
MSG_BeginReading ();
while (1)
{
if (msg_badread)
Host_Error ("CL_ParseServerMessage: Bad server message");
cmd = MSG_ReadByte ();
if (cmd == -1)
{
SHOWNET("END OF MESSAGE");
return; // end of message
}
// if the high bit of the command byte is set, it is a fast update
if (cmd & 128)
{
SHOWNET("fast update");
CL_ParseUpdate (cmd&127);
continue;
}
SHOWNET(svc_strings[cmd]);
// other commands
switch (cmd)
{
default:
Host_Error ("CL_ParseServerMessage: Illegible server message\n");
break;
case svc_nop:
// Con_Printf ("svc_nop\n");
break;
case svc_time:
cl.mtime[1] = cl.mtime[0];
cl.mtime[0] = MSG_ReadFloat ();
break;
case svc_clientdata:
i = MSG_ReadShort ();
CL_ParseClientdata (i);
break;
case svc_version:
i = MSG_ReadLong ();
if (i != PROTOCOL_VERSION)
Host_Error ("CL_ParseServerMessage: Server is protocol %i instead of %i\n", i, PROTOCOL_VERSION);
break;
case svc_disconnect:
Host_EndGame ("Server disconnected\n");
case svc_print:
Con_Printf ("%s", MSG_ReadString ());
break;
case svc_centerprint:
SCR_CenterPrint (MSG_ReadString ());
break;
case svc_stufftext:
Cbuf_AddText (MSG_ReadString ());
break;
case svc_damage:
V_ParseDamage ();
break;
case svc_serverinfo:
CL_ParseServerInfo ();
vid.recalc_refdef = true; // leave intermission full screen
break;
case svc_setangle:
for (i=0 ; i<3 ; i++)
cl.viewangles[i] = MSG_ReadAngle ();
break;
case svc_setview:
cl.viewentity = MSG_ReadShort ();
break;
case svc_lightstyle:
i = MSG_ReadByte ();
if (i >= MAX_LIGHTSTYLES)
Sys_Error ("svc_lightstyle > MAX_LIGHTSTYLES");
Q_strcpy (cl_lightstyle[i].map, MSG_ReadString());
cl_lightstyle[i].length = Q_strlen(cl_lightstyle[i].map);
break;
case svc_sound:
CL_ParseStartSoundPacket();
break;
case svc_stopsound:
i = MSG_ReadShort();
S_StopSound(i>>3, i&7);
break;
case svc_updatename:
Sbar_Changed ();
i = MSG_ReadByte ();
if (i >= cl.maxclients)
Host_Error ("CL_ParseServerMessage: svc_updatename > MAX_SCOREBOARD");
strcpy (cl.scores[i].name, MSG_ReadString ());
break;
case svc_updatefrags:
Sbar_Changed ();
i = MSG_ReadByte ();
if (i >= cl.maxclients)
Host_Error ("CL_ParseServerMessage: svc_updatefrags > MAX_SCOREBOARD");
cl.scores[i].frags = MSG_ReadShort ();
break;
case svc_updatecolors:
Sbar_Changed ();
i = MSG_ReadByte ();
if (i >= cl.maxclients)
Host_Error ("CL_ParseServerMessage: svc_updatecolors > MAX_SCOREBOARD");
cl.scores[i].colors = MSG_ReadByte ();
CL_NewTranslation (i);
break;
case svc_particle:
R_ParseParticleEffect ();
break;
case svc_spawnbaseline:
i = MSG_ReadShort ();
// must use CL_EntityNum() to force cl.num_entities up
CL_ParseBaseline (CL_EntityNum(i));
break;
case svc_spawnstatic:
CL_ParseStatic ();
break;
case svc_temp_entity:
CL_ParseTEnt ();
break;
case svc_setpause:
{
cl.paused = MSG_ReadByte ();
if (cl.paused)
{
CDAudio_Pause ();
#ifdef _WIN32
VID_HandlePause (true);
#endif
}
else
{
CDAudio_Resume ();
#ifdef _WIN32
VID_HandlePause (false);
#endif
}
}
break;
case svc_signonnum:
i = MSG_ReadByte ();
if (i <= cls.signon)
Host_Error ("Received signon %i when at %i", i, cls.signon);
cls.signon = i;
CL_SignonReply ();
break;
case svc_killedmonster:
cl.stats[STAT_MONSTERS]++;
break;
case svc_foundsecret:
cl.stats[STAT_SECRETS]++;
break;
case svc_updatestat:
i = MSG_ReadByte ();
if (i < 0 || i >= MAX_CL_STATS)
Sys_Error ("svc_updatestat: %i is invalid", i);
cl.stats[i] = MSG_ReadLong ();;
break;
case svc_spawnstaticsound:
CL_ParseStaticSound ();
break;
case svc_cdtrack:
cl.cdtrack = MSG_ReadByte ();
cl.looptrack = MSG_ReadByte ();
if ( (cls.demoplayback || cls.demorecording) && (cls.forcetrack != -1) )
CDAudio_Play ((byte)cls.forcetrack, true);
else
CDAudio_Play ((byte)cl.cdtrack, true);
break;
case svc_intermission:
cl.intermission = 1;
cl.completed_time = (int) cl.time;
vid.recalc_refdef = true; // go to full screen
break;
case svc_finale:
cl.intermission = 2;
cl.completed_time = (int) cl.time;
vid.recalc_refdef = true; // go to full screen
SCR_CenterPrint (MSG_ReadString ());
break;
case svc_cutscene:
cl.intermission = 3;
cl.completed_time = (int) cl.time;
vid.recalc_refdef = true; // go to full screen
SCR_CenterPrint (MSG_ReadString ());
break;
case svc_sellscreen:
Cmd_ExecuteString2 ("help", src_command);
break;
}
}
}
void CDAudio_Update(void)
{
#if defined(__FreeBSD__)
struct ioc_read_subchannel subchnl;
struct cd_sub_channel_info data;
#else
struct cdrom_subchnl subchnl;
#endif
static time_t lastchk;
if (cdfile == -1 || !enabled)
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 ();
}
}
if (playing && lastchk < time(NULL)) {
lastchk = time(NULL) + 2; //two seconds between chks
#if defined(__FreeBSD__)
subchnl.address_format = CD_MSF_FORMAT;
subchnl.data_format = CD_CURRENT_POSITION;
subchnl.data_len = sizeof(data);
subchnl.track = playTrack;
subchnl.data = &data;
if (ioctl(cdfile, CDIOCREADSUBCHANNEL, &subchnl) == -1 ) {
Com_DPrintf("ioctl cdiocreadsubchannel failed\n");
playing = false;
return;
}
if (subchnl.data->header.audio_status != CD_AS_PLAY_IN_PROGRESS &&
subchnl.data->header.audio_status != CD_AS_PLAY_PAUSED) {
playing = false;
if (playLooping)
CDAudio_Play(playTrack, true);
}
#else
subchnl.cdsc_format = CDROM_MSF;
if (ioctl(cdfile, CDROMSUBCHNL, &subchnl) == -1 ) {
Com_DPrintf("ioctl cdromsubchnl failed\n");
playing = false;
return;
}
if (subchnl.cdsc_audiostatus != CDROM_AUDIO_PLAY &&
subchnl.cdsc_audiostatus != CDROM_AUDIO_PAUSED) {
playing = false;
if (playLooping)
CDAudio_Play(playTrack, true);
}
#endif
}
}
/*
================
CL_ParseConfigString
================
*/
void CL_ParseConfigString (void)
{
size_t length;
int i;
char *s;
char olds[MAX_QPATH];
i = MSG_ReadShort (&net_message);
if (i < 0 || i >= MAX_CONFIGSTRINGS)
Com_Error (ERR_DROP, "CL_ParseConfigString: configstring %d >= MAX_CONFIGSTRINGS", i);
s = MSG_ReadString(&net_message);
Q_strncpy (olds, cl.configstrings[i], sizeof(olds)-1);
//Com_Printf ("cs: %i=%s\n", LOG_GENERAL, i, MakePrintable (s));
//r1ch: only allow statusbar to overflow
/*if (i >= CS_STATUSBAR && i < CS_AIRACCEL)
strncpy (cl.configstrings[i], s, (sizeof(cl.configstrings[i]) * (CS_AIRACCEL - i))-1);
else
Q_strncpy (cl.configstrings[i], s, sizeof(cl.configstrings[i])-1);*/
//r1: overflow may be desired by some mods in stats programs for example. who knows.
length = strlen(s);
if (length >= (sizeof(cl.configstrings[0]) * (MAX_CONFIGSTRINGS-i)) - 1)
Com_Error (ERR_DROP, "CL_ParseConfigString: configstring %d exceeds available space", i);
//r1: don't allow basic things to overflow
if (i != CS_NAME && i < CS_GENERAL)
{
if (i >= CS_STATUSBAR && i < CS_AIRACCEL)
{
strncpy (cl.configstrings[i], s, (sizeof(cl.configstrings[i]) * (CS_AIRACCEL - i))-1);
}
else
{
if (length >= MAX_QPATH)
Com_Printf ("WARNING: Configstring %d of length %d exceeds MAX_QPATH.\n", LOG_CLIENT|LOG_WARNING, i, (int)length);
Q_strncpy (cl.configstrings[i], s, sizeof(cl.configstrings[i])-1);
}
}
else
{
strcpy (cl.configstrings[i], s);
}
// do something apropriate
if (i == CS_AIRACCEL)
{
pm_airaccelerate = (qboolean)atoi(cl.configstrings[CS_AIRACCEL]);
}
else if (i >= CS_LIGHTS && i < CS_LIGHTS+MAX_LIGHTSTYLES)
{
CL_SetLightstyle (i - CS_LIGHTS);
}
#ifdef CD_AUDIO
else if (i == CS_CDTRACK)
{
if (cl.refresh_prepped)
CDAudio_Play (atoi(cl.configstrings[CS_CDTRACK]), true);
}
#endif
else if (i >= CS_MODELS && i < CS_MODELS+MAX_MODELS)
{
if (cl.refresh_prepped)
{
cl.model_draw[i-CS_MODELS] = re.RegisterModel (cl.configstrings[i]);
if (cl.configstrings[i][0] == '*')
cl.model_clip[i-CS_MODELS] = CM_InlineModel (cl.configstrings[i]);
else
cl.model_clip[i-CS_MODELS] = NULL;
}
//r1: load map whilst connecting to save a bit of time
/*if (i == CS_MODELS + 1)
{
CM_LoadMap (cl.configstrings[CS_MODELS+1], true, &i);
if (i && i != atoi(cl.configstrings[CS_MAPCHECKSUM]))
Com_Error (ERR_DROP, "Local map version differs from server: 0x%.8x != 0x%.8x\n",
i, atoi(cl.configstrings[CS_MAPCHECKSUM]));
}*/
}
else if (i >= CS_SOUNDS && i < CS_SOUNDS+MAX_MODELS)
{
if (cl.refresh_prepped)
cl.sound_precache[i-CS_SOUNDS] = S_RegisterSound (cl.configstrings[i]);
}
else if (i >= CS_IMAGES && i < CS_IMAGES+MAX_MODELS)
{
if (cl.refresh_prepped)
re.RegisterPic (cl.configstrings[i]);
}
else if (i == CS_MAXCLIENTS)
{
if (!cl.attractloop)
cl.maxclients = atoi(cl.configstrings[CS_MAXCLIENTS]);
}
else if (i >= CS_PLAYERSKINS && i < CS_PLAYERSKINS+MAX_CLIENTS)
{
//r1: hack to avoid parsing non-skins from mods that overload CS_PLAYERSKINS
//FIXME: how reliable is CS_MAXCLIENTS?
i -= CS_PLAYERSKINS;
if (i < cl.maxclients)
{
if (cl.refresh_prepped && strcmp(olds, s))
CL_ParseClientinfo (i);
}
else
{
Com_DPrintf ("CL_ParseConfigString: Ignoring out-of-range playerskin %d (%s)\n", i, MakePrintable(s, 0));
}
}
}
static void CD_f()
{
char *command;
int cdstate;
if(Cmd_Argc() < 2) return;
command = Cmd_Argv(1);
if(!Q_strcasecmp(command,"on"))
{
enabled = true;
}
if(!Q_strcasecmp(command,"off"))
{
if(!cd_id) return;
cdstate = SDL_CDStatus(cd_id);
if((cdstate == CD_PLAYING) || (cdstate == CD_PAUSED))
CDAudio_Stop();
enabled = false;
return;
}
if(!Q_strcasecmp(command,"play"))
{
CDAudio_Play((byte)atoi(Cmd_Argv(2)),false);
return;
}
if(!Q_strcasecmp(command,"loop"))
{
CDAudio_Play((byte)atoi(Cmd_Argv(2)),true);
return;
}
if(!Q_strcasecmp(command,"stop"))
{
CDAudio_Stop();
return;
}
if(!Q_strcasecmp(command,"pause"))
{
CDAudio_Pause();
return;
}
if(!Q_strcasecmp(command,"resume"))
{
CDAudio_Resume();
return;
}
if(!Q_strcasecmp(command,"eject"))
{
CDAudio_Eject();
return;
}
if(!Q_strcasecmp(command,"info"))
{
if(!cd_id) return;
cdstate = SDL_CDStatus(cd_id);
Com_Printf("%d tracks\n",cd_id->numtracks);
if(cdstate == CD_PLAYING)
Com_Printf("Currently %s track %d\n",
playLooping ? "looping" : "playing",
cd_id->cur_track+1);
else
if(cdstate == CD_PAUSED)
Com_Printf("Paused %s track %d\n",
playLooping ? "looping" : "playing",
cd_id->cur_track+1);
return;
}
}
