media/base/audio_fifo_unittest.cc

   1 // Copyright (c) 2012 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 // TODO(henrika): add test which included |start_frame| in Consume() call.
   6
   7 #include "media/base/audio_fifo.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9
  10 namespace media {
  11
  12 class AudioFifoTest : public testing::Test {
  13  public:
  14   AudioFifoTest() {}
  15   virtual ~AudioFifoTest() {}
  16
  17   void VerifyValue(const float data[], int size, float value) {
  18     for (int i = 0; i < size; ++i)
  19       ASSERT_FLOAT_EQ(value, data[i]) << "i=" << i;
  20   }
  21
  22  protected:
  23   DISALLOW_COPY_AND_ASSIGN(AudioFifoTest);
  24 };
  25
  26 // Verify that construction works as intended.
  27 TEST_F(AudioFifoTest, Construct) {
  28   static const int kChannels = 6;
  29   static const int kMaxFrameCount = 128;
  30   AudioFifo fifo(kChannels, kMaxFrameCount);
  31   EXPECT_EQ(fifo.frames(), 0);
  32 }
  33
  34 // Pushes audio bus objects to a FIFO and fill it up to different degrees.
  35 TEST_F(AudioFifoTest, Push) {
  36   static const int kChannels = 2;
  37   static const int kMaxFrameCount = 128;
  38   AudioFifo fifo(kChannels, kMaxFrameCount);
  39   {
  40     SCOPED_TRACE("Push 50%");
  41     scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, kMaxFrameCount / 2);
  42     EXPECT_EQ(fifo.frames(), 0);
  43     fifo.Push(bus.get());
  44     EXPECT_EQ(fifo.frames(), bus->frames());
  45     fifo.Clear();
  46   }
  47   {
  48     SCOPED_TRACE("Push 100%");
  49     scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, kMaxFrameCount);
  50     EXPECT_EQ(fifo.frames(), 0);
  51     fifo.Push(bus.get());
  52     EXPECT_EQ(fifo.frames(), bus->frames());
  53     fifo.Clear();
  54   }
  55 }
  56
  57 // Consumes audio bus objects from a FIFO and empty it to different degrees.
  58 TEST_F(AudioFifoTest, Consume) {
  59   static const int kChannels = 2;
  60   static const int kMaxFrameCount = 128;
  61   AudioFifo fifo(kChannels, kMaxFrameCount);
  62   {
  63     scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, kMaxFrameCount);
  64     fifo.Push(bus.get());
  65     EXPECT_EQ(fifo.frames(), kMaxFrameCount);
  66   }
  67   {
  68     SCOPED_TRACE("Consume 50%");
  69     scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, kMaxFrameCount / 2);
  70     fifo.Consume(bus.get(), 0, bus->frames());
  71     EXPECT_TRUE(fifo.frames() == bus->frames());
  72     fifo.Push(bus.get());
  73     EXPECT_EQ(fifo.frames(), kMaxFrameCount);
  74   }
  75   {
  76     SCOPED_TRACE("Consume 100%");
  77     scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, kMaxFrameCount);
  78     fifo.Consume(bus.get(), 0, bus->frames());
  79     EXPECT_EQ(fifo.frames(), 0);
  80     fifo.Push(bus.get());
  81     EXPECT_EQ(fifo.frames(), kMaxFrameCount);
  82   }
  83 }
  84
  85 // Verify that the frames() method of the FIFO works as intended while
  86 // appending and removing audio bus elements to/from the FIFO.
  87 TEST_F(AudioFifoTest, FramesInFifo) {
  88   static const int kChannels = 2;
  89   static const int kMaxFrameCount = 64;
  90   AudioFifo fifo(kChannels, kMaxFrameCount);
  91
  92   // Fill up the FIFO and verify that the size grows as it should while adding
  93   // one audio frame each time.
  94   scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, 1);
  95   int n = 0;
  96   while (fifo.frames() < kMaxFrameCount) {
  97     fifo.Push(bus.get());
  98     EXPECT_EQ(fifo.frames(), ++n);
  99   }
 100   EXPECT_EQ(fifo.frames(), kMaxFrameCount);
 101
 102   // Empty the FIFO and verify that the size decreases as it should.
 103   // Reduce the size of the FIFO by one frame each time.
 104   while (fifo.frames() > 0) {
 105     fifo.Consume(bus.get(), 0, bus->frames());
 106     EXPECT_EQ(fifo.frames(), --n);
 107   }
 108   EXPECT_EQ(fifo.frames(), 0);
 109
 110   // Verify that a steady-state size of #frames in the FIFO is maintained
 111   // during a sequence of Push/Consume calls which involves wrapping. We ensure
 112   // wrapping by selecting a buffer size which does divides the FIFO size
 113   // with a remainder of one.
 114   scoped_ptr<AudioBus> bus2 =
 115       AudioBus::Create(kChannels, (kMaxFrameCount / 4) - 1);
 116   const int frames_in_fifo = bus2->frames();
 117   fifo.Push(bus2.get());
 118   EXPECT_EQ(fifo.frames(), frames_in_fifo);
 119   for (int n = 0; n < kMaxFrameCount; ++n) {
 120     fifo.Push(bus2.get());
 121     fifo.Consume(bus2.get(), 0, frames_in_fifo);
 122     EXPECT_EQ(fifo.frames(), frames_in_fifo);
 123   }
 124 }
 125
 126 // Perform a sequence of Push/Consume calls and verify that the data written
 127 // to the FIFO is correctly retrieved, i.e., that the order is correct and the
 128 // values are correct.
 129 TEST_F(AudioFifoTest, VerifyDataValues) {
 130   static const int kChannels = 2;
 131   static const int kFrameCount = 2;
 132   static const int kFifoFrameCount = 5 * kFrameCount;
 133
 134   AudioFifo fifo(kChannels, kFifoFrameCount);
 135   scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, kFrameCount);
 136   EXPECT_EQ(fifo.frames(), 0);
 137   EXPECT_EQ(bus->frames(), kFrameCount);
 138
 139   // Start by filling up the FIFO with audio frames. The first audio frame
 140   // will contain all 1's, the second all 2's etc. All channels contain the
 141   // same value.
 142   int value = 1;
 143   while (fifo.frames() < kFifoFrameCount) {
 144     for (int j = 0; j < bus->channels(); ++j)
 145       std::fill(bus->channel(j), bus->channel(j) + bus->frames(), value);
 146     fifo.Push(bus.get());
 147     EXPECT_EQ(fifo.frames(), bus->frames() * value);
 148     ++value;
 149   }
 150
 151   // FIFO should be full now.
 152   EXPECT_EQ(fifo.frames(), kFifoFrameCount);
 153
 154   // Consume all audio frames in the FIFO and verify that the stored values
 155   // are correct. In this example, we shall read out: 1, 2, 3, 4, 5 in that
 156   // order. Note that we set |frames_to_consume| to half the size of the bus.
 157   // It means that we shall read out the same value two times in row.
 158   value = 1;
 159   int n = 1;
 160   const int frames_to_consume = bus->frames() / 2;
 161   while (fifo.frames() > 0) {
 162     fifo.Consume(bus.get(), 0, frames_to_consume);
 163     for (int j = 0; j < bus->channels(); ++j)
 164       VerifyValue(bus->channel(j), frames_to_consume, value);
 165     if (n++ % 2 == 0)
 166       ++value;  // counts 1, 1, 2, 2, 3, 3,...
 167   }
 168
 169   // FIFO should be empty now.
 170   EXPECT_EQ(fifo.frames(), 0);
 171
 172   // Push one audio bus to the FIFO and fill it with 1's.
 173   value = 1;
 174   for (int j = 0; j < bus->channels(); ++j)
 175     std::fill(bus->channel(j), bus->channel(j) + bus->frames(), value);
 176   fifo.Push(bus.get());
 177   EXPECT_EQ(fifo.frames(), bus->frames());
 178
 179   // Keep calling Consume/Push a few rounds and verify that we read out the
 180   // correct values. The number of elements shall be fixed (kFrameCount) during
 181   // this phase.
 182   for (int i = 0; i < 5 * kFifoFrameCount; i++) {
 183     fifo.Consume(bus.get(), 0, bus->frames());
 184     for (int j = 0; j < bus->channels(); ++j) {
 185       VerifyValue(bus->channel(j), bus->channels(), value);
 186       std::fill(bus->channel(j), bus->channel(j) + bus->frames(), value + 1);
 187     }
 188     fifo.Push(bus.get());
 189     EXPECT_EQ(fifo.frames(), bus->frames());
 190     ++value;
 191   }
 192 }
 193
 194 }  // namespace media