Large-scale renaming of all Win32 functions and types to use the
standard Windows names.
diff --git a/dlls/msacm32/builtin.c b/dlls/msacm32/builtin.c
index 3ba3339..0981ef7 100644
--- a/dlls/msacm32/builtin.c
+++ b/dlls/msacm32/builtin.c
@@ -18,10 +18,10 @@
* MSACM_BuiltinDrivers
*/
LONG WINAPI MSACM_DummyDriverProc(
- DWORD dwDriverId, HDRVR32 hdrvr, UINT32 msg,
+ DWORD dwDriverId, HDRVR hdrvr, UINT msg,
LONG lParam1, LONG lParam2);
-WINE_ACMBUILTINDRIVER32 MSACM_BuiltinDrivers32[] = {
+WINE_ACMBUILTINDRIVER MSACM_BuiltinDrivers[] = {
{ "MSACM.dummy", &MSACM_DummyDriverProc },
{ NULL, NULL }
};
@@ -30,7 +30,7 @@
* MSACM_DummyDriverProc
*/
LONG WINAPI MSACM_DummyDriverProc(
- DWORD dwDriverId, HDRVR32 hdrvr, UINT32 msg,
+ DWORD dwDriverId, HDRVR hdrvr, UINT msg,
LONG lParam1, LONG lParam2)
{
switch(msg)
@@ -68,7 +68,7 @@
default:
/* FIXME: DefDriverProc not implemented */
#if 0
- DefDriverProc32(dwDriverId, hdrvr, msg, lParam1, lParam2);
+ DefDriverProc(dwDriverId, hdrvr, msg, lParam1, lParam2);
#endif
break;
}
diff --git a/dlls/msacm32/driver.c b/dlls/msacm32/driver.c
index 2d7411a..9917314 100644
--- a/dlls/msacm32/driver.c
+++ b/dlls/msacm32/driver.c
@@ -19,11 +19,11 @@
/***********************************************************************
* acmDriverAddA (MSACM32.2)
*/
-MMRESULT32 WINAPI acmDriverAdd32A(
- PHACMDRIVERID32 phadid, HINSTANCE32 hinstModule,
+MMRESULT WINAPI acmDriverAddA(
+ PHACMDRIVERID phadid, HINSTANCE hinstModule,
LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
{
- PWINE_ACMLOCALDRIVER32 pld;
+ PWINE_ACMLOCALDRIVER pld;
if(!phadid)
return MMSYSERR_INVALPARAM;
@@ -38,10 +38,10 @@
(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);
+ pld = HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMLOCALDRIVER));
+ pld->pfnDriverProc = (DRIVERPROC)
+ GetProcAddress(hinstModule, "DriverProc");
+ *phadid = (HACMDRIVERID) MSACM_RegisterDriver(NULL, NULL, pld);
/* FIXME: lParam, dwPriority and fdwAdd ignored */
@@ -53,8 +53,8 @@
* FIXME
* Not implemented
*/
-MMRESULT32 WINAPI acmDriverAdd32W(
- PHACMDRIVERID32 phadid, HINSTANCE32 hinstModule,
+MMRESULT WINAPI acmDriverAddW(
+ PHACMDRIVERID phadid, HINSTANCE hinstModule,
LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
{
FIXME(msacm, "(%p, 0x%08x, %ld, %ld, %ld): stub\n",
@@ -67,15 +67,15 @@
/***********************************************************************
* acmDriverClose (MSACM32.4)
*/
-MMRESULT32 WINAPI acmDriverClose32(
- HACMDRIVER32 had, DWORD fdwClose)
+MMRESULT WINAPI acmDriverClose(
+ HACMDRIVER had, DWORD fdwClose)
{
- PWINE_ACMDRIVER32 p;
+ PWINE_ACMDRIVER p;
if(fdwClose)
return MMSYSERR_INVALFLAG;
- p = MSACM_GetDriver32(had);
+ p = MSACM_GetDriver(had);
if(!p)
return MMSYSERR_INVALHANDLE;
@@ -84,10 +84,10 @@
/* FIXME: CloseDriver32 not implemented */
#if 0
if(p->hDrvr)
- CloseDriver32(p->hDrvr, 0, 0);
+ CloseDriver(p->hDrvr, 0, 0);
#endif
- HeapFree(MSACM_hHeap32, 0, p);
+ HeapFree(MSACM_hHeap, 0, p);
return MMSYSERR_NOERROR;
}
@@ -95,14 +95,14 @@
/***********************************************************************
* acmDriverDetailsA (MSACM32.5)
*/
-MMRESULT32 WINAPI acmDriverDetails32A(
- HACMDRIVERID32 hadid, PACMDRIVERDETAILS32A padd, DWORD fdwDetails)
+MMRESULT WINAPI acmDriverDetailsA(
+ HACMDRIVERID hadid, PACMDRIVERDETAILSA padd, DWORD fdwDetails)
{
- PWINE_ACMDRIVERID32 p;
- MMRESULT32 mmr;
- BOOL32 bOpenTemporary;
+ PWINE_ACMDRIVERID p;
+ MMRESULT mmr;
+ BOOL bOpenTemporary;
- p = MSACM_GetDriverID32(hadid);
+ p = MSACM_GetDriverID(hadid);
if(!p)
return MMSYSERR_INVALHANDLE;
@@ -112,7 +112,7 @@
bOpenTemporary = !p->pACMDriver;
if(bOpenTemporary) {
bOpenTemporary = TRUE;
- acmDriverOpen32((PHACMDRIVER32) &p->pACMDriver, hadid, 0);
+ acmDriverOpen((PHACMDRIVER) &p->pACMDriver, hadid, 0);
}
/* FIXME
@@ -120,13 +120,13 @@
* 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,
+ mmr = (MMRESULT) acmDriverMessage(
+ (HACMDRIVER) p->pACMDriver, ACMDM_DRIVER_DETAILS,
(LPARAM) padd, 0
);
if(bOpenTemporary) {
- acmDriverClose32((HACMDRIVER32) p->pACMDriver, 0);
+ acmDriverClose((HACMDRIVER) p->pACMDriver, 0);
p->pACMDriver = NULL;
}
@@ -138,8 +138,8 @@
* FIXME
* Not implemented
*/
-MMRESULT32 WINAPI acmDriverDetails32W(
- HACMDRIVERID32 hadid, PACMDRIVERDETAILS32W padd, DWORD fdwDetails)
+MMRESULT WINAPI acmDriverDetailsW(
+ HACMDRIVERID hadid, PACMDRIVERDETAILSW padd, DWORD fdwDetails)
{
FIXME(msacm, "(0x%08x, %p, %ld): stub\n", hadid, padd, fdwDetails);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
@@ -149,10 +149,10 @@
/***********************************************************************
* acmDriverEnum (MSACM32.7)
*/
-MMRESULT32 WINAPI acmDriverEnum32(
- ACMDRIVERENUMCB32 fnCallback, DWORD dwInstance, DWORD fdwEnum)
+MMRESULT WINAPI acmDriverEnum(
+ ACMDRIVERENUMCB fnCallback, DWORD dwInstance, DWORD fdwEnum)
{
- PWINE_ACMDRIVERID32 p;
+ PWINE_ACMDRIVERID p;
if(!fnCallback)
{
@@ -164,10 +164,10 @@
return MMSYSERR_INVALFLAG;
}
- p = MSACM_pFirstACMDriverID32;
+ p = MSACM_pFirstACMDriverID;
while(p)
{
- (*fnCallback)((HACMDRIVERID32) p, dwInstance, ACMDRIVERDETAILS_SUPPORTF_CODEC);
+ (*fnCallback)((HACMDRIVERID) p, dwInstance, ACMDRIVERDETAILS_SUPPORTF_CODEC);
p = p->pNextACMDriverID;
}
@@ -177,12 +177,12 @@
/***********************************************************************
* acmDriverID (MSACM32.8)
*/
-MMRESULT32 WINAPI acmDriverID32(
- HACMOBJ32 hao, PHACMDRIVERID32 phadid, DWORD fdwDriverID)
+MMRESULT WINAPI acmDriverID(
+ HACMOBJ hao, PHACMDRIVERID phadid, DWORD fdwDriverID)
{
- PWINE_ACMOBJ32 pao;
+ PWINE_ACMOBJ pao;
- pao = MSACM_GetObj32(hao);
+ pao = MSACM_GetObj(hao);
if(!pao)
return MMSYSERR_INVALHANDLE;
@@ -192,7 +192,7 @@
if(fdwDriverID)
return MMSYSERR_INVALFLAG;
- *phadid = (HACMDRIVERID32) pao->pACMDriverID;
+ *phadid = (HACMDRIVERID) pao->pACMDriverID;
return MMSYSERR_NOERROR;
}
@@ -202,16 +202,16 @@
* FIXME
* Not implemented
*/
-LRESULT WINAPI acmDriverMessage32(
- HACMDRIVER32 had, UINT32 uMsg, LPARAM lParam1, LPARAM lParam2)
+LRESULT WINAPI acmDriverMessage(
+ HACMDRIVER had, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
{
- PWINE_ACMDRIVER32 pad = MSACM_GetDriver32(had);
+ PWINE_ACMDRIVER pad = MSACM_GetDriver(had);
if(!pad)
return MMSYSERR_INVALPARAM;
/* FIXME: Check if uMsg legal */
- if(!SendDriverMessage32(pad->hDrvr, uMsg, lParam1, lParam2))
+ if(!SendDriverMessage(pad->hDrvr, uMsg, lParam1, lParam2))
return MMSYSERR_NOTSUPPORTED;
return MMSYSERR_NOERROR;
@@ -221,15 +221,15 @@
/***********************************************************************
* acmDriverOpen (MSACM32.10)
*/
-MMRESULT32 WINAPI acmDriverOpen32(
- PHACMDRIVER32 phad, HACMDRIVERID32 hadid, DWORD fdwOpen)
+MMRESULT WINAPI acmDriverOpen(
+ PHACMDRIVER phad, HACMDRIVERID hadid, DWORD fdwOpen)
{
- PWINE_ACMDRIVERID32 padid;
+ PWINE_ACMDRIVERID padid;
if(!phad)
return MMSYSERR_INVALPARAM;
- padid = MSACM_GetDriverID32(hadid);
+ padid = MSACM_GetDriverID(hadid);
if(!padid)
return MMSYSERR_INVALHANDLE;
@@ -244,16 +244,16 @@
}
padid->pACMDriver = HeapAlloc(
- MSACM_hHeap32, 0, sizeof(WINE_ACMDRIVER32)
+ MSACM_hHeap, 0, sizeof(WINE_ACMDRIVER)
);
padid->pACMDriver->obj.pACMDriverID = padid;
if(!padid->pACMLocalDriver)
padid->pACMDriver->hDrvr =
- OpenDriver32A(padid->pszDriverAlias, "drivers32", 0);
+ OpenDriverA(padid->pszDriverAlias, "drivers32", 0);
else
{
- padid->pACMDriver->hDrvr = MSACM_OpenDriverProc32(
+ padid->pACMDriver->hDrvr = MSACM_OpenDriverProc(
padid->pACMLocalDriver->pfnDriverProc
);
}
@@ -262,7 +262,7 @@
return MMSYSERR_ERROR;
/* FIXME: Create a WINE_ACMDRIVER32 */
- *phad = (HACMDRIVER32) NULL;
+ *phad = (HACMDRIVER) NULL;
return MMSYSERR_ERROR;
}
@@ -270,10 +270,10 @@
/***********************************************************************
* acmDriverPriority (MSACM32.11)
*/
-MMRESULT32 WINAPI acmDriverPriority32(
- HACMDRIVERID32 hadid, DWORD dwPriority, DWORD fdwPriority)
+MMRESULT WINAPI acmDriverPriority(
+ HACMDRIVERID hadid, DWORD dwPriority, DWORD fdwPriority)
{
- PWINE_ACMDRIVERID32 padid;
+ PWINE_ACMDRIVERID padid;
CHAR szSubKey[17];
CHAR szBuffer[256];
LONG lBufferLength = sizeof(szBuffer);
@@ -281,7 +281,7 @@
HKEY hPriorityKey;
DWORD dwPriorityCounter;
- padid = MSACM_GetDriverID32(hadid);
+ padid = MSACM_GetDriverID(hadid);
if(!padid)
return MMSYSERR_INVALHANDLE;
@@ -301,7 +301,7 @@
(fdwPriority & ACM_DRIVERPRIORITYF_END))
return MMSYSERR_INVALFLAG;
- lError = RegOpenKey32A(HKEY_CURRENT_USER,
+ lError = RegOpenKeyA(HKEY_CURRENT_USER,
"Software\\Microsoft\\Multimedia\\"
"Audio Compression Manager\\Priority v4.00",
&hPriorityKey
@@ -312,8 +312,8 @@
for(dwPriorityCounter = 1; ; dwPriorityCounter++)
{
- wsnprintf32A(szSubKey, 17, "Priorty%ld", dwPriorityCounter);
- lError = RegQueryValue32A(hPriorityKey, szSubKey, szBuffer, &lBufferLength);
+ wsnprintfA(szSubKey, 17, "Priorty%ld", dwPriorityCounter);
+ lError = RegQueryValueA(hPriorityKey, szSubKey, szBuffer, &lBufferLength);
if(lError != ERROR_SUCCESS)
break;
@@ -331,19 +331,19 @@
/***********************************************************************
* acmDriverRemove (MSACM32.12)
*/
-MMRESULT32 WINAPI acmDriverRemove32(
- HACMDRIVERID32 hadid, DWORD fdwRemove)
+MMRESULT WINAPI acmDriverRemove(
+ HACMDRIVERID hadid, DWORD fdwRemove)
{
- PWINE_ACMDRIVERID32 padid;
+ PWINE_ACMDRIVERID padid;
- padid = MSACM_GetDriverID32(hadid);
+ padid = MSACM_GetDriverID(hadid);
if(!padid)
return MMSYSERR_INVALHANDLE;
if(fdwRemove)
return MMSYSERR_INVALFLAG;
- MSACM_UnregisterDriver32(padid);
+ MSACM_UnregisterDriver(padid);
return MMSYSERR_NOERROR;
}
diff --git a/dlls/msacm32/filter.c b/dlls/msacm32/filter.c
index 0c4f267..7420343 100644
--- a/dlls/msacm32/filter.c
+++ b/dlls/msacm32/filter.c
@@ -14,8 +14,8 @@
/***********************************************************************
* acmFilterChooseA (MSACM32.13)
*/
-MMRESULT32 WINAPI acmFilterChoose32A(
- PACMFILTERCHOOSE32A pafltrc)
+MMRESULT WINAPI acmFilterChooseA(
+ PACMFILTERCHOOSEA pafltrc)
{
FIXME(msacm, "(%p): stub\n", pafltrc);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
@@ -25,8 +25,8 @@
/***********************************************************************
* acmFilterChooseW (MSACM32.14)
*/
-MMRESULT32 WINAPI acmFilterChoose32W(
- PACMFILTERCHOOSE32W pafltrc)
+MMRESULT WINAPI acmFilterChooseW(
+ PACMFILTERCHOOSEW pafltrc)
{
FIXME(msacm, "(%p): stub\n", pafltrc);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
@@ -36,8 +36,8 @@
/***********************************************************************
* acmFilterDetailsA (MSACM32.15)
*/
-MMRESULT32 WINAPI acmFilterDetails32A(
- HACMDRIVER32 had, PACMFILTERDETAILS32A pafd, DWORD fdwDetails)
+MMRESULT WINAPI acmFilterDetailsA(
+ HACMDRIVER had, PACMFILTERDETAILSA pafd, DWORD fdwDetails)
{
if(fdwDetails & ~(ACM_FILTERDETAILSF_FILTER))
return MMSYSERR_INVALFLAG;
@@ -47,7 +47,7 @@
* the UNICODE variant of PACMFILTERDETAILS is used?
* It might check cbStruct or does it only accept ANSI.
*/
- return (MMRESULT32) acmDriverMessage32(
+ return (MMRESULT) acmDriverMessage(
had, ACMDM_FILTER_DETAILS,
(LPARAM) pafd, (LPARAM) fdwDetails
);
@@ -56,8 +56,8 @@
/***********************************************************************
* acmFilterDetailsW (MSACM32.16)
*/
-MMRESULT32 WINAPI acmFilterDetails32W(
- HACMDRIVER32 had, PACMFILTERDETAILS32W pafd, DWORD fdwDetails)
+MMRESULT WINAPI acmFilterDetailsW(
+ HACMDRIVER had, PACMFILTERDETAILSW pafd, DWORD fdwDetails)
{
FIXME(msacm, "(0x%08x, %p, %ld): stub\n", had, pafd, fdwDetails);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
@@ -67,9 +67,9 @@
/***********************************************************************
* acmFilterEnumA (MSACM32.17)
*/
-MMRESULT32 WINAPI acmFilterEnum32A(
- HACMDRIVER32 had, PACMFILTERDETAILS32A pafd,
- ACMFILTERENUMCB32A fnCallback, DWORD dwInstance, DWORD fdwEnum)
+MMRESULT WINAPI acmFilterEnumA(
+ HACMDRIVER had, PACMFILTERDETAILSA pafd,
+ ACMFILTERENUMCBA fnCallback, DWORD dwInstance, DWORD fdwEnum)
{
FIXME(msacm, "(0x%08x, %p, %p, %ld, %ld): stub\n",
had, pafd, fnCallback, dwInstance, fdwEnum
@@ -81,9 +81,9 @@
/***********************************************************************
* acmFilterEnumW (MSACM32.18)
*/
-MMRESULT32 WINAPI acmFilterEnum32W(
- HACMDRIVER32 had, PACMFILTERDETAILS32W pafd,
- ACMFILTERENUMCB32W fnCallback, DWORD dwInstance, DWORD fdwEnum)
+MMRESULT WINAPI acmFilterEnumW(
+ HACMDRIVER had, PACMFILTERDETAILSW pafd,
+ ACMFILTERENUMCBW fnCallback, DWORD dwInstance, DWORD fdwEnum)
{
FIXME(msacm, "(0x%08x, %p, %p, %ld, %ld): stub\n",
had, pafd, fnCallback, dwInstance, fdwEnum
@@ -95,8 +95,8 @@
/***********************************************************************
* acmFilterTagDetailsA (MSACM32.19)
*/
-MMRESULT32 WINAPI acmFilterTagDetails32A(
- HACMDRIVER32 had, PACMFILTERTAGDETAILS32A paftd, DWORD fdwDetails)
+MMRESULT WINAPI acmFilterTagDetailsA(
+ HACMDRIVER had, PACMFILTERTAGDETAILSA paftd, DWORD fdwDetails)
{
if(fdwDetails &
~(ACM_FILTERTAGDETAILSF_FILTERTAG|
@@ -108,7 +108,7 @@
* the UNICODE variant of PACMFILTERTAGDETAILS is used?
* It might check cbStruct or does it only accept ANSI.
*/
- return (MMRESULT32) acmDriverMessage32(
+ return (MMRESULT) acmDriverMessage(
had, ACMDM_FILTERTAG_DETAILS,
(LPARAM) paftd, (LPARAM) fdwDetails
);
@@ -117,8 +117,8 @@
/***********************************************************************
* acmFilterTagDetailsW (MSACM32.20)
*/
-MMRESULT32 WINAPI acmFilterTagDetails32W(
- HACMDRIVER32 had, PACMFILTERTAGDETAILS32W paftd, DWORD fdwDetails)
+MMRESULT WINAPI acmFilterTagDetailsW(
+ HACMDRIVER had, PACMFILTERTAGDETAILSW paftd, DWORD fdwDetails)
{
FIXME(msacm, "(0x%08x, %p, %ld): stub\n", had, paftd, fdwDetails);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
@@ -128,9 +128,9 @@
/***********************************************************************
* acmFilterTagEnumA (MSACM32.21)
*/
-MMRESULT32 WINAPI acmFilterTagEnum32A(
- HACMDRIVER32 had, PACMFILTERTAGDETAILS32A paftd,
- ACMFILTERTAGENUMCB32A fnCallback, DWORD dwInstance, DWORD fdwEnum)
+MMRESULT WINAPI acmFilterTagEnumA(
+ HACMDRIVER had, PACMFILTERTAGDETAILSA paftd,
+ ACMFILTERTAGENUMCBA fnCallback, DWORD dwInstance, DWORD fdwEnum)
{
FIXME(msacm, "(0x%08x, %p, %p, %ld, %ld): stub\n",
had, paftd, fnCallback, dwInstance, fdwEnum
@@ -142,9 +142,9 @@
/***********************************************************************
* acmFilterTagEnumW (MSACM32.22)
*/
-MMRESULT32 WINAPI acmFilterTagEnum32W(
- HACMDRIVER32 had, PACMFILTERTAGDETAILS32W paftd,
- ACMFILTERTAGENUMCB32W fnCallback, DWORD dwInstance, DWORD fdwEnum)
+MMRESULT WINAPI acmFilterTagEnumW(
+ HACMDRIVER had, PACMFILTERTAGDETAILSW paftd,
+ ACMFILTERTAGENUMCBW fnCallback, DWORD dwInstance, DWORD fdwEnum)
{
FIXME(msacm, "(0x%08x, %p, %p, %ld, %ld): stub\n",
had, paftd, fnCallback, dwInstance, fdwEnum
diff --git a/dlls/msacm32/format.c b/dlls/msacm32/format.c
index e780bd1..74e0a1a 100644
--- a/dlls/msacm32/format.c
+++ b/dlls/msacm32/format.c
@@ -15,8 +15,8 @@
/***********************************************************************
* acmFormatChooseA (MSACM32.23)
*/
-MMRESULT32 WINAPI acmFormatChoose32A(
- PACMFORMATCHOOSE32A pafmtc)
+MMRESULT WINAPI acmFormatChooseA(
+ PACMFORMATCHOOSEA pafmtc)
{
FIXME(msacm, "(%p): stub\n", pafmtc);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
@@ -26,8 +26,8 @@
/***********************************************************************
* acmFormatChooseW (MSACM32.24)
*/
-MMRESULT32 WINAPI acmFormatChoose32W(
- PACMFORMATCHOOSE32W pafmtc)
+MMRESULT WINAPI acmFormatChooseW(
+ PACMFORMATCHOOSEW pafmtc)
{
FIXME(msacm, "(%p): stub\n", pafmtc);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
@@ -37,8 +37,8 @@
/***********************************************************************
* acmFormatDetailsA (MSACM32.25)
*/
-MMRESULT32 WINAPI acmFormatDetails32A(
- HACMDRIVER32 had, PACMFORMATDETAILS32A pafd, DWORD fdwDetails)
+MMRESULT WINAPI acmFormatDetailsA(
+ HACMDRIVER had, PACMFORMATDETAILSA pafd, DWORD fdwDetails)
{
if(fdwDetails & ~(ACM_FORMATDETAILSF_FORMAT))
return MMSYSERR_INVALFLAG;
@@ -48,7 +48,7 @@
* the UNICODE variant of PACMFORMATDETAILS is used?
* It might check cbStruct or does it only accept ANSI.
*/
- return (MMRESULT32) acmDriverMessage32(
+ return (MMRESULT) acmDriverMessage(
had, ACMDM_FORMAT_DETAILS,
(LPARAM) pafd, (LPARAM) fdwDetails
);
@@ -57,8 +57,8 @@
/***********************************************************************
* acmFormatDetailsW (MSACM32.26)
*/
-MMRESULT32 WINAPI acmFormatDetails32W(
- HACMDRIVER32 had, PACMFORMATDETAILS32W pafd, DWORD fdwDetails)
+MMRESULT WINAPI acmFormatDetailsW(
+ HACMDRIVER had, PACMFORMATDETAILSW pafd, DWORD fdwDetails)
{
FIXME(msacm, "(0x%08x, %p, %ld): stub\n", had, pafd, fdwDetails);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
@@ -68,9 +68,9 @@
/***********************************************************************
* acmFormatEnumA (MSACM32.27)
*/
-MMRESULT32 WINAPI acmFormatEnum32A(
- HACMDRIVER32 had, PACMFORMATDETAILS32A pafd,
- ACMFORMATENUMCB32A fnCallback, DWORD dwInstance, DWORD fdwEnum)
+MMRESULT WINAPI acmFormatEnumA(
+ HACMDRIVER had, PACMFORMATDETAILSA pafd,
+ ACMFORMATENUMCBA fnCallback, DWORD dwInstance, DWORD fdwEnum)
{
FIXME(msacm, "(0x%08x, %p, %p, %ld, %ld): stub\n",
had, pafd, fnCallback, dwInstance, fdwEnum
@@ -82,9 +82,9 @@
/***********************************************************************
* acmFormatEnumW (MSACM32.28)
*/
-MMRESULT32 WINAPI acmFormatEnum32W(
- HACMDRIVER32 had, PACMFORMATDETAILS32W pafd,
- ACMFORMATENUMCB32W fnCallback, DWORD dwInstance, DWORD fdwEnum)
+MMRESULT WINAPI acmFormatEnumW(
+ HACMDRIVER had, PACMFORMATDETAILSW pafd,
+ ACMFORMATENUMCBW fnCallback, DWORD dwInstance, DWORD fdwEnum)
{
FIXME(msacm, "(0x%08x, %p, %p, %ld, %ld): stub\n",
had, pafd, fnCallback, dwInstance, fdwEnum
@@ -96,8 +96,8 @@
/***********************************************************************
* acmFormatSuggest (MSACM32.29)
*/
-MMRESULT32 WINAPI acmFormatSuggest32(
- HACMDRIVER32 had, PWAVEFORMATEX pwfxSrc, PWAVEFORMATEX pwfxDst,
+MMRESULT WINAPI acmFormatSuggest(
+ HACMDRIVER had, PWAVEFORMATEX pwfxSrc, PWAVEFORMATEX pwfxDst,
DWORD cbwfxDst, DWORD fdwSuggest)
{
FIXME(msacm, "(0x%08x, %p, %p, %ld, %ld): stub\n",
@@ -110,8 +110,8 @@
/***********************************************************************
* acmFormatTagDetailsA (MSACM32.30)
*/
-MMRESULT32 WINAPI acmFormatTagDetails32A(
- HACMDRIVER32 had, PACMFORMATTAGDETAILS32A paftd, DWORD fdwDetails)
+MMRESULT WINAPI acmFormatTagDetailsA(
+ HACMDRIVER had, PACMFORMATTAGDETAILSA paftd, DWORD fdwDetails)
{
if(fdwDetails &
~(ACM_FORMATTAGDETAILSF_FORMATTAG|ACM_FORMATTAGDETAILSF_LARGESTSIZE))
@@ -122,7 +122,7 @@
* the UNICODE variant of PACMFORMATTAGDETAILS is used?
* It might check cbStruct or does it only accept ANSI.
*/
- return (MMRESULT32) acmDriverMessage32(
+ return (MMRESULT) acmDriverMessage(
had, ACMDM_FORMATTAG_DETAILS,
(LPARAM) paftd, (LPARAM) fdwDetails
);
@@ -131,8 +131,8 @@
/***********************************************************************
* acmFormatTagDetailsW (MSACM32.31)
*/
-MMRESULT32 WINAPI acmFormatTagDetails32W(
- HACMDRIVER32 had, PACMFORMATTAGDETAILS32W paftd, DWORD fdwDetails)
+MMRESULT WINAPI acmFormatTagDetailsW(
+ HACMDRIVER had, PACMFORMATTAGDETAILSW paftd, DWORD fdwDetails)
{
FIXME(msacm, "(0x%08x, %p, %ld): stub\n", had, paftd, fdwDetails);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
@@ -142,9 +142,9 @@
/***********************************************************************
* acmFormatTagEnumA (MSACM32.32)
*/
-MMRESULT32 WINAPI acmFormatTagEnum32A(
- HACMDRIVER32 had, PACMFORMATTAGDETAILS32A paftd,
- ACMFORMATTAGENUMCB32A fnCallback, DWORD dwInstance, DWORD fdwEnum)
+MMRESULT WINAPI acmFormatTagEnumA(
+ HACMDRIVER had, PACMFORMATTAGDETAILSA paftd,
+ ACMFORMATTAGENUMCBA fnCallback, DWORD dwInstance, DWORD fdwEnum)
{
FIXME(msacm, "(0x%08x, %p, %p, %ld, %ld): stub\n",
had, paftd, fnCallback, dwInstance, fdwEnum
@@ -156,9 +156,9 @@
/***********************************************************************
* acmFormatTagEnumW (MSACM32.33)
*/
-MMRESULT32 WINAPI acmFormatTagEnum32W(
- HACMDRIVER32 had, PACMFORMATTAGDETAILS32W paftd,
- ACMFORMATTAGENUMCB32W fnCallback, DWORD dwInstance, DWORD fdwEnum)
+MMRESULT WINAPI acmFormatTagEnumW(
+ HACMDRIVER had, PACMFORMATTAGDETAILSW paftd,
+ ACMFORMATTAGENUMCBW fnCallback, DWORD dwInstance, DWORD fdwEnum)
{
FIXME(msacm, "(0x%08x, %p, %p, %ld, %ld): stub\n",
had, paftd, fnCallback, dwInstance, fdwEnum
diff --git a/dlls/msacm32/internal.c b/dlls/msacm32/internal.c
index e06d9e1..b1485e4 100644
--- a/dlls/msacm32/internal.c
+++ b/dlls/msacm32/internal.c
@@ -16,34 +16,34 @@
/**********************************************************************/
-HANDLE32 MSACM_hHeap32 = (HANDLE32) NULL;
-PWINE_ACMDRIVERID32 MSACM_pFirstACMDriverID32 = NULL;
-PWINE_ACMDRIVERID32 MSACM_pLastACMDriverID32 = NULL;
+HANDLE MSACM_hHeap = (HANDLE) NULL;
+PWINE_ACMDRIVERID MSACM_pFirstACMDriverID = NULL;
+PWINE_ACMDRIVERID MSACM_pLastACMDriverID = NULL;
/***********************************************************************
* MSACM_RegisterDriver32()
*/
-PWINE_ACMDRIVERID32 MSACM_RegisterDriver32(
+PWINE_ACMDRIVERID MSACM_RegisterDriver(
LPSTR pszDriverAlias, LPSTR pszFileName,
- PWINE_ACMLOCALDRIVER32 pLocalDriver)
+ PWINE_ACMLOCALDRIVER pLocalDriver)
{
- PWINE_ACMDRIVERID32 padid;
- padid = (PWINE_ACMDRIVERID32) HeapAlloc(
- MSACM_hHeap32, 0, sizeof(WINE_ACMDRIVERID32)
+ PWINE_ACMDRIVERID padid;
+ padid = (PWINE_ACMDRIVERID) HeapAlloc(
+ MSACM_hHeap, 0, sizeof(WINE_ACMDRIVERID)
);
padid->pszDriverAlias =
- HEAP_strdupA(MSACM_hHeap32, 0, pszDriverAlias);
+ HEAP_strdupA(MSACM_hHeap, 0, pszDriverAlias);
padid->pszFileName =
- HEAP_strdupA(MSACM_hHeap32, 0, pszFileName);
+ HEAP_strdupA(MSACM_hHeap, 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;
+ MSACM_pLastACMDriverID;
+ MSACM_pLastACMDriverID = padid;
+ if(!MSACM_pFirstACMDriverID)
+ MSACM_pFirstACMDriverID = padid;
return padid;
}
@@ -51,9 +51,9 @@
/***********************************************************************
* MSACM_RegisterAllDrivers32()
*/
-void MSACM_RegisterAllDrivers32()
+void MSACM_RegisterAllDrivers()
{
- PWINE_ACMBUILTINDRIVER32 pbd;
+ PWINE_ACMBUILTINDRIVER pbd;
LPSTR pszBuffer;
DWORD dwBufferLength;
@@ -61,33 +61,33 @@
* What if the user edits system.ini while the program is running?
* Does Windows handle that?
*/
- if(!MSACM_pFirstACMDriverID32)
+ if(!MSACM_pFirstACMDriverID)
return;
/* FIXME: Do not work! How do I determine the section length? */
dwBufferLength =
- GetPrivateProfileSection32A("drivers32", NULL, 0, "system.ini");
+ GetPrivateProfileSectionA("drivers32", NULL, 0, "system.ini");
pszBuffer = (LPSTR) HeapAlloc(
- MSACM_hHeap32, 0, dwBufferLength
+ MSACM_hHeap, 0, dwBufferLength
);
- if(GetPrivateProfileSection32A(
+ if(GetPrivateProfileSectionA(
"drivers32", pszBuffer, dwBufferLength, "system.ini"))
{
char *s = pszBuffer;
while(*s)
{
- if(!lstrncmpi32A("MSACM.", s, 6))
+ if(!lstrncmpiA("MSACM.", s, 6))
{
char *s2 = s;
while(*s2 != '\0' && *s2 != '=') s2++;
if(*s2)
{
*s2++='\0';
- MSACM_RegisterDriver32(s, s2, NULL);
+ MSACM_RegisterDriver(s, s2, NULL);
}
}
- s += lstrlen32A(s) + 1; /* Either next char or \0 */
+ s += lstrlenA(s) + 1; /* Either next char or \0 */
}
}
@@ -96,34 +96,34 @@
* when the external drivers was.
*/
- pbd = MSACM_BuiltinDrivers32;
+ pbd = MSACM_BuiltinDrivers;
while(pbd->pszDriverAlias)
{
- PWINE_ACMLOCALDRIVER32 pld;
- pld = HeapAlloc(MSACM_hHeap32, 0, sizeof(WINE_ACMLOCALDRIVER32));
+ PWINE_ACMLOCALDRIVER pld;
+ pld = HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMLOCALDRIVER));
pld->pfnDriverProc = pbd->pfnDriverProc;
- MSACM_RegisterDriver32(pbd->pszDriverAlias, NULL, pld);
+ MSACM_RegisterDriver(pbd->pszDriverAlias, NULL, pld);
pbd++;
}
- HeapFree(MSACM_hHeap32, 0, pszBuffer);
+ HeapFree(MSACM_hHeap, 0, pszBuffer);
}
/***********************************************************************
* MSACM_UnregisterDriver32()
*/
-PWINE_ACMDRIVERID32 MSACM_UnregisterDriver32(PWINE_ACMDRIVERID32 p)
+PWINE_ACMDRIVERID MSACM_UnregisterDriver(PWINE_ACMDRIVERID p)
{
- PWINE_ACMDRIVERID32 pNextACMDriverID;
+ PWINE_ACMDRIVERID pNextACMDriverID;
if(p->pACMDriver)
- acmDriverClose32((HACMDRIVER32) p->pACMDriver, 0);
+ acmDriverClose((HACMDRIVER) p->pACMDriver, 0);
if(p->pszDriverAlias)
- HeapFree(MSACM_hHeap32, 0, p->pszDriverAlias);
+ HeapFree(MSACM_hHeap, 0, p->pszDriverAlias);
if(p->pszFileName)
- HeapFree(MSACM_hHeap32, 0, p->pszFileName);
+ HeapFree(MSACM_hHeap, 0, p->pszFileName);
if(p->pACMLocalDriver)
- HeapFree(MSACM_hHeap32, 0, p->pACMLocalDriver);
+ HeapFree(MSACM_hHeap, 0, p->pACMLocalDriver);
if(p->pPreviousACMDriverID)
p->pPreviousACMDriverID->pNextACMDriverID = p->pNextACMDriverID;
@@ -132,7 +132,7 @@
pNextACMDriverID = p->pNextACMDriverID;
- HeapFree(MSACM_hHeap32, 0, p);
+ HeapFree(MSACM_hHeap, 0, p);
return pNextACMDriverID;
}
@@ -142,34 +142,34 @@
* FIXME
* Where should this function be called?
*/
-void MSACM_UnregisterAllDrivers32()
+void MSACM_UnregisterAllDrivers()
{
- PWINE_ACMDRIVERID32 p = MSACM_pFirstACMDriverID32;
- while(p) p = MSACM_UnregisterDriver32(p);
+ PWINE_ACMDRIVERID p = MSACM_pFirstACMDriverID;
+ while(p) p = MSACM_UnregisterDriver(p);
}
/***********************************************************************
* MSACM_GetDriverID32()
*/
-PWINE_ACMDRIVERID32 MSACM_GetDriverID32(HACMDRIVERID32 hDriverID)
+PWINE_ACMDRIVERID MSACM_GetDriverID(HACMDRIVERID hDriverID)
{
- return (PWINE_ACMDRIVERID32) hDriverID;
+ return (PWINE_ACMDRIVERID) hDriverID;
}
/***********************************************************************
* MSACM_GetDriver32()
*/
-PWINE_ACMDRIVER32 MSACM_GetDriver32(HACMDRIVER32 hDriver)
+PWINE_ACMDRIVER MSACM_GetDriver(HACMDRIVER hDriver)
{
- return (PWINE_ACMDRIVER32) hDriver;
+ return (PWINE_ACMDRIVER) hDriver;
}
/***********************************************************************
* MSACM_GetObj32()
*/
-PWINE_ACMOBJ32 MSACM_GetObj32(HACMOBJ32 hObj)
+PWINE_ACMOBJ MSACM_GetObj(HACMOBJ hObj)
{
- return (PWINE_ACMOBJ32) hObj;
+ return (PWINE_ACMOBJ) hObj;
}
/***********************************************************************
@@ -178,21 +178,21 @@
* This function should be integrated with OpenDriver,
* renamed and moved there.
*/
-HDRVR32 MSACM_OpenDriverProc32(DRIVERPROC32 pfnDriverProc)
+HDRVR MSACM_OpenDriverProc(DRIVERPROC pfnDriverProc)
{
#if 0
- LPDRIVERITEM32A pDrvr;
+ LPDRIVERITEMA pDrvr;
/* FIXME: This is a very bad solution */
- pDrvr = (LPDRIVERITEM32A) HeapAlloc(MSACM_hHeap32, HEAP_ZERO_MEMORY, sizeof(DRIVERITEM32A));
+ pDrvr = (LPDRIVERITEMA) HeapAlloc(MSACM_hHeap, HEAP_ZERO_MEMORY, sizeof(DRIVERITEMA));
pDrvr->count = 1;
pDrvr->driverproc = pfnDriverProc;
/* FIXME: Send DRV_OPEN among others to DriverProc */
- return (HDRVR32) pDrvr;
+ return (HDRVR) pDrvr;
#else
- return (HDRVR32) 0;
+ return (HDRVR) 0;
#endif
}
diff --git a/dlls/msacm32/msacm32_main.c b/dlls/msacm32/msacm32_main.c
index 655c226..7d9a818 100644
--- a/dlls/msacm32/msacm32_main.c
+++ b/dlls/msacm32/msacm32_main.c
@@ -14,31 +14,31 @@
/**********************************************************************/
-static DWORD MSACM_dwProcessesAttached32 = 0;
+static DWORD MSACM_dwProcessesAttached = 0;
/***********************************************************************
* MSACM_LibMain32 (MSACM32.init)
*/
-BOOL32 WINAPI MSACM32_LibMain(
- HINSTANCE32 hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
+BOOL WINAPI MSACM32_LibMain(
+ HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
switch(fdwReason)
{
case DLL_PROCESS_ATTACH:
- if(MSACM_dwProcessesAttached32 == 0)
+ if(MSACM_dwProcessesAttached == 0)
{
- MSACM_hHeap32 = HeapCreate(0, 0x10000, 0);
- MSACM_RegisterAllDrivers32();
+ MSACM_hHeap = HeapCreate(0, 0x10000, 0);
+ MSACM_RegisterAllDrivers();
}
- MSACM_dwProcessesAttached32++;
+ MSACM_dwProcessesAttached++;
break;
case DLL_PROCESS_DETACH:
- MSACM_dwProcessesAttached32--;
- if(MSACM_dwProcessesAttached32 == 0)
+ MSACM_dwProcessesAttached--;
+ if(MSACM_dwProcessesAttached == 0)
{
- MSACM_UnregisterAllDrivers32();
- HeapDestroy(MSACM_hHeap32);
- MSACM_hHeap32 = (HANDLE32) NULL;
+ MSACM_UnregisterAllDrivers();
+ HeapDestroy(MSACM_hHeap);
+ MSACM_hHeap = (HANDLE) NULL;
}
break;
case DLL_THREAD_ATTACH:
@@ -60,7 +60,7 @@
/***********************************************************************
* acmGetVersion32 (MSACM32.34)
*/
-DWORD WINAPI acmGetVersion32()
+DWORD WINAPI acmGetVersion()
{
switch(VERSION_GetVersion())
{
@@ -82,11 +82,11 @@
/***********************************************************************
* acmMetrics (MSACM32.36)
*/
-MMRESULT32 WINAPI acmMetrics32(
- HACMOBJ32 hao, UINT32 uMetric, LPVOID pMetric)
+MMRESULT WINAPI acmMetrics(
+ HACMOBJ hao, UINT uMetric, LPVOID pMetric)
{
- PWINE_ACMOBJ32 pao = MSACM_GetObj32(hao);
- BOOL32 bLocal = TRUE;
+ PWINE_ACMOBJ pao = MSACM_GetObj(hao);
+ BOOL bLocal = TRUE;
FIXME(msacm, "(0x%08x, %d, %p): stub\n", hao, uMetric, pMetric);
diff --git a/dlls/msacm32/stream.c b/dlls/msacm32/stream.c
index 21ca98b..760e3a8 100644
--- a/dlls/msacm32/stream.c
+++ b/dlls/msacm32/stream.c
@@ -15,8 +15,8 @@
/***********************************************************************
* acmStreamClose (MSACM32.37)
*/
-MMRESULT32 WINAPI acmStreamClose32(
- HACMSTREAM32 has, DWORD fdwClose)
+MMRESULT WINAPI acmStreamClose(
+ HACMSTREAM has, DWORD fdwClose)
{
FIXME(msacm, "(0x%08x, %ld): stub\n", has, fdwClose);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
@@ -26,8 +26,8 @@
/***********************************************************************
* acmStreamConvert (MSACM32.38)
*/
-MMRESULT32 WINAPI acmStreamConvert32(
- HACMSTREAM32 has, PACMSTREAMHEADER32 pash, DWORD fdwConvert)
+MMRESULT WINAPI acmStreamConvert(
+ HACMSTREAM has, PACMSTREAMHEADER pash, DWORD fdwConvert)
{
FIXME(msacm, "(0x%08x, %p, %ld): stub\n", has, pash, fdwConvert);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
@@ -37,8 +37,8 @@
/***********************************************************************
* acmStreamMessage (MSACM32.39)
*/
-MMRESULT32 WINAPI acmStreamMessage32(
- HACMSTREAM32 has, UINT32 uMsg, LPARAM lParam1, LPARAM lParam2)
+MMRESULT WINAPI acmStreamMessage(
+ HACMSTREAM has, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
{
FIXME(msacm, "(0x%08x, %u, %ld, %ld): stub\n",
has, uMsg, lParam1, lParam2
@@ -50,8 +50,8 @@
/***********************************************************************
* acmStreamOpen (MSACM32.40)
*/
-MMRESULT32 WINAPI acmStreamOpen32(
- PHACMSTREAM32 phas, HACMDRIVER32 had, PWAVEFORMATEX pwfxSrc,
+MMRESULT WINAPI acmStreamOpen(
+ PHACMSTREAM phas, HACMDRIVER had, PWAVEFORMATEX pwfxSrc,
PWAVEFORMATEX pwfxDst, PWAVEFILTER pwfltr, DWORD dwCallback,
DWORD dwInstance, DWORD fdwOpen)
{
@@ -67,8 +67,8 @@
/***********************************************************************
* acmStreamPrepareHeader (MSACM32.41)
*/
-MMRESULT32 WINAPI acmStreamPrepareHeader32(
- HACMSTREAM32 has, PACMSTREAMHEADER32 pash, DWORD fdwPrepare)
+MMRESULT WINAPI acmStreamPrepareHeader(
+ HACMSTREAM has, PACMSTREAMHEADER pash, DWORD fdwPrepare)
{
FIXME(msacm, "(0x%08x, %p, %ld): stub\n", has, pash, fdwPrepare);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
@@ -78,8 +78,8 @@
/***********************************************************************
* acmStreamReset (MSACM32.42)
*/
-MMRESULT32 WINAPI acmStreamReset32(
- HACMSTREAM32 has, DWORD fdwReset)
+MMRESULT WINAPI acmStreamReset(
+ HACMSTREAM has, DWORD fdwReset)
{
FIXME(msacm, "(0x%08x, %ld): stub\n", has, fdwReset);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
@@ -89,8 +89,8 @@
/***********************************************************************
* acmStreamSize (MSACM32.43)
*/
-MMRESULT32 WINAPI acmStreamSize32(
- HACMSTREAM32 has, DWORD cbInput,
+MMRESULT WINAPI acmStreamSize(
+ HACMSTREAM has, DWORD cbInput,
LPDWORD pdwOutputBytes, DWORD fdwSize)
{
FIXME(msacm, "(0x%08x, %ld, %p, %ld): stub\n",
@@ -103,8 +103,8 @@
/***********************************************************************
* acmStreamUnprepareHeader (MSACM32.44)
*/
-MMRESULT32 WINAPI acmStreamUnprepareHeader32(
- HACMSTREAM32 has, PACMSTREAMHEADER32 pash, DWORD fdwUnprepare)
+MMRESULT WINAPI acmStreamUnprepareHeader(
+ HACMSTREAM has, PACMSTREAMHEADER pash, DWORD fdwUnprepare)
{
FIXME(msacm, "(0x%08x, %p, %ld): stub\n",
has, pash, fdwUnprepare
