notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
cdriso: handle TOC and track timing better
[pcsx_rearmed.git] / libpcsxcore / cdriso.c
CommitLineData
ef79bbde
P		 1/***************************************************************************
2 * Copyright (C) 2007 PCSX-df Team *
3 * Copyright (C) 2009 Wei Mingzhi *
4 * *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
9 * *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
14 * *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. *
19 ***************************************************************************/
20
21#include "psxcommon.h"
22#include "plugins.h"
23#include "cdrom.h"
24#include "cdriso.h"
ae4e7dc9 25#include "ppf.h"
ef79bbde
P		 26
27#ifdef _WIN32
28#include <process.h>
29#include <windows.h>
30#else
31#include <pthread.h>
32#include <sys/time.h>
33#endif
34
35static FILE *cdHandle = NULL;
36static FILE *cddaHandle = NULL;
37static FILE *subHandle = NULL;
38
39static boolean subChanMixed = FALSE;
40static boolean subChanRaw = FALSE;
41
42static unsigned char cdbuffer[DATA_SIZE];
43static unsigned char subbuffer[SUB_FRAMESIZE];
44
45static unsigned char sndbuffer[CD_FRAMESIZE_RAW * 10];
46
47#define CDDA_FRAMETIME (1000 * (sizeof(sndbuffer) / CD_FRAMESIZE_RAW) / 75)
48
49#ifdef _WIN32
50static HANDLE threadid;
51#else
52static pthread_t threadid;
53#endif
54static unsigned int initial_offset = 0;
38b8102c 55static boolean playing = FALSE;
ef79bbde 56static boolean cddaBigEndian = FALSE;
38b8102c 57static unsigned int cddaCurOffset = 0;
58static unsigned int cddaStartOffset;
ef79bbde
P		 59
60char* CALLBACK CDR__getDriveLetter(void);
61long CALLBACK CDR__configure(void);
62long CALLBACK CDR__test(void);
63void CALLBACK CDR__about(void);
64long CALLBACK CDR__setfilename(char *filename);
65long CALLBACK CDR__getStatus(struct CdrStat *stat);
66
19c03d80 67static void DecodeRawSubData(void);
68
ef79bbde
P		 69extern void *hCDRDriver;
70
71struct trackinfo {
72 enum {DATA, CDDA} type;
73 char start[3]; // MSF-format
74 char length[3]; // MSF-format
38b8102c 75 FILE *handle; // for multi-track images CDDA
19c03d80 76 int start_offset; // sector offset from start of above file
ef79bbde
P		 77};
78
79#define MAXTRACKS 100 /* How many tracks can a CD hold? */
80
81static int numtracks = 0;
82static struct trackinfo ti[MAXTRACKS];
83
84// get a sector from a msf-array
85static unsigned int msf2sec(char *msf) {
86 return ((msf[0] * 60 + msf[1]) * 75) + msf[2];
87}
88
89static void sec2msf(unsigned int s, char *msf) {
90 msf[0] = s / 75 / 60;
91 s = s - msf[0] * 75 * 60;
92 msf[1] = s / 75;
93 s = s - msf[1] * 75;
94 msf[2] = s;
95}
96
97// divide a string of xx:yy:zz into m, s, f
98static void tok2msf(char *time, char *msf) {
99 char *token;
100
101 token = strtok(time, ":");
102 if (token) {
103 msf[0] = atoi(token);
104 }
105 else {
106 msf[0] = 0;
107 }
108
109 token = strtok(NULL, ":");
110 if (token) {
111 msf[1] = atoi(token);
112 }
113 else {
114 msf[1] = 0;
115 }
116
117 token = strtok(NULL, ":");
118 if (token) {
119 msf[2] = atoi(token);
120 }
121 else {
122 msf[2] = 0;
123 }
124}
125
126#ifndef _WIN32
127static long GetTickCount(void) {
128 static time_t initial_time = 0;
129 struct timeval now;
130
131 gettimeofday(&now, NULL);
132
133 if (initial_time == 0) {
134 initial_time = now.tv_sec;
135 }
136
137 return (now.tv_sec - initial_time) * 1000L + now.tv_usec / 1000L;
138}
139#endif
140
141// this thread plays audio data
142#ifdef _WIN32
143static void playthread(void *param)
144#else
145static void *playthread(void *param)
146#endif
147{
148 long d, t, i, s;
149 unsigned char tmp;
150
151 t = GetTickCount();
152
153 while (playing) {
154 d = t - (long)GetTickCount();
155 if (d <= 0) {
156 d = 1;
157 }
158 else if (d > CDDA_FRAMETIME) {
159 d = CDDA_FRAMETIME;
160 }
161#ifdef _WIN32
162 Sleep(d);
163#else
164 usleep(d * 1000);
165#endif
d4a1e87d 166 // HACK: stop feeding data while emu is paused
167 extern int stop;
168 if (stop) {
169 usleep(100000);
170 continue;
171 }
ef79bbde
P		 172
173 t = GetTickCount() + CDDA_FRAMETIME;
174
175 if (subChanMixed) {
176 s = 0;
177
178 for (i = 0; i < sizeof(sndbuffer) / CD_FRAMESIZE_RAW; i++) {
179 // read one sector
180 d = fread(sndbuffer + CD_FRAMESIZE_RAW * i, 1, CD_FRAMESIZE_RAW, cddaHandle);
181 if (d < CD_FRAMESIZE_RAW) {
182 break;
183 }
184
185 s += d;
186
19c03d80 187 fread(subbuffer, 1, SUB_FRAMESIZE, cddaHandle);
188 if (subChanRaw) DecodeRawSubData();
ef79bbde
P		 189 }
190 }
191 else {
192 s = fread(sndbuffer, 1, sizeof(sndbuffer), cddaHandle);
19c03d80 193
194 if (subHandle != NULL) {
195 fread(subbuffer, 1, SUB_FRAMESIZE, subHandle);
196 if (subChanRaw) DecodeRawSubData();
197
198 // a bit crude but ohwell
199 fseek(subHandle, (sizeof(sndbuffer) / CD_FRAMESIZE_RAW - 1) * SUB_FRAMESIZE, SEEK_CUR);
200 }
ef79bbde
P		 201 }
202
203 if (s == 0) {
204 playing = FALSE;
ef79bbde
P		 205 initial_offset = 0;
206 break;
207 }
208
209 if (!cdr.Muted && playing) {
210 if (cddaBigEndian) {
211 for (i = 0; i < s / 2; i++) {
212 tmp = sndbuffer[i * 2];
213 sndbuffer[i * 2] = sndbuffer[i * 2 + 1];
214 sndbuffer[i * 2 + 1] = tmp;
215 }
216 }
217
218 SPU_playCDDAchannel((short *)sndbuffer, s);
219 }
220
221 cddaCurOffset += s;
222 }
223
224#ifdef _WIN32
225 _endthread();
226#else
227 pthread_exit(0);
228 return NULL;
229#endif
230}
231
232// stop the CDDA playback
233static void stopCDDA() {
234 if (!playing) {
235 return;
236 }
237
238 playing = FALSE;
239#ifdef _WIN32
240 WaitForSingleObject(threadid, INFINITE);
241#else
242 pthread_join(threadid, NULL);
243#endif
244
ef79bbde
P		 245 initial_offset = 0;
246}
247
248// start the CDDA playback
249static void startCDDA(unsigned int offset) {
250 if (playing) {
251 if (initial_offset == offset) {
252 return;
253 }
254 stopCDDA();
255 }
256
ef79bbde
P		 257 initial_offset = offset;
258 cddaCurOffset = initial_offset;
259 fseek(cddaHandle, initial_offset, SEEK_SET);
260
261 playing = TRUE;
262
263#ifdef _WIN32
264 threadid = (HANDLE)_beginthread(playthread, 0, NULL);
265#else
266 pthread_create(&threadid, NULL, playthread, NULL);
267#endif
268}
269
270// this function tries to get the .toc file of the given .bin
271// the necessary data is put into the ti (trackinformation)-array
272static int parsetoc(const char *isofile) {
273 char tocname[MAXPATHLEN];
274 FILE *fi;
275 char linebuf[256], dummy[256], name[256];
276 char *token;
277 char time[20], time2[20];
19c03d80 278 unsigned int t, sector_offs;
ef79bbde
P		 279
280 numtracks = 0;
281
282 // copy name of the iso and change extension from .bin to .toc
283 strncpy(tocname, isofile, sizeof(tocname));
284 tocname[MAXPATHLEN - 1] = '\0';
285 if (strlen(tocname) >= 4) {
286 strcpy(tocname + strlen(tocname) - 4, ".toc");
287 }
288 else {
289 return -1;
290 }
291
292 if ((fi = fopen(tocname, "r")) == NULL) {
293 // try changing extension to .cue (to satisfy some stupid tutorials)
294 strcpy(tocname + strlen(tocname) - 4, ".cue");
295 if ((fi = fopen(tocname, "r")) == NULL) {
296 // if filename is image.toc.bin, try removing .bin (for Brasero)
297 strcpy(tocname, isofile);
298 t = strlen(tocname);
299 if (t >= 8 && strcmp(tocname + t - 8, ".toc.bin") == 0) {
300 tocname[t - 4] = '\0';
301 if ((fi = fopen(tocname, "r")) == NULL) {
302 return -1;
303 }
304 }
305 else {
306 return -1;
307 }
308 }
309 }
310
311 memset(&ti, 0, sizeof(ti));
312 cddaBigEndian = TRUE; // cdrdao uses big-endian for CD Audio
313
19c03d80 314 sector_offs = 2 * 75;
315
ef79bbde
P		 316 // parse the .toc file
317 while (fgets(linebuf, sizeof(linebuf), fi) != NULL) {
318 // search for tracks
319 strncpy(dummy, linebuf, sizeof(linebuf));
320 token = strtok(dummy, " ");
321
322 if (token == NULL) continue;
323
324 if (!strcmp(token, "TRACK")) {
325 // get type of track
326 token = strtok(NULL, " ");
327 numtracks++;
328
329 if (!strncmp(token, "MODE2_RAW", 9)) {
330 ti[numtracks].type = DATA;
331 sec2msf(2 * 75, ti[numtracks].start); // assume data track on 0:2:0
332
333 // check if this image contains mixed subchannel data
334 token = strtok(NULL, " ");
335 if (token != NULL && !strncmp(token, "RW_RAW", 6)) {
336 subChanMixed = TRUE;
337 subChanRaw = TRUE;
338 }
339 }
340 else if (!strncmp(token, "AUDIO", 5)) {
341 ti[numtracks].type = CDDA;
342 }
343 }
344 else if (!strcmp(token, "DATAFILE")) {
345 if (ti[numtracks].type == CDDA) {
346 sscanf(linebuf, "DATAFILE \"%[^\"]\" #%d %8s", name, &t, time2);
347 t /= CD_FRAMESIZE_RAW + (subChanMixed ? SUB_FRAMESIZE : 0);
19c03d80 348 ti[numtracks].start_offset = t;
349 t += sector_offs;
ef79bbde
P		 350 sec2msf(t, (char *)&ti[numtracks].start);
351 tok2msf((char *)&time2, (char *)&ti[numtracks].length);
352 }
353 else {
354 sscanf(linebuf, "DATAFILE \"%[^\"]\" %8s", name, time);
355 tok2msf((char *)&time, (char *)&ti[numtracks].length);
356 }
357 }
358 else if (!strcmp(token, "FILE")) {
359 sscanf(linebuf, "FILE \"%[^\"]\" #%d %8s %8s", name, &t, time, time2);
360 tok2msf((char *)&time, (char *)&ti[numtracks].start);
361 t /= CD_FRAMESIZE_RAW + (subChanMixed ? SUB_FRAMESIZE : 0);
19c03d80 362 ti[numtracks].start_offset = t;
363 t += msf2sec(ti[numtracks].start) + sector_offs;
ef79bbde
P		 364 sec2msf(t, (char *)&ti[numtracks].start);
365 tok2msf((char *)&time2, (char *)&ti[numtracks].length);
366 }
19c03d80 367 else if (!strcmp(token, "ZERO")) {
368 sscanf(linebuf, "ZERO AUDIO RW_RAW %8s", time);
369 tok2msf((char *)&time, dummy);
370 sector_offs += msf2sec(dummy);
371 }
ef79bbde
P		 372 }
373
374 fclose(fi);
375
376 return 0;
377}
378
379// this function tries to get the .cue file of the given .bin
380// the necessary data is put into the ti (trackinformation)-array
381static int parsecue(const char *isofile) {
382 char cuename[MAXPATHLEN];
38b8102c 383 char filepath[MAXPATHLEN];
384 char *incue_fname;
ef79bbde
P		 385 FILE *fi;
386 char *token;
387 char time[20];
388 char *tmp;
19c03d80 389 char linebuf[256], tmpb[256], dummy[256];
38b8102c 390 unsigned int incue_max_len;
19c03d80 391 unsigned int t, file_len, sector_offs;
ef79bbde
P		 392
393 numtracks = 0;
394
395 // copy name of the iso and change extension from .bin to .cue
396 strncpy(cuename, isofile, sizeof(cuename));
397 cuename[MAXPATHLEN - 1] = '\0';
398 if (strlen(cuename) >= 4) {
399 strcpy(cuename + strlen(cuename) - 4, ".cue");
400 }
401 else {
402 return -1;
403 }
404
405 if ((fi = fopen(cuename, "r")) == NULL) {
406 return -1;
407 }
408
409 // Some stupid tutorials wrongly tell users to use cdrdao to rip a
410 // "bin/cue" image, which is in fact a "bin/toc" image. So let's check
411 // that...
412 if (fgets(linebuf, sizeof(linebuf), fi) != NULL) {
413 if (!strncmp(linebuf, "CD_ROM_XA", 9)) {
414 // Don't proceed further, as this is actually a .toc file rather
415 // than a .cue file.
416 fclose(fi);
417 return parsetoc(isofile);
418 }
419 fseek(fi, 0, SEEK_SET);
420 }
421
38b8102c 422 // build a path for files referenced in .cue
423 strncpy(filepath, cuename, sizeof(filepath));
424 tmp = strrchr(filepath, '/') + 1;
425 if (tmp == NULL)
426 tmp = strrchr(filepath, '\\') + 1;
427 if (tmp == NULL)
428 tmp = filepath;
429 *tmp = 0;
430 filepath[sizeof(filepath) - 1] = 0;
431 incue_fname = tmp;
432 incue_max_len = sizeof(filepath) - (tmp - filepath) - 1;
433
ef79bbde
P		 434 memset(&ti, 0, sizeof(ti));
435
19c03d80 436 file_len = 0;
437 sector_offs = 2 * 75;
438
ef79bbde
P		 439 while (fgets(linebuf, sizeof(linebuf), fi) != NULL) {
440 strncpy(dummy, linebuf, sizeof(linebuf));
441 token = strtok(dummy, " ");
442
443 if (token == NULL) {
444 continue;
445 }
446
19c03d80 447 if (!strcmp(token, "TRACK")) {
ef79bbde
P		 448 numtracks++;
449
450 if (strstr(linebuf, "AUDIO") != NULL) {
451 ti[numtracks].type = CDDA;
452 }
453 else if (strstr(linebuf, "MODE1/2352") != NULL || strstr(linebuf, "MODE2/2352") != NULL) {
454 ti[numtracks].type = DATA;
455 }
456 }
457 else if (!strcmp(token, "INDEX")) {
19c03d80 458 sscanf(linebuf, " INDEX %02d %8s", &t, time);
459 tok2msf(time, (char *)&ti[numtracks].start);
ef79bbde 460
19c03d80 461 t = msf2sec(ti[numtracks].start);
462 ti[numtracks].start_offset = t;
463 t += sector_offs;
ef79bbde 464 sec2msf(t, ti[numtracks].start);
19c03d80 465
466 // default track length to file length
467 t = file_len - ti[numtracks].start_offset;
468 sec2msf(t, ti[numtracks].length);
469
470 if (numtracks > 1 && ti[numtracks].handle == NULL) {
471 // this track uses the same file as the last,
472 // start of this track is last track's end
473 t = msf2sec(ti[numtracks].start) - msf2sec(ti[numtracks - 1].start);
474 sec2msf(t, ti[numtracks - 1].length);
38b8102c 475 }
19c03d80 476 }
477 else if (!strcmp(token, "PREGAP")) {
478 if (sscanf(linebuf, " PREGAP %8s", time) == 1) {
479 tok2msf(time, dummy);
480 sector_offs += msf2sec(dummy);
38b8102c 481 }
19c03d80 482 }
483 else if (!strcmp(token, "FILE")) {
484 sscanf(linebuf, " FILE \"%[^\"]\"", tmpb);
485
486 // absolute path?
487 ti[numtracks + 1].handle = fopen(tmpb, "rb");
488 if (ti[numtracks + 1].handle == NULL) {
489 // relative to .cue?
490 tmp = strrchr(tmpb, '\\');
491 if (tmp == NULL)
492 tmp = strrchr(tmpb, '/');
38b8102c 493 if (tmp != NULL)
19c03d80 494 tmp++;
495 else
496 tmp = tmpb;
497 strncpy(incue_fname, tmp, incue_max_len);
498 ti[numtracks + 1].handle = fopen(filepath, "rb");
38b8102c 499 }
ef79bbde 500
19c03d80 501 // update global offset if this is not first file in this .cue
502 if (numtracks + 1 > 1)
503 sector_offs += file_len;
504
505 file_len = 0;
38b8102c 506 if (ti[numtracks + 1].handle == NULL) {
19c03d80 507 SysPrintf(_("\ncould not open: %s\n"), filepath);
508 continue;
38b8102c 509 }
19c03d80 510 fseek(ti[numtracks + 1].handle, 0, SEEK_END);
511 file_len = ftell(ti[numtracks + 1].handle) / 2352;
512
513 if (numtracks == 0 && strlen(isofile) >= 4 &&
514 strcmp(isofile + strlen(isofile) - 4, ".cue") == 0)
515 {
38b8102c 516 // user selected .cue as image file, use it's data track instead
517 fclose(cdHandle);
518 cdHandle = fopen(filepath, "rb");
ef79bbde
P		 519 }
520 }
521 }
522
523 fclose(fi);
524
ef79bbde
P		 525 return 0;
526}
527
528// this function tries to get the .ccd file of the given .img
529// the necessary data is put into the ti (trackinformation)-array
530static int parseccd(const char *isofile) {
531 char ccdname[MAXPATHLEN];
532 FILE *fi;
533 char linebuf[256];
534 unsigned int t;
535
536 numtracks = 0;
537
538 // copy name of the iso and change extension from .img to .ccd
539 strncpy(ccdname, isofile, sizeof(ccdname));
540 ccdname[MAXPATHLEN - 1] = '\0';
541 if (strlen(ccdname) >= 4) {
542 strcpy(ccdname + strlen(ccdname) - 4, ".ccd");
543 }
544 else {
545 return -1;
546 }
547
548 if ((fi = fopen(ccdname, "r")) == NULL) {
549 return -1;
550 }
551
552 memset(&ti, 0, sizeof(ti));
553
554 while (fgets(linebuf, sizeof(linebuf), fi) != NULL) {
555 if (!strncmp(linebuf, "[TRACK", 6)){
556 numtracks++;
557 }
558 else if (!strncmp(linebuf, "MODE=", 5)) {
559 sscanf(linebuf, "MODE=%d", &t);
560 ti[numtracks].type = ((t == 0) ? CDDA : DATA);
561 }
562 else if (!strncmp(linebuf, "INDEX 1=", 8)) {
563 sscanf(linebuf, "INDEX 1=%d", &t);
564 sec2msf(t + 2 * 75, ti[numtracks].start);
19c03d80 565 ti[numtracks].start_offset = t;
ef79bbde
P		 566
567 // If we've already seen another track, this is its end
568 if (numtracks > 1) {
569 t = msf2sec(ti[numtracks].start) - msf2sec(ti[numtracks - 1].start);
570 sec2msf(t, ti[numtracks - 1].length);
571 }
572 }
573 }
574
575 fclose(fi);
576
577 // Fill out the last track's end based on size
578 if (numtracks >= 1) {
579 fseek(cdHandle, 0, SEEK_END);
580 t = ftell(cdHandle) / 2352 - msf2sec(ti[numtracks].start) + 2 * 75;
581 sec2msf(t, ti[numtracks].length);
582 }
583
584 return 0;
585}
586
587// this function tries to get the .mds file of the given .mdf
588// the necessary data is put into the ti (trackinformation)-array
589static int parsemds(const char *isofile) {
590 char mdsname[MAXPATHLEN];
591 FILE *fi;
592 unsigned int offset, extra_offset, l, i;
593 unsigned short s;
594
595 numtracks = 0;
596
597 // copy name of the iso and change extension from .mdf to .mds
598 strncpy(mdsname, isofile, sizeof(mdsname));
599 mdsname[MAXPATHLEN - 1] = '\0';
600 if (strlen(mdsname) >= 4) {
601 strcpy(mdsname + strlen(mdsname) - 4, ".mds");
602 }
603 else {
604 return -1;
605 }
606
607 if ((fi = fopen(mdsname, "rb")) == NULL) {
608 return -1;
609 }
610
611 memset(&ti, 0, sizeof(ti));
612
613 // check if it's a valid mds file
614 fread(&i, 1, sizeof(unsigned int), fi);
615 i = SWAP32(i);
616 if (i != 0x4944454D) {
617 // not an valid mds file
618 fclose(fi);
619 return -1;
620 }
621
622 // get offset to session block
623 fseek(fi, 0x50, SEEK_SET);
624 fread(&offset, 1, sizeof(unsigned int), fi);
625 offset = SWAP32(offset);
626
627 // get total number of tracks
628 offset += 14;
629 fseek(fi, offset, SEEK_SET);
630 fread(&s, 1, sizeof(unsigned short), fi);
631 s = SWAP16(s);
632 numtracks = s;
633
634 // get offset to track blocks
635 fseek(fi, 4, SEEK_CUR);
636 fread(&offset, 1, sizeof(unsigned int), fi);
637 offset = SWAP32(offset);
638
639 // skip lead-in data
640 while (1) {
641 fseek(fi, offset + 4, SEEK_SET);
642 if (fgetc(fi) < 0xA0) {
643 break;
644 }
645 offset += 0x50;
646 }
647
648 // check if the image contains mixed subchannel data
649 fseek(fi, offset + 1, SEEK_SET);
650 subChanMixed = (fgetc(fi) ? TRUE : FALSE);
651
652 // read track data
653 for (i = 1; i <= numtracks; i++) {
654 fseek(fi, offset, SEEK_SET);
655
656 // get the track type
657 ti[i].type = ((fgetc(fi) == 0xA9) ? CDDA : DATA);
658 fseek(fi, 8, SEEK_CUR);
659
660 // get the track starting point
661 ti[i].start[0] = fgetc(fi);
662 ti[i].start[1] = fgetc(fi);
663 ti[i].start[2] = fgetc(fi);
664
ef79bbde
P		 665 // get the track length
666 fread(&extra_offset, 1, sizeof(unsigned int), fi);
667 extra_offset = SWAP32(extra_offset);
668
669 fseek(fi, extra_offset + 4, SEEK_SET);
670 fread(&l, 1, sizeof(unsigned int), fi);
671 l = SWAP32(l);
672 sec2msf(l, ti[i].length);
673
19c03d80 674 // get track start offset (in .mdf)
675 fseek(fi, offset + 0x28, SEEK_SET);
676 fread(&l, 1, sizeof(unsigned int), fi);
677 l = SWAP32(l);
678 ti[i].start_offset = l / CD_FRAMESIZE_RAW;
679
ef79bbde
P		 680 offset += 0x50;
681 }
682
683 fclose(fi);
684 return 0;
685}
686
687// this function tries to get the .sub file of the given .img
688static int opensubfile(const char *isoname) {
689 char subname[MAXPATHLEN];
690
691 // copy name of the iso and change extension from .img to .sub
692 strncpy(subname, isoname, sizeof(subname));
693 subname[MAXPATHLEN - 1] = '\0';
694 if (strlen(subname) >= 4) {
695 strcpy(subname + strlen(subname) - 4, ".sub");
696 }
697 else {
698 return -1;
699 }
700
701 subHandle = fopen(subname, "rb");
702 if (subHandle == NULL) {
703 return -1;
704 }
705
706 return 0;
707}
708
ae4e7dc9 709static int opensbifile(const char *isoname) {
710 char sbiname[MAXPATHLEN];
711 int s;
712
713 strncpy(sbiname, isoname, sizeof(sbiname));
714 sbiname[MAXPATHLEN - 1] = '\0';
715 if (strlen(sbiname) >= 4) {
716 strcpy(sbiname + strlen(sbiname) - 4, ".sbi");
717 }
718 else {
719 return -1;
720 }
721
722 fseek(cdHandle, 0, SEEK_END);
723 s = ftell(cdHandle) / 2352;
724
725 return LoadSBI(sbiname, s);
726}
727
ef79bbde
P		 728static void PrintTracks(void) {
729 int i;
730
731 for (i = 1; i <= numtracks; i++) {
732 SysPrintf(_("Track %.2d (%s) - Start %.2d:%.2d:%.2d, Length %.2d:%.2d:%.2d\n"),
733 i, (ti[i].type == DATA ? "DATA" : "AUDIO"),
734 ti[i].start[0], ti[i].start[1], ti[i].start[2],
735 ti[i].length[0], ti[i].length[1], ti[i].length[2]);
736 }
737}
738
739// This function is invoked by the front-end when opening an ISO
740// file for playback
741static long CALLBACK ISOopen(void) {
742 if (cdHandle != NULL) {
743 return 0; // it's already open
744 }
745
746 cdHandle = fopen(GetIsoFile(), "rb");
747 if (cdHandle == NULL) {
748 return -1;
749 }
750
751 SysPrintf(_("Loaded CD Image: %s"), GetIsoFile());
752
753 cddaBigEndian = FALSE;
754 subChanMixed = FALSE;
755 subChanRaw = FALSE;
756
757 if (parsecue(GetIsoFile()) == 0) {
758 SysPrintf("[+cue]");
759 }
760 else if (parsetoc(GetIsoFile()) == 0) {
761 SysPrintf("[+toc]");
762 }
763 else if (parseccd(GetIsoFile()) == 0) {
764 SysPrintf("[+ccd]");
765 }
766 else if (parsemds(GetIsoFile()) == 0) {
767 SysPrintf("[+mds]");
768 }
769
770 if (!subChanMixed && opensubfile(GetIsoFile()) == 0) {
771 SysPrintf("[+sub]");
772 }
ae4e7dc9 773 if (opensbifile(GetIsoFile()) == 0) {
774 SysPrintf("[+sbi]");
775 }
ef79bbde
P		 776
777 SysPrintf(".\n");
778
779 PrintTracks();
780
38b8102c 781 // make sure we have another handle open for cdda
782 if (numtracks > 1 && ti[1].handle == NULL) {
783 ti[1].handle = fopen(GetIsoFile(), "rb");
784 }
858ad511 785 cddaCurOffset = cddaStartOffset = 0;
38b8102c 786
ef79bbde
P		 787 return 0;
788}
789
790static long CALLBACK ISOclose(void) {
38b8102c 791 int i;
792
ef79bbde
P		 793 if (cdHandle != NULL) {
794 fclose(cdHandle);
795 cdHandle = NULL;
796 }
797 if (subHandle != NULL) {
798 fclose(subHandle);
799 subHandle = NULL;
800 }
801 stopCDDA();
38b8102c 802 cddaHandle = NULL;
803
804 for (i = 1; i <= numtracks; i++) {
805 if (ti[i].handle != NULL) {
806 fclose(ti[i].handle);
807 ti[i].handle = NULL;
808 }
809 }
810 numtracks = 0;
ae4e7dc9 811 UnloadSBI();
38b8102c 812
813 return 0;
814}
815
816static long CALLBACK ISOinit(void) {
817 assert(cdHandle == NULL);
818 assert(subHandle == NULL);
819
820 return 0; // do nothing
821}
822
823static long CALLBACK ISOshutdown(void) {
824 ISOclose();
ef79bbde
P		 825 return 0;
826}
827
828// return Starting and Ending Track
829// buffer:
830// byte 0 - start track
831// byte 1 - end track
832static long CALLBACK ISOgetTN(unsigned char *buffer) {
833 buffer[0] = 1;
834
835 if (numtracks > 0) {
836 buffer[1] = numtracks;
837 }
838 else {
839 buffer[1] = 1;
840 }
841
842 return 0;
843}
844
845// return Track Time
846// buffer:
847// byte 0 - frame
848// byte 1 - second
849// byte 2 - minute
850static long CALLBACK ISOgetTD(unsigned char track, unsigned char *buffer) {
858ad511 851 if (track == 0) {
852 // CD length according pcsxr-svn (done a bit different here)
853 unsigned int sect;
854 unsigned char time[3];
855 sect = msf2sec(ti[numtracks].start) + msf2sec(ti[numtracks].length);
ab948f7e 856 sec2msf(sect, (char *)time);
858ad511 857 buffer[2] = time[0];
858 buffer[1] = time[1];
859 buffer[0] = time[2];
860 }
861 else if (numtracks > 0 && track <= numtracks) {
ef79bbde
P		 862 buffer[2] = ti[track].start[0];
863 buffer[1] = ti[track].start[1];
864 buffer[0] = ti[track].start[2];
865 }
866 else {
867 buffer[2] = 0;
868 buffer[1] = 2;
869 buffer[0] = 0;
870 }
871
872 return 0;
873}
874
875// decode 'raw' subchannel data ripped by cdrdao
876static void DecodeRawSubData(void) {
877 unsigned char subQData[12];
878 int i;
879
880 memset(subQData, 0, sizeof(subQData));
881
882 for (i = 0; i < 8 * 12; i++) {
883 if (subbuffer[i] & (1 << 6)) { // only subchannel Q is needed
884 subQData[i >> 3] |= (1 << (7 - (i & 7)));
885 }
886 }
887
888 memcpy(&subbuffer[12], subQData, 12);
889}
890
891// read track
892// time: byte 0 - minute; byte 1 - second; byte 2 - frame
893// uses bcd format
894static long CALLBACK ISOreadTrack(unsigned char *time) {
19c03d80 895 int sector = MSF2SECT(btoi(time[0]), btoi(time[1]), btoi(time[2]));
896
ef79bbde
P		 897 if (cdHandle == NULL) {
898 return -1;
899 }
900
901 if (subChanMixed) {
19c03d80 902 fseek(cdHandle, sector * (CD_FRAMESIZE_RAW + SUB_FRAMESIZE) + 12, SEEK_SET);
ef79bbde
P		 903 fread(cdbuffer, 1, DATA_SIZE, cdHandle);
904 fread(subbuffer, 1, SUB_FRAMESIZE, cdHandle);
905
906 if (subChanRaw) DecodeRawSubData();
907 }
908 else {
19c03d80 909 fseek(cdHandle, sector * CD_FRAMESIZE_RAW + 12, SEEK_SET);
ef79bbde
P		 910 fread(cdbuffer, 1, DATA_SIZE, cdHandle);
911
912 if (subHandle != NULL) {
19c03d80 913 fseek(subHandle, sector * SUB_FRAMESIZE, SEEK_SET);
ef79bbde
P		 914 fread(subbuffer, 1, SUB_FRAMESIZE, subHandle);
915
916 if (subChanRaw) DecodeRawSubData();
917 }
918 }
919
920 return 0;
921}
922
923// return readed track
924static unsigned char * CALLBACK ISOgetBuffer(void) {
925 return cdbuffer;
926}
927
928// plays cdda audio
929// sector: byte 0 - minute; byte 1 - second; byte 2 - frame
930// does NOT uses bcd format
931static long CALLBACK ISOplay(unsigned char *time) {
19c03d80 932 unsigned int i, abs_sect;
933 int file_sect;
38b8102c 934
7b8da7ab 935 if (numtracks <= 1)
936 return 0;
937
38b8102c 938 // find the track
19c03d80 939 abs_sect = msf2sec((char *)time);
38b8102c 940 for (i = numtracks; i > 1; i--)
19c03d80 941 if (msf2sec(ti[i].start) <= abs_sect + 2 * 75)
38b8102c 942 break;
943
19c03d80 944 file_sect = ti[i].start_offset + (abs_sect - msf2sec(ti[i].start));
945 if (file_sect < 0)
946 file_sect = 0;
947
38b8102c 948 // find the file that contains this track
949 for (; i > 1; i--)
950 if (ti[i].handle != NULL)
951 break;
952
19c03d80 953 cddaStartOffset = abs_sect - file_sect;
38b8102c 954 cddaHandle = ti[i].handle;
955
ef79bbde
P		 956 if (SPU_playCDDAchannel != NULL) {
957 if (subChanMixed) {
19c03d80 958 startCDDA(file_sect * (CD_FRAMESIZE_RAW + SUB_FRAMESIZE));
ef79bbde
P		 959 }
960 else {
19c03d80 961 startCDDA(file_sect * CD_FRAMESIZE_RAW);
962 if (subHandle != NULL)
963 fseek(subHandle, file_sect * SUB_FRAMESIZE, SEEK_SET);
ef79bbde
P		 964 }
965 }
966 return 0;
967}
968
969// stops cdda audio
970static long CALLBACK ISOstop(void) {
971 stopCDDA();
972 return 0;
973}
974
975// gets subchannel data
976static unsigned char* CALLBACK ISOgetBufferSub(void) {
977 if (subHandle != NULL || subChanMixed) {
978 return subbuffer;
979 }
980
981 return NULL;
982}
983
984static long CALLBACK ISOgetStatus(struct CdrStat *stat) {
985 int sec;
986
987 CDR__getStatus(stat);
988
989 if (playing) {
990 stat->Type = 0x02;
991 stat->Status |= 0x80;
ef79bbde
P		 992 }
993 else {
994 stat->Type = 0x01;
995 }
996
858ad511 997 sec = (cddaStartOffset + cddaCurOffset) / CD_FRAMESIZE_RAW;
998 sec2msf(sec, (char *)stat->Time);
999
ef79bbde
P		 1000 return 0;
1001}
1002
1003void cdrIsoInit(void) {
1004 CDR_init = ISOinit;
1005 CDR_shutdown = ISOshutdown;
1006 CDR_open = ISOopen;
1007 CDR_close = ISOclose;
1008 CDR_getTN = ISOgetTN;
1009 CDR_getTD = ISOgetTD;
1010 CDR_readTrack = ISOreadTrack;
1011 CDR_getBuffer = ISOgetBuffer;
1012 CDR_play = ISOplay;
1013 CDR_stop = ISOstop;
1014 CDR_getBufferSub = ISOgetBufferSub;
1015 CDR_getStatus = ISOgetStatus;
1016
1017 CDR_getDriveLetter = CDR__getDriveLetter;
1018 CDR_configure = CDR__configure;
1019 CDR_test = CDR__test;
1020 CDR_about = CDR__about;
1021 CDR_setfilename = CDR__setfilename;
1022
1023 numtracks = 0;
1024}
1025
1026int cdrIsoActive(void) {
1027 return (cdHandle != NULL);
1028}
ARM optimized PCSX fork