void shuffle_test()
{
const int iter = 128*128*12;
const int size = 256;
_declspec( align(16) ) uchar data[size];
_declspec( align(16) ) uchar dstuchar[size];
for(int i=0;i<size;i++)
{
data[i]=i;
}
int64 pre;
clear(dstuchar,size);
pre = getTickCount();
for(int i=0;i<iter;i++)
flipdataBF(data,dstuchar,size);
cout<<"flip BF time: "<<1000.0*(getTickCount()-pre)/(getTickFrequency())<<" ms"<<endl;
printdataI(dstuchar,size);
clear(dstuchar,size);
pre = getTickCount();
for(int i=0;i<iter;i++)
flipdata(data,dstuchar,size);
cout<<"flip SSE time: "<<1000.0*(getTickCount()-pre)/(getTickFrequency())<<" ms"<<endl;
printdataI(dstuchar,size);
}
void SsePiAddI16(void)
{
_declspec(align(16)) XmmVal a;
_declspec(align(16)) XmmVal b;
_declspec(align(16)) XmmVal c[2];
char buff[256];
a.i16[0] = 10; b.i16[0] = 100;
a.i16[1] = 200; b.i16[1] = -200;
a.i16[2] = 30; b.i16[2] = 32760;
a.i16[3] = -32766; b.i16[3] = -400;
a.i16[4] = 50; b.i16[4] = 500;
a.i16[5] = 60; b.i16[5] = -600;
a.i16[6] = 32000; b.i16[6] = 1200;
a.i16[7] = -32000; b.i16[7] = -950;
SsePiAddI16_(&a, &b, c);
printf("\nResults for SsePiAddI16_\n");
printf("a: %s\n", a.ToString_i16(buff, sizeof(buff)));
printf("b: %s\n", b.ToString_i16(buff, sizeof(buff)));
printf("c[0]: %s\n", c[0].ToString_i16(buff, sizeof(buff)));
printf("\n");
printf("a: %s\n", a.ToString_i16(buff, sizeof(buff)));
printf("b: %s\n", b.ToString_i16(buff, sizeof(buff)));
printf("c[1]: %s\n", c[1].ToString_i16(buff, sizeof(buff)));
}
int main()
{
double execTime = 0.0;
double startTime, endTime;
int k, size1, size2;
// Tell the compiler to align the a, b, and x arrays on 16-byte
// boundaries. This allows the vectorizer to use aligned instructions
// and produce faster code.
#ifdef ALIGNED
#ifdef _WIN32
_declspec(align(16)) FTYPE a[ROW][COLWIDTH];
_declspec(align(16)) FTYPE b[ROW];
_declspec(align(16)) FTYPE x[COLWIDTH];
#else
FTYPE a[ROW][COLWIDTH] __attribute__((aligned(16)));
FTYPE b[ROW] __attribute__((aligned(16)));
FTYPE x[COLWIDTH] __attribute__((aligned(16)));
#endif // _WIN32
#else
FTYPE a[ROW][COLWIDTH];
FTYPE b[ROW];
FTYPE x[COLWIDTH];
#endif
size1 = ROW;
size2 = COLWIDTH;
printf("\nROW:%d COL: %d\n",ROW,COLWIDTH);
// initialize the arrays with data
init_matrix(ROW,COL,1,a);
init_array(COL,3,x);
//start timing the matrix multiply code
startTime = clock_it();
for (k = 0;k < REPEATNTIMES;k++) {
#ifdef NOFUNCCALL
int i, j;
for (i = 0; i < size1; i++) {
b[i] = 0;
for (j = 0;j < size2; j++) {
b[i] += a[i][j] * x[j];
}
}
#else
matvec(size1,size2,a,b,x);
#endif
x[0] = x[0] + 0.000001;
}
endTime = clock_it();
execTime = endTime - startTime;
printf("Execution time is %2.3f seconds\n", execTime);
printf("GigaFlops = %f\n", (((double)REPEATNTIMES * (double)COL * (double)ROW * 2.0) / (double)(execTime))/1000000000.0);
printsum(COL,b);
return 0;
}
BOOL ModeSense(
PEXT_ARG pExtArg,
PDEVICE pDevice
)
{
if (pDevice->FEATURE.byModePage2a) {
CDB::_MODE_SENSE cdb = { 0 };
cdb.OperationCode = SCSIOP_MODE_SENSE;
#if (NTDDI_VERSION <= NTDDI_WIN7)
cdb.LogicalUnitNumber = pDevice->address.Lun;
#endif
cdb.PageCode = MODE_PAGE_CAPABILITIES;
cdb.Pc = MODE_SENSE_CURRENT_VALUES;
cdb.AllocationLength = sizeof(CDVD_CAPABILITIES_PAGE_WITH_HEADER);
_declspec(align(4)) CDVD_CAPABILITIES_PAGE_WITH_HEADER modesense = { 0 };
BYTE byScsiStatus = 0;
if (!ScsiPassThroughDirect(pExtArg, pDevice, &cdb, CDB6GENERIC_LENGTH, &modesense,
sizeof(CDVD_CAPABILITIES_PAGE_WITH_HEADER), &byScsiStatus, _T(__FUNCTION__), __LINE__) ||
byScsiStatus >= SCSISTAT_CHECK_CONDITION) {
// not false.
}
else {
if (modesense.cdvd.PageCode == MODE_PAGE_CAPABILITIES) {
OutputModeParmeterHeader(&modesense.header);
OutputCDVDCapabilitiesPage(pDevice, &modesense.cdvd);
}
else {
OutputDriveLogA(
"SCSIOP_MODE_SENSE didn't fail. But it couldn't get PageCode on this drive\n");
}
}
}
return TRUE;
}
BOOL ReadBufferCapacity(
PEXT_ARG pExtArg,
PDEVICE pDevice
)
{
if (pDevice->FEATURE.byReadBufCapa) {
CDB::_READ_BUFFER_CAPACITY cdb = { 0 };
cdb.OperationCode = SCSIOP_READ_BUFFER_CAPACITY;
WORD wSize = sizeof(READ_BUFFER_CAPACITY_DATA);
REVERSE_BYTES_SHORT(&cdb.AllocationLength, &wSize);
_declspec(align(4)) READ_BUFFER_CAPACITY_DATA readBufCapaData = { 0 };
BYTE byScsiStatus = 0;
if (!ScsiPassThroughDirect(pExtArg, pDevice, &cdb, CDB12GENERIC_LENGTH
, &readBufCapaData, wSize, &byScsiStatus, _T(__FUNCTION__), __LINE__)
|| byScsiStatus >= SCSISTAT_CHECK_CONDITION) {
// not false.
OutputDriveNoSupportLogA(READ_BUFFER_CAPACITY);
}
else {
OutputReadBufferCapacity(&readBufCapaData);
}
}
return TRUE;
}
void SsePiSubI32(void)
{
_declspec(align(16)) XmmVal a;
_declspec(align(16)) XmmVal b;
_declspec(align(8)) XmmVal c; // Misaligned XmmVal
char buff[256];
a.i32[0] = 800; b.i32[0] = 250;
a.i32[1] = 500; b.i32[1] = -2000;
a.i32[2] = 1000; b.i32[2] = -40;
a.i32[3] = 900; b.i32[3] = 1200;
SsePiSubI32_(&a, &b, &c);
printf("\nResults for SsePiSubI32_\n");
printf("a: %s\n", a.ToString_i32(buff, sizeof(buff)));
printf("b: %s\n", b.ToString_i32(buff, sizeof(buff)));
printf("c: %s\n", c.ToString_i32(buff, sizeof(buff)));
}
BOOL Inquiry(
PEXT_ARG pExtArg,
PDEVICE pDevice
)
{
CDB::_CDB6INQUIRY3 cdb = { 0 };
cdb.OperationCode = SCSIOP_INQUIRY;
cdb.AllocationLength = sizeof(INQUIRYDATA);
_declspec(align(4)) INQUIRYDATA inquiryData = { 0 };
BYTE byScsiStatus = 0;
if (!ScsiPassThroughDirect(pExtArg, pDevice, &cdb, CDB6GENERIC_LENGTH, &inquiryData,
sizeof(INQUIRYDATA), &byScsiStatus, _T(__FUNCTION__), __LINE__) ||
byScsiStatus >= SCSISTAT_CHECK_CONDITION) {
return FALSE;
}
OutputInquiry(pDevice, &inquiryData);
return TRUE;
}
// https://msdn.microsoft.com/ja-jp/library/ff551396(v=vs.85).aspx
BOOL SetCDSpeed(
PEXT_ARG pExtArg,
PDEVICE pDevice,
DWORD dwCDSpeedNum
)
{
if (pDevice->FEATURE.bySetCDSpeed) {
WORD wSpeed = 0;
_declspec(align(4)) CDROM_SET_SPEED setspeed;
if (0 < dwCDSpeedNum && dwCDSpeedNum <= DRIVE_MAX_SPEED) {
wSpeed = (WORD)(CD_RAW_SECTOR_SIZE * 75 * dwCDSpeedNum / 1000);
setspeed.ReadSpeed = wSpeed;
}
else {
wSpeed = 0xffff;
setspeed.ReadSpeed = pDevice->wMaxReadSpeed;
}
CDB::_SET_CD_SPEED cdb = { 0 };
cdb.OperationCode = SCSIOP_SET_CD_SPEED;
REVERSE_BYTES_SHORT(&cdb.ReadSpeed, &wSpeed);
setspeed.RequestType = CdromSetSpeed;
setspeed.RotationControl = CdromDefaultRotation;
BYTE byScsiStatus = 0;
if (!ScsiPassThroughDirect(pExtArg, pDevice, &cdb, CDB12GENERIC_LENGTH, &setspeed,
sizeof(CDROM_SET_SPEED), &byScsiStatus, _T(__FUNCTION__), __LINE__)
|| byScsiStatus >= SCSISTAT_CHECK_CONDITION) {
// Somehow PX-W1210S fails...
OutputDriveNoSupportLogA(SET_CD_SPEED);
OutputDriveLogA("Or if you use the SATA/IDE to USB adapter, doesn't support this command\n");
}
else {
OutputSetSpeed(&setspeed);
OutputString(_T("Set the drive speed: %uKB/sec\n"), setspeed.ReadSpeed);
}
}
return TRUE;
}
BOOL ReadDiscInformation(
PEXT_ARG pExtArg,
PDEVICE pDevice
)
{
CDB::_READ_DISK_INFORMATION cdb = { 0 };
cdb.OperationCode = SCSIOP_READ_DISC_INFORMATION;
cdb.Lun = pDevice->address.Lun;
WORD wSize = sizeof(DISC_INFORMATION);
REVERSE_BYTES_SHORT(&cdb.AllocationLength, &wSize);
_declspec(align(4)) DISC_INFORMATION discInformation = { 0 };
BYTE byScsiStatus = 0;
if (!ScsiPassThroughDirect(pExtArg, pDevice, &cdb, CDB10GENERIC_LENGTH
, &discInformation, wSize, &byScsiStatus, _T(__FUNCTION__), __LINE__) ||
byScsiStatus >= SCSISTAT_CHECK_CONDITION) {
// not false.
OutputDriveNoSupportLogA(READ_DISC_INFORMATION);
}
else {
OutputDiscInformation(&discInformation);
}
return TRUE;
}
BOOL GetConfiguration(
PEXT_ARG pExtArg,
PDEVICE pDevice,
PDISC pDisc
)
{
CDB::_GET_CONFIGURATION cdb = { 0 };
cdb.OperationCode = SCSIOP_GET_CONFIGURATION;
cdb.RequestType = SCSI_GET_CONFIGURATION_REQUEST_TYPE_CURRENT;
cdb.StartingFeature[1] = FeatureProfileList;
WORD wSize = sizeof(GET_CONFIGURATION_HEADER);
REVERSE_BYTES_SHORT(&cdb.AllocationLength, &wSize);
_declspec(align(4)) GET_CONFIGURATION_HEADER configHeader = { 0 };
BYTE byScsiStatus = 0;
if (!ScsiPassThroughDirect(pExtArg, pDevice, &cdb, CDB10GENERIC_LENGTH
, &configHeader, wSize, &byScsiStatus, _T(__FUNCTION__), __LINE__)
|| byScsiStatus >= SCSISTAT_CHECK_CONDITION) {
pDisc->SCSI.wCurrentMedia = ProfileCdrom;
// not false. because undefined mmc1..
if (pDevice->byPlxtrDrive == PLXTR_DRIVE_TYPE::PX40TS) {
pDevice->FEATURE.byCanCDText = TRUE;
pDevice->FEATURE.byC2ErrorData = TRUE;
}
OutputDriveNoSupportLogA(GET_CONFIGURATION);
}
else {
pDisc->SCSI.wCurrentMedia =
MAKEWORD(configHeader.CurrentProfile[1], configHeader.CurrentProfile[0]);
if (pDisc->SCSI.wCurrentMedia == ProfileInvalid) {
OutputDriveLogA(
"SCSIOP_GET_CONFIGURATION didn't fail. But it couldn't get CurrentMedia on this drive\n"
"\tSet CurrentMedia to CD-ROM\n");
configHeader.CurrentProfile[1] = ProfileCdrom;
pDisc->SCSI.wCurrentMedia = ProfileCdrom;
}
OutputGetConfigurationHeader(&configHeader);
DWORD dwAllLen =
MAKELONG(MAKEWORD(configHeader.DataLength[3], configHeader.DataLength[2]),
MAKEWORD(configHeader.DataLength[1], configHeader.DataLength[0])) -
sizeof(configHeader.DataLength) + sizeof(GET_CONFIGURATION_HEADER);
LPBYTE pPConf = NULL;
LPBYTE lpConf = NULL;
if (!GetAlignedCallocatedBuffer(pDevice, &pPConf,
dwAllLen, &lpConf, _T(__FUNCTION__), __LINE__)) {
return FALSE;
}
REVERSE_BYTES_SHORT(&cdb.AllocationLength, &dwAllLen);
if (!ScsiPassThroughDirect(pExtArg, pDevice, &cdb, CDB10GENERIC_LENGTH
, lpConf, dwAllLen, &byScsiStatus, _T(__FUNCTION__), __LINE__)
|| byScsiStatus >= SCSISTAT_CHECK_CONDITION) {
// not false. because undefined mmc1..
OutputDriveNoSupportLogA(GET_CONFIGURATION);
}
else {
OutputGetConfigurationFeatureNumber(pDevice,
lpConf + sizeof(GET_CONFIGURATION_HEADER), dwAllLen - sizeof(GET_CONFIGURATION_HEADER));
if (pDevice->byPlxtrDrive == (BYTE)PLXTR_DRIVE_TYPE::PXW1210A ||
pDevice->byPlxtrDrive == (BYTE)PLXTR_DRIVE_TYPE::PXW1210S) {
// Somehow SetCDSpeed fails in PX-W1210...
pDevice->FEATURE.bySetCDSpeed = FALSE;
}
}
FreeAndNull(pPConf);
}
return TRUE;
}
BOOL ReadTOCText(
PEXT_ARG pExtArg,
PDEVICE pDevice,
PDISC pDisc,
FILE* fpCcd
)
{
CDB::_READ_TOC cdb = { 0 };
cdb.OperationCode = SCSIOP_READ_TOC;
cdb.LogicalUnitNumber = pDevice->address.Lun;
cdb.Format2 = CDROM_READ_TOC_EX_FORMAT_CDTEXT;
WORD wSize = sizeof(CDROM_TOC_CD_TEXT_DATA);
REVERSE_BYTES_SHORT(&cdb.AllocationLength, &wSize);
_declspec(align(4)) CDROM_TOC_CD_TEXT_DATA tocText = { 0 };
#ifdef _DEBUG
OutputString(_T("tocText address: %p\n"), &tocText);
#endif
OutputDiscLogA(OUTPUT_DHYPHEN_PLUS_STR(CDTEXT));
BYTE byScsiStatus = 0;
if (!ScsiPassThroughDirect(pExtArg, pDevice, &cdb, CDB10GENERIC_LENGTH
, &tocText, wSize, &byScsiStatus, _T(__FUNCTION__), __LINE__)
|| byScsiStatus >= SCSISTAT_CHECK_CONDITION) {
// not false. because undefined mmc1..
OutputDriveNoSupportLogA(Nothing CDTEXT or READ_TOC_EX_FORMAT_CDTEXT);
return TRUE;
}
WORD wTocTextLen = MAKEWORD(tocText.Length[1], tocText.Length[0]);
WORD wTocTextEntriesAll = wTocTextLen - sizeof(tocText.Length);
WriteCcdForDiscCDTextLength(wTocTextEntriesAll, fpCcd);
if (!wTocTextEntriesAll) {
OutputDiscLogA("\tNothing\n");
// many CD is nothing text
return TRUE;
}
WORD wTocTextEntries = wTocTextEntriesAll / sizeof(CDROM_TOC_CD_TEXT_DATA_BLOCK);
WriteCcdForCDText(wTocTextEntries, fpCcd);
WORD wTocTextLenFix = wTocTextEntriesAll + sizeof(CDROM_TOC_CD_TEXT_DATA);
// 4 byte padding
if (wTocTextLenFix % 4) {
wTocTextLenFix = (WORD)((wTocTextLenFix / 4 + 1) * 4);
}
LPBYTE pPTocText = NULL;
LPBYTE pTocText = NULL;
if (!GetAlignedCallocatedBuffer(pDevice, &pPTocText,
wTocTextLenFix, &pTocText, _T(__FUNCTION__), __LINE__)) {
return FALSE;
}
#ifdef _DEBUG
OutputDiscLogA(
"TocTextLen: %u, TocTextEntriesAll: %u, TocTextEntries: %u, TocTextLenFix: %u\n",
wTocTextLen, wTocTextEntriesAll, wTocTextEntries, wTocTextLenFix);
OutputString(_T("pPTocText address: %p\n"), &pPTocText);
OutputString(_T("pTocText address: %p\n"), &pTocText);
#endif
REVERSE_BYTES_SHORT(&cdb.AllocationLength, &wTocTextLenFix);
LPCH pTmpText = NULL;
BOOL bRet = TRUE;
try {
if (!ScsiPassThroughDirect(pExtArg, pDevice, &cdb, CDB10GENERIC_LENGTH
, pTocText, wTocTextLenFix, &byScsiStatus, _T(__FUNCTION__), __LINE__)
|| byScsiStatus >= SCSISTAT_CHECK_CONDITION) {
throw FALSE;
}
PCDROM_TOC_CD_TEXT_DATA_BLOCK pDesc =
((PCDROM_TOC_CD_TEXT_DATA)pTocText)->Descriptors;
WriteCcdForCDTextEntry(pDesc, wTocTextEntries, fpCcd);
WORD wAllTextSize = wTocTextEntries * sizeof(pDesc->Text);
if (NULL == (pTmpText = (LPCH)calloc(wAllTextSize, sizeof(_TCHAR)))) {
OutputLastErrorNumAndString(_T(__FUNCTION__), __LINE__);
throw FALSE;
}
WORD wEntrySize = 0;
BOOL bUnicode = FALSE;
while (wEntrySize < wTocTextEntries) {
if (pDesc[wEntrySize].Unicode == 1) {
bUnicode = TRUE;
break;
}
wEntrySize++;
}
SetAndOutputTocCDText(pDisc, pDesc, pTmpText, wEntrySize, wAllTextSize);
if (bUnicode) {
PWCHAR pTmpWText = NULL;
if (NULL == (pTmpWText = (PWCHAR)calloc(wAllTextSize, sizeof(BYTE)))) {
OutputLastErrorNumAndString(_T(__FUNCTION__), __LINE__);
throw FALSE;
}
SetAndOutputTocCDWText(pDesc,
pTmpText, wEntrySize, wTocTextEntries, wAllTextSize);
FreeAndNull(pTmpWText);
}
}
catch (BOOL ret) {
bRet = ret;
}
FreeAndNull(pPTocText);
FreeAndNull(pTmpText);
return bRet;
}
BOOL ReadTOCFull(
PEXT_ARG pExtArg,
PDEVICE pDevice,
PDISC pDisc,
FILE* fpCcd
)
{
CDB::_READ_TOC cdb = { 0 };
cdb.OperationCode = SCSIOP_READ_TOC;
cdb.LogicalUnitNumber = pDevice->address.Lun;
cdb.Format2 = CDROM_READ_TOC_EX_FORMAT_FULL_TOC;
cdb.StartingTrack = 1;
WORD wSize = sizeof(CDROM_TOC_FULL_TOC_DATA);
REVERSE_BYTES_SHORT(&cdb.AllocationLength, &wSize);
_declspec(align(4)) CDROM_TOC_FULL_TOC_DATA fullToc = { 0 };
#ifdef _DEBUG
OutputString(_T("fullToc address: %p\n"), &fullToc);
#endif
LPBYTE pBuf = NULL;
LPBYTE lpBuf = NULL;
BYTE lpCmd[CDB12GENERIC_LENGTH] = { 0 };
INT nOfs = 0;
BYTE byMode = DATA_BLOCK_MODE0;
BYTE bySessionNum = 0;
BYTE byScsiStatus = 0;
if (!ScsiPassThroughDirect(pExtArg, pDevice, &cdb, CDB10GENERIC_LENGTH
, &fullToc, wSize, &byScsiStatus, _T(__FUNCTION__), __LINE__)
|| byScsiStatus >= SCSISTAT_CHECK_CONDITION) {
if (!ReadCDForCheckingSubQAdrFirst(
pExtArg, pDevice, pDisc, &pBuf, &lpBuf, lpCmd, &nOfs)) {
return FALSE;
}
for (BYTE i = 0; i < pDisc->SCSI.toc.LastTrack; i++) {
if (!ReadCDForCheckingSubQAdr(pExtArg
, pDevice, pDisc, lpCmd, lpBuf, nOfs, i, &byMode, 1, fpCcd)) {
return FALSE;
}
if (bySessionNum < 1) {
WriteCcdForSession(1, byMode, fpCcd);
bySessionNum++;
}
OutputString(
_T("\rChecking SubQ adr (Track) %2u/%2u"), i + 1, pDisc->SCSI.toc.LastTrack);
}
OutputString(_T("\n"));
pDevice->bySuccessReadTocFull = FALSE;
return TRUE;
}
WORD wFullTocLen = MAKEWORD(fullToc.Length[1], fullToc.Length[0]);
WORD wTocEntriesAll = wFullTocLen - sizeof(fullToc.Length);
WORD wTocEntries = wTocEntriesAll / sizeof(CDROM_TOC_FULL_TOC_DATA_BLOCK);
if (fpCcd) {
WriteCcdForDisc(wTocEntries, fullToc.LastCompleteSession, fpCcd);
if (pDevice->FEATURE.byCanCDText) {
ReadTOCText(pExtArg, pDevice, pDisc, fpCcd);
}
}
WORD wFullTocLenFix = wTocEntriesAll + sizeof(CDROM_TOC_FULL_TOC_DATA);
// 4 byte padding
if (wFullTocLenFix % 4) {
wFullTocLenFix = (WORD)((wFullTocLenFix / 4 + 1) * 4);
}
LPBYTE pPFullToc = NULL;
LPBYTE pFullToc = NULL;
if (!GetAlignedCallocatedBuffer(pDevice, &pPFullToc,
wFullTocLenFix, &pFullToc, _T(__FUNCTION__), __LINE__)) {
return FALSE;
}
#ifdef _DEBUG
OutputDiscLogA(
"FullTocLen: %u, TocEntriesAll: %u, TocEntries: %u, FullTocLenFix: %u\n",
wFullTocLen, wTocEntriesAll, wTocEntries, wFullTocLenFix);
OutputString(_T("pPFullToc address: %p\n"), &pPFullToc);
OutputString(_T("pFullToc address: %p\n"), &pFullToc);
#endif
REVERSE_BYTES_SHORT(&cdb.AllocationLength, &wFullTocLenFix);
BOOL bRet = TRUE;
try {
if (!ScsiPassThroughDirect(pExtArg, pDevice, &cdb, CDB10GENERIC_LENGTH
, pFullToc, wFullTocLenFix, &byScsiStatus, _T(__FUNCTION__), __LINE__)
|| byScsiStatus >= SCSISTAT_CHECK_CONDITION) {
throw FALSE;
}
PCDROM_TOC_FULL_TOC_DATA_BLOCK pTocData =
((PCDROM_TOC_FULL_TOC_DATA)pFullToc)->Descriptors;
if (!ReadCDForCheckingSubQAdrFirst(pExtArg
, pDevice, pDisc, &pBuf, &lpBuf, lpCmd, &nOfs)) {
throw FALSE;
}
for (WORD i = 0; i < wTocEntries; i++) {
if (pDevice->byPlxtrDrive == PLXTR_DRIVE_TYPE::PX40TS) {
// Somehow Ultraplex seems to get the fulltoc data as "hexadecimal"
pTocData[i].Msf[0] = BcdToDec(pTocData[i].Msf[0]);
pTocData[i].Msf[1] = BcdToDec(pTocData[i].Msf[1]);
pTocData[i].Msf[2] = BcdToDec(pTocData[i].Msf[2]);
pTocData[i].MsfExtra[0] = BcdToDec(pTocData[i].MsfExtra[0]);
pTocData[i].MsfExtra[1] = BcdToDec(pTocData[i].MsfExtra[1]);
pTocData[i].MsfExtra[2] = BcdToDec(pTocData[i].MsfExtra[2]);
if (pTocData[i].Point < 0xa0) {
pTocData[i].Point = BcdToDec(pTocData[i].Point);
}
}
if (pTocData[i].Point < 100) {
if (!ReadCDForCheckingSubQAdr(pExtArg, pDevice, pDisc, lpCmd, lpBuf, nOfs
, (BYTE)(pTocData[i].Point - 1), &byMode, pTocData[i].SessionNumber, fpCcd)) {
throw FALSE;
}
if (bySessionNum < pTocData[i].SessionNumber) {
WriteCcdForSession(pTocData[i].SessionNumber, byMode, fpCcd);
bySessionNum++;
}
OutputString(
_T("\rChecking SubQ adr (Track) %2u/%2u"), pTocData[i].Point, pDisc->SCSI.toc.LastTrack);
}
}
OutputString(_T("\n"));
SetAndOutputTocFull(pDisc, &fullToc, pTocData, wTocEntries, fpCcd);
}
catch (BOOL ret) {
bRet = ret;
}
pDevice->bySuccessReadTocFull = TRUE;
FreeAndNull(pPFullToc);
FreeAndNull(pBuf);
return bRet;
}
