Add a block based Audio FIFO.

media/base/audio_block_fifo.h

Index: media/base/audio_block_fifo.h
diff --git a/media/base/audio_block_fifo.h b/media/base/audio_block_fifo.h
new file mode 100644
index 0000000000000000000000000000000000000000..08611ca98272fec0eca8b73f3a03486fad215693
--- /dev/null
+++ b/media/base/audio_block_fifo.h
@@ -0,0 +1,67 @@
+// Copyright 2014 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.
+
+#ifndef MEDIA_BASE_AUDIO_BLOCK_FIFO_H_
+#define MEDIA_BASE_AUDIO_BLOCK_FIFO_H_
+
+#include <queue>
+
+#include "base/memory/scoped_vector.h"
+#include "media/base/audio_bus.h"
+#include "media/base/media_export.h"
+
+namespace media {
+
+// First-in first-out container for AudioBus elements.
+// The FIFO is composed of blocks of AudioBus elements, it accepts interleaved
+// data as input and will deinterleave it into the FIFO, and it only allows
+// consuming a whole block of AudioBus element.
+// This class is thread-unsafe.
+class MEDIA_EXPORT AudioBlockFifo {
+ public:
+  // Creates a new AudioBlockFifo and allocates |blocks| memory, each block
+  // of memory can store |channels| of length |frames| data.
+  AudioBlockFifo(int channels, int frames, int blocks);
+  virtual ~AudioBlockFifo();
+
+  // Pushes interleaved audio data from |source| to the FIFO.
+  // The method will deinterleave the data into a audio bus.
+  // Push() will crash if the allocated space is insufficient.
+  void Push(const void* source, int frames, int bytes_per_sample);
+
+  // Consumes a block of audio from the FIFO.  Returns an AudioBus which
+  // contains the consumed audio data to avoid copying.
+  // Consume() will crash if the FIFO does not contain a block of data.
+  const AudioBus* Consume();
+
+  // Empties the FIFO without deallocating any memory.
+  void Clear();
+
+  // Number of block of memory ready to be consumed in the FIFO.
+  int filled_blocks() const;

[DaleCurtis, 2014/07/11 22:33:33]

Hacker_style requires the methods to be defined in the header.  How about
available_blocks() instead?

[no longer working on chromium, 2014/07/14 11:28:27]

Done. Just a though, since I change the empty_frames() to unfilled_frames(), do
this change your mind that filled_blocks() might be more clear?

[DaleCurtis, 2014/07/14 20:14:26]

I still like available better, but it's up to you. It can't be a hacker style
though as mentioned on the new patch set.

+
+  int empty_frames() const;

[DaleCurtis, 2014/07/11 22:33:33]

Ditto.  This also needs a comment since it's not really clear what it means
relative to the pre-allocated blocks.  I think you really just want this to mean
the number of unfilled frames in the current block.

[no longer working on chromium, 2014/07/14 11:28:27]

I want this to tell the number of unfilled frames in the whole FIFO. This is
useful for the clients to know how many more data they can write to the FIFO.

I added a comment and changed the name to unfilled_frames() since "empty" might
be a bit vague.

+
+ private:
+  // The actual FIFO is a vector of audio buses.
+  ScopedVector<AudioBus> audio_blocks_;
+
+  // Queues used to keep track which blocks of memory to be wirteen and
+  // consumed.
+  std::queue<AudioBus*> empty_blocks_;

[DaleCurtis, 2014/07/11 22:33:33]

Why do you need these?  Shouldn't you just need a head and tail index which you
increment % blocks?

In the beginning head == tail == 0.  On Push() which fills a bus completely,
head = (head + 1) % blocks;  On Consume(), tail = (tail + 1) % blocks.  If ever
head == tail, crash.

[no longer working on chromium, 2014/07/14 11:28:27]

Indexes might work but require more complicated logics.
For example, if blocks == 2, and user calls Push() to fill up all the blocks,
then head become 0, since there has been any Consume() yet, so tail will also be
0.

Take another conner case, blocks == 1, head and tail will be always 0, then we
need a way to know the the bus has been completely filled or not.


Using the queues is a bit simpler from readability perspective, I am still open
to switch to index but it might need more than head and tail, please let me know
how strongly you think.

[DaleCurtis, 2014/07/14 20:14:26]

Good point, you can just drop the head==tail checks in favor of tracking an
available_frames_ value which you add and remove from during push / consume. 
You can then make the unfilled_frames() method a hacker_style() method.  I think
it's easier to reason about indices moving around in a vector than it is to
reason about which block is where in the queues.  It's hard for me to follow the
push/pop maze and I prefer using as few data structures as possible.  I won't
block this CL though if you prefer using the multi-queue approach tough.

[no longer working on chromium, 2014/07/15 21:51:42]

:) Both work for me. But since you prefer indices, I just switch it over to
indices
As you might have already noticed from the new version, I need to use an extra
member variable to keep track how many blocks of data can be consumed, since we
don't want to provide zero to the clients when there is not enough data in the
FIFO, hope it is fine.

+  std::queue<AudioBus*> filled_blocks_;
+
+  // Maximum number of frames of data one block of memory can contain.
+  // This value is set by |frames| in the constructor.
+  const int block_frames_;
+
+  // Current write position in the current written block.
+  int write_pos_;
+
+  DISALLOW_COPY_AND_ASSIGN(AudioBlockFifo);
+};
+
+}  // namespace media
+
+#endif  // MEDIA_BASE_AUDIO_BLOCK_FIFO_H_