Changeset 6648 for trunk/src/msacm32

Timestamp:

Sep 5, 2001, 3:19:02 PM (24 years ago)

Author:

bird

Message:

Added $Id:$ keyword.

Location:

trunk/src/msacm32

Files:

• driver.c (modified) (14 diffs)
• filter.c (modified) (18 diffs)
• format.c (modified) (27 diffs)
• initterm.cpp (modified) (3 diffs)
• internal.c (modified) (7 diffs)
• msacm32_main.c (modified) (7 diffs)
• pcmconverter.c (modified) (31 diffs)
• stream.c (modified) (17 diffs)

trunk/src/msacm32/driver.c

@@ -1 +1 @@
 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
-
+/* $Id: driver.c,v 1.2 2001-09-05 13:11:25 bird Exp $ */
 /*
  *      MSACM32 library
  *
  *      Copyright 1998  Patrik Stridvall
- *                1999  Eric Pouech
+ *        1999  Eric Pouech
  */
 
@@ -29 +29 @@
 
 DEFAULT_DEBUG_CHANNEL(msacm);
-        
+
 /***********************************************************************
  *           acmDriverAddA (MSACM32.2)
  */
 MMRESULT WINAPI acmDriverAddA(PHACMDRIVERID phadid, HINSTANCE hinstModule,
-                              LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
+                  LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
 {
     if (!phadid)
-        return MMSYSERR_INVALPARAM;
-    
+    return MMSYSERR_INVALPARAM;
+
     /* Check if any unknown flags */
-    if (fdwAdd & 
-        ~(ACM_DRIVERADDF_FUNCTION|ACM_DRIVERADDF_NOTIFYHWND|
-          ACM_DRIVERADDF_GLOBAL))
-        return MMSYSERR_INVALFLAG;
-    
+    if (fdwAdd &
+    ~(ACM_DRIVERADDF_FUNCTION|ACM_DRIVERADDF_NOTIFYHWND|
+      ACM_DRIVERADDF_GLOBAL))
+    return MMSYSERR_INVALFLAG;
+
     /* Check if any incompatible flags */
-    if ((fdwAdd & ACM_DRIVERADDF_FUNCTION) && 
-        (fdwAdd & ACM_DRIVERADDF_NOTIFYHWND))
-        return MMSYSERR_INVALFLAG;
-    
-    /* FIXME: in fact, should GetModuleFileName(hinstModule) and do a 
+    if ((fdwAdd & ACM_DRIVERADDF_FUNCTION) &&
+    (fdwAdd & ACM_DRIVERADDF_NOTIFYHWND))
+    return MMSYSERR_INVALFLAG;
+
+    /* FIXME: in fact, should GetModuleFileName(hinstModule) and do a
      * LoadDriver on it, to be sure we can call SendDriverMessage on the
      * hDrvr handle.
      */
     *phadid = (HACMDRIVERID) MSACM_RegisterDriver(NULL, NULL, hinstModule);
-    
+
     /* FIXME: lParam, dwPriority and fdwAdd ignored */
-    
+
     return MMSYSERR_NOERROR;
 }
@@ -67 +67 @@
  */
 MMRESULT WINAPI acmDriverAddW(PHACMDRIVERID phadid, HINSTANCE hinstModule,
-                              LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
+                  LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
 {
     FIXME("(%p, 0x%08x, %ld, %ld, %ld): stub\n",
-          phadid, hinstModule, lParam, dwPriority, fdwAdd);
-    
+      phadid, hinstModule, lParam, dwPriority, fdwAdd);
+
     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     return MMSYSERR_ERROR;
@@ -81 +81 @@
 MMRESULT WINAPI acmDriverClose(HACMDRIVER had, DWORD fdwClose)
 {
-    PWINE_ACMDRIVER     pad;
-    PWINE_ACMDRIVERID   padid;
-    PWINE_ACMDRIVER*    tpad;
+    PWINE_ACMDRIVER pad;
+    PWINE_ACMDRIVERID   padid;
+    PWINE_ACMDRIVER*    tpad;
 
     if (fdwClose)
-        return MMSYSERR_INVALFLAG;
-    
+    return MMSYSERR_INVALFLAG;
+
     pad = MSACM_GetDriver(had);
     if (!pad)
-        return MMSYSERR_INVALHANDLE;
+    return MMSYSERR_INVALHANDLE;
 
     padid = pad->obj.pACMDriverID;
@@ -96 +96 @@
     /* remove driver from list */
     for (tpad = &(padid->pACMDriverList); *tpad; *tpad = (*tpad)->pNextACMDriver) {
-        if (*tpad == pad) {
-            *tpad = (*tpad)->pNextACMDriver;
-            break;
-        }
-    }
-    
+    if (*tpad == pad) {
+        *tpad = (*tpad)->pNextACMDriver;
+        break;
+    }
+    }
+
     /* close driver if it has been opened */
     if (pad->hDrvr && !padid->hInstModule)
-        CloseDriver(pad->hDrvr, 0, 0);
-    
+    CloseDriver(pad->hDrvr, 0, 0);
+
     HeapFree(MSACM_hHeap, 0, pad);
-    
+
     return MMSYSERR_NOERROR;
 }
@@ -117 +117 @@
 {
     MMRESULT mmr;
-    ACMDRIVERDETAILSW   addw;
-    
+    ACMDRIVERDETAILSW   addw;
+
     addw.cbStruct = sizeof(addw);
     mmr = acmDriverDetailsW(hadid, &addw, fdwDetails);
     if (mmr == 0) {
-        padd->fccType = addw.fccType; 
-        padd->fccComp = addw.fccComp; 
-        padd->wMid = addw.wMid; 
-        padd->wPid = addw.wPid; 
-        padd->vdwACM = addw.vdwACM; 
-        padd->vdwDriver = addw.vdwDriver; 
-        padd->fdwSupport = addw.fdwSupport; 
-        padd->cFormatTags = addw.cFormatTags; 
-        padd->cFilterTags = addw.cFilterTags; 
-        padd->hicon = addw.hicon; 
+    padd->fccType = addw.fccType;
+    padd->fccComp = addw.fccComp;
+    padd->wMid = addw.wMid;
+    padd->wPid = addw.wPid;
+    padd->vdwACM = addw.vdwACM;
+    padd->vdwDriver = addw.vdwDriver;
+    padd->fdwSupport = addw.fdwSupport;
+    padd->cFormatTags = addw.cFormatTags;
+    padd->cFilterTags = addw.cFilterTags;
+    padd->hicon = addw.hicon;
         WideCharToMultiByte( CP_ACP, 0, addw.szShortName, -1, padd->szShortName,
                              sizeof(padd->szShortName), NULL, NULL );
@@ -153 +153 @@
     HACMDRIVER acmDrvr;
     MMRESULT mmr;
-    
+
     if (fdwDetails)
-        return MMSYSERR_INVALFLAG;
-    
+    return MMSYSERR_INVALFLAG;
+
     mmr = acmDriverOpen(&acmDrvr, hadid, 0);
     if (mmr == MMSYSERR_NOERROR) {
-        mmr = (MMRESULT)MSACM_Message(acmDrvr, ACMDM_DRIVER_DETAILS, (LPARAM)padd,  0);
-    
-        acmDriverClose(acmDrvr, 0);
-    }
-    
+    mmr = (MMRESULT)MSACM_Message(acmDrvr, ACMDM_DRIVER_DETAILS, (LPARAM)padd,  0);
+
+    acmDriverClose(acmDrvr, 0);
+    }
+
     return mmr;
 }
@@ -172 +172 @@
 MMRESULT WINAPI acmDriverEnum(ACMDRIVERENUMCB fnCallback, DWORD dwInstance, DWORD fdwEnum)
 {
-    PWINE_ACMDRIVERID   p;
-    ACMDRIVERDETAILSW   add;
+    PWINE_ACMDRIVERID   p;
+    ACMDRIVERDETAILSW   add;
 
     if (!fnCallback) return MMSYSERR_INVALPARAM;
-    
+
     if (fdwEnum && ~(ACM_DRIVERENUMF_NOLOCAL|ACM_DRIVERENUMF_DISABLED))
-        return MMSYSERR_INVALFLAG;
-    
+    return MMSYSERR_INVALFLAG;
+
     add.cbStruct = sizeof(add);
     for (p = MSACM_pFirstACMDriverID; p; p = p->pNextACMDriverID) {
-        if (acmDriverDetailsW((HACMDRIVERID)p, &add, 0) != MMSYSERR_NOERROR)
-            continue;
-        if (!p->bEnabled) {
-            if (fdwEnum & ACM_DRIVERENUMF_DISABLED)
-                add.fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
-            else
-                continue;
-        }
-        if (!(*fnCallback)((HACMDRIVERID)p, dwInstance, add.fdwSupport))
-            break;
-    }
-    
+    if (acmDriverDetailsW((HACMDRIVERID)p, &add, 0) != MMSYSERR_NOERROR)
+        continue;
+    if (!p->bEnabled) {
+        if (fdwEnum & ACM_DRIVERENUMF_DISABLED)
+        add.fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
+        else
+        continue;
+    }
+    if (!(*fnCallback)((HACMDRIVERID)p, dwInstance, add.fdwSupport))
+        break;
+    }
+
     return MMSYSERR_NOERROR;
 }
@@ -203 +203 @@
 {
     PWINE_ACMOBJ pao;
-    
+
     if (!phadid)
-        return MMSYSERR_INVALPARAM;
-    
+    return MMSYSERR_INVALPARAM;
+
     if (fdwDriverID)
-        return MMSYSERR_INVALFLAG;
-    
+    return MMSYSERR_INVALFLAG;
+
     pao = MSACM_GetObj(hao, WINE_ACMOBJ_DONTCARE);
     if (!pao)
-        return MMSYSERR_INVALHANDLE;
-    
+    return MMSYSERR_INVALHANDLE;
+
     *phadid = (HACMDRIVERID) pao->pACMDriverID;
-    
+
     return MMSYSERR_NOERROR;
 }
@@ -226 +226 @@
 {
     if ((uMsg >= ACMDM_USER && uMsg < ACMDM_RESERVED_LOW) ||
-        uMsg == ACMDM_DRIVER_ABOUT ||
-        uMsg == DRV_QUERYCONFIGURE ||
-        uMsg == DRV_CONFIGURE)
-        return MSACM_Message(had, uMsg, lParam1, lParam2);
+    uMsg == ACMDM_DRIVER_ABOUT ||
+    uMsg == DRV_QUERYCONFIGURE ||
+    uMsg == DRV_CONFIGURE)
+    return MSACM_Message(had, uMsg, lParam1, lParam2);
     return MMSYSERR_INVALPARAM;
 }
@@ -239 +239 @@
 MMRESULT WINAPI acmDriverOpen(PHACMDRIVER phad, HACMDRIVERID hadid, DWORD fdwOpen)
 {
-    PWINE_ACMDRIVERID   padid;
-    PWINE_ACMDRIVER     pad;
+    PWINE_ACMDRIVERID   padid;
+    PWINE_ACMDRIVER pad;
 
     TRACE("(%p, %x, %08lu)\n", phad, hadid, fdwOpen);
 
     if (!phad)
-        return MMSYSERR_INVALPARAM;
-    
+    return MMSYSERR_INVALPARAM;
+
     if (fdwOpen)
-        return MMSYSERR_INVALFLAG;
-    
-    padid = MSACM_GetDriverID(hadid); 
+    return MMSYSERR_INVALFLAG;
+
+    padid = MSACM_GetDriverID(hadid);
     if (!padid)
-        return MMSYSERR_INVALHANDLE;
-    
+    return MMSYSERR_INVALHANDLE;
+
     pad = HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMDRIVER));
     if (!pad) return MMSYSERR_NOMEM;
@@ -259 +259 @@
     pad->obj.dwType = WINE_ACMOBJ_DRIVER;
     pad->obj.pACMDriverID = padid;
-    
+
     if (!(pad->hDrvr = padid->hInstModule) && padid->pszDriverAlias)
-        pad->hDrvr = OpenDriverA(padid->pszDriverAlias, NULL, 0);
+    pad->hDrvr = OpenDriverA(padid->pszDriverAlias, NULL, 0);
     if (!pad->hDrvr) {
-        HeapFree(MSACM_hHeap, 0, pad);
-        return MMSYSERR_ERROR;
+    HeapFree(MSACM_hHeap, 0, pad);
+    return MMSYSERR_ERROR;
     }
 
@@ -289 +289 @@
     HKEY hPriorityKey;
     DWORD dwPriorityCounter;
-    
+
     padid = MSACM_GetDriverID(hadid);
     if (!padid)
-        return MMSYSERR_INVALHANDLE;
-    
+    return MMSYSERR_INVALHANDLE;
+
     /* Check for unknown flags */
-    if (fdwPriority & 
-        ~(ACM_DRIVERPRIORITYF_ENABLE|ACM_DRIVERPRIORITYF_DISABLE|
-          ACM_DRIVERPRIORITYF_BEGIN|ACM_DRIVERPRIORITYF_END))
-        return MMSYSERR_INVALFLAG;
-    
+    if (fdwPriority &
+    ~(ACM_DRIVERPRIORITYF_ENABLE|ACM_DRIVERPRIORITYF_DISABLE|
+      ACM_DRIVERPRIORITYF_BEGIN|ACM_DRIVERPRIORITYF_END))
+    return MMSYSERR_INVALFLAG;
+
     /* Check for incompatible flags */
     if ((fdwPriority & ACM_DRIVERPRIORITYF_ENABLE) &&
-        (fdwPriority & ACM_DRIVERPRIORITYF_DISABLE))
-        return MMSYSERR_INVALFLAG;
-    
+    (fdwPriority & ACM_DRIVERPRIORITYF_DISABLE))
+    return MMSYSERR_INVALFLAG;
+
     /* Check for incompatible flags */
     if ((fdwPriority & ACM_DRIVERPRIORITYF_BEGIN) &&
-        (fdwPriority & ACM_DRIVERPRIORITYF_END))
-        return MMSYSERR_INVALFLAG;
-    
-    lError = RegOpenKeyA(HKEY_CURRENT_USER, 
-                         "Software\\Microsoft\\Multimedia\\"
-                         "Audio Compression Manager\\Priority v4.00",
-                         &hPriorityKey
-                         );
+    (fdwPriority & ACM_DRIVERPRIORITYF_END))
+    return MMSYSERR_INVALFLAG;
+
+    lError = RegOpenKeyA(HKEY_CURRENT_USER,
+             "Software\\Microsoft\\Multimedia\\"
+             "Audio Compression Manager\\Priority v4.00",
+             &hPriorityKey
+             );
     /* FIXME: Create key */
     if (lError != ERROR_SUCCESS)
-        return MMSYSERR_ERROR;
-    
-    for (dwPriorityCounter = 1; ; dwPriorityCounter++)  {
-        snprintf(szSubKey, 17, "Priorty%ld", dwPriorityCounter);
-        lError = RegQueryValueA(hPriorityKey, szSubKey, szBuffer, &lBufferLength);
-        if (lError != ERROR_SUCCESS)
-            break;
-        
-        FIXME("(0x%08x, %ld, %ld): stub (partial)\n", 
-              hadid, dwPriority, fdwPriority);
-        break;
-    }
-    
+    return MMSYSERR_ERROR;
+
+    for (dwPriorityCounter = 1; ; dwPriorityCounter++)  {
+    snprintf(szSubKey, 17, "Priorty%ld", dwPriorityCounter);
+    lError = RegQueryValueA(hPriorityKey, szSubKey, szBuffer, &lBufferLength);
+    if (lError != ERROR_SUCCESS)
+        break;
+
+    FIXME("(0x%08x, %ld, %ld): stub (partial)\n",
+          hadid, dwPriority, fdwPriority);
+    break;
+    }
+
     RegCloseKey(hPriorityKey);
-    
+
     return MMSYSERR_ERROR;
 }
@@ -341 +341 @@
 {
     PWINE_ACMDRIVERID padid;
-    
+
     padid = MSACM_GetDriverID(hadid);
     if (!padid)
-        return MMSYSERR_INVALHANDLE;
-    
+    return MMSYSERR_INVALHANDLE;
+
     if (fdwRemove)
-        return MMSYSERR_INVALFLAG;
-    
+    return MMSYSERR_INVALFLAG;
+
     MSACM_UnregisterDriver(padid);
-    
-    return MMSYSERR_NOERROR;
-}
-
+
+    return MMSYSERR_NOERROR;
+}
+

trunk/src/msacm32/filter.c

@@ -1 +1 @@
 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
-
+/* $Id: filter.c,v 1.2 2001-09-05 13:11:25 bird Exp $ */
 /*
  *      MSACM32 library
@@ -42 +42 @@
  *           acmFilterDetailsA (MSACM32.15)
  */
-MMRESULT WINAPI acmFilterDetailsA(HACMDRIVER had, PACMFILTERDETAILSA pafd, 
-                                  DWORD fdwDetails)
-{
-    ACMFILTERDETAILSW   afdw;
-    MMRESULT            mmr;
+MMRESULT WINAPI acmFilterDetailsA(HACMDRIVER had, PACMFILTERDETAILSA pafd,
+                  DWORD fdwDetails)
+{
+    ACMFILTERDETAILSW   afdw;
+    MMRESULT        mmr;
 
     memset(&afdw, 0, sizeof(afdw));
     afdw.cbStruct = sizeof(afdw);
     afdw.dwFilterIndex = pafd->dwFilterIndex;
-    afdw.dwFilterTag = pafd->dwFilterTag; 
+    afdw.dwFilterTag = pafd->dwFilterTag;
     afdw.pwfltr = pafd->pwfltr;
     afdw.cbwfltr = pafd->cbwfltr;
@@ -57 +57 @@
     mmr = acmFilterDetailsW(had, &afdw, fdwDetails);
     if (mmr == MMSYSERR_NOERROR) {
-        pafd->dwFilterTag = afdw.dwFilterTag; 
-        pafd->fdwSupport = afdw.fdwSupport; 
+    pafd->dwFilterTag = afdw.dwFilterTag;
+    pafd->fdwSupport = afdw.fdwSupport;
         WideCharToMultiByte( CP_ACP, 0, afdw.szFilter, -1, pafd->szFilter,
                              sizeof(pafd->szFilter), NULL, NULL );
@@ -68 +68 @@
  *           acmFilterDetailsW (MSACM32.16)
  */
-MMRESULT WINAPI acmFilterDetailsW(HACMDRIVER had, PACMFILTERDETAILSW pafd, 
-                                  DWORD fdwDetails)
-{
-    MMRESULT                    mmr;
-    ACMFILTERTAGDETAILSA        aftd;
+MMRESULT WINAPI acmFilterDetailsW(HACMDRIVER had, PACMFILTERDETAILSW pafd,
+                  DWORD fdwDetails)
+{
+    MMRESULT            mmr;
+    ACMFILTERTAGDETAILSA    aftd;
 
     TRACE("(0x%08x, %p, %ld)\n", had, pafd, fdwDetails);
@@ -80 +80 @@
 
     if (pafd->cbStruct < sizeof(*pafd)) return MMSYSERR_INVALPARAM;
-        
+
     switch (fdwDetails) {
     case ACM_FILTERDETAILSF_FILTER:
-        if (pafd->dwFilterTag != pafd->pwfltr->dwFilterTag) {
-            mmr = MMSYSERR_INVALPARAM;
-            break;
-        }
-        if (had == (HACMDRIVER)NULL) {
-            PWINE_ACMDRIVERID           padid;
-
-            mmr = ACMERR_NOTPOSSIBLE;
-            for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
-                /* should check for codec only */
-                if (padid->bEnabled && 
-                    acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
-                    mmr = MSACM_Message(had, ACMDM_FILTER_DETAILS,
-                                        (LPARAM)pafd, (LPARAM)fdwDetails);
-                    acmDriverClose(had, 0);
-                    if (mmr == MMSYSERR_NOERROR) break;
-                }
-            }               
-        } else {
-            mmr = MSACM_Message(had, ACMDM_FILTER_DETAILS,
-                                (LPARAM)pafd, (LPARAM)fdwDetails);
-        }
-        break;
+    if (pafd->dwFilterTag != pafd->pwfltr->dwFilterTag) {
+        mmr = MMSYSERR_INVALPARAM;
+        break;
+    }
+    if (had == (HACMDRIVER)NULL) {
+        PWINE_ACMDRIVERID       padid;
+
+        mmr = ACMERR_NOTPOSSIBLE;
+        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
+        /* should check for codec only */
+        if (padid->bEnabled &&
+            acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
+            mmr = MSACM_Message(had, ACMDM_FILTER_DETAILS,
+                    (LPARAM)pafd, (LPARAM)fdwDetails);
+            acmDriverClose(had, 0);
+            if (mmr == MMSYSERR_NOERROR) break;
+        }
+        }
+    } else {
+        mmr = MSACM_Message(had, ACMDM_FILTER_DETAILS,
+                (LPARAM)pafd, (LPARAM)fdwDetails);
+    }
+    break;
     case ACM_FILTERDETAILSF_INDEX:
-        /* should check pafd->dwFilterIndex < aftd->cStandardFilters */
-        mmr = MSACM_Message(had, ACMDM_FILTER_DETAILS,
-                            (LPARAM)pafd, (LPARAM)fdwDetails);
-        break;
+    /* should check pafd->dwFilterIndex < aftd->cStandardFilters */
+    mmr = MSACM_Message(had, ACMDM_FILTER_DETAILS,
+                (LPARAM)pafd, (LPARAM)fdwDetails);
+    break;
     default:
-        WARN("Unknown fdwDetails %08lx\n", fdwDetails);
-        mmr = MMSYSERR_INVALFLAG;
-        break;
+    WARN("Unknown fdwDetails %08lx\n", fdwDetails);
+    mmr = MMSYSERR_INVALFLAG;
+    break;
     }
 
@@ -122 +122 @@
 
 struct MSACM_FilterEnumWtoA_Instance {
-    PACMFILTERDETAILSA  pafda;
-    DWORD               dwInstance;
-    ACMFILTERENUMCBA    fnCallback;
+    PACMFILTERDETAILSA  pafda;
+    DWORD       dwInstance;
+    ACMFILTERENUMCBA    fnCallback;
 };
 
 static BOOL CALLBACK MSACM_FilterEnumCallbackWtoA(HACMDRIVERID hadid,
-                                                  PACMFILTERDETAILSW pafdw,  
-                                                  DWORD dwInstance,             
-                                                  DWORD fdwSupport)
+                          PACMFILTERDETAILSW pafdw,
+                          DWORD dwInstance,
+                          DWORD fdwSupport)
 {
     struct MSACM_FilterEnumWtoA_Instance* pafei;
@@ -136 +136 @@
     pafei = (struct MSACM_FilterEnumWtoA_Instance*)dwInstance;
 
-    pafei->pafda->dwFilterIndex = pafdw->dwFilterIndex; 
-    pafei->pafda->dwFilterTag = pafdw->dwFilterTag; 
-    pafei->pafda->fdwSupport = pafdw->fdwSupport; 
+    pafei->pafda->dwFilterIndex = pafdw->dwFilterIndex;
+    pafei->pafda->dwFilterTag = pafdw->dwFilterTag;
+    pafei->pafda->fdwSupport = pafdw->fdwSupport;
     WideCharToMultiByte( CP_ACP, 0, pafdw->szFilter, -1, pafei->pafda->szFilter,
                          sizeof(pafei->pafda->szFilter), NULL, NULL );
 
-    return (pafei->fnCallback)(hadid, pafei->pafda, 
-                               pafei->dwInstance, fdwSupport);
+    return (pafei->fnCallback)(hadid, pafei->pafda,
+                   pafei->dwInstance, fdwSupport);
 }
 
@@ -149 +149 @@
  *           acmFilterEnumA (MSACM32.17)
  */
-MMRESULT WINAPI acmFilterEnumA(HACMDRIVER had, PACMFILTERDETAILSA pafda, 
-                               ACMFILTERENUMCBA fnCallback, DWORD dwInstance, 
-                               DWORD fdwEnum)
-{
-    ACMFILTERDETAILSW           afdw;
+MMRESULT WINAPI acmFilterEnumA(HACMDRIVER had, PACMFILTERDETAILSA pafda,
+                   ACMFILTERENUMCBA fnCallback, DWORD dwInstance,
+                   DWORD fdwEnum)
+{
+    ACMFILTERDETAILSW       afdw;
     struct MSACM_FilterEnumWtoA_Instance afei;
 
@@ -167 +167 @@
     afei.fnCallback = fnCallback;
 
-    return acmFilterEnumW(had, &afdw, MSACM_FilterEnumCallbackWtoA, 
-                          (DWORD)&afei, fdwEnum);
-}
-
-static BOOL MSACM_FilterEnumHelper(PWINE_ACMDRIVERID padid, HACMDRIVER had, 
-                                   PACMFILTERDETAILSW pafd, 
-                                   ACMFILTERENUMCBW fnCallback, DWORD dwInstance,  
-                                   DWORD fdwEnum)
-{
-    ACMDRIVERDETAILSW           add;
-    ACMFILTERTAGDETAILSW        aftd;
-    int                         i, j;
+    return acmFilterEnumW(had, &afdw, MSACM_FilterEnumCallbackWtoA,
+              (DWORD)&afei, fdwEnum);
+}
+
+static BOOL MSACM_FilterEnumHelper(PWINE_ACMDRIVERID padid, HACMDRIVER had,
+                   PACMFILTERDETAILSW pafd,
+                   ACMFILTERENUMCBW fnCallback, DWORD dwInstance,
+                   DWORD fdwEnum)
+{
+    ACMDRIVERDETAILSW       add;
+    ACMFILTERTAGDETAILSW    aftd;
+    int             i, j;
 
     add.cbStruct = sizeof(add);
-    
+
     if (acmDriverDetailsW((HACMDRIVERID)padid, &add, 0) != MMSYSERR_NOERROR) return FALSE;
 
     for (i = 0; i < add.cFilterTags; i++) {
-        memset(&aftd, 0, sizeof(aftd));
-        aftd.cbStruct = sizeof(aftd);
-        aftd.dwFilterTagIndex = i;
-        if (acmFilterTagDetailsW(had, &aftd, ACM_FILTERTAGDETAILSF_INDEX) != MMSYSERR_NOERROR)
-            continue;
-        
-        if ((fdwEnum & ACM_FILTERENUMF_DWFILTERTAG) && 
-            aftd.dwFilterTag != pafd->pwfltr->dwFilterTag)
-            continue;
-        
-        for (j = 0; j < aftd.cStandardFilters; j++) {
-            pafd->dwFilterIndex = j;
-            pafd->dwFilterTag = aftd.dwFilterTag;
-            if (acmFilterDetailsW(had, pafd, ACM_FILTERDETAILSF_INDEX) != MMSYSERR_NOERROR) 
-                continue;
-            
-            if (!(fnCallback)((HACMDRIVERID)padid, pafd, dwInstance, add.fdwSupport))
-                return FALSE; 
-        }
+    memset(&aftd, 0, sizeof(aftd));
+    aftd.cbStruct = sizeof(aftd);
+    aftd.dwFilterTagIndex = i;
+    if (acmFilterTagDetailsW(had, &aftd, ACM_FILTERTAGDETAILSF_INDEX) != MMSYSERR_NOERROR)
+        continue;
+
+    if ((fdwEnum & ACM_FILTERENUMF_DWFILTERTAG) &&
+        aftd.dwFilterTag != pafd->pwfltr->dwFilterTag)
+        continue;
+
+    for (j = 0; j < aftd.cStandardFilters; j++) {
+        pafd->dwFilterIndex = j;
+        pafd->dwFilterTag = aftd.dwFilterTag;
+        if (acmFilterDetailsW(had, pafd, ACM_FILTERDETAILSF_INDEX) != MMSYSERR_NOERROR)
+        continue;
+
+        if (!(fnCallback)((HACMDRIVERID)padid, pafd, dwInstance, add.fdwSupport))
+        return FALSE;
+    }
     }
     return TRUE;
@@ -211 +211 @@
  *           acmFilterEnumW (MSACM32.18)
  */
-MMRESULT WINAPI acmFilterEnumW(HACMDRIVER had, PACMFILTERDETAILSW pafd, 
-                               ACMFILTERENUMCBW fnCallback, DWORD dwInstance, 
-                               DWORD fdwEnum)
-{
-    PWINE_ACMDRIVERID           padid;
-    BOOL                        ret;
+MMRESULT WINAPI acmFilterEnumW(HACMDRIVER had, PACMFILTERDETAILSW pafd,
+                   ACMFILTERENUMCBW fnCallback, DWORD dwInstance,
+                   DWORD fdwEnum)
+{
+    PWINE_ACMDRIVERID       padid;
+    BOOL            ret;
 
     TRACE("(0x%08x, %p, %p, %ld, %ld)\n",
-          had, pafd, fnCallback, dwInstance, fdwEnum);
+      had, pafd, fnCallback, dwInstance, fdwEnum);
 
     if (pafd->cbStruct < sizeof(*pafd)) return MMSYSERR_INVALPARAM;
 
     if (fdwEnum & ~(ACM_FILTERENUMF_DWFILTERTAG))
-        FIXME("Unsupported fdwEnum values\n");
+    FIXME("Unsupported fdwEnum values\n");
 
     if (had) {
-        HACMDRIVERID    hadid;
-
-        if (acmDriverID(had, &hadid, 0) != MMSYSERR_NOERROR)
-            return MMSYSERR_INVALHANDLE;
-        MSACM_FilterEnumHelper(MSACM_GetDriverID(hadid), had, pafd,
-                               fnCallback, dwInstance, fdwEnum);
-        return MMSYSERR_NOERROR;
+    HACMDRIVERID    hadid;
+
+    if (acmDriverID(had, &hadid, 0) != MMSYSERR_NOERROR)
+        return MMSYSERR_INVALHANDLE;
+    MSACM_FilterEnumHelper(MSACM_GetDriverID(hadid), had, pafd,
+                   fnCallback, dwInstance, fdwEnum);
+    return MMSYSERR_NOERROR;
     }
     for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
-            /* should check for codec only */
-            if (!padid->bEnabled || acmDriverOpen(&had, (HACMDRIVERID)padid, 0) != MMSYSERR_NOERROR)
-                continue;
-            ret = MSACM_FilterEnumHelper(padid, had, pafd, 
-                                         fnCallback, dwInstance, fdwEnum);
-            acmDriverClose(had, 0);
-            if (!ret) break;
+        /* should check for codec only */
+        if (!padid->bEnabled || acmDriverOpen(&had, (HACMDRIVERID)padid, 0) != MMSYSERR_NOERROR)
+        continue;
+        ret = MSACM_FilterEnumHelper(padid, had, pafd,
+                     fnCallback, dwInstance, fdwEnum);
+        acmDriverClose(had, 0);
+        if (!ret) break;
     }
     return MMSYSERR_NOERROR;
@@ -250 +250 @@
  *           acmFilterTagDetailsA (MSACM32.19)
  */
-MMRESULT WINAPI acmFilterTagDetailsA(HACMDRIVER had, PACMFILTERTAGDETAILSA paftda, 
-                                     DWORD fdwDetails)
-{
-    ACMFILTERTAGDETAILSW        aftdw;
-    MMRESULT                    mmr;
+MMRESULT WINAPI acmFilterTagDetailsA(HACMDRIVER had, PACMFILTERTAGDETAILSA paftda,
+                     DWORD fdwDetails)
+{
+    ACMFILTERTAGDETAILSW    aftdw;
+    MMRESULT            mmr;
 
     memset(&aftdw, 0, sizeof(aftdw));
@@ -263 +263 @@
     mmr = acmFilterTagDetailsW(had, &aftdw, fdwDetails);
     if (mmr == MMSYSERR_NOERROR) {
-        paftda->dwFilterTag = aftdw.dwFilterTag; 
-        paftda->dwFilterTagIndex = aftdw.dwFilterTagIndex;
-        paftda->cbFilterSize = aftdw.cbFilterSize; 
-        paftda->fdwSupport = aftdw.fdwSupport; 
-        paftda->cStandardFilters = aftdw.cStandardFilters; 
+    paftda->dwFilterTag = aftdw.dwFilterTag;
+    paftda->dwFilterTagIndex = aftdw.dwFilterTagIndex;
+    paftda->cbFilterSize = aftdw.cbFilterSize;
+    paftda->fdwSupport = aftdw.fdwSupport;
+    paftda->cStandardFilters = aftdw.cStandardFilters;
         WideCharToMultiByte( CP_ACP, 0, aftdw.szFilterTag, -1, paftda->szFilterTag,
                              sizeof(paftda->szFilterTag), NULL, NULL );
@@ -277 +277 @@
  *           acmFilterTagDetailsW (MSACM32.20)
  */
-MMRESULT WINAPI acmFilterTagDetailsW(HACMDRIVER had, PACMFILTERTAGDETAILSW paftd, 
-                                     DWORD fdwDetails)
-{
-    PWINE_ACMDRIVERID   padid;
-    MMRESULT            mmr;
+MMRESULT WINAPI acmFilterTagDetailsW(HACMDRIVER had, PACMFILTERTAGDETAILSW paftd,
+                     DWORD fdwDetails)
+{
+    PWINE_ACMDRIVERID   padid;
+    MMRESULT        mmr;
 
     TRACE("(0x%08x, %p, %ld)\n", had, paftd, fdwDetails);
 
     if (fdwDetails & ~(ACM_FILTERTAGDETAILSF_FILTERTAG|ACM_FILTERTAGDETAILSF_INDEX|
-                       ACM_FILTERTAGDETAILSF_LARGESTSIZE))
-        return MMSYSERR_INVALFLAG;
+               ACM_FILTERTAGDETAILSF_LARGESTSIZE))
+    return MMSYSERR_INVALFLAG;
 
     switch (fdwDetails) {
     case ACM_FILTERTAGDETAILSF_FILTERTAG:
-        if (had == (HACMDRIVER)NULL) {
-            mmr = ACMERR_NOTPOSSIBLE;
-            for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
-                /* should check for codec only */
-                if (padid->bEnabled && acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
-                    mmr = MSACM_Message(had, ACMDM_FILTERTAG_DETAILS,
-                                        (LPARAM)paftd, (LPARAM)fdwDetails);
-                    acmDriverClose(had, 0);
-                    if (mmr == MMSYSERR_NOERROR) break;
-                }
-            }
-        } else {
-            mmr = MSACM_Message(had, ACMDM_FILTERTAG_DETAILS,
-                                (LPARAM)paftd, (LPARAM)fdwDetails);
-        }
-        break;
+    if (had == (HACMDRIVER)NULL) {
+        mmr = ACMERR_NOTPOSSIBLE;
+        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
+        /* should check for codec only */
+        if (padid->bEnabled && acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
+            mmr = MSACM_Message(had, ACMDM_FILTERTAG_DETAILS,
+                    (LPARAM)paftd, (LPARAM)fdwDetails);
+            acmDriverClose(had, 0);
+            if (mmr == MMSYSERR_NOERROR) break;
+        }
+        }
+    } else {
+        mmr = MSACM_Message(had, ACMDM_FILTERTAG_DETAILS,
+                (LPARAM)paftd, (LPARAM)fdwDetails);
+    }
+    break;
 
     case ACM_FILTERTAGDETAILSF_INDEX:
-        /* FIXME should check paftd->dwFilterTagIndex < add.cFilterTags */
-        mmr = MSACM_Message(had, ACMDM_FILTERTAG_DETAILS,
-                            (LPARAM)paftd, (LPARAM)fdwDetails);
-        break;
+    /* FIXME should check paftd->dwFilterTagIndex < add.cFilterTags */
+    mmr = MSACM_Message(had, ACMDM_FILTERTAG_DETAILS,
+                (LPARAM)paftd, (LPARAM)fdwDetails);
+    break;
 
     case ACM_FILTERTAGDETAILSF_LARGESTSIZE:
-        if (had == (HACMDRIVER)NULL) {
-            ACMFILTERTAGDETAILSW        tmp;
-            DWORD                       ft = paftd->dwFilterTag;
-
-            mmr = ACMERR_NOTPOSSIBLE;
-            for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
-                /* should check for codec only */
-                if (padid->bEnabled && 
-                    acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
-
-                    memset(&tmp, 0, sizeof(tmp));
-                    tmp.cbStruct = sizeof(tmp);
-                    tmp.dwFilterTag = ft;
-
-                    if (MSACM_Message(had, ACMDM_FILTERTAG_DETAILS,
-                                      (LPARAM)&tmp, 
-                                      (LPARAM)fdwDetails) == MMSYSERR_NOERROR) {
-                        if (mmr == ACMERR_NOTPOSSIBLE ||
-                            paftd->cbFilterSize < tmp.cbFilterSize) {
-                            *paftd = tmp;
-                            mmr = MMSYSERR_NOERROR;
-                        } 
-                    }
-                    acmDriverClose(had, 0);
-                }
-            }
-        } else {
-            mmr = MSACM_Message(had, ACMDM_FILTERTAG_DETAILS,
-                                (LPARAM)paftd, (LPARAM)fdwDetails);
-        }
-        break;
+    if (had == (HACMDRIVER)NULL) {
+        ACMFILTERTAGDETAILSW    tmp;
+        DWORD           ft = paftd->dwFilterTag;
+
+        mmr = ACMERR_NOTPOSSIBLE;
+        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
+        /* should check for codec only */
+        if (padid->bEnabled &&
+            acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
+
+            memset(&tmp, 0, sizeof(tmp));
+            tmp.cbStruct = sizeof(tmp);
+            tmp.dwFilterTag = ft;
+
+            if (MSACM_Message(had, ACMDM_FILTERTAG_DETAILS,
+                      (LPARAM)&tmp,
+                      (LPARAM)fdwDetails) == MMSYSERR_NOERROR) {
+            if (mmr == ACMERR_NOTPOSSIBLE ||
+                paftd->cbFilterSize < tmp.cbFilterSize) {
+                *paftd = tmp;
+                mmr = MMSYSERR_NOERROR;
+            }
+            }
+            acmDriverClose(had, 0);
+        }
+        }
+    } else {
+        mmr = MSACM_Message(had, ACMDM_FILTERTAG_DETAILS,
+                (LPARAM)paftd, (LPARAM)fdwDetails);
+    }
+    break;
 
     default:
-        WARN("Unsupported fdwDetails=%08lx\n", fdwDetails);
-        mmr = MMSYSERR_ERROR;
-    }
-
-    if (mmr == MMSYSERR_NOERROR && 
-        paftd->dwFilterTag == WAVE_FORMAT_PCM && paftd->szFilterTag[0] == 0)
+    WARN("Unsupported fdwDetails=%08lx\n", fdwDetails);
+    mmr = MMSYSERR_ERROR;
+    }
+
+    if (mmr == MMSYSERR_NOERROR &&
+    paftd->dwFilterTag == WAVE_FORMAT_PCM && paftd->szFilterTag[0] == 0)
         MultiByteToWideChar( CP_ACP, 0, "PCM", -1, paftd->szFilterTag,
                              sizeof(paftd->szFilterTag)/sizeof(WCHAR) );
@@ -361 +361 @@
 
 struct MSACM_FilterTagEnumWtoA_Instance {
-    PACMFILTERTAGDETAILSA       paftda;
-    DWORD                       dwInstance;
-    ACMFILTERTAGENUMCBA         fnCallback;
+    PACMFILTERTAGDETAILSA   paftda;
+    DWORD           dwInstance;
+    ACMFILTERTAGENUMCBA     fnCallback;
 };
 
 static BOOL CALLBACK MSACM_FilterTagEnumCallbackWtoA(HACMDRIVERID hadid,
-                                                     PACMFILTERTAGDETAILSW paftdw,  
-                                                     DWORD dwInstance,             
-                                                     DWORD fdwSupport)
+                             PACMFILTERTAGDETAILSW paftdw,
+                             DWORD dwInstance,
+                             DWORD fdwSupport)
 {
     struct MSACM_FilterTagEnumWtoA_Instance* paftei;
@@ -375 +375 @@
     paftei = (struct MSACM_FilterTagEnumWtoA_Instance*)dwInstance;
 
-    paftei->paftda->dwFilterTagIndex = paftdw->dwFilterTagIndex; 
-    paftei->paftda->dwFilterTag = paftdw->dwFilterTag; 
-    paftei->paftda->cbFilterSize = paftdw->cbFilterSize; 
-    paftei->paftda->fdwSupport = paftdw->fdwSupport; 
-    paftei->paftda->cStandardFilters = paftdw->cStandardFilters; 
+    paftei->paftda->dwFilterTagIndex = paftdw->dwFilterTagIndex;
+    paftei->paftda->dwFilterTag = paftdw->dwFilterTag;
+    paftei->paftda->cbFilterSize = paftdw->cbFilterSize;
+    paftei->paftda->fdwSupport = paftdw->fdwSupport;
+    paftei->paftda->cStandardFilters = paftdw->cStandardFilters;
     WideCharToMultiByte( CP_ACP, 0, paftdw->szFilterTag, -1, paftei->paftda->szFilterTag,
                          sizeof(paftei->paftda->szFilterTag), NULL, NULL );
 
-    return (paftei->fnCallback)(hadid, paftei->paftda, 
-                                paftei->dwInstance, fdwSupport);
+    return (paftei->fnCallback)(hadid, paftei->paftda,
+                paftei->dwInstance, fdwSupport);
 }
 
@@ -391 +391 @@
  */
 MMRESULT WINAPI acmFilterTagEnumA(HACMDRIVER had, PACMFILTERTAGDETAILSA paftda,
-                                  ACMFILTERTAGENUMCBA fnCallback, DWORD dwInstance, 
-                                  DWORD fdwEnum)
-{
-    ACMFILTERTAGDETAILSW        aftdw;
+                  ACMFILTERTAGENUMCBA fnCallback, DWORD dwInstance,
+                  DWORD fdwEnum)
+{
+    ACMFILTERTAGDETAILSW    aftdw;
     struct MSACM_FilterTagEnumWtoA_Instance aftei;
 
@@ -406 +406 @@
     aftei.fnCallback = fnCallback;
 
-    return acmFilterTagEnumW(had, &aftdw, MSACM_FilterTagEnumCallbackWtoA, 
-                             (DWORD)&aftei, fdwEnum);
+    return acmFilterTagEnumW(had, &aftdw, MSACM_FilterTagEnumCallbackWtoA,
+                 (DWORD)&aftei, fdwEnum);
 }
 
@@ -414 +414 @@
  */
 MMRESULT WINAPI acmFilterTagEnumW(HACMDRIVER had, PACMFILTERTAGDETAILSW paftd,
-                                  ACMFILTERTAGENUMCBW fnCallback, DWORD dwInstance, 
-                                  DWORD fdwEnum)
-{
-    PWINE_ACMDRIVERID           padid;
-    ACMDRIVERDETAILSW           add;
-    int                         i;
+                  ACMFILTERTAGENUMCBW fnCallback, DWORD dwInstance,
+                  DWORD fdwEnum)
+{
+    PWINE_ACMDRIVERID       padid;
+    ACMDRIVERDETAILSW       add;
+    int             i;
 
     TRACE("(0x%08x, %p, %p, %ld, %ld)\n",
-          had, paftd, fnCallback, dwInstance, fdwEnum); 
+      had, paftd, fnCallback, dwInstance, fdwEnum);
 
     if (paftd->cbStruct < sizeof(*paftd)) return MMSYSERR_INVALPARAM;
 
     if (had) FIXME("had != NULL, not supported\n");
-    
+
     for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
-        /* should check for codec only */
-        if (padid->bEnabled && acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == MMSYSERR_NOERROR) {
-            add.cbStruct = sizeof(add);
-
-            if (acmDriverDetailsW((HACMDRIVERID)padid, &add, 0) == MMSYSERR_NOERROR) {
-                for (i = 0; i < add.cFilterTags; i++) {
-                    paftd->dwFilterTagIndex = i;
-                    if (acmFilterTagDetailsW(had, paftd, ACM_FILTERTAGDETAILSF_INDEX) == MMSYSERR_NOERROR) {
-                        if (!(fnCallback)((HACMDRIVERID)padid, paftd, dwInstance, 
-                                          add.fdwSupport)) {
-                            padid = NULL;
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-        acmDriverClose(had, 0);
+    /* should check for codec only */
+    if (padid->bEnabled && acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == MMSYSERR_NOERROR) {
+        add.cbStruct = sizeof(add);
+
+        if (acmDriverDetailsW((HACMDRIVERID)padid, &add, 0) == MMSYSERR_NOERROR) {
+        for (i = 0; i < add.cFilterTags; i++) {
+            paftd->dwFilterTagIndex = i;
+            if (acmFilterTagDetailsW(had, paftd, ACM_FILTERTAGDETAILSF_INDEX) == MMSYSERR_NOERROR) {
+            if (!(fnCallback)((HACMDRIVERID)padid, paftd, dwInstance,
+                      add.fdwSupport)) {
+                padid = NULL;
+                break;
+            }
+            }
+        }
+        }
+    }
+    acmDriverClose(had, 0);
     }
     return MMSYSERR_NOERROR;

trunk/src/msacm32/format.c

@@ -1 +1 @@
 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
-
+/* $Id: format.c,v 1.2 2001-09-05 13:11:25 bird Exp $ */
 /*
  *      MSACM32 library
  *
  *      Copyright 1998  Patrik Stridvall
- *                2000  Eric Pouech
+ *        2000  Eric Pouech
  */
 
@@ -24 +24 @@
 DEFAULT_DEBUG_CHANNEL(msacm);
 
-static  PACMFORMATCHOOSEA       afc;
+static  PACMFORMATCHOOSEA   afc;
 
 struct MSACM_FillFormatData {
-    HWND                hWnd;
-#define WINE_ACMFF_TAG          0
-#define WINE_ACMFF_FORMAT       1
-#define WINE_ACMFF_WFX          2
-    int                 mode;
-    char                szFormatTag[ACMFORMATTAGDETAILS_FORMATTAG_CHARS];
-    PACMFORMATCHOOSEA   afc;
-    DWORD               ret;
+    HWND        hWnd;
+#define WINE_ACMFF_TAG      0
+#define WINE_ACMFF_FORMAT   1
+#define WINE_ACMFF_WFX      2
+    int         mode;
+    char        szFormatTag[ACMFORMATTAGDETAILS_FORMATTAG_CHARS];
+    PACMFORMATCHOOSEA   afc;
+    DWORD       ret;
 };
 
-static BOOL CALLBACK MSACM_FillFormatTagsCB(HACMDRIVERID hadid, 
-                                            PACMFORMATTAGDETAILSA paftd,
-                                            DWORD dwInstance, DWORD fdwSupport)
-{
-    struct MSACM_FillFormatData*        affd = (struct MSACM_FillFormatData*)dwInstance;
+static BOOL CALLBACK MSACM_FillFormatTagsCB(HACMDRIVERID hadid,
+                        PACMFORMATTAGDETAILSA paftd,
+                        DWORD dwInstance, DWORD fdwSupport)
+{
+    struct MSACM_FillFormatData*    affd = (struct MSACM_FillFormatData*)dwInstance;
 
     switch (affd->mode) {
     case WINE_ACMFF_TAG:
-        if (SendDlgItemMessageA(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG, 
-                                CB_FINDSTRINGEXACT, 
-                                (WPARAM)-1, (LPARAM)paftd->szFormatTag) == CB_ERR)
-            SendDlgItemMessageA(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG, 
-                                CB_ADDSTRING, 0, (DWORD)paftd->szFormatTag);
-        break;
+    if (SendDlgItemMessageA(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
+                CB_FINDSTRINGEXACT,
+                (WPARAM)-1, (LPARAM)paftd->szFormatTag) == CB_ERR)
+        SendDlgItemMessageA(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
+                CB_ADDSTRING, 0, (DWORD)paftd->szFormatTag);
+    break;
     case WINE_ACMFF_FORMAT:
-        if (strcmp(affd->szFormatTag, paftd->szFormatTag) == 0) {
-            HACMDRIVER          had;
-
-            if (acmDriverOpen(&had, hadid, 0) == MMSYSERR_NOERROR) {
-                ACMFORMATDETAILSA       afd;
-                int                     i, idx;
-                MMRESULT                mmr;
-                char                    buffer[64];
-
-                afd.cbStruct = sizeof(afd);
-                afd.dwFormatTag = paftd->dwFormatTag;
-                afd.pwfx = HeapAlloc(GetProcessHeap(), 0, paftd->cbFormatSize);
-                afd.pwfx->wFormatTag = paftd->dwFormatTag;
-                afd.pwfx->cbSize = paftd->cbFormatSize;
-                afd.cbwfx = paftd->cbFormatSize;
-
-                for (i = 0; i < paftd->cStandardFormats; i++) {
-                    afd.dwFormatIndex = i;
-                    mmr = acmFormatDetailsA(had, &afd, ACM_FORMATDETAILSF_INDEX);
-                    if (mmr == MMSYSERR_NOERROR) {
-                        strcpy(buffer, afd.szFormat);
-                        for (idx = strlen(buffer); 
-                             idx < ACMFORMATTAGDETAILS_FORMATTAG_CHARS; idx++)
-                            buffer[idx] = ' ';
-                        wsprintfA(buffer + ACMFORMATTAGDETAILS_FORMATTAG_CHARS, 
-                                  "%d Ko/s", 
-                                  (afd.pwfx->nAvgBytesPerSec + 512) / 1024);
-                        SendDlgItemMessageA(affd->hWnd, 
-                                            IDD_ACMFORMATCHOOSE_CMB_FORMAT, 
-                                            CB_ADDSTRING, 0, (DWORD)buffer);
-                    }
-                }
-                acmDriverClose(had, 0);
-                SendDlgItemMessageA(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT, 
-                                    CB_SETCURSEL, 0, 0);
-            } 
-        }
-        break;
+    if (strcmp(affd->szFormatTag, paftd->szFormatTag) == 0) {
+        HACMDRIVER      had;
+
+        if (acmDriverOpen(&had, hadid, 0) == MMSYSERR_NOERROR) {
+        ACMFORMATDETAILSA   afd;
+        int         i, idx;
+        MMRESULT        mmr;
+        char            buffer[64];
+
+        afd.cbStruct = sizeof(afd);
+        afd.dwFormatTag = paftd->dwFormatTag;
+        afd.pwfx = HeapAlloc(GetProcessHeap(), 0, paftd->cbFormatSize);
+        afd.pwfx->wFormatTag = paftd->dwFormatTag;
+        afd.pwfx->cbSize = paftd->cbFormatSize;
+        afd.cbwfx = paftd->cbFormatSize;
+
+        for (i = 0; i < paftd->cStandardFormats; i++) {
+            afd.dwFormatIndex = i;
+            mmr = acmFormatDetailsA(had, &afd, ACM_FORMATDETAILSF_INDEX);
+            if (mmr == MMSYSERR_NOERROR) {
+            strcpy(buffer, afd.szFormat);
+            for (idx = strlen(buffer);
+                 idx < ACMFORMATTAGDETAILS_FORMATTAG_CHARS; idx++)
+                buffer[idx] = ' ';
+            wsprintfA(buffer + ACMFORMATTAGDETAILS_FORMATTAG_CHARS,
+                  "%d Ko/s",
+                  (afd.pwfx->nAvgBytesPerSec + 512) / 1024);
+            SendDlgItemMessageA(affd->hWnd,
+                        IDD_ACMFORMATCHOOSE_CMB_FORMAT,
+                        CB_ADDSTRING, 0, (DWORD)buffer);
+            }
+        }
+        acmDriverClose(had, 0);
+        SendDlgItemMessageA(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT,
+                    CB_SETCURSEL, 0, 0);
+        }
+    }
+    break;
     case WINE_ACMFF_WFX:
-        if (strcmp(affd->szFormatTag, paftd->szFormatTag) == 0) {
-            HACMDRIVER          had;
-
-            if (acmDriverOpen(&had, hadid, 0) == MMSYSERR_NOERROR) {
-                ACMFORMATDETAILSA       afd;
-
-                afd.cbStruct = sizeof(afd);
-                afd.dwFormatTag = paftd->dwFormatTag;
-                afd.pwfx = affd->afc->pwfx;
-                afd.cbwfx = affd->afc->cbwfx;
-
-                afd.dwFormatIndex = SendDlgItemMessageA(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT, CB_GETCURSEL, 0, 0);;
-                affd->ret = acmFormatDetailsA(had, &afd, ACM_FORMATDETAILSF_INDEX);
-                acmDriverClose(had, 0);
-                return TRUE;
-            } 
-        }
-        break;
+    if (strcmp(affd->szFormatTag, paftd->szFormatTag) == 0) {
+        HACMDRIVER      had;
+
+        if (acmDriverOpen(&had, hadid, 0) == MMSYSERR_NOERROR) {
+        ACMFORMATDETAILSA   afd;
+
+        afd.cbStruct = sizeof(afd);
+        afd.dwFormatTag = paftd->dwFormatTag;
+        afd.pwfx = affd->afc->pwfx;
+        afd.cbwfx = affd->afc->cbwfx;
+
+        afd.dwFormatIndex = SendDlgItemMessageA(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT, CB_GETCURSEL, 0, 0);;
+        affd->ret = acmFormatDetailsA(had, &afd, ACM_FORMATDETAILSF_INDEX);
+        acmDriverClose(had, 0);
+        return TRUE;
+        }
+    }
+    break;
     default:
-        FIXME("Unknown mode (%d)\n", affd->mode);
-        break;
+    FIXME("Unknown mode (%d)\n", affd->mode);
+    break;
     }
     return TRUE;
@@ -118 +118 @@
 static BOOL MSACM_FillFormatTags(HWND hWnd)
 {
-    ACMFORMATTAGDETAILSA        aftd;
-    struct MSACM_FillFormatData affd;
+    ACMFORMATTAGDETAILSA    aftd;
+    struct MSACM_FillFormatData affd;
 
     memset(&aftd, 0, sizeof(aftd));
@@ -134 +134 @@
 static BOOL MSACM_FillFormat(HWND hWnd)
 {
-    ACMFORMATTAGDETAILSA        aftd;
-    struct MSACM_FillFormatData affd;
+    ACMFORMATTAGDETAILSA    aftd;
+    struct MSACM_FillFormatData affd;
 
     SendDlgItemMessageA(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT, CB_RESETCONTENT, 0, 0);
@@ -144 +144 @@
     affd.hWnd = hWnd;
     affd.mode = WINE_ACMFF_FORMAT;
-    SendDlgItemMessageA(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG, 
-                        CB_GETLBTEXT,
-                        SendDlgItemMessageA(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG, 
-                                            CB_GETCURSEL, 0, 0),
-                        (DWORD)affd.szFormatTag);
-    
+    SendDlgItemMessageA(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
+            CB_GETLBTEXT,
+            SendDlgItemMessageA(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
+                        CB_GETCURSEL, 0, 0),
+            (DWORD)affd.szFormatTag);
+
     acmFormatTagEnumA((HACMDRIVER)0, &aftd, MSACM_FillFormatTagsCB, (DWORD)&affd, 0);
     SendDlgItemMessageA(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT, CB_SETCURSEL, 0, 0);
@@ -157 +157 @@
 static MMRESULT MSACM_GetWFX(HWND hWnd, PACMFORMATCHOOSEA afc)
 {
-    ACMFORMATTAGDETAILSA        aftd;
-    struct MSACM_FillFormatData affd;
+    ACMFORMATTAGDETAILSA    aftd;
+    struct MSACM_FillFormatData affd;
 
     memset(&aftd, 0, sizeof(aftd));
@@ -172 +172 @@
 }
 
-static BOOL WINAPI FormatChooseDlgProc(HWND hWnd, UINT msg, 
-                                       WPARAM wParam, LPARAM lParam)
-{
-    
+static BOOL WINAPI FormatChooseDlgProc(HWND hWnd, UINT msg,
+                       WPARAM wParam, LPARAM lParam)
+{
+
     TRACE("hwnd=%i msg=%i 0x%08x 0x%08lx\n", hWnd,  msg, wParam, lParam );
-    
+
     switch (msg) {
     case WM_INITDIALOG:
-        afc = (PACMFORMATCHOOSEA)lParam;
-        MSACM_FillFormatTags(hWnd);
-        MSACM_FillFormat(hWnd);
-        if ((afc->fdwStyle & ~(ACMFORMATCHOOSE_STYLEF_CONTEXTHELP|
-                               ACMFORMATCHOOSE_STYLEF_SHOWHELP)) != 0)
-            FIXME("Unsupported style %08lx\n", ((PACMFORMATCHOOSEA)lParam)->fdwStyle);
-        if (!(afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_SHOWHELP))
-            ShowWindow(GetDlgItem(hWnd, IDD_ACMFORMATCHOOSE_BTN_HELP), SW_HIDE);
-        return TRUE;
-        
+    afc = (PACMFORMATCHOOSEA)lParam;
+    MSACM_FillFormatTags(hWnd);
+    MSACM_FillFormat(hWnd);
+    if ((afc->fdwStyle & ~(ACMFORMATCHOOSE_STYLEF_CONTEXTHELP|
+                   ACMFORMATCHOOSE_STYLEF_SHOWHELP)) != 0)
+        FIXME("Unsupported style %08lx\n", ((PACMFORMATCHOOSEA)lParam)->fdwStyle);
+    if (!(afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_SHOWHELP))
+        ShowWindow(GetDlgItem(hWnd, IDD_ACMFORMATCHOOSE_BTN_HELP), SW_HIDE);
+    return TRUE;
+
     case WM_COMMAND:
-        switch (LOWORD(wParam)) {
-        case IDOK:
-            EndDialog(hWnd, MSACM_GetWFX(hWnd, afc));
-            return TRUE;
-        case IDCANCEL:
-            EndDialog(hWnd, ACMERR_CANCELED);
-            return TRUE;
-        case IDD_ACMFORMATCHOOSE_CMB_FORMATTAG:
-            switch (HIWORD(wParam)) {
-            case CBN_SELCHANGE:
-                MSACM_FillFormat(hWnd);
-                break;
-            default:
-                TRACE("Dropped dlgNotif (fmtTag): 0x%08x 0x%08lx\n", 
-                      HIWORD(wParam), lParam);
-                break;
-            }
-            break;
-        case IDD_ACMFORMATCHOOSE_BTN_HELP:
-            if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_SHOWHELP)
-                SendMessageA(afc->hwndOwner, 
-                             RegisterWindowMessageA(ACMHELPMSGSTRINGA), 0L, 0L);
-            break;
-            
-        default:
-            TRACE("Dropped dlgCmd: ctl=%d ntf=0x%04x 0x%08lx\n", 
-                  LOWORD(wParam), HIWORD(wParam), lParam);
-            break;
-        }
-        break;
+    switch (LOWORD(wParam)) {
+    case IDOK:
+        EndDialog(hWnd, MSACM_GetWFX(hWnd, afc));
+        return TRUE;
+    case IDCANCEL:
+        EndDialog(hWnd, ACMERR_CANCELED);
+        return TRUE;
+    case IDD_ACMFORMATCHOOSE_CMB_FORMATTAG:
+        switch (HIWORD(wParam)) {
+        case CBN_SELCHANGE:
+        MSACM_FillFormat(hWnd);
+        break;
+        default:
+        TRACE("Dropped dlgNotif (fmtTag): 0x%08x 0x%08lx\n",
+              HIWORD(wParam), lParam);
+        break;
+        }
+        break;
+    case IDD_ACMFORMATCHOOSE_BTN_HELP:
+        if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_SHOWHELP)
+        SendMessageA(afc->hwndOwner,
+                 RegisterWindowMessageA(ACMHELPMSGSTRINGA), 0L, 0L);
+        break;
+
+    default:
+        TRACE("Dropped dlgCmd: ctl=%d ntf=0x%04x 0x%08lx\n",
+          LOWORD(wParam), HIWORD(wParam), lParam);
+        break;
+    }
+    break;
     case WM_CONTEXTMENU:
-        if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_CONTEXTHELP)
-            SendMessageA(afc->hwndOwner, 
-                         RegisterWindowMessageA(ACMHELPMSGCONTEXTMENUA), 
-                         wParam, lParam);
-        break;
+    if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_CONTEXTHELP)
+        SendMessageA(afc->hwndOwner,
+             RegisterWindowMessageA(ACMHELPMSGCONTEXTMENUA),
+             wParam, lParam);
+    break;
 #if defined(WM_CONTEXTHELP)
     case WM_CONTEXTHELP:
-        if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_CONTEXTHELP)
-            SendMessageA(afc->hwndOwner, 
-                         RegisterWindowMessageA(ACMHELPMSGCONTEXTHELPA), 
-                         wParam, lParam);
-        break;
-#endif       
+    if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_CONTEXTHELP)
+        SendMessageA(afc->hwndOwner,
+             RegisterWindowMessageA(ACMHELPMSGCONTEXTHELPA),
+             wParam, lParam);
+    break;
+#endif
     default:
-        TRACE("Dropped dlgMsg: hwnd=%i msg=%i 0x%08x 0x%08lx\n", 
-              hWnd,  msg, wParam, lParam );
-        break;
+    TRACE("Dropped dlgMsg: hwnd=%i msg=%i 0x%08x 0x%08lx\n",
+          hWnd,  msg, wParam, lParam );
+    break;
     }
     return FALSE;
@@ -249 +249 @@
 {
     return DialogBoxParamA(MSACM_hInstance32, MAKEINTRESOURCEA(DLG_ACMFORMATCHOOSE_ID),
-                           pafmtc->hwndOwner, FormatChooseDlgProc, (INT)pafmtc);
+               pafmtc->hwndOwner, FormatChooseDlgProc, (INT)pafmtc);
 }
 
@@ -265 +265 @@
  *           acmFormatDetailsA (MSACM32.25)
  */
-MMRESULT WINAPI acmFormatDetailsA(HACMDRIVER had, PACMFORMATDETAILSA pafd, 
-                                  DWORD fdwDetails)
-{
-    ACMFORMATDETAILSW   afdw;
-    MMRESULT            mmr;
+MMRESULT WINAPI acmFormatDetailsA(HACMDRIVER had, PACMFORMATDETAILSA pafd,
+                  DWORD fdwDetails)
+{
+    ACMFORMATDETAILSW   afdw;
+    MMRESULT        mmr;
 
     memset(&afdw, 0, sizeof(afdw));
     afdw.cbStruct = sizeof(afdw);
     afdw.dwFormatIndex = pafd->dwFormatIndex;
-    afdw.dwFormatTag = pafd->dwFormatTag; 
-    afdw.pwfx = pafd->pwfx; 
-    afdw.cbwfx = pafd->cbwfx; 
+    afdw.dwFormatTag = pafd->dwFormatTag;
+    afdw.pwfx = pafd->pwfx;
+    afdw.cbwfx = pafd->cbwfx;
 
     mmr = acmFormatDetailsW(had, &afdw, fdwDetails);
     if (mmr == MMSYSERR_NOERROR) {
-        pafd->dwFormatTag = afdw.dwFormatTag; 
-        pafd->fdwSupport = afdw.fdwSupport; 
+    pafd->dwFormatTag = afdw.dwFormatTag;
+    pafd->fdwSupport = afdw.fdwSupport;
         WideCharToMultiByte( CP_ACP, 0, afdw.szFormat, -1,
                              pafd->szFormat, sizeof(pafd->szFormat), NULL, NULL );
@@ -291 +291 @@
  *           acmFormatDetailsW (MSACM32.26)
  */
-MMRESULT WINAPI acmFormatDetailsW(HACMDRIVER had, PACMFORMATDETAILSW pafd, 
-                                  DWORD fdwDetails)
-{
-    MMRESULT                    mmr;
-    static WCHAR                fmt1[] = {'%','d',' ','H','z',0};
-    static WCHAR                fmt2[] = {';',' ','%','d',' ','b','i','t','s',0};
-    ACMFORMATTAGDETAILSA        aftd;
+MMRESULT WINAPI acmFormatDetailsW(HACMDRIVER had, PACMFORMATDETAILSW pafd,
+                  DWORD fdwDetails)
+{
+    MMRESULT            mmr;
+    static WCHAR        fmt1[] = {'%','d',' ','H','z',0};
+    static WCHAR        fmt2[] = {';',' ','%','d',' ','b','i','t','s',0};
+    ACMFORMATTAGDETAILSA    aftd;
 
     TRACE("(0x%08x, %p, %ld)\n", had, pafd, fdwDetails);
@@ -305 +305 @@
 
     if (pafd->cbStruct < sizeof(*pafd)) return MMSYSERR_INVALPARAM;
-        
+
     switch (fdwDetails) {
     case ACM_FORMATDETAILSF_FORMAT:
-        if (pafd->dwFormatTag != pafd->pwfx->wFormatTag) {
-            mmr = MMSYSERR_INVALPARAM;
-            break;
-        }
-        if (had == (HACMDRIVER)NULL) {
-            PWINE_ACMDRIVERID           padid;
-
-            mmr = ACMERR_NOTPOSSIBLE;
-            for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
-                /* should check for codec only */
-                if (padid->bEnabled && 
-                    acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
-                    mmr = MSACM_Message(had, ACMDM_FORMAT_DETAILS,
-                                        (LPARAM)pafd, (LPARAM)fdwDetails);
-                    acmDriverClose(had, 0);
-                    if (mmr == MMSYSERR_NOERROR) break;
-                }
-            }               
-        } else {
-            mmr = MSACM_Message(had, ACMDM_FORMAT_DETAILS,
-                                (LPARAM)pafd, (LPARAM)fdwDetails);
-        }
-        break;
+    if (pafd->dwFormatTag != pafd->pwfx->wFormatTag) {
+        mmr = MMSYSERR_INVALPARAM;
+        break;
+    }
+    if (had == (HACMDRIVER)NULL) {
+        PWINE_ACMDRIVERID       padid;
+
+        mmr = ACMERR_NOTPOSSIBLE;
+        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
+        /* should check for codec only */
+        if (padid->bEnabled &&
+            acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
+            mmr = MSACM_Message(had, ACMDM_FORMAT_DETAILS,
+                    (LPARAM)pafd, (LPARAM)fdwDetails);
+            acmDriverClose(had, 0);
+            if (mmr == MMSYSERR_NOERROR) break;
+        }
+        }
+    } else {
+        mmr = MSACM_Message(had, ACMDM_FORMAT_DETAILS,
+                (LPARAM)pafd, (LPARAM)fdwDetails);
+    }
+    break;
     case ACM_FORMATDETAILSF_INDEX:
-        /* should check pafd->dwFormatIndex < aftd->cStandardFormats */
-        mmr = MSACM_Message(had, ACMDM_FORMAT_DETAILS,
-                            (LPARAM)pafd, (LPARAM)fdwDetails);
-        break;
+    /* should check pafd->dwFormatIndex < aftd->cStandardFormats */
+    mmr = MSACM_Message(had, ACMDM_FORMAT_DETAILS,
+                (LPARAM)pafd, (LPARAM)fdwDetails);
+    break;
     default:
-        WARN("Unknown fdwDetails %08lx\n", fdwDetails);
-        mmr = MMSYSERR_INVALFLAG;
-        break;
+    WARN("Unknown fdwDetails %08lx\n", fdwDetails);
+    mmr = MMSYSERR_INVALFLAG;
+    break;
     }
 
     if (mmr == MMSYSERR_NOERROR && pafd->szFormat[0] == (WCHAR)0) {
-        wsprintfW(pafd->szFormat, fmt1, pafd->pwfx->nSamplesPerSec);
-        if (pafd->pwfx->wBitsPerSample) {
-            wsprintfW(pafd->szFormat + lstrlenW(pafd->szFormat), fmt2, 
-                      pafd->pwfx->wBitsPerSample);
-        }
+    wsprintfW(pafd->szFormat, fmt1, pafd->pwfx->nSamplesPerSec);
+    if (pafd->pwfx->wBitsPerSample) {
+        wsprintfW(pafd->szFormat + lstrlenW(pafd->szFormat), fmt2,
+              pafd->pwfx->wBitsPerSample);
+    }
         MultiByteToWideChar( CP_ACP, 0, (pafd->pwfx->nChannels == 1) ? "; Mono" : "; Stereo", -1,
                              pafd->szFormat + strlenW(pafd->szFormat),
@@ -358 +358 @@
 
 struct MSACM_FormatEnumWtoA_Instance {
-    PACMFORMATDETAILSA  pafda;
-    DWORD               dwInstance;
-    ACMFORMATENUMCBA    fnCallback;
+    PACMFORMATDETAILSA  pafda;
+    DWORD       dwInstance;
+    ACMFORMATENUMCBA    fnCallback;
 };
 
 static BOOL CALLBACK MSACM_FormatEnumCallbackWtoA(HACMDRIVERID hadid,
-                                                  PACMFORMATDETAILSW pafdw,  
-                                                  DWORD dwInstance,             
-                                                  DWORD fdwSupport)
+                          PACMFORMATDETAILSW pafdw,
+                          DWORD dwInstance,
+                          DWORD fdwSupport)
 {
     struct MSACM_FormatEnumWtoA_Instance* pafei;
@@ -372 +372 @@
     pafei = (struct MSACM_FormatEnumWtoA_Instance*)dwInstance;
 
-    pafei->pafda->dwFormatIndex = pafdw->dwFormatIndex; 
-    pafei->pafda->dwFormatTag = pafdw->dwFormatTag; 
-    pafei->pafda->fdwSupport = pafdw->fdwSupport; 
+    pafei->pafda->dwFormatIndex = pafdw->dwFormatIndex;
+    pafei->pafda->dwFormatTag = pafdw->dwFormatTag;
+    pafei->pafda->fdwSupport = pafdw->fdwSupport;
     WideCharToMultiByte( CP_ACP, 0, pafdw->szFormat, -1,
                          pafei->pafda->szFormat, sizeof(pafei->pafda->szFormat), NULL, NULL );
 
-    return (pafei->fnCallback)(hadid, pafei->pafda, 
-                               pafei->dwInstance, fdwSupport);
+    return (pafei->fnCallback)(hadid, pafei->pafda,
+                   pafei->dwInstance, fdwSupport);
 }
 
@@ -386 +386 @@
  */
 MMRESULT WINAPI acmFormatEnumA(HACMDRIVER had, PACMFORMATDETAILSA pafda,
-                               ACMFORMATENUMCBA fnCallback, DWORD dwInstance, 
-                               DWORD fdwEnum)
-{
-    ACMFORMATDETAILSW           afdw;
+                   ACMFORMATENUMCBA fnCallback, DWORD dwInstance,
+                   DWORD fdwEnum)
+{
+    ACMFORMATDETAILSW       afdw;
     struct MSACM_FormatEnumWtoA_Instance afei;
 
@@ -403 +403 @@
     afei.fnCallback = fnCallback;
 
-    return acmFormatEnumW(had, &afdw, MSACM_FormatEnumCallbackWtoA, 
-                          (DWORD)&afei, fdwEnum);
+    return acmFormatEnumW(had, &afdw, MSACM_FormatEnumCallbackWtoA,
+              (DWORD)&afei, fdwEnum);
 }
 
@@ -410 +410 @@
  *           acmFormatEnumW (MSACM32.28)
  */
-static BOOL MSACM_FormatEnumHelper(PWINE_ACMDRIVERID padid, HACMDRIVER had, 
-                                   PACMFORMATDETAILSW pafd, PWAVEFORMATEX pwfxRef, 
-                                   ACMFORMATENUMCBW fnCallback, DWORD dwInstance,  
-                                   DWORD fdwEnum)
-{
-    ACMDRIVERDETAILSW           add;
-    ACMFORMATTAGDETAILSW        aftd;
-    int                         i, j;
+static BOOL MSACM_FormatEnumHelper(PWINE_ACMDRIVERID padid, HACMDRIVER had,
+                   PACMFORMATDETAILSW pafd, PWAVEFORMATEX pwfxRef,
+                   ACMFORMATENUMCBW fnCallback, DWORD dwInstance,
+                   DWORD fdwEnum)
+{
+    ACMDRIVERDETAILSW       add;
+    ACMFORMATTAGDETAILSW    aftd;
+    int             i, j;
 
     add.cbStruct = sizeof(add);
-    
+
     if (acmDriverDetailsW((HACMDRIVERID)padid, &add, 0) != MMSYSERR_NOERROR) return FALSE;
 
     for (i = 0; i < add.cFormatTags; i++) {
-        memset(&aftd, 0, sizeof(aftd));
-        aftd.cbStruct = sizeof(aftd);
-        aftd.dwFormatTagIndex = i;
-        if (acmFormatTagDetailsW(had, &aftd, ACM_FORMATTAGDETAILSF_INDEX) != MMSYSERR_NOERROR)
-            continue;
-        
-        if ((fdwEnum & ACM_FORMATENUMF_WFORMATTAG) && aftd.dwFormatTag != pwfxRef->wFormatTag)
-            continue;
-        
-        for (j = 0; j < aftd.cStandardFormats; j++) {
-            pafd->dwFormatIndex = j;
-            pafd->dwFormatTag = aftd.dwFormatTag;
-            if (acmFormatDetailsW(had, pafd, ACM_FORMATDETAILSF_INDEX) != MMSYSERR_NOERROR) 
-                continue;
-            
-            if ((fdwEnum & ACM_FORMATENUMF_NCHANNELS) && 
-                pafd->pwfx->nChannels != pwfxRef->nChannels)
-                continue;
-            if ((fdwEnum & ACM_FORMATENUMF_NSAMPLESPERSEC) && 
-                pafd->pwfx->nSamplesPerSec != pwfxRef->nSamplesPerSec)
-                continue;
-            if ((fdwEnum & ACM_FORMATENUMF_WBITSPERSAMPLE) && 
-                pafd->pwfx->wBitsPerSample != pwfxRef->wBitsPerSample)
-                continue;
-            if ((fdwEnum & ACM_FORMATENUMF_HARDWARE) &&
-                !(pafd->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_HARDWARE))
-                continue;
-            
-            /* more checks to be done on fdwEnum */
-
-            if (!(fnCallback)((HACMDRIVERID)padid, pafd, dwInstance, add.fdwSupport))
-                return FALSE; 
-        }
-        /* the "formats" used by the filters are also reported */
+    memset(&aftd, 0, sizeof(aftd));
+    aftd.cbStruct = sizeof(aftd);
+    aftd.dwFormatTagIndex = i;
+    if (acmFormatTagDetailsW(had, &aftd, ACM_FORMATTAGDETAILSF_INDEX) != MMSYSERR_NOERROR)
+        continue;
+
+    if ((fdwEnum & ACM_FORMATENUMF_WFORMATTAG) && aftd.dwFormatTag != pwfxRef->wFormatTag)
+        continue;
+
+    for (j = 0; j < aftd.cStandardFormats; j++) {
+        pafd->dwFormatIndex = j;
+        pafd->dwFormatTag = aftd.dwFormatTag;
+        if (acmFormatDetailsW(had, pafd, ACM_FORMATDETAILSF_INDEX) != MMSYSERR_NOERROR)
+        continue;
+
+        if ((fdwEnum & ACM_FORMATENUMF_NCHANNELS) &&
+        pafd->pwfx->nChannels != pwfxRef->nChannels)
+        continue;
+        if ((fdwEnum & ACM_FORMATENUMF_NSAMPLESPERSEC) &&
+        pafd->pwfx->nSamplesPerSec != pwfxRef->nSamplesPerSec)
+        continue;
+        if ((fdwEnum & ACM_FORMATENUMF_WBITSPERSAMPLE) &&
+        pafd->pwfx->wBitsPerSample != pwfxRef->wBitsPerSample)
+        continue;
+        if ((fdwEnum & ACM_FORMATENUMF_HARDWARE) &&
+        !(pafd->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_HARDWARE))
+        continue;
+
+        /* more checks to be done on fdwEnum */
+
+        if (!(fnCallback)((HACMDRIVERID)padid, pafd, dwInstance, add.fdwSupport))
+        return FALSE;
+    }
+    /* the "formats" used by the filters are also reported */
     }
     return TRUE;
@@ -465 +465 @@
 
 MMRESULT WINAPI acmFormatEnumW(HACMDRIVER had, PACMFORMATDETAILSW pafd,
-                               ACMFORMATENUMCBW fnCallback, DWORD dwInstance,  
-                               DWORD fdwEnum)
-{
-    PWINE_ACMDRIVERID           padid;
-    WAVEFORMATEX                wfxRef;
-    BOOL                        ret;
+                   ACMFORMATENUMCBW fnCallback, DWORD dwInstance,
+                   DWORD fdwEnum)
+{
+    PWINE_ACMDRIVERID       padid;
+    WAVEFORMATEX        wfxRef;
+    BOOL            ret;
 
     TRACE("(0x%08x, %p, %p, %ld, %ld)\n",
-          had, pafd, fnCallback, dwInstance, fdwEnum);
+      had, pafd, fnCallback, dwInstance, fdwEnum);
 
     if (pafd->cbStruct < sizeof(*pafd)) return MMSYSERR_INVALPARAM;
 
     if (fdwEnum & (ACM_FORMATENUMF_WFORMATTAG|ACM_FORMATENUMF_NCHANNELS|
-                   ACM_FORMATENUMF_NSAMPLESPERSEC|ACM_FORMATENUMF_WBITSPERSAMPLE|
-                   ACM_FORMATENUMF_CONVERT|ACM_FORMATENUMF_SUGGEST))
+           ACM_FORMATENUMF_NSAMPLESPERSEC|ACM_FORMATENUMF_WBITSPERSAMPLE|
+           ACM_FORMATENUMF_CONVERT|ACM_FORMATENUMF_SUGGEST))
         wfxRef = *pafd->pwfx;
 
-    if ((fdwEnum & ACM_FORMATENUMF_HARDWARE) && 
-        !(fdwEnum & (ACM_FORMATENUMF_INPUT|ACM_FORMATENUMF_OUTPUT)))
-        return MMSYSERR_INVALPARAM;
+    if ((fdwEnum & ACM_FORMATENUMF_HARDWARE) &&
+    !(fdwEnum & (ACM_FORMATENUMF_INPUT|ACM_FORMATENUMF_OUTPUT)))
+    return MMSYSERR_INVALPARAM;
 
     if ((fdwEnum & ACM_FORMATENUMF_WFORMATTAG) &&
-        (pafd->dwFormatTag != pafd->pwfx->wFormatTag))
-        return MMSYSERR_INVALPARAM;
+    (pafd->dwFormatTag != pafd->pwfx->wFormatTag))
+    return MMSYSERR_INVALPARAM;
 
     if (fdwEnum & (ACM_FORMATENUMF_CONVERT|ACM_FORMATENUMF_SUGGEST|
-                   ACM_FORMATENUMF_INPUT|ACM_FORMATENUMF_OUTPUT))
-        FIXME("Unsupported fdwEnum values %08lx\n", fdwEnum);
+           ACM_FORMATENUMF_INPUT|ACM_FORMATENUMF_OUTPUT))
+    FIXME("Unsupported fdwEnum values %08lx\n", fdwEnum);
 
     if (had) {
-        HACMDRIVERID    hadid;
-
-        if (acmDriverID(had, &hadid, 0) != MMSYSERR_NOERROR)
-            return MMSYSERR_INVALHANDLE;
-        MSACM_FormatEnumHelper(MSACM_GetDriverID(hadid), had, pafd, &wfxRef, 
-                               fnCallback, dwInstance, fdwEnum);
-        return MMSYSERR_NOERROR;
+    HACMDRIVERID    hadid;
+
+    if (acmDriverID(had, &hadid, 0) != MMSYSERR_NOERROR)
+        return MMSYSERR_INVALHANDLE;
+    MSACM_FormatEnumHelper(MSACM_GetDriverID(hadid), had, pafd, &wfxRef,
+                   fnCallback, dwInstance, fdwEnum);
+    return MMSYSERR_NOERROR;
     }
     for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
-            /* should check for codec only */
-            if (!padid->bEnabled || acmDriverOpen(&had, (HACMDRIVERID)padid, 0) != MMSYSERR_NOERROR)
-                continue;
-            ret = MSACM_FormatEnumHelper(padid, had, pafd, &wfxRef, 
-                                         fnCallback, dwInstance, fdwEnum);
-            acmDriverClose(had, 0);
-            if (!ret) break;
+        /* should check for codec only */
+        if (!padid->bEnabled || acmDriverOpen(&had, (HACMDRIVERID)padid, 0) != MMSYSERR_NOERROR)
+        continue;
+        ret = MSACM_FormatEnumHelper(padid, had, pafd, &wfxRef,
+                     fnCallback, dwInstance, fdwEnum);
+        acmDriverClose(had, 0);
+        if (!ret) break;
     }
     return MMSYSERR_NOERROR;
@@ -518 +518 @@
  *           acmFormatSuggest (MSACM32.29)
  */
-MMRESULT WINAPI acmFormatSuggest(HACMDRIVER had, PWAVEFORMATEX pwfxSrc, 
-                                 PWAVEFORMATEX pwfxDst, DWORD cbwfxDst, DWORD fdwSuggest)
-{
-    ACMDRVFORMATSUGGEST adfg;
-    MMRESULT            mmr;
-
-    TRACE("(0x%08x, %p, %p, %ld, %ld)\n", 
-          had, pwfxSrc, pwfxDst, cbwfxDst, fdwSuggest);
+MMRESULT WINAPI acmFormatSuggest(HACMDRIVER had, PWAVEFORMATEX pwfxSrc,
+                 PWAVEFORMATEX pwfxDst, DWORD cbwfxDst, DWORD fdwSuggest)
+{
+    ACMDRVFORMATSUGGEST adfg;
+    MMRESULT        mmr;
+
+    TRACE("(0x%08x, %p, %p, %ld, %ld)\n",
+      had, pwfxSrc, pwfxDst, cbwfxDst, fdwSuggest);
 
     if (fdwSuggest & ~(ACM_FORMATSUGGESTF_NCHANNELS|ACM_FORMATSUGGESTF_NSAMPLESPERSEC|
-                       ACM_FORMATSUGGESTF_WBITSPERSAMPLE|ACM_FORMATSUGGESTF_WFORMATTAG))
-        return MMSYSERR_INVALFLAG;
+               ACM_FORMATSUGGESTF_WBITSPERSAMPLE|ACM_FORMATSUGGESTF_WFORMATTAG))
+    return MMSYSERR_INVALFLAG;
 
     adfg.cbStruct = sizeof(adfg);
@@ -535 +535 @@
     adfg.pwfxSrc = pwfxSrc;
     adfg.cbwfxSrc = (pwfxSrc->wFormatTag == WAVE_FORMAT_PCM) ?
-        sizeof(WAVEFORMATEX) : pwfxSrc->cbSize;
+    sizeof(WAVEFORMATEX) : pwfxSrc->cbSize;
     adfg.pwfxDst = pwfxDst;
     adfg.cbwfxDst = cbwfxDst;
 
     if (had == (HACMDRIVER)NULL) {
-        PWINE_ACMDRIVERID       padid;
-        
-        /* MS doc says: ACM finds the best suggestion. 
-         * Well, first found will be the "best"
-         */
-        mmr = ACMERR_NOTPOSSIBLE;
-        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
-            /* should check for codec only */
-            if (!padid->bEnabled ||
-                acmDriverOpen(&had, (HACMDRIVERID)padid, 0) != MMSYSERR_NOERROR)
-                continue;
-            
-            if (MSACM_Message(had, ACMDM_FORMAT_SUGGEST, 
-                              (LPARAM)&adfg, 0L) == MMSYSERR_NOERROR) {
-                mmr = MMSYSERR_NOERROR;
-                break;
-            }
-            acmDriverClose(had, 0);
-        }
+    PWINE_ACMDRIVERID   padid;
+
+    /* MS doc says: ACM finds the best suggestion.
+     * Well, first found will be the "best"
+     */
+    mmr = ACMERR_NOTPOSSIBLE;
+    for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
+        /* should check for codec only */
+        if (!padid->bEnabled ||
+        acmDriverOpen(&had, (HACMDRIVERID)padid, 0) != MMSYSERR_NOERROR)
+        continue;
+
+        if (MSACM_Message(had, ACMDM_FORMAT_SUGGEST,
+                  (LPARAM)&adfg, 0L) == MMSYSERR_NOERROR) {
+        mmr = MMSYSERR_NOERROR;
+        break;
+        }
+        acmDriverClose(had, 0);
+    }
     } else {
-        mmr = MSACM_Message(had, ACMDM_FORMAT_SUGGEST, (LPARAM)&adfg, 0L);
+    mmr = MSACM_Message(had, ACMDM_FORMAT_SUGGEST, (LPARAM)&adfg, 0L);
     }
     return mmr;
@@ -568 +568 @@
  *           acmFormatTagDetailsA (MSACM32.30)
  */
-MMRESULT WINAPI acmFormatTagDetailsA(HACMDRIVER had, PACMFORMATTAGDETAILSA paftda, 
-                                     DWORD fdwDetails)
-{
-    ACMFORMATTAGDETAILSW        aftdw;
-    MMRESULT                    mmr;
+MMRESULT WINAPI acmFormatTagDetailsA(HACMDRIVER had, PACMFORMATTAGDETAILSA paftda,
+                     DWORD fdwDetails)
+{
+    ACMFORMATTAGDETAILSW    aftdw;
+    MMRESULT            mmr;
 
     memset(&aftdw, 0, sizeof(aftdw));
@@ -581 +581 @@
     mmr = acmFormatTagDetailsW(had, &aftdw, fdwDetails);
     if (mmr == MMSYSERR_NOERROR) {
-        paftda->dwFormatTag = aftdw.dwFormatTag; 
-        paftda->dwFormatTagIndex = aftdw.dwFormatTagIndex;
-        paftda->cbFormatSize = aftdw.cbFormatSize; 
-        paftda->fdwSupport = aftdw.fdwSupport; 
-        paftda->cStandardFormats = aftdw.cStandardFormats; 
+    paftda->dwFormatTag = aftdw.dwFormatTag;
+    paftda->dwFormatTagIndex = aftdw.dwFormatTagIndex;
+    paftda->cbFormatSize = aftdw.cbFormatSize;
+    paftda->fdwSupport = aftdw.fdwSupport;
+    paftda->cStandardFormats = aftdw.cStandardFormats;
         WideCharToMultiByte( CP_ACP, 0, aftdw.szFormatTag, -1, paftda->szFormatTag,
                              sizeof(paftda->szFormatTag), NULL, NULL );
@@ -595 +595 @@
  *           acmFormatTagDetailsW (MSACM32.31)
  */
-MMRESULT WINAPI acmFormatTagDetailsW(HACMDRIVER had, PACMFORMATTAGDETAILSW paftd, 
-                                     DWORD fdwDetails)
-{
-    PWINE_ACMDRIVERID   padid;
-    MMRESULT            mmr;
+MMRESULT WINAPI acmFormatTagDetailsW(HACMDRIVER had, PACMFORMATTAGDETAILSW paftd,
+                     DWORD fdwDetails)
+{
+    PWINE_ACMDRIVERID   padid;
+    MMRESULT        mmr;
 
     TRACE("(0x%08x, %p, %ld)\n", had, paftd, fdwDetails);
 
     if (fdwDetails & ~(ACM_FORMATTAGDETAILSF_FORMATTAG|ACM_FORMATTAGDETAILSF_INDEX|
-                       ACM_FORMATTAGDETAILSF_LARGESTSIZE))
-        return MMSYSERR_INVALFLAG;
+               ACM_FORMATTAGDETAILSF_LARGESTSIZE))
+    return MMSYSERR_INVALFLAG;
 
     switch (fdwDetails) {
     case ACM_FORMATTAGDETAILSF_FORMATTAG:
-        if (had == (HACMDRIVER)NULL) {
-            mmr = ACMERR_NOTPOSSIBLE;
-            for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
-                /* should check for codec only */
-                if (padid->bEnabled && acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
-                    mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
-                                        (LPARAM)paftd, (LPARAM)fdwDetails);
-                    acmDriverClose(had, 0);
-                    if (mmr == MMSYSERR_NOERROR) break;
-                }
-            }
-        } else {
-            mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
-                                (LPARAM)paftd, (LPARAM)fdwDetails);
-        }
-        break;
+    if (had == (HACMDRIVER)NULL) {
+        mmr = ACMERR_NOTPOSSIBLE;
+        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
+        /* should check for codec only */
+        if (padid->bEnabled && acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
+            mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
+                    (LPARAM)paftd, (LPARAM)fdwDetails);
+            acmDriverClose(had, 0);
+            if (mmr == MMSYSERR_NOERROR) break;
+        }
+        }
+    } else {
+        mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
+                (LPARAM)paftd, (LPARAM)fdwDetails);
+    }
+    break;
 
     case ACM_FORMATTAGDETAILSF_INDEX:
-        /* FIXME should check paftd->dwFormatTagIndex < add.cFormatTags */
-        mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
-                            (LPARAM)paftd, (LPARAM)fdwDetails);
-        break;
+    /* FIXME should check paftd->dwFormatTagIndex < add.cFormatTags */
+    mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
+                (LPARAM)paftd, (LPARAM)fdwDetails);
+    break;
 
     case ACM_FORMATTAGDETAILSF_LARGESTSIZE:
-        if (had == (HACMDRIVER)NULL) {
-            ACMFORMATTAGDETAILSW        tmp;
-            DWORD                       ft = paftd->dwFormatTag;
-
-            mmr = ACMERR_NOTPOSSIBLE;
-            for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
-                /* should check for codec only */
-                if (padid->bEnabled && 
-                    acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
-
-                    memset(&tmp, 0, sizeof(tmp));
-                    tmp.cbStruct = sizeof(tmp);
-                    tmp.dwFormatTag = ft;
-
-                    if (MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
-                                      (LPARAM)&tmp, 
-                                      (LPARAM)fdwDetails) == MMSYSERR_NOERROR) {
-                        if (mmr == ACMERR_NOTPOSSIBLE ||
-                            paftd->cbFormatSize < tmp.cbFormatSize) {
-                            *paftd = tmp;
-                            mmr = MMSYSERR_NOERROR;
-                        } 
-                    }
-                    acmDriverClose(had, 0);
-                }
-            }
-        } else {
-            mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
-                                (LPARAM)paftd, (LPARAM)fdwDetails);
-        }
-        break;
+    if (had == (HACMDRIVER)NULL) {
+        ACMFORMATTAGDETAILSW    tmp;
+        DWORD           ft = paftd->dwFormatTag;
+
+        mmr = ACMERR_NOTPOSSIBLE;
+        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
+        /* should check for codec only */
+        if (padid->bEnabled &&
+            acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
+
+            memset(&tmp, 0, sizeof(tmp));
+            tmp.cbStruct = sizeof(tmp);
+            tmp.dwFormatTag = ft;
+
+            if (MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
+                      (LPARAM)&tmp,
+                      (LPARAM)fdwDetails) == MMSYSERR_NOERROR) {
+            if (mmr == ACMERR_NOTPOSSIBLE ||
+                paftd->cbFormatSize < tmp.cbFormatSize) {
+                *paftd = tmp;
+                mmr = MMSYSERR_NOERROR;
+            }
+            }
+            acmDriverClose(had, 0);
+        }
+        }
+    } else {
+        mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
+                (LPARAM)paftd, (LPARAM)fdwDetails);
+    }
+    break;
 
     default:
-        WARN("Unsupported fdwDetails=%08lx\n", fdwDetails);
-        mmr = MMSYSERR_ERROR;
-    }
-
-    if (mmr == MMSYSERR_NOERROR && 
-        paftd->dwFormatTag == WAVE_FORMAT_PCM && paftd->szFormatTag[0] == 0)
+    WARN("Unsupported fdwDetails=%08lx\n", fdwDetails);
+    mmr = MMSYSERR_ERROR;
+    }
+
+    if (mmr == MMSYSERR_NOERROR &&
+    paftd->dwFormatTag == WAVE_FORMAT_PCM && paftd->szFormatTag[0] == 0)
         MultiByteToWideChar( CP_ACP, 0, "PCM", -1, paftd->szFormatTag,
                              sizeof(paftd->szFormatTag)/sizeof(WCHAR) );
@@ -679 +679 @@
 
 struct MSACM_FormatTagEnumWtoA_Instance {
-    PACMFORMATTAGDETAILSA       paftda;
-    DWORD                       dwInstance;
-    ACMFORMATTAGENUMCBA         fnCallback;
+    PACMFORMATTAGDETAILSA   paftda;
+    DWORD           dwInstance;
+    ACMFORMATTAGENUMCBA     fnCallback;
 };
 
 static BOOL CALLBACK MSACM_FormatTagEnumCallbackWtoA(HACMDRIVERID hadid,
-                                                     PACMFORMATTAGDETAILSW paftdw,  
-                                                     DWORD dwInstance,             
-                                                     DWORD fdwSupport)
+                             PACMFORMATTAGDETAILSW paftdw,
+                             DWORD dwInstance,
+                             DWORD fdwSupport)
 {
     struct MSACM_FormatTagEnumWtoA_Instance* paftei;
@@ -693 +693 @@
     paftei = (struct MSACM_FormatTagEnumWtoA_Instance*)dwInstance;
 
-    paftei->paftda->dwFormatTagIndex = paftdw->dwFormatTagIndex; 
-    paftei->paftda->dwFormatTag = paftdw->dwFormatTag; 
-    paftei->paftda->cbFormatSize = paftdw->cbFormatSize; 
-    paftei->paftda->fdwSupport = paftdw->fdwSupport; 
-    paftei->paftda->cStandardFormats = paftdw->cStandardFormats; 
+    paftei->paftda->dwFormatTagIndex = paftdw->dwFormatTagIndex;
+    paftei->paftda->dwFormatTag = paftdw->dwFormatTag;
+    paftei->paftda->cbFormatSize = paftdw->cbFormatSize;
+    paftei->paftda->fdwSupport = paftdw->fdwSupport;
+    paftei->paftda->cStandardFormats = paftdw->cStandardFormats;
     WideCharToMultiByte( CP_ACP, 0, paftdw->szFormatTag, -1, paftei->paftda->szFormatTag,
                          sizeof(paftei->paftda->szFormatTag), NULL, NULL );
 
-    return (paftei->fnCallback)(hadid, paftei->paftda, 
-                                paftei->dwInstance, fdwSupport);
+    return (paftei->fnCallback)(hadid, paftei->paftda,
+                paftei->dwInstance, fdwSupport);
 }
 
@@ -709 +709 @@
  */
 MMRESULT WINAPI acmFormatTagEnumA(HACMDRIVER had, PACMFORMATTAGDETAILSA paftda,
-                                  ACMFORMATTAGENUMCBA fnCallback, DWORD dwInstance, 
-                                  DWORD fdwEnum)
-{
-    ACMFORMATTAGDETAILSW        aftdw;
+                  ACMFORMATTAGENUMCBA fnCallback, DWORD dwInstance,
+                  DWORD fdwEnum)
+{
+    ACMFORMATTAGDETAILSW    aftdw;
     struct MSACM_FormatTagEnumWtoA_Instance aftei;
 
@@ -724 +724 @@
     aftei.fnCallback = fnCallback;
 
-    return acmFormatTagEnumW(had, &aftdw, MSACM_FormatTagEnumCallbackWtoA, 
-                             (DWORD)&aftei, fdwEnum);
+    return acmFormatTagEnumW(had, &aftdw, MSACM_FormatTagEnumCallbackWtoA,
+                 (DWORD)&aftei, fdwEnum);
 }
 
@@ -732 +732 @@
  */
 MMRESULT WINAPI acmFormatTagEnumW(HACMDRIVER had, PACMFORMATTAGDETAILSW paftd,
-                                  ACMFORMATTAGENUMCBW fnCallback, DWORD dwInstance, 
-                                  DWORD fdwEnum)
-{
-    PWINE_ACMDRIVERID           padid;
-    ACMDRIVERDETAILSW           add;
-    int                         i;
-    BOOL                        bPcmDone = FALSE;
+                  ACMFORMATTAGENUMCBW fnCallback, DWORD dwInstance,
+                  DWORD fdwEnum)
+{
+    PWINE_ACMDRIVERID       padid;
+    ACMDRIVERDETAILSW       add;
+    int             i;
+    BOOL            bPcmDone = FALSE;
 
     TRACE("(0x%08x, %p, %p, %ld, %ld)\n",
-          had, paftd, fnCallback, dwInstance, fdwEnum); 
+      had, paftd, fnCallback, dwInstance, fdwEnum);
 
     if (paftd->cbStruct < sizeof(*paftd)) return MMSYSERR_INVALPARAM;
 
     if (had) FIXME("had != NULL, not supported\n");
-    
+
     for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
-        /* should check for codec only */
-        if (padid->bEnabled && acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == MMSYSERR_NOERROR) {
-            add.cbStruct = sizeof(add);
-
-            if (acmDriverDetailsW((HACMDRIVERID)padid, &add, 0) == MMSYSERR_NOERROR) {
-                for (i = 0; i < add.cFormatTags; i++) {
-                    paftd->dwFormatTagIndex = i;
-                    if (acmFormatTagDetailsW(had, paftd, ACM_FORMATTAGDETAILSF_INDEX) == MMSYSERR_NOERROR) {
-                        if (paftd->dwFormatTag == WAVE_FORMAT_PCM) {
-                            /* FIXME (EPP): I'm not sure this is the correct 
-                             * algorithm (should make more sense to apply the same
-                             * for all already loaded formats, but this will do 
-                             * for now
-                             */
-                            if (bPcmDone) continue;
-                            bPcmDone = TRUE;
-                        }
-                        if (!(fnCallback)((HACMDRIVERID)padid, paftd, dwInstance, 
-                                          add.fdwSupport)) {
-                            padid = NULL;
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-        acmDriverClose(had, 0);
+    /* should check for codec only */
+    if (padid->bEnabled && acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == MMSYSERR_NOERROR) {
+        add.cbStruct = sizeof(add);
+
+        if (acmDriverDetailsW((HACMDRIVERID)padid, &add, 0) == MMSYSERR_NOERROR) {
+        for (i = 0; i < add.cFormatTags; i++) {
+            paftd->dwFormatTagIndex = i;
+            if (acmFormatTagDetailsW(had, paftd, ACM_FORMATTAGDETAILSF_INDEX) == MMSYSERR_NOERROR) {
+            if (paftd->dwFormatTag == WAVE_FORMAT_PCM) {
+                /* FIXME (EPP): I'm not sure this is the correct
+                 * algorithm (should make more sense to apply the same
+                 * for all already loaded formats, but this will do
+                 * for now
+                 */
+                if (bPcmDone) continue;
+                bPcmDone = TRUE;
+            }
+            if (!(fnCallback)((HACMDRIVERID)padid, paftd, dwInstance,
+                      add.fdwSupport)) {
+                padid = NULL;
+                break;
+            }
+            }
+        }
+        }
+    }
+    acmDriverClose(had, 0);
     }
     return MMSYSERR_NOERROR;

trunk/src/msacm32/initterm.cpp

@@ -1 @@
-/*
+/* $Id: initterm.cpp,v 1.7 2001-09-05 13:11:25 bird Exp $
+ *
  * DLL entry point
  *
@@ -53 +54 @@
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
-        return MSACM32_LibMain(hinstDLL, fdwReason, fImpLoad);
+    return MSACM32_LibMain(hinstDLL, fdwReason, fImpLoad);
 
    case DLL_PROCESS_DETACH:
-        MSACM32_LibMain(hinstDLL, fdwReason, fImpLoad);
-        ctordtorTerm();
-        return TRUE;
+    MSACM32_LibMain(hinstDLL, fdwReason, fImpLoad);
+    ctordtorTerm();
+    return TRUE;
    }
    return FALSE;
@@ -88 +89 @@
          CheckVersionFromHMOD(PE2LX_VERSION, hModule); /*PLF Wed  98-03-18 05:28:48*/
 
-         dllHandle = RegisterLxDll(hModule, LibMain, (PVOID)&_Resource_PEResTab);
-         if(dllHandle == 0) 
-                return 0UL;
+     dllHandle = RegisterLxDll(hModule, LibMain, (PVOID)&_Resource_PEResTab);
+         if(dllHandle == 0)
+        return 0UL;
 
          break;
       case 1 :
          if(dllHandle) {
-                UnregisterLxDll(dllHandle);
+        UnregisterLxDll(dllHandle);
          }
          break;

trunk/src/msacm32/internal.c

@@ -1 +1 @@
 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
-
+/* $Id: internal.c,v 1.2 2001-09-05 13:11:26 bird Exp $ */
 /*
  *      MSACM32 library
  *
  *      Copyright 1998  Patrik Stridvall
- *                1999  Eric Pouech
+ *        1999  Eric Pouech
  */
 
@@ -34 +34 @@
 
 /***********************************************************************
- *           MSACM_RegisterDriver() 
+ *           MSACM_RegisterDriver()
  */
 PWINE_ACMDRIVERID MSACM_RegisterDriver(LPSTR pszDriverAlias, LPSTR pszFileName,
-                                       HINSTANCE hinstModule)
-{ 
+                       HINSTANCE hinstModule)
+{
     PWINE_ACMDRIVERID padid;
 
@@ -64 +64 @@
     padid->pPrevACMDriverID = MSACM_pLastACMDriverID;
     if (MSACM_pLastACMDriverID)
-        MSACM_pLastACMDriverID->pNextACMDriverID = padid;
+    MSACM_pLastACMDriverID->pNextACMDriverID = padid;
     MSACM_pLastACMDriverID = padid;
     if (!MSACM_pFirstACMDriverID)
-        MSACM_pFirstACMDriverID = padid;
-    
+    MSACM_pFirstACMDriverID = padid;
+
     return padid;
 }
 
 /***********************************************************************
- *           MSACM_RegisterAllDrivers() 
+ *           MSACM_RegisterAllDrivers()
  */
 void MSACM_RegisterAllDrivers(void)
@@ -80 +80 @@
     DWORD dwBufferLength;
 
-    /* FIXME 
+    /* FIXME
      *  What if the user edits system.ini while the program is running?
      *  Does Windows handle that?
      */
     if (MSACM_pFirstACMDriverID)
-        return;
-    
+    return;
+
     /* FIXME: Do not work! How do I determine the section length? */
     dwBufferLength = 1024;
-/* EPP  GetPrivateProfileSectionA("drivers32", NULL, 0, "system.ini"); */
-    
+/* EPP  GetPrivateProfileSectionA("drivers32", NULL, 0, "system.ini"); */
+
     pszBuffer = (LPSTR) HeapAlloc(MSACM_hHeap, 0, dwBufferLength);
     if (GetPrivateProfileSectionA("drivers32", pszBuffer, dwBufferLength, "system.ini")) {
-        char* s = pszBuffer;
-        while (*s) {
-            if (!strncasecmp("MSACM.", s, 6)) {
-                char *s2 = s;
-                while (*s2 != '\0' && *s2 != '=') s2++;
-                if (*s2) {
-                    *s2 = '\0';
-                    MSACM_RegisterDriver(s, s2 + 1, 0);
-                    *s2 = '=';
-                }
-            }  
-            s += strlen(s) + 1; /* Either next char or \0 */
-        }
+    char* s = pszBuffer;
+    while (*s) {
+        if (!strncasecmp("MSACM.", s, 6)) {
+        char *s2 = s;
+        while (*s2 != '\0' && *s2 != '=') s2++;
+        if (*s2) {
+            *s2 = '\0';
+            MSACM_RegisterDriver(s, s2 + 1, 0);
+            *s2 = '=';
+        }
+        }
+        s += strlen(s) + 1; /* Either next char or \0 */
     }
-    
+    }
+
     HeapFree(MSACM_hHeap, 0, pszBuffer);
 
@@ -119 +119 @@
 {
     PWINE_ACMDRIVERID pNextACMDriverID;
-    
+
     while (p->pACMDriverList)
-        acmDriverClose((HACMDRIVER) p->pACMDriverList, 0);
-    
+    acmDriverClose((HACMDRIVER) p->pACMDriverList, 0);
+
     if (p->pszDriverAlias)
-        HeapFree(MSACM_hHeap, 0, p->pszDriverAlias);
+    HeapFree(MSACM_hHeap, 0, p->pszDriverAlias);
     if (p->pszFileName)
-        HeapFree(MSACM_hHeap, 0, p->pszFileName);
-    
+    HeapFree(MSACM_hHeap, 0, p->pszFileName);
+
     if (p == MSACM_pFirstACMDriverID)
-        MSACM_pFirstACMDriverID = p->pNextACMDriverID;
+    MSACM_pFirstACMDriverID = p->pNextACMDriverID;
     if (p == MSACM_pLastACMDriverID)
-        MSACM_pLastACMDriverID = p->pPrevACMDriverID;
+    MSACM_pLastACMDriverID = p->pPrevACMDriverID;
 
     if (p->pPrevACMDriverID)
-        p->pPrevACMDriverID->pNextACMDriverID = p->pNextACMDriverID;
+    p->pPrevACMDriverID->pNextACMDriverID = p->pNextACMDriverID;
     if (p->pNextACMDriverID)
-        p->pNextACMDriverID->pPrevACMDriverID = p->pPrevACMDriverID;
-    
+    p->pNextACMDriverID->pPrevACMDriverID = p->pPrevACMDriverID;
+
     pNextACMDriverID = p->pNextACMDriverID;
-    
+
     HeapFree(MSACM_hHeap, 0, p);
-    
+
     return pNextACMDriverID;
 }
@@ -162 +162 @@
 PWINE_ACMOBJ MSACM_GetObj(HACMOBJ hObj, DWORD type)
 {
-    PWINE_ACMOBJ        pao = (PWINE_ACMOBJ)hObj;
+    PWINE_ACMOBJ    pao = (PWINE_ACMOBJ)hObj;
 
     if (pao == NULL || IsBadReadPtr(pao, sizeof(WINE_ACMOBJ)) ||
-        ((type != WINE_ACMOBJ_DONTCARE) && (type != pao->dwType)))
-        return NULL;
+    ((type != WINE_ACMOBJ_DONTCARE) && (type != pao->dwType)))
+    return NULL;
     return pao;
 }
 
 /***********************************************************************
- *           MSACM_GetDriverID() 
+ *           MSACM_GetDriverID()
  */
 PWINE_ACMDRIVERID MSACM_GetDriverID(HACMDRIVERID hDriverID)
@@ -191 +191 @@
 MMRESULT MSACM_Message(HACMDRIVER had, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
 {
-    PWINE_ACMDRIVER     pad = MSACM_GetDriver(had);
+    PWINE_ACMDRIVER pad = MSACM_GetDriver(had);
 
     return pad ? SendDriverMessage(pad->hDrvr, uMsg, lParam1, lParam2) : MMSYSERR_INVALHANDLE;

trunk/src/msacm32/msacm32_main.c

@@ -1 +1 @@
 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
-
+/* $Id: msacm32_main.c,v 1.2 2001-09-05 13:11:26 bird Exp $ */
 /*
  *      MSACM32 library
  *
  *      Copyright 1998  Patrik Stridvall
- *                1999  Eric Pouech
+ *        1999  Eric Pouech
  */
 
@@ -17 +17 @@
 
 DEFAULT_DEBUG_CHANNEL(msacm);
-        
+
 /**********************************************************************/
-        
-HINSTANCE       MSACM_hInstance32 = 0;
+
+HINSTANCE   MSACM_hInstance32 = 0;
 
 /***********************************************************************
- *           MSACM_LibMain (MSACM32.init) 
+ *           MSACM_LibMain (MSACM32.init)
  */
 BOOL WINAPI MSACM32_LibMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpvReserved)
@@ -34 +34 @@
         MSACM_hInstance32 = hInstDLL;
         MSACM_RegisterAllDrivers();
-        break;
+    break;
     case DLL_PROCESS_DETACH:
         MSACM_UnregisterAllDrivers();
@@ -40 +40 @@
         MSACM_hHeap = (HANDLE) NULL;
         MSACM_hInstance32 = (HINSTANCE)NULL;
-        break;
+    break;
     case DLL_THREAD_ATTACH:
-        break;
+    break;
     case DLL_THREAD_DETACH:
-        break;
+    break;
     default:
-        break;
+    break;
     }
     return TRUE;
@@ -67 +67 @@
     {
     case VER_PLATFORM_WIN32_NT:
-        return 0x04000565; /* 4.0.1381 */
+    return 0x04000565; /* 4.0.1381 */
     default:
         FIXME("%ld not supported",version.dwPlatformId);
     case VER_PLATFORM_WIN32_WINDOWS:
-        return 0x04000000; /* 4.0.0 */
+    return 0x04000000; /* 4.0.0 */
   }
 }
@@ -86 +86 @@
 MMRESULT WINAPI acmMetrics(HACMOBJ hao, UINT uMetric, LPVOID pMetric)
 {
-    PWINE_ACMOBJ        pao = MSACM_GetObj(hao, WINE_ACMOBJ_DONTCARE);
-    BOOL                bLocal = TRUE;
-    PWINE_ACMDRIVERID   padid;
-    DWORD               val = 0;
-    MMRESULT            mmr = MMSYSERR_NOERROR;
+    PWINE_ACMOBJ    pao = MSACM_GetObj(hao, WINE_ACMOBJ_DONTCARE);
+    BOOL        bLocal = TRUE;
+    PWINE_ACMDRIVERID   padid;
+    DWORD       val = 0;
+    MMRESULT        mmr = MMSYSERR_NOERROR;
 
     TRACE("(0x%08x, %d, %p);\n", hao, uMetric, pMetric);
-    
+
     switch (uMetric) {
     case ACM_METRIC_COUNT_DRIVERS:
-        bLocal = FALSE;
-        /* fall thru */
+    bLocal = FALSE;
+    /* fall thru */
     case ACM_METRIC_COUNT_LOCAL_DRIVERS:
-        if (!pao)
-            return MMSYSERR_INVALHANDLE;
-        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID)
-            if (padid->bEnabled /* && (local(padid) || !bLocal) */)
-                val++;
-        *(LPDWORD)pMetric = val;
-        break;
+    if (!pao)
+        return MMSYSERR_INVALHANDLE;
+    for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID)
+        if (padid->bEnabled /* && (local(padid) || !bLocal) */)
+        val++;
+    *(LPDWORD)pMetric = val;
+    break;
 
     case ACM_METRIC_COUNT_CODECS:
-        if (!pao)
-            return MMSYSERR_INVALHANDLE;
-        bLocal = FALSE;
-        /* fall thru */
+    if (!pao)
+        return MMSYSERR_INVALHANDLE;
+    bLocal = FALSE;
+    /* fall thru */
     case ACM_METRIC_COUNT_LOCAL_CODECS:
-        /* FIXME: don't know how to differentiate codec, converters & filters yet */
-        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID)
-            if (padid->bEnabled /* && (local(padid) || !bLocal) */)
-                val++;
-        *(LPDWORD)pMetric = val;
-        break;
+    /* FIXME: don't know how to differentiate codec, converters & filters yet */
+    for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID)
+        if (padid->bEnabled /* && (local(padid) || !bLocal) */)
+        val++;
+    *(LPDWORD)pMetric = val;
+    break;
 
     case ACM_METRIC_COUNT_CONVERTERS:
-        bLocal = FALSE;
-        /* fall thru */
+    bLocal = FALSE;
+    /* fall thru */
     case ACM_METRIC_COUNT_LOCAL_CONVERTERS:
-        /* FIXME: don't know how to differentiate codec, converters & filters yet */
-        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID)
-            if (padid->bEnabled /* && (local(padid) || !bLocal) */)
-                val++;
-        *(LPDWORD)pMetric = val;
-        break;
+    /* FIXME: don't know how to differentiate codec, converters & filters yet */
+    for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID)
+        if (padid->bEnabled /* && (local(padid) || !bLocal) */)
+        val++;
+    *(LPDWORD)pMetric = val;
+    break;
 
     case ACM_METRIC_COUNT_FILTERS:
-        bLocal = FALSE;
-        /* fall thru */
+    bLocal = FALSE;
+    /* fall thru */
     case ACM_METRIC_COUNT_LOCAL_FILTERS:
-        /* FIXME: don't know how to differentiate codec, converters & filters yet */
-        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID)
-            if (padid->bEnabled /* && (local(padid) || !bLocal) */)
-                val++;
-        *(LPDWORD)pMetric = val;
-        break;
+    /* FIXME: don't know how to differentiate codec, converters & filters yet */
+    for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID)
+        if (padid->bEnabled /* && (local(padid) || !bLocal) */)
+        val++;
+    *(LPDWORD)pMetric = val;
+    break;
 
     case ACM_METRIC_COUNT_DISABLED:
-        bLocal = FALSE;
-        /* fall thru */
+    bLocal = FALSE;
+    /* fall thru */
     case ACM_METRIC_COUNT_LOCAL_DISABLED:
-        if (!pao)
-            return MMSYSERR_INVALHANDLE;  
-        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID)
-            if (!padid->bEnabled /* && (local(padid) || !bLocal) */)
-                val++;
-        *(LPDWORD)pMetric = val;
-        break;
-    
+    if (!pao)
+        return MMSYSERR_INVALHANDLE;
+    for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID)
+        if (!padid->bEnabled /* && (local(padid) || !bLocal) */)
+        val++;
+    *(LPDWORD)pMetric = val;
+    break;
+
     case ACM_METRIC_MAX_SIZE_FORMAT:
-        {
-            ACMFORMATTAGDETAILSW        aftd;
+    {
+        ACMFORMATTAGDETAILSW    aftd;
 
-            aftd.cbStruct = sizeof(aftd);
-            aftd.dwFormatTag = WAVE_FORMAT_UNKNOWN;
+        aftd.cbStruct = sizeof(aftd);
+        aftd.dwFormatTag = WAVE_FORMAT_UNKNOWN;
 
-            if (hao == (HACMOBJ)NULL) {
-                mmr = acmFormatTagDetailsW((HACMDRIVER)NULL, &aftd, ACM_FORMATTAGDETAILSF_LARGESTSIZE);
-            } else if (MSACM_GetObj(hao, WINE_ACMOBJ_DRIVER)) {
-                mmr = acmFormatTagDetailsW((HACMDRIVER)hao, &aftd, ACM_FORMATTAGDETAILSF_LARGESTSIZE);
-            } else if (MSACM_GetObj(hao, WINE_ACMOBJ_DRIVERID)) {
-                HACMDRIVER      had;
-                
-                if (acmDriverOpen(&had, (HACMDRIVERID)hao, 0) == 0) {
-                    mmr = acmFormatTagDetailsW((HACMDRIVER)hao, &aftd, ACM_FORMATTAGDETAILSF_LARGESTSIZE);
-                    acmDriverClose(had, 0);
-                }
-            } else {
-                mmr = MMSYSERR_INVALHANDLE;
-            }
-            if (mmr == MMSYSERR_NOERROR) *(LPDWORD)pMetric = aftd.cbFormatSize;
-        }
+        if (hao == (HACMOBJ)NULL) {
+        mmr = acmFormatTagDetailsW((HACMDRIVER)NULL, &aftd, ACM_FORMATTAGDETAILSF_LARGESTSIZE);
+        } else if (MSACM_GetObj(hao, WINE_ACMOBJ_DRIVER)) {
+        mmr = acmFormatTagDetailsW((HACMDRIVER)hao, &aftd, ACM_FORMATTAGDETAILSF_LARGESTSIZE);
+        } else if (MSACM_GetObj(hao, WINE_ACMOBJ_DRIVERID)) {
+        HACMDRIVER  had;
+
+        if (acmDriverOpen(&had, (HACMDRIVERID)hao, 0) == 0) {
+            mmr = acmFormatTagDetailsW((HACMDRIVER)hao, &aftd, ACM_FORMATTAGDETAILSF_LARGESTSIZE);
+            acmDriverClose(had, 0);
+        }
+        } else {
+        mmr = MMSYSERR_INVALHANDLE;
+        }
+        if (mmr == MMSYSERR_NOERROR) *(LPDWORD)pMetric = aftd.cbFormatSize;
+    }
         break;
 
@@ -186 +186 @@
     case ACM_METRIC_DRIVER_PRIORITY:
     default:
-        FIXME("(0x%08x, %d, %p): stub\n", hao, uMetric, pMetric);
-        mmr = MMSYSERR_NOTSUPPORTED;
+    FIXME("(0x%08x, %d, %p): stub\n", hao, uMetric, pMetric);
+    mmr = MMSYSERR_NOTSUPPORTED;
     }
     return mmr;

trunk/src/msacm32/pcmconverter.c

@@ -1 +1 @@
 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
-
+/* $Id: pcmconverter.c,v 1.2 2001-09-05 13:11:26 bird Exp $ */
 /*
  *      MSACM32 library
  *
- *      Copyright 2000          Eric Pouech
- *
- *      FIXME / TODO list
- *      + most of the computation should be done in fixed point arithmetic 
- *        instead of floating point (16 bits for integral part, and 16 bits
- *        for fractional part for example)
- *      + implement PCM_FormatSuggest function
- *      + get rid of hack for PCM_DriverProc (msacm32.dll shouldn't export
- *        a DriverProc, but this would require implementing a generic
- *        embedded driver handling scheme in msacm32.dll which isn't done yet
+ *      Copyright 2000      Eric Pouech
+ *
+ *  FIXME / TODO list
+ *  + most of the computation should be done in fixed point arithmetic
+ *    instead of floating point (16 bits for integral part, and 16 bits
+ *    for fractional part for example)
+ *  + implement PCM_FormatSuggest function
+ *  + get rid of hack for PCM_DriverProc (msacm32.dll shouldn't export
+ *    a DriverProc, but this would require implementing a generic
+ *    embedded driver handling scheme in msacm32.dll which isn't done yet
  */
 
@@ -35 +35 @@
  *           PCM_drvOpen
  */
-static  DWORD   PCM_drvOpen(LPCSTR str)
+static  DWORD   PCM_drvOpen(LPCSTR str)
 {
     return 1;
@@ -43 +43 @@
  *           PCM_drvClose
  */
-static  DWORD   PCM_drvClose(DWORD dwDevID)
+static  DWORD   PCM_drvClose(DWORD dwDevID)
 {
     return 1;
 }
 
-#define NUM_PCM_FORMATS (sizeof(PCM_Formats) / sizeof(PCM_Formats[0]))
-#define NUM_OF(a,b)     (((a)+(b)-1)/(b))
+#define NUM_PCM_FORMATS (sizeof(PCM_Formats) / sizeof(PCM_Formats[0]))
+#define NUM_OF(a,b) (((a)+(b)-1)/(b))
 
 /* flags for fdwDriver */
-#define PCM_RESAMPLE    1
+#define PCM_RESAMPLE    1
 
 /* data used while converting */
@@ -58 +58 @@
     /* conversion routine, depending if rate conversion is required */
     union {
-        void (*cvtKeepRate)(const unsigned char*, int, unsigned char*);
-        void (*cvtChangeRate)(struct tagAcmPcmData*, const unsigned char*, 
-                              LPDWORD, unsigned char*, LPDWORD);
+    void (*cvtKeepRate)(const unsigned char*, int, unsigned char*);
+    void (*cvtChangeRate)(struct tagAcmPcmData*, const unsigned char*,
+                  LPDWORD, unsigned char*, LPDWORD);
     } cvt;
     /* the following fields are used only with rate conversion) */
-    DWORD       srcPos;         /* position in source stream */
-    double      dstPos;         /* position in destination stream */
-    double      dstIncr;        /* value to increment dst stream when src stream 
-                                   is incremented by 1 */
+    DWORD   srcPos;     /* position in source stream */
+    double  dstPos;     /* position in destination stream */
+    double  dstIncr;    /* value to increment dst stream when src stream
+                   is incremented by 1 */
     /* last source stream value read */
     union {
-        unsigned char   b;      /*  8 bit value */
-        short           s;      /* 16 bit value */
+    unsigned char   b;  /*  8 bit value */
+    short       s;  /* 16 bit value */
     } last[2]; /* two channels max (stereo) */
 } AcmPcmData;
@@ -77 +77 @@
  * also helps given a unique index to each of the supported formats
  */
-static  struct {
-    int         nChannels;
-    int         nBits;
-    int         rate;
+static  struct {
+    int     nChannels;
+    int     nBits;
+    int     rate;
 } PCM_Formats[] = {
     {1,  8,  8000}, {2,  8,  8000}, {1, 16,  8000}, {2, 16,  8000},
@@ -91 +91 @@
  *           PCM_GetFormatIndex
  */
-static  DWORD   PCM_GetFormatIndex(LPWAVEFORMATEX wfx)
+static  DWORD   PCM_GetFormatIndex(LPWAVEFORMATEX wfx)
 {
     int i;
-    
+
     for (i = 0; i < NUM_PCM_FORMATS; i++) {
-        if (wfx->nChannels == PCM_Formats[i].nChannels &&
-            wfx->nSamplesPerSec == PCM_Formats[i].rate &&
-            wfx->wBitsPerSample == PCM_Formats[i].nBits)
-            return i;
+    if (wfx->nChannels == PCM_Formats[i].nChannels &&
+        wfx->nSamplesPerSec == PCM_Formats[i].rate &&
+        wfx->wBitsPerSample == PCM_Formats[i].nBits)
+        return i;
     }
     return 0xFFFFFFFF;
@@ -107 +107 @@
  *
  * parameters:
- *      + 8 bit unsigned vs 16 bit signed
- *      + mono vs stereo (1 or 2 channels)
- *      + sampling rate (8.0, 11.025, 22.05, 44.1 kHz are defined, but algo shall work
- *        in all cases)
+ *  + 8 bit unsigned vs 16 bit signed
+ *  + mono vs stereo (1 or 2 channels)
+ *  + sampling rate (8.0, 11.025, 22.05, 44.1 kHz are defined, but algo shall work
+ *    in all cases)
  *
  * mono => stereo: copy the same sample on Left & Right channels
  * stereo =) mono: use the average value of samples from Left & Right channels
  * resampling; we lookup for each destination sample the two source adjacent samples
- *      were src <= dst < src+1 (dst is increased by a fractional value which is 
- *      equivalent to the increment by one on src); then we use a linear
- *      interpolation between src and src+1
+ *  were src <= dst < src+1 (dst is increased by a fractional value which is
+ *  equivalent to the increment by one on src); then we use a linear
+ *  interpolation between src and src+1
  */
 
@@ -125 +125 @@
  * Converts a 8 bit sample to a 16 bit one
  */
-static inline short C816(unsigned char b) 
+static inline short C816(unsigned char b)
 {
     return (short)(b ^ 0x80) * 256;
@@ -135 +135 @@
  * Converts a 16 bit sample to a 8 bit one (data loss !!)
  */
-static inline unsigned char C168(short s) 
+static inline unsigned char C168(short s)
 {
     return HIBYTE(s) ^ (unsigned char)0x80;
@@ -164 +164 @@
  *           M16
  *
- * Convert the (l,r) 16 bit stereo sample into a 16 bit mono 
+ * Convert the (l,r) 16 bit stereo sample into a 16 bit mono
  * (takes the mid-point of the two values)
  */
@@ -175 +175 @@
  *           M8
  *
- * Convert the (l,r) 8 bit stereo sample into a 8 bit mono 
+ * Convert the (l,r) 8 bit stereo sample into a 8 bit mono
  * (takes the mid-point of the two values)
  */
@@ -194 +194 @@
  */
 
-static  void cvtMM88K(const unsigned char* src, int ns, unsigned char* dst)
+static  void cvtMM88K(const unsigned char* src, int ns, unsigned char* dst)
 {
     memcpy(dst, src, ns);
 }
 
-static  void cvtSS88K(const unsigned char* src, int ns, unsigned char* dst)
+static  void cvtSS88K(const unsigned char* src, int ns, unsigned char* dst)
 {
     memcpy(dst, src, ns * 2);
 }
 
-static  void cvtMM1616K(const unsigned char* src, int ns, unsigned char* dst)
+static  void cvtMM1616K(const unsigned char* src, int ns, unsigned char* dst)
 {
     memcpy(dst, src, ns * 2);
 }
 
-static  void cvtSS1616K(const unsigned char* src, int ns, unsigned char* dst)
+static  void cvtSS1616K(const unsigned char* src, int ns, unsigned char* dst)
 {
     memcpy(dst, src, ns * 4);
 }
 
-static  void cvtMS88K(const unsigned char* src, int ns, unsigned char* dst)
-{
-    while (ns--) {
-        *dst++ = *src;
-        *dst++ = *src++;
-    }
-}
-
-static  void cvtMS816K(const unsigned char* src, int ns, unsigned char* dst)
-{
-    short       v;
-    
-    while (ns--) {
-        v = C816(*src++);
-        W16(dst, v);            dst += 2;
-        W16(dst, v);            dst += 2;
-    }
-}
-
-static  void cvtMS168K(const unsigned char* src, int ns, unsigned char* dst)
+static  void cvtMS88K(const unsigned char* src, int ns, unsigned char* dst)
+{
+    while (ns--) {
+    *dst++ = *src;
+    *dst++ = *src++;
+    }
+}
+
+static  void cvtMS816K(const unsigned char* src, int ns, unsigned char* dst)
+{
+    short   v;
+
+    while (ns--) {
+    v = C816(*src++);
+    W16(dst, v);        dst += 2;
+    W16(dst, v);        dst += 2;
+    }
+}
+
+static  void cvtMS168K(const unsigned char* src, int ns, unsigned char* dst)
 {
     unsigned char v;
-    
-    while (ns--) {
-        v = C168(R16(src));             src += 2;
-        *dst++ = v;
-        *dst++ = v;
-    }
-}
-
-static  void cvtMS1616K(const unsigned char* src, int ns, unsigned char* dst)
-{
-    short       v;
-
-    while (ns--) {
-        v = R16(src);           src += 2;
-        W16(dst, v);            dst += 2;
-        W16(dst, v);            dst += 2;
-    }
-}
-
-static  void cvtSM88K(const unsigned char* src, int ns, unsigned char* dst)
-{
-    while (ns--) {
-        *dst++ = M8(src[0], src[1]);
-        src += 2;
-    }
-}
-
-static  void cvtSM816K(const unsigned char* src, int ns, unsigned char* dst)
-{
-    short       v;
-    
-    while (ns--) {
-        v = M16(C816(src[0]), C816(src[1]));
-        src += 2;
-        W16(dst, v);            dst += 2;
-    }
-}
-
-static  void cvtSM168K(const unsigned char* src, int ns, unsigned char* dst)
-{
-    while (ns--) {
-        *dst++ = C168(M16(R16(src), R16(src + 2)));
-        src += 4;
-    }
-}
-
-static  void cvtSM1616K(const unsigned char* src, int ns, unsigned char* dst)
-{
-    while (ns--) {
-        W16(dst, M16(R16(src),R16(src+2)));     dst += 2;
-        src += 4;
-    }
-}
-
-static  void cvtMM816K(const unsigned char* src, int ns, unsigned char* dst)
-{
-    while (ns--) {
-        W16(dst, C816(*src++));         dst += 2;
-    }
-}
-
-static  void cvtSS816K(const unsigned char* src, int ns, unsigned char* dst)
-{
-    while (ns--) {
-        W16(dst, C816(*src++)); dst += 2;
-        W16(dst, C816(*src++)); dst += 2;
-    }
-}
-
-static  void cvtMM168K(const unsigned char* src, int ns, unsigned char* dst)
-{
-    while (ns--) {
-        *dst++ = C168(R16(src));        src += 2;
-    }
-}
-
-static  void cvtSS168K(const unsigned char* src, int ns, unsigned char* dst)
-{
-    while (ns--) {
-        *dst++ = C168(R16(src));        src += 2;
-        *dst++ = C168(R16(src));        src += 2;
-    }
-}
-
-static  void (*PCM_ConvertKeepRate[16])(const unsigned char*, int, unsigned char*) = {
-    cvtSS88K,   cvtSM88K,   cvtMS88K,   cvtMM88K,
-    cvtSS816K,  cvtSM816K,  cvtMS816K,  cvtMM816K,
-    cvtSS168K,  cvtSM168K,  cvtMS168K,  cvtMM168K,
+
+    while (ns--) {
+    v = C168(R16(src));     src += 2;
+    *dst++ = v;
+    *dst++ = v;
+    }
+}
+
+static  void cvtMS1616K(const unsigned char* src, int ns, unsigned char* dst)
+{
+    short   v;
+
+    while (ns--) {
+    v = R16(src);       src += 2;
+    W16(dst, v);        dst += 2;
+    W16(dst, v);        dst += 2;
+    }
+}
+
+static  void cvtSM88K(const unsigned char* src, int ns, unsigned char* dst)
+{
+    while (ns--) {
+    *dst++ = M8(src[0], src[1]);
+    src += 2;
+    }
+}
+
+static  void cvtSM816K(const unsigned char* src, int ns, unsigned char* dst)
+{
+    short   v;
+
+    while (ns--) {
+    v = M16(C816(src[0]), C816(src[1]));
+    src += 2;
+    W16(dst, v);        dst += 2;
+    }
+}
+
+static  void cvtSM168K(const unsigned char* src, int ns, unsigned char* dst)
+{
+    while (ns--) {
+    *dst++ = C168(M16(R16(src), R16(src + 2)));
+    src += 4;
+    }
+}
+
+static  void cvtSM1616K(const unsigned char* src, int ns, unsigned char* dst)
+{
+    while (ns--) {
+    W16(dst, M16(R16(src),R16(src+2))); dst += 2;
+    src += 4;
+    }
+}
+
+static  void cvtMM816K(const unsigned char* src, int ns, unsigned char* dst)
+{
+    while (ns--) {
+    W16(dst, C816(*src++));     dst += 2;
+    }
+}
+
+static  void cvtSS816K(const unsigned char* src, int ns, unsigned char* dst)
+{
+    while (ns--) {
+    W16(dst, C816(*src++)); dst += 2;
+    W16(dst, C816(*src++)); dst += 2;
+    }
+}
+
+static  void cvtMM168K(const unsigned char* src, int ns, unsigned char* dst)
+{
+    while (ns--) {
+    *dst++ = C168(R16(src));    src += 2;
+    }
+}
+
+static  void cvtSS168K(const unsigned char* src, int ns, unsigned char* dst)
+{
+    while (ns--) {
+    *dst++ = C168(R16(src));    src += 2;
+    *dst++ = C168(R16(src));    src += 2;
+    }
+}
+
+static  void (*PCM_ConvertKeepRate[16])(const unsigned char*, int, unsigned char*) = {
+    cvtSS88K,   cvtSM88K,   cvtMS88K,   cvtMM88K,
+    cvtSS816K,  cvtSM816K,  cvtMS816K,  cvtMM816K,
+    cvtSS168K,  cvtSM168K,  cvtMS168K,  cvtMM168K,
     cvtSS1616K, cvtSM1616K, cvtMS1616K, cvtMM1616K,
 };
@@ -333 +333 @@
  * Linear interpolation is used
  */
-static  inline double   I(double v1, double v2, double r)
+static  inline double   I(double v1, double v2, double r)
 {
     if (0.0 >= r || r > 1.0) FIXME("r!! %f\n", r);
@@ -339 +339 @@
 }
 
-static  void cvtSS88C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
-                      unsigned char* dst, LPDWORD ndst)
-{
-    double              r;
-
-    while (*nsrc != 0 && *ndst != 0) {
-        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-            if (*nsrc == 0) return;
-            apd->last[0].b = *src++;
-            apd->last[1].b = *src++;
-            apd->srcPos++;
-            (*nsrc)--;
-        }
-        /* now do the interpolation */
-        *dst++ = I(apd->last[0].b, src[0], r);
-        *dst++ = I(apd->last[1].b, src[1], r);
-        apd->dstPos += apd->dstIncr;
-        (*ndst)--;
+static  void cvtSS88C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
+              unsigned char* dst, LPDWORD ndst)
+{
+    double          r;
+
+    while (*nsrc != 0 && *ndst != 0) {
+    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+        if (*nsrc == 0) return;
+        apd->last[0].b = *src++;
+        apd->last[1].b = *src++;
+        apd->srcPos++;
+        (*nsrc)--;
+    }
+    /* now do the interpolation */
+    *dst++ = I(apd->last[0].b, src[0], r);
+    *dst++ = I(apd->last[1].b, src[1], r);
+    apd->dstPos += apd->dstIncr;
+    (*ndst)--;
     }
 }
@@ -368 +368 @@
  *
  */
-static  void cvtSM88C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
-                      unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-
-    while (*nsrc != 0 && *ndst != 0) {
-        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-            if (*nsrc == 0) return;
-            apd->last[0].b = *src++;
-            apd->last[1].b = *src++;
-            apd->srcPos++;
-            (*nsrc)--;
-        }
-        /* now do the interpolation */
-        *dst++ = I(M8(apd->last[0].b, apd->last[1].b), M8(src[0], src[1]), r);
-        apd->dstPos += apd->dstIncr;
-        (*ndst)--;
-    }
-}
-
-static  void cvtMS88C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
-                      unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-
-    while (*nsrc != 0 && *ndst != 0) {
-        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-            if (*nsrc == 0) return;
-            apd->last[0].b = *src++;
-            apd->srcPos++;
-            (*nsrc)--;
-        }
-        /* now do the interpolation */
-        dst[0] = dst[1] = I(apd->last[0].b, src[0], r);
-        dst += 2;
-        apd->dstPos += apd->dstIncr;
-        (*ndst)--;
-    }
-}
-
-static  void cvtMM88C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
-                      unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-
-    while (*nsrc != 0 && *ndst != 0) {
-        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-            if (*nsrc == 0) return;
-            apd->last[0].b = *src++;
-            apd->srcPos++;
-            (*nsrc)--;
-        }
-        /* now do the interpolation */
-        *dst++ = I(apd->last[0].b, src[0], r);
-        apd->dstPos += apd->dstIncr;
-        (*ndst)--;
-    }
-}
-
-static  void cvtSS816C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
-                       unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-        
-    while (*nsrc != 0 && *ndst != 0) {
-        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-            if (*nsrc == 0) return;
-            apd->last[0].b = *src++;
-            apd->last[1].b = *src++;
-            apd->srcPos++;
-            (*nsrc)--;
-        }
-        /* now do the interpolation */
-        W16(dst, I(C816(apd->last[0].b), C816(src[0]), r));     dst += 2;
-        W16(dst, I(C816(apd->last[1].b), C816(src[1]), r));     dst += 2;
-        apd->dstPos += apd->dstIncr;
-        (*ndst)--;
-    }
-}
-
-static  void cvtSM816C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
-                        unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-
-    while (*nsrc != 0 && *ndst != 0) {
-        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-            if (*nsrc == 0) return;
-            apd->last[0].b = *src++;
-            apd->last[1].b = *src++;
-            apd->srcPos++;
-            (*nsrc)--;
-        }
-        /* now do the interpolation */
-        W16(dst, I(M16(C816(apd->last[0].b), C816(apd->last[1].b)),
-                    M16(C816(src[0]), C816(src[1])), r));
-        dst += 2;
-        apd->dstPos += apd->dstIncr;
-        (*ndst)--;
-    }
-}
-
-static  void cvtMS816C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
-                        unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-    short       v;
-
-    while (*nsrc != 0 && *ndst != 0) {
-        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-            if (*nsrc == 0) return;
-            apd->last[0].b = *src++;
-            apd->srcPos++;
-            (*nsrc)--;
-        }
-        /* now do the interpolation */
-        v = I(C816(apd->last[0].b), C816(src[0]), r);
-        W16(dst, v);            dst += 2;
-        W16(dst, v);            dst += 2;
-        apd->dstPos += apd->dstIncr;
-        (*ndst)--;
-    }
-}
-
-static  void cvtMM816C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
-                        unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-
-    while (*nsrc != 0 && *ndst != 0) {
-        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-            if (*nsrc == 0) return;
-            apd->last[0].b = *src++;
-            apd->srcPos++;
-            (*nsrc)--;
-        }
-        /* now do the interpolation */
-        W16(dst, I(C816(apd->last[0].b), C816(src[0]), r));
-        dst += 2;
-        apd->dstPos += apd->dstIncr;
-        (*ndst)--;
-    }
-}
-
-static  void cvtSS168C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
-                        unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-
-    while (*nsrc != 0 && *ndst != 0) {
-        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-            if (*nsrc == 0) return;
-            apd->last[0].s = R16(src);  src += 2;
-            apd->last[1].s = R16(src);  src += 2;
-            apd->srcPos++;
-            (*nsrc)--;
-        }
-        /* now do the interpolation */
-        *dst++ = C168(I(apd->last[0].s, R16(src)  , r));
-        *dst++ = C168(I(apd->last[1].s, R16(src+2), r));
-        apd->dstPos += apd->dstIncr;
-        (*ndst)--;
-    }
-}
-
-static  void cvtSM168C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
-                        unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-
-    while (*nsrc != 0 && *ndst != 0) {
-        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-            if (*nsrc == 0) return;
-            apd->last[0].s = R16(src);  src += 2;
-            apd->last[1].s = R16(src);  src += 2;
-            apd->srcPos++;
-            (*nsrc)--;
-        }
-        /* now do the interpolation */
-        *dst++ = C168(I(M16(apd->last[0].s, apd->last[1].s), 
-                        M16(R16(src), R16(src + 2)), r));
-        apd->dstPos += apd->dstIncr;
-        (*ndst)--;
-    }
-}
-
-
-static  void cvtMS168C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
-                        unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-
-    while (*nsrc != 0 && *ndst != 0) {
-        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-            if (*nsrc == 0) return;
-            apd->last[0].s = R16(src);  src += 2;
-            apd->srcPos++;
-            (*nsrc)--;
-        }
-        /* now do the interpolation */
-        dst[0] = dst[1] = C168(I(apd->last[0].s, R16(src), r)); dst += 2;
-        apd->dstPos += apd->dstIncr;
-        (*ndst)--;
-    }
-}
-
-
-static  void cvtMM168C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
-                        unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-
-    while (*nsrc != 0 && *ndst != 0) {
-        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-            if (*nsrc == 0) return;
-            apd->last[0].s = R16(src);  src += 2;
-            apd->srcPos++;
-            (*nsrc)--;
-        }
-        /* now do the interpolation */
-        *dst++ = C168(I(apd->last[0].s, R16(src), r));
-        apd->dstPos += apd->dstIncr;
-        (*ndst)--;
-    }
-}
-
-static  void cvtSS1616C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
-                        unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-
-    while (*nsrc != 0 && *ndst != 0) {
-        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-            if (*nsrc == 0) return;
-            apd->last[0].s = R16(src);  src += 2;
-            apd->last[1].s = R16(src);  src += 2;
-            apd->srcPos++;
-            (*nsrc)--;
-        }
-        /* now do the interpolation */
-        W16(dst, I(apd->last[0].s, R16(src)  , r));     dst += 2;
-        W16(dst, I(apd->last[1].s, R16(src+2), r));     dst += 2;
-        apd->dstPos += apd->dstIncr;
-        (*ndst)--;
-    }
-}
-
-static  void cvtSM1616C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
-                        unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-
-    while (*nsrc != 0 && *ndst != 0) {
-        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-            if (*nsrc == 0) return;
-            apd->last[0].s = R16(src);  src += 2;
-            apd->last[1].s = R16(src);  src += 2;
-            apd->srcPos++;
-            (*nsrc)--;
-        }
-        /* now do the interpolation */
-        W16(dst, I(M16(apd->last[0].s, apd->last[1].s),
-                   M16(R16(src), R16(src+2)), r));
-        dst += 2;
-        apd->dstPos += apd->dstIncr;
-        (*ndst)--;
-    }
-}
-
-static  void cvtMS1616C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
-                        unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-    short       v;
-
-    while (*nsrc != 0 && *ndst != 0) {
-        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-            if (*nsrc == 0) return;
-            apd->last[0].s = R16(src);  src += 2;
-            apd->srcPos++;
-            (*nsrc)--;
-        }
-        /* now do the interpolation */
-        v = I(apd->last[0].s, R16(src), r);
-        W16(dst, v);            dst += 2;
-        W16(dst, v);            dst += 2;
-        apd->dstPos += apd->dstIncr;
-        (*ndst)--;
-    }
-}
-
-static  void cvtMM1616C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
-                        unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-
-    while (*nsrc != 0 && *ndst != 0) {
-        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-            if (*nsrc == 0) return;
-            apd->last[0].s = R16(src);  src += 2;
-            apd->srcPos++;
-            (*nsrc)--;
-        }
-        /* now do the interpolation */
-        W16(dst, I(apd->last[0].s, R16(src), r));       dst += 2;
-        apd->dstPos += apd->dstIncr;
-        (*ndst)--;
-    }
-}
-
-static  void (*PCM_ConvertChangeRate[16])(AcmPcmData* apd, 
-                                          const unsigned char* src, LPDWORD nsrc, 
-                                          unsigned char* dst, LPDWORD ndst) = {
+static  void cvtSM88C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
+              unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+
+    while (*nsrc != 0 && *ndst != 0) {
+    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+        if (*nsrc == 0) return;
+        apd->last[0].b = *src++;
+        apd->last[1].b = *src++;
+        apd->srcPos++;
+        (*nsrc)--;
+    }
+    /* now do the interpolation */
+    *dst++ = I(M8(apd->last[0].b, apd->last[1].b), M8(src[0], src[1]), r);
+    apd->dstPos += apd->dstIncr;
+    (*ndst)--;
+    }
+}
+
+static  void cvtMS88C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
+              unsigned char* dst, LPDWORD ndst)
+{
+    double  r;
+
+    while (*nsrc != 0 && *ndst != 0) {
+    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+        if (*nsrc == 0) return;
+        apd->last[0].b = *src++;
+        apd->srcPos++;
+        (*nsrc)--;
+    }
+    /* now do the interpolation */
+    dst[0] = dst[1] = I(apd->last[0].b, src[0], r);
+    dst += 2;
+    apd->dstPos += apd->dstIncr;
+    (*ndst)--;
+    }
+}
+
+static  void cvtMM88C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
+              unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+
+    while (*nsrc != 0 && *ndst != 0) {
+    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+        if (*nsrc == 0) return;
+        apd->last[0].b = *src++;
+        apd->srcPos++;
+        (*nsrc)--;
+    }
+    /* now do the interpolation */
+    *dst++ = I(apd->last[0].b, src[0], r);
+    apd->dstPos += apd->dstIncr;
+    (*ndst)--;
+    }
+}
+
+static  void cvtSS816C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
+               unsigned char* dst, LPDWORD ndst)
+{
+    double  r;
+
+    while (*nsrc != 0 && *ndst != 0) {
+    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+        if (*nsrc == 0) return;
+        apd->last[0].b = *src++;
+        apd->last[1].b = *src++;
+        apd->srcPos++;
+        (*nsrc)--;
+    }
+    /* now do the interpolation */
+    W16(dst, I(C816(apd->last[0].b), C816(src[0]), r)); dst += 2;
+    W16(dst, I(C816(apd->last[1].b), C816(src[1]), r)); dst += 2;
+    apd->dstPos += apd->dstIncr;
+    (*ndst)--;
+    }
+}
+
+static  void cvtSM816C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
+            unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+
+    while (*nsrc != 0 && *ndst != 0) {
+    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+        if (*nsrc == 0) return;
+        apd->last[0].b = *src++;
+        apd->last[1].b = *src++;
+        apd->srcPos++;
+        (*nsrc)--;
+    }
+    /* now do the interpolation */
+    W16(dst, I(M16(C816(apd->last[0].b), C816(apd->last[1].b)),
+            M16(C816(src[0]), C816(src[1])), r));
+    dst += 2;
+    apd->dstPos += apd->dstIncr;
+    (*ndst)--;
+    }
+}
+
+static  void cvtMS816C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
+            unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+    short   v;
+
+    while (*nsrc != 0 && *ndst != 0) {
+    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+        if (*nsrc == 0) return;
+        apd->last[0].b = *src++;
+        apd->srcPos++;
+        (*nsrc)--;
+    }
+    /* now do the interpolation */
+    v = I(C816(apd->last[0].b), C816(src[0]), r);
+    W16(dst, v);        dst += 2;
+    W16(dst, v);        dst += 2;
+    apd->dstPos += apd->dstIncr;
+    (*ndst)--;
+    }
+}
+
+static  void cvtMM816C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
+            unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+
+    while (*nsrc != 0 && *ndst != 0) {
+    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+        if (*nsrc == 0) return;
+        apd->last[0].b = *src++;
+        apd->srcPos++;
+        (*nsrc)--;
+    }
+    /* now do the interpolation */
+    W16(dst, I(C816(apd->last[0].b), C816(src[0]), r));
+    dst += 2;
+    apd->dstPos += apd->dstIncr;
+    (*ndst)--;
+    }
+}
+
+static  void cvtSS168C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
+            unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+
+    while (*nsrc != 0 && *ndst != 0) {
+    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+        if (*nsrc == 0) return;
+        apd->last[0].s = R16(src);  src += 2;
+        apd->last[1].s = R16(src);  src += 2;
+        apd->srcPos++;
+        (*nsrc)--;
+    }
+    /* now do the interpolation */
+    *dst++ = C168(I(apd->last[0].s, R16(src)  , r));
+    *dst++ = C168(I(apd->last[1].s, R16(src+2), r));
+    apd->dstPos += apd->dstIncr;
+    (*ndst)--;
+    }
+}
+
+static  void cvtSM168C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
+            unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+
+    while (*nsrc != 0 && *ndst != 0) {
+    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+        if (*nsrc == 0) return;
+        apd->last[0].s = R16(src);  src += 2;
+        apd->last[1].s = R16(src);  src += 2;
+        apd->srcPos++;
+        (*nsrc)--;
+    }
+    /* now do the interpolation */
+    *dst++ = C168(I(M16(apd->last[0].s, apd->last[1].s),
+            M16(R16(src), R16(src + 2)), r));
+    apd->dstPos += apd->dstIncr;
+    (*ndst)--;
+    }
+}
+
+
+static  void cvtMS168C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
+            unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+
+    while (*nsrc != 0 && *ndst != 0) {
+    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+        if (*nsrc == 0) return;
+        apd->last[0].s = R16(src);  src += 2;
+        apd->srcPos++;
+        (*nsrc)--;
+    }
+    /* now do the interpolation */
+    dst[0] = dst[1] = C168(I(apd->last[0].s, R16(src), r)); dst += 2;
+    apd->dstPos += apd->dstIncr;
+    (*ndst)--;
+    }
+}
+
+
+static  void cvtMM168C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
+            unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+
+    while (*nsrc != 0 && *ndst != 0) {
+    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+        if (*nsrc == 0) return;
+        apd->last[0].s = R16(src);  src += 2;
+        apd->srcPos++;
+        (*nsrc)--;
+    }
+    /* now do the interpolation */
+    *dst++ = C168(I(apd->last[0].s, R16(src), r));
+    apd->dstPos += apd->dstIncr;
+    (*ndst)--;
+    }
+}
+
+static  void cvtSS1616C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
+            unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+
+    while (*nsrc != 0 && *ndst != 0) {
+    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+        if (*nsrc == 0) return;
+        apd->last[0].s = R16(src);  src += 2;
+        apd->last[1].s = R16(src);  src += 2;
+        apd->srcPos++;
+        (*nsrc)--;
+    }
+    /* now do the interpolation */
+    W16(dst, I(apd->last[0].s, R16(src)  , r)); dst += 2;
+    W16(dst, I(apd->last[1].s, R16(src+2), r)); dst += 2;
+    apd->dstPos += apd->dstIncr;
+    (*ndst)--;
+    }
+}
+
+static  void cvtSM1616C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
+            unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+
+    while (*nsrc != 0 && *ndst != 0) {
+    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+        if (*nsrc == 0) return;
+        apd->last[0].s = R16(src);  src += 2;
+        apd->last[1].s = R16(src);  src += 2;
+        apd->srcPos++;
+        (*nsrc)--;
+    }
+    /* now do the interpolation */
+    W16(dst, I(M16(apd->last[0].s, apd->last[1].s),
+           M16(R16(src), R16(src+2)), r));
+    dst += 2;
+    apd->dstPos += apd->dstIncr;
+    (*ndst)--;
+    }
+}
+
+static  void cvtMS1616C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
+            unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+    short   v;
+
+    while (*nsrc != 0 && *ndst != 0) {
+    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+        if (*nsrc == 0) return;
+        apd->last[0].s = R16(src);  src += 2;
+        apd->srcPos++;
+        (*nsrc)--;
+    }
+    /* now do the interpolation */
+    v = I(apd->last[0].s, R16(src), r);
+    W16(dst, v);        dst += 2;
+    W16(dst, v);        dst += 2;
+    apd->dstPos += apd->dstIncr;
+    (*ndst)--;
+    }
+}
+
+static  void cvtMM1616C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
+            unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+
+    while (*nsrc != 0 && *ndst != 0) {
+    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+        if (*nsrc == 0) return;
+        apd->last[0].s = R16(src);  src += 2;
+        apd->srcPos++;
+        (*nsrc)--;
+    }
+    /* now do the interpolation */
+    W16(dst, I(apd->last[0].s, R16(src), r));   dst += 2;
+    apd->dstPos += apd->dstIncr;
+    (*ndst)--;
+    }
+}
+
+static  void (*PCM_ConvertChangeRate[16])(AcmPcmData* apd,
+                      const unsigned char* src, LPDWORD nsrc,
+                      unsigned char* dst, LPDWORD ndst) = {
     cvtSS88C,   cvtSM88C,   cvtMS88C,   cvtMM88C,
-    cvtSS816C,  cvtSM816C,  cvtMS816C,  cvtMM816C,
-    cvtSS168C,  cvtSM168C,  cvtMS168C,  cvtMM168C,
+    cvtSS816C,  cvtSM816C,  cvtMS816C,  cvtMM816C,
+    cvtSS168C,  cvtSM168C,  cvtMS168C,  cvtMM168C,
     cvtSS1616C, cvtSM1616C, cvtMS1616C, cvtMM1616C,
 };
@@ -691 +691 @@
  *
  */
-static  LRESULT PCM_DriverDetails(PACMDRIVERDETAILSW add)
+static  LRESULT PCM_DriverDetails(PACMDRIVERDETAILSW add)
 {
     add->fccType = ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC;
@@ -712 +712 @@
                          add->szLicensing, sizeof(add->szLicensing)/sizeof(WCHAR) );
     add->szFeatures[0] = 0;
-    
+
     return MMSYSERR_NOERROR;
 }
@@ -720 +720 @@
  *
  */
-static  LRESULT PCM_FormatTagDetails(PACMFORMATTAGDETAILSW aftd, DWORD dwQuery)
+static  LRESULT PCM_FormatTagDetails(PACMFORMATTAGDETAILSW aftd, DWORD dwQuery)
 {
     switch (dwQuery) {
     case ACM_FORMATTAGDETAILSF_INDEX:
-        if (aftd->dwFormatTagIndex != 0) return ACMERR_NOTPOSSIBLE;
-        break;
-    case ACM_FORMATTAGDETAILSF_FORMATTAG: 
-        if (aftd->dwFormatTag != WAVE_FORMAT_PCM) return ACMERR_NOTPOSSIBLE;
-        break;
+    if (aftd->dwFormatTagIndex != 0) return ACMERR_NOTPOSSIBLE;
+    break;
+    case ACM_FORMATTAGDETAILSF_FORMATTAG:
+    if (aftd->dwFormatTag != WAVE_FORMAT_PCM) return ACMERR_NOTPOSSIBLE;
+    break;
     case ACM_FORMATTAGDETAILSF_LARGESTSIZE:
-        if (aftd->dwFormatTag != WAVE_FORMAT_UNKNOWN && 
-            aftd->dwFormatTag != WAVE_FORMAT_UNKNOWN)
-            return ACMERR_NOTPOSSIBLE;
-        break;
+    if (aftd->dwFormatTag != WAVE_FORMAT_UNKNOWN &&
+        aftd->dwFormatTag != WAVE_FORMAT_UNKNOWN)
+        return ACMERR_NOTPOSSIBLE;
+    break;
     default:
-        WARN("Unsupported query %08lx\n", dwQuery);
-        return MMSYSERR_NOTSUPPORTED;
-    }
-    
+    WARN("Unsupported query %08lx\n", dwQuery);
+    return MMSYSERR_NOTSUPPORTED;
+    }
+
     aftd->dwFormatTagIndex = 0;
     aftd->dwFormatTag = WAVE_FORMAT_PCM;
@@ -745 +745 @@
     aftd->cStandardFormats = NUM_PCM_FORMATS;
     aftd->szFormatTag[0] = 0;
-    
+
     return MMSYSERR_NOERROR;
 }
@@ -753 +753 @@
  *
  */
-static  LRESULT PCM_FormatDetails(PACMFORMATDETAILSW afd, DWORD dwQuery)
+static  LRESULT PCM_FormatDetails(PACMFORMATDETAILSW afd, DWORD dwQuery)
 {
     switch (dwQuery) {
     case ACM_FORMATDETAILSF_FORMAT:
-        afd->dwFormatIndex = PCM_GetFormatIndex(afd->pwfx);
-        if (afd->dwFormatIndex == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE;
-        break;
+    afd->dwFormatIndex = PCM_GetFormatIndex(afd->pwfx);
+    if (afd->dwFormatIndex == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE;
+    break;
     case ACM_FORMATDETAILSF_INDEX:
-        assert(afd->dwFormatIndex < NUM_PCM_FORMATS);
-        afd->pwfx->wFormatTag = WAVE_FORMAT_PCM;
-        afd->pwfx->nChannels = PCM_Formats[afd->dwFormatIndex].nChannels;
-        afd->pwfx->nSamplesPerSec = PCM_Formats[afd->dwFormatIndex].rate;
-        afd->pwfx->wBitsPerSample = PCM_Formats[afd->dwFormatIndex].nBits;
-        /* native MSACM uses a PCMWAVEFORMAT structure, so cbSize is not accessible
-         * afd->pwfx->cbSize = 0; 
-         */
-        afd->pwfx->nBlockAlign = 
-            (afd->pwfx->nChannels * afd->pwfx->wBitsPerSample) / 8;
-        afd->pwfx->nAvgBytesPerSec = 
-            afd->pwfx->nSamplesPerSec * afd->pwfx->nBlockAlign;
-        break;
+    assert(afd->dwFormatIndex < NUM_PCM_FORMATS);
+    afd->pwfx->wFormatTag = WAVE_FORMAT_PCM;
+    afd->pwfx->nChannels = PCM_Formats[afd->dwFormatIndex].nChannels;
+    afd->pwfx->nSamplesPerSec = PCM_Formats[afd->dwFormatIndex].rate;
+    afd->pwfx->wBitsPerSample = PCM_Formats[afd->dwFormatIndex].nBits;
+    /* native MSACM uses a PCMWAVEFORMAT structure, so cbSize is not accessible
+     * afd->pwfx->cbSize = 0;
+     */
+    afd->pwfx->nBlockAlign =
+        (afd->pwfx->nChannels * afd->pwfx->wBitsPerSample) / 8;
+    afd->pwfx->nAvgBytesPerSec =
+        afd->pwfx->nSamplesPerSec * afd->pwfx->nBlockAlign;
+    break;
     default:
-        WARN("Unsupported query %08lx\n", dwQuery);
-        return MMSYSERR_NOTSUPPORTED;   
-    }
-    
+    WARN("Unsupported query %08lx\n", dwQuery);
+    return MMSYSERR_NOTSUPPORTED;
+    }
+
     afd->dwFormatTag = WAVE_FORMAT_PCM;
     afd->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CONVERTER;
     afd->szFormat[0] = 0; /* let MSACM format this for us... */
-    
+
     return MMSYSERR_NOERROR;
 }
@@ -790 +790 @@
  *
  */
-static  LRESULT PCM_FormatSuggest(PACMDRVFORMATSUGGEST adfs)
+static  LRESULT PCM_FormatSuggest(PACMDRVFORMATSUGGEST adfs)
 {
     FIXME("(%p);\n", adfs);
@@ -800 +800 @@
  *
  */
-static  void    PCM_Reset(AcmPcmData* apd, int srcNumBits)
+static  void    PCM_Reset(AcmPcmData* apd, int srcNumBits)
 {
     apd->srcPos = 0;
@@ -806 +806 @@
     /* initialize with neutral value */
     if (srcNumBits == 16) {
-        apd->last[0].s = 0;
-        apd->last[1].s = 0;
+    apd->last[0].s = 0;
+    apd->last[1].s = 0;
     } else {
-        apd->last[0].b = (BYTE)0x80;
-        apd->last[1].b = (BYTE)0x80;
+    apd->last[0].b = (BYTE)0x80;
+    apd->last[1].b = (BYTE)0x80;
     }
 }
@@ -818 +818 @@
  *
  */
-static  LRESULT PCM_StreamOpen(PACMDRVSTREAMINSTANCE adsi)
-{
-    AcmPcmData* apd;
-    int         idx = 0;
+static  LRESULT PCM_StreamOpen(PACMDRVSTREAMINSTANCE adsi)
+{
+    AcmPcmData* apd;
+    int     idx = 0;
 
     assert(!(adsi->fdwOpen & ACM_STREAMOPENF_ASYNC));
-    
+
     if (PCM_GetFormatIndex(adsi->pwfxSrc) == 0xFFFFFFFF ||
-        PCM_GetFormatIndex(adsi->pwfxDst) == 0xFFFFFFFF)
-        return ACMERR_NOTPOSSIBLE;
+    PCM_GetFormatIndex(adsi->pwfxDst) == 0xFFFFFFFF)
+    return ACMERR_NOTPOSSIBLE;
 
     apd = HeapAlloc(GetProcessHeap(), 0, sizeof(AcmPcmData));
@@ -834 +834 @@
     adsi->dwDriver = (DWORD)apd;
     adsi->fdwDriver = 0;
-    
+
     if (adsi->pwfxSrc->wBitsPerSample == 16) idx += 8;
     if (adsi->pwfxDst->wBitsPerSample == 16) idx += 4;
@@ -841 +841 @@
 
     if (adsi->pwfxSrc->nSamplesPerSec == adsi->pwfxDst->nSamplesPerSec) {
-        apd->cvt.cvtKeepRate = PCM_ConvertKeepRate[idx];
+    apd->cvt.cvtKeepRate = PCM_ConvertKeepRate[idx];
     } else {
-        adsi->fdwDriver |= PCM_RESAMPLE;
-        apd->dstIncr = (double)(adsi->pwfxSrc->nSamplesPerSec) /
-            (double)(adsi->pwfxDst->nSamplesPerSec);
-        PCM_Reset(apd, adsi->pwfxSrc->wBitsPerSample);
-        apd->cvt.cvtChangeRate = PCM_ConvertChangeRate[idx];
+    adsi->fdwDriver |= PCM_RESAMPLE;
+    apd->dstIncr = (double)(adsi->pwfxSrc->nSamplesPerSec) /
+        (double)(adsi->pwfxDst->nSamplesPerSec);
+    PCM_Reset(apd, adsi->pwfxSrc->wBitsPerSample);
+    apd->cvt.cvtChangeRate = PCM_ConvertChangeRate[idx];
     }
 
@@ -857 +857 @@
  *
  */
-static  LRESULT PCM_StreamClose(PACMDRVSTREAMINSTANCE adsi)
+static  LRESULT PCM_StreamClose(PACMDRVSTREAMINSTANCE adsi)
 {
     HeapFree(GetProcessHeap(), 0, (void*)adsi->dwDriver);
@@ -867 +867 @@
  *
  */
-static  inline DWORD    PCM_round(DWORD a, DWORD b, DWORD c)
+static  inline DWORD    PCM_round(DWORD a, DWORD b, DWORD c)
 {
     assert(a && b && c);
@@ -878 +878 @@
  *
  */
-static  LRESULT PCM_StreamSize(PACMDRVSTREAMINSTANCE adsi, PACMDRVSTREAMSIZE adss)
+static  LRESULT PCM_StreamSize(PACMDRVSTREAMINSTANCE adsi, PACMDRVSTREAMSIZE adss)
 {
     switch (adss->fdwSize) {
     case ACM_STREAMSIZEF_DESTINATION:
-        /* cbDstLength => cbSrcLength */
-        adss->cbSrcLength = PCM_round(adss->cbDstLength, 
-                                      adsi->pwfxSrc->nAvgBytesPerSec, 
-                                      adsi->pwfxDst->nAvgBytesPerSec);
-        break;
+    /* cbDstLength => cbSrcLength */
+    adss->cbSrcLength = PCM_round(adss->cbDstLength,
+                      adsi->pwfxSrc->nAvgBytesPerSec,
+                      adsi->pwfxDst->nAvgBytesPerSec);
+    break;
     case ACM_STREAMSIZEF_SOURCE:
-        /* cbSrcLength => cbDstLength */
-        adss->cbDstLength =  PCM_round(adss->cbSrcLength, 
-                                       adsi->pwfxDst->nAvgBytesPerSec, 
-                                       adsi->pwfxSrc->nAvgBytesPerSec);
-        break;
+    /* cbSrcLength => cbDstLength */
+    adss->cbDstLength =  PCM_round(adss->cbSrcLength,
+                       adsi->pwfxDst->nAvgBytesPerSec,
+                       adsi->pwfxSrc->nAvgBytesPerSec);
+    break;
     default:
-        WARN("Unsupported query %08lx\n", adss->fdwSize);
-        return MMSYSERR_NOTSUPPORTED;   
+    WARN("Unsupported query %08lx\n", adss->fdwSize);
+    return MMSYSERR_NOTSUPPORTED;
     }
     return MMSYSERR_NOERROR;
@@ -906 +906 @@
 static LRESULT PCM_StreamConvert(PACMDRVSTREAMINSTANCE adsi, PACMDRVSTREAMHEADER adsh)
 {
-    AcmPcmData* apd = (AcmPcmData*)adsi->dwDriver;
-    DWORD       nsrc = NUM_OF(adsh->cbSrcLength, adsi->pwfxSrc->nBlockAlign);
-    DWORD       ndst = NUM_OF(adsh->cbDstLength, adsi->pwfxDst->nBlockAlign);
-
-    if (adsh->fdwConvert & 
-        ~(ACM_STREAMCONVERTF_BLOCKALIGN|
-          ACM_STREAMCONVERTF_END|
-          ACM_STREAMCONVERTF_START)) {
-        FIXME("Unsupported fdwConvert (%08lx), ignoring it\n", adsh->fdwConvert);
+    AcmPcmData* apd = (AcmPcmData*)adsi->dwDriver;
+    DWORD   nsrc = NUM_OF(adsh->cbSrcLength, adsi->pwfxSrc->nBlockAlign);
+    DWORD   ndst = NUM_OF(adsh->cbDstLength, adsi->pwfxDst->nBlockAlign);
+
+    if (adsh->fdwConvert &
+    ~(ACM_STREAMCONVERTF_BLOCKALIGN|
+      ACM_STREAMCONVERTF_END|
+      ACM_STREAMCONVERTF_START)) {
+    FIXME("Unsupported fdwConvert (%08lx), ignoring it\n", adsh->fdwConvert);
     }
     /* ACM_STREAMCONVERTF_BLOCKALIGN
-     *  currently all conversions are block aligned, so do nothing for this flag
+     *  currently all conversions are block aligned, so do nothing for this flag
      * ACM_STREAMCONVERTF_END
-     *  no pending data, so do nothing for this flag
+     *  no pending data, so do nothing for this flag
      */
-    if ((adsh->fdwConvert & ACM_STREAMCONVERTF_START) && 
-        (adsi->fdwDriver & PCM_RESAMPLE)) {
-        PCM_Reset(apd, adsi->pwfxSrc->wBitsPerSample);
+    if ((adsh->fdwConvert & ACM_STREAMCONVERTF_START) &&
+    (adsi->fdwDriver & PCM_RESAMPLE)) {
+    PCM_Reset(apd, adsi->pwfxSrc->wBitsPerSample);
     }
 
     /* do the job */
     if (adsi->fdwDriver & PCM_RESAMPLE) {
-        DWORD   nsrc2 = nsrc;
-        DWORD   ndst2 = ndst;
-
-        apd->cvt.cvtChangeRate(apd, adsh->pbSrc, &nsrc2, adsh->pbDst, &ndst2);
-        nsrc -= nsrc2;
-        ndst -= ndst2;
+    DWORD   nsrc2 = nsrc;
+    DWORD   ndst2 = ndst;
+
+    apd->cvt.cvtChangeRate(apd, adsh->pbSrc, &nsrc2, adsh->pbDst, &ndst2);
+    nsrc -= nsrc2;
+    ndst -= ndst2;
     } else {
-        if (nsrc < ndst) ndst = nsrc; else nsrc = ndst;
-
-        /* nsrc is now equal to ndst */
-        apd->cvt.cvtKeepRate(adsh->pbSrc, nsrc, adsh->pbDst);
+    if (nsrc < ndst) ndst = nsrc; else nsrc = ndst;
+
+    /* nsrc is now equal to ndst */
+    apd->cvt.cvtKeepRate(adsh->pbSrc, nsrc, adsh->pbDst);
     }
 
@@ -948 +948 @@
 
 /**************************************************************************
- *                      PCM_DriverProc                  [exported]
- */
-LRESULT CALLBACK        PCM_DriverProc(DWORD dwDevID, HDRVR hDriv, UINT wMsg, 
-                                       LPARAM dwParam1, LPARAM dwParam2)
-{
-    TRACE("(%08lx %08lx %u %08lx %08lx);\n", 
-          dwDevID, (DWORD)hDriv, wMsg, dwParam1, dwParam2);
-    
+ *          PCM_DriverProc          [exported]
+ */
+LRESULT CALLBACK    PCM_DriverProc(DWORD dwDevID, HDRVR hDriv, UINT wMsg,
+                       LPARAM dwParam1, LPARAM dwParam2)
+{
+    TRACE("(%08lx %08lx %u %08lx %08lx);\n",
+      dwDevID, (DWORD)hDriv, wMsg, dwParam1, dwParam2);
+
     switch (wMsg) {
-    case DRV_LOAD:              return 1;
-    case DRV_FREE:              return 1;
-    case DRV_OPEN:              return PCM_drvOpen((LPSTR)dwParam1);
-    case DRV_CLOSE:             return PCM_drvClose(dwDevID);
-    case DRV_ENABLE:            return 1;       
-    case DRV_DISABLE:           return 1;
-    case DRV_QUERYCONFIGURE:    return 1;
-    case DRV_CONFIGURE:         MessageBoxA(0, "MSACM PCM filter !", "Wine Driver", MB_OK); return 1;
-    case DRV_INSTALL:           return DRVCNF_RESTART;
-    case DRV_REMOVE:            return DRVCNF_RESTART;
-        
+    case DRV_LOAD:      return 1;
+    case DRV_FREE:      return 1;
+    case DRV_OPEN:      return PCM_drvOpen((LPSTR)dwParam1);
+    case DRV_CLOSE:     return PCM_drvClose(dwDevID);
+    case DRV_ENABLE:        return 1;
+    case DRV_DISABLE:       return 1;
+    case DRV_QUERYCONFIGURE:    return 1;
+    case DRV_CONFIGURE:     MessageBoxA(0, "MSACM PCM filter !", "Wine Driver", MB_OK); return 1;
+    case DRV_INSTALL:       return DRVCNF_RESTART;
+    case DRV_REMOVE:        return DRVCNF_RESTART;
+
     case ACMDM_DRIVER_NOTIFY:
-        /* no caching from other ACM drivers is done so far */
-        return MMSYSERR_NOERROR;
-        
+    /* no caching from other ACM drivers is done so far */
+    return MMSYSERR_NOERROR;
+
     case ACMDM_DRIVER_DETAILS:
-        return PCM_DriverDetails((PACMDRIVERDETAILSW)dwParam1);
-        
+    return PCM_DriverDetails((PACMDRIVERDETAILSW)dwParam1);
+
     case ACMDM_FORMATTAG_DETAILS:
-        return PCM_FormatTagDetails((PACMFORMATTAGDETAILSW)dwParam1, dwParam2);
-        
+    return PCM_FormatTagDetails((PACMFORMATTAGDETAILSW)dwParam1, dwParam2);
+
     case ACMDM_FORMAT_DETAILS:
-        return PCM_FormatDetails((PACMFORMATDETAILSW)dwParam1, dwParam2);
-        
+    return PCM_FormatDetails((PACMFORMATDETAILSW)dwParam1, dwParam2);
+
     case ACMDM_FORMAT_SUGGEST:
-        return PCM_FormatSuggest((PACMDRVFORMATSUGGEST)dwParam1);
-        
+    return PCM_FormatSuggest((PACMDRVFORMATSUGGEST)dwParam1);
+
     case ACMDM_STREAM_OPEN:
-        return PCM_StreamOpen((PACMDRVSTREAMINSTANCE)dwParam1);
-        
+    return PCM_StreamOpen((PACMDRVSTREAMINSTANCE)dwParam1);
+
     case ACMDM_STREAM_CLOSE:
-        return PCM_StreamClose((PACMDRVSTREAMINSTANCE)dwParam1);
-        
+    return PCM_StreamClose((PACMDRVSTREAMINSTANCE)dwParam1);
+
     case ACMDM_STREAM_SIZE:
-        return PCM_StreamSize((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMSIZE)dwParam2);
-        
+    return PCM_StreamSize((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMSIZE)dwParam2);
+
     case ACMDM_STREAM_CONVERT:
-        return PCM_StreamConvert((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMHEADER)dwParam2);
-        
+    return PCM_StreamConvert((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMHEADER)dwParam2);
+
     case ACMDM_HARDWARE_WAVE_CAPS_INPUT:
     case ACMDM_HARDWARE_WAVE_CAPS_OUTPUT:
-        /* this converter is not a hardware driver */
+    /* this converter is not a hardware driver */
     case ACMDM_FILTERTAG_DETAILS:
     case ACMDM_FILTER_DETAILS:
-        /* this converter is not a filter */
+    /* this converter is not a filter */
     case ACMDM_STREAM_RESET:
-        /* only needed for asynchronous driver... we aren't, so just say it */
+    /* only needed for asynchronous driver... we aren't, so just say it */
     case ACMDM_STREAM_PREPARE:
     case ACMDM_STREAM_UNPREPARE:
-        /* nothing special to do here... so don't do anything */
-        return MMSYSERR_NOTSUPPORTED;
-        
+    /* nothing special to do here... so don't do anything */
+    return MMSYSERR_NOTSUPPORTED;
+
     default:
-        return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
+    return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
     }
     return 0;

trunk/src/msacm32/stream.c

@@ -1 +1 @@
 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
-
+/* $Id: stream.c,v 1.2 2001-09-05 13:11:26 bird Exp $ */
 /*
  *      MSACM32 library
  *
  *      Copyright 1998  Patrik Stridvall
- *                1999  Eric Pouech
+ *        1999  Eric Pouech
  */
 
 /* TODO
- *      + asynchronous conversion is not implemented
- *      + callback/notification
- *      * acmStreamMessage
- *      + properly close ACM streams
+ *  + asynchronous conversion is not implemented
+ *  + callback/notification
+ *  * acmStreamMessage
+ *  + properly close ACM streams
  */
 
@@ -26 +26 @@
 
 DEFAULT_DEBUG_CHANNEL(msacm);
-    
-static PWINE_ACMSTREAM  ACM_GetStream(HACMSTREAM has)
+
+static PWINE_ACMSTREAM  ACM_GetStream(HACMSTREAM has)
 {
     return (PWINE_ACMSTREAM)has;
@@ -37 +37 @@
 MMRESULT WINAPI acmStreamClose(HACMSTREAM has, DWORD fdwClose)
 {
-    PWINE_ACMSTREAM     was;
-    MMRESULT            ret;
-                
+    PWINE_ACMSTREAM was;
+    MMRESULT        ret;
+
     TRACE("(0x%08x, %ld)\n", has, fdwClose);
-    
+
     if ((was = ACM_GetStream(has)) == NULL) {
-        return MMSYSERR_INVALHANDLE;
+    return MMSYSERR_INVALHANDLE;
     }
     ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_CLOSE, (DWORD)&was->drvInst, 0);
     if (ret == MMSYSERR_NOERROR) {
-        if (was->hAcmDriver)
-            acmDriverClose(was->hAcmDriver, 0L);        
-        HeapFree(MSACM_hHeap, 0, was);
+    if (was->hAcmDriver)
+        acmDriverClose(was->hAcmDriver, 0L);
+    HeapFree(MSACM_hHeap, 0, was);
     }
     TRACE("=> (%d)\n", ret);
@@ -58 +58 @@
  *           acmStreamConvert (MSACM32.38)
  */
-MMRESULT WINAPI acmStreamConvert(HACMSTREAM has, PACMSTREAMHEADER pash, 
-                                 DWORD fdwConvert)
-{
-    PWINE_ACMSTREAM     was;
-    MMRESULT            ret = MMSYSERR_NOERROR;
-    PACMDRVSTREAMHEADER padsh;
+MMRESULT WINAPI acmStreamConvert(HACMSTREAM has, PACMSTREAMHEADER pash,
+                 DWORD fdwConvert)
+{
+    PWINE_ACMSTREAM was;
+    MMRESULT        ret = MMSYSERR_NOERROR;
+    PACMDRVSTREAMHEADER padsh;
 
     TRACE("(0x%08x, %p, %ld)\n", has, pash, fdwConvert);
-    
+
     if ((was = ACM_GetStream(has)) == NULL)
-        return MMSYSERR_INVALHANDLE;
+    return MMSYSERR_INVALHANDLE;
     if (!pash || pash->cbStruct < sizeof(ACMSTREAMHEADER))
-        return MMSYSERR_INVALPARAM;
+    return MMSYSERR_INVALPARAM;
 
     if (!(pash->fdwStatus & ACMSTREAMHEADER_STATUSF_PREPARED))
-        return ACMERR_UNPREPARED;
+    return ACMERR_UNPREPARED;
 
     /* Note: the ACMSTREAMHEADER and ACMDRVSTREAMHEADER structs are of same
@@ -83 +83 @@
     /* check that pointers have not been modified */
     if (padsh->pbPreparedSrc != padsh->pbSrc ||
-        padsh->cbPreparedSrcLength < padsh->cbSrcLength ||
-        padsh->pbPreparedDst != padsh->pbDst ||
-        padsh->cbPreparedDstLength < padsh->cbDstLength) {
-        return MMSYSERR_INVALPARAM;
-    }   
+    padsh->cbPreparedSrcLength < padsh->cbSrcLength ||
+    padsh->pbPreparedDst != padsh->pbDst ||
+    padsh->cbPreparedDstLength < padsh->cbDstLength) {
+    return MMSYSERR_INVALPARAM;
+    }
 
     padsh->fdwConvert = fdwConvert;
@@ -93 +93 @@
     ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_CONVERT, (DWORD)&was->drvInst, (DWORD)padsh);
     if (ret == MMSYSERR_NOERROR) {
-        padsh->fdwStatus |= ACMSTREAMHEADER_STATUSF_DONE;
+    padsh->fdwStatus |= ACMSTREAMHEADER_STATUSF_DONE;
     }
     TRACE("=> (%d)\n", ret);
@@ -102 +102 @@
  *           acmStreamMessage (MSACM32.39)
  */
-MMRESULT WINAPI acmStreamMessage(HACMSTREAM has, UINT uMsg, LPARAM lParam1, 
-                                 LPARAM lParam2)
+MMRESULT WINAPI acmStreamMessage(HACMSTREAM has, UINT uMsg, LPARAM lParam1,
+                 LPARAM lParam2)
 {
     FIXME("(0x%08x, %u, %ld, %ld): stub\n", has, uMsg, lParam1, lParam2);
@@ -114 +114 @@
  */
 MMRESULT WINAPI acmStreamOpen(PHACMSTREAM phas, HACMDRIVER had, PWAVEFORMATEX pwfxSrc,
-                              PWAVEFORMATEX pwfxDst, PWAVEFILTER pwfltr, DWORD dwCallback,
-                              DWORD dwInstance, DWORD fdwOpen)
-{
-    PWINE_ACMSTREAM     was;
-    PWINE_ACMDRIVER     wad;
-    MMRESULT            ret;
-    int                 wfxSrcSize;
-    int                 wfxDstSize;
-    
+                  PWAVEFORMATEX pwfxDst, PWAVEFILTER pwfltr, DWORD dwCallback,
+                  DWORD dwInstance, DWORD fdwOpen)
+{
+    PWINE_ACMSTREAM was;
+    PWINE_ACMDRIVER wad;
+    MMRESULT        ret;
+    int         wfxSrcSize;
+    int         wfxDstSize;
+
     TRACE("(%p, 0x%08x, %p, %p, %p, %ld, %ld, %ld)\n",
-          phas, had, pwfxSrc, pwfxDst, pwfltr, dwCallback, dwInstance, fdwOpen);
-
-    TRACE("src [wFormatTag=%u, nChannels=%u, nSamplesPerSec=%lu, nAvgBytesPerSec=%lu, nBlockAlign=%u, wBitsPerSample=%u, cbSize=%u]\n", 
-          pwfxSrc->wFormatTag, pwfxSrc->nChannels, pwfxSrc->nSamplesPerSec, pwfxSrc->nAvgBytesPerSec, 
-          pwfxSrc->nBlockAlign, pwfxSrc->wBitsPerSample, pwfxSrc->cbSize);
-
-    TRACE("dst [wFormatTag=%u, nChannels=%u, nSamplesPerSec=%lu, nAvgBytesPerSec=%lu, nBlockAlign=%u, wBitsPerSample=%u, cbSize=%u]\n", 
-          pwfxDst->wFormatTag, pwfxDst->nChannels, pwfxDst->nSamplesPerSec, pwfxDst->nAvgBytesPerSec, 
-          pwfxDst->nBlockAlign, pwfxDst->wBitsPerSample, pwfxDst->cbSize);
+      phas, had, pwfxSrc, pwfxDst, pwfltr, dwCallback, dwInstance, fdwOpen);
+
+    TRACE("src [wFormatTag=%u, nChannels=%u, nSamplesPerSec=%lu, nAvgBytesPerSec=%lu, nBlockAlign=%u, wBitsPerSample=%u, cbSize=%u]\n",
+      pwfxSrc->wFormatTag, pwfxSrc->nChannels, pwfxSrc->nSamplesPerSec, pwfxSrc->nAvgBytesPerSec,
+      pwfxSrc->nBlockAlign, pwfxSrc->wBitsPerSample, pwfxSrc->cbSize);
+
+    TRACE("dst [wFormatTag=%u, nChannels=%u, nSamplesPerSec=%lu, nAvgBytesPerSec=%lu, nBlockAlign=%u, wBitsPerSample=%u, cbSize=%u]\n",
+      pwfxDst->wFormatTag, pwfxDst->nChannels, pwfxDst->nSamplesPerSec, pwfxDst->nAvgBytesPerSec,
+      pwfxDst->nBlockAlign, pwfxDst->wBitsPerSample, pwfxDst->cbSize);
 
     if ((fdwOpen & ACM_STREAMOPENF_QUERY) && phas) return MMSYSERR_INVALPARAM;
@@ -143 +143 @@
     was = HeapAlloc(MSACM_hHeap, 0, sizeof(*was) + wfxSrcSize + wfxDstSize + ((pwfltr) ? sizeof(WAVEFILTER) : 0));
     if (was == NULL)
-        return MMSYSERR_NOMEM;
-    
+    return MMSYSERR_NOMEM;
+
     was->drvInst.cbStruct = sizeof(was->drvInst);
     was->drvInst.pwfxSrc = (PWAVEFORMATEX)((LPSTR)was + sizeof(*was));
@@ -151 +151 @@
     memcpy(was->drvInst.pwfxDst, pwfxDst, wfxDstSize);
     if (pwfltr) {
-        was->drvInst.pwfltr = (PWAVEFILTER)((LPSTR)was + sizeof(*was) + wfxSrcSize + wfxDstSize);
-        memcpy(was->drvInst.pwfltr, pwfltr, sizeof(WAVEFILTER));
+    was->drvInst.pwfltr = (PWAVEFILTER)((LPSTR)was + sizeof(*was) + wfxSrcSize + wfxDstSize);
+    memcpy(was->drvInst.pwfltr, pwfltr, sizeof(WAVEFILTER));
     } else {
-        was->drvInst.pwfltr = NULL;
-    }
-    was->drvInst.dwCallback = dwCallback;    
+    was->drvInst.pwfltr = NULL;
+    }
+    was->drvInst.dwCallback = dwCallback;
     was->drvInst.dwInstance = dwInstance;
     was->drvInst.fdwOpen = fdwOpen;
-    was->drvInst.fdwDriver = 0L;  
-    was->drvInst.dwDriver = 0L;     
+    was->drvInst.fdwDriver = 0L;
+    was->drvInst.dwDriver = 0L;
     was->drvInst.has = (HACMSTREAM)was;
-    
+
     if (had) {
-        if (!(wad = MSACM_GetDriver(had))) {
-            ret = MMSYSERR_INVALPARAM;
-            goto errCleanUp;
-        }
-        
-        was->obj.dwType = WINE_ACMOBJ_STREAM;
-        was->obj.pACMDriverID = wad->obj.pACMDriverID;
-        was->pDrv = wad;
-        was->hAcmDriver = 0; /* not to close it in acmStreamClose */
-
-        ret = SendDriverMessage(wad->hDrvr, ACMDM_STREAM_OPEN, (DWORD)&was->drvInst, 0L);
-        if (ret != MMSYSERR_NOERROR)
-            goto errCleanUp;
+    if (!(wad = MSACM_GetDriver(had))) {
+        ret = MMSYSERR_INVALPARAM;
+        goto errCleanUp;
+    }
+
+    was->obj.dwType = WINE_ACMOBJ_STREAM;
+    was->obj.pACMDriverID = wad->obj.pACMDriverID;
+    was->pDrv = wad;
+    was->hAcmDriver = 0; /* not to close it in acmStreamClose */
+
+    ret = SendDriverMessage(wad->hDrvr, ACMDM_STREAM_OPEN, (DWORD)&was->drvInst, 0L);
+    if (ret != MMSYSERR_NOERROR)
+        goto errCleanUp;
     } else {
-        PWINE_ACMDRIVERID wadi;
-        
-        ret = ACMERR_NOTPOSSIBLE;
-        for (wadi = MSACM_pFirstACMDriverID; wadi; wadi = wadi->pNextACMDriverID) {
-            ret = acmDriverOpen(&had, (HACMDRIVERID)wadi, 0L);
-            if (ret == MMSYSERR_NOERROR) {
-                if ((wad = MSACM_GetDriver(had)) != 0) {
-                    was->obj.dwType = WINE_ACMOBJ_STREAM;
-                    was->obj.pACMDriverID = wad->obj.pACMDriverID;
-                    was->pDrv = wad;
-                    was->hAcmDriver = had;
-                    
-                    ret = SendDriverMessage(wad->hDrvr, ACMDM_STREAM_OPEN, (DWORD)&was->drvInst, 0L);
-                    if (ret == MMSYSERR_NOERROR) {
-                        if (fdwOpen & ACM_STREAMOPENF_QUERY) {
-                            acmDriverClose(had, 0L);
-                        }
-                        break;
-                    }
-                }
-                /* no match, close this acm driver and try next one */
-                acmDriverClose(had, 0L);
-            }
-        }
-        if (ret != MMSYSERR_NOERROR) {
-            ret = ACMERR_NOTPOSSIBLE;
-            goto errCleanUp;
-        }
+    PWINE_ACMDRIVERID wadi;
+
+    ret = ACMERR_NOTPOSSIBLE;
+    for (wadi = MSACM_pFirstACMDriverID; wadi; wadi = wadi->pNextACMDriverID) {
+        ret = acmDriverOpen(&had, (HACMDRIVERID)wadi, 0L);
+        if (ret == MMSYSERR_NOERROR) {
+        if ((wad = MSACM_GetDriver(had)) != 0) {
+            was->obj.dwType = WINE_ACMOBJ_STREAM;
+            was->obj.pACMDriverID = wad->obj.pACMDriverID;
+            was->pDrv = wad;
+            was->hAcmDriver = had;
+
+            ret = SendDriverMessage(wad->hDrvr, ACMDM_STREAM_OPEN, (DWORD)&was->drvInst, 0L);
+            if (ret == MMSYSERR_NOERROR) {
+            if (fdwOpen & ACM_STREAMOPENF_QUERY) {
+                acmDriverClose(had, 0L);
+            }
+            break;
+            }
+        }
+        /* no match, close this acm driver and try next one */
+        acmDriverClose(had, 0L);
+        }
+    }
+    if (ret != MMSYSERR_NOERROR) {
+        ret = ACMERR_NOTPOSSIBLE;
+        goto errCleanUp;
+    }
     }
     ret = MMSYSERR_NOERROR;
     if (!(fdwOpen & ACM_STREAMOPENF_QUERY)) {
-        if (phas)
-            *phas = (HACMSTREAM)was;
-        TRACE("=> (%d)\n", ret);
-        return ret;
-    }
-errCleanUp:             
     if (phas)
-        *phas = (HACMSTREAM)0;
+        *phas = (HACMSTREAM)was;
+    TRACE("=> (%d)\n", ret);
+    return ret;
+    }
+errCleanUp:
+    if (phas)
+    *phas = (HACMSTREAM)0;
     HeapFree(MSACM_hHeap, 0, was);
     TRACE("=> (%d)\n", ret);
@@ -226 +226 @@
  *           acmStreamPrepareHeader (MSACM32.41)
  */
-MMRESULT WINAPI acmStreamPrepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash, 
-                                       DWORD fdwPrepare)
-{
-    PWINE_ACMSTREAM     was;
-    MMRESULT            ret = MMSYSERR_NOERROR;
-    PACMDRVSTREAMHEADER padsh;
+MMRESULT WINAPI acmStreamPrepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash,
+                       DWORD fdwPrepare)
+{
+    PWINE_ACMSTREAM was;
+    MMRESULT        ret = MMSYSERR_NOERROR;
+    PACMDRVSTREAMHEADER padsh;
 
     TRACE("(0x%08x, %p, %ld)\n", has, pash, fdwPrepare);
-    
+
     if ((was = ACM_GetStream(has)) == NULL)
-        return MMSYSERR_INVALHANDLE;
+    return MMSYSERR_INVALHANDLE;
     if (!pash || pash->cbStruct < sizeof(ACMSTREAMHEADER))
-        return MMSYSERR_INVALPARAM;
+    return MMSYSERR_INVALPARAM;
     if (fdwPrepare)
-        ret = MMSYSERR_INVALFLAG;
+    ret = MMSYSERR_INVALFLAG;
 
     if (pash->fdwStatus & ACMSTREAMHEADER_STATUSF_DONE)
-        return MMSYSERR_NOERROR;
+    return MMSYSERR_NOERROR;
 
     /* Note: the ACMSTREAMHEADER and ACMDRVSTREAMHEADER structs are of same
@@ -264 +264 @@
     ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_PREPARE, (DWORD)&was->drvInst, (DWORD)padsh);
     if (ret == MMSYSERR_NOERROR || ret == MMSYSERR_NOTSUPPORTED) {
-        ret = MMSYSERR_NOERROR;
-        padsh->fdwStatus &= ~(ACMSTREAMHEADER_STATUSF_DONE|ACMSTREAMHEADER_STATUSF_INQUEUE);
-        padsh->fdwStatus |= ACMSTREAMHEADER_STATUSF_PREPARED;
-        padsh->fdwPrepared = padsh->fdwStatus;
-        padsh->dwPrepared = 0;
-        padsh->pbPreparedSrc = padsh->pbSrc;
-        padsh->cbPreparedSrcLength = padsh->cbSrcLength;
-        padsh->pbPreparedDst = padsh->pbDst;
-        padsh->cbPreparedDstLength = padsh->cbDstLength;
+    ret = MMSYSERR_NOERROR;
+    padsh->fdwStatus &= ~(ACMSTREAMHEADER_STATUSF_DONE|ACMSTREAMHEADER_STATUSF_INQUEUE);
+    padsh->fdwStatus |= ACMSTREAMHEADER_STATUSF_PREPARED;
+    padsh->fdwPrepared = padsh->fdwStatus;
+    padsh->dwPrepared = 0;
+    padsh->pbPreparedSrc = padsh->pbSrc;
+    padsh->cbPreparedSrcLength = padsh->cbSrcLength;
+    padsh->pbPreparedDst = padsh->pbDst;
+    padsh->cbPreparedDstLength = padsh->cbDstLength;
     } else {
-        padsh->fdwPrepared = 0;
-        padsh->dwPrepared = 0;
-        padsh->pbPreparedSrc = 0;
-        padsh->cbPreparedSrcLength = 0;
-        padsh->pbPreparedDst = 0;
-        padsh->cbPreparedDstLength = 0;
+    padsh->fdwPrepared = 0;
+    padsh->dwPrepared = 0;
+    padsh->pbPreparedSrc = 0;
+    padsh->cbPreparedSrcLength = 0;
+    padsh->pbPreparedDst = 0;
+    padsh->cbPreparedDstLength = 0;
     }
     TRACE("=> (%d)\n", ret);
@@ -290 +290 @@
 MMRESULT WINAPI acmStreamReset(HACMSTREAM has, DWORD fdwReset)
 {
-    PWINE_ACMSTREAM     was;
-    MMRESULT            ret = MMSYSERR_NOERROR;
+    PWINE_ACMSTREAM was;
+    MMRESULT        ret = MMSYSERR_NOERROR;
 
     TRACE("(0x%08x, %ld)\n", has, fdwReset);
 
     if (fdwReset) {
-        ret = MMSYSERR_INVALFLAG;
+    ret = MMSYSERR_INVALFLAG;
     } else if ((was = ACM_GetStream(has)) == NULL) {
-        return MMSYSERR_INVALHANDLE;
+    return MMSYSERR_INVALHANDLE;
     } else if (was->drvInst.fdwOpen & ACM_STREAMOPENF_ASYNC) {
-        ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_RESET, (DWORD)&was->drvInst, 0);
+    ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_RESET, (DWORD)&was->drvInst, 0);
     }
     TRACE("=> (%d)\n", ret);
@@ -309 +309 @@
  *           acmStreamSize (MSACM32.43)
  */
-MMRESULT WINAPI acmStreamSize(HACMSTREAM has, DWORD cbInput, 
-                              LPDWORD pdwOutputBytes, DWORD fdwSize)
-{
-    PWINE_ACMSTREAM     was;
-    ACMDRVSTREAMSIZE    adss;
-    MMRESULT            ret;
-    
+MMRESULT WINAPI acmStreamSize(HACMSTREAM has, DWORD cbInput,
+                  LPDWORD pdwOutputBytes, DWORD fdwSize)
+{
+    PWINE_ACMSTREAM was;
+    ACMDRVSTREAMSIZE    adss;
+    MMRESULT        ret;
+
     TRACE("(0x%08x, %ld, %p, %ld)\n", has, cbInput, pdwOutputBytes, fdwSize);
-    
+
     if ((was = ACM_GetStream(has)) == NULL) {
-        return MMSYSERR_INVALHANDLE;
+    return MMSYSERR_INVALHANDLE;
     }
     if ((fdwSize & ~ACM_STREAMSIZEF_QUERYMASK) != 0) {
-        return MMSYSERR_INVALFLAG;
+    return MMSYSERR_INVALFLAG;
     }
 
     *pdwOutputBytes = 0L;
-    
+
     switch (fdwSize & ACM_STREAMSIZEF_QUERYMASK) {
     case ACM_STREAMSIZEF_DESTINATION:
-        adss.cbDstLength = cbInput;
-        adss.cbSrcLength = 0;
-        break;
+    adss.cbDstLength = cbInput;
+    adss.cbSrcLength = 0;
+    break;
     case ACM_STREAMSIZEF_SOURCE:
-        adss.cbSrcLength = cbInput;
-        adss.cbDstLength = 0;
-        break;
-    default:    
-        return MMSYSERR_INVALFLAG;
-    }
-    
+    adss.cbSrcLength = cbInput;
+    adss.cbDstLength = 0;
+    break;
+    default:
+    return MMSYSERR_INVALFLAG;
+    }
+
     adss.cbStruct = sizeof(adss);
     adss.fdwSize = fdwSize;
-    ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_SIZE, 
-                            (DWORD)&was->drvInst, (DWORD)&adss);
+    ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_SIZE,
+                (DWORD)&was->drvInst, (DWORD)&adss);
     if (ret == MMSYSERR_NOERROR) {
-        switch (fdwSize & ACM_STREAMSIZEF_QUERYMASK) {
-        case ACM_STREAMSIZEF_DESTINATION:
-            *pdwOutputBytes = adss.cbSrcLength;
-            break;
-        case ACM_STREAMSIZEF_SOURCE:
-            *pdwOutputBytes = adss.cbDstLength;
-            break;
-        }
+    switch (fdwSize & ACM_STREAMSIZEF_QUERYMASK) {
+    case ACM_STREAMSIZEF_DESTINATION:
+        *pdwOutputBytes = adss.cbSrcLength;
+        break;
+    case ACM_STREAMSIZEF_SOURCE:
+        *pdwOutputBytes = adss.cbDstLength;
+        break;
+    }
     }
     TRACE("=> (%d) [%lu]\n", ret, *pdwOutputBytes);
@@ -361 +361 @@
  *           acmStreamUnprepareHeader (MSACM32.44)
  */
-MMRESULT WINAPI acmStreamUnprepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash, 
-                                         DWORD fdwUnprepare)
-{
-    PWINE_ACMSTREAM     was;
-    MMRESULT            ret = MMSYSERR_NOERROR;
-    PACMDRVSTREAMHEADER padsh;
+MMRESULT WINAPI acmStreamUnprepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash,
+                     DWORD fdwUnprepare)
+{
+    PWINE_ACMSTREAM was;
+    MMRESULT        ret = MMSYSERR_NOERROR;
+    PACMDRVSTREAMHEADER padsh;
 
     TRACE("(0x%08x, %p, %ld)\n", has, pash, fdwUnprepare);
-    
+
     if ((was = ACM_GetStream(has)) == NULL)
-        return MMSYSERR_INVALHANDLE;
+    return MMSYSERR_INVALHANDLE;
     if (!pash || pash->cbStruct < sizeof(ACMSTREAMHEADER))
-        return MMSYSERR_INVALPARAM;
+    return MMSYSERR_INVALPARAM;
 
     if (!(pash->fdwStatus & ACMSTREAMHEADER_STATUSF_PREPARED))
-        return ACMERR_UNPREPARED;
+    return ACMERR_UNPREPARED;
 
     /* Note: the ACMSTREAMHEADER and ACMDRVSTREAMHEADER structs are of same
@@ -386 +386 @@
     /* check that pointers have not been modified */
     if (padsh->pbPreparedSrc != padsh->pbSrc ||
-        padsh->cbPreparedSrcLength < padsh->cbSrcLength ||
-        padsh->pbPreparedDst != padsh->pbDst ||
-        padsh->cbPreparedDstLength < padsh->cbDstLength) {
-        return MMSYSERR_INVALPARAM;
-    }   
+    padsh->cbPreparedSrcLength < padsh->cbSrcLength ||
+    padsh->pbPreparedDst != padsh->pbDst ||
+    padsh->cbPreparedDstLength < padsh->cbDstLength) {
+    return MMSYSERR_INVALPARAM;
+    }
 
     padsh->fdwConvert = fdwUnprepare;
@@ -396 +396 @@
     ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_UNPREPARE, (DWORD)&was->drvInst, (DWORD)padsh);
     if (ret == MMSYSERR_NOERROR || ret == MMSYSERR_NOTSUPPORTED) {
-        ret = MMSYSERR_NOERROR;
-        padsh->fdwStatus &= ~(ACMSTREAMHEADER_STATUSF_DONE|ACMSTREAMHEADER_STATUSF_INQUEUE|ACMSTREAMHEADER_STATUSF_PREPARED);
-    }
-    TRACE("=> (%d)\n", ret);
-    return ret;
-}
+    ret = MMSYSERR_NOERROR;
+    padsh->fdwStatus &= ~(ACMSTREAMHEADER_STATUSF_DONE|ACMSTREAMHEADER_STATUSF_INQUEUE|ACMSTREAMHEADER_STATUSF_PREPARED);
+    }
+    TRACE("=> (%d)\n", ret);
+    return ret;
+}