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