Mercurial > mplayer.hg
annotate libao2/ao_pulse.c @ 26207:55a36b9e708e
Fix wrong res_comment.
author | diego |
---|---|
date | Sat, 15 Mar 2008 08:21:02 +0000 |
parents | bd46b759fd35 |
children | d48e2d7191df |
rev | line source |
---|---|
24782 | 1 /* |
2 * PulseAudio audio output driver. | |
3 * Copyright (C) 2006 Lennart Poettering | |
4 * Copyright (C) 2007 Reimar Doeffinger | |
5 * | |
6 * This file is part of MPlayer. | |
7 * | |
8 * MPlayer is free software; you can redistribute it and/or modify | |
9 * it under the terms of the GNU General Public License as published by | |
10 * the Free Software Foundation; either version 2 of the License, or | |
11 * (at your option) any later version. | |
12 * | |
13 * MPlayer is distributed in the hope that it will be useful, | |
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 * GNU General Public License for more details. | |
17 * | |
18 * You should have received a copy of the GNU General Public License | |
19 * along with MPlayer; if not, write to the Free Software | |
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
21 */ | |
22 #include <string.h> | |
23 | |
24 #include <pulse/pulseaudio.h> | |
25 | |
26 #include "config.h" | |
27 #include "libaf/af_format.h" | |
28 #include "mp_msg.h" | |
29 #include "audio_out.h" | |
30 #include "audio_out_internal.h" | |
31 | |
32 #define PULSE_CLIENT_NAME "MPlayer" | |
33 | |
34 /** General driver info */ | |
35 static ao_info_t info = { | |
36 "PulseAudio audio output", | |
37 "pulse", | |
38 "Lennart Poettering", | |
39 "" | |
40 }; | |
41 | |
42 /** PulseAudio playback stream object */ | |
43 static struct pa_stream *stream; | |
44 | |
45 /** PulseAudio connection context */ | |
46 static struct pa_context *context; | |
47 | |
48 /** Main event loop object */ | |
49 static struct pa_threaded_mainloop *mainloop; | |
50 | |
51 /** A temporary variable to store the current volume */ | |
52 static pa_cvolume volume; | |
53 | |
54 LIBAO_EXTERN(pulse) | |
55 | |
56 #define GENERIC_ERR_MSG(ctx, str) \ | |
57 mp_msg(MSGT_AO, MSGL_ERR, "AO: [pulse] "str": %s\n", \ | |
58 pa_strerror(pa_context_errno(ctx))) | |
59 | |
60 static void context_state_cb(pa_context *c, void *userdata) { | |
61 switch (pa_context_get_state(c)) { | |
62 case PA_CONTEXT_READY: | |
63 case PA_CONTEXT_TERMINATED: | |
64 case PA_CONTEXT_FAILED: | |
65 pa_threaded_mainloop_signal(mainloop, 0); | |
66 break; | |
67 } | |
68 } | |
69 | |
70 static void stream_state_cb(pa_stream *s, void *userdata) { | |
71 switch (pa_stream_get_state(s)) { | |
72 case PA_STREAM_READY: | |
73 case PA_STREAM_FAILED: | |
74 case PA_STREAM_TERMINATED: | |
75 pa_threaded_mainloop_signal(mainloop, 0); | |
76 break; | |
77 } | |
78 } | |
79 | |
80 static void stream_request_cb(pa_stream *s, size_t length, void *userdata) { | |
81 pa_threaded_mainloop_signal(mainloop, 0); | |
82 } | |
83 | |
84 static void stream_latency_update_cb(pa_stream *s, void *userdata) { | |
85 pa_threaded_mainloop_signal(mainloop, 0); | |
86 } | |
87 | |
88 static void success_cb(pa_stream *s, int success, void *userdata) { | |
89 if (userdata) | |
90 *(int *)userdata = success; | |
91 pa_threaded_mainloop_signal(mainloop, 0); | |
92 } | |
93 | |
25383 | 94 /** |
95 * \brief waits for a pulseaudio operation to finish, frees it and | |
96 * unlocks the mainloop | |
97 * \param op operation to wait for | |
98 * \return 1 if operation has finished normally (DONE state), 0 otherwise | |
99 */ | |
24782 | 100 static int waitop(pa_operation *op) { |
101 pa_operation_state_t state; | |
102 if (!op) return 0; | |
103 state = pa_operation_get_state(op); | |
104 while (state == PA_OPERATION_RUNNING) { | |
105 pa_threaded_mainloop_wait(mainloop); | |
106 state = pa_operation_get_state(op); | |
107 } | |
108 pa_operation_unref(op); | |
109 pa_threaded_mainloop_unlock(mainloop); | |
110 return state == PA_OPERATION_DONE; | |
111 } | |
112 | |
113 static const struct format_map_s { | |
114 int mp_format; | |
115 pa_sample_format_t pa_format; | |
116 } format_maps[] = { | |
117 {AF_FORMAT_U8, PA_SAMPLE_U8}, | |
118 {AF_FORMAT_S16_LE, PA_SAMPLE_S16LE}, | |
119 {AF_FORMAT_S16_BE, PA_SAMPLE_S16BE}, | |
120 {AF_FORMAT_FLOAT_LE, PA_SAMPLE_FLOAT32LE}, | |
121 {AF_FORMAT_FLOAT_BE, PA_SAMPLE_FLOAT32BE}, | |
122 {AF_FORMAT_MU_LAW, PA_SAMPLE_ULAW}, | |
123 {AF_FORMAT_A_LAW, PA_SAMPLE_ALAW}, | |
124 {AF_FORMAT_UNKNOWN, 0} | |
125 }; | |
126 | |
127 static int init(int rate_hz, int channels, int format, int flags) { | |
128 struct pa_sample_spec ss; | |
129 struct pa_channel_map map; | |
130 const struct format_map_s *fmt_map; | |
24921
148ca265fcb6
Change parsing to allow host == NULL and sink != NULL
reimar
parents:
24920
diff
changeset
|
131 char *devarg = NULL; |
24782 | 132 char *host = NULL; |
24919
51372a34bc7d
Make sink variable local, it is only used in one place
reimar
parents:
24782
diff
changeset
|
133 char *sink = NULL; |
24782 | 134 |
135 if (ao_subdevice) { | |
24921
148ca265fcb6
Change parsing to allow host == NULL and sink != NULL
reimar
parents:
24920
diff
changeset
|
136 devarg = strdup(ao_subdevice); |
148ca265fcb6
Change parsing to allow host == NULL and sink != NULL
reimar
parents:
24920
diff
changeset
|
137 sink = strchr(devarg, ':'); |
24920 | 138 if (sink) *sink++ = 0; |
24921
148ca265fcb6
Change parsing to allow host == NULL and sink != NULL
reimar
parents:
24920
diff
changeset
|
139 if (devarg[0]) host = devarg; |
24782 | 140 } |
141 | |
142 ss.channels = channels; | |
143 ss.rate = rate_hz; | |
144 | |
145 ao_data.samplerate = rate_hz; | |
146 ao_data.format = format; | |
147 ao_data.channels = channels; | |
148 | |
149 fmt_map = format_maps; | |
150 while (fmt_map->mp_format != format) { | |
151 if (fmt_map->mp_format == AF_FORMAT_UNKNOWN) { | |
152 mp_msg(MSGT_AO, MSGL_ERR, "AO: [pulse] Unsupported sample spec\n"); | |
153 goto fail; | |
154 } | |
155 fmt_map++; | |
156 } | |
157 ss.format = fmt_map->pa_format; | |
158 | |
159 if (!pa_sample_spec_valid(&ss)) { | |
160 mp_msg(MSGT_AO, MSGL_ERR, "AO: [pulse] Invalid sample spec\n"); | |
161 goto fail; | |
162 } | |
163 | |
164 pa_channel_map_init_auto(&map, ss.channels, PA_CHANNEL_MAP_ALSA); | |
165 ao_data.bps = pa_bytes_per_second(&ss); | |
166 | |
167 pa_cvolume_reset(&volume, ss.channels); | |
168 | |
169 if (!(mainloop = pa_threaded_mainloop_new())) { | |
170 mp_msg(MSGT_AO, MSGL_ERR, "AO: [pulse] Failed to allocate main loop\n"); | |
171 goto fail; | |
172 } | |
173 | |
174 if (!(context = pa_context_new(pa_threaded_mainloop_get_api(mainloop), PULSE_CLIENT_NAME))) { | |
175 mp_msg(MSGT_AO, MSGL_ERR, "AO: [pulse] Failed to allocate context\n"); | |
176 goto fail; | |
177 } | |
178 | |
179 pa_context_set_state_callback(context, context_state_cb, NULL); | |
180 | |
181 if (pa_context_connect(context, host, 0, NULL) < 0) | |
182 goto fail; | |
183 | |
184 pa_threaded_mainloop_lock(mainloop); | |
185 | |
186 if (pa_threaded_mainloop_start(mainloop) < 0) | |
187 goto unlock_and_fail; | |
188 | |
189 /* Wait until the context is ready */ | |
190 pa_threaded_mainloop_wait(mainloop); | |
191 | |
192 if (pa_context_get_state(context) != PA_CONTEXT_READY) | |
193 goto unlock_and_fail; | |
194 | |
195 if (!(stream = pa_stream_new(context, "audio stream", &ss, &map))) | |
196 goto unlock_and_fail; | |
197 | |
198 pa_stream_set_state_callback(stream, stream_state_cb, NULL); | |
199 pa_stream_set_write_callback(stream, stream_request_cb, NULL); | |
200 pa_stream_set_latency_update_callback(stream, stream_latency_update_cb, NULL); | |
201 | |
202 if (pa_stream_connect_playback(stream, sink, NULL, PA_STREAM_INTERPOLATE_TIMING|PA_STREAM_AUTO_TIMING_UPDATE, &volume, NULL) < 0) | |
203 goto unlock_and_fail; | |
204 | |
205 /* Wait until the stream is ready */ | |
206 pa_threaded_mainloop_wait(mainloop); | |
207 | |
208 if (pa_stream_get_state(stream) != PA_STREAM_READY) | |
209 goto unlock_and_fail; | |
210 | |
211 pa_threaded_mainloop_unlock(mainloop); | |
212 | |
24921
148ca265fcb6
Change parsing to allow host == NULL and sink != NULL
reimar
parents:
24920
diff
changeset
|
213 free(devarg); |
24782 | 214 return 1; |
215 | |
216 unlock_and_fail: | |
217 | |
218 if (mainloop) | |
219 pa_threaded_mainloop_unlock(mainloop); | |
220 | |
221 fail: | |
222 if (context) | |
223 GENERIC_ERR_MSG(context, "Init failed"); | |
24921
148ca265fcb6
Change parsing to allow host == NULL and sink != NULL
reimar
parents:
24920
diff
changeset
|
224 free(devarg); |
24782 | 225 uninit(1); |
226 return 0; | |
227 } | |
228 | |
229 /** Destroy libao driver */ | |
230 static void uninit(int immed) { | |
231 if (stream && !immed) { | |
232 pa_threaded_mainloop_lock(mainloop); | |
233 waitop(pa_stream_drain(stream, success_cb, NULL)); | |
234 } | |
235 | |
236 if (mainloop) | |
237 pa_threaded_mainloop_stop(mainloop); | |
238 | |
239 if (stream) { | |
240 pa_stream_disconnect(stream); | |
241 pa_stream_unref(stream); | |
242 stream = NULL; | |
243 } | |
244 | |
245 if (context) { | |
246 pa_context_disconnect(context); | |
247 pa_context_unref(context); | |
248 context = NULL; | |
249 } | |
250 | |
251 if (mainloop) { | |
252 pa_threaded_mainloop_free(mainloop); | |
253 mainloop = NULL; | |
254 } | |
255 } | |
256 | |
257 /** Play the specified data to the pulseaudio server */ | |
258 static int play(void* data, int len, int flags) { | |
25386
bd46b759fd35
pa_stream_write reportedly needs locking of the main loop
reimar
parents:
25385
diff
changeset
|
259 pa_threaded_mainloop_lock(mainloop); |
25385 | 260 if (pa_stream_write(stream, data, len, NULL, 0, PA_SEEK_RELATIVE) < 0) { |
261 GENERIC_ERR_MSG(context, "pa_stream_write() failed"); | |
25386
bd46b759fd35
pa_stream_write reportedly needs locking of the main loop
reimar
parents:
25385
diff
changeset
|
262 len = -1; |
25385 | 263 } |
25386
bd46b759fd35
pa_stream_write reportedly needs locking of the main loop
reimar
parents:
25385
diff
changeset
|
264 pa_threaded_mainloop_unlock(mainloop); |
24782 | 265 return len; |
266 } | |
267 | |
268 static void cork(int b) { | |
269 int success = 0; | |
270 pa_threaded_mainloop_lock(mainloop); | |
271 if (!waitop(pa_stream_cork(stream, b, success_cb, &success)) || | |
272 !success) | |
273 GENERIC_ERR_MSG(context, "pa_stream_cork() failed"); | |
274 } | |
275 | |
276 /** Pause the audio stream by corking it on the server */ | |
277 static void audio_pause(void) { | |
278 cork(1); | |
279 } | |
280 | |
281 /** Resume the audio stream by uncorking it on the server */ | |
282 static void audio_resume(void) { | |
283 cork(0); | |
284 } | |
285 | |
286 /** Reset the audio stream, i.e. flush the playback buffer on the server side */ | |
287 static void reset(void) { | |
288 int success = 0; | |
289 pa_threaded_mainloop_lock(mainloop); | |
290 if (!waitop(pa_stream_flush(stream, success_cb, &success)) || | |
291 !success) | |
292 GENERIC_ERR_MSG(context, "pa_stream_flush() failed"); | |
293 } | |
294 | |
295 /** Return number of bytes that may be written to the server without blocking */ | |
296 static int get_space(void) { | |
297 size_t l; | |
298 pa_threaded_mainloop_lock(mainloop); | |
299 l = pa_stream_writable_size(stream); | |
300 pa_threaded_mainloop_unlock(mainloop); | |
24923 | 301 return l; |
24782 | 302 } |
303 | |
304 /** Return the current latency in seconds */ | |
305 static float get_delay(void) { | |
306 pa_usec_t latency = (pa_usec_t) -1; | |
307 pa_threaded_mainloop_lock(mainloop); | |
308 while (pa_stream_get_latency(stream, &latency, NULL) < 0) { | |
309 if (pa_context_errno(context) != PA_ERR_NODATA) { | |
310 GENERIC_ERR_MSG(context, "pa_stream_get_latency() failed"); | |
311 break; | |
312 } | |
313 /* Wait until latency data is available again */ | |
314 pa_threaded_mainloop_wait(mainloop); | |
315 } | |
316 pa_threaded_mainloop_unlock(mainloop); | |
317 return latency == (pa_usec_t) -1 ? 0 : latency / 1000000.0; | |
318 } | |
319 | |
320 /** A callback function that is called when the | |
321 * pa_context_get_sink_input_info() operation completes. Saves the | |
322 * volume field of the specified structure to the global variable volume. */ | |
323 static void info_func(struct pa_context *c, const struct pa_sink_input_info *i, int is_last, void *userdata) { | |
324 if (is_last < 0) { | |
325 GENERIC_ERR_MSG(context, "Failed to get sink input info"); | |
326 return; | |
327 } | |
328 if (!i) | |
329 return; | |
330 volume = i->volume; | |
331 pa_threaded_mainloop_signal(mainloop, 0); | |
332 } | |
333 | |
334 static int control(int cmd, void *arg) { | |
335 switch (cmd) { | |
336 case AOCONTROL_GET_VOLUME: { | |
337 ao_control_vol_t *vol = arg; | |
338 uint32_t devidx = pa_stream_get_index(stream); | |
339 pa_threaded_mainloop_lock(mainloop); | |
340 if (!waitop(pa_context_get_sink_input_info(context, devidx, info_func, NULL))) { | |
341 GENERIC_ERR_MSG(context, "pa_stream_get_sink_input_info() failed"); | |
342 return CONTROL_ERROR; | |
343 } | |
344 | |
345 if (volume.channels != 2) | |
346 vol->left = vol->right = pa_cvolume_avg(&volume)*100/PA_VOLUME_NORM; | |
347 else { | |
348 vol->left = volume.values[0]*100/PA_VOLUME_NORM; | |
349 vol->right = volume.values[1]*100/PA_VOLUME_NORM; | |
350 } | |
351 | |
352 return CONTROL_OK; | |
353 } | |
354 | |
355 case AOCONTROL_SET_VOLUME: { | |
356 const ao_control_vol_t *vol = arg; | |
357 pa_operation *o; | |
358 | |
359 if (volume.channels != 2) | |
360 pa_cvolume_set(&volume, volume.channels, (pa_volume_t)vol->left*PA_VOLUME_NORM/100); | |
361 else { | |
362 volume.values[0] = (pa_volume_t)vol->left*PA_VOLUME_NORM/100; | |
363 volume.values[1] = (pa_volume_t)vol->right*PA_VOLUME_NORM/100; | |
364 } | |
365 | |
366 if (!(o = pa_context_set_sink_input_volume(context, pa_stream_get_index(stream), &volume, NULL, NULL))) { | |
367 GENERIC_ERR_MSG(context, "pa_context_set_sink_input_volume() failed"); | |
368 return CONTROL_ERROR; | |
369 } | |
370 /* We don't wait for completion here */ | |
371 pa_operation_unref(o); | |
372 return CONTROL_OK; | |
373 } | |
374 | |
375 default: | |
376 return CONTROL_UNKNOWN; | |
377 } | |
378 } |