00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include "config.h"
00024 #include <semaphore.h>
00025 #include <jack/jack.h>
00026
00027 #include "libavutil/log.h"
00028 #include "libavutil/fifo.h"
00029 #include "libavutil/opt.h"
00030 #include "libavcodec/avcodec.h"
00031 #include "libavformat/avformat.h"
00032 #include "libavformat/internal.h"
00033 #include "timefilter.h"
00034
00038 #define FIFO_PACKETS_NUM 16
00039
00040 typedef struct {
00041 AVClass *class;
00042 jack_client_t * client;
00043 int activated;
00044 sem_t packet_count;
00045 jack_nframes_t sample_rate;
00046 jack_nframes_t buffer_size;
00047 jack_port_t ** ports;
00048 int nports;
00049 TimeFilter * timefilter;
00050 AVFifoBuffer * new_pkts;
00051 AVFifoBuffer * filled_pkts;
00052 int pkt_xrun;
00053 int jack_xrun;
00054 } JackData;
00055
00056 static int process_callback(jack_nframes_t nframes, void *arg)
00057 {
00058
00059
00060
00061 int i, j;
00062 JackData *self = arg;
00063 float * buffer;
00064 jack_nframes_t latency, cycle_delay;
00065 AVPacket pkt;
00066 float *pkt_data;
00067 double cycle_time;
00068
00069 if (!self->client)
00070 return 0;
00071
00072
00073 cycle_delay = jack_frames_since_cycle_start(self->client);
00074
00075
00076 cycle_time = ff_timefilter_update(self->timefilter,
00077 av_gettime() / 1000000.0 - (double) cycle_delay / self->sample_rate,
00078 self->buffer_size);
00079
00080
00081 if ((av_fifo_size(self->new_pkts) < sizeof(pkt)) || (av_fifo_space(self->filled_pkts) < sizeof(pkt))) {
00082 self->pkt_xrun = 1;
00083 return 0;
00084 }
00085
00086
00087 av_fifo_generic_read(self->new_pkts, &pkt, sizeof(pkt), NULL);
00088
00089 pkt_data = (float *) pkt.data;
00090 latency = 0;
00091
00092
00093 for (i = 0; i < self->nports; i++) {
00094 latency += jack_port_get_total_latency(self->client, self->ports[i]);
00095 buffer = jack_port_get_buffer(self->ports[i], self->buffer_size);
00096 for (j = 0; j < self->buffer_size; j++)
00097 pkt_data[j * self->nports + i] = buffer[j];
00098 }
00099
00100
00101 pkt.pts = (cycle_time - (double) latency / (self->nports * self->sample_rate)) * 1000000.0;
00102
00103
00104 av_fifo_generic_write(self->filled_pkts, &pkt, sizeof(pkt), NULL);
00105 sem_post(&self->packet_count);
00106
00107 return 0;
00108 }
00109
00110 static void shutdown_callback(void *arg)
00111 {
00112 JackData *self = arg;
00113 self->client = NULL;
00114 }
00115
00116 static int xrun_callback(void *arg)
00117 {
00118 JackData *self = arg;
00119 self->jack_xrun = 1;
00120 ff_timefilter_reset(self->timefilter);
00121 return 0;
00122 }
00123
00124 static int supply_new_packets(JackData *self, AVFormatContext *context)
00125 {
00126 AVPacket pkt;
00127 int test, pkt_size = self->buffer_size * self->nports * sizeof(float);
00128
00129
00130
00131
00132 while (av_fifo_space(self->new_pkts) >= sizeof(pkt)) {
00133 if ((test = av_new_packet(&pkt, pkt_size)) < 0) {
00134 av_log(context, AV_LOG_ERROR, "Could not create packet of size %d\n", pkt_size);
00135 return test;
00136 }
00137 av_fifo_generic_write(self->new_pkts, &pkt, sizeof(pkt), NULL);
00138 }
00139 return 0;
00140 }
00141
00142 static int start_jack(AVFormatContext *context)
00143 {
00144 JackData *self = context->priv_data;
00145 jack_status_t status;
00146 int i, test;
00147 double o, period;
00148
00149
00150 self->client = jack_client_open(context->filename, JackNullOption, &status);
00151 if (!self->client) {
00152 av_log(context, AV_LOG_ERROR, "Unable to register as a JACK client\n");
00153 return AVERROR(EIO);
00154 }
00155
00156 sem_init(&self->packet_count, 0, 0);
00157
00158 self->sample_rate = jack_get_sample_rate(self->client);
00159 self->ports = av_malloc(self->nports * sizeof(*self->ports));
00160 self->buffer_size = jack_get_buffer_size(self->client);
00161
00162
00163 for (i = 0; i < self->nports; i++) {
00164 char str[16];
00165 snprintf(str, sizeof(str), "input_%d", i + 1);
00166 self->ports[i] = jack_port_register(self->client, str,
00167 JACK_DEFAULT_AUDIO_TYPE,
00168 JackPortIsInput, 0);
00169 if (!self->ports[i]) {
00170 av_log(context, AV_LOG_ERROR, "Unable to register port %s:%s\n",
00171 context->filename, str);
00172 jack_client_close(self->client);
00173 return AVERROR(EIO);
00174 }
00175 }
00176
00177
00178 jack_set_process_callback(self->client, process_callback, self);
00179 jack_on_shutdown(self->client, shutdown_callback, self);
00180 jack_set_xrun_callback(self->client, xrun_callback, self);
00181
00182
00183 period = (double) self->buffer_size / self->sample_rate;
00184 o = 2 * M_PI * 1.5 * period;
00185 self->timefilter = ff_timefilter_new (1.0 / self->sample_rate, sqrt(2 * o), o * o);
00186
00187
00188 self->filled_pkts = av_fifo_alloc(FIFO_PACKETS_NUM * sizeof(AVPacket));
00189
00190 self->new_pkts = av_fifo_alloc((FIFO_PACKETS_NUM + 1) * sizeof(AVPacket));
00191 if ((test = supply_new_packets(self, context))) {
00192 jack_client_close(self->client);
00193 return test;
00194 }
00195
00196 return 0;
00197
00198 }
00199
00200 static void free_pkt_fifo(AVFifoBuffer *fifo)
00201 {
00202 AVPacket pkt;
00203 while (av_fifo_size(fifo)) {
00204 av_fifo_generic_read(fifo, &pkt, sizeof(pkt), NULL);
00205 av_free_packet(&pkt);
00206 }
00207 av_fifo_free(fifo);
00208 }
00209
00210 static void stop_jack(JackData *self)
00211 {
00212 if (self->client) {
00213 if (self->activated)
00214 jack_deactivate(self->client);
00215 jack_client_close(self->client);
00216 }
00217 sem_destroy(&self->packet_count);
00218 free_pkt_fifo(self->new_pkts);
00219 free_pkt_fifo(self->filled_pkts);
00220 av_freep(&self->ports);
00221 ff_timefilter_destroy(self->timefilter);
00222 }
00223
00224 static int audio_read_header(AVFormatContext *context, AVFormatParameters *params)
00225 {
00226 JackData *self = context->priv_data;
00227 AVStream *stream;
00228 int test;
00229
00230 if ((test = start_jack(context)))
00231 return test;
00232
00233 stream = avformat_new_stream(context, NULL);
00234 if (!stream) {
00235 stop_jack(self);
00236 return AVERROR(ENOMEM);
00237 }
00238
00239 stream->codec->codec_type = AVMEDIA_TYPE_AUDIO;
00240 #if HAVE_BIGENDIAN
00241 stream->codec->codec_id = CODEC_ID_PCM_F32BE;
00242 #else
00243 stream->codec->codec_id = CODEC_ID_PCM_F32LE;
00244 #endif
00245 stream->codec->sample_rate = self->sample_rate;
00246 stream->codec->channels = self->nports;
00247
00248 avpriv_set_pts_info(stream, 64, 1, 1000000);
00249 return 0;
00250 }
00251
00252 static int audio_read_packet(AVFormatContext *context, AVPacket *pkt)
00253 {
00254 JackData *self = context->priv_data;
00255 struct timespec timeout = {0, 0};
00256 int test;
00257
00258
00259
00260
00261
00262 if (!self->activated) {
00263 if (!jack_activate(self->client)) {
00264 self->activated = 1;
00265 av_log(context, AV_LOG_INFO,
00266 "JACK client registered and activated (rate=%dHz, buffer_size=%d frames)\n",
00267 self->sample_rate, self->buffer_size);
00268 } else {
00269 av_log(context, AV_LOG_ERROR, "Unable to activate JACK client\n");
00270 return AVERROR(EIO);
00271 }
00272 }
00273
00274
00275 timeout.tv_sec = av_gettime() / 1000000 + 2;
00276 if (sem_timedwait(&self->packet_count, &timeout)) {
00277 if (errno == ETIMEDOUT) {
00278 av_log(context, AV_LOG_ERROR,
00279 "Input error: timed out when waiting for JACK process callback output\n");
00280 } else {
00281 av_log(context, AV_LOG_ERROR, "Error while waiting for audio packet: %s\n",
00282 strerror(errno));
00283 }
00284 if (!self->client)
00285 av_log(context, AV_LOG_ERROR, "Input error: JACK server is gone\n");
00286
00287 return AVERROR(EIO);
00288 }
00289
00290 if (self->pkt_xrun) {
00291 av_log(context, AV_LOG_WARNING, "Audio packet xrun\n");
00292 self->pkt_xrun = 0;
00293 }
00294
00295 if (self->jack_xrun) {
00296 av_log(context, AV_LOG_WARNING, "JACK xrun\n");
00297 self->jack_xrun = 0;
00298 }
00299
00300
00301 av_fifo_generic_read(self->filled_pkts, pkt, sizeof(*pkt), NULL);
00302
00303 if ((test = supply_new_packets(self, context)))
00304 return test;
00305
00306 return 0;
00307 }
00308
00309 static int audio_read_close(AVFormatContext *context)
00310 {
00311 JackData *self = context->priv_data;
00312 stop_jack(self);
00313 return 0;
00314 }
00315
00316 #define OFFSET(x) offsetof(JackData, x)
00317 static const AVOption options[] = {
00318 { "channels", "Number of audio channels.", OFFSET(nports), AV_OPT_TYPE_INT, { 2 }, 1, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
00319 { NULL },
00320 };
00321
00322 static const AVClass jack_indev_class = {
00323 .class_name = "JACK indev",
00324 .item_name = av_default_item_name,
00325 .option = options,
00326 .version = LIBAVUTIL_VERSION_INT,
00327 };
00328
00329 AVInputFormat ff_jack_demuxer = {
00330 .name = "jack",
00331 .long_name = NULL_IF_CONFIG_SMALL("JACK Audio Connection Kit"),
00332 .priv_data_size = sizeof(JackData),
00333 .read_header = audio_read_header,
00334 .read_packet = audio_read_packet,
00335 .read_close = audio_read_close,
00336 .flags = AVFMT_NOFILE,
00337 .priv_class = &jack_indev_class,
00338 };