Started the implementation of MSACM.DLL and MSACM32.DLL.

dlls/msacm/.cvsignore

+Makefile

dlls/msacm/Makefile.in

+DEFS      = @DLLFLAGS@ -D__WINE__
+TOPSRCDIR = @top_srcdir@
+TOPOBJDIR = ../..
+SRCDIR    = @srcdir@
+VPATH     = @srcdir@
+MODULE    = msacm
+
+C_SRCS = \
+	msacm_main.c
+
+all: $(MODULE).o
+
+@MAKE_RULES@
+
+### Dependencies:
+

dlls/msacm32/.cvsignore

+Makefile

dlls/msacm32/Makefile.in

+DEFS      = @DLLFLAGS@ -D__WINE__
+TOPSRCDIR = @top_srcdir@
+TOPOBJDIR = ../..
+SRCDIR    = @srcdir@
+VPATH     = @srcdir@
+MODULE    = msacm32
+
+C_SRCS = \
+	builtin.c \
+	driver.c \
+	filter.c \
+	format.c \
+	internal.c \
+	msacm32_main.c \
+	stream.c
+
+all: $(MODULE).o
+
+@MAKE_RULES@
+
+### Dependencies:
+

dlls/msacm32/builtin.c

+/*
+ *      MSACM32 library
+ *
+ *      Copyright 1998  Patrik Stridvall
+ */
+
+#include "windows.h"
+#include "winerror.h"
+#include "wintypes.h"
+#include "debug.h"
+#include "driver.h"
+#include "heap.h"
+#include "mmsystem.h"
+#include "msacm.h"
+#include "msacmdrv.h"
+
+/***********************************************************************
+ *           MSACM_BuiltinDrivers
+ */
+LONG MSACM_DummyDriverProc(
+   DWORD dwDriverId, HDRVR32 hdrvr, UINT32 msg,
+   LONG lParam1, LONG lParam2); 
+
+WINE_ACMBUILTINDRIVER32 MSACM_BuiltinDrivers32[] = {
+  { "MSACM.dummy", &MSACM_DummyDriverProc },
+  { NULL, NULL }
+};
+
+/***********************************************************************
+ *           MSACM_DummyDriverProc
+ */
+LONG MSACM_DummyDriverProc(
+   DWORD dwDriverId, HDRVR32 hdrvr, UINT32 msg,
+   LONG lParam1, LONG lParam2)
+{
+  switch(msg)
+    {
+    case DRV_LOAD:
+    case DRV_ENABLE:
+    case DRV_OPEN:
+    case DRV_CLOSE:
+    case DRV_DISABLE:
+    case DRV_FREE:
+    case DRV_CONFIGURE:
+    case DRV_QUERYCONFIGURE:
+    case DRV_INSTALL:
+    case DRV_REMOVE:
+    case DRV_EXITSESSION:
+    case DRV_EXITAPPLICATION:
+    case DRV_POWER:
+    case ACMDM_DRIVER_NOTIFY:
+    case ACMDM_DRIVER_DETAILS:
+    case ACMDM_HARDWARE_WAVE_CAPS_INPUT:
+    case ACMDM_HARDWARE_WAVE_CAPS_OUTPUT:
+    case ACMDM_FORMATTAG_DETAILS:
+    case ACMDM_FORMAT_DETAILS:
+    case ACMDM_FORMAT_SUGGEST:   
+    case ACMDM_FILTERTAG_DETAILS:
+    case ACMDM_FILTER_DETAILS:
+    case ACMDM_STREAM_OPEN:
+    case ACMDM_STREAM_CLOSE:
+    case ACMDM_STREAM_SIZE:
+    case ACMDM_STREAM_CONVERT:
+    case ACMDM_STREAM_RESET:
+    case ACMDM_STREAM_PREPARE:
+    case ACMDM_STREAM_UNPREPARE:
+    case ACMDM_STREAM_UPDATE:
+    default:
+      /* FIXME: DefDriverProc not implemented  */
+#if 0
+      DefDriverProc32(dwDriverId, hdrvr, msg, lParam1, lParam2);
+#endif
+      break;
+    }
+  return 0;
+} 
+

dlls/msacm32/driver.c

+/*
+ *      MSACM32 library
+ *
+ *      Copyright 1998  Patrik Stridvall
+ */
+
+#include "windows.h"
+#include "winerror.h"
+#include "wintypes.h"
+#include "debug.h"
+#include "driver.h"
+#include "heap.h"
+#include "mmsystem.h"
+#include "msacm.h"
+#include "msacmdrv.h"
+#include "winreg.h"
+
+/***********************************************************************
+ *           acmDriverAddA (MSACM32.2)
+ */
+MMRESULT32 WINAPI acmDriverAdd32A(
+  PHACMDRIVERID32 phadid, HINSTANCE32 hinstModule,
+  LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
+{
+  PWINE_ACMLOCALDRIVER32 pld;
+  if(!phadid)
+    return MMSYSERR_INVALPARAM;
+
+  /* Check if any unknown flags */
+  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;
+
+  pld = HeapAlloc(MSACM_hHeap32, 0, sizeof(WINE_ACMLOCALDRIVER32));
+  pld->pfnDriverProc = (DRIVERPROC32) 
+    GetProcAddress32(hinstModule, "DriverProc");
+  *phadid = (HACMDRIVERID32) MSACM_RegisterDriver32(NULL, NULL, pld);
+
+  /* FIXME: lParam, dwPriority and fdwAdd ignored */
+
+  return MMSYSERR_NOERROR;
+}
+
+/***********************************************************************
+ *           acmDriverAddW (MSACM32.3)
+ * FIXME
+ *   Not implemented
+ */
+MMRESULT32 WINAPI acmDriverAdd32W(
+  PHACMDRIVERID32 phadid, HINSTANCE32 hinstModule,
+  LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
+{
+  FIXME(msacm, "(%p, 0x%08x, %ld, %ld, %ld): stub\n",
+    phadid, hinstModule, lParam, dwPriority, fdwAdd
+  );
+  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+  return MMSYSERR_ERROR;
+}
+
+/***********************************************************************
+ *           acmDriverClose (MSACM32.4)
+ */
+MMRESULT32 WINAPI acmDriverClose32(
+  HACMDRIVER32 had, DWORD fdwClose)
+{
+  PWINE_ACMDRIVER32 p;
+
+  if(fdwClose)
+    return MMSYSERR_INVALFLAG;
+
+  p = MSACM_GetDriver32(had);
+  if(!p)
+    return MMSYSERR_INVALHANDLE;
+
+  p->obj.pACMDriverID->pACMDriver = NULL;
+
+  /* FIXME: CloseDriver32 not implemented */
+#if 0
+  if(p->hDrvr)
+    CloseDriver32(p->hDrvr, 0, 0);
+#endif
+
+  HeapFree(MSACM_hHeap32, 0, p);
+
+  return MMSYSERR_NOERROR;
+}
+
+/***********************************************************************
+ *           acmDriverDetailsA (MSACM32.5)
+ */
+MMRESULT32 WINAPI acmDriverDetails32A(
+  HACMDRIVERID32 hadid, PACMDRIVERDETAILS32A padd, DWORD fdwDetails)
+{
+  PWINE_ACMDRIVERID32 p;
+  MMRESULT32 mmr;
+  BOOL32 bOpenTemporary;
+
+  p = MSACM_GetDriverID32(hadid);
+  if(!p)
+    return MMSYSERR_INVALHANDLE;
+  
+  if(fdwDetails)
+    return MMSYSERR_INVALFLAG;
+
+  bOpenTemporary = !p->pACMDriver;
+  if(bOpenTemporary) {
+    bOpenTemporary = TRUE;
+    acmDriverOpen32((PHACMDRIVER32) &p->pACMDriver, hadid, 0);
+  }
+  
+  /* FIXME
+   *   How does the driver know if the ANSI or 
+   *   the UNICODE variant of PACMDRIVERDETAILS is used?
+   *   It might check cbStruct or does it only accept ANSI.
+   */
+  mmr = (MMRESULT32) acmDriverMessage32(
+    (HACMDRIVER32) p->pACMDriver, ACMDM_DRIVER_DETAILS, 
+    (LPARAM) padd,  0
+  );
+
+  if(bOpenTemporary) {
+    acmDriverClose32((HACMDRIVER32) p->pACMDriver, 0);
+    p->pACMDriver = NULL;
+  }
+
+  return mmr;
+}
+
+/***********************************************************************
+ *           acmDriverDetailsW (MSACM32.6)
+ * FIXME
+ *   Not implemented
+ */
+MMRESULT32 WINAPI acmDriverDetails32W(
+  HACMDRIVERID32 hadid, PACMDRIVERDETAILS32W padd, DWORD fdwDetails)
+{
+  FIXME(msacm, "(0x%08x, %p, %ld): stub\n", hadid, padd, fdwDetails);
+  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+  return MMSYSERR_ERROR;
+}
+
+/***********************************************************************
+ *           acmDriverEnum (MSACM32.7)
+ */
+MMRESULT32 WINAPI acmDriverEnum32(
+  ACMDRIVERENUMCB32 fnCallback, DWORD dwInstance, DWORD fdwEnum)
+{
+  PWINE_ACMDRIVERID32 p;
+
+  if(!fnCallback)
+    {
+      return MMSYSERR_INVALPARAM;
+    }
+
+  if(fdwEnum && ~(ACM_DRIVERENUMF_NOLOCAL|ACM_DRIVERENUMF_DISABLED))
+    {
+      return MMSYSERR_INVALFLAG;
+    }
+
+  p = MSACM_pFirstACMDriverID32;
+  while(p)
+    {
+      (*fnCallback)((HACMDRIVERID32) p, dwInstance, ACMDRIVERDETAILS_SUPPORTF_CODEC);
+      p = p->pNextACMDriverID;
+    }
+
+  return MMSYSERR_NOERROR;
+}
+
+/***********************************************************************
+ *           acmDriverID (MSACM32.8)
+ */
+MMRESULT32 WINAPI acmDriverID32(
+  HACMOBJ32 hao, PHACMDRIVERID32 phadid, DWORD fdwDriverID)
+{
+  PWINE_ACMOBJ32 pao;
+
+  pao = MSACM_GetObj32(hao);
+  if(!pao)
+    return MMSYSERR_INVALHANDLE;
+
+  if(!phadid)
+    return MMSYSERR_INVALPARAM;
+
+  if(fdwDriverID)
+    return MMSYSERR_INVALFLAG;
+
+  *phadid = (HACMDRIVERID32) pao->pACMDriverID;
+
+  return MMSYSERR_NOERROR;
+}
+
+/***********************************************************************
+ *           acmDriverMessage (MSACM32.9)
+ * FIXME
+ *   Not implemented
+ */
+LRESULT WINAPI acmDriverMessage32(
+  HACMDRIVER32 had, UINT32 uMsg, LPARAM lParam1, LPARAM lParam2)
+{
+  PWINE_ACMDRIVER32 pad = MSACM_GetDriver32(had);
+  if(!pad)
+    return MMSYSERR_INVALPARAM;
+
+  /* FIXME: Check if uMsg legal */
+
+  if(!SendDriverMessage32(pad->hDrvr, uMsg, lParam1, lParam2))
+    return MMSYSERR_NOTSUPPORTED;
+
+  return MMSYSERR_NOERROR;
+}
+
+
+/***********************************************************************
+ *           acmDriverOpen (MSACM32.10)
+ */
+MMRESULT32 WINAPI acmDriverOpen32(
+  PHACMDRIVER32 phad, HACMDRIVERID32 hadid, DWORD fdwOpen)
+{
+  PWINE_ACMDRIVERID32 padid;
+
+  if(!phad)
+    return MMSYSERR_INVALPARAM;
+
+  padid = MSACM_GetDriverID32(hadid); 
+  if(!padid)
+    return MMSYSERR_INVALHANDLE;
+
+  if(fdwOpen)
+    return MMSYSERR_INVALFLAG;
+
+  if(padid->pACMDriver)
+    {
+      /* FIXME: Is it allowed? */
+      ERR(msacm, "Can't open driver twice\n");
+      return MMSYSERR_ERROR;
+    }
+
+  padid->pACMDriver = HeapAlloc(
+    MSACM_hHeap32, 0, sizeof(WINE_ACMDRIVER32)
+  );
+  padid->pACMDriver->obj.pACMDriverID = padid;
+  
+  if(!padid->pACMLocalDriver)
+      padid->pACMDriver->hDrvr =
+        OpenDriver32A(padid->pszDriverAlias, "drivers32", 0);
+  else
+    {
+      padid->pACMDriver->hDrvr = MSACM_OpenDriverProc32(
+	padid->pACMLocalDriver->pfnDriverProc
+      );
+    }
+
+  if(!padid->pACMDriver->hDrvr)
+    return MMSYSERR_ERROR;
+ 
+  /* FIXME: Create a WINE_ACMDRIVER32 */
+  *phad = (HACMDRIVER32) NULL;
+
+  return MMSYSERR_ERROR;
+}
+
+/***********************************************************************
+ *           acmDriverPriority (MSACM32.11)
+ */
+MMRESULT32 WINAPI acmDriverPriority32(
+  HACMDRIVERID32 hadid, DWORD dwPriority, DWORD fdwPriority)
+{
+  PWINE_ACMDRIVERID32 padid;
+  CHAR szSubKey[17];
+  CHAR szBuffer[256];
+  LONG lBufferLength = sizeof(szBuffer);
+  LONG lError;
+  HKEY hPriorityKey;
+  DWORD dwPriorityCounter;
+
+  padid = MSACM_GetDriverID32(hadid);
+  if(!padid)
+    return MMSYSERR_INVALHANDLE;
+
+  /* Check for unknown flags */
+  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;
+
+  /* Check for incompatible flags */
+  if((fdwPriority & ACM_DRIVERPRIORITYF_BEGIN) &&
+    (fdwPriority & ACM_DRIVERPRIORITYF_END))
+    return MMSYSERR_INVALFLAG;
+
+  lError = RegOpenKey32A(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 = RegQueryValue32A(hPriorityKey, szSubKey, szBuffer, &lBufferLength);
+    if(lError != ERROR_SUCCESS)
+      break;
+
+    FIXME(msacm, "(0x%08x, %ld, %ld): stub (partial)\n", 
+      hadid, dwPriority, fdwPriority
+    );
+    break;
+  }
+
+  RegCloseKey(hPriorityKey);
+
+  return MMSYSERR_ERROR;
+}
+
+/***********************************************************************
+ *           acmDriverRemove (MSACM32.12)
+ */
+MMRESULT32 WINAPI acmDriverRemove32(
+  HACMDRIVERID32 hadid, DWORD fdwRemove)
+{
+  PWINE_ACMDRIVERID32 padid;
+
+  padid = MSACM_GetDriverID32(hadid);
+  if(!padid)
+    return MMSYSERR_INVALHANDLE;
+
+  if(fdwRemove)
+    return MMSYSERR_INVALFLAG;
+
+  MSACM_UnregisterDriver32(padid);
+
+  return MMSYSERR_NOERROR;
+}
+

dlls/msacm32/filter.c

+/*
+ *      MSACM32 library
+ *
+ *      Copyright 1998  Patrik Stridvall
+ */
+
+#include "windows.h"
+#include "winerror.h"
+#include "wintypes.h"
+#include "debug.h"
+#include "mmsystem.h"
+#include "msacm.h"
+#include "msacmdrv.h"
+
+/***********************************************************************
+ *           acmFilterChooseA (MSACM32.13)
+ */
+MMRESULT32 WINAPI acmFilterChoose32A(
+  PACMFILTERCHOOSE32A pafltrc)
+{
+  FIXME(msacm, "(%p): stub\n", pafltrc);
+  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+  return MMSYSERR_ERROR;
+}
+
+/***********************************************************************
+ *           acmFilterChooseW (MSACM32.14)
+ */
+MMRESULT32 WINAPI acmFilterChoose32W(
+  PACMFILTERCHOOSE32W pafltrc)
+{
+  FIXME(msacm, "(%p): stub\n", pafltrc);
+  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+  return MMSYSERR_ERROR;
+}
+
+/***********************************************************************
+ *           acmFilterDetailsA (MSACM32.15)
+ */
+MMRESULT32 WINAPI acmFilterDetails32A(
+  HACMDRIVER32 had, PACMFILTERDETAILS32A pafd, DWORD fdwDetails)
+{
+  if(fdwDetails & ~(ACM_FILTERDETAILSF_FILTER))
+    return MMSYSERR_INVALFLAG;
+
+  /* FIXME
+   *   How does the driver know if the ANSI or
+   *   the UNICODE variant of PACMFILTERDETAILS is used?
+   *   It might check cbStruct or does it only accept ANSI.
+   */
+  return (MMRESULT32) acmDriverMessage32(
+    had, ACMDM_FILTER_DETAILS,
+    (LPARAM) pafd,  (LPARAM) fdwDetails
+  );
+}
+
+/***********************************************************************
+ *           acmFilterDetailsW (MSACM32.16)
+ */
+MMRESULT32 WINAPI acmFilterDetails32W(
+  HACMDRIVER32 had, PACMFILTERDETAILS32W pafd, DWORD fdwDetails)
+{
+  FIXME(msacm, "(0x%08x, %p, %ld): stub\n", had, pafd, fdwDetails);
+  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+  return MMSYSERR_ERROR;
+}
+
+/***********************************************************************
+ *           acmFilterEnumA (MSACM32.17)
+ */
+MMRESULT32 WINAPI acmFilterEnum32A(
+  HACMDRIVER32 had, PACMFILTERDETAILS32A pafd, 
+  ACMFILTERENUMCB32A fnCallback, DWORD dwInstance, DWORD fdwEnum)
+{
+  FIXME(msacm, "(0x%08x, %p, %p, %ld, %ld): stub\n",
+    had, pafd, fnCallback, dwInstance, fdwEnum
+  );
+  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+  return MMSYSERR_ERROR;
+}
+
+/***********************************************************************
+ *           acmFilterEnumW (MSACM32.18)
+ */
+MMRESULT32 WINAPI acmFilterEnum32W(
+  HACMDRIVER32 had, PACMFILTERDETAILS32W pafd, 
+  ACMFILTERENUMCB32W fnCallback, DWORD dwInstance, DWORD fdwEnum)
+{
+  FIXME(msacm, "(0x%08x, %p, %p, %ld, %ld): stub\n",
+    had, pafd, fnCallback, dwInstance, fdwEnum
+  );
+  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+  return MMSYSERR_ERROR;
+}
+
+/***********************************************************************
+ *           acmFilterTagDetailsA (MSACM32.19)
+ */
+MMRESULT32 WINAPI acmFilterTagDetails32A(
+  HACMDRIVER32 had, PACMFILTERTAGDETAILS32A paftd, DWORD fdwDetails)
+{
+  if(fdwDetails & 
+     ~(ACM_FILTERTAGDETAILSF_FILTERTAG|
+       ACM_FILTERTAGDETAILSF_LARGESTSIZE))
+    return MMSYSERR_INVALFLAG;
+
+  /* FIXME
+   *   How does the driver know if the ANSI or
+   *   the UNICODE variant of PACMFILTERTAGDETAILS is used?
+   *   It might check cbStruct or does it only accept ANSI.
+   */
+  return (MMRESULT32) acmDriverMessage32(
+    had, ACMDM_FILTERTAG_DETAILS,
+    (LPARAM) paftd,  (LPARAM) fdwDetails
+  );
+}
+
+/***********************************************************************
+ *           acmFilterTagDetailsW (MSACM32.20)
+ */
+MMRESULT32 WINAPI acmFilterTagDetails32W(
+  HACMDRIVER32 had, PACMFILTERTAGDETAILS32W paftd, DWORD fdwDetails)
+{
+  FIXME(msacm, "(0x%08x, %p, %ld): stub\n", had, paftd, fdwDetails);
+  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+  return MMSYSERR_ERROR;
+}
+
+/***********************************************************************
+ *           acmFilterTagEnumA (MSACM32.21)
+ */
+MMRESULT32 WINAPI acmFilterTagEnum32A(
+  HACMDRIVER32 had, PACMFILTERTAGDETAILS32A  paftd,
+  ACMFILTERTAGENUMCB32A fnCallback, DWORD dwInstance, DWORD fdwEnum)
+{
+  FIXME(msacm, "(0x%08x, %p, %p, %ld, %ld): stub\n",
+    had, paftd, fnCallback, dwInstance, fdwEnum
+  );
+  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+  return MMSYSERR_ERROR;
+}
+
+/***********************************************************************
+ *           acmFilterTagEnumW (MSACM32.22)
+ */
+MMRESULT32 WINAPI acmFilterTagEnum32W(
+  HACMDRIVER32 had, PACMFILTERTAGDETAILS32W paftd,
+  ACMFILTERTAGENUMCB32W fnCallback, DWORD dwInstance, DWORD fdwEnum)
+{
+  FIXME(msacm, "(0x%08x, %p, %p, %ld, %ld): stub\n",
+    had, paftd, fnCallback, dwInstance, fdwEnum
+  );
+  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+  return MMSYSERR_ERROR;
+}

dlls/msacm32/format.c

+/*
+ *      MSACM32 library
+ *
+ *      Copyright 1998  Patrik Stridvall
+ */
+
+#include "windows.h"
+#include "winerror.h"
+#include "wintypes.h"
+#include "debug.h"
+#include "mmsystem.h"
+#include "msacm.h"
+#include "msacmdrv.h"
+
+/***********************************************************************
+ *           acmFormatChooseA (MSACM32.23)
+ */
+MMRESULT32 WINAPI acmFormatChoose32A(
+  PACMFORMATCHOOSE32A pafmtc)
+{
+  FIXME(msacm, "(%p): stub\n", pafmtc);
+  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+  return MMSYSERR_ERROR;
+}
+
+/***********************************************************************
+ *           acmFormatChooseW (MSACM32.24)
+ */
+MMRESULT32 WINAPI acmFormatChoose32W(
+  PACMFORMATCHOOSE32W pafmtc)
+{
+  FIXME(msacm, "(%p): stub\n", pafmtc);
+  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+  return MMSYSERR_ERROR;
+}
+
+/***********************************************************************
+ *           acmFormatDetailsA (MSACM32.25)
+ */
+MMRESULT32 WINAPI acmFormatDetails32A(
+  HACMDRIVER32 had, PACMFORMATDETAILS32A pafd, DWORD fdwDetails)
+{
+  if(fdwDetails & ~(ACM_FORMATDETAILSF_FORMAT))
+    return MMSYSERR_INVALFLAG;
+
+  /* FIXME
+   *   How does the driver know if the ANSI or
+   *   the UNICODE variant of PACMFORMATDETAILS is used?
+   *   It might check cbStruct or does it only accept ANSI.
+   */
+  return (MMRESULT32) acmDriverMessage32(
+    had, ACMDM_FORMAT_DETAILS,
+    (LPARAM) pafd,  (LPARAM) fdwDetails
+  );
+}
+
+/***********************************************************************
+ *           acmFormatDetailsW (MSACM32.26)
+ */
+MMRESULT32 WINAPI acmFormatDetails32W(
+  HACMDRIVER32 had, PACMFORMATDETAILS32W pafd, DWORD fdwDetails)
+{
+  FIXME(msacm, "(0x%08x, %p, %ld): stub\n", had, pafd, fdwDetails);
+  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+  return MMSYSERR_ERROR;
+}
+
+/***********************************************************************
+ *           acmFormatEnumA (MSACM32.27)
+ */
+MMRESULT32 WINAPI acmFormatEnum32A(
+  HACMDRIVER32 had, PACMFORMATDETAILS32A pafd,
+  ACMFORMATENUMCB32A fnCallback, DWORD dwInstance, DWORD fdwEnum)
+{
+  FIXME(msacm, "(0x%08x, %p, %p, %ld, %ld): stub\n",
+    had, pafd, fnCallback, dwInstance, fdwEnum
+  );
+  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+  return MMSYSERR_ERROR;
+}
+
+/***********************************************************************
+ *           acmFormatEnumW (MSACM32.28)
+ */
+MMRESULT32 WINAPI acmFormatEnum32W(
+  HACMDRIVER32 had, PACMFORMATDETAILS32W pafd,
+  ACMFORMATENUMCB32W fnCallback, DWORD dwInstance,  DWORD fdwEnum)
+{
+  FIXME(msacm, "(0x%08x, %p, %p, %ld, %ld): stub\n",
+    had, pafd, fnCallback, dwInstance, fdwEnum
+  );
+  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+  return MMSYSERR_ERROR;
+}
+
+/***********************************************************************
+ *           acmFormatSuggest (MSACM32.29)
+ */
+MMRESULT32 WINAPI acmFormatSuggest32(
+  HACMDRIVER32 had, PWAVEFORMATEX32 pwfxSrc, PWAVEFORMATEX32 pwfxDst,
+  DWORD cbwfxDst, DWORD fdwSuggest)
+{
+  FIXME(msacm, "(0x%08x, %p, %p, %ld, %ld): stub\n",
+    had, pwfxSrc, pwfxDst, cbwfxDst, fdwSuggest
+  );
+  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+  return MMSYSERR_ERROR;
+}
+
+/***********************************************************************
+ *           acmFormatTagDetailsA (MSACM32.30)
+ */
+MMRESULT32 WINAPI acmFormatTagDetails32A(
+  HACMDRIVER32 had, PACMFORMATTAGDETAILS32A paftd, DWORD fdwDetails)
+{
+  if(fdwDetails & 
+     ~(ACM_FORMATTAGDETAILSF_FORMATTAG|ACM_FORMATTAGDETAILSF_LARGESTSIZE))
+    return MMSYSERR_INVALFLAG;
+
+  /* FIXME
+   *   How does the driver know if the ANSI or
+   *   the UNICODE variant of PACMFORMATTAGDETAILS is used?
+   *   It might check cbStruct or does it only accept ANSI.
+   */
+  return (MMRESULT32) acmDriverMessage32(
+    had, ACMDM_FORMATTAG_DETAILS,
+    (LPARAM) paftd,  (LPARAM) fdwDetails
+  );
+}
+
+/***********************************************************************
+ *           acmFormatTagDetailsW (MSACM32.31)
+ */
+MMRESULT32 WINAPI acmFormatTagDetails32W(
+  HACMDRIVER32 had, PACMFORMATTAGDETAILS32W paftd, DWORD fdwDetails)
+{
+  FIXME(msacm, "(0x%08x, %p, %ld): stub\n", had, paftd, fdwDetails);
+  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+  return MMSYSERR_ERROR;
+}
+
+/***********************************************************************
+ *           acmFormatTagEnumA (MSACM32.32)
+ */
+MMRESULT32 WINAPI acmFormatTagEnum32A(
+  HACMDRIVER32 had, PACMFORMATTAGDETAILS32A paftd,
+  ACMFORMATTAGENUMCB32A fnCallback, DWORD dwInstance, DWORD fdwEnum)
+{
+  FIXME(msacm, "(0x%08x, %p, %p, %ld, %ld): stub\n",
+    had, paftd, fnCallback, dwInstance, fdwEnum
+  ); 
+  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+  return MMSYSERR_ERROR;
+}
+
+/***********************************************************************
+ *           acmFormatTagEnumW (MSACM32.33)
+ */
+MMRESULT32 WINAPI acmFormatTagEnum32W(
+  HACMDRIVER32 had, PACMFORMATTAGDETAILS32W paftd,
+  ACMFORMATTAGENUMCB32W fnCallback, DWORD dwInstance, DWORD fdwEnum)
+{
+  FIXME(msacm, "(0x%08x, %p, %p, %ld, %ld): stub\n",
+    had, paftd, fnCallback, dwInstance, fdwEnum
+  ); 
+  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+  return MMSYSERR_ERROR;
+}

dlls/msacm32/internal.c

+/*
+ *      MSACM32 library
+ *
+ *      Copyright 1998  Patrik Stridvall
+ */
+
+#include "windows.h"
+#include "winerror.h"
+#include "wintypes.h"
+#include "debug.h"
+#include "driver.h"
+#include "heap.h"
+#include "mmsystem.h"
+#include "msacm.h"
+#include "msacmdrv.h"
+
+/**********************************************************************/
+
+HANDLE32 MSACM_hHeap32 = (HANDLE32) NULL;
+PWINE_ACMDRIVERID32 MSACM_pFirstACMDriverID32 = NULL;
+PWINE_ACMDRIVERID32 MSACM_pLastACMDriverID32 = NULL;
+
+/***********************************************************************
+ *           MSACM_RegisterDriver32() 
+ */
+PWINE_ACMDRIVERID32 MSACM_RegisterDriver32(
+  LPSTR pszDriverAlias, LPSTR pszFileName,
+  PWINE_ACMLOCALDRIVER32 pLocalDriver)
+{
+  PWINE_ACMDRIVERID32 padid;
+  padid = (PWINE_ACMDRIVERID32) HeapAlloc(
+    MSACM_hHeap32, 0, sizeof(WINE_ACMDRIVERID32)
+  );
+  padid->pszDriverAlias = 
+    HEAP_strdupA(MSACM_hHeap32, 0, pszDriverAlias);
+  padid->pszFileName = 
+    HEAP_strdupA(MSACM_hHeap32, 0, pszFileName);
+  padid->pACMLocalDriver = pLocalDriver; 
+  padid->bEnabled = TRUE;
+  padid->pACMDriver = NULL;
+  padid->pNextACMDriverID = NULL;
+  padid->pPreviousACMDriverID = 
+    MSACM_pLastACMDriverID32;
+  MSACM_pLastACMDriverID32 = padid;
+  if(!MSACM_pFirstACMDriverID32)
+    MSACM_pFirstACMDriverID32 = padid;
+
+  return padid;
+}
+
+/***********************************************************************
+ *           MSACM_RegisterAllDrivers32() 
+ */
+void MSACM_RegisterAllDrivers32()
+{
+  PWINE_ACMBUILTINDRIVER32 pbd;
+  LPSTR pszBuffer;
+  DWORD dwBufferLength;
+
+  /* FIXME 
+   *  What if the user edits system.ini while the program is running?
+   *  Does Windows handle that?
+   */
+  if(!MSACM_pFirstACMDriverID32)
+    return;
+
+  /* FIXME: Do not work! How do I determine the section length? */
+  dwBufferLength = 
+    GetPrivateProfileSection32A("drivers32", NULL, 0, "system.ini");
+
+  pszBuffer = (LPSTR) HeapAlloc(
+    MSACM_hHeap32, 0, dwBufferLength
+  );
+  if(GetPrivateProfileSection32A(
+    "drivers32", pszBuffer, dwBufferLength, "system.ini"))
+    {
+      char *s = pszBuffer;
+      while(*s)
+	{
+	  if(!lstrncmpi32A("MSACM.", s, 6))
+	    {
+	      char *s2 = s;
+	      while(*s2 != '\0' && *s2 != '=') s2++;
+	      if(*s2)
+		{
+		  *s2++='\0';
+		  MSACM_RegisterDriver32(s, s2, NULL);
+		}
+	    }  
+	  s += lstrlen32A(s) + 1; /* Either next char or \0 */
+	}
+    }
+
+  /* FIXME
+   *   Check if any of the builtin driver was added
+   *   when the external drivers was. 
+   */
+
+  pbd = MSACM_BuiltinDrivers32;
+  while(pbd->pszDriverAlias)
+    {
+      PWINE_ACMLOCALDRIVER32 pld;
+      pld = HeapAlloc(MSACM_hHeap32, 0, sizeof(WINE_ACMLOCALDRIVER32));
+      pld->pfnDriverProc = pbd->pfnDriverProc;
+      MSACM_RegisterDriver32(pbd->pszDriverAlias, NULL, pld);
+      pbd++;
+    }
+   HeapFree(MSACM_hHeap32, 0, pszBuffer);
+}
+
+/***********************************************************************
+ *           MSACM_UnregisterDriver32()
+ */
+PWINE_ACMDRIVERID32 MSACM_UnregisterDriver32(PWINE_ACMDRIVERID32 p)
+{
+  PWINE_ACMDRIVERID32 pNextACMDriverID;
+
+  if(p->pACMDriver)
+    acmDriverClose32((HACMDRIVER32) p->pACMDriver, 0);
+
+  if(p->pszDriverAlias)
+    HeapFree(MSACM_hHeap32, 0, p->pszDriverAlias);
+  if(p->pszFileName)
+    HeapFree(MSACM_hHeap32, 0, p->pszFileName);
+  if(p->pACMLocalDriver)
+    HeapFree(MSACM_hHeap32, 0, p->pACMLocalDriver);
+
+  if(p->pPreviousACMDriverID)
+    p->pPreviousACMDriverID->pNextACMDriverID = p->pNextACMDriverID;
+  if(p->pNextACMDriverID)
+    p->pNextACMDriverID->pPreviousACMDriverID = p->pPreviousACMDriverID;
+
+  pNextACMDriverID = p->pNextACMDriverID;
+
+  HeapFree(MSACM_hHeap32, 0, p);
+
+  return pNextACMDriverID;
+}
+
+/***********************************************************************
+ *           MSACM_UnregisterAllDrivers32()
+ * FIXME
+ *   Where should this function be called?
+ */
+void MSACM_UnregisterAllDrivers32()
+{
+  PWINE_ACMDRIVERID32 p = MSACM_pFirstACMDriverID32;
+  while(p) p = MSACM_UnregisterDriver32(p);
+}
+
+/***********************************************************************
+ *           MSACM_GetDriverID32() 
+ */
+PWINE_ACMDRIVERID32 MSACM_GetDriverID32(HACMDRIVERID32 hDriverID)
+{
+  return (PWINE_ACMDRIVERID32) hDriverID;
+}
+
+/***********************************************************************
+ *           MSACM_GetDriver32()
+ */
+PWINE_ACMDRIVER32 MSACM_GetDriver32(HACMDRIVER32 hDriver)
+{
+  return (PWINE_ACMDRIVER32) hDriver;
+}
+
+/***********************************************************************
+ *           MSACM_GetObj32()
+ */
+PWINE_ACMOBJ32 MSACM_GetObj32(HACMOBJ32 hObj)
+{
+  return (PWINE_ACMOBJ32) hObj;
+}
+
+/***********************************************************************
+ *           MSACM_OpenDriverProc32
+ * FIXME
+ *  This function should be integrated with OpenDriver,
+ *  renamed and moved there.
+ */
+HDRVR32 MSACM_OpenDriverProc32(DRIVERPROC32 pfnDriverProc)
+{
+  LPDRIVERITEM32A pDrvr;
+
+  /* FIXME: This is a very bad solution */
+  pDrvr = (LPDRIVERITEM32A) HeapAlloc(MSACM_hHeap32, HEAP_ZERO_MEMORY, sizeof(DRIVERITEM32A));
+  pDrvr->count = 1;
+  pDrvr->driverproc = pfnDriverProc;
+  
+  /* FIXME: Send DRV_OPEN among others to DriverProc */
+
+  return (HDRVR32) pDrvr;
+}
+
+
+

dlls/msacm32/msacm32_main.c

+/*
+ *      MSACM32 library
+ *
+ *      Copyright 1998  Patrik Stridvall
+ */
+
+#include "windows.h"
+#include "winerror.h"
+#include "wintypes.h"
+#include "debug.h"
+#include "mmsystem.h"
+#include "msacm.h"
+#include "msacmdrv.h"
+#include "winversion.h"
+
+/**********************************************************************/
+
+static DWORD MSACM_dwProcessesAttached32 = 0;
+
+/***********************************************************************
+ *           MSACM_LibMain32 (MSACM32.init) 
+ */
+BOOL32 WINAPI MSACM32_LibMain(
+  HINSTANCE32 hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
+{
+  switch(fdwReason)
+    {
+    case DLL_PROCESS_ATTACH:
+      if(MSACM_dwProcessesAttached32 == 0)
+	{
+	  MSACM_hHeap32 = HeapCreate(0, 0x10000, 0);
+	  MSACM_RegisterAllDrivers32();
+	}
+      MSACM_dwProcessesAttached32++;
+      break;
+    case DLL_PROCESS_DETACH:
+      MSACM_dwProcessesAttached32--;
+      if(MSACM_dwProcessesAttached32 == 0)
+	{
+	  MSACM_UnregisterAllDrivers32();
+	  HeapDestroy(MSACM_hHeap32);
+	  MSACM_hHeap32 = (HANDLE32) NULL;
+	}
+      break;
+    case DLL_THREAD_ATTACH:
+      break;
+    case DLL_THREAD_DETACH:
+      break;
+    default:
+      break;
+    }
+  return TRUE;
+}
+
+/***********************************************************************
+ *           XRegThunkEntry (MSACM32.1)
+ * FIXME
+ *   No documentation found.
+ */
+
+/***********************************************************************
+ *           acmGetVersion32 (MSACM32.34)
+ */
+DWORD WINAPI acmGetVersion32()
+{
+  switch(VERSION_GetVersion()) 
+    {
+    default: 
+      FIXME(msacm, "%s not supported\n", VERSION_GetVersionName());
+    case WIN95:
+      return 0x04000000; /* 4.0.0 */
+    case NT40:
+      return 0x04000565; /* 4.0.1381 */
+    }
+}
+
+/***********************************************************************
+ *           acmMessage32 (MSACM32.35)
+ * FIXME
+ *   No documentation found.
+ */
+
+/***********************************************************************
+ *           acmMetrics (MSACM32.36)
+ */
+MMRESULT32 WINAPI acmMetrics32(
+  HACMOBJ32 hao, UINT32 uMetric, LPVOID  pMetric)
+{
+  PWINE_ACMOBJ32 pao = MSACM_GetObj32(hao);
+  BOOL32 bLocal = TRUE;
+
+  FIXME(msacm, "(0x%08x, %d, %p): stub\n", hao, uMetric, pMetric);
+
+  switch(uMetric)
+    {
+    case ACM_METRIC_COUNT_DRIVERS:
+      bLocal = FALSE;
+    case ACM_METRIC_COUNT_LOCAL_DRIVERS:
+      if(!pao)
+	return MMSYSERR_INVALHANDLE;  
+      return MMSYSERR_NOTSUPPORTED;
+    case ACM_METRIC_COUNT_CODECS:
+      bLocal = FALSE;
+    case ACM_METRIC_COUNT_LOCAL_CODECS:
+      return MMSYSERR_NOTSUPPORTED;
+    case ACM_METRIC_COUNT_CONVERTERS:
+      bLocal = FALSE;
+    case ACM_METRIC_COUNT_LOCAL_CONVERTERS:
+      return MMSYSERR_NOTSUPPORTED;
+    case ACM_METRIC_COUNT_FILTERS:
+      bLocal = FALSE;
+    case ACM_METRIC_COUNT_LOCAL_FILTERS:
+      return MMSYSERR_NOTSUPPORTED;
+    case ACM_METRIC_COUNT_DISABLED:
+      bLocal = FALSE;
+    case ACM_METRIC_COUNT_LOCAL_DISABLED:
+      if(!pao)
+	return MMSYSERR_INVALHANDLE;  
+      return MMSYSERR_NOTSUPPORTED;
+    case ACM_METRIC_COUNT_HARDWARE:
+    case ACM_METRIC_HARDWARE_WAVE_INPUT:
+    case ACM_METRIC_HARDWARE_WAVE_OUTPUT:
+    case ACM_METRIC_MAX_SIZE_FORMAT:
+    case ACM_METRIC_MAX_SIZE_FILTER:
+    case ACM_METRIC_DRIVER_SUPPORT:
+    case ACM_METRIC_DRIVER_PRIORITY:
+    default:
+      return MMSYSERR_NOTSUPPORTED;
+    }
+  return MMSYSERR_NOERROR;
+}

dlls/msacm32/stream.c

+/*
+ *      MSACM32 library
+ *
+ *      Copyright 1998  Patrik Stridvall
+ */
+
+#include "windows.h"
+#include "winerror.h"
+#include "wintypes.h"
+#include "debug.h"
+#include "mmsystem.h"
+#include "msacm.h"
+#include "msacmdrv.h"
+
+/***********************************************************************
+ *           acmStreamClose (MSACM32.37)
+ */
+MMRESULT32 WINAPI acmStreamClose32(
+  HACMSTREAM32 has, DWORD fdwClose)
+{
+  FIXME(msacm, "(0x%08x, %ld): stub\n", has, fdwClose);
+  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+  return MMSYSERR_ERROR;
+}
+
+/***********************************************************************
+ *           acmStreamConvert (MSACM32.38)
+ */
+MMRESULT32 WINAPI acmStreamConvert32(
+  HACMSTREAM32 has, PACMSTREAMHEADER32 pash, DWORD fdwConvert)
+{
+  FIXME(msacm, "(0x%08x, %p, %ld): stub\n", has, pash, fdwConvert);
+  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+  return MMSYSERR_ERROR;
+}
+
+/***********************************************************************
+ *           acmStreamMessage (MSACM32.39)
+ */
+MMRESULT32 WINAPI acmStreamMessage32(
+  HACMSTREAM32 has, UINT32 uMsg, LPARAM lParam1, LPARAM lParam2)
+{
+  FIXME(msacm, "(0x%08x, %u, %ld, %ld): stub\n",
+    has, uMsg, lParam1, lParam2
+  );
+  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+  return MMSYSERR_ERROR;
+}
+
+/***********************************************************************
+ *           acmStreamOpen (MSACM32.40)
+ */
+MMRESULT32 WINAPI acmStreamOpen32(
+  PHACMSTREAM32 phas, HACMDRIVER32 had, PWAVEFORMATEX32 pwfxSrc,
+  PWAVEFORMATEX32 pwfxDst, PWAVEFILTER32 pwfltr, DWORD dwCallback,
+  DWORD dwInstance, DWORD fdwOpen)
+{
+  FIXME(msacm, "(%p, 0x%08x, %p, %p, %p, %ld, %ld, %ld): stub\n",
+    phas, had, pwfxSrc, pwfxDst, pwfltr,
+    dwCallback, dwInstance, fdwOpen
+  );
+  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+  return MMSYSERR_ERROR;
+}
+
+
+/***********************************************************************
+ *           acmStreamPrepareHeader (MSACM32.41)
+ */
+MMRESULT32 WINAPI acmStreamPrepareHeader32(
+  HACMSTREAM32 has, PACMSTREAMHEADER32 pash, DWORD fdwPrepare)
+{
+  FIXME(msacm, "(0x%08x, %p, %ld): stub\n", has, pash, fdwPrepare);
+  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+  return MMSYSERR_ERROR;
+}
+
+/***********************************************************************
+ *           acmStreamReset (MSACM32.42)
+ */
+MMRESULT32 WINAPI acmStreamReset32(
+  HACMSTREAM32 has, DWORD fdwReset)
+{
+  FIXME(msacm, "(0x%08x, %ld): stub\n", has, fdwReset);
+  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+  return MMSYSERR_ERROR;
+}
+
+/***********************************************************************
+ *           acmStreamSize (MSACM32.43)
+ */
+MMRESULT32 WINAPI acmStreamSize32(
+  HACMSTREAM32 has, DWORD cbInput, 
+  LPDWORD pdwOutputBytes, DWORD fdwSize)
+{
+  FIXME(msacm, "(0x%08x, %ld, %p, %ld): stub\n",
+    has, cbInput, pdwOutputBytes, fdwSize
+  );
+  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+  return MMSYSERR_ERROR;
+}
+
+/***********************************************************************
+ *           acmStreamUnprepareHeader (MSACM32.44)
+ */
+MMRESULT32 WINAPI acmStreamUnprepareHeader32(
+  HACMSTREAM32 has, PACMSTREAMHEADER32 pash, DWORD fdwUnprepare)
+{
+  FIXME(msacm, "(0x%08x, %p, %ld): stub\n",
+    has, pash, fdwUnprepare
+  );
+  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+  return MMSYSERR_ERROR;
+}

if1632/msacm.spec

+name	msacm
+type	win16
+
+  1 stub     WEP
+  2 stub     DRIVERPROC
+  3 stub     ___EXPORTEDSTUB
+  7 pascal   acmGetVersion() acmGetVersion16
+  8 pascal16 acmMetrics(word word ptr) acmMetrics16
+ 10 pascal16 acmDriverEnum(ptr long long) acmDriverEnum16
+ 11 pascal16 acmDriverDetails(word ptr long) acmDriverDetails16
+ 12 pascal16 acmDriverAdd(ptr word long long long) acmDriverAdd16
+ 13 pascal16 acmDriverRemove(word long) acmDriverRemove16
+ 14 pascal16 acmDriverOpen(ptr word long) acmDriverOpen16
+ 15 pascal16 acmDriverClose(word long) acmDriverClose16
+ 16 pascal   acmDriverMessage(word word long long) acmDriverMessage16
+ 17 pascal16 acmDriverID(word ptr long) acmDriverID16
+ 18 pascal16 acmDriverPriority(word long long) acmDriverPriority16
+ 30 pascal16 acmFormatTagDetails(word ptr long) acmFormatTagDetails16
+ 31 pascal16 acmFormatTagEnum(word ptr ptr long long) acmFormatTagEnum16
+ 40 pascal16 acmFormatChoose(ptr) acmFormatChoose16
+ 41 pascal16 acmFormatDetails(word ptr long) acmFormatDetails16
+ 42 pascal16 acmFormatEnum(word ptr ptr long long) acmFormatEnum16
+ 45 pascal16 acmFormatSuggest(word ptr ptr long long) acmFormatSuggest16
+ 50 pascal16 acmFilterTagDetails(word ptr long) acmFilterTagDetails16
+ 51 pascal16 acmFilterTagEnum(word ptr ptr long long) acmFilterTagEnum16
+ 60 pascal16 acmFilterChoose(ptr) acmFilterChoose16
+ 61 pascal16 acmFilterDetails(word ptr long) acmFilterDetails16
+ 62 pascal16 acmFilterEnum(word ptr ptr long long) acmFilterEnum16
+ 70 pascal16 acmStreamOpen(ptr word ptr ptr ptr long long long) acmStreamOpen16
+ 71 pascal16 acmStreamClose(word long) acmStreamClose16
+ 72 pascal16 acmStreamSize(word long ptr long) acmStreamSize16
+ 75 pascal16 acmStreamConvert(word ptr long) acmStreamConvert16
+ 76 pascal16 acmStreamReset(word long) acmStreamReset16
+ 77 pascal16 acmStreamPrepareHeader(word ptr long) acmStreamPrepareHeader16
+ 78 pascal16 acmStreamUnprepareHeader(word ptr long) acmStreamUnprepareHeader16
+150 stub     ACMAPPLICATIONEXIT
+175 stub     ACMHUGEPAGELOCK
+176 stub     ACMHUGEPAGEUNLOCK
+200 stub     ACMOPENCONVERSION
+201 stub     ACMCLOSECONVERSION
+202 stub     ACMCONVERT
+203 stub     ACMCHOOSEFORMAT

include/msacmdrv.h

+/*
+ *      msacmdrv.h   -       Declarations for MSACM driver
+ */
+
+#ifndef __WINE_MSACMDRV_H
+#define __WINE_MSACMDRV_H
+
+#include "wintypes.h"
+#include "msacm.h"
+
+/***********************************************************************
+ * Types
+ */
+
+/***********************************************************************
+ * Defines/Enums
+ */
+
+#define MAKE_ACM_VERSION(mjr, mnr, bld) \
+  (((long)(mjr)<<24) | ((long)(mnr)<<16) | ((long)bld))
+
+#define ACMDRVOPENDESC_SECTIONNAME_CHARS    
+
+#define ACMDM_DRIVER_NOTIFY             (ACMDM_BASE + 1)
+#define ACMDM_DRIVER_DETAILS            (ACMDM_BASE + 10)
+
+#define ACMDM_HARDWARE_WAVE_CAPS_INPUT  (ACMDM_BASE + 20)
+#define ACMDM_HARDWARE_WAVE_CAPS_OUTPUT (ACMDM_BASE + 21)
+
+#define ACMDM_FORMATTAG_DETAILS         (ACMDM_BASE + 25)
+#define ACMDM_FORMAT_DETAILS            (ACMDM_BASE + 26)
+#define ACMDM_FORMAT_SUGGEST            (ACMDM_BASE + 27)
+
+#define ACMDM_FILTERTAG_DETAILS         (ACMDM_BASE + 50)
+#define ACMDM_FILTER_DETAILS            (ACMDM_BASE + 51)
+
+#define ACMDM_STREAM_OPEN               (ACMDM_BASE + 76)
+#define ACMDM_STREAM_CLOSE              (ACMDM_BASE + 77)
+#define ACMDM_STREAM_SIZE               (ACMDM_BASE + 78)
+#define ACMDM_STREAM_CONVERT            (ACMDM_BASE + 79)
+#define ACMDM_STREAM_RESET              (ACMDM_BASE + 80)
+#define ACMDM_STREAM_PREPARE            (ACMDM_BASE + 81)
+#define ACMDM_STREAM_UNPREPARE          (ACMDM_BASE + 82)
+#define ACMDM_STREAM_UPDATE             (ACMDM_BASE + 83)
+
+/***********************************************************************
+ * Structures
+ */
+
+typedef struct _ACMDRVOPENDESC32A
+{
+  DWORD  cbStruct;
+  FOURCC fccType;
+  FOURCC fccComp;
+  DWORD  dwVersion;
+  DWORD  dwFlags;
+  DWORD  dwError;
+  LPCSTR pszSectionName;
+  LPCSTR pszAliasName;
+  DWORD  dnDevNode;
+} ACMDRVOPENDESC32A, *PACMDRVOPENDESC32A;
+
+typedef struct _ACMDRVOPENDESC32W
+{
+  DWORD   cbStruct;
+  FOURCC  fccType;
+  FOURCC  fccComp;
+  DWORD   dwVersion;
+  DWORD   dwFlags;
+  DWORD   dwError;
+  LPCWSTR pszSectionName;
+  LPCWSTR pszAliasName;
+  DWORD   dnDevNode;
+} ACMDRVOPENDESC32W, *PACMDRVOPENDESC32W;
+
+typedef struct _ACMDRVOPENDESC16
+{
+  DWORD  cbStruct;
+  FOURCC fccType;
+  FOURCC fccComp;
+  DWORD  dwVersion;
+  DWORD  dwFlags;
+  DWORD  dwError;
+  LPCSTR pszSectionName;
+  LPCSTR pszAliasName;
+  DWORD  dnDevNode;
+} ACMDRVOPENDESC16, *NPACMDRVOPENDESC16, *LPACMDRVOPENDESC16;
+
+typedef struct _ACMDRVSTREAMINSTANCE16
+{
+  DWORD            cbStruct;
+  LPWAVEFORMATEX16 pwfxSrc;
+  LPWAVEFORMATEX16 pwfxDst;
+  LPWAVEFILTER16   pwfltr;
+  DWORD            dwCallback;
+  DWORD            dwInstance;
+  DWORD            fdwOpen;
+  DWORD            fdwDriver;
+  DWORD            dwDriver;
+  HACMSTREAM16     has;
+} ACMDRVSTREAMINSTANCE16, *NPACMDRVSTREAMINSTANCE16, *LPACMDRVSTREAMINSTANCE16;
+
+typedef struct _ACMDRVSTREAMINSTANCE32
+{
+  DWORD           cbStruct;
+  PWAVEFORMATEX32 pwfxSrc;
+  PWAVEFORMATEX32 pwfxDst;
+  PWAVEFILTER32   pwfltr;
+  DWORD           dwCallback;
+  DWORD           dwInstance;
+  DWORD           fdwOpen;
+  DWORD           fdwDriver;
+  DWORD           dwDriver;
+  HACMSTREAM32    has;
+} ACMDRVSTREAMINSTANCE32, *PACMDRVSTREAMINSTANCE32;
+
+
+typedef struct _ACMDRVSTREAMHEADER16 *LPACMDRVSTREAMHEADER16;
+typedef struct _ACMDRVSTREAMHEADER16 {
+  DWORD  cbStruct;
+  DWORD  fdwStatus;
+  DWORD  dwUser;
+  LPBYTE pbSrc;
+  DWORD  cbSrcLength;
+  DWORD  cbSrcLengthUsed;
+  DWORD  dwSrcUser;
+  LPBYTE pbDst;
+  DWORD  cbDstLength;
+  DWORD  cbDstLengthUsed;
+  DWORD  dwDstUser;
+
+  DWORD fdwConvert;
+  LPACMDRVSTREAMHEADER16 *padshNext;
+  DWORD fdwDriver;
+  DWORD dwDriver;
+
+  /* Internal fields for ACM */
+  DWORD  fdwPrepared;
+  DWORD  dwPrepared;
+  LPBYTE pbPreparedSrc;
+  DWORD  cbPreparedSrcLength;
+  LPBYTE pbPreparedDst;
+  DWORD  cbPreparedDstLength;
+} ACMDRVSTREAMHEADER16, *NPACMDRVSTREAMHEADER16;
+
+typedef struct _ACMDRVSTREAMHEADER32 *PACMDRVSTREAMHEADER32;
+typedef struct _ACMDRVSTREAMHEADER32 {
+  DWORD  cbStruct;
+  DWORD  fdwStatus;
+  DWORD  dwUser;
+  LPBYTE pbSrc;
+  DWORD  cbSrcLength;
+  DWORD  cbSrcLengthUsed;
+  DWORD  dwSrcUser;
+  LPBYTE pbDst;
+  DWORD  cbDstLength;
+  DWORD  cbDstLengthUsed;
+  DWORD  dwDstUser;
+
+  DWORD fdwConvert;
+  PACMDRVSTREAMHEADER32 *padshNext;
+  DWORD fdwDriver;
+  DWORD dwDriver;
+
+  /* Internal fields for ACM */
+  DWORD  fdwPrepared;
+  DWORD  dwPrepared;
+  LPBYTE pbPreparedSrc;
+  DWORD  cbPreparedSrcLength;
+  LPBYTE pbPreparedDst;
+  DWORD  cbPreparedDstLength;
+} ACMDRVSTREAMHEADER32;
+
+typedef struct _ACMDRVSTREAMSIZE
+{
+  DWORD cbStruct;
+  DWORD fdwSize;
+  DWORD cbSrcLength;
+  DWORD cbDstLength;
+} ACMDRVSTREAMSIZE16, *NPACMDRVSTREAMSIZE16, *LPACMDRVSTREAMSIZE16,
+  ACMDRVSTREAMSIZE32, *PACMDRVSTREAMSIZE;
+
+typedef struct _ACMDRVFORMATSUGGEST16
+{
+  DWORD            cbStruct;
+  DWORD            fdwSuggest;
+  LPWAVEFORMATEX16 pwfxSrc;
+  DWORD            cbwfxSrc;
+  LPWAVEFORMATEX16 pwfxDst;
+  DWORD            cbwfxDst;
+} ACMDRVFORMATSUGGEST16, *NPACMDRVFORMATSUGGEST, *LPACMDRVFORMATSUGGEST;
+
+typedef struct _ACMDRVFORMATSUGGEST32
+{
+  DWORD           cbStruct;
+  DWORD           fdwSuggest;
+  PWAVEFORMATEX32 pwfxSrc;
+  DWORD           cbwfxSrc;
+  PWAVEFORMATEX32 pwfxDst;
+  DWORD           cbwfxDst;
+} ACMDRVFORMATSUGGEST32, *PACMDRVFORMATSUGGEST32;
+
+#endif  /* __WINE_MSACMDRV_H */

relay32/msacm32.spec

+name msacm32
+type win32
+init MSACM32_LibMain
+
+ 1 stub XRegThunkEntry
+ 2 stdcall acmDriverAddA(ptr long long long long) acmDriverAdd32A
+ 3 stdcall acmDriverAddW(ptr long long long long) acmDriverAdd32W
+ 4 stdcall acmDriverClose(long long) acmDriverClose32
+ 5 stdcall acmDriverDetailsA(long ptr long) acmDriverDetails32A
+ 6 stdcall acmDriverDetailsW(long ptr long) acmDriverDetails32W
+ 7 stdcall acmDriverEnum(ptr long long) acmDriverEnum32
+ 8 stdcall acmDriverID(long ptr long) acmDriverID32
+ 9 stdcall acmDriverMessage(long long long long) acmDriverMessage32
+10 stdcall acmDriverOpen(ptr long long) acmDriverOpen32
+11 stdcall acmDriverPriority(long long long) acmDriverPriority32
+12 stdcall acmDriverRemove(long long) acmDriverRemove32
+13 stdcall acmFilterChooseA(ptr) acmFilterChoose32A
+14 stdcall acmFilterChooseW(ptr) acmFilterChoose32W
+15 stdcall acmFilterDetailsA(long ptr long) acmFilterDetails32A
+16 stdcall acmFilterDetailsW(long ptr long) acmFilterDetails32W
+17 stdcall acmFilterEnumA(long ptr ptr long long) acmFilterEnum32A
+18 stdcall acmFilterEnumW(long ptr ptr long long) acmFilterEnum32W
+19 stdcall acmFilterTagDetailsA(long ptr long) acmFilterTagDetails32A
+20 stdcall acmFilterTagDetailsW(long ptr long) acmFilterTagDetails32W
+21 stdcall acmFilterTagEnumA(long ptr ptr long long) acmFilterTagEnum32A
+22 stdcall acmFilterTagEnumW(long ptr ptr long long) acmFilterTagEnum32W
+23 stdcall acmFormatChooseA(ptr) acmFormatChoose32A
+24 stdcall acmFormatChooseW(ptr) acmFormatChoose32W
+25 stdcall acmFormatDetailsA(long ptr long) acmFormatDetails32A
+26 stdcall acmFormatDetailsW(long ptr long) acmFormatDetails32W
+27 stdcall acmFormatEnumA(long ptr ptr long long) acmFormatEnum32A
+28 stdcall acmFormatEnumW(long ptr ptr long long) acmFormatEnum32W
+29 stdcall acmFormatSuggest(long ptr ptr long long) acmFormatSuggest32
+30 stdcall acmFormatTagDetailsA(long ptr long) acmFormatTagDetails32A
+31 stdcall acmFormatTagDetailsW(long ptr long) acmFormatTagDetails32W
+32 stdcall acmFormatTagEnumA(long ptr ptr long long) acmFormatTagEnum32A
+33 stdcall acmFormatTagEnumW(long ptr ptr long long) acmFormatTagEnum32W
+34 stdcall acmGetVersion() acmGetVersion32
+35 stub acmMessage32
+36 stdcall acmMetrics(long long ptr) acmMetrics32
+37 stdcall acmStreamClose(long long) acmStreamClose32
+38 stdcall acmStreamConvert(long ptr long) acmStreamConvert32
+39 stdcall acmStreamMessage(long long long long) acmStreamMessage32
+40 stdcall acmStreamOpen(ptr long ptr ptr ptr long long long) acmStreamOpen32
+41 stdcall acmStreamPrepareHeader(long ptr long) acmStreamPrepareHeader32
+42 stdcall acmStreamReset(long long) acmStreamReset32
+43 stdcall acmStreamSize(long long ptr long) acmStreamSize32
+43 stdcall acmStreamUnprepareHeader(long ptr long) acmStreamUnprepareHeader32