开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 磁盘/存储 > SCSI/ASPI > 查看源码
aspilib.c
资源名称：xtractor.zip　[点击查看]
上传用户：xmgzy123
上传日期：2007-01-07
资源大小：373k
文件大小：43k
源码类别：

SCSI/ASPI

开发平台：

WINDOWS

aspilib.c：源码内容
  1. /*
  2.  * aspilib.c - Copyright (C) 1999 Jay A. Key
  3.  *
  4.  * Generic routines to access wnaspi32.dll
  5.  *
  6.  **********************************************************************
  7.  *
  8.  * This program is free software; you can redistribute it and/or modify
  9.  * it under the terms of the GNU Lesser General Public License as published
  10.  * by the Free Software Foundation; either version 2 of the License, or
  11.  * (at your option) any later version.
  12.  *
  13.  * This program is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  * GNU General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Lesser General Public License
  19.  * along with this program; if not, write to the Free Software
  20.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  21.  *
  22.  **********************************************************************
  23.  *
  24.  * $Id: aspilib.c,v 1.2 2000/02/25 10:47:37 akey Exp $
  25.  * $Date: 2000/02/25 10:47:37 $
  26.  * $Locker:  $
  27.  * $Log: aspilib.c,v $
  28.  * Revision 1.2  2000/02/25 10:47:37  akey
  29.  * sync'ed with akrip32.dll v0.94
  30.  *
  31.  * Revision 1.7  2000/02/25 10:14:36  akey
  32.  * v0.94 release
  33.  *
  34.  * Revision 1.6  2000/02/14 09:56:25  akey
  35.  * cleaned up #ifdef _DEBUG code considerably
  36.  *
  37.  * Revision 1.5  2000/02/11 10:00:35  akey
  38.  * added access to cdplayer.ini
  39.  *
  40.  * Revision 1.4  2000/01/31 15:35:40  akey
  41.  * v0.93: added CDDBGetServerList and fixed problem with Win2000 scsi pass through code
  42.  *
  43.  * Revision 1.3  2000/01/12 10:07:41  akey
  44.  * Added minimal SCSI passthrough IOCTL support
  45.  *
  46.  * Revision 1.2  2000/01/03 12:29:43  akey
  47.  * v0.91 release -- added CDDB and bug fixes
  48.  *
  49.  *
  50.  */
  52. #define _AKRIP32_
  54. #include <windows.h>
  55. #include <stdio.h>
  56. #include "aspilib.h"
  57. #include "scsidefs.h"
  59. typedef union {
  60.   CDHANDLEREC cdHandles[MAXCDHAND];
  61.   HANDLE cdMutex[MAXCDHAND];
  62.   int nextHandle;
  63. } AKSHAREDMEM, FAR *LPAKSHAREDMEM;
  65. DWORD deinitREAD10( HCDROM hCD );
  66. DWORD initREAD10( HCDROM hCD );
  67. DWORD readCDParameters( HCDROM hCD, BOOL bChangeMask );
  68. DWORD setCDSpeed( HCDROM hCD, DWORD speed );
  69. DWORD pauseResumeCD( HCDROM hCD, BOOL bPause );
  70. DWORD startStopUnit( HCDROM hCD, BOOL bLoEj, BOOL bStart );
  71. int loadAspi( void );
  72. void unloadAspi( void );
  73. BOOL initMutexes( void );
  74. BOOL deinitMutexes( void );
  75. DWORD CDDBSum( DWORD n );
  76. int compBuf( BYTE *b1, BYTE *b2, int n );
  77. DWORD testReadCDAudio( HCDROM hCD, LPTRACKBUF t );
  78. DWORD dummyGetASPI32SupportInfo( void );
  79. DWORD dummySendASPI32Command( LPSRB lpsrb );
  80. BOOL dummyGetASPI32Buffer( PASPI32BUFF pbuf );
  81. BOOL dummyFreeASPI32Buffer( PASPI32BUFF pbuf );
  82. BOOL dummyTranslateASPI32Address( PDWORD p1, PDWORD p2 );
  83. DWORD dummyGetASPI32DLLVersion( void );
  84. int InitSCSIPT( void );
  85. int DeinitSCSIPT( void );
  86. DWORD SPTIGetASPI32SupportInfo( void );
  87. DWORD SPTISendASPI32Command( LPSRB lpsrb );
  89. /*
  90.  * static variables
  91.  */
  92. static char *copyrightInfo = "Released under the GNU Lesser General Public License (http://www.fsf.org/).";
  93. static char *aSCSIDevTypes[] = {
  94.     "Direct-access device",
  95.     "Sequential-access device",
  96.     "Printer device",
  97.     "Processor device",
  98.     "Write-once device",
  99.     "CD-ROM device",
  100.     "Scanner device",
  101.     "Optical memory device",
  102.     "Medium changer device",
  103.     "Communication device",
  104.     "ASC IT8 device",
  105.     "ASC IT8 device"
  106. };
  108. #define MAXCDTYPE   8
  109. static CDREADFN aReadFn[] = {
  110.   NULL, readCDAudioLBA_ATAPI, readCDAudioLBA_ATAPI, readCDAudioLBA_READ10,
  111.   readCDAudioLBA_READ10, readCDAudioLBA_D8, readCDAudioLBA_D4,
  112.   readCDAudioLBA_D4, readCDAudioLBA_READ10
  113. };
  114. static HINSTANCE hinstWNASPI32 = NULL;
  115. int alErrCode = 0;
  116. BYTE alAspiErr = 0;
  117. static LPAKSHAREDMEM pcdShared;
  118. CDHANDLEREC *cdHandles;
  119. HANDLE *cdMutexes;
  120. int *nextHandle = NULL;
  121. CRITICAL_SECTION getHandle;
  122. HANDLE hCacheMutex = NULL;
  123. CRITICAL_SECTION csCache;
  125. //CRITICAL_SECTION useDbbuf;
  126. //char dbbuf[512];
  128. #define MAJVER   0
  129. #define MINVER   94
  131. DWORD (*pfnGetASPI32SupportInfo)(void);
  132. DWORD (*pfnSendASPI32Command)(LPSRB);
  133. BOOL  (*pfnGetASPI32Buffer)(PASPI32BUFF);
  134. BOOL  (*pfnFreeASPI32Buffer)(PASPI32BUFF);
  135. BOOL  (*pfnTranslateASPI32Address)(PDWORD,PDWORD);
  136. DWORD (*pfnGetASPI32DLLVersion)(void);
  137. BOOL  aspiLoaded = FALSE;
  139. /*
  140.  * local prototypes
  141.  */
  142. static char *devType( int i );
  147. /***************************************************************************
  148.  * DllMain
  149.  ***************************************************************************/
  150. BOOL WINAPI DllMain( HANDLE hModule, DWORD dwReason, LPVOID lpReserved )
  151. {
  152.   BOOL fInit;
  153.   static HANDLE hMapObject = NULL;
  154.   HANDLE hInitMutex = NULL;
  155.   BOOL retVal = FALSE;
  157.   hModule = hModule;
  158.   lpReserved = lpReserved;
  160.   hInitMutex = CreateMutex( NULL, FALSE, "AKRipDllMainMutex" );
  161.   if ( !hInitMutex )
  162.     {
  163.       dwReason = 0xFFFFFFFF;  // do not execute any attach/detach code
  164.     }
  165.   else if ( WaitForSingleObject( hInitMutex, 15 * 1000 ) != WAIT_OBJECT_0 )
  166.     {
  167.       CloseHandle( hInitMutex );
  168.       dwReason = 0xFFFFFFFF;    // do not execute any attach/detach code
  169.     }
  171.   switch( dwReason )
  172.     {
  173.     case DLL_PROCESS_ATTACH:
  174.       //InitializeCriticalSection( &useDbbuf );
  175.       InitializeCriticalSection( &getHandle );
  176. #ifdef _DBLIBMAIN
  177.       dbprintf( "akrip32: DLL_PROCESS_ATTACH (hModule=%04X)", hModule );
  178. #endif
  179.       loadAspi();
  180.       hMapObject = CreateFileMapping( (HANDLE)0xFFFFFFFF, NULL,
  181.       PAGE_READWRITE, 0, sizeof(AKSHAREDMEM),
  182.       "akrip32memmap" );
  183.       if ( hMapObject == NULL )
  184. break;
  185.       fInit = ( GetLastError() != ERROR_ALREADY_EXISTS );
  186.       pcdShared = MapViewOfFile( hMapObject, FILE_MAP_WRITE, 0, 0, 0 );
  187.       if ( !pcdShared )
  188. break;
  189.       if ( fInit )
  190. memset( pcdShared, 0, sizeof(AKSHAREDMEM) );
  191.       cdHandles = pcdShared->cdHandles;
  192.       cdMutexes = pcdShared->cdMutex;
  193.       nextHandle = &(pcdShared->nextHandle);
  194.       initMutexes( );
  195.       retVal = TRUE;
  196.       break;
  198.     case DLL_THREAD_ATTACH:
  199. #ifdef _DBLIBMAIN
  200.       dbprintf( "akrip32: DLL_THREAD_ATTACH (hModule=%04X)", hModule );
  201. #endif
  202.       retVal = TRUE;
  203.       break;
  205.     case DLL_THREAD_DETACH:
  206. #ifdef _DBLIBMAIN
  207.       dbprintf( "akrip32: DLL_THREAD_DETACH (hModule=%04X)", hModule );
  208. #endif
  209.       retVal = TRUE;
  210.       break;
  212.     case DLL_PROCESS_DETACH:
  213. #ifdef _DBLIBMAIN
  214.       OutputDebugString( "akrip32: DLL_PROCESS_DETACH" );
  215. #endif
  216.       deinitMutexes();
  217.       UnmapViewOfFile( pcdShared );
  218.       CloseHandle( hMapObject );
  219.       unloadAspi();
  220.       retVal = TRUE;
  221.       break;
  222.     }
  224.   if ( hInitMutex )
  225.     {
  226.       ReleaseMutex( hInitMutex );
  227.       CloseHandle( hInitMutex );
  228.     }
  229.   return retVal;
  230. }
  234. BOOL initMutexes( void )
  235. {
  236.   int i;
  237.   char tmp[32];
  239.   for( i = 0; i < MAXCDHAND; i++ )
  240.     {
  241.       wsprintf( tmp, "akrip32_cdMtx%02d", i );
  242.       cdMutexes[i] = CreateMutex( NULL, FALSE, tmp );
  243.       if ( !cdMutexes[i] )
  244. return FALSE;
  245.     }
  246.   hCacheMutex = CreateMutex( NULL, FALSE, "AKRipCacheMutex" );
  247.   InitializeCriticalSection( &csCache );
  248.   return TRUE;
  249. }
  252. BOOL deinitMutexes( void )
  253. {
  254.   int i;
  256.   for( i = 0; i < MAXCDHAND; i++ )
  257.     {
  258.       if ( cdMutexes[i] )
  259. CloseHandle( cdMutexes[i] );
  260.     }
  261.   if ( hCacheMutex )
  262.     CloseHandle( hCacheMutex );
  263.   DeleteCriticalSection( &csCache );
  264.   return TRUE;
  265. }
  268. static char *devType( int i )
  269. { 
  270.   if ( i >= 0x20 )
  271.     return "";
  273.   if ( i == 0x1F )
  274.     return "Unknown or no device";
  276.   if ( i >= 0x0C )
  277.     return "";
  279.   return aSCSIDevTypes[i];
  280. }
  283. /*
  284.  * Assumes that loadAspi has already been called
  285.  */
  286. int  getSCSIDevType( BYTE bHostAdapter, BYTE bTarget, BYTE bLUN,
  287.      LPBYTE pDevType, LPSTR lpDevTypeStr, int iDevTypeLen )
  288. {
  289.   SRB_GDEVBlock s;
  290.   DWORD dwStatus;
  292.   memset( &s, 0, sizeof(SRB_GDEVBlock) );
  293.   s.SRB_Cmd = SC_GET_DEV_TYPE;
  294.   s.SRB_HaID = bHostAdapter;
  295.   s.SRB_Target = bTarget;
  296.   s.SRB_Lun = bLUN;
  298.   //DebugBreak();
  299.   dwStatus = pfnSendASPI32Command( (LPSRB)&s );
  300.   switch( dwStatus )
  301.     {
  302.     case SS_COMP:
  303. #ifdef _DEBUG
  304.       dbprintf( "akrip32: getSCSIDevType() -> SS_COMP: %04X",
  305. s.SRB_DeviceType );
  306.       dbprintf( "akrip32: getSCSIDevType(): pDevType == 0x%08X", pDevType );
  307. #endif
  308.       if ( pDevType )
  309. *pDevType = s.SRB_DeviceType;
  310.       if ( lpDevTypeStr )
  311. strncpy( lpDevTypeStr, devType( s.SRB_DeviceType ), iDevTypeLen );
  312.       break;
  314.     case SS_NO_DEVICE:
  315. #ifdef _DEBUG
  316.       dbprintf( "akrip32: getSCSIDevType() -> SS_NO_DEVICE" );
  317. #endif
  318.       if ( pDevType )
  319. *pDevType = 0x1F;
  320.       if ( lpDevTypeStr )
  321. strncpy( lpDevTypeStr, "SS_NO_DEVICE", iDevTypeLen );
  322.       return FALSE;
  324.     default:
  325. #ifdef _DEBUG
  326.       dbprintf( "akrip32: getSCSIDevType(): unexpected return from ASPI (%04X)", dwStatus );
  327. #endif
  328.       if ( pDevType )
  329. *pDevType = 0x1F;
  330.       if ( lpDevTypeStr )
  331. strncpy( lpDevTypeStr, "Unknown return", iDevTypeLen );
  332.       return FALSE;
  333.     }
  335.   return TRUE;
  336. }
  339. DWORD dummyGetASPI32SupportInfo( void )
  340. {
  341.   return SS_NO_ASPI;
  342. }
  344. DWORD dummySendASPI32Command( LPSRB lpsrb )
  345. {
  346.   lpsrb->SRB_Status = SS_NO_ASPI;
  347.   return SS_NO_ASPI;
  348. }
  351. BOOL dummyGetASPI32Buffer( PASPI32BUFF pbuf )
  352. {
  353.   return FALSE;
  354. }
  357. BOOL dummyFreeASPI32Buffer( PASPI32BUFF pbuf )
  358. {
  359.   return FALSE;
  360. }
  363. BOOL dummyTranslateASPI32Address( PDWORD p1, PDWORD p2 )
  364. {
  365.   return FALSE;
  366. }
  369. DWORD dummyGetASPI32DLLVersion( void )
  370. {
  371.   return 0;
  372. }
  375. /***************************************************************************
  376.  * int loadAspi( void )
  377.  ***************************************************************************/
  378. int loadAspi( void )
  379. {
  380.   DWORD dwErr;
  381.   hinstWNASPI32 = LoadLibrary( "WNASPI32.DLL" );
  383.   if ( hinstWNASPI32 )
  384.     {
  385.       pfnGetASPI32SupportInfo =
  386. (DWORD(*)(void))GetProcAddress( hinstWNASPI32, "GetASPI32SupportInfo" );
  387.       pfnSendASPI32Command =
  388. (DWORD(*)(LPSRB))GetProcAddress( hinstWNASPI32, "SendASPI32Command" );
  389.       pfnGetASPI32Buffer =
  390. (BOOL(*)(PASPI32BUFF))GetProcAddress( hinstWNASPI32, "GetASPI32Buffer" );
  391.       pfnFreeASPI32Buffer =
  392. (BOOL(*)(PASPI32BUFF))GetProcAddress( hinstWNASPI32, "FreeASPI32Buffer" );
  393.       pfnTranslateASPI32Address =
  394. (BOOL(*)(PDWORD,PDWORD))GetProcAddress( hinstWNASPI32, "TranslateASPI32Address" );
  395.       pfnGetASPI32DLLVersion =
  396. (DWORD(*)(void))GetProcAddress( hinstWNASPI32, "GetASPI32DLLVersion" );
  398.       if ( !pfnGetASPI32SupportInfo || !pfnSendASPI32Command )
  399. {
  400.   if ( !pfnGetASPI32SupportInfo )
  401.     alErrCode = ALERR_NOGETASPI32SUPP;
  402.   else
  403.     alErrCode = ALERR_NOSENDASPICMD;
  405. #ifdef _DEBUG
  406.   dbprintf( "akrip32: GetASPI32SupportInfo == 0x%08X", 
  407.    pfnGetASPI32SupportInfo );
  408.   dbprintf( "akrip32: SendASPI32Command == 0x%08X", pfnSendASPI32Command );
  409. #endif
  410.   return 0;
  411. }
  413.     }
  414.   else if ( InitSCSIPT() )
  415.     {
  416.       pfnGetASPI32SupportInfo = SPTIGetASPI32SupportInfo;
  417.       pfnSendASPI32Command    = SPTISendASPI32Command;
  418.     }
  419.   else
  420.     {
  421.       dwErr = GetLastError();
  423.       alErrCode = ALERR_NOWNASPI;
  424.       pfnGetASPI32SupportInfo = dummyGetASPI32SupportInfo;
  425.       pfnSendASPI32Command = dummySendASPI32Command;
  426.       pfnGetASPI32Buffer = dummyGetASPI32Buffer;
  427.       pfnFreeASPI32Buffer = dummyFreeASPI32Buffer;
  428.       pfnTranslateASPI32Address = dummyTranslateASPI32Address;
  429.       pfnGetASPI32DLLVersion = dummyGetASPI32DLLVersion;
  431. #ifdef _DEBUG
  432.       dwErr = GetLastError();
  433.       dbprintf( "Unable to load WNASPI32.DLL" );
  434.       dbprintf( "akrip32: GetLastError() -> %d (%04X)", dwErr, dwErr );
  435. #endif
  437.       return 0;
  438.     }
  440.    aspiLoaded = TRUE;
  441.    return 1;
  442. }
  445. void unloadAspi( void )
  446. {
  447.   DeinitSCSIPT();
  449.   if ( hinstWNASPI32 )
  450.     {
  451.       aspiLoaded = FALSE;
  452.       pfnGetASPI32SupportInfo = NULL;
  453.       pfnSendASPI32Command = NULL;
  454.       pfnGetASPI32Buffer = NULL;
  455.       pfnFreeASPI32Buffer = NULL;
  456.       pfnTranslateASPI32Address = NULL;
  457.       pfnGetASPI32DLLVersion = NULL;
  458.       FreeLibrary( hinstWNASPI32 );
  459.       hinstWNASPI32 = NULL;
  460.     }
  461. }
  463. /***************************************************************************
  464.  * GetNumAdapters
  465.  ***************************************************************************/
  466. int GetNumAdapters( void )
  467. {
  468.   DWORD d;
  469.   BYTE bHACount;
  470.   BYTE bASPIStatus;
  472.   d = pfnGetASPI32SupportInfo();
  473.   bASPIStatus = HIBYTE(LOWORD(d));
  474.   bHACount    = LOBYTE(LOWORD(d));
  476.   if ( bASPIStatus != SS_COMP && bASPIStatus != SS_NO_ADAPTERS )
  477.     {
  478.       alErrCode = ALERR_ASPI;
  479.       alAspiErr = bASPIStatus;
  481. #ifdef _DEBUG
  482.       dbprintf( "akrip32: GetNumAdapters: bASPIStatus == 0x%02X", bASPIStatus );
  483. #endif
  484.       return -1;
  485.     }
  486.   return (int)bHACount;
  487. }
  489. /***************************************************************************
  490.  * GetDriveInfo
  491.  ***************************************************************************/
  492. DWORD GetDriveInfo( BYTE ha, BYTE tgt, BYTE lun, LPCDREC cdrec )
  493. {
  494.   DWORD dwStatus;
  495.   HANDLE heventSRB;
  496.   SRB_ExecSCSICmd s;
  497.   BYTE buf[100];
  498.   char outBuf[101];
  499.   CDREC cdrecTmp;
  501.   heventSRB = CreateEvent( NULL, TRUE, FALSE, NULL );
  503.   if ( cdrec )
  504.     cdrecTmp = *cdrec;
  506.   memset( &cdrecTmp.info, 0, sizeof(CDINFO) );
  507.   memset( &s, 0, sizeof( s ) );
  508.   memset( buf, 0, 100 );
  509.   s.SRB_Cmd        = SC_EXEC_SCSI_CMD;
  510.   s.SRB_HaID       = ha;
  511.   s.SRB_Target     = tgt;
  512.   s.SRB_Lun        = lun;
  513.   s.SRB_Flags      = SRB_DIR_IN | SRB_EVENT_NOTIFY;
  514.   s.SRB_BufLen     = 100;
  515.   s.SRB_BufPointer = buf;
  516.   s.SRB_SenseLen   = SENSE_LEN;
  517.   s.SRB_CDBLen     = 6;
  518.   s.SRB_PostProc   = (LPVOID)heventSRB;
  519.   s.CDBByte[0]     = SCSI_INQUIRY;
  520.   s.CDBByte[4]     = 100;
  522.   ResetEvent( heventSRB );
  523.   dwStatus = pfnSendASPI32Command( (LPSRB)&s );
  524.   if ( dwStatus == SS_PENDING )
  525.     {
  526.       WaitForSingleObject( heventSRB, DEFWAITLEN );
  527.     }
  528.   CloseHandle( heventSRB );
  530.   if ( s.SRB_Status != SS_COMP )
  531.     {
  532.       alErrCode = ALERR_ASPI;
  533.       alAspiErr = s.SRB_Status;
  535. #ifdef _DEBUG
  536.       dbprintf( "akrip32: GetDriveInfo: Error status: 0x%04Xn", s.SRB_Status );
  537. #endif
  538.       return SS_ERR;
  539.     }
  541. #ifdef _DEBUG
  542.   {
  543.     FILE *fp = fopen( "inquiry.dat", "wb" );
  544.     fwrite( buf, 1, 100, fp );
  545.     fclose( fp );
  546.   }
  547. #endif
  549.   memcpy( cdrecTmp.info.vendor, &buf[8], 8 );
  550.   memcpy( cdrecTmp.info.prodId, &buf[16], 16 );
  551.   memcpy( cdrecTmp.info.rev, &buf[32], 4 );
  552.   memcpy( cdrecTmp.info.vendSpec, &buf[36], 20 );
  553.   wsprintf( outBuf, "%s, %s v%s (%d:%d:%d)", 
  554.     cdrecTmp.info.vendor, cdrecTmp.info.prodId, cdrecTmp.info.rev,
  555.     ha, tgt, lun );
  556. #ifdef _DEBUG
  557.   dbprintf( "akrip32: GetDriveInfo: %s", outBuf );
  558. #endif
  560.   strncpy( cdrecTmp.id, outBuf, MAXIDLEN );
  561.   cdrecTmp.id[MAXIDLEN] = 0;
  563.   if ( cdrec )
  564.     *cdrec = cdrecTmp;
  566.   return SS_COMP;
  567. }
  570. /***************************************************************************
  571.  * Function Name    ReadTOC
  572.  *
  573.  * 
  574.  ***************************************************************************/
  575. DWORD ReadTOC( HCDROM hCD, LPTOC toc )
  576. {
  577.   DWORD dwStatus;
  578.   DWORD retVal = SS_COMP;
  579.   HANDLE heventSRB;
  580.   SRB_ExecSCSICmd s;
  581.   int idx = (int)hCD - 1;
  583.   if ( (idx<0) || (idx>=MAXCDHAND) )
  584.     {
  585.       alErrCode = ALERR_INVHANDLE;
  586.       return SS_ERR;
  587.     }
  589.   if ( WaitForSingleObject( cdMutexes[idx], TIMEOUT ) != WAIT_OBJECT_0 )
  590.     {
  591.       alErrCode = ALERR_LOCK;
  592.       return SS_ERR;
  593.     }
  595.   if ( !cdHandles[idx].used )
  596.     {
  597.       alErrCode = ALERR_INVHANDLE;
  598.       ReleaseMutex( cdMutexes[idx] );
  599.       return SS_ERR;
  600.     }
  602.   heventSRB = CreateEvent( NULL, TRUE, FALSE, NULL );
  604.   memset( &s, 0, sizeof( s ) );
  605.   s.SRB_Cmd        = SC_EXEC_SCSI_CMD;
  606.   s.SRB_HaID       = cdHandles[idx].ha;
  607.   s.SRB_Target     = cdHandles[idx].tgt;
  608.   s.SRB_Lun        = cdHandles[idx].lun;
  609.   s.SRB_Flags      = SRB_DIR_IN | SRB_EVENT_NOTIFY;
  610.   s.SRB_BufLen     = 0x324;
  611.   s.SRB_BufPointer = (BYTE FAR *)toc;
  612.   s.SRB_SenseLen   = 0x0E;
  613.   s.SRB_CDBLen     = 0x0A;
  614.   s.SRB_PostProc   = (LPVOID)heventSRB;
  615.   s.CDBByte[0]     = 0x43;
  616.   s.CDBByte[1]     = cdHandles[idx].bMSF?0x02:0x00;
  617.   //  s.CDBByte[1] = 0x02;               /* 0x02 == MSF format, 0x00 == LBA */
  618.   s.CDBByte[7]     = 0x03;               /* length of buffer to hold TOC    */
  619.   s.CDBByte[8]     = 0x24;               /*      == 0x324                   */
  621.   ResetEvent( heventSRB );
  622.   dwStatus = pfnSendASPI32Command( (LPSRB)&s );
  624.   if ( dwStatus == SS_PENDING )
  625.     {
  626.       WaitForSingleObject( heventSRB, 4000 );
  627.     }
  628.   CloseHandle( heventSRB );
  630.   if ( s.SRB_Status != SS_COMP )
  631.     {
  632.       alErrCode = ALERR_ASPI;
  633.       alAspiErr = s.SRB_Status;
  634.       retVal = SS_ERR;
  635.     }
  637. #ifdef _DEBUG
  638.   {
  639.     FILE *fp = fopen( "toc.dat", "wb" );
  640.     fwrite( toc, 1, sizeof(TOC), fp );
  641.     fclose( fp );
  642.   }
  643. #endif
  645.   ReleaseMutex( cdMutexes[idx] );
  646.   return retVal;
  647. }
  650. /***************************************************************************
  651.  * resetSCSIBus
  652.  * 
  653.  * According to Adaptec, this command can cause problems in Win95
  654.  *
  655.  ***************************************************************************/
  656. void resetSCSIBus( void )
  657. {
  658.   DWORD dwStatus;
  659.   HANDLE heventSRB;
  660.   SRB_BusDeviceReset s;
  662.   dbprintf( "akrip32: reset bus!" );
  663.   heventSRB = CreateEvent( NULL, TRUE, FALSE, NULL );
  665.   memset( &s, 0, sizeof( s ) );
  666.   s.SRB_Cmd = SC_RESET_DEV;
  667.   s.SRB_PostProc = (LPVOID)heventSRB;
  669.   ResetEvent( heventSRB );
  670.   dwStatus = pfnSendASPI32Command( (LPSRB)&s );
  671.   if ( dwStatus == SS_PENDING )
  672.     {
  673.       WaitForSingleObject( heventSRB, DEFWAITLEN );
  674.     }
  675.   CloseHandle( heventSRB );
  677. #ifdef _DEBUG
  678.   if ( s.SRB_Status != SS_COMP )
  679.     {
  680.       dbprintf( "akrip32: RESET BUS aspi status: 0x%08Xn", s.SRB_Status );
  681.     }
  682. #endif
  683. }
  686. /******************************************************************
  687.  * GetCDList
  688.  *
  689.  * Scans all host adapters for CD-ROM units, and stores information
  690.  * for all units located
  691.  ******************************************************************/
  692. int GetCDList( LPCDLIST cd )
  693. {
  694.   SRB_HAInquiry sh;
  695.   SRB_GDEVBlock sd;
  696.   int numAdapters, i, j, k;
  697.   int maxTgt;
  699.   /* initialize cd list */
  700.   maxTgt = cd->max;
  701.   memset( cd, 0, sizeof(*cd) );
  702.   cd->max = maxTgt;
  704.   numAdapters = GetNumAdapters();
  705. #ifdef _DEBUG
  706.   dbprintf( "AKRip32: GetCDList(): numAdapters == %d", numAdapters );
  707. #endif
  708.   //return 0;
  710.   for( i = 0; i < numAdapters; i++ )
  711.     {
  712.       memset( &sh, 0, sizeof( sh ) );
  713.       sh.SRB_Cmd   = SC_HA_INQUIRY;
  714.       sh.SRB_HaID  = i;
  715.       pfnSendASPI32Command( (LPSRB)&sh );
  717.       /* on error skip to next adapter */
  718.       if ( sh.SRB_Status != SS_COMP )
  719. continue;
  721.       maxTgt = (int)sh.HA_Unique[3];
  723.       if ( maxTgt == 0 )
  724. maxTgt = 8;
  726.       for( j = 0; j < maxTgt; j++ )
  727. {
  728.   for( k = 0; k < 8; k++ )
  729.     {
  730.       memset( &sd, 0, sizeof( sd ) );
  731.       sd.SRB_Cmd   = SC_GET_DEV_TYPE;
  732.       sd.SRB_HaID  = i;
  733.       sd.SRB_Target = j;
  734.       sd.SRB_Lun   = k;
  735.       pfnSendASPI32Command( (LPSRB)&sd );
  736.       if ( sd.SRB_Status == SS_COMP )
  737. {
  738.   if ( sd.SRB_DeviceType == DTYPE_CDROM )
  739.     {
  740.       cd->cd[cd->num].ha = i;
  741.       cd->cd[cd->num].tgt = j;
  742.       cd->cd[cd->num].lun = k;
  743.       memset( cd->cd[cd->num].id, 0, MAXIDLEN+1 );
  744.       GetDriveInfo( i, j, k, &(cd->cd[cd->num]) );
  745.       // getDriveInfo( i, j, k, cd->cd[cd->num].id, MAXIDLEN+1 );
  746.       cd->num++;
  747.     }
  748. #ifdef _DEBUG
  749.   else
  750.     {
  751.       dbprintf( "       : sd.SRB_DeviceType == %d", sd.SRB_DeviceType );
  752.       GetDriveInfo( i, j, k, NULL );
  753.     }
  754. #endif
  755. }
  756.     }
  757. }
  758.     }
  760.   return 1;
  761. }
  764. DWORD ReadCDAudioLBA( HCDROM hCD, LPTRACKBUF t )
  765. {
  766.   int idx = (int)hCD - 1;
  767.   DWORD retVal;
  769.   if ( (idx<0) || (idx>=MAXCDHAND) )
  770.     {
  771.       alErrCode = ALERR_INVHANDLE;
  772.       return SS_ERR;
  773.     }
  775.   retVal = WaitForSingleObject( cdMutexes[idx], TIMEOUT );
  776.   if ( retVal != WAIT_OBJECT_0 )
  777.     {
  778.       alErrCode = ALERR_LOCK;
  779.       return SS_ERR;
  780.     }
  782.   if ( !cdHandles[idx].used )
  783.     {
  784.       alErrCode = ALERR_INVHANDLE;
  785.       ReleaseMutex( cdMutexes[idx] );
  786.       return SS_ERR;
  787.     }
  789.   retVal = cdHandles[idx].pfnRead( hCD, t );
  790.   ReleaseMutex( cdMutexes[idx] );
  792.   return retVal;
  793. }
  796. /*
  797.  * Test the currently set read function.  Fills the buffer with 0xAA
  798.  * prior to reading, and then checks the read area for a series of 0xAA
  799.  * bytes.  This is because some read commands do not return an error, but
  800.  * also don't read correct data or a full buffer.
  801.  */
  802. DWORD testReadCDAudio( HCDROM hCD, LPTRACKBUF t )
  803. {
  804.   DWORD i;
  805.   DWORD dwStatus;
  806.   BYTE *p;
  807.   int idx = (int)hCD - 1;
  808.   int count;
  810.   // fill buffer with dummy data
  811.   memset( t->buf, 0xAA, t->len );
  813.   dwStatus = cdHandles[idx].pfnRead( hCD, t );
  814.   if ( dwStatus != SS_COMP )
  815.     {
  816.       return dwStatus;
  817.     }
  819.   p = &(t->buf[t->startOffset]);
  820.   for( i = 0, count = 0; i < t->len; i += 4 )
  821.     {
  822.       if ( *((DWORD *)p) == 0xAAAAAAAA )
  823. count += 1;
  824.       else
  825. count = 0;
  826.       if ( count == 8 )
  827. {
  828.   return SS_ERR;
  829. }
  831.       p += 4;
  832.     }
  834.   return dwStatus;
  835. }
  838. /***************************************************************************
  839.  * readCDAudioLBA_ANY
  840.  *
  841.  * Attempts to autodetect the proper read function for the CD.  It tries
  842.  * ATAPI2, ATAPI1, and then finally READ10
  843.  *
  844.  ***************************************************************************/
  845. DWORD readCDAudioLBA_ANY( HCDROM hCD, LPTRACKBUF t )
  846. {
  847.   DWORD dwStatus;
  848.   int idx = (int)hCD - 1;
  849.   int i, j;
  850.   int ord[7] = { 2, 1, 8, 4, 5, 6, 7 };
  852.   if ( (idx<0) || (idx>=MAXCDHAND) || !cdHandles[idx].used )
  853.     {
  854.       alErrCode = ALERR_INVHANDLE;
  855.       return SS_ERR;
  856.     }
  858.   if ( t->numFrames * 2352 > t->maxLen )
  859.     {
  860.       alErrCode = ALERR_BUFTOOSMALL;
  861.       return SS_ERR;
  862.     }
  864.   for( i = 0; i < 7; i++ )
  865.     {
  866. #ifdef _DEBUG
  867.       dbprintf( "akrip32: testing read fn %d", ord[i] );
  868. #endif
  870.       cdHandles[idx].readType = ord[i];
  871.       cdHandles[idx].pfnRead = aReadFn[ord[i]];
  872.       cdHandles[idx].pfnDeinit = NULL;
  873.       cdHandles[idx].bInit = FALSE;
  875.       for( j = 0; j < 3; j++ )
  876. {
  877.   dwStatus = testReadCDAudio( hCD, t );
  878.   if ( dwStatus == SS_COMP )
  879.     {
  880.       return dwStatus;
  881.     }
  882. }
  883.     }
  886.   // Failed to find compatible read mode, so we reset to the default
  887.   // and return the error
  888.   cdHandles[idx].readType = CDR_ANY;
  889.   cdHandles[idx].pfnRead  = readCDAudioLBA_ANY;
  890.   return dwStatus;
  891. }
  894. DWORD GetASPI32SupportInfo( void )
  895. {
  896.   return pfnGetASPI32SupportInfo();
  897. }
  900. DWORD SendASPI32Command( LPSRB s )
  901. {
  902.   return pfnSendASPI32Command( s );
  903. }
  906. #define _GEN_CDPARMS 0
  907. DWORD readCDParameters( HCDROM hCD, BOOL bChangeMask )
  908. {
  909.   HANDLE h;
  910.   SRB_ExecSCSICmd s;
  911.   DWORD d;
  912.   BYTE b[256];
  913.   int lenData;
  914.   BYTE *p;
  915.   BYTE *pMax = b + 256;
  916.   LPSENSEMASK psm;
  917.   int idx = (int)hCD - 1;
  919. #if _GEN_CDPARMS
  920.   FILE *fp;
  921. #endif
  923.   if ( (idx<0) || (idx>=MAXCDHAND) || !cdHandles[idx].used )
  924.     {
  925.       alErrCode = ALERR_INVHANDLE;
  926.       return SS_ERR;
  927.     }
  929.   cdHandles[idx].smRead = FALSE;
  930.   psm = &cdHandles[idx].sm;
  931.   memset( psm, 0, sizeof( SENSEMASK ) );
  934.   h = CreateEvent( NULL, TRUE, FALSE, NULL );
  935.   memset( &s, 0, sizeof( s ) );
  936.   memset( b, 0xFF, 256 );
  937.   s.SRB_Cmd      = SC_EXEC_SCSI_CMD;
  938.   s.SRB_HaID     = cdHandles[idx].ha;
  939.   s.SRB_Target   = cdHandles[idx].tgt;
  940.   s.SRB_Lun      = cdHandles[idx].lun;
  941.   s.SRB_Flags    = SRB_DIR_IN | SRB_EVENT_NOTIFY;
  942.   s.SRB_BufLen   = 256;
  943.   s.SRB_BufPointer = b;
  944.   s.SRB_CDBLen   = 12;
  945.   s.SRB_PostProc = (LPVOID)h;
  946.   s.CDBByte[0]   = 0x5A;
  947.   s.CDBByte[2]   = 0x3F;
  948.   s.CDBByte[7]   = 0x01;
  949.   s.CDBByte[8]   = 0x00;
  951.   /* do we want just a mask of changable items? */
  952.   if ( bChangeMask )
  953.     s.CDBByte[2] |= 0x40;
  955.   ResetEvent( h );
  956.   d = pfnSendASPI32Command( (LPSRB)&s );
  957.   if ( d == SS_PENDING )
  958.     {
  959.       WaitForSingleObject( h, 500 );
  960.     }
  961.   CloseHandle( h );
  963.   if ( s.SRB_Status != SS_COMP )
  964.     {
  965.       alErrCode = ALERR_ASPI;
  966.       alAspiErr = s.SRB_Status;
  967.       ReleaseMutex( cdMutexes[idx] );
  968.       return SS_ERR;
  969.     }
  971. #if _GEN_CDPARMS
  972.   fp = fopen( "cdparms.dat", "wb" );
  973.   if ( fp )
  974.     {
  975.       fwrite( b, 1, 256, fp );
  976.       fclose( fp );
  977.     }
  978. #endif
  980.   lenData = ((unsigned int)b[0] << 8) + b[1];
  982.   /* set to first sense mask, and then walk through the masks */
  983.   p = b + 8;
  984.   while( (p < &(b[2+lenData])) && (p < pMax) )
  985.     {
  986.       BYTE which;
  988.       which = p[0] & 0x3F;
  989.       switch( which )
  990. {
  991. case READERRREC:
  992.   psm->rerAvail = TRUE;
  993.   memcpy( psm->rer, p, p[1]+2 );
  994.   break;
  995. case CDRPARMS:
  996.   psm->cpmAvail = TRUE;
  997.   memcpy( psm->cpm, p, p[1]+2 );
  998.   break;
  999. case CDRAUDIOCTL:
  1000.   psm->cacmAvail = TRUE;
  1001.   memcpy( psm->cacm, p, p[1]+2 );
  1002.   break;
  1003. case CDRCAPS:
  1004.   psm->ccsmAvail = TRUE;
  1005.   memcpy( psm->ccsm, p, p[1]+2 );
  1006.   break;
  1007. }
  1008.       p += (p[1] + 2);
  1009.     }
  1011.   cdHandles[idx].smRead = TRUE;
  1012.   return s.SRB_Status;
  1013. }
  1016. /****************************************************************
  1017.  * Generic function to query CD unit capabilities and parameters
  1018.  *
  1019.  * which:   specifies the parm we wish to query
  1020.  * pNum:    pointer to DWORD to return data
  1021.  *
  1022.  * returns: If the parm is not available, returns FALSE.  Otherwise
  1023.  *          returns TRUE.
  1024.  *
  1025.  * The data requested will either be returned as a BOOL, or copied
  1026.  * to pNum, depending on the parameter requested.
  1027.  ****************************************************************/
  1028. BOOL QueryCDParms( HCDROM hCD, int which, DWORD *pNum )
  1029. {
  1030.   BOOL retVal = FALSE;
  1031.   DWORD dwTmp;
  1032.   int idx = (int)hCD - 1;
  1034.   if ( (idx<0) || (idx>=MAXCDHAND) || !cdHandles[idx].used )
  1035.     {
  1036.       alErrCode = ALERR_INVHANDLE;
  1037.       return FALSE;
  1038.     }
  1040.   if ( WaitForSingleObject( cdMutexes[idx], TIMEOUT ) != WAIT_OBJECT_0 )
  1041.     {
  1042.       alErrCode = ALERR_LOCK;
  1043.       return SS_ERR;
  1044.     }
  1046.   if ( pNum )
  1047.     *pNum = 0;
  1048.   else
  1049.     pNum = &dwTmp;
  1051.   if ( !cdHandles[idx].smRead )
  1052.     {
  1053.       if ( readCDParameters( hCD, FALSE ) != SS_COMP )
  1054. {
  1055.   ReleaseMutex( cdMutexes[idx] );
  1056.   return FALSE;
  1057. }
  1058.     }
  1060.   switch( which )
  1061.     {
  1062.     case CDP_READCDR:
  1063.       retVal = cdHandles[idx].sm.ccsmAvail && (cdHandles[idx].sm.ccsm[2] & 0x01);
  1064.       break;
  1066.     case CDP_READCDE:
  1067.       retVal = cdHandles[idx].sm.ccsmAvail && (cdHandles[idx].sm.ccsm[2] & 0x02);
  1068.       break;
  1070.     case CDP_METHOD2:
  1071.       retVal = cdHandles[idx].sm.ccsmAvail && (cdHandles[idx].sm.ccsm[2] & 0x04);
  1072.       break;
  1074.     case CDP_WRITECDR:
  1075.       retVal = cdHandles[idx].sm.ccsmAvail && (cdHandles[idx].sm.ccsm[3] & 0x01);
  1076.       break;
  1078.     case CDP_WRITECDE:
  1079.       retVal = cdHandles[idx].sm.ccsmAvail && (cdHandles[idx].sm.ccsm[3] & 0x02);
  1080.       break;
  1082.     case CDP_AUDIOPLAY:
  1083.       retVal = cdHandles[idx].sm.ccsmAvail && (cdHandles[idx].sm.ccsm[4] & 0x01);
  1084.       break;
  1086.     case CDP_COMPOSITE:
  1087.       retVal = cdHandles[idx].sm.ccsmAvail && (cdHandles[idx].sm.ccsm[4] & 0x02);
  1088.       break;
  1090.     case CDP_DIGITAL1:
  1091.       retVal = cdHandles[idx].sm.ccsmAvail && (cdHandles[idx].sm.ccsm[4] & 0x04);
  1092.       break;
  1094.     case CDP_DIGITAL2:
  1095.       retVal = cdHandles[idx].sm.ccsmAvail && (cdHandles[idx].sm.ccsm[4] & 0x08);
  1096.       break;
  1098.     case CDP_M2FORM1:
  1099.       retVal = cdHandles[idx].sm.ccsmAvail && (cdHandles[idx].sm.ccsm[4] & 0x10);
  1100.       break;
  1102.     case CDP_M2FORM2:
  1103.       retVal = cdHandles[idx].sm.ccsmAvail && (cdHandles[idx].sm.ccsm[4] & 0x20);
  1104.       break;
  1106.     case CDP_MULTISES:
  1107.       retVal = cdHandles[idx].sm.ccsmAvail && (cdHandles[idx].sm.ccsm[4] & 0x40);
  1108.       break;
  1110.     case CDP_CDDA:
  1111.       retVal = cdHandles[idx].sm.ccsmAvail && (cdHandles[idx].sm.ccsm[5] & 0x01);
  1112.       break;
  1114.     case CDP_RW:
  1115.       retVal = cdHandles[idx].sm.ccsmAvail && (cdHandles[idx].sm.ccsm[5] & 0x04);
  1116.       break;
  1118.     case CDP_RWCORR:
  1119.       retVal = cdHandles[idx].sm.ccsmAvail && (cdHandles[idx].sm.ccsm[5] & 0x08);
  1120.       break;
  1122.     case CDP_C2SUPP:
  1123.       retVal = cdHandles[idx].sm.ccsmAvail && (cdHandles[idx].sm.ccsm[5] & 0x10);
  1124.       break;
  1126.     case CDP_ISRC:
  1127.       retVal = cdHandles[idx].sm.ccsmAvail && (cdHandles[idx].sm.ccsm[5] & 0x20);
  1128.       break;
  1130.     case CDP_UPC:
  1131.       retVal = cdHandles[idx].sm.ccsmAvail && (cdHandles[idx].sm.ccsm[5] & 0x40);
  1132.       break;
  1134.     case CDP_CANLOCK:
  1135.       retVal = cdHandles[idx].sm.ccsmAvail && (cdHandles[idx].sm.ccsm[6] & 0x01);
  1136.       break;
  1138.     case CDP_LOCKED:
  1139.       retVal = cdHandles[idx].sm.ccsmAvail && (cdHandles[idx].sm.ccsm[6] & 0x02);
  1140.       break;
  1142.     case CDP_PREVJUMP:
  1143.       retVal = cdHandles[idx].sm.ccsmAvail && (cdHandles[idx].sm.ccsm[6] & 0x04);
  1144.       break;
  1146.     case CDP_CANEJECT:
  1147.       retVal = cdHandles[idx].sm.ccsmAvail && (cdHandles[idx].sm.ccsm[6] & 0x08);
  1148.       break;
  1150.     case CDP_SEPVOL:
  1151.       retVal = cdHandles[idx].sm.ccsmAvail && (cdHandles[idx].sm.ccsm[7] & 0x01);
  1152.       break;
  1154.     case CDP_SEPMUTE:
  1155.       retVal = cdHandles[idx].sm.ccsmAvail && (cdHandles[idx].sm.ccsm[7] & 0x02);
  1156.       break;
  1158.     case CDP_SDP:
  1159.       retVal = cdHandles[idx].sm.ccsmAvail && (cdHandles[idx].sm.ccsm[7] & 0x04);
  1160.       break;
  1162.     case CDP_SSS:
  1163.       retVal = cdHandles[idx].sm.ccsmAvail && (cdHandles[idx].sm.ccsm[7] & 0x08);
  1164.       break;
  1166.     case CDP_MECHTYPE:
  1167.       if ( cdHandles[idx].sm.ccsmAvail )
  1168. {
  1169.   retVal = TRUE;
  1170.   *pNum = (DWORD)(cdHandles[idx].sm.ccsm[6] >> 5);
  1171. }
  1172.       break;
  1174.     case CDP_STREAMACC:
  1175.       return cdHandles[idx].sm.ccsmAvail && (cdHandles[idx].sm.ccsm[5] & 0x02);
  1176.       break;
  1178.     case CDP_MAXSPEED:
  1179.       if ( cdHandles[idx].sm.ccsmAvail )
  1180. {
  1181.   retVal = TRUE;
  1182.   *pNum = ((DWORD)cdHandles[idx].sm.ccsm[8] << 8) + (DWORD)cdHandles[idx].sm.ccsm[9];
  1183. }
  1184.       break;
  1186.     case CDP_NUMVOL:
  1187.       if ( cdHandles[idx].sm.ccsmAvail )
  1188. {
  1189.   retVal = TRUE;
  1190.   *pNum = ((DWORD)cdHandles[idx].sm.ccsm[10] << 8) + (DWORD)cdHandles[idx].sm.ccsm[11];
  1191. }
  1192.       break;
  1194.     case CDP_BUFSIZE:
  1195.       if ( cdHandles[idx].sm.ccsmAvail )
  1196. {
  1197.   retVal = TRUE;
  1198.   *pNum = ((DWORD)cdHandles[idx].sm.ccsm[12] << 8) + (DWORD)cdHandles[idx].sm.ccsm[13];
  1199. }
  1200.       break;
  1202.     case CDP_CURRSPEED:
  1203.       if ( cdHandles[idx].sm.ccsmAvail )
  1204. {
  1205.   retVal = TRUE;
  1206.   *pNum = ((DWORD)cdHandles[idx].sm.ccsm[14] << 8) + (DWORD)cdHandles[idx].sm.ccsm[15];
  1207. }
  1208.       break;
  1210.     case CDP_SPM:
  1211.       if ( cdHandles[idx].sm.cpmAvail )
  1212. {
  1213.   retVal = TRUE;
  1214.   *pNum = ((DWORD)cdHandles[idx].sm.cpm[4] << 8) + (DWORD)cdHandles[idx].sm.cpm[5];
  1215. }
  1216.       break;
  1218.     case CDP_FPS:
  1219.       if ( cdHandles[idx].sm.cpmAvail )
  1220. {
  1221.   retVal = TRUE;
  1222.   *pNum = ((DWORD)cdHandles[idx].sm.cpm[6] << 8) + (DWORD)cdHandles[idx].sm.cpm[7];
  1223. }
  1224.       break;
  1226.     case CDP_INACTMULT:
  1227.       if ( cdHandles[idx].sm.cpmAvail )
  1228. {
  1229.   retVal = TRUE;
  1230.   *pNum = (DWORD)(cdHandles[idx].sm.cpm[3] & 0x0F);
  1231. }
  1232.       break;
  1234.     case CDP_MSF:
  1235.       retVal = cdHandles[idx].bMSF;
  1236.       break;
  1238.     case CDP_JITTER:
  1239.       retVal = TRUE;
  1240.       *pNum = (DWORD)(cdHandles[idx].numCheck);
  1241.       break;
  1243.     case CDP_OVERLAP:
  1244.       retVal = TRUE;
  1245.       *pNum = (DWORD)(cdHandles[idx].numOverlap);
  1246.       break;
  1248.     case CDP_READMODE:
  1249.       retVal = TRUE;
  1250.       *pNum = (DWORD)(cdHandles[idx].readMode);
  1251.       break;
  1253.     default:
  1254.       break;
  1255.     }
  1257.   ReleaseMutex( cdMutexes[idx] );
  1258.   return retVal;
  1259. }
  1262. /*
  1263.  * Complement to queryCDParms -- used to set values in the various control
  1264.  * pages on the CD drive.
  1265.  */
  1266. BOOL ModifyCDParms( HCDROM hCD, int which, DWORD val )
  1267. {
  1268.   //SENSEMASK smask;
  1269.   //BOOL smRead = FALSE;
  1270.   BOOL retVal = FALSE;
  1271.   int idx = (int)hCD - 1;
  1273.   if ( (idx<0) || (idx>=MAXCDHAND) || !cdHandles[idx].used )
  1274.     {
  1275.       alErrCode = ALERR_INVHANDLE;
  1276.       return FALSE;
  1277.     }
  1279.   if ( WaitForSingleObject( cdMutexes[idx], TIMEOUT ) != WAIT_OBJECT_0 )
  1280.     {
  1281.       alErrCode = ALERR_LOCK;
  1282.       return SS_ERR;
  1283.     }
  1285. #if 0
  1286.   if ( readCDParameters( hCD, TRUE ) != SS_COMP )
  1287.     {
  1288.       ReleaseMutex( cdMutexes[idx] );
  1289.       return FALSE;
  1290.     }
  1291. #endif
  1293.   switch( which )
  1294.     {
  1295.     case CDP_CURRSPEED:
  1296.       if ( setCDSpeed( hCD, val ) == SS_COMP )
  1297. retVal = TRUE;
  1298.       break;
  1300.     case CDP_MSF:
  1301.       cdHandles[idx].bMSF = (BOOL)val;
  1302.       retVal = TRUE;
  1303.       break;
  1305.     case CDP_JITTER:
  1306.       cdHandles[idx].numCheck = (int)val;
  1307.       retVal = TRUE;
  1308.       break;
  1310.     case CDP_OVERLAP:
  1311.       cdHandles[idx].numOverlap = (int)val;
  1312.       retVal = TRUE;
  1313.       break;
  1315.     case CDP_READMODE:
  1316.       cdHandles[idx].readMode = (int)val;
  1317.       retVal = TRUE;
  1318.       break;
  1319.     }
  1321.   ReleaseMutex( cdMutexes[idx] );
  1322.   return retVal;
  1323. }
  1326. /*
  1327.  * Speed is specified in KB/sec: 1x == 176, 2x == 353, 4x == 706
  1328.  *
  1329.  * To set to the maximum allowed speed, specify 0xFFFF.  Attempting to set
  1330.  * a speed higher than the allowed maximum speed should not cause an error,
  1331.  * but should set the speed at the highest allowed value.
  1332.  */
  1333. DWORD setCDSpeed( HCDROM hCD, DWORD speed )
  1334. {
  1335.   DWORD dwStatus;
  1336.   HANDLE heventSRB;
  1337.   SRB_ExecSCSICmd s;
  1338.   int idx = (int)hCD - 1;
  1340.   if ( (idx<0) || (idx>=MAXCDHAND) || !cdHandles[idx].used )
  1341.     {
  1342.       alErrCode = ALERR_INVHANDLE;
  1343.       return SS_ERR;
  1344.     }
  1346.   heventSRB = CreateEvent( NULL, TRUE, FALSE, NULL );
  1348.   memset( &s, 0, sizeof( s ) );
  1350.   s.SRB_Cmd      = SC_EXEC_SCSI_CMD;
  1351.   s.SRB_HaID     = cdHandles[idx].ha;
  1352.   s.SRB_Target   = cdHandles[idx].tgt;
  1353.   s.SRB_Lun      = cdHandles[idx].lun;
  1354.   s.SRB_Flags    = SRB_DIR_OUT | SRB_EVENT_NOTIFY;
  1355.   s.SRB_SenseLen = SENSE_LEN;
  1356.   s.SRB_CDBLen   = 12;
  1357.   s.SRB_PostProc = (LPVOID)heventSRB;
  1358.   s.CDBByte[0]   = 0xBB;
  1359.   s.CDBByte[2]   = (BYTE)(speed >> 8);
  1360.   s.CDBByte[3]   = (BYTE)speed;
  1362.   ResetEvent( heventSRB );
  1363.   dwStatus = pfnSendASPI32Command( (LPSRB)&s );
  1364.   if ( dwStatus == SS_PENDING )
  1365.     {
  1366.       WaitForSingleObject( heventSRB, DEFWAITLEN );
  1367.     }
  1368.   CloseHandle( heventSRB );
  1370.   if ( s.SRB_Status != SS_COMP )
  1371.     {
  1372.       alErrCode = ALERR_ASPI;
  1373.       alAspiErr = s.SRB_Status;
  1374.       CloseHandle( cdMutexes[idx] );
  1375.       return SS_ERR;
  1376.     }
  1378.   return s.SRB_Status;
  1379. }
  1382. DWORD pauseResumeCD( HCDROM hCD, BOOL bPause )
  1383. {
  1384.   DWORD dwStatus;
  1385.   HANDLE heventSRB;
  1386.   SRB_ExecSCSICmd s;
  1387.   int idx = (int)hCD - 1;
  1389.   if ( (idx<0) || (idx>=MAXCDHAND) || !cdHandles[idx].used )
  1390.     {
  1391.       alErrCode = ALERR_INVHANDLE;
  1392.       return SS_ERR;
  1393.     }
  1395.   if ( WaitForSingleObject( cdMutexes[idx], TIMEOUT ) != WAIT_OBJECT_0 )
  1396.     {
  1397.       alErrCode = ALERR_LOCK;
  1398.       return SS_ERR;
  1399.     }
  1401.   heventSRB = CreateEvent( NULL, TRUE, FALSE, NULL );
  1403.   memset( &s, 0, sizeof( s ) );
  1405.   s.SRB_Cmd      = SC_EXEC_SCSI_CMD;
  1406.   s.SRB_HaID     = cdHandles[idx].ha;
  1407.   s.SRB_Target   = cdHandles[idx].tgt;
  1408.   s.SRB_Lun      = cdHandles[idx].lun;
  1409.   s.SRB_Flags    = SRB_EVENT_NOTIFY;
  1410.   s.SRB_SenseLen = SENSE_LEN;
  1411.   s.SRB_CDBLen   = 10;
  1412.   s.SRB_PostProc = (LPVOID)heventSRB;
  1413.   s.CDBByte[0]   = 0x4B;
  1414.   s.CDBByte[8]   = bPause?0:1;
  1416.   ResetEvent( heventSRB );
  1417.   dwStatus = pfnSendASPI32Command( (LPSRB)&s );
  1418.   if ( dwStatus == SS_PENDING )
  1419.     {
  1420.       WaitForSingleObject( heventSRB, DEFWAITLEN );
  1421.     }
  1422.   CloseHandle( heventSRB );
  1424.   if ( s.SRB_Status != SS_COMP )
  1425.     {
  1426.       alErrCode = ALERR_ASPI;
  1427.       alAspiErr = s.SRB_Status;
  1428.       ReleaseMutex( cdMutexes[idx] );
  1429.       return SS_ERR;
  1430.     }
  1432.   ReleaseMutex( cdMutexes[idx] );
  1433.   return s.SRB_Status;
  1434. }
  1437. DWORD startStopUnit( HCDROM hCD, BOOL bLoEj, BOOL bStart )
  1438. {
  1439.   DWORD dwStatus;
  1440.   HANDLE heventSRB;
  1441.   SRB_ExecSCSICmd s;
  1442.   int idx = (int)hCD - 1;
  1444.   if ( (idx<0) || (idx>=MAXCDHAND) || !cdHandles[idx].used )
  1445.     {
  1446.       alErrCode = ALERR_INVHANDLE;
  1447.       return SS_ERR;
  1448.     }
  1449.  
  1450.   if ( WaitForSingleObject( cdMutexes[idx], TIMEOUT ) != WAIT_OBJECT_0 )
  1451.     {
  1452.       alErrCode = ALERR_LOCK;
  1453.       return SS_ERR;
  1454.     }
  1456.   heventSRB = CreateEvent( NULL, TRUE, FALSE, NULL );
  1458.   memset( &s, 0, sizeof( s ) );
  1460.   s.SRB_Cmd      = SC_EXEC_SCSI_CMD;
  1461.   s.SRB_HaID     = cdHandles[idx].ha;
  1462.   s.SRB_Target   = cdHandles[idx].tgt;
  1463.   s.SRB_Lun      = cdHandles[idx].lun;
  1464.   s.SRB_Flags    = SRB_EVENT_NOTIFY;
  1465.   s.SRB_SenseLen = SENSE_LEN;
  1466.   s.SRB_CDBLen   = 6;
  1467.   s.SRB_PostProc = (LPVOID)heventSRB;
  1468.   s.CDBByte[0]   = 0x1B;
  1469.   s.CDBByte[4]  |= bLoEj?0x02:0x00;
  1470.   s.CDBByte[4]  |= bStart?0x01:0x00;
  1472.   ResetEvent( heventSRB );
  1473.   dwStatus = pfnSendASPI32Command( (LPSRB)&s );
  1474.   if ( dwStatus == SS_PENDING )
  1475.     {
  1476.       WaitForSingleObject( heventSRB, DEFWAITLEN );
  1477.     }
  1478.   CloseHandle( heventSRB );
  1480.   if ( s.SRB_Status != SS_COMP )
  1481.     {
  1482.       alErrCode = ALERR_ASPI;
  1483.       alAspiErr = s.SRB_Status;
  1484.       ReleaseMutex( cdMutexes[idx] );
  1485.       return SS_ERR;
  1486.     }
  1488.   ReleaseMutex( cdMutexes[idx] );
  1489.   return s.SRB_Status;
  1490. }
  1493. /****************************************************************
  1494.  * GetAspiLibError
  1495.  *
  1496.  * Used after functions return SS_ERR to get more specific error
  1497.  * information.  If it returns AL_ERRASPI, call getAspiLibAspiError
  1498.  * to get the actual status code returned by the calls to the ASPI
  1499.  * manager.  After reading, the error code is cleared.
  1500.  *
  1501.  ****************************************************************/
  1502. int GetAspiLibError( void )
  1503. {
  1504.   int retVal;
  1506.   retVal = alErrCode;
  1507.   alErrCode = ALERR_NOERROR;
  1509.   return retVal;
  1510. }
  1513. /****************************************************************
  1514.  * GetAspiLibAspiError
  1515.  *
  1516.  * Returns the last error completion code from the ASPI manager.
  1517.  * After reading, the error code is cleared.
  1518.  *
  1519.  ****************************************************************/
  1520. BYTE GetAspiLibAspiError( void )
  1521. {
  1522.   BYTE retVal;
  1524.   retVal = alAspiErr;
  1525.   alAspiErr = SS_COMP;
  1527.   return retVal;
  1528. }
  1531. /****************************************************************
  1532.  * GetCDId
  1533.  *
  1534.  * Generates an identifier string for the CD drive identified by
  1535.  * hCD
  1536.  *
  1537.  ****************************************************************/
  1538. DWORD  GetCDId( HCDROM hCD, char *buf, int maxBuf )
  1539. {
  1540.   int idx = (int)hCD - 1;
  1541.   CDREC cd;
  1543.   if ( (idx<0) || (idx>=MAXCDHAND) || !cdHandles[idx].used )
  1544.     {
  1545.       alErrCode = ALERR_INVHANDLE;
  1546.       return SS_ERR;
  1547.     }
  1549.   if ( !buf )
  1550.     {
  1551.       alErrCode = ALERR_BUFPTR;
  1552.       return SS_ERR;
  1553.     }
  1555.   if ( WaitForSingleObject( cdMutexes[idx], TIMEOUT ) != WAIT_OBJECT_0 )
  1556.     {
  1557.       alErrCode = ALERR_LOCK;
  1558.       return SS_ERR;
  1559.     }
  1561.   memset( &cd, 0, sizeof(cd) );
  1562.   GetDriveInfo( cdHandles[idx].ha, cdHandles[idx].tgt, cdHandles[idx].lun,
  1563. &cd );
  1564.   if ( strlen( cd.id ) > maxBuf-1 )
  1565.     {
  1566.       alErrCode = ALERR_BUFTOOSMALL;
  1567.       strncpy( buf, cd.id, maxBuf );
  1568.       buf[maxBuf-1] = '';
  1569.       ReleaseMutex( cdMutexes[idx] );
  1570.       return SS_ERR;
  1571.     }
  1572.   else
  1573.     strcpy( buf, cd.id );
  1575.   ReleaseMutex( cdMutexes[idx] );
  1576.   return SS_COMP;
  1577. }
  1580. /*
  1581.  * Returns TRUE if the overlap buffer is located in the track buffer.  The
  1582.  * track buffer startOffset is adjusted to reflect where in the buffer the
  1583.  * aligned data begins.  numFrames and len are also adjusted to reflect the
  1584.  * number of complete frames are contained in the buffer.
  1585.  */
  1586. int jitterAdjust( LPTRACKBUF tbuf, LPTRACKBUF tover, int checkFrames )
  1587. {
  1588.   int i;
  1589.   int max;
  1590.   int bFound = 0;
  1591.   BYTE *p;
  1592.   int checkLen = checkFrames * 2352;
  1594.   max = tbuf->len - checkLen;
  1596.   if ( tover->len == 0 )
  1597.     return 1;
  1599.   p = &tover->buf[tover->startOffset];
  1601.   bFound = 0;
  1602.   for( i = 0; i < max; i++ )
  1603.     {
  1604.       if ( compBuf( p, &(tbuf->buf[i]), checkLen ) )
  1605. {
  1606.   tbuf->startOffset = i + checkLen;
  1607.   tbuf->len -= (i + checkLen);
  1608.   tbuf->startFrame = tover->startFrame + checkFrames;
  1609.   i = max + 1;
  1610.   bFound = -1;
  1611. }
  1612.     }
  1614.   /* adjust frame count and crop length */
  1615.   tbuf->numFrames = tbuf->len / 2352;
  1616.   tbuf->len = 2352 * tbuf->numFrames;
  1618.   //  return (tbuf->startOffset == 0);
  1619.   return bFound;
  1620. }
  1623. /*
  1624.  * Reads CD-DA audio, implementing jitter correction.  tOver is used to align
  1625.  * the current read, if possible.  After a successful read, numOverlap frames
  1626.  * are copied to tOver.
  1627.  */
  1628. DWORD ReadCDAudioLBAEx( HCDROM hCD, LPTRACKBUF t, LPTRACKBUF tOver )
  1629. {
  1630.   DWORD retVal;
  1631.   int idx = (int)hCD - 1;
  1632.   int j, o;
  1633.   unsigned char *pOverAddr;
  1634.   BOOL bJitterCorr;
  1636.   if ( (idx<0) || (idx>=MAXCDHAND) )
  1637.     {
  1638.       alErrCode = ALERR_INVHANDLE;
  1639.       return SS_ERR;
  1640.     }
  1642.   retVal = WaitForSingleObject( cdMutexes[idx], TIMEOUT );
  1643.   if ( retVal != WAIT_OBJECT_0 )
  1644.     {
  1645.       alErrCode = ALERR_LOCK;
  1646.       return SS_ERR;
  1647.     }
  1649.   if ( !cdHandles[idx].used )
  1650.     {
  1651.       alErrCode = ALERR_INVHANDLE;
  1652.       ReleaseMutex( cdMutexes[idx] );
  1653.       return SS_ERR;
  1654.     }
  1656.   j = cdHandles[idx].numCheck;
  1657.   o = cdHandles[idx].numOverlap;
  1659.   // check that the overlap buffer is large enough -- if not, disable
  1660.   // jitter correction.  We may want to eventually throw an error
  1661.   bJitterCorr = ((tOver->maxLen / 2352) >= o);
  1663. #ifdef _DEBUG
  1664.   dbprintf( "akrip32: ReadCDAudioLBAEx( t->startFrame == %08X, tOver->startFrame == %08X, j == %d )", t->startFrame, tOver->startFrame, j );
  1665.   dbprintf( "       : t: %08X %d %d", t->startFrame, t->numFrames, t->len );
  1666.   dbprintf( "       : tOver: %08X %d %d", tOver->startFrame, tOver->numFrames, tOver->len );
  1667. #endif
  1669.   // adjust the starting address of the read if necessary
  1670.   if ( bJitterCorr && tOver->startFrame && tOver->numFrames && tOver->len )
  1671.     {
  1672.       // is this tOver from the last sequential read?
  1673.       if ( tOver->startFrame == (t->startFrame - j) )
  1674. {
  1675. #ifdef _DEBUG
  1676.   dbprintf( "Rolling back the read..." );
  1677. #endif
  1678.   t->startFrame -= o;
  1679. }
  1680.       else
  1681. {
  1682. #ifdef _DEBUG
  1683.   dbprintf( "Zeroing out the overlap!" );
  1684. #endif
  1685.   tOver->len = tOver->startFrame = tOver->numFrames = 0;
  1686. }
  1687.     }
  1689.   retVal = cdHandles[idx].pfnRead( hCD, t );
  1691.   if ( (retVal == SS_COMP) && bJitterCorr )
  1692.     {
  1693. #ifdef _DEBUG
  1694.       dbprintf( "akrip32: ReadCDAudioLBAEx: read itself OK" );
  1695. #endif
  1696.       j = cdHandles[idx].numCheck;
  1697.       if ( !jitterAdjust( t, tOver, j ) )
  1698. {
  1699. #ifdef _DEBUG
  1700.   dbprintf( "akrip32: ... jitterAdjust failed!" );
  1701. #endif
  1702.   alErrCode = ALERR_JITTER;
  1703.   ReleaseMutex( cdMutexes[idx] );
  1704.   return SS_ERR;
  1705. }
  1706. #ifdef _DEBUG
  1707.       dbprintf( "akrip32: ... after successful jitter adjust" );
  1708. #endif
  1709.       pOverAddr = &(t->buf[2352*(t->numFrames-j)+t->startOffset]);
  1710.       memcpy( tOver->buf, pOverAddr, 2352*j );
  1712.       tOver->startFrame = t->startFrame + t->numFrames - j;
  1713.       tOver->numFrames = j;
  1714.       tOver->len = 2352 * j;
  1715.       tOver->startOffset = 0;
  1716.     }
  1717. #ifdef _DEBUG
  1718.   else
  1719.     dbprintf( "akrip32: ReadCDAudioLBAEx: read failed" );
  1720. #endif
  1722.   ReleaseMutex( cdMutexes[idx] );
  1724. #ifdef _DEBUG
  1725.   dbprintf( "akrip32: readCDAudioLBAEx: returning %04X", retVal );
  1726. #endif
  1728.   return retVal;
  1729. }
  1732. /********************************************************************
  1733.  * compBuf
  1734.  *
  1735.  * Compares two buffers up to n bytes, returning 1 if they contain the
  1736.  * same data, or zero if they are different.
  1737.  *
  1738.  ********************************************************************/
  1739. int compBuf( BYTE *b1, BYTE *b2, int n )
  1740. {
  1741. #if 0
  1742.   int i;
  1744.   for( i = 0; i < n; i++ )
  1745.     if ( b1[i] != b2[i] )
  1746.       {
  1747. return 0;
  1748.       }
  1750.   return 1;
  1751. #else
  1752.   return !memcmp( b1, b2, n );
  1753. #endif
  1754. }
  1758. DWORD GetAKRipDllVersion( void )
  1759. {
  1760.   DWORD retVal;
  1762.   retVal = (DWORD)( (((WORD)MAJVER)<<16) | (WORD)MINVER );
  1763.   return retVal;
  1764. }
  1767. void dbprintf( char *fmt, ... )
  1768. {
  1769.   char buf[512];
  1770.   va_list arg;
  1772.   va_start( arg, fmt );
  1774.   vsprintf( buf, fmt, arg );
  1775.   OutputDebugString( buf );
  1777.   va_end( arg );
  1778. }