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