Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: downloads/openal-0.0.8/src/backends/alc_backend.c @ 17

Last change on this file since 17 was 17, checked in by landauf, 16 years ago

added openal
File size: 13.9 KB
Line 
1/*
2 * This file defines the high-level interface to the sound device. It
3 * actually dispatches requests based on the architecture that we're
4 * targetting. See alc_backend.h for more of a clue.
5 */
6#include "al_siteconfig.h"
7
8#include <AL/al.h>
9#include <stdlib.h>
10#include <string.h>
11
12#include "al_config.h"
13#include "al_debug.h"
14#include "al_main.h"
15#include "backends/alc_backend.h"
16
17typedef enum
18{
19  AL_BACKEND_NONE_,
20  AL_BACKEND_NATIVE_,           /* native audio for platform */
21  AL_BACKEND_ALSA_,             /* ALSA backend */
22  AL_BACKEND_ARTS_,             /* aRts backend */
23  AL_BACKEND_DMEDIA_,           /* Irix/DMedia back-end */
24  AL_BACKEND_ESD_,              /* ESD backend */
25  AL_BACKEND_SDL_,              /* SDL backend */
26  AL_BACKEND_NULL_,             /* null backend */
27  AL_BACKEND_WAVEOUT_           /* WAVE backend */
28} ALC_BackendType;
29
30struct ALC_BackendStruct
31{
32  ALC_BackendType type;
33  ALC_OpenMode mode;
34  ALC_BackendPrivateData *privateData;
35};
36
37ALC_Backend *
38alcBackendOpen_ (ALC_OpenMode mode)
39{
40  Rcvar device_params;
41  Rcvar device_list;
42  Rcvar device;
43  ALC_BackendType type = AL_BACKEND_NONE_;
44  ALC_BackendPrivateData *privateData = NULL;
45  ALC_Backend *backend;
46  char adevname[64];            /* FIXME: magic number */
47
48  device_list = rc_lookup ("devices");
49  while (device_list != NULL)
50    {
51      device = rc_car (device_list);
52      device_list = rc_cdr (device_list);
53
54      switch (rc_type (device))
55        {
56        case ALRC_STRING:
57          rc_tostr0 (device, adevname, 64);
58          break;
59        case ALRC_SYMBOL:
60          rc_symtostr0 (device, adevname, 64);
61          break;
62        case ALRC_CONSCELL:
63          device_params = rc_cdr (device);
64          if (device_params == NULL)
65            {
66              continue;
67            }
68          rc_define ("device-params", device_params);
69          rc_symtostr0 (rc_car (device), adevname, 64);
70          break;
71        default:
72          _alDebug (ALD_CONTEXT, __FILE__, __LINE__,
73                    "alcBackendOpen_: bad type %s for device",
74                    rc_typestr (rc_type (device)));
75          continue;
76        }
77
78      if (strcmp (adevname, "dsp") == 0)
79        {
80          _alDebug (ALD_CONTEXT, __FILE__, __LINE__,
81                    "alcBackendOpen_: 'dsp' is a deprecated device name. Use 'native' instead.");
82          privateData = alcBackendOpenNative_ (mode);
83          if (privateData != NULL)
84            {
85              type = AL_BACKEND_NATIVE_;
86              break;
87            }
88        }
89      if (strcmp (adevname, "native") == 0)
90        {
91          privateData = alcBackendOpenNative_ (mode);
92          if (privateData != NULL)
93            {
94              type = AL_BACKEND_NATIVE_;
95              break;
96            }
97        }
98
99      if (strcmp (adevname, "alsa") == 0)
100        {
101          privateData = alcBackendOpenALSA_ (mode);
102          if (privateData != NULL)
103            {
104              type = AL_BACKEND_ALSA_;
105              break;
106            }
107        }
108
109      if (strcmp (adevname, "arts") == 0)
110        {
111          privateData = alcBackendOpenARts_ (mode);
112          if (privateData != NULL)
113            {
114              type = AL_BACKEND_ARTS_;
115              break;
116            }
117        }
118
119      if (strcmp (adevname, "dmedia") == 0)
120        {
121          privateData = alcBackendOpenDMedia_ (mode);
122          if (privateData != NULL)
123            {
124              type = AL_BACKEND_DMEDIA_;
125              break;
126            }
127        }
128
129      if (strcmp (adevname, "esd") == 0)
130        {
131          privateData = alcBackendOpenESD_ (mode);
132          if (privateData != NULL)
133            {
134              type = AL_BACKEND_ESD_;
135              break;
136            }
137        }
138
139      if (strcmp (adevname, "sdl") == 0)
140        {
141          privateData = alcBackendOpenSDL_ (mode);
142          if (privateData != NULL)
143            {
144              type = AL_BACKEND_SDL_;
145              break;
146            }
147        }
148
149      if (strcmp (adevname, "null") == 0)
150        {
151          privateData = alcBackendOpenNull_ (mode);
152          if (privateData != NULL)
153            {
154              type = AL_BACKEND_NULL_;
155              break;
156            }
157        }
158
159      if (strcmp (adevname, "waveout") == 0)
160        {
161          privateData = alcBackendOpenWAVE_ (mode);
162          if (privateData != NULL)
163            {
164              type = AL_BACKEND_WAVEOUT_;
165              break;
166            }
167        }
168    }
169
170  /* fallback: native */
171  if (type == AL_BACKEND_NONE_)
172    {
173      privateData = alcBackendOpenNative_ (mode);
174      if (privateData != NULL)
175        {
176          type = AL_BACKEND_NATIVE_;
177        }
178    }
179
180  if (type == AL_BACKEND_NONE_)
181    {
182      return NULL;
183    }
184
185  backend =
186    (struct ALC_BackendStruct *) malloc (sizeof (struct ALC_BackendStruct));
187  if (backend == NULL)
188    {
189      return NULL;
190    }
191
192  backend->type = type;
193  backend->mode = mode;
194  backend->privateData = privateData;
195  return backend;
196
197}
198
199ALboolean
200alcBackendClose_ (ALC_Backend *backend)
201{
202  switch (backend->type)
203    {
204    case AL_BACKEND_NATIVE_:
205      release_native (backend->privateData);
206      break;
207    case AL_BACKEND_ALSA_:
208      release_alsa (backend->privateData);
209      break;
210    case AL_BACKEND_ARTS_:
211      release_arts (backend->privateData);
212      break;
213    case AL_BACKEND_DMEDIA_:
214      release_dmedia (backend->privateData);
215      break;
216    case AL_BACKEND_ESD_:
217      release_esd (backend->privateData);
218      break;
219    case AL_BACKEND_SDL_:
220      release_sdl (backend->privateData);
221      break;
222    case AL_BACKEND_NULL_:
223      release_null (backend->privateData);
224      break;
225    case AL_BACKEND_WAVEOUT_:
226      release_waveout (backend->privateData);
227      break;
228    default:
229      _alDebug (ALD_CONTEXT, __FILE__, __LINE__,
230                "alcBackendClose_: unknown backend %d\n", backend->type);
231      return AL_FALSE;
232    }
233  free (backend);
234  return AL_TRUE;
235}
236
237void
238alcBackendPause_ (ALC_Backend *backend)
239{
240  switch (backend->type)
241    {
242    case AL_BACKEND_NATIVE_:
243      pause_nativedevice (backend->privateData);
244      break;
245    case AL_BACKEND_ALSA_:
246      pause_alsa (backend->privateData);
247      break;
248    case AL_BACKEND_ARTS_:
249      pause_arts (backend->privateData);
250      break;
251    case AL_BACKEND_DMEDIA_:
252      pause_dmedia (backend->privateData);
253      break;
254    case AL_BACKEND_ESD_:
255      pause_esd (backend->privateData);
256      break;
257    case AL_BACKEND_SDL_:
258      pause_sdl (backend->privateData);
259      break;
260    case AL_BACKEND_NULL_:
261      pause_null (backend->privateData);
262      break;
263    case AL_BACKEND_WAVEOUT_:
264      pause_waveout (backend->privateData);
265      break;
266    default:
267      _alDebug (ALD_CONTEXT, __FILE__, __LINE__,
268                "alcBackendPause_: unknown backend %d\n", backend->type);
269      break;
270    }
271}
272
273void
274alcBackendResume_ (ALC_Backend *backend)
275{
276  switch (backend->type)
277    {
278    case AL_BACKEND_NATIVE_:
279      resume_nativedevice (backend->privateData);
280      break;
281    case AL_BACKEND_ALSA_:
282      resume_alsa (backend->privateData);
283      break;
284    case AL_BACKEND_ARTS_:
285      resume_arts (backend->privateData);
286      break;
287    case AL_BACKEND_DMEDIA_:
288      resume_dmedia (backend->privateData);
289      break;
290    case AL_BACKEND_ESD_:
291      resume_esd (backend->privateData);
292      break;
293    case AL_BACKEND_SDL_:
294      resume_sdl (backend->privateData);
295      break;
296    case AL_BACKEND_NULL_:
297      resume_null (backend->privateData);
298      break;
299    case AL_BACKEND_WAVEOUT_:
300      resume_waveout (backend->privateData);
301      break;
302    default:
303      _alDebug (ALD_CONTEXT, __FILE__, __LINE__,
304                "alcBackendResume_: unknown backend %d\n", backend->type);
305      break;
306    }
307}
308
309ALboolean
310alcBackendSetAttributes_ (ALC_Backend *backend, ALuint *bufsiz,
311                          ALenum *fmt, ALuint *speed)
312{
313  switch (backend->type)
314    {
315    case AL_BACKEND_NATIVE_:
316      return alcBackendSetAttributesNative_ (backend->mode,
317                                             backend->privateData, bufsiz,
318                                             fmt, speed);
319    case AL_BACKEND_ALSA_:
320      return alcBackendSetAttributesALSA_ (backend->mode,
321                                           backend->privateData, bufsiz, fmt,
322                                           speed);
323    case AL_BACKEND_ARTS_:
324      return alcBackendSetAttributesARts_ (backend->mode,
325                                           backend->privateData, bufsiz, fmt,
326                                           speed);
327    case AL_BACKEND_DMEDIA_:
328      return alcBackendSetAttributesDMedia_ (backend->mode,
329                                             backend->privateData, bufsiz,
330                                             fmt, speed);
331    case AL_BACKEND_ESD_:
332      return alcBackendSetAttributesESD_ (backend->mode, backend->privateData,
333                                          bufsiz, fmt, speed);
334    case AL_BACKEND_SDL_:
335      return alcBackendSetAttributesSDL_ (backend->mode, backend->privateData,
336                                          bufsiz, fmt, speed);
337    case AL_BACKEND_NULL_:
338      return alcBackendSetAttributesNull_ (backend->mode,
339                                           backend->privateData, bufsiz, fmt,
340                                           speed);
341    case AL_BACKEND_WAVEOUT_:
342      return alcBackendSetAttributesWAVE_ (backend->mode,
343                                           backend->privateData, bufsiz, fmt,
344                                           speed);
345    default:
346      _alDebug (ALD_CONTEXT, __FILE__, __LINE__,
347                "alcBackendSetWrite_: unknown backend %d\n", backend->type);
348      return AL_FALSE;
349    }
350}
351
352void
353alcBackendWrite_ (ALC_Backend *backend, void *dataptr, int bytes_to_write)
354{
355  switch (backend->type)
356    {
357    case AL_BACKEND_NATIVE_:
358      native_blitbuffer (backend->privateData, dataptr, bytes_to_write);
359      break;
360    case AL_BACKEND_ALSA_:
361      alsa_blitbuffer (backend->privateData, dataptr, bytes_to_write);
362      break;
363    case AL_BACKEND_ARTS_:
364      arts_blitbuffer (backend->privateData, dataptr, bytes_to_write);
365      break;
366    case AL_BACKEND_DMEDIA_:
367      dmedia_blitbuffer (backend->privateData, dataptr, bytes_to_write);
368      break;
369    case AL_BACKEND_ESD_:
370      esd_blitbuffer (backend->privateData, dataptr, bytes_to_write);
371      break;
372    case AL_BACKEND_SDL_:
373      sdl_blitbuffer (backend->privateData, dataptr, bytes_to_write);
374      break;
375    case AL_BACKEND_NULL_:
376      null_blitbuffer (backend->privateData, dataptr, bytes_to_write);
377      break;
378    case AL_BACKEND_WAVEOUT_:
379      waveout_blitbuffer (backend->privateData, dataptr, bytes_to_write);
380      break;
381    default:
382      _alDebug (ALD_CONTEXT, __FILE__, __LINE__,
383                "alcBackendWrite_: unknown backend %d\n", backend->type);
384      break;
385    }
386}
387
388ALsizei
389alcBackendRead_ (ALC_Backend *backend, void *capture_buffer, int bufsiz)
390{
391  switch (backend->type)
392    {
393    case AL_BACKEND_NATIVE_:
394      return capture_nativedevice (backend->privateData, capture_buffer,
395                                   bufsiz);
396    case AL_BACKEND_ALSA_:
397      return capture_alsa (backend->privateData, capture_buffer, bufsiz);
398    case AL_BACKEND_ARTS_:
399      return capture_arts (backend->privateData, capture_buffer, bufsiz);
400    case AL_BACKEND_DMEDIA_:
401      return capture_dmedia (backend->privateData, capture_buffer, bufsiz);
402    case AL_BACKEND_ESD_:
403      return capture_esd (backend->privateData, capture_buffer, bufsiz);
404    case AL_BACKEND_SDL_:
405      return capture_sdl (backend->privateData, capture_buffer, bufsiz);
406    case AL_BACKEND_NULL_:
407      return capture_null (backend->privateData, capture_buffer, bufsiz);
408    case AL_BACKEND_WAVEOUT_:
409      return capture_waveout (backend->privateData, capture_buffer, bufsiz);
410    default:
411      _alDebug (ALD_CONTEXT, __FILE__, __LINE__,
412                "alcBackendRead_: unknown backend %d\n", backend->type);
413      return 0;
414    }
415}
416
417ALfloat
418alcBackendGetAudioChannel_ (ALC_Backend *backend, ALuint channel)
419{
420  switch (backend->type)
421    {
422    case AL_BACKEND_NATIVE_:
423      return get_nativechannel (backend->privateData, channel);
424    case AL_BACKEND_ALSA_:
425      return get_alsachannel (backend->privateData, channel);
426    case AL_BACKEND_ARTS_:
427      return get_artschannel (backend->privateData, channel);
428    case AL_BACKEND_DMEDIA_:
429      return get_dmediachannel (backend->privateData, channel);
430    case AL_BACKEND_ESD_:
431      return get_esdchannel (backend->privateData, channel);
432    case AL_BACKEND_SDL_:
433      return get_sdlchannel (backend->privateData, channel);
434    case AL_BACKEND_NULL_:
435      return get_nullchannel (backend->privateData, channel);
436    case AL_BACKEND_WAVEOUT_:
437      return get_waveoutchannel (backend->privateData, channel);
438    default:
439      _alDebug (ALD_CONTEXT, __FILE__, __LINE__,
440                "alcBackendGetAudioChannel_: unknown backend %d\n",
441                backend->type);
442      return 0;
443    }
444}
445
446void
447alcBackendSetAudioChannel_ (ALC_Backend *backend, ALuint channel,
448                            ALfloat volume)
449{
450  switch (backend->type)
451    {
452    case AL_BACKEND_NATIVE_:
453      set_nativechannel (backend->privateData, channel, volume);
454      break;
455    case AL_BACKEND_ALSA_:
456      set_alsachannel (backend->privateData, channel, volume);
457      break;
458    case AL_BACKEND_ARTS_:
459      set_artschannel (backend->privateData, channel, volume);
460      break;
461    case AL_BACKEND_DMEDIA_:
462      set_dmediachannel (backend->privateData, channel, volume);
463      break;
464    case AL_BACKEND_ESD_:
465      set_esdchannel (backend->privateData, channel, volume);
466      break;
467    case AL_BACKEND_SDL_:
468      set_sdlchannel (backend->privateData, channel, volume);
469      break;
470    case AL_BACKEND_NULL_:
471      set_nullchannel (backend->privateData, channel, volume);
472      break;
473    case AL_BACKEND_WAVEOUT_:
474      set_waveoutchannel (backend->privateData, channel, volume);
475      break;
476    default:
477      _alDebug (ALD_CONTEXT, __FILE__, __LINE__,
478                "alcBackendSetAudioChannel_: unknown backend %d\n",
479                backend->type);
480      break;
481    }
482}
Note: See TracBrowser for help on using the repository browser.