replace dispatch_clock variables with mclk() and gclk()

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)

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)

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);

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,21 +745,21 @@ 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)) {
             flush_data = 1;
             goto next;
           }
         }
-        key_update(dr, ki, mdispatch_clock);
+        key_update(dr, ki, mclk());
       }
     }
     dr->dr_skip = 1;
@@ -778,18 +778,18 @@ descrambler_descramble ( service_t *t,
             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 @@ descrambler_descramble ( service_t *t,
       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 */
             }

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 @@ dvr_entry_rerecord(dvr_entry_t *de)
         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;

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);

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);
   }