replace dispatch_clock variables with mclk() and gclk()

diff --git a/src/clock.h b/src/clock.h
index c2a65d0c4ab01730529c4d12fff8c50d99693226..328b3af827844505db8b57c656b40a0f55564e7c 100644 (file)
--- a/src/clock.h
+++ b/src/clock.h
@@ -39,8 +39,18 @@ static inline int clock_gettime(int clk_id, struct timespec* t) {
 }
 #endif
 
-extern int64_t mdispatch_clock;
-extern time_t  gdispatch_clock;
+extern int64_t __mdispatch_clock;
+extern time_t  __gdispatch_clock;
+
+static inline int64_t mclk(void)
+{
+  return atomic_add_s64(&__mdispatch_clock, 0);
+}
+
+static inline time_t gclk(void)
+{
+  return atomic_add_time_t(&__gdispatch_clock, 0);
+}
 
 #define MONOCLOCK_RESOLUTION 1000000LL /* microseconds */
 
@@ -90,9 +100,6 @@ getfastmonoclock(void)
          (tp.tv_nsec / (1000000000LL/MONOCLOCK_RESOLUTION));
 }
 
-time_t  gdispatch_clock_update(void);
-int64_t mdispatch_clock_update(void);
-
 void time_t_out_of_range_notify(int64_t val);
 
 static inline time_t time_t_out_of_range(uint64_t val)

diff --git a/src/descrambler/capmt.c b/src/descrambler/capmt.c
index 7acfae83c6afa6626b20909caa2ac0e4101ada38..96a508d3c55963fe0a5618b9ba96e72cff71be37 100644 (file)
--- a/src/descrambler/capmt.c
+++ b/src/descrambler/capmt.c
@@ -1772,7 +1772,7 @@ capmt_thread(void *aux)
 
     tvhlog(LOG_INFO, "capmt", "%s: Automatic reconnection attempt in in %d seconds", idnode_get_title(&capmt->cac_id, NULL), d);
 
-    mono = mdispatch_clock + sec2mono(d);
+    mono = mclk() + sec2mono(d);
     do {
       i = tvh_cond_timedwait(&capmt->capmt_cond, &capmt->capmt_mutex, mono);
       if (i == ETIMEDOUT)

diff --git a/src/descrambler/cwc.c b/src/descrambler/cwc.c
index 289fefe12ecc63786206c0e30addef51a04d2a86..cf619a81d677a4b5e5ad5046ea2f38f0136d6d64 100644 (file)
--- a/src/descrambler/cwc.c
+++ b/src/descrambler/cwc.c
@@ -1068,7 +1068,7 @@ cwc_writer_thread(void *aux)
 
     /* If nothing is to be sent in CWC_KEEPALIVE_INTERVAL seconds we
        need to send a keepalive */
-    mono = mdispatch_clock + sec2mono(CWC_KEEPALIVE_INTERVAL);
+    mono = mclk() + sec2mono(CWC_KEEPALIVE_INTERVAL);
     do {
       r = tvh_cond_timedwait(&cwc->cwc_writer_cond, &cwc->cwc_writer_mutex, mono);
       if(r == ETIMEDOUT) {
@@ -1247,7 +1247,7 @@ cwc_thread(void *aux)
            "%s:%i: Automatic connection attempt in %d seconds",
            cwc->cwc_hostname, cwc->cwc_port, d-1);
 
-    mono = mdispatch_clock + sec2mono(d);
+    mono = mclk() + sec2mono(d);
     do {
       r = tvh_cond_timedwait(&cwc->cwc_cond, &cwc->cwc_mutex, mono);
       if (r == ETIMEDOUT)
@@ -1316,10 +1316,10 @@ cwc_emm(void *opaque, int pid, const uint8_t *data, int len, int emm)
   if (pcard->running && cwc->cwc_forward_emm && cwc->cwc_writer_running) {
     if (cwc->cwc_emmex) {
       if (cwc->cwc_mux != mux) {
-        if (cwc->cwc_update_time + sec2mono(25) < mdispatch_clock)
+        if (cwc->cwc_update_time + sec2mono(25) < mclk())
           goto end_of_job;
       }
-      cwc->cwc_update_time = mdispatch_clock;
+      cwc->cwc_update_time = mclk();
     }
     cwc->cwc_mux = mux;
     emm_filter(&pcard->cs_ra, data, len, mux, cwc_emm_send, pcard);

diff --git a/src/descrambler/descrambler.c b/src/descrambler/descrambler.c
index 99bef606b81d4eec3760e2529636ce0142295de2..105ee1be7114141e3c2a0d3f1d21faf34c7e2fee 100644 (file)
--- a/src/descrambler/descrambler.c
+++ b/src/descrambler/descrambler.c
@@ -84,14 +84,14 @@ descrambler_data_append(th_descrambler_runtime_t *dr, const uint8_t *tsb, int le
   if (len == 0)
     return;
   dd = TAILQ_LAST(&dr->dr_queue, th_descrambler_queue);
-  if (dd && mono2sec(dd->dd_timestamp) == mono2sec(mdispatch_clock) &&
+  if (dd && mono2sec(dd->dd_timestamp) == mono2sec(mclk()) &&
       (dd->dd_sbuf.sb_data[3] & 0x40) == (tsb[3] & 0x40)) { /* key match */
     sbuf_append(&dd->dd_sbuf, tsb, len);
     dr->dr_queue_total += len;
     return;
   }
   dd = malloc(sizeof(*dd));
-  dd->dd_timestamp = mdispatch_clock;
+  dd->dd_timestamp = mclk();
   sbuf_init(&dd->dd_sbuf);
   sbuf_append(&dd->dd_sbuf, tsb, len);
   TAILQ_INSERT_TAIL(&dr->dr_queue, dd, dd_link);
@@ -451,14 +451,14 @@ descrambler_keys ( th_descrambler_t *td, int type,
     memcpy(dr->dr_key_even, even, dr->dr_csa.csa_keylen);
     dr->dr_key_changed |= 1;
     dr->dr_key_valid |= 0x40;
-    dr->dr_key_timestamp[0] = mdispatch_clock;
+    dr->dr_key_timestamp[0] = mclk();
   }
   if (memcmp(empty, odd, dr->dr_csa.csa_keylen)) {
     j++;
     memcpy(dr->dr_key_odd, odd, dr->dr_csa.csa_keylen);
     dr->dr_key_changed |= 2;
     dr->dr_key_valid |= 0x80;
-    dr->dr_key_timestamp[1] = mdispatch_clock;
+    dr->dr_key_timestamp[1] = mclk();
   }
 
   if (j) {
@@ -491,7 +491,7 @@ descrambler_keys ( th_descrambler_t *td, int type,
       tvhtrace("descrambler", "Unknown keys from %s for for service \"%s\"",
                td->td_nicename, ((mpegts_service_t *)t)->s_dvb_svcname);
     }
-    dr->dr_ecm_last_key_time = mdispatch_clock;
+    dr->dr_ecm_last_key_time = mclk();
     td->td_keystate = DS_RESOLVED;
     td->td_service->s_descrambler = td;
   } else {
@@ -625,7 +625,7 @@ static inline int
 key_started( th_descrambler_runtime_t *dr, uint8_t ki )
 {
   uint8_t kidx = (ki & 0x40) >> 6;
-  return mdispatch_clock - dr->dr_ecm_start[kidx] < sec2mono(5);
+  return mclk() - dr->dr_ecm_start[kidx] < sec2mono(5);
 }
 
 static int
@@ -699,7 +699,7 @@ descrambler_descramble ( service_t *t,
 
     /* process the queued TS packets */
     if (dr->dr_queue_total > 0) {
-      descrambler_data_time_flush(dr, mdispatch_clock - (dr->dr_key_interval - sec2mono(2)));
+      descrambler_data_time_flush(dr, mclk() - (dr->dr_key_interval - sec2mono(2)));
       for (dd = TAILQ_FIRST(&dr->dr_queue); dd; dd = dd_next) {
         dd_next = TAILQ_NEXT(dd, dd_link);
         sb = &dd->dd_sbuf;
@@ -745,13 +745,13 @@ descrambler_descramble ( service_t *t,
                                  "even stream key is not valid");
         goto next;
       }
-      if (key_changed(dr, ki, mdispatch_clock)) {
+      if (key_changed(dr, ki, mclk())) {
         tvhtrace("descrambler", "stream key changed to %s for service \"%s\"",
                                 (ki & 0x40) ? "odd" : "even",
                                 ((mpegts_service_t *)t)->s_dvb_svcname);
-        if (key_late(dr, ki, mdispatch_clock)) {
+        if (key_late(dr, ki, mclk())) {
           tvherror("descrambler", "ECM - key late (%ld ms) for service \"%s\"",
-                                  mono2ms(mdispatch_clock - dr->dr_ecm_last_key_time),
+                                  mono2ms(mclk() - dr->dr_ecm_last_key_time),
                                   ((mpegts_service_t *)t)->s_dvb_svcname);
           descrambler_notify_nokey(dr);
           if (ecm_reset(t, dr)) {
@@ -759,7 +759,7 @@ descrambler_descramble ( service_t *t,
             goto next;
           }
         }
-        key_update(dr, ki, mdispatch_clock);
+        key_update(dr, ki, mclk());
       }
     }
     dr->dr_skip = 1;
@@ -778,18 +778,18 @@ next:
             tvhtrace("descrambler", "initial stream key set to %s for service \"%s\"",
                                     (ki & 0x40) ? "odd" : "even",
                                     ((mpegts_service_t *)t)->s_dvb_svcname);
-            key_update(dr, ki, mdispatch_clock);
+            key_update(dr, ki, mclk());
             break;
           } else {
             descrambler_data_cut(dr, 188);
           }
         }
       } else if (dr->dr_key_index != (ki & 0x40) &&
-                 dr->dr_key_start + sec2mono(2) < mdispatch_clock) {
+                 dr->dr_key_start + sec2mono(2) < mclk()) {
         tvhtrace("descrambler", "stream key changed to %s for service \"%s\"",
                                 (ki & 0x40) ? "odd" : "even",
                                 ((mpegts_service_t *)t)->s_dvb_svcname);
-        key_update(dr, ki, mdispatch_clock);
+        key_update(dr, ki, mclk());
       }
     }
     if (count != failed) {
@@ -800,8 +800,8 @@ next:
       dbuflen = MAX(300, config.descrambler_buffer);
       if (dr->dr_queue_total >= dbuflen * 188) {
         descrambler_data_cut(dr, MAX((dbuflen / 10) * 188, len));
-        if (dr->dr_last_err + sec2mono(10) < mdispatch_clock) {
-          dr->dr_last_err = mdispatch_clock;
+        if (dr->dr_last_err + sec2mono(10) < mclk()) {
+          dr->dr_last_err = mclk();
           tvherror("descrambler", "cannot decode packets for service \"%s\"",
                    ((mpegts_service_t *)t)->s_dvb_svcname);
         } else {
@@ -873,7 +873,7 @@ descrambler_table_callback
                          t->s_dvb_svcname);
             }
             if ((ptr[0] & 0xfe) == 0x80) { /* 0x80 = even, 0x81 = odd */
-              dr->dr_ecm_start[ptr[0] & 1] = mdispatch_clock;
+              dr->dr_ecm_start[ptr[0] & 1] = mclk();
               if (dr->dr_quick_ecm)
                 dr->dr_key_valid &= ~(1 << ((ptr[0] & 1) + 6)); /* 0x40 = even, 0x80 = odd */
             }

diff --git a/src/dvr/dvr_db.c b/src/dvr/dvr_db.c
index dff53310480e0659d104ca845299439e8970afb4..1bb194aca7645d9b3c55385433a45d404ce9df05 100644 (file)
--- a/src/dvr/dvr_db.c
+++ b/src/dvr/dvr_db.c
@@ -354,7 +354,7 @@ dvr_dbus_timer_cb( void *aux )
     if (de->de_sched_state != DVR_SCHEDULED)
       continue;
     start = dvr_entry_get_start_time(de, 1);
-    if (gdispatch_clock < start && start > max)
+    if (gclk() < start && start > max)
       max = start;
   }
   /* lower the maximum value */
@@ -363,7 +363,7 @@ dvr_dbus_timer_cb( void *aux )
     if (de->de_sched_state != DVR_SCHEDULED)
       continue;
     start = dvr_entry_get_start_time(de, 1);
-    if (gdispatch_clock < start && start < result)
+    if (gclk() < start && start < result)
       result = start;
   }
   /* different? send it.... */
@@ -381,8 +381,8 @@ static void
 dvr_entry_retention_arm(dvr_entry_t *de, gti_callback_t *cb, time_t when)
 {
   uint32_t rerecord = dvr_entry_get_rerecord_errors(de);
-  if (rerecord && (when - gdispatch_clock) > 3600) {
-    when = gdispatch_clock + 3600;
+  if (rerecord && (when - gclk()) > 3600) {
+    when = gclk() + 3600;
     cb = dvr_timer_rerecord;
   }
   gtimer_arm_absn(&de->de_timer, cb, de, when);
@@ -401,7 +401,7 @@ dvr_entry_retention_timer(dvr_entry_t *de)
 
   stop = time_t_out_of_range((int64_t)de->de_stop + removal * (int64_t)86400);
   if ((removal > 0 || retention == 0) && removal < DVR_RET_SPACE) {
-    if (stop > gdispatch_clock) {
+    if (stop > gclk()) {
       dvr_entry_retention_arm(de, dvr_timer_remove_files, stop);
       return;
     }
@@ -605,7 +605,7 @@ dvr_entry_set_timer(dvr_entry_t *de)
 
     /* EPG thinks that the program is running */
     if(de->de_running_start > de->de_running_stop && !de->de_dont_reschedule) {
-      stop = gdispatch_clock + 10;
+      stop = gclk() + 10;
       if (de->de_sched_state == DVR_RECORDING)
         goto recording;
     }
@@ -951,7 +951,7 @@ dvr_entry_clone(dvr_entry_t *de)
     if(de->de_sched_state == DVR_RECORDING) {
       dvr_stop_recording(de, SM_CODE_SOURCE_RECONFIGURED, 1, 1);
       dvr_rec_migrate(de, n);
-      n->de_start = gdispatch_clock;
+      n->de_start = gclk();
       dvr_entry_start_recording(n, 1);
     } else {
       dvr_entry_set_timer(n);
@@ -1031,7 +1031,7 @@ not_so_good:
         dvr_entry_warm_time(de);
   RB_FOREACH(ev, &de->de_channel->ch_epg_schedule, sched_link) {
     if (de->de_bcast == ev) continue;
-    if (ev->start - pre < gdispatch_clock) continue;
+    if (ev->start - pre < gclk()) continue;
     if (dvr_entry_fuzzy_match(de, ev, 0, INT64_MAX))
       if (!e || e->start > ev->start)
         e = ev;
@@ -1497,8 +1497,8 @@ static dvr_entry_t *_dvr_entry_update
 
   if (!dvr_entry_is_editable(de)) {
     if (stop > 0) {
-      if (stop < gdispatch_clock)
-        stop = gdispatch_clock;
+      if (stop < gclk())
+        stop = gclk();
       if (stop < de->de_start)
         stop = de->de_start;
       if (stop != de->de_stop) {
@@ -1813,10 +1813,10 @@ void dvr_event_running(epg_broadcast_t *e, epg_source_t esrc, epg_running_t runn
                  idnode_uuid_as_str(&de->de_id, ubuf),
                  epg_broadcast_get_title(e, NULL),
                  channel_get_name(e->channel));
-        atomic_exchange_time_t(&de->de_running_start, gdispatch_clock);
+        atomic_exchange_time_t(&de->de_running_start, gclk());
       }
-      if (dvr_entry_get_start_time(de, 1) > gdispatch_clock) {
-        atomic_exchange_time_t(&de->de_start, gdispatch_clock);
+      if (dvr_entry_get_start_time(de, 1) > gclk()) {
+        atomic_exchange_time_t(&de->de_start, gclk());
         dvr_entry_set_timer(de);
         tvhdebug("dvr", "dvr entry %s event %s on %s - EPG start",
                  idnode_uuid_as_str(&de->de_id, ubuf),
@@ -1830,7 +1830,7 @@ void dvr_event_running(epg_broadcast_t *e, epg_source_t esrc, epg_running_t runn
        * sometimes, the running bits are parsed randomly for a few moments
        * so don't expect that the broacasting has only 5 seconds
        */
-      if (de->de_running_start + 5 > gdispatch_clock)
+      if (de->de_running_start + 5 > gclk())
         continue;
 
       srcname = de->de_dvb_eid == e->dvb_eid ? "event" : "other running event";
@@ -1841,7 +1841,7 @@ void dvr_event_running(epg_broadcast_t *e, epg_source_t esrc, epg_running_t runn
                  epg_broadcast_get_title(e, NULL),
                  channel_get_name(de->de_channel));
       }
-      atomic_exchange_time_t(&de->de_running_stop, gdispatch_clock);
+      atomic_exchange_time_t(&de->de_running_stop, gclk());
       atomic_exchange_time_t(&de->de_running_pause, 0);
       if (de->de_sched_state == DVR_RECORDING && de->de_running_start) {
         dvr_stop_recording(de, SM_CODE_OK, 0, 0);
@@ -1856,7 +1856,7 @@ void dvr_event_running(epg_broadcast_t *e, epg_source_t esrc, epg_running_t runn
                  idnode_uuid_as_str(&de->de_id, ubuf),
                  epg_broadcast_get_title(e, NULL),
                  channel_get_name(e->channel));
-        atomic_exchange_time_t(&de->de_running_pause, gdispatch_clock);
+        atomic_exchange_time_t(&de->de_running_pause, gclk());
       }
     }
   }
@@ -2168,8 +2168,8 @@ dvr_entry_class_stop_set(void *o, const void *_v)
   time_t v = *(time_t *)_v;
 
   if (!dvr_entry_is_editable(de)) {
-    if (v < gdispatch_clock)
-      v = gdispatch_clock;
+    if (v < gclk())
+      v = gclk();
   }
   if (v < de->de_start)
     v = de->de_start;

diff --git a/src/dvr/dvr_rec.c b/src/dvr/dvr_rec.c
index d107d7b7fd45c93433461da90d9c53c74f84ff96..7a4289930869a1f01c647f3629c38fa1487565fc 100644 (file)
--- a/src/dvr/dvr_rec.c
+++ b/src/dvr/dvr_rec.c
@@ -878,9 +878,9 @@ dvr_rec_fatal_error(dvr_entry_t *de, const char *fmt, ...)
 static void
 dvr_notify(dvr_entry_t *de)
 {
-  if (de->de_last_notify + sec2mono(5) < mdispatch_clock) {
+  if (de->de_last_notify + sec2mono(5) < mclk()) {
     idnode_notify_changed(&de->de_id);
-    de->de_last_notify = mdispatch_clock;
+    de->de_last_notify = mclk();
     htsp_dvr_entry_update(de);
   }
 }
@@ -1272,7 +1272,7 @@ dvr_thread(void *aux)
     streaming_queue_remove(sq, sm);
 
     if (running_disabled) {
-      epg_running = real_start <= gdispatch_clock;
+      epg_running = real_start <= gclk();
     } else if (sm->sm_type == SMT_PACKET || sm->sm_type == SMT_MPEGTS) {
       running_start = atomic_add_time_t(&de->de_running_start, 0);
       running_stop  = atomic_add_time_t(&de->de_running_stop,  0);
@@ -1281,13 +1281,13 @@ dvr_thread(void *aux)
         if (epg_running && atomic_add_time_t(&de->de_running_pause, 0) >= running_start)
           epg_running = 2;
       } else if (running_stop == 0) {
-        if (start_time + 2 >= gdispatch_clock) {
+        if (start_time + 2 >= gclk()) {
           TAILQ_INSERT_TAIL(&backlog, sm, sm_link);
           continue;
         } else {
           if (TAILQ_FIRST(&backlog))
             streaming_queue_clear(&backlog);
-          epg_running = real_start <= gdispatch_clock;
+          epg_running = real_start <= gclk();
         }
       } else {
         epg_running = 0;
@@ -1409,7 +1409,7 @@ dvr_thread(void *aux)
       break;
 
     case SMT_START:
-      start_time = gdispatch_clock;
+      start_time = gclk();
       packets = 0;
       if (ss)
        streaming_start_unref(ss);

diff --git a/src/dvr/dvr_timerec.c b/src/dvr/dvr_timerec.c
index c6d053624eceae0b18168ee50a89cfc3bfd954ea..c75510e88d97c1da84588c7541a08d5be29ea7bb 100644 (file)
--- a/src/dvr/dvr_timerec.c
+++ b/src/dvr/dvr_timerec.c
@@ -119,15 +119,15 @@ dvr_timerec_check(dvr_timerec_entry_t *dte)
   if(dte->dte_channel == NULL)
     goto fail;
 
-  limit = gdispatch_clock - 600;
-  start = dvr_timerec_timecorrection(gdispatch_clock, dte->dte_start, &tm_start);
-  stop  = dvr_timerec_timecorrection(gdispatch_clock, dte->dte_stop,  &tm_stop);
+  limit = gclk() - 600;
+  start = dvr_timerec_timecorrection(gclk(), dte->dte_start, &tm_start);
+  stop  = dvr_timerec_timecorrection(gclk(), dte->dte_stop,  &tm_stop);
   if (start < limit && stop < limit) {
     /* next day */
-    start = dvr_timerec_timecorrection(gdispatch_clock + 24*60*60,
+    start = dvr_timerec_timecorrection(gclk() + 24*60*60,
                                        dte->dte_start,
                                        &tm_start);
-    stop  = dvr_timerec_timecorrection(gdispatch_clock + 24*60*60,
+    stop  = dvr_timerec_timecorrection(gclk() + 24*60*60,
                                        dte->dte_stop,
                                        &tm_stop);
   }

diff --git a/src/dvr/dvr_vfsmgr.c b/src/dvr/dvr_vfsmgr.c
index aa3d6b142478215765b20bfb833e07d22417589e..cf792cadf9780ae661ddd6d5fb67a82e08a818bf 100644 (file)
--- a/src/dvr/dvr_vfsmgr.c
+++ b/src/dvr/dvr_vfsmgr.c
@@ -204,7 +204,7 @@ dvr_disk_space_cleanup(dvr_config_t *cfg)
   /* When deleting a file from the disk, the system needs some time to actually do this */
   /* If calling this function to fast after the previous call, statvfs might be wrong/not updated yet */
   /* So we are risking to delete more files than needed, so allow 10s for the system to handle previous deletes */
-  if (dvr_disk_space_config_lastdelete + sec2mono(10) > mdispatch_clock) {
+  if (dvr_disk_space_config_lastdelete + sec2mono(10) > mclk()) {
     tvhlog(LOG_WARNING, "dvr","disk space cleanup for config \"%s\" is not allowed now", configName);
     return -1;
   }
@@ -221,7 +221,7 @@ dvr_disk_space_cleanup(dvr_config_t *cfg)
 
   while (availBytes < requiredBytes || ((maximalBytes < usedBytes) && cfg->dvr_cleanup_threshold_used)) {
     oldest = NULL;
-    stoptime = gdispatch_clock;
+    stoptime = gclk();
 
     LIST_FOREACH(de, &dvrentries, de_global_link) {
       if (de->de_sched_state != DVR_COMPLETED &&
@@ -261,7 +261,7 @@ dvr_disk_space_cleanup(dvr_config_t *cfg)
       tvhlog(LOG_INFO, "dvr","Delete \"until space needed\" recording \"%s\" with stop time \"%s\" and file size \"%"PRId64" MB\"",
              lang_str_get(oldest->de_title, NULL), tbuf, TOMIB(fileSize));
 
-      dvr_disk_space_config_lastdelete = mdispatch_clock;
+      dvr_disk_space_config_lastdelete = mclk();
       if (dvr_entry_get_retention_days(oldest) == DVR_RET_ONREMOVE) {
         dvr_entry_delete(oldest);     // delete actual file
         dvr_entry_destroy(oldest, 1); // also delete database entry

diff --git a/src/epg.c b/src/epg.c
index 003afdf4506dc5189f98291a0118dc968e6050dd..e33f0d9fe3d405768b723f1baaf9cccbd290d85a 100644 (file)
--- a/src/epg.c
+++ b/src/epg.c
@@ -181,7 +181,7 @@ static void _epg_object_set_updated ( void *o )
     tvhtrace("epg", "eo [%p, %u, %d, %s] updated",
              eo, eo->id, eo->type, eo->uri);
     eo->_updated = 1;
-    eo->updated  = gdispatch_clock;
+    eo->updated  = gclk();
     LIST_INSERT_HEAD(&epg_object_updated, eo, up_link);
   }
 }
@@ -1559,7 +1559,7 @@ static void _epg_channel_timer_callback ( void *p )
   while ((ebc = RB_FIRST(&ch->ch_epg_schedule))) {
 
     /* Expire */
-    if ( ebc->stop <= gdispatch_clock ) {
+    if ( ebc->stop <= gclk() ) {
       tvhlog(LOG_DEBUG, "epg", "expire event %u (%s) from %s",
              ebc->id, epg_broadcast_get_title(ebc, NULL),
              channel_get_name(ch));
@@ -1567,7 +1567,7 @@ static void _epg_channel_timer_callback ( void *p )
       continue; // skip to next
 
     /* No now */
-    } else if (ebc->start > gdispatch_clock) {
+    } else if (ebc->start > gclk()) {
       ch->ch_epg_next = ebc;
       next            = ebc->start;
 
@@ -1761,7 +1761,7 @@ epg_broadcast_t *epg_broadcast_find_by_time
   epg_broadcast_t **ebc;
   if (!channel || !start || !stop) return NULL;
   if (stop <= start) return NULL;
-  if (stop <= gdispatch_clock) return NULL;
+  if (stop <= gclk()) return NULL;
 
   ebc = _epg_broadcast_skel();
   (*ebc)->start   = start;
@@ -1864,7 +1864,7 @@ void epg_broadcast_notify_running
   now = ch ? ch->ch_epg_now : NULL;
   if (running == EPG_RUNNING_STOP) {
     if (now == broadcast && orunning == broadcast->running)
-      broadcast->stop = gdispatch_clock - 1;
+      broadcast->stop = gclk() - 1;
   } else {
     if (broadcast != now && now) {
       now->running = EPG_RUNNING_STOP;
@@ -2090,7 +2090,7 @@ epg_broadcast_t *epg_broadcast_deserialize
   if (htsmsg_get_s64(m, "stop", &stop)) return NULL;
   if (!start || !stop) return NULL;
   if (stop <= start) return NULL;
-  if (stop <= gdispatch_clock) return NULL;
+  if (stop <= gclk()) return NULL;
   if (!(str = htsmsg_get_str(m, "episode"))) return NULL;
 
   _epg_object_deserialize(m, (epg_object_t*)*skel);
@@ -2538,7 +2538,7 @@ _eq_add ( epg_query_t *eq, epg_broadcast_t *e )
 
   /* Filtering */
   if (e == NULL) return;
-  if (e->stop < gdispatch_clock) return;
+  if (e->stop < gclk()) return;
   if (_eq_comp_num(&eq->start, e->start)) return;
   if (_eq_comp_num(&eq->stop, e->stop)) return;
   if (eq->duration.comp != EC_NO) {

diff --git a/src/epggrab/module/psip.c b/src/epggrab/module/psip.c
index f85e2d38cf03fa1d55280ea569895d8179f65291..cf6b387824c0e981d7702a12d6686531af5701d8 100644 (file)
--- a/src/epggrab/module/psip.c
+++ b/src/epggrab/module/psip.c
@@ -163,7 +163,7 @@ psip_activate_table(psip_status_t *ps, psip_table_t *pt)
   }
   ps->ps_refcount++;
   mt->mt_destroy = psip_status_destroy;
-  pt->pt_start = mdispatch_clock;
+  pt->pt_start = mclk();
   pt->pt_table = mt;
   tvhtrace("psip", "table activated - pid 0x%04X type 0x%04X", mt->mt_pid, pt->pt_type);
   return mt;
@@ -203,7 +203,7 @@ psip_reschedule_tables(psip_status_t *ps)
   total = 0;
   TAILQ_FOREACH(pt, &ps->ps_tables, pt_link) {
     total++;
-    if (pt->pt_table && pt->pt_start + sec2mono(10) < mdispatch_clock) {
+    if (pt->pt_table && pt->pt_start + sec2mono(10) < mclk()) {
       tvhtrace("psip", "table late: pid = 0x%04X, type = 0x%04X\n", pt->pt_pid, pt->pt_type);
       mpegts_table_destroy(pt->pt_table);
       pt->pt_table = NULL;

diff --git a/src/epggrab/module/pyepg.c b/src/epggrab/module/pyepg.c
index 9ea15a9dd26cdae3d5e6af525ddca9e110f0f9d2..4acfe7811485cdab993fa2de4692b75f65650efc 100644 (file)
--- a/src/epggrab/module/pyepg.c
+++ b/src/epggrab/module/pyepg.c
@@ -377,7 +377,7 @@ static int _pyepg_parse_schedule
 
   HTSMSG_FOREACH(f, tags) {
     if (strcmp(f->hmf_name, "broadcast") == 0) {
-      ec->laststamp = gdispatch_clock;
+      ec->laststamp = gclk();
       LIST_FOREACH(ilm, &ec->channels, ilm_in1_link) {
         ch = (channel_t *)ilm->ilm_in2;
         if (!ch->ch_enabled || ch->ch_epg_parent) continue;

diff --git a/src/epggrab/module/xmltv.c b/src/epggrab/module/xmltv.c
index 95f638ccf33c0f7321b9cda083687aaad498ef74..eb40b5ace85743be83b3df03c1a99d71b9d27493 100644 (file)
--- a/src/epggrab/module/xmltv.c
+++ b/src/epggrab/module/xmltv.c
@@ -613,9 +613,9 @@ static int _xmltv_parse_programme
      (attribs = htsmsg_get_map(subtag,  "attrib")) != NULL)
     icon = htsmsg_get_str(attribs, "src");
 
-  if(stop <= start || stop <= gdispatch_clock) return 0;
+  if(stop <= start || stop <= gclk()) return 0;
 
-  ec->laststamp = gdispatch_clock;
+  ec->laststamp = gclk();
   LIST_FOREACH(ilm, &ec->channels, ilm_in1_link) {
     ch = (channel_t *)ilm->ilm_in2;
     if (!ch->ch_enabled || ch->ch_epg_parent) continue;
@@ -642,7 +642,7 @@ static int _xmltv_parse_channel
   if((id      = htsmsg_get_str(attribs, "id"))   == NULL) return 0;
   if((tags    = htsmsg_get_map(body, "tags"))    == NULL) return 0;
   if((ch      = epggrab_channel_find(mod, id, 1, &save)) == NULL) return 0;
-  ch->laststamp = gdispatch_clock;
+  ch->laststamp = gclk();
   stats->channels.total++;
   if (save) stats->channels.created++;
   

diff --git a/src/epggrab/otamux.c b/src/epggrab/otamux.c
index 06f1084476fcae7ed6b4a160041e28db3fea00bd..63d1e9b81b0dcdb3dac86f5d2ceaaebad22a047b 100644 (file)
--- a/src/epggrab/otamux.c
+++ b/src/epggrab/otamux.c
@@ -641,7 +641,7 @@ epggrab_ota_start_cb ( void *p )
   epggrab_ota_kick(1);
 
   pthread_mutex_lock(&epggrab_ota_mutex);
-  if (!cron_multi_next(epggrab_ota_cron_multi, gdispatch_clock, &next))
+  if (!cron_multi_next(epggrab_ota_cron_multi, gclk(), &next))
     epggrab_ota_next_arm(next);
   else
     tvhwarn("epggrab", "ota cron config invalid or unset");

diff --git a/src/htsp_server.c b/src/htsp_server.c
index 220e9a77f0cc35b1b644347c87774215d8a57630..08998a29e5cdec8344453b98d77e169999a87169 100644 (file)
--- a/src/htsp_server.c
+++ b/src/htsp_server.c
@@ -1407,9 +1407,9 @@ htsp_method_async(htsp_connection_t *htsp, htsmsg_t *in)
     if (htsp->htsp_async_mode & HTSP_ASYNC_EPG) {
       /* Only allow to change the window in the correct range */
       if (htsp->htsp_epg_window && epgMaxTime > htsp->htsp_epg_lastupdate)
-        htsp->htsp_epg_window = epgMaxTime-gdispatch_clock;
-    } else if (epgMaxTime > gdispatch_clock) {
-      htsp->htsp_epg_window = epgMaxTime-gdispatch_clock;
+        htsp->htsp_epg_window = epgMaxTime-gclk();
+    } else if (epgMaxTime > gclk()) {
+      htsp->htsp_epg_window = epgMaxTime-gclk();
     } else {
       htsp->htsp_epg_window = 0;
     }
@@ -3663,7 +3663,7 @@ htsp_epg_send_waiting(htsp_connection_t *htsp, int64_t mintime)
   channel_t *ch;
   int64_t maxtime;
 
-  maxtime = gdispatch_clock + htsp->htsp_epg_window;
+  maxtime = gclk() + htsp->htsp_epg_window;
   htsp->htsp_epg_lastupdate = maxtime;
 
   /* Push new events */
@@ -3809,11 +3809,11 @@ htsp_stream_deliver(htsp_subscription_t *hs, th_pkt_t *pkt)
   htsp_send_subscription(htsp, m, pkt->pkt_payload, hs, payloadlen);
   atomic_add(&hs->hs_s_bytes_out, payloadlen);
 
-  if(mono2sec(hs->hs_last_report) != mono2sec(mdispatch_clock)) {
+  if(mono2sec(hs->hs_last_report) != mono2sec(mclk())) {
 
     /* Send a queue and signal status report every second */
 
-    hs->hs_last_report = mdispatch_clock;
+    hs->hs_last_report = mclk();
 
     m = htsmsg_create_map();
     htsmsg_add_str(m, "method", "queueStatus");

diff --git a/src/httpc.c b/src/httpc.c
index dc760f694dd271ae728bfc080331db9c880fc81e..e404a8a1402e726931e20005d4d934c3543c8e69 100644 (file)
--- a/src/httpc.c
+++ b/src/httpc.c
@@ -645,7 +645,7 @@ error:
   empty = TAILQ_EMPTY(&hc->hc_wqueue);
   TAILQ_INSERT_TAIL(&hc->hc_wqueue, wcmd, link);
 
-  hc->hc_ping_time = mdispatch_clock;
+  hc->hc_ping_time = mclk();
 
   if (empty)
     return http_client_send_partial(hc);

diff --git a/src/idnode.c b/src/idnode.c
index 5c8b818256175465d7dc8189a46b9459570fb9f2..5d094db5ab55bac18844bc250538705014e20e5f 100644 (file)
--- a/src/idnode.c
+++ b/src/idnode.c
@@ -1108,7 +1108,7 @@ idnode_save_queue ( idnode_t *self )
     return;
   ise = malloc(sizeof(*ise));
   ise->ise_node = self;
-  ise->ise_reqtime = mdispatch_clock;
+  ise->ise_reqtime = mclk();
   if (TAILQ_EMPTY(&idnodes_save) && save_running)
     mtimer_arm_rel(&save_timer, idnode_save_trigger_thread_cb, NULL, IDNODE_SAVE_DELAY);
   TAILQ_INSERT_TAIL(&idnodes_save, ise, ise_link);
@@ -1699,7 +1699,7 @@ save_thread ( void *aux )
 
   while (save_running) {
     if ((ise = TAILQ_FIRST(&idnodes_save)) == NULL ||
-        (ise->ise_reqtime + IDNODE_SAVE_DELAY > mdispatch_clock)) {
+        (ise->ise_reqtime + IDNODE_SAVE_DELAY > mclk())) {
       if (ise)
         mtimer_arm_abs(&save_timer, idnode_save_trigger_thread_cb, NULL,
                        ise->ise_reqtime + IDNODE_SAVE_DELAY);

diff --git a/src/imagecache.c b/src/imagecache.c
index 26d76ff5cbf37caceaf8ffec4ebe320caf5f6c2c..0466e2fa2b49821a15d9a56139890bd9626d1aba 100644 (file)
--- a/src/imagecache.c
+++ b/src/imagecache.c
@@ -668,7 +668,7 @@ imagecache_open ( uint32_t id )
 
     /* Wait */
     } else if (i->state == FETCHING) {
-      mono = mdispatch_clock + sec2mono(5);
+      mono = mclk() + sec2mono(5);
       do {
         e = tvh_cond_timedwait(&imagecache_cond, &global_lock, mono);
         if (e == ETIMEDOUT)

diff --git a/src/input/mpegts/dvb_psi.c b/src/input/mpegts/dvb_psi.c
index 6b803597ebaa0059d4a44c1ca4d3e4ed75635236..1531a151d6cf38e26be8faf35c6f77dd62f31754 100644 (file)
--- a/src/input/mpegts/dvb_psi.c
+++ b/src/input/mpegts/dvb_psi.c
@@ -118,7 +118,7 @@ dvb_service_autoenable( mpegts_service_t *s, const char *where )
             s->s_nicename, s->s_dvb_service_id, s->s_dvb_service_id, where);
     service_set_enabled((service_t *)s, 1, SERVICE_AUTO_NORMAL);
   }
-  s->s_dvb_check_seen = gdispatch_clock;
+  s->s_dvb_check_seen = gclk();
 }
 
 #if ENABLE_MPEGTS_DVB
@@ -2452,11 +2452,11 @@ static void dvb_time_update(const uint8_t *ptr, const char *srcname)
 {
   static time_t dvb_last_update = 0;
   time_t t;
-  if (dvb_last_update + 1800 < gdispatch_clock) {
+  if (dvb_last_update + 1800 < gclk()) {
     t = dvb_convert_date(ptr, 0);
     if (t > 0) {
       tvhtime_update(t, srcname);
-      dvb_last_update = gdispatch_clock;
+      dvb_last_update = gclk();
     }
   }
 }

diff --git a/src/input/mpegts/iptv/iptv_file.c b/src/input/mpegts/iptv/iptv_file.c
index 6d18765ec3d5f8098267c58ca91191fa218cb455..8abd359c9adc1122223c21630946819f2fd7e999 100644 (file)
--- a/src/input/mpegts/iptv/iptv_file.c
+++ b/src/input/mpegts/iptv/iptv_file.c
@@ -55,7 +55,7 @@ iptv_file_thread ( void *aux )
   pthread_mutex_lock(&iptv_lock);
   while (!fp->shutdown && fd > 0) {
     while (!fp->shutdown && pause) {
-      mono = mdispatch_clock + sec2mono(1);
+      mono = mclk() + sec2mono(1);
       do {
         e = tvh_cond_timedwait(&fp->cond, &iptv_lock, mono);
         if (e == ETIMEDOUT)

diff --git a/src/input/mpegts/iptv/iptv_http.c b/src/input/mpegts/iptv/iptv_http.c
index 2bcf8c9454f6e77c3d5bacf27d20365405d1be61..aea12161c9eefdfb50dc32e53d2c023c4fd201ba 100644 (file)
--- a/src/input/mpegts/iptv/iptv_http.c
+++ b/src/input/mpegts/iptv/iptv_http.c
@@ -323,14 +323,14 @@ iptv_http_data
     memcpy(hp->hls_si, buf, 2*188);
   }
 
-  if (hp->hls_last_si + sec2mono(1) <= mdispatch_clock && hp->hls_si) {
+  if (hp->hls_last_si + sec2mono(1) <= mclk() && hp->hls_si) {
     /* do rounding to start of the last MPEG-TS packet */
     rem = 188 - (hp->off % 188);
     if (im->mm_iptv_buffer.sb_ptr >= rem) {
       im->mm_iptv_buffer.sb_ptr -= rem;
       memcpy(tsbuf, im->mm_iptv_buffer.sb_data + im->mm_iptv_buffer.sb_ptr, rem);
       sbuf_append(&im->mm_iptv_buffer, hp->hls_si, 2*188);
-      hp->hls_last_si = mdispatch_clock;
+      hp->hls_last_si = mclk();
       sbuf_append(&im->mm_iptv_buffer, tsbuf, rem);
       hp->off += rem;
     }

diff --git a/src/input/mpegts/iptv/iptv_pipe.c b/src/input/mpegts/iptv/iptv_pipe.c
index bdb8640fbef34272df7bc6d6d3d609929c2c23c6..8b657b75bf9bca1194e6cbe2f4363fc011abc6cb 100644 (file)
--- a/src/input/mpegts/iptv/iptv_pipe.c
+++ b/src/input/mpegts/iptv/iptv_pipe.c
@@ -62,7 +62,7 @@ iptv_pipe_start ( iptv_mux_t *im, const char *raw, const url_t *url )
   im->mm_iptv_fd = rd;
   im->im_data = (void *)(intptr_t)pid;
 
-  im->mm_iptv_respawn_last = mdispatch_clock;
+  im->mm_iptv_respawn_last = mclk();
 
   if (url)
     iptv_input_mux_started(im);
@@ -123,7 +123,7 @@ iptv_pipe_read ( iptv_mux_t *im )
       spawn_kill(pid, iptv_pipe_kill_sig(im), im->mm_iptv_kill_timeout);
       im->mm_iptv_fd = -1;
       im->im_data = NULL;
-      if (mdispatch_clock < im->mm_iptv_respawn_last + sec2mono(2)) {
+      if (mclk() < im->mm_iptv_respawn_last + sec2mono(2)) {
         tvherror("iptv", "stdin pipe unexpectedly closed: %s",
                  r < 0 ? strerror(errno) : "No data");
       } else {
@@ -136,7 +136,7 @@ iptv_pipe_read ( iptv_mux_t *im )
             tvherror("iptv", "unable to respawn %s", im->mm_iptv_url_raw);
           } else {
             iptv_input_fd_started(im);
-            im->mm_iptv_respawn_last = mdispatch_clock;
+            im->mm_iptv_respawn_last = mclk();
           }
         }
         pthread_mutex_unlock(&iptv_lock);

diff --git a/src/input/mpegts/linuxdvb/linuxdvb_frontend.c b/src/input/mpegts/linuxdvb/linuxdvb_frontend.c
index 4fa76389afe2f5263fcbe7d7a7b7e3722ae816a3..b28b6747b330a2a6b6d0337c68291bbe22a569a5 100644 (file)
--- a/src/input/mpegts/linuxdvb/linuxdvb_frontend.c
+++ b/src/input/mpegts/linuxdvb/linuxdvb_frontend.c
@@ -789,14 +789,14 @@ linuxdvb_frontend_monitor ( void *aux )
                      lfe, ms2mono(50));
 
       /* Monitor 1 per sec */
-      if (mdispatch_clock < lfe->lfe_monitor)
+      if (mclk() < lfe->lfe_monitor)
         return;
-      lfe->lfe_monitor = mdispatch_clock + sec2mono(1);
+      lfe->lfe_monitor = mclk() + sec2mono(1);
     }
   } else {
-    if (mdispatch_clock < lfe->lfe_monitor)
+    if (mclk() < lfe->lfe_monitor)
       return;
-    lfe->lfe_monitor = mdispatch_clock + ms2mono(period);
+    lfe->lfe_monitor = mclk() + ms2mono(period);
   }
 
   /* Statistics - New API */

diff --git a/src/input/mpegts/mpegts_input.c b/src/input/mpegts/mpegts_input.c
index 43c5f9d48233dffec3e353c8a9fde856391db470..3792ae719bd41b1de457af7dc9416e2ec34d9fa2 100644 (file)
--- a/src/input/mpegts/mpegts_input.c
+++ b/src/input/mpegts/mpegts_input.c
@@ -1053,10 +1053,10 @@ mpegts_input_recv_packets
 
   if (len < (MIN_TS_PKT * 188) && (flags & MPEGTS_DATA_CC_RESTART) == 0) {
     /* For slow streams, check also against the clock */
-    if (mono2sec(mdispatch_clock) == mono2sec(mi->mi_last_dispatch))
+    if (mono2sec(mclk()) == mono2sec(mi->mi_last_dispatch))
       return;
   }
-  mi->mi_last_dispatch = mdispatch_clock;
+  mi->mi_last_dispatch = mclk();
 
   /* Check for sync */
   while ( (len >= MIN_TS_SYN) &&

diff --git a/src/input/mpegts/mpegts_network_dvb.c b/src/input/mpegts/mpegts_network_dvb.c
index 1804beb49f96b72d94ba7fddf86ae6f9dab948ed..3472d47ac331f8be5f995b6037f401531ed0c1ca 100644 (file)
--- a/src/input/mpegts/mpegts_network_dvb.c
+++ b/src/input/mpegts/mpegts_network_dvb.c
@@ -661,7 +661,7 @@ dvb_network_create_mux
     dvb_mux_t *lm = (dvb_mux_t*)mm;
     /* the nit tables may be inconsistent (like rolloff ping-pong) */
     /* accept information only from one origin mux */
-    if (mm->mm_dmc_origin_expire > mdispatch_clock && mm->mm_dmc_origin && mm->mm_dmc_origin != origin)
+    if (mm->mm_dmc_origin_expire > mclk() && mm->mm_dmc_origin && mm->mm_dmc_origin != origin)
       goto noop;
     #define COMPARE(x, cbit) ({ \
       int xr = dmc->x != lm->lm_tuning.x; \
@@ -740,7 +740,7 @@ dvb_network_create_mux
 save:
   if (mm && save) {
     mm->mm_dmc_origin        = origin;
-    mm->mm_dmc_origin_expire = mdispatch_clock + sec2mono(3600 * 24); /* one day */
+    mm->mm_dmc_origin_expire = mclk() + sec2mono(3600 * 24); /* one day */
     idnode_changed(&mm->mm_id);
   }
 noop:

diff --git a/src/input/mpegts/mpegts_service.c b/src/input/mpegts/mpegts_service.c
index 249e8a07581bdd36ed4ba03d5f9c40c6493910f5..0a68abb6d746863a150348fe437f7e1659656f3e 100644 (file)
--- a/src/input/mpegts/mpegts_service.c
+++ b/src/input/mpegts/mpegts_service.c
@@ -709,7 +709,7 @@ mpegts_service_create0
 {
   int r;
   char buf[256];
-  time_t dispatch_clock = gdispatch_clock;
+  time_t dispatch_clock = gclk();
 
   /* defaults for older version */
   s->s_dvb_created = dispatch_clock;
@@ -724,8 +724,8 @@ mpegts_service_create0
     if (sid)     s->s_dvb_service_id = sid;
     if (pmt_pid) s->s_pmt_pid        = pmt_pid;
   } else {
-    if (s->s_dvb_last_seen > gdispatch_clock) /* sanity check */
-      s->s_dvb_last_seen = gdispatch_clock;
+    if (s->s_dvb_last_seen > gclk()) /* sanity check */
+      s->s_dvb_last_seen = gclk();
   }
   s->s_dvb_mux        = mm;
   if ((r = dvb_servicetype_lookup(s->s_dvb_servicetype)) != -1)
@@ -788,8 +788,8 @@ mpegts_service_find
         if (save) *save = 1;
       }
       if (create) {
-        if ((save && *save) || s->s_dvb_last_seen + 3600 < gdispatch_clock) {
-          s->s_dvb_last_seen = gdispatch_clock;
+        if ((save && *save) || s->s_dvb_last_seen + 3600 < gclk()) {
+          s->s_dvb_last_seen = gclk();
           if (save) *save = 1;
         }
       }
@@ -800,7 +800,7 @@ mpegts_service_find
   /* Create */
   if (create) {
     s = mm->mm_network->mn_create_service(mm, sid, pmt_pid);
-    s->s_dvb_created = s->s_dvb_last_seen = gdispatch_clock;
+    s->s_dvb_created = s->s_dvb_last_seen = gclk();
     if (save) *save = 1;
   }
 

diff --git a/src/input/mpegts/satip/satip.c b/src/input/mpegts/satip/satip.c
index 655f31d45a7384ff7475bca695689dc7cf400e2a..f5dbea3431a53d68b3a72b5d5210483da58b7c37 100644 (file)
--- a/src/input/mpegts/satip/satip.c
+++ b/src/input/mpegts/satip/satip.c
@@ -1006,7 +1006,7 @@ satip_discovery_timerq_cb(void *aux)
     d = next;
     next = TAILQ_NEXT(d, disc_link);
     if (d->http_client) {
-      if (mdispatch_clock - d->http_start > sec2mono(4))
+      if (mclk() - d->http_start > sec2mono(4))
         satip_discovery_destroy(d, 1);
       continue;
     }
@@ -1016,7 +1016,7 @@ satip_discovery_timerq_cb(void *aux)
     if (d->http_client == NULL)
       satip_discovery_destroy(d, 1);
     else {
-      d->http_start = mdispatch_clock;
+      d->http_start = mclk();
       d->http_client->hc_conn_closed = satip_discovery_http_closed;
       http_client_register(d->http_client);
       r = http_client_simple(d->http_client, &d->url);

diff --git a/src/input/mpegts/satip/satip_frontend.c b/src/input/mpegts/satip/satip_frontend.c
index 703195b4ded9215edd44ecc29f6dafc7b728a79f..cb007bdd0f70b3e490aff61224953f976cc48b04 100644 (file)
--- a/src/input/mpegts/satip/satip_frontend.c
+++ b/src/input/mpegts/satip/satip_frontend.c
@@ -1123,7 +1123,7 @@ wrdata:
     }
 
     if (lfe->sf_sbuf.sb_ptr > 64 * 1024 ||
-        lfe->sf_last_data_tstamp + sec2mono(1) <= mdispatch_clock) {
+        lfe->sf_last_data_tstamp + sec2mono(1) <= mclk()) {
       pthread_mutex_lock(&lfe->sf_dvr_lock);
       if (lfe->sf_req == lfe->sf_req_thread) {
         mmi = lfe->sf_req->sf_mmi;
@@ -1132,7 +1132,7 @@ wrdata:
                                   &lfe->sf_sbuf, 0, NULL);
       }
       pthread_mutex_unlock(&lfe->sf_dvr_lock);
-      lfe->sf_last_data_tstamp = mdispatch_clock;
+      lfe->sf_last_data_tstamp = mclk();
     }
 
   } else if (b[1] == 1) {
@@ -1607,7 +1607,7 @@ new_tune:
     }
 
     /* We need to keep the session alive */
-    if (rtsp->hc_ping_time + sec2mono(rtsp->hc_rtp_timeout / 2) < mdispatch_clock &&
+    if (rtsp->hc_ping_time + sec2mono(rtsp->hc_rtp_timeout / 2) < mclk() &&
         rtsp->hc_cmd == HTTP_CMD_NONE) {
       rtsp_options(rtsp);
       reply = 1;

diff --git a/src/input/mpegts/tsdemux.c b/src/input/mpegts/tsdemux.c
index a417f23c3f95566dc6c444bfd06abffc63160f4d..fcdddc5c4e4357f6e66d1be03d16023820fb0edb 100644 (file)
--- a/src/input/mpegts/tsdemux.c
+++ b/src/input/mpegts/tsdemux.c
@@ -73,7 +73,7 @@ ts_recv_packet0
       cc = tsb2[3] & 0xf;
       if(st->es_cc != -1 && cc != st->es_cc) {
         /* Let the hardware to stabilize and don't flood the log */
-        if (t->s_start_time + sec2mono(1) < mdispatch_clock &&
+        if (t->s_start_time + sec2mono(1) < mclk() &&
             tvhlog_limit(&st->es_cc_log, 10))
           tvhwarn("TS", "%s Continuity counter error (total %zi)",
                         service_component_nicename(st), st->es_cc_log.count);
@@ -141,7 +141,7 @@ ts_recv_skipped0
       cc = tsb2[3] & 0xf;
       if(st->es_cc != -1 && cc != st->es_cc) {
         /* Let the hardware to stabilize and don't flood the log */
-        if (t->s_start_time + sec2mono(1) < mdispatch_clock &&
+        if (t->s_start_time + sec2mono(1) < mclk() &&
             tvhlog_limit(&st->es_cc_log, 10))
           tvhwarn("TS", "%s Continuity counter error (total %zi)",
                         service_component_nicename(st), st->es_cc_log.count);
@@ -325,7 +325,7 @@ ts_flush(mpegts_service_t *t, sbuf_t *sb)
   streaming_message_t sm;
   pktbuf_t *pb;
 
-  t->s_tsbuf_last = mdispatch_clock;
+  t->s_tsbuf_last = mclk();
 
   pb = pktbuf_alloc(sb->sb_data, sb->sb_ptr);
   pb->pb_err = sb->sb_err;
@@ -356,7 +356,7 @@ ts_remux(mpegts_service_t *t, const uint8_t *src, int len, int errors)
   sbuf_append(sb, src, len);
   sb->sb_err += errors;
 
-  if(mono2sec(mdispatch_clock) == mono2sec(t->s_tsbuf_last) &&
+  if(mono2sec(mclk()) == mono2sec(t->s_tsbuf_last) &&
      sb->sb_ptr < TS_REMUX_BUFSIZE)
     return;
 
@@ -379,7 +379,7 @@ ts_skip(mpegts_service_t *t, const uint8_t *src, int len)
 
   sb->sb_err += len / 188;
 
-  if(mono2sec(mdispatch_clock) == mono2sec(t->s_tsbuf_last) &&
+  if(mono2sec(mclk()) == mono2sec(t->s_tsbuf_last) &&
      sb->sb_err < (TS_REMUX_BUFSIZE / 188))
     return;
 

diff --git a/src/input/mpegts/tvhdhomerun/tvhdhomerun.c b/src/input/mpegts/tvhdhomerun/tvhdhomerun.c
index cdbb2358f1c32a63a767006d1c998484cd19e88d..3706b9e6e0f2d8dbb7ac0eda87b0cc25d6c4debe 100644 (file)
--- a/src/input/mpegts/tvhdhomerun/tvhdhomerun.c
+++ b/src/input/mpegts/tvhdhomerun/tvhdhomerun.c
@@ -379,7 +379,7 @@ tvhdhomerun_device_discovery_thread( void *aux )
     if (tvheadend_running) {
       brk = tvh_cond_timedwait(&tvhdhomerun_discovery_cond,
                                &tvhdhomerun_discovery_lock,
-                               mdispatch_clock + sec2mono(15));
+                               mclk() + sec2mono(15));
       brk = !ERRNO_AGAIN(brk) && brk != ETIMEDOUT;
     }
     pthread_mutex_unlock(&tvhdhomerun_discovery_lock);

diff --git a/src/main.c b/src/main.c
index 06890e910664626276e0f034cf5523f4e9ac180c..68753f0deeedebb5d706dae88021672b849b6924 100644 (file)
--- a/src/main.c
+++ b/src/main.c
@@ -83,6 +83,9 @@
 
 pthread_t main_tid;
 
+int64_t   __mdispatch_clock;
+time_t    __gdispatch_clock;
+
 /* Command line option struct */
 typedef struct {
   const char  sopt;
@@ -274,9 +277,9 @@ GTIMER_FCN(mtimer_arm_rel)
   (GTIMER_TRACEID_ mtimer_t *gti, mti_callback_t *callback, void *opaque, int64_t delta)
 {
 #if ENABLE_GTIMER_CHECK
-  GTIMER_FCN(mtimer_arm_abs)(id, fcn, gti, callback, opaque, mdispatch_clock + delta);
+  GTIMER_FCN(mtimer_arm_abs)(id, fcn, gti, callback, opaque, mclk() + delta);
 #else
-  mtimer_arm_abs(gti, callback, opaque, mdispatch_clock + delta);
+  mtimer_arm_abs(gti, callback, opaque, mclk() + delta);
 #endif
 }
 
@@ -335,9 +338,9 @@ GTIMER_FCN(gtimer_arm_rel)
   (GTIMER_TRACEID_ gtimer_t *gti, gti_callback_t *callback, void *opaque, time_t delta)
 {
 #if ENABLE_GTIMER_CHECK
-  GTIMER_FCN(gtimer_arm_absn)(id, fcn, gti, callback, opaque, gdispatch_clock + delta);
+  GTIMER_FCN(gtimer_arm_absn)(id, fcn, gti, callback, opaque, gclk() + delta);
 #else
-  gtimer_arm_absn(gti, callback, opaque, gdispatch_clock + delta);
+  gtimer_arm_absn(gti, callback, opaque, gclk() + delta);
 #endif
 }
 
@@ -515,17 +518,18 @@ show_usage
 /**
  *
  */
-int64_t
+static int64_t
 mdispatch_clock_update(void)
 {
   int64_t mono = getmonoclock();
 
-  if (mono > mtimer_periodic) {
-    mtimer_periodic = mono + MONOCLOCK_RESOLUTION;
+  if (mono > atomic_add_s64(&mtimer_periodic, 0)) {
+    atomic_exchange_s64(&mtimer_periodic, mono + MONOCLOCK_RESOLUTION);
     comet_flush(); /* Flush idle comet mailboxes */
   }
 
-  return mdispatch_clock = mono;
+  atomic_exchange_s64(&__mdispatch_clock, mono);
+  return mono;
 }
 
 /**
@@ -536,7 +540,7 @@ mtimer_tick_thread(void *aux)
 {
   while (tvheadend_running) {
     /* update clocks each 10x in one second */
-    mdispatch_clock = getmonoclock();
+    atomic_exchange_s64(&__mdispatch_clock, getmonoclock());
     tvh_safe_usleep(100000);
   }
   return NULL;
@@ -604,10 +608,12 @@ mtimer_thread(void *aux)
 /**
  *
  */
-time_t
+static inline time_t
 gdispatch_clock_update(void)
 {
-  return gdispatch_clock = time(NULL);
+  time_t now = time(NULL);
+  atomic_exchange_time_t(&__gdispatch_clock, now);
+  return now;
 }
 
 /**
@@ -717,8 +723,8 @@ main(int argc, char **argv)
   tvheadend_webroot         = NULL;
   tvheadend_htsp_port       = 9982;
   tvheadend_htsp_port_extra = 0;
-  mdispatch_clock = getmonoclock();
-  time(&gdispatch_clock);
+  __mdispatch_clock = getmonoclock();
+  __gdispatch_clock = time(NULL);
 
   /* Command line options */
   int         opt_help         = 0,
@@ -1083,8 +1089,8 @@ main(int argc, char **argv)
   
   /* Initialise clock */
   pthread_mutex_lock(&global_lock);
-  mdispatch_clock = getmonoclock();
-  time(&gdispatch_clock);
+  __mdispatch_clock = getmonoclock();
+  __gdispatch_clock = time(NULL);
 
   /* Signal handling */
   sigfillset(&set);

diff --git a/src/muxer/muxer_mkv.c b/src/muxer/muxer_mkv.c
index 89221c7349fc6068270880aa1fecce49e88fec96..332e893ce8acf8d1b5a5559dbe89ca4c7c8953e0 100644 (file)
--- a/src/muxer/muxer_mkv.c
+++ b/src/muxer/muxer_mkv.c
@@ -942,7 +942,7 @@ mk_close_cluster(mk_muxer_t *mk)
   if(mk->cluster != NULL)
     mk_write_master(mk, 0x1f43b675, mk->cluster);
   mk->cluster = NULL;
-  mk->cluster_last_close = mdispatch_clock;
+  mk->cluster_last_close = mclk();
 }
 
 
@@ -992,12 +992,12 @@ mk_write_frame_i(mk_muxer_t *mk, mk_track_t *t, th_pkt_t *pkt)
 
   if(vkeyframe && mk->cluster &&
      (mk->cluster->hq_size > mk->cluster_maxsize ||
-      mk->cluster_last_close + sec2mono(1) < mdispatch_clock))
+      mk->cluster_last_close + sec2mono(1) < mclk()))
     mk_close_cluster(mk);
 
   else if(!mk->has_video && mk->cluster &&
           (mk->cluster->hq_size > clusersizemax/40 ||
-           mk->cluster_last_close + sec2mono(1) < mdispatch_clock))
+           mk->cluster_last_close + sec2mono(1) < mclk()))
     mk_close_cluster(mk);
 
   else if(mk->cluster && mk->cluster->hq_size > clusersizemax)

diff --git a/src/parsers/parser_h264.c b/src/parsers/parser_h264.c
index bd7986e7c7345c47ba5ad36df2937a78788ddcc9..a51da34f42546e1867cdadeb01205fc76b6c0809 100644 (file)
--- a/src/parsers/parser_h264.c
+++ b/src/parsers/parser_h264.c
@@ -232,7 +232,7 @@ h264_decode_seq_parameter_set(elementary_stream_t *st, bitstream_t *bs)
 
   if ((p = st->es_priv) == NULL) {
     p = st->es_priv = calloc(1, sizeof(h264_private_t));
-    p->start = mdispatch_clock;
+    p->start = mclk();
   }
 
   profile_idc = read_bits(bs, 8);
@@ -348,7 +348,7 @@ h264_decode_pic_parameter_set(elementary_stream_t *st, bitstream_t *bs)
 
   if((p = st->es_priv) == NULL) {
     p = st->es_priv = calloc(1, sizeof(h264_private_t));
-    p->start = mdispatch_clock;
+    p->start = mclk();
   }
   
   pps_id = read_golomb_ue(bs);
@@ -427,7 +427,7 @@ h264_decode_slice_header(elementary_stream_t *st, bitstream_t *bs, int *pkttype,
   d = 0;
   if (sps->time_scale)
     d = 180000 * (uint64_t)sps->units_in_tick / (uint64_t)sps->time_scale;
-  if (d == 0 && st->es_frame_duration < 2 && p->start + sec2mono(4) < mdispatch_clock) {
+  if (d == 0 && st->es_frame_duration < 2 && p->start + sec2mono(4) < mclk()) {
     tvhwarn("parser", "H264 stream has not timing information, using 30fps");
     d = 3000; /* 90000/30 = 3000 : 30fps */
   }

diff --git a/src/parsers/parser_teletext.c b/src/parsers/parser_teletext.c
index a2eea48f812a6409f2d4940be23b8343a9e2b882..a51dc1b921c3fa39a4ebc6c44272e520b791cb3d 100644 (file)
--- a/src/parsers/parser_teletext.c
+++ b/src/parsers/parser_teletext.c
@@ -619,7 +619,7 @@ tt_construct_unix_time(uint8_t *buf)
   int i;
   struct tm tm;
 
-  t = gdispatch_clock;
+  t = gclk();
   localtime_r(&t, &tm);
 
   tm.tm_hour = atoi((char *)buf);

diff --git a/src/plumbing/tsfix.c b/src/plumbing/tsfix.c
index 2db787c472c613b9ee2f067b34c505b4ea37cbfc..9045b38031d89c03f68abfdb4e04d876ff49ef8e 100644 (file)
--- a/src/plumbing/tsfix.c
+++ b/src/plumbing/tsfix.c
@@ -419,7 +419,7 @@ tsfix_input_packet(tsfix_t *tf, streaming_message_t *sm)
   streaming_msg_free(sm);
   int64_t diff, diff2, threshold;
   
-  if(tfs == NULL || mdispatch_clock < tf->tf_start_time) {
+  if(tfs == NULL || mclk() < tf->tf_start_time) {
     pkt_ref_dec(pkt);
     return;
   }
@@ -573,7 +573,7 @@ tsfix_create(streaming_target_t *output)
   TAILQ_INIT(&tf->tf_ptsq);
 
   tf->tf_output = output;
-  tf->tf_start_time = mdispatch_clock;
+  tf->tf_start_time = mclk();
 
   streaming_target_init(&tf->tf_input, tsfix_input, tf, 0);
   return &tf->tf_input;

diff --git a/src/satip/rtp.c b/src/satip/rtp.c
index 34c6847f598ac8e2d34f4f526fba3e20b4df4189..6fef3c12336abad1195683973afda9deef0db6e8 100644 (file)
--- a/src/satip/rtp.c
+++ b/src/satip/rtp.c
@@ -140,7 +140,7 @@ static void
 satip_rtp_header(satip_rtp_session_t *rtp, struct iovec *v, uint32_t off)
 {
   uint8_t *data = v->iov_base;
-  uint32_t tstamp = mono2sec(mdispatch_clock) + rtp->seq;
+  uint32_t tstamp = mono2sec(mclk()) + rtp->seq;
 
   rtp->seq++;
 

diff --git a/src/satip/rtsp.c b/src/satip/rtsp.c
index 87d2bad11f73be476b8cbc5e4b66bbe92f34da9f..c8a603ccacf091a4dbb4b2d8149cee4076c7d4c3 100644 (file)
--- a/src/satip/rtsp.c
+++ b/src/satip/rtsp.c
@@ -1188,7 +1188,7 @@ error:
 static void
 rtsp_describe_header(session_t *rs, htsbuf_queue_t *q)
 {
-  unsigned long mono = mdispatch_clock;
+  unsigned long mono = mclk();
   int dvbt, dvbc;
 
   htsbuf_append_str(q, "v=0\r\n");

diff --git a/src/service.c b/src/service.c
index cd06f3cb3a7ee84a5e2b8ac756537c8dea73dc02..351345a49fcf84d0973e2ddd295201785dc816b6 100644 (file)
--- a/src/service.c
+++ b/src/service.c
@@ -645,7 +645,7 @@ service_start(service_t *t, int instance, int weight, int flags,
   t->s_streaming_live   = 0;
   t->s_scrambled_seen   = 0;
   t->s_scrambled_pass   = !!(flags & SUBSCRIPTION_NODESCR);
-  t->s_start_time       = mdispatch_clock;
+  t->s_start_time       = mclk();
 
   pthread_mutex_lock(&t->s_stream_mutex);
   service_build_filter(t);

diff --git a/src/spawn.c b/src/spawn.c
index 4c293c61d5cf6e851b9274c7ba3650bef4022617..08c8e21779fd6b7b48617e1aa5b6a0d38a4767ec 100644 (file)
--- a/src/spawn.c
+++ b/src/spawn.c
@@ -301,7 +301,7 @@ spawn_reaper(void)
   /* forced kill for expired PIDs */
   pthread_mutex_lock(&spawn_mutex);
   LIST_FOREACH(s, &spawns, link)
-    if (s->killed && s->killed < mdispatch_clock) {
+    if (s->killed && s->killed < mclk()) {
       /* kill the whole process group */
       kill(-(s->pid), SIGKILL);
     }
@@ -326,7 +326,7 @@ spawn_kill(pid_t pid, int sig, int timeout)
         break;
     if (s) {
       if (!s->killed)
-        s->killed = mdispatch_clock_update() + sec2mono(MINMAX(timeout, 5, 3600));
+        s->killed = mclk() + sec2mono(MINMAX(timeout, 5, 3600));
       /* kill the whole process group */
       r = kill(-pid, sig);
       if (r < 0)

diff --git a/src/subscriptions.c b/src/subscriptions.c
index 778faa2e0f76cdde63a5f2a0e8ebb0bfa95dae20..a715ab938e2e006d45a764bc63a4214827c3789c 100644 (file)
--- a/src/subscriptions.c
+++ b/src/subscriptions.c
@@ -285,8 +285,8 @@ subscription_start_instance
                              s->ths_source, s->ths_prch,
                              &s->ths_instances, error, s->ths_weight,
                              s->ths_flags, s->ths_timeout,
-                             mdispatch_clock > s->ths_postpone_end ?
-                               0 : mono2sec(s->ths_postpone_end - mdispatch_clock));
+                             mclk() > s->ths_postpone_end ?
+                               0 : mono2sec(s->ths_postpone_end - mclk()));
   return s->ths_current_instance = si;
 }
 
@@ -313,8 +313,8 @@ subscription_reschedule(void)
 
     /* Postpone the tuner decision */
     /* Leave some time to wakeup tuners through DBus or so */
-    if (s->ths_postpone_end > mdispatch_clock) {
-      postpone2 = mono2sec(s->ths_postpone_end - mdispatch_clock);
+    if (s->ths_postpone_end > mclk()) {
+      postpone2 = mono2sec(s->ths_postpone_end - mclk());
       if (postpone > postpone2)
         postpone = postpone2;
       sm = streaming_msg_create_code(SMT_GRACE, postpone + 5);
@@ -354,10 +354,10 @@ subscription_reschedule(void)
     s->ths_current_instance = si;
 
     if(si == NULL) {
-      if (s->ths_last_error != error || s->ths_last_find + sec2mono(2) >= mdispatch_clock) {
+      if (s->ths_last_error != error || s->ths_last_find + sec2mono(2) >= mclk()) {
         tvhtrace("subscription", "%04X: instance not available, retrying", shortid(s));
         if (s->ths_last_error != error)
-          s->ths_last_find = mdispatch_clock;
+          s->ths_last_find = mclk();
         s->ths_last_error = error;
         continue;
       }
@@ -414,7 +414,7 @@ static int64_t
 subscription_set_postpone(void *aux, const char *path, int64_t postpone)
 {
   th_subscription_t *s;
-  time_t now = mdispatch_clock_update();
+  int64_t now = mclk();
   int64_t postpone2;
 
   if (strcmp(path, "/set"))
@@ -434,7 +434,7 @@ subscription_set_postpone(void *aux, const char *path, int64_t postpone)
     mtimer_arm_rel(&subscription_reschedule_timer,
                   subscription_reschedule_cb, NULL, 0);
   }
-  pthread_mutex_unlock(&global_lock);
+ pthread_mutex_unlock(&global_lock);
   return postpone;
 }
 
@@ -706,7 +706,7 @@ subscription_create
   s->ths_flags             = flags;
   s->ths_timeout           = pro ? pro->pro_timeout : 0;
   s->ths_postpone          = subscription_postpone;
-  s->ths_postpone_end      = mdispatch_clock + sec2mono(s->ths_postpone);
+  s->ths_postpone_end      = mclk() + sec2mono(s->ths_postpone);
 
   if (s->ths_prch)
     s->ths_weight = profile_chain_weight(s->ths_prch, weight);

diff --git a/src/tcp.c b/src/tcp.c
index 32a6eebceb1ecf4f6beacdfb717dc2669fa05f8c..a8e6305977ee4586b84a304dce22dbc85b4e70fb 100644 (file)
--- a/src/tcp.c
+++ b/src/tcp.c
@@ -507,7 +507,7 @@ tcp_connection_launch
 {
   tcp_server_launch_t *tsl, *res;
   uint32_t used = 0, used2;
-  int64_t started = mdispatch_clock;
+  int64_t started = mclk();
   int c1, c2;
 
   lock_assert(&global_lock);
@@ -539,7 +539,7 @@ try_again:
     c2 = aa->aa_conn_limit_streaming ? used >= aa->aa_conn_limit_streaming : -1;
 
     if (c1 && c2) {
-      if (started + sec2mono(3) < mdispatch_clock) {
+      if (started + sec2mono(3) < mclk()) {
         tvherror("tcp", "multiple connections are not allowed for user '%s' from '%s' "
                         "(limit %u, streaming limit %u, active streaming %u, DVR %u)",
                  aa->aa_username ?: "", aa->aa_representative ?: "",
@@ -1112,9 +1112,9 @@ tcp_server_done(void)
   tvh_pipe_close(&tcp_server_pipe);
   tvhpoll_destroy(tcp_server_poll);
   
-  t = mdispatch_clock;
+  t = mclk();
   while (LIST_FIRST(&tcp_server_active) != NULL) {
-    if (t + sec2mono(5) < mdispatch_clock)
+    if (t + sec2mono(5) < mclk())
       tvhtrace("tcp", "tcp server %p active too long", LIST_FIRST(&tcp_server_active));
     tvh_safe_usleep(20000);
   }

diff --git a/src/tvhlog.c b/src/tvhlog.c
index 564afad9b011ca6baeef4038a4b7e920bd95636e..93284fc83c0b8ea878e6af42408b203ba842fa24 100644 (file)
--- a/src/tvhlog.c
+++ b/src/tvhlog.c
@@ -30,9 +30,6 @@
 #include "libav.h"
 #include "webui/webui.h"
 
-int64_t                  mdispatch_clock;
-time_t                   gdispatch_clock;
-
 int                      tvhlog_run;
 int                      tvhlog_level;
 int                      tvhlog_options;

diff --git a/src/tvhlog.h b/src/tvhlog.h
index ef5f58729d0ea0b6a6f59d1c37c075aa1f8f94e2..b76b0e06cc473f465fb2c51a460fc4e94bcecb3e 100644 (file)
--- a/src/tvhlog.h
+++ b/src/tvhlog.h
@@ -68,9 +68,8 @@ void _tvhlog_hexdump   ( const char *file, int line,
 static inline void tvhlog_limit_reset ( tvhlog_limit_t *limit )
   { limit->last = 0; limit->count = 0; }
 static inline int tvhlog_limit ( tvhlog_limit_t *limit, uint32_t delay )
-  { int64_t t = mdispatch_clock; limit->count++;
-    if (limit->last + (int64_t)delay * MONOCLOCK_RESOLUTION < t)
-      { limit->last = t; return 1; }
+  { int64_t t = mclk(); limit->count++;
+    if (limit->last + sec2mono(delay) < t) { limit->last = t; return 1; }
     return 0; }
 
 

diff --git a/src/webui/comet.c b/src/webui/comet.c
index f0500e49ea7ef4ca87787747b750c7a75665554e..c4425e4906a2caa3f913db61bd20d2fa36aa2ad7 100644 (file)
--- a/src/webui/comet.c
+++ b/src/webui/comet.c
@@ -95,7 +95,7 @@ comet_flush(void)
   for(cmb = LIST_FIRST(&mailboxes); cmb != NULL; cmb = next) {
     next = LIST_NEXT(cmb, cmb_link);
 
-    if(cmb->cmb_last_used && cmb->cmb_last_used + sec2mono(60) < mdispatch_clock)
+    if(cmb->cmb_last_used && cmb->cmb_last_used + sec2mono(60) < mclk())
       cmb_destroy(cmb);
   }
   pthread_mutex_unlock(&comet_mutex);
@@ -131,7 +131,7 @@ comet_mailbox_create(const char *lang)
 
   cmb->cmb_boxid = strdup(id);
   cmb->cmb_lang = lang ? strdup(lang) : NULL;
-  cmb->cmb_last_used = mdispatch_clock;
+  cmb->cmb_last_used = mclk();
   mailbox_tally++;
 
   LIST_INSERT_HEAD(&mailboxes, cmb, cmb_link);
@@ -264,7 +264,7 @@ comet_mailbox_poll(http_connection_t *hc, const char *remain, void *opaque)
   cmb->cmb_last_used = 0; /* Make sure we're not flushed out */
 
   if(!im && cmb->cmb_messages == NULL) {
-    mono = mdispatch_clock + sec2mono(10);
+    mono = mclk() + sec2mono(10);
     do {
       e = tvh_cond_timedwait(&comet_cond, &comet_mutex, mono);
       if (e == ETIMEDOUT)
@@ -281,7 +281,7 @@ comet_mailbox_poll(http_connection_t *hc, const char *remain, void *opaque)
   htsmsg_add_msg(m, "messages", cmb->cmb_messages ?: htsmsg_create_list());
   cmb->cmb_messages = NULL;
   
-  cmb->cmb_last_used = mdispatch_clock;
+  cmb->cmb_last_used = mclk();
 
   pthread_mutex_unlock(&comet_mutex);
 

diff --git a/src/webui/webui.c b/src/webui/webui.c
index 6e7e35e36ee792053cc78c7dae35020a1d8d6c30..8bf7f551a5a8b405133704bb1ef6b61697c1a7b9 100644 (file)
--- a/src/webui/webui.c
+++ b/src/webui/webui.c
@@ -329,7 +329,7 @@ http_stream_run(http_connection_t *hc, profile_chain_t *prch,
   if (config.dscp >= 0)
     socket_set_dscp(hc->hc_fd, config.dscp, NULL, 0);
 
-  lastpkt = mdispatch_clock;
+  lastpkt = mclk();
   ptimeout = prch->prch_pro ? prch->prch_pro->pro_timeout : 5;
 
   if (hc->hc_no_output) {
@@ -342,7 +342,7 @@ http_stream_run(http_connection_t *hc, profile_chain_t *prch,
     pthread_mutex_lock(&sq->sq_mutex);
     sm = TAILQ_FIRST(&sq->sq_queue);
     if(sm == NULL) {
-      mono = mdispatch_clock + sec2mono(1);
+      mono = mclk() + sec2mono(1);
       do {
         r = tvh_cond_timedwait(&sq->sq_cond, &sq->sq_mutex, mono);
         if (r == ETIMEDOUT) {
@@ -350,8 +350,8 @@ http_stream_run(http_connection_t *hc, profile_chain_t *prch,
           if (tcp_socket_dead(hc->hc_fd)) {
             tvhlog(LOG_DEBUG, "webui",  "Stop streaming %s, client hung up", hc->hc_url_orig);
             run = 0;
-          } else if((!started && mdispatch_clock - lastpkt > sec2mono(grace)) ||
-                     (started && ptimeout > 0 && mdispatch_clock - lastpkt > sec2mono(ptimeout))) {
+          } else if((!started && mclk() - lastpkt > sec2mono(grace)) ||
+                     (started && ptimeout > 0 && mclk() - lastpkt > sec2mono(ptimeout))) {
             tvhlog(LOG_WARNING, "webui",  "Stop streaming %s, timeout waiting for packets", hc->hc_url_orig);
             run = 0;
           }
@@ -377,7 +377,7 @@ http_stream_run(http_connection_t *hc, profile_chain_t *prch,
           pb = sm->sm_data;
         subscription_add_bytes_out(s, len = pktbuf_len(pb));
         if (len > 0)
-          lastpkt = mdispatch_clock;
+          lastpkt = mclk();
         muxer_write_pkt(mux, sm->sm_type, sm->sm_data);
         sm->sm_data = NULL;
       }
@@ -396,8 +396,8 @@ http_stream_run(http_connection_t *hc, profile_chain_t *prch,
 
         if (hc->hc_no_output) {
           streaming_msg_free(sm);
-          mono = mdispatch_clock + sec2mono(2);
-          while (mdispatch_clock < mono) {
+          mono = mclk() + sec2mono(2);
+          while (mclk() < mono) {
             if (tcp_socket_dead(hc->hc_fd))
               break;
             tvh_safe_usleep(50000);
@@ -429,8 +429,8 @@ http_stream_run(http_connection_t *hc, profile_chain_t *prch,
         tvhlog(LOG_DEBUG, "webui",  "Stop streaming %s, client hung up",
                hc->hc_url_orig);
         run = 0;
-      } else if((!started && mdispatch_clock - lastpkt > sec2mono(grace)) ||
-                 (started && ptimeout > 0 && mdispatch_clock - lastpkt > sec2mono(ptimeout))) {
+      } else if((!started && mclk() - lastpkt > sec2mono(grace)) ||
+                 (started && ptimeout > 0 && mclk() - lastpkt > sec2mono(ptimeout))) {
         tvhlog(LOG_WARNING, "webui",  "Stop streaming %s, timeout waiting for packets", hc->hc_url_orig);
         run = 0;
       }

diff --git a/src/wrappers.c b/src/wrappers.c
index 5dfb8836c98fdaf8c88958f526bc59ff63ae97c1..e1caa3d5feead1421fc31fb549189890689cbf57 100644 (file)
--- a/src/wrappers.c
+++ b/src/wrappers.c
@@ -78,14 +78,14 @@ tvh_pipe_close(th_pipe_t *p)
 int
 tvh_write(int fd, const void *buf, size_t len)
 {
-  int64_t limit = mdispatch_clock + sec2mono(25);
+  int64_t limit = mclk() + sec2mono(25);
   ssize_t c;
 
   while (len) {
     c = write(fd, buf, len);
     if (c < 0) {
       if (ERRNO_AGAIN(errno)) {
-        if (mdispatch_clock > limit)
+        if (mclk() > limit)
           break;
         tvh_safe_usleep(100);
         continue;