marko10_000
/
wine-wine
forked from Mirrors/wine-wine
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

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

oldstable
Patrik Stridvall 1998-10-11 17:00:29 +00:00 committed by Alexandre Julliard
parent 686db71fd5
commit 29c08dd4df
16 changed files with 2937 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
dlls/msacm/.cvsignore 100644
View File

@ -0,0 +1 @@
Makefile

16
dlls/msacm/Makefile.in 100644
View File

@ -0,0 +1,16 @@
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:

411
dlls/msacm/msacm_main.c 100644
View File

@ -0,0 +1,411 @@
/*
* MSACM library
*
* Copyright 1998 Patrik Stridvall
*/
#include "windows.h"
#include "winerror.h"
#include "wintypes.h"
#include "debug.h"
#include "mmsystem.h"
#include "msacm.h"
/***********************************************************************
* ACMGETVERSION (MSACM.7)
*/
DWORD WINAPI acmGetVersion16()
{
FIXME(msacm, "(): stub\n");
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0; /* FIXME */
}
/***********************************************************************
* ACMMETRICS (MSACM.8)
*/
MMRESULT16 WINAPI acmMetrics16(
HACMOBJ16 hao, UINT16 uMetric, LPVOID pMetric)
{
FIXME(msacm, "(0x%04x, %d, %p): stub\n", hao, uMetric, pMetric);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return MMSYSERR_ERROR;
}
/***********************************************************************
* ACMDRIVERENUM (MSACM.10)
*/
MMRESULT16 WINAPI acmDriverEnum16(
ACMDRIVERENUMCB16 fnCallback, DWORD dwInstance, DWORD fdwEnum)
{
FIXME(msacm, "(%p, %ld, %ld): stub\n",
fnCallback, dwInstance, fdwEnum
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return MMSYSERR_ERROR;
}
/***********************************************************************
* ACMDRIVERDETAILS (MSACM.11)
*/
MMRESULT16 WINAPI acmDriverDetails16(
HACMDRIVERID16 hadid, LPACMDRIVERDETAILS16 padd, DWORD fdwDetails)
{
FIXME(msacm, "(0x%04x, %p, %ld): stub\n", hadid, padd, fdwDetails);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return MMSYSERR_ERROR;
}
/***********************************************************************
* ACMDRIVERADD (MSACM.12)
*/
MMRESULT16 WINAPI acmDriverAdd16(
LPHACMDRIVERID16 phadid, HINSTANCE16 hinstModule,
LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
{
FIXME(msacm, "(%p, 0x%04x, %ld, %ld, %ld): stub\n",
phadid, hinstModule, lParam, dwPriority, fdwAdd
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return MMSYSERR_ERROR;
}
/***********************************************************************
* ACMDRIVERREMOVE (MSACM.13)
*/
MMRESULT16 WINAPI acmDriverRemove16(
HACMDRIVERID16 hadid, DWORD fdwRemove)
{
FIXME(msacm, "(0x%04x, %ld): stub\n", hadid, fdwRemove);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return MMSYSERR_ERROR;
}
/***********************************************************************
* ACMDRIVEROPEN (MSACM.14)
*/
MMRESULT16 WINAPI acmDriverOpen16(
LPHACMDRIVER16 phad, HACMDRIVERID16 hadid, DWORD fdwOpen)
{
FIXME(msacm, "(%p, 0x%04x, %ld): stub\n", phad, hadid, fdwOpen);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return MMSYSERR_ERROR;
}
/***********************************************************************
* ACMDRIVERCLOSE (MSACM.15)
*/
MMRESULT16 WINAPI acmDriverClose16(
HACMDRIVER16 had, DWORD fdwClose)
{
FIXME(msacm, "(0x%04x, %ld): stub\n", had, fdwClose);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return MMSYSERR_ERROR;
}
/***********************************************************************
* ACMDRIVERMESSAGE (MSACM.16)
*/
LRESULT WINAPI acmDriverMessage16(
HACMDRIVER16 had, UINT16 uMsg, LPARAM lParam1, LPARAM lParam2)
{
FIXME(msacm, "(0x%04x, %d, %ld, %ld): stub\n",
had, uMsg, lParam1, lParam2
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
/***********************************************************************
* ACMDRIVERID (MSACM.17)
*/
MMRESULT16 WINAPI acmDriverID16(
HACMOBJ16 hao, LPHACMDRIVERID16 phadid, DWORD fdwDriverID)
{
FIXME(msacm, "(0x%04x, %p, %ld): stub\n", hao, phadid, fdwDriverID);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return MMSYSERR_ERROR;
}
/***********************************************************************
* ACMDRIVERPRIORITY (MSACM.18)
*/
MMRESULT16 WINAPI acmDriverPriority16(
HACMDRIVERID16 hadid, DWORD dwPriority, DWORD fdwPriority)
{
FIXME(msacm, "(0x%04x, %ld, %ld): stub\n",
hadid, dwPriority, fdwPriority
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return MMSYSERR_ERROR;
}
/***********************************************************************
* ACMFORMATTAGDETAILS (MSACM.30)
*/
MMRESULT16 WINAPI acmFormatTagDetails16(
HACMDRIVER16 had, LPACMFORMATTAGDETAILS16 paftd, DWORD fdwDetails)
{
FIXME(msacm, "(0x%04x, %p, %ld): stub\n", had, paftd, fdwDetails);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return MMSYSERR_ERROR;
}
/***********************************************************************
* ACMFORMATTAGENUM (MSACM.31)
*/
MMRESULT16 WINAPI acmFormatTagEnum16(
HACMDRIVER16 had, LPACMFORMATTAGDETAILS16 paftd,
ACMFORMATTAGENUMCB16 fnCallback, DWORD dwInstance, DWORD fdwEnum)
{
FIXME(msacm, "(0x%04x, %p, %p, %ld, %ld): stub\n",
had, paftd, fnCallback, dwInstance, fdwEnum
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return MMSYSERR_ERROR;
}
/***********************************************************************
* ACMFORMATCHOOSE (MSACM.40)
*/
MMRESULT16 WINAPI acmFormatChoose16(
LPACMFORMATCHOOSE16 pafmtc)
{
FIXME(msacm, "(%p): stub\n", pafmtc);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return MMSYSERR_ERROR;
}
/***********************************************************************
* ACMFORMATDETAILS (MSACM.41)
*/
MMRESULT16 WINAPI acmFormatDetails16(
HACMDRIVER16 had, LPACMFORMATDETAILS16 pafd, DWORD fdwDetails)
{
FIXME(msacm, "(0x%04x, %p, %ld): stub\n", had, pafd, fdwDetails);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return MMSYSERR_ERROR;
}
/***********************************************************************
* ACMFORMATENUM (MSACM.42)
*/
MMRESULT16 WINAPI acmFormatEnum16(
HACMDRIVER16 had, LPACMFORMATDETAILS16 pafd,
ACMFORMATENUMCB16 fnCallback, DWORD dwInstance, DWORD fdwEnum)
{
FIXME(msacm, "(0x%04x, %p, %p, %ld, %ld): stub\n",
had, pafd, fnCallback, dwInstance, fdwEnum
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return MMSYSERR_ERROR;
}
/***********************************************************************
* ACMFORMATSUGGEST (MSACM.45)
*/
MMRESULT16 WINAPI acmFormatSuggest16(
HACMDRIVER16 had, LPWAVEFORMATEX16 pwfxSrc,
LPWAVEFORMATEX16 pwfxDst, DWORD cbwfxDst, DWORD fdwSuggest)
{
FIXME(msacm, "(0x%04x, %p, %p, %ld, %ld): stub\n",
had, pwfxSrc, pwfxDst, cbwfxDst, fdwSuggest
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return MMSYSERR_ERROR;
}
/***********************************************************************
* ACMFILTERTAGDETAILS (MSACM.50)
*/
MMRESULT16 WINAPI acmFilterTagDetails16(
HACMDRIVER16 had, LPACMFILTERTAGDETAILS16 paftd, DWORD fdwDetails)
{
FIXME(msacm, "(0x%04x, %p, %ld): stub\n", had, paftd, fdwDetails);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return MMSYSERR_ERROR;
}
/***********************************************************************
* ACMFILTERTAGENUM (MSACM.51)
*/
MMRESULT16 WINAPI acmFilterTagEnum16(
HACMDRIVER16 had, LPACMFILTERTAGDETAILS16 paftd,
ACMFILTERTAGENUMCB16 fnCallback, DWORD dwInstance, DWORD fdwEnum)
{
FIXME(msacm, "(0x%04x, %p, %p, %ld, %ld): stub\n",
had, paftd, fnCallback, dwInstance, fdwEnum
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return MMSYSERR_ERROR;
}
/***********************************************************************
* ACMFILTERCHOOSE (MSACM.60)
*/
MMRESULT16 WINAPI acmFilterChoose16(
LPACMFILTERCHOOSE16 pafltrc)
{
FIXME(msacm, "(%p): stub\n", pafltrc);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return MMSYSERR_ERROR;
}
/***********************************************************************
* ACMFILTERDETAILS (MSACM.61)
*/
MMRESULT16 WINAPI acmFilterDetails16(
HACMDRIVER16 had, LPACMFILTERDETAILS16 pafd, DWORD fdwDetails)
{
FIXME(msacm, "(0x%04x, %p, %ld): stub\n", had, pafd, fdwDetails);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return MMSYSERR_ERROR;
}
/***********************************************************************
* ACMFILTERENUM (MSACM.62)
*/
MMRESULT16 WINAPI acmFilterEnum16(
HACMDRIVER16 had, LPACMFILTERDETAILS16 pafd,
ACMFILTERENUMCB16 fnCallback, DWORD dwInstance, DWORD fdwEnum)
{
FIXME(msacm, "(0x%04x, %p, %p, %ld, %ld): stub\n",
had, pafd, fnCallback, dwInstance, fdwEnum
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return MMSYSERR_ERROR;
}
/***********************************************************************
* ACMSTREAMOPEN (MSACM.70)
*/
MMRESULT16 WINAPI acmStreamOpen16(
LPHACMSTREAM16 phas, HACMDRIVER16 had,
LPWAVEFORMATEX16 pwfxSrc, LPWAVEFORMATEX16 pwfxDst,
LPWAVEFILTER16 pwfltr, DWORD dwCallback,
DWORD dwInstance, DWORD fdwOpen)
{
FIXME(msacm, "(%p, 0x%04x, %p, %p, %p, %ld, %ld, %ld): stub\n",
phas, had, pwfxSrc, pwfxDst, pwfltr,
dwCallback, dwInstance, fdwOpen
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return MMSYSERR_ERROR;
}
/***********************************************************************
* ACMSTREAMCLOSE (MSACM.71)
*/
MMRESULT16 WINAPI acmStreamClose16(
HACMSTREAM16 has, DWORD fdwClose)
{
FIXME(msacm, "(0x%04x, %ld): stub\n", has, fdwClose);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return MMSYSERR_ERROR;
}
/***********************************************************************
* ACMSTREAMSIZE (MSACM.72)
*/
MMRESULT16 WINAPI acmStreamSize16(
HACMSTREAM16 has, DWORD cbInput,
LPDWORD pdwOutputBytes, DWORD fdwSize)
{
FIXME(msacm, "(0x%04x, %ld, %p, %ld): stub\n",
has, cbInput, pdwOutputBytes, fdwSize
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return MMSYSERR_ERROR;
}
/***********************************************************************
* ACMSTREAMCONVERT (MSACM.75)
*/
MMRESULT16 WINAPI acmStreamConvert16(
HACMSTREAM16 has, LPACMSTREAMHEADER16 pash, DWORD fdwConvert)
{
FIXME(msacm, "(0x%04x, %p, %ld): stub\n", has, pash, fdwConvert);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return MMSYSERR_ERROR;
}
/***********************************************************************
* ACMSTREAMRESET (MSACM.76)
*/
MMRESULT16 WINAPI acmStreamReset16(
HACMSTREAM16 has, DWORD fdwReset)
{
FIXME(msacm, "(0x%04x, %ld): stub\n", has, fdwReset);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return MMSYSERR_ERROR;
}
/***********************************************************************
* ACMSTREAMPREPAREHEADER (MSACM.77)
*/
MMRESULT16 WINAPI acmStreamPrepareHeader16(
HACMSTREAM16 has, LPACMSTREAMHEADER16 pash, DWORD fdwPrepare)
{
FIXME(msacm, "(0x%04x, %p, %ld): stub\n", has, pash, fdwPrepare);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return MMSYSERR_ERROR;
}
/***********************************************************************
* ACMSTREAMUNPREPAREHEADER (MSACM.78)
*/
MMRESULT16 WINAPI acmStreamUnprepareHeader16(
HACMSTREAM16 has, LPACMSTREAMHEADER16 pash, DWORD fdwUnprepare)
{
FIXME(msacm, "(0x%04x, %p, %ld): stub\n",
has, pash, fdwUnprepare
);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return MMSYSERR_ERROR;
}
/***********************************************************************
* ACMAPPLICATIONEXIT (MSACM.150)
* FIXME
* No documentation found.
*/
/***********************************************************************
* ACMHUGEPAGELOCK (MSACM.175)
* FIXME
* No documentation found.
*/
/***********************************************************************
* ACMHUGEPAGEUNLOCK (MSACM.176)
* FIXME
* No documentation found.
*/
/***********************************************************************
* ACMOPENCONVERSION (MSACM.200)
* FIXME
* No documentation found.
*/
/***********************************************************************
* ACMCLOSECONVERSION (MSACM.201)
* FIXME
* No documentation found.
*/
/***********************************************************************
* ACMCONVERT (MSACM.202)
* FIXME
* No documentation found.
*/
/***********************************************************************
* ACMCHOOSEFORMAT (MSACM.203)
* FIXME
* No documentation found.
*/

1
dlls/msacm32/.cvsignore 100644
View File

@ -0,0 +1 @@
Makefile

22
dlls/msacm32/Makefile.in 100644
View File

@ -0,0 +1,22 @@
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:

77
dlls/msacm32/builtin.c 100644
View File

@ -0,0 +1,77 @@
/*
* 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;
}

349
dlls/msacm32/driver.c 100644
View File

@ -0,0 +1,349 @@
/*
* 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;
}

155
dlls/msacm32/filter.c 100644
View File

@ -0,0 +1,155 @@
/*
* 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;
}

168
dlls/msacm32/format.c 100644
View File

@ -0,0 +1,168 @@
/*
* 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;
}

196
dlls/msacm32/internal.c 100644
View File

@ -0,0 +1,196 @@
/*
* 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;
}

131
dlls/msacm32/msacm32_main.c 100644
View File

@ -0,0 +1,131 @@
/*
* 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;
}

114
dlls/msacm32/stream.c 100644
View File

@ -0,0 +1,114 @@
/*
* 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;
}

42
if1632/msacm.spec 100644
View File

@ -0,0 +1,42 @@
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

1003
include/msacm.h 100644
View File

File diff suppressed because it is too large Load Diff

203
include/msacmdrv.h 100644
View File

@ -0,0 +1,203 @@
/*
* 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 */

48
relay32/msacm32.spec 100644
View File

@ -0,0 +1,48 @@
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