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.
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.
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
39 #include "alc/alconfig.h"
41 #include "alnumeric.h"
42 #include "aloptional.h"
43 #include "core/device.h"
44 #include "core/helpers.h"
45 #include "core/logging.h"
47 #include "ringbuffer.h"
51 #include <alsa/asoundlib.h>
56 constexpr char alsaDevice[] = "ALSA Default";
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_get_access); \
72 MAGIC(snd_pcm_hw_params_get_buffer_size); \
73 MAGIC(snd_pcm_hw_params_get_buffer_time_min); \
74 MAGIC(snd_pcm_hw_params_get_buffer_time_max); \
75 MAGIC(snd_pcm_hw_params_get_channels); \
76 MAGIC(snd_pcm_hw_params_get_period_size); \
77 MAGIC(snd_pcm_hw_params_get_period_time_max); \
78 MAGIC(snd_pcm_hw_params_get_period_time_min); \
79 MAGIC(snd_pcm_hw_params_get_periods); \
80 MAGIC(snd_pcm_hw_params_set_access); \
81 MAGIC(snd_pcm_hw_params_set_buffer_size_min); \
82 MAGIC(snd_pcm_hw_params_set_buffer_size_near); \
83 MAGIC(snd_pcm_hw_params_set_buffer_time_near); \
84 MAGIC(snd_pcm_hw_params_set_channels); \
85 MAGIC(snd_pcm_hw_params_set_channels_near); \
86 MAGIC(snd_pcm_hw_params_set_format); \
87 MAGIC(snd_pcm_hw_params_set_period_time_near); \
88 MAGIC(snd_pcm_hw_params_set_period_size_near); \
89 MAGIC(snd_pcm_hw_params_set_periods_near); \
90 MAGIC(snd_pcm_hw_params_set_rate_near); \
91 MAGIC(snd_pcm_hw_params_set_rate); \
92 MAGIC(snd_pcm_hw_params_set_rate_resample); \
93 MAGIC(snd_pcm_hw_params_test_format); \
94 MAGIC(snd_pcm_hw_params_test_channels); \
95 MAGIC(snd_pcm_hw_params); \
96 MAGIC(snd_pcm_sw_params); \
97 MAGIC(snd_pcm_sw_params_current); \
98 MAGIC(snd_pcm_sw_params_free); \
99 MAGIC(snd_pcm_sw_params_malloc); \
100 MAGIC(snd_pcm_sw_params_set_avail_min); \
101 MAGIC(snd_pcm_sw_params_set_stop_threshold); \
102 MAGIC(snd_pcm_prepare); \
103 MAGIC(snd_pcm_start); \
104 MAGIC(snd_pcm_resume); \
105 MAGIC(snd_pcm_reset); \
106 MAGIC(snd_pcm_wait); \
107 MAGIC(snd_pcm_delay); \
108 MAGIC(snd_pcm_state); \
109 MAGIC(snd_pcm_avail_update); \
110 MAGIC(snd_pcm_mmap_begin); \
111 MAGIC(snd_pcm_mmap_commit); \
112 MAGIC(snd_pcm_readi); \
113 MAGIC(snd_pcm_writei); \
114 MAGIC(snd_pcm_drain); \
115 MAGIC(snd_pcm_drop); \
116 MAGIC(snd_pcm_recover); \
117 MAGIC(snd_pcm_info_malloc); \
118 MAGIC(snd_pcm_info_free); \
119 MAGIC(snd_pcm_info_set_device); \
120 MAGIC(snd_pcm_info_set_subdevice); \
121 MAGIC(snd_pcm_info_set_stream); \
122 MAGIC(snd_pcm_info_get_name); \
123 MAGIC(snd_ctl_pcm_next_device); \
124 MAGIC(snd_ctl_pcm_info); \
125 MAGIC(snd_ctl_open); \
126 MAGIC(snd_ctl_close); \
127 MAGIC(snd_ctl_card_info_malloc); \
128 MAGIC(snd_ctl_card_info_free); \
129 MAGIC(snd_ctl_card_info); \
130 MAGIC(snd_ctl_card_info_get_name); \
131 MAGIC(snd_ctl_card_info_get_id); \
132 MAGIC(snd_card_next); \
133 MAGIC(snd_config_update_free_global)
136 #define MAKE_FUNC(f) decltype(f) * p##f
137 ALSA_FUNCS(MAKE_FUNC);
140 #ifndef IN_IDE_PARSER
141 #define snd_strerror psnd_strerror
142 #define snd_pcm_open psnd_pcm_open
143 #define snd_pcm_close psnd_pcm_close
144 #define snd_pcm_nonblock psnd_pcm_nonblock
145 #define snd_pcm_frames_to_bytes psnd_pcm_frames_to_bytes
146 #define snd_pcm_bytes_to_frames psnd_pcm_bytes_to_frames
147 #define snd_pcm_hw_params_malloc psnd_pcm_hw_params_malloc
148 #define snd_pcm_hw_params_free psnd_pcm_hw_params_free
149 #define snd_pcm_hw_params_any psnd_pcm_hw_params_any
150 #define snd_pcm_hw_params_current psnd_pcm_hw_params_current
151 #define snd_pcm_hw_params_set_access psnd_pcm_hw_params_set_access
152 #define snd_pcm_hw_params_set_format psnd_pcm_hw_params_set_format
153 #define snd_pcm_hw_params_set_channels psnd_pcm_hw_params_set_channels
154 #define snd_pcm_hw_params_set_channels_near psnd_pcm_hw_params_set_channels_near
155 #define snd_pcm_hw_params_set_periods_near psnd_pcm_hw_params_set_periods_near
156 #define snd_pcm_hw_params_set_rate_near psnd_pcm_hw_params_set_rate_near
157 #define snd_pcm_hw_params_set_rate psnd_pcm_hw_params_set_rate
158 #define snd_pcm_hw_params_set_rate_resample psnd_pcm_hw_params_set_rate_resample
159 #define snd_pcm_hw_params_set_buffer_time_near psnd_pcm_hw_params_set_buffer_time_near
160 #define snd_pcm_hw_params_set_period_time_near psnd_pcm_hw_params_set_period_time_near
161 #define snd_pcm_hw_params_set_buffer_size_near psnd_pcm_hw_params_set_buffer_size_near
162 #define snd_pcm_hw_params_set_period_size_near psnd_pcm_hw_params_set_period_size_near
163 #define snd_pcm_hw_params_set_buffer_size_min psnd_pcm_hw_params_set_buffer_size_min
164 #define snd_pcm_hw_params_get_buffer_time_min psnd_pcm_hw_params_get_buffer_time_min
165 #define snd_pcm_hw_params_get_buffer_time_max psnd_pcm_hw_params_get_buffer_time_max
166 #define snd_pcm_hw_params_get_period_time_min psnd_pcm_hw_params_get_period_time_min
167 #define snd_pcm_hw_params_get_period_time_max psnd_pcm_hw_params_get_period_time_max
168 #define snd_pcm_hw_params_get_buffer_size psnd_pcm_hw_params_get_buffer_size
169 #define snd_pcm_hw_params_get_period_size psnd_pcm_hw_params_get_period_size
170 #define snd_pcm_hw_params_get_access psnd_pcm_hw_params_get_access
171 #define snd_pcm_hw_params_get_periods psnd_pcm_hw_params_get_periods
172 #define snd_pcm_hw_params_get_channels psnd_pcm_hw_params_get_channels
173 #define snd_pcm_hw_params_test_format psnd_pcm_hw_params_test_format
174 #define snd_pcm_hw_params_test_channels psnd_pcm_hw_params_test_channels
175 #define snd_pcm_hw_params psnd_pcm_hw_params
176 #define snd_pcm_sw_params_malloc psnd_pcm_sw_params_malloc
177 #define snd_pcm_sw_params_current psnd_pcm_sw_params_current
178 #define snd_pcm_sw_params_set_avail_min psnd_pcm_sw_params_set_avail_min
179 #define snd_pcm_sw_params_set_stop_threshold psnd_pcm_sw_params_set_stop_threshold
180 #define snd_pcm_sw_params psnd_pcm_sw_params
181 #define snd_pcm_sw_params_free psnd_pcm_sw_params_free
182 #define snd_pcm_prepare psnd_pcm_prepare
183 #define snd_pcm_start psnd_pcm_start
184 #define snd_pcm_resume psnd_pcm_resume
185 #define snd_pcm_reset psnd_pcm_reset
186 #define snd_pcm_wait psnd_pcm_wait
187 #define snd_pcm_delay psnd_pcm_delay
188 #define snd_pcm_state psnd_pcm_state
189 #define snd_pcm_avail_update psnd_pcm_avail_update
190 #define snd_pcm_mmap_begin psnd_pcm_mmap_begin
191 #define snd_pcm_mmap_commit psnd_pcm_mmap_commit
192 #define snd_pcm_readi psnd_pcm_readi
193 #define snd_pcm_writei psnd_pcm_writei
194 #define snd_pcm_drain psnd_pcm_drain
195 #define snd_pcm_drop psnd_pcm_drop
196 #define snd_pcm_recover psnd_pcm_recover
197 #define snd_pcm_info_malloc psnd_pcm_info_malloc
198 #define snd_pcm_info_free psnd_pcm_info_free
199 #define snd_pcm_info_set_device psnd_pcm_info_set_device
200 #define snd_pcm_info_set_subdevice psnd_pcm_info_set_subdevice
201 #define snd_pcm_info_set_stream psnd_pcm_info_set_stream
202 #define snd_pcm_info_get_name psnd_pcm_info_get_name
203 #define snd_ctl_pcm_next_device psnd_ctl_pcm_next_device
204 #define snd_ctl_pcm_info psnd_ctl_pcm_info
205 #define snd_ctl_open psnd_ctl_open
206 #define snd_ctl_close psnd_ctl_close
207 #define snd_ctl_card_info_malloc psnd_ctl_card_info_malloc
208 #define snd_ctl_card_info_free psnd_ctl_card_info_free
209 #define snd_ctl_card_info psnd_ctl_card_info
210 #define snd_ctl_card_info_get_name psnd_ctl_card_info_get_name
211 #define snd_ctl_card_info_get_id psnd_ctl_card_info_get_id
212 #define snd_card_next psnd_card_next
213 #define snd_config_update_free_global psnd_config_update_free_global
218 struct HwParamsDeleter {
219 void operator()(snd_pcm_hw_params_t *ptr) { snd_pcm_hw_params_free(ptr); }
221 using HwParamsPtr = std::unique_ptr<snd_pcm_hw_params_t,HwParamsDeleter>;
222 HwParamsPtr CreateHwParams()
224 snd_pcm_hw_params_t *hp{};
225 snd_pcm_hw_params_malloc(&hp);
226 return HwParamsPtr{hp};
229 struct SwParamsDeleter {
230 void operator()(snd_pcm_sw_params_t *ptr) { snd_pcm_sw_params_free(ptr); }
232 using SwParamsPtr = std::unique_ptr<snd_pcm_sw_params_t,SwParamsDeleter>;
233 SwParamsPtr CreateSwParams()
235 snd_pcm_sw_params_t *sp{};
236 snd_pcm_sw_params_malloc(&sp);
237 return SwParamsPtr{sp};
243 std::string device_name;
245 template<typename T, typename U>
246 DevMap(T&& name_, U&& devname)
247 : name{std::forward<T>(name_)}, device_name{std::forward<U>(devname)}
251 al::vector<DevMap> PlaybackDevices;
252 al::vector<DevMap> CaptureDevices;
255 const char *prefix_name(snd_pcm_stream_t stream)
257 assert(stream == SND_PCM_STREAM_PLAYBACK || stream == SND_PCM_STREAM_CAPTURE);
258 return (stream==SND_PCM_STREAM_PLAYBACK) ? "device-prefix" : "capture-prefix";
261 al::vector<DevMap> probe_devices(snd_pcm_stream_t stream)
263 al::vector<DevMap> devlist;
265 snd_ctl_card_info_t *info;
266 snd_ctl_card_info_malloc(&info);
267 snd_pcm_info_t *pcminfo;
268 snd_pcm_info_malloc(&pcminfo);
270 auto defname = ConfigValueStr(nullptr, "alsa",
271 (stream == SND_PCM_STREAM_PLAYBACK) ? "device" : "capture");
272 devlist.emplace_back(alsaDevice, defname ? defname->c_str() : "default");
274 if(auto customdevs = ConfigValueStr(nullptr, "alsa",
275 (stream == SND_PCM_STREAM_PLAYBACK) ? "custom-devices" : "custom-captures"))
277 size_t nextpos{customdevs->find_first_not_of(';')};
279 while((curpos=nextpos) < customdevs->length())
281 nextpos = customdevs->find_first_of(';', curpos+1);
283 size_t seppos{customdevs->find_first_of('=', curpos)};
284 if(seppos == curpos || seppos >= nextpos)
286 std::string spec{customdevs->substr(curpos, nextpos-curpos)};
287 ERR("Invalid ALSA device specification \"%s\"\n", spec.c_str());
291 devlist.emplace_back(customdevs->substr(curpos, seppos-curpos),
292 customdevs->substr(seppos+1, nextpos-seppos-1));
293 const auto &entry = devlist.back();
294 TRACE("Got device \"%s\", \"%s\"\n", entry.name.c_str(), entry.device_name.c_str());
297 if(nextpos < customdevs->length())
298 nextpos = customdevs->find_first_not_of(';', nextpos+1);
302 const std::string main_prefix{
303 ConfigValueStr(nullptr, "alsa", prefix_name(stream)).value_or("plughw:")};
306 int err{snd_card_next(&card)};
307 for(;err >= 0 && card >= 0;err = snd_card_next(&card))
309 std::string name{"hw:" + std::to_string(card)};
312 if((err=snd_ctl_open(&handle, name.c_str(), 0)) < 0)
314 ERR("control open (hw:%d): %s\n", card, snd_strerror(err));
317 if((err=snd_ctl_card_info(handle, info)) < 0)
319 ERR("control hardware info (hw:%d): %s\n", card, snd_strerror(err));
320 snd_ctl_close(handle);
324 const char *cardname{snd_ctl_card_info_get_name(info)};
325 const char *cardid{snd_ctl_card_info_get_id(info)};
326 name = prefix_name(stream);
329 const std::string card_prefix{
330 ConfigValueStr(nullptr, "alsa", name.c_str()).value_or(main_prefix)};
335 if(snd_ctl_pcm_next_device(handle, &dev) < 0)
336 ERR("snd_ctl_pcm_next_device failed\n");
339 snd_pcm_info_set_device(pcminfo, static_cast<uint>(dev));
340 snd_pcm_info_set_subdevice(pcminfo, 0);
341 snd_pcm_info_set_stream(pcminfo, stream);
342 if((err=snd_ctl_pcm_info(handle, pcminfo)) < 0)
345 ERR("control digital audio info (hw:%d): %s\n", card, snd_strerror(err));
349 /* "prefix-cardid-dev" */
350 name = prefix_name(stream);
354 name += std::to_string(dev);
355 const std::string device_prefix{
356 ConfigValueStr(nullptr, "alsa", name.c_str()).value_or(card_prefix)};
358 /* "CardName, PcmName (CARD=cardid,DEV=dev)" */
361 name += snd_pcm_info_get_name(pcminfo);
365 name += std::to_string(dev);
368 /* "devprefixCARD=cardid,DEV=dev" */
369 std::string device{device_prefix};
373 device += std::to_string(dev);
375 devlist.emplace_back(std::move(name), std::move(device));
376 const auto &entry = devlist.back();
377 TRACE("Got device \"%s\", \"%s\"\n", entry.name.c_str(), entry.device_name.c_str());
379 snd_ctl_close(handle);
382 ERR("snd_card_next failed: %s\n", snd_strerror(err));
384 snd_pcm_info_free(pcminfo);
385 snd_ctl_card_info_free(info);
391 int verify_state(snd_pcm_t *handle)
393 snd_pcm_state_t state{snd_pcm_state(handle)};
398 case SND_PCM_STATE_OPEN:
399 case SND_PCM_STATE_SETUP:
400 case SND_PCM_STATE_PREPARED:
401 case SND_PCM_STATE_RUNNING:
402 case SND_PCM_STATE_DRAINING:
403 case SND_PCM_STATE_PAUSED:
407 case SND_PCM_STATE_XRUN:
408 if((err=snd_pcm_recover(handle, -EPIPE, 1)) < 0)
411 case SND_PCM_STATE_SUSPENDED:
412 if((err=snd_pcm_recover(handle, -ESTRPIPE, 1)) < 0)
415 case SND_PCM_STATE_DISCONNECTED:
423 struct AlsaPlayback final : public BackendBase {
424 AlsaPlayback(DeviceBase *device) noexcept : BackendBase{device} { }
425 ~AlsaPlayback() override;
428 int mixerNoMMapProc();
430 void open(const char *name) override;
431 bool reset() override;
432 void start() override;
433 void stop() override;
435 ClockLatency getClockLatency() override;
437 snd_pcm_t *mPcmHandle{nullptr};
442 al::vector<al::byte> mBuffer;
444 std::atomic<bool> mKillNow{true};
447 DEF_NEWDEL(AlsaPlayback)
450 AlsaPlayback::~AlsaPlayback()
453 snd_pcm_close(mPcmHandle);
454 mPcmHandle = nullptr;
458 int AlsaPlayback::mixerProc()
461 althrd_setname(MIXER_THREAD_NAME);
463 const snd_pcm_uframes_t update_size{mDevice->UpdateSize};
464 const snd_pcm_uframes_t buffer_size{mDevice->BufferSize};
465 while(!mKillNow.load(std::memory_order_acquire))
467 int state{verify_state(mPcmHandle)};
470 ERR("Invalid state detected: %s\n", snd_strerror(state));
471 mDevice->handleDisconnect("Bad state: %s", snd_strerror(state));
475 snd_pcm_sframes_t avails{snd_pcm_avail_update(mPcmHandle)};
478 ERR("available update failed: %s\n", snd_strerror(static_cast<int>(avails)));
481 snd_pcm_uframes_t avail{static_cast<snd_pcm_uframes_t>(avails)};
483 if(avail > buffer_size)
485 WARN("available samples exceeds the buffer size\n");
486 snd_pcm_reset(mPcmHandle);
490 // make sure there's frames to process
491 if(avail < update_size)
493 if(state != SND_PCM_STATE_RUNNING)
495 int err{snd_pcm_start(mPcmHandle)};
498 ERR("start failed: %s\n", snd_strerror(err));
502 if(snd_pcm_wait(mPcmHandle, 1000) == 0)
503 ERR("Wait timeout... buffer size too low?\n");
506 avail -= avail%update_size;
508 // it is possible that contiguous areas are smaller, thus we use a loop
509 std::lock_guard<std::mutex> _{mMutex};
512 snd_pcm_uframes_t frames{avail};
514 const snd_pcm_channel_area_t *areas{};
515 snd_pcm_uframes_t offset{};
516 int err{snd_pcm_mmap_begin(mPcmHandle, &areas, &offset, &frames)};
519 ERR("mmap begin error: %s\n", snd_strerror(err));
523 char *WritePtr{static_cast<char*>(areas->addr) + (offset * areas->step / 8)};
524 mDevice->renderSamples(WritePtr, static_cast<uint>(frames), mFrameStep);
526 snd_pcm_sframes_t commitres{snd_pcm_mmap_commit(mPcmHandle, offset, frames)};
527 if(commitres < 0 || static_cast<snd_pcm_uframes_t>(commitres) != frames)
529 ERR("mmap commit error: %s\n",
530 snd_strerror(commitres >= 0 ? -EPIPE : static_cast<int>(commitres)));
541 int AlsaPlayback::mixerNoMMapProc()
544 althrd_setname(MIXER_THREAD_NAME);
546 const snd_pcm_uframes_t update_size{mDevice->UpdateSize};
547 const snd_pcm_uframes_t buffer_size{mDevice->BufferSize};
548 while(!mKillNow.load(std::memory_order_acquire))
550 int state{verify_state(mPcmHandle)};
553 ERR("Invalid state detected: %s\n", snd_strerror(state));
554 mDevice->handleDisconnect("Bad state: %s", snd_strerror(state));
558 snd_pcm_sframes_t avail{snd_pcm_avail_update(mPcmHandle)};
561 ERR("available update failed: %s\n", snd_strerror(static_cast<int>(avail)));
565 if(static_cast<snd_pcm_uframes_t>(avail) > buffer_size)
567 WARN("available samples exceeds the buffer size\n");
568 snd_pcm_reset(mPcmHandle);
572 if(static_cast<snd_pcm_uframes_t>(avail) < update_size)
574 if(state != SND_PCM_STATE_RUNNING)
576 int err{snd_pcm_start(mPcmHandle)};
579 ERR("start failed: %s\n", snd_strerror(err));
583 if(snd_pcm_wait(mPcmHandle, 1000) == 0)
584 ERR("Wait timeout... buffer size too low?\n");
588 al::byte *WritePtr{mBuffer.data()};
589 avail = snd_pcm_bytes_to_frames(mPcmHandle, static_cast<ssize_t>(mBuffer.size()));
590 std::lock_guard<std::mutex> _{mMutex};
591 mDevice->renderSamples(WritePtr, static_cast<uint>(avail), mFrameStep);
594 snd_pcm_sframes_t ret{snd_pcm_writei(mPcmHandle, WritePtr,
595 static_cast<snd_pcm_uframes_t>(avail))};
600 #if ESTRPIPE != EPIPE
605 ret = snd_pcm_recover(mPcmHandle, static_cast<int>(ret), 1);
612 WritePtr += snd_pcm_frames_to_bytes(mPcmHandle, ret);
619 ret = snd_pcm_prepare(mPcmHandle);
629 void AlsaPlayback::open(const char *name)
631 std::string driver{"default"};
634 if(PlaybackDevices.empty())
635 PlaybackDevices = probe_devices(SND_PCM_STREAM_PLAYBACK);
637 auto iter = std::find_if(PlaybackDevices.cbegin(), PlaybackDevices.cend(),
638 [name](const DevMap &entry) -> bool { return entry.name == name; });
639 if(iter == PlaybackDevices.cend())
640 throw al::backend_exception{al::backend_error::NoDevice,
641 "Device name \"%s\" not found", name};
642 driver = iter->device_name;
647 if(auto driveropt = ConfigValueStr(nullptr, "alsa", "device"))
648 driver = std::move(driveropt).value();
650 TRACE("Opening device \"%s\"\n", driver.c_str());
652 snd_pcm_t *pcmHandle{};
653 int err{snd_pcm_open(&pcmHandle, driver.c_str(), SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK)};
655 throw al::backend_exception{al::backend_error::NoDevice,
656 "Could not open ALSA device \"%s\"", driver.c_str()};
658 snd_pcm_close(mPcmHandle);
659 mPcmHandle = pcmHandle;
661 /* Free alsa's global config tree. Otherwise valgrind reports a ton of leaks. */
662 snd_config_update_free_global();
664 mDevice->DeviceName = name;
667 bool AlsaPlayback::reset()
669 snd_pcm_format_t format{SND_PCM_FORMAT_UNKNOWN};
670 switch(mDevice->FmtType)
673 format = SND_PCM_FORMAT_S8;
676 format = SND_PCM_FORMAT_U8;
679 format = SND_PCM_FORMAT_S16;
682 format = SND_PCM_FORMAT_U16;
685 format = SND_PCM_FORMAT_S32;
688 format = SND_PCM_FORMAT_U32;
691 format = SND_PCM_FORMAT_FLOAT;
695 bool allowmmap{!!GetConfigValueBool(mDevice->DeviceName.c_str(), "alsa", "mmap", true)};
696 uint periodLen{static_cast<uint>(mDevice->UpdateSize * 1000000_u64 / mDevice->Frequency)};
697 uint bufferLen{static_cast<uint>(mDevice->BufferSize * 1000000_u64 / mDevice->Frequency)};
698 uint rate{mDevice->Frequency};
701 HwParamsPtr hp{CreateHwParams()};
702 #define CHECK(x) do { \
704 throw al::backend_exception{al::backend_error::DeviceError, #x " failed: %s", \
705 snd_strerror(err)}; \
707 CHECK(snd_pcm_hw_params_any(mPcmHandle, hp.get()));
708 /* set interleaved access */
710 || snd_pcm_hw_params_set_access(mPcmHandle, hp.get(), SND_PCM_ACCESS_MMAP_INTERLEAVED) < 0)
713 CHECK(snd_pcm_hw_params_set_access(mPcmHandle, hp.get(), SND_PCM_ACCESS_RW_INTERLEAVED));
715 /* test and set format (implicitly sets sample bits) */
716 if(snd_pcm_hw_params_test_format(mPcmHandle, hp.get(), format) < 0)
718 static const struct {
719 snd_pcm_format_t format;
722 { SND_PCM_FORMAT_FLOAT, DevFmtFloat },
723 { SND_PCM_FORMAT_S32, DevFmtInt },
724 { SND_PCM_FORMAT_U32, DevFmtUInt },
725 { SND_PCM_FORMAT_S16, DevFmtShort },
726 { SND_PCM_FORMAT_U16, DevFmtUShort },
727 { SND_PCM_FORMAT_S8, DevFmtByte },
728 { SND_PCM_FORMAT_U8, DevFmtUByte },
731 for(const auto &fmt : formatlist)
734 if(snd_pcm_hw_params_test_format(mPcmHandle, hp.get(), format) >= 0)
736 mDevice->FmtType = fmt.fmttype;
741 CHECK(snd_pcm_hw_params_set_format(mPcmHandle, hp.get(), format));
742 /* set channels (implicitly sets frame bits) */
743 if(snd_pcm_hw_params_set_channels(mPcmHandle, hp.get(), mDevice->channelsFromFmt()) < 0)
746 CHECK(snd_pcm_hw_params_set_channels_near(mPcmHandle, hp.get(), &numchans));
748 throw al::backend_exception{al::backend_error::DeviceError, "Got 0 device channels"};
749 if(numchans == 1) mDevice->FmtChans = DevFmtMono;
750 else mDevice->FmtChans = DevFmtStereo;
752 /* set rate (implicitly constrains period/buffer parameters) */
753 if(!GetConfigValueBool(mDevice->DeviceName.c_str(), "alsa", "allow-resampler", false)
754 || !mDevice->Flags.test(FrequencyRequest))
756 if(snd_pcm_hw_params_set_rate_resample(mPcmHandle, hp.get(), 0) < 0)
757 WARN("Failed to disable ALSA resampler\n");
759 else if(snd_pcm_hw_params_set_rate_resample(mPcmHandle, hp.get(), 1) < 0)
760 WARN("Failed to enable ALSA resampler\n");
761 CHECK(snd_pcm_hw_params_set_rate_near(mPcmHandle, hp.get(), &rate, nullptr));
762 /* set period time (implicitly constrains period/buffer parameters) */
763 if((err=snd_pcm_hw_params_set_period_time_near(mPcmHandle, hp.get(), &periodLen, nullptr)) < 0)
764 ERR("snd_pcm_hw_params_set_period_time_near failed: %s\n", snd_strerror(err));
765 /* set buffer time (implicitly sets buffer size/bytes/time and period size/bytes) */
766 if((err=snd_pcm_hw_params_set_buffer_time_near(mPcmHandle, hp.get(), &bufferLen, nullptr)) < 0)
767 ERR("snd_pcm_hw_params_set_buffer_time_near failed: %s\n", snd_strerror(err));
768 /* install and prepare hardware configuration */
769 CHECK(snd_pcm_hw_params(mPcmHandle, hp.get()));
771 /* retrieve configuration info */
772 snd_pcm_uframes_t periodSizeInFrames{};
773 snd_pcm_uframes_t bufferSizeInFrames{};
774 snd_pcm_access_t access{};
776 CHECK(snd_pcm_hw_params_get_access(hp.get(), &access));
777 CHECK(snd_pcm_hw_params_get_period_size(hp.get(), &periodSizeInFrames, nullptr));
778 CHECK(snd_pcm_hw_params_get_buffer_size(hp.get(), &bufferSizeInFrames));
779 CHECK(snd_pcm_hw_params_get_channels(hp.get(), &mFrameStep));
782 SwParamsPtr sp{CreateSwParams()};
783 CHECK(snd_pcm_sw_params_current(mPcmHandle, sp.get()));
784 CHECK(snd_pcm_sw_params_set_avail_min(mPcmHandle, sp.get(), periodSizeInFrames));
785 CHECK(snd_pcm_sw_params_set_stop_threshold(mPcmHandle, sp.get(), bufferSizeInFrames));
786 CHECK(snd_pcm_sw_params(mPcmHandle, sp.get()));
790 mDevice->BufferSize = static_cast<uint>(bufferSizeInFrames);
791 mDevice->UpdateSize = static_cast<uint>(periodSizeInFrames);
792 mDevice->Frequency = rate;
794 setDefaultChannelOrder();
799 void AlsaPlayback::start()
802 snd_pcm_access_t access{};
803 HwParamsPtr hp{CreateHwParams()};
804 #define CHECK(x) do { \
806 throw al::backend_exception{al::backend_error::DeviceError, #x " failed: %s", \
807 snd_strerror(err)}; \
809 CHECK(snd_pcm_hw_params_current(mPcmHandle, hp.get()));
810 /* retrieve configuration info */
811 CHECK(snd_pcm_hw_params_get_access(hp.get(), &access));
814 int (AlsaPlayback::*thread_func)(){};
815 if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
817 auto datalen = snd_pcm_frames_to_bytes(mPcmHandle, mDevice->UpdateSize);
818 mBuffer.resize(static_cast<size_t>(datalen));
819 thread_func = &AlsaPlayback::mixerNoMMapProc;
823 CHECK(snd_pcm_prepare(mPcmHandle));
824 thread_func = &AlsaPlayback::mixerProc;
829 mKillNow.store(false, std::memory_order_release);
830 mThread = std::thread{std::mem_fn(thread_func), this};
832 catch(std::exception& e) {
833 throw al::backend_exception{al::backend_error::DeviceError,
834 "Failed to start mixing thread: %s", e.what()};
838 void AlsaPlayback::stop()
840 if(mKillNow.exchange(true, std::memory_order_acq_rel) || !mThread.joinable())
845 int err{snd_pcm_drop(mPcmHandle)};
847 ERR("snd_pcm_drop failed: %s\n", snd_strerror(err));
850 ClockLatency AlsaPlayback::getClockLatency()
854 std::lock_guard<std::mutex> _{mMutex};
855 ret.ClockTime = GetDeviceClockTime(mDevice);
856 snd_pcm_sframes_t delay{};
857 int err{snd_pcm_delay(mPcmHandle, &delay)};
860 ERR("Failed to get pcm delay: %s\n", snd_strerror(err));
863 ret.Latency = std::chrono::seconds{std::max<snd_pcm_sframes_t>(0, delay)};
864 ret.Latency /= mDevice->Frequency;
870 struct AlsaCapture final : public BackendBase {
871 AlsaCapture(DeviceBase *device) noexcept : BackendBase{device} { }
872 ~AlsaCapture() override;
874 void open(const char *name) override;
875 void start() override;
876 void stop() override;
877 void captureSamples(al::byte *buffer, uint samples) override;
878 uint availableSamples() override;
879 ClockLatency getClockLatency() override;
881 snd_pcm_t *mPcmHandle{nullptr};
883 al::vector<al::byte> mBuffer;
885 bool mDoCapture{false};
886 RingBufferPtr mRing{nullptr};
888 snd_pcm_sframes_t mLastAvail{0};
890 DEF_NEWDEL(AlsaCapture)
893 AlsaCapture::~AlsaCapture()
896 snd_pcm_close(mPcmHandle);
897 mPcmHandle = nullptr;
901 void AlsaCapture::open(const char *name)
903 std::string driver{"default"};
906 if(CaptureDevices.empty())
907 CaptureDevices = probe_devices(SND_PCM_STREAM_CAPTURE);
909 auto iter = std::find_if(CaptureDevices.cbegin(), CaptureDevices.cend(),
910 [name](const DevMap &entry) -> bool { return entry.name == name; });
911 if(iter == CaptureDevices.cend())
912 throw al::backend_exception{al::backend_error::NoDevice,
913 "Device name \"%s\" not found", name};
914 driver = iter->device_name;
919 if(auto driveropt = ConfigValueStr(nullptr, "alsa", "capture"))
920 driver = std::move(driveropt).value();
923 TRACE("Opening device \"%s\"\n", driver.c_str());
924 int err{snd_pcm_open(&mPcmHandle, driver.c_str(), SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK)};
926 throw al::backend_exception{al::backend_error::NoDevice,
927 "Could not open ALSA device \"%s\"", driver.c_str()};
929 /* Free alsa's global config tree. Otherwise valgrind reports a ton of leaks. */
930 snd_config_update_free_global();
932 snd_pcm_format_t format{SND_PCM_FORMAT_UNKNOWN};
933 switch(mDevice->FmtType)
936 format = SND_PCM_FORMAT_S8;
939 format = SND_PCM_FORMAT_U8;
942 format = SND_PCM_FORMAT_S16;
945 format = SND_PCM_FORMAT_U16;
948 format = SND_PCM_FORMAT_S32;
951 format = SND_PCM_FORMAT_U32;
954 format = SND_PCM_FORMAT_FLOAT;
958 snd_pcm_uframes_t bufferSizeInFrames{maxu(mDevice->BufferSize, 100*mDevice->Frequency/1000)};
959 snd_pcm_uframes_t periodSizeInFrames{minu(mDevice->BufferSize, 25*mDevice->Frequency/1000)};
961 bool needring{false};
962 HwParamsPtr hp{CreateHwParams()};
963 #define CHECK(x) do { \
965 throw al::backend_exception{al::backend_error::DeviceError, #x " failed: %s", \
966 snd_strerror(err)}; \
968 CHECK(snd_pcm_hw_params_any(mPcmHandle, hp.get()));
969 /* set interleaved access */
970 CHECK(snd_pcm_hw_params_set_access(mPcmHandle, hp.get(), SND_PCM_ACCESS_RW_INTERLEAVED));
971 /* set format (implicitly sets sample bits) */
972 CHECK(snd_pcm_hw_params_set_format(mPcmHandle, hp.get(), format));
973 /* set channels (implicitly sets frame bits) */
974 CHECK(snd_pcm_hw_params_set_channels(mPcmHandle, hp.get(), mDevice->channelsFromFmt()));
975 /* set rate (implicitly constrains period/buffer parameters) */
976 CHECK(snd_pcm_hw_params_set_rate(mPcmHandle, hp.get(), mDevice->Frequency, 0));
977 /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
978 if(snd_pcm_hw_params_set_buffer_size_min(mPcmHandle, hp.get(), &bufferSizeInFrames) < 0)
980 TRACE("Buffer too large, using intermediate ring buffer\n");
982 CHECK(snd_pcm_hw_params_set_buffer_size_near(mPcmHandle, hp.get(), &bufferSizeInFrames));
984 /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
985 CHECK(snd_pcm_hw_params_set_period_size_near(mPcmHandle, hp.get(), &periodSizeInFrames, nullptr));
986 /* install and prepare hardware configuration */
987 CHECK(snd_pcm_hw_params(mPcmHandle, hp.get()));
988 /* retrieve configuration info */
989 CHECK(snd_pcm_hw_params_get_period_size(hp.get(), &periodSizeInFrames, nullptr));
994 mRing = RingBuffer::Create(mDevice->BufferSize, mDevice->frameSizeFromFmt(), false);
996 mDevice->DeviceName = name;
1000 void AlsaCapture::start()
1002 int err{snd_pcm_prepare(mPcmHandle)};
1004 throw al::backend_exception{al::backend_error::DeviceError, "snd_pcm_prepare failed: %s",
1007 err = snd_pcm_start(mPcmHandle);
1009 throw al::backend_exception{al::backend_error::DeviceError, "snd_pcm_start failed: %s",
1015 void AlsaCapture::stop()
1017 /* OpenAL requires access to unread audio after stopping, but ALSA's
1018 * snd_pcm_drain is unreliable and snd_pcm_drop drops it. Capture what's
1019 * available now so it'll be available later after the drop.
1021 uint avail{availableSamples()};
1022 if(!mRing && avail > 0)
1024 /* The ring buffer implicitly captures when checking availability.
1025 * Direct access needs to explicitly capture it into temp storage.
1027 auto temp = al::vector<al::byte>(
1028 static_cast<size_t>(snd_pcm_frames_to_bytes(mPcmHandle, avail)));
1029 captureSamples(temp.data(), avail);
1030 mBuffer = std::move(temp);
1032 int err{snd_pcm_drop(mPcmHandle)};
1034 ERR("drop failed: %s\n", snd_strerror(err));
1038 void AlsaCapture::captureSamples(al::byte *buffer, uint samples)
1042 mRing->read(buffer, samples);
1046 mLastAvail -= samples;
1047 while(mDevice->Connected.load(std::memory_order_acquire) && samples > 0)
1049 snd_pcm_sframes_t amt{0};
1051 if(!mBuffer.empty())
1053 /* First get any data stored from the last stop */
1054 amt = snd_pcm_bytes_to_frames(mPcmHandle, static_cast<ssize_t>(mBuffer.size()));
1055 if(static_cast<snd_pcm_uframes_t>(amt) > samples) amt = samples;
1057 amt = snd_pcm_frames_to_bytes(mPcmHandle, amt);
1058 std::copy_n(mBuffer.begin(), amt, buffer);
1060 mBuffer.erase(mBuffer.begin(), mBuffer.begin()+amt);
1061 amt = snd_pcm_bytes_to_frames(mPcmHandle, amt);
1064 amt = snd_pcm_readi(mPcmHandle, buffer, samples);
1067 ERR("read error: %s\n", snd_strerror(static_cast<int>(amt)));
1071 if((amt=snd_pcm_recover(mPcmHandle, static_cast<int>(amt), 1)) >= 0)
1073 amt = snd_pcm_start(mPcmHandle);
1075 amt = snd_pcm_avail_update(mPcmHandle);
1079 const char *err{snd_strerror(static_cast<int>(amt))};
1080 ERR("restore error: %s\n", err);
1081 mDevice->handleDisconnect("Capture recovery failure: %s", err);
1084 /* If the amount available is less than what's asked, we lost it
1085 * during recovery. So just give silence instead. */
1086 if(static_cast<snd_pcm_uframes_t>(amt) < samples)
1091 buffer = buffer + amt;
1092 samples -= static_cast<uint>(amt);
1095 std::fill_n(buffer, snd_pcm_frames_to_bytes(mPcmHandle, samples),
1096 al::byte((mDevice->FmtType == DevFmtUByte) ? 0x80 : 0));
1099 uint AlsaCapture::availableSamples()
1101 snd_pcm_sframes_t avail{0};
1102 if(mDevice->Connected.load(std::memory_order_acquire) && mDoCapture)
1103 avail = snd_pcm_avail_update(mPcmHandle);
1106 ERR("avail update failed: %s\n", snd_strerror(static_cast<int>(avail)));
1108 if((avail=snd_pcm_recover(mPcmHandle, static_cast<int>(avail), 1)) >= 0)
1111 avail = snd_pcm_start(mPcmHandle);
1113 avail = snd_pcm_avail_update(mPcmHandle);
1117 const char *err{snd_strerror(static_cast<int>(avail))};
1118 ERR("restore error: %s\n", err);
1119 mDevice->handleDisconnect("Capture recovery failure: %s", err);
1125 if(avail < 0) avail = 0;
1126 avail += snd_pcm_bytes_to_frames(mPcmHandle, static_cast<ssize_t>(mBuffer.size()));
1127 if(avail > mLastAvail) mLastAvail = avail;
1128 return static_cast<uint>(mLastAvail);
1133 auto vec = mRing->getWriteVector();
1134 if(vec.first.len == 0) break;
1136 snd_pcm_sframes_t amt{std::min(static_cast<snd_pcm_sframes_t>(vec.first.len), avail)};
1137 amt = snd_pcm_readi(mPcmHandle, vec.first.buf, static_cast<snd_pcm_uframes_t>(amt));
1140 ERR("read error: %s\n", snd_strerror(static_cast<int>(amt)));
1144 if((amt=snd_pcm_recover(mPcmHandle, static_cast<int>(amt), 1)) >= 0)
1147 amt = snd_pcm_start(mPcmHandle);
1149 amt = snd_pcm_avail_update(mPcmHandle);
1153 const char *err{snd_strerror(static_cast<int>(amt))};
1154 ERR("restore error: %s\n", err);
1155 mDevice->handleDisconnect("Capture recovery failure: %s", err);
1162 mRing->writeAdvance(static_cast<snd_pcm_uframes_t>(amt));
1166 return static_cast<uint>(mRing->readSpace());
1169 ClockLatency AlsaCapture::getClockLatency()
1173 ret.ClockTime = GetDeviceClockTime(mDevice);
1174 snd_pcm_sframes_t delay{};
1175 int err{snd_pcm_delay(mPcmHandle, &delay)};
1178 ERR("Failed to get pcm delay: %s\n", snd_strerror(err));
1181 ret.Latency = std::chrono::seconds{std::max<snd_pcm_sframes_t>(0, delay)};
1182 ret.Latency /= mDevice->Frequency;
1190 bool AlsaBackendFactory::init()
1197 std::string missing_funcs;
1199 alsa_handle = LoadLib("libasound.so.2");
1202 WARN("Failed to load %s\n", "libasound.so.2");
1207 #define LOAD_FUNC(f) do { \
1208 p##f = reinterpret_cast<decltype(p##f)>(GetSymbol(alsa_handle, #f)); \
1209 if(p##f == nullptr) { \
1211 missing_funcs += "\n" #f; \
1214 ALSA_FUNCS(LOAD_FUNC);
1219 WARN("Missing expected functions:%s\n", missing_funcs.c_str());
1220 CloseLib(alsa_handle);
1221 alsa_handle = nullptr;
1229 bool AlsaBackendFactory::querySupport(BackendType type)
1230 { return (type == BackendType::Playback || type == BackendType::Capture); }
1232 std::string AlsaBackendFactory::probe(BackendType type)
1234 std::string outnames;
1236 auto add_device = [&outnames](const DevMap &entry) -> void
1238 /* +1 to also append the null char (to ensure a null-separated list and
1239 * double-null terminated list).
1241 outnames.append(entry.name.c_str(), entry.name.length()+1);
1245 case BackendType::Playback:
1246 PlaybackDevices = probe_devices(SND_PCM_STREAM_PLAYBACK);
1247 std::for_each(PlaybackDevices.cbegin(), PlaybackDevices.cend(), add_device);
1250 case BackendType::Capture:
1251 CaptureDevices = probe_devices(SND_PCM_STREAM_CAPTURE);
1252 std::for_each(CaptureDevices.cbegin(), CaptureDevices.cend(), add_device);
1259 BackendPtr AlsaBackendFactory::createBackend(DeviceBase *device, BackendType type)
1261 if(type == BackendType::Playback)
1262 return BackendPtr{new AlsaPlayback{device}};
1263 if(type == BackendType::Capture)
1264 return BackendPtr{new AlsaCapture{device}};
1268 BackendFactory &AlsaBackendFactory::getFactory()
1270 static AlsaBackendFactory factory{};