@glassly/bluetooth-sdk 0.1.0-dev.26

package/android/lc3Lib/src/main/cpp/liblc3/liblc3/ltpf_neon.h

@@ -0,0 +1,281 @@
+/******************************************************************************
+ *
+ *  Copyright 2022 Google LLC
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at:
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ ******************************************************************************/
+
+#if __ARM_NEON && __ARM_ARCH_ISA_A64 && \
+        !defined(TEST_ARM) || defined(TEST_NEON)
+
+#ifndef TEST_NEON
+#include <arm_neon.h>
+#endif /* TEST_NEON */
+
+
+/**
+ * Import
+ */
+
+static inline int32_t filter_hp50(struct lc3_ltpf_hp50_state *, int32_t);
+
+
+/**
+ * Resample from 16 Khz to 12.8 KHz
+ */
+#ifndef resample_16k_12k8
+
+LC3_HOT static void neon_resample_16k_12k8(
+    struct lc3_ltpf_hp50_state *hp50, const int16_t *x, int16_t *y, int n)
+{
+    static const int16_t h[4][20] = {
+
+    {   -61,   214,  -398,   417,     0, -1052,  2686, -4529,  5997, 26233,
+       5997, -4529,  2686, -1052,     0,   417,  -398,   214,   -61,     0 },
+
+    {   -79,   180,  -213,     0,   598, -1522,  2389, -2427,     0, 24506,
+      13068, -5289,  1873,     0,  -752,   763,  -457,   156,     0,   -28 },
+
+    {   -61,    92,     0,  -323,   861, -1361,  1317,     0, -3885, 19741,
+      19741, -3885,     0,  1317, -1361,   861,  -323,     0,    92,   -61 },
+
+    {   -28,     0,   156,  -457,   763,  -752,     0,  1873, -5289, 13068,
+      24506,     0, -2427,  2389, -1522,   598,     0,  -213,   180,   -79 },
+
+    };
+
+    x -= 20 - 1;
+
+    for (int i = 0; i < 5*n; i += 5) {
+        const int16_t *hn = h[i & 3];
+        const int16_t *xn = x + (i >> 2);
+        int32x4_t un;
+
+        un = vmull_s16(    vld1_s16(xn), vld1_s16(hn)), xn += 4, hn += 4;
+        un = vmlal_s16(un, vld1_s16(xn), vld1_s16(hn)), xn += 4, hn += 4;
+        un = vmlal_s16(un, vld1_s16(xn), vld1_s16(hn)), xn += 4, hn += 4;
+        un = vmlal_s16(un, vld1_s16(xn), vld1_s16(hn)), xn += 4, hn += 4;
+        un = vmlal_s16(un, vld1_s16(xn), vld1_s16(hn)), xn += 4, hn += 4;
+
+        int32_t yn = filter_hp50(hp50, vaddvq_s32(un));
+        *(y++) = (yn + (1 << 15)) >> 16;
+    }
+}
+
+#ifndef TEST_NEON
+#define resample_16k_12k8 neon_resample_16k_12k8
+#endif
+
+#endif /* resample_16k_12k8 */
+
+/**
+ * Resample from 32 Khz to 12.8 KHz
+ */
+#ifndef resample_32k_12k8
+
+LC3_HOT static void neon_resample_32k_12k8(
+    struct lc3_ltpf_hp50_state *hp50, const int16_t *x, int16_t *y, int n)
+{
+    x -= 40 - 1;
+
+    static const int16_t h[2][40] = {
+
+    {   -30,   -31,    46,   107,     0,  -199,  -162,   209,   430,     0,
+       -681,  -526,   658,  1343,     0, -2264, -1943,  2999,  9871, 13116,
+       9871,  2999, -1943, -2264,     0,  1343,   658,  -526,  -681,     0,
+        430,   209,  -162,  -199,     0,   107,    46,   -31,   -30,     0 },
+
+    {   -14,   -39,     0,    90,    78,  -106,  -229,     0,   382,   299,
+       -376,  -761,     0,  1194,   937, -1214, -2644,     0,  6534, 12253,
+      12253,  6534,     0, -2644, -1214,   937,  1194,     0,  -761,  -376,
+        299,   382,     0,  -229,  -106,    78,    90,     0,   -39,   -14 },
+
+    };
+
+    for (int i = 0; i < 5*n; i += 5) {
+        const int16_t *hn = h[i & 1];
+        const int16_t *xn = x + (i >> 1);
+
+        int32x4_t un = vmull_s16(vld1_s16(xn), vld1_s16(hn));
+        xn += 4, hn += 4;
+
+        for (int i = 1; i < 10; i++)
+            un = vmlal_s16(un, vld1_s16(xn), vld1_s16(hn)), xn += 4, hn += 4;
+
+        int32_t yn = filter_hp50(hp50, vaddvq_s32(un));
+        *(y++) = (yn + (1 << 15)) >> 16;
+    }
+}
+
+#ifndef TEST_NEON
+#define resample_32k_12k8 neon_resample_32k_12k8
+#endif
+
+#endif /* resample_32k_12k8 */
+
+/**
+ * Resample from 48 Khz to 12.8 KHz
+ */
+#ifndef resample_48k_12k8
+
+LC3_HOT static void neon_resample_48k_12k8(
+    struct lc3_ltpf_hp50_state *hp50, const int16_t *x, int16_t *y, int n)
+{
+    static const int16_t alignas(16) h[4][64] = {
+
+    {  -13,   -25,   -20,    10,    51,    71,    38,   -47,  -133,  -145,
+       -42,   139,   277,   242,     0,  -329,  -511,  -351,   144,   698,
+       895,   450,  -535, -1510, -1697,  -521,  1999,  5138,  7737,  8744,
+      7737,  5138,  1999,  -521, -1697, -1510,  -535,   450,   895,   698,
+       144,  -351,  -511,  -329,     0,   242,   277,   139,   -42,  -145,
+      -133,   -47,    38,    71,    51,    10,   -20,   -25,   -13,     0 },
+
+    {   -9,   -23,   -24,     0,    41,    71,    52,   -23,  -115,  -152,
+       -78,    92,   254,   272,    76,  -251,  -493,  -427,     0,   576,
+       900,   624,  -262, -1309, -1763,  -954,  1272,  4356,  7203,  8679,
+      8169,  5886,  2767,     0, -1542, -1660,  -809,   240,   848,   796,
+       292,  -252,  -507,  -398,   -82,   199,   288,   183,     0,  -130,
+      -145,   -71,    20,    69,    60,    20,   -15,   -26,   -17,    -3 },
+
+    {   -6,   -20,   -26,    -8,    31,    67,    62,     0,   -94,  -152,
+      -108,    45,   223,   287,   143,  -167,  -454,  -480,  -134,   439,
+       866,   758,     0, -1071, -1748, -1295,   601,  3559,  6580,  8485,
+      8485,  6580,  3559,   601, -1295, -1748, -1071,     0,   758,   866,
+       439,  -134,  -480,  -454,  -167,   143,   287,   223,    45,  -108,
+      -152,   -94,     0,    62,    67,    31,    -8,   -26,   -20,    -6 },
+
+    {   -3,   -17,   -26,   -15,    20,    60,    69,    20,   -71,  -145,
+      -130,     0,   183,   288,   199,   -82,  -398,  -507,  -252,   292,
+       796,   848,   240,  -809, -1660, -1542,     0,  2767,  5886,  8169,
+      8679,  7203,  4356,  1272,  -954, -1763, -1309,  -262,   624,   900,
+       576,     0,  -427,  -493,  -251,    76,   272,   254,    92,   -78,
+      -152,  -115,   -23,    52,    71,    41,     0,   -24,   -23,    -9 },
+
+    };
+
+    x -= 60 - 1;
+
+    for (int i = 0; i < 15*n; i += 15) {
+        const int16_t *hn = h[i & 3];
+        const int16_t *xn = x + (i >> 2);
+
+        int32x4_t un = vmull_s16(vld1_s16(xn), vld1_s16(hn));
+        xn += 4, hn += 4;
+
+        for (int i = 1; i < 15; i++)
+            un = vmlal_s16(un, vld1_s16(xn), vld1_s16(hn)), xn += 4, hn += 4;
+
+        int32_t yn = filter_hp50(hp50, vaddvq_s32(un));
+        *(y++) = (yn + (1 << 15)) >> 16;
+    }
+}
+
+#ifndef TEST_NEON
+#define resample_48k_12k8 neon_resample_48k_12k8
+#endif
+
+#endif /* resample_48k_12k8 */
+
+/**
+ * Return dot product of 2 vectors
+ */
+#ifndef dot
+
+LC3_HOT static inline float neon_dot(const int16_t *a, const int16_t *b, int n)
+{
+    int64x2_t v = vmovq_n_s64(0);
+
+    for (int i = 0; i < (n >> 4); i++) {
+        int32x4_t u;
+
+        u = vmull_s16(   vld1_s16(a), vld1_s16(b)), a += 4, b += 4;
+        u = vmlal_s16(u, vld1_s16(a), vld1_s16(b)), a += 4, b += 4;
+        v = vpadalq_s32(v, u);
+
+        u = vmull_s16(   vld1_s16(a), vld1_s16(b)), a += 4, b += 4;
+        u = vmlal_s16(u, vld1_s16(a), vld1_s16(b)), a += 4, b += 4;
+        v = vpadalq_s32(v, u);
+    }
+
+    int32_t v32 = (vaddvq_s64(v) + (1 << 5)) >> 6;
+    return (float)v32;
+}
+
+#ifndef TEST_NEON
+#define dot neon_dot
+#endif
+
+#endif /* dot */
+
+/**
+ * Return vector of correlations
+ */
+#ifndef correlate
+
+LC3_HOT static void neon_correlate(
+    const int16_t *a, const int16_t *b, int n, float *y, int nc)
+{
+    for ( ; nc >= 4; nc -= 4, b -= 4) {
+        const int16_t *an = (const int16_t *)a;
+        const int16_t *bn = (const int16_t *)b;
+
+        int64x2_t v0 = vmovq_n_s64(0), v1 = v0, v2 = v0, v3 = v0;
+        int16x4_t ax, b0, b1;
+
+        b0 = vld1_s16(bn-4);
+
+        for (int i=0; i < (n >> 4); i++ )
+            for (int j = 0; j < 2; j++) {
+                int32x4_t u0, u1, u2, u3;
+
+                b1 = b0;
+                b0 = vld1_s16(bn), bn += 4;
+                ax = vld1_s16(an), an += 4;
+
+                u0 = vmull_s16(ax, b0);
+                u1 = vmull_s16(ax, vext_s16(b1, b0, 3));
+                u2 = vmull_s16(ax, vext_s16(b1, b0, 2));
+                u3 = vmull_s16(ax, vext_s16(b1, b0, 1));
+
+                b1 = b0;
+                b0 = vld1_s16(bn), bn += 4;
+                ax = vld1_s16(an), an += 4;
+
+                u0 = vmlal_s16(u0, ax, b0);
+                u1 = vmlal_s16(u1, ax, vext_s16(b1, b0, 3));
+                u2 = vmlal_s16(u2, ax, vext_s16(b1, b0, 2));
+                u3 = vmlal_s16(u3, ax, vext_s16(b1, b0, 1));
+
+                v0 = vpadalq_s32(v0, u0);
+                v1 = vpadalq_s32(v1, u1);
+                v2 = vpadalq_s32(v2, u2);
+                v3 = vpadalq_s32(v3, u3);
+            }
+
+        *(y++) = (float)((int32_t)((vaddvq_s64(v0) + (1 << 5)) >> 6));
+        *(y++) = (float)((int32_t)((vaddvq_s64(v1) + (1 << 5)) >> 6));
+        *(y++) = (float)((int32_t)((vaddvq_s64(v2) + (1 << 5)) >> 6));
+        *(y++) = (float)((int32_t)((vaddvq_s64(v3) + (1 << 5)) >> 6));
+    }
+
+    for ( ; nc > 0; nc--)
+        *(y++) = neon_dot(a, b--, n);
+}
+#endif /* correlate */
+
+#ifndef TEST_NEON
+#define correlate neon_correlate
+#endif
+
+#endif /* __ARM_NEON && __ARM_ARCH_ISA_A64 */

package/android/lc3Lib/src/main/cpp/liblc3/liblc3/makefile.mk

@@ -0,0 +1,35 @@
+#
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at:
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+liblc3_src += \
+    $(SRC_DIR)/attdet.c \
+    $(SRC_DIR)/bits.c \
+    $(SRC_DIR)/bwdet.c \
+    $(SRC_DIR)/energy.c \
+    $(SRC_DIR)/lc3.c \
+    $(SRC_DIR)/ltpf.c \
+    $(SRC_DIR)/mdct.c \
+    $(SRC_DIR)/plc.c \
+    $(SRC_DIR)/sns.c \
+    $(SRC_DIR)/spec.c \
+    $(SRC_DIR)/tables.c \
+    $(SRC_DIR)/tns.c
+
+liblc3_cflags += -ffast-math
+
+$(eval $(call add-lib,liblc3))
+
+default: liblc3