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)
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
=
34 "Reimar Döffinger <Reimar.Doeffinger@stud.uni-karlsruhe.de>",
40 //! maximum number of channels supported, avoids lots of mallocs
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
;
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
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
;
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() {
81 int free
= read_pos
- write_pos
- CHUNK_SIZE
;
82 if (free
< 0) free
+= BUFFSIZE
;
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() {
95 int used
= write_pos
- read_pos
;
96 if (used
< 0) used
+= BUFFSIZE
;
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 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 memcpy (buffer
, &data
[first_len
], len
- first_len
);
119 write_pos
= (write_pos
+ len
) % BUFFSIZE
;
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.
134 static int read_buffer(float **bufs
, int cnt
, int num_bufs
) {
135 int first_len
= BUFFSIZE
- read_pos
;
136 int buffered
= buf_used();
138 if (cnt
* sizeof(float) * num_bufs
> buffered
)
139 cnt
= buffered
/ sizeof(float) / num_bufs
;
140 for (i
= 0; i
< cnt
; i
++) {
141 for (j
= 0; j
< num_bufs
; j
++) {
142 bufs
[j
][i
] = *((float *)(&buffer
[read_pos
]));
143 read_pos
= (read_pos
+ sizeof(float)) % BUFFSIZE
;
149 // end ring buffer stuff
151 static int control(int cmd
, void *arg
) {
152 return CONTROL_UNKNOWN
;
156 * \brief fill the buffers with silence
157 * \param bufs num_bufs float buffers, each will contain the data of one channel
158 * \param cnt number of samples in each buffer
159 * \param num_bufs number of buffers
161 static void silence(float **bufs
, int cnt
, int num_bufs
) {
163 for (i
= 0; i
< cnt
; i
++)
164 for (j
= 0; j
< num_bufs
; j
++)
169 * \brief JACK Callback function
170 * \param nframes number of frames to fill into buffers
172 * \return currently always 0
174 * Write silence into buffers if paused or an underrun occured
176 static int outputaudio(jack_nframes_t nframes
, void *arg
) {
177 float *bufs
[MAX_CHANS
];
179 for (i
= 0; i
< num_ports
; i
++)
180 bufs
[i
] = jack_port_get_buffer(ports
[i
], nframes
);
181 if (!paused
&& !underrun
)
182 if (read_buffer(bufs
, nframes
, num_ports
) < nframes
)
184 if (paused
|| underrun
)
185 silence(bufs
, nframes
, num_ports
);
187 float now
= (float)GetTimer() / 1000000.0;
188 float diff
= callback_time
+ callback_interval
- now
;
189 if ((diff
> -0.002) && (diff
< 0.002))
190 callback_time
+= callback_interval
;
193 callback_interval
= (float)nframes
/ (float)ao_data
.samplerate
;
199 * \brief print suboption usage help
201 static void print_help ()
203 mp_msg (MSGT_AO
, MSGL_FATAL
,
204 "\n-ao jack commandline help:\n"
205 "Example: mplayer -ao jack:port=myout\n"
206 " connects MPlayer to the jack ports named myout\n"
208 " port=<port name>\n"
209 " Connects to the given ports instead of the default physical ones\n"
210 " name=<client name>\n"
211 " Client name to pass to JACK\n"
213 " Estimates the amount of data in buffers (experimental)\n");
216 static int init(int rate
, int channels
, int format
, int flags
) {
217 const char **matching_ports
= NULL
;
218 char *port_name
= NULL
;
219 char *client_name
= NULL
;
221 {"port", OPT_ARG_MSTRZ
, &port_name
, NULL
},
222 {"name", OPT_ARG_MSTRZ
, &client_name
, NULL
},
223 {"estimate", OPT_ARG_BOOL
, &estimate
, NULL
},
226 int port_flags
= JackPortIsInput
;
229 if (subopt_parse(ao_subdevice
, subopts
) != 0) {
233 if (channels
> MAX_CHANS
) {
234 mp_msg(MSGT_AO
, MSGL_FATAL
, "[JACK] Invalid number of channels: %i\n", channels
);
238 client_name
= (char *)malloc(40);
239 sprintf(client_name
, "MPlayer [%d]", getpid());
241 client
= jack_client_new(client_name
);
243 mp_msg(MSGT_AO
, MSGL_FATAL
, "[JACK] cannot open server\n");
247 jack_set_process_callback(client
, outputaudio
, 0);
249 // list matching ports
251 port_flags
|= JackPortIsPhysical
;
252 matching_ports
= jack_get_ports(client
, port_name
, NULL
, port_flags
);
253 for (num_ports
= 0; matching_ports
&& matching_ports
[num_ports
]; num_ports
++) ;
255 mp_msg(MSGT_AO
, MSGL_FATAL
, "[JACK] no physical ports available\n");
258 if (channels
> num_ports
) channels
= num_ports
;
259 num_ports
= channels
;
261 // create out output ports
262 for (i
= 0; i
< num_ports
; i
++) {
264 snprintf(pname
, 30, "out_%d", i
);
265 ports
[i
] = jack_port_register(client
, pname
, JACK_DEFAULT_AUDIO_TYPE
, JackPortIsOutput
, 0);
267 mp_msg(MSGT_AO
, MSGL_FATAL
, "[JACK] not enough ports available\n");
271 if (jack_activate(client
)) {
272 mp_msg(MSGT_AO
, MSGL_FATAL
, "[JACK] activate failed\n");
275 for (i
= 0; i
< num_ports
; i
++) {
276 if (jack_connect(client
, jack_port_name(ports
[i
]), matching_ports
[i
])) {
277 mp_msg(MSGT_AO
, MSGL_FATAL
, "[JACK] connecting failed\n");
281 rate
= jack_get_sample_rate(client
);
282 jack_latency
= (float)(jack_port_get_total_latency(client
, ports
[0]) +
283 jack_get_buffer_size(client
)) / (float)rate
;
284 callback_interval
= 0;
285 buffer
= (unsigned char *) malloc(BUFFSIZE
);
287 ao_data
.channels
= channels
;
288 ao_data
.samplerate
= rate
;
289 ao_data
.format
= AF_FORMAT_FLOAT_NE
;
290 ao_data
.bps
= channels
* rate
* sizeof(float);
291 ao_data
.buffersize
= CHUNK_SIZE
* NUM_CHUNKS
;
292 ao_data
.outburst
= CHUNK_SIZE
;
293 free(matching_ports
);
299 free(matching_ports
);
303 jack_client_close(client
);
309 // close audio device
310 static void uninit(int immed
) {
312 usec_sleep(get_delay() * 1000 * 1000);
313 // HACK, make sure jack doesn't loop-output dirty buffers
315 usec_sleep(100 * 1000);
316 jack_client_close(client
);
322 * \brief stop playing and empty buffers (for seeking/pause)
324 static void reset() {
332 * \brief stop playing, keep buffers (for pause)
334 static void audio_pause() {
339 * \brief resume playing, after audio_pause()
341 static void audio_resume() {
345 static int get_space() {
350 * \brief write data into buffer and reset underrun flag
352 static int play(void *data
, int len
, int flags
) {
353 len
-= len
% ao_data
.outburst
;
355 return write_buffer(data
, len
);
358 static float get_delay() {
359 int buffered
= BUFFSIZE
- CHUNK_SIZE
- buf_free(); // could be less
360 float in_jack
= jack_latency
;
361 if (estimate
&& callback_interval
> 0) {
362 float elapsed
= (float)GetTimer() / 1000000.0 - callback_time
;
363 in_jack
+= callback_interval
- elapsed
;
364 if (in_jack
< 0) in_jack
= 0;
366 return (float)buffered
/ (float)ao_data
.bps
+ in_jack
;