int main(int argc, char *argv[]) {
checkpoint(" Create test file 1: %08x", makeTestFile("ms0:/__iorename_test1.txt"));
checkpoint(" Create test file 2: %08x", makeTestFile("ms0:/__iorename_test2.txt"));
checkpoint(" Create test file 3: %08x", makeTestFile("ms0:/__iorename_test3.txt"));
checkpointNext("Rename behavior:");
checkpoint(" sceIoChdir host0:/: %08x", sceIoChdir("host0:/"));
checkpoint(" sceIoRename abs -> abs: %08x", sceIoRename("ms0:/__iorename_test1.txt", "ms0:/__iorename_test1a.txt"));
checkpoint(" sceIoRename abs -> abs overwrite: %08x", sceIoRename("ms0:/__iorename_test1a.txt", "ms0:/__iorename_test2.txt"));
checkpoint(" sceIoChdir ms0:/PSP: %08x", sceIoChdir("ms0:/PSP"));
checkpoint(" sceIoRename rel -> rel: %08x", sceIoRename("../__iorename_test2.txt", "__iorename_test2a.txt"));
checkpoint(" renamed to: %s", fileExists("ms0:/__iorename_test2a.txt") ? "origin dir" : (fileExists("ms0:/PSP/__iorename_test2a.txt") ? "cwd" : "nowhere?"));
checkpoint(" sceIoRename rel -> abs: %08x", sceIoRename("../__iorename_test3.txt", "ms0:/PSP/__iorename_test3a.txt"));
checkpoint(" renamed to: %s", fileExists("ms0:/__iorename_test3a.txt") ? "origin dir" : (fileExists("ms0:/PSP/__iorename_test3a.txt") ? "dest dir" : "nowhere?"));
// Okay, we've moved everything around a lot, let's clean it up.
sceIoRemove("ms0:/__iorename_test1.txt");
sceIoRemove("ms0:/__iorename_test1a.txt");
sceIoRemove("ms0:/__iorename_test2.txt");
sceIoRemove("ms0:/__iorename_test2a.txt");
sceIoRemove("ms0:/__iorename_test3.txt");
sceIoRemove("ms0:/__iorename_test3a.txt");
sceIoRemove("ms0:/PSP/__iorename_test2a.txt");
sceIoRemove("ms0:/PSP/__iorename_test3a.txt");
checkpointNext("Error handling:");
checkpoint(" Recreate test file 1: %08x", makeTestFile("ms0:/__iorename_test1.txt"));
checkpoint(" Recreate test file 2: %08x", makeTestFile("ms0:/__iorename_test2.txt"));
checkpoint(" sceIoRename cross device: %08x", sceIoRename("ms0:/__iorename_test1.txt", "host0:/__iorename_test1.txt"));
checkpoint(" sceIoRename bad dest path: %08x", sceIoRename("ms0:/__iorename_test2.txt", "ms0:/__DOES_NOT_EXIST/__iorename_test2.txt"));
checkpoint(" sceIoRename bad src path: %08x", sceIoRename("ms0:/_DOES_NOT_EXIST/__iorename_test3.txt", "ms0:/__iorename_test3.txt"));
checkpoint(" sceIoRename bad src file: %08x", sceIoRename("ms0:/__iorename_test3.txt", "ms0:/__iorename_test3a.txt"));
checkpoint(" sceIoRename same path: %08x", sceIoRename("ms0:/__iorename_test1.txt", "ms0:/__iorename_test1.txt"));
// Crash.
//checkpoint(" sceIoRename NULL -> rel", sceIoRename(NULL, "test.txt"));
//checkpoint(" sceIoRename rel -> NULL", sceIoRename("test.txt", NULL));
//checkpoint(" sceIoRename NULL -> NULL", sceIoRename(NULL, NULL));
checkpoint(" sceIoRename wild -> rel: %08x", sceIoRename("ms0:/__iorename_test*.txt", "ms0:/__iorename_test1a.txt"));
checkpoint(" sceIoRename rel -> wild: %08x", sceIoRename("ms0:/__iorename_test1.txt", "ms0:/__iorename_test*.txt"));
checkpoint(" sceIoRename wild -> wild: %08x", sceIoRename("ms0:/__iorename_test?.txt", "ms0:/__iorename_test?.txt"));
sceIoRemove("ms0:/__iorename_test1.txt");
sceIoRemove("ms0:/__iorename_test2.txt");
sceIoRemove("host0:/__iorename_test1.txt");
return 0;
}
void psp_init(void)
{
SceUID thid;
char buff[128], *r;
/* fw 1.5 sometimes returns 8002032c, although getcwd works */
r = getcwd(buff, sizeof(buff));
if (r) sceIoChdir(buff);
main_thread_id = sceKernelGetThreadId();
lprintf("running on %08x kernel\n", sceKernelDevkitVersion()),
lprintf("entered psp_init, threadId %08x, priority %i\n", main_thread_id,
sceKernelGetThreadCurrentPriority());
thid = sceKernelCreateThread("update_thread", callback_thread, 0x11, 0xFA0, 0, NULL);
if (thid >= 0)
{
sceKernelStartThread(thid, 0, 0);
}
/* video */
sceDisplaySetMode(0, 480, 272);
sceDisplaySetFrameBuf(VRAM_FB1, 512, PSP_DISPLAY_PIXEL_FORMAT_565, PSP_DISPLAY_SETBUF_NEXTFRAME);
current_screen = 1;
psp_screen = VRAM_FB0;
/* gu */
sceGuInit();
sceGuStart(GU_DIRECT, guCmdList);
sceGuDrawBuffer(GU_PSM_5650, (void *)VRAMOFFS_FB0, 512);
sceGuDispBuffer(480, 272, (void *)VRAMOFFS_FB1, 512); // don't care
sceGuClear(GU_COLOR_BUFFER_BIT | GU_DEPTH_BUFFER_BIT);
sceGuDepthBuffer((void *)VRAMOFFS_DEPTH, 512);
sceGuOffset(2048 - (480 / 2), 2048 - (272 / 2));
sceGuViewport(2048, 2048, 480, 272);
sceGuDepthRange(0xc350, 0x2710);
sceGuScissor(0, 0, 480, 272);
sceGuEnable(GU_SCISSOR_TEST);
sceGuDepthMask(0xffff);
sceGuDisable(GU_DEPTH_TEST);
sceGuFrontFace(GU_CW);
sceGuEnable(GU_TEXTURE_2D);
sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGB);
sceGuAmbientColor(0xffffffff);
sceGuColor(0xffffffff);
sceGuFinish();
sceGuSync(0, 0);
sceDisplayWaitVblankStart();
sceGuDisplay(GU_TRUE);
/* input */
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
}
int dispThread(SceSize args, void *argp)
{
sceIoChdir(cwd);
initBackground();
while (exit_state != EXCEPTION)
{
if (exit_state)
{
setFadeMode(&main_fade,FADE_IN,0);
if (getFadeState(&main_fade) == FADE_DONE) break;
}
if (checkGameState(GSQUARE))
{
g2dClear(BLACK);
dispgSquare();
}
if (checkGameState(BANNER))
{
g2dClear(BLACK);
dispBanner();
}
if (checkGameState(MENU))
{
drawMovingBackground();
dispMenu();
}
if (checkGameState(INGAME))
{
drawMovingBackground();
camera();
drawLevel();
drawUI();
}
if (checkGameState(LEVEL_TITLE))
{
g2dClear(WHITE);
intraFontSetStyle(seriffont,1.f,BLACK,0,0,INTRAFONT_ALIGN_CENTER);
intraFontPrint(seriffont,G2D_SCR_W/2,G2D_SCR_H/2,lvl.title);
}
if (checkGameState(END))
{
g2dClear(WHITE);
g2dBeginRects(img.end);
{
g2dAdd();
}
g2dEnd();
}
drawFade(&main_fade);
g2dFlip(G2D_VSYNC);
}
if (exit_state == EXCEPTION) dispException();
return 0;
}
/**
* Main.
*
* Initialises SDL and launches game.
*/
int main(int argc, char *argv[]) {
int ret;
// Early platform init
#ifdef PSP
pspDebugScreenInit();
atexit(sceKernelExitGame);
sceIoChdir("ms0:/PSP/GAME/OpenJazz");
#elif defined(WII)
fatInitDefault();
Wii_SetConsole();
#endif
// Initialise SDL
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER | SDL_INIT_JOYSTICK) < 0) {
logError("Could not start SDL", SDL_GetError());
return -1;
}
// Load configuration and establish a window
try {
startUp(argc, argv);
} catch (int e) {
SDL_Quit();
return -1;
}
// Play the opening cutscene, run the main menu, etc.
ret = play();
// Save configuration and shut down
shutDown();
SDL_Quit();
return ret;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Private functions:
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Decode thread:
int decodeThread(SceSize args, void *argp){
int res;
unsigned char MP3ME_header_buf[4];
int MP3ME_header;
int version;
int bitrate;
int padding;
int frame_size;
int size;
int total_size;
int offset = 0;
sceAudiocodecReleaseEDRAM(MP3ME_codec_buffer); //Fix: ReleaseEDRAM at the end is not enough to play another mp3.
MP3ME_threadActive = 1;
OutputBuffer_flip = 0;
OutputPtrME = OutputBuffer[0];
sceIoChdir(audioCurrentDir);
MP3ME_handle = sceIoOpen(MP3ME_fileName, PSP_O_RDONLY, 0777);
if (MP3ME_handle < 0)
MP3ME_threadActive = 0;
//now search for the first sync byte, tells us where the mp3 stream starts
total_size = sceIoLseek32(MP3ME_handle, 0, PSP_SEEK_END);
size = total_size;
sceIoLseek32(MP3ME_handle, 0, PSP_SEEK_SET);
data_start = ID3v2TagSize(MP3ME_fileName);
sceIoLseek32(MP3ME_handle, data_start, PSP_SEEK_SET);
data_start = SeekNextFrameMP3(MP3ME_handle);
if (data_start < 0)
MP3ME_threadActive = 0;
size -= data_start;
memset(MP3ME_codec_buffer, 0, sizeof(MP3ME_codec_buffer));
memset(MP3ME_input_buffer, 0, sizeof(MP3ME_input_buffer));
memset(MP3ME_output_buffer, 0, sizeof(MP3ME_output_buffer));
if ( sceAudiocodecCheckNeedMem(MP3ME_codec_buffer, 0x1002) < 0 )
MP3ME_threadActive = 0;
if ( sceAudiocodecGetEDRAM(MP3ME_codec_buffer, 0x1002) < 0 )
MP3ME_threadActive = 0;
getEDRAM = 1;
if ( sceAudiocodecInit(MP3ME_codec_buffer, 0x1002) < 0 )
MP3ME_threadActive = 0;
MP3ME_eof = 0;
MP3ME_info.framesDecoded = 0;
while (MP3ME_threadActive){
while( !MP3ME_eof && MP3ME_isPlaying )
{
MP3ME_filePos = sceIoLseek32(MP3ME_handle, 0, PSP_SEEK_CUR);
if ( sceIoRead( MP3ME_handle, MP3ME_header_buf, 4 ) != 4 ){
MP3ME_isPlaying = 0;
MP3ME_threadActive = 0;
continue;
}
MP3ME_header = MP3ME_header_buf[0];
MP3ME_header = (MP3ME_header<<8) | MP3ME_header_buf[1];
MP3ME_header = (MP3ME_header<<8) | MP3ME_header_buf[2];
MP3ME_header = (MP3ME_header<<8) | MP3ME_header_buf[3];
bitrate = (MP3ME_header & 0xf000) >> 12;
padding = (MP3ME_header & 0x200) >> 9;
version = (MP3ME_header & 0x180000) >> 19;
samplerate = samplerates[version][ (MP3ME_header & 0xC00) >> 10 ];
if ((bitrate > 14) || (version == 1) || (samplerate == 0) || (bitrate == 0))//invalid frame, look for the next one
{
data_start = SeekNextFrameMP3(MP3ME_handle);
if(data_start < 0)
{
MP3ME_eof = 1;
continue;
}
size -= (data_start - offset);
offset = data_start;
continue;
}
if (version == 3) //mpeg-1
{
sample_per_frame = 1152;
frame_size = 144000*bitrates[bitrate]/samplerate + padding;
MP3ME_info.instantBitrate = bitrates[bitrate] * 1000;
}else{
sample_per_frame = 576;
frame_size = 72000*bitrates_v2[bitrate]/samplerate + padding;
MP3ME_info.instantBitrate = bitrates_v2[bitrate] * 1000;
}
sceIoLseek32(MP3ME_handle, data_start, PSP_SEEK_SET); //seek back
if (MP3ME_newFilePos >= 0)
{
if (!MP3ME_newFilePos)
MP3ME_newFilePos = ID3v2TagSize(MP3ME_fileName);
long old_start = data_start;
if (sceIoLseek32(MP3ME_handle, MP3ME_newFilePos, PSP_SEEK_SET) != old_start){
data_start = SeekNextFrameMP3(MP3ME_handle);
if(data_start < 0){
MP3ME_eof = 1;
}
MP3ME_playingTime = (float)data_start / (float)frame_size / (float)samplerate / 1000.0f;
offset = data_start;
size = total_size - data_start;
}
MP3ME_newFilePos = -1;
continue;
}
size -= frame_size;
if ( size <= 0)
{
MP3ME_eof = 1;
continue;
}
//since we check for eof above, this can only happen when the file
// handle has been invalidated by syspend/resume/usb
if ( sceIoRead( MP3ME_handle, MP3ME_input_buffer, frame_size ) != frame_size ){
//Resume from suspend:
if ( MP3ME_handle >= 0 ){
sceIoClose(MP3ME_handle);
MP3ME_handle = -1;
}
MP3ME_handle = sceIoOpen(MP3ME_fileName, PSP_O_RDONLY, 0777);
if (MP3ME_handle < 0){
MP3ME_isPlaying = 0;
MP3ME_threadActive = 0;
continue;
}
size = sceIoLseek32(MP3ME_handle, 0, PSP_SEEK_END);
sceIoLseek32(MP3ME_handle, offset, PSP_SEEK_SET);
data_start = offset;
continue;
}
data_start += frame_size;
offset = data_start;
MP3ME_codec_buffer[6] = (unsigned long)MP3ME_input_buffer;
MP3ME_codec_buffer[8] = (unsigned long)MP3ME_output_buffer;
MP3ME_codec_buffer[7] = MP3ME_codec_buffer[10] = frame_size;
MP3ME_codec_buffer[9] = sample_per_frame * 4;
res = sceAudiocodecDecode(MP3ME_codec_buffer, 0x1002);
if ( res < 0 )
{
//instead of quitting see if the next frame can be decoded
//helps play files with an invalid frame
//we must look for a valid frame, the offset above may be wrong
data_start = SeekNextFrameMP3(MP3ME_handle);
if(data_start < 0)
{
MP3ME_eof = 1;
continue;
}
size -= (data_start - offset);
offset = data_start;
continue;
}
MP3ME_playingTime += (float)sample_per_frame/(float)samplerate;
MP3ME_info.framesDecoded++;
//Output:
memcpy( OutputPtrME, MP3ME_output_buffer, sample_per_frame*4);
OutputPtrME += (sample_per_frame * 4);
if( OutputPtrME + (sample_per_frame * 4) > &OutputBuffer[OutputBuffer_flip][OUTPUT_BUFFER_SIZE])
{
//Volume Boost:
if (MP3ME_volume_boost){
int i;
for (i=0; i<OUTPUT_BUFFER_SIZE; i++){
OutputBuffer[OutputBuffer_flip][i] = volume_boost(&OutputBuffer[OutputBuffer_flip][i], &MP3ME_volume_boost);
}
}
audioOutput(MP3ME_volume, OutputBuffer[OutputBuffer_flip]);
OutputBuffer_flip ^= 1;
OutputPtrME = OutputBuffer[OutputBuffer_flip];
//Check for playing speed:
if (MP3ME_playingSpeed){
long old_start = data_start;
if (sceIoLseek32(MP3ME_handle, frame_size * MP3ME_playingSpeed, PSP_SEEK_CUR) != old_start){
data_start = SeekNextFrameMP3(MP3ME_handle);
if(data_start < 0){
MP3ME_eof = 1;
continue;
}
float framesSkipped = (float)abs(old_start - data_start) / (float)frame_size;
if (MP3ME_playingSpeed > 0)
MP3ME_playingTime += framesSkipped * (float)sample_per_frame/(float)samplerate;
else
MP3ME_playingTime -= framesSkipped * (float)sample_per_frame/(float)samplerate;
offset = data_start;
size = total_size - data_start;
}else
MP3ME_setPlayingSpeed(0);
}
}
}
sceKernelDelayThread(10000);
}
if (getEDRAM)
sceAudiocodecReleaseEDRAM(MP3ME_codec_buffer);
if ( MP3ME_handle >= 0){
sceIoClose(MP3ME_handle);
MP3ME_handle = -1;
}
sceKernelExitThread(0);
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Private functions:
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Decode thread:
int AACdecodeThread(SceSize args, void *argp){
u8* aac_data_buffer = NULL;
u32 aac_data_start;
u8 aac_getEDRAM;
u32 aac_channels;
u32 aac_samplerate;
sceAudiocodecReleaseEDRAM(aac_codec_buffer);
sceIoChdir(audioCurrentDir);
AAC_threadActive = 1;
AAC_handle = sceIoOpen(AAC_fileName, PSP_O_RDONLY, 0777);
if ( ! AAC_handle ){
AAC_threadActive = 0;
goto end;
}
aac_output_index = 0;
aac_channels = 2;
aac_samplerate = AAC_info.hz;
aac_data_start = 0;
if (AAC_tagsize > 0)
aac_data_start = AAC_tagsize + 10;
sceIoLseek32(AAC_handle, aac_data_start, PSP_SEEK_SET);
aac_data_start = SeekNextFrameMP3(AAC_handle);
memset(aac_codec_buffer, 0, sizeof(aac_codec_buffer));
if ( sceAudiocodecCheckNeedMem(aac_codec_buffer, 0x1003) < 0 ){
AAC_threadActive = 0;
goto end;
}
if ( sceAudiocodecGetEDRAM(aac_codec_buffer, 0x1003) < 0 ){
AAC_threadActive = 0;
goto end;
}
aac_getEDRAM = 1;
aac_codec_buffer[10] = aac_samplerate;
if ( sceAudiocodecInit(aac_codec_buffer, 0x1003) < 0 ){
AAC_threadActive = 0;
goto end;
}
int samplesdecoded;
AAC_eof = 0;
unsigned char aac_header_buf[7];
int skip = 0;
while (AAC_threadActive){
while( !AAC_eof && AAC_isPlaying ){
memset(aac_mix_buffer, 0, aac_sample_per_frame*2*2);
if ( sceIoRead( AAC_handle, aac_header_buf, 7 ) != 7 ) {
AAC_eof = 1;
continue;
}
int aac_header = aac_header_buf[3];
aac_header = (aac_header<<8) | aac_header_buf[4];
aac_header = (aac_header<<8) | aac_header_buf[5];
aac_header = (aac_header<<8) | aac_header_buf[6];
int frame_size = aac_header & 67100672;
frame_size = frame_size >> 13;
frame_size = frame_size - 7;
if ( aac_data_buffer ){
free(aac_data_buffer);
aac_data_buffer = NULL;
}
aac_data_buffer = (u8*)memalign(64, frame_size);
if (AAC_newFilePos >= 0)
{
if (!AAC_newFilePos)
AAC_newFilePos = AAC_tagsize + 10;
u32 old_start = aac_data_start;
if (sceIoLseek32(AAC_handle, AAC_newFilePos, PSP_SEEK_SET) != old_start){
aac_data_start = SeekNextFrameMP3(AAC_handle);
if(aac_data_start < 0){
AAC_eof = 1;
}
AAC_playingTime = (float)aac_data_start / (float)frame_size / (float)aac_samplerate / 1000.0f;
}
AAC_newFilePos = -1;
continue;
}
//Check for playing speed:
if (AAC_playingSpeed){
if (skip){
u32 old_start = aac_data_start;
if (sceIoLseek32(AAC_handle, frame_size / 4 * AAC_playingSpeed, PSP_SEEK_CUR) != old_start){
aac_data_start = SeekNextFrameMP3(AAC_handle);
if(aac_data_start < 0){
AAC_eof = 1;
continue;
}
AAC_filePos = aac_data_start;
float framesSkipped = (float)aac_data_start / (float)frame_size;
AAC_playingTime = framesSkipped * (float)aac_sample_per_frame/(float)aac_samplerate;
}else
AAC_setPlayingSpeed(0);
skip = !skip;
continue;
}
skip = !skip;
}
if ( sceIoRead( AAC_handle, aac_data_buffer, frame_size ) != frame_size ) {
AAC_eof = 1;
continue;
}
aac_data_start += (frame_size+7);
AAC_filePos = aac_data_start;
aac_codec_buffer[6] = (unsigned long)aac_data_buffer;
aac_codec_buffer[8] = (unsigned long)aac_mix_buffer;
aac_codec_buffer[7] = frame_size;
aac_codec_buffer[9] = aac_sample_per_frame * 4;
int res = sceAudiocodecDecode(aac_codec_buffer, 0x1003);
if ( res < 0 ) {
AAC_eof = 1;
continue;
}
memcpy(aac_output_buffer[aac_output_index], aac_mix_buffer, aac_sample_per_frame*4);
//Volume Boost:
if (AAC_volume_boost){
int i;
for (i=0; i<aac_sample_per_frame * 2; i++){
aac_output_buffer[aac_output_index][i] = volume_boost(&aac_output_buffer[aac_output_index][i], &AAC_volume_boost);
}
}
audioOutput(AAC_volume, aac_output_buffer[aac_output_index]);
aac_output_index = (aac_output_index+1)%4;
samplesdecoded = aac_sample_per_frame;
AAC_playingTime += (float)aac_sample_per_frame/(float)aac_samplerate;
AAC_info.framesDecoded++;
}
sceKernelDelayThread(10000);
}
end:
if ( AAC_handle )
sceIoClose(AAC_handle);
if ( aac_data_buffer)
{
free(aac_data_buffer);
aac_data_buffer = NULL;
}
if ( aac_getEDRAM )
sceAudiocodecReleaseEDRAM(aac_codec_buffer);
sceKernelExitThread(0);
return 0;
}
int FileManager::ChangeDir(const char* path)
{
return sceIoChdir(path);
}
