自学教程：C++ FS_Write函数代码示例

//.........这里部分代码省略.........							fMaxVol = pSFX->fVolRange;							// free sfx->data...							//							{								// Hunk_FreeTempMemory( SFX.data );	// this will have been allocated inside S_LoadSound_Finalise()								//								// I want a big thankyou from the Mac guys for providing this define... :-) -ste								//								// #ifndef INT_MIN								// #define INT_MIN     (-2147483647 - 1) /* minimum (signed) int value */								// #endif								//								pSFX->iLastTimeUsed = INT_MIN;		// force this to be oldest sound file, therefore disposable...								pSFX->bInMemory = qtrue;								SND_FreeOldestSound();		// ... and do the disposal								// now set our temp SFX struct back to default name so nothing else accidentally uses it...								//								strcpy(pSFX->sSoundName, sReservedSFXEntrynameForMP3);								pSFX->bDefaultSound = qfalse;															}							// other stuff...							//							Z_Free(pbUnpackBuffer);						}						// well, time to update the file now...						//						fileHandle_t f = FS_FOpenFileWrite( sFilename );						if (f)						{							// write the file back out, but omitting the tag if there was one...							//							int iWritten = FS_Write(pbData, iSize-(pTAG?sizeof(*pTAG):0), f);							if (iWritten)							{								// make up a new tag if we didn't find one in the original file...								//								id3v1_1 TAG;								if (!pTAG)								{									pTAG = &TAG;									memset(&TAG,0,sizeof(TAG));									strncpy(pTAG->id,"TAG",3);								}								strncpy(pTAG->title,	Filename_WithoutPath(Filename_WithoutExt(sFilename)), sizeof(pTAG->title));								strncpy(pTAG->artist,	"Raven Software",						sizeof(pTAG->artist)	);								strncpy(pTAG->year,		"2001",									sizeof(pTAG->year)		);								strncpy(pTAG->comment,	va("%s %g",sKEY_MAXVOL,fMaxVol),		sizeof(pTAG->comment)	);								strncpy(pTAG->album,	va("%s %d",sKEY_UNCOMP,iActualUnpackedSize),sizeof(pTAG->album)	);																if (FS_Write( pTAG, sizeof(*pTAG), f ))	// NZ = success								{									iFilesUpdated++;								}								else								{									Com_Printf("*********** Failed write to file!/n");									iErrors++;								}							}							else							{								Com_Printf("*********** Failed write to file!/n");								iErrors++;							}							FS_FCloseFile( f );						}						else						{							Com_Printf("*********** Failed to re-open for write!/n");							iErrors++;						}										}					else					{						Com_Error(ERR_DROP, "******* This MP3 should be deleted: %s/n",sFilename);					}				}				else				{					Com_Printf("*********** File was not a valid MP3!/n");					iErrors++;				}			}			else			{				Com_Printf(" ( OK )/n");			}			FS_FreeFile( pbData );		}	}	FS_FreeFileList( sysFiles );	FS_FreeFileList( dirFiles );}

int CL_CgameSystemCalls( int *args ) {#ifndef __NO_JK2    if( Cvar_VariableIntegerValue("com_jk2") )    {        args[0] = (int)CL_ConvertJK2SysCall((cgameJK2Import_t)args[0]);    }#endif    switch( args[0] ) {    case CG_PRINT:        Com_Printf( "%s", VMA(1) );        return 0;    case CG_ERROR:        Com_Error( ERR_DROP, S_COLOR_RED"%s", VMA(1) );        return 0;    case CG_MILLISECONDS:        return Sys_Milliseconds();    case CG_CVAR_REGISTER:        Cvar_Register( (vmCvar_t *) VMA(1), (const char *) VMA(2), (const char *) VMA(3), args[4] );        return 0;    case CG_CVAR_UPDATE:        Cvar_Update( (vmCvar_t *) VMA(1) );        return 0;    case CG_CVAR_SET:        Cvar_Set( (const char *) VMA(1), (const char *) VMA(2) );        return 0;    case CG_ARGC:        return Cmd_Argc();    case CG_ARGV:        Cmd_ArgvBuffer( args[1], (char *) VMA(2), args[3] );        return 0;    case CG_ARGS:        Cmd_ArgsBuffer( (char *) VMA(1), args[2] );        return 0;    case CG_FS_FOPENFILE:        return FS_FOpenFileByMode( (const char *) VMA(1), (int *) VMA(2), (fsMode_t) args[3] );    case CG_FS_READ:        FS_Read( VMA(1), args[2], args[3] );        return 0;    case CG_FS_WRITE:        FS_Write( VMA(1), args[2], args[3] );        return 0;    case CG_FS_FCLOSEFILE:        FS_FCloseFile( args[1] );        return 0;    case CG_SENDCONSOLECOMMAND:        Cbuf_AddText( (const char *) VMA(1) );        return 0;    case CG_ADDCOMMAND:        CL_AddCgameCommand( (const char *) VMA(1) );        return 0;    case CG_SENDCLIENTCOMMAND:        CL_AddReliableCommand( (const char *) VMA(1) );        return 0;    case CG_UPDATESCREEN:        // this is used during lengthy level loading, so pump message loop        Com_EventLoop();	// FIXME: if a server restarts here, BAD THINGS HAPPEN!        SCR_UpdateScreen();        return 0;#ifdef _XBOX    case CG_RMG_INIT:    case CG_CM_REGISTER_TERRAIN:    case CG_RE_INIT_RENDERER_TERRAIN:        Com_Error( ERR_FATAL, "ERROR: Terrain unsupported on Xbox./n" );#else    case CG_RMG_INIT:        /*        if (!com_sv_running->integer)        {	// don't do this if we are connected locally        	if (!TheRandomMissionManager)        	{        		TheRandomMissionManager = new CRMManager;        	}        	TheRandomMissionManager->SetLandScape( cmg.landScapes[args[1]] );        	TheRandomMissionManager->LoadMission(qfalse);        	TheRandomMissionManager->SpawnMission(qfalse);        	cmg.landScapes[args[1]]->UpdatePatches();        }        */ //this is SP.. I guess we're always the client and server.//		cl.mRMGChecksum = cm.landScapes[args[1]]->get_rand_seed();        RM_CreateRandomModels(args[1], (const char *)VMA(2));        //cmg.landScapes[args[1]]->rand_seed(cl.mRMGChecksum);		// restore it, in case we do a vid restart        cmg.landScape->rand_seed(cmg.landScape->get_rand_seed());//		TheRandomMissionManager->CreateMap();        return 0;    case CG_CM_REGISTER_TERRAIN:        return CM_RegisterTerrain((const char *)VMA(1), false)->GetTerrainId();    case CG_RE_INIT_RENDERER_TERRAIN:        RE_InitRendererTerrain((const char *)VMA(1));        return 0;#endif	// _XBOX    case CG_CM_LOADMAP:#ifdef _XBOX        CL_CM_LoadMap( (const char *) VMA(1) );#else        CL_CM_LoadMap( (const char *) VMA(1), args[2] );#endif        return 0;//.........这里部分代码省略.........

/*====================CL_CgameSystemCallsThe cgame module is making a system call====================*/intptr_t CL_CgameSystemCalls( intptr_t *args ) {    switch( args[0] ) {    case CG_PRINT:        Com_Printf( "%s", (const char*)VMA(1) );        return 0;    case CG_ERROR:        Com_Error( ERR_DROP, "%s", (const char*)VMA(1) );        return 0;    case CG_MILLISECONDS:        return Sys_Milliseconds();    case CG_CVAR_REGISTER:        Cvar_Register( VMA(1), VMA(2), VMA(3), args[4] );        return 0;    case CG_CVAR_UPDATE:        Cvar_Update( VMA(1) );        return 0;    case CG_CVAR_SET:        Cvar_SetSafe( VMA(1), VMA(2) );        return 0;    case CG_CVAR_VARIABLESTRINGBUFFER:        Cvar_VariableStringBuffer( VMA(1), VMA(2), args[3] );        return 0;    case CG_ARGC:        return Cmd_Argc();    case CG_ARGV:        Cmd_ArgvBuffer( args[1], VMA(2), args[3] );        return 0;    case CG_ARGS:        Cmd_ArgsBuffer( VMA(1), args[2] );        return 0;    case CG_FS_FOPENFILE:        return FS_FOpenFileByMode( VMA(1), VMA(2), args[3] );    case CG_FS_READ:        FS_Read2( VMA(1), args[2], args[3] );        return 0;    case CG_FS_WRITE:        FS_Write( VMA(1), args[2], args[3] );        return 0;    case CG_FS_FCLOSEFILE:        FS_FCloseFile( args[1] );        return 0;    case CG_FS_SEEK:        return FS_Seek( args[1], args[2], args[3] );    case CG_SENDCONSOLECOMMAND:        Cbuf_AddText( VMA(1) );        return 0;    case CG_ADDCOMMAND:        CL_AddCgameCommand( VMA(1) );        return 0;    case CG_REMOVECOMMAND:        Cmd_RemoveCommandSafe( VMA(1) );        return 0;    case CG_SENDCLIENTCOMMAND:        CL_AddReliableCommand(VMA(1), qfalse);        return 0;    case CG_UPDATESCREEN:        // this is used during lengthy level loading, so pump message loop//		Com_EventLoop();	// FIXME: if a server restarts here, BAD THINGS HAPPEN!// We can't call Com_EventLoop here, a restart will crash and this _does_ happen// if there is a map change while we are downloading at pk3.// ZOID        SCR_UpdateScreen();        return 0;    case CG_CM_LOADMAP:        CL_CM_LoadMap( VMA(1) );        return 0;    case CG_CM_NUMINLINEMODELS:        return CM_NumInlineModels();    case CG_CM_INLINEMODEL:        return CM_InlineModel( args[1] );    case CG_CM_TEMPBOXMODEL:        return CM_TempBoxModel( VMA(1), VMA(2), /*int capsule*/ qfalse );    case CG_CM_TEMPCAPSULEMODEL:        return CM_TempBoxModel( VMA(1), VMA(2), /*int capsule*/ qtrue );    case CG_CM_POINTCONTENTS:        return CM_PointContents( VMA(1), args[2] );    case CG_CM_TRANSFORMEDPOINTCONTENTS:        return CM_TransformedPointContents( VMA(1), args[2], VMA(3), VMA(4) );    case CG_CM_BOXTRACE:        CM_BoxTrace( VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], /*int capsule*/ qfalse );        return 0;    case CG_CM_CAPSULETRACE:        CM_BoxTrace( VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], /*int capsule*/ qtrue );        return 0;    case CG_CM_TRANSFORMEDBOXTRACE:        CM_TransformedBoxTrace( VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], VMA(8), VMA(9), /*int capsule*/ qfalse );        return 0;    case CG_CM_TRANSFORMEDCAPSULETRACE:        CM_TransformedBoxTrace( VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], VMA(8), VMA(9), /*int capsule*/ qtrue );        return 0;    case CG_CM_MARKFRAGMENTS:        return re.MarkFragments( args[1], VMA(2), VMA(3), args[4], VMA(5), args[6], VMA(7) );    case CG_S_STARTSOUND://.........这里部分代码省略.........

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;}

/*============Cvar_WriteVariablesAppends lines containing "set variable value" for all variableswith the archive flag set that are not in a transient state.============*/void Cvar_WriteVariables( fileHandle_t f ){    std::string text = Cvar::GetCvarConfigText();    FS_Write(text.c_str(), text.size(), f);}

/*====================CL_CgameSystemCallsThe cgame module is making a system call====================*/intptr_t CL_CgameSystemCalls( intptr_t *args ) {	switch ( args[0] ) {	case CG_PRINT:		Com_Printf( "%s", VMA( 1 ) );		return 0;	case CG_ERROR:		Com_Error( ERR_DROP, "%s", VMA( 1 ) );		return 0;	case CG_MILLISECONDS:		return Sys_Milliseconds();	case CG_CVAR_REGISTER:		Cvar_Register( VMA( 1 ), VMA( 2 ), VMA( 3 ), args[4] );		return 0;	case CG_CVAR_UPDATE:		Cvar_Update( VMA( 1 ) );		return 0;	case CG_CVAR_SET:		Cvar_Set( VMA( 1 ), VMA( 2 ) );		return 0;	case CG_CVAR_VARIABLESTRINGBUFFER:		Cvar_VariableStringBuffer( VMA( 1 ), VMA( 2 ), args[3] );		return 0;	case CG_ARGC:		return Cmd_Argc();	case CG_ARGV:		Cmd_ArgvBuffer( args[1], VMA( 2 ), args[3] );		return 0;	case CG_ARGS:		Cmd_ArgsBuffer( VMA( 1 ), args[2] );		return 0;	case CG_FS_FOPENFILE:		return FS_FOpenFileByMode( VMA( 1 ), VMA( 2 ), args[3] );	case CG_FS_READ:		FS_Read( VMA( 1 ), args[2], args[3] );		return 0;	case CG_FS_WRITE:		return FS_Write( VMA( 1 ), args[2], args[3] );	case CG_FS_FCLOSEFILE:		FS_FCloseFile( args[1] );		return 0;	case CG_SENDCONSOLECOMMAND:		Cbuf_AddText( VMA( 1 ) );		return 0;	case CG_ADDCOMMAND:		CL_AddCgameCommand( VMA( 1 ) );		return 0;	case CG_REMOVECOMMAND:		Cmd_RemoveCommand( VMA( 1 ) );		return 0;	case CG_SENDCLIENTCOMMAND:		CL_AddReliableCommand( VMA( 1 ) );		return 0;	case CG_UPDATESCREEN:		// this is used during lengthy level loading, so pump message loop//		Com_EventLoop();	// FIXME: if a server restarts here, BAD THINGS HAPPEN!// We can't call Com_EventLoop here, a restart will crash and this _does_ happen// if there is a map change while we are downloading at pk3.// ZOID		SCR_UpdateScreen();		return 0;	case CG_CM_LOADMAP:		CL_CM_LoadMap( VMA( 1 ) );		return 0;	case CG_CM_NUMINLINEMODELS:		return CM_NumInlineModels();	case CG_CM_INLINEMODEL:		return CM_InlineModel( args[1] );	case CG_CM_TEMPBOXMODEL:		return CM_TempBoxModel( VMA( 1 ), VMA( 2 ), qfalse );	case CG_CM_TEMPCAPSULEMODEL:		return CM_TempBoxModel( VMA( 1 ), VMA( 2 ), qtrue );	case CG_CM_POINTCONTENTS:		return CM_PointContents( VMA( 1 ), args[2] );	case CG_CM_TRANSFORMEDPOINTCONTENTS:		return CM_TransformedPointContents( VMA( 1 ), args[2], VMA( 3 ), VMA( 4 ) );	case CG_CM_BOXTRACE:		CM_BoxTrace( VMA( 1 ), VMA( 2 ), VMA( 3 ), VMA( 4 ), VMA( 5 ), args[6], args[7], /*int capsule*/ qfalse );		return 0;	case CG_CM_TRANSFORMEDBOXTRACE:		CM_TransformedBoxTrace( VMA( 1 ), VMA( 2 ), VMA( 3 ), VMA( 4 ), VMA( 5 ), args[6], args[7], VMA( 8 ), VMA( 9 ), /*int capsule*/ qfalse );		return 0;	case CG_CM_CAPSULETRACE:		CM_BoxTrace( VMA( 1 ), VMA( 2 ), VMA( 3 ), VMA( 4 ), VMA( 5 ), args[6], args[7], /*int capsule*/ qtrue );		return 0;	case CG_CM_TRANSFORMEDCAPSULETRACE:		CM_TransformedBoxTrace( VMA( 1 ), VMA( 2 ), VMA( 3 ), VMA( 4 ), VMA( 5 ), args[6], args[7], VMA( 8 ), VMA( 9 ), /*int capsule*/ qtrue );		return 0;	case CG_CM_MARKFRAGMENTS:		return re.MarkFragments( args[1], VMA( 2 ), VMA( 3 ), args[4], VMA( 5 ), args[6], VMA( 7 ) );	case CG_S_STARTSOUND:		S_StartSound( VMA( 1 ), args[2], args[3], args[4] );		return 0;//----(SA)	added//.........这里部分代码省略.........

/***********************************************************************       _WriteAt*/static int    _WriteAt (void * hFile, void *pBuffer, U32 Pos, U32 NumBytes) {  _InitIfRequired();         // Perform automatic initialisation so that explicit call to FS_Init is not required  FS_FSeek((FS_FILE*) hFile, Pos, FS_SEEK_SET);  return FS_Write((FS_FILE*) hFile, pBuffer, NumBytes);}

static size_t CL_cURL_CallbackWrite(void *buffer, size_t size, size_t nmemb,	void *stream){	FS_Write( buffer, size*nmemb, ((fileHandle_t*)stream)[0] );	return size*nmemb;}

void Cvar_WriteVariables( fileHandle_t f ) {#if 0	cvar_t	*var;	char	buffer[1024];	for (var = cvar_vars ; var ; var = var->next) {		if( Q_stricmp( var->name, "cl_cdkey" ) == 0 ) {			continue;		}		if( var->flags & CVAR_ARCHIVE ) {			// write the latched value, even if it hasn't taken effect yet			if ( var->latchedString ) {				Com_sprintf (buffer, sizeof(buffer), "seta %s /"%s/"/n", var->name, var->latchedString);			} else {				Com_sprintf (buffer, sizeof(buffer), "seta %s /"%s/"/n", var->name, var->string);			}			FS_Printf (f, "%s", buffer);		}	}#else	cvar_t *var;	char buffer[MAX_STRING_CHARS] = {0};	int i=0, writeCount=0, totalCount=0, size=0;	cvarSerialise_t *list = NULL, *listPtr = NULL;	for ( var=cvar_vars; var; var=var->next ) {		char *value = var->latchedString ? var->latchedString : var->string;		if ( var->name && (var->flags & CVAR_ARCHIVE/*) && (Q_stricmp( var->resetString, value )*/ || (var->flags&CVAR_USER_CREATED)) ) {			if ( strlen( var->name ) + strlen( var->latchedString ? var->latchedString : var->string ) + 9 >= sizeof( buffer ) )				continue;			writeCount++;		}		totalCount++;	}	// allocate the working space for sorting	size = sizeof( cvarSerialise_t ) * writeCount;	list = (cvarSerialise_t *)Z_Malloc( size );	memset( list, 0, size );	for ( var=cvar_vars, listPtr=list; var; var=var->next ) {		char *value = var->latchedString ? var->latchedString : var->string;		if ( var->name && (var->flags & CVAR_ARCHIVE/*) && (Q_stricmp( var->resetString, value )*/ || (var->flags&CVAR_USER_CREATED)) ) {			if ( strlen( var->name ) + strlen( value ) + 9 >= sizeof( buffer ) ) {				Com_Printf( S_COLOR_YELLOW "WARNING: value of variable /"%s/" too long to write to file/n", var->name );				continue;			}			listPtr->name = var->name;			listPtr->value = value;			listPtr++;		}	}	qsort( list, writeCount, sizeof( cvarSerialise_t ), cvarSort );	for ( i=0, listPtr=list; i<writeCount; i++, listPtr++ ) {		Com_sprintf( buffer, sizeof( buffer ), "seta %s /"%s/"/n", listPtr->name, listPtr->value );		FS_Write( buffer, (int)strlen( buffer ), f );	}	Com_DPrintf( "Wrote %i/%i cvars to file/n", writeCount, totalCount );	Z_Free( list );	list = listPtr = NULL;#endif}

/***************************************************************************** * FUNCTION *  aud_trim_event_callback_hdlr * DESCRIPTION *  This function is used to handle the callback events from L1Audio. * PARAMETERS * * RETURNS *  void *****************************************************************************/void aud_trim_event_callback_hdlr(ilm_struct *ilm_ptr){    /*----------------------------------------------------------------*/    /* Local Variables                                                */    /*----------------------------------------------------------------*/    kal_uint8*                   buf_p = NULL;    kal_uint32                   buf_len; /* 2 bytes per unit */    kal_uint32                   len;     /* 1 byte per unit */    kal_int32                    fs_result = FS_NO_ERROR;    kal_int32                    med_result = MED_RES_OK;    l4aud_trim_event_ind_struct* ind_p = (l4aud_trim_event_ind_struct*) ilm_ptr->local_para_ptr;    /*----------------------------------------------------------------*/    /* Code Body                                                      */    /*----------------------------------------------------------------*/    /* Validate event */    if ((ind_p->handle != (kal_uint32)g_trim_ctx.mhdl_handle_p) ||        (g_trim_ctx.state != AUD_TRIM_STATE_TRIM))    {        _AUD_TRIM_TRACE(ind_p->handle, g_trim_ctx.mhdl_handle_p, g_trim_ctx.state);        return;    }    _AUD_TRIM_TRACE(ind_p->handle, ind_p->event, -1);    switch (ind_p->event)    {        case MEDIA_DATA_NOTIFICATION:        {            /* Get read buffer from L1Audio */            g_trim_ctx.mhdl_handle_p->GetReadBuffer(g_trim_ctx.mhdl_handle_p, &buf_p, &buf_len);                        if (buf_len > 0)            {                ASSERT(buf_p != NULL);                                /* Write to file system */                fs_result = FS_Write(g_trim_ctx.file_output,                                     buf_p,                                     buf_len,                                     &len);                _AUD_TRIM_TRACE(fs_result, buf_len, len);                if (fs_result == FS_NO_ERROR)                {                    /* Update file offset */                    g_trim_ctx.file_length += len;                                        _AUD_TRIM_TRACE(g_trim_ctx.file_output, g_trim_ctx.file_length, -1);                    /* Sleep MED for a moment such that MMI may have chance to cancel the trimming */                    kal_sleep_task(2);                                        /* Notify L1Audio how many bytes are read. L1audio will fire another MEDIA_DATA_NOTIFICATION                     * event if there is more data to be trimmed.                     */                    g_trim_ctx.mhdl_handle_p->ReadDataDone(g_trim_ctx.mhdl_handle_p, buf_len);                }                else                {                    /* Stop the trimming */                    _aud_trim_stop();                    /* Notify MMI with failure reason */                    switch (fs_result)                    {                        case FS_DISK_FULL:                            med_result = MED_RES_DISC_FULL;                            break;                        case FS_MSDC_WRITE_SECTOR_ERROR:                        case FS_MEDIA_CHANGED:                            med_result = MED_RES_NO_DISC;                            break;                        default:                            med_result = MED_RES_ERROR;                            break;                    }                    _aud_trim_send_result( med_result);                }            }                        break;        }        case MEDIA_END:            /* End of trimming */            _aud_trim_send_result(MED_RES_END_OF_FILE);            break;        default://.........这里部分代码省略.........

/*====================CL_CgameSystemCallsThe cgame module is making a system call====================*/intptr_t CL_CgameSystemCalls( intptr_t *args ) {	switch( args[0] ) {	case CG_PRINT:		Com_Printf( "%s", VMA(1) );		return 0;	case CG_FATAL_ERROR:		Com_Error( ERR_DROP, "%s", VMA(1) );		return 0;	case CG_MILLISECONDS:		return Sys_Milliseconds();	case CG_CVAR_REGISTER:		Cvar_Register( VMA(1), VMA(2), VMA(3), args[4] ); 		return 0;	case CG_CVAR_UPDATE:		Cvar_Update( VMA(1) );		return 0;	case CG_CVAR_SET:		Cvar_Set( VMA(1), VMA(2) );		return 0;	case CG_CVAR_VARIABLESTRINGBUFFER:		Cvar_VariableStringBuffer( VMA(1), VMA(2), args[3] );		return 0;	case CG_ARGC:		return Cmd_Argc();	case CG_ARGV:		Cmd_ArgvBuffer( args[1], VMA(2), args[3] );		return 0;	case CG_ARGVI:		return atoi( Cmd_Argv( args[1] ) );	case CG_ARGS:		Cmd_ArgsBuffer( VMA(1), args[2] );		return 0;	case CG_CMD_EXECUTETEXT:		Cbuf_ExecuteText( args[1], VMA(2) );		return 0;	case CG_FS_FOPENFILE:		return FS_FOpenFileByMode( VMA(1), VMA(2), args[3] );	case CG_FS_READ:		FS_Read( VMA(1), args[2], args[3] );		return 0;	case CG_FS_WRITE:		FS_Write( VMA(1), args[2], args[3] );		return 0;	case CG_FS_FCLOSEFILE:		FS_FCloseFile( args[1] );		return 0;	case CG_SENDCONSOLECOMMAND:		Cbuf_AddText( VMA(1) );		return 0;	case CG_FORWARDCOMMAND:		VM_Call( uivm, UI_CONSOLE_COMMAND, cls.realtime );		return 0;	case CG_ADDCOMMAND:		CL_AddCgameCommand( VMA(1) );		return 0;	case CG_REMOVECOMMAND:		Cmd_RemoveCommand( VMA(1) );		return 0;	case CG_SENDCLIENTCOMMAND:		CL_AddReliableCommand( VMA(1) );		return 0;	case CG_UPDATESCREEN:		// this is used during lengthy level loading, so pump message loop//		Com_EventLoop();	// FIXME: if a server restarts here, BAD THINGS HAPPEN!// We can't call Com_EventLoop here, a restart will crash and this _does_ happen// if there is a map change while we are downloading at pk3.// ZOID		SCR_UpdateScreen();		return 0;	case CG_CM_LOADMAP:		CL_CM_LoadMap( VMA(1) );		return 0;	case CG_CM_NUMINLINEMODELS:		return CM_NumInlineModels();	case CG_CM_INLINEMODEL:		return CM_InlineModel( args[1] );	case CG_CM_TEMPBOXMODEL:		return CM_TempBoxModel( VMA(1), VMA(2), /*int capsule*/ qfalse );	case CG_CM_TEMPCAPSULEMODEL:		return CM_TempBoxModel( VMA(1), VMA(2), /*int capsule*/ qtrue );	case CG_CM_POINTCONTENTS:		return CM_PointContents( VMA(1), args[2] );	case CG_CM_TRANSFORMEDPOINTCONTENTS:		return CM_TransformedPointContents( VMA(1), args[2], VMA(3), VMA(4) );	case CG_CM_BOXTRACE:		CM_BoxTrace( VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], /*int capsule*/ qfalse );		return 0;	case CG_CM_CAPSULETRACE:		CM_BoxTrace( VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], /*int capsule*/ qtrue );		return 0;	case CG_CM_TRANSFORMEDBOXTRACE:		CM_TransformedBoxTrace( VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], VMA(8), VMA(9), /*int capsule*/ qfalse );		return 0;//.........这里部分代码省略.........

/*====================SV_GameSystemCallsThe module is making a system call====================*/intptr_t SV_GameSystemCalls(intptr_t * args) {	switch (args[0]) {		case G_PRINT:			Com_Printf("%s", (char *)VMA(1));			return 0;		case G_ERROR:			Com_Error(ERR_DROP, "%s", (char *)VMA(1));			return 0;		case G_MILLISECONDS:			return Sys_Milliseconds();		case G_CVAR_REGISTER:			Cvar_Register((vmCvar_t*)VMA(1), (char*)VMA(2), (char*)VMA(3), args[4]);			return 0;		case G_CVAR_UPDATE:			Cvar_Update((vmCvar_t*)VMA(1));			return 0;		case G_CVAR_SET:			Cvar_Set((const char *)VMA(1), (const char *)VMA(2));			return 0;		case G_CVAR_VARIABLE_INTEGER_VALUE:			return Cvar_VariableIntegerValue((const char *)VMA(1));		case G_CVAR_VARIABLE_STRING_BUFFER:			Cvar_VariableStringBuffer((char *)VMA(1), (char*)VMA(2), args[3]);			return 0;		case G_CVAR_LATCHEDVARIABLESTRINGBUFFER:			Cvar_LatchedVariableStringBuffer((char *)VMA(1), (char*)VMA(2), args[3]);			return 0;		case G_ARGC:			return Cmd_Argc();		case G_ARGV:			Cmd_ArgvBuffer(args[1], (char*)VMA(2), args[3]);			return 0;		case G_SEND_CONSOLE_COMMAND:			Cbuf_ExecuteText(args[1], (char *)VMA(2));			return 0;		case G_FS_FOPEN_FILE:			return FS_FOpenFileByMode((char *)VMA(1), (fileHandle_t*)VMA(2), (fsMode_t)args[3]);		case G_FS_READ:			FS_Read2(VMA(1), args[2], args[3]);			return 0;		case G_FS_WRITE:			return FS_Write(VMA(1), args[2], args[3]);		case G_FS_RENAME:			FS_Rename((char *)VMA(1), (char *)VMA(2));			return 0;		case G_FS_FCLOSE_FILE:			FS_FCloseFile(args[1]);			return 0;		case G_FS_GETFILELIST:			return FS_GetFileList((char *)VMA(1), (char *)VMA(2), (char*)VMA(3), args[4]);		case G_LOCATE_GAME_DATA:			SV_LocateGameData((sharedEntity_t*)VMA(1), args[2], args[3], (playerState_t*)VMA(4), args[5]);			return 0;		case G_DROP_CLIENT:			SV_GameDropClient(args[1], (char*)VMA(2), args[3]);			return 0;		case G_SEND_SERVER_COMMAND:			SV_GameSendServerCommand(args[1], (char*)VMA(2));			return 0;		case G_LINKENTITY:			SV_LinkEntity((sharedEntity_t*)VMA(1));			return 0;		case G_UNLINKENTITY:			SV_UnlinkEntity((sharedEntity_t*)VMA(1));			return 0;		case G_ENTITIES_IN_BOX:			return SV_AreaEntities((float*)VMA(1), (float*)VMA(2), (int*)VMA(3), args[4]);		case G_ENTITY_CONTACT:			return SV_EntityContact((float*)VMA(1), (float*)VMA(2), (sharedEntity_t*)VMA(3), TT_AABB);		case G_ENTITY_CONTACTCAPSULE:			return SV_EntityContact((float*)VMA(1), (float*)VMA(2), (sharedEntity_t*)VMA(3), TT_CAPSULE);		case G_TRACE:			SV_Trace((trace_t*)VMA(1), (float*)VMA(2), (float*)VMA(3), (float*)VMA(4), (float*)VMA(5), args[6], args[7], TT_AABB);			return 0;		case G_TRACECAPSULE:			SV_Trace((trace_t*)VMA(1), (float*)VMA(2), (float*)VMA(3), (float*)VMA(4), (float*)VMA(5), args[6], args[7], TT_CAPSULE);			return 0;		case G_POINT_CONTENTS:			return SV_PointContents((float*)VMA(1), args[2]);		case G_SET_BRUSH_MODEL:			SV_SetBrushModel((sharedEntity_t*)VMA(1), (char*)VMA(2));			return 0;		case G_IN_PVS:			return SV_inPVS((float*)VMA(1), (float*)VMA(2));		case G_IN_PVS_IGNORE_PORTALS:			return SV_inPVSIgnorePortals((float*)VMA(1), (float*)VMA(2));		case G_SET_CONFIGSTRING:			SV_SetConfigstring(args[1], (char*)VMA(2));			return 0;		case G_GET_CONFIGSTRING:			SV_GetConfigstring(args[1], (char*)VMA(2), args[3]);			return 0;		case G_SET_CONFIGSTRING_RESTRICTIONS://.........这里部分代码省略.........

//.........这里部分代码省略.........				timeBeforeClient = Sys_Milliseconds ();			}			CL_Frame (msec, fractionMsec);			if ( com_speeds->integer ) {				timeAfter = Sys_Milliseconds ();			}		}		//		// report timing information		//		if ( com_speeds->integer ) {			int			all, sv, ev, cl;			all = timeAfter - timeBeforeServer;			sv = timeBeforeEvents - timeBeforeServer;			ev = timeBeforeServer - timeBeforeFirstEvents + timeBeforeClient - timeBeforeEvents;			cl = timeAfter - timeBeforeClient;			sv -= time_game;			cl -= time_frontend + time_backend;			Com_Printf("fr:%i all:%3i sv:%3i ev:%3i cl:%3i gm:%3i tr:%3i pvs:%3i rf:%3i bk:%3i/n", 						com_frameNumber, all, sv, ev, cl, time_game, timeInTrace, timeInPVSCheck, time_frontend, time_backend);			// speedslog			if ( com_speedslog && com_speedslog->integer )			{				if(!speedslog)				{					speedslog = FS_FOpenFileWrite("speeds.log");					FS_Write("data={/n", strlen("data={/n"), speedslog);					bComma=false;					if ( com_speedslog->integer > 1 ) 					{						// force it to not buffer so we get valid						// data even if we are crashing						FS_ForceFlush(logfile);					}				}				if (speedslog)				{					char		msg[MAXPRINTMSG];					if(bComma)					{						FS_Write(",/n", strlen(",/n"), speedslog);						bComma=false;					}					FS_Write("{", strlen("{"), speedslog);					Com_sprintf(msg,sizeof(msg),								"%8.4f,%8.4f,%8.4f,%8.4f,%8.4f,%8.4f,",corg[0],corg[1],corg[2],cangles[0],cangles[1],cangles[2]);					FS_Write(msg, strlen(msg), speedslog);					Com_sprintf(msg,sizeof(msg),						"%i,%3i,%3i,%3i,%3i,%3i,%3i,%3i,%3i,%3i}", 						com_frameNumber, all, sv, ev, cl, time_game, timeInTrace, timeInPVSCheck, time_frontend, time_backend);					FS_Write(msg, strlen(msg), speedslog);					bComma=true;				}			}			timeInTrace = timeInPVSCheck = 0;		}

//.........这里部分代码省略.........					char *dst;					if (workFrame->commandUsed + len + 1 > sizeof( workFrame->commandData)) {						Com_Printf("Overflowed state command data./n");						goto conversionerror;					}					dst = workFrame->commandData + workFrame->commandUsed;					*dst = clientNum;					Com_Memcpy( dst+1, s, len );					workFrame->commandUsed += len + 1;				}				break;			case svc_gamestate:				if (newHandle) {					FS_FCloseFile( newHandle );					newHandle = 0;				}				if (levelCount) {					Com_sprintf( newName, sizeof( newName ), "%s.%d.mme", newBaseName, levelCount );				} else {					Com_sprintf( newName, sizeof( newName ), "%s.mme", newBaseName );				}				fullTime = -1;				clientNum = -1;				oldTime = -1;				Com_Memset( convert, 0, sizeof( *convert ));				convert->frames[0].string.used = 1;				levelCount++;				newHandle = FS_FOpenFileWrite( newName );				if (!newHandle) {					Com_Printf("Failed to open %s for target conversion target./n", newName);					goto conversionerror;					return;				} else {					FS_Write ( demoHeader, strlen( demoHeader ), newHandle );				}				Com_sprintf( newName, sizeof( newName ), "%s.txt", newBaseName );				workFrame = &convert->frames[ convert->frameIndex % DEMOCONVERTFRAMES ];				msgSequence = MSG_ReadLong( &oldMsg );				while( 1 ) {					cmd = MSG_ReadByte( &oldMsg );					if (cmd == svc_EOF)						break;					if ( cmd == svc_configstring) {						int		num;						const char *s;						num = MSG_ReadShort( &oldMsg );						s = MSG_ReadBigString( &oldMsg );						demoFrameAddString( &workFrame->string, num, s );					} else if ( cmd == svc_baseline ) {						int num = MSG_ReadBits( &oldMsg, GENTITYNUM_BITS );						if ( num < 0 || num >= MAX_GENTITIES ) {							Com_Printf( "Baseline number out of range: %i./n", num );							goto conversionerror;						}						MSG_ReadDeltaEntity( &oldMsg, &demoNullEntityState, &convert->entityBaselines[num], num );					} else {						Com_Printf( "Unknown block while converting demo gamestate./n" );						goto conversionerror;					}				}				clientNum = MSG_ReadLong( &oldMsg );				/* Skip the checksum feed */				MSG_ReadLong( &oldMsg );				break;			case svc_snapshot:				nextTime = MSG_ReadLong( &oldMsg );

//.........这里部分代码省略.........            // we'll let the server disconnect us when it gets the bbl8r message            if (clc.downloadFlags & (1 << DL_FLAG_DISCON))            {                CL_AddReliableCommand("wwwdl bbl8r");                cls.bWWWDlDisconnected = qtrue;            }            return;        }        else        {            // server keeps sending that message till we ack it, eat and ignore            //MSG_ReadLong( msg );            MSG_ReadString(msg);            MSG_ReadLong(msg);            MSG_ReadLong(msg);            return;        }    }    if (!block)    {        // block zero is special, contains file size        clc.downloadSize = MSG_ReadLong(msg);        Cvar_SetValue("cl_downloadSize", clc.downloadSize);        if (clc.downloadSize < 0)        {            Com_Error(ERR_DROP, "%s", MSG_ReadString(msg));            return;        }    }    size = MSG_ReadShort(msg);    if (size < 0 || size > sizeof(data))    {        Com_Error(ERR_DROP, "CL_ParseDownload: Invalid size %d for download chunk.", size);        return;    }    MSG_ReadData(msg, data, size);    if (clc.downloadBlock != block)    {        Com_DPrintf("CL_ParseDownload: Expected block %d, got %d/n", clc.downloadBlock, block);        return;    }    // open the file if not opened yet    if (!clc.download)    {        clc.download = FS_SV_FOpenFileWrite(cls.downloadTempName);        if (!clc.download)        {            Com_Printf("Could not create %s/n", cls.downloadTempName);            CL_AddReliableCommand("stopdl");            CL_NextDownload();            return;        }    }    if (size)    {        FS_Write(data, size, clc.download);    }    CL_AddReliableCommand(va("nextdl %d", clc.downloadBlock));    clc.downloadBlock++;    clc.downloadCount += size;    // So UI gets access to it    Cvar_SetValue("cl_downloadCount", clc.downloadCount);    if (!size)     // A zero length block means EOF    {        if (clc.download)        {            FS_FCloseFile(clc.download);            clc.download = 0;            // rename the file            FS_SV_Rename(cls.downloadTempName, cls.downloadName);        }        *cls.downloadTempName = *cls.downloadName = 0;        Cvar_Set("cl_downloadName", "");        // send intentions now        // We need this because without it, we would hold the last nextdl and then start        // loading right away.  If we take a while to load, the server is happily trying        // to send us that last block over and over.        // Write it twice to help make sure we acknowledge the download        CL_WritePacket();        CL_WritePacket();        // get another file if needed        CL_NextDownload();    }}

static kal_int32 xml_generate_flash_text(kal_int8 hd, kal_char *text, kal_uint32 textlen){    kal_uint32 length, len;    kal_int32 ret;    FS_HANDLE fhandle = -1;    xml_generator_struct *p = NULL;/* first to get xml text length */    if(textlen == 0)/* text is in file */    {        fhandle = FS_Open((WCHAR*)text, FS_READ_ONLY);        if (fhandle < 0)        {            return XG_E_FAIL;        }        ret = FS_GetFileSize(fhandle, &length);	if (ret == FS_FILE_NOT_FOUND)	{	    return XG_E_FILE_NOT_FOUND;	}        if (ret < 0)        {            FS_Close(fhandle);            return XG_E_FAIL;        }           }    else /* text is in buffer */    {        length = textlen;    }    p = &(xg_array[hd]);        /* then write xml text to dest */    if(p->buf != NULL)     /* write xml text to buffer */        {        /* verify if over-buffer */        if(p->curlen+length > p->buflen)        {            if(fhandle != -1)            {                FS_Close(fhandle);            }            ASSERT(0);            kal_printf("buffer to save will be overflow!!!!/r/n");            return XG_E_OVER_BUFFER;                    }        if (textlen != 0) /* text is in buffer, write xml text from buffer to buffer */        {            memcpy(p->buf+p->curlen, text, textlen);            len = textlen;            ret = 0;        }        else /* text is in file, write xml text from file to buffer */        {            ret = xml_generate_write_filetobuf(p->buf+p->curlen, fhandle, &len);            FS_Close(fhandle);        }    }    else /* write xml text to file */    {                if (textlen != 0) /* text is in buffer, write xml text from buffer to file */        {                          ret = FS_Write(p->file, text, textlen, &len);              if(ret == FS_DISK_FULL)        {        	return XG_E_LACK_DISK;        }                               }        else    /* text is in file, write xml text from file to file */        {            ret = xml_generate_write_filetofile(p->file, fhandle, &len);            FS_Close(fhandle);             }    }    if (ret < 0)    {        return ret;    }      else    {                p->curlen += len;        return len;     }      }

/*====================CL_CgameSystemCallsThe cgame module is making a system call====================*/intptr_t CL_CgameSystemCalls( intptr_t *args ){	switch ( args[ 0 ] )	{		case CG_PRINT:			Com_Printf( "%s", ( char * ) VMA( 1 ) );			return 0;		case CG_ERROR:			Com_Error( ERR_DROP, "%s", ( char * ) VMA( 1 ) );		case CG_MILLISECONDS:			return Sys_Milliseconds();		case CG_CVAR_REGISTER:			Cvar_Register( VMA( 1 ), VMA( 2 ), VMA( 3 ), args[ 4 ] );			return 0;		case CG_CVAR_UPDATE:			Cvar_Update( VMA( 1 ) );			return 0;		case CG_CVAR_SET:			Cvar_Set( VMA( 1 ), VMA( 2 ) );			return 0;		case CG_CVAR_VARIABLESTRINGBUFFER:			VM_CheckBlock( args[2], args[3], "CVARVSB" );			Cvar_VariableStringBuffer( VMA( 1 ), VMA( 2 ), args[ 3 ] );			return 0;		case CG_CVAR_LATCHEDVARIABLESTRINGBUFFER:			VM_CheckBlock( args[2], args[3], "CVARLVSB" );			Cvar_LatchedVariableStringBuffer( VMA( 1 ), VMA( 2 ), args[ 3 ] );			return 0;		case CG_CVAR_VARIABLEINTEGERVALUE:			return Cvar_VariableIntegerValue( VMA( 1 ) );		case CG_ARGC:			return Cmd_Argc();		case CG_ARGV:			VM_CheckBlock( args[2], args[3], "ARGV" );			Cmd_ArgvBuffer( args[ 1 ], VMA( 2 ), args[ 3 ] );			return 0;		case CG_ARGS:			VM_CheckBlock( args[1], args[2], "ARGS" );			Cmd_ArgsBuffer( VMA( 1 ), args[ 2 ] );			return 0;		case CG_LITERAL_ARGS:			// FIXME			VM_CheckBlock( args[1], args[2], "LARGS" );			Cmd_LiteralArgsBuffer( VMA( 1 ), args[ 2 ] );//                      Cmd_ArgsBuffer(VMA(1), args[2]);			return 0;		case CG_GETDEMOSTATE:			return CL_DemoState();		case CG_GETDEMOPOS:			return CL_DemoPos();		case CG_FS_FOPENFILE:			return FS_FOpenFileByMode( VMA( 1 ), VMA( 2 ), args[ 3 ] );		case CG_FS_READ:			VM_CheckBlock( args[1], args[2], "FSREAD" );			FS_Read2( VMA( 1 ), args[ 2 ], args[ 3 ] );			return 0;		case CG_FS_WRITE:			VM_CheckBlock( args[1], args[2], "FSWRITE" );			return FS_Write( VMA( 1 ), args[ 2 ], args[ 3 ] );		case CG_FS_FCLOSEFILE:			FS_FCloseFile( args[ 1 ] );			return 0;		case CG_FS_GETFILELIST:			VM_CheckBlock( args[3], args[4], "FSGFL" );			return FS_GetFileList( VMA( 1 ), VMA( 2 ), VMA( 3 ), args[ 4 ] );		case CG_FS_DELETEFILE:			return FS_Delete( VMA( 1 ) );		case CG_SENDCONSOLECOMMAND:			Cbuf_AddText( VMA( 1 ) );			return 0;		case CG_ADDCOMMAND://.........这里部分代码省略.........

void ME_ExportToScript( const char* scriptname ){	char			scriptfile[256];	char			outstring[1024];	const char		*info, *mapname;	fileHandle_t	f;	static char		buf[MAX_MENUDEFFILE];	int				i, j;	IGME_vehicle_t* veh;	if( !scriptname )	{		CG_Printf("Invalid scriptname!/n");		return;	}	// set up mission filename	info = CG_ConfigString( CS_SERVERINFO );	mapname = Info_ValueForKey( info, "mapname" );	Com_sprintf(scriptfile, 255, "missions/%s/%s.mis", mapname, scriptname);	if( FS_FOpenFileByMode(scriptfile, &f, FS_WRITE) < 0 ) {		CG_Printf("Unable to write to file %s. Exporting to script cancelled.", scriptfile);		return;	}		CG_Printf("Saving to script: %s/n", scriptfile);	// first line comment	Com_sprintf( outstring, sizeof(outstring), "//Missionscript for map %s/n/n",mapname );	FS_Write( outstring, strlen(outstring), f );	// header	Com_sprintf( outstring, sizeof(outstring), "Overview/n{/n/tmap/t%s/n", mapname );	FS_Write( outstring, strlen(outstring), f );	Com_sprintf( outstring, sizeof(outstring), "/tgameset/t%d/n", cgs.gameset );	FS_Write( outstring, strlen(outstring), f );	Com_sprintf( outstring, sizeof(outstring), "/tgametype/t%d/n", cgs.gametype );	FS_Write( outstring, strlen(outstring), f );	Com_sprintf( outstring, sizeof(outstring), "/tmission/t%s/n", scriptname );	FS_Write( outstring, strlen(outstring), f );	Com_sprintf( outstring, sizeof(outstring), "/tgoal/tSearchAndDestroy/n}/n/n" );	FS_Write( outstring, strlen(outstring), f );	// entities and groundinstallations	Com_sprintf( outstring, sizeof(outstring), "Entities/n{/n", mapname );	FS_Write( outstring, strlen(outstring), f );	for( i = 0; i < IGME_MAX_VEHICLES; ++i ) {		veh = &cgs.IGME.vehicles[i]; 		if( !veh->active ) continue;		if( veh->groundInstallation	)		{			Com_sprintf( outstring, sizeof(outstring), "/tGroundInstallation/n/t{/n", mapname );			FS_Write( outstring, strlen(outstring), f );			Com_sprintf( outstring, sizeof(outstring), "/t/tIndex/t%d/n", veh->vehidx );			FS_Write( outstring, strlen(outstring), f );			Com_sprintf( outstring, sizeof(outstring), "/t/tName/tSAM Turret/n" );			FS_Write( outstring, strlen(outstring), f );			Com_sprintf( outstring, sizeof(outstring), "/t/tTeam/t?/n" ); // ADD TEAM HERE!			FS_Write( outstring, strlen(outstring), f );			Com_sprintf( outstring, sizeof(outstring), "/t/tOrigin/t%f;%f;%f/n", veh->origin[0],				veh->origin[1], veh->origin[2]);			FS_Write( outstring, strlen(outstring), f );			Com_sprintf( outstring, sizeof(outstring), "/t/tAngles/t%f;%f;%f/n", veh->angles[0],				veh->angles[1], veh->angles[2]);			FS_Write( outstring, strlen(outstring), f );			Com_sprintf( outstring, sizeof(outstring), "/t}/n/n", mapname );			FS_Write( outstring, strlen(outstring), f );		}		else		{			Com_sprintf( outstring, sizeof(outstring), "/tVehicle/n/t{/n", mapname );			FS_Write( outstring, strlen(outstring), f );			Com_sprintf( outstring, sizeof(outstring), "/t/tIndex/t%d/n", veh->vehidx );			FS_Write( outstring, strlen(outstring), f );			Com_sprintf( outstring, sizeof(outstring), "/t/tName/t%s/n", availableVehicles[veh->vehidx].modelName );			FS_Write( outstring, strlen(outstring), f );			Com_sprintf( outstring, sizeof(outstring), "/t/tTeam/t%d/n", availableVehicles[veh->vehidx].team ); 			FS_Write( outstring, strlen(outstring), f );			Com_sprintf( outstring, sizeof(outstring), "/t/tOrigin/t%f;%f;%f/n", veh->origin[0],				veh->origin[1], veh->origin[2]);			FS_Write( outstring, strlen(outstring), f );			Com_sprintf( outstring, sizeof(outstring), "/t/tAngles/t%f;%f;%f/n", veh->angles[0],				veh->angles[1], veh->angles[2]);			FS_Write( outstring, strlen(outstring), f );//.........这里部分代码省略.........

/*====================CL_UpdateLevelHunkUsage  This updates the "hunkusage.dat" file with the current map and it's hunk usage count  This is used for level loading, so we can show a percentage bar dependant on the amount  of hunk memory allocated so far  This will be slightly inaccurate if some settings like sound quality are changed, but these  things should only account for a small variation (hopefully)====================*/void CL_UpdateLevelHunkUsage( void ) {	int handle;	char *memlistfile = "hunkusage.dat";	char *buf, *outbuf;	char *buftrav, *outbuftrav;	char *token;	char outstr[256];	int len, memusage;	memusage = Cvar_VariableIntegerValue( "com_hunkused" ) + Cvar_VariableIntegerValue( "hunk_soundadjust" );	len = FS_FOpenFileByMode( memlistfile, &handle, FS_READ );	if ( len >= 0 ) { // the file exists, so read it in, strip out the current entry for this map, and save it out, so we can append the new value		buf = (char *)Z_Malloc( len + 1 );		memset( buf, 0, len + 1 );		outbuf = (char *)Z_Malloc( len + 1 );		memset( outbuf, 0, len + 1 );		FS_Read( (void *)buf, len, handle );		FS_FCloseFile( handle );		// now parse the file, filtering out the current map		buftrav = buf;		outbuftrav = outbuf;		outbuftrav[0] = '/0';		while ( ( token = COM_Parse( &buftrav ) ) && token[0] ) {			if ( !Q_strcasecmp( token, cl.mapname ) ) {				// found a match				token = COM_Parse( &buftrav );  // read the size				if ( token && token[0] ) {					if ( atoi( token ) == memusage ) {  // if it is the same, abort this process						Z_Free( buf );						Z_Free( outbuf );						return;					}				}			} else {    // send it to the outbuf				Q_strcat( outbuftrav, len + 1, token );				Q_strcat( outbuftrav, len + 1, " " );				token = COM_Parse( &buftrav );  // read the size				if ( token && token[0] ) {					Q_strcat( outbuftrav, len + 1, token );					Q_strcat( outbuftrav, len + 1, "/n" );				} else {					Com_Error( ERR_DROP, "hunkusage.dat file is corrupt/n" );				}			}		}#ifdef __MACOS__    //DAJ MacOS file typing		{			extern _MSL_IMP_EXP_C long _fcreator, _ftype;			_ftype = 'WlfB';			_fcreator = 'WlfS';		}#endif		handle = FS_FOpenFileWrite( memlistfile );		if ( handle < 0 ) {			Com_Error( ERR_DROP, "cannot create %s/n", memlistfile );		}		// input file is parsed, now output to the new file		len = strlen( outbuf );		if ( FS_Write( (void *)outbuf, len, handle ) != len ) {			Com_Error( ERR_DROP, "cannot write to %s/n", memlistfile );		}		FS_FCloseFile( handle );		Z_Free( buf );		Z_Free( outbuf );	}	// now append the current map to the current file	FS_FOpenFileByMode( memlistfile, &handle, FS_APPEND );	if ( handle < 0 ) {		Com_Error( ERR_DROP, "cannot write to hunkusage.dat, check disk full/n" );	}	Com_sprintf( outstr, sizeof( outstr ), "%s %i/n", cl.mapname, memusage );	FS_Write( outstr, strlen( outstr ), handle );	FS_FCloseFile( handle );	// now just open it and close it, so it gets copied to the pak dir	len = FS_FOpenFileByMode( memlistfile, &handle, FS_READ );	if ( len >= 0 ) {		FS_FCloseFile( handle );	}}

void CL_Record(const char *name){	int           i;	msg_t         buf;	byte          bufData[MAX_MSGLEN];	entityState_t *ent;	entityState_t nullstate;	char          *s;	int           len;	// open the demo file	Com_FuncPrinf("Recording to %s./n", name);	clc.demofile = FS_FOpenFileWrite(name);	if (!clc.demofile)	{		Com_FuncPrinf("ERROR: couldn't open./n");		return;	}	clc.demorecording = qtrue;	Cvar_Set("cl_demorecording", "1");    // fretn	Q_strncpyz(clc.demoName, demoName, sizeof(clc.demoName));	Cvar_Set("cl_demofilename", clc.demoName);    // bani	Cvar_Set("cl_demooffset", "0");    // bani	// don't start saving messages until a non-delta compressed message is received	clc.demowaiting = qtrue;	// write out the gamestate message	MSG_Init(&buf, bufData, sizeof(bufData));	MSG_Bitstream(&buf);	// NOTE: all server->client messages now acknowledge	MSG_WriteLong(&buf, clc.reliableSequence);	MSG_WriteByte(&buf, svc_gamestate);	MSG_WriteLong(&buf, clc.serverCommandSequence);	// configstrings	for (i = 0; i < MAX_CONFIGSTRINGS; i++)	{		if (!cl.gameState.stringOffsets[i])		{			continue;		}		s = cl.gameState.stringData + cl.gameState.stringOffsets[i];		MSG_WriteByte(&buf, svc_configstring);		MSG_WriteShort(&buf, i);		MSG_WriteBigString(&buf, s);	}	// baselines	memset(&nullstate, 0, sizeof(nullstate));	for (i = 0; i < MAX_GENTITIES; i++)	{		ent = &cl.entityBaselines[i];		if (!ent->number)		{			continue;		}		MSG_WriteByte(&buf, svc_baseline);		MSG_WriteDeltaEntity(&buf, &nullstate, ent, qtrue);	}	MSG_WriteByte(&buf, svc_EOF);	// finished writing the gamestate stuff	// write the client num	MSG_WriteLong(&buf, clc.clientNum);	// write the checksum feed	MSG_WriteLong(&buf, clc.checksumFeed);	// finished writing the client packet	MSG_WriteByte(&buf, svc_EOF);	// write it to the demo file	len = LittleLong(clc.serverMessageSequence - 1);	FS_Write(&len, 4, clc.demofile);	len = LittleLong(buf.cursize);	FS_Write(&len, 4, clc.demofile);	FS_Write(buf.data, buf.cursize, clc.demofile);	// the rest of the demo file will be copied from net messages}

/*=====================CL_ParseDownloadA download message has been received from the server=====================*/void CL_ParseDownload ( msg_t *msg ) {	int		size;	unsigned char data[MAX_MSGLEN];	uint16_t block;	if (!*clc.downloadTempName) {		Com_Printf("Server sending download, but no download was requested/n");		CL_AddReliableCommand("stopdl", qfalse);		return;	}	// read the data	block = MSG_ReadShort ( msg );	if(!block && !clc.downloadBlock)	{		// block zero is special, contains file size		clc.downloadSize = MSG_ReadLong ( msg );		Cvar_SetValue( "cl_downloadSize", clc.downloadSize );		if (clc.downloadSize < 0)		{			Com_Error( ERR_DROP, "%s", MSG_ReadString( msg ) );			return;		}	}	size = MSG_ReadShort ( msg );	if (size < 0 || size > sizeof(data))	{		Com_Error(ERR_DROP, "CL_ParseDownload: Invalid size %d for download chunk", size);		return;	}		MSG_ReadData(msg, data, size);	if((clc.downloadBlock & 0xFFFF) != block)	{		Com_DPrintf( "CL_ParseDownload: Expected block %d, got %d/n", (clc.downloadBlock & 0xFFFF), block);		return;	}	// open the file if not opened yet	if (!clc.download)	{		clc.download = FS_SV_FOpenFileWrite( clc.downloadTempName );		if (!clc.download) {			Com_Printf( "Could not create %s/n", clc.downloadTempName );			CL_AddReliableCommand("stopdl", qfalse);			CL_NextDownload();			return;		}	}	if (size)		FS_Write( data, size, clc.download );	CL_AddReliableCommand(va("nextdl %d", clc.downloadBlock), qfalse);	clc.downloadBlock++;	clc.downloadCount += size;	// So UI gets access to it	Cvar_SetValue( "cl_downloadCount", clc.downloadCount );	if (!size) { // A zero length block means EOF		if (clc.download) {			FS_FCloseFile( clc.download );			clc.download = 0;			// rename the file			FS_SV_Rename ( clc.downloadTempName, clc.downloadName, qfalse );		}		// send intentions now		// We need this because without it, we would hold the last nextdl and then start		// loading right away.  If we take a while to load, the server is happily trying		// to send us that last block over and over.		// Write it twice to help make sure we acknowledge the download		CL_WritePacket();		CL_WritePacket();		// get another file if needed		CL_NextDownload ();	}}

static void logfile_write(print_type_t type, const char *s){    char text[MAXPRINTMSG];    char buf[MAX_QPATH];    char *p, *maxp;    size_t len;    ssize_t ret;    int c;    if (logfile_prefix->string[0]) {        p = strchr(logfile_prefix->string, '@');        if (p) {            // expand it in place, hacky            switch (type) {            case PRINT_TALK:      *p = 'T'; break;            case PRINT_DEVELOPER: *p = 'D'; break;            case PRINT_WARNING:   *p = 'W'; break;            case PRINT_ERROR:     *p = 'E'; break;            case PRINT_NOTICE:    *p = 'N'; break;            default:              *p = 'A'; break;            }        }        len = format_local_time(buf, sizeof(buf), logfile_prefix->string);        if (p) {            *p = '@';        }    } else {        len = 0;    }    p = text;    maxp = text + sizeof(text) - 1;    while (*s) {        if (com_logNewline) {            if (len > 0 && p + len < maxp) {                memcpy(p, buf, len);                p += len;            }            com_logNewline = qfalse;        }        if (p == maxp) {            break;        }        c = *s++;        if (c == '/n') {            com_logNewline = qtrue;        } else {            c = Q_charascii(c);        }        *p++ = c;    }    *p = 0;    len = p - text;    ret = FS_Write(text, len, com_logFile);    if (ret != len) {        // zero handle BEFORE doing anything else to avoid recursion        qhandle_t tmp = com_logFile;        com_logFile = 0;        FS_FCloseFile(tmp);        Com_EPrintf("Couldn't write console log: %s/n", Q_ErrorString(ret));        Cvar_Set("logfile", "0");    }}

//.........这里部分代码省略.........				ti.target_bitrate = -1;				ti.keyframe_data_target_bitrate = (unsigned int)-1;				ti.quality = bound(0, ti.quality, 63);			}		}		else		{			if(ti.quality < 0)			{				ti.target_bitrate = bound(45000, ti.target_bitrate, 2000000);				ti.keyframe_data_target_bitrate = (int) (ti.target_bitrate * max(1, cl_capturevideo_ogg_theora_keyframe_bitrate_multiplier.value));				ti.quality = -1;			}			else			{				ti.target_bitrate = bound(45000, ti.target_bitrate, 2000000);				ti.keyframe_data_target_bitrate = (int) (ti.target_bitrate * max(1, cl_capturevideo_ogg_theora_keyframe_bitrate_multiplier.value));				ti.quality = -1;			}		}		// this -1 magic is because ti.keyframe_frequency and ti.keyframe_mindistance use different metrics		ti.keyframe_frequency = bound(1, cl_capturevideo_ogg_theora_keyframe_maxinterval.integer, 1000);		ti.keyframe_mindistance = bound(1, cl_capturevideo_ogg_theora_keyframe_mininterval.integer, (int) ti.keyframe_frequency) - 1;		ti.noise_sensitivity = bound(0, cl_capturevideo_ogg_theora_noise_sensitivity.integer, 6);		ti.sharpness = bound(0, cl_capturevideo_ogg_theora_sharpness.integer, 2);		ti.keyframe_auto_threshold = bound(0, cl_capturevideo_ogg_theora_keyframe_auto_threshold.integer, 100);		ti.keyframe_frequency_force = ti.keyframe_frequency;		ti.keyframe_auto_p = (ti.keyframe_frequency != ti.keyframe_mindistance + 1);		qtheora_encode_init(&format->ts, &ti);		qtheora_info_clear(&ti);		// vorbis?		if(cls.capturevideo.soundrate)		{			qvorbis_info_init(&format->vi);			qvorbis_encode_init_vbr(&format->vi, cls.capturevideo.soundchannels, cls.capturevideo.soundrate, bound(-1, cl_capturevideo_ogg_vorbis_quality.value, 10) * 0.099);			qvorbis_comment_init(&vc);			qvorbis_analysis_init(&format->vd, &format->vi);			qvorbis_block_init(&format->vd, &format->vb);		}		qtheora_comment_init(&tc);		/* create the remaining theora headers */		qtheora_encode_header(&format->ts, &pt);		qogg_stream_packetin(&format->to, &pt);		if (qogg_stream_pageout (&format->to, &pg) != 1)			fprintf (stderr, "Internal Ogg library error./n");		FS_Write(cls.capturevideo.videofile, pg.header, pg.header_len);		FS_Write(cls.capturevideo.videofile, pg.body, pg.body_len);		qtheora_encode_comment(&tc, &pt);		qogg_stream_packetin(&format->to, &pt);		qtheora_encode_tables(&format->ts, &pt);		qogg_stream_packetin (&format->to, &pt);		qtheora_comment_clear(&tc);		if(cls.capturevideo.soundrate)		{			qvorbis_analysis_headerout(&format->vd, &vc, &pt, &pt2, &pt3);			qogg_stream_packetin(&format->vo, &pt);			if (qogg_stream_pageout (&format->vo, &pg) != 1)				fprintf (stderr, "Internal Ogg library error./n");			FS_Write(cls.capturevideo.videofile, pg.header, pg.header_len);			FS_Write(cls.capturevideo.videofile, pg.body, pg.body_len);			qogg_stream_packetin(&format->vo, &pt2);			qogg_stream_packetin(&format->vo, &pt3);			qvorbis_comment_clear(&vc);		}		for(;;)		{			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)		for(;;)		{			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);		}	}}

/*====================CL_UISystemCallsThe ui module is making a system call====================*/int CL_UISystemCalls( int *args ) {	switch( args[0] ) {	case UI_ERROR:		Com_Error( ERR_DROP, "%s", VMA(1) );		return 0;	case UI_PRINT:		Com_Printf( "%s", VMA(1) );		return 0;	case UI_MILLISECONDS:		return Sys_Milliseconds();	case UI_CVAR_REGISTER:		Cvar_Register( VMA(1), VMA(2), VMA(3), args[4] ); 		return 0;	case UI_CVAR_UPDATE:		Cvar_Update( VMA(1) );		return 0;	case UI_CVAR_SET:		Cvar_Set( VMA(1), VMA(2) );		return 0;	case UI_CVAR_VARIABLEVALUE:		return FloatAsInt( Cvar_VariableValue( VMA(1) ) );	case UI_CVAR_VARIABLESTRINGBUFFER:		Cvar_VariableStringBuffer( VMA(1), VMA(2), args[3] );		return 0;	case UI_CVAR_SETVALUE:		Cvar_SetValue( VMA(1), VMF(2) );		return 0;	case UI_CVAR_RESET:		Cvar_Reset( VMA(1) );		return 0;	case UI_CVAR_CREATE:		Cvar_Get( VMA(1), VMA(2), args[3] );		return 0;	case UI_CVAR_INFOSTRINGBUFFER:		Cvar_InfoStringBuffer( args[1], VMA(2), args[3] );		return 0;	case UI_ARGC:		return Cmd_Argc();	case UI_ARGV:		Cmd_ArgvBuffer( args[1], VMA(2), args[3] );		return 0;	case UI_CMD_EXECUTETEXT:		Cbuf_ExecuteText( args[1], VMA(2) );		return 0;	case UI_FS_FOPENFILE:		return FS_FOpenFileByMode( VMA(1), VMA(2), args[3] );	case UI_FS_READ:		FS_Read2( VMA(1), args[2], args[3] );		return 0;	case UI_FS_WRITE:		FS_Write( VMA(1), args[2], args[3] );		return 0;	case UI_FS_FCLOSEFILE:		FS_FCloseFile( args[1] );		return 0;	case UI_FS_GETFILELIST:		return FS_GetFileList( VMA(1), VMA(2), VMA(3), args[4] );	case UI_FS_SEEK:		return FS_Seek( args[1], args[2], args[3] );		case UI_R_REGISTERMODEL:		return re.RegisterModel( VMA(1) );	case UI_R_REGISTERSKIN:		return re.RegisterSkin( VMA(1) );	case UI_R_REGISTERSHADERNOMIP:		return re.RegisterShaderNoMip( VMA(1) );	case UI_R_CLEARSCENE:		re.ClearScene();		return 0;//.........这里部分代码省略.........

//.........这里部分代码省略.........		return 0;	case UI_CVAR_RESET:		Cvar_Reset( (const char *)VMA(1) );		return 0;	case UI_CVAR_CREATE:		Cvar_Get( (const char *)VMA(1), (const char *)VMA(2), args[3] );		return 0;	case UI_CVAR_INFOSTRINGBUFFER:		Cvar_InfoStringBuffer( args[1], (char *)VMA(2), args[3] );		return 0;	case UI_ARGC:		return Cmd_Argc();	case UI_ARGV:		Cmd_ArgvBuffer( args[1], (char *)VMA(2), args[3] );		return 0;	case UI_CMD_EXECUTETEXT:		Cbuf_ExecuteText( args[1], (const char *)VMA(2) );		return 0;	case UI_FS_FOPENFILE:		return FS_FOpenFileByMode( (const char *)VMA(1), (int *)VMA(2), (fsMode_t)args[3] );	case UI_FS_READ:		FS_Read( VMA(1), args[2], args[3] );		return 0;	case UI_FS_WRITE:		FS_Write( VMA(1), args[2], args[3] );		return 0;	case UI_FS_FCLOSEFILE:		FS_FCloseFile( args[1] );		return 0;	case UI_FS_GETFILELIST:		return FS_GetFileList( (const char *)VMA(1), (const char *)VMA(2), (char *)VMA(3), args[4] );	case UI_R_REGISTERMODEL:		return re->RegisterModel( (const char *)VMA(1) );	case UI_R_REGISTERSKIN:		return re->RegisterSkin( (const char *)VMA(1) );	case UI_R_REGISTERSHADERNOMIP:		return re->RegisterShaderNoMip( (const char *)VMA(1) );	case UI_R_SHADERNAMEFROMINDEX:		CL_R_ShaderNameFromIndex( (char *)VMA(1), args[2] );		return 0;	case UI_R_CLEARSCENE:		re->ClearScene();		return 0;	case UI_R_ADDREFENTITYTOSCENE:		re->AddRefEntityToScene( (const refEntity_t *)VMA(1) );		return 0;	case UI_R_ADDPOLYTOSCENE:		re->AddPolyToScene( args[1], args[2], (const polyVert_t *)VMA(3), 1 );

static void CLQW_ParseDownload( QMsg& message ) {	// read the data	int size = message.ReadShort();	int percent = message.ReadByte();	if ( clc.demoplaying ) {		if ( size > 0 ) {			message.readcount += size;		}		return;	// not in demo playback	}	if ( size == -1 ) {		common->Printf( "File not found./n" );		if ( clc.download ) {			common->Printf( "cls.download shouldn't have been set/n" );			FS_FCloseFile( clc.download );			clc.download = 0;		}		CLQW_RequestNextDownload();		return;	}	// open the file if not opened yet	if ( !clc.download ) {		if ( String::NCmp( clc.downloadTempName, "skins/", 6 ) ) {			clc.download = FS_FOpenFileWrite( clc.downloadTempName );		} else {			char name[ 1024 ];			sprintf( name, "qw/%s", clc.downloadTempName );			clc.download = FS_SV_FOpenFileWrite( name );		}		if ( !clc.download ) {			message.readcount += size;			common->Printf( "Failed to open %s/n", clc.downloadTempName );			CLQW_RequestNextDownload();			return;		}	}	FS_Write( message._data + message.readcount, size, clc.download );	message.readcount += size;	if ( percent != 100 ) {		// change display routines by zoid		// request next block		clc.downloadPercent = percent;		CL_AddReliableCommand( "nextdl" );	} else {		FS_FCloseFile( clc.download );		// rename the temp file to it's final name		if ( String::Cmp( clc.downloadTempName, clc.downloadName ) ) {			if ( String::NCmp( clc.downloadTempName,"skins/",6 ) ) {				FS_Rename( clc.downloadTempName, clc.downloadName );			} else {				char oldn[ MAX_OSPATH ];				sprintf( oldn, "qw/%s", clc.downloadTempName );				char newn[ MAX_OSPATH ];				sprintf( newn, "qw/%s", clc.downloadName );				FS_SV_Rename( oldn, newn );			}		}		clc.download = 0;		clc.downloadPercent = 0;		// get another file if needed		CLQW_RequestNextDownload();	}}

/*====================CL_UISystemCallsThe ui module is making a system call====================*/intptr_t CL_UISystemCalls( intptr_t *args ) {	switch( args[0] ) {	case UI_ERROR:		Com_Error( ERR_DROP, "%s", (const char*)VMA(1) );		return 0;	case UI_PRINT:		Com_Printf( "%s", (const char*)VMA(1) );		return 0;	case UI_MILLISECONDS:		return Sys_Milliseconds();	case UI_CVAR_REGISTER:		Cvar_Register( VMA(1), VMA(2), VMA(3), args[4] ); 		return 0;	case UI_CVAR_UPDATE:		Cvar_Update( VMA(1) );		return 0;	case UI_CVAR_SET:		Cvar_SetSafe( VMA(1), VMA(2) );		return 0;	case UI_CVAR_VARIABLEVALUE:		return FloatAsInt( Cvar_VariableValue( VMA(1) ) );	case UI_CVAR_VARIABLESTRINGBUFFER:		Cvar_VariableStringBuffer( VMA(1), VMA(2), args[3] );		return 0;	case UI_CVAR_SETVALUE:		Cvar_SetValueSafe( VMA(1), VMF(2) );		return 0;	case UI_CVAR_RESET:		Cvar_Reset( VMA(1) );		return 0;	case UI_CVAR_CREATE:		Cvar_Get( VMA(1), VMA(2), args[3] );		return 0;	case UI_CVAR_INFOSTRINGBUFFER:		Cvar_InfoStringBuffer( args[1], VMA(2), args[3] );		return 0;	case UI_ARGC:		return Cmd_Argc();	case UI_ARGV:		Cmd_ArgvBuffer( args[1], VMA(2), args[3] );		return 0;	case UI_CMD_EXECUTETEXT:		if(args[1] == EXEC_NOW		&& (!strncmp(VMA(2), "snd_restart", 11)		|| !strncmp(VMA(2), "vid_restart", 11)		|| !strncmp(VMA(2), "quit", 5)))		{			Com_Printf (S_COLOR_YELLOW "turning EXEC_NOW '%.11s' into EXEC_INSERT/n", (const char*)VMA(2));			args[1] = EXEC_INSERT;		}		Cbuf_ExecuteText( args[1], VMA(2) );		return 0;	case UI_FS_FOPENFILE:		return FS_FOpenFileByMode( VMA(1), VMA(2), args[3] );	case UI_FS_READ:		FS_Read2( VMA(1), args[2], args[3] );		return 0;	case UI_FS_WRITE:		FS_Write( VMA(1), args[2], args[3] );		return 0;	case UI_FS_FCLOSEFILE:		FS_FCloseFile( args[1] );		return 0;	case UI_FS_GETFILELIST:		return FS_GetFileList( VMA(1), VMA(2), VMA(3), args[4] );		case UI_R_REGISTERMODEL:		return re.RegisterModel( VMA(1) );	case UI_R_REGISTERSKIN:		return re.RegisterSkin( VMA(1) );	case UI_R_REGISTERSHADERNOMIP:		return re.RegisterShaderNoMip( VMA(1) );//.........这里部分代码省略.........

/*===============SafeFS_Write===============*/static ID_INLINE void SafeFS_Write( const void *buffer, int len, fileHandle_t f ){  if( FS_Write( buffer, len, f ) < len )    Com_Error( ERR_DROP, "Failed to write avi file" );}

kal_bool BT_PcmLoopbackTest(void){   kal_int16 i, count = 0;   kal_uint16 *buf;   kal_uint32 len = 0, acmLen = 0;   kal_int32 magDB = 0;   TD_Handle hdl;   kal_uint16 *rb_base;      AM_BluetoothOn(2);//2:open earphone mode, 1: open cordless mode   AM_FlushQFunction();      kal_prompt_trace(MOD_L1SP, "after set,DP_VOL_OUT_PCM= %d",*DP_VOL_OUT_PCM);      /*initialize*/   rb_base = (kal_uint16 *)get_ctrl_buffer(BTLB_BUF_LEN << 1);   Media_SetBuffer( rb_base, BTLB_BUF_LEN );   TD_Init( &hdl, TARGET_TONE, BLOCK_SIZE);#ifdef BTLB_DEBUG   pcmDebugCnt = 0;   pcmDebugPtr = btlbPcmDebugBuf;#endif   /*start tone_play and record*/      KT_Play(TARGET_TONE, 0, 0); /*play single tone , continuous play*/   Media_Record(MEDIA_FORMAT_PCM_8K, BTLB_Handler, (void *)0);   for (i = 0 ; i < 100 ; i++)/*if delay is large, we should enlarge this waiting*/   {      Media_GetReadBuffer(&buf ,&len);      if ( len==0 )         kal_sleep_task(1);      else{         if ( (len + acmLen) >= BLOCK_SIZE ){/*acumulated length >= BLOCK_SIZE*/            len = BLOCK_SIZE - acmLen;/*recount samples to fit block*/         }         TD_ProcessBlock(&hdl, (kal_int16 *)buf, len);#ifdef BTLB_DEBUG{         int j;         for(j = 0 ; j < len ; j++ )            if( pcmDebugCnt < 80000 )            {               *pcmDebugPtr++ = buf[j];               pcmDebugCnt ++;            }}#endif         Media_ReadDataDone( len );         acmLen += len;         if ( acmLen >= BLOCK_SIZE){            magDB = TD_GetMagnitudeDB( &hdl );            kal_prompt_trace( MOD_L1SP, "magDB = %d", magDB);            if( magDB > BTLB_TONE_MAG_DB_THRESHOLD )              count ++;            TD_Reset( &hdl );            acmLen=0;//reset                     if ( count > 2)               break;         }      }   }#ifdef BTLB_DEBUG{      int file_handle;      kal_prompt_trace(MOD_L1SP, "prepare to dump pcm file");      kal_wsprintf(debugFile, "d://BTLBdebug.pcm");      file_handle = FS_Open(debugFile, FS_CREATE);      if(file_handle > 0)       {          FS_Write( file_handle, (void *)btlbPcmDebugBuf, pcmDebugCnt << 1, NULL );         FS_Close(file_handle);         kal_prompt_trace(MOD_L1SP, "finish dump pcm file BTLBdebug.pcm");      }      else{      	kal_prompt_trace(MOD_L1SP, "unable to dump file");      }      }#endif   KT_StopAndWait();   Media_Stop();   AM_BluetoothOff();//close earphone mode   /*close loopback path, should be removed in the future*/   //*AFE_VAC_CON1 &= ~0x02;      free_ctrl_buffer( rb_base );      if ( count > 2){      return true;   }else      return false;}