src/pulse/timeval.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2004-2006 Lennart Poettering
   5   Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
   6
   7   PulseAudio is free software; you can redistribute it and/or modify
   8   it under the terms of the GNU Lesser General Public License as
   9   published by the Free Software Foundation; either version 2.1 of the
  10   License, or (at your option) any later version.
  11
  12   PulseAudio is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public
  18   License along with PulseAudio; if not, write to the Free Software
  19   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20   USA.
  21 ***/
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <stddef.h>
  28 #include <sys/time.h>
  29
  30 #ifdef HAVE_WINDOWS_H
  31 #include <windows.h>
  32 #endif
  33
  34 #include <pulsecore/winsock.h>
  35 #include <pulsecore/macro.h>
  36
  37 #include "timeval.h"
  38
  39 struct timeval *pa_gettimeofday(struct timeval *tv) {
  40 #ifdef HAVE_GETTIMEOFDAY
  41     pa_assert(tv);
  42
  43     pa_assert_se(gettimeofday(tv, NULL) == 0);
  44     return tv;
  45 #elif defined(OS_IS_WIN32)
  46     /*
  47      * Copied from implementation by Steven Edwards (LGPL).
  48      * Found on wine mailing list.
  49      */
  50
  51 #if defined(_MSC_VER) || defined(__BORLANDC__)
  52 #define EPOCHFILETIME (116444736000000000i64)
  53 #else
  54 #define EPOCHFILETIME (116444736000000000LL)
  55 #endif
  56
  57     FILETIME        ft;
  58     LARGE_INTEGER   li;
  59     __int64         t;
  60
  61     pa_assert(tv);
  62
  63     GetSystemTimeAsFileTime(&ft);
  64     li.LowPart  = ft.dwLowDateTime;
  65     li.HighPart = ft.dwHighDateTime;
  66     t  = li.QuadPart;       /* In 100-nanosecond intervals */
  67     t -= EPOCHFILETIME;     /* Offset to the Epoch time */
  68     t /= 10;                /* In microseconds */
  69     tv->tv_sec  = (time_t) (t / PA_USEC_PER_SEC);
  70     tv->tv_usec = (suseconds_t) (t % PA_USEC_PER_SEC);
  71
  72     return tv;
  73 #else
  74 #error "Platform lacks gettimeofday() or equivalent function."
  75 #endif
  76 }
  77
  78 pa_usec_t pa_timeval_diff(const struct timeval *a, const struct timeval *b) {
  79     pa_usec_t r;
  80
  81     pa_assert(a);
  82     pa_assert(b);
  83
  84     /* Check which whan is the earlier time and swap the two arguments if required. */
  85     if (pa_timeval_cmp(a, b) < 0) {
  86         const struct timeval *c;
  87         c = a;
  88         a = b;
  89         b = c;
  90     }
  91
  92     /* Calculate the second difference*/
  93     r = ((pa_usec_t) a->tv_sec - b->tv_sec) * PA_USEC_PER_SEC;
  94
  95     /* Calculate the microsecond difference */
  96     if (a->tv_usec > b->tv_usec)
  97         r += ((pa_usec_t) a->tv_usec - b->tv_usec);
  98     else if (a->tv_usec < b->tv_usec)
  99         r -= ((pa_usec_t) b->tv_usec - a->tv_usec);
 100
 101     return r;
 102 }
 103
 104 int pa_timeval_cmp(const struct timeval *a, const struct timeval *b) {
 105     pa_assert(a);
 106     pa_assert(b);
 107
 108     if (a->tv_sec < b->tv_sec)
 109         return -1;
 110
 111     if (a->tv_sec > b->tv_sec)
 112         return 1;
 113
 114     if (a->tv_usec < b->tv_usec)
 115         return -1;
 116
 117     if (a->tv_usec > b->tv_usec)
 118         return 1;
 119
 120     return 0;
 121 }
 122
 123 pa_usec_t pa_timeval_age(const struct timeval *tv) {
 124     struct timeval now;
 125     pa_assert(tv);
 126
 127     return pa_timeval_diff(pa_gettimeofday(&now), tv);
 128 }
 129
 130 struct timeval* pa_timeval_add(struct timeval *tv, pa_usec_t v) {
 131     unsigned long secs;
 132     pa_assert(tv);
 133
 134     secs = (unsigned long) (v/PA_USEC_PER_SEC);
 135     tv->tv_sec += secs;
 136     v -= ((pa_usec_t) secs) * PA_USEC_PER_SEC;
 137
 138     tv->tv_usec += (suseconds_t) v;
 139
 140     /* Normalize */
 141     while ((unsigned) tv->tv_usec >= PA_USEC_PER_SEC) {
 142         tv->tv_sec++;
 143         tv->tv_usec -= PA_USEC_PER_SEC;
 144     }
 145
 146     return tv;
 147 }
 148
 149 struct timeval* pa_timeval_sub(struct timeval *tv, pa_usec_t v) {
 150     unsigned long secs;
 151     pa_assert(tv);
 152
 153     secs = (unsigned long) (v/PA_USEC_PER_SEC);
 154     tv->tv_sec -= secs;
 155     v -= ((pa_usec_t) secs) * PA_USEC_PER_SEC;
 156
 157     if (tv->tv_usec >= (suseconds_t) v)
 158         tv->tv_usec -= (suseconds_t) v;
 159     else {
 160         tv->tv_sec --;
 161         tv->tv_usec = tv->tv_usec + PA_USEC_PER_SEC - v;
 162     }
 163
 164     return tv;
 165 }
 166
 167 struct timeval* pa_timeval_store(struct timeval *tv, pa_usec_t v) {
 168     pa_assert(tv);
 169
 170     tv->tv_sec = v / PA_USEC_PER_SEC;
 171     tv->tv_usec = v % PA_USEC_PER_SEC;
 172
 173     return tv;
 174 }
 175
 176 pa_usec_t pa_timeval_load(const struct timeval *tv) {
 177     pa_assert(tv);
 178
 179     return
 180         (pa_usec_t) tv->tv_sec * PA_USEC_PER_SEC +
 181         (pa_usec_t) tv->tv_usec;
 182 }