CDVDiso/src/CDVDisop.cpp

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <time.h>
#include <string.h>
#include <stdarg.h>

#include "CDVDiso.h"
#include "Config.h"

#ifndef MAX_PATH
#define MAX_PATH 255
#endif

char IsoFile[256];
char IsoCWD[256];
char CdDev[256];

_cdIso cdIso[8];
u8 *pbuffer;
int cdblocksize;
int cdblockofs;
int cdoffset;
int cdtype;
int cdblocks;

int Zmode; // 1 Z - 2 bz2
int fmode;                                              // 0 - file / 1 - Zfile
char *Ztable;

int BlockDump;
isoFile *fdump;
isoFile *iso;

FILE *cdvdLog = NULL;

// This var is used to detect resume-style behavior of the Pcsx2 emulator,
// and skip prompting the user for a new CD when it's likely they want to run the existing one.
static char cdvdCurrentIso[MAX_PATH];

char *methods[] =
{
        ".Z  - compress faster",
        ".BZ - compress better",
        NULL
};

#ifdef PCSX2_DEBUG
char *LibName = "Linuz Iso CDVD (Debug) ";
#else
char *LibName = "Linuz Iso CDVD ";
#endif

const u8 version = PS2E_CDVD_VERSION;
const u8 revision = 0;
const u8 build = 9;

u8 cdbuffer[CD_FRAMESIZE_RAW * 10] = {0};

s32 msf_to_lba(u8 m, u8 s, u8 f)
{
        u32 lsn;
        lsn = f;
        lsn += (s - 2) * 75;
        lsn += m * 75 * 60;
        return lsn;
}

void lba_to_msf(s32 lba, u8* m, u8* s, u8* f)
{
        lba += 150;
        *m = lba / (60 * 75);
        *s = (lba / 75) % 60;
        *f = lba % 75;
}

#define btoi(b) ((b)/16*10 + (b)%16)    /* BCD to u_char */
#define itob(i)         ((i)/10*16 + (i)%10)            /* u_char to BCD */


EXPORT_C_(char*) PS2EgetLibName()
{
        return LibName;
}

EXPORT_C_(u32) PS2EgetLibType()
{
        return PS2E_LT_CDVD;
}

EXPORT_C_(u32) PS2EgetLibVersion2(u32 type)
{
        return (version << 16) | (revision << 8) | build;
}

#ifdef PCSX2_DEBUG
void __Log(char *fmt, ...)
{
        va_list list;

        if (cdvdLog == NULL) return;

        va_start(list, fmt);
        vfprintf(cdvdLog, fmt, list);
        va_end(list);
}
#else
#define __Log 0&&
#endif


EXPORT_C_(s32) CDVDinit()
{
#ifdef PCSX2_DEBUG
        cdvdLog = fopen("logs/cdvdLog.txt", "w");
        if (cdvdLog == NULL)
        {
                cdvdLog = fopen("cdvdLog.txt", "w");
                if (cdvdLog == NULL)
                {
                        SysMessage("Can't create cdvdLog.txt");
                        return -1;
                }
        }
        setvbuf(cdvdLog, NULL,  _IONBF, 0);
        CDVD_LOG("CDVDinit\n");
#endif

        cdvdCurrentIso[0] = 0;
        memset(cdIso, 0, sizeof(cdIso));
        return 0;
}

EXPORT_C_(void) CDVDshutdown()
{
        cdvdCurrentIso[0] = 0;
#ifdef CDVD_LOG
        if (cdvdLog != NULL) fclose(cdvdLog);
#endif
}

EXPORT_C_(s32) CDVDopen(const char* pTitle)
{
        LoadConf();

        if (pTitle != NULL) strcpy(IsoFile, pTitle);

        if (*IsoFile == 0) strcpy(IsoFile, cdvdCurrentIso);

        if (*IsoFile == 0)
        {
                char temp[256];

                CfgOpenFile();

                LoadConf();
                strcpy(temp, IsoFile);
                *IsoFile = 0;
                SaveConf();
                strcpy(IsoFile, temp);
        }

        iso = isoOpen(IsoFile);
        if (iso == NULL)
        {
                SysMessage("Error loading %s\n", IsoFile);
                return -1;
        }

        if (iso->type == ISOTYPE_DVD)
                cdtype = CDVD_TYPE_PS2DVD;
        else if (iso->type == ISOTYPE_AUDIO)
                cdtype = CDVD_TYPE_CDDA;
        else
                cdtype = CDVD_TYPE_PS2CD;

        if (BlockDump)
        {
                char fname_only[MAX_PATH];

#ifdef _WIN32
                char fname[MAX_PATH], ext[MAX_PATH];
                _splitpath(IsoFile, NULL, NULL, fname, ext);
                _makepath(fname_only, NULL, NULL, fname, NULL);
#else
                char* p, *plast;

                plast = p = strchr(IsoFile, '/');
                while (p != NULL)
                {
                        plast = p;
                        p = strchr(p + 1, '/');
                }

                // Lets not create dumps in the plugin directory.
                strcpy(fname_only, "../");
                if (plast != NULL)
                        strcat(fname_only, plast + 1);
                else
                        strcat(fname_only, IsoFile);

                plast = p = strchr(fname_only, '.');

                while (p != NULL)
                {
                        plast = p;
                        p = strchr(p + 1, '.');
                }

                if (plast != NULL) *plast = 0;

#endif
                strcat(fname_only, ".dump");
                fdump = isoCreate(fname_only, ISOFLAGS_BLOCKDUMP);
                if (fdump) isoSetFormat(fdump, iso->blockofs, iso->blocksize, iso->blocks);
        }
        else
        {
                fdump = NULL;
        }

        return 0;
}

EXPORT_C_(void) CDVDclose()
{

        strcpy(cdvdCurrentIso, IsoFile);

        isoClose(iso);
        if (fdump != NULL) isoClose(fdump);
}

EXPORT_C_(s32) CDVDreadSubQ(u32 lsn, cdvdSubQ* subq)
{
        // fake it
        u8 min, sec, frm;
        subq->ctrl              = 4;
        subq->mode              = 1;
        subq->trackNum  = itob(1);
        subq->trackIndex = itob(1);

        lba_to_msf(lsn, &min, &sec, &frm);
        subq->trackM    = itob(min);
        subq->trackS    = itob(sec);
        subq->trackF    = itob(frm);

        subq->pad               = 0;

        lba_to_msf(lsn + (2*75), &min, &sec, &frm);
        subq->discM             = itob(min);
        subq->discS             = itob(sec);
        subq->discF             = itob(frm);
        return 0;
}

EXPORT_C_(s32) CDVDgetTN(cdvdTN *Buffer)
{
        Buffer->strack = 1;
        Buffer->etrack = 1;

        return 0;
}

EXPORT_C_(s32) CDVDgetTD(u8 Track, cdvdTD *Buffer)
{
        if (Track == 0)
        {
                Buffer->lsn = iso->blocks;
        }
        else
        {
                Buffer->type = CDVD_MODE1_TRACK;
                Buffer->lsn = 0;
        }

        return 0;
}

static s32 layer1start = -1;

static bool testForPartitionInfo( const u8 (&tempbuffer)[CD_FRAMESIZE_RAW] )
{
        const int off   = iso->blockofs;

        // test for: CD001
        return (
                (tempbuffer[off+1] == 0x43) &&
                (tempbuffer[off+2] == 0x44) &&
                (tempbuffer[off+3] == 0x30) &&
                (tempbuffer[off+4] == 0x30) &&
                (tempbuffer[off+5] == 0x31)
        );
}

EXPORT_C_(s32) CDVDgetTOC(void* toc)
{
        u8 type = CDVDgetDiskType();
        u8* tocBuff = (u8*)toc;

        //__Log("CDVDgetTOC\n");

        if (type == CDVD_TYPE_DVDV || type == CDVD_TYPE_PS2DVD)
        {
                // get dvd structure format
                // scsi command 0x43
                memset(tocBuff, 0, 2048);

                if (layer1start != -2 && iso->blocks >= 0x300000)
                {
                        int off = iso->blockofs;

                        // dual sided
                        tocBuff[ 0] = 0x24;
                        tocBuff[ 1] = 0x02;
                        tocBuff[ 2] = 0xF2;
                        tocBuff[ 3] = 0x00;
                        tocBuff[ 4] = 0x41;
                        tocBuff[ 5] = 0x95;

                        tocBuff[14] = 0x60; // dual sided, ptp

                        tocBuff[16] = 0x00;
                        tocBuff[17] = 0x03;
                        tocBuff[18] = 0x00;
                        tocBuff[19] = 0x00;

                        // search for it
                        if (layer1start == -1)
                        {
                                printf("CDVD: searching for layer1...");

                                /*tempbuffer = (u8*)malloc(CD_FRAMESIZE_RAW * 10);
                                for (layer1start = (iso->blocks / 2 - 0x10) & ~0xf; layer1start < 0x200010; layer1start += 16)
                                {
                                        isoReadBlock(iso, tempbuffer, layer1start);
                                        // CD001
                                        if (tempbuffer[off+1] == 0x43 &&
                                                tempbuffer[off+2] == 0x44 &&
                                                tempbuffer[off+3] == 0x30 &&
                                                tempbuffer[off+4] == 0x30 &&
                                                tempbuffer[off+5] == 0x31)
                                                break;
                                }
                                free(tempbuffer);*/

                                uint midsector = (iso->blocks / 2) & ~0xf;
                                uint deviation = 0;

                                while( (layer1start == -1) && (deviation < midsector-16) )
                                {
                                        u8 tempbuffer[CD_FRAMESIZE_RAW];
                                        isoReadBlock(iso, tempbuffer, midsector-deviation);

                                        if(testForPartitionInfo( tempbuffer ))
                                                layer1start = midsector-deviation;
                                        else
                                        {
                                                isoReadBlock(iso, tempbuffer, midsector+deviation);
                                                if( testForPartitionInfo( tempbuffer ) )
                                                        layer1start = midsector+deviation;
                                        }

                                        if( layer1start != -1 )
                                        {
                                                if( tempbuffer[iso->blockofs] != 0x01 )
                                                {
                                                        fprintf( stderr, "(LinuzCDVDiso): Invalid partition type on layer 1!? (type=0x%x)", tempbuffer[iso->blockofs] );
                                                }
                                        }
                                        deviation += 16;
                                }


                                if (layer1start == -1)
                                {
                                        printf("(LinuzCDVDiso): Couldn't find second layer on dual layer... ignoring\n");
                                        // fake it
                                        tocBuff[ 0] = 0x04;
                                        tocBuff[ 1] = 0x02;
                                        tocBuff[ 2] = 0xF2;
                                        tocBuff[ 3] = 0x00;
                                        tocBuff[ 4] = 0x86;
                                        tocBuff[ 5] = 0x72;

                                        tocBuff[16] = 0x00;
                                        tocBuff[17] = 0x03;
                                        tocBuff[18] = 0x00;
                                        tocBuff[19] = 0x00;
                                        layer1start = -2;
                                        return 0;
                                }

                                printf("(LinuzCDVDiso): found at 0x%8.8x\n", layer1start);
                                layer1start = layer1start + 0x30000 - 1;
                        }

                        tocBuff[20] = layer1start >> 24;
                        tocBuff[21] = (layer1start >> 16) & 0xff;
                        tocBuff[22] = (layer1start >> 8) & 0xff;
                        tocBuff[23] = (layer1start >> 0) & 0xff;
                }
                else
                {
                        // fake it
                        tocBuff[ 0] = 0x04;
                        tocBuff[ 1] = 0x02;
                        tocBuff[ 2] = 0xF2;
                        tocBuff[ 3] = 0x00;
                        tocBuff[ 4] = 0x86;
                        tocBuff[ 5] = 0x72;

                        tocBuff[16] = 0x00;
                        tocBuff[17] = 0x03;
                        tocBuff[18] = 0x00;
                        tocBuff[19] = 0x00;
                }
        }
        else if ((type == CDVD_TYPE_CDDA) || (type == CDVD_TYPE_PS2CDDA) ||
                     (type == CDVD_TYPE_PS2CD) || (type == CDVD_TYPE_PSCDDA) || (type == CDVD_TYPE_PSCD))
        {
                // cd toc
                // (could be replaced by 1 command that reads the full toc)
                u8 min, sec, frm;
                s32 i, err;
                cdvdTN diskInfo;
                cdvdTD trackInfo;
                memset(tocBuff, 0, 1024);
                if (CDVDgetTN(&diskInfo) == -1)
                {
                        diskInfo.etrack = 0;
                        diskInfo.strack = 1;
                }
                if (CDVDgetTD(0, &trackInfo) == -1) trackInfo.lsn = 0;

                tocBuff[0] = 0x41;
                tocBuff[1] = 0x00;

                //Number of FirstTrack
                tocBuff[2] = 0xA0;
                tocBuff[7] = itob(diskInfo.strack);

                //Number of LastTrack
                tocBuff[12] = 0xA1;
                tocBuff[17] = itob(diskInfo.etrack);

                //DiskLength
                lba_to_msf(trackInfo.lsn, &min, &sec, &frm);
                tocBuff[22] = 0xA2;
                tocBuff[27] = itob(min);
                tocBuff[28] = itob(sec);

                for (i = diskInfo.strack; i <= diskInfo.etrack; i++)
                {
                        err = CDVDgetTD(i, &trackInfo);
                        lba_to_msf(trackInfo.lsn, &min, &sec, &frm);
                        tocBuff[i*10+30] = trackInfo.type;
                        tocBuff[i*10+32] = err == -1 ? 0 : itob(i);       //number
                        tocBuff[i*10+37] = itob(min);
                        tocBuff[i*10+38] = itob(sec);
                        tocBuff[i*10+39] = itob(frm);
                }
        }
        else
                return -1;

        return 0;
}

EXPORT_C_(s32) CDVDreadTrack(u32 lsn, int mode)
{
        int _lsn = lsn;

        //__Log("CDVDreadTrack: %x %x\n", lsn, mode);
        if (_lsn < 0)
        {
//              lsn = 2097152 + (-_lsn);
                lsn = iso->blocks - (-_lsn);
        }
//      printf ("CDRreadTrack %d\n", lsn);

        isoReadBlock(iso, cdbuffer, lsn);
        if (fdump != NULL)
        {
                isoWriteBlock(fdump, cdbuffer, lsn);
        }

        pbuffer = cdbuffer;
        switch (mode)
        {
                case CDVD_MODE_2352:
                        break;
                case CDVD_MODE_2340:
                        pbuffer += 12;
                        break;
                case CDVD_MODE_2328:
                        pbuffer += 24;
                        break;
                case CDVD_MODE_2048:
                        pbuffer += 24;
                        break;
        }

        return 0;
}

EXPORT_C_(u8*) CDVDgetBuffer()
{
        return pbuffer;
}

EXPORT_C_(s32) CDVDgetDiskType()
{
        return cdtype;
}

EXPORT_C_(s32) CDVDgetTrayStatus()
{
        return CDVD_TRAY_CLOSE;
}

EXPORT_C_(s32) CDVDctrlTrayOpen()
{
        return 0;
}
EXPORT_C_(s32) CDVDctrlTrayClose()
{
        return 0;
}


EXPORT_C_(s32) CDVDtest()
{
        if (*IsoFile == 0) return 0;

        iso = isoOpen(IsoFile);
        if (iso == NULL) return -1;
        isoClose(iso);

        return 0;
}

1	william	31	#include <stdio.h>
2			#include <stdlib.h>
3			#include <sys/types.h>
4			#include <sys/stat.h>
5			#include <fcntl.h>
6			#include <time.h>
7			#include <string.h>
8			#include <stdarg.h>
9
10			#include "CDVDiso.h"
11			#include "Config.h"
12
13			#ifndef MAX_PATH
14			#define MAX_PATH 255
15			#endif
16
17			char IsoFile[256];
18			char IsoCWD[256];
19			char CdDev[256];
20
21			_cdIso cdIso[8];
22			u8 *pbuffer;
23			int cdblocksize;
24			int cdblockofs;
25			int cdoffset;
26			int cdtype;
27			int cdblocks;
28
29			int Zmode; // 1 Z - 2 bz2
30			int fmode; // 0 - file / 1 - Zfile
31			char *Ztable;
32
33			int BlockDump;
34			isoFile *fdump;
35			isoFile *iso;
36
37			FILE *cdvdLog = NULL;
38
39			// This var is used to detect resume-style behavior of the Pcsx2 emulator,
40			// and skip prompting the user for a new CD when it's likely they want to run the existing one.
41			static char cdvdCurrentIso[MAX_PATH];
42
43			char *methods[] =
44			{
45			".Z - compress faster",
46			".BZ - compress better",
47			NULL
48			};
49
50			#ifdef PCSX2_DEBUG
51			char *LibName = "Linuz Iso CDVD (Debug) ";
52			#else
53			char *LibName = "Linuz Iso CDVD ";
54			#endif
55
56			const u8 version = PS2E_CDVD_VERSION;
57			const u8 revision = 0;
58			const u8 build = 9;
59
60			u8 cdbuffer[CD_FRAMESIZE_RAW * 10] = {0};
61
62			s32 msf_to_lba(u8 m, u8 s, u8 f)
63			{
64			u32 lsn;
65			lsn = f;
66			lsn += (s - 2) * 75;
67			lsn += m * 75 * 60;
68			return lsn;
69			}
70
71			void lba_to_msf(s32 lba, u8* m, u8* s, u8* f)
72			{
73			lba += 150;
74			m = lba / (60 75);
75			*s = (lba / 75) % 60;
76			*f = lba % 75;
77			}
78
79			#define btoi(b) ((b)/1610 + (b)%16) / BCD to u_char */
80			#define itob(i) ((i)/1016 + (i)%10) / u_char to BCD */
81
82
83			EXPORT_C_(char*) PS2EgetLibName()
84			{
85			return LibName;
86			}
87
88			EXPORT_C_(u32) PS2EgetLibType()
89			{
90			return PS2E_LT_CDVD;
91			}
92
93			EXPORT_C_(u32) PS2EgetLibVersion2(u32 type)
94			{
95			return (version << 16) \| (revision << 8) \| build;
96			}
97
98			#ifdef PCSX2_DEBUG
99			void __Log(char *fmt, ...)
100			{
101			va_list list;
102
103			if (cdvdLog == NULL) return;
104
105			va_start(list, fmt);
106			vfprintf(cdvdLog, fmt, list);
107			va_end(list);
108			}
109			#else
110			#define __Log 0&&
111			#endif
112
113
114			EXPORT_C_(s32) CDVDinit()
115			{
116			#ifdef PCSX2_DEBUG
117			cdvdLog = fopen("logs/cdvdLog.txt", "w");
118			if (cdvdLog == NULL)
119			{
120			cdvdLog = fopen("cdvdLog.txt", "w");
121			if (cdvdLog == NULL)
122			{
123			SysMessage("Can't create cdvdLog.txt");
124			return -1;
125			}
126			}
127			setvbuf(cdvdLog, NULL, _IONBF, 0);
128			CDVD_LOG("CDVDinit\n");
129			#endif
130
131			cdvdCurrentIso[0] = 0;
132			memset(cdIso, 0, sizeof(cdIso));
133			return 0;
134			}
135
136			EXPORT_C_(void) CDVDshutdown()
137			{
138			cdvdCurrentIso[0] = 0;
139			#ifdef CDVD_LOG
140			if (cdvdLog != NULL) fclose(cdvdLog);
141			#endif
142			}
143
144			EXPORT_C_(s32) CDVDopen(const char* pTitle)
145			{
146			LoadConf();
147
148			if (pTitle != NULL) strcpy(IsoFile, pTitle);
149
150			if (*IsoFile == 0) strcpy(IsoFile, cdvdCurrentIso);
151
152			if (*IsoFile == 0)
153			{
154			char temp[256];
155
156			CfgOpenFile();
157
158			LoadConf();
159			strcpy(temp, IsoFile);
160			*IsoFile = 0;
161			SaveConf();
162			strcpy(IsoFile, temp);
163			}
164
165			iso = isoOpen(IsoFile);
166			if (iso == NULL)
167			{
168			SysMessage("Error loading %s\n", IsoFile);
169			return -1;
170			}
171
172			if (iso->type == ISOTYPE_DVD)
173			cdtype = CDVD_TYPE_PS2DVD;
174			else if (iso->type == ISOTYPE_AUDIO)
175			cdtype = CDVD_TYPE_CDDA;
176			else
177			cdtype = CDVD_TYPE_PS2CD;
178
179			if (BlockDump)
180			{
181			char fname_only[MAX_PATH];
182
183			#ifdef _WIN32
184			char fname[MAX_PATH], ext[MAX_PATH];
185			_splitpath(IsoFile, NULL, NULL, fname, ext);
186			_makepath(fname_only, NULL, NULL, fname, NULL);
187			#else
188			char* p, *plast;
189
190			plast = p = strchr(IsoFile, '/');
191			while (p != NULL)
192			{
193			plast = p;
194			p = strchr(p + 1, '/');
195			}
196
197			// Lets not create dumps in the plugin directory.
198			strcpy(fname_only, "../");
199			if (plast != NULL)
200			strcat(fname_only, plast + 1);
201			else
202			strcat(fname_only, IsoFile);
203
204			plast = p = strchr(fname_only, '.');
205
206			while (p != NULL)
207			{
208			plast = p;
209			p = strchr(p + 1, '.');
210			}
211
212			if (plast != NULL) *plast = 0;
213
214			#endif
215			strcat(fname_only, ".dump");
216			fdump = isoCreate(fname_only, ISOFLAGS_BLOCKDUMP);
217			if (fdump) isoSetFormat(fdump, iso->blockofs, iso->blocksize, iso->blocks);
218			}
219			else
220			{
221			fdump = NULL;
222			}
223
224			return 0;
225			}
226
227			EXPORT_C_(void) CDVDclose()
228			{
229
230			strcpy(cdvdCurrentIso, IsoFile);
231
232			isoClose(iso);
233			if (fdump != NULL) isoClose(fdump);
234			}
235
236			EXPORT_C_(s32) CDVDreadSubQ(u32 lsn, cdvdSubQ* subq)
237			{
238			// fake it
239			u8 min, sec, frm;
240			subq->ctrl = 4;
241			subq->mode = 1;
242			subq->trackNum = itob(1);
243			subq->trackIndex = itob(1);
244
245			lba_to_msf(lsn, &min, &sec, &frm);
246			subq->trackM = itob(min);
247			subq->trackS = itob(sec);
248			subq->trackF = itob(frm);
249
250			subq->pad = 0;
251
252			lba_to_msf(lsn + (2*75), &min, &sec, &frm);
253			subq->discM = itob(min);
254			subq->discS = itob(sec);
255			subq->discF = itob(frm);
256			return 0;
257			}
258
259			EXPORT_C_(s32) CDVDgetTN(cdvdTN *Buffer)
260			{
261			Buffer->strack = 1;
262			Buffer->etrack = 1;
263
264			return 0;
265			}
266
267			EXPORT_C_(s32) CDVDgetTD(u8 Track, cdvdTD *Buffer)
268			{
269			if (Track == 0)
270			{
271			Buffer->lsn = iso->blocks;
272			}
273			else
274			{
275			Buffer->type = CDVD_MODE1_TRACK;
276			Buffer->lsn = 0;
277			}
278
279			return 0;
280			}
281
282			static s32 layer1start = -1;
283
284			static bool testForPartitionInfo( const u8 (&tempbuffer)[CD_FRAMESIZE_RAW] )
285			{
286			const int off = iso->blockofs;
287
288			// test for: CD001
289			return (
290			(tempbuffer[off+1] == 0x43) &&
291			(tempbuffer[off+2] == 0x44) &&
292			(tempbuffer[off+3] == 0x30) &&
293			(tempbuffer[off+4] == 0x30) &&
294			(tempbuffer[off+5] == 0x31)
295			);
296			}
297
298			EXPORT_C_(s32) CDVDgetTOC(void* toc)
299			{
300			u8 type = CDVDgetDiskType();
301			u8* tocBuff = (u8*)toc;
302
303			//__Log("CDVDgetTOC\n");
304
305			if (type == CDVD_TYPE_DVDV \|\| type == CDVD_TYPE_PS2DVD)
306			{
307			// get dvd structure format
308			// scsi command 0x43
309			memset(tocBuff, 0, 2048);
310
311			if (layer1start != -2 && iso->blocks >= 0x300000)
312			{
313			int off = iso->blockofs;
314
315			// dual sided
316			tocBuff[ 0] = 0x24;
317			tocBuff[ 1] = 0x02;
318			tocBuff[ 2] = 0xF2;
319			tocBuff[ 3] = 0x00;
320			tocBuff[ 4] = 0x41;
321			tocBuff[ 5] = 0x95;
322
323			tocBuff[14] = 0x60; // dual sided, ptp
324
325			tocBuff[16] = 0x00;
326			tocBuff[17] = 0x03;
327			tocBuff[18] = 0x00;
328			tocBuff[19] = 0x00;
329
330			// search for it
331			if (layer1start == -1)
332			{
333			printf("CDVD: searching for layer1...");
334
335			/tempbuffer = (u8)malloc(CD_FRAMESIZE_RAW * 10);
336			for (layer1start = (iso->blocks / 2 - 0x10) & ~0xf; layer1start < 0x200010; layer1start += 16)
337			{
338			isoReadBlock(iso, tempbuffer, layer1start);
339			// CD001
340			if (tempbuffer[off+1] == 0x43 &&
341			tempbuffer[off+2] == 0x44 &&
342			tempbuffer[off+3] == 0x30 &&
343			tempbuffer[off+4] == 0x30 &&
344			tempbuffer[off+5] == 0x31)
345			break;
346			}
347			free(tempbuffer);*/
348
349			uint midsector = (iso->blocks / 2) & ~0xf;
350			uint deviation = 0;
351
352			while( (layer1start == -1) && (deviation < midsector-16) )
353			{
354			u8 tempbuffer[CD_FRAMESIZE_RAW];
355			isoReadBlock(iso, tempbuffer, midsector-deviation);
356
357			if(testForPartitionInfo( tempbuffer ))
358			layer1start = midsector-deviation;
359			else
360			{
361			isoReadBlock(iso, tempbuffer, midsector+deviation);
362			if( testForPartitionInfo( tempbuffer ) )
363			layer1start = midsector+deviation;
364			}
365
366			if( layer1start != -1 )
367			{
368			if( tempbuffer[iso->blockofs] != 0x01 )
369			{
370			fprintf( stderr, "(LinuzCDVDiso): Invalid partition type on layer 1!? (type=0x%x)", tempbuffer[iso->blockofs] );
371			}
372			}
373			deviation += 16;
374			}
375
376
377			if (layer1start == -1)
378			{
379			printf("(LinuzCDVDiso): Couldn't find second layer on dual layer... ignoring\n");
380			// fake it
381			tocBuff[ 0] = 0x04;
382			tocBuff[ 1] = 0x02;
383			tocBuff[ 2] = 0xF2;
384			tocBuff[ 3] = 0x00;
385			tocBuff[ 4] = 0x86;
386			tocBuff[ 5] = 0x72;
387
388			tocBuff[16] = 0x00;
389			tocBuff[17] = 0x03;
390			tocBuff[18] = 0x00;
391			tocBuff[19] = 0x00;
392			layer1start = -2;
393			return 0;
394			}
395
396			printf("(LinuzCDVDiso): found at 0x%8.8x\n", layer1start);
397			layer1start = layer1start + 0x30000 - 1;
398			}
399
400			tocBuff[20] = layer1start >> 24;
401			tocBuff[21] = (layer1start >> 16) & 0xff;
402			tocBuff[22] = (layer1start >> 8) & 0xff;
403			tocBuff[23] = (layer1start >> 0) & 0xff;
404			}
405			else
406			{
407			// fake it
408			tocBuff[ 0] = 0x04;
409			tocBuff[ 1] = 0x02;
410			tocBuff[ 2] = 0xF2;
411			tocBuff[ 3] = 0x00;
412			tocBuff[ 4] = 0x86;
413			tocBuff[ 5] = 0x72;
414
415			tocBuff[16] = 0x00;
416			tocBuff[17] = 0x03;
417			tocBuff[18] = 0x00;
418			tocBuff[19] = 0x00;
419			}
420			}
421			else if ((type == CDVD_TYPE_CDDA) \|\| (type == CDVD_TYPE_PS2CDDA) \|\|
422			(type == CDVD_TYPE_PS2CD) \|\| (type == CDVD_TYPE_PSCDDA) \|\| (type == CDVD_TYPE_PSCD))
423			{
424			// cd toc
425			// (could be replaced by 1 command that reads the full toc)
426			u8 min, sec, frm;
427			s32 i, err;
428			cdvdTN diskInfo;
429			cdvdTD trackInfo;
430			memset(tocBuff, 0, 1024);
431			if (CDVDgetTN(&diskInfo) == -1)
432			{
433			diskInfo.etrack = 0;
434			diskInfo.strack = 1;
435			}
436			if (CDVDgetTD(0, &trackInfo) == -1) trackInfo.lsn = 0;
437
438			tocBuff[0] = 0x41;
439			tocBuff[1] = 0x00;
440
441			//Number of FirstTrack
442			tocBuff[2] = 0xA0;
443			tocBuff[7] = itob(diskInfo.strack);
444
445			//Number of LastTrack
446			tocBuff[12] = 0xA1;
447			tocBuff[17] = itob(diskInfo.etrack);
448
449			//DiskLength
450			lba_to_msf(trackInfo.lsn, &min, &sec, &frm);
451			tocBuff[22] = 0xA2;
452			tocBuff[27] = itob(min);
453			tocBuff[28] = itob(sec);
454
455			for (i = diskInfo.strack; i <= diskInfo.etrack; i++)
456			{
457			err = CDVDgetTD(i, &trackInfo);
458			lba_to_msf(trackInfo.lsn, &min, &sec, &frm);
459			tocBuff[i*10+30] = trackInfo.type;
460			tocBuff[i*10+32] = err == -1 ? 0 : itob(i); //number
461			tocBuff[i*10+37] = itob(min);
462			tocBuff[i*10+38] = itob(sec);
463			tocBuff[i*10+39] = itob(frm);
464			}
465			}
466			else
467			return -1;
468
469			return 0;
470			}
471
472			EXPORT_C_(s32) CDVDreadTrack(u32 lsn, int mode)
473			{
474			int _lsn = lsn;
475
476			//__Log("CDVDreadTrack: %x %x\n", lsn, mode);
477			if (_lsn < 0)
478			{
479			// lsn = 2097152 + (-_lsn);
480			lsn = iso->blocks - (-_lsn);
481			}
482			// printf ("CDRreadTrack %d\n", lsn);
483
484			isoReadBlock(iso, cdbuffer, lsn);
485			if (fdump != NULL)
486			{
487			isoWriteBlock(fdump, cdbuffer, lsn);
488			}
489
490			pbuffer = cdbuffer;
491			switch (mode)
492			{
493			case CDVD_MODE_2352:
494			break;
495			case CDVD_MODE_2340:
496			pbuffer += 12;
497			break;
498			case CDVD_MODE_2328:
499			pbuffer += 24;
500			break;
501			case CDVD_MODE_2048:
502			pbuffer += 24;
503			break;
504			}
505
506			return 0;
507			}
508
509			EXPORT_C_(u8*) CDVDgetBuffer()
510			{
511			return pbuffer;
512			}
513
514			EXPORT_C_(s32) CDVDgetDiskType()
515			{
516			return cdtype;
517			}
518
519			EXPORT_C_(s32) CDVDgetTrayStatus()
520			{
521			return CDVD_TRAY_CLOSE;
522			}
523
524			EXPORT_C_(s32) CDVDctrlTrayOpen()
525			{
526			return 0;
527			}
528			EXPORT_C_(s32) CDVDctrlTrayClose()
529			{
530			return 0;
531			}
532
533
534			EXPORT_C_(s32) CDVDtest()
535			{
536			if (*IsoFile == 0) return 0;
537
538			iso = isoOpen(IsoFile);
539			if (iso == NULL) return -1;
540			isoClose(iso);
541
542			return 0;
543			}
544