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