src/pulsecore/protocol-simple.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 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 <stdlib.h>
  27 #include <limits.h>
  28 #include <stdio.h>
  29 #include <errno.h>
  30 #include <string.h>
  31
  32 #include <pulse/xmalloc.h>
  33 #include <pulse/timeval.h>
  34
  35 #include <pulsecore/sink-input.h>
  36 #include <pulsecore/source-output.h>
  37 #include <pulsecore/client.h>
  38 #include <pulsecore/sample-util.h>
  39 #include <pulsecore/namereg.h>
  40 #include <pulsecore/log.h>
  41 #include <pulsecore/core-error.h>
  42 #include <pulsecore/atomic.h>
  43 #include <pulsecore/thread-mq.h>
  44 #include <pulsecore/core-util.h>
  45 #include <pulsecore/shared.h>
  46
  47 #include "protocol-simple.h"
  48
  49 /* Don't allow more than this many concurrent connections */
  50 #define MAX_CONNECTIONS 10
  51
  52 typedef struct connection {
  53     pa_msgobject parent;
  54     pa_simple_protocol *protocol;
  55     pa_simple_options *options;
  56     pa_iochannel *io;
  57     pa_sink_input *sink_input;
  58     pa_source_output *source_output;
  59     pa_client *client;
  60     pa_memblockq *input_memblockq, *output_memblockq;
  61
  62     pa_bool_t dead;
  63
  64     struct {
  65         pa_memblock *current_memblock;
  66         size_t memblock_index;
  67         pa_atomic_t missing;
  68         pa_bool_t underrun;
  69     } playback;
  70 } connection;
  71
  72 PA_DECLARE_CLASS(connection);
  73 #define CONNECTION(o) (connection_cast(o))
  74 static PA_DEFINE_CHECK_TYPE(connection, pa_msgobject);
  75
  76 struct pa_simple_protocol {
  77     PA_REFCNT_DECLARE;
  78
  79     pa_core *core;
  80     pa_idxset *connections;
  81 };
  82
  83 enum {
  84     SINK_INPUT_MESSAGE_POST_DATA = PA_SINK_INPUT_MESSAGE_MAX, /* data from main loop to sink input */
  85     SINK_INPUT_MESSAGE_DISABLE_PREBUF /* disabled prebuf, get playback started. */
  86 };
  87
  88 enum {
  89     CONNECTION_MESSAGE_REQUEST_DATA,      /* data requested from sink input from the main loop */
  90     CONNECTION_MESSAGE_POST_DATA,         /* data from source output to main loop */
  91     CONNECTION_MESSAGE_UNLINK_CONNECTION    /* Please drop a aconnection now */
  92 };
  93
  94 #define PLAYBACK_BUFFER_SECONDS (.5)
  95 #define PLAYBACK_BUFFER_FRAGMENTS (10)
  96 #define RECORD_BUFFER_SECONDS (5)
  97 #define DEFAULT_SINK_LATENCY (300*PA_USEC_PER_MSEC)
  98 #define DEFAULT_SOURCE_LATENCY (300*PA_USEC_PER_MSEC)
  99
 100 static void connection_unlink(connection *c) {
 101     pa_assert(c);
 102
 103     if (!c->protocol)
 104         return;
 105
 106     if (c->options) {
 107         pa_simple_options_unref(c->options);
 108         c->options = NULL;
 109     }
 110
 111     if (c->sink_input) {
 112         pa_sink_input_unlink(c->sink_input);
 113         pa_sink_input_unref(c->sink_input);
 114         c->sink_input = NULL;
 115     }
 116
 117     if (c->source_output) {
 118         pa_source_output_unlink(c->source_output);
 119         pa_source_output_unref(c->source_output);
 120         c->source_output = NULL;
 121     }
 122
 123     if (c->client) {
 124         pa_client_free(c->client);
 125         c->client = NULL;
 126     }
 127
 128     if (c->io) {
 129         pa_iochannel_free(c->io);
 130         c->io = NULL;
 131     }
 132
 133     pa_assert_se(pa_idxset_remove_by_data(c->protocol->connections, c, NULL) == c);
 134     c->protocol = NULL;
 135     connection_unref(c);
 136 }
 137
 138 static void connection_free(pa_object *o) {
 139     connection *c = CONNECTION(o);
 140     pa_assert(c);
 141
 142     if (c->playback.current_memblock)
 143         pa_memblock_unref(c->playback.current_memblock);
 144
 145     if (c->input_memblockq)
 146         pa_memblockq_free(c->input_memblockq);
 147     if (c->output_memblockq)
 148         pa_memblockq_free(c->output_memblockq);
 149
 150     pa_xfree(c);
 151 }
 152
 153 static int do_read(connection *c) {
 154     pa_memchunk chunk;
 155     ssize_t r;
 156     size_t l;
 157     void *p;
 158     size_t space;
 159
 160     connection_assert_ref(c);
 161
 162     if (!c->sink_input || (l = (size_t) pa_atomic_load(&c->playback.missing)) <= 0)
 163         return 0;
 164
 165     if (c->playback.current_memblock) {
 166
 167         space = pa_memblock_get_length(c->playback.current_memblock) - c->playback.memblock_index;
 168
 169         if (space <= 0) {
 170             pa_memblock_unref(c->playback.current_memblock);
 171             c->playback.current_memblock = NULL;
 172         }
 173     }
 174
 175     if (!c->playback.current_memblock) {
 176         pa_assert_se(c->playback.current_memblock = pa_memblock_new(c->protocol->core->mempool, (size_t) -1));
 177         c->playback.memblock_index = 0;
 178
 179         space = pa_memblock_get_length(c->playback.current_memblock);
 180     }
 181
 182     if (l > space)
 183         l = space;
 184
 185     p = pa_memblock_acquire(c->playback.current_memblock);
 186     r = pa_iochannel_read(c->io, (uint8_t*) p + c->playback.memblock_index, l);
 187     pa_memblock_release(c->playback.current_memblock);
 188
 189     if (r <= 0) {
 190
 191         if (r < 0 && (errno == EINTR || errno == EAGAIN))
 192             return 0;
 193
 194         pa_log_debug("read(): %s", r == 0 ? "EOF" : pa_cstrerror(errno));
 195         return -1;
 196     }
 197
 198     chunk.memblock = c->playback.current_memblock;
 199     chunk.index = c->playback.memblock_index;
 200     chunk.length = (size_t) r;
 201
 202     c->playback.memblock_index += (size_t) r;
 203
 204     pa_asyncmsgq_post(c->sink_input->sink->asyncmsgq, PA_MSGOBJECT(c->sink_input), SINK_INPUT_MESSAGE_POST_DATA, NULL, 0, &chunk, NULL);
 205     pa_atomic_sub(&c->playback.missing, (int) r);
 206
 207     return 0;
 208 }
 209
 210 static int do_write(connection *c) {
 211     pa_memchunk chunk;
 212     ssize_t r;
 213     void *p;
 214
 215     connection_assert_ref(c);
 216
 217     if (!c->source_output)
 218         return 0;
 219
 220     if (pa_memblockq_peek(c->output_memblockq, &chunk) < 0) {
 221 /*         pa_log("peek failed"); */
 222         return 0;
 223     }
 224
 225     pa_assert(chunk.memblock);
 226     pa_assert(chunk.length);
 227
 228     p = pa_memblock_acquire(chunk.memblock);
 229     r = pa_iochannel_write(c->io, (uint8_t*) p+chunk.index, chunk.length);
 230     pa_memblock_release(chunk.memblock);
 231
 232     pa_memblock_unref(chunk.memblock);
 233
 234     if (r < 0) {
 235
 236         if (errno == EINTR || errno == EAGAIN)
 237             return 0;
 238
 239         pa_log("write(): %s", pa_cstrerror(errno));
 240         return -1;
 241     }
 242
 243     pa_memblockq_drop(c->output_memblockq, (size_t) r);
 244
 245     return 0;
 246 }
 247
 248 static void do_work(connection *c) {
 249     connection_assert_ref(c);
 250
 251     if (c->dead)
 252         return;
 253
 254     if (pa_iochannel_is_readable(c->io))
 255         if (do_read(c) < 0)
 256             goto fail;
 257
 258     if (!c->sink_input && pa_iochannel_is_hungup(c->io))
 259         goto fail;
 260
 261     if (pa_iochannel_is_writable(c->io))
 262         if (do_write(c) < 0)
 263             goto fail;
 264
 265     return;
 266
 267 fail:
 268
 269     if (c->sink_input) {
 270
 271         /* If there is a sink input, we first drain what we already have read before shutting down the connection */
 272         c->dead = TRUE;
 273
 274         pa_iochannel_free(c->io);
 275         c->io = NULL;
 276
 277         pa_asyncmsgq_post(c->sink_input->sink->asyncmsgq, PA_MSGOBJECT(c->sink_input), SINK_INPUT_MESSAGE_DISABLE_PREBUF, NULL, 0, NULL, NULL);
 278     } else
 279         connection_unlink(c);
 280 }
 281
 282 static int connection_process_msg(pa_msgobject *o, int code, void*userdata, int64_t offset, pa_memchunk *chunk) {
 283     connection *c = CONNECTION(o);
 284     connection_assert_ref(c);
 285
 286     switch (code) {
 287         case CONNECTION_MESSAGE_REQUEST_DATA:
 288             do_work(c);
 289             break;
 290
 291         case CONNECTION_MESSAGE_POST_DATA:
 292 /*             pa_log("got data %u", chunk->length); */
 293             pa_memblockq_push_align(c->output_memblockq, chunk);
 294             do_work(c);
 295             break;
 296
 297         case CONNECTION_MESSAGE_UNLINK_CONNECTION:
 298             connection_unlink(c);
 299             break;
 300     }
 301
 302     return 0;
 303 }
 304
 305 /*** sink_input callbacks ***/
 306
 307 /* Called from thread context */
 308 static int sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
 309     pa_sink_input *i = PA_SINK_INPUT(o);
 310     connection*c;
 311
 312     pa_sink_input_assert_ref(i);
 313     c = CONNECTION(i->userdata);
 314     connection_assert_ref(c);
 315
 316     switch (code) {
 317
 318         case SINK_INPUT_MESSAGE_POST_DATA: {
 319             pa_assert(chunk);
 320
 321             /* New data from the main loop */
 322             pa_memblockq_push_align(c->input_memblockq, chunk);
 323
 324             if (pa_memblockq_is_readable(c->input_memblockq) && c->playback.underrun) {
 325                 pa_log_debug("Requesting rewind due to end of underrun.");
 326                 pa_sink_input_request_rewind(c->sink_input, 0, FALSE, TRUE, FALSE);
 327             }
 328
 329 /*             pa_log("got data, %u", pa_memblockq_get_length(c->input_memblockq)); */
 330
 331             return 0;
 332         }
 333
 334         case SINK_INPUT_MESSAGE_DISABLE_PREBUF:
 335             pa_memblockq_prebuf_disable(c->input_memblockq);
 336             return 0;
 337
 338         case PA_SINK_INPUT_MESSAGE_GET_LATENCY: {
 339             pa_usec_t *r = userdata;
 340
 341             *r = pa_bytes_to_usec(pa_memblockq_get_length(c->input_memblockq), &c->sink_input->sample_spec);
 342
 343             /* Fall through, the default handler will add in the extra
 344              * latency added by the resampler */
 345         }
 346
 347         default:
 348             return pa_sink_input_process_msg(o, code, userdata, offset, chunk);
 349     }
 350 }
 351
 352 /* Called from thread context */
 353 static int sink_input_pop_cb(pa_sink_input *i, size_t length, pa_memchunk *chunk) {
 354     connection *c;
 355
 356     pa_sink_input_assert_ref(i);
 357     c = CONNECTION(i->userdata);
 358     connection_assert_ref(c);
 359     pa_assert(chunk);
 360
 361     if (pa_memblockq_peek(c->input_memblockq, chunk) < 0) {
 362
 363         c->playback.underrun = TRUE;
 364
 365         if (c->dead && pa_sink_input_safe_to_remove(i))
 366             pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(c), CONNECTION_MESSAGE_UNLINK_CONNECTION, NULL, 0, NULL, NULL);
 367
 368         return -1;
 369     } else {
 370         size_t m;
 371
 372         chunk->length = PA_MIN(length, chunk->length);
 373
 374         c->playback.underrun = FALSE;
 375
 376         pa_memblockq_drop(c->input_memblockq, chunk->length);
 377         m = pa_memblockq_pop_missing(c->input_memblockq);
 378
 379         if (m > 0)
 380             if (pa_atomic_add(&c->playback.missing, (int) m) <= 0)
 381                 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(c), CONNECTION_MESSAGE_REQUEST_DATA, NULL, 0, NULL, NULL);
 382
 383         return 0;
 384     }
 385 }
 386
 387 /* Called from thread context */
 388 static void sink_input_process_rewind_cb(pa_sink_input *i, size_t nbytes) {
 389     connection *c;
 390
 391     pa_sink_input_assert_ref(i);
 392     c = CONNECTION(i->userdata);
 393     connection_assert_ref(c);
 394
 395     /* If we are in an underrun, then we don't rewind */
 396     if (i->thread_info.underrun_for > 0)
 397         return;
 398
 399     pa_memblockq_rewind(c->input_memblockq, nbytes);
 400 }
 401
 402 /* Called from thread context */
 403 static void sink_input_update_max_rewind_cb(pa_sink_input *i, size_t nbytes) {
 404     connection *c;
 405
 406     pa_sink_input_assert_ref(i);
 407     c = CONNECTION(i->userdata);
 408     connection_assert_ref(c);
 409
 410     pa_memblockq_set_maxrewind(c->input_memblockq, nbytes);
 411 }
 412
 413 /* Called from main context */
 414 static void sink_input_kill_cb(pa_sink_input *i) {
 415     pa_sink_input_assert_ref(i);
 416
 417     connection_unlink(CONNECTION(i->userdata));
 418 }
 419
 420 /*** source_output callbacks ***/
 421
 422 /* Called from thread context */
 423 static void source_output_push_cb(pa_source_output *o, const pa_memchunk *chunk) {
 424     connection *c;
 425
 426     pa_source_output_assert_ref(o);
 427     c = CONNECTION(o->userdata);
 428     pa_assert(c);
 429     pa_assert(chunk);
 430
 431     pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(c), CONNECTION_MESSAGE_POST_DATA, NULL, 0, chunk, NULL);
 432 }
 433
 434 /* Called from main context */
 435 static void source_output_kill_cb(pa_source_output *o) {
 436     pa_source_output_assert_ref(o);
 437
 438     connection_unlink(CONNECTION(o->userdata));
 439 }
 440
 441 /* Called from main context */
 442 static pa_usec_t source_output_get_latency_cb(pa_source_output *o) {
 443     connection*c;
 444
 445     pa_source_output_assert_ref(o);
 446     c = CONNECTION(o->userdata);
 447     pa_assert(c);
 448
 449     return pa_bytes_to_usec(pa_memblockq_get_length(c->output_memblockq), &c->source_output->sample_spec);
 450 }
 451
 452 /*** client callbacks ***/
 453
 454 static void client_kill_cb(pa_client *client) {
 455     connection*c;
 456
 457     pa_assert(client);
 458     c = CONNECTION(client->userdata);
 459     pa_assert(c);
 460
 461     connection_unlink(c);
 462 }
 463
 464 /*** pa_iochannel callbacks ***/
 465
 466 static void io_callback(pa_iochannel*io, void *userdata) {
 467     connection *c = CONNECTION(userdata);
 468
 469     connection_assert_ref(c);
 470     pa_assert(io);
 471
 472     do_work(c);
 473 }
 474
 475 /*** socket_server callbacks ***/
 476
 477 void pa_simple_protocol_connect(pa_simple_protocol *p, pa_iochannel *io, pa_simple_options *o) {
 478     connection *c = NULL;
 479     char pname[128];
 480     pa_client_new_data client_data;
 481
 482     pa_assert(p);
 483     pa_assert(io);
 484     pa_assert(o);
 485
 486     if (pa_idxset_size(p->connections)+1 > MAX_CONNECTIONS) {
 487         pa_log("Warning! Too many connections (%u), dropping incoming connection.", MAX_CONNECTIONS);
 488         pa_iochannel_free(io);
 489         return;
 490     }
 491
 492     c = pa_msgobject_new(connection);
 493     c->parent.parent.free = connection_free;
 494     c->parent.process_msg = connection_process_msg;
 495     c->io = io;
 496     pa_iochannel_set_callback(c->io, io_callback, c);
 497
 498     c->sink_input = NULL;
 499     c->source_output = NULL;
 500     c->input_memblockq = c->output_memblockq = NULL;
 501     c->protocol = p;
 502     c->options = pa_simple_options_ref(o);
 503     c->playback.current_memblock = NULL;
 504     c->playback.memblock_index = 0;
 505     c->dead = FALSE;
 506     c->playback.underrun = TRUE;
 507     pa_atomic_store(&c->playback.missing, 0);
 508
 509     pa_client_new_data_init(&client_data);
 510     client_data.module = o->module;
 511     client_data.driver = __FILE__;
 512     pa_iochannel_socket_peer_to_string(io, pname, sizeof(pname));
 513     pa_proplist_setf(client_data.proplist, PA_PROP_APPLICATION_NAME, "Simple client (%s)", pname);
 514     pa_proplist_sets(client_data.proplist, "simple-protocol.peer", pname);
 515     c->client = pa_client_new(p->core, &client_data);
 516     pa_client_new_data_done(&client_data);
 517
 518     if (!c->client)
 519         goto fail;
 520
 521     c->client->kill = client_kill_cb;
 522     c->client->userdata = c;
 523
 524     if (o->playback) {
 525         pa_sink_input_new_data data;
 526         size_t l;
 527         pa_sink *sink;
 528
 529         if (!(sink = pa_namereg_get(c->protocol->core, o->default_sink, PA_NAMEREG_SINK))) {
 530             pa_log("Failed to get sink.");
 531             goto fail;
 532         }
 533
 534         pa_sink_input_new_data_init(&data);
 535         data.driver = __FILE__;
 536         data.module = o->module;
 537         data.client = c->client;
 538         data.sink = sink;
 539         pa_proplist_update(data.proplist, PA_UPDATE_MERGE, c->client->proplist);
 540         pa_sink_input_new_data_set_sample_spec(&data, &o->sample_spec);
 541
 542         pa_sink_input_new(&c->sink_input, p->core, &data, 0);
 543         pa_sink_input_new_data_done(&data);
 544
 545         if (!c->sink_input) {
 546             pa_log("Failed to create sink input.");
 547             goto fail;
 548         }
 549
 550         c->sink_input->parent.process_msg = sink_input_process_msg;
 551         c->sink_input->pop = sink_input_pop_cb;
 552         c->sink_input->process_rewind = sink_input_process_rewind_cb;
 553         c->sink_input->update_max_rewind = sink_input_update_max_rewind_cb;
 554         c->sink_input->kill = sink_input_kill_cb;
 555         c->sink_input->userdata = c;
 556
 557         pa_sink_input_set_requested_latency(c->sink_input, DEFAULT_SINK_LATENCY);
 558
 559         l = (size_t) ((double) pa_bytes_per_second(&o->sample_spec)*PLAYBACK_BUFFER_SECONDS);
 560         c->input_memblockq = pa_memblockq_new(
 561                 0,
 562                 l,
 563                 l,
 564                 pa_frame_size(&o->sample_spec),
 565                 (size_t) -1,
 566                 l/PLAYBACK_BUFFER_FRAGMENTS,
 567                 0,
 568                 NULL);
 569         pa_iochannel_socket_set_rcvbuf(io, l);
 570
 571         pa_atomic_store(&c->playback.missing, (int) pa_memblockq_missing(c->input_memblockq));
 572
 573         pa_sink_input_put(c->sink_input);
 574     }
 575
 576     if (o->record) {
 577         pa_source_output_new_data data;
 578         size_t l;
 579         pa_source *source;
 580
 581         if (!(source = pa_namereg_get(c->protocol->core, o->default_source, PA_NAMEREG_SOURCE))) {
 582             pa_log("Failed to get source.");
 583             goto fail;
 584         }
 585
 586         pa_source_output_new_data_init(&data);
 587         data.driver = __FILE__;
 588         data.module = o->module;
 589         data.client = c->client;
 590         data.source = source;
 591         pa_proplist_update(data.proplist, PA_UPDATE_MERGE, c->client->proplist);
 592         pa_source_output_new_data_set_sample_spec(&data, &o->sample_spec);
 593
 594         pa_source_output_new(&c->source_output, p->core, &data, 0);
 595         pa_source_output_new_data_done(&data);
 596
 597         if (!c->source_output) {
 598             pa_log("Failed to create source output.");
 599             goto fail;
 600         }
 601         c->source_output->push = source_output_push_cb;
 602         c->source_output->kill = source_output_kill_cb;
 603         c->source_output->get_latency = source_output_get_latency_cb;
 604         c->source_output->userdata = c;
 605
 606         pa_source_output_set_requested_latency(c->source_output, DEFAULT_SOURCE_LATENCY);
 607
 608         l = (size_t) (pa_bytes_per_second(&o->sample_spec)*RECORD_BUFFER_SECONDS);
 609         c->output_memblockq = pa_memblockq_new(
 610                 0,
 611                 l,
 612                 0,
 613                 pa_frame_size(&o->sample_spec),
 614                 1,
 615                 0,
 616                 0,
 617                 NULL);
 618         pa_iochannel_socket_set_sndbuf(io, l);
 619
 620         pa_source_output_put(c->source_output);
 621     }
 622
 623     pa_idxset_put(p->connections, c, NULL);
 624
 625     return;
 626
 627 fail:
 628     if (c)
 629         connection_unlink(c);
 630 }
 631
 632 void pa_simple_protocol_disconnect(pa_simple_protocol *p, pa_module *m) {
 633     connection *c;
 634     void *state = NULL;
 635
 636     pa_assert(p);
 637     pa_assert(m);
 638
 639     while ((c = pa_idxset_iterate(p->connections, &state, NULL)))
 640         if (c->options->module == m)
 641             connection_unlink(c);
 642 }
 643
 644 static pa_simple_protocol* simple_protocol_new(pa_core *c) {
 645     pa_simple_protocol *p;
 646
 647     pa_assert(c);
 648
 649     p = pa_xnew(pa_simple_protocol, 1);
 650     PA_REFCNT_INIT(p);
 651     p->core = c;
 652     p->connections = pa_idxset_new(NULL, NULL);
 653
 654     pa_assert_se(pa_shared_set(c, "simple-protocol", p) >= 0);
 655
 656     return p;
 657 }
 658
 659 pa_simple_protocol* pa_simple_protocol_get(pa_core *c) {
 660     pa_simple_protocol *p;
 661
 662     if ((p = pa_shared_get(c, "simple-protocol")))
 663         return pa_simple_protocol_ref(p);
 664
 665     return simple_protocol_new(c);
 666 }
 667
 668 pa_simple_protocol* pa_simple_protocol_ref(pa_simple_protocol *p) {
 669     pa_assert(p);
 670     pa_assert(PA_REFCNT_VALUE(p) >= 1);
 671
 672     PA_REFCNT_INC(p);
 673
 674     return p;
 675 }
 676
 677 void pa_simple_protocol_unref(pa_simple_protocol *p) {
 678     connection *c;
 679     pa_assert(p);
 680     pa_assert(PA_REFCNT_VALUE(p) >= 1);
 681
 682     if (PA_REFCNT_DEC(p) > 0)
 683         return;
 684
 685     while ((c = pa_idxset_first(p->connections, NULL)))
 686         connection_unlink(c);
 687
 688     pa_idxset_free(p->connections, NULL, NULL);
 689
 690     pa_assert_se(pa_shared_remove(p->core, "simple-protocol") >= 0);
 691
 692     pa_xfree(p);
 693 }
 694
 695 pa_simple_options* pa_simple_options_new(void) {
 696     pa_simple_options *o;
 697
 698     o = pa_xnew0(pa_simple_options, 1);
 699     PA_REFCNT_INIT(o);
 700
 701     o->record = FALSE;
 702     o->playback = TRUE;
 703
 704     return o;
 705 }
 706
 707 pa_simple_options* pa_simple_options_ref(pa_simple_options *o) {
 708     pa_assert(o);
 709     pa_assert(PA_REFCNT_VALUE(o) >= 1);
 710
 711     PA_REFCNT_INC(o);
 712
 713     return o;
 714 }
 715
 716 void pa_simple_options_unref(pa_simple_options *o) {
 717     pa_assert(o);
 718     pa_assert(PA_REFCNT_VALUE(o) >= 1);
 719
 720     if (PA_REFCNT_DEC(o) > 0)
 721         return;
 722
 723     pa_xfree(o->default_sink);
 724     pa_xfree(o->default_source);
 725
 726     pa_xfree(o);
 727 }
 728
 729 int pa_simple_options_parse(pa_simple_options *o, pa_core *c, pa_modargs *ma) {
 730     pa_bool_t enabled;
 731
 732     pa_assert(o);
 733     pa_assert(PA_REFCNT_VALUE(o) >= 1);
 734     pa_assert(ma);
 735
 736     o->sample_spec = c->default_sample_spec;
 737     if (pa_modargs_get_sample_spec_and_channel_map(ma, &o->sample_spec, &o->channel_map, PA_CHANNEL_MAP_DEFAULT) < 0) {
 738         pa_log("Failed to parse sample type specification.");
 739         return -1;
 740     }
 741
 742     pa_xfree(o->default_source);
 743     o->default_source = pa_xstrdup(pa_modargs_get_value(ma, "source", NULL));
 744
 745     pa_xfree(o->default_sink);
 746     o->default_sink = pa_xstrdup(pa_modargs_get_value(ma, "sink", NULL));
 747
 748     enabled = o->record;
 749     if (pa_modargs_get_value_boolean(ma, "record", &enabled) < 0) {
 750         pa_log("record= expects a boolean argument.");
 751         return -1;
 752     }
 753     o->record = enabled;
 754
 755     enabled = o->playback;
 756     if (pa_modargs_get_value_boolean(ma, "playback", &enabled) < 0) {
 757         pa_log("playback= expects a boolean argument.");
 758         return -1;
 759     }
 760     o->playback = enabled;
 761
 762     if (!o->playback && !o->record) {
 763         pa_log("neither playback nor recording enabled for protocol.");
 764         return -1;
 765     }
 766
 767     return 0;
 768 }