home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / graphics / audio / acmapp / acmthunk.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-10-05  |  46.0 KB  |  1,803 lines
  1. //==========================================================================;
  2. //
  3. //  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
  4. //  KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  5. //  IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
  6. //  PURPOSE.
  7. //
  8. //  Copyright (C) 1992 - 1997 Microsoft Corporation.  All Rights Reserved.
  9. //
  10. //--------------------------------------------------------------------------;
  11. //
  12. //  acmthunk.c
  13. //
  14. //  Description:
  15. //      This is a thunk layer to the Audio Compression Manager. It's 
  16. //      purpose is to allow an application to use the ACM only if it is
  17. //      available (like under Win 3.1 and NT where the ACM may or may not
  18. //      be installed).
  19. //
  20. //      There are two requirements for using this module:
  21. //
  22. //      1.  Compile and link with this module before linking to MMSYSTEM.LIB.
  23. //          Do *NOT* link with MSACM.LIB.
  24. //
  25. //      2.  Before calling any other functions in ACM function set, call
  26. //          acmThunkInitialize(). This will cause all dyna-linking to occur.
  27. //
  28. //      3.  Before exiting your application, call acmThunkTerminate().
  29. //          This will unlink to the ACM and free allocated resources.
  30. //
  31. //      NOTE! this could be written more efficiently in Assembly by doing
  32. //      a jump to the correct API in the ACM, but this would not be
  33. //      portable (easily) on NT. So the arguments will be repushed on the
  34. //      stack.. such is life.
  35. //
  36. //==========================================================================;
  37.  
  38. #include <windows.h>
  39. #include <windowsx.h>
  40. #include <mmsystem.h>
  41. #include <mmreg.h>
  42. #include <msacm.h>
  43.  
  44. //
  45. //
  46. //
  47. #ifdef WIN32
  48.     #define BCODE
  49. #else
  50.     #define BCODE           _based(_segname("_CODE"))
  51. #endif
  52.  
  53.  
  54. //==========================================================================;
  55. //
  56. //  Prototypes and String Defines for Dyna-Linking to the ACM
  57. //
  58. //
  59. //==========================================================================;
  60.  
  61. #define ACMINST_NOT_PRESENT     NULL
  62. #define ACMINST_TRY_LINKING     (HINSTANCE)(UINT)-1
  63.  
  64. static HINSTANCE    ghinstAcm   = ACMINST_TRY_LINKING;
  65.  
  66. #ifdef WIN32
  67. TCHAR BCODE gszAcmModuleName[]  = TEXT("MSACM32.DLL");
  68. #else
  69. char BCODE  gszAcmModuleName[]  = "MSACM.DLL";
  70. #endif
  71.  
  72. FARPROC    *gpafnAcmFunctions;
  73.  
  74. PSTR BCODE  gapszAcmFunctions[] =
  75. {
  76.     "acmGetVersion",
  77.     "acmMetrics",
  78.  
  79.     "acmDriverEnum",
  80. #ifdef WIN32
  81.     "acmDriverDetailsW",
  82.     "acmDriverDetailsA",
  83. #else
  84.     "acmDriverDetails",
  85. #endif
  86. #ifdef WIN32
  87.     "acmDriverAddW",
  88.     "acmDriverAddA",
  89. #else
  90.     "acmDriverAdd",
  91. #endif
  92.     "acmDriverRemove",
  93.     "acmDriverOpen",
  94.     "acmDriverClose",
  95.     "acmDriverMessage",
  96.     "acmDriverID",
  97.     "acmDriverPriority",
  98.  
  99. #ifdef WIN32
  100.     "acmFormatTagDetailsW",
  101.     "acmFormatTagDetailsA",
  102. #else
  103.     "acmFormatTagDetails",
  104. #endif
  105. #ifdef WIN32
  106.     "acmFormatTagEnumW",
  107.     "acmFormatTagEnumA",
  108. #else
  109.     "acmFormatTagEnum",
  110. #endif
  111. #ifdef WIN32
  112.     "acmFormatChooseW",
  113.     "acmFormatChooseA",
  114. #else
  115.     "acmFormatChoose",
  116. #endif
  117. #ifdef WIN32
  118.     "acmFormatDetailsW",
  119.     "acmFormatDetailsA",
  120. #else
  121.     "acmFormatDetails",
  122. #endif
  123. #ifdef WIN32
  124.     "acmFormatEnumW",
  125.     "acmFormatEnumA",
  126. #else
  127.     "acmFormatEnum",
  128. #endif
  129.     "acmFormatSuggest",
  130.  
  131. #ifdef WIN32
  132.     "acmFilterTagDetailsW",
  133.     "acmFilterTagDetailsA",
  134. #else
  135.     "acmFilterTagDetails",
  136. #endif
  137. #ifdef WIN32
  138.     "acmFilterTagEnumW",
  139.     "acmFilterTagEnumA",
  140. #else
  141.     "acmFilterTagEnum",
  142. #endif
  143. #ifdef WIN32
  144.     "acmFilterChooseW",
  145.     "acmFilterChooseA",
  146. #else
  147.     "acmFilterChoose",
  148. #endif
  149. #ifdef WIN32
  150.     "acmFilterDetailsW",
  151.     "acmFilterDetailsA",
  152. #else
  153.     "acmFilterDetails",
  154. #endif
  155. #ifdef WIN32
  156.     "acmFilterEnumW",
  157.     "acmFilterEnumA",
  158. #else
  159.     "acmFilterEnum",
  160. #endif
  161.  
  162.     "acmStreamOpen",
  163.     "acmStreamClose",
  164.     "acmStreamSize",
  165.     "acmStreamConvert",
  166.     "acmStreamReset",
  167.     "acmStreamPrepareHeader",
  168.     "acmStreamUnprepareHeader"
  169. };
  170.  
  171. #ifdef WIN32    
  172. //
  173. //  For Win32
  174. //
  175. enum
  176. {
  177.      ACMTHUNK_GETVERSION = 0,
  178.      ACMTHUNK_METRICS,
  179.      ACMTHUNK_DRIVERENUM,
  180.      ACMTHUNK_DRIVERDETAILSW,
  181.      ACMTHUNK_DRIVERDETAILSA,
  182.      ACMTHUNK_DRIVERADDW,
  183.      ACMTHUNK_DRIVERADDA,
  184.      ACMTHUNK_DRIVERREMOVE,
  185.      ACMTHUNK_DRIVEROPEN,
  186.      ACMTHUNK_DRIVERCLOSE,
  187.      ACMTHUNK_DRIVERMESSAGE,
  188.      ACMTHUNK_DRIVERID,
  189.      ACMTHUNK_DRIVERPRIORITY,
  190.      ACMTHUNK_FORMATTAGDETAILSW,
  191.      ACMTHUNK_FORMATTAGDETAILSA,
  192.      ACMTHUNK_FORMATTAGENUMW,
  193.      ACMTHUNK_FORMATTAGENUMA,
  194.      ACMTHUNK_FORMATCHOOSEW,
  195.      ACMTHUNK_FORMATCHOOSEA,
  196.      ACMTHUNK_FORMATDETAILSW,
  197.      ACMTHUNK_FORMATDETAILSA,
  198.      ACMTHUNK_FORMATENUMW,
  199.      ACMTHUNK_FORMATENUMA,
  200.      ACMTHUNK_FORMATSUGGEST,
  201.      ACMTHUNK_FILTERTAGDETAILSW,
  202.      ACMTHUNK_FILTERTAGDETAILSA,
  203.      ACMTHUNK_FILTERTAGENUMW,
  204.      ACMTHUNK_FILTERTAGENUMA,
  205.      ACMTHUNK_FILTERCHOOSEW,
  206.      ACMTHUNK_FILTERCHOOSEA,
  207.      ACMTHUNK_FILTERDETAILSW,
  208.      ACMTHUNK_FILTERDETAILSA,
  209.      ACMTHUNK_FILTERENUMW,
  210.      ACMTHUNK_FILTERENUMA,
  211.      ACMTHUNK_STREAMOPEN,
  212.      ACMTHUNK_STREAMCLOSE,
  213.      ACMTHUNK_STREAMSIZE,
  214.      ACMTHUNK_STREAMCONVERT,
  215.      ACMTHUNK_STREAMRESET,
  216.      ACMTHUNK_STREAMPREPAREHEADER,
  217.      ACMTHUNK_STREAMUNPREPAREHEADER,
  218.  
  219.      ACMTHUNK_MAX_FUNCTIONS
  220. };
  221.      
  222.     #ifdef _UNICODE
  223.     #define ACMTHUNK_DRIVERDETAILS        ACMTHUNK_DRIVERDETAILSW
  224.     #define ACMTHUNK_DRIVERADD        ACMTHUNK_DRIVERADDW
  225.     #define ACMTHUNK_FORMATTAGDETAILS   ACMTHUNK_FORMATTAGDETAILSW
  226.     #define ACMTHUNK_FORMATTAGENUM        ACMTHUNK_FORMATTAGENUMW
  227.     #define ACMTHUNK_FORMATCHOOSE        ACMTHUNK_FORMATCHOOSEW
  228.     #define ACMTHUNK_FORMATDETAILS        ACMTHUNK_FORMATDETAILSW
  229.     #define ACMTHUNK_FORMATENUM        ACMTHUNK_FORMATENUMW
  230.     #define ACMTHUNK_FILTERTAGDETAILS   ACMTHUNK_FILTERTAGDETAILSW
  231.     #define ACMTHUNK_FILTERTAGENUM        ACMTHUNK_FILTERTAGENUMW
  232.     #define ACMTHUNK_FILTERCHOOSE        ACMTHUNK_FILTERCHOOSEW
  233.     #define ACMTHUNK_FILTERDETAILS        ACMTHUNK_FILTERDETAILSW
  234.     #define ACMTHUNK_FILTERENUM        ACMTHUNK_FILTERENUMW
  235.  
  236.     #else
  237.     #define ACMTHUNK_DRIVERDETAILS        ACMTHUNK_DRIVERDETAILSA
  238.     #define ACMTHUNK_DRIVERADD        ACMTHUNK_DRIVERADDA
  239.     #define ACMTHUNK_FORMATTAGDETAILS   ACMTHUNK_FORMATTAGDETAILSA
  240.     #define ACMTHUNK_FORMATTAGENUM        ACMTHUNK_FORMATTAGENUMA
  241.     #define ACMTHUNK_FORMATCHOOSE        ACMTHUNK_FORMATCHOOSEA
  242.     #define ACMTHUNK_FORMATDETAILS        ACMTHUNK_FORMATDETAILSA
  243.     #define ACMTHUNK_FORMATENUM        ACMTHUNK_FORMATENUMA
  244.     #define ACMTHUNK_FILTERTAGDETAILS   ACMTHUNK_FILTERTAGDETAILSA
  245.     #define ACMTHUNK_FILTERTAGENUM        ACMTHUNK_FILTERTAGENUMA
  246.     #define ACMTHUNK_FILTERCHOOSE        ACMTHUNK_FILTERCHOOSEA
  247.     #define ACMTHUNK_FILTERDETAILS        ACMTHUNK_FILTERDETAILSA
  248.     #define ACMTHUNK_FILTERENUM        ACMTHUNK_FILTERENUMA
  249.  
  250.     #endif
  251.  
  252. #else     // if Win32
  253. //
  254. //  For Win16
  255. //
  256. enum
  257. {
  258.      ACMTHUNK_GETVERSION = 0,
  259.      ACMTHUNK_METRICS,
  260.      ACMTHUNK_DRIVERENUM,
  261.      ACMTHUNK_DRIVERDETAILS,
  262.      ACMTHUNK_DRIVERADD,
  263.      ACMTHUNK_DRIVERREMOVE,
  264.      ACMTHUNK_DRIVEROPEN,
  265.      ACMTHUNK_DRIVERCLOSE,
  266.      ACMTHUNK_DRIVERMESSAGE,
  267.      ACMTHUNK_DRIVERID,
  268.      ACMTHUNK_DRIVERPRIORITY,
  269.      ACMTHUNK_FORMATTAGDETAILS,
  270.      ACMTHUNK_FORMATTAGENUM,
  271.      ACMTHUNK_FORMATCHOOSE,
  272.      ACMTHUNK_FORMATDETAILS,
  273.      ACMTHUNK_FORMATENUM,
  274.      ACMTHUNK_FORMATSUGGEST,
  275.      ACMTHUNK_FILTERTAGDETAILS,
  276.      ACMTHUNK_FILTERTAGENUM,
  277.      ACMTHUNK_FILTERCHOOSE,
  278.      ACMTHUNK_FILTERDETAILS,
  279.      ACMTHUNK_FILTERENUM,
  280.      ACMTHUNK_STREAMOPEN,
  281.      ACMTHUNK_STREAMCLOSE,
  282.      ACMTHUNK_STREAMSIZE,
  283.      ACMTHUNK_STREAMCONVERT,
  284.      ACMTHUNK_STREAMRESET,
  285.      ACMTHUNK_STREAMPREPAREHEADER,
  286.      ACMTHUNK_STREAMUNPREPAREHEADER,
  287.  
  288.      ACMTHUNK_MAX_FUNCTIONS
  289. };
  290.  
  291. #endif    // if WIN32 else
  292.  
  293. #define ACMTHUNK_SIZE_TABLE_BYTES   (ACMTHUNK_MAX_FUNCTIONS * sizeof(FARPROC))
  294.  
  295.  
  296. //==========================================================================;
  297. //
  298. //
  299. //
  300. //==========================================================================;
  301.  
  302. //--------------------------------------------------------------------------;
  303. //  
  304. //  BOOL acmThunkInitialize
  305. //  
  306. //  Description:
  307. //  
  308. //  
  309. //  Arguments:
  310. //      None.
  311. //  
  312. //  Return (BOOL):
  313. //  
  314. //--------------------------------------------------------------------------;
  315.  
  316. BOOL FAR PASCAL acmThunkInitialize
  317. (
  318.     void
  319. )
  320. {
  321.     DWORD (ACMAPI *pfnAcmGetVersion)
  322.     (
  323.         void
  324.     );
  325.  
  326.     UINT            fuErrorMode;
  327.     DWORD           dwVersion;
  328.     UINT            u;
  329.  
  330.     //
  331.     //  if we have already linked to the API's, then just succeed...
  332.     //
  333.     if (NULL != gpafnAcmFunctions)
  334.     {
  335.         //
  336.         //  someone isn't satisfied with calling this API only once?
  337.         //
  338.         return (TRUE);
  339.     }
  340.  
  341.  
  342.     //
  343.     //  if we have already tried to link to the ACM, then fail this
  344.     //  call--it isn't present.
  345.     //
  346.     if (ACMINST_TRY_LINKING != ghinstAcm)
  347.         return (FALSE);
  348.  
  349.  
  350.     //
  351.     //  try to get a handle on the ACM--if we cannot do this, then fail
  352.     //
  353.     fuErrorMode = SetErrorMode(SEM_NOOPENFILEERRORBOX);
  354.     ghinstAcm = LoadLibrary(gszAcmModuleName);
  355.     SetErrorMode(fuErrorMode);
  356.     if (ghinstAcm < (HINSTANCE)HINSTANCE_ERROR)
  357.     {
  358.         ghinstAcm = ACMINST_NOT_PRESENT;
  359.         return (FALSE);
  360.     }
  361.  
  362.     (FARPROC)pfnAcmGetVersion = GetProcAddress(ghinstAcm, gapszAcmFunctions[ACMTHUNK_GETVERSION]);
  363.     if (NULL == pfnAcmGetVersion)
  364.     {
  365.         FreeLibrary(ghinstAcm);
  366.         ghinstAcm = ACMINST_NOT_PRESENT;
  367.  
  368.         return (FALSE);
  369.     }
  370.  
  371.  
  372.     //
  373.     //  allocate our array of function pointers to the ACM... note that
  374.     //  this is dynamically allocated so if the ACM is _not_ present,
  375.     //  then this code and data takes up very little space.
  376.     //
  377.     gpafnAcmFunctions = (FARPROC *)LocalAlloc(LPTR, ACMTHUNK_SIZE_TABLE_BYTES);
  378.     if (NULL == gpafnAcmFunctions)
  379.     {
  380.         FreeLibrary(ghinstAcm);
  381.         ghinstAcm = ACMINST_NOT_PRESENT;
  382.  
  383.         return (FALSE);
  384.     }
  385.  
  386.     gpafnAcmFunctions[ACMTHUNK_GETVERSION] = (FARPROC)pfnAcmGetVersion;
  387.  
  388.     //
  389.     //  if the version of the ACM is *NOT* V2.00 or greater, then
  390.     //  all other API's are unavailable--so don't waste time trying
  391.     //  to link to them.
  392.     //
  393.     dwVersion = (* pfnAcmGetVersion)();
  394.     if (0x0200 > HIWORD(dwVersion))
  395.     {
  396.         return (TRUE);
  397.     }
  398.  
  399.  
  400.     //
  401.     //  yipee! the ACM V2.00 or greater appears to be installed and
  402.     //  happy with us--so link to the rest of the nifty cool API's.
  403.     //
  404.     //  start at index 1 since we already linked to acmGetVersion above
  405.     //
  406.     for (u = 1; u < ACMTHUNK_MAX_FUNCTIONS; u++)
  407.     {
  408.         gpafnAcmFunctions[u] = GetProcAddress(ghinstAcm, gapszAcmFunctions[u]);
  409.     }
  410.  
  411.  
  412.     //
  413.     //  finally, return success
  414.     //
  415.     return (TRUE);
  416. } // acmThunkInitialize()
  417.  
  418.  
  419. //--------------------------------------------------------------------------;
  420. //  
  421. //  BOOL acmThunkTerminate
  422. //  
  423. //  Description:
  424. //  
  425. //  
  426. //  Arguments:
  427. //      None.
  428. //  
  429. //  Return (BOOL):
  430. //  
  431. //--------------------------------------------------------------------------;
  432.  
  433. BOOL FAR PASCAL acmThunkTerminate
  434. (
  435.     void
  436. )
  437. {
  438.     //
  439.     //
  440.     //
  441.     if (NULL != gpafnAcmFunctions)
  442.     {
  443.         LocalFree((HLOCAL)gpafnAcmFunctions);
  444.  
  445.         gpafnAcmFunctions = NULL;
  446.  
  447.         FreeLibrary(ghinstAcm);
  448.         ghinstAcm = ACMINST_TRY_LINKING;
  449.     }
  450.  
  451.     return (TRUE);
  452. } // acmThunkTerminate()
  453.  
  454.  
  455. //==========================================================================;
  456. //
  457. //  General Information API's
  458. //
  459. //
  460. //==========================================================================;
  461.  
  462. DWORD ACMAPI acmGetVersion
  463. (
  464.     void
  465. )
  466. {
  467.     DWORD (ACMAPI *pfnAcmGetVersion)
  468.     (
  469.         void
  470.     );
  471.  
  472.     DWORD           dwVersion;
  473.  
  474.     if (NULL == gpafnAcmFunctions)
  475.         return (0L);
  476.  
  477.     (FARPROC)pfnAcmGetVersion = gpafnAcmFunctions[ACMTHUNK_GETVERSION];
  478.     if (NULL == pfnAcmGetVersion)
  479.         return (0L);
  480.  
  481.     dwVersion = (* pfnAcmGetVersion)();
  482.  
  483.     return (dwVersion);
  484. } // acmGetVersion()
  485.  
  486.  
  487. //--------------------------------------------------------------------------;
  488. //--------------------------------------------------------------------------;
  489.  
  490. MMRESULT ACMAPI acmMetrics
  491. (
  492.     HACMOBJ                 hao,
  493.     UINT                    uMetric,
  494.     LPVOID                  pMetric
  495. )
  496. {
  497.     MMRESULT (ACMAPI *pfnAcmMetrics)
  498.     (
  499.         HACMOBJ                 hao,
  500.         UINT                    uMetric,
  501.         LPVOID                  pMetric
  502.     );
  503.  
  504.     MMRESULT        mmr;
  505.  
  506.     if (NULL == gpafnAcmFunctions)
  507.         return (MMSYSERR_ERROR);
  508.  
  509.     (FARPROC)pfnAcmMetrics = gpafnAcmFunctions[ACMTHUNK_METRICS];
  510.     if (NULL == pfnAcmMetrics)
  511.         return (MMSYSERR_ERROR);
  512.  
  513.     mmr = (* pfnAcmMetrics)(hao, uMetric, pMetric);
  514.  
  515.     return (mmr);
  516. } // acmMetrics()
  517.  
  518.  
  519. //==========================================================================;
  520. //
  521. //  ACM Driver Management API's
  522. //
  523. //
  524. //==========================================================================;
  525.  
  526. //--------------------------------------------------------------------------;
  527. //--------------------------------------------------------------------------;
  528.  
  529. MMRESULT ACMAPI acmDriverEnum
  530. (
  531.     ACMDRIVERENUMCB         fnCallback,
  532.     DWORD                   dwInstance,
  533.     DWORD                   fdwEnum
  534. )
  535. {
  536.     MMRESULT (ACMAPI *pfnAcmDriverEnum)
  537.     (
  538.         ACMDRIVERENUMCB         fnCallback,
  539.         DWORD                   dwInstance,
  540.         DWORD                   fdwEnum
  541.     );
  542.  
  543.     MMRESULT        mmr;
  544.  
  545.     if (NULL == gpafnAcmFunctions)
  546.         return (MMSYSERR_ERROR);
  547.  
  548.     (FARPROC)pfnAcmDriverEnum = gpafnAcmFunctions[ACMTHUNK_DRIVERENUM];
  549.     if (NULL == pfnAcmDriverEnum)
  550.         return (MMSYSERR_ERROR);
  551.  
  552.     mmr = (* pfnAcmDriverEnum)(fnCallback, dwInstance, fdwEnum);
  553.  
  554.     return (mmr);
  555. }
  556.  
  557.  
  558. //--------------------------------------------------------------------------;
  559. //--------------------------------------------------------------------------;
  560.  
  561. MMRESULT ACMAPI acmDriverDetails
  562. (
  563.     HACMDRIVERID            hadid,
  564.     LPACMDRIVERDETAILS      padd,
  565.     DWORD                   fdwDetails
  566. )
  567. {
  568.     MMRESULT (ACMAPI *pfnAcmDriverDetails)
  569.     (
  570.         HACMDRIVERID            hadid,
  571.         LPACMDRIVERDETAILS      padd,
  572.         DWORD                   fdwDetails
  573.     );
  574.  
  575.     MMRESULT        mmr;
  576.  
  577.     if (NULL == gpafnAcmFunctions)
  578.         return (MMSYSERR_ERROR);
  579.  
  580.     (FARPROC)pfnAcmDriverDetails = gpafnAcmFunctions[ACMTHUNK_DRIVERDETAILS];
  581.     if (NULL == pfnAcmDriverDetails)
  582.         return (MMSYSERR_ERROR);
  583.  
  584.     mmr = (* pfnAcmDriverDetails)(hadid, padd, fdwDetails);
  585.  
  586.     return (mmr);
  587. }
  588.  
  589. #ifdef _UNICODE
  590. MMRESULT ACMAPI acmDriverDetailsA
  591. (
  592.     HACMDRIVERID            hadid,
  593.     LPACMDRIVERDETAILSA     padd,
  594.     DWORD                   fdwDetails
  595. )
  596. {
  597.     MMRESULT (ACMAPI *pfnAcmDriverDetails)
  598.     (
  599.         HACMDRIVERID            hadid,
  600.         LPACMDRIVERDETAILSA     padd,
  601.         DWORD                   fdwDetails
  602.     );
  603.  
  604.     MMRESULT        mmr;
  605.  
  606.     if (NULL == gpafnAcmFunctions)
  607.         return (MMSYSERR_ERROR);
  608.  
  609.     (FARPROC)pfnAcmDriverDetails = gpafnAcmFunctions[ACMTHUNK_DRIVERDETAILSA];
  610.     if (NULL == pfnAcmDriverDetails)
  611.         return (MMSYSERR_ERROR);
  612.  
  613.     mmr = (* pfnAcmDriverDetails)(hadid, padd, fdwDetails);
  614.  
  615.     return (mmr);
  616. }
  617. #endif
  618.  
  619. //--------------------------------------------------------------------------;
  620. //--------------------------------------------------------------------------;
  621.  
  622. MMRESULT ACMAPI acmDriverAdd
  623. (
  624.     LPHACMDRIVERID          phadid,
  625.     HINSTANCE               hinstModule,
  626.     LPARAM                  lParam, 
  627.     DWORD                   dwPriority,
  628.     DWORD                   fdwAdd
  629. )
  630. {
  631.     MMRESULT (ACMAPI *pfnAcmDriverAdd)
  632.     (
  633.         LPHACMDRIVERID          phadid,
  634.         HINSTANCE               hinstModule,
  635.         LPARAM                  lParam, 
  636.         DWORD                   dwPriority,
  637.         DWORD                   fdwAdd
  638.     );
  639.  
  640.     MMRESULT        mmr;
  641.  
  642.     if (NULL == gpafnAcmFunctions)
  643.         return (MMSYSERR_ERROR);
  644.  
  645.     (FARPROC)pfnAcmDriverAdd = gpafnAcmFunctions[ACMTHUNK_DRIVERADD];
  646.     if (NULL == pfnAcmDriverAdd)
  647.         return (MMSYSERR_ERROR);
  648.  
  649.     mmr = (* pfnAcmDriverAdd)(phadid, hinstModule, lParam, dwPriority, fdwAdd);
  650.  
  651.     return (mmr);
  652. }
  653.  
  654. #ifdef _UNICODE
  655. MMRESULT ACMAPI acmDriverAddA
  656. (
  657.     LPHACMDRIVERID          phadid,
  658.     HINSTANCE               hinstModule,
  659.     LPARAM                  lParam, 
  660.     DWORD                   dwPriority,
  661.     DWORD                   fdwAdd
  662. )
  663. {
  664.     MMRESULT (ACMAPI *pfnAcmDriverAdd)
  665.     (
  666.         LPHACMDRIVERID          phadid,
  667.         HINSTANCE               hinstModule,
  668.         LPARAM                  lParam, 
  669.         DWORD                   dwPriority,
  670.         DWORD                   fdwAdd
  671.     );
  672.  
  673.     MMRESULT        mmr;
  674.  
  675.     if (NULL == gpafnAcmFunctions)
  676.         return (MMSYSERR_ERROR);
  677.  
  678.     (FARPROC)pfnAcmDriverAdd = gpafnAcmFunctions[ACMTHUNK_DRIVERADDA];
  679.     if (NULL == pfnAcmDriverAdd)
  680.         return (MMSYSERR_ERROR);
  681.  
  682.     mmr = (* pfnAcmDriverAdd)(phadid, hinstModule, lParam, dwPriority, fdwAdd);
  683.  
  684.     return (mmr);
  685. }
  686. #endif
  687.  
  688. //--------------------------------------------------------------------------;
  689. //--------------------------------------------------------------------------;
  690.  
  691. MMRESULT ACMAPI acmDriverRemove
  692. (
  693.     HACMDRIVERID            hadid,
  694.     DWORD                   fdwRemove
  695. )
  696. {
  697.     MMRESULT (ACMAPI *pfnAcmDriverRemove)
  698.     (
  699.         HACMDRIVERID            hadid,
  700.         DWORD                   fdwRemove
  701.     );
  702.  
  703.     MMRESULT        mmr;
  704.  
  705.     if (NULL == gpafnAcmFunctions)
  706.         return (MMSYSERR_ERROR);
  707.  
  708.     (FARPROC)pfnAcmDriverRemove = gpafnAcmFunctions[ACMTHUNK_DRIVERREMOVE];
  709.     if (NULL == pfnAcmDriverRemove)
  710.         return (MMSYSERR_ERROR);
  711.  
  712.     mmr = (* pfnAcmDriverRemove)(hadid, fdwRemove);
  713.  
  714.     return (mmr);
  715. }
  716.  
  717. //--------------------------------------------------------------------------;
  718. //--------------------------------------------------------------------------;
  719.  
  720. MMRESULT ACMAPI acmDriverOpen
  721. (
  722.     LPHACMDRIVER            phad, 
  723.     HACMDRIVERID            hadid,
  724.     DWORD                   fdwOpen
  725. )
  726. {
  727.     MMRESULT (ACMAPI *pfnAcmDriverOpen)
  728.     (
  729.         LPHACMDRIVER            phad, 
  730.         HACMDRIVERID            hadid,
  731.         DWORD                   fdwOpen
  732.     );
  733.  
  734.     MMRESULT        mmr;
  735.  
  736.     if (NULL == gpafnAcmFunctions)
  737.         return (MMSYSERR_ERROR);
  738.  
  739.     (FARPROC)pfnAcmDriverOpen = gpafnAcmFunctions[ACMTHUNK_DRIVEROPEN];
  740.     if (NULL == pfnAcmDriverOpen)
  741.         return (MMSYSERR_ERROR);
  742.  
  743.     mmr = (* pfnAcmDriverOpen)(phad, hadid, fdwOpen);
  744.  
  745.     return (mmr);
  746. }
  747.  
  748.  
  749. //--------------------------------------------------------------------------;
  750. //--------------------------------------------------------------------------;
  751.  
  752. MMRESULT ACMAPI acmDriverClose
  753. (
  754.     HACMDRIVER              had,
  755.     DWORD                   fdwClose
  756. )
  757. {
  758.     MMRESULT (ACMAPI *pfnAcmDriverClose)
  759.     (
  760.         HACMDRIVER              had,
  761.         DWORD                   fdwClose
  762.     );
  763.  
  764.     MMRESULT        mmr;
  765.  
  766.     if (NULL == gpafnAcmFunctions)
  767.         return (MMSYSERR_ERROR);
  768.  
  769.     (FARPROC)pfnAcmDriverClose = gpafnAcmFunctions[ACMTHUNK_DRIVERCLOSE];
  770.     if (NULL == pfnAcmDriverClose)
  771.         return (MMSYSERR_ERROR);
  772.  
  773.     mmr = (* pfnAcmDriverClose)(had, fdwClose);
  774.  
  775.     return (mmr);
  776. }
  777.  
  778.  
  779. //--------------------------------------------------------------------------;
  780. //--------------------------------------------------------------------------;
  781.  
  782. LRESULT ACMAPI acmDriverMessage
  783. (
  784.     HACMDRIVER              had,
  785.     UINT                    uMsg, 
  786.     LPARAM                  lParam1,
  787.     LPARAM                  lParam2
  788. )
  789. {
  790.     LRESULT (ACMAPI *pfnAcmDriverMessage)
  791.     (
  792.         HACMDRIVER              had,
  793.         UINT                    uMsg, 
  794.         LPARAM                  lParam1,
  795.         LPARAM                  lParam2
  796.     );
  797.  
  798.     LRESULT         lr;
  799.  
  800.     if (NULL == gpafnAcmFunctions)
  801.         return (MMSYSERR_ERROR);
  802.  
  803.     (FARPROC)pfnAcmDriverMessage = gpafnAcmFunctions[ACMTHUNK_DRIVERMESSAGE];
  804.     if (NULL == pfnAcmDriverMessage)
  805.         return (MMSYSERR_ERROR);
  806.  
  807.     lr = (* pfnAcmDriverMessage)(had, uMsg, lParam1, lParam2);
  808.  
  809.     return (lr);
  810. }
  811.  
  812.  
  813. //--------------------------------------------------------------------------;
  814. //--------------------------------------------------------------------------;
  815.  
  816. MMRESULT ACMAPI acmDriverID
  817. (
  818.     HACMOBJ                 hao,
  819.     LPHACMDRIVERID          phadid,
  820.     DWORD                   fdwDriverId
  821. )
  822. {
  823.     MMRESULT (ACMAPI *pfnAcmDriverId)
  824.     (
  825.         HACMOBJ                 hao,
  826.         LPHACMDRIVERID          phadid,
  827.         DWORD                   fdwDriverId
  828.     );
  829.  
  830.     MMRESULT        mmr;
  831.  
  832.     if (NULL == gpafnAcmFunctions)
  833.         return (MMSYSERR_ERROR);
  834.  
  835.     (FARPROC)pfnAcmDriverId = gpafnAcmFunctions[ACMTHUNK_DRIVERID];
  836.     if (NULL == pfnAcmDriverId)
  837.         return (MMSYSERR_ERROR);
  838.  
  839.     mmr = (* pfnAcmDriverId)(hao, phadid, fdwDriverId);
  840.  
  841.     return (mmr);
  842. }
  843.  
  844. //--------------------------------------------------------------------------;
  845. //--------------------------------------------------------------------------;
  846.  
  847. MMRESULT ACMAPI acmDriverPriority
  848. (
  849.     HACMDRIVERID            hadid,
  850.     DWORD                   dwPriority,
  851.     DWORD                   fdwPriority
  852. )
  853. {
  854.     MMRESULT (ACMAPI *pfnAcmDriverPriority)
  855.     (
  856.         HACMDRIVERID            hadid,
  857.         DWORD                   dwPriority,
  858.         DWORD                   fdwPriority
  859.     );
  860.  
  861.     MMRESULT        mmr;
  862.  
  863.     if (NULL == gpafnAcmFunctions)
  864.         return (MMSYSERR_ERROR);
  865.  
  866.     (FARPROC)pfnAcmDriverPriority = gpafnAcmFunctions[ACMTHUNK_DRIVERPRIORITY];
  867.     if (NULL == pfnAcmDriverPriority)
  868.         return (MMSYSERR_ERROR);
  869.  
  870.     mmr = (* pfnAcmDriverPriority)(hadid, dwPriority, fdwPriority);
  871.  
  872.     return (mmr);
  873. }
  874.  
  875.  
  876. //==========================================================================;
  877. //
  878. //  Format Tag Information API's
  879. //
  880. //
  881. //==========================================================================;
  882.  
  883. //--------------------------------------------------------------------------;
  884. //--------------------------------------------------------------------------;
  885.  
  886. MMRESULT ACMAPI acmFormatTagDetails
  887. (
  888.     HACMDRIVER              had,
  889.     LPACMFORMATTAGDETAILS   paftd,
  890.     DWORD                   fdwDetails
  891. )
  892. {
  893.     MMRESULT (ACMAPI *pfnAcmFormatTagDetails)
  894.     (
  895.         HACMDRIVER              had,
  896.         LPACMFORMATTAGDETAILS   paftd,
  897.         DWORD                   fdwDetails
  898.     );
  899.  
  900.     MMRESULT        mmr;
  901.  
  902.     if (NULL == gpafnAcmFunctions)
  903.         return (MMSYSERR_ERROR);
  904.  
  905.     (FARPROC)pfnAcmFormatTagDetails = gpafnAcmFunctions[ACMTHUNK_FORMATTAGDETAILS];
  906.     if (NULL == pfnAcmFormatTagDetails)
  907.         return (MMSYSERR_ERROR);
  908.  
  909.     mmr = (* pfnAcmFormatTagDetails)(had, paftd, fdwDetails);
  910.  
  911.     return (mmr);
  912. } // acmFormatTagDetails()
  913.  
  914. #ifdef _UNICODE
  915. MMRESULT ACMAPI acmFormatTagDetailsA
  916. (
  917.     HACMDRIVER              had,
  918.     LPACMFORMATTAGDETAILSA  paftd,
  919.     DWORD                   fdwDetails
  920. )
  921. {
  922.     MMRESULT (ACMAPI *pfnAcmFormatTagDetails)
  923.     (
  924.         HACMDRIVER              had,
  925.         LPACMFORMATTAGDETAILSA  paftd,
  926.         DWORD                   fdwDetails
  927.     );
  928.  
  929.     MMRESULT        mmr;
  930.  
  931.     if (NULL == gpafnAcmFunctions)
  932.         return (MMSYSERR_ERROR);
  933.  
  934.     (FARPROC)pfnAcmFormatTagDetails = gpafnAcmFunctions[ACMTHUNK_FORMATTAGDETAILSA];
  935.     if (NULL == pfnAcmFormatTagDetails)
  936.         return (MMSYSERR_ERROR);
  937.  
  938.     mmr = (* pfnAcmFormatTagDetails)(had, paftd, fdwDetails);
  939.  
  940.     return (mmr);
  941. } // acmFormatTagDetails()
  942. #endif
  943.  
  944. //--------------------------------------------------------------------------;
  945. //--------------------------------------------------------------------------;
  946.  
  947. MMRESULT ACMAPI acmFormatTagEnum
  948. (
  949.     HACMDRIVER              had,
  950.     LPACMFORMATTAGDETAILS   paftd,
  951.     ACMFORMATTAGENUMCB      fnCallback,
  952.     DWORD                   dwInstance, 
  953.     DWORD                   fdwEnum
  954. )
  955. {
  956.     MMRESULT (ACMAPI *pfnAcmFormatTagEnum)
  957.     (
  958.         HACMDRIVER              had,
  959.         LPACMFORMATTAGDETAILS   paftd,
  960.         ACMFORMATTAGENUMCB      fnCallback,
  961.         DWORD                   dwInstance, 
  962.         DWORD                   fdwEnum
  963.     );
  964.  
  965.     MMRESULT        mmr;
  966.  
  967.     if (NULL == gpafnAcmFunctions)
  968.         return (MMSYSERR_ERROR);
  969.  
  970.     (FARPROC)pfnAcmFormatTagEnum = gpafnAcmFunctions[ACMTHUNK_FORMATTAGENUM];
  971.     if (NULL == pfnAcmFormatTagEnum)
  972.         return (MMSYSERR_ERROR);
  973.  
  974.     mmr = (* pfnAcmFormatTagEnum)(had, paftd, fnCallback, dwInstance, fdwEnum);
  975.  
  976.     return (mmr);
  977. } // acmFormatTagEnum()
  978.  
  979. #ifdef _UNICODE
  980. MMRESULT ACMAPI acmFormatTagEnumA
  981. (
  982.     HACMDRIVER              had,
  983.     LPACMFORMATTAGDETAILSA  paftd,
  984.     ACMFORMATTAGENUMCBA     fnCallback,
  985.     DWORD                   dwInstance, 
  986.     DWORD                   fdwEnum
  987. )
  988. {
  989.     MMRESULT (ACMAPI *pfnAcmFormatTagEnum)
  990.     (
  991.         HACMDRIVER              had,
  992.         LPACMFORMATTAGDETAILSA  paftd,
  993.         ACMFORMATTAGENUMCBA     fnCallback,
  994.         DWORD                   dwInstance, 
  995.         DWORD                   fdwEnum
  996.     );
  997.  
  998.     MMRESULT        mmr;
  999.  
  1000.     if (NULL == gpafnAcmFunctions)
  1001.         return (MMSYSERR_ERROR);
  1002.  
  1003.     (FARPROC)pfnAcmFormatTagEnum = gpafnAcmFunctions[ACMTHUNK_FORMATTAGENUMA];
  1004.     if (NULL == pfnAcmFormatTagEnum)
  1005.         return (MMSYSERR_ERROR);
  1006.  
  1007.     mmr = (* pfnAcmFormatTagEnum)(had, paftd, fnCallback, dwInstance, fdwEnum);
  1008.  
  1009.     return (mmr);
  1010. } // acmFormatTagEnum()
  1011. #endif
  1012.  
  1013. //==========================================================================;
  1014. //
  1015. //  Format Information API's
  1016. //
  1017. //
  1018. //==========================================================================;
  1019.  
  1020. //--------------------------------------------------------------------------;
  1021. //--------------------------------------------------------------------------;
  1022.  
  1023. MMRESULT ACMAPI acmFormatChoose
  1024. (
  1025.     LPACMFORMATCHOOSE       pafmtc
  1026. )
  1027. {
  1028.     MMRESULT (ACMAPI *pfnAcmFormatChoose)
  1029.     (
  1030.         LPACMFORMATCHOOSE       pafmtc
  1031.     );
  1032.  
  1033.     MMRESULT        mmr;
  1034.  
  1035.     if (NULL == gpafnAcmFunctions)
  1036.         return (MMSYSERR_ERROR);
  1037.  
  1038.     (FARPROC)pfnAcmFormatChoose = gpafnAcmFunctions[ACMTHUNK_FORMATCHOOSE];
  1039.     if (NULL == pfnAcmFormatChoose)
  1040.         return (MMSYSERR_ERROR);
  1041.  
  1042.     mmr = (* pfnAcmFormatChoose)(pafmtc);
  1043.  
  1044.     return (mmr);
  1045. }
  1046.  
  1047. #ifdef _UNICODE
  1048. MMRESULT ACMAPI acmFormatChooseA
  1049. (
  1050.     LPACMFORMATCHOOSEA      pafmtc
  1051. )
  1052. {
  1053.     MMRESULT (ACMAPI *pfnAcmFormatChoose)
  1054.     (
  1055.         LPACMFORMATCHOOSEA      pafmtc
  1056.     );
  1057.  
  1058.     MMRESULT        mmr;
  1059.  
  1060.     if (NULL == gpafnAcmFunctions)
  1061.         return (MMSYSERR_ERROR);
  1062.  
  1063.     (FARPROC)pfnAcmFormatChoose = gpafnAcmFunctions[ACMTHUNK_FORMATCHOOSEA];
  1064.     if (NULL == pfnAcmFormatChoose)
  1065.         return (MMSYSERR_ERROR);
  1066.  
  1067.     mmr = (* pfnAcmFormatChoose)(pafmtc);
  1068.  
  1069.     return (mmr);
  1070. }
  1071. #endif
  1072.  
  1073. //--------------------------------------------------------------------------;
  1074. //--------------------------------------------------------------------------;
  1075.  
  1076. MMRESULT ACMAPI acmFormatDetails
  1077. (
  1078.     HACMDRIVER              had,
  1079.     LPACMFORMATDETAILS      pafd,
  1080.     DWORD                   fdwDetails
  1081. )
  1082. {
  1083.     MMRESULT (ACMAPI *pfnAcmFormatDetails)
  1084.     (
  1085.         HACMDRIVER              had,
  1086.         LPACMFORMATDETAILS      pafd,
  1087.         DWORD                   fdwDetails
  1088.     );
  1089.  
  1090.     MMRESULT        mmr;
  1091.  
  1092.     if (NULL == gpafnAcmFunctions)
  1093.         return (MMSYSERR_ERROR);
  1094.  
  1095.     (FARPROC)pfnAcmFormatDetails = gpafnAcmFunctions[ACMTHUNK_FORMATDETAILS];
  1096.     if (NULL == pfnAcmFormatDetails)
  1097.         return (MMSYSERR_ERROR);
  1098.  
  1099.     mmr = (* pfnAcmFormatDetails)(had, pafd, fdwDetails);
  1100.  
  1101.     return (mmr);
  1102. } // acmFormatDetails()
  1103.  
  1104. #ifdef _UNICODE
  1105. MMRESULT ACMAPI acmFormatDetailsA
  1106. (
  1107.     HACMDRIVER              had,
  1108.     LPACMFORMATDETAILSA     pafd,
  1109.     DWORD                   fdwDetails
  1110. )
  1111. {
  1112.     MMRESULT (ACMAPI *pfnAcmFormatDetails)
  1113.     (
  1114.         HACMDRIVER              had,
  1115.         LPACMFORMATDETAILSA     pafd,
  1116.         DWORD                   fdwDetails
  1117.     );
  1118.  
  1119.     MMRESULT        mmr;
  1120.  
  1121.     if (NULL == gpafnAcmFunctions)
  1122.         return (MMSYSERR_ERROR);
  1123.  
  1124.     (FARPROC)pfnAcmFormatDetails = gpafnAcmFunctions[ACMTHUNK_FORMATDETAILSA];
  1125.     if (NULL == pfnAcmFormatDetails)
  1126.         return (MMSYSERR_ERROR);
  1127.  
  1128.     mmr = (* pfnAcmFormatDetails)(had, pafd, fdwDetails);
  1129.  
  1130.     return (mmr);
  1131. } // acmFormatDetails()
  1132. #endif
  1133.  
  1134. //--------------------------------------------------------------------------;
  1135. //--------------------------------------------------------------------------;
  1136.  
  1137. MMRESULT ACMAPI acmFormatEnum
  1138. (
  1139.     HACMDRIVER              had,
  1140.     LPACMFORMATDETAILS      pafd,
  1141.     ACMFORMATENUMCB         fnCallback,
  1142.     DWORD                   dwInstance, 
  1143.     DWORD                   fdwEnum
  1144. )
  1145. {
  1146.     MMRESULT (ACMAPI *pfnAcmFormatEnum)
  1147.     (
  1148.         HACMDRIVER              had,
  1149.         LPACMFORMATDETAILS      pafd,
  1150.         ACMFORMATENUMCB         fnCallback,
  1151.         DWORD                   dwInstance, 
  1152.         DWORD                   fdwEnum
  1153.     );
  1154.  
  1155.     MMRESULT        mmr;
  1156.  
  1157.     if (NULL == gpafnAcmFunctions)
  1158.         return (MMSYSERR_ERROR);
  1159.  
  1160.     (FARPROC)pfnAcmFormatEnum = gpafnAcmFunctions[ACMTHUNK_FORMATENUM];
  1161.     if (NULL == pfnAcmFormatEnum)
  1162.         return (MMSYSERR_ERROR);
  1163.  
  1164.     mmr = (* pfnAcmFormatEnum)(had, pafd, fnCallback, dwInstance, fdwEnum);
  1165.  
  1166.     return (mmr);
  1167. }
  1168.  
  1169. #ifdef _UNICODE
  1170. MMRESULT ACMAPI acmFormatEnumA
  1171. (
  1172.     HACMDRIVER              had,
  1173.     LPACMFORMATDETAILSA     pafd,
  1174.     ACMFORMATENUMCBA        fnCallback,
  1175.     DWORD                   dwInstance, 
  1176.     DWORD                   fdwEnum
  1177. )
  1178. {
  1179.     MMRESULT (ACMAPI *pfnAcmFormatEnum)
  1180.     (
  1181.         HACMDRIVER              had,
  1182.         LPACMFORMATDETAILSA     pafd,
  1183.         ACMFORMATENUMCBA        fnCallback,
  1184.         DWORD                   dwInstance, 
  1185.         DWORD                   fdwEnum
  1186.     );
  1187.  
  1188.     MMRESULT        mmr;
  1189.  
  1190.     if (NULL == gpafnAcmFunctions)
  1191.         return (MMSYSERR_ERROR);
  1192.  
  1193.     (FARPROC)pfnAcmFormatEnum = gpafnAcmFunctions[ACMTHUNK_FORMATENUMA];
  1194.     if (NULL == pfnAcmFormatEnum)
  1195.         return (MMSYSERR_ERROR);
  1196.  
  1197.     mmr = (* pfnAcmFormatEnum)(had, pafd, fnCallback, dwInstance, fdwEnum);
  1198.  
  1199.     return (mmr);
  1200. }
  1201. #endif
  1202.  
  1203. //--------------------------------------------------------------------------;
  1204. //--------------------------------------------------------------------------;
  1205.  
  1206. MMRESULT ACMAPI acmFormatSuggest
  1207. (
  1208.     HACMDRIVER          had,
  1209.     LPWAVEFORMATEX      pwfxSrc,
  1210.     LPWAVEFORMATEX      pwfxDst,
  1211.     DWORD               cbwfxDst,
  1212.     DWORD               fdwSuggest
  1213. )
  1214. {
  1215.     MMRESULT (ACMAPI *pfnAcmFormatSuggest)
  1216.     (
  1217.         HACMDRIVER          had,
  1218.         LPWAVEFORMATEX      pwfxSrc,
  1219.         LPWAVEFORMATEX      pwfxDst,
  1220.         DWORD               cbwfxDst,
  1221.         DWORD               fdwSuggest
  1222.     );
  1223.  
  1224.     MMRESULT        mmr;
  1225.  
  1226.     if (NULL == gpafnAcmFunctions)
  1227.         return (MMSYSERR_ERROR);
  1228.  
  1229.     (FARPROC)pfnAcmFormatSuggest = gpafnAcmFunctions[ACMTHUNK_FORMATSUGGEST];
  1230.     if (NULL == pfnAcmFormatSuggest)
  1231.         return (MMSYSERR_ERROR);
  1232.  
  1233.     mmr = (* pfnAcmFormatSuggest)(had, pwfxSrc, pwfxDst, cbwfxDst, fdwSuggest);
  1234.  
  1235.     return (mmr);
  1236. }
  1237.  
  1238.  
  1239. //==========================================================================;
  1240. //
  1241. //  Filter Tag Information API's
  1242. //
  1243. //
  1244. //==========================================================================;
  1245.  
  1246. //--------------------------------------------------------------------------;
  1247. //--------------------------------------------------------------------------;
  1248.  
  1249. MMRESULT ACMAPI acmFilterTagDetails
  1250. (
  1251.     HACMDRIVER              had,
  1252.     LPACMFILTERTAGDETAILS   paftd,
  1253.     DWORD                   fdwDetails
  1254. )
  1255. {
  1256.     MMRESULT (ACMAPI *pfnAcmFilterTagDetails)
  1257.     (
  1258.         HACMDRIVER              had,
  1259.         LPACMFILTERTAGDETAILS   paftd,
  1260.         DWORD                   fdwDetails
  1261.     );
  1262.  
  1263.     MMRESULT        mmr;
  1264.  
  1265.     if (NULL == gpafnAcmFunctions)
  1266.         return (MMSYSERR_ERROR);
  1267.  
  1268.     (FARPROC)pfnAcmFilterTagDetails = gpafnAcmFunctions[ACMTHUNK_FILTERTAGDETAILS];
  1269.     if (NULL == pfnAcmFilterTagDetails)
  1270.         return (MMSYSERR_ERROR);
  1271.  
  1272.     mmr = (* pfnAcmFilterTagDetails)(had, paftd, fdwDetails);
  1273.  
  1274.     return (mmr);
  1275. } // acmFilterTagDetails()
  1276.  
  1277. #ifdef _UNICODE
  1278. MMRESULT ACMAPI acmFilterTagDetailsA
  1279. (
  1280.     HACMDRIVER              had,
  1281.     LPACMFILTERTAGDETAILSA  paftd,
  1282.     DWORD                   fdwDetails
  1283. )
  1284. {
  1285.     MMRESULT (ACMAPI *pfnAcmFilterTagDetails)
  1286.     (
  1287.         HACMDRIVER              had,
  1288.         LPACMFILTERTAGDETAILSA  paftd,
  1289.         DWORD                   fdwDetails
  1290.     );
  1291.  
  1292.     MMRESULT        mmr;
  1293.  
  1294.     if (NULL == gpafnAcmFunctions)
  1295.         return (MMSYSERR_ERROR);
  1296.  
  1297.     (FARPROC)pfnAcmFilterTagDetails = gpafnAcmFunctions[ACMTHUNK_FILTERTAGDETAILSA];
  1298.     if (NULL == pfnAcmFilterTagDetails)
  1299.         return (MMSYSERR_ERROR);
  1300.  
  1301.     mmr = (* pfnAcmFilterTagDetails)(had, paftd, fdwDetails);
  1302.  
  1303.     return (mmr);
  1304. } // acmFilterTagDetails()
  1305. #endif
  1306.  
  1307. //--------------------------------------------------------------------------;
  1308. //--------------------------------------------------------------------------;
  1309.  
  1310. MMRESULT ACMAPI acmFilterTagEnum
  1311. (
  1312.     HACMDRIVER              had,
  1313.     LPACMFILTERTAGDETAILS   paftd,
  1314.     ACMFILTERTAGENUMCB      fnCallback,
  1315.     DWORD                   dwInstance, 
  1316.     DWORD                   fdwEnum
  1317. )
  1318. {
  1319.     MMRESULT (ACMAPI *pfnAcmFilterTagEnum)
  1320.     (
  1321.         HACMDRIVER              had,
  1322.         LPACMFILTERTAGDETAILS   paftd,
  1323.         ACMFILTERTAGENUMCB      fnCallback,
  1324.         DWORD                   dwInstance, 
  1325.         DWORD                   fdwEnum
  1326.     );
  1327.  
  1328.     MMRESULT        mmr;
  1329.  
  1330.     if (NULL == gpafnAcmFunctions)
  1331.         return (MMSYSERR_ERROR);
  1332.  
  1333.     (FARPROC)pfnAcmFilterTagEnum = gpafnAcmFunctions[ACMTHUNK_FILTERTAGENUM];
  1334.     if (NULL == pfnAcmFilterTagEnum)
  1335.         return (MMSYSERR_ERROR);
  1336.  
  1337.     mmr = (* pfnAcmFilterTagEnum)(had, paftd, fnCallback, dwInstance, fdwEnum);
  1338.  
  1339.     return (mmr);
  1340. } // acmFilterTagEnum()
  1341.  
  1342. #ifdef _UNICODE
  1343. MMRESULT ACMAPI acmFilterTagEnumA
  1344. (
  1345.     HACMDRIVER              had,
  1346.     LPACMFILTERTAGDETAILSA  paftd,
  1347.     ACMFILTERTAGENUMCBA     fnCallback,
  1348.     DWORD                   dwInstance, 
  1349.     DWORD                   fdwEnum
  1350. )
  1351. {
  1352.     MMRESULT (ACMAPI *pfnAcmFilterTagEnum)
  1353.     (
  1354.         HACMDRIVER              had,
  1355.         LPACMFILTERTAGDETAILSA  paftd,
  1356.         ACMFILTERTAGENUMCBA     fnCallback,
  1357.         DWORD                   dwInstance, 
  1358.         DWORD                   fdwEnum
  1359.     );
  1360.  
  1361.     MMRESULT        mmr;
  1362.  
  1363.     if (NULL == gpafnAcmFunctions)
  1364.         return (MMSYSERR_ERROR);
  1365.  
  1366.     (FARPROC)pfnAcmFilterTagEnum = gpafnAcmFunctions[ACMTHUNK_FILTERTAGENUMA];
  1367.     if (NULL == pfnAcmFilterTagEnum)
  1368.         return (MMSYSERR_ERROR);
  1369.  
  1370.     mmr = (* pfnAcmFilterTagEnum)(had, paftd, fnCallback, dwInstance, fdwEnum);
  1371.  
  1372.     return (mmr);
  1373. } // acmFilterTagEnum()
  1374. #endif
  1375.  
  1376. //==========================================================================;
  1377. //
  1378. //  Filter Information API's
  1379. //
  1380. //
  1381. //==========================================================================;
  1382.  
  1383. //--------------------------------------------------------------------------;
  1384. //--------------------------------------------------------------------------;
  1385.  
  1386. MMRESULT ACMAPI acmFilterChoose
  1387. (
  1388.     LPACMFILTERCHOOSE       pafltrc
  1389. )
  1390. {
  1391.     MMRESULT (ACMAPI *pfnAcmFilterChoose)
  1392.     (
  1393.         LPACMFILTERCHOOSE       pafltrc
  1394.     );
  1395.  
  1396.     MMRESULT        mmr;
  1397.  
  1398.     if (NULL == gpafnAcmFunctions)
  1399.         return (MMSYSERR_ERROR);
  1400.  
  1401.     (FARPROC)pfnAcmFilterChoose = gpafnAcmFunctions[ACMTHUNK_FILTERCHOOSE];
  1402.     if (NULL == pfnAcmFilterChoose)
  1403.         return (MMSYSERR_ERROR);
  1404.  
  1405.     mmr = (* pfnAcmFilterChoose)(pafltrc);
  1406.  
  1407.     return (mmr);
  1408. }
  1409.  
  1410. #ifdef _UNICODE
  1411. MMRESULT ACMAPI acmFilterChooseA
  1412. (
  1413.     LPACMFILTERCHOOSEA      pafltrc
  1414. )
  1415. {
  1416.     MMRESULT (ACMAPI *pfnAcmFilterChoose)
  1417.     (
  1418.         LPACMFILTERCHOOSEA      pafltrc
  1419.     );
  1420.  
  1421.     MMRESULT        mmr;
  1422.  
  1423.     if (NULL == gpafnAcmFunctions)
  1424.         return (MMSYSERR_ERROR);
  1425.  
  1426.     (FARPROC)pfnAcmFilterChoose = gpafnAcmFunctions[ACMTHUNK_FILTERCHOOSEA];
  1427.     if (NULL == pfnAcmFilterChoose)
  1428.         return (MMSYSERR_ERROR);
  1429.  
  1430.     mmr = (* pfnAcmFilterChoose)(pafltrc);
  1431.  
  1432.     return (mmr);
  1433. }
  1434. #endif
  1435.  
  1436. //--------------------------------------------------------------------------;
  1437. //--------------------------------------------------------------------------;
  1438.  
  1439. MMRESULT ACMAPI acmFilterDetails
  1440. (
  1441.     HACMDRIVER              had,
  1442.     LPACMFILTERDETAILS      pafd,
  1443.     DWORD                   fdwDetails
  1444. )
  1445. {
  1446.     MMRESULT (ACMAPI *pfnAcmFilterDetails)
  1447.     (
  1448.         HACMDRIVER              had,
  1449.         LPACMFILTERDETAILS      pafd,
  1450.         DWORD                   fdwDetails
  1451.     );
  1452.  
  1453.     MMRESULT        mmr;
  1454.  
  1455.     if (NULL == gpafnAcmFunctions)
  1456.         return (MMSYSERR_ERROR);
  1457.  
  1458.     (FARPROC)pfnAcmFilterDetails = gpafnAcmFunctions[ACMTHUNK_FILTERDETAILS];
  1459.     if (NULL == pfnAcmFilterDetails)
  1460.         return (MMSYSERR_ERROR);
  1461.  
  1462.     mmr = (* pfnAcmFilterDetails)(had, pafd, fdwDetails);
  1463.  
  1464.     return (mmr);
  1465. } // acmFilterDetails()
  1466.  
  1467. #ifdef _UNICODE
  1468. MMRESULT ACMAPI acmFilterDetailsA
  1469. (
  1470.     HACMDRIVER              had,
  1471.     LPACMFILTERDETAILSA     pafd,
  1472.     DWORD                   fdwDetails
  1473. )
  1474. {
  1475.     MMRESULT (ACMAPI *pfnAcmFilterDetails)
  1476.     (
  1477.         HACMDRIVER              had,
  1478.         LPACMFILTERDETAILSA     pafd,
  1479.         DWORD                   fdwDetails
  1480.     );
  1481.  
  1482.     MMRESULT        mmr;
  1483.  
  1484.     if (NULL == gpafnAcmFunctions)
  1485.         return (MMSYSERR_ERROR);
  1486.  
  1487.     (FARPROC)pfnAcmFilterDetails = gpafnAcmFunctions[ACMTHUNK_FILTERDETAILSA];
  1488.     if (NULL == pfnAcmFilterDetails)
  1489.         return (MMSYSERR_ERROR);
  1490.  
  1491.     mmr = (* pfnAcmFilterDetails)(had, pafd, fdwDetails);
  1492.  
  1493.     return (mmr);
  1494. } // acmFilterDetails()
  1495. #endif
  1496.  
  1497. //--------------------------------------------------------------------------;
  1498. //--------------------------------------------------------------------------;
  1499.  
  1500. MMRESULT ACMAPI acmFilterEnum
  1501. (
  1502.     HACMDRIVER              had,
  1503.     LPACMFILTERDETAILS      pafd,
  1504.     ACMFILTERENUMCB         fnCallback,
  1505.     DWORD                   dwInstance, 
  1506.     DWORD                   fdwEnum
  1507. )
  1508. {
  1509.     MMRESULT (ACMAPI *pfnAcmFilterEnum)
  1510.     (
  1511.         HACMDRIVER              had,
  1512.         LPACMFILTERDETAILS      pafd,
  1513.         ACMFILTERENUMCB         fnCallback,
  1514.         DWORD                   dwInstance, 
  1515.         DWORD                   fdwEnum
  1516.     );
  1517.  
  1518.     MMRESULT        mmr;
  1519.  
  1520.     if (NULL == gpafnAcmFunctions)
  1521.         return (MMSYSERR_ERROR);
  1522.  
  1523.     (FARPROC)pfnAcmFilterEnum = gpafnAcmFunctions[ACMTHUNK_FILTERENUM];
  1524.     if (NULL == pfnAcmFilterEnum)
  1525.         return (MMSYSERR_ERROR);
  1526.  
  1527.     mmr = (* pfnAcmFilterEnum)(had, pafd, fnCallback, dwInstance, fdwEnum);
  1528.  
  1529.     return (mmr);
  1530. }
  1531.  
  1532. #ifdef _UNICODE
  1533. MMRESULT ACMAPI acmFilterEnumA
  1534. (
  1535.     HACMDRIVER              had,
  1536.     LPACMFILTERDETAILSA     pafd,
  1537.     ACMFILTERENUMCBA        fnCallback,
  1538.     DWORD                   dwInstance, 
  1539.     DWORD                   fdwEnum
  1540. )
  1541. {
  1542.     MMRESULT (ACMAPI *pfnAcmFilterEnum)
  1543.     (
  1544.         HACMDRIVER              had,
  1545.         LPACMFILTERDETAILSA     pafd,
  1546.         ACMFILTERENUMCBA        fnCallback,
  1547.         DWORD                   dwInstance, 
  1548.         DWORD                   fdwEnum
  1549.     );
  1550.  
  1551.     MMRESULT        mmr;
  1552.  
  1553.     if (NULL == gpafnAcmFunctions)
  1554.         return (MMSYSERR_ERROR);
  1555.  
  1556.     (FARPROC)pfnAcmFilterEnum = gpafnAcmFunctions[ACMTHUNK_FILTERENUMA];
  1557.     if (NULL == pfnAcmFilterEnum)
  1558.         return (MMSYSERR_ERROR);
  1559.  
  1560.     mmr = (* pfnAcmFilterEnum)(had, pafd, fnCallback, dwInstance, fdwEnum);
  1561.  
  1562.     return (mmr);
  1563. }
  1564. #endif
  1565.  
  1566. //==========================================================================;
  1567. //
  1568. //  ACM Stream Management API's
  1569. //
  1570. //
  1571. //==========================================================================;
  1572.  
  1573. //--------------------------------------------------------------------------;
  1574. //--------------------------------------------------------------------------;
  1575.  
  1576. MMRESULT ACMAPI acmStreamOpen
  1577. (
  1578.     LPHACMSTREAM            phas,
  1579.     HACMDRIVER              had,
  1580.     LPWAVEFORMATEX          pwfxSrc,
  1581.     LPWAVEFORMATEX          pwfxDst,
  1582.     LPWAVEFILTER            pwfltr,
  1583.     DWORD                   dwCallback,
  1584.     DWORD                   dwInstance,
  1585.     DWORD                   fdwOpen
  1586. )
  1587. {
  1588.     MMRESULT (ACMAPI *pfnAcmStreamOpen)
  1589.     (
  1590.         LPHACMSTREAM            phas,
  1591.         HACMDRIVER              had,
  1592.         LPWAVEFORMATEX          pwfxSrc,
  1593.         LPWAVEFORMATEX          pwfxDst,
  1594.         LPWAVEFILTER            pwfltr,
  1595.         DWORD                   dwCallback,
  1596.         DWORD                   dwInstance,
  1597.         DWORD                   fdwOpen
  1598.     );
  1599.  
  1600.     MMRESULT        mmr;
  1601.  
  1602.     if (NULL == gpafnAcmFunctions)
  1603.         return (MMSYSERR_ERROR);
  1604.  
  1605.     (FARPROC)pfnAcmStreamOpen = gpafnAcmFunctions[ACMTHUNK_STREAMOPEN];
  1606.     if (NULL == pfnAcmStreamOpen)
  1607.         return (MMSYSERR_ERROR);
  1608.  
  1609.     mmr = (* pfnAcmStreamOpen)(phas, had, pwfxSrc, pwfxDst, pwfltr, dwCallback, dwInstance, fdwOpen);
  1610.  
  1611.     return (mmr);
  1612. }
  1613.  
  1614.  
  1615. //--------------------------------------------------------------------------;
  1616. //--------------------------------------------------------------------------;
  1617.  
  1618. MMRESULT ACMAPI acmStreamClose
  1619. (
  1620.     HACMSTREAM              has,
  1621.     DWORD                   fdwClose
  1622. )
  1623. {
  1624.     MMRESULT (ACMAPI *pfnAcmStreamClose)
  1625.     (
  1626.         HACMSTREAM              has,
  1627.         DWORD                   fdwClose
  1628.     );
  1629.  
  1630.     MMRESULT        mmr;
  1631.  
  1632.     if (NULL == gpafnAcmFunctions)
  1633.         return (MMSYSERR_ERROR);
  1634.  
  1635.     (FARPROC)pfnAcmStreamClose = gpafnAcmFunctions[ACMTHUNK_STREAMCLOSE];
  1636.     if (NULL == pfnAcmStreamClose)
  1637.         return (MMSYSERR_ERROR);
  1638.  
  1639.     mmr = (* pfnAcmStreamClose)(has, fdwClose);
  1640.  
  1641.     return (mmr);
  1642. }
  1643.  
  1644.  
  1645. //--------------------------------------------------------------------------;
  1646. //--------------------------------------------------------------------------;
  1647.  
  1648. MMRESULT ACMAPI acmStreamSize
  1649. (
  1650.     HACMSTREAM              has,
  1651.     DWORD                   cbInput,
  1652.     LPDWORD                 pdwOutputBytes,
  1653.     DWORD                   fdwSize
  1654. )
  1655. {
  1656.     MMRESULT (ACMAPI *pfnAcmStreamSize)
  1657.     (
  1658.         HACMSTREAM              has,
  1659.         DWORD                   cbInput,
  1660.         LPDWORD                 pdwOutputBytes,
  1661.         DWORD                   fdwSize
  1662.     );
  1663.  
  1664.     MMRESULT        mmr;
  1665.  
  1666.     if (NULL == gpafnAcmFunctions)
  1667.         return (MMSYSERR_ERROR);
  1668.  
  1669.     (FARPROC)pfnAcmStreamSize = gpafnAcmFunctions[ACMTHUNK_STREAMSIZE];
  1670.     if (NULL == pfnAcmStreamSize)
  1671.         return (MMSYSERR_ERROR);
  1672.  
  1673.     mmr = (* pfnAcmStreamSize)(has, cbInput, pdwOutputBytes, fdwSize);
  1674.  
  1675.     return (mmr);
  1676. }
  1677.  
  1678.  
  1679. //--------------------------------------------------------------------------;
  1680. //--------------------------------------------------------------------------;
  1681.  
  1682. MMRESULT ACMAPI acmStreamConvert
  1683. (
  1684.     HACMSTREAM              has, 
  1685.     LPACMSTREAMHEADER       pash,
  1686.     DWORD                   fdwConvert
  1687. )
  1688. {
  1689.     MMRESULT (ACMAPI *pfnAcmStreamConvert)
  1690.     (
  1691.         HACMSTREAM              has, 
  1692.         LPACMSTREAMHEADER       pash,
  1693.         DWORD                   fdwConvert
  1694.     );
  1695.  
  1696.     MMRESULT        mmr;
  1697.  
  1698.     if (NULL == gpafnAcmFunctions)
  1699.         return (MMSYSERR_ERROR);
  1700.  
  1701.     (FARPROC)pfnAcmStreamConvert = gpafnAcmFunctions[ACMTHUNK_STREAMCONVERT];
  1702.     if (NULL == pfnAcmStreamConvert)
  1703.         return (MMSYSERR_ERROR);
  1704.  
  1705.     mmr = (* pfnAcmStreamConvert)(has, pash, fdwConvert);
  1706.  
  1707.     return (mmr);
  1708. }
  1709.  
  1710.  
  1711. //--------------------------------------------------------------------------;
  1712. //--------------------------------------------------------------------------;
  1713.  
  1714. MMRESULT ACMAPI acmStreamReset
  1715. (
  1716.     HACMSTREAM              has, 
  1717.     DWORD                   fdwReset
  1718. )
  1719. {
  1720.     MMRESULT (ACMAPI *pfnAcmStreamReset)
  1721.     (
  1722.         HACMSTREAM              has, 
  1723.         DWORD                   fdwReset
  1724.     );
  1725.  
  1726.     MMRESULT        mmr;
  1727.  
  1728.     if (NULL == gpafnAcmFunctions)
  1729.         return (MMSYSERR_ERROR);
  1730.  
  1731.     (FARPROC)pfnAcmStreamReset = gpafnAcmFunctions[ACMTHUNK_STREAMRESET];
  1732.     if (NULL == pfnAcmStreamReset)
  1733.         return (MMSYSERR_ERROR);
  1734.  
  1735.     mmr = (* pfnAcmStreamReset)(has, fdwReset);
  1736.  
  1737.     return (mmr);
  1738. }
  1739.  
  1740.  
  1741. //--------------------------------------------------------------------------;
  1742. //--------------------------------------------------------------------------;
  1743.  
  1744. MMRESULT ACMAPI acmStreamPrepareHeader
  1745. (
  1746.     HACMSTREAM              has, 
  1747.     LPACMSTREAMHEADER       pash,
  1748.     DWORD                   fdwPrepare
  1749. )
  1750. {
  1751.     MMRESULT (ACMAPI *pfnAcmStreamPrepareHeader)
  1752.     (
  1753.         HACMSTREAM              has, 
  1754.         LPACMSTREAMHEADER       pash,
  1755.         DWORD                   fdwPrepare
  1756.     );
  1757.  
  1758.     MMRESULT        mmr;
  1759.  
  1760.     if (NULL == gpafnAcmFunctions)
  1761.         return (MMSYSERR_ERROR);
  1762.  
  1763.     (FARPROC)pfnAcmStreamPrepareHeader = gpafnAcmFunctions[ACMTHUNK_STREAMPREPAREHEADER];
  1764.     if (NULL == pfnAcmStreamPrepareHeader)
  1765.         return (MMSYSERR_ERROR);
  1766.  
  1767.     mmr = (* pfnAcmStreamPrepareHeader)(has, pash, fdwPrepare);
  1768.  
  1769.     return (mmr);
  1770. }
  1771.  
  1772.  
  1773. //--------------------------------------------------------------------------;
  1774. //--------------------------------------------------------------------------;
  1775.  
  1776. MMRESULT ACMAPI acmStreamUnprepareHeader
  1777. (
  1778.     HACMSTREAM              has, 
  1779.     LPACMSTREAMHEADER       pash,
  1780.     DWORD                   fdwUnprepare
  1781. )
  1782. {
  1783.     MMRESULT (ACMAPI *pfnAcmStreamUnprepareHeader)
  1784.     (
  1785.         HACMSTREAM              has, 
  1786.         LPACMSTREAMHEADER       pash,
  1787.         DWORD                   fdwUnprepare
  1788.     );
  1789.  
  1790.     MMRESULT        mmr;
  1791.  
  1792.     if (NULL == gpafnAcmFunctions)
  1793.         return (MMSYSERR_ERROR);
  1794.  
  1795.     (FARPROC)pfnAcmStreamUnprepareHeader = gpafnAcmFunctions[ACMTHUNK_STREAMUNPREPAREHEADER];
  1796.     if (NULL == pfnAcmStreamUnprepareHeader)
  1797.         return (MMSYSERR_ERROR);
  1798.  
  1799.     mmr = (* pfnAcmStreamUnprepareHeader)(has, pash, fdwUnprepare);
  1800.  
  1801.     return (mmr);
  1802. }
  1803.