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