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