git.oblomov.eu Git - wine/blob - dlls/msacm32/driver.c

   1 /*
   2  *      MSACM32 library
   3  *
   4  *      Copyright 1998  Patrik Stridvall
   5  */
   6
   7 #include "winbase.h"
   8 #include "winerror.h"
   9 #include "windef.h"
  10 #include "winuser.h"
  11 #include "debug.h"
  12 #include "driver.h"
  13 #include "heap.h"
  14 #include "mmsystem.h"
  15 #include "msacm.h"
  16 #include "msacmdrv.h"
  17 #include "winreg.h"
  18
  19 /***********************************************************************
  20  *           acmDriverAddA (MSACM32.2)
  21  */
  22 MMRESULT WINAPI acmDriverAddA(
  23   PHACMDRIVERID phadid, HINSTANCE hinstModule,
  24   LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
  25 {
  26   PWINE_ACMLOCALDRIVER pld;
  27   if(!phadid)
  28     return MMSYSERR_INVALPARAM;
  29
  30   /* Check if any unknown flags */
  31   if(fdwAdd &
  32      ~(ACM_DRIVERADDF_FUNCTION|ACM_DRIVERADDF_NOTIFYHWND|
  33        ACM_DRIVERADDF_GLOBAL))
  34     return MMSYSERR_INVALFLAG;
  35
  36   /* Check if any incompatible flags */
  37   if((fdwAdd & ACM_DRIVERADDF_FUNCTION) &&
  38      (fdwAdd & ACM_DRIVERADDF_NOTIFYHWND))
  39     return MMSYSERR_INVALFLAG;
  40
  41   pld = HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMLOCALDRIVER));
  42   pld->pfnDriverProc = (DRIVERPROC)
  43     GetProcAddress(hinstModule, "DriverProc");
  44   *phadid = (HACMDRIVERID) MSACM_RegisterDriver(NULL, NULL, pld);
  45
  46   /* FIXME: lParam, dwPriority and fdwAdd ignored */
  47
  48   return MMSYSERR_NOERROR;
  49 }
  50
  51 /***********************************************************************
  52  *           acmDriverAddW (MSACM32.3)
  53  * FIXME
  54  *   Not implemented
  55  */
  56 MMRESULT WINAPI acmDriverAddW(
  57   PHACMDRIVERID phadid, HINSTANCE hinstModule,
  58   LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
  59 {
  60   FIXME(msacm, "(%p, 0x%08x, %ld, %ld, %ld): stub\n",
  61     phadid, hinstModule, lParam, dwPriority, fdwAdd
  62   );
  63   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  64   return MMSYSERR_ERROR;
  65 }
  66
  67 /***********************************************************************
  68  *           acmDriverClose (MSACM32.4)
  69  */
  70 MMRESULT WINAPI acmDriverClose(
  71   HACMDRIVER had, DWORD fdwClose)
  72 {
  73   PWINE_ACMDRIVER p;
  74
  75   if(fdwClose)
  76     return MMSYSERR_INVALFLAG;
  77
  78   p = MSACM_GetDriver(had);
  79   if(!p)
  80     return MMSYSERR_INVALHANDLE;
  81
  82   p->obj.pACMDriverID->pACMDriver = NULL;
  83
  84   /* FIXME: CloseDriver32 not implemented */
  85 #if 0
  86   if(p->hDrvr)
  87     CloseDriver(p->hDrvr, 0, 0);
  88 #endif
  89
  90   HeapFree(MSACM_hHeap, 0, p);
  91
  92   return MMSYSERR_NOERROR;
  93 }
  94
  95 /***********************************************************************
  96  *           acmDriverDetailsA (MSACM32.5)
  97  */
  98 MMRESULT WINAPI acmDriverDetailsA(
  99   HACMDRIVERID hadid, PACMDRIVERDETAILSA padd, DWORD fdwDetails)
 100 {
 101   PWINE_ACMDRIVERID p;
 102   MMRESULT mmr;
 103   BOOL bOpenTemporary;
 104
 105   p = MSACM_GetDriverID(hadid);
 106   if(!p)
 107     return MMSYSERR_INVALHANDLE;
 108
 109   if(fdwDetails)
 110     return MMSYSERR_INVALFLAG;
 111
 112   bOpenTemporary = !p->pACMDriver;
 113   if(bOpenTemporary) {
 114     bOpenTemporary = TRUE;
 115     acmDriverOpen((PHACMDRIVER) &p->pACMDriver, hadid, 0);
 116   }
 117
 118   /* FIXME
 119    *   How does the driver know if the ANSI or
 120    *   the UNICODE variant of PACMDRIVERDETAILS is used?
 121    *   It might check cbStruct or does it only accept ANSI.
 122    */
 123   mmr = (MMRESULT) acmDriverMessage(
 124     (HACMDRIVER) p->pACMDriver, ACMDM_DRIVER_DETAILS,
 125     (LPARAM) padd,  0
 126   );
 127
 128   if(bOpenTemporary) {
 129     acmDriverClose((HACMDRIVER) p->pACMDriver, 0);
 130     p->pACMDriver = NULL;
 131   }
 132
 133   return mmr;
 134 }
 135
 136 /***********************************************************************
 137  *           acmDriverDetailsW (MSACM32.6)
 138  * FIXME
 139  *   Not implemented
 140  */
 141 MMRESULT WINAPI acmDriverDetailsW(
 142   HACMDRIVERID hadid, PACMDRIVERDETAILSW padd, DWORD fdwDetails)
 143 {
 144   FIXME(msacm, "(0x%08x, %p, %ld): stub\n", hadid, padd, fdwDetails);
 145   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 146   return MMSYSERR_ERROR;
 147 }
 148
 149 /***********************************************************************
 150  *           acmDriverEnum (MSACM32.7)
 151  */
 152 MMRESULT WINAPI acmDriverEnum(
 153   ACMDRIVERENUMCB fnCallback, DWORD dwInstance, DWORD fdwEnum)
 154 {
 155   PWINE_ACMDRIVERID p;
 156
 157   if(!fnCallback)
 158     {
 159       return MMSYSERR_INVALPARAM;
 160     }
 161
 162   if(fdwEnum && ~(ACM_DRIVERENUMF_NOLOCAL|ACM_DRIVERENUMF_DISABLED))
 163     {
 164       return MMSYSERR_INVALFLAG;
 165     }
 166
 167   p = MSACM_pFirstACMDriverID;
 168   while(p)
 169     {
 170       (*fnCallback)((HACMDRIVERID) p, dwInstance, ACMDRIVERDETAILS_SUPPORTF_CODEC);
 171       p = p->pNextACMDriverID;
 172     }
 173
 174   return MMSYSERR_NOERROR;
 175 }
 176
 177 /***********************************************************************
 178  *           acmDriverID (MSACM32.8)
 179  */
 180 MMRESULT WINAPI acmDriverID(
 181   HACMOBJ hao, PHACMDRIVERID phadid, DWORD fdwDriverID)
 182 {
 183   PWINE_ACMOBJ pao;
 184
 185   pao = MSACM_GetObj(hao);
 186   if(!pao)
 187     return MMSYSERR_INVALHANDLE;
 188
 189   if(!phadid)
 190     return MMSYSERR_INVALPARAM;
 191
 192   if(fdwDriverID)
 193     return MMSYSERR_INVALFLAG;
 194
 195   *phadid = (HACMDRIVERID) pao->pACMDriverID;
 196
 197   return MMSYSERR_NOERROR;
 198 }
 199
 200 /***********************************************************************
 201  *           acmDriverMessage (MSACM32.9)
 202  * FIXME
 203  *   Not implemented
 204  */
 205 LRESULT WINAPI acmDriverMessage(
 206   HACMDRIVER had, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
 207 {
 208   PWINE_ACMDRIVER pad = MSACM_GetDriver(had);
 209   if(!pad)
 210     return MMSYSERR_INVALPARAM;
 211
 212   /* FIXME: Check if uMsg legal */
 213
 214   if(!SendDriverMessage(pad->hDrvr, uMsg, lParam1, lParam2))
 215     return MMSYSERR_NOTSUPPORTED;
 216
 217   return MMSYSERR_NOERROR;
 218 }
 219
 220
 221 /***********************************************************************
 222  *           acmDriverOpen (MSACM32.10)
 223  */
 224 MMRESULT WINAPI acmDriverOpen(
 225   PHACMDRIVER phad, HACMDRIVERID hadid, DWORD fdwOpen)
 226 {
 227   PWINE_ACMDRIVERID padid;
 228
 229   if(!phad)
 230     return MMSYSERR_INVALPARAM;
 231
 232   padid = MSACM_GetDriverID(hadid);
 233   if(!padid)
 234     return MMSYSERR_INVALHANDLE;
 235
 236   if(fdwOpen)
 237     return MMSYSERR_INVALFLAG;
 238
 239   if(padid->pACMDriver)
 240     {
 241       /* FIXME: Is it allowed? */
 242       ERR(msacm, "Can't open driver twice\n");
 243       return MMSYSERR_ERROR;
 244     }
 245
 246   padid->pACMDriver = HeapAlloc(
 247     MSACM_hHeap, 0, sizeof(WINE_ACMDRIVER)
 248   );
 249   padid->pACMDriver->obj.pACMDriverID = padid;
 250
 251   if(!padid->pACMLocalDriver)
 252       padid->pACMDriver->hDrvr =
 253         OpenDriverA(padid->pszDriverAlias, "drivers32", 0);
 254   else
 255     {
 256       padid->pACMDriver->hDrvr = MSACM_OpenDriverProc(
 257         padid->pACMLocalDriver->pfnDriverProc
 258       );
 259     }
 260
 261   if(!padid->pACMDriver->hDrvr)
 262     return MMSYSERR_ERROR;
 263
 264   /* FIXME: Create a WINE_ACMDRIVER32 */
 265   *phad = (HACMDRIVER) NULL;
 266
 267   return MMSYSERR_ERROR;
 268 }
 269
 270 /***********************************************************************
 271  *           acmDriverPriority (MSACM32.11)
 272  */
 273 MMRESULT WINAPI acmDriverPriority(
 274   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   {
 315     wsnprintfA(szSubKey, 17, "Priorty%ld", dwPriorityCounter);
 316     lError = RegQueryValueA(hPriorityKey, szSubKey, szBuffer, &lBufferLength);
 317     if(lError != ERROR_SUCCESS)
 318       break;
 319
 320     FIXME(msacm, "(0x%08x, %ld, %ld): stub (partial)\n",
 321       hadid, dwPriority, fdwPriority
 322     );
 323     break;
 324   }
 325
 326   RegCloseKey(hPriorityKey);
 327
 328   return MMSYSERR_ERROR;
 329 }
 330
 331 /***********************************************************************
 332  *           acmDriverRemove (MSACM32.12)
 333  */
 334 MMRESULT WINAPI acmDriverRemove(
 335   HACMDRIVERID hadid, DWORD fdwRemove)
 336 {
 337   PWINE_ACMDRIVERID padid;
 338
 339   padid = MSACM_GetDriverID(hadid);
 340   if(!padid)
 341     return MMSYSERR_INVALHANDLE;
 342
 343   if(fdwRemove)
 344     return MMSYSERR_INVALFLAG;
 345
 346   MSACM_UnregisterDriver(padid);
 347
 348   return MMSYSERR_NOERROR;
 349 }
 350