diff -r 000000000000 -r 6474c204b198 content/media/AudioCompactor.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/content/media/AudioCompactor.h	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,121 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#if !defined(AudioCompactor_h)
+#define AudioCompactor_h
+
+#include "MediaQueue.h"
+#include "MediaData.h"
+#include "VideoUtils.h"
+
+namespace mozilla {
+
+class AudioCompactor
+{
+public:
+  AudioCompactor(MediaQueue<AudioData>& aQueue)
+    : mQueue(aQueue)
+  { }
+
+  // Push audio data into the underlying queue with minimal heap allocation
+  // slop.  This method is responsible for allocating AudioDataValue[] buffers.
+  // The caller must provide a functor to copy the data into the buffers.  The
+  // functor must provide the following signature:
+  //
+  //   uint32_t operator()(AudioDataValue *aBuffer, uint32_t aSamples);
+  //
+  // The functor must copy as many complete frames as possible to the provided
+  // buffer given its length (in AudioDataValue elements).  The number of frames
+  // copied must be returned.  This copy functor must support being called
+  // multiple times in order to copy the audio data fully.  The copy functor
+  // must copy full frames as partial frames will be ignored.
+  template<typename CopyFunc>
+  bool Push(int64_t aOffset, int64_t aTime, int32_t aSampleRate,
+            uint32_t aFrames, uint32_t aChannels, CopyFunc aCopyFunc)
+  {
+    // If we are losing more than a reasonable amount to padding, try to chunk
+    // the data.
+    size_t maxSlop = AudioDataSize(aFrames, aChannels) / MAX_SLOP_DIVISOR;
+
+    while (aFrames > 0) {
+      uint32_t samples = GetChunkSamples(aFrames, aChannels, maxSlop);
+      nsAutoArrayPtr<AudioDataValue> buffer(new AudioDataValue[samples]);
+
+      // Copy audio data to buffer using caller-provided functor.
+      uint32_t framesCopied = aCopyFunc(buffer, samples);
+
+      NS_ASSERTION(framesCopied <= aFrames, "functor copied too many frames");
+
+      CheckedInt64 duration = FramesToUsecs(framesCopied, aSampleRate);
+      if (!duration.isValid()) {
+        return false;
+      }
+
+      mQueue.Push(new AudioData(aOffset,
+                                aTime,
+                                duration.value(),
+                                framesCopied,
+                                buffer.forget(),
+                                aChannels));
+
+      // Remove the frames we just pushed into the queue and loop if there is
+      // more to be done.
+      aTime += duration.value();
+      aFrames -= framesCopied;
+
+      // NOTE: No need to update aOffset as its only an approximation anyway.
+    }
+
+    return true;
+  }
+
+  // Copy functor suitable for copying audio samples already in the
+  // AudioDataValue format/layout expected by AudioStream on this platform.
+  class NativeCopy
+  {
+  public:
+    NativeCopy(const uint8_t* aSource, size_t aSourceBytes,
+               uint32_t aChannels)
+      : mSource(aSource)
+      , mSourceBytes(aSourceBytes)
+      , mChannels(aChannels)
+      , mNextByte(0)
+    { }
+
+    uint32_t operator()(AudioDataValue *aBuffer, uint32_t aSamples);
+
+  private:
+    const uint8_t* const mSource;
+    const size_t mSourceBytes;
+    const uint32_t mChannels;
+    size_t mNextByte;
+  };
+
+  // Allow 12.5% slop before chunking kicks in.  Public so that the gtest can
+  // access it.
+  static const size_t MAX_SLOP_DIVISOR = 8;
+
+private:
+  // Compute the number of AudioDataValue samples that will be fit the most
+  // frames while keeping heap allocation slop less than the given threshold.
+  static uint32_t
+  GetChunkSamples(uint32_t aFrames, uint32_t aChannels, size_t aMaxSlop);
+
+  static size_t BytesPerFrame(uint32_t aChannels)
+  {
+    return sizeof(AudioDataValue) * aChannels;
+  }
+
+  static size_t AudioDataSize(uint32_t aFrames, uint32_t aChannels)
+  {
+    return aFrames * BytesPerFrame(aChannels);
+  }
+
+  MediaQueue<AudioData> &mQueue;
+};
+
+} // namespace mozilla
+
+#endif // AudioCompactor_h