]> git.mxchange.org Git - flightgear.git/blob - tests/alcinfo.cxx
Enable light source for transparent surfaces
[flightgear.git] / tests / alcinfo.cxx
1 /* -*- mode: C; tab-width:8; c-basic-offset:8 -*-
2  * vi:set ts=8:
3  *
4  * alcinfo.x
5  *
6  * alcinfo display info about a ALC extension and OpenAL renderer
7  *
8  * This file is in the Public Domain and comes with no warranty.
9  * Erik Hofman <erik@ehofman.com>
10  *
11  */
12
13 #if HAVE_CONFIG_H
14 # include "config.h"
15 #endif
16
17 #ifdef __APPLE__
18 # include <OpenAL/al.h>
19 # include <OpenAL/alc.h>
20 #else
21 # include <AL/al.h>
22 # include <AL/alc.h>
23 # include <AL/alext.h>
24 #endif
25
26 #ifndef AL_VERSION_1_1
27 # ifdef __APPLE__
28 #  include <OpenAL/altypes.h>
29 #  include <OpenAL/alctypes.h>
30 #else
31 #  include <AL/altypes.h>
32 #  include <AL/alctypes.h>
33 # endif
34 #endif
35
36 #include <stdlib.h>
37 #include <string.h>
38 #include <stdio.h>
39 #include <string>
40
41 using std::string;
42
43 #ifndef ALC_ALL_DEVICES_SPECIFIER
44 # define ALC_ALL_DEVICES_SPECIFIER      0x1013
45 #endif
46
47 #define MAX_DATA        16
48 static const int indentation = 4;
49 static const int maxmimumWidth = 79;
50
51 void printExtensions (const char *, char, const char *);
52 void displayDevices(const char *, const char *);
53 char *getDeviceName(int, char **);
54 void testForError(void *, const string&);
55 void testForALCError(ALCdevice *);
56
57 int main(int argc, char **argv)
58 {
59    ALCint data[MAX_DATA];
60    ALCdevice *device = NULL;
61    ALCcontext *context = NULL;
62    ALenum error;
63    char *s;
64
65    if (alcIsExtensionPresent(NULL, "ALC_enumeration_EXT") == AL_TRUE)
66    {
67       if (alcIsExtensionPresent(NULL, "ALC_enumerate_all_EXT") == AL_FALSE)
68          s = (char *)alcGetString(NULL, ALC_DEVICE_SPECIFIER);
69       else
70          s = (char *)alcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER);
71       displayDevices("output", s);
72
73       s = (char *)alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER);
74       displayDevices("input", s);
75    }
76
77    s = getDeviceName(argc, argv);
78    device = alcOpenDevice(s);
79    testForError(device, "Audio device not available.");
80
81    context = alcCreateContext(device, NULL);
82    testForError(context, "Unable to create a valid context.");
83
84    alcMakeContextCurrent(context);
85    testForALCError(device);
86
87    s = (char *)alcGetString(device, ALC_DEFAULT_DEVICE_SPECIFIER);
88    printf("default output device: %s\n", s);
89    testForALCError(device);
90
91    error = alcIsExtensionPresent(device, "ALC_EXT_capture");
92    if (error)
93    {
94       s = (char *)alcGetString(device, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
95       printf("default input device:  %s\n", s);
96       testForALCError(device);
97    }
98    printf("capture support: %s\n", (error) ? "yes" : "no");
99
100    alcGetIntegerv(device, ALC_FREQUENCY, 1, data);
101    printf("mixer frequency: %u hz\n", data[0]);
102    testForALCError(device);
103
104    alcGetIntegerv(device, ALC_REFRESH, 1, data+1);
105    printf("refresh rate : %u hz\n", data[0]/data[1]);
106    testForALCError(device);
107
108    data[0] = 0;
109    alcGetIntegerv(device, ALC_MONO_SOURCES, 1, data);
110    error = alcGetError(device);
111    if (error == AL_NONE) {
112       printf("supported sources; mono: %u, ", data[0]);
113
114       data[0] = 0;
115       alcGetIntegerv(device, ALC_STEREO_SOURCES, 1, data);
116       printf("stereo: %u\n", data[0]);
117       testForALCError(device);
118    }
119
120    printf("ALC version: ");
121    alcGetIntegerv(device, ALC_MAJOR_VERSION, 1, data);
122    printf("%i.", *data);
123    alcGetIntegerv(device, ALC_MINOR_VERSION, 1, data);
124    printf("%i\n", *data);
125    testForALCError(device);
126
127    s = (char *)alcGetString(device, ALC_EXTENSIONS);
128    printExtensions ("ALC extensions", ' ', s);
129    testForALCError(device);
130
131    s = (char *)alGetString(AL_VENDOR);
132    error = alGetError();
133    if ((error = alGetError()) != AL_NO_ERROR)
134       printf("Error #%x: %s\n", error, alGetString(error));
135    else
136       printf("OpenAL vendor string: %s\n", s);
137
138    s = (char *)alGetString(AL_RENDERER);
139    if ((error = alGetError()) != AL_NO_ERROR)
140       printf("Error #%x: %s\n", error, alGetString(error));
141    else
142       printf("OpenAL renderer string: %s\n", s);
143
144    s = (char *)alGetString(AL_VERSION);
145    if ((error = alGetError()) != AL_NO_ERROR)
146       printf("Error #%x: %s\n", error, alGetString(error));
147    else if (!s)
148       printf("Quering AL_VERSION returned NULL pointer!\n");
149    else
150       printf("OpenAL version string: %s\n", s);
151
152    s = (char *)alGetString(AL_EXTENSIONS);
153    printExtensions ("OpenAL extensions", ' ', s);
154    testForALCError(device);
155
156 /* alut testing mechanism */
157    context = alcGetCurrentContext();
158    if (context == NULL)
159    {
160       printf("Error: no current context\n");
161    }
162    else
163    {
164       if (alGetError () != AL_NO_ERROR)
165       {
166          printf("Alert: AL error on entry\n");
167       }
168       else
169       {
170          if (alcGetError (alcGetContextsDevice (context)) != ALC_NO_ERROR)
171          {
172             printf("Alert: ALC error on entry\n");
173          }
174       }
175    }
176 /* end of alut test */
177  
178    
179    if (alcMakeContextCurrent(NULL) == 0)
180       printf("alcMakeContextCurrent failed.\n");
181
182    device = alcGetContextsDevice(context);
183    alcDestroyContext(context);
184    testForALCError(device);
185
186    if (alcCloseDevice(device) == 0)
187       printf("alcCloseDevice failed.\n");
188
189    return 0;
190 }
191
192 /* -------------------------------------------------------------------------- */
193
194 void
195 printChar (int c, int *width)
196 {
197   putchar (c);
198   *width = (c == '\n') ? 0 : (*width + 1);
199 }
200
201 void
202 indent (int *width)
203 {
204   int i;
205   for (i = 0; i < indentation; i++)
206     {
207       printChar (' ', width);
208     }
209 }
210
211 void
212 printExtensions (const char *header, char separator, const char *extensions)
213 {
214   int width = 0, start = 0, end = 0;
215
216   printf ("%s:\n", header);
217   if (extensions == NULL || extensions[0] == '\0')
218     {
219       return;
220     }
221
222   indent (&width);
223   while (1)
224     {
225       if (extensions[end] == separator || extensions[end] == '\0')
226         {
227           if (width + end - start + 2 > maxmimumWidth)
228             {
229               printChar ('\n', &width);
230               indent (&width);
231             }
232           while (start < end)
233             {
234               printChar (extensions[start], &width);
235               start++;
236             }
237           if (extensions[end] == '\0')
238             {
239               break;
240             }
241           start++;
242           end++;
243           if (extensions[end] == '\0')
244             {
245               break;
246             }
247           printChar (',', &width);
248           printChar (' ', &width);
249         }
250       end++;
251     }
252   printChar ('\n', &width);
253 }
254
255 char *
256 getCommandLineOption(int argc, char **argv, const string& option)
257 {
258    int slen = option.size();
259    char *rv = 0;
260    int i;
261
262    for (i=0; i<argc; i++)
263    {
264       if (strncmp(argv[i], option.c_str(), slen) == 0)
265       {
266          i++;
267          if (i<argc) rv = argv[i];
268       }
269    }
270
271    return rv;
272 }
273
274 char *
275 getDeviceName(int argc, char **argv)
276 {
277    static char devname[255];
278    int len = 255;
279    char *s;
280
281    s = getCommandLineOption(argc, argv, "-d");
282    if (s)
283    {
284       strncpy((char *)&devname, s, len);
285       len -= strlen(s);
286
287       s = getCommandLineOption(argc, argv, "-r");
288       if (s)
289       {
290          strncat((char *)&devname, " on ", len);
291          len -= 4;
292
293          strncat((char *)&devname, s, len);
294       }
295       s = (char *)&devname;
296    }
297
298    return s;
299 }
300
301 void
302 displayDevices(const char *type, const char *list)
303 {
304    ALCchar *ptr, *nptr;
305
306    ptr = (ALCchar *)list;
307    printf("list of all available %s devices:\n", type);
308    if (!list)
309    {
310       printf("none\n");
311    }
312    else
313    {
314       nptr = ptr;
315       while (*(nptr += strlen(ptr)+1) != 0)
316       {
317          printf("  %s\n", ptr);
318          ptr = nptr;
319       }
320       printf("  %s\n", ptr);
321    }
322
323
324 void
325 testForError(void *p, const string& s)
326 {
327    if (p == NULL)
328    {
329       printf("\nError: %s\n\n", s.c_str());
330       exit(-1);
331    }
332 }
333
334 void
335 testForALCError(ALCdevice *device)
336 {
337    ALenum error;
338    error = alcGetError(device);
339    if (error != ALC_NO_ERROR)
340       printf("\nALC Error %x occurred: %s\n", error, alcGetString(device, error));
341 }