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[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_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);
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;
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) {
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 };
ff_jack_demuxer
const AVInputFormat ff_jack_demuxer
Definition: jack.c:345
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:424
TimeFilter
Opaque type representing a time filter state.
Definition: timefilter.c:30
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:334
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:47
OFFSET
#define OFFSET(x)
Definition: jack.c:331
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: utils.c:768
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
JackData::client
jack_client_t * client
Definition: jack.c:45
av_fifo_generic_write
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
sem_t
#define sem_t
Definition: semaphore.h:25
JackData::new_pkts
AVFifoBuffer * new_pkts
Definition: jack.c:53
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:41
AVPacket::data
uint8_t * data
Definition: packet.h:373
AVOption
AVOption.
Definition: opt.h:247
av_fifo_generic_read
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
JackData::filled_pkts
AVFifoBuffer * filled_pkts
Definition: jack.c:54
JackData::jack_xrun
int jack_xrun
Definition: jack.c:56
start_jack
static int start_jack(AVFormatContext *context)
Definition: jack.c:147
AVFifoBuffer
Definition: fifo.h:31
JackData
Definition: jack.c:43
jack_indev_class
static const AVClass jack_indev_class
Definition: jack.c:337
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
fifo.h
JackData::ports
jack_port_t ** ports
Definition: jack.c:50
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:105
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:141
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:46
JackData::sample_rate
jack_nframes_t sample_rate
Definition: jack.c:48
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
av_fifo_space
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
AVInputFormat
Definition: avformat.h:650
semaphore.h
sem_timedwait
#define sem_timedwait(psem, val)
Definition: semaphore.h:28
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:99
process_callback
static int process_callback(jack_nframes_t nframes, void *arg)
Definition: jack.c:59
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:655
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
JackData::pkt_xrun
int pkt_xrun
Definition: jack.c:55
audio_read_packet
static int audio_read_packet(AVFormatContext *context, AVPacket *pkt)
Definition: jack.c:264
arg
const char * arg
Definition: jacosubdec.c:67
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:1200
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1095
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:527
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:235
time.h
supply_new_packets
static int supply_new_packets(JackData *self, AVFormatContext *context)
Definition: jack.c:129
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:170
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
free_pkt_fifo
static void free_pkt_fifo(AVFifoBuffer **fifo)
Definition: jack.c:212
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:117
stop_jack
static void stop_jack(JackData *self)
Definition: jack.c:222
JackData::timefilter
TimeFilter * timefilter
Definition: jack.c:52
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:464
audio_read_close
static int audio_read_close(AVFormatContext *context)
Definition: jack.c:324
avdevice.h
ff_timefilter_reset
void ff_timefilter_reset(TimeFilter *self)
Reset the filter.
Definition: timefilter.c:67
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:62
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:366
internal.h
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
av_fifo_alloc_array
AVFifoBuffer * av_fifo_alloc_array(size_t nmemb, size_t size)
Initialize an AVFifoBuffer.
Definition: fifo.c:49
options
static const AVOption options[]
Definition: jack.c:332
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:278
ff_timefilter_update
double ff_timefilter_update(TimeFilter *self, double system_time, double period)
Update the filter.
Definition: timefilter.c:72
JackData::nports
int nports
Definition: jack.c:51
avcodec.h
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:935
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
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:224
sem_post
#define sem_post(psem)
Definition: semaphore.h:26
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: utils.c:1196
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:49
av_fifo_size
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
av_fifo_freep
void av_fifo_freep(AVFifoBuffer **f)
Free an AVFifoBuffer and reset pointer to NULL.
Definition: fifo.c:63
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AVPacket
This structure stores compressed data.
Definition: packet.h:350
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
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:335
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
JackData::activated
int activated
Definition: jack.c:46
snprintf
#define snprintf
Definition: snprintf.h:34
audio_read_header
static int audio_read_header(AVFormatContext *context)
Definition: jack.c:236
sem_init
#define sem_init
Definition: semaphore.h:40