4 This file is part of PulseAudio.
6 Copyright 2004-2006 Lennart Poettering
7 Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
9 PulseAudio is free software; you can redistribute it and/or modify
10 it under the terms of the GNU Lesser General Public License as published
11 by the Free Software Foundation; either version 2 of the License,
12 or (at your option) any later version.
14 PulseAudio is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 General Public License for more details.
19 You should have received a copy of the GNU Lesser General Public License
20 along with PulseAudio; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
33 #include <sys/types.h>
37 #include <pulse/timeval.h>
38 #include <pulse/util.h>
39 #include <pulse/version.h>
40 #include <pulse/xmalloc.h>
42 #include <pulsecore/module.h>
43 #include <pulsecore/core-util.h>
44 #include <pulsecore/modargs.h>
45 #include <pulsecore/log.h>
46 #include <pulsecore/core-subscribe.h>
47 #include <pulsecore/sink-input.h>
48 #include <pulsecore/pdispatch.h>
49 #include <pulsecore/pstream.h>
50 #include <pulsecore/pstream-util.h>
51 #include <pulsecore/authkey.h>
52 #include <pulsecore/socket-client.h>
53 #include <pulsecore/socket-util.h>
54 #include <pulsecore/authkey-prop.h>
57 #include "module-tunnel-sink-symdef.h"
58 PA_MODULE_DESCRIPTION("Tunnel module for sinks")
61 "sink=<remote sink name> "
63 "format=<sample format> "
64 "channels=<number of channels> "
66 "sink_name=<name for the local sink> "
67 "channel_map=<channel map>")
69 #include "module-tunnel-source-symdef.h"
70 PA_MODULE_DESCRIPTION("Tunnel module for sources")
73 "source=<remote source name> "
75 "format=<sample format> "
76 "channels=<number of channels> "
78 "source_name=<name for the local source> "
79 "channel_map=<channel map>")
82 PA_MODULE_AUTHOR("Lennart Poettering")
83 PA_MODULE_VERSION(PACKAGE_VERSION)
85 #define DEFAULT_TLENGTH (44100*2*2/10) //(10240*8)
86 #define DEFAULT_MAXLENGTH ((DEFAULT_TLENGTH*3)/2)
87 #define DEFAULT_MINREQ 512
88 #define DEFAULT_PREBUF (DEFAULT_TLENGTH-DEFAULT_MINREQ)
89 #define DEFAULT_FRAGSIZE 1024
91 #define DEFAULT_TIMEOUT 5
93 #define LATENCY_INTERVAL 10
95 static const char* const valid_modargs[] = {
112 static void command_stream_killed(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
113 static void command_subscribe_event(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
116 static void command_request(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
119 static const pa_pdispatch_cb_t command_table[PA_COMMAND_MAX] = {
121 [PA_COMMAND_REQUEST] = command_request,
123 [PA_COMMAND_PLAYBACK_STREAM_KILLED] = command_stream_killed,
124 [PA_COMMAND_RECORD_STREAM_KILLED] = command_stream_killed,
125 [PA_COMMAND_SUBSCRIBE_EVENT] = command_subscribe_event,
129 pa_socket_client *client;
131 pa_pdispatch *pdispatch;
137 uint32_t requested_bytes;
146 uint8_t auth_cookie[PA_NATIVE_COOKIE_LENGTH];
150 uint32_t device_index;
153 pa_usec_t host_latency;
155 pa_time_event *time_event;
157 int auth_cookie_in_property;
160 static void close_stuff(struct userdata *u) {
164 pa_pstream_close(u->pstream);
165 pa_pstream_unref(u->pstream);
170 pa_pdispatch_unref(u->pdispatch);
175 pa_socket_client_unref(u->client);
181 pa_sink_disconnect(u->sink);
182 pa_sink_unref(u->sink);
187 pa_source_disconnect(u->source);
188 pa_source_unref(u->source);
194 u->core->mainloop->time_free(u->time_event);
195 u->time_event = NULL;
199 static void die(struct userdata *u) {
202 pa_module_unload_request(u->module);
205 static void command_stream_killed(pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
206 struct userdata *u = userdata;
207 assert(pd && t && u && u->pdispatch == pd);
209 pa_log("stream killed");
213 static void request_info(struct userdata *u);
215 static void command_subscribe_event(pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
216 struct userdata *u = userdata;
217 pa_subscription_event_type_t e;
220 assert(pd && t && u);
221 assert(command == PA_COMMAND_SUBSCRIBE_EVENT);
223 if (pa_tagstruct_getu32(t, &e) < 0 ||
224 pa_tagstruct_getu32(t, &idx) < 0 ||
225 !pa_tagstruct_eof(t)) {
226 pa_log("invalid protocol reply");
232 if (e != (PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE))
235 if (e != (PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE))
243 static void send_prebuf_request(struct userdata *u) {
246 t = pa_tagstruct_new(NULL, 0);
247 pa_tagstruct_putu32(t, PA_COMMAND_PREBUF_PLAYBACK_STREAM);
248 pa_tagstruct_putu32(t, u->ctag++);
249 pa_tagstruct_putu32(t, u->channel);
250 pa_pstream_send_tagstruct(u->pstream, t);
253 static void send_bytes(struct userdata *u) {
259 while (u->requested_bytes > 0) {
261 if (pa_sink_render(u->sink, u->requested_bytes, &chunk) < 0) {
263 if (u->requested_bytes >= DEFAULT_TLENGTH-DEFAULT_PREBUF)
264 send_prebuf_request(u);
269 pa_pstream_send_memblock(u->pstream, u->channel, 0, PA_SEEK_RELATIVE, &chunk);
270 pa_memblock_unref(chunk.memblock);
272 /* pa_log("sent %lu", (unsigned long) chunk.length); */
274 if (chunk.length > u->requested_bytes)
275 u->requested_bytes = 0;
277 u->requested_bytes -= chunk.length;
281 static void command_request(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
282 struct userdata *u = userdata;
283 uint32_t bytes, channel;
284 assert(pd && command == PA_COMMAND_REQUEST && t && u && u->pdispatch == pd);
286 if (pa_tagstruct_getu32(t, &channel) < 0 ||
287 pa_tagstruct_getu32(t, &bytes) < 0 ||
288 !pa_tagstruct_eof(t)) {
289 pa_log("invalid protocol reply");
294 if (channel != u->channel) {
295 pa_log("recieved data for invalid channel");
300 u->requested_bytes += bytes;
306 static void stream_get_latency_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
307 struct userdata *u = userdata;
308 pa_usec_t sink_usec, source_usec, transport_usec;
310 int64_t write_index, read_index;
311 struct timeval local, remote, now;
314 if (command != PA_COMMAND_REPLY) {
315 if (command == PA_COMMAND_ERROR)
316 pa_log("failed to get latency.");
318 pa_log("protocol error.");
323 if (pa_tagstruct_get_usec(t, &sink_usec) < 0 ||
324 pa_tagstruct_get_usec(t, &source_usec) < 0 ||
325 pa_tagstruct_get_boolean(t, &playing) < 0 ||
326 pa_tagstruct_get_timeval(t, &local) < 0 ||
327 pa_tagstruct_get_timeval(t, &remote) < 0 ||
328 pa_tagstruct_gets64(t, &write_index) < 0 ||
329 pa_tagstruct_gets64(t, &read_index) < 0 ||
330 !pa_tagstruct_eof(t)) {
331 pa_log("invalid reply. (latency)");
336 pa_gettimeofday(&now);
338 /* FIXME! This could use some serious love. */
340 if (pa_timeval_cmp(&local, &remote) < 0 && pa_timeval_cmp(&remote, &now)) {
341 /* local and remote seem to have synchronized clocks */
343 transport_usec = pa_timeval_diff(&remote, &local);
345 transport_usec = pa_timeval_diff(&now, &remote);
348 transport_usec = pa_timeval_diff(&now, &local)/2;
351 u->host_latency = sink_usec + transport_usec;
353 u->host_latency = source_usec + transport_usec;
354 if (u->host_latency > sink_usec)
355 u->host_latency -= sink_usec;
360 /* pa_log("estimated host latency: %0.0f usec", (double) u->host_latency); */
363 static void request_latency(struct userdata *u) {
369 t = pa_tagstruct_new(NULL, 0);
371 pa_tagstruct_putu32(t, PA_COMMAND_GET_PLAYBACK_LATENCY);
373 pa_tagstruct_putu32(t, PA_COMMAND_GET_RECORD_LATENCY);
375 pa_tagstruct_putu32(t, tag = u->ctag++);
376 pa_tagstruct_putu32(t, u->channel);
378 pa_gettimeofday(&now);
379 pa_tagstruct_put_timeval(t, &now);
381 pa_pstream_send_tagstruct(u->pstream, t);
382 pa_pdispatch_register_reply(u->pdispatch, tag, DEFAULT_TIMEOUT, stream_get_latency_callback, u, NULL);
385 static void stream_get_info_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
386 struct userdata *u = userdata;
387 uint32_t idx, owner_module, monitor_source;
389 const char *name, *description, *monitor_source_name, *driver;
392 pa_sample_spec sample_spec;
393 pa_channel_map channel_map;
397 if (command != PA_COMMAND_REPLY) {
398 if (command == PA_COMMAND_ERROR)
399 pa_log("failed to get info.");
401 pa_log("protocol error.");
406 if (pa_tagstruct_getu32(t, &idx) < 0 ||
407 pa_tagstruct_gets(t, &name) < 0 ||
408 pa_tagstruct_gets(t, &description) < 0 ||
409 pa_tagstruct_get_sample_spec(t, &sample_spec) < 0 ||
410 pa_tagstruct_get_channel_map(t, &channel_map) < 0 ||
411 pa_tagstruct_getu32(t, &owner_module) < 0 ||
412 pa_tagstruct_get_cvolume(t, &volume) < 0 ||
413 pa_tagstruct_get_boolean(t, &mute) < 0 ||
414 pa_tagstruct_getu32(t, &monitor_source) < 0 ||
415 pa_tagstruct_gets(t, &monitor_source_name) < 0 ||
416 pa_tagstruct_get_usec(t, &latency) < 0 ||
417 pa_tagstruct_gets(t, &driver) < 0 ||
418 pa_tagstruct_getu32(t, &flags) < 0 ||
419 !pa_tagstruct_eof(t)) {
420 pa_log("invalid reply. (get_info)");
427 if ((!!mute == !!u->sink->hw_muted) &&
428 pa_cvolume_equal(&volume, &u->sink->hw_volume))
432 if ((!!mute == !!u->source->hw_muted) &&
433 pa_cvolume_equal(&volume, &u->source->hw_volume))
438 memcpy(&u->sink->hw_volume, &volume, sizeof(pa_cvolume));
439 u->sink->hw_muted = !!mute;
441 pa_subscription_post(u->sink->core,
442 PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE,
445 memcpy(&u->source->hw_volume, &volume, sizeof(pa_cvolume));
446 u->source->hw_muted = !!mute;
448 pa_subscription_post(u->source->core,
449 PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE,
454 static void request_info(struct userdata *u) {
459 t = pa_tagstruct_new(NULL, 0);
461 pa_tagstruct_putu32(t, PA_COMMAND_GET_SINK_INFO);
463 pa_tagstruct_putu32(t, PA_COMMAND_GET_SOURCE_INFO);
465 pa_tagstruct_putu32(t, tag = u->ctag++);
467 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
469 pa_tagstruct_puts(t, u->sink_name);
471 pa_tagstruct_puts(t, u->source_name);
474 pa_pstream_send_tagstruct(u->pstream, t);
475 pa_pdispatch_register_reply(u->pdispatch, tag, DEFAULT_TIMEOUT, stream_get_info_callback, u, NULL);
478 static void start_subscribe(struct userdata *u) {
483 t = pa_tagstruct_new(NULL, 0);
484 pa_tagstruct_putu32(t, PA_COMMAND_SUBSCRIBE);
485 pa_tagstruct_putu32(t, tag = u->ctag++);
488 pa_tagstruct_putu32(t, PA_SUBSCRIPTION_MASK_SINK);
490 pa_tagstruct_putu32(t, PA_SUBSCRIPTION_MASK_SOURCE);
493 pa_pstream_send_tagstruct(u->pstream, t);
496 static void timeout_callback(pa_mainloop_api *m, pa_time_event*e, PA_GCC_UNUSED const struct timeval *tv, void *userdata) {
497 struct userdata *u = userdata;
503 pa_gettimeofday(&ntv);
504 ntv.tv_sec += LATENCY_INTERVAL;
505 m->time_restart(e, &ntv);
508 static void create_stream_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
509 struct userdata *u = userdata;
511 assert(pd && u && u->pdispatch == pd);
513 if (command != PA_COMMAND_REPLY) {
514 if (command == PA_COMMAND_ERROR)
515 pa_log("failed to create stream.");
517 pa_log("protocol error.");
522 if (pa_tagstruct_getu32(t, &u->channel) < 0 ||
523 pa_tagstruct_getu32(t, &u->device_index) < 0
525 || pa_tagstruct_getu32(t, &u->requested_bytes) < 0
530 if (u->version >= 9) {
532 uint32_t maxlength, tlength, prebuf, minreq;
534 if (pa_tagstruct_getu32(t, &maxlength) < 0 ||
535 pa_tagstruct_getu32(t, &tlength) < 0 ||
536 pa_tagstruct_getu32(t, &prebuf) < 0 ||
537 pa_tagstruct_getu32(t, &minreq) < 0)
540 uint32_t maxlength, fragsize;
542 if (pa_tagstruct_getu32(t, &maxlength) < 0 ||
543 pa_tagstruct_getu32(t, &fragsize) < 0)
548 if (!pa_tagstruct_eof(t))
554 assert(!u->time_event);
555 pa_gettimeofday(&ntv);
556 ntv.tv_sec += LATENCY_INTERVAL;
557 u->time_event = u->core->mainloop->time_new(u->core->mainloop, &ntv, timeout_callback, u);
567 pa_log("invalid reply. (create stream)");
571 static void setup_complete_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
572 struct userdata *u = userdata;
574 char name[256], un[128], hn[128];
578 assert(pd && u && u->pdispatch == pd);
580 if (command != PA_COMMAND_REPLY ||
581 pa_tagstruct_getu32(t, &u->version) < 0 ||
582 !pa_tagstruct_eof(t)) {
583 if (command == PA_COMMAND_ERROR)
584 pa_log("failed to authenticate");
586 pa_log("protocol error.");
591 /* Minimum supported protocol version */
592 if (u->version < 8) {
593 pa_log("incompatible protocol version");
599 snprintf(name, sizeof(name), "Tunnel from host %s, user %s, sink %s",
600 pa_get_host_name(hn, sizeof(hn)),
601 pa_get_user_name(un, sizeof(un)),
604 snprintf(name, sizeof(name), "Tunnel from host %s, user %s, source %s",
605 pa_get_host_name(hn, sizeof(hn)),
606 pa_get_user_name(un, sizeof(un)),
610 reply = pa_tagstruct_new(NULL, 0);
611 pa_tagstruct_putu32(reply, PA_COMMAND_SET_CLIENT_NAME);
612 pa_tagstruct_putu32(reply, tag = u->ctag++);
613 pa_tagstruct_puts(reply, name);
614 pa_pstream_send_tagstruct(u->pstream, reply);
615 /* We ignore the server's reply here */
617 reply = pa_tagstruct_new(NULL, 0);
619 pa_tagstruct_putu32(reply, PA_COMMAND_CREATE_PLAYBACK_STREAM);
620 pa_tagstruct_putu32(reply, tag = u->ctag++);
621 pa_tagstruct_puts(reply, name);
622 pa_tagstruct_put_sample_spec(reply, &u->sink->sample_spec);
623 pa_tagstruct_put_channel_map(reply, &u->sink->channel_map);
624 pa_tagstruct_putu32(reply, PA_INVALID_INDEX);
625 pa_tagstruct_puts(reply, u->sink_name);
626 pa_tagstruct_putu32(reply, DEFAULT_MAXLENGTH);
627 pa_tagstruct_put_boolean(reply, 0);
628 pa_tagstruct_putu32(reply, DEFAULT_TLENGTH);
629 pa_tagstruct_putu32(reply, DEFAULT_PREBUF);
630 pa_tagstruct_putu32(reply, DEFAULT_MINREQ);
631 pa_tagstruct_putu32(reply, 0);
632 pa_cvolume_reset(&volume, u->sink->sample_spec.channels);
633 pa_tagstruct_put_cvolume(reply, &volume);
635 pa_tagstruct_putu32(reply, PA_COMMAND_CREATE_RECORD_STREAM);
636 pa_tagstruct_putu32(reply, tag = u->ctag++);
637 pa_tagstruct_puts(reply, name);
638 pa_tagstruct_put_sample_spec(reply, &u->source->sample_spec);
639 pa_tagstruct_put_channel_map(reply, &u->source->channel_map);
640 pa_tagstruct_putu32(reply, PA_INVALID_INDEX);
641 pa_tagstruct_puts(reply, u->source_name);
642 pa_tagstruct_putu32(reply, DEFAULT_MAXLENGTH);
643 pa_tagstruct_put_boolean(reply, 0);
644 pa_tagstruct_putu32(reply, DEFAULT_FRAGSIZE);
647 pa_pstream_send_tagstruct(u->pstream, reply);
648 pa_pdispatch_register_reply(u->pdispatch, tag, DEFAULT_TIMEOUT, create_stream_callback, u, NULL);
651 static void pstream_die_callback(pa_pstream *p, void *userdata) {
652 struct userdata *u = userdata;
655 pa_log("stream died.");
659 static void pstream_packet_callback(pa_pstream *p, pa_packet *packet, const pa_creds *creds, void *userdata) {
660 struct userdata *u = userdata;
661 assert(p && packet && u);
663 if (pa_pdispatch_run(u->pdispatch, packet, creds, u) < 0) {
664 pa_log("invalid packet");
670 static void pstream_memblock_callback(pa_pstream *p, uint32_t channel, PA_GCC_UNUSED int64_t offset, PA_GCC_UNUSED pa_seek_mode_t seek, const pa_memchunk *chunk, void *userdata) {
671 struct userdata *u = userdata;
672 assert(p && chunk && u);
674 if (channel != u->channel) {
675 pa_log("recieved memory block on bad channel.");
680 pa_source_post(u->source, chunk);
684 static void on_connection(pa_socket_client *sc, pa_iochannel *io, void *userdata) {
685 struct userdata *u = userdata;
688 assert(sc && u && u->client == sc);
690 pa_socket_client_unref(u->client);
694 pa_log("connection failed.");
695 pa_module_unload_request(u->module);
699 u->pstream = pa_pstream_new(u->core->mainloop, io, u->core->mempool);
700 u->pdispatch = pa_pdispatch_new(u->core->mainloop, command_table, PA_COMMAND_MAX);
702 pa_pstream_set_die_callback(u->pstream, pstream_die_callback, u);
703 pa_pstream_set_recieve_packet_callback(u->pstream, pstream_packet_callback, u);
705 pa_pstream_set_recieve_memblock_callback(u->pstream, pstream_memblock_callback, u);
708 t = pa_tagstruct_new(NULL, 0);
709 pa_tagstruct_putu32(t, PA_COMMAND_AUTH);
710 pa_tagstruct_putu32(t, tag = u->ctag++);
711 pa_tagstruct_putu32(t, PA_PROTOCOL_VERSION);
712 pa_tagstruct_put_arbitrary(t, u->auth_cookie, sizeof(u->auth_cookie));
713 pa_pstream_send_tagstruct(u->pstream, t);
714 pa_pdispatch_register_reply(u->pdispatch, tag, DEFAULT_TIMEOUT, setup_complete_callback, u, NULL);
719 static void sink_notify(pa_sink*sink) {
721 assert(sink && sink->userdata);
727 static pa_usec_t sink_get_latency(pa_sink *sink) {
731 assert(sink && sink->userdata);
736 if (l > u->requested_bytes) {
737 l -= u->requested_bytes;
738 usec += pa_bytes_to_usec(l, &u->sink->sample_spec);
741 usec += u->host_latency;
746 static int sink_get_hw_volume(pa_sink *sink) {
748 assert(sink && sink->userdata);
754 static int sink_set_hw_volume(pa_sink *sink) {
758 assert(sink && sink->userdata);
761 t = pa_tagstruct_new(NULL, 0);
762 pa_tagstruct_putu32(t, PA_COMMAND_SET_SINK_VOLUME);
763 pa_tagstruct_putu32(t, tag = u->ctag++);
765 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
766 pa_tagstruct_puts(t, u->sink_name);
767 pa_tagstruct_put_cvolume(t, &sink->hw_volume);
768 pa_pstream_send_tagstruct(u->pstream, t);
773 static int sink_get_hw_mute(pa_sink *sink) {
775 assert(sink && sink->userdata);
781 static int sink_set_hw_mute(pa_sink *sink) {
785 assert(sink && sink->userdata);
788 t = pa_tagstruct_new(NULL, 0);
789 pa_tagstruct_putu32(t, PA_COMMAND_SET_SINK_MUTE);
790 pa_tagstruct_putu32(t, tag = u->ctag++);
792 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
793 pa_tagstruct_puts(t, u->sink_name);
794 pa_tagstruct_put_boolean(t, !!sink->hw_muted);
795 pa_pstream_send_tagstruct(u->pstream, t);
801 static pa_usec_t source_get_latency(pa_source *source) {
803 assert(source && source->userdata);
804 u = source->userdata;
806 return u->host_latency;
809 static int source_get_hw_volume(pa_source *source) {
811 assert(source && source->userdata);
812 u = source->userdata;
817 static int source_set_hw_volume(pa_source *source) {
821 assert(source && source->userdata);
822 u = source->userdata;
824 t = pa_tagstruct_new(NULL, 0);
825 pa_tagstruct_putu32(t, PA_COMMAND_SET_SOURCE_VOLUME);
826 pa_tagstruct_putu32(t, tag = u->ctag++);
828 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
829 pa_tagstruct_puts(t, u->source_name);
830 pa_tagstruct_put_cvolume(t, &source->hw_volume);
831 pa_pstream_send_tagstruct(u->pstream, t);
836 static int source_get_hw_mute(pa_source *source) {
838 assert(source && source->userdata);
839 u = source->userdata;
844 static int source_set_hw_mute(pa_source *source) {
848 assert(source && source->userdata);
849 u = source->userdata;
851 t = pa_tagstruct_new(NULL, 0);
852 pa_tagstruct_putu32(t, PA_COMMAND_SET_SOURCE_MUTE);
853 pa_tagstruct_putu32(t, tag = u->ctag++);
855 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
856 pa_tagstruct_puts(t, u->source_name);
857 pa_tagstruct_put_boolean(t, !!source->hw_muted);
858 pa_pstream_send_tagstruct(u->pstream, t);
864 static int load_key(struct userdata *u, const char*fn) {
867 u->auth_cookie_in_property = 0;
869 if (!fn && pa_authkey_prop_get(u->core, PA_NATIVE_COOKIE_PROPERTY_NAME, u->auth_cookie, sizeof(u->auth_cookie)) >= 0) {
870 pa_log_debug("using already loaded auth cookie.");
871 pa_authkey_prop_ref(u->core, PA_NATIVE_COOKIE_PROPERTY_NAME);
872 u->auth_cookie_in_property = 1;
877 fn = PA_NATIVE_COOKIE_FILE;
879 if (pa_authkey_load_auto(fn, u->auth_cookie, sizeof(u->auth_cookie)) < 0)
882 pa_log_debug("loading cookie from disk.");
884 if (pa_authkey_prop_put(u->core, PA_NATIVE_COOKIE_PROPERTY_NAME, u->auth_cookie, sizeof(u->auth_cookie)) >= 0)
885 u->auth_cookie_in_property = 1;
890 int pa__init(pa_core *c, pa_module*m) {
891 pa_modargs *ma = NULL;
892 struct userdata *u = NULL;
899 if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
900 pa_log("failed to parse module arguments");
904 u = pa_xmalloc(sizeof(struct userdata));
911 u->server_name = NULL;
913 u->sink_name = pa_xstrdup(pa_modargs_get_value(ma, "sink", NULL));;
915 u->requested_bytes = 0;
917 u->source_name = pa_xstrdup(pa_modargs_get_value(ma, "source", NULL));;
921 u->device_index = u->channel = PA_INVALID_INDEX;
923 u->auth_cookie_in_property = 0;
924 u->time_event = NULL;
926 if (load_key(u, pa_modargs_get_value(ma, "cookie", NULL)) < 0)
929 if (!(u->server_name = pa_xstrdup(pa_modargs_get_value(ma, "server", NULL)))) {
930 pa_log("no server specified.");
934 ss = c->default_sample_spec;
935 if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_DEFAULT) < 0) {
936 pa_log("invalid sample format specification");
940 if (!(u->client = pa_socket_client_new_string(c->mainloop, u->server_name, PA_NATIVE_DEFAULT_PORT))) {
941 pa_log("failed to connect to server '%s'", u->server_name);
948 pa_socket_client_set_callback(u->client, on_connection, u);
952 if (!(dn = pa_xstrdup(pa_modargs_get_value(ma, "sink_name", NULL))))
953 dn = pa_sprintf_malloc("tunnel.%s", u->server_name);
955 if (!(u->sink = pa_sink_new(c, __FILE__, dn, 0, &ss, &map))) {
956 pa_log("failed to create sink.");
960 u->sink->get_latency = sink_get_latency;
961 u->sink->get_hw_volume = sink_get_hw_volume;
962 u->sink->set_hw_volume = sink_set_hw_volume;
963 u->sink->get_hw_mute = sink_get_hw_mute;
964 u->sink->set_hw_mute = sink_set_hw_mute;
965 u->sink->notify = sink_notify;
966 u->sink->userdata = u;
967 pa_sink_set_description(u->sink, t = pa_sprintf_malloc("Tunnel to %s%s%s", u->sink_name ? u->sink_name : "", u->sink_name ? " on " : "", u->server_name));
970 pa_sink_set_owner(u->sink, m);
973 if (!(dn = pa_xstrdup(pa_modargs_get_value(ma, "source_name", NULL))))
974 dn = pa_sprintf_malloc("tunnel.%s", u->server_name);
976 if (!(u->source = pa_source_new(c, __FILE__, dn, 0, &ss, &map))) {
977 pa_log("failed to create source.");
981 u->source->get_latency = source_get_latency;
982 u->source->get_hw_volume = source_get_hw_volume;
983 u->source->set_hw_volume = source_set_hw_volume;
984 u->source->get_hw_mute = source_get_hw_mute;
985 u->source->set_hw_mute = source_set_hw_mute;
986 u->source->userdata = u;
988 pa_source_set_description(u->source, t = pa_sprintf_malloc("Tunnel to %s%s%s", u->source_name ? u->source_name : "", u->source_name ? " on " : "", u->server_name));
991 pa_source_set_owner(u->source, m);
996 u->time_event = NULL;
1006 pa_modargs_free(ma);
1013 void pa__done(pa_core *c, pa_module*m) {
1017 if (!(u = m->userdata))
1022 if (u->auth_cookie_in_property)
1023 pa_authkey_prop_unref(c, PA_NATIVE_COOKIE_PROPERTY_NAME);
1026 pa_xfree(u->sink_name);
1028 pa_xfree(u->source_name);
1030 pa_xfree(u->server_name);