void loadmodules(int free) { s32 ret; if(free == 1) { if((ret = SifLoadModule("host0:freesio2.irx", 0, NULL)) < 0) { printf("Failed to load freesio2.irx module (%d)\n", ret); SleepThread(); } if((ret = SifLoadModule("host0:freepad.irx", 0, NULL)) < 0) { printf("Failed to load freepad.irx module (%d)\n", ret); SleepThread(); } } else { if((ret = SifLoadModule("rom0:XSIO2MAN", 0, NULL)) < 0) { printf("Failed to load XSIO2MAN module (%d)\n", ret); SleepThread(); } if((ret = SifLoadModule("rom0:XPADMAN", 0, NULL)) < 0) { printf("Failed to load XPADMAN module (%d)\n", ret); SleepThread(); } } }
static void loadModules(void) { int ret; #ifdef ROM_PADMAN ret = SifLoadModule("rom0:SIO2MAN", 0, NULL); #else ret = SifLoadModule("rom0:XSIO2MAN", 0, NULL); #endif if (ret < 0) { SleepThread(); } ret = SifLoadModule("rom0:CDVDMAN", 0, NULL); if(ret < 0) { SleepThread(); } #ifdef ROM_PADMAN ret = SifLoadModule("rom0:PADMAN", 0, NULL); #else ret = SifLoadModule("rom0:XPADMAN", 0, NULL); #endif if (ret < 0) { SleepThread(); } }
int main(void) { int ret; /* Load LibSD (freesd will work too one day, I promise ;) */ ret = SifLoadModule("host:LIBSD.IRX", 0, NULL); if (ret<0) { printf("XXXXX failed to load host:LIBSD.IRX (%d)\n", ret); SleepThread(); } /* Load ps2snd */ ret = SifLoadModule("host:ps2snd.irx", 0, NULL); if (ret<0) { printf("XXXXX failed to load host:ps2snd.irx (%d)\n", ret); SleepThread(); } /* Start LibSD */ if (sceSdInit(0)<0) { printf("Failed to start LibSD\n"); SleepThread(); } /* Setup master volumes for both cores */ sceSdSetParam(0 | SD_PARAM_MVOLL, 0x3fff); sceSdSetParam(0 | SD_PARAM_MVOLR, 0x3fff); sceSdSetParam(1 | SD_PARAM_MVOLL, 0x3fff); sceSdSetParam(1 | SD_PARAM_MVOLR, 0x3fff); /* Open a stream, using voices 0:22 and 0:23 It's stereo and it should be closed when the end is hit. The SPU buffers are at 0x6000 in spu2 ram. The chunksize is 1024 blocks (16kbyte) */ if (sndStreamOpen("host:stream.adpcm", SD_VOICE(0,22) | (SD_VOICE(0,23)<<16), STREAM_STEREO | STREAM_END_CLOSE, 0x6000, 1024)<0) { printf("Failed to open stream\n"); SleepThread(); } sndStreamPlay(); SleepThread(); return(0); }
// 注册线程 void CDlgAutoRegister::Run() { ResetEvent(m_hEventTheadNoRun1); ::CoInitialize(NULL); int nStart = GetSeconds(m_config.m_startTime); int nLast = GetSeconds(m_config.m_endTime); while(1) { int nCurrent = (int)time(NULL); // if (nCurrent > nLast) // { // PostMessage(M_TASK_OVER); // SetEvent(m_hEventTheadNoRun1); // ::CoUninitialize(); // return; // } try { if (nCurrent >= nStart) { int n = m_arrayTasks.size(); for (int i = 0; i < (int)m_arrayTasks.size(); i++) { TaskNode& task = m_arrayTasks[i]; //Sleep(task.nDeltaSeconds S); SleepThread(task.nDeltaSeconds, 1); RegisterID(task); } ::CoUninitialize(); PostMessage(M_TASK_OVER); SetEvent(m_hEventTheadNoRun1); return ; } } catch(...) { IBA_LOG0(_T("出现异常1")); } //Sleep(1 S); SleepThread(1,1); } ::CoUninitialize(); PostMessage(M_TASK_OVER); SetEvent(m_hEventTheadNoRun1); }
void ExecGame(void) { int i; scr_printf(" Installing Engine...\n"); u32 EngineStore = 0x80080000; u32 EngineRead = (void*)Engine; for (i = 0; i < sizeof(Engine); i += 4) { //scr_printf("A"); ee_kmode_enter(); *(u32*)EngineStore = *(u32*)EngineRead; ee_kmode_exit(); EngineStore += 4; EngineRead += 4; } ee_kmode_enter(); *(u32*)0x80081000 = 0x80081010; //Writes the initial storage of the codes ee_kmode_exit(); waitCdReady(); scr_printf(" Loading...\n"); //for (a = 0; a < 40000000; a++) { } if(strlen(bootFileName = parseSystemCnf()) <= 0) { scr_printf(" == Fatal Error ==\n"); SleepThread(); } scr_printf("\n Loaded Game!\n"); u32 HookValue = (0x00080000 / 4) + 0x0C000000; padPortClose(0, 0); //scr_printf(" Shut down PAD, shutting down RPC\n GOODBYE!!!"); SifExitRpc(); ee_kmode_enter(); *(u32*)0x800002FC = HookValue; ee_kmode_exit(); LoadExecPS2((const char *)bootFileName, 0, NULL); SleepThread(); }
// From PS2DEV.ORG - Thread dispatcher static void ioThreadDispatcher ( void* apParam ) { while ( ! gIOTerminate ) { SleepThread (); } /* end while */ ExitDeleteThread(); } /* end dispatcher */
void rmEndFrame(void) { gsKit_set_finish(gsGlobal); rmFlush(); // Wait for draw ops to finish gsKit_finish(); if(!gsGlobal->FirstFrame) { SleepThread(); if(gsGlobal->DoubleBuffering == GS_SETTING_ON) { GS_SET_DISPFB2( gsGlobal->ScreenBuffer[gsGlobal->ActiveBuffer & 1] / 8192, gsGlobal->Width / 64, gsGlobal->PSM, 0, 0 ); gsGlobal->ActiveBuffer ^= 1; gsGlobal->PrimContext ^= 1; } } gsKit_setactive(gsGlobal); }
void sleep_test() { int i = 0; int j = 0; int sleep = 0; while(1) { if (sleep == 1) { printf("WAKING UP\n"); sleep = 0; } if (i % 100000000 == 0) { int id = GetMyId(); printf("sleep_thread tid: %d j = %d\n", id, j); j++; } if (j == 5) { j++; printf("SLEEP FOR 5 SECONDS (tid: %d)\n", GetMyId()); sleep = 1; SleepThread(5); } i++; } }
static void TxThread(void *arg) { int ThreadToWakeUp; while(1) { SleepThread(); if(PacketReqs.count > 0) { while(PacketReqs.count > 0) { WaitSema(NetManIOSemaID); while(SifCallRpc(&NETMAN_rpc_cd, NETMAN_IOP_RPC_FUNC_SEND_PACKETS, 0, &PacketReqs, sizeof(PacketReqs), &ReceiveBuffer, sizeof(ReceiveBuffer.result), &TxEndCallback, NULL) < 0){}; SignalSema(NetManIOSemaID); } } else { if(NetmanTxWaitingThread >= 0) { DI(); ThreadToWakeUp=NetmanTxWaitingThread; NetmanTxWaitingThread=-1; EI(); WakeupThread(ThreadToWakeUp); } } } }
// Wait for a event until the cancel flag becomes true bool WaitEx(EVENT *e, UINT timeout, volatile bool *cancel) { bool dummy_bool = false; UINT64 start, giveup; // Validate arguments if (cancel == NULL) { cancel = &dummy_bool; } start = Tick64(); if (timeout == INFINITE || timeout == 0x7FFFFFFF) { giveup = 0; } else { giveup = start + (UINT64)timeout; } while (true) { UINT64 now = Tick64(); UINT interval_to_giveup = (UINT)(giveup - now); if (giveup == 0) { interval_to_giveup = INFINITE; } else { if (now >= giveup) { // Time-out occurs return false; } } interval_to_giveup = MIN(interval_to_giveup, 25); if (*cancel) { // Cancel flag is set to true. Time-out occurs return false; } if (e != NULL) { if (Wait(e, interval_to_giveup)) { // Event is set return true; } } else { SleepThread(interval_to_giveup); } } }
int NetManRpcNetIFSendPacket(const void *packet, unsigned int length){ struct PacketTag *PacketTag; WaitSema(NetManTxSemaID); NetmanTxWaitingThread=GetThreadId(); WaitSema(TxBankAccessSema); //Check is there is space in the current Tx FIFO. If not, wait for the Tx thread to empty out the other FIFO. */ while(CurrentTxFIFOData->PacketReqs.NumPackets>=NETMAN_RPC_BLOCK_SIZE){ SignalSema(TxBankAccessSema); WakeupThread(TxThreadID); SleepThread(); WaitSema(TxBankAccessSema); } memcpy(&CurrentTxFIFOData->FrameBuffer[CurrentTxFIFOData->PacketReqs.TotalLength], packet, length); PacketTag=&CurrentTxFIFOData->PacketReqs.tags[CurrentTxFIFOData->PacketReqs.NumPackets]; PacketTag->offset=CurrentTxFIFOData->PacketReqs.TotalLength; PacketTag->length=length; CurrentTxFIFOData->PacketReqs.TotalLength+=(length+3)&~3; CurrentTxFIFOData->PacketReqs.NumPackets++; WakeupThread(TxThreadID); SignalSema(TxBankAccessSema); NetmanTxWaitingThread=-1; SignalSema(NetManTxSemaID); return 0; }
void fileXio_Thread(void* param) { int OldState; printf("fileXio: fileXio RPC Server v1.00\nCopyright (c) 2003 adresd\n"); #ifdef DEBUG printf("fileXio: RPC Initialize\n"); #endif SifInitRpc(0); RWBufferSize=DEFAULT_RWSIZE; CpuSuspendIntr(&OldState); rwbuf = AllocSysMemory(ALLOC_FIRST, RWBufferSize, NULL); CpuResumeIntr(OldState); if (rwbuf == NULL) { #ifdef DEBUG printf("Failed to allocate memory for RW buffer!\n"); #endif SleepThread(); } SifSetRpcQueue(&qd, GetThreadId()); SifRegisterRpc(&sd0, FILEXIO_IRX, &fileXio_rpc_server, fileXio_rpc_buffer, NULL, NULL, &qd); SifRpcLoop(&qd); }
// WinMain function int PASCAL WinMain(HINSTANCE hInst, HINSTANCE hPrev, char *CmdLine, int CmdShow) { INSTANCE *instance; is_debug = false; MayaquaMinimalMode(); InitMayaqua(false, is_debug, 0, NULL); InitCedar(); ViSetSkip(); ViLoadStringTables(); InitWinUi(_U(IDS_TITLE+skip), _A(IDS_FONT+skip), ToInt(_A(IDS_FONT_SIZE+skip))); instance = NewSingleInstance(VI_INSTANCE_NAME); if (instance == NULL) { MsgBox(NULL, MB_ICONINFORMATION, _U(IDS_INSTANCE_EXISTS+skip)); } else { ViMain(); FreeSingleInstance(instance); if (sleep_before_exit) { SleepThread(60 * 1000); } } FreeWinUi(); ViFreeStringTables(); FreeCedar(); FreeMayaqua(); return 0; }
void testcase5_g(void) { int i = 0; while (1) { i++; if (i % 10000000 == 0) { printf("%s: id=%d: Current value i = %d\n", __FUNCTION__, GetMyId(), i); if (i == 10000000) { printf("%s: id=%d: Sleeping thread.\n", __FUNCTION__, GetMyId()); SleepThread(2000); } if (i == 90000000) { printf("%s: id=%d: Deleteing thread 0. Return value = %d\n", __FUNCTION__, GetMyId(), DeleteThread(0)); } if (i == 150000000) { CleanUp(); } } } }
///////////////////////////////////////////////////////////////////////[10] int SifCallRpc(struct sifcmd_RPC_CLIENT_DATA *client, unsigned int fno, unsigned int mode, void *send, int ssize, void *receive, int rsize, void (*end_func)(void*), void *end_para){ RPC_PACKET_CALL *packet; if ((packet=(RPC_PACKET_CALL *)rpc_get_packet(&rpc_common))==0) return -1; client->hdr.pkt_addr=(void*)packet; client->func = end_func; client->param = end_para; client->hdr.rpc_id= packet->packet.packet.pid; packet->packet.packet.paddr = packet; packet->packet.client = client; packet->packet.fno = fno; packet->size = ssize; packet->receive= receive; packet->rsize = rsize; packet->server = client->server; if (mode & 1){ packet->rmode=(end_func!=0); client->hdr.tid=-1; if (SifSendCmd(0x8000000A, packet, 0x40, send, client->buff, ssize)) return 0; return -2; }else{ packet->rmode=1; client->hdr.tid=GetThreadId(); if (SifSendCmd(0x8000000A, packet, 0x40, send, client->buff, ssize)==0) return -2; SleepThread(); return 0; } }
///////////////////////////////////////////////////////////////////////[0F] int SifBindRpc(struct sifcmd_RPC_CLIENT_DATA *client, unsigned int number, unsigned int mode) { RPC_PACKET_BIND *packet; client->command=0; client->server=0; packet = (RPC_PACKET_BIND *)rpc_get_packet(&rpc_common); if (packet==NULL) return -1; client->hdr.pkt_addr = packet; client->hdr.rpc_id = packet->packet.pid; packet->packet.paddr = packet; packet->client = client; packet->fno = number; if (mode & 1==0){ client->hdr.tid=GetThreadId(); if (SifSendCmd(0x80000009, packet, 0x40, 0, 0, 0)==0) return -2; SleepThread(); }else{ //async client->hdr.tid=-1; if (SifSendCmd(0x80000009, packet, 0x40, 0, 0, 0)==0) return -2; } return 0; }
///////////////////////////////////////////////////////////////////////[17] int SifGetOtherData(struct sifcmd_RPC_RECEIVE_DATA *rd, void *src, void *dst, int size, int mode){ RPC_PACKET_RDATA *packet; if ((packet=(RPC_PACKET_RDATA *)rpc_get_packet(&rpc_common))==0) return -1; rd->hdr.pkt_addr=packet; rd->hdr.rpc_id =packet->packet.pid; packet->packet.paddr=packet; packet->client=(struct sifcmd_RPC_CLIENT_DATA*)rd; packet->src=src; packet->dst=dst; packet->size=size; if (mode & 1==0){ rd->hdr.tid=GetThreadId(); if (SifSendCmd(0x8000000C, packet, 0x40, 0, 0, 0)==0) return -2; SleepThread(); }else{ //async rd->hdr.tid=-1; if (SifSendCmd(0x8000000C, packet, 0x40, 0, 0, 0)==0) return -2; } return 0; }
int main(void) { char *ini; dma_channel_initialize(DMA_CHANNEL_GIF,NULL,0); dma_channel_fast_waits(DMA_CHANNEL_GIF); fontx_load("rom0:KROM", &krom_u, SINGLE_BYTE, 2, 1, 1); fontx_load("rom0:KROM", &krom_k, DOUBLE_BYTE, 2, 1, 1); if((ini = fontstudio_load_ini("host:impress.ini")) != NULL) { fontstudio_parse_ini(&impress, ini, 512, 256); free(ini); draw_init_env(); init_texture(); run_demo(&packet); fontstudio_unload_ini(&impress); fontx_unload(&krom_u); fontx_unload(&krom_k); } else { printf("Error: cannot load ini file.\n"); } SleepThread(); return 0; }
int main (int argc, char *argv []) { SifInitRpc (0); init_scr (); scr_printf (APP_NAME "-" VERSION "\n"); /* decide whether to load TCP/IP or it is already loaded */ SifExitIopHeap (); SifLoadFileExit (); SifExitRpc (); SifIopReset (NULL /* "rom0:UDNL rom0:EELOADCNF" */, 0); while (SifIopSync ()) ; SifInitRpc (0); if (load_modules () == 0) { scr_printf ("Ready\n"); } else scr_printf ("Failed to load\n"); /* our job is done; IOP would handle the rest */ SleepThread (); return (0); }
// 消费线程 void CDlgAutoRegister::Run2() { ResetEvent(m_hEventTheadNoRun2); ::CoInitialize(NULL); while(1) { //Sleep(1 * 60 S); // 5分钟 SleepThread(5 * 60, 2); try { int nCount = 0; m_cs.Lock(); nCount = (int)m_arrConsumeNode.size(); m_cs.Unlock(); if (nCount > 0) { for (int i = 0; i < nCount; i++) { m_cs.Lock(); ConsumeNode& node = m_arrConsumeNode[i]; m_cs.Unlock(); if(0 == node.bInvalid) { ::CoInitialize(NULL); SendConsumeRecord(node); ::CoUninitialize(); m_cs.Lock(); node.bInvalid = 1; m_cs.Unlock(); } SleepThread(1, 2); } } } catch(...) { IBA_LOG0(_T("出现异常2")); } } ::CoUninitialize(); SetEvent(m_hEventTheadNoRun2); }
BOOLEAN DoMenuChooser (MENU_STATE *pMS, BYTE BaseState) { BYTE NewState = pMS->CurState; BYTE OrigBase = BaseState; BOOLEAN useAltMenu = FALSE; if (optWhichMenu == OPT_PC) useAltMenu = GetAlternateMenu (&BaseState, &NewState); if (PulsedInputState.menu[KEY_MENU_LEFT] || PulsedInputState.menu[KEY_MENU_UP]) NewState = PreviousMenuState (BaseState, NewState); else if (PulsedInputState.menu[KEY_MENU_RIGHT] || PulsedInputState.menu[KEY_MENU_DOWN]) NewState = NextMenuState (BaseState, NewState); else if (useAltMenu && PulsedInputState.menu[KEY_MENU_SELECT]) { NewState = ConvertAlternateMenu (BaseState, NewState); if (NewState == ALT_MANIFEST) { DrawMenuStateStrings (PM_ALT_CARGO, 0); pMS->CurState = PM_CARGO - PM_SCAN; return TRUE; } if (NewState == ALT_EXIT_MANIFEST) { if (OrigBase == PM_SCAN) DrawMenuStateStrings (PM_ALT_SCAN, PM_ALT_MANIFEST - PM_ALT_SCAN); else DrawMenuStateStrings (PM_ALT_STARMAP, PM_ALT_MANIFEST - PM_ALT_STARMAP); pMS->CurState = ALT_MANIFEST; return TRUE; } return FALSE; } else if ((optWhichMenu == OPT_PC) && PulsedInputState.menu[KEY_MENU_CANCEL] && (BaseState == PM_ALT_CARGO)) { if (OrigBase == PM_SCAN) DrawMenuStateStrings (PM_ALT_SCAN, PM_ALT_MANIFEST - PM_ALT_SCAN); else DrawMenuStateStrings (PM_ALT_STARMAP, PM_ALT_MANIFEST - PM_ALT_STARMAP); pMS->CurState = ALT_MANIFEST; return TRUE; } else return FALSE; DrawMenuStateStrings (BaseState, NewState); if (useAltMenu) NewState = ConvertAlternateMenu (BaseState, NewState); pMS->CurState = NewState; SleepThread (ONE_SECOND / 20); return TRUE; }
static void runCommAnimFrame (void) { LockMutex (GraphicsLock); UpdateCommGraphics (); UnlockMutex (GraphicsLock); SleepThread (COMM_ANIM_RATE); }
static BOOLEAN DoPopup (struct popup_state *self) { (void)self; SleepThread (ONE_SECOND / 20); return !(PulsedInputState.menu[KEY_MENU_SELECT] || PulsedInputState.menu[KEY_MENU_CANCEL]); }
static BOOLEAN DoPopup (struct popup_state *self) { (void)self; SleepThread (ONE_SECOND / 20); return !(PulsedInputState.menu[KEY_MENU_SELECT] || PulsedInputState.menu[KEY_MENU_CANCEL] || (GLOBAL (CurrentActivity) & CHECK_ABORT)); }
void CDlgAutoRegister::Run3() { ResetEvent(m_hEventTheadNoRun3); ::CoInitialize(NULL); while(1) { try { int nCount = 0; m_cs.Lock(); nCount = (int)m_arrDeRegisterNode.size(); m_cs.Unlock(); if (nCount > 0) { for (int i = 0; i < nCount; i++) { m_cs.Lock(); DeRegisterNode& node = m_arrDeRegisterNode[i]; m_cs.Unlock(); if(0 == node.bInvalid) { if(node.OldDeRegisterTime < COleDateTime::GetCurrentTime()) { DeRegister(node); m_cs.Lock(); node.bInvalid = 1; m_cs.Unlock(); } } SleepThread(1, 3); } } } catch(...) { IBA_LOG0(_T("出现异常3")); } SleepThread(1 * 60, 3); // 一分钟检测一次 } SetEvent(m_hEventTheadNoRun3); }
///////////////////////////////////////////////////////////////////////[16] void SifRpcLoop(struct sifcmd_RPC_DATA_QUEUE *qd){ register struct sifcmd_RPC_SERVER_DATA *s; do{ if (s=SifGetNextRequest(qd)) SifExecRequest(s); else SleepThread(); } while (1); }
// Maybe move to elsewhere, where it can be reused? static BOOLEAN waitForKey (struct wait_state *self) { if (PulsedInputState.menu[KEY_MENU_SELECT] || PulsedInputState.menu[KEY_MENU_CANCEL]) return FALSE; SleepThread (ONE_SECOND / 20); (void) self; return TRUE; }
//------------------------------------------------------------------------- void init_thread(void *args) { if (!sceSifCheckInit()) sceSifInit(); sceSifInitRpc(0); cdvdfsv_buf = AllocSysMemory(ALLOC_FIRST, (CDVDFSV_BUF_SECTORS << 11)+2048, NULL); if (!cdvdfsv_buf) SleepThread(); cdvdfsv_startrpcthreads(); }
void initalise(void) { int ret; // load all modules loadModules(); // init pad padInit(0); if((ret = padPortOpen(0, 0, padBuf)) == 0) { #if defined DEBUG scr_printf("padOpenPort failed: %d\n", ret); #endif SleepThread(); } if(!initializePad(0, 0)) { #if defined DEBUG scr_printf("pad initalization failed!\n"); #endif SleepThread(); } }
int main(int argc, char *argv[]) { SifInitRpc(0); SifLoadModule("host:ps2ips.irx", 0, NULL); if(ps2ip_init() < 0) { printf("ERROR: ps2ip_init falied!\n"); SleepThread(); } serverThread(); return 0; }