media/base/audio_block_fifo_unittest.cc

   1 // Copyright 2014 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/time/time.h"
   6 #include "media/audio/audio_power_monitor.h"
   7 #include "media/base/audio_block_fifo.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9
  10 namespace media {
  11
  12 class AudioBlockFifoTest : public testing::Test {
  13  public:
  14   AudioBlockFifoTest() {}
  15   ~AudioBlockFifoTest() override {}
  16
  17   void PushAndVerify(AudioBlockFifo* fifo, int frames_to_push,
  18                      int channels, int block_frames, int max_frames) {
  19     for (int filled_frames = max_frames - fifo->GetUnfilledFrames();
  20          filled_frames + frames_to_push <= max_frames;) {
  21       Push(fifo, frames_to_push, channels);
  22       filled_frames += frames_to_push;
  23       EXPECT_EQ(max_frames - filled_frames, fifo->GetUnfilledFrames());
  24       EXPECT_EQ(static_cast<int>(filled_frames / block_frames),
  25                 fifo->available_blocks());
  26     }
  27   }
  28
  29   void Push(AudioBlockFifo* fifo, int frames_to_push, int channels) {
  30     DCHECK_LE(frames_to_push, fifo->GetUnfilledFrames());
  31     const int bytes_per_sample = 2;
  32     const int data_byte_size = bytes_per_sample * channels * frames_to_push;
  33     scoped_ptr<uint8[]> data(new uint8[data_byte_size]);
  34     memset(data.get(), 1, data_byte_size);
  35     fifo->Push(data.get(), frames_to_push, bytes_per_sample);
  36   }
  37
  38   void ConsumeAndVerify(AudioBlockFifo* fifo, int expected_unfilled_frames,
  39                         int expected_available_blocks) {
  40     const AudioBus* bus = fifo->Consume();
  41     EXPECT_EQ(fifo->GetUnfilledFrames(), expected_unfilled_frames);
  42     EXPECT_EQ(fifo->available_blocks(), expected_available_blocks);
  43
  44     // Verify the audio data is not 0.
  45     for (int i = 0; i < bus->channels(); ++i) {
  46       EXPECT_GT(bus->channel(i)[0], 0.0f);
  47       EXPECT_GT(bus->channel(i)[bus->frames() - 1], 0.0f);
  48     }
  49   }
  50
  51  private:
  52   DISALLOW_COPY_AND_ASSIGN(AudioBlockFifoTest);
  53 };
  54
  55 // Verify that construction works as intended.
  56 TEST_F(AudioBlockFifoTest, Construct) {
  57   const int channels = 6;
  58   const int frames = 128;
  59   const int blocks = 4;
  60   AudioBlockFifo fifo(channels, frames, blocks);
  61   EXPECT_EQ(0, fifo.available_blocks());
  62   EXPECT_EQ(frames * blocks, fifo.GetUnfilledFrames());
  63 }
  64
  65 // Pushes audio bus objects to/from a FIFO up to different degrees.
  66 TEST_F(AudioBlockFifoTest, Push) {
  67   const int channels = 2;
  68   const int frames = 128;
  69   const int blocks = 2;
  70   AudioBlockFifo fifo(channels, frames, blocks);
  71
  72   // Push frames / 2 of data until FIFO is full.
  73   PushAndVerify(&fifo, frames / 2, channels, frames, frames * blocks);
  74   fifo.Clear();
  75
  76   // Push frames of data until FIFO is full.
  77   PushAndVerify(&fifo, frames, channels, frames, frames * blocks);
  78   fifo.Clear();
  79
  80   // Push 1.5 * frames of data.
  81   PushAndVerify(&fifo, frames * 1.5, channels, frames, frames * blocks);
  82   fifo.Clear();
  83 }
  84
  85 // Perform a sequence of Push/Consume calls to different degrees, and verify
  86 // things are correct.
  87 TEST_F(AudioBlockFifoTest, PushAndConsume) {
  88   const int channels = 2;
  89   const int frames = 441;
  90   const int blocks = 4;
  91   AudioBlockFifo fifo(channels, frames, blocks);
  92   PushAndVerify(&fifo, frames, channels, frames, frames * blocks);
  93   EXPECT_TRUE(fifo.GetUnfilledFrames() == 0);
  94   EXPECT_TRUE(fifo.available_blocks() == blocks);
  95
  96   // Consume 1 block of data.
  97   const AudioBus* bus = fifo.Consume();
  98   EXPECT_TRUE(channels == bus->channels());
  99   EXPECT_TRUE(frames == bus->frames());
 100   EXPECT_TRUE(fifo.available_blocks() == (blocks - 1));
 101   EXPECT_TRUE(fifo.GetUnfilledFrames() == frames);
 102
 103   // Fill it up again.
 104   PushAndVerify(&fifo, frames, channels, frames, frames * blocks);
 105   EXPECT_TRUE(fifo.GetUnfilledFrames() == 0);
 106   EXPECT_TRUE(fifo.available_blocks() == blocks);
 107
 108   // Consume all blocks of data.
 109   for (int i = 1; i <= blocks; ++i) {
 110     const AudioBus* bus = fifo.Consume();
 111     EXPECT_TRUE(channels == bus->channels());
 112     EXPECT_TRUE(frames == bus->frames());
 113     EXPECT_TRUE(fifo.GetUnfilledFrames() == frames * i);
 114     EXPECT_TRUE(fifo.available_blocks() == (blocks - i));
 115   }
 116   EXPECT_TRUE(fifo.GetUnfilledFrames() == frames * blocks);
 117   EXPECT_TRUE(fifo.available_blocks() == 0);
 118
 119   fifo.Clear();
 120   int new_push_frames = 128;
 121   // Change the input frame and try to fill up the FIFO.
 122   PushAndVerify(&fifo, new_push_frames, channels, frames,
 123                 frames * blocks);
 124   EXPECT_TRUE(fifo.GetUnfilledFrames() != 0);
 125   EXPECT_TRUE(fifo.available_blocks() == blocks -1);
 126
 127   // Consume all the existing filled blocks of data.
 128   while (fifo.available_blocks()) {
 129     const AudioBus* bus = fifo.Consume();
 130     EXPECT_TRUE(channels == bus->channels());
 131     EXPECT_TRUE(frames == bus->frames());
 132   }
 133
 134   // Since one block of FIFO has not been completely filled up, there should
 135   // be remaining frames.
 136   const int number_of_push =
 137       static_cast<int>(frames * blocks / new_push_frames);
 138   const int remain_frames = frames * blocks - fifo.GetUnfilledFrames();
 139   EXPECT_EQ(number_of_push * new_push_frames - frames * (blocks - 1),
 140             remain_frames);
 141
 142   // Completely fill up the buffer again.
 143   new_push_frames = frames * blocks - remain_frames;
 144   PushAndVerify(&fifo, new_push_frames, channels, frames,
 145                 frames * blocks);
 146   EXPECT_TRUE(fifo.GetUnfilledFrames() == 0);
 147   EXPECT_TRUE(fifo.available_blocks() == blocks);
 148 }
 149
 150 // Perform a sequence of Push/Consume calls to a 1 block FIFO.
 151 TEST_F(AudioBlockFifoTest, PushAndConsumeOneBlockFifo) {
 152   static const int channels = 2;
 153   static const int frames = 441;
 154   static const int blocks = 1;
 155   AudioBlockFifo fifo(channels, frames, blocks);
 156   PushAndVerify(&fifo, frames, channels, frames, frames * blocks);
 157   EXPECT_TRUE(fifo.GetUnfilledFrames() == 0);
 158   EXPECT_TRUE(fifo.available_blocks() == blocks);
 159
 160   // Consume 1 block of data.
 161   const AudioBus* bus = fifo.Consume();
 162   EXPECT_TRUE(channels == bus->channels());
 163   EXPECT_TRUE(frames == bus->frames());
 164   EXPECT_TRUE(fifo.available_blocks() == 0);
 165   EXPECT_TRUE(fifo.GetUnfilledFrames() == frames);
 166 }
 167
 168 // Dynamically increase the capacity of FIFO and verify buffers are correct.
 169 TEST_F(AudioBlockFifoTest, DynamicallyIncreaseCapacity) {
 170   // Create a FIFO with default blocks of buffers.
 171   const int channels = 2;
 172   const int frames = 441;
 173   const int default_blocks = 2;
 174   AudioBlockFifo fifo(channels, frames, default_blocks);
 175   Push(&fifo, frames, channels);
 176   int expected_unfilled_frames = frames;
 177   int expected_available_blocks = 1;
 178   EXPECT_EQ(expected_unfilled_frames, fifo.GetUnfilledFrames());
 179   EXPECT_EQ(expected_available_blocks, fifo.available_blocks());
 180
 181   // Increase the capacity dynamically for the first time.
 182   const int new_blocks_1 = 3;
 183   fifo.IncreaseCapacity(new_blocks_1);
 184   expected_unfilled_frames += new_blocks_1 * frames;
 185   EXPECT_EQ(fifo.GetUnfilledFrames(), expected_unfilled_frames);
 186   EXPECT_EQ(fifo.available_blocks(), expected_available_blocks);
 187
 188   // Verify the previous buffer is not affected by the dynamic capacity
 189   // increment.
 190   expected_unfilled_frames += frames;
 191   expected_available_blocks -= 1;
 192   ConsumeAndVerify(&fifo, expected_unfilled_frames, expected_available_blocks);
 193
 194   // Fill another |new_blocks_1 + 0.5| blocks of data to the FIFO.
 195   const int frames_to_push = static_cast<int>((new_blocks_1 + 0.5) * frames);
 196   int max_frames = frames * (default_blocks + new_blocks_1);
 197   Push(&fifo, frames_to_push, channels);
 198   expected_unfilled_frames = max_frames - frames_to_push;
 199   expected_available_blocks = new_blocks_1;
 200   EXPECT_EQ(fifo.GetUnfilledFrames(), expected_unfilled_frames);
 201   EXPECT_EQ(fifo.available_blocks(), expected_available_blocks);
 202
 203   // Increase the capacity dynamically for the second time.
 204   const int new_blocks_2 = 2;
 205   fifo.IncreaseCapacity(new_blocks_2);
 206   max_frames += new_blocks_2 * frames;
 207   expected_unfilled_frames += new_blocks_2 * frames;
 208   EXPECT_EQ(fifo.GetUnfilledFrames(), expected_unfilled_frames);
 209   EXPECT_EQ(fifo.available_blocks(), expected_available_blocks);
 210
 211   // Verify the previous buffers are not affected by the dynamic capacity
 212   // increment.
 213   while (fifo.available_blocks()) {
 214     expected_unfilled_frames += frames;
 215     expected_available_blocks -= 1;
 216     ConsumeAndVerify(&fifo, expected_unfilled_frames,
 217                      expected_available_blocks);
 218   }
 219
 220   // Fill up one block of buffer and consume it, FIFO should then be empty.
 221   const int available_frames = max_frames - expected_unfilled_frames;
 222   Push(&fifo, frames - available_frames, channels);
 223   ConsumeAndVerify(&fifo, max_frames, 0);
 224 }
 225
 226 }  // namespace media