code.delx.au - pulseaudio/blob - src/pulsecore/rtclock.c

   1 /* $Id$ */
   2
   3 /***
   4   This file is part of PulseAudio.
   5
   6   Copyright 2004-2006 Lennart Poettering
   7   Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
   8
   9   PulseAudio is free software; you can redistribute it and/or modify
  10   it under the terms of the GNU Lesser General Public License as
  11   published by the Free Software Foundation; either version 2.1 of the
  12   License, or (at your option) any later version.
  13
  14   PulseAudio is distributed in the hope that it will be useful, but
  15   WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17   Lesser General Public License for more details.
  18
  19   You should have received a copy of the GNU Lesser General Public
  20   License along with PulseAudio; if not, write to the Free Software
  21   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  22   USA.
  23 ***/
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include <config.h>
  27 #endif
  28
  29 #include <stddef.h>
  30 #include <sys/time.h>
  31
  32 #include <pulse/timeval.h>
  33 #include <pulsecore/macro.h>
  34
  35 #include "rtclock.h"
  36
  37 struct timespec *pa_timespec_store(struct timespec *a, pa_usec_t u) {
  38     pa_assert(a);
  39
  40     a->tv_sec = u / PA_USEC_PER_SEC;
  41
  42     u -= (pa_usec_t) a->tv_sec * PA_USEC_PER_SEC;
  43
  44     a->tv_nsec = u * 1000;
  45
  46     return a;
  47 }
  48
  49 struct timespec *pa_timespec_reset(struct timespec *a) {
  50     pa_assert(a);
  51
  52     a->tv_sec = a->tv_nsec = 0;
  53     return a;
  54 }
  55
  56 pa_usec_t pa_timespec_load(struct timespec *ts) {
  57     pa_assert(ts);
  58
  59     return (pa_usec_t) ts->tv_sec * PA_USEC_PER_SEC + (pa_usec_t) (ts->tv_nsec / 1000);
  60 }
  61
  62 pa_usec_t pa_timespec_diff(const struct timespec *a, const struct timespec *b) {
  63     pa_usec_t r;
  64
  65     pa_assert(a);
  66     pa_assert(b);
  67
  68     /* Check which whan is the earlier time and swap the two arguments if required. */
  69     if (pa_timespec_cmp(a, b) < 0) {
  70         const struct timespec *c;
  71         c = a;
  72         a = b;
  73         b = c;
  74     }
  75
  76     /* Calculate the second difference*/
  77     r = ((pa_usec_t) a->tv_sec - b->tv_sec) * PA_USEC_PER_SEC;
  78
  79     /* Calculate the microsecond difference */
  80     if (a->tv_nsec > b->tv_nsec)
  81         r += (pa_usec_t) ((a->tv_nsec - b->tv_nsec) / 1000);
  82     else if (a->tv_nsec < b->tv_nsec)
  83         r -= (pa_usec_t) ((b->tv_nsec - a->tv_nsec) / 1000);
  84
  85     return r;
  86 }
  87
  88 int pa_timespec_cmp(const struct timespec *a, const struct timespec *b) {
  89     pa_assert(a);
  90     pa_assert(b);
  91
  92     if (a->tv_sec < b->tv_sec)
  93         return -1;
  94
  95     if (a->tv_sec > b->tv_sec)
  96         return 1;
  97
  98     if (a->tv_nsec < b->tv_nsec)
  99         return -1;
 100
 101     if (a->tv_nsec > b->tv_nsec)
 102         return 1;
 103
 104     return 0;
 105 }
 106
 107 struct timespec* pa_timespec_add(struct timespec *ts, pa_usec_t v) {
 108     unsigned long secs;
 109     pa_assert(ts);
 110
 111     secs = (unsigned long) (v/PA_USEC_PER_SEC);
 112     ts->tv_sec += secs;
 113     v -= ((pa_usec_t) secs) * PA_USEC_PER_SEC;
 114
 115     ts->tv_nsec += (long) (v*1000);
 116
 117     /* Normalize */
 118     while (ts->tv_nsec >= PA_NSEC_PER_SEC) {
 119         ts->tv_sec++;
 120         ts->tv_nsec -= PA_NSEC_PER_SEC;
 121     }
 122
 123     return ts;
 124 }
 125
 126 pa_usec_t pa_rtclock_age(const struct timespec *ts) {
 127     struct timespec now;
 128     pa_assert(ts);
 129
 130     return pa_timespec_diff(pa_rtclock_get(&now), ts);
 131 }
 132
 133 struct timespec *pa_rtclock_get(struct timespec *ts) {
 134     static int no_monotonic = 0;
 135
 136     /* No locking or atomic ops for no_monotonic here */
 137
 138     pa_assert(ts);
 139
 140     if (!no_monotonic) {
 141         if (clock_gettime(CLOCK_MONOTONIC, ts) >= 0)
 142             return ts;
 143
 144         no_monotonic = 1;
 145     }
 146
 147     pa_assert_se(clock_gettime(CLOCK_REALTIME, ts) == 0);
 148     return ts;
 149 }
 150
 151 int pa_rtclock_hrtimer(void) {
 152     struct timespec ts;
 153
 154     if (clock_getres(CLOCK_MONOTONIC, &ts) >= 0)
 155         return ts.tv_sec == 0 && ts.tv_nsec <= PA_HRTIMER_THRESHOLD_USEC*1000;
 156
 157     pa_assert_se(clock_getres(CLOCK_REALTIME, &ts) == 0);
 158     return ts.tv_sec == 0 && ts.tv_nsec <= PA_HRTIMER_THRESHOLD_USEC*1000;
 159 }
 160