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