int main(int argc, char *argv[])
{
#ifdef PSPSDK
pspDebugScreenInit();
SetupCallbacks();
#else
// Shut down the server if we get a kill signal.
signal( SIGINT, (sighandler_t) shutdownServer );
signal( SIGTERM, (sighandler_t) shutdownServer );
#endif
/* Setup Data-Directory */
dataDir = CBuffer(argv[0]).replaceAll("\\", "/");
dataDir = dataDir.copy(0, dataDir.findl('/') + 1);
programDir = dataDir;
dataDir << "world/";
/* Main Initiating */
adminNames.load( __admin, sizeof(__admin) / sizeof(const char*) );
colourNames.load( __colours, sizeof(__colours) / sizeof(const char*) );
clothCommands.load( __cloths, sizeof(__cloths) / sizeof(const char*) );
defaultGaniNames.load( __defaultgani, sizeof(__defaultgani) / sizeof(const char*) );
defaultSwordNames.load( __defaultsword, sizeof(__defaultsword) / sizeof(const char*) );
defaultShieldNames.load( __defaultshield, sizeof(__defaultshield) / sizeof(const char*) );
playerIds.add(0);
playerIds.add(0);
npcIds.add(0);
srand((int)time(NULL));
/* Load Important Files */
updateFile("rchelp.txt");
updateFile("rcmessage.txt");
updateFile("rules.txt");
updateFile("serverflags.txt");
updateFile("servermessage.html");
updateFile("foldersconfig.txt");
/* Load Settings */
if (!loadSettings("serveroptions.txt"))
{
errorOut("errorlog.txt", "Unable to load server settings..");
return 1;
}
/* Load Weapons */
if (!loadWeapons("weapons.txt"))
{
errorOut("errorlog.txt", "Unable to load weapons from weapons.txt..");
return 1;
}
/* Initialize Sockets */
if (CSocket::sockStart() != 0)
return 1;
if(!serverSock.listenSock(serverPort, 20))
{
errorOut("errorlog.txt", CString() << "SOCK ERROR: Unable to listen on port: " << toString(serverPort));
return 1;
}
serverSock.setSync(false);
/* Server Finished Loading */
printf("GServer 2 by 39ster\nSpecial thanks to Marlon, Agret, Pac300, 39ster and others for porting the \noriginal 1.39 gserver to 2.1\nServer listening on port: %i\nServer version: Build %s\n\n", serverPort, listServerFields[3].text());
errorOut("serverlog.txt", "Server started");
if ( listServerFields[5] == "localhost" )
errorOut("serverlog.txt", "[DEBUG_LOCALHOSTMODE] Localhost mode is activated.\nListserver communication & account authentication are disabled.", true);
serverRunning = true;
if ( !(listServerFields[5] == "localhost") )
if (!lsConnected)
ListServer_Connect();
while (serverRunning)
{
long long second = time(NULL);
while (second == time(NULL))
{
acceptNewPlayers(serverSock);
for (int i = 0; i < newPlayers.count(); i ++)
{
CPlayer* player = (CPlayer*)newPlayers[i];
player->main();
if (player->deleteMe)
{
delete player;
i--;
}
}
for(int i = 0; i < playerList.count(); i++)
{
CPlayer* player = (CPlayer*)playerList[i];
player->main();
if(player->deleteMe)
{
delete player;
i--;
}
}
// Was moved so it can process faster. - Joey
ListServer_Main();
wait(100);
}
doTimer();
gameTime ++;
NOLEVEL->reset();
// Every 30 seconds
if (gameTime % 30 == 0)
{
ListServer_Send(CPacket() << (char)SLSPING);
}
// Every 10 seconds
if (gameTime % 10 == 0)
{
CPacket pPacket;
CString file;
for (int i = 0; i < playerList.count(); i++)
{
CPlayer *player = (CPlayer *)playerList[i];
file << player->accountName << "," << player->nickName << "," << player->levelName << "," << toString(player->x) << "," << toString(player->y) << "," << toString(player->ap) << "\n";
}
file.save("logs/playerlist.txt");
serverFlags.save("serverflags.txt");
}
//Every 5 seconds?
int current = getNWTime();
if (nwTime != current)
{
nwTime = current;
for (int i = 0; i < playerList.count(); i++)
{
CPacket out;
out << (char)NEWWORLDTIME;
out.writeByte4(current);
((CPlayer*)playerList[i])->sendPacket(out);
}
}
}
}
/* main routine */
int main(int argc, char *argv[])
{
SceCtrlData pad;
//init screen and callbacks
pspDebugScreenInit();
pspDebugScreenClear();
SetupCallbacks();
// Setup Pad
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(0);
// Load modules
int status = sceUtilityLoadModule(PSP_MODULE_AV_AVCODEC);
if (status<0)
{
ERRORMSG("ERROR: sceUtilityLoadModule(PSP_MODULE_AV_AVCODEC) returned 0x%08X\n", status);
}
status = sceUtilityLoadModule(PSP_MODULE_AV_MP3);
if (status<0)
{
ERRORMSG("ERROR: sceUtilityLoadModule(PSP_MODULE_AV_MP3) returned 0x%08X\n", status);
}
// Open the input file
int fd = sceIoOpen( MP3FILE, PSP_O_RDONLY, 0777 );
if (fd<0)
{
ERRORMSG("ERROR: Could not open file '%s' - 0x%08X\n", MP3FILE, fd);
}
// Init mp3 resources
status = sceMp3InitResource();
if (status<0)
{
ERRORMSG("ERROR: sceMp3InitResource returned 0x%08X\n", status);
}
// Reserve a mp3 handle for our playback
SceMp3InitArg mp3Init;
mp3Init.mp3StreamStart = 0;
mp3Init.mp3StreamEnd = sceIoLseek32( fd, 0, SEEK_END );
mp3Init.unk1 = 0;
mp3Init.unk2 = 0;
mp3Init.mp3Buf = mp3Buf;
mp3Init.mp3BufSize = sizeof(mp3Buf);
mp3Init.pcmBuf = pcmBuf;
mp3Init.pcmBufSize = sizeof(pcmBuf);
int handle = sceMp3ReserveMp3Handle( &mp3Init );
if (handle<0)
{
ERRORMSG("ERROR: sceMp3ReserveMp3Handle returned 0x%08X\n", handle);
}
// Fill the stream buffer with some data so that sceMp3Init has something to work with
fillStreamBuffer( fd, handle );
status = sceMp3Init( handle );
if (status<0)
{
ERRORMSG("ERROR: sceMp3Init returned 0x%08X\n", status);
}
int channel = -1;
int samplingRate = sceMp3GetSamplingRate( handle );
int numChannels = sceMp3GetMp3ChannelNum( handle );
int lastDecoded = 0;
int volume = PSP_AUDIO_VOLUME_MAX;
int numPlayed = 0;
int paused = 0;
int lastButtons = 0;
int loop = 0;
while (isrunning)
{
sceDisplayWaitVblankStart();
pspDebugScreenSetXY(0, 0);
printf("PSP Mp3 Sample v1.0 by Raphael\n\n");
printf("Playing '%s'...\n", MP3FILE);
printf(" %i Hz\n", samplingRate);
printf(" %i kbit/s\n", sceMp3GetBitRate( handle ));
printf(" %s\n", numChannels==2?"Stereo":"Mono");
printf(" %s\n\n", loop==0?"No loop":"Loop");
int playTime = samplingRate>0?numPlayed / samplingRate:0;
printf(" Playtime: %02i:%02i\n", playTime/60, playTime%60 );
printf("\n\n\nPress CIRCLE to Pause/Resume playback\nPress TRIANGLE to reset playback\nPress CROSS to switch loop mode\nPress SQUARE to stop playback and quit\n");
if (!paused)
{
// Check if we need to fill our stream buffer
if (sceMp3CheckStreamDataNeeded( handle )>0)
{
fillStreamBuffer( fd, handle );
}
// Decode some samples
short* buf;
int bytesDecoded;
int retries = 0;
// We retry in case it's just that we reached the end of the stream and need to loop
for (; retries<1; retries++)
{
bytesDecoded = sceMp3Decode( handle, &buf );
if (bytesDecoded>0)
break;
if (sceMp3CheckStreamDataNeeded( handle )<=0)
break;
if (!fillStreamBuffer( fd, handle ))
{
numPlayed = 0;
}
}
if (bytesDecoded<0 && bytesDecoded!=0x80671402)
{
ERRORMSG("ERROR: sceMp3Decode returned 0x%08X\n", bytesDecoded);
}
// Nothing more to decode? Must have reached end of input buffer
if (bytesDecoded==0 || bytesDecoded==0x80671402)
{
paused = 1;
sceMp3ResetPlayPosition( handle );
numPlayed = 0;
}
else
{
// Reserve the Audio channel for our output if not yet done
if (channel<0 || lastDecoded!=bytesDecoded)
{
if (channel>=0)
sceAudioSRCChRelease();
channel = sceAudioSRCChReserve( bytesDecoded/(2*numChannels), samplingRate, numChannels );
}
// Output the decoded samples and accumulate the number of played samples to get the playtime
numPlayed += sceAudioSRCOutputBlocking( volume, buf );
}
}
sceCtrlPeekBufferPositive(&pad, 1);
if (pad.Buttons!=lastButtons)
{
if (pad.Buttons & PSP_CTRL_CIRCLE)
{
paused ^= 1;
}
if (pad.Buttons & PSP_CTRL_TRIANGLE)
{
// Reset the stream and playback status
sceMp3ResetPlayPosition( handle );
numPlayed = 0;
}
if (pad.Buttons & PSP_CTRL_CROSS)
{
loop = (loop==0?-1:0);
status = sceMp3SetLoopNum( handle, loop );
if (status<0)
{
ERRORMSG("ERROR: sceMp3SetLoopNum returned 0x%08X\n", status);
}
}
if (pad.Buttons & PSP_CTRL_SQUARE)
{
break;
}
lastButtons = pad.Buttons;
}
}
// Cleanup time...
if (channel>=0)
sceAudioSRCChRelease();
status = sceMp3ReleaseMp3Handle( handle );
if (status<0)
{
ERRORMSG("ERROR: sceMp3ReleaseMp3Handle returned 0x%08X\n", status);
}
status = sceMp3TermResource();
if (status<0)
{
ERRORMSG("ERROR: sceMp3TermResource returned 0x%08X\n", status);
}
status = sceIoClose( fd );
if (status<0)
{
ERRORMSG("ERROR: sceIoClose returned 0x%08X\n", status);
}
sceKernelExitGame();
return 0;
}
int main(int argc, char *argv[])
{
SceCtrlData pad;
u32 buttonsold = 0;
int ret;
int outputmode = PSP_IRKBD_OUTPUT_MODE_VT100;
/*
possible output modes
PSP_IRKBD_OUTPUT_MODE_ASCII
PSP_IRKBD_OUTPUT_MODE_RAW
PSP_IRKBD_OUTPUT_MODE_SCANCODE
PSP_IRKBD_OUTPUT_MODE_VT100
*/
SetupCallbacks();
pspDebugScreenInit();
printf("PSP Irda Keyboard test\n");
ret = pspIrKeybInit( CONFIG_FILE, KERNELMODE );
if( ret == PSP_IRKBD_RESULT_OK )
{
pspIrKeybOutputMode( outputmode );
if( outputmode == PSP_IRKBD_OUTPUT_MODE_ASCII )
outputAsciiTest();
else if( outputmode == PSP_IRKBD_OUTPUT_MODE_RAW )
outputRawTest();
else if( outputmode == PSP_IRKBD_OUTPUT_MODE_SCANCODE )
outputScanCodeTest();
else if( outputmode == PSP_IRKBD_OUTPUT_MODE_VT100 )
outputVT100Test();
if( pspIrKeybFinish() == 0 )
printf( "\nclosed IR keyboard\n" );
else
printf( "\nerror: closing IR keyboard\n" );
} else {
switch( ret )
{
case PSP_IRKBD_RESULT_CANT_OPEN_DEVICE:
printf( "error: can't open device\n" );
break;
case PSP_IRKBD_RESULT_CANT_OPEN_MAPFILE:
printf( "error: can't open mapfile\n" );
break;
case PSP_IRKBD_RESULT_MAPFILE_MAXDEPTHLEVEL:
printf( "error: mapfile max include level reached - recursion?\n" );
break;
case PSP_IRKBD_RESULT_CANT_OPEN_MAPFILE_INCLUDE:
printf( "error: can't open include in mapfile\n" );
break;
case PSP_IRKBD_RESULT_CANT_SET_BAUDTATE:
printf( "error: can't set baudrate - you need kernel support\n" );
break;
case PSP_IRKBD_RESULT_CONFIG_FILE_NOT_FOUND:
printf( "error: can't read config file\n" );
break;
case PSP_IRKBD_RESULT_UNKNOW_KEYBOARD:
printf( "error: unknown keyboard\n" );
break;
case PSP_IRKBD_RESULT_FAILED:
default:
printf( "error: init failed\n" );
break;
}
}
printf( "\n bye... (PRESS psp button to quit)\n" );
while (1) {
sceCtrlReadBufferPositive(&pad, 1);
if (pad.Buttons != buttonsold) {
/* Exit */
sceKernelExitGame();
}
}
return 0;
}
int adhocReconnect(char *ssid)
{
int err = 0;
// Disconnect Wifi
if(g_NetAdhocctlConnect)
{
printf2("sceNetAdhocctlDisconnect\n");
err = sceNetAdhocctlDisconnect();
if(err != 0)
{
pspDebugScreenInit();
printf(" returned %x\n", err);
}
g_NetAdhocctlConnect = false;
}
if(g_NetAdhocPdpCreate)
{
printf2("sceNetAdhocPdpDelete\n");
err = sceNetAdhocPdpDelete(pdpId,0);
if(err != 0)
{
pspDebugScreenInit();
printf("sceNetAdhocPdpDelete returned %x\n", err);
}
g_NetAdhocPdpCreate = false;
}
if(g_NetAdhocMatchingStart)
{
printf2("sceNetAdhocMatchingStop\n");
err = sceNetAdhocMatchingStop(matchingId);
if(err != 0)
{
pspDebugScreenInit();
printf("sceNetAdhocMatchingStop returned %x\n", err);
}
g_NetAdhocMatchingStart = false;
}
if(g_NetAdhocMatchingCreate)
{
printf2("sceNetAdhocMatchingDelete\n");
err = sceNetAdhocMatchingDelete(matchingId);
if(err != 0)
{
pspDebugScreenInit();
printf("sceNetAdhocMatchingDelete returned %x\n", err);
}
g_NetAdhocMatchingCreate = false;
}
if(g_NetAdhocMatchingInit)
{
printf2("sceNetAdhocMatchingTerm\n");
err = sceNetAdhocMatchingTerm();
if(err != 0)
{
pspDebugScreenInit();
printf("sceNetAdhocMatchingTerm returned %x\n", err);
}
g_NetAdhocMatchingInit = false;
}
int stateLast = -1;
while (1)
{
int state;
err = sceNetAdhocctlGetState(&state);
if (err != 0)
{
pspDebugScreenInit();
printf("sceNetApctlGetState returns $%x\n", err);
sceKernelDelayThread(10*1000000); // 10sec to read before exit
return -1;
}
if (state > stateLast)
{
sprintf(temp," connection state %d of 1\n", state);
printf2(temp);
stateLast = state;
}
if (state == 0)
break; // connected
// wait a little before polling again
sceKernelDelayThread(50*1000); // 50ms
}
// Now connect to the PSP using a new SSID
// Connect
err = sceNetAdhocctlConnect(ssid);
if (err != 0)
{
pspDebugScreenInit();
printf("err=%x\n", err);
for(;;)
sceDisplayWaitVblankStart();
return err;
}
g_NetAdhocctlConnect = true;
stateLast = -1;
printf2("Connecting...\n");
while (1)
{
int state;
err = sceNetAdhocctlGetState(&state);
if (err != 0)
{
pspDebugScreenInit();
printf("sceNetApctlGetState returns $%x\n", err);
sceKernelDelayThread(10*1000000); // 10sec to read before exit
return -1;
}
if (state > stateLast)
{
sprintf(temp," connection state %d of 1\n", state);
printf2(temp);
stateLast = state;
}
if (state == 1)
break; // connected
// wait a little before polling again
sceKernelDelayThread(50*1000); // 50ms
}
char macAddr[10];
sceWlanGetEtherAddr(macAddr);
printf2("sceNetAdhocPdpCreate\n");
pdpId = sceNetAdhocPdpCreate(macAddr,
0x309, // 0x309 in lumines
0x800, // 0x400 in lumines
0); // 0 in lumines
if(pdpId <= 0)
{
pspDebugScreenInit();
printf("pdpId = %x\n", pdpId);
return -1;
}
g_NetAdhocPdpCreate = true;
}
int main(int argc, char *argv[])
{
SceCtrlData pad;
int oldButtons = 0;
#define SECOND 1000000
#define REPEAT_START (1 * SECOND)
#define REPEAT_DELAY (SECOND / 5)
struct timeval repeatStart;
struct timeval repeatDelay;
repeatStart.tv_sec = 0;
repeatStart.tv_usec = 0;
repeatDelay.tv_sec = 0;
repeatDelay.tv_usec = 0;
pspDebugScreenInit();
pspDebugScreenPrintf("Press Cross to start the IO Test\n");
while(!done)
{
sceCtrlReadBufferPositive(&pad, 1);
int buttonDown = (oldButtons ^ pad.Buttons) & pad.Buttons;
if (pad.Buttons == oldButtons)
{
struct timeval now;
gettimeofday(&now, NULL);
if (repeatStart.tv_sec == 0)
{
repeatStart.tv_sec = now.tv_sec;
repeatStart.tv_usec = now.tv_usec;
repeatDelay.tv_sec = 0;
repeatDelay.tv_usec = 0;
}
else
{
long usec = (now.tv_sec - repeatStart.tv_sec) * SECOND;
usec += (now.tv_usec - repeatStart.tv_usec);
if (usec >= REPEAT_START)
{
if (repeatDelay.tv_sec != 0)
{
usec = (now.tv_sec - repeatDelay.tv_sec) * SECOND;
usec += (now.tv_usec - repeatDelay.tv_usec);
if (usec >= REPEAT_DELAY)
{
repeatDelay.tv_sec = 0;
}
}
if (repeatDelay.tv_sec == 0)
{
buttonDown = pad.Buttons;
repeatDelay.tv_sec = now.tv_sec;
repeatDelay.tv_usec = now.tv_usec;
}
}
}
}
else
{
repeatStart.tv_sec = 0;
}
if (buttonDown & PSP_CTRL_CROSS)
{
sceKernelSetCompiledSdkVersion(0x307FFFF);
runTest();
sceKernelSetCompiledSdkVersion(0x307FFFF + 1);
runTest();
}
if (buttonDown & PSP_CTRL_TRIANGLE)
{
done = 1;
}
oldButtons = pad.Buttons;
}
sceGuTerm();
sceKernelExitGame();
return 0;
}
int main(int argc, char *argv[])
{
SceCtrlData pad;
int oldButtons = 0;
#define SECOND 1000000
#define REPEAT_START (1 * SECOND)
#define REPEAT_DELAY (SECOND / 5)
struct timeval repeatStart;
struct timeval repeatDelay;
repeatStart.tv_sec = 0;
repeatStart.tv_usec = 0;
repeatDelay.tv_sec = 0;
repeatDelay.tv_usec = 0;
pspDebugScreenInit();
pspDebugScreenPrintf("Press Cross to start the Task Scheduler Test\n");
pspDebugScreenPrintf("Press Circle to start the CpuSuspendIntr/CpuResumeIntr Test\n");
pspDebugScreenPrintf("Press Square to start the Task with thread of same priority\n");
pspDebugScreenPrintf("Press Left to start the Task Dispatcher Test\n");
pspDebugScreenPrintf("Press Triangle to Exit\n");
while(!done)
{
sceCtrlReadBufferPositive(&pad, 1);
int buttonDown = (oldButtons ^ pad.Buttons) & pad.Buttons;
if (pad.Buttons == oldButtons)
{
struct timeval now;
gettimeofday(&now, NULL);
if (repeatStart.tv_sec == 0)
{
repeatStart.tv_sec = now.tv_sec;
repeatStart.tv_usec = now.tv_usec;
repeatDelay.tv_sec = 0;
repeatDelay.tv_usec = 0;
}
else
{
long usec = (now.tv_sec - repeatStart.tv_sec) * SECOND;
usec += (now.tv_usec - repeatStart.tv_usec);
if (usec >= REPEAT_START)
{
if (repeatDelay.tv_sec != 0)
{
usec = (now.tv_sec - repeatDelay.tv_sec) * SECOND;
usec += (now.tv_usec - repeatDelay.tv_usec);
if (usec >= REPEAT_DELAY)
{
repeatDelay.tv_sec = 0;
}
}
if (repeatDelay.tv_sec == 0)
{
buttonDown = pad.Buttons;
repeatDelay.tv_sec = now.tv_sec;
repeatDelay.tv_usec = now.tv_usec;
}
}
}
}
else
{
repeatStart.tv_sec = 0;
}
if (buttonDown & PSP_CTRL_CROSS)
{
SceUID lowThid = sceKernelCreateThread("Low Prio Thread", threadLowPrio, 0x70, 0x1000, 0, 0);
SceUID mediumThid = sceKernelCreateThread("Medium Prio Thread", threadMediumPrio, 0x30, 0x1000, 0, 0);
SceUID highThid = sceKernelCreateThread("High Prio Thread", threadHighPrio, 0x10, 0x1000, 0, 0);
SceUID busyThid = sceKernelCreateThread("Busy Thread", threadBusy, 0x30, 0x1000, 0, 0);
testDone = 0;
highPrioCounter = 0;
mediumPrioCounter = 0;
lowPrioCounter = 0;
sceKernelStartThread(lowThid, 0, 0);
sceKernelStartThread(mediumThid, 0, 0);
sceKernelStartThread(busyThid, 0, 0);
sceKernelStartThread(highThid, 0, 0);
int totalDelay = 5000000;
sceKernelDelayThread(totalDelay);
testDone = 1;
sceKernelWaitThreadEnd(busyThid, NULL);
sceKernelWaitThreadEnd(mediumThid, NULL);
sceKernelWaitThreadEnd(highThid, NULL);
sceKernelWaitThreadEnd(lowThid, NULL);
pspDebugScreenPrintf("Counters: high=%d (%d us), medium=%d, low=%d\n", highPrioCounter, (totalDelay / highPrioCounter), mediumPrioCounter, lowPrioCounter);
}
if (buttonDown & PSP_CTRL_CIRCLE)
{
msg = buffer;
strcpy(msg, "");
SceUID sleepingThid = sceKernelCreateThread("Sleeping Thread", sleepingThread, 0x10, 0x1000, 0, 0);
sceKernelStartThread(sleepingThid, 0, 0);
sceKernelDelayThread(100000);
int intr = sceKernelCpuSuspendIntr();
sceKernelWakeupThread(sleepingThid);
strcat(msg, "Main Thread with disabled interrupts\n");
sceKernelCpuResumeIntr(intr);
strcat(msg, "Main Thread with enabled interrupts\n");
pspDebugScreenPrintf("%s", msg);
}
if (buttonDown & PSP_CTRL_SQUARE)
{
msg = buffer;
strcpy(msg, "");
// Two threads having the same priority
SceUID thread1 = sceKernelCreateThread("Thread 1", threadPrio_1, sceKernelGetThreadCurrentPriority(), 0x1000, 0, 0);
SceUID thread2 = sceKernelCreateThread("Thread 2", threadPrio_2, sceKernelGetThreadCurrentPriority(), 0x1000, 0, 0);
// Test that thread1 will be scheduled before thread2
sceKernelStartThread(thread1, 0, 0);
sceKernelStartThread(thread2, 0, 0);
strcat(msg, "1 ");
sceKernelDelayThread(10000);
strcat(msg, "4");
sceKernelWaitThreadEnd(thread1, NULL);
sceKernelWaitThreadEnd(thread2, NULL);
pspDebugScreenPrintf("Starting 2 threads at same priority: %s\n", msg);
// Now with a different order for create & start
strcpy(msg, "");
SceUID thread3 = sceKernelCreateThread("Thread 3", threadPrio_3, sceKernelGetThreadCurrentPriority(), 0x1000, 0, 0);
SceUID thread4 = sceKernelCreateThread("Thread 4", threadPrio_4, sceKernelGetThreadCurrentPriority(), 0x1000, 0, 0);
// Test that thread4 will be scheduled before thread3
sceKernelStartThread(thread4, 0, 0);
sceKernelStartThread(thread3, 0, 0);
strcat(msg, "1 ");
sceKernelDelayThread(10000);
strcat(msg, "4");
sceKernelWaitThreadEnd(thread3, NULL);
sceKernelWaitThreadEnd(thread4, NULL);
pspDebugScreenPrintf("Starting 2 threads with a different order create/start: %s\n", msg);
}
if (buttonDown & PSP_CTRL_LEFT)
{
msg = buffer;
strcpy(msg, "");
int state = sceKernelSuspendDispatchThread();
// High priority thread
SceUID thread = sceKernelCreateThread("Thread 1", threadHello, 0x10, 0x1000, 0, 0);
strcat(msg, "1 ");
// sceKernelStartThread resumes the thread dispatcher
sceKernelStartThread(thread, 0, 0);
strcat(msg, "2 ");
sceKernelDelayThread(10000);
strcat(msg, "3 ");
sceKernelResumeDispatchThread(state);
sceKernelWaitThreadEnd(thread, NULL);
pspDebugScreenPrintf("Starting high prio thread with a disabled dispatcher (state=0x%X): %s\n", state, msg);
msg = buffer;
strcpy(msg, "");
state = sceKernelSuspendDispatchThread();
// Low priority thread
thread = sceKernelCreateThread("Thread 1", threadHello, 0x70, 0x1000, 0, 0);
strcat(msg, "1 ");
// sceKernelStartThread resumes the thread dispatcher
sceKernelStartThread(thread, 0, 0);
strcat(msg, "2 ");
sceKernelDelayThread(10000);
strcat(msg, "3 ");
sceKernelResumeDispatchThread(state);
sceKernelWaitThreadEnd(thread, NULL);
pspDebugScreenPrintf("Starting low prio thread with a disabled dispatcher (state=0x%X): %s\n", state, msg);
}
if (buttonDown & PSP_CTRL_TRIANGLE)
{
done = 1;
}
oldButtons = pad.Buttons;
}
sceGuTerm();
sceKernelExitGame();
return 0;
}
int main(int argc, char *argv[])
{
SceCtrlData pad;
int oldButtons = 0;
#define SECOND 1000000
#define REPEAT_START (1 * SECOND)
#define REPEAT_DELAY (SECOND / 5)
struct timeval repeatStart;
struct timeval repeatDelay;
repeatStart.tv_sec = 0;
repeatStart.tv_usec = 0;
repeatDelay.tv_sec = 0;
repeatDelay.tv_usec = 0;
logFd = sceIoOpen("compilerPerf.log", PSP_O_WRONLY | PSP_O_CREAT, 0777);
pspDebugScreenInit();
pspDebugScreenPrintf("Press Cross to start the Performance Test\n");
pspDebugScreenPrintf("Press Circle to change the CPU Clock\n");
while(!done)
{
sceCtrlReadBufferPositive(&pad, 1);
int buttonDown = (oldButtons ^ pad.Buttons) & pad.Buttons;
if (pad.Buttons == oldButtons)
{
struct timeval now;
gettimeofday(&now, NULL);
if (repeatStart.tv_sec == 0)
{
repeatStart.tv_sec = now.tv_sec;
repeatStart.tv_usec = now.tv_usec;
repeatDelay.tv_sec = 0;
repeatDelay.tv_usec = 0;
}
else
{
long usec = (now.tv_sec - repeatStart.tv_sec) * SECOND;
usec += (now.tv_usec - repeatStart.tv_usec);
if (usec >= REPEAT_START)
{
if (repeatDelay.tv_sec != 0)
{
usec = (now.tv_sec - repeatDelay.tv_sec) * SECOND;
usec += (now.tv_usec - repeatDelay.tv_usec);
if (usec >= REPEAT_DELAY)
{
repeatDelay.tv_sec = 0;
}
}
if (repeatDelay.tv_sec == 0)
{
buttonDown = pad.Buttons;
repeatDelay.tv_sec = now.tv_sec;
repeatDelay.tv_usec = now.tv_usec;
}
}
}
}
else
{
repeatStart.tv_sec = 0;
}
if (buttonDown & PSP_CTRL_CROSS)
{
runTest();
}
if (buttonDown & PSP_CTRL_CIRCLE)
{
cpuFreq += 111;
if (cpuFreq > 333)
{
cpuFreq = 111;
}
int result = scePowerSetCpuClockFrequency(cpuFreq);
if (result == 0)
{
pspDebugScreenPrintf("CPU Clock set to %d MHz\n", cpuFreq);
}
else
{
pspDebugScreenPrintf("Could not set CPU Clock set to %d MHz\n", cpuFreq);
}
}
if (buttonDown & PSP_CTRL_TRIANGLE)
{
done = 1;
}
oldButtons = pad.Buttons;
}
sceGuTerm();
sceIoClose(logFd);
sceKernelExitGame();
return 0;
}
int main(int argc, char *argv[])
{
SceCtrlData pad;
u32 buttonsold = 0;
int kernelmode = 0; /* only 0 works for now - some keyboards need baud change */
const char *config_file = NULL; /* this will force ms0:/seplugins/pspirkeyb.ini */
SetupCallbacks();
pspDebugScreenInit();
printf("PSP Irda Keyboard test - ASCii input \n");
if (sceKernelDevkitVersion() >= 0x03080010)
{
/* Load irda PRX for CFW >= 3.80 - Thanks, ZX81! */
u32 mod_id = sceKernelLoadModule("flash0:/kd/irda.prx", 0, NULL);
sceKernelStartModule(mod_id, 0, NULL, NULL, NULL);
}
if( pspIrKeybInit( config_file, kernelmode ) != 0 )
{
printf( "error: can't inialize the keyboard\n" );
printf( " check keyboard type/map in ms0:/seplugins/pspirkeyb.ini\n" );
}
else
{
unsigned char termchar = 'X';
unsigned char buffer[255];
int i, length=0;
printf("\npress %c on keyboard or any PSP button to exit\n", termchar );
/* setup output method to ASCii */
pspIrKeybOutputMode( PSP_IRKBD_OUTPUT_MODE_ASCII );
while(1) {
length = 0;
/* non blocking read */
if( pspIrKeybReadinput(buffer, &length) >= 0 )
{
for( i=0; i < length; i++ )
printf( "%c", buffer[i] );
if( length == 1 && buffer[0] == termchar )
break;
}
else
{
sceKernelDelayThread(10*1000);
sceCtrlReadBufferPositive(&pad, 1);
if (pad.Buttons != buttonsold)
break;
}
}
/* bye keyboard */
pspIrKeybFinish();
}
printf( "\n bye... (PRESS psp button to quit)\n" );
buttonsold = 0;
while (1) {
sceCtrlReadBufferPositive(&pad, 1);
if (pad.Buttons != buttonsold) {
/* Exit */
sceKernelExitGame();
}
}
return 0;
}
int main(void)
{
SceCtrlData pad;
pspDebugScreenInit();
SetupCallbacks();
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
while(!done){
pspDebugScreenSetXY(0, 2);
sceCtrlReadBufferPositive(&pad, 1);
printf("Analog X = %d ", pad.Lx);
printf("Analog Y = %d \n", pad.Ly);
if (pad.Buttons != 0){
if (pad.Buttons & PSP_CTRL_SQUARE){
printf("Square pressed \n");
}
if (pad.Buttons & PSP_CTRL_TRIANGLE){
printf("Triangle pressed \n");
}
if (pad.Buttons & PSP_CTRL_CIRCLE){
printf("Cicle pressed \n");
}
if (pad.Buttons & PSP_CTRL_CROSS){
printf("Cross pressed \n");
}
if (pad.Buttons & PSP_CTRL_UP){
printf("Up pressed \n");
}
if (pad.Buttons & PSP_CTRL_DOWN){
printf("Down pressed \n");
}
if (pad.Buttons & PSP_CTRL_LEFT){
printf("Left pressed \n");
}
if (pad.Buttons & PSP_CTRL_RIGHT){
printf("Right pressed \n");
}
if (pad.Buttons & PSP_CTRL_START){
printf("Start pressed \n");
}
if (pad.Buttons & PSP_CTRL_SELECT){
printf("Select pressed \n");
}
if (pad.Buttons & PSP_CTRL_LTRIGGER){
printf("L-trigger pressed \n");
}
if (pad.Buttons & PSP_CTRL_RTRIGGER){
printf("R-trigger pressed \n");
}
}
}
sceKernelExitGame();
return 0;
}
int main(int argc, char *argv[])
{
SceCtrlData pad;
int result;
int oldButtons = 0;
int cbid = -1;
int waitStatThid = -1;
pspDebugScreenInit();
if (argc > 0) {
printf("Bootpath: %s\n", argv[0]);
}
printf("Triangle - Exit\n");
printf("Left - sceUmdActivate\n");
printf("Right - sceUmdDeactivate\n");
printf("Cross - Delay CB\n");
printf("Circle - Display umd info\n");
printf("Square - Refer umd callback\n");
printf("L-Trigger - IO test\n");
printf("R-Trigger - Start/Stop wait stat test\n");
SetupCallbacks();
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
{
printUmdInfo();
// result:
// callback events are generated if we launch from iso or immediately after psplink has reset
cbid = sceKernelCreateCallback("UMD Callback (not active)", umd_callback, (void*)0x34343434);
result = sceUmdRegisterUMDCallBack(cbid);
printf("sceUmdRegisterUMDCallBack result %08X\n", result);
// Register a second UMD callback: it will overwrite the first one.
cbid = sceKernelCreateCallback("UMD Callback", umd_callback, (void*)0x11111111);
result = sceUmdRegisterUMDCallBack(cbid);
printf("sceUmdRegisterUMDCallBack result %08X\n", result);
}
while (!done)
{
sceCtrlReadBufferPositive(&pad, 1); // context switch in here
//sceCtrlPeekBufferPositive(&pad, 1); // no context switch version
int buttonDown = (oldButtons ^ pad.Buttons) & pad.Buttons;
if (buttonDown & PSP_CTRL_LEFT)
{
result = sceUmdActivate(1, "disc0:");
printf("sceUmdActivate result %08x\n", result);
}
if (buttonDown & PSP_CTRL_RIGHT)
{
result = sceUmdDeactivate(1, "disc0:");
printf("sceUmdDeactivate result %08x\n", result);
}
if (buttonDown & PSP_CTRL_CROSS)
{
printf("sceKernelDelayThreadCB ...\n");
sceKernelDelayThreadCB(10000);
}
if (buttonDown & PSP_CTRL_CIRCLE)
{
printUmdInfo();
}
if (buttonDown & PSP_CTRL_SQUARE)
{
SceKernelCallbackInfo info;
memset(&info, 0xee, sizeof(info));
info.size = sizeof(info);
result = sceKernelReferCallbackStatus(cbid, &info);
printf("sceKernelReferCallbackStatus result %08x\n", result);
printf(" size %d (%d)\n", info.size, sizeof(info));
printf(" name '%s'\n", info.name);
printf(" threadId %08x (%08x)\n", info.threadId, sceKernelGetThreadId());
printf(" callback %p common %p\n", info.callback, info.common);
printf(" notifyCount %08x\n", info.notifyCount);
printf(" notifyArg %08x\n", info.notifyArg);
}
if (buttonDown & PSP_CTRL_LTRIGGER)
{
test_io();
}
if (buttonDown & PSP_CTRL_RTRIGGER)
{
if (waitStatThid >= 0)
{
printf("Cleaning up wait stat test ...\n");
referThread(waitStatThid);
result = sceUmdCancelWaitDriveStat();
printf("sceUmdCancelWaitDriveStat result %08x\n", result);
referThread(waitStatThid);
result = sceKernelDeleteThread(waitStatThid);
printf("sceKernelDeleteThread result %08x\n", result);
//result = sceKernelTerminateDeleteThread(waitStatThid);
//printf("sceKernelTerminateDeleteThread result %08x\n", result);
waitStatThid = -1;
}
else
{
printf("Starting wait stat test ...\n");
// test timeout:
// Press Right (deactivate UMD)
// Press R-Trigger:
// - Press R-Trigger again before 3 seconds:
// 0x800201a9 wait cancelled
// - Or wait 3 seconds:
// 0x800201a8 wait timeout
struct WaitStatParams params = { 0x20, 3000000 };
// test internal workings:
// - (wantStat & curStat) == wantStat
// - (wantStat & curStat) != 0 <-- looks like this is the correct one
//struct WaitStatParams params = { 0xFF, 3000000 };
waitStatThid = sceKernelCreateThread("WaitUMDStat", waitstat_thread, 0x20, 0x4000, 0, 0);
printf("sceKernelCreateThread result %08x\n", waitStatThid);
if (waitStatThid >= 0)
{
result = sceKernelStartThread(waitStatThid, sizeof(params), ¶ms);
printf("sceKernelStartThread result %08x\n", result);
}
}
}
if (buttonDown & PSP_CTRL_TRIANGLE)
done = 1;
oldButtons = pad.Buttons;
sceDisplayWaitVblank(); // only catch callback when we press Cross (sceKernelDelayThreadCB)
//sceDisplayWaitVblankCB(); // catch all callback events
}
sceKernelExitGame();
return 0;
}
int main(int argc, char* argv[])
{
unsigned int i,j;
pspDebugScreenInit();
SetupCallbacks();
#ifdef ENABLE_PROFILER
// Enable profiling
pspDebugProfilerClear();
pspDebugProfilerEnable();
#endif
// initialize global context
g_context.iterationCount = NUM_VERTEX_BUFFERS * NUM_ITERATIONS;
g_context.t = 0;
g_context.sint = 0;
// initialize torus
for (i = 0; i < NUM_SLICES; ++i)
{
for (j = 0; j < NUM_ROWS; ++j)
{
float s = i + 0.5f, t = j;
float x,y,z;
x = (RING_SIZE + RING_RADIUS * cosf(s * ((GU_PI*2)/NUM_SLICES))) * cosf(t * ((GU_PI*2)/NUM_ROWS));
y = (RING_SIZE + RING_RADIUS * cosf(s * ((GU_PI*2)/NUM_SLICES))) * sinf(t * ((GU_PI*2)/NUM_ROWS));
z = RING_RADIUS * sinf(s * ((GU_PI*2)/NUM_SLICES));
torus_vertices[j + i * NUM_ROWS].x = x;
torus_vertices[j + i * NUM_ROWS].y = y;
torus_vertices[j + i * NUM_ROWS].z = z;
}
}
// initialize torus modifiers
for (j = 0; j < NUM_ROWS; ++j)
{
float t = j;
torus_modifiers[j].x = 0;
torus_modifiers[j].y = 0;
torus_modifiers[j].z = 0.3*cosf( t * 8.0f *((GU_PI*2)/NUM_ROWS) );
}
// init GU and set callbacks
sceGuInit();
// 0x01 - user callback
// 0x04 - 'rendering finished' callback
sceGuSetCallback(1, &mySignalHandler);
sceGuSetCallback(4, &myFinishHandler);
// setup GU
sceGuStart(GU_DIRECT,list);
sceGuDrawBuffer(GU_PSM_8888,(void*)0,BUF_WIDTH);
sceGuDispBuffer(SCR_WIDTH,SCR_HEIGHT,(void*)0x88000,BUF_WIDTH);
sceGuDepthBuffer((void*)0x110000,BUF_WIDTH);
sceGuOffset(2048 - (SCR_WIDTH/2),2048 - (SCR_HEIGHT/2));
sceGuViewport(2048,2048,SCR_WIDTH,SCR_HEIGHT);
sceGuDepthRange(0xc350,0x2710);
sceGuScissor(0,0,SCR_WIDTH,SCR_HEIGHT);
sceGuEnable(GU_SCISSOR_TEST);
sceGuAlphaFunc(GU_GREATER,0,0xff);
sceGuEnable(GU_ALPHA_TEST);
sceGuDepthFunc(GU_GEQUAL);
sceGuEnable(GU_DEPTH_TEST);
sceGuFrontFace(GU_CW);
sceGuShadeModel(GU_SMOOTH);
sceGuEnable(GU_CULL_FACE);
sceGuEnable(GU_TEXTURE_2D);
sceGuFinish();
sceGuSync(0,0);
sceDisplayWaitVblankStart();
sceGuDisplay(GU_TRUE);
// run sample
#ifdef USING_SIGNALS
sceGuCallMode(1);
#endif
// generate callable command-list with texture setup
{
sceGuStart(GU_CALL, smallList1);
// setup texture
sceGuTexMode(GU_PSM_5551,0,0,0);
sceGuTexImage(0,32,32,32,ball_start); // width, height, buffer width, tbp
sceGuTexFunc(GU_TFX_MODULATE,GU_TCC_RGBA); // NOTE: this enables reads of the alpha-component from the texture, otherwise blend/test won't work
sceGuTexFilter(GU_NEAREST,GU_NEAREST);
sceGuTexWrap(GU_CLAMP,GU_CLAMP);
sceGuTexScale(1,1);
sceGuTexOffset(0,0);
sceGuAmbientColor(0xffffffff);
sceGuFinish();
sceGuSync(0,0);
}
// generate callable command-list for cube rendering
{
sceGuStart(GU_CALL, smallList2);
// draw cube
sceGuDrawArray(GU_TRIANGLES,GU_TEXTURE_32BITF|GU_COLOR_8888|GU_VERTEX_32BITF|GU_TRANSFORM_3D,12*3,0,cubeVertices);
sceGuFinish();
sceGuSync(0,0);
}
for(;;)
{
sceGuStart(GU_DIRECT,list);
unsigned int i = 0;
for( ; i < NUM_VERTEX_BUFFERS; i++ )
g_context.vbuffer[i] = sceGuGetMemory((NUM_SLICES/g_context.iterationCount) * 2 * NUM_ROWS * sizeof(Vertex));
g_context.vertsRendered = 0;
// clear screen
sceGuClearColor(0x00334455);
sceGuClearDepth(0);
sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT);
// setup matrices
sceGumMatrixMode(GU_PROJECTION);
sceGumLoadIdentity();
sceGumPerspective(75.0f,16.0f/9.0f,0.5f,1000.0f);
sceGumMatrixMode(GU_VIEW);
sceGumLoadIdentity();
sceGumMatrixMode(GU_MODEL);
{
ScePspFVector3 pos = {0.0f,0.0f,-3.5f};
ScePspFVector3 rot = {g_context.t * 0.3f * (GU_PI/180.0f), g_context.t * 0.7f * (GU_PI/180.0f), g_context.t * 1.3f * (GU_PI/180.0f)};
sceGumLoadIdentity();
sceGumTranslate(&pos);
sceGumRotateXYZ(&rot);
}
sceGumStoreMatrix(&g_context.world);
// call pregenerated command-list to setup texture
sceGuCallList(smallList1);
// start billboard rendering
render_billboards(0);
// call pregenerated command-list to render cube
{
ScePspFVector3 scale = {0.3f, 0.3f, 0.3f};
sceGumScale(&scale);
}
sceGumUpdateMatrix();
sceGuCallList(smallList2);
#ifndef USING_SIGNALS
// HACK: sceGuFinish() is called inside the signal interupt handler when all rendering job is done
// this is done in order to stall GPU if it is ahead of CPU
sceGuFinish();
#endif
sceGuSync(0,0);
#ifndef ENABLE_FRAMERATE
// wait for next frame
sceDisplayWaitVblankStart();
#endif
sceGuSwapBuffers();
pspDebugScreenSetXY(0,0);
#ifdef ENABLE_PROFILER
// Print profile information to the screen
pspDebugProfilerPrint();
#endif
#ifdef ENABLE_FRAMERATE
// simple frame rate counter
static float curr_ms = 1.0f;
static struct timeval time_slices[16];
static int t = 0;
float curr_fps = 1.0f / curr_ms;
t++;
float vertsPerSec = g_context.vertsRendered*curr_fps;
float kbPerSec = vertsPerSec * sizeof(Vertex) / 1024.0f;
gettimeofday(&time_slices[t & 15],0);
pspDebugScreenPrintf("fps: %d.%03d ms: %d vert/s: %dK MB/s: %d.%03d",(int)curr_fps, ((int)(curr_fps*1000.0f)%1000), (int)(curr_ms*1000.0f),
(int)(vertsPerSec/1000.0f),
(int)(kbPerSec/1024.0f), (int)((1000.0f/1024.0f)*((int)kbPerSec%1024)) );
if (!(t & 15))
{
struct timeval last_time = time_slices[0];
unsigned int i;
curr_ms = 0;
for (i = 1; i < 16; ++i)
{
struct timeval curr_time = time_slices[i];
int curr_time_usec = curr_time.tv_usec + curr_time.tv_sec * 1000000;
int last_time_usec = last_time.tv_usec + last_time.tv_sec * 1000000;
if( last_time_usec < curr_time_usec )
curr_ms += (( curr_time_usec - last_time_usec ) * (1.0f/1000000.0f));
last_time = time_slices[i];
}
curr_ms /= 15.0f;
}
#endif
}
sceGuTerm();
sceKernelExitGame();
return 0;
}
int main() {
SceUID video_thid; //int xx, yy, nubspeed;
SetupCallbacks(); pspDebugScreenInit(); initGraphics();
SceCtrlData pad, oldpad; oldpad.Buttons = 0xFFFFFFFF;
sceCtrlSetSamplingCycle(0); sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
// Start the video thread to draw objects to screen and manage video input.
video_thid = sceKernelCreateThread("video_thread", video_thread, 0x12, 512 * 1024, 0, NULL);
if (video_thid > 0) sceKernelStartThread(video_thid, 0, NULL);
while (!connected) { sceCtrlReadBufferPositive(&pad, 1); if (pad.Buttons) connected = 1; }
// Wait for camera to be aligned to playing area and for game to start.
while (running && (!aligned || menu)) {
// Uncomment the following lines to include analog stick and button input during alignment.
/*sceCtrlPeekBufferPositive(&pad, 1);
xx = pad.Lx - 128; yy = pad.Ly - 128;
nubspeed = sqrt((xx * xx) + (yy * yy)) / (2 * sqrt(sqrt((xx * xx) + (yy * yy))));
if (xx > 30) cursorx += nubspeed; else if (xx < -30) cursorx -= nubspeed;
if (yy > 30) cursory += nubspeed; else if (yy < -30) cursory -= nubspeed;
if (cursorx > 480) cursorx = 480; else if (cursorx < 0) cursorx = 0;
if (cursory > 272) cursory = 272; else if (cursory < 0) cursory = 0;
// Detect changes in button input.
if (pad.Buttons != oldpad.Buttons) {
}
oldpad.Buttons = pad.Buttons;*/
sceKernelDelayThread(50000);
}
int x;
// Initialize global data.
_highScore = 0;
_score = 0;
_ballCount = 0;
_resBalls = START_RES_BALLS;
_gameState = GAME_RUNNING;
_pauseSem = sceKernelCreateSema("PauseSem", 0, 1, 1, 0);
// Initialize array used to keep track of balls in play.
for (x = 0; x < MAX_BALLS; x++) { _activeBalls[x] = 0; }
// Initialize the paddle
(&_paddle)->h = 60;
(&_paddle)->w = 8;
(&_paddle)->xPos = 3;
(&_paddle)->yPos = 136;
(&_paddle)->xPosOld = 250;
(&_paddle)->yPosOld = 250;
(&_paddle)->speed = 10;
(&_paddle)->dir = 1;
(&_paddle)->color = COLOR_LIGHT_BLUE;
while (running) {
// Uncomment the following lines to include analog stick and button input.
// Defeats the purpose as holding the PSP or touching it shakes the camera
// and makes the laser pointer input very inaccurate. Could be useful with
// the PSP remote control to allow games to be played using the remote
// for D-Pad movement and the laser pointer for looking/aiming.
/*sceCtrlPeekBufferPositive(&pad, 1);
xx = pad.Lx - 128; yy = pad.Ly - 128;
nubspeed = sqrt((xx * xx) + (yy * yy)) / (2 * sqrt(sqrt((xx * xx) + (yy * yy))));
if (xx > 30) cursorx += nubspeed; else if (xx < -30) cursorx -= nubspeed;
if (yy > 30) cursory += nubspeed; else if (yy < -30) cursory -= nubspeed;
if (cursorx > 480) cursorx = 480; else if (cursorx < 0) cursorx = 0;
if (cursory > 272) cursory = 272; else if (cursory < 0) cursory = 0;
// Detect changes in button input.
if (pad.Buttons != oldpad.Buttons) {
}
oldpad.Buttons = pad.Buttons;*/
// Change sprite speeds, positions and behaviors here.
CreateBall(); // Create a ball and put it in play.
while (_gameState == GAME_RUNNING) { CheckUserInput(); }
while (_gameState == GAME_CONTINUE) { sceKernelDelayThread(2000); }
while (_gameState == GAME_OVER) { sceKernelDelayThread(2000); }
sceKernelDelayThread(200);
//CreateBall(); // Create a ball and put it in play.
}
StopApp();
sceKernelExitGame();
return 0;
}
int main(int argc, char* argv[]) {
/* Setup Homebutton Callbacks */
setupCallbacks();
sceKernelDcacheWritebackAll();
// setup GU
SceCtrlData pad;
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_DIGITAL);
sceGuInit();
sceGuStart(GU_DIRECT,list);
sceGuDrawBuffer(GU_PSM_8888,(void*)0,BUF_WIDTH);
sceGuDispBuffer(SCR_WIDTH,SCR_HEIGHT,(void*)0x88000,BUF_WIDTH);
sceGuDepthBuffer((void*)0x110000,BUF_WIDTH);
sceGuOffset(2048 - (SCR_WIDTH/2),2048 - (SCR_HEIGHT/2));
sceGuViewport(2048,2048,SCR_WIDTH,SCR_HEIGHT);
sceGuDepthRange(0xc350,0x2710);
sceGuScissor(0,0,SCR_WIDTH,SCR_HEIGHT);
sceGuEnable(GU_SCISSOR_TEST);
sceGuDepthFunc(GU_GEQUAL);
sceGuEnable(GU_DEPTH_TEST);
sceGuFrontFace(GU_CCW);
sceGuColor(0xffffffff);
sceGuShadeModel(GU_SMOOTH);
// sceGuEnable(GU_CULL_FACE);
sceGuEnable(GU_CLIP_PLANES);
sceGuEnable(GU_TEXTURE_2D);
sceGuTexMode(GU_PSM_8888, 0, 0, 0);
sceGuTexImage(0, 16, 16, 16, texture);
sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGB);
sceGuTexEnvColor(0xffffff);
sceGuTexFilter(GU_LINEAR, GU_LINEAR);
sceGuTexWrap(GU_REPEAT, GU_REPEAT);
sceGuTexScale(1.0f, 1.0f);
sceGuTexOffset(0.0f, 0.0f);
sceGuAmbientColor(0xffffffff);
sceGuFinish();
sceGuSync(0,0);
sceDisplayWaitVblankStart();
sceGuDisplay(GU_TRUE);
void* buffer = 0;
pspDebugScreenInit();
unsigned int old = 0;
unsigned int flags = PSP_CTRL_CIRCLE | PSP_CTRL_CROSS;
int tex = 1;
while(running()) {
sceGuStart(GU_DIRECT,list);
sceGuClearColor(0);
sceGuClearDepth(0);
sceGuClear(GU_COLOR_BUFFER_BIT | GU_DEPTH_BUFFER_BIT);
sceGumMatrixMode(GU_PROJECTION);
sceGumLoadIdentity();
sceGumPerspective(90.0f, 480.0/272.0f, 0.1f, 10.0f);
sceGumMatrixMode(GU_VIEW);
sceGumLoadIdentity();
ScePspFVector3 trans = { 0.0f, 0.0f, -1.8f };
sceGumTranslate(&trans);
sceGumMatrixMode(GU_MODEL);
sceGumLoadIdentity();
sceGumDrawArray(objects[o].prim, objects[o].flags, objects[o].count, 0, objects[o].data);
sceCtrlReadBufferPositive(&pad, 1);
if(old != pad.Buttons) {
if(pad.Buttons & PSP_CTRL_CROSS) {
o++;
if(o >= sizeof(objects) / sizeof(Object)) {
o = 0;
}
}
if(pad.Buttons & PSP_CTRL_CIRCLE) {
tex = !tex;
if(tex) {
sceGuEnable(GU_TEXTURE_2D);
} else {
sceGuDisable(GU_TEXTURE_2D);
}
}
}
old = pad.Buttons;
sceGuFinish();
sceGuSync(0,0);
pspDebugScreenSetOffset((int)buffer);
pspDebugScreenSetXY(0, 0);
pspDebugScreenPrintf("Mode: %s (X to change) Texture: %s (O to change)", objects[o].text, tex ? "on " : "off");
sceDisplayWaitVblankStart();
buffer = sceGuSwapBuffers();
}
sceGuTerm();
sceKernelExitGame();
return 0;
}
int main(int argc, char *argv[])
{
SceCtrlData pad;
int result;
int oldButtons = 0;
pspDebugScreenInit();
if (argc > 0) {
printf("Bootpath: %s\n", argv[0]);
}
printf("Triangle - Exit\n");
printf("Square - Set lower 16-bits\n");
printf("Circle - Clear lower 16-bits\n");
printf("Cross - Delay + refer status\n");
printf("R-Trigger - Cancel event flag\n\n");
printf("L-Trigger - Delete event flag\n\n");
SetupCallbacks();
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
evid = sceKernelCreateEventFlag("test_ef", PSP_EVENT_WAITMULTIPLE, INITIAL_PATTERN, 0);
//evid = sceKernelCreateEventFlag("test_ef", 0, INITIAL_PATTERN, 0);
printf("EVID: %08x pattern %08x\n", evid, INITIAL_PATTERN);
if (evid >= 0)
{
createStartThread("and", and_thread);
createStartThread("or", or_thread);
createStartThread("clear", clear_thread);
#if 0
// testing context switch timing
sceKernelSetEventFlag(evid, 0x0000FFFF);
//int buf[64]; for(;;) sceCtrlReadLatch(buf); // sceCtrlReadLatch does not context switch
for(;;) sceKernelDelayThread(0); // does not wait forever
#else
while(!done)
{
sceCtrlReadBufferPositive(&pad, 1); // context switch in here
int buttonDown = (oldButtons ^ pad.Buttons) & pad.Buttons;
if (buttonDown & PSP_CTRL_SQUARE)
{
result = sceKernelSetEventFlag(evid, 0x0000FFFF);
printf("\nsceKernelSetEventFlag result %08x\n", result);
printSceKernelEventFlagInfo(evid);
}
if (buttonDown & PSP_CTRL_CIRCLE)
{
//result = sceKernelClearEventFlag(evid, 0x0000FFFF); // bits to clear - bad
result = sceKernelClearEventFlag(evid, 0xFFFF0000); // bits to keep - ok
printf("\nsceKernelClearEventFlag result %08x\n", result);
printSceKernelEventFlagInfo(evid);
}
if (buttonDown & PSP_CTRL_CROSS)
{
printf("\nsceKernelDelayThreadCB ...\n");
sceKernelDelayThreadCB(1000);
printSceKernelEventFlagInfo(evid);
}
if (buttonDown & PSP_CTRL_RTRIGGER)
{
//result = sceKernelCancelEventFlag(evid, newPattern, addr);
result = sceKernelCancelEventFlag(evid, INITIAL_PATTERN, 0);
printf("sceKernelCancelEventFlag result %08x\n", result);
printSceKernelEventFlagInfo(evid);
}
if (buttonDown & PSP_CTRL_LTRIGGER)
{
//result = sceKernelCancelEventFlag(evid, newPattern, addr);
result = sceKernelDeleteEventFlag(evid);
printf("sceKernelDeleteEventFlag result %08x\n", result);
evid = 0;
}
if (buttonDown & PSP_CTRL_TRIANGLE)
done = 1;
oldButtons = pad.Buttons;
//sceKernelDelayThread(0); // ok, not infinite :)
}
#endif
}
else
{
printf("sceKernelCreateEventFlag failed %08x\n", evid);
sceKernelSleepThreadCB();
}
sceKernelExitGame();
return 0;
}
int main_thread(SceSize args, void *argp) {
sceKernelDelayThread(3000000);
u32 keycombination;
SceCtrlData pad;
u32 oldButtons = 0;
int extra = 0;
keycombination = PSP_CTRL_RTRIGGER; //Button to start interpreter (Basic)
u32 keycombination2 = PSP_CTRL_RTRIGGER + PSP_CTRL_LTRIGGER; // Button to start interpreter (Extra PSP Go)
while(1){
oldButtons = pad.Buttons;
if (go==0){
sceCtrlPeekBufferPositive(&pad, 1);
if(oldButtons != pad.Buttons)
{
if(pad.Buttons & keycombination2)
{
pauseGame(thid1);
go=1;
extra=1;
pspDebugScreenInit();
pspDebugScreenClear();
oldButtons = pad.Buttons;
}else if(pad.Buttons & keycombination)
{
pauseGame(thid1);
go=1;
pspDebugScreenInit();
pspDebugScreenClear();
oldButtons = pad.Buttons;
}
}
}
if (go ==1){
pspDebugScreenSetXY(0,0);
pspDebugScreenSetTextColor(0xffffff);
int go2=1;
SceUID id;
if (((kuKernelGetModel() + 1) == 4) || ((kuKernelGetModel() + 1) == 5)){
if (extra==1){
id = sceIoDopen("ms0:/seplugins/script"); //PSP Go MS Support
}else{
id = sceIoDopen("ef0:/seplugins/script"); //PSP Go Internal HD Support
}
}else{
id = sceIoDopen("ms0:/seplugins/script");
}
SceIoDirent entry;
int script_files = -2;
memset(&entry, 0, sizeof(SceIoDirent));
while (sceIoDread(id, &entry) > 0)
{
script_files = script_files+1;
memset(&entry, 0, sizeof(SceIoDirent));
}
sceIoDclose(id);
char script[256];
if (((kuKernelGetModel() + 1) == 4) || ((kuKernelGetModel() + 1) == 5)){
if (extra==1){
strcpy(script,"ms0:/seplugins/script/index.lua"); //PSP Go MS Support
}else{
strcpy(script,"ef0:/seplugins/script/index.lua"); //PSP Go Internal HD Support
}
}else{
strcpy(script,"ms0:/seplugins/script/index.lua");
}
while(go2==1)
{
const char *errMsg;
if (script_files>1){
errMsg = runScript(extralibs, true);
}else{
SceUID fp = sceIoOpen(script, PSP_O_RDONLY,0777);
int size = sceIoLseek(fp, 0, SEEK_END);
sceIoLseek(fp, 0, SEEK_SET);
unsigned char *buffer;
buffer = malloc((size+1) * sizeof (char));
sceIoRead(fp, buffer, size);
buffer[size]=0;
sceIoClose(fp);
errMsg = runScript(buffer, true);
free(buffer);
}
// System.restart sourcecode
if (strstr(errMsg, "lpp_restart")){
go2=0;
// End System.restart sources
// Temp replacing for loadfile/dofile functions: System.protodofile
}else if (strstr(errMsg, "lpp_open")){
char dum1[20], dum2[20], dum3[20];
char script_path2[256];
sscanf( errMsg, "%s %s %s %s", dum1, dum2, dum3, script_path2 );
strcpy(script,script_path2);
script_files=1;
// End System.protodofile sources
}else if (strstr(errMsg, "resumeThread")){
go=0;
go2=0;
}else{
if (errMsg != NULL);
{
pspDebugScreenClear();
pspDebugScreenSetTextColor(0xffffff);
debugOutput("\nError: %s\n", errMsg);
}
debugOutput("\nPress start to restart\nPress select to resume thread\n");
SceCtrlData pad;
int restore = 0;
while(restore==0){
sceCtrlPeekBufferPositive(&pad, 1);
if (pad.Buttons&PSP_CTRL_START){
restore=1;
go2=0;
}
if (pad.Buttons&PSP_CTRL_SELECT){
resumeGame(thid1);
restore=1;
go=0;
go2=0;
}
}
}
}
}
sceDisplayWaitVblankStart();
}
sceKernelSleepThread();
return 0;
}
/* Our default handler in case nothing else is installed */
static void _pspDebugDefaultHandler(PspDebugRegBlock *regs)
{
pspDebugScreenInit();
pspDebugDumpException(regs);
}
int main()
{
pspDebugScreenInit();
pspDebugScreenSetBackColor(0xFF0000);
pspDebugScreenSetTextColor(0x00FFFF);
pspDebugScreenClear();
printf("Recovery Mode by Dark_Alex, in-eboot by BlackSith\n\n\n\n");
printf("Press start to activate USB Mass.\n");
printf("Press triangle to flash ms0:/index.dat to flash0.\n");
printf("Press cross to start the program under ms0:/PSP/GAME/UPDATE/EBOOT.PBP\n");
printf("Press home to exit.\n\n\n\n");
sceIoUnassign("flash0:");
sceIoAssign("flash0:", "lflash0:0,0", "flashfat0:", IOASSIGN_RDWR, NULL, 0);
while (1)
{
SceCtrlData pad;
int keyprocessed = 0;
sceCtrlReadBufferPositive(&pad, 1);
if (pad.Buttons & PSP_CTRL_START)
{
start_usb();
printf("Usb started.\n");
keyprocessed = 1;
}
else if (pad.Buttons & PSP_CTRL_TRIANGLE)
{
if (copy_file("ms0:/index.dat", "flash0:/vsh/etc/index.dat") < 0)
printf("Cannot copy file. (file missing?).\n");
else
printf("File copied succesfully.\n");
keyprocessed = 1;
}
else if (pad.Buttons & PSP_CTRL_CROSS)
{
struct SceKernelLoadExecParam param;
memset(¶m, 0, sizeof(param));
param.size = sizeof(param);
param.args = strlen(PROGRAM)+1;
param.argp = PROGRAM;
param.key = "updater";
printf("Starting program...\n");
sceKernelLoadExec(PROGRAM, ¶m);
keyprocessed = 1;
}
else if (pad.Buttons & PSP_CTRL_HOME)
{
break;
}
sceKernelDelayThread((keyprocessed) ? 200000 : 50000);
}
sceKernelExitGame();
return 0;
}
int main(void)
{
int err = 0;
scePowerSetClockFrequency(333, 333, 166);
pspDebugScreenInit();
printf("#### PSCRYPTER v2.0 by Carlosgs ####\nEncrypt EBOOT.PBP files directly from the PSP\nUses the code made by 'bbtgp' and parts of the PSPSDK\nv2.0 added realocation fixing by JJS\nTHANK YOU!\n\n");
sceIoMkdir("./sign/", 0777);
chdir("./sign/");
sceIoRemove("EBOOT_signed.PBP");
sceIoRemove("param.sfo");
sceIoRemove("icon0.png");
sceIoRemove("icon1.pmf");
sceIoRemove("pic0.png");
sceIoRemove("pic1.png");
sceIoRemove("snd0.at3");
sceIoRemove("data.psp");
sceIoRemove("data_unsigned.psp");
sceIoRemove("data.psar");
printf("Unpacking EBOOT file...\n");
err = main_unpack_pbp();
if(err != 0)
{
printf("Error while unpacking: %d\n",err);
myexit();
}
printf("\nFixing PRX realocations...\n");
err = main_fix_realocations();
if(err != 0)
{
printf("Error while fixing realocations: %d\n",err);
myexit();
}
printf("\nCrypting PRX file...\n");
err = main_crypter();
if(err != 0)
{
printf("Error while crypting: %d\n",err);
myexit();
}
printf("\nPacking new EBOOT file...\n");
err = main_pack_pbp(10, filename_list);
if(err != 0)
{
printf("Error while packing: %d\n",err);
myexit();
}
printf("\n\nFinished! Hope it works!\n");
myexit();
return 0;
}
int main(int argc, char* argv[])
{
setupCallbacks();
int i, j;
// Load emd mesh from file
EMD_MESH* mesh = EMD_LoadMeshFromFile("scene.emd");
int vert_count = EMD_GetVertexCount(mesh);
int idx_count = 0;
int elem_count = EMD_GetElementCount(mesh);
for (i=0; i<elem_count; i++)
{
idx_count += EMD_GetIndexCount(mesh, i);
}
VERTEX* vert_buf = (VERTEX*)memalign(16, sizeof(VERTEX) * vert_count);
GW_UINT16* idx_buf = (GW_UINT16*)memalign(16, sizeof(GW_UINT16) * idx_count);
for (i=0; i<vert_count; i++)
{
EMD_GetVertexByIndex(mesh, i, &vert_buf[i].x, &vert_buf[i].y, &vert_buf[i].z);
EMD_GetTexcoordByIndex(mesh, i, &vert_buf[i].u, &vert_buf[i].v);
EMD_GetNormalByIndex(mesh, i, &vert_buf[i].nx, &vert_buf[i].ny, &vert_buf[i].nz);
//vert_buf[i].color = 0xffffffff;
}
GW_UINT32 idx_head = 0;
GW_UINT32* data;
GW_UINT32 count;
// Pack 32-bit index into 16-bit buffer
for (i=0; i<elem_count; i++)
{
count = EMD_GetIndexCount(mesh, i);
data = EMD_GetIndexArray(mesh, i);
for (j=0; j<count; j++)
{
idx_buf[j + idx_head] = (GW_UINT16)data[j];
}
idx_head += count;
}
EMD_FreeMesh(mesh);
// flush cache so that no stray data remains
sceKernelDcacheWritebackAll();
// setup GU
void* fbp0 = getStaticVramBuffer(BUF_WIDTH,SCR_HEIGHT,GU_PSM_8888);
void* fbp1 = getStaticVramBuffer(BUF_WIDTH,SCR_HEIGHT,GU_PSM_8888);
void* zbp = getStaticVramBuffer(BUF_WIDTH,SCR_HEIGHT,GU_PSM_4444);
pspDebugScreenInit();
sceGuInit();
sceGuStart(GU_DIRECT,list);
sceGuDrawBuffer(GU_PSM_8888,fbp0,BUF_WIDTH);
sceGuDispBuffer(SCR_WIDTH,SCR_HEIGHT,fbp1,BUF_WIDTH);
sceGuDepthBuffer(zbp,BUF_WIDTH);
sceGuOffset(2048 - (SCR_WIDTH/2),2048 - (SCR_HEIGHT/2));
sceGuViewport(2048,2048,SCR_WIDTH,SCR_HEIGHT);
sceGuDepthRange(65535,0);
sceGuScissor(0,0,SCR_WIDTH,SCR_HEIGHT);
sceGuEnable(GU_SCISSOR_TEST);
sceGuDepthFunc(GU_GEQUAL);
sceGuEnable(GU_DEPTH_TEST);
sceGuFrontFace(GU_CCW);
sceGuShadeModel(GU_SMOOTH);
sceGuEnable(GU_CULL_FACE);
//sceGuDisable(GU_TEXTURE_2D);
sceGuEnable(GU_CLIP_PLANES);
sceGuEnable(GU_LIGHTING);
sceGuEnable(GU_LIGHT0);
sceGuEnable(GU_LIGHT1);
sceGuFinish();
sceGuSync(0,0);
sceDisplayWaitVblankStart();
sceGuDisplay(GU_TRUE);
// run sample
int val = 0;
while(running())
{
sceGuStart(GU_DIRECT,list);
// clear screen
sceGuClearColor(0xff554433);
sceGuClearDepth(0);
sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT);
// setup lights
ScePspFVector3 light_dir = { 1.0f, 1.0f, 1.0f };
// GU_DIRECTIONAL
// GU_POINTLIGHT
sceGuLight(0, GU_POINTLIGHT, GU_DIFFUSE, &light_dir);
sceGuLightColor(0, GU_DIFFUSE, 0xffffffff);
sceGuAmbient(0x00202020);
light_dir.x = -light_dir.x;
light_dir.y = -light_dir.y;
light_dir.z = -light_dir.z;
sceGuLight(1, GU_DIRECTIONAL, GU_DIFFUSE_AND_SPECULAR, &light_dir);
sceGuLightColor(1, GU_DIFFUSE, 0xff7f7f7f);
// setup matrices for cube
sceGumMatrixMode(GU_PROJECTION);
sceGumLoadIdentity();
sceGumPerspective(75.0f,16.0f/9.0f,0.5f,1000.0f);
sceGumMatrixMode(GU_VIEW);
sceGumLoadIdentity();
sceGumMatrixMode(GU_MODEL);
sceGumLoadIdentity();
{
ScePspFVector3 pos = { 0, 0, -5.0f };
ScePspFVector3 rot = { val * 0.79f * (GU_PI/180.0f), val * 0.98f * (GU_PI/180.0f), val * 1.32f * (GU_PI/180.0f) };
sceGumTranslate(&pos);
sceGumRotateXYZ(&rot);
}
// setup texture
//sceGuTexMode(GU_PSM_4444,0,0,0);
// sceGuTexImage(0,64,64,64,logo_start);
//sceGuTexFunc(GU_TFX_ADD,GU_TCC_RGB);
//sceGuTexEnvColor(0xffff00);
//sceGuTexFilter(GU_LINEAR,GU_LINEAR);
//sceGuTexScale(1.0f,1.0f);
//sceGuTexOffset(0.0f,0.0f);
//sceGuAmbientColor(0xff7f7f7f);
// draw cube
sceGuColor(0xffffff);
sceGumDrawArray(GU_TRIANGLES, GU_TEXTURE_32BITF|GU_NORMAL_32BITF|GU_VERTEX_32BITF|GU_INDEX_16BIT|GU_TRANSFORM_3D,
idx_count, idx_buf, vert_buf);
pspDebugScreenSetXY(0, 0);
pspDebugScreenPrintf("v: %d", vert_count);
pspDebugScreenSetXY(0, 1);
pspDebugScreenPrintf("i: %d", idx_count);
sceGuFinish();
sceGuSync(0,0);
sceDisplayWaitVblankStart();
sceGuSwapBuffers();
val++;
}
sceGuTerm();
// Release buffers
free(vert_buf);
free(idx_buf);
sceKernelExitGame();
return 0;
}
//entry point
int main(int argc, char * argv[])
{
pspDebugScreenInit();
psp_fw_version = sceKernelDevkitVersion();
#if defined(CONFIG_660) || defined(CONFIG_661)
if((psp_fw_version == FW_660) || (psp_fw_version == FW_661)) {
goto version_OK;
}
#endif
#ifdef CONFIG_639
if(psp_fw_version == FW_639) {
goto version_OK;
}
#endif
#ifdef CONFIG_620
if(psp_fw_version == FW_620) {
goto version_OK;
}
#endif
#ifdef CONFIG_635
if(psp_fw_version == FW_635) {
goto version_OK;
}
#endif
pspDebugScreenPrintf("Sorry. This program doesn't support your FW(0x%08X).\n", (uint)psp_fw_version);
sceKernelDelayThread(5*1000000);
goto exit;
version_OK:
setup_patch_offset_table(psp_fw_version);
//puzzle installer path
strcpy(installerpath, argv[0]);
char * slash = strrchr(installerpath, '/');
if (slash) slash[1] = '\0';
write_files(installerpath);
strcat(installerpath, "installer.prx");
printk_init("ms0:/launcher.txt");
printk("Hello exploit\n");
if(sctrlHENGetVersion() >= 0) {
install_in_cfw();
return 0;
}
#if defined(CONFIG_660) || defined(CONFIG_661)
if((psp_fw_version == FW_660) || (psp_fw_version == FW_661)) {
do_exploit_660();
}
#endif
#ifdef CONFIG_639
if(psp_fw_version == FW_639) {
do_exploit_639();
}
#endif
#if defined(CONFIG_620) || defined(CONFIG_635)
if(psp_fw_version == FW_620 || psp_fw_version == FW_635) {
do_exploit();
}
#endif
exit:
//trigger reboot
sceKernelExitGame();
//kill thread
sceKernelExitDeleteThread(0);
//return
return 0;
}
int adhocInit(char *MatchingData)
{
char mac[6];
struct productStruct product;
ClearPspList();
strcpy(product.product, "ULUS99999");
product.unknown = 0;
u32 err;
printf2("sceNetInit()\n");
err = sceNetInit(0x20000, 0x20, 0x1000, 0x20, 0x1000);
if (err != 0)
return err;
g_NetInit = true;
printf2("sceNetAdhocInit()\n");
err = sceNetAdhocInit();
if (err != 0)
return err;
g_NetAdhocInit = true;
printf2("sceNetAdhocctlInit()\n");
err = sceNetAdhocctlInit(0x2000, 0x20, &product);
if (err != 0)
return err;
g_NetAdhocctlInit = true;
// Connect
err = sceNetAdhocctlConnect("");
if (err != 0)
return err;
g_NetAdhocctlConnect = true;
int stateLast = -1;
printf2("Connecting...\n");
while (1)
{
int state;
err = sceNetAdhocctlGetState(&state);
if (err != 0)
{
pspDebugScreenInit();
printf("sceNetApctlGetState returns $%x\n", err);
sceKernelDelayThread(10*1000000); // 10sec to read before exit
return -1;
}
if (state > stateLast)
{
sprintf(temp," connection state %d of 1\n", state);
printf2(temp);
stateLast = state;
}
if (state == 1)
break; // connected
// wait a little before polling again
sceKernelDelayThread(50*1000); // 50ms
}
printf2("Connected!\n");
sceWlanGetEtherAddr(mac);
printf2("sceNetAdhocPdpCreate\n");
pdpId = sceNetAdhocPdpCreate(mac,
0x309, // 0x309 in lumines
0x400, // 0x400 in lumines
0); // 0 in lumines
if(pdpId <= 0)
{
pspDebugScreenInit();
printf("pdpId = %x\n", pdpId);
return -1;
}
g_NetAdhocPdpCreate = true;
printf2("sceNetAdhocMatchingInit()\n");
err = sceNetAdhocMatchingInit(0x20000);
if(err != 0)
{
pspDebugScreenInit();
printf("error = %x\n", err);
}
g_NetAdhocMatchingInit = true;
printf2("sceNetAdhocMatchingCreate()\n");
matchingId = sceNetAdhocMatchingCreate( 3,
0xa,
0x22b,
0x800,
0x2dc6c0,
0x5b8d80,
3,
0x7a120,
matchingCallback);
if(matchingId < 0)
{
sprintf(temp,"matchingId = %x\n", matchingId);
printf2(temp);
}
g_NetAdhocMatchingCreate = true;
/*char tempStr[100];
tempStr[0] = '\0';
if(strlen(MatchingData))
{
strncpy(tempStr, strrchr(MatchingData, '/')+1, 100);
strrchr(tempStr, '.')[0] = '\0';
}*
printf("tempStr=%s\n", tempStr);*/
printf2("sceNetAdhocMatchingStart()\n");
err = sceNetAdhocMatchingStart(matchingId, // 1 in lumines (presuming what is returned from create)
0x10, // 0x10
0x2000, // 0x2000
0x10, // 0x10
0x2000, // 0x2000
strlen(MatchingData)+1,
MatchingData);
if(err != 0)
{
pspDebugScreenInit();
printf("error = %x\n", err);
}
g_NetAdhocMatchingStart = true;
// All the init functions have passed
return 0;
}
int main(int argc, char *argv[])
{
SceUID thid;
int error;
void *data;
pspDebugScreenInit();
if (argc > 0) {
printf("Bootpath: %s\n", argv[0]);
}
SetupCallbacks();
/* Create a messagebox */
myMessagebox = sceKernelCreateMbx("pspSDK-testMBX", 0, 0);
printf("MAIN: created messagebox %08x\n", myMessagebox);
/* Create a task that will post in the messagebox */
thid = sceKernelCreateThread("subthread", SubThread, 17, 8192, THREAD_ATTR_USER, 0);
sceKernelStartThread(thid, 0, NULL);
printf("MAIN: started task %08x\n", thid);
/* Wait for a message */
printf("MAIN: waiting for message\n");
error = sceKernelReceiveMbx(myMessagebox, &data, NULL);
if(error < 0)
printf("MAIN: ERROR %08x\n", error);
else
printf("MAIN: got message: \"%s\"\n", ((MyMessage *)data)->text);
/* Wait for a message with timeout */
printf("MAIN: waiting with timeout (will fail the first couple of times)\n");
for(;;) {
SceUInt timeout = 300000; /* microseconds */
error = sceKernelReceiveMbx(myMessagebox, &data, &timeout);
if(error < 0)
printf("MAIN: ERROR %08x\n", error);
else {
printf("MAIN: got message: \"%s\" (timeout remaining %d us)\n",
((MyMessage *)data)->text, timeout);
break;
}
}
/* Poll for messages */
printf("MAIN: polling for message (non-blocking)\n");
for(;;) {
error = sceKernelPollMbx(myMessagebox, &data);
if(error < 0) {
printf("MAIN: ERROR %08x\n", error);
/* Sleep for a little while to give the message
a chance to arrive */
sceKernelDelayThread(300000);
} else {
printf("MAIN: got message: \"%s\"\n", ((MyMessage *)data)->text);
break;
}
}
/* This call to sceKernelReceiveMbx() will be interrupted
by the sub task without a message being sent */
printf("MAIN: waiting for a message that will not arrive\n");
error = sceKernelReceiveMbx(myMessagebox, &data, NULL);
if(error < 0)
printf("MAIN: ERROR %08x\n", error);
else
printf("MAIN: got message: \"%s\"\n", ((MyMessage *)data)->text);
/* Prepare to shutdown */
printf("MAIN: waiting for sub task to exit\n");
sceKernelWaitThreadEnd(thid, NULL);
printf("MAIN: sub task exited, deleting messagebox\n");
error = sceKernelDeleteMbx(myMessagebox);
if(error < 0)
printf("MAIN: ERROR %08x\n", error);
else
printf("MAIN: all done\n");
sceKernelSleepThread();
return 0;
}
// The order that procedures are called was taken by patching
// Lumines network procs
int adhocTerm()
{
u32 err;
if(g_NetAdhocctlConnect)
{
printf2("sceNetAdhocctlDisconnect\n");
err = sceNetAdhocctlDisconnect();
if(err != 0)
{
pspDebugScreenInit();
printf(" returned %x\n", err);
}
g_NetAdhocctlConnect = false;
}
if(g_NetAdhocPdpCreate)
{
printf2("sceNetAdhocPdpDelete\n");
err = sceNetAdhocPdpDelete(pdpId,0);
if(err != 0)
{
pspDebugScreenInit();
printf("sceNetAdhocPdpDelete returned %x\n", err);
}
g_NetAdhocPdpCreate = false;
}
if(g_NetAdhocMatchingStart)
{
printf2("sceNetAdhocMatchingStop\n");
err = sceNetAdhocMatchingStop(matchingId);
if(err != 0)
{
pspDebugScreenInit();
printf("sceNetAdhocMatchingStop returned %x\n", err);
}
g_NetAdhocMatchingStart = false;
}
if(g_NetAdhocMatchingCreate)
{
printf2("sceNetAdhocMatchingDelete\n");
err = sceNetAdhocMatchingDelete(matchingId);
if(err != 0)
{
pspDebugScreenInit();
printf("sceNetAdhocMatchingDelete returned %x\n", err);
}
g_NetAdhocMatchingCreate = false;
}
if(g_NetAdhocMatchingInit)
{
printf2("sceNetAdhocMatchingTerm\n");
err = sceNetAdhocMatchingTerm();
if(err != 0)
{
pspDebugScreenInit();
printf("sceNetAdhocMatchingTerm returned %x\n", err);
}
g_NetAdhocMatchingInit = false;
}
if(g_NetAdhocctlInit)
{
printf2("sceNetAdhocctlTerm\n");
err = sceNetAdhocctlTerm();
if(err != 0)
{
pspDebugScreenInit();
printf("sceNetAdhocctlTerm returned %x\n", err);
}
g_NetAdhocctlInit = false;
}
if(g_NetAdhocInit)
{
printf2("sceNetAdhocTerm\n");
err = sceNetAdhocTerm();
if(err != 0)
{
pspDebugScreenInit();
printf("sceNetAdhocTerm returned %x\n", err);
}
g_NetAdhocInit = false;
}
if(g_NetInit)
{
printf2("sceNetTerm\n");
err = sceNetTerm();
if(err != 0)
{
pspDebugScreenInit();
printf("sceNetTerm returned %x\n", err);
}
g_NetInit = false;
}
return 0; // assume it worked
}
int main(int argc, char* argv[])
{
pspDebugScreenInit();
setupCallbacks();
// setup GU
void* fbp0 = getStaticVramBuffer(BUF_WIDTH,SCR_HEIGHT,GU_PSM_8888);
void* fbp1 = getStaticVramBuffer(BUF_WIDTH,SCR_HEIGHT,GU_PSM_8888);
void* zbp = getStaticVramBuffer(BUF_WIDTH,SCR_HEIGHT,GU_PSM_4444);
sceGuInit();
sceGuStart(GU_DIRECT,list);
sceGuDrawBuffer(GU_PSM_8888,fbp0,BUF_WIDTH);
sceGuDispBuffer(SCR_WIDTH,SCR_HEIGHT,fbp1,BUF_WIDTH);
sceGuDepthBuffer(zbp,BUF_WIDTH);
sceGuOffset(2048 - (SCR_WIDTH/2),2048 - (SCR_HEIGHT/2));
sceGuViewport(2048,2048,SCR_WIDTH,SCR_HEIGHT);
sceGuDepthRange(65535,0);
sceGuScissor(0,0,SCR_WIDTH,SCR_HEIGHT);
sceGuEnable(GU_SCISSOR_TEST);
sceGuFinish();
sceGuSync(0,0);
sceDisplayWaitVblankStart();
sceGuDisplay(GU_TRUE);
int val = 0;
gettimeofday(&base_time,0);
while(running())
{
struct Vertex* vertices;
struct timeval tv;
sceGuStart(GU_DIRECT,list);
// clear screen
sceGuClearColor(0);
sceGuClearDepth(0);
sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT);
// draw triangle 1 (normal)
sceGuColor(0xffffffff);
vertices = (struct Vertex*)sceGuGetMemory(3*sizeof(struct Vertex));
vertices[0].x = (SCR_WIDTH/2) + cosf(val * (GU_PI/180)) * (SCR_HEIGHT/2);
vertices[0].y = (SCR_HEIGHT/2) + sinf(val * (GU_PI/180)) * (SCR_HEIGHT/2);
vertices[0].z = 0;
vertices[1].x = (SCR_WIDTH/2) + cosf((val+120) * (GU_PI/180)) * (SCR_HEIGHT/2);
vertices[1].y = (SCR_HEIGHT/2) + sinf((val+120) * (GU_PI/180)) * (SCR_HEIGHT/2);
vertices[1].z = 0;
vertices[2].x = (SCR_WIDTH/2) + cosf((val+240) * (GU_PI/180)) * (SCR_HEIGHT/2);
vertices[2].y = (SCR_HEIGHT/2) + sinf((val+240) * (GU_PI/180)) * (SCR_HEIGHT/2);
vertices[2].z = 0;
sceGuDrawArray(GU_TRIANGLES,GU_VERTEX_32BITF|GU_TRANSFORM_2D,3,0,vertices);
// draw triangle 2 (affected by logic op)
sceGuEnable(GU_COLOR_LOGIC_OP);
sceGuLogicalOp(curr_state);
sceGuColor(0xffff00ff);
vertices = (struct Vertex*)sceGuGetMemory(3*sizeof(struct Vertex));
vertices[0].x = (SCR_WIDTH/2) + cosf((val*1.1f) * (GU_PI/180)) * (SCR_HEIGHT/2);
vertices[0].y = (SCR_HEIGHT/2) + sinf((val*1.1f) * (GU_PI/180)) * (SCR_HEIGHT/2);
vertices[0].z = 0;
vertices[1].x = (SCR_WIDTH/2) + cosf((val*1.1f+120) * (GU_PI/180)) * (SCR_HEIGHT/2);
vertices[1].y = (SCR_HEIGHT/2) + sinf((val*1.1f+120) * (GU_PI/180)) * (SCR_HEIGHT/2);
vertices[1].z = 0;
vertices[2].x = (SCR_WIDTH/2) + cosf((val*1.1f+240) * (GU_PI/180)) * (SCR_HEIGHT/2);
vertices[2].y = (SCR_HEIGHT/2) + sinf((val*1.1f+240) * (GU_PI/180)) * (SCR_HEIGHT/2);
vertices[2].z = 0;
sceGuDrawArray(GU_TRIANGLES,GU_VERTEX_32BITF|GU_TRANSFORM_2D,3,0,vertices);
sceGuDisable(GU_COLOR_LOGIC_OP);
sceGuFinish();
sceGuSync(0,0);
gettimeofday(&tv,0);
if ((tv.tv_sec-base_time.tv_sec) > TIME_SLICE)
{
curr_state = (curr_state + 1) & 15;
base_time = tv;
}
sceDisplayWaitVblankStart();
sceGuSwapBuffers();
pspDebugScreenSetXY(0,0);
pspDebugScreenPrintf("%s",names[curr_state]);
val++;
}
sceGuTerm();
sceKernelExitGame();
return 0;
}
int main(int argc, char **argv)
{
SceCtrlData pad;
int oldButtons = 0;
int useVblank = 1;
pspDebugScreenInit();
if (argc > 0) {
printf("Bootpath: %s\n", argv[0]);
}
printf("Triangle - Exit\n");
printf("Square - Toggle vblank (60 fps limit)\n");
printf("\n");
SetupCallbacks();
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
sceRtcGetCurrentTick( &fpsTickLast );
tickResolution = sceRtcGetTickResolution();
printGetDayOfWeek();
printf("\n");
printGetDaysInMonth();
printf("\n");
printSetTick();
printf("\n");
printGetTick();
printf("\n");
printf("sceRtcGetTickResolution: %d", (int)tickResolution);
while(!done)
{
sceCtrlPeekBufferPositive(&pad, 1);
int buttonDown = (oldButtons ^ pad.Buttons) & pad.Buttons;
if (buttonDown & PSP_CTRL_SQUARE)
{
useVblank ^= 1;
}
if (buttonDown & PSP_CTRL_TRIANGLE)
done = 1;
oldButtons = pad.Buttons;
updateDrawFPS();
if (useVblank)
sceDisplayWaitVblankStart();
fbp0 = sceGuSwapBuffers();
}
sceKernelExitGame(); // Quits Application
return 0;
}
int main()
{
pspDebugScreenInit();
int devkit = sceKernelDevkitVersion(),
cursor = 0;
if(devkit != 0x06060010)
Exit("This program supports only 6.60!");
printf("USB Mod Flasher\n\n");
setcolor(RED);
printf("This Mod is only for the TN-V8 eCFW for the PS Vita!");
setcolor(WHITE);
printf("\n\n\n\n\n\n\n\n\n\n\n\nCredits:\nXMB Mod by The Z\nInstaller Port by KanadeEngel\n\nSpecial Thanks to:\nfrostegater");
while(1)
{
if(cursor > 2)
cursor = 0;
else if(cursor < 0)
cursor = 2;
if(cursor == 0) setbcolor(GRAY);
printfc(3, 4, " Install XMB Mod. ");
setbcolor(BLACK);
if(cursor == 1) setbcolor(GRAY);
printfc(3, 5, " Restore Original Files. ");
setbcolor(BLACK);
if(cursor == 2) setbcolor(GRAY);
printfc(3, 6, " Exit. ");
setbcolor(BLACK);
int i;
for(i = 0; i < 4; i++)
printfc(1, 4 + i, " ");
setcolor(BLUE);
printfc(1, 4 + cursor, ">");
unsigned int Buttons = wait_press(PSP_CTRL_CROSS | PSP_CTRL_UP | PSP_CTRL_DOWN);
wait_release(PSP_CTRL_CROSS | PSP_CTRL_UP | PSP_CTRL_DOWN);
SceCtrlData pad;
sceCtrlReadBufferPositive(&pad, 1);
if(Buttons & PSP_CTRL_CROSS)
{
if(cursor != 2)
{
setc(0, 9);
if(assign_flash_zero() < 0)
Exit("\n Error in 'flash0:/' assign.");
{
if(cursor == 0)//Install Mod Module
{
flash_file("flash0:/vsh/resource/topmenu_icon.rco", _660_install_X_icon, size__660_install_X_icon);
}
else if(cursor == 1)//Restore Original Module
flash_file("flash0:/vsh/resource/topmenu_icon.rco", _660_original_X_icon, size__660_original_X_icon);
}
}
else
Exit("");
break;
}
else if(Buttons & PSP_CTRL_UP)
cursor--;
else if(Buttons & PSP_CTRL_DOWN)
cursor++;
}
Exit("Done.");
sceKernelExitGame();
return 0;
}
int main(int argc, char *argv[])
{
SceCtrlData pad;
int oldButtons = 0;
int i;
#define SECOND 1000000
#define REPEAT_START (1 * SECOND)
#define REPEAT_DELAY (SECOND / 5)
struct timeval repeatStart;
struct timeval repeatDelay;
repeatStart.tv_sec = 0;
repeatStart.tv_usec = 0;
repeatDelay.tv_sec = 0;
repeatDelay.tv_usec = 0;
for (i = 0; i < SAMPLE_SIZE; i += 2)
{
buffer1[i+0] = 0x00;
buffer1[i+1] = 0x70;
buffer2[i+0] = 0x00;
buffer2[i+1] = 0x10;
}
pspDebugScreenInit();
printf("Triangle - Exit\n");
printf("Cross - Test Blocking Audio\n");
printf("Square - Test non-Blocking Audio\n");
printf("Circle - Test Audio2\n");
channel = sceAudioChReserve(PSP_AUDIO_NEXT_CHANNEL, SAMPLE_SIZE, PSP_AUDIO_FORMAT_STEREO);
if (channel < 0)
{
sceKernelExitGame();
}
while(!done)
{
sceCtrlReadBufferPositive(&pad, 1);
int buttonDown = (oldButtons ^ pad.Buttons) & pad.Buttons;
if (pad.Buttons == oldButtons)
{
struct timeval now;
gettimeofday(&now, NULL);
if (repeatStart.tv_sec == 0)
{
repeatStart.tv_sec = now.tv_sec;
repeatStart.tv_usec = now.tv_usec;
repeatDelay.tv_sec = 0;
repeatDelay.tv_usec = 0;
}
else
{
long usec = (now.tv_sec - repeatStart.tv_sec) * SECOND;
usec += (now.tv_usec - repeatStart.tv_usec);
if (usec >= REPEAT_START)
{
if (repeatDelay.tv_sec != 0)
{
usec = (now.tv_sec - repeatDelay.tv_sec) * SECOND;
usec += (now.tv_usec - repeatDelay.tv_usec);
if (usec >= REPEAT_DELAY)
{
repeatDelay.tv_sec = 0;
}
}
if (repeatDelay.tv_sec == 0)
{
buttonDown = pad.Buttons;
repeatDelay.tv_sec = now.tv_sec;
repeatDelay.tv_usec = now.tv_usec;
}
}
}
}
else
{
repeatStart.tv_sec = 0;
}
if (buttonDown & PSP_CTRL_CROSS)
{
strcpy(text, "Start Test:\n");
gettimeofday(&previousAudioOutput, NULL);
for (i = 0; i < 10; i++)
{
audioOutput(buffer1, 1);
audioOutput(buffer2, 1);
}
strcat(text, "\n");
printf(text);
}
if (buttonDown & PSP_CTRL_SQUARE)
{
strcpy(text, "Start Test:\n");
gettimeofday(&previousAudioOutput, NULL);
for (i = 0; i < 10; i++)
{
audioOutput(buffer1, 0);
audioOutput(buffer2, 0);
}
strcat(text, "\n");
printf(text);
}
if (buttonDown & PSP_CTRL_CIRCLE)
{
sceAudioOutput2Reserve(SAMPLE_SIZE / 2);
audioOutput2(buffer1, 0xFFFFF);
sceKernelDelayThread(1 * 1000000);
audioOutput2(buffer1, 0x20000);
sceKernelDelayThread(1 * 1000000);
audioOutput2(buffer1, 0x10000);
sceKernelDelayThread(1 * 1000000);
audioOutput2(buffer1, 0x08000);
sceKernelDelayThread(1 * 1000000);
audioOutput2(buffer1, 0x04000);
sceKernelDelayThread(1 * 1000000);
audioOutput2(buffer1, 0x02000);
sceKernelDelayThread(1 * 1000000);
audioOutput2(buffer1, 0x01000);
sceKernelDelayThread(1 * 1000000);
audioOutput2(buffer1, 0x00800);
}
if (buttonDown & PSP_CTRL_RIGHT)
{
}
if (buttonDown & PSP_CTRL_UP)
{
}
if (buttonDown & PSP_CTRL_DOWN)
{
}
if (buttonDown & PSP_CTRL_TRIANGLE)
{
done = 1;
}
oldButtons = pad.Buttons;
sceDisplayWaitVblank();
}
sceKernelExitGame();
return 0;
}
int main(void)
{
SceCtrlData pad, lastpad;
int maxchan = 128;
BOOL outputEnabled;
MODULE *mf = NULL;
SAMPLE *sf = NULL;
int voice = 0;
int pan = 127;
int vol = 127;
int freq = 22000;
pspDebugScreenInit();
SetupCallbacks();
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(1);
if (!MikMod_InitThreads()) {
printf("MikMod thread init failed\n");
}
MikMod_RegisterErrorHandler(my_error_handler);
/* register all the drivers */
MikMod_RegisterAllDrivers();
/* register all the module loaders */
MikMod_RegisterAllLoaders();
/* initialize the library */
md_mode = DMODE_16BITS|DMODE_STEREO|DMODE_SOFT_SNDFX|DMODE_SOFT_MUSIC;
md_reverb = 0;
md_pansep = 128;
if (MikMod_Init("")) {
printf("Could not initialize sound, reason: %s\n", MikMod_strerror(MikMod_errno));
sceKernelExitGame();
return 0;
}
MikMod_SetNumVoices(-1, 8);
/* get ready to play */
sf = Sample_Load("ms0:/sound.wav");
printf("Starting.\n");
MikMod_EnableOutput();
outputEnabled = 1;
if ((mikModThreadID = sceKernelCreateThread("MikMod" ,(void*)&AudioChannelThread,0x12,0x10000,0,NULL)) > 0) {
sceKernelStartThread(mikModThreadID, 0 , NULL);
}
else {
printf("Play thread create failed!\n");
}
sceCtrlReadBufferPositive(&lastpad, 1);
do {
sceCtrlReadBufferPositive(&pad, 1);
if(pad.Buttons != lastpad.Buttons) {
if(pad.Buttons & PSP_CTRL_CROSS) {
voice = Sample_Play(sf,0,0);
Voice_SetPanning(voice, pan);
}
if(pad.Buttons & PSP_CTRL_SQUARE) {
outputEnabled = !outputEnabled;
if(outputEnabled)
MikMod_EnableOutput();
else MikMod_DisableOutput();
}
if(pad.Buttons & PSP_CTRL_CIRCLE) {
mf = Player_Load("ms0:/MUSIC.XM", maxchan, 0);
if (NULL != mf) {
mf->wrap = 1;
Player_Start(mf);
}
}
if(pad.Buttons & PSP_CTRL_TRIANGLE) {
if (NULL != mf) {
Player_Stop();
Player_Free(mf); /* To stop the song for real, it needs to be freed. I know, weird... */
mf = NULL;
}
}
if(pad.Buttons & PSP_CTRL_SELECT)
printf("Player is %s\n", Player_Active()?"On":"Off");
lastpad = pad;
}
if(pad.Buttons & PSP_CTRL_LTRIGGER) {
Voice_SetPanning(voice, (pan<2)?pan:--pan);
printf("pan is %d\n", pan);
}
if(pad.Buttons & PSP_CTRL_RTRIGGER) {
Voice_SetPanning(voice, (pan>254)?pan:++pan);
printf("pan is %d\n", pan);
}
if(pad.Buttons & PSP_CTRL_UP) {
Voice_SetVolume(voice, (vol>254)?vol:++vol);
printf("vol is %d\n", vol);
}
if(pad.Buttons & PSP_CTRL_DOWN) {
Voice_SetVolume(voice, (vol<2)?vol:--vol);
printf("vol is %d\n", vol);
}
if(pad.Buttons & PSP_CTRL_LEFT) {
Voice_SetFrequency(voice, (freq<1001)?freq:(freq -=1000));
printf("freq is %d\n", freq);
}
if(pad.Buttons & PSP_CTRL_RIGHT) {
Voice_SetFrequency(voice, (freq>44000)?freq:(freq +=1000));
printf("freq is %d\n", freq);
}
sceDisplayWaitVblankStart();
} while(!((pad.Buttons & PSP_CTRL_START) || done));
printf("Stopping.\n");
/* allow audio thread to terminate cleanly */
done = 1;
if (mikModThreadID > 0) {
SceUInt timeout = 100000;
sceKernelWaitThreadEnd(mikModThreadID, &timeout);
/* not 100% sure if this is necessary after a clean exit,
* but just to make sure any resources are freed: */
sceKernelDeleteThread(mikModThreadID);
}
Player_Stop();
Player_Free(mf);
MikMod_Exit();
sceKernelExitGame();
return 0;
}
int main(int argc, char *argv[])
{
int i;
pspDebugScreenInit();
SceUID mod = pspSdkLoadStartModule ("flash0:/kd/chnnlsv.prx",PSP_MEMORY_PARTITION_KERNEL);
if (mod < 0) {
printf("Error 0x%08X loading/starting chnnlsv.prx.\n", mod);
}
mod = pspSdkLoadStartModule ("kernelcall.prx",PSP_MEMORY_PARTITION_KERNEL);
if (mod < 0) {
printf("Error 0x%08X loading/starting kernelcall.prx.\n", mod);
}
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
for(;;)
{
printf("====================================================================");
printf("PPSSPP Save Tool\n");
printf("====================================================================\n\n\n");
switch(currentMenu)
{
case 0:
{
int maxOption = 0;
for(i = 0; menuList0[i]; i++)
{
if(i == selectedOption)
printf(" > %s\n",menuList0[i]);
else
printf(" %s\n",menuList0[i]);
maxOption++;
}
int input = ProcessInput(maxOption, &selectedOption);
if(input == 0)
{
currentMenu = 1;
selectedOption = 0;
}
else if(input == 1)
{
currentMenu = 4;
selectedOption = 0;
}
else if(input == 2)
{
sceKernelExitGame();
}
}
break;
case 4:
case 1:
{
int maxOption = 0;
printf("PPSSPP Decrypted Save Directory : \n");
for(i = 0; menuList1[i]; i++)
{
if(i == selectedOption)
printf(" > %s\n",menuList1[i]);
else
printf(" %s\n",menuList1[i]);
maxOption++;
}
int input = ProcessInput(maxOption, &selectedOption);
if(input == maxOption-1)
{
if(currentMenu == 1)
selectedOption = 0;
else
selectedOption = 1;
currentMenu = 0;
}
else if(input >= 0)
{
basePath = selectedOption;
if(currentMenu == 1)
{
currentMenu = 2;
UpdateValidDir(1);
}
else
{
currentMenu = 5;
UpdateValidDir(0);
}
selectedOption = 0;
}
}
break;
case 5:
case 2:
{
int maxOption = 0;
if(currentMenu == 2)
printf("Save to encrypt : \n");
else
printf("Save to decrypt : \n");
if(numDirList == 0)
{
printf("No compatible data, see README for help on use\n");
}
for(i = 0; i < numDirList; i++)
{
if(i == selectedOption)
printf(" > %s\n",dirList[i].name);
else
printf(" %s\n",dirList[i].name);
maxOption++;
}
for(i = 0; menuList2[i]; i++)
{
if((i+numDirList) == selectedOption)
printf(" > %s\n",menuList2[i]);
else
printf(" %s\n",menuList2[i]);
maxOption++;
}
printf("\n Invalid path : \n");
for(i = 0; i < numInvalidDirList && i < (22-numDirList); i++)
{
switch(invalidDirList[i].errorId)
{
case 1:
printf(" %s : ENCRYPT_INFO.BIN not found\n",invalidDirList[i].name);
break;
case 2:
printf(" %s : ENCRYPT_INFO.BIN read error\n",invalidDirList[i].name);
break;
case 3:
printf(" %s : ENCRYPT_INFO.BIN wrong version\n",invalidDirList[i].name);
break;
case 4:
printf(" %s : PARAM.SFO not found\n",invalidDirList[i].name);
break;
case 5:
printf(" %s : PARAM.SFO read error\n",invalidDirList[i].name);
break;
case 6:
printf(" %s : SAVEDATA_FILE_LIST not found in PARAM.SFO\n",invalidDirList[i].name);
break;
case 7:
printf(" %s : no save name in SAVEDATA_FILE_LIST\n",invalidDirList[i].name);
break;
case 8:
printf(" %s : no save found\n",invalidDirList[i].name);
break;
default:
break;
}
}
int input = ProcessInput(maxOption, &selectedOption);
if(input == numDirList)
{
if(currentMenu == 2)
currentMenu = 1;
else
currentMenu = 4;
selectedOption = basePath;
}
else if(input >= 0)
{
if(currentMenu == 2)
currentMenu = 3;
else
currentMenu = 6;
workDir = input;
selectedOption = 0;
}
}
break;
case 6:
case 3:
{
EncryptFileInfo encryptInfo;
if(FileRead(menuList1[basePath], dirList[workDir].name, "ENCRYPT_INFO.BIN",(u8*)&encryptInfo,sizeof(encryptInfo)) < 0)
{
printf("Can't read encrypt file\n");
}
else
{
printf("Key : ");
for(i = 0; i < 16; i++)
printf(" %02x",(u8)encryptInfo.key[i]);
printf("\n");
printf("SDK Version : 0x%x\n",encryptInfo.sdkVersion);
char srcPath[128];
char dstPath[128];
if(currentMenu == 3)
{
sprintf(srcPath,"%s%s",menuList1[basePath], dirList[workDir].name);
sprintf(dstPath,"ms0:/PSP/SAVEDATA/%s",dirList[workDir].name);
sceIoMkdir(dstPath,0777);
}
else
{
sprintf(srcPath,"ms0:/PSP/SAVEDATA/%s",dirList[workDir].name);
sprintf(dstPath,"%s%s",menuList1[basePath], dirList[workDir].name);
}
int dfd;
dfd = sceIoDopen(srcPath);
if(dfd >= 0)
{
SceIoDirent dirinfo;
while(sceIoDread(dfd, &dirinfo) > 0)
{
if(!(dirinfo.d_stat.st_mode & 0x2000)) // is not a file
continue;
if(strcmp(dirinfo.d_name,"ENCRYPT_INFO.BIN") == 0) // don't copy encrypt info
continue;
FileCopy(srcPath, dstPath, dirinfo.d_name);
}
sceIoDclose(dfd);
}
if(currentMenu == 3)
{
char decryptedFile[258], encryptedFile[258], srcSFO[258], dstSFO[258];
sprintf(decryptedFile,"%s/%s",srcPath ,dirList[workDir].saveFile);
sprintf(srcSFO,"%s/PARAM.SFO",srcPath);
sprintf(encryptedFile,"%s/%s",dstPath ,dirList[workDir].saveFile);
sprintf(dstSFO,"%s/PARAM.SFO",dstPath);
printf("Encoding %s into %s\n",decryptedFile, encryptedFile);
int ret = encrypt_file(decryptedFile,
encryptedFile,
dirList[workDir].saveFile,
srcSFO,
dstSFO,
encryptInfo.key[0] != 0 ? encryptInfo.key : NULL,
GetSDKMainVersion(encryptInfo.sdkVersion)
);
if(ret < 0) {
printf("Error: encrypt_file() returned %d\n\n", ret);
} else {
printf("Successfully wrote %d bytes to\n", ret);
printf(" %s\n", encryptedFile);
printf("and updated hashes in\n");
printf(" %s\n\n", dstSFO);
}
}
else
{
char decryptedFile[258], encryptedFile[258];
sprintf(encryptedFile,"%s/%s",srcPath ,dirList[workDir].saveFile);
sprintf(decryptedFile,"%s/%s",dstPath ,dirList[workDir].saveFile);
printf("Decoding %s into %s\n",encryptedFile, decryptedFile);
int ret = decrypt_file(decryptedFile, encryptedFile, encryptInfo.key[0] != 0 ? encryptInfo.key : NULL, GetSDKMainVersion(encryptInfo.sdkVersion));
if(ret < 0) {
printf("Error: decrypt_file() returned %d\n\n", ret);
} else {
printf("Successfully wrote %d bytes to\n", ret);
printf(" %s\n", decryptedFile);
}
}
printf(" > Back\n");
int input = ProcessInput(1, &selectedOption);
if(input >= 0)
{
if(currentMenu == 3)
currentMenu = 2;
else
currentMenu = 5;
selectedOption = 0;
}
}
}
break;
default:
sceKernelExitGame();
break;
}
pspDebugScreenClear();
sceDisplayWaitVblankStart();
sceGuSwapBuffers();
}
return 0;
}
//*************************************************************************************
//
//*************************************************************************************
static bool Initialize()
{
strcpy(gDaedalusExePath, DAEDALUS_PSP_PATH( "" ));
printf( "Cpu was: %dMHz, Bus: %dMHz\n", scePowerGetCpuClockFrequency(), scePowerGetBusClockFrequency() );
if (scePowerSetClockFrequency(333, 333, 166) != 0)
{
printf( "Could not set CPU to 333MHz\n" );
}
printf( "Cpu now: %dMHz, Bus: %dMHz\n", scePowerGetCpuClockFrequency(), scePowerGetBusClockFrequency() );
// Set up our Kernel Home button
//ToDo: This doesn't work properly for Vita, there's no longer a "home" button available
InitHomeButton();
// If (o) is pressed during boot the Emulator will use 32bit
// else use default 16bit color mode
SceCtrlData pad;
sceCtrlPeekBufferPositive(&pad, 1);
if( pad.Buttons & PSP_CTRL_CIRCLE ) g32bitColorMode = true;
else g32bitColorMode = false;
// Check for unsupported FW >=4.01 (We use M33 SDK 4.01)
// Otherwise PSP model can't be detected correctly
DaedalusFWCheck();
// Initiate MediaEngine
//Note: Media Engine is not available for Vita
bool bMeStarted = InitialiseJobManager();
// Disable for profiling
// srand(time(0));
//Set the debug output to default
if( g32bitColorMode ) pspDebugScreenInit();
else pspDebugScreenInitEx( NULL , GU_PSM_5650, 1); //Sets debug output to 16bit mode
// This Breaks gdb, better disable it in debug build
//
#ifndef DAEDALUS_DEBUG_CONSOLE
initExceptionHandler();
#endif
_DisableFPUExceptions();
//Init Panic button thread
SetupPanic();
// Init volatile memory
VolatileMemInit();
#ifdef DAEDALUS_CALLBACKS
//Set up callback for our thread
SetupCallbacks();
#endif
//Set up the DveMgr (TV Display) and Detect PSP Slim /3K/ Go
if ( kuKernelGetModel() > PSP_MODEL_STANDARD )
{
// Can't use extra memory if ME isn't available
if( bMeStarted )
PSP_IS_SLIM = true;
HAVE_DVE = CModule::Load("dvemgr.prx");
if (HAVE_DVE >= 0)
PSP_TV_CABLE = pspDveMgrCheckVideoOut();
if (PSP_TV_CABLE == 1)
PSP_TV_LACED = 1; // composite cable => interlaced
else if( PSP_TV_CABLE == 0 )
CModule::Unload( HAVE_DVE ); // Stop and unload dvemgr.prx since if no video cable is connected
}
HAVE_DVE = (HAVE_DVE < 0) ? 0 : 1; // 0 == no dvemgr, 1 == dvemgr
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
// Init the savegame directory
strcpy( g_DaedalusConfig.mSaveDir, DAEDALUS_PSP_PATH( "SaveGames/" ) );
if (!System_Init())
return false;
return true;
}