git.sesse.net Git - vlc/blob - 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 #ifdef HAVE_UNISTD_H
  40 #    include <unistd.h>
  41 #endif
  42 #include <sys/types.h>
  43 #ifdef HAVE_POLL
  44 #   include <poll.h>
  45 #endif
  46
  47 #include <vlc_network.h>
  48
  49 #define NETSYNC_PORT 9875
  50
  51 /*****************************************************************************
  52  * Module descriptor
  53  *****************************************************************************/
  54 static int  Open (vlc_object_t *);
  55 static void Close(vlc_object_t *);
  56
  57 #define NETSYNC_TEXT N_("Network master clock")
  58 #define NETSYNC_LONGTEXT N_("When set, " \
  59   "this VLC instance will act as the master clock for synchronization " \
  60   "for clients listening")
  61
  62 #define MIP_TEXT N_("Master server ip address")
  63 #define MIP_LONGTEXT N_("The IP address of " \
  64   "the network master clock to use for clock synchronization.")
  65
  66 #define NETSYNC_TIMEOUT_TEXT N_("UDP timeout (in ms)")
  67 #define NETSYNC_TIMEOUT_LONGTEXT N_("Length of time (in ms) " \
  68   "until aborting data reception.")
  69
  70 vlc_module_begin()
  71     set_shortname(N_("Network Sync"))
  72     set_description(N_("Network synchronization"))
  73     set_category(CAT_ADVANCED)
  74     set_subcategory(SUBCAT_ADVANCED_MISC)
  75
  76     add_bool("netsync-master", false,
  77               NETSYNC_TEXT, NETSYNC_LONGTEXT, true)
  78     add_string("netsync-master-ip", NULL, MIP_TEXT, MIP_LONGTEXT,
  79                 true)
  80     add_integer("netsync-timeout", 500,
  81                  NETSYNC_TIMEOUT_TEXT, NETSYNC_TIMEOUT_LONGTEXT, true)
  82
  83     set_capability("interface", 0)
  84     set_callbacks(Open, Close)
  85 vlc_module_end()
  86
  87 /*****************************************************************************
  88  * Local prototypes
  89  *****************************************************************************/
  90 struct intf_sys_t {
  91     int            fd;
  92     int            timeout;
  93     bool           is_master;
  94     playlist_t     *playlist;
  95
  96     /* */
  97     input_thread_t *input;
  98     vlc_thread_t   thread;
  99 };
 100
 101 static int PlaylistEvent(vlc_object_t *, char const *cmd,
 102                          vlc_value_t oldval, vlc_value_t newval, void *data);
 103
 104 /*****************************************************************************
 105  * Activate: initialize and create stuff
 106  *****************************************************************************/
 107 static int Open(vlc_object_t *object)
 108 {
 109     intf_thread_t *intf = (intf_thread_t*)object;
 110     intf_sys_t    *sys;
 111     int fd;
 112
 113     if (!var_InheritBool(intf, "netsync-master")) {
 114         char *psz_master = var_InheritString(intf, "netsync-master-ip");
 115         if (psz_master == NULL) {
 116             msg_Err(intf, "master address not specified");
 117             return VLC_EGENERIC;
 118         }
 119         fd = net_ConnectUDP(VLC_OBJECT(intf), psz_master, NETSYNC_PORT, -1);
 120         free(psz_master);
 121     } else {
 122         fd = net_ListenUDP1(VLC_OBJECT(intf), NULL, NETSYNC_PORT);
 123     }
 124
 125     if (fd == -1) {
 126         msg_Err(intf, "Netsync socket failure");
 127         return VLC_EGENERIC;
 128     }
 129
 130     intf->p_sys = sys = malloc(sizeof(*sys));
 131     if (!sys) {
 132         net_Close(fd);
 133         return VLC_ENOMEM;
 134     }
 135
 136     sys->fd = fd;
 137     sys->is_master = var_InheritBool(intf, "netsync-master");
 138     sys->timeout = var_InheritInteger(intf, "netsync-timeout");
 139     if (sys->timeout < 500)
 140         sys->timeout = 500;
 141     sys->playlist = pl_Get(intf);
 142     sys->input = NULL;
 143
 144     var_AddCallback(sys->playlist, "input-current", PlaylistEvent, intf);
 145     return VLC_SUCCESS;
 146 }
 147
 148 /*****************************************************************************
 149  * Close: destroy interface
 150  *****************************************************************************/
 151 void Close(vlc_object_t *object)
 152 {
 153     intf_thread_t *intf = (intf_thread_t*)object;
 154     intf_sys_t *sys = intf->p_sys;
 155
 156     assert(sys->input == NULL);
 157     var_DelCallback(sys->playlist, "input-current", PlaylistEvent, intf);
 158     net_Close(sys->fd);
 159     free(sys);
 160 }
 161
 162 static mtime_t GetPcrSystem(input_thread_t *input)
 163 {
 164     int canc = vlc_savecancel();
 165     /* TODO use the delay */
 166     mtime_t system;
 167     if (input_GetPcrSystem(input, &system, NULL))
 168         system = -1;
 169     vlc_restorecancel(canc);
 170
 171     return system;
 172 }
 173
 174 static void *Master(void *handle)
 175 {
 176     intf_thread_t *intf = handle;
 177     intf_sys_t *sys = intf->p_sys;
 178     for (;;) {
 179         struct pollfd ufd = { .fd = sys->fd, .events = POLLIN, };
 180         uint64_t data[2];
 181
 182         if (poll(&ufd, 1, -1) < 0)
 183             continue;
 184
 185         /* We received something */
 186         struct sockaddr_storage from;
 187         unsigned struct_size = sizeof(from);
 188         recvfrom(sys->fd, data, sizeof(data), 0,
 189                  (struct sockaddr*)&from, &struct_size);
 190
 191         mtime_t master_system = GetPcrSystem(sys->input);
 192         if (master_system < 0)
 193             continue;
 194
 195         data[0] = hton64(mdate());
 196         data[1] = hton64(master_system);
 197
 198         /* Reply to the sender */
 199         sendto(sys->fd, data, sizeof(data), 0,
 200                (struct sockaddr *)&from, struct_size);
 201 #if 0
 202         /* not sure we need the client information to sync,
 203            since we are the master anyway */
 204         mtime_t client_system = ntoh64(data[0]);
 205         msg_Dbg(intf, "Master clockref: %"PRId64" -> %"PRId64", from %s "
 206                  "(date: %"PRId64")", client_system, master_system,
 207                  (from.ss_family == AF_INET) ? inet_ntoa(((struct sockaddr_in *)&from)->sin_addr)
 208                  : "non-IPv4", /*date*/ 0);
 209 #endif
 210     }
 211     return NULL;
 212 }
 213
 214 static void *Slave(void *handle)
 215 {
 216     intf_thread_t *intf = handle;
 217     intf_sys_t *sys = intf->p_sys;
 218
 219     for (;;) {
 220         struct pollfd ufd = { .fd = sys->fd, .events = POLLIN, };
 221         uint64_t data[2];
 222
 223         mtime_t system = GetPcrSystem(sys->input);
 224         if (system < 0)
 225             goto wait;
 226
 227         /* Send clock request to the master */
 228         data[0] = hton64(system);
 229
 230         const mtime_t send_date = mdate();
 231         if (send(sys->fd, data, sizeof(data[0]), 0) <= 0)
 232             goto wait;
 233
 234         /* Don't block */
 235         if (poll(&ufd, 1, sys->timeout) <= 0)
 236             continue;
 237
 238         const mtime_t receive_date = mdate();
 239         if (recv(sys->fd, data, sizeof(data), 0) <= 0)
 240             goto wait;
 241
 242         const mtime_t master_date   = ntoh64(data[0]);
 243         const mtime_t master_system = ntoh64(data[1]);
 244         const mtime_t diff_date = receive_date -
 245                                   ((receive_date - send_date) / 2 + master_date);
 246
 247         if (master_system > 0) {
 248             int canc = vlc_savecancel();
 249
 250             mtime_t client_system;
 251             if (!input_GetPcrSystem(sys->input, &client_system, NULL)) {
 252                 const mtime_t diff_system = client_system - master_system - diff_date;
 253                 if (diff_system != 0) {
 254                     input_ModifyPcrSystem(sys->input, true, master_system - diff_date);
 255 #if 0
 256                     msg_Dbg(intf, "Slave clockref: %"PRId64" -> %"PRId64" -> %"PRId64","
 257                              " clock diff: %"PRId64", diff: %"PRId64"",
 258                              system, master_system, client_system,
 259                              diff_system, diff_date);
 260 #endif
 261                 }
 262             }
 263             vlc_restorecancel(canc);
 264         }
 265     wait:
 266         msleep(INTF_IDLE_SLEEP);
 267     }
 268     return NULL;
 269 }
 270
 271 static int InputEvent(vlc_object_t *object, char const *cmd,
 272                       vlc_value_t oldval, vlc_value_t newval, void *data)
 273 {
 274     VLC_UNUSED(cmd); VLC_UNUSED(oldval); VLC_UNUSED(object);
 275     intf_thread_t  *intf = data;
 276     intf_sys_t     *sys = intf->p_sys;
 277
 278     if (newval.i_int == INPUT_EVENT_DEAD && sys->input) {
 279         msg_Err(intf, "InputEvent DEAD");
 280         vlc_cancel(sys->thread);
 281         vlc_join(sys->thread, NULL);
 282         vlc_object_release(sys->input);
 283         sys->input = NULL;
 284     }
 285     return VLC_SUCCESS;
 286 }
 287
 288 static int PlaylistEvent(vlc_object_t *object, char const *cmd,
 289                          vlc_value_t oldval, vlc_value_t newval, void *data)
 290 {
 291     VLC_UNUSED(cmd); VLC_UNUSED(oldval); VLC_UNUSED(object);
 292     intf_thread_t  *intf = data;
 293     intf_sys_t     *sys = intf->p_sys;
 294
 295     input_thread_t *input = newval.p_address;
 296     assert(sys->input == NULL);
 297     sys->input = vlc_object_hold(input);
 298     if (vlc_clone(&sys->thread, sys->is_master ? Master : Slave, intf,
 299                   VLC_THREAD_PRIORITY_INPUT)) {
 300         vlc_object_release(input);
 301         return VLC_SUCCESS;
 302     }
 303     var_AddCallback(input, "intf-event", InputEvent, intf);
 304     return VLC_SUCCESS;
 305 }
 306