2 Copyright (C) 2001 Paul Davis
3 Copyright (C) 2003 Jack O'Quin
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 * 2002/08/23 - modify for libsndfile 1.0.0 <andy@alsaplayer.org>
20 * 2003/05/26 - use ringbuffers - joq
32 #include <jack/jack.h>
33 #include <jack/ringbuffer.h>
35 typedef struct _thread_info
{
38 jack_nframes_t duration
;
39 jack_nframes_t rb_size
;
40 jack_client_t
*client
;
41 unsigned int channels
;
44 volatile int can_capture
;
45 volatile int can_process
;
52 jack_default_audio_sample_t
**in
;
53 jack_nframes_t nframes
;
54 const size_t sample_size
= sizeof(jack_default_audio_sample_t
);
56 /* Synchronization between process thread and disk thread. */
57 #define DEFAULT_RB_SIZE 16384 /* ringbuffer size in frames */
58 jack_ringbuffer_t
*rb
;
59 pthread_mutex_t disk_thread_lock
= PTHREAD_MUTEX_INITIALIZER
;
60 pthread_cond_t data_ready
= PTHREAD_COND_INITIALIZER
;
62 jack_client_t
*client
;
64 static void signal_handler(int sig
)
66 jack_client_close(client
);
67 fprintf(stderr
, "signal received, exiting ...\n");
72 disk_thread (void *arg
)
74 jack_thread_info_t
*info
= (jack_thread_info_t
*) arg
;
75 static jack_nframes_t total_captured
= 0;
76 jack_nframes_t samples_per_frame
= info
->channels
;
77 size_t bytes_per_frame
= samples_per_frame
* sample_size
;
78 void *framebuf
= malloc (bytes_per_frame
);
80 pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS
, NULL
);
81 pthread_mutex_lock (&disk_thread_lock
);
87 /* Write the data one frame at a time. This is
88 * inefficient, but makes things simpler. */
89 while (info
->can_capture
&&
90 (jack_ringbuffer_read_space (rb
) >= bytes_per_frame
)) {
92 jack_ringbuffer_read (rb
, framebuf
, bytes_per_frame
);
94 if (sf_writef_float (info
->sf
, framebuf
, 1) != 1) {
96 sf_error_str (0, errstr
, sizeof (errstr
) - 1);
98 "cannot write sndfile (%s)\n",
100 info
->status
= EIO
; /* write failed */
104 if (++total_captured
>= info
->duration
) {
105 printf ("disk thread finished\n");
110 /* wait until process() signals more data */
111 pthread_cond_wait (&data_ready
, &disk_thread_lock
);
115 pthread_mutex_unlock (&disk_thread_lock
);
121 process (jack_nframes_t nframes
, void *arg
)
125 jack_thread_info_t
*info
= (jack_thread_info_t
*) arg
;
127 /* Do nothing until we're ready to begin. */
128 if ((!info
->can_process
) || (!info
->can_capture
))
131 for (chn
= 0; chn
< nports
; chn
++)
132 in
[chn
] = jack_port_get_buffer (ports
[chn
], nframes
);
134 /* Sndfile requires interleaved data. It is simpler here to
135 * just queue interleaved samples to a single ringbuffer. */
136 for (i
= 0; i
< nframes
; i
++) {
137 for (chn
= 0; chn
< nports
; chn
++) {
138 if (jack_ringbuffer_write (rb
, (void *) (in
[chn
]+i
),
145 /* Tell the disk thread there is work to do. If it is already
146 * running, the lock will not be available. We can't wait
147 * here in the process() thread, but we don't need to signal
148 * in that case, because the disk thread will read all the
149 * data queued before waiting again. */
150 if (pthread_mutex_trylock (&disk_thread_lock
) == 0) {
151 pthread_cond_signal (&data_ready
);
152 pthread_mutex_unlock (&disk_thread_lock
);
159 jack_shutdown (void *arg
)
161 fprintf (stderr
, "JACK shutdown\n");
167 setup_disk_thread (jack_thread_info_t
*info
)
172 sf_info
.samplerate
= jack_get_sample_rate (info
->client
);
173 sf_info
.channels
= info
->channels
;
175 switch (info
->bitdepth
) {
176 case 8: short_mask
= SF_FORMAT_PCM_U8
;
178 case 16: short_mask
= SF_FORMAT_PCM_16
;
180 case 24: short_mask
= SF_FORMAT_PCM_24
;
182 case 32: short_mask
= SF_FORMAT_PCM_32
;
184 default: short_mask
= SF_FORMAT_PCM_16
;
187 sf_info
.format
= SF_FORMAT_WAV
|short_mask
;
189 if ((info
->sf
= sf_open (info
->path
, SFM_WRITE
, &sf_info
)) == NULL
) {
191 sf_error_str (0, errstr
, sizeof (errstr
) - 1);
192 fprintf (stderr
, "cannot open sndfile \"%s\" for output (%s)\n", info
->path
, errstr
);
193 jack_client_close (info
->client
);
197 info
->duration
*= sf_info
.samplerate
;
198 info
->can_capture
= 0;
200 pthread_create (&info
->thread_id
, NULL
, disk_thread
, info
);
204 run_disk_thread (jack_thread_info_t
*info
)
206 info
->can_capture
= 1;
207 pthread_join (info
->thread_id
, NULL
);
211 "jackrec failed with %ld overruns.\n", overruns
);
212 fprintf (stderr
, " try a bigger buffer than -B %"
213 PRIu32
".\n", info
->rb_size
);
214 info
->status
= EPIPE
;
219 setup_ports (int sources
, char *source_names
[], jack_thread_info_t
*info
)
224 /* Allocate data structures that depend on the number of ports. */
226 ports
= (jack_port_t
**) malloc (sizeof (jack_port_t
*) * nports
);
227 in_size
= nports
* sizeof (jack_default_audio_sample_t
*);
228 in
= (jack_default_audio_sample_t
**) malloc (in_size
);
229 rb
= jack_ringbuffer_create (nports
* sample_size
* info
->rb_size
);
231 /* When JACK is running realtime, jack_activate() will have
232 * called mlockall() to lock our pages into memory. But, we
233 * still need to touch any newly allocated pages before
234 * process() starts using them. Otherwise, a page fault could
235 * create a delay that would force JACK to shut us down. */
236 memset(in
, 0, in_size
);
237 memset(rb
->buf
, 0, rb
->size
);
239 for (i
= 0; i
< nports
; i
++) {
242 sprintf (name
, "input%d", i
+1);
244 if ((ports
[i
] = jack_port_register (info
->client
, name
, JACK_DEFAULT_AUDIO_TYPE
, JackPortIsInput
, 0)) == 0) {
245 fprintf (stderr
, "cannot register input port \"%s\"!\n", name
);
246 jack_client_close (info
->client
);
251 for (i
= 0; i
< nports
; i
++) {
252 if (jack_connect (info
->client
, source_names
[i
], jack_port_name (ports
[i
]))) {
253 fprintf (stderr
, "cannot connect input port %s to %s\n", jack_port_name (ports
[i
]), source_names
[i
]);
254 jack_client_close (info
->client
);
259 info
->can_process
= 1; /* process() can start, now */
263 main (int argc
, char *argv
[])
265 jack_thread_info_t thread_info
;
267 int longopt_index
= 0;
268 extern int optind
, opterr
;
270 char *optstring
= "d:f:b:B:h";
271 struct option long_options
[] = {
272 { "help", 0, 0, 'h' },
273 { "duration", 1, 0, 'd' },
274 { "file", 1, 0, 'f' },
275 { "bitdepth", 1, 0, 'b' },
276 { "bufsize", 1, 0, 'B' },
280 memset (&thread_info
, 0, sizeof (thread_info
));
281 thread_info
.rb_size
= DEFAULT_RB_SIZE
;
284 while ((c
= getopt_long (argc
, argv
, optstring
, long_options
, &longopt_index
)) != -1) {
287 /* getopt signals end of '-' options */
294 thread_info
.duration
= atoi (optarg
);
297 thread_info
.path
= optarg
;
300 thread_info
.bitdepth
= atoi (optarg
);
303 thread_info
.rb_size
= atoi (optarg
);
306 fprintf (stderr
, "error\n");
312 if (show_usage
|| thread_info
.path
== NULL
|| optind
== argc
) {
313 fprintf (stderr
, "usage: jackrec -f filename [ -d second ] [ -b bitdepth ] [ -B bufsize ] port1 [ port2 ... ]\n");
317 if ((client
= jack_client_open ("jackrec", JackNullOption
, NULL
)) == 0) {
318 fprintf (stderr
, "jack server not running?\n");
322 thread_info
.client
= client
;
323 thread_info
.channels
= argc
- optind
;
324 thread_info
.can_process
= 0;
326 setup_disk_thread (&thread_info
);
328 jack_set_process_callback (client
, process
, &thread_info
);
329 jack_on_shutdown (client
, jack_shutdown
, &thread_info
);
331 if (jack_activate (client
)) {
332 fprintf (stderr
, "cannot activate client");
335 setup_ports (argc
- optind
, &argv
[optind
], &thread_info
);
337 /* install a signal handler to properly quits jack client */
338 signal(SIGQUIT
, signal_handler
);
339 signal(SIGTERM
, signal_handler
);
340 signal(SIGHUP
, signal_handler
);
341 signal(SIGINT
, signal_handler
);
343 run_disk_thread (&thread_info
);
345 jack_client_close (client
);
347 jack_ringbuffer_free (rb
);