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 printALInfo(void)
 185 {
 186     printf("OpenAL vendor string: %s\n", alGetString(AL_VENDOR));
 187     printf("OpenAL renderer string: %s\n", alGetString(AL_RENDERER));
 188     printf("OpenAL version string: %s\n", alGetString(AL_VERSION));
 189     printf("OpenAL extensions:");
 190     printList(alGetString(AL_EXTENSIONS), ' ');
 191     checkALErrors();
 192 }
 193
 194 static void printResamplerInfo(void)
 195 {
 196     LPALGETSTRINGISOFT alGetStringiSOFT;
 197     ALint num_resamplers;
 198     ALint def_resampler;
 199
 200     if(!alIsExtensionPresent("AL_SOFT_source_resampler"))
 201     {
 202         printf("Resampler info not available\n");
 203         return;
 204     }
 205
 206     alGetStringiSOFT = FUNCTION_CAST(LPALGETSTRINGISOFT, alGetProcAddress("alGetStringiSOFT"));
 207
 208     num_resamplers = alGetInteger(AL_NUM_RESAMPLERS_SOFT);
 209     def_resampler = alGetInteger(AL_DEFAULT_RESAMPLER_SOFT);
 210
 211     if(!num_resamplers)
 212         printf("!!! No resamplers found !!!\n");
 213     else
 214     {
 215         ALint i;
 216         printf("Available resamplers:\n");
 217         for(i = 0;i < num_resamplers;++i)
 218         {
 219             const ALchar *name = alGetStringiSOFT(AL_RESAMPLER_NAME_SOFT, i);
 220             printf("    %s%s\n", name, (i==def_resampler)?" *":"");
 221         }
 222     }
 223     checkALErrors();
 224 }
 225
 226 static void printEFXInfo(ALCdevice *device)
 227 {
 228     static LPALGENFILTERS palGenFilters;
 229     static LPALDELETEFILTERS palDeleteFilters;
 230     static LPALFILTERI palFilteri;
 231     static LPALGENEFFECTS palGenEffects;
 232     static LPALDELETEEFFECTS palDeleteEffects;
 233     static LPALEFFECTI palEffecti;
 234
 235     static const ALint filters[] = {
 236         AL_FILTER_LOWPASS, AL_FILTER_HIGHPASS, AL_FILTER_BANDPASS,
 237         AL_FILTER_NULL
 238     };
 239     char filterNames[] = "Low-pass,High-pass,Band-pass,";
 240     static const ALint effects[] = {
 241         AL_EFFECT_EAXREVERB, AL_EFFECT_REVERB, AL_EFFECT_CHORUS,
 242         AL_EFFECT_DISTORTION, AL_EFFECT_ECHO, AL_EFFECT_FLANGER,
 243         AL_EFFECT_FREQUENCY_SHIFTER, AL_EFFECT_VOCAL_MORPHER,
 244         AL_EFFECT_PITCH_SHIFTER, AL_EFFECT_RING_MODULATOR,
 245         AL_EFFECT_AUTOWAH, AL_EFFECT_COMPRESSOR, AL_EFFECT_EQUALIZER,
 246         AL_EFFECT_NULL
 247     };
 248     static const ALint dedeffects[] = {
 249         AL_EFFECT_DEDICATED_DIALOGUE, AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT,
 250         AL_EFFECT_NULL
 251     };
 252     char effectNames[] = "EAX Reverb,Reverb,Chorus,Distortion,Echo,Flanger,"
 253         "Frequency Shifter,Vocal Morpher,Pitch Shifter,Ring Modulator,Autowah,"
 254         "Compressor,Equalizer,Dedicated Dialog,Dedicated LFE,";
 255     ALCint major, minor, sends;
 256     ALuint object;
 257     char *current;
 258     int i;
 259
 260     if(alcIsExtensionPresent(device, "ALC_EXT_EFX") == AL_FALSE)
 261     {
 262         printf("EFX not available\n");
 263         return;
 264     }
 265
 266     palGenFilters = FUNCTION_CAST(LPALGENFILTERS, alGetProcAddress("alGenFilters"));
 267     palDeleteFilters = FUNCTION_CAST(LPALDELETEFILTERS, alGetProcAddress("alDeleteFilters"));
 268     palFilteri = FUNCTION_CAST(LPALFILTERI, alGetProcAddress("alFilteri"));
 269     palGenEffects = FUNCTION_CAST(LPALGENEFFECTS, alGetProcAddress("alGenEffects"));
 270     palDeleteEffects = FUNCTION_CAST(LPALDELETEEFFECTS, alGetProcAddress("alDeleteEffects"));
 271     palEffecti = FUNCTION_CAST(LPALEFFECTI, alGetProcAddress("alEffecti"));
 272
 273     alcGetIntegerv(device, ALC_EFX_MAJOR_VERSION, 1, &major);
 274     alcGetIntegerv(device, ALC_EFX_MINOR_VERSION, 1, &minor);
 275     if(checkALCErrors(device) == ALC_NO_ERROR)
 276         printf("EFX version: %d.%d\n", major, minor);
 277     alcGetIntegerv(device, ALC_MAX_AUXILIARY_SENDS, 1, &sends);
 278     if(checkALCErrors(device) == ALC_NO_ERROR)
 279         printf("Max auxiliary sends: %d\n", sends);
 280
 281     palGenFilters(1, &object);
 282     checkALErrors();
 283
 284     current = filterNames;
 285     for(i = 0;filters[i] != AL_FILTER_NULL;i++)
 286     {
 287         char *next = strchr(current, ',');
 288         assert(next != NULL);
 289
 290         palFilteri(object, AL_FILTER_TYPE, filters[i]);
 291         if(alGetError() != AL_NO_ERROR)
 292             memmove(current, next+1, strlen(next));
 293         else
 294             current = next+1;
 295     }
 296     printf("Supported filters:");
 297     printList(filterNames, ',');
 298
 299     palDeleteFilters(1, &object);
 300     palGenEffects(1, &object);
 301     checkALErrors();
 302
 303     current = effectNames;
 304     for(i = 0;effects[i] != AL_EFFECT_NULL;i++)
 305     {
 306         char *next = strchr(current, ',');
 307         assert(next != NULL);
 308
 309         palEffecti(object, AL_EFFECT_TYPE, effects[i]);
 310         if(alGetError() != AL_NO_ERROR)
 311             memmove(current, next+1, strlen(next));
 312         else
 313             current = next+1;
 314     }
 315     if(alcIsExtensionPresent(device, "ALC_EXT_DEDICATED"))
 316     {
 317         for(i = 0;dedeffects[i] != AL_EFFECT_NULL;i++)
 318         {
 319             char *next = strchr(current, ',');
 320             assert(next != NULL);
 321
 322             palEffecti(object, AL_EFFECT_TYPE, dedeffects[i]);
 323             if(alGetError() != AL_NO_ERROR)
 324                 memmove(current, next+1, strlen(next));
 325             else
 326                 current = next+1;
 327         }
 328     }
 329     else
 330     {
 331         for(i = 0;dedeffects[i] != AL_EFFECT_NULL;i++)
 332         {
 333             char *next = strchr(current, ',');
 334             assert(next != NULL);
 335             memmove(current, next+1, strlen(next));
 336         }
 337     }
 338     printf("Supported effects:");
 339     printList(effectNames, ',');
 340
 341     palDeleteEffects(1, &object);
 342     checkALErrors();
 343 }
 344
 345 int main(int argc, char *argv[])
 346 {
 347     ALCdevice *device;
 348     ALCcontext *context;
 349
 350 #ifdef _WIN32
 351     /* OpenAL Soft gives UTF-8 strings, so set the console to expect that. */
 352     SetConsoleOutputCP(CP_UTF8);
 353 #endif
 354
 355     if(argc > 1 && (strcmp(argv[1], "--help") == 0 ||
 356                     strcmp(argv[1], "-h") == 0))
 357     {
 358         printf("Usage: %s [playback device]\n", argv[0]);
 359         return 0;
 360     }
 361
 362     printf("Available playback devices:\n");
 363     if(alcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT") != AL_FALSE)
 364         printDeviceList(alcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER));
 365     else
 366         printDeviceList(alcGetString(NULL, ALC_DEVICE_SPECIFIER));
 367     printf("Available capture devices:\n");
 368     printDeviceList(alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER));
 369
 370     if(alcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT") != AL_FALSE)
 371         printf("Default playback device: %s\n",
 372                alcGetString(NULL, ALC_DEFAULT_ALL_DEVICES_SPECIFIER));
 373     else
 374         printf("Default playback device: %s\n",
 375                alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER));
 376     printf("Default capture device: %s\n",
 377            alcGetString(NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER));
 378
 379     printALCInfo(NULL);
 380
 381     device = alcOpenDevice((argc>1) ? argv[1] : NULL);
 382     if(!device)
 383     {
 384         printf("\n!!! Failed to open %s !!!\n\n", ((argc>1) ? argv[1] : "default device"));
 385         return 1;
 386     }
 387     printALCInfo(device);
 388     printHRTFInfo(device);
 389
 390     context = alcCreateContext(device, NULL);
 391     if(!context || alcMakeContextCurrent(context) == ALC_FALSE)
 392     {
 393         if(context)
 394             alcDestroyContext(context);
 395         alcCloseDevice(device);
 396         printf("\n!!! Failed to set a context !!!\n\n");
 397         return 1;
 398     }
 399
 400     printALInfo();
 401     printResamplerInfo();
 402     printEFXInfo(device);
 403
 404     alcMakeContextCurrent(NULL);
 405     alcDestroyContext(context);
 406     alcCloseDevice(device);
 407
 408     return 0;
 409 }