int parseDiff( const char * file, tSceModule * mod )
{
int off = inCtf( file );
if ( off < 0 )
{
log( "there's no patch for %s\n", file );
return 0;
}
int ctf = sceIoOpen( cxmb_theme_file, PSP_O_RDONLY, 0644 );
if ( ctf < 0 )
{
log( "no ctf file found!\n" );
return -1;
}
sceIoLseek( ctf, ctf_header[off].start, PSP_SEEK_SET );
log( "patch %s!\nstart: %08x\nsize: %08x\n", file, ctf_header[off].start, ctf_header[off].size );
unsigned int attr[2];
int i = 0;
while( i < ctf_header[off].size )
{
sceIoRead( ctf, attr, 8 );
sceIoRead( ctf, ( void * )( mod->text_addr + attr[0] ), attr[1] );
i ++;
}
sceIoClose( ctf );
sceKernelIcacheInvalidateAll();
sceKernelDcacheWritebackInvalidateAll();
log( "%s patched!\n", file );
return 0;
}
static int neogeo_init(void)
{
SceUID fd;
char path[MAX_PATH];
sprintf(path, "%smemcard/%s.bin", launchDir, game_name);
if ((fd = sceIoOpen(path, PSP_O_RDONLY, 0777)) >= 0)
{
sceIoRead(fd, neogeo_memcard, 0x800);
sceIoClose(fd);
}
sprintf(path, "%snvram/%s.nv", launchDir, game_name);
if ((fd = sceIoOpen(path, PSP_O_RDONLY, 0777)) >= 0)
{
sceIoRead(fd, neogeo_sram16, 0x2000);
sceIoClose(fd);
swab(neogeo_sram16, neogeo_sram16, 0x2000);
}
neogeo_driver_init();
neogeo_video_init();
msg_printf(TEXT(DONE2));
return 1;
}
frame_cfg_t *frame_factory_read_cfg(SceUID fd)
{
int bytes = 0;
int cfg_size = 0;
frame_cfg_t *cfg = NULL;
if (fd == -1) {
goto error;
}
bytes = sceIoRead(fd, &cfg_size, sizeof(cfg_size));
if (bytes != sizeof(cfg_size)) {
printf("can't read file size\n");
goto error;
}
//printf("cfg size %d\n", cfg_size);
cfg = (frame_cfg_t *)malloc(cfg_size);
if (cfg == NULL) {
printf("not enough mem!\n");
goto error;
}
cfg->size = cfg_size;
bytes = sceIoRead(fd, (void*)cfg+sizeof(cfg_size), cfg_size-sizeof(cfg_size));
if (bytes != cfg_size-sizeof(cfg_size)) {
printf("size check fail %d/%d\n", cfg_size, bytes);
goto error;
}
return cfg;
error:
if (cfg != NULL) {
free(cfg);
}
return NULL;
}
int mhp3_read(SceUID fd, void *data, SceSize size) {
u32 k1;
int res;
u32 cur;
SceOff pos;
SceSize offset;
if (fd == datafd) {
pos = sceIoLseek(fd, 0, PSP_SEEK_CUR);
cur = 0;
offset = data_start;
while (cur < patch_count) {
if (pos < patch_offset[cur] + patch_size[cur] && pos + size > patch_offset[cur]) {
k1 = pspSdkSetK1(0);
reopen_translation();
sceIoLseek(transfd, offset + (pos - patch_offset[cur]), PSP_SEEK_SET);
res = sceIoRead(transfd, data, size);
if (res != (int) size) {
kprintf("failed to read translation data\n");
}
pspSdkSetK1(k1);
sceIoLseek(fd, size, PSP_SEEK_CUR);
return res;
}
offset += patch_size[cur];
cur++;
}
} else {
res = read_install(fd, data, size);
return res;
}
res = sceIoRead(fd, data, size);
return res;
}
int fill_tables(SceUID fd) {
if (fd < 0)
return -1;
sceIoLseek(fd, 0, PSP_SEEK_SET);
sceIoRead(fd, &patch_count, 4);
// max permitted: 6KiB
if (patch_count > 6144) {
patch_count = 6144;
}
kprintf("Allocating %i bytes\n", patch_count * 4 * 3);
memid = sceKernelAllocPartitionMemory(PSP_MEMORY_PARTITION_KERNEL, "mhp3tbl", PSP_SMEM_High, patch_count * 4 * 3, NULL);
if (memid < 0) {
kprintf("Mamory alloc failed\n");
return -1;
}
patch_offset = sceKernelGetBlockHeadAddr(memid);
kprintf("patch_offset addr: %08X\n", (u32)patch_offset);
patch_size = &patch_offset[patch_count];
kprintf("patch_size addr: %08X\n", (u32)patch_size);
for (u32 i = 0; i < patch_count; i++) {
sceIoRead(fd, &patch_offset[i], 4);
sceIoRead(fd, &patch_size[i], 4);
}
data_start = ((patch_count + 1) * 8);
if (data_start % 16 > 0) {
data_start += 16 - (data_start % 16);
}
return 0;
}
void checkIo(int doDispatch) {
char temp[128];
SceUID fd = sceIoOpen("dispatch.prx", PSP_O_RDONLY, 0777);
dispatchCheckpoint("sceIoOpen: %08x", fd >= 0 ? 1 : fd);
dispatchCheckpoint("sceIoRead: %08x", sceIoRead(fd, temp, sizeof(temp)));
dispatchCheckpoint("sceIoClose: %08x", sceIoClose(fd));
int state;
if (doDispatch) {
++ignoreResched;
state = sceKernelSuspendDispatchThread();
dispatchCheckpoint("sceKernelSuspendDispatchThread: %08x", state);
}
fd = sceIoOpen("dispatch.prx", PSP_O_RDONLY, 0777);
dispatchCheckpoint("sceIoOpen: %08x", fd >= 0 ? 1 : fd);
dispatchCheckpoint("sceIoRead: %08x", sceIoRead(fd, temp, sizeof(temp)));
dispatchCheckpoint("sceIoClose: %08x", sceIoClose(fd));
if (doDispatch) {
dispatchCheckpoint("sceKernelResumeDispatchThread: %08x", sceKernelResumeDispatchThread(state));
--ignoreResched;
}
SceInt64 res = -1;
int result = -1;
fd = sceIoOpenAsync("dispatch.prx", PSP_O_RDONLY, 0777);
dispatchCheckpoint("sceIoOpenAsync: %08x", fd >= 0 ? 1 : fd);
if (doDispatch) {
++ignoreResched;
state = sceKernelSuspendDispatchThread();
dispatchCheckpoint("sceKernelSuspendDispatchThread: %08x", state);
}
result = sceIoPollAsync(fd, &res);
dispatchCheckpoint("sceIoPollAsync: %08x / %016llx", result, res >= 0 ? 1LL : res);
result = sceIoGetAsyncStat(fd, 1, &res);
dispatchCheckpoint("sceIoGetAsyncStat: %08x / %016llx", result, res >= 0 ? 1LL : res);
result = sceIoGetAsyncStat(fd, 0, &res);
dispatchCheckpoint("sceIoGetAsyncStat: %08x / %016llx", result, res >= 0 ? 1LL : res);
result = sceIoWaitAsync(fd, &res);
dispatchCheckpoint("sceIoWaitAsync: %08x / %016llx", result, res >= 0 ? 1LL : res);
if (doDispatch) {
dispatchCheckpoint("sceKernelResumeDispatchThread: %08x", sceKernelResumeDispatchThread(state));
--ignoreResched;
}
result = sceIoWaitAsync(fd, &res);
dispatchCheckpoint("sceIoWaitAsync: %08x / %016llx", result, res >= 0 ? 1LL : res);
if (doDispatch) {
++ignoreResched;
state = sceKernelSuspendDispatchThread();
dispatchCheckpoint("sceKernelSuspendDispatchThread: %08x", state);
}
dispatchCheckpoint("sceIoRead: %08x", sceIoRead(fd, temp, sizeof(temp)));
dispatchCheckpoint("sceIoWrite: %08x", sceIoWrite(1, "Hello.", sizeof("Hello.")));
if (doDispatch) {
dispatchCheckpoint("sceKernelResumeDispatchThread: %08x", sceKernelResumeDispatchThread(state));
--ignoreResched;
}
dispatchCheckpoint("sceIoCloseAsync: %08x", sceIoCloseAsync(fd));
result = sceIoWaitAsync(fd, &res);
dispatchCheckpoint("sceIoWaitAsync: %08x / %016llx", result, res);
}
int colorconfig_read(ColorConfig* prConfig, SceUID fd) {
if (prConfig == NULL) {
return COLORCONFIG_NULLPTR;
}
sceIoRead(fd, &prConfig->background, sizeof(u32));
sceIoRead(fd, &prConfig->text, sizeof(u32));
return COLORCONFIG_SUCCESS;
}
void PBPParse::Parse(const char *file){
fid = sceIoOpen(file, PSP_O_RDONLY, 0777);
sceIoMkdir("ms0:/TMP", 0777);
if (fid >= 0)
{
if (sceIoRead(fid, &header, sizeof(PBPHeader)) == sizeof(PBPHeader)){
char *temp = (char*)malloc(header.icon0 - header.sfo);
sceIoLseek(fid, header.sfo, PSP_SEEK_SET);
sceIoRead(fid, temp, header.icon0 - header.sfo);
SceUID sfoFile = sceIoOpen("ms0:/TMP/PARAM.SFO", PSP_O_CREAT | PSP_O_WRONLY, 0777);
sceIoWrite(sfoFile, temp, header.icon0 - header.sfo);
sceIoClose(sfoFile);
free(temp);
sfo.Parse("ms0:/TMP/PARAM.SFO");
temp = (char*)malloc(header.icon1 - header.icon0);
sceIoLseek(fid, header.icon0, PSP_SEEK_SET);
sceIoRead(fid, temp, header.icon1 - header.icon0);
SceUID icoFile = sceIoOpen("ms0:/TMP/ICON0.PNG", PSP_O_CREAT | PSP_O_WRONLY, 0777);
sceIoWrite(icoFile, temp, header.icon1 - header.icon0);
sceIoClose(icoFile);
if (header.icon1 - header.icon0 > 0){
OSL_IMAGE *ico = oslLoadImageFilePNG("ms0:/TMP/ICON0.PNG", OSL_IN_RAM | OSL_SWIZZLED, OSL_PF_5650);
icon = oslScaleImageCreate(ico, OSL_IN_RAM, 64, 64, OSL_PF_5650);
oslDeleteImage(ico);
oslWriteImageFilePNG(icon, "ms0:/TMP/ICON0.PNG", 0);
}
else{
icon = oslCreateImageCopy(defaultUNKN, OSL_IN_RAM);
}
free(temp);
temp = (char*)malloc(header.snd - header.pic1);
sceIoLseek(fid, header.pic1, PSP_SEEK_SET);
sceIoRead(fid, temp, header.snd - header.pic1);
SceUID picFile = sceIoOpen("ms0:/TMP/PIC1.PNG", PSP_O_CREAT | PSP_O_WRONLY, 0777);
sceIoWrite(picFile, temp, header.snd - header.pic1);
sceIoClose(picFile);
if (header.snd - header.pic1 > 0){
pic = oslLoadImageFilePNG("ms0:/TMP/PIC1.PNG", OSL_IN_RAM, OSL_PF_8888);
OSL_IMAGE *tmpPic = oslScaleImageCreate(pic, OSL_IN_RAM, 128, 128, OSL_PF_8888);
oslUnswizzleImage(tmpPic);
oslWriteImageFilePNG(tmpPic, "ms0:/TMP/PIC1SC.PNG", 0);
oslDeleteImage(tmpPic);
oslDeleteImage(pic); //Get rid of the pic file for now, we don't need it
}
free(temp);
sceIoClose(fid);
}
}
}
//Seek next valid frame
//NOTE: this function comes from Music prx 0.55 source
// all credits goes to joek2100.
int MP3ME_SeekNextFrameMP3(SceUID fd)
{
int offset = 0;
unsigned char buf[1024];
unsigned char *pBuffer;
int i;
int size = 0;
offset = sceIoLseek32(fd, 0, PSP_SEEK_CUR);
sceIoRead(fd, buf, sizeof(buf));
if (!strncmp((char*)buf, "ID3", 3) || !strncmp((char*)buf, "ea3", 3)) //skip past id3v2 header, which can cause a false sync to be found
{
//get the real size from the syncsafe int
size = buf[6];
size = (size<<7) | buf[7];
size = (size<<7) | buf[8];
size = (size<<7) | buf[9];
size += 10;
if (buf[5] & 0x10) //has footer
size += 10;
}
sceIoLseek32(fd, offset, PSP_SEEK_SET); //now seek for a sync
while(1)
{
offset = sceIoLseek32(fd, 0, PSP_SEEK_CUR);
size = sceIoRead(fd, buf, sizeof(buf));
if (size <= 2)//at end of file
return -1;
if (!strncmp((char*)buf, "EA3", 3))//oma mp3 files have non-safe ints in the EA3 header
{
sceIoLseek32(fd, (buf[4]<<8)+buf[5], PSP_SEEK_CUR);
continue;
}
pBuffer = buf;
for( i = 0; i < size; i++)
{
//if this is a valid frame sync (0xe0 is for mpeg version 2.5,2+1)
if ( (pBuffer[i] == 0xff) && ((pBuffer[i+1] & 0xE0) == 0xE0))
{
offset += i;
sceIoLseek32(fd, offset, PSP_SEEK_SET);
return offset;
}
}
//go back two bytes to catch any syncs that on the boundary
sceIoLseek32(fd, -2, PSP_SEEK_CUR);
}
}
void loadTheme()
{
int i, bytesRead;
SceUID fp;
fp = sceIoOpen("ms0:/lockdown.thm", PSP_O_RDONLY, 0777);
if (fp < 0)
{
fp = sceIoOpen("flash0:/lockdown.thm", PSP_O_RDONLY, 0777);
if (fp < 0)
{
printTextScreen(0, 0, "Error loading flash0:/lockdown.thm.", RGB(255, 0, 0));
printTextScreen(0, 8, "Place theme at ms0:/lockdown.thm to load from memory stick.", RGB(255, 0, 0));
sceDisplayWaitVblankStart();
flipScreen();
sceKernelSleepThread();
}
}
for (i = 0; i < NUMFILES; i++)
{
bytesRead = sceIoRead(fp, &images[i].hdr, sizeof(imagehdr));
if (bytesRead != sizeof(imagehdr))
{
printTextScreen(0, 0, "Unexpected end of header.", RGB(255, 0, 0));
sceDisplayWaitVblankStart();
flipScreen();
sceKernelSleepThread();
}
images[i].blockid = sceKernelAllocPartitionMemory(2, "block", 0, (sizeof(unsigned char) * images[i].hdr.size), NULL);
if (images[i].blockid < 0)
{
printTextScreen(0, 0, "Memory allocation error.", RGB(255, 0, 0));
sceDisplayWaitVblankStart();
flipScreen();
sceKernelSleepThread();
}
images[i].data = (unsigned char*) sceKernelGetBlockHeadAddr(images[i].blockid);
bytesRead = sceIoRead(fp, images[i].data, images[i].hdr.size);
if (bytesRead != images[i].hdr.size)
{
printTextScreen(0, 0, "Unexpected end of data.", RGB(255, 0, 0));
sceDisplayWaitVblankStart();
flipScreen();
sceKernelSleepThread();
}
}
sceIoClose(fp);
}
int compare_file_buffer(const char *path, void *file_buf, int size)
{
SceUID fd = -1;
int ret;
SceIoStat srcstat;
ret = sceIoGetstat(path, &srcstat);
if (ret != 0) {
goto not_equal;
}
if (srcstat.st_size != size) {
goto not_equal;
}
ret = sceIoOpen(path, PSP_O_RDONLY, 0777);
if (ret < 0) {
goto not_equal;
}
fd = ret;
ret = sizeof(g_buf);
ret = sceIoRead(fd, g_buf, ret);
while (ret > 0) {
if (memcmp(g_buf, file_buf, ret)) {
goto not_equal;
}
file_buf += ret;
ret = sceIoRead(fd, g_buf, ret);
}
if (ret < 0) {
goto not_equal;
}
sceIoClose(fd);
return 0;
not_equal:
if (fd >= 0)
sceIoClose(fd);
return 1;
}
static int get_icon0_status(void)
{
u32 icon0_offset = 0;
int result = ICON0_MISSING;
SceUID fd = -1;;
const char *filename;
u8 p[40 + 64], *header;
header = (u8*)((((u32)p) & ~(64-1)) + 64);
filename = sceKernelInitFileName();
if(filename == NULL) {
goto exit;
}
fd = sceIoOpen(filename, PSP_O_RDONLY, 0777);
if(fd < 0) {
printk("%s: sceIoOpen %s -> 0x%08X\n", __func__, filename, fd);
goto exit;
}
sceIoRead(fd, header, 40);
icon0_offset = *(u32*)(header+0x0c);
sceIoLseek32(fd, icon0_offset, PSP_SEEK_SET);
sceIoRead(fd, header, 40);
if(*(u32*)(header+4) == 0xA1A0A0D) {
if ( *(u32*)(header+0xc) == 0x52444849 && // IHDR
*(u32*)(header+0x10) == 0x50000000 && //
*(u32*)(header+0x14) == *(u32*)(header+0x10)
) {
result = ICON0_OK;
} else {
result = ICON0_CORRUPTED;
}
} else {
result = ICON0_MISSING;
}
printk("%s: PNG file status -> %d\n", __func__, result);
exit:
if(fd >= 0) {
sceIoClose(fd);
}
return result;
}
int copy_file(const char *src, const char *dst)
{
SceUID fd = -1, fdw = -1;
int ret;
ret = sceIoOpen(src, PSP_O_RDONLY, 0777);
if (ret < 0) {
goto error;
}
fd = ret;
ret = sceIoOpen(dst, PSP_O_WRONLY | PSP_O_CREAT | PSP_O_TRUNC, 0777);
if (ret < 0) {
goto error;
}
fdw = ret;
ret = sizeof(g_buf);
ret = sceIoRead(fd, g_buf, ret);
while (ret > 0) {
ret = sceIoWrite(fdw, g_buf, ret);
if (ret < 0) {
goto error;
}
ret = sceIoRead(fd, g_buf, ret);
}
if (ret < 0) {
goto error;
}
sceIoClose(fd);
sceIoClose(fdw);
return 0;
error:
sceIoClose(fd);
sceIoClose(fdw);
return ret;
}
pgeObj *pgeObjLoad(const char *filename)
{
int fd = sceIoOpen(filename, PSP_O_RDONLY, 0777);
if(fd < 0)
return NULL;
long filesize;
filesize = sceIoLseek32(fd, 0, PSP_SEEK_END);
sceIoLseek32(fd, 0, PSP_SEEK_SET);
unsigned char *data = pgeMalloc(filesize);
if(!data)
return NULL;
sceIoRead(fd, data, filesize);
sceIoClose(fd);
pgeObj *obj = pgeObjLoadInternal(data, filesize);
if(data)
pgeFree(data);
return obj;
}
int sctrlSEGetConfig(TNConfig *config)
{
int k1 = pspSdkSetK1(0);
memset(config, 0, sizeof(TNConfig));
/* Default settings */
strcpy(config->nickname, "CEF User");
config->exit_button_1 = 2; //PSP_CTRL_START
config->exit_hold_duration = 2;
config->button_assign = 1; //CROSS
config->show_pic1 = 1; //enabled
SceUID fd = sceIoOpen("ms0:/PSP/SYSTEM/CONFIG.TN", PSP_O_RDONLY, 0);
if(fd < 0)
{
pspSdkSetK1(k1);
return fd;
}
int read = sceIoRead(fd, config, sizeof(TNConfig));
sceIoClose(fd);
pspSdkSetK1(k1);
return read;
}
static int check_file_is_encrypted(int fd)
{
int ret;
u32 k1;
char p[8 + 64], *buf;
k1 = pspSdkSetK1(0);
buf = (char*)((((u32)p) & ~(64-1)) + 64);
ret = sceIoRead(fd, buf, 8);
pspSdkSetK1(k1);
sceIoLseek32(fd, 0, PSP_SEEK_SET);
if (ret != 8)
return 0;
if (!memcmp(buf, g_drm_magic_1, sizeof(g_drm_magic_1))) {
return 1;
}
if (!memcmp(buf, g_drm_magic_2, sizeof(g_drm_magic_2))) {
return 1;
}
#if 0
printk("%s: buf:\n", __func__);
hexdump(buf, 8);
#endif
return 0;
}
static int load_key(const char *keypath, u8 *key, int size)
{
SceUID keys;
int ret;
keys = sceIoOpen(keypath, PSP_O_RDONLY, 0777);
if (keys < 0) {
printk("%s: sceIoOpen %s -> 0x%08X\n", __func__, keypath, keys);
return -1;
}
ret = sceIoRead(keys, key, size);
if (ret == size) {
ret = 0;
} else {
ret = -2;
}
sceIoClose(keys);
return ret;
}
int JMP3::GetID3TagSize(char *fname)
{
SceUID fd;
char header[10];
int size = 0;
fd = sceIoOpen(fname, PSP_O_RDONLY, 0777);
if (fd < 0)
return 0;
sceIoRead(fd, header, sizeof(header));
sceIoClose(fd);
if (!strncmp((char*)header, "ea3", 3) || !strncmp((char*)header, "EA3", 3)
||!strncmp((char*)header, "ID3", 3))
{
//get the real size from the syncsafe int
size = header[6];
size = (size<<7) | header[7];
size = (size<<7) | header[8];
size = (size<<7) | header[9];
size += 10;
if (header[5] & 0x10) //has footer
size += 10;
return size;
}
return 0;
}
static void send_file(ClientInfo *client, const char *path)
{
unsigned char *buffer;
SceUID fd;
unsigned int bytes_read;
DEBUG("Opening: %s\n", path);
if ((fd = sceIoOpen(path, PSP2_O_RDONLY, 0777)) >= 0) {
buffer = malloc(FILE_BUF_SIZE);
if (buffer == NULL) {
client_send_ctrl_msg(client, "550 Could not allocate memory.\n");
return;
}
client_open_data_connection(client);
client_send_ctrl_msg(client, "150 Opening Image mode data transfer.\n");
while ((bytes_read = sceIoRead (fd, buffer, FILE_BUF_SIZE)) > 0) {
client_send_data_raw(client, buffer, bytes_read);
}
sceIoClose(fd);
free(buffer);
client_send_ctrl_msg(client, "226 Transfer completed.\n");
client_close_data_connection(client);
} else {
client_send_ctrl_msg(client, "550 File not found.\n");
}
}
static int read_ADIF_header(SceUID file, unsigned long filesize, struct fileInfo *info)
{
int bitstream;
unsigned char buffer[ADIF_MAX_SIZE];
int skip_size = 0;
int sf_idx;
/* Get ADIF header data */
if (sceIoRead(file, buffer, ADIF_MAX_SIZE) != ADIF_MAX_SIZE)
return -1;
/* copyright string */
if(buffer[0] & 0x80)
skip_size += 9; /* skip 9 bytes */
bitstream = buffer[0 + skip_size] & 0x10;
/*info->bitrate = ((unsigned int)(buffer[0 + skip_size] & 0x0F)<<19)|
((unsigned int)buffer[1 + skip_size]<<11)|
((unsigned int)buffer[2 + skip_size]<<3)|
((unsigned int)buffer[3 + skip_size] & 0xE0);*/
int bitrate = ((unsigned int)(buffer[0 + skip_size] & 0x0F)<<19)|
((unsigned int)buffer[1 + skip_size]<<11)|
((unsigned int)buffer[2 + skip_size]<<3)|
((unsigned int)buffer[3 + skip_size] & 0xE0);
info->kbit = bitrate / 1000;
if (bitstream == 0)
{
//info->object_type = ((buffer[6 + skip_size]&0x01)<<1)|((buffer[7 + skip_size]&0x80)>>7);
sf_idx = (buffer[7 + skip_size]&0x78)>>3;
} else {
int LPP_UtilsGameShareInit(const char *filepath, const char *name)
{
sceNetAdhocMatchingInit(32*1024);
memset(&lpp_UtilsGameShareParams, 0, sizeof(lpp_UtilsGameShareParams));
lpp_UtilsGameShareParams.base.size = sizeof(lpp_UtilsGameShareParams);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_LANGUAGE, &lpp_UtilsGameShareParams.base.language);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_UNKNOWN, &lpp_UtilsGameShareParams.base.buttonSwap);
lpp_UtilsGameShareParams.base.graphicsThread = 17;
lpp_UtilsGameShareParams.base.accessThread = 19;
lpp_UtilsGameShareParams.base.fontThread = 18;
lpp_UtilsGameShareParams.base.soundThread = 16;
size_t lsize = 0;
SceUID fd = sceIoOpen(filepath, PSP_O_RDONLY, 0777);
if(fd < 0) return -1;
lsize = sceIoLseek32(fd, 0, PSP_SEEK_END);
u8 *buffer = (u8*)malloc(lsize);
if(buffer == null)
{
sceIoClose(fd);
return -1;
}
sceIoLseek32(fd, 0, PSP_SEEK_SET);
int read = sceIoRead(fd, buffer,lsize);
if(read < lsize)
{
sceIoClose(fd);
free(buffer);
return -1;
}
sceIoClose(fd);
buffer[276] = 0x57;
strncpy((char *)&buffer[320], name, 127);
kuKernelMemcpy(&lpp_UtilsGameShareParams.name, "GameShar", 8);
lpp_UtilsGameShareParams.mode = 1;
lpp_UtilsGameShareParams.datatype = 2;
lpp_UtilsGameShareParams.data = buffer;
lpp_UtilsGameShareParams.datasize = lsize;
int res = sceUtilityGameSharingInitStart(&lpp_UtilsGameShareParams);
if(res == 0) return 1;
return (res);
}
/**
* Read Line from File
* @param fd File Descriptor to read line from
* @param buffer Buffer to read line into
* @param buflen Length of Buffer in Bytes
* @return Length of Line or... 0
*/
uint32_t _readLine(int fd, char * buffer, uint32_t buflen)
{
// Erase Buffer
memset(buffer, 0, buflen);
// Length of Line
uint32_t length = 0;
// Read Line
while(length < buflen - 1)
{
// Read Character
int b = sceIoRead(fd, buffer + length, 1);
// Read Failure
if(b <= 0) break;
// Move Pointer
length++;
// End of Line Symbol
if(buffer[length - 1] == '\n') break;
}
// Remove End of Line Symbols
int i = 0; for(; i < length; i++) if(buffer[i] == '\r' || buffer[i] == '\n') buffer[i] = 0;
// Return true Length
return strlen(buffer);
}
int FileCopy(char* srcPath, char* destPath, char* fileName)
{
SceIoStat fileStat;
char path[258];
sprintf(path,"%s/%s",srcPath, fileName);
if(sceIoGetstat(path, &fileStat) < 0)
return -1;
u8* data = malloc(fileStat.st_size);
SceUID fileId = sceIoOpen(path, PSP_O_RDONLY, 0777);
if(fileId < 0)
{
printf("Fail opening %s\n",path);
free(data);
return -1;
}
sceIoRead(fileId, data, fileStat.st_size);
sceIoClose(fileId);
sprintf(path,"%s/%s",destPath, fileName);
fileId = sceIoOpen(path, PSP_O_WRONLY | PSP_O_CREAT, 0777);
if(fileId < 0)
{
printf("Fail opening %s\n",path);
return -1;
}
sceIoWrite(fileId, data, fileStat.st_size);
sceIoClose(fileId);
free(data);
return 0;
}
int
MP3_Load(char *filename)
{
int fd;
if (!strcmp(mp3_curr_filename, filename)) {
// already loaded !
} else
if ((fd = sceIoOpen(filename, PSP_O_RDONLY, 0777)) > 0) {
// opened file, so get size now
size = sceIoLseek(fd, 0, PSP_SEEK_END);
sceIoLseek(fd, 0, PSP_SEEK_SET);
if (mp3_data) { free(mp3_data); mp3_data = 0; }
mp3_data = (unsigned char *) malloc(size + 8);
if (mp3_data) memset(mp3_data, 0, size + 8);
if (mp3_data != 0) { // Read file in
sceIoRead(fd, mp3_data, size);
} else {
//printf("Error allocing\n");
sceIoClose(fd);
return 0;
}
// Close file
sceIoClose(fd);
strcpy(mp3_curr_filename, filename);
} else {
return 0;
}
isPlaying = 0;
FrameCount = 0;
MP3_getInfo();
return 1;
}
size_t fread(void *buf, size_t size, size_t n, FILE *fp){
int ret;
ret = sceIoRead( (int)fp, buf, size * n );
return ret / size;
}
int locate_umd_img1(const char *umdfile, size_t file_offset, SceUID * pfd)
{
int ret = -1;
char buf[9] = { 0 };
size_t stread = 0;
if (!umdfile || !pfd || file_offset < 0)
return -1;
*pfd = -1;
do {
struct UMDHeaderDataEx *pEx;
if ((*pfd = sceIoOpen(umdfile, PSP_O_RDONLY, 0777)) < 0) {
return -2;
}
if (0 < sceIoLseek(*pfd, file_offset, SEEK_SET))
return -3;
if ((stread = sceIoRead(*pfd, buf, 9)) < 0) {
dbg_printf(d, "%s read umd file head chunk error!", __func__);
break;
}
pEx = (struct UMDHeaderDataEx *) &buf;
if (!pEx || pEx->Mark != '$' || pEx->Length < 9)
break;
return pEx->Length - 9;
} while (false);
if (*pfd) {
sceIoClose(*pfd);
*pfd = -1;
}
return ret;
}
int copy_file(char *input, char *output)
{
SceUID i = sceIoOpen(input, PSP_O_RDONLY, 0777);
if (i < 0)
return -1;
sceIoRemove(output);
SceUID o = sceIoOpen(output, PSP_O_WRONLY | PSP_O_CREAT | PSP_O_TRUNC, 0777);
if (o < 0)
return -1;
int read;
while ((read = sceIoRead(i, buf, 16384)) > 0)
{
sceIoWrite(o, buf, read);
}
sceIoClose(i);
sceIoClose(o);
return 0;
}
ssize_t filestream_read(RFILE *stream, void *s, size_t len)
{
if (!stream || !s)
goto error;
#if defined(PSP)
return sceIoRead(stream->fd, s, len);
#else
#if defined(HAVE_BUFFERED_IO)
if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0)
return fread(s, 1, len, stream->fp);
#endif
#ifdef HAVE_MMAP
if (stream->hints & RFILE_HINT_MMAP)
{
if (stream->mappos > stream->mapsize)
goto error;
if (stream->mappos + len > stream->mapsize)
len = stream->mapsize - stream->mappos;
memcpy(s, &stream->mapped[stream->mappos], len);
stream->mappos += len;
return len;
}
#endif
return read(stream->fd, s, len);
#endif
error:
return -1;
}
void *Red3dLoadFile(const char *path, int mempart)
{
void *ptr, *readbuffer;
int c = Red3dCheckFile(path);
if(c >= 0) return DirIndex[c]->address;
int fd = sceIoOpen(path, PSP_O_RDONLY, 0777);
if(fd >= 0)
{
u32 size = sceIoLseek(fd, 0, SEEK_END);
sceIoLseek(fd, 0, SEEK_SET);
readbuffer = malloc(size);
sceIoRead(fd, readbuffer, size);
ptr = Red3dLoadBuf(readbuffer, size, mempart);
free(readbuffer);
sceKernelDcacheWritebackInvalidateAll();
sceIoClose(fd);
return ptr;
}
return NULL;
}
int fgetc(FILE *fp){
char c;
sceIoRead( (int)fp, &c, sizeof(char) );
return (int)c;
}
