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