Enhance AudioSplicer to crossfade marked splice frames.

media/base/vector_math_unittest.cc

 // Copyright (c) 2012 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.
 
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 #include <cmath>
 
 #include "base/cpu.h"
 #include "base/memory/aligned_memory.h"
@@ skipping 26 matching lines @@
   }
 
   void FillTestVectors(float input, float output) {
     // Setup input and output vectors.
     fill(input_vector_.get(), input_vector_.get() + kVectorSize, input);
     fill(output_vector_.get(), output_vector_.get() + kVectorSize, output);
   }
 
   void VerifyOutput(float value) {
     for (int i = 0; i < kVectorSize; ++i)
-      ASSERT_FLOAT_EQ(output_vector_.get()[i], value);
+      ASSERT_FLOAT_EQ(output_vector_[i], value);
   }
 
  protected:
-  scoped_ptr<float, base::AlignedFreeDeleter> input_vector_;
-  scoped_ptr<float, base::AlignedFreeDeleter> output_vector_;
+  scoped_ptr<float[], base::AlignedFreeDeleter> input_vector_;
+  scoped_ptr<float[], base::AlignedFreeDeleter> output_vector_;
 
   DISALLOW_COPY_AND_ASSIGN(VectorMathTest);
 };
 
 // Ensure each optimized vector_math::FMAC() method returns the same value.
 TEST_F(VectorMathTest, FMAC) {
   static const float kResult = kInputFillValue * kScale + kOutputFillValue;
 
   {
     SCOPED_TRACE("FMAC");
@@ skipping 68 matching lines @@
   {
     SCOPED_TRACE("FMUL_NEON");
     FillTestVectors(kInputFillValue, kOutputFillValue);
     vector_math::FMUL_NEON(
         input_vector_.get(), kScale, kVectorSize, output_vector_.get());
     VerifyOutput(kResult);
   }
 #endif
 }
 
-namespace {
+TEST_F(VectorMathTest, Crossfade) {
+  FillTestVectors(0, 1);
+  vector_math::Crossfade(
+      input_vector_.get(), kVectorSize, output_vector_.get());
+  for (int i = 0; i < kVectorSize; ++i) {
+    ASSERT_FLOAT_EQ(i / static_cast<float>(kVectorSize), output_vector_[i])
+        << "i=" << i;
+  }
+}
 
 class EWMATestScenario {
  public:
   EWMATestScenario(float initial_value, const float src[], int len,
                    float smoothing_factor)
       : initial_value_(initial_value),
         data_(static_cast<float*>(
             len == 0 ? NULL :
             base::AlignedAlloc(len * sizeof(float),
                                vector_math::kRequiredAlignment))),
@@ skipping 89 matching lines @@
 
  private:
   float initial_value_;
   scoped_ptr<float, base::AlignedFreeDeleter> data_;
   int data_len_;
   float smoothing_factor_;
   float expected_final_avg_;
   float expected_max_;
 };
 
-}  // namespace
-
 typedef testing::TestWithParam<EWMATestScenario> VectorMathEWMAAndMaxPowerTest;
 
 TEST_P(VectorMathEWMAAndMaxPowerTest, Correctness) {
   GetParam().RunTest();
 }
 
 static const float kZeros[] = {  // 32 zeros
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 };
@@ skipping 113 matching lines @@
              .HasExpectedResult(0.00017858f, 4.0f),
          EWMATestScenario(0.0f, kZeros, 32, 0.25f)
              .WithImpulse(2.0f, 2)
              .HasExpectedResult(0.00023811f, 4.0f),
          EWMATestScenario(0.0f, kZeros, 32, 0.25f)
              .WithImpulse(2.0f, 3)
              .HasExpectedResult(0.00031748f, 4.0f)
     ));
 
 }  // namespace media