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
165
166
167
168
169
170
171
172
173
174
|
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* 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 2
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* $URL$
* $Id$
*
*/
#ifndef SOUND_TIMESTAMP_H
#define SOUND_TIMESTAMP_H
#include "common/scummsys.h"
namespace Audio {
/**
* Timestamps allow measuring times with a sub-millisecond granularity,
* and without rounding losses. This is achieved by measuring frames
* instead of milliseconds: Specify an initial time in milliseconds
* plus framerate (in frames per second).
*/
class Timestamp {
protected:
/**
* The seconds part of this timestamp.
* The total time in seconds represented by this timestamp can be
* computed as follows:
* _secs + (double)_numberOfFrames / _framerate
*/
uint _secs;
/**
* The number of frames which together with _secs encodes
* the timestamp. The total number of frames represented
* by this timestamp is computed as follows:
* _numberOfFrames + _secs * _framerate
*/
int _numberOfFrames;
/**
* The internal framerate, i.e. the number of frames per second.
* This is computed as the least common multiple of the framerate
* specified by the client code, and 1000.
* This way, we ensure that we can store both frames and
* milliseconds without any rounding losses.
*/
int _framerate;
/**
* Factor by which the original framerate specified by the client
* code was multipled to obtain the internal _framerate value.
*/
int _framerateFactor;
public:
/**
* Set up a timestamp with a given time and framerate.
* @param msecs starting time in milliseconds
* @param framerate number of frames per second (must be > 0)
*/
Timestamp(uint32 msecs, int framerate);
/**
* Set up a timestamp with a given time, frames and framerate.
* @param secs starting time in seconds
* @param frames starting frames
* @param framerate number of frames per second (must be > 0)
*/
Timestamp(uint secs, int frames, int framerate);
/**
* Return a timestamp which represents as closely as possible
* the point in time describes by this timestamp, but with
* a different framerate.
*/
Timestamp convertToFramerate(int newFramerate) const;
/**
* Check whether to timestamps describe the exact same moment
* in time. This means that two timestamps can compare
* as equal even if they use different framerates.
*/
bool operator==(const Timestamp &ts) const;
bool operator!=(const Timestamp &ts) const;
bool operator<(const Timestamp &ts) const;
bool operator<=(const Timestamp &ts) const;
bool operator>(const Timestamp &ts) const;
bool operator>=(const Timestamp &ts) const;
/**
* Returns a new timestamp, which corresponds to the time encoded
* by this timestamp with the given number of frames added.
* @param frames number of frames to add
*/
Timestamp addFrames(int frames) const;
/**
* Returns a new timestamp, which corresponds to the time encoded
* by this timestamp with the given number of milliseconds added.
* @param msecs number of milliseconds to add
*/
Timestamp addMsecs(int msecs) const;
/**
* Computes the number of frames between this timestamp and ts.
* The frames are with respect to the framerate used by this
* Timestamp (which may differ from the framerate used by ts).
*/
int frameDiff(const Timestamp &ts) const;
/** Computes the number off milliseconds between this timestamp and ts. */
int msecsDiff(const Timestamp &ts) const;
/**
* Return the time in milliseconds described by this timestamp,
* rounded down.
*/
uint32 msecs() const;
/**
* Return the time in seconds described by this timestamp,
* rounded down.
*/
inline uint32 secs() const {
return _secs;
}
/**
* Return the time in frames described by this timestamp.
*/
inline int totalNumberOfFrames() const {
return _numberOfFrames / _framerateFactor + _secs * (_framerate / _framerateFactor);
}
/**
* A timestamp consists of a number of seconds, plus a number
* of frames, the latter describing a fraction of a second.
* This method returns the latter number.
*/
inline int numberOfFrames() const {
return _numberOfFrames / _framerateFactor;
}
/** Return the framerate used by this timestamp. */
inline int framerate() const { return _framerate / _framerateFactor; }
protected:
int cmp(const Timestamp &ts) const;
void addFramesIntern(int frames);
};
} // End of namespace Audio
#endif
|
