![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to paaudio.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / audio|
Return to paaudio.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / audio |
1.1 root 1: /* public domain */
2: #include "qemu-common.h"
3: #include "audio.h"
4:
5: #include <pulse/simple.h>
6: #include <pulse/error.h>
7:
8: #define AUDIO_CAP "pulseaudio"
9: #include "audio_int.h"
10: #include "audio_pt_int.h"
11:
12: typedef struct {
13: HWVoiceOut hw;
14: int done;
15: int live;
16: int decr;
17: int rpos;
18: pa_simple *s;
19: void *pcm_buf;
20: struct audio_pt pt;
21: } PAVoiceOut;
22:
23: typedef struct {
24: HWVoiceIn hw;
25: int done;
26: int dead;
27: int incr;
28: int wpos;
29: pa_simple *s;
30: void *pcm_buf;
31: struct audio_pt pt;
32: } PAVoiceIn;
33:
34: static struct {
35: int samples;
36: int divisor;
37: char *server;
38: char *sink;
39: char *source;
40: } conf = {
41: 1024,
42: 2,
43: NULL,
44: NULL,
45: NULL
46: };
47:
48: static void GCC_FMT_ATTR (2, 3) qpa_logerr (int err, const char *fmt, ...)
49: {
50: va_list ap;
51:
52: va_start (ap, fmt);
53: AUD_vlog (AUDIO_CAP, fmt, ap);
54: va_end (ap);
55:
56: AUD_log (AUDIO_CAP, "Reason: %s\n", pa_strerror (err));
57: }
58:
59: static void *qpa_thread_out (void *arg)
60: {
61: PAVoiceOut *pa = arg;
62: HWVoiceOut *hw = &pa->hw;
63: int threshold;
64:
65: threshold = conf.divisor ? hw->samples / conf.divisor : 0;
66:
67: if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {
68: return NULL;
69: }
70:
71: for (;;) {
72: int decr, to_mix, rpos;
73:
74: for (;;) {
75: if (pa->done) {
76: goto exit;
77: }
78:
79: if (pa->live > threshold) {
80: break;
81: }
82:
83: if (audio_pt_wait (&pa->pt, AUDIO_FUNC)) {
84: goto exit;
85: }
86: }
87:
88: decr = to_mix = pa->live;
89: rpos = hw->rpos;
90:
91: if (audio_pt_unlock (&pa->pt, AUDIO_FUNC)) {
92: return NULL;
93: }
94:
95: while (to_mix) {
96: int error;
97: int chunk = audio_MIN (to_mix, hw->samples - rpos);
98: struct st_sample *src = hw->mix_buf + rpos;
99:
100: hw->clip (pa->pcm_buf, src, chunk);
101:
102: if (pa_simple_write (pa->s, pa->pcm_buf,
103: chunk << hw->info.shift, &error) < 0) {
104: qpa_logerr (error, "pa_simple_write failed\n");
105: return NULL;
106: }
107:
108: rpos = (rpos + chunk) % hw->samples;
109: to_mix -= chunk;
110: }
111:
112: if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {
113: return NULL;
114: }
115:
116: pa->rpos = rpos;
117: pa->live -= decr;
118: pa->decr += decr;
119: }
120:
121: exit:
122: audio_pt_unlock (&pa->pt, AUDIO_FUNC);
123: return NULL;
124: }
125:
126: static int qpa_run_out (HWVoiceOut *hw)
127: {
128: int live, decr;
129: PAVoiceOut *pa = (PAVoiceOut *) hw;
130:
131: if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {
132: return 0;
133: }
134:
135: live = audio_pcm_hw_get_live_out (hw);
136: decr = audio_MIN (live, pa->decr);
137: pa->decr -= decr;
138: pa->live = live - decr;
139: hw->rpos = pa->rpos;
140: if (pa->live > 0) {
141: audio_pt_unlock_and_signal (&pa->pt, AUDIO_FUNC);
142: }
143: else {
144: audio_pt_unlock (&pa->pt, AUDIO_FUNC);
145: }
146: return decr;
147: }
148:
149: static int qpa_write (SWVoiceOut *sw, void *buf, int len)
150: {
151: return audio_pcm_sw_write (sw, buf, len);
152: }
153:
154: /* capture */
155: static void *qpa_thread_in (void *arg)
156: {
157: PAVoiceIn *pa = arg;
158: HWVoiceIn *hw = &pa->hw;
159: int threshold;
160:
161: threshold = conf.divisor ? hw->samples / conf.divisor : 0;
162:
163: if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {
164: return NULL;
165: }
166:
167: for (;;) {
168: int incr, to_grab, wpos;
169:
170: for (;;) {
171: if (pa->done) {
172: goto exit;
173: }
174:
175: if (pa->dead > threshold) {
176: break;
177: }
178:
179: if (audio_pt_wait (&pa->pt, AUDIO_FUNC)) {
180: goto exit;
181: }
182: }
183:
184: incr = to_grab = pa->dead;
185: wpos = hw->wpos;
186:
187: if (audio_pt_unlock (&pa->pt, AUDIO_FUNC)) {
188: return NULL;
189: }
190:
191: while (to_grab) {
192: int error;
193: int chunk = audio_MIN (to_grab, hw->samples - wpos);
194: void *buf = advance (pa->pcm_buf, wpos);
195:
196: if (pa_simple_read (pa->s, buf,
197: chunk << hw->info.shift, &error) < 0) {
198: qpa_logerr (error, "pa_simple_read failed\n");
199: return NULL;
200: }
201:
202: hw->conv (hw->conv_buf + wpos, buf, chunk, &nominal_volume);
203: wpos = (wpos + chunk) % hw->samples;
204: to_grab -= chunk;
205: }
206:
207: if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {
208: return NULL;
209: }
210:
211: pa->wpos = wpos;
212: pa->dead -= incr;
213: pa->incr += incr;
214: }
215:
216: exit:
217: audio_pt_unlock (&pa->pt, AUDIO_FUNC);
218: return NULL;
219: }
220:
221: static int qpa_run_in (HWVoiceIn *hw)
222: {
223: int live, incr, dead;
224: PAVoiceIn *pa = (PAVoiceIn *) hw;
225:
226: if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {
227: return 0;
228: }
229:
230: live = audio_pcm_hw_get_live_in (hw);
231: dead = hw->samples - live;
232: incr = audio_MIN (dead, pa->incr);
233: pa->incr -= incr;
234: pa->dead = dead - incr;
235: hw->wpos = pa->wpos;
236: if (pa->dead > 0) {
237: audio_pt_unlock_and_signal (&pa->pt, AUDIO_FUNC);
238: }
239: else {
240: audio_pt_unlock (&pa->pt, AUDIO_FUNC);
241: }
242: return incr;
243: }
244:
245: static int qpa_read (SWVoiceIn *sw, void *buf, int len)
246: {
247: return audio_pcm_sw_read (sw, buf, len);
248: }
249:
250: static pa_sample_format_t audfmt_to_pa (audfmt_e afmt, int endianness)
251: {
252: int format;
253:
254: switch (afmt) {
255: case AUD_FMT_S8:
256: case AUD_FMT_U8:
257: format = PA_SAMPLE_U8;
258: break;
259: case AUD_FMT_S16:
260: case AUD_FMT_U16:
261: format = endianness ? PA_SAMPLE_S16BE : PA_SAMPLE_S16LE;
262: break;
263: case AUD_FMT_S32:
264: case AUD_FMT_U32:
265: format = endianness ? PA_SAMPLE_S32BE : PA_SAMPLE_S32LE;
266: break;
267: default:
268: dolog ("Internal logic error: Bad audio format %d\n", afmt);
269: format = PA_SAMPLE_U8;
270: break;
271: }
272: return format;
273: }
274:
275: static audfmt_e pa_to_audfmt (pa_sample_format_t fmt, int *endianness)
276: {
277: switch (fmt) {
278: case PA_SAMPLE_U8:
279: return AUD_FMT_U8;
280: case PA_SAMPLE_S16BE:
281: *endianness = 1;
282: return AUD_FMT_S16;
283: case PA_SAMPLE_S16LE:
284: *endianness = 0;
285: return AUD_FMT_S16;
286: case PA_SAMPLE_S32BE:
287: *endianness = 1;
288: return AUD_FMT_S32;
289: case PA_SAMPLE_S32LE:
290: *endianness = 0;
291: return AUD_FMT_S32;
292: default:
293: dolog ("Internal logic error: Bad pa_sample_format %d\n", fmt);
294: return AUD_FMT_U8;
295: }
296: }
297:
298: static int qpa_init_out (HWVoiceOut *hw, struct audsettings *as)
299: {
300: int error;
301: static pa_sample_spec ss;
302: struct audsettings obt_as = *as;
303: PAVoiceOut *pa = (PAVoiceOut *) hw;
304:
305: ss.format = audfmt_to_pa (as->fmt, as->endianness);
306: ss.channels = as->nchannels;
307: ss.rate = as->freq;
308:
309: obt_as.fmt = pa_to_audfmt (ss.format, &obt_as.endianness);
310:
311: pa->s = pa_simple_new (
312: conf.server,
313: "qemu",
314: PA_STREAM_PLAYBACK,
315: conf.sink,
316: "pcm.playback",
317: &ss,
318: NULL, /* channel map */
319: NULL, /* buffering attributes */
320: &error
321: );
322: if (!pa->s) {
323: qpa_logerr (error, "pa_simple_new for playback failed\n");
324: goto fail1;
325: }
326:
327: audio_pcm_init_info (&hw->info, &obt_as);
328: hw->samples = conf.samples;
329: pa->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
330: if (!pa->pcm_buf) {
331: dolog ("Could not allocate buffer (%d bytes)\n",
332: hw->samples << hw->info.shift);
333: goto fail2;
334: }
335:
336: if (audio_pt_init (&pa->pt, qpa_thread_out, hw, AUDIO_CAP, AUDIO_FUNC)) {
337: goto fail3;
338: }
339:
340: return 0;
341:
342: fail3:
343: free (pa->pcm_buf);
344: pa->pcm_buf = NULL;
345: fail2:
346: pa_simple_free (pa->s);
347: pa->s = NULL;
348: fail1:
349: return -1;
350: }
351:
352: static int qpa_init_in (HWVoiceIn *hw, struct audsettings *as)
353: {
354: int error;
355: static pa_sample_spec ss;
356: struct audsettings obt_as = *as;
357: PAVoiceIn *pa = (PAVoiceIn *) hw;
358:
359: ss.format = audfmt_to_pa (as->fmt, as->endianness);
360: ss.channels = as->nchannels;
361: ss.rate = as->freq;
362:
363: obt_as.fmt = pa_to_audfmt (ss.format, &obt_as.endianness);
364:
365: pa->s = pa_simple_new (
366: conf.server,
367: "qemu",
368: PA_STREAM_RECORD,
369: conf.source,
370: "pcm.capture",
371: &ss,
372: NULL, /* channel map */
373: NULL, /* buffering attributes */
374: &error
375: );
376: if (!pa->s) {
377: qpa_logerr (error, "pa_simple_new for capture failed\n");
378: goto fail1;
379: }
380:
381: audio_pcm_init_info (&hw->info, &obt_as);
382: hw->samples = conf.samples;
383: pa->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
384: if (!pa->pcm_buf) {
385: dolog ("Could not allocate buffer (%d bytes)\n",
386: hw->samples << hw->info.shift);
387: goto fail2;
388: }
389:
390: if (audio_pt_init (&pa->pt, qpa_thread_in, hw, AUDIO_CAP, AUDIO_FUNC)) {
391: goto fail3;
392: }
393:
394: return 0;
395:
396: fail3:
397: free (pa->pcm_buf);
398: pa->pcm_buf = NULL;
399: fail2:
400: pa_simple_free (pa->s);
401: pa->s = NULL;
402: fail1:
403: return -1;
404: }
405:
406: static void qpa_fini_out (HWVoiceOut *hw)
407: {
408: void *ret;
409: PAVoiceOut *pa = (PAVoiceOut *) hw;
410:
411: audio_pt_lock (&pa->pt, AUDIO_FUNC);
412: pa->done = 1;
413: audio_pt_unlock_and_signal (&pa->pt, AUDIO_FUNC);
414: audio_pt_join (&pa->pt, &ret, AUDIO_FUNC);
415:
416: if (pa->s) {
417: pa_simple_free (pa->s);
418: pa->s = NULL;
419: }
420:
421: audio_pt_fini (&pa->pt, AUDIO_FUNC);
422: qemu_free (pa->pcm_buf);
423: pa->pcm_buf = NULL;
424: }
425:
426: static void qpa_fini_in (HWVoiceIn *hw)
427: {
428: void *ret;
429: PAVoiceIn *pa = (PAVoiceIn *) hw;
430:
431: audio_pt_lock (&pa->pt, AUDIO_FUNC);
432: pa->done = 1;
433: audio_pt_unlock_and_signal (&pa->pt, AUDIO_FUNC);
434: audio_pt_join (&pa->pt, &ret, AUDIO_FUNC);
435:
436: if (pa->s) {
437: pa_simple_free (pa->s);
438: pa->s = NULL;
439: }
440:
441: audio_pt_fini (&pa->pt, AUDIO_FUNC);
442: qemu_free (pa->pcm_buf);
443: pa->pcm_buf = NULL;
444: }
445:
446: static int qpa_ctl_out (HWVoiceOut *hw, int cmd, ...)
447: {
448: (void) hw;
449: (void) cmd;
450: return 0;
451: }
452:
453: static int qpa_ctl_in (HWVoiceIn *hw, int cmd, ...)
454: {
455: (void) hw;
456: (void) cmd;
457: return 0;
458: }
459:
460: /* common */
461: static void *qpa_audio_init (void)
462: {
463: return &conf;
464: }
465:
466: static void qpa_audio_fini (void *opaque)
467: {
468: (void) opaque;
469: }
470:
471: struct audio_option qpa_options[] = {
472: {"SAMPLES", AUD_OPT_INT, &conf.samples,
473: "buffer size in samples", NULL, 0},
474:
475: {"DIVISOR", AUD_OPT_INT, &conf.divisor,
476: "threshold divisor", NULL, 0},
477:
478: {"SERVER", AUD_OPT_STR, &conf.server,
479: "server address", NULL, 0},
480:
481: {"SINK", AUD_OPT_STR, &conf.sink,
482: "sink device name", NULL, 0},
483:
484: {"SOURCE", AUD_OPT_STR, &conf.source,
485: "source device name", NULL, 0},
486:
487: {NULL, 0, NULL, NULL, NULL, 0}
488: };
489:
490: static struct audio_pcm_ops qpa_pcm_ops = {
491: qpa_init_out,
492: qpa_fini_out,
493: qpa_run_out,
494: qpa_write,
495: qpa_ctl_out,
496: qpa_init_in,
497: qpa_fini_in,
498: qpa_run_in,
499: qpa_read,
500: qpa_ctl_in
501: };
502:
503: struct audio_driver pa_audio_driver = {
504: INIT_FIELD (name = ) "pa",
505: INIT_FIELD (descr = ) "http://www.pulseaudio.org/",
506: INIT_FIELD (options = ) qpa_options,
507: INIT_FIELD (init = ) qpa_audio_init,
508: INIT_FIELD (fini = ) qpa_audio_fini,
509: INIT_FIELD (pcm_ops = ) &qpa_pcm_ops,
510: INIT_FIELD (can_be_default = ) 0,
511: INIT_FIELD (max_voices_out = ) INT_MAX,
512: INIT_FIELD (max_voices_in = ) INT_MAX,
513: INIT_FIELD (voice_size_out = ) sizeof (PAVoiceOut),
514: INIT_FIELD (voice_size_in = ) sizeof (PAVoiceIn)
515: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.