home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / VISUAL_B / FERRAMEN / VB_WAVE / VBWAVE.C next >
Encoding:
C/C++ Source or Header  |  1992-05-27  |  18.0 KB  |  675 lines
  1.  
  2. #include "windows.h"
  3. #include "mmsystem.h"
  4. #include "commdlg.h"
  5. #include "vbapi.h"
  6. #include "vbwave.h"
  7.  
  8. LONG _export FAR PASCAL WaveWndProc( HCTL hCtl, HWND hWnd, WORD msg, WORD wParam, LONG lParam )
  9. {
  10.    switch( msg )
  11.    {
  12.       case WM_CREATE:
  13.       {
  14.          WAVESTRUCT far *Wv = DEREF( hCtl );
  15.  
  16.          if( Wv )
  17.          {
  18.             Wv->WaveFile = (HSZ)NULL;              /*  Initialize variables  */
  19.             Wv->Enable = 0;
  20.             Wv->hWaveHeader = NULL;
  21.             Wv->hWaveData = NULL;
  22.             Wv->dwStart = 0L;
  23.             Wv->dwEnd = 0L;
  24.             Wv->dwSize = 0L;
  25.             Wv->dwVolume = 0L;
  26.             Wv->Loops = 0;
  27.             Wv->dwPlayback = 0x00010000L;
  28.             Wv->nSampPerSec = 0;
  29.             Wv->nBytesPerSec = 0;
  30.             Wv->Reverse = 0;
  31.          }
  32.          break;
  33.       }
  34.  
  35.       case VBM_CREATED:                            /*  Hide icon if runtime  */
  36.          if( VBGetMode() != MODE_DESIGN )
  37.             SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOMOVE );
  38.          else
  39.             SetWindowPos( hWnd, 0, 0, 0, 32, 32, SWP_NOMOVE | SWP_NOZORDER );
  40.          break;
  41.  
  42.       case WM_PAINT:
  43.       {
  44.          PAINTSTRUCT ps;
  45.          HICON hIcon;
  46.          HDC hDC;
  47.          WAVESTRUCT far *Wv = DEREF( hCtl );
  48.  
  49.          hDC = BeginPaint( hWnd, &ps );
  50.          if( Wv )
  51.          {
  52.             if( VBGetMode() == MODE_DESIGN )
  53.             {
  54.                hIcon = LoadIcon( hmodDLL, "Icon" );
  55.                if( hIcon )
  56.                {
  57.                   DrawIcon( hDC, 0, 0, hIcon );
  58.                   DestroyIcon( hIcon );
  59.                }
  60.             }
  61.          }
  62.          EndPaint( hWnd, &ps );
  63.          break;
  64.       }
  65.  
  66.       case VBM_GETPROPERTY:
  67.       {
  68.          WAVESTRUCT far *Wv = DEREF( hCtl );
  69.  
  70.          switch( wParam )
  71.          {
  72.             case PROP_VERSION:
  73.             {
  74.                *(WORD far *)lParam = 100;
  75.                return( FALSE );
  76.             }
  77.  
  78.             case PROP_ENABLE:
  79.             {
  80.                *(WORD far *)lParam = Wv->Enable;
  81.                return( FALSE );
  82.             }
  83.  
  84.             case PROP_LOOP:                 /*  Get number of times to loop  */
  85.             {
  86.                *(WORD far *)lParam = Wv->Loops;
  87.                return( FALSE );
  88.             }
  89.  
  90.             case PROP_CHANNELS:
  91.             {
  92.                WAVEOUTCAPS wc;
  93.  
  94.                waveOutGetDevCaps( Wv->Device, &wc, sizeof(WAVEOUTCAPS) );
  95.                *(WORD far *)lParam = wc.wChannels;
  96.                return( FALSE );
  97.             }
  98.  
  99.             case PROP_DEVICE:
  100.             {
  101.                *(WORD far *)lParam = Wv->Device;
  102.                return( FALSE );
  103.             }
  104.  
  105.             case PROP_END:
  106.             {
  107.                *(LONG far *)lParam = Wv->dwEnd;
  108.                return( FALSE );
  109.             }
  110.  
  111.             case PROP_START:
  112.             {
  113.                *(LONG far *)lParam = Wv->dwStart;
  114.                return( FALSE );
  115.             }
  116.  
  117.             case PROP_VOL:
  118.             {
  119.                DWORD dwVol;
  120.  
  121.                waveOutGetVolume( Wv->Device, &dwVol );
  122.                *(WORD far *)lParam = LOWORD( dwVol );
  123.                return( FALSE );
  124.             }
  125.  
  126.             case PROP_PLAY:
  127.             {
  128.                if( VBGetMode() == MODE_DESIGN )
  129.                   return( FALSE );
  130.  
  131.                if( ! OpenWaveFile( hCtl ) )
  132.                   return( 32000 );
  133.  
  134.                if( ! PlayWaveFile( hCtl ) )
  135.                   return( 32000 );
  136.  
  137.                CloseWaveFile( hCtl );
  138.                return( FALSE );
  139.             }
  140.  
  141.             case PROP_SIZE:
  142.                *(LONG far *)lParam = Wv->dwSize;
  143.                return( FALSE );
  144.  
  145.             case PROP_LVOL:
  146.             {
  147.                DWORD dwVol;
  148.  
  149.                waveOutGetVolume( Wv->Device, &dwVol );
  150.                *(WORD far *)lParam = LOWORD( dwVol );
  151.                return( FALSE );
  152.             }
  153.  
  154.             case PROP_RVOL:
  155.             {
  156.                DWORD dwVol;
  157.  
  158.                waveOutGetVolume( Wv->Device, &dwVol );
  159.                *(WORD far *)lParam = HIWORD( dwVol );
  160.                return( FALSE );
  161.             }
  162.  
  163.             case PROP_PLAYBACK:
  164.             {
  165.                DWORD dwPlay;
  166.  
  167.                waveOutGetPlaybackRate( Wv->Device, &dwPlay );
  168.                *(WORD far *)lParam = HIWORD( dwPlay );
  169.                return( FALSE );
  170.             }
  171.  
  172.             case PROP_PITCH:
  173.             {
  174.                DWORD dwPitch;
  175.  
  176.                waveOutGetPitch( Wv->Device, &dwPitch );
  177.                *(WORD far *)lParam = HIWORD( dwPitch );
  178.                return( FALSE );
  179.             }
  180.  
  181.             case PROP_VOLOK:
  182.             {
  183.                WAVEOUTCAPS Wo;
  184.  
  185.                waveOutGetDevCaps( Wv->Device, &Wo, sizeof(WAVEOUTCAPS) );
  186.                if( Wo.dwSupport & WAVECAPS_VOLUME )
  187.                   *(WORD far *)lParam = -1;
  188.                else
  189.                   *(WORD far *)lParam = 0;
  190.                return( FALSE );
  191.             }
  192.  
  193.             case PROP_PITCHOK:
  194.             {
  195.                WAVEOUTCAPS Wo;
  196.  
  197.                waveOutGetDevCaps( Wv->Device, &Wo, sizeof(WAVEOUTCAPS) );
  198.                if( Wo.dwSupport & WAVECAPS_PITCH )
  199.                   *(WORD far *)lParam = -1;
  200.                else
  201.                   *(WORD far *)lParam = 0;
  202.                return( FALSE );
  203.             }
  204.  
  205.             case PROP_PLAYRATEOK:
  206.             {
  207.                WAVEOUTCAPS Wo;
  208.  
  209.                waveOutGetDevCaps( Wv->Device, &Wo, sizeof(WAVEOUTCAPS) );
  210.                if( Wo.dwSupport & WAVECAPS_PLAYBACKRATE )
  211.                   *(WORD far *)lParam = -1;
  212.                else
  213.                   *(WORD far *)lParam = 0;
  214.                return( FALSE );
  215.             }
  216.  
  217.             case PROP_LRVOLUMEOK:
  218.             {
  219.                WAVEOUTCAPS Wo;
  220.  
  221.                waveOutGetDevCaps( Wv->Device, &Wo, sizeof(WAVEOUTCAPS) );
  222.                if( Wo.dwSupport & WAVECAPS_LRVOLUME )
  223.                   *(WORD far *)lParam = -1;
  224.                else
  225.                   *(WORD far *)lParam = 0;
  226.                return( FALSE );
  227.             }
  228.  
  229.             case PROP_ISSYNC:
  230.             {
  231.                WAVEOUTCAPS Wo;
  232.  
  233.                waveOutGetDevCaps( Wv->Device, &Wo, sizeof(WAVEOUTCAPS) );
  234.                if( Wo.dwSupport & WAVECAPS_SYNC )
  235.                   *(WORD far *)lParam = -1;
  236.                else
  237.                   *(WORD far *)lParam = 0;
  238.                return( FALSE );
  239.             }
  240.  
  241.             case PROP_SAMPPERSEC:
  242.             {
  243.                *(WORD far *)lParam = Wv->nSampPerSec;
  244.                return( FALSE );
  245.             }
  246.  
  247.             case PROP_REVERSE:
  248.             {
  249.                *(WORD far *)lParam = Wv->Reverse;
  250.                return( FALSE );
  251.             }
  252.          }
  253.          break;
  254.       }
  255.  
  256.       case VBM_SETPROPERTY:
  257.       {
  258.          WAVESTRUCT far *Wv = DEREF( hCtl );
  259.  
  260.          switch( wParam )
  261.          {
  262.             case PROP_FILENAME:
  263.             {
  264.                if( ! OpenWaveFile( hCtl ) )
  265.                   return( TRUE );
  266.  
  267.                CloseWaveFile( hCtl );
  268.                return( FALSE );
  269.             }
  270.  
  271.             case PROP_ENABLE:
  272.                Wv->Enable = (BOOL)lParam;
  273.                return( FALSE );
  274.  
  275.             case PROP_LOOP:
  276.                Wv->Loops = LOWORD( lParam );
  277.                return( FALSE );
  278.  
  279.             case PROP_DEVICE:
  280.                Wv->Device = LOWORD( lParam );
  281.                return( FALSE );
  282.  
  283.             case PROP_START:
  284.                if( lParam > Wv->dwSize )
  285.                   Wv->dwStart = Wv->dwSize;
  286.                else
  287.                   Wv->dwStart = lParam;
  288.                break;
  289.  
  290.             case PROP_END:
  291.                if( lParam > Wv->dwSize )
  292.                   Wv->dwEnd = Wv->dwSize;
  293.                else
  294.                   Wv->dwEnd = lParam;
  295.                return( FALSE );
  296.  
  297.             case PROP_VOL:
  298.                Wv->dwVolume = MAKELONG( LOWORD( lParam ), LOWORD( lParam ) );
  299.                waveOutSetVolume( Wv->Device,
  300.                                  MAKELONG( LOWORD( Wv->dwVolume ), LOWORD( Wv->dwVolume ) ) );
  301.                return( FALSE );
  302.  
  303.             case PROP_LVOL:
  304.                Wv->dwVolume = ( Wv->dwVolume & 0xFFFF0000L ) + LOWORD( lParam );
  305.                waveOutSetVolume( Wv->Device, Wv->dwVolume );
  306.                return( FALSE );
  307.  
  308.             case PROP_RVOL:
  309.                Wv->dwVolume = ( Wv->dwVolume & 0xFFFFL ) + ( lParam << 16 );
  310.                waveOutSetVolume( Wv->Device, Wv->dwVolume );
  311.                return( FALSE );
  312.  
  313.             case PROP_PLAYBACK:
  314.                Wv->dwPlayback = lParam << 16;
  315.                return( FALSE );
  316.  
  317.             case PROP_PITCH:
  318.                Wv->dwPitch = lParam << 16;
  319.                return( FALSE );
  320.  
  321.             case PROP_SAMPPERSEC:
  322.                Wv->nSampPerSec = LOWORD( lParam );
  323.                return( FALSE );
  324.  
  325.             case PROP_REVERSE:
  326.                Wv->Reverse = (BOOL)lParam;
  327.                return( FALSE );
  328.          }
  329.          break;
  330.       }
  331.  
  332.       case VBM_INITPROPPOPUP:
  333.       {
  334.          switch( wParam )
  335.          {
  336.             case PROP_FILENAME:
  337.             {
  338.                FARPROC DlgProc;
  339.  
  340.                if( VBGetMode() == MODE_DESIGN )
  341.                {
  342.                   DlgCtl = hCtl;
  343.  
  344.                   return( CreateWindow( CLASSPOPUP, NULL, WS_POPUP, 0, 0, 0, 0,
  345.                                         NULL, NULL, hmodDLL, NULL ) );
  346.                }
  347.                return( NULL );
  348.             }
  349.          }
  350.          break;
  351.       }
  352.    }
  353.    return( VBDefControlProc( hCtl, hWnd, msg, wParam, lParam ) );
  354. }
  355.  
  356.  
  357. LONG _export FAR PASCAL PopupWndProc( HWND hWnd, WORD msg, WORD wParam, LONG lParam )
  358. {
  359.    switch( msg )
  360.    {
  361.       case WM_SHOWWINDOW:
  362.          if( wParam )
  363.          {
  364.             PostMessage( hWnd, WM_USER, 0, 0L );
  365.             return( 0L );
  366.          }
  367.          break;
  368.  
  369.       case WM_USER:
  370.       {
  371.          OPENFILENAME Of;
  372.          HSZ hsz;
  373.          char str[ 128 ];
  374.  
  375.          lstrcpy( str, WaveWild );
  376.          Of.lStructSize = sizeof(OPENFILENAME);
  377.          Of.hwndOwner = hWnd;
  378.          Of.hInstance = (HANDLE)NULL;
  379.          Of.lpstrFilter = WaveMask;
  380.          Of.lpstrCustomFilter = (LPSTR)NULL;
  381.          Of.nMaxCustFilter = (DWORD)0;
  382.          Of.nFilterIndex = (DWORD)0;
  383.          Of.lpstrFile = str;
  384.          Of.nMaxFile = (DWORD)128;
  385.          Of.lpstrFileTitle = (LPSTR)NULL;
  386.          Of.nMaxFileTitle = (DWORD)NULL;
  387.          Of.lpstrInitialDir = (LPSTR)NULL;
  388.          Of.lpstrTitle = WaveTitle;
  389.          Of.Flags = (DWORD)NULL;
  390.          Of.nFileOffset = 0;
  391.          Of.nFileExtension = 0;
  392.          Of.lpstrDefExt = (LPSTR)NULL;
  393.          Of.lCustData = NULL;
  394.          Of.lpfnHook = NULL;
  395.          Of.lpTemplateName = (LPSTR)NULL;
  396.  
  397.          if( GetOpenFileName( &Of ) )
  398.             VBSetControlProperty( DlgCtl, PROP_FILENAME, (LONG)(LPSTR)str );
  399.          return( 0L );
  400.       }
  401.    }
  402.    return( DefWindowProc( hWnd, msg, wParam, lParam ) );
  403. }
  404.  
  405.  
  406. BOOL OpenWaveFile( HCTL hCtl )
  407. {
  408.    WAVESTRUCT far *Wv = DEREF( hCtl );
  409.    LPSTR lpWaveName;
  410.    int fd, status;
  411.    char str[ 6 ];
  412.    DWORD Dsize;
  413.    HWAVEOUT hWo;
  414.    PCMWAVEFORMAT Pcm;
  415.    LPWAVEHDR Wf;
  416.  
  417.    lpWaveName = VBDerefHsz( Wv->WaveFile );
  418.  
  419.    fd = _lopen( lpWaveName, READ_WRITE );                /*  Open .WAV file  */
  420.  
  421.    if( fd == -1 )                               /*  If it didn't open, quit  */
  422.       return( TRUE );
  423.  
  424.    _lread( fd, str, 4 );                               /*  Read file ID tag  */
  425.  
  426.    str[ 4 ] = '\0';                                 /*  Add NULL terminator  */
  427.  
  428.    if( lstrcmp( str, "RIFF" ) )         /*  Make sure it's a 'RIFF' file...  */
  429.    {
  430.       _lclose( fd );                                       /*  If not, exit  */
  431.       return( FALSE );
  432.    }
  433.                                                     /*  Get total file size  */
  434.    _lread( fd, (LPSTR)&Dsize, sizeof(DWORD) );
  435.  
  436.    _lread( fd, str, 4 );                             /*  Read next file tag  */
  437.  
  438.    if( lstrcmp( str, "WAVE" ) )         /*  Make sure it's a 'WAVE' file...  */
  439.    {
  440.       _lclose( fd );                           /*  If not a Wave file, exit  */
  441.       return( FALSE );
  442.    }
  443.  
  444.    _lread( fd, str, 4 );               /*  Search for WAVEFORMAT header tag  */
  445.  
  446.    if( lstrcmp( str, "fmt " ) )                  /*  If this isn't it, exit  */
  447.    {
  448.       _lclose( fd );
  449.       return( FALSE );
  450.    }
  451.  
  452.                                            /*  Read PCMWAVEFORMAT structure  */
  453.    _lread( fd, (LPSTR)&Dsize, sizeof(DWORD) );
  454.    if( Dsize != sizeof(PCMWAVEFORMAT) )
  455.    {
  456.       _lclose( fd );                /*  If info in file isn't for structure  */
  457.       return( FALSE );                             /*  then exit, of course  */
  458.    }
  459.  
  460.    _lread( fd, (LPSTR)&Pcm, Dsize );          /*  Fill structure  */
  461.  
  462.    Wv->nSamplesPerSec = (WORD)Pcm.wf.nSamplesPerSec;
  463.    Wv->nBytesPerSec = (WORD)Pcm.wf.nAvgBytesPerSec;
  464.  
  465.    _lread( fd, str, 4 );
  466.    if( lstrcmp( str, "data" ) )               /*  Signals beginning of data  */
  467.    {
  468.       _lclose( fd );
  469.       return( FALSE );
  470.    }
  471.                                                       /*  Read size of data  */
  472.    _lread( fd, (LPSTR)&Dsize, sizeof(DWORD) );
  473.    Wv->dwSize = Dsize;                            /*  Save data size for VB  */
  474.  
  475.    if( Wv->nSampPerSec == 0 )
  476.       Pcm.wf.nSamplesPerSec = 11025;
  477.  
  478.    if( Wv->nSampPerSec == 1 )
  479.       Pcm.wf.nSamplesPerSec = 22050;
  480.  
  481.    if( Wv->nSampPerSec == 2 )
  482.       Pcm.wf.nSamplesPerSec = 44100;
  483.  
  484.    if( waveOutOpen( &hWo, 0, (PCMWAVEFORMAT far *)&Pcm, NULL, NULL,
  485.                     WAVE_ALLOWSYNC ) )
  486.    {
  487.       _lclose( fd );
  488.       return( FALSE );
  489.    }
  490.                                        /*  Allocate global space for header  */
  491.    Wv->hWaveHeader = GlobalAlloc( GMEM_MOVEABLE | GMEM_DDESHARE, sizeof(WAVEHDR) );
  492.    if( ! Wv->hWaveHeader )
  493.    {
  494.       _lclose( fd );
  495.       return( NULL );
  496.    }
  497.  
  498.    Wf = (LPWAVEHDR)GlobalLock( Wv->hWaveHeader );
  499.    if( ! Wf )
  500.    {
  501.       GlobalFree( Wv->hWaveHeader );
  502.       Wv->hWaveHeader = NULL;
  503.       _lclose( fd );
  504.       return( NULL );
  505.    }
  506.                                                 /*  Allocate space for data  */
  507.    Wv->hWaveData = GlobalAlloc( GMEM_MOVEABLE | GMEM_DDESHARE, Dsize );
  508.    if( ! Wv->hWaveData )
  509.    {
  510.       GlobalUnlock( Wv->hWaveHeader );
  511.       GlobalFree( Wv->hWaveHeader );
  512.       Wv->hWaveHeader = NULL;
  513.       _lclose( fd );
  514.       return( NULL );
  515.    }
  516.  
  517.    Wf->lpData = GlobalLock( Wv->hWaveData );
  518.    if( ! Wf->lpData )
  519.    {
  520.       GlobalFree( Wv->hWaveData );
  521.       Wv->hWaveData = NULL;
  522.       GlobalUnlock( Wv->hWaveHeader );
  523.       GlobalFree( Wv->hWaveHeader );
  524.       Wv->hWaveHeader = NULL;
  525.       _lclose( fd );
  526.       return( NULL );
  527.    }
  528.                                              /*  Read data into data buffer  */
  529.    _hread( fd, Wf->lpData, Dsize );
  530.  
  531.    Wf->dwBufferLength = Dsize;                        /*  Initialize header  */
  532.    Wf->dwFlags = WHDR_BEGINLOOP | WHDR_ENDLOOP;
  533.    Wf->dwLoops = (DWORD)Wv->Loops;
  534.    Wv->hWave = hWo;                                      /*  Save ID handle  */
  535.  
  536.    Wv->dwSize = Dsize;
  537.  
  538.    GlobalUnlock( Wv->hWaveData );
  539.    GlobalUnlock( Wv->hWaveHeader );
  540.    _lclose( fd );
  541.  
  542.    return( TRUE );
  543. }
  544.  
  545.  
  546. BOOL CloseWaveFile( HCTL hCtl )
  547. {
  548.    WAVESTRUCT far *Wv = DEREF( hCtl );
  549.  
  550.    if( ! Wv->hWaveHeader && ! Wv->hWaveData )
  551.       return( TRUE );
  552.  
  553.    if( Wv->hWaveHeader )
  554.    {
  555.       GlobalFree( Wv->hWaveHeader );
  556.       Wv->hWaveHeader = NULL;
  557.    }
  558.  
  559.    if( Wv->hWaveData )
  560.    {
  561.       GlobalFree( Wv->hWaveData );
  562.       Wv->hWaveData = NULL;
  563.    }
  564.  
  565.    waveOutClose( Wv->hWave );
  566.    return( TRUE );
  567. }
  568.  
  569.  
  570. BOOL PlayWaveFile( HCTL hCtl )
  571. {
  572.    WAVESTRUCT far *Wv = DEREF( hCtl );
  573.    int status;
  574.    LPWAVEHDR Wf;
  575.    LPSTR lpData;
  576.    DWORD dwBufferLength, dwTemp;
  577.  
  578.    Wf = (LPWAVEHDR)GlobalLock( Wv->hWaveHeader );
  579.    if( ! Wf )
  580.       return( FALSE );
  581.  
  582.    Wf->lpData = GlobalLock( Wv->hWaveData );
  583.    if( ! Wf->lpData )
  584.    {
  585.       GlobalUnlock( Wv->hWaveHeader );
  586.       return( FALSE );
  587.    }
  588.  
  589.    lpData = Wf->lpData;
  590.    dwBufferLength = Wf->dwBufferLength;
  591.  
  592.    if( Wv->dwStart > Wv->dwEnd )
  593.    {
  594.       dwTemp = Wv->dwStart;
  595.       Wv->dwStart = Wv->dwEnd;
  596.       Wv->dwEnd = dwTemp;
  597.    }
  598.  
  599.    waveOutSetVolume( Wv->Device, Wv->dwVolume );
  600.    waveOutSetPlaybackRate( Wv->Device, Wv->dwPlayback );
  601.    waveOutSetPitch( Wv->Device, Wv->dwPitch );
  602.  
  603.    Wf->lpData = Wf->lpData + Wv->dwStart;
  604.    Wf->dwBufferLength = Wv->dwEnd - Wv->dwStart;
  605.  
  606.    status = waveOutPrepareHeader( Wv->hWave, Wf, sizeof(WAVEHDR) );
  607.    if( status )
  608.    {
  609.       Wf->lpData = lpData;
  610.       Wf->dwBufferLength = dwBufferLength;
  611.       GlobalUnlock( Wv->hWaveHeader );
  612.       GlobalUnlock( Wv->hWaveData );
  613.       return( FALSE );
  614.    }
  615.  
  616.    if( Wv->Reverse )
  617.       ReverseData( Wv->hWaveData );
  618.  
  619.    status = waveOutWrite( Wv->hWave, Wf, sizeof(WAVEHDR) );
  620.  
  621.    if( Wv->Reverse )
  622.       ReverseData( Wv->hWaveData );
  623.  
  624.    if( status )
  625.    {
  626.       Wf->lpData = lpData;
  627.       Wf->dwBufferLength = dwBufferLength;
  628.       GlobalUnlock( Wv->hWaveHeader );
  629.       GlobalUnlock( Wv->hWaveData );
  630.       return( FALSE );
  631.    }
  632.  
  633.    status = waveOutUnprepareHeader( Wv->hWave, Wf, sizeof(WAVEHDR) );
  634.    if( status )
  635.    {
  636.       Wf->lpData = lpData;
  637.       Wf->dwBufferLength = dwBufferLength;
  638.       GlobalUnlock( Wv->hWaveHeader );
  639.       GlobalUnlock( Wv->hWaveData );
  640.       return( FALSE );
  641.    }
  642.  
  643.    Wf->lpData = lpData;
  644.    Wf->dwBufferLength = dwBufferLength;
  645.  
  646.    GlobalUnlock( Wv->hWaveData );
  647.    GlobalUnlock( Wv->hWaveHeader );
  648.  
  649.    return( TRUE );
  650. }
  651.  
  652.  
  653.  
  654. void ReverseData( HANDLE hMem )
  655. {
  656.    BYTE far *lpData;
  657.    DWORD Counter, dwHalf, dwLength;
  658.    BYTE bTemp;
  659.  
  660.    lpData = GlobalLock( hMem );
  661.    if( ! lpData )
  662.       return;
  663.  
  664.    dwLength = GlobalSize( hMem ) - 32;
  665.    dwHalf = ( dwLength ) / 2;
  666.    for( Counter = 0; Counter < dwHalf; Counter++ )
  667.    {
  668.       bTemp = *( lpData + Counter );
  669.       *( lpData + Counter ) = *( lpData + dwLength - Counter );
  670.       *( lpData + dwLength - Counter ) = bTemp;
  671.    }
  672.    GlobalUnlock( hMem );
  673. }
  674.  
  675.