X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=libpcsxcore%2Fcdriso.c;h=c8eacb8794dd098404d1aa1326e82fce2de96bd3;hb=d56340b165b4a7ef25bc3c7509d4f2315843bc31;hp=c29fd775d08c34641c030147d3f9c08fafe1b907;hpb=9a92bffbed92c9b6bd7d0ddde7c0982a8590959e;p=pcsx_rearmed.git diff --git a/libpcsxcore/cdriso.c b/libpcsxcore/cdriso.c index c29fd775..c8eacb87 100644 --- a/libpcsxcore/cdriso.c +++ b/libpcsxcore/cdriso.c @@ -1,6 +1,7 @@ /*************************************************************************** * Copyright (C) 2007 PCSX-df Team * * Copyright (C) 2009 Wei Mingzhi * + * Copyright (C) 2012 notaz * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * @@ -15,7 +16,7 @@ * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * - * 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. * ***************************************************************************/ #include "psxcommon.h" @@ -24,14 +25,28 @@ #include "cdriso.h" #include "ppf.h" +#include +#include +#ifdef HAVE_CHD +#include +#endif + #ifdef _WIN32 +#define WIN32_LEAN_AND_MEAN #include #include +#define strcasecmp _stricmp +#define usleep(x) (Sleep((x) / 1000)) #else #include #include +#include #endif -#include + +#define OFF_T_MSB ((off_t)1 << (sizeof(off_t) * 8 - 1)) + +unsigned int cdrIsoMultidiskCount; +unsigned int cdrIsoMultidiskSelect; static FILE *cdHandle = NULL; static FILE *cddaHandle = NULL; @@ -41,7 +56,9 @@ static boolean subChanMixed = FALSE; static boolean subChanRaw = FALSE; static boolean subChanMissing = FALSE; -static unsigned char cdbuffer[DATA_SIZE]; +static boolean multifile = FALSE; + +static unsigned char cdbuffer[CD_FRAMESIZE_RAW]; static unsigned char subbuffer[SUB_FRAMESIZE]; static unsigned char sndbuffer[CD_FRAMESIZE_RAW * 10]; @@ -56,25 +73,41 @@ static pthread_t threadid; static unsigned int initial_offset = 0; static boolean playing = FALSE; static boolean cddaBigEndian = FALSE; +// cdda sectors in toc, byte offset in file static unsigned int cdda_cur_sector; -static unsigned int cdda_start_sector; +static unsigned int cdda_first_sector; +static unsigned int cdda_file_offset; /* Frame offset into CD image where pregap data would be found if it was there. * If a game seeks there we must *not* return subchannel data since it's * not in the CD image, so that cdrom code can fake subchannel data instead. * XXX: there could be multiple pregaps but PSX dumps only have one? */ static unsigned int pregapOffset; +#define cddaCurPos cdda_cur_sector + // compressed image stuff static struct { unsigned char buff_raw[16][CD_FRAMESIZE_RAW]; unsigned char buff_compressed[CD_FRAMESIZE_RAW * 16 + 100]; - unsigned int *index_table; + off_t *index_table; unsigned int index_len; + unsigned int block_shift; unsigned int current_block; unsigned int sector_in_blk; } *compr_img; -int (*cdimg_read_func)(FILE *f, void *dest, int sector, int offset); +#ifdef HAVE_CHD +static struct { + unsigned char (*buffer)[CD_FRAMESIZE_RAW + SUB_FRAMESIZE]; + chd_file* chd; + const chd_header* header; + unsigned int sectors_per_hunk; + unsigned int current_hunk; + unsigned int sector_in_hunk; +} *chd_img; +#endif + +int (*cdimg_read_func)(FILE *f, unsigned int base, void *dest, int sector); char* CALLBACK CDR__getDriveLetter(void); long CALLBACK CDR__configure(void); @@ -85,14 +118,12 @@ long CALLBACK CDR__getStatus(struct CdrStat *stat); static void DecodeRawSubData(void); -extern void *hCDRDriver; - struct trackinfo { - enum {DATA, CDDA} type; + enum {DATA=1, CDDA} type; char start[3]; // MSF-format char length[3]; // MSF-format FILE *handle; // for multi-track images CDDA - int start_offset; // sector offset from start of above file + unsigned int start_offset; // byte offset from start of above file }; #define MAXTRACKS 100 /* How many tracks can a CD hold? */ @@ -164,50 +195,31 @@ static void playthread(void *param) static void *playthread(void *param) #endif { - long d, t, i, s; + long osleep, d, t, i, s; unsigned char tmp; + int ret = 0, sector_offs; t = GetTickCount(); while (playing) { - d = t - (long)GetTickCount(); - if (d <= 0) { - d = 1; - } - else if (d > CDDA_FRAMETIME) { - d = CDDA_FRAMETIME; - } -#ifdef _WIN32 - Sleep(d); -#else - usleep(d * 1000); -#endif - // HACK: stop feeding data while emu is paused - extern int stop; - if (stop) { - usleep(100000); - continue; - } - - t = GetTickCount() + CDDA_FRAMETIME; - s = 0; for (i = 0; i < sizeof(sndbuffer) / CD_FRAMESIZE_RAW; i++) { - d = cdimg_read_func(cddaHandle, sndbuffer + s, cdda_cur_sector, 0); - if (d < CD_FRAMESIZE_RAW) - break; + sector_offs = cdda_cur_sector - cdda_first_sector; + if (sector_offs < 0) { + d = CD_FRAMESIZE_RAW; + memset(sndbuffer + s, 0, d); + } + else { + d = cdimg_read_func(cddaHandle, cdda_file_offset, + sndbuffer + s, sector_offs); + if (d < CD_FRAMESIZE_RAW) + break; + } s += d; cdda_cur_sector++; } - if (subHandle != NULL) { - fseek(subHandle, cdda_cur_sector * SUB_FRAMESIZE, SEEK_SET); - fread(subbuffer, 1, SUB_FRAMESIZE, subHandle); - - if (subChanRaw) DecodeRawSubData(); - } - if (s == 0) { playing = FALSE; initial_offset = 0; @@ -223,8 +235,43 @@ static void *playthread(void *param) } } - SPU_playCDDAchannel((short *)sndbuffer, s); + // can't do it yet due to readahead.. + //cdrAttenuate((short *)sndbuffer, s / 4, 1); + do { + ret = SPU_playCDDAchannel((short *)sndbuffer, s); + if (ret == 0x7761) + { + usleep(6 * 1000); + } + } while (ret == 0x7761 && playing); // rearmed_wait } + + if (ret != 0x676f) { // !rearmed_go + // do approx sleep + long now; + + // HACK: stop feeding data while emu is paused + extern int stop; + while (stop && playing) + { + usleep(10000); + } + + now = GetTickCount(); + osleep = t - now; + if (osleep <= 0) { + osleep = 1; + t = now; + } + else if (osleep > CDDA_FRAMETIME) { + osleep = CDDA_FRAMETIME; + t = now; + } + + usleep(osleep * 1000); + t += CDDA_FRAMETIME; + } + } #ifdef _WIN32 @@ -250,12 +297,11 @@ static void stopCDDA() { } // start the CDDA playback -static void startCDDA(unsigned int sector) { +static void startCDDA(void) { if (playing) { stopCDDA(); } - cdda_cur_sector = sector; playing = TRUE; #ifdef _WIN32 @@ -270,10 +316,11 @@ static void startCDDA(unsigned int sector) { static int parsetoc(const char *isofile) { char tocname[MAXPATHLEN]; FILE *fi; - char linebuf[256], dummy[256], name[256]; + char linebuf[256], tmp[256], name[256]; char *token; char time[20], time2[20]; - unsigned int t, sector_offs; + unsigned int t, sector_offs, sector_size; + unsigned int current_zero_gap = 0; numtracks = 0; @@ -304,22 +351,34 @@ static int parsetoc(const char *isofile) { return -1; } } + // check if it's really a TOC named as a .cue + fgets(linebuf, sizeof(linebuf), fi); + token = strtok(linebuf, " "); + if (token && strncmp(token, "CD", 2) != 0 && strcmp(token, "CATALOG") != 0) { + fclose(fi); + return -1; + } + fseek(fi, 0, SEEK_SET); } memset(&ti, 0, sizeof(ti)); cddaBigEndian = TRUE; // cdrdao uses big-endian for CD Audio + sector_size = CD_FRAMESIZE_RAW; sector_offs = 2 * 75; // parse the .toc file while (fgets(linebuf, sizeof(linebuf), fi) != NULL) { // search for tracks - strncpy(dummy, linebuf, sizeof(linebuf)); - token = strtok(dummy, " "); + strncpy(tmp, linebuf, sizeof(linebuf)); + token = strtok(tmp, " "); if (token == NULL) continue; if (!strcmp(token, "TRACK")) { + sector_offs += current_zero_gap; + current_zero_gap = 0; + // get type of track token = strtok(NULL, " "); numtracks++; @@ -330,9 +389,11 @@ static int parsetoc(const char *isofile) { // check if this image contains mixed subchannel data token = strtok(NULL, " "); - if (token != NULL && !strncmp(token, "RW_RAW", 6)) { + if (token != NULL && !strncmp(token, "RW", 2)) { + sector_size = CD_FRAMESIZE_RAW + SUB_FRAMESIZE; subChanMixed = TRUE; - subChanRaw = TRUE; + if (!strncmp(token, "RW_RAW", 6)) + subChanRaw = TRUE; } } else if (!strncmp(token, "AUDIO", 5)) { @@ -342,9 +403,8 @@ static int parsetoc(const char *isofile) { else if (!strcmp(token, "DATAFILE")) { if (ti[numtracks].type == CDDA) { sscanf(linebuf, "DATAFILE \"%[^\"]\" #%d %8s", name, &t, time2); - t /= CD_FRAMESIZE_RAW + (subChanMixed ? SUB_FRAMESIZE : 0); ti[numtracks].start_offset = t; - t += sector_offs; + t = t / sector_size + sector_offs; sec2msf(t, (char *)&ti[numtracks].start); tok2msf((char *)&time2, (char *)&ti[numtracks].length); } @@ -356,21 +416,39 @@ static int parsetoc(const char *isofile) { else if (!strcmp(token, "FILE")) { sscanf(linebuf, "FILE \"%[^\"]\" #%d %8s %8s", name, &t, time, time2); tok2msf((char *)&time, (char *)&ti[numtracks].start); - t /= CD_FRAMESIZE_RAW + (subChanMixed ? SUB_FRAMESIZE : 0); + t += msf2sec(ti[numtracks].start) * sector_size; ti[numtracks].start_offset = t; - t += msf2sec(ti[numtracks].start) + sector_offs; + t = t / sector_size + sector_offs; sec2msf(t, (char *)&ti[numtracks].start); tok2msf((char *)&time2, (char *)&ti[numtracks].length); } - else if (!strcmp(token, "ZERO")) { - sscanf(linebuf, "ZERO AUDIO RW_RAW %8s", time); - tok2msf((char *)&time, dummy); - sector_offs += msf2sec(dummy); + else if (!strcmp(token, "ZERO") || !strcmp(token, "SILENCE")) { + // skip unneeded optional fields + while (token != NULL) { + token = strtok(NULL, " "); + if (strchr(token, ':') != NULL) + break; + } + if (token != NULL) { + tok2msf(token, tmp); + current_zero_gap = msf2sec(tmp); + } if (numtracks > 1) { t = ti[numtracks - 1].start_offset; + t /= sector_size; pregapOffset = t + msf2sec(ti[numtracks - 1].length); } } + else if (!strcmp(token, "START")) { + token = strtok(NULL, " "); + if (token != NULL && strchr(token, ':')) { + tok2msf(token, tmp); + t = msf2sec(tmp); + ti[numtracks].start_offset += (t - current_zero_gap) * sector_size; + t = msf2sec(ti[numtracks].start) + t; + sec2msf(t, (char *)&ti[numtracks].start); + } + } } fclose(fi); @@ -390,7 +468,8 @@ static int parsecue(const char *isofile) { char *tmp; char linebuf[256], tmpb[256], dummy[256]; unsigned int incue_max_len; - unsigned int t, file_len, sector_offs; + unsigned int t, file_len, mode, sector_offs; + unsigned int sector_size = 2352; numtracks = 0; @@ -423,10 +502,12 @@ static int parsecue(const char *isofile) { // build a path for files referenced in .cue strncpy(filepath, cuename, sizeof(filepath)); - tmp = strrchr(filepath, '/') + 1; - if (tmp == NULL) - tmp = strrchr(filepath, '\\') + 1; + tmp = strrchr(filepath, '/'); if (tmp == NULL) + tmp = strrchr(filepath, '\\'); + if (tmp != NULL) + tmp++; + else tmp = filepath; *tmp = 0; filepath[sizeof(filepath) - 1] = 0; @@ -449,24 +530,32 @@ static int parsecue(const char *isofile) { if (!strcmp(token, "TRACK")) { numtracks++; + sector_size = 0; if (strstr(linebuf, "AUDIO") != NULL) { ti[numtracks].type = CDDA; + sector_size = 2352; } - else if (strstr(linebuf, "MODE1/2352") != NULL || strstr(linebuf, "MODE2/2352") != NULL) { + else if (sscanf(linebuf, " TRACK %u MODE%u/%u", &t, &mode, §or_size) == 3) ti[numtracks].type = DATA; + else { + SysPrintf(".cue: failed to parse TRACK\n"); + ti[numtracks].type = numtracks == 1 ? DATA : CDDA; } + if (sector_size == 0) + sector_size = 2352; } else if (!strcmp(token, "INDEX")) { - sscanf(linebuf, " INDEX %02d %8s", &t, time); + if (sscanf(linebuf, " INDEX %02d %8s", &t, time) != 2) + SysPrintf(".cue: failed to parse INDEX\n"); tok2msf(time, (char *)&ti[numtracks].start); t = msf2sec(ti[numtracks].start); - ti[numtracks].start_offset = t; + ti[numtracks].start_offset = t * sector_size; t += sector_offs; sec2msf(t, ti[numtracks].start); // default track length to file length - t = file_len - ti[numtracks].start_offset; + t = file_len - ti[numtracks].start_offset / sector_size; sec2msf(t, ti[numtracks].length); if (numtracks > 1 && ti[numtracks].handle == NULL) { @@ -476,7 +565,7 @@ static int parsecue(const char *isofile) { sec2msf(t, ti[numtracks - 1].length); } if (numtracks > 1 && pregapOffset == -1) - pregapOffset = ti[numtracks].start_offset; + pregapOffset = ti[numtracks].start_offset / sector_size; } else if (!strcmp(token, "PREGAP")) { if (sscanf(linebuf, " PREGAP %8s", time) == 1) { @@ -486,26 +575,25 @@ static int parsecue(const char *isofile) { pregapOffset = -1; // mark to fill track start_offset } else if (!strcmp(token, "FILE")) { - sscanf(linebuf, " FILE \"%[^\"]\"", tmpb); - - // absolute path? - ti[numtracks + 1].handle = fopen(tmpb, "rb"); - if (ti[numtracks + 1].handle == NULL) { - // relative to .cue? - tmp = strrchr(tmpb, '\\'); - if (tmp == NULL) - tmp = strrchr(tmpb, '/'); - if (tmp != NULL) - tmp++; - else - tmp = tmpb; - strncpy(incue_fname, tmp, incue_max_len); - ti[numtracks + 1].handle = fopen(filepath, "rb"); - } + t = sscanf(linebuf, " FILE \"%255[^\"]\"", tmpb); + if (t != 1) + sscanf(linebuf, " FILE %255s", tmpb); + + tmp = strrchr(tmpb, '\\'); + if (tmp == NULL) + tmp = strrchr(tmpb, '/'); + if (tmp != NULL) + tmp++; + else + tmp = tmpb; + strncpy(incue_fname, tmp, incue_max_len); + ti[numtracks + 1].handle = fopen(filepath, "rb"); // update global offset if this is not first file in this .cue - if (numtracks + 1 > 1) + if (numtracks + 1 > 1) { + multifile = 1; sector_offs += file_len; + } file_len = 0; if (ti[numtracks + 1].handle == NULL) { @@ -567,7 +655,7 @@ static int parseccd(const char *isofile) { else if (!strncmp(linebuf, "INDEX 1=", 8)) { sscanf(linebuf, "INDEX 1=%d", &t); sec2msf(t + 2 * 75, ti[numtracks].start); - ti[numtracks].start_offset = t; + ti[numtracks].start_offset = t * 2352; // If we've already seen another track, this is its end if (numtracks > 1) { @@ -652,7 +740,7 @@ static int parsemds(const char *isofile) { // check if the image contains mixed subchannel data fseek(fi, offset + 1, SEEK_SET); - subChanMixed = (fgetc(fi) ? TRUE : FALSE); + subChanMixed = subChanRaw = (fgetc(fi) ? TRUE : FALSE); // read track data for (i = 1; i <= numtracks; i++) { @@ -674,14 +762,14 @@ static int parsemds(const char *isofile) { fseek(fi, offset + 0x28, SEEK_SET); fread(&l, 1, sizeof(unsigned int), fi); l = SWAP32(l); - ti[i].start_offset = l / CD_FRAMESIZE_RAW; + ti[i].start_offset = l; // get pregap fseek(fi, extra_offset, SEEK_SET); fread(&l, 1, sizeof(unsigned int), fi); l = SWAP32(l); if (l != 0 && i > 1) - pregapOffset = ti[i].start_offset; + pregapOffset = msf2sec(ti[i].start); // get the track length fread(&l, 1, sizeof(unsigned int), fi); @@ -695,7 +783,7 @@ static int parsemds(const char *isofile) { return 0; } -static int parsepbp(const char *isofile) { +static int handlepbp(const char *isofile) { struct { unsigned int sig; unsigned int dontcare[8]; @@ -714,8 +802,10 @@ static int parsepbp(const char *isofile) { unsigned int size; unsigned int dontcare[6]; } index_entry; - char psar_sig[9]; - unsigned int t, cd_length, cdimg_base; + char psar_sig[11]; + off_t psisoimg_offs, cdimg_base; + unsigned int t, cd_length; + unsigned int offsettab[8]; const char *ext = NULL; int i, ret; @@ -724,31 +814,72 @@ static int parsepbp(const char *isofile) { if (ext == NULL || (strcmp(ext, ".pbp") != 0 && strcmp(ext, ".PBP") != 0)) return -1; + fseeko(cdHandle, 0, SEEK_SET); + numtracks = 0; ret = fread(&pbp_hdr, 1, sizeof(pbp_hdr), cdHandle); if (ret != sizeof(pbp_hdr)) { - fprintf(stderr, "failed to read pbp\n"); + SysPrintf("failed to read pbp\n"); goto fail_io; } - ret = fseek(cdHandle, pbp_hdr.psar_offs, SEEK_SET); + ret = fseeko(cdHandle, pbp_hdr.psar_offs, SEEK_SET); if (ret != 0) { - fprintf(stderr, "failed to seek to %x\n", pbp_hdr.psar_offs); + SysPrintf("failed to seek to %x\n", pbp_hdr.psar_offs); goto fail_io; } + psisoimg_offs = pbp_hdr.psar_offs; fread(psar_sig, 1, sizeof(psar_sig), cdHandle); - psar_sig[8] = 0; - if (strcmp(psar_sig, "PSISOIMG") != 0) { - fprintf(stderr, "bad psar_sig: %s\n", psar_sig); + psar_sig[10] = 0; + if (strcmp(psar_sig, "PSTITLEIMG") == 0) { + // multidisk image? + ret = fseeko(cdHandle, pbp_hdr.psar_offs + 0x200, SEEK_SET); + if (ret != 0) { + SysPrintf("failed to seek to %x\n", pbp_hdr.psar_offs + 0x200); + goto fail_io; + } + + if (fread(&offsettab, 1, sizeof(offsettab), cdHandle) != sizeof(offsettab)) { + SysPrintf("failed to read offsettab\n"); + goto fail_io; + } + + for (i = 0; i < sizeof(offsettab) / sizeof(offsettab[0]); i++) { + if (offsettab[i] == 0) + break; + } + cdrIsoMultidiskCount = i; + if (cdrIsoMultidiskCount == 0) { + SysPrintf("multidisk eboot has 0 images?\n"); + goto fail_io; + } + + if (cdrIsoMultidiskSelect >= cdrIsoMultidiskCount) + cdrIsoMultidiskSelect = 0; + + psisoimg_offs += offsettab[cdrIsoMultidiskSelect]; + + ret = fseeko(cdHandle, psisoimg_offs, SEEK_SET); + if (ret != 0) { + SysPrintf("failed to seek to %llx\n", (long long)psisoimg_offs); + goto fail_io; + } + + fread(psar_sig, 1, sizeof(psar_sig), cdHandle); + psar_sig[10] = 0; + } + + if (strcmp(psar_sig, "PSISOIMG00") != 0) { + SysPrintf("bad psar_sig: %s\n", psar_sig); goto fail_io; } // seek to TOC - ret = fseek(cdHandle, pbp_hdr.psar_offs + 0x800, SEEK_SET); + ret = fseeko(cdHandle, psisoimg_offs + 0x800, SEEK_SET); if (ret != 0) { - fprintf(stderr, "failed to seek to %x\n", pbp_hdr.psar_offs); + SysPrintf("failed to seek to %llx\n", (long long)psisoimg_offs + 0x800); goto fail_io; } @@ -768,6 +899,7 @@ static int parsepbp(const char *isofile) { ti[i].start_offset = btoi(toc_entry.index0[0]) * 60 * 75 + btoi(toc_entry.index0[1]) * 75 + btoi(toc_entry.index0[2]); + ti[i].start_offset *= 2352; ti[i].start[0] = btoi(toc_entry.index1[0]); ti[i].start[1] = btoi(toc_entry.index1[1]); ti[i].start[2] = btoi(toc_entry.index1[2]); @@ -777,13 +909,13 @@ static int parsepbp(const char *isofile) { sec2msf(t, ti[i - 1].length); } } - t = cd_length - ti[numtracks].start_offset; + t = cd_length - ti[numtracks].start_offset / 2352; sec2msf(t, ti[numtracks].length); // seek to ISO index - ret = fseek(cdHandle, pbp_hdr.psar_offs + 0x4000, SEEK_SET); + ret = fseeko(cdHandle, psisoimg_offs + 0x4000, SEEK_SET); if (ret != 0) { - fprintf(stderr, "failed to seek to ISO index\n"); + SysPrintf("failed to seek to ISO index\n"); goto fail_io; } @@ -791,6 +923,7 @@ static int parsepbp(const char *isofile) { if (compr_img == NULL) goto fail_io; + compr_img->block_shift = 4; compr_img->current_block = (unsigned int)-1; compr_img->index_len = (0x100000 - 0x4000) / sizeof(index_entry); @@ -798,11 +931,11 @@ static int parsepbp(const char *isofile) { if (compr_img->index_table == NULL) goto fail_io; - cdimg_base = pbp_hdr.psar_offs + 0x100000; + cdimg_base = psisoimg_offs + 0x100000; for (i = 0; i < compr_img->index_len; i++) { ret = fread(&index_entry, 1, sizeof(index_entry), cdHandle); if (ret != sizeof(index_entry)) { - fprintf(stderr, "failed to read index_entry #%d\n", i); + SysPrintf("failed to read index_entry #%d\n", i); goto fail_index; } @@ -819,8 +952,170 @@ fail_index: free(compr_img->index_table); compr_img->index_table = NULL; fail_io: + if (compr_img != NULL) { + free(compr_img); + compr_img = NULL; + } + return -1; +} + +static int handlecbin(const char *isofile) { + struct + { + char magic[4]; + unsigned int header_size; + unsigned long long total_bytes; + unsigned int block_size; + unsigned char ver; // 1 + unsigned char align; + unsigned char rsv_06[2]; + } ciso_hdr; + const char *ext = NULL; + unsigned int *index_table = NULL; + unsigned int index = 0, plain; + int i, ret; + + if (strlen(isofile) >= 5) + ext = isofile + strlen(isofile) - 5; + if (ext == NULL || (strcasecmp(ext + 1, ".cbn") != 0 && strcasecmp(ext, ".cbin") != 0)) + return -1; + + fseek(cdHandle, 0, SEEK_SET); + + ret = fread(&ciso_hdr, 1, sizeof(ciso_hdr), cdHandle); + if (ret != sizeof(ciso_hdr)) { + SysPrintf("failed to read ciso header\n"); + return -1; + } + + if (strncmp(ciso_hdr.magic, "CISO", 4) != 0 || ciso_hdr.total_bytes <= 0 || ciso_hdr.block_size <= 0) { + SysPrintf("bad ciso header\n"); + return -1; + } + if (ciso_hdr.header_size != 0 && ciso_hdr.header_size != sizeof(ciso_hdr)) { + ret = fseeko(cdHandle, ciso_hdr.header_size, SEEK_SET); + if (ret != 0) { + SysPrintf("failed to seek to %x\n", ciso_hdr.header_size); + return -1; + } + } + + compr_img = calloc(1, sizeof(*compr_img)); + if (compr_img == NULL) + goto fail_io; + + compr_img->block_shift = 0; + compr_img->current_block = (unsigned int)-1; + + compr_img->index_len = ciso_hdr.total_bytes / ciso_hdr.block_size; + index_table = malloc((compr_img->index_len + 1) * sizeof(index_table[0])); + if (index_table == NULL) + goto fail_io; + + ret = fread(index_table, sizeof(index_table[0]), compr_img->index_len, cdHandle); + if (ret != compr_img->index_len) { + SysPrintf("failed to read index table\n"); + goto fail_index; + } + + compr_img->index_table = malloc((compr_img->index_len + 1) * sizeof(compr_img->index_table[0])); + if (compr_img->index_table == NULL) + goto fail_index; + + for (i = 0; i < compr_img->index_len + 1; i++) { + index = index_table[i]; + plain = index & 0x80000000; + index &= 0x7fffffff; + compr_img->index_table[i] = (off_t)index << ciso_hdr.align; + if (plain) + compr_img->index_table[i] |= OFF_T_MSB; + } + + return 0; + +fail_index: + free(index_table); +fail_io: + if (compr_img != NULL) { + free(compr_img); + compr_img = NULL; + } + return -1; +} + +#ifdef HAVE_CHD +static int handlechd(const char *isofile) { + chd_img = calloc(1, sizeof(*chd_img)); + if (chd_img == NULL) + goto fail_io; + + if(chd_open(isofile, CHD_OPEN_READ, NULL, &chd_img->chd) != CHDERR_NONE) + goto fail_io; + + chd_img->header = chd_get_header(chd_img->chd); + + chd_img->buffer = malloc(chd_img->header->hunkbytes); + if (chd_img->buffer == NULL) + goto fail_io; + + chd_img->sectors_per_hunk = chd_img->header->hunkbytes / (CD_FRAMESIZE_RAW + SUB_FRAMESIZE); + chd_img->current_hunk = (unsigned int)-1; + + cddaBigEndian = TRUE; + + numtracks = 0; + int frame_offset = 150; + memset(ti, 0, sizeof(ti)); + + while (1) + { + struct { + char type[64]; + char subtype[32]; + char pgtype[32]; + char pgsub[32]; + uint32_t track; + uint32_t frames; + uint32_t pregap; + uint32_t postgap; + } md = {}; + char meta[256]; + uint32_t meta_size = 0; + + if (chd_get_metadata(chd_img->chd, CDROM_TRACK_METADATA2_TAG, numtracks, meta, sizeof(meta), &meta_size, NULL, NULL) == CHDERR_NONE) + sscanf(meta, CDROM_TRACK_METADATA2_FORMAT, &md.track, md.type, md.subtype, &md.frames, &md.pregap, md.pgtype, md.pgsub, &md.postgap); + else if (chd_get_metadata(chd_img->chd, CDROM_TRACK_METADATA_TAG, numtracks, meta, sizeof(meta), &meta_size, NULL, NULL) == CHDERR_NONE) + sscanf(meta, CDROM_TRACK_METADATA_FORMAT, &md.track, md.type, md.subtype, &md.frames); + else + break; + + ti[md.track].type = !strncmp(md.type, "AUDIO", 5) ? CDDA : DATA; + + sec2msf(frame_offset + md.pregap, ti[md.track].start); + sec2msf(md.frames - md.pregap, ti[md.track].length); + + if (!strcmp(md.type, md.pgtype)) + frame_offset += md.pregap; + + ti[md.track].start_offset = frame_offset * CD_FRAMESIZE_RAW; + + frame_offset += md.frames; + frame_offset += md.postgap; + numtracks++; + } + + if (numtracks) + return 0; + +fail_io: + if (chd_img != NULL) { + free(chd_img->buffer); + free(chd_img); + chd_img = NULL; + } return -1; } +#endif // this function tries to get the .sub file of the given .img static int opensubfile(const char *isoname) { @@ -845,13 +1140,18 @@ static int opensubfile(const char *isoname) { } static int opensbifile(const char *isoname) { - char sbiname[MAXPATHLEN]; + char sbiname[MAXPATHLEN], disknum[MAXPATHLEN] = "0"; int s; strncpy(sbiname, isoname, sizeof(sbiname)); sbiname[MAXPATHLEN - 1] = '\0'; if (strlen(sbiname) >= 4) { - strcpy(sbiname + strlen(sbiname) - 4, ".sbi"); + if (cdrIsoMultidiskCount > 1) { + sprintf(disknum, "_%i.sbi", cdrIsoMultidiskSelect + 1); + strcpy(sbiname + strlen(sbiname) - 4, disknum); + } + else + strcpy(sbiname + strlen(sbiname) - 4, ".sbi"); } else { return -1; @@ -863,18 +1163,206 @@ static int opensbifile(const char *isoname) { return LoadSBI(sbiname, s); } -static int cdread_normal(FILE *f, void *dest, int sector, int offset) +#ifdef _WIN32 +static void readThreadStop() {} +static void readThreadStart() {} +#else +static pthread_t read_thread_id; + +static pthread_cond_t read_thread_msg_avail; +static pthread_cond_t read_thread_msg_done; +static pthread_mutex_t read_thread_msg_lock; + +static pthread_cond_t sectorbuffer_cond; +static pthread_mutex_t sectorbuffer_lock; + +static boolean read_thread_running = FALSE; +static int read_thread_sector_start = -1; +static int read_thread_sector_end = -1; + +typedef struct { + int sector; + long ret; + unsigned char data[CD_FRAMESIZE_RAW]; +} SectorBufferEntry; + +#define SECTOR_BUFFER_SIZE 4096 + +static SectorBufferEntry *sectorbuffer; +static size_t sectorbuffer_index; + +int (*sync_cdimg_read_func)(FILE *f, unsigned int base, void *dest, int sector); +unsigned char *(*sync_CDR_getBuffer)(void); + +static unsigned char * CALLBACK ISOgetBuffer_async(void); +static int cdread_async(FILE *f, unsigned int base, void *dest, int sector); + +static void *readThreadMain(void *param) { + int max_sector = -1; + int requested_sector_start = -1; + int requested_sector_end = -1; + int last_read_sector = -1; + int index = 0; + + int ra_sector = -1; + int max_ra = 128; + int initial_ra = 1; + int speedmult_ra = 4; + + int ra_count = 0; + int how_far_ahead = 0; + + unsigned char tmpdata[CD_FRAMESIZE_RAW]; + long ret; + + max_sector = msf2sec(ti[numtracks].start) + msf2sec(ti[numtracks].length); + + while(1) { + pthread_mutex_lock(&read_thread_msg_lock); + + // If we don't have readahead and we don't have a sector request, wait for one. + // If we still have readahead to go, don't block, just keep going. + // And if we ever have a sector request pending, acknowledge and reset it. + + if (!ra_count) { + if (read_thread_sector_start == -1 && read_thread_running) { + pthread_cond_wait(&read_thread_msg_avail, &read_thread_msg_lock); + } + } + + if (read_thread_sector_start != -1) { + requested_sector_start = read_thread_sector_start; + requested_sector_end = read_thread_sector_end; + read_thread_sector_start = -1; + read_thread_sector_end = -1; + pthread_cond_signal(&read_thread_msg_done); + } + + pthread_mutex_unlock(&read_thread_msg_lock); + + if (!read_thread_running) + break; + + // Readahead code, based on the implementation in mednafen psx's cdromif.cpp + if (requested_sector_start != -1) { + if (last_read_sector != -1 && last_read_sector == (requested_sector_start - 1)) { + how_far_ahead = ra_sector - requested_sector_end; + + if(how_far_ahead <= max_ra) + ra_count = (max_ra - how_far_ahead + 1 ? max_ra - how_far_ahead + 1 : speedmult_ra); + else + ra_count++; + } else if (requested_sector_end != last_read_sector) { + ra_sector = requested_sector_end; + ra_count = initial_ra; + } + + last_read_sector = requested_sector_end; + } + + // check for end of CD + if (ra_count && ra_sector >= max_sector) { + ra_count = 0; + } + + if (ra_count) { + + index = ra_sector % SECTOR_BUFFER_SIZE; + pthread_mutex_lock(§orbuffer_lock); + if (sectorbuffer[index].sector != ra_sector) { + pthread_mutex_unlock(§orbuffer_lock); + + ret = sync_cdimg_read_func(cdHandle, 0, tmpdata, ra_sector); + + pthread_mutex_lock(§orbuffer_lock); + sectorbuffer[index].ret = ret; + sectorbuffer[index].sector = ra_sector; + memcpy(sectorbuffer[index].data, tmpdata, CD_FRAMESIZE_RAW); + } + pthread_cond_signal(§orbuffer_cond); + pthread_mutex_unlock(§orbuffer_lock); + + ra_sector++; + ra_count--; + } + } + + return NULL; +} + +static void readThreadStop() { + if (read_thread_running == TRUE) { + read_thread_running = FALSE; + pthread_cond_signal(&read_thread_msg_avail); + pthread_join(read_thread_id, NULL); + } + + pthread_cond_destroy(&read_thread_msg_done); + pthread_cond_destroy(&read_thread_msg_avail); + pthread_mutex_destroy(&read_thread_msg_lock); + + pthread_cond_destroy(§orbuffer_cond); + pthread_mutex_destroy(§orbuffer_lock); + + CDR_getBuffer = sync_CDR_getBuffer; + cdimg_read_func = sync_cdimg_read_func; + + free(sectorbuffer); + sectorbuffer = NULL; +} + +static void readThreadStart() { + SysPrintf("Starting async CD thread\n"); + + if (read_thread_running == TRUE) + return; + + read_thread_running = TRUE; + read_thread_sector_start = -1; + read_thread_sector_end = -1; + sectorbuffer_index = 0; + + sectorbuffer = calloc(SECTOR_BUFFER_SIZE, sizeof(SectorBufferEntry)); + if(!sectorbuffer) + goto error; + + sectorbuffer[0].sector = -1; // Otherwise we might think we've already fetched sector 0! + + sync_CDR_getBuffer = CDR_getBuffer; + CDR_getBuffer = ISOgetBuffer_async; + sync_cdimg_read_func = cdimg_read_func; + cdimg_read_func = cdread_async; + + if (pthread_cond_init(&read_thread_msg_avail, NULL) || + pthread_cond_init(&read_thread_msg_done, NULL) || + pthread_mutex_init(&read_thread_msg_lock, NULL) || + pthread_cond_init(§orbuffer_cond, NULL) || + pthread_mutex_init(§orbuffer_lock, NULL) || + pthread_create(&read_thread_id, NULL, readThreadMain, NULL)) + goto error; + + return; + + error: + SysPrintf("Error starting async CD thread\n"); + SysPrintf("Falling back to sync\n"); + + readThreadStop(); +} +#endif + +static int cdread_normal(FILE *f, unsigned int base, void *dest, int sector) { - fseek(f, sector * CD_FRAMESIZE_RAW + offset, SEEK_SET); - return fread(dest, 1, CD_FRAMESIZE_RAW - offset, f); + fseek(f, base + sector * CD_FRAMESIZE_RAW, SEEK_SET); + return fread(dest, 1, CD_FRAMESIZE_RAW, f); } -static int cdread_sub_mixed(FILE *f, void *dest, int sector, int offset) +static int cdread_sub_mixed(FILE *f, unsigned int base, void *dest, int sector) { int ret; - fseek(f, sector * (CD_FRAMESIZE_RAW + SUB_FRAMESIZE) + offset, SEEK_SET); - ret = fread(dest, 1, CD_FRAMESIZE_RAW - offset, f); + fseek(f, base + sector * (CD_FRAMESIZE_RAW + SUB_FRAMESIZE), SEEK_SET); + ret = fread(dest, 1, CD_FRAMESIZE_RAW, f); fread(subbuffer, 1, SUB_FRAMESIZE, f); if (subChanRaw) DecodeRawSubData(); @@ -882,7 +1370,7 @@ static int cdread_sub_mixed(FILE *f, void *dest, int sector, int offset) return ret; } -static int uncompress2(void *out, unsigned long *out_size, void *in, unsigned long in_size) +static int uncompress2_pcsx(void *out, unsigned long *out_size, void *in, unsigned long in_size) { static z_stream z; int ret = 0; @@ -913,14 +1401,19 @@ static int uncompress2(void *out, unsigned long *out_size, void *in, unsigned lo return ret == 1 ? 0 : ret; } -static int cdread_compressed(FILE *f, void *dest, int sector, int offset) +static int cdread_compressed(FILE *f, unsigned int base, void *dest, int sector) { - unsigned int start_byte, size; - unsigned long cdbuffer_size; + unsigned long cdbuffer_size, cdbuffer_size_expect; + unsigned int size; + int is_compressed; + off_t start_byte; int ret, block; - block = sector >> 4; - compr_img->sector_in_blk = sector & 15; + if (base) + sector += base / 2352; + + block = sector >> compr_img->block_shift; + compr_img->sector_in_blk = sector & ((1 << compr_img->block_shift) - 1); if (block == compr_img->current_block) { //printf("hit sect %d\n", sector); @@ -928,72 +1421,167 @@ static int cdread_compressed(FILE *f, void *dest, int sector, int offset) } if (sector >= compr_img->index_len * 16) { - fprintf(stderr, "sector %d is past img end\n", sector); + SysPrintf("sector %d is past img end\n", sector); return -1; } - start_byte = compr_img->index_table[block]; - if (fseek(cdHandle, start_byte, SEEK_SET) != 0) { - fprintf(stderr, "seek error for block %d at %x: ", - block, start_byte); + start_byte = compr_img->index_table[block] & ~OFF_T_MSB; + if (fseeko(cdHandle, start_byte, SEEK_SET) != 0) { + SysPrintf("seek error for block %d at %llx: ", + block, (long long)start_byte); perror(NULL); return -1; } - size = compr_img->index_table[block + 1] - start_byte; + is_compressed = !(compr_img->index_table[block] & OFF_T_MSB); + size = (compr_img->index_table[block + 1] & ~OFF_T_MSB) - start_byte; if (size > sizeof(compr_img->buff_compressed)) { - fprintf(stderr, "block %d is too large: %u\n", block, size); + SysPrintf("block %d is too large: %u\n", block, size); return -1; } - if (fread(compr_img->buff_compressed, 1, size, cdHandle) != size) { - fprintf(stderr, "read error for block %d at %x: ", block, start_byte); + if (fread(is_compressed ? compr_img->buff_compressed : compr_img->buff_raw[0], + 1, size, cdHandle) != size) { + SysPrintf("read error for block %d at %x: ", block, start_byte); perror(NULL); return -1; } - cdbuffer_size = sizeof(compr_img->buff_raw[0]) * 16; - ret = uncompress2(compr_img->buff_raw[0], &cdbuffer_size, compr_img->buff_compressed, size); - if (ret != 0) { - fprintf(stderr, "uncompress failed with %d for block %d, sector %d\n", - ret, block, sector); - return -1; + if (is_compressed) { + cdbuffer_size_expect = sizeof(compr_img->buff_raw[0]) << compr_img->block_shift; + cdbuffer_size = cdbuffer_size_expect; + ret = uncompress2_pcsx(compr_img->buff_raw[0], &cdbuffer_size, compr_img->buff_compressed, size); + if (ret != 0) { + SysPrintf("uncompress failed with %d for block %d, sector %d\n", + ret, block, sector); + return -1; + } + if (cdbuffer_size != cdbuffer_size_expect) + SysPrintf("cdbuffer_size: %lu != %lu, sector %d\n", cdbuffer_size, + cdbuffer_size_expect, sector); } - if (cdbuffer_size != sizeof(compr_img->buff_raw[0]) * 16) - fprintf(stderr, "cdbuffer_size: %lu != %d, sector %d\n", cdbuffer_size, - sizeof(compr_img->buff_raw[0]) * 16, sector); // done at last! compr_img->current_block = block; finish: if (dest != cdbuffer) // copy avoid HACK - memcpy(dest, compr_img->buff_raw[compr_img->sector_in_blk] + offset, - CD_FRAMESIZE_RAW - offset); - return CD_FRAMESIZE_RAW - offset; + memcpy(dest, compr_img->buff_raw[compr_img->sector_in_blk], + CD_FRAMESIZE_RAW); + return CD_FRAMESIZE_RAW; } -static int cdread_2048(FILE *f, void *dest, int sector, int offset) +#ifdef HAVE_CHD +static int cdread_chd(FILE *f, unsigned int base, void *dest, int sector) +{ + int hunk; + + if (base) + sector += base / CD_FRAMESIZE_RAW; + + hunk = sector / chd_img->sectors_per_hunk; + chd_img->sector_in_hunk = sector % chd_img->sectors_per_hunk; + + if (hunk == chd_img->current_hunk) + goto finish; + + chd_read(chd_img->chd, hunk, chd_img->buffer); + + chd_img->current_hunk = hunk; + +finish: + if (dest != cdbuffer) // copy avoid HACK + memcpy(dest, chd_img->buffer[chd_img->sector_in_hunk], + CD_FRAMESIZE_RAW); + return CD_FRAMESIZE_RAW; +} +#endif +static int cdread_2048(FILE *f, unsigned int base, void *dest, int sector) { int ret; - fseek(f, sector * 2048, SEEK_SET); - ret = fread((char *)dest + 12, 1, 2048, f); + fseek(f, base + sector * 2048, SEEK_SET); + ret = fread((char *)dest + 12 * 2, 1, 2048, f); // not really necessary, fake mode 2 header - memset(cdbuffer, 0, 12); - sec2msf(sector + 2 * 75, (char *)cdbuffer); - cdbuffer[3] = 1; + memset(cdbuffer, 0, 12 * 2); + sec2msf(sector + 2 * 75, (char *)&cdbuffer[12]); + cdbuffer[12 + 3] = 1; return ret; } +#ifndef _WIN32 + +static int cdread_async(FILE *f, unsigned int base, void *dest, int sector) { + boolean found = FALSE; + int i = sector % SECTOR_BUFFER_SIZE; + long ret; + + if (f != cdHandle || base != 0 || dest != cdbuffer) { + // Async reads are only supported for cdbuffer, so call the sync + // function directly. + return sync_cdimg_read_func(f, base, dest, sector); + } + + pthread_mutex_lock(&read_thread_msg_lock); + + // Only wait if we're not trying to read the next sector and + // sector_start is set (meaning the last request hasn't been + // processed yet) + while(read_thread_sector_start != -1 && read_thread_sector_end + 1 != sector) { + pthread_cond_wait(&read_thread_msg_done, &read_thread_msg_lock); + } + + if (read_thread_sector_start == -1) + read_thread_sector_start = sector; + + read_thread_sector_end = sector; + pthread_cond_signal(&read_thread_msg_avail); + pthread_mutex_unlock(&read_thread_msg_lock); + + do { + pthread_mutex_lock(§orbuffer_lock); + if (sectorbuffer[i].sector == sector) { + sectorbuffer_index = i; + ret = sectorbuffer[i].ret; + found = TRUE; + } + + if (!found) { + pthread_cond_wait(§orbuffer_cond, §orbuffer_lock); + } + pthread_mutex_unlock(§orbuffer_lock); + } while (!found); + + return ret; +} + +#endif + static unsigned char * CALLBACK ISOgetBuffer_compr(void) { return compr_img->buff_raw[compr_img->sector_in_blk] + 12; } +#ifdef HAVE_CHD +static unsigned char * CALLBACK ISOgetBuffer_chd(void) { + return chd_img->buffer[chd_img->sector_in_hunk] + 12; +} +#endif + +#ifndef _WIN32 +static unsigned char * CALLBACK ISOgetBuffer_async(void) { + unsigned char *buffer; + pthread_mutex_lock(§orbuffer_lock); + buffer = sectorbuffer[sectorbuffer_index].data; + pthread_mutex_unlock(§orbuffer_lock); + return buffer + 12; +} + +#endif + static unsigned char * CALLBACK ISOgetBuffer(void) { - return cdbuffer; + return cdbuffer + 12; } static void PrintTracks(void) { @@ -1011,6 +1599,9 @@ static void PrintTracks(void) { // file for playback static long CALLBACK ISOopen(void) { boolean isMode1ISO = FALSE; + char alt_bin_filename[MAXPATHLEN]; + const char *bin_filename; + char image_str[1024] = {0}; if (cdHandle != NULL) { return 0; // it's already open @@ -1018,58 +1609,102 @@ static long CALLBACK ISOopen(void) { cdHandle = fopen(GetIsoFile(), "rb"); if (cdHandle == NULL) { + SysPrintf(_("Could't open '%s' for reading: %s\n"), + GetIsoFile(), strerror(errno)); return -1; } - SysPrintf(_("Loaded CD Image: %s"), GetIsoFile()); + sprintf(image_str, "Loaded CD Image: %s", GetIsoFile()); cddaBigEndian = FALSE; subChanMixed = FALSE; subChanRaw = FALSE; pregapOffset = 0; + cdrIsoMultidiskCount = 1; + multifile = 0; CDR_getBuffer = ISOgetBuffer; cdimg_read_func = cdread_normal; - if (parsecue(GetIsoFile()) == 0) { - SysPrintf("[+cue]"); - } - else if (parsetoc(GetIsoFile()) == 0) { - SysPrintf("[+toc]"); + if (parsetoc(GetIsoFile()) == 0) { + strcat(image_str, "[+toc]"); } else if (parseccd(GetIsoFile()) == 0) { - SysPrintf("[+ccd]"); + strcat(image_str, "[+ccd]"); } else if (parsemds(GetIsoFile()) == 0) { - SysPrintf("[+mds]"); + strcat(image_str, "[+mds]"); + } + else if (parsecue(GetIsoFile()) == 0) { + strcat(image_str, "[+cue]"); } - else if (parsepbp(GetIsoFile()) == 0) { - SysPrintf("[pbp]"); + if (handlepbp(GetIsoFile()) == 0) { + strcat(image_str, "[+pbp]"); CDR_getBuffer = ISOgetBuffer_compr; cdimg_read_func = cdread_compressed; } + else if (handlecbin(GetIsoFile()) == 0) { + strcat(image_str, "[+cbin]"); + CDR_getBuffer = ISOgetBuffer_compr; + cdimg_read_func = cdread_compressed; + } +#ifdef HAVE_CHD + else if (handlechd(GetIsoFile()) == 0) { + strcat(image_str, "[+chd]"); + CDR_getBuffer = ISOgetBuffer_chd; + cdimg_read_func = cdread_chd; + } +#endif if (!subChanMixed && opensubfile(GetIsoFile()) == 0) { - SysPrintf("[+sub]"); + strcat(image_str, "[+sub]"); } if (opensbifile(GetIsoFile()) == 0) { - SysPrintf("[+sbi]"); + strcat(image_str, "[+sbi]"); + } + + fseeko(cdHandle, 0, SEEK_END); + + // maybe user selected metadata file instead of main .bin .. + bin_filename = GetIsoFile(); + if (ftello(cdHandle) < 2352 * 0x10) { + static const char *exts[] = { ".bin", ".BIN", ".img", ".IMG" }; + FILE *tmpf = NULL; + size_t i; + char *p; + + strncpy(alt_bin_filename, bin_filename, sizeof(alt_bin_filename)); + alt_bin_filename[MAXPATHLEN - 1] = '\0'; + if (strlen(alt_bin_filename) >= 4) { + p = alt_bin_filename + strlen(alt_bin_filename) - 4; + for (i = 0; i < sizeof(exts) / sizeof(exts[0]); i++) { + strcpy(p, exts[i]); + tmpf = fopen(alt_bin_filename, "rb"); + if (tmpf != NULL) + break; + } + } + if (tmpf != NULL) { + bin_filename = alt_bin_filename; + fclose(cdHandle); + cdHandle = tmpf; + fseeko(cdHandle, 0, SEEK_END); + } } // guess whether it is mode1/2048 - fseek(cdHandle, 0, SEEK_END); - if (ftell(cdHandle) % 2048 == 0) { + if (ftello(cdHandle) % 2048 == 0) { unsigned int modeTest = 0; fseek(cdHandle, 0, SEEK_SET); fread(&modeTest, 4, 1, cdHandle); if (SWAP32(modeTest) != 0xffffff00) { - SysPrintf("[2048]"); + strcat(image_str, "[2048]"); isMode1ISO = TRUE; } } fseek(cdHandle, 0, SEEK_SET); - SysPrintf(".\n"); + SysPrintf("%s.\n", image_str); PrintTracks(); @@ -1080,10 +1715,14 @@ static long CALLBACK ISOopen(void) { // make sure we have another handle open for cdda if (numtracks > 1 && ti[1].handle == NULL) { - ti[1].handle = fopen(GetIsoFile(), "rb"); + ti[1].handle = fopen(bin_filename, "rb"); } - cdda_cur_sector = cdda_start_sector = 0; + cdda_cur_sector = 0; + cdda_file_offset = 0; + if (Config.AsyncCD) { + readThreadStart(); + } return 0; } @@ -1107,6 +1746,15 @@ static long CALLBACK ISOclose(void) { compr_img = NULL; } +#ifdef HAVE_CHD + if (chd_img != NULL) { + chd_close(chd_img->chd); + free(chd_img->buffer); + free(chd_img); + chd_img = NULL; + } +#endif + for (i = 1; i <= numtracks; i++) { if (ti[i].handle != NULL) { fclose(ti[i].handle); @@ -1114,8 +1762,16 @@ static long CALLBACK ISOclose(void) { } } numtracks = 0; + ti[1].type = 0; UnloadSBI(); + memset(cdbuffer, 0, sizeof(cdbuffer)); + CDR_getBuffer = ISOgetBuffer; + + if (Config.AsyncCD) { + readThreadStop(); + } + return 0; } @@ -1155,7 +1811,6 @@ static long CALLBACK ISOgetTN(unsigned char *buffer) { // byte 2 - minute static long CALLBACK ISOgetTD(unsigned char track, unsigned char *buffer) { if (track == 0) { - // CD length according pcsxr-svn (done a bit different here) unsigned int sect; unsigned char time[3]; sect = msf2sec(ti[numtracks].start) + msf2sec(ti[numtracks].length); @@ -1199,6 +1854,7 @@ static void DecodeRawSubData(void) { // uses bcd format static long CALLBACK ISOreadTrack(unsigned char *time) { int sector = MSF2SECT(btoi(time[0]), btoi(time[1]), btoi(time[2])); + long ret; if (cdHandle == NULL) { return -1; @@ -1213,7 +1869,9 @@ static long CALLBACK ISOreadTrack(unsigned char *time) { } } - cdimg_read_func(cdHandle, cdbuffer, sector, 12); + ret = cdimg_read_func(cdHandle, 0, cdbuffer, sector); + if (ret < 0) + return -1; if (subHandle != NULL) { fseek(subHandle, sector * SUB_FRAMESIZE, SEEK_SET); @@ -1229,38 +1887,30 @@ static long CALLBACK ISOreadTrack(unsigned char *time) { // sector: byte 0 - minute; byte 1 - second; byte 2 - frame // does NOT uses bcd format static long CALLBACK ISOplay(unsigned char *time) { - unsigned int i, abs_sect; - int file_sect; + unsigned int i; if (numtracks <= 1) return 0; // find the track - abs_sect = msf2sec((char *)time); - for (i = numtracks; i > 1; i--) - if (msf2sec(ti[i].start) <= abs_sect + 2 * 75) + cdda_cur_sector = msf2sec((char *)time); + for (i = numtracks; i > 1; i--) { + cdda_first_sector = msf2sec(ti[i].start); + if (cdda_first_sector <= cdda_cur_sector + 2 * 75) break; - - file_sect = ti[i].start_offset + (abs_sect - msf2sec(ti[i].start)); - if (file_sect < 0) - file_sect = 0; + } + cdda_file_offset = ti[i].start_offset; // find the file that contains this track for (; i > 1; i--) if (ti[i].handle != NULL) break; - cdda_start_sector = abs_sect - file_sect; cddaHandle = ti[i].handle; - if (pregapOffset && (unsigned int)(pregapOffset - file_sect) < 2 * 75) { - // get out of the missing pregap to avoid noise - file_sect = pregapOffset; - } + if (SPU_playCDDAchannel != NULL) + startCDDA(); - if (SPU_playCDDAchannel != NULL) { - startCDDA(file_sect); - } return 0; } @@ -1280,20 +1930,74 @@ static unsigned char* CALLBACK ISOgetBufferSub(void) { } static long CALLBACK ISOgetStatus(struct CdrStat *stat) { - int sec; - + u32 sect; + CDR__getStatus(stat); - + if (playing) { stat->Type = 0x02; stat->Status |= 0x80; } else { - stat->Type = 0x01; + // BIOS - boot ID (CD type) + stat->Type = ti[1].type; + } + + // relative -> absolute time + sect = cddaCurPos; + sec2msf(sect, (char *)stat->Time); + + return 0; +} + +// read CDDA sector into buffer +long CALLBACK ISOreadCDDA(unsigned char m, unsigned char s, unsigned char f, unsigned char *buffer) { + unsigned char msf[3] = {m, s, f}; + unsigned int file, track, track_start = 0; + int ret; + + cddaCurPos = msf2sec((char *)msf); + + // find current track index + for (track = numtracks; ; track--) { + track_start = msf2sec(ti[track].start); + if (track_start <= cddaCurPos) + break; + if (track == 1) + break; + } + + // data tracks play silent + if (ti[track].type != CDDA) { + memset(buffer, 0, CD_FRAMESIZE_RAW); + return 0; + } + + file = 1; + if (multifile) { + // find the file that contains this track + for (file = track; file > 1; file--) + if (ti[file].handle != NULL) + break; + } + + ret = cdimg_read_func(ti[file].handle, ti[track].start_offset, + buffer, cddaCurPos - track_start); + if (ret != CD_FRAMESIZE_RAW) { + memset(buffer, 0, CD_FRAMESIZE_RAW); + return -1; } - sec = cdda_start_sector + cdda_cur_sector; - sec2msf(sec, (char *)stat->Time); + if (cddaBigEndian) { + int i; + unsigned char tmp; + + for (i = 0; i < CD_FRAMESIZE_RAW / 2; i++) { + tmp = buffer[i * 2]; + buffer[i * 2] = buffer[i * 2 + 1]; + buffer[i * 2 + 1] = tmp; + } + } return 0; } @@ -1311,6 +2015,7 @@ void cdrIsoInit(void) { CDR_stop = ISOstop; CDR_getBufferSub = ISOgetBufferSub; CDR_getStatus = ISOgetStatus; + CDR_readCDDA = ISOreadCDDA; CDR_getDriveLetter = CDR__getDriveLetter; CDR_configure = CDR__configure;