jack_audio.c
Go to the documentation of this file.
1 /*
2  * JACK Audio Connection Kit input device
3  * Copyright (c) 2009 Samalyse
4  * Author: Olivier Guilyardi <olivier samalyse com>
5  *
6  * This file is part of Libav.
7  *
8  * Libav is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * Libav is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with Libav; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include "config.h"
24 #include <semaphore.h>
25 #include <jack/jack.h>
26 
27 #include "libavutil/log.h"
28 #include "libavutil/fifo.h"
29 #include "libavutil/opt.h"
30 #include "libavcodec/avcodec.h"
31 #include "libavformat/avformat.h"
32 #include "libavformat/internal.h"
33 #include "timefilter.h"
34 
38 #define FIFO_PACKETS_NUM 16
39 
40 typedef struct {
41  AVClass *class;
42  jack_client_t * client;
43  int activated;
44  sem_t packet_count;
45  jack_nframes_t sample_rate;
46  jack_nframes_t buffer_size;
47  jack_port_t ** ports;
48  int nports;
52  int pkt_xrun;
53  int jack_xrun;
54 } JackData;
55 
56 static int process_callback(jack_nframes_t nframes, void *arg)
57 {
58  /* Warning: this function runs in realtime. One mustn't allocate memory here
59  * or do any other thing that could block. */
60 
61  int i, j;
62  JackData *self = arg;
63  float * buffer;
64  jack_nframes_t latency, cycle_delay;
65  AVPacket pkt;
66  float *pkt_data;
67  double cycle_time;
68 
69  if (!self->client)
70  return 0;
71 
72  /* The approximate delay since the hardware interrupt as a number of frames */
73  cycle_delay = jack_frames_since_cycle_start(self->client);
74 
75  /* Retrieve filtered cycle time */
76  cycle_time = ff_timefilter_update(self->timefilter,
77  av_gettime() / 1000000.0 - (double) cycle_delay / self->sample_rate,
78  self->buffer_size);
79 
80  /* Check if an empty packet is available, and if there's enough space to send it back once filled */
81  if ((av_fifo_size(self->new_pkts) < sizeof(pkt)) || (av_fifo_space(self->filled_pkts) < sizeof(pkt))) {
82  self->pkt_xrun = 1;
83  return 0;
84  }
85 
86  /* Retrieve empty (but allocated) packet */
87  av_fifo_generic_read(self->new_pkts, &pkt, sizeof(pkt), NULL);
88 
89  pkt_data = (float *) pkt.data;
90  latency = 0;
91 
92  /* Copy and interleave audio data from the JACK buffer into the packet */
93  for (i = 0; i < self->nports; i++) {
94  latency += jack_port_get_total_latency(self->client, self->ports[i]);
95  buffer = jack_port_get_buffer(self->ports[i], self->buffer_size);
96  for (j = 0; j < self->buffer_size; j++)
97  pkt_data[j * self->nports + i] = buffer[j];
98  }
99 
100  /* Timestamp the packet with the cycle start time minus the average latency */
101  pkt.pts = (cycle_time - (double) latency / (self->nports * self->sample_rate)) * 1000000.0;
102 
103  /* Send the now filled packet back, and increase packet counter */
104  av_fifo_generic_write(self->filled_pkts, &pkt, sizeof(pkt), NULL);
105  sem_post(&self->packet_count);
106 
107  return 0;
108 }
109 
110 static void shutdown_callback(void *arg)
111 {
112  JackData *self = arg;
113  self->client = NULL;
114 }
115 
116 static int xrun_callback(void *arg)
117 {
118  JackData *self = arg;
119  self->jack_xrun = 1;
120  ff_timefilter_reset(self->timefilter);
121  return 0;
122 }
123 
124 static int supply_new_packets(JackData *self, AVFormatContext *context)
125 {
126  AVPacket pkt;
127  int test, pkt_size = self->buffer_size * self->nports * sizeof(float);
128 
129  /* Supply the process callback with new empty packets, by filling the new
130  * packets FIFO buffer with as many packets as possible. process_callback()
131  * can't do this by itself, because it can't allocate memory in realtime. */
132  while (av_fifo_space(self->new_pkts) >= sizeof(pkt)) {
133  if ((test = av_new_packet(&pkt, pkt_size)) < 0) {
134  av_log(context, AV_LOG_ERROR, "Could not create packet of size %d\n", pkt_size);
135  return test;
136  }
137  av_fifo_generic_write(self->new_pkts, &pkt, sizeof(pkt), NULL);
138  }
139  return 0;
140 }
141 
142 static int start_jack(AVFormatContext *context)
143 {
144  JackData *self = context->priv_data;
145  jack_status_t status;
146  int i, test;
147  double o, period;
148 
149  /* Register as a JACK client, using the context filename as client name. */
150  self->client = jack_client_open(context->filename, JackNullOption, &status);
151  if (!self->client) {
152  av_log(context, AV_LOG_ERROR, "Unable to register as a JACK client\n");
153  return AVERROR(EIO);
154  }
155 
156  sem_init(&self->packet_count, 0, 0);
157 
158  self->sample_rate = jack_get_sample_rate(self->client);
159  self->ports = av_malloc(self->nports * sizeof(*self->ports));
160  self->buffer_size = jack_get_buffer_size(self->client);
161 
162  /* Register JACK ports */
163  for (i = 0; i < self->nports; i++) {
164  char str[16];
165  snprintf(str, sizeof(str), "input_%d", i + 1);
166  self->ports[i] = jack_port_register(self->client, str,
167  JACK_DEFAULT_AUDIO_TYPE,
168  JackPortIsInput, 0);
169  if (!self->ports[i]) {
170  av_log(context, AV_LOG_ERROR, "Unable to register port %s:%s\n",
171  context->filename, str);
172  jack_client_close(self->client);
173  return AVERROR(EIO);
174  }
175  }
176 
177  /* Register JACK callbacks */
178  jack_set_process_callback(self->client, process_callback, self);
179  jack_on_shutdown(self->client, shutdown_callback, self);
180  jack_set_xrun_callback(self->client, xrun_callback, self);
181 
182  /* Create time filter */
183  period = (double) self->buffer_size / self->sample_rate;
184  o = 2 * M_PI * 1.5 * period;
185  self->timefilter = ff_timefilter_new (1.0 / self->sample_rate, sqrt(2 * o), o * o);
186 
187  /* Create FIFO buffers */
188  self->filled_pkts = av_fifo_alloc(FIFO_PACKETS_NUM * sizeof(AVPacket));
189  /* New packets FIFO with one extra packet for safety against underruns */
190  self->new_pkts = av_fifo_alloc((FIFO_PACKETS_NUM + 1) * sizeof(AVPacket));
191  if ((test = supply_new_packets(self, context))) {
192  jack_client_close(self->client);
193  return test;
194  }
195 
196  return 0;
197 
198 }
199 
200 static void free_pkt_fifo(AVFifoBuffer *fifo)
201 {
202  AVPacket pkt;
203  while (av_fifo_size(fifo)) {
204  av_fifo_generic_read(fifo, &pkt, sizeof(pkt), NULL);
205  av_free_packet(&pkt);
206  }
207  av_fifo_free(fifo);
208 }
209 
210 static void stop_jack(JackData *self)
211 {
212  if (self->client) {
213  if (self->activated)
214  jack_deactivate(self->client);
215  jack_client_close(self->client);
216  }
217  sem_destroy(&self->packet_count);
218  free_pkt_fifo(self->new_pkts);
219  free_pkt_fifo(self->filled_pkts);
220  av_freep(&self->ports);
221  ff_timefilter_destroy(self->timefilter);
222 }
223 
225 {
226  JackData *self = context->priv_data;
227  AVStream *stream;
228  int test;
229 
230  if ((test = start_jack(context)))
231  return test;
232 
233  stream = avformat_new_stream(context, NULL);
234  if (!stream) {
235  stop_jack(self);
236  return AVERROR(ENOMEM);
237  }
238 
240 #if HAVE_BIGENDIAN
241  stream->codec->codec_id = CODEC_ID_PCM_F32BE;
242 #else
243  stream->codec->codec_id = CODEC_ID_PCM_F32LE;
244 #endif
245  stream->codec->sample_rate = self->sample_rate;
246  stream->codec->channels = self->nports;
247 
248  avpriv_set_pts_info(stream, 64, 1, 1000000); /* 64 bits pts in us */
249  return 0;
250 }
251 
252 static int audio_read_packet(AVFormatContext *context, AVPacket *pkt)
253 {
254  JackData *self = context->priv_data;
255  struct timespec timeout = {0, 0};
256  int test;
257 
258  /* Activate the JACK client on first packet read. Activating the JACK client
259  * means that process_callback() starts to get called at regular interval.
260  * If we activate it in audio_read_header(), we're actually reading audio data
261  * from the device before instructed to, and that may result in an overrun. */
262  if (!self->activated) {
263  if (!jack_activate(self->client)) {
264  self->activated = 1;
265  av_log(context, AV_LOG_INFO,
266  "JACK client registered and activated (rate=%dHz, buffer_size=%d frames)\n",
267  self->sample_rate, self->buffer_size);
268  } else {
269  av_log(context, AV_LOG_ERROR, "Unable to activate JACK client\n");
270  return AVERROR(EIO);
271  }
272  }
273 
274  /* Wait for a packet coming back from process_callback(), if one isn't available yet */
275  timeout.tv_sec = av_gettime() / 1000000 + 2;
276  if (sem_timedwait(&self->packet_count, &timeout)) {
277  if (errno == ETIMEDOUT) {
278  av_log(context, AV_LOG_ERROR,
279  "Input error: timed out when waiting for JACK process callback output\n");
280  } else {
281  av_log(context, AV_LOG_ERROR, "Error while waiting for audio packet: %s\n",
282  strerror(errno));
283  }
284  if (!self->client)
285  av_log(context, AV_LOG_ERROR, "Input error: JACK server is gone\n");
286 
287  return AVERROR(EIO);
288  }
289 
290  if (self->pkt_xrun) {
291  av_log(context, AV_LOG_WARNING, "Audio packet xrun\n");
292  self->pkt_xrun = 0;
293  }
294 
295  if (self->jack_xrun) {
296  av_log(context, AV_LOG_WARNING, "JACK xrun\n");
297  self->jack_xrun = 0;
298  }
299 
300  /* Retrieve the packet filled with audio data by process_callback() */
301  av_fifo_generic_read(self->filled_pkts, pkt, sizeof(*pkt), NULL);
302 
303  if ((test = supply_new_packets(self, context)))
304  return test;
305 
306  return 0;
307 }
308 
309 static int audio_read_close(AVFormatContext *context)
310 {
311  JackData *self = context->priv_data;
312  stop_jack(self);
313  return 0;
314 }
315 
316 #define OFFSET(x) offsetof(JackData, x)
317 static const AVOption options[] = {
318  { "channels", "Number of audio channels.", OFFSET(nports), AV_OPT_TYPE_INT, { 2 }, 1, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
319  { NULL },
320 };
321 
322 static const AVClass jack_indev_class = {
323  .class_name = "JACK indev",
324  .item_name = av_default_item_name,
325  .option = options,
326  .version = LIBAVUTIL_VERSION_INT,
327 };
328 
330  .name = "jack",
331  .long_name = NULL_IF_CONFIG_SMALL("JACK Audio Connection Kit"),
332  .priv_data_size = sizeof(JackData),
336  .flags = AVFMT_NOFILE,
337  .priv_class = &jack_indev_class,
338 };