Attachment #7477 for bug #34722

View | Details | Raw Unified | Return to bug 34722
Collapse All | Expand All




++ b/cc/raster/texture_compressor.cc

#include "base/memory/ptr_util.h"
#include "cc/raster/texture_compressor_etc1.h"

#if defined(ARCH_CPU_X86_64)
#include "base/cpu.h"
#include "cc/raster/texture_compressor_etc1_sse.h"
#endif

std::unique_ptr<TextureCompressor> TextureCompressor::Create(Format format) {
  switch (format) {
    case kFormatETC1: {
#if defined(ARCH_CPU_X86_64)
      base::CPU cpu;
      if (cpu.has_sse2()) {
        return base::WrapUnique(new TextureCompressorETC1SSE());
++ b/media/base/sinc_resampler.cc

#include "base/numerics/math_constants.h"
#include "build/build_config.h"

#if defined(__x86_64__)
#include <xmmintrin.h>
#define CONVOLVE_FUNC Convolve_SSE
#elif defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)

      kernel_interpolation_factor * sum2);
}

#if defined(__x86_64__)
float SincResampler::Convolve_SSE(const float* input_ptr, const float* k1,
                                  const float* k2,
                                  double kernel_interpolation_factor) {
++ b/media/base/sinc_resampler.h

  // ARM, NEON support is chosen at compile time based on compilation flags.
  static float Convolve_C(const float* input_ptr, const float* k1,
                          const float* k2, double kernel_interpolation_factor);
#if defined(__x86_64__)
  static float Convolve_SSE(const float* input_ptr, const float* k1,
                            const float* k2,
                            double kernel_interpolation_factor);
++ b/media/base/sinc_resampler_perftest.cc

static void DoNothing(int frames, float* destination) {}

// Define platform independent function name for Convolve* tests.
#if defined(__x86_64__)
#define CONVOLVE_FUNC Convolve_SSE
#elif defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)
#define CONVOLVE_FUNC Convolve_NEON
++ b/media/base/sinc_resampler_unittest.cc



// Define platform independent function name for Convolve* tests.
#if defined(__x86_64__)
#define CONVOLVE_FUNC Convolve_SSE
#elif defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)
#define CONVOLVE_FUNC Convolve_NEON
++ b/media/base/vector_math.cc

#include "build/build_config.h"

// NaCl does not allow intrinsics.
#if defined(__x86_64__) && !defined(OS_NACL)
#include <xmmintrin.h>
// Don't use custom SSE versions where the auto-vectorized C version performs
// better, which is anywhere clang is used.

  return result;
}

#if defined(__x86_64__) && !defined(OS_NACL)
void FMUL_SSE(const float src[], float scale, int len, float dest[]) {
  const int rem = len % 4;
  const int last_index = len - rem;
++ b/media/base/vector_math_perftest.cc

};

// Define platform dependent function names for SIMD optimized methods.
#if defined(__x86_64__)
#define FMAC_FUNC FMAC_SSE
#define FMUL_FUNC FMUL_SSE
#define EWMAAndMaxPower_FUNC EWMAAndMaxPower_SSE
++ b/media/base/vector_math_testing.h

    int len,
    float smoothing_factor);

#if defined(__x86_64__) && !defined(OS_NACL)
MEDIA_SHMEM_EXPORT void FMAC_SSE(const float src[],
                                 float scale,
                                 int len,
++ b/media/base/vector_math_unittest.cc

    VerifyOutput(kResult);
  }

#if defined(__x86_64__)
  {
    SCOPED_TRACE("FMAC_SSE");
    FillTestVectors(kInputFillValue, kOutputFillValue);

    VerifyOutput(kResult);
  }

#if defined(__x86_64__)
  {
    SCOPED_TRACE("FMUL_SSE");
    FillTestVectors(kInputFillValue, kOutputFillValue);

      EXPECT_NEAR(expected_max_, result.second, 0.0000001f);
    }

#if defined(__x86_64__)
    {
      SCOPED_TRACE("EWMAAndMaxPower_SSE");
      const std::pair<float, float>& result = vector_math::EWMAAndMaxPower_SSE(
++ b/skia/ext/convolver.h

// We can build SSE2 optimized versions for all x86 CPUs
// except when building for the IOS emulator.
#if defined(ARCH_CPU_X86_FAMILY) && !defined(OS_IOS)
#define SIMD_SSE2 1
#define SIMD_PADDING 8  // 8 * int16_t
#endif

++ b/third_party/WebKit/Source/platform/audio/DirectConvolver.cpp

#include <Accelerate/Accelerate.h>
#endif

#if defined(ARCH_CPU_X86_64) && !defined(OS_MACOSX)
#include <emmintrin.h>
#endif


#endif  // ARCH_CPU_X86
#else
  size_t i = 0;
#if defined(ARCH_CPU_X86_64)
  // Convolution using SSE2. Currently only do this if both |kernelSize| and
  // |framesToProcess| are multiples of 4. If not, use the straightforward loop
  // below.

      }
      dest_p[i++] = sum;
    }
#if defined(ARCH_CPU_X86_64)
  }
#endif
#endif  // OS_MACOSX
++ b/third_party/WebKit/Source/platform/audio/SincResampler.cpp

#include "platform/audio/AudioBus.h"
#include "platform/wtf/MathExtras.h"

#if defined(ARCH_CPU_X86_64)
#include <emmintrin.h>
#endif


      {
        float input;

#if defined(ARCH_CPU_X86_64)
        // If the sourceP address is not 16-byte aligned, the first several
        // frames (at most three) should be processed seperately.
        while ((reinterpret_cast<uintptr_t>(input_p) & 0x0F) && n) {
++ b/third_party/WebKit/Source/platform/audio/VectorMath.cpp

#include "platform/audio/cpu/arm/VectorMathNEON.h"
#elif HAVE_MIPS_MSA_INTRINSICS
#include "platform/audio/cpu/mips/VectorMathMSA.h"
#elif defined(ARCH_CPU_X86_64)
#include "platform/audio/cpu/x86/VectorMathX86.h"
#else
#include "platform/audio/VectorMathScalar.h"

namespace Impl = NEON;
#elif HAVE_MIPS_MSA_INTRINSICS
namespace Impl = MSA;
#elif defined(ARCH_CPU_X86_64)
namespace Impl = X86;
#else
namespace Impl = Scalar;
++ b/third_party/WebKit/Source/platform/graphics/cpu/x86/WebGLImageConversionSSE.h


#include "build/build_config.h"

#if defined(ARCH_CPU_X86_64)
#include <emmintrin.h>

namespace blink {

}  // namespace SIMD
}  // namespace blink

#endif  // ARCH_CPU_X86_64

#endif  // WebGLImageConversionSSE_h
++ b/third_party/WebKit/Source/platform/graphics/gpu/WebGLImageConversion.cpp

  const uint32_t* source32 = reinterpret_cast_ptr<const uint32_t*>(source);
  uint32_t* destination32 = reinterpret_cast_ptr<uint32_t*>(destination);

#if defined(ARCH_CPU_X86_64)
  SIMD::UnpackOneRowOfBGRA8LittleToRGBA8(source32, destination32,
                                         pixels_per_row);
#endif

    const uint16_t* source,
    uint8_t* destination,
    unsigned pixels_per_row) {
#if defined(ARCH_CPU_X86_64)
  SIMD::UnpackOneRowOfRGBA5551LittleToRGBA8(source, destination,
                                            pixels_per_row);
#endif

    const uint16_t* source,
    uint8_t* destination,
    unsigned pixels_per_row) {
#if defined(ARCH_CPU_X86_64)
  SIMD::UnpackOneRowOfRGBA4444LittleToRGBA8(source, destination,
                                            pixels_per_row);
#endif

          uint8_t>(const uint8_t* source,
                   uint8_t* destination,
                   unsigned pixels_per_row) {
#if defined(ARCH_CPU_X86_64)
  SIMD::PackOneRowOfRGBA8LittleToR8(source, destination, pixels_per_row);
#endif
#if HAVE_MIPS_MSA_INTRINSICS

          uint8_t>(const uint8_t* source,
                   uint8_t* destination,
                   unsigned pixels_per_row) {
#if defined(ARCH_CPU_X86_64)
  SIMD::PackOneRowOfRGBA8LittleToRA8(source, destination, pixels_per_row);
#endif
#if HAVE_MIPS_MSA_INTRINSICS

          uint8_t>(const uint8_t* source,
                   uint8_t* destination,
                   unsigned pixels_per_row) {
#if defined(ARCH_CPU_X86_64)
  SIMD::PackOneRowOfRGBA8LittleToRGBA8(source, destination, pixels_per_row);
#endif
#if HAVE_MIPS_MSA_INTRINSICS
++ b/third_party/WebKit/Source/modules/webaudio/AudioParamTimeline.cpp

#include "platform/wtf/CPU.h"
#include "platform/wtf/MathExtras.h"

#if defined(ARCH_CPU_X86_64)
#include <emmintrin.h>
#endif


    size_t current_frame,
    float value,
    unsigned write_index) {
#if defined(ARCH_CPU_X86_64)
  auto number_of_values = current_state.number_of_values;
#endif
  auto fill_to_frame = current_state.fill_to_frame;

  double delta_time = time2 - time1;
  float k = delta_time > 0 ? 1 / delta_time : 0;
  const float value_delta = value2 - value1;
#if defined(ARCH_CPU_X86_64)
  if (fill_to_frame > write_index) {
    // Minimize in-loop operations. Calculate starting value and increment.
    // Next step: value += inc.

    size_t current_frame,
    float value,
    unsigned write_index) {
#if defined(ARCH_CPU_X86_64)
  auto number_of_values = current_state.number_of_values;
#endif
  auto fill_to_frame = current_state.fill_to_frame;

    for (; write_index < fill_to_frame; ++write_index)
      values[write_index] = target;
  } else {
#if defined(ARCH_CPU_X86_64)
    if (fill_to_frame > write_index) {
      // Resolve recursion by expanding constants to achieve a 4-step
      // loop unrolling.

  // Oversampled curve data can be provided if sharp discontinuities are
  // desired.
  unsigned k = 0;
#if defined(ARCH_CPU_X86_64)
  if (fill_to_frame > write_index) {
    const __m128 v_curve_virtual_index = _mm_set_ps1(curve_virtual_index);
    const __m128 v_curve_points_per_frame = _mm_set_ps1(curve_points_per_frame);

Return to bug 34722

Line Link Here

(-)file_not_specified_in_diff (-52 / +51 lines)
0	-- a/cc/raster/texture_compressor.cc	0	++ b/cc/raster/texture_compressor.cc
Lines 8-14 Link Here
8	#include "base/memory/ptr_util.h"	8	#include "base/memory/ptr_util.h"
9	#include "cc/raster/texture_compressor_etc1.h"	9	#include "cc/raster/texture_compressor_etc1.h"
10		10
11	#if defined(ARCH_CPU_X86_FAMILY)	11	#if defined(ARCH_CPU_X86_64)
12	#include "base/cpu.h"	12	#include "base/cpu.h"
13	#include "cc/raster/texture_compressor_etc1_sse.h"	13	#include "cc/raster/texture_compressor_etc1_sse.h"
14	#endif	14	#endif
Lines 18-24 namespace cc { Link Here
18	std::unique_ptr<TextureCompressor> TextureCompressor::Create(Format format) {	18	std::unique_ptr<TextureCompressor> TextureCompressor::Create(Format format) {
19	switch (format) {	19	switch (format) {
20	case kFormatETC1: {	20	case kFormatETC1: {
21	#if defined(ARCH_CPU_X86_FAMILY)	21	#if defined(ARCH_CPU_X86_64)
22	base::CPU cpu;	22	base::CPU cpu;
23	if (cpu.has_sse2()) {	23	if (cpu.has_sse2()) {
24	return base::WrapUnique(new TextureCompressorETC1SSE());	24	return base::WrapUnique(new TextureCompressorETC1SSE());
25	-- a/media/base/sinc_resampler.cc	25	++ b/media/base/sinc_resampler.cc
Lines 81-87 Link Here
81	#include "base/numerics/math_constants.h"	81	#include "base/numerics/math_constants.h"
82	#include "build/build_config.h"	82	#include "build/build_config.h"
83		83
84	#if defined(ARCH_CPU_X86_FAMILY)	84	#if defined(__x86_64__)
85	#include <xmmintrin.h>	85	#include <xmmintrin.h>
86	#define CONVOLVE_FUNC Convolve_SSE	86	#define CONVOLVE_FUNC Convolve_SSE
87	#elif defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)	87	#elif defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)
Lines 326-332 float SincResampler::Convolve_C(const fl Link Here
326	kernel_interpolation_factor * sum2);	326	kernel_interpolation_factor * sum2);
327	}	327	}
328		328
329	#if defined(ARCH_CPU_X86_FAMILY)	329	#if defined(__x86_64__)
330	float SincResampler::Convolve_SSE(const float* input_ptr, const float* k1,	330	float SincResampler::Convolve_SSE(const float* input_ptr, const float* k1,
331	const float* k2,	331	const float* k2,
332	double kernel_interpolation_factor) {	332	double kernel_interpolation_factor) {
333	-- a/media/base/sinc_resampler.h	333	++ b/media/base/sinc_resampler.h
Lines 98-104 class MEDIA_EXPORT SincResampler { Link Here
98	// ARM, NEON support is chosen at compile time based on compilation flags.	98	// ARM, NEON support is chosen at compile time based on compilation flags.
99	static float Convolve_C(const float* input_ptr, const float* k1,	99	static float Convolve_C(const float* input_ptr, const float* k1,
100	const float* k2, double kernel_interpolation_factor);	100	const float* k2, double kernel_interpolation_factor);
101	#if defined(ARCH_CPU_X86_FAMILY)	101	#if defined(__x86_64__)
102	static float Convolve_SSE(const float* input_ptr, const float* k1,	102	static float Convolve_SSE(const float* input_ptr, const float* k1,
103	const float* k2,	103	const float* k2,
104	double kernel_interpolation_factor);	104	double kernel_interpolation_factor);
105	-- a/media/base/sinc_resampler_perftest.cc	105	++ b/media/base/sinc_resampler_perftest.cc
Lines 22-28 static const double kKernelInterpolation Link Here
22	static void DoNothing(int frames, float* destination) {}	22	static void DoNothing(int frames, float* destination) {}
23		23
24	// Define platform independent function name for Convolve* tests.	24	// Define platform independent function name for Convolve* tests.
25	#if defined(ARCH_CPU_X86_FAMILY)	25	#if defined(__x86_64__)
26	#define CONVOLVE_FUNC Convolve_SSE	26	#define CONVOLVE_FUNC Convolve_SSE
27	#elif defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)	27	#elif defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)
28	#define CONVOLVE_FUNC Convolve_NEON	28	#define CONVOLVE_FUNC Convolve_NEON
29	-- a/media/base/sinc_resampler_unittest.cc	29	++ b/media/base/sinc_resampler_unittest.cc
Lines 150-156 TEST(SincResamplerTest, DISABLED_SetRati Link Here
150		150
151		151
152	// Define platform independent function name for Convolve* tests.	152	// Define platform independent function name for Convolve* tests.
153	#if defined(ARCH_CPU_X86_FAMILY)	153	#if defined(__x86_64__)
154	#define CONVOLVE_FUNC Convolve_SSE	154	#define CONVOLVE_FUNC Convolve_SSE
155	#elif defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)	155	#elif defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)
156	#define CONVOLVE_FUNC Convolve_NEON	156	#define CONVOLVE_FUNC Convolve_NEON
157	-- a/media/base/vector_math.cc	157	++ b/media/base/vector_math.cc
Lines 11-17 Link Here
11	#include "build/build_config.h"	11	#include "build/build_config.h"
12		12
13	// NaCl does not allow intrinsics.	13	// NaCl does not allow intrinsics.
14	#if defined(ARCH_CPU_X86_FAMILY) && !defined(OS_NACL)	14	#if defined(__x86_64__) && !defined(OS_NACL)
15	#include <xmmintrin.h>	15	#include <xmmintrin.h>
16	// Don't use custom SSE versions where the auto-vectorized C version performs	16	// Don't use custom SSE versions where the auto-vectorized C version performs
17	// better, which is anywhere clang is used.	17	// better, which is anywhere clang is used.
Lines 91-97 std::pair<float, float> EWMAAndMaxPower_ Link Here
91	return result;	91	return result;
92	}	92	}
93		93
94	#if defined(ARCH_CPU_X86_FAMILY) && !defined(OS_NACL)	94	#if defined(__x86_64__) && !defined(OS_NACL)
95	void FMUL_SSE(const float src[], float scale, int len, float dest[]) {	95	void FMUL_SSE(const float src[], float scale, int len, float dest[]) {
96	const int rem = len % 4;	96	const int rem = len % 4;
97	const int last_index = len - rem;	97	const int last_index = len - rem;
98	-- a/media/base/vector_math_perftest.cc	98	++ b/media/base/vector_math_perftest.cc
Lines 83-89 class VectorMathPerfTest : public testin Link Here
83	};	83	};
84		84
85	// Define platform dependent function names for SIMD optimized methods.	85	// Define platform dependent function names for SIMD optimized methods.
86	#if defined(ARCH_CPU_X86_FAMILY)	86	#if defined(__x86_64__)
87	#define FMAC_FUNC FMAC_SSE	87	#define FMAC_FUNC FMAC_SSE
88	#define FMUL_FUNC FMUL_SSE	88	#define FMUL_FUNC FMUL_SSE
89	#define EWMAAndMaxPower_FUNC EWMAAndMaxPower_SSE	89	#define EWMAAndMaxPower_FUNC EWMAAndMaxPower_SSE
90	-- a/media/base/vector_math_testing.h	90	++ b/media/base/vector_math_testing.h
Lines 28-34 MEDIA_SHMEM_EXPORT std::pair<float, floa Link Here
28	int len,	28	int len,
29	float smoothing_factor);	29	float smoothing_factor);
30		30
31	#if defined(ARCH_CPU_X86_FAMILY) && !defined(OS_NACL)	31	#if defined(__x86_64__) && !defined(OS_NACL)
32	MEDIA_SHMEM_EXPORT void FMAC_SSE(const float src[],	32	MEDIA_SHMEM_EXPORT void FMAC_SSE(const float src[],
33	float scale,	33	float scale,
34	int len,	34	int len,
35	-- a/media/base/vector_math_unittest.cc	35	++ b/media/base/vector_math_unittest.cc
Lines 73-79 TEST_F(VectorMathTest, FMAC) { Link Here
73	VerifyOutput(kResult);	73	VerifyOutput(kResult);
74	}	74	}
75		75
76	#if defined(ARCH_CPU_X86_FAMILY)	76	#if defined(__x86_64__)
77	{	77	{
78	SCOPED_TRACE("FMAC_SSE");	78	SCOPED_TRACE("FMAC_SSE");
79	FillTestVectors(kInputFillValue, kOutputFillValue);	79	FillTestVectors(kInputFillValue, kOutputFillValue);
Lines 114-120 TEST_F(VectorMathTest, FMUL) { Link Here
114	VerifyOutput(kResult);	114	VerifyOutput(kResult);
115	}	115	}
116		116
117	#if defined(ARCH_CPU_X86_FAMILY)	117	#if defined(__x86_64__)
118	{	118	{
119	SCOPED_TRACE("FMUL_SSE");	119	SCOPED_TRACE("FMUL_SSE");
120	FillTestVectors(kInputFillValue, kOutputFillValue);	120	FillTestVectors(kInputFillValue, kOutputFillValue);
Lines 222-228 class EWMATestScenario { Link Here
222	EXPECT_NEAR(expected_max_, result.second, 0.0000001f);	222	EXPECT_NEAR(expected_max_, result.second, 0.0000001f);
223	}	223	}
224		224
225	#if defined(ARCH_CPU_X86_FAMILY)	225	#if defined(__x86_64__)
226	{	226	{
227	SCOPED_TRACE("EWMAAndMaxPower_SSE");	227	SCOPED_TRACE("EWMAAndMaxPower_SSE");
228	const std::pair<float, float>& result = vector_math::EWMAAndMaxPower_SSE(	228	const std::pair<float, float>& result = vector_math::EWMAAndMaxPower_SSE(
229	-- a/skia/ext/convolver.h	229	++ b/skia/ext/convolver.h
Lines 17-23 Link Here
17	// We can build SSE2 optimized versions for all x86 CPUs	17	// We can build SSE2 optimized versions for all x86 CPUs
18	// except when building for the IOS emulator.	18	// except when building for the IOS emulator.
19	#if defined(ARCH_CPU_X86_FAMILY) && !defined(OS_IOS)	19	#if defined(ARCH_CPU_X86_FAMILY) && !defined(OS_IOS)
20	#define SIMD_SSE2 1
21	#define SIMD_PADDING 8 // 8 * int16_t	20	#define SIMD_PADDING 8 // 8 * int16_t
22	#endif	21	#endif
23		22
24	-- a/third_party/WebKit/Source/platform/audio/DirectConvolver.cpp	23	++ b/third_party/WebKit/Source/platform/audio/DirectConvolver.cpp
Lines 35-41 Link Here
35	#include <Accelerate/Accelerate.h>	35	#include <Accelerate/Accelerate.h>
36	#endif	36	#endif
37		37
38	#if defined(ARCH_CPU_X86_FAMILY) && !defined(OS_MACOSX)	38	#if defined(ARCH_CPU_X86_64) && !defined(OS_MACOSX)
39	#include <emmintrin.h>	39	#include <emmintrin.h>
40	#endif	40	#endif
41		41
Lines 83-89 void DirectConvolver::Process(AudioFloat Link Here
83	#endif // ARCH_CPU_X86	83	#endif // ARCH_CPU_X86
84	#else	84	#else
85	size_t i = 0;	85	size_t i = 0;
86	#if defined(ARCH_CPU_X86_FAMILY)	86	#if defined(ARCH_CPU_X86_64)
87	// Convolution using SSE2. Currently only do this if both \|kernelSize\| and	87	// Convolution using SSE2. Currently only do this if both \|kernelSize\| and
88	// \|framesToProcess\| are multiples of 4. If not, use the straightforward loop	88	// \|framesToProcess\| are multiples of 4. If not, use the straightforward loop
89	// below.	89	// below.
Lines 397-403 void DirectConvolver::Process(AudioFloat Link Here
397	}	397	}
398	dest_p[i++] = sum;	398	dest_p[i++] = sum;
399	}	399	}
400	#if defined(ARCH_CPU_X86_FAMILY)	400	#if defined(ARCH_CPU_X86_64)
401	}	401	}
402	#endif	402	#endif
403	#endif // OS_MACOSX	403	#endif // OS_MACOSX
404	-- a/third_party/WebKit/Source/platform/audio/SincResampler.cpp	404	++ b/third_party/WebKit/Source/platform/audio/SincResampler.cpp
Lines 32-38 Link Here
32	#include "platform/audio/AudioBus.h"	32	#include "platform/audio/AudioBus.h"
33	#include "platform/wtf/MathExtras.h"	33	#include "platform/wtf/MathExtras.h"
34		34
35	#if defined(ARCH_CPU_X86_FAMILY)	35	#if defined(ARCH_CPU_X86_64)
36	#include <emmintrin.h>	36	#include <emmintrin.h>
37	#endif	37	#endif
38		38
Lines 277-283 void SincResampler::Process(AudioSourceP Link Here
277	{	277	{
278	float input;	278	float input;
279		279
280	#if defined(ARCH_CPU_X86_FAMILY)	280	#if defined(ARCH_CPU_X86_64)
281	// If the sourceP address is not 16-byte aligned, the first several	281	// If the sourceP address is not 16-byte aligned, the first several
282	// frames (at most three) should be processed seperately.	282	// frames (at most three) should be processed seperately.
283	while ((reinterpret_cast<uintptr_t>(input_p) & 0x0F) && n) {	283	while ((reinterpret_cast<uintptr_t>(input_p) & 0x0F) && n) {
284	-- a/third_party/WebKit/Source/platform/audio/VectorMath.cpp	284	++ b/third_party/WebKit/Source/platform/audio/VectorMath.cpp
Lines 37-43 Link Here
37	#include "platform/audio/cpu/arm/VectorMathNEON.h"	37	#include "platform/audio/cpu/arm/VectorMathNEON.h"
38	#elif HAVE_MIPS_MSA_INTRINSICS	38	#elif HAVE_MIPS_MSA_INTRINSICS
39	#include "platform/audio/cpu/mips/VectorMathMSA.h"	39	#include "platform/audio/cpu/mips/VectorMathMSA.h"
40	#elif defined(ARCH_CPU_X86_FAMILY)	40	#elif defined(ARCH_CPU_X86_64)
41	#include "platform/audio/cpu/x86/VectorMathX86.h"	41	#include "platform/audio/cpu/x86/VectorMathX86.h"
42	#else	42	#else
43	#include "platform/audio/VectorMathScalar.h"	43	#include "platform/audio/VectorMathScalar.h"
Lines 54-60 namespace Impl = Mac; Link Here
54	namespace Impl = NEON;	54	namespace Impl = NEON;
55	#elif HAVE_MIPS_MSA_INTRINSICS	55	#elif HAVE_MIPS_MSA_INTRINSICS
56	namespace Impl = MSA;	56	namespace Impl = MSA;
57	#elif defined(ARCH_CPU_X86_FAMILY)	57	#elif defined(ARCH_CPU_X86_64)
58	namespace Impl = X86;	58	namespace Impl = X86;
59	#else	59	#else
60	namespace Impl = Scalar;	60	namespace Impl = Scalar;
61	-- a/third_party/WebKit/Source/platform/graphics/cpu/x86/WebGLImageConversionSSE.h	61	++ b/third_party/WebKit/Source/platform/graphics/cpu/x86/WebGLImageConversionSSE.h
Lines 7-13 Link Here
7		7
8	#include "build/build_config.h"	8	#include "build/build_config.h"
9		9
10	#if defined(ARCH_CPU_X86_FAMILY)	10	#if defined(ARCH_CPU_X86_64)
11	#include <emmintrin.h>	11	#include <emmintrin.h>
12		12
13	namespace blink {	13	namespace blink {
Lines 195-200 ALWAYS_INLINE void PackOneRowOfRGBA8Litt Link Here
195	} // namespace SIMD	195	} // namespace SIMD
196	} // namespace blink	196	} // namespace blink
197		197
198	#endif // ARCH_CPU_X86_FAMILY	198	#endif // ARCH_CPU_X86_64
199		199
200	#endif // WebGLImageConversionSSE_h	200	#endif // WebGLImageConversionSSE_h
201	-- a/third_party/WebKit/Source/platform/graphics/gpu/WebGLImageConversion.cpp	201	++ b/third_party/WebKit/Source/platform/graphics/gpu/WebGLImageConversion.cpp
Lines 444-450 void Unpack<WebGLImageConversion::kDataF Link Here
444	const uint32_t* source32 = reinterpret_cast_ptr<const uint32_t*>(source);	444	const uint32_t* source32 = reinterpret_cast_ptr<const uint32_t*>(source);
445	uint32_t* destination32 = reinterpret_cast_ptr<uint32_t*>(destination);	445	uint32_t* destination32 = reinterpret_cast_ptr<uint32_t*>(destination);
446		446
447	#if defined(ARCH_CPU_X86_FAMILY)	447	#if defined(ARCH_CPU_X86_64)
448	SIMD::UnpackOneRowOfBGRA8LittleToRGBA8(source32, destination32,	448	SIMD::UnpackOneRowOfBGRA8LittleToRGBA8(source32, destination32,
449	pixels_per_row);	449	pixels_per_row);
450	#endif	450	#endif
Lines 472-478 void Unpack<WebGLImageConversion::kDataF Link Here
472	const uint16_t* source,	472	const uint16_t* source,
473	uint8_t* destination,	473	uint8_t* destination,
474	unsigned pixels_per_row) {	474	unsigned pixels_per_row) {
475	#if defined(ARCH_CPU_X86_FAMILY)	475	#if defined(ARCH_CPU_X86_64)
476	SIMD::UnpackOneRowOfRGBA5551LittleToRGBA8(source, destination,	476	SIMD::UnpackOneRowOfRGBA5551LittleToRGBA8(source, destination,
477	pixels_per_row);	477	pixels_per_row);
478	#endif	478	#endif
Lines 502-508 void Unpack<WebGLImageConversion::kDataF Link Here
502	const uint16_t* source,	502	const uint16_t* source,
503	uint8_t* destination,	503	uint8_t* destination,
504	unsigned pixels_per_row) {	504	unsigned pixels_per_row) {
505	#if defined(ARCH_CPU_X86_FAMILY)	505	#if defined(ARCH_CPU_X86_64)
506	SIMD::UnpackOneRowOfRGBA4444LittleToRGBA8(source, destination,	506	SIMD::UnpackOneRowOfRGBA4444LittleToRGBA8(source, destination,
507	pixels_per_row);	507	pixels_per_row);
508	#endif	508	#endif
Lines 718-724 void Pack<WebGLImageConversion::kDataFor Link Here
718	uint8_t>(const uint8_t* source,	718	uint8_t>(const uint8_t* source,
719	uint8_t* destination,	719	uint8_t* destination,
720	unsigned pixels_per_row) {	720	unsigned pixels_per_row) {
721	#if defined(ARCH_CPU_X86_FAMILY)	721	#if defined(ARCH_CPU_X86_64)
722	SIMD::PackOneRowOfRGBA8LittleToR8(source, destination, pixels_per_row);	722	SIMD::PackOneRowOfRGBA8LittleToR8(source, destination, pixels_per_row);
723	#endif	723	#endif
724	#if HAVE_MIPS_MSA_INTRINSICS	724	#if HAVE_MIPS_MSA_INTRINSICS
Lines 775-781 void Pack<WebGLImageConversion::kDataFor Link Here
775	uint8_t>(const uint8_t* source,	775	uint8_t>(const uint8_t* source,
776	uint8_t* destination,	776	uint8_t* destination,
777	unsigned pixels_per_row) {	777	unsigned pixels_per_row) {
778	#if defined(ARCH_CPU_X86_FAMILY)	778	#if defined(ARCH_CPU_X86_64)
779	SIMD::PackOneRowOfRGBA8LittleToRA8(source, destination, pixels_per_row);	779	SIMD::PackOneRowOfRGBA8LittleToRA8(source, destination, pixels_per_row);
780	#endif	780	#endif
781	#if HAVE_MIPS_MSA_INTRINSICS	781	#if HAVE_MIPS_MSA_INTRINSICS
Lines 887-893 void Pack<WebGLImageConversion::kDataFor Link Here
887	uint8_t>(const uint8_t* source,	887	uint8_t>(const uint8_t* source,
888	uint8_t* destination,	888	uint8_t* destination,
889	unsigned pixels_per_row) {	889	unsigned pixels_per_row) {
890	#if defined(ARCH_CPU_X86_FAMILY)	890	#if defined(ARCH_CPU_X86_64)
891	SIMD::PackOneRowOfRGBA8LittleToRGBA8(source, destination, pixels_per_row);	891	SIMD::PackOneRowOfRGBA8LittleToRGBA8(source, destination, pixels_per_row);
892	#endif	892	#endif
893	#if HAVE_MIPS_MSA_INTRINSICS	893	#if HAVE_MIPS_MSA_INTRINSICS
894	-- a/third_party/WebKit/Source/modules/webaudio/AudioParamTimeline.cpp	894	++ b/third_party/WebKit/Source/modules/webaudio/AudioParamTimeline.cpp
Lines 39-45 Link Here
39	#include "platform/wtf/CPU.h"	39	#include "platform/wtf/CPU.h"
40	#include "platform/wtf/MathExtras.h"	40	#include "platform/wtf/MathExtras.h"
41		41
42	#if defined(ARCH_CPU_X86_FAMILY)	42	#if defined(ARCH_CPU_X86_64)
43	#include <emmintrin.h>	43	#include <emmintrin.h>
44	#endif	44	#endif
45		45
Lines 1333-1339 std::tuple<size_t, float, unsigned> Audi Link Here
1333	size_t current_frame,	1333	size_t current_frame,
1334	float value,	1334	float value,
1335	unsigned write_index) {	1335	unsigned write_index) {
1336	#if defined(ARCH_CPU_X86_FAMILY)	1336	#if defined(ARCH_CPU_X86_64)
1337	auto number_of_values = current_state.number_of_values;	1337	auto number_of_values = current_state.number_of_values;
1338	#endif	1338	#endif
1339	auto fill_to_frame = current_state.fill_to_frame;	1339	auto fill_to_frame = current_state.fill_to_frame;
Lines 1346-1352 std::tuple<size_t, float, unsigned> Audi Link Here
1346	double delta_time = time2 - time1;	1346	double delta_time = time2 - time1;
1347	float k = delta_time > 0 ? 1 / delta_time : 0;	1347	float k = delta_time > 0 ? 1 / delta_time : 0;
1348	const float value_delta = value2 - value1;	1348	const float value_delta = value2 - value1;
1349	#if defined(ARCH_CPU_X86_FAMILY)	1349	#if defined(ARCH_CPU_X86_64)
1350	if (fill_to_frame > write_index) {	1350	if (fill_to_frame > write_index) {
1351	// Minimize in-loop operations. Calculate starting value and increment.	1351	// Minimize in-loop operations. Calculate starting value and increment.
1352	// Next step: value += inc.	1352	// Next step: value += inc.
Lines 1474-1480 std::tuple<size_t, float, unsigned> Audi Link Here
1474	size_t current_frame,	1474	size_t current_frame,
1475	float value,	1475	float value,
1476	unsigned write_index) {	1476	unsigned write_index) {
1477	#if defined(ARCH_CPU_X86_FAMILY)	1477	#if defined(ARCH_CPU_X86_64)
1478	auto number_of_values = current_state.number_of_values;	1478	auto number_of_values = current_state.number_of_values;
1479	#endif	1479	#endif
1480	auto fill_to_frame = current_state.fill_to_frame;	1480	auto fill_to_frame = current_state.fill_to_frame;
Lines 1524-1530 std::tuple<size_t, float, unsigned> Audi Link Here
1524	for (; write_index < fill_to_frame; ++write_index)	1524	for (; write_index < fill_to_frame; ++write_index)
1525	values[write_index] = target;	1525	values[write_index] = target;
1526	} else {	1526	} else {
1527	#if defined(ARCH_CPU_X86_FAMILY)	1527	#if defined(ARCH_CPU_X86_64)
1528	if (fill_to_frame > write_index) {	1528	if (fill_to_frame > write_index) {
1529	// Resolve recursion by expanding constants to achieve a 4-step	1529	// Resolve recursion by expanding constants to achieve a 4-step
1530	// loop unrolling.	1530	// loop unrolling.
Lines 1658-1664 std::tuple<size_t, float, unsigned> Audi Link Here
1658	// Oversampled curve data can be provided if sharp discontinuities are	1658	// Oversampled curve data can be provided if sharp discontinuities are
1659	// desired.	1659	// desired.
1660	unsigned k = 0;	1660	unsigned k = 0;
1661	#if defined(ARCH_CPU_X86_FAMILY)	1661	#if defined(ARCH_CPU_X86_64)
1662	if (fill_to_frame > write_index) {	1662	if (fill_to_frame > write_index) {
1663	const __m128 v_curve_virtual_index = _mm_set_ps1(curve_virtual_index);	1663	const __m128 v_curve_virtual_index = _mm_set_ps1(curve_virtual_index);
1664	const __m128 v_curve_points_per_frame = _mm_set_ps1(curve_points_per_frame);	1664	const __m128 v_curve_points_per_frame = _mm_set_ps1(curve_points_per_frame);