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