chiark / gitweb /
disorder setup-guest enforces mail_sender requirement
[disorder] / clients / playrtp-oss.c
1 /*
2  * This file is part of DisOrder.
3  * Copyright (C) 2007 Richard Kettlewell
4  * Portions copyright (C) 2007 Ross Younger
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful, but
12  * WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
19  * USA
20  */
21 /** @file clients/playrtp-oss.c
22  * @brief RTP player - OSS and empeg support
23  */
24
25 #include <config.h>
26
27 #if HAVE_SYS_SOUNDCARD_H || EMPEG_HOST
28 #include "types.h"
29
30 #include <poll.h>
31 #include <sys/ioctl.h>
32 #if !EMPEG_HOST
33 #include <sys/soundcard.h>
34 #endif
35 #include <assert.h>
36 #include <pthread.h>
37 #include <string.h>
38 #include <fcntl.h>
39 #include <unistd.h>
40 #include <errno.h>
41 #include <arpa/inet.h>
42
43 #include "mem.h"
44 #include "log.h"
45 #include "vector.h"
46 #include "heap.h"
47 #include "syscalls.h"
48 #include "playrtp.h"
49
50 /** @brief /dev/dsp (or whatever) */
51 static int playrtp_oss_fd = -1;
52
53 /** @brief Audio buffer */
54 static char *playrtp_oss_buffer;
55
56 /** @brief Size of @ref playrtp_oss_buffer in bytes */
57 static int playrtp_oss_bufsize;
58
59 /** @brief Number of bytes used in @ref playrtp_oss_buffer */
60 static int playrtp_oss_bufused;
61
62 /** @brief Open and configure the OSS audio device */
63 static void playrtp_oss_enable(void) {
64   if(playrtp_oss_fd == -1) {
65 #if EMPEG_HOST
66     /* empeg audio driver only knows /dev/audio, only supports the equivalent
67      * of AFMT_S16_NE, has a fixed buffer size, and does not support the
68      * SNDCTL_ ioctls. */
69     if(!device)
70       device = "/dev/audio";
71     if((playrtp_oss_fd = open(device, O_WRONLY)) < 0)
72       fatal(errno, "error opening %s", device);
73     playrtp_oss_bufsize = 4608;
74 #else
75     int rate = 44100, stereo = 1, format = AFMT_S16_BE;
76     if(!device) {
77       if(access("/dev/dsp", W_OK) == 0)
78         device = "/dev/dsp";
79       else if(access("/dev/audio", W_OK) == 0)
80         device = "/dev/audio";
81       else
82         fatal(0, "cannot determine default audio device");
83     }
84     if((playrtp_oss_fd = open(device, O_WRONLY)) < 0)
85       fatal(errno, "error opening %s", device);
86     if(ioctl(playrtp_oss_fd, SNDCTL_DSP_SETFMT, &format) < 0)
87       fatal(errno, "ioctl SNDCTL_DSP_SETFMT");
88     if(ioctl(playrtp_oss_fd, SNDCTL_DSP_STEREO, &stereo) < 0)
89       fatal(errno, "ioctl SNDCTL_DSP_STEREO");
90     if(ioctl(playrtp_oss_fd, SNDCTL_DSP_SPEED, &rate) < 0)
91       fatal(errno, "ioctl SNDCTL_DSP_SPEED");
92     if(rate != 44100)
93       error(0, "asking for 44100Hz, got %dHz", rate);
94     if(ioctl(playrtp_oss_fd, SNDCTL_DSP_GETBLKSIZE, &playrtp_oss_bufsize) < 0)
95       fatal(errno, "ioctl SNDCTL_DSP_GETBLKSIZE");
96     info("OSS buffer size %d", playrtp_oss_bufsize);
97 #endif
98     playrtp_oss_buffer = xmalloc(playrtp_oss_bufsize);
99     playrtp_oss_bufused = 0;
100     nonblock(playrtp_oss_fd);
101   }
102 }
103
104 /** @brief Flush the OSS output buffer
105  * @return 0 on success, non-0 on error
106  */
107 static int playrtp_oss_flush(void) {
108   int nbyteswritten;
109
110   if(!playrtp_oss_bufused)
111     return 0;                           /* nothing to do */
112   /* 0 out the unused portion of the buffer */
113   memset(playrtp_oss_buffer + playrtp_oss_bufused, 0,
114          playrtp_oss_bufsize - playrtp_oss_bufused);
115 #if EMPEG_HOST 
116   /* empeg audio driver insists on native-endian samples */
117   {
118     uint16_t *ptr,
119       *const limit = (uint16_t *)(playrtp_oss_buffer + playrtp_oss_bufused);
120
121     for(ptr = (uint16_t *)playrtp_oss_buffer; ptr < limit; ++ptr)
122       *ptr = ntohs(*ptr);
123   }
124 #endif
125   for(;;) {
126     nbyteswritten = write(playrtp_oss_fd,
127                           playrtp_oss_buffer, playrtp_oss_bufsize);
128     if(nbyteswritten < 0) {
129       switch(errno) {
130       case EINTR:
131         break;                          /* try again */
132       case EAGAIN:
133         return 0;                       /* try later */
134       default:
135         error(errno, "error writing to %s", device);
136         return -1;
137       }
138     } else {
139       if(nbyteswritten < playrtp_oss_bufsize)
140         error(0, "%s: short write (%d/%d)",
141               device, nbyteswritten, playrtp_oss_bufsize);
142       if(dump_buffer) {
143         int count;
144         const int16_t *sp = (const int16_t *)playrtp_oss_buffer;
145         
146         for(count = 0; count < playrtp_oss_bufsize; count += sizeof(int16_t)) {
147           dump_buffer[dump_index++] = (int16_t)ntohs(*sp++);
148           dump_index %= dump_size;
149         }
150       }
151       playrtp_oss_bufused = 0;
152       return 0;
153     }
154   }
155 }
156
157 /** @brief Wait until the audio device can accept more data */
158 static void playrtp_oss_wait(void) {
159   struct pollfd fds[1];
160   int n;
161
162   do {
163     fds[0].fd = playrtp_oss_fd;
164     fds[0].events = POLLOUT;
165     while((n = poll(fds, 1, -1)) < 0 && errno == EINTR)
166       ;
167     if(n < 0)
168       fatal(errno, "calling poll");
169   } while(!(fds[0].revents & (POLLOUT|POLLERR)));
170 }
171
172 /** @brief Close the OSS output device
173  * @param hard If nonzero, drop pending data
174  */
175 static void playrtp_oss_disable(int hard) {
176   if(hard) {
177 #if !EMPEG_HOST
178     /* No SNDCTL_DSP_ ioctls on empeg */
179     if(ioctl(playrtp_oss_fd, SNDCTL_DSP_RESET, 0) < 0)
180       error(errno, "ioctl SNDCTL_DSP_RESET");
181 #endif
182   } else
183     playrtp_oss_flush();
184   xclose(playrtp_oss_fd);
185   playrtp_oss_fd = -1;
186   free(playrtp_oss_buffer);
187   playrtp_oss_buffer = 0;
188 }
189
190 /** @brief Write samples to OSS output device
191  * @param data Pointer to sample data
192  * @param samples Number of samples
193  * @return 0 on success, non-0 on error
194  */
195 static int playrtp_oss_write(const char *data, size_t samples) {
196   long bytes = samples * sizeof(int16_t);
197   while(bytes > 0) {
198     int n = playrtp_oss_bufsize - playrtp_oss_bufused;
199
200     if(n > bytes)
201       n = bytes;
202     memcpy(playrtp_oss_buffer + playrtp_oss_bufused, data, n);
203     bytes -= n;
204     data += n;
205     playrtp_oss_bufused += n;
206     if(playrtp_oss_bufused == playrtp_oss_bufsize)
207       if(playrtp_oss_flush())
208         return -1;
209   }
210   next_timestamp += samples;
211   return 0;
212 }
213
214 /** @brief Play some data from packet @p p
215  *
216  * @p p is assumed to contain @ref next_timestamp.
217  */
218 static int playrtp_oss_play(const struct packet *p) {
219   return playrtp_oss_write
220     ((const char *)(p->samples_raw + next_timestamp - p->timestamp),
221      (p->timestamp + p->nsamples) - next_timestamp);
222 }
223
224 /** @brief Play some silence before packet @p p
225  *
226  * @p p is assumed to be entirely before @ref next_timestamp.
227  */
228 static int playrtp_oss_infill(const struct packet *p) {
229   static const char zeros[INFILL_SAMPLES * sizeof(int16_t)];
230   size_t samples_available = INFILL_SAMPLES;
231
232   if(p && samples_available > p->timestamp - next_timestamp)
233     samples_available = p->timestamp - next_timestamp;
234   return playrtp_oss_write(zeros, samples_available);
235 }
236
237 /** @brief OSS backend for playrtp */
238 void playrtp_oss(void) {
239   int escape;
240   const struct packet *p;
241
242   pthread_mutex_lock(&lock);
243   for(;;) {
244     /* Wait for the buffer to fill up a bit */
245     playrtp_fill_buffer();
246     playrtp_oss_enable();
247     escape = 0;
248     info("Playing...");
249     /* Keep playing until the buffer empties out, we get an error */
250     while((nsamples >= minbuffer
251            || (nsamples > 0
252                && contains(pheap_first(&packets), next_timestamp)))
253           && !escape) {
254       /* Wait until we can play more */
255       pthread_mutex_unlock(&lock);
256       playrtp_oss_wait();
257       pthread_mutex_lock(&lock);
258       /* Device is ready for more data, find something to play */
259       p = playrtp_next_packet();
260       /* Play it or play some silence */
261       if(contains(p, next_timestamp))
262         escape = playrtp_oss_play(p);
263       else
264         escape = playrtp_oss_infill(p);
265     }
266     active = 0;
267     /* We stop playing for a bit until the buffer re-fills */
268     pthread_mutex_unlock(&lock);
269     playrtp_oss_disable(escape);
270     pthread_mutex_lock(&lock);
271   }
272 }
273
274 #endif
275
276 /*
277 Local Variables:
278 c-basic-offset:2
279 comment-column:40
280 fill-column:79
281 indent-tabs-mode:nil
282 End:
283 */