dbus: fix timeout handling
[vlc.git] / modules / control / netsync.c
1 /*****************************************************************************
2  * netsync.c: synchronization between several network clients.
3  *****************************************************************************
4  * Copyright (C) 2004-2009 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Gildas Bazin <gbazin@videolan.org>
8  *          Jean-Paul Saman <jpsaman@videolan.org>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31 #include <assert.h>
32
33 #include <vlc_common.h>
34 #include <vlc_plugin.h>
35 #include <vlc_interface.h>
36 #include <vlc_input.h>
37 #include <vlc_playlist.h>
38
39 #include <sys/types.h>
40 #include <unistd.h>
41 #ifdef HAVE_POLL
42 #   include <poll.h>
43 #endif
44
45 #include <vlc_network.h>
46
47 #define NETSYNC_PORT 9875
48
49 /*****************************************************************************
50  * Module descriptor
51  *****************************************************************************/
52 static int  Open (vlc_object_t *);
53 static void Close(vlc_object_t *);
54
55 #define NETSYNC_TEXT N_("Network master clock")
56 #define NETSYNC_LONGTEXT N_("When set, " \
57   "this VLC instance will act as the master clock for synchronization " \
58   "for clients listening")
59
60 #define MIP_TEXT N_("Master server ip address")
61 #define MIP_LONGTEXT N_("The IP address of " \
62   "the network master clock to use for clock synchronization.")
63
64 #define NETSYNC_TIMEOUT_TEXT N_("UDP timeout (in ms)")
65 #define NETSYNC_TIMEOUT_LONGTEXT N_("Length of time (in ms) " \
66   "until aborting data reception.")
67
68 vlc_module_begin()
69     set_shortname(N_("Network Sync"))
70     set_description(N_("Network synchronization"))
71     set_category(CAT_ADVANCED)
72     set_subcategory(SUBCAT_ADVANCED_MISC)
73
74     add_bool("netsync-master", false,
75               NETSYNC_TEXT, NETSYNC_LONGTEXT, true)
76     add_string("netsync-master-ip", NULL, MIP_TEXT, MIP_LONGTEXT,
77                 true)
78     add_integer("netsync-timeout", 500,
79                  NETSYNC_TIMEOUT_TEXT, NETSYNC_TIMEOUT_LONGTEXT, true)
80
81     set_capability("interface", 0)
82     set_callbacks(Open, Close)
83 vlc_module_end()
84
85 /*****************************************************************************
86  * Local prototypes
87  *****************************************************************************/
88 struct intf_sys_t {
89     int            fd;
90     int            timeout;
91     bool           is_master;
92     playlist_t     *playlist;
93
94     /* */
95     input_thread_t *input;
96     vlc_thread_t   thread;
97 };
98
99 static int PlaylistEvent(vlc_object_t *, char const *cmd,
100                          vlc_value_t oldval, vlc_value_t newval, void *data);
101
102 /*****************************************************************************
103  * Activate: initialize and create stuff
104  *****************************************************************************/
105 static int Open(vlc_object_t *object)
106 {
107     intf_thread_t *intf = (intf_thread_t*)object;
108     intf_sys_t    *sys;
109     int fd;
110
111     if (!var_InheritBool(intf, "netsync-master")) {
112         char *psz_master = var_InheritString(intf, "netsync-master-ip");
113         if (psz_master == NULL) {
114             msg_Err(intf, "master address not specified");
115             return VLC_EGENERIC;
116         }
117         fd = net_ConnectUDP(VLC_OBJECT(intf), psz_master, NETSYNC_PORT, -1);
118         free(psz_master);
119     } else {
120         fd = net_ListenUDP1(VLC_OBJECT(intf), NULL, NETSYNC_PORT);
121     }
122
123     if (fd == -1) {
124         msg_Err(intf, "Netsync socket failure");
125         return VLC_EGENERIC;
126     }
127
128     intf->p_sys = sys = malloc(sizeof(*sys));
129     if (!sys) {
130         net_Close(fd);
131         return VLC_ENOMEM;
132     }
133
134     sys->fd = fd;
135     sys->is_master = var_InheritBool(intf, "netsync-master");
136     sys->timeout = var_InheritInteger(intf, "netsync-timeout");
137     if (sys->timeout < 500)
138         sys->timeout = 500;
139     sys->playlist = pl_Get(intf);
140     sys->input = NULL;
141
142     var_AddCallback(sys->playlist, "input-current", PlaylistEvent, intf);
143     return VLC_SUCCESS;
144 }
145
146 /*****************************************************************************
147  * Close: destroy interface
148  *****************************************************************************/
149 void Close(vlc_object_t *object)
150 {
151     intf_thread_t *intf = (intf_thread_t*)object;
152     intf_sys_t *sys = intf->p_sys;
153
154     var_DelCallback(sys->playlist, "input-current", PlaylistEvent, intf);
155
156     if (sys->input != NULL) {
157         vlc_cancel(sys->thread);
158         vlc_join(sys->thread, NULL);
159     }
160
161     net_Close(sys->fd);
162     free(sys);
163 }
164
165 static mtime_t GetPcrSystem(input_thread_t *input)
166 {
167     int canc = vlc_savecancel();
168     /* TODO use the delay */
169     mtime_t system;
170     if (input_GetPcrSystem(input, &system, NULL))
171         system = -1;
172     vlc_restorecancel(canc);
173
174     return system;
175 }
176
177 static void *Master(void *handle)
178 {
179     intf_thread_t *intf = handle;
180     intf_sys_t *sys = intf->p_sys;
181     for (;;) {
182         struct pollfd ufd = { .fd = sys->fd, .events = POLLIN, };
183         uint64_t data[2];
184
185         if (poll(&ufd, 1, -1) < 0)
186             continue;
187
188         /* We received something */
189         struct sockaddr_storage from;
190         unsigned struct_size = sizeof(from);
191         recvfrom(sys->fd, data, sizeof(data), 0,
192                  (struct sockaddr*)&from, &struct_size);
193
194         mtime_t master_system = GetPcrSystem(sys->input);
195         if (master_system < 0)
196             continue;
197
198         data[0] = hton64(mdate());
199         data[1] = hton64(master_system);
200
201         /* Reply to the sender */
202         sendto(sys->fd, data, sizeof(data), 0,
203                (struct sockaddr *)&from, struct_size);
204 #if 0
205         /* not sure we need the client information to sync,
206            since we are the master anyway */
207         mtime_t client_system = ntoh64(data[0]);
208         msg_Dbg(intf, "Master clockref: %"PRId64" -> %"PRId64", from %s "
209                  "(date: %"PRId64")", client_system, master_system,
210                  (from.ss_family == AF_INET) ? inet_ntoa(((struct sockaddr_in *)&from)->sin_addr)
211                  : "non-IPv4", /*date*/ 0);
212 #endif
213     }
214     return NULL;
215 }
216
217 static void *Slave(void *handle)
218 {
219     intf_thread_t *intf = handle;
220     intf_sys_t *sys = intf->p_sys;
221
222     for (;;) {
223         struct pollfd ufd = { .fd = sys->fd, .events = POLLIN, };
224         uint64_t data[2];
225
226         mtime_t system = GetPcrSystem(sys->input);
227         if (system < 0)
228             goto wait;
229
230         /* Send clock request to the master */
231         data[0] = hton64(system);
232
233         const mtime_t send_date = mdate();
234         if (send(sys->fd, data, sizeof(data[0]), 0) <= 0)
235             goto wait;
236
237         /* Don't block */
238         if (poll(&ufd, 1, sys->timeout) <= 0)
239             continue;
240
241         const mtime_t receive_date = mdate();
242         if (recv(sys->fd, data, sizeof(data), 0) <= 0)
243             goto wait;
244
245         const mtime_t master_date   = ntoh64(data[0]);
246         const mtime_t master_system = ntoh64(data[1]);
247         const mtime_t diff_date = receive_date -
248                                   ((receive_date - send_date) / 2 + master_date);
249
250         if (master_system > 0) {
251             int canc = vlc_savecancel();
252
253             mtime_t client_system;
254             if (!input_GetPcrSystem(sys->input, &client_system, NULL)) {
255                 const mtime_t diff_system = client_system - master_system - diff_date;
256                 if (diff_system != 0) {
257                     input_ModifyPcrSystem(sys->input, true, master_system - diff_date);
258 #if 0
259                     msg_Dbg(intf, "Slave clockref: %"PRId64" -> %"PRId64" -> %"PRId64","
260                              " clock diff: %"PRId64", diff: %"PRId64"",
261                              system, master_system, client_system,
262                              diff_system, diff_date);
263 #endif
264                 }
265             }
266             vlc_restorecancel(canc);
267         }
268     wait:
269         msleep(INTF_IDLE_SLEEP);
270     }
271     return NULL;
272 }
273
274 static int PlaylistEvent(vlc_object_t *object, char const *cmd,
275                          vlc_value_t oldval, vlc_value_t newval, void *data)
276 {
277     VLC_UNUSED(cmd); VLC_UNUSED(object);
278     intf_thread_t  *intf = data;
279     intf_sys_t     *sys = intf->p_sys;
280     input_thread_t *input = newval.p_address;
281
282     if (sys->input != NULL) {
283         msg_Err(intf, "InputEvent DEAD");
284         assert(oldval.p_address == sys->input);
285
286         vlc_cancel(sys->thread);
287         vlc_join(sys->thread, NULL);
288     }
289
290     sys->input = input;
291
292     if (input != NULL) {
293         if (vlc_clone(&sys->thread, sys->is_master ? Master : Slave, intf,
294                       VLC_THREAD_PRIORITY_INPUT))
295             sys->input = NULL;
296     }
297     return VLC_SUCCESS;
298 }
299