extern "C" int main(int argc, char *argv[]) { SceUID vtimer = sceKernelCreateVTimer("test", NULL); checkpointNext("Objects"); checkpoint(" Normal: %08x", sceKernelStopVTimer(vtimer)); checkpoint(" Twice: %08x", sceKernelStopVTimer(vtimer)); checkpoint(" NULL: %08x", sceKernelStopVTimer(0)); checkpoint(" Invalid: %08x", sceKernelStopVTimer(0xDEADBEEF)); sceKernelDeleteVTimer(vtimer); checkpoint(" Deleted: %08x", sceKernelStopVTimer(vtimer)); vtimer = sceKernelCreateVTimer("test", NULL); checkpointNext("Resetting"); sceKernelStartVTimer(vtimer); sceKernelDelayThread(1000); sceKernelStopVTimer(vtimer); sceKernelDelayThread(1000); sceKernelStartVTimer(vtimer); sceKernelDelayThread(1000); sceKernelStopVTimer(vtimer); sceKernelDelayThread(1000); sceKernelStartVTimer(vtimer); sceKernelDelayThread(1000); sceKernelStopVTimer(vtimer); checkpoint(" Start/Stop 3 times: %dms", (int)(sceKernelGetVTimerTimeWide(vtimer) / 1000)); checkpoint(" Base: %lld", sceKernelGetVTimerBaseWide(vtimer)); sceKernelDeleteVTimer(vtimer); return 0; }
extern "C" int main(int argc, char *argv[]) { checkpointNext("Normal (FIFO):"); { SceUID fpl = sceKernelCreateFpl("fpl", PSP_MEMORY_PARTITION_USER, 0, 0x100, 1, NULL); void *data; sceKernelAllocateFpl(fpl, &data, NULL); FplWaitThread wait1("waiting thread 1", fpl, NO_TIMEOUT, 300, 0x30); FplWaitThread wait2("waiting thread 2", fpl, NO_TIMEOUT, 300, 0x34); FplWaitThread wait3("waiting thread 3", fpl, NO_TIMEOUT, 300, 0x31); sceKernelFreeFpl(fpl, data); schedfFpl(fpl); sceKernelDelayThread(200000); sceKernelDeleteFpl(fpl); } checkpointNext("Priority:"); { SceUID fpl = sceKernelCreateFpl("fpl", PSP_MEMORY_PARTITION_USER, PSP_FPL_ATTR_PRIORITY, 0x100, 1, NULL); void *data; sceKernelAllocateFpl(fpl, &data, NULL); FplWaitThread wait1("waiting thread 1", fpl, NO_TIMEOUT, 300, 0x30); FplWaitThread wait2("waiting thread 2", fpl, NO_TIMEOUT, 300, 0x34); FplWaitThread wait3("waiting thread 3", fpl, NO_TIMEOUT, 300, 0x31); sceKernelFreeFpl(fpl, data); schedfFpl(fpl); sceKernelDelayThread(200000); sceKernelDeleteFpl(fpl); } return 0; }
void checkVblankInterruptHandler() { int counter = 0, last_counter = 0; int results[3], n; //pspDebugScreenInit(); pspDebugScreenPrintf("Starting...\n"); printf("Starting...\n"); sceKernelRegisterSubIntrHandler(PSP_VBLANK_INT, 0, vblank_handler_counter, &counter); sceKernelDelayThread(80000); results[0] = counter; printf("NotEnabled: Counter:%s\n", (counter == 0) ? "zero" : "non-zero"); // 0. Not enabled yet. sceKernelEnableSubIntr(PSP_VBLANK_INT, 0); sceKernelDelayThread(160000); results[1] = counter; printf("Enabled (GreaterThan2): Counter:%s\n", (counter >= 2) ? "greater" : "no greater"); // n. Already enabled. sceKernelReleaseSubIntrHandler(PSP_VBLANK_INT, 0); last_counter = counter; sceKernelDelayThread(80000); results[2] = counter; printf("Disabled (NotChangedAfterDisabled): %s\n", (last_counter != counter) ? "changed" : "not changed"); // n. Disabled. for (n = 0; n < 3; n++) { //printf("Output %d:%d\n", n, results[n]); pspDebugScreenPrintf("%d\n", results[n]); } }
/** * display_begin_frame: Begin processing for a frame. * * [Parameters] * None * [Return value] * None */ void display_begin_frame(void) { sceKernelDelayThread(0); // Seems to be needed for the buffer swap to work while (swap_pending) { sceKernelDelayThread(100); // 0.1ms } vram_next_alloc = vram_spare_ptr; guStart(GU_DIRECT, display_list); /* We don't use a depth buffer, so disable depth buffer writing */ guDepthMask(GU_TRUE); /* Clear the work surface--make sure to use the base pointer here, not * the effective pointer, lest we stomp on spare VRAM while using the * second buffer */ guDrawBuffer(GU_PSM_8888, surfaces[work_surface], DISPLAY_STRIDE); guDisable(GU_SCISSOR_TEST); guClear(GU_COLOR_BUFFER_BIT); guCommit(); /* Register the effective work surface pointer */ guDrawBuffer(GU_PSM_8888, display_work_buffer(), DISPLAY_STRIDE); /* Set up drawing area parameters (we set the depth parameters too, * just in case a custom drawing routine wants to use 3D coordinates) */ guViewport(2048, 2048, display_width, display_height); guOffset(2048 - display_width/2, 2048 - display_height/2); guScissor(0, 0, display_width, display_height); guEnable(GU_SCISSOR_TEST); guDepthRange(65535, 0); guDisable(GU_DEPTH_TEST); }
void testVTimerGetSimple() { SceUID vtimer1; printf("sceKernelCreateVTimer:%08X\n", vtimer1 = sceKernelCreateVTimer("VTIMER1", NULL)); sceKernelDelayThread(10000); printf("sceKernelGetVTimerTimeWide: %lld\n", sceKernelGetVTimerTimeWide(vtimer1) / 10000); printf("sceKernelStartVTimer:0x%08X\n", sceKernelStartVTimer(vtimer1)); sceKernelDelayThread(10000); printf("sceKernelGetVTimerTimeWide: %lld\n", sceKernelGetVTimerTimeWide(vtimer1) / 10000); printf("sceKernelStopVTimer:0x%08X\n", sceKernelStopVTimer(vtimer1)); printf("sceKernelStartVTimer:0x%08X\n", sceKernelStartVTimer(vtimer1)); sceKernelDelayThread(10000); printf("sceKernelGetVTimerTimeWide: %lld\n", sceKernelGetVTimerTimeWide(vtimer1) / 10000); printf("sceKernelStopVTimer:0x%08X\n", sceKernelStopVTimer(vtimer1)); printf("sceKernelStopVTimer:0x%08X\n", sceKernelStopVTimer(vtimer1)); printf("sceKernelGetVTimerTimeWide: %lld\n", sceKernelGetVTimerTimeWide(vtimer1) / 10000); printf("sceKernelCancelVTimerHandler:0x%08X\n", sceKernelCancelVTimerHandler(vtimer1)); }
/* Start a client */ int JSocket::start_client(const char *szIpAddr){ #ifdef NETWORK_SUPPORT int sock; sockaddr_in addrListen; int error; sock = sceNetInetSocket(AF_INET, SOCK_STREAM, 0); if (sock <= 0){ printf("socket returned $%x\n", sock); sceKernelDelayThread(500*1000); return sock; } addrListen.sin_family = AF_INET; addrListen.sin_addr.s_addr = inet_addr(szIpAddr); addrListen.sin_port = htons(SERVER_PORT); int err = sceNetInetConnect(sock, (sockaddr *)&addrListen, sizeof(addrListen)); if (err != 0){ printf("Unable to connect!\n"); printf("connect returned $%x\n", err); printf(" errno=$%x\n", sceNetInetGetErrno()); sceKernelDelayThread(500*1000); return err; } connected = 1; while(1){ readWrite(sock); } #endif return 0; }
static int MainThread( SceSize args, void *argp ) { hookDisplay(); sceKernelDcacheWritebackInvalidateAll(); sceKernelIcacheInvalidateAll(); unsigned int paddata_old = 0; SceCtrlData paddata; sceKernelDelayThread(10000); while(1) { sceCtrlPeekBufferPositive(&paddata, 1); if(paddata.Buttons != paddata_old) { //press "note" button and magick begin if(paddata.Buttons & PSP_CTRL_NOTE) { //can parse command list can_parse = 1; } } paddata_old = paddata.Buttons; sceKernelDelayThread(10000); } return( 0 ); }
void execPriorityTests(int attr, int deleteInstead) { SceUID threads[5]; int test[5] = {1, 2, 3, 4, 5}; int result; sceKernelCreateLwMutex(&workarea, "mutex1", attr, 1, NULL); int i; for (i = 0; i < 5; i++) { threads[i] = CREATE_PRIORITY_THREAD(threadFunction, 0x16 - i); sceKernelStartThread(threads[i], sizeof(int), (void*)&test[i]); } // This one intentionally is an invalid unlock. sceKernelDelayThread(1000); printf("Unlocking...\n"); result = sceKernelUnlockLwMutex(&workarea, 2); sceKernelDelayThread(5000); printf("Unlocked 2? %08X\n", result); if (!deleteInstead) { sceKernelDelayThread(1000); printf("Unlocking...\n"); result = sceKernelUnlockLwMutex(&workarea, 1); sceKernelDelayThread(5000); printf("Unlocked 1? %08X\n", result); } sceKernelDelayThread(1000); printf("Delete: %08X\n", sceKernelDeleteLwMutex(&workarea)); printf("\n\n"); }
extern "C" int main(int argc, char *argv[]) { vtimer = sceKernelCreateVTimer("cancel", NULL); testCancel("Normal", vtimer); testCancel("Twice", vtimer); testCancel("NULL", 0); testCancel("Invalid", 0xDEADBEEF); sceKernelDeleteVTimer(vtimer); testCancel("Deleted", vtimer); vtimer = sceKernelCreateVTimer("delete", NULL); sceKernelStartVTimer(vtimer); testCancel("Started", vtimer); sceKernelSetVTimerHandlerWide(vtimer, 1, &basicHandler, (void *)0xABCD1337); testCancel("With handler", vtimer); SceKernelSysClock t = {1, 0}; sceKernelSetVTimerHandler(vtimer, &t, &cancelHandler, (void *)0xABCD1337); sceKernelDelayThread(1000); testCancel("After cancel handler", vtimer); sceKernelSetVTimerHandlerWide(vtimer, 1, &zeroHandler, (void *)0xABCD1337); sceKernelDelayThread(1000); schedfVTimer(vtimer); testCancel("After return zero handler", vtimer); return 0; }
void testTryAllocThread(const char *title, u32 attr, u32 requestBytes, u32 initialBytes) { schedf("%s: ", title); SceUID vpl = sceKernelCreateVpl("vpl", PSP_MEMORY_PARTITION_USER, attr, 0x100, NULL); // This way we have some allocated + free. void *data; sceKernelAllocateVpl(vpl, initialBytes, &data, NULL); SceUID allocThread = sceKernelCreateThread("allocThread", &allocFunc, 0x12, 0x1000, 0, NULL); sceKernelStartThread(allocThread, sizeof(SceUID), &vpl); sceKernelDelayThread(400); int result = sceKernelTryAllocateVpl(vpl, requestBytes, &data); schedf("L2 "); sceKernelDelayThread(600); sceKernelDeleteVpl(vpl); sceKernelWaitThreadEnd(allocThread, NULL); sceKernelTerminateDeleteThread(allocThread); if (result == 0) { schedf("OK (thread=%08X)\n", schedulingResult); } else { schedf("Failed (thread=%08X, main=%08X)\n", schedulingResult, result); } }
void uninstall_permanent_patch(void) { int ret; do { ret = sceIoRemove(VSHMAIN); if(ret != 0) { printf("Delete %s failed\n", VSHMAIN); sceKernelDelayThread(1000000L); } } while(ret != 0); do { ret = copy_file(VSHORIG, VSHMAIN); if(ret != 0) { printf("Copy %s to %s failed 0x%08X\n", VSHORIG, VSHMAIN, ret); sceKernelDelayThread(1000000L); } } while(ret != 0); do { ret = sceIoRemove(VSHORIG); if(ret != 0) { printf("Delete %s failed\n", VSHTEMP); sceKernelDelayThread(1000000L); } } while(ret != 0); sceIoRemove(VSHTEMP); }
int main(int argc, char **argv) { int result; int check_not_update_value = 7; SceKernelSemaInfo info; sema = sceKernelCreateSema("sema1", 0, 0, 2, NULL); sceKernelReferSemaStatus(sema, &info); PRINT_SEMAPHORE(sema, info); threads[0] = sceKernelCreateThread("Thread-0", (void *)&threadFunction, 0x12, 0x10000, 0, NULL); threads[1] = sceKernelCreateThread("Thread-1", (void *)&threadFunction, 0x12, 0x10000, 0, NULL); threads[2] = sceKernelCreateThread("Thread-2", (void *)&threadFunction, 0x12, 0x10000, 0, NULL); threads[3] = sceKernelCreateThread("Thread-3", (void *)&threadFunction, 0x12, 0x10000, 0, NULL); threads[4] = sceKernelCreateThread("Thread-4", (void *)&threadFunction2, 0x12, 0x10000, 0, NULL); schedf("VALUE-INVARIANT:%d\n", check_not_update_value); sceKernelStartThread(threads[0], 1, (void*)&test[1]); sceKernelStartThread(threads[1], 2, NULL); sceKernelStartThread(threads[2], 0, (void*)&test[0]); sceKernelStartThread(threads[3], sizeof(int), (void*)&test[4]); sceKernelStartThread(threads[4], sizeof(int), &check_not_update_value); sceKernelDelayThread(10 * 1000); schedf("---\n"); sceKernelReferSemaStatus(sema, &info); PRINT_SEMAPHORE(sema, info); schedf("---\n"); sceKernelSignalSema(sema, 1); sceKernelDelayThread(10 * 1000); schedf("---\n"); sceKernelReferSemaStatus(sema, &info); PRINT_SEMAPHORE(sema, info); schedf("---\n"); sceKernelSignalSema(sema, 1); sceKernelDelayThread(10 * 1000); schedf("---\n"); sceKernelReferSemaStatus(sema, &info); PRINT_SEMAPHORE(sema, info); schedf("---\n"); result = sceKernelDeleteSema(sema); schedf("%08X\n", result); result = sceKernelDeleteSema(sema); schedf("%08X\n", result); schedf("VALUE-INVARIANT:%d\n", check_not_update_value); flushschedf(); return 0; }
static int messagebubble(int buttonif, const char *message) { sceDisplayWaitVblankStart(); sceKernelDelayThread(100 * 1000); ShowMessageDialog(message, buttonif); sceKernelDelayThread(300 * 1000); sceUtilityMsgDialogShutdownStart(); return 1; }
extern "C" int main(int argc, char *argv[]) { loadPsmfPlayer(); sceMpegInit(); checkpointNext("Init"); checkpointNext("Players:"); testGetAudioData(" Initial", createPsmfPlayerInitial()); testGetAudioData(" Standby", createPsmfPlayerStandby(TEST_VIDEO_FILENAME)); testGetAudioData(" Deleted", createPsmfPlayerDeleted()); // Crashes. //testGetAudioData(" NULL", NULL); SceUID *psmfPlaying = createPsmfPlayerPlaying(TEST_VIDEO_FILENAME); testGetAudioData(" Playing", psmfPlaying); // Force the video ahead a bit. warmUpVideo(psmfPlaying); sceKernelDelayThread(16000); testGetAudioData(" Twice", psmfPlaying); SceUID psmf2 = *psmfPlaying; sceKernelDelayThread(16000); testGetAudioData(" Copy", &psmf2); testGetAudioData(" Finished", createPsmfPlayerAudioFinished(TEST_VIDEO_FILENAME)); psmfPlaying = createPsmfPlayerPlaying(TEST_VIDEO_FILENAME); warmUpVideo(psmfPlaying); checkpointNext("Params:"); // Crashes. //testGetAudioData(" NULL audioData", psmfPlaying, false); checkpointNext("Frame write"); scePsmfPlayerChangePlayMode(psmfPlaying, 3, 0); prepScanAudioData(); testGetAudioData(" Paused 1", psmfPlaying); doScanAudioData(); sceKernelDelayThread(16000); prepScanAudioData(); testGetAudioData(" Paused 2", psmfPlaying); doScanAudioData(); SceUID *psmfFinished = createPsmfPlayerAudioFinished(TEST_VIDEO_FILENAME); prepScanAudioData(); testGetAudioData(" Finished", psmfFinished); doScanAudioData(); checkpointNext("Video sync better priority:"); testAudioDataVideoSync(0x17); checkpointNext("Video sync worse priority:"); testAudioDataVideoSync(0x28); sceMpegFinish(); unloadPsmfPlayer(); return 0; }
static void execPriorityTests(int attr, int changePriority) { printf("For attr %08X%s:\n", attr, changePriority ? " and changed priorities" : ""); schedulingLogPos = 0; SceUID threads[7]; int test[7] = {1, 2, 3, 4, 5, 6, 7}; mbx = sceKernelCreateMbx("mbx1", attr, NULL); PRINT_MBX(mbx); sendMbx(mbx, 0x20); sendMbx(mbx, 0x10); int i; for (i = 0; i < 7; i++) { threads[i] = CREATE_PRIORITY_THREAD(threadFunction, 0x18 - i); sceKernelStartThread(threads[i], sizeof(int), (void*)&test[i]); } sceKernelDelayThread(10 * 1000); // What we're gonna do now is change the threads' priorities to see whether // priority at time of wait (already happened) or at time of send matters. if (changePriority) { for (i = 0; i < 7; i++) { sceKernelChangeThreadPriority(threads[i], 0x18 - 7 + i); } printf("Priorities reversed. Have a nice day.\n"); } schedf("---\n"); PRINT_MBX(mbx); schedf("---\n"); sendMbx(mbx, 0x15); sceKernelDelayThread(10 * 1000); schedf("---\n"); PRINT_MBX(mbx); schedf("---\n"); sendMbx(mbx, 0x20); sendMbx(mbx, 0x10); sceKernelDelayThread(10 * 1000); schedf("---\n"); PRINT_MBX(mbx); schedf("---\n"); sceKernelDeleteMbx(mbx); schedf("\n\n"); printf("%s", schedulingLog); }
int threadMediumPrio(SceSize args, void *argp) { sceKernelDelayThread(1000); /* Small delay to let the Busy Thread start immediately */ while (!testDone) { sceKernelDelayThread(1000); mediumPrioCounter++; } return 0; }
/* Select && Connect to an Access Point */ int selectAccessPoint(int selected) { int err; int stateLast = -1; int state; /* Connect using the first profile */ err = sceNetApctlConnect(selected); if (err != 0) { writeToLogFile("Error, sceNetApctlConnect returns %08X\n", err); wifiError = 1; return -1; } //printf("Connecting...\n"); while(1) { err = sceNetApctlGetState(&state); if(err != 0) { writeToLogFile("sceNetApctlGetState returns $%x\n", err); wifiError = 1; break; } if(state > stateLast) { //printf("Connection state %d of 4\n", state); stateLast = state; } /* Connected with IP Address*/ if(state == 4) break; /* Wait 50 ms before polling again */ sceKernelDelayThread(50*1000); } /* Now obtain IP Address */ while(1) { if(sceNetApctlGetInfo(8, AccessPoints[selected-1].pInfo) == 0) { AccessPoints[selected-1].color = DARK_GREEN; addPSP("SamuraiX", "11:11:11:11", "22:22:22:22", AccessPoints[selected-1].pInfo->ip, 5060, "88:88:88:88", "99:99:99:99", AccessPoints[selected-1].pInfo->ip, 5060, 0); break; } sceKernelDelayThread(1000 * 1000); } if(err != 0) { wifiError = 1; return -1; } return 1; }
int connectToAP(int config){ oslStartDrawing(); oslDrawImageXY(bkg, 0, 0); oslDrawString(30, 200, "Connecting to AP..."); oslEndDrawing(); oslEndFrame(); oslSyncFrame(); int result = oslConnectToAP(config, 30, connectAPCallback); if (!result){ char ip[30] = ""; char resolvedIP[30] = ""; oslStartDrawing(); oslDrawImageXY(bkg, 0, 0); oslGetIPaddress(ip); sprintf(buffer, "IP address: %s", ip); oslDrawString(30, 170, buffer); sprintf(buffer, "Resolving %s", ADDRESS); oslDrawString(30, 200, buffer); oslEndDrawing(); oslEndFrame(); oslSyncFrame(); result = oslResolveAddress(ADDRESS, resolvedIP); oslStartDrawing(); oslDrawImageXY(bkg, 0, 0); oslGetIPaddress(ip); if (!result) sprintf(buffer, "Resolved IP address: %s", ip); else sprintf(buffer, "Error resolving address!"); oslDrawString(30, 230, buffer); oslEndDrawing(); oslEndFrame(); oslSyncFrame(); sceKernelDelayThread(3*1000000); }else{ oslStartDrawing(); oslDrawImageXY(bkg, 0, 0); sprintf(buffer, "Error connecting to AP!"); oslDrawString(30, 200, buffer); oslEndDrawing(); oslEndFrame(); oslSyncFrame(); sceKernelDelayThread(3*1000000); } oslDisconnectFromAP(); return 0; }
void testSysTime() { u64 initial = sceKernelGetSystemTimeWide(); sceKernelDelayThread(1000); u64 diff1 = sceKernelGetSystemTimeWide() - initial; sceKernelDelayThread(1000); u64 diff2 = sceKernelGetSystemTimeWide() - initial - diff1; if ((diff1 + diff2) / 2 > 900 && (diff1 + diff2) / 2 < 1100) { printf("sceKernelGetSystemTimeWide: OK\n"); } else { printf("sceKernelGetSystemTimeWide: %u %u\n", (unsigned int) diff1, (unsigned int) diff2); } }
int launchAppByUriExit(char *titleid) { char uri[32]; sprintf(uri, "psgm:play?titleid=%s", titleid); sceKernelDelayThread(10000); sceAppMgrLaunchAppByUri(0xFFFFF, uri); sceKernelDelayThread(10000); sceAppMgrLaunchAppByUri(0xFFFFF, uri); sceKernelExitProcess(0); return 0; }
void testClock() { u32 initial = sceKernelLibcClock(); sceKernelDelayThread(1000); u32 diff1 = sceKernelLibcClock() - initial; sceKernelDelayThread(1000); u32 diff2 = sceKernelLibcClock() - initial - diff1; if ((diff1 + diff2) / 2 > 900 && (diff1 + diff2) / 2 < 1100) { printf("sceKernelLibcClock: OK\n"); } else { printf("sceKernelLibcClock: %u %u\n", (unsigned int) diff1, (unsigned int) diff2); } }
int check_game(game_info_t* game_info) { // get the game's module info SceModule* module = NULL; while (module == NULL) { sceKernelDelayThread(1000000); module = sceKernelFindModuleByAddress(0x08804000); } // set the module id and game name game_info->module_id = module->modid; strcpy(game_info->game_name, module->modname); // get the game's global pointer // NOTE: the SceModule structure is incorrect, text_addr is actually the gp_value unsigned int module_gp = module->text_addr; // add the offset to the global pointer, add the offset to the character pointer, // set the size and file name based on the game name if (strcmp("MonsterHunterPSP", game_info->game_name) == 0) { module_gp -= 0x6e60; game_info->character = (char *) 648; game_info->size = 0x46a0; strcat(game_info->file_name, "mhp.bin"); } else if (strcmp("MonsterHunterPortable2nd", game_info->game_name) == 0) { module_gp -= 0x7e5c; game_info->character = (char *) 1060; game_info->size = 0x13ef4; strcat(game_info->file_name, "mhp2.bin"); } else if (strcmp("MonsterHunterPortable2ndG", game_info->game_name) == 0) { module_gp -= 0x7648; game_info->character = (char *) 1184; game_info->size = 0x6a938; strcat(game_info->file_name, "mhp2g.bin"); } else if (strcmp("MonsterHunterPortable3rd", game_info->game_name) == 0) { module_gp += 0x88fc0; game_info->character = (char *) 2140; game_info->size = 0x5f378; strcat(game_info->file_name, "mhp3.bin"); } else { return 0; } // wait for the global pointer to be filled while (*((unsigned int *) module_gp) == 0) sceKernelDelayThread(1000000); // set the character pointer game_info->character += *((unsigned int *) module_gp); // check if a save file already exists SceIoStat stat; if (sceIoGetstat(game_info->file_name, &stat) < 0) game_info->file_exists = 0; else game_info->file_exists = 1; return 1; }
int PlayThread(SceSize argsize, void* args) { if (argsize!=sizeof(int)) { sceKernelExitThread(0); } int hardwareChannel=*((int*)args); int channel=hardwareChannels[hardwareChannel]; int stopReason; void *mainBuf,*backBuf,*tempBuf; mainBuf=malloc(4096); backBuf=malloc(4096); sceAudioChReserve(hardwareChannel,1024,PSP_AUDIO_FORMAT_STEREO); while(TRUE) { stopReason=AalibGetStopReason(channel); if (!stopReason) { goto Play; } else if (stopReason<0) { sceKernelDelayThread(10); continue; } else { goto Release; } } Play: GetProcessedBuffer(mainBuf,1024,channel); while (!AalibGetStopReason(channel)) { sceAudioOutputPanned(hardwareChannel,(unsigned int)(channels[channel].volume.left*channels[channel].audioStrength*PSP_AUDIO_VOLUME_MAX),(unsigned int)(channels[channel].volume.right*channels[channel].audioStrength*PSP_AUDIO_VOLUME_MAX),mainBuf); GetProcessedBuffer(backBuf,1024,channel); while (sceAudioGetChannelRestLen(hardwareChannel)) sceKernelDelayThread(100); tempBuf=mainBuf; mainBuf=backBuf; backBuf=tempBuf; } Release: FreeHardwareChannel(channel); AalibStop(channel); sceKernelExitThread(0); return 0; }
/** * mode: 0 - OFW mode, 1 - CFW mode */ void start_reboot(int mode) { int modid, ret; int delay = 0; char modpath[80]; sprintf(modpath, "rebootex.prx"); modid = kuKernelLoadModule(modpath, 0, 0); if (modid >= 0) { ret = sceKernelStartModule(modid, sizeof(mode), &mode, 0, NULL); if (ret < 0) { printf("start module error 0x%08x\n", ret); delay = 5000000; } } else { printf("load module error 0x%08x\n", modid); delay = 5000000; } cleanup_exit(); sceKernelDelayThread(delay); sceKernelExitGame(); }
static int lockFunc(SceSize argSize, void* argPointer) { SceUInt timeout = 1000; schedulingResult = sceKernelLockMutex(*(int*) argPointer, 1, &timeout); schedulingLogPos += sprintf(schedulingLog + schedulingLogPos, "L1 "); sceKernelDelayThread(1000); return 0; }
void CSleep(int milliseconds) { #if defined(PSP) sceKernelDelayThread(milliseconds * 1000); #elif defined(__BEOS__) snooze(milliseconds * 1000); #elif defined(__AMIGA__) { ULONG signals; ULONG TimerSigBit = 1 << TimerPort->mp_SigBit; /* send IORequest */ TimerRequest->tr_node.io_Command = TR_ADDREQUEST; TimerRequest->tr_time.tv_secs = (milliseconds * 1000) / 1000000; TimerRequest->tr_time.tv_micro = (milliseconds * 1000) % 1000000; SendIO((struct IORequest *)TimerRequest); if (!((signals = Wait(TimerSigBit | SIGBREAKF_CTRL_C)) & TimerSigBit) ) { AbortIO((struct IORequest *)TimerRequest); } WaitIO((struct IORequest *)TimerRequest); } #else usleep(milliseconds * 1000); #endif }
/** * stop_channel: Stop playback from the given playback buffer. * * [Parameters] * buffer_desc: Playback buffer descriptor * [Return value] * None */ void stop_channel(PSPSoundBufferDesc *buffer_desc) { if (!buffer_desc) { DMSG("buffer_desc == NULL"); return; } if (!buffer_desc->started) { DMSG("Buffer has not been started!"); return; } /* Signal the thread to stop, then wait for it (if we try to stop the * thread in the middle of an audio write, we won't be able to free * the hardware channel) */ buffer_desc->stop = 1; int tries; for (tries = (1000 * (2*BUFFER_SIZE)/PLAYBACK_RATE); tries > 0; tries--) { if (sys_delete_thread_if_stopped(buffer_desc->thread, NULL)) { break; } sceKernelDelayThread(1000); // Wait for 1ms before trying again } if (!tries) { /* The thread didn't stop on its own, so terminate it with * extreme prejudice */ sceKernelTerminateDeleteThread(buffer_desc->thread); sceAudioChRelease(buffer_desc->channel); memset(buffer_desc, 0, sizeof(*buffer_desc)); } }
int delayFunc(SceSize argc, void *argv) { schedf("* delayFunc\n"); sceKernelDelayThread(500); return 7; }
int main(int argc, char *argv[]) { SceUID mod; char s[255]; int r; int SDCB1, SDCB2; sceKernelDelayThread(7000000); mod = pspSdkLoadStartModule("ms0:/seplugins/deemerd.prx", PSP_MEMORY_PARTITION_KERNEL); if (mod < 0) { sprintf(s, "Error 0x%08X loading/starting deemerd.prx.\n", mod); debugIssueError(s); } SDCB1 = sceKernelCreateCallback("SaveDataStartCallback", hcDeemerCapturedSDParamsCallback, NULL ); SDCB2 = sceKernelCreateCallback("SaveDataGetStatusCallback", hcDeemerSavedataGetStatusCallback, NULL ); hcDeemerDriverSetupCallbackCapturedSDParams(SDCB1, SDCB2); r = hcDeemerDriverPatchSavedataInitStart(); sceKernelSleepThreadCB(); return 0; }
int sub_00000588(void) { int intr; void (*ptr)(u32) = (void*)g_func_1200; (*ptr)(0); open_iso(); intr = sceKernelCpuSuspendIntr(); /* sceUmdManGetUmdDiscInfo patch */ _sw(0xE0000800, g_sceNp9660_driver_text_addr + g_offs->Data1); _sw(0x00000009, g_sceNp9660_driver_text_addr + g_offs->Data2); _sw(g_total_blocks, g_sceNp9660_driver_text_addr + g_offs->Data3); _sw(g_total_blocks, g_sceNp9660_driver_text_addr + g_offs->Data4); _sw(0x00000000, g_sceNp9660_driver_text_addr + g_offs->Data5); sceKernelCpuResumeIntr(intr); if(g_data_1204 == 0) { g_data_1204 = 1; sceKernelDelayThread(800000); } clear_cache(); sceKernelSetQTGP3(g_umddata); return 0; }