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_can_read(self->new_pkts) ||
85  !av_fifo_can_write(self->filled_pkts)) {
86  self->pkt_xrun = 1;
87  return 0;
88  }
89 
90  /* Retrieve empty (but allocated) packet */
91  av_fifo_read(self->new_pkts, &pkt, 1);
92 
93  pkt_data = (float *) pkt.data;
94  latency = 0;
95 
96  /* Copy and interleave audio data from the JACK buffer into the packet */
97  for (i = 0; i < self->nports; i++) {
98  jack_latency_range_t range;
99  jack_port_get_latency_range(self->ports[i], JackCaptureLatency, &range);
100  latency += range.max;
101  buffer = jack_port_get_buffer(self->ports[i], self->buffer_size);
102  for (j = 0; j < self->buffer_size; j++)
103  pkt_data[j * self->nports + i] = buffer[j];
104  }
105 
106  /* Timestamp the packet with the cycle start time minus the average latency */
107  pkt.pts = (cycle_time - (double) latency / (self->nports * self->sample_rate)) * 1000000.0;
108 
109  /* Send the now filled packet back, and increase packet counter */
110  av_fifo_write(self->filled_pkts, &pkt, 1);
111  sem_post(&self->packet_count);
112 
113  return 0;
114 }
115 
116 static void shutdown_callback(void *arg)
117 {
118  JackData *self = arg;
119  self->client = NULL;
120 }
121 
122 static int xrun_callback(void *arg)
123 {
124  JackData *self = arg;
125  self->jack_xrun = 1;
126  ff_timefilter_reset(self->timefilter);
127  return 0;
128 }
129 
131 {
132  AVPacket pkt;
133  int test, pkt_size = self->buffer_size * self->nports * sizeof(float);
134 
135  /* Supply the process callback with new empty packets, by filling the new
136  * packets FIFO buffer with as many packets as possible. process_callback()
137  * can't do this by itself, because it can't allocate memory in realtime. */
138  while (av_fifo_can_write(self->new_pkts)) {
139  if ((test = av_new_packet(&pkt, pkt_size)) < 0) {
140  av_log(context, AV_LOG_ERROR, "Could not create packet of size %d\n", pkt_size);
141  return test;
142  }
143  av_fifo_write(self->new_pkts, &pkt, 1);
144  }
145  return 0;
146 }
147 
149 {
150  JackData *self = context->priv_data;
151  jack_status_t status;
152  int i, test;
153 
154  /* Register as a JACK client, using the context url as client name. */
155  self->client = jack_client_open(context->url, JackNullOption, &status);
156  if (!self->client) {
157  av_log(context, AV_LOG_ERROR, "Unable to register as a JACK client\n");
158  return AVERROR(EIO);
159  }
160 
161  sem_init(&self->packet_count, 0, 0);
162 
163  self->sample_rate = jack_get_sample_rate(self->client);
164  self->ports = av_malloc_array(self->nports, sizeof(*self->ports));
165  if (!self->ports)
166  return AVERROR(ENOMEM);
167  self->buffer_size = jack_get_buffer_size(self->client);
168 
169  /* Register JACK ports */
170  for (i = 0; i < self->nports; i++) {
171  char str[32];
172  snprintf(str, sizeof(str), "input_%d", i + 1);
173  self->ports[i] = jack_port_register(self->client, str,
174  JACK_DEFAULT_AUDIO_TYPE,
175  JackPortIsInput, 0);
176  if (!self->ports[i]) {
177  av_log(context, AV_LOG_ERROR, "Unable to register port %s:%s\n",
178  context->url, str);
179  jack_client_close(self->client);
180  return AVERROR(EIO);
181  }
182  }
183 
184  /* Register JACK callbacks */
185  jack_set_process_callback(self->client, process_callback, self);
186  jack_on_shutdown(self->client, shutdown_callback, self);
187  jack_set_xrun_callback(self->client, xrun_callback, self);
188 
189  /* Create time filter */
190  self->timefilter = ff_timefilter_new (1.0 / self->sample_rate, self->buffer_size, 1.5);
191  if (!self->timefilter) {
192  jack_client_close(self->client);
193  return AVERROR(ENOMEM);
194  }
195 
196  /* Create FIFO buffers */
197  self->filled_pkts = av_fifo_alloc2(FIFO_PACKETS_NUM, sizeof(AVPacket), 0);
198  /* New packets FIFO with one extra packet for safety against underruns */
199  self->new_pkts = av_fifo_alloc2((FIFO_PACKETS_NUM + 1), sizeof(AVPacket), 0);
200  if (!self->new_pkts) {
201  jack_client_close(self->client);
202  return AVERROR(ENOMEM);
203  }
204  if ((test = supply_new_packets(self, context))) {
205  jack_client_close(self->client);
206  return test;
207  }
208 
209  return 0;
210 
211 }
212 
213 static void free_pkt_fifo(AVFifo **fifop)
214 {
215  AVFifo *fifo = *fifop;
216  AVPacket pkt;
217  while (av_fifo_read(fifo, &pkt, 1) >= 0)
219  av_fifo_freep2(fifop);
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->ch_layout.nb_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_read(self->filled_pkts, pkt, 1);
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: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:336
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: options.c:237
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:57
JackData::client
jack_client_t * client
Definition: jack.c:45
sem_t
#define sem_t
Definition: semaphore.h:25
xrun_callback
static int xrun_callback(void *arg)
Definition: jack.c:122
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:374
av_fifo_can_read
size_t av_fifo_can_read(const AVFifo *f)
Definition: fifo.c:87
AVOption
AVOption.
Definition: opt.h:251
test
Definition: idctdsp.c:34
av_fifo_read
int av_fifo_read(AVFifo *f, void *buf, size_t nb_elems)
Read data from a FIFO.
Definition: fifo.c:240
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:300
JackData::jack_xrun
int jack_xrun
Definition: jack.c:56
start_jack
static int start_jack(AVFormatContext *context)
Definition: jack.c:148
JackData
Definition: jack.c:43
jack_indev_class
static const AVClass jack_indev_class
Definition: jack.c:337
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:697
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: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: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
AVInputFormat
Definition: avformat.h:656
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:59
free_pkt_fifo
static void free_pkt_fifo(AVFifo **fifop)
Definition: jack.c:213
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:55
audio_read_packet
static int audio_read_packet(AVFormatContext *context, AVPacket *pkt)
Definition: jack.c:264
av_fifo_can_write
size_t av_fifo_can_write(const AVFifo *f)
Definition: fifo.c:94
arg
const char * arg
Definition: jacosubdec.c:67
JackData::new_pkts
AVFifo * new_pkts
Definition: jack.c:53
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:1213
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:529
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:116
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
double
double
Definition: af_crystalizer.c:132
time.h
supply_new_packets
static int supply_new_packets(JackData *self, AVFormatContext *context)
Definition: jack.c:130
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:212
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:177
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:116
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
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:470
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: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: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:367
internal.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
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
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:282
av_fifo_freep2
void av_fifo_freep2(AVFifo **f)
Free an AVFifo and reset pointer to NULL.
Definition: fifo.c:286
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: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: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_write
int av_fifo_write(AVFifo *f, const void *buf, size_t nb_elems)
Write data into a FIFO.
Definition: fifo.c:188
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:49
JackData::filled_pkts
AVFifo * filled_pkts
Definition: jack.c:54
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:61
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:337
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
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