[PATCH 13/25] raop: Code renaming for protocol specific IDs

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Rename the entire code so that protocol-specific identifiers have
`tcp_` and `udp_` prefix.
---
 src/modules/raop/module-raop-sink.c | 116 ++++++-------
 src/modules/raop/raop_client.c      | 318 ++++++++++++++++++------------------
 src/modules/raop/raop_client.h      |  20 +--
 3 files changed, 227 insertions(+), 227 deletions(-)

diff --git a/src/modules/raop/module-raop-sink.c b/src/modules/raop/module-raop-sink.c
index d9cbe7b..9a3bd59 100644
--- a/src/modules/raop/module-raop-sink.c
+++ b/src/modules/raop/module-raop-sink.c
@@ -113,11 +113,11 @@ struct userdata {
     size_t block_size;
 
     /* Members only for the TCP protocol */
-    int fd;
+    int tcp_fd;
 
     /* Members only for the UDP protocol */
-    int control_fd;
-    int timing_fd;
+    int udp_control_fd;
+    int udp_timing_fd;
 };
 
 static const char* const valid_modargs[] = {
@@ -134,26 +134,26 @@ static const char* const valid_modargs[] = {
 };
 
 enum {
-    SINK_MESSAGE_PASS_SOCKET = PA_SINK_MESSAGE_MAX,
-    SINK_MESSAGE_RIP_SOCKET,
-    SINK_MESSAGE_SETUP,
-    SINK_MESSAGE_RECORD,
-    SINK_MESSAGE_DISCONNECTED,
+    SINK_MESSAGE_TCP_PASS_SOCKET = PA_SINK_MESSAGE_MAX,
+    SINK_MESSAGE_TCP_RIP_SOCKET,
+    SINK_MESSAGE_UDP_SETUP,
+    SINK_MESSAGE_UDP_RECORD,
+    SINK_MESSAGE_UDP_DISCONNECTED,
 };
 
 /* Forward declarations: */
 static void sink_set_volume_cb(pa_sink *);
 
-static void on_connection(int fd, void *userdata) {
+static void tcp_on_connection(int fd, void *userdata) {
     int so_sndbuf = 0;
     socklen_t sl = sizeof(int);
     struct userdata *u = userdata;
     pa_assert(u);
 
-    pa_assert(u->fd < 0);
-    u->fd = fd;
+    pa_assert(u->tcp_fd < 0);
+    u->tcp_fd = fd;
 
-    if (getsockopt(u->fd, SOL_SOCKET, SO_SNDBUF, &so_sndbuf, &sl) < 0)
+    if (getsockopt(u->tcp_fd, SOL_SOCKET, SO_SNDBUF, &so_sndbuf, &sl) < 0)
         pa_log_warn("getsockopt(SO_SNDBUF) failed: %s", pa_cstrerror(errno));
     else {
         pa_log_debug("SO_SNDBUF is %zu.", (size_t) so_sndbuf);
@@ -165,16 +165,16 @@ static void on_connection(int fd, void *userdata) {
 
     pa_log_debug("Connection authenticated, handing fd to IO thread...");
 
-    pa_asyncmsgq_post(u->thread_mq.inq, PA_MSGOBJECT(u->sink), SINK_MESSAGE_PASS_SOCKET, NULL, 0, NULL, NULL);
+    pa_asyncmsgq_post(u->thread_mq.inq, PA_MSGOBJECT(u->sink), SINK_MESSAGE_TCP_PASS_SOCKET, NULL, 0, NULL, NULL);
 }
 
-static void on_close(void*userdata) {
+static void tcp_on_close(void*userdata) {
     struct userdata *u = userdata;
     pa_assert(u);
 
     pa_log_debug("Connection closed, informing IO thread...");
 
-    pa_asyncmsgq_post(u->thread_mq.inq, PA_MSGOBJECT(u->sink), SINK_MESSAGE_RIP_SOCKET, NULL, 0, NULL, NULL);
+    pa_asyncmsgq_post(u->thread_mq.inq, PA_MSGOBJECT(u->sink), SINK_MESSAGE_TCP_RIP_SOCKET, NULL, 0, NULL, NULL);
 }
 
 static pa_usec_t sink_get_latency(const struct userdata *u) {
@@ -201,7 +201,7 @@ static int tcp_sink_process_msg(pa_msgobject *o, int code, void *data, int64_t o
                     pa_smoother_pause(u->smoother, pa_rtclock_now());
 
                     /* Issue a FLUSH if we are connected. */
-                    if (u->fd >= 0) {
+                    if (u->tcp_fd >= 0) {
                         pa_raop_client_flush(u->raop);
                     }
                     break;
@@ -214,7 +214,7 @@ static int tcp_sink_process_msg(pa_msgobject *o, int code, void *data, int64_t o
 
                         /* The connection can be closed when idle, so check to
                          * see if we need to reestablish it. */
-                        if (u->fd < 0)
+                        if (u->tcp_fd < 0)
                             pa_raop_client_connect(u->raop);
                         else
                             pa_raop_client_flush(u->raop);
@@ -235,14 +235,14 @@ static int tcp_sink_process_msg(pa_msgobject *o, int code, void *data, int64_t o
             return 0;
         }
 
-        case SINK_MESSAGE_PASS_SOCKET: {
+        case SINK_MESSAGE_TCP_PASS_SOCKET: {
             struct pollfd *pollfd;
 
             pa_assert(!u->rtpoll_item);
 
             u->rtpoll_item = pa_rtpoll_item_new(u->rtpoll, PA_RTPOLL_NEVER, 1);
             pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
-            pollfd->fd = u->fd;
+            pollfd->fd = u->tcp_fd;
             pollfd->events = POLLOUT;
             /*pollfd->events = */pollfd->revents = 0;
 
@@ -253,10 +253,10 @@ static int tcp_sink_process_msg(pa_msgobject *o, int code, void *data, int64_t o
             return 0;
         }
 
-        case SINK_MESSAGE_RIP_SOCKET: {
-            if (u->fd >= 0) {
-                pa_close(u->fd);
-                u->fd = -1;
+        case SINK_MESSAGE_TCP_RIP_SOCKET: {
+            if (u->tcp_fd >= 0) {
+                pa_close(u->tcp_fd);
+                u->tcp_fd = -1;
             } else
                 /* FIXME */
                 pa_log("We should not get to this state. Cannot rip socket if not connected.");
@@ -292,7 +292,7 @@ static int udp_sink_process_msg(pa_msgobject *o, int code, void *data, int64_t o
                     pa_log_debug("RAOP: SUSPENDED");
                     pa_smoother_pause(u->smoother, pa_rtclock_now());
 
-                    if (pa_raop_client_can_stream(u->raop)) {
+                    if (pa_raop_client_udp_can_stream(u->raop)) {
                         /* Issue a TEARDOWN if we are still connected. */
                         pa_raop_client_teardown(u->raop);
                     }
@@ -313,7 +313,7 @@ static int udp_sink_process_msg(pa_msgobject *o, int code, void *data, int64_t o
                     if (u->sink->thread_info.state == PA_SINK_SUSPENDED)
                         pa_smoother_resume(u->smoother, pa_rtclock_now(), true);
                     pa_log_debug("RAOP: RUNNING");
-                    if (!pa_raop_client_can_stream(u->raop)) {
+                    if (!pa_raop_client_udp_can_stream(u->raop)) {
                         /* Connecting will trigger a RECORD */
                         pa_raop_client_connect(u->raop);
                     }
@@ -331,7 +331,7 @@ static int udp_sink_process_msg(pa_msgobject *o, int code, void *data, int64_t o
         case PA_SINK_MESSAGE_GET_LATENCY: {
             pa_usec_t r = 0;
 
-            if (pa_raop_client_can_stream(u->raop))
+            if (pa_raop_client_udp_can_stream(u->raop))
                 r = sink_get_latency(u);
 
             *((pa_usec_t*) data) = r;
@@ -339,26 +339,26 @@ static int udp_sink_process_msg(pa_msgobject *o, int code, void *data, int64_t o
             return 0;
         }
 
-        case SINK_MESSAGE_SETUP: {
+        case SINK_MESSAGE_UDP_SETUP: {
             struct pollfd *pollfd;
 
             u->rtpoll_item = pa_rtpoll_item_new(u->rtpoll, PA_RTPOLL_NEVER, 2);
             pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
 
-            pollfd->fd = u->control_fd;
+            pollfd->fd = u->udp_control_fd;
             pollfd->events = POLLIN | POLLPRI;
             pollfd->revents = 0;
             pollfd++;
-            pollfd->fd = u->timing_fd;
+            pollfd->fd = u->udp_timing_fd;
             pollfd->events = POLLIN | POLLPRI;
             pollfd->revents = 0;
 
-            u->control_fd = -1;
-            u->timing_fd = -1;
+            u->udp_control_fd = -1;
+            u->udp_timing_fd = -1;
             return 0;
         }
 
-        case SINK_MESSAGE_RECORD: {
+        case SINK_MESSAGE_UDP_RECORD: {
             pa_rtpoll_set_timer_relative(u->rtpoll, pa_bytes_to_usec(u->block_size, &u->sink->sample_spec));
 
             if (u->sink->thread_info.state == PA_SINK_SUSPENDED) {
@@ -369,7 +369,7 @@ static int udp_sink_process_msg(pa_msgobject *o, int code, void *data, int64_t o
             return 0;
         }
 
-        case SINK_MESSAGE_DISCONNECTED: {
+        case SINK_MESSAGE_UDP_DISCONNECTED: {
             if (u->sink->thread_info.state == PA_SINK_SUSPENDED) {
                 pa_rtpoll_set_timer_disabled(u->rtpoll);
                 if (u->rtpoll_item)
@@ -381,8 +381,8 @@ static int udp_sink_process_msg(pa_msgobject *o, int code, void *data, int64_t o
                 pa_module_unload_request(u->module, true);
             }
 
-            u->control_fd = -1;
-            u->timing_fd = -1;
+            u->udp_control_fd = -1;
+            u->udp_timing_fd = -1;
             return 0;
         }
     }
@@ -435,22 +435,22 @@ static void sink_set_mute_cb(pa_sink *s) {
     }
 }
 
-static void raop_setup_cb(int control_fd, int timing_fd, void *userdata) {
+static void udp_setup_cb(int control_fd, int timing_fd, void *userdata) {
     struct userdata *u = userdata;
 
     pa_assert(control_fd);
     pa_assert(timing_fd);
     pa_assert(u);
 
-    u->control_fd = control_fd;
-    u->timing_fd = timing_fd;
+    u->udp_control_fd = control_fd;
+    u->udp_timing_fd = timing_fd;
 
     pa_log_debug("Connection authenticated, syncing with server...");
 
-    pa_asyncmsgq_post(u->thread_mq.inq, PA_MSGOBJECT(u->sink), SINK_MESSAGE_SETUP, NULL, 0, NULL, NULL);
+    pa_asyncmsgq_post(u->thread_mq.inq, PA_MSGOBJECT(u->sink), SINK_MESSAGE_UDP_SETUP, NULL, 0, NULL, NULL);
 }
 
-static void raop_record_cb(void *userdata) {
+static void udp_record_cb(void *userdata) {
     struct userdata *u = userdata;
 
     pa_assert(u);
@@ -460,17 +460,17 @@ static void raop_record_cb(void *userdata) {
 
     pa_log_debug("Synchronization done, pushing job to IO thread...");
 
-    pa_asyncmsgq_post(u->thread_mq.inq, PA_MSGOBJECT(u->sink), SINK_MESSAGE_RECORD, NULL, 0, NULL, NULL);
+    pa_asyncmsgq_post(u->thread_mq.inq, PA_MSGOBJECT(u->sink), SINK_MESSAGE_UDP_RECORD, NULL, 0, NULL, NULL);
 }
 
-static void raop_disconnected_cb(void *userdata) {
+static void udp_disconnected_cb(void *userdata) {
     struct userdata *u = userdata;
 
     pa_assert(u);
 
     pa_log_debug("Connection closed, informing IO thread...");
 
-    pa_asyncmsgq_post(u->thread_mq.inq, PA_MSGOBJECT(u->sink), SINK_MESSAGE_DISCONNECTED, NULL, 0, NULL, NULL);
+    pa_asyncmsgq_post(u->thread_mq.inq, PA_MSGOBJECT(u->sink), SINK_MESSAGE_UDP_DISCONNECTED, NULL, 0, NULL, NULL);
 }
 
 static void tcp_thread_func(struct userdata *u) {
@@ -561,7 +561,7 @@ static void tcp_thread_func(struct userdata *u) {
                     pa_assert(u->encoded_memchunk.length > 0);
 
                     p = pa_memblock_acquire(u->encoded_memchunk.memblock);
-                    l = pa_write(u->fd, (uint8_t*) p + u->encoded_memchunk.index, u->encoded_memchunk.length, &write_type);
+                    l = pa_write(u->tcp_fd, (uint8_t*) p + u->encoded_memchunk.index, u->encoded_memchunk.length, &write_type);
                     pa_memblock_release(u->encoded_memchunk.memblock);
 
                     pa_assert(l != 0);
@@ -610,7 +610,7 @@ static void tcp_thread_func(struct userdata *u) {
 #ifdef SIOCOUTQ
                 {
                     int l;
-                    if (ioctl(u->fd, SIOCOUTQ, &l) >= 0 && l > 0)
+                    if (ioctl(u->tcp_fd, SIOCOUTQ, &l) >= 0 && l > 0)
                         n -= (l / u->encoding_ratio);
                 }
 #endif
@@ -706,7 +706,7 @@ static void udp_thread_func(struct userdata *u) {
                     pollfd->revents = 0;
                     pa_log_debug("Received control packet.");
                     read = pa_read(pollfd->fd, packet, sizeof(packet), NULL);
-                    pa_raop_client_handle_control_packet(u->raop, packet, read);
+                    pa_raop_client_udp_handle_control_packet(u->raop, packet, read);
                 }
 
                 pollfd++;
@@ -716,14 +716,14 @@ static void udp_thread_func(struct userdata *u) {
                     pollfd->revents = 0;
                     pa_log_debug("Received timing packet.");
                     read = pa_read(pollfd->fd, packet, sizeof(packet), NULL);
-                    pa_raop_client_handle_timing_packet(u->raop, packet, read);
+                    pa_raop_client_udp_handle_timing_packet(u->raop, packet, read);
                 }
             }
 
             continue;
         }
 
-        if (!pa_raop_client_can_stream(u->raop))
+        if (!pa_raop_client_udp_can_stream(u->raop))
             continue;
         if (u->sink->thread_info.state != PA_SINK_RUNNING)
             continue;
@@ -751,7 +751,7 @@ static void udp_thread_func(struct userdata *u) {
 
         pa_assert(u->encoded_memchunk.length > 0);
 
-        pa_raop_client_send_audio_packet(u->raop, &u->encoded_memchunk, &written);
+        pa_raop_client_udp_send_audio_packet(u->raop, &u->encoded_memchunk, &written);
         pa_rtpoll_set_timer_relative(u->rtpoll, pa_bytes_to_usec(u->block_size, &u->sink->sample_spec));
 
         pa_assert(written != 0);
@@ -821,7 +821,7 @@ int pa__init(pa_module *m) {
     u->core = m->core;
     u->module = m;
     m->userdata = u;
-    u->fd = -1;
+    u->tcp_fd = -1;
     u->smoother = pa_smoother_new(
             PA_USEC_PER_SEC,
             PA_USEC_PER_SEC*2,
@@ -916,18 +916,18 @@ int pa__init(pa_module *m) {
         goto fail;
     }
 
-    pa_raop_client_set_callback(u->raop, on_connection, u);
-    pa_raop_client_set_closed_callback(u->raop, on_close, u);
+    pa_raop_client_tcp_set_callback(u->raop, tcp_on_connection, u);
+    pa_raop_client_tcp_set_closed_callback(u->raop, tcp_on_close, u);
 
     if (u->protocol == RAOP_UDP) {
         /* The number of frames per blocks is not negotiable... */
-        pa_raop_client_get_blocks_size(u->raop, &u->block_size);
+        pa_raop_client_udp_get_blocks_size(u->raop, &u->block_size);
         u->block_size *= pa_frame_size(&ss);
         pa_sink_set_max_request(u->sink, u->block_size);
 
-        pa_raop_client_set_setup_callback(u->raop, raop_setup_cb, u);
-        pa_raop_client_set_record_callback(u->raop, raop_record_cb, u);
-        pa_raop_client_set_disconnected_callback(u->raop, raop_disconnected_cb, u);
+        pa_raop_client_udp_set_setup_callback(u->raop, udp_setup_cb, u);
+        pa_raop_client_udp_set_record_callback(u->raop, udp_record_cb, u);
+        pa_raop_client_udp_set_disconnected_callback(u->raop, udp_disconnected_cb, u);
     }
 
     if (!(u->thread = pa_thread_new("raop-sink", thread_func, u))) {
@@ -1002,8 +1002,8 @@ void pa__done(pa_module *m) {
     if (u->smoother)
         pa_smoother_free(u->smoother);
 
-    if (u->fd >= 0)
-        pa_close(u->fd);
+    if (u->tcp_fd >= 0)
+        pa_close(u->tcp_fd);
 
     pa_xfree(u);
 }
diff --git a/src/modules/raop/raop_client.c b/src/modules/raop/raop_client.c
index 1ca8421..0174572 100644
--- a/src/modules/raop/raop_client.c
+++ b/src/modules/raop/raop_client.c
@@ -59,7 +59,7 @@
 #include "rtsp_client.h"
 #include "base64.h"
 
-#define FRAMES_PER_PACKET 352
+#define UDP_FRAMES_PER_PACKET 352
 #define AES_CHUNKSIZE 16
 
 #define JACK_STATUS_DISCONNECTED 0
@@ -72,20 +72,19 @@
 #define VOLUME_MIN -144
 #define VOLUME_MAX 0
 
-#define RAOP_PORT 5000
 #define DEFAULT_RAOP_PORT 5000
-#define DEFAULT_AUDIO_PORT 6000
-#define DEFAULT_CONTROL_PORT 6001
-#define DEFAULT_TIMING_PORT 6002
+#define UDP_DEFAULT_AUDIO_PORT 6000
+#define UDP_DEFAULT_CONTROL_PORT 6001
+#define UDP_DEFAULT_TIMING_PORT 6002
 
 typedef enum {
-    PAYLOAD_TIMING_REQUEST = 0x52,
-    PAYLOAD_TIMING_RESPONSE = 0x53,
-    PAYLOAD_SYNCHRONIZATION = 0x54,
-    PAYLOAD_RETRANSMIT_REQUEST = 0x55,
-    PAYLOAD_RETRANSMIT_REPLY = 0x56,
-    PAYLOAD_AUDIO_DATA = 0x60
-} pa_raop_payload_type;
+    UDP_PAYLOAD_TIMING_REQUEST = 0x52,
+    UDP_PAYLOAD_TIMING_RESPONSE = 0x53,
+    UDP_PAYLOAD_SYNCHRONIZATION = 0x54,
+    UDP_PAYLOAD_RETRANSMIT_REQUEST = 0x55,
+    UDP_PAYLOAD_RETRANSMIT_REPLY = 0x56,
+    UDP_PAYLOAD_AUDIO_DATA = 0x60
+} pa_raop_udp_payload_type;
 
 struct pa_raop_client {
     pa_core *core;
@@ -108,36 +107,36 @@ struct pa_raop_client {
     uint32_t rtptime;
 
     /* Members only for the TCP protocol */
-    pa_socket_client *sc;
-    int fd;
+    pa_socket_client *tcp_sc;
+    int tcp_fd;
 
-    pa_raop_client_cb_t callback;
-    void *userdata;
-    pa_raop_client_closed_cb_t closed_callback;
-    void *closed_userdata;
+    pa_raop_client_cb_t tcp_callback;
+    void *tcp_userdata;
+    pa_raop_client_closed_cb_t tcp_closed_callback;
+    void *tcp_closed_userdata;
 
     /* Members only for the UDP protocol */
-    uint16_t control_port;
-    uint16_t timing_port;
+    uint16_t udp_control_port;
+    uint16_t udp_timing_port;
 
-    int stream_fd;
-    int control_fd;
-    int timing_fd;
+    int udp_stream_fd;
+    int udp_control_fd;
+    int udp_timing_fd;
 
-    uint32_t ssrc;
+    uint32_t udp_ssrc;
 
-    bool first_packet;
-    uint32_t sync_interval;
-    uint32_t sync_count;
+    bool udp_first_packet;
+    uint32_t udp_sync_interval;
+    uint32_t udp_sync_count;
 
-    pa_raop_client_setup_cb_t setup_callback;
-    void *setup_userdata;
+    pa_raop_client_setup_cb_t udp_setup_callback;
+    void *udp_setup_userdata;
 
-    pa_raop_client_record_cb_t record_callback;
-    void *record_userdata;
+    pa_raop_client_record_cb_t udp_record_callback;
+    void *udp_record_userdata;
 
-    pa_raop_client_disconnected_cb_t disconnected_callback;
-    void *disconnected_userdata;
+    pa_raop_client_disconnected_cb_t udp_disconnected_callback;
+    void *udp_disconnected_userdata;
 };
 
 /* Timming packet header (8x8):
@@ -145,7 +144,7 @@ struct pa_raop_client {
  *  [1]   Payload type: 0x53 | marker bit: 0x80,
  *  [2,3] Sequence number: 0x0007,
  *  [4,7] Timestamp: 0x00000000 (unused). */
-static const uint8_t timming_header[8] = {
+static const uint8_t udp_timming_header[8] = {
     0x80, 0xd3, 0x00, 0x07,
     0x00, 0x00, 0x00, 0x00
 };
@@ -155,7 +154,7 @@ static const uint8_t timming_header[8] = {
  *  [1]   Payload type: 0x54 | marker bit: 0x80,
  *  [2,3] Sequence number: 0x0007,
  *  [4,7] Timestamp: 0x00000000 (to be set). */
-static const uint8_t sync_header[8] = {
+static const uint8_t udp_sync_header[8] = {
     0x80, 0xd4, 0x00, 0x07,
     0x00, 0x00, 0x00, 0x00
 };
@@ -283,32 +282,32 @@ static inline void rtrimchar(char *str, char rc) {
     }
 }
 
-static void on_connection(pa_socket_client *sc, pa_iochannel *io, void *userdata) {
+static void tcp_on_connection(pa_socket_client *sc, pa_iochannel *io, void *userdata) {
     pa_raop_client *c = userdata;
 
     pa_assert(sc);
     pa_assert(c);
-    pa_assert(c->sc == sc);
-    pa_assert(c->fd < 0);
-    pa_assert(c->callback);
+    pa_assert(c->tcp_sc == sc);
+    pa_assert(c->tcp_fd < 0);
+    pa_assert(c->tcp_callback);
 
-    pa_socket_client_unref(c->sc);
-    c->sc = NULL;
+    pa_socket_client_unref(c->tcp_sc);
+    c->tcp_sc = NULL;
 
     if (!io) {
         pa_log("Connection failed: %s", pa_cstrerror(errno));
         return;
     }
 
-    c->fd = pa_iochannel_get_send_fd(io);
+    c->tcp_fd = pa_iochannel_get_send_fd(io);
 
     pa_iochannel_set_noclose(io, true);
     pa_iochannel_free(io);
 
-    pa_make_tcp_socket_low_delay(c->fd);
+    pa_make_tcp_socket_low_delay(c->tcp_fd);
 
     pa_log_debug("Connection established");
-    c->callback(c->fd, c->userdata);
+    c->tcp_callback(c->tcp_fd, c->tcp_userdata);
 }
 
 static inline uint64_t timeval_to_ntp(struct timeval *tv) {
@@ -442,14 +441,14 @@ fail:
     return -1;
 }
 
-static int send_timing_packet(pa_raop_client *c, const uint32_t data[6], uint64_t received) {
+static int udp_send_timing_packet(pa_raop_client *c, const uint32_t data[6], uint64_t received) {
     uint32_t packet[8];
     struct timeval tv;
     ssize_t written = 0;
     uint64_t trs = 0;
     int rv = 1;
 
-    memcpy(packet, timming_header, sizeof(timming_header));
+    memcpy(packet, udp_timming_header, sizeof(udp_timming_header));
     /* Copying originate timestamp from the incoming request packet. */
     packet[2] = data[4];
     packet[3] = data[5];
@@ -461,14 +460,14 @@ static int send_timing_packet(pa_raop_client *c, const uint32_t data[6], uint64_
     packet[6] = htonl(trs >> 32);
     packet[7] = htonl(trs & 0xffffffff);
 
-    written = pa_loop_write(c->timing_fd, packet, sizeof(packet), NULL);
+    written = pa_loop_write(c->udp_timing_fd, packet, sizeof(packet), NULL);
     if (written == sizeof(packet))
         rv = 0;
 
     return rv;
 }
 
-static int send_sync_packet(pa_raop_client *c, uint32_t stamp) {
+static int udp_send_sync_packet(pa_raop_client *c, uint32_t stamp) {
     const uint32_t delay = 88200;
     uint32_t packet[5];
     struct timeval tv;
@@ -476,8 +475,8 @@ static int send_sync_packet(pa_raop_client *c, uint32_t stamp) {
     uint64_t trs = 0;
     int rv = 1;
 
-    memcpy(packet, sync_header, sizeof(sync_header));
-    if (c->first_packet)
+    memcpy(packet, udp_sync_header, sizeof(udp_sync_header));
+    if (c->udp_first_packet)
         packet[0] |= 0x10;
     stamp -= delay;
     packet[1] = htonl(stamp);
@@ -488,25 +487,25 @@ static int send_sync_packet(pa_raop_client *c, uint32_t stamp) {
     stamp += delay;
     packet[4] = htonl(stamp);
 
-    written = pa_loop_write(c->control_fd, packet, sizeof(packet), NULL);
+    written = pa_loop_write(c->udp_control_fd, packet, sizeof(packet), NULL);
     if (written == sizeof(packet))
         rv = 0;
 
     return rv;
 }
 
-static int send_audio_packet(pa_raop_client *c, uint32_t *buffer, size_t size, ssize_t *written) {
+static int udp_send_audio_packet(pa_raop_client *c, uint32_t *buffer, size_t size, ssize_t *written) {
     ssize_t length = 0;
     int rv = 1;
 
     memcpy(buffer, udp_audio_header, sizeof(udp_audio_header));
-    if (c->first_packet)
+    if (c->udp_first_packet)
         buffer[0] |= ((uint32_t) 0x80) << 8;
     buffer[0] |= htonl((uint32_t) c->seq);
     buffer[1] = htonl(c->rtptime);
-    buffer[2] = htonl(c->ssrc);
+    buffer[2] = htonl(c->udp_ssrc);
 
-    length = pa_loop_write(c->stream_fd, buffer, size, NULL);
+    length = pa_loop_write(c->udp_stream_fd, buffer, size, NULL);
     if (length == ((ssize_t) size))
         rv = 0;
 
@@ -557,7 +556,7 @@ static void do_rtsp_announce(pa_raop_client *c) {
         "a=rsaaeskey:%s\r\n"
         "a=aesiv:%s\r\n",
         c->sid, ip, c->host,
-        c->protocol == RAOP_TCP ? 4096 : FRAMES_PER_PACKET,
+        c->protocol == RAOP_TCP ? 4096 : UDP_FRAMES_PER_PACKET,
         key, iv);
     pa_rtsp_announce(c->rtsp, sdp);
     pa_xfree(key);
@@ -619,11 +618,11 @@ static void tcp_rtsp_cb(pa_rtsp_client *rtsp, pa_rtsp_state state, pa_headerlist
             uint32_t port = pa_rtsp_serverport(c->rtsp);
             pa_log_debug("RAOP: RECORDED");
 
-            if (!(c->sc = pa_socket_client_new_string(c->core->mainloop, true, c->host, port))) {
+            if (!(c->tcp_sc = pa_socket_client_new_string(c->core->mainloop, true, c->host, port))) {
                 pa_log("failed to connect to server '%s:%d'", c->host, port);
                 return;
             }
-            pa_socket_client_set_callback(c->sc, on_connection, c);
+            pa_socket_client_set_callback(c->tcp_sc, tcp_on_connection, c);
             break;
         }
 
@@ -640,23 +639,23 @@ static void tcp_rtsp_cb(pa_rtsp_client *rtsp, pa_rtsp_state state, pa_headerlist
             break;
 
         case STATE_DISCONNECTED:
-            pa_assert(c->closed_callback);
+            pa_assert(c->tcp_closed_callback);
             pa_assert(c->rtsp);
 
             pa_log_debug("RTSP control channel closed");
             pa_rtsp_client_free(c->rtsp);
             c->rtsp = NULL;
-            if (c->fd > 0) {
+            if (c->tcp_fd > 0) {
                 /* We do not close the fd, we leave it to the closed callback to do that */
-                c->fd = -1;
+                c->tcp_fd = -1;
             }
-            if (c->sc) {
-                pa_socket_client_unref(c->sc);
-                c->sc = NULL;
+            if (c->tcp_sc) {
+                pa_socket_client_unref(c->tcp_sc);
+                c->tcp_sc = NULL;
             }
             pa_xfree(c->sid);
             c->sid = NULL;
-            c->closed_callback(c->closed_userdata);
+            c->tcp_closed_callback(c->tcp_closed_userdata);
             break;
     }
 }
@@ -697,8 +696,8 @@ static void udp_rtsp_cb(pa_rtsp_client *rtsp, pa_rtsp_state state, pa_headerlist
             char *trs;
 
             trs = pa_sprintf_malloc("RTP/AVP/UDP;unicast;interleaved=0-1;mode=record;control_port=%d;timing_port=%d",
-                c->control_port,
-                c->timing_port);
+                c->udp_control_port,
+                c->udp_timing_port);
 
             pa_rtsp_setup(c->rtsp, trs);
 
@@ -707,7 +706,7 @@ static void udp_rtsp_cb(pa_rtsp_client *rtsp, pa_rtsp_state state, pa_headerlist
         }
 
         case STATE_SETUP: {
-            uint32_t stream_port = DEFAULT_AUDIO_PORT;
+            uint32_t stream_port = UDP_DEFAULT_AUDIO_PORT;
             char *ajs, *trs, *token, *pc;
             char delimiters[] = ";";
             const char *token_state = NULL;
@@ -748,12 +747,12 @@ static void udp_rtsp_cb(pa_rtsp_client *rtsp, pa_rtsp_state state, pa_headerlist
                         if (pa_streq(token, "control_port")) {
                             port = 0;
                             pa_atou(pc + 1, &port);
-                            c->control_port = port;
+                            c->udp_control_port = port;
                         }
                         if (pa_streq(token, "timing_port")) {
                             port = 0;
                             pa_atou(pc + 1, &port);
-                            c->timing_port = port;
+                            c->udp_timing_port = port;
                         }
                         *pc = '=';
                     }
@@ -769,47 +768,47 @@ static void udp_rtsp_cb(pa_rtsp_client *rtsp, pa_rtsp_state state, pa_headerlist
             stream_port = pa_rtsp_serverport(c->rtsp);
             if (stream_port == 0)
                 goto error;
-            if (c->control_port == 0 || c->timing_port == 0)
+            if (c->udp_control_port == 0 || c->udp_timing_port == 0)
                 goto error;
 
             pa_log_debug("Using server_port=%d, control_port=%d & timing_port=%d",
                 stream_port,
-                c->control_port,
-                c->timing_port);
+                c->udp_control_port,
+                c->udp_timing_port);
 
-            c->stream_fd = open_udp_socket(c, stream_port, 0);
-            c->control_fd = open_udp_socket(c, c->control_port, 1);
-            c->timing_fd = open_udp_socket(c, c->timing_port, 1);
+            c->udp_stream_fd = open_udp_socket(c, stream_port, 0);
+            c->udp_control_fd = open_udp_socket(c, c->udp_control_port, 1);
+            c->udp_timing_fd = open_udp_socket(c, c->udp_timing_port, 1);
 
-            if (c->stream_fd <= 0)
+            if (c->udp_stream_fd <= 0)
                 goto error;
-            if (c->control_fd <= 0 || c->timing_fd <= 0)
+            if (c->udp_control_fd <= 0 || c->udp_timing_fd <= 0)
                 goto error;
 
-            c->setup_callback(c->control_fd, c->timing_fd, c->setup_userdata);
+            c->udp_setup_callback(c->udp_control_fd, c->udp_timing_fd, c->udp_setup_userdata);
             pa_rtsp_record(c->rtsp, &c->seq, &c->rtptime);
 
             break;
 
         error:
-            if (c->stream_fd > 0) {
-                pa_close(c->stream_fd);
-                c->stream_fd = -1;
+            if (c->udp_stream_fd > 0) {
+                pa_close(c->udp_stream_fd);
+                c->udp_stream_fd = -1;
             }
-            if (c->control_fd > 0) {
-                pa_close(c->control_fd);
-                c->control_fd = -1;
+            if (c->udp_control_fd > 0) {
+                pa_close(c->udp_control_fd);
+                c->udp_control_fd = -1;
             }
-            if (c->timing_fd > 0) {
-                pa_close(c->timing_fd);
-                c->timing_fd = -1;
+            if (c->udp_timing_fd > 0) {
+                pa_close(c->udp_timing_fd);
+                c->udp_timing_fd = -1;
             }
 
             pa_rtsp_client_free(c->rtsp);
             c->rtsp = NULL;
 
-            c->control_port = DEFAULT_CONTROL_PORT;
-            c->timing_port = DEFAULT_TIMING_PORT;
+            c->udp_control_port = UDP_DEFAULT_CONTROL_PORT;
+            c->udp_timing_port = UDP_DEFAULT_TIMING_PORT;
 
             pa_log_error("aborting RTSP setup, failed creating required sockets");
 
@@ -826,15 +825,15 @@ static void udp_rtsp_cb(pa_rtsp_client *rtsp, pa_rtsp_state state, pa_headerlist
             alt = pa_xstrdup(pa_headerlist_gets(headers, "Audio-Latency"));
             /* Generate a random synchronization source identifier from this session. */
             pa_random(&rand, sizeof(rand));
-            c->ssrc = rand;
+            c->udp_ssrc = rand;
 
             if (alt)
                 pa_atoi(alt, &latency);
 
-            c->first_packet = true;
-            c->sync_count = 0;
+            c->udp_first_packet = true;
+            c->udp_sync_count = 0;
 
-            c->record_callback(c->setup_userdata);
+            c->udp_record_callback(c->udp_setup_userdata);
 
             pa_xfree(alt);
             break;
@@ -857,17 +856,17 @@ static void udp_rtsp_cb(pa_rtsp_client *rtsp, pa_rtsp_state state, pa_headerlist
 
             pa_rtsp_disconnect(c->rtsp);
 
-            if (c->stream_fd > 0) {
-                pa_close(c->stream_fd);
-                c->stream_fd = -1;
+            if (c->udp_stream_fd > 0) {
+                pa_close(c->udp_stream_fd);
+                c->udp_stream_fd = -1;
             }
-            if (c->control_fd > 0) {
-                pa_close(c->control_fd);
-                c->control_fd = -1;
+            if (c->udp_control_fd > 0) {
+                pa_close(c->udp_control_fd);
+                c->udp_control_fd = -1;
             }
-            if (c->timing_fd > 0) {
-                pa_close(c->timing_fd);
-                c->timing_fd = -1;
+            if (c->udp_timing_fd > 0) {
+                pa_close(c->udp_timing_fd);
+                c->udp_timing_fd = -1;
             }
 
             pa_log_debug("RTSP control channel closed");
@@ -881,20 +880,20 @@ static void udp_rtsp_cb(pa_rtsp_client *rtsp, pa_rtsp_state state, pa_headerlist
         }
 
         case STATE_DISCONNECTED: {
-            pa_assert(c->disconnected_callback);
+            pa_assert(c->udp_disconnected_callback);
             pa_assert(c->rtsp);
 
-            if (c->stream_fd > 0) {
-                pa_close(c->stream_fd);
-                c->stream_fd = -1;
+            if (c->udp_stream_fd > 0) {
+                pa_close(c->udp_stream_fd);
+                c->udp_stream_fd = -1;
             }
-            if (c->control_fd > 0) {
-                pa_close(c->control_fd);
-                c->control_fd = -1;
+            if (c->udp_control_fd > 0) {
+                pa_close(c->udp_control_fd);
+                c->udp_control_fd = -1;
             }
-            if (c->timing_fd > 0) {
-                pa_close(c->timing_fd);
-                c->timing_fd = -1;
+            if (c->udp_timing_fd > 0) {
+                pa_close(c->udp_timing_fd);
+                c->udp_timing_fd = -1;
             }
 
             pa_log_debug("RTSP control channel closed");
@@ -904,7 +903,7 @@ static void udp_rtsp_cb(pa_rtsp_client *rtsp, pa_rtsp_state state, pa_headerlist
             c->rtsp = NULL;
             c->sid = NULL;
 
-            c->disconnected_callback(c->disconnected_userdata);
+            c->udp_disconnected_callback(c->udp_disconnected_userdata);
 
             break;
         }
@@ -924,14 +923,14 @@ pa_raop_client* pa_raop_client_new(pa_core *core, const char *host,
         return NULL;
 
     c->core = core;
-    c->fd = -1;
+    c->tcp_fd = -1;
     c->protocol = protocol;
-    c->stream_fd = -1;
-    c->control_fd = -1;
-    c->timing_fd = -1;
+    c->udp_stream_fd = -1;
+    c->udp_control_fd = -1;
+    c->udp_timing_fd = -1;
 
-    c->control_port = DEFAULT_CONTROL_PORT;
-    c->timing_port = DEFAULT_TIMING_PORT;
+    c->udp_control_port = UDP_DEFAULT_CONTROL_PORT;
+    c->udp_timing_port = UDP_DEFAULT_TIMING_PORT;
 
     c->host = pa_xstrdup(a.path_or_host);
     if (a.port)
@@ -939,10 +938,10 @@ pa_raop_client* pa_raop_client_new(pa_core *core, const char *host,
     else
         c->port = DEFAULT_RAOP_PORT;
 
-    c->first_packet = true;
+    c->udp_first_packet = true;
     /* Packet sync interval should be around 1s. */
-    c->sync_interval = spec.rate / FRAMES_PER_PACKET;
-    c->sync_count = 0;
+    c->udp_sync_interval = spec.rate / UDP_FRAMES_PER_PACKET;
+    c->udp_sync_count = 0;
 
     if (c->protocol == RAOP_TCP) {
         if (pa_raop_client_connect(c)) {
@@ -1011,7 +1010,7 @@ int pa_raop_client_flush(pa_raop_client *c) {
 
     if (c->rtsp != NULL) {
         rv = pa_rtsp_flush(c->rtsp, c->seq, c->rtptime);
-        c->sync_count = -1;
+        c->udp_sync_count = -1;
     }
 
     return rv;
@@ -1030,18 +1029,18 @@ int pa_raop_client_teardown(pa_raop_client *c) {
     return rv;
 }
 
-int pa_raop_client_can_stream(pa_raop_client *c) {
+int pa_raop_client_udp_can_stream(pa_raop_client *c) {
     int rv = 0;
 
     pa_assert(c);
 
-    if (c->stream_fd > 0)
+    if (c->udp_stream_fd > 0)
         rv = 1;
 
     return rv;
 }
 
-int pa_raop_client_handle_timing_packet(pa_raop_client *c, const uint8_t packet[], ssize_t size) {
+int pa_raop_client_udp_handle_timing_packet(pa_raop_client *c, const uint8_t packet[], ssize_t size) {
     const uint32_t * data = NULL;
     uint8_t payload = 0;
     struct timeval tv;
@@ -1058,15 +1057,15 @@ int pa_raop_client_handle_timing_packet(pa_raop_client *c, const uint8_t packet[
         return 1;
     }
 
-    data = (uint32_t *) (packet + sizeof(timming_header));
+    data = (uint32_t *) (packet + sizeof(udp_timming_header));
     rci = timeval_to_ntp(pa_rtclock_get(&tv));
     /* The market bit is always set (see rfc3550 for packet structure) ! */
     payload = packet[1] ^ 0x80;
     switch (payload) {
-        case PAYLOAD_TIMING_REQUEST:
-            rv = send_timing_packet(c, data, rci);
+        case UDP_PAYLOAD_TIMING_REQUEST:
+            rv = udp_send_timing_packet(c, data, rci);
             break;
-        case PAYLOAD_TIMING_RESPONSE:
+        case UDP_PAYLOAD_TIMING_RESPONSE:
         default:
             pa_log_debug("Got an unexpected payload type on timing channel !");
             return 1;
@@ -1075,7 +1074,7 @@ int pa_raop_client_handle_timing_packet(pa_raop_client *c, const uint8_t packet[
     return rv;
 }
 
-int pa_raop_client_handle_control_packet(pa_raop_client *c, const uint8_t packet[], ssize_t size) {
+int pa_raop_client_udp_handle_control_packet(pa_raop_client *c, const uint8_t packet[], ssize_t size) {
     uint8_t payload = 0;
     int rv = 0;
 
@@ -1089,13 +1088,14 @@ int pa_raop_client_handle_control_packet(pa_raop_client *c, const uint8_t packet
     }
 
     /* The market bit is always set (see rfc3550 for packet structure) ! */
+
     payload = packet[1] ^ 0x80;
     switch (payload) {
-        case PAYLOAD_RETRANSMIT_REQUEST:
+        case UDP_PAYLOAD_RETRANSMIT_REQUEST:
             /* Packet retransmission not implemented yet... */
             /* rv = ... */
             break;
-        case PAYLOAD_RETRANSMIT_REPLY:
+        case UDP_PAYLOAD_RETRANSMIT_REPLY:
         default:
             pa_log_debug("Got an unexpected payload type on control channel !");
             return 1;
@@ -1104,18 +1104,18 @@ int pa_raop_client_handle_control_packet(pa_raop_client *c, const uint8_t packet
     return rv;
 }
 
-int pa_raop_client_get_blocks_size(pa_raop_client *c, size_t *size) {
+int pa_raop_client_udp_get_blocks_size(pa_raop_client *c, size_t *size) {
     int rv = 0;
 
     pa_assert(c);
     pa_assert(size);
 
-    *size = FRAMES_PER_PACKET;
+    *size = UDP_FRAMES_PER_PACKET;
 
     return rv;
 }
 
-int pa_raop_client_send_audio_packet(pa_raop_client *c, pa_memchunk *block, ssize_t *written) {
+int pa_raop_client_udp_send_audio_packet(pa_raop_client *c, pa_memchunk *block, ssize_t *written) {
     uint32_t *buf = NULL;
     ssize_t length = 0;
     int rv = 0;
@@ -1124,24 +1124,24 @@ int pa_raop_client_send_audio_packet(pa_raop_client *c, pa_memchunk *block, ssiz
     pa_assert(block);
 
     /* Sync RTP & NTP timestamp if required. */
-    if (c->first_packet || c->sync_count >= c->sync_interval) {
-        send_sync_packet(c, c->rtptime);
-        c->sync_count = 0;
+    if (c->udp_first_packet || c->udp_sync_count >= c->udp_sync_interval) {
+        udp_send_sync_packet(c, c->rtptime);
+        c->udp_sync_count = 0;
     } else {
-        c->sync_count++;
+        c->udp_sync_count++;
     }
 
     buf = (uint32_t *) pa_memblock_acquire(block->memblock);
     if (buf != NULL && block->length > 0)
-        rv = send_audio_packet(c, buf + block->index, block->length, &length);
+        rv = udp_send_audio_packet(c, buf + block->index, block->length, &length);
     pa_memblock_release(block->memblock);
     block->index += length;
     block->length -= length;
     if (written != NULL)
         *written = length;
 
-    if (c->first_packet)
-        c->first_packet = false;
+    if (c->udp_first_packet)
+        c->udp_first_packet = false;
 
     return rv;
 }
@@ -1256,38 +1256,38 @@ int pa_raop_client_encode_sample(pa_raop_client *c, pa_memchunk *raw, pa_memchun
     return 0;
 }
 
-void pa_raop_client_set_callback(pa_raop_client *c, pa_raop_client_cb_t callback, void *userdata) {
+void pa_raop_client_tcp_set_callback(pa_raop_client *c, pa_raop_client_cb_t callback, void *userdata) {
     pa_assert(c);
 
-    c->callback = callback;
-    c->userdata = userdata;
+    c->tcp_callback = callback;
+    c->tcp_userdata = userdata;
 }
 
-void pa_raop_client_set_closed_callback(pa_raop_client *c, pa_raop_client_closed_cb_t callback, void *userdata) {
+void pa_raop_client_tcp_set_closed_callback(pa_raop_client *c, pa_raop_client_closed_cb_t callback, void *userdata) {
     pa_assert(c);
 
-    c->closed_callback = callback;
-    c->closed_userdata = userdata;
+    c->tcp_closed_callback = callback;
+    c->tcp_closed_userdata = userdata;
 }
 
 
-void pa_raop_client_set_setup_callback(pa_raop_client *c, pa_raop_client_setup_cb_t callback, void *userdata) {
+void pa_raop_client_udp_set_setup_callback(pa_raop_client *c, pa_raop_client_setup_cb_t callback, void *userdata) {
     pa_assert(c);
 
-    c->setup_callback = callback;
-    c->setup_userdata = userdata;
+    c->udp_setup_callback = callback;
+    c->udp_setup_userdata = userdata;
 }
 
-void pa_raop_client_set_record_callback(pa_raop_client *c, pa_raop_client_record_cb_t callback, void *userdata) {
+void pa_raop_client_udp_set_record_callback(pa_raop_client *c, pa_raop_client_record_cb_t callback, void *userdata) {
     pa_assert(c);
 
-    c->record_callback = callback;
-    c->record_userdata = userdata;
+    c->udp_record_callback = callback;
+    c->udp_record_userdata = userdata;
 }
 
-void pa_raop_client_set_disconnected_callback(pa_raop_client *c, pa_raop_client_disconnected_cb_t callback, void *userdata) {
+void pa_raop_client_udp_set_disconnected_callback(pa_raop_client *c, pa_raop_client_disconnected_cb_t callback, void *userdata) {
     pa_assert(c);
 
-    c->disconnected_callback = callback;
-    c->disconnected_userdata = userdata;
+    c->udp_disconnected_callback = callback;
+    c->udp_disconnected_userdata = userdata;
 }
diff --git a/src/modules/raop/raop_client.h b/src/modules/raop/raop_client.h
index 97847d9..5cf1ff7 100644
--- a/src/modules/raop/raop_client.h
+++ b/src/modules/raop/raop_client.h
@@ -41,30 +41,30 @@ int pa_raop_client_connect(pa_raop_client *c);
 int pa_raop_client_flush(pa_raop_client *c);
 int pa_raop_client_teardown(pa_raop_client *c);
 
-int pa_raop_client_can_stream(pa_raop_client *c);
+int pa_raop_client_udp_can_stream(pa_raop_client *c);
 int pa_raop_client_set_volume(pa_raop_client *c, pa_volume_t volume);
 int pa_raop_client_encode_sample(pa_raop_client *c, pa_memchunk *raw, pa_memchunk *encoded);
 
-int pa_raop_client_handle_timing_packet(pa_raop_client *c, const uint8_t packet
+int pa_raop_client_udp_handle_timing_packet(pa_raop_client *c, const uint8_t packet
 [], ssize_t size);
-int pa_raop_client_handle_control_packet(pa_raop_client *c, const uint8_t packet[], ssize_t size);
-int pa_raop_client_get_blocks_size(pa_raop_client *c, size_t *size);
-int pa_raop_client_send_audio_packet(pa_raop_client *c, pa_memchunk *block, ssize_t *written);
+int pa_raop_client_udp_handle_control_packet(pa_raop_client *c, const uint8_t packet[], ssize_t size);
+int pa_raop_client_udp_get_blocks_size(pa_raop_client *c, size_t *size);
+int pa_raop_client_udp_send_audio_packet(pa_raop_client *c, pa_memchunk *block, ssize_t *written);
 
 typedef void (*pa_raop_client_cb_t)(int fd, void *userdata);
-void pa_raop_client_set_callback(pa_raop_client *c, pa_raop_client_cb_t callback, void *userdata);
+void pa_raop_client_tcp_set_callback(pa_raop_client *c, pa_raop_client_cb_t callback, void *userdata);
 
 typedef void (*pa_raop_client_closed_cb_t)(void *userdata);
-void pa_raop_client_set_closed_callback(pa_raop_client *c, pa_raop_client_closed_cb_t callback, void *userdata);
+void pa_raop_client_tcp_set_closed_callback(pa_raop_client *c, pa_raop_client_closed_cb_t callback, void *userdata);
 
 
 typedef void (*pa_raop_client_setup_cb_t)(int control_fd, int timing_fd, void *userdata);
-void pa_raop_client_set_setup_callback(pa_raop_client *c, pa_raop_client_setup_cb_t callback, void *userdata);
+void pa_raop_client_udp_set_setup_callback(pa_raop_client *c, pa_raop_client_setup_cb_t callback, void *userdata);
 
 typedef void (*pa_raop_client_record_cb_t)(void *userdata);
-void pa_raop_client_set_record_callback(pa_raop_client *c, pa_raop_client_record_cb_t callback, void *userdata);
+void pa_raop_client_udp_set_record_callback(pa_raop_client *c, pa_raop_client_record_cb_t callback, void *userdata);
 
 typedef void (*pa_raop_client_disconnected_cb_t)(void *userdata);
-void pa_raop_client_set_disconnected_callback(pa_raop_client *c, pa_raop_client_disconnected_cb_t callback, void *userdata);
+void pa_raop_client_udp_set_disconnected_callback(pa_raop_client *c, pa_raop_client_disconnected_cb_t callback, void *userdata);
 
 #endif
-- 
1.8.1.2



[Index of Archives]     [Linux Audio Users]     [AMD Graphics]     [Linux USB Devel]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]

  Powered by Linux