chiark / gitweb /
disobedience/control.c: Handle state-change toggles better.
[disorder] / lib / uaudio-rtp.c
CommitLineData
7a2c7068
RK
1/*
2 * This file is part of DisOrder.
80fb0bd9 3 * Copyright (C) 2009, 2013 Richard Kettlewell
7a2c7068
RK
4 *
5 * This program is free software: you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation, either version 3 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
17 */
e8c185c3 18/** @file lib/uaudio-rtp.c
7a2c7068
RK
19 * @brief Support for RTP network play backend */
20#include "common.h"
21
dfa51bb7 22#include <errno.h>
60e5bc86 23#include <sys/socket.h>
dfa51bb7
RK
24#include <ifaddrs.h>
25#include <net/if.h>
adeb58a0
RK
26#include <arpa/inet.h>
27#include <netinet/in.h>
dfa51bb7
RK
28#include <gcrypt.h>
29#include <unistd.h>
30#include <time.h>
60e5bc86 31#include <sys/uio.h>
80fb0bd9 32#include <pthread.h>
7a2c7068
RK
33
34#include "uaudio.h"
35#include "mem.h"
36#include "log.h"
37#include "syscalls.h"
dfa51bb7
RK
38#include "rtp.h"
39#include "addr.h"
40#include "ifreq.h"
41#include "timeval.h"
ba70caca 42#include "configuration.h"
dfa51bb7 43
2a2b84aa
MW
44/** @brief Bytes to send per network packet */
45static int rtp_max_payload;
dfa51bb7
RK
46
47/** @brief RTP payload type */
48static int rtp_payload;
49
ac52c873 50/** @brief RTP broadcast/multicast output socket */
4285d0cf 51static int rtp_fd = -1;
dfa51bb7 52
ac52c873
MW
53/** @brief RTP unicast output socket (IPv4) */
54static int rtp_fd4 = -1;
55
4285d0cf
MW
56/** @brief RTP unicast output socket (IPv6) */
57static int rtp_fd6 = -1;
80fb0bd9 58
dfa51bb7
RK
59/** @brief RTP SSRC */
60static uint32_t rtp_id;
61
b1f6ca8c
RK
62/** @brief Base for timestamp */
63static uint32_t rtp_base;
64
dfa51bb7
RK
65/** @brief RTP sequence number */
66static uint16_t rtp_sequence;
67
dfa51bb7
RK
68/** @brief Network error count
69 *
70 * If too many errors occur in too short a time, we give up.
71 */
72static int rtp_errors;
73
80fb0bd9
RK
74/** @brief RTP mode */
75static int rtp_mode;
76
77#define RTP_BROADCAST 1
78#define RTP_MULTICAST 2
79#define RTP_UNICAST 3
80#define RTP_REQUEST 4
81#define RTP_AUTO 5
82
83/** @brief A unicast client */
84struct rtp_recipient {
85 struct rtp_recipient *next;
86 struct sockaddr_storage sa;
87};
88
89/** @brief List of unicast clients */
90static struct rtp_recipient *rtp_recipient_list;
91
92/** @brief Mutex protecting data structures */
93static pthread_mutex_t rtp_lock = PTHREAD_MUTEX_INITIALIZER;
94
7a2c7068 95static const char *const rtp_options[] = {
dfa51bb7
RK
96 "rtp-destination",
97 "rtp-destination-port",
98 "rtp-source",
99 "rtp-source-port",
100 "multicast-ttl",
101 "multicast-loop",
80fb0bd9 102 "rtp-mode",
2a2b84aa 103 "rtp-max-payload",
10511fad 104 "rtp-mtu-discovery",
7a2c7068
RK
105 NULL
106};
107
76e72f65
RK
108static void rtp_get_netconfig(const char *af,
109 const char *addr,
110 const char *port,
111 struct netaddress *na) {
112 char *vec[3];
113
114 vec[0] = uaudio_get(af, NULL);
115 vec[1] = uaudio_get(addr, NULL);
116 vec[2] = uaudio_get(port, NULL);
117 if(!*vec)
118 na->af = -1;
119 else
120 if(netaddress_parse(na, 3, vec))
2e9ba080 121 disorder_fatal(0, "invalid RTP address");
76e72f65
RK
122}
123
124static void rtp_set_netconfig(const char *af,
125 const char *addr,
126 const char *port,
127 const struct netaddress *na) {
128 uaudio_set(af, NULL);
129 uaudio_set(addr, NULL);
130 uaudio_set(port, NULL);
131 if(na->af != -1) {
132 int nvec;
133 char **vec;
134
135 netaddress_format(na, &nvec, &vec);
136 if(nvec > 0) {
137 uaudio_set(af, vec[0]);
138 xfree(vec[0]);
139 }
140 if(nvec > 1) {
141 uaudio_set(addr, vec[1]);
142 xfree(vec[1]);
143 }
144 if(nvec > 2) {
145 uaudio_set(port, vec[2]);
146 xfree(vec[2]);
147 }
148 xfree(vec);
149 }
150}
151
b1f6ca8c 152static size_t rtp_play(void *buffer, size_t nsamples, unsigned flags) {
dfa51bb7
RK
153 struct rtp_header header;
154 struct iovec vec[2];
b1f6ca8c
RK
155
156#if 0
157 if(flags & (UAUDIO_PAUSE|UAUDIO_RESUME))
158 fprintf(stderr, "rtp_play %zu samples%s%s%s%s\n", nsamples,
159 flags & UAUDIO_PAUSE ? " UAUDIO_PAUSE" : "",
160 flags & UAUDIO_RESUME ? " UAUDIO_RESUME" : "",
161 flags & UAUDIO_PLAYING ? " UAUDIO_PLAYING" : "",
162 flags & UAUDIO_PAUSED ? " UAUDIO_PAUSED" : "");
163#endif
164
dfa51bb7
RK
165 /* We do as much work as possible before checking what time it is */
166 /* Fill out header */
167 header.vpxcc = 2 << 6; /* V=2, P=0, X=0, CC=0 */
168 header.seq = htons(rtp_sequence++);
169 header.ssrc = rtp_id;
b1f6ca8c
RK
170 header.mpt = rtp_payload;
171 /* If we've come out of a pause, set the marker bit */
172 if(flags & UAUDIO_RESUME)
173 header.mpt |= 0x80;
dfa51bb7
RK
174#if !WORDS_BIGENDIAN
175 /* Convert samples to network byte order */
176 uint16_t *u = buffer, *const limit = u + nsamples;
177 while(u < limit) {
178 *u = htons(*u);
179 ++u;
180 }
181#endif
182 vec[0].iov_base = (void *)&header;
183 vec[0].iov_len = sizeof header;
184 vec[1].iov_base = buffer;
185 vec[1].iov_len = nsamples * uaudio_sample_size;
b1f6ca8c
RK
186 const uint32_t timestamp = uaudio_schedule_sync();
187 header.timestamp = htonl(rtp_base + (uint32_t)timestamp);
87864f77
RK
188
189 /* We send ~120 packets a second with current arrangements. So if we log
190 * once every 8192 packets we log about once a minute. */
191
192 if(!(ntohs(header.seq) & 8191)
193 && config->rtp_verbose)
194 disorder_info("RTP: seq %04"PRIx16" %08"PRIx32"+%08"PRIx32"=%08"PRIx32" ns %zu%s",
195 ntohs(header.seq),
196 rtp_base,
197 timestamp,
198 header.timestamp,
199 nsamples,
200 flags & UAUDIO_PAUSED ? " [paused]" : "");
201
b1f6ca8c
RK
202 /* If we're paused don't actually end a packet, we just pretend */
203 if(flags & UAUDIO_PAUSED) {
204 uaudio_schedule_sent(nsamples);
205 return nsamples;
206 }
43e7474d
MW
207 /* Send stuff to explicitly registerd unicast addresses unconditionally */
208 struct rtp_recipient *r;
209 struct msghdr m;
210 memset(&m, 0, sizeof m);
211 m.msg_iov = vec;
212 m.msg_iovlen = 2;
213 pthread_mutex_lock(&rtp_lock);
214 for(r = rtp_recipient_list; r; r = r->next) {
215 m.msg_name = &r->sa;
216 m.msg_namelen = r->sa.ss_family == AF_INET ?
217 sizeof(struct sockaddr_in) : sizeof (struct sockaddr_in6);
218 sendmsg(r->sa.ss_family == AF_INET ? rtp_fd4 : rtp_fd6,
219 &m, MSG_DONTWAIT|MSG_NOSIGNAL);
220 // TODO similar error handling to other case?
221 }
222 pthread_mutex_unlock(&rtp_lock);
223 if(rtp_mode != RTP_REQUEST) {
80fb0bd9
RK
224 int written_bytes;
225 do {
226 written_bytes = writev(rtp_fd, vec, 2);
227 } while(written_bytes < 0 && errno == EINTR);
228 if(written_bytes < 0) {
229 disorder_error(errno, "error transmitting audio data");
230 ++rtp_errors;
231 if(rtp_errors == 10)
232 disorder_fatal(0, "too many audio transmission errors");
233 return 0;
234 } else
235 rtp_errors /= 2; /* gradual decay */
236 }
b1f6ca8c
RK
237 /* TODO what can we sensibly do about short writes here? Really that's just
238 * an error and we ought to be using smaller packets. */
239 uaudio_schedule_sent(nsamples);
240 return nsamples;
dfa51bb7
RK
241}
242
d5172201
MW
243static void hack_send_buffer_size(int fd, const char *what) {
244 int sndbuf, target_sndbuf = 131072;
245 socklen_t len = sizeof sndbuf;
246
247 if(getsockopt(fd, SOL_SOCKET, SO_SNDBUF,
248 &sndbuf, &len) < 0)
249 disorder_fatal(errno, "error getting SO_SNDBUF on %s socket", what);
250 if(target_sndbuf > sndbuf) {
251 if(setsockopt(fd, SOL_SOCKET, SO_SNDBUF,
252 &target_sndbuf, sizeof target_sndbuf) < 0)
253 disorder_error(errno, "error setting SO_SNDBUF on %s socket to %d",
254 what, target_sndbuf);
255 else
256 disorder_info("changed socket send buffer size on %socket from %d to %d",
257 what, sndbuf, target_sndbuf);
258 } else
259 disorder_info("default socket send buffer on %s socket is %d",
260 what, sndbuf);
261}
262
dfa51bb7 263static void rtp_open(void) {
80fb0bd9 264 struct addrinfo *dres, *sres;
dfa51bb7 265 static const int one = 1;
76e72f65 266 struct netaddress dst[1], src[1];
80fb0bd9 267 const char *mode;
10511fad
MW
268#ifdef IP_MTU_DISCOVER
269 const char *mtu_disc;
270 int opt;
271#endif
dfa51bb7 272
80fb0bd9
RK
273 /* Get the mode */
274 mode = uaudio_get("rtp-mode", "auto");
275 if(!strcmp(mode, "broadcast")) rtp_mode = RTP_BROADCAST;
276 else if(!strcmp(mode, "multicast")) rtp_mode = RTP_MULTICAST;
277 else if(!strcmp(mode, "unicast")) rtp_mode = RTP_UNICAST;
278 else if(!strcmp(mode, "request")) rtp_mode = RTP_REQUEST;
279 else rtp_mode = RTP_AUTO;
280 /* Get the source and destination addresses (which might be missing) */
76e72f65
RK
281 rtp_get_netconfig("rtp-destination-af",
282 "rtp-destination",
283 "rtp-destination-port",
284 dst);
285 rtp_get_netconfig("rtp-source-af",
286 "rtp-source",
287 "rtp-source-port",
288 src);
80fb0bd9
RK
289 if(dst->af != -1) {
290 dres = netaddress_resolve(dst, 0, IPPROTO_UDP);
291 if(!dres)
292 exit(-1);
293 } else
294 dres = 0;
76e72f65
RK
295 if(src->af != -1) {
296 sres = netaddress_resolve(src, 1, IPPROTO_UDP);
297 if(!sres)
298 exit(-1);
dfa51bb7
RK
299 } else
300 sres = 0;
80fb0bd9
RK
301 /* _AUTO inspects the destination address and acts accordingly */
302 if(rtp_mode == RTP_AUTO) {
303 if(!dres)
304 rtp_mode = RTP_REQUEST;
305 else if(multicast(dres->ai_addr))
306 rtp_mode = RTP_MULTICAST;
307 else {
308 struct ifaddrs *ifs;
309
310 if(getifaddrs(&ifs) < 0)
311 disorder_fatal(errno, "error calling getifaddrs");
312 while(ifs) {
313 /* (At least on Darwin) IFF_BROADCAST might be set but ifa_broadaddr
314 * still a null pointer. It turns out that there's a subsequent entry
315 * for he same interface which _does_ have ifa_broadaddr though... */
316 if((ifs->ifa_flags & IFF_BROADCAST)
317 && ifs->ifa_broadaddr
318 && sockaddr_equal(ifs->ifa_broadaddr, dres->ai_addr))
319 break;
320 ifs = ifs->ifa_next;
321 }
322 if(ifs)
323 rtp_mode = RTP_BROADCAST;
324 else
325 rtp_mode = RTP_UNICAST;
326 }
327 }
2a2b84aa
MW
328 rtp_max_payload = atoi(uaudio_get("rtp-max-payload", "-1"));
329 if(rtp_max_payload < 0)
330 rtp_max_payload = 1500 - 8/*UDP*/ - 40/*IP*/ - 8/*conservatism*/;
ac52c873 331 /* Create the sockets */
80fb0bd9
RK
332 if(rtp_mode != RTP_REQUEST) {
333 if((rtp_fd = socket(dres->ai_family,
334 dres->ai_socktype,
335 dres->ai_protocol)) < 0)
336 disorder_fatal(errno, "error creating RTP transmission socket");
80fb0bd9 337 }
ac52c873
MW
338 if((rtp_fd4 = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
339 disorder_fatal(errno, "error creating v4 RTP transmission socket");
340 if((rtp_fd6 = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP)) < 0)
341 disorder_fatal(errno, "error creating v6 RTP transmission socket");
80fb0bd9
RK
342 /* Configure the socket according to the desired mode */
343 switch(rtp_mode) {
344 case RTP_MULTICAST: {
dfa51bb7 345 /* Enable multicast options */
b50cfb8a
RK
346 const int ttl = atoi(uaudio_get("multicast-ttl", "1"));
347 const int loop = !strcmp(uaudio_get("multicast-loop", "yes"), "yes");
80fb0bd9 348 switch(dres->ai_family) {
dfa51bb7
RK
349 case PF_INET: {
350 if(setsockopt(rtp_fd, IPPROTO_IP, IP_MULTICAST_TTL,
351 &ttl, sizeof ttl) < 0)
2e9ba080 352 disorder_fatal(errno, "error setting IP_MULTICAST_TTL on multicast socket");
dfa51bb7
RK
353 if(setsockopt(rtp_fd, IPPROTO_IP, IP_MULTICAST_LOOP,
354 &loop, sizeof loop) < 0)
2e9ba080 355 disorder_fatal(errno, "error setting IP_MULTICAST_LOOP on multicast socket");
dfa51bb7
RK
356 break;
357 }
358 case PF_INET6: {
359 if(setsockopt(rtp_fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
360 &ttl, sizeof ttl) < 0)
2e9ba080 361 disorder_fatal(errno, "error setting IPV6_MULTICAST_HOPS on multicast socket");
dfa51bb7
RK
362 if(setsockopt(rtp_fd, IPPROTO_IP, IPV6_MULTICAST_LOOP,
363 &loop, sizeof loop) < 0)
2e9ba080 364 disorder_fatal(errno, "error setting IPV6_MULTICAST_LOOP on multicast socket");
dfa51bb7
RK
365 break;
366 }
367 default:
80fb0bd9 368 disorder_fatal(0, "unsupported address family %d", dres->ai_family);
dfa51bb7 369 }
2e9ba080 370 disorder_info("multicasting on %s TTL=%d loop=%s",
80fb0bd9
RK
371 format_sockaddr(dres->ai_addr), ttl, loop ? "yes" : "no");
372 break;
373 }
374 case RTP_UNICAST: {
375 disorder_info("unicasting on %s", format_sockaddr(dres->ai_addr));
376 break;
377 }
378 case RTP_BROADCAST: {
379 if(setsockopt(rtp_fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof one) < 0)
380 disorder_fatal(errno, "error setting SO_BROADCAST on broadcast socket");
381 disorder_info("broadcasting on %s",
382 format_sockaddr(dres->ai_addr));
383 break;
384 }
385 case RTP_REQUEST: {
386 disorder_info("will transmit on request");
387 break;
388 }
dfa51bb7 389 }
d5172201 390 /* Enlarge the socket buffers */
ac52c873
MW
391 if (rtp_fd != -1) hack_send_buffer_size(rtp_fd, "master socket");
392 hack_send_buffer_size(rtp_fd4, "IPv4 on-demand socket");
dc24572f 393 hack_send_buffer_size(rtp_fd6, "IPv6 on-demand socket");
dfa51bb7
RK
394 /* We might well want to set additional broadcast- or multicast-related
395 * options here */
80fb0bd9
RK
396 if(rtp_mode != RTP_REQUEST) {
397 if(sres && bind(rtp_fd, sres->ai_addr, sres->ai_addrlen) < 0)
398 disorder_fatal(errno, "error binding broadcast socket to %s",
399 format_sockaddr(sres->ai_addr));
400 if(connect(rtp_fd, dres->ai_addr, dres->ai_addrlen) < 0)
401 disorder_fatal(errno, "error connecting broadcast socket to %s",
402 format_sockaddr(dres->ai_addr));
403 }
10511fad
MW
404#ifdef IP_MTU_DISCOVER
405 mtu_disc = uaudio_get("rtp-mtu-discovery", "default");
406 do {
407 if(!strcmp(mtu_disc, "yes")) opt = IP_PMTUDISC_DO;
408 else if(!strcmp(mtu_disc, "no")) opt = IP_PMTUDISC_DONT;
409 else break;
410 if(setsockopt(rtp_fd4, IPPROTO_IP, IP_MTU_DISCOVER, &opt, sizeof opt))
411 disorder_fatal(errno, "error setting MTU discovery");
412 if(sres->ai_family == AF_INET &&
413 setsockopt(rtp_fd, IPPROTO_IP, IP_MTU_DISCOVER, &opt, sizeof opt))
414 disorder_fatal(errno, "error setting MTU discovery");
415 } while (0);
416#endif
87864f77
RK
417 if(config->rtp_verbose)
418 disorder_info("RTP: prepared socket");
dfa51bb7
RK
419}
420
7a2c7068
RK
421static void rtp_start(uaudio_callback *callback,
422 void *userdata) {
dfa51bb7
RK
423 /* We only support L16 (but we do stereo and mono and will convert sign) */
424 if(uaudio_channels == 2
425 && uaudio_bits == 16
426 && uaudio_rate == 44100)
427 rtp_payload = 10;
428 else if(uaudio_channels == 1
429 && uaudio_bits == 16
430 && uaudio_rate == 44100)
431 rtp_payload = 11;
432 else
2e9ba080
RK
433 disorder_fatal(0, "asked for %d/%d/%d 16/44100/1 and 16/44100/2",
434 uaudio_bits, uaudio_rate, uaudio_channels);
87864f77
RK
435 if(config->rtp_verbose)
436 disorder_info("RTP: %d channels %d bits %d Hz payload type %d",
437 uaudio_channels, uaudio_bits, uaudio_rate, rtp_payload);
ec57f6c9
RK
438 /* Various fields are required to have random initial values by RFC3550. The
439 * packet contents are highly public so there's no point asking for very
440 * strong randomness. */
441 gcry_create_nonce(&rtp_id, sizeof rtp_id);
b1f6ca8c 442 gcry_create_nonce(&rtp_base, sizeof rtp_base);
ec57f6c9 443 gcry_create_nonce(&rtp_sequence, sizeof rtp_sequence);
87864f77
RK
444 if(config->rtp_verbose)
445 disorder_info("RTP: id %08"PRIx32" base %08"PRIx32" initial seq %08"PRIx16,
446 rtp_id, rtp_base, rtp_sequence);
dfa51bb7 447 rtp_open();
ec57f6c9 448 uaudio_schedule_init();
87864f77
RK
449 if(config->rtp_verbose)
450 disorder_info("RTP: initialized schedule");
dfa51bb7
RK
451 uaudio_thread_start(callback,
452 userdata,
453 rtp_play,
454 256 / uaudio_sample_size,
2a2b84aa 455 (rtp_max_payload - sizeof(struct rtp_header))
63761c19
RK
456 / uaudio_sample_size,
457 0);
87864f77
RK
458 if(config->rtp_verbose)
459 disorder_info("RTP: created thread");
7a2c7068
RK
460}
461
462static void rtp_stop(void) {
dfa51bb7 463 uaudio_thread_stop();
ac52c873
MW
464 if(rtp_fd >= 0) { close(rtp_fd); rtp_fd = -1; }
465 if(rtp_fd4 >= 0) { close(rtp_fd4); rtp_fd4 = -1; }
2301e915 466 if(rtp_fd6 >= 0) { close(rtp_fd6); rtp_fd6 = -1; }
7a2c7068
RK
467}
468
ba70caca
RK
469static void rtp_configure(void) {
470 char buffer[64];
471
b0116b5c 472 uaudio_set("rtp-mode", config->rtp_mode);
76e72f65
RK
473 rtp_set_netconfig("rtp-destination-af",
474 "rtp-destination",
475 "rtp-destination-port", &config->broadcast);
476 rtp_set_netconfig("rtp-source-af",
477 "rtp-source",
478 "rtp-source-port", &config->broadcast_from);
ba70caca
RK
479 snprintf(buffer, sizeof buffer, "%ld", config->multicast_ttl);
480 uaudio_set("multicast-ttl", buffer);
481 uaudio_set("multicast-loop", config->multicast_loop ? "yes" : "no");
2a2b84aa
MW
482 snprintf(buffer, sizeof buffer, "%ld", config->rtp_max_payload);
483 uaudio_set("rtp-max-payload", buffer);
10511fad 484 uaudio_set("rtp-mtu-discovery", config->rtp_mtu_discovery);
87864f77
RK
485 if(config->rtp_verbose)
486 disorder_info("RTP: configured");
ba70caca
RK
487}
488
80fb0bd9
RK
489/** @brief Add an RTP recipient address
490 * @param sa Pointer to recipient address
491 * @return 0 on success, -1 on error
492 */
493int rtp_add_recipient(const struct sockaddr_storage *sa) {
494 struct rtp_recipient *r;
495 int rc;
496 pthread_mutex_lock(&rtp_lock);
497 for(r = rtp_recipient_list;
498 r && sockaddrcmp((struct sockaddr *)sa,
499 (struct sockaddr *)&r->sa);
500 r = r->next)
501 ;
502 if(r)
503 rc = -1;
504 else {
505 r = xmalloc(sizeof *r);
c0dadbae 506 memcpy(&r->sa, sa, sizeof *sa);
80fb0bd9
RK
507 r->next = rtp_recipient_list;
508 rtp_recipient_list = r;
509 rc = 0;
510 }
511 pthread_mutex_unlock(&rtp_lock);
512 return rc;
513}
514
515/** @brief Remove an RTP recipient address
516 * @param sa Pointer to recipient address
517 * @return 0 on success, -1 on error
518 */
519int rtp_remove_recipient(const struct sockaddr_storage *sa) {
520 struct rtp_recipient *r, **rr;
521 int rc;
522 pthread_mutex_lock(&rtp_lock);
523 for(rr = &rtp_recipient_list;
524 (r = *rr) && sockaddrcmp((struct sockaddr *)sa,
525 (struct sockaddr *)&r->sa);
526 rr = &r->next)
527 ;
528 if(r) {
529 *rr = r->next;
530 xfree(r);
531 rc = 0;
532 } else {
533 disorder_error(0, "bogus rtp_remove_recipient");
534 rc = -1;
535 }
536 pthread_mutex_unlock(&rtp_lock);
537 return rc;
538}
539
7a2c7068
RK
540const struct uaudio uaudio_rtp = {
541 .name = "rtp",
542 .options = rtp_options,
543 .start = rtp_start,
544 .stop = rtp_stop,
b1f6ca8c
RK
545 .activate = uaudio_thread_activate,
546 .deactivate = uaudio_thread_deactivate,
ba70caca 547 .configure = rtp_configure,
06385470 548 .flags = UAUDIO_API_SERVER,
7a2c7068
RK
549};
550
551/*
552Local Variables:
553c-basic-offset:2
554comment-column:40
555fill-column:79
556indent-tabs-mode:nil
557End:
558*/