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 pa_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 pa_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
);