Add explanatory comments to the #endif part of multiple inclusion guards.
[mplayer/greg.git] / libao2 / ao_jack.c
blob6860810249d450f1c444da57ddf7794fcb1869e8
1 /*
2 * ao_jack.c - libao2 JACK Audio Output Driver for MPlayer
4 * This driver is under the same license as MPlayer.
5 * (http://www.mplayerhq.hu)
7 * Copyleft 2001 by Felix Bünemann (atmosfear@users.sf.net)
8 * and Reimar Döffinger (Reimar.Doeffinger@stud.uni-karlsruhe.de)
9 */
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <string.h>
14 #include <unistd.h>
16 #include "config.h"
17 #include "mp_msg.h"
18 #include "help_mp.h"
20 #include "audio_out.h"
21 #include "audio_out_internal.h"
22 #include "libaf/af_format.h"
23 #include "osdep/timer.h"
24 #include "subopt-helper.h"
26 #include "libvo/fastmemcpy.h"
28 #include <jack/jack.h>
30 static ao_info_t info =
32 "JACK audio output",
33 "jack",
34 "Reimar Döffinger <Reimar.Doeffinger@stud.uni-karlsruhe.de>",
35 "based on ao_sdl.c"
38 LIBAO_EXTERN(jack)
40 //! maximum number of channels supported, avoids lots of mallocs
41 #define MAX_CHANS 6
42 static jack_port_t *ports[MAX_CHANS];
43 static int num_ports; ///< Number of used ports == number of channels
44 static jack_client_t *client;
45 static float jack_latency;
46 static int estimate;
47 static volatile int paused = 0; ///< set if paused
48 static volatile int underrun = 0; ///< signals if an underrun occured
50 static volatile float callback_interval = 0;
51 static volatile float callback_time = 0;
53 //! size of one chunk, if this is too small MPlayer will start to "stutter"
54 //! after a short time of playback
55 #define CHUNK_SIZE (16 * 1024)
56 //! number of "virtual" chunks the buffer consists of
57 #define NUM_CHUNKS 8
58 // This type of ring buffer may never fill up completely, at least
59 // one byte must always be unused.
60 // For performance reasons (alignment etc.) one whole chunk always stays
61 // empty, not only one byte.
62 #define BUFFSIZE ((NUM_CHUNKS + 1) * CHUNK_SIZE)
64 //! buffer for audio data
65 static unsigned char *buffer = NULL;
67 //! buffer read position, may only be modified by playback thread or while it is stopped
68 static volatile int read_pos;
69 //! buffer write position, may only be modified by MPlayer's thread
70 static volatile int write_pos;
72 /**
73 * \brief get the number of free bytes in the buffer
74 * \return number of free bytes in buffer
76 * may only be called by MPlayer's thread
77 * return value may change between immediately following two calls,
78 * and the real number of free bytes might be larger!
80 static int buf_free(void) {
81 int free = read_pos - write_pos - CHUNK_SIZE;
82 if (free < 0) free += BUFFSIZE;
83 return free;
86 /**
87 * \brief get amount of data available in the buffer
88 * \return number of bytes available in buffer
90 * may only be called by the playback thread
91 * return value may change between immediately following two calls,
92 * and the real number of buffered bytes might be larger!
94 static int buf_used(void) {
95 int used = write_pos - read_pos;
96 if (used < 0) used += BUFFSIZE;
97 return used;
101 * \brief insert len bytes into buffer
102 * \param data data to insert
103 * \param len length of data
104 * \return number of bytes inserted into buffer
106 * If there is not enough room, the buffer is filled up
108 static int write_buffer(unsigned char* data, int len) {
109 int first_len = BUFFSIZE - write_pos;
110 int free = buf_free();
111 if (len > free) len = free;
112 if (first_len > len) first_len = len;
113 // till end of buffer
114 fast_memcpy (&buffer[write_pos], data, first_len);
115 if (len > first_len) { // we have to wrap around
116 // remaining part from beginning of buffer
117 fast_memcpy (buffer, &data[first_len], len - first_len);
119 write_pos = (write_pos + len) % BUFFSIZE;
120 return len;
124 * \brief read data from buffer and splitting it into channels
125 * \param bufs num_bufs float buffers, each will contain the data of one channel
126 * \param cnt number of samples to read per channel
127 * \param num_bufs number of channels to split the data into
128 * \return number of samples read per channel, equals cnt unless there was too
129 * little data in the buffer
131 * Assumes the data in the buffer is of type float, the number of bytes
132 * read is res * num_bufs * sizeof(float), where res is the return value.
133 * If there is not enough data in the buffer remaining parts will be filled
134 * with silence.
136 static int read_buffer(float **bufs, int cnt, int num_bufs) {
137 int buffered = buf_used();
138 int i, j;
139 int orig_cnt = cnt;
140 if (cnt * sizeof(float) * num_bufs > buffered)
141 cnt = buffered / sizeof(float) / num_bufs;
142 for (i = 0; i < cnt; i++) {
143 for (j = 0; j < num_bufs; j++) {
144 bufs[j][i] = *((float *)(&buffer[read_pos]));
145 read_pos = (read_pos + sizeof(float)) % BUFFSIZE;
148 for (i = cnt; i < orig_cnt; i++)
149 for (j = 0; j < num_bufs; j++)
150 bufs[j][i] = 0;
151 return cnt;
154 // end ring buffer stuff
156 static int control(int cmd, void *arg) {
157 return CONTROL_UNKNOWN;
161 * \brief fill the buffers with silence
162 * \param bufs num_bufs float buffers, each will contain the data of one channel
163 * \param cnt number of samples in each buffer
164 * \param num_bufs number of buffers
166 static void silence(float **bufs, int cnt, int num_bufs) {
167 int i, j;
168 for (i = 0; i < cnt; i++)
169 for (j = 0; j < num_bufs; j++)
170 bufs[j][i] = 0;
174 * \brief JACK Callback function
175 * \param nframes number of frames to fill into buffers
176 * \param arg unused
177 * \return currently always 0
179 * Write silence into buffers if paused or an underrun occured
181 static int outputaudio(jack_nframes_t nframes, void *arg) {
182 float *bufs[MAX_CHANS];
183 int i;
184 for (i = 0; i < num_ports; i++)
185 bufs[i] = jack_port_get_buffer(ports[i], nframes);
186 if (paused || underrun)
187 silence(bufs, nframes, num_ports);
188 else
189 if (read_buffer(bufs, nframes, num_ports) < nframes)
190 underrun = 1;
191 if (estimate) {
192 float now = (float)GetTimer() / 1000000.0;
193 float diff = callback_time + callback_interval - now;
194 if ((diff > -0.002) && (diff < 0.002))
195 callback_time += callback_interval;
196 else
197 callback_time = now;
198 callback_interval = (float)nframes / (float)ao_data.samplerate;
200 return 0;
204 * \brief print suboption usage help
206 static void print_help (void)
208 mp_msg (MSGT_AO, MSGL_FATAL,
209 "\n-ao jack commandline help:\n"
210 "Example: mplayer -ao jack:port=myout\n"
211 " connects MPlayer to the jack ports named myout\n"
212 "\nOptions:\n"
213 " port=<port name>\n"
214 " Connects to the given ports instead of the default physical ones\n"
215 " name=<client name>\n"
216 " Client name to pass to JACK\n"
217 " estimate\n"
218 " Estimates the amount of data in buffers (experimental)\n");
221 static int init(int rate, int channels, int format, int flags) {
222 const char **matching_ports = NULL;
223 char *port_name = NULL;
224 char *client_name = NULL;
225 opt_t subopts[] = {
226 {"port", OPT_ARG_MSTRZ, &port_name, NULL},
227 {"name", OPT_ARG_MSTRZ, &client_name, NULL},
228 {"estimate", OPT_ARG_BOOL, &estimate, NULL},
229 {NULL}
231 int port_flags = JackPortIsInput;
232 int i;
233 estimate = 1;
234 if (subopt_parse(ao_subdevice, subopts) != 0) {
235 print_help();
236 return 0;
238 if (channels > MAX_CHANS) {
239 mp_msg(MSGT_AO, MSGL_FATAL, "[JACK] Invalid number of channels: %i\n", channels);
240 goto err_out;
242 if (!client_name) {
243 client_name = malloc(40);
244 sprintf(client_name, "MPlayer [%d]", getpid());
246 client = jack_client_new(client_name);
247 if (!client) {
248 mp_msg(MSGT_AO, MSGL_FATAL, "[JACK] cannot open server\n");
249 goto err_out;
251 reset();
252 jack_set_process_callback(client, outputaudio, 0);
254 // list matching ports
255 if (!port_name)
256 port_flags |= JackPortIsPhysical;
257 matching_ports = jack_get_ports(client, port_name, NULL, port_flags);
258 for (num_ports = 0; matching_ports && matching_ports[num_ports]; num_ports++) ;
259 if (!num_ports) {
260 mp_msg(MSGT_AO, MSGL_FATAL, "[JACK] no physical ports available\n");
261 goto err_out;
263 if (channels > num_ports) channels = num_ports;
264 num_ports = channels;
266 // create out output ports
267 for (i = 0; i < num_ports; i++) {
268 char pname[30];
269 snprintf(pname, 30, "out_%d", i);
270 ports[i] = jack_port_register(client, pname, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
271 if (!ports[i]) {
272 mp_msg(MSGT_AO, MSGL_FATAL, "[JACK] not enough ports available\n");
273 goto err_out;
276 if (jack_activate(client)) {
277 mp_msg(MSGT_AO, MSGL_FATAL, "[JACK] activate failed\n");
278 goto err_out;
280 for (i = 0; i < num_ports; i++) {
281 if (jack_connect(client, jack_port_name(ports[i]), matching_ports[i])) {
282 mp_msg(MSGT_AO, MSGL_FATAL, "[JACK] connecting failed\n");
283 goto err_out;
286 rate = jack_get_sample_rate(client);
287 jack_latency = (float)(jack_port_get_total_latency(client, ports[0]) +
288 jack_get_buffer_size(client)) / (float)rate;
289 callback_interval = 0;
290 buffer = (unsigned char *) malloc(BUFFSIZE);
292 ao_data.channels = channels;
293 ao_data.samplerate = rate;
294 ao_data.format = AF_FORMAT_FLOAT_NE;
295 ao_data.bps = channels * rate * sizeof(float);
296 ao_data.buffersize = CHUNK_SIZE * NUM_CHUNKS;
297 ao_data.outburst = CHUNK_SIZE;
298 free(matching_ports);
299 free(port_name);
300 free(client_name);
301 return 1;
303 err_out:
304 free(matching_ports);
305 free(port_name);
306 free(client_name);
307 if (client)
308 jack_client_close(client);
309 free(buffer);
310 buffer = NULL;
311 return 0;
314 // close audio device
315 static void uninit(int immed) {
316 if (!immed)
317 usec_sleep(get_delay() * 1000 * 1000);
318 // HACK, make sure jack doesn't loop-output dirty buffers
319 reset();
320 usec_sleep(100 * 1000);
321 jack_client_close(client);
322 free(buffer);
323 buffer = NULL;
327 * \brief stop playing and empty buffers (for seeking/pause)
329 static void reset(void) {
330 paused = 1;
331 read_pos = 0;
332 write_pos = 0;
333 paused = 0;
337 * \brief stop playing, keep buffers (for pause)
339 static void audio_pause(void) {
340 paused = 1;
344 * \brief resume playing, after audio_pause()
346 static void audio_resume(void) {
347 paused = 0;
350 static int get_space(void) {
351 return buf_free();
355 * \brief write data into buffer and reset underrun flag
357 static int play(void *data, int len, int flags) {
358 if (!(flags & AOPLAY_FINAL_CHUNK))
359 len -= len % ao_data.outburst;
360 underrun = 0;
361 return write_buffer(data, len);
364 static float get_delay(void) {
365 int buffered = BUFFSIZE - CHUNK_SIZE - buf_free(); // could be less
366 float in_jack = jack_latency;
367 if (estimate && callback_interval > 0) {
368 float elapsed = (float)GetTimer() / 1000000.0 - callback_time;
369 in_jack += callback_interval - elapsed;
370 if (in_jack < 0) in_jack = 0;
372 return (float)buffered / (float)ao_data.bps + in_jack;