2 * (C) GraÅžvydas "notaz" Ignotas, 2010
4 * This work is licensed under the terms of any of these licenses
6 * - GNU GPL, version 2 or later.
7 * - GNU LGPL, version 2.1 or later.
8 * See the COPYING file in the top-level directory.
11 #include <compat/fopen_utf8.h>
23 #define WIN32_LEAN_AND_MEAN
29 #define PFX "cdrcimg: "
30 #define err(f, ...) fprintf(stderr, PFX f, ##__VA_ARGS__)
32 #define CD_FRAMESIZE_RAW 2352
40 static const char *cd_fname;
41 static unsigned int *cd_index_table;
42 static unsigned int cd_index_len;
43 static unsigned int cd_sectors_per_blk;
44 static int cd_compression;
47 static int (*pBZ2_bzBuffToBuffDecompress)(char *dest, unsigned int *destLen, char *source,
48 unsigned int sourceLen, int small, int verbosity);
51 unsigned char raw[16][CD_FRAMESIZE_RAW];
52 unsigned char compressed[CD_FRAMESIZE_RAW * 16 + 100];
54 static int current_block, current_sect_in_blk;
57 extern long CALLBACK CDR__getStatus(struct CdrStat *stat);
63 unsigned char Time[3]; // current playing time
67 enum {DATA, CDDA} type;
68 char start[3]; // MSF-format
69 char length[3]; // MSF-format
72 #define MAXTRACKS 100 /* How many tracks can a CD hold? */
74 static int numtracks = 0;
76 #define btoi(b) ((b) / 16 * 10 + (b) % 16) /* BCD to u_char */
77 #define MSF2SECT(m, s, f) (((m) * 60 + (s) - 2) * 75 + (f))
79 // return Starting and Ending Track
81 // byte 0 - start track
83 static long CDRgetTN(unsigned char *buffer)
86 buffer[1] = numtracks > 0 ? numtracks : 1;
96 static long CDRgetTD(unsigned char track, unsigned char *buffer)
105 static int uncompress2_pcsx(void *out, unsigned long *out_size, void *in, unsigned long in_size)
110 if (z.zalloc == NULL) {
111 // XXX: one-time leak here..
117 ret = inflateInit2(&z, -15);
120 ret = inflateReset(&z);
125 z.avail_in = in_size;
127 z.avail_out = *out_size;
129 ret = inflate(&z, Z_NO_FLUSH);
132 *out_size -= z.avail_out;
133 return ret == 1 ? 0 : ret;
137 // time: byte 0 - minute; byte 1 - second; byte 2 - frame
139 static long CDRreadTrack(unsigned char *time)
141 unsigned int start_byte, size;
142 unsigned long cdbuffer_size;
143 int ret, sector, block;
148 sector = MSF2SECT(btoi(time[0]), btoi(time[1]), btoi(time[2]));
150 // avoid division if possible
151 switch (cd_sectors_per_blk) {
154 current_sect_in_blk = 0;
158 current_sect_in_blk = sector % 10;
162 current_sect_in_blk = sector & 15;
165 err("unhandled cd_sectors_per_blk: %d\n", cd_sectors_per_blk);
169 if (block == current_block) {
170 // it's already there, nothing to do
171 //printf("hit sect %d\n", sector);
175 if (sector >= cd_index_len * cd_sectors_per_blk) {
176 err("sector %d is past track end\n", sector);
180 start_byte = cd_index_table[block];
181 if (fseek(cd_file, start_byte, SEEK_SET) != 0) {
182 err("seek error for block %d at %x: ",
188 size = cd_index_table[block + 1] - start_byte;
189 if (size > sizeof(cdbuffer->compressed)) {
190 err("block %d is too large: %u\n", block, size);
194 if (fread(cdbuffer->compressed, 1, size, cd_file) != size) {
195 err("read error for block %d at %x: ", block, start_byte);
200 cdbuffer_size = sizeof(cdbuffer->raw[0]) * cd_sectors_per_blk;
201 switch (cd_compression) {
203 ret = uncompress(cdbuffer->raw[0], &cdbuffer_size, cdbuffer->compressed, size);
206 ret = uncompress2_pcsx(cdbuffer->raw[0], &cdbuffer_size, cdbuffer->compressed, size);
209 ret = pBZ2_bzBuffToBuffDecompress((char *)cdbuffer->raw, (unsigned int *)&cdbuffer_size,
210 (char *)cdbuffer->compressed, size, 0, 0);
213 err("bad cd_compression: %d\n", cd_compression);
218 err("uncompress failed with %d for block %d, sector %d\n",
222 if (cdbuffer_size != sizeof(cdbuffer->raw[0]) * cd_sectors_per_blk)
223 err("cdbuffer_size: %lu != %d, sector %d\n", cdbuffer_size,
224 (int)sizeof(cdbuffer->raw[0]) * cd_sectors_per_blk, sector);
227 current_block = block;
232 static unsigned char *CDRgetBuffer(void)
234 return cdbuffer->raw[current_sect_in_blk] + 12;
238 // sector: byte 0 - minute; byte 1 - second; byte 2 - frame
239 // does NOT uses bcd format
240 static long CDRplay(unsigned char *time)
246 static long CDRstop(void)
251 // gets subchannel data
252 static unsigned char* CDRgetBufferSub(void)
257 static long CDRgetStatus(struct CdrStat *stat) {
258 CDR__getStatus(stat);
265 static long CDRclose(void)
267 if (cd_file != NULL) {
271 if (cd_index_table != NULL) {
272 free(cd_index_table);
273 cd_index_table = NULL;
278 static long CDRshutdown(void)
283 static long CDRinit(void)
285 if (cdbuffer == NULL) {
286 cdbuffer = malloc(sizeof(*cdbuffer));
287 if (cdbuffer == NULL) {
292 #if !defined(_WIN32) && !defined(NO_DYLIB)
293 if (pBZ2_bzBuffToBuffDecompress == NULL) {
294 void *h = dlopen("/usr/lib/libbz2.so.1", RTLD_LAZY);
296 h = dlopen("./lib/libbz2.so.1", RTLD_LAZY);
298 pBZ2_bzBuffToBuffDecompress = dlsym(h, "BZ2_bzBuffToBuffDecompress");
299 if (pBZ2_bzBuffToBuffDecompress == NULL) {
300 err("dlsym bz2: %s", dlerror());
309 static long handle_eboot(void)
313 unsigned int dontcare[8];
314 unsigned int psar_offs;
319 unsigned int dontcare[6];
322 unsigned int cdimg_base;
326 f = fopen_utf8(cd_fname, "rb");
328 err("missing file: %s: ", cd_fname);
333 ret = fread(&pbp_hdr, 1, sizeof(pbp_hdr), f);
334 if (ret != sizeof(pbp_hdr)) {
335 err("failed to read pbp\n");
339 ret = fseek(f, pbp_hdr.psar_offs, SEEK_SET);
341 err("failed to seek to %x\n", pbp_hdr.psar_offs);
345 ret = fread(psar_sig, 1, sizeof(psar_sig), f);
346 if (ret != sizeof(psar_sig)) {
347 err("failed to read psar_sig\n");
352 if (strcmp(psar_sig, "PSISOIMG") != 0) {
353 err("bad psar_sig: %s\n", psar_sig);
358 ret = fseek(f, 0x4000 - sizeof(psar_sig), SEEK_CUR);
360 err("failed to seek to ISO index\n");
364 cd_index_len = (0x100000 - 0x4000) / sizeof(index_entry);
365 cd_index_table = malloc((cd_index_len + 1) * sizeof(cd_index_table[0]));
366 if (cd_index_table == NULL)
369 cdimg_base = pbp_hdr.psar_offs + 0x100000;
370 for (i = 0; i < cd_index_len; i++) {
371 ret = fread(&index_entry, 1, sizeof(index_entry), f);
372 if (ret != sizeof(index_entry)) {
373 err("failed to read index_entry #%d\n", i);
377 if (index_entry.size == 0)
380 cd_index_table[i] = cdimg_base + index_entry.offset;
382 cd_index_table[i] = cdimg_base + index_entry.offset + index_entry.size;
384 cd_compression = CDRC_ZLIB2;
385 cd_sectors_per_blk = 16;
388 printf(PFX "Loaded EBOOT CD Image: %s.\n", cd_fname);
392 free(cd_index_table);
393 cd_index_table = NULL;
399 // This function is invoked by the front-end when opening an ISO
401 static long CDRopen(void)
407 } __attribute__((packed)) ztab_entry;
411 unsigned int dontcare;
412 } __attribute__((packed)) znxtab_entry;
413 unsigned int bztab_entry;
416 char table_fname[256];
423 return 0; // it's already open
427 current_sect_in_blk = 0;
429 if (cd_fname == NULL)
432 ext = strrchr(cd_fname, '.');
436 if (strcasecmp(ext, ".pbp") == 0) {
437 return handle_eboot();
441 else if (strcasecmp(ext, ".z") == 0) {
442 cd_compression = CDRC_ZLIB;
443 tabentry_size = sizeof(u.ztab_entry);
444 snprintf(table_fname, sizeof(table_fname), "%s.table", cd_fname);
446 else if (strcasecmp(ext, ".znx") == 0) {
447 cd_compression = CDRC_ZLIB;
448 tabentry_size = sizeof(u.znxtab_entry);
449 snprintf(table_fname, sizeof(table_fname), "%s.table", cd_fname);
451 else if (strcasecmp(ext, ".bz") == 0) {
452 if (pBZ2_bzBuffToBuffDecompress == NULL) {
453 err("libbz2 unavailable for .bz2 handling\n");
456 cd_compression = CDRC_BZ;
457 tabentry_size = sizeof(u.bztab_entry);
458 snprintf(table_fname, sizeof(table_fname), "%s.index", cd_fname);
461 err("unhandled extension: %s\n", ext);
465 f = fopen_utf8(table_fname, "rb");
467 err("missing file: %s: ", table_fname);
472 ret = fseek(f, 0, SEEK_END);
474 err("failed to seek\n");
477 table_size = ftell(f);
478 fseek(f, 0, SEEK_SET);
480 if (table_size > 4 * 1024 * 1024) {
481 err(".table too large\n");
485 cd_index_len = table_size / tabentry_size;
487 cd_index_table = malloc((cd_index_len + 1) * sizeof(cd_index_table[0]));
488 if (cd_index_table == NULL)
491 switch (cd_compression) {
493 // a Z.table file is binary where each element represents
494 // one compressed frame.
495 // 4 bytes: the offset of the frame in the .Z file
496 // 2 bytes: the length of the compressed frame
497 // .znx.table has 4 additional bytes (xa header??)
498 u.znxtab_entry.dontcare = 0;
499 for (i = 0; i < cd_index_len; i++) {
500 ret = fread(&u, 1, tabentry_size, f);
501 if (ret != tabentry_size) {
502 err(".table read failed on entry %d/%d\n", i, cd_index_len);
503 goto fail_table_io_read;
505 cd_index_table[i] = u.ztab_entry.offset;
506 //if (u.znxtab_entry.dontcare != 0)
507 // printf("znx %08x!\n", u.znxtab_entry.dontcare);
509 // fake entry, so that we know last compressed block size
510 cd_index_table[i] = u.ztab_entry.offset + u.ztab_entry.size;
511 cd_sectors_per_blk = 1;
514 // the .BZ.table file is arranged so that one entry represents
515 // 10 compressed frames. Each element is a 4 byte unsigned integer
516 // representing the offset in the .BZ file. Last entry is the size
517 // of the compressed file.
518 for (i = 0; i < cd_index_len; i++) {
519 ret = fread(&u.bztab_entry, 1, sizeof(u.bztab_entry), f);
520 if (ret != sizeof(u.bztab_entry)) {
521 err(".table read failed on entry %d/%d\n", i, cd_index_len);
522 goto fail_table_io_read;
524 cd_index_table[i] = u.bztab_entry;
526 cd_sectors_per_blk = 10;
530 cd_file = fopen_utf8(cd_fname, "rb");
531 if (cd_file == NULL) {
532 err("failed to open: %s: ", table_fname);
538 printf(PFX "Loaded compressed CD Image: %s.\n", cd_fname);
544 free(cd_index_table);
545 cd_index_table = NULL;
551 #define FUNC(n) { #n, n }
553 static const struct {
566 FUNC(CDRgetBufferSub),
572 void cdrcimg_set_fname(const char *fname)
577 void *cdrcimg_get_sym(const char *sym)
580 for (i = 0; i < sizeof(plugin_funcs) / sizeof(plugin_funcs[0]); i++)
581 if (strcmp(plugin_funcs[i].name, sym) == 0)
582 return plugin_funcs[i].func;