RouterTest/main.cpp

   1 #include <al.h>
   2 #include <alc.h>
   3 #include <stdio.h>
   4 #include <conio.h>
   5 #include <string.h>
   6 #include <windows.h>
   7 #include <mmsystem.h>
   8
   9 int main(int argc, char* argv[])
  10 {
  11         const ALchar *szNames = NULL;
  12         long lErrorCount = 0;
  13
  14         ///////////////////////////////////////////////////////////////////
  15         // TEST : Enumerate the playback devices
  16         //
  17         printf("--------------------------------------\n");
  18         printf("TESTING ALC_ENUMERATION_EXT EXTENSION\n\n");
  19         if (alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT") == AL_TRUE)
  20         {
  21                 printf("ALC_ENUMERATION_EXT Device List:-\n\n");
  22
  23                 szNames = alcGetString(NULL, ALC_DEVICE_SPECIFIER);
  24                 if (strlen(szNames) == 0)
  25                         printf("NO DEVICES FOUND\n");
  26                 else
  27                 {
  28                         while (szNames && *szNames)
  29                         {
  30                                 printf("%s ", szNames);
  31                                 // Try opening each device
  32                                 ALCdevice *pDevice = alcOpenDevice(szNames);
  33                                 if (pDevice)
  34                                 {
  35                                         printf("- Opened Successfully\n");
  36                                         alcCloseDevice(pDevice);
  37                                 }
  38                                 else
  39                                 {
  40                                         printf("- FAILED to open\n");
  41                                         lErrorCount++;
  42                                 }
  43                                 szNames += (strlen(szNames) + 1);
  44                         }
  45                 }
  46         }
  47         else
  48         {
  49                 printf("!!!ERROR!!! : ALC_ENUMERATION_EXT NOT FOUND!\n");
  50                 lErrorCount++;
  51         }
  52         printf("--------------------------------------\n\n");
  53         ///////////////////////////////////////////////////////////////////
  54
  55
  56         ///////////////////////////////////////////////////////////////////
  57         // TEST : Get Default Playback Device
  58         //
  59         printf("--------------------------------------\n");
  60         printf("TESTING GET DEFAULT PLAYBACK DEVICE\n\n");
  61         szNames = alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);
  62         if (szNames && strlen(szNames))
  63         {
  64                 printf("\nDEFAULT DEVICE is %s\n", szNames);
  65         }
  66         else
  67         {
  68                 if (waveOutGetNumDevs())
  69                 {
  70                         printf("\n!!!ERROR!!! DEFAULT DEVICE NOT FOUND!\n");
  71                         lErrorCount++;
  72                 }
  73                 else
  74                 {
  75                         printf("\nDEFAULT DEVICE NOT FOUND!\n");
  76                 }
  77         }
  78         printf("--------------------------------------\n\n");
  79         ///////////////////////////////////////////////////////////////////
  80
  81
  82         ///////////////////////////////////////////////////////////////////
  83         // TEST : Enumerate all the capture devices
  84         //
  85         printf("--------------------------------------\n");
  86         printf("TESTING CAPTURE ENUMERATION EXTENSION\n\n");
  87         if (alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT") == AL_TRUE)
  88         {
  89                 printf("ALC_ENUMERATION_EXT Capture Device List:-\n\n");
  90
  91                 szNames = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER);
  92                 if (strlen(szNames) == 0)
  93                         printf("NO DEVICES FOUND\n");
  94                 else
  95                 {
  96                         while (szNames && *szNames)
  97                         {
  98                                 printf("%s ", szNames);
  99                                 // Try opening each device
 100                                 ALCdevice *pDevice = alcCaptureOpenDevice(szNames, 11025, AL_FORMAT_STEREO16, 8192);
 101                                 if (pDevice)
 102                                 {
 103                                         printf("- Opened Successfully\n");
 104                                         alcCaptureCloseDevice(pDevice);
 105                                 }
 106                                 else
 107                                 {
 108                                         printf("- FAILED to open\n");
 109                                         lErrorCount++;
 110                                 }
 111                                 szNames += (strlen(szNames) + 1);
 112                         }
 113                 }
 114         }
 115         else
 116         {
 117                 printf("!!!ERROR!!! : ALC_ENUMERATION_EXT NOT FOUND!\n");
 118                 lErrorCount++;
 119         }
 120         printf("--------------------------------------\n\n");
 121         ///////////////////////////////////////////////////////////////////
 122
 123
 124         ///////////////////////////////////////////////////////////////////
 125         // TEST : Get Default Capture Device
 126         //
 127         printf("--------------------------------------\n");
 128         printf("TESTING DEFAULT CAPTURE DEVICE\n\n");
 129         szNames = alcGetString(NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
 130         if (szNames && strlen(szNames))
 131         {
 132                 printf("\nDEFAULT CAPTURE DEVICE IS %s\n", szNames);
 133         }
 134         else
 135         {
 136                 if (waveInGetNumDevs())
 137                 {
 138                         printf("\n!!!ERROR!!! DEFAULT CAPTURE DEVICE NOT FOUND!\n");
 139                         lErrorCount++;
 140                 }
 141                 else
 142                 {
 143                         printf("\nDEFAULT CAPTURE DEVICE NOT FOUND!\n");
 144                 }
 145         }
 146         printf("--------------------------------------\n\n");
 147         ///////////////////////////////////////////////////////////////////
 148
 149
 150         ///////////////////////////////////////////////////////////////////
 151         // TEST : Enumerate *all* the playback devices
 152         //
 153         printf("--------------------------------------\n");
 154         printf("TESTING PLAYBACK ENUMERATE ALL EXTENSION\n\n");
 155         if (alcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT") == AL_TRUE)
 156         {
 157                 printf("ALC_ENUMERATE_ALL_EXT DEVICE LIST:-\n\n");
 158
 159                 szNames = alcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER);
 160                 if (strlen(szNames) == 0)
 161                         printf("NO DEVICES FOUND\n");
 162                 else
 163                 {
 164                         while (szNames && *szNames)
 165                         {
 166                                 printf("%s ", szNames);
 167
 168                                 // Try opening each device
 169                                 ALCdevice *pDevice = alcOpenDevice(szNames);
 170                                 if (pDevice)
 171                                 {
 172                                         printf("- Opened Successfully\n");
 173                                         alcCloseDevice(pDevice);
 174                                 }
 175                                 else
 176                                 {
 177                                         printf("- FAILED to open\n");
 178                                         lErrorCount++;
 179                                 }
 180
 181                                 szNames += (strlen(szNames) + 1);
 182                         }
 183                 }
 184         }
 185         else
 186         {
 187                 printf("!!!ERROR!!! : ALC_ENUMERATE_ALL_EXT NOT FOUND!\n");
 188                 lErrorCount++;
 189         }
 190         printf("--------------------------------------\n\n");
 191         ///////////////////////////////////////////////////////////////////
 192
 193
 194         ///////////////////////////////////////////////////////////////////
 195         // TEST : Get Default *All* Playback Device
 196         //
 197         printf("--------------------------------------\n");
 198         printf("TESTING DEFAULT ALL PLAYBACK DEVICE\n\n");
 199         szNames = alcGetString(NULL, ALC_DEFAULT_ALL_DEVICES_SPECIFIER);
 200         if (szNames && strlen(szNames))
 201         {
 202                 printf("\nDEFAULT ALL DEVICES IS %s\n", szNames);
 203         }
 204         else
 205         {
 206                 if (waveOutGetNumDevs())
 207                 {
 208                         printf("\n!!!ERROR!!! DEFAULT ALL DEVICE NOT FOUND!\n");
 209                         lErrorCount++;
 210                 }
 211                 else
 212                 {
 213                         printf("\nDEFAULT ALL DEVICES NOT FOUND!\n");
 214                 }
 215         }
 216         printf("--------------------------------------\n\n");
 217         ///////////////////////////////////////////////////////////////////
 218
 219
 220         ///////////////////////////////////////////////////////////////////
 221         // TEST : Open 'Generic Hardware' device
 222         //
 223         printf("--------------------------------------\n");
 224         printf("TESTING 'Generic Hardware' DEVICE\n\n");
 225         ALCdevice *pDevice = alcOpenDevice("Generic Hardware");
 226         if (pDevice)
 227         {
 228                 printf("OPENED 'Generic Hardware' DEVICE ... GOT %s\n", alcGetString(pDevice, ALC_DEVICE_SPECIFIER));
 229                 alcCloseDevice(pDevice);
 230         }
 231         else
 232         {
 233                 if (waveOutGetNumDevs())
 234                 {
 235                         printf("!!!ERROR!!! : FAILED TO OPEN 'Generic Hardware' DEVICE\n");
 236                         lErrorCount++;
 237                 }
 238                 else
 239                 {
 240                         printf("FAILED TO OPEN 'Generic Hardware' DEVICE\n");
 241                 }
 242         }
 243         printf("--------------------------------------\n\n");
 244         ///////////////////////////////////////////////////////////////////
 245
 246
 247         ///////////////////////////////////////////////////////////////////
 248         // TEST : Open 'Generic Software' device
 249         //
 250         printf("--------------------------------------\n");
 251         printf("TESTING 'Generic Software' DEVICE\n\n");
 252         pDevice = alcOpenDevice("Generic Software");
 253         if (pDevice)
 254         {
 255                 printf("OPENED 'Generic Software' DEVICE ... GOT %s\n", alcGetString(pDevice, ALC_DEVICE_SPECIFIER));
 256                 alcCloseDevice(pDevice);
 257         }
 258         else
 259         {
 260                 if (waveOutGetNumDevs())
 261                 {
 262                         printf("!!!ERROR!!! : FAILED TO OPEN 'Generic Software' DEVICE\n");
 263                         lErrorCount++;
 264                 }
 265                 else
 266                 {
 267                         printf("FAILED TO OPEN 'Generic Software' DEVICE\n");
 268                 }
 269         }
 270         printf("--------------------------------------\n\n");
 271         ///////////////////////////////////////////////////////////////////
 272
 273         ///////////////////////////////////////////////////////////////////
 274         // TEST : Open legacy 'DirectSound3D' device
 275         //
 276         printf("--------------------------------------\n");
 277         printf("TESTING LEGACY 'DirectSound3D' DEVICE\n\n");
 278         pDevice = alcOpenDevice("DirectSound3D");
 279         if (pDevice)
 280         {
 281                 printf("OPENED 'DirectSound3D' DEVICE ... GOT %s\n", alcGetString(pDevice, ALC_DEVICE_SPECIFIER));
 282                 alcCloseDevice(pDevice);
 283         }
 284         else
 285         {
 286                 if (waveOutGetNumDevs())
 287                 {
 288                         printf("!!!ERROR!!! : FAILED TO OPEN 'DirectSound3D' DEVICE\n");
 289                         lErrorCount++;
 290                 }
 291                 else
 292                 {
 293                         printf("FAILED TO OPEN 'DirectSound3D' DEVICE\n");
 294                 }
 295         }
 296         printf("--------------------------------------\n\n");
 297         ///////////////////////////////////////////////////////////////////
 298
 299
 300         ///////////////////////////////////////////////////////////////////
 301         // TEST : Open legacy 'DirectSound' device
 302         //
 303         printf("--------------------------------------\n");
 304         printf("TESTING LEGACY 'DirectSound' DEVICE\n\n");
 305         pDevice = alcOpenDevice("DirectSound");
 306         if (pDevice)
 307         {
 308                 printf("OPENED 'DirectSound' DEVICE ... GOT %s\n", alcGetString(pDevice, ALC_DEVICE_SPECIFIER));
 309                 alcCloseDevice(pDevice);
 310         }
 311         else
 312         {
 313                 if (waveOutGetNumDevs())
 314                 {
 315                         printf("!!!ERROR!!! : FAILED TO OPEN 'DirectSound' DEVICE\n");
 316                         lErrorCount++;
 317                 }
 318                 else
 319                 {
 320                         printf("FAILED TO OPEN 'DirectSound' DEVICE\n");
 321                 }
 322         }
 323         printf("--------------------------------------\n\n");
 324         ///////////////////////////////////////////////////////////////////
 325
 326
 327         ///////////////////////////////////////////////////////////////////
 328         // TEST : Open legacy 'MMSYSTEM' device
 329         //
 330         printf("--------------------------------------\n");
 331         printf("TESTING LEGACY 'MMSYSTEM' DEVICE\n\n");
 332         pDevice = alcOpenDevice("MMSYSTEM");
 333         if (pDevice)
 334         {
 335                 printf("OPENED 'MMSYSTEM' DEVICE ... GOT %s\n", alcGetString(pDevice, ALC_DEVICE_SPECIFIER));
 336                 alcCloseDevice(pDevice);
 337         }
 338         else
 339         {
 340                 if (waveOutGetNumDevs())
 341                 {
 342                         printf("!!!ERROR!!! : FAILED TO OPEN 'MMSYSTEM' DEVICE\n");
 343                         lErrorCount++;
 344                 }
 345                 else
 346                 {
 347                         printf("FAILED TO OPEN 'MMSYSTEM' DEVICE\n");
 348                 }
 349         }
 350         printf("--------------------------------------\n\n");
 351         ///////////////////////////////////////////////////////////////////
 352
 353
 354         ///////////////////////////////////////////////////////////////////
 355         // TEST : Open NULL device
 356         //
 357         printf("--------------------------------------\n");
 358         printf("TESTING NULL DEVICE\n\n");
 359         pDevice = alcOpenDevice(NULL);
 360         if (pDevice)
 361         {
 362                 printf("OPENED NULL DEVICE ... GOT %s\n", alcGetString(pDevice, ALC_DEVICE_SPECIFIER));
 363                 alcCloseDevice(pDevice);
 364         }
 365         else
 366         {
 367                 if (waveOutGetNumDevs())
 368                 {
 369                         printf("!!!ERROR!!! : FAILED TO OPEN NULL DEVICE\n");
 370                         lErrorCount++;
 371                 }
 372                 else
 373                 {
 374                         printf("FAILED TO OPEN NULL DEVICE\n");
 375                 }
 376         }
 377         printf("--------------------------------------\n\n");
 378         ///////////////////////////////////////////////////////////////////
 379
 380
 381         ///////////////////////////////////////////////////////////////////
 382         // TEST : Open "" device
 383         //
 384         printf("--------------------------------------\n");
 385         printf("TESTING EMPTY DEVICE\n\n");
 386         pDevice = alcOpenDevice("");
 387         if (pDevice)
 388         {
 389                 printf("OPENED \"\" DEVICE ... GOT %s\n", alcGetString(pDevice, ALC_DEVICE_SPECIFIER));
 390                 alcCloseDevice(pDevice);
 391         }
 392         else
 393         {
 394                 if (waveOutGetNumDevs())
 395                 {
 396                         printf("!!!ERROR!!! : FAILED TO OPEN EMPTY DEVICE\n");
 397                         lErrorCount++;
 398                 }
 399                 else
 400                 {
 401                         printf("FAILED TO OPEN EMPTY DEVICE\n");
 402                 }
 403         }
 404         printf("--------------------------------------\n\n");
 405         ///////////////////////////////////////////////////////////////////
 406
 407
 408         ///////////////////////////////////////////////////////////////////
 409         // TEST : Open "A Random Name" device
 410         //
 411         printf("--------------------------------------\n");
 412         printf("TESTING 'A Random Name' DEVICE\n\n");
 413         pDevice = alcOpenDevice("A Random Name");
 414         if (pDevice)
 415         {
 416                 printf("!!!ERROR!!! : OPENED 'A Random Name' DEVICE ... GOT %s\n", alcGetString(pDevice, ALC_DEVICE_SPECIFIER));
 417                 lErrorCount++;
 418                 alcCloseDevice(pDevice);
 419         }
 420         else
 421         {
 422                 printf("FAILED TO OPEN 'A Random Name' DEVICE\n");
 423         }
 424         printf("--------------------------------------\n\n");
 425         ///////////////////////////////////////////////////////////////////
 426
 427
 428         ///////////////////////////////////////////////////////////////////
 429         // TEST : Open NULL Capture device
 430         //
 431         printf("--------------------------------------\n");
 432         printf("TESTING NULL CAPTURE DEVICE\n\n");
 433         pDevice = alcCaptureOpenDevice(NULL, 22500, AL_FORMAT_MONO16, 4096);
 434         if (pDevice)
 435         {
 436                 printf("OPENED NULL CAPTURE DEVICE ... GOT %s\n", alcGetString(pDevice, ALC_CAPTURE_DEVICE_SPECIFIER));
 437                 alcCaptureCloseDevice(pDevice);
 438         }
 439         else
 440         {
 441                 if (waveInGetNumDevs())
 442                 {
 443                         printf("!!!ERROR!!! : FAILED TO OPEN NULL CAPTURE DEVICE\n");
 444                         lErrorCount++;
 445                 }
 446                 else
 447                 {
 448                         printf("FAILED TO OPEN NULL CAPTURE DEVICE\n");
 449                 }
 450         }
 451         printf("--------------------------------------\n\n");
 452         ///////////////////////////////////////////////////////////////////
 453
 454
 455         ///////////////////////////////////////////////////////////////////
 456         // TEST : Open "" capture device
 457         //
 458         printf("--------------------------------------\n");
 459         printf("TESTING EMPTY CAPTURE DEVICE\n\n");
 460         pDevice = alcCaptureOpenDevice("", 22500, AL_FORMAT_MONO16, 4096);
 461         if (pDevice)
 462         {
 463                 printf("OPENED \"\" CAPTURE DEVICE ... GOT %s\n", alcGetString(pDevice, ALC_CAPTURE_DEVICE_SPECIFIER));
 464                 alcCaptureCloseDevice(pDevice);
 465         }
 466         else
 467         {
 468                 if (waveInGetNumDevs())
 469                 {
 470                         printf("!!!ERROR!!! : FAILED TO OPEN EMPTY CAPTURE DEVICE\n");
 471                         lErrorCount++;
 472                 }
 473                 else
 474                 {
 475                         printf("FAILED TO OPEN EMPTY CAPTURE DEVICE\n");
 476                 }
 477         }
 478         printf("--------------------------------------\n\n");
 479         ///////////////////////////////////////////////////////////////////
 480
 481
 482         ///////////////////////////////////////////////////////////////////
 483         // TEST : Open "A Random Name" capture device
 484         //
 485         printf("--------------------------------------\n");
 486         printf("TESTING 'A Random Name' CAPTURE DEVICE\n\n");
 487         pDevice = alcCaptureOpenDevice("A Random Name", 22500, AL_FORMAT_MONO16, 4096);
 488         if (pDevice)
 489         {
 490                 printf("!!!ERROR!!! : OPENED 'A Random Name' CAPTURE DEVICE ... GOT %s\n", alcGetString(pDevice, ALC_CAPTURE_DEVICE_SPECIFIER));
 491                 lErrorCount++;
 492                 alcCaptureCloseDevice(pDevice);
 493         }
 494         else
 495         {
 496                 printf("FAILED TO OPEN 'A Random Name' CAPTURE DEVICE\n");
 497         }
 498         printf("--------------------------------------\n\n");
 499         ///////////////////////////////////////////////////////////////////
 500
 501         printf("\nFOUND %d ERRORS\n", lErrorCount);
 502
 503         printf("\nPress a key to quit\n");
 504         char ch = _getch();
 505
 506         return 0;
 507 }
 508
 509
 510 /*
 511 ALboolean InitOpenAL(ALCdevice **ppDevice, ALCcontext **ppContext)
 512 {
 513         ALchar          szDeviceNames[10][1024];
 514         ALchar          *szNames;
 515         ALint           lNumDevices;
 516         ALint           lLoop;
 517         ALint           lLength;
 518         ALbyte          ch;
 519         ALboolean       bInit;
 520
 521         bInit = AL_FALSE;
 522         memset(szDeviceNames, 0, sizeof(ALchar) * 10 * 1024);
 523         lNumDevices = 0;
 524
 525
 526
 527         if (!szNames)
 528         {
 529                 szNames = (char *)alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);
 530                 if (szNames && *szNames && (strlen(szNames) < 1024))
 531                         strcpy(szDeviceNames[lNumDevices++], szNames);
 532         }
 533
 534         for (lLoop = 0; lLoop < lNumDevices; lLoop++)
 535                 printf("Press %d for '%s' Device\n", lLoop+1, szDeviceNames[lLoop]);
 536         printf("Press Q to quit\n");
 537
 538         do
 539         {
 540                 ch = _getch();
 541                 if (ch == 'q' || ch == 'Q')
 542                         exit(0);
 543                 else if ((ch >= '1') && (ch < ('1' + lNumDevices)))
 544                         break;
 545         } while (1);
 546
 547         *ppDevice = alcOpenDevice(szDeviceNames[ch - '1']);
 548         if (*ppDevice)
 549         {
 550                 *ppContext = alcCreateContext(*ppDevice,NULL);
 551                 if (*ppContext)
 552                 {
 553                         alcGetError(*ppDevice);
 554                         alcMakeContextCurrent(*ppContext);
 555                         if (alcGetError(*ppDevice) == ALC_NO_ERROR)
 556                                 bInit = AL_TRUE;
 557                 }
 558                 else
 559                 {
 560                         alcCloseDevice(*ppDevice);
 561                 }
 562         }
 563
 564         return bInit;
 565 }
 566
 567
 568 ALboolean InitOpenALEx(ALCdevice **ppDevice, ALCcontext **ppContext)
 569 {
 570         ALchar                  szDeviceNames[32][1024];
 571         const ALchar    *szNames;
 572         const ALchar    *szDefaultName = NULL;
 573         const ALchar    *szDefaultAllName = NULL;
 574         ALint                   lNumDevices = 0;
 575         ALint                   lLoop;
 576         ALint                   lLength;
 577         ALbyte                  ch;
 578         ALboolean               bInit;
 579
 580         bInit = AL_FALSE;
 581         memset(szDeviceNames, 0, sizeof(ALchar) * 32 * 1024);
 582
 583         // Get legacy enumeration list and Default Device
 584         if (alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT") == AL_TRUE)
 585         {
 586                 szNames = alcGetString(NULL, ALC_DEVICE_SPECIFIER);
 587
 588                 while (szNames && *szNames)
 589                 {
 590                         if ((lLength = strlen(szNames)) < 1024)
 591                                 strcpy(szDeviceNames[lNumDevices++], szNames);
 592                         szNames += lLength + 1;
 593                 }
 594
 595                 szDefaultName = alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);
 596         }
 597
 598         // Get new uber enumeration list and Default Device
 599         if (alcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT") == AL_TRUE)
 600         {
 601                 szNames = alcGetString(NULL, alcGetEnumValue(NULL, "ALC_ALL_DEVICES_SPECIFIER"));
 602
 603                 while (szNames && *szNames)
 604                 {
 605                         if ((lLength = strlen(szNames)) < 1024)
 606                                 strcpy(szDeviceNames[lNumDevices++], szNames);
 607                         szNames += lLength + 1;
 608                 }
 609
 610                 szDefaultAllName = alcGetString(NULL, alcGetEnumValue(NULL, "ALC_DEFAULT_ALL_DEVICES_SPECIFIER"));
 611         }
 612
 613
 614         for (lLoop = 0; lLoop < lNumDevices; lLoop++)
 615                 printf("Press %d for '%s' Device %s\n", lLoop+1, szDeviceNames[lLoop],
 616                 (strcmp(szDeviceNames[lLoop], szDefaultName?szDefaultName:"") == 0) ? "*" : (strcmp(szDeviceNames[lLoop], szDefaultAllName?szDefaultAllName:"") == 0) ? "**" : "");
 617         printf("Press Q to quit\n");
 618
 619         do
 620         {
 621                 ch = _getch();
 622                 if (ch == 'q' || ch == 'Q')
 623                         exit(0);
 624                 else if ((ch >= '1') && (ch < ('1' + lNumDevices)))
 625                         break;
 626         } while (1);
 627
 628         *ppDevice = alcOpenDevice(szDeviceNames[ch - '1']);
 629         if (*ppDevice)
 630         {
 631                 *ppContext = alcCreateContext(*ppDevice,NULL);
 632                 if (*ppContext)
 633                 {
 634                         alcGetError(*ppDevice);
 635                         alcMakeContextCurrent(*ppContext);
 636                         if (alcGetError(*ppDevice) == ALC_NO_ERROR)
 637                                 bInit = AL_TRUE;
 638                 }
 639                 else
 640                 {
 641                         alcCloseDevice(*ppDevice);
 642                 }
 643         }
 644
 645         return bInit;
 646 }
 647 */