1 /**
2 * OpenAL cross platform audio library
3 * Copyright (C) 1999-2007 by authors.
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
13 *
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 * Or go to http://www.gnu.org/copyleft/lgpl.html
19 */
20
21 #include "config.h"
22
23 #include "backends/alsa.h"
24
25 #include <algorithm>
26 #include <atomic>
27 #include <cassert>
28 #include <cerrno>
29 #include <chrono>
30 #include <cstring>
31 #include <exception>
32 #include <functional>
33 #include <memory>
34 #include <string>
35 #include <thread>
36 #include <utility>
37
38 #include "albyte.h"
39 #include "alcmain.h"
40 #include "alconfig.h"
41 #include "almalloc.h"
42 #include "alnumeric.h"
43 #include "aloptional.h"
44 #include "alu.h"
45 #include "core/logging.h"
46 #include "dynload.h"
47 #include "ringbuffer.h"
48 #include "threads.h"
49 #include "vector.h"
50
51 #include <alsa/asoundlib.h>
52
53
54 namespace {
55
56 constexpr char alsaDevice[] = "ALSA Default";
57
58
59 #ifdef HAVE_DYNLOAD
60 #define ALSA_FUNCS(MAGIC) \
61 MAGIC(snd_strerror); \
62 MAGIC(snd_pcm_open); \
63 MAGIC(snd_pcm_close); \
64 MAGIC(snd_pcm_nonblock); \
65 MAGIC(snd_pcm_frames_to_bytes); \
66 MAGIC(snd_pcm_bytes_to_frames); \
67 MAGIC(snd_pcm_hw_params_malloc); \
68 MAGIC(snd_pcm_hw_params_free); \
69 MAGIC(snd_pcm_hw_params_any); \
70 MAGIC(snd_pcm_hw_params_current); \
71 MAGIC(snd_pcm_hw_params_set_access); \
72 MAGIC(snd_pcm_hw_params_set_format); \
73 MAGIC(snd_pcm_hw_params_set_channels); \
74 MAGIC(snd_pcm_hw_params_set_periods_near); \
75 MAGIC(snd_pcm_hw_params_set_rate_near); \
76 MAGIC(snd_pcm_hw_params_set_rate); \
77 MAGIC(snd_pcm_hw_params_set_rate_resample); \
78 MAGIC(snd_pcm_hw_params_set_buffer_time_near); \
79 MAGIC(snd_pcm_hw_params_set_period_time_near); \
80 MAGIC(snd_pcm_hw_params_set_buffer_size_near); \
81 MAGIC(snd_pcm_hw_params_set_period_size_near); \
82 MAGIC(snd_pcm_hw_params_set_buffer_size_min); \
83 MAGIC(snd_pcm_hw_params_get_buffer_time_min); \
84 MAGIC(snd_pcm_hw_params_get_buffer_time_max); \
85 MAGIC(snd_pcm_hw_params_get_period_time_min); \
86 MAGIC(snd_pcm_hw_params_get_period_time_max); \
87 MAGIC(snd_pcm_hw_params_get_buffer_size); \
88 MAGIC(snd_pcm_hw_params_get_period_size); \
89 MAGIC(snd_pcm_hw_params_get_access); \
90 MAGIC(snd_pcm_hw_params_get_periods); \
91 MAGIC(snd_pcm_hw_params_test_format); \
92 MAGIC(snd_pcm_hw_params_test_channels); \
93 MAGIC(snd_pcm_hw_params); \
94 MAGIC(snd_pcm_sw_params_malloc); \
95 MAGIC(snd_pcm_sw_params_current); \
96 MAGIC(snd_pcm_sw_params_set_avail_min); \
97 MAGIC(snd_pcm_sw_params_set_stop_threshold); \
98 MAGIC(snd_pcm_sw_params); \
99 MAGIC(snd_pcm_sw_params_free); \
100 MAGIC(snd_pcm_prepare); \
101 MAGIC(snd_pcm_start); \
102 MAGIC(snd_pcm_resume); \
103 MAGIC(snd_pcm_reset); \
104 MAGIC(snd_pcm_wait); \
105 MAGIC(snd_pcm_delay); \
106 MAGIC(snd_pcm_state); \
107 MAGIC(snd_pcm_avail_update); \
108 MAGIC(snd_pcm_areas_silence); \
109 MAGIC(snd_pcm_mmap_begin); \
110 MAGIC(snd_pcm_mmap_commit); \
111 MAGIC(snd_pcm_readi); \
112 MAGIC(snd_pcm_writei); \
113 MAGIC(snd_pcm_drain); \
114 MAGIC(snd_pcm_drop); \
115 MAGIC(snd_pcm_recover); \
116 MAGIC(snd_pcm_info_malloc); \
117 MAGIC(snd_pcm_info_free); \
118 MAGIC(snd_pcm_info_set_device); \
119 MAGIC(snd_pcm_info_set_subdevice); \
120 MAGIC(snd_pcm_info_set_stream); \
121 MAGIC(snd_pcm_info_get_name); \
122 MAGIC(snd_ctl_pcm_next_device); \
123 MAGIC(snd_ctl_pcm_info); \
124 MAGIC(snd_ctl_open); \
125 MAGIC(snd_ctl_close); \
126 MAGIC(snd_ctl_card_info_malloc); \
127 MAGIC(snd_ctl_card_info_free); \
128 MAGIC(snd_ctl_card_info); \
129 MAGIC(snd_ctl_card_info_get_name); \
130 MAGIC(snd_ctl_card_info_get_id); \
131 MAGIC(snd_card_next); \
132 MAGIC(snd_config_update_free_global)
133
134 static void *alsa_handle;
135 #define MAKE_FUNC(f) decltype(f) * p##f
136 ALSA_FUNCS(MAKE_FUNC);
137 #undef MAKE_FUNC
138
139 #ifndef IN_IDE_PARSER
140 #define snd_strerror psnd_strerror
141 #define snd_pcm_open psnd_pcm_open
142 #define snd_pcm_close psnd_pcm_close
143 #define snd_pcm_nonblock psnd_pcm_nonblock
144 #define snd_pcm_frames_to_bytes psnd_pcm_frames_to_bytes
145 #define snd_pcm_bytes_to_frames psnd_pcm_bytes_to_frames
146 #define snd_pcm_hw_params_malloc psnd_pcm_hw_params_malloc
147 #define snd_pcm_hw_params_free psnd_pcm_hw_params_free
148 #define snd_pcm_hw_params_any psnd_pcm_hw_params_any
149 #define snd_pcm_hw_params_current psnd_pcm_hw_params_current
150 #define snd_pcm_hw_params_set_access psnd_pcm_hw_params_set_access
151 #define snd_pcm_hw_params_set_format psnd_pcm_hw_params_set_format
152 #define snd_pcm_hw_params_set_channels psnd_pcm_hw_params_set_channels
153 #define snd_pcm_hw_params_set_periods_near psnd_pcm_hw_params_set_periods_near
154 #define snd_pcm_hw_params_set_rate_near psnd_pcm_hw_params_set_rate_near
155 #define snd_pcm_hw_params_set_rate psnd_pcm_hw_params_set_rate
156 #define snd_pcm_hw_params_set_rate_resample psnd_pcm_hw_params_set_rate_resample
157 #define snd_pcm_hw_params_set_buffer_time_near psnd_pcm_hw_params_set_buffer_time_near
158 #define snd_pcm_hw_params_set_period_time_near psnd_pcm_hw_params_set_period_time_near
159 #define snd_pcm_hw_params_set_buffer_size_near psnd_pcm_hw_params_set_buffer_size_near
160 #define snd_pcm_hw_params_set_period_size_near psnd_pcm_hw_params_set_period_size_near
161 #define snd_pcm_hw_params_set_buffer_size_min psnd_pcm_hw_params_set_buffer_size_min
162 #define snd_pcm_hw_params_get_buffer_time_min psnd_pcm_hw_params_get_buffer_time_min
163 #define snd_pcm_hw_params_get_buffer_time_max psnd_pcm_hw_params_get_buffer_time_max
164 #define snd_pcm_hw_params_get_period_time_min psnd_pcm_hw_params_get_period_time_min
165 #define snd_pcm_hw_params_get_period_time_max psnd_pcm_hw_params_get_period_time_max
166 #define snd_pcm_hw_params_get_buffer_size psnd_pcm_hw_params_get_buffer_size
167 #define snd_pcm_hw_params_get_period_size psnd_pcm_hw_params_get_period_size
168 #define snd_pcm_hw_params_get_access psnd_pcm_hw_params_get_access
169 #define snd_pcm_hw_params_get_periods psnd_pcm_hw_params_get_periods
170 #define snd_pcm_hw_params_test_format psnd_pcm_hw_params_test_format
171 #define snd_pcm_hw_params_test_channels psnd_pcm_hw_params_test_channels
172 #define snd_pcm_hw_params psnd_pcm_hw_params
173 #define snd_pcm_sw_params_malloc psnd_pcm_sw_params_malloc
174 #define snd_pcm_sw_params_current psnd_pcm_sw_params_current
175 #define snd_pcm_sw_params_set_avail_min psnd_pcm_sw_params_set_avail_min
176 #define snd_pcm_sw_params_set_stop_threshold psnd_pcm_sw_params_set_stop_threshold
177 #define snd_pcm_sw_params psnd_pcm_sw_params
178 #define snd_pcm_sw_params_free psnd_pcm_sw_params_free
179 #define snd_pcm_prepare psnd_pcm_prepare
180 #define snd_pcm_start psnd_pcm_start
181 #define snd_pcm_resume psnd_pcm_resume
182 #define snd_pcm_reset psnd_pcm_reset
183 #define snd_pcm_wait psnd_pcm_wait
184 #define snd_pcm_delay psnd_pcm_delay
185 #define snd_pcm_state psnd_pcm_state
186 #define snd_pcm_avail_update psnd_pcm_avail_update
187 #define snd_pcm_areas_silence psnd_pcm_areas_silence
188 #define snd_pcm_mmap_begin psnd_pcm_mmap_begin
189 #define snd_pcm_mmap_commit psnd_pcm_mmap_commit
190 #define snd_pcm_readi psnd_pcm_readi
191 #define snd_pcm_writei psnd_pcm_writei
192 #define snd_pcm_drain psnd_pcm_drain
193 #define snd_pcm_drop psnd_pcm_drop
194 #define snd_pcm_recover psnd_pcm_recover
195 #define snd_pcm_info_malloc psnd_pcm_info_malloc
196 #define snd_pcm_info_free psnd_pcm_info_free
197 #define snd_pcm_info_set_device psnd_pcm_info_set_device
198 #define snd_pcm_info_set_subdevice psnd_pcm_info_set_subdevice
199 #define snd_pcm_info_set_stream psnd_pcm_info_set_stream
200 #define snd_pcm_info_get_name psnd_pcm_info_get_name
201 #define snd_ctl_pcm_next_device psnd_ctl_pcm_next_device
202 #define snd_ctl_pcm_info psnd_ctl_pcm_info
203 #define snd_ctl_open psnd_ctl_open
204 #define snd_ctl_close psnd_ctl_close
205 #define snd_ctl_card_info_malloc psnd_ctl_card_info_malloc
206 #define snd_ctl_card_info_free psnd_ctl_card_info_free
207 #define snd_ctl_card_info psnd_ctl_card_info
208 #define snd_ctl_card_info_get_name psnd_ctl_card_info_get_name
209 #define snd_ctl_card_info_get_id psnd_ctl_card_info_get_id
210 #define snd_card_next psnd_card_next
211 #define snd_config_update_free_global psnd_config_update_free_global
212 #endif
213 #endif
214
215
216 struct HwParamsDeleter {
operator ()__anon761787e20111::HwParamsDeleter217 void operator()(snd_pcm_hw_params_t *ptr) { snd_pcm_hw_params_free(ptr); }
218 };
219 using HwParamsPtr = std::unique_ptr<snd_pcm_hw_params_t,HwParamsDeleter>;
CreateHwParams()220 HwParamsPtr CreateHwParams()
221 {
222 snd_pcm_hw_params_t *hp{};
223 snd_pcm_hw_params_malloc(&hp);
224 return HwParamsPtr{hp};
225 }
226
227 struct SwParamsDeleter {
operator ()__anon761787e20111::SwParamsDeleter228 void operator()(snd_pcm_sw_params_t *ptr) { snd_pcm_sw_params_free(ptr); }
229 };
230 using SwParamsPtr = std::unique_ptr<snd_pcm_sw_params_t,SwParamsDeleter>;
CreateSwParams()231 SwParamsPtr CreateSwParams()
232 {
233 snd_pcm_sw_params_t *sp{};
234 snd_pcm_sw_params_malloc(&sp);
235 return SwParamsPtr{sp};
236 }
237
238
239 struct DevMap {
240 std::string name;
241 std::string device_name;
242 };
243
244 al::vector<DevMap> PlaybackDevices;
245 al::vector<DevMap> CaptureDevices;
246
247
prefix_name(snd_pcm_stream_t stream)248 const char *prefix_name(snd_pcm_stream_t stream)
249 {
250 assert(stream == SND_PCM_STREAM_PLAYBACK || stream == SND_PCM_STREAM_CAPTURE);
251 return (stream==SND_PCM_STREAM_PLAYBACK) ? "device-prefix" : "capture-prefix";
252 }
253
probe_devices(snd_pcm_stream_t stream)254 al::vector<DevMap> probe_devices(snd_pcm_stream_t stream)
255 {
256 al::vector<DevMap> devlist;
257
258 snd_ctl_card_info_t *info;
259 snd_ctl_card_info_malloc(&info);
260 snd_pcm_info_t *pcminfo;
261 snd_pcm_info_malloc(&pcminfo);
262
263 devlist.emplace_back(DevMap{alsaDevice,
264 GetConfigValue(nullptr, "alsa", (stream==SND_PCM_STREAM_PLAYBACK) ? "device" : "capture",
265 "default")});
266
267 const char *customdevs{GetConfigValue(nullptr, "alsa",
268 (stream == SND_PCM_STREAM_PLAYBACK) ? "custom-devices" : "custom-captures", "")};
269 while(const char *curdev{customdevs})
270 {
271 if(!curdev[0]) break;
272 customdevs = strchr(curdev, ';');
273 const char *sep{strchr(curdev, '=')};
274 if(!sep)
275 {
276 std::string spec{customdevs ? std::string(curdev, customdevs++) : std::string(curdev)};
277 ERR("Invalid ALSA device specification \"%s\"\n", spec.c_str());
278 continue;
279 }
280
281 const char *oldsep{sep++};
282 devlist.emplace_back(DevMap{std::string(curdev, oldsep),
283 customdevs ? std::string(sep, customdevs++) : std::string(sep)});
284 const auto &entry = devlist.back();
285 TRACE("Got device \"%s\", \"%s\"\n", entry.name.c_str(), entry.device_name.c_str());
286 }
287
288 const std::string main_prefix{
289 ConfigValueStr(nullptr, "alsa", prefix_name(stream)).value_or("plughw:")};
290
291 int card{-1};
292 int err{snd_card_next(&card)};
293 for(;err >= 0 && card >= 0;err = snd_card_next(&card))
294 {
295 std::string name{"hw:" + std::to_string(card)};
296
297 snd_ctl_t *handle;
298 if((err=snd_ctl_open(&handle, name.c_str(), 0)) < 0)
299 {
300 ERR("control open (hw:%d): %s\n", card, snd_strerror(err));
301 continue;
302 }
303 if((err=snd_ctl_card_info(handle, info)) < 0)
304 {
305 ERR("control hardware info (hw:%d): %s\n", card, snd_strerror(err));
306 snd_ctl_close(handle);
307 continue;
308 }
309
310 const char *cardname{snd_ctl_card_info_get_name(info)};
311 const char *cardid{snd_ctl_card_info_get_id(info)};
312 name = prefix_name(stream);
313 name += '-';
314 name += cardid;
315 const std::string card_prefix{
316 ConfigValueStr(nullptr, "alsa", name.c_str()).value_or(main_prefix)};
317
318 int dev{-1};
319 while(1)
320 {
321 if(snd_ctl_pcm_next_device(handle, &dev) < 0)
322 ERR("snd_ctl_pcm_next_device failed\n");
323 if(dev < 0) break;
324
325 snd_pcm_info_set_device(pcminfo, static_cast<uint>(dev));
326 snd_pcm_info_set_subdevice(pcminfo, 0);
327 snd_pcm_info_set_stream(pcminfo, stream);
328 if((err=snd_ctl_pcm_info(handle, pcminfo)) < 0)
329 {
330 if(err != -ENOENT)
331 ERR("control digital audio info (hw:%d): %s\n", card, snd_strerror(err));
332 continue;
333 }
334
335 /* "prefix-cardid-dev" */
336 name = prefix_name(stream);
337 name += '-';
338 name += cardid;
339 name += '-';
340 name += std::to_string(dev);
341 const std::string device_prefix{
342 ConfigValueStr(nullptr, "alsa", name.c_str()).value_or(card_prefix)};
343
344 /* "CardName, PcmName (CARD=cardid,DEV=dev)" */
345 name = cardname;
346 name += ", ";
347 name += snd_pcm_info_get_name(pcminfo);
348 name += " (CARD=";
349 name += cardid;
350 name += ",DEV=";
351 name += std::to_string(dev);
352 name += ')';
353
354 /* "devprefixCARD=cardid,DEV=dev" */
355 std::string device{device_prefix};
356 device += "CARD=";
357 device += cardid;
358 device += ",DEV=";
359 device += std::to_string(dev);
360
361 devlist.emplace_back(DevMap{std::move(name), std::move(device)});
362 const auto &entry = devlist.back();
363 TRACE("Got device \"%s\", \"%s\"\n", entry.name.c_str(), entry.device_name.c_str());
364 }
365 snd_ctl_close(handle);
366 }
367 if(err < 0)
368 ERR("snd_card_next failed: %s\n", snd_strerror(err));
369
370 snd_pcm_info_free(pcminfo);
371 snd_ctl_card_info_free(info);
372
373 return devlist;
374 }
375
376
verify_state(snd_pcm_t * handle)377 int verify_state(snd_pcm_t *handle)
378 {
379 snd_pcm_state_t state{snd_pcm_state(handle)};
380
381 int err;
382 switch(state)
383 {
384 case SND_PCM_STATE_OPEN:
385 case SND_PCM_STATE_SETUP:
386 case SND_PCM_STATE_PREPARED:
387 case SND_PCM_STATE_RUNNING:
388 case SND_PCM_STATE_DRAINING:
389 case SND_PCM_STATE_PAUSED:
390 /* All Okay */
391 break;
392
393 case SND_PCM_STATE_XRUN:
394 if((err=snd_pcm_recover(handle, -EPIPE, 1)) < 0)
395 return err;
396 break;
397 case SND_PCM_STATE_SUSPENDED:
398 if((err=snd_pcm_recover(handle, -ESTRPIPE, 1)) < 0)
399 return err;
400 break;
401 case SND_PCM_STATE_DISCONNECTED:
402 return -ENODEV;
403 }
404
405 return state;
406 }
407
408
409 struct AlsaPlayback final : public BackendBase {
AlsaPlayback__anon761787e20111::AlsaPlayback410 AlsaPlayback(ALCdevice *device) noexcept : BackendBase{device} { }
411 ~AlsaPlayback() override;
412
413 int mixerProc();
414 int mixerNoMMapProc();
415
416 void open(const char *name) override;
417 bool reset() override;
418 void start() override;
419 void stop() override;
420
421 ClockLatency getClockLatency() override;
422
423 snd_pcm_t *mPcmHandle{nullptr};
424
425 std::mutex mMutex;
426
427 al::vector<al::byte> mBuffer;
428
429 std::atomic<bool> mKillNow{true};
430 std::thread mThread;
431
432 DEF_NEWDEL(AlsaPlayback)
433 };
434
~AlsaPlayback()435 AlsaPlayback::~AlsaPlayback()
436 {
437 if(mPcmHandle)
438 snd_pcm_close(mPcmHandle);
439 mPcmHandle = nullptr;
440 }
441
442
mixerProc()443 int AlsaPlayback::mixerProc()
444 {
445 SetRTPriority();
446 althrd_setname(MIXER_THREAD_NAME);
447
448 const size_t samplebits{mDevice->bytesFromFmt() * 8};
449 const snd_pcm_uframes_t update_size{mDevice->UpdateSize};
450 const snd_pcm_uframes_t buffer_size{mDevice->BufferSize};
451 while(!mKillNow.load(std::memory_order_acquire))
452 {
453 int state{verify_state(mPcmHandle)};
454 if(state < 0)
455 {
456 ERR("Invalid state detected: %s\n", snd_strerror(state));
457 mDevice->handleDisconnect("Bad state: %s", snd_strerror(state));
458 break;
459 }
460
461 snd_pcm_sframes_t avails{snd_pcm_avail_update(mPcmHandle)};
462 if(avails < 0)
463 {
464 ERR("available update failed: %s\n", snd_strerror(static_cast<int>(avails)));
465 continue;
466 }
467 snd_pcm_uframes_t avail{static_cast<snd_pcm_uframes_t>(avails)};
468
469 if(avail > buffer_size)
470 {
471 WARN("available samples exceeds the buffer size\n");
472 snd_pcm_reset(mPcmHandle);
473 continue;
474 }
475
476 // make sure there's frames to process
477 if(avail < update_size)
478 {
479 if(state != SND_PCM_STATE_RUNNING)
480 {
481 int err{snd_pcm_start(mPcmHandle)};
482 if(err < 0)
483 {
484 ERR("start failed: %s\n", snd_strerror(err));
485 continue;
486 }
487 }
488 if(snd_pcm_wait(mPcmHandle, 1000) == 0)
489 ERR("Wait timeout... buffer size too low?\n");
490 continue;
491 }
492 avail -= avail%update_size;
493
494 // it is possible that contiguous areas are smaller, thus we use a loop
495 std::lock_guard<std::mutex> _{mMutex};
496 while(avail > 0)
497 {
498 snd_pcm_uframes_t frames{avail};
499
500 const snd_pcm_channel_area_t *areas{};
501 snd_pcm_uframes_t offset{};
502 int err{snd_pcm_mmap_begin(mPcmHandle, &areas, &offset, &frames)};
503 if(err < 0)
504 {
505 ERR("mmap begin error: %s\n", snd_strerror(err));
506 break;
507 }
508
509 char *WritePtr{static_cast<char*>(areas->addr) + (offset * areas->step / 8)};
510 mDevice->renderSamples(WritePtr, static_cast<uint>(frames), areas->step/samplebits);
511
512 snd_pcm_sframes_t commitres{snd_pcm_mmap_commit(mPcmHandle, offset, frames)};
513 if(commitres < 0 || static_cast<snd_pcm_uframes_t>(commitres) != frames)
514 {
515 ERR("mmap commit error: %s\n",
516 snd_strerror(commitres >= 0 ? -EPIPE : static_cast<int>(commitres)));
517 break;
518 }
519
520 avail -= frames;
521 }
522 }
523
524 return 0;
525 }
526
mixerNoMMapProc()527 int AlsaPlayback::mixerNoMMapProc()
528 {
529 SetRTPriority();
530 althrd_setname(MIXER_THREAD_NAME);
531
532 const size_t frame_step{mDevice->channelsFromFmt()};
533 const snd_pcm_uframes_t update_size{mDevice->UpdateSize};
534 const snd_pcm_uframes_t buffer_size{mDevice->BufferSize};
535 while(!mKillNow.load(std::memory_order_acquire))
536 {
537 int state{verify_state(mPcmHandle)};
538 if(state < 0)
539 {
540 ERR("Invalid state detected: %s\n", snd_strerror(state));
541 mDevice->handleDisconnect("Bad state: %s", snd_strerror(state));
542 break;
543 }
544
545 snd_pcm_sframes_t avail{snd_pcm_avail_update(mPcmHandle)};
546 if(avail < 0)
547 {
548 ERR("available update failed: %s\n", snd_strerror(static_cast<int>(avail)));
549 continue;
550 }
551
552 if(static_cast<snd_pcm_uframes_t>(avail) > buffer_size)
553 {
554 WARN("available samples exceeds the buffer size\n");
555 snd_pcm_reset(mPcmHandle);
556 continue;
557 }
558
559 if(static_cast<snd_pcm_uframes_t>(avail) < update_size)
560 {
561 if(state != SND_PCM_STATE_RUNNING)
562 {
563 int err{snd_pcm_start(mPcmHandle)};
564 if(err < 0)
565 {
566 ERR("start failed: %s\n", snd_strerror(err));
567 continue;
568 }
569 }
570 if(snd_pcm_wait(mPcmHandle, 1000) == 0)
571 ERR("Wait timeout... buffer size too low?\n");
572 continue;
573 }
574
575 al::byte *WritePtr{mBuffer.data()};
576 avail = snd_pcm_bytes_to_frames(mPcmHandle, static_cast<ssize_t>(mBuffer.size()));
577 std::lock_guard<std::mutex> _{mMutex};
578 mDevice->renderSamples(WritePtr, static_cast<uint>(avail), frame_step);
579 while(avail > 0)
580 {
581 snd_pcm_sframes_t ret{snd_pcm_writei(mPcmHandle, WritePtr,
582 static_cast<snd_pcm_uframes_t>(avail))};
583 switch(ret)
584 {
585 case -EAGAIN:
586 continue;
587 #if ESTRPIPE != EPIPE
588 case -ESTRPIPE:
589 #endif
590 case -EPIPE:
591 case -EINTR:
592 ret = snd_pcm_recover(mPcmHandle, static_cast<int>(ret), 1);
593 if(ret < 0)
594 avail = 0;
595 break;
596 default:
597 if(ret >= 0)
598 {
599 WritePtr += snd_pcm_frames_to_bytes(mPcmHandle, ret);
600 avail -= ret;
601 }
602 break;
603 }
604 if(ret < 0)
605 {
606 ret = snd_pcm_prepare(mPcmHandle);
607 if(ret < 0) break;
608 }
609 }
610 }
611
612 return 0;
613 }
614
615
open(const char * name)616 void AlsaPlayback::open(const char *name)
617 {
618 const char *driver{};
619 if(name)
620 {
621 if(PlaybackDevices.empty())
622 PlaybackDevices = probe_devices(SND_PCM_STREAM_PLAYBACK);
623
624 auto iter = std::find_if(PlaybackDevices.cbegin(), PlaybackDevices.cend(),
625 [name](const DevMap &entry) -> bool
626 { return entry.name == name; }
627 );
628 if(iter == PlaybackDevices.cend())
629 throw al::backend_exception{al::backend_error::NoDevice,
630 "Device name \"%s\" not found", name};
631 driver = iter->device_name.c_str();
632 }
633 else
634 {
635 name = alsaDevice;
636 driver = GetConfigValue(nullptr, "alsa", "device", "default");
637 }
638
639 TRACE("Opening device \"%s\"\n", driver);
640 int err{snd_pcm_open(&mPcmHandle, driver, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK)};
641 if(err < 0)
642 throw al::backend_exception{al::backend_error::NoDevice,
643 "Could not open ALSA device \"%s\"", driver};
644
645 /* Free alsa's global config tree. Otherwise valgrind reports a ton of leaks. */
646 snd_config_update_free_global();
647
648 mDevice->DeviceName = name;
649 }
650
reset()651 bool AlsaPlayback::reset()
652 {
653 snd_pcm_format_t format{SND_PCM_FORMAT_UNKNOWN};
654 switch(mDevice->FmtType)
655 {
656 case DevFmtByte:
657 format = SND_PCM_FORMAT_S8;
658 break;
659 case DevFmtUByte:
660 format = SND_PCM_FORMAT_U8;
661 break;
662 case DevFmtShort:
663 format = SND_PCM_FORMAT_S16;
664 break;
665 case DevFmtUShort:
666 format = SND_PCM_FORMAT_U16;
667 break;
668 case DevFmtInt:
669 format = SND_PCM_FORMAT_S32;
670 break;
671 case DevFmtUInt:
672 format = SND_PCM_FORMAT_U32;
673 break;
674 case DevFmtFloat:
675 format = SND_PCM_FORMAT_FLOAT;
676 break;
677 }
678
679 bool allowmmap{!!GetConfigValueBool(mDevice->DeviceName.c_str(), "alsa", "mmap", 1)};
680 uint periodLen{static_cast<uint>(mDevice->UpdateSize * 1000000_u64 / mDevice->Frequency)};
681 uint bufferLen{static_cast<uint>(mDevice->BufferSize * 1000000_u64 / mDevice->Frequency)};
682 uint rate{mDevice->Frequency};
683
684 int err{};
685 HwParamsPtr hp{CreateHwParams()};
686 #define CHECK(x) do { \
687 if((err=(x)) < 0) \
688 throw al::backend_exception{al::backend_error::DeviceError, #x " failed: %s", \
689 snd_strerror(err)}; \
690 } while(0)
691 CHECK(snd_pcm_hw_params_any(mPcmHandle, hp.get()));
692 /* set interleaved access */
693 if(!allowmmap
694 || snd_pcm_hw_params_set_access(mPcmHandle, hp.get(), SND_PCM_ACCESS_MMAP_INTERLEAVED) < 0)
695 {
696 /* No mmap */
697 CHECK(snd_pcm_hw_params_set_access(mPcmHandle, hp.get(), SND_PCM_ACCESS_RW_INTERLEAVED));
698 }
699 /* test and set format (implicitly sets sample bits) */
700 if(snd_pcm_hw_params_test_format(mPcmHandle, hp.get(), format) < 0)
701 {
702 static const struct {
703 snd_pcm_format_t format;
704 DevFmtType fmttype;
705 } formatlist[] = {
706 { SND_PCM_FORMAT_FLOAT, DevFmtFloat },
707 { SND_PCM_FORMAT_S32, DevFmtInt },
708 { SND_PCM_FORMAT_U32, DevFmtUInt },
709 { SND_PCM_FORMAT_S16, DevFmtShort },
710 { SND_PCM_FORMAT_U16, DevFmtUShort },
711 { SND_PCM_FORMAT_S8, DevFmtByte },
712 { SND_PCM_FORMAT_U8, DevFmtUByte },
713 };
714
715 for(const auto &fmt : formatlist)
716 {
717 format = fmt.format;
718 if(snd_pcm_hw_params_test_format(mPcmHandle, hp.get(), format) >= 0)
719 {
720 mDevice->FmtType = fmt.fmttype;
721 break;
722 }
723 }
724 }
725 CHECK(snd_pcm_hw_params_set_format(mPcmHandle, hp.get(), format));
726 /* test and set channels (implicitly sets frame bits) */
727 if(snd_pcm_hw_params_test_channels(mPcmHandle, hp.get(), mDevice->channelsFromFmt()) < 0)
728 {
729 static const DevFmtChannels channellist[] = {
730 DevFmtStereo,
731 DevFmtQuad,
732 DevFmtX51,
733 DevFmtX71,
734 DevFmtMono,
735 };
736
737 for(const auto &chan : channellist)
738 {
739 if(snd_pcm_hw_params_test_channels(mPcmHandle, hp.get(), ChannelsFromDevFmt(chan, 0)) >= 0)
740 {
741 mDevice->FmtChans = chan;
742 mDevice->mAmbiOrder = 0;
743 break;
744 }
745 }
746 }
747 CHECK(snd_pcm_hw_params_set_channels(mPcmHandle, hp.get(), mDevice->channelsFromFmt()));
748 /* set rate (implicitly constrains period/buffer parameters) */
749 if(!GetConfigValueBool(mDevice->DeviceName.c_str(), "alsa", "allow-resampler", 0)
750 || !mDevice->Flags.test(FrequencyRequest))
751 {
752 if(snd_pcm_hw_params_set_rate_resample(mPcmHandle, hp.get(), 0) < 0)
753 ERR("Failed to disable ALSA resampler\n");
754 }
755 else if(snd_pcm_hw_params_set_rate_resample(mPcmHandle, hp.get(), 1) < 0)
756 ERR("Failed to enable ALSA resampler\n");
757 CHECK(snd_pcm_hw_params_set_rate_near(mPcmHandle, hp.get(), &rate, nullptr));
758 /* set period time (implicitly constrains period/buffer parameters) */
759 if((err=snd_pcm_hw_params_set_period_time_near(mPcmHandle, hp.get(), &periodLen, nullptr)) < 0)
760 ERR("snd_pcm_hw_params_set_period_time_near failed: %s\n", snd_strerror(err));
761 /* set buffer time (implicitly sets buffer size/bytes/time and period size/bytes) */
762 if((err=snd_pcm_hw_params_set_buffer_time_near(mPcmHandle, hp.get(), &bufferLen, nullptr)) < 0)
763 ERR("snd_pcm_hw_params_set_buffer_time_near failed: %s\n", snd_strerror(err));
764 /* install and prepare hardware configuration */
765 CHECK(snd_pcm_hw_params(mPcmHandle, hp.get()));
766
767 /* retrieve configuration info */
768 snd_pcm_uframes_t periodSizeInFrames{};
769 snd_pcm_uframes_t bufferSizeInFrames{};
770 snd_pcm_access_t access{};
771
772 CHECK(snd_pcm_hw_params_get_access(hp.get(), &access));
773 CHECK(snd_pcm_hw_params_get_period_size(hp.get(), &periodSizeInFrames, nullptr));
774 CHECK(snd_pcm_hw_params_get_buffer_size(hp.get(), &bufferSizeInFrames));
775 hp = nullptr;
776
777 SwParamsPtr sp{CreateSwParams()};
778 CHECK(snd_pcm_sw_params_current(mPcmHandle, sp.get()));
779 CHECK(snd_pcm_sw_params_set_avail_min(mPcmHandle, sp.get(), periodSizeInFrames));
780 CHECK(snd_pcm_sw_params_set_stop_threshold(mPcmHandle, sp.get(), bufferSizeInFrames));
781 CHECK(snd_pcm_sw_params(mPcmHandle, sp.get()));
782 #undef CHECK
783 sp = nullptr;
784
785 mDevice->BufferSize = static_cast<uint>(bufferSizeInFrames);
786 mDevice->UpdateSize = static_cast<uint>(periodSizeInFrames);
787 mDevice->Frequency = rate;
788
789 setDefaultChannelOrder();
790
791 return true;
792 }
793
start()794 void AlsaPlayback::start()
795 {
796 int err{};
797 snd_pcm_access_t access{};
798 HwParamsPtr hp{CreateHwParams()};
799 #define CHECK(x) do { \
800 if((err=(x)) < 0) \
801 throw al::backend_exception{al::backend_error::DeviceError, #x " failed: %s", \
802 snd_strerror(err)}; \
803 } while(0)
804 CHECK(snd_pcm_hw_params_current(mPcmHandle, hp.get()));
805 /* retrieve configuration info */
806 CHECK(snd_pcm_hw_params_get_access(hp.get(), &access));
807 hp = nullptr;
808
809 int (AlsaPlayback::*thread_func)(){};
810 if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
811 {
812 mBuffer.resize(
813 static_cast<size_t>(snd_pcm_frames_to_bytes(mPcmHandle, mDevice->UpdateSize)));
814 thread_func = &AlsaPlayback::mixerNoMMapProc;
815 }
816 else
817 {
818 CHECK(snd_pcm_prepare(mPcmHandle));
819 thread_func = &AlsaPlayback::mixerProc;
820 }
821 #undef CHECK
822
823 try {
824 mKillNow.store(false, std::memory_order_release);
825 mThread = std::thread{std::mem_fn(thread_func), this};
826 }
827 catch(std::exception& e) {
828 throw al::backend_exception{al::backend_error::DeviceError,
829 "Failed to start mixing thread: %s", e.what()};
830 }
831 }
832
stop()833 void AlsaPlayback::stop()
834 {
835 if(mKillNow.exchange(true, std::memory_order_acq_rel) || !mThread.joinable())
836 return;
837 mThread.join();
838
839 mBuffer.clear();
840 int err{snd_pcm_drop(mPcmHandle)};
841 if(err < 0)
842 ERR("snd_pcm_drop failed: %s\n", snd_strerror(err));
843 }
844
getClockLatency()845 ClockLatency AlsaPlayback::getClockLatency()
846 {
847 ClockLatency ret;
848
849 std::lock_guard<std::mutex> _{mMutex};
850 ret.ClockTime = GetDeviceClockTime(mDevice);
851 snd_pcm_sframes_t delay{};
852 int err{snd_pcm_delay(mPcmHandle, &delay)};
853 if(err < 0)
854 {
855 ERR("Failed to get pcm delay: %s\n", snd_strerror(err));
856 delay = 0;
857 }
858 ret.Latency = std::chrono::seconds{std::max<snd_pcm_sframes_t>(0, delay)};
859 ret.Latency /= mDevice->Frequency;
860
861 return ret;
862 }
863
864
865 struct AlsaCapture final : public BackendBase {
AlsaCapture__anon761787e20111::AlsaCapture866 AlsaCapture(ALCdevice *device) noexcept : BackendBase{device} { }
867 ~AlsaCapture() override;
868
869 void open(const char *name) override;
870 void start() override;
871 void stop() override;
872 void captureSamples(al::byte *buffer, uint samples) override;
873 uint availableSamples() override;
874 ClockLatency getClockLatency() override;
875
876 snd_pcm_t *mPcmHandle{nullptr};
877
878 al::vector<al::byte> mBuffer;
879
880 bool mDoCapture{false};
881 RingBufferPtr mRing{nullptr};
882
883 snd_pcm_sframes_t mLastAvail{0};
884
885 DEF_NEWDEL(AlsaCapture)
886 };
887
~AlsaCapture()888 AlsaCapture::~AlsaCapture()
889 {
890 if(mPcmHandle)
891 snd_pcm_close(mPcmHandle);
892 mPcmHandle = nullptr;
893 }
894
895
open(const char * name)896 void AlsaCapture::open(const char *name)
897 {
898 const char *driver{};
899 if(name)
900 {
901 if(CaptureDevices.empty())
902 CaptureDevices = probe_devices(SND_PCM_STREAM_CAPTURE);
903
904 auto iter = std::find_if(CaptureDevices.cbegin(), CaptureDevices.cend(),
905 [name](const DevMap &entry) -> bool
906 { return entry.name == name; }
907 );
908 if(iter == CaptureDevices.cend())
909 throw al::backend_exception{al::backend_error::NoDevice,
910 "Device name \"%s\" not found", name};
911 driver = iter->device_name.c_str();
912 }
913 else
914 {
915 name = alsaDevice;
916 driver = GetConfigValue(nullptr, "alsa", "capture", "default");
917 }
918
919 TRACE("Opening device \"%s\"\n", driver);
920 int err{snd_pcm_open(&mPcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK)};
921 if(err < 0)
922 throw al::backend_exception{al::backend_error::NoDevice,
923 "Could not open ALSA device \"%s\"", driver};
924
925 /* Free alsa's global config tree. Otherwise valgrind reports a ton of leaks. */
926 snd_config_update_free_global();
927
928 snd_pcm_format_t format{SND_PCM_FORMAT_UNKNOWN};
929 switch(mDevice->FmtType)
930 {
931 case DevFmtByte:
932 format = SND_PCM_FORMAT_S8;
933 break;
934 case DevFmtUByte:
935 format = SND_PCM_FORMAT_U8;
936 break;
937 case DevFmtShort:
938 format = SND_PCM_FORMAT_S16;
939 break;
940 case DevFmtUShort:
941 format = SND_PCM_FORMAT_U16;
942 break;
943 case DevFmtInt:
944 format = SND_PCM_FORMAT_S32;
945 break;
946 case DevFmtUInt:
947 format = SND_PCM_FORMAT_U32;
948 break;
949 case DevFmtFloat:
950 format = SND_PCM_FORMAT_FLOAT;
951 break;
952 }
953
954 snd_pcm_uframes_t bufferSizeInFrames{maxu(mDevice->BufferSize, 100*mDevice->Frequency/1000)};
955 snd_pcm_uframes_t periodSizeInFrames{minu(mDevice->BufferSize, 25*mDevice->Frequency/1000)};
956
957 bool needring{false};
958 HwParamsPtr hp{CreateHwParams()};
959 #define CHECK(x) do { \
960 if((err=(x)) < 0) \
961 throw al::backend_exception{al::backend_error::DeviceError, #x " failed: %s", \
962 snd_strerror(err)}; \
963 } while(0)
964 CHECK(snd_pcm_hw_params_any(mPcmHandle, hp.get()));
965 /* set interleaved access */
966 CHECK(snd_pcm_hw_params_set_access(mPcmHandle, hp.get(), SND_PCM_ACCESS_RW_INTERLEAVED));
967 /* set format (implicitly sets sample bits) */
968 CHECK(snd_pcm_hw_params_set_format(mPcmHandle, hp.get(), format));
969 /* set channels (implicitly sets frame bits) */
970 CHECK(snd_pcm_hw_params_set_channels(mPcmHandle, hp.get(), mDevice->channelsFromFmt()));
971 /* set rate (implicitly constrains period/buffer parameters) */
972 CHECK(snd_pcm_hw_params_set_rate(mPcmHandle, hp.get(), mDevice->Frequency, 0));
973 /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
974 if(snd_pcm_hw_params_set_buffer_size_min(mPcmHandle, hp.get(), &bufferSizeInFrames) < 0)
975 {
976 TRACE("Buffer too large, using intermediate ring buffer\n");
977 needring = true;
978 CHECK(snd_pcm_hw_params_set_buffer_size_near(mPcmHandle, hp.get(), &bufferSizeInFrames));
979 }
980 /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
981 CHECK(snd_pcm_hw_params_set_period_size_near(mPcmHandle, hp.get(), &periodSizeInFrames, nullptr));
982 /* install and prepare hardware configuration */
983 CHECK(snd_pcm_hw_params(mPcmHandle, hp.get()));
984 /* retrieve configuration info */
985 CHECK(snd_pcm_hw_params_get_period_size(hp.get(), &periodSizeInFrames, nullptr));
986 #undef CHECK
987 hp = nullptr;
988
989 if(needring)
990 mRing = RingBuffer::Create(mDevice->BufferSize, mDevice->frameSizeFromFmt(), false);
991
992 mDevice->DeviceName = name;
993 }
994
995
start()996 void AlsaCapture::start()
997 {
998 int err{snd_pcm_prepare(mPcmHandle)};
999 if(err < 0)
1000 throw al::backend_exception{al::backend_error::DeviceError, "snd_pcm_prepare failed: %s",
1001 snd_strerror(err)};
1002
1003 err = snd_pcm_start(mPcmHandle);
1004 if(err < 0)
1005 throw al::backend_exception{al::backend_error::DeviceError, "snd_pcm_start failed: %s",
1006 snd_strerror(err)};
1007
1008 mDoCapture = true;
1009 }
1010
stop()1011 void AlsaCapture::stop()
1012 {
1013 /* OpenAL requires access to unread audio after stopping, but ALSA's
1014 * snd_pcm_drain is unreliable and snd_pcm_drop drops it. Capture what's
1015 * available now so it'll be available later after the drop.
1016 */
1017 uint avail{availableSamples()};
1018 if(!mRing && avail > 0)
1019 {
1020 /* The ring buffer implicitly captures when checking availability.
1021 * Direct access needs to explicitly capture it into temp storage.
1022 */
1023 auto temp = al::vector<al::byte>(
1024 static_cast<size_t>(snd_pcm_frames_to_bytes(mPcmHandle, avail)));
1025 captureSamples(temp.data(), avail);
1026 mBuffer = std::move(temp);
1027 }
1028 int err{snd_pcm_drop(mPcmHandle)};
1029 if(err < 0)
1030 ERR("drop failed: %s\n", snd_strerror(err));
1031 mDoCapture = false;
1032 }
1033
captureSamples(al::byte * buffer,uint samples)1034 void AlsaCapture::captureSamples(al::byte *buffer, uint samples)
1035 {
1036 if(mRing)
1037 {
1038 mRing->read(buffer, samples);
1039 return;
1040 }
1041
1042 mLastAvail -= samples;
1043 while(mDevice->Connected.load(std::memory_order_acquire) && samples > 0)
1044 {
1045 snd_pcm_sframes_t amt{0};
1046
1047 if(!mBuffer.empty())
1048 {
1049 /* First get any data stored from the last stop */
1050 amt = snd_pcm_bytes_to_frames(mPcmHandle, static_cast<ssize_t>(mBuffer.size()));
1051 if(static_cast<snd_pcm_uframes_t>(amt) > samples) amt = samples;
1052
1053 amt = snd_pcm_frames_to_bytes(mPcmHandle, amt);
1054 std::copy_n(mBuffer.begin(), amt, buffer);
1055
1056 mBuffer.erase(mBuffer.begin(), mBuffer.begin()+amt);
1057 amt = snd_pcm_bytes_to_frames(mPcmHandle, amt);
1058 }
1059 else if(mDoCapture)
1060 amt = snd_pcm_readi(mPcmHandle, buffer, samples);
1061 if(amt < 0)
1062 {
1063 ERR("read error: %s\n", snd_strerror(static_cast<int>(amt)));
1064
1065 if(amt == -EAGAIN)
1066 continue;
1067 if((amt=snd_pcm_recover(mPcmHandle, static_cast<int>(amt), 1)) >= 0)
1068 {
1069 amt = snd_pcm_start(mPcmHandle);
1070 if(amt >= 0)
1071 amt = snd_pcm_avail_update(mPcmHandle);
1072 }
1073 if(amt < 0)
1074 {
1075 const char *err{snd_strerror(static_cast<int>(amt))};
1076 ERR("restore error: %s\n", err);
1077 mDevice->handleDisconnect("Capture recovery failure: %s", err);
1078 break;
1079 }
1080 /* If the amount available is less than what's asked, we lost it
1081 * during recovery. So just give silence instead. */
1082 if(static_cast<snd_pcm_uframes_t>(amt) < samples)
1083 break;
1084 continue;
1085 }
1086
1087 buffer = buffer + amt;
1088 samples -= static_cast<uint>(amt);
1089 }
1090 if(samples > 0)
1091 std::fill_n(buffer, snd_pcm_frames_to_bytes(mPcmHandle, samples),
1092 al::byte((mDevice->FmtType == DevFmtUByte) ? 0x80 : 0));
1093 }
1094
availableSamples()1095 uint AlsaCapture::availableSamples()
1096 {
1097 snd_pcm_sframes_t avail{0};
1098 if(mDevice->Connected.load(std::memory_order_acquire) && mDoCapture)
1099 avail = snd_pcm_avail_update(mPcmHandle);
1100 if(avail < 0)
1101 {
1102 ERR("avail update failed: %s\n", snd_strerror(static_cast<int>(avail)));
1103
1104 if((avail=snd_pcm_recover(mPcmHandle, static_cast<int>(avail), 1)) >= 0)
1105 {
1106 if(mDoCapture)
1107 avail = snd_pcm_start(mPcmHandle);
1108 if(avail >= 0)
1109 avail = snd_pcm_avail_update(mPcmHandle);
1110 }
1111 if(avail < 0)
1112 {
1113 const char *err{snd_strerror(static_cast<int>(avail))};
1114 ERR("restore error: %s\n", err);
1115 mDevice->handleDisconnect("Capture recovery failure: %s", err);
1116 }
1117 }
1118
1119 if(!mRing)
1120 {
1121 if(avail < 0) avail = 0;
1122 avail += snd_pcm_bytes_to_frames(mPcmHandle, static_cast<ssize_t>(mBuffer.size()));
1123 if(avail > mLastAvail) mLastAvail = avail;
1124 return static_cast<uint>(mLastAvail);
1125 }
1126
1127 while(avail > 0)
1128 {
1129 auto vec = mRing->getWriteVector();
1130 if(vec.first.len == 0) break;
1131
1132 snd_pcm_sframes_t amt{std::min(static_cast<snd_pcm_sframes_t>(vec.first.len), avail)};
1133 amt = snd_pcm_readi(mPcmHandle, vec.first.buf, static_cast<snd_pcm_uframes_t>(amt));
1134 if(amt < 0)
1135 {
1136 ERR("read error: %s\n", snd_strerror(static_cast<int>(amt)));
1137
1138 if(amt == -EAGAIN)
1139 continue;
1140 if((amt=snd_pcm_recover(mPcmHandle, static_cast<int>(amt), 1)) >= 0)
1141 {
1142 if(mDoCapture)
1143 amt = snd_pcm_start(mPcmHandle);
1144 if(amt >= 0)
1145 amt = snd_pcm_avail_update(mPcmHandle);
1146 }
1147 if(amt < 0)
1148 {
1149 const char *err{snd_strerror(static_cast<int>(amt))};
1150 ERR("restore error: %s\n", err);
1151 mDevice->handleDisconnect("Capture recovery failure: %s", err);
1152 break;
1153 }
1154 avail = amt;
1155 continue;
1156 }
1157
1158 mRing->writeAdvance(static_cast<snd_pcm_uframes_t>(amt));
1159 avail -= amt;
1160 }
1161
1162 return static_cast<uint>(mRing->readSpace());
1163 }
1164
getClockLatency()1165 ClockLatency AlsaCapture::getClockLatency()
1166 {
1167 ClockLatency ret;
1168
1169 ret.ClockTime = GetDeviceClockTime(mDevice);
1170 snd_pcm_sframes_t delay{};
1171 int err{snd_pcm_delay(mPcmHandle, &delay)};
1172 if(err < 0)
1173 {
1174 ERR("Failed to get pcm delay: %s\n", snd_strerror(err));
1175 delay = 0;
1176 }
1177 ret.Latency = std::chrono::seconds{std::max<snd_pcm_sframes_t>(0, delay)};
1178 ret.Latency /= mDevice->Frequency;
1179
1180 return ret;
1181 }
1182
1183 } // namespace
1184
1185
init()1186 bool AlsaBackendFactory::init()
1187 {
1188 bool error{false};
1189
1190 #ifdef HAVE_DYNLOAD
1191 if(!alsa_handle)
1192 {
1193 std::string missing_funcs;
1194
1195 alsa_handle = LoadLib("libasound.so.2");
1196 if(!alsa_handle)
1197 {
1198 WARN("Failed to load %s\n", "libasound.so.2");
1199 return false;
1200 }
1201
1202 error = false;
1203 #define LOAD_FUNC(f) do { \
1204 p##f = reinterpret_cast<decltype(p##f)>(GetSymbol(alsa_handle, #f)); \
1205 if(p##f == nullptr) { \
1206 error = true; \
1207 missing_funcs += "\n" #f; \
1208 } \
1209 } while(0)
1210 ALSA_FUNCS(LOAD_FUNC);
1211 #undef LOAD_FUNC
1212
1213 if(error)
1214 {
1215 WARN("Missing expected functions:%s\n", missing_funcs.c_str());
1216 CloseLib(alsa_handle);
1217 alsa_handle = nullptr;
1218 }
1219 }
1220 #endif
1221
1222 return !error;
1223 }
1224
querySupport(BackendType type)1225 bool AlsaBackendFactory::querySupport(BackendType type)
1226 { return (type == BackendType::Playback || type == BackendType::Capture); }
1227
probe(BackendType type)1228 std::string AlsaBackendFactory::probe(BackendType type)
1229 {
1230 std::string outnames;
1231
1232 auto add_device = [&outnames](const DevMap &entry) -> void
1233 {
1234 /* +1 to also append the null char (to ensure a null-separated list and
1235 * double-null terminated list).
1236 */
1237 outnames.append(entry.name.c_str(), entry.name.length()+1);
1238 };
1239 switch(type)
1240 {
1241 case BackendType::Playback:
1242 PlaybackDevices = probe_devices(SND_PCM_STREAM_PLAYBACK);
1243 std::for_each(PlaybackDevices.cbegin(), PlaybackDevices.cend(), add_device);
1244 break;
1245
1246 case BackendType::Capture:
1247 CaptureDevices = probe_devices(SND_PCM_STREAM_CAPTURE);
1248 std::for_each(CaptureDevices.cbegin(), CaptureDevices.cend(), add_device);
1249 break;
1250 }
1251
1252 return outnames;
1253 }
1254
createBackend(ALCdevice * device,BackendType type)1255 BackendPtr AlsaBackendFactory::createBackend(ALCdevice *device, BackendType type)
1256 {
1257 if(type == BackendType::Playback)
1258 return BackendPtr{new AlsaPlayback{device}};
1259 if(type == BackendType::Capture)
1260 return BackendPtr{new AlsaCapture{device}};
1261 return nullptr;
1262 }
1263
getFactory()1264 BackendFactory &AlsaBackendFactory::getFactory()
1265 {
1266 static AlsaBackendFactory factory{};
1267 return factory;
1268 }
1269