2 * This file is part of DisOrder.
3 * Copyright (C) 2007 Richard Kettlewell
4 * Portions copyright (C) 2007 Ross Younger
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 3 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 /** @file clients/playrtp-oss.c
20 * @brief RTP player - OSS and empeg support
25 #if HAVE_SYS_SOUNDCARD_H || EMPEG_HOST
28 #include <sys/ioctl.h>
30 #include <sys/soundcard.h>
36 #include <arpa/inet.h>
45 /** @brief /dev/dsp (or whatever) */
46 static int playrtp_oss_fd = -1;
48 /** @brief Audio buffer */
49 static char *playrtp_oss_buffer;
51 /** @brief Size of @ref playrtp_oss_buffer in bytes */
52 static int playrtp_oss_bufsize;
54 /** @brief Number of bytes used in @ref playrtp_oss_buffer */
55 static int playrtp_oss_bufused;
57 /** @brief Open and configure the OSS audio device */
58 static void playrtp_oss_enable(void) {
59 if(playrtp_oss_fd == -1) {
61 /* empeg audio driver only knows /dev/audio, only supports the equivalent
62 * of AFMT_S16_NE, has a fixed buffer size, and does not support the
65 device = "/dev/audio";
66 if((playrtp_oss_fd = open(device, O_WRONLY)) < 0)
67 fatal(errno, "error opening %s", device);
68 playrtp_oss_bufsize = 4608;
70 int rate = 44100, stereo = 1, format = AFMT_S16_BE;
72 if(access("/dev/dsp", W_OK) == 0)
74 else if(access("/dev/audio", W_OK) == 0)
75 device = "/dev/audio";
77 fatal(0, "cannot determine default audio device");
79 if((playrtp_oss_fd = open(device, O_WRONLY)) < 0)
80 fatal(errno, "error opening %s", device);
81 if(ioctl(playrtp_oss_fd, SNDCTL_DSP_SETFMT, &format) < 0)
82 fatal(errno, "ioctl SNDCTL_DSP_SETFMT");
83 if(ioctl(playrtp_oss_fd, SNDCTL_DSP_STEREO, &stereo) < 0)
84 fatal(errno, "ioctl SNDCTL_DSP_STEREO");
85 if(ioctl(playrtp_oss_fd, SNDCTL_DSP_SPEED, &rate) < 0)
86 fatal(errno, "ioctl SNDCTL_DSP_SPEED");
88 error(0, "asking for 44100Hz, got %dHz", rate);
89 if(ioctl(playrtp_oss_fd, SNDCTL_DSP_GETBLKSIZE, &playrtp_oss_bufsize) < 0)
90 fatal(errno, "ioctl SNDCTL_DSP_GETBLKSIZE");
91 info("OSS buffer size %d", playrtp_oss_bufsize);
93 playrtp_oss_buffer = xmalloc(playrtp_oss_bufsize);
94 playrtp_oss_bufused = 0;
95 nonblock(playrtp_oss_fd);
99 /** @brief Flush the OSS output buffer
100 * @return 0 on success, non-0 on error
102 static int playrtp_oss_flush(void) {
105 if(!playrtp_oss_bufused)
106 return 0; /* nothing to do */
107 /* 0 out the unused portion of the buffer */
108 memset(playrtp_oss_buffer + playrtp_oss_bufused, 0,
109 playrtp_oss_bufsize - playrtp_oss_bufused);
111 /* empeg audio driver insists on native-endian samples */
114 *const limit = (uint16_t *)(playrtp_oss_buffer + playrtp_oss_bufused);
116 for(ptr = (uint16_t *)playrtp_oss_buffer; ptr < limit; ++ptr)
121 nbyteswritten = write(playrtp_oss_fd,
122 playrtp_oss_buffer, playrtp_oss_bufsize);
123 if(nbyteswritten < 0) {
126 break; /* try again */
128 return 0; /* try later */
130 error(errno, "error writing to %s", device);
134 if(nbyteswritten < playrtp_oss_bufsize)
135 error(0, "%s: short write (%d/%d)",
136 device, nbyteswritten, playrtp_oss_bufsize);
139 const int16_t *sp = (const int16_t *)playrtp_oss_buffer;
141 for(count = 0; count < playrtp_oss_bufsize; count += sizeof(int16_t)) {
142 dump_buffer[dump_index++] = (int16_t)ntohs(*sp++);
143 dump_index %= dump_size;
146 playrtp_oss_bufused = 0;
152 /** @brief Wait until the audio device can accept more data */
153 static void playrtp_oss_wait(void) {
154 struct pollfd fds[1];
158 fds[0].fd = playrtp_oss_fd;
159 fds[0].events = POLLOUT;
160 while((n = poll(fds, 1, -1)) < 0 && errno == EINTR)
163 fatal(errno, "calling poll");
164 } while(!(fds[0].revents & (POLLOUT|POLLERR)));
167 /** @brief Close the OSS output device
168 * @param hard If nonzero, drop pending data
170 static void playrtp_oss_disable(int hard) {
173 /* No SNDCTL_DSP_ ioctls on empeg */
174 if(ioctl(playrtp_oss_fd, SNDCTL_DSP_RESET, 0) < 0)
175 error(errno, "ioctl SNDCTL_DSP_RESET");
179 xclose(playrtp_oss_fd);
181 free(playrtp_oss_buffer);
182 playrtp_oss_buffer = 0;
185 /** @brief Write samples to OSS output device
186 * @param data Pointer to sample data
187 * @param samples Number of samples
188 * @return 0 on success, non-0 on error
190 static int playrtp_oss_write(const char *data, size_t samples) {
191 long bytes = samples * sizeof(int16_t);
193 int n = playrtp_oss_bufsize - playrtp_oss_bufused;
197 memcpy(playrtp_oss_buffer + playrtp_oss_bufused, data, n);
200 playrtp_oss_bufused += n;
201 if(playrtp_oss_bufused == playrtp_oss_bufsize)
202 if(playrtp_oss_flush())
205 next_timestamp += samples;
209 /** @brief Play some data from packet @p p
211 * @p p is assumed to contain @ref next_timestamp.
213 static int playrtp_oss_play(const struct packet *p) {
214 return playrtp_oss_write
215 ((const char *)(p->samples_raw + next_timestamp - p->timestamp),
216 (p->timestamp + p->nsamples) - next_timestamp);
219 /** @brief Play some silence before packet @p p
221 * @p p is assumed to be entirely before @ref next_timestamp.
223 static int playrtp_oss_infill(const struct packet *p) {
224 static const char zeros[INFILL_SAMPLES * sizeof(int16_t)];
225 size_t samples_available = INFILL_SAMPLES;
227 if(p && samples_available > p->timestamp - next_timestamp)
228 samples_available = p->timestamp - next_timestamp;
229 return playrtp_oss_write(zeros, samples_available);
232 /** @brief OSS backend for playrtp */
233 void playrtp_oss(void) {
235 const struct packet *p;
237 pthread_mutex_lock(&lock);
239 /* Wait for the buffer to fill up a bit */
240 playrtp_fill_buffer();
241 playrtp_oss_enable();
244 /* Keep playing until the buffer empties out, we get an error */
245 while((nsamples >= minbuffer
247 && contains(pheap_first(&packets), next_timestamp)))
249 /* Wait until we can play more */
250 pthread_mutex_unlock(&lock);
252 pthread_mutex_lock(&lock);
253 /* Device is ready for more data, find something to play */
254 p = playrtp_next_packet();
255 /* Play it or play some silence */
256 if(contains(p, next_timestamp))
257 escape = playrtp_oss_play(p);
259 escape = playrtp_oss_infill(p);
262 /* We stop playing for a bit until the buffer re-fills */
263 pthread_mutex_unlock(&lock);
264 playrtp_oss_disable(escape);
265 pthread_mutex_lock(&lock);