1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
//
// Copyright 2011-2013 Ettus Research LLC
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
#include <osmosdr/time_spec.h>
#include <ciso646>
using namespace osmosdr;
/***********************************************************************
* Time spec system time
**********************************************************************/
#ifdef HAVE_CLOCK_GETTIME
#include <time.h>
time_spec_t time_spec_t::get_system_time(void){
timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts);
return time_spec_t(ts.tv_sec, ts.tv_nsec, 1e9);
}
#endif /* HAVE_CLOCK_GETTIME */
#ifdef HAVE_MACH_ABSOLUTE_TIME
#include <mach/mach_time.h>
time_spec_t time_spec_t::get_system_time(void){
mach_timebase_info_data_t info; mach_timebase_info(&info);
intmax_t nanosecs = mach_absolute_time()*info.numer/info.denom;
return time_spec_t::from_ticks(nanosecs, 1e9);
}
#endif /* HAVE_MACH_ABSOLUTE_TIME */
#ifdef HAVE_QUERY_PERFORMANCE_COUNTER
#include <Windows.h>
time_spec_t time_spec_t::get_system_time(void){
LARGE_INTEGER counts, freq;
QueryPerformanceCounter(&counts);
QueryPerformanceFrequency(&freq);
return time_spec_t::from_ticks(counts.QuadPart, double(freq.QuadPart));
}
#endif /* HAVE_QUERY_PERFORMANCE_COUNTER */
#ifdef HAVE_MICROSEC_CLOCK
#include <boost/date_time/posix_time/posix_time.hpp>
namespace pt = boost::posix_time;
time_spec_t time_spec_t::get_system_time(void){
pt::ptime time_now = pt::microsec_clock::universal_time();
pt::time_duration time_dur = time_now - pt::from_time_t(0);
return time_spec_t(
time_t(time_dur.total_seconds()),
long(time_dur.fractional_seconds()),
double(pt::time_duration::ticks_per_second())
);
}
#endif /* HAVE_MICROSEC_CLOCK */
/***********************************************************************
* Time spec constructors
**********************************************************************/
#define time_spec_init(full, frac) { \
const time_t _full = time_t(full); \
const double _frac = double(frac); \
const int _frac_int = int(_frac); \
_full_secs = _full + _frac_int; \
_frac_secs = _frac - _frac_int; \
if (_frac_secs < 0) {\
_full_secs -= 1; \
_frac_secs += 1; \
} \
}
inline long long fast_llround(const double x){
return (long long)(x + 0.5); // assumption of non-negativity
}
time_spec_t::time_spec_t(double secs){
time_spec_init(0, secs);
}
time_spec_t::time_spec_t(time_t full_secs, double frac_secs){
time_spec_init(full_secs, frac_secs);
}
time_spec_t::time_spec_t(time_t full_secs, long tick_count, double tick_rate){
const double frac_secs = tick_count/tick_rate;
time_spec_init(full_secs, frac_secs);
}
time_spec_t time_spec_t::from_ticks(long long ticks, double tick_rate){
const long long rate_i = (long long)(tick_rate);
const double rate_f = tick_rate - rate_i;
const time_t secs_full = time_t(ticks/rate_i);
const long long ticks_error = ticks - (secs_full*rate_i);
const double ticks_frac = ticks_error - secs_full*rate_f;
return time_spec_t(secs_full, ticks_frac/tick_rate);
}
/***********************************************************************
* Time spec accessors
**********************************************************************/
long time_spec_t::get_tick_count(double tick_rate) const{
return long(fast_llround(this->get_frac_secs()*tick_rate));
}
long long time_spec_t::to_ticks(double tick_rate) const{
const long long rate_i = (long long)(tick_rate);
const double rate_f = tick_rate - rate_i;
const long long ticks_full = this->get_full_secs()*rate_i;
const double ticks_error = this->get_full_secs()*rate_f;
const double ticks_frac = this->get_frac_secs()*tick_rate;
return ticks_full + fast_llround(ticks_error + ticks_frac);
}
double time_spec_t::get_real_secs(void) const{
return this->get_full_secs() + this->get_frac_secs();
}
/***********************************************************************
* Time spec math overloads
**********************************************************************/
time_spec_t &time_spec_t::operator+=(const time_spec_t &rhs){
time_spec_init(
this->get_full_secs() + rhs.get_full_secs(),
this->get_frac_secs() + rhs.get_frac_secs()
);
return *this;
}
time_spec_t &time_spec_t::operator-=(const time_spec_t &rhs){
time_spec_init(
this->get_full_secs() - rhs.get_full_secs(),
this->get_frac_secs() - rhs.get_frac_secs()
);
return *this;
}
bool osmosdr::operator==(const time_spec_t &lhs, const time_spec_t &rhs){
return
lhs.get_full_secs() == rhs.get_full_secs() and
lhs.get_frac_secs() == rhs.get_frac_secs()
;
}
bool osmosdr::operator<(const time_spec_t &lhs, const time_spec_t &rhs){
return (
(lhs.get_full_secs() < rhs.get_full_secs()) or (
(lhs.get_full_secs() == rhs.get_full_secs()) and
(lhs.get_frac_secs() < rhs.get_frac_secs())
));
}
|
