media/base/audio_buffer_queue_unittest.cc

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