🛠️🐜 Antkeeper superbuild with dependencies included
https://antkeeper.com
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
437 lines
12 KiB
437 lines
12 KiB
/*
|
|
* OpenAL Info Utility
|
|
*
|
|
* Copyright (c) 2010 by Chris Robinson <chris.kcat@gmail.com>
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "AL/alc.h"
|
|
#include "AL/al.h"
|
|
#include "AL/alext.h"
|
|
|
|
#ifndef ALC_ENUMERATE_ALL_EXT
|
|
#define ALC_DEFAULT_ALL_DEVICES_SPECIFIER 0x1012
|
|
#define ALC_ALL_DEVICES_SPECIFIER 0x1013
|
|
#endif
|
|
|
|
#ifndef ALC_EXT_EFX
|
|
#define ALC_EFX_MAJOR_VERSION 0x20001
|
|
#define ALC_EFX_MINOR_VERSION 0x20002
|
|
#define ALC_MAX_AUXILIARY_SENDS 0x20003
|
|
#endif
|
|
|
|
|
|
#ifdef _WIN32
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#include <windows.h>
|
|
|
|
static WCHAR *FromUTF8(const char *str)
|
|
{
|
|
WCHAR *out = NULL;
|
|
int len;
|
|
|
|
if((len=MultiByteToWideChar(CP_UTF8, 0, str, -1, NULL, 0)) > 0)
|
|
{
|
|
out = calloc(sizeof(WCHAR), len);
|
|
MultiByteToWideChar(CP_UTF8, 0, str, -1, out, len);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
/* Override printf, fprintf, and fwrite so we can print UTF-8 strings. */
|
|
static void al_fprintf(FILE *file, const char *fmt, ...)
|
|
{
|
|
char str[1024];
|
|
WCHAR *wstr;
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
vsnprintf(str, sizeof(str), fmt, ap);
|
|
va_end(ap);
|
|
|
|
str[sizeof(str)-1] = 0;
|
|
wstr = FromUTF8(str);
|
|
if(!wstr)
|
|
fprintf(file, "<UTF-8 error> %s", str);
|
|
else
|
|
fprintf(file, "%ls", wstr);
|
|
free(wstr);
|
|
}
|
|
#define fprintf al_fprintf
|
|
#define printf(...) al_fprintf(stdout, __VA_ARGS__)
|
|
|
|
static size_t al_fwrite(const void *ptr, size_t size, size_t nmemb, FILE *file)
|
|
{
|
|
char str[1024];
|
|
WCHAR *wstr;
|
|
size_t len;
|
|
|
|
len = size * nmemb;
|
|
if(len > sizeof(str)-1)
|
|
len = sizeof(str)-1;
|
|
memcpy(str, ptr, len);
|
|
str[len] = 0;
|
|
|
|
wstr = FromUTF8(str);
|
|
if(!wstr)
|
|
fprintf(file, "<UTF-8 error> %s", str);
|
|
else
|
|
fprintf(file, "%ls", wstr);
|
|
free(wstr);
|
|
|
|
return len / size;
|
|
}
|
|
#define fwrite al_fwrite
|
|
#endif
|
|
|
|
|
|
#define MAX_WIDTH 80
|
|
|
|
static void printList(const char *list, char separator)
|
|
{
|
|
size_t col = MAX_WIDTH, len;
|
|
const char *indent = " ";
|
|
const char *next;
|
|
|
|
if(!list || *list == '\0')
|
|
{
|
|
fprintf(stdout, "\n%s!!! none !!!\n", indent);
|
|
return;
|
|
}
|
|
|
|
do {
|
|
next = strchr(list, separator);
|
|
if(next)
|
|
{
|
|
len = next-list;
|
|
do {
|
|
next++;
|
|
} while(*next == separator);
|
|
}
|
|
else
|
|
len = strlen(list);
|
|
|
|
if(len + col + 2 >= MAX_WIDTH)
|
|
{
|
|
fprintf(stdout, "\n%s", indent);
|
|
col = strlen(indent);
|
|
}
|
|
else
|
|
{
|
|
fputc(' ', stdout);
|
|
col++;
|
|
}
|
|
|
|
len = fwrite(list, 1, len, stdout);
|
|
col += len;
|
|
|
|
if(!next || *next == '\0')
|
|
break;
|
|
fputc(',', stdout);
|
|
col++;
|
|
|
|
list = next;
|
|
} while(1);
|
|
fputc('\n', stdout);
|
|
}
|
|
|
|
static void printDeviceList(const char *list)
|
|
{
|
|
if(!list || *list == '\0')
|
|
printf(" !!! none !!!\n");
|
|
else do {
|
|
printf(" %s\n", list);
|
|
list += strlen(list) + 1;
|
|
} while(*list != '\0');
|
|
}
|
|
|
|
|
|
static ALenum checkALErrors(int linenum)
|
|
{
|
|
ALenum err = alGetError();
|
|
if(err != AL_NO_ERROR)
|
|
printf("OpenAL Error: %s (0x%x), @ %d\n", alGetString(err), err, linenum);
|
|
return err;
|
|
}
|
|
#define checkALErrors() checkALErrors(__LINE__)
|
|
|
|
static ALCenum checkALCErrors(ALCdevice *device, int linenum)
|
|
{
|
|
ALCenum err = alcGetError(device);
|
|
if(err != ALC_NO_ERROR)
|
|
printf("ALC Error: %s (0x%x), @ %d\n", alcGetString(device, err), err, linenum);
|
|
return err;
|
|
}
|
|
#define checkALCErrors(x) checkALCErrors((x),__LINE__)
|
|
|
|
|
|
static void printALCInfo(ALCdevice *device)
|
|
{
|
|
ALCint major, minor;
|
|
|
|
if(device)
|
|
{
|
|
const ALCchar *devname = NULL;
|
|
printf("\n");
|
|
if(alcIsExtensionPresent(device, "ALC_ENUMERATE_ALL_EXT") != AL_FALSE)
|
|
devname = alcGetString(device, ALC_ALL_DEVICES_SPECIFIER);
|
|
if(checkALCErrors(device) != ALC_NO_ERROR || !devname)
|
|
devname = alcGetString(device, ALC_DEVICE_SPECIFIER);
|
|
printf("** Info for device \"%s\" **\n", devname);
|
|
}
|
|
alcGetIntegerv(device, ALC_MAJOR_VERSION, 1, &major);
|
|
alcGetIntegerv(device, ALC_MINOR_VERSION, 1, &minor);
|
|
if(checkALCErrors(device) == ALC_NO_ERROR)
|
|
printf("ALC version: %d.%d\n", major, minor);
|
|
if(device)
|
|
{
|
|
printf("ALC extensions:");
|
|
printList(alcGetString(device, ALC_EXTENSIONS), ' ');
|
|
checkALCErrors(device);
|
|
}
|
|
}
|
|
|
|
static void printHRTFInfo(ALCdevice *device)
|
|
{
|
|
LPALCGETSTRINGISOFT alcGetStringiSOFT;
|
|
ALCint num_hrtfs;
|
|
|
|
if(alcIsExtensionPresent(device, "ALC_SOFT_HRTF") == ALC_FALSE)
|
|
{
|
|
printf("HRTF extension not available\n");
|
|
return;
|
|
}
|
|
|
|
alcGetStringiSOFT = alcGetProcAddress(device, "alcGetStringiSOFT");
|
|
|
|
alcGetIntegerv(device, ALC_NUM_HRTF_SPECIFIERS_SOFT, 1, &num_hrtfs);
|
|
if(!num_hrtfs)
|
|
printf("No HRTFs found\n");
|
|
else
|
|
{
|
|
ALCint i;
|
|
printf("Available HRTFs:\n");
|
|
for(i = 0;i < num_hrtfs;++i)
|
|
{
|
|
const ALCchar *name = alcGetStringiSOFT(device, ALC_HRTF_SPECIFIER_SOFT, i);
|
|
printf(" %s\n", name);
|
|
}
|
|
}
|
|
checkALCErrors(device);
|
|
}
|
|
|
|
static void printALInfo(void)
|
|
{
|
|
printf("OpenAL vendor string: %s\n", alGetString(AL_VENDOR));
|
|
printf("OpenAL renderer string: %s\n", alGetString(AL_RENDERER));
|
|
printf("OpenAL version string: %s\n", alGetString(AL_VERSION));
|
|
printf("OpenAL extensions:");
|
|
printList(alGetString(AL_EXTENSIONS), ' ');
|
|
checkALErrors();
|
|
}
|
|
|
|
static void printResamplerInfo(void)
|
|
{
|
|
LPALGETSTRINGISOFT alGetStringiSOFT;
|
|
ALint num_resamplers;
|
|
ALint def_resampler;
|
|
|
|
if(!alIsExtensionPresent("AL_SOFT_source_resampler"))
|
|
{
|
|
printf("Resampler info not available\n");
|
|
return;
|
|
}
|
|
|
|
alGetStringiSOFT = alGetProcAddress("alGetStringiSOFT");
|
|
|
|
num_resamplers = alGetInteger(AL_NUM_RESAMPLERS_SOFT);
|
|
def_resampler = alGetInteger(AL_DEFAULT_RESAMPLER_SOFT);
|
|
|
|
if(!num_resamplers)
|
|
printf("!!! No resamplers found !!!\n");
|
|
else
|
|
{
|
|
ALint i;
|
|
printf("Available resamplers:\n");
|
|
for(i = 0;i < num_resamplers;++i)
|
|
{
|
|
const ALchar *name = alGetStringiSOFT(AL_RESAMPLER_NAME_SOFT, i);
|
|
printf(" %s%s\n", name, (i==def_resampler)?" *":"");
|
|
}
|
|
}
|
|
checkALErrors();
|
|
}
|
|
|
|
static void printEFXInfo(ALCdevice *device)
|
|
{
|
|
ALCint major, minor, sends;
|
|
static const ALchar filters[][32] = {
|
|
"AL_FILTER_LOWPASS", "AL_FILTER_HIGHPASS", "AL_FILTER_BANDPASS", ""
|
|
};
|
|
char filterNames[] = "Low-pass,High-pass,Band-pass,";
|
|
static const ALchar effects[][32] = {
|
|
"AL_EFFECT_EAXREVERB", "AL_EFFECT_REVERB", "AL_EFFECT_CHORUS",
|
|
"AL_EFFECT_DISTORTION", "AL_EFFECT_ECHO", "AL_EFFECT_FLANGER",
|
|
"AL_EFFECT_FREQUENCY_SHIFTER", "AL_EFFECT_VOCAL_MORPHER",
|
|
"AL_EFFECT_PITCH_SHIFTER", "AL_EFFECT_RING_MODULATOR",
|
|
"AL_EFFECT_AUTOWAH", "AL_EFFECT_COMPRESSOR", "AL_EFFECT_EQUALIZER", ""
|
|
};
|
|
static const ALchar dedeffects[][64] = {
|
|
"AL_EFFECT_DEDICATED_DIALOGUE",
|
|
"AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT", ""
|
|
};
|
|
char effectNames[] = "EAX Reverb,Reverb,Chorus,Distortion,Echo,Flanger,"
|
|
"Frequency Shifter,Vocal Morpher,Pitch Shifter,"
|
|
"Ring Modulator,Autowah,Compressor,Equalizer,"
|
|
"Dedicated Dialog,Dedicated LFE,";
|
|
char *current;
|
|
int i;
|
|
|
|
if(alcIsExtensionPresent(device, "ALC_EXT_EFX") == AL_FALSE)
|
|
{
|
|
printf("EFX not available\n");
|
|
return;
|
|
}
|
|
|
|
alcGetIntegerv(device, ALC_EFX_MAJOR_VERSION, 1, &major);
|
|
alcGetIntegerv(device, ALC_EFX_MINOR_VERSION, 1, &minor);
|
|
if(checkALCErrors(device) == ALC_NO_ERROR)
|
|
printf("EFX version: %d.%d\n", major, minor);
|
|
alcGetIntegerv(device, ALC_MAX_AUXILIARY_SENDS, 1, &sends);
|
|
if(checkALCErrors(device) == ALC_NO_ERROR)
|
|
printf("Max auxiliary sends: %d\n", sends);
|
|
|
|
current = filterNames;
|
|
for(i = 0;filters[i][0];i++)
|
|
{
|
|
char *next = strchr(current, ',');
|
|
ALenum val;
|
|
|
|
val = alGetEnumValue(filters[i]);
|
|
if(alGetError() != AL_NO_ERROR || val == 0 || val == -1)
|
|
memmove(current, next+1, strlen(next));
|
|
else
|
|
current = next+1;
|
|
}
|
|
printf("Supported filters:");
|
|
printList(filterNames, ',');
|
|
|
|
current = effectNames;
|
|
for(i = 0;effects[i][0];i++)
|
|
{
|
|
char *next = strchr(current, ',');
|
|
ALenum val;
|
|
|
|
val = alGetEnumValue(effects[i]);
|
|
if(alGetError() != AL_NO_ERROR || val == 0 || val == -1)
|
|
memmove(current, next+1, strlen(next));
|
|
else
|
|
current = next+1;
|
|
}
|
|
if(alcIsExtensionPresent(device, "ALC_EXT_DEDICATED"))
|
|
{
|
|
for(i = 0;dedeffects[i][0];i++)
|
|
{
|
|
char *next = strchr(current, ',');
|
|
ALenum val;
|
|
|
|
val = alGetEnumValue(dedeffects[i]);
|
|
if(alGetError() != AL_NO_ERROR || val == 0 || val == -1)
|
|
memmove(current, next+1, strlen(next));
|
|
else
|
|
current = next+1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(i = 0;dedeffects[i][0];i++)
|
|
{
|
|
char *next = strchr(current, ',');
|
|
memmove(current, next+1, strlen(next));
|
|
}
|
|
}
|
|
printf("Supported effects:");
|
|
printList(effectNames, ',');
|
|
}
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
ALCdevice *device;
|
|
ALCcontext *context;
|
|
|
|
if(argc > 1 && (strcmp(argv[1], "--help") == 0 ||
|
|
strcmp(argv[1], "-h") == 0))
|
|
{
|
|
printf("Usage: %s [playback device]\n", argv[0]);
|
|
return 0;
|
|
}
|
|
|
|
printf("Available playback devices:\n");
|
|
if(alcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT") != AL_FALSE)
|
|
printDeviceList(alcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER));
|
|
else
|
|
printDeviceList(alcGetString(NULL, ALC_DEVICE_SPECIFIER));
|
|
printf("Available capture devices:\n");
|
|
printDeviceList(alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER));
|
|
|
|
if(alcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT") != AL_FALSE)
|
|
printf("Default playback device: %s\n",
|
|
alcGetString(NULL, ALC_DEFAULT_ALL_DEVICES_SPECIFIER));
|
|
else
|
|
printf("Default playback device: %s\n",
|
|
alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER));
|
|
printf("Default capture device: %s\n",
|
|
alcGetString(NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER));
|
|
|
|
printALCInfo(NULL);
|
|
|
|
device = alcOpenDevice((argc>1) ? argv[1] : NULL);
|
|
if(!device)
|
|
{
|
|
printf("\n!!! Failed to open %s !!!\n\n", ((argc>1) ? argv[1] : "default device"));
|
|
return 1;
|
|
}
|
|
printALCInfo(device);
|
|
printHRTFInfo(device);
|
|
|
|
context = alcCreateContext(device, NULL);
|
|
if(!context || alcMakeContextCurrent(context) == ALC_FALSE)
|
|
{
|
|
if(context)
|
|
alcDestroyContext(context);
|
|
alcCloseDevice(device);
|
|
printf("\n!!! Failed to set a context !!!\n\n");
|
|
return 1;
|
|
}
|
|
|
|
printALInfo();
|
|
printResamplerInfo();
|
|
printEFXInfo(device);
|
|
|
|
alcMakeContextCurrent(NULL);
|
|
alcDestroyContext(context);
|
|
alcCloseDevice(device);
|
|
|
|
return 0;
|
|
}
|