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 "libavformat/avformat.h"
33 #include "libavformat/internal.h"
34 #include "timefilter.h"
35 #include "avdevice.h"
36 
37 /**
38  * Size of the internal FIFO buffers as a number of audio packets
39  */
40 #define FIFO_PACKETS_NUM 16
41 
42 typedef struct JackData {
43  AVClass *class;
44  jack_client_t * client;
45  int activated;
47  jack_nframes_t sample_rate;
48  jack_nframes_t buffer_size;
49  jack_port_t ** ports;
50  int nports;
54  int pkt_xrun;
55  int jack_xrun;
56 } JackData;
57 
58 static int process_callback(jack_nframes_t nframes, void *arg)
59 {
60  /* Warning: this function runs in realtime. One mustn't allocate memory here
61  * or do any other thing that could block. */
62 
63  int i, j;
64  JackData *self = arg;
65  float * buffer;
66  jack_nframes_t latency, cycle_delay;
67  AVPacket pkt;
68  float *pkt_data;
69  double cycle_time;
70 
71  if (!self->client)
72  return 0;
73 
74  /* The approximate delay since the hardware interrupt as a number of frames */
75  cycle_delay = jack_frames_since_cycle_start(self->client);
76 
77  /* Retrieve filtered cycle time */
78  cycle_time = ff_timefilter_update(self->timefilter,
79  av_gettime() / 1000000.0 - (double) cycle_delay / self->sample_rate,
80  self->buffer_size);
81 
82  /* Check if an empty packet is available, and if there's enough space to send it back once filled */
83  if (!av_fifo_can_read(self->new_pkts) ||
84  !av_fifo_can_write(self->filled_pkts)) {
85  self->pkt_xrun = 1;
86  return 0;
87  }
88 
89  /* Retrieve empty (but allocated) packet */
90  av_fifo_read(self->new_pkts, &pkt, 1);
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_write(self->filled_pkts, &pkt, 1);
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_can_write(self->new_pkts)) {
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_write(self->new_pkts, &pkt, 1);
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[32];
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_alloc2(FIFO_PACKETS_NUM, sizeof(AVPacket), 0);
197  /* New packets FIFO with one extra packet for safety against underruns */
198  self->new_pkts = av_fifo_alloc2((FIFO_PACKETS_NUM + 1), sizeof(AVPacket), 0);
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(AVFifo **fifop)
213 {
214  AVFifo *fifo = *fifop;
215  AVPacket pkt;
216  while (av_fifo_read(fifo, &pkt, 1) >= 0)
218  av_fifo_freep2(fifop);
219 }
220 
221 static void stop_jack(JackData *self)
222 {
223  if (self->client) {
224  if (self->activated)
225  jack_deactivate(self->client);
226  jack_client_close(self->client);
227  }
228  sem_destroy(&self->packet_count);
229  free_pkt_fifo(&self->new_pkts);
230  free_pkt_fifo(&self->filled_pkts);
231  av_freep(&self->ports);
232  ff_timefilter_destroy(self->timefilter);
233 }
234 
236 {
237  JackData *self = context->priv_data;
238  AVStream *stream;
239  int test;
240 
241  if ((test = start_jack(context)))
242  return test;
243 
244  stream = avformat_new_stream(context, NULL);
245  if (!stream) {
246  stop_jack(self);
247  return AVERROR(ENOMEM);
248  }
249 
251 #if HAVE_BIGENDIAN
253 #else
255 #endif
256  stream->codecpar->sample_rate = self->sample_rate;
257  stream->codecpar->ch_layout.nb_channels = self->nports;
258 
259  avpriv_set_pts_info(stream, 64, 1, 1000000); /* 64 bits pts in us */
260  return 0;
261 }
262 
264 {
265  JackData *self = context->priv_data;
266  struct timespec timeout = {0, 0};
267  int test;
268 
269  /* Activate the JACK client on first packet read. Activating the JACK client
270  * means that process_callback() starts to get called at regular interval.
271  * If we activate it in audio_read_header(), we're actually reading audio data
272  * from the device before instructed to, and that may result in an overrun. */
273  if (!self->activated) {
274  if (!jack_activate(self->client)) {
275  self->activated = 1;
277  "JACK client registered and activated (rate=%dHz, buffer_size=%d frames)\n",
278  self->sample_rate, self->buffer_size);
279  } else {
280  av_log(context, AV_LOG_ERROR, "Unable to activate JACK client\n");
281  return AVERROR(EIO);
282  }
283  }
284 
285  /* Wait for a packet coming back from process_callback(), if one isn't available yet */
286  timeout.tv_sec = av_gettime() / 1000000 + 2;
287  if (sem_timedwait(&self->packet_count, &timeout)) {
288  if (errno == ETIMEDOUT) {
290  "Input error: timed out when waiting for JACK process callback output\n");
291  } else {
292  char errbuf[128];
293  int ret = AVERROR(errno);
294  av_strerror(ret, errbuf, sizeof(errbuf));
295  av_log(context, AV_LOG_ERROR, "Error while waiting for audio packet: %s\n",
296  errbuf);
297  }
298  if (!self->client)
299  av_log(context, AV_LOG_ERROR, "Input error: JACK server is gone\n");
300 
301  return AVERROR(EIO);
302  }
303 
304  if (self->pkt_xrun) {
305  av_log(context, AV_LOG_WARNING, "Audio packet xrun\n");
306  self->pkt_xrun = 0;
307  }
308 
309  if (self->jack_xrun) {
310  av_log(context, AV_LOG_WARNING, "JACK xrun\n");
311  self->jack_xrun = 0;
312  }
313 
314  /* Retrieve the packet filled with audio data by process_callback() */
315  av_fifo_read(self->filled_pkts, pkt, 1);
316 
317  if ((test = supply_new_packets(self, context)))
318  return test;
319 
320  return 0;
321 }
322 
324 {
325  JackData *self = context->priv_data;
326  stop_jack(self);
327  return 0;
328 }
329 
330 #define OFFSET(x) offsetof(JackData, x)
331 static const AVOption options[] = {
332  { "channels", "Number of audio channels.", OFFSET(nports), AV_OPT_TYPE_INT, { .i64 = 2 }, 1, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
333  { NULL },
334 };
335 
336 static const AVClass jack_indev_class = {
337  .class_name = "JACK indev",
338  .item_name = av_default_item_name,
339  .option = options,
340  .version = LIBAVUTIL_VERSION_INT,
342 };
343 
345  .name = "jack",
346  .long_name = NULL_IF_CONFIG_SMALL("JACK Audio Connection Kit"),
347  .priv_data_size = sizeof(JackData),
351  .flags = AVFMT_NOFILE,
352  .priv_class = &jack_indev_class,
353 };
ff_jack_demuxer
const AVInputFormat ff_jack_demuxer
Definition: jack.c:344
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:422
TimeFilter
Opaque type representing a time filter state.
Definition: timefilter.c:34
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AV_CODEC_ID_PCM_F32BE
@ AV_CODEC_ID_PCM_F32BE
Definition: codec_id.h:346
av_fifo_can_write
size_t av_fifo_can_write(const AVFifo *f)
Definition: fifo.c:94
status
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
JackData::packet_count
sem_t packet_count
Definition: jack.c:46
OFFSET
#define OFFSET(x)
Definition: jack.c:330
AVERROR
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
opt.h
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: options.c:237
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:58
JackData::client
jack_client_t * client
Definition: jack.c:44
sem_t
#define sem_t
Definition: semaphore.h:25
xrun_callback
static int xrun_callback(void *arg)
Definition: jack.c:121
FIFO_PACKETS_NUM
#define FIFO_PACKETS_NUM
Size of the internal FIFO buffers as a number of audio packets.
Definition: jack.c:40
AVPacket::data
uint8_t * data
Definition: packet.h:374
AVOption
AVOption.
Definition: opt.h:251
test
Definition: idctdsp.c:34
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:311
JackData::jack_xrun
int jack_xrun
Definition: jack.c:55
start_jack
static int start_jack(AVFormatContext *context)
Definition: jack.c:147
JackData
Definition: jack.c:42
jack_indev_class
static const AVClass jack_indev_class
Definition: jack.c:336
fifo.h
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:763
JackData::ports
jack_port_t ** ports
Definition: jack.c:49
av_fifo_write
int av_fifo_write(AVFifo *f, const void *buf, size_t nb_elems)
Write data into a FIFO.
Definition: fifo.c:188
av_strerror
int av_strerror(int errnum, char *errbuf, size_t errbuf_size)
Put a description of the AVERROR code errnum in errbuf.
Definition: error.c:108
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:143
ff_timefilter_new
TimeFilter * ff_timefilter_new(double time_base, double period, double bandwidth)
Create a new Delay Locked Loop time filter.
Definition: timefilter.c:50
JackData::sample_rate
jack_nframes_t sample_rate
Definition: jack.c:47
AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT
@ AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT
Definition: log.h:43
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVInputFormat
Definition: avformat.h:656
av_fifo_read
int av_fifo_read(AVFifo *f, void *buf, size_t nb_elems)
Read data from a FIFO.
Definition: fifo.c:240
semaphore.h
sem_timedwait
#define sem_timedwait(psem, val)
Definition: semaphore.h:28
float
float
Definition: af_crystalizer.c:122
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:97
process_callback
static int process_callback(jack_nframes_t nframes, void *arg)
Definition: jack.c:58
free_pkt_fifo
static void free_pkt_fifo(AVFifo **fifop)
Definition: jack.c:212
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:661
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
JackData::pkt_xrun
int pkt_xrun
Definition: jack.c:54
audio_read_packet
static int audio_read_packet(AVFormatContext *context, AVPacket *pkt)
Definition: jack.c:263
arg
const char * arg
Definition: jacosubdec.c:67
JackData::new_pkts
AVFifo * new_pkts
Definition: jack.c:52
context
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 context
Definition: writing_filters.txt:91
AVFormatContext
Format I/O context.
Definition: avformat.h:1216
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1108
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:540
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
timefilter.h
shutdown_callback
static void shutdown_callback(void *arg)
Definition: jack.c:115
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
av_fifo_can_read
size_t av_fifo_can_read(const AVFifo *f)
Definition: fifo.c:87
double
double
Definition: af_crystalizer.c:132
time.h
supply_new_packets
static int supply_new_packets(JackData *self, AVFormatContext *context)
Definition: jack.c:129
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:213
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:178
AVFifo
Definition: fifo.c:35
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:115
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
stop_jack
static void stop_jack(JackData *self)
Definition: jack.c:221
JackData::timefilter
TimeFilter * timefilter
Definition: jack.c:51
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:470
audio_read_close
static int audio_read_close(AVFormatContext *context)
Definition: jack.c:323
avdevice.h
ff_timefilter_reset
void ff_timefilter_reset(TimeFilter *self)
Reset the filter.
Definition: timefilter.c:71
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
ff_timefilter_destroy
void ff_timefilter_destroy(TimeFilter *self)
Free all resources associated with the filter.
Definition: timefilter.c:66
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:367
internal.h
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
options
static const AVOption options[]
Definition: jack.c:331
AV_OPT_FLAG_DECODING_PARAM
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:282
ff_timefilter_update
double ff_timefilter_update(TimeFilter *self, double system_time, double period)
Update the filter.
Definition: timefilter.c:76
JackData::nports
int nports
Definition: jack.c:50
sem_destroy
#define sem_destroy(psem)
Definition: semaphore.h:29
ret
ret
Definition: filter_design.txt:187
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
AVStream
Stream structure.
Definition: avformat.h:948
AVClass::class_name
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:71
avformat.h
av_fifo_alloc2
AVFifo * av_fifo_alloc2(size_t nb_elems, size_t elem_size, unsigned int flags)
Allocate and initialize an AVFifo with a given element size.
Definition: fifo.c:47
test
static int test(void)
Definition: dnn-layer-dense.c:28
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
sem_post
#define sem_post(psem)
Definition: semaphore.h:26
av_gettime
int64_t av_gettime(void)
Get the current time in microseconds.
Definition: time.c:39
JackData::buffer_size
jack_nframes_t buffer_size
Definition: jack.c:48
JackData::filled_pkts
AVFifo * filled_pkts
Definition: jack.c:53
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:62
AVPacket
This structure stores compressed data.
Definition: packet.h:351
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
convert_header.str
string str
Definition: convert_header.py:20
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AV_CODEC_ID_PCM_F32LE
@ AV_CODEC_ID_PCM_F32LE
Definition: codec_id.h:347
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
av_fifo_freep2
void av_fifo_freep2(AVFifo **f)
Free an AVFifo and reset pointer to NULL.
Definition: fifo.c:286
JackData::activated
int activated
Definition: jack.c:45
snprintf
#define snprintf
Definition: snprintf.h:34
audio_read_header
static int audio_read_header(AVFormatContext *context)
Definition: jack.c:235
sem_init
#define sem_init
Definition: semaphore.h:40