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