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
  10 #include <stdio.h>
  11
  12 #include "winbase.h"
  13 #include "winerror.h"
  14 #include "windef.h"
  15 #include "wingdi.h"
  16 #include "winuser.h"
  17 #include "debugtools.h"
  18 #include "heap.h"
  19 #include "mmsystem.h"
  20 #include "msacm.h"
  21 #include "msacmdrv.h"
  22 #include "wineacm.h"
  23 #include "winreg.h"
  24
  25 DEFAULT_DEBUG_CHANNEL(msacm);
  26
  27 /***********************************************************************
  28  *           acmDriverAddA (MSACM32.2)
  29  */
  30 MMRESULT WINAPI acmDriverAddA(PHACMDRIVERID phadid, HINSTANCE hinstModule,
  31                               LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
  32 {
  33     if (!phadid)
  34         return MMSYSERR_INVALPARAM;
  35
  36     /* Check if any unknown flags */
  37     if (fdwAdd &
  38         ~(ACM_DRIVERADDF_FUNCTION|ACM_DRIVERADDF_NOTIFYHWND|
  39           ACM_DRIVERADDF_GLOBAL))
  40         return MMSYSERR_INVALFLAG;
  41
  42     /* Check if any incompatible flags */
  43     if ((fdwAdd & ACM_DRIVERADDF_FUNCTION) &&
  44         (fdwAdd & ACM_DRIVERADDF_NOTIFYHWND))
  45         return MMSYSERR_INVALFLAG;
  46
  47     /* FIXME: in fact, should GetModuleFileName(hinstModule) and do a
  48      * LoadDriver on it, to be sure we can call SendDriverMessage on the
  49      * hDrvr handle.
  50      */
  51     *phadid = (HACMDRIVERID) MSACM_RegisterDriver(NULL, NULL, hinstModule);
  52
  53     /* FIXME: lParam, dwPriority and fdwAdd ignored */
  54
  55     return MMSYSERR_NOERROR;
  56 }
  57
  58 /***********************************************************************
  59  *           acmDriverAddW (MSACM32.3)
  60  * FIXME
  61  *   Not implemented
  62  */
  63 MMRESULT WINAPI acmDriverAddW(PHACMDRIVERID phadid, HINSTANCE hinstModule,
  64                               LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
  65 {
  66     FIXME("(%p, 0x%08x, %ld, %ld, %ld): stub\n",
  67           phadid, hinstModule, lParam, dwPriority, fdwAdd);
  68
  69     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  70     return MMSYSERR_ERROR;
  71 }
  72
  73 /***********************************************************************
  74  *           acmDriverClose (MSACM32.4)
  75  */
  76 MMRESULT WINAPI acmDriverClose(HACMDRIVER had, DWORD fdwClose)
  77 {
  78     PWINE_ACMDRIVER  p;
  79     PWINE_ACMDRIVER* tp;
  80
  81     if (fdwClose)
  82         return MMSYSERR_INVALFLAG;
  83
  84     p = MSACM_GetDriver(had);
  85     if (!p)
  86         return MMSYSERR_INVALHANDLE;
  87
  88     for (tp = &(p->obj.pACMDriverID->pACMDriverList); *tp; *tp = (*tp)->pNextACMDriver) {
  89         if (*tp == p) {
  90             *tp = (*tp)->pNextACMDriver;
  91             break;
  92         }
  93     }
  94
  95     if (p->hDrvr && !p->obj.pACMDriverID->pACMDriverList)
  96         CloseDriver(p->hDrvr, 0, 0);
  97
  98     HeapFree(MSACM_hHeap, 0, p);
  99
 100     return MMSYSERR_NOERROR;
 101 }
 102
 103 /***********************************************************************
 104  *           acmDriverDetailsA (MSACM32.5)
 105  */
 106 MMRESULT WINAPI acmDriverDetailsA(HACMDRIVERID hadid, PACMDRIVERDETAILSA padd, DWORD fdwDetails)
 107 {
 108     MMRESULT mmr;
 109     ACMDRIVERDETAILSW   addw;
 110
 111     addw.cbStruct = sizeof(addw);
 112     mmr = acmDriverDetailsW(hadid, &addw, fdwDetails);
 113     if (mmr == 0) {
 114         padd->fccType = addw.fccType;
 115         padd->fccComp = addw.fccComp;
 116         padd->wMid = addw.wMid;
 117         padd->wPid = addw.wPid;
 118         padd->vdwACM = addw.vdwACM;
 119         padd->vdwDriver = addw.vdwDriver;
 120         padd->fdwSupport = addw.fdwSupport;
 121         padd->cFormatTags = addw.cFormatTags;
 122         padd->cFilterTags = addw.cFilterTags;
 123         padd->hicon = addw.hicon;
 124         lstrcpyWtoA(padd->szShortName, addw.szShortName);
 125         lstrcpyWtoA(padd->szLongName, addw.szLongName);
 126         lstrcpyWtoA(padd->szCopyright, addw.szCopyright);
 127         lstrcpyWtoA(padd->szLicensing, addw.szLicensing);
 128         lstrcpyWtoA(padd->szFeatures, addw.szFeatures);
 129     }
 130     return mmr;
 131 }
 132
 133 /***********************************************************************
 134  *           acmDriverDetailsW (MSACM32.6)
 135  */
 136 MMRESULT WINAPI acmDriverDetailsW(HACMDRIVERID hadid, PACMDRIVERDETAILSW padd, DWORD fdwDetails)
 137 {
 138     HACMDRIVER acmDrvr;
 139     MMRESULT mmr;
 140
 141     if (fdwDetails)
 142         return MMSYSERR_INVALFLAG;
 143
 144     mmr = acmDriverOpen(&acmDrvr, hadid, 0);
 145     if (mmr == MMSYSERR_NOERROR) {
 146         mmr = (MMRESULT)MSACM_Message(acmDrvr, ACMDM_DRIVER_DETAILS, (LPARAM)padd,  0);
 147
 148         acmDriverClose(acmDrvr, 0);
 149     }
 150
 151     return mmr;
 152 }
 153
 154 /***********************************************************************
 155  *           acmDriverEnum (MSACM32.7)
 156  */
 157 MMRESULT WINAPI acmDriverEnum(ACMDRIVERENUMCB fnCallback, DWORD dwInstance, DWORD fdwEnum)
 158 {
 159     PWINE_ACMDRIVERID   p;
 160     ACMDRIVERDETAILSW   add;
 161
 162     if (!fnCallback) return MMSYSERR_INVALPARAM;
 163
 164     if (fdwEnum && ~(ACM_DRIVERENUMF_NOLOCAL|ACM_DRIVERENUMF_DISABLED))
 165         return MMSYSERR_INVALFLAG;
 166
 167     add.cbStruct = sizeof(add);
 168     for (p = MSACM_pFirstACMDriverID; p; p = p->pNextACMDriverID) {
 169         if (acmDriverDetailsW((HACMDRIVERID)p, &add, 0) != MMSYSERR_NOERROR)
 170             continue;
 171         if (!p->bEnabled) {
 172             if (fdwEnum & ACM_DRIVERENUMF_DISABLED)
 173                 add.fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
 174             else
 175                 continue;
 176         }
 177         if (!(*fnCallback)((HACMDRIVERID)p, dwInstance, add.fdwSupport))
 178             break;
 179     }
 180
 181     return MMSYSERR_NOERROR;
 182 }
 183
 184 /***********************************************************************
 185  *           acmDriverID (MSACM32.8)
 186  */
 187 MMRESULT WINAPI acmDriverID(HACMOBJ hao, PHACMDRIVERID phadid, DWORD fdwDriverID)
 188 {
 189     PWINE_ACMOBJ pao;
 190
 191     if (!phadid)
 192         return MMSYSERR_INVALPARAM;
 193
 194     if (fdwDriverID)
 195         return MMSYSERR_INVALFLAG;
 196
 197     pao = MSACM_GetObj(hao, WINE_ACMOBJ_DONTCARE);
 198     if (!pao)
 199         return MMSYSERR_INVALHANDLE;
 200
 201     *phadid = (HACMDRIVERID) pao->pACMDriverID;
 202
 203     return MMSYSERR_NOERROR;
 204 }
 205
 206 /***********************************************************************
 207  *           acmDriverMessage (MSACM32.9)
 208  *
 209  */
 210 LRESULT WINAPI acmDriverMessage(HACMDRIVER had, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
 211 {
 212     if ((uMsg >= ACMDM_USER && uMsg < ACMDM_RESERVED_LOW) ||
 213         uMsg == ACMDM_DRIVER_ABOUT ||
 214         uMsg == DRV_QUERYCONFIGURE ||
 215         uMsg == DRV_CONFIGURE)
 216         return MSACM_Message(had, uMsg, lParam1, lParam2);
 217     return MMSYSERR_INVALPARAM;
 218 }
 219
 220
 221 /***********************************************************************
 222  *           acmDriverOpen (MSACM32.10)
 223  */
 224 MMRESULT WINAPI acmDriverOpen(PHACMDRIVER phad, HACMDRIVERID hadid, DWORD fdwOpen)
 225 {
 226     PWINE_ACMDRIVERID   padid;
 227     PWINE_ACMDRIVER     pad;
 228
 229     TRACE("(%p, %x, %08lu)\n", phad, hadid, fdwOpen);
 230
 231     if (!phad)
 232         return MMSYSERR_INVALPARAM;
 233
 234     padid = MSACM_GetDriverID(hadid);
 235     if (!padid)
 236         return MMSYSERR_INVALHANDLE;
 237
 238     if (fdwOpen)
 239         return MMSYSERR_INVALFLAG;
 240
 241     pad = HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMDRIVER));
 242     if (!pad) return MMSYSERR_NOMEM;
 243
 244     pad->obj.dwType = WINE_ACMOBJ_DRIVER;
 245     pad->obj.pACMDriverID = padid;
 246
 247     if (!padid->hInstModule)
 248         pad->hDrvr = OpenDriverA(padid->pszDriverAlias, "drivers32", 0);
 249     else
 250         pad->hDrvr = padid->hInstModule;
 251
 252     if (!pad->hDrvr) {
 253         HeapFree(MSACM_hHeap, 0, pad);
 254         return MMSYSERR_ERROR;
 255     }
 256
 257     pad->pfnDriverProc = GetProcAddress(pad->hDrvr, "DriverProc");
 258
 259     /* insert new pad at beg of list */
 260     pad->pNextACMDriver = padid->pACMDriverList;
 261     padid->pACMDriverList = pad;
 262
 263     /* FIXME: Create a WINE_ACMDRIVER32 */
 264     *phad = (HACMDRIVER)pad;
 265
 266     return MMSYSERR_NOERROR;
 267 }
 268
 269 /***********************************************************************
 270  *           acmDriverPriority (MSACM32.11)
 271  */
 272 MMRESULT WINAPI acmDriverPriority(HACMDRIVERID hadid, DWORD dwPriority, DWORD fdwPriority)
 273 {
 274     PWINE_ACMDRIVERID padid;
 275     CHAR szSubKey[17];
 276     CHAR szBuffer[256];
 277     LONG lBufferLength = sizeof(szBuffer);
 278     LONG lError;
 279     HKEY hPriorityKey;
 280     DWORD dwPriorityCounter;
 281
 282     padid = MSACM_GetDriverID(hadid);
 283     if (!padid)
 284         return MMSYSERR_INVALHANDLE;
 285
 286     /* Check for unknown flags */
 287     if (fdwPriority &
 288         ~(ACM_DRIVERPRIORITYF_ENABLE|ACM_DRIVERPRIORITYF_DISABLE|
 289           ACM_DRIVERPRIORITYF_BEGIN|ACM_DRIVERPRIORITYF_END))
 290         return MMSYSERR_INVALFLAG;
 291
 292     /* Check for incompatible flags */
 293     if ((fdwPriority & ACM_DRIVERPRIORITYF_ENABLE) &&
 294         (fdwPriority & ACM_DRIVERPRIORITYF_DISABLE))
 295         return MMSYSERR_INVALFLAG;
 296
 297     /* Check for incompatible flags */
 298     if ((fdwPriority & ACM_DRIVERPRIORITYF_BEGIN) &&
 299         (fdwPriority & ACM_DRIVERPRIORITYF_END))
 300         return MMSYSERR_INVALFLAG;
 301
 302     lError = RegOpenKeyA(HKEY_CURRENT_USER,
 303                          "Software\\Microsoft\\Multimedia\\"
 304                          "Audio Compression Manager\\Priority v4.00",
 305                          &hPriorityKey
 306                          );
 307     /* FIXME: Create key */
 308     if (lError != ERROR_SUCCESS)
 309         return MMSYSERR_ERROR;
 310
 311     for (dwPriorityCounter = 1; ; dwPriorityCounter++)  {
 312         snprintf(szSubKey, 17, "Priorty%ld", dwPriorityCounter);
 313         lError = RegQueryValueA(hPriorityKey, szSubKey, szBuffer, &lBufferLength);
 314         if (lError != ERROR_SUCCESS)
 315             break;
 316
 317         FIXME("(0x%08x, %ld, %ld): stub (partial)\n",
 318               hadid, dwPriority, fdwPriority);
 319         break;
 320     }
 321
 322     RegCloseKey(hPriorityKey);
 323
 324     return MMSYSERR_ERROR;
 325 }
 326
 327 /***********************************************************************
 328  *           acmDriverRemove (MSACM32.12)
 329  */
 330 MMRESULT WINAPI acmDriverRemove(HACMDRIVERID hadid, DWORD fdwRemove)
 331 {
 332     PWINE_ACMDRIVERID padid;
 333
 334     padid = MSACM_GetDriverID(hadid);
 335     if (!padid)
 336         return MMSYSERR_INVALHANDLE;
 337
 338     if (fdwRemove)
 339         return MMSYSERR_INVALFLAG;
 340
 341     MSACM_UnregisterDriver(padid);
 342
 343     return MMSYSERR_NOERROR;
 344 }
 345