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