src/utils/pactl.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2004-2006 Lennart Poettering
   5
   6   PulseAudio is free software; you can redistribute it and/or modify
   7   it under the terms of the GNU Lesser General Public License as published
   8   by the Free Software Foundation; either version 2.1 of the License,
   9   or (at your option) any later version.
  10
  11   PulseAudio is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with PulseAudio; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <signal.h>
  27 #include <string.h>
  28 #include <errno.h>
  29 #include <unistd.h>
  30 #include <assert.h>
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <limits.h>
  34 #include <getopt.h>
  35 #include <locale.h>
  36
  37 #include <sndfile.h>
  38
  39 #include <pulse/i18n.h>
  40 #include <pulse/pulseaudio.h>
  41
  42 #include <pulsecore/macro.h>
  43 #include <pulsecore/core-util.h>
  44 #include <pulsecore/log.h>
  45 #include <pulsecore/sndfile-util.h>
  46
  47 #define BUFSIZE (16*1024)
  48
  49 static pa_context *context = NULL;
  50 static pa_mainloop_api *mainloop_api = NULL;
  51
  52 static char
  53     *sample_name = NULL,
  54     *sink_name = NULL,
  55     *source_name = NULL,
  56     *module_name = NULL,
  57     *module_args = NULL,
  58     *card_name = NULL,
  59     *profile_name = NULL,
  60     *port_name = NULL;
  61
  62 static uint32_t
  63     sink_input_idx = PA_INVALID_INDEX,
  64     source_output_idx = PA_INVALID_INDEX;
  65
  66 static uint32_t module_index;
  67 static pa_bool_t suspend;
  68 static pa_bool_t mute;
  69 static pa_volume_t volume;
  70
  71 static pa_proplist *proplist = NULL;
  72
  73 static SNDFILE *sndfile = NULL;
  74 static pa_stream *sample_stream = NULL;
  75 static pa_sample_spec sample_spec;
  76 static pa_channel_map channel_map;
  77 static size_t sample_length = 0;
  78 static int actions = 1;
  79
  80 static pa_bool_t nl = FALSE;
  81
  82 static enum {
  83     NONE,
  84     EXIT,
  85     STAT,
  86     UPLOAD_SAMPLE,
  87     PLAY_SAMPLE,
  88     REMOVE_SAMPLE,
  89     LIST,
  90     MOVE_SINK_INPUT,
  91     MOVE_SOURCE_OUTPUT,
  92     LOAD_MODULE,
  93     UNLOAD_MODULE,
  94     SUSPEND_SINK,
  95     SUSPEND_SOURCE,
  96     SET_CARD_PROFILE,
  97     SET_SINK_PORT,
  98     SET_SOURCE_PORT,
  99     SET_SINK_VOLUME,
 100     SET_SOURCE_VOLUME,
 101     SET_SINK_INPUT_VOLUME,
 102     SET_SINK_MUTE,
 103     SET_SOURCE_MUTE,
 104     SET_SINK_INPUT_MUTE
 105 } action = NONE;
 106
 107 static void quit(int ret) {
 108     pa_assert(mainloop_api);
 109     mainloop_api->quit(mainloop_api, ret);
 110 }
 111
 112 static void context_drain_complete(pa_context *c, void *userdata) {
 113     pa_context_disconnect(c);
 114 }
 115
 116 static void drain(void) {
 117     pa_operation *o;
 118
 119     if (!(o = pa_context_drain(context, context_drain_complete, NULL)))
 120         pa_context_disconnect(context);
 121     else
 122         pa_operation_unref(o);
 123 }
 124
 125 static void complete_action(void) {
 126     pa_assert(actions > 0);
 127
 128     if (!(--actions))
 129         drain();
 130 }
 131
 132 static void stat_callback(pa_context *c, const pa_stat_info *i, void *userdata) {
 133     char s[PA_BYTES_SNPRINT_MAX];
 134     if (!i) {
 135         pa_log(_("Failed to get statistics: %s"), pa_strerror(pa_context_errno(c)));
 136         quit(1);
 137         return;
 138     }
 139
 140     pa_bytes_snprint(s, sizeof(s), i->memblock_total_size);
 141     printf(_("Currently in use: %u blocks containing %s bytes total.\n"), i->memblock_total, s);
 142
 143     pa_bytes_snprint(s, sizeof(s), i->memblock_allocated_size);
 144     printf(_("Allocated during whole lifetime: %u blocks containing %s bytes total.\n"), i->memblock_allocated, s);
 145
 146     pa_bytes_snprint(s, sizeof(s), i->scache_size);
 147     printf(_("Sample cache size: %s\n"), s);
 148
 149     complete_action();
 150 }
 151
 152 static void get_server_info_callback(pa_context *c, const pa_server_info *i, void *useerdata) {
 153     char ss[PA_SAMPLE_SPEC_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
 154
 155     if (!i) {
 156         pa_log(_("Failed to get server information: %s"), pa_strerror(pa_context_errno(c)));
 157         quit(1);
 158         return;
 159     }
 160
 161     pa_sample_spec_snprint(ss, sizeof(ss), &i->sample_spec);
 162     pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map);
 163
 164     printf(_("User name: %s\n"
 165              "Host Name: %s\n"
 166              "Server Name: %s\n"
 167              "Server Version: %s\n"
 168              "Default Sample Specification: %s\n"
 169              "Default Channel Map: %s\n"
 170              "Default Sink: %s\n"
 171              "Default Source: %s\n"
 172              "Cookie: %08x\n"),
 173            i->user_name,
 174            i->host_name,
 175            i->server_name,
 176            i->server_version,
 177            ss,
 178            cm,
 179            i->default_sink_name,
 180            i->default_source_name,
 181            i->cookie);
 182
 183     complete_action();
 184 }
 185
 186 static void get_sink_info_callback(pa_context *c, const pa_sink_info *i, int is_last, void *userdata) {
 187
 188     static const char *state_table[] = {
 189         [1+PA_SINK_INVALID_STATE] = "n/a",
 190         [1+PA_SINK_RUNNING] = "RUNNING",
 191         [1+PA_SINK_IDLE] = "IDLE",
 192         [1+PA_SINK_SUSPENDED] = "SUSPENDED"
 193     };
 194
 195     char
 196         s[PA_SAMPLE_SPEC_SNPRINT_MAX],
 197         cv[PA_CVOLUME_SNPRINT_MAX],
 198         cvdb[PA_SW_CVOLUME_SNPRINT_DB_MAX],
 199         v[PA_VOLUME_SNPRINT_MAX],
 200         vdb[PA_SW_VOLUME_SNPRINT_DB_MAX],
 201         cm[PA_CHANNEL_MAP_SNPRINT_MAX];
 202     char *pl;
 203
 204     if (is_last < 0) {
 205         pa_log(_("Failed to get sink information: %s"), pa_strerror(pa_context_errno(c)));
 206         quit(1);
 207         return;
 208     }
 209
 210     if (is_last) {
 211         complete_action();
 212         return;
 213     }
 214
 215     pa_assert(i);
 216
 217     if (nl)
 218         printf("\n");
 219     nl = TRUE;
 220
 221     printf(_("Sink #%u\n"
 222              "\tState: %s\n"
 223              "\tName: %s\n"
 224              "\tDescription: %s\n"
 225              "\tDriver: %s\n"
 226              "\tSample Specification: %s\n"
 227              "\tChannel Map: %s\n"
 228              "\tOwner Module: %u\n"
 229              "\tMute: %s\n"
 230              "\tVolume: %s%s%s\n"
 231              "\t        balance %0.2f\n"
 232              "\tBase Volume: %s%s%s\n"
 233              "\tMonitor Source: %s\n"
 234              "\tLatency: %0.0f usec, configured %0.0f usec\n"
 235              "\tFlags: %s%s%s%s%s%s\n"
 236              "\tProperties:\n\t\t%s\n"),
 237            i->index,
 238            state_table[1+i->state],
 239            i->name,
 240            pa_strnull(i->description),
 241            pa_strnull(i->driver),
 242            pa_sample_spec_snprint(s, sizeof(s), &i->sample_spec),
 243            pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map),
 244            i->owner_module,
 245            pa_yes_no(i->mute),
 246            pa_cvolume_snprint(cv, sizeof(cv), &i->volume),
 247            i->flags & PA_SINK_DECIBEL_VOLUME ? "\n\t        " : "",
 248            i->flags & PA_SINK_DECIBEL_VOLUME ? pa_sw_cvolume_snprint_dB(cvdb, sizeof(cvdb), &i->volume) : "",
 249            pa_cvolume_get_balance(&i->volume, &i->channel_map),
 250            pa_volume_snprint(v, sizeof(v), i->base_volume),
 251            i->flags & PA_SINK_DECIBEL_VOLUME ? "\n\t             " : "",
 252            i->flags & PA_SINK_DECIBEL_VOLUME ? pa_sw_volume_snprint_dB(vdb, sizeof(vdb), i->base_volume) : "",
 253            pa_strnull(i->monitor_source_name),
 254            (double) i->latency, (double) i->configured_latency,
 255            i->flags & PA_SINK_HARDWARE ? "HARDWARE " : "",
 256            i->flags & PA_SINK_NETWORK ? "NETWORK " : "",
 257            i->flags & PA_SINK_HW_MUTE_CTRL ? "HW_MUTE_CTRL " : "",
 258            i->flags & PA_SINK_HW_VOLUME_CTRL ? "HW_VOLUME_CTRL " : "",
 259            i->flags & PA_SINK_DECIBEL_VOLUME ? "DECIBEL_VOLUME " : "",
 260            i->flags & PA_SINK_LATENCY ? "LATENCY " : "",
 261            pl = pa_proplist_to_string_sep(i->proplist, "\n\t\t"));
 262
 263     pa_xfree(pl);
 264
 265     if (i->ports) {
 266         pa_sink_port_info **p;
 267
 268         printf(_("\tPorts:\n"));
 269         for (p = i->ports; *p; p++)
 270             printf("\t\t%s: %s (priority. %u)\n", (*p)->name, (*p)->description, (*p)->priority);
 271     }
 272
 273     if (i->active_port)
 274         printf(_("\tActive Port: %s\n"),
 275                i->active_port->name);
 276 }
 277
 278 static void get_source_info_callback(pa_context *c, const pa_source_info *i, int is_last, void *userdata) {
 279
 280     static const char *state_table[] = {
 281         [1+PA_SOURCE_INVALID_STATE] = "n/a",
 282         [1+PA_SOURCE_RUNNING] = "RUNNING",
 283         [1+PA_SOURCE_IDLE] = "IDLE",
 284         [1+PA_SOURCE_SUSPENDED] = "SUSPENDED"
 285     };
 286
 287     char
 288         s[PA_SAMPLE_SPEC_SNPRINT_MAX],
 289         cv[PA_CVOLUME_SNPRINT_MAX],
 290         cvdb[PA_SW_CVOLUME_SNPRINT_DB_MAX],
 291         v[PA_VOLUME_SNPRINT_MAX],
 292         vdb[PA_SW_VOLUME_SNPRINT_DB_MAX],
 293         cm[PA_CHANNEL_MAP_SNPRINT_MAX];
 294     char *pl;
 295
 296     if (is_last < 0) {
 297         pa_log(_("Failed to get source information: %s"), pa_strerror(pa_context_errno(c)));
 298         quit(1);
 299         return;
 300     }
 301
 302     if (is_last) {
 303         complete_action();
 304         return;
 305     }
 306
 307     pa_assert(i);
 308
 309     if (nl)
 310         printf("\n");
 311     nl = TRUE;
 312
 313     printf(_("Source #%u\n"
 314              "\tState: %s\n"
 315              "\tName: %s\n"
 316              "\tDescription: %s\n"
 317              "\tDriver: %s\n"
 318              "\tSample Specification: %s\n"
 319              "\tChannel Map: %s\n"
 320              "\tOwner Module: %u\n"
 321              "\tMute: %s\n"
 322              "\tVolume: %s%s%s\n"
 323              "\t        balance %0.2f\n"
 324              "\tBase Volume: %s%s%s\n"
 325              "\tMonitor of Sink: %s\n"
 326              "\tLatency: %0.0f usec, configured %0.0f usec\n"
 327              "\tFlags: %s%s%s%s%s%s\n"
 328              "\tProperties:\n\t\t%s\n"),
 329            i->index,
 330            state_table[1+i->state],
 331            i->name,
 332            pa_strnull(i->description),
 333            pa_strnull(i->driver),
 334            pa_sample_spec_snprint(s, sizeof(s), &i->sample_spec),
 335            pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map),
 336            i->owner_module,
 337            pa_yes_no(i->mute),
 338            pa_cvolume_snprint(cv, sizeof(cv), &i->volume),
 339            i->flags & PA_SOURCE_DECIBEL_VOLUME ? "\n\t        " : "",
 340            i->flags & PA_SOURCE_DECIBEL_VOLUME ? pa_sw_cvolume_snprint_dB(cvdb, sizeof(cvdb), &i->volume) : "",
 341            pa_cvolume_get_balance(&i->volume, &i->channel_map),
 342            pa_volume_snprint(v, sizeof(v), i->base_volume),
 343            i->flags & PA_SOURCE_DECIBEL_VOLUME ? "\n\t             " : "",
 344            i->flags & PA_SOURCE_DECIBEL_VOLUME ? pa_sw_volume_snprint_dB(vdb, sizeof(vdb), i->base_volume) : "",
 345            i->monitor_of_sink_name ? i->monitor_of_sink_name : _("n/a"),
 346            (double) i->latency, (double) i->configured_latency,
 347            i->flags & PA_SOURCE_HARDWARE ? "HARDWARE " : "",
 348            i->flags & PA_SOURCE_NETWORK ? "NETWORK " : "",
 349            i->flags & PA_SOURCE_HW_MUTE_CTRL ? "HW_MUTE_CTRL " : "",
 350            i->flags & PA_SOURCE_HW_VOLUME_CTRL ? "HW_VOLUME_CTRL " : "",
 351            i->flags & PA_SOURCE_DECIBEL_VOLUME ? "DECIBEL_VOLUME " : "",
 352            i->flags & PA_SOURCE_LATENCY ? "LATENCY " : "",
 353            pl = pa_proplist_to_string_sep(i->proplist, "\n\t\t"));
 354
 355     pa_xfree(pl);
 356
 357     if (i->ports) {
 358         pa_source_port_info **p;
 359
 360         printf(_("\tPorts:\n"));
 361         for (p = i->ports; *p; p++)
 362             printf("\t\t%s: %s (priority. %u)\n", (*p)->name, (*p)->description, (*p)->priority);
 363     }
 364
 365     if (i->active_port)
 366         printf(_("\tActive Port: %s\n"),
 367                i->active_port->name);
 368 }
 369
 370 static void get_module_info_callback(pa_context *c, const pa_module_info *i, int is_last, void *userdata) {
 371     char t[32];
 372     char *pl;
 373
 374     if (is_last < 0) {
 375         pa_log(_("Failed to get module information: %s"), pa_strerror(pa_context_errno(c)));
 376         quit(1);
 377         return;
 378     }
 379
 380     if (is_last) {
 381         complete_action();
 382         return;
 383     }
 384
 385     pa_assert(i);
 386
 387     if (nl)
 388         printf("\n");
 389     nl = TRUE;
 390
 391     pa_snprintf(t, sizeof(t), "%u", i->n_used);
 392
 393     printf(_("Module #%u\n"
 394              "\tName: %s\n"
 395              "\tArgument: %s\n"
 396              "\tUsage counter: %s\n"
 397              "\tProperties:\n\t\t%s\n"),
 398            i->index,
 399            i->name,
 400            i->argument ? i->argument : "",
 401            i->n_used != PA_INVALID_INDEX ? t : _("n/a"),
 402            pl = pa_proplist_to_string_sep(i->proplist, "\n\t\t"));
 403
 404     pa_xfree(pl);
 405 }
 406
 407 static void get_client_info_callback(pa_context *c, const pa_client_info *i, int is_last, void *userdata) {
 408     char t[32];
 409     char *pl;
 410
 411     if (is_last < 0) {
 412         pa_log(_("Failed to get client information: %s"), pa_strerror(pa_context_errno(c)));
 413         quit(1);
 414         return;
 415     }
 416
 417     if (is_last) {
 418         complete_action();
 419         return;
 420     }
 421
 422     pa_assert(i);
 423
 424     if (nl)
 425         printf("\n");
 426     nl = TRUE;
 427
 428     pa_snprintf(t, sizeof(t), "%u", i->owner_module);
 429
 430     printf(_("Client #%u\n"
 431              "\tDriver: %s\n"
 432              "\tOwner Module: %s\n"
 433              "\tProperties:\n\t\t%s\n"),
 434            i->index,
 435            pa_strnull(i->driver),
 436            i->owner_module != PA_INVALID_INDEX ? t : _("n/a"),
 437            pl = pa_proplist_to_string_sep(i->proplist, "\n\t\t"));
 438
 439     pa_xfree(pl);
 440 }
 441
 442 static void get_card_info_callback(pa_context *c, const pa_card_info *i, int is_last, void *userdata) {
 443     char t[32];
 444     char *pl;
 445
 446     if (is_last < 0) {
 447         pa_log(_("Failed to get card information: %s"), pa_strerror(pa_context_errno(c)));
 448         complete_action();
 449         return;
 450     }
 451
 452     if (is_last) {
 453         complete_action();
 454         return;
 455     }
 456
 457     pa_assert(i);
 458
 459     if (nl)
 460         printf("\n");
 461     nl = TRUE;
 462
 463     pa_snprintf(t, sizeof(t), "%u", i->owner_module);
 464
 465     printf(_("Card #%u\n"
 466              "\tName: %s\n"
 467              "\tDriver: %s\n"
 468              "\tOwner Module: %s\n"
 469              "\tProperties:\n\t\t%s\n"),
 470            i->index,
 471            i->name,
 472            pa_strnull(i->driver),
 473            i->owner_module != PA_INVALID_INDEX ? t : _("n/a"),
 474            pl = pa_proplist_to_string_sep(i->proplist, "\n\t\t"));
 475
 476     if (i->profiles) {
 477         pa_card_profile_info *p;
 478
 479         printf(_("\tProfiles:\n"));
 480         for (p = i->profiles; p->name; p++)
 481             printf("\t\t%s: %s (sinks: %u, sources: %u, priority. %u)\n", p->name, p->description, p->n_sinks, p->n_sources, p->priority);
 482     }
 483
 484     if (i->active_profile)
 485         printf(_("\tActive Profile: %s\n"),
 486                i->active_profile->name);
 487
 488     pa_xfree(pl);
 489 }
 490
 491 static void get_sink_input_info_callback(pa_context *c, const pa_sink_input_info *i, int is_last, void *userdata) {
 492     char t[32], k[32], s[PA_SAMPLE_SPEC_SNPRINT_MAX], cv[PA_CVOLUME_SNPRINT_MAX], cvdb[PA_SW_CVOLUME_SNPRINT_DB_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
 493     char *pl;
 494
 495     if (is_last < 0) {
 496         pa_log(_("Failed to get sink input information: %s"), pa_strerror(pa_context_errno(c)));
 497         quit(1);
 498         return;
 499     }
 500
 501     if (is_last) {
 502         complete_action();
 503         return;
 504     }
 505
 506     pa_assert(i);
 507
 508     if (nl)
 509         printf("\n");
 510     nl = TRUE;
 511
 512     pa_snprintf(t, sizeof(t), "%u", i->owner_module);
 513     pa_snprintf(k, sizeof(k), "%u", i->client);
 514
 515     printf(_("Sink Input #%u\n"
 516              "\tDriver: %s\n"
 517              "\tOwner Module: %s\n"
 518              "\tClient: %s\n"
 519              "\tSink: %u\n"
 520              "\tSample Specification: %s\n"
 521              "\tChannel Map: %s\n"
 522              "\tMute: %s\n"
 523              "\tVolume: %s\n"
 524              "\t        %s\n"
 525              "\t        balance %0.2f\n"
 526              "\tBuffer Latency: %0.0f usec\n"
 527              "\tSink Latency: %0.0f usec\n"
 528              "\tResample method: %s\n"
 529              "\tProperties:\n\t\t%s\n"),
 530            i->index,
 531            pa_strnull(i->driver),
 532            i->owner_module != PA_INVALID_INDEX ? t : _("n/a"),
 533            i->client != PA_INVALID_INDEX ? k : _("n/a"),
 534            i->sink,
 535            pa_sample_spec_snprint(s, sizeof(s), &i->sample_spec),
 536            pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map),
 537            pa_yes_no(i->mute),
 538            pa_cvolume_snprint(cv, sizeof(cv), &i->volume),
 539            pa_sw_cvolume_snprint_dB(cvdb, sizeof(cvdb), &i->volume),
 540            pa_cvolume_get_balance(&i->volume, &i->channel_map),
 541            (double) i->buffer_usec,
 542            (double) i->sink_usec,
 543            i->resample_method ? i->resample_method : _("n/a"),
 544            pl = pa_proplist_to_string_sep(i->proplist, "\n\t\t"));
 545
 546     pa_xfree(pl);
 547 }
 548
 549 static void get_source_output_info_callback(pa_context *c, const pa_source_output_info *i, int is_last, void *userdata) {
 550     char t[32], k[32], s[PA_SAMPLE_SPEC_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
 551     char *pl;
 552
 553     if (is_last < 0) {
 554         pa_log(_("Failed to get source output information: %s"), pa_strerror(pa_context_errno(c)));
 555         quit(1);
 556         return;
 557     }
 558
 559     if (is_last) {
 560         complete_action();
 561         return;
 562     }
 563
 564     pa_assert(i);
 565
 566     if (nl)
 567         printf("\n");
 568     nl = TRUE;
 569
 570
 571     pa_snprintf(t, sizeof(t), "%u", i->owner_module);
 572     pa_snprintf(k, sizeof(k), "%u", i->client);
 573
 574     printf(_("Source Output #%u\n"
 575              "\tDriver: %s\n"
 576              "\tOwner Module: %s\n"
 577              "\tClient: %s\n"
 578              "\tSource: %u\n"
 579              "\tSample Specification: %s\n"
 580              "\tChannel Map: %s\n"
 581              "\tBuffer Latency: %0.0f usec\n"
 582              "\tSource Latency: %0.0f usec\n"
 583              "\tResample method: %s\n"
 584              "\tProperties:\n\t\t%s\n"),
 585            i->index,
 586            pa_strnull(i->driver),
 587            i->owner_module != PA_INVALID_INDEX ? t : _("n/a"),
 588            i->client != PA_INVALID_INDEX ? k : _("n/a"),
 589            i->source,
 590            pa_sample_spec_snprint(s, sizeof(s), &i->sample_spec),
 591            pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map),
 592            (double) i->buffer_usec,
 593            (double) i->source_usec,
 594            i->resample_method ? i->resample_method : _("n/a"),
 595            pl = pa_proplist_to_string_sep(i->proplist, "\n\t\t"));
 596
 597     pa_xfree(pl);
 598 }
 599
 600 static void get_sample_info_callback(pa_context *c, const pa_sample_info *i, int is_last, void *userdata) {
 601     char t[PA_BYTES_SNPRINT_MAX], s[PA_SAMPLE_SPEC_SNPRINT_MAX], cv[PA_CVOLUME_SNPRINT_MAX], cvdb[PA_SW_CVOLUME_SNPRINT_DB_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
 602     char *pl;
 603
 604     if (is_last < 0) {
 605         pa_log(_("Failed to get sample information: %s"), pa_strerror(pa_context_errno(c)));
 606         quit(1);
 607         return;
 608     }
 609
 610     if (is_last) {
 611         complete_action();
 612         return;
 613     }
 614
 615     pa_assert(i);
 616
 617     if (nl)
 618         printf("\n");
 619     nl = TRUE;
 620
 621     pa_bytes_snprint(t, sizeof(t), i->bytes);
 622
 623     printf(_("Sample #%u\n"
 624              "\tName: %s\n"
 625              "\tSample Specification: %s\n"
 626              "\tChannel Map: %s\n"
 627              "\tVolume: %s\n"
 628              "\t        %s\n"
 629              "\t        balance %0.2f\n"
 630              "\tDuration: %0.1fs\n"
 631              "\tSize: %s\n"
 632              "\tLazy: %s\n"
 633              "\tFilename: %s\n"
 634              "\tProperties:\n\t\t%s\n"),
 635            i->index,
 636            i->name,
 637            pa_sample_spec_valid(&i->sample_spec) ? pa_sample_spec_snprint(s, sizeof(s), &i->sample_spec) : _("n/a"),
 638            pa_sample_spec_valid(&i->sample_spec) ? pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map) : _("n/a"),
 639            pa_cvolume_snprint(cv, sizeof(cv), &i->volume),
 640            pa_sw_cvolume_snprint_dB(cvdb, sizeof(cvdb), &i->volume),
 641            pa_cvolume_get_balance(&i->volume, &i->channel_map),
 642            (double) i->duration/1000000.0,
 643            t,
 644            pa_yes_no(i->lazy),
 645            i->filename ? i->filename : _("n/a"),
 646            pl = pa_proplist_to_string_sep(i->proplist, "\n\t\t"));
 647
 648     pa_xfree(pl);
 649 }
 650
 651 static void simple_callback(pa_context *c, int success, void *userdata) {
 652     if (!success) {
 653         pa_log(_("Failure: %s"), pa_strerror(pa_context_errno(c)));
 654         quit(1);
 655         return;
 656     }
 657
 658     complete_action();
 659 }
 660
 661 static void index_callback(pa_context *c, uint32_t idx, void *userdata) {
 662     if (idx == PA_INVALID_INDEX) {
 663         pa_log(_("Failure: %s"), pa_strerror(pa_context_errno(c)));
 664         quit(1);
 665         return;
 666     }
 667
 668     printf("%u\n", idx);
 669
 670     complete_action();
 671 }
 672
 673 static void stream_state_callback(pa_stream *s, void *userdata) {
 674     pa_assert(s);
 675
 676     switch (pa_stream_get_state(s)) {
 677         case PA_STREAM_CREATING:
 678         case PA_STREAM_READY:
 679             break;
 680
 681         case PA_STREAM_TERMINATED:
 682             drain();
 683             break;
 684
 685         case PA_STREAM_FAILED:
 686         default:
 687             pa_log(_("Failed to upload sample: %s"), pa_strerror(pa_context_errno(pa_stream_get_context(s))));
 688             quit(1);
 689     }
 690 }
 691
 692 static void stream_write_callback(pa_stream *s, size_t length, void *userdata) {
 693     sf_count_t l;
 694     float *d;
 695     pa_assert(s && length && sndfile);
 696
 697     d = pa_xmalloc(length);
 698
 699     pa_assert(sample_length >= length);
 700     l = (sf_count_t) (length/pa_frame_size(&sample_spec));
 701
 702     if ((sf_readf_float(sndfile, d, l)) != l) {
 703         pa_xfree(d);
 704         pa_log(_("Premature end of file"));
 705         quit(1);
 706         return;
 707     }
 708
 709     pa_stream_write(s, d, length, pa_xfree, 0, PA_SEEK_RELATIVE);
 710
 711     sample_length -= length;
 712
 713     if (sample_length  <= 0) {
 714         pa_stream_set_write_callback(sample_stream, NULL, NULL);
 715         pa_stream_finish_upload(sample_stream);
 716     }
 717 }
 718
 719 static void context_state_callback(pa_context *c, void *userdata) {
 720     pa_assert(c);
 721     switch (pa_context_get_state(c)) {
 722         case PA_CONTEXT_CONNECTING:
 723         case PA_CONTEXT_AUTHORIZING:
 724         case PA_CONTEXT_SETTING_NAME:
 725             break;
 726
 727         case PA_CONTEXT_READY:
 728             switch (action) {
 729                 case STAT:
 730                     actions = 2;
 731                     pa_operation_unref(pa_context_stat(c, stat_callback, NULL));
 732                     pa_operation_unref(pa_context_get_server_info(c, get_server_info_callback, NULL));
 733                     break;
 734
 735                 case PLAY_SAMPLE:
 736                     pa_operation_unref(pa_context_play_sample(c, sample_name, sink_name, PA_VOLUME_NORM, simple_callback, NULL));
 737                     break;
 738
 739                 case REMOVE_SAMPLE:
 740                     pa_operation_unref(pa_context_remove_sample(c, sample_name, simple_callback, NULL));
 741                     break;
 742
 743                 case UPLOAD_SAMPLE:
 744                     sample_stream = pa_stream_new(c, sample_name, &sample_spec, NULL);
 745                     pa_assert(sample_stream);
 746
 747                     pa_stream_set_state_callback(sample_stream, stream_state_callback, NULL);
 748                     pa_stream_set_write_callback(sample_stream, stream_write_callback, NULL);
 749                     pa_stream_connect_upload(sample_stream, sample_length);
 750                     break;
 751
 752                 case EXIT:
 753                     pa_operation_unref(pa_context_exit_daemon(c, simple_callback, NULL));
 754                     break;
 755
 756                 case LIST:
 757                     actions = 8;
 758                     pa_operation_unref(pa_context_get_module_info_list(c, get_module_info_callback, NULL));
 759                     pa_operation_unref(pa_context_get_sink_info_list(c, get_sink_info_callback, NULL));
 760                     pa_operation_unref(pa_context_get_source_info_list(c, get_source_info_callback, NULL));
 761                     pa_operation_unref(pa_context_get_sink_input_info_list(c, get_sink_input_info_callback, NULL));
 762                     pa_operation_unref(pa_context_get_source_output_info_list(c, get_source_output_info_callback, NULL));
 763                     pa_operation_unref(pa_context_get_client_info_list(c, get_client_info_callback, NULL));
 764                     pa_operation_unref(pa_context_get_sample_info_list(c, get_sample_info_callback, NULL));
 765                     pa_operation_unref(pa_context_get_card_info_list(c, get_card_info_callback, NULL));
 766                     break;
 767
 768                 case MOVE_SINK_INPUT:
 769                     pa_operation_unref(pa_context_move_sink_input_by_name(c, sink_input_idx, sink_name, simple_callback, NULL));
 770                     break;
 771
 772                 case MOVE_SOURCE_OUTPUT:
 773                     pa_operation_unref(pa_context_move_source_output_by_name(c, source_output_idx, source_name, simple_callback, NULL));
 774                     break;
 775
 776                 case LOAD_MODULE:
 777                     pa_operation_unref(pa_context_load_module(c, module_name, module_args, index_callback, NULL));
 778                     break;
 779
 780                 case UNLOAD_MODULE:
 781                     pa_operation_unref(pa_context_unload_module(c, module_index, simple_callback, NULL));
 782                     break;
 783
 784                 case SUSPEND_SINK:
 785                     if (sink_name)
 786                         pa_operation_unref(pa_context_suspend_sink_by_name(c, sink_name, suspend, simple_callback, NULL));
 787                     else
 788                         pa_operation_unref(pa_context_suspend_sink_by_index(c, PA_INVALID_INDEX, suspend, simple_callback, NULL));
 789                     break;
 790
 791                 case SUSPEND_SOURCE:
 792                     if (source_name)
 793                         pa_operation_unref(pa_context_suspend_source_by_name(c, source_name, suspend, simple_callback, NULL));
 794                     else
 795                         pa_operation_unref(pa_context_suspend_source_by_index(c, PA_INVALID_INDEX, suspend, simple_callback, NULL));
 796                     break;
 797
 798                 case SET_CARD_PROFILE:
 799                     pa_operation_unref(pa_context_set_card_profile_by_name(c, card_name, profile_name, simple_callback, NULL));
 800                     break;
 801
 802                 case SET_SINK_PORT:
 803                     pa_operation_unref(pa_context_set_sink_port_by_name(c, sink_name, port_name, simple_callback, NULL));
 804                     break;
 805
 806                 case SET_SOURCE_PORT:
 807                     pa_operation_unref(pa_context_set_source_port_by_name(c, source_name, port_name, simple_callback, NULL));
 808                     break;
 809
 810                 case SET_SINK_MUTE:
 811                     pa_operation_unref(pa_context_set_sink_mute_by_name(c, sink_name, mute, simple_callback, NULL));
 812                     break;
 813
 814                 case SET_SOURCE_MUTE:
 815                     pa_operation_unref(pa_context_set_source_mute_by_name(c, source_name, mute, simple_callback, NULL));
 816                     break;
 817
 818                 case SET_SINK_INPUT_MUTE:
 819                     pa_operation_unref(pa_context_set_sink_input_mute(c, sink_input_idx, mute, simple_callback, NULL));
 820                     break;
 821
 822                 case SET_SINK_VOLUME: {
 823                     pa_cvolume v;
 824
 825                     pa_cvolume_set(&v, 1, volume);
 826                     pa_operation_unref(pa_context_set_sink_volume_by_name(c, sink_name, &v, simple_callback, NULL));
 827                     break;
 828                 }
 829
 830                 case SET_SOURCE_VOLUME: {
 831                     pa_cvolume v;
 832
 833                     pa_cvolume_set(&v, 1, volume);
 834                     pa_operation_unref(pa_context_set_source_volume_by_name(c, source_name, &v, simple_callback, NULL));
 835                     break;
 836                 }
 837
 838                 case SET_SINK_INPUT_VOLUME: {
 839                     pa_cvolume v;
 840
 841                     pa_cvolume_set(&v, 1, volume);
 842                     pa_operation_unref(pa_context_set_sink_input_volume(c, sink_input_idx, &v, simple_callback, NULL));
 843                     break;
 844                 }
 845
 846                 default:
 847                     pa_assert_not_reached();
 848             }
 849             break;
 850
 851         case PA_CONTEXT_TERMINATED:
 852             quit(0);
 853             break;
 854
 855         case PA_CONTEXT_FAILED:
 856         default:
 857             pa_log(_("Connection failure: %s"), pa_strerror(pa_context_errno(c)));
 858             quit(1);
 859     }
 860 }
 861
 862 static void exit_signal_callback(pa_mainloop_api *m, pa_signal_event *e, int sig, void *userdata) {
 863     pa_log(_("Got SIGINT, exiting."));
 864     quit(0);
 865 }
 866
 867 static void help(const char *argv0) {
 868
 869     printf(_("%s [options] stat\n"
 870              "%s [options] list\n"
 871              "%s [options] exit\n"
 872              "%s [options] upload-sample FILENAME [NAME]\n"
 873              "%s [options] play-sample NAME [SINK]\n"
 874              "%s [options] remove-sample NAME\n"
 875              "%s [options] move-sink-input SINKINPUT SINK\n"
 876              "%s [options] move-source-output SOURCEOUTPUT SOURCE\n"
 877              "%s [options] load-module NAME [ARGS ...]\n"
 878              "%s [options] unload-module MODULE\n"
 879              "%s [options] suspend-sink SINK 1|0\n"
 880              "%s [options] suspend-source SOURCE 1|0\n"
 881              "%s [options] set-card-profile CARD PROFILE\n"
 882              "%s [options] set-sink-port SINK PORT\n"
 883              "%s [options] set-source-port SOURCE PORT\n"
 884              "%s [options] set-sink-volume SINK VOLUME\n"
 885              "%s [options] set-source-volume SOURCE VOLUME\n"
 886              "%s [options] set-sink-input-volume SINKINPUT VOLUME\n"
 887              "%s [options] set-sink-mute SINK 1|0\n"
 888              "%s [options] set-source-mute SOURCE 1|0\n"
 889              "%s [options] set-sink-input-mute SINKINPUT 1|0\n\n"
 890              "  -h, --help                            Show this help\n"
 891              "      --version                         Show version\n\n"
 892              "  -s, --server=SERVER                   The name of the server to connect to\n"
 893              "  -n, --client-name=NAME                How to call this client on the server\n"),
 894            argv0, argv0, argv0, argv0, argv0,
 895            argv0, argv0, argv0, argv0, argv0,
 896            argv0, argv0, argv0, argv0, argv0,
 897            argv0, argv0, argv0, argv0, argv0,
 898            argv0);
 899 }
 900
 901 enum {
 902     ARG_VERSION = 256
 903 };
 904
 905 int main(int argc, char *argv[]) {
 906     pa_mainloop* m = NULL;
 907     int ret = 1, c;
 908     char *server = NULL, *bn;
 909
 910     static const struct option long_options[] = {
 911         {"server",      1, NULL, 's'},
 912         {"client-name", 1, NULL, 'n'},
 913         {"version",     0, NULL, ARG_VERSION},
 914         {"help",        0, NULL, 'h'},
 915         {NULL,          0, NULL, 0}
 916     };
 917
 918     setlocale(LC_ALL, "");
 919     bindtextdomain(GETTEXT_PACKAGE, PULSE_LOCALEDIR);
 920
 921     bn = pa_path_get_filename(argv[0]);
 922
 923     proplist = pa_proplist_new();
 924
 925     while ((c = getopt_long(argc, argv, "s:n:h", long_options, NULL)) != -1) {
 926         switch (c) {
 927             case 'h' :
 928                 help(bn);
 929                 ret = 0;
 930                 goto quit;
 931
 932             case ARG_VERSION:
 933                 printf(_("pactl %s\n"
 934                          "Compiled with libpulse %s\n"
 935                          "Linked with libpulse %s\n"),
 936                        PACKAGE_VERSION,
 937                        pa_get_headers_version(),
 938                        pa_get_library_version());
 939                 ret = 0;
 940                 goto quit;
 941
 942             case 's':
 943                 pa_xfree(server);
 944                 server = pa_xstrdup(optarg);
 945                 break;
 946
 947             case 'n': {
 948                 char *t;
 949
 950                 if (!(t = pa_locale_to_utf8(optarg)) ||
 951                     pa_proplist_sets(proplist, PA_PROP_APPLICATION_NAME, t) < 0) {
 952
 953                     pa_log(_("Invalid client name '%s'"), t ? t : optarg);
 954                     pa_xfree(t);
 955                     goto quit;
 956                 }
 957
 958                 pa_xfree(t);
 959                 break;
 960             }
 961
 962             default:
 963                 goto quit;
 964         }
 965     }
 966
 967     if (optind < argc) {
 968         if (pa_streq(argv[optind], "stat"))
 969             action = STAT;
 970         else if (pa_streq(argv[optind], "exit"))
 971             action = EXIT;
 972         else if (pa_streq(argv[optind], "list"))
 973             action = LIST;
 974         else if (pa_streq(argv[optind], "upload-sample")) {
 975             struct SF_INFO sfi;
 976             action = UPLOAD_SAMPLE;
 977
 978             if (optind+1 >= argc) {
 979                 pa_log(_("Please specify a sample file to load"));
 980                 goto quit;
 981             }
 982
 983             if (optind+2 < argc)
 984                 sample_name = pa_xstrdup(argv[optind+2]);
 985             else {
 986                 char *f = pa_path_get_filename(argv[optind+1]);
 987                 sample_name = pa_xstrndup(f, strcspn(f, "."));
 988             }
 989
 990             pa_zero(sfi);
 991             if (!(sndfile = sf_open(argv[optind+1], SFM_READ, &sfi))) {
 992                 pa_log(_("Failed to open sound file."));
 993                 goto quit;
 994             }
 995
 996             if (pa_sndfile_read_sample_spec(sndfile, &sample_spec) < 0) {
 997                 pa_log(_("Failed to determine sample specification from file."));
 998                 goto quit;
 999             }
1000             sample_spec.format = PA_SAMPLE_FLOAT32;
1001
1002             if (pa_sndfile_read_channel_map(sndfile, &channel_map) < 0) {
1003                 if (sample_spec.channels > 2)
1004                      pa_log(_("Warning: Failed to determine sample specification from file."));
1005                 pa_channel_map_init_extend(&channel_map, sample_spec.channels, PA_CHANNEL_MAP_DEFAULT);
1006             }
1007
1008             pa_assert(pa_channel_map_compatible(&channel_map, &sample_spec));
1009             sample_length = (size_t) sfi.frames*pa_frame_size(&sample_spec);
1010
1011         } else if (pa_streq(argv[optind], "play-sample")) {
1012             action = PLAY_SAMPLE;
1013             if (argc != optind+2 && argc != optind+3) {
1014                 pa_log(_("You have to specify a sample name to play"));
1015                 goto quit;
1016             }
1017
1018             sample_name = pa_xstrdup(argv[optind+1]);
1019
1020             if (optind+2 < argc)
1021                 sink_name = pa_xstrdup(argv[optind+2]);
1022
1023         } else if (pa_streq(argv[optind], "remove-sample")) {
1024             action = REMOVE_SAMPLE;
1025             if (argc != optind+2) {
1026                 pa_log(_("You have to specify a sample name to remove"));
1027                 goto quit;
1028             }
1029
1030             sample_name = pa_xstrdup(argv[optind+1]);
1031
1032         } else if (pa_streq(argv[optind], "move-sink-input")) {
1033             action = MOVE_SINK_INPUT;
1034             if (argc != optind+3) {
1035                 pa_log(_("You have to specify a sink input index and a sink"));
1036                 goto quit;
1037             }
1038
1039             sink_input_idx = (uint32_t) atoi(argv[optind+1]);
1040             sink_name = pa_xstrdup(argv[optind+2]);
1041
1042         } else if (pa_streq(argv[optind], "move-source-output")) {
1043             action = MOVE_SOURCE_OUTPUT;
1044             if (argc != optind+3) {
1045                 pa_log(_("You have to specify a source output index and a source"));
1046                 goto quit;
1047             }
1048
1049             source_output_idx = (uint32_t) atoi(argv[optind+1]);
1050             source_name = pa_xstrdup(argv[optind+2]);
1051
1052         } else if (pa_streq(argv[optind], "load-module")) {
1053             int i;
1054             size_t n = 0;
1055             char *p;
1056
1057             action = LOAD_MODULE;
1058
1059             if (argc <= optind+1) {
1060                 pa_log(_("You have to specify a module name and arguments."));
1061                 goto quit;
1062             }
1063
1064             module_name = argv[optind+1];
1065
1066             for (i = optind+2; i < argc; i++)
1067                 n += strlen(argv[i])+1;
1068
1069             if (n > 0) {
1070                 p = module_args = pa_xmalloc(n);
1071
1072                 for (i = optind+2; i < argc; i++)
1073                     p += sprintf(p, "%s%s", p == module_args ? "" : " ", argv[i]);
1074             }
1075
1076         } else if (pa_streq(argv[optind], "unload-module")) {
1077             action = UNLOAD_MODULE;
1078
1079             if (argc != optind+2) {
1080                 pa_log(_("You have to specify a module index"));
1081                 goto quit;
1082             }
1083
1084             module_index = (uint32_t) atoi(argv[optind+1]);
1085
1086         } else if (pa_streq(argv[optind], "suspend-sink")) {
1087             action = SUSPEND_SINK;
1088
1089             if (argc > optind+3 || optind+1 >= argc) {
1090                 pa_log(_("You may not specify more than one sink. You have to specify a boolean value."));
1091                 goto quit;
1092             }
1093
1094             suspend = pa_parse_boolean(argv[argc-1]);
1095
1096             if (argc > optind+2)
1097                 sink_name = pa_xstrdup(argv[optind+1]);
1098
1099         } else if (pa_streq(argv[optind], "suspend-source")) {
1100             action = SUSPEND_SOURCE;
1101
1102             if (argc > optind+3 || optind+1 >= argc) {
1103                 pa_log(_("You may not specify more than one source. You have to specify a boolean value."));
1104                 goto quit;
1105             }
1106
1107             suspend = pa_parse_boolean(argv[argc-1]);
1108
1109             if (argc > optind+2)
1110                 source_name = pa_xstrdup(argv[optind+1]);
1111         } else if (pa_streq(argv[optind], "set-card-profile")) {
1112             action = SET_CARD_PROFILE;
1113
1114             if (argc != optind+3) {
1115                 pa_log(_("You have to specify a card name/index and a profile name"));
1116                 goto quit;
1117             }
1118
1119             card_name = pa_xstrdup(argv[optind+1]);
1120             profile_name = pa_xstrdup(argv[optind+2]);
1121
1122         } else if (pa_streq(argv[optind], "set-sink-port")) {
1123             action = SET_SINK_PORT;
1124
1125             if (argc != optind+3) {
1126                 pa_log(_("You have to specify a sink name/index and a port name"));
1127                 goto quit;
1128             }
1129
1130             sink_name = pa_xstrdup(argv[optind+1]);
1131             port_name = pa_xstrdup(argv[optind+2]);
1132
1133         } else if (pa_streq(argv[optind], "set-source-port")) {
1134             action = SET_SOURCE_PORT;
1135
1136             if (argc != optind+3) {
1137                 pa_log(_("You have to specify a source name/index and a port name"));
1138                 goto quit;
1139             }
1140
1141             source_name = pa_xstrdup(argv[optind+1]);
1142             port_name = pa_xstrdup(argv[optind+2]);
1143
1144         } else if (pa_streq(argv[optind], "set-sink-volume")) {
1145             uint32_t v;
1146             action = SET_SINK_VOLUME;
1147
1148             if (argc != optind+3) {
1149                 pa_log(_("You have to specify a sink name/index and a volume"));
1150                 goto quit;
1151             }
1152
1153             if (pa_atou(argv[optind+2], &v) < 0) {
1154                 pa_log(_("Invalid volume specification"));
1155                 goto quit;
1156             }
1157
1158             sink_name = pa_xstrdup(argv[optind+1]);
1159             volume = (pa_volume_t) v;
1160
1161         } else if (pa_streq(argv[optind], "set-source-volume")) {
1162             uint32_t v;
1163             action = SET_SOURCE_VOLUME;
1164
1165             if (argc != optind+3) {
1166                 pa_log(_("You have to specify a source name/index and a volume"));
1167                 goto quit;
1168             }
1169
1170             if (pa_atou(argv[optind+2], &v) < 0) {
1171                 pa_log(_("Invalid volume specification"));
1172                 goto quit;
1173             }
1174
1175             source_name = pa_xstrdup(argv[optind+1]);
1176             volume = (pa_volume_t) v;
1177
1178         } else if (pa_streq(argv[optind], "set-sink-input-volume")) {
1179             uint32_t v;
1180             action = SET_SINK_INPUT_VOLUME;
1181
1182             if (argc != optind+3) {
1183                 pa_log(_("You have to specify a sink input index and a volume"));
1184                 goto quit;
1185             }
1186
1187             if (pa_atou(argv[optind+1], &sink_input_idx) < 0) {
1188                 pa_log(_("Invalid sink input index"));
1189                 goto quit;
1190             }
1191
1192             if (pa_atou(argv[optind+2], &v) < 0) {
1193                 pa_log(_("Invalid volume specification"));
1194                 goto quit;
1195             }
1196
1197             volume = (pa_volume_t) v;
1198
1199         } else if (pa_streq(argv[optind], "set-sink-mute")) {
1200             int b;
1201             action = SET_SINK_MUTE;
1202
1203             if (argc != optind+3) {
1204                 pa_log(_("You have to specify a sink name/index and a mute boolean"));
1205                 goto quit;
1206             }
1207
1208             if ((b = pa_parse_boolean(argv[optind+2])) < 0) {
1209                 pa_log(_("Invalid volume specification"));
1210                 goto quit;
1211             }
1212
1213             sink_name = pa_xstrdup(argv[optind+1]);
1214             mute = b;
1215
1216         } else if (pa_streq(argv[optind], "set-source-mute")) {
1217             int b;
1218             action = SET_SOURCE_MUTE;
1219
1220             if (argc != optind+3) {
1221                 pa_log(_("You have to specify a source name/index and a mute boolean"));
1222                 goto quit;
1223             }
1224
1225             if ((b = pa_parse_boolean(argv[optind+2])) < 0) {
1226                 pa_log(_("Invalid volume specification"));
1227                 goto quit;
1228             }
1229
1230             source_name = pa_xstrdup(argv[optind+1]);
1231             mute = b;
1232
1233         } else if (pa_streq(argv[optind], "set-sink-input-mute")) {
1234             int b;
1235             action = SET_SINK_INPUT_MUTE;
1236
1237             if (argc != optind+3) {
1238                 pa_log(_("You have to specify a sink input index and a mute boolean"));
1239                 goto quit;
1240             }
1241
1242             if (pa_atou(argv[optind+1], &sink_input_idx) < 0) {
1243                 pa_log(_("Invalid sink input index specification"));
1244                 goto quit;
1245             }
1246
1247             if ((b = pa_parse_boolean(argv[optind+2])) < 0) {
1248                 pa_log(_("Invalid volume specification"));
1249                 goto quit;
1250             }
1251
1252             mute = b;
1253
1254         } else if (pa_streq(argv[optind], "help")) {
1255             help(bn);
1256             ret = 0;
1257             goto quit;
1258         }
1259     }
1260
1261     if (action == NONE) {
1262         pa_log(_("No valid command specified."));
1263         goto quit;
1264     }
1265
1266     if (!(m = pa_mainloop_new())) {
1267         pa_log(_("pa_mainloop_new() failed."));
1268         goto quit;
1269     }
1270
1271     mainloop_api = pa_mainloop_get_api(m);
1272
1273     pa_assert_se(pa_signal_init(mainloop_api) == 0);
1274     pa_signal_new(SIGINT, exit_signal_callback, NULL);
1275     pa_signal_new(SIGTERM, exit_signal_callback, NULL);
1276     pa_disable_sigpipe();
1277
1278     if (!(context = pa_context_new_with_proplist(mainloop_api, NULL, proplist))) {
1279         pa_log(_("pa_context_new() failed."));
1280         goto quit;
1281     }
1282
1283     pa_context_set_state_callback(context, context_state_callback, NULL);
1284     if (pa_context_connect(context, server, 0, NULL) < 0) {
1285         pa_log(_("pa_context_connect() failed: %s"), pa_strerror(pa_context_errno(context)));
1286         goto quit;
1287     }
1288
1289     if (pa_mainloop_run(m, &ret) < 0) {
1290         pa_log(_("pa_mainloop_run() failed."));
1291         goto quit;
1292     }
1293
1294 quit:
1295     if (sample_stream)
1296         pa_stream_unref(sample_stream);
1297
1298     if (context)
1299         pa_context_unref(context);
1300
1301     if (m) {
1302         pa_signal_done();
1303         pa_mainloop_free(m);
1304     }
1305
1306     pa_xfree(server);
1307     pa_xfree(sample_name);
1308     pa_xfree(sink_name);
1309     pa_xfree(source_name);
1310     pa_xfree(module_args);
1311     pa_xfree(card_name);
1312     pa_xfree(profile_name);
1313
1314     if (sndfile)
1315         sf_close(sndfile);
1316
1317     if (proplist)
1318         pa_proplist_free(proplist);
1319
1320     return ret;
1321 }