]> code.delx.au - pulseaudio/blob - src/utils/pacat.c
delx.au / code / pulseaudio / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
pacat: allow configuration of latency in msec
[pulseaudio] / src / utils / pacat.c
1 /***
2 This file is part of PulseAudio.
3
4 Copyright 2004-2006 Lennart Poettering
5 Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
6
7 PulseAudio is free software; you can redistribute it and/or modify
8 it under the terms of the GNU Lesser General Public License as published
9 by the Free Software Foundation; either version 2.1 of the License,
10 or (at your option) any later version.
11
12 PulseAudio is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
16
17 You should have received a copy of the GNU Lesser General Public License
18 along with PulseAudio; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
20 USA.
21 ***/
22
23 #ifdef HAVE_CONFIG_H
24 #include <config.h>
25 #endif
26
27 #include <signal.h>
28 #include <string.h>
29 #include <errno.h>
30 #include <unistd.h>
31 #include <assert.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <getopt.h>
35 #include <fcntl.h>
36 #include <locale.h>
37
38 #include <sndfile.h>
39
40 #include <pulse/i18n.h>
41 #include <pulse/pulseaudio.h>
42 #include <pulse/rtclock.h>
43
44 #include <pulsecore/macro.h>
45 #include <pulsecore/core-util.h>
46 #include <pulsecore/log.h>
47 #include <pulsecore/sndfile-util.h>
48 #include <pulsecore/core-util.h>
49
50 #define TIME_EVENT_USEC 50000
51
52 #define CLEAR_LINE "\x1B[K"
53
54 static enum { RECORD, PLAYBACK } mode = PLAYBACK;
55
56 static pa_context *context = NULL;
57 static pa_stream *stream = NULL;
58 static pa_mainloop_api *mainloop_api = NULL;
59
60 static void *buffer = NULL;
61 static size_t buffer_length = 0, buffer_index = 0;
62
63 static pa_io_event* stdio_event = NULL;
64
65 static pa_proplist *proplist = NULL;
66 static char *device = NULL;
67
68 static SNDFILE* sndfile = NULL;
69
70 static pa_bool_t verbose = FALSE;
71 static pa_volume_t volume = PA_VOLUME_NORM;
72 static pa_bool_t volume_is_set = FALSE;
73
74 static pa_sample_spec sample_spec = {
75 .format = PA_SAMPLE_S16LE,
76 .rate = 44100,
77 .channels = 2
78 };
79 static pa_bool_t sample_spec_set = FALSE;
80
81 static pa_channel_map channel_map;
82 static pa_bool_t channel_map_set = FALSE;
83
84 static sf_count_t (*readf_function)(SNDFILE *_sndfile, void *ptr, sf_count_t frames) = NULL;
85 static sf_count_t (*writef_function)(SNDFILE *_sndfile, const void *ptr, sf_count_t frames) = NULL;
86
87 static pa_stream_flags_t flags = 0;
88
89 static size_t latency = 0, process_time = 0;
90 static int32_t latency_msec = 0, process_time_msec = 0;
91
92 static pa_bool_t raw = TRUE;
93 static int file_format = -1;
94
95 /* A shortcut for terminating the application */
96 static void quit(int ret) {
97 pa_assert(mainloop_api);
98 mainloop_api->quit(mainloop_api, ret);
99 }
100
101 /* Connection draining complete */
102 static void context_drain_complete(pa_context*c, void *userdata) {
103 pa_context_disconnect(c);
104 }
105
106 /* Stream draining complete */
107 static void stream_drain_complete(pa_stream*s, int success, void *userdata) {
108
109 if (!success) {
110 pa_log(_("Failed to drain stream: %s"), pa_strerror(pa_context_errno(context)));
111 quit(1);
112 }
113
114 if (verbose)
115 pa_log(_("Playback stream drained."));
116
117 pa_stream_disconnect(stream);
118 pa_stream_unref(stream);
119 stream = NULL;
120
121 if (!pa_context_drain(context, context_drain_complete, NULL))
122 pa_context_disconnect(context);
123 else {
124 if (verbose)
125 pa_log(_("Draining connection to server."));
126 }
127 }
128
129 /* Start draining */
130 static void start_drain(void) {
131
132 if (stream) {
133 pa_operation *o;
134
135 pa_stream_set_write_callback(stream, NULL, NULL);
136
137 if (!(o = pa_stream_drain(stream, stream_drain_complete, NULL))) {
138 pa_log(_("pa_stream_drain(): %s"), pa_strerror(pa_context_errno(context)));
139 quit(1);
140 return;
141 }
142
143 pa_operation_unref(o);
144 } else
145 quit(0);
146 }
147
148 /* Write some data to the stream */
149 static void do_stream_write(size_t length) {
150 size_t l;
151 pa_assert(length);
152
153 if (!buffer || !buffer_length)
154 return;
155
156 l = length;
157 if (l > buffer_length)
158 l = buffer_length;
159
160 if (pa_stream_write(stream, (uint8_t*) buffer + buffer_index, l, NULL, 0, PA_SEEK_RELATIVE) < 0) {
161 pa_log(_("pa_stream_write() failed: %s"), pa_strerror(pa_context_errno(context)));
162 quit(1);
163 return;
164 }
165
166 buffer_length -= l;
167 buffer_index += l;
168
169 if (!buffer_length) {
170 pa_xfree(buffer);
171 buffer = NULL;
172 buffer_index = buffer_length = 0;
173 }
174 }
175
176 /* This is called whenever new data may be written to the stream */
177 static void stream_write_callback(pa_stream *s, size_t length, void *userdata) {
178 pa_assert(s);
179 pa_assert(length > 0);
180
181 if (raw) {
182 pa_assert(!sndfile);
183
184 if (stdio_event)
185 mainloop_api->io_enable(stdio_event, PA_IO_EVENT_INPUT);
186
187 if (!buffer)
188 return;
189
190 do_stream_write(length);
191
192 } else {
193 sf_count_t bytes;
194 void *data;
195
196 pa_assert(sndfile);
197
198 if (pa_stream_begin_write(s, &data, &length) < 0) {
199 pa_log(_("pa_stream_begin_write() failed: %s"), pa_strerror(pa_context_errno(context)));
200 quit(1);
201 return;
202 }
203
204 if (readf_function) {
205 size_t k = pa_frame_size(&sample_spec);
206
207 if ((bytes = readf_function(sndfile, data, (sf_count_t) (length/k))) > 0)
208 bytes *= (sf_count_t) k;
209
210 } else
211 bytes = sf_read_raw(sndfile, data, (sf_count_t) length);
212
213 if (bytes > 0)
214 pa_stream_write(s, data, (size_t) bytes, NULL, 0, PA_SEEK_RELATIVE);
215 else
216 pa_stream_cancel_write(s);
217
218 if (bytes < (sf_count_t) length)
219 start_drain();
220 }
221 }
222
223 /* This is called whenever new data may is available */
224 static void stream_read_callback(pa_stream *s, size_t length, void *userdata) {
225
226 pa_assert(s);
227 pa_assert(length > 0);
228
229 if (raw) {
230 pa_assert(!sndfile);
231
232 if (stdio_event)
233 mainloop_api->io_enable(stdio_event, PA_IO_EVENT_OUTPUT);
234
235 while (pa_stream_readable_size(s) > 0) {
236 const void *data;
237
238 if (pa_stream_peek(s, &data, &length) < 0) {
239 pa_log(_("pa_stream_peek() failed: %s"), pa_strerror(pa_context_errno(context)));
240 quit(1);
241 return;
242 }
243
244 pa_assert(data);
245 pa_assert(length > 0);
246
247 if (buffer) {
248 buffer = pa_xrealloc(buffer, buffer_length + length);
249 memcpy((uint8_t*) buffer + buffer_length, data, length);
250 buffer_length += length;
251 } else {
252 buffer = pa_xmalloc(length);
253 memcpy(buffer, data, length);
254 buffer_length = length;
255 buffer_index = 0;
256 }
257
258 pa_stream_drop(s);
259 }
260
261 } else {
262 pa_assert(sndfile);
263
264 while (pa_stream_readable_size(s) > 0) {
265 sf_count_t bytes;
266 const void *data;
267
268 if (pa_stream_peek(s, &data, &length) < 0) {
269 pa_log(_("pa_stream_peek() failed: %s"), pa_strerror(pa_context_errno(context)));
270 quit(1);
271 return;
272 }
273
274 pa_assert(data);
275 pa_assert(length > 0);
276
277 if (writef_function) {
278 size_t k = pa_frame_size(&sample_spec);
279
280 if ((bytes = writef_function(sndfile, data, (sf_count_t) (length/k))) > 0)
281 bytes *= (sf_count_t) k;
282
283 } else
284 bytes = sf_write_raw(sndfile, data, (sf_count_t) length);
285
286 if (bytes < (sf_count_t) length)
287 quit(1);
288
289 pa_stream_drop(s);
290 }
291 }
292 }
293
294 /* This routine is called whenever the stream state changes */
295 static void stream_state_callback(pa_stream *s, void *userdata) {
296 pa_assert(s);
297
298 switch (pa_stream_get_state(s)) {
299 case PA_STREAM_CREATING:
300 case PA_STREAM_TERMINATED:
301 break;
302
303 case PA_STREAM_READY:
304
305 if (verbose) {
306 const pa_buffer_attr *a;
307 char cmt[PA_CHANNEL_MAP_SNPRINT_MAX], sst[PA_SAMPLE_SPEC_SNPRINT_MAX];
308
309 pa_log(_("Stream successfully created."));
310
311 if (!(a = pa_stream_get_buffer_attr(s)))
312 pa_log(_("pa_stream_get_buffer_attr() failed: %s"), pa_strerror(pa_context_errno(pa_stream_get_context(s))));
313 else {
314
315 if (mode == PLAYBACK)
316 pa_log(_("Buffer metrics: maxlength=%u, tlength=%u, prebuf=%u, minreq=%u"), a->maxlength, a->tlength, a->prebuf, a->minreq);
317 else {
318 pa_assert(mode == RECORD);
319 pa_log(_("Buffer metrics: maxlength=%u, fragsize=%u"), a->maxlength, a->fragsize);
320 }
321 }
322
323 pa_log(_("Using sample spec '%s', channel map '%s'."),
324 pa_sample_spec_snprint(sst, sizeof(sst), pa_stream_get_sample_spec(s)),
325 pa_channel_map_snprint(cmt, sizeof(cmt), pa_stream_get_channel_map(s)));
326
327 pa_log(_("Connected to device %s (%u, %ssuspended)."),
328 pa_stream_get_device_name(s),
329 pa_stream_get_device_index(s),
330 pa_stream_is_suspended(s) ? "" : "not ");
331 }
332
333 break;
334
335 case PA_STREAM_FAILED:
336 default:
337 pa_log(_("Stream error: %s"), pa_strerror(pa_context_errno(pa_stream_get_context(s))));
338 quit(1);
339 }
340 }
341
342 static void stream_suspended_callback(pa_stream *s, void *userdata) {
343 pa_assert(s);
344
345 if (verbose) {
346 if (pa_stream_is_suspended(s))
347 pa_log(_("Stream device suspended.%s"), CLEAR_LINE);
348 else
349 pa_log(_("Stream device resumed.%s"), CLEAR_LINE);
350 }
351 }
352
353 static void stream_underflow_callback(pa_stream *s, void *userdata) {
354 pa_assert(s);
355
356 if (verbose)
357 pa_log(_("Stream underrun.%s"), CLEAR_LINE);
358 }
359
360 static void stream_overflow_callback(pa_stream *s, void *userdata) {
361 pa_assert(s);
362
363 if (verbose)
364 pa_log(_("Stream overrun.%s"), CLEAR_LINE);
365 }
366
367 static void stream_started_callback(pa_stream *s, void *userdata) {
368 pa_assert(s);
369
370 if (verbose)
371 pa_log(_("Stream started.%s"), CLEAR_LINE);
372 }
373
374 static void stream_moved_callback(pa_stream *s, void *userdata) {
375 pa_assert(s);
376
377 if (verbose)
378 pa_log(_("Stream moved to device %s (%u, %ssuspended).%s"), pa_stream_get_device_name(s), pa_stream_get_device_index(s), pa_stream_is_suspended(s) ? "" : _("not "), CLEAR_LINE);
379 }
380
381 static void stream_buffer_attr_callback(pa_stream *s, void *userdata) {
382 pa_assert(s);
383
384 if (verbose)
385 pa_log(_("Stream buffer attributes changed.%s"), CLEAR_LINE);
386 }
387
388 static void stream_event_callback(pa_stream *s, const char *name, pa_proplist *pl, void *userdata) {
389 char *t;
390
391 pa_assert(s);
392 pa_assert(name);
393 pa_assert(pl);
394
395 t = pa_proplist_to_string_sep(pl, ", ");
396 pa_log("Got event '%s', properties '%s'", name, t);
397 pa_xfree(t);
398 }
399
400 /* This is called whenever the context status changes */
401 static void context_state_callback(pa_context *c, void *userdata) {
402 pa_assert(c);
403
404 switch (pa_context_get_state(c)) {
405 case PA_CONTEXT_CONNECTING:
406 case PA_CONTEXT_AUTHORIZING:
407 case PA_CONTEXT_SETTING_NAME:
408 break;
409
410 case PA_CONTEXT_READY: {
411 pa_buffer_attr buffer_attr;
412
413 pa_assert(c);
414 pa_assert(!stream);
415
416 if (verbose)
417 pa_log(_("Connection established.%s"), CLEAR_LINE);
418
419 if (!(stream = pa_stream_new_with_proplist(c, NULL, &sample_spec, &channel_map, proplist))) {
420 pa_log(_("pa_stream_new() failed: %s"), pa_strerror(pa_context_errno(c)));
421 goto fail;
422 }
423
424 pa_stream_set_state_callback(stream, stream_state_callback, NULL);
425 pa_stream_set_write_callback(stream, stream_write_callback, NULL);
426 pa_stream_set_read_callback(stream, stream_read_callback, NULL);
427 pa_stream_set_suspended_callback(stream, stream_suspended_callback, NULL);
428 pa_stream_set_moved_callback(stream, stream_moved_callback, NULL);
429 pa_stream_set_underflow_callback(stream, stream_underflow_callback, NULL);
430 pa_stream_set_overflow_callback(stream, stream_overflow_callback, NULL);
431 pa_stream_set_started_callback(stream, stream_started_callback, NULL);
432 pa_stream_set_event_callback(stream, stream_event_callback, NULL);
433 pa_stream_set_buffer_attr_callback(stream, stream_buffer_attr_callback, NULL);
434
435 pa_zero(buffer_attr);
436 buffer_attr.maxlength = (uint32_t) -1;
437 buffer_attr.prebuf = (uint32_t) -1;
438
439 if (latency_msec > 0) {
440 buffer_attr.fragsize = buffer_attr.tlength = pa_usec_to_bytes(latency_msec * PA_USEC_PER_MSEC, &sample_spec);
441 flags |= PA_STREAM_ADJUST_LATENCY;
442 } else if (latency > 0) {
443 buffer_attr.fragsize = buffer_attr.tlength = (uint32_t) latency;
444 flags |= PA_STREAM_ADJUST_LATENCY;
445 } else
446 buffer_attr.fragsize = buffer_attr.tlength = (uint32_t) -1;
447
448 if (process_time_msec > 0) {
449 buffer_attr.minreq = pa_usec_to_bytes(process_time_msec * PA_USEC_PER_MSEC, &sample_spec);
450 } else if (process_time > 0)
451 buffer_attr.minreq = (uint32_t) process_time;
452 else
453 buffer_attr.minreq = (uint32_t) -1;
454
455 if (mode == PLAYBACK) {
456 pa_cvolume cv;
457 if (pa_stream_connect_playback(stream, device, &buffer_attr, flags, volume_is_set ? pa_cvolume_set(&cv, sample_spec.channels, volume) : NULL, NULL) < 0) {
458 pa_log(_("pa_stream_connect_playback() failed: %s"), pa_strerror(pa_context_errno(c)));
459 goto fail;
460 }
461
462 } else {
463 if (pa_stream_connect_record(stream, device, latency > 0 ? &buffer_attr : NULL, flags) < 0) {
464 pa_log(_("pa_stream_connect_record() failed: %s"), pa_strerror(pa_context_errno(c)));
465 goto fail;
466 }
467 }
468
469 break;
470 }
471
472 case PA_CONTEXT_TERMINATED:
473 quit(0);
474 break;
475
476 case PA_CONTEXT_FAILED:
477 default:
478 pa_log(_("Connection failure: %s"), pa_strerror(pa_context_errno(c)));
479 goto fail;
480 }
481
482 return;
483
484 fail:
485 quit(1);
486
487 }
488
489 /* New data on STDIN **/
490 static void stdin_callback(pa_mainloop_api*a, pa_io_event *e, int fd, pa_io_event_flags_t f, void *userdata) {
491 size_t l, w = 0;
492 ssize_t r;
493
494 pa_assert(a == mainloop_api);
495 pa_assert(e);
496 pa_assert(stdio_event == e);
497
498 if (buffer) {
499 mainloop_api->io_enable(stdio_event, PA_IO_EVENT_NULL);
500 return;
501 }
502
503 if (!stream || pa_stream_get_state(stream) != PA_STREAM_READY || !(l = w = pa_stream_writable_size(stream)))
504 l = 4096;
505
506 buffer = pa_xmalloc(l);
507
508 if ((r = read(fd, buffer, l)) <= 0) {
509 if (r == 0) {
510 if (verbose)
511 pa_log(_("Got EOF."));
512
513 start_drain();
514
515 } else {
516 pa_log(_("read() failed: %s"), strerror(errno));
517 quit(1);
518 }
519
520 mainloop_api->io_free(stdio_event);
521 stdio_event = NULL;
522 return;
523 }
524
525 buffer_length = (uint32_t) r;
526 buffer_index = 0;
527
528 if (w)
529 do_stream_write(w);
530 }
531
532 /* Some data may be written to STDOUT */
533 static void stdout_callback(pa_mainloop_api*a, pa_io_event *e, int fd, pa_io_event_flags_t f, void *userdata) {
534 ssize_t r;
535
536 pa_assert(a == mainloop_api);
537 pa_assert(e);
538 pa_assert(stdio_event == e);
539
540 if (!buffer) {
541 mainloop_api->io_enable(stdio_event, PA_IO_EVENT_NULL);
542 return;
543 }
544
545 pa_assert(buffer_length);
546
547 if ((r = write(fd, (uint8_t*) buffer+buffer_index, buffer_length)) <= 0) {
548 pa_log(_("write() failed: %s"), strerror(errno));
549 quit(1);
550
551 mainloop_api->io_free(stdio_event);
552 stdio_event = NULL;
553 return;
554 }
555
556 buffer_length -= (uint32_t) r;
557 buffer_index += (uint32_t) r;
558
559 if (!buffer_length) {
560 pa_xfree(buffer);
561 buffer = NULL;
562 buffer_length = buffer_index = 0;
563 }
564 }
565
566 /* UNIX signal to quit recieved */
567 static void exit_signal_callback(pa_mainloop_api*m, pa_signal_event *e, int sig, void *userdata) {
568 if (verbose)
569 pa_log(_("Got signal, exiting."));
570 quit(0);
571 }
572
573 /* Show the current latency */
574 static void stream_update_timing_callback(pa_stream *s, int success, void *userdata) {
575 pa_usec_t l, usec;
576 int negative = 0;
577
578 pa_assert(s);
579
580 if (!success ||
581 pa_stream_get_time(s, &usec) < 0 ||
582 pa_stream_get_latency(s, &l, &negative) < 0) {
583 pa_log(_("Failed to get latency: %s"), pa_strerror(pa_context_errno(context)));
584 quit(1);
585 return;
586 }
587
588 fprintf(stderr, _("Time: %0.3f sec; Latency: %0.0f usec."),
589 (float) usec / 1000000,
590 (float) l * (negative?-1.0f:1.0f));
591 fprintf(stderr, " \r");
592 }
593
594 /* Someone requested that the latency is shown */
595 static void sigusr1_signal_callback(pa_mainloop_api*m, pa_signal_event *e, int sig, void *userdata) {
596
597 if (!stream)
598 return;
599
600 pa_operation_unref(pa_stream_update_timing_info(stream, stream_update_timing_callback, NULL));
601 }
602
603 static void time_event_callback(pa_mainloop_api *m, pa_time_event *e, const struct timeval *t, void *userdata) {
604 if (stream && pa_stream_get_state(stream) == PA_STREAM_READY) {
605 pa_operation *o;
606 if (!(o = pa_stream_update_timing_info(stream, stream_update_timing_callback, NULL)))
607 pa_log(_("pa_stream_update_timing_info() failed: %s"), pa_strerror(pa_context_errno(context)));
608 else
609 pa_operation_unref(o);
610 }
611
612 pa_context_rttime_restart(context, e, pa_rtclock_now() + TIME_EVENT_USEC);
613 }
614
615 static void help(const char *argv0) {
616
617 printf(_("%s [options]\n\n"
618 " -h, --help Show this help\n"
619 " --version Show version\n\n"
620 " -r, --record Create a connection for recording\n"
621 " -p, --playback Create a connection for playback\n\n"
622 " -v, --verbose Enable verbose operations\n\n"
623 " -s, --server=SERVER The name of the server to connect to\n"
624 " -d, --device=DEVICE The name of the sink/source to connect to\n"
625 " -n, --client-name=NAME How to call this client on the server\n"
626 " --stream-name=NAME How to call this stream on the server\n"
627 " --volume=VOLUME Specify the initial (linear) volume in range 0...65536\n"
628 " --rate=SAMPLERATE The sample rate in Hz (defaults to 44100)\n"
629 " --format=SAMPLEFORMAT The sample type, one of s16le, s16be, u8, float32le,\n"
630 " float32be, ulaw, alaw, s32le, s32be, s24le, s24be,\n"
631 " s24-32le, s24-32be (defaults to s16ne)\n"
632 " --channels=CHANNELS The number of channels, 1 for mono, 2 for stereo\n"
633 " (defaults to 2)\n"
634 " --channel-map=CHANNELMAP Channel map to use instead of the default\n"
635 " --fix-format Take the sample format from the sink the stream is\n"
636 " being connected to.\n"
637 " --fix-rate Take the sampling rate from the sink the stream is\n"
638 " being connected to.\n"
639 " --fix-channels Take the number of channels and the channel map\n"
640 " from the sink the stream is being connected to.\n"
641 " --no-remix Don't upmix or downmix channels.\n"
642 " --no-remap Map channels by index instead of name.\n"
643 " --latency=BYTES Request the specified latency in bytes.\n"
644 " --process-time=BYTES Request the specified process time per request in bytes.\n"
645 " --latency-msec=MSEC Request the specified latency in msec.\n"
646 " --process-time-msec=MSEC Request the specified process time per request in msec.\n"
647 " --property=PROPERTY=VALUE Set the specified property to the specified value.\n"
648 " --raw Record/play raw PCM data.\n"
649 " --file-format[=FFORMAT] Record/play formatted PCM data.\n"
650 " --list-file-formats List available file formats.\n")
651 , argv0);
652 }
653
654 enum {
655 ARG_VERSION = 256,
656 ARG_STREAM_NAME,
657 ARG_VOLUME,
658 ARG_SAMPLERATE,
659 ARG_SAMPLEFORMAT,
660 ARG_CHANNELS,
661 ARG_CHANNELMAP,
662 ARG_FIX_FORMAT,
663 ARG_FIX_RATE,
664 ARG_FIX_CHANNELS,
665 ARG_NO_REMAP,
666 ARG_NO_REMIX,
667 ARG_LATENCY,
668 ARG_PROCESS_TIME,
669 ARG_RAW,
670 ARG_PROPERTY,
671 ARG_FILE_FORMAT,
672 ARG_LIST_FILE_FORMATS,
673 ARG_LATENCY_MSEC,
674 ARG_PROCESS_TIME_MSEC
675 };
676
677 int main(int argc, char *argv[]) {
678 pa_mainloop* m = NULL;
679 int ret = 1, c;
680 char *bn, *server = NULL;
681 pa_time_event *time_event = NULL;
682 const char *filename = NULL;
683
684 static const struct option long_options[] = {
685 {"record", 0, NULL, 'r'},
686 {"playback", 0, NULL, 'p'},
687 {"device", 1, NULL, 'd'},
688 {"server", 1, NULL, 's'},
689 {"client-name", 1, NULL, 'n'},
690 {"stream-name", 1, NULL, ARG_STREAM_NAME},
691 {"version", 0, NULL, ARG_VERSION},
692 {"help", 0, NULL, 'h'},
693 {"verbose", 0, NULL, 'v'},
694 {"volume", 1, NULL, ARG_VOLUME},
695 {"rate", 1, NULL, ARG_SAMPLERATE},
696 {"format", 1, NULL, ARG_SAMPLEFORMAT},
697 {"channels", 1, NULL, ARG_CHANNELS},
698 {"channel-map", 1, NULL, ARG_CHANNELMAP},
699 {"fix-format", 0, NULL, ARG_FIX_FORMAT},
700 {"fix-rate", 0, NULL, ARG_FIX_RATE},
701 {"fix-channels", 0, NULL, ARG_FIX_CHANNELS},
702 {"no-remap", 0, NULL, ARG_NO_REMAP},
703 {"no-remix", 0, NULL, ARG_NO_REMIX},
704 {"latency", 1, NULL, ARG_LATENCY},
705 {"process-time", 1, NULL, ARG_PROCESS_TIME},
706 {"property", 1, NULL, ARG_PROPERTY},
707 {"raw", 0, NULL, ARG_RAW},
708 {"file-format", 2, NULL, ARG_FILE_FORMAT},
709 {"list-file-formats", 0, NULL, ARG_LIST_FILE_FORMATS},
710 {"latency-msec", 1, NULL, ARG_LATENCY_MSEC},
711 {"process-time-msec", 1, NULL, ARG_PROCESS_TIME_MSEC},
712 {NULL, 0, NULL, 0}
713 };
714
715 setlocale(LC_ALL, "");
716 bindtextdomain(GETTEXT_PACKAGE, PULSE_LOCALEDIR);
717
718 bn = pa_path_get_filename(argv[0]);
719
720 if (strstr(bn, "play")) {
721 mode = PLAYBACK;
722 raw = FALSE;
723 } else if (strstr(bn, "record")) {
724 mode = RECORD;
725 raw = FALSE;
726 } else if (strstr(bn, "cat")) {
727 mode = PLAYBACK;
728 raw = TRUE;
729 } if (strstr(bn, "rec") || strstr(bn, "mon")) {
730 mode = RECORD;
731 raw = TRUE;
732 }
733
734 proplist = pa_proplist_new();
735
736 while ((c = getopt_long(argc, argv, "rpd:s:n:hv", long_options, NULL)) != -1) {
737
738 switch (c) {
739 case 'h' :
740 help(bn);
741 ret = 0;
742 goto quit;
743
744 case ARG_VERSION:
745 printf(_("pacat %s\n"
746 "Compiled with libpulse %s\n"
747 "Linked with libpulse %s\n"),
748 PACKAGE_VERSION,
749 pa_get_headers_version(),
750 pa_get_library_version());
751 ret = 0;
752 goto quit;
753
754 case 'r':
755 mode = RECORD;
756 break;
757
758 case 'p':
759 mode = PLAYBACK;
760 break;
761
762 case 'd':
763 pa_xfree(device);
764 device = pa_xstrdup(optarg);
765 break;
766
767 case 's':
768 pa_xfree(server);
769 server = pa_xstrdup(optarg);
770 break;
771
772 case 'n': {
773 char *t;
774
775 if (!(t = pa_locale_to_utf8(optarg)) ||
776 pa_proplist_sets(proplist, PA_PROP_APPLICATION_NAME, t) < 0) {
777
778 pa_log(_("Invalid client name '%s'"), t ? t : optarg);
779 pa_xfree(t);
780 goto quit;
781 }
782
783 pa_xfree(t);
784 break;
785 }
786
787 case ARG_STREAM_NAME: {
788 char *t;
789
790 if (!(t = pa_locale_to_utf8(optarg)) ||
791 pa_proplist_sets(proplist, PA_PROP_MEDIA_NAME, t) < 0) {
792
793 pa_log(_("Invalid stream name '%s'"), t ? t : optarg);
794 pa_xfree(t);
795 goto quit;
796 }
797
798 pa_xfree(t);
799 break;
800 }
801
802 case 'v':
803 verbose = 1;
804 break;
805
806 case ARG_VOLUME: {
807 int v = atoi(optarg);
808 volume = v < 0 ? 0U : (pa_volume_t) v;
809 volume_is_set = TRUE;
810 break;
811 }
812
813 case ARG_CHANNELS:
814 sample_spec.channels = (uint8_t) atoi(optarg);
815 sample_spec_set = TRUE;
816 break;
817
818 case ARG_SAMPLEFORMAT:
819 sample_spec.format = pa_parse_sample_format(optarg);
820 sample_spec_set = TRUE;
821 break;
822
823 case ARG_SAMPLERATE:
824 sample_spec.rate = (uint32_t) atoi(optarg);
825 sample_spec_set = TRUE;
826 break;
827
828 case ARG_CHANNELMAP:
829 if (!pa_channel_map_parse(&channel_map, optarg)) {
830 pa_log(_("Invalid channel map '%s'"), optarg);
831 goto quit;
832 }
833
834 channel_map_set = TRUE;
835 break;
836
837 case ARG_FIX_CHANNELS:
838 flags |= PA_STREAM_FIX_CHANNELS;
839 break;
840
841 case ARG_FIX_RATE:
842 flags |= PA_STREAM_FIX_RATE;
843 break;
844
845 case ARG_FIX_FORMAT:
846 flags |= PA_STREAM_FIX_FORMAT;
847 break;
848
849 case ARG_NO_REMIX:
850 flags |= PA_STREAM_NO_REMIX_CHANNELS;
851 break;
852
853 case ARG_NO_REMAP:
854 flags |= PA_STREAM_NO_REMAP_CHANNELS;
855 break;
856
857 case ARG_LATENCY:
858 if (((latency = (size_t) atoi(optarg))) <= 0) {
859 pa_log(_("Invalid latency specification '%s'"), optarg);
860 goto quit;
861 }
862 break;
863
864 case ARG_PROCESS_TIME:
865 if (((process_time = (size_t) atoi(optarg))) <= 0) {
866 pa_log(_("Invalid process time specification '%s'"), optarg);
867 goto quit;
868 }
869 break;
870
871 case ARG_LATENCY_MSEC:
872 if (((latency_msec = (int32_t) atoi(optarg))) <= 0) {
873 pa_log(_("Invalid latency specification '%s'"), optarg);
874 goto quit;
875 }
876 break;
877
878 case ARG_PROCESS_TIME_MSEC:
879 if (((process_time_msec = (int32_t) atoi(optarg))) <= 0) {
880 pa_log(_("Invalid process time specification '%s'"), optarg);
881 goto quit;
882 }
883 break;
884
885 case ARG_PROPERTY: {
886 char *t;
887
888 if (!(t = pa_locale_to_utf8(optarg)) ||
889 pa_proplist_setp(proplist, t) < 0) {
890
891 pa_xfree(t);
892 pa_log(_("Invalid property '%s'"), optarg);
893 goto quit;
894 }
895
896 pa_xfree(t);
897 break;
898 }
899
900 case ARG_RAW:
901 raw = TRUE;
902 break;
903
904 case ARG_FILE_FORMAT:
905 raw = FALSE;
906
907 if (optarg) {
908 if ((file_format = pa_sndfile_format_from_string(optarg)) < 0) {
909 pa_log(_("Unknown file format %s."), optarg);
910 goto quit;
911 }
912 }
913
914 raw = FALSE;
915 break;
916
917 case ARG_LIST_FILE_FORMATS:
918 pa_sndfile_dump_formats();
919 ret = 0;
920 goto quit;
921
922 default:
923 goto quit;
924 }
925 }
926
927 if (!pa_sample_spec_valid(&sample_spec)) {
928 pa_log(_("Invalid sample specification"));
929 goto quit;
930 }
931
932 if (optind+1 == argc) {
933 int fd;
934
935 filename = argv[optind];
936
937 if ((fd = pa_open_cloexec(argv[optind], mode == PLAYBACK ? O_RDONLY : O_WRONLY|O_TRUNC|O_CREAT, 0666)) < 0) {
938 pa_log(_("open(): %s"), strerror(errno));
939 goto quit;
940 }
941
942 if (dup2(fd, mode == PLAYBACK ? STDIN_FILENO : STDOUT_FILENO) < 0) {
943 pa_log(_("dup2(): %s"), strerror(errno));
944 goto quit;
945 }
946
947 pa_close(fd);
948
949 } else if (optind+1 <= argc) {
950 pa_log(_("Too many arguments."));
951 goto quit;
952 }
953
954 if (!raw) {
955 SF_INFO sfi;
956 pa_zero(sfi);
957
958 if (mode == RECORD) {
959 /* This might patch up the sample spec */
960 if (pa_sndfile_write_sample_spec(&sfi, &sample_spec) < 0) {
961 pa_log(_("Failed to generate sample specification for file."));
962 goto quit;
963 }
964
965 /* Transparently upgrade classic .wav to wavex for multichannel audio */
966 if (file_format <= 0) {
967 if ((sample_spec.channels == 2 && (!channel_map_set || (channel_map.map[0] == PA_CHANNEL_POSITION_LEFT &&
968 channel_map.map[1] == PA_CHANNEL_POSITION_RIGHT))) ||
969 (sample_spec.channels == 1 && (!channel_map_set || (channel_map.map[0] == PA_CHANNEL_POSITION_MONO))))
970 file_format = SF_FORMAT_WAV;
971 else
972 file_format = SF_FORMAT_WAVEX;
973 }
974
975 sfi.format |= file_format;
976 }
977
978 if (!(sndfile = sf_open_fd(mode == RECORD ? STDOUT_FILENO : STDIN_FILENO,
979 mode == RECORD ? SFM_WRITE : SFM_READ,
980 &sfi, 0))) {
981 pa_log(_("Failed to open audio file."));
982 goto quit;
983 }
984
985 if (mode == PLAYBACK) {
986 if (sample_spec_set)
987 pa_log(_("Warning: specified sample specification will be overwritten with specification from file."));
988
989 if (pa_sndfile_read_sample_spec(sndfile, &sample_spec) < 0) {
990 pa_log(_("Failed to determine sample specification from file."));
991 goto quit;
992 }
993 sample_spec_set = TRUE;
994
995 if (!channel_map_set) {
996 /* Allow the user to overwrite the channel map on the command line */
997 if (pa_sndfile_read_channel_map(sndfile, &channel_map) < 0) {
998 if (sample_spec.channels > 2)
999 pa_log(_("Warning: Failed to determine channel map from file."));
1000 } else
1001 channel_map_set = TRUE;
1002 }
1003 }
1004 }
1005
1006 if (!channel_map_set)
1007 pa_channel_map_init_extend(&channel_map, sample_spec.channels, PA_CHANNEL_MAP_DEFAULT);
1008
1009 if (!pa_channel_map_compatible(&channel_map, &sample_spec)) {
1010 pa_log(_("Channel map doesn't match sample specification"));
1011 goto quit;
1012 }
1013
1014 if (!raw) {
1015 pa_proplist *sfp;
1016
1017 if (mode == PLAYBACK)
1018 readf_function = pa_sndfile_readf_function(&sample_spec);
1019 else {
1020 if (pa_sndfile_write_channel_map(sndfile, &channel_map) < 0)
1021 pa_log(_("Warning: failed to write channel map to file."));
1022
1023 writef_function = pa_sndfile_writef_function(&sample_spec);
1024 }
1025
1026 /* Fill in libsndfile prop list data */
1027 sfp = pa_proplist_new();
1028 pa_sndfile_init_proplist(sndfile, sfp);
1029 pa_proplist_update(proplist, PA_UPDATE_MERGE, sfp);
1030 pa_proplist_free(sfp);
1031 }
1032
1033 if (verbose) {
1034 char tss[PA_SAMPLE_SPEC_SNPRINT_MAX], tcm[PA_CHANNEL_MAP_SNPRINT_MAX];
1035
1036 pa_log(_("Opening a %s stream with sample specification '%s' and channel map '%s'."),
1037 mode == RECORD ? _("recording") : _("playback"),
1038 pa_sample_spec_snprint(tss, sizeof(tss), &sample_spec),
1039 pa_channel_map_snprint(tcm, sizeof(tcm), &channel_map));
1040 }
1041
1042 /* Fill in client name if none was set */
1043 if (!pa_proplist_contains(proplist, PA_PROP_APPLICATION_NAME)) {
1044 char *t;
1045
1046 if ((t = pa_locale_to_utf8(bn))) {
1047 pa_proplist_sets(proplist, PA_PROP_APPLICATION_NAME, t);
1048 pa_xfree(t);
1049 }
1050 }
1051
1052 /* Fill in media name if none was set */
1053 if (!pa_proplist_contains(proplist, PA_PROP_MEDIA_NAME)) {
1054 const char *t;
1055
1056 if ((t = filename) ||
1057 (t = pa_proplist_gets(proplist, PA_PROP_APPLICATION_NAME)))
1058 pa_proplist_sets(proplist, PA_PROP_MEDIA_NAME, t);
1059 }
1060
1061 /* Set up a new main loop */
1062 if (!(m = pa_mainloop_new())) {
1063 pa_log(_("pa_mainloop_new() failed."));
1064 goto quit;
1065 }
1066
1067 mainloop_api = pa_mainloop_get_api(m);
1068
1069 pa_assert_se(pa_signal_init(mainloop_api) == 0);
1070 pa_signal_new(SIGINT, exit_signal_callback, NULL);
1071 pa_signal_new(SIGTERM, exit_signal_callback, NULL);
1072 #ifdef SIGUSR1
1073 pa_signal_new(SIGUSR1, sigusr1_signal_callback, NULL);
1074 #endif
1075 pa_disable_sigpipe();
1076
1077 if (raw) {
1078 if (!(stdio_event = mainloop_api->io_new(mainloop_api,
1079 mode == PLAYBACK ? STDIN_FILENO : STDOUT_FILENO,
1080 mode == PLAYBACK ? PA_IO_EVENT_INPUT : PA_IO_EVENT_OUTPUT,
1081 mode == PLAYBACK ? stdin_callback : stdout_callback, NULL))) {
1082 pa_log(_("io_new() failed."));
1083 goto quit;
1084 }
1085 }
1086
1087 /* Create a new connection context */
1088 if (!(context = pa_context_new_with_proplist(mainloop_api, NULL, proplist))) {
1089 pa_log(_("pa_context_new() failed."));
1090 goto quit;
1091 }
1092
1093 pa_context_set_state_callback(context, context_state_callback, NULL);
1094
1095 /* Connect the context */
1096 if (pa_context_connect(context, server, 0, NULL) < 0) {
1097 pa_log(_("pa_context_connect() failed: %s"), pa_strerror(pa_context_errno(context)));
1098 goto quit;
1099 }
1100
1101 if (verbose) {
1102 if (!(time_event = pa_context_rttime_new(context, pa_rtclock_now() + TIME_EVENT_USEC, time_event_callback, NULL))) {
1103 pa_log(_("pa_context_rttime_new() failed."));
1104 goto quit;
1105 }
1106 }
1107
1108 /* Run the main loop */
1109 if (pa_mainloop_run(m, &ret) < 0) {
1110 pa_log(_("pa_mainloop_run() failed."));
1111 goto quit;
1112 }
1113
1114 quit:
1115 if (stream)
1116 pa_stream_unref(stream);
1117
1118 if (context)
1119 pa_context_unref(context);
1120
1121 if (stdio_event) {
1122 pa_assert(mainloop_api);
1123 mainloop_api->io_free(stdio_event);
1124 }
1125
1126 if (time_event) {
1127 pa_assert(mainloop_api);
1128 mainloop_api->time_free(time_event);
1129 }
1130
1131 if (m) {
1132 pa_signal_done();
1133 pa_mainloop_free(m);
1134 }
1135
1136 pa_xfree(buffer);
1137
1138 pa_xfree(server);
1139 pa_xfree(device);
1140
1141 if (sndfile)
1142 sf_close(sndfile);
1143
1144 if (proplist)
1145 pa_proplist_free(proplist);
1146
1147 return ret;
1148 }