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