← Back to branch summary

~ubuntu-branches/ubuntu/utopic/ardour3/utopic

« back to all changes in this revision

Viewing changes to libs/vamp-sdk/src/vamp-sdk/RealTime.cpp

  • Committer: Package Import Robot
  • Author(s): Felipe Sateler
  • Date: 2013-09-21 19:05:02 UTC
  • Revision ID: package-import@ubuntu.com-20130921190502-8gsftrku6jnzhd7v
Tags: upstream-3.4~dfsg
Import upstream version 3.4~dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
libs/vamp-sdk/src/vamp-sdk/RealTime.cpp
 
1
/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
 
2
 
 
3
/*
 
4
    Vamp
 
5
 
 
6
    An API for audio analysis and feature extraction plugins.
 
7
 
 
8
    Centre for Digital Music, Queen Mary, University of London.
 
9
    Copyright 2006 Chris Cannam.
 
10
  
 
11
    Permission is hereby granted, free of charge, to any person
 
12
    obtaining a copy of this software and associated documentation
 
13
    files (the "Software"), to deal in the Software without
 
14
    restriction, including without limitation the rights to use, copy,
 
15
    modify, merge, publish, distribute, sublicense, and/or sell copies
 
16
    of the Software, and to permit persons to whom the Software is
 
17
    furnished to do so, subject to the following conditions:
 
18
 
 
19
    The above copyright notice and this permission notice shall be
 
20
    included in all copies or substantial portions of the Software.
 
21
 
 
22
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 
23
    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 
24
    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 
25
    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
 
26
    ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
 
27
    CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 
28
    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
29
 
 
30
    Except as contained in this notice, the names of the Centre for
 
31
    Digital Music; Queen Mary, University of London; and Chris Cannam
 
32
    shall not be used in advertising or otherwise to promote the sale,
 
33
    use or other dealings in this Software without prior written
 
34
    authorization.
 
35
*/
 
36
 
 
37
/*
 
38
   This is a modified version of a source file from the 
 
39
   Rosegarden MIDI and audio sequencer and notation editor.
 
40
   This file copyright 2000-2006 Chris Cannam.
 
41
   Relicensed by the author as detailed above.
 
42
*/
 
43
 
 
44
#include <iostream>
 
45
 
 
46
#if (__GNUC__ < 3)
 
47
#include <strstream>
 
48
#define stringstream strstream
 
49
#else
 
50
#include <sstream>
 
51
#endif
 
52
 
 
53
using std::cerr;
 
54
using std::endl;
 
55
 
 
56
#ifndef _WIN32
 
57
#include <sys/time.h>
 
58
#endif
 
59
 
 
60
#include "vamp-sdk/RealTime.h"
 
61
 
 
62
_VAMP_SDK_PLUGSPACE_BEGIN(RealTime.cpp)
 
63
 
 
64
namespace Vamp {
 
65
 
 
66
// A RealTime consists of two ints that must be at least 32 bits each.
 
67
// A signed 32-bit int can store values exceeding +/- 2 billion.  This
 
68
// means we can safely use our lower int for nanoseconds, as there are
 
69
// 1 billion nanoseconds in a second and we need to handle double that
 
70
// because of the implementations of addition etc that we use.
 
71
//
 
72
// The maximum valid RealTime on a 32-bit system is somewhere around
 
73
// 68 years: 999999999 nanoseconds longer than the classic Unix epoch.
 
74
 
 
75
#define ONE_BILLION 1000000000
 
76
 
 
77
RealTime::RealTime(int s, int n) :
 
78
    sec(s), nsec(n)
 
79
{
 
80
    if (sec == 0) {
 
81
        while (nsec <= -ONE_BILLION) { nsec += ONE_BILLION; --sec; }
 
82
        while (nsec >=  ONE_BILLION) { nsec -= ONE_BILLION; ++sec; }
 
83
    } else if (sec < 0) {
 
84
        while (nsec <= -ONE_BILLION) { nsec += ONE_BILLION; --sec; }
 
85
        while (nsec > 0)             { nsec -= ONE_BILLION; ++sec; }
 
86
    } else { 
 
87
        while (nsec >=  ONE_BILLION) { nsec -= ONE_BILLION; ++sec; }
 
88
        while (nsec < 0)             { nsec += ONE_BILLION; --sec; }
 
89
    }
 
90
}
 
91
 
 
92
RealTime
 
93
RealTime::fromSeconds(double sec)
 
94
{
 
95
    return RealTime(int(sec), int((sec - int(sec)) * ONE_BILLION + 0.5));
 
96
}
 
97
 
 
98
RealTime
 
99
RealTime::fromMilliseconds(int msec)
 
100
{
 
101
    return RealTime(msec / 1000, (msec % 1000) * 1000000);
 
102
}
 
103
 
 
104
#ifndef _WIN32
 
105
RealTime
 
106
RealTime::fromTimeval(const struct timeval &tv)
 
107
{
 
108
    return RealTime(tv.tv_sec, tv.tv_usec * 1000);
 
109
}
 
110
#endif
 
111
 
 
112
std::ostream &operator<<(std::ostream &out, const RealTime &rt)
 
113
{
 
114
    if (rt < RealTime::zeroTime) {
 
115
        out << "-";
 
116
    } else {
 
117
        out << " ";
 
118
    }
 
119
 
 
120
    int s = (rt.sec < 0 ? -rt.sec : rt.sec);
 
121
    int n = (rt.nsec < 0 ? -rt.nsec : rt.nsec);
 
122
 
 
123
    out << s << ".";
 
124
 
 
125
    int nn(n);
 
126
    if (nn == 0) out << "00000000";
 
127
    else while (nn < (ONE_BILLION / 10)) {
 
128
        out << "0";
 
129
        nn *= 10;
 
130
    }
 
131
    
 
132
    out << n << "R";
 
133
    return out;
 
134
}
 
135
 
 
136
std::string
 
137
RealTime::toString() const
 
138
{
 
139
    std::stringstream out;
 
140
    out << *this;
 
141
    
 
142
#if (__GNUC__ < 3)
 
143
    out << std::ends;
 
144
#endif
 
145
 
 
146
    std::string s = out.str();
 
147
 
 
148
    // remove trailing R
 
149
    return s.substr(0, s.length() - 1);
 
150
}
 
151
 
 
152
std::string
 
153
RealTime::toText(bool fixedDp) const
 
154
{
 
155
    if (*this < RealTime::zeroTime) return "-" + (-*this).toText();
 
156
 
 
157
    std::stringstream out;
 
158
 
 
159
    if (sec >= 3600) {
 
160
        out << (sec / 3600) << ":";
 
161
    }
 
162
 
 
163
    if (sec >= 60) {
 
164
        out << (sec % 3600) / 60 << ":";
 
165
    }
 
166
 
 
167
    if (sec >= 10) {
 
168
        out << ((sec % 60) / 10);
 
169
    }
 
170
 
 
171
    out << (sec % 10);
 
172
    
 
173
    int ms = msec();
 
174
 
 
175
    if (ms != 0) {
 
176
        out << ".";
 
177
        out << (ms / 100);
 
178
        ms = ms % 100;
 
179
        if (ms != 0) {
 
180
            out << (ms / 10);
 
181
            ms = ms % 10;
 
182
        } else if (fixedDp) {
 
183
            out << "0";
 
184
        }
 
185
        if (ms != 0) {
 
186
            out << ms;
 
187
        } else if (fixedDp) {
 
188
            out << "0";
 
189
        }
 
190
    } else if (fixedDp) {
 
191
        out << ".000";
 
192
    }
 
193
        
 
194
#if (__GNUC__ < 3)
 
195
    out << std::ends;
 
196
#endif
 
197
 
 
198
    std::string s = out.str();
 
199
 
 
200
    return s;
 
201
}
 
202
 
 
203
 
 
204
RealTime
 
205
RealTime::operator/(int d) const
 
206
{
 
207
    int secdiv = sec / d;
 
208
    int secrem = sec % d;
 
209
 
 
210
    double nsecdiv = (double(nsec) + ONE_BILLION * double(secrem)) / d;
 
211
    
 
212
    return RealTime(secdiv, int(nsecdiv + 0.5));
 
213
}
 
214
 
 
215
double 
 
216
RealTime::operator/(const RealTime &r) const
 
217
{
 
218
    double lTotal = double(sec) * ONE_BILLION + double(nsec);
 
219
    double rTotal = double(r.sec) * ONE_BILLION + double(r.nsec);
 
220
    
 
221
    if (rTotal == 0) return 0.0;
 
222
    else return lTotal/rTotal;
 
223
}
 
224
 
 
225
long
 
226
RealTime::realTime2Frame(const RealTime &time, unsigned int sampleRate)
 
227
{
 
228
    if (time < zeroTime) return -realTime2Frame(-time, sampleRate);
 
229
    double s = time.sec + double(time.nsec + 1) / 1000000000.0;
 
230
    return long(s * sampleRate);
 
231
}
 
232
 
 
233
RealTime
 
234
RealTime::frame2RealTime(long frame, unsigned int sampleRate)
 
235
{
 
236
    if (frame < 0) return -frame2RealTime(-frame, sampleRate);
 
237
 
 
238
    RealTime rt;
 
239
    rt.sec = frame / long(sampleRate);
 
240
    frame -= rt.sec * long(sampleRate);
 
241
    rt.nsec = (int)(((double(frame) * 1000000.0) / sampleRate) * 1000.0);
 
242
    return rt;
 
243
}
 
244
 
 
245
const RealTime RealTime::zeroTime(0,0);
 
246
 
 
247
}
 
248
 
 
249
_VAMP_SDK_PLUGSPACE_END(RealTime.cpp)
 
250
 
 
251
 
 
252