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             pa_zero(buffer_attr);
 434             buffer_attr.maxlength = (uint32_t) -1;
 435             buffer_attr.prebuf = (uint32_t) -1;
 436
 437             if (latency > 0) {
 438                 buffer_attr.fragsize = buffer_attr.tlength = (uint32_t) latency;
 439                 buffer_attr.minreq = (uint32_t) process_time;
 440                 flags |= PA_STREAM_ADJUST_LATENCY;
 441             } else {
 442                 buffer_attr.tlength = (uint32_t) -1;
 443                 buffer_attr.minreq = (uint32_t) -1;
 444                 buffer_attr.fragsize = (uint32_t) -1;
 445             }
 446
 447             if (mode == PLAYBACK) {
 448                 pa_cvolume cv;
 449                 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) {
 450                     pa_log(_("pa_stream_connect_playback() failed: %s"), pa_strerror(pa_context_errno(c)));
 451                     goto fail;
 452                 }
 453
 454             } else {
 455                 if (pa_stream_connect_record(stream, device, latency > 0 ? &buffer_attr : NULL, flags) < 0) {
 456                     pa_log(_("pa_stream_connect_record() failed: %s"), pa_strerror(pa_context_errno(c)));
 457                     goto fail;
 458                 }
 459             }
 460
 461             break;
 462         }
 463
 464         case PA_CONTEXT_TERMINATED:
 465             quit(0);
 466             break;
 467
 468         case PA_CONTEXT_FAILED:
 469         default:
 470             pa_log(_("Connection failure: %s"), pa_strerror(pa_context_errno(c)));
 471             goto fail;
 472     }
 473
 474     return;
 475
 476 fail:
 477     quit(1);
 478
 479 }
 480
 481 /* New data on STDIN **/
 482 static void stdin_callback(pa_mainloop_api*a, pa_io_event *e, int fd, pa_io_event_flags_t f, void *userdata) {
 483     size_t l, w = 0;
 484     ssize_t r;
 485
 486     pa_assert(a == mainloop_api);
 487     pa_assert(e);
 488     pa_assert(stdio_event == e);
 489
 490     if (buffer) {
 491         mainloop_api->io_enable(stdio_event, PA_IO_EVENT_NULL);
 492         return;
 493     }
 494
 495     if (!stream || pa_stream_get_state(stream) != PA_STREAM_READY || !(l = w = pa_stream_writable_size(stream)))
 496         l = 4096;
 497
 498     buffer = pa_xmalloc(l);
 499
 500     if ((r = read(fd, buffer, l)) <= 0) {
 501         if (r == 0) {
 502             if (verbose)
 503                 pa_log(_("Got EOF."));
 504
 505             start_drain();
 506
 507         } else {
 508             pa_log(_("read() failed: %s"), strerror(errno));
 509             quit(1);
 510         }
 511
 512         mainloop_api->io_free(stdio_event);
 513         stdio_event = NULL;
 514         return;
 515     }
 516
 517     buffer_length = (uint32_t) r;
 518     buffer_index = 0;
 519
 520     if (w)
 521         do_stream_write(w);
 522 }
 523
 524 /* Some data may be written to STDOUT */
 525 static void stdout_callback(pa_mainloop_api*a, pa_io_event *e, int fd, pa_io_event_flags_t f, void *userdata) {
 526     ssize_t r;
 527
 528     pa_assert(a == mainloop_api);
 529     pa_assert(e);
 530     pa_assert(stdio_event == e);
 531
 532     if (!buffer) {
 533         mainloop_api->io_enable(stdio_event, PA_IO_EVENT_NULL);
 534         return;
 535     }
 536
 537     pa_assert(buffer_length);
 538
 539     if ((r = write(fd, (uint8_t*) buffer+buffer_index, buffer_length)) <= 0) {
 540         pa_log(_("write() failed: %s"), strerror(errno));
 541         quit(1);
 542
 543         mainloop_api->io_free(stdio_event);
 544         stdio_event = NULL;
 545         return;
 546     }
 547
 548     buffer_length -= (uint32_t) r;
 549     buffer_index += (uint32_t) r;
 550
 551     if (!buffer_length) {
 552         pa_xfree(buffer);
 553         buffer = NULL;
 554         buffer_length = buffer_index = 0;
 555     }
 556 }
 557
 558 /* UNIX signal to quit recieved */
 559 static void exit_signal_callback(pa_mainloop_api*m, pa_signal_event *e, int sig, void *userdata) {
 560     if (verbose)
 561         pa_log(_("Got signal, exiting."));
 562     quit(0);
 563 }
 564
 565 /* Show the current latency */
 566 static void stream_update_timing_callback(pa_stream *s, int success, void *userdata) {
 567     pa_usec_t l, usec;
 568     int negative = 0;
 569
 570     pa_assert(s);
 571
 572     if (!success ||
 573         pa_stream_get_time(s, &usec) < 0 ||
 574         pa_stream_get_latency(s, &l, &negative) < 0) {
 575         pa_log(_("Failed to get latency: %s"), pa_strerror(pa_context_errno(context)));
 576         quit(1);
 577         return;
 578     }
 579
 580     fprintf(stderr, _("Time: %0.3f sec; Latency: %0.0f usec."),
 581             (float) usec / 1000000,
 582             (float) l * (negative?-1.0f:1.0f));
 583     fprintf(stderr, "        \r");
 584 }
 585
 586 /* Someone requested that the latency is shown */
 587 static void sigusr1_signal_callback(pa_mainloop_api*m, pa_signal_event *e, int sig, void *userdata) {
 588
 589     if (!stream)
 590         return;
 591
 592     pa_operation_unref(pa_stream_update_timing_info(stream, stream_update_timing_callback, NULL));
 593 }
 594
 595 static void time_event_callback(pa_mainloop_api *m, pa_time_event *e, const struct timeval *t, void *userdata) {
 596     if (stream && pa_stream_get_state(stream) == PA_STREAM_READY) {
 597         pa_operation *o;
 598         if (!(o = pa_stream_update_timing_info(stream, stream_update_timing_callback, NULL)))
 599             pa_log(_("pa_stream_update_timing_info() failed: %s"), pa_strerror(pa_context_errno(context)));
 600         else
 601             pa_operation_unref(o);
 602     }
 603
 604     pa_context_rttime_restart(context, e, pa_rtclock_now() + TIME_EVENT_USEC);
 605 }
 606
 607 static void help(const char *argv0) {
 608
 609     printf(_("%s [options]\n\n"
 610              "  -h, --help                            Show this help\n"
 611              "      --version                         Show version\n\n"
 612              "  -r, --record                          Create a connection for recording\n"
 613              "  -p, --playback                        Create a connection for playback\n\n"
 614              "  -v, --verbose                         Enable verbose operations\n\n"
 615              "  -s, --server=SERVER                   The name of the server to connect to\n"
 616              "  -d, --device=DEVICE                   The name of the sink/source to connect to\n"
 617              "  -n, --client-name=NAME                How to call this client on the server\n"
 618              "      --stream-name=NAME                How to call this stream on the server\n"
 619              "      --volume=VOLUME                   Specify the initial (linear) volume in range 0...65536\n"
 620              "      --rate=SAMPLERATE                 The sample rate in Hz (defaults to 44100)\n"
 621              "      --format=SAMPLEFORMAT             The sample type, one of s16le, s16be, u8, float32le,\n"
 622              "                                        float32be, ulaw, alaw, s32le, s32be, s24le, s24be,\n"
 623              "                                        s24-32le, s24-32be (defaults to s16ne)\n"
 624              "      --channels=CHANNELS               The number of channels, 1 for mono, 2 for stereo\n"
 625              "                                        (defaults to 2)\n"
 626              "      --channel-map=CHANNELMAP          Channel map to use instead of the default\n"
 627              "      --fix-format                      Take the sample format from the sink the stream is\n"
 628              "                                        being connected to.\n"
 629              "      --fix-rate                        Take the sampling rate from the sink the stream is\n"
 630              "                                        being connected to.\n"
 631              "      --fix-channels                    Take the number of channels and the channel map\n"
 632              "                                        from the sink the stream is being connected to.\n"
 633              "      --no-remix                        Don't upmix or downmix channels.\n"
 634              "      --no-remap                        Map channels by index instead of name.\n"
 635              "      --latency=BYTES                   Request the specified latency in bytes.\n"
 636              "      --process-time=BYTES              Request the specified process time per request in bytes.\n"
 637              "      --property=PROPERTY=VALUE         Set the specified property to the specified value.\n"
 638              "      --raw                             Record/play raw PCM data.\n"
 639              "      --file-format=FFORMAT             Record/play formatted PCM data.\n"
 640              "      --list-file-formats               List available file formats.\n")
 641            , argv0);
 642 }
 643
 644 enum {
 645     ARG_VERSION = 256,
 646     ARG_STREAM_NAME,
 647     ARG_VOLUME,
 648     ARG_SAMPLERATE,
 649     ARG_SAMPLEFORMAT,
 650     ARG_CHANNELS,
 651     ARG_CHANNELMAP,
 652     ARG_FIX_FORMAT,
 653     ARG_FIX_RATE,
 654     ARG_FIX_CHANNELS,
 655     ARG_NO_REMAP,
 656     ARG_NO_REMIX,
 657     ARG_LATENCY,
 658     ARG_PROCESS_TIME,
 659     ARG_RAW,
 660     ARG_PROPERTY,
 661     ARG_FILE_FORMAT,
 662     ARG_LIST_FILE_FORMATS
 663 };
 664
 665 int main(int argc, char *argv[]) {
 666     pa_mainloop* m = NULL;
 667     int ret = 1, c;
 668     char *bn, *server = NULL;
 669     pa_time_event *time_event = NULL;
 670     const char *filename = NULL;
 671
 672     static const struct option long_options[] = {
 673         {"record",       0, NULL, 'r'},
 674         {"playback",     0, NULL, 'p'},
 675         {"device",       1, NULL, 'd'},
 676         {"server",       1, NULL, 's'},
 677         {"client-name",  1, NULL, 'n'},
 678         {"stream-name",  1, NULL, ARG_STREAM_NAME},
 679         {"version",      0, NULL, ARG_VERSION},
 680         {"help",         0, NULL, 'h'},
 681         {"verbose",      0, NULL, 'v'},
 682         {"volume",       1, NULL, ARG_VOLUME},
 683         {"rate",         1, NULL, ARG_SAMPLERATE},
 684         {"format",       1, NULL, ARG_SAMPLEFORMAT},
 685         {"channels",     1, NULL, ARG_CHANNELS},
 686         {"channel-map",  1, NULL, ARG_CHANNELMAP},
 687         {"fix-format",   0, NULL, ARG_FIX_FORMAT},
 688         {"fix-rate",     0, NULL, ARG_FIX_RATE},
 689         {"fix-channels", 0, NULL, ARG_FIX_CHANNELS},
 690         {"no-remap",     0, NULL, ARG_NO_REMAP},
 691         {"no-remix",     0, NULL, ARG_NO_REMIX},
 692         {"latency",      1, NULL, ARG_LATENCY},
 693         {"process-time", 1, NULL, ARG_PROCESS_TIME},
 694         {"property",     1, NULL, ARG_PROPERTY},
 695         {"raw",          0, NULL, ARG_RAW},
 696         {"file-format",  2, NULL, ARG_FILE_FORMAT},
 697         {"list-file-formats", 0, NULL, ARG_LIST_FILE_FORMATS},
 698         {NULL,           0, NULL, 0}
 699     };
 700
 701     setlocale(LC_ALL, "");
 702     bindtextdomain(GETTEXT_PACKAGE, PULSE_LOCALEDIR);
 703
 704     bn = pa_path_get_filename(argv[0]);
 705
 706     if (strstr(bn, "play")) {
 707         mode = PLAYBACK;
 708         raw = FALSE;
 709     } else if (strstr(bn, "record")) {
 710         mode = RECORD;
 711         raw = FALSE;
 712     } else if (strstr(bn, "cat")) {
 713         mode = PLAYBACK;
 714         raw = TRUE;
 715     } if (strstr(bn, "rec") || strstr(bn, "mon")) {
 716         mode = RECORD;
 717         raw = TRUE;
 718     }
 719
 720     proplist = pa_proplist_new();
 721
 722     while ((c = getopt_long(argc, argv, "rpd:s:n:hv", long_options, NULL)) != -1) {
 723
 724         switch (c) {
 725             case 'h' :
 726                 help(bn);
 727                 ret = 0;
 728                 goto quit;
 729
 730             case ARG_VERSION:
 731                 printf(_("pacat %s\n"
 732                          "Compiled with libpulse %s\n"
 733                          "Linked with libpulse %s\n"),
 734                        PACKAGE_VERSION,
 735                        pa_get_headers_version(),
 736                        pa_get_library_version());
 737                 ret = 0;
 738                 goto quit;
 739
 740             case 'r':
 741                 mode = RECORD;
 742                 break;
 743
 744             case 'p':
 745                 mode = PLAYBACK;
 746                 break;
 747
 748             case 'd':
 749                 pa_xfree(device);
 750                 device = pa_xstrdup(optarg);
 751                 break;
 752
 753             case 's':
 754                 pa_xfree(server);
 755                 server = pa_xstrdup(optarg);
 756                 break;
 757
 758             case 'n': {
 759                 char *t;
 760
 761                 if (!(t = pa_locale_to_utf8(optarg)) ||
 762                     pa_proplist_sets(proplist, PA_PROP_APPLICATION_NAME, t) < 0) {
 763
 764                     pa_log(_("Invalid client name '%s'"), t ? t : optarg);
 765                     pa_xfree(t);
 766                     goto quit;
 767                 }
 768
 769                 pa_xfree(t);
 770                 break;
 771             }
 772
 773             case ARG_STREAM_NAME: {
 774                 char *t;
 775
 776                 if (!(t = pa_locale_to_utf8(optarg)) ||
 777                     pa_proplist_sets(proplist, PA_PROP_MEDIA_NAME, t) < 0) {
 778
 779                     pa_log(_("Invalid stream name '%s'"), t ? t : optarg);
 780                     pa_xfree(t);
 781                     goto quit;
 782                 }
 783
 784                 pa_xfree(t);
 785                 break;
 786             }
 787
 788             case 'v':
 789                 verbose = 1;
 790                 break;
 791
 792             case ARG_VOLUME: {
 793                 int v = atoi(optarg);
 794                 volume = v < 0 ? 0U : (pa_volume_t) v;
 795                 volume_is_set = TRUE;
 796                 break;
 797             }
 798
 799             case ARG_CHANNELS:
 800                 sample_spec.channels = (uint8_t) atoi(optarg);
 801                 sample_spec_set = TRUE;
 802                 break;
 803
 804             case ARG_SAMPLEFORMAT:
 805                 sample_spec.format = pa_parse_sample_format(optarg);
 806                 sample_spec_set = TRUE;
 807                 break;
 808
 809             case ARG_SAMPLERATE:
 810                 sample_spec.rate = (uint32_t) atoi(optarg);
 811                 sample_spec_set = TRUE;
 812                 break;
 813
 814             case ARG_CHANNELMAP:
 815                 if (!pa_channel_map_parse(&channel_map, optarg)) {
 816                     pa_log(_("Invalid channel map '%s'"), optarg);
 817                     goto quit;
 818                 }
 819
 820                 channel_map_set = TRUE;
 821                 break;
 822
 823             case ARG_FIX_CHANNELS:
 824                 flags |= PA_STREAM_FIX_CHANNELS;
 825                 break;
 826
 827             case ARG_FIX_RATE:
 828                 flags |= PA_STREAM_FIX_RATE;
 829                 break;
 830
 831             case ARG_FIX_FORMAT:
 832                 flags |= PA_STREAM_FIX_FORMAT;
 833                 break;
 834
 835             case ARG_NO_REMIX:
 836                 flags |= PA_STREAM_NO_REMIX_CHANNELS;
 837                 break;
 838
 839             case ARG_NO_REMAP:
 840                 flags |= PA_STREAM_NO_REMAP_CHANNELS;
 841                 break;
 842
 843             case ARG_LATENCY:
 844                 if (((latency = (size_t) atoi(optarg))) <= 0) {
 845                     pa_log(_("Invalid latency specification '%s'"), optarg);
 846                     goto quit;
 847                 }
 848                 break;
 849
 850             case ARG_PROCESS_TIME:
 851                 if (((process_time = (size_t) atoi(optarg))) <= 0) {
 852                     pa_log(_("Invalid process time specification '%s'"), optarg);
 853                     goto quit;
 854                 }
 855                 break;
 856
 857             case ARG_PROPERTY: {
 858                 char *t;
 859
 860                 if (!(t = pa_locale_to_utf8(optarg)) ||
 861                     pa_proplist_setp(proplist, t) < 0) {
 862
 863                     pa_xfree(t);
 864                     pa_log(_("Invalid property '%s'"), optarg);
 865                     goto quit;
 866                 }
 867
 868                 pa_xfree(t);
 869                 break;
 870             }
 871
 872             case ARG_RAW:
 873                 raw = TRUE;
 874                 break;
 875
 876             case ARG_FILE_FORMAT:
 877                 raw = FALSE;
 878
 879                 if (optarg) {
 880                     if ((file_format = pa_sndfile_format_from_string(optarg)) < 0) {
 881                         pa_log(_("Unknown file format %s."), optarg);
 882                         goto quit;
 883                     }
 884                 }
 885
 886                 raw = FALSE;
 887                 break;
 888
 889             case ARG_LIST_FILE_FORMATS:
 890                 pa_sndfile_dump_formats();
 891                 ret = 0;
 892                 goto quit;
 893
 894             default:
 895                 goto quit;
 896         }
 897     }
 898
 899     if (!pa_sample_spec_valid(&sample_spec)) {
 900         pa_log(_("Invalid sample specification"));
 901         goto quit;
 902     }
 903
 904     if (optind+1 == argc) {
 905         int fd;
 906
 907         filename = argv[optind];
 908
 909         if ((fd = open(argv[optind], mode == PLAYBACK ? O_RDONLY : O_WRONLY|O_TRUNC|O_CREAT, 0666)) < 0) {
 910             pa_log(_("open(): %s"), strerror(errno));
 911             goto quit;
 912         }
 913
 914         if (dup2(fd, mode == PLAYBACK ? STDIN_FILENO : STDOUT_FILENO) < 0) {
 915             pa_log(_("dup2(): %s"), strerror(errno));
 916             goto quit;
 917         }
 918
 919         pa_close(fd);
 920
 921     } else if (optind+1 <= argc) {
 922         pa_log(_("Too many arguments."));
 923         goto quit;
 924     }
 925
 926     if (!raw) {
 927         SF_INFO sfi;
 928         pa_zero(sfi);
 929
 930         if (mode == RECORD) {
 931             /* This might patch up the sample spec */
 932             if (pa_sndfile_write_sample_spec(&sfi, &sample_spec) < 0) {
 933                 pa_log(_("Failed to generate sample specification for file."));
 934                 goto quit;
 935             }
 936
 937             /* Transparently upgrade classic .wav to wavex for multichannel audio */
 938             if (file_format <= 0) {
 939                 if ((sample_spec.channels == 2 && (!channel_map_set || (channel_map.map[0] == PA_CHANNEL_POSITION_LEFT &&
 940                                                                         channel_map.map[1] == PA_CHANNEL_POSITION_RIGHT))) ||
 941                     (sample_spec.channels == 1 && (!channel_map_set || (channel_map.map[0] == PA_CHANNEL_POSITION_MONO))))
 942                     file_format = SF_FORMAT_WAV;
 943                 else
 944                     file_format = SF_FORMAT_WAVEX;
 945             }
 946
 947             sfi.format |= file_format;
 948         }
 949
 950         if (!(sndfile = sf_open_fd(mode == RECORD ? STDOUT_FILENO : STDIN_FILENO,
 951                                    mode == RECORD ? SFM_WRITE : SFM_READ,
 952                                    &sfi, 0))) {
 953             pa_log(_("Failed to open audio file."));
 954             goto quit;
 955         }
 956
 957         if (mode == PLAYBACK) {
 958             if (sample_spec_set)
 959                 pa_log(_("Warning: specified sample specification will be overwritten with specification from file."));
 960
 961             if (pa_sndfile_read_sample_spec(sndfile, &sample_spec) < 0) {
 962                 pa_log(_("Failed to determine sample specification from file."));
 963                 goto quit;
 964             }
 965             sample_spec_set = TRUE;
 966
 967             if (!channel_map_set) {
 968                 /* Allow the user to overwrite the channel map on the command line */
 969                 if (pa_sndfile_read_channel_map(sndfile, &channel_map) < 0) {
 970                     if (sample_spec.channels > 2)
 971                         pa_log(_("Warning: Failed to determine channel map from file."));
 972                 } else
 973                     channel_map_set = TRUE;
 974             }
 975         }
 976     }
 977
 978     if (!channel_map_set)
 979         pa_channel_map_init_extend(&channel_map, sample_spec.channels, PA_CHANNEL_MAP_DEFAULT);
 980
 981     if (!pa_channel_map_compatible(&channel_map, &sample_spec)) {
 982         pa_log(_("Channel map doesn't match sample specification"));
 983         goto quit;
 984     }
 985
 986     if (!raw) {
 987         pa_proplist *sfp;
 988
 989         if (mode == PLAYBACK)
 990             readf_function = pa_sndfile_readf_function(&sample_spec);
 991         else {
 992             if (pa_sndfile_write_channel_map(sndfile, &channel_map) < 0)
 993                 pa_log(_("Warning: failed to write channel map to file."));
 994
 995             writef_function = pa_sndfile_writef_function(&sample_spec);
 996         }
 997
 998         /* Fill in libsndfile prop list data */
 999         sfp = pa_proplist_new();
1000         pa_sndfile_init_proplist(sndfile, sfp);
1001         pa_proplist_update(proplist, PA_UPDATE_MERGE, sfp);
1002         pa_proplist_free(sfp);
1003     }
1004
1005     if (verbose) {
1006         char tss[PA_SAMPLE_SPEC_SNPRINT_MAX], tcm[PA_CHANNEL_MAP_SNPRINT_MAX];
1007
1008         pa_log(_("Opening a %s stream with sample specification '%s' and channel map '%s'."),
1009                 mode == RECORD ? _("recording") : _("playback"),
1010                 pa_sample_spec_snprint(tss, sizeof(tss), &sample_spec),
1011                 pa_channel_map_snprint(tcm, sizeof(tcm), &channel_map));
1012     }
1013
1014     /* Fill in client name if none was set */
1015     if (!pa_proplist_contains(proplist, PA_PROP_APPLICATION_NAME)) {
1016         char *t;
1017
1018         if ((t = pa_locale_to_utf8(bn))) {
1019             pa_proplist_sets(proplist, PA_PROP_APPLICATION_NAME, t);
1020             pa_xfree(t);
1021         }
1022     }
1023
1024     /* Fill in media name if none was set */
1025     if (!pa_proplist_contains(proplist, PA_PROP_MEDIA_NAME)) {
1026         const char *t;
1027
1028         if ((t = filename) ||
1029             (t = pa_proplist_gets(proplist, PA_PROP_APPLICATION_NAME)))
1030             pa_proplist_sets(proplist, PA_PROP_MEDIA_NAME, t);
1031     }
1032
1033     /* Set up a new main loop */
1034     if (!(m = pa_mainloop_new())) {
1035         pa_log(_("pa_mainloop_new() failed."));
1036         goto quit;
1037     }
1038
1039     mainloop_api = pa_mainloop_get_api(m);
1040
1041     pa_assert_se(pa_signal_init(mainloop_api) == 0);
1042     pa_signal_new(SIGINT, exit_signal_callback, NULL);
1043     pa_signal_new(SIGTERM, exit_signal_callback, NULL);
1044 #ifdef SIGUSR1
1045     pa_signal_new(SIGUSR1, sigusr1_signal_callback, NULL);
1046 #endif
1047     pa_disable_sigpipe();
1048
1049     if (raw) {
1050         if (!(stdio_event = mainloop_api->io_new(mainloop_api,
1051                                                  mode == PLAYBACK ? STDIN_FILENO : STDOUT_FILENO,
1052                                                  mode == PLAYBACK ? PA_IO_EVENT_INPUT : PA_IO_EVENT_OUTPUT,
1053                                                  mode == PLAYBACK ? stdin_callback : stdout_callback, NULL))) {
1054             pa_log(_("io_new() failed."));
1055             goto quit;
1056         }
1057     }
1058
1059     /* Create a new connection context */
1060     if (!(context = pa_context_new_with_proplist(mainloop_api, NULL, proplist))) {
1061         pa_log(_("pa_context_new() failed."));
1062         goto quit;
1063     }
1064
1065     pa_context_set_state_callback(context, context_state_callback, NULL);
1066
1067     /* Connect the context */
1068     if (pa_context_connect(context, server, 0, NULL) < 0) {
1069         pa_log(_("pa_context_connect() failed: %s"), pa_strerror(pa_context_errno(context)));
1070         goto quit;
1071     }
1072
1073     if (verbose) {
1074         if (!(time_event = pa_context_rttime_new(context, pa_rtclock_now() + TIME_EVENT_USEC, time_event_callback, NULL))) {
1075             pa_log(_("pa_context_rttime_new() failed."));
1076             goto quit;
1077         }
1078     }
1079
1080     /* Run the main loop */
1081     if (pa_mainloop_run(m, &ret) < 0) {
1082         pa_log(_("pa_mainloop_run() failed."));
1083         goto quit;
1084     }
1085
1086 quit:
1087     if (stream)
1088         pa_stream_unref(stream);
1089
1090     if (context)
1091         pa_context_unref(context);
1092
1093     if (stdio_event) {
1094         pa_assert(mainloop_api);
1095         mainloop_api->io_free(stdio_event);
1096     }
1097
1098     if (time_event) {
1099         pa_assert(mainloop_api);
1100         mainloop_api->time_free(time_event);
1101     }
1102
1103     if (m) {
1104         pa_signal_done();
1105         pa_mainloop_free(m);
1106     }
1107
1108     pa_xfree(buffer);
1109
1110     pa_xfree(server);
1111     pa_xfree(device);
1112
1113     if (sndfile)
1114         sf_close(sndfile);
1115
1116     if (proplist)
1117         pa_proplist_free(proplist);
1118
1119     return ret;
1120 }