utils/openal-info.c

   1 /*
   2  * OpenAL Info Utility
   3  *
   4  * Copyright (c) 2010 by Chris Robinson <chris.kcat@gmail.com>
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25 #include <assert.h>
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30
  31 #include "AL/alc.h"
  32 #include "AL/al.h"
  33 #include "AL/alext.h"
  34
  35 #include "win_main_utf8.h"
  36
  37 /* C doesn't allow casting between function and non-function pointer types, so
  38  * with C99 we need to use a union to reinterpret the pointer type. Pre-C99
  39  * still needs to use a normal cast and live with the warning (C++ is fine with
  40  * a regular reinterpret_cast).
  41  */
  42 #if __STDC_VERSION__ >= 199901L
  43 #define FUNCTION_CAST(T, ptr) (union{void *p; T f;}){ptr}.f
  44 #else
  45 #define FUNCTION_CAST(T, ptr) (T)(ptr)
  46 #endif
  47
  48 #define MAX_WIDTH  80
  49
  50 static void printList(const char *list, char separator)
  51 {
  52     size_t col = MAX_WIDTH, len;
  53     const char *indent = "    ";
  54     const char *next;
  55
  56     if(!list || *list == '\0')
  57     {
  58         fprintf(stdout, "\n%s!!! none !!!\n", indent);
  59         return;
  60     }
  61
  62     do {
  63         next = strchr(list, separator);
  64         if(next)
  65         {
  66             len = (size_t)(next-list);
  67             do {
  68                 next++;
  69             } while(*next == separator);
  70         }
  71         else
  72             len = strlen(list);
  73
  74         if(len + col + 2 >= MAX_WIDTH)
  75         {
  76             fprintf(stdout, "\n%s", indent);
  77             col = strlen(indent);
  78         }
  79         else
  80         {
  81             fputc(' ', stdout);
  82             col++;
  83         }
  84
  85         len = fwrite(list, 1, len, stdout);
  86         col += len;
  87
  88         if(!next || *next == '\0')
  89             break;
  90         fputc(',', stdout);
  91         col++;
  92
  93         list = next;
  94     } while(1);
  95     fputc('\n', stdout);
  96 }
  97
  98 static void printDeviceList(const char *list)
  99 {
 100     if(!list || *list == '\0')
 101         printf("    !!! none !!!\n");
 102     else do {
 103         printf("    %s\n", list);
 104         list += strlen(list) + 1;
 105     } while(*list != '\0');
 106 }
 107
 108
 109 static ALenum checkALErrors(int linenum)
 110 {
 111     ALenum err = alGetError();
 112     if(err != AL_NO_ERROR)
 113         printf("OpenAL Error: %s (0x%x), @ %d\n", alGetString(err), err, linenum);
 114     return err;
 115 }
 116 #define checkALErrors() checkALErrors(__LINE__)
 117
 118 static ALCenum checkALCErrors(ALCdevice *device, int linenum)
 119 {
 120     ALCenum err = alcGetError(device);
 121     if(err != ALC_NO_ERROR)
 122         printf("ALC Error: %s (0x%x), @ %d\n", alcGetString(device, err), err, linenum);
 123     return err;
 124 }
 125 #define checkALCErrors(x) checkALCErrors((x),__LINE__)
 126
 127
 128 static void printALCInfo(ALCdevice *device)
 129 {
 130     ALCint major, minor;
 131
 132     if(device)
 133     {
 134         const ALCchar *devname = NULL;
 135         printf("\n");
 136         if(alcIsExtensionPresent(device, "ALC_ENUMERATE_ALL_EXT") != AL_FALSE)
 137             devname = alcGetString(device, ALC_ALL_DEVICES_SPECIFIER);
 138         if(checkALCErrors(device) != ALC_NO_ERROR || !devname)
 139             devname = alcGetString(device, ALC_DEVICE_SPECIFIER);
 140         printf("** Info for device \"%s\" **\n", devname);
 141     }
 142     alcGetIntegerv(device, ALC_MAJOR_VERSION, 1, &major);
 143     alcGetIntegerv(device, ALC_MINOR_VERSION, 1, &minor);
 144     if(checkALCErrors(device) == ALC_NO_ERROR)
 145         printf("ALC version: %d.%d\n", major, minor);
 146     if(device)
 147     {
 148         printf("ALC extensions:");
 149         printList(alcGetString(device, ALC_EXTENSIONS), ' ');
 150         checkALCErrors(device);
 151     }
 152 }
 153
 154 static void printHRTFInfo(ALCdevice *device)
 155 {
 156     LPALCGETSTRINGISOFT alcGetStringiSOFT;
 157     ALCint num_hrtfs;
 158
 159     if(alcIsExtensionPresent(device, "ALC_SOFT_HRTF") == ALC_FALSE)
 160     {
 161         printf("HRTF extension not available\n");
 162         return;
 163     }
 164
 165     alcGetStringiSOFT = FUNCTION_CAST(LPALCGETSTRINGISOFT,
 166         alcGetProcAddress(device, "alcGetStringiSOFT"));
 167
 168     alcGetIntegerv(device, ALC_NUM_HRTF_SPECIFIERS_SOFT, 1, &num_hrtfs);
 169     if(!num_hrtfs)
 170         printf("No HRTFs found\n");
 171     else
 172     {
 173         ALCint i;
 174         printf("Available HRTFs:\n");
 175         for(i = 0;i < num_hrtfs;++i)
 176         {
 177             const ALCchar *name = alcGetStringiSOFT(device, ALC_HRTF_SPECIFIER_SOFT, i);
 178             printf("    %s\n", name);
 179         }
 180     }
 181     checkALCErrors(device);
 182 }
 183
 184 static void printModeInfo(ALCdevice *device)
 185 {
 186     if(alcIsExtensionPresent(device, "ALC_SOFT_output_mode"))
 187     {
 188         const char *modename = "(error)";
 189         ALCenum mode = 0;
 190
 191         alcGetIntegerv(device, ALC_OUTPUT_MODE_SOFT, 1, &mode);
 192         checkALCErrors(device);
 193         switch(mode)
 194         {
 195         case ALC_ANY_SOFT: modename = "Unknown / unspecified"; break;
 196         case ALC_MONO_SOFT: modename = "Mono"; break;
 197         case ALC_STEREO_SOFT: modename = "Stereo (unspecified encoding)"; break;
 198         case ALC_STEREO_BASIC_SOFT: modename = "Stereo (basic)"; break;
 199         case ALC_STEREO_UHJ_SOFT: modename = "Stereo (UHJ)"; break;
 200         case ALC_STEREO_HRTF_SOFT: modename = "Stereo (HRTF)"; break;
 201         case ALC_QUAD_SOFT: modename = "Quadraphonic"; break;
 202         case ALC_SURROUND_5_1_SOFT: modename = "5.1 Surround"; break;
 203         case ALC_SURROUND_6_1_SOFT: modename = "6.1 Surround"; break;
 204         case ALC_SURROUND_7_1_SOFT: modename = "7.1 Surround"; break;
 205         }
 206         printf("Output channel mode: %s\n", modename);
 207     }
 208     else
 209         printf("Output mode extension not available\n");
 210 }
 211
 212 static void printALInfo(void)
 213 {
 214     printf("OpenAL vendor string: %s\n", alGetString(AL_VENDOR));
 215     printf("OpenAL renderer string: %s\n", alGetString(AL_RENDERER));
 216     printf("OpenAL version string: %s\n", alGetString(AL_VERSION));
 217     printf("OpenAL extensions:");
 218     printList(alGetString(AL_EXTENSIONS), ' ');
 219     checkALErrors();
 220 }
 221
 222 static void printResamplerInfo(void)
 223 {
 224     LPALGETSTRINGISOFT alGetStringiSOFT;
 225     ALint num_resamplers;
 226     ALint def_resampler;
 227
 228     if(!alIsExtensionPresent("AL_SOFT_source_resampler"))
 229     {
 230         printf("Resampler info not available\n");
 231         return;
 232     }
 233
 234     alGetStringiSOFT = FUNCTION_CAST(LPALGETSTRINGISOFT, alGetProcAddress("alGetStringiSOFT"));
 235
 236     num_resamplers = alGetInteger(AL_NUM_RESAMPLERS_SOFT);
 237     def_resampler = alGetInteger(AL_DEFAULT_RESAMPLER_SOFT);
 238
 239     if(!num_resamplers)
 240         printf("!!! No resamplers found !!!\n");
 241     else
 242     {
 243         ALint i;
 244         printf("Available resamplers:\n");
 245         for(i = 0;i < num_resamplers;++i)
 246         {
 247             const ALchar *name = alGetStringiSOFT(AL_RESAMPLER_NAME_SOFT, i);
 248             printf("    %s%s\n", name, (i==def_resampler)?" *":"");
 249         }
 250     }
 251     checkALErrors();
 252 }
 253
 254 static void printEFXInfo(ALCdevice *device)
 255 {
 256     static LPALGENFILTERS palGenFilters;
 257     static LPALDELETEFILTERS palDeleteFilters;
 258     static LPALFILTERI palFilteri;
 259     static LPALGENEFFECTS palGenEffects;
 260     static LPALDELETEEFFECTS palDeleteEffects;
 261     static LPALEFFECTI palEffecti;
 262
 263     static const ALint filters[] = {
 264         AL_FILTER_LOWPASS, AL_FILTER_HIGHPASS, AL_FILTER_BANDPASS,
 265         AL_FILTER_NULL
 266     };
 267     char filterNames[] = "Low-pass,High-pass,Band-pass,";
 268     static const ALint effects[] = {
 269         AL_EFFECT_EAXREVERB, AL_EFFECT_REVERB, AL_EFFECT_CHORUS,
 270         AL_EFFECT_DISTORTION, AL_EFFECT_ECHO, AL_EFFECT_FLANGER,
 271         AL_EFFECT_FREQUENCY_SHIFTER, AL_EFFECT_VOCAL_MORPHER,
 272         AL_EFFECT_PITCH_SHIFTER, AL_EFFECT_RING_MODULATOR,
 273         AL_EFFECT_AUTOWAH, AL_EFFECT_COMPRESSOR, AL_EFFECT_EQUALIZER,
 274         AL_EFFECT_NULL
 275     };
 276     static const ALint dedeffects[] = {
 277         AL_EFFECT_DEDICATED_DIALOGUE, AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT,
 278         AL_EFFECT_NULL
 279     };
 280     char effectNames[] = "EAX Reverb,Reverb,Chorus,Distortion,Echo,Flanger,"
 281         "Frequency Shifter,Vocal Morpher,Pitch Shifter,Ring Modulator,Autowah,"
 282         "Compressor,Equalizer,Dedicated Dialog,Dedicated LFE,";
 283     ALCint major, minor, sends;
 284     ALuint object;
 285     char *current;
 286     int i;
 287
 288     if(alcIsExtensionPresent(device, "ALC_EXT_EFX") == AL_FALSE)
 289     {
 290         printf("EFX not available\n");
 291         return;
 292     }
 293
 294     palGenFilters = FUNCTION_CAST(LPALGENFILTERS, alGetProcAddress("alGenFilters"));
 295     palDeleteFilters = FUNCTION_CAST(LPALDELETEFILTERS, alGetProcAddress("alDeleteFilters"));
 296     palFilteri = FUNCTION_CAST(LPALFILTERI, alGetProcAddress("alFilteri"));
 297     palGenEffects = FUNCTION_CAST(LPALGENEFFECTS, alGetProcAddress("alGenEffects"));
 298     palDeleteEffects = FUNCTION_CAST(LPALDELETEEFFECTS, alGetProcAddress("alDeleteEffects"));
 299     palEffecti = FUNCTION_CAST(LPALEFFECTI, alGetProcAddress("alEffecti"));
 300
 301     alcGetIntegerv(device, ALC_EFX_MAJOR_VERSION, 1, &major);
 302     alcGetIntegerv(device, ALC_EFX_MINOR_VERSION, 1, &minor);
 303     if(checkALCErrors(device) == ALC_NO_ERROR)
 304         printf("EFX version: %d.%d\n", major, minor);
 305     alcGetIntegerv(device, ALC_MAX_AUXILIARY_SENDS, 1, &sends);
 306     if(checkALCErrors(device) == ALC_NO_ERROR)
 307         printf("Max auxiliary sends: %d\n", sends);
 308
 309     palGenFilters(1, &object);
 310     checkALErrors();
 311
 312     current = filterNames;
 313     for(i = 0;filters[i] != AL_FILTER_NULL;i++)
 314     {
 315         char *next = strchr(current, ',');
 316         assert(next != NULL);
 317
 318         palFilteri(object, AL_FILTER_TYPE, filters[i]);
 319         if(alGetError() != AL_NO_ERROR)
 320             memmove(current, next+1, strlen(next));
 321         else
 322             current = next+1;
 323     }
 324     printf("Supported filters:");
 325     printList(filterNames, ',');
 326
 327     palDeleteFilters(1, &object);
 328     palGenEffects(1, &object);
 329     checkALErrors();
 330
 331     current = effectNames;
 332     for(i = 0;effects[i] != AL_EFFECT_NULL;i++)
 333     {
 334         char *next = strchr(current, ',');
 335         assert(next != NULL);
 336
 337         palEffecti(object, AL_EFFECT_TYPE, effects[i]);
 338         if(alGetError() != AL_NO_ERROR)
 339             memmove(current, next+1, strlen(next));
 340         else
 341             current = next+1;
 342     }
 343     if(alcIsExtensionPresent(device, "ALC_EXT_DEDICATED"))
 344     {
 345         for(i = 0;dedeffects[i] != AL_EFFECT_NULL;i++)
 346         {
 347             char *next = strchr(current, ',');
 348             assert(next != NULL);
 349
 350             palEffecti(object, AL_EFFECT_TYPE, dedeffects[i]);
 351             if(alGetError() != AL_NO_ERROR)
 352                 memmove(current, next+1, strlen(next));
 353             else
 354                 current = next+1;
 355         }
 356     }
 357     else
 358     {
 359         for(i = 0;dedeffects[i] != AL_EFFECT_NULL;i++)
 360         {
 361             char *next = strchr(current, ',');
 362             assert(next != NULL);
 363             memmove(current, next+1, strlen(next));
 364         }
 365     }
 366     printf("Supported effects:");
 367     printList(effectNames, ',');
 368
 369     palDeleteEffects(1, &object);
 370     checkALErrors();
 371 }
 372
 373 int main(int argc, char *argv[])
 374 {
 375     ALCdevice *device;
 376     ALCcontext *context;
 377
 378 #ifdef _WIN32
 379     /* OpenAL Soft gives UTF-8 strings, so set the console to expect that. */
 380     SetConsoleOutputCP(CP_UTF8);
 381 #endif
 382
 383     if(argc > 1 && (strcmp(argv[1], "--help") == 0 ||
 384                     strcmp(argv[1], "-h") == 0))
 385     {
 386         printf("Usage: %s [playback device]\n", argv[0]);
 387         return 0;
 388     }
 389
 390     printf("Available playback devices:\n");
 391     if(alcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT") != AL_FALSE)
 392         printDeviceList(alcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER));
 393     else
 394         printDeviceList(alcGetString(NULL, ALC_DEVICE_SPECIFIER));
 395     printf("Available capture devices:\n");
 396     printDeviceList(alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER));
 397
 398     if(alcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT") != AL_FALSE)
 399         printf("Default playback device: %s\n",
 400                alcGetString(NULL, ALC_DEFAULT_ALL_DEVICES_SPECIFIER));
 401     else
 402         printf("Default playback device: %s\n",
 403                alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER));
 404     printf("Default capture device: %s\n",
 405            alcGetString(NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER));
 406
 407     printALCInfo(NULL);
 408
 409     device = alcOpenDevice((argc>1) ? argv[1] : NULL);
 410     if(!device)
 411     {
 412         printf("\n!!! Failed to open %s !!!\n\n", ((argc>1) ? argv[1] : "default device"));
 413         return 1;
 414     }
 415     printALCInfo(device);
 416     printHRTFInfo(device);
 417
 418     context = alcCreateContext(device, NULL);
 419     if(!context || alcMakeContextCurrent(context) == ALC_FALSE)
 420     {
 421         if(context)
 422             alcDestroyContext(context);
 423         alcCloseDevice(device);
 424         printf("\n!!! Failed to set a context !!!\n\n");
 425         return 1;
 426     }
 427
 428     printModeInfo(device);
 429     printALInfo();
 430     printResamplerInfo();
 431     printEFXInfo(device);
 432
 433     alcMakeContextCurrent(NULL);
 434     alcDestroyContext(context);
 435     alcCloseDevice(device);
 436
 437     return 0;
 438 }