Introduce PushPullFIFO class and remove other FIFOs

third_party/WebKit/Source/platform/audio/PushPullFIFOTest.cpp

+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "platform/audio/PushPullFIFO.h"
+
+#include "platform/testing/TestingPlatformSupport.h"
+#include "testing/gtest/include/gtest/gtest-death-test.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "wtf/PtrUtil.h"
+#include <memory>
+
+namespace blink {
+
+namespace {
+
+const unsigned kNumberOfChannel = 2;
+const size_t kFIFOSize = 8192;
+const size_t kCallbackBufferSize = 1024;

[Raymond Toy, 2017/01/12 19:29:40]

If you have to pick values for this, why not use "funny" values?  Say 3
channels, fifo size that isn't a power of two, callback size like 3072 (or some
other random Android value that we've seen.)

[o1ka, 2017/01/13 11:23:44]

I believe we need to have parametrized tests (TEST_P) and test different
combinations of values.

[hongchan, 2017/01/13 23:29:23]

Please bear with me - this is my first attempt to write a blink unit test.
WebAudio has been focused on the layout test, not the c++ unit test.

I will try the TEST_P.

[hongchan, 2017/01/13 23:29:23]

Done.

+const size_t kRenderQuantum = 128;

[o1ka, 2017/01/13 11:23:44]

The values are multipliers of each other, so many corner cases are not covered.

+
+// Fills AudioBus with a value.
+void fillBusWithValue(AudioBus* targetBus, float value) {
+  for (unsigned c = 0; c < targetBus->numberOfChannels(); ++c) {
+    float* busChannel = targetBus->channel(c)->mutableData();
+    std::fill(busChannel, busChannel + targetBus->channel(c)->length(), value);
+  }
+}
+
+// Check if AudioBus is filled with a specific value within the given range.

[o1ka, 2017/01/13 11:23:44]

To make sure the indexes are always consistent and we read/write at the right
places, we may want to fill with increments instead of uniform values.

[hongchan, 2017/01/13 23:29:23]

Done.

+bool isBusConstantValueOf(AudioBus* targetBus,
+                          float value,
+                          unsigned startFrame,
+                          unsigned endFrame) {
+  for (unsigned c = 0; c < targetBus->numberOfChannels(); ++c) {
+    const float* busChannel = targetBus->channel(c)->data();
+    for (unsigned i = startFrame; i < endFrame; ++i) {
+      if (busChannel[i] != value)
+        return false;
+    }
+  }
+  return true;
+}
+
+}  // namespace
+
+TEST(PushPullFIFOTest, Construction) {
+  std::unique_ptr<PushPullFIFO> fifo =
+      WTF::wrapUnique(new PushPullFIFO(kNumberOfChannel, kFIFOSize));
+
+  EXPECT_EQ(static_cast<int>(kFIFOSize), fifo->length());
+  EXPECT_EQ(0, fifo->framesAvailable());
+  EXPECT_EQ(kNumberOfChannel, fifo->numberOfChannels());
+}
+
+TEST(PushPullFIFOTest, BasicOperation) {
+  // Create a FIFO of 2X render quantum. (256 frames)
+  std::unique_ptr<PushPullFIFO> fifo =
+      WTF::wrapUnique(new PushPullFIFO(kNumberOfChannel, 2 * kRenderQuantum));
+
+  RefPtr<AudioBus> inputBus =
+      AudioBus::create(kNumberOfChannel, kRenderQuantum);
+  RefPtr<AudioBus> outputBus =
+      AudioBus::create(kNumberOfChannel, 2 * kRenderQuantum);
+
+  // Create an input vector (128 frames) of '1'.
+  fillBusWithValue(inputBus.get(), 1);
+  EXPECT_TRUE(isBusConstantValueOf(inputBus.get(), 1, 0, kRenderQuantum));
+
+  // Push and pull by 128 frames.
+  fifo->push(inputBus.get());
+  fifo->pull(outputBus.get(), kRenderQuantum);
+
+  // Thus no frames available in FIFO.
+  EXPECT_EQ(fifo->framesAvailable(), 0);
+
+  // The half of output bus should be the exact copy of input bus. The rest
+  // should be 0.
+  EXPECT_TRUE(isBusConstantValueOf(outputBus.get(), 1, 0, kRenderQuantum));
+  EXPECT_TRUE(isBusConstantValueOf(outputBus.get(), 0, kRenderQuantum,
+                                   2 * kRenderQuantum));
+}
+
+TEST(PushPullFIFOTest, WrapAround) {
+  std::unique_ptr<PushPullFIFO> fifo =
+      WTF::wrapUnique(new PushPullFIFO(kNumberOfChannel, kCallbackBufferSize));
+
+  RefPtr<AudioBus> inputBus =
+      AudioBus::create(kNumberOfChannel, kRenderQuantum);
+  RefPtr<AudioBus> outputBus =
+      AudioBus::create(kNumberOfChannel, kCallbackBufferSize);
+
+  unsigned numberOfblocks = kCallbackBufferSize / kRenderQuantum;
+
+  // The first round fills the FIFO with 1.
+  fillBusWithValue(inputBus.get(), 1);
+  for (unsigned i = 0; i < numberOfblocks; ++i)
+    fifo->push(inputBus.get());
+
+  // Then pull the half of FIFO.
+  for (unsigned i = 0; i < 0.5 * numberOfblocks; ++i)
+    fifo->pull(outputBus.get(), kRenderQuantum);
+
+  // Fill the emptied half with 2. After this point the FIFO content should
+  // be { 2, 2, 2, 2, 1, 1, 1, 1 } by each 128 frame block. Note that the read
+  // index is in the middle.
+  fillBusWithValue(inputBus.get(), 2);
+  for (unsigned i = 0; i < 0.5 * numberOfblocks; ++i)
+    fifo->push(inputBus.get());
+
+  // If FIFO is pulled 8 times (numberOfBlocks), it must produce the following
+  // block sequence because of warp-around.
+  float expectedValueInBlocks[] = {1, 1, 1, 1, 2, 2, 2, 2};
+
+  for (unsigned i = 0; i < numberOfblocks; ++i) {
+    fifo->pull(outputBus.get(), kRenderQuantum);
+    EXPECT_TRUE(isBusConstantValueOf(outputBus.get(), expectedValueInBlocks[i],
+                                     0, kRenderQuantum));
+  }
+}
+
+TEST(PushPullFIFOTest, Overflow) {
+  std::unique_ptr<PushPullFIFO> fifo =
+      WTF::wrapUnique(new PushPullFIFO(kNumberOfChannel, kCallbackBufferSize));
+  RefPtr<AudioBus> inputBus =
+      AudioBus::create(kNumberOfChannel, kRenderQuantum);
+
+  unsigned numberOfblocks = kCallbackBufferSize / kRenderQuantum;
+
+  // Push data up to the full capacity of FIFO.
+  fillBusWithValue(inputBus.get(), 1);
+  for (unsigned i = 0; i < numberOfblocks; ++i)
+    fifo->push(inputBus.get());
+
+  // Pushing one more time without pulling causes DCHECK failure.
+  EXPECT_DEBUG_DEATH(fifo->push(inputBus.get()), "fifoOverflow");

[o1ka, 2017/01/13 11:23:44]

But this should not be the case in real life, right? We should eb able to
continue execution. So should it be in the code/tests as well.

[hongchan, 2017/01/13 23:29:23]

Without DCHECK, how can the test runner detect such case?

+}
+
+TEST(PushPullFIFOTest, Underflow) {
+  std::unique_ptr<PushPullFIFO> fifo =
+      WTF::wrapUnique(new PushPullFIFO(kNumberOfChannel, kCallbackBufferSize));
+  RefPtr<AudioBus> inputBus =
+      AudioBus::create(kNumberOfChannel, kRenderQuantum);
+  RefPtr<AudioBus> outputBus =
+      AudioBus::create(kNumberOfChannel, kRenderQuantum);
+
+  unsigned numberOfblocks = kCallbackBufferSize / kRenderQuantum;
+
+  fillBusWithValue(inputBus.get(), 1);
+  for (unsigned i = 0; i < numberOfblocks; ++i)
+    fifo->push(inputBus.get());
+
+  // Then pull the entire FIFO content. The FIFO will be empty.
+  for (unsigned i = 0; i < numberOfblocks; ++i)
+    fifo->pull(outputBus.get(), kRenderQuantum);
+
+  // Pulling an empty FIFO results the silence.
+  fifo->pull(outputBus.get(), kRenderQuantum);
+  EXPECT_TRUE(isBusConstantValueOf(outputBus.get(), 0, 0, kRenderQuantum));
+}
+
+}  // namespace blink