Replaces clock_gettime() with ast_tsnow()
[asterisk/asterisk.git] / include / asterisk / time.h
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2005, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  * \brief Time-related functions and macros
21  */
22
23 #ifndef _ASTERISK_TIME_H
24 #define _ASTERISK_TIME_H
25
26 #include "asterisk/autoconfig.h"
27
28 #ifdef HAVE_SYS_TIME_H
29 #include <sys/time.h>
30 #endif
31
32 #ifdef HAVE_UNISTD_H
33 #include <unistd.h>
34 #endif
35
36 #include "asterisk/inline_api.h"
37
38 /* We have to let the compiler learn what types to use for the elements of a
39    struct timeval since on linux, it's time_t and suseconds_t, but on *BSD,
40    they are just a long. */
41 extern struct timeval tv;
42 typedef typeof(tv.tv_sec) ast_time_t;
43 typedef typeof(tv.tv_usec) ast_suseconds_t;
44
45 /*!
46  * \brief Computes the difference (in seconds) between two \c struct \c timeval instances.
47  * \param end the end of the time period
48  * \param start the beginning of the time period
49  * \return the difference in seconds
50  */
51 AST_INLINE_API(
52 int64_t ast_tvdiff_sec(struct timeval end, struct timeval start),
53 {
54         int64_t result = end.tv_sec - start.tv_sec;
55         if (result > 0 && end.tv_usec < start.tv_usec)
56                 result--;
57         else if (result < 0 && end.tv_usec > start.tv_usec)
58                 result++;
59
60         return result;
61 }
62 )
63
64 /*!
65  * \brief Computes the difference (in microseconds) between two \c struct \c timeval instances.
66  * \param end the end of the time period
67  * \param start the beginning of the time period
68  * \return the difference in microseconds
69  */
70 AST_INLINE_API(
71 int64_t ast_tvdiff_us(struct timeval end, struct timeval start),
72 {
73         return (end.tv_sec - start.tv_sec) * (int64_t) 1000000 +
74                 end.tv_usec - start.tv_usec;
75 }
76 )
77
78 /*!
79  * \brief Computes the difference (in milliseconds) between two \c struct \c timeval instances.
80  * \param end end of the time period
81  * \param start beginning of the time period
82  * \return the difference in milliseconds
83  */
84 AST_INLINE_API(
85 int64_t ast_tvdiff_ms(struct timeval end, struct timeval start),
86 {
87         /* the offset by 1,000,000 below is intentional...
88            it avoids differences in the way that division
89            is handled for positive and negative numbers, by ensuring
90            that the divisor is always positive
91         */
92         int64_t sec_dif = (int64_t)(end.tv_sec - start.tv_sec) * 1000;
93         int64_t usec_dif = (1000000 + end.tv_usec - start.tv_usec) / 1000 - 1000;
94         return  sec_dif + usec_dif;
95 }
96 )
97
98 /*!
99  * \brief Returns true if the argument is 0,0
100  */
101 AST_INLINE_API(
102 int ast_tvzero(const struct timeval t),
103 {
104         return (t.tv_sec == 0 && t.tv_usec == 0);
105 }
106 )
107
108 /*!
109  * \brief Compres two \c struct \c timeval instances returning
110  * -1, 0, 1 if the first arg is smaller, equal or greater to the second.
111  */
112 AST_INLINE_API(
113 int ast_tvcmp(struct timeval _a, struct timeval _b),
114 {
115         if (_a.tv_sec < _b.tv_sec)
116                 return -1;
117         if (_a.tv_sec > _b.tv_sec)
118                 return 1;
119         /* now seconds are equal */
120         if (_a.tv_usec < _b.tv_usec)
121                 return -1;
122         if (_a.tv_usec > _b.tv_usec)
123                 return 1;
124         return 0;
125 }
126 )
127
128 /*!
129  * \brief Returns true if the two \c struct \c timeval arguments are equal.
130  */
131 AST_INLINE_API(
132 int ast_tveq(struct timeval _a, struct timeval _b),
133 {
134         return (_a.tv_sec == _b.tv_sec && _a.tv_usec == _b.tv_usec);
135 }
136 )
137
138 /*!
139  * \brief Returns current timeval. Meant to replace calls to gettimeofday().
140  */
141 AST_INLINE_API(
142 struct timeval ast_tvnow(void),
143 {
144         struct timeval t;
145         gettimeofday(&t, NULL);
146         return t;
147 }
148 )
149
150 /*!
151  * \brief Returns current timespec. Meant to avoid calling ast_tvnow() just to
152  * create a timespec from the timeval it returns.
153  */
154 #if defined _POSIX_TIMERS && _POSIX_TIMERS > 0
155 AST_INLINE_API(
156 struct timespec ast_tsnow(void),
157 {
158         struct timespec ts;
159         clock_gettime(CLOCK_REALTIME, &ts);
160         return ts;
161 }
162 )
163 #else
164 AST_INLINE_API(
165 struct timespec ast_tsnow(void),
166 {
167         struct timeval tv = ast_tvnow();
168         struct timespec ts;
169         /* Can't use designated initializer, because it does odd things with
170          * the AST_INLINE_API macro. Go figure. */
171         ts.tv_sec = tv.tv_sec;
172         ts.tv_nsec = tv.tv_usec * 1000;
173         return ts;
174 }
175 )
176 #endif
177
178 /*!
179  * \brief Returns the sum of two timevals a + b
180  */
181 struct timeval ast_tvadd(struct timeval a, struct timeval b);
182
183 /*!
184  * \brief Returns the difference of two timevals a - b
185  */
186 struct timeval ast_tvsub(struct timeval a, struct timeval b);
187
188 /*!
189  * \since 12
190  * \brief Formats a duration into HH:MM:SS
191  *
192  * \param duration The time (in seconds) to format
193  * \param buf A buffer to hold the formatted string'
194  * \param length The size of the buffer
195  */
196 void ast_format_duration_hh_mm_ss(int duration, char *buf, size_t length);
197
198
199 /*!
200  * \brief Calculate remaining milliseconds given a starting timestamp
201  * and upper bound
202  *
203  * If the upper bound is negative, then this indicates that there is no
204  * upper bound on the amount of time to wait. This will result in a
205  * negative return.
206  *
207  * \param start When timing started being calculated
208  * \param max_ms The maximum number of milliseconds to wait from start. May be negative.
209  * \return The number of milliseconds left to wait for. May be negative.
210  */
211 int ast_remaining_ms(struct timeval start, int max_ms);
212
213 /*!
214  * \brief Returns a timeval from sec, usec
215  */
216 AST_INLINE_API(
217 struct timeval ast_tv(ast_time_t sec, ast_suseconds_t usec),
218 {
219         struct timeval t;
220         t.tv_sec = sec;
221         t.tv_usec = usec;
222         return t;
223 }
224 )
225
226 /*!
227  * \brief Returns a timeval corresponding to the duration of n samples at rate r.
228  * Useful to convert samples to timevals, or even milliseconds to timevals
229  * in the form ast_samp2tv(milliseconds, 1000)
230  */
231 AST_INLINE_API(
232 struct timeval ast_samp2tv(unsigned int _nsamp, unsigned int _rate),
233 {
234         return ast_tv(_nsamp / _rate, (_nsamp % _rate) * (1000000 / (float) _rate));
235 }
236 )
237
238 #endif /* _ASTERISK_TIME_H */