programs/winecfg/audio.c

   1 /*
   2  * Audio management UI code
   3  *
   4  * Copyright 2004 Chris Morgan
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  */
  21
  22 #define WIN32_LEAN_AND_MEAN
  23 #define NONAMELESSSTRUCT
  24 #define NONAMELESSUNION
  25
  26 #include "config.h"
  27 #include "wine/port.h"
  28
  29 #include <assert.h>
  30 #include <stdlib.h>
  31 #include <stdio.h>
  32 #include <string.h>
  33
  34 #include <windows.h>
  35 #include <wine/debug.h>
  36 #include <shellapi.h>
  37 #include <objbase.h>
  38 #include <shlguid.h>
  39 #include <shlwapi.h>
  40 #include <shlobj.h>
  41 #include <mmsystem.h>
  42 #include <mmreg.h>
  43 #include <mmddk.h>
  44
  45 #include "winecfg.h"
  46 #include "resource.h"
  47
  48 WINE_DEFAULT_DEBUG_CHANNEL(winecfg);
  49
  50 #define DRIVER_MASK 0x80000000
  51 #define DEVICE_MASK 0x40000000
  52 #define MAX_NAME_LENGTH 64
  53
  54 typedef DWORD (WINAPI * MessagePtr)(UINT, UINT, DWORD_PTR, DWORD_PTR, DWORD_PTR);
  55
  56 static struct DSOUNDACCEL
  57 {
  58   UINT displayID;
  59   UINT visible;
  60   const char* settingStr;
  61 } DSound_HW_Accels[] = {
  62   {IDS_ACCEL_FULL,      1, "Full"},
  63   {IDS_ACCEL_STANDARD,  0, "Standard"},
  64   {IDS_ACCEL_BASIC,     0, "Basic"},
  65   {IDS_ACCEL_EMULATION, 1, "Emulation"},
  66   {0, 0, 0}
  67 };
  68
  69 static const char* DSound_Rates[] = {
  70   "48000",
  71   "44100",
  72   "22050",
  73   "16000",
  74   "11025",
  75   "8000",
  76   NULL
  77 };
  78
  79 static const char* DSound_Bits[] = {
  80   "8",
  81   "16",
  82   NULL
  83 };
  84
  85 typedef struct
  86 {
  87   UINT nameID;
  88   const char *szDriver;
  89   HDRVR hDriver;
  90 } AUDIO_DRIVER;
  91
  92 static AUDIO_DRIVER sAudioDrivers[] = {
  93   {IDS_DRIVER_PULSE,     "pulse"},
  94   {IDS_DRIVER_ALSA,      "alsa"},
  95   {IDS_DRIVER_OSS,       "oss"},
  96   {IDS_DRIVER_COREAUDIO, "coreaudio"},
  97   {IDS_DRIVER_JACK,      "jack"},
  98 #if 0
  99   {IDS_DRIVER_NAS,       "nas"},
 100 #endif
 101   {IDS_DRIVER_ESOUND,    "esd"},
 102   {IDS_DRIVER_AUDIOIO,   "audioio"},
 103   {0, ""}
 104 };
 105
 106 /* list of available drivers */
 107 static AUDIO_DRIVER * loadedAudioDrv;
 108
 109 /* local copy of registry setting */
 110 static char curAudioDriver[1024];
 111
 112 /* driver index to configure */
 113 static int toConfigure;
 114
 115 /* display a driver specific configuration dialog */
 116 static void configureAudioDriver(HWND hDlg)
 117 {
 118     const AUDIO_DRIVER *pAudioDrv = &loadedAudioDrv[toConfigure];
 119
 120     if (strlen(pAudioDrv->szDriver) != 0)
 121     {
 122         HDRVR hdrvr;
 123         char wine_driver[MAX_NAME_LENGTH + 9];
 124         sprintf(wine_driver, "wine%s.drv", pAudioDrv->szDriver);
 125         hdrvr = pAudioDrv->hDriver;
 126         if (hdrvr != 0)
 127         {
 128             if (SendDriverMessage(hdrvr, DRV_QUERYCONFIGURE, 0, 0) != 0)
 129             {
 130                 DRVCONFIGINFO dci;
 131                 dci.dwDCISize = sizeof (dci);
 132                 dci.lpszDCISectionName = NULL;
 133                 dci.lpszDCIAliasName = NULL;
 134                 SendDriverMessage(hdrvr, DRV_CONFIGURE, 0, (LONG_PTR)&dci);
 135             }
 136         }
 137         else
 138         {
 139             WCHAR wine_driverW[MAX_NAME_LENGTH+9];
 140             WCHAR messageStr[256];
 141             WCHAR str[1024];
 142
 143             MultiByteToWideChar (CP_ACP, 0, wine_driver, -1, wine_driverW,
 144                 sizeof (wine_driverW)/sizeof(wine_driverW[0]));
 145
 146             LoadStringW (GetModuleHandle (NULL), IDS_OPEN_DRIVER_ERROR, messageStr,
 147                 sizeof(messageStr)/sizeof(messageStr[0]));
 148             wsprintfW (str, messageStr, wine_driverW);
 149             MessageBoxW (hDlg, str, NULL, MB_OK | MB_ICONERROR);
 150         }
 151     }
 152 }
 153
 154 /* is driver in local copy of driver registry string */
 155 static BOOL isDriverSet(const char * driver)
 156 {
 157     WINE_TRACE("driver = %s, curAudioDriver = %s\n", driver, curAudioDriver);
 158
 159     if (strstr(curAudioDriver, driver))
 160         return TRUE;
 161
 162     return FALSE;
 163 }
 164
 165 /* add driver to local copy of driver registry string */
 166 static void addDriver(const char * driver)
 167 {
 168     if (!isDriverSet(driver))
 169     {
 170         if (strlen(curAudioDriver))
 171             strcat(curAudioDriver, ",");
 172         strcat(curAudioDriver, driver);
 173     }
 174 }
 175
 176 /* remove driver from local copy of driver registry string */
 177 static void removeDriver(const char * driver)
 178 {
 179     char pattern[32], *p;
 180     int drvlen, listlen;
 181
 182     strcpy(pattern, ",");
 183     strcat(pattern, driver);
 184     strcat(pattern, ",");
 185     drvlen = strlen(driver);
 186     listlen = strlen(curAudioDriver);
 187
 188     p = strstr(curAudioDriver, pattern);
 189     if (p) /* somewhere in the middle */
 190         memmove(p, p+drvlen+1, strlen(p+drvlen+1)+1);
 191     else if (!strncmp(curAudioDriver, pattern+1, drvlen+1)) /* the head */
 192         memmove(curAudioDriver, curAudioDriver+drvlen+1, listlen-drvlen);
 193     else if (!strncmp(curAudioDriver+listlen-drvlen-1, pattern, drvlen+1)) /* the tail */
 194         curAudioDriver[listlen-drvlen-1] = 0;
 195     else if (!strcmp(curAudioDriver, driver)) /* only one entry (head&tail) */
 196         curAudioDriver[0] = 0;
 197     else
 198         WINE_FIXME("driver '%s' is not in the list, please report!\n", driver);
 199 }
 200
 201 static void initAudioDeviceTree(HWND hDlg)
 202 {
 203     AUDIO_DRIVER *pAudioDrv = NULL;
 204     int i, j;
 205     TVINSERTSTRUCTW insert;
 206     HTREEITEM root, driver[10];
 207     HWND tree = NULL;
 208     HIMAGELIST hImageList;
 209     HBITMAP hBitMap;
 210     HCURSOR old_cursor;
 211     WCHAR driver_type[64], dev_type[64];
 212
 213     tree = GetDlgItem(hDlg, IDC_AUDIO_TREE);
 214
 215     if (!tree)
 216         return;
 217
 218     /* set tree view style */
 219     SetWindowLong(tree, GWL_STYLE, GetWindowLong(tree, GWL_STYLE) | TVS_HASBUTTONS | TVS_HASLINES | TVS_LINESATROOT);
 220
 221     /* state checkbox */
 222     hImageList = ImageList_Create(16, 16, FALSE, 3, 0);
 223     hBitMap = LoadBitmap(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_CHECKBOX));
 224     ImageList_Add(hImageList, hBitMap, NULL);
 225     DeleteObject(hBitMap);
 226     SendMessageW( tree, TVM_SETIMAGELIST, TVSIL_STATE, (LPARAM)hImageList );
 227
 228     /* root item */
 229     LoadStringW (GetModuleHandle (NULL), IDS_SOUNDDRIVERS, driver_type,
 230         sizeof(driver_type)/sizeof(driver_type[0]));
 231     insert.hParent = TVI_ROOT;
 232     insert.hInsertAfter = TVI_LAST;
 233     insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN;
 234     insert.u.item.pszText = driver_type;
 235     insert.u.item.cChildren = 1;
 236     root = (HTREEITEM)SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 237
 238     /* change to the wait cursor because this can take a while if there is a
 239      * misbehaving driver that takes a long time to open
 240      */
 241     old_cursor = SetCursor(LoadCursor(0, IDC_WAIT));
 242
 243     /* iterate over list of loaded drivers */
 244     for (pAudioDrv = loadedAudioDrv, i = 0; pAudioDrv->nameID; i++, pAudioDrv++) {
 245         HDRVR hdrv;
 246         char name[MAX_PATH];
 247         WCHAR text[MAX_PATH];
 248
 249         sprintf(name, "wine%s.drv", pAudioDrv->szDriver);
 250         LoadStringW (GetModuleHandle (NULL), pAudioDrv->nameID, text,
 251             sizeof(text)/sizeof(text[0]));
 252
 253         if ((hdrv = pAudioDrv->hDriver))
 254         {
 255             HMODULE lib;
 256             if ((lib = GetDriverModuleHandle(hdrv)))
 257             {
 258                 int num_wod = 0, num_wid = 0, num_mod = 0, num_mid = 0, num_aux = 0, num_mxd = 0;
 259                 MessagePtr wodMessagePtr = (MessagePtr)GetProcAddress(lib, "wodMessage");
 260                 MessagePtr widMessagePtr = (MessagePtr)GetProcAddress(lib, "widMessage");
 261                 MessagePtr modMessagePtr = (MessagePtr)GetProcAddress(lib, "modMessage");
 262                 MessagePtr midMessagePtr = (MessagePtr)GetProcAddress(lib, "midMessage");
 263                 MessagePtr auxMessagePtr = (MessagePtr)GetProcAddress(lib, "auxMessage");
 264                 MessagePtr mxdMessagePtr = (MessagePtr)GetProcAddress(lib, "mxdMessage");
 265
 266                 if (wodMessagePtr)
 267                     num_wod = wodMessagePtr(0, WODM_GETNUMDEVS, 0, 0, 0);
 268
 269                 if (widMessagePtr)
 270                     num_wid = widMessagePtr(0, WIDM_GETNUMDEVS, 0, 0, 0);
 271
 272                 if (modMessagePtr)
 273                     num_mod = modMessagePtr(0, MODM_GETNUMDEVS, 0, 0, 0);
 274
 275                 if (midMessagePtr)
 276                     num_mid = midMessagePtr(0, MIDM_GETNUMDEVS, 0, 0, 0);
 277
 278                 if (auxMessagePtr)
 279                     num_aux = auxMessagePtr(0, AUXDM_GETNUMDEVS, 0, 0, 0);
 280
 281                 if (mxdMessagePtr)
 282                     num_mxd = mxdMessagePtr(0, MXDM_GETNUMDEVS, 0, 0, 0);
 283
 284                 if (num_wod == 0 && num_wid == 0 && num_mod == 0 && num_mid == 0 && num_aux == 0 && num_mxd == 0)
 285                 {
 286                     insert.hParent = root;
 287                     insert.u.item.mask = TVIF_TEXT | TVIF_STATE | TVIF_PARAM;
 288                     insert.u.item.pszText = text;
 289                     insert.u.item.stateMask = TVIS_STATEIMAGEMASK;
 290                     insert.u.item.lParam =  i + DRIVER_MASK;
 291                     if (isDriverSet(pAudioDrv->szDriver))
 292                         insert.u.item.state = INDEXTOSTATEIMAGEMASK(2);
 293                     else
 294                         insert.u.item.state = INDEXTOSTATEIMAGEMASK(1);
 295
 296                     driver[i] = (HTREEITEM)SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 297                 }
 298                 else
 299                 {
 300                     HTREEITEM type;
 301
 302                     insert.hParent = root;
 303                     insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN | TVIF_STATE | TVIF_PARAM;
 304                     insert.u.item.pszText = text;
 305                     insert.u.item.cChildren = 1;
 306                     insert.u.item.stateMask = TVIS_STATEIMAGEMASK;
 307                     insert.u.item.lParam =  i + DRIVER_MASK;
 308
 309                     if (isDriverSet(pAudioDrv->szDriver))
 310                         insert.u.item.state = INDEXTOSTATEIMAGEMASK(2);
 311                     else
 312                         insert.u.item.state = INDEXTOSTATEIMAGEMASK(1);
 313
 314                     driver[i] = (HTREEITEM)SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 315
 316                     if (num_wod)
 317                     {
 318                         LoadStringW (GetModuleHandle (NULL), IDS_DEVICES_WAVEOUT, dev_type,
 319                             sizeof(dev_type)/sizeof(dev_type[0]));
 320
 321                         insert.hParent = driver[i];
 322                         insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN;
 323                         insert.u.item.pszText = dev_type;
 324                         insert.u.item.cChildren = 1;
 325
 326                         type = (HTREEITEM)SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 327
 328                         for (j = 0; j < num_wod; j++)
 329                         {
 330                             WAVEOUTCAPSW caps;
 331
 332                             wodMessagePtr(j, WODM_GETDEVCAPS, 0, (DWORD_PTR)&caps, sizeof(caps));
 333
 334                             insert.hParent = type;
 335                             insert.u.item.mask = TVIF_TEXT | TVIF_PARAM;
 336                             insert.u.item.pszText = caps.szPname;
 337                             insert.u.item.lParam = j + DEVICE_MASK;
 338
 339                             SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 340                         }
 341                     }
 342
 343                     if (num_wid)
 344                     {
 345                         LoadStringW (GetModuleHandle (NULL), IDS_DEVICES_WAVEIN, dev_type,
 346                             sizeof(dev_type)/sizeof(dev_type[0]));
 347
 348                         insert.hParent = driver[i];
 349                         insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN;
 350                         insert.u.item.pszText = dev_type;
 351                         insert.u.item.cChildren = 1;
 352
 353                         type = (HTREEITEM)SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 354
 355                         for (j = 0; j < num_wid; j++)
 356                         {
 357                             WAVEINCAPSW caps;
 358
 359                             widMessagePtr(j, WIDM_GETDEVCAPS, 0, (DWORD_PTR)&caps, sizeof(caps));
 360
 361                             insert.hParent = type;
 362                             insert.u.item.mask = TVIF_TEXT | TVIF_PARAM;
 363                             insert.u.item.pszText = caps.szPname;
 364                             insert.u.item.lParam = j + DEVICE_MASK;
 365
 366                             SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 367                         }
 368                     }
 369
 370                     if (num_mod)
 371                     {
 372                         LoadStringW (GetModuleHandle (NULL), IDS_DEVICES_MIDIOUT, dev_type,
 373                             sizeof(dev_type)/sizeof(dev_type[0]));
 374
 375                         insert.hParent = driver[i];
 376                         insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN;
 377                         insert.u.item.pszText = dev_type;
 378                         insert.u.item.cChildren = 1;
 379
 380                         type = (HTREEITEM)SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 381
 382                         for (j = 0; j < num_mod; j++)
 383                         {
 384                             MIDIOUTCAPSW caps;
 385
 386                             modMessagePtr(j, MODM_GETDEVCAPS, 0, (DWORD_PTR)&caps, sizeof(caps));
 387
 388                             insert.hParent = type;
 389                             insert.u.item.mask = TVIF_TEXT | TVIF_PARAM;
 390                             insert.u.item.pszText = caps.szPname;
 391                             insert.u.item.lParam = j + DEVICE_MASK;
 392
 393                             SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 394                         }
 395                     }
 396
 397                     if (num_mid)
 398                     {
 399                         LoadStringW (GetModuleHandle (NULL), IDS_DEVICES_MIDIIN, dev_type,
 400                             sizeof(dev_type)/sizeof(dev_type[0]));
 401
 402                         insert.hParent = driver[i];
 403                         insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN;
 404                         insert.u.item.pszText = dev_type;
 405                         insert.u.item.cChildren = 1;
 406
 407                         type = (HTREEITEM)SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 408
 409                         for (j = 0; j < num_mid; j++)
 410                         {
 411                             MIDIINCAPSW caps;
 412
 413                             midMessagePtr(j, MIDM_GETDEVCAPS, 0, (DWORD_PTR)&caps, sizeof(caps));
 414
 415                             insert.hParent = type;
 416                             insert.u.item.mask = TVIF_TEXT | TVIF_PARAM;
 417                             insert.u.item.pszText = caps.szPname;
 418                             insert.u.item.lParam = j + DEVICE_MASK;
 419
 420                             SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 421                         }
 422                     }
 423
 424                     if (num_aux)
 425                     {
 426                         LoadStringW (GetModuleHandle (NULL), IDS_DEVICES_AUX, dev_type,
 427                             sizeof(dev_type)/sizeof(dev_type[0]));
 428
 429                         insert.hParent = driver[i];
 430                         insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN;
 431                         insert.u.item.pszText = dev_type;
 432                         insert.u.item.cChildren = 1;
 433
 434                         type = (HTREEITEM)SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 435
 436                         for (j = 0; j < num_aux; j++)
 437                         {
 438                             AUXCAPSW caps;
 439
 440                             auxMessagePtr(j, AUXDM_GETDEVCAPS, 0, (DWORD_PTR)&caps, sizeof(caps));
 441
 442                             insert.hParent = type;
 443                             insert.u.item.mask = TVIF_TEXT | TVIF_PARAM;
 444                             insert.u.item.pszText = caps.szPname;
 445                             insert.u.item.lParam = j + DEVICE_MASK;
 446
 447                             SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 448                         }
 449                     }
 450
 451                     if (num_mxd)
 452                     {
 453                         LoadStringW (GetModuleHandle (NULL), IDS_DEVICES_MIXER, dev_type,
 454                             sizeof(dev_type)/sizeof(dev_type[0]));
 455
 456                         insert.hParent = driver[i];
 457                         insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN;
 458                         insert.u.item.pszText = dev_type;
 459                         insert.u.item.cChildren = 1;
 460
 461                         type = (HTREEITEM)SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 462
 463                         for (j = 0; j < num_mxd; j++)
 464                         {
 465                             MIXERCAPSW caps;
 466
 467                             mxdMessagePtr(j, MXDM_GETDEVCAPS, 0, (DWORD_PTR)&caps, sizeof(caps));
 468
 469                             insert.hParent = type;
 470                             insert.u.item.mask = TVIF_TEXT | TVIF_PARAM;
 471                             insert.u.item.pszText = caps.szPname;
 472                             insert.u.item.lParam = j + DEVICE_MASK;
 473
 474                             SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 475                         }
 476                     }
 477                 }
 478             }
 479         }
 480     }
 481
 482     /* restore the original cursor */
 483     SetCursor(old_cursor);
 484
 485     SendDlgItemMessage(hDlg, IDC_AUDIO_TREE, TVM_SELECTITEM, 0, 0);
 486     SendDlgItemMessage(hDlg, IDC_AUDIO_TREE, TVM_EXPAND, TVE_EXPAND, (LPARAM)root);
 487     for (j = 0; j < i; j++)
 488         SendDlgItemMessage(hDlg, IDC_AUDIO_TREE, TVM_EXPAND, TVE_EXPAND, (LPARAM)driver[j]);
 489 }
 490
 491 /* find all drivers that can be loaded */
 492 static void findAudioDrivers(void)
 493 {
 494     int numFound = 0;
 495     AUDIO_DRIVER *pAudioDrv = NULL;
 496     HCURSOR old_cursor;
 497
 498     /* delete an existing list */
 499     HeapFree(GetProcessHeap(), 0, loadedAudioDrv);
 500     loadedAudioDrv = 0;
 501
 502     /* change to the wait cursor because this can take a while if there is a
 503      * misbehaving driver that takes a long time to open
 504      */
 505     old_cursor = SetCursor(LoadCursor(0, IDC_WAIT));
 506
 507     for (pAudioDrv = sAudioDrivers; pAudioDrv->nameID; pAudioDrv++)
 508     {
 509         if (strlen(pAudioDrv->szDriver))
 510         {
 511             HDRVR hdrv;
 512             char driver[MAX_PATH];
 513
 514             sprintf(driver, "wine%s.drv", pAudioDrv->szDriver);
 515
 516             hdrv = pAudioDrv->hDriver;
 517             if (!pAudioDrv->hDriver && (hdrv = OpenDriverA(driver, 0, 0))) {
 518                 HMODULE lib = GetDriverModuleHandle(hdrv);
 519                 MessagePtr wodMessagePtr = (MessagePtr)GetProcAddress(lib, "wodMessage");
 520                 MessagePtr widMessagePtr = (MessagePtr)GetProcAddress(lib, "widMessage");
 521                 MessagePtr modMessagePtr = (MessagePtr)GetProcAddress(lib, "modMessage");
 522                 MessagePtr midMessagePtr = (MessagePtr)GetProcAddress(lib, "midMessage");
 523                 MessagePtr auxMessagePtr = (MessagePtr)GetProcAddress(lib, "auxMessage");
 524                 MessagePtr mxdMessagePtr = (MessagePtr)GetProcAddress(lib, "mxdMessage");
 525
 526                 pAudioDrv->hDriver = hdrv;
 527
 528                 if (wodMessagePtr)
 529                     wodMessagePtr(0, DRVM_INIT, 0, 0, 0);
 530
 531                 if (widMessagePtr)
 532                     widMessagePtr(0, DRVM_INIT, 0, 0, 0);
 533
 534                 if (modMessagePtr)
 535                     modMessagePtr(0, DRVM_INIT, 0, 0, 0);
 536
 537                 if (midMessagePtr)
 538                     midMessagePtr(0, DRVM_INIT, 0, 0, 0);
 539
 540                 if (auxMessagePtr)
 541                     auxMessagePtr(0, DRVM_INIT, 0, 0, 0);
 542
 543                 if (mxdMessagePtr)
 544                     mxdMessagePtr(0, DRVM_INIT, 0, 0, 0);
 545             }
 546             if (hdrv)
 547             {
 548                 if (loadedAudioDrv)
 549                     loadedAudioDrv = HeapReAlloc(GetProcessHeap(), 0, loadedAudioDrv, (numFound + 1) * sizeof(AUDIO_DRIVER));
 550                 else
 551                     loadedAudioDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(AUDIO_DRIVER));
 552
 553                 CopyMemory(&loadedAudioDrv[numFound], pAudioDrv, sizeof(AUDIO_DRIVER));
 554                 numFound++;
 555             }
 556         }
 557     }
 558
 559     /* restore the original cursor */
 560     SetCursor(old_cursor);
 561
 562     /* terminate list with empty driver */
 563     if (numFound) {
 564         loadedAudioDrv = HeapReAlloc(GetProcessHeap(), 0, loadedAudioDrv, (numFound + 1) * sizeof(AUDIO_DRIVER));
 565         CopyMemory(&loadedAudioDrv[numFound], pAudioDrv, sizeof(AUDIO_DRIVER));
 566     } else {
 567         loadedAudioDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(AUDIO_DRIVER));
 568         CopyMemory(&loadedAudioDrv[0], pAudioDrv, sizeof(AUDIO_DRIVER));
 569     }
 570 }
 571
 572 /* check local copy of registry string for unloadable drivers */
 573 static void checkRegistrySetting(HWND hDlg)
 574 {
 575     const AUDIO_DRIVER *pAudioDrv;
 576     char * token, * tokens;
 577
 578     tokens = HeapAlloc(GetProcessHeap(), 0, strlen(curAudioDriver)+1);
 579     strcpy(tokens, curAudioDriver);
 580
 581 start_over:
 582     token = strtok(tokens, ",");
 583     while (token != NULL)
 584     {
 585         BOOL found = FALSE;
 586         for (pAudioDrv = loadedAudioDrv; pAudioDrv->nameID; pAudioDrv++)
 587         {
 588             if (strcmp(token, pAudioDrv->szDriver) == 0)
 589             {
 590                 found = TRUE;
 591                 break;
 592             }
 593         }
 594         if (found == FALSE)
 595         {
 596             WCHAR tokenW[MAX_NAME_LENGTH+1];
 597             WCHAR messageStr[256];
 598             WCHAR str[1024];
 599             WCHAR caption[64];
 600
 601             MultiByteToWideChar (CP_ACP, 0, token, -1, tokenW, sizeof(tokenW)/sizeof(tokenW[0]));
 602
 603             LoadStringW (GetModuleHandle (NULL), IDS_UNAVAILABLE_DRIVER, messageStr,
 604                 sizeof(messageStr)/sizeof(messageStr[0]));
 605             wsprintfW (str, messageStr, tokenW);
 606             LoadStringW (GetModuleHandle (NULL), IDS_WARNING, caption,
 607                 sizeof(caption)/sizeof(caption[0]));
 608             if (MessageBoxW (hDlg, str, caption, MB_ICONWARNING | MB_YESNOCANCEL) == IDYES)
 609             {
 610                 removeDriver(token);
 611                 strcpy(tokens, curAudioDriver);
 612                 goto start_over;
 613             }
 614         }
 615         token = strtok(NULL, ",");
 616     }
 617     HeapFree(GetProcessHeap(), 0, tokens);
 618 }
 619
 620 static void selectDriver(HWND hDlg, const char * driver)
 621 {
 622     WCHAR text[1024];
 623     WCHAR caption[64];
 624
 625     strcpy(curAudioDriver, driver);
 626     set_reg_key(config_key, "Drivers", "Audio", curAudioDriver);
 627
 628     if (LoadStringW(GetModuleHandle(NULL), IDS_AUDIO_MISSING, text, sizeof(text)/sizeof(text[0])))
 629     {
 630         if (LoadStringW(GetModuleHandle(NULL), IDS_WINECFG_TITLE, caption, sizeof(caption)/sizeof(caption[0])))
 631             MessageBoxW(hDlg, text, caption, MB_OK | MB_ICONINFORMATION);
 632     }
 633
 634     SendMessage(GetParent(hDlg), PSM_CHANGED, (WPARAM) hDlg, 0); /* enable apply button */
 635 }
 636
 637 static void initAudioDlg (HWND hDlg)
 638 {
 639     int i, j, found;
 640     char* buf = NULL;
 641
 642     WINE_TRACE("\n");
 643
 644     /* make a list of all drivers that can be loaded */
 645     findAudioDrivers();
 646
 647     /* get current registry setting if available */
 648     buf = get_reg_key(config_key, "Drivers", "Audio", NULL);
 649
 650     /* check for first time install and set a default driver
 651      * select first available driver, and if that fails: none
 652      */
 653     if (buf == NULL)
 654     {
 655         /* select first available driver */
 656         if (*loadedAudioDrv->szDriver)
 657             selectDriver(hDlg, loadedAudioDrv->szDriver);
 658     }
 659     else /* make a local copy of the current registry setting */
 660         strcpy(curAudioDriver, buf);
 661
 662     WINE_TRACE("curAudioDriver = %s\n", curAudioDriver);
 663
 664     /* check for drivers that can't be loaded */
 665     checkRegistrySetting(hDlg);
 666
 667     initAudioDeviceTree(hDlg);
 668
 669     SendDlgItemMessage(hDlg, IDC_DSOUND_HW_ACCEL, CB_RESETCONTENT, 0, 0);
 670     buf = get_reg_key(config_key, keypath("DirectSound"), "HardwareAcceleration", "Full");
 671
 672     j = found = 0;
 673     for (i = 0; 0 != DSound_HW_Accels[i].displayID; ++i) {
 674       WCHAR accelStr[64];
 675       int match;
 676
 677       match = (strcmp(buf, DSound_HW_Accels[i].settingStr) == 0);
 678       if (match)
 679       {
 680         DSound_HW_Accels[i].visible = 1;
 681         found = 1;
 682       }
 683
 684       if (DSound_HW_Accels[i].visible)
 685       {
 686         LoadStringW (GetModuleHandle (NULL), DSound_HW_Accels[i].displayID,
 687                      accelStr, sizeof(accelStr)/sizeof(accelStr[0]));
 688         SendDlgItemMessageW (hDlg, IDC_DSOUND_HW_ACCEL, CB_ADDSTRING, 0, (LPARAM)accelStr);
 689         if (match)
 690           SendDlgItemMessage(hDlg, IDC_DSOUND_HW_ACCEL, CB_SETCURSEL, j, 0);
 691         j++;
 692       }
 693     }
 694     if (!found) {
 695       WINE_ERR("Invalid Direct Sound HW Accel read from registry (%s)\n", buf);
 696     }
 697     HeapFree(GetProcessHeap(), 0, buf);
 698
 699     SendDlgItemMessage(hDlg, IDC_DSOUND_RATES, CB_RESETCONTENT, 0, 0);
 700     for (i = 0; NULL != DSound_Rates[i]; ++i) {
 701       SendDlgItemMessage(hDlg, IDC_DSOUND_RATES, CB_ADDSTRING, 0, (LPARAM) DSound_Rates[i]);
 702     }
 703     buf = get_reg_key(config_key, keypath("DirectSound"), "DefaultSampleRate", "44100");
 704     for (i = 0; NULL != DSound_Rates[i]; ++i) {
 705       if (strcmp(buf, DSound_Rates[i]) == 0) {
 706         SendDlgItemMessage(hDlg, IDC_DSOUND_RATES, CB_SETCURSEL, i, 0);
 707         break ;
 708       }
 709     }
 710
 711     SendDlgItemMessage(hDlg, IDC_DSOUND_BITS, CB_RESETCONTENT, 0, 0);
 712     for (i = 0; NULL != DSound_Bits[i]; ++i) {
 713       SendDlgItemMessage(hDlg, IDC_DSOUND_BITS, CB_ADDSTRING, 0, (LPARAM) DSound_Bits[i]);
 714     }
 715     buf = get_reg_key(config_key, keypath("DirectSound"), "DefaultBitsPerSample", "16");
 716     for (i = 0; NULL != DSound_Bits[i]; ++i) {
 717       if (strcmp(buf, DSound_Bits[i]) == 0) {
 718         SendDlgItemMessage(hDlg, IDC_DSOUND_BITS, CB_SETCURSEL, i, 0);
 719         break ;
 720       }
 721     }
 722     HeapFree(GetProcessHeap(), 0, buf);
 723 }
 724
 725 INT_PTR CALLBACK
 726 AudioDlgProc (HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
 727 {
 728   switch (uMsg) {
 729       case WM_COMMAND:
 730         switch (LOWORD(wParam)) {
 731           case IDC_AUDIO_CONFIGURE:
 732              configureAudioDriver(hDlg);
 733              break;
 734           case IDC_AUDIO_TEST:
 735              if(!PlaySound(MAKEINTRESOURCE(IDW_TESTSOUND), NULL, SND_RESOURCE | SND_SYNC))
 736                 MessageBox(NULL, "Audio test failed!", "Error", MB_OK | MB_ICONERROR);
 737              break;
 738           case IDC_AUDIO_CONTROL_PANEL:
 739              MessageBox(NULL, "Launching audio control panel not implemented yet!", "Fixme", MB_OK | MB_ICONERROR);
 740              break;
 741           case IDC_DSOUND_HW_ACCEL:
 742             if (HIWORD(wParam) == CBN_SELCHANGE) {
 743               int selected_dsound_accel;
 744               int i, j = 0;
 745
 746               SendMessage(GetParent(hDlg), PSM_CHANGED, 0, 0);
 747               selected_dsound_accel = SendDlgItemMessage(hDlg, IDC_DSOUND_HW_ACCEL, CB_GETCURSEL, 0, 0);
 748               for (i = 0; DSound_HW_Accels[i].settingStr; ++i)
 749               {
 750                 if (DSound_HW_Accels[i].visible)
 751                 {
 752                   if (j == selected_dsound_accel)
 753                   {
 754                     set_reg_key(config_key, keypath("DirectSound"), "HardwareAcceleration",
 755                       DSound_HW_Accels[i].settingStr);
 756                     break;
 757                   }
 758                   j++;
 759                 }
 760               }
 761             }
 762             break;
 763           case IDC_DSOUND_RATES:
 764             if (HIWORD(wParam) == CBN_SELCHANGE) {
 765               int selected_dsound_rate;
 766               SendMessage(GetParent(hDlg), PSM_CHANGED, 0, 0);
 767               selected_dsound_rate = SendDlgItemMessage(hDlg, IDC_DSOUND_RATES, CB_GETCURSEL, 0, 0);
 768               set_reg_key(config_key, keypath("DirectSound"), "DefaultSampleRate", DSound_Rates[selected_dsound_rate]);
 769             }
 770             break;
 771           case IDC_DSOUND_BITS:
 772             if (HIWORD(wParam) == CBN_SELCHANGE) {
 773               int selected_dsound_bits;
 774               SendMessage(GetParent(hDlg), PSM_CHANGED, 0, 0);
 775               selected_dsound_bits = SendDlgItemMessage(hDlg, IDC_DSOUND_BITS, CB_GETCURSEL, 0, 0);
 776               set_reg_key(config_key, keypath("DirectSound"), "DefaultBitsPerSample", DSound_Bits[selected_dsound_bits]);
 777             }
 778             break;
 779         }
 780         break;
 781
 782       case WM_SHOWWINDOW:
 783         set_window_title(hDlg);
 784         break;
 785
 786       case WM_NOTIFY:
 787         switch(((LPNMHDR)lParam)->code) {
 788             case PSN_KILLACTIVE:
 789               SetWindowLongPtr(hDlg, DWLP_MSGRESULT, FALSE);
 790               break;
 791             case PSN_APPLY:
 792               set_reg_key(config_key, "Drivers", "Audio", curAudioDriver);
 793               apply();
 794               SetWindowLongPtr(hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
 795               break;
 796             case PSN_SETACTIVE:
 797               break;
 798             case NM_CLICK:
 799               if (((LPNMHDR)lParam)->idFrom == IDC_AUDIO_TREE)
 800               {
 801                   TVHITTESTINFO ht;
 802                   DWORD dwPos = GetMessagePos();
 803                   HWND tree = ((LPNMHDR)lParam)->hwndFrom;
 804                   ZeroMemory(&ht, sizeof(ht));
 805                   ht.pt.x = (short)LOWORD(dwPos);
 806                   ht.pt.y = (short)HIWORD(dwPos);
 807                   MapWindowPoints(HWND_DESKTOP, tree, &ht.pt, 1);
 808                   SendMessageW( tree, TVM_HITTEST, 0, (LPARAM)&ht );
 809                   if (TVHT_ONITEMSTATEICON & ht.flags)
 810                   {
 811                       TVITEM tvItem;
 812                       int index;
 813                       ZeroMemory(&tvItem, sizeof(tvItem));
 814                       tvItem.hItem = ht.hItem;
 815                       SendMessageW( tree, TVM_GETITEMW, 0, (LPARAM) &tvItem );
 816
 817                       index = TreeView_GetItemState(tree, ht.hItem, TVIS_STATEIMAGEMASK);
 818                       if (index == INDEXTOSTATEIMAGEMASK(1))
 819                       {
 820                           TreeView_SetItemState(tree, ht.hItem, INDEXTOSTATEIMAGEMASK(2), TVIS_STATEIMAGEMASK);
 821                           addDriver(loadedAudioDrv[tvItem.lParam & 0xff].szDriver);
 822                           SendMessage(GetParent(hDlg), PSM_CHANGED, (WPARAM) hDlg, 0); /* enable apply button */
 823                       }
 824                       else if (index == INDEXTOSTATEIMAGEMASK(2))
 825                       {
 826                           TreeView_SetItemState(tree, ht.hItem, INDEXTOSTATEIMAGEMASK(1), TVIS_STATEIMAGEMASK);
 827                           removeDriver(loadedAudioDrv[tvItem.lParam & 0xff].szDriver);
 828                           SendMessage(GetParent(hDlg), PSM_CHANGED, (WPARAM) hDlg, 0); /* enable apply button */
 829                       }
 830                   }
 831               }
 832               break;
 833             case NM_RCLICK:
 834               if (((LPNMHDR)lParam)->idFrom == IDC_AUDIO_TREE)
 835               {
 836                   TVHITTESTINFO ht;
 837                   DWORD dwPos = GetMessagePos();
 838                   HWND tree = ((LPNMHDR)lParam)->hwndFrom;
 839                   POINT pt;
 840                   ZeroMemory(&ht, sizeof(ht));
 841                   pt.x = (short)LOWORD(dwPos);
 842                   pt.y = (short)HIWORD(dwPos);
 843                   ht.pt = pt;
 844                   MapWindowPoints(HWND_DESKTOP, tree, &ht.pt, 1);
 845                   SendMessageW( tree, TVM_HITTEST, 0, (LPARAM)&ht );
 846                   if (TVHT_ONITEMLABEL & ht.flags)
 847                   {
 848                       TVITEM tvItem;
 849                       ZeroMemory(&tvItem, sizeof(tvItem));
 850                       tvItem.hItem = ht.hItem;
 851                       tvItem.mask = TVIF_PARAM;
 852                       tvItem.lParam = -1;
 853                       if (TreeView_GetItem(tree, &tvItem))
 854                       {
 855                           if (tvItem.lParam & DRIVER_MASK)
 856                           {
 857                               if (hPopupMenus)
 858                               {
 859                                   TrackPopupMenu(GetSubMenu(hPopupMenus, 0), TPM_RIGHTBUTTON, pt.x, pt.y, 0, tree, NULL);
 860                                   toConfigure = tvItem.lParam & ~DRIVER_MASK;
 861                               }
 862                           }
 863                           else if (tvItem.lParam & DEVICE_MASK)
 864                           {
 865                               /* FIXME TBD */
 866                           }
 867
 868                       }
 869                   }
 870               }
 871         }
 872         break;
 873
 874   case WM_INITDIALOG:
 875     initAudioDlg(hDlg);
 876     break;
 877   }
 878
 879   return FALSE;
 880 }