home *** CD-ROM | disk | FTP | other *** search
/ QBasic & Borland Pascal & C / Delphi5.iso / C / BC_502 / MIXTREE.PAK / MIXINFO.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-06  |  6.9 KB  |  261 lines
  1. // THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
  2. // ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  3. // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
  4. // PARTICULAR PURPOSE.
  5. //
  6. // Copyright (C) 1993 - 1995  Microsoft Corporation.  All Rights Reserved.
  7. //
  8. //  MODULE:   mixinfo.c
  9. //
  10. //  PURPOSE:  Obtain information about mixer lines and controls.
  11. //
  12. //  FUNCTIONS:
  13. //    InitMixer          - Mixer services initialization code.
  14. //    GetLineInfo        - Get information for a mixer line.      
  15. //    GetLineControls    - Get information for one or more mixer controls.
  16. //
  17. //
  18. //  COMMENTS:
  19. //
  20.  
  21. #include <windows.h>                // required for all Windows applications.
  22. #include <windowsx.h>
  23.  
  24. #include "globals.h"                // prototypes specific to this application.
  25. #include "resource.h"
  26. #include "mixinfo.h"
  27.  
  28.  
  29. //
  30. //  FUNCTION: InitMixer(HWND)
  31. //
  32. //  PURPOSE: Mixer services initialization code.
  33. //
  34. //  PARAMETERS:
  35. //    hwnd - Application window handle.
  36. //
  37. //  RETURN VALUE:
  38. //    TRUE  - Success
  39. //    FALSE - Initialization failed
  40. //
  41. //  COMMENTS:
  42. //
  43. //    This function is called at application initialization time.  It
  44. //    opens a mixer device and sets a global variable for the handle
  45. //    to the mixer device.  If no mixer device is found, then MixTree 
  46. //    will simulate a mixer device instead.
  47. //
  48. //
  49.  
  50. BOOL InitMixer(HWND hwnd)
  51. {           
  52.     MMRESULT result;
  53.     char achMsg[80];   
  54.    
  55.     // query for the number of mixer devices in the system
  56.     uNumMixers = mixerGetNumDevs();    
  57.  
  58.     if (uNumMixers)
  59.     {
  60.     // Note - this code just deals with a single mixer device!
  61.     // It uses mixer device id 0 regardless of how many mixer
  62.     // devices are actually present.
  63.     uMixerID = 0;
  64.  
  65.     // open the mixer device without using any callback mechanism
  66.     result = mixerOpen(&hMixer, uMixerID, 0, 0, 0);    
  67.     if (result)
  68.     {               
  69.         wsprintf((LPSTR)achMsg, 
  70.              (LPSTR)"Error #%d opening mixer device", result);
  71.         MessageBox(hwnd, achMsg, "MixTree Error", MB_ICONHAND);
  72.         return (FALSE);
  73.     }
  74.    
  75.     // query the mixer's capabilities
  76.     result = mixerGetDevCaps(uMixerID, &MixerCaps, sizeof(MIXERCAPS));  
  77.     if (result)
  78.     {               
  79.         wsprintf((LPSTR)achMsg, 
  80.              (LPSTR)"Error #%d getting mixer capabilities", result);
  81.         MessageBox(hwnd, achMsg, "MixTree Error", MB_ICONHAND);
  82.         return (FALSE);
  83.     }
  84.  
  85.     }
  86.     else
  87.     {
  88.     // provide simulated mixer capabilities
  89.     strcpy(MixerCaps.szPname, "Simulated Mixer Device");
  90.     MixerCaps.cDestinations = SIMDESTLINES;                       
  91.     }
  92.  
  93.     // display the mixer device name in the window title
  94.     wsprintf((LPSTR)achMsg, (LPSTR)"MixTree - %s", MixerCaps.szPname);
  95.     SetWindowText(hwnd, achMsg);
  96.            
  97.     return (TRUE);
  98. }
  99.   
  100.  
  101. //
  102. //  FUNCTION: GetLineInfo(HWND, LPMIXERLINE, DWORD)
  103. //
  104. //  PURPOSE: Get the information for a mixer line. 
  105. //
  106. //  PARAMETERS:    
  107. //    hwnd     - application window handle.
  108. //    lpml     - address of a MIXERLINE structure to be filled with
  109. //               information about a mixer line.
  110. //    dwFlags  - flag indicating the method used to retrieve information.
  111. //
  112. //  RETURN VALUE:
  113. //    A return value of 0 indicates success.  Any non-zero return value 
  114. //    indicates an error in the mixerGetLineInfo() call.
  115. //
  116. //  COMMENTS: If hMixer = 0, no actual mixer device is present so data from
  117. //    the simulated mixer is returned.
  118. //    
  119. //
  120.  
  121. MMRESULT GetLineInfo(
  122.     HWND hwnd,
  123.     LPMIXERLINE lpml, 
  124.     DWORD dwFlags)
  125. {
  126.     char achMsg[80];   
  127.     MMRESULT result = 0;
  128.  
  129.     if (hMixer)
  130.     {
  131.     // call mixer services to fill a MIXERLINE structure with info
  132.  
  133.     result = mixerGetLineInfo(hMixer, lpml, dwFlags);
  134.     if (result)
  135.     {
  136.         wsprintf((LPSTR)achMsg, 
  137.              (LPSTR)"Error #%d calling mixerGetLineInfo", 
  138.              result);
  139.         MessageBox(hwnd, achMsg, "MixTree Error", MB_ICONHAND);
  140.     }
  141.     }
  142.     else
  143.     {
  144.     // fill the MIXERLINE structure with simulated mixer info
  145.  
  146.     switch (dwFlags)
  147.     {
  148.         case MIXER_GETLINEINFOF_DESTINATION:
  149.         _fmemcpy(lpml, 
  150.              &SimLine[lpml->dwDestination],
  151.              sizeof(MIXERLINE)); 
  152.         break;
  153.  
  154.         case MIXER_GETLINEINFOF_SOURCE:
  155.         _fmemcpy(lpml, 
  156.              &SimLine[SimSourceID[lpml->dwDestination]
  157.                          [lpml->dwSource]],
  158.              sizeof(MIXERLINE)); 
  159.         break;
  160.      
  161.         case MIXER_GETLINEINFOF_LINEID:
  162.         _fmemcpy(lpml, 
  163.              &SimLine[lpml->dwLineID],
  164.              sizeof(MIXERLINE)); 
  165.         break;
  166.  
  167.         default:
  168.         OutputDebugString("GetLineInfo: bad dwFlags\r\n");
  169.         return 1;
  170.     }
  171.     }
  172.  
  173.     return result;
  174. }
  175.  
  176.  
  177. //
  178. //  FUNCTION: GetLineControls(HWND, LPMIXERLINECONTROLS, DWORD)
  179. //
  180. //  PURPOSE: Get the information for one or more mixer controls.
  181. //
  182. //  PARAMETERS:
  183. //    hwnd     - application window handle.
  184. //    lpmlcs   - address of a MIXERLINECONTROLS referencing one or more
  185. //               MIXERLINECONTROL structures to be filled with information
  186. //               about the associated mixer controls.
  187. //    dwFlags  - flag indicating the method used to retrieve information.
  188. //
  189. //  RETURN VALUE:
  190. //    A return value of 0 indicates success.  Any non-zero return value
  191. //    indicates an error in the mixerGetLineControls() call.
  192. //
  193. //  COMMENTS: If hMixer = 0, no actual mixer device is present so data from
  194. //    the simulated mixer is returned.
  195. //
  196. //
  197.  
  198. MMRESULT GetLineControls(
  199.      HWND hwnd,
  200.      LPMIXERLINECONTROLS lpmlcs,
  201.      DWORD dwFlags)
  202. {
  203.      UINT i;
  204.     char achMsg[80];
  205.     MMRESULT result = 0;
  206.  
  207.     if (hMixer)
  208.     {
  209.     // call mixer services to fill one or more MIXERLINECONTROL structures
  210.     // associated with the MIXERLINECONTROLS structure 
  211.  
  212.     result = mixerGetLineControls(hMixer, lpmlcs, dwFlags); 
  213.     if (result)
  214.     {
  215.         wsprintf((LPSTR)achMsg, 
  216.              (LPSTR)"Error #%d calling mixerGetLineControls", 
  217.              result);
  218.         MessageBox(hwnd, achMsg, "MixTree Error", MB_ICONHAND);
  219.     }
  220.     }
  221.     else
  222.     {
  223.     // fill one or more MIXERLINECONTROL structures associated with the 
  224.     // MIXERLINECONTROLS structure with simulated mixer info
  225.  
  226.     switch (dwFlags)
  227.     {
  228.         case MIXER_GETLINECONTROLSF_ALL:
  229.         for (i = 0; i < lpmlcs->cControls; i++)
  230.             _fmemcpy(&(lpmlcs->pamxctrl[i]), 
  231.             &SimLineControl[SimLineControlID[lpmlcs->dwLineID][i]],
  232.             sizeof(MIXERCONTROL)); 
  233.         break;
  234.  
  235.         case MIXER_GETLINECONTROLSF_ONEBYID:
  236.  
  237.          // MIXERLINECONTROLS uses anonymous unions, which are not supported in
  238.          // C.  The code below is conditionalized to show you how the usage
  239.          // differs between C and C++.
  240.          #if defined (__cplusplus)
  241.         _fmemcpy(lpmlcs->pamxctrl,
  242.              &SimLineControl[lpmlcs->dwControlID],
  243.              sizeof(MIXERCONTROL));
  244.          #else
  245.         _fmemcpy(lpmlcs->pamxctrl,
  246.              &SimLineControl[lpmlcs->u.dwControlID],
  247.              sizeof(MIXERCONTROL));
  248.         #endif
  249.  
  250.         break;
  251.  
  252.         default:
  253.         // other flags not supported
  254.         OutputDebugString("GetLineControls: bad dwFlags\r\n");
  255.         return 1;
  256.     }
  257.     }
  258.  
  259.     return result;
  260. }
  261.