fly/flightgear
1
0
Fork 0
Code Activity

add alcinfo instead.

Browse source
This commit is contained in:
ehofman 2009-11-29 18:08:46 +00:00 committed by Tim Moore
parent 3a4892cede
commit b4b3f62717
3 changed files with 334 additions and 117 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
tests/Makefile.am
View file

@ -1,4 +1,4 @@
bin_PROGRAMS = est-epsilon gl-info al-info
bin_PROGRAMS = est-epsilon gl-info alcinfo
noinst_PROGRAMS = test-gethostname test-mktime test-text test-up test-env-map
@ -8,8 +8,8 @@ est_epsilon_LDADD = $(opengl_LIBS)
gl_info_SOURCES = gl-info.c
gl_info_LDADD = $(opengl_LIBS)
al_info_SOURCES = al-info.c
al_info_LDADD = $(openal_LIBS)
alcinfo_SOURCES = alcinfo.c
alcinfo_LDADD = $(openal_LIBS)
test_env_map_SOURCES = test-env-map.cxx
test_env_map_LDADD = $(opengl_LIBS)

114
tests/al-info.c
View file

@ -1,114 +0,0 @@
#include <stdio.h>
#ifdef __APPLE__
# include <OpenAL/al.h>
# include <OpenAL/alc.h>
#else
# include <AL/al.h>
# include <AL/alc.h>
# ifndef __CYGWIN__
# include <AL/alext.h>
# endif
#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
#define MAX_DATA 16
int main()
{
ALCint data[MAX_DATA];
ALCdevice *device = NULL;
ALCcontext *context = NULL;
const ALchar *s;
ALCenum error;
device = alcOpenDevice(NULL);
if (device == NULL)
{
printf("No default audio device available.\n");
return -1;
}
context = alcCreateContext(device, NULL);
if (context == NULL)
{
printf("Could not create a valid context.\n");
return -2;
}
alcMakeContextCurrent(context);
s = alGetString(AL_VENDOR);
printf("AL_VENDOR = \"%s\"\n", s);
s = alGetString(AL_RENDERER);
printf("AL_RENDERER = \"%s\"\n", s);
s = alGetString(AL_VERSION);
printf("AL_VERSION = \"%s\"\n", s);
s = alGetString(AL_EXTENSIONS);
printf("AL_EXTENSIONS = \"%s\"\n", s);
alcGetError(device);
printf("\n");
if (alcIsExtensionPresent(NULL, (const ALchar *)"ALC_ENUMERATION_EXT") == AL_TRUE)
{
s = alcGetString(NULL, ALC_DEVICE_SPECIFIER);
printf("ALC_DEVICE_SPECIFIER = \"%s\"\n", s);
}
alcGetIntegerv(device, ALC_MAJOR_VERSION, 1, data);
printf("ALC_MAJOR_VERSION = %i\n", *data);
alcGetIntegerv(device, ALC_MINOR_VERSION, 1, data);
printf("ALC_MINOR_VERSION = %i\n", *data);
s = alcGetString(device, ALC_EXTENSIONS);
printf("ALC_EXTENSIONS = \"%s\"\n", s);
if ((error = alcGetError(device)))
{
printf("Error #%i occured\n", error);
return error;
}
s = alcGetString(device, ALC_DEFAULT_DEVICE_SPECIFIER);
printf("ALC_DEFAULT_DEVICE_SPECIFIER = \"%s\"\n", s);
if ((error = alcGetError(device)))
{
printf("Error #%i occured\n", error);
return error;
}
#if 0
alcGetIntegerv(device, ALC_ATTRIBUTES_SIZE, 1, &i);
printf("ALC attributes(%i): ", i);
alcGetIntegerv(device, ALC_ALL_ATTRIBUTES, i, data);
for (j=0; j<i; j++)
{
printf("%i ", data[j]);
}
printf("\n");
if ((error = alcGetError(device)))
{
printf("Error #%i occured\n", error);
return error;
}
#endif
alcCloseDevice(device);
return 0;
}

331
tests/alcinfo.c Normal file
View file

@ -0,0 +1,331 @@
/* -*- mode: C; tab-width:8; c-basic-offset:8 -*-
* vi:set ts=8:
*
* alcinfo.x
*
* alcinfo display info about a ALC extension and OpenAL renderer
*
* This file is in the Public Domain and comes with no warranty.
* Erik Hofman <erik@ehofman.com>
*
*/
#if HAVE_CONFIG_H
# include "config.h"
#endif
#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 <string.h>
#include <stdio.h>
#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 *, char *);
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]);
testForError(device, "invalid context");
alcGetIntegerv(device, ALC_REFRESH, 1, data+1);
printf("refresh rate : %u hz\n", data[0]/data[1]);
testForError(device, "invalid context");
data[0] = 0;
alcGetIntegerv(device, ALC_MONO_SOURCES, 1, data);
printf("supported sources; mono: %u, ", data[0]);
testForError(device, "invalid context");
data[0] = 0;
alcGetIntegerv(device, ALC_STEREO_SOURCES, 1, data);
printf("stereo: %u\n", data[0]);
testForError(device, "invalid context");
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, char *option)
{
int slen = strlen(option);
char *rv = 0;
int i;
for (i=0; i<argc; i++)
{
if (strncmp(argv[i], option, 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, char *s)
{
if (p == NULL)
{
printf("\nError: %s\n\n", s);
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));
}