readd4.c
上传用户:xmgzy123
上传日期:2007-01-07
资源大小:373k
文件大小:6k
源码类别:

SCSI/ASPI

开发平台:

WINDOWS

  1. /*
  2.  * readd4.c - Copyright (C) 1999 Jay A. Key
  3.  *
  4.  * Functions for the CDR_READ_D4 class of read/init/deinit functions
  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: readd4.c,v 1.2 2000/02/25 10:47:37 akey Exp $
  25.  * $Date: 2000/02/25 10:47:37 $
  26.  * $Locker:  $
  27.  * $Log: readd4.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.4  2000/02/14 09:56:25  akey
  32.  * cleaned up #ifdef _DEBUG code considerably
  33.  *
  34.  * Revision 1.3  2000/01/07 09:04:22  akey
  35.  * Fixed stupid bug with && used in place of &
  36.  *
  37.  * Revision 1.2  2000/01/03 12:29:43  akey
  38.  * v0.91 release -- added CDDB and bug fixes
  39.  *
  40.  *
  41.  */
  42. #define _AKRIP32_
  43. #include <windows.h>
  44. #include <stdio.h>
  45. #include "myaspi32.h"
  46. #include "scsidefs.h"
  47. #include "aspilib.h"
  48. #include "akrip32.h"
  49. extern CDHANDLEREC *cdHandles;
  50. extern HANDLE *cdMutexes;
  51. extern CRITICAL_SECTION getHandle;
  52. extern int alErrCode;
  53. extern BYTE alAspiErr;
  54. extern int *nextHandle;
  55. extern DWORD (*pfnSendASPI32Command)(LPSRB);
  56. DWORD d4_1ModeSelect( HCDROM hCD );
  57. /***************************************************************************
  58.  * readCDAudioLBA_D4
  59.  ***************************************************************************/
  60. DWORD readCDAudioLBA_D4( HCDROM hCD, LPTRACKBUF t )
  61. {
  62.   DWORD dwStatus;
  63.   HANDLE heventSRB;
  64.   SRB_ExecSCSICmd s;
  65.   int idx = (int)hCD - 1;
  66.   if ( (idx<0) || (idx>=MAXCDHAND) || !cdHandles[idx].used )
  67.     {
  68.       alErrCode = ALERR_INVHANDLE;
  69.       return SS_ERR;
  70.     }
  71.   if ( t->numFrames * 2352 > t->maxLen )
  72.     {
  73.       alErrCode = ALERR_BUFTOOSMALL;
  74.       return SS_ERR;
  75.     }
  76.   dwStatus = WaitForSingleObject( cdMutexes[idx], TIMEOUT );
  77.   if ( dwStatus != WAIT_OBJECT_0 )
  78.     {
  79.       alErrCode = ALERR_LOCK;
  80.       return SS_ERR;
  81.     }
  82.   if ( !cdHandles[idx].bInit )
  83.     {
  84.       pauseResumeCD( hCD, TRUE );  // stop the unit if happens to be playing
  85.       if ( cdHandles[idx].readType == CDR_READ_D4_1 )
  86. d4_1ModeSelect( hCD );
  87.       cdHandles[idx].bInit = TRUE;
  88.     }
  89. #ifdef _DEBUG
  90.   dbprintf( "akrip32: readCDAudioLBA_D4: (%d:%d:%d) %08X:%02X", 
  91.     cdHandles[idx].ha, cdHandles[idx].tgt, cdHandles[idx].lun,
  92.     t->startFrame, t->numFrames );
  93. #endif
  94.   heventSRB = CreateEvent( NULL, TRUE, FALSE, NULL );
  95.   memset( &s, 0, sizeof( s ) );
  96.   s.SRB_Cmd        = SC_EXEC_SCSI_CMD;
  97.   s.SRB_HaID       = cdHandles[idx].ha;
  98.   s.SRB_Target     = cdHandles[idx].tgt;
  99.   s.SRB_Lun        = cdHandles[idx].lun;
  100.   s.SRB_Flags      = SRB_DIR_IN | SRB_EVENT_NOTIFY;
  101.   s.SRB_BufLen     = t->maxLen;
  102.   s.SRB_BufPointer = &(t->buf[0]);
  103.   s.SRB_SenseLen   = SENSE_LEN;
  104.   s.SRB_CDBLen     = 10;
  105.   s.SRB_PostProc   = (LPVOID)heventSRB;
  106.   s.CDBByte[0]     = 0xD4;
  107.   s.CDBByte[3]     = (t->startFrame >> 16) & 0xFF;
  108.   s.CDBByte[4]     = (t->startFrame >> 8) & 0xFF;
  109.   s.CDBByte[5]     = t->startFrame & 0xFF;
  110.   s.CDBByte[8]     = t->numFrames & 0xFF;
  111.   ResetEvent( heventSRB );
  112.   dwStatus = pfnSendASPI32Command( (LPSRB)&s );
  113.   if ( dwStatus == SS_PENDING )
  114.     {
  115.       WaitForSingleObject( heventSRB, DEFWAITLEN );
  116.     }
  117.   CloseHandle( heventSRB );
  118.   if ( s.SRB_Status != SS_COMP )
  119.     {
  120. #ifdef _DEBUG
  121.       BYTE *p;
  122.       dbprintf( "akrip32: readCDAudioLBA_D4: ERROR! 0x%08Xn", s.SRB_Status );
  123.       dbprintf( "akrip32:  haStat == %d (0x%04X), tgtStat == %d (0x%04X)",
  124.        s.SRB_HaStat, s.SRB_HaStat, s.SRB_TargStat, s.SRB_TargStat );
  125.       p = s.SenseArea;
  126.       dbprintf( "  %02X %02X %02X %02X %02X %02X %02X %02X",
  127.        p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7] );
  128.       p = &(s.SenseArea[8]);
  129.       dbprintf( "  %02X %02X %02X %02X %02X %02X %02X %02X",
  130.        p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7] );
  131. #endif
  132.       alErrCode = ALERR_ASPI;
  133.       alAspiErr = s.SRB_Status;
  134.       ReleaseMutex( cdMutexes[idx] );
  135.       return SS_ERR;
  136.     }
  137.   t->len = t->numFrames * 2352;
  138.   t->startOffset = 0;
  139.   t->status = s.SRB_Status;
  140.   ReleaseMutex( cdMutexes[idx] );
  141.   return s.SRB_Status;
  142. }
  143. /***************************************************************************
  144.  * readCDAudioLBA_D4
  145.  ***************************************************************************/
  146. DWORD d4_1ModeSelect( HCDROM hCD )
  147. {
  148.   DWORD dwStatus;
  149.   HANDLE heventSRB;
  150.   SRB_ExecSCSICmd s;
  151.   int idx = (int)hCD - 1;
  152.   BYTE buf[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x09, 0x30 };
  153.   if ( (idx<0) || (idx>=MAXCDHAND) || !cdHandles[idx].used )
  154.     {
  155.       alErrCode = ALERR_INVHANDLE;
  156.       return SS_ERR;
  157.     }
  158.   dwStatus = WaitForSingleObject( cdMutexes[idx], TIMEOUT );
  159.   if ( dwStatus != WAIT_OBJECT_0 )
  160.     {
  161.       alErrCode = ALERR_LOCK;
  162.       return SS_ERR;
  163.     }
  164.   memset( &s, 0, sizeof(s) );
  165.   heventSRB = CreateEvent( NULL, TRUE, FALSE, NULL );
  166.   s.SRB_Cmd        = SC_EXEC_SCSI_CMD;
  167.   s.SRB_HaID       = cdHandles[idx].ha;
  168.   s.SRB_Target     = cdHandles[idx].tgt;
  169.   s.SRB_Lun        = cdHandles[idx].lun;
  170.   s.SRB_Flags      = SRB_EVENT_NOTIFY;
  171.   s.SRB_PostProc   = (LPVOID)heventSRB;
  172.   s.SRB_SenseLen   = SENSE_LEN;
  173.   s.SRB_CDBLen     = 6;
  174.   s.SRB_BufLen     = 12;
  175.   s.SRB_BufPointer = buf;
  176.   s.CDBByte[0]     = 0x15;
  177.   s.CDBByte[1]     = 0x10;
  178.   s.CDBByte[4]     = 0x08;
  179.   ResetEvent( heventSRB );
  180.   dwStatus = pfnSendASPI32Command( (LPSRB)&s );
  181.   if ( dwStatus == SS_PENDING )
  182.     WaitForSingleObject( heventSRB, DEFWAITLEN );
  183.   CloseHandle( heventSRB );
  184.   if ( s.SRB_Status != SS_COMP )
  185.     {
  186.       alErrCode = ALERR_ASPI;
  187.       alAspiErr = s.SRB_Status;
  188.       return SS_ERR;
  189.     }
  190.   return SS_COMP;
  191. }