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
175
176
177
178
179
180
|
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "media/base/audio_timestamp_helper.h"
#include <stddef.h>
#include <stdint.h>
#include "media/base/timestamp_constants.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace media {
namespace {
const int k48kHz = 48000;
} // namespace
static const int kDefaultSampleRate = 44100;
class AudioTimestampHelperTest : public ::testing::Test {
public:
AudioTimestampHelperTest() : helper_(kDefaultSampleRate) {
helper_.SetBaseTimestamp(base::TimeDelta());
}
AudioTimestampHelperTest(const AudioTimestampHelperTest&) = delete;
AudioTimestampHelperTest& operator=(const AudioTimestampHelperTest&) = delete;
// Adds frames to the helper and returns the current timestamp in
// microseconds.
int64_t AddFrames(int frames) {
helper_.AddFrames(frames);
return helper_.GetTimestamp().InMicroseconds();
}
int64_t FramesToTarget(int target_in_microseconds) {
return helper_.GetFramesToTarget(
base::Microseconds(target_in_microseconds));
}
void TestGetFramesToTargetRange(int frame_count, int start, int end) {
for (int i = start; i <= end; ++i) {
EXPECT_EQ(frame_count, FramesToTarget(i)) << " Failure for timestamp "
<< i << " us.";
}
}
protected:
AudioTimestampHelper helper_;
};
TEST_F(AudioTimestampHelperTest, FramesToTime) {
// Negative value.
EXPECT_EQ(base::Seconds(-1),
AudioTimestampHelper::FramesToTime(-48000, k48kHz));
// Zero.
EXPECT_EQ(base::Microseconds(0),
AudioTimestampHelper::FramesToTime(0, k48kHz));
// One frame.
EXPECT_EQ(base::Microseconds(20),
AudioTimestampHelper::FramesToTime(1, k48kHz));
// Exact value with maximum precision of TimeDelta.
EXPECT_EQ(base::Microseconds(15625),
AudioTimestampHelper::FramesToTime(750, k48kHz));
// One second.
EXPECT_EQ(base::Seconds(1),
AudioTimestampHelper::FramesToTime(48000, k48kHz));
// Argument and return value exceeding 32 bits.
EXPECT_EQ(base::Seconds(1000000),
AudioTimestampHelper::FramesToTime(48000000000, k48kHz));
}
TEST_F(AudioTimestampHelperTest, TimeToFrames) {
// Negative value.
EXPECT_EQ(-48000,
AudioTimestampHelper::TimeToFrames(base::Seconds(-1), k48kHz));
// Zero.
EXPECT_EQ(0,
AudioTimestampHelper::TimeToFrames(base::Microseconds(0), k48kHz));
// Duration of each frame is 20.833 microseconds. The result is rounded to
// integral.
EXPECT_EQ(0,
AudioTimestampHelper::TimeToFrames(base::Microseconds(10), k48kHz));
EXPECT_EQ(1,
AudioTimestampHelper::TimeToFrames(base::Microseconds(20), k48kHz));
EXPECT_EQ(1,
AudioTimestampHelper::TimeToFrames(base::Microseconds(21), k48kHz));
// Exact value with maximum precision of TimeDelta.
EXPECT_EQ(750, AudioTimestampHelper::TimeToFrames(base::Microseconds(15625),
k48kHz));
// One second.
EXPECT_EQ(48000,
AudioTimestampHelper::TimeToFrames(base::Seconds(1), k48kHz));
// Argument and return value exceeding 32 bits.
EXPECT_EQ(48000000000,
AudioTimestampHelper::TimeToFrames(base::Seconds(1000000), k48kHz));
}
TEST_F(AudioTimestampHelperTest, Basic) {
EXPECT_EQ(0, helper_.GetTimestamp().InMicroseconds());
// Verify that the output timestamp is always rounded down to the
// nearest microsecond. 1 frame @ 44100 is ~22.67573 microseconds,
// which is why the timestamp sometimes increments by 23 microseconds
// and other times it increments by 22 microseconds.
EXPECT_EQ(0, AddFrames(0));
EXPECT_EQ(22, AddFrames(1));
EXPECT_EQ(45, AddFrames(1));
EXPECT_EQ(68, AddFrames(1));
EXPECT_EQ(90, AddFrames(1));
EXPECT_EQ(113, AddFrames(1));
// Verify that adding frames one frame at a time matches the timestamp
// returned if the same number of frames are added all at once.
base::TimeDelta timestamp_1 = helper_.GetTimestamp();
helper_.SetBaseTimestamp(kNoTimestamp);
EXPECT_TRUE(kNoTimestamp == helper_.base_timestamp());
helper_.SetBaseTimestamp(base::TimeDelta());
EXPECT_EQ(0, helper_.GetTimestamp().InMicroseconds());
helper_.AddFrames(5);
EXPECT_EQ(113, helper_.GetTimestamp().InMicroseconds());
EXPECT_TRUE(timestamp_1 == helper_.GetTimestamp());
}
TEST_F(AudioTimestampHelperTest, GetDuration) {
helper_.SetBaseTimestamp(base::Microseconds(100));
int frame_count = 5;
int64_t expected_durations[] = {113, 113, 114, 113, 113, 114};
for (size_t i = 0; i < std::size(expected_durations); ++i) {
base::TimeDelta duration = helper_.GetFrameDuration(frame_count);
EXPECT_EQ(expected_durations[i], duration.InMicroseconds());
base::TimeDelta timestamp_1 = helper_.GetTimestamp() + duration;
helper_.AddFrames(frame_count);
base::TimeDelta timestamp_2 = helper_.GetTimestamp();
EXPECT_TRUE(timestamp_1 == timestamp_2);
}
}
TEST_F(AudioTimestampHelperTest, GetFramesToTarget) {
// Verify GetFramesToTarget() rounding behavior.
// 1 frame @ 44100 is ~22.67573 microseconds,
// Test values less than half of the frame duration.
TestGetFramesToTargetRange(0, 0, 11);
// Test values between half the frame duration & the
// full frame duration.
TestGetFramesToTargetRange(1, 12, 22);
// Verify that the same number of frames is returned up
// to the next half a frame.
TestGetFramesToTargetRange(1, 23, 34);
// Verify the next 3 ranges.
TestGetFramesToTargetRange(2, 35, 56);
TestGetFramesToTargetRange(3, 57, 79);
TestGetFramesToTargetRange(4, 80, 102);
TestGetFramesToTargetRange(5, 103, 124);
// Add frames to the helper so negative frame counts can be tested.
helper_.AddFrames(5);
// Note: The timestamp ranges must match the positive values
// tested above to verify that the code is rounding properly.
TestGetFramesToTargetRange(0, 103, 124);
TestGetFramesToTargetRange(-1, 80, 102);
TestGetFramesToTargetRange(-2, 57, 79);
TestGetFramesToTargetRange(-3, 35, 56);
TestGetFramesToTargetRange(-4, 12, 34);
TestGetFramesToTargetRange(-5, 0, 11);
}
} // namespace media
|
