dll/win32/msacm32/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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include "wineacm.h"
  25
  26 /***********************************************************************
  27  *           acmDriverAddA (MSACM32.@)
  28  */
  29 MMRESULT WINAPI acmDriverAddA(PHACMDRIVERID phadid, HINSTANCE hinstModule,
  30                               LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
  31 {
  32     MMRESULT resultW;
  33     WCHAR * driverW = NULL;
  34     LPARAM lParamW = lParam;
  35
  36     TRACE("(%p, %p, %08lx, %08x, %08x)\n",
  37           phadid, hinstModule, lParam, dwPriority, fdwAdd);
  38
  39     if (!phadid) {
  40         WARN("invalid parameter\n");
  41         return MMSYSERR_INVALPARAM;
  42     }
  43
  44     /* Check if any unknown flags */
  45     if (fdwAdd &
  46         ~(ACM_DRIVERADDF_FUNCTION|ACM_DRIVERADDF_NOTIFYHWND|
  47           ACM_DRIVERADDF_GLOBAL)) {
  48         WARN("invalid flag\n");
  49         return MMSYSERR_INVALFLAG;
  50     }
  51
  52     /* Check if any incompatible flags */
  53     if ((fdwAdd & ACM_DRIVERADDF_FUNCTION) &&
  54         (fdwAdd & ACM_DRIVERADDF_NOTIFYHWND)) {
  55         WARN("invalid flag\n");
  56         return MMSYSERR_INVALFLAG;
  57     }
  58
  59     /* A->W translation of name */
  60     if ((fdwAdd & ACM_DRIVERADDF_TYPEMASK) == ACM_DRIVERADDF_NAME) {
  61         INT len;
  62
  63         if (lParam == 0) return MMSYSERR_INVALPARAM;
  64         len = MultiByteToWideChar(CP_ACP, 0, (LPSTR)lParam, -1, NULL, 0);
  65         driverW = HeapAlloc(MSACM_hHeap, 0, len * sizeof(WCHAR));
  66         if (!driverW) return MMSYSERR_NOMEM;
  67         MultiByteToWideChar(CP_ACP, 0, (LPSTR)lParam, -1, driverW, len);
  68         lParamW = (LPARAM)driverW;
  69     }
  70
  71     resultW = acmDriverAddW(phadid, hinstModule, lParamW, dwPriority, fdwAdd);
  72     HeapFree(MSACM_hHeap, 0, driverW);
  73     return resultW;
  74 }
  75
  76 /***********************************************************************
  77  *           acmDriverAddW (MSACM32.@)
  78  *
  79  */
  80 MMRESULT WINAPI acmDriverAddW(PHACMDRIVERID phadid, HINSTANCE hinstModule,
  81                               LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
  82 {
  83     PWINE_ACMLOCALDRIVER pLocalDrv = NULL;
  84
  85     TRACE("(%p, %p, %08lx, %08x, %08x)\n",
  86           phadid, hinstModule, lParam, dwPriority, fdwAdd);
  87
  88     if (!phadid) {
  89         WARN("invalid parameter\n");
  90         return MMSYSERR_INVALPARAM;
  91     }
  92
  93     /* Check if any unknown flags */
  94     if (fdwAdd &
  95         ~(ACM_DRIVERADDF_FUNCTION|ACM_DRIVERADDF_NOTIFYHWND|
  96           ACM_DRIVERADDF_GLOBAL)) {
  97         WARN("invalid flag\n");
  98         return MMSYSERR_INVALFLAG;
  99     }
 100
 101     /* Check if any incompatible flags */
 102     if ((fdwAdd & ACM_DRIVERADDF_FUNCTION) &&
 103         (fdwAdd & ACM_DRIVERADDF_NOTIFYHWND)) {
 104         WARN("invalid flag\n");
 105         return MMSYSERR_INVALFLAG;
 106     }
 107
 108     switch (fdwAdd & ACM_DRIVERADDF_TYPEMASK) {
 109     case ACM_DRIVERADDF_NAME:
 110         /*
 111                 hInstModule     (unused)
 112                 lParam          name of value in HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Drivers32
 113                 dwPriority      (unused, set to 0)
 114          */
 115         *phadid = (HACMDRIVERID) MSACM_RegisterDriverFromRegistry((LPCWSTR)lParam);
 116         if (!*phadid) {
 117             ERR("Unable to register driver via ACM_DRIVERADDF_NAME\n");
 118             return MMSYSERR_INVALPARAM;
 119         }
 120         break;
 121     case ACM_DRIVERADDF_FUNCTION:
 122         /*
 123                 hInstModule     Handle of module which contains driver entry proc
 124                 lParam          Driver function address
 125                 dwPriority      (unused, set to 0)
 126          */
 127         fdwAdd &= ~ACM_DRIVERADDF_TYPEMASK;
 128         /* FIXME: fdwAdd ignored */
 129         /* Application-supplied acmDriverProc's are placed at the top of the priority unless
 130            fdwAdd indicates ACM_DRIVERADDF_GLOBAL
 131          */
 132         pLocalDrv = MSACM_RegisterLocalDriver(hinstModule, (DRIVERPROC)lParam);
 133         *phadid = pLocalDrv ? (HACMDRIVERID) MSACM_RegisterDriver(NULL, NULL, pLocalDrv) : NULL;
 134         if (!*phadid) {
 135             ERR("Unable to register driver via ACM_DRIVERADDF_FUNCTION\n");
 136             return MMSYSERR_INVALPARAM;
 137         }
 138         break;
 139     case ACM_DRIVERADDF_NOTIFYHWND:
 140         /*
 141                 hInstModule     (unused)
 142                 lParam          Handle of notification window
 143                 dwPriority      Window message to send for notification broadcasts
 144          */
 145         *phadid = (HACMDRIVERID) MSACM_RegisterNotificationWindow((HWND)lParam, dwPriority);
 146         if (!*phadid) {
 147             ERR("Unable to register driver via ACM_DRIVERADDF_NOTIFYHWND\n");
 148             return MMSYSERR_INVALPARAM;
 149         }
 150         break;
 151     default:
 152         ERR("invalid flag value 0x%08x for fdwAdd\n", fdwAdd & ACM_DRIVERADDF_TYPEMASK);
 153         return MMSYSERR_INVALFLAG;
 154     }
 155
 156     MSACM_BroadcastNotification();
 157     return MMSYSERR_NOERROR;
 158 }
 159
 160 /***********************************************************************
 161  *           acmDriverClose (MSACM32.@)
 162  */
 163 MMRESULT WINAPI acmDriverClose(HACMDRIVER had, DWORD fdwClose)
 164 {
 165     PWINE_ACMDRIVER     pad;
 166     PWINE_ACMDRIVERID   padid;
 167     PWINE_ACMDRIVER*    tpad;
 168
 169     TRACE("(%p, %08x)\n", had, fdwClose);
 170
 171     if (fdwClose) {
 172         WARN("invalid flag\n");
 173         return MMSYSERR_INVALFLAG;
 174     }
 175
 176     pad = MSACM_GetDriver(had);
 177     if (!pad) {
 178         WARN("invalid handle\n");
 179         return MMSYSERR_INVALHANDLE;
 180     }
 181
 182     padid = pad->obj.pACMDriverID;
 183
 184     /* remove driver from list */
 185     for (tpad = &(padid->pACMDriverList); *tpad; tpad = &((*tpad)->pNextACMDriver)) {
 186         if (*tpad == pad) {
 187             *tpad = (*tpad)->pNextACMDriver;
 188             break;
 189         }
 190     }
 191
 192     /* close driver if it has been opened */
 193     if (pad->hDrvr && !pad->pLocalDrvrInst)
 194         CloseDriver(pad->hDrvr, 0, 0);
 195     else if (pad->pLocalDrvrInst)
 196         MSACM_CloseLocalDriver(pad->pLocalDrvrInst);
 197
 198     pad->obj.dwType = 0;
 199     HeapFree(MSACM_hHeap, 0, pad);
 200
 201     return MMSYSERR_NOERROR;
 202 }
 203
 204 /***********************************************************************
 205  *           acmDriverDetailsA (MSACM32.@)
 206  */
 207 MMRESULT WINAPI acmDriverDetailsA(HACMDRIVERID hadid, PACMDRIVERDETAILSA padd, DWORD fdwDetails)
 208 {
 209     MMRESULT mmr;
 210     ACMDRIVERDETAILSW   addw;
 211
 212     TRACE("(%p, %p, %08x)\n", hadid, padd, fdwDetails);
 213
 214     if (!padd) {
 215         WARN("invalid parameter\n");
 216         return MMSYSERR_INVALPARAM;
 217     }
 218
 219     if (padd->cbStruct < 4) {
 220         WARN("invalid parameter\n");
 221         return MMSYSERR_INVALPARAM;
 222     }
 223
 224     addw.cbStruct = sizeof(addw);
 225     mmr = acmDriverDetailsW(hadid, &addw, fdwDetails);
 226     if (mmr == 0) {
 227         ACMDRIVERDETAILSA padda;
 228
 229         padda.fccType = addw.fccType;
 230         padda.fccComp = addw.fccComp;
 231         padda.wMid = addw.wMid;
 232         padda.wPid = addw.wPid;
 233         padda.vdwACM = addw.vdwACM;
 234         padda.vdwDriver = addw.vdwDriver;
 235         padda.fdwSupport = addw.fdwSupport;
 236         padda.cFormatTags = addw.cFormatTags;
 237         padda.cFilterTags = addw.cFilterTags;
 238         padda.hicon = addw.hicon;
 239         WideCharToMultiByte( CP_ACP, 0, addw.szShortName, -1, padda.szShortName,
 240                              sizeof(padda.szShortName), NULL, NULL );
 241         WideCharToMultiByte( CP_ACP, 0, addw.szLongName, -1, padda.szLongName,
 242                              sizeof(padda.szLongName), NULL, NULL );
 243         WideCharToMultiByte( CP_ACP, 0, addw.szCopyright, -1, padda.szCopyright,
 244                              sizeof(padda.szCopyright), NULL, NULL );
 245         WideCharToMultiByte( CP_ACP, 0, addw.szLicensing, -1, padda.szLicensing,
 246                              sizeof(padda.szLicensing), NULL, NULL );
 247         WideCharToMultiByte( CP_ACP, 0, addw.szFeatures, -1, padda.szFeatures,
 248                              sizeof(padda.szFeatures), NULL, NULL );
 249         padda.cbStruct = min(padd->cbStruct, sizeof(*padd));
 250         memcpy(padd, &padda, padda.cbStruct);
 251     }
 252     return mmr;
 253 }
 254
 255 /***********************************************************************
 256  *           acmDriverDetailsW (MSACM32.@)
 257  */
 258 MMRESULT WINAPI acmDriverDetailsW(HACMDRIVERID hadid, PACMDRIVERDETAILSW padd, DWORD fdwDetails)
 259 {
 260     HACMDRIVER acmDrvr;
 261     MMRESULT mmr;
 262
 263     TRACE("(%p, %p, %08x)\n", hadid, padd, fdwDetails);
 264
 265     if (!padd) {
 266         WARN("invalid parameter\n");
 267         return MMSYSERR_INVALPARAM;
 268     }
 269
 270     if (padd->cbStruct < 4) {
 271         WARN("invalid parameter\n");
 272         return MMSYSERR_INVALPARAM;
 273     }
 274
 275     if (fdwDetails) {
 276         WARN("invalid flag\n");
 277         return MMSYSERR_INVALFLAG;
 278     }
 279
 280     mmr = acmDriverOpen(&acmDrvr, hadid, 0);
 281     if (mmr == MMSYSERR_NOERROR) {
 282         ACMDRIVERDETAILSW paddw;
 283         paddw.cbStruct = sizeof(paddw);
 284         mmr = MSACM_Message(acmDrvr, ACMDM_DRIVER_DETAILS, (LPARAM)&paddw,  0);
 285
 286         acmDriverClose(acmDrvr, 0);
 287         paddw.cbStruct = min(padd->cbStruct, sizeof(*padd));
 288         memcpy(padd, &paddw, paddw.cbStruct);
 289     }
 290     else if (mmr == MMSYSERR_NODRIVER)
 291         return MMSYSERR_NOTSUPPORTED;
 292
 293     return mmr;
 294 }
 295
 296 /***********************************************************************
 297  *           acmDriverEnum (MSACM32.@)
 298  */
 299 MMRESULT WINAPI acmDriverEnum(ACMDRIVERENUMCB fnCallback, DWORD_PTR dwInstance,
 300                               DWORD fdwEnum)
 301 {
 302     PWINE_ACMDRIVERID   padid;
 303     DWORD               fdwSupport;
 304
 305     TRACE("(%p, %08lx, %08x)\n", fnCallback, dwInstance, fdwEnum);
 306
 307     if (!fnCallback) {
 308         WARN("invalid parameter\n");
 309         return MMSYSERR_INVALPARAM;
 310     }
 311
 312     if (fdwEnum & ~(ACM_DRIVERENUMF_NOLOCAL|ACM_DRIVERENUMF_DISABLED)) {
 313         WARN("invalid flag\n");
 314         return MMSYSERR_INVALFLAG;
 315     }
 316
 317     for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
 318         fdwSupport = padid->fdwSupport;
 319
 320         if (padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) {
 321             if (fdwEnum & ACM_DRIVERENUMF_DISABLED)
 322                 fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
 323             else
 324                 continue;
 325         }
 326         if (!(*fnCallback)((HACMDRIVERID)padid, dwInstance, fdwSupport))
 327             break;
 328     }
 329
 330     return MMSYSERR_NOERROR;
 331 }
 332
 333 /***********************************************************************
 334  *           acmDriverID (MSACM32.@)
 335  */
 336 MMRESULT WINAPI acmDriverID(HACMOBJ hao, PHACMDRIVERID phadid, DWORD fdwDriverID)
 337 {
 338     PWINE_ACMOBJ pao;
 339
 340     TRACE("(%p, %p, %08x)\n", hao, phadid, fdwDriverID);
 341
 342     if (fdwDriverID) {
 343         WARN("invalid flag\n");
 344         return MMSYSERR_INVALFLAG;
 345     }
 346
 347     pao = MSACM_GetObj(hao, WINE_ACMOBJ_DONTCARE);
 348     if (!pao) {
 349         WARN("invalid handle\n");
 350         return MMSYSERR_INVALHANDLE;
 351     }
 352
 353     if (!phadid) {
 354         WARN("invalid parameter\n");
 355         return MMSYSERR_INVALPARAM;
 356     }
 357
 358     *phadid = (HACMDRIVERID) pao->pACMDriverID;
 359
 360     return MMSYSERR_NOERROR;
 361 }
 362
 363 /***********************************************************************
 364  *           acmDriverMessage (MSACM32.@)
 365  *
 366  * Note: MSDN documentation (July 2001) is incomplete. This function
 367  * accepts sending messages to an HACMDRIVERID in addition to the
 368  * documented HACMDRIVER. In fact, for DRV_QUERYCONFIGURE and DRV_CONFIGURE,
 369  * this might actually be the required mode of operation.
 370  *
 371  * Note: For DRV_CONFIGURE, msacm supplies its own DRVCONFIGINFO structure
 372  * when the application fails to supply one. Some native drivers depend on
 373  * this and refuse to display unless a valid DRVCONFIGINFO structure is
 374  * built and supplied.
 375  */
 376 LRESULT WINAPI acmDriverMessage(HACMDRIVER had, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
 377 {
 378     TRACE("(%p, %04x, %08lx, %08lx\n", had, uMsg, lParam1, lParam2);
 379
 380     if ((uMsg >= ACMDM_USER && uMsg < ACMDM_RESERVED_LOW) ||
 381         uMsg == ACMDM_DRIVER_ABOUT ||
 382         uMsg == DRV_QUERYCONFIGURE ||
 383         uMsg == DRV_CONFIGURE)
 384     {
 385         PWINE_ACMDRIVERID padid;
 386         LRESULT lResult;
 387         LPDRVCONFIGINFO pConfigInfo = NULL;
 388         LPWSTR section_name = NULL;
 389         LPWSTR alias_name = NULL;
 390
 391         /* Check whether handle is an HACMDRIVERID */
 392         padid  = MSACM_GetDriverID((HACMDRIVERID)had);
 393
 394         /* If the message is DRV_CONFIGURE, and the application provides no
 395            DRVCONFIGINFO structure, msacm must supply its own.
 396          */
 397         if (uMsg == DRV_CONFIGURE && lParam2 == 0) {
 398             LPWSTR pAlias;
 399
 400             /* Get the alias from the HACMDRIVERID */
 401             if (padid) {
 402                 pAlias = padid->pszDriverAlias;
 403                 if (pAlias == NULL) {
 404                     WARN("DRV_CONFIGURE: no alias for this driver, cannot self-supply alias\n");
 405                 }
 406             } else {
 407                 FIXME("DRV_CONFIGURE: reverse lookup HACMDRIVER -> HACMDRIVERID not implemented\n");
 408                 pAlias = NULL;
 409             }
 410
 411             if (pAlias != NULL) {
 412                 /* DRVCONFIGINFO is only 12 bytes long, but native msacm
 413                  * reports a 16-byte structure to codecs, so allocate 16 bytes,
 414                  * just to be on the safe side.
 415                  */
 416                 const unsigned int iStructSize = 16;
 417                 pConfigInfo = HeapAlloc(MSACM_hHeap, 0, iStructSize);
 418                 if (!pConfigInfo) {
 419                     ERR("OOM while supplying DRVCONFIGINFO for DRV_CONFIGURE, using NULL\n");
 420                 } else {
 421                     static const WCHAR drivers32[] = {'D','r','i','v','e','r','s','3','2','\0'};
 422
 423                     pConfigInfo->dwDCISize = iStructSize;
 424
 425                     section_name = HeapAlloc(MSACM_hHeap, 0, (strlenW(drivers32) + 1) * sizeof(WCHAR));
 426                     if (section_name) strcpyW(section_name, drivers32);
 427                     pConfigInfo->lpszDCISectionName = section_name;
 428                     alias_name = HeapAlloc(MSACM_hHeap, 0, (strlenW(pAlias) + 1) * sizeof(WCHAR));
 429                     if (alias_name) strcpyW(alias_name, pAlias);
 430                     pConfigInfo->lpszDCIAliasName = alias_name;
 431
 432                     if (pConfigInfo->lpszDCISectionName == NULL || pConfigInfo->lpszDCIAliasName == NULL) {
 433                         HeapFree(MSACM_hHeap, 0, alias_name);
 434                         HeapFree(MSACM_hHeap, 0, section_name);
 435                         HeapFree(MSACM_hHeap, 0, pConfigInfo);
 436                         pConfigInfo = NULL;
 437                         ERR("OOM while supplying DRVCONFIGINFO for DRV_CONFIGURE, using NULL\n");
 438                     }
 439                 }
 440             }
 441
 442             lParam2 = (LPARAM)pConfigInfo;
 443         }
 444
 445         if (padid) {
 446             /* Handle is really an HACMDRIVERID, must have an open session to get an HACMDRIVER */
 447             if (padid->pACMDriverList != NULL) {
 448                 lResult = MSACM_Message((HACMDRIVER)padid->pACMDriverList, uMsg, lParam1, lParam2);
 449             } else {
 450                 MMRESULT mmr = acmDriverOpen(&had, (HACMDRIVERID)padid, 0);
 451                 if (mmr != MMSYSERR_NOERROR) {
 452                     lResult = MMSYSERR_INVALPARAM;
 453                 } else {
 454                     lResult = acmDriverMessage(had, uMsg, lParam1, lParam2);
 455                     acmDriverClose(had, 0);
 456                 }
 457             }
 458         } else {
 459             lResult = MSACM_Message(had, uMsg, lParam1, lParam2);
 460         }
 461         if (pConfigInfo) {
 462             HeapFree(MSACM_hHeap, 0, alias_name);
 463             HeapFree(MSACM_hHeap, 0, section_name);
 464             HeapFree(MSACM_hHeap, 0, pConfigInfo);
 465         }
 466         return lResult;
 467     }
 468     WARN("invalid parameter\n");
 469     return MMSYSERR_INVALPARAM;
 470 }
 471
 472 /***********************************************************************
 473  *           acmDriverOpen (MSACM32.@)
 474  */
 475 MMRESULT WINAPI acmDriverOpen(PHACMDRIVER phad, HACMDRIVERID hadid, DWORD fdwOpen)
 476 {
 477     PWINE_ACMDRIVERID   padid;
 478     PWINE_ACMDRIVER     pad = NULL;
 479     MMRESULT            ret;
 480
 481     TRACE("(%p, %p, %08u)\n", phad, hadid, fdwOpen);
 482
 483     if (!phad) {
 484         WARN("invalid parameter\n");
 485         return MMSYSERR_INVALPARAM;
 486     }
 487
 488     if (fdwOpen) {
 489         WARN("invalid flag\n");
 490         return MMSYSERR_INVALFLAG;
 491     }
 492
 493     padid = MSACM_GetDriverID(hadid);
 494     if (!padid) {
 495         WARN("invalid handle\n");
 496         return MMSYSERR_INVALHANDLE;
 497     }
 498
 499     pad = HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMDRIVER));
 500     if (!pad) {
 501         WARN("no memory\n");
 502         return MMSYSERR_NOMEM;
 503     }
 504
 505     pad->obj.dwType = WINE_ACMOBJ_DRIVER;
 506     pad->obj.pACMDriverID = padid;
 507     pad->hDrvr = 0;
 508     pad->pLocalDrvrInst = NULL;
 509
 510     if (padid->pLocalDriver == NULL)
 511     {
 512         ACMDRVOPENDESCW adod;
 513         int             len;
 514         LPWSTR          section_name;
 515
 516         /* this is not an externally added driver... need to actually load it */
 517         if (!padid->pszDriverAlias)
 518         {
 519             ret = MMSYSERR_ERROR;
 520             goto gotError;
 521         }
 522
 523         adod.cbStruct = sizeof(adod);
 524         adod.fccType = ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC;
 525         adod.fccComp = ACMDRIVERDETAILS_FCCCOMP_UNDEFINED;
 526         adod.dwVersion = acmGetVersion();
 527         adod.dwFlags = fdwOpen;
 528         adod.dwError = 0;
 529         len = strlen("Drivers32") + 1;
 530         section_name = HeapAlloc(MSACM_hHeap, 0, len * sizeof(WCHAR));
 531         MultiByteToWideChar(CP_ACP, 0, "Drivers32", -1, section_name, len);
 532         adod.pszSectionName = section_name;
 533         adod.pszAliasName = padid->pszDriverAlias;
 534         adod.dnDevNode = 0;
 535
 536         pad->hDrvr = OpenDriver(padid->pszDriverAlias, NULL, (DWORD_PTR)&adod);
 537
 538         HeapFree(MSACM_hHeap, 0, section_name);
 539         if (!pad->hDrvr)
 540         {
 541             ret = adod.dwError;
 542             if (ret == MMSYSERR_NOERROR)
 543                 ret = MMSYSERR_NODRIVER;
 544             goto gotError;
 545         }
 546     }
 547     else
 548     {
 549         ACMDRVOPENDESCW adod;
 550
 551         pad->hDrvr = NULL;
 552
 553         adod.cbStruct = sizeof(adod);
 554         adod.fccType = ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC;
 555         adod.fccComp = ACMDRIVERDETAILS_FCCCOMP_UNDEFINED;
 556         adod.dwVersion = acmGetVersion();
 557         adod.dwFlags = fdwOpen;
 558         adod.dwError = 0;
 559         adod.pszSectionName = NULL;
 560         adod.pszAliasName = NULL;
 561         adod.dnDevNode = 0;
 562
 563         pad->pLocalDrvrInst = MSACM_OpenLocalDriver(padid->pLocalDriver, (DWORD_PTR)&adod);
 564         if (!pad->pLocalDrvrInst)
 565         {
 566             ret = adod.dwError;
 567             if (ret == MMSYSERR_NOERROR)
 568                 ret = MMSYSERR_NODRIVER;
 569             goto gotError;
 570         }
 571     }
 572
 573     /* insert new pad at beg of list */
 574     pad->pNextACMDriver = padid->pACMDriverList;
 575     padid->pACMDriverList = pad;
 576
 577     /* FIXME: Create a WINE_ACMDRIVER32 */
 578     *phad = (HACMDRIVER)pad;
 579     TRACE("%s => %p\n", debugstr_w(padid->pszDriverAlias), pad);
 580
 581     return MMSYSERR_NOERROR;
 582  gotError:
 583     WARN("failed: ret = %08x\n", ret);
 584     if (pad && !pad->hDrvr)
 585         HeapFree(MSACM_hHeap, 0, pad);
 586     return ret;
 587 }
 588
 589 /***********************************************************************
 590  *           acmDriverPriority (MSACM32.@)
 591  */
 592 MMRESULT WINAPI acmDriverPriority(HACMDRIVERID hadid, DWORD dwPriority, DWORD fdwPriority)
 593 {
 594
 595     TRACE("(%p, %08x, %08x)\n", hadid, dwPriority, fdwPriority);
 596
 597     /* Check for unknown flags */
 598     if (fdwPriority &
 599         ~(ACM_DRIVERPRIORITYF_ENABLE|ACM_DRIVERPRIORITYF_DISABLE|
 600           ACM_DRIVERPRIORITYF_BEGIN|ACM_DRIVERPRIORITYF_END)) {
 601         WARN("invalid flag\n");
 602         return MMSYSERR_INVALFLAG;
 603     }
 604
 605     /* Check for incompatible flags */
 606     if ((fdwPriority & ACM_DRIVERPRIORITYF_ENABLE) &&
 607         (fdwPriority & ACM_DRIVERPRIORITYF_DISABLE)) {
 608         WARN("invalid flag\n");
 609         return MMSYSERR_INVALFLAG;
 610     }
 611
 612     /* Check for incompatible flags */
 613     if ((fdwPriority & ACM_DRIVERPRIORITYF_BEGIN) &&
 614         (fdwPriority & ACM_DRIVERPRIORITYF_END)) {
 615         WARN("invalid flag\n");
 616         return MMSYSERR_INVALFLAG;
 617     }
 618
 619     /* According to MSDN, ACM_DRIVERPRIORITYF_BEGIN and ACM_DRIVERPRIORITYF_END
 620        may only appear by themselves, and in addition, hadid and dwPriority must
 621        both be zero */
 622     if ((fdwPriority & ACM_DRIVERPRIORITYF_BEGIN) ||
 623         (fdwPriority & ACM_DRIVERPRIORITYF_END)) {
 624         if (fdwPriority & ~(ACM_DRIVERPRIORITYF_BEGIN|ACM_DRIVERPRIORITYF_END)) {
 625             WARN("ACM_DRIVERPRIORITYF_[BEGIN|END] cannot be used with any other flags\n");
 626             return MMSYSERR_INVALPARAM;
 627         }
 628         if (dwPriority) {
 629             WARN("priority invalid with ACM_DRIVERPRIORITYF_[BEGIN|END]\n");
 630             return MMSYSERR_INVALPARAM;
 631         }
 632         if (hadid) {
 633             WARN("non-null hadid invalid with ACM_DRIVERPRIORITYF_[BEGIN|END]\n");
 634             return MMSYSERR_INVALPARAM;
 635         }
 636         /* FIXME: MSDN wording suggests that deferred notification should be
 637            implemented as a system-wide lock held by a calling task, and that
 638            re-enabling notifications should broadcast them across all processes.
 639            This implementation uses a simple DWORD counter. One consequence of the
 640            current implementation is that applications will never see
 641            MMSYSERR_ALLOCATED as a return error.
 642          */
 643         if (fdwPriority & ACM_DRIVERPRIORITYF_BEGIN) {
 644             MSACM_DisableNotifications();
 645         } else if (fdwPriority & ACM_DRIVERPRIORITYF_END) {
 646             MSACM_EnableNotifications();
 647         }
 648         return MMSYSERR_NOERROR;
 649     } else {
 650         PWINE_ACMDRIVERID padid;
 651         PWINE_ACMNOTIFYWND panwnd;
 652         BOOL bPerformBroadcast = FALSE;
 653
 654         /* Fetch driver ID */
 655         padid = MSACM_GetDriverID(hadid);
 656         panwnd = MSACM_GetNotifyWnd(hadid);
 657         if (!padid && !panwnd) {
 658             WARN("invalid handle\n");
 659             return MMSYSERR_INVALHANDLE;
 660         }
 661
 662         if (padid) {
 663             /* Check whether driver ID is appropriate for requested op */
 664             if (dwPriority) {
 665                 if (padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_LOCAL) {
 666                     return MMSYSERR_NOTSUPPORTED;
 667                 }
 668                 if (dwPriority != 1 && dwPriority != (DWORD)-1) {
 669                     FIXME("unexpected priority %d, using sign only\n", dwPriority);
 670                     if ((signed)dwPriority < 0) dwPriority = (DWORD)-1;
 671                     if (dwPriority > 0) dwPriority = 1;
 672                 }
 673
 674                 if (dwPriority == 1 && (padid->pPrevACMDriverID == NULL ||
 675                     (padid->pPrevACMDriverID->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_LOCAL))) {
 676                     /* do nothing - driver is first of list, or first after last
 677                        local driver */
 678                 } else if (dwPriority == (DWORD)-1 && padid->pNextACMDriverID == NULL) {
 679                     /* do nothing - driver is last of list */
 680                 } else {
 681                     MSACM_RePositionDriver(padid, dwPriority);
 682                     bPerformBroadcast = TRUE;
 683                 }
 684             }
 685
 686             /* Check whether driver ID should be enabled or disabled */
 687             if (fdwPriority & ACM_DRIVERPRIORITYF_DISABLE) {
 688                 if (!(padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED)) {
 689                     padid->fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
 690                     bPerformBroadcast = TRUE;
 691                 }
 692             } else if (fdwPriority & ACM_DRIVERPRIORITYF_ENABLE) {
 693                 if (padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) {
 694                     padid->fdwSupport &= ~ACMDRIVERDETAILS_SUPPORTF_DISABLED;
 695                     bPerformBroadcast = TRUE;
 696                 }
 697             }
 698         }
 699
 700         if (panwnd) {
 701             if (dwPriority) {
 702                 return MMSYSERR_NOTSUPPORTED;
 703             }
 704
 705             /* Check whether notify window should be enabled or disabled */
 706             if (fdwPriority & ACM_DRIVERPRIORITYF_DISABLE) {
 707                 if (!(panwnd->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED)) {
 708                     panwnd->fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
 709                     bPerformBroadcast = TRUE;
 710                 }
 711             } else if (fdwPriority & ACM_DRIVERPRIORITYF_ENABLE) {
 712                 if (panwnd->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) {
 713                     panwnd->fdwSupport &= ~ACMDRIVERDETAILS_SUPPORTF_DISABLED;
 714                     bPerformBroadcast = TRUE;
 715                 }
 716             }
 717         }
 718
 719         /* Perform broadcast of changes */
 720         if (bPerformBroadcast) {
 721             MSACM_WriteCurrentPriorities();
 722             MSACM_BroadcastNotification();
 723         }
 724         return MMSYSERR_NOERROR;
 725     }
 726 }
 727
 728 /***********************************************************************
 729  *           acmDriverRemove (MSACM32.@)
 730  */
 731 MMRESULT WINAPI acmDriverRemove(HACMDRIVERID hadid, DWORD fdwRemove)
 732 {
 733     PWINE_ACMDRIVERID padid;
 734     PWINE_ACMNOTIFYWND panwnd;
 735
 736     TRACE("(%p, %08x)\n", hadid, fdwRemove);
 737
 738     padid = MSACM_GetDriverID(hadid);
 739     panwnd = MSACM_GetNotifyWnd(hadid);
 740     if (!padid && !panwnd) {
 741         WARN("invalid handle\n");
 742         return MMSYSERR_INVALHANDLE;
 743     }
 744
 745     if (fdwRemove) {
 746         WARN("invalid flag\n");
 747         return MMSYSERR_INVALFLAG;
 748     }
 749
 750     if (padid) MSACM_UnregisterDriver(padid);
 751     if (panwnd) MSACM_UnRegisterNotificationWindow(panwnd);
 752     MSACM_BroadcastNotification();
 753
 754     return MMSYSERR_NOERROR;
 755 }