Hold the default context extensions globally
[openal-soft.git] / Alc / portaudio.c
blob5d403f298d7131ee58a5693541286676e7e3a291
1 /**
2 * OpenAL cross platform audio library
3 * Copyright (C) 1999-2007 by authors.
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
18 * Or go to http://www.gnu.org/copyleft/lgpl.html
21 #include "config.h"
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include "alMain.h"
27 #include "AL/al.h"
28 #include "AL/alc.h"
29 #ifdef HAVE_DLFCN_H
30 #include <dlfcn.h>
31 #endif
33 #include <portaudio.h>
35 static void *pa_handle;
36 #define MAKE_FUNC(x) static typeof(x) * p##x
37 MAKE_FUNC(Pa_Initialize);
38 MAKE_FUNC(Pa_Terminate);
39 MAKE_FUNC(Pa_GetErrorText);
40 MAKE_FUNC(Pa_StartStream);
41 MAKE_FUNC(Pa_StopStream);
42 MAKE_FUNC(Pa_OpenStream);
43 MAKE_FUNC(Pa_CloseStream);
44 MAKE_FUNC(Pa_GetDefaultOutputDevice);
45 MAKE_FUNC(Pa_GetStreamInfo);
46 #undef MAKE_FUNC
49 static const ALCchar pa_device[] = "PortAudio Software";
50 static volatile ALuint load_count;
53 void *pa_load(void)
55 const char *str;
56 PaError err;
58 if(load_count == 0)
60 #ifdef HAVE_DLFCN_H
61 #if defined(__APPLE__) && defined(__MACH__)
62 # define PALIB "libportaudio.2.dylib"
63 #else
64 # define PALIB "libportaudio.so.2"
65 #endif
66 pa_handle = dlopen(PALIB, RTLD_NOW);
67 if(!pa_handle)
68 return NULL;
69 dlerror();
71 #define LOAD_FUNC(f) do { \
72 p##f = (typeof(f)*)dlsym(pa_handle, #f); \
73 if((str=dlerror()) != NULL) \
74 { \
75 dlclose(pa_handle); \
76 pa_handle = NULL; \
77 AL_PRINT("Could not load %s from "PALIB": %s\n", #f, str); \
78 return NULL; \
79 } \
80 } while(0)
81 #else
82 str = NULL;
83 pa_handle = (void*)0xDEADBEEF;
84 #define LOAD_FUNC(f) p##f = f
85 #endif
87 LOAD_FUNC(Pa_Initialize);
88 LOAD_FUNC(Pa_Terminate);
89 LOAD_FUNC(Pa_GetErrorText);
90 LOAD_FUNC(Pa_StartStream);
91 LOAD_FUNC(Pa_StopStream);
92 LOAD_FUNC(Pa_OpenStream);
93 LOAD_FUNC(Pa_CloseStream);
94 LOAD_FUNC(Pa_GetDefaultOutputDevice);
95 LOAD_FUNC(Pa_GetStreamInfo);
97 #undef LOAD_FUNC
99 if((err=pPa_Initialize()) != paNoError)
101 AL_PRINT("Pa_Initialize() returned an error: %s\n", pPa_GetErrorText(err));
102 #ifdef HAVE_DLFCN_H
103 dlclose(pa_handle);
104 #endif
105 pa_handle = NULL;
106 return NULL;
109 ++load_count;
111 return pa_handle;
114 void pa_unload(void)
116 if(load_count == 0 || --load_count > 0)
117 return;
119 pPa_Terminate();
120 #ifdef HAVE_DLFCN_H
121 dlclose(pa_handle);
122 #endif
123 pa_handle = NULL;
127 typedef struct {
128 PaStream *stream;
129 } pa_data;
132 static int pa_callback(const void *inputBuffer, void *outputBuffer,
133 unsigned long framesPerBuffer, const PaStreamCallbackTimeInfo *timeInfo,
134 const PaStreamCallbackFlags statusFlags, void *userData)
136 ALCdevice *device = (ALCdevice*)userData;
138 (void)inputBuffer;
139 (void)timeInfo;
140 (void)statusFlags;
142 aluMixData(device, outputBuffer, framesPerBuffer);
143 return 0;
147 static ALCboolean pa_open_playback(ALCdevice *device, const ALCchar *deviceName)
149 const PaStreamInfo *streamInfo;
150 PaStreamParameters outParams;
151 pa_data *data;
152 PaError err;
154 if(!deviceName)
155 deviceName = pa_device;
156 else if(strcmp(deviceName, pa_device) != 0)
157 return ALC_FALSE;
159 if(!pa_load())
160 return ALC_FALSE;
162 data = (pa_data*)calloc(1, sizeof(pa_data));
163 device->ExtraData = data;
165 outParams.device = GetConfigValueInt("port", "device", -1);
166 if(outParams.device < 0)
167 outParams.device = pPa_GetDefaultOutputDevice();
168 outParams.suggestedLatency = (device->UpdateSize*device->NumUpdates) /
169 (float)device->Frequency;
170 outParams.hostApiSpecificStreamInfo = NULL;
172 switch(aluBytesFromFormat(device->Format))
174 case 1:
175 outParams.sampleFormat = paUInt8;
176 break;
177 case 2:
178 outParams.sampleFormat = paInt16;
179 break;
180 case 4:
181 outParams.sampleFormat = paFloat32;
182 break;
183 default:
184 AL_PRINT("Unknown format: 0x%x\n", device->Format);
185 device->ExtraData = NULL;
186 free(data);
187 pa_unload();
188 return ALC_FALSE;
190 outParams.channelCount = aluChannelsFromFormat(device->Format);
192 SetDefaultChannelOrder(device);
194 err = pPa_OpenStream(&data->stream, NULL, &outParams, device->Frequency,
195 device->UpdateSize, paNoFlag, pa_callback, device);
196 if(err != paNoError)
198 AL_PRINT("Pa_OpenStream() returned an error: %s\n", pPa_GetErrorText(err));
199 device->ExtraData = NULL;
200 free(data);
201 pa_unload();
202 return ALC_FALSE;
204 streamInfo = pPa_GetStreamInfo(data->stream);
206 device->szDeviceName = strdup(deviceName);
207 device->Frequency = streamInfo->sampleRate;
209 return ALC_TRUE;
212 static void pa_close_playback(ALCdevice *device)
214 pa_data *data = (pa_data*)device->ExtraData;
215 PaError err;
217 err = pPa_CloseStream(data->stream);
218 if(err != paNoError)
219 AL_PRINT("Error closing stream: %s\n", pPa_GetErrorText(err));
221 free(data);
222 device->ExtraData = NULL;
224 pa_unload();
227 static ALCboolean pa_reset_playback(ALCdevice *device)
229 pa_data *data = (pa_data*)device->ExtraData;
230 const PaStreamInfo *streamInfo;
231 PaError err;
233 streamInfo = pPa_GetStreamInfo(data->stream);
234 device->Frequency = streamInfo->sampleRate;
236 err = pPa_StartStream(data->stream);
237 if(err != paNoError)
239 AL_PRINT("Pa_StartStream() returned an error: %s\n", pPa_GetErrorText(err));
240 return ALC_FALSE;
243 return ALC_TRUE;
246 static void pa_stop_playback(ALCdevice *device)
248 pa_data *data = (pa_data*)device->ExtraData;
249 PaError err;
251 err = pPa_StopStream(data->stream);
252 if(err != paNoError)
253 AL_PRINT("Error stopping stream: %s\n", pPa_GetErrorText(err));
257 static ALCboolean pa_open_capture(ALCdevice *device, const ALCchar *deviceName)
259 return ALC_FALSE;
260 (void)device;
261 (void)deviceName;
266 static const BackendFuncs pa_funcs = {
267 pa_open_playback,
268 pa_close_playback,
269 pa_reset_playback,
270 pa_stop_playback,
271 pa_open_capture,
272 NULL,
273 NULL,
274 NULL,
275 NULL,
276 NULL
279 void alc_pa_init(BackendFuncs *func_list)
281 *func_list = pa_funcs;
284 void alc_pa_deinit(void)
288 void alc_pa_probe(int type)
290 if(!pa_load()) return;
292 if(type == DEVICE_PROBE)
293 AppendDeviceList(pa_device);
294 else if(type == ALL_DEVICE_PROBE)
295 AppendAllDeviceList(pa_device);
297 pa_unload();