drc: avoid excessive recursion in hle mode
[pcsx_rearmed.git] / plugins / cdrcimg / cdrcimg.c
CommitLineData
47bf65ab 1/*
2 * (C) GraÅžvydas "notaz" Ignotas, 2010
3 *
4 * This work is licensed under the terms of any of these licenses
5 * (at your option):
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.
9 */
10
11#include <stdio.h>
12#include <string.h>
13#include <stdlib.h>
14#include <zlib.h>
78de2879 15#if !defined(_WIN32) && !defined(NO_DYLIB)
bb5cf0fc 16#include <dlfcn.h>
fc99395c 17#endif
47bf65ab 18
19#include "cdrcimg.h"
20
78de2879 21#undef CALLBACK
22#define CALLBACK
23
33716956 24#define PFX "cdrcimg: "
25#define err(f, ...) fprintf(stderr, PFX f, ##__VA_ARGS__)
26
47bf65ab 27#define CD_FRAMESIZE_RAW 2352
28
33716956 29enum {
30 CDRC_ZLIB,
31 CDRC_ZLIB2,
32 CDRC_BZ,
33};
34
47bf65ab 35static const char *cd_fname;
36static unsigned int *cd_index_table;
37static unsigned int cd_index_len;
33716956 38static unsigned int cd_sectors_per_blk;
39static int cd_compression;
47bf65ab 40static FILE *cd_file;
41
bb5cf0fc 42static int (*pBZ2_bzBuffToBuffDecompress)(char *dest, unsigned int *destLen, char *source,
43 unsigned int sourceLen, int small, int verbosity);
44
33716956 45static struct {
46 unsigned char raw[16][CD_FRAMESIZE_RAW];
47 unsigned char compressed[CD_FRAMESIZE_RAW * 16 + 100];
48} *cdbuffer;
49static int current_block, current_sect_in_blk;
47bf65ab 50
51struct CdrStat;
003cfc63 52extern long CALLBACK CDR__getStatus(struct CdrStat *stat);
47bf65ab 53
54struct CdrStat
55{
c668f248 56 unsigned int Type;
57 unsigned int Status;
47bf65ab 58 unsigned char Time[3]; // current playing time
59};
60
61struct trackinfo {
62 enum {DATA, CDDA} type;
63 char start[3]; // MSF-format
64 char length[3]; // MSF-format
65};
66
67#define MAXTRACKS 100 /* How many tracks can a CD hold? */
68
69static int numtracks = 0;
70
71#define btoi(b) ((b) / 16 * 10 + (b) % 16) /* BCD to u_char */
72#define MSF2SECT(m, s, f) (((m) * 60 + (s) - 2) * 75 + (f))
73
74// return Starting and Ending Track
75// buffer:
76// byte 0 - start track
77// byte 1 - end track
78static long CDRgetTN(unsigned char *buffer)
79{
80 buffer[0] = 1;
81 buffer[1] = numtracks > 0 ? numtracks : 1;
82
83 return 0;
84}
85
86// return Track Time
87// buffer:
88// byte 0 - frame
89// byte 1 - second
90// byte 2 - minute
91static long CDRgetTD(unsigned char track, unsigned char *buffer)
92{
93 buffer[2] = 0;
94 buffer[1] = 2;
95 buffer[0] = 0;
96
97 return 0;
98}
99
2dd6a826 100static int uncompress2_pcsx(void *out, unsigned long *out_size, void *in, unsigned long in_size)
33716956 101{
102 static z_stream z;
103 int ret = 0;
104
105 if (z.zalloc == NULL) {
106 // XXX: one-time leak here..
107 z.next_in = Z_NULL;
108 z.avail_in = 0;
109 z.zalloc = Z_NULL;
110 z.zfree = Z_NULL;
111 z.opaque = Z_NULL;
112 ret = inflateInit2(&z, -15);
113 }
114 else
115 ret = inflateReset(&z);
116 if (ret != Z_OK)
117 return ret;
118
119 z.next_in = in;
120 z.avail_in = in_size;
121 z.next_out = out;
122 z.avail_out = *out_size;
123
124 ret = inflate(&z, Z_NO_FLUSH);
125 //inflateEnd(&z);
126
127 *out_size -= z.avail_out;
128 return ret == 1 ? 0 : ret;
129}
130
47bf65ab 131// read track
132// time: byte 0 - minute; byte 1 - second; byte 2 - frame
133// uses bcd format
134static long CDRreadTrack(unsigned char *time)
135{
136 unsigned int start_byte, size;
137 unsigned long cdbuffer_size;
33716956 138 int ret, sector, block;
47bf65ab 139
140 if (cd_file == NULL)
141 return -1;
142
143 sector = MSF2SECT(btoi(time[0]), btoi(time[1]), btoi(time[2]));
33716956 144
145 // avoid division if possible
146 switch (cd_sectors_per_blk) {
147 case 1:
148 block = sector;
149 current_sect_in_blk = 0;
150 break;
151 case 10:
152 block = sector / 10;
153 current_sect_in_blk = sector % 10;
154 break;
155 case 16:
156 block = sector >> 4;
157 current_sect_in_blk = sector & 15;
158 break;
159 default:
160 err("unhandled cd_sectors_per_blk: %d\n", cd_sectors_per_blk);
161 return -1;
162 }
163
164 if (block == current_block) {
47bf65ab 165 // it's already there, nothing to do
166 //printf("hit sect %d\n", sector);
167 return 0;
168 }
169
33716956 170 if (sector >= cd_index_len * cd_sectors_per_blk) {
171 err("sector %d is past track end\n", sector);
47bf65ab 172 return -1;
173 }
174
33716956 175 start_byte = cd_index_table[block];
47bf65ab 176 if (fseek(cd_file, start_byte, SEEK_SET) != 0) {
33716956 177 err("seek error for block %d at %x: ",
178 block, start_byte);
47bf65ab 179 perror(NULL);
180 return -1;
181 }
182
33716956 183 size = cd_index_table[block + 1] - start_byte;
184 if (size > sizeof(cdbuffer->compressed)) {
185 err("block %d is too large: %u\n", block, size);
47bf65ab 186 return -1;
187 }
188
33716956 189 if (fread(cdbuffer->compressed, 1, size, cd_file) != size) {
190 err("read error for block %d at %x: ", block, start_byte);
47bf65ab 191 perror(NULL);
192 return -1;
193 }
194
33716956 195 cdbuffer_size = sizeof(cdbuffer->raw[0]) * cd_sectors_per_blk;
196 switch (cd_compression) {
197 case CDRC_ZLIB:
198 ret = uncompress(cdbuffer->raw[0], &cdbuffer_size, cdbuffer->compressed, size);
199 break;
200 case CDRC_ZLIB2:
2dd6a826 201 ret = uncompress2_pcsx(cdbuffer->raw[0], &cdbuffer_size, cdbuffer->compressed, size);
33716956 202 break;
203 case CDRC_BZ:
bb5cf0fc 204 ret = pBZ2_bzBuffToBuffDecompress((char *)cdbuffer->raw, (unsigned int *)&cdbuffer_size,
33716956 205 (char *)cdbuffer->compressed, size, 0, 0);
206 break;
207 default:
208 err("bad cd_compression: %d\n", cd_compression);
209 return -1;
210 }
211
47bf65ab 212 if (ret != 0) {
33716956 213 err("uncompress failed with %d for block %d, sector %d\n",
214 ret, block, sector);
47bf65ab 215 return -1;
216 }
33716956 217 if (cdbuffer_size != sizeof(cdbuffer->raw[0]) * cd_sectors_per_blk)
218 err("cdbuffer_size: %lu != %d, sector %d\n", cdbuffer_size,
c979c3ee 219 (int)sizeof(cdbuffer->raw[0]) * cd_sectors_per_blk, sector);
47bf65ab 220
221 // done at last!
33716956 222 current_block = block;
47bf65ab 223 return 0;
224}
225
226// return read track
227static unsigned char *CDRgetBuffer(void)
228{
33716956 229 return cdbuffer->raw[current_sect_in_blk] + 12;
47bf65ab 230}
231
232// plays cdda audio
233// sector: byte 0 - minute; byte 1 - second; byte 2 - frame
234// does NOT uses bcd format
235static long CDRplay(unsigned char *time)
236{
237 return 0;
238}
239
240// stops cdda audio
241static long CDRstop(void)
242{
243 return 0;
244}
245
246// gets subchannel data
247static unsigned char* CDRgetBufferSub(void)
248{
249 return NULL;
250}
251
252static long CDRgetStatus(struct CdrStat *stat) {
253 CDR__getStatus(stat);
254
255 stat->Type = 0x01;
256
257 return 0;
258}
259
260static long CDRclose(void)
261{
262 if (cd_file != NULL) {
263 fclose(cd_file);
264 cd_file = NULL;
265 }
266 if (cd_index_table != NULL) {
267 free(cd_index_table);
268 cd_index_table = NULL;
269 }
270 return 0;
271}
272
273static long CDRshutdown(void)
274{
275 return CDRclose();
276}
277
278static long CDRinit(void)
279{
33716956 280 if (cdbuffer == NULL) {
281 cdbuffer = malloc(sizeof(*cdbuffer));
282 if (cdbuffer == NULL) {
283 err("OOM\n");
284 return -1;
285 }
286 }
c4052f4d 287#if !defined(_WIN32) && !defined(NO_DYLIB)
bb5cf0fc 288 if (pBZ2_bzBuffToBuffDecompress == NULL) {
289 void *h = dlopen("/usr/lib/libbz2.so.1", RTLD_LAZY);
290 if (h == NULL)
291 h = dlopen("./lib/libbz2.so.1", RTLD_LAZY);
292 if (h != NULL) {
293 pBZ2_bzBuffToBuffDecompress = dlsym(h, "BZ2_bzBuffToBuffDecompress");
294 if (pBZ2_bzBuffToBuffDecompress == NULL) {
295 err("dlsym bz2: %s", dlerror());
296 dlclose(h);
297 }
298 }
299 }
003cfc63 300#endif
33716956 301 return 0;
302}
303
304static long handle_eboot(void)
305{
306 struct {
307 unsigned int sig;
308 unsigned int dontcare[8];
309 unsigned int psar_offs;
310 } pbp_hdr;
311 struct {
312 unsigned int offset;
313 unsigned int size;
314 unsigned int dontcare[6];
315 } index_entry;
316 char psar_sig[9];
317 unsigned int cdimg_base;
318 int i, ret;
319 FILE *f;
320
226a5691 321 f = fopen(cd_fname, "rb");
33716956 322 if (f == NULL) {
323 err("missing file: %s: ", cd_fname);
324 perror(NULL);
325 return -1;
326 }
327
328 ret = fread(&pbp_hdr, 1, sizeof(pbp_hdr), f);
329 if (ret != sizeof(pbp_hdr)) {
330 err("failed to read pbp\n");
331 goto fail_io;
332 }
333
334 ret = fseek(f, pbp_hdr.psar_offs, SEEK_SET);
335 if (ret != 0) {
336 err("failed to seek to %x\n", pbp_hdr.psar_offs);
337 goto fail_io;
338 }
339
340 ret = fread(psar_sig, 1, sizeof(psar_sig), f);
341 if (ret != sizeof(psar_sig)) {
342 err("failed to read psar_sig\n");
343 goto fail_io;
344 }
345
346 psar_sig[8] = 0;
347 if (strcmp(psar_sig, "PSISOIMG") != 0) {
348 err("bad psar_sig: %s\n", psar_sig);
349 goto fail_io;
350 }
351
352 // seek to ISO index
353 ret = fseek(f, 0x4000 - sizeof(psar_sig), SEEK_CUR);
354 if (ret != 0) {
355 err("failed to seek to ISO index\n");
356 goto fail_io;
357 }
358
359 cd_index_len = (0x100000 - 0x4000) / sizeof(index_entry);
360 cd_index_table = malloc((cd_index_len + 1) * sizeof(cd_index_table[0]));
361 if (cd_index_table == NULL)
362 goto fail_io;
363
364 cdimg_base = pbp_hdr.psar_offs + 0x100000;
365 for (i = 0; i < cd_index_len; i++) {
366 ret = fread(&index_entry, 1, sizeof(index_entry), f);
367 if (ret != sizeof(index_entry)) {
368 err("failed to read index_entry #%d\n", i);
369 goto fail_index;
370 }
371
372 if (index_entry.size == 0)
373 break;
374
375 cd_index_table[i] = cdimg_base + index_entry.offset;
376 }
377 cd_index_table[i] = cdimg_base + index_entry.offset + index_entry.size;
378
379 cd_compression = CDRC_ZLIB2;
380 cd_sectors_per_blk = 16;
381 cd_file = f;
382
383 printf(PFX "Loaded EBOOT CD Image: %s.\n", cd_fname);
384 return 0;
385
386fail_index:
387 free(cd_index_table);
388 cd_index_table = NULL;
389fail_io:
390 fclose(f);
391 return -1;
47bf65ab 392}
393
394// This function is invoked by the front-end when opening an ISO
395// file for playback
396static long CDRopen(void)
397{
33716956 398 union {
399 struct {
400 unsigned int offset;
401 unsigned short size;
402 } __attribute__((packed)) ztab_entry;
403 struct {
404 unsigned int offset;
405 unsigned short size;
406 unsigned int dontcare;
407 } __attribute__((packed)) znxtab_entry;
408 unsigned int bztab_entry;
409 } u;
410 int tabentry_size;
47bf65ab 411 char table_fname[256];
412 long table_size;
413 int i, ret;
33716956 414 char *ext;
415 FILE *f = NULL;
47bf65ab 416
417 if (cd_file != NULL)
418 return 0; // it's already open
419
420 numtracks = 0;
33716956 421 current_block = -1;
422 current_sect_in_blk = 0;
47bf65ab 423
424 if (cd_fname == NULL)
425 return -1;
426
33716956 427 ext = strrchr(cd_fname, '.');
428 if (ext == NULL)
429 return -1;
430
431 if (strcasecmp(ext, ".pbp") == 0) {
432 return handle_eboot();
433 }
434
435 // pocketiso stuff
436 else if (strcasecmp(ext, ".z") == 0) {
437 cd_compression = CDRC_ZLIB;
438 tabentry_size = sizeof(u.ztab_entry);
439 snprintf(table_fname, sizeof(table_fname), "%s.table", cd_fname);
440 }
441 else if (strcasecmp(ext, ".znx") == 0) {
442 cd_compression = CDRC_ZLIB;
443 tabentry_size = sizeof(u.znxtab_entry);
444 snprintf(table_fname, sizeof(table_fname), "%s.table", cd_fname);
445 }
446 else if (strcasecmp(ext, ".bz") == 0) {
bb5cf0fc 447 if (pBZ2_bzBuffToBuffDecompress == NULL) {
448 err("libbz2 unavailable for .bz2 handling\n");
449 return -1;
450 }
33716956 451 cd_compression = CDRC_BZ;
452 tabentry_size = sizeof(u.bztab_entry);
453 snprintf(table_fname, sizeof(table_fname), "%s.index", cd_fname);
454 }
455 else {
456 err("unhandled extension: %s\n", ext);
457 return -1;
458 }
459
226a5691 460 f = fopen(table_fname, "rb");
47bf65ab 461 if (f == NULL) {
33716956 462 err("missing file: %s: ", table_fname);
47bf65ab 463 perror(NULL);
464 return -1;
465 }
466
467 ret = fseek(f, 0, SEEK_END);
468 if (ret != 0) {
33716956 469 err("failed to seek\n");
47bf65ab 470 goto fail_table_io;
471 }
472 table_size = ftell(f);
473 fseek(f, 0, SEEK_SET);
474
33716956 475 if (table_size > 4 * 1024 * 1024) {
476 err(".table too large\n");
47bf65ab 477 goto fail_table_io;
478 }
479
33716956 480 cd_index_len = table_size / tabentry_size;
481
47bf65ab 482 cd_index_table = malloc((cd_index_len + 1) * sizeof(cd_index_table[0]));
483 if (cd_index_table == NULL)
484 goto fail_table_io;
485
33716956 486 switch (cd_compression) {
487 case CDRC_ZLIB:
488 // a Z.table file is binary where each element represents
489 // one compressed frame.
490 // 4 bytes: the offset of the frame in the .Z file
491 // 2 bytes: the length of the compressed frame
492 // .znx.table has 4 additional bytes (xa header??)
493 u.znxtab_entry.dontcare = 0;
494 for (i = 0; i < cd_index_len; i++) {
495 ret = fread(&u, 1, tabentry_size, f);
496 if (ret != tabentry_size) {
497 err(".table read failed on entry %d/%d\n", i, cd_index_len);
498 goto fail_table_io_read;
499 }
500 cd_index_table[i] = u.ztab_entry.offset;
501 //if (u.znxtab_entry.dontcare != 0)
502 // printf("znx %08x!\n", u.znxtab_entry.dontcare);
503 }
504 // fake entry, so that we know last compressed block size
505 cd_index_table[i] = u.ztab_entry.offset + u.ztab_entry.size;
506 cd_sectors_per_blk = 1;
507 break;
508 case CDRC_BZ:
509 // the .BZ.table file is arranged so that one entry represents
510 // 10 compressed frames. Each element is a 4 byte unsigned integer
511 // representing the offset in the .BZ file. Last entry is the size
512 // of the compressed file.
513 for (i = 0; i < cd_index_len; i++) {
514 ret = fread(&u.bztab_entry, 1, sizeof(u.bztab_entry), f);
515 if (ret != sizeof(u.bztab_entry)) {
516 err(".table read failed on entry %d/%d\n", i, cd_index_len);
517 goto fail_table_io_read;
518 }
519 cd_index_table[i] = u.bztab_entry;
47bf65ab 520 }
33716956 521 cd_sectors_per_blk = 10;
522 break;
47bf65ab 523 }
47bf65ab 524
226a5691 525 cd_file = fopen(cd_fname, "rb");
47bf65ab 526 if (cd_file == NULL) {
33716956 527 err("failed to open: %s: ", table_fname);
47bf65ab 528 perror(NULL);
529 goto fail_img;
530 }
531 fclose(f);
532
33716956 533 printf(PFX "Loaded compressed CD Image: %s.\n", cd_fname);
47bf65ab 534
535 return 0;
536
537fail_img:
538fail_table_io_read:
539 free(cd_index_table);
540 cd_index_table = NULL;
541fail_table_io:
542 fclose(f);
543 return -1;
544}
545
546#define FUNC(n) { #n, n }
547
548static const struct {
549 const char *name;
550 void *func;
551} plugin_funcs[] = {
552 /* CDR */
553 FUNC(CDRinit),
554 FUNC(CDRshutdown),
555 FUNC(CDRopen),
556 FUNC(CDRclose),
557 FUNC(CDRgetTN),
558 FUNC(CDRgetTD),
559 FUNC(CDRreadTrack),
560 FUNC(CDRgetBuffer),
561 FUNC(CDRgetBufferSub),
562 FUNC(CDRplay),
563 FUNC(CDRstop),
564 FUNC(CDRgetStatus),
565};
566
567void cdrcimg_set_fname(const char *fname)
568{
569 cd_fname = fname;
570}
571
572void *cdrcimg_get_sym(const char *sym)
573{
574 int i;
575 for (i = 0; i < sizeof(plugin_funcs) / sizeof(plugin_funcs[0]); i++)
576 if (strcmp(plugin_funcs[i].name, sym) == 0)
577 return plugin_funcs[i].func;
578 return NULL;
579}
580