void PowerCallback (int unknown, int pwrflags)
{
if (pwrflags & PSP_POWER_CB_HOLD_SWITCH)
{
extern bool8 g_bShowProfilerIno;
g_bShowProfilerInfo = (! g_bShowProfilerInfo);
}
if (pwrflags & PSP_POWER_CB_POWER_SWITCH){
if (g_bROMLoaded) {
scePowerSetClockFrequency (222, 222, 111);
S9xSetSoundMute (TRUE);
g_bSleep = true;
save_config ();
Memory.SaveSRAM (S9xGetFilename ("srm"));
}
} else if (pwrflags & PSP_POWER_CB_RESUME_COMPLETE) {
g_bSleep = false;
}
if (pwrflags & PSP_POWER_CB_BATTERY_LOW){
scePowerSetClockFrequency (222,222,111);
S9xSetInfoString ("WARNING: PSP Battery is Low! (Automatically Throttling CPU)");
}
int cbid;
cbid = sceKernelCreateCallback ("Power Callback", (SceKernelCallbackFunction)PowerCallback, NULL);
scePowerRegisterCallback (0, cbid);
}
// Callback thread
int CallbackThread(SceSize args, void *argp) {
int cbid;
cbid = sceKernelCreateCallback("Exit Callback", (void *) exit_callback, NULL);
sceKernelRegisterExitCallback(cbid);
cbid = sceKernelCreateCallback("Power Callback", (void *) power_callback, NULL);
scePowerRegisterCallback(0, cbid);
sceKernelSleepThreadCB();
return 0;
}
// Thread to create the callbacks and then begin polling
int CallbackThread (int args, void *argp)
{
int cbid;
cbid = sceKernelCreateCallback ("Exit Callback", (SceKernelCallbackFunction)ExitCallback, NULL);
sceKernelRegisterExitCallback (cbid);
cbid = sceKernelCreateCallback ("Power Callback", (SceKernelCallbackFunction)PowerCallback, NULL);
scePowerRegisterCallback (0, cbid);
sceKernelSleepThreadCB ();
}
/* Callback thread */
static int callback_thread(SceSize args, void *argp)
{
int cbid;
lprintf("callback_thread started with id %08x, priority %i\n",
sceKernelGetThreadId(), sceKernelGetThreadCurrentPriority());
cbid = sceKernelCreateCallback("Exit Callback", exit_callback, NULL);
sceKernelRegisterExitCallback(cbid);
cbid = sceKernelCreateCallback("Power Callback", power_callback, NULL);
scePowerRegisterCallback(0, cbid);
sceKernelSleepThreadCB();
return 0;
}
// Power callback
int power_callback(int unknown, int pwrflags) {
int cbid;
if (pwrflags & POWER_CB_POWER || pwrflags & POWER_CB_SUSPEND || pwrflags & POWER_CB_EXT) {
// Put game in paused state if game is running
if (_gameState == GAME_RUNNING) {
HandlePauseGame();
} else if (_gameState == GAME_CONTINUE) {
// If game is in continue state, wait until it enters the running state
// before pausing. Game is only in continue state for about 1 second,
// and it cannot be paused from this sate
while (_gameState == GAME_CONTINUE ) { sceKernelDelayThread(1000); }
HandlePauseGame();
}
}
// Re-register power callback so it executes again the next time a power event occurs.
cbid = sceKernelCreateCallback("Power Callback", (void *) power_callback, NULL);
scePowerRegisterCallback(0, cbid);
return 0;
}
/* Callback thread */
int CallbackThread(SceSize /*size*/, void *arg) {
int cbid;
cbid = sceKernelCreateCallback("Exit Callback", (SceKernelCallbackFunction)exit_callback, NULL);
sceKernelRegisterExitCallback(cbid);
/* Set up callbacks for PSPIoStream */
cbid = sceKernelCreateCallback("Power Callback", (SceKernelCallbackFunction)power_callback, 0);
if (cbid >= 0) {
if (scePowerRegisterCallback(-1, cbid) < 0) {
PSP_ERROR("Couldn't register callback for power_callback\n");
}
} else {
PSP_ERROR("Couldn't create a callback for power_callback\n");
}
sceKernelSleepThreadCB();
return 0;
}
extern "C" int main(int argc, char *argv[]) {
Callback cb("notify", &cbFunc, NULL);
checkpointNext("Objects:");
testNotify(" Normal", cb, 0x1337);
testNotify(" NULL", 0, 0x1337);
testNotify(" Invalid", 0xDEADBEEF, 0x1337);
cb.Delete();
testNotify(" Deleted", cb, 0x1337);
cb.Create("notify", &cbFunc, NULL);
checkpointNext("Values:");
testNotify(" Zero", cb, 0);
testNotify(" DEADBEEF", cb, 0xDEADBEEF);
checkpointNext("Notifies:");
int result = 0;
for (int i = 0; i < 10000; ++i) {
result = sceKernelNotifyCallback(cb, 1);
if (result != 0) {
checkpoint(" Failed at %d: %08x", i, result);
break;
}
}
if (result == 0) {
checkpoint(" 10000 notifies: OK");
}
checkpoint("sceKernelDelayThreadCB: %08x", sceKernelDelayThreadCB(1000));
checkpointNext("Different thread:");
{
CallbackSleeper waiter1("better priority sleeping thread", 0x10);
CallbackSleeper waiter2("worse priority sleeping thread", 0x30);
sceKernelDelayThread(1000);
sceKernelNotifyCallback(waiter1.callbackID(), 0x1337);
sceKernelNotifyCallback(waiter2.callbackID(), 0x1337);
sceKernelDelayThread(1000);
}
checkpointNext("Return value:");
{
CallbackSleeper waiter("sleeping thread");
waiter.setReturn(0x1337);
sceKernelDelayThread(1000);
testNotify(" Notify #1", waiter.callbackID(), 0x1337);
sceKernelDelayThread(1000);
testNotify(" Notify #2", waiter.callbackID(), 0x1337);
sceKernelDelayThread(1000);
}
checkpointNext("Recursion:");
{
SelfNotifier waiter("sleeping thread");
sceKernelDelayThread(1000);
testNotify(" Notify #1", waiter.callbackID(), 0x1337);
sceKernelDelayThread(1000);
}
checkpointNext("Mixing types:");
checkpoint(" scePowerRegisterCallback (causes notify): %08x", scePowerRegisterCallback(0, cb));
testNotify(" Manual notify", cb, 0x1337);
checkpoint(" sceKernelDelayThreadCB: %08x", sceKernelDelayThreadCB(1000));
checkpointNext("Order:");
Callback cb1("notify1", &cbFunc, (void *)0xABC00001);
Callback cb2("notify2", &cbFunc, (void *)0xABC00002);
Callback cb3("notify3", &cbFunc, (void *)0xABC00003);
testNotify(" Notify cb #2", cb2, 0xDEF00001);
testNotify(" Notify cb #1", cb1, 0xDEF00002);
testNotify(" Notify cb #3", cb3, 0xDEF00003);
checkpoint(" sceKernelCheckCallback: %08x", sceKernelCheckCallback());
return 0;
}
