media/base/sinc_resampler.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef MEDIA_BASE_SINC_RESAMPLER_H_
   6 #define MEDIA_BASE_SINC_RESAMPLER_H_
   7
   8 #include "base/atomic_ref_count.h"
   9 #include "base/callback.h"
  10 #include "base/gtest_prod_util.h"
  11 #include "base/memory/aligned_memory.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "build/build_config.h"
  14 #include "media/base/media_export.h"
  15
  16 namespace media {
  17
  18 // SincResampler is a high-quality single-channel sample-rate converter.
  19 class MEDIA_EXPORT SincResampler {
  20  public:
  21   enum {
  22     // The kernel size can be adjusted for quality (higher is better) at the
  23     // expense of performance.  Must be a multiple of 32.
  24     // TODO(dalecurtis): Test performance to see if we can jack this up to 64+.
  25     kKernelSize = 32,
  26
  27     // Default request size.  Affects how often and for how much SincResampler
  28     // calls back for input.  Must be greater than kKernelSize.
  29     kDefaultRequestSize = 512,
  30
  31     // The kernel offset count is used for interpolation and is the number of
  32     // sub-sample kernel shifts.  Can be adjusted for quality (higher is better)
  33     // at the expense of allocating more memory.
  34     kKernelOffsetCount = 32,
  35     kKernelStorageSize = kKernelSize * (kKernelOffsetCount + 1),
  36   };
  37
  38   // Selects runtime specific CPU features like SSE.  Must be called before
  39   // using SincResampler.
  40   static void InitializeCPUSpecificFeatures();
  41
  42   // Callback type for providing more data into the resampler.  Expects |frames|
  43   // of data to be rendered into |destination|; zero padded if not enough frames
  44   // are available to satisfy the request.
  45   typedef base::Callback<void(int frames, float* destination)> ReadCB;
  46
  47   // Constructs a SincResampler with the specified |read_cb|, which is used to
  48   // acquire audio data for resampling.  |io_sample_rate_ratio| is the ratio
  49   // of input / output sample rates.  |request_frames| controls the size in
  50   // frames of the buffer requested by each |read_cb| call.  The value must be
  51   // greater than kKernelSize.  Specify kDefaultRequestSize if there are no
  52   // request size constraints.
  53   SincResampler(double io_sample_rate_ratio,
  54                 int request_frames,
  55                 const ReadCB& read_cb);
  56   virtual ~SincResampler();
  57
  58   // Resample |frames| of data from |read_cb_| into |destination|.
  59   void Resample(int frames, float* destination);
  60
  61   // The maximum size in frames that guarantees Resample() will only make a
  62   // single call to |read_cb_| for more data.
  63   int ChunkSize() const;
  64
  65   // Flush all buffered data and reset internal indices.  Not thread safe, do
  66   // not call while Resample() is in progress.
  67   void Flush();
  68
  69   // Update |io_sample_rate_ratio_|.  SetRatio() will cause a reconstruction of
  70   // the kernels used for resampling.  Not thread safe, do not call while
  71   // Resample() is in progress.
  72   void SetRatio(double io_sample_rate_ratio);
  73
  74   float* get_kernel_for_testing() { return kernel_storage_.get(); }
  75
  76  private:
  77   FRIEND_TEST_ALL_PREFIXES(SincResamplerTest, Convolve);
  78   FRIEND_TEST_ALL_PREFIXES(SincResamplerTest, ConvolveBenchmark);
  79
  80   void InitializeKernel();
  81   void UpdateRegions(bool second_load);
  82
  83   // Compute convolution of |k1| and |k2| over |input_ptr|, resultant sums are
  84   // linearly interpolated using |kernel_interpolation_factor|.  On x86, the
  85   // underlying implementation is chosen at run time based on SSE support.  On
  86   // ARM, NEON support is chosen at compile time based on compilation flags.
  87   static float Convolve_C(const float* input_ptr, const float* k1,
  88                           const float* k2, double kernel_interpolation_factor);
  89 #if defined(ARCH_CPU_X86_FAMILY)
  90   static float Convolve_SSE(const float* input_ptr, const float* k1,
  91                             const float* k2,
  92                             double kernel_interpolation_factor);
  93 #elif defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)
  94   static float Convolve_NEON(const float* input_ptr, const float* k1,
  95                              const float* k2,
  96                              double kernel_interpolation_factor);
  97 #endif
  98
  99   // The ratio of input / output sample rates.
 100   double io_sample_rate_ratio_;
 101
 102   // An index on the source input buffer with sub-sample precision.  It must be
 103   // double precision to avoid drift.
 104   double virtual_source_idx_;
 105
 106   // The buffer is primed once at the very beginning of processing.
 107   bool buffer_primed_;
 108
 109   // Source of data for resampling.
 110   const ReadCB read_cb_;
 111
 112   // The size (in samples) to request from each |read_cb_| execution.
 113   const int request_frames_;
 114
 115   // The number of source frames processed per pass.
 116   int block_size_;
 117
 118   // The size (in samples) of the internal buffer used by the resampler.
 119   const int input_buffer_size_;
 120
 121   // Contains kKernelOffsetCount kernels back-to-back, each of size kKernelSize.
 122   // The kernel offsets are sub-sample shifts of a windowed sinc shifted from
 123   // 0.0 to 1.0 sample.
 124   scoped_ptr<float[], base::ScopedPtrAlignedFree> kernel_storage_;
 125   scoped_ptr<float[], base::ScopedPtrAlignedFree> kernel_pre_sinc_storage_;
 126   scoped_ptr<float[], base::ScopedPtrAlignedFree> kernel_window_storage_;
 127
 128   // Data from the source is copied into this buffer for each processing pass.
 129   scoped_ptr<float[], base::ScopedPtrAlignedFree> input_buffer_;
 130
 131   // Pointers to the various regions inside |input_buffer_|.  See the diagram at
 132   // the top of the .cc file for more information.
 133   float* r0_;
 134   float* const r1_;
 135   float* const r2_;
 136   float* r3_;
 137   float* r4_;
 138
 139   // Atomic ref count indicating when when we're in the middle of resampling.
 140   // Will be CHECK'd to find crashes...
 141   // TODO(dalecurtis): Remove debug helpers for http://crbug.com/295278
 142   base::AtomicRefCount currently_resampling_;
 143
 144   DISALLOW_COPY_AND_ASSIGN(SincResampler);
 145 };
 146
 147 }  // namespace media
 148
 149 #endif  // MEDIA_BASE_SINC_RESAMPLER_H_