diff --git a/plugins/GSdx/GSdx_vs2008.vcproj b/plugins/GSdx/GSdx_vs2008.vcproj index b7a6f0f670..d3cbfdd97d 100644 --- a/plugins/GSdx/GSdx_vs2008.vcproj +++ b/plugins/GSdx/GSdx_vs2008.vcproj @@ -1,11 +1,12 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - @@ -1579,6 +1796,14 @@ UsePrecompiledHeader="1" /> + + + @@ -1587,6 +1812,14 @@ UsePrecompiledHeader="1" /> + + + @@ -1595,6 +1828,14 @@ UsePrecompiledHeader="1" /> + + + @@ -1603,6 +1844,14 @@ UsePrecompiledHeader="1" /> + + + @@ -1611,6 +1860,14 @@ UsePrecompiledHeader="1" /> + + + @@ -2031,46 +2288,6 @@ UsePrecompiledHeader="0" /> - - - - - - - - - - - - - - - @@ -2079,6 +2296,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2087,6 +2312,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2095,6 +2328,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2103,6 +2344,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2111,6 +2360,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2151,46 +2408,6 @@ UsePrecompiledHeader="0" /> - - - - - - - - - - - - - - - @@ -2199,6 +2416,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2207,6 +2432,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2215,6 +2448,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2223,6 +2464,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2231,6 +2480,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2271,46 +2528,6 @@ UsePrecompiledHeader="0" /> - - - - - - - - - - - - - - - @@ -2319,6 +2536,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2327,6 +2552,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2335,6 +2568,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2343,6 +2584,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2351,6 +2600,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2391,46 +2648,6 @@ UsePrecompiledHeader="0" /> - - - - - - - - - - - - - - - @@ -2439,6 +2656,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2447,6 +2672,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2455,6 +2688,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2463,6 +2704,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2471,6 +2720,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2511,46 +2768,6 @@ UsePrecompiledHeader="0" /> - - - - - - - - - - - - - - - @@ -2559,6 +2776,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2567,6 +2792,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2575,6 +2808,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2583,6 +2824,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2591,6 +2840,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2631,46 +2888,6 @@ UsePrecompiledHeader="0" /> - - - - - - - - - - - - - - - @@ -2679,6 +2896,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2687,6 +2912,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2695,6 +2928,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2703,6 +2944,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2711,6 +2960,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2767,46 +3024,6 @@ UsePrecompiledHeader="0" /> - - - - - - - - - - - - - - - @@ -2815,6 +3032,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2823,6 +3048,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2831,6 +3064,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2839,6 +3080,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2847,6 +3096,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2887,46 +3144,6 @@ UsePrecompiledHeader="0" /> - - - - - - - - - - - - - - - @@ -2935,6 +3152,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2943,6 +3168,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2951,6 +3184,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2959,6 +3200,14 @@ UsePrecompiledHeader="0" /> + + + @@ -2967,6 +3216,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3007,46 +3264,6 @@ UsePrecompiledHeader="0" /> - - - - - - - - - - - - - - - @@ -3055,6 +3272,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3063,6 +3288,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3071,6 +3304,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3079,6 +3320,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3087,6 +3336,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3127,46 +3384,6 @@ UsePrecompiledHeader="0" /> - - - - - - - - - - - - - - - @@ -3175,6 +3392,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3183,6 +3408,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3191,6 +3424,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3199,6 +3440,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3207,6 +3456,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3247,46 +3504,6 @@ UsePrecompiledHeader="0" /> - - - - - - - - - - - - - - - @@ -3295,6 +3512,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3303,6 +3528,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3311,6 +3544,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3319,6 +3560,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3327,6 +3576,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3371,46 +3628,6 @@ UsePrecompiledHeader="0" /> - - - - - - - - - - - - - - - @@ -3419,6 +3636,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3427,6 +3652,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3435,6 +3668,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3443,6 +3684,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3451,6 +3700,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3491,46 +3748,6 @@ UsePrecompiledHeader="0" /> - - - - - - - - - - - - - - - @@ -3539,6 +3756,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3547,6 +3772,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3555,6 +3788,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3563,6 +3804,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3571,6 +3820,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3611,46 +3868,6 @@ UsePrecompiledHeader="0" /> - - - - - - - - - - - - - - - @@ -3659,6 +3876,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3667,6 +3892,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3675,6 +3908,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3683,6 +3924,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3691,6 +3940,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3731,46 +3988,6 @@ UsePrecompiledHeader="0" /> - - - - - - - - - - - - - - - @@ -3779,6 +3996,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3787,6 +4012,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3795,6 +4028,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3803,6 +4044,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3811,6 +4060,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3855,46 +4112,6 @@ UsePrecompiledHeader="0" /> - - - - - - - - - - - - - - - @@ -3903,6 +4120,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3911,6 +4136,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3919,6 +4152,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3927,6 +4168,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3935,6 +4184,14 @@ UsePrecompiledHeader="0" /> + + + @@ -3975,46 +4232,6 @@ UsePrecompiledHeader="0" /> - - - - - - - - - - - - - - - @@ -4023,6 +4240,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4031,6 +4256,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4039,6 +4272,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4047,6 +4288,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4055,6 +4304,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4095,46 +4352,6 @@ UsePrecompiledHeader="0" /> - - - - - - - - - - - - - - - @@ -4143,6 +4360,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4151,6 +4376,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4159,6 +4392,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4167,6 +4408,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4175,6 +4424,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4215,46 +4472,6 @@ UsePrecompiledHeader="0" /> - - - - - - - - - - - - - - - @@ -4263,6 +4480,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4271,6 +4496,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4279,6 +4512,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4287,6 +4528,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4295,6 +4544,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4335,46 +4592,6 @@ UsePrecompiledHeader="0" /> - - - - - - - - - - - - - - - @@ -4383,6 +4600,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4391,6 +4616,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4399,6 +4632,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4407,6 +4648,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4415,6 +4664,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4455,46 +4712,6 @@ UsePrecompiledHeader="0" /> - - - - - - - - - - - - - - - @@ -4503,6 +4720,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4511,6 +4736,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4519,6 +4752,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4527,6 +4768,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4535,6 +4784,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4575,46 +4832,6 @@ UsePrecompiledHeader="0" /> - - - - - - - - - - - - - - - @@ -4623,6 +4840,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4631,6 +4856,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4639,6 +4872,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4647,6 +4888,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4655,6 +4904,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4695,46 +4952,6 @@ UsePrecompiledHeader="0" /> - - - - - - - - - - - - - - - @@ -4743,6 +4960,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4751,6 +4976,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4759,6 +4992,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4767,6 +5008,14 @@ UsePrecompiledHeader="0" /> + + + @@ -4775,6 +5024,14 @@ UsePrecompiledHeader="0" /> + + + diff --git a/plugins/cdvdGigaherz/CDVD.cpp b/plugins/cdvdGigaherz/CDVD.cpp new file mode 100644 index 0000000000..85036beeea --- /dev/null +++ b/plugins/cdvdGigaherz/CDVD.cpp @@ -0,0 +1,517 @@ +#define _CRT_SECURE_NO_WARNINGS + +#include + +#include "CDVD.h" +#include "resource.h" +#include "Shlwapi.h" + +#include + +void (*newDiscCB)(); + +#define STRFY(x) #x +#define TOSTR(x) STRFY(x) + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// +// State Information // + +int strack; +int etrack; +track tracks[100]; + +int curDiskType; +int curTrayStatus; + +int csector; +int cmode; + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// +// Plugin Interface // + +char *LibName = "Gigaherz's CDVD Plugin"; + +const unsigned char version = PS2E_CDVD_VERSION; +const unsigned char revision = 0; +const unsigned char build = 8; + +HINSTANCE hinst; + +BOOL WINAPI DllMain( + HINSTANCE hinstDLL, // handle to DLL module + DWORD fdwReason, // reason for calling function + LPVOID lpvReserved // reserved +) +{ + if(fdwReason==DLL_PROCESS_ATTACH) { + hinst=hinstDLL; + } + return TRUE; +} + +char* CALLBACK PS2EgetLibName() { + return LibName; +} + +u32 CALLBACK PS2EgetLibType() { + return PS2E_LT_CDVD; +} + +u32 CALLBACK PS2EgetLibVersion2(u32 type) { + return (version << 16) | (revision << 8) | build; +} + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// +// Utility Functions // + +void SysMessage(char *fmt, ...) { + va_list list; + char tmp[512]; + + va_start(list,fmt); + vsprintf(tmp,fmt,list); + va_end(list); + MessageBox(0, tmp, "cdvdGigaherz Msg", 0); +} + +u8 __inline dec_to_bcd(u8 dec) +{ + return ((dec/10)<<4)|(dec%10); +} + +void __inline lsn_to_msf(u8* minute, u8* second, u8* frame, u32 lsn) +{ + *frame = dec_to_bcd(lsn%75); + lsn/=75; + *second= dec_to_bcd(lsn%60); + lsn/=60; + *minute= dec_to_bcd(lsn%100); +} + +void __inline lba_to_msf(s32 lba, u8* m, u8* s, u8* f) { + lba += 150; + *m = (u8)(lba / (60*75)); + *s = (u8)((lba / 75) % 60); + *f = (u8)(lba % 75); +} + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// +// CDVD processing functions // + +char csrc[20]; + +BOOL cdvd_is_open=FALSE; + +Source *src; + +s32 disc_has_changed=0; + +int weAreInNewDiskCB=0; + +char bfr[2352]; + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// +// CDVD Pluin Interface // + +s32 CALLBACK CDVDinit() +{ + return 0; +} + +s32 CALLBACK CDVDopen(const char* pTitleFilename) +{ + ReadSettings(); + + if(source_drive=='-') + { + char temp[3]="A:"; + + for(char d='A';d<='Z';d++) + { + temp[0]=d; + if(GetDriveType(temp)==DRIVE_CDROM) + { + source_drive=d; + break; + } + } + } + + if(source_drive=='@') + { + curDiskType=CDVD_TYPE_NODISC; + return 0; + } + + if(source_drive='$') + { + printf(" * CDVD: Opening image '%s'...\n",source_file); + + //open device file + src=new FileSrc(source_file); + } + else + { + sprintf(csrc,"\\\\.\\%c:",source_drive); + + printf(" * CDVD: Opening drive '%s'...\n",csrc); + + //open device file + src=new IOCtlSrc(csrc); + } + + if(!src->IsOK()) + { + printf(" * CDVD: Error opening source.\n"); + return -1; + } + + //setup threading manager + cdvdStartThread(); + + return cdvdRefreshData(); +} + +void CALLBACK CDVDclose() +{ + cdvdStopThread(); + + //close device + delete src; + src=NULL; +} + +void CALLBACK CDVDshutdown() +{ + //nothing to do here +} + +s32 CALLBACK CDVDgetDualInfo(s32* dualType, u32* _layer1start) +{ + switch(src->GetMediaType()) + { + case 1: + *dualType = 1; + *_layer1start = src->GetLayerBreakAddress(); + return 1; + case 2: + *dualType = 2; + *_layer1start = src->GetLayerBreakAddress(); + return 1; + case 0: + *dualType = 0; + *_layer1start = 0; + return 1; + } + return 0; +} + +int lastReadInNewDiskCB=0; +char fuckThisSector[2352]; + +s32 CALLBACK CDVDreadSector(u8* buffer, s32 lsn, int mode) +{ + return cdvdDirectReadSector(lsn,mode,(char*)buffer); +} + +s32 CALLBACK CDVDreadTrack(u32 lsn, int mode) +{ + csector=lsn; + cmode=mode; + + if(weAreInNewDiskCB) + { + int ret = cdvdDirectReadSector(lsn,mode,fuckThisSector); + if(ret==0) lastReadInNewDiskCB=1; + return ret; + } + + if(lsn>tracks[0].length) // track 0 is total disc. + { + return -1; + } + + return cdvdRequestSector(lsn,mode); +} + +// return can be NULL (for async modes) +u8* CALLBACK CDVDgetBuffer() +{ + if(lastReadInNewDiskCB) + { + lastReadInNewDiskCB=0; + return (u8*)fuckThisSector; + } + + u8 *s = (u8*)cdvdGetSector(csector,cmode); + + return s; +} + +// return can be NULL (for async modes) +int CALLBACK CDVDgetBuffer2(u8* dest) +{ + int csize = 2352; + switch(cmode) + { + case CDVD_MODE_2048: csize = 2048; break; + case CDVD_MODE_2328: csize = 2328; break; + case CDVD_MODE_2340: csize = 2340; break; + } + + if(lastReadInNewDiskCB) + { + lastReadInNewDiskCB=0; + + memcpy(dest, fuckThisSector, csize); + return 0; + } + + memcpy(dest, cdvdGetSector(csector,cmode), csize); + + return 0; +} + +s32 CALLBACK CDVDreadSubQ(u32 lsn, cdvdSubQ* subq) +{ + int i; + // the formatted subq command returns: control/adr, track, index, trk min, trk sec, trk frm, 0x00, abs min, abs sec, abs frm + + if(lsn>tracks[0].length) // track 0 is total disc. + return -1; + + memset(subq,0,sizeof(cdvdSubQ)); + + lsn_to_msf(&subq->discM,&subq->discS,&subq->discF,lsn+150); + + i=strack; + while(i<=etrack) + { + if(lsn<=tracks[i].length) + break; + lsn-=tracks[i].length; + i++; + } + + if(i>etrack) + i=etrack; + + lsn_to_msf(&subq->trackM,&subq->trackS,&subq->trackF,lsn); + + subq->mode=1; + subq->ctrl=tracks[i].type; + subq->trackNum=i; + subq->trackIndex=1; + + return 0; +} + +s32 CALLBACK CDVDgetTN(cdvdTN *Buffer) +{ + Buffer->strack=strack; + Buffer->etrack=etrack; + return 0; +} + +s32 CALLBACK CDVDgetTD(u8 Track, cdvdTD *Buffer) +{ + if(Track==0) + { + Buffer->lsn = tracks[0].length; + Buffer->type= 0; + return 0; + } + + if(Tracketrack) return -1; + + Buffer->lsn = tracks[Track].start_lba; + Buffer->type= tracks[Track].type; + return 0; +} + +u32 layer1start=-1; + +s32 CALLBACK CDVDgetTOC(u8* tocBuff) +{ + //return src->ReadTOC((char*)toc,2048); + //that didn't work too well... + + if(curDiskType==CDVD_TYPE_NODISC) + return -1; + + if((curDiskType == CDVD_TYPE_DVDV) || + (curDiskType == CDVD_TYPE_PS2DVD)) + { + memset(tocBuff, 0, 2048); + + s32 mt=src->GetMediaType(); + + if(mt<0) + return -1; + + if(mt==0) //single layer + { + // fake it + tocBuff[ 0] = 0x04; + tocBuff[ 1] = 0x02; + tocBuff[ 2] = 0xF2; + tocBuff[ 3] = 0x00; + tocBuff[ 4] = 0x86; + tocBuff[ 5] = 0x72; + + tocBuff[16] = 0x00; // first sector for layer 0 + tocBuff[17] = 0x03; + tocBuff[18] = 0x00; + tocBuff[19] = 0x00; + } + else if(mt==1) //PTP + { + layer1start = src->GetLayerBreakAddress() + 0x30000; + + // dual sided + tocBuff[ 0] = 0x24; + tocBuff[ 1] = 0x02; + tocBuff[ 2] = 0xF2; + tocBuff[ 3] = 0x00; + tocBuff[ 4] = 0x41; + tocBuff[ 5] = 0x95; + + tocBuff[14] = 0x61; // PTP + + tocBuff[16] = 0x00; + tocBuff[17] = 0x03; + tocBuff[18] = 0x00; + tocBuff[19] = 0x00; + + tocBuff[20] = (layer1start>>24); + tocBuff[21] = (layer1start>>16)&0xff; + tocBuff[22] = (layer1start>> 8)&0xff; + tocBuff[23] = (layer1start>> 0)&0xff; + } + else //OTP + { + layer1start = src->GetLayerBreakAddress() + 0x30000; + + // dual sided + tocBuff[ 0] = 0x24; + tocBuff[ 1] = 0x02; + tocBuff[ 2] = 0xF2; + tocBuff[ 3] = 0x00; + tocBuff[ 4] = 0x41; + tocBuff[ 5] = 0x95; + + tocBuff[14] = 0x71; // OTP + + tocBuff[16] = 0x00; + tocBuff[17] = 0x03; + tocBuff[18] = 0x00; + tocBuff[19] = 0x00; + + tocBuff[24] = (layer1start>>24); + tocBuff[25] = (layer1start>>16)&0xff; + tocBuff[26] = (layer1start>> 8)&0xff; + tocBuff[27] = (layer1start>> 0)&0xff; + } + } + else if(curDiskType == CDVD_TYPE_CDDA || + curDiskType == CDVD_TYPE_PS2CDDA || + curDiskType == CDVD_TYPE_PS2CD || + curDiskType == CDVD_TYPE_PSCDDA || + curDiskType == CDVD_TYPE_PSCD) + { + // cd toc + // (could be replaced by 1 command that reads the full toc) + u8 min, sec, frm,i; + s32 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; + +#define itob(n) ((((n)/10)<<4)+((n)%10)) + + //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); + tocBuff[29] = itob(frm); + + fprintf(stderr,"Track 0: %d mins %d secs %d frames\n",min,sec,frm); + + 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); + fprintf(stderr,"Track %d: %d mins %d secs %d frames\n",i,min,sec,frm); + } + } + else + return -1; + + return 0; +} + +s32 CALLBACK CDVDgetDiskType() +{ + return curDiskType; +} + +s32 CALLBACK CDVDgetTrayStatus() +{ + return curTrayStatus; +} + +s32 CALLBACK CDVDctrlTrayOpen() +{ + curTrayStatus=CDVD_TRAY_OPEN; + return 0; +} + +s32 CALLBACK CDVDctrlTrayClose() +{ + curTrayStatus=CDVD_TRAY_CLOSE; + return 0; +} + +void CALLBACK CDVDnewDiskCB(void (*callback)()) +{ + newDiscCB=callback; +} + +void configure(); +void CALLBACK CDVDconfigure() +{ + configure(); +} + +void CALLBACK CDVDabout() { + SysMessage("%s %d.%d", LibName, revision, build); +} + +s32 CALLBACK CDVDtest() { + return 0; +} diff --git a/plugins/cdvdGigaherz/CDVD.h b/plugins/cdvdGigaherz/CDVD.h new file mode 100644 index 0000000000..2a78dc93bd --- /dev/null +++ b/plugins/cdvdGigaherz/CDVD.h @@ -0,0 +1,206 @@ +#ifndef __CDVD_H__ +#define __CDVD_H__ + +#include +#include + +#define CDVDdefs +#include + +typedef struct _track +{ + u32 start_lba; + u32 length; + u32 type; +} track; + +extern int strack; +extern int etrack; +extern track tracks[100]; + +extern int curDiskType; +extern int curTrayStatus; + +typedef struct _toc_entry { + UCHAR SessionNumber; + UCHAR Control : 4; + UCHAR Adr : 4; + UCHAR Reserved1; + UCHAR Point; + UCHAR MsfExtra[3]; + UCHAR Zero; + UCHAR Msf[3]; +} toc_entry; + +typedef struct _toc_data +{ + UCHAR Length[2]; + UCHAR FirstCompleteSession; + UCHAR LastCompleteSession; + + toc_entry Descriptors[255]; +} toc_data; + +extern toc_data cdtoc; + + +class Source //abstract class as base for source modules +{ +public: + //virtual destructor + virtual ~Source() + { + } + + //virtual members + virtual s32 GetSectorCount()=0; + virtual s32 ReadTOC(char *toc,int size)=0; + virtual s32 ReadSectors2048(u32 sector, u32 count, char *buffer)=0; + virtual s32 ReadSectors2352(u32 sector, u32 count, char *buffer)=0; + virtual s32 GetLayerBreakAddress()=0; + + virtual s32 GetMediaType()=0; + + virtual s32 IsOK()=0; + virtual s32 Reopen()=0; + + virtual s32 DiscChanged()=0; +}; + +class IOCtlSrc: public Source +{ +private: + HANDLE device; + + bool OpenOK; + + s32 last_read_mode; + + s32 last_sector_count; + + char sectorbuffer[32*2048]; + + char fName[256]; + + DWORD sessID; + + bool tocCached; + char tocCacheData[2048]; + + bool mediaTypeCached; + int mediaType; + + bool discSizeCached; + s32 discSize; + + bool layerBreakCached; + s32 layerBreak; + +public: + IOCtlSrc(const char* fileName); + + //virtual destructor + virtual ~IOCtlSrc(); + + //virtual members + virtual s32 GetSectorCount(); + virtual s32 ReadTOC(char *toc,int size); + virtual s32 ReadSectors2048(u32 sector, u32 count, char *buffer); + virtual s32 ReadSectors2352(u32 sector, u32 count, char *buffer); + virtual s32 GetLayerBreakAddress(); + + virtual s32 GetMediaType(); + + virtual s32 IsOK(); + virtual s32 Reopen(); + + virtual s32 DiscChanged(); +}; + +class FileSrc: public Source +{ +private: + HANDLE fileSource; + + bool OpenOK; + + s32 sector_count; + + char sectorbuffer[32*2048]; + + char fName[256]; + + DWORD sessID; + + bool tocCached; + char tocCacheData[2048]; + + bool mediaTypeCached; + int mediaType; + + bool discSizeCached; + s32 discSize; + + bool layerBreakCached; + s32 layerBreak; + +public: + FileSrc(const char* fileName); + + //virtual destructor + virtual ~FileSrc(); + + //virtual members + virtual s32 GetSectorCount(); + virtual s32 ReadTOC(char *toc,int size); + virtual s32 ReadSectors2048(u32 sector, u32 count, char *buffer); + virtual s32 ReadSectors2352(u32 sector, u32 count, char *buffer); + virtual s32 GetLayerBreakAddress(); + + virtual s32 GetMediaType(); + + virtual s32 IsOK(); + virtual s32 Reopen(); + + virtual s32 DiscChanged(); +}; + +extern Source *src; + +int FindDiskType(); + +void configure(); + +extern char source_drive; +extern char source_file[]; + +extern HINSTANCE hinst; + +#define MSF_TO_LBA(m,s,f) ((m*60+s)*75+f-150) + +s32 cdvdDirectReadSector(s32 first, s32 mode, char *buffer); + +s32 cdvdGetMediaType(); + +void ReadSettings(); +void WriteSettings(); + +extern char csrc[]; +extern BOOL cdvd_is_open; +extern int weAreInNewDiskCB; + +extern void (*newDiscCB)(); + +extern s32 disc_has_changed; + +s32 cdvdStartThread(); +void cdvdStopThread(); +s32 cdvdRequestSector(u32 sector, s32 mode); +s32 cdvdRequestComplete(); +char* cdvdGetSector(s32 sector, s32 mode); +s32 cdvdDirectReadSector(s32 first, s32 mode, char *buffer); +s32 cdvdGetMediaType(); +s32 cdvdRefreshData(); +s32 cdvdParseTOC(); + +#endif /* __CDVD_H__ */ diff --git a/plugins/cdvdGigaherz/CheckDiskType.cpp b/plugins/cdvdGigaherz/CheckDiskType.cpp new file mode 100644 index 0000000000..9aecb51c24 --- /dev/null +++ b/plugins/cdvdGigaherz/CheckDiskType.cpp @@ -0,0 +1,119 @@ + +#include + +#include "CDVD.h" +#include "isofs/CDVDlib.h" +#include "isofs/CDVDiso.h" +#include "isofs/CDVDisodrv.h" + +char buffer[2048]; //if the file is longer...it should be shorter :D + +int CheckDiskType(int baseType) +{ + int f; + char *pos; + static struct TocEntry tocEntry; + + CDVDFS_init(); + + // check if the file exists + if (CDVD_findfile("SYSTEM.CNF;1", &tocEntry) == TRUE) + { + f=CDVDFS_open("SYSTEM.CNF;1", 1); + CDVDFS_read(f, buffer, 2047); + CDVDFS_close(f); + + buffer[tocEntry.fileSize]='\0'; + + pos=strstr(buffer, "BOOT2"); + if (pos==NULL){ + pos=strstr(buffer, "BOOT"); + if (pos==NULL) { + return CDVD_TYPE_ILLEGAL; + } + return CDVD_TYPE_PSCD; + } + return (baseType==CDVD_TYPE_DETCTCD)?CDVD_TYPE_PS2CD:CDVD_TYPE_PS2DVD; + } + + if (CDVD_findfile("PSX.EXE;1", &tocEntry) == TRUE) + { + return CDVD_TYPE_PSCD; + } + + if (CDVD_findfile("VIDEO_TS/VIDEO_TS.IFO;1", &tocEntry) == TRUE) + { + return CDVD_TYPE_DVDV; + } + + return CDVD_TYPE_ILLEGAL; +} + +char bleh[2352]; + +int FindDiskType() +{ + int dataTracks=0; + int audioTracks=0; + + int iCDType = CDVD_TYPE_DETCTDVDS; + + s32 mt=cdvdGetMediaType(); + + if(mt<0) + { + if(tracks[0].length>452849) + { + iCDType = CDVD_TYPE_DETCTDVDS; + } + else if(cdvdDirectReadSector(16,CDVD_MODE_2048,bleh)==0) + { + struct cdVolDesc* volDesc=(struct cdVolDesc *)bleh; + if(volDesc) + { + if(volDesc->rootToc.tocSize==2048) iCDType = CDVD_TYPE_DETCTCD; + else iCDType = CDVD_TYPE_DETCTDVDS; + } + } + } + + fprintf(stderr," * CDVD Disk Open: %d tracks (%d to %d):\n",etrack-strack+1,strack,etrack); + + audioTracks=dataTracks=0; + for(int i=strack;i<=etrack;i++) + { + if(tracks[i].type==CDVD_AUDIO_TRACK) + { + audioTracks++; + fprintf(stderr," * * Track %d: Audio (%d sectors)\n",i,tracks[i].length); + } + else + { + dataTracks++; + fprintf(stderr," * * Track %d: Data (Mode %d) (%d sectors)\n",i,((tracks[i].type==CDVD_MODE1_TRACK)?1:2),tracks[i].length); + } + } + + if(dataTracks>0) + { + iCDType=CheckDiskType(iCDType); + } + + if(audioTracks>0) + { + if(iCDType==CDVD_TYPE_PS2CD) + { + iCDType=CDVD_TYPE_PS2CDDA; + } + else if(iCDType==CDVD_TYPE_PSCD) + { + iCDType=CDVD_TYPE_PSCDDA; + } + else + { + iCDType=CDVD_TYPE_CDDA; + } + } + + return iCDType; +} \ No newline at end of file diff --git a/plugins/cdvdGigaherz/FileSrc.cpp b/plugins/cdvdGigaherz/FileSrc.cpp new file mode 100644 index 0000000000..a471cd6320 --- /dev/null +++ b/plugins/cdvdGigaherz/FileSrc.cpp @@ -0,0 +1,243 @@ +#undef _WIN32_WINNT +#define _WIN32_WINNT 0x0600 +#include "CDVD.h" +#pragma warning(disable:4200) +#pragma pack(1) +#include +#include "rosddk/ntddcdvd.h" +#include "rosddk/ntddcdrm.h" +#include "rosddk/ntddscsi.h" +#pragma warning(default:4200) +#include + +#include "SectorConverters.h" +template +bool ApiErrorCheck(T t,T okValue,bool cmpEq) +{ + bool cond=(t==okValue); + + if(!cmpEq) cond=!cond; + + if(!cond) + { + static char buff[1024]; + DWORD ec = GetLastError(); + FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,NULL,ec,0,buff,1023,NULL); + MessageBoxEx(0,buff,"ERROR?!",MB_OK,0); + } + return cond; +} + +#define RETURN(v) {OpenOK=v; return;} + +s32 FileSrc::Reopen() +{ + if(fileSource!=INVALID_HANDLE_VALUE) + { + CloseHandle(fileSource); + } + + DWORD share = FILE_SHARE_READ; + DWORD flags = FILE_ATTRIBUTE_READONLY | FILE_FLAG_SEQUENTIAL_SCAN; + + OpenOK = false; + + fileSource = CreateFile(fName, GENERIC_READ|FILE_READ_ATTRIBUTES, share, NULL, OPEN_EXISTING, flags, 0); + + tocCached = false; + mediaTypeCached = false; + discSizeCached = false; + layerBreakCached = false; + + OpenOK=true; + return 0; +} + +FileSrc::FileSrc(const char* fileName) +{ + fileSource=INVALID_HANDLE_VALUE; + + strcpy_s(fName,256,fileName); + + Reopen(); +} + +FileSrc::~FileSrc() +{ + if(OpenOK) + { + CloseHandle(fileSource); + } +} + +s32 FileSrc::GetSectorCount() +{ + LARGE_INTEGER li; + int plain_sectors = 0; + + if(discSizeCached) + return discSize; + + if(GetFileSizeEx(fileSource,&li)) + { + discSizeCached = true; + discSize = (s32)(li.QuadPart / 2048); + return discSize; + } + + return -1; +} + +s32 FileSrc::GetLayerBreakAddress() +{ + return 0; +} + +s32 FileSrc::GetMediaType() +{ + if(mediaTypeCached) + return mediaType; + + // assume single layer DVD, for now + mediaTypeCached = true; + mediaType = 0; + return mediaType; +} + +#define MKDESCRIPTOR(n,ses,ctr,adr,pt,me,se,fe,tm,ts,tf) \ + ftd->Descriptors[n].SessionNumber = ses; \ + ftd->Descriptors[n].Control = ctr; \ + ftd->Descriptors[n].Adr = adr; \ + ftd->Descriptors[n].Reserved1 = 0; \ + ftd->Descriptors[n].Point = pt; \ + ftd->Descriptors[n].MsfExtra[0] = me; \ + ftd->Descriptors[n].MsfExtra[1] = se; \ + ftd->Descriptors[n].MsfExtra[2] = fe; \ + ftd->Descriptors[n].Zero = 0; \ + ftd->Descriptors[n].Msf[0] = tm; \ + ftd->Descriptors[n].Msf[1] = ts; \ + ftd->Descriptors[n].Msf[2] = tf; + +#define MSF_TO_LBA(m,s,f) ((m*60+s)*75+f-150) +#define LBA_TO_MSF(m,s,f,l) \ + m = (l)/(75*60); \ + s = (((l)/75)%60); \ + f = ((l)%75); + + +s32 FileSrc::ReadTOC(char *toc,int msize) +{ + DWORD size=0; + + if(GetMediaType()>=0) + return -1; + + if(!tocCached) + { + CDROM_TOC_FULL_TOC_DATA *ftd=(CDROM_TOC_FULL_TOC_DATA*)tocCacheData; + + // Build basic TOC + int length = 6 * sizeof(ftd->Descriptors[0]) + 2; + ftd->Length[0] = length>>8; + ftd->Length[1] = length; + ftd->FirstCompleteSession=1; + ftd->LastCompleteSession=2; + + int dm,ds,df; + + LBA_TO_MSF(dm,ds,df,sector_count); + + MKDESCRIPTOR(0,1,0x00,1,0xA0,0,0,0,1,0,0); + MKDESCRIPTOR(1,1,0x00,1,0xA1,0,0,0,1,0,0); + MKDESCRIPTOR(2,1,0x00,1,0xA2,0,0,0,dm,ds,df); + MKDESCRIPTOR(3,1,0x00,5,0xB0,0,0,0,0,0,0); + MKDESCRIPTOR(4,1,0x00,5,0xC0,0,0,0,0,0,0); + MKDESCRIPTOR(5,1,0x04,1,0x01,0,0,0,0,2,0); + + tocCached = true; + } + + memcpy(toc,tocCacheData,min(2048,msize)); + + return 0; +} + +s32 FileSrc::ReadSectors2048(u32 sector, u32 count, char *buffer) +{ + DWORD size=0; + LARGE_INTEGER Offset; + + if(!OpenOK) return -1; + + Offset.QuadPart=sector*(u64)2048; + + //fall back to standard reading + if(SetFilePointer(fileSource,Offset.LowPart,&Offset.HighPart,FILE_BEGIN)==-1) + { + if(GetLastError()!=0) + return -1; + } + + if(ReadFile(fileSource,buffer,2048*count,&size,NULL)==0) + { + return -1; + } + + if(size!=(2048*count)) + { + return -1; + } + + return 0; +} + + +s32 FileSrc::ReadSectors2352(u32 sector, u32 count, char *buffer) +{ + DWORD size=0; + LARGE_INTEGER Offset; + + if(!OpenOK) return -1; + + assert(count <= 32); + + Offset.QuadPart=sector*(u64)2048; + + //fall back to standard reading + if(SetFilePointer(fileSource,Offset.LowPart,&Offset.HighPart,FILE_BEGIN)==-1) + { + if(GetLastError()!=0) + return -1; + } + + if(ReadFile(fileSource,sectorbuffer,2048*count,&size,NULL)==0) + { + return -1; + } + + if(size!=(2048*count)) + { + return -1; + } + + for(uint i=0;i(buffer+2352*i,sectorbuffer+2048*i,sector+i); + } + + return 0; +} + +s32 FileSrc::DiscChanged() +{ + DWORD size=0; + + if(!OpenOK) return -1; + + return 0; +} + +s32 FileSrc::IsOK() +{ + return OpenOK; +} diff --git a/plugins/cdvdGigaherz/IOCtlSrc.cpp b/plugins/cdvdGigaherz/IOCtlSrc.cpp new file mode 100644 index 0000000000..3d92539512 --- /dev/null +++ b/plugins/cdvdGigaherz/IOCtlSrc.cpp @@ -0,0 +1,673 @@ +#undef _WIN32_WINNT +#define _WIN32_WINNT 0x0600 +#include "CDVD.h" +#pragma warning(disable:4200) +#pragma pack(1) +#include +#include "rosddk/ntddcdvd.h" +#include "rosddk/ntddcdrm.h" +#include "rosddk/ntddscsi.h" +#pragma warning(default:4200) +#include + +template +bool ApiErrorCheck(T t,T okValue,bool cmpEq) +{ + bool cond=(t==okValue); + + if(!cmpEq) cond=!cond; + + if(!cond) + { + static char buff[1024]; + DWORD ec = GetLastError(); + FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,NULL,ec,0,buff,1023,NULL); + MessageBoxEx(0,buff,"ERROR?!",MB_OK,0); + } + return cond; +} + +#if FALSE +typedef struct { + SCSI_PASS_THROUGH_DIRECT spt; + ULONG Filler; + UCHAR ucSenseBuf[32]; +} SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER, *PSCSI_PASS_THROUGH_DIRECT_WITH_BUFFER; + +SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER sptIOCTL; // global read bufs + +char szBuf[1024]; + +PSCSI_ADDRESS pSA; + +DWORD SendIoCtlScsiCommand(HANDLE hDevice, u8 direction, + u8 cdbLength, u8* cdb, + u32 dataLength, void* dataBuffer + ) +{ + DWORD dwRet; + + memset(szBuf,0,1024); + + pSA=(PSCSI_ADDRESS)szBuf; + pSA->Length=sizeof(SCSI_ADDRESS); + + if(!DeviceIoControl(hDevice,IOCTL_SCSI_GET_ADDRESS,NULL, + 0,pSA,sizeof(SCSI_ADDRESS), + &dwRet,NULL)) + { + return -1; + } + + memset(&sptIOCTL,0,sizeof(sptIOCTL)); + + sptIOCTL.spt.Length = sizeof(SCSI_PASS_THROUGH_DIRECT); + sptIOCTL.spt.TimeOutValue = 60; + sptIOCTL.spt.SenseInfoLength = 14; + sptIOCTL.spt.SenseInfoOffset = offsetof(SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER, ucSenseBuf); + + sptIOCTL.spt.PathId = pSA->PortNumber; + sptIOCTL.spt.TargetId = pSA->TargetId; + sptIOCTL.spt.Lun = pSA->Lun; + + sptIOCTL.spt.DataIn = (direction>0)?SCSI_IOCTL_DATA_IN:((direction<0)?SCSI_IOCTL_DATA_OUT:SCSI_IOCTL_DATA_UNSPECIFIED); + sptIOCTL.spt.DataTransferLength = dataLength; + sptIOCTL.spt.DataBuffer = dataBuffer; + + sptIOCTL.spt.CdbLength = cdbLength; + memcpy(sptIOCTL.spt.Cdb,cdb,cdbLength); + + DWORD code = DeviceIoControl(hDevice, + IOCTL_SCSI_PASS_THROUGH_DIRECT, + &sptIOCTL,sizeof(sptIOCTL), + &sptIOCTL,sizeof(sptIOCTL), + &dwRet,NULL); + ApiErrorCheck(code,0,false); + return code; +} + +//0x00 = PHYSICAL STRUCTURE +DWORD ScsiReadStructure(HANDLE hDevice, u32 layer, u32 format, u32 buffer_length, void* buffer) +{ + u8 cdb[12]={0}; + + + cdb[0] = 0xAD; + /* + cdb[2] = (unsigned char)((addr >> 24) & 0xFF); + cdb[3] = (unsigned char)((addr >> 16) & 0xFF); + cdb[4] = (unsigned char)((addr >> 8) & 0xFF); + cdb[5] = (unsigned char)(addr & 0xFF); + */ + cdb[6] = layer; + cdb[7] = format; + cdb[8] = (unsigned char)((buffer_length>>8) & 0xFF); + cdb[9] = (unsigned char)((buffer_length) & 0xFF); + + return SendIoCtlScsiCommand(hDevice, 1, 12, cdb, buffer_length, buffer); +} + + +DWORD ScsiReadBE_2(HANDLE hDevice, u32 addr, u32 count, u8* buffer) +{ + u8 cdb[12]={0}; + + cdb[0] = 0xBE; + cdb[2] = (unsigned char)((addr >> 24) & 0xFF); + cdb[3] = (unsigned char)((addr >> 16) & 0xFF); + cdb[4] = (unsigned char)((addr >> 8) & 0xFF); + cdb[5] = (unsigned char)(addr & 0xFF); + cdb[8] = count; + cdb[9] = 0xF8; + cdb[10] = 0x2; + + return SendIoCtlScsiCommand(hDevice, 1, 12, cdb, 2352, buffer); +} + +DWORD ScsiRead10(HANDLE hDevice, u32 addr, u32 count, u8* buffer) +{ + u8 cdb[10]={0}; + + cdb[0] = 0x28; + //cdb[1] = lun<<5; + cdb[2] = (unsigned char)((addr >> 24) & 0xFF); + cdb[3] = (unsigned char)((addr >> 16) & 0xFF); + cdb[4] = (unsigned char)((addr >> 8) & 0xFF); + cdb[5] = (unsigned char)(addr & 0xFF); + cdb[8] = count; + + return SendIoCtlScsiCommand(hDevice, 1, 10, cdb, 2352, buffer); +} + +DWORD ScsiReadTOC(HANDLE hDevice, u32 addr, u8* buffer, bool use_msf) +{ + u8 cdb[12]={0}; + + cdb[0] = 0x43; + cdb[7] = 0x03; + cdb[8] = 0x24; + + if(use_msf) cdb[1]=2; + + return SendIoCtlScsiCommand(hDevice, 1, 10, cdb, 2352, buffer); +} + +s32 IOCtlSrc::GetSectorCount() +{ + DWORD size; + + LARGE_INTEGER li; + int plain_sectors = 0; + + if(GetFileSizeEx(device,&li)) + { + return li.QuadPart / 2048; + } + + GET_LENGTH_INFORMATION info; + if(DeviceIoControl(device, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, &info, sizeof(info), &size, NULL)) + { + return info.Length.QuadPart / 2048; + } + + CDROM_READ_TOC_EX tocrq={0}; + + tocrq.Format = CDROM_READ_TOC_EX_FORMAT_FULL_TOC; + tocrq.Msf=1; + tocrq.SessionTrack=1; + + CDROM_TOC_FULL_TOC_DATA *ftd=(CDROM_TOC_FULL_TOC_DATA*)sectorbuffer; + + if(DeviceIoControl(device,IOCTL_CDROM_READ_TOC_EX,&tocrq,sizeof(tocrq),ftd, 2048, &size, NULL)) + { + for(int i=0;i<101;i++) + { + if(ftd->Descriptors[i].Point==0xa2) + { + if(ftd->Descriptors[i].SessionNumber==ftd->LastCompleteSession) + { + int min=ftd->Descriptors[i].Msf[0]; + int sec=ftd->Descriptors[i].Msf[1]; + int frm=ftd->Descriptors[i].Msf[2]; + + return MSF_TO_LBA(min,sec,frm); + } + } + } + } + + int sectors1=-1; + + if(ScsiReadStructure(device,0,DvdPhysicalDescriptor, sizeof(dld), &dld)!=0) + { + if(dld.ld.EndLayerZeroSector>0) // OTP? + { + sectors1 = dld.ld.EndLayerZeroSector - dld.ld.StartingDataSector; + } + else //PTP or single layer + { + sectors1 = dld.ld.EndDataSector - dld.ld.StartingDataSector; + } + + if(ScsiReadStructure(device,1,DvdPhysicalDescriptor, sizeof(dld), &dld)!=0) + { + // PTP second layer + //sectors1 += dld.ld.EndDataSector - dld.ld.StartingDataSector; + if(dld.ld.EndLayerZeroSector>0) // OTP? + { + sectors1 += dld.ld.EndLayerZeroSector - dld.ld.StartingDataSector; + } + else //PTP + { + sectors1 += dld.ld.EndDataSector - dld.ld.StartingDataSector; + } + } + + return sectors1; + } + + return -1; +} + +s32 IOCtlSrc::GetLayerBreakAddress() +{ + DWORD size; + if(ScsiReadStructure(device,0,DvdPhysicalDescriptor, sizeof(dld), &dld)!=0) + { + if(dld.ld.EndLayerZeroSector>0) // OTP? + { + return dld.ld.EndLayerZeroSector - dld.ld.StartingDataSector; + } + else //PTP or single layer + { + u32 s1 = dld.ld.EndDataSector - dld.ld.StartingDataSector; + + if(ScsiReadStructure(device,1,DvdPhysicalDescriptor, sizeof(dld), &dld)!=0) + { + //PTP + return s1; + } + + // single layer + return 0; + } + } + + return -1; +} +#endif + +#define RETURN(v) {OpenOK=v; return;} + +s32 IOCtlSrc::Reopen() +{ + if(device!=INVALID_HANDLE_VALUE) + { + DWORD size; + DeviceIoControl(device,IOCTL_DVD_END_SESSION,&sessID,sizeof(DVD_SESSION_ID),NULL,0,&size, NULL); + CloseHandle(device); + } + + DWORD share = FILE_SHARE_READ; + DWORD flags = FILE_ATTRIBUTE_READONLY | FILE_FLAG_SEQUENTIAL_SCAN; + DWORD size; + + OpenOK = false; + + device = CreateFile(fName, GENERIC_READ|GENERIC_WRITE|FILE_READ_ATTRIBUTES, share, NULL, OPEN_EXISTING, flags, 0); + if(device==INVALID_HANDLE_VALUE) + { + device = CreateFile(fName, GENERIC_READ|FILE_READ_ATTRIBUTES, share, NULL, OPEN_EXISTING, flags, 0); + if(device==INVALID_HANDLE_VALUE) + return -1; + } + + sessID=0; + DeviceIoControl(device,IOCTL_DVD_START_SESSION,NULL,0,&sessID,sizeof(DVD_SESSION_ID), &size, NULL); + + tocCached = false; + mediaTypeCached = false; + discSizeCached = false; + layerBreakCached = false; + + OpenOK=true; + return 0; +} + +IOCtlSrc::IOCtlSrc(const char* fileName) +{ + device=INVALID_HANDLE_VALUE; + + strcpy_s(fName,256,fileName); + + Reopen(); +} + +IOCtlSrc::~IOCtlSrc() +{ + if(OpenOK) + { + DWORD size; + DeviceIoControl(device,IOCTL_DVD_END_SESSION,&sessID,sizeof(DVD_SESSION_ID),NULL,0,&size, NULL); + + CloseHandle(device); + } +} + +struct mycrap +{ + DWORD shit; + DVD_LAYER_DESCRIPTOR ld; +}; + +DVD_READ_STRUCTURE dvdrs; +mycrap dld; +DISK_GEOMETRY dg; +CDROM_READ_TOC_EX tocrq={0}; + +s32 IOCtlSrc::GetSectorCount() +{ + DWORD size; + + LARGE_INTEGER li; + int plain_sectors = 0; + + if(discSizeCached) + return discSize; + + if(GetFileSizeEx(device,&li)) + { + discSizeCached = true; + discSize = (s32)(li.QuadPart / 2048); + return discSize; + } + + GET_LENGTH_INFORMATION info; + if(DeviceIoControl(device, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, &info, sizeof(info), &size, NULL)) + { + discSizeCached = true; + discSize = (s32)(info.Length.QuadPart / 2048); + return discSize; + } + + memset(&tocrq,0,sizeof(CDROM_READ_TOC_EX)); + tocrq.Format = CDROM_READ_TOC_EX_FORMAT_FULL_TOC; + tocrq.Msf=1; + tocrq.SessionTrack=1; + + CDROM_TOC_FULL_TOC_DATA *ftd=(CDROM_TOC_FULL_TOC_DATA*)sectorbuffer; + + if(DeviceIoControl(device,IOCTL_CDROM_READ_TOC_EX,&tocrq,sizeof(tocrq),ftd, 2048, &size, NULL)) + { + for(int i=0;i<101;i++) + { + if(ftd->Descriptors[i].Point==0xa2) + { + if(ftd->Descriptors[i].SessionNumber==ftd->LastCompleteSession) + { + int min=ftd->Descriptors[i].Msf[0]; + int sec=ftd->Descriptors[i].Msf[1]; + int frm=ftd->Descriptors[i].Msf[2]; + + discSizeCached = true; + discSize = (s32)MSF_TO_LBA(min,sec,frm); + return discSize; + } + } + } + } + + int sectors1=-1; + + dvdrs.BlockByteOffset.QuadPart=0; + dvdrs.Format=DvdPhysicalDescriptor; + dvdrs.SessionId=sessID; + dvdrs.LayerNumber=0; + if(DeviceIoControl(device,IOCTL_DVD_READ_STRUCTURE,&dvdrs,sizeof(dvdrs),&dld, sizeof(dld), &size, NULL)!=0) + { + if(dld.ld.EndLayerZeroSector>0) // OTP? + { + sectors1 = dld.ld.EndLayerZeroSector - dld.ld.StartingDataSector; + } + else //PTP or single layer + { + sectors1 = dld.ld.EndDataSector - dld.ld.StartingDataSector; + } + dvdrs.BlockByteOffset.QuadPart=0; + dvdrs.Format=DvdPhysicalDescriptor; + dvdrs.SessionId=sessID; + dvdrs.LayerNumber=1; + if(DeviceIoControl(device,IOCTL_DVD_READ_STRUCTURE,&dvdrs,sizeof(dvdrs),&dld, sizeof(dld), &size, NULL)!=0) + { + // PTP second layer + //sectors1 += dld.ld.EndDataSector - dld.ld.StartingDataSector; + if(dld.ld.EndLayerZeroSector>0) // OTP? + { + sectors1 += dld.ld.EndLayerZeroSector - dld.ld.StartingDataSector; + } + else //PTP + { + sectors1 += dld.ld.EndDataSector - dld.ld.StartingDataSector; + } + } + + discSizeCached = true; + discSize = sectors1; + return discSize; + } + + return -1; +} + +s32 IOCtlSrc::GetLayerBreakAddress() +{ + DWORD size; + DWORD code; + + if(GetMediaType()<0) + return -1; + + if(layerBreakCached) + return layerBreak; + + dvdrs.BlockByteOffset.QuadPart=0; + dvdrs.Format=DvdPhysicalDescriptor; + dvdrs.SessionId=sessID; + dvdrs.LayerNumber=0; + if(code=DeviceIoControl(device,IOCTL_DVD_READ_STRUCTURE,&dvdrs,sizeof(dvdrs),&dld, sizeof(dld), &size, NULL)!=0) + { + if(dld.ld.EndLayerZeroSector>0) // OTP? + { + layerBreakCached = true; + layerBreak = dld.ld.EndLayerZeroSector - dld.ld.StartingDataSector; + return layerBreak; + } + else //PTP or single layer + { + u32 s1 = dld.ld.EndDataSector - dld.ld.StartingDataSector; + + dvdrs.BlockByteOffset.QuadPart=0; + dvdrs.Format=DvdPhysicalDescriptor; + dvdrs.SessionId=sessID; + dvdrs.LayerNumber=1; + + if(DeviceIoControl(device,IOCTL_DVD_READ_STRUCTURE,&dvdrs,sizeof(dvdrs),&dld, sizeof(dld), &size, NULL)!=0) + { + //PTP + layerBreakCached = true; + layerBreak = s1; + return layerBreak; + } + + // single layer + layerBreakCached = true; + layerBreak = 0; + return layerBreak; + } + } + + //if not a cd, and fails, assume single layer + return 0; +} + +s32 IOCtlSrc::GetMediaType() +{ + DWORD size; + DWORD code; + + if(mediaTypeCached) + return mediaType; + + memset(&tocrq,0,sizeof(CDROM_READ_TOC_EX)); + tocrq.Format = CDROM_READ_TOC_EX_FORMAT_FULL_TOC; + tocrq.Msf=1; + tocrq.SessionTrack=1; + + CDROM_TOC_FULL_TOC_DATA *ftd=(CDROM_TOC_FULL_TOC_DATA*)sectorbuffer; + + if(DeviceIoControl(device,IOCTL_CDROM_READ_TOC_EX,&tocrq,sizeof(tocrq),ftd, 2048, &size, NULL)) + { + mediaTypeCached = true; + mediaType = -1; + return mediaType; + } + + dvdrs.BlockByteOffset.QuadPart=0; + dvdrs.Format=DvdPhysicalDescriptor; + dvdrs.SessionId=sessID; + dvdrs.LayerNumber=0; + if(code=DeviceIoControl(device,IOCTL_DVD_READ_STRUCTURE,&dvdrs,sizeof(dvdrs),&dld, sizeof(dld), &size, NULL)!=0) + { + if(dld.ld.EndLayerZeroSector>0) // OTP? + { + mediaTypeCached = true; + mediaType = 2; + return mediaType; + } + else //PTP or single layer + { + u32 s1 = dld.ld.EndDataSector - dld.ld.StartingDataSector; + + dvdrs.BlockByteOffset.QuadPart=0; + dvdrs.Format=DvdPhysicalDescriptor; + dvdrs.SessionId=sessID; + dvdrs.LayerNumber=1; + + if(DeviceIoControl(device,IOCTL_DVD_READ_STRUCTURE,&dvdrs,sizeof(dvdrs),&dld, sizeof(dld), &size, NULL)!=0) + { + //PTP + mediaTypeCached = true; + mediaType = 2; + return mediaType; + } + + // single layer + mediaTypeCached = true; + mediaType = 0; + return mediaType; + } + } + + //if not a cd, and fails, assume single layer + mediaTypeCached = true; + mediaType = 0; + return mediaType; +} + +s32 IOCtlSrc::ReadTOC(char *toc,int msize) +{ + DWORD size=0; + + if(GetMediaType()>=0) + return -1; + + if(!tocCached) + { + memset(&tocrq,0,sizeof(CDROM_READ_TOC_EX)); + tocrq.Format = CDROM_READ_TOC_EX_FORMAT_FULL_TOC; + tocrq.Msf=1; + tocrq.SessionTrack=1; + + CDROM_TOC_FULL_TOC_DATA *ftd=(CDROM_TOC_FULL_TOC_DATA*)tocCacheData; + + if(!OpenOK) return -1; + + int code = DeviceIoControl(device,IOCTL_CDROM_READ_TOC_EX,&tocrq,sizeof(tocrq),tocCacheData, 2048, &size, NULL); + + if(code==0) + return -1; + + tocCached = true; + } + + memcpy(toc,tocCacheData,min(2048,msize)); + + return 0; +} + +s32 IOCtlSrc::ReadSectors2048(u32 sector, u32 count, char *buffer) +{ + RAW_READ_INFO rri; + + DWORD size=0; + + if(!OpenOK) return -1; + + rri.DiskOffset.QuadPart=sector*(u64)2048; + rri.SectorCount=count; + + //fall back to standard reading + if(SetFilePointer(device,rri.DiskOffset.LowPart,&rri.DiskOffset.HighPart,FILE_BEGIN)==-1) + { + if(GetLastError()!=0) + return -1; + } + + if(ReadFile(device,buffer,2048*count,&size,NULL)==0) + { + return -1; + } + + if(size!=(2048*count)) + { + return -1; + } + + return 0; +} + + +s32 IOCtlSrc::ReadSectors2352(u32 sector, u32 count, char *buffer) +{ + RAW_READ_INFO rri; + + DWORD size=0; + + if(!OpenOK) return -1; + + rri.DiskOffset.QuadPart=sector*(u64)2048; + rri.SectorCount=count; + + rri.TrackMode=(TRACK_MODE_TYPE)last_read_mode; + if(DeviceIoControl(device,IOCTL_CDROM_RAW_READ,&rri,sizeof(rri),buffer, 2352*count, &size, NULL)==0) + { + rri.TrackMode=CDDA; + if(DeviceIoControl(device,IOCTL_CDROM_RAW_READ,&rri,sizeof(rri),buffer, 2352*count, &size, NULL)==0) + { + rri.TrackMode=XAForm2; + if(DeviceIoControl(device,IOCTL_CDROM_RAW_READ,&rri,sizeof(rri),buffer, 2352*count, &size, NULL)==0) + { + rri.TrackMode=YellowMode2; + if(DeviceIoControl(device,IOCTL_CDROM_RAW_READ,&rri,sizeof(rri),buffer, 2352*count, &size, NULL)==0) + { + return -1; + } + } + } + } + + last_read_mode=rri.TrackMode; + + if(size!=(2352*count)) + { + return -1; + } + + return 0; +} + +s32 IOCtlSrc::DiscChanged() +{ + DWORD size=0; + + if(!OpenOK) return -1; + + int ret = DeviceIoControl(device,IOCTL_STORAGE_CHECK_VERIFY,NULL,0,NULL,0, &size, NULL); + + if(ret==0) + { + tocCached = false; + mediaTypeCached = false; + discSizeCached = false; + layerBreakCached = false; + + if(sessID!=0) + { + DeviceIoControl(device,IOCTL_DVD_END_SESSION,&sessID,sizeof(DVD_SESSION_ID),NULL,0,&size, NULL); + sessID=0; + } + return 1; + } + + if(sessID==0) + { + DeviceIoControl(device,IOCTL_DVD_START_SESSION,NULL,0,&sessID,sizeof(DVD_SESSION_ID), &size, NULL); + } + + return 0; +} + +s32 IOCtlSrc::IsOK() +{ + return OpenOK; +} diff --git a/plugins/cdvdGigaherz/ReadThread.cpp b/plugins/cdvdGigaherz/ReadThread.cpp new file mode 100644 index 0000000000..6d8290fef8 --- /dev/null +++ b/plugins/cdvdGigaherz/ReadThread.cpp @@ -0,0 +1,422 @@ +#include "CDVD.h" + +const s32 prefetch_max_blocks=16; +s32 prefetch_mode=0; +s32 prefetch_last_lba=0; +s32 prefetch_last_mode=0; +s32 prefetch_left=0; + +HANDLE hNotify = INVALID_HANDLE_VALUE; +HANDLE hThread = INVALID_HANDLE_VALUE; +DWORD pidThread= 0; + +enum loadStatus +{ + LoadIdle, + LoadPending, + LoadSuccess, +}; + +typedef struct +{ + int lsn; + int mode; + char data[2352*16]; //we will read in blocks of 16 sectors +} SectorInfo; + +//bits: 8 would use 1<<8 entries, or 256*16 sectors +#define CACHE_SIZE 10 + +const s32 CacheSize=(1<=0) + { + t^=lsn&m; + lsn>>=CACHE_SIZE; + i-=CACHE_SIZE; + } + + return (t^mode)&m; +} + +void cdvdCacheUpdate(int lsn, int mode, char* data) +{ + u32 entry = cdvdSectorHash(lsn,mode); + + memcpy(Cache[entry].data,data,2352*16); + Cache[entry].lsn = lsn; + Cache[entry].mode = mode; +} + +bool cdvdCacheFetch(int lsn, int mode, char* data) +{ + u32 entry = cdvdSectorHash(lsn,mode); + + if((Cache[entry].lsn==lsn) && + (Cache[entry].mode==mode)) + { + memcpy(data,Cache[entry].data,2352*16); + return true; + } + + return false; +} + +void cdvdCacheReset() +{ + for(int i=0;iDiscChanged(); + + if(change==-1) //error getting status (no disc in drive?) + { + //try to recreate the device + src->Reopen(); + + if(src->IsOK()) + { + change = 1; + } + else + { + curDiskType=CDVD_TYPE_NODISC; + curTrayStatus=CDVD_TRAY_OPEN; + return true; + } + } + + if(change==1) + { + if(!disc_has_changed) + { + disc_has_changed=1; + curDiskType=CDVD_TYPE_NODISC; + curTrayStatus=CDVD_TRAY_OPEN; + cdvdCallNewDiscCB(); + } + } + else + { + if(disc_has_changed) + { + curDiskType=CDVD_TYPE_NODISC; + curTrayStatus=CDVD_TRAY_CLOSE; + + // just a test + src->Reopen(); + + disc_has_changed=0; + cdvdRefreshData(); + cdvdCallNewDiscCB(); + } + } + return (change!=0); +} + +DWORD CALLBACK cdvdThread(PVOID param) +{ + printf(" * CDVD: IO thread started...\n"); + while(cdvd_is_open) + { + DWORD f=0; + + if(!src) break; + + if(cdvdUpdateDiscStatus()) continue; + + if(prefetch_left) + WaitForSingleObject(hNotify,1); + else + WaitForSingleObject(hNotify,250); + + if(cdvd_is_open) + { + static SectorInfo info; + + bool handlingRequest = false; + + if(threadRequestPending) + { + info=threadRequestInfo; + handlingRequest = true; + } + else + { + info.lsn = prefetch_last_lba; + info.mode = prefetch_last_mode; + } + + if(threadRequestPending || prefetch_left) + { + s32 ret = -1; + s32 tries=5; + + s32 count = 16; + + s32 left = tracks[0].length-info.lsn; + + if(leftReadSectors2048(info.lsn,count,info.data); + else + ret = src->ReadSectors2352(info.lsn,count,info.data); + + if(ret==0) + break; + + tries--; + + } while((ret<0)&&(tries>0)); + + cdvdCacheUpdate(info.lsn,info.mode,info.data); + + if(handlingRequest) + { + threadRequestInfo = info; + + handlingRequest = false; + threadRequestPending = false; + + prefetch_last_lba=info.lsn; + prefetch_last_mode=info.mode; + + prefetch_left = prefetch_max_blocks; + } + else + { + prefetch_last_lba+=16; + prefetch_left--; + } + } + } + } + printf(" * CDVD: IO thread finished.\n"); + return 0; +} + +s32 cdvdStartThread() +{ + + hNotify = CreateEvent(NULL,FALSE,FALSE,NULL); + if(hNotify==INVALID_HANDLE_VALUE) + return -1; + + cdvd_is_open=true; + hThread = CreateThread(NULL,0,cdvdThread,NULL,0,&pidThread); + + if(hThread==INVALID_HANDLE_VALUE) + return -1; + + SetThreadPriority(hThread,THREAD_PRIORITY_NORMAL); + + cdvdCacheReset(); + + return 0; +} + +void cdvdStopThread() +{ + cdvd_is_open=false; + PulseEvent(hNotify); + if(WaitForSingleObject(hThread,4000)==WAIT_TIMEOUT) + { + TerminateThread(hThread,0); + } + CloseHandle(hThread); + CloseHandle(hNotify); +} + +s32 cdvdRequestSector(u32 sector, s32 mode) +{ + if(sector>=tracks[0].length) + return -1; + + sector&=~15; //align to 16-sector block + + threadRequestInfo.lsn = sector; + threadRequestInfo.mode = mode; + threadRequestPending = false; + if(cdvdCacheFetch(sector,mode,threadRequestInfo.data)) + { + return 0; + } + + threadRequestPending = true; + + PulseEvent(hNotify); + + return 0; +} + +s32 cdvdRequestComplete() +{ + return !threadRequestPending; +} + +s8* cdvdGetSector(s32 sector, s32 mode) +{ + while(threadRequestPending) + { + Sleep(1); + } + + s32 offset; + + if(mode==CDVD_MODE_2048) + { + offset = 2048*(sector-threadRequestInfo.lsn); + return threadRequestInfo.data + offset; + } + + offset = 2352*(sector-threadRequestInfo.lsn); + s8* data = threadRequestInfo.data + offset; + + switch(mode) + { + case CDVD_MODE_2328: + return data + 24; + case CDVD_MODE_2340: + return data + 12; + } + return data; +} + +s32 cdvdDirectReadSector(s32 first, s32 mode, char *buffer) +{ + static char data[16*2352]; + + if((u32)first>=tracks[0].length) + return -1; + + s32 sector = first&(~15); //align to 16-sector block + + if(!cdvdCacheFetch(sector,mode,data)) + { + s32 ret = -1; + s32 tries=5; + + s32 count = 16; + + s32 left = tracks[0].length-sector; + + if(leftReadSectors2048(sector,count,data); + else + ret = src->ReadSectors2352(sector,count,data); + + if(ret==0) + break; + + tries--; + + } while((ret<0)&&(tries>0)); + + cdvdCacheUpdate(sector,mode,data); + } + + s32 offset; + + if(mode==CDVD_MODE_2048) + { + offset = 2048*(first-sector); + memcpy(buffer,data + offset,2048); + return 0; + } + + offset = 2352*(first-sector); + s8* bfr = data + offset; + + switch(mode) + { + case CDVD_MODE_2328: + memcpy(buffer,bfr+24,2328); + return 0; + case CDVD_MODE_2340: + memcpy(buffer,bfr+12,2340); + return 0; + default: + memcpy(buffer,bfr+12,2352); + return 0; + } + return 0; +} + +s32 cdvdGetMediaType() +{ + return src->GetMediaType(); +} + +s32 refreshes=0; + +s32 cdvdRefreshData() +{ + char *diskTypeName="Unknown"; + + //read TOC from device + cdvdParseTOC(); + + if((etrack==0)||(strack>etrack)) + { + curDiskType=CDVD_TYPE_NODISC; + } + else + { + curDiskType = FindDiskType(); + } + + curTrayStatus = CDVD_TRAY_CLOSE; + + switch(curDiskType) + { + case CDVD_TYPE_ILLEGAL: diskTypeName="Illegal Disc"; break; + case CDVD_TYPE_DVDV: diskTypeName="DVD-Video"; break; + case CDVD_TYPE_CDDA: diskTypeName="CD-Audio"; break; + case CDVD_TYPE_PS2DVD: diskTypeName="PS2 DVD"; break; + case CDVD_TYPE_PS2CDDA: diskTypeName="PS2 CD+Audio"; break; + case CDVD_TYPE_PS2CD: diskTypeName="PS2 CD"; break; + case CDVD_TYPE_PSCDDA: diskTypeName="PS1 CD+Audio"; break; + case CDVD_TYPE_PSCD: diskTypeName="PS1 CD"; break; + case CDVD_TYPE_UNKNOWN: diskTypeName="Unknown"; break; + case CDVD_TYPE_DETCTDVDD: diskTypeName="Detecting (Single-Layer DVD)"; break; + case CDVD_TYPE_DETCTDVDS: diskTypeName="Detecting (Double-Layer DVD)"; break; + case CDVD_TYPE_DETCTCD: diskTypeName="Detecting (CD)"; break; + case CDVD_TYPE_DETCT: diskTypeName="Detecting"; break; + case CDVD_TYPE_NODISC: diskTypeName="No Disc"; break; + } + + printf(" * CDVD: Disk Type: %s\n",diskTypeName); + + cdvdCacheReset(); + + return 0; +} diff --git a/plugins/cdvdGigaherz/SectorConverters.h b/plugins/cdvdGigaherz/SectorConverters.h new file mode 100644 index 0000000000..44de8c86f7 --- /dev/null +++ b/plugins/cdvdGigaherz/SectorConverters.h @@ -0,0 +1,40 @@ +#pragma once + +template +int Convert(char *dest, const char* psrc, int lsn); + +template<> +int Convert<2048,2048>(char *dest, const char* psrc, int lsn) +{ + memcpy(dest,psrc,2048); + return 0; +} + +template<> +int Convert<2352,2352>(char *dest, const char* psrc, int lsn) +{ + memcpy(dest,psrc,2352); + return 0; +} + +template<> +int Convert<2352,2048>(char *dest, const char* psrc, int lsn) +{ + memcpy(dest,psrc+16,2048); + return 0; +} + +template<> +int Convert<2048,2352>(char *dest, const char* psrc, int lsn) +{ + int m = lsn / (75*60); + int s = (lsn/75) % 60; + int f = lsn%75; + unsigned char header[16] = { + 0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x00, m, s, f,0x02 + }; + + memcpy(dest,header,16); + memcpy(dest+16,psrc,2048); + return 0; +} diff --git a/plugins/cdvdGigaherz/TestRun.cpp b/plugins/cdvdGigaherz/TestRun.cpp new file mode 100644 index 0000000000..38720b0bbd --- /dev/null +++ b/plugins/cdvdGigaherz/TestRun.cpp @@ -0,0 +1,313 @@ +#include "CDVD.h" + +#define TLogN(msg) printf(msg); sprintf(tlptr,msg); tlptr=tlptr+strlen(tlptr) +#define TLogN1(msg,p1) printf(msg,p1); sprintf(tlptr,msg,p1); tlptr=tlptr+strlen(tlptr) +#define TLogN3(msg,p1,p2,p3) printf(msg,p1,p2,p3); sprintf(tlptr,msg,p1,p2,p3); tlptr=tlptr+strlen(tlptr) +#define TLog(msg) printf(" * CDVD Test: " msg); sprintf(tlptr,msg); tlptr=tlptr+strlen(tlptr) +#define TLog1(msg,p1) printf(" * CDVD Test: " msg,p1); sprintf(tlptr,msg,p1); tlptr=tlptr+strlen(tlptr) +#define TLog3(msg,p1,p2,p3) printf(" * CDVD Test: " msg,p1,p2,p3); sprintf(tlptr,msg,p1,p2,p3); tlptr=tlptr+strlen(tlptr) +#define TReturn(k) ret=k;break + +s32 testReadSector(u32 snum, bool raw) +{ + if(CDVDreadTrack(snum,raw?CDVD_MODE_2352:CDVD_MODE_2048)<0) + { + printf(" * CDVD Test: Reading sector %d in %s mode...",snum,raw?"raw":"user"); + printf("failed.\n"); + return -1; + } + u8*bfr = CDVDgetBuffer(); + + if(!bfr) + { + printf(" * CDVD Test: Reading sector %d in %s mode...",snum,raw?"raw":"user"); + printf("failed.\n"); + return -1; + } + + //printf("ok.\n"); + + return 0; +} + +s32 CALLBACK CDVDtest() +{ + char *buffer = (char*)malloc(1024*1024); + char *tlptr = buffer; + + int ret; + + for(;;) + { + ReadSettings(); + + if(source_drive=='@') + { + TLog("WARNING: Plugin configured to use no disc. Nothing to test."); + TReturn(0); + } + + sprintf(csrc,"\\\\.\\%c:",source_drive); + + TLog1("1. Opening drive '%s'... ",csrc); + + //open device file + src=new IOCtlSrc(csrc); + if(!src) + { + TLogN(" failed!\n"); + TReturn(-1); + } + + if(!src->IsOK()) + { + TLogN(" failed!\n"); + TReturn(-1); + } + TLogN("ok.\n"); + + TLog("2. Starting read thread... "); + //setup threading manager + if(cdvdStartThread()<0) + { + TLogN(" failed!\n"); + TReturn(-1); + } + TLogN("ok.\n"); + + TLog("3. Checking Sizes...\n"); + TLog(" * Checking Sector Count... "); + s32 sectorcount = src->GetSectorCount(); + + if(sectorcount<0) + { + TLogN("error. Is there a disc in the drive?\n"); + TReturn(-1); + } + else if(sectorcount==0) + { + TLogN("0 sectors. Bad disc?\n"); + TReturn(-1); + } + else + { + TLogN1("%d sectors.\n",sectorcount); + } + + TLog(" * Checking Layer Break Address... "); + s32 lastaddr = src->GetLayerBreakAddress(); + + if(lastaddr<0) + { + TLogN("error. Probably not a DVD. Assuming CDROM....\n"); + } + else if(lastaddr==0) + { + TLogN("0. Single layer.\n"); + } + else + { + TLogN1("%d. Double layer disc.\n",lastaddr); + } + + TLog("4. Attempting to read disc TOC... "); + if(lastaddr<0) + { + if(src->ReadTOC((char*)&cdtoc,sizeof(cdtoc))<0) + { + TLogN("failed!\n"); + TReturn(-1); + } + TLogN("ok.\n"); + + TLog(" * Reading TOC descriptors...\n"); + for(int i=0;i<101;i++) + { + if(cdtoc.Descriptors[i].Point!=0) + { + TLog1(" * Descriptor %d: ",i); + TLogN1("Session %d, ",cdtoc.Descriptors[i].SessionNumber); + switch(cdtoc.Descriptors[i].Point) + { + case 0xa0: + TLogN1("0xA0: First track = %d.\n",cdtoc.Descriptors[i].Msf[0]); + break; + case 0xa1: + TLogN1("0xA1: Last track = %d.\n",cdtoc.Descriptors[i].Msf[0]); + if(cdtoc.Descriptors[i].SessionNumber==cdtoc.LastCompleteSession) + { + etrack = cdtoc.Descriptors[i].Msf[0]; + } + break; + case 0xa2: // session size + { + int min,sec,frm,lba; + + min=cdtoc.Descriptors[i].Msf[0]; + sec=cdtoc.Descriptors[i].Msf[1]; + frm=cdtoc.Descriptors[i].Msf[2]; + lba=MSF_TO_LBA(min,sec,frm); + + TLogN3("0xA2: Start of lead-out track: msf(%d,%d,%d)",min,sec,frm); + TLogN1("=lba(%d).\n",lba); + } + break; + case 0xb0: + { + int min,sec,frm,lba; + + min=cdtoc.Descriptors[i].Msf[0]; + sec=cdtoc.Descriptors[i].Msf[1]; + frm=cdtoc.Descriptors[i].Msf[2]; + lba=MSF_TO_LBA(min,sec,frm); + + TLogN3("0xB0: Leadout start? msf(%d,%d,%d)",min,sec,frm); + TLogN1("=lba(%d).\n",lba); + } + break; + case 0xc0: + { + int min,sec,frm,lba; + + min=cdtoc.Descriptors[i].Msf[0]; + sec=cdtoc.Descriptors[i].Msf[1]; + frm=cdtoc.Descriptors[i].Msf[2]; + lba=MSF_TO_LBA(min,sec,frm); + + TLogN3("0xC0: Leadout end? msf(%d,%d,%d)",min,sec,frm); + TLogN1("=lba(%d).\n",lba); + } + break; + default: + if((cdtoc.Descriptors[i].Point<101)&&(cdtoc.Descriptors[i].Point>0)) + { + int min,sec,frm,lba; + int tn=cdtoc.Descriptors[i].Point; + + min=cdtoc.Descriptors[i].Msf[0]; + sec=cdtoc.Descriptors[i].Msf[1]; + frm=cdtoc.Descriptors[i].Msf[2]; + lba = MSF_TO_LBA(min,sec,frm); + + TLogN1("%d: Track start:",tn); + TLogN3(" msf(%d,%d,%d)",min,sec,frm); + TLogN3("=lba(%d), adr=%x control=%x.\n",lba,cdtoc.Descriptors[i].Adr,cdtoc.Descriptors[i].Control); + + + } + else if(cdtoc.Descriptors[i].Point>0) + { + int min,sec,frm,lba; + int tn=cdtoc.Descriptors[i].Point; + + min=cdtoc.Descriptors[i].Msf[0]; + sec=cdtoc.Descriptors[i].Msf[1]; + frm=cdtoc.Descriptors[i].Msf[2]; + lba = MSF_TO_LBA(min,sec,frm); + + TLogN1("0x%02x: Unknon descriptor point code:",tn); + TLogN3(" msf(%d,%d,%d)",min,sec,frm); + TLogN1("=lba(%d).\n",lba); + + + } + break; + } + } + } + } + else + { + TLogN("skipped (not a cdrom).\n"); + } + + TLog("6. Attempting to detect disc type... "); + + cdvdParseTOC(); + curDiskType = FindDiskType(); + + if(curDiskType<0) + { + TLogN("failed!\n"); + TReturn(-1); + } + + char *diskTypeName="Unknown"; + + switch(curDiskType) + { + case CDVD_TYPE_ILLEGAL: diskTypeName="Illegal Disc"; break; + case CDVD_TYPE_DVDV: diskTypeName="DVD-Video"; break; + case CDVD_TYPE_CDDA: diskTypeName="CD-Audio"; break; + case CDVD_TYPE_PS2DVD: diskTypeName="PS2 DVD"; break; + case CDVD_TYPE_PS2CDDA: diskTypeName="PS2 CD+Audio"; break; + case CDVD_TYPE_PS2CD: diskTypeName="PS2 CD"; break; + case CDVD_TYPE_PSCDDA: diskTypeName="PS1 CD+Audio"; break; + case CDVD_TYPE_PSCD: diskTypeName="PS1 CD"; break; + case CDVD_TYPE_UNKNOWN: diskTypeName="Unknown"; break; + case CDVD_TYPE_DETCTDVDD: diskTypeName="Detecting (Single-Layer DVD)"; break; + case CDVD_TYPE_DETCTDVDS: diskTypeName="Detecting (Double-Layer DVD)"; break; + case CDVD_TYPE_DETCTCD: diskTypeName="Detecting (CD)"; break; + case CDVD_TYPE_DETCT: diskTypeName="Detecting"; break; + case CDVD_TYPE_NODISC: diskTypeName="No Disc"; break; + } + + TLogN1(" %s.\n",diskTypeName); + + TLog("7. Testing USER sector reading... "); + + //force a spinup + testReadSector(16,true); + + DWORD ticksStart = GetTickCount(); + + for(int i=16;i<2016;i++) + { + if(testReadSector(i,false)<0) + { + TLogN1("%d failed!\n",i); + TReturn(-1); + } + } + DWORD ticksEnd = GetTickCount(); + float speed =(2000.0f*2048.0f*1000.0f)/(ticksEnd-ticksStart); + + TLogN1("OK: %f Kbytes/s.\n",speed/1024); + + if(src->GetMediaType()<0) + { + TLog("8. Testing RAW sector reading... "); + + //force a spinup + testReadSector(16,true); + + ticksStart = GetTickCount(); + for(int i=16;i<2016;i++) + { + if(testReadSector(i,true)<0) + { + TLogN1("%d failed!\n",i); + TReturn(-1); + } + } + ticksEnd = GetTickCount(); + speed =(2000.0f*2352.0f*1000.0f)/(ticksEnd-ticksStart); + + TLogN1("OK: %f Kbytes/s.\n",speed/1024); + } + + TReturn(0); + } + + MessageBoxEx(0,buffer,"Test Results",MB_OK,0); + + if(src!=NULL) + { + cdvdStopThread(); + delete src; + src=NULL; + } + + free(buffer); + return ret; +} diff --git a/plugins/cdvdGigaherz/TocStuff.cpp b/plugins/cdvdGigaherz/TocStuff.cpp new file mode 100644 index 0000000000..85a0d54512 --- /dev/null +++ b/plugins/cdvdGigaherz/TocStuff.cpp @@ -0,0 +1,149 @@ +#include "CDVD.h" + +toc_data cdtoc; + +s32 cdvdParseTOC() +{ + memset(&cdtoc,0,sizeof(cdtoc)); + + s32 len = src->GetSectorCount(); + + tracks[0].length = len; + tracks[0].start_lba=0; + tracks[0].type=0; + tracks[1].start_lba=0; + + if(len<=0) + { + curDiskType=CDVD_TYPE_NODISC; + tracks[0].length=0; + strack=1; + etrack=0; + return 0; + } + + s32 lastaddr = src->GetLayerBreakAddress(); + + + if(lastaddr>=0) + { + if((lastaddr > 0)&&(tracks[0].length>lastaddr)) + { + tracks[1].length=lastaddr+1; + tracks[1].type=0; + + tracks[2].start_lba = tracks[1].length; + tracks[2].length = tracks[0].length-tracks[1].length; + tracks[2].type=0; + + strack=1; + etrack=2; + } + else + { + tracks[1].length=tracks[0].length; + tracks[1].type=0; + + strack=1; + etrack=1; + } + } + else + { + u8 min, sec, frm; + + if(src->ReadTOC((char*)&cdtoc,sizeof(cdtoc))<0) + { + /* + printf(" * CDVD: WARNING ReadTOC() failed, trying to use MCI instead...\n"); + delete src; + int status = MCI_CDGetTOC(source_drive); + + src=new SOURCECLASS(csrc); + + if(status<0)*/ + return -1; + + //return 0; + } + +#define btoi(b) ((b>>4)*10+(b&0xF)) + + int length = (cdtoc.Length[0]<<8) | cdtoc.Length[1]; + int descriptors = length/sizeof(cdtoc.Descriptors[0]); + for(int i=0;i0)) + { + int tn=cdtoc.Descriptors[i].Point; + + min=cdtoc.Descriptors[i].Msf[0]; + sec=cdtoc.Descriptors[i].Msf[1]; + frm=cdtoc.Descriptors[i].Msf[2]; + + tracks[tn].start_lba = MSF_TO_LBA(min,sec,frm); + if(tn>1) + tracks[tn-1].length = tracks[tn].start_lba - tracks[tn-1].start_lba; + + if((cdtoc.Descriptors[i].Control&4)==0) + { + tracks[tn].type = 1; + } + else if((cdtoc.Descriptors[i].Control&0xE)==4) + { + tracks[tn].type = CDVD_MODE1_TRACK; + } + else + { + tracks[tn].type = CDVD_MODE1_TRACK; + } + + fprintf(stderr,"Track %d: %d mins %d secs %d frames\n",tn,min,sec,frm); + } + else if(cdtoc.Descriptors[i].Point>0) + { + printf("Found code 0x%02x\n",cdtoc.Descriptors[i].Point); + } + break; + } + } + + tracks[etrack].length = tracks[0].length - tracks[etrack].start_lba; + } + + return 0; +} diff --git a/plugins/cdvdGigaherz/cdvd.rc b/plugins/cdvdGigaherz/cdvd.rc new file mode 100644 index 0000000000..97b8dec37f --- /dev/null +++ b/plugins/cdvdGigaherz/cdvd.rc @@ -0,0 +1,99 @@ +// Microsoft Visual C++ generated resource script. +// +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include "afxres.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// Spanish resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ESN) +#ifdef _WIN32 +LANGUAGE LANG_SPANISH, SUBLANG_SPANISH_MODERN +#pragma code_page(1252) +#endif //_WIN32 + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE +BEGIN + "resource.h\0" +END + +2 TEXTINCLUDE +BEGIN + "#include ""afxres.h""\r\n" + "\0" +END + +3 TEXTINCLUDE +BEGIN + "\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Dialog +// + +IDD_CONFIG DIALOGEX 0, 0, 184, 77 +STYLE DS_SETFONT | DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "cdvdGigaherz" +FONT 8, "MS Sans Serif", 0, 0, 0x0 +BEGIN + DEFPUSHBUTTON "OK",IDOK,75,59,50,14 + PUSHBUTTON "Cancel",IDCANCEL,129,59,50,14 + COMBOBOX IDC_DRIVE,15,20,160,64,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP + GROUPBOX "Source drive...",IDC_STATIC,7,7,172,48 +END + + +///////////////////////////////////////////////////////////////////////////// +// +// DESIGNINFO +// + +#ifdef APSTUDIO_INVOKED +GUIDELINES DESIGNINFO +BEGIN + IDD_CONFIG, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 179 + TOPMARGIN, 7 + BOTTOMMARGIN, 73 + END +END +#endif // APSTUDIO_INVOKED + +#endif // Spanish resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// + + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED + diff --git a/plugins/cdvdGigaherz/cdvdGigaherz2008.sln b/plugins/cdvdGigaherz/cdvdGigaherz2008.sln new file mode 100644 index 0000000000..73fecff3f5 --- /dev/null +++ b/plugins/cdvdGigaherz/cdvdGigaherz2008.sln @@ -0,0 +1,19 @@ +Microsoft Visual Studio Solution File, Format Version 10.00 +# Visual Studio 2008 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cdvdGigaherz2008", "cdvdGigaherz2008.vcproj", "{5CF88D5F-64DD-4EDC-9F1A-436BD502940A}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Release|Win32 = Release|Win32 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {5CF88D5F-64DD-4EDC-9F1A-436BD502940A}.Debug|Win32.ActiveCfg = Debug|Win32 + {5CF88D5F-64DD-4EDC-9F1A-436BD502940A}.Debug|Win32.Build.0 = Debug|Win32 + {5CF88D5F-64DD-4EDC-9F1A-436BD502940A}.Release|Win32.ActiveCfg = Release|Win32 + {5CF88D5F-64DD-4EDC-9F1A-436BD502940A}.Release|Win32.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/plugins/cdvdGigaherz/cdvdGigaherz2008.vcproj b/plugins/cdvdGigaherz/cdvdGigaherz2008.vcproj new file mode 100644 index 0000000000..e76034e841 --- /dev/null +++ b/plugins/cdvdGigaherz/cdvdGigaherz2008.vcproj @@ -0,0 +1,373 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/cdvdGigaherz/config.cpp b/plugins/cdvdGigaherz/config.cpp new file mode 100644 index 0000000000..2f1ba1a5db --- /dev/null +++ b/plugins/cdvdGigaherz/config.cpp @@ -0,0 +1,224 @@ +//GiGaHeRz SPU2 Driver +//Copyright (c) David Quintana +// +//This library is free software; you can redistribute it and/or +//modify it under the terms of the GNU Lesser General Public +//License as published by the Free Software Foundation; either +//version 2.1 of the License, or (at your option) any later version. +// +//This library is distributed in the hope that it will be useful, +//but WITHOUT ANY WARRANTY; without even the implied warranty of +//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +//Lesser General Public License for more details. +// +//You should have received a copy of the GNU Lesser General Public +//License along with this library; if not, write to the Free Software +//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +//#include "spu2.h" +#include +#include +#include "resource.h" + +#include "cdvd.h" + +// Config Vars + +// DEBUG + +char source_drive; +char source_file[256]; + +char CfgFile[]="inis\\cdvdGigaherz.ini"; + + + /*| Config File Format: |¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯*\ ++--+---------------------+------------------------+ +| | +| Option=Value | +| | +| | +| Boolean Values: TRUE,YES,1,T,Y mean 'true', | +| everything else means 'false'. | +| | +| All Values are limited to 255 chars. | +| | ++-------------------------------------------------+ + \*_____________________________________________*/ + + +void CfgWriteBool(char *Section, char*Name, char Value) { + char *Data=Value?"TRUE":"FALSE"; + + WritePrivateProfileString(Section,Name,Data,CfgFile); +} + +void CfgWriteInt(char *Section, char*Name, int Value) { + char Data[255]; + _itoa(Value,Data,10); + + WritePrivateProfileString(Section,Name,Data,CfgFile); +} + +void CfgWriteStr(char *Section, char*Name,char *Data) { + WritePrivateProfileString(Section,Name,Data,CfgFile); +} + +/*****************************************************************************/ + +char CfgReadBool(char *Section,char *Name,char Default) { + char Data[255]=""; + GetPrivateProfileString(Section,Name,"",Data,255,CfgFile); + Data[254]=0; + if(strlen(Data)==0) { + CfgWriteBool(Section,Name,Default); + return Default; + } + + if(strcmp(Data,"1")==0) return -1; + if(strcmp(Data,"Y")==0) return -1; + if(strcmp(Data,"T")==0) return -1; + if(strcmp(Data,"YES")==0) return -1; + if(strcmp(Data,"TRUE")==0) return -1; + return 0; +} + +int CfgReadInt(char *Section, char*Name,int Default) { + char Data[255]=""; + GetPrivateProfileString(Section,Name,"",Data,255,CfgFile); + Data[254]=0; + + if(strlen(Data)==0) { + CfgWriteInt(Section,Name,Default); + return Default; + } + + return atoi(Data); +} + +void CfgReadStr(char *Section, char*Name,char *Data,int DataSize,char *Default) { + int sl; + GetPrivateProfileString(Section,Name,"",Data,DataSize,CfgFile); + + if(strlen(Data)==0) { + sl=(int)strlen(Default); + strncpy(Data,Default,sl>255?255:sl); + CfgWriteStr(Section,Name,Data); + } +} + +/*****************************************************************************/ + +void ReadSettings() +{ + char temp[512]; + + CfgReadStr("Config","Source",temp,511,"-"); + source_drive=temp[0]; + + if(source_drive=='$') + strcpy_s(source_file,sizeof(source_file),temp+1); + else + source_file[0]=0; +} + +/*****************************************************************************/ + +void WriteSettings() +{ + char temp[511]; + + temp[0]=source_drive; + temp[1]=0; + + strcat(temp,source_file); + + CfgWriteStr("Config","Source",temp); +} + +char* path[] = { + "A:","B:","C:","D:","E:","F:","G:","H:","I:","J:","K:","L:","M:", + "N:","O:","P:","Q:","R:","S:","T:","U:","V:","W:","X:","Y:","Z:", +}; + +int n,s; + +#define SET_CHECK(idc,value) SendMessage(GetDlgItem(hWnd,idc),BM_SETCHECK,((value)==0)?BST_UNCHECKED:BST_CHECKED,0) +#define HANDLE_CHECK(idc,hvar) case idc: hvar=hvar?0:1; SendMessage(GetDlgItem(hWnd,idc),BM_SETCHECK,(hvar==1)?BST_CHECKED:BST_UNCHECKED,0); break +#define HANDLE_CHECKNB(idc,hvar)case idc: hvar=hvar?0:1; SendMessage(GetDlgItem(hWnd,idc),BM_SETCHECK,(hvar==1)?BST_CHECKED:BST_UNCHECKED,0) +#define ENABLE_CONTROL(idc,value) EnableWindow(GetDlgItem(hWnd,idc),value) + +BOOL CALLBACK ConfigProc(HWND hWnd,UINT uMsg,WPARAM wParam,LPARAM lParam) +{ + int wmId,wmEvent; + char temp[20]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + + switch(uMsg) + { + + case WM_PAINT: + return FALSE; + case WM_INITDIALOG: + + n=0;s=0; + + SendMessage(GetDlgItem(hWnd,IDC_DRIVE),CB_RESETCONTENT,0,0); + SendMessage(GetDlgItem(hWnd,IDC_DRIVE),CB_ADDSTRING,0,(LPARAM)"@ (No disc)"); + for(char d='A';d<='Z';d++) + { + if(GetDriveType(path[d-'A'])==DRIVE_CDROM) + { + n++; + + SendMessage(GetDlgItem(hWnd,IDC_DRIVE),CB_ADDSTRING,0,(LPARAM)path[d-'A']); + + if(source_drive==d) + { + s=n; + } + } + } + + SendMessage(GetDlgItem(hWnd,IDC_DRIVE),CB_SETCURSEL,s,0); + + break; + case WM_COMMAND: + wmId = LOWORD(wParam); + wmEvent = HIWORD(wParam); + // Parse the menu selections: + switch (wmId) + { + case IDOK: + GetDlgItemText(hWnd,IDC_DRIVE,temp,20); + temp[19]=0; + source_drive=temp[0]; + + WriteSettings(); + EndDialog(hWnd,0); + break; + case IDCANCEL: + EndDialog(hWnd,0); + break; + + default: + return FALSE; + } + break; + default: + return FALSE; + } + return TRUE; +} + +void configure() +{ + INT_PTR ret; + ReadSettings(); + ret=DialogBoxParam(hinst,MAKEINTRESOURCE(IDD_CONFIG),GetActiveWindow(),(DLGPROC)ConfigProc,1); + if(ret==-1) + { + MessageBoxEx(GetActiveWindow(),"Error Opening the config dialog.","OMG ERROR!",MB_OK,0); + return; + } + ReadSettings(); +} diff --git a/plugins/cdvdGigaherz/isofs/CDVDiso.cpp b/plugins/cdvdGigaherz/isofs/CDVDiso.cpp new file mode 100644 index 0000000000..72a3382f15 --- /dev/null +++ b/plugins/cdvdGigaherz/isofs/CDVDiso.cpp @@ -0,0 +1,825 @@ +/* + * Original code from libcdvd by Hiryu & Sjeep (C) 2002 + * Modified by Florin for PCSX2 emu + * Fixed CdRead by linuzappz + */ + +#include +#ifdef __LINUX__ +#define strnicmp strncasecmp +#endif + +#include "CDVDiso.h" +#include "CDVDisodrv.h" + +#include +#include +#define FALSE 0 +#define TRUE 1 + +struct dir_toc_data{ + unsigned int start_LBA; + unsigned int num_sectors; + unsigned int num_entries; + unsigned int current_entry; + unsigned int current_sector; + unsigned int current_sector_offset; + unsigned int inc_dirs; + unsigned char extension_list[128+1]; +}; + +//static u8 cdVolDescriptor[2048]; +static struct dir_toc_data getDirTocData; +static struct cdVolDesc CDVolDesc; + +extern s32 cdvdDirectReadSector(s32 first, s32 mode, char *buffer); + +void _splitpath2(const char *constpath, char *dir, char *fname){ + // 255 char max path-length is an ISO9660 restriction + // we must change this for Joliet or relaxed iso restriction support + static char pathcopy[1024+1]; + + char* slash; + + strncpy(pathcopy, constpath, 1024); + pathcopy[1024]=0; + + slash = strrchr (pathcopy, '/'); + + // if the path doesn't contain a '/' then look for a '\' + if (!slash) + slash = strrchr (pathcopy, (int)'\\'); + + // if a slash was found + if (slash != NULL) + { + // null terminate the path + slash[0] = 0; + // and copy the path into 'dir' + strncpy(dir, pathcopy, 1024); + dir[255]=0; + + // copy the filename into 'fname' + strncpy(fname, slash+1, 128); + fname[128]=0; + } + else + { + dir[0] = 0; + + strncpy(fname, pathcopy, 128); + fname[128]=0; + } + +} + +// Used in findfile +int strcasecmp(const char *s1, const char *s2){ + while (*s1 != '\0' && tolower(*s1) == tolower(*s2)) + { + s1++; + s2++; + } + + return tolower(*(unsigned char *) s1) - tolower(*(unsigned char *) s2); +} + +// Copy a TOC Entry from the CD native format to our tidier format +void TocEntryCopy(struct TocEntry* tocEntry, struct dirTocEntry* internalTocEntry){ + int i; + int filenamelen; + + tocEntry->fileSize = internalTocEntry->fileSize; + tocEntry->fileLBA = internalTocEntry->fileLBA; + tocEntry->fileProperties = internalTocEntry->fileProperties; + memcpy(tocEntry->date, internalTocEntry->dateStamp, 6); + tocEntry->date[6]=0; + + if (CDVolDesc.filesystemType == 2){ + // This is a Joliet Filesystem, so use Unicode to ISO string copy + + filenamelen = internalTocEntry->filenameLength/2; + + if (!(tocEntry->fileProperties & 0x02)){ + // strip the ;1 from the filename +// filenamelen -= 2;//(Florin) nah, do not strip ;1 + } + + for (i=0; i < filenamelen; i++) + tocEntry->filename[i] = internalTocEntry->filename[(i<<1)+1]; + + tocEntry->filename[filenamelen] = 0; + } + else{ + filenamelen = internalTocEntry->filenameLength; + + if (!(tocEntry->fileProperties & 0x02)){ + // strip the ;1 from the filename +// filenamelen -= 2;//(Florin) nah, do not strip ;1 + } + + // use normal string copy + strncpy((char*)tocEntry->filename,(char*)internalTocEntry->filename,128); + tocEntry->filename[filenamelen] = 0; + } +} + +// Check if a TOC Entry matches our extension list +int TocEntryCompare(char* filename, char* extensions){ + static char ext_list[129]; + + char* token; + + char* ext_point; + + strncpy(ext_list,extensions,128); + ext_list[128]=0; + + token = strtok( ext_list, " ," ); + while( token != NULL ) + { + // if 'token' matches extension of 'filename' + // then return a match + ext_point = strrchr(filename,'.'); + + if (_strnicmp(ext_point, token, strlen(token)) == 0) + return (TRUE); + + /* Get next token: */ + token = strtok( NULL, " ," ); + } + + // If not match found then return FALSE + return (FALSE); + +} + +#define CD_SECS 60 /* seconds per minute */ +#define CD_FRAMES 75 /* frames per second */ +#define CD_MSF_OFFSET 150 /* MSF numbering offset of first frame */ + +int CdRead(u32 lsn, u32 sectors, void *buf, CdRMode *mode){ + u32 i; + int rmode; + + switch (mode->datapattern) { + case CdSecS2048: + rmode = CDVD_MODE_2048; break; + case CdSecS2328: + rmode = CDVD_MODE_2328; break; + case CdSecS2340: + rmode = CDVD_MODE_2340; break; + default: + return 0; + } + + for (i=0; idatapattern) + { + case CdSecS2048: + if(cdvdDirectReadSector(lsn+i, rmode, (char*)buf+2048*i)) + return 0; + case CdSecS2328: + if(cdvdDirectReadSector(lsn+i, rmode, (char*)buf+2328*i)) + return 0; + case CdSecS2340: + if(cdvdDirectReadSector(lsn+i, rmode, (char*)buf+2340*i)) + return 0; + } + } + return 1; +} + +int DvdRead(u32 lsn, u32 sectors, void *buf, CdRMode *mode){ + u32 i; + + for (i=lsn; i<(lsn+sectors); i++) + { + ((u32*)buf)[0] = i + 0x30000; + + if(cdvdDirectReadSector(lsn+i, CDVD_MODE_2048,(char*)buf+12)) + return 0; + + buf=((u8*)buf)+2064; break; +// default: +// return 0; +// } + } + + return 1; +} + +/************************************************************** +* The functions below are not exported for normal file-system * +* operations, but are used by the file-system operations, and * +* may also be exported for use via RPC * +**************************************************************/ + +int CDVD_GetVolumeDescriptor(void){ + // Read until we find the last valid Volume Descriptor + int volDescSector; + + static struct cdVolDesc localVolDesc; + +#ifdef DEBUG + printf("CDVD_GetVolumeDescriptor called\n"); +#endif + + for (volDescSector = 16; volDescSector<20; volDescSector++) + { + CdRead(volDescSector,1,&localVolDesc,&cdReadMode); +// CdSync(0x00); + + // If this is still a volume Descriptor + if (strncmp((char*)localVolDesc.volID, "CD001", 5) == 0) + { + if ((localVolDesc.filesystemType == 1) || + (localVolDesc.filesystemType == 2)) + { + memcpy(&CDVolDesc, &localVolDesc, sizeof(struct cdVolDesc)); + } + } + else + break; + } + +#ifdef DEBUG + if (CDVolDesc.filesystemType == 1) + printf("CD FileSystem is ISO9660\n"); + else if (CDVolDesc.filesystemType == 2) + printf("CD FileSystem is Joliet\n"); + else printf("Could not detect CD FileSystem type\n"); +#endif +// CdStop(); + + return TRUE; +} + +int CDVD_findfile(char* fname, struct TocEntry* tocEntry){ + static char filename[128+1]; + static char pathname[1024+1]; + static char toc[2048]; + char* dirname; + + + static struct TocEntry localTocEntry; // used for internal checking only + + int found_dir; + + int num_dir_sectors; + int current_sector; + + int dir_lba; + + struct dirTocEntry* tocEntryPointer; + +#ifdef DEBUG + printf("CDVD_findfile called\n"); +#endif + + //make sure we have good cdReadMode + cdReadMode.trycount = 0; + cdReadMode.spindlctrl = CdSpinStm; + cdReadMode.datapattern = CdSecS2048; + + _splitpath2(fname, pathname, filename); + + // Find the TOC for a specific directory + if (CDVD_GetVolumeDescriptor() != TRUE){ +#ifdef RPC_LOG + RPC_LOG("Could not get CD Volume Descriptor\n"); +#endif + return -1; + } + + // Read the TOC of the root directory + if (CdRead(CDVolDesc.rootToc.tocLBA,1,toc,&cdReadMode) != TRUE){ +#ifdef RPC_LOG + RPC_LOG("Couldn't Read from CD !\n"); +#endif + return -1; + } + //CdSync(0x00); + + // point the tocEntryPointer at the first real toc entry + tocEntryPointer = (dirTocEntry*)toc; + + num_dir_sectors = (tocEntryPointer->fileSize+2047) >> 11; //round up fix + current_sector = tocEntryPointer->fileLBA; + + tocEntryPointer = (dirTocEntry*)(((char*)tocEntryPointer)+tocEntryPointer->length); + tocEntryPointer = (dirTocEntry*)(((char*)tocEntryPointer)+tocEntryPointer->length); + + + localTocEntry.fileLBA = CDVolDesc.rootToc.tocLBA; + // while (there are more dir names in the path) + dirname = strtok( pathname, "\\/" ); + + while( dirname != NULL ) + { + found_dir = FALSE; +/* + while(tocEntryPointer->length > 0) + { + // while there are still more directory entries then search through + // for the one we want + + if (tocEntryPointer->fileProperties & 0x02) + { + // Copy the CD format TOC Entry to our format + TocEntryCopy(&localTocEntry, tocEntryPointer); + + // If this TOC Entry is a directory, + // then see if it has the right name + if (strcasecmp(dirname,localTocEntry.filename) == 0) + { + // if the name matches then we've found the directory + found_dir = TRUE; + break; + } + } + + // point to the next entry + (char*)tocEntryPointer += tocEntryPointer->length; + } +*/ + while(1) + { + if ((tocEntryPointer->length == 0) || (((char*)tocEntryPointer-toc)>=2048)) + { + num_dir_sectors--; + + if (num_dir_sectors > 0) + { + // If we've run out of entries, but arent on the last sector + // then load another sector + + current_sector++; + if (CdRead(current_sector,1,toc,&cdReadMode) != TRUE) + { + return -1; + } +// CdSync(0x00); + + tocEntryPointer = (dirTocEntry*)toc; + } + else + { + // Couldnt find the directory, and got to end of directory + return -1; + } + } + + + if (tocEntryPointer->fileProperties & 0x02) + { + TocEntryCopy(&localTocEntry, tocEntryPointer); + + // If this TOC Entry is a directory, + // then see if it has the right name + if (strcmp(dirname,(char*)localTocEntry.filename) == 0) + { + // if the name matches then we've found the directory + found_dir = TRUE; + break; + } + } + + // point to the next entry + tocEntryPointer = (dirTocEntry*)(((char*)tocEntryPointer)+tocEntryPointer->length); + } + + // If we havent found the directory name we wanted then fail + if (found_dir != TRUE) + { + return -1; + } + + // Get next directory name + dirname = strtok( NULL, "\\/" ); + + // Read the TOC of the found subdirectory + if (CdRead(localTocEntry.fileLBA,1,toc,&cdReadMode) != TRUE) + { + return -1; + } +// CdSync(0x00); + + num_dir_sectors = (localTocEntry.fileSize+2047) >> 11; //round up fix + current_sector = localTocEntry.fileLBA; + + // and point the tocEntryPointer at the first real toc entry + tocEntryPointer = (dirTocEntry*)toc; + tocEntryPointer = (dirTocEntry*)(((char*)tocEntryPointer)+tocEntryPointer->length); + tocEntryPointer = (dirTocEntry*)(((char*)tocEntryPointer)+tocEntryPointer->length); + } + + tocEntryPointer = (dirTocEntry*)toc; + + num_dir_sectors = (tocEntryPointer->fileSize+2047) >> 11; //round up fix + dir_lba = tocEntryPointer->fileLBA; + + tocEntryPointer = (dirTocEntry*)toc; + tocEntryPointer = (dirTocEntry*)(((char*)tocEntryPointer)+tocEntryPointer->length); + tocEntryPointer = (dirTocEntry*)(((char*)tocEntryPointer)+tocEntryPointer->length); + + while (num_dir_sectors > 0) + { + while(tocEntryPointer->length != 0) + { + // Copy the CD format TOC Entry to our format + TocEntryCopy(&localTocEntry, tocEntryPointer); + + if ((_strnicmp((char*)localTocEntry.filename, filename, strlen(filename)) == 0) || + ((filename[strlen(filename)-2] == ';') && + (localTocEntry.filename[strlen((char*)localTocEntry.filename)-2] == ';') && + (_strnicmp((char*)localTocEntry.filename, filename, strlen(filename)-2) == 0))) + { + // if the filename matches then copy the toc Entry + tocEntry->fileLBA = localTocEntry.fileLBA; + tocEntry->fileProperties = localTocEntry.fileProperties; + tocEntry->fileSize = localTocEntry.fileSize; + + strcpy((char*)tocEntry->filename, (char*)localTocEntry.filename); + memcpy((char*)tocEntry->date, (char*)localTocEntry.date, 7); + +#ifdef DEBUG + printf("CDVD_findfile: found file\n"); +#endif + + return TRUE; + } + + tocEntryPointer = (dirTocEntry*)(((char*)tocEntryPointer)+tocEntryPointer->length); + } + + num_dir_sectors--; + + if (num_dir_sectors > 0) + { + dir_lba++; + + if (CdRead(dir_lba,1,toc,&cdReadMode) != TRUE){ + return -1; + } +// CdSync(0x00); + + tocEntryPointer = (dirTocEntry*)toc; + } + } + + return FALSE; +} + +// This is the RPC-ready function which takes the request to start the tocEntry retrieval +int CDVD_GetDir_RPC_request(char* pathname, char* extensions, unsigned int inc_dirs){ +// int dir_depth = 1; + static char toc[2048]; + char* dirname; + int found_dir; + int num_dir_sectors; + unsigned int toc_entry_num; + struct dirTocEntry* tocEntryPointer; + static struct TocEntry localTocEntry; + int current_sector; + + // store the extension list statically for the retrieve function + strncpy((char*)getDirTocData.extension_list, extensions, 128); + getDirTocData.extension_list[128]=0; + + getDirTocData.inc_dirs = inc_dirs; + + // Find the TOC for a specific directory + if (CDVD_GetVolumeDescriptor() != TRUE){ +#ifdef RPC_LOG + RPC_LOG("[RPC:cdvd] Could not get CD Volume Descriptor\n"); +#endif + return -1; + } + +#ifdef RPC_LOG + RPC_LOG("[RPC:cdvd] Getting Directory Listing for: \"%s\"\n", pathname); +#endif + + // Read the TOC of the root directory + if (CdRead(CDVolDesc.rootToc.tocLBA,1,toc,&cdReadMode) != TRUE){ +#ifdef RPC_LOG + RPC_LOG("[RPC: ] Couldn't Read from CD !\n"); +#endif + return -1; + } + //CdSync(0x00); + + // point the tocEntryPointer at the first real toc entry + tocEntryPointer = (dirTocEntry*)toc; + + num_dir_sectors = (tocEntryPointer->fileSize+2047) >> 11; + current_sector = tocEntryPointer->fileLBA; + + tocEntryPointer = (dirTocEntry*)(((char*)tocEntryPointer)+tocEntryPointer->length); + tocEntryPointer = (dirTocEntry*)(((char*)tocEntryPointer)+tocEntryPointer->length); + + // use strtok to get the next dir name + + // if there isnt one, then assume we want the LBA + // for the current one, and exit the while loop + + // if there is another dir name then increment dir_depth + // and look through dir table entries until we find the right name + // if we dont find the right name + // before finding an entry at a higher level (lower num), then return nothing + + localTocEntry.fileLBA = CDVolDesc.rootToc.tocLBA; + + // while (there are more dir names in the path) + dirname = strtok( pathname, "\\/" ); + while( dirname != NULL ){ + found_dir = FALSE; + + while(1){ + if ((tocEntryPointer->length == 0) || (((char*)tocEntryPointer-toc)>=2048)) { + num_dir_sectors--; + + if (num_dir_sectors > 0){ + // If we've run out of entries, but arent on the last sector + // then load another sector + + current_sector++; + if (CdRead(current_sector,1,toc,&cdReadMode) != TRUE){ +#ifdef RPC_LOG + RPC_LOG("[RPC: ] Couldn't Read from CD !\n"); +#endif + return -1; + } + //CdSync(0x00); + + tocEntryPointer = (dirTocEntry*)toc; + } + else{ + // Couldnt find the directory, and got to end of directory + return -1; + } + } + + if (tocEntryPointer->fileProperties & 0x02){ + TocEntryCopy(&localTocEntry, tocEntryPointer); + + // If this TOC Entry is a directory, + // then see if it has the right name + if (strcmp(dirname,(char*)localTocEntry.filename) == 0){ + // if the name matches then we've found the directory + found_dir = TRUE; +#ifdef RPC_LOG + RPC_LOG("[RPC: ] Found directory %s in subdir at sector %d\n",dirname,current_sector); + RPC_LOG("[RPC: ] LBA of found subdirectory = %d\n",localTocEntry.fileLBA); +#endif + break; + } + } + + // point to the next entry + tocEntryPointer = (dirTocEntry*)(((char*)tocEntryPointer)+tocEntryPointer->length); + } + + // If we havent found the directory name we wanted then fail + if (found_dir != TRUE) + return -1; + + // Get next directory name + dirname = strtok( NULL, "\\/" ); + + // Read the TOC of the found subdirectory + if (CdRead(localTocEntry.fileLBA,1,toc,&cdReadMode) != TRUE){ +#ifdef RPC_LOG + RPC_LOG("[RPC: ] Couldn't Read from CD !\n"); +#endif + return -1; + } + //CdSync(0x00); + + num_dir_sectors = (localTocEntry.fileSize+2047) >> 11; + current_sector = localTocEntry.fileLBA; + + // and point the tocEntryPointer at the first real toc entry + tocEntryPointer = (dirTocEntry*)toc; + tocEntryPointer = (dirTocEntry*)(((char*)tocEntryPointer)+tocEntryPointer->length); + tocEntryPointer = (dirTocEntry*)(((char*)tocEntryPointer)+tocEntryPointer->length); + } + + // We know how much data we need to read in from the DirTocHeader + // but we need to read in at least 1 sector before we can get this value + + // Now we need to COUNT the number of entries (dont do anything with info at this point) + // so set the tocEntryPointer to point to the first actual file entry + + // This is a bit of a waste of reads since we're not actually copying the data out yet, + // but we dont know how big this TOC might be, so we cant allocate a specific size + + tocEntryPointer = (dirTocEntry*)toc; + + // Need to STORE the start LBA and number of Sectors, for use by the retrieve func. + getDirTocData.start_LBA = localTocEntry.fileLBA; + getDirTocData.num_sectors = (tocEntryPointer->fileSize+2047) >> 11; + getDirTocData.num_entries = 0; + getDirTocData.current_entry = 0; + getDirTocData.current_sector = getDirTocData.start_LBA; + getDirTocData.current_sector_offset = 0; + + num_dir_sectors = getDirTocData.num_sectors; + + tocEntryPointer = (dirTocEntry*)toc; + tocEntryPointer = (dirTocEntry*)(((char*)tocEntryPointer)+tocEntryPointer->length); + tocEntryPointer = (dirTocEntry*)(((char*)tocEntryPointer)+tocEntryPointer->length); + + toc_entry_num=0; + + while(1){ + if ((tocEntryPointer->length == 0) || (((char*)tocEntryPointer-toc)>=2048)){ + // decrease the number of dirs remaining + num_dir_sectors--; + + if (num_dir_sectors > 0){ + // If we've run out of entries, but arent on the last sector + // then load another sector + getDirTocData.current_sector++; + + if (CdRead(getDirTocData.current_sector,1,toc,&cdReadMode) != TRUE){ +#ifdef RPC_LOG + RPC_LOG("[RPC: ] Couldn't Read from CD !\n"); +#endif + return -1; + } + //CdSync(0x00); + + tocEntryPointer = (dirTocEntry*)toc; + +// continue; + } + else{ + getDirTocData.num_entries = toc_entry_num; + getDirTocData.current_sector = getDirTocData.start_LBA; + return (toc_entry_num); + } + } + + // We've found a file/dir in this directory + // now check if it matches our extension list (if there is one) + TocEntryCopy(&localTocEntry, tocEntryPointer); + + if (localTocEntry.fileProperties & 0x02){ + // If this is a subdir, then check if we want to include subdirs + if (getDirTocData.inc_dirs){ + toc_entry_num++; + } + } + else{ + if (strlen((char*)getDirTocData.extension_list) > 0){ + if (TocEntryCompare((char*)localTocEntry.filename, (char*)getDirTocData.extension_list) == TRUE){ + // increment the number of matching entries counter + toc_entry_num++; + } + } + else{ + toc_entry_num++; + } + } + + tocEntryPointer = (dirTocEntry*)(((char*)tocEntryPointer)+tocEntryPointer->length); + + } + + + // THIS SHOULD BE UNREACHABLE - + // since we are trying to count ALL matching entries, rather than upto a limit + + + // STORE total number of TOC entries + getDirTocData.num_entries = toc_entry_num; + getDirTocData.current_sector = getDirTocData.start_LBA; + + + // we've reached the toc entry limit, so return how many we've done + return (toc_entry_num); + +} + +// This function can be called repeatedly after CDVD_GetDir_RPC_request to get the actual entries +// buffer (tocEntry) must be 18KB in size, and this will be filled with a maximum of 128 entries in one go +int CDVD_GetDir_RPC_get_entries(struct TocEntry tocEntry[], int req_entries){ + static char toc[2048]; + int toc_entry_num; + + struct dirTocEntry* tocEntryPointer; + + if (CdRead(getDirTocData.current_sector,1,toc,&cdReadMode) != TRUE){ +#ifdef RPC_LOG + RPC_LOG("[RPC:cdvd] Couldn't Read from CD !\n"); +#endif + return -1; + } + //CdSync(0x00); + + if (getDirTocData.current_entry == 0){ + // if this is the first read then make sure we point to the first real entry + tocEntryPointer = (dirTocEntry*)toc; + tocEntryPointer = (dirTocEntry*)(((char*)tocEntryPointer)+tocEntryPointer->length); + tocEntryPointer = (dirTocEntry*)(((char*)tocEntryPointer)+tocEntryPointer->length); + + getDirTocData.current_sector_offset = (char*)tocEntryPointer - toc; + } + else{ + tocEntryPointer = (dirTocEntry*)(toc + getDirTocData.current_sector_offset); + } + + if (req_entries > 128) + req_entries = 128; + + for (toc_entry_num=0; toc_entry_num < req_entries;){ + if ((tocEntryPointer->length == 0) || (getDirTocData.current_sector_offset >= 2048)){ + // decrease the number of dirs remaining + getDirTocData.num_sectors--; + + if (getDirTocData.num_sectors > 0){ + // If we've run out of entries, but arent on the last sector + // then load another sector + getDirTocData.current_sector++; + + if (CdRead(getDirTocData.current_sector,1,toc,&cdReadMode) != TRUE){ +#ifdef RPC_LOG + RPC_LOG("[RPC:cdvd] Couldn't Read from CD !\n"); +#endif + return -1; + } + //CdSync(0x00); + + getDirTocData.current_sector_offset = 0; + tocEntryPointer = (dirTocEntry*)(toc + getDirTocData.current_sector_offset); + +// continue; + } + else{ + return (toc_entry_num); + } + } + + // This must be incremented even if the filename doesnt match extension list + getDirTocData.current_entry++; + + // We've found a file in this directory + // now check if it matches our extension list (if there is one) + + // Copy the entry regardless, as it makes the comparison easier + // if it doesn't match then it will just be overwritten + TocEntryCopy(&tocEntry[toc_entry_num], tocEntryPointer); + + if (tocEntry[toc_entry_num].fileProperties & 0x02){ + // If this is a subdir, then check if we want to include subdirs + if (getDirTocData.inc_dirs) { + toc_entry_num++; + } + + getDirTocData.current_sector_offset += tocEntryPointer->length; + tocEntryPointer = (dirTocEntry*)(toc + getDirTocData.current_sector_offset); + } + else{ + if (strlen((char*)getDirTocData.extension_list) > 0){ + if (TocEntryCompare((char*)tocEntry[toc_entry_num].filename, (char*)getDirTocData.extension_list) == TRUE){ + // increment the number of matching entries counter + toc_entry_num++; + } + + getDirTocData.current_sector_offset += tocEntryPointer->length; + tocEntryPointer = (dirTocEntry*)(toc + getDirTocData.current_sector_offset); + + } + else{ + toc_entry_num++; + getDirTocData.current_sector_offset += tocEntryPointer->length; + tocEntryPointer = (dirTocEntry*)(toc + getDirTocData.current_sector_offset); + } + } +/* + if (strlen(getDirTocData.extension_list) > 0) + { + if (TocEntryCompare(tocEntry[toc_entry_num].filename, getDirTocData.extension_list) == TRUE) + { + + // increment this here, rather than in the main for loop + // since this should count the number of matching entries + toc_entry_num++; + } + + getDirTocData.current_sector_offset += tocEntryPointer->length; + (char*)tocEntryPointer = toc + getDirTocData.current_sector_offset; + } + else + { + toc_entry_num++; + getDirTocData.current_sector_offset += tocEntryPointer->length; + (char*)tocEntryPointer = toc + getDirTocData.current_sector_offset; + } +*/ + } + return (toc_entry_num); +} diff --git a/plugins/cdvdGigaherz/isofs/CDVDiso.h b/plugins/cdvdGigaherz/isofs/CDVDiso.h new file mode 100644 index 0000000000..72b0552280 --- /dev/null +++ b/plugins/cdvdGigaherz/isofs/CDVDiso.h @@ -0,0 +1,131 @@ +/* + * Original code from libcdvd by Hiryu & Sjeep (C) 2002 + * Modified by Florin for PCSX2 emu + */ + +#ifndef __CDVDISO_H__ +#define __CDVDISO_H__ + +#include "CDVDlib.h" + +int CDVD_findfile(char* fname, struct TocEntry* tocEntry); +int CDVD_GetDir_RPC_request(char* pathname, char* extensions, unsigned int inc_dirs); +int CDVD_GetDir_RPC_get_entries(struct TocEntry tocEntry[], int req_entries); + +#if defined(__WIN32__) +#pragma pack(1) +#endif + +struct rootDirTocHeader +{ + u16 length; //+00 + u32 tocLBA; //+02 + u32 tocLBA_bigend; //+06 + u32 tocSize; //+0A + u32 tocSize_bigend; //+0E + u8 dateStamp[8]; //+12 + u8 reserved[6]; //+1A + u8 reserved2; //+20 + u8 reserved3; //+21 +#if defined(__WIN32__) +}; //+22 +#else +} __attribute__((packed)); +#endif + +struct asciiDate +{ + char year[4]; + char month[2]; + char day[2]; + char hours[2]; + char minutes[2]; + char seconds[2]; + char hundreths[2]; + char terminator[1]; +#if defined(__WIN32__) +}; +#else +} __attribute__((packed)); +#endif + +struct cdVolDesc +{ + u8 filesystemType; // 0x01 = ISO9660, 0x02 = Joliet, 0xFF = NULL + u8 volID[5]; // "CD001" + u8 reserved2; + u8 reserved3; + u8 sysIdName[32]; + u8 volName[32]; // The ISO9660 Volume Name + u8 reserved5[8]; + u32 volSize; // Volume Size + u32 volSizeBig; // Volume Size Big-Endian + u8 reserved6[32]; + u32 unknown1; + u32 unknown1_bigend; + u16 volDescSize; //+80 + u16 volDescSize_bigend; //+82 + u32 unknown3; //+84 + u32 unknown3_bigend; //+88 + u32 priDirTableLBA; // LBA of Primary Dir Table //+8C + u32 reserved7; //+90 + u32 secDirTableLBA; // LBA of Secondary Dir Table //+94 + u32 reserved8; //+98 + struct rootDirTocHeader rootToc; + u8 volSetName[128]; + u8 publisherName[128]; + u8 preparerName[128]; + u8 applicationName[128]; + u8 copyrightFileName[37]; + u8 abstractFileName[37]; + u8 bibliographyFileName[37]; + struct asciiDate creationDate; + struct asciiDate modificationDate; + struct asciiDate effectiveDate; + struct asciiDate expirationDate; + u8 reserved10; + u8 reserved11[1166]; +#if defined(__WIN32__) +}; +#else +} __attribute__((packed)); +#endif + +struct dirTableEntry +{ + u8 dirNameLength; + u8 reserved; + u32 dirTOCLBA; + u16 dirDepth; + u8 dirName[32]; +#if defined(__WIN32__) +}; +#else +} __attribute__((packed)); +#endif + +struct dirTocEntry +{ + short length; + unsigned int fileLBA; + unsigned int fileLBA_bigend; + unsigned int fileSize; + unsigned int fileSize_bigend; + unsigned char dateStamp[6]; + unsigned char reserved1; + unsigned char fileProperties; + unsigned char reserved2[6]; + unsigned char filenameLength; + unsigned char filename[128]; +#if defined(__WIN32__) +}; +#else +} __attribute__((packed)); +#endif // This is the internal format on the CD +// TocEntry structure contains only the important stuff needed for export + +#if defined(__WIN32__) +#pragma pack() +#endif + +#endif//__CDVDISO_H__ diff --git a/plugins/cdvdGigaherz/isofs/CDVDisodrv.cpp b/plugins/cdvdGigaherz/isofs/CDVDisodrv.cpp new file mode 100644 index 0000000000..f02b21a362 --- /dev/null +++ b/plugins/cdvdGigaherz/isofs/CDVDisodrv.cpp @@ -0,0 +1,269 @@ +/* + * Original code from libcdvd by Hiryu & Sjeep (C) 2002 + * Modified by Florin for PCSX2 emu + */ + +#include + +#include "CDVDlib.h" +#include "CDVDiso.h" +#include "CDVDisodrv.h" + +#include + +#define FALSE 0 +#define TRUE 1 + +#define min(x,y) (((y)<(x))?(x):(y)) + +CdRMode cdReadMode; + +struct fdtable{ +//int fd; + int fileSize; + int LBA; + int filePos; +}; + +static struct fdtable fd_table[16]; +static int fd_used[16]; +static int files_open=0; +static int inited=FALSE; + +/************************************************************* +* The functions below are the normal file-system operations, * +* used to provide a standard filesystem interface * +*************************************************************/ + +////////////////////////////////////////////////////////////////////// +// CDVDFS_init +// called by 80000592 sceCdInit() +////////////////////////////////////////////////////////////////////// +void CDVDFS_init(){ + +#ifdef RPC_LOG + RPC_LOG("[CDVDisodrv:init] CDVD Filesystem v1.00\n"); + RPC_LOG("[CDVDisodrv ] \tby A.Lee (aka Hiryu) & Nicholas Van Veen (aka Sjeep)\n"); + RPC_LOG("[CDVDisodrv ] Initializing '%s' file driver.\n", "cdfs"); +#endif + + //CdInit(0); already called by plugin loading system ;) + + cdReadMode.trycount = 0; + cdReadMode.spindlctrl = CdSpinStm; + cdReadMode.datapattern = CdSecS2048; //isofs driver only needs + //2KB sectors + + memset(fd_table, 0, sizeof(fd_table)); + memset(fd_used, 0, 16*sizeof(int)); + + inited = TRUE; + + return; +} + +////////////////////////////////////////////////////////////////////// +// CDVDFS_open +// called by 80000001 fileio_open for devices: "cdrom:", "cdrom0:" +////////////////////////////////////////////////////////////////////// +int CDVDFS_open(char *name, int mode){ + register int j; + static struct TocEntry tocEntry; + + // check if the file exists + if (CDVD_findfile(name, &tocEntry) != TRUE) + return -1; + + if(mode != 1) return -2; //SCE_RDONLY + + // set up a new file descriptor + for(j=0; j < 16; j++) if(fd_used[j] == 0) break; + if(j >= 16) return -3; + + fd_used[j] = 1; + files_open++; + +#ifdef RPC_LOG + RPC_LOG("[CDVDisodrv:open] internal fd=%d\n", j); +#endif + + fd_table[j].fileSize = tocEntry.fileSize; + fd_table[j].LBA = tocEntry.fileLBA; + fd_table[j].filePos = 0; + +#ifdef RPC_LOG + RPC_LOG("[CDVDisodrv ] tocEntry.fileSize = %d\n",tocEntry.fileSize); +#endif + + return j; +} + +////////////////////////////////////////////////////////////////////// +// CDVDFS_lseek +// called by 80000001 fileio_lseek for devices: "cdrom:", "cdrom0:" +////////////////////////////////////////////////////////////////////// +int CDVDFS_lseek(int fd, int offset, int whence){ + + if ((fd >= 16) || (fd_used[fd]==0)){ +#ifdef RPC_LOG + RPC_LOG("[CDVDisodrv:lseek] ERROR: File does not appear to be open!\n"); +#endif + return -1; + } + + switch(whence){ + case SEEK_SET: + fd_table[fd].filePos = offset; + break; + + case SEEK_CUR: + fd_table[fd].filePos += offset; + break; + + case SEEK_END: + fd_table[fd].filePos = fd_table[fd].fileSize + offset; + break; + + default: + return -1; + } + + if (fd_table[fd].filePos < 0) + fd_table[fd].filePos = 0; + + if (fd_table[fd].filePos > fd_table[fd].fileSize) + fd_table[fd].filePos = fd_table[fd].fileSize; + + return fd_table[fd].filePos; +} + +////////////////////////////////////////////////////////////////////// +// CDVDFS_read +// called by 80000001 fileio_read for devices: "cdrom:", "cdrom0:", "cdfs:" +////////////////////////////////////////////////////////////////////// +int CDVDFS_read( int fd, char *buffer, int size ){ +// int start_sector; + int off_sector; +// int num_sectors; + + //static char local_buffer[2024*2048]; //4MB + static char lb[2048]; //2KB + //Start, Aligned, End + int ssector, asector, esector; + int ssize=0, asize, esize; + + if ((fd >= 16) || (fd_used[fd]==0)){ +#ifdef RPC_LOG + RPC_LOG("[CDVDisodrv:read] ERROR: File does not appear to be open!\n"); +#endif + return -1; + } + + // A few sanity checks + if (fd_table[fd].filePos > fd_table[fd].fileSize){ + // We cant start reading from past the beginning of the file + return 0; // File exists but we couldnt read anything from it + } + + if ((fd_table[fd].filePos + size) > fd_table[fd].fileSize) + size = fd_table[fd].fileSize - fd_table[fd].filePos; + + // Now work out where we want to start reading from + asector = ssector = fd_table[fd].LBA + (fd_table[fd].filePos >> 11); + off_sector = (fd_table[fd].filePos & 0x7FF); + if (off_sector){ + ssize = min(2048 - off_sector, size); + size -= ssize; + asector++; + } + asize = size & 0xFFFFF800; + esize = size & 0x000007FF; + esector=asector + (asize >> 11); + size += ssize; + +#ifdef RPC_LOG + RPC_LOG("[CDVDisodrv:read] read sectors 0x%08X to 0x%08X\n", ssector, esector-(esize==0)); +#endif + + if (ssize){ if (CdRead(ssector, 1, lb, &cdReadMode) != TRUE){ +#ifdef RPC_LOG + RPC_LOG("[CDVDisodrv: ] Couldn't Read from file for some reason\n"); +#endif + return 0; + } + memcpy(buffer, lb + off_sector, ssize); + } + if (asize) if (CdRead(asector, asize >> 11, buffer+ssize, &cdReadMode) != TRUE){ +#ifdef RPC_LOG + RPC_LOG("[CDVDisodrv: ] Couldn't Read from file for some reason\n"); +#endif + return 0; + } + if (esize){ if (CdRead(esector, 1, lb, &cdReadMode) != TRUE){ +#ifdef RPC_LOG + RPC_LOG("[CDVDisodrv: ] Couldn't Read from file for some reason\n"); +#endif + return 0; + } + memcpy(buffer+ssize+asize, lb, esize); + } +/*********************** + // Now work out where we want to start reading from + start_sector = fd_table[fd].LBA + (fd_table[fd].filePos >> 11); + off_sector = (fd_table[fd].filePos & 0x7FF); + num_sectors = ((off_sector + size) >> 11) + 1; + +#ifdef RPC_LOG + RPC_LOG("[CDVDisodrv:read] read sectors 0x%08X to 0x%08X\n",start_sector,start_sector+num_sectors); +#endif + + // Read the data (we only ever get 16KB max request at once) + if (CdRead(start_sector, num_sectors, local_buffer, &cdReadMode) != TRUE){ +#ifdef RPC_LOG + //RPC_LOG("sector = %d, start sector = %d\n",sector,start_sector); + RPC_LOG("[CDVDisodrv: ] Couldn't Read from file for some reason\n"); +#endif + return 0; + } + //CdSync(0); hm, a wait function maybe... + + memcpy(buffer,local_buffer+off_sector,size); +**************************/ + fd_table[fd].filePos += size; + + return (size); +} + +////////////////////////////////////////////////////////////////////// +// CDVDFS_write +// called by 80000001 fileio_write for devices: "cdrom:", "cdrom0:" +// hehe, this ain't a CD writing option :D +////////////////////////////////////////////////////////////////////// +int CDVDFS_write( int fd, char * buffer, int size ){ + if(size == 0) return 0; + else return -1; +} + +////////////////////////////////////////////////////////////////////// +// CDVDFS_close +// called by 80000001 fileio_close for devices: "cdrom:", "cdrom0:" +////////////////////////////////////////////////////////////////////// +int CDVDFS_close( int fd){ + + if ((fd >= 16) || (fd_used[fd]==0)){ +#ifdef RPC_LOG + RPC_LOG("[CDVDisodrv:close] ERROR: File does not appear to be open!\n"); +#endif + return -1; + } + +#ifdef RPC_LOG + RPC_LOG("[CDVDisodrv:close] internal fd %d\n", fd); +#endif + + fd_used[fd] = 0; + files_open--; + + return 0; +} + diff --git a/plugins/cdvdGigaherz/isofs/CDVDisodrv.h b/plugins/cdvdGigaherz/isofs/CDVDisodrv.h new file mode 100644 index 0000000000..dcf8545a86 --- /dev/null +++ b/plugins/cdvdGigaherz/isofs/CDVDisodrv.h @@ -0,0 +1,22 @@ +/* + * Original code from libcdvd by Hiryu & Sjeep (C) 2002 + * Modified by Florin for PCSX2 emu + */ + +#ifndef __CDVDISODRV_H__ +#define __CDVDISODRV_H__ + +//#include "Common.h" +#include "CDVDlib.h" + +extern CdRMode cdReadMode; + +/* Filing-system exported functions */ +void CDVDFS_init(); +int CDVDFS_open(char *name, int mode); +int CDVDFS_lseek(int fd, int offset, int whence); +int CDVDFS_read( int fd, char * buffer, int size ); +int CDVDFS_write( int fd, char * buffer, int size ); +int CDVDFS_close( int fd); + +#endif//__CDVDISODRV_H__ diff --git a/plugins/cdvdGigaherz/isofs/CDVDlib.h b/plugins/cdvdGigaherz/isofs/CDVDlib.h new file mode 100644 index 0000000000..5d7e27610b --- /dev/null +++ b/plugins/cdvdGigaherz/isofs/CDVDlib.h @@ -0,0 +1,187 @@ +/* + * Original code from libcdvd by Hiryu & Sjeep (C) 2002 + * Linux kernel headers + * Modified by Florin for PCSX2 emu + */ + +#ifndef _CDVDLIB_H +#define _CDVDLIB_H + +#define __WIN32__ +#define CDVDdefs +#include + +// Macros for READ Data pattan +#define CdSecS2048 0 // sector size 2048 +#define CdSecS2328 1 // sector size 2328 +#define CdSecS2340 2 // sector size 2340 + +//#define CD_FRAMESIZE_RAW1 (CD_FRAMESIZE_RAW-CD_SYNC_SIZE) /*2340*/ +//#define CD_FRAMESIZE_RAW0 (CD_FRAMESIZE_RAW-CD_SYNC_SIZE-CD_HEAD_SIZE) /*2336*/ +//#define CD_HEAD_SIZE 4 /* header (address) bytes per raw data frame */ +//#define CD_SUBHEAD_SIZE 8 /* subheader bytes per raw XA data frame */ +//#define CD_XA_HEAD (CD_HEAD_SIZE+CD_SUBHEAD_SIZE) /* "before data" part of raw XA frame */ + +/* + * A CD-ROM physical sector size is 2048, 2052, 2056, 2324, 2332, 2336, + * 2340, or 2352 bytes long. + * Sector types of the standard CD-ROM data formats: + * + * format sector type user data size (bytes) + * ----------------------------------------------------------------------------- + * 1 (Red Book) CD-DA 2352 (CD_FRAMESIZE_RAW) + * 2 (Yellow Book) Mode1 Form1 2048 (CD_FRAMESIZE) + * 3 (Yellow Book) Mode1 Form2 2336 (CD_FRAMESIZE_RAW0) + * 4 (Green Book) Mode2 Form1 2048 (CD_FRAMESIZE) + * 5 (Green Book) Mode2 Form2 2328 (2324+4 spare bytes) + * + * + * The layout of the standard CD-ROM data formats: + * ----------------------------------------------------------------------------- + * - audio (red): | audio_sample_bytes | + * | 2352 | + * + * - data (yellow, mode1): | sync - head - data - EDC - zero - ECC | + * | 12 - 4 - 2048 - 4 - 8 - 276 | + * + * - data (yellow, mode2): | sync - head - data | + * | 12 - 4 - 2336 | + * + * - XA data (green, mode2 form1): | sync - head - sub - data - EDC - ECC | + * | 12 - 4 - 8 - 2048 - 4 - 276 | + * + * - XA data (green, mode2 form2): | sync - head - sub - data - Spare | + * | 12 - 4 - 8 - 2324 - 4 | + * + */ + +// Macros for Spindle control +#define CdSpinMax 0 +#define CdSpinNom 1 // Starts reading data at maximum rotational velocity and if a read error occurs, the rotational velocity is reduced. +#define CdSpinStm 0 // Recommended stream rotation speed. + +// Macros for TrayReq +#define CdTrayOpen 0 +#define CdTrayClose 1 +#define CdTrayCheck 2 + +/* + * Macros for sceCdGetDiskType() //comments translated from japanese;) + */ +#define SCECdIllgalMedia 0xff + /* ILIMEDIA (Illegal Media) + A non-PS / non-PS2 Disc. */ +#define SCECdDVDV 0xfe + /* DVDV (DVD Video) + A non-PS / non-PS2 Disc, but a DVD Video Disc */ +#define SCECdCDDA 0xfd + /* CDDA (CD DA) + A non-PS / non-PS2 Disc that include a DA track */ +#define SCECdPS2DVD 0x14 + /* PS2DVD PS2 consumer DVD. */ +#define SCECdPS2CDDA 0x13 + /* PS2CDDA PS2 consumer CD that includes a DA track */ +#define SCECdPS2CD 0x12 + /* PS2CD PS2 consumer CD that does not include a DA track */ +#define SCECdPSCDDA 0x11 + /* PSCDDA PS CD that includes a DA track */ +#define SCECdPSCD 0x10 + /* PSCD PS CD that does not include a DA track */ +#define SCECdDETCT 0x01 + /* DETCT (Detecting) Disc distinction action */ +#define SCECdNODISC 0x00 + /* NODISC (No disc) No disc entered */ + +/* + * Media mode + */ +#define SCECdCD 1 +#define SCECdDVD 2 + +typedef struct { + u8 stat; // 0: normal. Any other: error + u8 second; // second (BCD value) + u8 minute; // minute (BCD value) + u8 hour; // hour (BCD value) + u8 week; // week (BCD value) + u8 day; // day (BCD value) + u8 month; // month (BCD value) + u8 year; // year (BCD value) +} CdCLOCK; + +typedef struct { + u32 lsn; // Logical sector number of file + u32 size; // File size (in bytes) + char name[16]; // Filename + u8 date[8]; // 1th: Seconds + // 2th: Minutes + // 3th: Hours + // 4th: Date + // 5th: Month + // 6th 7th: Year (4 digits) +} CdlFILE; + +typedef struct { + u8 minute; // Minutes + u8 second; // Seconds + u8 sector; // Sector + u8 track; // Track number +} CdlLOCCD; + +typedef struct { + u8 trycount; // Read try count (No. of error retries + 1) (0 - 255) + u8 spindlctrl; // SCECdSpinStm: Recommended stream rotation speed. + // SCECdSpinNom: Starts reading data at maximum rotational velocity and if a read error occurs, the rotational velocity is reduced. + u8 datapattern; // SCECdSecS2048: Data size 2048 bytes + // SCECdSecS2328: 2328 bytes + // SCECdSecS2340: 2340 bytes + u8 pad; // Padding data produced by alignment. +} CdRMode; + +#if defined(__WIN32__) +#pragma pack(1) +#endif + +struct TocEntry +{ + u32 fileLBA; + u32 fileSize; + u8 fileProperties; + u8 padding1[3]; + u8 filename[128+1]; + u8 date[7]; +#if defined(__WIN32__) +}; +#else +} __attribute__((packed)); +#endif + +#if defined(__WIN32__) +#pragma pack() +#endif + +int CDVD_findfile(char* fname, struct TocEntry* tocEntry); +/* +int CdBreak(void); +int CdCallback( void (*func)() ); +int CdDiskReady(int mode); +int CdGetDiskType(void); +int CdGetError(void); +u32 CdGetReadPos(void); +int CdGetToc(u8 *toc); +int CdInit(int init_mode); +CdlLOCCD *CdIntToPos(int i, CdlLOCCD *p); +int CdPause(void); +int CdPosToInt(CdlLOCCD *p);*/ +int CdRead(u32 lsn, u32 sectors, void *buf, CdRMode *mode); +int DvdRead(u32 lsn, u32 sectors, void *buf, CdRMode *mode); +/*int CdReadClock(CdCLOCK *rtc); +int CdSearchFile (CdlFILE *fp, const char *name); +int CdSeek(u32 lsn); +int CdStandby(void); +int CdStatus(void); +int CdStop(void); +int CdSync(int mode); +int CdTrayReq(int mode, u32 *traycnt); +*/ +#endif // _CDVDLIB_H diff --git a/plugins/cdvdGigaherz/mciTOC.cpp b/plugins/cdvdGigaherz/mciTOC.cpp new file mode 100644 index 0000000000..a5a8ded462 --- /dev/null +++ b/plugins/cdvdGigaherz/mciTOC.cpp @@ -0,0 +1,119 @@ +/* General ioctl() CD-ROM command function */ +#include "CDVD.h" + +#define MSF_TO_LBA(m,s,f) ((m*60+s)*75+f-150) + +int MCI_CDioctl(int id, UINT msg, DWORD flags, void *arg) +{ + MCIERROR mci_error; + + mci_error = mciSendCommand(id, msg, flags, (DWORD)arg); + if ( mci_error ) { + char error[256]; + + mciGetErrorString(mci_error, error, 256); + printf(" * CDVD mciTOC: mciSendCommand() error: %s", error); + } + return(!mci_error ? 0 : -1); +} + +int MCI_CDGetTOC(char driveLetter) +{ + MCI_OPEN_PARMS mci_open; + MCI_SET_PARMS mci_set; + MCI_STATUS_PARMS mci_status; + + char device[3]; + int i, okay; + DWORD flags; + + okay = 0; + + int cdromId; + + device[0] = driveLetter; + device[1] = ':'; + device[2] = '\0'; + + /* Open the requested device */ + mci_open.lpstrDeviceType = (LPCSTR) MCI_DEVTYPE_CD_AUDIO; + mci_open.lpstrElementName = device; + flags = (MCI_OPEN_TYPE|MCI_OPEN_SHAREABLE|MCI_OPEN_TYPE_ID|MCI_OPEN_ELEMENT); + if ( MCI_CDioctl(0, MCI_OPEN, flags, &mci_open) < 0 ) + { + flags &= ~MCI_OPEN_SHAREABLE; + if ( MCI_CDioctl(0, MCI_OPEN, flags, &mci_open) < 0 ) + { + return(-1); + } + } + cdromId = mci_open.wDeviceID; + + /* Set the minute-second-frame time format */ + mci_set.dwTimeFormat = MCI_FORMAT_MSF; + MCI_CDioctl(cdromId, MCI_SET, MCI_SET_TIME_FORMAT, &mci_set); + + /* Request number of tracks */ + mci_status.dwItem = MCI_STATUS_NUMBER_OF_TRACKS; + flags = MCI_STATUS_ITEM | MCI_WAIT; + if ( MCI_CDioctl(cdromId, MCI_STATUS, flags, &mci_status) == 0 ) + { + strack=1; + etrack=mci_status.dwReturn; + + /* Read all the track TOC entries */ + flags = MCI_STATUS_ITEM | MCI_TRACK | MCI_WAIT; + + for ( i=strack; i 0 ) + { + tracks[i].length = tracks[i+1].start_lba - tracks[i].start_lba; + } + } + if ( i == etrack ) + { + mci_status.dwTrack = i; + mci_status.dwItem = MCI_STATUS_LENGTH; + if ( MCI_CDioctl(cdromId, MCI_STATUS, flags, &mci_status) == 0 ) + { + tracks[i].length = MSF_TO_LBA( + MCI_MSF_MINUTE(mci_status.dwReturn), + MCI_MSF_SECOND(mci_status.dwReturn), + MCI_MSF_FRAME(mci_status.dwReturn)) + 1; /* +1 to fix MCI last track length bug */ + /* compute lead-out offset */ + tracks[i+1].start_lba = tracks[i].start_lba + tracks[i].length; + tracks[i+1].length = 0; + okay = 1; + } + } + } + + MCI_CDioctl(cdromId, MCI_CLOSE, MCI_WAIT, NULL); + + return(okay ? 0 : -1); +} diff --git a/plugins/cdvdGigaherz/plugin.def b/plugins/cdvdGigaherz/plugin.def new file mode 100644 index 0000000000..5351ba64f9 --- /dev/null +++ b/plugins/cdvdGigaherz/plugin.def @@ -0,0 +1,25 @@ +EXPORTS + PS2EgetLibType @2 + PS2EgetLibName @3 + PS2EgetLibVersion2 @4 + CDVDinit @5 + CDVDshutdown @6 + CDVDopen @7 + CDVDclose @8 + CDVDreadTrack @9 + CDVDgetBuffer @10 + CDVDreadSubQ @11 + CDVDgetTN @12 + CDVDgetTD @13 + CDVDgetTOC @14 + CDVDgetDiskType @15 + CDVDgetTrayStatus @16 + CDVDctrlTrayOpen @17 + CDVDctrlTrayClose @18 + CDVDconfigure @19 + CDVDtest @20 + CDVDabout @21 + CDVDnewDiskCB @22 + CDVDgetBuffer2 @23 + CDVDreadSector @24 + CDVDgetDualInfo @25 diff --git a/plugins/cdvdGigaherz/resource.h b/plugins/cdvdGigaherz/resource.h new file mode 100644 index 0000000000..062dbc4208 --- /dev/null +++ b/plugins/cdvdGigaherz/resource.h @@ -0,0 +1,37 @@ +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by cdvd.rc +// +#define IDD_CONFIG 101 +#define IDC_PLUGINS 1000 +#define IDC_CONFIGURE 1001 +#define IDC_TEST 1002 +#define IDC_ABOUT 1003 +#define IDC_IMAGE_BROWSE 1004 +#define IDC_USEISO 1005 +#define IDC_NOCD 1006 +#define IDC_PLUGIN 1007 +#define IDC_IMAGE 1008 +#define IDC_IMAGE_FILE 1009 +#define IDC_NOSUB 1010 +#define IDC_FAKE 1011 +#define IDC_SAME 1012 +#define IDC_DRIVE 1012 +#define IDC_SUB_FILE 1014 +#define IDC_ABOUT3 1015 +#define IDC_SUB_BROWSE 1015 +#define IDC_FILE 1016 +#define IDC_NODUMP 1020 +#define IDC_DUMP_ISO 1021 +#define IDC_DUMP_BDV2 1022 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 102 +#define _APS_NEXT_COMMAND_VALUE 40001 +#define _APS_NEXT_CONTROL_VALUE 1011 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif diff --git a/plugins/cdvdGigaherz/rosddk/ntddcdrm.h b/plugins/cdvdGigaherz/rosddk/ntddcdrm.h new file mode 100644 index 0000000000..c430cb7c1c --- /dev/null +++ b/plugins/cdvdGigaherz/rosddk/ntddcdrm.h @@ -0,0 +1,348 @@ +/* + * ntddcdrm.h + * + * CDROM IOCTL interface. + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Casper S. Hornstrup + * + * THIS SOFTWARE IS NOT COPYRIGHTED + * + * This source code is offered for use in the public domain. You may + * use, modify or distribute it freely. + * + * This code is distributed in the hope that it will be useful but + * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY + * DISCLAIMED. This includes but is not limited to warranties of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * + */ + +#ifndef _NTDDCDRM_H_ +#define _NTDDCDRM_H_ + +#include "ntddstor.h" + +#define _ANONYMOUS_UNION +#define DUMMYUNIONNAME + +#ifdef __cplusplus +extern "C" { +#endif + +#define IOCTL_CDROM_BASE FILE_DEVICE_CD_ROM + +#define IOCTL_CDROM_CHECK_VERIFY \ + CTL_CODE(IOCTL_CDROM_BASE, 0x0200, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_CDROM_FIND_NEW_DEVICES \ + CTL_CODE(IOCTL_CDROM_BASE, 0x0206, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_CDROM_GET_CONTROL \ + CTL_CODE(IOCTL_CDROM_BASE, 0x000D, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_CDROM_GET_DRIVE_GEOMETRY \ + CTL_CODE(IOCTL_CDROM_BASE, 0x0013, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_CDROM_GET_LAST_SESSION \ + CTL_CODE(IOCTL_CDROM_BASE, 0x000E, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_CDROM_GET_VOLUME \ + CTL_CODE(IOCTL_CDROM_BASE, 0x0005, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_CDROM_PAUSE_AUDIO \ + CTL_CODE(IOCTL_CDROM_BASE, 0x0003, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_CDROM_PLAY_AUDIO_MSF \ + CTL_CODE(IOCTL_CDROM_BASE, 0x0006, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_CDROM_RAW_READ \ + CTL_CODE(IOCTL_CDROM_BASE, 0x000F, METHOD_OUT_DIRECT, FILE_READ_ACCESS) + +#define IOCTL_CDROM_DISK_TYPE \ + CTL_CODE(IOCTL_CDROM_BASE, 0x0010, METHOD_BUFFERED, FILE_ANY_ACCESS) + +#define IOCTL_CDROM_READ_Q_CHANNEL \ + CTL_CODE(IOCTL_CDROM_BASE, 0x000B, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_CDROM_READ_TOC \ + CTL_CODE(IOCTL_CDROM_BASE, 0x0000, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_CDROM_READ_TOC_EX \ + CTL_CODE(IOCTL_CDROM_BASE, 0x0015, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_CDROM_RESUME_AUDIO \ + CTL_CODE(IOCTL_CDROM_BASE, 0x0004, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_CDROM_SEEK_AUDIO_MSF \ + CTL_CODE(IOCTL_CDROM_BASE, 0x0001, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_CDROM_SET_VOLUME \ + CTL_CODE(IOCTL_CDROM_BASE, 0x000A, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_CDROM_SIMBAD \ + CTL_CODE(IOCTL_CDROM_BASE, 0x1003, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_CDROM_STOP_AUDIO \ + CTL_CODE(IOCTL_CDROM_BASE, 0x0002, METHOD_BUFFERED, FILE_READ_ACCESS) + + +#define MAXIMUM_NUMBER_TRACKS 100 +#define MAXIMUM_CDROM_SIZE 804 +#define MINIMUM_CDROM_READ_TOC_EX_SIZE 2 + +typedef struct _TRACK_DATA { + UCHAR Reserved; + UCHAR Control : 4; + UCHAR Adr : 4; + UCHAR TrackNumber; + UCHAR Reserved1; + UCHAR Address[4]; +} TRACK_DATA, *PTRACK_DATA; + +/* CDROM_DISK_DATA.DiskData flags */ +#define CDROM_DISK_AUDIO_TRACK 0x00000001 +#define CDROM_DISK_DATA_TRACK 0x00000002 + +typedef struct _CDROM_DISK_DATA { + ULONG DiskData; +} CDROM_DISK_DATA, *PCDROM_DISK_DATA; + +typedef struct _CDROM_PLAY_AUDIO_MSF { + UCHAR StartingM; + UCHAR StartingS; + UCHAR StartingF; + UCHAR EndingM; + UCHAR EndingS; + UCHAR EndingF; +} CDROM_PLAY_AUDIO_MSF, *PCDROM_PLAY_AUDIO_MSF; + +/* CDROM_READ_TOC_EX.Format constants */ +#define CDROM_READ_TOC_EX_FORMAT_TOC 0x00 +#define CDROM_READ_TOC_EX_FORMAT_SESSION 0x01 +#define CDROM_READ_TOC_EX_FORMAT_FULL_TOC 0x02 +#define CDROM_READ_TOC_EX_FORMAT_PMA 0x03 +#define CDROM_READ_TOC_EX_FORMAT_ATIP 0x04 +#define CDROM_READ_TOC_EX_FORMAT_CDTEXT 0x05 + +typedef struct _CDROM_READ_TOC_EX { + UCHAR Format : 4; + UCHAR Reserved1 : 3; + UCHAR Msf : 1; + UCHAR SessionTrack; + UCHAR Reserved2; + UCHAR Reserved3; +} CDROM_READ_TOC_EX, *PCDROM_READ_TOC_EX; + +typedef struct _CDROM_SEEK_AUDIO_MSF { + UCHAR M; + UCHAR S; + UCHAR F; +} CDROM_SEEK_AUDIO_MSF, *PCDROM_SEEK_AUDIO_MSF; + +/* CDROM_SUB_Q_DATA_FORMAT.Format constants */ +#define IOCTL_CDROM_SUB_Q_CHANNEL 0x00 +#define IOCTL_CDROM_CURRENT_POSITION 0x01 +#define IOCTL_CDROM_MEDIA_CATALOG 0x02 +#define IOCTL_CDROM_TRACK_ISRC 0x03 + +typedef struct _CDROM_SUB_Q_DATA_FORMAT { + UCHAR Format; + UCHAR Track; +} CDROM_SUB_Q_DATA_FORMAT, *PCDROM_SUB_Q_DATA_FORMAT; + +typedef struct _CDROM_TOC { + UCHAR Length[2]; + UCHAR FirstTrack; + UCHAR LastTrack; + TRACK_DATA TrackData[MAXIMUM_NUMBER_TRACKS]; +} CDROM_TOC, *PCDROM_TOC; + +#define CDROM_TOC_SIZE sizeof(CDROM_TOC) + +typedef struct _CDROM_TOC_ATIP_DATA_BLOCK { + UCHAR CdrwReferenceSpeed : 3; + UCHAR Reserved3 : 1; + UCHAR WritePower : 3; + UCHAR True1 : 1; + UCHAR Reserved4 : 6; + UCHAR UnrestrictedUse : 1; + UCHAR Reserved5 : 1; + UCHAR A3Valid : 1; + UCHAR A2Valid : 1; + UCHAR A1Valid : 1; + UCHAR Reserved6 : 3; + UCHAR IsCdrw : 1; + UCHAR True2 : 1; + UCHAR Reserved7; + UCHAR LeadInMsf[3]; + UCHAR Reserved8; + UCHAR LeadOutMsf[3]; + UCHAR Reserved9; + UCHAR A1Values[3]; + UCHAR Reserved10; + UCHAR A2Values[3]; + UCHAR Reserved11; + UCHAR A3Values[3]; + UCHAR Reserved12; +} CDROM_TOC_ATIP_DATA_BLOCK, *PCDROM_TOC_ATIP_DATA_BLOCK; + +typedef struct _CDROM_TOC_ATIP_DATA { + UCHAR Length[2]; + UCHAR Reserved1; + UCHAR Reserved2; + CDROM_TOC_ATIP_DATA_BLOCK Descriptors[0]; +} CDROM_TOC_ATIP_DATA, *PCDROM_TOC_ATIP_DATA; + +/* CDROM_TOC_CD_TEXT_DATA_BLOCK.PackType constants */ +#define CDROM_CD_TEXT_PACK_ALBUM_NAME 0x80 +#define CDROM_CD_TEXT_PACK_PERFORMER 0x81 +#define CDROM_CD_TEXT_PACK_SONGWRITER 0x82 +#define CDROM_CD_TEXT_PACK_COMPOSER 0x83 +#define CDROM_CD_TEXT_PACK_ARRANGER 0x84 +#define CDROM_CD_TEXT_PACK_MESSAGES 0x85 +#define CDROM_CD_TEXT_PACK_DISC_ID 0x86 +#define CDROM_CD_TEXT_PACK_GENRE 0x87 +#define CDROM_CD_TEXT_PACK_TOC_INFO 0x88 +#define CDROM_CD_TEXT_PACK_TOC_INFO2 0x89 +#define CDROM_CD_TEXT_PACK_UPC_EAN 0x8e +#define CDROM_CD_TEXT_PACK_SIZE_INFO 0x8f + +typedef struct _CDROM_TOC_CD_TEXT_DATA_BLOCK { + UCHAR PackType; + UCHAR TrackNumber : 7; + UCHAR ExtensionFlag : 1; + UCHAR SequenceNumber; + UCHAR CharacterPosition : 4; + UCHAR BlockNumber : 3; + UCHAR Unicode : 1; + _ANONYMOUS_UNION union { + UCHAR Text[12]; + WCHAR WText[6]; + } DUMMYUNIONNAME; + UCHAR CRC[2]; +} CDROM_TOC_CD_TEXT_DATA_BLOCK, *PCDROM_TOC_CD_TEXT_DATA_BLOCK; + +typedef struct _CDROM_TOC_CD_TEXT_DATA { + UCHAR Length[2]; + UCHAR Reserved1; + UCHAR Reserved2; + CDROM_TOC_CD_TEXT_DATA_BLOCK Descriptors[0]; +} CDROM_TOC_CD_TEXT_DATA, *PCDROM_TOC_CD_TEXT_DATA; + +/* CDROM_TOC_FULL_TOC_DATA_BLOCK.Adr constants */ +#define ADR_NO_MODE_INFORMATION 0x0 +#define ADR_ENCODES_CURRENT_POSITION 0x1 +#define ADR_ENCODES_MEDIA_CATALOG 0x2 +#define ADR_ENCODES_ISRC 0x3 + +typedef struct _CDROM_TOC_FULL_TOC_DATA_BLOCK { + UCHAR SessionNumber; + UCHAR Control : 4; + UCHAR Adr : 4; + UCHAR Reserved1; + UCHAR Point; + UCHAR MsfExtra[3]; + UCHAR Zero; + UCHAR Msf[3]; +} CDROM_TOC_FULL_TOC_DATA_BLOCK, *PCDROM_TOC_FULL_TOC_DATA_BLOCK; + +typedef struct _CDROM_TOC_FULL_TOC_DATA { + UCHAR Length[2]; + UCHAR FirstCompleteSession; + UCHAR LastCompleteSession; + CDROM_TOC_FULL_TOC_DATA_BLOCK Descriptors[0]; +} CDROM_TOC_FULL_TOC_DATA, *PCDROM_TOC_FULL_TOC_DATA; + +typedef struct _CDROM_TOC_PMA_DATA { + UCHAR Length[2]; + UCHAR Reserved1; + UCHAR Reserved2; + CDROM_TOC_FULL_TOC_DATA_BLOCK Descriptors[0]; +} CDROM_TOC_PMA_DATA, *PCDROM_TOC_PMA_DATA; + +/* SUB_Q_HEADER.AudioStatus constants */ +#define AUDIO_STATUS_NOT_SUPPORTED 0x00 +#define AUDIO_STATUS_IN_PROGRESS 0x11 +#define AUDIO_STATUS_PAUSED 0x12 +#define AUDIO_STATUS_PLAY_COMPLETE 0x13 +#define AUDIO_STATUS_PLAY_ERROR 0x14 +#define AUDIO_STATUS_NO_STATUS 0x15 + +typedef struct _SUB_Q_HEADER { + UCHAR Reserved; + UCHAR AudioStatus; + UCHAR DataLength[2]; +} SUB_Q_HEADER, *PSUB_Q_HEADER; + +typedef struct _SUB_Q_MEDIA_CATALOG_NUMBER { + SUB_Q_HEADER Header; + UCHAR FormatCode; + UCHAR Reserved[3]; + UCHAR Reserved1 : 7; + UCHAR Mcval :1; + UCHAR MediaCatalog[15]; +} SUB_Q_MEDIA_CATALOG_NUMBER, *PSUB_Q_MEDIA_CATALOG_NUMBER; + +typedef struct _SUB_Q_TRACK_ISRC { + SUB_Q_HEADER Header; + UCHAR FormatCode; + UCHAR Reserved0; + UCHAR Track; + UCHAR Reserved1; + UCHAR Reserved2 : 7; + UCHAR Tcval : 1; + UCHAR TrackIsrc[15]; +} SUB_Q_TRACK_ISRC, *PSUB_Q_TRACK_ISRC; + +typedef struct _SUB_Q_CURRENT_POSITION { + SUB_Q_HEADER Header; + UCHAR FormatCode; + UCHAR Control : 4; + UCHAR ADR : 4; + UCHAR TrackNumber; + UCHAR IndexNumber; + UCHAR AbsoluteAddress[4]; + UCHAR TrackRelativeAddress[4]; +} SUB_Q_CURRENT_POSITION, *PSUB_Q_CURRENT_POSITION; + +typedef union _SUB_Q_CHANNEL_DATA { + SUB_Q_CURRENT_POSITION CurrentPosition; + SUB_Q_MEDIA_CATALOG_NUMBER MediaCatalog; + SUB_Q_TRACK_ISRC TrackIsrc; +} SUB_Q_CHANNEL_DATA, *PSUB_Q_CHANNEL_DATA; + +/* CDROM_AUDIO_CONTROL.LbaFormat constants */ +#define AUDIO_WITH_PREEMPHASIS 0x1 +#define DIGITAL_COPY_PERMITTED 0x2 +#define AUDIO_DATA_TRACK 0x4 +#define TWO_FOUR_CHANNEL_AUDIO 0x8 + +typedef struct _CDROM_AUDIO_CONTROL { + UCHAR LbaFormat; + USHORT LogicalBlocksPerSecond; +} CDROM_AUDIO_CONTROL, *PCDROM_AUDIO_CONTROL; + +typedef struct _VOLUME_CONTROL { + UCHAR PortVolume[4]; +} VOLUME_CONTROL, *PVOLUME_CONTROL; + +typedef enum _TRACK_MODE_TYPE { + YellowMode2, + XAForm2, + CDDA +} TRACK_MODE_TYPE, *PTRACK_MODE_TYPE; + +typedef struct __RAW_READ_INFO { + LARGE_INTEGER DiskOffset; + ULONG SectorCount; + TRACK_MODE_TYPE TrackMode; +} RAW_READ_INFO, *PRAW_READ_INFO; + +#ifdef __cplusplus +} +#endif + +#endif /* _NTDDCDRM_H_ */ diff --git a/plugins/cdvdGigaherz/rosddk/ntddcdvd.h b/plugins/cdvdGigaherz/rosddk/ntddcdvd.h new file mode 100644 index 0000000000..f346f34422 --- /dev/null +++ b/plugins/cdvdGigaherz/rosddk/ntddcdvd.h @@ -0,0 +1,208 @@ +/* + * ntddcdvd.h + * + * DVD IOCTL interface. + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Casper S. Hornstrup + * + * THIS SOFTWARE IS NOT COPYRIGHTED + * + * This source code is offered for use in the public domain. You may + * use, modify or distribute it freely. + * + * This code is distributed in the hope that it will be useful but + * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY + * DISCLAIMED. This includes but is not limited to warranties of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * + */ + +#ifndef _NTDDCDVD_H_ +#define _NTDDCDVD_H_ + +#include "ntddstor.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define IOCTL_DVD_BASE FILE_DEVICE_DVD + +#define IOCTL_DVD_END_SESSION \ + CTL_CODE(IOCTL_DVD_BASE, 0x0403, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_DVD_GET_REGION \ + CTL_CODE(IOCTL_DVD_BASE, 0x0405, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_DVD_READ_KEY \ + CTL_CODE(IOCTL_DVD_BASE, 0x0401, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_DVD_READ_STRUCTURE \ + CTL_CODE(IOCTL_DVD_BASE, 0x0450, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_DVD_SEND_KEY \ + CTL_CODE(IOCTL_DVD_BASE, 0x0402, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_DVD_START_SESSION \ + CTL_CODE(IOCTL_DVD_BASE, 0x0400, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_DVD_SET_READ_AHEAD \ + CTL_CODE(IOCTL_DVD_BASE, 0x0404, METHOD_BUFFERED, FILE_READ_ACCESS) + + +typedef ULONG DVD_SESSION_ID, *PDVD_SESSION_ID; + +typedef struct _STORAGE_SET_READ_AHEAD { + LARGE_INTEGER TriggerAddress; + LARGE_INTEGER TargetAddress; +} STORAGE_SET_READ_AHEAD, *PSTORAGE_SET_READ_AHEAD; + +typedef enum DVD_STRUCTURE_FORMAT { + DvdPhysicalDescriptor, + DvdCopyrightDescriptor, + DvdDiskKeyDescriptor, + DvdBCADescriptor, + DvdManufacturerDescriptor, + DvdMaxDescriptor +} DVD_STRUCTURE_FORMAT, *PDVD_STRUCTURE_FORMAT; + +#include +typedef struct DVD_READ_STRUCTURE { + LARGE_INTEGER BlockByteOffset; + DVD_STRUCTURE_FORMAT Format; + DVD_SESSION_ID SessionId; + UCHAR LayerNumber; +} DVD_READ_STRUCTURE, *PDVD_READ_STRUCTURE; +#include + +typedef struct _DVD_DESCRIPTOR_HEADER { + USHORT Length; + UCHAR Reserved[2]; + UCHAR Data[0]; +} DVD_DESCRIPTOR_HEADER, *PDVD_DESCRIPTOR_HEADER; + +#include +typedef struct _DVD_LAYER_DESCRIPTOR { + UCHAR BookVersion : 4; + UCHAR BookType : 4; + UCHAR MinimumRate : 4; + UCHAR DiskSize : 4; + UCHAR LayerType : 4; + UCHAR TrackPath : 1; + UCHAR NumberOfLayers : 2; + UCHAR Reserved1 : 1; + UCHAR TrackDensity : 4; + UCHAR LinearDensity : 4; + ULONG StartingDataSector; + ULONG EndDataSector; + ULONG EndLayerZeroSector; + UCHAR Reserved5 : 7; + UCHAR BCAFlag : 1; + UCHAR Reserved6; +} DVD_LAYER_DESCRIPTOR, *PDVD_LAYER_DESCRIPTOR; +#include + +typedef struct _DVD_COPYRIGHT_DESCRIPTOR { + UCHAR CopyrightProtectionType; + UCHAR RegionManagementInformation; + USHORT Reserved; +} DVD_COPYRIGHT_DESCRIPTOR, *PDVD_COPYRIGHT_DESCRIPTOR; + +typedef struct _DVD_DISK_KEY_DESCRIPTOR { + UCHAR DiskKeyData[2048]; +} DVD_DISK_KEY_DESCRIPTOR, *PDVD_DISK_KEY_DESCRIPTOR; + +typedef enum _DVD_KEY_TYPE { + DvdChallengeKey = 0x01, + DvdBusKey1, + DvdBusKey2, + DvdTitleKey, + DvdAsf, + DvdSetRpcKey = 0x6, + DvdGetRpcKey = 0x8, + DvdDiskKey = 0x80, + DvdInvalidateAGID = 0x3f +} DVD_KEY_TYPE; + +typedef struct _DVD_COPY_PROTECT_KEY { + ULONG KeyLength; + DVD_SESSION_ID SessionId; + DVD_KEY_TYPE KeyType; + ULONG KeyFlags; + union { + HANDLE FileHandle; + LARGE_INTEGER TitleOffset; + } Parameters; + UCHAR KeyData[0]; +} DVD_COPY_PROTECT_KEY, *PDVD_COPY_PROTECT_KEY; + +#define DVD_CHALLENGE_KEY_LENGTH (12 + sizeof(DVD_COPY_PROTECT_KEY)) +#define DVD_BUS_KEY_LENGTH (8 + sizeof(DVD_COPY_PROTECT_KEY)) +#define DVD_TITLE_KEY_LENGTH (8 + sizeof(DVD_COPY_PROTECT_KEY)) +#define DVD_DISK_KEY_LENGTH (2048 + sizeof(DVD_COPY_PROTECT_KEY)) +#define DVD_RPC_KEY_LENGTH (sizeof(DVD_RPC_KEY) + sizeof(DVD_COPY_PROTECT_KEY)) +#define DVD_SET_RPC_KEY_LENGTH (sizeof(DVD_SET_RPC_KEY) + sizeof(DVD_COPY_PROTECT_KEY)) +#define DVD_ASF_LENGTH (sizeof(DVD_ASF) + sizeof(DVD_COPY_PROTECT_KEY)) + +#define DVD_END_ALL_SESSIONS ((DVD_SESSION_ID) 0xffffffff) + + +#define DVD_CGMS_RESERVED_MASK 0x00000078 + +#define DVD_CGMS_COPY_PROTECT_MASK 0x00000018 +#define DVD_CGMS_COPY_PERMITTED 0x00000000 +#define DVD_CGMS_COPY_ONCE 0x00000010 +#define DVD_CGMS_NO_COPY 0x00000018 + +#define DVD_COPYRIGHT_MASK 0x00000040 +#define DVD_NOT_COPYRIGHTED 0x00000000 +#define DVD_COPYRIGHTED 0x00000040 + +#define DVD_SECTOR_PROTECT_MASK 0x00000020 +#define DVD_SECTOR_NOT_PROTECTED 0x00000000 +#define DVD_SECTOR_PROTECTED 0x00000020 + + +typedef struct _DVD_BCA_DESCRIPTOR { + UCHAR BCAInformation[0]; +} DVD_BCA_DESCRIPTOR, *PDVD_BCA_DESCRIPTOR; + +typedef struct _DVD_MANUFACTURER_DESCRIPTOR { + UCHAR ManufacturingInformation[2048]; +} DVD_MANUFACTURER_DESCRIPTOR, *PDVD_MANUFACTURER_DESCRIPTOR; + +typedef struct _DVD_RPC_KEY { + UCHAR UserResetsAvailable : 3; + UCHAR ManufacturerResetsAvailable : 3; + UCHAR TypeCode : 2; + UCHAR RegionMask; + UCHAR RpcScheme; + UCHAR Reserved2[1]; +} DVD_RPC_KEY, *PDVD_RPC_KEY; + +typedef struct _DVD_SET_RPC_KEY { + UCHAR PreferredDriveRegionCode; + UCHAR Reserved[3]; +} DVD_SET_RPC_KEY, *PDVD_SET_RPC_KEY; + +typedef struct _DVD_ASF { + UCHAR Reserved0[3]; + UCHAR SuccessFlag : 1; + UCHAR Reserved1 : 7; +} DVD_ASF, *PDVD_ASF; + +typedef struct _DVD_REGION { + UCHAR CopySystem; + UCHAR RegionData; + UCHAR SystemRegion; + UCHAR ResetCount; +} DVD_REGION, *PDVD_REGION; + +#ifdef __cplusplus +} +#endif + +#endif /* _NTDDCDVD_H_ */ diff --git a/plugins/cdvdGigaherz/rosddk/ntddscsi.h b/plugins/cdvdGigaherz/rosddk/ntddscsi.h new file mode 100644 index 0000000000..0cf785e7ef --- /dev/null +++ b/plugins/cdvdGigaherz/rosddk/ntddscsi.h @@ -0,0 +1,171 @@ +/* + * ntddscsi.h + * + * SCSI port IOCTL interface. + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Casper S. Hornstrup + * + * THIS SOFTWARE IS NOT COPYRIGHTED + * + * This source code is offered for use in the public domain. You may + * use, modify or distribute it freely. + * + * This code is distributed in the hope that it will be useful but + * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY + * DISCLAIMED. This includes but is not limited to warranties of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * + */ + +#ifndef __NTDDSCSI_H +#define __NTDDSCSI_H + +#ifdef __cplusplus +extern "C" { +#endif + +#define DD_SCSI_DEVICE_NAME "\\Device\\ScsiPort" +#define DD_SCSI_DEVICE_NAME_U L"\\Device\\ScsiPort" + +#define IOCTL_SCSI_BASE FILE_DEVICE_CONTROLLER + +#define IOCTL_SCSI_FREE_DUMP_POINTERS \ + CTL_CODE(IOCTL_SCSI_BASE, 0x0409, METHOD_BUFFERED, FILE_ANY_ACCESS) + +#define IOCTL_SCSI_GET_INQUIRY_DATA \ + CTL_CODE(IOCTL_SCSI_BASE, 0x0403, METHOD_BUFFERED, FILE_ANY_ACCESS) + +#define IOCTL_SCSI_GET_CAPABILITIES \ + CTL_CODE(IOCTL_SCSI_BASE, 0x0404, METHOD_BUFFERED, FILE_ANY_ACCESS) + +#define IOCTL_SCSI_GET_ADDRESS \ + CTL_CODE(IOCTL_SCSI_BASE, 0x0406, METHOD_BUFFERED, FILE_ANY_ACCESS) + +#define IOCTL_SCSI_GET_DUMP_POINTERS \ + CTL_CODE(IOCTL_SCSI_BASE, 0x0408, METHOD_BUFFERED, FILE_ANY_ACCESS) + +#define IOCTL_SCSI_MINIPORT \ + CTL_CODE(IOCTL_SCSI_BASE, 0x0402, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS) + +#define IOCTL_SCSI_PASS_THROUGH \ + CTL_CODE(IOCTL_SCSI_BASE, 0x0401, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS) + +#define IOCTL_SCSI_PASS_THROUGH_DIRECT \ + CTL_CODE(IOCTL_SCSI_BASE, 0x0405, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS) + +#define IOCTL_SCSI_RESCAN_BUS \ + CTL_CODE(IOCTL_SCSI_BASE, 0x0407, METHOD_BUFFERED, FILE_ANY_ACCESS) + + +DEFINE_GUID(ScsiRawInterfaceGuid, \ + 0x53f56309L, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b); + +DEFINE_GUID(WmiScsiAddressGuid, \ + 0x53f5630fL, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b); + +typedef struct _SCSI_PASS_THROUGH { + USHORT Length; + UCHAR ScsiStatus; + UCHAR PathId; + UCHAR TargetId; + UCHAR Lun; + UCHAR CdbLength; + UCHAR SenseInfoLength; + UCHAR DataIn; + ULONG DataTransferLength; + ULONG TimeOutValue; + ULONG_PTR DataBufferOffset; + ULONG SenseInfoOffset; + UCHAR Cdb[16]; +} SCSI_PASS_THROUGH, *PSCSI_PASS_THROUGH; + +typedef struct _SCSI_PASS_THROUGH_DIRECT { + USHORT Length; + UCHAR ScsiStatus; + UCHAR PathId; + UCHAR TargetId; + UCHAR Lun; + UCHAR CdbLength; + UCHAR SenseInfoLength; + UCHAR DataIn; + ULONG DataTransferLength; + ULONG TimeOutValue; + PVOID DataBuffer; + ULONG SenseInfoOffset; + UCHAR Cdb[16]; +} SCSI_PASS_THROUGH_DIRECT, *PSCSI_PASS_THROUGH_DIRECT; + +typedef struct _SRB_IO_CONTROL { + ULONG HeaderLength; + UCHAR Signature[8]; + ULONG Timeout; + ULONG ControlCode; + ULONG ReturnCode; + ULONG Length; +} SRB_IO_CONTROL, *PSRB_IO_CONTROL; + +typedef struct _SCSI_ADDRESS { + ULONG Length; + UCHAR PortNumber; + UCHAR PathId; + UCHAR TargetId; + UCHAR Lun; +} SCSI_ADDRESS, *PSCSI_ADDRESS; + +typedef struct _SCSI_BUS_DATA { + UCHAR NumberOfLogicalUnits; + UCHAR InitiatorBusId; + ULONG InquiryDataOffset; +}SCSI_BUS_DATA, *PSCSI_BUS_DATA; + +typedef struct _SCSI_ADAPTER_BUS_INFO { + UCHAR NumberOfBuses; + SCSI_BUS_DATA BusData[1]; +} SCSI_ADAPTER_BUS_INFO, *PSCSI_ADAPTER_BUS_INFO; + +typedef struct _IO_SCSI_CAPABILITIES { + ULONG Length; + ULONG MaximumTransferLength; + ULONG MaximumPhysicalPages; + ULONG SupportedAsynchronousEvents; + ULONG AlignmentMask; + BOOLEAN TaggedQueuing; + BOOLEAN AdapterScansDown; + BOOLEAN AdapterUsesPio; +} IO_SCSI_CAPABILITIES, *PIO_SCSI_CAPABILITIES; + +typedef struct _SCSI_INQUIRY_DATA { + UCHAR PathId; + UCHAR TargetId; + UCHAR Lun; + BOOLEAN DeviceClaimed; + ULONG InquiryDataLength; + ULONG NextInquiryDataOffset; + UCHAR InquiryData[1]; +} SCSI_INQUIRY_DATA, *PSCSI_INQUIRY_DATA; + +#define SCSI_IOCTL_DATA_OUT 0 +#define SCSI_IOCTL_DATA_IN 1 +#define SCSI_IOCTL_DATA_UNSPECIFIED 2 + +typedef struct _DUMP_POINTERS { + struct _ADAPTER_OBJECT *AdapterObject; + PVOID MappedRegisterBase; + PVOID DumpData; + PVOID CommonBufferVa; + LARGE_INTEGER CommonBufferPa; + ULONG CommonBufferSize; + BOOLEAN AllocateCommonBuffers; + BOOLEAN UseDiskDump; + UCHAR Spare1[2]; + PVOID DeviceObject; +} DUMP_POINTERS, *PDUMP_POINTERS; + +#ifdef __cplusplus +} +#endif + +#endif /* __NTDDSCSI_H */ diff --git a/plugins/cdvdGigaherz/rosddk/ntddstor.h b/plugins/cdvdGigaherz/rosddk/ntddstor.h new file mode 100644 index 0000000000..bc16dccd83 --- /dev/null +++ b/plugins/cdvdGigaherz/rosddk/ntddstor.h @@ -0,0 +1,356 @@ +/* + * ntddstor.h + * + * Storage class IOCTL interface. + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Casper S. Hornstrup + * + * THIS SOFTWARE IS NOT COPYRIGHTED + * + * This source code is offered for use in the public domain. You may + * use, modify or distribute it freely. + * + * This code is distributed in the hope that it will be useful but + * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY + * DISCLAIMED. This includes but is not limited to warranties of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * + */ + +#ifndef _NTDDSTOR_H_ +#define _NTDDSTOR_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#define IOCTL_STORAGE_BASE FILE_DEVICE_MASS_STORAGE + +#define IOCTL_STORAGE_CHECK_VERIFY \ + CTL_CODE(IOCTL_STORAGE_BASE, 0x0200, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_STORAGE_CHECK_VERIFY2 \ + CTL_CODE(IOCTL_STORAGE_BASE, 0x0200, METHOD_BUFFERED, FILE_ANY_ACCESS) + +#define IOCTL_STORAGE_EJECT_MEDIA \ + CTL_CODE(IOCTL_STORAGE_BASE, 0x0202, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_STORAGE_EJECTION_CONTROL \ + CTL_CODE(IOCTL_STORAGE_BASE, 0x0250, METHOD_BUFFERED, FILE_ANY_ACCESS) + +#define IOCTL_STORAGE_FIND_NEW_DEVICES \ + CTL_CODE(IOCTL_STORAGE_BASE, 0x0206, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_STORAGE_GET_DEVICE_NUMBER \ + CTL_CODE(IOCTL_STORAGE_BASE, 0x0420, METHOD_BUFFERED, FILE_ANY_ACCESS) + +#define IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER \ + CTL_CODE(IOCTL_STORAGE_BASE, 0x0304, METHOD_BUFFERED, FILE_ANY_ACCESS) + +#define IOCTL_STORAGE_GET_MEDIA_TYPES \ + CTL_CODE(IOCTL_STORAGE_BASE, 0x0300, METHOD_BUFFERED, FILE_ANY_ACCESS) + +#define IOCTL_STORAGE_GET_MEDIA_TYPES_EX \ + CTL_CODE(IOCTL_STORAGE_BASE, 0x0301, METHOD_BUFFERED, FILE_ANY_ACCESS) + +#define IOCTL_STORAGE_LOAD_MEDIA \ + CTL_CODE(IOCTL_STORAGE_BASE, 0x0203, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_STORAGE_LOAD_MEDIA2 \ + CTL_CODE(IOCTL_STORAGE_BASE, 0x0203, METHOD_BUFFERED, FILE_ANY_ACCESS) + +#define IOCTL_STORAGE_MCN_CONTROL \ + CTL_CODE(IOCTL_STORAGE_BASE, 0x0251, METHOD_BUFFERED, FILE_ANY_ACCESS) + +#define IOCTL_STORAGE_MEDIA_REMOVAL \ + CTL_CODE(IOCTL_STORAGE_BASE, 0x0201, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_STORAGE_PREDICT_FAILURE \ + CTL_CODE(IOCTL_STORAGE_BASE, 0x0440, METHOD_BUFFERED, FILE_ANY_ACCESS) + +#define IOCTL_STORAGE_QUERY_PROPERTY \ + CTL_CODE(IOCTL_STORAGE_BASE, 0x0500, METHOD_BUFFERED, FILE_ANY_ACCESS) + +#define IOCTL_STORAGE_RELEASE \ + CTL_CODE(IOCTL_STORAGE_BASE, 0x0205, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_STORAGE_RESERVE \ + CTL_CODE(IOCTL_STORAGE_BASE, 0x0204, METHOD_BUFFERED, FILE_READ_ACCESS) + +#define IOCTL_STORAGE_GET_HOTPLUG_INFO \ + CTL_CODE(IOCTL_STORAGE_BASE, 0x0305, METHOD_BUFFERED, FILE_ANY_ACCESS) + +#define IOCTL_STORAGE_SET_HOTPLUG_INFO \ + CTL_CODE(IOCTL_STORAGE_BASE, 0x0306, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS) + +#define IOCTL_STORAGE_RESET_BUS \ + CTL_CODE(IOCTL_STORAGE_BASE, 0x0400, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS) + +#define IOCTL_STORAGE_RESET_DEVICE \ + CTL_CODE(IOCTL_STORAGE_BASE, 0x0401, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS) + + +DEFINE_GUID(GUID_DEVINTERFACE_DISK, + 0x53f56307L, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b); + +DEFINE_GUID(GUID_DEVINTERFACE_CDROM, + 0x53f56308L, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b); + +DEFINE_GUID(GUID_DEVINTERFACE_PARTITION, + 0x53f5630aL, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b); + +DEFINE_GUID(GUID_DEVINTERFACE_TAPE, + 0x53f5630bL, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b); + +DEFINE_GUID(GUID_DEVINTERFACE_WRITEONCEDISK, + 0x53f5630cL, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b); + +DEFINE_GUID(GUID_DEVINTERFACE_VOLUME, + 0x53f5630dL, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b); + +DEFINE_GUID(GUID_DEVINTERFACE_MEDIUMCHANGER, + 0x53f56310L, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b); + +DEFINE_GUID(GUID_DEVINTERFACE_FLOPPY, + 0x53f56311L, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b); + +DEFINE_GUID(GUID_DEVINTERFACE_CDCHANGER, + 0x53f56312L, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b); + +DEFINE_GUID(GUID_DEVINTERFACE_STORAGEPORT, + 0x2accfe60L, 0xc130, 0x11d2, 0xb0, 0x82, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b); + +DEFINE_GUID(GUID_DEVINTERFACE_HIDDEN_VOLUME, + 0x7f108a28L, 0x9833, 0x4b3b, 0xb7, 0x80, 0x2c, 0x6b, 0x5f, 0xa5, 0xc0, 0x62); + +/* Aliases for storage guids */ +#define DiskClassGuid GUID_DEVINTERFACE_DISK +#define CdRomClassGuid GUID_DEVINTERFACE_CDROM +#define PartitionClassGuid GUID_DEVINTERFACE_PARTITION +#define TapeClassGuid GUID_DEVINTERFACE_TAPE +#define WriteOnceDiskClassGuid GUID_DEVINTERFACE_WRITEONCEDISK +#define VolumeClassGuid GUID_DEVINTERFACE_VOLUME +#define MediumChangerClassGuid GUID_DEVINTERFACE_MEDIUMCHANGER +#define FloppyClassGuid GUID_DEVINTERFACE_FLOPPY +#define CdChangerClassGuid GUID_DEVINTERFACE_CDCHANGER +#define StoragePortClassGuid GUID_DEVINTERFACE_STORAGEPORT +#define HiddenVolumeClassGuid GUID_DEVINTERFACE_HIDDEN_VOLUME + +typedef enum _STORAGE_MEDIA_TYPE { + DDS_4mm = 0x20, + MiniQic, + Travan, + QIC, + MP_8mm, + AME_8mm, + AIT1_8mm, + DLT, + NCTP, + IBM_3480, + IBM_3490E, + IBM_Magstar_3590, + IBM_Magstar_MP, + STK_DATA_D3, + SONY_DTF, + DV_6mm, + DMI, + SONY_D2, + CLEANER_CARTRIDGE, + CD_ROM, + CD_R, + CD_RW, + DVD_ROM, + DVD_R, + DVD_RW, + MO_3_RW, + MO_5_WO, + MO_5_RW, + MO_5_LIMDOW, + PC_5_WO, + PC_5_RW, + PD_5_RW, + ABL_5_WO, + PINNACLE_APEX_5_RW, + SONY_12_WO, + PHILIPS_12_WO, + HITACHI_12_WO, + CYGNET_12_WO, + KODAK_14_WO, + MO_NFR_525, + NIKON_12_RW, + IOMEGA_ZIP, + IOMEGA_JAZ, + SYQUEST_EZ135, + SYQUEST_EZFLYER, + SYQUEST_SYJET, + AVATAR_F2, + MP2_8mm, + DST_S, + DST_M, + DST_L, + VXATape_1, + VXATape_2, + STK_9840, + LTO_Ultrium, + LTO_Accelis, + DVD_RAM, + AIT_8mm, + ADR_1, + ADR_2 +} STORAGE_MEDIA_TYPE, *PSTORAGE_MEDIA_TYPE; + +typedef enum _STORAGE_BUS_TYPE { + BusTypeUnknown = 0x00, + BusTypeScsi, + BusTypeAtapi, + BusTypeAta, + BusType1394, + BusTypeSsa, + BusTypeFibre, + BusTypeUsb, + BusTypeRAID, + BusTypeMaxReserved = 0x7F +} STORAGE_BUS_TYPE, *PSTORAGE_BUS_TYPE; + +/* DEVICE_MEDIA_INFO.DeviceSpecific.DiskInfo.MediaCharacteristics constants */ +#define MEDIA_ERASEABLE 0x00000001 +#define MEDIA_WRITE_ONCE 0x00000002 +#define MEDIA_READ_ONLY 0x00000004 +#define MEDIA_READ_WRITE 0x00000008 +#define MEDIA_WRITE_PROTECTED 0x00000100 +#define MEDIA_CURRENTLY_MOUNTED 0x80000000 + +typedef struct _DEVICE_MEDIA_INFO { + union { + struct { + LARGE_INTEGER Cylinders; + STORAGE_MEDIA_TYPE MediaType; + ULONG TracksPerCylinder; + ULONG SectorsPerTrack; + ULONG BytesPerSector; + ULONG NumberMediaSides; + ULONG MediaCharacteristics; + } DiskInfo; + struct { + LARGE_INTEGER Cylinders; + STORAGE_MEDIA_TYPE MediaType; + ULONG TracksPerCylinder; + ULONG SectorsPerTrack; + ULONG BytesPerSector; + ULONG NumberMediaSides; + ULONG MediaCharacteristics; + } RemovableDiskInfo; + struct { + STORAGE_MEDIA_TYPE MediaType; + ULONG MediaCharacteristics; + ULONG CurrentBlockSize; + STORAGE_BUS_TYPE BusType; + union { + struct { + UCHAR MediumType; + UCHAR DensityCode; + } ScsiInformation; + } BusSpecificData; + } TapeInfo; + } DeviceSpecific; +} DEVICE_MEDIA_INFO, *PDEVICE_MEDIA_INFO; + +typedef struct _GET_MEDIA_TYPES { + ULONG DeviceType; + ULONG MediaInfoCount; + DEVICE_MEDIA_INFO MediaInfo[1]; +} GET_MEDIA_TYPES, *PGET_MEDIA_TYPES; + +typedef struct _STORAGE_ADAPTER_DESCRIPTOR { + ULONG Version; + ULONG Size; + ULONG MaximumTransferLength; + ULONG MaximumPhysicalPages; + ULONG AlignmentMask; + BOOLEAN AdapterUsesPio; + BOOLEAN AdapterScansDown; + BOOLEAN CommandQueueing; + BOOLEAN AcceleratedTransfer; + STORAGE_BUS_TYPE BusType; + USHORT BusMajorVersion; + USHORT BusMinorVersion; +} STORAGE_ADAPTER_DESCRIPTOR, *PSTORAGE_ADAPTER_DESCRIPTOR; + +typedef struct _STORAGE_BUS_RESET_REQUEST { + UCHAR PathId; +} STORAGE_BUS_RESET_REQUEST, *PSTORAGE_BUS_RESET_REQUEST; + +typedef struct _STORAGE_DESCRIPTOR_HEADER { + ULONG Version; + ULONG Size; +} STORAGE_DESCRIPTOR_HEADER, *PSTORAGE_DESCRIPTOR_HEADER; + +typedef struct _STORAGE_DEVICE_DESCRIPTOR { + ULONG Version; + ULONG Size; + UCHAR DeviceType; + UCHAR DeviceTypeModifier; + BOOLEAN RemovableMedia; + BOOLEAN CommandQueueing; + ULONG VendorIdOffset; + ULONG ProductIdOffset; + ULONG ProductRevisionOffset; + ULONG SerialNumberOffset; + STORAGE_BUS_TYPE BusType; + ULONG RawPropertiesLength; + UCHAR RawDeviceProperties[1]; +} STORAGE_DEVICE_DESCRIPTOR, *PSTORAGE_DEVICE_DESCRIPTOR; + +typedef struct _STORAGE_DEVICE_ID_DESCRIPTOR { + ULONG Version; + ULONG Size; + ULONG NumberOfIdentifiers; + UCHAR Identifiers[1]; +} STORAGE_DEVICE_ID_DESCRIPTOR, *PSTORAGE_DEVICE_ID_DESCRIPTOR; + +typedef struct _STORAGE_DEVICE_NUMBER { + DEVICE_TYPE DeviceType; + ULONG DeviceNumber; + ULONG PartitionNumber; +} STORAGE_DEVICE_NUMBER, *PSTORAGE_DEVICE_NUMBER; + +typedef struct _STORAGE_PREDICT_FAILURE { + ULONG PredictFailure; + UCHAR VendorSpecific[512]; +} STORAGE_PREDICT_FAILURE, *PSTORAGE_PREDICT_FAILURE; + +typedef enum _STORAGE_PROPERTY_ID { + StorageDeviceProperty = 0, + StorageAdapterProperty, + StorageDeviceIdProperty, + StorageDeviceUniqueIdProperty, + StorageDeviceWriteCacheProperty, + StorageMiniportProperty, + StorageAccessAlignmentProperty +} STORAGE_PROPERTY_ID, *PSTORAGE_PROPERTY_ID; + +typedef enum _STORAGE_QUERY_TYPE { + PropertyStandardQuery = 0, + PropertyExistsQuery, + PropertyMaskQuery, + PropertyQueryMaxDefined +} STORAGE_QUERY_TYPE, *PSTORAGE_QUERY_TYPE; + +typedef struct _STORAGE_PROPERTY_QUERY { + STORAGE_PROPERTY_ID PropertyId; + STORAGE_QUERY_TYPE QueryType; + UCHAR AdditionalParameters[1]; +} STORAGE_PROPERTY_QUERY, *PSTORAGE_PROPERTY_QUERY; + +typedef struct _PREVENT_MEDIA_REMOVAL { + BOOLEAN PreventMediaRemoval; +} PREVENT_MEDIA_REMOVAL, *PPREVENT_MEDIA_REMOVAL; + +#ifdef __cplusplus +} +#endif + +#endif /* _NTDDSTOR_H_ */