auracaster/liblc3
3
0
Fork 0
mirror of https://github.com/google/liblc3.git synced 2026-05-04 04:08:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

mdct: Add neon implementation of FFT

Browse Source
This commit is contained in:
Antoine SOULIER
2022-05-10 13:56:39 +02:00
parent c4f48f2618
commit f182fe7e0d
6 changed files with 624 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files

315
test/neon/neon.h
View File

@@ -25,6 +25,11 @@
#include <stdint.h>
/* ----------------------------------------------------------------------------
* Integer
* -------------------------------------------------------------------------- */
typedef struct { int16_t e[4]; } int16x4_t;
typedef struct { int16_t e[8]; } int16x8_t;
@@ -32,82 +37,34 @@ typedef struct { int32_t e[4]; } int32x4_t;
typedef struct { int64_t e[2]; } int64x2_t;
/* ----------------------------------------------------------------------------
* Load / Store
* -------------------------------------------------------------------------- */
/**
* Load / Store
*/
__attribute__((unused))
static int16x4_t vld1_s16(const int16_t *p)
{
int16x4_t r;
for (int i = 0; i < 4; i++)
r.e[i] = *(p++);
return r;
}
__attribute__((unused))
static int64x2_t vmovq_n_s64(int64_t v)
{
int64x2_t r;
r.e[0] = v;
r.e[1] = v;
return r;
return (int16x4_t){ { p[0], p[1], p[2], p[3] } };
}
/* ----------------------------------------------------------------------------
* Move
* -------------------------------------------------------------------------- */
__attribute__((unused))
static int32x4_t vmovq_n_s32(uint32_t v)
{
int32x4_t r;
for (int i = 0; i < 4; i++)
r.e[i] = v;
return r;
}
__attribute__((unused))
static int16x4_t vext_s16(int16x4_t a, int16x4_t b, const int n)
{
int16x4_t r;
int i = 0;
for (; i < n; i++) r.e[3-i] = b.e[(n-1)-i];
for (; i < 4; i++) r.e[3-i] = a.e[3-(i-n)];
return r;
}
/* ----------------------------------------------------------------------------
* Arithmetic
* -------------------------------------------------------------------------- */
/**
* Arithmetic
*/
__attribute__((unused))
static int32x4_t vmull_s16(int16x4_t a, int16x4_t b)
{
int32x4_t r;
for (int i = 0; i < 4; i++)
r.e[i] = (int32_t)a.e[i] * b.e[i];
return r;
return (int32x4_t){ { a.e[0] * b.e[0], a.e[1] * b.e[1],
a.e[2] * b.e[2], a.e[3] * b.e[3] } };
}
__attribute__((unused))
static int32x4_t vmlal_s16(int32x4_t r, int16x4_t a, int16x4_t b)
{
for (int i = 0; i < 4; i++)
r.e[i] += (int32_t)a.e[i] * b.e[i];
return r;
return (int32x4_t){ {
r.e[0] + a.e[0] * b.e[0], r.e[1] + a.e[1] * b.e[1],
r.e[2] + a.e[2] * b.e[2], r.e[3] + a.e[3] * b.e[3] } };
}
__attribute__((unused))
@@ -122,9 +79,9 @@ static int64x2_t vpadalq_s32(int64x2_t a, int32x4_t b)
}
/* ----------------------------------------------------------------------------
* Reduce
* -------------------------------------------------------------------------- */
/**
* Reduce
*/
__attribute__((unused))
static int32_t vaddvq_s32(int32x4_t v)
@@ -138,4 +95,236 @@ static int64_t vaddvq_s64(int64x2_t v)
return v.e[0] + v.e[1];
}
/**
* Manipulation
*/
__attribute__((unused))
static int16x4_t vext_s16(int16x4_t a, int16x4_t b, const int n)
{
int16_t x[] = { a.e[0], a.e[1], a.e[2], a.e[3],
b.e[0], b.e[1], b.e[2], b.e[3] };
return (int16x4_t){ { x[n], x[n+1], x[n+2], x[n+3] } };
}
__attribute__((unused))
static int32x4_t vmovq_n_s32(uint32_t v)
{
return (int32x4_t){ { v, v, v, v } };
}
__attribute__((unused))
static int64x2_t vmovq_n_s64(int64_t v)
{
return (int64x2_t){ { v, v, } };
}
/* ----------------------------------------------------------------------------
* Floating Point
* -------------------------------------------------------------------------- */
typedef struct { float e[2]; } float32x2_t;
typedef struct { float e[4]; } float32x4_t;
typedef struct { float32x2_t val[2]; } float32x2x2_t;
typedef struct { float32x4_t val[2]; } float32x4x2_t;
/**
* Load / Store
*/
__attribute__((unused))
static float32x2_t vld1_f32(const float *p)
{
return (float32x2_t){ { p[0], p[1] } };
}
__attribute__((unused))
static float32x4_t vld1q_f32(const float *p)
{
return (float32x4_t){ { p[0], p[1], p[2], p[3] } };
}
__attribute__((unused))
static float32x4_t vld1q_dup_f32(const float *p)
{
return (float32x4_t){ { p[0], p[0], p[0], p[0] } };
}
__attribute__((unused))
static float32x2x2_t vld2_f32(const float *p)
{
return (float32x2x2_t){ .val[0] = { { p[0], p[2] } },
.val[1] = { { p[1], p[3] } } };
}
__attribute__((unused))
static float32x4x2_t vld2q_f32(const float *p)
{
return (float32x4x2_t){ .val[0] = { { p[0], p[2], p[4], p[6] } },
.val[1] = { { p[1], p[3], p[5], p[7] } } };
}
__attribute__((unused))
static void vst1_f32(float *p, float32x2_t v)
{
p[0] = v.e[0], p[1] = v.e[1];
}
__attribute__((unused))
static void vst1q_f32(float *p, float32x4_t v)
{
p[0] = v.e[0], p[1] = v.e[1], p[2] = v.e[2], p[3] = v.e[3];
}
/**
* Arithmetic
*/
__attribute__((unused))
static float32x2_t vneg_f32(float32x2_t a)
{
return (float32x2_t){ { -a.e[0], -a.e[1] } };
}
__attribute__((unused))
static float32x4_t vnegq_f32(float32x4_t a)
{
return (float32x4_t){ { -a.e[0], -a.e[1], -a.e[2], -a.e[3] } };
}
__attribute__((unused))
static float32x4_t vaddq_f32(float32x4_t a, float32x4_t b)
{
return (float32x4_t){ { a.e[0] + b.e[0], a.e[1] + b.e[1],
a.e[2] + b.e[2], a.e[3] + b.e[3] } };
}
__attribute__((unused))
static float32x4_t vsubq_f32(float32x4_t a, float32x4_t b)
{
return (float32x4_t){ { a.e[0] - b.e[0], a.e[1] - b.e[1],
a.e[2] - b.e[2], a.e[3] - b.e[3] } };
}
__attribute__((unused))
static float32x2_t vfma_f32(float32x2_t a, float32x2_t b, float32x2_t c)
{
return (float32x2_t){ {
a.e[0] + b.e[0] * c.e[0], a.e[1] + b.e[1] * c.e[1] } };
}
__attribute__((unused))
static float32x4_t vfmaq_f32(float32x4_t a, float32x4_t b, float32x4_t c)
{
return (float32x4_t){ {
a.e[0] + b.e[0] * c.e[0], a.e[1] + b.e[1] * c.e[1],
a.e[2] + b.e[2] * c.e[2], a.e[3] + b.e[3] * c.e[3] } };
}
__attribute__((unused))
static float32x2_t vfms_f32(float32x2_t a, float32x2_t b, float32x2_t c)
{
return (float32x2_t){ {
a.e[0] - b.e[0] * c.e[0], a.e[1] - b.e[1] * c.e[1] } };
}
__attribute__((unused))
static float32x4_t vfmsq_f32(float32x4_t a, float32x4_t b, float32x4_t c)
{
return (float32x4_t){ {
a.e[0] - b.e[0] * c.e[0], a.e[1] - b.e[1] * c.e[1],
a.e[2] - b.e[2] * c.e[2], a.e[3] - b.e[3] * c.e[3] } };
}
/**
* Manipulation
*/
__attribute__((unused))
static float32x2_t vcreate_f32(uint64_t u)
{
float *f = (float *)&u;
return (float32x2_t){ { f[0] , f[1] } };
}
__attribute__((unused))
static float32x4_t vcombine_f32(float32x2_t a, float32x2_t b)
{
return (float32x4_t){ { a.e[0], a.e[1], b.e[0], b.e[1] } };
}
__attribute__((unused))
static float32x2_t vget_low_f32(float32x4_t a)
{
return (float32x2_t){ { a.e[0], a.e[1] } };
}
__attribute__((unused))
static float32x2_t vget_high_f32(float32x4_t a)
{
return (float32x2_t){ { a.e[2], a.e[3] } };
}
__attribute__((unused))
static float32x4_t vmovq_n_f32(float v)
{
return (float32x4_t){ { v, v, v, v } };
}
__attribute__((unused))
static float32x2_t vrev64_f32(float32x2_t v)
{
return (float32x2_t){ { v.e[1], v.e[0] } };
}
__attribute__((unused))
static float32x4_t vrev64q_f32(float32x4_t v)
{
return (float32x4_t){ { v.e[1], v.e[0], v.e[3], v.e[2] } };
}
__attribute__((unused))
static float32x2_t vtrn1_f32(float32x2_t a, float32x2_t b)
{
return (float32x2_t){ { a.e[0], b.e[0] } };
}
__attribute__((unused))
static float32x2_t vtrn2_f32(float32x2_t a, float32x2_t b)
{
return (float32x2_t){ { a.e[1], b.e[1] } };
}
__attribute__((unused))
static float32x4_t vtrn1q_f32(float32x4_t a, float32x4_t b)
{
return (float32x4_t){ { a.e[0], b.e[0], a.e[2], b.e[2] } };
}
__attribute__((unused))
static float32x4_t vtrn2q_f32(float32x4_t a, float32x4_t b)
{
return (float32x4_t){ { a.e[1], b.e[1], a.e[3], b.e[3] } };
}
__attribute__((unused))
static float32x4_t vzip1q_f32(float32x4_t a, float32x4_t b)
{
return (float32x4_t){ { a.e[0], b.e[0], a.e[1], b.e[1] } };
}
__attribute__((unused))
static float32x4_t vzip2q_f32(float32x4_t a, float32x4_t b)
{
return (float32x4_t){ { a.e[2], b.e[2], a.e[3], b.e[3] } };
}
#endif /* __ARM_NEON */