예제 #1
0
/*
=====================================
Cmd_GetConfigList

Prints or complete .cfg filename
=====================================
*/
qboolean Cmd_GetConfigList( const char *s, char *completedname, int length )
{
	search_t		*t;
	string		matchbuf;
	int		i, numconfigs;

	t = FS_Search( va( "%s*.cfg", s ), true, false );
	if( !t ) return false;

	Q_strncpy( matchbuf, t->filenames[0], 256 );
	if( completedname && length ) Q_strncpy( completedname, matchbuf, length );
	if( t->numfilenames == 1 ) return true;

	for( i = 0, numconfigs = 0; i < t->numfilenames; i++ )
	{
		const char *ext = FS_FileExtension( t->filenames[i] );

		if( Q_stricmp( ext, "cfg" )) continue;
		Q_strncpy( matchbuf, t->filenames[i], 256 );
		Msg( "%16s\n", matchbuf );
		numconfigs++;
	}

	Msg( "\n^3 %i configs found.\n", numconfigs );
	Mem_Free( t );

	// cut shortestMatch to the amount common with s
	if( completedname && length )
	{
		for( i = 0; matchbuf[i]; i++ )
		{
			if( Q_tolower( completedname[i] ) != Q_tolower( matchbuf[i] ))
				completedname[i] = 0;
		}
	}

	return true;
}
예제 #2
0
/*
=====================================
Cmd_GetSavesList

Prints or complete savegame filename
=====================================
*/
qboolean Cmd_GetSavesList( const char *s, char *completedname, int length )
{
	search_t		*t;
	string		matchbuf;
	int		i, numsaves;

	t = FS_Search( va( "save/%s*.sav", s ), true, true );	// lookup only in gamedir
	if( !t ) return false;

	FS_FileBase( t->filenames[0], matchbuf ); 
	if( completedname && length ) Q_strncpy( completedname, matchbuf, length );
	if( t->numfilenames == 1 ) return true;

	for( i = 0, numsaves = 0; i < t->numfilenames; i++ )
	{
		const char *ext = FS_FileExtension( t->filenames[i] ); 

		if( Q_stricmp( ext, "sav" )) continue;
		FS_FileBase( t->filenames[i], matchbuf );
		Msg( "%16s\n", matchbuf );
		numsaves++;
	}

	Msg( "\n^3 %i saves found.\n", numsaves );
	Mem_Free( t );

	// cut shortestMatch to the amount common with s
	if( completedname && length )
	{
		for( i = 0; matchbuf[i]; i++ )
		{
			if( Q_tolower( completedname[i] ) != Q_tolower( matchbuf[i] ))
				completedname[i] = 0;
		}
	}

	return true;
}
/*
=============================
idGameBustOutWindow::LoadBoardFiles
=============================
*/
void idGameBustOutWindow::LoadBoardFiles( void ) {
	int i;
	int w,h;
	ID_TIME_T time;
	int boardSize;
	byte *currentBoard;

	if ( boardDataLoaded ) {
		return;
	}

	boardSize = 9 * 12 * 4;
	levelBoardData = (byte*)Mem_Alloc( boardSize * numLevels );

	currentBoard = levelBoardData;

	for ( i=0; i<numLevels; i++ ) {
		byte *pic;
		idStr	name = "guis/assets/bustout/level";
		name += (i+1);
		name += ".tga";

		R_LoadImage( name, &pic, &w, &h, &time, false );

		if ( pic != NULL ) {
			if ( w != 9 || h != 12 ) {
				common->DWarning( "Hell Bust-Out level image not correct dimensions! (%d x %d)", w, h );
			}

			memcpy( currentBoard, pic, boardSize );
			Mem_Free(pic);
		}

		currentBoard += boardSize;
	}

	boardDataLoaded = true;
}
예제 #4
0
void SW_VES_deconstruct(void)
{
	OutPeriod pd;
	IntU i;

	// De-allocate parameters
	if (SW_VegEstab.count > 0)
	{
		for (i = 0; i < SW_VegEstab.count; i++)
		{
			Mem_Free(SW_VegEstab.parms[i]);
			SW_VegEstab.parms[i] = NULL;
		}

		Mem_Free(SW_VegEstab.parms);
		SW_VegEstab.parms = NULL;
	}


	ForEachOutPeriod(pd)
	{
		// De-allocate days and parameters
		if (SW_VegEstab.count > 0)
		{
			if (!isnull(SW_VegEstab.p_oagg[pd]->days)) {
				Mem_Free(SW_VegEstab.p_oagg[eSW_Year]->days);
			}

			if (!isnull(SW_VegEstab.p_accu[pd]->days)) {
				Mem_Free(SW_VegEstab.p_accu[eSW_Year]->days);
			}
		}

		// De-allocate output structures
		if (pd > eSW_Day && !isnull(SW_VegEstab.p_oagg[pd])) {
			Mem_Free(SW_VegEstab.p_oagg[pd]);
			SW_VegEstab.p_oagg[pd] = NULL;
		}

		if (!isnull(SW_VegEstab.p_accu[pd])) {
			Mem_Free(SW_VegEstab.p_accu[pd]);
			SW_VegEstab.p_accu[pd] = NULL;
		}
	}
}
예제 #5
0
static unsigned char *decode_image(downloadinfo *di, const char *content_type)
{
	unsigned char *pixels = NULL;
	fs_offset_t filesize = 0;
	unsigned char *data = FS_LoadFile(di->filename, tempmempool, true, &filesize);
	if(data)
	{
		int mip = 0;
		if(!strcmp(content_type, "image/jpeg"))
			pixels = JPEG_LoadImage_BGRA(data, filesize, &mip);
		else if(!strcmp(content_type, "image/png"))
			pixels = PNG_LoadImage_BGRA(data, filesize, &mip);
		else if(filesize >= 7 && !strncmp((char *) data, "\xFF\xD8", 7))
			pixels = JPEG_LoadImage_BGRA(data, filesize, &mip);
		else if(filesize >= 7 && !strncmp((char *) data, "\x89PNG\x0D\x0A\x1A\x0A", 7))
			pixels = PNG_LoadImage_BGRA(data, filesize, &mip);
		else
			Con_Printf("Did not detect content type: %s\n", content_type);
		Mem_Free(data);
	}
	// do we call Image_MakeLinearColorsFromsRGB or not?
	return pixels;
}
예제 #6
0
DRESULT disk_read(BYTE drv, BYTE *buff, DWORD sector, BYTE count)
{
    void *buffer;

    u32 len;
    s32 ret = 0;

    /* Buffer length */
    len = (count * SECTOR_SZ);

    /* Allocate buffer */
    buffer = Mem_Alloc(count * 512);
    if (!buffer)
        return RES_ERROR;

    /* Read sectors */
    switch (drv) {
    case DRIVE_SDHC:
        /* Read SD sectors */
        ret = sdio_ReadSectors(sector, count, buffer);
        break;

    case DRIVE_EHCI:
        /* Read USB sectors */
        ret = ehci_ReadSectors(sector, count, buffer);
        break;
    }

    /* Copy buffer */
    if (ret)
        memcpy(buff, buffer, len);

    /* Free buffer */
    Mem_Free(buffer);

    return (ret) ? RES_OK : RES_ERROR;
}
예제 #7
0
/*
 * @brief Captures a screenshot, writing it to the user's directory.
 */
void R_Screenshot_f(void) {
	static uint16_t last_screenshot;
	char filename[MAX_OS_PATH];
	uint16_t i;

	// find a file name to save it to
	for (i = last_screenshot; i < MAX_SCREENSHOTS; i++) {
		g_snprintf(filename, sizeof(filename), "screenshots/quetoo%03u.jpg", i);

		if (!Fs_Exists(filename))
			break; // file doesn't exist
	}

	if (i == MAX_SCREENSHOTS) {
		Com_Warn("Failed to create %s\n", filename);
		return;
	}

	last_screenshot = i; // save for next call

	const uint32_t width = r_context.width;
	const uint32_t height = r_context.height;

	byte *buffer = Mem_Malloc(width * height * 3);

	glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, buffer);

	const int32_t quality = Clamp(r_screenshot_quality->integer, 0, 100);

	if (Img_WriteJPEG(filename, buffer, width, height, quality)) {
		Com_Print("Saved %s\n", Basename(filename));
	} else {
		Com_Warn("Failed to write %s\n", filename);
	}

	Mem_Free(buffer);
}
예제 #8
0
void FreeXprt(SVCXPRT *xprt)
{
  if(!xprt)
    {
      LogFullDebug(COMPONENT_RPC,
                   "Attempt to free NULL xprt");
      return;
      
    }

  LogFullDebug(COMPONENT_RPC,
               "FreeXprt xprt=%p", xprt);
  if(xprt->xp_ops == &Svcudp_op)
    {
      xp_free(Su_data(xprt));
      xp_free(rpc_buffer(xprt));
    }
  else if (xprt->xp_ops == &Svctcp_op)
    {
      struct tcp_conn *cd = (struct tcp_conn *)xprt->xp_p1;
      XDR_DESTROY(&(cd->xdrs));
      xp_free(xprt->xp_p1); /* cd */
    }
  else if (xprt->xp_ops == &Svctcp_rendezvous_op)
    {
      xp_free(xprt->xp_p1); /* r */
    }
  else
    {
      LogCrit(COMPONENT_RPC,
              "Attempt to free unknown xprt %p",
              xprt);
      return;
    }

  Mem_Free(xprt);
}
예제 #9
0
/* test the maps that have seedlists */
static void testSeedlists (void)
{
    int i, n;
    long time, timeSum = 0;
    MapInfo *randomMap;
    size_t length;
    const char* assNames[][2] = {
        {"farm", "medium"},
        {"farm", "large"},
        {"forest", "large"},
        {"forest", "large_crash"},
        {"oriental", "large"},
        {"village", "commercial"},
        {"village", "small"}
    };
    length = sizeof(assNames) / (2 * sizeof(char *));
    char entityString[MAX_TOKEN_CHARS];

    sv_threads->integer = 0;
    for (n = 0; n < length; n++) {
        for (i = 1; i < 20; i++) {
            srand(i);
            time = Sys_Milliseconds();
            Com_Printf("Seed: %i\n", i);
            randomMap = SV_AssembleMap(assNames[n][0], assNames[n][1], mapStr, posStr, entityString, i);
            CU_ASSERT(randomMap != NULL);
            time = Sys_Milliseconds() - time;
            timeSum += time;
            UFO_CU_ASSERT_TRUE_MSG(time < MAX_ALLOWED_TIME_TO_ASSEMBLE,
                                   va("%s fails to assemble in a reasonable time with seed %i (time: %li ms)", randomMap->name, i, time));
            if (time > 10000)
                Com_Printf("Seed %i: tiles: %i ms: %li\n", i, randomMap->numPlaced, time);
            Mem_Free(randomMap);
        }
    }
    Com_Printf("TotalTime: %li\n", timeSum);
}
예제 #10
0
파일: host.c 프로젝트: ptitSeb/xash3d
/*
===============
Host_Exec_f
===============
*/
void Host_Exec_f( void )
{
	string	cfgpath;
	char	*f;

	if( Cmd_Argc() != 2 )
	{
		Msg( "Usage: exec <filename>\n" );
		return;
	}

	// HACKHACK: don't execute listenserver.cfg in singleplayer
	if( !Q_stricmp( Cvar_VariableString( "lservercfgfile" ),  Cmd_Argv( 1 )))
	{
		if( Cvar_VariableValue( "maxplayers" ) == 1.0f )
			return;
	}

	Q_strncpy( cfgpath, Cmd_Argv( 1 ), sizeof( cfgpath )); 
	FS_DefaultExtension( cfgpath, ".cfg" ); // append as default

	f = (char *)FS_LoadFile( cfgpath, NULL, false );
	if( !f )
	{
		MsgDev( D_NOTE, "couldn't exec %s\n", Cmd_Argv( 1 ));
		return;
	}

	MsgDev( D_INFO, "execing %s\n", Cmd_Argv( 1 ));

	// terminate the string with newline just in case it's missing
	// insertion order is backwards from execution order
	Cbuf_InsertText( "\n" );
	Cbuf_InsertText( f );
	Mem_Free( f );
}
예제 #11
0
/*
================
idDemoFile::Close
================
*/
void idDemoFile::Close() {
	if ( writing && compressor ) {
		compressor->FinishCompress();
	}

	if ( f ) {
		fileSystem->CloseFile( f );
		f = NULL;
	}
	if ( fLog ) {
		fileSystem->CloseFile( fLog );
		fLog = NULL;
	}
	if ( fileImage ) {
		Mem_Free( fileImage );
		fileImage = NULL;
	}
	if ( compressor ) {
		delete compressor;
		compressor = NULL;
	}

	demoStrings.DeleteContents( true );
}
예제 #12
0
/**
 * FSAL_closedir :
 * Free the resources allocated for reading directory entries.
 *     
 * \param dir_descriptor (input):
 *        Pointer to a directory descriptor filled by FSAL_opendir.
 * 
 * \return Major error codes :
 *        - ERR_FSAL_NO_ERROR     (no error)
 *        - Another error code if an error occured.
 */
fsal_status_t POSIXFSAL_closedir(fsal_dir_t * dir_descriptor     /* IN */  )
{
  posixfsal_dir_t * p_dir_descriptor = (posixfsal_dir_t *) dir_descriptor;
  int rc;

  /* sanity checks */
  if(!p_dir_descriptor)
    Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_closedir);

#ifdef _USE_POSIXDB_READDIR_BLOCK
  if(p_dir_descriptor->p_dbentries)
    Mem_Free(p_dir_descriptor->p_dbentries);
#endif

  rc = closedir(p_dir_descriptor->p_dir);
  if(rc != 0)
    Return(posix2fsal_error(errno), errno, INDEX_FSAL_closedir);

  /* fill dir_descriptor with zeros */
  memset(p_dir_descriptor, 0, sizeof(posixfsal_dir_t));

  Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_closedir);

}
예제 #13
0
void Delta_Shutdown( void )
{
	int	i;

	if( !delta_init ) return;

	for( i = 0; i < NUM_FIELDS( dt_info ); i++ )
	{
		dt_info[i].numFields = 0;
		dt_info[i].customEncode = CUSTOM_NONE;
		dt_info[i].userCallback = NULL;
		dt_info[i].funcName[0] = '\0';

		if( dt_info[i].pFields )
		{
			Mem_Free( dt_info[i].pFields );
			dt_info[i].pFields = NULL;
		}

		dt_info[i].bInitialized = false;
	}

	delta_init = false;
}
예제 #14
0
/* <65aeb> ../engine/net_chan.c:1123 */
void Netchan_FragSend(netchan_t *chan)
{
	fragbufwaiting_t *wait;
	int i;

	if (!chan)
		return;

	for (i = 0; i < MAX_STREAMS; i++)
	{
		// Already something queued up, just leave in waitlist
		if (chan->fragbufs[i])
		{
			continue;
		}

		wait = chan->waitlist[i];

		// Nothing to queue?
		if (!wait)
		{
			continue;
		}

		chan->waitlist[i] = wait->next;

		wait->next = NULL;

		// Copy in to fragbuf
		chan->fragbufs[i] = wait->fragbufs;
		chan->fragbufcount[i] = wait->fragbufcount;

		// Throw away wait list
		Mem_Free(wait);
	}
}
예제 #15
0
파일: lightmap.c 프로젝트: kevlund/ufoai
static void WriteTGA24 (const char *filename, const byte * data, int width, int height, int offset)
{
	int i, size;
	byte *buffer;
	qFILE file;

	size = width * height * 3;
	/* allocate a buffer and set it up */
	buffer = (byte *)Mem_Alloc(size + TGA_HEADER_SIZE);
	memset(buffer, 0, TGA_HEADER_SIZE);
	buffer[2] = 2;
	buffer[12] = width & 255;
	buffer[13] = width >> 8;
	buffer[14] = height & 255;
	buffer[15] = height >> 8;
	buffer[16] = 24;
	/* create top-down TGA */
	buffer[17] = 32;

	/* swap rgb to bgr */
	for (i = 0; i < size; i += 3) {
		buffer[i + TGA_HEADER_SIZE] = data[i*2 + offset + 2];	/* blue */
		buffer[i + TGA_HEADER_SIZE + 1] = data[i*2 + offset + 1];	/* green */
		buffer[i + TGA_HEADER_SIZE + 2] = data[i*2 + offset + 0];	/* red */
	}

	/* write it and free the buffer */
	if (FS_OpenFile(filename, &file, FILE_WRITE) > 0)
		Sys_Error("Unable to open %s for writing", filename);

	FS_Write(buffer, size + TGA_HEADER_SIZE, &file);

	/* close the file */
	FS_CloseFile(&file);
	Mem_Free(buffer);
}
예제 #16
0
파일: cl_scrn.c 프로젝트: bmk10/sing-engine
static void SCR_LoadCreditsFont( void )
{
	byte	*buffer;
	size_t	length;
	int	fontWidth;
	qfont_t	*src;

	// setup creditsfont
	if( !FS_FileExists( "gfx/creditsfont.fnt", false ))
		return;

	// half-life font with variable chars witdh
	buffer = FS_LoadFile( "gfx/creditsfont.fnt", &length, false );
	R_GetTextureParms( &fontWidth, NULL, cls.creditsFont.hFontTexture );
	
	if( buffer && length >= sizeof( qfont_t ))
	{
		int	i;
	
		src = (qfont_t *)buffer;
		clgame.scrInfo.iCharHeight = src->rowheight;

		// build rectangles
		for( i = 0; i < 256; i++ )
		{
			cls.creditsFont.fontRc[i].left = (word)src->fontinfo[i].startoffset % fontWidth;
			cls.creditsFont.fontRc[i].right = cls.creditsFont.fontRc[i].left + src->fontinfo[i].charwidth;
			cls.creditsFont.fontRc[i].top = (word)src->fontinfo[i].startoffset / fontWidth;
			cls.creditsFont.fontRc[i].bottom = cls.creditsFont.fontRc[i].top + src->rowheight;
			clgame.scrInfo.charWidths[i] = src->fontinfo[i].charwidth;
		}
		cls.creditsFont.valid = true;
	}

	if( buffer ) Mem_Free( buffer );
}
예제 #17
0
파일: cl_keys.c 프로젝트: chrisglass/ufoai
/**
 * @brief Bind a keynum to script command
 * @param[in] keynum Converted from string to keynum
 * @param[in] binding The script command to bind keynum to
 * @param[in] space The key space to bind the key for (menu, game or battle)
 * @sa Key_Bind_f
 * @sa Key_StringToKeynum
 * @note If command is empty, this function will only remove the actual key binding instead of setting empty string.
 */
void Key_SetBinding (int keynum, const char *binding, keyBindSpace_t space)
{
	char **keySpace = NULL;

	if (keynum == -1 || keynum >= K_KEY_SIZE)
		return;

	Com_DPrintf(DEBUG_CLIENT, "Binding for '%s' for space ", binding);
	switch (space) {
	case KEYSPACE_UI:
		keySpace = &menuKeyBindings[keynum];
		Com_DPrintf(DEBUG_CLIENT, "menu\n");
		break;
	case KEYSPACE_GAME:
		keySpace = &keyBindings[keynum];
		Com_DPrintf(DEBUG_CLIENT, "game\n");
		break;
	case KEYSPACE_BATTLE:
		keySpace = &battleKeyBindings[keynum];
		Com_DPrintf(DEBUG_CLIENT, "battle\n");
		break;
	default:
		Com_DPrintf(DEBUG_CLIENT, "failure\n");
		return;
	}

	/* free old bindings */
	if (*keySpace) {
		Mem_Free(*keySpace);
		*keySpace = NULL;
	}

	/* allocate memory for new binding, but don't set empty commands*/
	if (binding)
		*keySpace = Mem_PoolStrDup(binding, com_genericPool, 0);
}
예제 #18
0
/*
==============================
Netchan_CopyNormalFragments

==============================
*/
qboolean Netchan_CopyNormalFragments( netchan_t *chan, sizebuf_t *msg )
{
	fragbuf_t	*p, *n;

	if( !chan->incomingready[FRAG_NORMAL_STREAM] )
		return false;

	if( !chan->incomingbufs[FRAG_NORMAL_STREAM] )
	{
		MsgDev( D_ERROR, "Netchan_CopyNormalFragments:  Called with no fragments readied\n" );
		chan->incomingready[FRAG_NORMAL_STREAM] = false;
		return false;
	}

	p = chan->incomingbufs[FRAG_NORMAL_STREAM];

	BF_Init( msg, "NetMessage", net_message_buffer, sizeof( net_message_buffer ));

	while( p )
	{
		n = p->next;
		
		// copy it in
		BF_WriteBits( msg, BF_GetData( &p->frag_message ), BF_GetNumBitsWritten( &p->frag_message ));

		Mem_Free( p );
		p = n;
	}
	
	chan->incomingbufs[FRAG_NORMAL_STREAM] = NULL;

	// reset flag
	chan->incomingready[FRAG_NORMAL_STREAM] = false;

	return true;
}
예제 #19
0
void VID_StartupGamma( void )
{
	// Device supports gamma anyway, but cannot do anything with it.
	fs_offset_t	gamma_size;
	byte	*savedGamma;
	size_t	gammaTypeSize = sizeof(glState.stateRamp);

	// init gamma ramp
	Q_memset( glState.stateRamp, 0, gammaTypeSize);

#if defined(XASH_SDL)
	glConfig.deviceSupportsGamma = !SDL_GetWindowGammaRamp( host.hWnd, NULL, NULL, NULL);
#endif

	if( !glConfig.deviceSupportsGamma )
	{
		// force to set cvar
		Cvar_FullSet( "gl_ignorehwgamma", "1", CVAR_GLCONFIG );
		MsgDev( D_ERROR, "VID_StartupGamma: hardware gamma unsupported\n");
	}

	if( gl_ignorehwgamma->integer )
	{
		glConfig.deviceSupportsGamma = false;	// even if supported!
		BuildGammaTable( vid_gamma->value, vid_texgamma->value );
		MsgDev( D_NOTE, "VID_StartupGamma: software gamma initialized\n" );
		return;
	}

	// share this extension so engine can grab them
	GL_SetExtension( GL_HARDWARE_GAMMA_CONTROL, glConfig.deviceSupportsGamma );

	savedGamma = FS_LoadFile( "gamma.dat", &gamma_size, false );

	if( !savedGamma || gamma_size != (fs_offset_t)gammaTypeSize)
	{
		// saved gamma not found or corrupted file
		FS_WriteFile( "gamma.dat", glState.stateRamp, gammaTypeSize);
		MsgDev( D_NOTE, "VID_StartupGamma: gamma.dat initialized\n" );
		if( savedGamma ) Mem_Free( savedGamma );
	}
	else
	{
		GL_BuildGammaTable();

		// validate base gamma
		if( !Q_memcmp( savedGamma, glState.stateRamp, gammaTypeSize))
		{
			// all ok, previous gamma is valid
			MsgDev( D_NOTE, "VID_StartupGamma: validate screen gamma - ok\n" );
		}
		else if( !Q_memcmp( glState.gammaRamp, glState.stateRamp, gammaTypeSize))
		{
			// screen gamma is equal to render gamma (probably previous instance crashed)
			// run additional check to make sure for it
			if( Q_memcmp( savedGamma, glState.stateRamp, gammaTypeSize))
			{
				// yes, current gamma it's totally wrong, restore it from gamma.dat
				MsgDev( D_NOTE, "VID_StartupGamma: restore original gamma after crash\n" );
				Q_memcpy( glState.stateRamp, savedGamma, gammaTypeSize);
			}
			else
			{
				// oops, savedGamma == glState.stateRamp == glState.gammaRamp
				// probably r_gamma set as default
				MsgDev( D_NOTE, "VID_StartupGamma: validate screen gamma - disabled\n" ); 
			}
		}
		else if( !Q_memcmp( glState.gammaRamp, savedGamma, gammaTypeSize))
		{
			// saved gamma is equal render gamma, probably gamma.dat wroted after crash
			// run additional check to make sure it
			if( Q_memcmp( savedGamma, glState.stateRamp, gammaTypeSize))
			{
				// yes, saved gamma it's totally wrong, get origianl gamma from screen
				MsgDev( D_NOTE, "VID_StartupGamma: merge gamma.dat after crash\n" );
				FS_WriteFile( "gamma.dat", glState.stateRamp, gammaTypeSize);
			}
			else
			{
				// oops, savedGamma == glState.stateRamp == glState.gammaRamp
				// probably r_gamma set as default
				MsgDev( D_NOTE, "VID_StartupGamma: validate screen gamma - disabled\n" ); 
			}
		}
		else
		{
			// current gamma unset by other application, so we can restore it here
			MsgDev( D_NOTE, "VID_StartupGamma: restore original gamma after crash\n" );
			Q_memcpy( glState.stateRamp, savedGamma, gammaTypeSize);
		}

		Mem_Free( savedGamma );
	}

	vid_gamma->modified = true;
}
예제 #20
0
파일: cmd.cpp 프로젝트: LeninChan/rehlds
/* <5e43> ../engine/cmd.c:347 */
void Cmd_Exec_f(void)
{
	const char *pszFileName;
	const char *pszFileExt;
	char *pszFileData;
	int nAddLen;
	FileHandle_t hFile;

	if (Cmd_Argc() != 2)
	{
		Con_Printf("exec <filename> : execute a script file\n");
		return;
	}

	pszFileName = Cmd_Argv(1);
	if (!pszFileName || pszFileName[0] == 0)
	{
		return;
	}

	if (Q_strstr(pszFileName, "\\")
		|| Q_strstr(pszFileName, ":")
		|| Q_strstr(pszFileName, "~")
		|| Q_strstr(pszFileName, "..")
		|| *pszFileName == '/')
	{
		Con_Printf("exec %s: invalid path.\n", pszFileName);
		return;
	}

	pszFileExt = COM_FileExtension((char *)pszFileName);
	if (Q_stricmp(pszFileExt, "cfg") && Q_stricmp(pszFileExt, "rc"))
	{
		Con_Printf("exec %s: not a .cfg or .rc file\n", pszFileName);
		return;
	}

	hFile = FS_OpenPathID(pszFileName, "rb", "GAMECONFIG");
	if (!hFile)
	{
		hFile = FS_OpenPathID(pszFileName, "rb", "GAME");
	}
	if (!hFile)
	{
		hFile = FS_Open(pszFileName, "rb");
	}

	if (!hFile)
	{
		if (!Q_strstr(pszFileName, "autoexec.cfg")
			&& !Q_strstr(pszFileName, "userconfig.cfg")
			&& !Q_strstr(pszFileName, "hw/opengl.cfg")
			&& !Q_strstr(pszFileName, "joystick.cfg")
			&& !Q_strstr(pszFileName, "game.cfg"))
		{
			Con_Printf("couldn't exec %s\n", pszFileName);
		}

		return;
	}

	nAddLen = FS_Size(hFile);
	pszFileData = (char *)Mem_Malloc(nAddLen + 1);

	if (!pszFileData)
	{
		Con_Printf("exec: not enough space for %s", pszFileName);
		FS_Close(hFile);
		return;
	}

	FS_Read(pszFileData, nAddLen, 1, hFile);
	pszFileData[nAddLen] = 0;
	FS_Close(hFile);

	Con_DPrintf("execing %s\n", pszFileName);

	if (cmd_text.cursize + nAddLen + 2 < cmd_text.maxsize)
	{
		Cbuf_InsertTextLines(pszFileData);
	}
	else
	{
		char *pszDataPtr = pszFileData;
		while (true)
		{
			Cbuf_Execute();	// TODO: This doesn't obey the rule to first execute commands from the file, and then the others in the buffer
			pszDataPtr = COM_ParseLine(pszDataPtr);

			if (com_token[0] == 0)
			{
				break;
			}

			Cbuf_InsertTextLines(com_token);
		}
	}

	Mem_Free(pszFileData);
}
예제 #21
0
/*
================
Sys_ListFiles
================
*/
int Sys_ListFiles( const char* directory, const char* extension, idStrList& list )
{
	struct dirent* d;
	DIR* fdir;
	bool dironly = false;
	char search[MAX_OSPATH];
	struct stat st;
	bool debug;
	
	list.Clear();
	
	debug = cvarSystem->GetCVarBool( "fs_debug" );
	// DG: we use fnmatch for shell-style pattern matching
	// so the pattern should at least contain "*" to match everything,
	// the extension will be added behind that (if !dironly)
	idStr pattern( "*" );
	
	// passing a slash as extension will find directories
	if( extension[0] == '/' && extension[1] == 0 )
	{
		dironly = true;
	}
	else
	{
		// so we have *<extension>, the same as in the windows code basically
		pattern += extension;
	}
	// DG end
	
	// NOTE: case sensitivity of directory path can screw us up here
	if( ( fdir = opendir( directory ) ) == NULL )
	{
		if( debug )
		{
			common->Printf( "Sys_ListFiles: opendir %s failed\n", directory );
		}
		return -1;
	}
	
	// DG: use readdir_r instead of readdir for thread safety
	// the following lines are from the readdir_r manpage.. fscking ugly.
	int nameMax = pathconf( directory, _PC_NAME_MAX );
	if( nameMax == -1 )
		nameMax = 255;
	int direntLen = offsetof( struct dirent, d_name ) + nameMax + 1;
	
	struct dirent* entry = ( struct dirent* )Mem_Alloc( direntLen, TAG_CRAP );
	
	if( entry == NULL )
	{
		common->Warning( "Sys_ListFiles: Mem_Alloc for entry failed!" );
		closedir( fdir );
		return 0;
	}
	
	while( readdir_r( fdir, entry, &d ) == 0 && d != NULL )
	{
		// DG end
		idStr::snPrintf( search, sizeof( search ), "%s/%s", directory, d->d_name );
		if( stat( search, &st ) == -1 )
			continue;
		if( !dironly )
		{
			// DG: the original code didn't work because d3 bfg abuses the extension
			// to match whole filenames and patterns in the savegame-code, not just file extensions...
			// so just use fnmatch() which supports matching shell wildcard patterns ("*.foo" etc)
			// if we should ever need case insensitivity, use FNM_CASEFOLD as third flag
			if( fnmatch( pattern.c_str(), d->d_name, 0 ) != 0 )
				continue;
			// DG end
		}
		if( ( dironly && !( st.st_mode & S_IFDIR ) ) ||
				( !dironly && ( st.st_mode & S_IFDIR ) ) )
			continue;
			
		list.Append( d->d_name );
	}
	
	closedir( fdir );
	Mem_Free( entry );
	
	if( debug )
	{
		common->Printf( "Sys_ListFiles: %d entries in %s\n", list.Num(), directory );
	}
	
	return list.Num();
}
예제 #22
0
/**
 *
 * nfs_read_core_conf: read the configuration ite; for the worker theads.
 *
 * Reads the configuration ite; for the worker theads.
 *
 * @param in_config [IN] configuration file handle
 * @param pparam [OUT] read parameters
 *
 * @return 0 if ok, -1 if failed, 1 is stanza is not there.
 *
 */
int nfs_read_core_conf(config_file_t in_config, nfs_core_parameter_t * pparam)
{
  int var_max;
  int var_index;
  int err;
  char *key_name;
  char *key_value;
  config_item_t block;

  /* Is the config tree initialized ? */
  if(in_config == NULL || pparam == NULL)
    return CACHE_INODE_INVALID_ARGUMENT;

  /* Get the config BLOCK */
  if((block = config_FindItemByName(in_config, CONF_LABEL_NFS_CORE)) == NULL)
    {
      LogDebug(COMPONENT_CONFIG,
               "Cannot read item \"%s\" from configuration file",
               CONF_LABEL_NFS_CORE);
      return 1;
    }
  else if(config_ItemType(block) != CONFIG_ITEM_BLOCK)
    {
      /* Expected to be a block */
      LogDebug(COMPONENT_CONFIG,
               "Item \"%s\" is expected to be a block",
               CONF_LABEL_NFS_CORE);
      return 1;
    }

  var_max = config_GetNbItems(block);

  for(var_index = 0; var_index < var_max; var_index++)
    {
      config_item_t item;

      item = config_GetItemByIndex(block, var_index);

      /* Get key's name */
      if((err = config_GetKeyValue(item, &key_name, &key_value)) != 0)
        {
          LogCrit(COMPONENT_CONFIG,
                  "Error reading key[%d] from section \"%s\" of configuration file.",
                  var_index, CONF_LABEL_NFS_CORE);
          return CACHE_INODE_INVALID_ARGUMENT;
        }

      if(!strcasecmp(key_name, "Nb_Worker"))
        {
          pparam->nb_worker = atoi(key_value);
        }
      else if(!strcasecmp(key_name, "Nb_Call_Before_Queue_Avg"))
        {
          pparam->nb_call_before_queue_avg = atoi(key_value);
        }
      else if(!strcasecmp(key_name, "Nb_MaxConcurrentGC"))
        {
          pparam->nb_max_concurrent_gc = atoi(key_value);
        }
      else if(!strcasecmp(key_name, "DupReq_Expiration"))
        {
          pparam->expiration_dupreq = atoi(key_value);
        }
      else if(!strcasecmp(key_name, "Drop_IO_Errors"))
        {
          pparam->drop_io_errors = StrToBoolean(key_value);
        }
      else if(!strcasecmp(key_name, "Drop_Inval_Errors"))
        {
          pparam->drop_inval_errors = StrToBoolean(key_value);
        }
      else if(!strcasecmp(key_name, "Drop_Delay_Errors"))
        {
          pparam->drop_delay_errors = StrToBoolean(key_value);
        }
      else if(!strcasecmp(key_name, "NFS_Port"))
        {
          pparam->port[P_NFS] = (unsigned short)atoi(key_value);
        }
      else if(!strcasecmp(key_name, "MNT_Port"))
        {
          pparam->port[P_MNT] = (unsigned short)atoi(key_value);
        }
      else if(!strcasecmp(key_name, "NLM_Port"))
        {
#ifdef _USE_NLM
          pparam->port[P_NLM] = (unsigned short)atoi(key_value);
#endif
        }
      else if(!strcasecmp(key_name, "Rquota_Port"))
        {
#ifdef _USE_QUOTA
          pparam->port[P_RQUOTA] = (unsigned short)atoi(key_value);
#endif
        }
      else if(!strcasecmp(key_name, "NFS_Program"))
        {
          pparam->program[P_NFS] = atoi(key_value);
        }
      else if(!strcasecmp(key_name, "MNT_Program"))
        {
          pparam->program[P_MNT] = atoi(key_value);
        }
      else if(!strcasecmp(key_name, "NLM_Program"))
        {
#ifdef _USE_NLM
          pparam->program[P_NLM] = atoi(key_value);
#endif
        }
      else if(!strcasecmp(key_name, "Rquota_Program"))
        {
#ifdef _USE_QUOTA
          pparam->program[P_RQUOTA] = atoi(key_value);
#endif
        }
      else if(!strcasecmp(key_name, "NFS_Protocols"))
        {

#     define MAX_NFSPROTO      10       /* large enough !!! */
#     define MAX_NFSPROTO_LEN  256      /* so is it !!! */

          char *nfsvers_list[MAX_NFSPROTO];
          int idx, count;

          /* reset nfs versions flags (clean defaults) */
          pparam->core_options &= ~(CORE_OPTION_ALL_VERS);

          /* allocate nfs vers strings */
          for(idx = 0; idx < MAX_NFSPROTO; idx++)
            nfsvers_list[idx] = (char *)Mem_Alloc(MAX_NFSPROTO_LEN);

          /*
           * Search for coma-separated list of nfsprotos
           */
          count = nfs_ParseConfLine(nfsvers_list, MAX_NFSPROTO,
                                    key_value, find_comma, find_endLine);

          if(count < 0)
            {
              LogCrit(COMPONENT_CONFIG,
                      "NFS_Protocols list too long (>%d)",
                      MAX_NFSPROTO);

              /* free sec strings */
              for(idx = 0; idx < MAX_NFSPROTO; idx++)
                Mem_Free((caddr_t) nfsvers_list[idx]);

              return -1;
            }

          /* add each Nfs protocol flag to the option field.  */

          for(idx = 0; idx < count; idx++)
            {
              if(!strcmp(nfsvers_list[idx], "4"))
                {
                  pparam->core_options |= CORE_OPTION_NFSV4;
                }
/* only NFSv4 is supported for the FSAL_PROXY */
#if ! defined( _USE_PROXY ) || defined ( _HANDLE_MAPPING )
              else if(!strcmp(nfsvers_list[idx], "2"))
                {
                  pparam->core_options |= CORE_OPTION_NFSV2;
                }
              else if(!strcmp(nfsvers_list[idx], "3"))
                {
                  pparam->core_options |= CORE_OPTION_NFSV3;
                }
#endif                          /* _USE_PROXY */
              else
                {
                  LogCrit(COMPONENT_CONFIG,
                          "Invalid NFS Protocol \"%s\". Values can be: 2, 3, 4.",
                          nfsvers_list[idx]);
                  return -1;
                }
            }

          /* free sec strings */
          for(idx = 0; idx < MAX_NFSPROTO; idx++)
            Mem_Free((caddr_t) nfsvers_list[idx]);

          /* check that at least one nfs protocol has been specified */
          if((pparam->core_options & (CORE_OPTION_ALL_VERS)) == 0)
            {
              LogCrit(COMPONENT_CONFIG, "Empty NFS_Protocols list");
              return -1;
            }
        }
      else if(!strcasecmp(key_name, "Bind_Addr"))
        {
          int rc;
          memset(&pparam->bind_addr.sin_addr, 0, sizeof(pparam->bind_addr.sin_addr));
          rc = inet_pton(AF_INET, key_value, &pparam->bind_addr.sin_addr);
          if(rc <= 0)
            {
              /* Revert to INADDR_ANY in case of any error */
              pparam->bind_addr.sin_addr.s_addr = INADDR_ANY;   /* All the interfaces on the machine are used */
            }
        }
      else if(!strcasecmp(key_name, "Core_Dump_Size"))
        {
          pparam->core_dump_size = atol(key_value);
        }
      else if(!strcasecmp(key_name, "Nb_Max_Fd"))
        {
          pparam->nb_max_fd = atoi(key_value);
        }
      else if(!strcasecmp(key_name, "Stats_File_Path"))
        {
          strncpy(pparam->stats_file_path, key_value, MAXPATHLEN);
        }
      else if(!strcasecmp(key_name, "Stats_Update_Delay"))
        {
          pparam->stats_update_delay = atoi(key_value);
        }
      else if(!strcasecmp(key_name, "Long_Processing_Threshold"))
        {
          pparam->long_processing_threshold = atoi(key_value);
        }
      else if(!strcasecmp( key_name, "TCP_Fridge_Expiration_Delay" ) )
        {
          pparam->tcp_fridge_expiration_delay = atoi(key_value);
        }
      else if(!strcasecmp(key_name, "Dump_Stats_Per_Client"))
        {
          pparam->dump_stats_per_client = StrToBoolean(key_value);
        }
      else if(!strcasecmp(key_name, "Stats_Per_Client_Directory"))
        {
          strncpy(pparam->stats_per_client_directory, key_value, MAXPATHLEN);
        }
      else if(!strcasecmp(key_name, "FSAL_Shared_Library"))
        {
          strncpy(pparam->fsal_shared_library, key_value, MAXPATHLEN);
        }
      else
        {
          LogCrit(COMPONENT_CONFIG,
                  "Unknown or unsettable key: %s (item %s)",
                  key_name, CONF_LABEL_NFS_CORE);
          return -1;
        }

    }

  return 0;
}                               /* nfs_read_core_conf */
예제 #23
0
/*
=================
R_StaticFree
=================
*/
void R_StaticFree( void *data ) {
	tr.pc.c_free++;
    Mem_Free( data );
}
예제 #24
0
/*
====================
ModPlug_FetchSound
====================
*/
static const snd_buffer_t* ModPlug_FetchSound (void *sfxfetcher, void **chfetcherpointer, unsigned int *start, unsigned int nbsampleframes)
{
	modplug_stream_perchannel_t* per_ch = (modplug_stream_perchannel_t *)*chfetcherpointer;
	modplug_stream_persfx_t* per_sfx = (modplug_stream_persfx_t *)sfxfetcher;
	snd_buffer_t* sb;
	int newlength, done, ret;
	unsigned int real_start;
	unsigned int factor;

	// If there's no fetcher structure attached to the channel yet
	if (per_ch == NULL)
	{
		size_t buff_len, memsize;
		snd_format_t sb_format;

		sb_format.speed = snd_renderbuffer->format.speed;
		sb_format.width = per_sfx->format.width;
		sb_format.channels = per_sfx->format.channels;

		buff_len = STREAM_BUFFER_SIZE(&sb_format);
		memsize = sizeof (*per_ch) - sizeof (per_ch->sb.samples) + buff_len;
		per_ch = (modplug_stream_perchannel_t *)Mem_Alloc (snd_mempool, memsize);

		// Open it with the modplugFile API
		per_ch->mf = qModPlug_Load(per_sfx->file, per_sfx->filesize);
		if (!per_ch->mf)
		{
			Con_Printf("error while reading ModPlug stream \"%s\"\n", per_sfx->name);
			Mem_Free (per_ch);
			return NULL;
		}

#ifndef SND_MODPLUG_STATIC
		if(qModPlug_SetMasterVolume)
#endif
			qModPlug_SetMasterVolume(per_ch->mf, 512); // max volume, DP scales down!

		per_ch->bs = 0;

		per_ch->sb_offset = 0;
		per_ch->sb.format = sb_format;
		per_ch->sb.nbframes = 0;
		per_ch->sb.maxframes = buff_len / (per_ch->sb.format.channels * per_ch->sb.format.width);

		*chfetcherpointer = per_ch;
	}

	real_start = *start;

	sb = &per_ch->sb;
	factor = per_sfx->format.width * per_sfx->format.channels;

	// If the stream buffer can't contain that much samples anyway
	if (nbsampleframes > sb->maxframes)
	{
		Con_Printf ("ModPlug_FetchSound: stream buffer too small (%u sample frames required)\n", nbsampleframes);
		return NULL;
	}

	// If the data we need has already been decompressed in the sfxbuffer, just return it
	if (per_ch->sb_offset <= real_start && per_ch->sb_offset + sb->nbframes >= real_start + nbsampleframes)
	{
		*start = per_ch->sb_offset;
		return sb;
	}

	newlength = (int)(per_ch->sb_offset + sb->nbframes) - real_start;

	// If we need to skip some data before decompressing the rest, or if the stream has looped
	if (newlength < 0 || per_ch->sb_offset > real_start)
	{
		unsigned int time_start;
		unsigned int modplug_start;

		/*
		MODs loop on their own, so any position is valid!
		if (real_start > (unsigned int)per_sfx->total_length)
		{
			Con_Printf ("ModPlug_FetchSound: asked for a start position after the end of the sfx! (%u > %u)\n",
						real_start, per_sfx->total_length);
			return NULL;
		}
		*/

		// We work with 200ms (1/5 sec) steps to avoid rounding errors
		time_start = real_start * 5 / snd_renderbuffer->format.speed;
		modplug_start = time_start * (1000 / 5);

		Con_DPrintf("warning: mod file needed to seek (to %d)\n", modplug_start);

		qModPlug_Seek(per_ch->mf, modplug_start);
		sb->nbframes = 0;

		real_start = (unsigned int) ((float)modplug_start / 1000 * snd_renderbuffer->format.speed);
		if (*start - real_start + nbsampleframes > sb->maxframes)
		{
			Con_Printf ("ModPlug_FetchSound: stream buffer too small after seek (%u sample frames required)\n",
						*start - real_start + nbsampleframes);
			per_ch->sb_offset = real_start;
			return NULL;
		}
	}
	// Else, move forward the samples we need to keep in the sound buffer
	else
	{
		memmove (sb->samples, sb->samples + (real_start - per_ch->sb_offset) * factor, newlength * factor);
		sb->nbframes = newlength;
	}

	per_ch->sb_offset = real_start;

	// We add more than one frame of sound to the buffer:
	// 1- to ensure we won't lose many samples during the resampling process
	// 2- to reduce calls to ModPlug_FetchSound to regulate workload
	newlength = (int)(per_sfx->format.speed*STREAM_BUFFER_FILL);
	if ((size_t) ((double) newlength * (double)sb->format.speed / (double)per_sfx->format.speed) + sb->nbframes > sb->maxframes)
	{
		Con_Printf ("ModPlug_FetchSound: stream buffer overflow (%u + %u = %u sample frames / %u)\n",
					(unsigned int) ((double) newlength * (double)sb->format.speed / (double)per_sfx->format.speed), sb->nbframes, (unsigned int) ((double) newlength * (double)sb->format.speed / (double)per_sfx->format.speed) + sb->nbframes, sb->maxframes);
		return NULL;
	}
	newlength *= factor; // convert from sample frames to bytes
	if(newlength > (int)sizeof(resampling_buffer))
		newlength = sizeof(resampling_buffer);

	// Decompress in the resampling_buffer
	done = 0;
	while ((ret = qModPlug_Read (per_ch->mf, (char *)&resampling_buffer[done], (int)(newlength - done))) > 0)
		done += ret;
	if(done < newlength)
	{
		// Argh. We didn't get as many samples as we wanted. Probably
		// libmodplug forgot what mLoopCount==-1 means... basically, this means
		// we can't loop like this. Try to let DP fix it later...
		per_sfx->sfx->total_length = (real_start + ((size_t)done / (size_t)factor));
		per_sfx->sfx->loopstart = 0;

		if(newlength != done)
			Con_DPrintf("ModPlug_Fetch: wanted: %d, got: %d\n", newlength, done);
	}

	Snd_AppendToSndBuffer (sb, resampling_buffer, (size_t)done / (size_t)factor, &per_sfx->format);

	*start = per_ch->sb_offset;
	return sb;
}
예제 #25
0
/*
====================
ModPlug_LoadmodplugFile

Load an modplug file into memory
====================
*/
qboolean ModPlug_LoadModPlugFile (const char *filename, sfx_t *sfx)
{
	unsigned char *data;
	fs_offset_t filesize;
	ModPlugFile *mf;
	modplug_stream_persfx_t* per_sfx;
	ModPlug_Settings s;

	if (!modplug_dll)
		return false;

	// Already loaded?
	if (sfx->fetcher != NULL)
		return true;

	// Load the file
	data = FS_LoadFile (filename, snd_mempool, false, &filesize);
	if (data == NULL)
		return false;

	if (developer_loading.integer >= 2)
		Con_Printf ("Loading ModPlug file \"%s\"\n", filename);

	qModPlug_GetSettings(&s);
	s.mFlags = MODPLUG_ENABLE_OVERSAMPLING | MODPLUG_ENABLE_NOISE_REDUCTION | MODPLUG_ENABLE_REVERB;
	s.mChannels = 2;
	s.mBits = 16;
	s.mFrequency = 44100;
	s.mResamplingMode = MODPLUG_RESAMPLE_SPLINE;
	s.mLoopCount = -1;
	qModPlug_SetSettings(&s);

	// Open it with the modplugFile API
	if (!(mf = qModPlug_Load (data, filesize)))
	{
		Con_Printf ("error while opening ModPlug file \"%s\"\n", filename);
		Mem_Free(data);
		return false;
	}

#ifndef SND_MODPLUG_STATIC
	if(qModPlug_SetMasterVolume)
#endif
		qModPlug_SetMasterVolume(mf, 512); // max volume, DP scales down!

	if (developer_loading.integer >= 2)
		Con_Printf ("\"%s\" will be streamed\n", filename);
	per_sfx = (modplug_stream_persfx_t *)Mem_Alloc (snd_mempool, sizeof (*per_sfx));
	strlcpy(per_sfx->name, sfx->name, sizeof(per_sfx->name));
	sfx->memsize += sizeof (*per_sfx);
	per_sfx->file = data;
	per_sfx->filesize = filesize;
	sfx->memsize += filesize;

	per_sfx->format.speed = 44100; // modplug always works at that rate
	per_sfx->format.width = 2;  // We always work with 16 bits samples
	per_sfx->format.channels = 2; // stereo rulez ;) (MAYBE default to mono because Amiga MODs sound better then?)
	per_sfx->sfx = sfx;

	sfx->fetcher_data = per_sfx;
	sfx->fetcher = &modplug_fetcher;
	sfx->flags |= SFXFLAG_STREAMED;
	sfx->total_length = 2147384647; // they always loop
	sfx->loopstart = sfx->total_length; // modplug does it

	return true;
}
예제 #26
0
파일: cap_ogg.c 프로젝트: Blub/darkplaces
static void SCR_CaptureVideo_Ogg_EndVideo(void)
{
	LOAD_FORMATSPECIFIC_OGG();
	ogg_page pg;
	ogg_packet pt;

	if(format->yuvi >= 0)
	{
		// send the previous (and last) frame
		while(format->lastnum-- > 0)
		{
			qtheora_encode_YUVin(&format->ts, &format->yuv[format->yuvi]);

			while(qtheora_encode_packetout(&format->ts, !format->lastnum, &pt))
				qogg_stream_packetin(&format->to, &pt);

			SCR_CaptureVideo_Ogg_Interleave();
		}
	}

	if(cls.capturevideo.soundrate)
	{
		qvorbis_analysis_wrote(&format->vd, 0);
		while(qvorbis_analysis_blockout(&format->vd, &format->vb) == 1)
		{
			qvorbis_analysis(&format->vb, NULL);
			qvorbis_bitrate_addblock(&format->vb);
			while(qvorbis_bitrate_flushpacket(&format->vd, &pt))
				qogg_stream_packetin(&format->vo, &pt);
			SCR_CaptureVideo_Ogg_Interleave();
		}
	}

	SCR_CaptureVideo_Ogg_FlushInterleaving();

	while(qogg_stream_pageout(&format->to, &pg) > 0)
	{
		FS_Write(cls.capturevideo.videofile, pg.header, pg.header_len);
		FS_Write(cls.capturevideo.videofile, pg.body, pg.body_len);
	}

	if(cls.capturevideo.soundrate)
	{
		while(qogg_stream_pageout(&format->vo, &pg) > 0)
		{
			FS_Write(cls.capturevideo.videofile, pg.header, pg.header_len);
			FS_Write(cls.capturevideo.videofile, pg.body, pg.body_len);
		}
	}
		
	while (1) {
		int result = qogg_stream_flush (&format->to, &pg);
		if (result < 0)
			fprintf (stderr, "Internal Ogg library error.\n"); // TODO Host_Error
		if (result <= 0)
			break;
		FS_Write(cls.capturevideo.videofile, pg.header, pg.header_len);
		FS_Write(cls.capturevideo.videofile, pg.body, pg.body_len);
	}

	if(cls.capturevideo.soundrate)
	{
		while (1) {
			int result = qogg_stream_flush (&format->vo, &pg);
			if (result < 0)
				fprintf (stderr, "Internal Ogg library error.\n"); // TODO Host_Error
			if (result <= 0)
				break;
			FS_Write(cls.capturevideo.videofile, pg.header, pg.header_len);
			FS_Write(cls.capturevideo.videofile, pg.body, pg.body_len);
		}

		qogg_stream_clear(&format->vo);
		qvorbis_block_clear(&format->vb);
		qvorbis_dsp_clear(&format->vd);
	}

	qogg_stream_clear(&format->to);
	qtheora_clear(&format->ts);
	qvorbis_info_clear(&format->vi);

	Mem_Free(format->yuv[0].y);
	Mem_Free(format->yuv[0].u);
	Mem_Free(format->yuv[0].v);
	Mem_Free(format->yuv[1].y);
	Mem_Free(format->yuv[1].u);
	Mem_Free(format->yuv[1].v);
	Mem_Free(format);

	FS_Close(cls.capturevideo.videofile);
	cls.capturevideo.videofile = NULL;
}
예제 #27
0
파일: sv_init.c 프로젝트: kevlund/ufoai
/**
 * @brief Change the server to a new map, taking all connected clients along with it.
 * @note the full syntax is: @code map [day|night] [+]<map> [<assembly>] @endcode
 * @sa SV_AssembleMap
 * @sa CM_LoadMap
 * @sa Com_SetServerState
 */
void SV_Map (qboolean day, const char *levelstring, const char *assembly)
{
	int i;
	unsigned checksum = 0;
	char * map = SV_GetConfigString(CS_TILES);
	char * pos = SV_GetConfigString(CS_POSITIONS);
	mapInfo_t *randomMap = NULL;
	client_t *cl;

	/* any partially connected client will be restarted */
	Com_SetServerState(ss_restart);

	/* the game is just starting */
	SV_InitGame();

	if (!svs.initialized) {
		Com_Printf("Could not spawn the server\n");
		return;
	}

	assert(levelstring[0] != '\0');

	Com_DPrintf(DEBUG_SERVER, "SpawnServer: %s\n", levelstring);

	/* save name for levels that don't set message */
	SV_SetConfigString(CS_NAME, levelstring);
	SV_SetConfigString(CS_LIGHTMAP, day);

	Q_strncpyz(sv->name, levelstring, sizeof(sv->name));

	/* set serverinfo variable */
	sv_mapname = Cvar_FullSet("sv_mapname", sv->name, CVAR_SERVERINFO | CVAR_NOSET);

	/* notify the client in case of a listening server */
	SCR_BeginLoadingPlaque();

	if (assembly)
		Q_strncpyz(sv->assembly, assembly, sizeof(sv->assembly));
	else
		sv->assembly[0] = '\0';

	/* leave slots at start for clients only */
	cl = NULL;
	while ((cl = SV_GetNextClient(cl)) != NULL) {
		/* needs to reconnect */
		if (cl->state >= cs_spawning)
			SV_SetClientState(cl, cs_connected);
	}

	/* assemble and load the map */
	if (levelstring[0] == '+') {
		randomMap = SV_AssembleMap(levelstring + 1, assembly, map, pos, 0);
		if (!randomMap) {
			Com_Printf("Could not load assembly for map '%s'\n", levelstring);
			return;
		}
	} else {
		SV_SetConfigString(CS_TILES, levelstring);
		SV_SetConfigString(CS_POSITIONS, assembly ? assembly : "");
	}

	CM_LoadMap(map, day, pos, &sv->mapData, &sv->mapTiles);

	Com_Printf("checksum for the map '%s': %u\n", levelstring, sv->mapData.mapChecksum);
	SV_SetConfigString(CS_MAPCHECKSUM, sv->mapData.mapChecksum);

	checksum = Com_GetScriptChecksum();

	Com_Printf("ufo script checksum %u\n", checksum);
	SV_SetConfigString(CS_UFOCHECKSUM, checksum);
	SV_SetConfigString(CS_OBJECTAMOUNT, csi.numODs);
	SV_SetConfigString(CS_VERSION, UFO_VERSION);
	SV_SetConfigString(CS_MAPTITLE, SV_GetMapTitle(randomMap, levelstring));
	if (Q_strstart(SV_GetConfigString(CS_MAPTITLE), "b/")) {
		/* For base attack, CS_MAPTITLE contains too many chars */
		SV_SetConfigString(CS_MAPTITLE, "Base attack");
		SV_SetConfigString(CS_NAME, ".baseattack");
	}

	/* clear random-map assembly data */
	Mem_Free(randomMap);
	randomMap = NULL;

	/* clear physics interaction links */
	SV_ClearWorld();

	/* fix this! */
	for (i = 1; i <= sv->mapData.numInline; i++)
		sv->models[i] = CM_InlineModel(&sv->mapTiles, va("*%i", i));

	/* precache and static commands can be issued during map initialization */
	Com_SetServerState(ss_loading);

	TH_MutexLock(svs.serverMutex);
	/* load and spawn all other entities */
	svs.ge->SpawnEntities(sv->name, SV_GetConfigStringInteger(CS_LIGHTMAP), sv->mapData.mapEntityString);
	TH_MutexUnlock(svs.serverMutex);

	/* all precaches are complete */
	Com_SetServerState(ss_game);

	Com_Printf("-------------------------------------\n");

	Cbuf_CopyToDefer();
}
예제 #28
0
파일: tree.cpp 프로젝트: ibrahimmusba/ufoai
void FreeTree (tree_t *tree)
{
	FreeTreePortals_r(tree->headnode);
	FreeTree_r(tree->headnode);
	Mem_Free(tree);
}
예제 #29
0
/* Free a struct cidr_addr */
void
cidr_free(CIDR *tofree)
{

	Mem_Free(tofree);
}
예제 #30
0
파일: md2.cpp 프로젝트: AresAndy/ufoai
void MD2SkinNum (const byte* buf, const char* fileName, int bufSize, void* userData)
{
	byte* copy = Mem_Dup(byte, buf, bufSize);
	dMD2Model_t* md2 = (dMD2Model_t*)copy;

	MD2HeaderCheck(md2, fileName, bufSize);

	const uint32_t numSkins = LittleLong(md2->num_skins);

	const uint32_t ofsST = LittleLong(md2->ofs_st);
	const uint32_t ofsTris = LittleLong(md2->ofs_tris);
	const uint32_t ofsFrames = LittleLong(md2->ofs_frames);
	const uint32_t ofsGLCmds = LittleLong(md2->ofs_glcmds);
	const uint32_t ofsEnd = LittleLong(md2->ofs_end);
	const uint32_t ofsSkins = LittleLong(md2->ofs_skins);

	uint32_t moveOffset = ofsEnd;
#define CHECKMAX(val) 	if ((val) > ofsSkins && (val) < moveOffset) moveOffset = (val);
	CHECKMAX(ofsST);
	CHECKMAX(ofsTris);
	CHECKMAX(ofsFrames);
	CHECKMAX(ofsGLCmds);
	CHECKMAX(ofsSkins);
#undef CHECKMAX

	Com_Printf("  \\ - skins %i\n", numSkins);
	int newSkins = 0;
	printf("  \\ - new skin number: ");
	fflush(stdout);
	scanf("%i", &newSkins);
	if (newSkins <= 0) {
		Com_Printf("A model must have a skin\n");
		Mem_Free(copy);
		return;
	}
	if (newSkins > MD2_MAX_SKINS) {
		Com_Printf("Only %i skins are allowed\n", MD2_MAX_SKINS);
		Mem_Free(copy);
		return;
	}

	if (newSkins == numSkins) {
		Mem_Free(copy);
		return;
	}

	const int32_t deltaSkins = newSkins - numSkins;
	const int32_t offsetDelta = deltaSkins * MD2_MAX_SKINNAME;
	if (ofsST > ofsSkins)
		md2->ofs_st = LittleLong(ofsST + offsetDelta);
	if (ofsTris > ofsSkins)
		md2->ofs_tris = LittleLong(ofsTris + offsetDelta);
	if (ofsFrames > ofsSkins)
		md2->ofs_frames = LittleLong(ofsFrames + offsetDelta);
	if (ofsGLCmds > ofsSkins)
		md2->ofs_glcmds = LittleLong(ofsGLCmds + offsetDelta);
	md2->ofs_end = LittleLong(ofsEnd + offsetDelta);
	md2->num_skins = LittleLong(newSkins);

	Com_Printf("change to %i skins\n", newSkins);
	if (deltaSkins > 0) {
		copy = (byte*)Mem_ReAlloc(copy, md2->ofs_end);
		md2 = (dMD2Model_t*)copy;
	}

	const int n = ofsEnd - moveOffset;
	byte* from = copy + moveOffset;
	byte* to = from + offsetDelta;
	memmove(to, from, n);

	if (deltaSkins > 0) {
		char*  md2Path = (char*) copy + LittleLong(md2->ofs_skins);
		for (int i = numSkins; i < numSkins + deltaSkins; i++) {
			char* name = md2Path + i * MD2_MAX_SKINNAME;
			memset(name, 0, MD2_MAX_SKINNAME);
			strcpy(name, ".none");
			Com_Printf("  \\ - skin %i: %s\n", i + 1, name);
			printf("  \\ - new skin: ");
			fflush(stdout);
			scanf(va("%%%is", MD2_MAX_SKINNAME), name);
		}
	}
	ScopedFile md2ModelFile;
	FS_OpenFile(fileName, &md2ModelFile, FILE_WRITE);
	if (!md2ModelFile) {
		Com_Printf("Error writing md2 file %s\n", fileName);
		Mem_Free(copy);
		return;
	}
	FS_Write(copy, md2->ofs_end, &md2ModelFile);
	Mem_Free(copy);
}