88bc4292d7a1e426a7cd9e650e99afd804b375ad
[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     assert(sys->input == NULL);
155     var_DelCallback(sys->playlist, "input-current", PlaylistEvent, intf);
156     net_Close(sys->fd);
157     free(sys);
158 }
159
160 static mtime_t GetPcrSystem(input_thread_t *input)
161 {
162     int canc = vlc_savecancel();
163     /* TODO use the delay */
164     mtime_t system;
165     if (input_GetPcrSystem(input, &system, NULL))
166         system = -1;
167     vlc_restorecancel(canc);
168
169     return system;
170 }
171
172 static void *Master(void *handle)
173 {
174     intf_thread_t *intf = handle;
175     intf_sys_t *sys = intf->p_sys;
176     for (;;) {
177         struct pollfd ufd = { .fd = sys->fd, .events = POLLIN, };
178         uint64_t data[2];
179
180         if (poll(&ufd, 1, -1) < 0)
181             continue;
182
183         /* We received something */
184         struct sockaddr_storage from;
185         unsigned struct_size = sizeof(from);
186         recvfrom(sys->fd, data, sizeof(data), 0,
187                  (struct sockaddr*)&from, &struct_size);
188
189         mtime_t master_system = GetPcrSystem(sys->input);
190         if (master_system < 0)
191             continue;
192
193         data[0] = hton64(mdate());
194         data[1] = hton64(master_system);
195
196         /* Reply to the sender */
197         sendto(sys->fd, data, sizeof(data), 0,
198                (struct sockaddr *)&from, struct_size);
199 #if 0
200         /* not sure we need the client information to sync,
201            since we are the master anyway */
202         mtime_t client_system = ntoh64(data[0]);
203         msg_Dbg(intf, "Master clockref: %"PRId64" -> %"PRId64", from %s "
204                  "(date: %"PRId64")", client_system, master_system,
205                  (from.ss_family == AF_INET) ? inet_ntoa(((struct sockaddr_in *)&from)->sin_addr)
206                  : "non-IPv4", /*date*/ 0);
207 #endif
208     }
209     return NULL;
210 }
211
212 static void *Slave(void *handle)
213 {
214     intf_thread_t *intf = handle;
215     intf_sys_t *sys = intf->p_sys;
216
217     for (;;) {
218         struct pollfd ufd = { .fd = sys->fd, .events = POLLIN, };
219         uint64_t data[2];
220
221         mtime_t system = GetPcrSystem(sys->input);
222         if (system < 0)
223             goto wait;
224
225         /* Send clock request to the master */
226         data[0] = hton64(system);
227
228         const mtime_t send_date = mdate();
229         if (send(sys->fd, data, sizeof(data[0]), 0) <= 0)
230             goto wait;
231
232         /* Don't block */
233         if (poll(&ufd, 1, sys->timeout) <= 0)
234             continue;
235
236         const mtime_t receive_date = mdate();
237         if (recv(sys->fd, data, sizeof(data), 0) <= 0)
238             goto wait;
239
240         const mtime_t master_date   = ntoh64(data[0]);
241         const mtime_t master_system = ntoh64(data[1]);
242         const mtime_t diff_date = receive_date -
243                                   ((receive_date - send_date) / 2 + master_date);
244
245         if (master_system > 0) {
246             int canc = vlc_savecancel();
247
248             mtime_t client_system;
249             if (!input_GetPcrSystem(sys->input, &client_system, NULL)) {
250                 const mtime_t diff_system = client_system - master_system - diff_date;
251                 if (diff_system != 0) {
252                     input_ModifyPcrSystem(sys->input, true, master_system - diff_date);
253 #if 0
254                     msg_Dbg(intf, "Slave clockref: %"PRId64" -> %"PRId64" -> %"PRId64","
255                              " clock diff: %"PRId64", diff: %"PRId64"",
256                              system, master_system, client_system,
257                              diff_system, diff_date);
258 #endif
259                 }
260             }
261             vlc_restorecancel(canc);
262         }
263     wait:
264         msleep(INTF_IDLE_SLEEP);
265     }
266     return NULL;
267 }
268
269 static int InputEvent(vlc_object_t *object, char const *cmd,
270                       vlc_value_t oldval, vlc_value_t newval, void *data)
271 {
272     VLC_UNUSED(cmd); VLC_UNUSED(oldval); VLC_UNUSED(object);
273     intf_thread_t  *intf = data;
274     intf_sys_t     *sys = intf->p_sys;
275
276     if (newval.i_int == INPUT_EVENT_DEAD && sys->input) {
277         msg_Err(intf, "InputEvent DEAD");
278         vlc_cancel(sys->thread);
279         vlc_join(sys->thread, NULL);
280         vlc_object_release(sys->input);
281         sys->input = NULL;
282     }
283     return VLC_SUCCESS;
284 }
285
286 static int PlaylistEvent(vlc_object_t *object, char const *cmd,
287                          vlc_value_t oldval, vlc_value_t newval, void *data)
288 {
289     VLC_UNUSED(cmd); VLC_UNUSED(oldval); VLC_UNUSED(object);
290     intf_thread_t  *intf = data;
291     intf_sys_t     *sys = intf->p_sys;
292
293     input_thread_t *input = newval.p_address;
294     assert(sys->input == NULL);
295     sys->input = vlc_object_hold(input);
296     if (vlc_clone(&sys->thread, sys->is_master ? Master : Slave, intf,
297                   VLC_THREAD_PRIORITY_INPUT)) {
298         vlc_object_release(input);
299         sys->input = NULL;
300         return VLC_SUCCESS;
301     }
302     var_AddCallback(input, "intf-event", InputEvent, intf);
303     return VLC_SUCCESS;
304 }
305