u8 *load_file_from_ISO(const char *iso, char *name, int *size)
{
int ret;
u32 lba;
u8 *buf;
ret = isoOpen(iso);
if (ret < 0) {
return NULL;
}
ret = isoGetFileInfo(name, (u32*)size, &lba);
if (ret < 0) {
isoClose();
return NULL;
}
buf = malloc(*size);
if (buf == NULL) {
isoClose();
return NULL;
}
ret = isoRead(buf, lba, 0, *size);
if (ret < 0) {
isoClose();
return NULL;
}
isoClose();
return buf;
}
void Decompress(char *filename)
{
struct stat buf;
char file[256];
u8 cdbuff[10*2352];
u32 lsn;
isoFile *src;
isoFile *dst;
int ret = 0;
src = isoOpen(filename);
if (src == NULL) return;
strcpy(file, filename);
if (src->flags & ISOFLAGS_Z)
file[strlen(file) - 2] = 0;
else if (src->flags & ISOFLAGS_Z2)
file[strlen(file) - 3] = 0;
else if (src->flags & ISOFLAGS_BZ2)
file[strlen(file) - 3] = 0;
else
{
printf("%s is not a compressed image\n", filename);
return;
}
if (stat(file, &buf) != -1)
{
char str[256];
sprintf(str, "'%s' already exists", file);
isoClose(src);
return;
}
dst = isoCreate(file, 0);
if (dst == NULL) return;
isoSetFormat(dst, src->blockofs, src->blocksize, src->blocks);
for (lsn = 0; lsn < src->blocks; lsn++)
{
printf("block %d ", lsn);
putchar(13);
fflush(stdout);
ret = isoReadBlock(src, cdbuff, lsn);
if (ret == -1) break;
ret = isoWriteBlock(dst, cdbuff, lsn);
if (ret == -1) break;
}
isoClose(src);
isoClose(dst);
if (ret == -1)
printf("Error decompressing iso image\n");
else
printf("Iso image decompressed OK\n");
}
static int has_prometheus_module(VirtualPBP *vpbp)
{
int ret;
u32 size, lba;
ret = isoOpen(vpbp->name);
if (ret < 0) {
return 0;
}
ret = isoGetFileInfo("/PSP_GAME/SYSDIR/EBOOT.OLD", &size, &lba);
ret = (ret >= 0) ? 1 : 0;
isoClose();
return ret;
}
int vpbp_close(SceUID fd)
{
VirtualPBP *vpbp;
lock();
vpbp = get_vpbp_by_fd(fd);
if (vpbp == NULL) {
printk("%s: unknown fd 0x%08X\n", __func__, fd);
unlock();
return -7;
}
isoClose();
unlock();
return 0;
}
int vshDetectDiscType(const char *path)
{
int result, ret;
u32 k1;
result = -1;
k1 = pspSdkSetK1(0);
ret = isoOpen(path);
if (ret < 0) {
pspSdkSetK1(k1);
return result;
}
result = 0;
if(has_file("/PSP_GAME/SYSDIR/EBOOT.BIN")) {
result |= PSP_UMD_TYPE_GAME;
}
if(has_file("/UMD_VIDEO/PLAYLIST.UMD")) {
result |= PSP_UMD_TYPE_VIDEO;
}
if(has_file("/UMD_AUDIO/PLAYLIST.UMD")) {
result |= PSP_UMD_TYPE_AUDIO;
}
if(result == 0) {
result = -2;
}
isoClose();
pspSdkSetK1(k1);
return result;
}
static int build_vpbp(VirtualPBP *vpbp)
{
int ret, i;
u32 off;
printk("Need to build vpbp %s\n", vpbp->name);
memset(vpbp->header, 0, sizeof(vpbp->header));
memset(vpbp->sects, 0, sizeof(vpbp->sects));
vpbp->enabled = 1;
vpbp->file_pointer = 0;
vpbp->header[0] = 0x50425000; // PBP magic
vpbp->header[1] = 0x10000; // version
// fill vpbp offsets
off = 0x28;
ret = isoOpen(vpbp->name);
if (ret < 0) {
printk("%s: isoOpen -> %d\n", __func__, ret);
ret = add_cache(vpbp);
return ret;
}
for(i=0; i<NELEMS(pbp_entries); ++i) {
vpbp->header[i+2] = off;
if (pbp_entries[i].enabled) {
PBPSection *sec = &vpbp->sects[i];
ret = isoGetFileInfo(pbp_entries[i].name, &sec->size, &sec->lba);
if (ret < 0) {
if (i == 0) {
// no PARAM.SFO?
// then it's a bad ISO
isoClose();
return -36;
} else {
continue;
}
}
if (i == 0) {
off += sizeof(virtualsfo);
} else {
off += sec->size;
}
}
}
vpbp->pbp_total_size = vpbp->header[9];
get_iso_file_size(vpbp->name, &vpbp->iso_total_size);
ret = add_cache(vpbp);
printk("%s: add_cache -> %d\n", __func__, ret);
isoClose();
return ret;
}
int isoOpen(const char *path)
{
int ret;
if (g_isofp != NULL) {
isoClose();
}
g_filename = path;
if (reOpen() == NULL) {
printf("%s: open failed %s\n", __func__, g_filename);
ret = -2;
goto error;
}
fseek(g_isofp, 0, SEEK_SET);
memset(&g_ciso_h, 0, sizeof(g_ciso_h));
ret = fread(&g_ciso_h, sizeof(g_ciso_h), 1, g_isofp);
if (ret != 1) {
ret = -9;
goto error;
}
if (*(u32*)g_ciso_h.magic == 0x4F534943 && g_ciso_h.block_size == SECTOR_SIZE) {
g_is_compressed = 1;
} else {
g_is_compressed = 0;
}
if (g_is_compressed) {
g_total_sectors = g_ciso_h.total_bytes / g_ciso_h.block_size;
g_CISO_cur_idx = -1;
if (g_ciso_dec_buf == NULL) {
g_ciso_dec_buf = malloc(CISO_DEC_BUFFER_SIZE);
if (g_ciso_dec_buf == NULL) {
printf("malloc -> 0x%08x\n", (u32)g_ciso_dec_buf);
ret = -6;
goto error;
}
}
memset(g_CISO_idx_cache, 0, sizeof(g_CISO_idx_cache));
g_ciso_dec_buf_offset = -1;
g_CISO_cur_idx = -1;
} else {
g_total_sectors = isoGetSize();
}
ret = readSector(16, g_sector_buffer);
if (ret < 0) {
ret = -7;
goto error;
}
if (memcmp(&g_sector_buffer[1], ISO_STANDARD_ID, sizeof(ISO_STANDARD_ID)-1)) {
printf("%s: vol descriptor not found\n", __func__);
ret = -10;
goto error;
}
memcpy(&g_root_record, &g_sector_buffer[0x9C], sizeof(g_root_record));
return 0;
error:
if (g_isofp >= 0) {
isoClose();
}
return ret;
}
void Compress(char *filename, int mode)
{
struct stat buf;
u32 lsn;
u8 cdbuff[1024*16];
char Zfile[256];
int ret = 0;
isoFile *src;
isoFile *dst;
if (mode == 1)
{
sprintf(Zfile, "%s.Z2", filename);
}
else
{
sprintf(Zfile, "%s.BZ2", filename);
}
if (stat(Zfile, &buf) != -1)
{
printf("'%s' already exists\n", Zfile);
return;
/* sprintf(str, "'%s' already exists, overwrite?", Zfile);
if (MessageBox(hDlg, str, "Question", MB_YESNO) != IDYES) {
return;
}*/
}
printf("src %s; dst %s\n", filename, Zfile);
src = isoOpen(filename);
if (src == NULL) return;
if (mode == 1)
{
dst = isoCreate(Zfile, ISOFLAGS_Z2);
}
else
{
dst = isoCreate(Zfile, ISOFLAGS_BZ2);
}
isoSetFormat(dst, src->blockofs, src->blocksize, src->blocks);
if (dst == NULL) return;
for (lsn = 0; lsn < src->blocks; lsn++)
{
printf("block %d ", lsn);
putchar(13);
fflush(stdout);
ret = isoReadBlock(src, cdbuff, lsn);
if (ret == -1) break;
ret = isoWriteBlock(dst, cdbuff, lsn);
if (ret == -1) break;
}
isoClose(src);
isoClose(dst);
if (ret == -1)
{
printf("Error compressing iso image\n");
}
else
{
printf("Iso image compressed OK\n");
}
}
