pcsx2/plugins/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();

		if (IsoFile[0] == 0)
		{
			// user pressed CANCEL
			return 1;
		}
		
		strcpy(temp, IsoFile);
		*IsoFile = 0;
		SaveConf();
		strcpy(IsoFile, temp);
	}

	iso = isoOpen(IsoFile);
	if (iso == NULL)
	{
		SysMessage("Error loading %s\nMake sure the iso file is not mounted in any disk emulation software!", 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()
{
	if (!iso) return;

	strcpy(cdvdCurrentIso, IsoFile);

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

EXPORT_C_(s32) CDVDreadSubQ(u32 lsn, cdvdSubQ* subq)
{
	if (!iso) return -1;

	// 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 (!iso) return -1;

	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)
{
	if (!iso) return -1;
	
	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)
{
	if (!iso) return -1;

	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;
}