]> code.delx.au - pulseaudio/blob - src/modules/alsa/alsa-source.c
alsa: when creating alsa sinks/sources include mapping name in device name to allow...
[pulseaudio] / src / modules / alsa / alsa-source.c
1 /***
2 This file is part of PulseAudio.
3
4 Copyright 2004-2008 Lennart Poettering
5 Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
6
7 PulseAudio is free software; you can redistribute it and/or modify
8 it under the terms of the GNU Lesser General Public License as published
9 by the Free Software Foundation; either version 2.1 of the License,
10 or (at your option) any later version.
11
12 PulseAudio is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
16
17 You should have received a copy of the GNU Lesser General Public License
18 along with PulseAudio; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
20 USA.
21 ***/
22
23 #ifdef HAVE_CONFIG_H
24 #include <config.h>
25 #endif
26
27 #include <stdio.h>
28
29 #include <asoundlib.h>
30
31 #include <pulse/xmalloc.h>
32 #include <pulse/util.h>
33 #include <pulse/timeval.h>
34 #include <pulse/i18n.h>
35
36 #include <pulsecore/core-error.h>
37 #include <pulsecore/core.h>
38 #include <pulsecore/module.h>
39 #include <pulsecore/memchunk.h>
40 #include <pulsecore/sink.h>
41 #include <pulsecore/modargs.h>
42 #include <pulsecore/core-util.h>
43 #include <pulsecore/sample-util.h>
44 #include <pulsecore/log.h>
45 #include <pulsecore/macro.h>
46 #include <pulsecore/thread.h>
47 #include <pulsecore/core-error.h>
48 #include <pulsecore/thread-mq.h>
49 #include <pulsecore/rtpoll.h>
50 #include <pulsecore/time-smoother.h>
51 #include <pulsecore/rtclock.h>
52
53 #include <modules/reserve-wrap.h>
54
55 #include "alsa-util.h"
56 #include "alsa-source.h"
57
58 /* #define DEBUG_TIMING */
59
60 #define DEFAULT_DEVICE "default"
61 #define DEFAULT_TSCHED_BUFFER_USEC (2*PA_USEC_PER_SEC) /* 2s */
62 #define DEFAULT_TSCHED_WATERMARK_USEC (20*PA_USEC_PER_MSEC) /* 20ms */
63 #define TSCHED_WATERMARK_STEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms */
64 #define TSCHED_MIN_SLEEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms */
65 #define TSCHED_MIN_WAKEUP_USEC (4*PA_USEC_PER_MSEC) /* 4ms */
66
67 struct userdata {
68 pa_core *core;
69 pa_module *module;
70 pa_source *source;
71
72 pa_thread *thread;
73 pa_thread_mq thread_mq;
74 pa_rtpoll *rtpoll;
75
76 snd_pcm_t *pcm_handle;
77
78 pa_alsa_fdlist *mixer_fdl;
79 snd_mixer_t *mixer_handle;
80 pa_alsa_path_set *mixer_path_set;
81 pa_alsa_path *mixer_path;
82
83 pa_cvolume hardware_volume;
84
85 size_t
86 frame_size,
87 fragment_size,
88 hwbuf_size,
89 tsched_watermark,
90 hwbuf_unused,
91 min_sleep,
92 min_wakeup,
93 watermark_step;
94
95 unsigned nfragments;
96
97 char *device_name;
98 char *control_device;
99
100 pa_bool_t use_mmap:1, use_tsched:1;
101
102 pa_rtpoll_item *alsa_rtpoll_item;
103
104 snd_mixer_selem_channel_id_t mixer_map[SND_MIXER_SCHN_LAST];
105
106 pa_smoother *smoother;
107 uint64_t read_count;
108
109 pa_reserve_wrapper *reserve;
110 pa_hook_slot *reserve_slot;
111 pa_reserve_monitor_wrapper *monitor;
112 pa_hook_slot *monitor_slot;
113 };
114
115 static void userdata_free(struct userdata *u);
116
117 static pa_hook_result_t reserve_cb(pa_reserve_wrapper *r, void *forced, struct userdata *u) {
118 pa_assert(r);
119 pa_assert(u);
120
121 if (pa_source_suspend(u->source, TRUE, PA_SUSPEND_APPLICATION) < 0)
122 return PA_HOOK_CANCEL;
123
124 return PA_HOOK_OK;
125 }
126
127 static void reserve_done(struct userdata *u) {
128 pa_assert(u);
129
130 if (u->reserve_slot) {
131 pa_hook_slot_free(u->reserve_slot);
132 u->reserve_slot = NULL;
133 }
134
135 if (u->reserve) {
136 pa_reserve_wrapper_unref(u->reserve);
137 u->reserve = NULL;
138 }
139 }
140
141 static void reserve_update(struct userdata *u) {
142 const char *description;
143 pa_assert(u);
144
145 if (!u->source || !u->reserve)
146 return;
147
148 if ((description = pa_proplist_gets(u->source->proplist, PA_PROP_DEVICE_DESCRIPTION)))
149 pa_reserve_wrapper_set_application_device_name(u->reserve, description);
150 }
151
152 static int reserve_init(struct userdata *u, const char *dname) {
153 char *rname;
154
155 pa_assert(u);
156 pa_assert(dname);
157
158 if (u->reserve)
159 return 0;
160
161 if (pa_in_system_mode())
162 return 0;
163
164 /* We are resuming, try to lock the device */
165 if (!(rname = pa_alsa_get_reserve_name(dname)))
166 return 0;
167
168 u->reserve = pa_reserve_wrapper_get(u->core, rname);
169 pa_xfree(rname);
170
171 if (!(u->reserve))
172 return -1;
173
174 reserve_update(u);
175
176 pa_assert(!u->reserve_slot);
177 u->reserve_slot = pa_hook_connect(pa_reserve_wrapper_hook(u->reserve), PA_HOOK_NORMAL, (pa_hook_cb_t) reserve_cb, u);
178
179 return 0;
180 }
181
182 static pa_hook_result_t monitor_cb(pa_reserve_monitor_wrapper *w, void* busy, struct userdata *u) {
183 pa_bool_t b;
184
185 pa_assert(w);
186 pa_assert(u);
187
188 b = PA_PTR_TO_UINT(busy) && !u->reserve;
189
190 pa_source_suspend(u->source, b, PA_SUSPEND_APPLICATION);
191 return PA_HOOK_OK;
192 }
193
194 static void monitor_done(struct userdata *u) {
195 pa_assert(u);
196
197 if (u->monitor_slot) {
198 pa_hook_slot_free(u->monitor_slot);
199 u->monitor_slot = NULL;
200 }
201
202 if (u->monitor) {
203 pa_reserve_monitor_wrapper_unref(u->monitor);
204 u->monitor = NULL;
205 }
206 }
207
208 static int reserve_monitor_init(struct userdata *u, const char *dname) {
209 char *rname;
210
211 pa_assert(u);
212 pa_assert(dname);
213
214 if (pa_in_system_mode())
215 return 0;
216
217 /* We are resuming, try to lock the device */
218 if (!(rname = pa_alsa_get_reserve_name(dname)))
219 return 0;
220
221 u->monitor = pa_reserve_monitor_wrapper_get(u->core, rname);
222 pa_xfree(rname);
223
224 if (!(u->monitor))
225 return -1;
226
227 pa_assert(!u->monitor_slot);
228 u->monitor_slot = pa_hook_connect(pa_reserve_monitor_wrapper_hook(u->monitor), PA_HOOK_NORMAL, (pa_hook_cb_t) monitor_cb, u);
229
230 return 0;
231 }
232
233 static void fix_min_sleep_wakeup(struct userdata *u) {
234 size_t max_use, max_use_2;
235 pa_assert(u);
236
237 max_use = u->hwbuf_size - u->hwbuf_unused;
238 max_use_2 = pa_frame_align(max_use/2, &u->source->sample_spec);
239
240 u->min_sleep = pa_usec_to_bytes(TSCHED_MIN_SLEEP_USEC, &u->source->sample_spec);
241 u->min_sleep = PA_CLAMP(u->min_sleep, u->frame_size, max_use_2);
242
243 u->min_wakeup = pa_usec_to_bytes(TSCHED_MIN_WAKEUP_USEC, &u->source->sample_spec);
244 u->min_wakeup = PA_CLAMP(u->min_wakeup, u->frame_size, max_use_2);
245 }
246
247 static void fix_tsched_watermark(struct userdata *u) {
248 size_t max_use;
249 pa_assert(u);
250
251 max_use = u->hwbuf_size - u->hwbuf_unused;
252
253 if (u->tsched_watermark > max_use - u->min_sleep)
254 u->tsched_watermark = max_use - u->min_sleep;
255
256 if (u->tsched_watermark < u->min_wakeup)
257 u->tsched_watermark = u->min_wakeup;
258 }
259
260 static void adjust_after_overrun(struct userdata *u) {
261 size_t old_watermark;
262 pa_usec_t old_min_latency, new_min_latency;
263
264 pa_assert(u);
265 pa_assert(u->use_tsched);
266
267 /* First, just try to increase the watermark */
268 old_watermark = u->tsched_watermark;
269 u->tsched_watermark = PA_MIN(u->tsched_watermark * 2, u->tsched_watermark + u->watermark_step);
270
271 fix_tsched_watermark(u);
272
273 if (old_watermark != u->tsched_watermark) {
274 pa_log_notice("Increasing wakeup watermark to %0.2f ms",
275 (double) pa_bytes_to_usec(u->tsched_watermark, &u->source->sample_spec) / PA_USEC_PER_MSEC);
276 return;
277 }
278
279 /* Hmm, we cannot increase the watermark any further, hence let's raise the latency */
280 old_min_latency = u->source->thread_info.min_latency;
281 new_min_latency = PA_MIN(old_min_latency * 2, old_min_latency + TSCHED_WATERMARK_STEP_USEC);
282 new_min_latency = PA_MIN(new_min_latency, u->source->thread_info.max_latency);
283
284 if (old_min_latency != new_min_latency) {
285 pa_log_notice("Increasing minimal latency to %0.2f ms",
286 (double) new_min_latency / PA_USEC_PER_MSEC);
287
288 pa_source_set_latency_range_within_thread(u->source, new_min_latency, u->source->thread_info.max_latency);
289 return;
290 }
291
292 /* When we reach this we're officialy fucked! */
293 }
294
295 static pa_usec_t hw_sleep_time(struct userdata *u, pa_usec_t *sleep_usec, pa_usec_t*process_usec) {
296 pa_usec_t wm, usec;
297
298 pa_assert(u);
299
300 usec = pa_source_get_requested_latency_within_thread(u->source);
301
302 if (usec == (pa_usec_t) -1)
303 usec = pa_bytes_to_usec(u->hwbuf_size, &u->source->sample_spec);
304
305 wm = pa_bytes_to_usec(u->tsched_watermark, &u->source->sample_spec);
306
307 if (wm > usec)
308 wm = usec/2;
309
310 *sleep_usec = usec - wm;
311 *process_usec = wm;
312
313 #ifdef DEBUG_TIMING
314 pa_log_debug("Buffer time: %lu ms; Sleep time: %lu ms; Process time: %lu ms",
315 (unsigned long) (usec / PA_USEC_PER_MSEC),
316 (unsigned long) (*sleep_usec / PA_USEC_PER_MSEC),
317 (unsigned long) (*process_usec / PA_USEC_PER_MSEC));
318 #endif
319
320 return usec;
321 }
322
323 static int try_recover(struct userdata *u, const char *call, int err) {
324 pa_assert(u);
325 pa_assert(call);
326 pa_assert(err < 0);
327
328 pa_log_debug("%s: %s", call, pa_alsa_strerror(err));
329
330 pa_assert(err != -EAGAIN);
331
332 if (err == -EPIPE)
333 pa_log_debug("%s: Buffer overrun!", call);
334
335 if ((err = snd_pcm_recover(u->pcm_handle, err, 1)) < 0) {
336 pa_log("%s: %s", call, pa_alsa_strerror(err));
337 return -1;
338 }
339
340 snd_pcm_start(u->pcm_handle);
341 return 0;
342 }
343
344 static size_t check_left_to_record(struct userdata *u, size_t n_bytes) {
345 size_t left_to_record;
346 size_t rec_space = u->hwbuf_size - u->hwbuf_unused;
347
348 /* We use <= instead of < for this check here because an overrun
349 * only happens after the last sample was processed, not already when
350 * it is removed from the buffer. This is particularly important
351 * when block transfer is used. */
352
353 if (n_bytes <= rec_space) {
354 left_to_record = rec_space - n_bytes;
355
356 #ifdef DEBUG_TIMING
357 pa_log_debug("%0.2f ms left to record", (double) pa_bytes_to_usec(left_to_record, &u->source->sample_spec) / PA_USEC_PER_MSEC);
358 #endif
359
360 } else {
361 left_to_record = 0;
362
363 #ifdef DEBUG_TIMING
364 PA_DEBUG_TRAP;
365 #endif
366
367 if (pa_log_ratelimit())
368 pa_log_info("Overrun!");
369
370 if (u->use_tsched)
371 adjust_after_overrun(u);
372 }
373
374 return left_to_record;
375 }
376
377 static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled) {
378 pa_bool_t work_done = FALSE;
379 pa_usec_t max_sleep_usec = 0, process_usec = 0;
380 size_t left_to_record;
381 unsigned j = 0;
382
383 pa_assert(u);
384 pa_source_assert_ref(u->source);
385
386 if (u->use_tsched)
387 hw_sleep_time(u, &max_sleep_usec, &process_usec);
388
389 for (;;) {
390 snd_pcm_sframes_t n;
391 size_t n_bytes;
392 int r;
393
394 if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
395
396 if ((r = try_recover(u, "snd_pcm_avail", (int) n)) == 0)
397 continue;
398
399 return r;
400 }
401
402 n_bytes = (size_t) n * u->frame_size;
403
404 #ifdef DEBUG_TIMING
405 pa_log_debug("avail: %lu", (unsigned long) n_bytes);
406 #endif
407
408 left_to_record = check_left_to_record(u, n_bytes);
409
410 if (u->use_tsched)
411 if (!polled &&
412 pa_bytes_to_usec(left_to_record, &u->source->sample_spec) > process_usec+max_sleep_usec/2) {
413 #ifdef DEBUG_TIMING
414 pa_log_debug("Not reading, because too early.");
415 #endif
416 break;
417 }
418
419 if (PA_UNLIKELY(n_bytes <= 0)) {
420
421 if (polled)
422 PA_ONCE_BEGIN {
423 char *dn = pa_alsa_get_driver_name_by_pcm(u->pcm_handle);
424 pa_log(_("ALSA woke us up to read new data from the device, but there was actually nothing to read!\n"
425 "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
426 "We were woken up with POLLIN set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
427 pa_strnull(dn));
428 pa_xfree(dn);
429 } PA_ONCE_END;
430
431 #ifdef DEBUG_TIMING
432 pa_log_debug("Not reading, because not necessary.");
433 #endif
434 break;
435 }
436
437 if (++j > 10) {
438 #ifdef DEBUG_TIMING
439 pa_log_debug("Not filling up, because already too many iterations.");
440 #endif
441
442 break;
443 }
444
445 polled = FALSE;
446
447 #ifdef DEBUG_TIMING
448 pa_log_debug("Reading");
449 #endif
450
451 for (;;) {
452 int err;
453 const snd_pcm_channel_area_t *areas;
454 snd_pcm_uframes_t offset, frames;
455 pa_memchunk chunk;
456 void *p;
457 snd_pcm_sframes_t sframes;
458
459 frames = (snd_pcm_uframes_t) (n_bytes / u->frame_size);
460
461 /* pa_log_debug("%lu frames to read", (unsigned long) frames); */
462
463 if (PA_UNLIKELY((err = pa_alsa_safe_mmap_begin(u->pcm_handle, &areas, &offset, &frames, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
464
465 if ((r = try_recover(u, "snd_pcm_mmap_begin", err)) == 0)
466 continue;
467
468 return r;
469 }
470
471 /* Make sure that if these memblocks need to be copied they will fit into one slot */
472 if (frames > pa_mempool_block_size_max(u->source->core->mempool)/u->frame_size)
473 frames = pa_mempool_block_size_max(u->source->core->mempool)/u->frame_size;
474
475 /* Check these are multiples of 8 bit */
476 pa_assert((areas[0].first & 7) == 0);
477 pa_assert((areas[0].step & 7)== 0);
478
479 /* We assume a single interleaved memory buffer */
480 pa_assert((areas[0].first >> 3) == 0);
481 pa_assert((areas[0].step >> 3) == u->frame_size);
482
483 p = (uint8_t*) areas[0].addr + (offset * u->frame_size);
484
485 chunk.memblock = pa_memblock_new_fixed(u->core->mempool, p, frames * u->frame_size, TRUE);
486 chunk.length = pa_memblock_get_length(chunk.memblock);
487 chunk.index = 0;
488
489 pa_source_post(u->source, &chunk);
490 pa_memblock_unref_fixed(chunk.memblock);
491
492 if (PA_UNLIKELY((sframes = snd_pcm_mmap_commit(u->pcm_handle, offset, frames)) < 0)) {
493
494 if ((r = try_recover(u, "snd_pcm_mmap_commit", (int) sframes)) == 0)
495 continue;
496
497 return r;
498 }
499
500 work_done = TRUE;
501
502 u->read_count += frames * u->frame_size;
503
504 #ifdef DEBUG_TIMING
505 pa_log_debug("Read %lu bytes (of possible %lu bytes)", (unsigned long) (frames * u->frame_size), (unsigned long) n_bytes);
506 #endif
507
508 if ((size_t) frames * u->frame_size >= n_bytes)
509 break;
510
511 n_bytes -= (size_t) frames * u->frame_size;
512 }
513 }
514
515 *sleep_usec = pa_bytes_to_usec(left_to_record, &u->source->sample_spec);
516
517 if (*sleep_usec > process_usec)
518 *sleep_usec -= process_usec;
519 else
520 *sleep_usec = 0;
521
522 return work_done ? 1 : 0;
523 }
524
525 static int unix_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled) {
526 int work_done = FALSE;
527 pa_usec_t max_sleep_usec = 0, process_usec = 0;
528 size_t left_to_record;
529 unsigned j = 0;
530
531 pa_assert(u);
532 pa_source_assert_ref(u->source);
533
534 if (u->use_tsched)
535 hw_sleep_time(u, &max_sleep_usec, &process_usec);
536
537 for (;;) {
538 snd_pcm_sframes_t n;
539 size_t n_bytes;
540 int r;
541
542 if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
543
544 if ((r = try_recover(u, "snd_pcm_avail", (int) n)) == 0)
545 continue;
546
547 return r;
548 }
549
550 n_bytes = (size_t) n * u->frame_size;
551 left_to_record = check_left_to_record(u, n_bytes);
552
553 if (u->use_tsched)
554 if (!polled &&
555 pa_bytes_to_usec(left_to_record, &u->source->sample_spec) > process_usec+max_sleep_usec/2)
556 break;
557
558 if (PA_UNLIKELY(n_bytes <= 0)) {
559
560 if (polled)
561 PA_ONCE_BEGIN {
562 char *dn = pa_alsa_get_driver_name_by_pcm(u->pcm_handle);
563 pa_log(_("ALSA woke us up to read new data from the device, but there was actually nothing to read!\n"
564 "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
565 "We were woken up with POLLIN set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
566 pa_strnull(dn));
567 pa_xfree(dn);
568 } PA_ONCE_END;
569
570 break;
571 }
572
573 if (++j > 10) {
574 #ifdef DEBUG_TIMING
575 pa_log_debug("Not filling up, because already too many iterations.");
576 #endif
577
578 break;
579 }
580
581 polled = FALSE;
582
583 for (;;) {
584 void *p;
585 snd_pcm_sframes_t frames;
586 pa_memchunk chunk;
587
588 chunk.memblock = pa_memblock_new(u->core->mempool, (size_t) -1);
589
590 frames = (snd_pcm_sframes_t) (pa_memblock_get_length(chunk.memblock) / u->frame_size);
591
592 if (frames > (snd_pcm_sframes_t) (n_bytes/u->frame_size))
593 frames = (snd_pcm_sframes_t) (n_bytes/u->frame_size);
594
595 /* pa_log_debug("%lu frames to read", (unsigned long) n); */
596
597 p = pa_memblock_acquire(chunk.memblock);
598 frames = snd_pcm_readi(u->pcm_handle, (uint8_t*) p, (snd_pcm_uframes_t) frames);
599 pa_memblock_release(chunk.memblock);
600
601 pa_assert(frames != 0);
602
603 if (PA_UNLIKELY(frames < 0)) {
604 pa_memblock_unref(chunk.memblock);
605
606 if ((r = try_recover(u, "snd_pcm_readi", (int) (frames))) == 0)
607 continue;
608
609 return r;
610 }
611
612 chunk.index = 0;
613 chunk.length = (size_t) frames * u->frame_size;
614
615 pa_source_post(u->source, &chunk);
616 pa_memblock_unref(chunk.memblock);
617
618 work_done = TRUE;
619
620 u->read_count += frames * u->frame_size;
621
622 /* pa_log_debug("read %lu frames", (unsigned long) frames); */
623
624 if ((size_t) frames * u->frame_size >= n_bytes)
625 break;
626
627 n_bytes -= (size_t) frames * u->frame_size;
628 }
629 }
630
631 *sleep_usec = pa_bytes_to_usec(left_to_record, &u->source->sample_spec);
632
633 if (*sleep_usec > process_usec)
634 *sleep_usec -= process_usec;
635 else
636 *sleep_usec = 0;
637
638 return work_done ? 1 : 0;
639 }
640
641 static void update_smoother(struct userdata *u) {
642 snd_pcm_sframes_t delay = 0;
643 uint64_t position;
644 int err;
645 pa_usec_t now1 = 0, now2;
646 snd_pcm_status_t *status;
647
648 snd_pcm_status_alloca(&status);
649
650 pa_assert(u);
651 pa_assert(u->pcm_handle);
652
653 /* Let's update the time smoother */
654
655 if (PA_UNLIKELY((err = pa_alsa_safe_delay(u->pcm_handle, &delay, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
656 pa_log_warn("Failed to get delay: %s", pa_alsa_strerror(err));
657 return;
658 }
659
660 if (PA_UNLIKELY((err = snd_pcm_status(u->pcm_handle, status)) < 0))
661 pa_log_warn("Failed to get timestamp: %s", pa_alsa_strerror(err));
662 else {
663 snd_htimestamp_t htstamp = { 0, 0 };
664 snd_pcm_status_get_htstamp(status, &htstamp);
665 now1 = pa_timespec_load(&htstamp);
666 }
667
668 position = u->read_count + ((uint64_t) delay * (uint64_t) u->frame_size);
669
670 /* Hmm, if the timestamp is 0, then it wasn't set and we take the current time */
671 if (now1 <= 0)
672 now1 = pa_rtclock_usec();
673
674 now2 = pa_bytes_to_usec(position, &u->source->sample_spec);
675
676 pa_smoother_put(u->smoother, now1, now2);
677 }
678
679 static pa_usec_t source_get_latency(struct userdata *u) {
680 int64_t delay;
681 pa_usec_t now1, now2;
682
683 pa_assert(u);
684
685 now1 = pa_rtclock_usec();
686 now2 = pa_smoother_get(u->smoother, now1);
687
688 delay = (int64_t) now2 - (int64_t) pa_bytes_to_usec(u->read_count, &u->source->sample_spec);
689
690 return delay >= 0 ? (pa_usec_t) delay : 0;
691 }
692
693 static int build_pollfd(struct userdata *u) {
694 pa_assert(u);
695 pa_assert(u->pcm_handle);
696
697 if (u->alsa_rtpoll_item)
698 pa_rtpoll_item_free(u->alsa_rtpoll_item);
699
700 if (!(u->alsa_rtpoll_item = pa_alsa_build_pollfd(u->pcm_handle, u->rtpoll)))
701 return -1;
702
703 return 0;
704 }
705
706 static int suspend(struct userdata *u) {
707 pa_assert(u);
708 pa_assert(u->pcm_handle);
709
710 pa_smoother_pause(u->smoother, pa_rtclock_usec());
711
712 /* Let's suspend */
713 snd_pcm_close(u->pcm_handle);
714 u->pcm_handle = NULL;
715
716 if (u->alsa_rtpoll_item) {
717 pa_rtpoll_item_free(u->alsa_rtpoll_item);
718 u->alsa_rtpoll_item = NULL;
719 }
720
721 pa_log_info("Device suspended...");
722
723 return 0;
724 }
725
726 static int update_sw_params(struct userdata *u) {
727 snd_pcm_uframes_t avail_min;
728 int err;
729
730 pa_assert(u);
731
732 /* Use the full buffer if noone asked us for anything specific */
733 u->hwbuf_unused = 0;
734
735 if (u->use_tsched) {
736 pa_usec_t latency;
737
738 if ((latency = pa_source_get_requested_latency_within_thread(u->source)) != (pa_usec_t) -1) {
739 size_t b;
740
741 pa_log_debug("latency set to %0.2fms", (double) latency / PA_USEC_PER_MSEC);
742
743 b = pa_usec_to_bytes(latency, &u->source->sample_spec);
744
745 /* We need at least one sample in our buffer */
746
747 if (PA_UNLIKELY(b < u->frame_size))
748 b = u->frame_size;
749
750 u->hwbuf_unused = PA_LIKELY(b < u->hwbuf_size) ? (u->hwbuf_size - b) : 0;
751 }
752
753 fix_min_sleep_wakeup(u);
754 fix_tsched_watermark(u);
755 }
756
757 pa_log_debug("hwbuf_unused=%lu", (unsigned long) u->hwbuf_unused);
758
759 avail_min = 1;
760
761 if (u->use_tsched) {
762 pa_usec_t sleep_usec, process_usec;
763
764 hw_sleep_time(u, &sleep_usec, &process_usec);
765 avail_min += pa_usec_to_bytes(sleep_usec, &u->source->sample_spec) / u->frame_size;
766 }
767
768 pa_log_debug("setting avail_min=%lu", (unsigned long) avail_min);
769
770 if ((err = pa_alsa_set_sw_params(u->pcm_handle, avail_min)) < 0) {
771 pa_log("Failed to set software parameters: %s", pa_alsa_strerror(err));
772 return err;
773 }
774
775 return 0;
776 }
777
778 static int unsuspend(struct userdata *u) {
779 pa_sample_spec ss;
780 int err;
781 pa_bool_t b, d;
782 unsigned nfrags;
783 snd_pcm_uframes_t period_size;
784
785 pa_assert(u);
786 pa_assert(!u->pcm_handle);
787
788 pa_log_info("Trying resume...");
789
790 snd_config_update_free_global();
791
792 if ((err = snd_pcm_open(&u->pcm_handle, u->device_name, SND_PCM_STREAM_CAPTURE,
793 /*SND_PCM_NONBLOCK|*/
794 SND_PCM_NO_AUTO_RESAMPLE|
795 SND_PCM_NO_AUTO_CHANNELS|
796 SND_PCM_NO_AUTO_FORMAT)) < 0) {
797 pa_log("Error opening PCM device %s: %s", u->device_name, pa_alsa_strerror(err));
798 goto fail;
799 }
800
801 ss = u->source->sample_spec;
802 nfrags = u->nfragments;
803 period_size = u->fragment_size / u->frame_size;
804 b = u->use_mmap;
805 d = u->use_tsched;
806
807 if ((err = pa_alsa_set_hw_params(u->pcm_handle, &ss, &nfrags, &period_size, u->hwbuf_size / u->frame_size, &b, &d, TRUE)) < 0) {
808 pa_log("Failed to set hardware parameters: %s", pa_alsa_strerror(err));
809 goto fail;
810 }
811
812 if (b != u->use_mmap || d != u->use_tsched) {
813 pa_log_warn("Resume failed, couldn't get original access mode.");
814 goto fail;
815 }
816
817 if (!pa_sample_spec_equal(&ss, &u->source->sample_spec)) {
818 pa_log_warn("Resume failed, couldn't restore original sample settings.");
819 goto fail;
820 }
821
822 if (nfrags != u->nfragments || period_size*u->frame_size != u->fragment_size) {
823 pa_log_warn("Resume failed, couldn't restore original fragment settings. (Old: %lu*%lu, New %lu*%lu)",
824 (unsigned long) u->nfragments, (unsigned long) u->fragment_size,
825 (unsigned long) nfrags, period_size * u->frame_size);
826 goto fail;
827 }
828
829 if (update_sw_params(u) < 0)
830 goto fail;
831
832 if (build_pollfd(u) < 0)
833 goto fail;
834
835 /* FIXME: We need to reload the volume somehow */
836
837 snd_pcm_start(u->pcm_handle);
838 pa_smoother_resume(u->smoother, pa_rtclock_usec(), TRUE);
839
840 pa_log_info("Resumed successfully...");
841
842 return 0;
843
844 fail:
845 if (u->pcm_handle) {
846 snd_pcm_close(u->pcm_handle);
847 u->pcm_handle = NULL;
848 }
849
850 return -1;
851 }
852
853 static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
854 struct userdata *u = PA_SOURCE(o)->userdata;
855
856 switch (code) {
857
858 case PA_SOURCE_MESSAGE_GET_LATENCY: {
859 pa_usec_t r = 0;
860
861 if (u->pcm_handle)
862 r = source_get_latency(u);
863
864 *((pa_usec_t*) data) = r;
865
866 return 0;
867 }
868
869 case PA_SOURCE_MESSAGE_SET_STATE:
870
871 switch ((pa_source_state_t) PA_PTR_TO_UINT(data)) {
872
873 case PA_SOURCE_SUSPENDED:
874 pa_assert(PA_SOURCE_IS_OPENED(u->source->thread_info.state));
875
876 if (suspend(u) < 0)
877 return -1;
878
879 break;
880
881 case PA_SOURCE_IDLE:
882 case PA_SOURCE_RUNNING:
883
884 if (u->source->thread_info.state == PA_SOURCE_INIT) {
885 if (build_pollfd(u) < 0)
886 return -1;
887
888 snd_pcm_start(u->pcm_handle);
889 }
890
891 if (u->source->thread_info.state == PA_SOURCE_SUSPENDED) {
892 if (unsuspend(u) < 0)
893 return -1;
894 }
895
896 break;
897
898 case PA_SOURCE_UNLINKED:
899 case PA_SOURCE_INIT:
900 case PA_SOURCE_INVALID_STATE:
901 ;
902 }
903
904 break;
905 }
906
907 return pa_source_process_msg(o, code, data, offset, chunk);
908 }
909
910 /* Called from main context */
911 static int source_set_state_cb(pa_source *s, pa_source_state_t new_state) {
912 pa_source_state_t old_state;
913 struct userdata *u;
914
915 pa_source_assert_ref(s);
916 pa_assert_se(u = s->userdata);
917
918 old_state = pa_source_get_state(u->source);
919
920 if (PA_SINK_IS_OPENED(old_state) && new_state == PA_SINK_SUSPENDED)
921 reserve_done(u);
922 else if (old_state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(new_state))
923 if (reserve_init(u, u->device_name) < 0)
924 return -1;
925
926 return 0;
927 }
928
929 static int mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) {
930 struct userdata *u = snd_mixer_elem_get_callback_private(elem);
931
932 pa_assert(u);
933 pa_assert(u->mixer_handle);
934
935 if (mask == SND_CTL_EVENT_MASK_REMOVE)
936 return 0;
937
938 if (mask & SND_CTL_EVENT_MASK_VALUE) {
939 pa_source_get_volume(u->source, TRUE);
940 pa_source_get_mute(u->source, TRUE);
941 }
942
943 return 0;
944 }
945
946 static void source_get_volume_cb(pa_source *s) {
947 struct userdata *u = s->userdata;
948 pa_cvolume r;
949 char t[PA_CVOLUME_SNPRINT_MAX];
950
951 pa_assert(u);
952 pa_assert(u->mixer_path);
953 pa_assert(u->mixer_handle);
954
955 if (pa_alsa_path_get_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r) < 0)
956 return;
957
958 /* Shift down by the base volume, so that 0dB becomes maximum volume */
959 pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
960
961 pa_log_debug("Read hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &r));
962
963 if (pa_cvolume_equal(&u->hardware_volume, &r))
964 return;
965
966 s->virtual_volume = u->hardware_volume = r;
967
968 if (u->mixer_path->has_dB) {
969 pa_cvolume reset;
970
971 /* Hmm, so the hardware volume changed, let's reset our software volume */
972 pa_cvolume_reset(&reset, s->sample_spec.channels);
973 pa_source_set_soft_volume(s, &reset);
974 }
975 }
976
977 static void source_set_volume_cb(pa_source *s) {
978 struct userdata *u = s->userdata;
979 pa_cvolume r;
980 char t[PA_CVOLUME_SNPRINT_MAX];
981
982 pa_assert(u);
983 pa_assert(u->mixer_path);
984 pa_assert(u->mixer_handle);
985
986 /* Shift up by the base volume */
987 pa_sw_cvolume_divide_scalar(&r, &s->virtual_volume, s->base_volume);
988
989 if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r) < 0)
990 return;
991
992 /* Shift down by the base volume, so that 0dB becomes maximum volume */
993 pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
994
995 u->hardware_volume = r;
996
997 if (u->mixer_path->has_dB) {
998
999 /* Match exactly what the user requested by software */
1000 pa_sw_cvolume_divide(&s->soft_volume, &s->virtual_volume, &u->hardware_volume);
1001
1002 pa_log_debug("Requested volume: %s", pa_cvolume_snprint(t, sizeof(t), &s->virtual_volume));
1003 pa_log_debug("Got hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &u->hardware_volume));
1004 pa_log_debug("Calculated software volume: %s", pa_cvolume_snprint(t, sizeof(t), &s->soft_volume));
1005
1006 } else {
1007 pa_log_debug("Wrote hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &r));
1008
1009 /* We can't match exactly what the user requested, hence let's
1010 * at least tell the user about it */
1011
1012 s->virtual_volume = r;
1013 }
1014 }
1015
1016 static void source_get_mute_cb(pa_source *s) {
1017 struct userdata *u = s->userdata;
1018 pa_bool_t b;
1019
1020 pa_assert(u);
1021 pa_assert(u->mixer_path);
1022 pa_assert(u->mixer_handle);
1023
1024 if (pa_alsa_path_get_mute(u->mixer_path, u->mixer_handle, &b) < 0)
1025 return;
1026
1027 s->muted = b;
1028 }
1029
1030 static void source_set_mute_cb(pa_source *s) {
1031 struct userdata *u = s->userdata;
1032
1033 pa_assert(u);
1034 pa_assert(u->mixer_path);
1035 pa_assert(u->mixer_handle);
1036
1037 pa_alsa_path_set_mute(u->mixer_path, u->mixer_handle, s->muted);
1038 }
1039
1040 static int source_set_port_cb(pa_source *s, pa_device_port *p) {
1041 struct userdata *u = s->userdata;
1042 pa_alsa_port_data *data;
1043
1044 pa_assert(u);
1045 pa_assert(p);
1046 pa_assert(u->mixer_handle);
1047
1048 data = PA_DEVICE_PORT_DATA(p);
1049
1050 pa_assert_se(u->mixer_path = data->path);
1051 pa_alsa_path_select(u->mixer_path, u->mixer_handle);
1052
1053 if (u->mixer_path->has_volume && u->mixer_path->has_dB) {
1054 s->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
1055 s->n_volume_steps = PA_VOLUME_NORM+1;
1056
1057 if (u->mixer_path->max_dB > 0.0)
1058 pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(s->base_volume));
1059 else
1060 pa_log_info("No particular base volume set, fixing to 0 dB");
1061 } else {
1062 s->base_volume = PA_VOLUME_NORM;
1063 s->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1;
1064 }
1065
1066 if (data->setting)
1067 pa_alsa_setting_select(data->setting, u->mixer_handle);
1068
1069 if (s->set_mute)
1070 s->set_mute(s);
1071 if (s->set_volume)
1072 s->set_volume(s);
1073
1074 return 0;
1075 }
1076
1077 static void source_update_requested_latency_cb(pa_source *s) {
1078 struct userdata *u = s->userdata;
1079 pa_assert(u);
1080
1081 if (!u->pcm_handle)
1082 return;
1083
1084 update_sw_params(u);
1085 }
1086
1087 static void thread_func(void *userdata) {
1088 struct userdata *u = userdata;
1089 unsigned short revents = 0;
1090
1091 pa_assert(u);
1092
1093 pa_log_debug("Thread starting up");
1094
1095 if (u->core->realtime_scheduling)
1096 pa_make_realtime(u->core->realtime_priority);
1097
1098 pa_thread_mq_install(&u->thread_mq);
1099 pa_rtpoll_install(u->rtpoll);
1100
1101 for (;;) {
1102 int ret;
1103
1104 #ifdef DEBUG_TIMING
1105 pa_log_debug("Loop");
1106 #endif
1107
1108 /* Read some data and pass it to the sources */
1109 if (PA_SOURCE_IS_OPENED(u->source->thread_info.state)) {
1110 int work_done;
1111 pa_usec_t sleep_usec = 0;
1112
1113 if (u->use_mmap)
1114 work_done = mmap_read(u, &sleep_usec, revents & POLLIN);
1115 else
1116 work_done = unix_read(u, &sleep_usec, revents & POLLIN);
1117
1118 if (work_done < 0)
1119 goto fail;
1120
1121 /* pa_log_debug("work_done = %i", work_done); */
1122
1123 if (work_done)
1124 update_smoother(u);
1125
1126 if (u->use_tsched) {
1127 pa_usec_t cusec;
1128
1129 /* OK, the capture buffer is now empty, let's
1130 * calculate when to wake up next */
1131
1132 /* pa_log_debug("Waking up in %0.2fms (sound card clock).", (double) sleep_usec / PA_USEC_PER_MSEC); */
1133
1134 /* Convert from the sound card time domain to the
1135 * system time domain */
1136 cusec = pa_smoother_translate(u->smoother, pa_rtclock_usec(), sleep_usec);
1137
1138 /* pa_log_debug("Waking up in %0.2fms (system clock).", (double) cusec / PA_USEC_PER_MSEC); */
1139
1140 /* We don't trust the conversion, so we wake up whatever comes first */
1141 pa_rtpoll_set_timer_relative(u->rtpoll, PA_MIN(sleep_usec, cusec));
1142 }
1143 } else if (u->use_tsched)
1144
1145 /* OK, we're in an invalid state, let's disable our timers */
1146 pa_rtpoll_set_timer_disabled(u->rtpoll);
1147
1148 /* Hmm, nothing to do. Let's sleep */
1149 if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
1150 goto fail;
1151
1152 if (ret == 0)
1153 goto finish;
1154
1155 /* Tell ALSA about this and process its response */
1156 if (PA_SOURCE_IS_OPENED(u->source->thread_info.state)) {
1157 struct pollfd *pollfd;
1158 int err;
1159 unsigned n;
1160
1161 pollfd = pa_rtpoll_item_get_pollfd(u->alsa_rtpoll_item, &n);
1162
1163 if ((err = snd_pcm_poll_descriptors_revents(u->pcm_handle, pollfd, n, &revents)) < 0) {
1164 pa_log("snd_pcm_poll_descriptors_revents() failed: %s", pa_alsa_strerror(err));
1165 goto fail;
1166 }
1167
1168 if (revents & ~POLLIN) {
1169 if (pa_alsa_recover_from_poll(u->pcm_handle, revents) < 0)
1170 goto fail;
1171
1172 snd_pcm_start(u->pcm_handle);
1173 } else if (revents && u->use_tsched && pa_log_ratelimit())
1174 pa_log_debug("Wakeup from ALSA!");
1175
1176 } else
1177 revents = 0;
1178 }
1179
1180 fail:
1181 /* If this was no regular exit from the loop we have to continue
1182 * processing messages until we received PA_MESSAGE_SHUTDOWN */
1183 pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
1184 pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
1185
1186 finish:
1187 pa_log_debug("Thread shutting down");
1188 }
1189
1190 static void set_source_name(pa_source_new_data *data, pa_modargs *ma, const char *device_id, const char *device_name, pa_alsa_mapping *mapping) {
1191 const char *n;
1192 char *t;
1193
1194 pa_assert(data);
1195 pa_assert(ma);
1196 pa_assert(device_name);
1197
1198 if ((n = pa_modargs_get_value(ma, "source_name", NULL))) {
1199 pa_source_new_data_set_name(data, n);
1200 data->namereg_fail = TRUE;
1201 return;
1202 }
1203
1204 if ((n = pa_modargs_get_value(ma, "name", NULL)))
1205 data->namereg_fail = TRUE;
1206 else {
1207 n = device_id ? device_id : device_name;
1208 data->namereg_fail = FALSE;
1209 }
1210
1211 if (mapping)
1212 t = pa_sprintf_malloc("alsa_input.%s.%s", n, mapping->name);
1213 else
1214 t = pa_sprintf_malloc("alsa_input.%s", n);
1215
1216 pa_source_new_data_set_name(data, t);
1217 pa_xfree(t);
1218 }
1219
1220 static void find_mixer(struct userdata *u, pa_alsa_mapping *mapping, const char *element, pa_bool_t ignore_dB) {
1221
1222 if (!mapping && !element)
1223 return;
1224
1225 if (!(u->mixer_handle = pa_alsa_open_mixer_for_pcm(u->pcm_handle, &u->control_device))) {
1226 pa_log_info("Failed to find a working mixer device.");
1227 return;
1228 }
1229
1230 if (element) {
1231
1232 if (!(u->mixer_path = pa_alsa_path_synthesize(element, PA_ALSA_DIRECTION_INPUT)))
1233 goto fail;
1234
1235 if (pa_alsa_path_probe(u->mixer_path, u->mixer_handle, ignore_dB) < 0)
1236 goto fail;
1237
1238 pa_log_debug("Probed mixer path %s:", u->mixer_path->name);
1239 pa_alsa_path_dump(u->mixer_path);
1240 } else {
1241
1242 if (!(u->mixer_path_set = pa_alsa_path_set_new(mapping, PA_ALSA_DIRECTION_INPUT)))
1243 goto fail;
1244
1245 pa_alsa_path_set_probe(u->mixer_path_set, u->mixer_handle, ignore_dB);
1246
1247 pa_log_debug("Probed mixer paths:");
1248 pa_alsa_path_set_dump(u->mixer_path_set);
1249 }
1250
1251 return;
1252
1253 fail:
1254
1255 if (u->mixer_path_set) {
1256 pa_alsa_path_set_free(u->mixer_path_set);
1257 u->mixer_path_set = NULL;
1258 } else if (u->mixer_path) {
1259 pa_alsa_path_free(u->mixer_path);
1260 u->mixer_path = NULL;
1261 }
1262
1263 if (u->mixer_handle) {
1264 snd_mixer_close(u->mixer_handle);
1265 u->mixer_handle = NULL;
1266 }
1267 }
1268
1269 static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) {
1270 pa_assert(u);
1271
1272 if (!u->mixer_handle)
1273 return 0;
1274
1275 if (u->source->active_port) {
1276 pa_alsa_port_data *data;
1277
1278 /* We have a list of supported paths, so let's activate the
1279 * one that has been chosen as active */
1280
1281 data = PA_DEVICE_PORT_DATA(u->source->active_port);
1282 u->mixer_path = data->path;
1283
1284 pa_alsa_path_select(data->path, u->mixer_handle);
1285
1286 if (data->setting)
1287 pa_alsa_setting_select(data->setting, u->mixer_handle);
1288
1289 } else {
1290
1291 if (!u->mixer_path && u->mixer_path_set)
1292 u->mixer_path = u->mixer_path_set->paths;
1293
1294 if (u->mixer_path) {
1295 /* Hmm, we have only a single path, then let's activate it */
1296
1297 pa_alsa_path_select(u->mixer_path, u->mixer_handle);
1298
1299 if (u->mixer_path->settings)
1300 pa_alsa_setting_select(u->mixer_path->settings, u->mixer_handle);
1301 } else
1302 return 0;
1303 }
1304
1305 if (!u->mixer_path->has_volume)
1306 pa_log_info("Driver does not support hardware volume control, falling back to software volume control.");
1307 else {
1308
1309 if (u->mixer_path->has_dB) {
1310 pa_log_info("Hardware volume ranges from %0.2f dB to %0.2f dB.", u->mixer_path->min_dB, u->mixer_path->max_dB);
1311
1312 u->source->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
1313 u->source->n_volume_steps = PA_VOLUME_NORM+1;
1314
1315 if (u->mixer_path->max_dB > 0.0)
1316 pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(u->source->base_volume));
1317 else
1318 pa_log_info("No particular base volume set, fixing to 0 dB");
1319
1320 } else {
1321 pa_log_info("Hardware volume ranges from %li to %li.", u->mixer_path->min_volume, u->mixer_path->max_volume);
1322 u->source->base_volume = PA_VOLUME_NORM;
1323 u->source->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1;
1324 }
1325
1326 u->source->get_volume = source_get_volume_cb;
1327 u->source->set_volume = source_set_volume_cb;
1328
1329 u->source->flags |= PA_SOURCE_HW_VOLUME_CTRL | (u->mixer_path->has_dB ? PA_SOURCE_DECIBEL_VOLUME : 0);
1330 pa_log_info("Using hardware volume control. Hardware dB scale %s.", u->mixer_path->has_dB ? "supported" : "not supported");
1331 }
1332
1333 if (!u->mixer_path->has_mute) {
1334 pa_log_info("Driver does not support hardware mute control, falling back to software mute control.");
1335 } else {
1336 u->source->get_mute = source_get_mute_cb;
1337 u->source->set_mute = source_set_mute_cb;
1338 u->source->flags |= PA_SOURCE_HW_MUTE_CTRL;
1339 pa_log_info("Using hardware mute control.");
1340 }
1341
1342 u->mixer_fdl = pa_alsa_fdlist_new();
1343
1344 if (pa_alsa_fdlist_set_mixer(u->mixer_fdl, u->mixer_handle, u->core->mainloop) < 0) {
1345 pa_log("Failed to initialize file descriptor monitoring");
1346 return -1;
1347 }
1348
1349 if (u->mixer_path_set)
1350 pa_alsa_path_set_set_callback(u->mixer_path_set, u->mixer_handle, mixer_callback, u);
1351 else
1352 pa_alsa_path_set_callback(u->mixer_path, u->mixer_handle, mixer_callback, u);
1353
1354 return 0;
1355 }
1356
1357 pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, pa_card *card, pa_alsa_mapping *mapping) {
1358
1359 struct userdata *u = NULL;
1360 const char *dev_id = NULL;
1361 pa_sample_spec ss, requested_ss;
1362 pa_channel_map map;
1363 uint32_t nfrags, hwbuf_size, frag_size, tsched_size, tsched_watermark;
1364 snd_pcm_uframes_t period_frames, tsched_frames;
1365 size_t frame_size;
1366 pa_bool_t use_mmap = TRUE, b, use_tsched = TRUE, d, ignore_dB = FALSE;
1367 pa_source_new_data data;
1368 pa_alsa_profile_set *profile_set = NULL;
1369
1370 pa_assert(m);
1371 pa_assert(ma);
1372
1373 ss = m->core->default_sample_spec;
1374 map = m->core->default_channel_map;
1375 if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_ALSA) < 0) {
1376 pa_log("Failed to parse sample specification");
1377 goto fail;
1378 }
1379
1380 requested_ss = ss;
1381 frame_size = pa_frame_size(&ss);
1382
1383 nfrags = m->core->default_n_fragments;
1384 frag_size = (uint32_t) pa_usec_to_bytes(m->core->default_fragment_size_msec*PA_USEC_PER_MSEC, &ss);
1385 if (frag_size <= 0)
1386 frag_size = (uint32_t) frame_size;
1387 tsched_size = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_BUFFER_USEC, &ss);
1388 tsched_watermark = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_WATERMARK_USEC, &ss);
1389
1390 if (pa_modargs_get_value_u32(ma, "fragments", &nfrags) < 0 ||
1391 pa_modargs_get_value_u32(ma, "fragment_size", &frag_size) < 0 ||
1392 pa_modargs_get_value_u32(ma, "tsched_buffer_size", &tsched_size) < 0 ||
1393 pa_modargs_get_value_u32(ma, "tsched_buffer_watermark", &tsched_watermark) < 0) {
1394 pa_log("Failed to parse buffer metrics");
1395 goto fail;
1396 }
1397
1398 hwbuf_size = frag_size * nfrags;
1399 period_frames = frag_size/frame_size;
1400 tsched_frames = tsched_size/frame_size;
1401
1402 if (pa_modargs_get_value_boolean(ma, "mmap", &use_mmap) < 0) {
1403 pa_log("Failed to parse mmap argument.");
1404 goto fail;
1405 }
1406
1407 if (pa_modargs_get_value_boolean(ma, "tsched", &use_tsched) < 0) {
1408 pa_log("Failed to parse timer_scheduling argument.");
1409 goto fail;
1410 }
1411
1412 if (pa_modargs_get_value_boolean(ma, "ignore_dB", &ignore_dB) < 0) {
1413 pa_log("Failed to parse ignore_dB argument.");
1414 goto fail;
1415 }
1416
1417 if (use_tsched && !pa_rtclock_hrtimer()) {
1418 pa_log_notice("Disabling timer-based scheduling because high-resolution timers are not available from the kernel.");
1419 use_tsched = FALSE;
1420 }
1421
1422 u = pa_xnew0(struct userdata, 1);
1423 u->core = m->core;
1424 u->module = m;
1425 u->use_mmap = use_mmap;
1426 u->use_tsched = use_tsched;
1427 u->rtpoll = pa_rtpoll_new();
1428 pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
1429
1430 u->smoother = pa_smoother_new(
1431 DEFAULT_TSCHED_WATERMARK_USEC*2,
1432 DEFAULT_TSCHED_WATERMARK_USEC*2,
1433 TRUE,
1434 TRUE,
1435 5,
1436 pa_rtclock_usec(),
1437 FALSE);
1438
1439 dev_id = pa_modargs_get_value(
1440 ma, "device_id",
1441 pa_modargs_get_value(ma, "device", DEFAULT_DEVICE));
1442
1443 if (reserve_init(u, dev_id) < 0)
1444 goto fail;
1445
1446 if (reserve_monitor_init(u, dev_id) < 0)
1447 goto fail;
1448
1449 b = use_mmap;
1450 d = use_tsched;
1451
1452 if (mapping) {
1453
1454 if (!(dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1455 pa_log("device_id= not set");
1456 goto fail;
1457 }
1458
1459 if (!(u->pcm_handle = pa_alsa_open_by_device_id_mapping(
1460 dev_id,
1461 &u->device_name,
1462 &ss, &map,
1463 SND_PCM_STREAM_CAPTURE,
1464 &nfrags, &period_frames, tsched_frames,
1465 &b, &d, mapping)))
1466 goto fail;
1467
1468 } else if ((dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1469
1470 if (!(profile_set = pa_alsa_profile_set_new(NULL, &map)))
1471 goto fail;
1472
1473 if (!(u->pcm_handle = pa_alsa_open_by_device_id_auto(
1474 dev_id,
1475 &u->device_name,
1476 &ss, &map,
1477 SND_PCM_STREAM_CAPTURE,
1478 &nfrags, &period_frames, tsched_frames,
1479 &b, &d, profile_set, &mapping)))
1480 goto fail;
1481
1482 } else {
1483
1484 if (!(u->pcm_handle = pa_alsa_open_by_device_string(
1485 pa_modargs_get_value(ma, "device", DEFAULT_DEVICE),
1486 &u->device_name,
1487 &ss, &map,
1488 SND_PCM_STREAM_CAPTURE,
1489 &nfrags, &period_frames, tsched_frames,
1490 &b, &d, FALSE)))
1491 goto fail;
1492 }
1493
1494 pa_assert(u->device_name);
1495 pa_log_info("Successfully opened device %s.", u->device_name);
1496
1497 if (pa_alsa_pcm_is_modem(u->pcm_handle)) {
1498 pa_log_notice("Device %s is modem, refusing further initialization.", u->device_name);
1499 goto fail;
1500 }
1501
1502 if (mapping)
1503 pa_log_info("Selected mapping '%s' (%s).", mapping->description, mapping->name);
1504
1505 if (use_mmap && !b) {
1506 pa_log_info("Device doesn't support mmap(), falling back to UNIX read/write mode.");
1507 u->use_mmap = use_mmap = FALSE;
1508 }
1509
1510 if (use_tsched && (!b || !d)) {
1511 pa_log_info("Cannot enable timer-based scheduling, falling back to sound IRQ scheduling.");
1512 u->use_tsched = use_tsched = FALSE;
1513 }
1514
1515 if (use_tsched && !pa_alsa_pcm_is_hw(u->pcm_handle)) {
1516 pa_log_info("Device is not a hardware device, disabling timer-based scheduling.");
1517 u->use_tsched = use_tsched = FALSE;
1518 }
1519
1520 if (u->use_mmap)
1521 pa_log_info("Successfully enabled mmap() mode.");
1522
1523 if (u->use_tsched)
1524 pa_log_info("Successfully enabled timer-based scheduling mode.");
1525
1526 /* ALSA might tweak the sample spec, so recalculate the frame size */
1527 frame_size = pa_frame_size(&ss);
1528
1529 find_mixer(u, mapping, pa_modargs_get_value(ma, "control", NULL), ignore_dB);
1530
1531 pa_source_new_data_init(&data);
1532 data.driver = driver;
1533 data.module = m;
1534 data.card = card;
1535 set_source_name(&data, ma, dev_id, u->device_name, mapping);
1536 pa_source_new_data_set_sample_spec(&data, &ss);
1537 pa_source_new_data_set_channel_map(&data, &map);
1538
1539 pa_alsa_init_proplist_pcm(m->core, data.proplist, u->pcm_handle);
1540 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->device_name);
1541 pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE, "%lu", (unsigned long) (period_frames * frame_size * nfrags));
1542 pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE, "%lu", (unsigned long) (period_frames * frame_size));
1543 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_ACCESS_MODE, u->use_tsched ? "mmap+timer" : (u->use_mmap ? "mmap" : "serial"));
1544
1545 if (mapping) {
1546 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_NAME, mapping->name);
1547 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_DESCRIPTION, mapping->description);
1548 }
1549
1550 pa_alsa_init_description(data.proplist);
1551
1552 if (u->control_device)
1553 pa_alsa_init_proplist_ctl(data.proplist, u->control_device);
1554
1555 if (pa_modargs_get_proplist(ma, "source_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
1556 pa_log("Invalid properties");
1557 pa_source_new_data_done(&data);
1558 goto fail;
1559 }
1560
1561 if (u->mixer_path_set)
1562 pa_alsa_add_ports(&data.ports, u->mixer_path_set);
1563
1564 u->source = pa_source_new(m->core, &data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY|(u->use_tsched ? PA_SOURCE_DYNAMIC_LATENCY : 0));
1565 pa_source_new_data_done(&data);
1566
1567 if (!u->source) {
1568 pa_log("Failed to create source object");
1569 goto fail;
1570 }
1571
1572 u->source->parent.process_msg = source_process_msg;
1573 u->source->update_requested_latency = source_update_requested_latency_cb;
1574 u->source->set_state = source_set_state_cb;
1575 u->source->set_port = source_set_port_cb;
1576 u->source->userdata = u;
1577
1578 pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
1579 pa_source_set_rtpoll(u->source, u->rtpoll);
1580
1581 u->frame_size = frame_size;
1582 u->fragment_size = frag_size = (uint32_t) (period_frames * frame_size);
1583 u->nfragments = nfrags;
1584 u->hwbuf_size = u->fragment_size * nfrags;
1585 u->tsched_watermark = pa_usec_to_bytes_round_up(pa_bytes_to_usec_round_up(tsched_watermark, &requested_ss), &u->source->sample_spec);
1586 pa_cvolume_mute(&u->hardware_volume, u->source->sample_spec.channels);
1587
1588 pa_log_info("Using %u fragments of size %lu bytes, buffer time is %0.2fms",
1589 nfrags, (long unsigned) u->fragment_size,
1590 (double) pa_bytes_to_usec(u->hwbuf_size, &ss) / PA_USEC_PER_MSEC);
1591
1592 if (u->use_tsched) {
1593 u->watermark_step = pa_usec_to_bytes(TSCHED_WATERMARK_STEP_USEC, &u->source->sample_spec);
1594
1595 fix_min_sleep_wakeup(u);
1596 fix_tsched_watermark(u);
1597
1598 pa_source_set_latency_range(u->source,
1599 0,
1600 pa_bytes_to_usec(u->hwbuf_size, &ss));
1601
1602 pa_log_info("Time scheduling watermark is %0.2fms",
1603 (double) pa_bytes_to_usec(u->tsched_watermark, &ss) / PA_USEC_PER_MSEC);
1604 } else
1605 pa_source_set_fixed_latency(u->source, pa_bytes_to_usec(u->hwbuf_size, &ss));
1606
1607 reserve_update(u);
1608
1609 if (update_sw_params(u) < 0)
1610 goto fail;
1611
1612 if (setup_mixer(u, ignore_dB) < 0)
1613 goto fail;
1614
1615 pa_alsa_dump(PA_LOG_DEBUG, u->pcm_handle);
1616
1617 if (!(u->thread = pa_thread_new(thread_func, u))) {
1618 pa_log("Failed to create thread.");
1619 goto fail;
1620 }
1621 /* Get initial mixer settings */
1622 if (data.volume_is_set) {
1623 if (u->source->set_volume)
1624 u->source->set_volume(u->source);
1625 } else {
1626 if (u->source->get_volume)
1627 u->source->get_volume(u->source);
1628 }
1629
1630 if (data.muted_is_set) {
1631 if (u->source->set_mute)
1632 u->source->set_mute(u->source);
1633 } else {
1634 if (u->source->get_mute)
1635 u->source->get_mute(u->source);
1636 }
1637
1638 pa_source_put(u->source);
1639
1640 if (profile_set)
1641 pa_alsa_profile_set_free(profile_set);
1642
1643 return u->source;
1644
1645 fail:
1646
1647 if (u)
1648 userdata_free(u);
1649
1650 if (profile_set)
1651 pa_alsa_profile_set_free(profile_set);
1652
1653 return NULL;
1654 }
1655
1656 static void userdata_free(struct userdata *u) {
1657 pa_assert(u);
1658
1659 if (u->source)
1660 pa_source_unlink(u->source);
1661
1662 if (u->thread) {
1663 pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
1664 pa_thread_free(u->thread);
1665 }
1666
1667 pa_thread_mq_done(&u->thread_mq);
1668
1669 if (u->source)
1670 pa_source_unref(u->source);
1671
1672 if (u->alsa_rtpoll_item)
1673 pa_rtpoll_item_free(u->alsa_rtpoll_item);
1674
1675 if (u->rtpoll)
1676 pa_rtpoll_free(u->rtpoll);
1677
1678 if (u->pcm_handle) {
1679 snd_pcm_drop(u->pcm_handle);
1680 snd_pcm_close(u->pcm_handle);
1681 }
1682
1683 if (u->mixer_fdl)
1684 pa_alsa_fdlist_free(u->mixer_fdl);
1685
1686 if (u->mixer_path_set)
1687 pa_alsa_path_set_free(u->mixer_path_set);
1688 else if (u->mixer_path)
1689 pa_alsa_path_free(u->mixer_path);
1690
1691 if (u->mixer_handle)
1692 snd_mixer_close(u->mixer_handle);
1693
1694 if (u->smoother)
1695 pa_smoother_free(u->smoother);
1696
1697 reserve_done(u);
1698 monitor_done(u);
1699
1700 pa_xfree(u->device_name);
1701 pa_xfree(u->control_device);
1702 pa_xfree(u);
1703 }
1704
1705 void pa_alsa_source_free(pa_source *s) {
1706 struct userdata *u;
1707
1708 pa_source_assert_ref(s);
1709 pa_assert_se(u = s->userdata);
1710
1711 userdata_free(u);
1712 }