audio_buffer_queue_unittest.cc revision a1401311d1ab56c4ed0a474bd38c108f75cb0cd9 
1// Copyright 2013 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "base/basictypes.h"
6#include "base/logging.h"
7#include "base/memory/scoped_ptr.h"
8#include "base/strings/stringprintf.h"
9#include "base/time/time.h"
10#include "media/base/audio_buffer.h"
11#include "media/base/audio_buffer_queue.h"
12#include "media/base/audio_bus.h"
13#include "media/base/buffers.h"
14#include "media/base/test_helpers.h"
15#include "testing/gtest/include/gtest/gtest.h"
16
17namespace media {
18
19static void VerifyResult(float* channel_data,
20                         int frames,
21                         float start,
22                         float increment) {
23  for (int i = 0; i < frames; ++i) {
24    SCOPED_TRACE(base::StringPrintf(
25        "i=%d/%d start=%f, increment=%f", i, frames, start, increment));
26    ASSERT_EQ(start, channel_data[i]);
27    start += increment;
28  }
29}
30
31TEST(AudioBufferQueueTest, AppendAndClear) {
32  const int channels = 1;
33  const int frames = 8;
34  const base::TimeDelta kNoTime = kNoTimestamp();
35  AudioBufferQueue buffer;
36  EXPECT_EQ(0, buffer.frames());
37  buffer.Append(MakeAudioBuffer<uint8>(
38      kSampleFormatU8, channels, 10, 1, frames, kNoTime, kNoTime));
39  EXPECT_EQ(frames, buffer.frames());
40  buffer.Clear();
41  EXPECT_EQ(0, buffer.frames());
42  buffer.Append(MakeAudioBuffer<uint8>(
43      kSampleFormatU8, channels, 20, 1, frames, kNoTime, kNoTime));
44  EXPECT_EQ(frames, buffer.frames());
45}
46
47TEST(AudioBufferQueueTest, MultipleAppend) {
48  const int channels = 1;
49  const int frames = 8;
50  const base::TimeDelta kNoTime = kNoTimestamp();
51  AudioBufferQueue buffer;
52
53  // Append 40 frames in 5 buffers.
54  buffer.Append(MakeAudioBuffer<uint8>(
55      kSampleFormatU8, channels, 10, 1, frames, kNoTime, kNoTime));
56  EXPECT_EQ(8, buffer.frames());
57  buffer.Append(MakeAudioBuffer<uint8>(
58      kSampleFormatU8, channels, 10, 1, frames, kNoTime, kNoTime));
59  EXPECT_EQ(16, buffer.frames());
60  buffer.Append(MakeAudioBuffer<uint8>(
61      kSampleFormatU8, channels, 10, 1, frames, kNoTime, kNoTime));
62  EXPECT_EQ(24, buffer.frames());
63  buffer.Append(MakeAudioBuffer<uint8>(
64      kSampleFormatU8, channels, 10, 1, frames, kNoTime, kNoTime));
65  EXPECT_EQ(32, buffer.frames());
66  buffer.Append(MakeAudioBuffer<uint8>(
67      kSampleFormatU8, channels, 10, 1, frames, kNoTime, kNoTime));
68  EXPECT_EQ(40, buffer.frames());
69}
70
71TEST(AudioBufferQueueTest, IteratorCheck) {
72  const int channels = 1;
73  const int frames = 8;
74  const base::TimeDelta kNoTime = kNoTimestamp();
75  AudioBufferQueue buffer;
76  scoped_ptr<AudioBus> bus = AudioBus::Create(channels, 100);
77
78  // Append 40 frames in 5 buffers. Intersperse ReadFrames() to make the
79  // iterator is pointing to the correct position.
80  buffer.Append(MakeAudioBuffer<float>(
81      kSampleFormatF32, channels, 10.0f, 1.0f, frames, kNoTime, kNoTime));
82  EXPECT_EQ(8, buffer.frames());
83
84  EXPECT_EQ(4, buffer.ReadFrames(4, 0, bus.get()));
85  EXPECT_EQ(4, buffer.frames());
86  VerifyResult(bus->channel(0), 4, 10.0f, 1.0f);
87
88  buffer.Append(MakeAudioBuffer<float>(
89      kSampleFormatF32, channels, 20.0f, 1.0f, frames, kNoTime, kNoTime));
90  EXPECT_EQ(12, buffer.frames());
91  buffer.Append(MakeAudioBuffer<float>(
92      kSampleFormatF32, channels, 30.0f, 1.0f, frames, kNoTime, kNoTime));
93  EXPECT_EQ(20, buffer.frames());
94
95  buffer.SeekFrames(16);
96  EXPECT_EQ(4, buffer.ReadFrames(4, 0, bus.get()));
97  EXPECT_EQ(0, buffer.frames());
98  VerifyResult(bus->channel(0), 4, 34.0f, 1.0f);
99
100  buffer.Append(MakeAudioBuffer<float>(
101      kSampleFormatF32, channels, 40.0f, 1.0f, frames, kNoTime, kNoTime));
102  EXPECT_EQ(8, buffer.frames());
103  buffer.Append(MakeAudioBuffer<float>(
104      kSampleFormatF32, channels, 50.0f, 1.0f, frames, kNoTime, kNoTime));
105  EXPECT_EQ(16, buffer.frames());
106
107  EXPECT_EQ(4, buffer.ReadFrames(4, 0, bus.get()));
108  VerifyResult(bus->channel(0), 4, 40.0f, 1.0f);
109
110  // Read off the end of the buffer.
111  EXPECT_EQ(12, buffer.frames());
112  buffer.SeekFrames(8);
113  EXPECT_EQ(4, buffer.ReadFrames(100, 0, bus.get()));
114  VerifyResult(bus->channel(0), 4, 54.0f, 1.0f);
115}
116
117TEST(AudioBufferQueueTest, Seek) {
118  const int channels = 2;
119  const int frames = 6;
120  const base::TimeDelta kNoTime = kNoTimestamp();
121  AudioBufferQueue buffer;
122
123  // Add 6 frames of data.
124  buffer.Append(MakeAudioBuffer<float>(
125      kSampleFormatF32, channels, 1.0f, 1.0f, frames, kNoTime, kNoTime));
126  EXPECT_EQ(6, buffer.frames());
127
128  // Seek past 2 frames.
129  buffer.SeekFrames(2);
130  EXPECT_EQ(4, buffer.frames());
131
132  // Seek to end of data.
133  buffer.SeekFrames(4);
134  EXPECT_EQ(0, buffer.frames());
135
136  // At end, seek now fails unless 0 specified.
137  buffer.SeekFrames(0);
138}
139
140TEST(AudioBufferQueueTest, ReadF32) {
141  const int channels = 2;
142  const base::TimeDelta kNoTime = kNoTimestamp();
143  AudioBufferQueue buffer;
144
145  // Add 76 frames of data.
146  buffer.Append(MakeAudioBuffer<float>(
147      kSampleFormatF32, channels, 1.0f, 1.0f, 6, kNoTime, kNoTime));
148  buffer.Append(MakeAudioBuffer<float>(
149      kSampleFormatF32, channels, 13.0f, 1.0f, 10, kNoTime, kNoTime));
150  buffer.Append(MakeAudioBuffer<float>(
151      kSampleFormatF32, channels, 33.0f, 1.0f, 60, kNoTime, kNoTime));
152  EXPECT_EQ(76, buffer.frames());
153
154  // Read 3 frames from the buffer. F32 is interleaved, so ch[0] should be
155  // 1, 3, 5, and ch[1] should be 2, 4, 6.
156  scoped_ptr<AudioBus> bus = AudioBus::Create(channels, 100);
157  EXPECT_EQ(3, buffer.ReadFrames(3, 0, bus.get()));
158  EXPECT_EQ(73, buffer.frames());
159  VerifyResult(bus->channel(0), 3, 1.0f, 2.0f);
160  VerifyResult(bus->channel(1), 3, 2.0f, 2.0f);
161
162  // Now read 5 frames, which will span buffers. Append the data into AudioBus.
163  EXPECT_EQ(5, buffer.ReadFrames(5, 3, bus.get()));
164  EXPECT_EQ(68, buffer.frames());
165  VerifyResult(bus->channel(0), 8, 1.0f, 2.0f);
166  VerifyResult(bus->channel(1), 8, 2.0f, 2.0f);
167
168  // Now skip into the third buffer.
169  buffer.SeekFrames(20);
170  EXPECT_EQ(48, buffer.frames());
171
172  // Now read 2 frames, which are in the third buffer.
173  EXPECT_EQ(2, buffer.ReadFrames(2, 0, bus.get()));
174  VerifyResult(bus->channel(0), 2, 57.0f, 2.0f);
175  VerifyResult(bus->channel(1), 2, 58.0f, 2.0f);
176}
177
178TEST(AudioBufferQueueTest, ReadU8) {
179  const int channels = 4;
180  const int frames = 4;
181  const base::TimeDelta kNoTime = kNoTimestamp();
182  AudioBufferQueue buffer;
183
184  // Add 4 frames of data.
185  buffer.Append(MakeAudioBuffer<uint8>(
186      kSampleFormatU8, channels, 128, 1, frames, kNoTime, kNoTime));
187
188  // Read all 4 frames from the buffer. Data is interleaved, so ch[0] should be
189  // 128, 132, 136, 140, other channels similar. However, values are converted
190  // from [0, 255] to [-1.0, 1.0] with a bias of 128. Thus the first buffer
191  // value should be 0.0, then 1/127, 2/127, etc.
192  scoped_ptr<AudioBus> bus = AudioBus::Create(channels, 100);
193  EXPECT_EQ(4, buffer.ReadFrames(4, 0, bus.get()));
194  EXPECT_EQ(0, buffer.frames());
195  VerifyResult(bus->channel(0), 4, 0.0f, 4.0f / 127.0f);
196  VerifyResult(bus->channel(1), 4, 1.0f / 127.0f, 4.0f / 127.0f);
197  VerifyResult(bus->channel(2), 4, 2.0f / 127.0f, 4.0f / 127.0f);
198  VerifyResult(bus->channel(3), 4, 3.0f / 127.0f, 4.0f / 127.0f);
199}
200
201TEST(AudioBufferQueueTest, ReadS16) {
202  const int channels = 2;
203  const base::TimeDelta kNoTime = kNoTimestamp();
204  AudioBufferQueue buffer;
205
206  // Add 24 frames of data.
207  buffer.Append(MakeAudioBuffer<int16>(
208      kSampleFormatS16, channels, 1, 1, 4, kNoTime, kNoTime));
209  buffer.Append(MakeAudioBuffer<int16>(
210      kSampleFormatS16, channels, 9, 1, 20, kNoTime, kNoTime));
211  EXPECT_EQ(24, buffer.frames());
212
213  // Read 6 frames from the buffer. Data is interleaved, so ch[0] should be
214  // 1, 3, 5, 7, 9, 11, and ch[1] should be 2, 4, 6, 8, 10, 12.
215  // Data is converted to float from -1.0 to 1.0 based on int16 range.
216  scoped_ptr<AudioBus> bus = AudioBus::Create(channels, 100);
217  EXPECT_EQ(6, buffer.ReadFrames(6, 0, bus.get()));
218  EXPECT_EQ(18, buffer.frames());
219  VerifyResult(bus->channel(0), 6, 1.0f / kint16max, 2.0f / kint16max);
220  VerifyResult(bus->channel(1), 6, 2.0f / kint16max, 2.0f / kint16max);
221}
222
223TEST(AudioBufferQueueTest, ReadS32) {
224  const int channels = 2;
225  const base::TimeDelta kNoTime = kNoTimestamp();
226  AudioBufferQueue buffer;
227
228  // Add 24 frames of data.
229  buffer.Append(MakeAudioBuffer<int32>(
230      kSampleFormatS32, channels, 1, 1, 4, kNoTime, kNoTime));
231  buffer.Append(MakeAudioBuffer<int32>(
232      kSampleFormatS32, channels, 9, 1, 20, kNoTime, kNoTime));
233  EXPECT_EQ(24, buffer.frames());
234
235  // Read 6 frames from the buffer. Data is interleaved, so ch[0] should be
236  // 1, 3, 5, 7, 100, 106, and ch[1] should be 2, 4, 6, 8, 103, 109.
237  // Data is converted to float from -1.0 to 1.0 based on int32 range.
238  scoped_ptr<AudioBus> bus = AudioBus::Create(channels, 100);
239  EXPECT_EQ(6, buffer.ReadFrames(6, 0, bus.get()));
240  EXPECT_EQ(18, buffer.frames());
241  VerifyResult(bus->channel(0), 6, 1.0f / kint32max, 2.0f / kint32max);
242  VerifyResult(bus->channel(1), 6, 2.0f / kint32max, 2.0f / kint32max);
243
244  // Read the next 2 frames.
245  EXPECT_EQ(2, buffer.ReadFrames(2, 0, bus.get()));
246  EXPECT_EQ(16, buffer.frames());
247  VerifyResult(bus->channel(0), 2, 13.0f / kint32max, 2.0f / kint32max);
248  VerifyResult(bus->channel(1), 2, 14.0f / kint32max, 2.0f / kint32max);
249}
250
251TEST(AudioBufferQueueTest, ReadF32Planar) {
252  const int channels = 2;
253  const base::TimeDelta kNoTime = kNoTimestamp();
254  AudioBufferQueue buffer;
255
256  // Add 14 frames of data.
257  buffer.Append(MakeAudioBuffer<float>(
258      kSampleFormatPlanarF32, channels, 1.0f, 1.0f, 4, kNoTime, kNoTime));
259  buffer.Append(MakeAudioBuffer<float>(
260      kSampleFormatPlanarF32, channels, 50.0f, 1.0f, 10, kNoTime, kNoTime));
261  EXPECT_EQ(14, buffer.frames());
262
263  // Read 6 frames from the buffer. F32 is planar, so ch[0] should be
264  // 1, 2, 3, 4, 50, 51, and ch[1] should be 5, 6, 7, 8, 60, 61.
265  scoped_ptr<AudioBus> bus = AudioBus::Create(channels, 100);
266  EXPECT_EQ(6, buffer.ReadFrames(6, 0, bus.get()));
267  EXPECT_EQ(8, buffer.frames());
268  VerifyResult(bus->channel(0), 4, 1.0f, 1.0f);
269  VerifyResult(bus->channel(0) + 4, 2, 50.0f, 1.0f);
270  VerifyResult(bus->channel(1), 4, 5.0f, 1.0f);
271  VerifyResult(bus->channel(1) + 4, 2, 60.0f, 1.0f);
272}
273
274TEST(AudioBufferQueueTest, ReadS16Planar) {
275  const int channels = 2;
276  const base::TimeDelta kNoTime = kNoTimestamp();
277  AudioBufferQueue buffer;
278
279  // Add 24 frames of data.
280  buffer.Append(MakeAudioBuffer<int16>(
281      kSampleFormatPlanarS16, channels, 1, 1, 4, kNoTime, kNoTime));
282  buffer.Append(MakeAudioBuffer<int16>(
283      kSampleFormatPlanarS16, channels, 100, 5, 20, kNoTime, kNoTime));
284  EXPECT_EQ(24, buffer.frames());
285
286  // Read 6 frames from the buffer. Data is planar, so ch[0] should be
287  // 1, 2, 3, 4, 100, 105, and ch[1] should be 5, 6, 7, 8, 200, 205.
288  // Data is converted to float from -1.0 to 1.0 based on int16 range.
289  scoped_ptr<AudioBus> bus = AudioBus::Create(channels, 100);
290  EXPECT_EQ(6, buffer.ReadFrames(6, 0, bus.get()));
291  EXPECT_EQ(18, buffer.frames());
292  VerifyResult(bus->channel(0), 4, 1.0f / kint16max, 1.0f / kint16max);
293  VerifyResult(bus->channel(0) + 4, 2, 100.0f / kint16max, 5.0f / kint16max);
294  VerifyResult(bus->channel(1), 4, 5.0f / kint16max, 1.0f / kint16max);
295  VerifyResult(bus->channel(1) + 4, 2, 200.0f / kint16max, 5.0f / kint16max);
296}
297
298TEST(AudioBufferQueueTest, ReadManyChannels) {
299  const int channels = 16;
300  const base::TimeDelta kNoTime = kNoTimestamp();
301  AudioBufferQueue buffer;
302
303  // Add 76 frames of data.
304  buffer.Append(MakeAudioBuffer<float>(
305      kSampleFormatF32, channels, 0.0f, 1.0f, 6, kNoTime, kNoTime));
306  buffer.Append(MakeAudioBuffer<float>(
307      kSampleFormatF32, channels, 6.0f * channels, 1.0f, 10, kNoTime, kNoTime));
308  buffer.Append(MakeAudioBuffer<float>(kSampleFormatF32,
309                                       channels,
310                                       16.0f * channels,
311                                       1.0f,
312                                       60,
313                                       kNoTime,
314                                       kNoTime));
315  EXPECT_EQ(76, buffer.frames());
316
317  // Read 3 frames from the buffer. F32 is interleaved, so ch[0] should be
318  // 1, 17, 33, and ch[1] should be 2, 18, 34. Just check a few channels.
319  scoped_ptr<AudioBus> bus = AudioBus::Create(channels, 100);
320  EXPECT_EQ(30, buffer.ReadFrames(30, 0, bus.get()));
321  EXPECT_EQ(46, buffer.frames());
322  for (int i = 0; i < channels; ++i) {
323    VerifyResult(bus->channel(i), 30, static_cast<float>(i), 16.0f);
324  }
325}
326
327TEST(AudioBufferQueueTest, Peek) {
328  const int channels = 4;
329  const base::TimeDelta kNoTime = kNoTimestamp();
330  AudioBufferQueue buffer;
331
332  // Add 60 frames of data.
333  buffer.Append(MakeAudioBuffer<float>(
334      kSampleFormatF32, channels, 0.0f, 1.0f, 60, kNoTime, kNoTime));
335  EXPECT_EQ(60, buffer.frames());
336
337  // Peek at the first 30 frames.
338  scoped_ptr<AudioBus> bus1 = AudioBus::Create(channels, 100);
339  EXPECT_EQ(60, buffer.frames());
340  EXPECT_EQ(60, buffer.PeekFrames(100, 0, 0, bus1.get()));
341  EXPECT_EQ(30, buffer.PeekFrames(30, 0, 0, bus1.get()));
342  EXPECT_EQ(60, buffer.frames());
343
344  // Now read the next 30 frames (which should be the same as those peeked at).
345  scoped_ptr<AudioBus> bus2 = AudioBus::Create(channels, 100);
346  EXPECT_EQ(30, buffer.ReadFrames(30, 0, bus2.get()));
347  for (int i = 0; i < channels; ++i) {
348    VerifyResult(bus1->channel(i),
349                 30,
350                 static_cast<float>(i),
351                 static_cast<float>(channels));
352    VerifyResult(bus2->channel(i),
353                 30,
354                 static_cast<float>(i),
355                 static_cast<float>(channels));
356  }
357
358  // Peek 10 frames forward
359  EXPECT_EQ(5, buffer.PeekFrames(5, 10, 0, bus1.get()));
360  for (int i = 0; i < channels; ++i) {
361    VerifyResult(bus1->channel(i),
362                 5,
363                 static_cast<float>(i + 40 * channels),
364                 static_cast<float>(channels));
365  }
366
367  // Peek to the end of the buffer.
368  EXPECT_EQ(30, buffer.frames());
369  EXPECT_EQ(30, buffer.PeekFrames(100, 0, 0, bus1.get()));
370  EXPECT_EQ(30, buffer.PeekFrames(30, 0, 0, bus1.get()));
371}
372
373TEST(AudioBufferQueueTest, Time) {
374  const int channels = 2;
375  const base::TimeDelta start_time1;
376  const base::TimeDelta start_time2 = base::TimeDelta::FromSeconds(30);
377  const base::TimeDelta duration = base::TimeDelta::FromSeconds(10);
378  AudioBufferQueue buffer;
379  scoped_ptr<AudioBus> bus = AudioBus::Create(channels, 100);
380
381  // Add two buffers (second one added later):
382  //   first:  start=0s,  duration=10s
383  //   second: start=30s, duration=10s
384  buffer.Append(MakeAudioBuffer<int16>(
385      kSampleFormatS16, channels, 1, 1, 10, start_time1, duration));
386  EXPECT_EQ(10, buffer.frames());
387
388  // Check starting time.
389  EXPECT_EQ(start_time1, buffer.current_time());
390
391  // Read 2 frames, should be 2s in (since duration is 1s per sample).
392  EXPECT_EQ(2, buffer.ReadFrames(2, 0, bus.get()));
393  EXPECT_EQ(start_time1 + base::TimeDelta::FromSeconds(2),
394            buffer.current_time());
395
396  // Skip 2 frames.
397  buffer.SeekFrames(2);
398  EXPECT_EQ(start_time1 + base::TimeDelta::FromSeconds(4),
399            buffer.current_time());
400
401  // Add second buffer for more data.
402  buffer.Append(MakeAudioBuffer<int16>(
403      kSampleFormatS16, channels, 1, 1, 10, start_time2, duration));
404  EXPECT_EQ(16, buffer.frames());
405
406  // Read until almost the end of buffer1.
407  EXPECT_EQ(5, buffer.ReadFrames(5, 0, bus.get()));
408  EXPECT_EQ(start_time1 + base::TimeDelta::FromSeconds(9),
409            buffer.current_time());
410
411  // Read 1 value, so time moved to buffer2.
412  EXPECT_EQ(1, buffer.ReadFrames(1, 0, bus.get()));
413  EXPECT_EQ(start_time2, buffer.current_time());
414
415  // Read all 10 frames in buffer2, timestamp should be last time from buffer2.
416  EXPECT_EQ(10, buffer.ReadFrames(10, 0, bus.get()));
417  EXPECT_EQ(start_time2 + base::TimeDelta::FromSeconds(10),
418            buffer.current_time());
419
420  // Try to read more frames (which don't exist), timestamp should remain.
421  EXPECT_EQ(0, buffer.ReadFrames(5, 0, bus.get()));
422  EXPECT_EQ(start_time2 + base::TimeDelta::FromSeconds(10),
423            buffer.current_time());
424}
425
426TEST(AudioBufferQueueTest, NoTime) {
427  const int channels = 2;
428  const base::TimeDelta kNoTime = kNoTimestamp();
429  AudioBufferQueue buffer;
430  scoped_ptr<AudioBus> bus = AudioBus::Create(channels, 100);
431
432  // Add two buffers with no timestamps. Time should always be unknown.
433  buffer.Append(MakeAudioBuffer<int16>(
434      kSampleFormatS16, channels, 1, 1, 10, kNoTime, kNoTime));
435  buffer.Append(MakeAudioBuffer<int16>(
436      kSampleFormatS16, channels, 1, 1, 10, kNoTime, kNoTime));
437  EXPECT_EQ(20, buffer.frames());
438
439  // Check starting time.
440  EXPECT_EQ(kNoTime, buffer.current_time());
441
442  // Read 2 frames.
443  EXPECT_EQ(2, buffer.ReadFrames(2, 0, bus.get()));
444  EXPECT_EQ(kNoTime, buffer.current_time());
445
446  // Skip 2 frames.
447  buffer.SeekFrames(2);
448  EXPECT_EQ(kNoTime, buffer.current_time());
449
450  // Read until almost the end of buffer1.
451  EXPECT_EQ(5, buffer.ReadFrames(5, 0, bus.get()));
452  EXPECT_EQ(kNoTime, buffer.current_time());
453
454  // Read 1 value, so time moved to buffer2.
455  EXPECT_EQ(1, buffer.ReadFrames(1, 0, bus.get()));
456  EXPECT_EQ(kNoTime, buffer.current_time());
457
458  // Read all 10 frames in buffer2.
459  EXPECT_EQ(10, buffer.ReadFrames(10, 0, bus.get()));
460  EXPECT_EQ(kNoTime, buffer.current_time());
461
462  // Try to read more frames (which don't exist), timestamp should remain.
463  EXPECT_EQ(0, buffer.ReadFrames(5, 0, bus.get()));
464  EXPECT_EQ(kNoTime, buffer.current_time());
465}
466
467}  // namespace media
468