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