Changeset 1607 for trunk/src/msacm32


Ignore:
Timestamp:
Nov 5, 1999, 10:19:27 AM (26 years ago)
Author:
sandervl
Message:

Jens Weissner's update

Location:
trunk/src/msacm32
Files:
5 added
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/msacm32/internal.cpp

    r972 r1607  
    1 /* $Id: internal.cpp,v 1.2 1999-09-18 15:57:10 sandervl Exp $ */
     1/* -*- tab-width: 8; c-basic-offset: 4 -*- */
     2
    23/*
    34 *      MSACM32 library
    45 *
    56 *      Copyright 1998  Patrik Stridvall
    6  *      Copyright 1999  Jens Wiessner
     7 *                1999  Eric Pouech
    78 */
    89
    910#include <os2win.h>
    10 #include <stdio.h>
    11 #include <stdlib.h>
    1211#include <string.h>
    13 #include <odinwrap.h>
    1412
    1513#include "winbase.h"
    … …  
    2119#include "msacm.h"
    2220#include "msacmdrv.h"
     21#include "wineacm.h"
    2322#include "debugtools.h"
     23
     24DEFAULT_DEBUG_CHANNEL(msacm)   
    2425
    2526/**********************************************************************/
    … …  
    2829PWINE_ACMDRIVERID MSACM_pFirstACMDriverID = NULL;
    2930PWINE_ACMDRIVERID MSACM_pLastACMDriverID = NULL;
    30 INT         WINAPI lstrncmpiA(LPCSTR,LPCSTR,INT);
    31 
    3231
    3332/***********************************************************************
    3433 *           MSACM_RegisterDriver32()
    3534 */
    36 PWINE_ACMDRIVERID MSACM_RegisterDriver(
    37   LPSTR pszDriverAlias, LPSTR pszFileName,
    38   PWINE_ACMLOCALDRIVER pLocalDriver)
    39 {
    40   PWINE_ACMDRIVERID padid;
    41   padid = (PWINE_ACMDRIVERID) HeapAlloc(
    42     MSACM_hHeap, 0, sizeof(WINE_ACMDRIVERID)
    43   );
    44   padid->pszDriverAlias =
    45     HEAP_strdupA(MSACM_hHeap, 0, pszDriverAlias);
    46   padid->pszFileName =
    47     HEAP_strdupA(MSACM_hHeap, 0, pszFileName);
    48   padid->pACMLocalDriver = pLocalDriver;
    49   padid->bEnabled = TRUE;
    50   padid->pACMDriver = NULL;
    51   padid->pNextACMDriverID = NULL;
    52   padid->pPreviousACMDriverID =
    53     MSACM_pLastACMDriverID;
    54   MSACM_pLastACMDriverID = padid;
    55   if(!MSACM_pFirstACMDriverID)
    56     MSACM_pFirstACMDriverID = padid;
     35PWINE_ACMDRIVERID MSACM_RegisterDriver(LPSTR pszDriverAlias, LPSTR pszFileName,
     36                                       HINSTANCE hinstModule)
     37{
     38    PWINE_ACMDRIVERID padid;
    5739
    58   return padid;
     40    TRACE("('%s', '%s', 0x%08x)\n", pszDriverAlias, pszFileName, hinstModule);
     41
     42    padid = (PWINE_ACMDRIVERID) HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMDRIVERID));
     43    padid->pszDriverAlias = HEAP_strdupA(MSACM_hHeap, 0, pszDriverAlias);
     44    padid->pszFileName = HEAP_strdupA(MSACM_hHeap, 0, pszFileName);
     45    padid->hInstModule = hinstModule;
     46    padid->bEnabled = TRUE;
     47    padid->pACMDriver = NULL;
     48    padid->pNextACMDriverID = NULL;
     49    padid->pPreviousACMDriverID = MSACM_pLastACMDriverID;
     50    if (MSACM_pLastACMDriverID)
     51        MSACM_pLastACMDriverID->pNextACMDriverID = padid;
     52    MSACM_pLastACMDriverID = padid;
     53    if (!MSACM_pFirstACMDriverID)
     54        MSACM_pFirstACMDriverID = padid;
     55   
     56    return padid;
    5957}
    6058
    … …  
    6260 *           MSACM_RegisterAllDrivers32()
    6361 */
    64 void MSACM_RegisterAllDrivers()
     62void MSACM_RegisterAllDrivers(void)
    6563{
    66   PWINE_ACMBUILTINDRIVER pbd;
    67   LPSTR pszBuffer;
    68   DWORD dwBufferLength;
    69 
    70   /* FIXME
    71    *  What if the user edits system.ini while the program is running?
    72    *  Does Windows handle that?
    73    */
    74   if(!MSACM_pFirstACMDriverID)
    75     return;
    76 
    77   /* FIXME: Do not work! How do I determine the section length? */
    78   dwBufferLength =
    79     GetPrivateProfileSectionA("drivers32", NULL, 0, "system.ini");
    80 
    81   pszBuffer = (LPSTR) HeapAlloc(
    82     MSACM_hHeap, 0, dwBufferLength
    83   );
    84   if(GetPrivateProfileSectionA(
    85     "drivers32", pszBuffer, dwBufferLength, "system.ini"))
    86     {
    87       char *s = pszBuffer;
    88       while(*s)
    89         {
    90           if(!lstrncmpiA("MSACM.", s, 6))
    91             {
    92               char *s2 = s;
    93               while(*s2 != '\0' && *s2 != '=') s2++;
    94               if(*s2)
    95                 {
    96                   *s2++='\0';
    97                   MSACM_RegisterDriver(s, s2, NULL);
     64    LPSTR pszBuffer;
     65    DWORD dwBufferLength;
     66   
     67    /* FIXME
     68     *  What if the user edits system.ini while the program is running?
     69     *  Does Windows handle that?
     70     */
     71    if (MSACM_pFirstACMDriverID)
     72        return;
     73   
     74    /* FIXME: Do not work! How do I determine the section length? */
     75    dwBufferLength = 1024;
     76/* EPP  GetPrivateProfileSectionA("drivers32", NULL, 0, "system.ini"); */
     77   
     78    pszBuffer = (LPSTR) HeapAlloc(MSACM_hHeap, 0, dwBufferLength);
     79    if (GetPrivateProfileSectionA("drivers32", pszBuffer, dwBufferLength, "system.ini")) {
     80        char* s = pszBuffer;
     81        while (*s) {
     82            if (!lstrncmpiA("MSACM.", s, 6)) {
     83                char *s2 = s;
     84                while (*s2 != '\0' && *s2 != '=') s2++;
     85                if (*s2) {
     86                    *s2++ = '\0';
     87                    MSACM_RegisterDriver(s, s2, 0);
    9888                }
    9989            } 
    100           s += lstrlenA(s) + 1; /* Either next char or \0 */
     90            s += lstrlenA(s) + 1; /* Either next char or \0 */
    10191        }
    10292    }
    103 
    104   /* FIXME
    105    *   Check if any of the builtin driver was added
    106    *   when the external drivers was.
    107    */
    108 
    109   pbd = MSACM_BuiltinDrivers;
    110   while(pbd->pszDriverAlias)
    111     {
    112       PWINE_ACMLOCALDRIVER pld;
    113       pld = (PWINE_ACMLOCALDRIVER) HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMLOCALDRIVER));
    114       pld->pfnDriverProc = pbd->pfnDriverProc;
    115       MSACM_RegisterDriver(pbd->pszDriverAlias, NULL, pld);
    116       pbd++;
    117     }
    118    HeapFree(MSACM_hHeap, 0, pszBuffer);
     93   
     94    HeapFree(MSACM_hHeap, 0, pszBuffer);
    11995}
    12096
    … …  
    124100PWINE_ACMDRIVERID MSACM_UnregisterDriver(PWINE_ACMDRIVERID p)
    125101{
    126   PWINE_ACMDRIVERID pNextACMDriverID;
     102    PWINE_ACMDRIVERID pNextACMDriverID;
     103   
     104    if (p->pACMDriver)
     105        acmDriverClose((HACMDRIVER) p->pACMDriver, 0);
     106   
     107    if (p->pszDriverAlias)
     108        HeapFree(MSACM_hHeap, 0, p->pszDriverAlias);
     109    if (p->pszFileName)
     110        HeapFree(MSACM_hHeap, 0, p->pszFileName);
     111   
     112    if (p == MSACM_pFirstACMDriverID)
     113        MSACM_pFirstACMDriverID = p->pNextACMDriverID;
     114    if (p == MSACM_pLastACMDriverID)
     115        MSACM_pLastACMDriverID = p->pPreviousACMDriverID;
    127116
    128   if(p->pACMDriver)
    129     acmDriverClose((HACMDRIVER) p->pACMDriver, 0);
    130 
    131   if(p->pszDriverAlias)
    132     HeapFree(MSACM_hHeap, 0, p->pszDriverAlias);
    133   if(p->pszFileName)
    134     HeapFree(MSACM_hHeap, 0, p->pszFileName);
    135   if(p->pACMLocalDriver)
    136     HeapFree(MSACM_hHeap, 0, p->pACMLocalDriver);
    137 
    138   if(p->pPreviousACMDriverID)
    139     p->pPreviousACMDriverID->pNextACMDriverID = p->pNextACMDriverID;
    140   if(p->pNextACMDriverID)
    141     p->pNextACMDriverID->pPreviousACMDriverID = p->pPreviousACMDriverID;
    142 
    143   pNextACMDriverID = p->pNextACMDriverID;
    144 
    145   HeapFree(MSACM_hHeap, 0, p);
    146 
    147   return pNextACMDriverID;
     117    if (p->pPreviousACMDriverID)
     118        p->pPreviousACMDriverID->pNextACMDriverID = p->pNextACMDriverID;
     119    if (p->pNextACMDriverID)
     120        p->pNextACMDriverID->pPreviousACMDriverID = p->pPreviousACMDriverID;
     121   
     122    pNextACMDriverID = p->pNextACMDriverID;
     123   
     124    HeapFree(MSACM_hHeap, 0, p);
     125   
     126    return pNextACMDriverID;
    148127}
    149128
    … …  
    153132 *   Where should this function be called?
    154133 */
    155 void MSACM_UnregisterAllDrivers()
     134void MSACM_UnregisterAllDrivers(void)
    156135{
    157   PWINE_ACMDRIVERID p = MSACM_pFirstACMDriverID;
    158   while(p) p = MSACM_UnregisterDriver(p);
     136    PWINE_ACMDRIVERID p;
     137
     138    for (p = MSACM_pFirstACMDriverID; p; p = MSACM_UnregisterDriver(p));
    159139}
    160140
    … …  
    164144PWINE_ACMDRIVERID MSACM_GetDriverID(HACMDRIVERID hDriverID)
    165145{
    166   return (PWINE_ACMDRIVERID) hDriverID;
     146    return (PWINE_ACMDRIVERID)hDriverID;
    167147}
    168148
    … …  
    172152PWINE_ACMDRIVER MSACM_GetDriver(HACMDRIVER hDriver)
    173153{
    174   return (PWINE_ACMDRIVER) hDriver;
     154    return (PWINE_ACMDRIVER)hDriver;
    175155}
    176156
    … …  
    180160PWINE_ACMOBJ MSACM_GetObj(HACMOBJ hObj)
    181161{
    182   return (PWINE_ACMOBJ) hObj;
    183 }
    184 
    185 /***********************************************************************
    186  *           MSACM_OpenDriverProc32
    187  * FIXME
    188  *  This function should be integrated with OpenDriver,
    189  *  renamed and moved there.
    190  */
    191 HDRVR MSACM_OpenDriverProc(DRIVERPROC pfnDriverProc)
    192 {
    193 #if 0
    194   LPDRIVERITEMA pDrvr;
    195 
    196   /* FIXME: This is a very bad solution */
    197   pDrvr = (LPDRIVERITEMA) HeapAlloc(MSACM_hHeap, HEAP_ZERO_MEMORY, sizeof(DRIVERITEMA));
    198   pDrvr->count = 1;
    199   pDrvr->driverproc = pfnDriverProc;
    200  
    201   /* FIXME: Send DRV_OPEN among others to DriverProc */
    202 
    203   return (HDRVR) pDrvr;
    204 #else
    205   return (HDRVR) 0;
    206 #endif
     162    return (PWINE_ACMOBJ)hObj;
    207163}
    208164

  • trunk/src/msacm32/makefile

    r1585 r1607  
    1 # $Id: makefile,v 1.4 1999-11-03 23:28:05 sandervl Exp $
     1# $Id: makefile,v 1.5 1999-11-05 09:19:15 sandervl Exp $
    22
    33#
    … …  
    2121TARGET = msacm32
    2222
    23 OBJS =  msacm32.obj builtin.obj internal.obj initterm.obj
     23OBJS =  msacm32.obj filter.obj format.obj internal.obj \
     24        stream.obj driver.obj  initterm.obj
    2425
    2526all: $(TARGET).dll $(TARGET).lib
    … …  
    4041
    4142
     43msacm32.obj: msacm32.cpp
     44driver.obj: driver.cpp
     45filter.obj: filter.cpp
     46format.obj: format.cpp
     47internal.obj: internal.cpp
     48stream.obj: stream.cpp
    4249initterm.obj: initterm.cpp
    43 internal.obj: internal.cpp
    44 msacm32.obj: msacm32.cpp
    45 builtin.obj: builtin.cpp
     50
    4651
    4752clean:
    48         $(RM) *.obj *.lib *.dll *~ *.map *.pch
     53        $(RM) *.obj *.lib *.dll *.map *.pch
    4954        $(RM) $(PDWIN32_BIN)\$(TARGET).dll
    5055        $(RM) $(PDWIN32_LIB)\$(TARGET).lib

  • trunk/src/msacm32/msacm32.cpp

    r1118 r1607  
    1 /* $Id: msacm32.cpp,v 1.3 1999-10-04 09:55:58 sandervl Exp $ */
     1/* -*- tab-width: 8; c-basic-offset: 4 -*- */
     2
    23/*
    34 *      MSACM32 library
    45 *
    56 *      Copyright 1998  Patrik Stridvall
    6  *      Copyright 1999  Jens Wiessner
     7 *                1999  Eric Pouech
    78 */
    89
    910#include <os2win.h>
    10 #include <winerror.h>
    11 #include <windef.h>
    12 #include <winuser.h>
    13 #include <misc.h>
    14 #include <odinwrap.h>
     11#include "winbase.h"
     12#include "winerror.h"
     13#include "windef.h"
     14#include "debugtools.h"
    1515#include "msacm.h"
    1616#include "msacmdrv.h"
     17#include "wineacm.h"
    1718#include "winversion.h"
    18 #include "winreg.h"
    19 #include "debugtools.h"
    20 #include <debugdefs.h>
    21 
    2219
    2320DEFAULT_DEBUG_CHANNEL(msacm)
    24 
     21       
    2522/**********************************************************************/
    26 
     23       
    2724static DWORD MSACM_dwProcessesAttached = 0;
    2825
    … …  
    3027 *           MSACM_LibMain32 (MSACM32.init)
    3128 */
    32 BOOL WINAPI MSACM32_LibMain(
    33   HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
     29BOOL WINAPI MSACM32_LibMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpvReserved)
    3430{
    35   switch(fdwReason)
    36     {
     31    dprintf(("0x%x 0x%lx %p\n", hInstDLL, fdwReason, lpvReserved));
     32
     33    switch (fdwReason) {
    3734    case DLL_PROCESS_ATTACH:
    38       if(MSACM_dwProcessesAttached == 0)
    39         {
    40           MSACM_hHeap = HeapCreate(0, 0x10000, 0);
    41           MSACM_RegisterAllDrivers();
     35        if (MSACM_dwProcessesAttached == 0) {
     36            MSACM_hHeap = HeapCreate(0, 0x10000, 0);
     37            MSACM_RegisterAllDrivers();
    4238        }
    43       MSACM_dwProcessesAttached++;
    44       break;
     39        MSACM_dwProcessesAttached++;
     40        break;
    4541    case DLL_PROCESS_DETACH:
    46       MSACM_dwProcessesAttached--;
    47       if(MSACM_dwProcessesAttached == 0)
    48         {
    49           MSACM_UnregisterAllDrivers();
    50           HeapDestroy(MSACM_hHeap);
    51           MSACM_hHeap = (HANDLE) NULL;
     42        MSACM_dwProcessesAttached--;
     43        if (MSACM_dwProcessesAttached == 0) {
     44            MSACM_UnregisterAllDrivers();
     45            HeapDestroy(MSACM_hHeap);
     46            MSACM_hHeap = (HANDLE) NULL;
    5247        }
    53       break;
     48        break;
    5449    case DLL_THREAD_ATTACH:
    55       break;
     50        break;
    5651    case DLL_THREAD_DETACH:
    57       break;
     52        break;
    5853    default:
    59       break;
     54        break;
    6055    }
    61   return TRUE;
     56    return TRUE;
    6257}
    6358
    … …  
    6964
    7065/***********************************************************************
    71  *           acmDriverAddA (MSACM32.2)
     66 *           acmGetVersion32 (MSACM32.34)
    7267 */
    73 MMRESULT WINAPI acmDriverAddA(
    74   PHACMDRIVERID phadid, HINSTANCE hinstModule,
    75   LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
     68DWORD WINAPI acmGetVersion(void)
    7669{
    77 #ifdef DEBUG
    78   dprintf(("MSACM32: acmDriverAddA\n"));
    79 #endif
    80   PWINE_ACMLOCALDRIVER pld;
    81   if(!phadid)
    82     return MMSYSERR_INVALPARAM;
    83 
    84   /* Check if any unknown flags */
    85   if(fdwAdd &
    86      ~(ACM_DRIVERADDF_FUNCTION|ACM_DRIVERADDF_NOTIFYHWND|
    87        ACM_DRIVERADDF_GLOBAL))
    88     return MMSYSERR_INVALFLAG;
    89 
    90   /* Check if any incompatible flags */
    91   if((fdwAdd & ACM_DRIVERADDF_FUNCTION) &&
    92      (fdwAdd & ACM_DRIVERADDF_NOTIFYHWND))
    93     return MMSYSERR_INVALFLAG;
    94 
    95   pld = (PWINE_ACMLOCALDRIVER) HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMLOCALDRIVER));
    96   pld->pfnDriverProc = (DRIVERPROC)
    97     GetProcAddress(hinstModule, "DriverProc");
    98   *phadid = (HACMDRIVERID) MSACM_RegisterDriver(NULL, NULL, pld);
    99 
    100   /* FIXME: lParam, dwPriority and fdwAdd ignored */
    101 
    102   return MMSYSERR_NOERROR;
    103 }
    104 
    105 /***********************************************************************
    106  *           acmDriverAddW (MSACM32.3)
    107  * FIXME
    108  *   Not implemented
    109  */
    110 MMRESULT WINAPI acmDriverAddW(
    111   PHACMDRIVERID phadid, HINSTANCE hinstModule,
    112   LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
    113 {
    114 #ifdef DEBUG
    115   dprintf(("MSACM32: acmDriverAddW not implemented\n"));
    116 #endif
    117   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    118   return MMSYSERR_ERROR;
    119 }
    120 
    121 /***********************************************************************
    122  *           acmDriverClose (MSACM32.4)
    123  */
    124 MMRESULT WINAPI acmDriverClose(
    125   HACMDRIVER had, DWORD fdwClose)
    126 {
    127 #ifdef DEBUG
    128   dprintf(("MSACM32: acmDriverClose\n"));
    129 #endif
    130   PWINE_ACMDRIVER p;
    131 
    132   if(fdwClose)
    133     return MMSYSERR_INVALFLAG;
    134 
    135   p = MSACM_GetDriver(had);
    136   if(!p)
    137     return MMSYSERR_INVALHANDLE;
    138 
    139   p->obj.pACMDriverID->pACMDriver = NULL;
    140 
    141   if(p->hDrvr)
    142     CloseDriver(p->hDrvr, 0, 0);
    143 
    144   HeapFree(MSACM_hHeap, 0, p);
    145 
    146   return MMSYSERR_NOERROR;
    147 }
    148 
    149 /***********************************************************************
    150  *           acmDriverDetailsA (MSACM32.5)
    151  */
    152 MMRESULT WINAPI acmDriverDetailsA(
    153   HACMDRIVERID hadid, PACMDRIVERDETAILSA padd, DWORD fdwDetails)
    154 {
    155 #ifdef DEBUG
    156   dprintf(("MSACM32: acmDriverDetailsA\n"));
    157 #endif
    158   PWINE_ACMDRIVERID p;
    159   MMRESULT mmr;
    160   BOOL bOpenTemporary;
    161 
    162   p = MSACM_GetDriverID(hadid);
    163   if(!p)
    164     return MMSYSERR_INVALHANDLE;
    165  
    166   if(fdwDetails)
    167     return MMSYSERR_INVALFLAG;
    168 
    169   bOpenTemporary = !p->pACMDriver;
    170   if(bOpenTemporary) {
    171     bOpenTemporary = TRUE;
    172     acmDriverOpen((PHACMDRIVER) &p->pACMDriver, hadid, 0);
    173   }
    174  
    175   /* FIXME
    176    *   How does the driver know if the ANSI or
    177    *   the UNICODE variant of PACMDRIVERDETAILS is used?
    178    *   It might check cbStruct or does it only accept ANSI.
    179    */
    180   mmr = (MMRESULT) acmDriverMessage(
    181     (HACMDRIVER) p->pACMDriver, ACMDM_DRIVER_DETAILS,
    182     (LPARAM) padd,  0
    183   );
    184 
    185   if(bOpenTemporary) {
    186     acmDriverClose((HACMDRIVER) p->pACMDriver, 0);
    187     p->pACMDriver = NULL;
    188   }
    189 
    190   return mmr;
    191 }
    192 
    193 /***********************************************************************
    194  *           acmDriverDetailsW (MSACM32.6)
    195  * FIXME
    196  *   Not implemented
    197  */
    198 MMRESULT WINAPI acmDriverDetailsW(
    199   HACMDRIVERID hadid, PACMDRIVERDETAILSW padd, DWORD fdwDetails)
    200 {
    201 #ifdef DEBUG
    202   dprintf(("MSACM32: acmDriverDetailsW not implemented\n"));
    203 #endif
    204   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    205   return MMSYSERR_ERROR;
    206 }
    207 
    208 /***********************************************************************
    209  *           acmDriverEnum (MSACM32.7)
    210  */
    211 MMRESULT WINAPI acmDriverEnum(
    212   ACMDRIVERENUMCB fnCallback, DWORD dwInstance, DWORD fdwEnum)
    213 {
    214 #ifdef DEBUG
    215   dprintf(("MSACM32: acmDriverEnum\n"));
    216 #endif
    217   PWINE_ACMDRIVERID p;
    218 
    219   if(!fnCallback)
    220     {
    221       return MMSYSERR_INVALPARAM;
    222     }
    223 
    224   if(fdwEnum && ~(ACM_DRIVERENUMF_NOLOCAL|ACM_DRIVERENUMF_DISABLED))
    225     {
    226       return MMSYSERR_INVALFLAG;
    227     }
    228 
    229   p = MSACM_pFirstACMDriverID;
    230   while(p)
    231     {
    232       (*fnCallback)((HACMDRIVERID) p, dwInstance, ACMDRIVERDETAILS_SUPPORTF_CODEC);
    233       p = p->pNextACMDriverID;
    234     }
    235 
    236   return MMSYSERR_NOERROR;
    237 }
    238 
    239 /***********************************************************************
    240  *           acmDriverID (MSACM32.8)
    241  */
    242 MMRESULT WINAPI acmDriverID(
    243   HACMOBJ hao, PHACMDRIVERID phadid, DWORD fdwDriverID)
    244 {
    245 #ifdef DEBUG
    246   dprintf(("MSACM32: acmDriverID\n"));
    247 #endif
    248   PWINE_ACMOBJ pao;
    249 
    250   pao = MSACM_GetObj(hao);
    251   if(!pao)
    252     return MMSYSERR_INVALHANDLE;
    253 
    254   if(!phadid)
    255     return MMSYSERR_INVALPARAM;
    256 
    257   if(fdwDriverID)
    258     return MMSYSERR_INVALFLAG;
    259 
    260   *phadid = (HACMDRIVERID) pao->pACMDriverID;
    261 
    262   return MMSYSERR_NOERROR;
    263 }
    264 
    265 /***********************************************************************
    266  *           acmDriverMessage (MSACM32.9)
    267  * FIXME
    268  *   Not implemented
    269  */
    270 LRESULT WINAPI acmDriverMessage(
    271   HACMDRIVER had, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
    272 {
    273 #ifdef DEBUG
    274   dprintf(("MSACM32: acmDriverMessage not implemented\n"));
    275 #endif
    276   PWINE_ACMDRIVER pad = MSACM_GetDriver(had);
    277   if(!pad)
    278     return MMSYSERR_INVALPARAM;
    279 
    280   /* FIXME: Check if uMsg legal */
    281 
    282   if(!SendDriverMessage(pad->hDrvr, uMsg, lParam1, lParam2))
    283     return MMSYSERR_NOTSUPPORTED;
    284 
    285   return MMSYSERR_NOERROR;
    286 }
    287 
    288 
    289 /***********************************************************************
    290  *           acmDriverOpen (MSACM32.10)
    291  */
    292 MMRESULT WINAPI acmDriverOpen(
    293   PHACMDRIVER phad, HACMDRIVERID hadid, DWORD fdwOpen)
    294 {
    295 #ifdef DEBUG
    296   dprintf(("MSACM32: acmDriverOpen\n"));
    297 #endif
    298   PWINE_ACMDRIVERID padid;
    299 
    300   if(!phad)
    301     return MMSYSERR_INVALPARAM;
    302 
    303   padid = MSACM_GetDriverID(hadid);
    304   if(!padid)
    305     return MMSYSERR_INVALHANDLE;
    306 
    307   if(fdwOpen)
    308     return MMSYSERR_INVALFLAG;
    309 
    310   if(padid->pACMDriver)
    311     {
    312       /* FIXME: Is it allowed? */
    313       return MMSYSERR_ERROR;
    314     }
    315 
    316   padid->pACMDriver = (PWINE_ACMDRIVER) HeapAlloc(
    317     MSACM_hHeap, 0, sizeof(WINE_ACMDRIVER)
    318   );
    319   padid->pACMDriver->obj.pACMDriverID = padid;
    320  
    321   if(!padid->pACMLocalDriver)
    322       padid->pACMDriver->hDrvr =
    323         OpenDriverA(padid->pszDriverAlias, "drivers32", 0);
    324   else
    325     {
    326       padid->pACMDriver->hDrvr = MSACM_OpenDriverProc(
    327         padid->pACMLocalDriver->pfnDriverProc
    328       );
    329     }
    330 
    331   if(!padid->pACMDriver->hDrvr)
    332     return MMSYSERR_ERROR;
    333  
    334   /* FIXME: Create a WINE_ACMDRIVER32 */
    335   *phad = (HACMDRIVER) NULL;
    336 
    337   return MMSYSERR_ERROR;
    338 }
    339 
    340 /***********************************************************************
    341  *           acmDriverPriority (MSACM32.11)
    342  */
    343 MMRESULT WINAPI acmDriverPriority(
    344   HACMDRIVERID hadid, DWORD dwPriority, DWORD fdwPriority)
    345 {
    346 #ifdef DEBUG
    347   dprintf(("MSACM32: acmDriverPriority\n"));
    348 #endif
    349   PWINE_ACMDRIVERID padid;
    350   CHAR szSubKey[17];
    351   CHAR szBuffer[256];
    352   LONG lBufferLength = sizeof(szBuffer);
    353   LONG lError;
    354   HKEY hPriorityKey;
    355   DWORD dwPriorityCounter;
    356 
    357   padid = MSACM_GetDriverID(hadid);
    358   if(!padid)
    359     return MMSYSERR_INVALHANDLE;
    360 
    361   /* Check for unknown flags */
    362   if(fdwPriority &
    363      ~(ACM_DRIVERPRIORITYF_ENABLE|ACM_DRIVERPRIORITYF_DISABLE|
    364        ACM_DRIVERPRIORITYF_BEGIN|ACM_DRIVERPRIORITYF_END))
    365     return MMSYSERR_INVALFLAG;
    366 
    367   /* Check for incompatible flags */
    368   if((fdwPriority & ACM_DRIVERPRIORITYF_ENABLE) &&
    369     (fdwPriority & ACM_DRIVERPRIORITYF_DISABLE))
    370     return MMSYSERR_INVALFLAG;
    371 
    372   /* Check for incompatible flags */
    373   if((fdwPriority & ACM_DRIVERPRIORITYF_BEGIN) &&
    374     (fdwPriority & ACM_DRIVERPRIORITYF_END))
    375     return MMSYSERR_INVALFLAG;
    376 
    377   lError = RegOpenKeyA(HKEY_CURRENT_USER,
    378     "Software\\Microsoft\\Multimedia\\"
    379       "Audio Compression Manager\\Priority v4.00",
    380     &hPriorityKey
    381   );
    382   /* FIXME: Create key */
    383   if(lError != ERROR_SUCCESS)
    384     return MMSYSERR_ERROR;
    385 
    386   for(dwPriorityCounter = 1; ; dwPriorityCounter++)
    387   {
    388 //
    389 // FIXME ODIN   wsnprintfA(szSubKey, 17, "Priorty%ld", dwPriorityCounter);
    390 //
    391     lError = RegQueryValueA(hPriorityKey, szSubKey, szBuffer, &lBufferLength);
    392     if(lError != ERROR_SUCCESS)
    393       break;
    394 
    395     break;
    396   }
    397 
    398   RegCloseKey(hPriorityKey);
    399 
    400   return MMSYSERR_ERROR;
    401 }
    402 
    403 /***********************************************************************
    404  *           acmDriverRemove (MSACM32.12)
    405  */
    406 MMRESULT WINAPI acmDriverRemove(
    407   HACMDRIVERID hadid, DWORD fdwRemove)
    408 {
    409 #ifdef DEBUG
    410   dprintf(("MSACM32: acmDriverRemove\n"));
    411 #endif
    412   PWINE_ACMDRIVERID padid;
    413 
    414   padid = MSACM_GetDriverID(hadid);
    415   if(!padid)
    416     return MMSYSERR_INVALHANDLE;
    417 
    418   if(fdwRemove)
    419     return MMSYSERR_INVALFLAG;
    420 
    421   MSACM_UnregisterDriver(padid);
    422 
    423   return MMSYSERR_NOERROR;
    424 }
    425 
    426 /***********************************************************************
    427  *           acmFilterChooseA (MSACM32.13)
    428  */
    429 MMRESULT WINAPI acmFilterChooseA(
    430   PACMFILTERCHOOSEA pafltrc)
    431 {
    432 #ifdef DEBUG
    433   dprintf(("MSACM32: acmDriverChooseA not implemented\n"));
    434 #endif
    435   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    436   return MMSYSERR_ERROR;
    437 }
    438 
    439 /***********************************************************************
    440  *           acmFilterChooseW (MSACM32.14)
    441  */
    442 MMRESULT WINAPI acmFilterChooseW(
    443   PACMFILTERCHOOSEW pafltrc)
    444 {
    445 #ifdef DEBUG
    446   dprintf(("MSACM32: acmDriverChooseW not implemented\n"));
    447 #endif
    448   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    449   return MMSYSERR_ERROR;
    450 }
    451 
    452 /***********************************************************************
    453  *           acmFilterDetailsA (MSACM32.15)
    454  */
    455 MMRESULT WINAPI acmFilterDetailsA(
    456   HACMDRIVER had, PACMFILTERDETAILSA pafd, DWORD fdwDetails)
    457 {
    458 #ifdef DEBUG
    459   dprintf(("MSACM32: acmFilterDetailsA\n"));
    460 #endif
    461   if(fdwDetails & ~(ACM_FILTERDETAILSF_FILTER))
    462     return MMSYSERR_INVALFLAG;
    463 
    464   /* FIXME
    465    *   How does the driver know if the ANSI or
    466    *   the UNICODE variant of PACMFILTERDETAILS is used?
    467    *   It might check cbStruct or does it only accept ANSI.
    468    */
    469   return (MMRESULT) acmDriverMessage(
    470     had, ACMDM_FILTER_DETAILS,
    471     (LPARAM) pafd,  (LPARAM) fdwDetails
    472   );
    473 }
    474 
    475 /***********************************************************************
    476  *           acmFilterDetailsW (MSACM32.16)
    477  */
    478 MMRESULT WINAPI acmFilterDetailsW(
    479   HACMDRIVER had, PACMFILTERDETAILSW pafd, DWORD fdwDetails)
    480 {
    481 #ifdef DEBUG
    482   dprintf(("MSACM32: acmFilterDetailsW not implemented\n"));
    483 #endif
    484   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    485   return MMSYSERR_ERROR;
    486 }
    487 
    488 /***********************************************************************
    489  *           acmFilterEnumA (MSACM32.17)
    490  */
    491 MMRESULT WINAPI acmFilterEnumA(
    492   HACMDRIVER had, PACMFILTERDETAILSA pafd,
    493   ACMFILTERENUMCBA fnCallback, DWORD dwInstance, DWORD fdwEnum)
    494 {
    495 #ifdef DEBUG
    496   dprintf(("MSACM32: acmFilterEnumA not implemented\n"));
    497 #endif
    498   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    499   return MMSYSERR_ERROR;
    500 }
    501 
    502 /***********************************************************************
    503  *           acmFilterEnumW (MSACM32.18)
    504  */
    505 MMRESULT WINAPI acmFilterEnumW(
    506   HACMDRIVER had, PACMFILTERDETAILSW pafd,
    507   ACMFILTERENUMCBW fnCallback, DWORD dwInstance, DWORD fdwEnum)
    508 {
    509 #ifdef DEBUG
    510   dprintf(("MSACM32: acmFilterEnumW not implemented\n"));
    511 #endif
    512   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    513   return MMSYSERR_ERROR;
    514 }
    515 
    516 /***********************************************************************
    517  *           acmFilterTagDetailsA (MSACM32.19)
    518  */
    519 MMRESULT WINAPI acmFilterTagDetailsA(
    520   HACMDRIVER had, PACMFILTERTAGDETAILSA paftd, DWORD fdwDetails)
    521 {
    522 #ifdef DEBUG
    523   dprintf(("MSACM32: acmFilterTagDetailsA\n"));
    524 #endif
    525   if(fdwDetails &
    526      ~(ACM_FILTERTAGDETAILSF_FILTERTAG|
    527        ACM_FILTERTAGDETAILSF_LARGESTSIZE))
    528     return MMSYSERR_INVALFLAG;
    529 
    530   /* FIXME
    531    *   How does the driver know if the ANSI or
    532    *   the UNICODE variant of PACMFILTERTAGDETAILS is used?
    533    *   It might check cbStruct or does it only accept ANSI.
    534    */
    535   return (MMRESULT) acmDriverMessage(
    536     had, ACMDM_FILTERTAG_DETAILS,
    537     (LPARAM) paftd,  (LPARAM) fdwDetails
    538   );
    539 }
    540 
    541 /***********************************************************************
    542  *           acmFilterTagDetailsW (MSACM32.20)
    543  */
    544 MMRESULT WINAPI acmFilterTagDetailsW(
    545   HACMDRIVER had, PACMFILTERTAGDETAILSW paftd, DWORD fdwDetails)
    546 {
    547 #ifdef DEBUG
    548   dprintf(("MSACM32: acmFilterTagDetailsW not implemented\n"));
    549 #endif
    550   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    551   return MMSYSERR_ERROR;
    552 }
    553 
    554 /***********************************************************************
    555  *           acmFilterTagEnumA (MSACM32.21)
    556  */
    557 MMRESULT WINAPI acmFilterTagEnumA(
    558   HACMDRIVER had, PACMFILTERTAGDETAILSA  paftd,
    559   ACMFILTERTAGENUMCBA fnCallback, DWORD dwInstance, DWORD fdwEnum)
    560 {
    561 #ifdef DEBUG
    562   dprintf(("MSACM32: acmFilterTagEnumA not implemented\n"));
    563 #endif
    564   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    565   return MMSYSERR_ERROR;
    566 }
    567 
    568 /***********************************************************************
    569  *           acmFilterTagEnumW (MSACM32.22)
    570  */
    571 MMRESULT WINAPI acmFilterTagEnumW(
    572   HACMDRIVER had, PACMFILTERTAGDETAILSW paftd,
    573   ACMFILTERTAGENUMCBW fnCallback, DWORD dwInstance, DWORD fdwEnum)
    574 {
    575 #ifdef DEBUG
    576   dprintf(("MSACM32: acmFilterTagEnumW not implemented\n"));
    577 #endif
    578   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    579   return MMSYSERR_ERROR;
    580 }
    581 
    582 /***********************************************************************
    583  *           acmFormatChooseA (MSACM32.23)
    584  */
    585 MMRESULT WINAPI acmFormatChooseA(
    586   PACMFORMATCHOOSEA pafmtc)
    587 {
    588 #ifdef DEBUG
    589   dprintf(("MSACM32: acmFormatChooseA not implemented\n"));
    590 #endif
    591   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    592   return MMSYSERR_ERROR;
    593 }
    594 
    595 /***********************************************************************
    596  *           acmFormatChooseW (MSACM32.24)
    597  */
    598 MMRESULT WINAPI acmFormatChooseW(
    599   PACMFORMATCHOOSEW pafmtc)
    600 {
    601 #ifdef DEBUG
    602   dprintf(("MSACM32: acmFormatChooseW not implemented\n"));
    603 #endif
    604   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    605   return MMSYSERR_ERROR;
    606 }
    607 
    608 /***********************************************************************
    609  *           acmFormatDetailsA (MSACM32.25)
    610  */
    611 MMRESULT WINAPI acmFormatDetailsA(
    612   HACMDRIVER had, PACMFORMATDETAILSA pafd, DWORD fdwDetails)
    613 {
    614 #ifdef DEBUG
    615   dprintf(("MSACM32: acmFormatDetailsA\n"));
    616 #endif
    617   if(fdwDetails & ~(ACM_FORMATDETAILSF_FORMAT))
    618     return MMSYSERR_INVALFLAG;
    619 
    620   /* FIXME
    621    *   How does the driver know if the ANSI or
    622    *   the UNICODE variant of PACMFORMATDETAILS is used?
    623    *   It might check cbStruct or does it only accept ANSI.
    624    */
    625   return (MMRESULT) acmDriverMessage(
    626     had, ACMDM_FORMAT_DETAILS,
    627     (LPARAM) pafd,  (LPARAM) fdwDetails
    628   );
    629 }
    630 
    631 /***********************************************************************
    632  *           acmFormatDetailsW (MSACM32.26)
    633  */
    634 MMRESULT WINAPI acmFormatDetailsW(
    635   HACMDRIVER had, PACMFORMATDETAILSW pafd, DWORD fdwDetails)
    636 {
    637 #ifdef DEBUG
    638   dprintf(("MSACM32: acmFormatDetailsW not implemented\n"));
    639 #endif
    640   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    641   return MMSYSERR_ERROR;
    642 }
    643 
    644 /***********************************************************************
    645  *           acmFormatEnumA (MSACM32.27)
    646  */
    647 MMRESULT WINAPI acmFormatEnumA(
    648   HACMDRIVER had, PACMFORMATDETAILSA pafd,
    649   ACMFORMATENUMCBA fnCallback, DWORD dwInstance, DWORD fdwEnum)
    650 {
    651 #ifdef DEBUG
    652   dprintf(("MSACM32: acmFormatEnumA not implemented\n"));
    653 #endif
    654   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    655   return MMSYSERR_ERROR;
    656 }
    657 
    658 /***********************************************************************
    659  *           acmFormatEnumW (MSACM32.28)
    660  */
    661 MMRESULT WINAPI acmFormatEnumW(
    662   HACMDRIVER had, PACMFORMATDETAILSW pafd,
    663   ACMFORMATENUMCBW fnCallback, DWORD dwInstance,  DWORD fdwEnum)
    664 {
    665 #ifdef DEBUG
    666   dprintf(("MSACM32: acmFormatEnumW not implemented\n"));
    667 #endif
    668   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    669   return MMSYSERR_ERROR;
    670 }
    671 
    672 /***********************************************************************
    673  *           acmFormatSuggest (MSACM32.29)
    674  */
    675 MMRESULT WINAPI acmFormatSuggest(
    676   HACMDRIVER had, PWAVEFORMATEX pwfxSrc, PWAVEFORMATEX pwfxDst,
    677   DWORD cbwfxDst, DWORD fdwSuggest)
    678 {
    679 #ifdef DEBUG
    680   dprintf(("MSACM32: acmFormatSuggest not implemented\n"));
    681 #endif
    682   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    683   return MMSYSERR_ERROR;
    684 }
    685 
    686 /***********************************************************************
    687  *           acmFormatTagDetailsA (MSACM32.30)
    688  */
    689 MMRESULT WINAPI acmFormatTagDetailsA(
    690   HACMDRIVER had, PACMFORMATTAGDETAILSA paftd, DWORD fdwDetails)
    691 {
    692 #ifdef DEBUG
    693   dprintf(("MSACM32: acmFormatTagDetailsA\n"));
    694 #endif
    695   if(fdwDetails &
    696      ~(ACM_FORMATTAGDETAILSF_FORMATTAG|ACM_FORMATTAGDETAILSF_LARGESTSIZE))
    697     return MMSYSERR_INVALFLAG;
    698 
    699   /* FIXME
    700    *   How does the driver know if the ANSI or
    701    *   the UNICODE variant of PACMFORMATTAGDETAILS is used?
    702    *   It might check cbStruct or does it only accept ANSI.
    703    */
    704   return (MMRESULT) acmDriverMessage(
    705     had, ACMDM_FORMATTAG_DETAILS,
    706     (LPARAM) paftd,  (LPARAM) fdwDetails
    707   );
    708 }
    709 
    710 /***********************************************************************
    711  *           acmFormatTagDetailsW (MSACM32.31)
    712  */
    713 MMRESULT WINAPI acmFormatTagDetailsW(
    714   HACMDRIVER had, PACMFORMATTAGDETAILSW paftd, DWORD fdwDetails)
    715 {
    716 #ifdef DEBUG
    717   dprintf(("MSACM32: acmFormatTagDetailsW not implemented\n"));
    718 #endif
    719   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    720   return MMSYSERR_ERROR;
    721 }
    722 
    723 /***********************************************************************
    724  *           acmFormatTagEnumA (MSACM32.32)
    725  */
    726 MMRESULT WINAPI acmFormatTagEnumA(
    727   HACMDRIVER had, PACMFORMATTAGDETAILSA paftd,
    728   ACMFORMATTAGENUMCBA fnCallback, DWORD dwInstance, DWORD fdwEnum)
    729 {
    730 #ifdef DEBUG
    731   dprintf(("MSACM32: acmFormatTagEnumA not implemented\n"));
    732 #endif
    733   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    734   return MMSYSERR_ERROR;
    735 }
    736 
    737 /***********************************************************************
    738  *           acmFormatTagEnumW (MSACM32.33)
    739  */
    740 MMRESULT WINAPI acmFormatTagEnumW(
    741   HACMDRIVER had, PACMFORMATTAGDETAILSW paftd,
    742   ACMFORMATTAGENUMCBW fnCallback, DWORD dwInstance, DWORD fdwEnum)
    743 {
    744 #ifdef DEBUG
    745   dprintf(("MSACM32: acmFormatTagEnumW not implemented\n"));
    746 #endif
    747   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    748   return MMSYSERR_ERROR;
    749 }
    750 
    751 /***********************************************************************
    752  *           acmGetVersion (MSACM32.34)
    753  */
    754 DWORD WINAPI acmGetVersion()
    755 {
    756 #ifdef DEBUG
    757   dprintf(("MSACM32: acmGetVersion\n"));
    758 #endif
    759   switch(GetVersion())
    760     {
     70    switch (GetVersion()) {
    76171    default:
    762 //
     72        dprintf(("OS not supported\n"));
    76373    case WIN95:
    764       return 0x04000000; /* 4.0.0 */
     74        return 0x04000000; /* 4.0.0 */
    76575    case NT40:
    766       return 0x04000565; /* 4.0.1381 */
     76        return 0x04000565; /* 4.0.1381 */
    76777    }
    76878}
    76979
    77080/***********************************************************************
    771  *           acmMessage (MSACM32.35)
     81 *           acmMessage32 (MSACM32.35)
    77282 * FIXME
    77383 *   No documentation found.
    … …  
    77787 *           acmMetrics (MSACM32.36)
    77888 */
    779 MMRESULT WINAPI acmMetrics(
    780   HACMOBJ hao, UINT uMetric, LPVOID  pMetric)
     89MMRESULT WINAPI acmMetrics(HACMOBJ hao, UINT uMetric, LPVOID  pMetric)
    78190{
    782 #ifdef DEBUG
    783   dprintf(("MSACM32: acmMetrics\n"));
    784 #endif
    785   PWINE_ACMOBJ pao = MSACM_GetObj(hao);
    786   BOOL bLocal = TRUE;
    787 
    788   switch(uMetric)
    789     {
     91    PWINE_ACMOBJ pao = MSACM_GetObj(hao);
     92    BOOL bLocal = TRUE;
     93   
     94    dprintf(("(0x%08x, %d, %p): stub\n", hao, uMetric, pMetric));
     95   
     96    switch (uMetric) {
    79097    case ACM_METRIC_COUNT_DRIVERS:
    791       bLocal = FALSE;
     98        bLocal = FALSE;
    79299    case ACM_METRIC_COUNT_LOCAL_DRIVERS:
    793       if(!pao)
    794         return MMSYSERR_INVALHANDLE; 
    795       return MMSYSERR_NOTSUPPORTED;
     100        if (!pao)
     101            return MMSYSERR_INVALHANDLE; 
     102        return MMSYSERR_NOTSUPPORTED;
    796103    case ACM_METRIC_COUNT_CODECS:
    797       bLocal = FALSE;
     104        bLocal = FALSE;
    798105    case ACM_METRIC_COUNT_LOCAL_CODECS:
    799       return MMSYSERR_NOTSUPPORTED;
     106        return MMSYSERR_NOTSUPPORTED;
    800107    case ACM_METRIC_COUNT_CONVERTERS:
    801       bLocal = FALSE;
     108        bLocal = FALSE;
    802109    case ACM_METRIC_COUNT_LOCAL_CONVERTERS:
    803       return MMSYSERR_NOTSUPPORTED;
     110        return MMSYSERR_NOTSUPPORTED;
    804111    case ACM_METRIC_COUNT_FILTERS:
    805       bLocal = FALSE;
     112        bLocal = FALSE;
    806113    case ACM_METRIC_COUNT_LOCAL_FILTERS:
    807       return MMSYSERR_NOTSUPPORTED;
     114        return MMSYSERR_NOTSUPPORTED;
    808115    case ACM_METRIC_COUNT_DISABLED:
    809       bLocal = FALSE;
     116        bLocal = FALSE;
    810117    case ACM_METRIC_COUNT_LOCAL_DISABLED:
    811       if(!pao)
    812         return MMSYSERR_INVALHANDLE; 
    813       return MMSYSERR_NOTSUPPORTED;
     118        if (!pao)
     119            return MMSYSERR_INVALHANDLE; 
     120        return MMSYSERR_NOTSUPPORTED;
    814121    case ACM_METRIC_COUNT_HARDWARE:
    815122    case ACM_METRIC_HARDWARE_WAVE_INPUT:
    … …  
    820127    case ACM_METRIC_DRIVER_PRIORITY:
    821128    default:
    822       return MMSYSERR_NOTSUPPORTED;
     129        return MMSYSERR_NOTSUPPORTED;
    823130    }
    824   return MMSYSERR_NOERROR;
     131    return MMSYSERR_NOERROR;
    825132}
    826 
    827 /***********************************************************************
    828  *           acmStreamClose (MSACM32.37)
    829  */
    830 MMRESULT WINAPI acmStreamClose(
    831   HACMSTREAM has, DWORD fdwClose)
    832 {
    833 #ifdef DEBUG
    834   dprintf(("MSACM32: acmStreamClose not implemented\n"));
    835 #endif
    836   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    837   return MMSYSERR_ERROR;
    838 }
    839 
    840 /***********************************************************************
    841  *           acmStreamConvert (MSACM32.38)
    842  */
    843 MMRESULT WINAPI acmStreamConvert(
    844   HACMSTREAM has, PACMSTREAMHEADER pash, DWORD fdwConvert)
    845 {
    846 #ifdef DEBUG
    847   dprintf(("MSACM32: acmStreamConvert not implemented\n"));
    848 #endif
    849   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    850   return MMSYSERR_ERROR;
    851 }
    852 
    853 /***********************************************************************
    854  *           acmStreamMessage (MSACM32.39)
    855  */
    856 MMRESULT WINAPI acmStreamMessage(
    857   HACMSTREAM has, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
    858 {
    859 #ifdef DEBUG
    860   dprintf(("MSACM32: acmStreamMessage not implemented\n"));
    861 #endif
    862   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    863   return MMSYSERR_ERROR;
    864 }
    865 
    866 /***********************************************************************
    867  *           acmStreamOpen (MSACM32.40)
    868  */
    869 MMRESULT WINAPI acmStreamOpen(
    870   PHACMSTREAM phas, HACMDRIVER had, PWAVEFORMATEX pwfxSrc,
    871   PWAVEFORMATEX pwfxDst, PWAVEFILTER pwfltr, DWORD dwCallback,
    872   DWORD dwInstance, DWORD fdwOpen)
    873 {
    874 #ifdef DEBUG
    875   dprintf(("MSACM32: acmStreamOpen not implemented\n"));
    876 #endif
    877   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    878   return MMSYSERR_ERROR;
    879 }
    880 
    881 
    882 /***********************************************************************
    883  *           acmStreamPrepareHeader (MSACM32.41)
    884  */
    885 MMRESULT WINAPI acmStreamPrepareHeader(
    886   HACMSTREAM has, PACMSTREAMHEADER pash, DWORD fdwPrepare)
    887 {
    888 #ifdef DEBUG
    889   dprintf(("MSACM32: acmStreamPrepareHeader not implemented\n"));
    890 #endif
    891   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    892   return MMSYSERR_ERROR;
    893 }
    894 
    895 /***********************************************************************
    896  *           acmStreamReset (MSACM32.42)
    897  */
    898 MMRESULT WINAPI acmStreamReset(
    899   HACMSTREAM has, DWORD fdwReset)
    900 {
    901 #ifdef DEBUG
    902   dprintf(("MSACM32: acmStreamReset not implemented\n"));
    903 #endif
    904   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    905   return MMSYSERR_ERROR;
    906 }
    907 
    908 /***********************************************************************
    909  *           acmStreamSize (MSACM32.43)
    910  */
    911 MMRESULT WINAPI acmStreamSize(
    912   HACMSTREAM has, DWORD cbInput,
    913   LPDWORD pdwOutputBytes, DWORD fdwSize)
    914 {
    915 #ifdef DEBUG
    916   dprintf(("MSACM32: acmStreamSize not implemented\n"));
    917 #endif
    918   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    919   return MMSYSERR_ERROR;
    920 }
    921 
    922 /***********************************************************************
    923  *           acmStreamUnprepareHeader (MSACM32.44)
    924  */
    925 MMRESULT WINAPI acmStreamUnprepareHeader(
    926   HACMSTREAM has, PACMSTREAMHEADER pash, DWORD fdwUnprepare)
    927 {
    928 #ifdef DEBUG
    929   dprintf(("MSACM32: acmStreamUnprepareHeader not implemented\n"));
    930 #endif
    931   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    932   return MMSYSERR_ERROR;
    933 }
Note: See TracChangeset for help on using the changeset viewer.