1 #include "alsa_input.h"
3 #include <alsa/error.h>
4 #include <alsa/global.h>
14 #include "alsa_pool.h"
15 #include "bmusb/bmusb.h"
18 using namespace std::chrono;
19 using namespace std::placeholders;
21 #define RETURN_ON_ERROR(msg, expr) do { \
24 fprintf(stderr, "[%s] " msg ": %s\n", device.c_str(), snd_strerror(err)); \
25 if (err == -ENODEV) return CaptureEndReason::DEVICE_GONE; \
26 return CaptureEndReason::OTHER_ERROR; \
30 #define RETURN_FALSE_ON_ERROR(msg, expr) do { \
33 fprintf(stderr, "[%s] " msg ": %s\n", device.c_str(), snd_strerror(err)); \
38 #define WARN_ON_ERROR(msg, expr) do { \
41 fprintf(stderr, "[%s] " msg ": %s\n", device.c_str(), snd_strerror(err)); \
45 ALSAInput::ALSAInput(const char *device, unsigned sample_rate, unsigned num_channels, audio_callback_t audio_callback, ALSAPool *parent_pool, unsigned internal_dev_index)
47 sample_rate(sample_rate),
48 num_channels(num_channels),
49 audio_callback(audio_callback),
50 parent_pool(parent_pool),
51 internal_dev_index(internal_dev_index)
55 bool ALSAInput::open_device()
57 RETURN_FALSE_ON_ERROR("snd_pcm_open()", snd_pcm_open(&pcm_handle, device.c_str(), SND_PCM_STREAM_CAPTURE, 0));
60 snd_pcm_hw_params_t *hw_params;
61 snd_pcm_hw_params_alloca(&hw_params);
62 if (!set_base_params(device.c_str(), pcm_handle, hw_params, &sample_rate)) {
66 RETURN_FALSE_ON_ERROR("snd_pcm_hw_params_set_channels()", snd_pcm_hw_params_set_channels(pcm_handle, hw_params, num_channels));
68 // Fragment size of 64 samples (about 1 ms at 48 kHz; a frame at 60
69 // fps/48 kHz is 800 samples.) We ask for 64 such periods in our buffer
70 // (~85 ms buffer); more than that, and our jitter is probably so high
71 // that the resampling queue can't keep up anyway.
72 // The entire thing with periods and such is a bit mysterious to me;
73 // seemingly I can get 96 frames at a time with no problems even if
74 // the period size is 64 frames. And if I set num_periods to e.g. 1,
75 // I can't have a big buffer.
78 RETURN_FALSE_ON_ERROR("snd_pcm_hw_params_set_periods_near()", snd_pcm_hw_params_set_periods_near(pcm_handle, hw_params, &num_periods, &dir));
81 RETURN_FALSE_ON_ERROR("snd_pcm_hw_params_set_period_size_near()", snd_pcm_hw_params_set_period_size_near(pcm_handle, hw_params, &period_size, &dir));
82 buffer_frames = 64 * 64;
83 RETURN_FALSE_ON_ERROR("snd_pcm_hw_params_set_buffer_size_near()", snd_pcm_hw_params_set_buffer_size_near(pcm_handle, hw_params, &buffer_frames));
84 RETURN_FALSE_ON_ERROR("snd_pcm_hw_params()", snd_pcm_hw_params(pcm_handle, hw_params));
85 //snd_pcm_hw_params_free(hw_params);
87 // Figure out which format the card actually chose.
88 RETURN_FALSE_ON_ERROR("snd_pcm_hw_params_current()", snd_pcm_hw_params_current(pcm_handle, hw_params));
89 snd_pcm_format_t chosen_format;
90 RETURN_FALSE_ON_ERROR("snd_pcm_hw_params_get_format()", snd_pcm_hw_params_get_format(hw_params, &chosen_format));
92 audio_format.num_channels = num_channels;
93 audio_format.bits_per_sample = 0;
94 switch (chosen_format) {
95 case SND_PCM_FORMAT_S16_LE:
96 audio_format.bits_per_sample = 16;
98 case SND_PCM_FORMAT_S24_LE:
99 audio_format.bits_per_sample = 24;
101 case SND_PCM_FORMAT_S32_LE:
102 audio_format.bits_per_sample = 32;
107 audio_format.sample_rate = sample_rate;
108 //printf("num_periods=%u period_size=%u buffer_frames=%u sample_rate=%u bits_per_sample=%d\n",
109 // num_periods, unsigned(period_size), unsigned(buffer_frames), sample_rate, audio_format.bits_per_sample);
111 buffer.reset(new uint8_t[buffer_frames * num_channels * audio_format.bits_per_sample / 8]);
113 snd_pcm_sw_params_t *sw_params;
114 snd_pcm_sw_params_alloca(&sw_params);
115 RETURN_FALSE_ON_ERROR("snd_pcm_sw_params_current()", snd_pcm_sw_params_current(pcm_handle, sw_params));
116 RETURN_FALSE_ON_ERROR("snd_pcm_sw_params_set_start_threshold", snd_pcm_sw_params_set_start_threshold(pcm_handle, sw_params, num_periods * period_size / 2));
117 RETURN_FALSE_ON_ERROR("snd_pcm_sw_params_set_tstamp_mode", snd_pcm_sw_params_set_tstamp_mode(pcm_handle, sw_params, SND_PCM_TSTAMP_ENABLE));
118 RETURN_FALSE_ON_ERROR("snd_pcm_sw_params_set_tstamp_type", snd_pcm_sw_params_set_tstamp_type(pcm_handle, sw_params, SND_PCM_TSTAMP_TYPE_MONOTONIC));
120 RETURN_FALSE_ON_ERROR("snd_pcm_sw_params()", snd_pcm_sw_params(pcm_handle, sw_params));
122 RETURN_FALSE_ON_ERROR("snd_pcm_nonblock()", snd_pcm_nonblock(pcm_handle, 1));
123 RETURN_FALSE_ON_ERROR("snd_pcm_prepare()", snd_pcm_prepare(pcm_handle));
127 bool ALSAInput::set_base_params(const char *device_name, snd_pcm_t *pcm_handle, snd_pcm_hw_params_t *hw_params, unsigned *sample_rate)
130 err = snd_pcm_hw_params_any(pcm_handle, hw_params);
132 fprintf(stderr, "[%s] snd_pcm_hw_params_any(): %s\n", device_name, snd_strerror(err));
135 err = snd_pcm_hw_params_set_access(pcm_handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED);
137 fprintf(stderr, "[%s] snd_pcm_hw_params_set_access(): %s\n", device_name, snd_strerror(err));
140 snd_pcm_format_mask_t *format_mask;
141 snd_pcm_format_mask_alloca(&format_mask);
142 snd_pcm_format_mask_set(format_mask, SND_PCM_FORMAT_S16_LE);
143 snd_pcm_format_mask_set(format_mask, SND_PCM_FORMAT_S24_LE);
144 snd_pcm_format_mask_set(format_mask, SND_PCM_FORMAT_S32_LE);
145 err = snd_pcm_hw_params_set_format_mask(pcm_handle, hw_params, format_mask);
147 fprintf(stderr, "[%s] snd_pcm_hw_params_set_format_mask(): %s\n", device_name, snd_strerror(err));
150 err = snd_pcm_hw_params_set_rate_near(pcm_handle, hw_params, sample_rate, 0);
152 fprintf(stderr, "[%s] snd_pcm_hw_params_set_rate_near(): %s\n", device_name, snd_strerror(err));
158 ALSAInput::~ALSAInput()
161 WARN_ON_ERROR("snd_pcm_close()", snd_pcm_close(pcm_handle));
165 void ALSAInput::start_capture_thread()
167 assert(!device.empty());
168 should_quit.unquit();
169 capture_thread = thread(&ALSAInput::capture_thread_func, this);
172 void ALSAInput::stop_capture_thread()
175 capture_thread.join();
178 void ALSAInput::capture_thread_func()
181 char thread_name[16];
182 snprintf(thread_name, sizeof(thread_name), "ALSA_C_%d", internal_dev_index);
183 pthread_setname_np(pthread_self(), thread_name);
188 parent_pool->set_card_state(internal_dev_index, ALSAPool::Device::State::STARTING);
190 // If the device hasn't been opened already, we need to do so
191 // before we can capture.
192 while (!should_quit.should_quit() && pcm_handle == nullptr) {
193 if (!open_device()) {
194 fprintf(stderr, "[%s] Waiting one second and trying again...\n",
196 should_quit.sleep_for(seconds(1));
200 if (should_quit.should_quit()) {
201 // Don't call free_card(); that would be a deadlock.
203 WARN_ON_ERROR("snd_pcm_close()", snd_pcm_close(pcm_handle));
205 pcm_handle = nullptr;
209 // Do the actual capture. (Termination condition within loop.)
211 switch (do_capture()) {
212 case CaptureEndReason::REQUESTED_QUIT:
213 // Don't call free_card(); that would be a deadlock.
214 WARN_ON_ERROR("snd_pcm_close()", snd_pcm_close(pcm_handle));
215 pcm_handle = nullptr;
217 case CaptureEndReason::DEVICE_GONE:
218 parent_pool->free_card(internal_dev_index);
219 WARN_ON_ERROR("snd_pcm_close()", snd_pcm_close(pcm_handle));
220 pcm_handle = nullptr;
222 case CaptureEndReason::OTHER_ERROR:
223 parent_pool->set_card_state(internal_dev_index, ALSAPool::Device::State::STARTING);
224 fprintf(stderr, "[%s] Sleeping one second and restarting capture...\n",
226 should_quit.sleep_for(seconds(1));
232 ALSAInput::CaptureEndReason ALSAInput::do_capture()
234 parent_pool->set_card_state(internal_dev_index, ALSAPool::Device::State::STARTING);
235 RETURN_ON_ERROR("snd_pcm_start()", snd_pcm_start(pcm_handle));
236 parent_pool->set_card_state(internal_dev_index, ALSAPool::Device::State::RUNNING);
238 snd_pcm_status_t *status;
239 snd_pcm_status_alloca(&status);
240 while (!should_quit.should_quit()) {
241 int ret = snd_pcm_wait(pcm_handle, /*timeout=*/100);
242 if (ret == 0) continue; // Timeout.
244 fprintf(stderr, "[%s] ALSA overrun\n", device.c_str());
245 snd_pcm_prepare(pcm_handle);
246 snd_pcm_start(pcm_handle);
249 RETURN_ON_ERROR("snd_pcm_wait()", ret);
251 ret = snd_pcm_status(pcm_handle, status);
252 RETURN_ON_ERROR("snd_pcm_status()", ret);
254 snd_pcm_sframes_t avail = snd_pcm_status_get_avail(status);
255 snd_htimestamp_t alsa_ts;
256 snd_pcm_status_get_htstamp(status, &alsa_ts);
258 snd_pcm_sframes_t frames = snd_pcm_readi(pcm_handle, buffer.get(), avail);
259 if (frames == -EPIPE) {
260 fprintf(stderr, "[%s] ALSA overrun\n", device.c_str());
261 snd_pcm_prepare(pcm_handle);
262 snd_pcm_start(pcm_handle);
266 fprintf(stderr, "snd_pcm_readi() returned 0\n");
269 RETURN_ON_ERROR("snd_pcm_readi()", frames);
271 // NOTE: This assumes steady_clock::time_point is the same as clock_gettime(CLOCK_MONOTONIC).
272 const steady_clock::time_point ts = steady_clock::time_point(seconds(alsa_ts.tv_sec) + nanoseconds(alsa_ts.tv_nsec));
275 if (should_quit.should_quit()) return CaptureEndReason::REQUESTED_QUIT;
276 success = audio_callback(buffer.get(), frames, audio_format, ts);
279 return CaptureEndReason::REQUESTED_QUIT;