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 // Initial input buffer layout, dividing into regions r0_ to r4_ (note: r0_, r3_ 6 // and r4_ will move after the first load): 7 // 8 // |----------------|-----------------------------------------|----------------| 9 // 10 // request_frames_ 11 // <---------------------------------------------------------> 12 // r0_ (during first load) 13 // 14 // kKernelSize / 2 kKernelSize / 2 kKernelSize / 2 kKernelSize / 2 15 // <---------------> <---------------> <---------------> <---------------> 16 // r1_ r2_ r3_ r4_ 17 // 18 // block_size_ == r4_ - r2_ 19 // <---------------------------------------> 20 // 21 // request_frames_ 22 // <------------------ ... -----------------> 23 // r0_ (during second load) 24 // 25 // On the second request r0_ slides to the right by kKernelSize / 2 and r3_, r4_ 26 // and block_size_ are reinitialized via step (3) in the algorithm below. 27 // 28 // These new regions remain constant until a Flush() occurs. While complicated, 29 // this allows us to reduce jitter by always requesting the same amount from the 30 // provided callback. 31 // 32 // The algorithm: 33 // 34 // 1) Allocate input_buffer of size: request_frames_ + kKernelSize; this ensures 35 // there's enough room to read request_frames_ from the callback into region 36 // r0_ (which will move between the first and subsequent passes). 37 // 38 // 2) Let r1_, r2_ each represent half the kernel centered around r0_: 39 // 40 // r0_ = input_buffer_ + kKernelSize / 2 41 // r1_ = input_buffer_ 42 // r2_ = r0_ 43 // 44 // r0_ is always request_frames_ in size. r1_, r2_ are kKernelSize / 2 in 45 // size. r1_ must be zero initialized to avoid convolution with garbage (see 46 // step (5) for why). 47 // 48 // 3) Let r3_, r4_ each represent half the kernel right aligned with the end of 49 // r0_ and choose block_size_ as the distance in frames between r4_ and r2_: 50 // 51 // r3_ = r0_ + request_frames_ - kKernelSize 52 // r4_ = r0_ + request_frames_ - kKernelSize / 2 53 // block_size_ = r4_ - r2_ = request_frames_ - kKernelSize / 2 54 // 55 // 4) Consume request_frames_ frames into r0_. 56 // 57 // 5) Position kernel centered at start of r2_ and generate output frames until 58 // the kernel is centered at the start of r4_ or we've finished generating 59 // all the output frames. 60 // 61 // 6) Wrap left over data from the r3_ to r1_ and r4_ to r2_. 62 // 63 // 7) If we're on the second load, in order to avoid overwriting the frames we 64 // just wrapped from r4_ we need to slide r0_ to the right by the size of 65 // r4_, which is kKernelSize / 2: 66 // 67 // r0_ = r0_ + kKernelSize / 2 = input_buffer_ + kKernelSize 68 // 69 // r3_, r4_, and block_size_ then need to be reinitialized, so goto (3). 70 // 71 // 8) Else, if we're not on the second load, goto (4). 72 // 73 // Note: we're glossing over how the sub-sample handling works with 74 // |virtual_source_idx_|, etc. 75 76 // MSVC++ requires this to be set before any other includes to get M_PI. 77 #define _USE_MATH_DEFINES 78 79 #include "media/base/sinc_resampler.h" 80 81 #include <cmath> 82 #include <limits> 83 84 #include "base/cpu.h" 85 #include "base/logging.h" 86 87 #if defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON) 88 #include <arm_neon.h> 89 #endif 90 91 namespace media { 92 93 static double SincScaleFactor(double io_ratio) { 94 // |sinc_scale_factor| is basically the normalized cutoff frequency of the 95 // low-pass filter. 96 double sinc_scale_factor = io_ratio > 1.0 ? 1.0 / io_ratio : 1.0; 97 98 // The sinc function is an idealized brick-wall filter, but since we're 99 // windowing it the transition from pass to stop does not happen right away. 100 // So we should adjust the low pass filter cutoff slightly downward to avoid 101 // some aliasing at the very high-end. 102 // TODO(crogers): this value is empirical and to be more exact should vary 103 // depending on kKernelSize. 104 sinc_scale_factor *= 0.9; 105 106 return sinc_scale_factor; 107 } 108 109 // If we know the minimum architecture at compile time, avoid CPU detection. 110 // Force NaCl code to use C routines since (at present) nothing there uses these 111 // methods and plumbing the -msse built library is non-trivial. iOS lies 112 // about its architecture, so we also need to exclude it here. 113 #if defined(ARCH_CPU_X86_FAMILY) && !defined(OS_NACL) && !defined(OS_IOS) 114 #if defined(__SSE__) 115 #define CONVOLVE_FUNC Convolve_SSE 116 void SincResampler::InitializeCPUSpecificFeatures() {} 117 #else 118 // X86 CPU detection required. Functions will be set by 119 // InitializeCPUSpecificFeatures(). 120 // TODO(dalecurtis): Once Chrome moves to an SSE baseline this can be removed. 121 #define CONVOLVE_FUNC g_convolve_proc_ 122 123 typedef float (*ConvolveProc)(const float*, const float*, const float*, double); 124 static ConvolveProc g_convolve_proc_ = NULL; 125 126 void SincResampler::InitializeCPUSpecificFeatures() { 127 CHECK(!g_convolve_proc_); 128 g_convolve_proc_ = base::CPU().has_sse() ? Convolve_SSE : Convolve_C; 129 } 130 #endif 131 #elif defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON) 132 #define CONVOLVE_FUNC Convolve_NEON 133 void SincResampler::InitializeCPUSpecificFeatures() {} 134 #else 135 // Unknown architecture. 136 #define CONVOLVE_FUNC Convolve_C 137 void SincResampler::InitializeCPUSpecificFeatures() {} 138 #endif 139 140 SincResampler::SincResampler(double io_sample_rate_ratio, 141 int request_frames, 142 const ReadCB& read_cb) 143 : io_sample_rate_ratio_(io_sample_rate_ratio), 144 read_cb_(read_cb), 145 request_frames_(request_frames), 146 input_buffer_size_(request_frames_ + kKernelSize), 147 // Create input buffers with a 16-byte alignment for SSE optimizations. 148 kernel_storage_(static_cast<float*>( 149 base::AlignedAlloc(sizeof(float) * kKernelStorageSize, 16))), 150 kernel_pre_sinc_storage_(static_cast<float*>( 151 base::AlignedAlloc(sizeof(float) * kKernelStorageSize, 16))), 152 kernel_window_storage_(static_cast<float*>( 153 base::AlignedAlloc(sizeof(float) * kKernelStorageSize, 16))), 154 input_buffer_(static_cast<float*>( 155 base::AlignedAlloc(sizeof(float) * input_buffer_size_, 16))), 156 r1_(input_buffer_.get()), 157 r2_(input_buffer_.get() + kKernelSize / 2) { 158 CHECK_GT(request_frames_, 0); 159 Flush(); 160 CHECK_GT(block_size_, kKernelSize) 161 << "block_size must be greater than kKernelSize!"; 162 163 memset(kernel_storage_.get(), 0, 164 sizeof(*kernel_storage_.get()) * kKernelStorageSize); 165 memset(kernel_pre_sinc_storage_.get(), 0, 166 sizeof(*kernel_pre_sinc_storage_.get()) * kKernelStorageSize); 167 memset(kernel_window_storage_.get(), 0, 168 sizeof(*kernel_window_storage_.get()) * kKernelStorageSize); 169 170 InitializeKernel(); 171 } 172 173 SincResampler::~SincResampler() {} 174 175 void SincResampler::UpdateRegions(bool second_load) { 176 // Setup various region pointers in the buffer (see diagram above). If we're 177 // on the second load we need to slide r0_ to the right by kKernelSize / 2. 178 r0_ = input_buffer_.get() + (second_load ? kKernelSize : kKernelSize / 2); 179 r3_ = r0_ + request_frames_ - kKernelSize; 180 r4_ = r0_ + request_frames_ - kKernelSize / 2; 181 block_size_ = r4_ - r2_; 182 183 // r1_ at the beginning of the buffer. 184 CHECK_EQ(r1_, input_buffer_.get()); 185 // r1_ left of r2_, r4_ left of r3_ and size correct. 186 CHECK_EQ(r2_ - r1_, r4_ - r3_); 187 // r2_ left of r3. 188 CHECK_LT(r2_, r3_); 189 } 190 191 void SincResampler::InitializeKernel() { 192 // Blackman window parameters. 193 static const double kAlpha = 0.16; 194 static const double kA0 = 0.5 * (1.0 - kAlpha); 195 static const double kA1 = 0.5; 196 static const double kA2 = 0.5 * kAlpha; 197 198 // Generates a set of windowed sinc() kernels. 199 // We generate a range of sub-sample offsets from 0.0 to 1.0. 200 const double sinc_scale_factor = SincScaleFactor(io_sample_rate_ratio_); 201 for (int offset_idx = 0; offset_idx <= kKernelOffsetCount; ++offset_idx) { 202 const float subsample_offset = 203 static_cast<float>(offset_idx) / kKernelOffsetCount; 204 205 for (int i = 0; i < kKernelSize; ++i) { 206 const int idx = i + offset_idx * kKernelSize; 207 const float pre_sinc = M_PI * (i - kKernelSize / 2 - subsample_offset); 208 kernel_pre_sinc_storage_[idx] = pre_sinc; 209 210 // Compute Blackman window, matching the offset of the sinc(). 211 const float x = (i - subsample_offset) / kKernelSize; 212 const float window = kA0 - kA1 * cos(2.0 * M_PI * x) + kA2 213 * cos(4.0 * M_PI * x); 214 kernel_window_storage_[idx] = window; 215 216 // Compute the sinc with offset, then window the sinc() function and store 217 // at the correct offset. 218 if (pre_sinc == 0) { 219 kernel_storage_[idx] = sinc_scale_factor * window; 220 } else { 221 kernel_storage_[idx] = 222 window * sin(sinc_scale_factor * pre_sinc) / pre_sinc; 223 } 224 } 225 } 226 } 227 228 void SincResampler::SetRatio(double io_sample_rate_ratio) { 229 if (fabs(io_sample_rate_ratio_ - io_sample_rate_ratio) < 230 std::numeric_limits<double>::epsilon()) { 231 return; 232 } 233 234 io_sample_rate_ratio_ = io_sample_rate_ratio; 235 236 // Optimize reinitialization by reusing values which are independent of 237 // |sinc_scale_factor|. Provides a 3x speedup. 238 const double sinc_scale_factor = SincScaleFactor(io_sample_rate_ratio_); 239 for (int offset_idx = 0; offset_idx <= kKernelOffsetCount; ++offset_idx) { 240 for (int i = 0; i < kKernelSize; ++i) { 241 const int idx = i + offset_idx * kKernelSize; 242 const float window = kernel_window_storage_[idx]; 243 const float pre_sinc = kernel_pre_sinc_storage_[idx]; 244 245 if (pre_sinc == 0) { 246 kernel_storage_[idx] = sinc_scale_factor * window; 247 } else { 248 kernel_storage_[idx] = 249 window * sin(sinc_scale_factor * pre_sinc) / pre_sinc; 250 } 251 } 252 } 253 } 254 255 void SincResampler::Resample(int frames, float* destination) { 256 int remaining_frames = frames; 257 258 // Step (1) -- Prime the input buffer at the start of the input stream. 259 if (!buffer_primed_ && remaining_frames) { 260 read_cb_.Run(request_frames_, r0_); 261 buffer_primed_ = true; 262 } 263 264 // Step (2) -- Resample! const what we can outside of the loop for speed. It 265 // actually has an impact on ARM performance. See inner loop comment below. 266 const double current_io_ratio = io_sample_rate_ratio_; 267 const float* const kernel_ptr = kernel_storage_.get(); 268 while (remaining_frames) { 269 // |i| may be negative if the last Resample() call ended on an iteration 270 // that put |virtual_source_idx_| over the limit. 271 // 272 // Note: The loop construct here can severely impact performance on ARM 273 // or when built with clang. See https://codereview.chromium.org/18566009/ 274 for (int i = ceil((block_size_ - virtual_source_idx_) / current_io_ratio); 275 i > 0; --i) { 276 DCHECK_LT(virtual_source_idx_, block_size_); 277 278 // |virtual_source_idx_| lies in between two kernel offsets so figure out 279 // what they are. 280 const int source_idx = virtual_source_idx_; 281 const double subsample_remainder = virtual_source_idx_ - source_idx; 282 283 const double virtual_offset_idx = 284 subsample_remainder * kKernelOffsetCount; 285 const int offset_idx = virtual_offset_idx; 286 287 // We'll compute "convolutions" for the two kernels which straddle 288 // |virtual_source_idx_|. 289 const float* const k1 = kernel_ptr + offset_idx * kKernelSize; 290 const float* const k2 = k1 + kKernelSize; 291 292 // Ensure |k1|, |k2| are 16-byte aligned for SIMD usage. Should always be 293 // true so long as kKernelSize is a multiple of 16. 294 DCHECK_EQ(0u, reinterpret_cast<uintptr_t>(k1) & 0x0F); 295 DCHECK_EQ(0u, reinterpret_cast<uintptr_t>(k2) & 0x0F); 296 297 // Initialize input pointer based on quantized |virtual_source_idx_|. 298 const float* const input_ptr = r1_ + source_idx; 299 300 // Figure out how much to weight each kernel's "convolution". 301 const double kernel_interpolation_factor = 302 virtual_offset_idx - offset_idx; 303 *destination++ = CONVOLVE_FUNC( 304 input_ptr, k1, k2, kernel_interpolation_factor); 305 306 // Advance the virtual index. 307 virtual_source_idx_ += current_io_ratio; 308 309 if (!--remaining_frames) 310 return; 311 } 312 313 // Wrap back around to the start. 314 virtual_source_idx_ -= block_size_; 315 316 // Step (3) -- Copy r3_, r4_ to r1_, r2_. 317 // This wraps the last input frames back to the start of the buffer. 318 memcpy(r1_, r3_, sizeof(*input_buffer_.get()) * kKernelSize); 319 320 // Step (4) -- Reinitialize regions if necessary. 321 if (r0_ == r2_) 322 UpdateRegions(true); 323 324 // Step (5) -- Refresh the buffer with more input. 325 read_cb_.Run(request_frames_, r0_); 326 } 327 } 328 329 #undef CONVOLVE_FUNC 330 331 int SincResampler::ChunkSize() const { 332 return block_size_ / io_sample_rate_ratio_; 333 } 334 335 void SincResampler::Flush() { 336 virtual_source_idx_ = 0; 337 buffer_primed_ = false; 338 memset(input_buffer_.get(), 0, 339 sizeof(*input_buffer_.get()) * input_buffer_size_); 340 UpdateRegions(false); 341 } 342 343 float SincResampler::Convolve_C(const float* input_ptr, const float* k1, 344 const float* k2, 345 double kernel_interpolation_factor) { 346 float sum1 = 0; 347 float sum2 = 0; 348 349 // Generate a single output sample. Unrolling this loop hurt performance in 350 // local testing. 351 int n = kKernelSize; 352 while (n--) { 353 sum1 += *input_ptr * *k1++; 354 sum2 += *input_ptr++ * *k2++; 355 } 356 357 // Linearly interpolate the two "convolutions". 358 return (1.0 - kernel_interpolation_factor) * sum1 359 + kernel_interpolation_factor * sum2; 360 } 361 362 #if defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON) 363 float SincResampler::Convolve_NEON(const float* input_ptr, const float* k1, 364 const float* k2, 365 double kernel_interpolation_factor) { 366 float32x4_t m_input; 367 float32x4_t m_sums1 = vmovq_n_f32(0); 368 float32x4_t m_sums2 = vmovq_n_f32(0); 369 370 const float* upper = input_ptr + kKernelSize; 371 for (; input_ptr < upper; ) { 372 m_input = vld1q_f32(input_ptr); 373 input_ptr += 4; 374 m_sums1 = vmlaq_f32(m_sums1, m_input, vld1q_f32(k1)); 375 k1 += 4; 376 m_sums2 = vmlaq_f32(m_sums2, m_input, vld1q_f32(k2)); 377 k2 += 4; 378 } 379 380 // Linearly interpolate the two "convolutions". 381 m_sums1 = vmlaq_f32( 382 vmulq_f32(m_sums1, vmovq_n_f32(1.0 - kernel_interpolation_factor)), 383 m_sums2, vmovq_n_f32(kernel_interpolation_factor)); 384 385 // Sum components together. 386 float32x2_t m_half = vadd_f32(vget_high_f32(m_sums1), vget_low_f32(m_sums1)); 387 return vget_lane_f32(vpadd_f32(m_half, m_half), 0); 388 } 389 #endif 390 391 } // namespace media 392