]> code.delx.au - pulseaudio/blob - src/utils/pacat.c
delx.au / code / pulseaudio / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge commit 'flameeyes/master'
[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
43 #include <pulsecore/macro.h>
44 #include <pulsecore/core-util.h>
45 #include <pulsecore/log.h>
46 #include <pulsecore/sndfile-util.h>
47
48 #define TIME_EVENT_USEC 50000
49
50 #define CLEAR_LINE "\x1B[K"
51
52 static enum { RECORD, PLAYBACK } mode = PLAYBACK;
53
54 static pa_context *context = NULL;
55 static pa_stream *stream = NULL;
56 static pa_mainloop_api *mainloop_api = NULL;
57
58 static void *buffer = NULL;
59 static size_t buffer_length = 0, buffer_index = 0;
60
61 static pa_io_event* stdio_event = NULL;
62
63 static pa_proplist *proplist = NULL;
64 static char *device = NULL;
65
66 static SNDFILE* sndfile = NULL;
67
68 static pa_bool_t verbose = FALSE;
69 static pa_volume_t volume = PA_VOLUME_NORM;
70 static pa_bool_t volume_is_set = FALSE;
71
72 static pa_sample_spec sample_spec = {
73 .format = PA_SAMPLE_S16LE,
74 .rate = 44100,
75 .channels = 2
76 };
77 static pa_bool_t sample_spec_set = FALSE;
78
79 static pa_channel_map channel_map;
80 static pa_bool_t channel_map_set = FALSE;
81
82 static sf_count_t (*readf_function)(SNDFILE *_sndfile, void *ptr, sf_count_t frames) = NULL;
83 static sf_count_t (*writef_function)(SNDFILE *_sndfile, const void *ptr, sf_count_t frames) = NULL;
84
85 static pa_stream_flags_t flags = 0;
86
87 static size_t latency = 0, process_time = 0;
88
89 static pa_bool_t raw = TRUE;
90 static int file_format = -1;
91
92 /* A shortcut for terminating the application */
93 static void quit(int ret) {
94 pa_assert(mainloop_api);
95 mainloop_api->quit(mainloop_api, ret);
96 }
97
98 /* Connection draining complete */
99 static void context_drain_complete(pa_context*c, void *userdata) {
100 pa_context_disconnect(c);
101 }
102
103 /* Stream draining complete */
104 static void stream_drain_complete(pa_stream*s, int success, void *userdata) {
105
106 if (!success) {
107 pa_log(_("Failed to drain stream: %s\n"), pa_strerror(pa_context_errno(context)));
108 quit(1);
109 }
110
111 if (verbose)
112 pa_log(_("Playback stream drained.\n"));
113
114 pa_stream_disconnect(stream);
115 pa_stream_unref(stream);
116 stream = NULL;
117
118 if (!pa_context_drain(context, context_drain_complete, NULL))
119 pa_context_disconnect(context);
120 else {
121 if (verbose)
122 pa_log(_("Draining connection to server.\n"));
123 }
124 }
125
126 /* Start draining */
127 static void start_drain(void) {
128
129 if (stream) {
130 pa_operation *o;
131
132 pa_stream_set_write_callback(stream, NULL, NULL);
133
134 if (!(o = pa_stream_drain(stream, stream_drain_complete, NULL))) {
135 pa_log(_("pa_stream_drain(): %s\n"), pa_strerror(pa_context_errno(context)));
136 quit(1);
137 return;
138 }
139
140 pa_operation_unref(o);
141 } else
142 quit(0);
143 }
144
145 /* Write some data to the stream */
146 static void do_stream_write(size_t length) {
147 size_t l;
148 pa_assert(length);
149
150 if (!buffer || !buffer_length)
151 return;
152
153 l = length;
154 if (l > buffer_length)
155 l = buffer_length;
156
157 if (pa_stream_write(stream, (uint8_t*) buffer + buffer_index, l, NULL, 0, PA_SEEK_RELATIVE) < 0) {
158 pa_log(_("pa_stream_write() failed: %s\n"), pa_strerror(pa_context_errno(context)));
159 quit(1);
160 return;
161 }
162
163 buffer_length -= l;
164 buffer_index += l;
165
166 if (!buffer_length) {
167 pa_xfree(buffer);
168 buffer = NULL;
169 buffer_index = buffer_length = 0;
170 }
171 }
172
173 /* This is called whenever new data may be written to the stream */
174 static void stream_write_callback(pa_stream *s, size_t length, void *userdata) {
175 pa_assert(s);
176 pa_assert(length > 0);
177
178 if (raw) {
179 pa_assert(!sndfile);
180
181 if (stdio_event)
182 mainloop_api->io_enable(stdio_event, PA_IO_EVENT_INPUT);
183
184 if (!buffer)
185 return;
186
187 do_stream_write(length);
188
189 } else {
190 sf_count_t bytes;
191 void *data;
192
193 pa_assert(sndfile);
194
195 data = pa_xmalloc(length);
196
197 if (readf_function) {
198 size_t k = pa_frame_size(&sample_spec);
199
200 if ((bytes = readf_function(sndfile, data, (sf_count_t) (length/k))) > 0)
201 bytes *= (sf_count_t) k;
202
203 } else
204 bytes = sf_read_raw(sndfile, data, (sf_count_t) length);
205
206 if (bytes > 0)
207 pa_stream_write(s, data, (size_t) bytes, pa_xfree, 0, PA_SEEK_RELATIVE);
208 else
209 pa_xfree(data);
210
211 if (bytes < (sf_count_t) length)
212 start_drain();
213 }
214 }
215
216 /* This is called whenever new data may is available */
217 static void stream_read_callback(pa_stream *s, size_t length, void *userdata) {
218
219 pa_assert(s);
220 pa_assert(length > 0);
221
222 if (raw) {
223 pa_assert(!sndfile);
224
225 if (stdio_event)
226 mainloop_api->io_enable(stdio_event, PA_IO_EVENT_OUTPUT);
227
228
229 while (pa_stream_readable_size(s) > 0) {
230 const void *data;
231
232 if (pa_stream_peek(s, &data, &length) < 0) {
233 pa_log(_("pa_stream_peek() failed: %s\n"), pa_strerror(pa_context_errno(context)));
234 quit(1);
235 return;
236 }
237
238 pa_assert(data);
239 pa_assert(length > 0);
240
241 if (buffer) {
242 buffer = pa_xrealloc(buffer, buffer_length + length);
243 memcpy((uint8_t*) buffer + buffer_length, data, length);
244 buffer_length += length;
245 } else {
246 buffer = pa_xmalloc(length);
247 memcpy(buffer, data, length);
248 buffer_length = length;
249 buffer_index = 0;
250 }
251 pa_stream_drop(s);
252 }
253
254 } else {
255 pa_assert(sndfile);
256
257 while (pa_stream_readable_size(s) > 0) {
258 sf_count_t bytes;
259 const void *data;
260
261 if (pa_stream_peek(s, &data, &length) < 0) {
262 pa_log(_("pa_stream_peek() failed: %s\n"), pa_strerror(pa_context_errno(context)));
263 quit(1);
264 return;
265 }
266
267 pa_assert(data);
268 pa_assert(length > 0);
269
270 if (writef_function) {
271 size_t k = pa_frame_size(&sample_spec);
272
273 if ((bytes = writef_function(sndfile, data, (sf_count_t) (length/k))) > 0)
274 bytes *= (sf_count_t) k;
275
276 } else
277 bytes = sf_write_raw(sndfile, data, (sf_count_t) length);
278
279 if (bytes < (sf_count_t) length)
280 quit(1);
281
282 pa_stream_drop(s);
283 }
284 }
285 }
286
287 /* This routine is called whenever the stream state changes */
288 static void stream_state_callback(pa_stream *s, void *userdata) {
289 pa_assert(s);
290
291 switch (pa_stream_get_state(s)) {
292 case PA_STREAM_CREATING:
293 case PA_STREAM_TERMINATED:
294 break;
295
296 case PA_STREAM_READY:
297
298 if (verbose) {
299 const pa_buffer_attr *a;
300 char cmt[PA_CHANNEL_MAP_SNPRINT_MAX], sst[PA_SAMPLE_SPEC_SNPRINT_MAX];
301
302 pa_log(_("Stream successfully created.\n"));
303
304 if (!(a = pa_stream_get_buffer_attr(s)))
305 pa_log(_("pa_stream_get_buffer_attr() failed: %s\n"), pa_strerror(pa_context_errno(pa_stream_get_context(s))));
306 else {
307
308 if (mode == PLAYBACK)
309 pa_log(_("Buffer metrics: maxlength=%u, tlength=%u, prebuf=%u, minreq=%u\n"), a->maxlength, a->tlength, a->prebuf, a->minreq);
310 else {
311 pa_assert(mode == RECORD);
312 pa_log(_("Buffer metrics: maxlength=%u, fragsize=%u\n"), a->maxlength, a->fragsize);
313 }
314 }
315
316 pa_log(_("Using sample spec '%s', channel map '%s'.\n"),
317 pa_sample_spec_snprint(sst, sizeof(sst), pa_stream_get_sample_spec(s)),
318 pa_channel_map_snprint(cmt, sizeof(cmt), pa_stream_get_channel_map(s)));
319
320 pa_log(_("Connected to device %s (%u, %ssuspended).\n"),
321 pa_stream_get_device_name(s),
322 pa_stream_get_device_index(s),
323 pa_stream_is_suspended(s) ? "" : "not ");
324 }
325
326 break;
327
328 case PA_STREAM_FAILED:
329 default:
330 pa_log(_("Stream error: %s\n"), pa_strerror(pa_context_errno(pa_stream_get_context(s))));
331 quit(1);
332 }
333 }
334
335 static void stream_suspended_callback(pa_stream *s, void *userdata) {
336 pa_assert(s);
337
338 if (verbose) {
339 if (pa_stream_is_suspended(s))
340 pa_log(_("Stream device suspended.%s \n"), CLEAR_LINE);
341 else
342 pa_log(_("Stream device resumed.%s \n"), CLEAR_LINE);
343 }
344 }
345
346 static void stream_underflow_callback(pa_stream *s, void *userdata) {
347 pa_assert(s);
348
349 if (verbose)
350 pa_log(_("Stream underrun.%s \n"), CLEAR_LINE);
351 }
352
353 static void stream_overflow_callback(pa_stream *s, void *userdata) {
354 pa_assert(s);
355
356 if (verbose)
357 pa_log(_("Stream overrun.%s \n"), CLEAR_LINE);
358 }
359
360 static void stream_started_callback(pa_stream *s, void *userdata) {
361 pa_assert(s);
362
363 if (verbose)
364 pa_log(_("Stream started.%s \n"), CLEAR_LINE);
365 }
366
367 static void stream_moved_callback(pa_stream *s, void *userdata) {
368 pa_assert(s);
369
370 if (verbose)
371 pa_log(_("Stream moved to device %s (%u, %ssuspended).%s \n"), pa_stream_get_device_name(s), pa_stream_get_device_index(s), pa_stream_is_suspended(s) ? "" : _("not "), CLEAR_LINE);
372 }
373
374 static void stream_buffer_attr_callback(pa_stream *s, void *userdata) {
375 pa_assert(s);
376
377 if (verbose)
378 pa_log(_("Stream buffer attributes changed.%s \n"), CLEAR_LINE);
379 }
380
381 static void stream_event_callback(pa_stream *s, const char *name, pa_proplist *pl, void *userdata) {
382 char *t;
383
384 pa_assert(s);
385 pa_assert(name);
386 pa_assert(pl);
387
388 t = pa_proplist_to_string_sep(pl, ", ");
389 pa_log("Got event '%s', properties '%s'\n", name, t);
390 pa_xfree(t);
391 }
392
393 /* This is called whenever the context status changes */
394 static void context_state_callback(pa_context *c, void *userdata) {
395 pa_assert(c);
396
397 switch (pa_context_get_state(c)) {
398 case PA_CONTEXT_CONNECTING:
399 case PA_CONTEXT_AUTHORIZING:
400 case PA_CONTEXT_SETTING_NAME:
401 break;
402
403 case PA_CONTEXT_READY: {
404 int r;
405 pa_buffer_attr buffer_attr;
406
407 pa_assert(c);
408 pa_assert(!stream);
409
410 if (verbose)
411 pa_log(_("Connection established.%s \n"), CLEAR_LINE);
412
413 if (!(stream = pa_stream_new_with_proplist(c, NULL, &sample_spec, &channel_map, proplist))) {
414 pa_log(_("pa_stream_new() failed: %s\n"), pa_strerror(pa_context_errno(c)));
415 goto fail;
416 }
417
418 pa_stream_set_state_callback(stream, stream_state_callback, NULL);
419 pa_stream_set_write_callback(stream, stream_write_callback, NULL);
420 pa_stream_set_read_callback(stream, stream_read_callback, NULL);
421 pa_stream_set_suspended_callback(stream, stream_suspended_callback, NULL);
422 pa_stream_set_moved_callback(stream, stream_moved_callback, NULL);
423 pa_stream_set_underflow_callback(stream, stream_underflow_callback, NULL);
424 pa_stream_set_overflow_callback(stream, stream_overflow_callback, NULL);
425 pa_stream_set_started_callback(stream, stream_started_callback, NULL);
426 pa_stream_set_event_callback(stream, stream_event_callback, NULL);
427 pa_stream_set_buffer_attr_callback(stream, stream_buffer_attr_callback, NULL);
428
429 if (latency > 0) {
430 memset(&buffer_attr, 0, sizeof(buffer_attr));
431 buffer_attr.tlength = (uint32_t) latency;
432 buffer_attr.minreq = (uint32_t) process_time;
433 buffer_attr.maxlength = (uint32_t) -1;
434 buffer_attr.prebuf = (uint32_t) -1;
435 buffer_attr.fragsize = (uint32_t) latency;
436 flags |= PA_STREAM_ADJUST_LATENCY;
437 }
438
439 if (mode == PLAYBACK) {
440 pa_cvolume cv;
441 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) {
442 pa_log(_("pa_stream_connect_playback() failed: %s\n"), pa_strerror(pa_context_errno(c)));
443 goto fail;
444 }
445
446 } else {
447 if ((r = pa_stream_connect_record(stream, device, latency > 0 ? &buffer_attr : NULL, flags)) < 0) {
448 pa_log(_("pa_stream_connect_record() failed: %s\n"), pa_strerror(pa_context_errno(c)));
449 goto fail;
450 }
451 }
452
453 break;
454 }
455
456 case PA_CONTEXT_TERMINATED:
457 quit(0);
458 break;
459
460 case PA_CONTEXT_FAILED:
461 default:
462 pa_log(_("Connection failure: %s\n"), pa_strerror(pa_context_errno(c)));
463 goto fail;
464 }
465
466 return;
467
468 fail:
469 quit(1);
470
471 }
472
473 /* New data on STDIN **/
474 static void stdin_callback(pa_mainloop_api*a, pa_io_event *e, int fd, pa_io_event_flags_t f, void *userdata) {
475 size_t l, w = 0;
476 ssize_t r;
477
478 pa_assert(a == mainloop_api);
479 pa_assert(e);
480 pa_assert(stdio_event == e);
481
482 if (buffer) {
483 mainloop_api->io_enable(stdio_event, PA_IO_EVENT_NULL);
484 return;
485 }
486
487 if (!stream || pa_stream_get_state(stream) != PA_STREAM_READY || !(l = w = pa_stream_writable_size(stream)))
488 l = 4096;
489
490 buffer = pa_xmalloc(l);
491
492 if ((r = read(fd, buffer, l)) <= 0) {
493 if (r == 0) {
494 if (verbose)
495 pa_log(_("Got EOF.\n"));
496
497 start_drain();
498
499 } else {
500 pa_log(_("read() failed: %s\n"), strerror(errno));
501 quit(1);
502 }
503
504 mainloop_api->io_free(stdio_event);
505 stdio_event = NULL;
506 return;
507 }
508
509 buffer_length = (uint32_t) r;
510 buffer_index = 0;
511
512 if (w)
513 do_stream_write(w);
514 }
515
516 /* Some data may be written to STDOUT */
517 static void stdout_callback(pa_mainloop_api*a, pa_io_event *e, int fd, pa_io_event_flags_t f, void *userdata) {
518 ssize_t r;
519
520 pa_assert(a == mainloop_api);
521 pa_assert(e);
522 pa_assert(stdio_event == e);
523
524 if (!buffer) {
525 mainloop_api->io_enable(stdio_event, PA_IO_EVENT_NULL);
526 return;
527 }
528
529 pa_assert(buffer_length);
530
531 if ((r = write(fd, (uint8_t*) buffer+buffer_index, buffer_length)) <= 0) {
532 pa_log(_("write() failed: %s\n"), strerror(errno));
533 quit(1);
534
535 mainloop_api->io_free(stdio_event);
536 stdio_event = NULL;
537 return;
538 }
539
540 buffer_length -= (uint32_t) r;
541 buffer_index += (uint32_t) r;
542
543 if (!buffer_length) {
544 pa_xfree(buffer);
545 buffer = NULL;
546 buffer_length = buffer_index = 0;
547 }
548 }
549
550 /* UNIX signal to quit recieved */
551 static void exit_signal_callback(pa_mainloop_api*m, pa_signal_event *e, int sig, void *userdata) {
552 if (verbose)
553 pa_log(_("Got signal, exiting.\n"));
554 quit(0);
555 }
556
557 /* Show the current latency */
558 static void stream_update_timing_callback(pa_stream *s, int success, void *userdata) {
559 pa_usec_t l, usec;
560 int negative = 0;
561
562 pa_assert(s);
563
564 if (!success ||
565 pa_stream_get_time(s, &usec) < 0 ||
566 pa_stream_get_latency(s, &l, &negative) < 0) {
567 pa_log(_("Failed to get latency: %s\n"), pa_strerror(pa_context_errno(context)));
568 quit(1);
569 return;
570 }
571
572 pa_log(_("Time: %0.3f sec; Latency: %0.0f usec. \r"),
573 (float) usec / 1000000,
574 (float) l * (negative?-1.0f:1.0f));
575 }
576
577 /* Someone requested that the latency is shown */
578 static void sigusr1_signal_callback(pa_mainloop_api*m, pa_signal_event *e, int sig, void *userdata) {
579
580 if (!stream)
581 return;
582
583 pa_operation_unref(pa_stream_update_timing_info(stream, stream_update_timing_callback, NULL));
584 }
585
586 static void time_event_callback(pa_mainloop_api*m, pa_time_event *e, const struct timeval *tv, void *userdata) {
587 struct timeval next;
588
589 if (stream && pa_stream_get_state(stream) == PA_STREAM_READY) {
590 pa_operation *o;
591 if (!(o = pa_stream_update_timing_info(stream, stream_update_timing_callback, NULL)))
592 pa_log(_("pa_stream_update_timing_info() failed: %s\n"), pa_strerror(pa_context_errno(context)));
593 else
594 pa_operation_unref(o);
595 }
596
597 pa_gettimeofday(&next);
598 pa_timeval_add(&next, TIME_EVENT_USEC);
599
600 m->time_restart(e, &next);
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'\n"), 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'\n"), 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'\n"), 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'\n"), 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'\n"), 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'\n"), 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\n"));
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\n"), strerror(errno));
908 goto quit;
909 }
910
911 if (dup2(fd, mode == PLAYBACK ? STDIN_FILENO : STDOUT_FILENO) < 0) {
912 pa_log(_("dup2(): %s\n"), strerror(errno));
913 goto quit;
914 }
915
916 pa_close(fd);
917
918 } else if (optind+1 <= argc) {
919 pa_log(_("Too many arguments.\n"));
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.\n"));
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.\n"));
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.\n"));
957
958 if (pa_sndfile_read_sample_spec(sndfile, &sample_spec) < 0) {
959 pa_log(_("Failed to determine sample specification from file.\n"));
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.\n"));
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\n"));
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.\n"));
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'.\n"),
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.\n"));
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.\n"));
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.\n"));
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\n"), pa_strerror(pa_context_errno(context)));
1067 goto quit;
1068 }
1069
1070 if (verbose) {
1071 struct timeval tv;
1072
1073 pa_gettimeofday(&tv);
1074 pa_timeval_add(&tv, TIME_EVENT_USEC);
1075
1076 if (!(time_event = mainloop_api->time_new(mainloop_api, &tv, time_event_callback, NULL))) {
1077 pa_log(_("time_new() failed.\n"));
1078 goto quit;
1079 }
1080 }
1081
1082 /* Run the main loop */
1083 if (pa_mainloop_run(m, &ret) < 0) {
1084 pa_log(_("pa_mainloop_run() failed.\n"));
1085 goto quit;
1086 }
1087
1088 quit:
1089 if (stream)
1090 pa_stream_unref(stream);
1091
1092 if (context)
1093 pa_context_unref(context);
1094
1095 if (stdio_event) {
1096 pa_assert(mainloop_api);
1097 mainloop_api->io_free(stdio_event);
1098 }
1099
1100 if (time_event) {
1101 pa_assert(mainloop_api);
1102 mainloop_api->time_free(time_event);
1103 }
1104
1105 if (m) {
1106 pa_signal_done();
1107 pa_mainloop_free(m);
1108 }
1109
1110 pa_xfree(buffer);
1111
1112 pa_xfree(server);
1113 pa_xfree(device);
1114
1115 if (sndfile)
1116 sf_close(sndfile);
1117
1118 if (proplist)
1119 pa_proplist_free(proplist);
1120
1121 return ret;
1122 }