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 NONAMELESSUNION
  24
  25 #include "config.h"
  26 #include "wine/port.h"
  27
  28 #include <assert.h>
  29 #include <stdlib.h>
  30 #include <stdio.h>
  31 #include <string.h>
  32
  33 #define COBJMACROS
  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 "ole2.h"
  46 #include "initguid.h"
  47 #include "propkey.h"
  48 #include "devpkey.h"
  49 #include "mmdeviceapi.h"
  50 #include "audioclient.h"
  51 #include "audiopolicy.h"
  52
  53 #include "winecfg.h"
  54 #include "resource.h"
  55
  56 WINE_DEFAULT_DEBUG_CHANNEL(winecfg);
  57
  58 struct DeviceInfo {
  59     WCHAR *id;
  60     PROPVARIANT name;
  61     int speaker_config;
  62 };
  63
  64 static WCHAR g_drv_keyW[256] = {'S','o','f','t','w','a','r','e','\\',
  65     'W','i','n','e','\\','D','r','i','v','e','r','s','\\',0};
  66
  67 static const WCHAR reg_out_nameW[] = {'D','e','f','a','u','l','t','O','u','t','p','u','t',0};
  68 static const WCHAR reg_in_nameW[] = {'D','e','f','a','u','l','t','I','n','p','u','t',0};
  69 static const WCHAR reg_vout_nameW[] = {'D','e','f','a','u','l','t','V','o','i','c','e','O','u','t','p','u','t',0};
  70 static const WCHAR reg_vin_nameW[] = {'D','e','f','a','u','l','t','V','o','i','c','e','I','n','p','u','t',0};
  71
  72 static UINT num_render_devs, num_capture_devs;
  73 static struct DeviceInfo *render_devs, *capture_devs;
  74
  75 static const struct
  76 {
  77     int text_id;
  78     DWORD speaker_mask;
  79 } speaker_configs[] =
  80 {
  81     { IDS_AUDIO_SPEAKER_5POINT1, KSAUDIO_SPEAKER_5POINT1 },
  82     { IDS_AUDIO_SPEAKER_QUAD, KSAUDIO_SPEAKER_QUAD },
  83     { IDS_AUDIO_SPEAKER_STEREO, KSAUDIO_SPEAKER_STEREO },
  84     { IDS_AUDIO_SPEAKER_MONO, KSAUDIO_SPEAKER_MONO },
  85     { 0, 0 }
  86 };
  87
  88 static BOOL load_device(IMMDevice *dev, struct DeviceInfo *info)
  89 {
  90     IPropertyStore *ps;
  91     HRESULT hr;
  92     PROPVARIANT pv;
  93     UINT i;
  94
  95     hr = IMMDevice_GetId(dev, &info->id);
  96     if(FAILED(hr)){
  97         info->id = NULL;
  98         return FALSE;
  99     }
 100
 101     hr = IMMDevice_OpenPropertyStore(dev, STGM_READ, &ps);
 102     if(FAILED(hr)){
 103         CoTaskMemFree(info->id);
 104         info->id = NULL;
 105         return FALSE;
 106     }
 107
 108     PropVariantInit(&info->name);
 109
 110     hr = IPropertyStore_GetValue(ps,
 111             (PROPERTYKEY*)&DEVPKEY_Device_FriendlyName, &info->name);
 112     if(FAILED(hr)){
 113         CoTaskMemFree(info->id);
 114         info->id = NULL;
 115         IPropertyStore_Release(ps);
 116         return FALSE;
 117     }
 118
 119     PropVariantInit(&pv);
 120
 121     hr = IPropertyStore_GetValue(ps,
 122             &PKEY_AudioEndpoint_PhysicalSpeakers, &pv);
 123
 124     info->speaker_config = -1;
 125     if(SUCCEEDED(hr) && pv.vt == VT_UI4){
 126         i = 0;
 127         while (speaker_configs[i].text_id != 0) {
 128             if ((speaker_configs[i].speaker_mask & pv.u.ulVal) == speaker_configs[i].speaker_mask) {
 129                 info->speaker_config = i;
 130                 break;
 131             }
 132             i++;
 133         }
 134     }
 135
 136     /* fallback to stereo */
 137     if(info->speaker_config == -1)
 138         info->speaker_config = 2;
 139
 140     IPropertyStore_Release(ps);
 141
 142     return TRUE;
 143 }
 144
 145 static BOOL load_devices(IMMDeviceEnumerator *devenum, EDataFlow dataflow,
 146         UINT *ndevs, struct DeviceInfo **out)
 147 {
 148     IMMDeviceCollection *coll;
 149     UINT i;
 150     HRESULT hr;
 151
 152     hr = IMMDeviceEnumerator_EnumAudioEndpoints(devenum, dataflow,
 153             DEVICE_STATE_ACTIVE, &coll);
 154     if(FAILED(hr))
 155         return FALSE;
 156
 157     hr = IMMDeviceCollection_GetCount(coll, ndevs);
 158     if(FAILED(hr)){
 159         IMMDeviceCollection_Release(coll);
 160         return FALSE;
 161     }
 162
 163     if(*ndevs > 0){
 164         *out = HeapAlloc(GetProcessHeap(), 0,
 165                 sizeof(struct DeviceInfo) * (*ndevs));
 166         if(!*out){
 167             IMMDeviceCollection_Release(coll);
 168             return FALSE;
 169         }
 170
 171         for(i = 0; i < *ndevs; ++i){
 172             IMMDevice *dev;
 173
 174             hr = IMMDeviceCollection_Item(coll, i, &dev);
 175             if(FAILED(hr)){
 176                 (*out)[i].id = NULL;
 177                 continue;
 178             }
 179
 180             load_device(dev, &(*out)[i]);
 181
 182             IMMDevice_Release(dev);
 183         }
 184     }else
 185         *out = NULL;
 186
 187     IMMDeviceCollection_Release(coll);
 188
 189     return TRUE;
 190 }
 191
 192 static BOOL get_driver_name(IMMDeviceEnumerator *devenum, PROPVARIANT *pv)
 193 {
 194     IMMDevice *device;
 195     IPropertyStore *ps;
 196     HRESULT hr;
 197
 198     static const WCHAR wine_info_deviceW[] = {'W','i','n','e',' ',
 199         'i','n','f','o',' ','d','e','v','i','c','e',0};
 200
 201     hr = IMMDeviceEnumerator_GetDevice(devenum, wine_info_deviceW, &device);
 202     if(FAILED(hr))
 203         return FALSE;
 204
 205     hr = IMMDevice_OpenPropertyStore(device, STGM_READ, &ps);
 206     if(FAILED(hr)){
 207         IMMDevice_Release(device);
 208         return FALSE;
 209     }
 210
 211     hr = IPropertyStore_GetValue(ps,
 212             (const PROPERTYKEY *)&DEVPKEY_Device_Driver, pv);
 213     IPropertyStore_Release(ps);
 214     IMMDevice_Release(device);
 215     if(FAILED(hr))
 216         return FALSE;
 217
 218     return TRUE;
 219 }
 220
 221 static void initAudioDlg (HWND hDlg)
 222 {
 223     WCHAR display_str[256], format_str[256], sysdefault_str[256], disabled_str[64];
 224     IMMDeviceEnumerator *devenum;
 225     BOOL have_driver = FALSE;
 226     HRESULT hr;
 227     UINT i;
 228
 229     WINE_TRACE("\n");
 230
 231     LoadStringW(GetModuleHandleW(NULL), IDS_AUDIO_DRIVER,
 232             format_str, sizeof(format_str) / sizeof(*format_str));
 233     LoadStringW(GetModuleHandleW(NULL), IDS_AUDIO_DRIVER_NONE,
 234             disabled_str, sizeof(disabled_str) / sizeof(*disabled_str));
 235     LoadStringW(GetModuleHandleW(NULL), IDS_AUDIO_SYSDEFAULT,
 236             sysdefault_str, sizeof(sysdefault_str) / sizeof(*sysdefault_str));
 237
 238     hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL,
 239             CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, (void**)&devenum);
 240     if(SUCCEEDED(hr)){
 241         PROPVARIANT pv;
 242
 243         load_devices(devenum, eRender, &num_render_devs, &render_devs);
 244         load_devices(devenum, eCapture, &num_capture_devs, &capture_devs);
 245
 246         PropVariantInit(&pv);
 247         if(get_driver_name(devenum, &pv) && pv.u.pwszVal[0] != '\0'){
 248             have_driver = TRUE;
 249             wnsprintfW(display_str, sizeof(display_str) / sizeof(*display_str),
 250                     format_str, pv.u.pwszVal);
 251             lstrcatW(g_drv_keyW, pv.u.pwszVal);
 252         }
 253         PropVariantClear(&pv);
 254
 255         IMMDeviceEnumerator_Release(devenum);
 256     }
 257
 258     SendDlgItemMessageW(hDlg, IDC_AUDIOOUT_DEVICE, CB_ADDSTRING,
 259             0, (LPARAM)sysdefault_str);
 260     SendDlgItemMessageW(hDlg, IDC_AUDIOOUT_DEVICE, CB_SETCURSEL, 0, 0);
 261     SendDlgItemMessageW(hDlg, IDC_VOICEOUT_DEVICE, CB_ADDSTRING,
 262             0, (LPARAM)sysdefault_str);
 263     SendDlgItemMessageW(hDlg, IDC_VOICEOUT_DEVICE, CB_SETCURSEL, 0, 0);
 264
 265     SendDlgItemMessageW(hDlg, IDC_AUDIOIN_DEVICE, CB_ADDSTRING,
 266             0, (LPARAM)sysdefault_str);
 267     SendDlgItemMessageW(hDlg, IDC_AUDIOIN_DEVICE, CB_SETCURSEL, 0, 0);
 268     SendDlgItemMessageW(hDlg, IDC_VOICEIN_DEVICE, CB_ADDSTRING,
 269             0, (LPARAM)sysdefault_str);
 270     SendDlgItemMessageW(hDlg, IDC_VOICEIN_DEVICE, CB_SETCURSEL, 0, 0);
 271
 272     i = 0;
 273     while (speaker_configs[i].text_id != 0) {
 274         WCHAR speaker_str[256];
 275
 276         LoadStringW(GetModuleHandleW(NULL), speaker_configs[i].text_id,
 277             speaker_str, sizeof(speaker_str) / sizeof(*speaker_str));
 278
 279         SendDlgItemMessageW(hDlg, IDC_SPEAKERCONFIG_SPEAKERS, CB_ADDSTRING,
 280             0, (LPARAM)speaker_str);
 281
 282         i++;
 283     }
 284
 285     if(have_driver){
 286         WCHAR *reg_out_dev, *reg_vout_dev, *reg_in_dev, *reg_vin_dev;
 287         BOOL default_dev_found = FALSE;
 288
 289         reg_out_dev = get_reg_keyW(HKEY_CURRENT_USER, g_drv_keyW, reg_out_nameW, NULL);
 290         reg_vout_dev = get_reg_keyW(HKEY_CURRENT_USER, g_drv_keyW, reg_vout_nameW, NULL);
 291         reg_in_dev = get_reg_keyW(HKEY_CURRENT_USER, g_drv_keyW, reg_in_nameW, NULL);
 292         reg_vin_dev = get_reg_keyW(HKEY_CURRENT_USER, g_drv_keyW, reg_vin_nameW, NULL);
 293
 294         SendDlgItemMessageW(hDlg, IDC_SPEAKERCONFIG_DEVICE, CB_SETCURSEL, i, 0);
 295         SendDlgItemMessageW(hDlg, IDC_SPEAKERCONFIG_SPEAKERS, CB_SETCURSEL, render_devs[i].speaker_config, 0);
 296
 297         for(i = 0; i < num_render_devs; ++i){
 298             if(!render_devs[i].id)
 299                 continue;
 300
 301             SendDlgItemMessageW(hDlg, IDC_AUDIOOUT_DEVICE, CB_ADDSTRING,
 302                     0, (LPARAM)render_devs[i].name.u.pwszVal);
 303             SendDlgItemMessageW(hDlg, IDC_AUDIOOUT_DEVICE, CB_SETITEMDATA,
 304                     i + 1, (LPARAM)&render_devs[i]);
 305
 306             SendDlgItemMessageW(hDlg, IDC_SPEAKERCONFIG_DEVICE, CB_ADDSTRING,
 307                     0, (LPARAM)render_devs[i].name.u.pwszVal);
 308
 309             if(reg_out_dev && !lstrcmpW(render_devs[i].id, reg_out_dev)){
 310                 SendDlgItemMessageW(hDlg, IDC_AUDIOOUT_DEVICE, CB_SETCURSEL, i + 1, 0);
 311                 SendDlgItemMessageW(hDlg, IDC_SPEAKERCONFIG_DEVICE, CB_SETCURSEL, i, 0);
 312                 SendDlgItemMessageW(hDlg, IDC_SPEAKERCONFIG_SPEAKERS, CB_SETCURSEL, render_devs[i].speaker_config, 0);
 313                 default_dev_found = TRUE;
 314             }
 315
 316             SendDlgItemMessageW(hDlg, IDC_VOICEOUT_DEVICE, CB_ADDSTRING,
 317                     0, (LPARAM)render_devs[i].name.u.pwszVal);
 318             SendDlgItemMessageW(hDlg, IDC_VOICEOUT_DEVICE, CB_SETITEMDATA,
 319                     i + 1, (LPARAM)&render_devs[i]);
 320             if(reg_vout_dev && !lstrcmpW(render_devs[i].id, reg_vout_dev))
 321                 SendDlgItemMessageW(hDlg, IDC_VOICEOUT_DEVICE, CB_SETCURSEL, i + 1, 0);
 322         }
 323
 324         if(!default_dev_found && num_render_devs > 0){
 325             SendDlgItemMessageW(hDlg, IDC_SPEAKERCONFIG_DEVICE, CB_SETCURSEL, 0, 0);
 326             SendDlgItemMessageW(hDlg, IDC_SPEAKERCONFIG_SPEAKERS, CB_SETCURSEL, render_devs[0].speaker_config, 0);
 327         }
 328
 329         for(i = 0; i < num_capture_devs; ++i){
 330             if(!capture_devs[i].id)
 331                 continue;
 332
 333             SendDlgItemMessageW(hDlg, IDC_AUDIOIN_DEVICE, CB_ADDSTRING,
 334                     0, (LPARAM)capture_devs[i].name.u.pwszVal);
 335             SendDlgItemMessageW(hDlg, IDC_AUDIOIN_DEVICE, CB_SETITEMDATA,
 336                     i + 1, (LPARAM)&capture_devs[i]);
 337             if(reg_in_dev && !lstrcmpW(capture_devs[i].id, reg_in_dev))
 338                 SendDlgItemMessageW(hDlg, IDC_AUDIOIN_DEVICE, CB_SETCURSEL, i + 1, 0);
 339
 340             SendDlgItemMessageW(hDlg, IDC_VOICEIN_DEVICE, CB_ADDSTRING,
 341                     0, (LPARAM)capture_devs[i].name.u.pwszVal);
 342             SendDlgItemMessageW(hDlg, IDC_VOICEIN_DEVICE, CB_SETITEMDATA,
 343                     i + 1, (LPARAM)&capture_devs[i]);
 344             if(reg_vin_dev && !lstrcmpW(capture_devs[i].id, reg_vin_dev))
 345                 SendDlgItemMessageW(hDlg, IDC_VOICEIN_DEVICE, CB_SETCURSEL, i + 1, 0);
 346         }
 347
 348         HeapFree(GetProcessHeap(), 0, reg_out_dev);
 349         HeapFree(GetProcessHeap(), 0, reg_vout_dev);
 350         HeapFree(GetProcessHeap(), 0, reg_in_dev);
 351         HeapFree(GetProcessHeap(), 0, reg_vin_dev);
 352     }else
 353         wnsprintfW(display_str, sizeof(display_str) / sizeof(*display_str),
 354                 format_str, disabled_str);
 355
 356     SetDlgItemTextW(hDlg, IDC_AUDIO_DRIVER, display_str);
 357 }
 358
 359 static void set_reg_device(HWND hDlg, int dlgitem, const WCHAR *key_name)
 360 {
 361     UINT idx;
 362     struct DeviceInfo *info;
 363
 364     idx = SendDlgItemMessageW(hDlg, dlgitem, CB_GETCURSEL, 0, 0);
 365
 366     info = (struct DeviceInfo *)SendDlgItemMessageW(hDlg, dlgitem,
 367             CB_GETITEMDATA, idx, 0);
 368
 369     if(!info || info == (void*)CB_ERR)
 370         set_reg_keyW(HKEY_CURRENT_USER, g_drv_keyW, key_name, NULL);
 371     else
 372         set_reg_keyW(HKEY_CURRENT_USER, g_drv_keyW, key_name, info->id);
 373 }
 374
 375 static void test_sound(void)
 376 {
 377     if(!PlaySoundW(MAKEINTRESOURCEW(IDW_TESTSOUND), NULL, SND_RESOURCE | SND_ASYNC)){
 378         WCHAR error_str[256], title_str[256];
 379
 380         LoadStringW(GetModuleHandleW(NULL), IDS_AUDIO_TEST_FAILED,
 381                 error_str, sizeof(error_str) / sizeof(*error_str));
 382         LoadStringW(GetModuleHandleW(NULL), IDS_AUDIO_TEST_FAILED_TITLE,
 383                 title_str, sizeof(title_str) / sizeof(*title_str));
 384
 385         MessageBoxW(NULL, error_str, title_str, MB_OK | MB_ICONERROR);
 386     }
 387 }
 388
 389 static void apply_speaker_configs(void)
 390 {
 391     UINT i;
 392     IMMDeviceEnumerator *devenum;
 393     IMMDevice *dev;
 394     IPropertyStore *ps;
 395     PROPVARIANT pv;
 396     HRESULT hr;
 397
 398     hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL,
 399         CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, (void**)&devenum);
 400
 401     if(FAILED(hr)){
 402         ERR("Unable to create MMDeviceEnumerator: 0x%08x\n", hr);
 403         return;
 404     }
 405
 406     PropVariantInit(&pv);
 407     pv.vt = VT_UI4;
 408
 409     for (i = 0; i < num_render_devs; i++) {
 410         hr = IMMDeviceEnumerator_GetDevice(devenum, render_devs[i].id, &dev);
 411
 412         if(FAILED(hr)){
 413             WARN("Could not get MMDevice for %s: 0x%08x\n", wine_dbgstr_w(render_devs[i].id), hr);
 414             continue;
 415         }
 416
 417         hr = IMMDevice_OpenPropertyStore(dev, STGM_WRITE, &ps);
 418
 419         if(FAILED(hr)){
 420             WARN("Could not open property store for %s: 0x%08x\n", wine_dbgstr_w(render_devs[i].id), hr);
 421             IMMDevice_Release(dev);
 422             continue;
 423         }
 424
 425         pv.u.ulVal = speaker_configs[render_devs[i].speaker_config].speaker_mask;
 426
 427         hr = IPropertyStore_SetValue(ps, &PKEY_AudioEndpoint_PhysicalSpeakers, &pv);
 428
 429         if (FAILED(hr))
 430             WARN("IPropertyStore_SetValue failed for %s: 0x%08x\n", wine_dbgstr_w(render_devs[i].id), hr);
 431
 432         IPropertyStore_Release(ps);
 433         IMMDevice_Release(dev);
 434     }
 435
 436     IMMDeviceEnumerator_Release(devenum);
 437 }
 438
 439 INT_PTR CALLBACK
 440 AudioDlgProc (HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
 441 {
 442   switch (uMsg) {
 443       case WM_COMMAND:
 444         switch (LOWORD(wParam)) {
 445           case IDC_AUDIO_TEST:
 446               test_sound();
 447               break;
 448           case IDC_AUDIOOUT_DEVICE:
 449               if(HIWORD(wParam) == CBN_SELCHANGE){
 450                   set_reg_device(hDlg, IDC_AUDIOOUT_DEVICE, reg_out_nameW);
 451                   SendMessageW(GetParent(hDlg), PSM_CHANGED, 0, 0);
 452               }
 453               break;
 454           case IDC_VOICEOUT_DEVICE:
 455               if(HIWORD(wParam) == CBN_SELCHANGE){
 456                   set_reg_device(hDlg, IDC_VOICEOUT_DEVICE, reg_vout_nameW);
 457                   SendMessageW(GetParent(hDlg), PSM_CHANGED, 0, 0);
 458               }
 459               break;
 460           case IDC_AUDIOIN_DEVICE:
 461               if(HIWORD(wParam) == CBN_SELCHANGE){
 462                   set_reg_device(hDlg, IDC_AUDIOIN_DEVICE, reg_in_nameW);
 463                   SendMessageW(GetParent(hDlg), PSM_CHANGED, 0, 0);
 464               }
 465               break;
 466           case IDC_VOICEIN_DEVICE:
 467               if(HIWORD(wParam) == CBN_SELCHANGE){
 468                   set_reg_device(hDlg, IDC_VOICEIN_DEVICE, reg_vin_nameW);
 469                   SendMessageW(GetParent(hDlg), PSM_CHANGED, 0, 0);
 470               }
 471               break;
 472           case IDC_SPEAKERCONFIG_DEVICE:
 473               if(HIWORD(wParam) == CBN_SELCHANGE){
 474                   UINT idx;
 475
 476                   idx = SendDlgItemMessageW(hDlg, IDC_SPEAKERCONFIG_DEVICE, CB_GETCURSEL, 0, 0);
 477
 478                   if(idx < num_render_devs){
 479                       SendDlgItemMessageW(hDlg, IDC_SPEAKERCONFIG_SPEAKERS, CB_SETCURSEL, render_devs[idx].speaker_config, 0);
 480                   }
 481               }
 482               break;
 483           case IDC_SPEAKERCONFIG_SPEAKERS:
 484               if(HIWORD(wParam) == CBN_SELCHANGE){
 485                   UINT dev, idx;
 486
 487                   idx = SendDlgItemMessageW(hDlg, IDC_SPEAKERCONFIG_SPEAKERS, CB_GETCURSEL, 0, 0);
 488                   dev = SendDlgItemMessageW(hDlg, IDC_SPEAKERCONFIG_DEVICE, CB_GETCURSEL, 0, 0);
 489
 490                   if(dev < num_render_devs){
 491                       render_devs[dev].speaker_config = idx;
 492                       SendMessageW(GetParent(hDlg), PSM_CHANGED, 0, 0);
 493                   }
 494               }
 495               break;
 496         }
 497         break;
 498
 499       case WM_SHOWWINDOW:
 500         set_window_title(hDlg);
 501         break;
 502
 503       case WM_NOTIFY:
 504         switch(((LPNMHDR)lParam)->code) {
 505             case PSN_KILLACTIVE:
 506               SetWindowLongPtrW(hDlg, DWLP_MSGRESULT, FALSE);
 507               break;
 508             case PSN_APPLY:
 509               apply_speaker_configs();
 510               apply();
 511               SetWindowLongPtrW(hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
 512               break;
 513             case PSN_SETACTIVE:
 514               break;
 515         }
 516         break;
 517       case WM_INITDIALOG:
 518         initAudioDlg(hDlg);
 519         break;
 520   }
 521
 522   return FALSE;
 523 }