]> git.sesse.net Git - nageru/blob - nageru/alsa_input.cpp
Add support for V4L2 output.
[nageru] / nageru / alsa_input.cpp
1 #include "alsa_input.h"
2
3 #include <alsa/error.h>
4 #include <assert.h>
5 #include <errno.h>
6 #include <stdio.h>
7 #include <unistd.h>
8 #include <cstdint>
9
10 #include "alsa_pool.h"
11 #include "bmusb/bmusb.h"
12 #include "shared/timebase.h"
13
14 using namespace std;
15 using namespace std::chrono;
16 using namespace std::placeholders;
17
18 #define RETURN_ON_ERROR(msg, expr) do {                                                    \
19         int err = (expr);                                                                  \
20         if (err < 0) {                                                                     \
21                 fprintf(stderr, "[%s] " msg ": %s\n", device.c_str(), snd_strerror(err));  \
22                 if (err == -ENODEV) return CaptureEndReason::DEVICE_GONE;                  \
23                 return CaptureEndReason::OTHER_ERROR;                                      \
24         }                                                                                  \
25 } while (false)
26
27 #define RETURN_FALSE_ON_ERROR(msg, expr) do {                                              \
28         int err = (expr);                                                                  \
29         if (err < 0) {                                                                     \
30                 fprintf(stderr, "[%s] " msg ": %s\n", device.c_str(), snd_strerror(err));  \
31                 return false;                                                              \
32         }                                                                                  \
33 } while (false)
34
35 #define WARN_ON_ERROR(msg, expr) do {                                                      \
36         int err = (expr);                                                                  \
37         if (err < 0) {                                                                     \
38                 fprintf(stderr, "[%s] " msg ": %s\n", device.c_str(), snd_strerror(err));  \
39         }                                                                                  \
40 } while (false)
41
42 ALSAInput::ALSAInput(const char *device, unsigned sample_rate, unsigned num_channels, audio_callback_t audio_callback, ALSAPool *parent_pool, unsigned internal_dev_index)
43         : device(device),
44           sample_rate(sample_rate),
45           num_channels(num_channels),
46           audio_callback(audio_callback),
47           parent_pool(parent_pool),
48           internal_dev_index(internal_dev_index)
49 {
50 }
51
52 bool ALSAInput::open_device()
53 {
54         RETURN_FALSE_ON_ERROR("snd_pcm_open()", snd_pcm_open(&pcm_handle, device.c_str(), SND_PCM_STREAM_CAPTURE, 0));
55
56         // Set format.
57         snd_pcm_hw_params_t *hw_params;
58         snd_pcm_hw_params_alloca(&hw_params);
59         if (!set_base_params(device.c_str(), pcm_handle, hw_params, &sample_rate)) {
60                 return false;
61         }
62
63         RETURN_FALSE_ON_ERROR("snd_pcm_hw_params_set_channels()", snd_pcm_hw_params_set_channels(pcm_handle, hw_params, num_channels));
64
65         // Fragment size of 64 samples (about 1 ms at 48 kHz; a frame at 60
66         // fps/48 kHz is 800 samples.) We ask for 64 such periods in our buffer
67         // (~85 ms buffer); more than that, and our jitter is probably so high
68         // that the resampling queue can't keep up anyway.
69         // The entire thing with periods and such is a bit mysterious to me;
70         // seemingly I can get 96 frames at a time with no problems even if
71         // the period size is 64 frames. And if I set num_periods to e.g. 1,
72         // I can't have a big buffer.
73         num_periods = 16;
74         int dir = 0;
75         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));
76         period_size = 64;
77         dir = 0;
78         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));
79         buffer_frames = 64 * 64;
80         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));
81         RETURN_FALSE_ON_ERROR("snd_pcm_hw_params()", snd_pcm_hw_params(pcm_handle, hw_params));
82         //snd_pcm_hw_params_free(hw_params);
83
84         // Figure out which format the card actually chose.
85         RETURN_FALSE_ON_ERROR("snd_pcm_hw_params_current()", snd_pcm_hw_params_current(pcm_handle, hw_params));
86         snd_pcm_format_t chosen_format;
87         RETURN_FALSE_ON_ERROR("snd_pcm_hw_params_get_format()", snd_pcm_hw_params_get_format(hw_params, &chosen_format));
88
89         audio_format.num_channels = num_channels;
90         audio_format.bits_per_sample = 0;
91         switch (chosen_format) {
92         case SND_PCM_FORMAT_S16_LE:
93                 audio_format.bits_per_sample = 16;
94                 break;
95         case SND_PCM_FORMAT_S24_LE:
96                 audio_format.bits_per_sample = 24;
97                 break;
98         case SND_PCM_FORMAT_S32_LE:
99                 audio_format.bits_per_sample = 32;
100                 break;
101         default:
102                 assert(false);
103         }
104         audio_format.sample_rate = sample_rate;
105         //printf("num_periods=%u period_size=%u buffer_frames=%u sample_rate=%u bits_per_sample=%d\n",
106         //      num_periods, unsigned(period_size), unsigned(buffer_frames), sample_rate, audio_format.bits_per_sample);
107
108         buffer.reset(new uint8_t[buffer_frames * num_channels * audio_format.bits_per_sample / 8]);
109
110         snd_pcm_sw_params_t *sw_params;
111         snd_pcm_sw_params_alloca(&sw_params);
112         RETURN_FALSE_ON_ERROR("snd_pcm_sw_params_current()", snd_pcm_sw_params_current(pcm_handle, sw_params));
113         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));
114         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));
115         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));
116
117         RETURN_FALSE_ON_ERROR("snd_pcm_sw_params()", snd_pcm_sw_params(pcm_handle, sw_params));
118
119         RETURN_FALSE_ON_ERROR("snd_pcm_nonblock()", snd_pcm_nonblock(pcm_handle, 1));
120         RETURN_FALSE_ON_ERROR("snd_pcm_prepare()", snd_pcm_prepare(pcm_handle));
121         return true;
122 }
123
124 bool ALSAInput::set_base_params(const char *device_name, snd_pcm_t *pcm_handle, snd_pcm_hw_params_t *hw_params, unsigned *sample_rate)
125 {
126         int err;
127         err = snd_pcm_hw_params_any(pcm_handle, hw_params);
128         if (err < 0) {
129                 fprintf(stderr, "[%s] snd_pcm_hw_params_any(): %s\n", device_name, snd_strerror(err));
130                 return false;
131         }
132         err = snd_pcm_hw_params_set_access(pcm_handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED);
133         if (err < 0) {
134                 fprintf(stderr, "[%s] snd_pcm_hw_params_set_access(): %s\n", device_name, snd_strerror(err));
135                 return false;
136         }
137         snd_pcm_format_mask_t *format_mask;
138         snd_pcm_format_mask_alloca(&format_mask);
139         snd_pcm_format_mask_set(format_mask, SND_PCM_FORMAT_S16_LE);
140         snd_pcm_format_mask_set(format_mask, SND_PCM_FORMAT_S24_LE);
141         snd_pcm_format_mask_set(format_mask, SND_PCM_FORMAT_S32_LE);
142         err = snd_pcm_hw_params_set_format_mask(pcm_handle, hw_params, format_mask);
143         if (err < 0) {
144                 fprintf(stderr, "[%s] snd_pcm_hw_params_set_format_mask(): %s\n", device_name, snd_strerror(err));
145                 return false;
146         }
147         err = snd_pcm_hw_params_set_rate_near(pcm_handle, hw_params, sample_rate, 0);
148         if (err < 0) {
149                 fprintf(stderr, "[%s] snd_pcm_hw_params_set_rate_near(): %s\n", device_name, snd_strerror(err));
150                 return false;
151         }
152         return true;
153 }
154
155 ALSAInput::~ALSAInput()
156 {
157         if (pcm_handle) {
158                 WARN_ON_ERROR("snd_pcm_close()", snd_pcm_close(pcm_handle));
159         }
160 }
161
162 void ALSAInput::start_capture_thread()
163 {
164         assert(!device.empty());
165         should_quit.unquit();
166         capture_thread = thread(&ALSAInput::capture_thread_func, this);
167 }
168
169 void ALSAInput::stop_capture_thread()
170 {
171         should_quit.quit();
172         capture_thread.join();
173 }
174
175 void ALSAInput::capture_thread_func()
176 {
177         if (!done_init) {
178                 char thread_name[16];
179                 snprintf(thread_name, sizeof(thread_name), "ALSA_C_%d", internal_dev_index);
180                 pthread_setname_np(pthread_self(), thread_name);
181
182                 done_init = true;
183         }
184
185         parent_pool->set_card_state(internal_dev_index, ALSAPool::Device::State::STARTING);
186
187         // If the device hasn't been opened already, we need to do so
188         // before we can capture.
189         while (!should_quit.should_quit() && pcm_handle == nullptr) {
190                 if (!open_device()) {
191                         fprintf(stderr, "[%s] Waiting one second and trying again...\n",
192                                 device.c_str());
193                         should_quit.sleep_for(seconds(1));
194                 }
195         }
196
197         if (should_quit.should_quit()) {
198                 // Don't call free_card(); that would be a deadlock.
199                 if (pcm_handle) {
200                         WARN_ON_ERROR("snd_pcm_close()", snd_pcm_close(pcm_handle));
201                 }
202                 pcm_handle = nullptr;
203                 return;
204         }
205
206         // Do the actual capture. (Termination condition within loop.)
207         for ( ;; ) {
208                 switch (do_capture()) {
209                 case CaptureEndReason::REQUESTED_QUIT:
210                         // Don't call free_card(); that would be a deadlock.
211                         WARN_ON_ERROR("snd_pcm_close()", snd_pcm_close(pcm_handle));
212                         pcm_handle = nullptr;
213                         return;
214                 case CaptureEndReason::DEVICE_GONE:
215                         parent_pool->free_card(internal_dev_index);
216                         WARN_ON_ERROR("snd_pcm_close()", snd_pcm_close(pcm_handle));
217                         pcm_handle = nullptr;
218                         return;
219                 case CaptureEndReason::OTHER_ERROR:
220                         parent_pool->set_card_state(internal_dev_index, ALSAPool::Device::State::STARTING);
221                         fprintf(stderr, "[%s] Sleeping one second and restarting capture...\n",
222                                 device.c_str());
223                         should_quit.sleep_for(seconds(1));
224                         break;
225                 }
226         }
227 }
228
229 ALSAInput::CaptureEndReason ALSAInput::do_capture()
230 {
231         parent_pool->set_card_state(internal_dev_index, ALSAPool::Device::State::STARTING);
232         RETURN_ON_ERROR("snd_pcm_start()", snd_pcm_start(pcm_handle));
233         parent_pool->set_card_state(internal_dev_index, ALSAPool::Device::State::RUNNING);
234
235         snd_pcm_status_t *status;
236         snd_pcm_status_alloca(&status);
237         while (!should_quit.should_quit()) {
238                 int ret = snd_pcm_wait(pcm_handle, /*timeout=*/100);
239                 if (ret == 0) continue;  // Timeout.
240                 if (ret == -EPIPE) {
241                         fprintf(stderr, "[%s] ALSA overrun\n", device.c_str());
242                         snd_pcm_prepare(pcm_handle);
243                         snd_pcm_start(pcm_handle);
244                         continue;
245                 }
246                 RETURN_ON_ERROR("snd_pcm_wait()", ret);
247
248                 ret = snd_pcm_status(pcm_handle, status);
249                 RETURN_ON_ERROR("snd_pcm_status()", ret);
250
251                 snd_pcm_sframes_t avail = snd_pcm_status_get_avail(status);
252                 snd_htimestamp_t alsa_ts;
253                 snd_pcm_status_get_htstamp(status, &alsa_ts);
254
255                 snd_pcm_sframes_t frames = snd_pcm_readi(pcm_handle, buffer.get(), avail);
256                 if (frames == -EPIPE) {
257                         fprintf(stderr, "[%s] ALSA overrun\n", device.c_str());
258                         snd_pcm_prepare(pcm_handle);
259                         snd_pcm_start(pcm_handle);
260                         continue;
261                 }
262                 if (frames == 0) {
263                         fprintf(stderr, "snd_pcm_readi() returned 0\n");
264                         break;
265                 }
266                 RETURN_ON_ERROR("snd_pcm_readi()", frames);
267
268                 // NOTE: This assumes steady_clock::time_point is the same as clock_gettime(CLOCK_MONOTONIC).
269                 const steady_clock::time_point ts = steady_clock::time_point(seconds(alsa_ts.tv_sec) + nanoseconds(alsa_ts.tv_nsec));
270                 bool success;
271                 do {
272                         if (should_quit.should_quit()) return CaptureEndReason::REQUESTED_QUIT;
273                         success = audio_callback(buffer.get(), frames, audio_format, ts);
274                 } while (!success);
275         }
276         return CaptureEndReason::REQUESTED_QUIT;
277 }