git.oblomov.eu Git - wine/blob - dlls/msacm/driver.c

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2
   3 /*
   4  *      MSACM32 library
   5  *
   6  *      Copyright 1998  Patrik Stridvall
   7  *                1999  Eric Pouech
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  */
  23
  24 #include "config.h"
  25 #include "wine/port.h"
  26
  27 #include <stdarg.h>
  28 #include <stdio.h>
  29
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "winerror.h"
  33 #include "wingdi.h"
  34 #include "winuser.h"
  35 #include "winnls.h"
  36 #include "winreg.h"
  37 #include "mmsystem.h"
  38 #include "mmreg.h"
  39 #include "msacm.h"
  40 #include "msacmdrv.h"
  41 #include "wineacm.h"
  42 #include "wine/debug.h"
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL(msacm);
  45
  46 /***********************************************************************
  47  *           acmDriverAddA (MSACM32.@)
  48  */
  49 MMRESULT WINAPI acmDriverAddA(PHACMDRIVERID phadid, HINSTANCE hinstModule,
  50                               LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
  51 {
  52     MMRESULT resultW;
  53     WCHAR * driverW = NULL;
  54     LPARAM lParamW = lParam;
  55
  56     TRACE("(%p, %p, %08lx, %08lx, %08lx)\n",
  57           phadid, hinstModule, lParam, dwPriority, fdwAdd);
  58
  59     if (!phadid) {
  60         WARN("invalid parameter\n");
  61         return MMSYSERR_INVALPARAM;
  62     }
  63
  64     /* Check if any unknown flags */
  65     if (fdwAdd &
  66         ~(ACM_DRIVERADDF_FUNCTION|ACM_DRIVERADDF_NOTIFYHWND|
  67           ACM_DRIVERADDF_GLOBAL)) {
  68         WARN("invalid flag\n");
  69         return MMSYSERR_INVALFLAG;
  70     }
  71
  72     /* Check if any incompatible flags */
  73     if ((fdwAdd & ACM_DRIVERADDF_FUNCTION) &&
  74         (fdwAdd & ACM_DRIVERADDF_NOTIFYHWND)) {
  75         WARN("invalid flag\n");
  76         return MMSYSERR_INVALFLAG;
  77     }
  78
  79     /* A->W translation of name */
  80     if ((fdwAdd & ACM_DRIVERADDF_TYPEMASK) == ACM_DRIVERADDF_NAME) {
  81         unsigned long len;
  82
  83         if (lParam == 0) return MMSYSERR_INVALPARAM;
  84         len = MultiByteToWideChar(CP_ACP, 0, (LPSTR)lParam, -1, NULL, 0);
  85         driverW = HeapAlloc(MSACM_hHeap, 0, len * sizeof(WCHAR));
  86         if (!driverW) return MMSYSERR_NOMEM;
  87         MultiByteToWideChar(CP_ACP, 0, (LPSTR)lParam, -1, driverW, len);
  88         lParamW = (LPARAM)driverW;
  89     }
  90
  91     resultW = acmDriverAddW(phadid, hinstModule, lParamW, dwPriority, fdwAdd);
  92     HeapFree(MSACM_hHeap, 0, driverW);
  93     return resultW;
  94 }
  95
  96 /***********************************************************************
  97  *           acmDriverAddW (MSACM32.@)
  98  *
  99  */
 100 MMRESULT WINAPI acmDriverAddW(PHACMDRIVERID phadid, HINSTANCE hinstModule,
 101                               LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
 102 {
 103     TRACE("(%p, %p, %08lx, %08lx, %08lx)\n",
 104           phadid, hinstModule, lParam, dwPriority, fdwAdd);
 105
 106     if (!phadid) {
 107         WARN("invalid parameter\n");
 108         return MMSYSERR_INVALPARAM;
 109     }
 110
 111     /* Check if any unknown flags */
 112     if (fdwAdd &
 113         ~(ACM_DRIVERADDF_FUNCTION|ACM_DRIVERADDF_NOTIFYHWND|
 114           ACM_DRIVERADDF_GLOBAL)) {
 115         WARN("invalid flag\n");
 116         return MMSYSERR_INVALFLAG;
 117     }
 118
 119     /* Check if any incompatible flags */
 120     if ((fdwAdd & ACM_DRIVERADDF_FUNCTION) &&
 121         (fdwAdd & ACM_DRIVERADDF_NOTIFYHWND)) {
 122         WARN("invalid flag\n");
 123         return MMSYSERR_INVALFLAG;
 124     }
 125
 126     switch (fdwAdd & ACM_DRIVERADDF_TYPEMASK) {
 127     case ACM_DRIVERADDF_NAME:
 128         /*
 129                 hInstModule     (unused)
 130                 lParam          name of value in HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Drivers32
 131                 dwPriority      (unused, set to 0)
 132          */
 133         *phadid = (HACMDRIVERID) MSACM_RegisterDriverFromRegistry((LPCWSTR)lParam);
 134         if (!*phadid) {
 135             ERR("Unable to register driver via ACM_DRIVERADDF_NAME\n");
 136             return MMSYSERR_INVALPARAM;
 137         }
 138         break;
 139     case ACM_DRIVERADDF_FUNCTION:
 140         /*
 141                 hInstModule     Handle of module which contains driver entry proc
 142                 lParam          Driver function address
 143                 dwPriority      (unused, set to 0)
 144          */
 145         fdwAdd &= ~ACM_DRIVERADDF_TYPEMASK;
 146
 147         *phadid = 0;
 148         FIXME("(%p, %p, %ld, %ld, %ld): ACM_DRIVERADDF_FUNCTION: stub\n", phadid, hinstModule, lParam, dwPriority, fdwAdd);
 149         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 150         return MMSYSERR_ERROR;
 151     case ACM_DRIVERADDF_NOTIFYHWND:
 152         /*
 153                 hInstModule     (unused)
 154                 lParam          Handle of notification window
 155                 dwPriority      Window message to send for notification broadcasts
 156          */
 157         *phadid = 0;
 158         FIXME("(%p, %p, %ld, %ld, %ld): ACM_DRIVERADDF_NOTIFYHWND: stub\n", phadid, hinstModule, lParam, dwPriority, fdwAdd);
 159         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 160         return MMSYSERR_ERROR;
 161     default:
 162         ERR("invalid flag value 0x%08lx for fdwAdd\n", fdwAdd & ACM_DRIVERADDF_TYPEMASK);
 163         return MMSYSERR_INVALFLAG;
 164     }
 165
 166     MSACM_BroadcastNotification();
 167     return MMSYSERR_NOERROR;
 168 }
 169
 170 /***********************************************************************
 171  *           acmDriverClose (MSACM32.@)
 172  */
 173 MMRESULT WINAPI acmDriverClose(HACMDRIVER had, DWORD fdwClose)
 174 {
 175     PWINE_ACMDRIVER     pad;
 176     PWINE_ACMDRIVERID   padid;
 177     PWINE_ACMDRIVER*    tpad;
 178
 179     TRACE("(%p, %08lx)\n", had, fdwClose);
 180
 181     if (fdwClose) {
 182         WARN("invalid flag\n");
 183         return MMSYSERR_INVALFLAG;
 184     }
 185
 186     pad = MSACM_GetDriver(had);
 187     if (!pad) {
 188         WARN("invalid handle\n");
 189         return MMSYSERR_INVALHANDLE;
 190     }
 191
 192     padid = pad->obj.pACMDriverID;
 193
 194     /* remove driver from list */
 195     for (tpad = &(padid->pACMDriverList); *tpad; tpad = &((*tpad)->pNextACMDriver)) {
 196         if (*tpad == pad) {
 197             *tpad = (*tpad)->pNextACMDriver;
 198             break;
 199         }
 200     }
 201
 202     /* close driver if it has been opened */
 203     if (pad->hDrvr && !padid->hInstModule)
 204         CloseDriver(pad->hDrvr, 0, 0);
 205
 206     HeapFree(MSACM_hHeap, 0, pad);
 207
 208     return MMSYSERR_NOERROR;
 209 }
 210
 211 /***********************************************************************
 212  *           acmDriverDetailsA (MSACM32.@)
 213  */
 214 MMRESULT WINAPI acmDriverDetailsA(HACMDRIVERID hadid, PACMDRIVERDETAILSA padd, DWORD fdwDetails)
 215 {
 216     MMRESULT mmr;
 217     ACMDRIVERDETAILSW   addw;
 218
 219     TRACE("(%p, %p, %08lx)\n", hadid, padd, fdwDetails);
 220
 221     if (!padd) {
 222         WARN("invalid parameter\n");
 223         return MMSYSERR_INVALPARAM;
 224     }
 225
 226     if (padd->cbStruct < 4) {
 227         WARN("invalid parameter\n");
 228         return MMSYSERR_INVALPARAM;
 229     }
 230
 231     addw.cbStruct = sizeof(addw);
 232     mmr = acmDriverDetailsW(hadid, &addw, fdwDetails);
 233     if (mmr == 0) {
 234         ACMDRIVERDETAILSA padda;
 235
 236         padda.fccType = addw.fccType;
 237         padda.fccComp = addw.fccComp;
 238         padda.wMid = addw.wMid;
 239         padda.wPid = addw.wPid;
 240         padda.vdwACM = addw.vdwACM;
 241         padda.vdwDriver = addw.vdwDriver;
 242         padda.fdwSupport = addw.fdwSupport;
 243         padda.cFormatTags = addw.cFormatTags;
 244         padda.cFilterTags = addw.cFilterTags;
 245         padda.hicon = addw.hicon;
 246         WideCharToMultiByte( CP_ACP, 0, addw.szShortName, -1, padda.szShortName,
 247                              sizeof(padda.szShortName), NULL, NULL );
 248         WideCharToMultiByte( CP_ACP, 0, addw.szLongName, -1, padda.szLongName,
 249                              sizeof(padda.szLongName), NULL, NULL );
 250         WideCharToMultiByte( CP_ACP, 0, addw.szCopyright, -1, padda.szCopyright,
 251                              sizeof(padda.szCopyright), NULL, NULL );
 252         WideCharToMultiByte( CP_ACP, 0, addw.szLicensing, -1, padda.szLicensing,
 253                              sizeof(padda.szLicensing), NULL, NULL );
 254         WideCharToMultiByte( CP_ACP, 0, addw.szFeatures, -1, padda.szFeatures,
 255                              sizeof(padda.szFeatures), NULL, NULL );
 256         padda.cbStruct = min(padd->cbStruct, sizeof(*padd));
 257         memcpy(padd, &padda, padda.cbStruct);
 258     }
 259     return mmr;
 260 }
 261
 262 /***********************************************************************
 263  *           acmDriverDetailsW (MSACM32.@)
 264  */
 265 MMRESULT WINAPI acmDriverDetailsW(HACMDRIVERID hadid, PACMDRIVERDETAILSW padd, DWORD fdwDetails)
 266 {
 267     HACMDRIVER acmDrvr;
 268     MMRESULT mmr;
 269
 270     TRACE("(%p, %p, %08lx)\n", hadid, padd, fdwDetails);
 271
 272     if (!padd) {
 273         WARN("invalid parameter\n");
 274         return MMSYSERR_INVALPARAM;
 275     }
 276
 277     if (padd->cbStruct < 4) {
 278         WARN("invalid parameter\n");
 279         return MMSYSERR_INVALPARAM;
 280     }
 281
 282     if (fdwDetails) {
 283         WARN("invalid flag\n");
 284         return MMSYSERR_INVALFLAG;
 285     }
 286
 287     mmr = acmDriverOpen(&acmDrvr, hadid, 0);
 288     if (mmr == MMSYSERR_NOERROR) {
 289         ACMDRIVERDETAILSW paddw;
 290         paddw.cbStruct = sizeof(paddw);
 291         mmr = (MMRESULT)MSACM_Message(acmDrvr, ACMDM_DRIVER_DETAILS, (LPARAM)&paddw,  0);
 292
 293         acmDriverClose(acmDrvr, 0);
 294         paddw.cbStruct = min(padd->cbStruct, sizeof(*padd));
 295         memcpy(padd, &paddw, paddw.cbStruct);
 296     }
 297
 298     return mmr;
 299 }
 300
 301 /***********************************************************************
 302  *           acmDriverEnum (MSACM32.@)
 303  */
 304 MMRESULT WINAPI acmDriverEnum(ACMDRIVERENUMCB fnCallback, DWORD dwInstance, DWORD fdwEnum)
 305 {
 306     PWINE_ACMDRIVERID   padid;
 307     DWORD               fdwSupport;
 308
 309     TRACE("(%p, %08lx, %08lx)\n", fnCallback, dwInstance, fdwEnum);
 310
 311     if (!fnCallback) {
 312         WARN("invalid parameter\n");
 313         return MMSYSERR_INVALPARAM;
 314     }
 315
 316     if (fdwEnum & ~(ACM_DRIVERENUMF_NOLOCAL|ACM_DRIVERENUMF_DISABLED)) {
 317         WARN("invalid flag\n");
 318         return MMSYSERR_INVALFLAG;
 319     }
 320
 321     for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
 322         fdwSupport = padid->fdwSupport;
 323
 324         if (padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) {
 325             if (fdwEnum & ACM_DRIVERENUMF_DISABLED)
 326                 fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
 327             else
 328                 continue;
 329         }
 330         if (!(*fnCallback)((HACMDRIVERID)padid, dwInstance, fdwSupport))
 331             break;
 332     }
 333
 334     return MMSYSERR_NOERROR;
 335 }
 336
 337 /***********************************************************************
 338  *           acmDriverID (MSACM32.@)
 339  */
 340 MMRESULT WINAPI acmDriverID(HACMOBJ hao, PHACMDRIVERID phadid, DWORD fdwDriverID)
 341 {
 342     PWINE_ACMOBJ pao;
 343
 344     TRACE("(%p, %p, %08lx)\n", hao, phadid, fdwDriverID);
 345
 346     if (fdwDriverID) {
 347         WARN("invalid flag\n");
 348         return MMSYSERR_INVALFLAG;
 349     }
 350
 351     pao = MSACM_GetObj(hao, WINE_ACMOBJ_DONTCARE);
 352     if (!pao) {
 353         WARN("invalid handle\n");
 354         return MMSYSERR_INVALHANDLE;
 355     }
 356
 357     if (!phadid) {
 358         WARN("invalid parameter\n");
 359         return MMSYSERR_INVALPARAM;
 360     }
 361
 362     *phadid = (HACMDRIVERID) pao->pACMDriverID;
 363
 364     return MMSYSERR_NOERROR;
 365 }
 366
 367 /***********************************************************************
 368  *           acmDriverMessage (MSACM32.@)
 369  *
 370  */
 371 LRESULT WINAPI acmDriverMessage(HACMDRIVER had, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
 372 {
 373     TRACE("(%p, %04x, %08lx, %08lx\n", had, uMsg, lParam1, lParam2);
 374
 375     if ((uMsg >= ACMDM_USER && uMsg < ACMDM_RESERVED_LOW) ||
 376         uMsg == ACMDM_DRIVER_ABOUT ||
 377         uMsg == DRV_QUERYCONFIGURE ||
 378         uMsg == DRV_CONFIGURE)
 379         return MSACM_Message(had, uMsg, lParam1, lParam2);
 380
 381     WARN("invalid parameter\n");
 382     return MMSYSERR_INVALPARAM;
 383 }
 384
 385 /***********************************************************************
 386  *           acmDriverOpen (MSACM32.@)
 387  */
 388 MMRESULT WINAPI acmDriverOpen(PHACMDRIVER phad, HACMDRIVERID hadid, DWORD fdwOpen)
 389 {
 390     PWINE_ACMDRIVERID   padid;
 391     PWINE_ACMDRIVER     pad = NULL;
 392     MMRESULT            ret;
 393
 394     TRACE("(%p, %p, %08lu)\n", phad, hadid, fdwOpen);
 395
 396     if (!phad) {
 397         WARN("invalid parameter\n");
 398         return MMSYSERR_INVALPARAM;
 399     }
 400
 401     if (fdwOpen) {
 402         WARN("invalid flag\n");
 403         return MMSYSERR_INVALFLAG;
 404     }
 405
 406     padid = MSACM_GetDriverID(hadid);
 407     if (!padid) {
 408         WARN("invalid handle\n");
 409         return MMSYSERR_INVALHANDLE;
 410     }
 411
 412     pad = HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMDRIVER));
 413     if (!pad) {
 414         WARN("no memory\n");
 415         return MMSYSERR_NOMEM;
 416     }
 417
 418     pad->obj.dwType = WINE_ACMOBJ_DRIVER;
 419     pad->obj.pACMDriverID = padid;
 420
 421     if (!(pad->hDrvr = (HDRVR)padid->hInstModule))
 422     {
 423         ACMDRVOPENDESCW adod;
 424         int             len;
 425
 426         /* this is not an externally added driver... need to actually load it */
 427         if (!padid->pszDriverAlias)
 428         {
 429             ret = MMSYSERR_ERROR;
 430             goto gotError;
 431         }
 432
 433         adod.cbStruct = sizeof(adod);
 434         adod.fccType = ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC;
 435         adod.fccComp = ACMDRIVERDETAILS_FCCCOMP_UNDEFINED;
 436         adod.dwVersion = acmGetVersion();
 437         adod.dwFlags = fdwOpen;
 438         adod.dwError = 0;
 439         len = strlen("Drivers32") + 1;
 440         adod.pszSectionName = HeapAlloc(MSACM_hHeap, 0, len * sizeof(WCHAR));
 441         MultiByteToWideChar(CP_ACP, 0, "Drivers32", -1, (LPWSTR)adod.pszSectionName, len);
 442         adod.pszAliasName = padid->pszDriverAlias;
 443         adod.dnDevNode = 0;
 444
 445         pad->hDrvr = OpenDriver(padid->pszDriverAlias, NULL, (DWORD)&adod);
 446
 447         HeapFree(MSACM_hHeap, 0, (LPWSTR)adod.pszSectionName);
 448         if (!pad->hDrvr)
 449         {
 450             ret = adod.dwError;
 451             goto gotError;
 452         }
 453     }
 454
 455     /* insert new pad at beg of list */
 456     pad->pNextACMDriver = padid->pACMDriverList;
 457     padid->pACMDriverList = pad;
 458
 459     /* FIXME: Create a WINE_ACMDRIVER32 */
 460     *phad = (HACMDRIVER)pad;
 461     TRACE("'%s' => %p\n", debugstr_w(padid->pszDriverAlias), pad);
 462
 463     return MMSYSERR_NOERROR;
 464  gotError:
 465     WARN("failed: ret = %08x\n", ret);
 466     if (pad && !pad->hDrvr)
 467         HeapFree(MSACM_hHeap, 0, pad);
 468     return ret;
 469 }
 470
 471 /***********************************************************************
 472  *           acmDriverPriority (MSACM32.@)
 473  */
 474 MMRESULT WINAPI acmDriverPriority(HACMDRIVERID hadid, DWORD dwPriority, DWORD fdwPriority)
 475 {
 476
 477     TRACE("(%p, %08lx, %08lx)\n", hadid, dwPriority, fdwPriority);
 478
 479     /* Check for unknown flags */
 480     if (fdwPriority &
 481         ~(ACM_DRIVERPRIORITYF_ENABLE|ACM_DRIVERPRIORITYF_DISABLE|
 482           ACM_DRIVERPRIORITYF_BEGIN|ACM_DRIVERPRIORITYF_END)) {
 483         WARN("invalid flag\n");
 484         return MMSYSERR_INVALFLAG;
 485     }
 486
 487     /* Check for incompatible flags */
 488     if ((fdwPriority & ACM_DRIVERPRIORITYF_ENABLE) &&
 489         (fdwPriority & ACM_DRIVERPRIORITYF_DISABLE)) {
 490         WARN("invalid flag\n");
 491         return MMSYSERR_INVALFLAG;
 492     }
 493
 494     /* Check for incompatible flags */
 495     if ((fdwPriority & ACM_DRIVERPRIORITYF_BEGIN) &&
 496         (fdwPriority & ACM_DRIVERPRIORITYF_END)) {
 497         WARN("invalid flag\n");
 498         return MMSYSERR_INVALFLAG;
 499     }
 500
 501     /* According to MSDN, ACM_DRIVERPRIORITYF_BEGIN and ACM_DRIVERPRIORITYF_END
 502        may only appear by themselves, and in addition, hadid and dwPriority must
 503        both be zero */
 504     if ((fdwPriority & ACM_DRIVERPRIORITYF_BEGIN) ||
 505         (fdwPriority & ACM_DRIVERPRIORITYF_END)) {
 506         if (fdwPriority & ~(ACM_DRIVERPRIORITYF_BEGIN|ACM_DRIVERPRIORITYF_END)) {
 507             WARN("ACM_DRIVERPRIORITYF_[BEGIN|END] cannot be used with any other flags\n");
 508             return MMSYSERR_INVALPARAM;
 509         }
 510         if (dwPriority) {
 511             WARN("priority invalid with ACM_DRIVERPRIORITYF_[BEGIN|END]\n");
 512             return MMSYSERR_INVALPARAM;
 513         }
 514         if (hadid) {
 515             WARN("non-null hadid invalid with ACM_DRIVERPRIORITYF_[BEGIN|END]\n");
 516             return MMSYSERR_INVALPARAM;
 517         }
 518         /* FIXME: MSDN wording suggests that deferred notification should be
 519            implemented as a system-wide lock held by a calling task, and that
 520            re-enabling notifications should broadcast them across all processes.
 521            This implementation uses a simple DWORD counter. One consequence of the
 522            current implementation is that applications will never see
 523            MMSYSERR_ALLOCATED as a return error.
 524          */
 525         if (fdwPriority & ACM_DRIVERPRIORITYF_BEGIN) {
 526             MSACM_DisableNotifications();
 527         } else if (fdwPriority & ACM_DRIVERPRIORITYF_END) {
 528             MSACM_EnableNotifications();
 529         }
 530         return MMSYSERR_NOERROR;
 531     } else {
 532         PWINE_ACMDRIVERID padid;
 533         BOOL bPerformBroadcast = FALSE;
 534
 535         /* Fetch driver ID */
 536         padid = MSACM_GetDriverID(hadid);
 537         if (!padid) {
 538             WARN("invalid handle\n");
 539             return MMSYSERR_INVALHANDLE;
 540         }
 541
 542         /* Check whether driver ID is appropriate for requested op */
 543         if (dwPriority) {
 544             if (padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_LOCAL) {
 545                 return MMSYSERR_NOTSUPPORTED;
 546             }
 547             if (dwPriority != 1 && dwPriority != -1) {
 548                 FIXME("unexpected priority %ld, using sign only\n", dwPriority);
 549                 if (dwPriority < 0) dwPriority = -1;
 550                 if (dwPriority > 0) dwPriority = 1;
 551             }
 552
 553             if (dwPriority == 1 && (padid->pPrevACMDriverID == NULL ||
 554                 (padid->pPrevACMDriverID->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_LOCAL))) {
 555                 /* do nothing - driver is first of list, or first after last
 556                    local driver */
 557             } else if (dwPriority == -1 && padid->pNextACMDriverID == NULL) {
 558                 /* do nothing - driver is last of list */
 559             } else {
 560                 MSACM_RePositionDriver(padid, dwPriority);
 561                 bPerformBroadcast = TRUE;
 562             }
 563         }
 564
 565         /* Check whether driver ID should be enabled or disabled */
 566         if (fdwPriority & ACM_DRIVERPRIORITYF_DISABLE) {
 567             if (!(padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED)) {
 568                 padid->fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
 569                 bPerformBroadcast = TRUE;
 570             }
 571         } else if (fdwPriority & ACM_DRIVERPRIORITYF_ENABLE) {
 572             if (padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) {
 573                 padid->fdwSupport &= ~ACMDRIVERDETAILS_SUPPORTF_DISABLED;
 574                 bPerformBroadcast = TRUE;
 575             }
 576         }
 577
 578         /* Perform broadcast of changes */
 579         if (bPerformBroadcast) {
 580             MSACM_WriteCurrentPriorities();
 581             MSACM_BroadcastNotification();
 582         }
 583         return MMSYSERR_NOERROR;
 584     }
 585 }
 586
 587 /***********************************************************************
 588  *           acmDriverRemove (MSACM32.@)
 589  */
 590 MMRESULT WINAPI acmDriverRemove(HACMDRIVERID hadid, DWORD fdwRemove)
 591 {
 592     PWINE_ACMDRIVERID padid;
 593
 594     TRACE("(%p, %08lx)\n", hadid, fdwRemove);
 595
 596     padid = MSACM_GetDriverID(hadid);
 597     if (!padid) {
 598         WARN("invalid handle\n");
 599         return MMSYSERR_INVALHANDLE;
 600     }
 601
 602     if (fdwRemove) {
 603         WARN("invalid flag\n");
 604         return MMSYSERR_INVALFLAG;
 605     }
 606
 607     MSACM_UnregisterDriver(padid);
 608     MSACM_BroadcastNotification();
 609
 610     return MMSYSERR_NOERROR;
 611 }