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

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