]> 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' of git://0pointer.de/pulseaudio
[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 pa_buffer_attr buffer_attr;
410
411 pa_assert(c);
412 pa_assert(!stream);
413
414 if (verbose)
415 pa_log(_("Connection established.%s"), CLEAR_LINE);
416
417 if (!(stream = pa_stream_new_with_proplist(c, NULL, &sample_spec, &channel_map, proplist))) {
418 pa_log(_("pa_stream_new() failed: %s"), pa_strerror(pa_context_errno(c)));
419 goto fail;
420 }
421
422 pa_stream_set_state_callback(stream, stream_state_callback, NULL);
423 pa_stream_set_write_callback(stream, stream_write_callback, NULL);
424 pa_stream_set_read_callback(stream, stream_read_callback, NULL);
425 pa_stream_set_suspended_callback(stream, stream_suspended_callback, NULL);
426 pa_stream_set_moved_callback(stream, stream_moved_callback, NULL);
427 pa_stream_set_underflow_callback(stream, stream_underflow_callback, NULL);
428 pa_stream_set_overflow_callback(stream, stream_overflow_callback, NULL);
429 pa_stream_set_started_callback(stream, stream_started_callback, NULL);
430 pa_stream_set_event_callback(stream, stream_event_callback, NULL);
431 pa_stream_set_buffer_attr_callback(stream, stream_buffer_attr_callback, NULL);
432
433 if (latency > 0) {
434 memset(&buffer_attr, 0, sizeof(buffer_attr));
435 buffer_attr.tlength = (uint32_t) latency;
436 buffer_attr.minreq = (uint32_t) process_time;
437 buffer_attr.maxlength = (uint32_t) -1;
438 buffer_attr.prebuf = (uint32_t) -1;
439 buffer_attr.fragsize = (uint32_t) latency;
440 flags |= PA_STREAM_ADJUST_LATENCY;
441 }
442
443 if (mode == PLAYBACK) {
444 pa_cvolume cv;
445 if (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) {
446 pa_log(_("pa_stream_connect_playback() failed: %s"), pa_strerror(pa_context_errno(c)));
447 goto fail;
448 }
449
450 } else {
451 if (pa_stream_connect_record(stream, device, latency > 0 ? &buffer_attr : NULL, flags) < 0) {
452 pa_log(_("pa_stream_connect_record() failed: %s"), pa_strerror(pa_context_errno(c)));
453 goto fail;
454 }
455 }
456
457 break;
458 }
459
460 case PA_CONTEXT_TERMINATED:
461 quit(0);
462 break;
463
464 case PA_CONTEXT_FAILED:
465 default:
466 pa_log(_("Connection failure: %s"), pa_strerror(pa_context_errno(c)));
467 goto fail;
468 }
469
470 return;
471
472 fail:
473 quit(1);
474
475 }
476
477 /* New data on STDIN **/
478 static void stdin_callback(pa_mainloop_api*a, pa_io_event *e, int fd, pa_io_event_flags_t f, void *userdata) {
479 size_t l, w = 0;
480 ssize_t r;
481
482 pa_assert(a == mainloop_api);
483 pa_assert(e);
484 pa_assert(stdio_event == e);
485
486 if (buffer) {
487 mainloop_api->io_enable(stdio_event, PA_IO_EVENT_NULL);
488 return;
489 }
490
491 if (!stream || pa_stream_get_state(stream) != PA_STREAM_READY || !(l = w = pa_stream_writable_size(stream)))
492 l = 4096;
493
494 buffer = pa_xmalloc(l);
495
496 if ((r = read(fd, buffer, l)) <= 0) {
497 if (r == 0) {
498 if (verbose)
499 pa_log(_("Got EOF."));
500
501 start_drain();
502
503 } else {
504 pa_log(_("read() failed: %s"), strerror(errno));
505 quit(1);
506 }
507
508 mainloop_api->io_free(stdio_event);
509 stdio_event = NULL;
510 return;
511 }
512
513 buffer_length = (uint32_t) r;
514 buffer_index = 0;
515
516 if (w)
517 do_stream_write(w);
518 }
519
520 /* Some data may be written to STDOUT */
521 static void stdout_callback(pa_mainloop_api*a, pa_io_event *e, int fd, pa_io_event_flags_t f, void *userdata) {
522 ssize_t r;
523
524 pa_assert(a == mainloop_api);
525 pa_assert(e);
526 pa_assert(stdio_event == e);
527
528 if (!buffer) {
529 mainloop_api->io_enable(stdio_event, PA_IO_EVENT_NULL);
530 return;
531 }
532
533 pa_assert(buffer_length);
534
535 if ((r = write(fd, (uint8_t*) buffer+buffer_index, buffer_length)) <= 0) {
536 pa_log(_("write() failed: %s"), strerror(errno));
537 quit(1);
538
539 mainloop_api->io_free(stdio_event);
540 stdio_event = NULL;
541 return;
542 }
543
544 buffer_length -= (uint32_t) r;
545 buffer_index += (uint32_t) r;
546
547 if (!buffer_length) {
548 pa_xfree(buffer);
549 buffer = NULL;
550 buffer_length = buffer_index = 0;
551 }
552 }
553
554 /* UNIX signal to quit recieved */
555 static void exit_signal_callback(pa_mainloop_api*m, pa_signal_event *e, int sig, void *userdata) {
556 if (verbose)
557 pa_log(_("Got signal, exiting."));
558 quit(0);
559 }
560
561 /* Show the current latency */
562 static void stream_update_timing_callback(pa_stream *s, int success, void *userdata) {
563 pa_usec_t l, usec;
564 int negative = 0;
565
566 pa_assert(s);
567
568 if (!success ||
569 pa_stream_get_time(s, &usec) < 0 ||
570 pa_stream_get_latency(s, &l, &negative) < 0) {
571 pa_log(_("Failed to get latency: %s"), pa_strerror(pa_context_errno(context)));
572 quit(1);
573 return;
574 }
575
576 fprintf(stderr, _("Time: %0.3f sec; Latency: %0.0f usec."),
577 (float) usec / 1000000,
578 (float) l * (negative?-1.0f:1.0f));
579 fprintf(stderr, " \r");
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
772 if (!(t = pa_locale_to_utf8(optarg)) ||
773 pa_proplist_sets(proplist, PA_PROP_MEDIA_NAME, t) < 0) {
774
775 pa_log(_("Invalid stream name '%s'"), t ? t : optarg);
776 pa_xfree(t);
777 goto quit;
778 }
779
780 pa_xfree(t);
781 break;
782 }
783
784 case 'v':
785 verbose = 1;
786 break;
787
788 case ARG_VOLUME: {
789 int v = atoi(optarg);
790 volume = v < 0 ? 0U : (pa_volume_t) v;
791 volume_is_set = TRUE;
792 break;
793 }
794
795 case ARG_CHANNELS:
796 sample_spec.channels = (uint8_t) atoi(optarg);
797 sample_spec_set = TRUE;
798 break;
799
800 case ARG_SAMPLEFORMAT:
801 sample_spec.format = pa_parse_sample_format(optarg);
802 sample_spec_set = TRUE;
803 break;
804
805 case ARG_SAMPLERATE:
806 sample_spec.rate = (uint32_t) atoi(optarg);
807 sample_spec_set = TRUE;
808 break;
809
810 case ARG_CHANNELMAP:
811 if (!pa_channel_map_parse(&channel_map, optarg)) {
812 pa_log(_("Invalid channel map '%s'"), optarg);
813 goto quit;
814 }
815
816 channel_map_set = TRUE;
817 break;
818
819 case ARG_FIX_CHANNELS:
820 flags |= PA_STREAM_FIX_CHANNELS;
821 break;
822
823 case ARG_FIX_RATE:
824 flags |= PA_STREAM_FIX_RATE;
825 break;
826
827 case ARG_FIX_FORMAT:
828 flags |= PA_STREAM_FIX_FORMAT;
829 break;
830
831 case ARG_NO_REMIX:
832 flags |= PA_STREAM_NO_REMIX_CHANNELS;
833 break;
834
835 case ARG_NO_REMAP:
836 flags |= PA_STREAM_NO_REMAP_CHANNELS;
837 break;
838
839 case ARG_LATENCY:
840 if (((latency = (size_t) atoi(optarg))) <= 0) {
841 pa_log(_("Invalid latency specification '%s'"), optarg);
842 goto quit;
843 }
844 break;
845
846 case ARG_PROCESS_TIME:
847 if (((process_time = (size_t) atoi(optarg))) <= 0) {
848 pa_log(_("Invalid process time specification '%s'"), optarg);
849 goto quit;
850 }
851 break;
852
853 case ARG_PROPERTY: {
854 char *t;
855
856 if (!(t = pa_locale_to_utf8(optarg)) ||
857 pa_proplist_setp(proplist, t) < 0) {
858
859 pa_xfree(t);
860 pa_log(_("Invalid property '%s'"), optarg);
861 goto quit;
862 }
863
864 pa_xfree(t);
865 break;
866 }
867
868 case ARG_RAW:
869 raw = TRUE;
870 break;
871
872 case ARG_FILE_FORMAT:
873 raw = FALSE;
874
875 if (optarg) {
876 if ((file_format = pa_sndfile_format_from_string(optarg)) < 0) {
877 pa_log(_("Unknown file format %s."), optarg);
878 goto quit;
879 }
880 }
881
882 raw = FALSE;
883 break;
884
885 case ARG_LIST_FILE_FORMATS:
886 pa_sndfile_dump_formats();
887 ret = 0;
888 goto quit;
889
890 default:
891 goto quit;
892 }
893 }
894
895 if (!pa_sample_spec_valid(&sample_spec)) {
896 pa_log(_("Invalid sample specification"));
897 goto quit;
898 }
899
900 if (optind+1 == argc) {
901 int fd;
902
903 filename = argv[optind];
904
905 if ((fd = open(argv[optind], mode == PLAYBACK ? O_RDONLY : O_WRONLY|O_TRUNC|O_CREAT, 0666)) < 0) {
906 pa_log(_("open(): %s"), strerror(errno));
907 goto quit;
908 }
909
910 if (dup2(fd, mode == PLAYBACK ? STDIN_FILENO : STDOUT_FILENO) < 0) {
911 pa_log(_("dup2(): %s"), strerror(errno));
912 goto quit;
913 }
914
915 pa_close(fd);
916
917 } else if (optind+1 <= argc) {
918 pa_log(_("Too many arguments."));
919 goto quit;
920 }
921
922 if (!raw) {
923 SF_INFO sfi;
924 pa_zero(sfi);
925
926 if (mode == RECORD) {
927 /* This might patch up the sample spec */
928 if (pa_sndfile_write_sample_spec(&sfi, &sample_spec) < 0) {
929 pa_log(_("Failed to generate sample specification for file."));
930 goto quit;
931 }
932
933 /* Transparently upgrade classic .wav to wavex for multichannel audio */
934 if (file_format <= 0) {
935 if ((sample_spec.channels == 2 && (!channel_map_set || (channel_map.map[0] == PA_CHANNEL_POSITION_LEFT &&
936 channel_map.map[1] == PA_CHANNEL_POSITION_RIGHT))) ||
937 (sample_spec.channels == 1 && (!channel_map_set || (channel_map.map[0] == PA_CHANNEL_POSITION_MONO))))
938 file_format = SF_FORMAT_WAV;
939 else
940 file_format = SF_FORMAT_WAVEX;
941 }
942
943 sfi.format |= file_format;
944 }
945
946 if (!(sndfile = sf_open_fd(mode == RECORD ? STDOUT_FILENO : STDIN_FILENO,
947 mode == RECORD ? SFM_WRITE : SFM_READ,
948 &sfi, 0))) {
949 pa_log(_("Failed to open audio file."));
950 goto quit;
951 }
952
953 if (mode == PLAYBACK) {
954 if (sample_spec_set)
955 pa_log(_("Warning: specified sample specification will be overwritten with specification from file."));
956
957 if (pa_sndfile_read_sample_spec(sndfile, &sample_spec) < 0) {
958 pa_log(_("Failed to determine sample specification from file."));
959 goto quit;
960 }
961 sample_spec_set = TRUE;
962
963 if (!channel_map_set) {
964 /* Allow the user to overwrite the channel map on the command line */
965 if (pa_sndfile_read_channel_map(sndfile, &channel_map) < 0) {
966 if (sample_spec.channels > 2)
967 pa_log(_("Warning: Failed to determine channel map from file."));
968 } else
969 channel_map_set = TRUE;
970 }
971 }
972 }
973
974 if (!channel_map_set)
975 pa_channel_map_init_extend(&channel_map, sample_spec.channels, PA_CHANNEL_MAP_DEFAULT);
976
977 if (!pa_channel_map_compatible(&channel_map, &sample_spec)) {
978 pa_log(_("Channel map doesn't match sample specification"));
979 goto quit;
980 }
981
982 if (!raw) {
983 pa_proplist *sfp;
984
985 if (mode == PLAYBACK)
986 readf_function = pa_sndfile_readf_function(&sample_spec);
987 else {
988 if (pa_sndfile_write_channel_map(sndfile, &channel_map) < 0)
989 pa_log(_("Warning: failed to write channel map to file."));
990
991 writef_function = pa_sndfile_writef_function(&sample_spec);
992 }
993
994 /* Fill in libsndfile prop list data */
995 sfp = pa_proplist_new();
996 pa_sndfile_init_proplist(sndfile, sfp);
997 pa_proplist_update(proplist, PA_UPDATE_MERGE, sfp);
998 pa_proplist_free(sfp);
999 }
1000
1001 if (verbose) {
1002 char tss[PA_SAMPLE_SPEC_SNPRINT_MAX], tcm[PA_CHANNEL_MAP_SNPRINT_MAX];
1003
1004 pa_log(_("Opening a %s stream with sample specification '%s' and channel map '%s'."),
1005 mode == RECORD ? _("recording") : _("playback"),
1006 pa_sample_spec_snprint(tss, sizeof(tss), &sample_spec),
1007 pa_channel_map_snprint(tcm, sizeof(tcm), &channel_map));
1008 }
1009
1010 /* Fill in client name if none was set */
1011 if (!pa_proplist_contains(proplist, PA_PROP_APPLICATION_NAME)) {
1012 char *t;
1013
1014 if ((t = pa_locale_to_utf8(bn))) {
1015 pa_proplist_sets(proplist, PA_PROP_APPLICATION_NAME, t);
1016 pa_xfree(t);
1017 }
1018 }
1019
1020 /* Fill in media name if none was set */
1021 if (!pa_proplist_contains(proplist, PA_PROP_MEDIA_NAME)) {
1022 const char *t;
1023
1024 if ((t = filename) ||
1025 (t = pa_proplist_gets(proplist, PA_PROP_APPLICATION_NAME)))
1026 pa_proplist_sets(proplist, PA_PROP_MEDIA_NAME, t);
1027 }
1028
1029 /* Set up a new main loop */
1030 if (!(m = pa_mainloop_new())) {
1031 pa_log(_("pa_mainloop_new() failed."));
1032 goto quit;
1033 }
1034
1035 mainloop_api = pa_mainloop_get_api(m);
1036
1037 pa_assert_se(pa_signal_init(mainloop_api) == 0);
1038 pa_signal_new(SIGINT, exit_signal_callback, NULL);
1039 pa_signal_new(SIGTERM, exit_signal_callback, NULL);
1040 #ifdef SIGUSR1
1041 pa_signal_new(SIGUSR1, sigusr1_signal_callback, NULL);
1042 #endif
1043 pa_disable_sigpipe();
1044
1045 if (raw) {
1046 if (!(stdio_event = mainloop_api->io_new(mainloop_api,
1047 mode == PLAYBACK ? STDIN_FILENO : STDOUT_FILENO,
1048 mode == PLAYBACK ? PA_IO_EVENT_INPUT : PA_IO_EVENT_OUTPUT,
1049 mode == PLAYBACK ? stdin_callback : stdout_callback, NULL))) {
1050 pa_log(_("io_new() failed."));
1051 goto quit;
1052 }
1053 }
1054
1055 /* Create a new connection context */
1056 if (!(context = pa_context_new_with_proplist(mainloop_api, NULL, proplist))) {
1057 pa_log(_("pa_context_new() failed."));
1058 goto quit;
1059 }
1060
1061 pa_context_set_state_callback(context, context_state_callback, NULL);
1062
1063 /* Connect the context */
1064 if (pa_context_connect(context, server, 0, NULL) < 0) {
1065 pa_log(_("pa_context_connect() failed: %s"), pa_strerror(pa_context_errno(context)));
1066 goto quit;
1067 }
1068
1069 if (verbose) {
1070 if (!(time_event = pa_context_rttime_new(context, pa_rtclock_now() + TIME_EVENT_USEC, time_event_callback, NULL))) {
1071 pa_log(_("pa_context_rttime_new() failed."));
1072 goto quit;
1073 }
1074 }
1075
1076 /* Run the main loop */
1077 if (pa_mainloop_run(m, &ret) < 0) {
1078 pa_log(_("pa_mainloop_run() failed."));
1079 goto quit;
1080 }
1081
1082 quit:
1083 if (stream)
1084 pa_stream_unref(stream);
1085
1086 if (context)
1087 pa_context_unref(context);
1088
1089 if (stdio_event) {
1090 pa_assert(mainloop_api);
1091 mainloop_api->io_free(stdio_event);
1092 }
1093
1094 if (time_event) {
1095 pa_assert(mainloop_api);
1096 mainloop_api->time_free(time_event);
1097 }
1098
1099 if (m) {
1100 pa_signal_done();
1101 pa_mainloop_free(m);
1102 }
1103
1104 pa_xfree(buffer);
1105
1106 pa_xfree(server);
1107 pa_xfree(device);
1108
1109 if (sndfile)
1110 sf_close(sndfile);
1111
1112 if (proplist)
1113 pa_proplist_free(proplist);
1114
1115 return ret;
1116 }