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