Das Auflisten aller Geräte im offenen AL funktioniert nicht ⇐ C++

[Anonymous]

Ich habe einige Beispiele gefunden, die behaupten, alle Ausgabegeräte für Audio mit openAL aufzulisten, ich kann sie jedoch nur dazu bringen, das aktuell ausgewählte Gerät unter OSX (Yosemite, Maverick) aufzulisten. Ich verwende einen Mac und habe die Standard-Soundkarte (integrierter Ausgang) sowie ein Airplay-Gerät und einige Sound-Flower-Geräte.
Hinweis: Unter Windows werden alle Geräte aufgelistet.
Ich erwarte

Code: Select all

s = (char *)alcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER);

um zumindest die Standardkarte und die Sound-Flower-Geräte aufzulisten. Es gibt nichts zurück.

Code: Select all

s = (char *)alcGetString(NULL, ALC_DEVICE_SPECIFIER);

gibt das aktuell ausgewählte Gerät zurück.
Vielleicht gibt es ein Problem damit, dass die Geräte virtuell sind? Wenn Sie jedoch Soundflower in den Mac-Einstellungen als Standardausgabe auswählen, wird es anstelle von „Integrierte Ausgabe“ angezeigt. Wir haben es auch mit einem externen DAC versucht und das gleiche Verhalten festgestellt.

Code: Select all

list of all available output devices:   Built-in Output
list of all available input devices:   Built-in Microphone
default output device: Built-in Output
default input device:  Built-in Microphone
...

Hier ist der Code:

Code: Select all

#ifdef __APPLE__
# include 
# include 
#else
# include 
# include 
# include 
#endif

#ifndef AL_VERSION_1_1
# ifdef __APPLE__
#  include 
#  include 
#else
#  include 
#  include 
# endif
#endif

#include 
#include 
#include 
#include 

using std::string;

#ifndef ALC_ALL_DEVICES_SPECIFIER
# define ALC_ALL_DEVICES_SPECIFIER      0x1013
#endif

#define MAX_DATA    16
static const int indentation = 4;
static const int maxmimumWidth = 79;

void printExtensions (const char *, char, const char *);
void displayDevices(const char *, const char *);
char *getDeviceName(int, char **);
void testForError(void *, const string&);
void testForALCError(ALCdevice *);

int main(int argc, char **argv)
{
ALCint data[MAX_DATA];
ALCdevice *device = NULL;
ALCcontext *context = NULL;
ALenum error;
char *s;

if (alcIsExtensionPresent(NULL, "ALC_enumeration_EXT") == AL_TRUE)
{
if (alcIsExtensionPresent(NULL, "ALC_enumerate_all_EXT") == AL_FALSE)
s = (char *)alcGetString(NULL, ALC_DEVICE_SPECIFIER);
else
s = (char *)alcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER);
displayDevices("output", s);

s = (char *)alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER);
displayDevices("input", s);
}

s = getDeviceName(argc, argv);
device = alcOpenDevice(s);
testForError(device, "Audio device not available.");

context = alcCreateContext(device, NULL);
testForError(context, "Unable to create a valid context.");

alcMakeContextCurrent(context);
testForALCError(device);

s = (char *)alcGetString(device, ALC_DEFAULT_DEVICE_SPECIFIER);
printf("default output device: %s\n", s);
testForALCError(device);

error = alcIsExtensionPresent(device, "ALC_EXT_capture");
if (error)
{
s = (char *)alcGetString(device, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
printf("default input device:  %s\n", s);
testForALCError(device);
}
printf("capture support: %s\n", (error) ? "yes" : "no");

alcGetIntegerv(device, ALC_FREQUENCY, 1, data);
printf("mixer frequency: %u hz\n", data[0]);
testForALCError(device);

alcGetIntegerv(device, ALC_REFRESH, 1, data+1);
printf("refresh rate : %u hz\n", data[0]/data[1]);
testForALCError(device);

data[0] = 0;
alcGetIntegerv(device, ALC_MONO_SOURCES, 1, data);
error = alcGetError(device);
if (error == AL_NONE) {
printf("supported sources;  mono: %u, ", data[0]);

data[0] = 0;
alcGetIntegerv(device, ALC_STEREO_SOURCES, 1, data);
printf("stereo: %u\n", data[0]);
testForALCError(device);
}

printf("ALC version: ");
alcGetIntegerv(device, ALC_MAJOR_VERSION, 1, data);
printf("%i.", *data);
alcGetIntegerv(device, ALC_MINOR_VERSION, 1, data);
printf("%i\n", *data);
testForALCError(device);

s = (char *)alcGetString(device, ALC_EXTENSIONS);
printExtensions ("ALC extensions", ' ', s);
testForALCError(device);

s = (char *)alGetString(AL_VENDOR);
error = alGetError();
if ((error = alGetError()) != AL_NO_ERROR)
printf("Error #%x: %s\n", error, alGetString(error));
else
printf("OpenAL vendor string: %s\n", s);

s = (char *)alGetString(AL_RENDERER);
if ((error = alGetError()) != AL_NO_ERROR)
printf("Error #%x: %s\n", error, alGetString(error));
else
printf("OpenAL renderer string: %s\n", s);

s = (char *)alGetString(AL_VERSION);
if ((error = alGetError()) != AL_NO_ERROR)
printf("Error #%x: %s\n", error, alGetString(error));
else if (!s)
printf("Querying AL_VERSION returned NULL pointer!\n");
else
printf("OpenAL version string: %s\n", s);

s = (char *)alGetString(AL_EXTENSIONS);
printExtensions ("OpenAL extensions", ' ', s);
testForALCError(device);

/* alut testing mechanism */
context = alcGetCurrentContext();
if (context == NULL)
{
printf("Error: no current context\n");
}
else
{
if (alGetError () != AL_NO_ERROR)
{
printf("Alert: AL error on entry\n");
}
else
{
if (alcGetError (alcGetContextsDevice (context)) != ALC_NO_ERROR)
{
printf("Alert: ALC error on entry\n");
}
}
}
/* end of alut test */

if (alcMakeContextCurrent(NULL) == 0)
printf("alcMakeContextCurrent failed.\n");

device = alcGetContextsDevice(context);
alcDestroyContext(context);
testForALCError(device);

if (alcCloseDevice(device) == 0)
printf("alcCloseDevice failed.\n");

return 0;
}

/* -------------------------------------------------------------------------- */

void
printChar (int c, int *width)
{
putchar (c);
*width = (c == '\n') ? 0 : (*width + 1);
}

void
indent (int *width)
{
int i;
for (i = 0; i < indentation; i++)
{
printChar (' ', width);
}
}

void
printExtensions (const char *header, char separator, const char *extensions)
{
int width = 0, start = 0, end = 0;

printf ("%s:\n", header);
if (extensions == NULL || extensions[0] == '\0')
{
return;
}

indent (&width);
while (1)
{
if (extensions[end] == separator || extensions[end] == '\0')
{
if (width + end - start + 2 > maxmimumWidth)
{
printChar ('\n', &width);
indent (&width);
}
while (start < end)
{
printChar (extensions[start], &width);
start++;
}
if (extensions[end] == '\0')
{
break;
}
start++;
end++;
if (extensions[end] == '\0')
{
break;
}
printChar (',', &width);
printChar (' ', &width);
}
end++;
}
printChar ('\n', &width);
}

char *
getCommandLineOption(int argc, char **argv, const string& option)
{
int slen = option.size();
char *rv = 0;
int i;

for (i=0; i