Upgrade AudioRendererAlgorithm to use WSOLA,

media/filters/wsola_internals.h

Index: media/filters/wsola_internals.h
diff --git a/media/filters/wsola_internals.h b/media/filters/wsola_internals.h
new file mode 100644
index 0000000000000000000000000000000000000000..4def78314c303b97047081a58295a57acfaa46e3
--- /dev/null
+++ b/media/filters/wsola_internals.h
@@ -0,0 +1,88 @@
+// 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.
+
+// A set of utility functions to perform WSOLA.
+
+#ifndef MEDIA_FILTERS_WSOLA_INTERNALS_H_
+#define MEDIA_FILTERS_WSOLA_INTERNALS_H_
+
+#include <utility>
+
+namespace media {
+
+class AudioBus;
+
+namespace internal {
+
+typedef std::pair<int, int> Interval;
+
+// Dot-product of channels of two AudioBus. For each AudioBus an offset is
+// given. |dot_product[k]| is the dot-product of channel |k|. The caller should
+// allocate sufficient space for |dot_product|.
+void MultiChannelDotProduct(const AudioBus* a,
+                            int frame_offset_a,
+                            const AudioBus* b,
+                            int frame_offset_b,
+                            int num_frames,
+                            float* dot_product);
+
+// Energies of sliding windows of channels are interleaved.
+// The number windows is |input->frames()| - (|frames_per_window| - 1), hence,
+// the method assumes |energy| must be, at least, of size
+// (|input->frames()| - (|frames_per_window| - 1)) * |input->channels()|.
+void MultiChannelMovingWindowEnergies(const AudioBus* input,
+                                      int frames_per_window,
+                                      float* energy);
+
+// Fit the curve f(x) = a * x^2 + b * x + c such that
+//
+// f(-1) = |y[0]|
+// f(0) = |y[1]|
+// f(1) = |y[2]|.
+//
+// Then compute the |extremum| point -b / (2*a) and |extremum_value|
+// b^2 / (4*a) - b^2 / (2*a) + c.
+void CubicInterpolation(const float* y_values,
+                        float* extremum,
+                        float* extremum_value);
+
+// Search a subset of all candid blocks. The search is performed every
+// |decimation| frames. This reduces complexity by a factor of about
+// 1 / |decimation|. A cubic interpolation is used to have a better estimate of
+// the best match.
+int DecimatedSearch(int decimation,
+                    Interval exclude_interval,
+                    const AudioBus* target_block,
+                    const AudioBus* search_segment,
+                    const float* energy_target_block,
+                    const float* energy_candid_blocks);
+
+// Search [|lim_low|, |lim_high|] of |search_segment| to find a block that is
+// most similar to |target_interval|. |energy_target_block| is the energy of the

[marpan, 2013/08/02 17:56:54]

Most similar to |target_block|?

[turaj, 2013/08/02 23:45:59]

Done.

+// target block. |energy_candid_blocks| is the energy of all blocks within
+// |search_segment|.
+int PartialSearch(int lim_low,

[marpan, 2013/08/02 17:56:54]

Maybe rename to RefinedSearch, but PartialSearch is fine too.
(Refined in the sense that it follows the coarse/decimated search)

[turaj, 2013/08/02 23:45:59]

how about "FullSearch".

On 2013/08/02 17:56:54, marpan wrote:

[marpan, 2013/08/06 17:14:10]

FullSearch is fine.

+                  int lim_high,
+                  Interval exclude_interval,
+                  const AudioBus* target_block,
+                  const AudioBus* search_segment,
+                  const float* energy_target_block,
+                  const float* energy_candid_blocks);
+
+// Find the index of the block, within |search_segment|, that is most similar
+// to |target_block|. Obviously, the returned index is w.r.t. |search_segment|.
+// |exclude_interval| is an interval that is excluded from the search.
+int OptimalIndex(const AudioBus* search_segment,
+                 const AudioBus* target_block,
+                 Interval exclude_interval);
+
+// Return a "periodic" Hann window. This is the first L samples of an L+1
+// Hann window. It is perfect reconstruction for overlap-and-add.
+void GetSymmetricHanningWindow(int window_length, float* window);
+
+}  // namespace internal
+
+}  // namespace media
+
+#endif  // MEDIA_FILTERS_WSOLA_INTERNALS_H_