FFmpeg
jack.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 FFmpeg.
7  *
8  * FFmpeg 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  * FFmpeg 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 FFmpeg; 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/internal.h"
28 #include "libavutil/log.h"
29 #include "libavutil/fifo.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/time.h"
32 #include "libavcodec/avcodec.h"
33 #include "libavformat/avformat.h"
34 #include "libavformat/internal.h"
35 #include "timefilter.h"
36 #include "avdevice.h"
37 
38 /**
39  * Size of the internal FIFO buffers as a number of audio packets
40  */
41 #define FIFO_PACKETS_NUM 16
42 
43 typedef struct JackData {
44  AVClass *class;
45  jack_client_t * client;
46  int activated;
48  jack_nframes_t sample_rate;
49  jack_nframes_t buffer_size;
50  jack_port_t ** ports;
51  int nports;
55  int pkt_xrun;
56  int jack_xrun;
57 } JackData;
58 
59 static int process_callback(jack_nframes_t nframes, void *arg)
60 {
61  /* Warning: this function runs in realtime. One mustn't allocate memory here
62  * or do any other thing that could block. */
63 
64  int i, j;
65  JackData *self = arg;
66  float * buffer;
67  jack_nframes_t latency, cycle_delay;
68  AVPacket pkt;
69  float *pkt_data;
70  double cycle_time;
71 
72  if (!self->client)
73  return 0;
74 
75  /* The approximate delay since the hardware interrupt as a number of frames */
76  cycle_delay = jack_frames_since_cycle_start(self->client);
77 
78  /* Retrieve filtered cycle time */
79  cycle_time = ff_timefilter_update(self->timefilter,
80  av_gettime() / 1000000.0 - (double) cycle_delay / self->sample_rate,
81  self->buffer_size);
82 
83  /* Check if an empty packet is available, and if there's enough space to send it back once filled */
84  if ((av_fifo_size(self->new_pkts) < sizeof(pkt)) || (av_fifo_space(self->filled_pkts) < sizeof(pkt))) {
85  self->pkt_xrun = 1;
86  return 0;
87  }
88 
89  /* Retrieve empty (but allocated) packet */
90  av_fifo_generic_read(self->new_pkts, &pkt, sizeof(pkt), NULL);
91 
92  pkt_data = (float *) pkt.data;
93  latency = 0;
94 
95  /* Copy and interleave audio data from the JACK buffer into the packet */
96  for (i = 0; i < self->nports; i++) {
97  jack_latency_range_t range;
98  jack_port_get_latency_range(self->ports[i], JackCaptureLatency, &range);
99  latency += range.max;
100  buffer = jack_port_get_buffer(self->ports[i], self->buffer_size);
101  for (j = 0; j < self->buffer_size; j++)
102  pkt_data[j * self->nports + i] = buffer[j];
103  }
104 
105  /* Timestamp the packet with the cycle start time minus the average latency */
106  pkt.pts = (cycle_time - (double) latency / (self->nports * self->sample_rate)) * 1000000.0;
107 
108  /* Send the now filled packet back, and increase packet counter */
109  av_fifo_generic_write(self->filled_pkts, &pkt, sizeof(pkt), NULL);
110  sem_post(&self->packet_count);
111 
112  return 0;
113 }
114 
115 static void shutdown_callback(void *arg)
116 {
117  JackData *self = arg;
118  self->client = NULL;
119 }
120 
121 static int xrun_callback(void *arg)
122 {
123  JackData *self = arg;
124  self->jack_xrun = 1;
125  ff_timefilter_reset(self->timefilter);
126  return 0;
127 }
128 
130 {
131  AVPacket pkt;
132  int test, pkt_size = self->buffer_size * self->nports * sizeof(float);
133 
134  /* Supply the process callback with new empty packets, by filling the new
135  * packets FIFO buffer with as many packets as possible. process_callback()
136  * can't do this by itself, because it can't allocate memory in realtime. */
137  while (av_fifo_space(self->new_pkts) >= sizeof(pkt)) {
138  if ((test = av_new_packet(&pkt, pkt_size)) < 0) {
139  av_log(context, AV_LOG_ERROR, "Could not create packet of size %d\n", pkt_size);
140  return test;
141  }
142  av_fifo_generic_write(self->new_pkts, &pkt, sizeof(pkt), NULL);
143  }
144  return 0;
145 }
146 
148 {
149  JackData *self = context->priv_data;
150  jack_status_t status;
151  int i, test;
152 
153  /* Register as a JACK client, using the context url as client name. */
154  self->client = jack_client_open(context->url, JackNullOption, &status);
155  if (!self->client) {
156  av_log(context, AV_LOG_ERROR, "Unable to register as a JACK client\n");
157  return AVERROR(EIO);
158  }
159 
160  sem_init(&self->packet_count, 0, 0);
161 
162  self->sample_rate = jack_get_sample_rate(self->client);
163  self->ports = av_malloc_array(self->nports, sizeof(*self->ports));
164  if (!self->ports)
165  return AVERROR(ENOMEM);
166  self->buffer_size = jack_get_buffer_size(self->client);
167 
168  /* Register JACK ports */
169  for (i = 0; i < self->nports; i++) {
170  char str[16];
171  snprintf(str, sizeof(str), "input_%d", i + 1);
172  self->ports[i] = jack_port_register(self->client, str,
173  JACK_DEFAULT_AUDIO_TYPE,
174  JackPortIsInput, 0);
175  if (!self->ports[i]) {
176  av_log(context, AV_LOG_ERROR, "Unable to register port %s:%s\n",
177  context->url, str);
178  jack_client_close(self->client);
179  return AVERROR(EIO);
180  }
181  }
182 
183  /* Register JACK callbacks */
184  jack_set_process_callback(self->client, process_callback, self);
185  jack_on_shutdown(self->client, shutdown_callback, self);
186  jack_set_xrun_callback(self->client, xrun_callback, self);
187 
188  /* Create time filter */
189  self->timefilter = ff_timefilter_new (1.0 / self->sample_rate, self->buffer_size, 1.5);
190  if (!self->timefilter) {
191  jack_client_close(self->client);
192  return AVERROR(ENOMEM);
193  }
194 
195  /* Create FIFO buffers */
196  self->filled_pkts = av_fifo_alloc_array(FIFO_PACKETS_NUM, sizeof(AVPacket));
197  /* New packets FIFO with one extra packet for safety against underruns */
198  self->new_pkts = av_fifo_alloc_array((FIFO_PACKETS_NUM + 1), sizeof(AVPacket));
199  if (!self->new_pkts) {
200  jack_client_close(self->client);
201  return AVERROR(ENOMEM);
202  }
203  if ((test = supply_new_packets(self, context))) {
204  jack_client_close(self->client);
205  return test;
206  }
207 
208  return 0;
209 
210 }
211 
212 static void free_pkt_fifo(AVFifoBuffer **fifo)
213 {
214  AVPacket pkt;
215  while (av_fifo_size(*fifo)) {
216  av_fifo_generic_read(*fifo, &pkt, sizeof(pkt), NULL);
217  av_packet_unref(&pkt);
218  }
219  av_fifo_freep(fifo);
220 }
221 
222 static void stop_jack(JackData *self)
223 {
224  if (self->client) {
225  if (self->activated)
226  jack_deactivate(self->client);
227  jack_client_close(self->client);
228  }
229  sem_destroy(&self->packet_count);
230  free_pkt_fifo(&self->new_pkts);
231  free_pkt_fifo(&self->filled_pkts);
232  av_freep(&self->ports);
233  ff_timefilter_destroy(self->timefilter);
234 }
235 
237 {
238  JackData *self = context->priv_data;
239  AVStream *stream;
240  int test;
241 
242  if ((test = start_jack(context)))
243  return test;
244 
245  stream = avformat_new_stream(context, NULL);
246  if (!stream) {
247  stop_jack(self);
248  return AVERROR(ENOMEM);
249  }
250 
252 #if HAVE_BIGENDIAN
254 #else
256 #endif
257  stream->codecpar->sample_rate = self->sample_rate;
258  stream->codecpar->channels = self->nports;
259 
260  avpriv_set_pts_info(stream, 64, 1, 1000000); /* 64 bits pts in us */
261  return 0;
262 }
263 
265 {
266  JackData *self = context->priv_data;
267  struct timespec timeout = {0, 0};
268  int test;
269 
270  /* Activate the JACK client on first packet read. Activating the JACK client
271  * means that process_callback() starts to get called at regular interval.
272  * If we activate it in audio_read_header(), we're actually reading audio data
273  * from the device before instructed to, and that may result in an overrun. */
274  if (!self->activated) {
275  if (!jack_activate(self->client)) {
276  self->activated = 1;
277  av_log(context, AV_LOG_INFO,
278  "JACK client registered and activated (rate=%dHz, buffer_size=%d frames)\n",
279  self->sample_rate, self->buffer_size);
280  } else {
281  av_log(context, AV_LOG_ERROR, "Unable to activate JACK client\n");
282  return AVERROR(EIO);
283  }
284  }
285 
286  /* Wait for a packet coming back from process_callback(), if one isn't available yet */
287  timeout.tv_sec = av_gettime() / 1000000 + 2;
288  if (sem_timedwait(&self->packet_count, &timeout)) {
289  if (errno == ETIMEDOUT) {
290  av_log(context, AV_LOG_ERROR,
291  "Input error: timed out when waiting for JACK process callback output\n");
292  } else {
293  char errbuf[128];
294  int ret = AVERROR(errno);
295  av_strerror(ret, errbuf, sizeof(errbuf));
296  av_log(context, AV_LOG_ERROR, "Error while waiting for audio packet: %s\n",
297  errbuf);
298  }
299  if (!self->client)
300  av_log(context, AV_LOG_ERROR, "Input error: JACK server is gone\n");
301 
302  return AVERROR(EIO);
303  }
304 
305  if (self->pkt_xrun) {
306  av_log(context, AV_LOG_WARNING, "Audio packet xrun\n");
307  self->pkt_xrun = 0;
308  }
309 
310  if (self->jack_xrun) {
311  av_log(context, AV_LOG_WARNING, "JACK xrun\n");
312  self->jack_xrun = 0;
313  }
314 
315  /* Retrieve the packet filled with audio data by process_callback() */
316  av_fifo_generic_read(self->filled_pkts, pkt, sizeof(*pkt), NULL);
317 
318  if ((test = supply_new_packets(self, context)))
319  return test;
320 
321  return 0;
322 }
323 
325 {
326  JackData *self = context->priv_data;
327  stop_jack(self);
328  return 0;
329 }
330 
331 #define OFFSET(x) offsetof(JackData, x)
332 static const AVOption options[] = {
333  { "channels", "Number of audio channels.", OFFSET(nports), AV_OPT_TYPE_INT, { .i64 = 2 }, 1, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
334  { NULL },
335 };
336 
337 static const AVClass jack_indev_class = {
338  .class_name = "JACK indev",
339  .item_name = av_default_item_name,
340  .option = options,
341  .version = LIBAVUTIL_VERSION_INT,
343 };
344 
346  .name = "jack",
347  .long_name = NULL_IF_CONFIG_SMALL("JACK Audio Connection Kit"),
348  .priv_data_size = sizeof(JackData),
352  .flags = AVFMT_NOFILE,
353  .priv_class = &jack_indev_class,
354 };
jack_client_t * client
Definition: jack.c:45
#define NULL
Definition: coverity.c:32
int pkt_xrun
Definition: jack.c:55
AVOption.
Definition: opt.h:246
void ff_timefilter_destroy(TimeFilter *self)
Free all resources associated with the filter.
Definition: timefilter.c:62
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
void ff_timefilter_reset(TimeFilter *self)
Reset the filter.
Definition: timefilter.c:67
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4892
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3957
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
int jack_xrun
Definition: jack.c:56
static AVPacket pkt
#define sem_t
Definition: semaphore.h:25
int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int(*func)(void *, void *, int))
Feed data from a user-supplied callback to an AVFifoBuffer.
Definition: fifo.c:122
Definition: jack.c:43
Format I/O context.
Definition: avformat.h:1358
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
Opaque type representing a time filter state.
Definition: timefilter.c:30
AVOptions.
static int supply_new_packets(JackData *self, AVFormatContext *context)
Definition: jack.c:129
int av_fifo_space(const AVFifoBuffer *f)
Return the amount of space in bytes in the AVFifoBuffer, that is the amount of data you can write int...
Definition: fifo.c:82
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4465
AVInputFormat ff_jack_demuxer
Definition: jack.c:345
AVFifoBuffer * filled_pkts
Definition: jack.c:54
static void free_pkt_fifo(AVFifoBuffer **fifo)
Definition: jack.c:212
jack_port_t ** ports
Definition: jack.c:50
#define sem_init
Definition: semaphore.h:40
uint8_t * data
Definition: avcodec.h:1477
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:145
#define FIFO_PACKETS_NUM
Size of the internal FIFO buffers as a number of audio packets.
Definition: jack.c:41
#define sem_post(psem)
Definition: semaphore.h:26
#define av_log(a,...)
Main libavdevice API header.
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:86
int nports
Definition: jack.c:51
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
char * url
input or output URL.
Definition: avformat.h:1454
int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void(*func)(void *, void *, int))
Feed data from an AVFifoBuffer to a user-supplied callback.
Definition: fifo.c:213
static const AVOption options[]
Definition: jack.c:332
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3953
const char * arg
Definition: jacosubdec.c:66
#define sem_destroy(psem)
Definition: semaphore.h:29
static int start_jack(AVFormatContext *context)
Definition: jack.c:147
int activated
Definition: jack.c:46
common internal API header
sem_t packet_count
Definition: jack.c:47
#define sem_timedwait(psem, val)
Definition: semaphore.h:28
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:530
int64_t av_gettime(void)
Get the current time in microseconds.
Definition: time.c:39
Stream structure.
Definition: avformat.h:881
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
TimeFilter * ff_timefilter_new(double time_base, double period, double bandwidth)
Create a new Delay Locked Loop time filter.
Definition: timefilter.c:46
Libavcodec external API header.
static int audio_read_packet(AVFormatContext *context, AVPacket *pkt)
Definition: jack.c:264
int av_fifo_size(const AVFifoBuffer *f)
Return the amount of data in bytes in the AVFifoBuffer, that is the amount of data you can read from ...
Definition: fifo.c:77
static void test(const char *pattern, const char *host)
Definition: noproxy.c:23
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:599
jack_nframes_t sample_rate
Definition: jack.c:48
a very simple circular buffer FIFO implementation
Describe the class of an AVClass context structure.
Definition: log.h:67
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:277
they must not be accessed directly The fifo field contains the frames that are queued in the input for processing by the filter The status_in and status_out fields contains the queued status(EOF or error) of the link
#define snprintf
Definition: snprintf.h:34
#define OFFSET(x)
Definition: jack.c:331
static int process_callback(jack_nframes_t nframes, void *arg)
Definition: jack.c:59
static void shutdown_callback(void *arg)
Definition: jack.c:115
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AVFifoBuffer * av_fifo_alloc_array(size_t nmemb, size_t size)
Initialize an AVFifoBuffer.
Definition: fifo.c:49
static int audio_read_close(AVFormatContext *context)
Definition: jack.c:324
int av_strerror(int errnum, char *errbuf, size_t errbuf_size)
Put a description of the AVERROR code errnum in errbuf.
Definition: error.c:105
int sample_rate
Audio only.
Definition: avcodec.h:4067
TimeFilter * timefilter
Definition: jack.c:52
Main libavformat public API header.
double ff_timefilter_update(TimeFilter *self, double system_time, double period)
Update the filter.
Definition: timefilter.c:72
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:463
static int audio_read_header(AVFormatContext *context)
Definition: jack.c:236
static int xrun_callback(void *arg)
Definition: jack.c:121
static const AVClass jack_indev_class
Definition: jack.c:337
void * priv_data
Format private data.
Definition: avformat.h:1386
int channels
Audio only.
Definition: avcodec.h:4063
#define av_freep(p)
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:654
void av_fifo_freep(AVFifoBuffer **f)
Free an AVFifoBuffer and reset pointer to NULL.
Definition: fifo.c:63
jack_nframes_t buffer_size
Definition: jack.c:49
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1028
#define av_malloc_array(a, b)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your local context
This structure stores compressed data.
Definition: avcodec.h:1454
static void stop_jack(JackData *self)
Definition: jack.c:222
AVFifoBuffer * new_pkts
Definition: jack.c:53
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1470
for(j=16;j >0;--j)
GLuint buffer
Definition: opengl_enc.c:101