#include <errno.h>
#include <zlib.h>
+#ifdef HAVE_CHD
+#include "chd.h"
+#endif
+
+#define OFF_T_MSB ((off_t)1 << (sizeof(off_t) * 8 - 1))
+
unsigned int cdrIsoMultidiskCount;
unsigned int cdrIsoMultidiskSelect;
static unsigned char cdbuffer[CD_FRAMESIZE_RAW];
static unsigned char subbuffer[SUB_FRAMESIZE];
-static unsigned char sndbuffer[CD_FRAMESIZE_RAW * 10];
-
-#define CDDA_FRAMETIME (1000 * (sizeof(sndbuffer) / CD_FRAMESIZE_RAW) / 75)
-
-#ifdef _WIN32
-static HANDLE threadid;
-#else
-static pthread_t threadid;
-#endif
-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_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
+static unsigned int cddaCurPos;
// 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;
+#ifdef HAVE_CHD
+typedef 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;
+
+static CHD_IMG *chd_img;
+#endif
+
int (*cdimg_read_func)(FILE *f, unsigned int base, void *dest, int sector);
char* CALLBACK CDR__getDriveLetter(void);
}
}
-#ifndef _WIN32
-static long GetTickCount(void) {
- static time_t initial_time = 0;
- struct timeval now;
-
- gettimeofday(&now, NULL);
-
- if (initial_time == 0) {
- initial_time = now.tv_sec;
- }
-
- return (now.tv_sec - initial_time) * 1000L + now.tv_usec / 1000L;
-}
-#endif
-
-// this thread plays audio data
-#ifdef _WIN32
-static void playthread(void *param)
-#else
-static void *playthread(void *param)
-#endif
-{
- long osleep, d, t, i, s;
- unsigned char tmp;
- int ret = 0, sector_offs;
-
- t = GetTickCount();
-
- while (playing) {
- s = 0;
- for (i = 0; i < sizeof(sndbuffer) / CD_FRAMESIZE_RAW; i++) {
- 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 (s == 0) {
- playing = FALSE;
- initial_offset = 0;
- break;
- }
-
- if (!cdr.Muted && playing) {
- if (cddaBigEndian) {
- for (i = 0; i < s / 2; i++) {
- tmp = sndbuffer[i * 2];
- sndbuffer[i * 2] = sndbuffer[i * 2 + 1];
- sndbuffer[i * 2 + 1] = tmp;
- }
- }
-
- // 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
- _endthread();
-#else
- pthread_exit(0);
- return NULL;
-#endif
-}
-
// stop the CDDA playback
static void stopCDDA() {
- if (!playing) {
- return;
- }
-
playing = FALSE;
-#ifdef _WIN32
- WaitForSingleObject(threadid, INFINITE);
-#else
- pthread_join(threadid, NULL);
-#endif
-}
-
-// start the CDDA playback
-static void startCDDA(void) {
- if (playing) {
- stopCDDA();
- }
-
- playing = TRUE;
-
-#ifdef _WIN32
- threadid = (HANDLE)_beginthread(playthread, 0, NULL);
-#else
- pthread_create(&threadid, NULL, playthread, NULL);
-#endif
}
// this function tries to get the .toc file of the given .bin
unsigned int dontcare[6];
} index_entry;
char psar_sig[11];
- unsigned int t, cd_length, cdimg_base;
- unsigned int offsettab[8], psisoimg_offs;
+ off_t psisoimg_offs, cdimg_base;
+ unsigned int t, cd_length;
+ unsigned int offsettab[8];
const char *ext = NULL;
int i, ret;
if (ext == NULL || (strcmp(ext, ".pbp") != 0 && strcmp(ext, ".PBP") != 0))
return -1;
- fseek(cdHandle, 0, SEEK_SET);
+ fseeko(cdHandle, 0, SEEK_SET);
numtracks = 0;
goto fail_io;
}
- ret = fseek(cdHandle, pbp_hdr.psar_offs, SEEK_SET);
+ ret = fseeko(cdHandle, pbp_hdr.psar_offs, SEEK_SET);
if (ret != 0) {
SysPrintf("failed to seek to %x\n", pbp_hdr.psar_offs);
goto fail_io;
psar_sig[10] = 0;
if (strcmp(psar_sig, "PSTITLEIMG") == 0) {
// multidisk image?
- ret = fseek(cdHandle, pbp_hdr.psar_offs + 0x200, SEEK_SET);
+ 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;
psisoimg_offs += offsettab[cdrIsoMultidiskSelect];
- ret = fseek(cdHandle, psisoimg_offs, SEEK_SET);
+ ret = fseeko(cdHandle, psisoimg_offs, SEEK_SET);
if (ret != 0) {
- SysPrintf("failed to seek to %x\n", psisoimg_offs);
+ SysPrintf("failed to seek to %llx\n", (long long)psisoimg_offs);
goto fail_io;
}
}
// seek to TOC
- ret = fseek(cdHandle, psisoimg_offs + 0x800, SEEK_SET);
+ ret = fseeko(cdHandle, psisoimg_offs + 0x800, SEEK_SET);
if (ret != 0) {
- SysPrintf("failed to seek to %x\n", psisoimg_offs + 0x800);
+ SysPrintf("failed to seek to %llx\n", (long long)psisoimg_offs + 0x800);
goto fail_io;
}
sec2msf(t, ti[numtracks].length);
// seek to ISO index
- ret = fseek(cdHandle, psisoimg_offs + 0x4000, SEEK_SET);
+ ret = fseeko(cdHandle, psisoimg_offs + 0x4000, SEEK_SET);
if (ret != 0) {
SysPrintf("failed to seek to ISO index\n");
goto fail_io;
unsigned char rsv_06[2];
} ciso_hdr;
const char *ext = NULL;
+ unsigned int *index_table = NULL;
unsigned int index = 0, plain;
int i, ret;
return -1;
}
if (ciso_hdr.header_size != 0 && ciso_hdr.header_size != sizeof(ciso_hdr)) {
- ret = fseek(cdHandle, ciso_hdr.header_size, SEEK_SET);
+ 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->current_block = (unsigned int)-1;
compr_img->index_len = ciso_hdr.total_bytes / ciso_hdr.block_size;
- compr_img->index_table = malloc((compr_img->index_len + 1) * sizeof(compr_img->index_table[0]));
- if (compr_img->index_table == NULL)
+ index_table = malloc((compr_img->index_len + 1) * sizeof(index_table[0]));
+ if (index_table == NULL)
goto fail_io;
- ret = fread(compr_img->index_table, sizeof(compr_img->index_table[0]), compr_img->index_len, cdHandle);
+ 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 = compr_img->index_table[i];
+ index = index_table[i];
plain = index & 0x80000000;
index &= 0x7fffffff;
- compr_img->index_table[i] = (index << ciso_hdr.align) | plain;
+ compr_img->index_table[i] = (off_t)index << ciso_hdr.align;
+ if (plain)
+ compr_img->index_table[i] |= OFF_T_MSB;
}
- if ((long long)index << ciso_hdr.align >= 0x80000000ll)
- SysPrintf("warning: ciso img too large, expect problems\n");
return 0;
fail_index:
- free(compr_img->index_table);
- compr_img->index_table = NULL;
+ free(index_table);
fail_io:
if (compr_img != NULL) {
free(compr_img);
return -1;
}
+#ifdef HAVE_CHD
+static int handlechd(const char *isofile) {
+ int frame_offset = 0;
+ int file_offset = 0;
+
+ chd_img = (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 = (unsigned char (*)[CD_FRAMESIZE_RAW + SUB_FRAMESIZE])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;
+ 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;
+
+ if(md.track == 1)
+ md.pregap = 150;
+ else
+ sec2msf(msf2sec(ti[md.track-1].length) + md.pregap, ti[md.track-1].length);
+
+ ti[md.track].type = !strncmp(md.type, "AUDIO", 5) ? CDDA : DATA;
+
+ sec2msf(frame_offset + md.pregap, ti[md.track].start);
+ sec2msf(md.frames, ti[md.track].length);
+
+ ti[md.track].start_offset = file_offset;
+
+ frame_offset += md.pregap + md.frames + md.postgap;
+ file_offset += md.frames + 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) {
char subname[MAXPATHLEN];
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;
static int cdread_compressed(FILE *f, unsigned int base, void *dest, int sector)
{
unsigned long cdbuffer_size, cdbuffer_size_expect;
- unsigned int start_byte, size;
+ unsigned int size;
int is_compressed;
+ off_t start_byte;
int ret, block;
if (base)
return -1;
}
- start_byte = compr_img->index_table[block] & 0x7fffffff;
- if (fseek(cdHandle, start_byte, SEEK_SET) != 0) {
- SysPrintf("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;
}
- is_compressed = !(compr_img->index_table[block] & 0x80000000);
- size = (compr_img->index_table[block + 1] & 0x7fffffff) - 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)) {
SysPrintf("block %d is too large: %u\n", block, size);
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(compr_img->buff_raw[0], &cdbuffer_size, compr_img->buff_compressed, size);
+ 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 CD_FRAMESIZE_RAW;
}
+#ifdef HAVE_CHD
+static int cdread_chd(FILE *f, unsigned int base, void *dest, int sector)
+{
+ int hunk;
+
+ if (base)
+ sector += base;
+
+ hunk = sector / chd_img->sectors_per_hunk;
+ chd_img->sector_in_hunk = sector % chd_img->sectors_per_hunk;
+
+ if (hunk != chd_img->current_hunk)
+ {
+ chd_read(chd_img->chd, hunk, chd_img->buffer);
+ chd_img->current_hunk = hunk;
+ }
+
+ 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;
return compr_img->buff_raw[compr_img->sector_in_blk] + 12;
}
+#ifdef HAVE_CHD
+static unsigned char *ISOgetBuffer_chd(void) {
+ return chd_img->buffer[chd_img->sector_in_hunk] + 12;
+}
+#endif
+
static unsigned char * CALLBACK ISOgetBuffer(void) {
return cdbuffer + 12;
}
CDR_getBuffer = ISOgetBuffer_compr;
cdimg_read_func = cdread_compressed;
}
+
+#ifdef HAVE_CHD
+ else if (handlechd(GetIsoFile()) == 0) {
+ printf("[chd]");
+ CDR_getBuffer = ISOgetBuffer_chd;
+ cdimg_read_func = cdread_chd;
+ }
+#endif
if (!subChanMixed && opensubfile(GetIsoFile()) == 0) {
SysPrintf("[+sub]");
SysPrintf("[+sbi]");
}
- fseek(cdHandle, 0, SEEK_END);
+ fseeko(cdHandle, 0, SEEK_END);
// maybe user selected metadata file instead of main .bin ..
bin_filename = GetIsoFile();
- if (ftell(cdHandle) < 2352 * 0x10) {
+ if (ftello(cdHandle) < 2352 * 0x10) {
static const char *exts[] = { ".bin", ".BIN", ".img", ".IMG" };
FILE *tmpf = NULL;
size_t i;
bin_filename = alt_bin_filename;
fclose(cdHandle);
cdHandle = tmpf;
- fseek(cdHandle, 0, SEEK_END);
+ fseeko(cdHandle, 0, SEEK_END);
}
}
// guess whether it is mode1/2048
- 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 (numtracks > 1 && ti[1].handle == NULL) {
ti[1].handle = fopen(bin_filename, "rb");
}
- cdda_cur_sector = 0;
- cdda_file_offset = 0;
return 0;
}
free(compr_img);
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) {
// read track
// time: byte 0 - minute; byte 1 - second; byte 2 - frame
// uses bcd format
-static long CALLBACK ISOreadTrack(unsigned char *time) {
+static boolean CALLBACK ISOreadTrack(unsigned char *time) {
int sector = MSF2SECT(btoi(time[0]), btoi(time[1]), btoi(time[2]));
long ret;
if (cdHandle == NULL) {
- return -1;
+ return 0;
}
if (pregapOffset) {
ret = cdimg_read_func(cdHandle, 0, cdbuffer, sector);
if (ret < 0)
- return -1;
+ return 0;
if (subHandle != NULL) {
fseek(subHandle, sector * SUB_FRAMESIZE, SEEK_SET);
if (subChanRaw) DecodeRawSubData();
}
- return 0;
+ return 1;
}
// plays cdda audio
// 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;
-
- if (numtracks <= 1)
- return 0;
-
- // find the track
- 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;
- }
- cdda_file_offset = ti[i].start_offset;
-
- // find the file that contains this track
- for (; i > 1; i--)
- if (ti[i].handle != NULL)
- break;
-
- cddaHandle = ti[i].handle;
-
- if (SPU_playCDDAchannel != NULL)
- startCDDA();
-
+ playing = TRUE;
return 0;
}