Esempio n. 1
0
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;
}
Esempio n. 2
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;
}
Esempio n. 3
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]);
	}
}
Esempio n. 4
0
/**
 * 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);

}
Esempio n. 5
0
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));
}
Esempio n. 6
0
/* 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;
}
Esempio n. 7
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 );
}
Esempio n. 8
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");
}
Esempio n. 9
0
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;
}
Esempio n. 10
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);
	}
}
Esempio n. 11
0
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);
}
Esempio n. 12
0
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;
}
Esempio n. 13
0
static int messagebubble(int buttonif, const char *message)
{
    sceDisplayWaitVblankStart();
    sceKernelDelayThread(100 * 1000);
    ShowMessageDialog(message, buttonif);
    sceKernelDelayThread(300 * 1000);
    sceUtilityMsgDialogShutdownStart();
    return 1;
}
Esempio n. 14
0
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;
}
Esempio n. 15
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);
}
Esempio n. 16
0
int threadMediumPrio(SceSize args, void *argp)
{
    sceKernelDelayThread(1000); /* Small delay to let the Busy Thread start immediately */
    while (!testDone)
    {
        sceKernelDelayThread(1000);
        mediumPrioCounter++;
    }

    return 0;
}
Esempio n. 17
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;
}
Esempio n. 18
0
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;
}
Esempio n. 19
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);
	}
}
Esempio n. 20
0
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;
}
Esempio n. 21
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);
	}
}
Esempio n. 22
0
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;
}
Esempio n. 23
0
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;
}
Esempio n. 24
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();
}
Esempio n. 25
0
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;
}
Esempio n. 26
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
}
Esempio n. 27
0
/**
 * 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));
    }
}
Esempio n. 28
0
int delayFunc(SceSize argc, void *argv) {
	schedf("* delayFunc\n");

	sceKernelDelayThread(500);

	return 7;
}
Esempio n. 29
0
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;
}