xtractor.c

读取音乐光盘磁道为磁盘文件的DLL源码

  hEditAlbum = CreateWindowEx( WS_EX_CLIENTEDGE, "EDIT", "",
		  ES_LEFT | WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL
		  | WS_BORDER | WS_TABSTOP,
		  rc.right + 72, rc.top + 26, 210, 24, hRet,
		  (HMENU)IDE_ALBUM, hInst, NULL );

  return hRet;
}


void doPaint( HWND hWnd )
{
  PAINTSTRUCT p;
  HDC hDC;

  hDC = BeginPaint( hWnd, &p );
  if ( !hDC )
    return;

  EndPaint( hWnd, &p );
}


void handleToolbarNotify( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
#if 0
  LPTOOLTIPTEXT lpt = (LPTOOLTIPTEXT)lParam;

  if ( lpt->hdr.code == TTN_NEEDTEXT )
    {
      // we should put in tool-text code here
      //OutputDebugString( "Got a TTN_NEEDTEXT" );
    }
#else
  hWnd = hWnd; uMsg = uMsg; wParam = wParam; lParam = lParam;
#endif
}


int WindowHeight( HWND hWnd )
{
  RECT rc;

  GetWindowRect( hWnd, &rc );
  return ( rc.bottom - rc.top );
}


void DoCDDBQuery( HWND hWnd )
{
  DWORD dwThreadID;

  bInCDDBQuery = TRUE;

  CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)DoCDDBQueryThread,
		(LPVOID)hWnd, 0, &dwThreadID );
}


DWORD DoCDDBQueryThread( LPVOID lpParam )
{
  CDDBQUERYITEM cdq[5];
  CDDBQUERY query;
  char linebuf[81];
  int i;
  BOOL bCDDB = FALSE;
  char *buf, *p;
  HWND hWnd = (HWND)lpParam;

  ZeroMemory( cdq, sizeof(cdq) );

  buf = (char *)GlobalAlloc( GPTR, 32000 );

#if 1
  CDDBSetOption( CDDB_OPT_USECDPLAYERINI, "", TRUE );
#endif
  CDDBSetOption( CDDB_OPT_SERVER, szCDDBServer, 0 );
  CDDBSetOption( CDDB_OPT_CGI, szCGI, 0 );
  CDDBSetOption( CDDB_OPT_USEPROXY, "", bUseProxy );
  if ( bUseProxy )
    {
      CDDBSetOption( CDDB_OPT_PROXY, szProxyAddr, 0 );
      CDDBSetOption( CDDB_OPT_PROXYPORT, "", iProxyPort );
    }
  CDDBSetOption( CDDB_OPT_USER, "[e-mail]", 0 );
  CDDBSetOption( CDDB_OPT_AGENT, "xtractor 0.12", 0 );

  SetStatusMessage( "Contacting CDDB Server..." );
  query.num = 5;
  query.q = cdq;
  bCDDB = (CDDBQuery( hCD, &query ) == SS_COMP);
#if 0
  if ( !bCDDB )
    OutputDebugString( "Something\'s not quite right here..." );
  wsprintf( linebuf, "After CDDBQuery(), num == %d", query.num );
  OutputDebugString( linebuf );
#endif
  if ( bCDDB && (query.num == 0) )
    {
      SetStatusMessage( "No matches in CDDB database..." );
    }

  if ( query.num )
    {
      // If we're in the middle of a rip operation, just use the first one
      // as a default.  Otherwise, pop up a dialog to let the user choose
      // which one to use
      if ( bRippingTracks || (query.num == 1) )
	{
	  SetStatusMessage( "Retrieving CD info..." );
	  query.num = 0;
	  bCDDB = (CDDBGetDiskInfo( &cdq[0], buf, 32000 ) == SS_COMP);
	  if ( !bCDDB )
	    {
	      SetStatusMessage( "Error retrieving CDDB info..." );
	    }
	}
      else
	{
	  DialogBoxParam( ghInstance, "MultipleCDDBQueryDialog", hWnd,
			  (DLGPROC)MultipleCDDBQueryDlgProc, (LPARAM)&query );
	  if ( query.num < 0 )
	    {
	      SetStatusMessage( "CDDB Query cancelled..." );
	      bCDDB = FALSE;
	    }
	  else
	    {
	      SetStatusMessage( "Retrieving CD info..." );
	      bCDDB = (CDDBGetDiskInfo( &cdq[query.num], buf, 32000 ) == SS_COMP);
	      if ( !bCDDB )
		{
		  SetStatusMessage( "Error retrieving CDDB info..." );
		}
	    }
	}
    }


  // probably want to pop up an error message here
  if ( !bCDDB )
    {
      bInCDDBQuery = FALSE;
      GlobalFree( (HGLOBAL)buf );  
      return 0;
    }

  SetEditItemText( IDE_ARTIST, cdq[query.num].artist );
  SetEditItemText( IDE_ALBUM, cdq[query.num].title );
  id3CDDBCat2Genre( cdq[query.num].categ );

  p = buf;
  i = 0;
  while( p && *p )
    {
      GetLineFromBuf( linebuf, &p, 81 );
      if ( !strncmp( linebuf, "TTITLE", 6 ) )
	{
	  SetTrackText( linebuf, i );
	  i++;
	}
      else if ( linebuf[0] == '.' )
	p = NULL;     // last line read
    }

  GlobalFree( (HGLOBAL)buf );  
  bInCDDBQuery = FALSE;

  UpdateStatusBar();
  return 0;
}


void SetTrackText( char *buf, int i )
{
  char *p;

  p = strstr( buf, "=" );
  if ( p )
    {
      p++;
      if ( *p )
	SendMessage( hTrackWnd, WM_SETTRACKTEXT, (WPARAM)i, (LPARAM)p );
    }
}


void RefreshTrackList( void )
{
  ADDTRACK at;
  TOC toc;
  int i;

  SendMessage( hTrackWnd, WM_DELTRACK, ALLTRACKS, 0L );

  ZeroMemory( &toc, sizeof(TOC) );
  ModifyCDParms( hCD, CDP_MSF, (DWORD)FALSE );
  ReadTOC( hCD, &toc );

  for( i = toc.firstTrack; i <= toc.lastTrack; i++ )
    {
      TOCTRACK *t;
      int idx;

      idx = i - toc.firstTrack;

      ZeroMemory( &at, sizeof(at) );
      wsprintf( at.name, "Track %d", i );

      t = &(toc.tracks[idx]);
      MSB2DWORD( &(at.start), t->addr );
      if ( t->ADR & 0x04 )
	{
	  // will need to fix the leadout detection code here
	  at.bData = TRUE;
	  lstrcpy( at.name, "Data Track" );
	}

      t = &(toc.tracks[idx+1]);
      MSB2DWORD( &(at.len), t->addr );
      at.len -= at.start;

      #define LEADOUT  (150*75)
      // if the next track is a data track, subtract 150 seconds of leadout
      if ( (t->ADR & 0x04) && (at.len > LEADOUT) )
	at.len -= LEADOUT;

      SendMessage( hTrackWnd, WM_ADDTRACK, 0, (LPARAM)&at );
    }
}



/*
 * Save parameters to the registry
 */
void DeinitAKRip( void )
{
  HKEY hKey;
  DWORD dwDisposition, driveInfo, dwAutoTOC;
  DWORD dwTmp;
  LONG retVal;

  retVal = RegCreateKeyEx( HKEY_LOCAL_MACHINE, regKeyName, 0L,
			 "", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS,
			 NULL, &hKey, &dwDisposition );
  if ( retVal != ERROR_SUCCESS )
    {
      return;
    }

  RegSetValueEx( hKey, "numRip", 0L, REG_DWORD, (BYTE *)(&maxRip),
		 sizeof(DWORD) );
  RegSetValueEx( hKey, "jitterCheck", 0L, REG_DWORD, (LPBYTE)&jitterCheck,
		 4L );
  RegSetValueEx( hKey, "overlap", 0L, REG_DWORD, (LPBYTE)&numOverlap, 4L );
  RegSetValueEx( hKey, "readMode", 0L, REG_DWORD, (LPBYTE)&readMode, 4L );
  dwAutoTOC = (DWORD)bAutoTOC;
  RegSetValueEx( hKey, "autoTOC", 0L, REG_DWORD, (LPBYTE)&dwAutoTOC, 4L );
  dwTmp = (DWORD)bAutoCheck;
  RegSetValueEx( hKey, "autoCheck", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  dwTmp = (DWORD)bMP3;
  RegSetValueEx( hKey, "MP3", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  dwTmp = (DWORD)wBitrate;
  RegSetValueEx( hKey, "bitrate", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  dwTmp = (DWORD)wMaxBitrate;
  RegSetValueEx( hKey, "maxbitrate", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  dwTmp = (DWORD)wMode;
  RegSetValueEx( hKey, "mpegmode", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  dwTmp = (DWORD)bID3;
  RegSetValueEx( hKey, "id3level", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  dwTmp = bCRC;
  RegSetValueEx( hKey, "crc", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  dwTmp = bUseProxy;
  RegSetValueEx( hKey, "useproxy", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  dwTmp = iProxyPort;
  RegSetValueEx( hKey, "proxyport", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  RegSetValueEx( hKey, "proxyaddr", 0L, REG_SZ, szProxyAddr, lstrlen(szProxyAddr)+1 );
  RegSetValueEx( hKey, "cddbaddr", 0L, REG_SZ, szCDDBServer, lstrlen(szCDDBServer)+1 );
  RegSetValueEx( hKey, "cddbcgi", 0L, REG_SZ, szCGI, lstrlen(szCGI)+1 );
  dwTmp = bCDDB;
  RegSetValueEx( hKey, "enablecddb", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  dwTmp = iEncoder;
  RegSetValueEx( hKey, "encoder", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  dwTmp = (DWORD)bHiColor;
  RegSetValueEx( hKey, "hicolor", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  dwTmp = 0;
  if ( bVBR )
    dwTmp |= 0x80000000;
  if ( bVBRHeader )
    dwTmp |= 0x40000000;
  dwTmp |= ( (wMaxBitrate & 0x1FF) << 21 );
  dwTmp |= ( (nQuality & 0x03) << 19 );
  dwTmp |= ( (nVBRQuality & 0x0F) << 15 );
  RegSetValueEx( hKey, "lameopts", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );

  if ( cdlistIdx >= 0 )
    {
      driveInfo = ((DWORD)bReadType) << 24 |
	((DWORD)cdlist.cd[cdlistIdx].ha) << 16 |
	((DWORD)cdlist.cd[cdlistIdx].tgt) << 8 |
	((DWORD)cdlist.cd[cdlistIdx].lun);
      RegSetValueEx( hKey, "driveInfo", 0L, REG_DWORD,
		     (LPBYTE)&driveInfo, 4L );
    }
  else
    RegDeleteValue( hKey, "driveInfo" );

  RegSetValueEx( hKey, "wavOutputdir", 0L, REG_SZ, (LPBYTE)szWavOutputDir,
		 lstrlen( szWavOutputDir)+1 );
  RegSetValueEx( hKey, "mp3Outputdir", 0L, REG_SZ, (LPBYTE)szMP3OutputDir,
		 lstrlen( szMP3OutputDir)+1 );

  RegCloseKey( hKey );
}

/*
 * void InitAKRip( void );
 *
 * Reads initialization values from the registry, if present.  Currently
 * looks for the following values:
 *   numRip      - (DWORD) number of frames to read at once
 *   jitterCheck - (DWORD) number of frames to try to match
 *   overlap     - (DWORD) number of frames of overlap (at least
 *                 jitterCheck + 1
 *   autoTOC     - (DWORD) boolean, whether to automatically scan the TOC on
 *                 startup
 *   driveInfo   - (DWORD) ha, tgt, lun identifier of last CD unit used
 *   driveString - (REG_SZ) string identifier of CD unit
 *   driveVendor - (REG_SZ) vendor identifier of CD unit
 *   driveProdID - (REG_SZ) product identifier of CD unit
 *   driveRev    - (REG_SZ) hardware revision number of CD unit
 *   driveVendSp - (REG_SZ) vendor specific info for CD unit
 *   
 */
void InitAKRip( void )
{
  HKEY hKey;
  DWORD dwDisposition, driveInfo, dwAutoTOC;
  DWORD dwTmp;
  LONG retVal;
  CDREC cd;

  // scan the list of available cd drives
  ZeroMemory( &cdlist, sizeof(CDLIST) );
  cdlist.max = MAXCDLIST;
  GetCDList( &cdlist );
  cdlistIdx = -1;

  memset( &cd, 0, sizeof(cd) );
  memset( validFnameChar, 0xFF, 256 );
  validFnameChar['\\'] = 0;
  validFnameChar['/'] = 0;
  validFnameChar[':'] = 0;
  validFnameChar['*'] = 0;
  validFnameChar['?'] = 0;
  validFnameChar['\"'] = 0;
  validFnameChar['<'] = 0;
  validFnameChar['>'] = 0;
  validFnameChar['|'] = 0;

  retVal = RegCreateKeyEx( HKEY_LOCAL_MACHINE, regKeyName, 0L,
			 "", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS,
			 NULL, &hKey, &dwDisposition );
  if ( retVal != ERROR_SUCCESS )
    {
      // UserOutput( UO_ERROPENREG, regKeyName, retVal );
      return;
    }

  if ( !readRegDWORD( hKey, "numRip", &maxRip ) )
    {
      maxRip = 26;  /* default value */
      RegSetValueEx( hKey, "numRip", 0L, REG_DWORD, (BYTE *)(&maxRip),
		     sizeof(DWORD) );
    }
  if ( !readRegDWORD( hKey, "jitterCheck", &jitterCheck ) )
    {
      jitterCheck = 1;
      RegSetValueEx( hKey, "jitterCheck", 0L, REG_DWORD,
		     (LPBYTE)&jitterCheck, 4L );
    }
  if ( !readRegDWORD( hKey, "overlap", &numOverlap ) )
    {
      numOverlap = jitterCheck + 2;
      RegSetValueEx( hKey, "overlap", 0L, REG_DWORD,
		     (LPBYTE)&numOverlap, 4L );
    }

  if ( !readRegDWORD( hKey, "autoTOC", &dwAutoTOC ) )
    {
      dwAutoTOC = 1;
      RegSetValueEx( hKey, "autoTOC", 0L, REG_DWORD,
		     (LPBYTE)&dwAutoTOC, 4L );
    }
  bAutoTOC = (BOOL)dwAutoTOC;

  if ( !readRegDWORD( hKey, "autoCheck", &dwAutoTOC ) )
    {
      dwAutoTOC = 1;
      RegSetValueEx( hKey, "autoCheck", 0L, REG_DWORD,
		     (LPBYTE)&dwAutoTOC, 4L );
    }
  bAutoCheck = (BOOL)dwAutoTOC;

  if ( !readRegDWORD( hKey, "readMode", &readMode ) )
    {
      readMode = CDRM_JITTERONERR;
      RegSetValueEx( hKey, "readMode", 0L, REG_DWORD,
		     (LPBYTE)&readMode, 4L );
    }

  if ( readRegDWORD( hKey, "MP3", &dwTmp ) )
    bMP3 = (BOOL)dwTmp;
  else
    {
      bMP3 = FALSE;
      dwTmp = 0L;
      RegSetValueEx( hKey, "MP3", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
    }

  if ( readRegDWORD( hKey, "bitrate", &dwTmp ) )
    wBitrate = (WORD)dwTmp;
  else
    {
      wBitrate = 192;
      dwTmp = 192L;
      RegSetValueEx( hKey, "bitrate", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
    }

  if ( readRegDWORD( hKey, "maxbitrate", &dwTmp ) )
    wMaxBitrate = (WORD)dwTmp;
  else
    {
      wMaxBitrate = 320;
      dwTmp = 320L;
      RegSetValueEx( hKey, "maxbitrate", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
    }

  if ( readRegDWORD( hKey, "mpegmode", &dwTmp ) )
    wMode = (WORD)dwTmp;
  else
    {
      wMode = BE_MP3_MODE_STEREO;
      dwTmp = BE_MP3_MODE_STEREO;
      RegSetValueEx( hKey, "mpegmode", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
    }

  if ( readRegDWORD( hKey, "id3level", &dwTmp ) )
    bID3 = (BOOL)dwTmp;
  else
    {
      bID3 = FALSE;
      dwTmp = (DWORD)FALSE;
      RegSetValueEx( hKey, "id3level", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
    }

  if ( readRegDWORD( hKey, "crc", &dwTmp ) )
    bCRC = (BOOL)dwTmp;
  else
    {
      bCRC = FALSE;
      dwTmp = (DWORD)FALSE;
      RegSetValueEx( hKey, "crc", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
    }

  if ( readRegDWORD( hKey, "useproxy", &dwTmp ) )
    bUseProxy = (BOOL)dwTmp;
  else
    {
      bUseProxy = FALSE;
      dwTmp = (DWORD)FALSE;
      RegSetValueEx( hKey, "useproxy", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
    }

  if ( readRegDWORD( hKey, "lameopts", &dwTmp ) )
    {
      bVBR        = (BOOL)(dwTmp & 0x80000000);
      bVBRHeader  = (BOOL)(dwTmp & 0x40000000);
      wMaxBitrate = (dwTmp >> 21) & 0x1FF;
      nQuality    = (dwTmp >> 19) & 0x03;
      nVBRQuality = (dwTmp >> 15) & 0x0F;
    }

  if ( readRegDWORD( hKey, "encoder", &dwTmp ) )
    iEncoder = (int)dwTmp;
  else
    {
      iEncoder = NOENCODER;
      dwTmp = NOENCODER;
      RegSetValueEx( hKey, "encoder", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
   }

  if ( readRegDWORD( hKey, "proxyport", &dwTmp ) )
    iProxyPort = (int)dwTmp;
  else
    {
      iProxyPort = 0;
      dwTmp = 0;
      RegSetValueEx( hKey, "proxyport", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
    }

  if ( !readRegSZ( hKey, "proxyaddr", szProxyAddr, 81 ) )
    lstrcpy( szProxyAddr, "" );

  if ( !readRegSZ( hKey, "cddbaddr", szCDDBServer, 81 ) )
    lstrcpy( szCDDBServer, "www.freedb.org" );

  if ( !readRegSZ( hKey, "cddbcgi", szCGI, 81 ) )
    lstrcpy( szCGI, "/~cddb/cddb.cgi" );

  if ( readRegDWORD( hKey, "enablecddb", &dwTmp ) )
    bCDDB = (BOOL)dwTmp;
  else
    {
      bCDDB = FALSE;
      dwTmp = 0;
      RegSetValueEx( hKey, "enablecddb", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
    }

  if ( readRegDWORD( hKey, "hicolor", &dwTmp ) )
    bHiColor = (BOOL)dwTmp;
  else
    {
      bHiColor = DisplayIsHiColor();
      dwTmp = (DWORD)bHiColor;
      RegSetValueEx( hKey, "hicolor", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
    }

  if ( readRegDWORD( hKey, "driveInfo", &driveInfo ) )
    {
      //      BYTE bRead;
      GETCDHAND cdh;

      cd.ha = (BYTE)((0x00FF0000 & driveInfo) >> 16);
      cd.tgt = (BYTE)((0x0000FF00 & driveInfo) >> 8 );
      cd.lun = (BYTE)(0x000000FF & driveInfo);
      bReadType = (BYTE)((0xFF000000 & driveInfo) >> 24);
      memset( &cdh, 0, sizeof(GETCDHAND) );
      cdh.size       = sizeof(GETCDHAND);
      cdh.ver        = 1;
      cdh.ha         = cd.ha;
      cdh.tgt        = cd.tgt;
      cdh.lun        = cd.lun;
      cdh.readType   = bReadType;
      cdh.numOverlap = numOverlap;
      cdh.numJitter  = jitterCheck;
      hCD = GetCDHandle( &cdh );
      if ( !hCD )