C++ 列出所有打开的设备不起作用

我发现一些例子声称使用openAL列出所有音频输出设备，但是我只能让他们列出OSX上当前选择的设备（约塞米蒂，Maverick）。我使用的是mac电脑，有默认的声卡（内置输出），还有一个airplay设备和一些sound flower设备

（注意：在windows上它列出了所有设备）

我期望

s=（char*）algetstring（NULL，ALC\u ALL\u DEVICES\u说明符）

至少列出默认卡和声音设备。它什么也不返回

s=（char*）alcGetString（NULL，ALC\u设备\u说明符）返回当前选定的设备

也许虚拟设备存在一些问题？然而，从mac设置中选择soundflower作为默认输出首先会使其显示为“内置输出”。我们还尝试使用外部DAC，得到了相同的结果

所有可用输出设备列表：内置输出

所有可用输入设备列表：内置麦克风

默认输出设备：内置输出

默认输入设备：内置麦克风


代码如下：

#ifdef __APPLE__
# include <OpenAL/al.h>
# include <OpenAL/alc.h>
#else
# include <AL/al.h>
# include <AL/alc.h>
# include <AL/alext.h>
#endif

#ifndef AL_VERSION_1_1
# ifdef __APPLE__
#  include <OpenAL/altypes.h>
#  include <OpenAL/alctypes.h>
#else
#  include <AL/altypes.h>
#  include <AL/alctypes.h>
# endif
#endif

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <string>

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("Quering 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<argc; i++)
  {
    if (strncmp(argv[i], option.c_str(), slen) == 0)
    {
      i++;
      if (i<argc) rv = argv[i];
    }
  }
  
  return rv;
}

char *
getDeviceName(int argc, char **argv)
{
  static char devname[255];
  int len = 255;
  char *s;
  
  s = getCommandLineOption(argc, argv, "-d");
  if (s)
  {
    strncpy((char *)&devname, s, len);
    len -= strlen(s);
    
    s = getCommandLineOption(argc, argv, "-r");
    if (s)
    {
      strncat((char *)&devname, " on ", len);
      len -= 4;
      
      strncat((char *)&devname, s, len);
    }
    s = (char *)&devname;
  }
  
  return s;
}

void
displayDevices(const char *type, const char *list)
{
  ALCchar *ptr, *nptr;
  
  ptr = (ALCchar *)list;
  printf("list of all available %s devices:\n", type);
  if (!list)
  {
    printf("none\n");
  }
  else
  {
    nptr = ptr;
    while (*(nptr += strlen(ptr)+1) != 0)
    {
      printf("  %s\n", ptr);
      ptr = nptr;
    }
    printf("  %s\n", ptr);
  }
}

void
testForError(void *p, const string& s)
{
  if (p == NULL)
  {
    printf("\nError: %s\n\n", s.c_str());
    exit(-1);
  }
}

void
testForALCError(ALCdevice *device)
{
  ALenum error;
  error = alcGetError(device);
  if (error != ALC_NO_ERROR)
    printf("\nALC Error %x occurred: %s\n", error, alcGetString(device, error));
}

苹果公司__
#包括
#包括
#否则
#包括
#包括
#包括
#恩迪夫
#ifndef AL_版本1_1
#苹果__
#包括
#包括
#否则
#包括
#包括
#恩迪夫
#恩迪夫
#包括
#包括
#包括
#包括
使用std:：string；
#ifndef ALC\u所有设备\u说明符
#定义ALC\u所有\u设备\u说明符0x1013
#恩迪夫
#定义MAX_数据16
静态常量int缩进=4；
静态常量int maxmimumWidth=79；
无效打印扩展（常量字符*，字符，常量字符*）；
无效显示设备（常量字符*，常量字符*）；
char*getDeviceName（int，char**）；
void testForError（void*，常量字符串&）；
无效TestForalError（ALC设备*）；
int main（int argc，字符**argv）
{
ALCint数据[最大值数据]；
ALCdevice*设备=NULL；
ALCcontext*context=NULL；
阿伦误差；
char*s；
if（alcIsExtensionPresent（NULL，“ALC_枚举_EXT”）==AL_TRUE）
{
if（alcIsExtensionPresent（NULL，“ALC_枚举所有_EXT”）==AL_FALSE）
s=（char*）alcGetString（NULL，ALC_设备_说明符）；
其他的
s=（char*）alcGetString（NULL，ALC\u所有设备\u说明符）；
显示设备（“输出”）；
s=（字符*）alcGetString（NULL，ALC\u捕获\u设备\u说明符）；
显示设备（“输入”）；
}
s=getDeviceName（argc，argv）；
设备=ALCOpendenice（多个）；
testForError（设备，“音频设备不可用”）；
context=alcreatecontext（设备，空）；
testForError（上下文，“无法创建有效上下文”）；
alcMakeContextCurrent（上下文）；
TestForalError（设备）；
s=（字符*）alcGetString（设备，ALC\U默认\U设备\U说明符）；
printf（“默认输出设备：%s\n”，s）；
TestForalError（设备）；
错误=alcIsExtensionPresent（设备，“ALC_EXT_捕获”）；
如果（错误）
{
s=（字符*）alcGetString（设备、ALC\u捕获\u默认\u设备\u说明符）；
printf（“默认输入设备：%s\n”，s）；
TestForalError（设备）；
}
printf（“捕获支持：%s\n”，（错误）？“是”：“否”）；
alcGetIntegerv（设备，ALC_频率，1，数据）；
printf（“混频器频率：%u hz\n”，数据[0]）；
TestForalError（设备）；
alcGetIntegerv（设备，ALC_刷新，1，数据+1）；
printf（“刷新率：%u hz\n”，数据[0]/data[1]）；
TestForalError（设备）；
数据[0]=0；
alcGetIntegerv（设备，ALC单声道源，1，数据）；
错误=alcGetError（设备）；
如果（错误==无）{
printf（“支持的源；mono:%u，”，数据[0]）；
数据[0]=0；
alcGetIntegerv（设备，ALC_立体声_源，1，数据）；
printf（“立体声：%u\n”，数据[0]）；
TestForalError（设备）；
}
printf（“ALC版本：”）；
alcGetIntegerv（设备，自动高度控制主版本，1，数据）；
printf（“%i.”，*数据）；
alcGetIntegerv（设备，自动高度控制次要版本，1，数据）；
printf（“%i\n”，*数据）；
TestForalError（设备）；
s=（字符*）alcGetString（设备，ALC_扩展）；
打印扩展名（“ALC扩展名”）；
TestForalError（设备）；
s=（字符*）代数字符串（AL_供应商）；
error=algeorror（）；
如果（（error=algerorr（））！=AL_无错误）
printf（“错误#%x:%s\n”，错误，代数字符串（错误））；
其他的
printf（“OpenAL供应商字符串：%s\n”，s）；
s=（char*）代数串（AL_渲染器）；
如果（（error=algerorr（））！=AL_无错误）
printf（“错误#%x:%s\n”，错误，代数字符串（错误））；
其他的
printf（“OpenAL呈现程序字符串：%s\n”，s）；
s=（char*）代数串（AL_版本）；
如果（（error=algerorr（））！=AL_无错误）
printf（“错误#%x:%s\n”，错误，代数字符串（错误））；
如果（！s）
printf（“查询AL_版本返回空指针！\n”）；
其他的
printf（“OpenAL版本字符串：%s\n”，s）；
s=（char*）代数串（AL_扩展）；
printExtensions（“OpenAL extensions”）、“”、s）；
TestForalError（设备）；
/*铝测试机构*/
context=alcGetCurrentContext（）；
if（上下文==NULL）
{
printf（“错误：没有当前上下文\n”）；
}
其他的
{
如果（alGetError（）！=AL_无错误）
{
printf（“警报：输入错误\n”）；
}
其他的
{
if（alcGetError（alcGetContextDevice（上下文））！=ALC\u无错误）
{
printf（“警报：条目上的ALC错误\n”）；
}
}
}
/*明矾试验结束*/
如果（alcMakeContextCurrent（NULL）==0）
printf（“alcMakeContextCurrent失败。\n”）；
设备=AlcGetContextDevice（上下文）；
语境（context）；
TestForalError（设备）；
如果（设备（设备）==0）
printf（“ALCloseDevice失败。\n”）；
返回0；
}
/* -------------------------------------------------------------------------- */
无效的
打印字符（整数c，整数*宽度）
{
普查尔（c）；
*宽度=（c='\n'）？0:（*宽度+1）；
}
无效的
缩进（整数*宽度）
{
int i；
对于（i=0；ig++ -o openal_list_audio_devices openal_list_audio_devices.cpp -lopenal


stens@kamchatka ~/Dropbox/Documents/code/c++ λ 
stens@kamchatka ~/Dropbox/Documents/code/c++ λ ./openal_list_audio_devices

list of all available output devices:
  Built-in Audio Analog Stereo
list of all available input devices:
  Built-in Audio Analog Stereo
  Monitor of Built-in Audio Analog Stereo
default output device: OpenAL Soft
default input device:  Built-in Audio Analog Stereo
capture support: yes
mixer frequency: 44100 hz
refresh rate : 1025 hz
supported sources; mono: 255, stereo: 1
ALC version: 1.1
ALC extensions:
    ALC_ENUMERATE_ALL_EXT, ALC_ENUMERATION_EXT, ALC_EXT_CAPTURE, 
    ALC_EXT_DEDICATED, ALC_EXT_disconnect, ALC_EXT_EFX, 
    ALC_EXT_thread_local_context, ALC_SOFT_loopback
OpenAL vendor string: OpenAL Community
OpenAL renderer string: OpenAL Soft
OpenAL version string: 1.1 ALSOFT 1.15.1
OpenAL extensions:
    AL_EXT_ALAW, AL_EXT_DOUBLE, AL_EXT_EXPONENT_DISTANCE, AL_EXT_FLOAT32, 
    AL_EXT_IMA4, AL_EXT_LINEAR_DISTANCE, AL_EXT_MCFORMATS, AL_EXT_MULAW, 
    AL_EXT_MULAW_MCFORMATS, AL_EXT_OFFSET, AL_EXT_source_distance_model, 
    AL_LOKI_quadriphonic, AL_SOFT_buffer_samples, AL_SOFT_buffer_sub_data, 
    AL_SOFTX_deferred_updates, AL_SOFT_direct_channels, AL_SOFT_loop_points, 
    AL_SOFT_source_latency