Changeset 6712 for trunk/src/msacm32

Timestamp:

Sep 15, 2001, 11:47:44 AM (24 years ago)

Author:

sandervl

Message:

restored old version

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)
• wineacm.h (modified) (1 diff)

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;
+    }
+    
+    RegCloseKey(hPriorityKey);
+    
     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);
+        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;
+    }
     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;
-    }
-    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);
+        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;
+    }
     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;
-    }
-    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
  *
@@ -54 +53 @@
    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;
@@ -89 +88 @@
          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;
 
-    case ACM_METRIC_MAX_SIZE_FORMAT:
-    {
-        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)was;
-    TRACE("=> (%d)\n", ret);
-    return ret;
-    }
-errCleanUp:
-    if (phas)
-    *phas = (HACMSTREAM)0;
+        *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;
+}

trunk/src/msacm32/wineacm.h

@@ -3 +3 @@
 #define __WINE_WINEACM_H
 
-#ifndef __WIN32OS2__
+#ifdef __WIN32OS2__
+#include "windef.h"
+#else
 #include "wine/windef16.h"
 #include "wine/mmsystem16.h"