void QTVList_Cache_File_Download(void) { CURL *curl; CURLcode res; FILE *f; curl = curl_easy_init(); if (curl) { curl_easy_setopt(curl, CURLOPT_URL, sb_qtvlist_url.string); } else { Com_Printf_State(PRINT_FAIL, "QTVList_List_f() Can't init cURL\n"); return; } if (!FS_FCreateFile(QTVLIST_CACHE_FILE, &f, QTVLIST_CACHE_FILE_DIR, "wb+")) { Com_Printf_State(PRINT_FAIL, "Can't create QTVList cache file\n"); return; } curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, NULL); curl_easy_setopt(curl, CURLOPT_WRITEDATA, f); res = curl_easy_perform(curl); curl_easy_cleanup(curl); fclose(f); if (res != CURLE_OK) { Com_Printf_State(PRINT_FAIL, "Couldn't download QTV list"); return; } }
void NET_GetLocalAddress (int socket, netadr_t *out) { char buff[512]; struct sockaddr_storage address; size_t namelen; netadr_t adr = {0}; qbool notvalid = false; strlcpy (buff, "localhost", sizeof (buff)); gethostname (buff, sizeof (buff)); buff[sizeof(buff) - 1] = 0; if (!NET_StringToAdr (buff, &adr)) //urm NET_StringToAdr ("127.0.0.1", &adr); namelen = sizeof(address); if (getsockname (socket, (struct sockaddr *)&address, (socklen_t *)&namelen) == -1) { notvalid = true; NET_StringToSockaddr("0.0.0.0", (struct sockaddr_storage *)&address); // Sys_Error ("NET_Init: getsockname:", strerror(qerrno)); } SockadrToNetadr(&address, out); if (!*(int*)out->ip) //socket was set to auto *(int *)out->ip = *(int *)adr.ip; //change it to what the machine says it is, rather than the socket. #ifndef SERVERONLY if (notvalid) Com_Printf_State (PRINT_FAIL, "Couldn't detect local ip\n"); else Com_Printf_State (PRINT_OK, "IP address %s\n", NET_AdrToString (*out)); #endif }
static void SetBufferSize(void) { static DIPROPDWORD dipdw = { { sizeof(dipdw), sizeof(dipdw.diph), 0, DIPH_DEVICE }, 0 }; HRESULT hr; unsigned int bufsize; if (in_di_bufsize.integer) { // we don't wont dynamic buffer change Com_Printf_State(PRINT_OK, "DirectInput overflow, increasing skipped because of %s.\n", in_di_bufsize.name); return; } bufsize = max(dipdw.dwData, DI_BufSize()); // well, DI_BufSize() return 16, since in_di_bufsize is zero dipdw.dwData = bufsize + max(1, bufsize / 2); Com_Printf_State(PRINT_INFO, "DirectInput overflow, increasing buffer size to %u.\n", dipdw.dwData); IN_DeactivateMouse(); hr = IDirectInputDevice_SetProperty(g_pMouse, DIPROP_BUFFERSIZE, &dipdw.diph); IN_ActivateMouse(); if(FAILED(hr)) { Com_Printf_State (PRINT_FAIL, "Unable to increase DirectInput buffer size.\n"); } }
//Try to find a sound device to mix for. //Returns false if nothing is found. qbool SNDDMA_Init(void) { sndinitstat stat; Cvar_SetCurrentGroup(CVAR_GROUP_SOUND); Cvar_Register (&sys_inactivesound); Cvar_ResetCurrentGroup (); if (COM_CheckParm ("-wavonly")) wavonly = true; dsound_init = wav_init = 0; stat = SIS_FAILURE; // assume DirectSound won't initialize /* Init DirectSound */ if (!wavonly) { if (snd_firsttime || snd_isdirect) { stat = SNDDMA_InitDirect (); if (stat == SIS_SUCCESS) { snd_isdirect = true; if (snd_firsttime) Com_Printf_State (PRINT_OK, "DirectSound initialized\n"); } else { snd_isdirect = false; Com_Printf_State (PRINT_FAIL, "DirectSound failed to init\n"); } } } // if DirectSound didn't succeed in initializing, try to initialize waveOut sound if (!dsound_init) { if (snd_firsttime || snd_iswave) { snd_iswave = SNDDMA_InitWav (); if (snd_iswave) { if (snd_firsttime) Com_Printf_State (PRINT_OK, "Wave sound initialized\n"); } else { Com_Printf_State (PRINT_FAIL, "Wave sound failed to init\n"); } } } snd_firsttime = false; if (!dsound_init && !wav_init) { if (snd_firsttime) Com_Printf_State (PRINT_INFO, "No sound device initialized\n"); return false; } return true; }
static void GfxInfo_f(void) { SDL_DisplayMode current; Com_Printf_State(PRINT_ALL, "\nGL_VENDOR: %s\n", glConfig.vendor_string ); Com_Printf_State(PRINT_ALL, "GL_RENDERER: %s\n", glConfig.renderer_string ); Com_Printf_State(PRINT_ALL, "GL_VERSION: %s\n", glConfig.version_string ); if (r_showextensions.value) { Com_Printf_State(PRINT_ALL, "GL_EXTENSIONS: %s\n", glConfig.extensions_string); } Com_Printf_State(PRINT_ALL, "PIXELFORMAT: color(%d-bits) Z(%d-bit)\n stencil(%d-bits)\n", glConfig.colorBits, glConfig.depthBits, glConfig.stencilBits); if (SDL_GetCurrentDisplayMode(VID_DisplayNumber(r_fullscreen.value), ¤t) != 0) { current.refresh_rate = 0; // print 0Hz if we run into problem fetching data } Com_Printf_State(PRINT_ALL, "MODE: %d x %d @ %d Hz ", current.w, current.h, current.refresh_rate); if (r_fullscreen.integer) { Com_Printf_State(PRINT_ALL, "[fullscreen]\n"); } else { Com_Printf_State(PRINT_ALL, "[windowed]\n"); } Com_Printf_State(PRINT_ALL, "CONRES: %d x %d\n", r_conwidth.integer, r_conheight.integer ); }
static void Rulesets_OnChange_ruleset (cvar_t *var, char *value, qbool *cancel) { extern void Cmd_ReInitAllMacro (void); if (cls.state != ca_disconnected) { Com_Printf ("%s can be changed only in disconneced mode\n", var->name); *cancel = true; return; } if (strncasecmp (value, "smackdown", 9) && strncasecmp (value, "mtfl", 4) && strncasecmp (value, "default", 7)) { Com_Printf_State (PRINT_INFO, "Unknown ruleset \"%s\"\n", value); *cancel = true; return; } // All checks passed so we can remove old ruleset and set a new one switch (rulesetDef.ruleset) { case rs_smackdown: Rulesets_Smackdown (false); break; case rs_mtfl: Rulesets_MTFL (false); break; case rs_default: break; default: break; } // we need to mark custom textures in the memory (like for backpack and eyes) to be reloaded again Cache_Flush (); if (!strncasecmp (value, "smackdown", 9)) { Rulesets_Smackdown (true); Com_Printf_State (PRINT_OK, "Ruleset Smackdown initialized\n"); } else if (!strncasecmp (value, "mtfl", 4)) { Rulesets_MTFL (true); Com_Printf_State (PRINT_OK, "Ruleset MTFL initialized\n"); } else if (!strncasecmp (value, "default", 7)) { Rulesets_Default (); Com_Printf_State (PRINT_OK, "Ruleset default initialized\n"); } else { Sys_Error ("OnChange_ruleset: WTF?\n"); // this will never happen *cancel = true; return; } Cmd_ReInitAllMacro (); }
static void SB_Update_Source_From_URL(const source_data *s, server_data *servers[], int *serversn) { CURL *curl; CURLcode res; size_t filename_buf_len; char *filename; FILE *f; if (s->type != type_url) { Com_Printf_State(PRINT_FAIL, "SB_Update_Source_From_URL() Invalid argument\n"); return; } curl = curl_easy_init(); if (curl) { curl_easy_setopt(curl, CURLOPT_URL, s->address.url); } else { Com_Printf_State(PRINT_FAIL, "SB_Update_Source_From_URL() Can't init cURL\n"); return; } filename_buf_len = SB_URL_To_Filename_Length(s->address.url); filename = Q_malloc(filename_buf_len); SB_URL_to_FileName(s->address.url, filename, filename_buf_len); if (!FS_FCreateFile(filename, &f, "ezquake/sb/cache", "wt+")) { Com_Printf_State(PRINT_FAIL, "SB_Update_Source_From_URL() Can't open cached file"); return; } curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, NULL); curl_easy_setopt(curl, CURLOPT_WRITEDATA, f); res = curl_easy_perform(curl); if (res != CURLE_OK) { Com_Printf("Error: Could not read URL %s\n", s->address.url); } fseek(f, 0, SEEK_SET); SB_Process_URL_Buffer(f, servers, serversn); fclose(f); Q_free(filename); /* always cleanup */ curl_easy_cleanup(curl); }
void *DSOUND_Capture_Init (int rate) { dsndcapture_t *result; DSCBUFFERDESC bufdesc = {0}; WAVEFORMATEX wfxFormat = {0}; Com_DPrintf("DSOUND_Capture_Init: rate %d\n", rate); wfxFormat.wFormatTag = WAVE_FORMAT_PCM; wfxFormat.nChannels = 1; wfxFormat.nSamplesPerSec = rate; wfxFormat.wBitsPerSample = 8*inputwidth; wfxFormat.nBlockAlign = wfxFormat.nChannels * (wfxFormat.wBitsPerSample / 8); wfxFormat.nAvgBytesPerSec = wfxFormat.nSamplesPerSec * wfxFormat.nBlockAlign; wfxFormat.cbSize = 0; bufdesc.dwSize = sizeof(bufdesc); bufdesc.dwBufferBytes = bufferbytes; bufdesc.dwFlags = 0; bufdesc.dwReserved = 0; bufdesc.lpwfxFormat = &wfxFormat; result = Z_Malloc(sizeof(*result)); if (FAILED(DirectSoundCaptureCreate(NULL, &result->DSCapture, NULL))) { Com_Printf_State (PRINT_FAIL, "DirectSound: Couldn't create a capture device\n"); } else if (FAILED(IDirectSoundCapture_CreateCaptureBuffer(result->DSCapture, &bufdesc, &result->DSCaptureBuffer, NULL))) { Com_Printf_State (PRINT_FAIL, "DirectSound: Couldn't create a capture buffer\n"); } else { Com_DPrintf("DSOUND_Capture_Init: OK\n"); return result; } // failure, lets clean up. if (result->DSCapture) { IDirectSoundCapture_Release(result->DSCapture); } Z_Free(result); return NULL; }
void NET_InitClient(void) { int port = PORT_CLIENT; int p; p = COM_CheckParm ("-clientport"); if (p && p < COM_Argc()) { port = atoi(COM_Argv(p+1)); } if (cls.socketip == INVALID_SOCKET) cls.socketip = UDP_OpenSocket (port); if (cls.socketip == INVALID_SOCKET) cls.socketip = UDP_OpenSocket (PORT_ANY); // any dynamic port if (cls.socketip == INVALID_SOCKET) Sys_Error ("Couldn't allocate client socket"); // init the message buffer SZ_Init (&net_message, net_message_buffer, sizeof(net_message_buffer)); // determine my name & address NET_GetLocalAddress (cls.socketip, &net_local_cl_ipadr); Com_Printf_State (PRINT_OK, "Client port Initialized\n"); }
void Capture_InitACM (void) { movie_acm_loaded = false; if (!(handle_acm = LoadLibrary("msacm32.dll"))) { Com_Printf ("\x02" "ACM module not found\n"); goto fail; } ACM_GETFUNC(DriverOpen); ACM_GETFUNC(DriverEnum); ACM_GETFUNC(StreamOpen); ACM_GETFUNC(StreamSize); ACM_GETFUNC(StreamPrepareHeader); ACM_GETFUNC(StreamUnprepareHeader); ACM_GETFUNC(StreamConvert); ACM_GETFUNC(StreamClose); ACM_GETFUNC(DriverClose); qacmDriverDetails = (void *)GetProcAddress (handle_acm, "acmDriverDetailsA"); qacmFormatTagDetails = (void *)GetProcAddress (handle_acm, "acmFormatTagDetailsA"); movie_acm_loaded = qacmDriverOpen && qacmDriverDetails && qacmDriverEnum && qacmFormatTagDetails && qacmStreamOpen && qacmStreamSize && qacmStreamPrepareHeader && qacmStreamUnprepareHeader && qacmStreamConvert && qacmStreamClose && qacmDriverClose; if (!movie_acm_loaded) { Com_Printf_State (PRINT_FAIL, "ACM module not initialized\n"); goto fail; } Com_Printf_State (PRINT_OK, "ACM module initialized\n"); return; fail: if (handle_acm) { FreeLibrary (handle_acm); handle_acm = NULL; } }
void Capture_InitAVI (void) { movie_avi_loaded = false; if (!(handle_avi = LoadLibrary("avifil32.dll"))) { Com_Printf ("\x02" "Avi capturing module not found\n"); goto fail; } AVI_GETFUNC(FileInit); AVI_GETFUNC(FileOpen); AVI_GETFUNC(FileCreateStream); AVI_GETFUNC(MakeCompressedStream); AVI_GETFUNC(StreamSetFormat); AVI_GETFUNC(StreamWrite); AVI_GETFUNC(StreamRelease); AVI_GETFUNC(FileRelease); AVI_GETFUNC(FileExit); movie_avi_loaded = qAVIFileInit && qAVIFileOpen && qAVIFileCreateStream && qAVIMakeCompressedStream && qAVIStreamSetFormat && qAVIStreamWrite && qAVIStreamRelease && qAVIFileRelease && qAVIFileExit; if (!movie_avi_loaded) { Com_Printf_State (PRINT_FAIL, "Avi capturing module not initialized\n"); goto fail; } Com_Printf_State (PRINT_OK, "Avi capturing module initialized\n"); return; fail: if (handle_avi) { FreeLibrary (handle_avi); handle_avi = NULL; } }
void Cam_FinishMove(usercmd_t *cmd) { int i, end, inc; player_info_t *s; if (cls.state != ca_active) return; if (!cl.spectator) // only in spectator mode return; if (cmd->buttons & BUTTON_ATTACK) { if (!(oldbuttons & BUTTON_ATTACK)) { oldbuttons |= BUTTON_ATTACK; autocam++; if (autocam > CAM_TRACK) { Cam_Unlock(); VectorCopy(cl.viewangles, cmd->angles); return; } } else return; } else { oldbuttons &= ~BUTTON_ATTACK; if (!autocam) return; } // cl_hightrack if (autocam && cl_hightrack.value) { Cam_CheckHighTarget(); if (Cam_JumpCheck(cmd)) { Com_Printf_State(PRINT_FAIL,"cl_hightrack enabled. Unable to switch POV.\n"); } return; } if (Cam_MoveDownCheck(cmd)) { inc = -1; } else { inc = 1; } if (locked) { if (!Cam_JumpCheck(cmd) && inc == 1) { return; } // Swap the Multiview mvinset/main view pov when jump button is pressed. nSwapPov = inc; } if (locked && autocam) end = (ideal_track + MAX_CLIENTS + inc) % MAX_CLIENTS; else end = ideal_track; i = end; do { s = &cl.players[i]; if (s->name[0] && !s->spectator) { if (cls.mvdplayback && cl.teamfortress) V_TF_ClearGrenadeEffects(); // BorisU Cam_Lock(i); ideal_track = i; return; } i = (i + MAX_CLIENTS + inc) % MAX_CLIENTS; } while (i != end); // stay on same guy? i = ideal_track; s = &cl.players[i]; if (s->name[0] && !s->spectator) { Cam_Lock(i); return; } Com_Printf ("No target found ...\n"); autocam = locked = false; }
void Movie_Demo_Capture_f(void) { int argc; double time; char *error; #ifdef _WIN32 error = va("Usage: %s <start time [avifile] | stop>\n", Cmd_Argv(0)); if ((argc = Cmd_Argc()) != 2 && argc != 3 && argc != 4) { #else error = va("Usage: %s <start time | stop>\n", Cmd_Argv(0)); if ((argc = Cmd_Argc()) != 2 && argc != 3) { #endif Com_Printf(error); return; } if (argc == 2) { if (strncasecmp("stop", Cmd_Argv(1), 4)) Com_Printf(error); else if (Movie_IsCapturing()) Movie_Stop(); else Com_Printf("%s : Not capturing\n", Cmd_Argv(0)); return; } if (strncasecmp("start", Cmd_Argv(1), 5)) { Com_Printf(error); return; } else if (Movie_IsCapturing()) { Com_Printf("%s : Already capturing\n", Cmd_Argv(0)); return; } if (!cls.demoplayback || cls.timedemo) { Com_Printf("%s : Must be playing a demo to capture\n", Cmd_Argv(0)); return; } if ((time = Q_atof(Cmd_Argv(2))) <= 0) { Com_Printf("%s : Time argument must be positive\n", Cmd_Argv(0)); return; } #ifdef _WIN32 //joe: capturing to avi if (argc == 4) { avi_number = 0; strlcpy(movie_avi_filename, Cmd_Argv(3), sizeof(movie_avi_filename)-10); // Store user's requested filename if (!movie_avi_loaded) { Com_Printf_State (PRINT_FAIL, "Avi capturing not initialized\n"); return; } Movie_Start_AVI_Capture(movie_vid_maxlen.value > 0 && movie_vid_maxlen.value < time); } #endif Movie_Start(time); } #ifdef _WIN32 static void Movie_Start_AVI_Capture(qbool split) { ++avi_number; // If we're going to break up the movie, append number char aviname[MAX_OSPATH]; if (split) snprintf (aviname, sizeof(aviname), "%s-%03d", movie_avi_filename, avi_number); else strlcpy (aviname, movie_avi_filename, sizeof(aviname)); if (!(Util_Is_Valid_Filename(aviname))) { Com_Printf(Util_Invalid_Filename_Msg(aviname)); return; } COM_ForceExtensionEx (aviname, ".avi", sizeof (aviname)); snprintf (avipath, sizeof(avipath), "%s/%s/%s", com_basedir, movie_dir.string, aviname); if (!(avifile = fopen(avipath, "wb"))) { FS_CreatePath (avipath); if (!(avifile = fopen(avipath, "wb"))) { Com_Printf("Error: Couldn't open %s\n", aviname); return; } } }
void S_Init (void) { if (snd_initialized) { //whoops Com_Printf_State (PRINT_INFO, "Sound is already initialized\n"); return; } Com_DPrintf("\nSound Initialization\n"); Cvar_SetCurrentGroup(CVAR_GROUP_SOUND); Cvar_Register(&bgmvolume); Cvar_Register(&s_volume); Cvar_Register(&s_nosound); Cvar_Register(&s_precache); Cvar_Register(&s_loadas8bit); Cvar_Register(&s_khz); Cvar_Register(&s_ambientlevel); Cvar_Register(&s_ambientfade); Cvar_Register(&s_noextraupdate); Cvar_Register(&s_show); Cvar_Register(&s_mixahead); Cvar_Register(&s_swapstereo); #if (defined(__linux__) || defined(__FreeBSD__)) Cvar_Register(&s_stereo); Cvar_Register(&s_device); Cvar_Register(&s_bits); #endif #ifdef __linux__ Cvar_Register(&s_noalsa); #endif Cvar_ResetCurrentGroup(); // compatibility with old configs Cmd_AddLegacyCommand ("nosound", "s_nosound"); Cmd_AddLegacyCommand ("precache", "s_precache"); Cmd_AddLegacyCommand ("loadas8bit", "s_loadas8bit"); Cmd_AddLegacyCommand ("ambient_level", "s_ambientlevel"); Cmd_AddLegacyCommand ("ambient_fade", "s_ambientfade"); Cmd_AddLegacyCommand ("snd_noextraupdate", "s_noextraupdate"); Cmd_AddLegacyCommand ("snd_show", "s_show"); Cmd_AddLegacyCommand ("_snd_mixahead", "s_mixahead"); if (COM_CheckParm("-nosound")) { Cmd_AddLegacyCommand ("play", ""); // just suppress warnings return; } Cmd_AddCommand("snd_restart", S_Restart_f); Cmd_AddLegacyCommand("s_restart", "snd_restart"); // exclusively for Disconnect Cmd_AddCommand("play", S_Play_f); Cmd_AddCommand("playvol", S_PlayVol_f); Cmd_AddCommand("stopsound", S_StopAllSounds_f); Cmd_AddCommand("soundlist", S_SoundList_f); Cmd_AddCommand("soundinfo", S_SoundInfo_f); if (!snd_initialized && host_memsize < 0x800000) { Cvar_Set (&s_loadas8bit, "1"); Com_Printf ("loading all sounds as 8bit\n"); } snd_initialized = true; SND_InitScaletable (); if (!S_Startup ()) { snd_initialized = false; return; } known_sfx = (sfx_t *) Hunk_AllocName (MAX_SFX * sizeof(sfx_t), "sfx_t"); num_sfx = 0; ambient_sfx[AMBIENT_WATER] = S_PrecacheSound ("ambience/water1.wav"); ambient_sfx[AMBIENT_SKY] = S_PrecacheSound ("ambience/wind2.wav"); S_StopAllSounds (true); }
static sndinitstat SNDDMA_InitDirect (void) { DSBUFFERDESC dsbuf; DSBCAPS dsbcaps; DWORD dwSize, dwWrite; DSCAPS dscaps; WAVEFORMATEX format, pformat; HRESULT hresult; int reps, temp, devicenum; memset((void *)shm, 0, sizeof(*shm)); shm->format.channels = 2; shm->format.width = 2; shm->format.speed = SND_Rate((int)s_khz.value); memset (&format, 0, sizeof(format)); format.wFormatTag = WAVE_FORMAT_PCM; format.nChannels = shm->format.channels; format.wBitsPerSample = shm->format.width * 8; format.nSamplesPerSec = shm->format.speed; format.nBlockAlign = format.nChannels * format.wBitsPerSample / 8; format.cbSize = 0; format.nAvgBytesPerSec = format.nSamplesPerSec * format.nBlockAlign; dsdevice = NULL; if ((temp = COM_CheckParm("-snddev")) && temp + 1 < COM_Argc()) { devicenum = Q_atoi(COM_Argv(temp + 1)); currentenum = 0; if ((hresult = DirectSoundEnumerate(DS_EnumDevices, &devicenum)) != DS_OK) { Com_Printf_State (PRINT_INFO, "Couldn't open preferred sound device. Falling back to primary sound device.\n"); dsdevice = NULL; } } hresult = DirectSoundCreate(dsdevice, &pDS, NULL); if (hresult != DS_OK && dsdevice) { Com_Printf_State (PRINT_INFO, "Couldn't open preferred sound device. Falling back to primary sound device.\n"); dsdevice = NULL; hresult = DirectSoundCreate(dsdevice, &pDS, NULL); } if (hresult != DS_OK) { if (hresult == DSERR_ALLOCATED) { Com_Printf_State (PRINT_FAIL, "DirectSoundCreate failed, hardware already in use\n"); return SIS_NOTAVAIL; } Com_Printf_State (PRINT_FAIL, "DirectSound create failed\n"); return SIS_FAILURE; } dscaps.dwSize = sizeof(dscaps); if (DS_OK != pDS->lpVtbl->GetCaps (pDS, &dscaps)) Com_Printf_State (PRINT_FAIL, "Couldn't get DS caps\n"); if (dscaps.dwFlags & DSCAPS_EMULDRIVER) { Com_Printf_State (PRINT_FAIL, "No DirectSound driver installed\n"); FreeSound (); return SIS_FAILURE; } if (DS_OK != pDS->lpVtbl->SetCooperativeLevel (pDS, mainwindow, DSSCL_EXCLUSIVE)) { Com_Printf_State (PRINT_FAIL, "Set coop level failed\n"); FreeSound (); return SIS_FAILURE; } // get access to the primary buffer, if possible, so we can set the sound hardware format memset (&dsbuf, 0, sizeof(dsbuf)); dsbuf.dwSize = sizeof(DSBUFFERDESC); dsbuf.dwFlags = DSBCAPS_PRIMARYBUFFER | (sys_inactivesound.value ? DSBCAPS_GLOBALFOCUS : 0); dsbuf.dwBufferBytes = 0; dsbuf.lpwfxFormat = NULL; memset(&dsbcaps, 0, sizeof(dsbcaps)); dsbcaps.dwSize = sizeof(dsbcaps); primary_format_set = false; if (!COM_CheckParm ("-snoforceformat")) { if (DS_OK == pDS->lpVtbl->CreateSoundBuffer(pDS, &dsbuf, &pDSPBuf, NULL)) { pformat = format; if (DS_OK != pDSPBuf->lpVtbl->SetFormat (pDSPBuf, &pformat)) { // if (snd_firsttime) // Com_Printf ("Set primary sound buffer format: no\n"); } else { // if (snd_firsttime) // Com_Printf ("Set primary sound buffer format: yes\n"); primary_format_set = true; } } } if (!primary_format_set || !COM_CheckParm ("-primarysound")) { // create the secondary buffer we'll actually work with memset (&dsbuf, 0, sizeof(dsbuf)); dsbuf.dwSize = sizeof(DSBUFFERDESC); dsbuf.dwFlags = DSBCAPS_CTRLFREQUENCY | DSBCAPS_LOCSOFTWARE | (sys_inactivesound.value ? DSBCAPS_GLOBALFOCUS : 0); dsbuf.dwBufferBytes = SECONDARY_BUFFER_SIZE; dsbuf.lpwfxFormat = &format; memset(&dsbcaps, 0, sizeof(dsbcaps)); dsbcaps.dwSize = sizeof(dsbcaps); if (DS_OK != pDS->lpVtbl->CreateSoundBuffer(pDS, &dsbuf, &pDSBuf, NULL)) { Com_Printf_State (PRINT_FAIL, "DS:CreateSoundBuffer Failed"); FreeSound (); return SIS_FAILURE; } shm->format.channels = format.nChannels; shm->format.width = format.wBitsPerSample / 8; shm->format.speed = format.nSamplesPerSec; if (DS_OK != pDSBuf->lpVtbl->GetCaps (pDSBuf, &dsbcaps)) { Com_Printf_State (PRINT_FAIL, "DS:GetCaps failed\n"); FreeSound (); return SIS_FAILURE; } // if (snd_firsttime) // Com_Printf ("Using secondary sound buffer\n"); } else { if (DS_OK != pDS->lpVtbl->SetCooperativeLevel (pDS, mainwindow, DSSCL_WRITEPRIMARY)) { Com_Printf_State (PRINT_FAIL, "Set coop level failed\n"); FreeSound (); return SIS_FAILURE; } if (DS_OK != pDSPBuf->lpVtbl->GetCaps (pDSPBuf, &dsbcaps)) { Com_Printf_State (PRINT_FAIL, "DS:GetCaps failed\n"); return SIS_FAILURE; } pDSBuf = pDSPBuf; // Com_Printf ("Using primary sound buffer\n"); } // Make sure mixer is active pDSBuf->lpVtbl->Play(pDSBuf, 0, 0, DSBPLAY_LOOPING); /* if (snd_firsttime) Com_Printf (" %d channel(s)\n" " %d bits/sample\n" " %d bytes/sec\n", shm->format.channels, shm->format.width * , shm->format.speed);*/ gSndBufSize = dsbcaps.dwBufferBytes; // initialize the buffer reps = 0; while ((hresult = pDSBuf->lpVtbl->Lock(pDSBuf, 0, gSndBufSize, &lpData, &dwSize, NULL, NULL, 0)) != DS_OK) { if (hresult != DSERR_BUFFERLOST) { Com_Printf_State (PRINT_FAIL, "SNDDMA_InitDirect: DS::Lock Sound Buffer Failed\n"); FreeSound (); return SIS_FAILURE; } if (++reps > 10000) { Com_Printf_State (PRINT_FAIL, "SNDDMA_InitDirect: DS: couldn't restore buffer\n"); FreeSound (); return SIS_FAILURE; } } memset(lpData, 0, dwSize); // lpData[4] = lpData[5] = 0x7f; // force a pop for debugging pDSBuf->lpVtbl->Unlock(pDSBuf, lpData, dwSize, NULL, 0); /* we don't want anyone to access the buffer directly w/o locking it first. */ lpData = NULL; pDSBuf->lpVtbl->Stop(pDSBuf); pDSBuf->lpVtbl->GetCurrentPosition(pDSBuf, &mmstarttime.u.sample, &dwWrite); pDSBuf->lpVtbl->Play(pDSBuf, 0, 0, DSBPLAY_LOOPING); shm->samples = gSndBufSize/shm->format.width; shm->sampleframes = shm->samples / shm->format.channels; shm->samplepos = 0; shm->buffer = (unsigned char *) lpData; sample16 = shm->format.width - 1; dsound_init = true; return SIS_SUCCESS; }
void Host_Init (int argc, char **argv, int default_memsize) { vfsfile_t *vf; cvar_t *v; char cfg[MAX_PATH] = {0}; int i; char *cfg_name; COM_InitArgv (argc, argv); COM_StoreOriginalCmdline(argc, argv); #ifdef WITH_DP_MEM Memory2_Init (); #endif Host_InitMemory (default_memsize); #ifdef WITH_TCL // interpreter should be initialized // before any cvar definitions TCL_InterpInit (); #endif Cbuf_Init (); Cmd_Init (); Cvar_Init (); COM_Init (); Key_Init (); #ifdef WITH_DP_MEM Memory2_Init_Commands (); #endif Cache_Init_Commands (); FS_InitFilesystem (); NET_Init (); Commands_For_Configs_Init (); ConfigManager_Init(); ResetBinds(); i = COM_CheckParm("+cfg_load"); if (i && (i + 1 < COM_Argc())) { cfg_name = COM_Argv(i + 1); } else { cfg_name = MAIN_CONFIG_FILENAME; } snprintf(cfg, sizeof(cfg), "%s", cfg_name); COM_ForceExtensionEx (cfg, ".cfg", sizeof (cfg)); Cbuf_AddText(va("cfg_load %s\n", cfg)); Cbuf_Execute(); Cbuf_AddEarlyCommands (); Cbuf_Execute (); Con_Init (); NET_InitClient (); Netchan_Init (); #if (!defined WITH_PNG_STATIC || !defined WITH_JPEG_STATIC || defined WITH_MP3_PLAYER) QLib_Init(); #endif Sys_Init (); CM_Init (); PM_Init (); Mod_Init (); SV_Init (); CL_Init (); Cvar_CleanUpTempVars (); SYSINFO_Init(); #ifdef WITH_TCL if (!TCL_InterpLoaded()) Com_Printf_State (PRINT_FAIL, "Could not load "TCL_LIB_NAME", embedded Tcl disabled\n"); #endif Hunk_AllocName (0, "-HOST_HUNKLEVEL-"); host_hunklevel = Hunk_LowMark (); host_initialized = true; // walk through all vars and forse OnChange event if cvar was modified, // also apply that to variables which mirrored in userinfo because of cl_parsefunchars was't applyed as this moment, // same for serverinfo and may be this fix something also. for ( v = NULL; (v = Cvar_Next ( v )); ) { char val[2048]; // if ( !v->modified ) // continue; // not modified even that strange at this moment if ( Cvar_GetFlags( v ) & (CVAR_ROM | CVAR_INIT) ) continue; snprintf(val, sizeof(val), "%s", v->string); Cvar_Set(v, val); } Hud_262LoadOnFirstStart(); Com_Printf_State (PRINT_INFO, "Exe: "__TIME__" "__DATE__"\n"); Com_Printf_State (PRINT_INFO, "Hunk allocation: %4.1f MB.\n", (float) host_memsize / (1024 * 1024)); Com_Printf ("\nezQuake %s\n\n", VersionString()); Com_Printf(Host_PrintBars("ezQuake\x9c" "SourceForge\x9c" "net", 38)); Com_Printf(Host_PrintBars("ezQuake Initialized", 38)); Com_Printf("\n"); Com_Printf ("\nType /help to access the manual.\nUse /describe to learn about commands.\n", VersionString()); if ((vf = FS_OpenVFS("autoexec.cfg", "rb", FS_ANY))) { Cbuf_AddText ("exec autoexec.cfg\n"); VFS_CLOSE(vf); } Cmd_StuffCmds_f (); // process command line arguments Cbuf_AddText ("cl_warncmd 1\n"); #ifdef WIN32 // // Verify that ezQuake is associated with the QW:// protocl handler. // { extern qbool CL_CheckIfQWProtocolHandler(); extern cvar_t cl_verify_qwprotocol; if (cl_verify_qwprotocol.integer >= 2) { // Always register the qw:// protocol. Cbuf_AddText("register_qwurl_protocol\n"); } else if (cl_verify_qwprotocol.integer == 1 && !CL_CheckIfQWProtocolHandler()) { // Check if the running exe is the one associated with the qw:// protocol. Com_PrintVerticalBar(0.8 * vid.conwidth / 8); Com_Printf("\n"); Com_Printf("This ezQuake is not associated with the "); Com_Printf("\x02QW:// protocol.\n"); Com_Printf("Register it using "); Com_Printf("\x02/register_qwurl_protocol\n"); Com_Printf("(set "); Com_Printf("\x02 cl_verify_qwprotocol "); Com_Printf("to 0 to hide this warning)\n"); Com_PrintVerticalBar(0.8 * vid.conwidth / 8); Com_Printf("\n"); } } #endif // WIN32 // Check if a qtv/demo file is specified as the first argument, in that case play that // otherwise, do some more checks of what to show at startup. { char cmd[1024] = {0}; if (COM_CheckArgsForPlayableFiles(cmd, sizeof(cmd))) { Cbuf_AddText(cmd); } else { Startup_Place(); } } #ifdef _WIN32 SetForegroundWindow(mainwindow); SetActiveWindow(mainwindow); #endif host_everything_loaded = true; }
void Movie_Demo_Capture_f(void) { int argc; double time; char *error; #ifdef _WIN32 error = va("Usage: %s <start time [avifile] | stop>\n", Cmd_Argv(0)); if ((argc = Cmd_Argc()) != 2 && argc != 3 && argc != 4) { #else error = va("Usage: %s <start time | stop>\n", Cmd_Argv(0)); if ((argc = Cmd_Argc()) != 2 && argc != 3) { #endif Com_Printf(error); return; } if (argc == 2) { if (strncasecmp("stop", Cmd_Argv(1), 4)) Com_Printf(error); else if (Movie_IsCapturing()) Movie_Stop(); else Com_Printf("%s : Not capturing\n", Cmd_Argv(0)); return; } if (strncasecmp("start", Cmd_Argv(1), 5)) { Com_Printf(error); return; } else if (Movie_IsCapturing()) { Com_Printf("%s : Already capturing\n", Cmd_Argv(0)); return; } if (!cls.demoplayback || cls.timedemo) { Com_Printf("%s : Must be playing a demo to capture\n", Cmd_Argv(0)); return; } if ((time = Q_atof(Cmd_Argv(2))) <= 0) { Com_Printf("%s : Time argument must be positive\n", Cmd_Argv(0)); return; } #ifdef _WIN32 //joe: capturing to avi if (argc == 4) { char aviname[MAX_OSPATH]; if (!movie_avi_loaded) { Com_Printf_State (PRINT_FAIL, "Avi capturing not initialized\n"); return; } strlcpy (aviname, Cmd_Argv(3), sizeof(aviname)); if (!(Util_Is_Valid_Filename(aviname))) { Com_Printf(Util_Invalid_Filename_Msg(aviname)); return; } COM_ForceExtensionEx (aviname, ".avi", sizeof (aviname)); snprintf (avipath, sizeof(avipath), "%s/%s/%s", com_basedir, movie_dir.string, aviname); if (!(avifile = fopen(avipath, "wb"))) { FS_CreatePath (avipath); if (!(avifile = fopen(avipath, "wb"))) { Com_Printf("Error: Couldn't open %s\n", aviname); return; } } } #endif Movie_Start(time); } void Movie_Init(void) { Cvar_SetCurrentGroup(CVAR_GROUP_DEMO); Cvar_Register(&movie_fps); Cvar_Register(&movie_dir); Cvar_Register(&movie_steadycam); Cvar_ResetCurrentGroup(); Cmd_AddCommand("demo_capture", Movie_Demo_Capture_f); #ifdef _WIN32 Capture_InitAVI (); //joe: capturing to avi if (!movie_avi_loaded) return; captured_audio_samples = 0; Cvar_SetCurrentGroup(CVAR_GROUP_DEMO); Cvar_Register(&movie_codec); Cvar_ResetCurrentGroup(); Capture_InitACM (); if (!movie_acm_loaded) return; Cvar_SetCurrentGroup(CVAR_GROUP_DEMO); Cvar_Register(&movie_mp3); Cvar_Register(&movie_mp3_kbps); Cvar_ResetCurrentGroup(); #endif }
void IN_StartupMouse (void) { if (in_mouse.integer == mt_none) return; mouseinitialized = true; in_mwheeltype = MWHEEL_UNKNOWN; #if DIRECTINPUT_VERSION >= 0x0700 if (in_mouse.integer == mt_dinput) { dinput = IN_InitDInput(); if (dinput) { Com_Printf_State (PRINT_OK, "DirectInput initialized\n"); mouse_buttons = 8; if (use_m_smooth) Com_Printf_State (PRINT_OK, "Mouse smoothing initialized\n"); } else { Com_Printf_State (PRINT_FAIL, "DirectInput not initialized\n"); } } #endif // DIRECTINPUT_VERSION >= 0x0700 if (!dinput) { mouseparmsvalid = SystemParametersInfo (SPI_GETMOUSE, 0, originalmouseparms, 0); if (mouseparmsvalid) { if (in_m_os_parameters.integer == 1) { // Keeps the OS acceleration settings. newmouseparms[2] = originalmouseparms[2]; } if (in_m_os_parameters.integer == 2) { // Keeps the OS speed settings. newmouseparms[0] = originalmouseparms[0]; newmouseparms[1] = originalmouseparms[1]; } if (in_m_os_parameters.integer > 2) { // Keeps both OS acceleration and speed settings. newmouseparms[0] = originalmouseparms[0]; newmouseparms[1] = originalmouseparms[1]; newmouseparms[2] = originalmouseparms[2]; } } mouse_buttons = 8; #ifdef USINGRAWINPUT if (in_mouse.integer == mt_raw) { IN_RawInput_Init(); } #endif // USINGRAWINPUT } // If a fullscreen video mode was set before the mouse was initialized, set the mouse state appropriately. if (mouseactivatetoggle) IN_ActivateMouse (); }
qbool IN_InitDInput (void) { #if DIRECTINPUT_VERSION >= 0x0700 HRESULT hr; DIPROPDWORD dipdw = { { sizeof(DIPROPDWORD), // diph.dwSize sizeof(DIPROPHEADER), // diph.dwHeaderSize 0, // diph.dwObj DIPH_DEVICE, // diph.dwHow }, DI_BufSize(), // dwData }; DIDATAFORMAT qdf = { sizeof(DIDATAFORMAT), // this structure sizeof(DIOBJECTDATAFORMAT), // size of object data format DIDF_RELAXIS, // absolute axis coordinates sizeof(MYDATA), // device data size sizeof(rgodf)/sizeof(rgodf[0]), // number of objects rgodf // and here they are }; if (!hInstDI) { hInstDI = LoadLibrary("dinput.dll"); if (hInstDI == NULL) { Com_Printf_State(PRINT_FAIL, "Couldn't load dinput.dll\n"); return false; } } if (!pDirectInputCreateEx) { pDirectInputCreateEx = (void *)GetProcAddress(hInstDI,"DirectInputCreateEx"); if (!pDirectInputCreateEx) { Com_Printf_State(PRINT_FAIL, "Couldn't get DI proc addr\n"); return false; } } // register with DirectInput and get an IDirectInput to play with. hr = pDirectInputCreateEx(global_hInstance, DIRECTINPUT_VERSION, &IID_IDirectInput7, (LPVOID *) &g_pdi, NULL); if (FAILED(hr)) return false; // obtain an interface to the system mouse device. hr = IDirectInput7_CreateDeviceEx(g_pdi, &GUID_SysMouse, &IID_IDirectInputDevice7, (LPVOID *) &g_pMouse, NULL); if (FAILED(hr)) { Com_Printf_State(PRINT_FAIL, "Couldn't open DI mouse device\n"); return false; } // set the data format to "mouse format". hr = IDirectInputDevice7_SetDataFormat(g_pMouse, &qdf); if (FAILED(hr)) { Com_Printf_State(PRINT_FAIL, "Couldn't set DI mouse format\n"); return false; } // set the cooperativity level. hr = IDirectInputDevice7_SetCooperativeLevel(g_pMouse, mainwindow, DISCL_EXCLUSIVE | DISCL_FOREGROUND); if (FAILED(hr)) { Com_Printf_State(PRINT_FAIL, "Couldn't set DI coop level\n"); return false; } // set the buffer size to DI_BufSize() elements. // the buffer size is a DWORD property associated with the device if (in_di_buffered.integer) { hr = IDirectInputDevice7_SetProperty(g_pMouse, DIPROP_BUFFERSIZE, &dipdw.diph); if (FAILED(hr)) { Com_Printf_State(PRINT_FAIL, "Couldn't set DI buffersize\n"); return false; } } else { // no properties for immediate input } IN_SMouseInit(); return true; #else // DIRECTINPUT_VERSION >= 0x0700 return false; #endif // DIRECTINPUT_VERSION >= 0x0700 else }