home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / graphics / directx / dsshow / shell.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-07-15  |  77.4 KB  |  3,130 lines
  1. /*==========================================================================
  2.  *
  3.  *  Copyright (C) 1995-1997 Microsoft Corporation. All Rights Reserved.
  4.  *
  5.  *  File:       shell.c
  6.  *  Content:    Direct Sound show-off.
  7.  *  This app basically uses the direct sound api's and pops up some
  8.  *  controls that the user can play with at runtime to change
  9.  *  the sound frequency, panning, volume, etc.   It has a few
  10.  *  other functions built in.
  11.  *
  12.  *  This app also takes a couple command-line parameters.  The format is:
  13.  *
  14.  *    DSShow [/PLAY [/LOOP]] [file] [file] ...
  15.  *
  16.  *    Specifying /PLAY causes any specified files to be played as they're
  17.  * opened.  Adding the /LOOP causes them to loop as well.  /LOOP without
  18.  * /PLAY means nothing.  Everything else is assumed to be one or more file
  19.  * names.  Filenames can be enclosed in quotes.  This also means you can
  20.  * drag and drop files onto the program's icon
  21.  *
  22.  *
  23.  ***************************************************************************/
  24.  
  25. #define INITGUID
  26. #include <windows.h>
  27. #include <windowsx.h>
  28. #include <commctrl.h>
  29. #include <commdlg.h>
  30. #include <stdio.h>
  31.  
  32. #include <mmsystem.h>
  33. #include <mmreg.h>
  34. #include <msacm.h>
  35. #include <dsound.h>
  36.  
  37.  
  38. #include "wassert.h"
  39. #include "wave.h"
  40.  
  41. #include "resource.h"
  42. #include "shell.h"
  43. #include "dsenum.h"
  44.  
  45.  
  46. // =======================================================================
  47. /* Procedure called when the application is loaded for the first time */
  48. // =======================================================================
  49. BOOL ClassInit( hInstance )
  50. HANDLE hInstance;
  51. {
  52.     WNDCLASS    myClass;
  53.         
  54.     myClass.hCursor             = LoadCursor( NULL, IDC_ARROW );
  55.     myClass.hIcon               = LoadIcon( hInstance, MAKEINTRESOURCE(IDI_ICON3));
  56.     myClass.lpszMenuName        = MAKEINTRESOURCE(IDR_MAINMENU);
  57.     myClass.lpszClassName       = (LPSTR)szAppName;
  58.     myClass.hbrBackground       = (HBRUSH)(COLOR_WINDOW);
  59.     myClass.hInstance           = hInstance;
  60.     myClass.style               = CS_HREDRAW | CS_VREDRAW;
  61.     myClass.lpfnWndProc         = WndProc;
  62.     myClass.cbClsExtra          = 0;
  63.     myClass.cbWndExtra          = 0;
  64.  
  65.     if (!RegisterClass( &myClass ) )
  66.        return FALSE;
  67.  
  68.     return TRUE;        /* Initialization succeeded */
  69. }
  70.  
  71.  
  72. // =======================================================================
  73. /* This "hook procedure" is called by the common dialog code for certain
  74.  *   events that may occur during the life of our nested dialog structure.
  75.  *     We nest the Explorer style dialog inside our file open dialog so we
  76.  *   can addd a check box for stick buffers.
  77.  */
  78.  // =======================================================================
  79. UINT CALLBACK FileOpenCustomTemplateDlgProc( hDlg, message, wParam, lParam )
  80. HWND hDlg;
  81. UINT message;
  82. WPARAM wParam;
  83. LPARAM lParam;
  84. {
  85.     static LPOPENFILENAME   lpofn = NULL;
  86.  
  87.     switch( message )
  88.     {
  89.     case WM_INITDIALOG:
  90.         lpofn = (LPOPENFILENAME)lParam;
  91.         
  92.         /* Set the flag to match the current state of the check box control */
  93.         *((LPBOOL)lpofn->lCustData) = SendDlgItemMessage( hDlg, IDC_FONEST_STICKY,
  94.                                                             BM_GETCHECK, 0, 0 );
  95.         return TRUE;
  96.  
  97.     case WM_NOTIFY:
  98.         switch(((LPOFNOTIFY)lParam)->hdr.code)
  99.         {
  100.         case CDN_SELCHANGE:
  101.             /* Use this area to process anything that must be updated when the
  102.              * user changes the selection in the Common Dialog Box.
  103.              *   NOTE: Provided only for informational purposes
  104.              */
  105.             return FALSE;
  106.  
  107.         case CDN_FILEOK:
  108.             /* We can do lots of things in this notification message.  The most
  109.              * important is that we can decide whether the Common Dialog call will
  110.              * go through or whether it will fail.  I decided to handle the checkbox
  111.              * control in this one place versus 4 others... -PRN
  112.              */
  113.             Assert( lpofn != NULL );
  114.             *((LPBOOL)lpofn->lCustData) = SendDlgItemMessage( hDlg, IDC_FONEST_STICKY,
  115.                                                                 BM_GETCHECK, 0, 0 );
  116.             /* Returning zero signifies that we "approve" of the OK command,
  117.              * and allows the common dialog to finish.
  118.              */
  119.             return FALSE;
  120.         }
  121.         /* Let the default dialog do/continue processing */
  122.         return FALSE;
  123.     }
  124.     return FALSE;
  125. }
  126.  
  127.  
  128. // =======================================================================
  129. // =======================================================================
  130. int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
  131. HINSTANCE hInstance, hPrevInstance;
  132. LPSTR lpszCmdLine;
  133. int cmdShow;
  134. {
  135.     MSG   msg;
  136.     HWND  hWnd;
  137.  
  138.     // We must call this to ensure the common controls are setup for
  139.     // this application
  140.     InitCommonControls();
  141.  
  142.     if (!hPrevInstance) {
  143.     /* Call initialization procedure if this is the first instance */
  144.     if (!ClassInit( hInstance ))
  145.         return FALSE;
  146.     }
  147.  
  148.     
  149.     hWnd = CreateWindow((LPSTR)szAppName,
  150.                         (LPSTR)szMessage,
  151.                         WS_OVERLAPPEDWINDOW,
  152.                         CW_USEDEFAULT,    
  153.                         CW_USEDEFAULT,    
  154.                         DX_MINWINDOW,     
  155.                         DY_MINWINDOW,     
  156.                         (HWND)NULL,        
  157.                         (HMENU)NULL,      
  158.                         (HANDLE)hInstance, 
  159.                         (LPSTR)NULL        
  160.                         );
  161.  
  162.     if (!hWnd) return (int)msg.wParam;
  163.  
  164.     // Make a long line across the top.
  165.     CreateWindow(
  166.     "STATIC", 
  167.     "", 
  168.     WS_CHILD | WS_VISIBLE | SS_ETCHEDHORZ, 
  169.     0,
  170.     0,
  171.     8000, 
  172.     2,              
  173.     hWnd, 
  174.     (HMENU)0, 
  175.     hInst, 
  176.     NULL);
  177.     
  178.  
  179.     /* Save instance handle for DialogBox */
  180.     hInst = hInstance;
  181.     
  182.     ShowWindow( hWnd, cmdShow );
  183.  
  184.     if( lpszCmdLine && *lpszCmdLine )
  185.         if( !ParseCommandLine( lpszCmdLine ))
  186.         goto Exit_WinMain;
  187.     
  188.     /* Polling messages from event queue */
  189.     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
  190.     TranslateMessage((LPMSG)&msg);
  191.     DispatchMessage((LPMSG)&msg);
  192.     }
  193.  
  194. Exit_WinMain:
  195.     DestroyWindow(hWnd);
  196.     UnregisterClass(szAppName, hInstance);
  197.     return (int)msg.wParam;
  198. }
  199.  
  200. // =======================================================================
  201. /*  This function updates the status window by writing the specified
  202.     string to the window, prepended by a string indicating whether
  203.     the buffer is in hardware or software
  204. */
  205. // =======================================================================
  206. void UpdateStatus(FILEINFO *pFileInfo, DWORD dwStatus)
  207. {
  208.     TCHAR szStatus[200];
  209.     DWORD dwPlay, dwWrite;
  210.     HRESULT hr;
  211.  
  212.     lstrcpy(szStatus, pFileInfo->fHardware ? szHW : szSW);
  213.     if (dwStatus & DSBSTATUS_BUFFERLOST)
  214.     {
  215.     lstrcat(szStatus, szLost);
  216.     SendMessage(pFileInfo->hWndStatus_TXT, WM_SETTEXT, 0, (LPARAM)szStatus);
  217.     }
  218.     else if (dwStatus & DSBSTATUS_PLAYING)
  219.     {
  220.     lstrcat(szStatus, szPlaying);
  221.     SendMessage(pFileInfo->hWndStatus_TXT, WM_SETTEXT, 0, (LPARAM)szStatus);
  222.     }
  223.     else
  224.     {
  225.     lstrcat(szStatus, szStopped);
  226.     SendMessage(pFileInfo->hWndStatus_TXT, WM_SETTEXT, 0, (LPARAM)szStatus);
  227.     }
  228.  
  229.     if (pFileInfo->fSticky)
  230.     {
  231.     lstrcat(szStatus, szSticky);
  232.     SendMessage(pFileInfo->hWndStatus_TXT, WM_SETTEXT, 0, (LPARAM)szStatus);
  233.     }
  234.     hr = IDirectSoundBuffer_GetCurrentPosition(pFileInfo->pDSB, &dwPlay, &dwWrite);
  235.     if (DS_OK == hr) {
  236.     wsprintf(szStatus, szFmtPlayPosition, dwPlay);
  237.     SendMessage(pFileInfo->hWndPlayPosition_TXT, WM_SETTEXT, 0, (LPARAM)szStatus);
  238.     wsprintf(szStatus, szFmtWritePosition, dwWrite);
  239.     SendMessage(pFileInfo->hWndWritePosition_TXT, WM_SETTEXT, 0, (LPARAM)szStatus);
  240.     }
  241.  
  242.     return;
  243. }
  244.  
  245. // =======================================================================
  246. /*  This function updates the main window title to show some
  247.     relevant information about the direct sound object
  248. */
  249. // =======================================================================
  250. void UpdateMainStatus()
  251. {
  252.     DSCAPS  dsc;
  253.     TCHAR   szTitle[200];
  254.     
  255.     // Update main window title with some relevant info
  256.     dsc.dwSize = sizeof(dsc);
  257.     IDirectSound_GetCaps(gpds, &dsc);
  258.     wsprintf(szTitle, "%s : free hw memory = %dKb, free hw buffers = %d",
  259.      szMessage, (dsc.dwFreeHwMemBytes+512)/1024,
  260.      dsc.dwFreeHwMixingAllBuffers);
  261.     SendMessage(hWndMain, WM_SETTEXT, 0, (LPARAM)szTitle);
  262.     return;
  263. }
  264.  
  265.  
  266. // =======================================================================
  267. /*  This routine will set up everything needed for the app to run.
  268.  
  269.     Input:
  270.     hWnd                - App main window handle
  271.  
  272.     Output:
  273.     None.
  274.  
  275. */
  276. // =======================================================================
  277. int AppInit(HWND hWnd)
  278. {
  279.     UINT            cT;
  280.     DSBUFFERDESC    dsbd;
  281.     BOOL        fUseGuid;
  282.     HRESULT         hr;
  283.     DWORD           dw;
  284.  
  285.     // Set up the global window handle.
  286.     hWndMain = hWnd;
  287.  
  288.     // Set up the global File...Open dialog's start directory
  289.     GetMediaStartPath();
  290.  
  291.     // Set up the file info header
  292.     FileInfoFirst.pNext = NULL;
  293.     FileInfoFirst.pwfx = NULL;
  294.     FileInfoFirst.cox = COX_STARTCONTROL;
  295.     FileInfoFirst.coy = COY_STARTCONTROL;
  296.  
  297.     // Clear the coordinate buffer.  Used to find the next available
  298.     // position to use for a new control.  -1 is the invalid value.
  299.     for (cT=0; cT<MAXCONTROLS; cT++) rgfcoxAvail[cT] = FALSE;
  300.  
  301.     // Setup the timer...
  302.     if ((dwTimer = SetTimer(hWnd, 1, TIMERPERIOD, NULL)) == 0) 
  303.     {
  304.         MessageBox(hWnd, "Cannot allocate timer, aborting", "DirectSound Demo", MB_OK|MB_ICONSTOP);
  305.         return -1;
  306.     }
  307.  
  308.     // Now set up all the direct sound stuff...
  309.  
  310.     // Get the largest waveformatex structure.
  311.     if (MMSYSERR_NOERROR != acmMetrics(NULL, ACM_METRIC_MAX_SIZE_FORMAT, &dw))
  312.     {
  313.     MessageBox(hWnd, "ACM Metrics failed, aborting", "DirectSound Demo",
  314.            MB_OK|MB_ICONSTOP);
  315.     return -1;
  316.     }
  317.  
  318.  
  319.     // Setup the format, frequency, volume, etc.
  320.     if ((FileInfoFirst.pwfx = GlobalAllocPtr(GPTR, dw)) == NULL)
  321.     {
  322.     MessageBox(hWnd, "Out of Memory", "DirectSound Demo",
  323.            MB_OK|MB_ICONSTOP);
  324.     return -1;
  325.     }
  326.  
  327.  
  328.  
  329.     FileInfoFirst.pwfx->wFormatTag = WAVE_FORMAT_PCM;
  330.     FileInfoFirst.pwfx->nChannels = 2;
  331.     FileInfoFirst.pwfx->nSamplesPerSec = 22050;
  332.     FileInfoFirst.pwfx->nAvgBytesPerSec = 22050*2*2;
  333.     FileInfoFirst.pwfx->nBlockAlign = 4;
  334.     FileInfoFirst.pwfx->wBitsPerSample = 16;
  335.     FileInfoFirst.pwfx->cbSize = 0;
  336.     
  337. #ifdef STARTEIGHTBITS
  338.  
  339.     FileInfoFirst.pwfx->wFormatTag = WAVE_FORMAT_PCM;
  340.     FileInfoFirst.pwfx->nChannels = 2;
  341.     FileInfoFirst.pwfx->nSamplesPerSec = 22050;
  342.     FileInfoFirst.pwfx->nAvgBytesPerSec = 22050*1*2;
  343.     FileInfoFirst.pwfx->nBlockAlign = 2;
  344.     FileInfoFirst.pwfx->wBitsPerSample = 8;
  345.     FileInfoFirst.pwfx->cbSize = 0;
  346. #endif
  347.  
  348. #ifdef STARTMONO    
  349.     FileInfoFirst.pwfx->wFormatTag = WAVE_FORMAT_PCM;
  350.     FileInfoFirst.pwfx->nChannels = 1;
  351.     FileInfoFirst.pwfx->nSamplesPerSec = 22050;
  352.     FileInfoFirst.pwfx->nAvgBytesPerSec = 22050*1*2;
  353.     FileInfoFirst.pwfx->nBlockAlign = 2;
  354.     FileInfoFirst.pwfx->wBitsPerSample = 16;
  355.     FileInfoFirst.pwfx->cbSize = 0;
  356. #endif
  357.     
  358.     // Optionally enumerate DSOUND devices and allow the user to pick one...
  359.  
  360.     if (!SUCCEEDED(CoInitialize(NULL))) {
  361.     MessageBox(hWnd, "Failed to initialize COM library", "DirectSound Demo", MB_OK | MB_ICONSTOP);
  362.     return -1;
  363.     }
  364.     
  365.     fEnumDrivers = (BOOL)GetProfileInt( "DSSHOW", "EnumDrivers", FALSE );
  366.     fUseGuid = (fEnumDrivers && !DoDSoundEnumerate(&guID));
  367.  
  368.     // Create the direct sound object.
  369.     hr = CoCreateInstance(&CLSID_DirectSound, NULL, CLSCTX_INPROC_SERVER,
  370.               &IID_IDirectSound, &gpds);
  371.  
  372.     if (SUCCEEDED(hr) && (NULL != gpds))
  373.     {
  374.         hr = IDirectSound_Initialize(gpds, fUseGuid ? &guID : NULL);
  375.         if (SUCCEEDED(hr)) 
  376.         {
  377.             // Note we need to set the level to be priority to set the
  378.             // format of the primary buffer
  379.             hr = IDirectSound_SetCooperativeLevel(gpds, hWndMain, DSSCL_PRIORITY);
  380.             if (SUCCEEDED(hr)) 
  381.             {
  382.  
  383.             // Set up the primary direct sound buffer.
  384.             ZeroMemory(&dsbd, sizeof(dsbd));
  385.             dsbd.dwSize = sizeof(dsbd);
  386.             dsbd.dwFlags = DSBCAPS_PRIMARYBUFFER;
  387.     
  388.             hr = IDirectSound_CreateSoundBuffer(gpds, &dsbd, &(FileInfoFirst.pDSB), NULL);
  389.             if (SUCCEEDED(hr)) 
  390.             {
  391.                 hr = IDirectSoundBuffer_Play(FileInfoFirst.pDSB, 0, 0, DSBPLAY_LOOPING);
  392.                 if (SUCCEEDED(hr)) 
  393.                 {
  394.                     UpdateMainStatus();
  395.                 } 
  396.                 else 
  397.                 {
  398.                     MessageBox(hWnd, "Cannot play primary buffer","DirectSound Demo", MB_OK|MB_ICONSTOP);
  399.                     IDirectSoundBuffer_Release(FileInfoFirst.pDSB);
  400.                     FileInfoFirst.pDSB = NULL;
  401.                 }        
  402.             } 
  403.             else 
  404.             {
  405.                 MessageBox(hWnd, "Cannot create primary buffer","DirectSound Demo", MB_OK|MB_ICONSTOP);
  406.             }
  407.         } 
  408.         else 
  409.         {
  410.         MessageBox(hWnd, "DirectSound SetCooperativeLevel failed","DirectSound Demo", MB_OK|MB_ICONSTOP);
  411.         }
  412.     } //initialize
  413.     else 
  414.     {
  415.         MessageBox(hWnd, "Failed to Initialize DirectSound object", "DirectSound Demo", MB_OK | MB_ICONSTOP);
  416.     }
  417.  
  418.     if (!SUCCEEDED(hr)) 
  419.     {
  420.         IDirectSound_Release(gpds);
  421.         gpds = NULL;
  422.     }
  423.  
  424.  } 
  425. else 
  426. {
  427.     MessageBox(hWnd, "Failed to create DirectSound COM object",
  428.            "DirectSound Demo", MB_OK | MB_ICONSTOP);
  429. }
  430.  
  431. if (SUCCEEDED(hr)) 
  432. {
  433.     return 0;
  434. } 
  435. else 
  436. {
  437.     CoUninitialize();
  438.     return -1;
  439. }
  440. }
  441.  
  442. // =======================================================================
  443. /*  This will destroy all the created objects, allocated memory, etc.  Must be called
  444.     before termination of app.
  445.  
  446.     Input:
  447.     hWnd                - Window handle of main window
  448.  
  449.     Output:
  450.     None.
  451.  
  452. */
  453. // =======================================================================
  454. void AppDestroy( HWND hWnd )
  455. {
  456.  
  457.     HRESULT     hr = 0;
  458.  
  459.     if (dwTimer != 0)
  460.     {
  461.     KillTimer(hWnd, dwTimer);
  462.     dwTimer = 0;
  463.     }
  464.  
  465.  
  466.     StopAllDSounds(hWnd, &FileInfoFirst);
  467.     FreeAllList(hWnd, &FileInfoFirst);
  468.  
  469.  
  470.     // Destroy the direct sound buffer.
  471.     if(FileInfoFirst.pDSB != NULL) 
  472.     {
  473.     IDirectSoundBuffer_Stop(FileInfoFirst.pDSB);
  474.     IDirectSoundBuffer_Release(FileInfoFirst.pDSB);
  475.     FileInfoFirst.pDSB = NULL;
  476.     }
  477.  
  478.     // Destroy the direct sound object.
  479.     if (gpds != NULL)
  480.     {
  481.     IDirectSound_Release(gpds);
  482.     gpds = NULL;
  483.     CoUninitialize();
  484.     }
  485.  
  486.     if (FileInfoFirst.pwfx != NULL)
  487.     {
  488.     GlobalFreePtr(FileInfoFirst.pwfx);
  489.     FileInfoFirst.pwfx = NULL;
  490.     }
  491.  
  492.     if (FileInfoFirst.pbData != NULL)
  493.     {
  494.     GlobalFreePtr(FileInfoFirst.pbData);
  495.     FileInfoFirst.pbData = NULL;
  496.     }
  497.  
  498.     WriteProfileString( "DSSHOW", "EnumDrivers", fEnumDrivers ? "1" : "0" );
  499.  
  500. }
  501.  
  502. // =======================================================================
  503. /* Procedures which make up the window class. */
  504. // =======================================================================
  505. long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
  506. HWND hWnd;
  507. unsigned message;
  508. WPARAM wParam;
  509. LPARAM lParam;
  510. {
  511.  
  512.  
  513.  
  514.     switch (message)
  515.     {
  516.  
  517.     case WM_CREATE:
  518.         if (AppInit(hWnd)) return (-1);
  519.         break;
  520.  
  521.     case WM_TIMER:  
  522.         if (!UIMainWindowTimerHandler(hWnd, wParam, lParam))
  523.         return(DefWindowProc(hWnd, message, wParam, lParam));                           
  524.         break;
  525.         
  526.     
  527.     case WM_HSCROLL:
  528.         if (!UIMainWindowHSBHandler(hWnd, wParam, lParam))
  529.         return(DefWindowProc(hWnd, message, wParam, lParam));
  530.             
  531.         break;
  532.  
  533.     case WM_VSCROLL:
  534.         if (!UIMainWindowVSBHandler(hWnd, wParam, lParam))
  535.         return(DefWindowProc(hWnd, message, wParam, lParam));
  536.         break;
  537.             
  538.  
  539.         case WM_INITMENU:
  540.             if((HMENU)wParam != GetMenu( hWnd ))
  541.                 break;
  542.             CheckMenuItem((HMENU)wParam, IDPD_ENUMDRIVERS,
  543.                 fEnumDrivers ? MF_CHECKED : MF_UNCHECKED );
  544.             break;
  545.  
  546.         case WM_COMMAND:
  547.         if (!UIMainWindowCMDHandler(hWnd, wParam, lParam))
  548.         return(DefWindowProc(hWnd, message, wParam, lParam));
  549.         break;
  550.         
  551.         break;
  552.     
  553.     /*case WM_PAINT:
  554.         {           
  555.         
  556.         break;
  557.         }*/
  558.  
  559.  
  560.     case WM_DESTROY:
  561.         AppDestroy(hWnd);
  562.         PostQuitMessage( 0 );
  563.         break;
  564.     
  565.     default:
  566.         return DefWindowProc( hWnd, message, wParam, lParam );
  567.         break;
  568.         
  569.     }
  570.     
  571.     return(0L);
  572. }
  573.  
  574. // =======================================================================
  575. /*  This routine will pop up the open file dialog and open a file, and make any internal
  576.     arrangements so we know the file is loaded.
  577.  
  578.     Input:
  579.     hWnd            -   Handle of parent window.
  580.  
  581.     Output:
  582.     None.
  583.  
  584. */
  585. // =======================================================================
  586. void PD_FileOpen( HWND hWnd )
  587. {
  588.  
  589.     char            szFileName[MAX_PATH];
  590.     UINT            cSamples;
  591.     FILEINFO        *pFileInfo                  = NULL;
  592.     int             nFileName;
  593.     BOOL            fSticky;
  594.  
  595.     if (GetNumControls(&FileInfoFirst) >= MAXCONTROLS)
  596.     {
  597.     MessageBox(hWnd, "No more controls allowed",
  598.        "Hold on a sec...", MB_OK);
  599.     return;
  600.     }
  601.  
  602.     // Open the file, and check its format, etc.
  603.     if (OpenFileDialog(hWnd, szFileName, &nFileName, &fSticky))
  604.     {
  605.  
  606.     // Allocate the memory for the structure.
  607.     if ((pFileInfo = GlobalAllocPtr(GPTR, sizeof(FILEINFO))) == NULL)
  608.     {
  609.     MessageBox(hWnd, "Cannot add this file",
  610.            "Out of Memory", MB_OK|MB_ICONSTOP);
  611.     goto ERROR_DONE_ROUTINE;
  612.     }
  613.  
  614.     pFileInfo->pbData   = NULL;
  615.     pFileInfo->pwfx     = NULL;
  616.     pFileInfo->pDSB     = NULL;
  617.     pFileInfo->fSticky  = fSticky;
  618.     strcpy(pFileInfo->szFileName, szFileName);
  619.     
  620.     if (WaveLoadFile(szFileName, &pFileInfo->cbSize, 
  621.         &cSamples, &pFileInfo->pwfx, &pFileInfo->pbData) != 0)
  622.     {
  623.     MessageBox(hWnd, "Bad wave file or file too big to fit in memory",
  624.         "Cannot load wave", MB_OK|MB_ICONSTOP);
  625.     goto ERROR_DONE_ROUTINE;
  626.     }
  627.  
  628.     GetNextControlCoords(&FileInfoFirst,
  629.              &pFileInfo->cox, &pFileInfo->coy);
  630.  
  631.     if (NewDirectSoundBuffer(pFileInfo) != 0)
  632.     {
  633.     MessageBox(hWnd, "Cannot create new buffer",
  634.            "Direct Sound Error", MB_OK|MB_ICONSTOP);
  635.     goto ERROR_DONE_ROUTINE;
  636.     }
  637.     
  638.     Assert(pFileInfo->pbData != NULL);
  639.  
  640.     // If we fail after this, make sure to update the list!!!
  641.     if (AddToList(&FileInfoFirst, pFileInfo) != 0)
  642.     {
  643.     MessageBox(hWnd, "Cannot add file to list",
  644.            "Out of Memory", MB_OK|MB_ICONSTOP);
  645.     goto ERROR_DONE_ROUTINE;
  646.     }
  647.  
  648.     pFileInfo->nFileName = nFileName;
  649.     CreateControl(hWnd, pFileInfo, pFileInfo->pwfx->nSamplesPerSec,
  650.           (MAXPAN_TB-MINPAN_TB)/2, MINVOL_TB );
  651.     ChangeOutputVol(pFileInfo);
  652.     ChangeOutputFreq(pFileInfo);
  653.     ChangeOutputPan(pFileInfo);
  654.     UpdateMainStatus();
  655.  
  656.     }
  657.  
  658.     goto DONE_ROUTINE;
  659.        
  660. ERROR_DONE_ROUTINE:
  661.     if (pFileInfo != NULL)
  662.     {
  663.     
  664.     ReleaseDirectSoundBuffer(pFileInfo);
  665.  
  666.     if (pFileInfo->pwfx != NULL)
  667.     {
  668.     GlobalFreePtr(pFileInfo->pwfx);
  669.         
  670.     }
  671.     if (pFileInfo->pbData != NULL)
  672.     {
  673.     GlobalFreePtr(pFileInfo->pbData);           
  674.     }
  675.  
  676.     GlobalFreePtr(pFileInfo);
  677.     pFileInfo = NULL;
  678.     }
  679.  
  680. DONE_ROUTINE:
  681.     return;
  682.  
  683. }
  684.  
  685. // =======================================================================
  686. /*  This routine will initialize a new direct sound buffer,
  687.     set the data in the buffer, 
  688.     set the rate, format, etc...
  689.  
  690.     Input:
  691.     pFileInfo   -   Pointer to file info with all
  692.     nessecary info filled, 
  693.     like pbData, cbData, etc...
  694.  
  695.     Output:
  696.     0 if successful, else the error code.
  697.  
  698. */
  699. // =======================================================================
  700. int NewDirectSoundBuffer(FILEINFO *pFileInfo)
  701. {
  702.  
  703.     DSBUFFERDESC        dsbd;
  704.     DSBCAPS         dsbc;
  705.     HRESULT         hr;
  706.     BYTE            *pbData         = NULL;
  707.     BYTE            *pbData2        = NULL;
  708.     DWORD           dwLength;
  709.     DWORD           dwLength2;
  710.  
  711.     // Set up the direct sound buffer. 
  712.     memset(&dsbd, 0, sizeof(DSBUFFERDESC));
  713.     dsbd.dwSize                 = sizeof(DSBUFFERDESC);
  714.     dsbd.dwFlags                = 0;
  715.     dsbd.dwFlags                |= DSBCAPS_STATIC;
  716.     // Use new GetCurrentPosition() accuracy (DirectX 2 feature)
  717.     dsbd.dwFlags                |= DSBCAPS_CTRLDEFAULT | DSBCAPS_GETCURRENTPOSITION2;
  718.     if (pFileInfo->fSticky)
  719.         dsbd.dwFlags |= DSBCAPS_STICKYFOCUS;
  720.     dsbd.dwBufferBytes               = pFileInfo->cbSize;
  721.     dsbd.lpwfxFormat            = pFileInfo->pwfx;
  722.     if ((hr = gpds->lpVtbl->CreateSoundBuffer(gpds,
  723.               &dsbd,
  724.               &(pFileInfo->pDSB),
  725.               NULL )) != 0)
  726.     {
  727.     goto ERROR_IN_ROUTINE;
  728.     }
  729.  
  730.     // Ok, lock the sucker down, and copy the memory to it.
  731.     if ((hr = pFileInfo->pDSB->lpVtbl->Lock(pFileInfo->pDSB,
  732.             0,
  733.             pFileInfo->cbSize,
  734.             &pbData,
  735.             &dwLength,
  736.             &pbData2,
  737.             &dwLength2,
  738.                         0L)) != 0)
  739.     {
  740.     goto ERROR_IN_ROUTINE;
  741.     }
  742.  
  743.     Assert(pbData != NULL);
  744.     memcpy(pbData, pFileInfo->pbData, pFileInfo->cbSize);
  745.  
  746.     // Ok, now unlock the buffer, we don't need it anymore.
  747.     if ((hr = pFileInfo->pDSB->lpVtbl->Unlock(pFileInfo->pDSB,
  748.                           pbData, pFileInfo->cbSize,
  749.                           NULL, 0)) != 0)
  750.     {
  751.     goto ERROR_IN_ROUTINE;
  752.     }
  753.  
  754.     pbData = NULL;
  755.  
  756.     if ((hr = pFileInfo->pDSB->lpVtbl->SetVolume(pFileInfo->pDSB,
  757.         MAXVOL_VAL)) != 0)
  758.     {
  759.     goto ERROR_IN_ROUTINE;
  760.     }
  761.  
  762.     if ((hr = pFileInfo->pDSB->lpVtbl->SetPan(pFileInfo->pDSB,
  763.         MIDPAN_VAL)) != 0)
  764.     {
  765.     goto ERROR_IN_ROUTINE;
  766.     }
  767.  
  768.     dsbc.dwSize = sizeof(dsbc);
  769.     if (hr = IDirectSoundBuffer_GetCaps(pFileInfo->pDSB, &dsbc))
  770.     {
  771.     goto ERROR_IN_ROUTINE;
  772.     }
  773.  
  774.     if (dsbc.dwFlags & DSBCAPS_LOCHARDWARE) {
  775.     pFileInfo->fHardware = TRUE;
  776.     } else {
  777.     pFileInfo->fHardware = FALSE;
  778.     }
  779.  
  780.     goto DONE_ROUTINE;
  781.  
  782. ERROR_IN_ROUTINE:
  783.     if (pbData != NULL)
  784.     {
  785.     hr = pFileInfo->pDSB->lpVtbl->Unlock(pFileInfo->pDSB, pbData,
  786.                         pFileInfo->cbSize, NULL, 0);
  787.     pbData = NULL;
  788.     }
  789.  
  790.     if (pFileInfo->pDSB != NULL)
  791.     {
  792.     pFileInfo->pDSB->lpVtbl->Release(pFileInfo->pDSB);
  793.     pFileInfo->pDSB = NULL;
  794.     }
  795.     
  796. DONE_ROUTINE:
  797.  
  798.     return(hr); 
  799.  
  800. }
  801.  
  802. // =======================================================================
  803. /*  This routine will release a direct sound buffer,
  804.     freeing up memory, resources, 
  805.     whatever.
  806.  
  807.     Input:
  808.     pFileInfo   -   Pointer to the file info,
  809.         with the proper stuff set.
  810.  
  811.     Output: 
  812.     0 if successful, else the error code.
  813.  
  814. */
  815. // =======================================================================
  816. int ReleaseDirectSoundBuffer( FILEINFO *pFileInfo )
  817. {
  818.  
  819.     if (pFileInfo->pDSB != NULL)
  820.     {
  821.     pFileInfo->pDSB->lpVtbl->Release(pFileInfo->pDSB);
  822.     pFileInfo->pDSB = NULL; 
  823.     }
  824.  
  825.     return(0);
  826.  
  827. }
  828.  
  829. // =======================================================================
  830. /*  This routine will find the next x and y coordinates to
  831.     write the control to.
  832.     The rgfcoxAvail is an array of booleans.
  833.     If false, then the index can be 
  834.     used as an x coordinate.
  835.  
  836.     Input:
  837.     pFileInfoHead - Header of the linked list.
  838.     pcox, pcoy    - Filled upon return with next
  839.         coordinates to use.
  840.     
  841.     Output:
  842.     Only pcox and pcoy change.
  843.     
  844. */
  845. // =======================================================================    
  846. void GetNextControlCoords(                     
  847.             FILEINFO    *pFileInfoHead, 
  848.             int         *pcox, 
  849.             int         *pcoy
  850.             )
  851. {
  852.     UINT            cT;
  853.  
  854.     for (cT=0; cT<MAXCONTROLS; cT++)
  855.     {
  856.     if (rgfcoxAvail[cT] == FALSE)
  857.     {
  858.     rgfcoxAvail[cT] = TRUE;
  859.     break;
  860.     }
  861.         
  862.     }
  863.  
  864.     if (cT == MAXCONTROLS)
  865.     {
  866.     Assert(FALSE);
  867.     // Couldn't find a place to put control, shouldn't happen though.
  868.     cT = 666;       // Well, at least put it off screen.
  869.     }
  870.  
  871.     *pcox = cT*DX_CONTROLSPACING+COX_STARTCONTROL;      //Offsetting the text from the border
  872.     *pcoy = COY_STARTCONTROL;
  873.     
  874.  
  875. }
  876.  
  877. // =======================================================================
  878. /*  CreateControl
  879.  
  880.     This will create the control used for the window, actually it is a
  881.     bundle of controls put together.  I was thinking of a good way to
  882.     figure out id codes for the controls but found no good way except a
  883.     "funny" way...I'm going to use the x coordinate of the control as the
  884.     id for the first control, then id+1 for the second control.  Since
  885.     all the controls have different x coordinates, this is fine, as long
  886.     as the # of windows in the control is not more than the spacing of
  887.     the controls.
  888.  
  889.     Input:
  890.     hWnd                -   Parent Window.
  891.     pFileInfo           -   Pointer to FileInfo structure with the cox and coy filled.
  892.     dwFreq, dwPan, dwVol-   Default track bar values.
  893.  
  894.     Output:
  895.     0 if successful, else the error code.
  896.  
  897. */
  898. // =======================================================================
  899. int CreateControl(HWND hWnd, FILEINFO *pFileInfo, DWORD dwFreq,DWORD dwPan, DWORD dwVol)
  900. {
  901.     int        cox, coy;
  902.     int     coxOld, coyOld;
  903.     int     nError = 0;
  904.     DWORD    idBase;
  905.     SIZE    Size;       
  906.     HDC     hDC = NULL;
  907.     DWORD dwMinFreq, dwMaxFreq;
  908.  
  909.     /* Figure out the values of dwPan and dwVol that the track bars like */
  910.  
  911.     idBase = pFileInfo->cox;
  912.     Assert(pFileInfo != NULL);
  913.     cox = pFileInfo->cox+DX_TEXTSPACING;
  914.     coy = pFileInfo->coy+DY_TEXTSPACING;        //We may have to shift this
  915.  
  916.     coxOld = cox;
  917.     coyOld = coy;
  918.     coy -= 8;                       //We must adjust to fit the text in the border
  919.  
  920.     if ((hDC = GetDC(hWnd)) == NULL)
  921.     {
  922.     nError = -1;
  923.     goto DONE_ROUTINE;
  924.     }
  925.  
  926.  
  927.     if (!GetTextExtentPoint32(hDC, pFileInfo->szFileName+pFileInfo->nFileName, strlen(pFileInfo->szFileName+pFileInfo->nFileName), &Size))
  928.     {
  929.     nError = -1;
  930.     goto DONE_ROUTINE;
  931.     }
  932.  
  933.     //Creates the Filename window
  934.     if ((pFileInfo->hWndFileName_TXT = CreateWindow(
  935.     "STATIC", 
  936.     pFileInfo->szFileName+pFileInfo->nFileName, 
  937.     WS_CHILD | WS_VISIBLE | SS_LEFTNOWORDWRAP, 
  938.     cox,
  939.     coy,                                                                    
  940.     DX_FILENAME_TXT,                                                                        
  941.     Size.cy,              
  942.     hWnd, 
  943.     (HMENU)0, 
  944.     hInst, 
  945.     NULL)) == NULL)
  946.     {
  947.     nError = -1;
  948.     goto DONE_ROUTINE;
  949.     }   
  950.                                                                         //Create line under Filename            
  951.     cox += DX_LOOPEDSPACING;
  952.     coy += Size.cy + DY_TEXTSPACING + DY_LOOPEDSPACING;
  953.  
  954.     if ((pFileInfo->hWndFileName_EDGE = CreateWindow(
  955.     "STATIC", 
  956.     "", 
  957.     WS_CHILD | WS_VISIBLE | SS_ETCHEDHORZ, 
  958.     cox,
  959.     coy - (DY_LOOPEDSPACING+DY_TEXTSPACING)/2,
  960.     DX_LINEEDGE, 
  961.     DY_LINEEDGE,                
  962.     hWnd, 
  963.     (HMENU)0, 
  964.     hInst, 
  965.     NULL)) == NULL)
  966.     {
  967.     nError = -1;
  968.     goto DONE_ROUTINE;
  969.     }   
  970.  
  971.     // Now create status if required.
  972.     
  973.     #ifdef SHOWSTATUS   
  974.  
  975.     if (!GetTextExtentPoint32(hDC, szPlaying, strlen(szPlaying), &Size))
  976.     {
  977.     nError = -1;
  978.     goto DONE_ROUTINE;
  979.     }
  980.  
  981.  
  982.     //Creates Status Window
  983.     if ((pFileInfo->hWndStatus_TXT = CreateWindow(
  984.     "STATIC", 
  985.     "",
  986.     WS_CHILD | WS_VISIBLE | SS_LEFTNOWORDWRAP, 
  987.     cox,
  988.     coy,
  989.     DX_STATUS_TXT, 
  990.     Size.cy, // + DY_TEXTSPACING,               
  991.     hWnd, 
  992.     (HMENU)0, 
  993.     hInst, 
  994.     NULL)) == NULL)
  995.     {
  996.     nError = -1;
  997.     goto DONE_ROUTINE;
  998.     }   
  999.  
  1000.     cox += DX_LOOPEDSPACING;
  1001.     coy += Size.cy + DY_TEXTSPACING + DY_LOOPEDSPACING;
  1002.  
  1003.     //Create line under Status
  1004.     if ((pFileInfo->hWndStatus_EDGE = CreateWindow(
  1005.     "STATIC", 
  1006.     "", 
  1007.     WS_CHILD | WS_VISIBLE | SS_ETCHEDHORZ, 
  1008.     cox,
  1009.     coy - (DY_LOOPEDSPACING+DY_TEXTSPACING)/2,
  1010.     DX_LINEEDGE, 
  1011.     DY_LINEEDGE,                
  1012.     hWnd, 
  1013.     (HMENU)0, 
  1014.     hInst, 
  1015.     NULL)) == NULL)
  1016.     {
  1017.     nError = -1;
  1018.     goto DONE_ROUTINE;
  1019.     }
  1020.  
  1021.     //Creates PlayPos Window
  1022.     if ((pFileInfo->hWndPlayPosition_TXT = CreateWindow(
  1023.     "STATIC", "",
  1024.     WS_CHILD | WS_VISIBLE | SS_LEFTNOWORDWRAP,
  1025.     cox, 
  1026.     coy,
  1027.     DX_STATUS_TXT, 
  1028.     Size.cy,
  1029.     hWnd, 
  1030.     NULL, 
  1031.     hInst, 
  1032.     NULL)) == NULL)
  1033.     {
  1034.     nError = -1;
  1035.     goto DONE_ROUTINE;
  1036.     }
  1037.  
  1038.     cox += DX_LOOPEDSPACING;
  1039.     coy += Size.cy + DY_TEXTSPACING + DY_LOOPEDSPACING; //Create line under PlayPos
  1040.     
  1041.     if ((pFileInfo->hWndPlayPosition_EDGE = CreateWindow(
  1042.     "STATIC", "", 
  1043.     WS_CHILD | WS_VISIBLE | SS_ETCHEDHORZ, 
  1044.     cox, 
  1045.     coy - (DY_LOOPEDSPACING+DY_TEXTSPACING)/2,
  1046.     DX_LINEEDGE, 
  1047.     DY_LINEEDGE,               
  1048.     hWnd, 
  1049.     NULL, 
  1050.     hInst, 
  1051.     NULL)) == NULL)
  1052.     {
  1053.     nError = -1;
  1054.     goto DONE_ROUTINE;
  1055.     }
  1056.     
  1057.     //Creates WritePos Window
  1058.     if ((pFileInfo->hWndWritePosition_TXT = CreateWindow(
  1059.     "STATIC", "",
  1060.     WS_CHILD | WS_VISIBLE | SS_LEFTNOWORDWRAP,
  1061.     cox, 
  1062.     coy,
  1063.     DX_STATUS_TXT, 
  1064.     Size.cy,
  1065.     hWnd, 
  1066.     NULL, 
  1067.     hInst, 
  1068.     NULL)) == NULL)
  1069.     {
  1070.     nError = -1;
  1071.     goto DONE_ROUTINE;
  1072.     }
  1073.  
  1074.     cox += DX_LOOPEDSPACING;
  1075.     coy += Size.cy + DY_TEXTSPACING + DY_LOOPEDSPACING;
  1076.     
  1077.     //Create line under WritePos
  1078.     if ((pFileInfo->hWndWritePosition_EDGE = CreateWindow(
  1079.     "STATIC", "", 
  1080.     WS_CHILD | WS_VISIBLE | SS_ETCHEDHORZ, 
  1081.     cox, 
  1082.     coy - (DY_LOOPEDSPACING+DY_TEXTSPACING)/2,
  1083.     DX_LINEEDGE,
  1084.     DY_LINEEDGE,               
  1085.     hWnd,
  1086.     NULL, 
  1087.     hInst, 
  1088.     NULL)) == NULL)
  1089.     {
  1090.     nError = -1;
  1091.     goto DONE_ROUTINE;
  1092.     }
  1093.     
  1094.     #endif      
  1095.     
  1096.     //Set up the Freq Text
  1097.     if (!GetTextExtentPoint32(hDC, szFreq, strlen(szFreq), &Size))
  1098.     {
  1099.     nError = -1;
  1100.     goto DONE_ROUTINE;
  1101.     }
  1102.  
  1103.     // Make the frequency text there.
  1104.     if ((pFileInfo->hWndFreq_TXT = CreateWindow(
  1105.     "STATIC", 
  1106.     szFreq, 
  1107.     WS_CHILD | WS_VISIBLE | SS_LEFTNOWORDWRAP, 
  1108.     cox,
  1109.     coy,
  1110.     DX_FREQ_TXT, 
  1111.     Size.cy,                
  1112.     hWnd, 
  1113.     (HMENU)0, 
  1114.     hInst, 
  1115.     NULL)) == NULL)
  1116.     {
  1117.     nError = -1;
  1118.     goto DONE_ROUTINE;
  1119.     }   
  1120.  
  1121.     coy += Size.cy;
  1122.  
  1123.     // Make the frequency trackbar.
  1124.     if ((pFileInfo->hWndFreq_TB = CreateWindow(
  1125.     TRACKBAR_CLASS, 
  1126.     "", 
  1127.     WS_CHILD | WS_VISIBLE | TBS_HORZ | TBS_BOTH, 
  1128.     cox,
  1129.     coy,
  1130.     DX_FREQ_TB, 
  1131.     DY_FREQ_TB,             
  1132.     hWnd, 
  1133.     (HMENU)(idBase+idFreqTB), 
  1134.     hInst, 
  1135.     NULL)) == NULL)
  1136.     {
  1137.     nError = -1;
  1138.     goto DONE_ROUTINE;
  1139.     }   
  1140.  
  1141.     // get the min and max range that the sound card supports.
  1142.     // If the buffer is in hardware query the card, else use
  1143.     // our ifdef'd values.
  1144.     if (pFileInfo->fHardware)
  1145.     {
  1146.         DSCAPS dsc;
  1147.         memset(&dsc, 0, sizeof(DSCAPS));
  1148.         dsc.dwSize = sizeof(DSCAPS);
  1149.         nError = IDirectSound_GetCaps(gpds, &dsc);
  1150.         Assert(nError == DS_OK);
  1151.         dwMinFreq = dsc.dwMinSecondarySampleRate;
  1152.         dwMaxFreq = dsc.dwMaxSecondarySampleRate;
  1153.     }
  1154.     else
  1155.     {    
  1156.         dwMinFreq = DSBFREQUENCY_MIN;    
  1157.         dwMaxFreq = DSBFREQUENCY_MAX;
  1158.     }
  1159.  
  1160.     SendMessage(pFileInfo->hWndFreq_TB, TBM_SETRANGEMIN, FALSE, dwMinFreq / FREQFACTOR );
  1161.     SendMessage(pFileInfo->hWndFreq_TB, TBM_SETRANGEMAX, FALSE, dwMaxFreq / FREQFACTOR );
  1162.     
  1163.     SendMessage(pFileInfo->hWndFreq_TB, TBM_SETPAGESIZE, 0, FREQPAGE );
  1164.     SendMessage(pFileInfo->hWndFreq_TB, TBM_SETPOS, TRUE, (dwFreq + FREQADD)/FREQFACTOR);
  1165.     pFileInfo->dwFreq = dwFreq;
  1166.  
  1167.  
  1168.     coy += DY_FREQ_TB+DY_PANSPACING;    
  1169.  
  1170.     if ((pFileInfo->hWndFreq_EDGE = CreateWindow(
  1171.     "STATIC", 
  1172.     "", 
  1173.     WS_CHILD | WS_VISIBLE | SS_ETCHEDHORZ, 
  1174.     cox,
  1175.     coy - (DY_PANSPACING+DY_TEXTSPACING)/2,
  1176.     DX_LINEEDGE, 
  1177.     DY_LINEEDGE,                
  1178.     hWnd, 
  1179.     (HMENU)0, 
  1180.     hInst, 
  1181.     NULL)) == NULL)
  1182.     {
  1183.     nError = -1;
  1184.     goto DONE_ROUTINE;
  1185.     }   
  1186.  
  1187.     //Adjusts the relative position of the Text    
  1188.     coy -= (((DY_PANSPACING+DY_TEXTSPACING)/2)-((DY_LOOPEDSPACING+DY_TEXTSPACING)/2));
  1189.  
  1190.     if (!GetTextExtentPoint32(hDC, szPan, strlen(szPan), &Size))
  1191.     {
  1192.     nError = -1;
  1193.     goto DONE_ROUTINE;
  1194.     }
  1195.  
  1196.  
  1197.     // Make the pan text there.
  1198.     if ((pFileInfo->hWndPan_TXT = CreateWindow(
  1199.     "STATIC", 
  1200.     szPan, 
  1201.     WS_CHILD | WS_VISIBLE | SS_LEFTNOWORDWRAP, 
  1202.     cox,
  1203.     coy,
  1204.     DX_PAN_TXT, 
  1205.     Size.cy,                
  1206.     hWnd, 
  1207.     (HMENU)0, 
  1208.     hInst, 
  1209.     NULL)) == NULL)
  1210.     {
  1211.     nError = -1;
  1212.     goto DONE_ROUTINE;
  1213.     }   
  1214.  
  1215.     coy += Size.cy;
  1216.  
  1217.     // Make the pan trackbar.
  1218.     if ((pFileInfo->hWndPan_TB = CreateWindow(
  1219.     TRACKBAR_CLASS, 
  1220.     "", 
  1221.     WS_CHILD | WS_VISIBLE | TBS_HORZ | TBS_BOTH, 
  1222.     cox,
  1223.     coy,
  1224.     DX_PAN_TB, 
  1225.     DY_PAN_TB,              
  1226.     hWnd, 
  1227.     (HMENU)(idBase+idPanTB), 
  1228.     hInst, 
  1229.     NULL)) == NULL)
  1230.     {
  1231.     nError = -1;
  1232.     goto DONE_ROUTINE;
  1233.     }   
  1234.  
  1235.     SendMessage(pFileInfo->hWndPan_TB, TBM_SETRANGE, FALSE, MAKELONG(MINPAN_TB, MAXPAN_TB)); 
  1236.     SendMessage(pFileInfo->hWndPan_TB, TBM_SETPOS, TRUE, dwPan);
  1237.     SendMessage(pFileInfo->hWndPan_TB, TBM_SETPAGESIZE, 0, PANPAGE );
  1238.     pFileInfo->dwPan = dwPan;
  1239.  
  1240.  
  1241.     coy += DY_PAN_TB + DY_VOLSPACING;
  1242.  
  1243.     if ((pFileInfo->hWndPan_EDGE = CreateWindow(
  1244.     "STATIC", 
  1245.     "", 
  1246.     WS_CHILD | WS_VISIBLE | SS_ETCHEDHORZ, 
  1247.     cox,
  1248.     coy - (DY_VOLSPACING+DY_TEXTSPACING)/2,
  1249.     DX_LINEEDGE, 
  1250.     DY_LINEEDGE,                
  1251.     hWnd, 
  1252.     (HMENU)0, 
  1253.     hInst, 
  1254.     NULL)) == NULL)
  1255.     {
  1256.     nError = -1;
  1257.     goto DONE_ROUTINE;
  1258.     }   
  1259.  
  1260.     //Adjusts the relative position of the Text
  1261.     coy -= (((DY_PANSPACING+DY_TEXTSPACING)/2)-((DY_LOOPEDSPACING+DY_TEXTSPACING)/2));
  1262.  
  1263.     if (!GetTextExtentPoint32(hDC, szVolume, strlen(szVolume), &Size))
  1264.     {
  1265.     nError = -1;
  1266.     goto DONE_ROUTINE;
  1267.     }
  1268.  
  1269.     // Make the volume text there.
  1270.     if ((pFileInfo->hWndVol_TXT = CreateWindow(
  1271.     "STATIC", 
  1272.     szVolume, 
  1273.     WS_CHILD | WS_VISIBLE | SS_LEFTNOWORDWRAP, 
  1274.     cox,
  1275.     coy,
  1276.     DX_VOL_TXT, 
  1277.     Size.cy,                
  1278.     hWnd, 
  1279.     (HMENU)idBase, 
  1280.     hInst, 
  1281.     NULL)) == NULL)
  1282.     {
  1283.     nError = -1;
  1284.     goto DONE_ROUTINE;
  1285.     }   
  1286.  
  1287.     coy += Size.cy;
  1288.  
  1289.     // Make the volume trackbars.
  1290.     // Create main volume bar.
  1291.     if ((pFileInfo->hWndVolM_TB = CreateWindow(
  1292.     TRACKBAR_CLASS, 
  1293.     "", 
  1294.     WS_CHILD | WS_VISIBLE | TBS_VERT | TBS_BOTH, 
  1295.     cox,
  1296.     coy,
  1297.     DX_VOL_TB, 
  1298.     DY_VOL_TB,              
  1299.     hWnd, 
  1300.     (HMENU)(idBase+idVolMTB), 
  1301.     hInst, 
  1302.     NULL)) == NULL)
  1303.     {
  1304.     nError = -1;
  1305.     goto DONE_ROUTINE;
  1306.     }   
  1307.  
  1308.     SendMessage(pFileInfo->hWndVolM_TB, TBM_SETRANGE, FALSE, MAKELONG(MINVOL_TB, MAXVOL_TB)); 
  1309.     SendMessage(pFileInfo->hWndVolM_TB, TBM_SETPOS, TRUE, dwVol);
  1310.     pFileInfo->dwVol = MAXVOL_TB - dwVol;
  1311.  
  1312.  
  1313.  
  1314.     // Now the left volume.
  1315.     if ((pFileInfo->hWndVolL_TB = CreateWindow(
  1316.     TRACKBAR_CLASS, 
  1317.     "", 
  1318.     WS_CHILD | WS_VISIBLE |WS_DISABLED| TBS_VERT | TBS_BOTH, 
  1319.     cox+DX_VOL_TB+DX_VOLSPACING_TB,
  1320.     coy,
  1321.     DX_VOL_TB, 
  1322.     DY_VOL_TB,              
  1323.     hWnd, 
  1324.     (HMENU)(idBase+idVolLTB), 
  1325.     hInst, 
  1326.     NULL)) == NULL)
  1327.     {
  1328.     nError = -1;
  1329.     goto DONE_ROUTINE;
  1330.     }   
  1331.  
  1332.     SendMessage(pFileInfo->hWndVolL_TB, TBM_SETRANGE, FALSE, MAKELONG(MINVOL_TB, MAXVOL_TB)); 
  1333.     SendMessage(pFileInfo->hWndVolL_TB, TBM_SETPOS, TRUE, MAXVOL_TB);
  1334.  
  1335.     if ((pFileInfo->hWndVolL_TXT = CreateWindow(
  1336.     "STATIC", 
  1337.     "L", 
  1338.     WS_CHILD | WS_VISIBLE | SS_LEFTNOWORDWRAP, 
  1339.     cox+DX_VOL_TB*3/2+DX_VOLSPACING_TB/2,
  1340.     coy+DY_VOL_TB+DY_VOLSPACINGY,
  1341.     DX_VOLUMECHAR, 
  1342.     Size.cy,                
  1343.     hWnd, 
  1344.     (HMENU)0, 
  1345.     hInst, 
  1346.     NULL)) == NULL)
  1347.     {
  1348.     nError = -1;
  1349.     goto DONE_ROUTINE;
  1350.     }   
  1351.  
  1352.  
  1353.     // And right volume.
  1354.     if ((pFileInfo->hWndVolR_TB = CreateWindow(
  1355.     TRACKBAR_CLASS, 
  1356.     "", 
  1357.     WS_CHILD | WS_VISIBLE | WS_DISABLED | TBS_VERT | TBS_BOTH, 
  1358.     cox+DX_VOL_TB*2+DX_VOLSPACING_TB*2,
  1359.     coy,
  1360.     DX_VOL_TB, 
  1361.     DY_VOL_TB,              
  1362.     hWnd, 
  1363.     (HMENU)(idBase+idVolRTB), 
  1364.     hInst, 
  1365.     NULL)) == NULL)
  1366.     {
  1367.     nError = -1;
  1368.     goto DONE_ROUTINE;
  1369.     }   
  1370.  
  1371.     SendMessage(pFileInfo->hWndVolR_TB,
  1372.         TBM_SETRANGE, FALSE, MAKELONG(MINVOL_TB, MAXVOL_TB)); 
  1373.     SendMessage(pFileInfo->hWndVolR_TB,
  1374.         TBM_SETPOS, TRUE, MAXVOL_TB);
  1375.  
  1376.     if ((pFileInfo->hWndVolR_TXT = CreateWindow(
  1377.     "STATIC", 
  1378.     "R", 
  1379.     WS_CHILD | WS_VISIBLE | SS_LEFTNOWORDWRAP, 
  1380.     cox+DX_VOL_TB*5/2+DX_VOLSPACING_TB/2+2,
  1381.                 // +2 to look nice.
  1382.     coy+DY_VOL_TB+DY_VOLSPACINGY,
  1383.     DX_VOLUMECHAR, 
  1384.     Size.cy,                
  1385.     hWnd, 
  1386.     (HMENU)0, 
  1387.     hInst, 
  1388.     NULL)) == NULL)
  1389.     {
  1390.     nError = -1;
  1391.     goto DONE_ROUTINE;
  1392.     }   
  1393.  
  1394.  
  1395.     coy += DY_VOL_TB + DY_BEFOREFIRSTBUTTON;    //Line under L & R
  1396.  
  1397.     if ((pFileInfo->hWndVol_EDGE = CreateWindow(
  1398.     "STATIC", 
  1399.     "", 
  1400.     WS_CHILD | WS_VISIBLE | SS_ETCHEDHORZ, 
  1401.     cox,
  1402.     coy - (DY_BEFOREFIRSTBUTTON)/2,
  1403.     DX_LINEEDGE, 
  1404.     DY_LINEEDGE,                
  1405.     hWnd, 
  1406.     (HMENU)0, 
  1407.     hInst, 
  1408.     NULL)) == NULL)
  1409.     {
  1410.     nError = -1;
  1411.     goto DONE_ROUTINE;
  1412.     }   
  1413.  
  1414.  
  1415.  
  1416.     if (!GetTextExtentPoint32(hDC, szPlay, strlen(szPlay), &Size))
  1417.     {
  1418.     nError = -1;
  1419.     goto DONE_ROUTINE;
  1420.     }
  1421.  
  1422.  
  1423.     //Create Play Button
  1424.     if ((pFileInfo->hWndPlay_BN = CreateWindow(
  1425.     "BUTTON", 
  1426.     szPlay, 
  1427.     WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 
  1428.     cox,
  1429.     coy,
  1430.     DX_BUTTONSPACING, 
  1431.     Size.cy + DY_BUTTONSPACING,             
  1432.     hWnd, 
  1433.     (HMENU)(idBase+idPlayBN), 
  1434.     hInst, 
  1435.     NULL)) == NULL)
  1436.     {
  1437.     nError = -1;
  1438.     goto DONE_ROUTINE;
  1439.     }       
  1440.  
  1441.     //coy += Size.cy + DY_BUTTONSPACING + DY_BETWEENBUTTONS;
  1442.     
  1443.     if (!GetTextExtentPoint32(hDC, szPlay, strlen(szPlay), &Size))
  1444.     {
  1445.     nError = -1;
  1446.     goto DONE_ROUTINE;
  1447.     }
  1448.      
  1449.     //Make Remove button
  1450.     if ((pFileInfo->hWndRemove_BN = CreateWindow(
  1451.     "BUTTON", 
  1452.     szRemove, 
  1453.     WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 
  1454.     cox + DX_BUTTONSPACING + DY_BETWEENBUTTONS,
  1455.     coy,
  1456.     DX_BUTTONSPACING, 
  1457.     Size.cy + DY_BUTTONSPACING,             
  1458.     hWnd, 
  1459.     (HMENU)(idBase+idRemoveBN), 
  1460.     hInst, 
  1461.     NULL)) == NULL)
  1462.     {
  1463.     nError = -1;
  1464.     goto DONE_ROUTINE;
  1465.     }       
  1466.  
  1467.     coy += Size.cy + DY_BUTTONSPACING+ DY_BETWEENBUTTONS;
  1468.  
  1469.  
  1470.     //Set up Looped Checkbox 
  1471.     if (!GetTextExtentPoint32(hDC, szLooped, strlen(szLooped), &Size))
  1472.     {
  1473.     nError = -1;
  1474.     goto DONE_ROUTINE;
  1475.     }
  1476.  
  1477.     //Create Looped Checkbox window
  1478.     if ((pFileInfo->hWndLooped_BN = CreateWindow(
  1479.     "BUTTON", 
  1480.     szLooped, 
  1481.     WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX, 
  1482.     cox,
  1483.     coy,
  1484.     DX_LOOPED_TXT, 
  1485.     Size.cy + DY_TEXTSPACING -2,               
  1486.     hWnd, 
  1487.     (HMENU)(idBase+idLoopedBN), 
  1488.     hInst, 
  1489.     NULL)) == NULL)
  1490.     {
  1491.     nError = -1;
  1492.     goto DONE_ROUTINE;
  1493.     }       
  1494.       
  1495.  
  1496.     // Don't need the between buttons spacing
  1497.     //  because there are no more controls.
  1498.     coy += Size.cy;// + DY_BUTTONSPACING; //+ DY_BETWEENBUTTONS;
  1499.  
  1500.     if ((pFileInfo->hWndWhole_EDGE = CreateWindow(
  1501.     "STATIC", 
  1502.     "", 
  1503.     WS_CHILD | WS_VISIBLE | SS_ETCHEDFRAME, 
  1504.     coxOld-DX_FRAMEEDGE,
  1505.     coyOld-DY_FRAMEEDGE,
  1506.     DX_CONTROLSPACING-DX_FRAMEEDGEINNER, 
  1507.     coy - coyOld + DY_FRAMEEDGE*2,              
  1508.     hWnd, 
  1509.     (HMENU)0, 
  1510.     hInst, 
  1511.     NULL)) == NULL)
  1512.     {
  1513.     nError = -1;
  1514.     goto DONE_ROUTINE;
  1515.     }   
  1516.  
  1517.     
  1518.     SetAllText(pFileInfo);
  1519.     UpdateLRVolume(pFileInfo);
  1520.  
  1521.     
  1522. DONE_ROUTINE:   
  1523.     if (hDC != NULL)
  1524.     {
  1525.     if (ReleaseDC(hWnd, hDC) == 0)
  1526.     {
  1527.     nError = -1;
  1528.     goto DONE_ROUTINE;
  1529.     }
  1530.     }
  1531.  
  1532.     return(nError);
  1533.  
  1534. }
  1535.  
  1536. // =======================================================================
  1537. /*  This will add to the linked list of FileInfo's.
  1538.     The FileInfo's keep track of the
  1539.     files loaded, and this is done in a linked list format
  1540.  
  1541.     Input:
  1542.     pFileInfoHead   -   Top of linked list.
  1543.     pFileInfo   -   Pointer to entry to add.
  1544.  
  1545.     Output:
  1546.     0 if successful, else the error code.
  1547.  
  1548. */      
  1549. // =======================================================================
  1550. int AddToList(FILEINFO *pFileInfoHead, FILEINFO *pFileInfo)
  1551. {
  1552.     pFileInfo->pNext = NULL;    
  1553.     pFileInfo->fPlaying = FALSE;
  1554.  
  1555.     while (pFileInfoHead->pNext != NULL)
  1556.     {
  1557.     pFileInfoHead = pFileInfoHead->pNext;
  1558.     }
  1559.  
  1560.     pFileInfoHead->pNext = pFileInfo;
  1561.  
  1562.     return(0);
  1563.  
  1564. }
  1565.  
  1566. // =======================================================================
  1567. /*  This routine will get the number of controls in the window.
  1568.     Can be used to determine new size of window.
  1569.  
  1570.     Input:
  1571.     pFileInfoHead           -   Header of linked list.
  1572.  
  1573.     Output:
  1574.     # of controls.
  1575. */
  1576. // =======================================================================
  1577. int GetNumControls( FILEINFO *pFileInfoHead )
  1578. {
  1579.  
  1580.     int cT  = 0;
  1581.  
  1582.     while (pFileInfoHead->pNext != NULL)
  1583.     {
  1584.     pFileInfoHead = pFileInfoHead->pNext;
  1585.     cT++;
  1586.     }
  1587.  
  1588.     return(cT);
  1589.  
  1590. }
  1591.  
  1592. // =======================================================================
  1593. /*  This routine will free the whole linked list in pFileInfoFirst,
  1594.     including all the
  1595.     memory used by the wave file, waveformatex structure, etc.
  1596. */
  1597. // =======================================================================
  1598. int FreeAllList(HWND hWnd, FILEINFO *pFileInfoFirst)
  1599. {
  1600.  
  1601.     FILEINFO        *pFileInfo, *pFileNext;
  1602.     UINT        cT;
  1603.  
  1604.     Assert(pFileInfoFirst != NULL);
  1605.     pFileInfo = pFileInfoFirst->pNext;
  1606.  
  1607.     while (pFileInfo != NULL)
  1608.     {
  1609.     ReleaseDirectSoundBuffer(pFileInfo);
  1610.     GlobalFreePtr(pFileInfo->pwfx);
  1611.     GlobalFreePtr(pFileInfo->pbData);
  1612.     pFileNext = pFileInfo->pNext;
  1613.     GlobalFreePtr(pFileInfo);
  1614.     pFileInfo = pFileNext;
  1615.     }
  1616.  
  1617.     for (cT=0; cT<MAXCONTROLS; cT++)
  1618.     rgfcoxAvail[cT] = FALSE;
  1619.  
  1620.  
  1621.  
  1622.     return(0);          
  1623.  
  1624.  
  1625. }
  1626.  
  1627. // =======================================================================
  1628. /*  This routine will remove an entry from the list, i.e. will remove
  1629.     pFileInfo and all its allocated memory from the list pointed by the header
  1630.     by pFileInfoHead
  1631.  
  1632.     Input:
  1633.     pFileInfo               -   Pointer to entry to remove.
  1634.     pFileInfoHead           -   Head, first entry.
  1635.  
  1636.     Output:
  1637.     0 if successful, else the error.
  1638.  
  1639. */
  1640. // =======================================================================
  1641. int RemoveFromList(FILEINFO *pFileInfo, FILEINFO *pFileInfoHead)
  1642. {
  1643.  
  1644.     FILEINFO        *pFileNext;
  1645.  
  1646.     Assert(pFileInfoHead != NULL);
  1647.  
  1648.     // This used to be pFileInfoHead != NULL
  1649.     while (pFileInfoHead->pNext != NULL)
  1650.     {
  1651.     if (pFileInfoHead->pNext == pFileInfo)
  1652.         {
  1653.         Assert(pFileInfo->cox/DX_CONTROLSPACING < MAXCONTROLS);
  1654.         rgfcoxAvail[pFileInfo->cox/DX_CONTROLSPACING] = FALSE;
  1655.        
  1656.         DestroyWindow(pFileInfo->hWndFileName_TXT); 
  1657.         DestroyWindow(pFileInfo->hWndFreq_TB);      
  1658.         DestroyWindow(pFileInfo->hWndFreq_TXT);     
  1659.         DestroyWindow(pFileInfo->hWndPan_TB);           
  1660.         DestroyWindow(pFileInfo->hWndPan_TXT);      
  1661.         DestroyWindow(pFileInfo->hWndVol_TXT);      
  1662.         DestroyWindow(pFileInfo->hWndVolL_TB);      
  1663.         DestroyWindow(pFileInfo->hWndVolR_TB);      
  1664.         DestroyWindow(pFileInfo->hWndVolM_TB);      
  1665.         DestroyWindow(pFileInfo->hWndLooped_BN);        
  1666.         DestroyWindow(pFileInfo->hWndPlay_BN);      
  1667.         DestroyWindow(pFileInfo->hWndRemove_BN);
  1668.         DestroyWindow(pFileInfo->hWndFileName_EDGE);
  1669.         DestroyWindow(pFileInfo->hWndLooped_EDGE);  
  1670.         DestroyWindow(pFileInfo->hWndFreq_EDGE);        
  1671.         DestroyWindow(pFileInfo->hWndPan_EDGE);     
  1672.         DestroyWindow(pFileInfo->hWndVol_EDGE);     
  1673.         DestroyWindow(pFileInfo->hWndWhole_EDGE);       
  1674.         DestroyWindow(pFileInfo->hWndVolL_TXT);     
  1675.         DestroyWindow(pFileInfo->hWndVolR_TXT);     
  1676.         #ifdef SHOWSTATUS
  1677.         DestroyWindow(pFileInfo->hWndStatus_TXT);
  1678.         DestroyWindow(pFileInfo->hWndStatus_EDGE);
  1679.         DestroyWindow(pFileInfo->hWndPlayPosition_TXT);
  1680.         DestroyWindow(pFileInfo->hWndPlayPosition_EDGE);
  1681.         DestroyWindow(pFileInfo->hWndWritePosition_TXT);
  1682.         DestroyWindow(pFileInfo->hWndWritePosition_EDGE);
  1683.         #endif
  1684.  
  1685.  
  1686.  
  1687.  
  1688.         GlobalFree(pFileInfoHead->pNext->pwfx);
  1689.         GlobalFree(pFileInfoHead->pNext->pbData);
  1690.         pFileNext = pFileInfoHead->pNext->pNext;
  1691.         GlobalFreePtr(pFileInfoHead->pNext);
  1692.         pFileInfoHead->pNext = pFileNext;                                                         
  1693.         break;
  1694.         }
  1695.     pFileInfoHead = pFileInfoHead->pNext;
  1696.     }
  1697.  
  1698.     return(0);
  1699. }
  1700.  
  1701. // =======================================================================
  1702. /*  This will pop up the open file dialog and allow the user to pick one file. 
  1703.     
  1704.     Input:  
  1705.     hWnd            -   Handle of parent window.
  1706.     pszFileName         -   String to store filename in, must be at least MAX_PATH long.
  1707.  
  1708.  
  1709.     Output:
  1710.     TRUE if a file was  picked successfully, else FALSE (user didn't pick a file)
  1711.  
  1712.  */
  1713. // =======================================================================
  1714. BOOL OpenFileDialog(HWND hWnd, LPSTR pszFileName, int *nFileName, LPBOOL lpfSticky)
  1715. {
  1716.     BOOL            fReturn,
  1717.             fValid;
  1718.     OPENFILENAME    ofn;                
  1719.  
  1720.     pszFileName[0]          = 0;
  1721.  
  1722.     ofn.lStructSize         = sizeof(ofn);
  1723.     ofn.hwndOwner           = hWnd;
  1724.     ofn.hInstance           = hInst;
  1725.     ofn.lpstrFilter         = "Wave Files\0*.wav\0All Files\0*.*\0\0";
  1726.     ofn.lpstrCustomFilter   = NULL;
  1727.     ofn.nMaxCustFilter      = 0;
  1728.     ofn.nFilterIndex        = 1;
  1729.     ofn.lpstrFile           = pszFileName;
  1730.     ofn.nMaxFile            = MAX_PATH;
  1731.     ofn.lpstrFileTitle      = NULL;
  1732.     ofn.nMaxFileTitle       = 0;
  1733.     ofn.lpstrInitialDir     = gszCDStartPath;
  1734.     ofn.lpstrTitle          = "File Open";
  1735.     ofn.Flags               = OFN_FILEMUSTEXIST | OFN_EXPLORER
  1736.                                 | OFN_ENABLETEMPLATE | OFN_ENABLEHOOK | OFN_HIDEREADONLY;
  1737.     ofn.nFileOffset         = 0;
  1738.     ofn.nFileExtension      = 0;
  1739.     ofn.lpstrDefExt         = "wav";
  1740.     ofn.lCustData           = (LONG)lpfSticky;
  1741.     ofn.lpfnHook            = FileOpenCustomTemplateDlgProc;
  1742.     ofn.lpTemplateName      = MAKEINTRESOURCE(IDD_FILEOPEN_NEST);
  1743.                 
  1744.     fValid = FALSE;
  1745.     do   {    
  1746.     
  1747.     if (fReturn = GetOpenFileName(&ofn))
  1748.     {                               
  1749.     // Set the start path for the next time this dialog is opened
  1750.         lstrcpy( gszCDStartPath, pszFileName );
  1751.         gszCDStartPath[ofn.nFileOffset] = '\0';
  1752.  
  1753.     fValid = IsValidWave(pszFileName);
  1754.     if (!fValid)
  1755.     {
  1756.     MessageBox(hWnd, "Wave files must be PCM format!",
  1757.            "Invalid Wave File", MB_OK|MB_ICONSTOP);
  1758.     }
  1759.     else
  1760.     *nFileName = ofn.nFileOffset;
  1761.     }
  1762.     else fValid = TRUE;         // Force break out of loop.
  1763.     
  1764.     } while (!fValid);
  1765.  
  1766.     return(fReturn);     
  1767.  
  1768. }
  1769.  
  1770. // =======================================================================
  1771. /*  This function will determine if the filename passed
  1772.     in is a valid wave for this
  1773.     app, that is a PCM wave.
  1774.  
  1775.     Input:
  1776.     pszFileName -   FileName to check.
  1777.  
  1778.     Output:
  1779.     FALSE if not a valid wave, TRUE if it is.
  1780.     
  1781. */
  1782. // =======================================================================
  1783. BOOL IsValidWave(LPSTR pszFileName)
  1784. { 
  1785.     BOOL            fReturn     = FALSE;
  1786.     int             nError      = 0;
  1787.     HMMIO           hmmio;
  1788.     MMCKINFO        mmck;
  1789.     WAVEFORMATEX    *pwfx;
  1790.  
  1791.     if ((nError = WaveOpenFile(pszFileName, &hmmio, &pwfx, &mmck)) != 0)
  1792.     {       
  1793.     goto ERROR_IN_ROUTINE;
  1794.     }
  1795.  
  1796.     if (pwfx->wFormatTag != WAVE_FORMAT_PCM) 
  1797.     {
  1798.     goto ERROR_IN_ROUTINE;
  1799.     }
  1800.  
  1801.     WaveCloseReadFile(&hmmio, &pwfx);
  1802.  
  1803.     fReturn = TRUE;
  1804.  
  1805. ERROR_IN_ROUTINE:
  1806.     return(fReturn);    
  1807.  
  1808. }
  1809.  
  1810. // =======================================================================
  1811. // =======================================================================
  1812. BOOL UIMainWindowVSBHandler(HWND hWnd, WPARAM wParam, LPARAM lParam)
  1813. {
  1814.  
  1815.     FILEINFO    *pFileInfo;
  1816.     BOOL        fReturn             = FALSE;
  1817.  
  1818.     pFileInfo = FileInfoFirst.pNext;
  1819.  
  1820.     Assert(pFileInfo != NULL);
  1821.  
  1822.     while (pFileInfo != NULL)
  1823.     {
  1824.  
  1825.     if ((HWND)lParam == pFileInfo->hWndVolM_TB)
  1826.     {
  1827.     pFileInfo->dwVol = MAXVOL_TB -
  1828.     SendMessage(pFileInfo->hWndVolM_TB, TBM_GETPOS, 0, 0);
  1829.     ChangeOutputVol(pFileInfo);
  1830.     SetAllText(pFileInfo);
  1831.     UpdateLRVolume(pFileInfo);
  1832.     fReturn = TRUE;
  1833.     }
  1834.  
  1835.     pFileInfo = pFileInfo->pNext;
  1836.     
  1837.     }
  1838.  
  1839.     return (fReturn);
  1840.  
  1841. }
  1842.  
  1843.  
  1844. // =======================================================================
  1845. /*  This routine will handle all the calls to the WM_HSCROLL
  1846.     for the main window, that
  1847.     is, all the horizontal scrollbar (and trackbar) messages.
  1848.  
  1849.     Input:
  1850.     Standard parameters (minus the "message" parameter)
  1851.     for a window callback, though
  1852.     this is called from the window callback.
  1853.  
  1854.     Output:
  1855.     FALSE if the message isn't processed, else TRUE if it is.
  1856.     If FALSE, the
  1857.     return procedure should call the default windows procedure.
  1858. */
  1859. // =======================================================================
  1860. BOOL UIMainWindowHSBHandler(HWND hWnd, WPARAM wParam, LPARAM lParam)
  1861. {
  1862.  
  1863.     FILEINFO    *pFileInfo;
  1864.     BOOL        fReturn             = FALSE;
  1865.  
  1866.     pFileInfo = FileInfoFirst.pNext;
  1867.     
  1868.     Assert(pFileInfo != NULL);
  1869.  
  1870.     while (pFileInfo != NULL)
  1871.     {
  1872.  
  1873.     if ((HWND)lParam == pFileInfo->hWndFreq_TB)
  1874.     {
  1875.     pFileInfo->dwFreq = (SendMessage(pFileInfo->hWndFreq_TB,
  1876.             TBM_GETPOS, 0, 0) * FREQFACTOR) - FREQADD;
  1877.     ChangeOutputFreq(pFileInfo);
  1878.     SetAllText(pFileInfo);          
  1879.     fReturn = TRUE;
  1880.     }
  1881.  
  1882.     else if ((HWND)lParam == pFileInfo->hWndPan_TB)
  1883.     {
  1884.     pFileInfo->dwPan = SendMessage(pFileInfo->hWndPan_TB,
  1885.                TBM_GETPOS, 0, 0);
  1886.     ChangeOutputPan(pFileInfo);
  1887.     SetAllText(pFileInfo);
  1888.     UpdateLRVolume(pFileInfo);
  1889.     fReturn = TRUE;
  1890.     }
  1891.  
  1892.     pFileInfo = pFileInfo->pNext;
  1893.     
  1894.     }
  1895.  
  1896.     return (fReturn);
  1897.     
  1898.  
  1899.  
  1900. }
  1901.  
  1902. // =======================================================================
  1903. /*  This routine will handle all the calls to the WM_COMMAND
  1904.     for the main window.
  1905.  
  1906.     Input:
  1907.     Standard parameters (minus the "message" parameter)
  1908.     for a window callback, though
  1909.     this is called from the window callback.
  1910.  
  1911.     Output:
  1912.     FALSE if the message isn't processed, else TRUE if it is.
  1913.     If FALSE, the
  1914.     return procedure should call the default windows procedure.
  1915.     
  1916.  
  1917. */
  1918. // =======================================================================
  1919. BOOL UIMainWindowCMDHandler(HWND hWnd, WPARAM wParam, LPARAM lParam)
  1920. {
  1921.  
  1922.     BOOL        fReturn     = FALSE;
  1923.     FILEINFO        *pFileInfo;
  1924.     FILEINFO        *pFileInfoNext;
  1925.     DWORD       dwLooping;
  1926.  
  1927.     pFileInfo = FileInfoFirst.pNext;
  1928.     while (pFileInfo != NULL)
  1929.     {
  1930.     
  1931.     pFileInfoNext = pFileInfo->pNext;
  1932.     
  1933.     if ((HWND)lParam == pFileInfo->hWndLooped_BN)
  1934.     {
  1935.     pFileInfo->fLooped = SendMessage(pFileInfo->hWndLooped_BN,
  1936.              BM_GETCHECK, 0, 0);
  1937.     // If it is playing then reset the looping to be proper
  1938.     if( pFileInfo->fPlaying ) {
  1939.     if( pFileInfo->fLooped ) {
  1940.         dwLooping = DSBPLAY_LOOPING;
  1941.     } else {
  1942.             dwLooping = 0;
  1943.     }
  1944.         pFileInfo->pDSB->lpVtbl->Play(pFileInfo->pDSB,
  1945.                         0, 0, dwLooping );
  1946.     } 
  1947.     fReturn = TRUE;
  1948.     }
  1949.     else if ((HWND)lParam == pFileInfo->hWndPlay_BN)
  1950.     {
  1951.     if (pFileInfo->fPlaying)
  1952.     {
  1953.     if (StopDSound(hWnd, pFileInfo) == 0)
  1954.     {
  1955.         SendMessage((HWND)lParam,
  1956.         WM_SETTEXT, 0, (LPARAM)(LPCTSTR)szPlay);
  1957.  
  1958. #ifdef SHOWSTATUS
  1959.         UpdateStatus(pFileInfo, 0);
  1960. #endif
  1961.         
  1962.         fReturn = TRUE;
  1963.         break;
  1964.     }
  1965.     
  1966.     }
  1967.     else            
  1968.     {
  1969.     if (StartDSound(hWnd, pFileInfo) == 0)
  1970.     {
  1971.         SendMessage((HWND)lParam,
  1972.         WM_SETTEXT, 0, (LPARAM)(LPCTSTR)szStop);
  1973. #ifdef SHOWSTATUS
  1974.         UpdateStatus(pFileInfo, DSBSTATUS_PLAYING);
  1975. #endif
  1976.             
  1977.         fReturn = TRUE;
  1978.         break;
  1979.     }
  1980.     
  1981.     }
  1982.     fReturn = TRUE;
  1983.     }
  1984.     
  1985.     else if ((HWND)lParam == pFileInfo->hWndRemove_BN)
  1986.     {
  1987.     ReleaseDirectSoundBuffer(pFileInfo);
  1988.     RemoveFromList(pFileInfo, &FileInfoFirst);
  1989.         UpdateMainStatus();
  1990.     
  1991.     fReturn = TRUE;
  1992.     }
  1993.     
  1994.  
  1995.     pFileInfo = pFileInfoNext;
  1996.     
  1997.     }
  1998.     
  1999.     if (!fReturn)
  2000.     {
  2001.  
  2002.     switch(wParam)
  2003.     {
  2004.  
  2005.     case IDPD_FILE_EXIT:    
  2006.     PostMessage(hWnd, WM_CLOSE, 0, 0);
  2007.     break;
  2008.  
  2009.     case IDPD_FILE_OPEN:
  2010.     PD_FileOpen(hWnd);
  2011.     break;
  2012.         
  2013.     case IDPD_HELP_ABOUT:
  2014.     DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUT),
  2015.           hWnd, (DLGPROC)DLGHelpAbout);
  2016.     break;
  2017.  
  2018.     case IDPD_OPTIONS_OUTPUTTYPE:
  2019.     DialogBox(hInst, MAKEINTRESOURCE(IDD_OUTPUTBUFFERTYPE),
  2020.           hWnd, (DLGPROC)DLGOutputBufferType);
  2021.     break;
  2022.  
  2023.     case IDPD_CHECKLATENCY:
  2024.     StopAllDSounds(hWnd, &FileInfoFirst);
  2025.     // Now fake that we're on in each voice so the
  2026.     //timer will update the 
  2027.     // strings in the window.
  2028.     pFileInfo = FileInfoFirst.pNext;
  2029.     while (pFileInfo != NULL)
  2030.     {                                           
  2031.         pFileInfo->fPlaying = TRUE;
  2032.         pFileInfo = pFileInfo->pNext;       
  2033.     }
  2034.  
  2035.     DialogBox(hInst, MAKEINTRESOURCE(IDD_CHECKLATENCY),
  2036.           hWnd, (DLGPROC)DLGCheckLatency);
  2037.     break;
  2038.  
  2039.         case IDPD_ENUMDRIVERS:
  2040.         fEnumDrivers = !fEnumDrivers;
  2041.         if( fEnumDrivers )
  2042.             {
  2043.             MessageBox( hWnd,
  2044.             "Drivers will not be enumerated until DSSHOW is run again.",
  2045.             szAppName, MB_OK );
  2046.             }
  2047.         break;
  2048.  
  2049.     default:
  2050.     return(FALSE);
  2051.     
  2052.     }
  2053.     }
  2054.  
  2055.     return(TRUE);
  2056.  
  2057.  
  2058. }
  2059.  
  2060. // =======================================================================
  2061. /*  This routine will handle the timer messages.
  2062.  
  2063.     Input:
  2064.     Standard input.
  2065.  
  2066.     Output: 
  2067.     TRUE if processed message, otherwise FALSE
  2068. */
  2069. // =======================================================================
  2070. BOOL UIMainWindowTimerHandler(HWND hWnd, WPARAM wParam, LPARAM lParam)
  2071. {
  2072.     FILEINFO        *pFileInfo;
  2073.     BOOL            fReturn             = FALSE;
  2074.     DWORD           dwStatus            = 0;
  2075.  
  2076.     for (pFileInfo = FileInfoFirst.pNext; pFileInfo != NULL; pFileInfo = pFileInfo->pNext)
  2077.     {
  2078.     HRESULT hr;
  2079.  
  2080.     hr = IDirectSoundBuffer_GetStatus(pFileInfo->pDSB, &dwStatus);
  2081.     if (DS_OK != hr) continue;
  2082.  
  2083.     if (dwStatus & DSBSTATUS_BUFFERLOST) {
  2084.     LPBYTE pbData, pbData2;
  2085.     DWORD  dwLength, dwLength2;
  2086.     
  2087.     //
  2088.     //  Restore the buffer, rewrite data, and play
  2089.     //
  2090.     hr = IDirectSoundBuffer_Restore(pFileInfo->pDSB);
  2091.     if (DS_OK == hr) {
  2092.  
  2093.     hr = IDirectSoundBuffer_Lock(pFileInfo->pDSB, 0,
  2094.              pFileInfo->cbSize,
  2095.              &pbData, &dwLength,
  2096.              &pbData2, &dwLength2,
  2097.              0);
  2098.  
  2099.     if (DS_OK == hr) {
  2100.     
  2101.         Assert(pbData != NULL);
  2102.         Assert(pFileInfo->pbData != NULL);
  2103.         memcpy(pbData, pFileInfo->pbData, pFileInfo->cbSize);
  2104.  
  2105.         hr = IDirectSoundBuffer_Unlock(pFileInfo->pDSB,
  2106.                        pbData, dwLength,
  2107.                        NULL, 0);
  2108.  
  2109.         if (DS_OK == hr) {
  2110.  
  2111.         if (pFileInfo->fPlaying) {
  2112.         if (pFileInfo->fLooped) {
  2113.         IDirectSoundBuffer_Play( pFileInfo->pDSB, 0, 0,
  2114.                      DSBPLAY_LOOPING );
  2115.         } else {
  2116.         IDirectSoundBuffer_Play( pFileInfo->pDSB, 0, 0,
  2117.                      0 );
  2118.         }
  2119.         }
  2120.  
  2121.         IDirectSoundBuffer_GetStatus(pFileInfo->pDSB, &dwStatus);
  2122.  
  2123.         }
  2124.     }
  2125.     }
  2126.     }
  2127.  
  2128. #ifdef SHOWSTATUS
  2129.     UpdateStatus(pFileInfo, dwStatus);
  2130. #endif
  2131.  
  2132.     if (!(dwStatus & DSBSTATUS_BUFFERLOST))
  2133.     {
  2134.     if ((pFileInfo->fPlaying) && (!(dwStatus & DSBSTATUS_PLAYING)) )
  2135.     {
  2136.     if (StopDSound(hWnd, pFileInfo) == 0)
  2137.     {
  2138.         SendMessage(pFileInfo->hWndPlay_BN,
  2139.         WM_SETTEXT, 0, (LPARAM)(LPCTSTR)szPlay);
  2140.     }
  2141.     }
  2142.     }
  2143.  
  2144.     pFileInfo->fLost = dwStatus & DSBSTATUS_BUFFERLOST;
  2145.  
  2146.     fReturn = TRUE;
  2147.     }
  2148.  
  2149.     return (fReturn);
  2150.  
  2151. }   
  2152.  
  2153.  
  2154.  
  2155. // =======================================================================
  2156. /*  This routine will start a sound to be played.  
  2157.     Input:
  2158.     hWnd        -   Of parent window.
  2159.     pFileInfo   -   Pointer to file to start,
  2160.         which is loaded and the
  2161.         data is filled in the structure,
  2162.         such as pbData, 
  2163.         etc.
  2164.  
  2165.     Output:
  2166.     0 if successful, else the error code.
  2167. */
  2168. // =======================================================================
  2169. int StartDSound(HWND hWnd, FILEINFO *pFileInfo)
  2170. {
  2171.     HRESULT     hr              = 0;
  2172.     DWORD           dwLooped;
  2173.     DWORD           dwStatus                = 0;
  2174.  
  2175.     // Already playing?
  2176.  
  2177.     // Start sound here....
  2178.     dwLooped = 0;
  2179.     if (pFileInfo->fLooped) {
  2180.     dwLooped = DSBPLAY_LOOPING;
  2181.     }
  2182.             
  2183.  
  2184.     if ((hr = pFileInfo->pDSB->lpVtbl->GetStatus(pFileInfo->pDSB,
  2185.              &dwStatus)) == 0)
  2186.     {
  2187.     if ((dwStatus&DSBSTATUS_PLAYING) == DSBSTATUS_PLAYING)
  2188.     {
  2189.     // Don't bother playing, just restart
  2190.     if ((hr = pFileInfo->pDSB->lpVtbl->SetCurrentPosition(
  2191.         pFileInfo->pDSB, 0)) != 0)
  2192.     {
  2193.     MessageBox(hWnd, "Cannot set current position",
  2194.            "Direct Sound Error", MB_OK);
  2195.     }
  2196.     }
  2197.     // Yes gotos are bad but this is real life not school.
  2198.     else goto PLAY_THE_THING;           
  2199.     }
  2200.     
  2201.     else
  2202.     {
  2203. PLAY_THE_THING:
  2204.     if ((hr = pFileInfo->pDSB->lpVtbl->Play(pFileInfo->pDSB,
  2205.                         0, 0, dwLooped)) != 0)
  2206.     {
  2207.     MessageBox(hWnd, "Cannot start playing",
  2208.        "Direct Sound Error", MB_OK);
  2209.     }
  2210.     else
  2211.     pFileInfo->fPlaying = TRUE;
  2212.     }
  2213.  
  2214.     return(hr);
  2215.  
  2216.  
  2217. }
  2218.  
  2219. // =======================================================================
  2220. /*  This routine will stop a sound which is playing.
  2221.  
  2222.     Input:
  2223.     hWnd        - Of parent window.
  2224.     pFileInfo       - Pointer to file to stop playing.
  2225.  
  2226.     Output:
  2227.     0 if successful, else the error code.
  2228.  
  2229. */
  2230. // =======================================================================
  2231. int StopDSound(HWND hWnd, FILEINFO *pFileInfo)
  2232. {
  2233.     HRESULT     hr          = 0;
  2234.  
  2235.     if (!pFileInfo->fPlaying)
  2236.     return(0);
  2237.        
  2238.  
  2239.     // Stop sound here...
  2240.     if ((hr = pFileInfo->pDSB->lpVtbl->Stop(pFileInfo->pDSB)) != 0) 
  2241.     {
  2242.     MessageBox(hWnd, "Cannot stop sound",
  2243.        "Direct Sound Error", MB_OK);        
  2244.     }
  2245.     else
  2246.     pFileInfo->fPlaying = FALSE;    
  2247.  
  2248.     return(hr);
  2249.  
  2250. }
  2251.  
  2252. // =======================================================================
  2253. /*  This routine will stop all the sounds which are playing.
  2254.  
  2255.     Input:
  2256.     hWnd        - Of parent window.
  2257.     pFileInfo   - Pointer to file to stop playing.
  2258.         (i.e. the head)
  2259.  
  2260.     Output:
  2261.     0 if successful, else the error code.
  2262.  
  2263. */
  2264. // =======================================================================
  2265. int StopAllDSounds(HWND hWnd, FILEINFO *pFileInfo)
  2266. {
  2267.     while (pFileInfo->pNext != NULL)
  2268.     {
  2269.     StopDSound(hWnd, pFileInfo->pNext);
  2270.     pFileInfo = pFileInfo->pNext;       
  2271.     }
  2272.  
  2273.     return(0);
  2274.  
  2275. }
  2276.  
  2277.  
  2278.  
  2279. // =======================================================================
  2280. /*  This routine will set the freq, vol and pan slider text
  2281.     according to the value 
  2282.     passed in.
  2283.  
  2284.     Input:
  2285.     pFileInfo   -   File pointer to set frequency for.
  2286.  
  2287.     The dwFreq in the pFileInfo structure must be set.
  2288.     This also uses the window handle
  2289.     in the pFileInfo structure.
  2290.     
  2291.     Output:
  2292.     None.
  2293. */
  2294. // =======================================================================
  2295. void SetAllText(FILEINFO    *pFileInfo)
  2296. {
  2297.     char            szBufT[128];
  2298.  
  2299.     sprintf(szBufT, "%s: %lu Hz     ",
  2300.     szFreq, pFileInfo->dwFreq);
  2301.     SetWindowText(pFileInfo->hWndFreq_TXT, szBufT);
  2302.  
  2303.     // Change PAN val to show full range
  2304.     sprintf(szBufT, "%s: %ld", szPan,
  2305.     (((LONG)(pFileInfo->dwPan) + SHIFTPAN_TB) * MULTPAN_TB ) );
  2306.     SetWindowText(pFileInfo->hWndPan_TXT, szBufT);
  2307.  
  2308.     // Change VOLUME val to show full range
  2309.     sprintf(szBufT, "%s: %ld", szVolume,
  2310.     (((LONG)(pFileInfo->dwVol) + SHIFTVOL_TB) * MULTVOL_TB ));
  2311.     SetWindowText(pFileInfo->hWndVol_TXT, szBufT);
  2312.  
  2313.  
  2314. }
  2315.  
  2316. // =======================================================================
  2317. /*  This routine will update the left and right
  2318.     volume according to main volume 
  2319.     and pan.
  2320.  
  2321.     Input:
  2322.     pFileInfo   - Pointer to fileinfo to update.
  2323.  
  2324.     Output:
  2325.     Nothing worth using.
  2326. */
  2327. // =======================================================================
  2328. void UpdateLRVolume(FILEINFO *pFileInfo)
  2329. {
  2330.  
  2331.     int             volLeft, volRight;
  2332.  
  2333.     if (pFileInfo->dwPan < MIDPAN_TB)
  2334.     {
  2335.     volLeft = pFileInfo->dwVol;
  2336.     volRight = (((int)pFileInfo->dwPan)
  2337.         *(int)pFileInfo->dwVol)/((int)MIDPAN_TB);
  2338.     }
  2339.     else
  2340.     {
  2341.     volLeft = ((((int)pFileInfo->dwPan - MAXPAN_TB)*-1)
  2342.        *(int)pFileInfo->dwVol)/((int)MIDPAN_TB);
  2343.     volRight = pFileInfo->dwVol;
  2344.     }
  2345.  
  2346.     
  2347.  
  2348.     SendMessage(pFileInfo->hWndVolL_TB, TBM_SETPOS, TRUE, MAXVOL_TB-volLeft);
  2349.     SendMessage(pFileInfo->hWndVolR_TB, TBM_SETPOS, TRUE, MAXVOL_TB-volRight);
  2350.     
  2351.     
  2352.  
  2353. }
  2354.  
  2355. // =======================================================================
  2356. /*  This will change the output panning position for a certain FILEINFO.
  2357.     This is 
  2358.     done by sending messages to the direct sound driver 
  2359.  
  2360.     Input:  
  2361.     pFileInfo   -   FileInfo to set.  This must contain the
  2362.         panning value to set.
  2363.  
  2364.     Output:
  2365.     0 if successful, else the error code.
  2366.  
  2367. */
  2368. // =======================================================================
  2369. int ChangeOutputPan(FILEINFO *pFileInfo)
  2370. {
  2371.  
  2372.     HRESULT     hr      = 0;
  2373.  
  2374.     // Change PAN val  since TB does not go full range
  2375.     if ((hr = pFileInfo->pDSB->lpVtbl->SetPan(pFileInfo->pDSB,
  2376.     (((pFileInfo->dwPan) + SHIFTPAN_TB) * MULTPAN_TB) )) != 0)
  2377.     {
  2378.     goto ERROR_DONE_ROUTINE;
  2379.     }
  2380.  
  2381. ERROR_DONE_ROUTINE:
  2382.     return(hr);
  2383.  
  2384. }
  2385.  
  2386. // =======================================================================
  2387. /*  This will change the output freq for a certain FILEINFO.  This is 
  2388.     done by sending messages to the direct sound driver 
  2389.  
  2390.     Input:  
  2391.     pFileInfo                   -   FileInfo to set.  This must contain the
  2392.                     freq value to set.
  2393.  
  2394.     Output:
  2395.     0 if successful, else the error code.
  2396.  
  2397. */
  2398. // =======================================================================
  2399. int ChangeOutputFreq(FILEINFO *pFileInfo)
  2400. {
  2401.  
  2402.     HRESULT     hr      = 0;
  2403.  
  2404.     if ((hr = pFileInfo->pDSB->lpVtbl->SetFrequency(pFileInfo->pDSB, pFileInfo->dwFreq)) != 0)
  2405.     {
  2406.     goto ERROR_DONE_ROUTINE;
  2407.     }
  2408.  
  2409. ERROR_DONE_ROUTINE:
  2410.     return(hr);
  2411.  
  2412. }
  2413.  
  2414.  
  2415.  
  2416. // =======================================================================
  2417. /*  This will change the output vol for a certain FILEINFO.  This is 
  2418.     done by sending messages to the direct sound driver 
  2419.  
  2420.     Input:  
  2421.     pFileInfo                   -   FileInfo to set.  This must contain the
  2422.                     freq value to set.
  2423.  
  2424.     Output:
  2425.     0 if successful, else the error code.
  2426.  
  2427. */
  2428. // =======================================================================
  2429. int ChangeOutputVol(FILEINFO *pFileInfo)
  2430. {
  2431.  
  2432.     HRESULT     hr      = 0;
  2433.  
  2434.     // Shift VOLUME val by 4 bits since TB does not go full range
  2435.     if ((hr = pFileInfo->pDSB->lpVtbl->SetVolume(pFileInfo->pDSB,
  2436.     (((pFileInfo->dwVol) + SHIFTVOL_TB) * MULTVOL_TB) )) != 0)
  2437.     {
  2438.     goto ERROR_DONE_ROUTINE;
  2439.     }
  2440.  
  2441. ERROR_DONE_ROUTINE:
  2442.     return(hr);
  2443.  
  2444. }
  2445.  
  2446.  
  2447. // =======================================================================
  2448. /*  This is the dialog box handler for the check latency dialog box.
  2449.  
  2450.     Input:
  2451.     Standard dialog box input.
  2452.  
  2453.     Output:
  2454.     Standard dialog box output.
  2455.  
  2456. */
  2457. // =======================================================================
  2458. long FAR PASCAL DLGCheckLatency(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  2459. {
  2460.  
  2461.     static HWND     hWndFiles_LB;
  2462.     FILEINFO        *pFileInfo              = NULL;
  2463.     int         nSelected;
  2464.     int         cT;
  2465.  
  2466.  
  2467.     switch(uMsg)
  2468.     {
  2469.     case WM_INITDIALOG:
  2470.     hWndFiles_LB = GetDlgItem(hWnd, IDC_FILES_LB);
  2471.     
  2472.     pFileInfo = FileInfoFirst.pNext;
  2473.     while (pFileInfo != NULL)
  2474.     {               
  2475.     SendMessage(hWndFiles_LB,
  2476.         LB_ADDSTRING,
  2477.         0,
  2478.         (LPARAM)(pFileInfo->szFileName
  2479.              + pFileInfo->nFileName));
  2480.         pFileInfo = pFileInfo->pNext;       
  2481.     }
  2482.  
  2483.     break;      
  2484.     
  2485.     case WM_COMMAND:
  2486.     switch(wParam)
  2487.     {
  2488.     case ID_DONE:                   
  2489.         PostMessage(hWnd, WM_CLOSE, 0, 0);
  2490.         break;
  2491.         
  2492.     case ID_PLAY:                       
  2493.         if ((nSelected = SendMessage(hWndFiles_LB,
  2494.              LB_GETCURSEL, 0, 0))
  2495.         != LB_ERR)
  2496.         {
  2497.         for (cT=0, pFileInfo = FileInfoFirst.pNext;
  2498.         pFileInfo != NULL;
  2499.         pFileInfo = pFileInfo->pNext, cT++)
  2500.         {
  2501.         if (cT == nSelected)
  2502.         {
  2503.         StartDSound(hWnd, pFileInfo);
  2504.         break;
  2505.         }
  2506.         }
  2507.         
  2508.         }
  2509.             
  2510.         break;
  2511.             
  2512.     case ID_STOP:
  2513.         StopAllDSounds(hWnd, &FileInfoFirst);
  2514.         break;
  2515.         
  2516.     default:
  2517.         break;
  2518.         
  2519.     }
  2520.     break;
  2521.  
  2522.     case WM_CLOSE:
  2523.     StopAllDSounds(hWnd, &FileInfoFirst);
  2524.     EndDialog(hWnd, 0);
  2525.     break;
  2526.  
  2527.     default:
  2528.     return(0);
  2529.     break;               
  2530.     
  2531.     }
  2532.     
  2533.     return(1);
  2534.  
  2535. }
  2536.  
  2537.  
  2538. // =======================================================================
  2539. /*  The help about dialog procedure.  
  2540.     
  2541.     Input:
  2542.     Standard windows dialog procedure.
  2543.  
  2544.     Output:
  2545.     Standard windows dialog procedure.
  2546.  
  2547. */
  2548. // =======================================================================
  2549. long FAR PASCAL DLGHelpAbout(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  2550. {
  2551.     switch(uMsg)
  2552.     {
  2553.     case WM_INITDIALOG:
  2554.     break;      
  2555.     
  2556.     case WM_COMMAND:
  2557.     switch(wParam)
  2558.     {
  2559.     case ID_OK:                 
  2560.         PostMessage(hWnd, WM_CLOSE, 0, 0);
  2561.         break;
  2562.         
  2563.     default:
  2564.         break;
  2565.         
  2566.     }
  2567.     break;
  2568.     
  2569.     case WM_CLOSE:
  2570.     EndDialog(hWnd, 0);
  2571.     break;
  2572.  
  2573.     default:
  2574.     return(0);
  2575.     break;               
  2576.  
  2577.     }
  2578.     
  2579.     return(1);
  2580.  
  2581. }
  2582.  
  2583.  
  2584. // =======================================================================
  2585. /*  The help about dialog procedure.  
  2586.     
  2587.     Input:
  2588.     Standard windows dialog procedure.
  2589.  
  2590.     Output:
  2591.     Standard windows dialog procedure.
  2592.  
  2593. */
  2594. // =======================================================================
  2595. long FAR PASCAL DLGOutputBufferType(HWND hWnd,UINT uMsg, WPARAM wParam, LPARAM lParam)
  2596. {
  2597.  
  2598.     static HWND     hWndFormats_LB          = NULL;
  2599.     int         cT;
  2600.     int         nSelection;
  2601.  
  2602.          
  2603.     switch(uMsg)
  2604.     {
  2605.     case WM_INITDIALOG:
  2606.     // Get the windows we need.
  2607.     hWndFormats_LB = GetDlgItem(hWnd, IDC_FORMATS);
  2608.     
  2609.     // Put the strings in the list box.
  2610.     for (cT=0; cT<C_DROPDOWNPCMFORMATS; cT++)
  2611.     SendMessage(hWndFormats_LB,
  2612.         LB_ADDSTRING, 0, (LPARAM)rgszTypes[cT]);
  2613.  
  2614.     // Get the current format and highlight it in the list box.
  2615.     if ((nSelection = FormatToIndex(hWnd, &FileInfoFirst)) != LB_ERR)
  2616.     {
  2617.     SendMessage(hWndFormats_LB, LB_SETCURSEL, nSelection, 0);
  2618.     }
  2619.  
  2620.  
  2621.     break;      
  2622.     
  2623.     case WM_COMMAND:
  2624.         switch(LOWORD(wParam))
  2625.     {
  2626.         case IDC_FORMATS:
  2627.             if( HIWORD( wParam ) == LBN_DBLCLK )
  2628.             {
  2629.             SendMessage( hWnd, WM_COMMAND, MAKEWPARAM( ID_OK, 0 ),
  2630.                                     0L );
  2631.             }
  2632.             break;
  2633.  
  2634.         case ID_OK:
  2635.         if ((nSelection = SendMessage(hWndFormats_LB,
  2636.         LB_GETCURSEL, 0, 0)) != LB_ERR)
  2637.         {
  2638.         if (IndexToFormat(hWnd, &FileInfoFirst, nSelection)
  2639.             == 0)
  2640.         PostMessage(hWnd, WM_CLOSE, 0, 0);
  2641.         }
  2642.         break;
  2643.         
  2644.     case ID_CANCEL:                 
  2645.         PostMessage(hWnd, WM_CLOSE, 0, 0);
  2646.         break;
  2647.  
  2648.     case ID_APPLY:                  
  2649.         if ((nSelection = SendMessage(hWndFormats_LB,
  2650.         LB_GETCURSEL, 0, 0)) != LB_ERR)
  2651.         IndexToFormat(hWnd, &FileInfoFirst, nSelection);
  2652.             
  2653.         break;
  2654.  
  2655.  
  2656.     default:
  2657.         break;
  2658.  
  2659.     }
  2660.     break;
  2661.  
  2662.     case WM_CLOSE:
  2663.     EndDialog(hWnd, 0);
  2664.     break;
  2665.  
  2666.     default:
  2667.     return(0);
  2668.     break;               
  2669.  
  2670.     }
  2671.         
  2672.     return(1);
  2673.  
  2674. }
  2675.  
  2676. // =======================================================================
  2677. /*  This routine will determine the output format in
  2678.     terms of an integer from the
  2679.     current output rate, type, etc.
  2680.     stored in the direct sound routines.   Integer
  2681.     values designate the string # in rgszTypes,
  2682.     i.e. index 0 is 8000kHz, 8 bit mono, 
  2683.     etc...
  2684.  
  2685.     Input:
  2686.     hWnd    - Handle of the current window.
  2687.     pFileInfo   - Pointer to the file info to retrieve the format for.
  2688.  
  2689.     Output:
  2690.     The index of the format, LB_ERR if undetermined.
  2691.  
  2692. */
  2693. // =======================================================================
  2694. int FormatToIndex(HWND hWnd, FILEINFO *pFileInfo)
  2695. {
  2696.  
  2697.     WAVEFORMATEX    wfx;
  2698.     DWORD       dwWaveStyle;
  2699.     DWORD       dwSize;
  2700.     int         nError              = 0;
  2701.  
  2702.     // Get the format.
  2703.     if ((nError = pFileInfo->pDSB->lpVtbl->GetFormat(pFileInfo->pDSB,
  2704.         &wfx, sizeof(wfx), &dwSize)) != 0)
  2705.     {
  2706.     goto ERROR_IN_ROUTINE;
  2707.     }
  2708.     if( dwSize > sizeof( wfx ) ) {
  2709.     nError = DSERR_GENERIC;
  2710.     goto ERROR_IN_ROUTINE;
  2711.     }
  2712.  
  2713.  
  2714.     // Change wfx to an integer.
  2715.     // Assume theres an error and check all parameters to 
  2716.     // see if its valid.
  2717.     nError = LB_ERR;
  2718.     dwWaveStyle = 0;
  2719.  
  2720.     if (wfx.wFormatTag != WAVE_FORMAT_PCM)
  2721.        goto ERROR_IN_ROUTINE;
  2722.  
  2723.     // Check the channels
  2724.     switch (wfx.nChannels)
  2725.     {
  2726.     case 1:
  2727.         break;
  2728.  
  2729.     case 2:
  2730.         dwWaveStyle |= 1;
  2731.         break;
  2732.  
  2733.     default:
  2734.         goto ERROR_IN_ROUTINE;
  2735.     }
  2736.  
  2737.     // Check the bits...
  2738.     switch (wfx.wBitsPerSample)
  2739.     {
  2740.     case 8:
  2741.         break;
  2742.  
  2743.     case 16:
  2744.         dwWaveStyle |= 2;
  2745.         break;
  2746.  
  2747.     default:
  2748.         goto ERROR_IN_ROUTINE;
  2749.     }
  2750.  
  2751.     // Check the rate.
  2752.     switch(wfx.nSamplesPerSec)
  2753.     {
  2754.     case 8000:
  2755.         break;
  2756.  
  2757.     case 11025:
  2758.         dwWaveStyle |= 4;
  2759.         break;
  2760.  
  2761.     case 22050:
  2762.         dwWaveStyle |= 8;
  2763.         break;
  2764.  
  2765.     case 44100:
  2766.         dwWaveStyle |= 12;
  2767.         break;
  2768.  
  2769.     default:
  2770.         goto ERROR_IN_ROUTINE;
  2771.     }
  2772.  
  2773.     nError = (int)dwWaveStyle;
  2774.  
  2775. ERROR_IN_ROUTINE:
  2776.     return(nError);
  2777. }
  2778.  
  2779.  
  2780. // =======================================================================
  2781. /*  This will convert an index (from a list box for instance)
  2782.     to a format by passing
  2783.     in the format to direct sound.
  2784.  
  2785.     Input:
  2786.     hWnd        -   Handle to window.
  2787.     pFileInfo   -   Pointer to current file info.
  2788.     index       -   Index value to convert to a
  2789.             waveformat structure.
  2790.  
  2791.     Output:
  2792.     0 if successful, else the error code.
  2793. */
  2794. // =======================================================================
  2795. int IndexToFormat(HWND hWnd, FILEINFO *pFileInfo, int index)
  2796. {
  2797.  
  2798.     int         nError      = 0;
  2799.  
  2800.  
  2801.     pFileInfo->pwfx->wFormatTag = WAVE_FORMAT_PCM;
  2802.  
  2803.     pFileInfo->pwfx->nChannels = 2;                                     // Assume stereo.
  2804.     if ((index%2) == 0)
  2805.     pFileInfo->pwfx->nChannels = 1;                                 // Its mono.
  2806.     
  2807.     // Assume 16 bit    
  2808.     pFileInfo->pwfx->nBlockAlign = 2*pFileInfo->pwfx->nChannels;
  2809.     pFileInfo->pwfx->wBitsPerSample = 16;
  2810.     if ((index%4) < 2) {
  2811.     // Its 8 bit.
  2812.     pFileInfo->pwfx->nBlockAlign = 1*pFileInfo->pwfx->nChannels;
  2813.     pFileInfo->pwfx->wBitsPerSample = 8;
  2814.     }
  2815.     
  2816.     pFileInfo->pwfx->nSamplesPerSec = 44100;    // Assume 44.1 kHz
  2817.     if (index < 4)
  2818.     pFileInfo->pwfx->nSamplesPerSec = 8000;
  2819.     else if (index < 8)
  2820.     pFileInfo->pwfx->nSamplesPerSec = 11025;
  2821.     else if (index < 12)
  2822.     pFileInfo->pwfx->nSamplesPerSec = 22050;
  2823.     
  2824.     
  2825.     pFileInfo->pwfx->nAvgBytesPerSec = pFileInfo->pwfx->nSamplesPerSec *
  2826.                pFileInfo->pwfx->nBlockAlign;                                        
  2827.     pFileInfo->pwfx->cbSize = 0;
  2828.  
  2829.     if ((nError = pFileInfo->pDSB->lpVtbl->SetFormat(pFileInfo->pDSB,
  2830.             pFileInfo->pwfx)) != DS_OK)         {
  2831.     MessageBox(hWnd, "Cannot set format buffer",
  2832.        "Direct Sound Error", MB_OK);
  2833.     goto ERROR_DONE_ROUTINE;
  2834.  
  2835.     }
  2836.  
  2837. ERROR_DONE_ROUTINE:
  2838.     return(nError);
  2839.  
  2840. }
  2841.  
  2842.  
  2843. // =======================================================================
  2844. /* GetMediaStartPath()                                                      */
  2845. /*                                                                          */
  2846. /*   This helper function attempts to get the media directory for Direct3D, */
  2847. /* which is where all the installed DX wave files go. If it can't find that */
  2848. /* it settles for the media sub-directory of the Windows directory.         */
  2849. // =======================================================================
  2850. void GetMediaStartPath( void )
  2851.     {
  2852.     HKEY    hReg;
  2853.     DWORD   cbStartPathLen;
  2854.  
  2855.     if( ERROR_SUCCESS != RegOpenKeyEx( HKEY_LOCAL_MACHINE,
  2856.             gszRegKeyDirect3D,
  2857.             0, KEY_READ, &hReg ))
  2858.     {
  2859.         goto REG_OPEN_FAILED;
  2860.     }
  2861.     else
  2862.     {
  2863.     // Query the Registry for the path to the media directory
  2864.     cbStartPathLen = sizeof( gszCDStartPath );
  2865.     if( ERROR_SUCCESS != RegQueryValueEx( hReg, gszRegValueD3DPath,
  2866.                 NULL, NULL,
  2867.                 gszCDStartPath, &cbStartPathLen ))
  2868.         {
  2869.         goto REG_OPEN_FAILED;
  2870.         }
  2871.     RegCloseKey( hReg );
  2872.     hReg = NULL;
  2873.     }
  2874.  
  2875.     return;
  2876.  
  2877. REG_OPEN_FAILED:
  2878.     // Start off by getting the Windows directory -- we're trying to build a
  2879.     // file path like "C:\WINDOWS\MEDIA", but the WINDOWS directory could be
  2880.     // named anything, so we must ask.
  2881.     GetWindowsDirectory( gszCDStartPath, sizeof(gszCDStartPath));
  2882.     // If there's no trailing backslash, append one
  2883.     if( lstrcmp( &gszCDStartPath[lstrlen(gszCDStartPath)], TEXT("\\") ))
  2884.     lstrcat( gszCDStartPath, TEXT("\\"));
  2885.     // Now add on the MEDIA part of the path
  2886.     lstrcat( gszCDStartPath, TEXT("MEDIA"));
  2887.     }
  2888.  
  2889.  
  2890. // =======================================================================
  2891. // fGetToken()
  2892. //
  2893. //    Parses the command-line string "in place" starting at pszStart.  A ptr
  2894. // to the start of the next token and it's length will be the out parameters,
  2895. // or NULL and 0 if no token.  Note that *ppszRet will NOT be NULL-terminated
  2896. // since the string is part of another string.  That's what then length is for.
  2897. //
  2898. // Returns: TRUE if a token was retrieved, or FALSE if there was no token.
  2899. // =======================================================================
  2900. BOOL fGetToken( PSTR pszStart, PSTR *ppszRet, int *pcchRet )
  2901.     {
  2902.     PSTR  pszCur = pszStart;
  2903.     PSTR  pszTokStart;
  2904.  
  2905.     if( !pszStart || NULL == ppszRet || NULL == pcchRet )
  2906.     return FALSE;
  2907.  
  2908.     // Skip leading whitespace
  2909.     while( *pszCur && (*pszCur == ' ' || *pszCur == '\t'))
  2910.     pszCur++;
  2911.  
  2912.     *ppszRet = NULL;
  2913.     *pcchRet = 0;
  2914.  
  2915.     if( *pszCur )
  2916.     {
  2917.     pszTokStart = pszCur;
  2918.  
  2919.     while( *pszCur && *pszCur != ' ' && *pszCur != '\t' )
  2920.         pszCur++;
  2921.  
  2922.     *ppszRet = pszTokStart;
  2923.     *pcchRet = (int)(pszCur - pszTokStart);
  2924.     }
  2925.  
  2926.     if( *pcchRet != 0 )
  2927.     return TRUE;
  2928.     else
  2929.     return FALSE;
  2930.     }
  2931.  
  2932.  
  2933. // =======================================================================
  2934. // fMatchToken()
  2935. //
  2936. //    Attempts to match the first cchLen characters of pszDatum to the
  2937. // string at pszString.  The comparison is case-insensitive (this function
  2938. // is designed for command-line switch matching).
  2939. //
  2940. // Returns: TRUE if the first cchLen characters are a match, else FALSE.
  2941. // =======================================================================
  2942. BOOL fMatchToken( PSTR pszString, PSTR pszDatum, int cchLen )
  2943.     {
  2944.     int    i;
  2945.  
  2946.     for( i = 0; i < cchLen; i++ )
  2947.     {
  2948.     if( CharLower( (LPTSTR)MAKELONG( pszString[i], 0 ))
  2949.             != CharLower( (LPTSTR)MAKELONG( pszDatum[i], 0 )))
  2950.         return FALSE;
  2951.     }
  2952.     return TRUE;
  2953.     }
  2954.  
  2955.  
  2956. // =======================================================================
  2957. // ParseCommandLine()
  2958. //
  2959. //    Given a command-line string without the module name, this function will
  2960. // parse the command line and takes action on whatever it finds there.
  2961. //
  2962. // Returns: TRUE if successful, or FALSE if there was an error.
  2963. // =======================================================================
  2964. BOOL ParseCommandLine(LPSTR lpszCmdLine)
  2965.     {
  2966.     PSTR    pszCur,pszToken;
  2967.     PSTR    ppszFiles[MAXCONTROLS];
  2968.     BOOL    fStartPlaying = FALSE, fStartLooping = FALSE;
  2969.     int        cchTokLen = 0, i, nFilesFound;
  2970.  
  2971.     pszCur = lpszCmdLine;
  2972.  
  2973.     // First get all the command line switches
  2974.     while( fGetToken(pszCur, &pszToken, &cchTokLen) &&
  2975.        (pszToken[0] == '/' || pszToken[0] == '-' ))
  2976.     {
  2977.     pszCur = pszToken + cchTokLen;
  2978.     pszToken++;
  2979.  
  2980.     if( fMatchToken( pszToken, "PLAY", 4 ))
  2981.         {
  2982.         fStartPlaying = TRUE;
  2983.         }
  2984.     else if( fMatchToken( pszToken, "LOOP", 4 ))
  2985.         {
  2986.         fStartLooping = TRUE;
  2987.         }
  2988.     else
  2989.         {
  2990.         // We don't recognize this mysterious switch, so eat it and move on
  2991.         }
  2992.     }
  2993.  
  2994.     // Anything left on the command-line will be treated as a filename and
  2995.     // we'll attempt to open it after we've found them all
  2996.     nFilesFound = 0;
  2997.     while( fGetToken(pszCur, &pszToken, &cchTokLen) && nFilesFound < MAXCONTROLS )
  2998.     {
  2999.     pszCur = pszToken + cchTokLen;
  3000.     ppszFiles[nFilesFound] = GlobalAllocPtr( GPTR, (cchTokLen+1)*sizeof(char));
  3001.     // Copy the token out of the command-line string and into our buffer
  3002.     CopyMemory( ppszFiles[nFilesFound], pszToken, cchTokLen*sizeof(char));
  3003.     // Append a NULL terminator to what we just copied (to be safe)
  3004.     *(ppszFiles[nFilesFound] + cchTokLen) = 0;
  3005.     nFilesFound++;
  3006.     }
  3007.     // This function will take the array of strings we've created and open
  3008.     // each string as a file.  It will obey the global fStartPlaying and
  3009.     // fStartLooping flags we may have already set above
  3010.     if( nFilesFound )
  3011.     BatchOpenFiles( ppszFiles, nFilesFound, fStartPlaying, fStartLooping );
  3012.  
  3013.     // Free the space we allocated
  3014.     for( i = 0; i < nFilesFound; i++ )
  3015.     {
  3016.     GlobalFreePtr( ppszFiles[i] );
  3017.     ppszFiles[i] = NULL;
  3018.     }
  3019.  
  3020.     // Returning TRUE means the caller should continue doing what they
  3021.     // were doing: we succeeded.
  3022.     return TRUE;
  3023.     }
  3024.  
  3025.  
  3026. // =======================================================================
  3027. // BatchOpenFiles()
  3028. //
  3029. //    Takes an array of string pointers and tries to open each as a file to
  3030. // playback.  If fPlay is TRUE, the files will be played as they are being
  3031. // opened.  If fLoop is TRUE, they will also be set to loop.
  3032. //
  3033. // Returns: FALSE in the event of catastrophic failure, otherwise TRUE.
  3034. // =======================================================================
  3035. BOOL BatchOpenFiles( PSTR *ppszFiles, int nFiles, BOOL fPlay, BOOL fLoop )
  3036.     {
  3037.     int i;
  3038.     FILEINFO *pfi;
  3039.     DWORD cSamples;
  3040.  
  3041.     // Cap the number of files we can load out of the given set if we'd load
  3042.     // too many otherwise
  3043.     if( GetNumControls(&FileInfoFirst) + nFiles > MAXCONTROLS )
  3044.     nFiles = MAXCONTROLS - GetNumControls(&FileInfoFirst);
  3045.     
  3046.     for( i = 0; i < nFiles; i++ )
  3047.     {
  3048.     if(( pfi = GlobalAllocPtr(GPTR, sizeof(FILEINFO))) == NULL )
  3049.         goto BOF_Fail;
  3050.  
  3051.     ZeroMemory( pfi, sizeof(FILEINFO));
  3052.     strcpy( pfi->szFileName, ppszFiles[i] );
  3053.  
  3054.     if( WaveLoadFile( ppszFiles[i], &pfi->cbSize, &cSamples,
  3055.               &pfi->pwfx, &pfi->pbData ) != 0 )
  3056.         goto BOF_LoopError;
  3057.  
  3058.     GetNextControlCoords( &FileInfoFirst, &pfi->cox, &pfi->coy );
  3059.     if( NewDirectSoundBuffer(pfi) != 0)
  3060.         goto BOF_LoopError;
  3061.     Assert( pfi->pbData != NULL );
  3062.  
  3063.     if( AddToList( &FileInfoFirst, pfi ) != 0 )
  3064.         goto BOF_LoopError;
  3065.  
  3066.     pfi->nFileName = 0;
  3067.  
  3068.     if( CreateControl( hWndMain, pfi, pfi->pwfx->nSamplesPerSec,
  3069.                (MAXPAN_TB-MINPAN_TB)/2, MINVOL_TB ) != 0 )
  3070.         {
  3071.         ReleaseDirectSoundBuffer(pfi);
  3072.         RemoveFromList( pfi, &FileInfoFirst );
  3073.         // RemoveFromList will do all the cleanup
  3074.         pfi = NULL;
  3075.         goto BOF_LoopError;
  3076.         }
  3077.     ChangeOutputVol(pfi);
  3078.     ChangeOutputFreq(pfi);
  3079.     ChangeOutputPan(pfi);
  3080.  
  3081.     // LOOP is only obeyed if PLAY was also specified
  3082.     if( fPlay )
  3083.         {
  3084.         if( fLoop )
  3085.         {
  3086.         pfi->fLooped = TRUE;
  3087.         SendMessage( pfi->hWndLooped_BN, BM_SETCHECK, TRUE, 0L );
  3088.         }
  3089.         SendMessage( hWndMain, WM_COMMAND, 0, (LPARAM)pfi->hWndPlay_BN );
  3090.         }
  3091.  
  3092.     // Avoid the in-loop error cleanup by using a continue statement here
  3093.     // to jump back up to the top
  3094.     continue;
  3095.     
  3096.     // Cleanup code in case we fail to open a particular file -- we should
  3097.     // just ignore this one and continue because we might still be able to
  3098.     // open other files
  3099.     BOF_LoopError:
  3100.     if( NULL != pfi )
  3101.         {
  3102.         if( NULL != pfi->pwfx )
  3103.         {
  3104.         GlobalFreePtr(pfi->pwfx);
  3105.         pfi->pwfx = NULL;
  3106.         }
  3107.         if( NULL != pfi->pbData )
  3108.         {
  3109.         GlobalFreePtr(pfi->pbData);
  3110.         pfi->pbData = NULL;
  3111.         }
  3112.  
  3113.         ReleaseDirectSoundBuffer(pfi);
  3114.         GlobalFreePtr(pfi);
  3115.         pfi = NULL;
  3116.         }
  3117.     }
  3118.  
  3119.     UpdateMainStatus();
  3120.  
  3121.     return TRUE;
  3122.  
  3123. BOF_Fail:
  3124.     return FALSE;
  3125.     }
  3126.  
  3127.  
  3128.  
  3129.  
  3130.