void CServerRemoteAccess::SetValue(const char *variable, const char *value)
{
FileHandle_t f;
struct cvar_s *var;
if (!Q_stricmp(variable, "map"))
{
Cbuf_AddText("changelevel ");
Cbuf_AddText((char*)value);
Cbuf_AddText("\n");
Cbuf_Execute();
}
else if (!Q_stricmp(variable, "mapcycle"))
{
f = FS_Open(mapcyclefile.string, "wt");
if (!f)
{
Con_Printf("Couldn't write to read-only file %s, using file _dev_mapcycle.txt instead.\n", mapcyclefile.string);
Cvar_DirectSet(&mapcyclefile, "_temp_mapcycle.txt");
f = FS_Open(mapcyclefile.string, "wt");
}
if (f)
{
FS_Write(value, Q_strlen(value) + 1, 1, f);
FS_Close(f);
}
}
else
{
var = Cvar_FindVar(variable);
if (var)
Cvar_DirectSet(var, value);
}
}
/*
===============
Host_WriteConfig
Writes key bindings and archived cvars to config.cfg
===============
*/
void Host_WriteConfig( void )
{
kbutton_t *mlook, *jlook;
file_t *f;
// if client not loaded, client cvars will lost
if( !clgame.hInstance )
{
MsgDev( D_NOTE, "Client not loaded, skipping config save!\n" );
return;
}
MsgDev( D_NOTE, "Host_WriteConfig()\n" );
f = FS_Open( "config.cfg", "w", true );
if( f )
{
FS_Printf( f, "//=======================================================================\n");
FS_Printf( f, "//\t\t\tCopyright XashXT Group %s ©\n", Q_timestamp( TIME_YEAR_ONLY ));
FS_Printf( f, "//\t\t\tconfig.cfg - archive of cvars\n" );
FS_Printf( f, "//=======================================================================\n" );
Cmd_WriteVariables( f );
FS_Printf( f, "exec keyboard.cfg\n" );
FS_Printf( f, "exec userconfig.cfg\n" );
FS_Close( f );
}
else MsgDev( D_ERROR, "Couldn't write config.cfg.\n" );
if( cls.initialized && ( cls.keybind_changed || !FS_FileExists( "keyboard.cfg", true ) ) )
{
f = FS_Open( "keyboard.cfg", "w", true );
if( f )
{
FS_Printf( f, "//=======================================================================\n");
FS_Printf( f, "//\t\t\tCopyright XashXT Group %s ©\n", Q_timestamp( TIME_YEAR_ONLY ));
FS_Printf( f, "//\t\t\tkeyboard.cfg - archive of keybindings\n" );
FS_Printf( f, "//=======================================================================\n" );
Key_WriteBindings( f );
mlook = (kbutton_t *)clgame.dllFuncs.KB_Find( "in_mlook" );
jlook = (kbutton_t *)clgame.dllFuncs.KB_Find( "in_jlook" );
if( mlook && ( mlook->state & 1 ))
FS_Printf( f, "+mlook\n" );
if( jlook && ( jlook->state & 1 ))
FS_Printf( f, "+jlook\n" );
FS_Close( f );
}
else MsgDev( D_ERROR, "Couldn't write keyboard.cfg.\n" );
}
else
MsgDev( D_NOTE, "Keyboard configuration not changed\n" );
}
/*****************************************************************************
* FUNCTION
* vid_create_dummy_video_file
* DESCRIPTION
*
* PARAMETERS
* void
* RETURNS
* void
*****************************************************************************/
void vid_create_dummy_video_file(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
FS_HANDLE fd = -1;
kal_uint32 len;
kal_int32 result;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
#ifdef __NVRAM_IN_USB_MS__
if (stack_query_boot_mode() == USBMS_BOOT)
{
return;
}
#endif /* __NVRAM_IN_USB_MS__ */
/* creat folder */
fd = FS_Open((kal_uint16*)VID_SYSTEM_FOLDER, FS_OPEN_DIR | FS_READ_ONLY);
if (fd >= 0)
{
/* path already exist */
FS_Close(fd);
}
else
{
/* file not exist */
fd = FS_CreateDir((kal_uint16*)VID_SYSTEM_FOLDER);
}
if ((fd = FS_Open((kal_wchar*) VID_DUMMY_INIT_FILE, FS_READ_ONLY)) >= 0)
{
FS_Close(fd);
return;
}
else if ((fd = FS_Open((kal_wchar*) VID_INIT_FILE, FS_READ_ONLY)) >= 0)
{
FS_Close(fd);
/* FS_Rename((kal_wchar*)VID_INIT_FILE, (kal_wchar*)VID_DUMMY_INIT_FILE); */
return;
}
fd = FS_Open((kal_wchar*) VID_DUMMY_INIT_FILE, FS_CREATE | FS_READ_WRITE);
if (fd >= 0)
{
result = FS_Write(fd, DUMMY_VIDEO_FILE_CONTENT, kal_wstrlen(DUMMY_VIDEO_FILE_CONTENT) * ENCODE_BYTE, &len);
FS_Close(fd);
}
}
/*****************************************************************************
* FUNCTION
* applib_get_file_size
* DESCRIPTION
* This function is used to get the size of one file.
* PARAMETERS
* filename [IN] The filename
* RETURNS
* file size.
*****************************************************************************/
kal_uint32 applib_get_file_size(kal_wchar *filename)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_int32 fileHandle;
kal_uint32 fileSize = 0;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
if (filename == NULL)
{
return 0;
}
fileHandle = FS_Open(filename, APPLIB_ASYNC_FILE_READ | FS_NONBLOCK_MODE | FS_OPEN_SHARED);
if (fileHandle < 0)
{
return 0;
}
FS_GetFileSize(fileHandle, &fileSize);
FS_Close(fileHandle);
return fileSize;
}
kal_int32 SDS_ReadNvramFileInRecord_sim(const kal_uint16 *pFilename, kal_uint8* pBuf, kal_uint32 bufLen)
{
kal_int32 status;
kal_uint32 readLen, fileLen;
kal_int32 fd = FS_Open(pFilename, FS_OPEN_NO_DIR | FS_READ_ONLY);
ASSERT(fd >= 0);
status = FS_GetFileSize(fd, &fileLen);
ASSERT(status >= 0);
if(pBuf == NULL && bufLen == 0)
{
return fileLen;
}
if(bufLen < fileLen)
{
return SDS_BUF_TOO_SMALL;
}
status = FS_Read(fd, pBuf, fileLen, &readLen);
ASSERT(status >= 0 && readLen == fileLen);
FS_Close(fd);
return readLen;
}
/*
======================
SV_Map_f
handle a
map <mapname>
command from the console or progs.
======================
*/
void SV_Map_f (void)
{
char expanded[MAX_QPATH];
qfile_t *f;
if (Cmd_Argc() != 2) {
Com_Printf ("map <mapname> : continue game on a new map\n");
return;
}
// check to make sure the level exists
Q_snprintf (expanded, sizeof(expanded), "maps/%s.bsp", Cmd_Argv(1));
f = FS_Open (expanded, "rb", false, true);
if (!f)
return;
FS_Close (f);
if (sv.mvdrecording)
SV_MVDStop_f();
NET_ServerConfig (true);
if (!dedicated)
CL_BeginLocalConnection ();
SV_BroadcastCommand ("changing\n");
SV_SendMessagesToAll ();
SV_SpawnServer (Cmd_Argv(1), !Q_stricmp(Cmd_Argv(0), "devmap"));
SV_BroadcastCommand ("reconnect\n");
}
static GPSAppDataBackupError_t GPSAppDataBackupWriteAttrFile(kal_bool bNewCreate)
{
FS_HANDLE file_handle;
int result;
kal_uint32 len;
//create file
file_handle = FS_Open((kal_uint16*)gGPSAppDataBackupAttrFileName, (bNewCreate == KAL_TRUE ? FS_CREATE : 0) | FS_READ_WRITE);
if (file_handle < FS_NO_ERROR)
{
//fail to create
return GPSAPP_DATABACKUP_ERROR_OPEN_FAIL;
}
//write
result = FS_Write(file_handle, gGPSAppDataBackAttrCache, sizeof(gGPSAppDataBackAttrCache), &len);
FS_Close(file_handle);
if (result != FS_NO_ERROR || len != sizeof(gGPSAppDataBackAttrCache))
{
return GPSAPP_DATABACKUP_ERROR_WRITE_FAIL;
}
else
{
return GPSAPP_DATABACKUP_ERROR_NONE;
}
}
/*
===============
Host_WriteConfig
Writes key bindings and archived cvars to config.cfg
===============
*/
void Host_WriteConfig( void )
{
kbutton_t *mlook, *jlook;
file_t *f;
if( !clgame.hInstance ) return;
MsgDev( D_NOTE, "Host_WriteConfig()\n" );
f = FS_Open( "config.cfg", "w", false );
if( f )
{
FS_Printf( f, "//=======================================================================\n");
FS_Printf( f, "//\t\t\tCopyright XashXT Group %s ©\n", Q_timestamp( TIME_YEAR_ONLY ));
FS_Printf( f, "//\t\t\tconfig.cfg - archive of cvars\n" );
FS_Printf( f, "//=======================================================================\n" );
Key_WriteBindings( f );
Cmd_WriteVariables( f );
mlook = (kbutton_t *)clgame.dllFuncs.KB_Find( "in_mlook" );
jlook = (kbutton_t *)clgame.dllFuncs.KB_Find( "in_jlook" );
if( mlook && ( mlook->state & 1 ))
FS_Printf( f, "+mlook\n" );
if( jlook && ( jlook->state & 1 ))
FS_Printf( f, "+jlook\n" );
FS_Printf( f, "exec userconfig.cfg" );
FS_Close( f );
}
else MsgDev( D_ERROR, "Couldn't write config.cfg.\n" );
}
void Key_EnumCmds_f( void )
{
file_t *f;
FS_AllowDirectPaths( true );
if( FS_FileExists( "../help.txt", false ))
{
Msg( "help.txt already exist\n" );
FS_AllowDirectPaths( false );
return;
}
f = FS_Open( "../help.txt", "w", false );
if( f )
{
FS_Printf( f, "//=======================================================================\n");
FS_Printf( f, "//\t\t\tCopyright XashXT Group %s ©\n", Q_timestamp( TIME_YEAR_ONLY ));
FS_Printf( f, "//\t\thelp.txt - xash commands and console variables\n");
FS_Printf( f, "//=======================================================================\n");
FS_Printf( f, "\n\n\t\t\tconsole variables\n\n");
Cvar_LookupVars( 0, NULL, f, Cmd_WriteHelp );
FS_Printf( f, "\n\n\t\t\tconsole commands\n\n");
Cmd_LookupCmds( NULL, f, Cmd_WriteHelp );
FS_Printf( f, "\n\n");
FS_Close( f );
Msg( "help.txt created\n" );
}
else MsgDev( D_ERROR, "Couldn't write help.txt.\n");
FS_AllowDirectPaths( false );
}
static kal_bool GPSLocateNvramStoreData(void)
{
FS_HANDLE file_handle;
int result;
unsigned int len;
if (app_ucs2_strlen((const kal_int8*)gGPSLocateNvramFullPathFileName) == 0)
{
//empty file name
return KAL_FALSE;
}
//open file
file_handle = FS_Open(gGPSLocateNvramFullPathFileName, FS_READ_WRITE);
if (file_handle < FS_NO_ERROR)
{
//fail to open
return KAL_FALSE;
}
//write
result = FS_Write(file_handle, &(gGPSLocateNvramDataCache.Cache), sizeof(GPSLocateNvramDataStruct_t), &len);
FS_Close(file_handle);
if (result != FS_NO_ERROR || len != sizeof(GPSLocateNvramDataStruct_t))
{
return KAL_FALSE;
}
else
{
return KAL_TRUE;
}
}
PRIVATE INT32 _fsTraceFileOpen(CONST CHAR *name, UINT32 iFlag, UINT32 iMode)
{
INT32 result;
INT32 fd = -1;
UINT32 uni_len = 0;
UINT8* uni_name = NULL;
if((result = ML_LocalLanguage2UnicodeBigEnding(name, DSM_StrLen(name),&uni_name,&uni_len,NULL) )!= ERR_SUCCESS){
if(uni_name){
CSW_Free(uni_name);
uni_name = NULL;
}
CSW_TRACE(BASE_BAL_TS_ID,"fstrace:%s:%u:ML_LocalLanguage2UnicodeBigEnding ret %d",__FUNCTION__, __LINE__,result);
return -1;
}
fd = FS_Open(uni_name,iFlag,iMode);
if(uni_name){
CSW_Free(uni_name);
uni_name = NULL;
}
return fd;
}
void R_CreateDetailTexturesList( const char *filename )
{
file_t *detail_txt = NULL;
const char *detail_name, *texname;
int i;
for( i = 0; i < cl.worldmodel->numtextures; i++ )
{
texname = cl.worldmodel->textures[i]->name;
detail_name = R_DetailTextureForName( texname );
if( !detail_name ) continue;
// detailtexture detected
if( detail_name )
{
if( !detail_txt ) detail_txt = FS_Open( filename, "w", false );
if( !detail_txt )
{
MsgDev( D_ERROR, "Can't write %s\n", filename );
break;
}
// store detailtexture description
FS_Printf( detail_txt, "%s detail/%s 10.0 10.0\n", texname, detail_name );
}
}
if( detail_txt ) FS_Close( detail_txt );
}
static kal_bool GPSLocateNvramLoadData(void)
{
FS_HANDLE file_handle;
int result;
unsigned int len;
GPSLocateNvramDataStruct_t tmpCache;
if (app_ucs2_strlen((const kal_int8*)gGPSLocateNvramFullPathFileName) == 0)
{
//empty file name
return KAL_FALSE;
}
//open file
file_handle = FS_Open(gGPSLocateNvramFullPathFileName, FS_READ_ONLY);
if (file_handle < FS_NO_ERROR)
{
//fail to open
return KAL_FALSE;
}
//read
result = FS_Read(file_handle, &tmpCache, sizeof(GPSLocateNvramDataStruct_t), &len);
FS_Close(file_handle);
if (result != FS_NO_ERROR || len != sizeof(GPSLocateNvramDataStruct_t))
{
//read fail
return KAL_FALSE;
}
//copy data to global cache
memcpy(&(gGPSLocateNvramDataCache.Cache), &tmpCache, sizeof(GPSLocateNvramDataStruct_t));
gGPSLocateNvramDataCache.Valid = KAL_TRUE;
return KAL_TRUE;
}
void vm_log_init(char* filename, int log_level) {
char wfilename[MAX_APP_NAME_LEN];
def_log_level = log_level;
log_init = 0;
strcpy(logModule, MRE_DEFAULT_LOG_MODULE);
_modFile[0] = 0;
_cache_file_ = NULL;
_lineNo = 0;
_logAllModule = TRUE;
mmi_chset_convert(
MMI_CHSET_ASCII,
MMI_CHSET_UCS2,
(VMCHAR *)filename,
(VMCHAR *)wfilename,
MAX_APP_NAME_LEN);
if ((log_file = FS_Open((WCHAR *)wfilename,FS_CREATE_ALWAYS)) < 0)
{
return;
}
log_init = 1;
}
/*****************************************************************************
* FUNCTION
* PmgCheckImyMidFileSize
* DESCRIPTION
*
* PARAMETERS
* path [?]
* RETURNS
*
*****************************************************************************/
PMG_ADDFILE_ERRNO PmgCheckImyMidFileSize(S8 *path)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
S8 *file_ext_p;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
file_ext_p = PmgGetFileExt(path);
if (mmi_ucs2ncmp(file_ext_p, (S8*) L"mid", 3) == 0 || mmi_ucs2ncmp(file_ext_p, (S8*) L"MID", 3) == 0
|| mmi_ucs2ncmp(file_ext_p, (S8*) L"imy", 3) == 0 || mmi_ucs2ncmp(file_ext_p, (S8*) L"IMY", 3) == 0)
{
FS_HANDLE h;
kal_uint32 file_size = 0; /* U32 file_size=0; */
h = FS_Open((U16*) path, FS_READ_ONLY);
if (h)
{
FS_GetFileSize(h, &file_size);
FS_Close(h);
}
else
{
return PMG_ADDFILE_ERR_UNKNOWN;
}
if (file_size > mdi_audio_get_midi_size_limit() )
{
return PMG_ADDFILE_ERR_FILE_TOO_LARGE;
}
}
return PMG_ADDFILE_ERR_SUCCESS;
}
/*****************************************************************************
* FUNCTION
* PmgQueryFileExistBySlot
* DESCRIPTION
*
* PARAMETERS
* slot [IN]
* RETURNS
*
*****************************************************************************/
BOOL PmgQueryFileExistBySlot(U8 slot)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
S8 buf[MAX_EXT_MELODY_FULLNAME_WIDTH];
FS_HANDLE h;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
if (slot > MAXIMUM_EXT_MELODY_NUM)
{
return MMI_FALSE;
}
PmgConstructPathFileName(
buf,
sizeof(buf),
(S8*) gPmgExtMelodyInfo.info[slot].filepath,
(S8*) gPmgExtMelodyInfo.info[slot].filename);
h = FS_Open((WCHAR*)buf, FS_READ_ONLY);
if (h > 0)
{
FS_Close(h);
return MMI_TRUE;
}
else
{
return MMI_FALSE;
}
}
void nandread()
{
if(*((u32*)0x02ffe230) != 0x4b344445 && *((u32*)0x02ffe230) != 0x484e4145)return;
void (*FS_InitCtx)(u8*);
int (*FS_Open)(u8*, char*, u32);
int (*FS_Close)(u8*);
int (*FS_Read)(u8*, u8*, u32);
u8 ctx[0x48];
if(*((u32*)0x02ffe230) == 0x4b344445)
{
FS_InitCtx = (void*)0x20a1c6c;
FS_Open = (void*)0x20a1ea4;
FS_Close = (void*)0x20a1f28;
}
else if(*((u32*)0x02ffe230) == 0x484e4145)//launcher. note that this launcher stuff is for on-the-fly patching stuff, no nand-based only hax.
{
FS_InitCtx = (void*)0x26baf99;
FS_Open = (void*)0x26bb4c5;
FS_Close = (void*)0x26bb511;
FS_Read = (void*)0x26bb581;
}
if(*((u32*)0x02ffe230) == 0x4b344445)
{
nandread_asm();
DC_FlushAll();
REG_IME = 1;
FS_InitCtx(ctx);
if(FS_Open(ctx, "nand:/<tmpjump>", 1)==1)FS_Close(ctx);
REG_IME = 0;
}
else if(*((u32*)0x02ffe230) == 0x484e4145)
{
REG_IME = 1;
FS_InitCtx(ctx);
if(FS_Open(ctx, "nand:/sys/arm7hax.bin", 1)==1)
{
FS_Read(ctx, (void*)0x3780260, 0x40);//this is the beginning of the nand_read_sectors func. since this data won't get written there until after that func returns, another read is triggered below.
FS_Close(ctx);
FS_InitCtx(ctx);
if(FS_Open(ctx, "nand:/<tmpjump>", 1)==1)FS_Close(ctx);//unless the arm7hax code returns,(my local code doesn't) this will hang.
}
REG_IME = 0;
}
}
qboolean HPAK_ResourceForIndex( const char *filename, int index, resource_t *pRes )
{
file_t *f;
hpak_header_t hdr;
hpak_container_t hpakcontainer;
string pakname;
if( !filename || !filename[0] )
return false;
Q_strncpy( pakname, filename, sizeof( pakname ));
FS_StripExtension( pakname );
FS_DefaultExtension( pakname, ".hpk" );
f = FS_Open( pakname, "rb", false );
FS_Read( f, &hdr, sizeof( hdr ));
if( hdr.ident != IDCUSTOMHEADER )
{
MsgDev( D_ERROR, "HPAK_ResourceForIndex: %s it's not a HPK file.\n", pakname );
FS_Close( f );
return false;
}
if( hdr.version != IDCUSTOM_VERSION )
{
MsgDev( D_ERROR, "HPAK_ResourceForIndex: %s has invalid version (%i should be %i).\n", pakname, hdr.version, IDCUSTOM_VERSION );
FS_Close( f );
return false;
}
FS_Seek( f, hdr.seek, SEEK_SET );
FS_Read( f, &hpakcontainer.count, sizeof( hpakcontainer.count ));
if( hpakcontainer.count < 1 || hpakcontainer.count > MAX_FILES_IN_WAD )
{
MsgDev( D_ERROR, "HPAK_ResourceForIndex: %s has too many lumps %u.\n", pakname, hpakcontainer.count );
FS_Close( f );
return false;
}
if( index < 1 || index > hpakcontainer.count )
{
MsgDev( D_ERROR, "HPAK_ResourceForIndex: %s, lump with index %i doesn't exist.\n", pakname, index );
FS_Close( f );
return false;
}
hpakcontainer.dirs = Z_Malloc( sizeof( hpak_dir_t ) * hpakcontainer.count );
// we could just seek the right data...
FS_Read( f, hpakcontainer.dirs, sizeof( hpak_dir_t ) * hpakcontainer.count );
*pRes = hpakcontainer.dirs[index-1].DirectoryResource;
Mem_Free( hpakcontainer.dirs );
FS_Close( f );
return true;
}
/* <2aac9> ../engine/hashpak.c:772 */
qboolean HPAK_ResourceForIndex(char *pakname, int nIndex, struct resource_s *pResource)
{
hash_pack_header_t header;
hash_pack_directory_t directory;
hash_pack_entry_t *entry;
char name[MAX_PATH];
FileHandle_t fp;
if (cmd_source != src_command)
return FALSE;
Q_snprintf(name, ARRAYSIZE(name), "%s", pakname);
#ifdef REHLDS_FIXES
name[ARRAYSIZE(name) - 1] = 0;
#endif // REHLDS_FIXES
COM_DefaultExtension(name, HASHPAK_EXTENSION);
fp = FS_Open(name, "rb");
if (!fp)
{
Con_Printf("ERROR: couldn't open %s.\n", name);
return FALSE;
}
FS_Read(&header, sizeof(hash_pack_header_t), 1, fp);
if (Q_strncmp(header.szFileStamp, "HPAK", sizeof(header.szFileStamp)))
{
Con_Printf("%s is not an HPAK file\n", name);
FS_Close(fp);
return FALSE;
}
if (header.version != HASHPAK_VERSION)
{
Con_Printf("HPAK_List: version mismatch\n");
FS_Close(fp);
return FALSE;
}
FS_Seek(fp, header.nDirectoryOffset, FILESYSTEM_SEEK_HEAD);
FS_Read(&directory.nEntries, 4, 1, fp);
if (directory.nEntries < 1 || (unsigned int)directory.nEntries > MAX_FILE_ENTRIES)
{
Con_Printf("ERROR: HPAK had bogus # of directory entries: %i\n", directory.nEntries);
FS_Close(fp);
return FALSE;
}
if (nIndex < 1 || nIndex > directory.nEntries)
{
Con_Printf("ERROR: HPAK bogus directory entry request: %i\n", nIndex);
FS_Close(fp);
return FALSE;
}
directory.p_rgEntries = (hash_pack_entry_t *)Mem_Malloc(sizeof(hash_pack_entry_t) * directory.nEntries);
FS_Read(directory.p_rgEntries, sizeof(hash_pack_entry_t) * directory.nEntries, 1, fp);
entry = &directory.p_rgEntries[nIndex - 1];
Q_memcpy(pResource, &entry->resource, sizeof(resource_t));
FS_Close(fp);
Mem_Free(directory.p_rgEntries);
return TRUE;
}
void VERIFY_DATA_TO_DSP_START( void )
{
if( fs_handle )
FS_Close( fs_handle );
fs_handle = FS_Open( (const kal_wchar*)fname, FS_CREATE_ALWAYS );
ASSERT( fs_handle > 0 );
uDSPBufferSize = 8192;
uDSPBufferRead = 0;
uDSPBufferWrite = 0;
}
/*****************************************************************************
* FUNCTION
* jma_audio_recorder_timer_expired
* DESCRIPTION
* This function handles if audio recorder timer is expired
* PARAMETERS
* mma_type [IN]
* java_recorder [IN]
* int reocrder(?)
* RETURNS
* void
*****************************************************************************/
void jma_audio_recorder_timer_expired(kal_int32 vm_id)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_uint32 record_size = 0;
kal_int32 ticks = kal_milli_secs_to_ticks(200); /* 200 ms */
FS_HANDLE file_handle;
kal_int32 result;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
kal_trace(TRACE_GROUP_4, FUNC_J2ME_JMA_AUDIO_RECORDER_TIMER_EXPIRED, vm_id, audio_recorder[vm_id].id, audio_recorder[vm_id].state);
JMA_CS_ENTER(vm_id, JMA_VOID);
if (audio_recorder[vm_id].state != JAVA_MEDIA_STATE_RECORDING)
{
JMA_CS_LEAVE(JMA_VOID);
}
EXT_ASSERT(audio_recorder[vm_id].state == JAVA_MEDIA_STATE_RECORDING, 0, 0, 0);
/* Get file size */
file_handle = FS_Open(audio_recorder[vm_id].filename, FS_READ_ONLY | FS_OPEN_SHARED);
if (file_handle <= 0)
{
kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_MARKER_FAIL);
kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_D, file_handle);
JMA_CS_LEAVE(JMA_VOID);
}
result = FS_GetFileSize(file_handle, &record_size);
result = FS_Close(file_handle);
if(1 == result)
{
kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_D, record_size+1);
}
kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_D, record_size);
/* Reach record size limit */
if (record_size >= audio_recorder[vm_id].record_size_limit)
{
/* State will be changed */
jma_mvm_audio_recorder_commit(vm_id, audio_recorder[vm_id].id);
jvm_post_mma_event(MMA_EVENT_RECORD_STOPPED,
audio_recorder[vm_id].id, audio_recorder[vm_id].current_time);
}
else /* re-start timer */
{
kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_STACK_START_TIMER);
stack_start_timer(&java_media_timer, JAVA_MEDIA_TIMER_AUDIO_RECORDER + vm_id, ticks);
}
JMA_CS_LEAVE(JMA_VOID);
}
/*****************************************************************************
* FUNCTION
* applib_async_file_task_start
* DESCRIPTION
*
* PARAMETERS
* op [?]
* mod_id [IN]
* filename [?]
* access_mode [IN]
* es [?]
* callback [IN]
* return_arg [?]
* RETURNS
*
*****************************************************************************/
kal_bool applib_async_file_task_start(
applib_async_file_task_struct *op,
module_type mod_id,
kal_wchar *filename,
applib_async_file_mode_enum access_mode,
event_scheduler *es,
applib_aysnc_file_task_callback_fn callback,
void *return_arg)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
int fileHandle;
int openMode;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
if (op == NULL || filename == NULL)
{
return KAL_FALSE;
}
kal_mem_set(op, 0, sizeof(applib_async_file_task_struct));
switch (access_mode)
{
case APPLIB_ASYNC_FILE_MODE_READ:
openMode = APPLIB_ASYNC_FILE_READ | FS_NONBLOCK_MODE | FS_OPEN_SHARED;
break;
case APPLIB_ASYNC_FILE_MODE_READ_WRITE:
case APPLIB_ASYNC_FILE_MODE_WRITE:
openMode = APPLIB_ASYNC_FILE_WRITE | APPLIB_ASYNC_FILE_CREATE | FS_NONBLOCK_MODE;
break;
default:
openMode = APPLIB_ASYNC_FILE_WRITE | APPLIB_ASYNC_FILE_CREATE | FS_NONBLOCK_MODE;
break;
}
fileHandle = FS_Open(filename, openMode);
if (fileHandle < 0)
{
return KAL_FALSE;
}
op->mod_id = mod_id;
op->isFSopen = KAL_TRUE;
op->fileHandle = fileHandle;
op->es = es;
op->callback = callback;
op->arg_in_callback = return_arg;
return KAL_TRUE;
}
/* <2ae8e> ../engine/hashpak.c:1599 */
NOXREF char *HPAK_GetItem(int item)
{
NOXREFCHECK;
int nCurrent;
hash_pack_header_t header;
hash_pack_directory_t directory;
hash_pack_entry_t *entry;
static char name[MAX_PATH];
char szFileName[MAX_PATH];
FileHandle_t fp;
HPAK_FlushHostQueue();
Q_snprintf(name, ARRAYSIZE(name), "%s", "custom");
COM_DefaultExtension(name, HASHPAK_EXTENSION);
fp = FS_Open(name, "rb");
if (!fp)
return "";
FS_Read(&header, sizeof(hash_pack_header_t), 1, fp);
if (Q_strncmp(header.szFileStamp, "HPAK", sizeof(header.szFileStamp)))
{
Con_Printf("%s is not an HPAK file\n", name);
FS_Close(fp);
return "";
}
if (header.version != HASHPAK_VERSION)
{
Con_Printf("HPAK_List: version mismatch\n");
FS_Close(fp);
return "";
}
FS_Seek(fp, header.nDirectoryOffset, FILESYSTEM_SEEK_HEAD);
FS_Read(&directory.nEntries, 4, 1, fp);
if (directory.nEntries < 1 || (unsigned int)directory.nEntries > MAX_FILE_ENTRIES)
{
Con_Printf("ERROR: HPAK had bogus # of directory entries: %i\n", directory.nEntries);
FS_Close(fp);
return "";
}
directory.p_rgEntries = (hash_pack_entry_t *)Mem_Malloc(sizeof(hash_pack_entry_t) * directory.nEntries);
FS_Read(directory.p_rgEntries, sizeof(hash_pack_entry_t) * directory.nEntries, 1, fp);
nCurrent = directory.nEntries - 1;
if (nCurrent > item)
nCurrent = item;
entry = &directory.p_rgEntries[nCurrent];
COM_FileBase(entry->resource.szFileName, szFileName);
Q_snprintf(name, sizeof(name), "!MD5%s", MD5_Print(entry->resource.rgucMD5_hash));
FS_Close(fp);
Mem_Free(directory.p_rgEntries);
return name;
}
/*****************************************************************************
* FUNCTION
* xml_generate_inline_element
* DESCRIPTION
* This function is for application to generate a whole element without child element
* and attribute, only content. just as following: <a> test </a>.
* PARAMETERS
* hd [IN] handle of generator
* el [IN] element name
* data [IN] Filename or buffer with data.
* datalen [IN] if with buffer, datalen is the length of buffer,
* if with file, datalen should be 0
* RETURNS
* <0: means failed, returns error code;
* 0 : means succeed;
*****************************************************************************/
kal_int32 xml_generate_inline_element(XG_HANDLE hd, const kal_char* el, kal_char* data, kal_uint32 datalen)
{
kal_int32 ret;
kal_uint32 len_read, len;
FS_HANDLE fhandle = -1;
kal_char tempbuf[TEMP_BUF_LEN];
if ((ret = xml_generate_stag(hd, el, NULL, 0)) < 0)
{
return ret;
}
if (datalen == 0)
{
fhandle = FS_Open((WCHAR*)data, FS_READ_ONLY);
if (fhandle < 0)
{
return XG_E_FAIL;
}
ret = FS_GetFileSize(fhandle, &len);
if (ret < 0)
{
FS_Close(fhandle);
return XG_E_FAIL;
}
while ((ret = FS_Read(fhandle, tempbuf, TEMP_BUF_LEN-1, &len_read)) >= FS_NO_ERROR)
{
if (len_read == 0)
{
break;
}
if ((ret=xml_generate_converted_data(hd, tempbuf, len_read)) < 0)
{
return ret;
}
}
FS_Close(fhandle);
}
else
{
if ((ret = xml_generate_converted_data(hd, data, datalen)) < 0)
{
return ret;
}
}
/*
if ((ret = xml_generate_data(hd, data, datalen)) < 0)
{
return ret;
}
*/
return xml_generate_etag(hd, el);
}
void VERIFY_DATA_TO_DSP_RESUME( void )
{
kal_uint32 uFileSize;
kal_int32 ret;
fs_handle = FS_Open( (const kal_wchar*)fname, FS_READ_WRITE|FS_CREATE );
ASSERT( fs_handle > 0 );
if(FS_GetFileSize(fs_handle, &uFileSize) < 0)
ASSERT(0);
if(FS_Seek(fs_handle, uFileSize, FS_FILE_BEGIN) < 0)
ASSERT(0);
uDSPBufferSize = 8192;
}
void SCR_CreateStartupVids( void )
{
file_t *f;
f = FS_Open( "media/StartupVids.txt", "w", false );
if( !f ) return;
// make standard video playlist: sierra, valve
FS_Print( f, "media/sierra.avi\n" );
FS_Print( f, "media/valve.avi\n" );
FS_Close( f );
}
/******************************************************************************
* Function:
* GPSAppDataBackupStore
*
* Usage:
* Store data to backup files.
*
* Parameters:
* pBuff - pointer to caller's data buffer, which contains data to be stored.
* Length - data length (in byte)
*
* Return:
* Error code
******************************************************************************/
GPSAppDataBackupError_t GPSAppDataBackupStore(
const kal_uint8* pBuff,
kal_uint16 Length
)
{
kal_uint16 FileName[GPSAPP_DATABACKUP_FULLPATHNAME_LEN_MAX];
GPSAppDataBackupError_t ErrCode = GPSAPP_DATABACKUP_ERROR_NONE;
FS_HANDLE file_handle;
int result;
kal_uint32 len;
kal_int32 FileID;
if (pBuff == NULL || Length == 0)
{
return GPSAPP_DATABACKUP_ERROR_INVALID_PARAM;
}
//take the semaphore
kal_take_sem(gGPSAppDataBackupSem, KAL_INFINITE_WAIT);
//apply file name
if ((FileID = GPSAppDataBackupApplyCell(FileName, CELLATTR_FREE)) < 0)
{
ErrCode = GPSAPP_DATABACKUP_ERROR_STORAGE_FULL;
goto _RelSem_Return_;
}
//create file
file_handle = FS_Open(FileName, FS_CREATE | FS_READ_WRITE);
if (file_handle < FS_NO_ERROR)
{
//fail to open
ErrCode = GPSAPP_DATABACKUP_ERROR_OPEN_FAIL;
#if _GPSAPP_DATABACKUP_DBG_
trace_printf("GPSAppDataBackupStore: Open fail (%d)", file_handle);
#endif //_GPSAPP_DATABACKUP_DBG_
goto _RelSem_Return_;
}
//write
result = FS_Write(file_handle, (void*)pBuff, Length, &len);
FS_Close(file_handle);
if (result != FS_NO_ERROR || len != Length)
{
ErrCode = GPSAPP_DATABACKUP_ERROR_WRITE_FAIL;
goto _RelSem_Return_;
}
//update attr
GPSAppDataBackupUpdateAttrCache(FileID, ATTRUPDATE_ADD);
ErrCode = GPSAppDataBackupWriteAttrFile(KAL_FALSE);
_RelSem_Return_:
//release semaphore
kal_give_sem(gGPSAppDataBackupSem);
return ErrCode;
}
/*
=====================
CL_WriteErrorMessage
write net_message into buffer.dat for debugging
=====================
*/
void CL_WriteErrorMessage( int current_count, sizebuf_t *msg )
{
file_t *fp;
const char *buffer_file = "buffer.dat";
fp = FS_Open( buffer_file, "wb", false );
if( !fp ) return;
FS_Write( fp, &starting_count, sizeof( int ));
FS_Write( fp, ¤t_count, sizeof( int ));
FS_Write( fp, BF_GetData( msg ), BF_GetMaxBytes( msg ));
FS_Close( fp );
MsgDev( D_INFO, "Wrote erroneous message to %s\n", buffer_file );
}
SFFS_HANDLE SFFS_Open(UString path,SFUint flags)
{
#ifdef WIN32
g_kernal.fpFile=_wfopen(path,(flags&SFFSF_READ)?L"rb":L"wb");
if(!g_kernal.fpFile)
return 0;
return 1;
#else
//暂时关闭存档功能
g_kernal.hFile=FS_Open(path,(flags&SFFSF_READ)?FS_READ_ONLY:(FS_READ_WRITE|FS_CREATE));
if(g_kernal.hFile<0)//???
return 0;
return 1;
#endif
}
static void
handle_buffer_content(msf_sas_handle_t* handle, msf_sas_op_t *op)
{
int file_handle;
int size_remain;
int bytes_written;
int size;
if(!op->data)
{
msf_sas_create_error_dialog (handle, op, MSF_WIDGET_STRING_GET_PREDEFINED(BRA_STR_ID_SAVE_AS_FAIL));
op->state = MSF_SAS_STATE_MESSAGE_WAIT;
return;
}
FS_Delete((WCHAR *)op->file_name);
file_handle = FS_Open((WCHAR *)op->file_name, FS_READ_WRITE | FS_CREATE | FS_OPEN_SHARED);
if (file_handle <= 0)
{
msf_sas_create_error_dialog (handle, op, MSF_WIDGET_STRING_GET_PREDEFINED(BRA_STR_ID_SAVE_AS_FAIL));
op->state = MSF_SAS_STATE_MESSAGE_WAIT;
return;
}
size_remain = op->data_len;
bytes_written = 0;
while (size_remain > 0)
{
if (FS_Write(file_handle, (void *)(op->data), size_remain, (UINT*) & size) != FS_NO_ERROR)
{
msf_sas_create_error_dialog (handle, op, MSF_WIDGET_STRING_GET_PREDEFINED(BRA_STR_ID_SAVE_AS_FAIL));
op->state = MSF_SAS_STATE_MESSAGE_WAIT;
return;
}
if (size <= 0)
{
break;
}
}
op->status = MSF_SAS_RETURN_OK;
op->state = MSF_SAS_STATE_FINISHED;
return;
}
