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 "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     pad;
  80     PWINE_ACMDRIVERID   padid;
  81     PWINE_ACMDRIVER*    tpad;
  82
  83     if (fdwClose)
  84         return MMSYSERR_INVALFLAG;
  85
  86     pad = MSACM_GetDriver(had);
  87     if (!pad)
  88         return MMSYSERR_INVALHANDLE;
  89
  90     padid = pad->obj.pACMDriverID;
  91
  92     /* remove driver from list */
  93     for (tpad = &(padid->pACMDriverList); *tpad; *tpad = (*tpad)->pNextACMDriver) {
  94         if (*tpad == pad) {
  95             *tpad = (*tpad)->pNextACMDriver;
  96             break;
  97         }
  98     }
  99
 100     /* close driver if it has been opened */
 101     if (pad->hDrvr && !padid->hInstModule)
 102         CloseDriver(pad->hDrvr, 0, 0);
 103
 104     HeapFree(MSACM_hHeap, 0, pad);
 105
 106     return MMSYSERR_NOERROR;
 107 }
 108
 109 /***********************************************************************
 110  *           acmDriverDetailsA (MSACM32.5)
 111  */
 112 MMRESULT WINAPI acmDriverDetailsA(HACMDRIVERID hadid, PACMDRIVERDETAILSA padd, DWORD fdwDetails)
 113 {
 114     MMRESULT mmr;
 115     ACMDRIVERDETAILSW   addw;
 116
 117     addw.cbStruct = sizeof(addw);
 118     mmr = acmDriverDetailsW(hadid, &addw, fdwDetails);
 119     if (mmr == 0) {
 120         padd->fccType = addw.fccType;
 121         padd->fccComp = addw.fccComp;
 122         padd->wMid = addw.wMid;
 123         padd->wPid = addw.wPid;
 124         padd->vdwACM = addw.vdwACM;
 125         padd->vdwDriver = addw.vdwDriver;
 126         padd->fdwSupport = addw.fdwSupport;
 127         padd->cFormatTags = addw.cFormatTags;
 128         padd->cFilterTags = addw.cFilterTags;
 129         padd->hicon = addw.hicon;
 130         lstrcpyWtoA(padd->szShortName, addw.szShortName);
 131         lstrcpyWtoA(padd->szLongName, addw.szLongName);
 132         lstrcpyWtoA(padd->szCopyright, addw.szCopyright);
 133         lstrcpyWtoA(padd->szLicensing, addw.szLicensing);
 134         lstrcpyWtoA(padd->szFeatures, addw.szFeatures);
 135     }
 136     return mmr;
 137 }
 138
 139 /***********************************************************************
 140  *           acmDriverDetailsW (MSACM32.6)
 141  */
 142 MMRESULT WINAPI acmDriverDetailsW(HACMDRIVERID hadid, PACMDRIVERDETAILSW padd, DWORD fdwDetails)
 143 {
 144     HACMDRIVER acmDrvr;
 145     MMRESULT mmr;
 146
 147     if (fdwDetails)
 148         return MMSYSERR_INVALFLAG;
 149
 150     mmr = acmDriverOpen(&acmDrvr, hadid, 0);
 151     if (mmr == MMSYSERR_NOERROR) {
 152         mmr = (MMRESULT)MSACM_Message(acmDrvr, ACMDM_DRIVER_DETAILS, (LPARAM)padd,  0);
 153
 154         acmDriverClose(acmDrvr, 0);
 155     }
 156
 157     return mmr;
 158 }
 159
 160 /***********************************************************************
 161  *           acmDriverEnum (MSACM32.7)
 162  */
 163 MMRESULT WINAPI acmDriverEnum(ACMDRIVERENUMCB fnCallback, DWORD dwInstance, DWORD fdwEnum)
 164 {
 165     PWINE_ACMDRIVERID   p;
 166     ACMDRIVERDETAILSW   add;
 167
 168     if (!fnCallback) return MMSYSERR_INVALPARAM;
 169
 170     if (fdwEnum && ~(ACM_DRIVERENUMF_NOLOCAL|ACM_DRIVERENUMF_DISABLED))
 171         return MMSYSERR_INVALFLAG;
 172
 173     add.cbStruct = sizeof(add);
 174     for (p = MSACM_pFirstACMDriverID; p; p = p->pNextACMDriverID) {
 175         if (acmDriverDetailsW((HACMDRIVERID)p, &add, 0) != MMSYSERR_NOERROR)
 176             continue;
 177         if (!p->bEnabled) {
 178             if (fdwEnum & ACM_DRIVERENUMF_DISABLED)
 179                 add.fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
 180             else
 181                 continue;
 182         }
 183         if (!(*fnCallback)((HACMDRIVERID)p, dwInstance, add.fdwSupport))
 184             break;
 185     }
 186
 187     return MMSYSERR_NOERROR;
 188 }
 189
 190 /***********************************************************************
 191  *           acmDriverID (MSACM32.8)
 192  */
 193 MMRESULT WINAPI acmDriverID(HACMOBJ hao, PHACMDRIVERID phadid, DWORD fdwDriverID)
 194 {
 195     PWINE_ACMOBJ pao;
 196
 197     if (!phadid)
 198         return MMSYSERR_INVALPARAM;
 199
 200     if (fdwDriverID)
 201         return MMSYSERR_INVALFLAG;
 202
 203     pao = MSACM_GetObj(hao, WINE_ACMOBJ_DONTCARE);
 204     if (!pao)
 205         return MMSYSERR_INVALHANDLE;
 206
 207     *phadid = (HACMDRIVERID) pao->pACMDriverID;
 208
 209     return MMSYSERR_NOERROR;
 210 }
 211
 212 /***********************************************************************
 213  *           acmDriverMessage (MSACM32.9)
 214  *
 215  */
 216 LRESULT WINAPI acmDriverMessage(HACMDRIVER had, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
 217 {
 218     if ((uMsg >= ACMDM_USER && uMsg < ACMDM_RESERVED_LOW) ||
 219         uMsg == ACMDM_DRIVER_ABOUT ||
 220         uMsg == DRV_QUERYCONFIGURE ||
 221         uMsg == DRV_CONFIGURE)
 222         return MSACM_Message(had, uMsg, lParam1, lParam2);
 223     return MMSYSERR_INVALPARAM;
 224 }
 225
 226
 227 /***********************************************************************
 228  *           acmDriverOpen (MSACM32.10)
 229  */
 230 MMRESULT WINAPI acmDriverOpen(PHACMDRIVER phad, HACMDRIVERID hadid, DWORD fdwOpen)
 231 {
 232     PWINE_ACMDRIVERID   padid;
 233     PWINE_ACMDRIVER     pad;
 234
 235     TRACE("(%p, %x, %08lu)\n", phad, hadid, fdwOpen);
 236
 237     if (!phad)
 238         return MMSYSERR_INVALPARAM;
 239
 240     if (fdwOpen)
 241         return MMSYSERR_INVALFLAG;
 242
 243     padid = MSACM_GetDriverID(hadid);
 244     if (!padid)
 245         return MMSYSERR_INVALHANDLE;
 246
 247     pad = HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMDRIVER));
 248     if (!pad) return MMSYSERR_NOMEM;
 249
 250     pad->obj.dwType = WINE_ACMOBJ_DRIVER;
 251     pad->obj.pACMDriverID = padid;
 252
 253     if (!(pad->hDrvr = padid->hInstModule) && padid->pszDriverAlias)
 254         pad->hDrvr = OpenDriverA(padid->pszDriverAlias, NULL, 0);
 255     if (!pad->hDrvr) {
 256         HeapFree(MSACM_hHeap, 0, pad);
 257         return MMSYSERR_ERROR;
 258     }
 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     TRACE("'%s' => %08lx\n", padid->pszDriverAlias, (DWORD)pad);
 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