]> code.delx.au - pulseaudio/blob - src/modules/alsa/alsa-sink.c
delx.au / code / pulseaudio / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
alsa: Update process_usec before going to sleep
[pulseaudio] / src / modules / alsa / alsa-sink.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 #ifdef HAVE_VALGRIND_MEMCHECK_H
32 #include <valgrind/memcheck.h>
33 #endif
34
35 #include <pulse/rtclock.h>
36 #include <pulse/timeval.h>
37 #include <pulse/volume.h>
38 #include <pulse/xmalloc.h>
39
40 #include <pulsecore/core.h>
41 #include <pulsecore/i18n.h>
42 #include <pulsecore/module.h>
43 #include <pulsecore/memchunk.h>
44 #include <pulsecore/sink.h>
45 #include <pulsecore/modargs.h>
46 #include <pulsecore/core-rtclock.h>
47 #include <pulsecore/core-util.h>
48 #include <pulsecore/sample-util.h>
49 #include <pulsecore/log.h>
50 #include <pulsecore/macro.h>
51 #include <pulsecore/thread.h>
52 #include <pulsecore/thread-mq.h>
53 #include <pulsecore/rtpoll.h>
54 #include <pulsecore/time-smoother.h>
55
56 #include <modules/reserve-wrap.h>
57
58 #include "alsa-util.h"
59 #include "alsa-sink.h"
60
61 /* #define DEBUG_TIMING */
62
63 #define DEFAULT_DEVICE "default"
64
65 #define DEFAULT_TSCHED_BUFFER_USEC (2*PA_USEC_PER_SEC) /* 2s -- Overall buffer size */
66 #define DEFAULT_TSCHED_WATERMARK_USEC (20*PA_USEC_PER_MSEC) /* 20ms -- Fill up when only this much is left in the buffer */
67
68 #define TSCHED_WATERMARK_INC_STEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms -- On underrun, increase watermark by this */
69 #define TSCHED_WATERMARK_DEC_STEP_USEC (5*PA_USEC_PER_MSEC) /* 5ms -- When everything's great, decrease watermark by this */
70 #define TSCHED_WATERMARK_VERIFY_AFTER_USEC (20*PA_USEC_PER_SEC) /* 20s -- How long after a drop out recheck if things are good now */
71 #define TSCHED_WATERMARK_INC_THRESHOLD_USEC (0*PA_USEC_PER_MSEC) /* 0ms -- If the buffer level ever below this theshold, increase the watermark */
72 #define TSCHED_WATERMARK_DEC_THRESHOLD_USEC (100*PA_USEC_PER_MSEC) /* 100ms -- If the buffer level didn't drop below this theshold in the verification time, decrease the watermark */
73
74 /* Note that TSCHED_WATERMARK_INC_THRESHOLD_USEC == 0 means tht we
75 * will increase the watermark only if we hit a real underrun. */
76
77 #define TSCHED_MIN_SLEEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms -- Sleep at least 10ms on each iteration */
78 #define TSCHED_MIN_WAKEUP_USEC (4*PA_USEC_PER_MSEC) /* 4ms -- Wakeup at least this long before the buffer runs empty*/
79
80 #define SMOOTHER_WINDOW_USEC (10*PA_USEC_PER_SEC) /* 10s -- smoother windows size */
81 #define SMOOTHER_ADJUST_USEC (1*PA_USEC_PER_SEC) /* 1s -- smoother adjust time */
82
83 #define SMOOTHER_MIN_INTERVAL (2*PA_USEC_PER_MSEC) /* 2ms -- min smoother update interval */
84 #define SMOOTHER_MAX_INTERVAL (200*PA_USEC_PER_MSEC) /* 200ms -- max smoother update interval */
85
86 #define VOLUME_ACCURACY (PA_VOLUME_NORM/100) /* don't require volume adjustments to be perfectly correct. don't necessarily extend granularity in software unless the differences get greater than this level */
87
88 #define DEFAULT_REWIND_SAFEGUARD_BYTES (256U) /* 1.33ms @48kHz, we'll never rewind less than this */
89 #define DEFAULT_REWIND_SAFEGUARD_USEC (1330) /* 1.33ms, depending on channels/rate/sample we may rewind more than 256 above */
90
91 struct userdata {
92 pa_core *core;
93 pa_module *module;
94 pa_sink *sink;
95
96 pa_thread *thread;
97 pa_thread_mq thread_mq;
98 pa_rtpoll *rtpoll;
99
100 snd_pcm_t *pcm_handle;
101
102 pa_alsa_fdlist *mixer_fdl;
103 pa_alsa_mixer_pdata *mixer_pd;
104 snd_mixer_t *mixer_handle;
105 pa_alsa_path_set *mixer_path_set;
106 pa_alsa_path *mixer_path;
107
108 pa_cvolume hardware_volume;
109
110 uint32_t old_rate;
111
112 size_t
113 frame_size,
114 fragment_size,
115 hwbuf_size,
116 tsched_watermark,
117 hwbuf_unused,
118 min_sleep,
119 min_wakeup,
120 watermark_inc_step,
121 watermark_dec_step,
122 watermark_inc_threshold,
123 watermark_dec_threshold,
124 rewind_safeguard;
125
126 pa_usec_t watermark_dec_not_before;
127
128 pa_memchunk memchunk;
129
130 char *device_name; /* name of the PCM device */
131 char *control_device; /* name of the control device */
132
133 pa_bool_t use_mmap:1, use_tsched:1, sync_volume:1;
134
135 pa_bool_t first, after_rewind;
136
137 pa_rtpoll_item *alsa_rtpoll_item;
138
139 snd_mixer_selem_channel_id_t mixer_map[SND_MIXER_SCHN_LAST];
140
141 pa_smoother *smoother;
142 uint64_t write_count;
143 uint64_t since_start;
144 pa_usec_t smoother_interval;
145 pa_usec_t last_smoother_update;
146
147 pa_reserve_wrapper *reserve;
148 pa_hook_slot *reserve_slot;
149 pa_reserve_monitor_wrapper *monitor;
150 pa_hook_slot *monitor_slot;
151 };
152
153 static void userdata_free(struct userdata *u);
154
155 static pa_hook_result_t reserve_cb(pa_reserve_wrapper *r, void *forced, struct userdata *u) {
156 pa_assert(r);
157 pa_assert(u);
158
159 if (pa_sink_suspend(u->sink, TRUE, PA_SUSPEND_APPLICATION) < 0)
160 return PA_HOOK_CANCEL;
161
162 return PA_HOOK_OK;
163 }
164
165 static void reserve_done(struct userdata *u) {
166 pa_assert(u);
167
168 if (u->reserve_slot) {
169 pa_hook_slot_free(u->reserve_slot);
170 u->reserve_slot = NULL;
171 }
172
173 if (u->reserve) {
174 pa_reserve_wrapper_unref(u->reserve);
175 u->reserve = NULL;
176 }
177 }
178
179 static void reserve_update(struct userdata *u) {
180 const char *description;
181 pa_assert(u);
182
183 if (!u->sink || !u->reserve)
184 return;
185
186 if ((description = pa_proplist_gets(u->sink->proplist, PA_PROP_DEVICE_DESCRIPTION)))
187 pa_reserve_wrapper_set_application_device_name(u->reserve, description);
188 }
189
190 static int reserve_init(struct userdata *u, const char *dname) {
191 char *rname;
192
193 pa_assert(u);
194 pa_assert(dname);
195
196 if (u->reserve)
197 return 0;
198
199 if (pa_in_system_mode())
200 return 0;
201
202 if (!(rname = pa_alsa_get_reserve_name(dname)))
203 return 0;
204
205 /* We are resuming, try to lock the device */
206 u->reserve = pa_reserve_wrapper_get(u->core, rname);
207 pa_xfree(rname);
208
209 if (!(u->reserve))
210 return -1;
211
212 reserve_update(u);
213
214 pa_assert(!u->reserve_slot);
215 u->reserve_slot = pa_hook_connect(pa_reserve_wrapper_hook(u->reserve), PA_HOOK_NORMAL, (pa_hook_cb_t) reserve_cb, u);
216
217 return 0;
218 }
219
220 static pa_hook_result_t monitor_cb(pa_reserve_monitor_wrapper *w, void* busy, struct userdata *u) {
221 pa_bool_t b;
222
223 pa_assert(w);
224 pa_assert(u);
225
226 b = PA_PTR_TO_UINT(busy) && !u->reserve;
227
228 pa_sink_suspend(u->sink, b, PA_SUSPEND_APPLICATION);
229 return PA_HOOK_OK;
230 }
231
232 static void monitor_done(struct userdata *u) {
233 pa_assert(u);
234
235 if (u->monitor_slot) {
236 pa_hook_slot_free(u->monitor_slot);
237 u->monitor_slot = NULL;
238 }
239
240 if (u->monitor) {
241 pa_reserve_monitor_wrapper_unref(u->monitor);
242 u->monitor = NULL;
243 }
244 }
245
246 static int reserve_monitor_init(struct userdata *u, const char *dname) {
247 char *rname;
248
249 pa_assert(u);
250 pa_assert(dname);
251
252 if (pa_in_system_mode())
253 return 0;
254
255 if (!(rname = pa_alsa_get_reserve_name(dname)))
256 return 0;
257
258 /* We are resuming, try to lock the device */
259 u->monitor = pa_reserve_monitor_wrapper_get(u->core, rname);
260 pa_xfree(rname);
261
262 if (!(u->monitor))
263 return -1;
264
265 pa_assert(!u->monitor_slot);
266 u->monitor_slot = pa_hook_connect(pa_reserve_monitor_wrapper_hook(u->monitor), PA_HOOK_NORMAL, (pa_hook_cb_t) monitor_cb, u);
267
268 return 0;
269 }
270
271 static void fix_min_sleep_wakeup(struct userdata *u) {
272 size_t max_use, max_use_2;
273
274 pa_assert(u);
275 pa_assert(u->use_tsched);
276
277 max_use = u->hwbuf_size - u->hwbuf_unused;
278 max_use_2 = pa_frame_align(max_use/2, &u->sink->sample_spec);
279
280 u->min_sleep = pa_usec_to_bytes(TSCHED_MIN_SLEEP_USEC, &u->sink->sample_spec);
281 u->min_sleep = PA_CLAMP(u->min_sleep, u->frame_size, max_use_2);
282
283 u->min_wakeup = pa_usec_to_bytes(TSCHED_MIN_WAKEUP_USEC, &u->sink->sample_spec);
284 u->min_wakeup = PA_CLAMP(u->min_wakeup, u->frame_size, max_use_2);
285 }
286
287 static void fix_tsched_watermark(struct userdata *u) {
288 size_t max_use;
289 pa_assert(u);
290 pa_assert(u->use_tsched);
291
292 max_use = u->hwbuf_size - u->hwbuf_unused;
293
294 if (u->tsched_watermark > max_use - u->min_sleep)
295 u->tsched_watermark = max_use - u->min_sleep;
296
297 if (u->tsched_watermark < u->min_wakeup)
298 u->tsched_watermark = u->min_wakeup;
299 }
300
301 static void increase_watermark(struct userdata *u) {
302 size_t old_watermark;
303 pa_usec_t old_min_latency, new_min_latency;
304
305 pa_assert(u);
306 pa_assert(u->use_tsched);
307
308 /* First, just try to increase the watermark */
309 old_watermark = u->tsched_watermark;
310 u->tsched_watermark = PA_MIN(u->tsched_watermark * 2, u->tsched_watermark + u->watermark_inc_step);
311 fix_tsched_watermark(u);
312
313 if (old_watermark != u->tsched_watermark) {
314 pa_log_info("Increasing wakeup watermark to %0.2f ms",
315 (double) pa_bytes_to_usec(u->tsched_watermark, &u->sink->sample_spec) / PA_USEC_PER_MSEC);
316 return;
317 }
318
319 /* Hmm, we cannot increase the watermark any further, hence let's raise the latency */
320 old_min_latency = u->sink->thread_info.min_latency;
321 new_min_latency = PA_MIN(old_min_latency * 2, old_min_latency + TSCHED_WATERMARK_INC_STEP_USEC);
322 new_min_latency = PA_MIN(new_min_latency, u->sink->thread_info.max_latency);
323
324 if (old_min_latency != new_min_latency) {
325 pa_log_info("Increasing minimal latency to %0.2f ms",
326 (double) new_min_latency / PA_USEC_PER_MSEC);
327
328 pa_sink_set_latency_range_within_thread(u->sink, new_min_latency, u->sink->thread_info.max_latency);
329 }
330
331 /* When we reach this we're officialy fucked! */
332 }
333
334 static void decrease_watermark(struct userdata *u) {
335 size_t old_watermark;
336 pa_usec_t now;
337
338 pa_assert(u);
339 pa_assert(u->use_tsched);
340
341 now = pa_rtclock_now();
342
343 if (u->watermark_dec_not_before <= 0)
344 goto restart;
345
346 if (u->watermark_dec_not_before > now)
347 return;
348
349 old_watermark = u->tsched_watermark;
350
351 if (u->tsched_watermark < u->watermark_dec_step)
352 u->tsched_watermark = u->tsched_watermark / 2;
353 else
354 u->tsched_watermark = PA_MAX(u->tsched_watermark / 2, u->tsched_watermark - u->watermark_dec_step);
355
356 fix_tsched_watermark(u);
357
358 if (old_watermark != u->tsched_watermark)
359 pa_log_info("Decreasing wakeup watermark to %0.2f ms",
360 (double) pa_bytes_to_usec(u->tsched_watermark, &u->sink->sample_spec) / PA_USEC_PER_MSEC);
361
362 /* We don't change the latency range*/
363
364 restart:
365 u->watermark_dec_not_before = now + TSCHED_WATERMARK_VERIFY_AFTER_USEC;
366 }
367
368 static void hw_sleep_time(struct userdata *u, pa_usec_t *sleep_usec, pa_usec_t*process_usec) {
369 pa_usec_t usec, wm;
370
371 pa_assert(sleep_usec);
372 pa_assert(process_usec);
373
374 pa_assert(u);
375 pa_assert(u->use_tsched);
376
377 usec = pa_sink_get_requested_latency_within_thread(u->sink);
378
379 if (usec == (pa_usec_t) -1)
380 usec = pa_bytes_to_usec(u->hwbuf_size, &u->sink->sample_spec);
381
382 wm = pa_bytes_to_usec(u->tsched_watermark, &u->sink->sample_spec);
383
384 if (wm > usec)
385 wm = usec/2;
386
387 *sleep_usec = usec - wm;
388 *process_usec = wm;
389
390 #ifdef DEBUG_TIMING
391 pa_log_debug("Buffer time: %lu ms; Sleep time: %lu ms; Process time: %lu ms",
392 (unsigned long) (usec / PA_USEC_PER_MSEC),
393 (unsigned long) (*sleep_usec / PA_USEC_PER_MSEC),
394 (unsigned long) (*process_usec / PA_USEC_PER_MSEC));
395 #endif
396 }
397
398 static int try_recover(struct userdata *u, const char *call, int err) {
399 pa_assert(u);
400 pa_assert(call);
401 pa_assert(err < 0);
402
403 pa_log_debug("%s: %s", call, pa_alsa_strerror(err));
404
405 pa_assert(err != -EAGAIN);
406
407 if (err == -EPIPE)
408 pa_log_debug("%s: Buffer underrun!", call);
409
410 if (err == -ESTRPIPE)
411 pa_log_debug("%s: System suspended!", call);
412
413 if ((err = snd_pcm_recover(u->pcm_handle, err, 1)) < 0) {
414 pa_log("%s: %s", call, pa_alsa_strerror(err));
415 return -1;
416 }
417
418 u->first = TRUE;
419 u->since_start = 0;
420 return 0;
421 }
422
423 static size_t check_left_to_play(struct userdata *u, size_t n_bytes, pa_bool_t on_timeout) {
424 size_t left_to_play;
425 pa_bool_t underrun = FALSE;
426
427 /* We use <= instead of < for this check here because an underrun
428 * only happens after the last sample was processed, not already when
429 * it is removed from the buffer. This is particularly important
430 * when block transfer is used. */
431
432 if (n_bytes <= u->hwbuf_size)
433 left_to_play = u->hwbuf_size - n_bytes;
434 else {
435
436 /* We got a dropout. What a mess! */
437 left_to_play = 0;
438 underrun = TRUE;
439
440 #ifdef DEBUG_TIMING
441 PA_DEBUG_TRAP;
442 #endif
443
444 if (!u->first && !u->after_rewind)
445 if (pa_log_ratelimit(PA_LOG_INFO))
446 pa_log_info("Underrun!");
447 }
448
449 #ifdef DEBUG_TIMING
450 pa_log_debug("%0.2f ms left to play; inc threshold = %0.2f ms; dec threshold = %0.2f ms",
451 (double) pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) / PA_USEC_PER_MSEC,
452 (double) pa_bytes_to_usec(u->watermark_inc_threshold, &u->sink->sample_spec) / PA_USEC_PER_MSEC,
453 (double) pa_bytes_to_usec(u->watermark_dec_threshold, &u->sink->sample_spec) / PA_USEC_PER_MSEC);
454 #endif
455
456 if (u->use_tsched) {
457 pa_bool_t reset_not_before = TRUE;
458
459 if (!u->first && !u->after_rewind) {
460 if (underrun || left_to_play < u->watermark_inc_threshold)
461 increase_watermark(u);
462 else if (left_to_play > u->watermark_dec_threshold) {
463 reset_not_before = FALSE;
464
465 /* We decrease the watermark only if have actually
466 * been woken up by a timeout. If something else woke
467 * us up it's too easy to fulfill the deadlines... */
468
469 if (on_timeout)
470 decrease_watermark(u);
471 }
472 }
473
474 if (reset_not_before)
475 u->watermark_dec_not_before = 0;
476 }
477
478 return left_to_play;
479 }
480
481 static int mmap_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled, pa_bool_t on_timeout) {
482 pa_bool_t work_done = FALSE;
483 pa_usec_t max_sleep_usec = 0, process_usec = 0;
484 size_t left_to_play;
485 unsigned j = 0;
486
487 pa_assert(u);
488 pa_sink_assert_ref(u->sink);
489
490 if (u->use_tsched)
491 hw_sleep_time(u, &max_sleep_usec, &process_usec);
492
493 for (;;) {
494 snd_pcm_sframes_t n;
495 size_t n_bytes;
496 int r;
497 pa_bool_t after_avail = TRUE;
498
499 /* First we determine how many samples are missing to fill the
500 * buffer up to 100% */
501
502 if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->sink->sample_spec)) < 0)) {
503
504 if ((r = try_recover(u, "snd_pcm_avail", (int) n)) == 0)
505 continue;
506
507 return r;
508 }
509
510 n_bytes = (size_t) n * u->frame_size;
511
512 #ifdef DEBUG_TIMING
513 pa_log_debug("avail: %lu", (unsigned long) n_bytes);
514 #endif
515
516 left_to_play = check_left_to_play(u, n_bytes, on_timeout);
517 on_timeout = FALSE;
518
519 if (u->use_tsched)
520
521 /* We won't fill up the playback buffer before at least
522 * half the sleep time is over because otherwise we might
523 * ask for more data from the clients then they expect. We
524 * need to guarantee that clients only have to keep around
525 * a single hw buffer length. */
526
527 if (!polled &&
528 pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) > process_usec+max_sleep_usec/2) {
529 #ifdef DEBUG_TIMING
530 pa_log_debug("Not filling up, because too early.");
531 #endif
532 break;
533 }
534
535 if (PA_UNLIKELY(n_bytes <= u->hwbuf_unused)) {
536
537 if (polled)
538 PA_ONCE_BEGIN {
539 char *dn = pa_alsa_get_driver_name_by_pcm(u->pcm_handle);
540 pa_log(_("ALSA woke us up to write new data to the device, but there was actually nothing to write!\n"
541 "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
542 "We were woken up with POLLOUT set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
543 pa_strnull(dn));
544 pa_xfree(dn);
545 } PA_ONCE_END;
546
547 #ifdef DEBUG_TIMING
548 pa_log_debug("Not filling up, because not necessary.");
549 #endif
550 break;
551 }
552
553
554 if (++j > 10) {
555 #ifdef DEBUG_TIMING
556 pa_log_debug("Not filling up, because already too many iterations.");
557 #endif
558
559 break;
560 }
561
562 n_bytes -= u->hwbuf_unused;
563 polled = FALSE;
564
565 #ifdef DEBUG_TIMING
566 pa_log_debug("Filling up");
567 #endif
568
569 for (;;) {
570 pa_memchunk chunk;
571 void *p;
572 int err;
573 const snd_pcm_channel_area_t *areas;
574 snd_pcm_uframes_t offset, frames;
575 snd_pcm_sframes_t sframes;
576
577 frames = (snd_pcm_uframes_t) (n_bytes / u->frame_size);
578 /* pa_log_debug("%lu frames to write", (unsigned long) frames); */
579
580 if (PA_UNLIKELY((err = pa_alsa_safe_mmap_begin(u->pcm_handle, &areas, &offset, &frames, u->hwbuf_size, &u->sink->sample_spec)) < 0)) {
581
582 if (!after_avail && err == -EAGAIN)
583 break;
584
585 if ((r = try_recover(u, "snd_pcm_mmap_begin", err)) == 0)
586 continue;
587
588 return r;
589 }
590
591 /* Make sure that if these memblocks need to be copied they will fit into one slot */
592 if (frames > pa_mempool_block_size_max(u->core->mempool)/u->frame_size)
593 frames = pa_mempool_block_size_max(u->core->mempool)/u->frame_size;
594
595 if (!after_avail && frames == 0)
596 break;
597
598 pa_assert(frames > 0);
599 after_avail = FALSE;
600
601 /* Check these are multiples of 8 bit */
602 pa_assert((areas[0].first & 7) == 0);
603 pa_assert((areas[0].step & 7)== 0);
604
605 /* We assume a single interleaved memory buffer */
606 pa_assert((areas[0].first >> 3) == 0);
607 pa_assert((areas[0].step >> 3) == u->frame_size);
608
609 p = (uint8_t*) areas[0].addr + (offset * u->frame_size);
610
611 chunk.memblock = pa_memblock_new_fixed(u->core->mempool, p, frames * u->frame_size, TRUE);
612 chunk.length = pa_memblock_get_length(chunk.memblock);
613 chunk.index = 0;
614
615 pa_sink_render_into_full(u->sink, &chunk);
616 pa_memblock_unref_fixed(chunk.memblock);
617
618 if (PA_UNLIKELY((sframes = snd_pcm_mmap_commit(u->pcm_handle, offset, frames)) < 0)) {
619
620 if (!after_avail && (int) sframes == -EAGAIN)
621 break;
622
623 if ((r = try_recover(u, "snd_pcm_mmap_commit", (int) sframes)) == 0)
624 continue;
625
626 return r;
627 }
628
629 work_done = TRUE;
630
631 u->write_count += frames * u->frame_size;
632 u->since_start += frames * u->frame_size;
633
634 #ifdef DEBUG_TIMING
635 pa_log_debug("Wrote %lu bytes (of possible %lu bytes)", (unsigned long) (frames * u->frame_size), (unsigned long) n_bytes);
636 #endif
637
638 if ((size_t) frames * u->frame_size >= n_bytes)
639 break;
640
641 n_bytes -= (size_t) frames * u->frame_size;
642 }
643 }
644
645 if (u->use_tsched) {
646 *sleep_usec = pa_bytes_to_usec(left_to_play, &u->sink->sample_spec);
647 process_usec = pa_bytes_to_usec(u->tsched_watermark, &u->sink->sample_spec);
648
649 if (*sleep_usec > process_usec)
650 *sleep_usec -= process_usec;
651 else
652 *sleep_usec = 0;
653 } else
654 *sleep_usec = 0;
655
656 return work_done ? 1 : 0;
657 }
658
659 static int unix_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled, pa_bool_t on_timeout) {
660 pa_bool_t work_done = FALSE;
661 pa_usec_t max_sleep_usec = 0, process_usec = 0;
662 size_t left_to_play;
663 unsigned j = 0;
664
665 pa_assert(u);
666 pa_sink_assert_ref(u->sink);
667
668 if (u->use_tsched)
669 hw_sleep_time(u, &max_sleep_usec, &process_usec);
670
671 for (;;) {
672 snd_pcm_sframes_t n;
673 size_t n_bytes;
674 int r;
675 pa_bool_t after_avail = TRUE;
676
677 if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->sink->sample_spec)) < 0)) {
678
679 if ((r = try_recover(u, "snd_pcm_avail", (int) n)) == 0)
680 continue;
681
682 return r;
683 }
684
685 n_bytes = (size_t) n * u->frame_size;
686 left_to_play = check_left_to_play(u, n_bytes, on_timeout);
687 on_timeout = FALSE;
688
689 if (u->use_tsched)
690
691 /* We won't fill up the playback buffer before at least
692 * half the sleep time is over because otherwise we might
693 * ask for more data from the clients then they expect. We
694 * need to guarantee that clients only have to keep around
695 * a single hw buffer length. */
696
697 if (!polled &&
698 pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) > process_usec+max_sleep_usec/2)
699 break;
700
701 if (PA_UNLIKELY(n_bytes <= u->hwbuf_unused)) {
702
703 if (polled)
704 PA_ONCE_BEGIN {
705 char *dn = pa_alsa_get_driver_name_by_pcm(u->pcm_handle);
706 pa_log(_("ALSA woke us up to write new data to the device, but there was actually nothing to write!\n"
707 "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
708 "We were woken up with POLLOUT set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
709 pa_strnull(dn));
710 pa_xfree(dn);
711 } PA_ONCE_END;
712
713 break;
714 }
715
716 if (++j > 10) {
717 #ifdef DEBUG_TIMING
718 pa_log_debug("Not filling up, because already too many iterations.");
719 #endif
720
721 break;
722 }
723
724 n_bytes -= u->hwbuf_unused;
725 polled = FALSE;
726
727 for (;;) {
728 snd_pcm_sframes_t frames;
729 void *p;
730
731 /* pa_log_debug("%lu frames to write", (unsigned long) frames); */
732
733 if (u->memchunk.length <= 0)
734 pa_sink_render(u->sink, n_bytes, &u->memchunk);
735
736 pa_assert(u->memchunk.length > 0);
737
738 frames = (snd_pcm_sframes_t) (u->memchunk.length / u->frame_size);
739
740 if (frames > (snd_pcm_sframes_t) (n_bytes/u->frame_size))
741 frames = (snd_pcm_sframes_t) (n_bytes/u->frame_size);
742
743 p = pa_memblock_acquire(u->memchunk.memblock);
744 frames = snd_pcm_writei(u->pcm_handle, (const uint8_t*) p + u->memchunk.index, (snd_pcm_uframes_t) frames);
745 pa_memblock_release(u->memchunk.memblock);
746
747 if (PA_UNLIKELY(frames < 0)) {
748
749 if (!after_avail && (int) frames == -EAGAIN)
750 break;
751
752 if ((r = try_recover(u, "snd_pcm_writei", (int) frames)) == 0)
753 continue;
754
755 return r;
756 }
757
758 if (!after_avail && frames == 0)
759 break;
760
761 pa_assert(frames > 0);
762 after_avail = FALSE;
763
764 u->memchunk.index += (size_t) frames * u->frame_size;
765 u->memchunk.length -= (size_t) frames * u->frame_size;
766
767 if (u->memchunk.length <= 0) {
768 pa_memblock_unref(u->memchunk.memblock);
769 pa_memchunk_reset(&u->memchunk);
770 }
771
772 work_done = TRUE;
773
774 u->write_count += frames * u->frame_size;
775 u->since_start += frames * u->frame_size;
776
777 /* pa_log_debug("wrote %lu frames", (unsigned long) frames); */
778
779 if ((size_t) frames * u->frame_size >= n_bytes)
780 break;
781
782 n_bytes -= (size_t) frames * u->frame_size;
783 }
784 }
785
786 if (u->use_tsched) {
787 *sleep_usec = pa_bytes_to_usec(left_to_play, &u->sink->sample_spec);
788 process_usec = pa_bytes_to_usec(u->tsched_watermark, &u->sink->sample_spec);
789
790 if (*sleep_usec > process_usec)
791 *sleep_usec -= process_usec;
792 else
793 *sleep_usec = 0;
794 } else
795 *sleep_usec = 0;
796
797 return work_done ? 1 : 0;
798 }
799
800 static void update_smoother(struct userdata *u) {
801 snd_pcm_sframes_t delay = 0;
802 int64_t position;
803 int err;
804 pa_usec_t now1 = 0, now2;
805 snd_pcm_status_t *status;
806
807 snd_pcm_status_alloca(&status);
808
809 pa_assert(u);
810 pa_assert(u->pcm_handle);
811
812 /* Let's update the time smoother */
813
814 if (PA_UNLIKELY((err = pa_alsa_safe_delay(u->pcm_handle, &delay, u->hwbuf_size, &u->sink->sample_spec, FALSE)) < 0)) {
815 pa_log_warn("Failed to query DSP status data: %s", pa_alsa_strerror(err));
816 return;
817 }
818
819 if (PA_UNLIKELY((err = snd_pcm_status(u->pcm_handle, status)) < 0))
820 pa_log_warn("Failed to get timestamp: %s", pa_alsa_strerror(err));
821 else {
822 snd_htimestamp_t htstamp = { 0, 0 };
823 snd_pcm_status_get_htstamp(status, &htstamp);
824 now1 = pa_timespec_load(&htstamp);
825 }
826
827 /* Hmm, if the timestamp is 0, then it wasn't set and we take the current time */
828 if (now1 <= 0)
829 now1 = pa_rtclock_now();
830
831 /* check if the time since the last update is bigger than the interval */
832 if (u->last_smoother_update > 0)
833 if (u->last_smoother_update + u->smoother_interval > now1)
834 return;
835
836 position = (int64_t) u->write_count - ((int64_t) delay * (int64_t) u->frame_size);
837
838 if (PA_UNLIKELY(position < 0))
839 position = 0;
840
841 now2 = pa_bytes_to_usec((uint64_t) position, &u->sink->sample_spec);
842
843 pa_smoother_put(u->smoother, now1, now2);
844
845 u->last_smoother_update = now1;
846 /* exponentially increase the update interval up to the MAX limit */
847 u->smoother_interval = PA_MIN (u->smoother_interval * 2, SMOOTHER_MAX_INTERVAL);
848 }
849
850 static pa_usec_t sink_get_latency(struct userdata *u) {
851 pa_usec_t r;
852 int64_t delay;
853 pa_usec_t now1, now2;
854
855 pa_assert(u);
856
857 now1 = pa_rtclock_now();
858 now2 = pa_smoother_get(u->smoother, now1);
859
860 delay = (int64_t) pa_bytes_to_usec(u->write_count, &u->sink->sample_spec) - (int64_t) now2;
861
862 r = delay >= 0 ? (pa_usec_t) delay : 0;
863
864 if (u->memchunk.memblock)
865 r += pa_bytes_to_usec(u->memchunk.length, &u->sink->sample_spec);
866
867 return r;
868 }
869
870 static int build_pollfd(struct userdata *u) {
871 pa_assert(u);
872 pa_assert(u->pcm_handle);
873
874 if (u->alsa_rtpoll_item)
875 pa_rtpoll_item_free(u->alsa_rtpoll_item);
876
877 if (!(u->alsa_rtpoll_item = pa_alsa_build_pollfd(u->pcm_handle, u->rtpoll)))
878 return -1;
879
880 return 0;
881 }
882
883 /* Called from IO context */
884 static int suspend(struct userdata *u) {
885 pa_assert(u);
886 pa_assert(u->pcm_handle);
887
888 pa_smoother_pause(u->smoother, pa_rtclock_now());
889
890 /* Let's suspend -- we don't call snd_pcm_drain() here since that might
891 * take awfully long with our long buffer sizes today. */
892 snd_pcm_close(u->pcm_handle);
893 u->pcm_handle = NULL;
894
895 if (u->alsa_rtpoll_item) {
896 pa_rtpoll_item_free(u->alsa_rtpoll_item);
897 u->alsa_rtpoll_item = NULL;
898 }
899
900 /* We reset max_rewind/max_request here to make sure that while we
901 * are suspended the old max_request/max_rewind values set before
902 * the suspend can influence the per-stream buffer of newly
903 * created streams, without their requirements having any
904 * influence on them. */
905 pa_sink_set_max_rewind_within_thread(u->sink, 0);
906 pa_sink_set_max_request_within_thread(u->sink, 0);
907
908 pa_log_info("Device suspended...");
909
910 return 0;
911 }
912
913 /* Called from IO context */
914 static int update_sw_params(struct userdata *u) {
915 snd_pcm_uframes_t avail_min;
916 int err;
917
918 pa_assert(u);
919
920 /* Use the full buffer if noone asked us for anything specific */
921 u->hwbuf_unused = 0;
922
923 if (u->use_tsched) {
924 pa_usec_t latency;
925
926 if ((latency = pa_sink_get_requested_latency_within_thread(u->sink)) != (pa_usec_t) -1) {
927 size_t b;
928
929 pa_log_debug("Latency set to %0.2fms", (double) latency / PA_USEC_PER_MSEC);
930
931 b = pa_usec_to_bytes(latency, &u->sink->sample_spec);
932
933 /* We need at least one sample in our buffer */
934
935 if (PA_UNLIKELY(b < u->frame_size))
936 b = u->frame_size;
937
938 u->hwbuf_unused = PA_LIKELY(b < u->hwbuf_size) ? (u->hwbuf_size - b) : 0;
939 }
940
941 fix_min_sleep_wakeup(u);
942 fix_tsched_watermark(u);
943 }
944
945 pa_log_debug("hwbuf_unused=%lu", (unsigned long) u->hwbuf_unused);
946
947 /* We need at last one frame in the used part of the buffer */
948 avail_min = (snd_pcm_uframes_t) u->hwbuf_unused / u->frame_size + 1;
949
950 if (u->use_tsched) {
951 pa_usec_t sleep_usec, process_usec;
952
953 hw_sleep_time(u, &sleep_usec, &process_usec);
954 avail_min += pa_usec_to_bytes(sleep_usec, &u->sink->sample_spec) / u->frame_size;
955 }
956
957 pa_log_debug("setting avail_min=%lu", (unsigned long) avail_min);
958
959 if ((err = pa_alsa_set_sw_params(u->pcm_handle, avail_min, !u->use_tsched)) < 0) {
960 pa_log("Failed to set software parameters: %s", pa_alsa_strerror(err));
961 return err;
962 }
963
964 pa_sink_set_max_request_within_thread(u->sink, u->hwbuf_size - u->hwbuf_unused);
965 if (pa_alsa_pcm_is_hw(u->pcm_handle))
966 pa_sink_set_max_rewind_within_thread(u->sink, u->hwbuf_size);
967 else {
968 pa_log_info("Disabling rewind_within_thread for device %s", u->device_name);
969 pa_sink_set_max_rewind_within_thread(u->sink, 0);
970 }
971
972 return 0;
973 }
974
975 /* Called from IO context */
976 static int unsuspend(struct userdata *u) {
977 pa_sample_spec ss;
978 int err;
979 pa_bool_t b, d;
980 snd_pcm_uframes_t period_size, buffer_size;
981
982 pa_assert(u);
983 pa_assert(!u->pcm_handle);
984
985 pa_log_info("Trying resume...");
986
987 if ((err = snd_pcm_open(&u->pcm_handle, u->device_name, SND_PCM_STREAM_PLAYBACK,
988 SND_PCM_NONBLOCK|
989 SND_PCM_NO_AUTO_RESAMPLE|
990 SND_PCM_NO_AUTO_CHANNELS|
991 SND_PCM_NO_AUTO_FORMAT)) < 0) {
992 pa_log("Error opening PCM device %s: %s", u->device_name, pa_alsa_strerror(err));
993 goto fail;
994 }
995
996 ss = u->sink->sample_spec;
997 period_size = u->fragment_size / u->frame_size;
998 buffer_size = u->hwbuf_size / u->frame_size;
999 b = u->use_mmap;
1000 d = u->use_tsched;
1001
1002 if ((err = pa_alsa_set_hw_params(u->pcm_handle, &ss, &period_size, &buffer_size, 0, &b, &d, TRUE)) < 0) {
1003 pa_log("Failed to set hardware parameters: %s", pa_alsa_strerror(err));
1004 goto fail;
1005 }
1006
1007 if (b != u->use_mmap || d != u->use_tsched) {
1008 pa_log_warn("Resume failed, couldn't get original access mode.");
1009 goto fail;
1010 }
1011
1012 if (!pa_sample_spec_equal(&ss, &u->sink->sample_spec)) {
1013 pa_log_warn("Resume failed, couldn't restore original sample settings.");
1014 goto fail;
1015 }
1016
1017 if (period_size*u->frame_size != u->fragment_size ||
1018 buffer_size*u->frame_size != u->hwbuf_size) {
1019 pa_log_warn("Resume failed, couldn't restore original fragment settings. (Old: %lu/%lu, New %lu/%lu)",
1020 (unsigned long) u->hwbuf_size, (unsigned long) u->fragment_size,
1021 (unsigned long) (buffer_size*u->frame_size), (unsigned long) (period_size*u->frame_size));
1022 goto fail;
1023 }
1024
1025 if (update_sw_params(u) < 0)
1026 goto fail;
1027
1028 if (build_pollfd(u) < 0)
1029 goto fail;
1030
1031 u->write_count = 0;
1032 pa_smoother_reset(u->smoother, pa_rtclock_now(), TRUE);
1033 u->smoother_interval = SMOOTHER_MIN_INTERVAL;
1034 u->last_smoother_update = 0;
1035
1036 u->first = TRUE;
1037 u->since_start = 0;
1038
1039 pa_log_info("Resumed successfully...");
1040
1041 return 0;
1042
1043 fail:
1044 if (u->pcm_handle) {
1045 snd_pcm_close(u->pcm_handle);
1046 u->pcm_handle = NULL;
1047 }
1048
1049 return -PA_ERR_IO;
1050 }
1051
1052 /* Called from IO context */
1053 static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
1054 struct userdata *u = PA_SINK(o)->userdata;
1055
1056 switch (code) {
1057
1058 case PA_SINK_MESSAGE_FINISH_MOVE:
1059 case PA_SINK_MESSAGE_ADD_INPUT: {
1060 pa_sink_input *i = PA_SINK_INPUT(data);
1061 int r = 0;
1062
1063 if (PA_LIKELY(!pa_sink_input_is_passthrough(i)))
1064 break;
1065
1066 u->old_rate = u->sink->sample_spec.rate;
1067
1068 /* Passthrough format, see if we need to reset sink sample rate */
1069 if (u->sink->sample_spec.rate == i->thread_info.sample_spec.rate)
1070 break;
1071
1072 /* .. we do */
1073 if ((r = suspend(u)) < 0)
1074 return r;
1075
1076 u->sink->sample_spec.rate = i->thread_info.sample_spec.rate;
1077
1078 if ((r = unsuspend(u)) < 0)
1079 return r;
1080
1081 break;
1082 }
1083
1084 case PA_SINK_MESSAGE_START_MOVE:
1085 case PA_SINK_MESSAGE_REMOVE_INPUT: {
1086 pa_sink_input *i = PA_SINK_INPUT(data);
1087 int r = 0;
1088
1089 if (PA_LIKELY(!pa_sink_input_is_passthrough(i)))
1090 break;
1091
1092 /* Passthrough format, see if we need to reset sink sample rate */
1093 if (u->sink->sample_spec.rate == u->old_rate)
1094 break;
1095
1096 /* .. we do */
1097 if ((r = suspend(u)) < 0)
1098 return r;
1099
1100 u->sink->sample_spec.rate = u->old_rate;
1101
1102 if ((r = unsuspend(u)) < 0)
1103 return r;
1104
1105 break;
1106 }
1107
1108 case PA_SINK_MESSAGE_GET_LATENCY: {
1109 pa_usec_t r = 0;
1110
1111 if (u->pcm_handle)
1112 r = sink_get_latency(u);
1113
1114 *((pa_usec_t*) data) = r;
1115
1116 return 0;
1117 }
1118
1119 case PA_SINK_MESSAGE_SET_STATE:
1120
1121 switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) {
1122
1123 case PA_SINK_SUSPENDED: {
1124 int r;
1125
1126 pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
1127
1128 if ((r = suspend(u)) < 0)
1129 return r;
1130
1131 break;
1132 }
1133
1134 case PA_SINK_IDLE:
1135 case PA_SINK_RUNNING: {
1136 int r;
1137
1138 if (u->sink->thread_info.state == PA_SINK_INIT) {
1139 if (build_pollfd(u) < 0)
1140 return -PA_ERR_IO;
1141 }
1142
1143 if (u->sink->thread_info.state == PA_SINK_SUSPENDED) {
1144 if ((r = unsuspend(u)) < 0)
1145 return r;
1146 }
1147
1148 break;
1149 }
1150
1151 case PA_SINK_UNLINKED:
1152 case PA_SINK_INIT:
1153 case PA_SINK_INVALID_STATE:
1154 ;
1155 }
1156
1157 break;
1158 }
1159
1160 return pa_sink_process_msg(o, code, data, offset, chunk);
1161 }
1162
1163 /* Called from main context */
1164 static int sink_set_state_cb(pa_sink *s, pa_sink_state_t new_state) {
1165 pa_sink_state_t old_state;
1166 struct userdata *u;
1167
1168 pa_sink_assert_ref(s);
1169 pa_assert_se(u = s->userdata);
1170
1171 old_state = pa_sink_get_state(u->sink);
1172
1173 if (PA_SINK_IS_OPENED(old_state) && new_state == PA_SINK_SUSPENDED)
1174 reserve_done(u);
1175 else if (old_state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(new_state))
1176 if (reserve_init(u, u->device_name) < 0)
1177 return -PA_ERR_BUSY;
1178
1179 return 0;
1180 }
1181
1182 static int ctl_mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) {
1183 struct userdata *u = snd_mixer_elem_get_callback_private(elem);
1184
1185 pa_assert(u);
1186 pa_assert(u->mixer_handle);
1187
1188 if (mask == SND_CTL_EVENT_MASK_REMOVE)
1189 return 0;
1190
1191 if (u->sink->suspend_cause & PA_SUSPEND_SESSION)
1192 return 0;
1193
1194 if (mask & SND_CTL_EVENT_MASK_VALUE) {
1195 pa_sink_get_volume(u->sink, TRUE);
1196 pa_sink_get_mute(u->sink, TRUE);
1197 }
1198
1199 return 0;
1200 }
1201
1202 static int io_mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) {
1203 struct userdata *u = snd_mixer_elem_get_callback_private(elem);
1204
1205 pa_assert(u);
1206 pa_assert(u->mixer_handle);
1207
1208 if (mask == SND_CTL_EVENT_MASK_REMOVE)
1209 return 0;
1210
1211 if (u->sink->suspend_cause & PA_SUSPEND_SESSION)
1212 return 0;
1213
1214 if (mask & SND_CTL_EVENT_MASK_VALUE)
1215 pa_sink_update_volume_and_mute(u->sink);
1216
1217 return 0;
1218 }
1219
1220 static void sink_get_volume_cb(pa_sink *s) {
1221 struct userdata *u = s->userdata;
1222 pa_cvolume r;
1223 char vol_str_pcnt[PA_CVOLUME_SNPRINT_MAX];
1224
1225 pa_assert(u);
1226 pa_assert(u->mixer_path);
1227 pa_assert(u->mixer_handle);
1228
1229 if (pa_alsa_path_get_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r) < 0)
1230 return;
1231
1232 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1233 pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
1234
1235 pa_log_debug("Read hardware volume: %s", pa_cvolume_snprint(vol_str_pcnt, sizeof(vol_str_pcnt), &r));
1236
1237 if (u->mixer_path->has_dB) {
1238 char vol_str_db[PA_SW_CVOLUME_SNPRINT_DB_MAX];
1239
1240 pa_log_debug(" in dB: %s", pa_sw_cvolume_snprint_dB(vol_str_db, sizeof(vol_str_db), &r));
1241 }
1242
1243 if (pa_cvolume_equal(&u->hardware_volume, &r))
1244 return;
1245
1246 s->real_volume = u->hardware_volume = r;
1247
1248 /* Hmm, so the hardware volume changed, let's reset our software volume */
1249 if (u->mixer_path->has_dB)
1250 pa_sink_set_soft_volume(s, NULL);
1251 }
1252
1253 static void sink_set_volume_cb(pa_sink *s) {
1254 struct userdata *u = s->userdata;
1255 pa_cvolume r;
1256 char vol_str_pcnt[PA_CVOLUME_SNPRINT_MAX];
1257 pa_bool_t sync_volume = !!(s->flags & PA_SINK_SYNC_VOLUME);
1258
1259 pa_assert(u);
1260 pa_assert(u->mixer_path);
1261 pa_assert(u->mixer_handle);
1262
1263 /* Shift up by the base volume */
1264 pa_sw_cvolume_divide_scalar(&r, &s->real_volume, s->base_volume);
1265
1266 if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r, sync_volume, !sync_volume) < 0)
1267 return;
1268
1269 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1270 pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
1271
1272 u->hardware_volume = r;
1273
1274 if (u->mixer_path->has_dB) {
1275 pa_cvolume new_soft_volume;
1276 pa_bool_t accurate_enough;
1277 char vol_str_db[PA_SW_CVOLUME_SNPRINT_DB_MAX];
1278
1279 /* Match exactly what the user requested by software */
1280 pa_sw_cvolume_divide(&new_soft_volume, &s->real_volume, &u->hardware_volume);
1281
1282 /* If the adjustment to do in software is only minimal we
1283 * can skip it. That saves us CPU at the expense of a bit of
1284 * accuracy */
1285 accurate_enough =
1286 (pa_cvolume_min(&new_soft_volume) >= (PA_VOLUME_NORM - VOLUME_ACCURACY)) &&
1287 (pa_cvolume_max(&new_soft_volume) <= (PA_VOLUME_NORM + VOLUME_ACCURACY));
1288
1289 pa_log_debug("Requested volume: %s", pa_cvolume_snprint(vol_str_pcnt, sizeof(vol_str_pcnt), &s->real_volume));
1290 pa_log_debug(" in dB: %s", pa_sw_cvolume_snprint_dB(vol_str_db, sizeof(vol_str_db), &s->real_volume));
1291 pa_log_debug("Got hardware volume: %s", pa_cvolume_snprint(vol_str_pcnt, sizeof(vol_str_pcnt), &u->hardware_volume));
1292 pa_log_debug(" in dB: %s", pa_sw_cvolume_snprint_dB(vol_str_db, sizeof(vol_str_db), &u->hardware_volume));
1293 pa_log_debug("Calculated software volume: %s (accurate-enough=%s)",
1294 pa_cvolume_snprint(vol_str_pcnt, sizeof(vol_str_pcnt), &new_soft_volume),
1295 pa_yes_no(accurate_enough));
1296 pa_log_debug(" in dB: %s", pa_sw_cvolume_snprint_dB(vol_str_db, sizeof(vol_str_db), &new_soft_volume));
1297
1298 if (!accurate_enough)
1299 s->soft_volume = new_soft_volume;
1300
1301 } else {
1302 pa_log_debug("Wrote hardware volume: %s", pa_cvolume_snprint(vol_str_pcnt, sizeof(vol_str_pcnt), &r));
1303
1304 /* We can't match exactly what the user requested, hence let's
1305 * at least tell the user about it */
1306
1307 s->real_volume = r;
1308 }
1309 }
1310
1311 static void sink_write_volume_cb(pa_sink *s) {
1312 struct userdata *u = s->userdata;
1313 pa_cvolume hw_vol = s->thread_info.current_hw_volume;
1314
1315 pa_assert(u);
1316 pa_assert(u->mixer_path);
1317 pa_assert(u->mixer_handle);
1318 pa_assert(s->flags & PA_SINK_SYNC_VOLUME);
1319
1320 /* Shift up by the base volume */
1321 pa_sw_cvolume_divide_scalar(&hw_vol, &hw_vol, s->base_volume);
1322
1323 if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &hw_vol, TRUE, TRUE) < 0)
1324 pa_log_error("Writing HW volume failed");
1325 else {
1326 pa_cvolume tmp_vol;
1327 pa_bool_t accurate_enough;
1328
1329 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1330 pa_sw_cvolume_multiply_scalar(&hw_vol, &hw_vol, s->base_volume);
1331
1332 pa_sw_cvolume_divide(&tmp_vol, &hw_vol, &s->thread_info.current_hw_volume);
1333 accurate_enough =
1334 (pa_cvolume_min(&tmp_vol) >= (PA_VOLUME_NORM - VOLUME_ACCURACY)) &&
1335 (pa_cvolume_max(&tmp_vol) <= (PA_VOLUME_NORM + VOLUME_ACCURACY));
1336
1337 if (!accurate_enough) {
1338 union {
1339 char db[2][PA_SW_CVOLUME_SNPRINT_DB_MAX];
1340 char pcnt[2][PA_CVOLUME_SNPRINT_MAX];
1341 } vol;
1342
1343 pa_log_debug("Written HW volume did not match with the request: %s (request) != %s",
1344 pa_cvolume_snprint(vol.pcnt[0], sizeof(vol.pcnt[0]), &s->thread_info.current_hw_volume),
1345 pa_cvolume_snprint(vol.pcnt[1], sizeof(vol.pcnt[1]), &hw_vol));
1346 pa_log_debug(" in dB: %s (request) != %s",
1347 pa_sw_cvolume_snprint_dB(vol.db[0], sizeof(vol.db[0]), &s->thread_info.current_hw_volume),
1348 pa_sw_cvolume_snprint_dB(vol.db[1], sizeof(vol.db[1]), &hw_vol));
1349 }
1350 }
1351 }
1352
1353 static void sink_get_mute_cb(pa_sink *s) {
1354 struct userdata *u = s->userdata;
1355 pa_bool_t b;
1356
1357 pa_assert(u);
1358 pa_assert(u->mixer_path);
1359 pa_assert(u->mixer_handle);
1360
1361 if (pa_alsa_path_get_mute(u->mixer_path, u->mixer_handle, &b) < 0)
1362 return;
1363
1364 s->muted = b;
1365 }
1366
1367 static void sink_set_mute_cb(pa_sink *s) {
1368 struct userdata *u = s->userdata;
1369
1370 pa_assert(u);
1371 pa_assert(u->mixer_path);
1372 pa_assert(u->mixer_handle);
1373
1374 pa_alsa_path_set_mute(u->mixer_path, u->mixer_handle, s->muted);
1375 }
1376
1377 static void mixer_volume_init(struct userdata *u) {
1378 pa_assert(u);
1379
1380 if (!u->mixer_path->has_volume) {
1381 pa_sink_set_write_volume_callback(u->sink, NULL);
1382 pa_sink_set_get_volume_callback(u->sink, NULL);
1383 pa_sink_set_set_volume_callback(u->sink, NULL);
1384
1385 pa_log_info("Driver does not support hardware volume control, falling back to software volume control.");
1386 } else {
1387 pa_sink_set_get_volume_callback(u->sink, sink_get_volume_cb);
1388 pa_sink_set_set_volume_callback(u->sink, sink_set_volume_cb);
1389
1390 if (u->mixer_path->has_dB && u->sync_volume) {
1391 pa_sink_set_write_volume_callback(u->sink, sink_write_volume_cb);
1392 pa_log_info("Successfully enabled synchronous volume.");
1393 } else
1394 pa_sink_set_write_volume_callback(u->sink, NULL);
1395
1396 if (u->mixer_path->has_dB) {
1397 pa_sink_enable_decibel_volume(u->sink, TRUE);
1398 pa_log_info("Hardware volume ranges from %0.2f dB to %0.2f dB.", u->mixer_path->min_dB, u->mixer_path->max_dB);
1399
1400 u->sink->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
1401 u->sink->n_volume_steps = PA_VOLUME_NORM+1;
1402
1403 pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(u->sink->base_volume));
1404 } else {
1405 pa_sink_enable_decibel_volume(u->sink, FALSE);
1406 pa_log_info("Hardware volume ranges from %li to %li.", u->mixer_path->min_volume, u->mixer_path->max_volume);
1407
1408 u->sink->base_volume = PA_VOLUME_NORM;
1409 u->sink->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1;
1410 }
1411
1412 pa_log_info("Using hardware volume control. Hardware dB scale %s.", u->mixer_path->has_dB ? "supported" : "not supported");
1413 }
1414
1415 if (!u->mixer_path->has_mute) {
1416 pa_sink_set_get_mute_callback(u->sink, NULL);
1417 pa_sink_set_set_mute_callback(u->sink, NULL);
1418 pa_log_info("Driver does not support hardware mute control, falling back to software mute control.");
1419 } else {
1420 pa_sink_set_get_mute_callback(u->sink, sink_get_mute_cb);
1421 pa_sink_set_set_mute_callback(u->sink, sink_set_mute_cb);
1422 pa_log_info("Using hardware mute control.");
1423 }
1424 }
1425
1426 static int sink_set_port_cb(pa_sink *s, pa_device_port *p) {
1427 struct userdata *u = s->userdata;
1428 pa_alsa_port_data *data;
1429
1430 pa_assert(u);
1431 pa_assert(p);
1432 pa_assert(u->mixer_handle);
1433
1434 data = PA_DEVICE_PORT_DATA(p);
1435
1436 pa_assert_se(u->mixer_path = data->path);
1437 pa_alsa_path_select(u->mixer_path, u->mixer_handle);
1438
1439 mixer_volume_init(u);
1440
1441 if (data->setting)
1442 pa_alsa_setting_select(data->setting, u->mixer_handle);
1443
1444 if (s->set_mute)
1445 s->set_mute(s);
1446 if (s->set_volume)
1447 s->set_volume(s);
1448
1449 return 0;
1450 }
1451
1452 static void sink_update_requested_latency_cb(pa_sink *s) {
1453 struct userdata *u = s->userdata;
1454 size_t before;
1455 pa_assert(u);
1456 pa_assert(u->use_tsched); /* only when timer scheduling is used
1457 * we can dynamically adjust the
1458 * latency */
1459
1460 if (!u->pcm_handle)
1461 return;
1462
1463 before = u->hwbuf_unused;
1464 update_sw_params(u);
1465
1466 /* Let's check whether we now use only a smaller part of the
1467 buffer then before. If so, we need to make sure that subsequent
1468 rewinds are relative to the new maximum fill level and not to the
1469 current fill level. Thus, let's do a full rewind once, to clear
1470 things up. */
1471
1472 if (u->hwbuf_unused > before) {
1473 pa_log_debug("Requesting rewind due to latency change.");
1474 pa_sink_request_rewind(s, (size_t) -1);
1475 }
1476 }
1477
1478 static int process_rewind(struct userdata *u) {
1479 snd_pcm_sframes_t unused;
1480 size_t rewind_nbytes, unused_nbytes, limit_nbytes;
1481 pa_assert(u);
1482
1483 /* Figure out how much we shall rewind and reset the counter */
1484 rewind_nbytes = u->sink->thread_info.rewind_nbytes;
1485
1486 pa_log_debug("Requested to rewind %lu bytes.", (unsigned long) rewind_nbytes);
1487
1488 if (PA_UNLIKELY((unused = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->sink->sample_spec)) < 0)) {
1489 pa_log("snd_pcm_avail() failed: %s", pa_alsa_strerror((int) unused));
1490 return -1;
1491 }
1492
1493 unused_nbytes = (size_t) unused * u->frame_size;
1494
1495 /* make sure rewind doesn't go too far, can cause issues with DMAs */
1496 unused_nbytes += u->rewind_safeguard;
1497
1498 if (u->hwbuf_size > unused_nbytes)
1499 limit_nbytes = u->hwbuf_size - unused_nbytes;
1500 else
1501 limit_nbytes = 0;
1502
1503 if (rewind_nbytes > limit_nbytes)
1504 rewind_nbytes = limit_nbytes;
1505
1506 if (rewind_nbytes > 0) {
1507 snd_pcm_sframes_t in_frames, out_frames;
1508
1509 pa_log_debug("Limited to %lu bytes.", (unsigned long) rewind_nbytes);
1510
1511 in_frames = (snd_pcm_sframes_t) (rewind_nbytes / u->frame_size);
1512 pa_log_debug("before: %lu", (unsigned long) in_frames);
1513 if ((out_frames = snd_pcm_rewind(u->pcm_handle, (snd_pcm_uframes_t) in_frames)) < 0) {
1514 pa_log("snd_pcm_rewind() failed: %s", pa_alsa_strerror((int) out_frames));
1515 if (try_recover(u, "process_rewind", out_frames) < 0)
1516 return -1;
1517 out_frames = 0;
1518 }
1519
1520 pa_log_debug("after: %lu", (unsigned long) out_frames);
1521
1522 rewind_nbytes = (size_t) out_frames * u->frame_size;
1523
1524 if (rewind_nbytes <= 0)
1525 pa_log_info("Tried rewind, but was apparently not possible.");
1526 else {
1527 u->write_count -= rewind_nbytes;
1528 pa_log_debug("Rewound %lu bytes.", (unsigned long) rewind_nbytes);
1529 pa_sink_process_rewind(u->sink, rewind_nbytes);
1530
1531 u->after_rewind = TRUE;
1532 return 0;
1533 }
1534 } else
1535 pa_log_debug("Mhmm, actually there is nothing to rewind.");
1536
1537 pa_sink_process_rewind(u->sink, 0);
1538 return 0;
1539 }
1540
1541 static void thread_func(void *userdata) {
1542 struct userdata *u = userdata;
1543 unsigned short revents = 0;
1544
1545 pa_assert(u);
1546
1547 pa_log_debug("Thread starting up");
1548
1549 if (u->core->realtime_scheduling)
1550 pa_make_realtime(u->core->realtime_priority);
1551
1552 pa_thread_mq_install(&u->thread_mq);
1553
1554 for (;;) {
1555 int ret;
1556 pa_usec_t rtpoll_sleep = 0;
1557
1558 #ifdef DEBUG_TIMING
1559 pa_log_debug("Loop");
1560 #endif
1561
1562 /* Render some data and write it to the dsp */
1563 if (PA_SINK_IS_OPENED(u->sink->thread_info.state)) {
1564 int work_done;
1565 pa_usec_t sleep_usec = 0;
1566 pa_bool_t on_timeout = pa_rtpoll_timer_elapsed(u->rtpoll);
1567
1568 if (PA_UNLIKELY(u->sink->thread_info.rewind_requested))
1569 if (process_rewind(u) < 0)
1570 goto fail;
1571
1572 if (u->use_mmap)
1573 work_done = mmap_write(u, &sleep_usec, revents & POLLOUT, on_timeout);
1574 else
1575 work_done = unix_write(u, &sleep_usec, revents & POLLOUT, on_timeout);
1576
1577 if (work_done < 0)
1578 goto fail;
1579
1580 /* pa_log_debug("work_done = %i", work_done); */
1581
1582 if (work_done) {
1583
1584 if (u->first) {
1585 pa_log_info("Starting playback.");
1586 snd_pcm_start(u->pcm_handle);
1587
1588 pa_smoother_resume(u->smoother, pa_rtclock_now(), TRUE);
1589
1590 u->first = FALSE;
1591 }
1592
1593 update_smoother(u);
1594 }
1595
1596 if (u->use_tsched) {
1597 pa_usec_t cusec;
1598
1599 if (u->since_start <= u->hwbuf_size) {
1600
1601 /* USB devices on ALSA seem to hit a buffer
1602 * underrun during the first iterations much
1603 * quicker then we calculate here, probably due to
1604 * the transport latency. To accommodate for that
1605 * we artificially decrease the sleep time until
1606 * we have filled the buffer at least once
1607 * completely.*/
1608
1609 if (pa_log_ratelimit(PA_LOG_DEBUG))
1610 pa_log_debug("Cutting sleep time for the initial iterations by half.");
1611 sleep_usec /= 2;
1612 }
1613
1614 /* OK, the playback buffer is now full, let's
1615 * calculate when to wake up next */
1616 /* pa_log_debug("Waking up in %0.2fms (sound card clock).", (double) sleep_usec / PA_USEC_PER_MSEC); */
1617
1618 /* Convert from the sound card time domain to the
1619 * system time domain */
1620 cusec = pa_smoother_translate(u->smoother, pa_rtclock_now(), sleep_usec);
1621
1622 /* pa_log_debug("Waking up in %0.2fms (system clock).", (double) cusec / PA_USEC_PER_MSEC); */
1623
1624 /* We don't trust the conversion, so we wake up whatever comes first */
1625 rtpoll_sleep = PA_MIN(sleep_usec, cusec);
1626 }
1627
1628 u->after_rewind = FALSE;
1629
1630 }
1631
1632 if (u->sink->flags & PA_SINK_SYNC_VOLUME) {
1633 pa_usec_t volume_sleep;
1634 pa_sink_volume_change_apply(u->sink, &volume_sleep);
1635 if (volume_sleep > 0)
1636 rtpoll_sleep = PA_MIN(volume_sleep, rtpoll_sleep);
1637 }
1638
1639 if (rtpoll_sleep > 0)
1640 pa_rtpoll_set_timer_relative(u->rtpoll, rtpoll_sleep);
1641 else
1642 pa_rtpoll_set_timer_disabled(u->rtpoll);
1643
1644 /* Hmm, nothing to do. Let's sleep */
1645 if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
1646 goto fail;
1647
1648 if (u->sink->flags & PA_SINK_SYNC_VOLUME)
1649 pa_sink_volume_change_apply(u->sink, NULL);
1650
1651 if (ret == 0)
1652 goto finish;
1653
1654 /* Tell ALSA about this and process its response */
1655 if (PA_SINK_IS_OPENED(u->sink->thread_info.state)) {
1656 struct pollfd *pollfd;
1657 int err;
1658 unsigned n;
1659
1660 pollfd = pa_rtpoll_item_get_pollfd(u->alsa_rtpoll_item, &n);
1661
1662 if ((err = snd_pcm_poll_descriptors_revents(u->pcm_handle, pollfd, n, &revents)) < 0) {
1663 pa_log("snd_pcm_poll_descriptors_revents() failed: %s", pa_alsa_strerror(err));
1664 goto fail;
1665 }
1666
1667 if (revents & ~POLLOUT) {
1668 if (pa_alsa_recover_from_poll(u->pcm_handle, revents) < 0)
1669 goto fail;
1670
1671 u->first = TRUE;
1672 u->since_start = 0;
1673 } else if (revents && u->use_tsched && pa_log_ratelimit(PA_LOG_DEBUG))
1674 pa_log_debug("Wakeup from ALSA!");
1675
1676 } else
1677 revents = 0;
1678 }
1679
1680 fail:
1681 /* If this was no regular exit from the loop we have to continue
1682 * processing messages until we received PA_MESSAGE_SHUTDOWN */
1683 pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
1684 pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
1685
1686 finish:
1687 pa_log_debug("Thread shutting down");
1688 }
1689
1690 static void set_sink_name(pa_sink_new_data *data, pa_modargs *ma, const char *device_id, const char *device_name, pa_alsa_mapping *mapping) {
1691 const char *n;
1692 char *t;
1693
1694 pa_assert(data);
1695 pa_assert(ma);
1696 pa_assert(device_name);
1697
1698 if ((n = pa_modargs_get_value(ma, "sink_name", NULL))) {
1699 pa_sink_new_data_set_name(data, n);
1700 data->namereg_fail = TRUE;
1701 return;
1702 }
1703
1704 if ((n = pa_modargs_get_value(ma, "name", NULL)))
1705 data->namereg_fail = TRUE;
1706 else {
1707 n = device_id ? device_id : device_name;
1708 data->namereg_fail = FALSE;
1709 }
1710
1711 if (mapping)
1712 t = pa_sprintf_malloc("alsa_output.%s.%s", n, mapping->name);
1713 else
1714 t = pa_sprintf_malloc("alsa_output.%s", n);
1715
1716 pa_sink_new_data_set_name(data, t);
1717 pa_xfree(t);
1718 }
1719
1720 static void find_mixer(struct userdata *u, pa_alsa_mapping *mapping, const char *element, pa_bool_t ignore_dB) {
1721
1722 if (!mapping && !element)
1723 return;
1724
1725 if (!(u->mixer_handle = pa_alsa_open_mixer_for_pcm(u->pcm_handle, &u->control_device))) {
1726 pa_log_info("Failed to find a working mixer device.");
1727 return;
1728 }
1729
1730 if (element) {
1731
1732 if (!(u->mixer_path = pa_alsa_path_synthesize(element, PA_ALSA_DIRECTION_OUTPUT)))
1733 goto fail;
1734
1735 if (pa_alsa_path_probe(u->mixer_path, u->mixer_handle, ignore_dB) < 0)
1736 goto fail;
1737
1738 pa_log_debug("Probed mixer path %s:", u->mixer_path->name);
1739 pa_alsa_path_dump(u->mixer_path);
1740 } else {
1741
1742 if (!(u->mixer_path_set = pa_alsa_path_set_new(mapping, PA_ALSA_DIRECTION_OUTPUT)))
1743 goto fail;
1744
1745 pa_alsa_path_set_probe(u->mixer_path_set, u->mixer_handle, ignore_dB);
1746 }
1747
1748 return;
1749
1750 fail:
1751
1752 if (u->mixer_path_set) {
1753 pa_alsa_path_set_free(u->mixer_path_set);
1754 u->mixer_path_set = NULL;
1755 } else if (u->mixer_path) {
1756 pa_alsa_path_free(u->mixer_path);
1757 u->mixer_path = NULL;
1758 }
1759
1760 if (u->mixer_handle) {
1761 snd_mixer_close(u->mixer_handle);
1762 u->mixer_handle = NULL;
1763 }
1764 }
1765
1766
1767 static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) {
1768 pa_bool_t need_mixer_callback = FALSE;
1769
1770 pa_assert(u);
1771
1772 if (!u->mixer_handle)
1773 return 0;
1774
1775 if (u->sink->active_port) {
1776 pa_alsa_port_data *data;
1777
1778 /* We have a list of supported paths, so let's activate the
1779 * one that has been chosen as active */
1780
1781 data = PA_DEVICE_PORT_DATA(u->sink->active_port);
1782 u->mixer_path = data->path;
1783
1784 pa_alsa_path_select(data->path, u->mixer_handle);
1785
1786 if (data->setting)
1787 pa_alsa_setting_select(data->setting, u->mixer_handle);
1788
1789 } else {
1790
1791 if (!u->mixer_path && u->mixer_path_set)
1792 u->mixer_path = u->mixer_path_set->paths;
1793
1794 if (u->mixer_path) {
1795 /* Hmm, we have only a single path, then let's activate it */
1796
1797 pa_alsa_path_select(u->mixer_path, u->mixer_handle);
1798
1799 if (u->mixer_path->settings)
1800 pa_alsa_setting_select(u->mixer_path->settings, u->mixer_handle);
1801 } else
1802 return 0;
1803 }
1804
1805 mixer_volume_init(u);
1806
1807 /* Will we need to register callbacks? */
1808 if (u->mixer_path_set && u->mixer_path_set->paths) {
1809 pa_alsa_path *p;
1810
1811 PA_LLIST_FOREACH(p, u->mixer_path_set->paths) {
1812 if (p->has_volume || p->has_mute)
1813 need_mixer_callback = TRUE;
1814 }
1815 }
1816 else if (u->mixer_path)
1817 need_mixer_callback = u->mixer_path->has_volume || u->mixer_path->has_mute;
1818
1819 if (need_mixer_callback) {
1820 int (*mixer_callback)(snd_mixer_elem_t *, unsigned int);
1821 if (u->sink->flags & PA_SINK_SYNC_VOLUME) {
1822 u->mixer_pd = pa_alsa_mixer_pdata_new();
1823 mixer_callback = io_mixer_callback;
1824
1825 if (pa_alsa_set_mixer_rtpoll(u->mixer_pd, u->mixer_handle, u->rtpoll) < 0) {
1826 pa_log("Failed to initialize file descriptor monitoring");
1827 return -1;
1828 }
1829 } else {
1830 u->mixer_fdl = pa_alsa_fdlist_new();
1831 mixer_callback = ctl_mixer_callback;
1832
1833 if (pa_alsa_fdlist_set_mixer(u->mixer_fdl, u->mixer_handle, u->core->mainloop) < 0) {
1834 pa_log("Failed to initialize file descriptor monitoring");
1835 return -1;
1836 }
1837 }
1838
1839 if (u->mixer_path_set)
1840 pa_alsa_path_set_set_callback(u->mixer_path_set, u->mixer_handle, mixer_callback, u);
1841 else
1842 pa_alsa_path_set_callback(u->mixer_path, u->mixer_handle, mixer_callback, u);
1843 }
1844
1845 return 0;
1846 }
1847
1848 pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_card *card, pa_alsa_mapping *mapping) {
1849
1850 struct userdata *u = NULL;
1851 const char *dev_id = NULL;
1852 pa_sample_spec ss, requested_ss;
1853 pa_channel_map map;
1854 uint32_t nfrags, frag_size, buffer_size, tsched_size, tsched_watermark, rewind_safeguard;
1855 snd_pcm_uframes_t period_frames, buffer_frames, tsched_frames;
1856 size_t frame_size;
1857 pa_bool_t use_mmap = TRUE, b, use_tsched = TRUE, d, ignore_dB = FALSE, namereg_fail = FALSE, sync_volume = FALSE;
1858 pa_sink_new_data data;
1859 pa_alsa_profile_set *profile_set = NULL;
1860
1861 pa_assert(m);
1862 pa_assert(ma);
1863
1864 ss = m->core->default_sample_spec;
1865 map = m->core->default_channel_map;
1866 if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_ALSA) < 0) {
1867 pa_log("Failed to parse sample specification and channel map");
1868 goto fail;
1869 }
1870
1871 requested_ss = ss;
1872 frame_size = pa_frame_size(&ss);
1873
1874 nfrags = m->core->default_n_fragments;
1875 frag_size = (uint32_t) pa_usec_to_bytes(m->core->default_fragment_size_msec*PA_USEC_PER_MSEC, &ss);
1876 if (frag_size <= 0)
1877 frag_size = (uint32_t) frame_size;
1878 tsched_size = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_BUFFER_USEC, &ss);
1879 tsched_watermark = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_WATERMARK_USEC, &ss);
1880
1881 if (pa_modargs_get_value_u32(ma, "fragments", &nfrags) < 0 ||
1882 pa_modargs_get_value_u32(ma, "fragment_size", &frag_size) < 0 ||
1883 pa_modargs_get_value_u32(ma, "tsched_buffer_size", &tsched_size) < 0 ||
1884 pa_modargs_get_value_u32(ma, "tsched_buffer_watermark", &tsched_watermark) < 0) {
1885 pa_log("Failed to parse buffer metrics");
1886 goto fail;
1887 }
1888
1889 buffer_size = nfrags * frag_size;
1890
1891 period_frames = frag_size/frame_size;
1892 buffer_frames = buffer_size/frame_size;
1893 tsched_frames = tsched_size/frame_size;
1894
1895 if (pa_modargs_get_value_boolean(ma, "mmap", &use_mmap) < 0) {
1896 pa_log("Failed to parse mmap argument.");
1897 goto fail;
1898 }
1899
1900 if (pa_modargs_get_value_boolean(ma, "tsched", &use_tsched) < 0) {
1901 pa_log("Failed to parse tsched argument.");
1902 goto fail;
1903 }
1904
1905 if (pa_modargs_get_value_boolean(ma, "ignore_dB", &ignore_dB) < 0) {
1906 pa_log("Failed to parse ignore_dB argument.");
1907 goto fail;
1908 }
1909
1910 rewind_safeguard = PA_MAX(DEFAULT_REWIND_SAFEGUARD_BYTES, pa_usec_to_bytes(DEFAULT_REWIND_SAFEGUARD_USEC, &ss));
1911 if (pa_modargs_get_value_u32(ma, "rewind_safeguard", &rewind_safeguard) < 0) {
1912 pa_log("Failed to parse rewind_safeguard argument");
1913 goto fail;
1914 }
1915
1916 sync_volume = m->core->sync_volume;
1917 if (pa_modargs_get_value_boolean(ma, "sync_volume", &sync_volume) < 0) {
1918 pa_log("Failed to parse sync_volume argument.");
1919 goto fail;
1920 }
1921
1922 use_tsched = pa_alsa_may_tsched(use_tsched);
1923
1924 u = pa_xnew0(struct userdata, 1);
1925 u->core = m->core;
1926 u->module = m;
1927 u->use_mmap = use_mmap;
1928 u->use_tsched = use_tsched;
1929 u->sync_volume = sync_volume;
1930 u->first = TRUE;
1931 u->rewind_safeguard = rewind_safeguard;
1932 u->rtpoll = pa_rtpoll_new();
1933 pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
1934
1935 u->smoother = pa_smoother_new(
1936 SMOOTHER_ADJUST_USEC,
1937 SMOOTHER_WINDOW_USEC,
1938 TRUE,
1939 TRUE,
1940 5,
1941 pa_rtclock_now(),
1942 TRUE);
1943 u->smoother_interval = SMOOTHER_MIN_INTERVAL;
1944
1945 dev_id = pa_modargs_get_value(
1946 ma, "device_id",
1947 pa_modargs_get_value(ma, "device", DEFAULT_DEVICE));
1948
1949 if (reserve_init(u, dev_id) < 0)
1950 goto fail;
1951
1952 if (reserve_monitor_init(u, dev_id) < 0)
1953 goto fail;
1954
1955 b = use_mmap;
1956 d = use_tsched;
1957
1958 if (mapping) {
1959
1960 if (!(dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1961 pa_log("device_id= not set");
1962 goto fail;
1963 }
1964
1965 if (!(u->pcm_handle = pa_alsa_open_by_device_id_mapping(
1966 dev_id,
1967 &u->device_name,
1968 &ss, &map,
1969 SND_PCM_STREAM_PLAYBACK,
1970 &period_frames, &buffer_frames, tsched_frames,
1971 &b, &d, mapping)))
1972 goto fail;
1973
1974 } else if ((dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1975
1976 if (!(profile_set = pa_alsa_profile_set_new(NULL, &map)))
1977 goto fail;
1978
1979 if (!(u->pcm_handle = pa_alsa_open_by_device_id_auto(
1980 dev_id,
1981 &u->device_name,
1982 &ss, &map,
1983 SND_PCM_STREAM_PLAYBACK,
1984 &period_frames, &buffer_frames, tsched_frames,
1985 &b, &d, profile_set, &mapping)))
1986 goto fail;
1987
1988 } else {
1989
1990 if (!(u->pcm_handle = pa_alsa_open_by_device_string(
1991 pa_modargs_get_value(ma, "device", DEFAULT_DEVICE),
1992 &u->device_name,
1993 &ss, &map,
1994 SND_PCM_STREAM_PLAYBACK,
1995 &period_frames, &buffer_frames, tsched_frames,
1996 &b, &d, FALSE)))
1997 goto fail;
1998 }
1999
2000 pa_assert(u->device_name);
2001 pa_log_info("Successfully opened device %s.", u->device_name);
2002
2003 if (pa_alsa_pcm_is_modem(u->pcm_handle)) {
2004 pa_log_notice("Device %s is modem, refusing further initialization.", u->device_name);
2005 goto fail;
2006 }
2007
2008 if (mapping)
2009 pa_log_info("Selected mapping '%s' (%s).", mapping->description, mapping->name);
2010
2011 if (use_mmap && !b) {
2012 pa_log_info("Device doesn't support mmap(), falling back to UNIX read/write mode.");
2013 u->use_mmap = use_mmap = FALSE;
2014 }
2015
2016 if (use_tsched && (!b || !d)) {
2017 pa_log_info("Cannot enable timer-based scheduling, falling back to sound IRQ scheduling.");
2018 u->use_tsched = use_tsched = FALSE;
2019 }
2020
2021 if (u->use_mmap)
2022 pa_log_info("Successfully enabled mmap() mode.");
2023
2024 if (u->use_tsched)
2025 pa_log_info("Successfully enabled timer-based scheduling mode.");
2026
2027 /* ALSA might tweak the sample spec, so recalculate the frame size */
2028 frame_size = pa_frame_size(&ss);
2029
2030 find_mixer(u, mapping, pa_modargs_get_value(ma, "control", NULL), ignore_dB);
2031
2032 pa_sink_new_data_init(&data);
2033 data.driver = driver;
2034 data.module = m;
2035 data.card = card;
2036 set_sink_name(&data, ma, dev_id, u->device_name, mapping);
2037
2038 /* We need to give pa_modargs_get_value_boolean() a pointer to a local
2039 * variable instead of using &data.namereg_fail directly, because
2040 * data.namereg_fail is a bitfield and taking the address of a bitfield
2041 * variable is impossible. */
2042 namereg_fail = data.namereg_fail;
2043 if (pa_modargs_get_value_boolean(ma, "namereg_fail", &namereg_fail) < 0) {
2044 pa_log("Failed to parse boolean argument namereg_fail.");
2045 pa_sink_new_data_done(&data);
2046 goto fail;
2047 }
2048 data.namereg_fail = namereg_fail;
2049
2050 pa_sink_new_data_set_sample_spec(&data, &ss);
2051 pa_sink_new_data_set_channel_map(&data, &map);
2052
2053 pa_alsa_init_proplist_pcm(m->core, data.proplist, u->pcm_handle);
2054 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->device_name);
2055 pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE, "%lu", (unsigned long) (buffer_frames * frame_size));
2056 pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE, "%lu", (unsigned long) (period_frames * frame_size));
2057 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_ACCESS_MODE, u->use_tsched ? "mmap+timer" : (u->use_mmap ? "mmap" : "serial"));
2058
2059 if (mapping) {
2060 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_NAME, mapping->name);
2061 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_DESCRIPTION, mapping->description);
2062 }
2063
2064 pa_alsa_init_description(data.proplist);
2065
2066 if (u->control_device)
2067 pa_alsa_init_proplist_ctl(data.proplist, u->control_device);
2068
2069 if (pa_modargs_get_proplist(ma, "sink_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
2070 pa_log("Invalid properties");
2071 pa_sink_new_data_done(&data);
2072 goto fail;
2073 }
2074
2075 if (u->mixer_path_set)
2076 pa_alsa_add_ports(&data.ports, u->mixer_path_set);
2077
2078 u->sink = pa_sink_new(m->core, &data, PA_SINK_HARDWARE|PA_SINK_LATENCY|(u->use_tsched ? PA_SINK_DYNAMIC_LATENCY : 0));
2079 pa_sink_new_data_done(&data);
2080
2081 if (!u->sink) {
2082 pa_log("Failed to create sink object");
2083 goto fail;
2084 }
2085
2086 if (pa_modargs_get_value_u32(ma, "sync_volume_safety_margin",
2087 &u->sink->thread_info.volume_change_safety_margin) < 0) {
2088 pa_log("Failed to parse sync_volume_safety_margin parameter");
2089 goto fail;
2090 }
2091
2092 if (pa_modargs_get_value_s32(ma, "sync_volume_extra_delay",
2093 &u->sink->thread_info.volume_change_extra_delay) < 0) {
2094 pa_log("Failed to parse sync_volume_extra_delay parameter");
2095 goto fail;
2096 }
2097
2098 u->sink->parent.process_msg = sink_process_msg;
2099 if (u->use_tsched)
2100 u->sink->update_requested_latency = sink_update_requested_latency_cb;
2101 u->sink->set_state = sink_set_state_cb;
2102 u->sink->set_port = sink_set_port_cb;
2103 u->sink->userdata = u;
2104
2105 pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
2106 pa_sink_set_rtpoll(u->sink, u->rtpoll);
2107
2108 u->frame_size = frame_size;
2109 u->fragment_size = frag_size = (size_t) (period_frames * frame_size);
2110 u->hwbuf_size = buffer_size = (size_t) (buffer_frames * frame_size);
2111 pa_cvolume_mute(&u->hardware_volume, u->sink->sample_spec.channels);
2112
2113 pa_log_info("Using %0.1f fragments of size %lu bytes (%0.2fms), buffer size is %lu bytes (%0.2fms)",
2114 (double) u->hwbuf_size / (double) u->fragment_size,
2115 (long unsigned) u->fragment_size,
2116 (double) pa_bytes_to_usec(u->fragment_size, &ss) / PA_USEC_PER_MSEC,
2117 (long unsigned) u->hwbuf_size,
2118 (double) pa_bytes_to_usec(u->hwbuf_size, &ss) / PA_USEC_PER_MSEC);
2119
2120 pa_sink_set_max_request(u->sink, u->hwbuf_size);
2121 if (pa_alsa_pcm_is_hw(u->pcm_handle))
2122 pa_sink_set_max_rewind(u->sink, u->hwbuf_size);
2123 else {
2124 pa_log_info("Disabling rewind for device %s", u->device_name);
2125 pa_sink_set_max_rewind(u->sink, 0);
2126 }
2127
2128 if (u->use_tsched) {
2129 u->tsched_watermark = pa_usec_to_bytes_round_up(pa_bytes_to_usec_round_up(tsched_watermark, &requested_ss), &u->sink->sample_spec);
2130
2131 u->watermark_inc_step = pa_usec_to_bytes(TSCHED_WATERMARK_INC_STEP_USEC, &u->sink->sample_spec);
2132 u->watermark_dec_step = pa_usec_to_bytes(TSCHED_WATERMARK_DEC_STEP_USEC, &u->sink->sample_spec);
2133
2134 u->watermark_inc_threshold = pa_usec_to_bytes_round_up(TSCHED_WATERMARK_INC_THRESHOLD_USEC, &u->sink->sample_spec);
2135 u->watermark_dec_threshold = pa_usec_to_bytes_round_up(TSCHED_WATERMARK_DEC_THRESHOLD_USEC, &u->sink->sample_spec);
2136
2137 fix_min_sleep_wakeup(u);
2138 fix_tsched_watermark(u);
2139
2140 pa_sink_set_latency_range(u->sink,
2141 0,
2142 pa_bytes_to_usec(u->hwbuf_size, &ss));
2143
2144 pa_log_info("Time scheduling watermark is %0.2fms",
2145 (double) pa_bytes_to_usec(u->tsched_watermark, &ss) / PA_USEC_PER_MSEC);
2146 } else
2147 pa_sink_set_fixed_latency(u->sink, pa_bytes_to_usec(u->hwbuf_size, &ss));
2148
2149 reserve_update(u);
2150
2151 if (update_sw_params(u) < 0)
2152 goto fail;
2153
2154 if (setup_mixer(u, ignore_dB) < 0)
2155 goto fail;
2156
2157 pa_alsa_dump(PA_LOG_DEBUG, u->pcm_handle);
2158
2159 if (!(u->thread = pa_thread_new("alsa-sink", thread_func, u))) {
2160 pa_log("Failed to create thread.");
2161 goto fail;
2162 }
2163
2164 /* Get initial mixer settings */
2165 if (data.volume_is_set) {
2166 if (u->sink->set_volume)
2167 u->sink->set_volume(u->sink);
2168 } else {
2169 if (u->sink->get_volume)
2170 u->sink->get_volume(u->sink);
2171 }
2172
2173 if (data.muted_is_set) {
2174 if (u->sink->set_mute)
2175 u->sink->set_mute(u->sink);
2176 } else {
2177 if (u->sink->get_mute)
2178 u->sink->get_mute(u->sink);
2179 }
2180
2181 if ((data.volume_is_set || data.muted_is_set) && u->sink->write_volume)
2182 u->sink->write_volume(u->sink);
2183
2184 pa_sink_put(u->sink);
2185
2186 if (profile_set)
2187 pa_alsa_profile_set_free(profile_set);
2188
2189 return u->sink;
2190
2191 fail:
2192
2193 if (u)
2194 userdata_free(u);
2195
2196 if (profile_set)
2197 pa_alsa_profile_set_free(profile_set);
2198
2199 return NULL;
2200 }
2201
2202 static void userdata_free(struct userdata *u) {
2203 pa_assert(u);
2204
2205 if (u->sink)
2206 pa_sink_unlink(u->sink);
2207
2208 if (u->thread) {
2209 pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
2210 pa_thread_free(u->thread);
2211 }
2212
2213 pa_thread_mq_done(&u->thread_mq);
2214
2215 if (u->sink)
2216 pa_sink_unref(u->sink);
2217
2218 if (u->memchunk.memblock)
2219 pa_memblock_unref(u->memchunk.memblock);
2220
2221 if (u->mixer_pd)
2222 pa_alsa_mixer_pdata_free(u->mixer_pd);
2223
2224 if (u->alsa_rtpoll_item)
2225 pa_rtpoll_item_free(u->alsa_rtpoll_item);
2226
2227 if (u->rtpoll)
2228 pa_rtpoll_free(u->rtpoll);
2229
2230 if (u->pcm_handle) {
2231 snd_pcm_drop(u->pcm_handle);
2232 snd_pcm_close(u->pcm_handle);
2233 }
2234
2235 if (u->mixer_fdl)
2236 pa_alsa_fdlist_free(u->mixer_fdl);
2237
2238 if (u->mixer_path_set)
2239 pa_alsa_path_set_free(u->mixer_path_set);
2240 else if (u->mixer_path)
2241 pa_alsa_path_free(u->mixer_path);
2242
2243 if (u->mixer_handle)
2244 snd_mixer_close(u->mixer_handle);
2245
2246 if (u->smoother)
2247 pa_smoother_free(u->smoother);
2248
2249 reserve_done(u);
2250 monitor_done(u);
2251
2252 pa_xfree(u->device_name);
2253 pa_xfree(u->control_device);
2254 pa_xfree(u);
2255 }
2256
2257 void pa_alsa_sink_free(pa_sink *s) {
2258 struct userdata *u;
2259
2260 pa_sink_assert_ref(s);
2261 pa_assert_se(u = s->userdata);
2262
2263 userdata_free(u);
2264 }