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