]> 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
Remove unnecessary #includes
[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/i18n.h>
36 #include <pulse/rtclock.h>
37 #include <pulse/timeval.h>
38 #include <pulse/volume.h>
39 #include <pulse/xmalloc.h>
40
41 #include <pulsecore/core.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;
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 = TRUE;
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->sink->core->mempool)/u->frame_size)
593 frames = pa_mempool_block_size_max(u->sink->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
648 if (*sleep_usec > process_usec)
649 *sleep_usec -= process_usec;
650 else
651 *sleep_usec = 0;
652 } else
653 *sleep_usec = 0;
654
655 return work_done ? 1 : 0;
656 }
657
658 static int unix_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled, pa_bool_t on_timeout) {
659 pa_bool_t work_done = FALSE;
660 pa_usec_t max_sleep_usec = 0, process_usec = 0;
661 size_t left_to_play;
662 unsigned j = 0;
663
664 pa_assert(u);
665 pa_sink_assert_ref(u->sink);
666
667 if (u->use_tsched)
668 hw_sleep_time(u, &max_sleep_usec, &process_usec);
669
670 for (;;) {
671 snd_pcm_sframes_t n;
672 size_t n_bytes;
673 int r;
674 pa_bool_t after_avail = TRUE;
675
676 if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->sink->sample_spec)) < 0)) {
677
678 if ((r = try_recover(u, "snd_pcm_avail", (int) n)) == 0)
679 continue;
680
681 return r;
682 }
683
684 n_bytes = (size_t) n * u->frame_size;
685 left_to_play = check_left_to_play(u, n_bytes, on_timeout);
686 on_timeout = FALSE;
687
688 if (u->use_tsched)
689
690 /* We won't fill up the playback buffer before at least
691 * half the sleep time is over because otherwise we might
692 * ask for more data from the clients then they expect. We
693 * need to guarantee that clients only have to keep around
694 * a single hw buffer length. */
695
696 if (!polled &&
697 pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) > process_usec+max_sleep_usec/2)
698 break;
699
700 if (PA_UNLIKELY(n_bytes <= u->hwbuf_unused)) {
701
702 if (polled)
703 PA_ONCE_BEGIN {
704 char *dn = pa_alsa_get_driver_name_by_pcm(u->pcm_handle);
705 pa_log(_("ALSA woke us up to write new data to the device, but there was actually nothing to write!\n"
706 "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
707 "We were woken up with POLLOUT set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
708 pa_strnull(dn));
709 pa_xfree(dn);
710 } PA_ONCE_END;
711
712 break;
713 }
714
715 if (++j > 10) {
716 #ifdef DEBUG_TIMING
717 pa_log_debug("Not filling up, because already too many iterations.");
718 #endif
719
720 break;
721 }
722
723 n_bytes -= u->hwbuf_unused;
724 polled = FALSE;
725
726 for (;;) {
727 snd_pcm_sframes_t frames;
728 void *p;
729
730 /* pa_log_debug("%lu frames to write", (unsigned long) frames); */
731
732 if (u->memchunk.length <= 0)
733 pa_sink_render(u->sink, n_bytes, &u->memchunk);
734
735 pa_assert(u->memchunk.length > 0);
736
737 frames = (snd_pcm_sframes_t) (u->memchunk.length / u->frame_size);
738
739 if (frames > (snd_pcm_sframes_t) (n_bytes/u->frame_size))
740 frames = (snd_pcm_sframes_t) (n_bytes/u->frame_size);
741
742 p = pa_memblock_acquire(u->memchunk.memblock);
743 frames = snd_pcm_writei(u->pcm_handle, (const uint8_t*) p + u->memchunk.index, (snd_pcm_uframes_t) frames);
744 pa_memblock_release(u->memchunk.memblock);
745
746 if (PA_UNLIKELY(frames < 0)) {
747
748 if (!after_avail && (int) frames == -EAGAIN)
749 break;
750
751 if ((r = try_recover(u, "snd_pcm_writei", (int) frames)) == 0)
752 continue;
753
754 return r;
755 }
756
757 if (!after_avail && frames == 0)
758 break;
759
760 pa_assert(frames > 0);
761 after_avail = FALSE;
762
763 u->memchunk.index += (size_t) frames * u->frame_size;
764 u->memchunk.length -= (size_t) frames * u->frame_size;
765
766 if (u->memchunk.length <= 0) {
767 pa_memblock_unref(u->memchunk.memblock);
768 pa_memchunk_reset(&u->memchunk);
769 }
770
771 work_done = TRUE;
772
773 u->write_count += frames * u->frame_size;
774 u->since_start += frames * u->frame_size;
775
776 /* pa_log_debug("wrote %lu frames", (unsigned long) frames); */
777
778 if ((size_t) frames * u->frame_size >= n_bytes)
779 break;
780
781 n_bytes -= (size_t) frames * u->frame_size;
782 }
783 }
784
785 if (u->use_tsched) {
786 *sleep_usec = pa_bytes_to_usec(left_to_play, &u->sink->sample_spec);
787
788 if (*sleep_usec > process_usec)
789 *sleep_usec -= process_usec;
790 else
791 *sleep_usec = 0;
792 } else
793 *sleep_usec = 0;
794
795 return work_done ? 1 : 0;
796 }
797
798 static void update_smoother(struct userdata *u) {
799 snd_pcm_sframes_t delay = 0;
800 int64_t position;
801 int err;
802 pa_usec_t now1 = 0, now2;
803 snd_pcm_status_t *status;
804
805 snd_pcm_status_alloca(&status);
806
807 pa_assert(u);
808 pa_assert(u->pcm_handle);
809
810 /* Let's update the time smoother */
811
812 if (PA_UNLIKELY((err = pa_alsa_safe_delay(u->pcm_handle, &delay, u->hwbuf_size, &u->sink->sample_spec, FALSE)) < 0)) {
813 pa_log_warn("Failed to query DSP status data: %s", pa_alsa_strerror(err));
814 return;
815 }
816
817 if (PA_UNLIKELY((err = snd_pcm_status(u->pcm_handle, status)) < 0))
818 pa_log_warn("Failed to get timestamp: %s", pa_alsa_strerror(err));
819 else {
820 snd_htimestamp_t htstamp = { 0, 0 };
821 snd_pcm_status_get_htstamp(status, &htstamp);
822 now1 = pa_timespec_load(&htstamp);
823 }
824
825 /* Hmm, if the timestamp is 0, then it wasn't set and we take the current time */
826 if (now1 <= 0)
827 now1 = pa_rtclock_now();
828
829 /* check if the time since the last update is bigger than the interval */
830 if (u->last_smoother_update > 0)
831 if (u->last_smoother_update + u->smoother_interval > now1)
832 return;
833
834 position = (int64_t) u->write_count - ((int64_t) delay * (int64_t) u->frame_size);
835
836 if (PA_UNLIKELY(position < 0))
837 position = 0;
838
839 now2 = pa_bytes_to_usec((uint64_t) position, &u->sink->sample_spec);
840
841 pa_smoother_put(u->smoother, now1, now2);
842
843 u->last_smoother_update = now1;
844 /* exponentially increase the update interval up to the MAX limit */
845 u->smoother_interval = PA_MIN (u->smoother_interval * 2, SMOOTHER_MAX_INTERVAL);
846 }
847
848 static pa_usec_t sink_get_latency(struct userdata *u) {
849 pa_usec_t r;
850 int64_t delay;
851 pa_usec_t now1, now2;
852
853 pa_assert(u);
854
855 now1 = pa_rtclock_now();
856 now2 = pa_smoother_get(u->smoother, now1);
857
858 delay = (int64_t) pa_bytes_to_usec(u->write_count, &u->sink->sample_spec) - (int64_t) now2;
859
860 r = delay >= 0 ? (pa_usec_t) delay : 0;
861
862 if (u->memchunk.memblock)
863 r += pa_bytes_to_usec(u->memchunk.length, &u->sink->sample_spec);
864
865 return r;
866 }
867
868 static int build_pollfd(struct userdata *u) {
869 pa_assert(u);
870 pa_assert(u->pcm_handle);
871
872 if (u->alsa_rtpoll_item)
873 pa_rtpoll_item_free(u->alsa_rtpoll_item);
874
875 if (!(u->alsa_rtpoll_item = pa_alsa_build_pollfd(u->pcm_handle, u->rtpoll)))
876 return -1;
877
878 return 0;
879 }
880
881 /* Called from IO context */
882 static int suspend(struct userdata *u) {
883 pa_assert(u);
884 pa_assert(u->pcm_handle);
885
886 pa_smoother_pause(u->smoother, pa_rtclock_now());
887
888 /* Let's suspend -- we don't call snd_pcm_drain() here since that might
889 * take awfully long with our long buffer sizes today. */
890 snd_pcm_close(u->pcm_handle);
891 u->pcm_handle = NULL;
892
893 if (u->alsa_rtpoll_item) {
894 pa_rtpoll_item_free(u->alsa_rtpoll_item);
895 u->alsa_rtpoll_item = NULL;
896 }
897
898 /* We reset max_rewind/max_request here to make sure that while we
899 * are suspended the old max_request/max_rewind values set before
900 * the suspend can influence the per-stream buffer of newly
901 * created streams, without their requirements having any
902 * influence on them. */
903 pa_sink_set_max_rewind_within_thread(u->sink, 0);
904 pa_sink_set_max_request_within_thread(u->sink, 0);
905
906 pa_log_info("Device suspended...");
907
908 return 0;
909 }
910
911 /* Called from IO context */
912 static int update_sw_params(struct userdata *u) {
913 snd_pcm_uframes_t avail_min;
914 int err;
915
916 pa_assert(u);
917
918 /* Use the full buffer if noone asked us for anything specific */
919 u->hwbuf_unused = 0;
920
921 if (u->use_tsched) {
922 pa_usec_t latency;
923
924 if ((latency = pa_sink_get_requested_latency_within_thread(u->sink)) != (pa_usec_t) -1) {
925 size_t b;
926
927 pa_log_debug("Latency set to %0.2fms", (double) latency / PA_USEC_PER_MSEC);
928
929 b = pa_usec_to_bytes(latency, &u->sink->sample_spec);
930
931 /* We need at least one sample in our buffer */
932
933 if (PA_UNLIKELY(b < u->frame_size))
934 b = u->frame_size;
935
936 u->hwbuf_unused = PA_LIKELY(b < u->hwbuf_size) ? (u->hwbuf_size - b) : 0;
937 }
938
939 fix_min_sleep_wakeup(u);
940 fix_tsched_watermark(u);
941 }
942
943 pa_log_debug("hwbuf_unused=%lu", (unsigned long) u->hwbuf_unused);
944
945 /* We need at last one frame in the used part of the buffer */
946 avail_min = (snd_pcm_uframes_t) u->hwbuf_unused / u->frame_size + 1;
947
948 if (u->use_tsched) {
949 pa_usec_t sleep_usec, process_usec;
950
951 hw_sleep_time(u, &sleep_usec, &process_usec);
952 avail_min += pa_usec_to_bytes(sleep_usec, &u->sink->sample_spec) / u->frame_size;
953 }
954
955 pa_log_debug("setting avail_min=%lu", (unsigned long) avail_min);
956
957 if ((err = pa_alsa_set_sw_params(u->pcm_handle, avail_min, !u->use_tsched)) < 0) {
958 pa_log("Failed to set software parameters: %s", pa_alsa_strerror(err));
959 return err;
960 }
961
962 pa_sink_set_max_request_within_thread(u->sink, u->hwbuf_size - u->hwbuf_unused);
963 if (pa_alsa_pcm_is_hw(u->pcm_handle))
964 pa_sink_set_max_rewind_within_thread(u->sink, u->hwbuf_size);
965 else {
966 pa_log_info("Disabling rewind_within_thread for device %s", u->device_name);
967 pa_sink_set_max_rewind_within_thread(u->sink, 0);
968 }
969
970 return 0;
971 }
972
973 /* Called from IO context */
974 static int unsuspend(struct userdata *u) {
975 pa_sample_spec ss;
976 int err;
977 pa_bool_t b, d;
978 snd_pcm_uframes_t period_size, buffer_size;
979
980 pa_assert(u);
981 pa_assert(!u->pcm_handle);
982
983 pa_log_info("Trying resume...");
984
985 if ((err = snd_pcm_open(&u->pcm_handle, u->device_name, SND_PCM_STREAM_PLAYBACK,
986 SND_PCM_NONBLOCK|
987 SND_PCM_NO_AUTO_RESAMPLE|
988 SND_PCM_NO_AUTO_CHANNELS|
989 SND_PCM_NO_AUTO_FORMAT)) < 0) {
990 pa_log("Error opening PCM device %s: %s", u->device_name, pa_alsa_strerror(err));
991 goto fail;
992 }
993
994 ss = u->sink->sample_spec;
995 period_size = u->fragment_size / u->frame_size;
996 buffer_size = u->hwbuf_size / u->frame_size;
997 b = u->use_mmap;
998 d = u->use_tsched;
999
1000 if ((err = pa_alsa_set_hw_params(u->pcm_handle, &ss, &period_size, &buffer_size, 0, &b, &d, TRUE)) < 0) {
1001 pa_log("Failed to set hardware parameters: %s", pa_alsa_strerror(err));
1002 goto fail;
1003 }
1004
1005 if (b != u->use_mmap || d != u->use_tsched) {
1006 pa_log_warn("Resume failed, couldn't get original access mode.");
1007 goto fail;
1008 }
1009
1010 if (!pa_sample_spec_equal(&ss, &u->sink->sample_spec)) {
1011 pa_log_warn("Resume failed, couldn't restore original sample settings.");
1012 goto fail;
1013 }
1014
1015 if (period_size*u->frame_size != u->fragment_size ||
1016 buffer_size*u->frame_size != u->hwbuf_size) {
1017 pa_log_warn("Resume failed, couldn't restore original fragment settings. (Old: %lu/%lu, New %lu/%lu)",
1018 (unsigned long) u->hwbuf_size, (unsigned long) u->fragment_size,
1019 (unsigned long) (buffer_size*u->frame_size), (unsigned long) (period_size*u->frame_size));
1020 goto fail;
1021 }
1022
1023 if (update_sw_params(u) < 0)
1024 goto fail;
1025
1026 if (build_pollfd(u) < 0)
1027 goto fail;
1028
1029 u->write_count = 0;
1030 pa_smoother_reset(u->smoother, pa_rtclock_now(), TRUE);
1031 u->smoother_interval = SMOOTHER_MIN_INTERVAL;
1032 u->last_smoother_update = 0;
1033
1034 u->first = TRUE;
1035 u->since_start = 0;
1036
1037 pa_log_info("Resumed successfully...");
1038
1039 return 0;
1040
1041 fail:
1042 if (u->pcm_handle) {
1043 snd_pcm_close(u->pcm_handle);
1044 u->pcm_handle = NULL;
1045 }
1046
1047 return -PA_ERR_IO;
1048 }
1049
1050 /* Called from IO context */
1051 static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
1052 struct userdata *u = PA_SINK(o)->userdata;
1053
1054 switch (code) {
1055
1056 case PA_SINK_MESSAGE_FINISH_MOVE:
1057 case PA_SINK_MESSAGE_ADD_INPUT: {
1058 pa_sink_input *i = PA_SINK_INPUT(data);
1059 int r = 0;
1060
1061 if (PA_LIKELY(!pa_sink_input_is_passthrough(i)))
1062 break;
1063
1064 u->old_rate = u->sink->sample_spec.rate;
1065
1066 /* Passthrough format, see if we need to reset sink sample rate */
1067 if (u->sink->sample_spec.rate == i->thread_info.sample_spec.rate)
1068 break;
1069
1070 /* .. we do */
1071 if ((r = suspend(u)) < 0)
1072 return r;
1073
1074 u->sink->sample_spec.rate = i->thread_info.sample_spec.rate;
1075
1076 if ((r = unsuspend(u)) < 0)
1077 return r;
1078
1079 break;
1080 }
1081
1082 case PA_SINK_MESSAGE_START_MOVE:
1083 case PA_SINK_MESSAGE_REMOVE_INPUT: {
1084 pa_sink_input *i = PA_SINK_INPUT(data);
1085 int r = 0;
1086
1087 if (PA_LIKELY(!pa_sink_input_is_passthrough(i)))
1088 break;
1089
1090 /* Passthrough format, see if we need to reset sink sample rate */
1091 if (u->sink->sample_spec.rate == u->old_rate)
1092 break;
1093
1094 /* .. we do */
1095 if ((r = suspend(u)) < 0)
1096 return r;
1097
1098 u->sink->sample_spec.rate = u->old_rate;
1099
1100 if ((r = unsuspend(u)) < 0)
1101 return r;
1102
1103 break;
1104 }
1105
1106 case PA_SINK_MESSAGE_GET_LATENCY: {
1107 pa_usec_t r = 0;
1108
1109 if (u->pcm_handle)
1110 r = sink_get_latency(u);
1111
1112 *((pa_usec_t*) data) = r;
1113
1114 return 0;
1115 }
1116
1117 case PA_SINK_MESSAGE_SET_STATE:
1118
1119 switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) {
1120
1121 case PA_SINK_SUSPENDED: {
1122 int r;
1123
1124 pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
1125
1126 if ((r = suspend(u)) < 0)
1127 return r;
1128
1129 break;
1130 }
1131
1132 case PA_SINK_IDLE:
1133 case PA_SINK_RUNNING: {
1134 int r;
1135
1136 if (u->sink->thread_info.state == PA_SINK_INIT) {
1137 if (build_pollfd(u) < 0)
1138 return -PA_ERR_IO;
1139 }
1140
1141 if (u->sink->thread_info.state == PA_SINK_SUSPENDED) {
1142 if ((r = unsuspend(u)) < 0)
1143 return r;
1144 }
1145
1146 break;
1147 }
1148
1149 case PA_SINK_UNLINKED:
1150 case PA_SINK_INIT:
1151 case PA_SINK_INVALID_STATE:
1152 ;
1153 }
1154
1155 break;
1156 }
1157
1158 return pa_sink_process_msg(o, code, data, offset, chunk);
1159 }
1160
1161 /* Called from main context */
1162 static int sink_set_state_cb(pa_sink *s, pa_sink_state_t new_state) {
1163 pa_sink_state_t old_state;
1164 struct userdata *u;
1165
1166 pa_sink_assert_ref(s);
1167 pa_assert_se(u = s->userdata);
1168
1169 old_state = pa_sink_get_state(u->sink);
1170
1171 if (PA_SINK_IS_OPENED(old_state) && new_state == PA_SINK_SUSPENDED)
1172 reserve_done(u);
1173 else if (old_state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(new_state))
1174 if (reserve_init(u, u->device_name) < 0)
1175 return -PA_ERR_BUSY;
1176
1177 return 0;
1178 }
1179
1180 static int ctl_mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) {
1181 struct userdata *u = snd_mixer_elem_get_callback_private(elem);
1182
1183 pa_assert(u);
1184 pa_assert(u->mixer_handle);
1185
1186 if (mask == SND_CTL_EVENT_MASK_REMOVE)
1187 return 0;
1188
1189 if (u->sink->suspend_cause & PA_SUSPEND_SESSION)
1190 return 0;
1191
1192 if (mask & SND_CTL_EVENT_MASK_VALUE) {
1193 pa_sink_get_volume(u->sink, TRUE);
1194 pa_sink_get_mute(u->sink, TRUE);
1195 }
1196
1197 return 0;
1198 }
1199
1200 static int io_mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) {
1201 struct userdata *u = snd_mixer_elem_get_callback_private(elem);
1202
1203 pa_assert(u);
1204 pa_assert(u->mixer_handle);
1205
1206 if (mask == SND_CTL_EVENT_MASK_REMOVE)
1207 return 0;
1208
1209 if (u->sink->suspend_cause & PA_SUSPEND_SESSION)
1210 return 0;
1211
1212 if (mask & SND_CTL_EVENT_MASK_VALUE)
1213 pa_sink_update_volume_and_mute(u->sink);
1214
1215 return 0;
1216 }
1217
1218 static void sink_get_volume_cb(pa_sink *s) {
1219 struct userdata *u = s->userdata;
1220 pa_cvolume r;
1221 char vol_str_pcnt[PA_CVOLUME_SNPRINT_MAX];
1222
1223 pa_assert(u);
1224 pa_assert(u->mixer_path);
1225 pa_assert(u->mixer_handle);
1226
1227 if (pa_alsa_path_get_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r) < 0)
1228 return;
1229
1230 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1231 pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
1232
1233 pa_log_debug("Read hardware volume: %s", pa_cvolume_snprint(vol_str_pcnt, sizeof(vol_str_pcnt), &r));
1234
1235 if (u->mixer_path->has_dB) {
1236 char vol_str_db[PA_SW_CVOLUME_SNPRINT_DB_MAX];
1237
1238 pa_log_debug(" in dB: %s", pa_sw_cvolume_snprint_dB(vol_str_db, sizeof(vol_str_db), &r));
1239 }
1240
1241 if (pa_cvolume_equal(&u->hardware_volume, &r))
1242 return;
1243
1244 s->real_volume = u->hardware_volume = r;
1245
1246 /* Hmm, so the hardware volume changed, let's reset our software volume */
1247 if (u->mixer_path->has_dB)
1248 pa_sink_set_soft_volume(s, NULL);
1249 }
1250
1251 static void sink_set_volume_cb(pa_sink *s) {
1252 struct userdata *u = s->userdata;
1253 pa_cvolume r;
1254 char vol_str_pcnt[PA_CVOLUME_SNPRINT_MAX];
1255 pa_bool_t sync_volume = !!(s->flags & PA_SINK_SYNC_VOLUME);
1256
1257 pa_assert(u);
1258 pa_assert(u->mixer_path);
1259 pa_assert(u->mixer_handle);
1260
1261 /* Shift up by the base volume */
1262 pa_sw_cvolume_divide_scalar(&r, &s->real_volume, s->base_volume);
1263
1264 if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r, sync_volume, !sync_volume) < 0)
1265 return;
1266
1267 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1268 pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
1269
1270 u->hardware_volume = r;
1271
1272 if (u->mixer_path->has_dB) {
1273 pa_cvolume new_soft_volume;
1274 pa_bool_t accurate_enough;
1275 char vol_str_db[PA_SW_CVOLUME_SNPRINT_DB_MAX];
1276
1277 /* Match exactly what the user requested by software */
1278 pa_sw_cvolume_divide(&new_soft_volume, &s->real_volume, &u->hardware_volume);
1279
1280 /* If the adjustment to do in software is only minimal we
1281 * can skip it. That saves us CPU at the expense of a bit of
1282 * accuracy */
1283 accurate_enough =
1284 (pa_cvolume_min(&new_soft_volume) >= (PA_VOLUME_NORM - VOLUME_ACCURACY)) &&
1285 (pa_cvolume_max(&new_soft_volume) <= (PA_VOLUME_NORM + VOLUME_ACCURACY));
1286
1287 pa_log_debug("Requested volume: %s", pa_cvolume_snprint(vol_str_pcnt, sizeof(vol_str_pcnt), &s->real_volume));
1288 pa_log_debug(" in dB: %s", pa_sw_cvolume_snprint_dB(vol_str_db, sizeof(vol_str_db), &s->real_volume));
1289 pa_log_debug("Got hardware volume: %s", pa_cvolume_snprint(vol_str_pcnt, sizeof(vol_str_pcnt), &u->hardware_volume));
1290 pa_log_debug(" in dB: %s", pa_sw_cvolume_snprint_dB(vol_str_db, sizeof(vol_str_db), &u->hardware_volume));
1291 pa_log_debug("Calculated software volume: %s (accurate-enough=%s)",
1292 pa_cvolume_snprint(vol_str_pcnt, sizeof(vol_str_pcnt), &new_soft_volume),
1293 pa_yes_no(accurate_enough));
1294 pa_log_debug(" in dB: %s", pa_sw_cvolume_snprint_dB(vol_str_db, sizeof(vol_str_db), &new_soft_volume));
1295
1296 if (!accurate_enough)
1297 s->soft_volume = new_soft_volume;
1298
1299 } else {
1300 pa_log_debug("Wrote hardware volume: %s", pa_cvolume_snprint(vol_str_pcnt, sizeof(vol_str_pcnt), &r));
1301
1302 /* We can't match exactly what the user requested, hence let's
1303 * at least tell the user about it */
1304
1305 s->real_volume = r;
1306 }
1307 }
1308
1309 static void sink_write_volume_cb(pa_sink *s) {
1310 struct userdata *u = s->userdata;
1311 pa_cvolume hw_vol = s->thread_info.current_hw_volume;
1312
1313 pa_assert(u);
1314 pa_assert(u->mixer_path);
1315 pa_assert(u->mixer_handle);
1316 pa_assert(s->flags & PA_SINK_SYNC_VOLUME);
1317
1318 /* Shift up by the base volume */
1319 pa_sw_cvolume_divide_scalar(&hw_vol, &hw_vol, s->base_volume);
1320
1321 if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &hw_vol, TRUE, TRUE) < 0)
1322 pa_log_error("Writing HW volume failed");
1323 else {
1324 pa_cvolume tmp_vol;
1325 pa_bool_t accurate_enough;
1326
1327 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1328 pa_sw_cvolume_multiply_scalar(&hw_vol, &hw_vol, s->base_volume);
1329
1330 pa_sw_cvolume_divide(&tmp_vol, &hw_vol, &s->thread_info.current_hw_volume);
1331 accurate_enough =
1332 (pa_cvolume_min(&tmp_vol) >= (PA_VOLUME_NORM - VOLUME_ACCURACY)) &&
1333 (pa_cvolume_max(&tmp_vol) <= (PA_VOLUME_NORM + VOLUME_ACCURACY));
1334
1335 if (!accurate_enough) {
1336 union {
1337 char db[2][PA_SW_CVOLUME_SNPRINT_DB_MAX];
1338 char pcnt[2][PA_CVOLUME_SNPRINT_MAX];
1339 } vol;
1340
1341 pa_log_debug("Written HW volume did not match with the request: %s (request) != %s",
1342 pa_cvolume_snprint(vol.pcnt[0], sizeof(vol.pcnt[0]), &s->thread_info.current_hw_volume),
1343 pa_cvolume_snprint(vol.pcnt[1], sizeof(vol.pcnt[1]), &hw_vol));
1344 pa_log_debug(" in dB: %s (request) != %s",
1345 pa_sw_cvolume_snprint_dB(vol.db[0], sizeof(vol.db[0]), &s->thread_info.current_hw_volume),
1346 pa_sw_cvolume_snprint_dB(vol.db[1], sizeof(vol.db[1]), &hw_vol));
1347 }
1348 }
1349 }
1350
1351 static void sink_get_mute_cb(pa_sink *s) {
1352 struct userdata *u = s->userdata;
1353 pa_bool_t b;
1354
1355 pa_assert(u);
1356 pa_assert(u->mixer_path);
1357 pa_assert(u->mixer_handle);
1358
1359 if (pa_alsa_path_get_mute(u->mixer_path, u->mixer_handle, &b) < 0)
1360 return;
1361
1362 s->muted = b;
1363 }
1364
1365 static void sink_set_mute_cb(pa_sink *s) {
1366 struct userdata *u = s->userdata;
1367
1368 pa_assert(u);
1369 pa_assert(u->mixer_path);
1370 pa_assert(u->mixer_handle);
1371
1372 pa_alsa_path_set_mute(u->mixer_path, u->mixer_handle, s->muted);
1373 }
1374
1375 static int sink_set_port_cb(pa_sink *s, pa_device_port *p) {
1376 struct userdata *u = s->userdata;
1377 pa_alsa_port_data *data;
1378
1379 pa_assert(u);
1380 pa_assert(p);
1381 pa_assert(u->mixer_handle);
1382
1383 data = PA_DEVICE_PORT_DATA(p);
1384
1385 pa_assert_se(u->mixer_path = data->path);
1386 pa_alsa_path_select(u->mixer_path, u->mixer_handle);
1387
1388 if (u->mixer_path->has_volume && u->mixer_path->has_dB) {
1389 s->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
1390 s->n_volume_steps = PA_VOLUME_NORM+1;
1391
1392 pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(s->base_volume));
1393 } else {
1394 s->base_volume = PA_VOLUME_NORM;
1395 s->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1;
1396 }
1397
1398 if (data->setting)
1399 pa_alsa_setting_select(data->setting, u->mixer_handle);
1400
1401 if (s->set_mute)
1402 s->set_mute(s);
1403 if (s->set_volume)
1404 s->set_volume(s);
1405
1406 return 0;
1407 }
1408
1409 static void sink_update_requested_latency_cb(pa_sink *s) {
1410 struct userdata *u = s->userdata;
1411 size_t before;
1412 pa_assert(u);
1413 pa_assert(u->use_tsched); /* only when timer scheduling is used
1414 * we can dynamically adjust the
1415 * latency */
1416
1417 if (!u->pcm_handle)
1418 return;
1419
1420 before = u->hwbuf_unused;
1421 update_sw_params(u);
1422
1423 /* Let's check whether we now use only a smaller part of the
1424 buffer then before. If so, we need to make sure that subsequent
1425 rewinds are relative to the new maximum fill level and not to the
1426 current fill level. Thus, let's do a full rewind once, to clear
1427 things up. */
1428
1429 if (u->hwbuf_unused > before) {
1430 pa_log_debug("Requesting rewind due to latency change.");
1431 pa_sink_request_rewind(s, (size_t) -1);
1432 }
1433 }
1434
1435 static int process_rewind(struct userdata *u) {
1436 snd_pcm_sframes_t unused;
1437 size_t rewind_nbytes, unused_nbytes, limit_nbytes;
1438 pa_assert(u);
1439
1440 /* Figure out how much we shall rewind and reset the counter */
1441 rewind_nbytes = u->sink->thread_info.rewind_nbytes;
1442
1443 pa_log_debug("Requested to rewind %lu bytes.", (unsigned long) rewind_nbytes);
1444
1445 if (PA_UNLIKELY((unused = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->sink->sample_spec)) < 0)) {
1446 pa_log("snd_pcm_avail() failed: %s", pa_alsa_strerror((int) unused));
1447 return -1;
1448 }
1449
1450 unused_nbytes = (size_t) unused * u->frame_size;
1451
1452 /* make sure rewind doesn't go too far, can cause issues with DMAs */
1453 unused_nbytes += u->rewind_safeguard;
1454
1455 if (u->hwbuf_size > unused_nbytes)
1456 limit_nbytes = u->hwbuf_size - unused_nbytes;
1457 else
1458 limit_nbytes = 0;
1459
1460 if (rewind_nbytes > limit_nbytes)
1461 rewind_nbytes = limit_nbytes;
1462
1463 if (rewind_nbytes > 0) {
1464 snd_pcm_sframes_t in_frames, out_frames;
1465
1466 pa_log_debug("Limited to %lu bytes.", (unsigned long) rewind_nbytes);
1467
1468 in_frames = (snd_pcm_sframes_t) (rewind_nbytes / u->frame_size);
1469 pa_log_debug("before: %lu", (unsigned long) in_frames);
1470 if ((out_frames = snd_pcm_rewind(u->pcm_handle, (snd_pcm_uframes_t) in_frames)) < 0) {
1471 pa_log("snd_pcm_rewind() failed: %s", pa_alsa_strerror((int) out_frames));
1472 if (try_recover(u, "process_rewind", out_frames) < 0)
1473 return -1;
1474 out_frames = 0;
1475 }
1476
1477 pa_log_debug("after: %lu", (unsigned long) out_frames);
1478
1479 rewind_nbytes = (size_t) out_frames * u->frame_size;
1480
1481 if (rewind_nbytes <= 0)
1482 pa_log_info("Tried rewind, but was apparently not possible.");
1483 else {
1484 u->write_count -= rewind_nbytes;
1485 pa_log_debug("Rewound %lu bytes.", (unsigned long) rewind_nbytes);
1486 pa_sink_process_rewind(u->sink, rewind_nbytes);
1487
1488 u->after_rewind = TRUE;
1489 return 0;
1490 }
1491 } else
1492 pa_log_debug("Mhmm, actually there is nothing to rewind.");
1493
1494 pa_sink_process_rewind(u->sink, 0);
1495 return 0;
1496 }
1497
1498 static void thread_func(void *userdata) {
1499 struct userdata *u = userdata;
1500 unsigned short revents = 0;
1501
1502 pa_assert(u);
1503
1504 pa_log_debug("Thread starting up");
1505
1506 if (u->core->realtime_scheduling)
1507 pa_make_realtime(u->core->realtime_priority);
1508
1509 pa_thread_mq_install(&u->thread_mq);
1510
1511 for (;;) {
1512 int ret;
1513 pa_usec_t rtpoll_sleep = 0;
1514
1515 #ifdef DEBUG_TIMING
1516 pa_log_debug("Loop");
1517 #endif
1518
1519 /* Render some data and write it to the dsp */
1520 if (PA_SINK_IS_OPENED(u->sink->thread_info.state)) {
1521 int work_done;
1522 pa_usec_t sleep_usec = 0;
1523 pa_bool_t on_timeout = pa_rtpoll_timer_elapsed(u->rtpoll);
1524
1525 if (PA_UNLIKELY(u->sink->thread_info.rewind_requested))
1526 if (process_rewind(u) < 0)
1527 goto fail;
1528
1529 if (u->use_mmap)
1530 work_done = mmap_write(u, &sleep_usec, revents & POLLOUT, on_timeout);
1531 else
1532 work_done = unix_write(u, &sleep_usec, revents & POLLOUT, on_timeout);
1533
1534 if (work_done < 0)
1535 goto fail;
1536
1537 /* pa_log_debug("work_done = %i", work_done); */
1538
1539 if (work_done) {
1540
1541 if (u->first) {
1542 pa_log_info("Starting playback.");
1543 snd_pcm_start(u->pcm_handle);
1544
1545 pa_smoother_resume(u->smoother, pa_rtclock_now(), TRUE);
1546
1547 u->first = FALSE;
1548 }
1549
1550 update_smoother(u);
1551 }
1552
1553 if (u->use_tsched) {
1554 pa_usec_t cusec;
1555
1556 if (u->since_start <= u->hwbuf_size) {
1557
1558 /* USB devices on ALSA seem to hit a buffer
1559 * underrun during the first iterations much
1560 * quicker then we calculate here, probably due to
1561 * the transport latency. To accommodate for that
1562 * we artificially decrease the sleep time until
1563 * we have filled the buffer at least once
1564 * completely.*/
1565
1566 if (pa_log_ratelimit(PA_LOG_DEBUG))
1567 pa_log_debug("Cutting sleep time for the initial iterations by half.");
1568 sleep_usec /= 2;
1569 }
1570
1571 /* OK, the playback buffer is now full, let's
1572 * calculate when to wake up next */
1573 /* pa_log_debug("Waking up in %0.2fms (sound card clock).", (double) sleep_usec / PA_USEC_PER_MSEC); */
1574
1575 /* Convert from the sound card time domain to the
1576 * system time domain */
1577 cusec = pa_smoother_translate(u->smoother, pa_rtclock_now(), sleep_usec);
1578
1579 /* pa_log_debug("Waking up in %0.2fms (system clock).", (double) cusec / PA_USEC_PER_MSEC); */
1580
1581 /* We don't trust the conversion, so we wake up whatever comes first */
1582 rtpoll_sleep = PA_MIN(sleep_usec, cusec);
1583 }
1584
1585 u->after_rewind = FALSE;
1586
1587 }
1588
1589 if (u->sink->flags & PA_SINK_SYNC_VOLUME) {
1590 pa_usec_t volume_sleep;
1591 pa_sink_volume_change_apply(u->sink, &volume_sleep);
1592 if (volume_sleep > 0)
1593 rtpoll_sleep = PA_MIN(volume_sleep, rtpoll_sleep);
1594 }
1595
1596 if (rtpoll_sleep > 0)
1597 pa_rtpoll_set_timer_relative(u->rtpoll, rtpoll_sleep);
1598 else
1599 pa_rtpoll_set_timer_disabled(u->rtpoll);
1600
1601 /* Hmm, nothing to do. Let's sleep */
1602 if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
1603 goto fail;
1604
1605 if (u->sink->flags & PA_SINK_SYNC_VOLUME)
1606 pa_sink_volume_change_apply(u->sink, NULL);
1607
1608 if (ret == 0)
1609 goto finish;
1610
1611 /* Tell ALSA about this and process its response */
1612 if (PA_SINK_IS_OPENED(u->sink->thread_info.state)) {
1613 struct pollfd *pollfd;
1614 int err;
1615 unsigned n;
1616
1617 pollfd = pa_rtpoll_item_get_pollfd(u->alsa_rtpoll_item, &n);
1618
1619 if ((err = snd_pcm_poll_descriptors_revents(u->pcm_handle, pollfd, n, &revents)) < 0) {
1620 pa_log("snd_pcm_poll_descriptors_revents() failed: %s", pa_alsa_strerror(err));
1621 goto fail;
1622 }
1623
1624 if (revents & ~POLLOUT) {
1625 if (pa_alsa_recover_from_poll(u->pcm_handle, revents) < 0)
1626 goto fail;
1627
1628 u->first = TRUE;
1629 u->since_start = 0;
1630 } else if (revents && u->use_tsched && pa_log_ratelimit(PA_LOG_DEBUG))
1631 pa_log_debug("Wakeup from ALSA!");
1632
1633 } else
1634 revents = 0;
1635 }
1636
1637 fail:
1638 /* If this was no regular exit from the loop we have to continue
1639 * processing messages until we received PA_MESSAGE_SHUTDOWN */
1640 pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
1641 pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
1642
1643 finish:
1644 pa_log_debug("Thread shutting down");
1645 }
1646
1647 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) {
1648 const char *n;
1649 char *t;
1650
1651 pa_assert(data);
1652 pa_assert(ma);
1653 pa_assert(device_name);
1654
1655 if ((n = pa_modargs_get_value(ma, "sink_name", NULL))) {
1656 pa_sink_new_data_set_name(data, n);
1657 data->namereg_fail = TRUE;
1658 return;
1659 }
1660
1661 if ((n = pa_modargs_get_value(ma, "name", NULL)))
1662 data->namereg_fail = TRUE;
1663 else {
1664 n = device_id ? device_id : device_name;
1665 data->namereg_fail = FALSE;
1666 }
1667
1668 if (mapping)
1669 t = pa_sprintf_malloc("alsa_output.%s.%s", n, mapping->name);
1670 else
1671 t = pa_sprintf_malloc("alsa_output.%s", n);
1672
1673 pa_sink_new_data_set_name(data, t);
1674 pa_xfree(t);
1675 }
1676
1677 static void find_mixer(struct userdata *u, pa_alsa_mapping *mapping, const char *element, pa_bool_t ignore_dB) {
1678
1679 if (!mapping && !element)
1680 return;
1681
1682 if (!(u->mixer_handle = pa_alsa_open_mixer_for_pcm(u->pcm_handle, &u->control_device))) {
1683 pa_log_info("Failed to find a working mixer device.");
1684 return;
1685 }
1686
1687 if (element) {
1688
1689 if (!(u->mixer_path = pa_alsa_path_synthesize(element, PA_ALSA_DIRECTION_OUTPUT)))
1690 goto fail;
1691
1692 if (pa_alsa_path_probe(u->mixer_path, u->mixer_handle, ignore_dB) < 0)
1693 goto fail;
1694
1695 pa_log_debug("Probed mixer path %s:", u->mixer_path->name);
1696 pa_alsa_path_dump(u->mixer_path);
1697 } else {
1698
1699 if (!(u->mixer_path_set = pa_alsa_path_set_new(mapping, PA_ALSA_DIRECTION_OUTPUT)))
1700 goto fail;
1701
1702 pa_alsa_path_set_probe(u->mixer_path_set, u->mixer_handle, ignore_dB);
1703
1704 pa_log_debug("Probed mixer paths:");
1705 pa_alsa_path_set_dump(u->mixer_path_set);
1706 }
1707
1708 return;
1709
1710 fail:
1711
1712 if (u->mixer_path_set) {
1713 pa_alsa_path_set_free(u->mixer_path_set);
1714 u->mixer_path_set = NULL;
1715 } else if (u->mixer_path) {
1716 pa_alsa_path_free(u->mixer_path);
1717 u->mixer_path = NULL;
1718 }
1719
1720 if (u->mixer_handle) {
1721 snd_mixer_close(u->mixer_handle);
1722 u->mixer_handle = NULL;
1723 }
1724 }
1725
1726 static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB, pa_bool_t sync_volume) {
1727 pa_assert(u);
1728
1729 if (!u->mixer_handle)
1730 return 0;
1731
1732 if (u->sink->active_port) {
1733 pa_alsa_port_data *data;
1734
1735 /* We have a list of supported paths, so let's activate the
1736 * one that has been chosen as active */
1737
1738 data = PA_DEVICE_PORT_DATA(u->sink->active_port);
1739 u->mixer_path = data->path;
1740
1741 pa_alsa_path_select(data->path, u->mixer_handle);
1742
1743 if (data->setting)
1744 pa_alsa_setting_select(data->setting, u->mixer_handle);
1745
1746 } else {
1747
1748 if (!u->mixer_path && u->mixer_path_set)
1749 u->mixer_path = u->mixer_path_set->paths;
1750
1751 if (u->mixer_path) {
1752 /* Hmm, we have only a single path, then let's activate it */
1753
1754 pa_alsa_path_select(u->mixer_path, u->mixer_handle);
1755
1756 if (u->mixer_path->settings)
1757 pa_alsa_setting_select(u->mixer_path->settings, u->mixer_handle);
1758 } else
1759 return 0;
1760 }
1761
1762 if (!u->mixer_path->has_volume)
1763 pa_log_info("Driver does not support hardware volume control, falling back to software volume control.");
1764 else {
1765
1766 if (u->mixer_path->has_dB) {
1767 pa_log_info("Hardware volume ranges from %0.2f dB to %0.2f dB.", u->mixer_path->min_dB, u->mixer_path->max_dB);
1768
1769 u->sink->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
1770 u->sink->n_volume_steps = PA_VOLUME_NORM+1;
1771
1772 pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(u->sink->base_volume));
1773
1774 } else {
1775 pa_log_info("Hardware volume ranges from %li to %li.", u->mixer_path->min_volume, u->mixer_path->max_volume);
1776 u->sink->base_volume = PA_VOLUME_NORM;
1777 u->sink->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1;
1778 }
1779
1780 u->sink->get_volume = sink_get_volume_cb;
1781 u->sink->set_volume = sink_set_volume_cb;
1782 u->sink->write_volume = sink_write_volume_cb;
1783
1784 u->sink->flags |= PA_SINK_HW_VOLUME_CTRL;
1785 if (u->mixer_path->has_dB) {
1786 u->sink->flags |= PA_SINK_DECIBEL_VOLUME;
1787 if (sync_volume) {
1788 u->sink->flags |= PA_SINK_SYNC_VOLUME;
1789 pa_log_info("Successfully enabled synchronous volume.");
1790 }
1791 }
1792
1793 pa_log_info("Using hardware volume control. Hardware dB scale %s.", u->mixer_path->has_dB ? "supported" : "not supported");
1794 }
1795
1796 if (!u->mixer_path->has_mute) {
1797 pa_log_info("Driver does not support hardware mute control, falling back to software mute control.");
1798 } else {
1799 u->sink->get_mute = sink_get_mute_cb;
1800 u->sink->set_mute = sink_set_mute_cb;
1801 u->sink->flags |= PA_SINK_HW_MUTE_CTRL;
1802 pa_log_info("Using hardware mute control.");
1803 }
1804
1805 if (u->sink->flags & (PA_SINK_HW_VOLUME_CTRL|PA_SINK_HW_MUTE_CTRL)) {
1806 int (*mixer_callback)(snd_mixer_elem_t *, unsigned int);
1807 if (u->sink->flags & PA_SINK_SYNC_VOLUME) {
1808 u->mixer_pd = pa_alsa_mixer_pdata_new();
1809 mixer_callback = io_mixer_callback;
1810
1811 if (pa_alsa_set_mixer_rtpoll(u->mixer_pd, u->mixer_handle, u->rtpoll) < 0) {
1812 pa_log("Failed to initialize file descriptor monitoring");
1813 return -1;
1814 }
1815 } else {
1816 u->mixer_fdl = pa_alsa_fdlist_new();
1817 mixer_callback = ctl_mixer_callback;
1818
1819 if (pa_alsa_fdlist_set_mixer(u->mixer_fdl, u->mixer_handle, u->core->mainloop) < 0) {
1820 pa_log("Failed to initialize file descriptor monitoring");
1821 return -1;
1822 }
1823 }
1824
1825 if (u->mixer_path_set)
1826 pa_alsa_path_set_set_callback(u->mixer_path_set, u->mixer_handle, mixer_callback, u);
1827 else
1828 pa_alsa_path_set_callback(u->mixer_path, u->mixer_handle, mixer_callback, u);
1829 }
1830
1831 return 0;
1832 }
1833
1834 pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_card *card, pa_alsa_mapping *mapping) {
1835
1836 struct userdata *u = NULL;
1837 const char *dev_id = NULL;
1838 pa_sample_spec ss, requested_ss;
1839 pa_channel_map map;
1840 uint32_t nfrags, frag_size, buffer_size, tsched_size, tsched_watermark, rewind_safeguard;
1841 snd_pcm_uframes_t period_frames, buffer_frames, tsched_frames;
1842 size_t frame_size;
1843 pa_bool_t use_mmap = TRUE, b, use_tsched = TRUE, d, ignore_dB = FALSE, namereg_fail = FALSE, sync_volume = FALSE;
1844 pa_sink_new_data data;
1845 pa_alsa_profile_set *profile_set = NULL;
1846
1847 pa_assert(m);
1848 pa_assert(ma);
1849
1850 ss = m->core->default_sample_spec;
1851 map = m->core->default_channel_map;
1852 if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_ALSA) < 0) {
1853 pa_log("Failed to parse sample specification and channel map");
1854 goto fail;
1855 }
1856
1857 requested_ss = ss;
1858 frame_size = pa_frame_size(&ss);
1859
1860 nfrags = m->core->default_n_fragments;
1861 frag_size = (uint32_t) pa_usec_to_bytes(m->core->default_fragment_size_msec*PA_USEC_PER_MSEC, &ss);
1862 if (frag_size <= 0)
1863 frag_size = (uint32_t) frame_size;
1864 tsched_size = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_BUFFER_USEC, &ss);
1865 tsched_watermark = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_WATERMARK_USEC, &ss);
1866
1867 if (pa_modargs_get_value_u32(ma, "fragments", &nfrags) < 0 ||
1868 pa_modargs_get_value_u32(ma, "fragment_size", &frag_size) < 0 ||
1869 pa_modargs_get_value_u32(ma, "tsched_buffer_size", &tsched_size) < 0 ||
1870 pa_modargs_get_value_u32(ma, "tsched_buffer_watermark", &tsched_watermark) < 0) {
1871 pa_log("Failed to parse buffer metrics");
1872 goto fail;
1873 }
1874
1875 buffer_size = nfrags * frag_size;
1876
1877 period_frames = frag_size/frame_size;
1878 buffer_frames = buffer_size/frame_size;
1879 tsched_frames = tsched_size/frame_size;
1880
1881 if (pa_modargs_get_value_boolean(ma, "mmap", &use_mmap) < 0) {
1882 pa_log("Failed to parse mmap argument.");
1883 goto fail;
1884 }
1885
1886 if (pa_modargs_get_value_boolean(ma, "tsched", &use_tsched) < 0) {
1887 pa_log("Failed to parse tsched argument.");
1888 goto fail;
1889 }
1890
1891 if (pa_modargs_get_value_boolean(ma, "ignore_dB", &ignore_dB) < 0) {
1892 pa_log("Failed to parse ignore_dB argument.");
1893 goto fail;
1894 }
1895
1896 rewind_safeguard = PA_MAX(DEFAULT_REWIND_SAFEGUARD_BYTES, pa_usec_to_bytes(DEFAULT_REWIND_SAFEGUARD_USEC, &ss));
1897 if (pa_modargs_get_value_u32(ma, "rewind_safeguard", &rewind_safeguard) < 0) {
1898 pa_log("Failed to parse rewind_safeguard argument");
1899 goto fail;
1900 }
1901
1902 sync_volume = m->core->sync_volume;
1903 if (pa_modargs_get_value_boolean(ma, "sync_volume", &sync_volume) < 0) {
1904 pa_log("Failed to parse sync_volume argument.");
1905 goto fail;
1906 }
1907
1908 use_tsched = pa_alsa_may_tsched(use_tsched);
1909
1910 u = pa_xnew0(struct userdata, 1);
1911 u->core = m->core;
1912 u->module = m;
1913 u->use_mmap = use_mmap;
1914 u->use_tsched = use_tsched;
1915 u->first = TRUE;
1916 u->rewind_safeguard = rewind_safeguard;
1917 u->rtpoll = pa_rtpoll_new();
1918 pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
1919
1920 u->smoother = pa_smoother_new(
1921 SMOOTHER_ADJUST_USEC,
1922 SMOOTHER_WINDOW_USEC,
1923 TRUE,
1924 TRUE,
1925 5,
1926 pa_rtclock_now(),
1927 TRUE);
1928 u->smoother_interval = SMOOTHER_MIN_INTERVAL;
1929
1930 dev_id = pa_modargs_get_value(
1931 ma, "device_id",
1932 pa_modargs_get_value(ma, "device", DEFAULT_DEVICE));
1933
1934 if (reserve_init(u, dev_id) < 0)
1935 goto fail;
1936
1937 if (reserve_monitor_init(u, dev_id) < 0)
1938 goto fail;
1939
1940 b = use_mmap;
1941 d = use_tsched;
1942
1943 if (mapping) {
1944
1945 if (!(dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1946 pa_log("device_id= not set");
1947 goto fail;
1948 }
1949
1950 if (!(u->pcm_handle = pa_alsa_open_by_device_id_mapping(
1951 dev_id,
1952 &u->device_name,
1953 &ss, &map,
1954 SND_PCM_STREAM_PLAYBACK,
1955 &period_frames, &buffer_frames, tsched_frames,
1956 &b, &d, mapping)))
1957 goto fail;
1958
1959 } else if ((dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1960
1961 if (!(profile_set = pa_alsa_profile_set_new(NULL, &map)))
1962 goto fail;
1963
1964 if (!(u->pcm_handle = pa_alsa_open_by_device_id_auto(
1965 dev_id,
1966 &u->device_name,
1967 &ss, &map,
1968 SND_PCM_STREAM_PLAYBACK,
1969 &period_frames, &buffer_frames, tsched_frames,
1970 &b, &d, profile_set, &mapping)))
1971 goto fail;
1972
1973 } else {
1974
1975 if (!(u->pcm_handle = pa_alsa_open_by_device_string(
1976 pa_modargs_get_value(ma, "device", DEFAULT_DEVICE),
1977 &u->device_name,
1978 &ss, &map,
1979 SND_PCM_STREAM_PLAYBACK,
1980 &period_frames, &buffer_frames, tsched_frames,
1981 &b, &d, FALSE)))
1982 goto fail;
1983 }
1984
1985 pa_assert(u->device_name);
1986 pa_log_info("Successfully opened device %s.", u->device_name);
1987
1988 if (pa_alsa_pcm_is_modem(u->pcm_handle)) {
1989 pa_log_notice("Device %s is modem, refusing further initialization.", u->device_name);
1990 goto fail;
1991 }
1992
1993 if (mapping)
1994 pa_log_info("Selected mapping '%s' (%s).", mapping->description, mapping->name);
1995
1996 if (use_mmap && !b) {
1997 pa_log_info("Device doesn't support mmap(), falling back to UNIX read/write mode.");
1998 u->use_mmap = use_mmap = FALSE;
1999 }
2000
2001 if (use_tsched && (!b || !d)) {
2002 pa_log_info("Cannot enable timer-based scheduling, falling back to sound IRQ scheduling.");
2003 u->use_tsched = use_tsched = FALSE;
2004 }
2005
2006 if (u->use_mmap)
2007 pa_log_info("Successfully enabled mmap() mode.");
2008
2009 if (u->use_tsched)
2010 pa_log_info("Successfully enabled timer-based scheduling mode.");
2011
2012 /* ALSA might tweak the sample spec, so recalculate the frame size */
2013 frame_size = pa_frame_size(&ss);
2014
2015 find_mixer(u, mapping, pa_modargs_get_value(ma, "control", NULL), ignore_dB);
2016
2017 pa_sink_new_data_init(&data);
2018 data.driver = driver;
2019 data.module = m;
2020 data.card = card;
2021 set_sink_name(&data, ma, dev_id, u->device_name, mapping);
2022
2023 /* We need to give pa_modargs_get_value_boolean() a pointer to a local
2024 * variable instead of using &data.namereg_fail directly, because
2025 * data.namereg_fail is a bitfield and taking the address of a bitfield
2026 * variable is impossible. */
2027 namereg_fail = data.namereg_fail;
2028 if (pa_modargs_get_value_boolean(ma, "namereg_fail", &namereg_fail) < 0) {
2029 pa_log("Failed to parse boolean argument namereg_fail.");
2030 pa_sink_new_data_done(&data);
2031 goto fail;
2032 }
2033 data.namereg_fail = namereg_fail;
2034
2035 pa_sink_new_data_set_sample_spec(&data, &ss);
2036 pa_sink_new_data_set_channel_map(&data, &map);
2037
2038 pa_alsa_init_proplist_pcm(m->core, data.proplist, u->pcm_handle);
2039 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->device_name);
2040 pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE, "%lu", (unsigned long) (buffer_frames * frame_size));
2041 pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE, "%lu", (unsigned long) (period_frames * frame_size));
2042 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_ACCESS_MODE, u->use_tsched ? "mmap+timer" : (u->use_mmap ? "mmap" : "serial"));
2043
2044 if (mapping) {
2045 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_NAME, mapping->name);
2046 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_DESCRIPTION, mapping->description);
2047 }
2048
2049 pa_alsa_init_description(data.proplist);
2050
2051 if (u->control_device)
2052 pa_alsa_init_proplist_ctl(data.proplist, u->control_device);
2053
2054 if (pa_modargs_get_proplist(ma, "sink_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
2055 pa_log("Invalid properties");
2056 pa_sink_new_data_done(&data);
2057 goto fail;
2058 }
2059
2060 if (u->mixer_path_set)
2061 pa_alsa_add_ports(&data.ports, u->mixer_path_set);
2062
2063 u->sink = pa_sink_new(m->core, &data, PA_SINK_HARDWARE|PA_SINK_LATENCY|(u->use_tsched ? PA_SINK_DYNAMIC_LATENCY : 0));
2064 pa_sink_new_data_done(&data);
2065
2066 if (!u->sink) {
2067 pa_log("Failed to create sink object");
2068 goto fail;
2069 }
2070
2071 if (pa_modargs_get_value_u32(ma, "sync_volume_safety_margin",
2072 &u->sink->thread_info.volume_change_safety_margin) < 0) {
2073 pa_log("Failed to parse sync_volume_safety_margin parameter");
2074 goto fail;
2075 }
2076
2077 if (pa_modargs_get_value_s32(ma, "sync_volume_extra_delay",
2078 &u->sink->thread_info.volume_change_extra_delay) < 0) {
2079 pa_log("Failed to parse sync_volume_extra_delay parameter");
2080 goto fail;
2081 }
2082
2083 u->sink->parent.process_msg = sink_process_msg;
2084 if (u->use_tsched)
2085 u->sink->update_requested_latency = sink_update_requested_latency_cb;
2086 u->sink->set_state = sink_set_state_cb;
2087 u->sink->set_port = sink_set_port_cb;
2088 u->sink->userdata = u;
2089
2090 pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
2091 pa_sink_set_rtpoll(u->sink, u->rtpoll);
2092
2093 u->frame_size = frame_size;
2094 u->fragment_size = frag_size = (size_t) (period_frames * frame_size);
2095 u->hwbuf_size = buffer_size = (size_t) (buffer_frames * frame_size);
2096 pa_cvolume_mute(&u->hardware_volume, u->sink->sample_spec.channels);
2097
2098 pa_log_info("Using %0.1f fragments of size %lu bytes (%0.2fms), buffer size is %lu bytes (%0.2fms)",
2099 (double) u->hwbuf_size / (double) u->fragment_size,
2100 (long unsigned) u->fragment_size,
2101 (double) pa_bytes_to_usec(u->fragment_size, &ss) / PA_USEC_PER_MSEC,
2102 (long unsigned) u->hwbuf_size,
2103 (double) pa_bytes_to_usec(u->hwbuf_size, &ss) / PA_USEC_PER_MSEC);
2104
2105 pa_sink_set_max_request(u->sink, u->hwbuf_size);
2106 if (pa_alsa_pcm_is_hw(u->pcm_handle))
2107 pa_sink_set_max_rewind(u->sink, u->hwbuf_size);
2108 else {
2109 pa_log_info("Disabling rewind for device %s", u->device_name);
2110 pa_sink_set_max_rewind(u->sink, 0);
2111 }
2112
2113 if (u->use_tsched) {
2114 u->tsched_watermark = pa_usec_to_bytes_round_up(pa_bytes_to_usec_round_up(tsched_watermark, &requested_ss), &u->sink->sample_spec);
2115
2116 u->watermark_inc_step = pa_usec_to_bytes(TSCHED_WATERMARK_INC_STEP_USEC, &u->sink->sample_spec);
2117 u->watermark_dec_step = pa_usec_to_bytes(TSCHED_WATERMARK_DEC_STEP_USEC, &u->sink->sample_spec);
2118
2119 u->watermark_inc_threshold = pa_usec_to_bytes_round_up(TSCHED_WATERMARK_INC_THRESHOLD_USEC, &u->sink->sample_spec);
2120 u->watermark_dec_threshold = pa_usec_to_bytes_round_up(TSCHED_WATERMARK_DEC_THRESHOLD_USEC, &u->sink->sample_spec);
2121
2122 fix_min_sleep_wakeup(u);
2123 fix_tsched_watermark(u);
2124
2125 pa_sink_set_latency_range(u->sink,
2126 0,
2127 pa_bytes_to_usec(u->hwbuf_size, &ss));
2128
2129 pa_log_info("Time scheduling watermark is %0.2fms",
2130 (double) pa_bytes_to_usec(u->tsched_watermark, &ss) / PA_USEC_PER_MSEC);
2131 } else
2132 pa_sink_set_fixed_latency(u->sink, pa_bytes_to_usec(u->hwbuf_size, &ss));
2133
2134 reserve_update(u);
2135
2136 if (update_sw_params(u) < 0)
2137 goto fail;
2138
2139 if (setup_mixer(u, ignore_dB, sync_volume) < 0)
2140 goto fail;
2141
2142 pa_alsa_dump(PA_LOG_DEBUG, u->pcm_handle);
2143
2144 if (!(u->thread = pa_thread_new("alsa-sink", thread_func, u))) {
2145 pa_log("Failed to create thread.");
2146 goto fail;
2147 }
2148
2149 /* Get initial mixer settings */
2150 if (data.volume_is_set) {
2151 if (u->sink->set_volume)
2152 u->sink->set_volume(u->sink);
2153 } else {
2154 if (u->sink->get_volume)
2155 u->sink->get_volume(u->sink);
2156 }
2157
2158 if (data.muted_is_set) {
2159 if (u->sink->set_mute)
2160 u->sink->set_mute(u->sink);
2161 } else {
2162 if (u->sink->get_mute)
2163 u->sink->get_mute(u->sink);
2164 }
2165
2166 pa_sink_put(u->sink);
2167
2168 if (profile_set)
2169 pa_alsa_profile_set_free(profile_set);
2170
2171 return u->sink;
2172
2173 fail:
2174
2175 if (u)
2176 userdata_free(u);
2177
2178 if (profile_set)
2179 pa_alsa_profile_set_free(profile_set);
2180
2181 return NULL;
2182 }
2183
2184 static void userdata_free(struct userdata *u) {
2185 pa_assert(u);
2186
2187 if (u->sink)
2188 pa_sink_unlink(u->sink);
2189
2190 if (u->thread) {
2191 pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
2192 pa_thread_free(u->thread);
2193 }
2194
2195 pa_thread_mq_done(&u->thread_mq);
2196
2197 if (u->sink)
2198 pa_sink_unref(u->sink);
2199
2200 if (u->memchunk.memblock)
2201 pa_memblock_unref(u->memchunk.memblock);
2202
2203 if (u->mixer_pd)
2204 pa_alsa_mixer_pdata_free(u->mixer_pd);
2205
2206 if (u->alsa_rtpoll_item)
2207 pa_rtpoll_item_free(u->alsa_rtpoll_item);
2208
2209 if (u->rtpoll)
2210 pa_rtpoll_free(u->rtpoll);
2211
2212 if (u->pcm_handle) {
2213 snd_pcm_drop(u->pcm_handle);
2214 snd_pcm_close(u->pcm_handle);
2215 }
2216
2217 if (u->mixer_fdl)
2218 pa_alsa_fdlist_free(u->mixer_fdl);
2219
2220 if (u->mixer_path_set)
2221 pa_alsa_path_set_free(u->mixer_path_set);
2222 else if (u->mixer_path)
2223 pa_alsa_path_free(u->mixer_path);
2224
2225 if (u->mixer_handle)
2226 snd_mixer_close(u->mixer_handle);
2227
2228 if (u->smoother)
2229 pa_smoother_free(u->smoother);
2230
2231 reserve_done(u);
2232 monitor_done(u);
2233
2234 pa_xfree(u->device_name);
2235 pa_xfree(u->control_device);
2236 pa_xfree(u);
2237 }
2238
2239 void pa_alsa_sink_free(pa_sink *s) {
2240 struct userdata *u;
2241
2242 pa_sink_assert_ref(s);
2243 pa_assert_se(u = s->userdata);
2244
2245 userdata_free(u);
2246 }