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