1 /*
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "modules/audio_coding/neteq/dtmf_buffer.h"
12
13 #ifdef WIN32
14 #include <winsock2.h> // ntohl()
15 #else
16 #include <arpa/inet.h> // ntohl()
17 #endif
18
19 #include <iostream>
20
21 #include "test/gtest.h"
22
23 // Modify the tests so that they pass with the modifications done to DtmfBuffer
24 // for backwards bit-exactness. Once bit-exactness is no longer required, this
25 // #define should be removed (and the code that it enables).
26 #define LEGACY_BITEXACT
27
28 namespace webrtc {
29
30 static int sample_rate_hz = 8000;
31
MakeDtmfPayload(int event,bool end,int volume,int duration)32 static uint32_t MakeDtmfPayload(int event, bool end, int volume, int duration) {
33 uint32_t payload = 0;
34 // 0 1 2 3
35 // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
36 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
37 // | event |E|R| volume | duration |
38 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
39 payload |= (event & 0x00FF) << 24;
40 payload |= (end ? 0x00800000 : 0x00000000);
41 payload |= (volume & 0x003F) << 16;
42 payload |= (duration & 0xFFFF);
43 payload = ntohl(payload);
44 return payload;
45 }
46
EqualEvents(const DtmfEvent & a,const DtmfEvent & b)47 static bool EqualEvents(const DtmfEvent& a, const DtmfEvent& b) {
48 return (a.duration == b.duration && a.end_bit == b.end_bit &&
49 a.event_no == b.event_no && a.timestamp == b.timestamp &&
50 a.volume == b.volume);
51 }
52
TEST(DtmfBuffer,CreateAndDestroy)53 TEST(DtmfBuffer, CreateAndDestroy) {
54 DtmfBuffer* buffer = new DtmfBuffer(sample_rate_hz);
55 delete buffer;
56 }
57
58 // Test the event parser.
TEST(DtmfBuffer,ParseEvent)59 TEST(DtmfBuffer, ParseEvent) {
60 int event_no = 7;
61 bool end_bit = true;
62 int volume = 17;
63 int duration = 4711;
64 uint32_t timestamp = 0x12345678;
65 uint32_t payload = MakeDtmfPayload(event_no, end_bit, volume, duration);
66 uint8_t* payload_ptr = reinterpret_cast<uint8_t*>(&payload);
67 DtmfEvent event;
68 EXPECT_EQ(DtmfBuffer::kOK, DtmfBuffer::ParseEvent(timestamp, payload_ptr,
69 sizeof(payload), &event));
70 EXPECT_EQ(duration, event.duration);
71 EXPECT_EQ(end_bit, event.end_bit);
72 EXPECT_EQ(event_no, event.event_no);
73 EXPECT_EQ(timestamp, event.timestamp);
74 EXPECT_EQ(volume, event.volume);
75
76 EXPECT_EQ(DtmfBuffer::kPayloadTooShort,
77 DtmfBuffer::ParseEvent(timestamp, payload_ptr, 3, &event));
78 }
79
TEST(DtmfBuffer,SimpleInsertAndGet)80 TEST(DtmfBuffer, SimpleInsertAndGet) {
81 int event_no = 7;
82 bool end_bit = true;
83 int volume = 17;
84 int duration = 4711;
85 uint32_t timestamp = 0x12345678;
86 DtmfEvent event(timestamp, event_no, volume, duration, end_bit);
87 DtmfBuffer buffer(sample_rate_hz);
88 EXPECT_EQ(DtmfBuffer::kOK, buffer.InsertEvent(event));
89 EXPECT_EQ(1u, buffer.Length());
90 EXPECT_FALSE(buffer.Empty());
91 DtmfEvent out_event;
92 // Too early to get event.
93 EXPECT_FALSE(buffer.GetEvent(timestamp - 10, &out_event));
94 EXPECT_EQ(1u, buffer.Length());
95 EXPECT_FALSE(buffer.Empty());
96 // Get the event at its starting timestamp.
97 EXPECT_TRUE(buffer.GetEvent(timestamp, &out_event));
98 EXPECT_TRUE(EqualEvents(event, out_event));
99 EXPECT_EQ(1u, buffer.Length());
100 EXPECT_FALSE(buffer.Empty());
101 // Get the event some time into the event.
102 EXPECT_TRUE(buffer.GetEvent(timestamp + duration / 2, &out_event));
103 EXPECT_TRUE(EqualEvents(event, out_event));
104 EXPECT_EQ(1u, buffer.Length());
105 EXPECT_FALSE(buffer.Empty());
106 // Give a "current" timestamp after the event has ended.
107 #ifdef LEGACY_BITEXACT
108 EXPECT_TRUE(buffer.GetEvent(timestamp + duration + 10, &out_event));
109 #endif
110 EXPECT_FALSE(buffer.GetEvent(timestamp + duration + 10, &out_event));
111 EXPECT_EQ(0u, buffer.Length());
112 EXPECT_TRUE(buffer.Empty());
113 }
114
TEST(DtmfBuffer,MergingPackets)115 TEST(DtmfBuffer, MergingPackets) {
116 int event_no = 0;
117 bool end_bit = false;
118 int volume = 17;
119 int duration = 80;
120 uint32_t timestamp = 0x12345678;
121 DtmfEvent event(timestamp, event_no, volume, duration, end_bit);
122 DtmfBuffer buffer(sample_rate_hz);
123 EXPECT_EQ(DtmfBuffer::kOK, buffer.InsertEvent(event));
124
125 event.duration += 80;
126 EXPECT_EQ(DtmfBuffer::kOK, buffer.InsertEvent(event));
127
128 event.duration += 80;
129 event.end_bit = true;
130 EXPECT_EQ(DtmfBuffer::kOK, buffer.InsertEvent(event));
131
132 EXPECT_EQ(1u, buffer.Length());
133
134 DtmfEvent out_event;
135 EXPECT_TRUE(buffer.GetEvent(timestamp, &out_event));
136 EXPECT_TRUE(EqualEvents(event, out_event));
137 }
138
139 // This test case inserts one shorter event completely overlapped by one longer
140 // event. The expected outcome is that only the longer event is played.
TEST(DtmfBuffer,OverlappingEvents)141 TEST(DtmfBuffer, OverlappingEvents) {
142 int event_no = 0;
143 bool end_bit = true;
144 int volume = 1;
145 int duration = 80;
146 uint32_t timestamp = 0x12345678 + 80;
147 DtmfEvent short_event(timestamp, event_no, volume, duration, end_bit);
148 DtmfBuffer buffer(sample_rate_hz);
149 EXPECT_EQ(DtmfBuffer::kOK, buffer.InsertEvent(short_event));
150
151 event_no = 10;
152 end_bit = false;
153 timestamp = 0x12345678;
154 DtmfEvent long_event(timestamp, event_no, volume, duration, end_bit);
155 EXPECT_EQ(DtmfBuffer::kOK, buffer.InsertEvent(long_event));
156
157 long_event.duration += 80;
158 EXPECT_EQ(DtmfBuffer::kOK, buffer.InsertEvent(long_event));
159
160 long_event.duration += 80;
161 long_event.end_bit = true;
162 EXPECT_EQ(DtmfBuffer::kOK, buffer.InsertEvent(long_event));
163
164 EXPECT_EQ(2u, buffer.Length());
165
166 DtmfEvent out_event;
167 // Expect to get the long event.
168 EXPECT_TRUE(buffer.GetEvent(timestamp, &out_event));
169 EXPECT_TRUE(EqualEvents(long_event, out_event));
170 // Expect no more events.
171 #ifdef LEGACY_BITEXACT
172 EXPECT_TRUE(
173 buffer.GetEvent(timestamp + long_event.duration + 10, &out_event));
174 EXPECT_TRUE(EqualEvents(long_event, out_event));
175 EXPECT_TRUE(
176 buffer.GetEvent(timestamp + long_event.duration + 10, &out_event));
177 EXPECT_TRUE(EqualEvents(short_event, out_event));
178 #else
179 EXPECT_FALSE(
180 buffer.GetEvent(timestamp + long_event.duration + 10, &out_event));
181 #endif
182 EXPECT_TRUE(buffer.Empty());
183 }
184
TEST(DtmfBuffer,ExtrapolationTime)185 TEST(DtmfBuffer, ExtrapolationTime) {
186 int event_no = 0;
187 bool end_bit = false;
188 int volume = 1;
189 int duration = 80;
190 uint32_t timestamp = 0x12345678;
191 DtmfEvent event1(timestamp, event_no, volume, duration, end_bit);
192 DtmfBuffer buffer(sample_rate_hz);
193 EXPECT_EQ(DtmfBuffer::kOK, buffer.InsertEvent(event1));
194 EXPECT_EQ(1u, buffer.Length());
195
196 DtmfEvent out_event;
197 // Get the event at the start.
198 EXPECT_TRUE(buffer.GetEvent(timestamp, &out_event));
199 EXPECT_TRUE(EqualEvents(event1, out_event));
200 // Also get the event 100 samples after the end of the event (since we're
201 // missing the end bit).
202 uint32_t timestamp_now = timestamp + duration + 100;
203 EXPECT_TRUE(buffer.GetEvent(timestamp_now, &out_event));
204 EXPECT_TRUE(EqualEvents(event1, out_event));
205 // Insert another event starting back-to-back with the previous event.
206 timestamp += duration;
207 event_no = 1;
208 DtmfEvent event2(timestamp, event_no, volume, duration, end_bit);
209 EXPECT_EQ(DtmfBuffer::kOK, buffer.InsertEvent(event2));
210 EXPECT_EQ(2u, buffer.Length());
211 // Now we expect to get the new event when supplying `timestamp_now`.
212 EXPECT_TRUE(buffer.GetEvent(timestamp_now, &out_event));
213 EXPECT_TRUE(EqualEvents(event2, out_event));
214 // Expect the the first event to be erased now.
215 EXPECT_EQ(1u, buffer.Length());
216 // Move `timestamp_now` to more than 560 samples after the end of the second
217 // event. Expect that event to be erased.
218 timestamp_now = timestamp + duration + 600;
219 #ifdef LEGACY_BITEXACT
220 EXPECT_TRUE(buffer.GetEvent(timestamp_now, &out_event));
221 #endif
222 EXPECT_FALSE(buffer.GetEvent(timestamp_now, &out_event));
223 EXPECT_TRUE(buffer.Empty());
224 }
225
TEST(DtmfBuffer,TimestampWraparound)226 TEST(DtmfBuffer, TimestampWraparound) {
227 int event_no = 0;
228 bool end_bit = true;
229 int volume = 1;
230 int duration = 80;
231 uint32_t timestamp1 = 0xFFFFFFFF - duration;
232 DtmfEvent event1(timestamp1, event_no, volume, duration, end_bit);
233 uint32_t timestamp2 = 0;
234 DtmfEvent event2(timestamp2, event_no, volume, duration, end_bit);
235 DtmfBuffer buffer(sample_rate_hz);
236 EXPECT_EQ(DtmfBuffer::kOK, buffer.InsertEvent(event1));
237 EXPECT_EQ(DtmfBuffer::kOK, buffer.InsertEvent(event2));
238 EXPECT_EQ(2u, buffer.Length());
239 DtmfEvent out_event;
240 EXPECT_TRUE(buffer.GetEvent(timestamp1, &out_event));
241 EXPECT_TRUE(EqualEvents(event1, out_event));
242 #ifdef LEGACY_BITEXACT
243 EXPECT_EQ(1u, buffer.Length());
244 #else
245 EXPECT_EQ(2u, buffer.Length());
246 #endif
247
248 buffer.Flush();
249 // Reverse the insert order. Expect same results.
250 EXPECT_EQ(DtmfBuffer::kOK, buffer.InsertEvent(event2));
251 EXPECT_EQ(DtmfBuffer::kOK, buffer.InsertEvent(event1));
252 EXPECT_EQ(2u, buffer.Length());
253 EXPECT_TRUE(buffer.GetEvent(timestamp1, &out_event));
254 EXPECT_TRUE(EqualEvents(event1, out_event));
255 #ifdef LEGACY_BITEXACT
256 EXPECT_EQ(1u, buffer.Length());
257 #else
258 EXPECT_EQ(2u, buffer.Length());
259 #endif
260 }
261
TEST(DtmfBuffer,InvalidEvents)262 TEST(DtmfBuffer, InvalidEvents) {
263 int event_no = 0;
264 bool end_bit = true;
265 int volume = 1;
266 int duration = 80;
267 uint32_t timestamp = 0x12345678;
268 DtmfEvent event(timestamp, event_no, volume, duration, end_bit);
269 DtmfBuffer buffer(sample_rate_hz);
270
271 // Invalid event number.
272 event.event_no = -1;
273 EXPECT_EQ(DtmfBuffer::kInvalidEventParameters, buffer.InsertEvent(event));
274 event.event_no = 16;
275 EXPECT_EQ(DtmfBuffer::kInvalidEventParameters, buffer.InsertEvent(event));
276 event.event_no = 0; // Valid value;
277
278 // Invalid volume.
279 event.volume = -1;
280 EXPECT_EQ(DtmfBuffer::kInvalidEventParameters, buffer.InsertEvent(event));
281 event.volume = 64;
282 EXPECT_EQ(DtmfBuffer::kInvalidEventParameters, buffer.InsertEvent(event));
283 event.volume = 0; // Valid value;
284
285 // Invalid duration.
286 event.duration = -1;
287 EXPECT_EQ(DtmfBuffer::kInvalidEventParameters, buffer.InsertEvent(event));
288 event.duration = 0;
289 EXPECT_EQ(DtmfBuffer::kInvalidEventParameters, buffer.InsertEvent(event));
290 event.duration = 0xFFFF + 1;
291 EXPECT_EQ(DtmfBuffer::kInvalidEventParameters, buffer.InsertEvent(event));
292 event.duration = 1; // Valid value;
293
294 // Finish with a valid event, just to verify that all is ok.
295 EXPECT_EQ(DtmfBuffer::kOK, buffer.InsertEvent(event));
296 }
297 } // namespace webrtc
298