finish up changelog for release
[osspd.git] / ossp-alsap.c
1 /*
2  * ossp-alsap - ossp DSP slave which forwards to alsa
3  *
4  * Copyright (C)      2009 Maarten Lankhorst <m.b.lankhorst@gmail.com>
5  *
6  * This file is released under the GPLv2.
7  *
8  * Why an alsa plugin as well? Just to show how much
9  * the alsa userspace api sucks ;-)
10  */
11
12 #include <assert.h>
13 #include <errno.h>
14 #include <fcntl.h>
15 #include <getopt.h>
16 #include <libgen.h>
17 #include <limits.h>
18 #include <poll.h>
19 #include <pthread.h>
20 #include <pwd.h>
21 #include <stdarg.h>
22 #include <stdio.h>
23 #include <string.h>
24 #include <sys/stat.h>
25 #include <sys/types.h>
26 #include <unistd.h>
27
28 #include <alsa/asoundlib.h>
29 #include <sys/soundcard.h>
30
31 #include "ossp-slave.h"
32
33 enum {
34         AFMT_FLOAT              = 0x00004000,
35         AFMT_S32_LE             = 0x00001000,
36         AFMT_S32_BE             = 0x00002000,
37 };
38
39 static size_t page_size;
40
41 /* alsa structures */
42 static snd_pcm_t *pcm[2];
43 static snd_pcm_hw_params_t *hw_params;
44 static snd_pcm_sw_params_t *sw_params;
45 static int block;
46
47 static unsigned int byte_counter[2];
48 static snd_pcm_uframes_t mmap_pos[2];
49 static int stream_corked[2];
50 static int stream_notify;
51
52 static struct format {
53         snd_pcm_format_t format;
54         snd_pcm_sframes_t rate;
55         int channels;
56 } hw_format = { SND_PCM_FORMAT_U8, 8000, 1 };
57
58 #if 0
59 /* future mmap stuff */
60 static size_t mmap_raw_size, mmap_size;
61 static int mmap_fd[2] = { -1, -1 };
62 static void *mmap_map[2];
63 static uint64_t mmap_idx[2];            /* mmap pointer */
64 static uint64_t mmap_last_idx[2];       /* last idx for get_ptr */
65 static struct ring_buf mmap_stg[2];     /* staging ring buffer */
66 static size_t mmap_lead[2];             /* lead bytes */
67 static int mmap_sync[2];                /* sync with backend stream */
68 #endif
69
70 static snd_pcm_format_t fmt_oss_to_alsa(int fmt)
71 {
72         switch (fmt) {
73         case AFMT_U8:                   return SND_PCM_FORMAT_U8;
74         case AFMT_A_LAW:                return SND_PCM_FORMAT_A_LAW;
75         case AFMT_MU_LAW:               return SND_PCM_FORMAT_MU_LAW;
76         case AFMT_S16_LE:               return SND_PCM_FORMAT_S16_LE;
77         case AFMT_S16_BE:               return SND_PCM_FORMAT_S16_BE;
78         case AFMT_FLOAT:                return SND_PCM_FORMAT_FLOAT;
79         case AFMT_S32_LE:               return SND_PCM_FORMAT_S32_LE;
80         case AFMT_S32_BE:               return SND_PCM_FORMAT_S32_BE;
81         default:                        return SND_PCM_FORMAT_U8;
82         }
83 }
84
85 static int fmt_alsa_to_oss(snd_pcm_format_t fmt)
86 {
87         switch (fmt) {
88         case SND_PCM_FORMAT_U8:         return AFMT_U8;
89         case SND_PCM_FORMAT_A_LAW:      return AFMT_A_LAW;
90         case SND_PCM_FORMAT_MU_LAW:     return AFMT_MU_LAW;
91         case SND_PCM_FORMAT_S16_LE:     return AFMT_S16_LE;
92         case SND_PCM_FORMAT_S16_BE:     return AFMT_S16_BE;
93         case SND_PCM_FORMAT_FLOAT:      return AFMT_FLOAT;
94         case SND_PCM_FORMAT_S32_LE:     return AFMT_S32_LE;
95         case SND_PCM_FORMAT_S32_BE:     return AFMT_S32_BE;
96         default:                        return AFMT_U8;
97         }
98 }
99
100 static void flush_streams(int drain)
101 {
102         /* FIXME: snd_pcm_drain appears to be able to deadlock,
103          * always drop or check state? */
104         if (drain) {
105                 if (pcm[PLAY])
106                         snd_pcm_drain(pcm[PLAY]);
107                 if (pcm[REC])
108                         snd_pcm_drain(pcm[REC]);
109         } else {
110                 if (pcm[PLAY])
111                         snd_pcm_drop(pcm[PLAY]);
112                 if (pcm[REC])
113                         snd_pcm_drop(pcm[REC]);
114         }
115
116         /* XXX: Really needed? */
117 #if 0
118         if (pcm[PLAY]) {
119                 snd_pcm_close(pcm[PLAY]);
120                 snd_pcm_open(&pcm[PLAY], "default",
121                              SND_PCM_STREAM_PLAYBACK, block);
122         }
123         if (pcm[REC]) {
124                 snd_pcm_close(pcm[REC]);
125                 snd_pcm_open(&pcm[REC], "default",
126                              SND_PCM_STREAM_CAPTURE, block);
127         }
128 #endif
129 }
130
131 static void kill_streams(void)
132 {
133         flush_streams(0);
134 }
135
136 static int trigger_streams(int play, int rec)
137 {
138         int ret = 0;
139
140         if (pcm[PLAY] && play >= 0) {
141                 ret = snd_pcm_sw_params_set_start_threshold(pcm[PLAY], sw_params,
142                                                            play ? 1 : -1);
143                 if (ret >= 0)
144                         snd_pcm_sw_params(pcm[PLAY], sw_params);
145         }
146         if (ret >= 0 && pcm[REC] && rec >= 0) {
147                 ret = snd_pcm_sw_params_set_start_threshold(pcm[REC], sw_params,
148                                                             rec ? 1 : -1);
149                 if (ret >= 0)
150                         snd_pcm_sw_params(pcm[REC], sw_params);
151         }
152
153         return ret;
154 }
155
156 static ssize_t alsap_mixer(enum ossp_opcode opcode,
157                            void *carg, void *din, size_t din_sz,
158                            void *rarg, void *dout, size_t *dout_szp, int tfd)
159 {
160 return -EBUSY;
161 }
162
163 static int set_hw_params(snd_pcm_t *pcm)
164 {
165         int ret;
166         unsigned rate;
167
168         ret = snd_pcm_hw_params_any(pcm, hw_params);
169         if (ret >= 0)
170                 ret = snd_pcm_hw_params_set_access(pcm, hw_params,
171                                                    SND_PCM_ACCESS_RW_INTERLEAVED);
172         rate = hw_format.rate;
173         if (ret >= 0)
174                 ret = snd_pcm_hw_params_set_rate_minmax(pcm, hw_params,
175                                                         &rate, NULL,
176                                                         &rate, NULL);
177         if (ret >= 0)
178                 ret = snd_pcm_hw_params_set_format(pcm, hw_params, hw_format.format);
179         if (ret >= 0)
180                 ret = snd_pcm_hw_params_set_channels(pcm, hw_params,
181                                                      hw_format.channels);
182         if (ret >= 0)
183                 ret = snd_pcm_hw_params(pcm, hw_params);
184         if (ret >= 0)
185                 ret = snd_pcm_sw_params_current(pcm, sw_params);
186         if (ret >= 0)
187                 ret = snd_pcm_sw_params(pcm, sw_params);
188         return ret;
189 }
190
191 static ssize_t alsap_open(enum ossp_opcode opcode,
192                           void *carg, void *din, size_t din_sz,
193                           void *rarg, void *dout, size_t *dout_szp, int tfd)
194 {
195         struct ossp_dsp_open_arg *arg = carg;
196         int ret;
197         block = arg->flags & O_NONBLOCK ? SND_PCM_NONBLOCK : 0;
198         int access;
199 //      block |= SND_PCM_ASYNC;
200         /* Woop dee dooo.. I love handling things in SIGIO (PAIN!!)
201          * Probably needed for MMAP
202          */
203
204         if (!hw_params)
205                 ret = snd_pcm_hw_params_malloc(&hw_params);
206         if (ret < 0)
207                 return ret;
208
209         if (!sw_params)
210                 ret = snd_pcm_sw_params_malloc(&sw_params);
211         if (ret < 0)
212                 return ret;
213
214         if (pcm[PLAY])
215                 snd_pcm_close(pcm[PLAY]);
216         if (pcm[REC])
217                 snd_pcm_close(pcm[REC]);
218         pcm[REC] = pcm[PLAY] = NULL;
219
220         access = arg->flags & O_ACCMODE;
221         if (access == O_WRONLY || access == O_RDWR) {
222                 ret = snd_pcm_open(&pcm[PLAY], "default",
223                                    SND_PCM_STREAM_PLAYBACK, block);
224                 if (ret >= 0)
225                         ret = set_hw_params(pcm[PLAY]);
226         }
227
228         if (ret >= 0 && (access == O_RDONLY || access == O_RDWR)) {
229                 ret = snd_pcm_open(&pcm[REC], "default",
230                                    SND_PCM_STREAM_CAPTURE, block);
231                 if (ret >= 0)
232                         ret = set_hw_params(pcm[REC]);
233         }
234
235         if (ret < 0) {
236                 if (pcm[PLAY])
237                         snd_pcm_close(pcm[PLAY]);
238                 if (pcm[REC])
239                         snd_pcm_close(pcm[REC]);
240                 pcm[REC] = pcm[PLAY] = NULL;
241                 return ret;
242         }
243         return 0;
244 }
245
246 static ssize_t alsap_write(enum ossp_opcode opcode,
247                            void *carg, void *din, size_t din_sz,
248                            void *rarg, void *dout, size_t *dout_szp, int tfd)
249 {
250 //      struct ossp_dsp_rw_arg *arg = carg;
251         int ret, insize;
252
253         insize = snd_pcm_bytes_to_frames(pcm[PLAY], din_sz);
254
255         if (snd_pcm_state(pcm[PLAY]) == SND_PCM_STATE_SETUP)
256                 snd_pcm_prepare(pcm[PLAY]);
257
258 //      snd_pcm_start(pcm[PLAY]);
259         ret = snd_pcm_writei(pcm[PLAY], din, insize);
260         if (ret < 0)
261                 ret = snd_pcm_recover(pcm[PLAY], ret, 1);
262
263         if (ret >= 0)
264                 return snd_pcm_frames_to_bytes(pcm[PLAY], ret);
265         else
266                 return ret;
267 }
268
269 static ssize_t alsap_read(enum ossp_opcode opcode,
270                           void *carg, void *din, size_t din_sz,
271                           void *rarg, void *dout, size_t *dout_szp, int tfd)
272 {
273 //      struct ossp_dsp_rw_arg *arg = carg;
274         int ret, outsize;
275
276         outsize = snd_pcm_bytes_to_frames(pcm[REC], *dout_szp);
277
278         if (snd_pcm_state(pcm[REC]) == SND_PCM_STATE_SETUP)
279                 snd_pcm_prepare(pcm[REC]);
280
281         ret = snd_pcm_readi(pcm[REC], dout, outsize);
282         if (ret < 0)
283                 ret = snd_pcm_recover(pcm[REC], ret, 1);
284         if (ret >= 0)
285                 *dout_szp = ret = snd_pcm_frames_to_bytes(pcm[REC], ret);
286         else
287                 *dout_szp = 0;
288
289         return ret;
290 }
291
292 static ssize_t alsap_poll(enum ossp_opcode opcode,
293                           void *carg, void *din, size_t din_sz,
294                           void *rarg, void *dout, size_t *dout_szp, int tfd)
295 {
296         unsigned revents = 0;
297
298         stream_notify |= *(int *)carg;
299
300         if (pcm[PLAY])
301                 revents |= POLLOUT;
302         if (pcm[REC])
303                 revents |= POLLIN;
304
305         *(unsigned *)rarg = revents;
306         return 0;
307 }
308
309
310 static ssize_t alsap_flush(enum ossp_opcode opcode,
311                            void *carg, void *din, size_t din_sz,
312                            void *rarg, void *dout, size_t *dout_szp, int tfd)
313 {
314         flush_streams(opcode == OSSP_DSP_SYNC);
315         return 0;
316 }
317
318 static ssize_t alsap_post(enum ossp_opcode opcode,
319                           void *carg, void *din, size_t din_sz,
320                           void *rarg, void *dout, size_t *dout_szp, int tfd)
321 {
322         int ret;
323
324         ret = trigger_streams(1, 1);
325         if (ret >= 0 && pcm[PLAY])
326                 ret = snd_pcm_start(pcm[PLAY]);
327         if (pcm[REC])
328                 ret = snd_pcm_start(pcm[REC]);
329         return ret;
330 }
331
332 static ssize_t alsap_get_param(enum ossp_opcode opcode,
333                                void *carg, void *din, size_t din_sz,
334                                void *rarg, void *dout, size_t *dout_szp,
335                                int tfd)
336 {
337         int v = 0;
338
339         switch (opcode) {
340         case OSSP_DSP_GET_RATE:
341                 return hw_format.rate;
342
343         case OSSP_DSP_GET_CHANNELS:
344                 return hw_format.channels;
345
346         case OSSP_DSP_GET_FORMAT: {
347                 v = fmt_alsa_to_oss(hw_format.format);
348                 break;
349         }
350
351         case OSSP_DSP_GET_BLKSIZE: {
352                 snd_pcm_uframes_t psize;
353                 snd_pcm_hw_params_get_period_size(hw_params, &psize, NULL);
354                 v = psize;
355                 break;
356         }
357
358         case OSSP_DSP_GET_FORMATS:
359                 v = AFMT_U8 | AFMT_A_LAW | AFMT_MU_LAW | AFMT_S16_LE |
360                         AFMT_S16_BE | AFMT_FLOAT | AFMT_S32_LE | AFMT_S32_BE;
361                 break;
362
363         case OSSP_DSP_GET_TRIGGER:
364                 if (!stream_corked[PLAY])
365                         v |= PCM_ENABLE_OUTPUT;
366                 if (!stream_corked[REC])
367                         v |= PCM_ENABLE_INPUT;
368                 break;
369
370         default:
371                 assert(0);
372         }
373
374         *(int *)rarg = v;
375
376         return 0;
377 }
378
379 static ssize_t alsap_set_param(enum ossp_opcode opcode,
380                                void *carg, void *din, size_t din_sz,
381                                void *rarg, void *dout, size_t *dout_szp,
382                                int tfd)
383 {
384         int v = *(int *)carg;
385         int ret = 0;
386
387         /* kill the streams before changing parameters */
388         kill_streams();
389
390         switch (opcode) {
391         case OSSP_DSP_SET_RATE: {
392                 hw_format.rate = v;
393                 break;
394         }
395
396         case OSSP_DSP_SET_CHANNELS: {
397                 hw_format.channels = v;
398                 break;
399         }
400
401         case OSSP_DSP_SET_FORMAT: {
402                 snd_pcm_format_t format = fmt_oss_to_alsa(v);
403                 hw_format.format = format;
404                 break;
405         }
406
407         case OSSP_DSP_SET_SUBDIVISION:
408                 if (!v)
409                         v = 1;
410 #if 0
411                 if (!v) {
412                         v = user_subdivision ?: 1;
413                         break;
414                 }
415                 user_frag_size = 0;
416                 user_subdivision = v;
417                 break;
418
419         case OSSP_DSP_SET_FRAGMENT:
420                 user_subdivision = 0;
421                 user_frag_size = 1 << (v & 0xffff);
422                 user_max_frags = (v >> 16) & 0xffff;
423                 if (user_frag_size < 4)
424                         user_frag_size = 4;
425                 if (user_max_frags < 2)
426                         user_max_frags = 2;
427 #else
428         case OSSP_DSP_SET_FRAGMENT:
429 #endif
430                 break;
431         default:
432                 assert(0);
433         }
434
435         if (pcm[PLAY])
436                 ret = set_hw_params(pcm[PLAY]);
437         if (ret >= 0 && pcm[REC])
438                 ret = set_hw_params(pcm[REC]);
439
440         if (rarg)
441                 *(int *)rarg = v;
442         return 0;
443 }
444
445 static ssize_t alsap_set_trigger(enum ossp_opcode opcode,
446                                  void *carg, void *din, size_t din_sz,
447                                  void *rarg, void *dout, size_t *dout_szp,
448                                  int fd)
449 {
450         int enable = *(int *)carg;
451
452         stream_corked[PLAY] = !!(enable & PCM_ENABLE_OUTPUT);
453         stream_corked[REC] = !!(enable & PCM_ENABLE_INPUT);
454
455         return trigger_streams(enable & PCM_ENABLE_OUTPUT,
456                                enable & PCM_ENABLE_INPUT);
457 }
458
459 static ssize_t alsap_get_space(enum ossp_opcode opcode,
460                                void *carg, void *din, size_t din_sz,
461                                void *rarg, void *dout, size_t *dout_szp, int tfd)
462 {
463         int dir = (opcode == OSSP_DSP_GET_OSPACE) ? PLAY : REC;
464         int underrun = 0;
465         struct audio_buf_info info = { };
466         unsigned long bufsize;
467         snd_pcm_uframes_t avail, fragsize;
468         snd_pcm_state_t state;
469
470         if (!pcm[dir])
471                 return -EINVAL;
472
473         state = snd_pcm_state(pcm[dir]);
474         if (state == SND_PCM_STATE_XRUN) {
475                 snd_pcm_recover(pcm[dir], -EPIPE, 0);
476                 underrun = 1;
477         } else if (state == SND_PCM_STATE_SUSPENDED) {
478                 snd_pcm_recover(pcm[dir], -ESTRPIPE, 0);
479                 underrun = 1;
480         }
481
482         snd_pcm_hw_params_current(pcm[dir], hw_params);
483         snd_pcm_hw_params_get_period_size(hw_params, &fragsize, NULL);
484         snd_pcm_hw_params_get_buffer_size(hw_params, &bufsize);
485         info.fragsize = snd_pcm_frames_to_bytes(pcm[dir], fragsize);
486         info.fragstotal = bufsize / fragsize;
487         if (!underrun) {
488                 avail = snd_pcm_avail_update(pcm[dir]);
489                 info.fragments = avail / fragsize;
490         } else
491                 info.fragments = info.fragstotal;
492
493         info.bytes = info.fragsize * info.fragments;
494
495         *(struct audio_buf_info *)rarg = info;
496         return 0;
497 }
498
499 static ssize_t alsap_get_ptr(enum ossp_opcode opcode,
500                              void *carg, void *din, size_t din_sz,
501                              void *rarg, void *dout, size_t *dout_szp, int tfd)
502 {
503         int dir = (opcode == OSSP_DSP_GET_OPTR) ? PLAY : REC;
504         struct count_info info = { };
505
506         if (!pcm[dir])
507                 return -EIO;
508
509         snd_pcm_hw_params_current(pcm[dir], hw_params);
510         info.bytes = byte_counter[dir];
511         snd_pcm_hw_params_get_periods(hw_params, (unsigned int *)&info.blocks, NULL);
512         info.ptr = mmap_pos[dir];
513
514         *(struct count_info *)rarg = info;
515         return 0;
516 }
517
518 static ssize_t alsap_get_odelay(enum ossp_opcode opcode,
519                                 void *carg, void *din, size_t din_sz,
520                                 void *rarg, void *dout, size_t *dout_szp,
521                                 int fd)
522 {
523         snd_pcm_sframes_t delay;
524
525         if (!pcm[PLAY])
526                 return -EIO;
527
528         if (snd_pcm_delay(pcm[PLAY], &delay) < 0)
529                 return -EIO;
530
531         *(int *)rarg = snd_pcm_frames_to_bytes(pcm[PLAY], delay);
532         return 0;
533 }
534
535 static ossp_action_fn_t action_fn_tbl[OSSP_NR_OPCODES] = {
536         [OSSP_MIXER]            = alsap_mixer,
537         [OSSP_DSP_OPEN]         = alsap_open,
538         [OSSP_DSP_READ]         = alsap_read,
539         [OSSP_DSP_WRITE]        = alsap_write,
540         [OSSP_DSP_POLL]         = alsap_poll,
541 #if 0
542         [OSSP_DSP_MMAP]         = alsap_mmap,
543         [OSSP_DSP_MUNMAP]       = alsap_munmap,
544 #endif
545         [OSSP_DSP_RESET]        = alsap_flush,
546         [OSSP_DSP_SYNC]         = alsap_flush,
547         [OSSP_DSP_POST]         = alsap_post,
548         [OSSP_DSP_GET_RATE]     = alsap_get_param,
549         [OSSP_DSP_GET_CHANNELS] = alsap_get_param,
550         [OSSP_DSP_GET_FORMAT]   = alsap_get_param,
551         [OSSP_DSP_GET_BLKSIZE]  = alsap_get_param,
552         [OSSP_DSP_GET_FORMATS]  = alsap_get_param,
553         [OSSP_DSP_SET_RATE]     = alsap_set_param,
554         [OSSP_DSP_SET_CHANNELS] = alsap_set_param,
555         [OSSP_DSP_SET_FORMAT]   = alsap_set_param,
556         [OSSP_DSP_SET_SUBDIVISION] = alsap_set_param,
557         [OSSP_DSP_SET_FRAGMENT] = alsap_set_param,
558         [OSSP_DSP_GET_TRIGGER]  = alsap_get_param,
559         [OSSP_DSP_SET_TRIGGER]  = alsap_set_trigger,
560         [OSSP_DSP_GET_OSPACE]   = alsap_get_space,
561         [OSSP_DSP_GET_ISPACE]   = alsap_get_space,
562         [OSSP_DSP_GET_OPTR]     = alsap_get_ptr,
563         [OSSP_DSP_GET_IPTR]     = alsap_get_ptr,
564         [OSSP_DSP_GET_ODELAY]   = alsap_get_odelay,
565 };
566
567 static int action_pre(void)
568 {
569         return 0;
570 }
571
572 static void action_post(void)
573 {
574 }
575
576 int main(int argc, char **argv)
577 {
578         int rc;
579
580         ossp_slave_init(argc, argv);
581
582         page_size = sysconf(_SC_PAGE_SIZE);
583
584         /* Okay, now we're open for business */
585         rc = 0;
586         do {
587                 rc = ossp_slave_process_command(ossp_cmd_fd, action_fn_tbl,
588                                                 action_pre, action_post);
589         } while (rc > 0);
590
591         return rc ? 1 : 0;
592 }