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/mem.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/time.h"
33 #include "libavformat/avformat.h"
34 #include "libavformat/demux.h"
35 #include "libavformat/internal.h"
36 #include "timefilter.h"
37 #include "avdevice.h"
38 
39 /**
40  * Size of the internal FIFO buffers as a number of audio packets
41  */
42 #define FIFO_PACKETS_NUM 16
43 
44 typedef struct JackData {
45  AVClass *class;
46  jack_client_t * client;
47  int activated;
49  jack_nframes_t sample_rate;
50  jack_nframes_t buffer_size;
51  jack_port_t ** ports;
52  int nports;
56  int pkt_xrun;
57  int jack_xrun;
58 } JackData;
59 
60 static int process_callback(jack_nframes_t nframes, void *arg)
61 {
62  /* Warning: this function runs in realtime. One mustn't allocate memory here
63  * or do any other thing that could block. */
64 
65  int i, j;
66  JackData *self = arg;
67  float * buffer;
68  jack_nframes_t latency, cycle_delay;
69  AVPacket pkt;
70  float *pkt_data;
71  double cycle_time;
72 
73  if (!self->client)
74  return 0;
75 
76  /* The approximate delay since the hardware interrupt as a number of frames */
77  cycle_delay = jack_frames_since_cycle_start(self->client);
78 
79  /* Retrieve filtered cycle time */
80  cycle_time = ff_timefilter_update(self->timefilter,
81  av_gettime() / 1000000.0 - (double) cycle_delay / self->sample_rate,
82  self->buffer_size);
83 
84  /* Check if an empty packet is available, and if there's enough space to send it back once filled */
85  if (!av_fifo_can_read(self->new_pkts) ||
86  !av_fifo_can_write(self->filled_pkts)) {
87  self->pkt_xrun = 1;
88  return 0;
89  }
90 
91  /* Retrieve empty (but allocated) packet */
92  av_fifo_read(self->new_pkts, &pkt, 1);
93 
94  pkt_data = (float *) pkt.data;
95  latency = 0;
96 
97  /* Copy and interleave audio data from the JACK buffer into the packet */
98  for (i = 0; i < self->nports; i++) {
99  jack_latency_range_t range;
100  jack_port_get_latency_range(self->ports[i], JackCaptureLatency, &range);
101  latency += range.max;
102  buffer = jack_port_get_buffer(self->ports[i], self->buffer_size);
103  for (j = 0; j < self->buffer_size; j++)
104  pkt_data[j * self->nports + i] = buffer[j];
105  }
106 
107  /* Timestamp the packet with the cycle start time minus the average latency */
108  pkt.pts = (cycle_time - (double) latency / (self->nports * self->sample_rate)) * 1000000.0;
109 
110  /* Send the now filled packet back, and increase packet counter */
111  av_fifo_write(self->filled_pkts, &pkt, 1);
112  sem_post(&self->packet_count);
113 
114  return 0;
115 }
116 
117 static void shutdown_callback(void *arg)
118 {
119  JackData *self = arg;
120  self->client = NULL;
121 }
122 
123 static int xrun_callback(void *arg)
124 {
125  JackData *self = arg;
126  self->jack_xrun = 1;
127  ff_timefilter_reset(self->timefilter);
128  return 0;
129 }
130 
132 {
133  AVPacket pkt;
134  int test, pkt_size = self->buffer_size * self->nports * sizeof(float);
135 
136  /* Supply the process callback with new empty packets, by filling the new
137  * packets FIFO buffer with as many packets as possible. process_callback()
138  * can't do this by itself, because it can't allocate memory in realtime. */
139  while (av_fifo_can_write(self->new_pkts)) {
140  if ((test = av_new_packet(&pkt, pkt_size)) < 0) {
141  av_log(context, AV_LOG_ERROR, "Could not create packet of size %d\n", pkt_size);
142  return test;
143  }
144  av_fifo_write(self->new_pkts, &pkt, 1);
145  }
146  return 0;
147 }
148 
150 {
151  JackData *self = context->priv_data;
152  jack_status_t status;
153  int i, test;
154 
155  /* Register as a JACK client, using the context url as client name. */
156  self->client = jack_client_open(context->url, JackNullOption, &status);
157  if (!self->client) {
158  av_log(context, AV_LOG_ERROR, "Unable to register as a JACK client\n");
159  return AVERROR(EIO);
160  }
161 
162  sem_init(&self->packet_count, 0, 0);
163 
164  self->sample_rate = jack_get_sample_rate(self->client);
165  self->ports = av_malloc_array(self->nports, sizeof(*self->ports));
166  if (!self->ports)
167  return AVERROR(ENOMEM);
168  self->buffer_size = jack_get_buffer_size(self->client);
169 
170  /* Register JACK ports */
171  for (i = 0; i < self->nports; i++) {
172  char str[32];
173  snprintf(str, sizeof(str), "input_%d", i + 1);
174  self->ports[i] = jack_port_register(self->client, str,
175  JACK_DEFAULT_AUDIO_TYPE,
176  JackPortIsInput, 0);
177  if (!self->ports[i]) {
178  av_log(context, AV_LOG_ERROR, "Unable to register port %s:%s\n",
179  context->url, str);
180  jack_client_close(self->client);
181  return AVERROR(EIO);
182  }
183  }
184 
185  /* Register JACK callbacks */
186  jack_set_process_callback(self->client, process_callback, self);
187  jack_on_shutdown(self->client, shutdown_callback, self);
188  jack_set_xrun_callback(self->client, xrun_callback, self);
189 
190  /* Create time filter */
191  self->timefilter = ff_timefilter_new (1.0 / self->sample_rate, self->buffer_size, 1.5);
192  if (!self->timefilter) {
193  jack_client_close(self->client);
194  return AVERROR(ENOMEM);
195  }
196 
197  /* Create FIFO buffers */
198  self->filled_pkts = av_fifo_alloc2(FIFO_PACKETS_NUM, sizeof(AVPacket), 0);
199  /* New packets FIFO with one extra packet for safety against underruns */
200  self->new_pkts = av_fifo_alloc2((FIFO_PACKETS_NUM + 1), sizeof(AVPacket), 0);
201  if (!self->new_pkts) {
202  jack_client_close(self->client);
203  return AVERROR(ENOMEM);
204  }
205  if ((test = supply_new_packets(self, context))) {
206  jack_client_close(self->client);
207  return test;
208  }
209 
210  return 0;
211 
212 }
213 
214 static void free_pkt_fifo(AVFifo **fifop)
215 {
216  AVFifo *fifo = *fifop;
217  AVPacket pkt;
218  while (av_fifo_read(fifo, &pkt, 1) >= 0)
220  av_fifo_freep2(fifop);
221 }
222 
223 static void stop_jack(JackData *self)
224 {
225  if (self->client) {
226  if (self->activated)
227  jack_deactivate(self->client);
228  jack_client_close(self->client);
229  }
230  sem_destroy(&self->packet_count);
231  free_pkt_fifo(&self->new_pkts);
232  free_pkt_fifo(&self->filled_pkts);
233  av_freep(&self->ports);
234  ff_timefilter_destroy(self->timefilter);
235 }
236 
238 {
239  JackData *self = context->priv_data;
240  AVStream *stream;
241  int test;
242 
243  if ((test = start_jack(context)))
244  return test;
245 
246  stream = avformat_new_stream(context, NULL);
247  if (!stream) {
248  stop_jack(self);
249  return AVERROR(ENOMEM);
250  }
251 
253 #if HAVE_BIGENDIAN
255 #else
257 #endif
258  stream->codecpar->sample_rate = self->sample_rate;
259  stream->codecpar->ch_layout.nb_channels = self->nports;
260 
261  avpriv_set_pts_info(stream, 64, 1, 1000000); /* 64 bits pts in us */
262  return 0;
263 }
264 
266 {
267  JackData *self = context->priv_data;
268  struct timespec timeout = {0, 0};
269  int test;
270 
271  /* Activate the JACK client on first packet read. Activating the JACK client
272  * means that process_callback() starts to get called at regular interval.
273  * If we activate it in audio_read_header(), we're actually reading audio data
274  * from the device before instructed to, and that may result in an overrun. */
275  if (!self->activated) {
276  if (!jack_activate(self->client)) {
277  self->activated = 1;
279  "JACK client registered and activated (rate=%dHz, buffer_size=%d frames)\n",
280  self->sample_rate, self->buffer_size);
281  } else {
282  av_log(context, AV_LOG_ERROR, "Unable to activate JACK client\n");
283  return AVERROR(EIO);
284  }
285  }
286 
287  /* Wait for a packet coming back from process_callback(), if one isn't available yet */
288  timeout.tv_sec = av_gettime() / 1000000 + 2;
289  if (sem_timedwait(&self->packet_count, &timeout)) {
290  if (errno == ETIMEDOUT) {
292  "Input error: timed out when waiting for JACK process callback output\n");
293  } else {
294  char errbuf[128];
295  int ret = AVERROR(errno);
296  av_strerror(ret, errbuf, sizeof(errbuf));
297  av_log(context, AV_LOG_ERROR, "Error while waiting for audio packet: %s\n",
298  errbuf);
299  }
300  if (!self->client)
301  av_log(context, AV_LOG_ERROR, "Input error: JACK server is gone\n");
302 
303  return AVERROR(EIO);
304  }
305 
306  if (self->pkt_xrun) {
307  av_log(context, AV_LOG_WARNING, "Audio packet xrun\n");
308  self->pkt_xrun = 0;
309  }
310 
311  if (self->jack_xrun) {
312  av_log(context, AV_LOG_WARNING, "JACK xrun\n");
313  self->jack_xrun = 0;
314  }
315 
316  /* Retrieve the packet filled with audio data by process_callback() */
317  av_fifo_read(self->filled_pkts, pkt, 1);
318 
319  if ((test = supply_new_packets(self, context)))
320  return test;
321 
322  return 0;
323 }
324 
326 {
327  JackData *self = context->priv_data;
328  stop_jack(self);
329  return 0;
330 }
331 
332 #define OFFSET(x) offsetof(JackData, x)
333 static const AVOption options[] = {
334  { "channels", "Number of audio channels.", OFFSET(nports), AV_OPT_TYPE_INT, { .i64 = 2 }, 1, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
335  { NULL },
336 };
337 
338 static const AVClass jack_indev_class = {
339  .class_name = "JACK indev",
340  .item_name = av_default_item_name,
341  .option = options,
342  .version = LIBAVUTIL_VERSION_INT,
344 };
345 
347  .p.name = "jack",
348  .p.long_name = NULL_IF_CONFIG_SMALL("JACK Audio Connection Kit"),
349  .p.flags = AVFMT_NOFILE,
350  .p.priv_class = &jack_indev_class,
351  .priv_data_size = sizeof(JackData),
355 };
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:428
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:348
av_fifo_can_write
size_t av_fifo_can_write(const AVFifo *f)
Definition: fifo.c:94
JackData::packet_count
sem_t packet_count
Definition: jack.c:48
OFFSET
#define OFFSET(x)
Definition: jack.c:332
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
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
JackData::client
jack_client_t * client
Definition: jack.c:46
sem_t
#define sem_t
Definition: semaphore.h:25
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
xrun_callback
static int xrun_callback(void *arg)
Definition: jack.c:123
FIFO_PACKETS_NUM
#define FIFO_PACKETS_NUM
Size of the internal FIFO buffers as a number of audio packets.
Definition: jack.c:42
AVPacket::data
uint8_t * data
Definition: packet.h:533
AVOption
AVOption.
Definition: opt.h:357
test
Definition: idctdsp.c:35
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:321
JackData::jack_xrun
int jack_xrun
Definition: jack.c:57
start_jack
static int start_jack(AVFormatContext *context)
Definition: jack.c:149
JackData
Definition: jack.c:44
jack_indev_class
static const AVClass jack_indev_class
Definition: jack.c:338
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:855
JackData::ports
jack_port_t ** ports
Definition: jack.c:51
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:109
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:49
AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT
@ AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT
Definition: log.h:43
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_fifo_read
int av_fifo_read(AVFifo *f, void *buf, size_t nb_elems)
Read data from a FIFO.
Definition: fifo.c:240
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_read_callback.c:42
semaphore.h
sem_timedwait
#define sem_timedwait(psem, val)
Definition: semaphore.h:28
float
float
Definition: af_crystalizer.c:121
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: packet.c:98
process_callback
static int process_callback(jack_nframes_t nframes, void *arg)
Definition: jack.c:60
free_pkt_fifo
static void free_pkt_fifo(AVFifo **fifop)
Definition: jack.c:214
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:553
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
JackData::pkt_xrun
int pkt_xrun
Definition: jack.c:56
audio_read_packet
static int audio_read_packet(AVFormatContext *context, AVPacket *pkt)
Definition: jack.c:265
arg
const char * arg
Definition: jacosubdec.c:67
JackData::new_pkts
AVFifo * new_pkts
Definition: jack.c:54
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:1260
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:771
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:550
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:117
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:131
time.h
supply_new_packets
static int supply_new_packets(JackData *self, AVFormatContext *context)
Definition: jack.c:131
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:184
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:94
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
stop_jack
static void stop_jack(JackData *self)
Definition: jack.c:223
JackData::timefilter
TimeFilter * timefilter
Definition: jack.c:53
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:468
audio_read_close
static int audio_read_close(AVFormatContext *context)
Definition: jack.c:325
range
enum AVColorRange range
Definition: mediacodec_wrapper.c:2464
avdevice.h
FFInputFormat::p
AVInputFormat p
The public AVInputFormat.
Definition: demux.h:41
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:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:526
internal.h
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
options
static const AVOption options[]
Definition: jack.c:333
ff_timefilter_update
double ff_timefilter_update(TimeFilter *self, double system_time, double period)
Update the filter.
Definition: timefilter.c:76
demux.h
JackData::nports
int nports
Definition: jack.c:52
sem_destroy
#define sem_destroy(psem)
Definition: semaphore.h:29
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:748
ff_jack_demuxer
const FFInputFormat ff_jack_demuxer
Definition: jack.c:346
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
status
ov_status_e status
Definition: dnn_backend_openvino.c:101
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:245
test
static void test(const char *pattern, const char *host)
Definition: noproxy.c:23
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
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:284
mem.h
JackData::buffer_size
jack_nframes_t buffer_size
Definition: jack.c:50
JackData::filled_pkts
AVFifo * filled_pkts
Definition: jack.c:55
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:510
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
FFInputFormat
Definition: demux.h:37
AV_CODEC_ID_PCM_F32LE
@ AV_CODEC_ID_PCM_F32LE
Definition: codec_id.h:349
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:47
snprintf
#define snprintf
Definition: snprintf.h:34
audio_read_header
static int audio_read_header(AVFormatContext *context)
Definition: jack.c:237
sem_init
#define sem_init
Definition: semaphore.h:40