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