Introduce AudioBufferMemoryPool to avoid thrashing on audio buffers.

media/base/audio_buffer.h

 // Copyright 2013 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_BUFFER_H_
 #define MEDIA_BASE_AUDIO_BUFFER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <list>
 #include <memory>
+#include <utility>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/aligned_memory.h"
 #include "base/memory/ref_counted.h"
+#include "base/synchronization/lock.h"
 #include "base/time/time.h"
 #include "media/base/channel_layout.h"
 #include "media/base/media_export.h"
 #include "media/base/sample_format.h"
 
 namespace mojo {
 template <typename T, typename U>
 struct TypeConverter;
 template <typename T>
 class StructPtr;
 };
 
 namespace media {
 class AudioBus;
+class AudioBufferMemoryPool;
 
 namespace mojom {
 class AudioBuffer;
 }
 
 // An audio buffer that takes a copy of the data passed to it, holds it, and
 // copies it into an AudioBus when needed. Also supports an end of stream
 // marker.
 class MEDIA_EXPORT AudioBuffer
     : public base::RefCountedThreadSafe<AudioBuffer> {
  public:
   // Alignment of each channel's data; this must match what ffmpeg expects
   // (which may be 0, 16, or 32, depending on the processor). Selecting 32 in
   // order to work on all processors.
   enum { kChannelAlignment = 32 };
 
   // Create an AudioBuffer whose channel data is copied from |data|. For
   // interleaved data, only the first buffer is used. For planar data, the
   // number of buffers must be equal to |channel_count|. |frame_count| is the
   // number of frames in each buffer. |data| must not be null and |frame_count|
-  // must be >= 0.
-  static scoped_refptr<AudioBuffer> CopyFrom(SampleFormat sample_format,
-                                             ChannelLayout channel_layout,
-                                             int channel_count,
-                                             int sample_rate,
-                                             int frame_count,
-                                             const uint8_t* const* data,
-                                             const base::TimeDelta timestamp);
+  // must be >= 0. For optimal efficiency when many buffers are being created, a
+  // AudioBufferMemoryPool can be provided to avoid thrashing memory.
+  static scoped_refptr<AudioBuffer> CopyFrom(
+      SampleFormat sample_format,
+      ChannelLayout channel_layout,
+      int channel_count,
+      int sample_rate,
+      int frame_count,
+      const uint8_t* const* data,
+      const base::TimeDelta timestamp,
+      scoped_refptr<AudioBufferMemoryPool> pool = nullptr);
 
   // Create an AudioBuffer with |frame_count| frames. Buffer is allocated, but
-  // not initialized. Timestamp and duration are set to kNoTimestamp.
-  static scoped_refptr<AudioBuffer> CreateBuffer(SampleFormat sample_format,
-                                                 ChannelLayout channel_layout,
-                                                 int channel_count,
-                                                 int sample_rate,
-                                                 int frame_count);
+  // not initialized. Timestamp and duration are set to kNoTimestamp. For
+  // optimal efficiency when many buffers are being created, a
+  // AudioBufferMemoryPool can be provided to avoid thrashing memory.
+  static scoped_refptr<AudioBuffer> CreateBuffer(
+      SampleFormat sample_format,
+      ChannelLayout channel_layout,
+      int channel_count,
+      int sample_rate,
+      int frame_count,
+      scoped_refptr<AudioBufferMemoryPool> pool = nullptr);
 
   // Create an empty AudioBuffer with |frame_count| frames.
   static scoped_refptr<AudioBuffer> CreateEmptyBuffer(
       ChannelLayout channel_layout,
       int channel_count,
       int sample_rate,
       int frame_count,
       const base::TimeDelta timestamp);
 
   // Create a AudioBuffer indicating we've reached end of stream.
@@ skipping 73 matching lines @@
   // [data,data+data_size) to the allocated buffer(s). If |data| is null, no
   // data is copied. If |create_buffer| is false, no data buffer is created (or
   // copied to).
   AudioBuffer(SampleFormat sample_format,
               ChannelLayout channel_layout,
               int channel_count,
               int sample_rate,
               int frame_count,
               bool create_buffer,
               const uint8_t* const* data,
-              const base::TimeDelta timestamp);
+              const base::TimeDelta timestamp,
+              scoped_refptr<AudioBufferMemoryPool> pool);
 
   virtual ~AudioBuffer();
 
   const SampleFormat sample_format_;
   const ChannelLayout channel_layout_;
   const int channel_count_;
   int sample_rate_;
   int adjusted_frame_count_;
   const bool end_of_stream_;
   base::TimeDelta timestamp_;
   base::TimeDelta duration_;
 
   // Contiguous block of channel data.
   std::unique_ptr<uint8_t, base::AlignedFreeDeleter> data_;
   size_t data_size_;
 
   // For planar data, points to each channels data.
   std::vector<uint8_t*> channel_data_;
 
+  // Allows recycling of memory data to avoid repeated allocations.
+  scoped_refptr<AudioBufferMemoryPool> pool_;
+
   DISALLOW_IMPLICIT_CONSTRUCTORS(AudioBuffer);
 };
 
+// Basic memory pool for reusing AudioBuffer internal memory to avoid thrashing.

[xhwang, 2017/04/01 00:05:26]

Please add a comment that AudioBuffer created using this pool will hold a
ref-count to it.

[DaleCurtis, 2017/04/01 01:00:01]

Done.

+class MEDIA_EXPORT AudioBufferMemoryPool
+    : public base::RefCountedThreadSafe<AudioBufferMemoryPool> {
+ public:
+  AudioBufferMemoryPool();
+
+  size_t get_pool_size_for_testing() const { return entries_.size(); }
+
+ private:
+  friend class AudioBuffer;
+  friend class base::RefCountedThreadSafe<AudioBufferMemoryPool>;
+
+  ~AudioBufferMemoryPool();
+
+  using AudioMemory = std::unique_ptr<uint8_t, base::AlignedFreeDeleter>;
+  AudioMemory CreateBuffer(size_t size);
+  void ReturnBuffer(AudioMemory memory, size_t size);
+
+  base::Lock entry_lock_;
+  using MemoryEntry = std::pair<AudioMemory, size_t>;
+  std::list<MemoryEntry> entries_;
+
+  DISALLOW_COPY_AND_ASSIGN(AudioBufferMemoryPool);
+};
+
 }  // namespace media
 
 #endif  // MEDIA_BASE_AUDIO_BUFFER_H_