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