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

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

SCSI/ASPI

开发平台：

WINDOWS

riptracks.c：源码内容
  1. /*
  2.  * riptracks.c - Copyright (C) 1999,2000 Jay A. Key
  3.  *
  4.  * Contains the RipTrack() function.  The rip dialog proc, plus the
  5.  * read and encode threads are all contained in this file.  The read 
  6.  * thread is also responsible for jitter correction.  A good example of 
  7.  * how to rip a track from a CD via AKRip32.dll
  8.  *
  9.  **********************************************************************
  10.  *
  11.  * This program is free software; you can redistribute it and/or modify
  12.  * it under the terms of the GNU General Public License as published by
  13.  * the Free Software Foundation; either version 2 of the License, or
  14.  * (at your option) any later version.
  15.  *
  16.  * This program is distributed in the hope that it will be useful,
  17.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19.  * GNU General Public License for more details.
  20.  *
  21.  * You should have received a copy of the GNU General Public License
  22.  * along with this program; if not, write to the Free Software
  23.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  24.  *
  25.  */
  26. #include <windows.h>
  27. #include <stdio.h>
  28. #include <time.h>
  29. #include <malloc.h>
  30. #include "akrip/akrip32.h"
  31. #include "resources.h"
  32. #include "globals.h"
  33. #include "riptracks.h"
  34. #include "trackwnd.h"
  35. #include "bladedll.h"
  36. #include "gauge.h"
  37. #include "id3.h"
  39. #define _USE_LAME  0
  41. DWORD RipThread( LPENCODETHREAD pet );
  42. DWORD EncodeThread( LPENCODETHREAD pet );
  43. LPTRACKBUF newTrackBuf( DWORD numFrames );
  44. void RipTrack( HWND hDlg, int idx, LPADDTRACK lpAddTrack );
  45. int writeAndFlush( FILE *fp, BYTE *buf, int len );
  46. void writeWavHeader( FILE *fp, DWORD len );
  47. BOOL loadBladeEnc( void );
  48. void setRipTrackStatus( LPENCODETHREAD e );
  49. BOOL LoadEncoderFunctions( ENCODER nEncoder );
  50. void UpdateTime (long numWritten);
  51. BOOL isOldLameEnc( void );
  53. static ENCODETHREAD e;
  54. static ADDTRACK rtAddTrack;
  55. //static BOOL bSecond = FALSE;
  57. /*
  58.  * 1. initializes the common data structure
  59.  * 2. starts the threads
  60.  * 
  61.  * 
  62.  */
  63. void RipTrack( HWND hDlg, int idx, LPADDTRACK lpAddTrack )
  64. {
  65.   DWORD dwRipThreadID, dwEncThreadID;
  66.   static DWORD numBufFrames = 8;
  67.   static char outputName[MAX_PATH+1];
  68.   int iDirLen;                      // iNameLen, iTotal;
  69.   char *p;
  71.   ZeroMemory( &e, sizeof(e) );
  73.   e.idx = idx;
  75.   time( &e.tstart );
  77.   e.hDlg = hDlg;
  79.   wsprintf( outputName, "%s.%s", lpAddTrack->name,  bMP3?"mp3":"wav" );
  80.   SetDlgItemText( hDlg, IDT_TRACKNAME, outputName );
  82.   // we really need to check filename lengths here, but I'm just too damn
  83.   // tired right now
  84.   iDirLen = lstrlen( szMP3OutputDir );
  85.   //iNameLen = lstrlen( lpAddTrack->name );
  86.   //iTotal = iDirLen + iNameLen + 5;
  88.   if ( bMP3 )
  89.     lstrcpy( outputName, szMP3OutputDir );
  90.   else
  91.     lstrcpy( outputName, szWavOutputDir );
  93.   iDirLen = lstrlen( outputName );
  94.   if ( !iDirLen )
  95.     lstrcpy( outputName, ".\" );
  96.   if ( iDirLen && outputName[iDirLen-1] != '\' )
  97.     lstrcat( outputName, "\" );
  99.   // add the track name, and then replace illegal characters with a '_'
  100.   p = outputName + lstrlen( outputName );
  101.   lstrcat( outputName, lpAddTrack->name );
  102.   while( *p )
  103.     {
  104.       if ( !validFnameChar[(unsigned char)*p] )
  105. *p = '_';
  106.       p++;
  107.     }
  109.   // add the proper extension
  110.   p = outputName + lstrlen( outputName );
  111.   lstrcat( outputName, bMP3?".mp3":".wav" );
  113.   e.fpOut = fopen( outputName, "w+b" );
  114.   if ( !bMP3 )
  115.     writeWavHeader( e.fpOut, 0 );
  117.   if ( bMP3 && bWavMirror )
  118.     {
  119.       // change the extension to WAV (p was set to the terminating NULL)
  120.       lstrcpy( p, ".wav" );
  121.       e.fpWavMirror = fopen( outputName, "wb" );
  122.       writeWavHeader( e.fpWavMirror, 0 );
  123.     }
  124.   else
  125.     e.fpWavMirror = NULL;
  127.   if ( bMP3 )
  128.     {
  129.       switch( iEncoder )
  130. {
  131. case BLADE_ENC_DLL:
  132.   wsprintf( outputName, "%d kbps MP3 via BladeEnc DLL", wBitrate );
  133.   break;
  134. case LAME_ENC_DLL:
  135.   if ( isOldLameEnc() )
  136.     {
  137.       e.bOldLame = TRUE;
  138.     }
  139.   wsprintf( outputName, "%d kbps MP3 via Lame_Enc DLL", wBitrate );
  140.   if ( bVBR && !e.bOldLame )
  141.     wsprintf( outputName+lstrlen(outputName),
  142.       ", VBR max bitrate %d, VBR quality %d", wMaxBitrate,
  143.       nVBRQuality );
  144.   break;
  145. }
  146.     }
  147.   else
  148.     wsprintf( outputName, "WAV file" );
  149.   SetDlgItemText( hDlg, IDT_OUTPUTOPTTEXT, outputName );
  151.   ModifyCDParms( hCD, CDP_OVERLAP, numOverlap );
  152.   ModifyCDParms( hCD, CDP_JITTER, jitterCheck );
  153.   ModifyCDParms( hCD, CDP_READMODE, readMode );
  155.   e.startFrame = lpAddTrack->start;
  156.   e.trackLen = lpAddTrack->len;
  157.   e.endFrame = e.startFrame + e.trackLen;
  159.   InitializeCriticalSection( &e.cs );
  161.   e.hRipCancel = CreateEvent( NULL, FALSE, FALSE, NULL );
  163.   SendDlgItemMessage( hDlg, IDG_RIPPROG, GM_SETRANGE,
  164.       (WPARAM)((UINT)e.trackLen * 2352),
  165.       0L );
  166.   SendDlgItemMessage( hDlg, IDG_RIPPROG, GM_SETPOS, 0, 0L );
  168.   wrqInitQueue( &e.q, maxRip * 2352 * numBufFrames );
  170.   SendDlgItemMessage( hDlg, IDG_READBUF, GM_DISPPCT, (WPARAM)FALSE, 0L );
  171.   SendDlgItemMessage( hDlg, IDG_READBUF, GM_SETRANGE,
  172.       (WPARAM)wrqFreeSpace( &e.q ), 0L );
  174.   // Set ID3 info for track.  Album title and artist are set elsewhere
  175.   asSetID3Info( ID3_TITLE, lpAddTrack->name, 0 );
  176.   asSetID3Info( ID3_LEVEL, NULL, 1 );
  177. #if 0
  178.   asSetID3Info( ID3_YEAR, "1997", 0 );
  179.   asSetID3Info( ID3_GENRE, NULL, 17 );
  180. #endif
  181.   
  183.   e.aHandles[0] = CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)RipThread,
  184. (LPVOID)&e, 0, &dwRipThreadID );
  185.   e.aHandles[1] = CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)EncodeThread,
  186. (LPVOID)&e, 0, &dwEncThreadID );
  187. }
  190. BOOL RipTrackDlgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
  191. {
  192.   WORD wID;
  193.   //static BOOL bDone = FALSE;
  194.   static HWND hTrckWnd = NULL;
  195.   int idx = -1;
  197.   switch( uMsg )
  198.     {
  199.     case WM_DESTROY:
  200.       bRippingTracks = FALSE;
  201.       EndDialog( hWnd, 0 );
  202.       break;
  204.     case WM_TRACKDONE:
  205.       //bSecond = TRUE;
  206.       DeleteCriticalSection( &e.cs );
  207.       //CloseHandle( &e.hRipCancel );
  208.       wrqDeinitQueue( &e.q );
  209.       // set the status text for the last track ripped
  210.       setRipTrackStatus( &e );
  211.       // if more tracks to rip and the last one finished successfully,
  212.       // call RipTrack again
  213.       idx = SendMessage( hTrckWnd,WM_FINDNEXTTRACK,0,(LPARAM)&rtAddTrack);
  214.       if ( (idx != -1) && (e.status == EST_SUCCESS) )
  215. RipTrack( hWnd, idx, &rtAddTrack );
  216.       else
  217. {
  218.   bRippingTracks = FALSE;
  219.   EndDialog( hWnd, 0 );
  220. }
  221.       break;
  223.     case WM_INITDIALOG:
  224.       //bDone = FALSE;
  225.       //bSecond = FALSE;
  226.       hTrckWnd = (HWND)lParam;
  227.       bRippingTracks = TRUE;
  228.       idx = SendMessage(hTrckWnd,WM_FINDFIRSTTRACK,0,
  229.        (LPARAM)&rtAddTrack);
  230.       if ( idx != -1 )
  231. {
  232.   RipTrack( hWnd, idx, &rtAddTrack );
  233. }
  234.       else
  235. {
  236.   MessageBox( GetParent(hTrckWnd), "No tracks selected", "Warning!",
  237.       MB_ICONEXCLAMATION | MB_OK );
  238.   bRippingTracks = FALSE;
  239.   EndDialog( hWnd, 0 );
  240. }
  241.       break;
  243.     case WM_COMMAND:
  244.       wID = LOWORD( wParam );
  245.       if ( wID == IDBN_CANCELRIP || wID == 2 )
  246. {
  247.   if ( /* bDone || */ (MessageBox( hWnd, "Really stop?", "Abort?", MB_APPLMODAL | MB_YESNO | MB_ICONEXCLAMATION ) == IDYES) )
  248.     {
  249.       e.bForceRipExit = TRUE;
  250.       e.status = EST_ABORTED;
  251.       SetEvent( e.hRipCancel );
  252.       EnableWindow( GetDlgItem( hWnd, IDBN_CANCELRIP ),FALSE );
  253.     }
  254. }
  255.       return TRUE;
  256.     }
  258.   return FALSE;
  259. }
  262. BOOL RipTrackSegmentDlgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
  263. {
  264.   WORD wID;
  266.   switch( uMsg )
  267.     {
  268.     case WM_DESTROY:
  269.       bRippingTracks = FALSE;
  270.       EndDialog( hWnd, 0 );
  271.       break;
  273.     case WM_TRACKDONE:
  274.       DeleteCriticalSection( &e.cs );
  275.       wrqDeinitQueue( &e.q );
  276.       if ( e.status != EST_SUCCESS )
  277. {
  278. }
  279.       bRippingTracks = FALSE;
  280.       EndDialog( hWnd, 0 );
  281.       break;
  283.     case WM_INITDIALOG:
  284.       bRippingTracks = TRUE;
  285.       RipTrack( hWnd, -1, (LPADDTRACK)lParam );
  286.       break;
  288.     case WM_COMMAND:
  289.       wID = LOWORD( wParam );
  290.       if ( wID == IDBN_CANCELRIP || wID == 2 )
  291. {
  292.   if ( MessageBox( hWnd, "Really stop?", "Abort?", MB_APPLMODAL | MB_YESNO | MB_ICONEXCLAMATION ) == IDYES )
  293.     {
  294.       e.bForceRipExit = TRUE;
  295.       e.status = EST_ABORTED;
  296.       SetEvent( e.hRipCancel );
  297.       EnableWindow( GetDlgItem( hWnd, IDBN_CANCELRIP ),FALSE );
  298.     }
  299. }
  300.       return TRUE;
  301.     }
  303.   return FALSE;
  304. }
  307. LPTRACKBUF newTrackBuf( DWORD numFrames )
  308. {
  309.   LPTRACKBUF t;
  310.   int numAlloc;
  312.   numAlloc = (((int)numFrames)*2352) + TRACKBUFEXTRA;
  314.   t = (LPTRACKBUF)malloc( numAlloc );
  316.   if ( !t )
  317.     return NULL;
  319.   t->startFrame = 0;
  320.   t->numFrames = 0;
  321.   t->maxLen = numFrames * 2352;
  322.   t->len = 0;
  323.   t->status = 0;
  324.   t->startOffset = 0;
  326.   return t;
  327. }
  330. //#define _ALWAYS_READ_MAX
  331. /*
  332.  * Thread responsible for reading the data from the CD and placing it in
  333.  * a queue for the encode thread.
  334.  *
  335.  * trying a new strategy -- always read the full maxRip frames, and truncate
  336.  * if it's too many, but after the read.  Some of the SCSI read modes were
  337.  * crapping out on the last read when I suddenly requested a different number
  338.  * of frames.  To switch back to the old method, undefine _ALWAYS_READ_MAX
  339.  *
  340.  * CDRM_JITTERONERR uses two full-size TRACKBUFs on a rotating basis.  On the
  341.  * read it uses t1, and then on the next read switches to t2.  If an error
  342.  * is returned from the read function, then the buffer from the previous read
  343.  * is used to jitter correct the current one.
  344.  */
  345. DWORD RipThread( LPENCODETHREAD pet )
  346. {
  347.   LPTRACKBUF tbuf, t1, t2, tover, tTmp;
  348.   DWORD num2rip, dwStatus;
  349.   HANDLE hWait[2];
  350.   int retries;
  351.   BOOL useT1 = FALSE;
  352.   HWND hReadGauge;
  353.   BOOL bWaited;
  354.   //char buf[81];
  356.   hWait[0] = CreateEvent( NULL, FALSE, FALSE, NULL ); 
  357.   hWait[1] = pet->hRipCancel;
  359.   // initialize all buffers
  360.   tbuf = t1 = t2 = tover = tTmp = NULL;
  362.   tbuf = t1 = newTrackBuf( maxRip );
  363.   switch ( readMode )
  364.     {
  365.     case CDRM_JITTER:
  366.       tover = newTrackBuf( numOverlap );
  367.       break;
  368.     case CDRM_JITTERONERR:
  369.       t2 = newTrackBuf( maxRip );
  370.       break;
  371.     default:
  372.     case CDRM_NOJITTER:
  373.       readMode = CDRM_NOJITTER;
  374.       break;
  375.     }
  377.   num2rip = maxRip;
  379.   hReadGauge = GetDlgItem( e.hDlg, IDG_READBUF );
  381.   while( TRUE )
  382.     {
  383.       bWaited = FALSE;
  385.       if ( e.startFrame >= e.endFrame )
  386. break;
  388.       if ( e.bForceRipExit )
  389. {
  390.   e.bForceEncExit = TRUE;
  391.   goto asRipExit;
  392. }
  394.       EnterCriticalSection( &e.cs );
  395.       if ( e.endFrame - e.startFrame < maxRip )
  396. num2rip = e.endFrame - e.startFrame;
  397.       LeaveCriticalSection( &e.cs );
  399.       while( wrqFreeSpace( &e.q ) < 2352 * num2rip )
  400. {
  401.   bWaited = TRUE;
  402.   if ( e.bForceRipExit )
  403.     {
  404.       e.bForceEncExit = TRUE;
  405.       goto asRipExit;
  406.     }
  407.   ResetEvent( hWait[0] );
  408.   wrqSetWait( &e.q, hWait[0], 2352 * maxRip * 6 );
  409.   //WaitForSingleObject( hWait, 20000 );
  410.   WaitForMultipleObjects( 2, hWait, FALSE, 60000 );
  411.   if ( e.bForceRipExit )
  412.     {
  413.       e.bForceEncExit = TRUE;
  414.       goto asRipExit;
  415.     }
  416. }
  418.       switch( readMode )
  419. {
  420. case CDRM_JITTER:
  421.   EnterCriticalSection( &e.cs );
  422.   tbuf->startFrame = e.startFrame;
  423.   LeaveCriticalSection( &e.cs );
  424. #ifndef _ALWAYS_READ_MAX
  425.   tbuf->numFrames = num2rip;
  426. #else
  427.   tbuf->numFrames = maxRip;
  428. #endif
  429.   tbuf->startOffset = 0;
  430.   tbuf->len = 0;
  431.   //retries = 3;
  432.   //dwStatus = SS_ERR;
  433.   for( dwStatus = SS_ERR, retries = 3; dwStatus != SS_COMP && retries; retries-- )
  434.     {
  435.       dwStatus = ReadCDAudioLBAEx( hCD, tbuf, tover );
  436.     }
  437.   break;
  439. case CDRM_JITTERONERR:
  440.   if ( useT1 )
  441.     {
  442.       tbuf = t1;
  443.       tTmp = t2;
  444.     }
  445.   else
  446.     {
  447.       tbuf = t2;
  448.       tTmp = t1;
  449.     }
  450.   EnterCriticalSection( &e.cs );
  451.   tbuf->startFrame = e.startFrame;
  452.   LeaveCriticalSection( &e.cs );
  454. #ifndef _ALWAYS_READ_MAX
  455.   tbuf->numFrames = num2rip;
  456. #else
  457.   tbuf->numFrames = maxRip;
  458. #endif
  459.   tbuf->startOffset = 0;
  460.   tbuf->len = 0;
  462.   // try to force jitter correction after a wait
  463.   if ( !bWaited )
  464.     dwStatus = ReadCDAudioLBA( hCD, tbuf );
  465.   else
  466.     dwStatus = SS_ERR;
  468.   // after an error or a wait, dwStatus will be SS_ERR
  469.   if ( dwStatus == SS_ERR )
  470.     {
  471.       if ( tTmp->len )
  472. {
  473.   tTmp->startOffset += ((tTmp->numFrames - jitterCheck)*2352);
  474.   tTmp->startFrame += ( tTmp->numFrames - jitterCheck );
  475.   tTmp->numFrames = jitterCheck;
  476.   tTmp->len = jitterCheck * 2352;
  477. }
  478.       else
  479. tTmp->len = tTmp->startOffset = tTmp->numFrames;
  481.       for( retries = 3; (dwStatus != SS_COMP) && retries; retries-- )
  482. {
  483.   dwStatus = ReadCDAudioLBAEx( hCD, tbuf, tTmp );
  484. }
  485.     }
  486.   useT1 = !useT1;
  487.   break;
  489. case CDRM_NOJITTER:
  490.   EnterCriticalSection( &e.cs );
  491.   tbuf->startFrame = e.startFrame;
  492.   LeaveCriticalSection( &e.cs );
  494. #ifndef _ALWAYS_READ_MAX
  495.   tbuf->numFrames = num2rip;
  496. #else
  497.   tbuf->numFrames = maxRip;
  498. #endif
  499.   tbuf->startOffset = 0;
  500.   tbuf->len = 0;
  502.   //dwStatus = SS_ERR;
  503.   //retries = 3;
  504.   for( retries = 3, dwStatus = SS_ERR; (dwStatus != SS_COMP) && retries; retries -- )
  505.     dwStatus = ReadCDAudioLBA( hCD, tbuf );
  506.   break;
  507. }
  509.       if ( dwStatus != SS_COMP )
  510. {
  511.   // display the error here
  512.           e.status = EST_ERROR;
  513.   e.bForceEncExit = TRUE;
  514.   goto asRipExit;
  515. }
  516.       
  517. #ifdef _ALWAYS_READ_MAX
  518.       if ( (maxRip > num2rip) && (tbuf->numFrames > num2rip) )
  519. {
  520.   tbuf->numFrames = num2rip;
  521.   tbuf->len = tbuf->numFrames * 2352;
  522. }
  523. #endif
  525.       wrqEnqueue( &e.q, tbuf->buf + tbuf->startOffset, tbuf->len );
  526. #if 0
  527.       SendDlgItemMessage( e.hDlg, IDG_READBUF, GM_SETPOS,
  528.   (WPARAM)wrqNumUsed( &e.q ), 0L );
  529. #else
  530.       PostMessage( hReadGauge, GM_SETPOS, (WPARAM)wrqNumUsed( &e.q ), 0L );
  531. #endif
  532.       EnterCriticalSection( &e.cs );
  533.       e.startFrame += tbuf->numFrames;
  534.       LeaveCriticalSection( &e.cs );
  535.     }
  536.   
  537.   e.bNormalExit = TRUE;
  539.   ResetEvent( hWait[0] );
  540.   wrqSetWait( &e.q, hWait[0], e.q.dataLen - 500 );
  541.   WaitForSingleObject( hWait[0], 5000 );
  543.  asRipExit:
  544.   if ( WaitForSingleObject( e.aHandles[1], 120000 ) == WAIT_TIMEOUT )
  545.     {
  546.       e.bForceEncExit = TRUE;
  547.       if ( WaitForSingleObject( e.aHandles[1], 30000 ) == WAIT_TIMEOUT )
  548. {
  549.   TerminateThread( e.aHandles[1], 0xDEADBEEF );
  550. }
  551.     }
  553.   free( t1 );
  554.   if ( t2 )
  555.     free( t2 );
  556.   if ( tover )
  557.     free( tover );
  559.   time( &e.tnow );
  561.   CloseHandle( hWait[0] );
  562.   CloseHandle( hWait[1] );
  564. #if 0
  565.   if ( !e.bForceEncExit && !e.bForceRipExit )
  566.     PostMessage( e.hDlg, WM_TRACKDONE, 0, 0L );
  567.   else
  568.     PostMessage( e.hDlg, WM_DESTROY, 0, 0L );
  569. #else
  570.   PostMessage( e.hDlg, WM_TRACKDONE, 0, 0L );
  571. #endif
  573.   return 0xDEADBEEF;
  574. }
  577. DWORD EncodeThread( LPENCODETHREAD pet )
  578. {
  579.   BE_CONFIG b;
  580.   BE_ERR err;
  581.   HBE_STREAM hbeStream = 0;
  582.   DWORD dwSamples, dwSampleBytes, dwMP3BufferSize;
  583.   unsigned char *pInput = NULL, *pOutput = NULL;
  584.   DWORD numQueued, numWritten = 0;
  585.   DWORD totalWritten = 0;
  586.   //HWND hRipGauge, hReadGauge;
  587.   BOOL bStreamDirty = FALSE;
  589.   UpdateTime( -1 );
  590.   //hRipGauge = GetDlgItem( e.hDlg, IDG_RIPPROG );
  591.   //hReadGauge = GetDlgItem( e.hDlg, IDG_READBUF );
  593.   if ( bMP3 )
  594.     {
  595.       ZeroMemory( &b, sizeof(b) );
  596.       if ( iEncoder == BLADE_ENC_DLL || pet->bOldLame )
  597. {
  598.   b.dwConfig = BE_CONFIG_MP3;
  599.   b.format.mp3.dwSampleRate = 44100;
  600.   b.format.mp3.byMode = BE_MP3_MODE_STEREO;
  601.   b.format.mp3.wBitrate = wBitrate;
  602.   //b.format.mp3.wBitrate = 128;
  603.   b.format.mp3.bCRC = bCRC;
  604.   b.format.mp3.bPrivate = bPrivate;
  605.   b.format.mp3.bOriginal = bOriginal;
  606.   b.format.mp3.bCopyright = bCopyright;
  607. }
  608.       else if ( iEncoder == LAME_ENC_DLL )
  609. {
  610.   b.dwConfig = BE_CONFIG_LAME;
  611.   b.format.LHV1.dwStructVersion    = 1;
  612.   b.format.LHV1.dwStructSize       = sizeof(BE_CONFIG);
  613.   b.format.LHV1.dwSampleRate       = 44100;
  614.   b.format.LHV1.dwReSampleRate     = 0;
  615.   b.format.LHV1.nMode              = BE_MP3_MODE_STEREO;
  616.   b.format.LHV1.dwBitrate          = (DWORD)wBitrate;
  617.   b.format.LHV1.dwMaxBitrate       = 320;
  618.   b.format.LHV1.nQuality           = nQuality;
  619.   b.format.LHV1.dwMpegVersion      = MPEG1;
  620.   b.format.LHV1.bCRC               = bCRC;
  621.   b.format.LHV1.bPrivate           = bPrivate;
  622.   b.format.LHV1.bOriginal          = bOriginal;
  623.   b.format.LHV1.bCopyright         = bCopyright;
  624.   b.format.LHV1.bWriteVBRHeader    = bVBRHeader;
  625.   b.format.LHV1.bEnableVBR         = bVBR;
  626.   b.format.LHV1.nVBRQuality        = nVBRQuality;
  627. }
  629.       err = beInitStream( &b, &dwSamples, &dwMP3BufferSize, &hbeStream );
  630.       dwSampleBytes = 2 * dwSamples;
  631.       pInput = (unsigned char *)malloc( dwSampleBytes );
  632.       pOutput = (unsigned char *)malloc( dwMP3BufferSize );
  633.     }
  634.   else
  635.     pOutput = (unsigned char *)malloc( 32656 );
  637.   while( TRUE )
  638.     {
  639.       unsigned char *pTmp;
  641.       pTmp = pOutput;
  643.       if ( pet->bForceEncExit )
  644. break;
  646.       numQueued = wrqNumUsed( &pet->q );
  647.       if ( !numQueued && pet->bNormalExit )
  648. {
  649.   break;
  650. }
  652.       if ( !bMP3 )
  653. {
  654.   while( wrqNumUsed( &pet->q ) )
  655.     {
  656.       int numRead;
  657.       numRead = wrqDequeue( &pet->q, &pTmp, 32656 );
  658.       writeAndFlush( pet->fpOut, pTmp, numRead );
  659.       totalWritten += numRead;
  660.       UpdateTime( numRead );
  661.     }
  662. }
  663.       else  // encoding to MP3
  664. {
  665.   pTmp = pInput;
  666.   if ( numQueued >= dwSampleBytes || pet->bNormalExit )
  667.     {
  668.       DWORD num2dequeue = numQueued;
  669.       if ( num2dequeue > dwSampleBytes )
  670. num2dequeue = dwSampleBytes;
  671.       num2dequeue = wrqDequeue( &pet->q, &pTmp, num2dequeue );
  672.       if ( bWavMirror )
  673. {
  674.   writeAndFlush( pet->fpWavMirror, pTmp, num2dequeue );
  675.   totalWritten += num2dequeue;
  676. }
  677.       beEncodeChunk( hbeStream, num2dequeue/2, (PSHORT)pTmp,
  678.      pOutput, &numWritten );
  679.       fwrite( pOutput, 1, numWritten, pet->fpOut );
  680.       UpdateTime( num2dequeue );
  681.       bStreamDirty = TRUE;
  682.     }
  683. }
  684.     }
  686.   if ( pet->fpWavMirror && bWavMirror )
  687.     writeWavHeader( pet->fpWavMirror, totalWritten );
  689.   if ( !bMP3 )
  690.     writeWavHeader( pet->fpOut, totalWritten );
  691.   else
  692.     {
  693.       if ( hbeStream && bStreamDirty )
  694. {
  695.   beDeinitStream( hbeStream, pOutput, &numWritten );
  696.   if ( numWritten )
  697.     {
  698.       fwrite( pOutput, 1, numWritten, pet->fpOut );
  699.     }
  700.   beCloseStream( hbeStream );
  701. }
  703.       // write ID3 tag here
  704.       if ( bID3 )
  705. writeID3V1Tag( pet->fpOut );
  706.     }
  708.   if ( pInput )
  709.     free( pInput );
  710.   if ( pOutput )
  711.     free( pOutput );
  713.   fclose( pet->fpOut );
  714.   if ( pet->fpWavMirror && bWavMirror )
  715.     fclose( pet->fpWavMirror );
  717.   return 0xDEADBEEF;
  718. }
  721. int writeAndFlush( FILE *fp, BYTE *buf, int len )
  722. {
  723.   static int wafNumWritten = 0;
  724.   int retVal = 0;
  726.   wafNumWritten += len;
  727.   retVal = fwrite( buf, 1, len, fp );
  728.   if ( wafNumWritten > 20480 )
  729.     {
  730.       fflush( fp );
  731.       wafNumWritten = 0;
  732.     }
  734.   return retVal;
  735. }
  738. void writeWavHeader( FILE *fp, DWORD len )
  739. {
  740.   WAVHDR wav;
  742.   if ( !fp )
  743.     return;
  745.   memcpy( wav.riff, "RIFF", 4 );
  746.   wav.len = len + 44 - 8;
  747.   memcpy( wav.cWavFmt, "WAVEfmt ", 8 );
  748.   wav.dwHdrLen = 16;
  749.   wav.wFormat = 1;
  750.   wav.wNumChannels = 2;
  751.   wav.dwSampleRate = 44100;
  752.   wav.dwBytesPerSec = 44100*2*2;
  753.   wav.wBlockAlign = 4;
  754.   wav.wBitsPerSample = 16;
  755.   memcpy( wav.cData, "data", 4 );
  756.   wav.dwDataLen = len;
  757.   fseek( fp, 0, SEEK_SET );
  759.   fwrite( &wav, 1, sizeof(wav), fp );
  760. }
  763. BOOL loadBladeEnc( void )
  764. {
  765.   ENCODER i;
  767.   if ( hBladeDll && hLameDll )
  768.     return TRUE;
  770.   if ( !hLameDll )
  771.     hLameDll = LoadLibrary( "LAME_ENC.DLL" );
  772.   if ( !hBladeDll )
  773.     hBladeDll = LoadLibrary( "BLADEENC.DLL" );
  775.   // See if we can get addresses for the encoder functions, to determine
  776.   // what encoders are present
  777.   for( i = BLADE_ENC_DLL; i < MAXENCODER; i++ )
  778.     LoadEncoderFunctions( i );
  780.   if ( !hBladeDll && !hLameDll )
  781.     return FALSE;
  783.   if ( (iEncoder == NOENCODER ) || !LoadEncoderFunctions( iEncoder ) )
  784.     {
  785.       if ( hBladeDll && !hLameDll )
  786. iEncoder = BLADE_ENC_DLL;
  787.       else if ( hLameDll && !hBladeDll )
  788. iEncoder = LAME_ENC_DLL;
  789.       else
  790. iEncoder = BLADE_ENC_DLL;  // default if not read from registry
  792.       if ( !LoadEncoderFunctions( iEncoder ) )
  793. {
  794.   iEncoder = NOENCODER;
  795.   return FALSE;
  796. }
  797.       return TRUE;
  798.     }
  800.   return TRUE;
  801. }
  804. /*
  805.  * Calls GetProcAddress for the given encoder to obtain addresses for the
  806.  * encoder functions.  Returns FALSE if the DLL is not loaded, or if
  807.  * one or more function addresses cannot be loaded.
  808.  */
  809. BOOL LoadEncoderFunctions( ENCODER nEncoder )
  810. {
  811.   HANDLE hDll;
  813.   if ( nEncoder <= NOENCODER || nEncoder > MAXENCODER )
  814.     return FALSE;
  816.   switch( nEncoder )
  817.     {
  818.     case BLADE_ENC_DLL:
  819.       hDll = hBladeDll;
  820.       break;
  822.     case LAME_ENC_DLL:
  823.       hDll = hLameDll;
  824.       break;
  826.     case NOENCODER:
  827.     default:
  828.       return FALSE;
  829.     }
  831.   if ( !hDll )
  832.     return FALSE;
  834.   beInitStream = (BEINITSTREAM)GetProcAddress( hDll, "beInitStream" );
  835.   beEncodeChunk = (BEENCODECHUNK)GetProcAddress( hDll, "beEncodeChunk" );
  836.   beDeinitStream = (BEDEINITSTREAM)GetProcAddress( hDll, "beDeinitStream" );
  837.   beCloseStream = (BECLOSESTREAM)GetProcAddress( hDll, "beCloseStream" );
  838.   beVersion = (BEVERSION)GetProcAddress( hDll, "beVersion" );
  840.   if ( !beInitStream || !beEncodeChunk || !beDeinitStream ||
  841.        !beCloseStream || !beVersion )
  842.     {
  843.       switch( nEncoder )
  844. {
  845. case BLADE_ENC_DLL:
  846.   hBladeDll = NULL;
  847.   break;
  848. case LAME_ENC_DLL:
  849.   hLameDll = NULL;
  850.   break;
  851. case NOENCODER:
  852. default:
  853.   break;
  854. }
  855.       beInitStream = NULL;
  856.       beEncodeChunk = NULL;
  857.       beDeinitStream = NULL;
  858.       beCloseStream = NULL;
  859.       beVersion = NULL;
  861.       FreeLibrary( hDll );
  862.       return FALSE;
  863.     }  
  865.   return TRUE;
  866. }
  869. /***************************************************************************/
  870. /*                                                                         */
  871. /* UpdateTime                                                              */
  872. /*                                                                         */
  873. /* Update the elapsed/remaining time field on the dialog.  If we're        */
  874. /* supplied with negative bytes, we assume we're initialising our static   */
  875. /* variables.                                                              */
  876. /*                                                                         */
  877. /* Written by B. Thompson, January 27, 2000                                */
  878. /*                                                                         */
  879. /***************************************************************************/
  881. void UpdateTime (long numWritten)
  882. {
  883.   static
  884.   time_t   startTime = 0;              /* Start time stamp                 */
  885.   static
  886.   DWORD    totalWritten = 0;           /* Total bytes written              */
  887.   static
  888.   DWORD    timeLeft = 0;               /* Time remaining                   */
  889.   static
  890.   DWORD    numToWrite;                 /* Total number to be written       */
  891.   static
  892.   HWND     hRipGauge, hReadGauge;      /* Dialog controls                  */
  894.   double   timeLeftd;                  /* Improved calculational ability   */
  895.   time_t   currTime;                   /* Current time stamp               */
  896.   long     secsElapsed;                /* Elapsed seconds since last hour  */
  897.   long     secsLeft;                   /* Remaining seconds since last hour*/
  898.   char     estTime[24];                /* Estimated time                   */
  901.   if (numWritten < 0)
  902.     {                                                     /* Initialisation*/
  903.       time(&startTime);
  904.       totalWritten = 0;
  905.       numToWrite = e.trackLen * 2352;
  906.       hRipGauge = GetDlgItem(e.hDlg, IDG_RIPPROG);
  907.       hReadGauge = GetDlgItem(e.hDlg, IDG_READBUF);
  908.       return;
  909.     }                                                             /* End if*/
  911.   totalWritten += numWritten;
  912.   if (!totalWritten)
  913.     return;                                        /* Avoid divide by zero!*/
  915.   time(&currTime);
  916.   currTime -= startTime;                          /* Elapsed time (seconds)*/
  917.   if (currTime != timeLeft)
  918.     {                                        /* At least one second elapsed*/
  919.       timeLeftd = currTime;
  920.       timeLeftd *= numToWrite;
  921.       timeLeftd /= totalWritten;
  922.       timeLeftd -= currTime;
  924.       timeLeft = (DWORD)timeLeftd;
  925.       secsElapsed = currTime % 3600;
  926.       secsLeft = (long)(timeLeft % 3600);
  927. //    sprintf(estTime, "%i %i", totalWritten, numToWrite);
  928.       sprintf(estTime, "%li:%02li:%02li (%ld:%02ld:%02ld)",
  929.               currTime / 3600, secsElapsed / 60, secsElapsed % 60,
  930.               timeLeft / 3600, secsLeft / 60, secsLeft % 60);
  931.       SetDlgItemText(e.hDlg, IDT_ESTTIME, estTime);
  932.     }                                                             /* End if*/
  933.     timeLeft = currTime;                              /* For next iteration*/
  934. #if 0
  935.     SendDlgItemMessage( e.hDlg, IDG_RIPPROG, GM_SETDELTAPOS,
  936.                         (WPARAM)((UINT)numWritten), 0L );
  937.     SendDlgItemMessage( e.hDlg, IDG_READBUF, GM_SETPOS,
  938.                         (WPARAM)wrqNumUsed( &e.q ), 0L );
  939. #else
  940.     PostMessage( hRipGauge, GM_SETDELTAPOS, (WPARAM)((UINT)numWritten), 0L );
  941.     PostMessage( hReadGauge, GM_SETPOS, (WPARAM)wrqNumUsed( &e.q ), 0L );
  942. #endif
  943. }                                             /* End of UpdateTime function*/
  946. /*
  947.  * Returns TRUE if Lame_enc.dll is old enough to use the original BladeEnc
  948.  * interface.  Also returns TRUE if lame_enc isn't available...
  949.  */
  950. BOOL isOldLameEnc( void )
  951. {
  952.   BE_VERSION bev;
  953.   BEVERSION      pfnbeVersion;
  954.   DWORD dwEngine, dwDll;
  956.   if ( hLameDll )
  957.     {
  958.       pfnbeVersion = (BEVERSION)GetProcAddress( hLameDll, "beVersion" );
  959.       ZeroMemory( &bev, sizeof(bev) );
  960.       if ( pfnbeVersion )
  961. pfnbeVersion( &bev );
  962.       dwEngine = (((DWORD)bev.byMajorVersion)<<8) + bev.byMinorVersion;
  963.       dwDll = (((DWORD)bev.byDLLMajorVersion)<<8) + bev.byDLLMinorVersion;
  964.       if ( (dwEngine < 0x0336) || (dwDll < 0x0104) )
  965. return TRUE;
  966.       return FALSE;
  967.     }
  969.   return TRUE;
  970. }