cdrom: adjust the resume timing hack
[pcsx_rearmed.git] / plugins / cdrcimg / cdrcimg.c
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>
15 #if !defined(_WIN32) && !defined(NO_DYLIB)
16 #include <dlfcn.h>
17 #endif
18
19 #include "cdrcimg.h"
20
21 #undef CALLBACK
22 #define CALLBACK
23
24 #define PFX "cdrcimg: "
25 #define err(f, ...) fprintf(stderr, PFX f, ##__VA_ARGS__)
26
27 #define CD_FRAMESIZE_RAW 2352
28
29 enum {
30         CDRC_ZLIB,
31         CDRC_ZLIB2,
32         CDRC_BZ,
33 };
34
35 static const char *cd_fname;
36 static unsigned int *cd_index_table;
37 static unsigned int  cd_index_len;
38 static unsigned int  cd_sectors_per_blk;
39 static int cd_compression;
40 static FILE *cd_file;
41
42 static int (*pBZ2_bzBuffToBuffDecompress)(char *dest, unsigned int *destLen, char *source,
43                 unsigned int sourceLen, int small, int verbosity);
44
45 static struct {
46         unsigned char raw[16][CD_FRAMESIZE_RAW];
47         unsigned char compressed[CD_FRAMESIZE_RAW * 16 + 100];
48 } *cdbuffer;
49 static int current_block, current_sect_in_blk;
50
51 struct CdrStat;
52 extern long CALLBACK CDR__getStatus(struct CdrStat *stat);
53
54 struct CdrStat
55 {
56         unsigned int Type;
57         unsigned int Status;
58         unsigned char Time[3]; // current playing time
59 };
60
61 struct 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
69 static 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
78 static 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
91 static 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
100 static int uncompress2_pcsx(void *out, unsigned long *out_size, void *in, unsigned long in_size)
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
131 // read track
132 // time: byte 0 - minute; byte 1 - second; byte 2 - frame
133 // uses bcd format
134 static long CDRreadTrack(unsigned char *time)
135 {
136         unsigned int start_byte, size;
137         unsigned long cdbuffer_size;
138         int ret, sector, block;
139
140         if (cd_file == NULL)
141                 return -1;
142
143         sector = MSF2SECT(btoi(time[0]), btoi(time[1]), btoi(time[2]));
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) {
165                 // it's already there, nothing to do
166                 //printf("hit sect %d\n", sector);
167                 return 0;
168         }
169
170         if (sector >= cd_index_len * cd_sectors_per_blk) {
171                 err("sector %d is past track end\n", sector);
172                 return -1;
173         }
174
175         start_byte = cd_index_table[block];
176         if (fseek(cd_file, start_byte, SEEK_SET) != 0) {
177                 err("seek error for block %d at %x: ",
178                         block, start_byte);
179                 perror(NULL);
180                 return -1;
181         }
182
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);
186                 return -1;
187         }
188
189         if (fread(cdbuffer->compressed, 1, size, cd_file) != size) {
190                 err("read error for block %d at %x: ", block, start_byte);
191                 perror(NULL);
192                 return -1;
193         }
194
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:
201                 ret = uncompress2_pcsx(cdbuffer->raw[0], &cdbuffer_size, cdbuffer->compressed, size);
202                 break;
203         case CDRC_BZ:
204                 ret = pBZ2_bzBuffToBuffDecompress((char *)cdbuffer->raw, (unsigned int *)&cdbuffer_size,
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
212         if (ret != 0) {
213                 err("uncompress failed with %d for block %d, sector %d\n",
214                         ret, block, sector);
215                 return -1;
216         }
217         if (cdbuffer_size != sizeof(cdbuffer->raw[0]) * cd_sectors_per_blk)
218                 err("cdbuffer_size: %lu != %d, sector %d\n", cdbuffer_size,
219                         (int)sizeof(cdbuffer->raw[0]) * cd_sectors_per_blk, sector);
220
221         // done at last!
222         current_block = block;
223         return 0;
224 }
225
226 // return read track
227 static unsigned char *CDRgetBuffer(void)
228 {
229         return cdbuffer->raw[current_sect_in_blk] + 12;
230 }
231
232 // plays cdda audio
233 // sector: byte 0 - minute; byte 1 - second; byte 2 - frame
234 // does NOT uses bcd format
235 static long CDRplay(unsigned char *time)
236 {
237         return 0;
238 }
239
240 // stops cdda audio
241 static long CDRstop(void)
242 {
243         return 0;
244 }
245
246 // gets subchannel data
247 static unsigned char* CDRgetBufferSub(void)
248 {
249         return NULL;
250 }
251
252 static long CDRgetStatus(struct CdrStat *stat) {
253         CDR__getStatus(stat);
254
255         stat->Type = 0x01;
256
257         return 0;
258 }
259
260 static 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
273 static long CDRshutdown(void)
274 {
275         return CDRclose();
276 }
277
278 static long CDRinit(void)
279 {
280         if (cdbuffer == NULL) {
281                 cdbuffer = malloc(sizeof(*cdbuffer));
282                 if (cdbuffer == NULL) {
283                         err("OOM\n");
284                         return -1;
285                 }
286         }
287 #if !defined(_WIN32) && !defined(NO_DYLIB)
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         }
300 #endif
301         return 0;
302 }
303
304 static 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
321         f = fopen(cd_fname, "rb");
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
386 fail_index:
387         free(cd_index_table);
388         cd_index_table = NULL;
389 fail_io:
390         fclose(f);
391         return -1;
392 }
393
394 // This function is invoked by the front-end when opening an ISO
395 // file for playback
396 static long CDRopen(void)
397 {
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;
411         char table_fname[256];
412         long table_size;
413         int i, ret;
414         char *ext;
415         FILE *f = NULL;
416
417         if (cd_file != NULL)
418                 return 0; // it's already open
419
420         numtracks = 0;
421         current_block = -1;
422         current_sect_in_blk = 0;
423
424         if (cd_fname == NULL)
425                 return -1;
426
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) {
447                 if (pBZ2_bzBuffToBuffDecompress == NULL) {
448                         err("libbz2 unavailable for .bz2 handling\n");
449                         return -1;
450                 }
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
460         f = fopen(table_fname, "rb");
461         if (f == NULL) {
462                 err("missing file: %s: ", table_fname);
463                 perror(NULL);
464                 return -1;
465         }
466
467         ret = fseek(f, 0, SEEK_END);
468         if (ret != 0) {
469                 err("failed to seek\n");
470                 goto fail_table_io;
471         }
472         table_size = ftell(f);
473         fseek(f, 0, SEEK_SET);
474
475         if (table_size > 4 * 1024 * 1024) {
476                 err(".table too large\n");
477                 goto fail_table_io;
478         }
479
480         cd_index_len = table_size / tabentry_size;
481
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
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;
520                 }
521                 cd_sectors_per_blk = 10;
522                 break;
523         }
524
525         cd_file = fopen(cd_fname, "rb");
526         if (cd_file == NULL) {
527                 err("failed to open: %s: ", table_fname);
528                 perror(NULL);
529                 goto fail_img;
530         }
531         fclose(f);
532
533         printf(PFX "Loaded compressed CD Image: %s.\n", cd_fname);
534
535         return 0;
536
537 fail_img:
538 fail_table_io_read:
539         free(cd_index_table);
540         cd_index_table = NULL;
541 fail_table_io:
542         fclose(f);
543         return -1;
544 }
545
546 #define FUNC(n) { #n, n }
547
548 static 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
567 void cdrcimg_set_fname(const char *fname)
568 {
569         cd_fname = fname;
570 }
571
572 void *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