@mentra/bluetooth-sdk 0.1.0

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

@@ -0,0 +1,94 @@
+/******************************************************************************
+ *
+ *  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.
+ *
+ ******************************************************************************/
+
+#ifndef __LC3_TABLES_H
+#define __LC3_TABLES_H
+
+#include "common.h"
+#include "bits.h"
+
+
+/**
+ * MDCT Twiddles and window coefficients
+ */
+
+struct lc3_fft_bf3_twiddles { int n3; const struct lc3_complex (*t)[2]; };
+struct lc3_fft_bf2_twiddles { int n2; const struct lc3_complex *t; };
+struct lc3_mdct_rot_def { int n4; const struct lc3_complex *w; };
+
+extern const struct lc3_fft_bf3_twiddles *lc3_fft_twiddles_bf3[];
+extern const struct lc3_fft_bf2_twiddles *lc3_fft_twiddles_bf2[][3];
+extern const struct lc3_mdct_rot_def *lc3_mdct_rot[LC3_NUM_DT][LC3_NUM_SRATE];
+
+extern const float *lc3_mdct_win[LC3_NUM_DT][LC3_NUM_SRATE];
+
+
+/**
+ * Limits of bands
+ */
+
+#define LC3_NUM_BANDS  64
+
+extern const int lc3_band_lim[LC3_NUM_DT][LC3_NUM_SRATE][LC3_NUM_BANDS+1];
+
+
+/**
+ * SNS Quantization
+ */
+
+extern const float lc3_sns_lfcb[32][8];
+extern const float lc3_sns_hfcb[32][8];
+
+struct lc3_sns_vq_gains {
+    int count; const float *v;
+};
+
+extern const struct lc3_sns_vq_gains lc3_sns_vq_gains[4];
+
+extern const int32_t lc3_sns_mpvq_offsets[][11];
+
+
+/**
+ * TNS Arithmetic Coding
+ */
+
+extern const struct lc3_ac_model lc3_tns_order_models[];
+extern const uint16_t lc3_tns_order_bits[][8];
+
+extern const struct lc3_ac_model lc3_tns_coeffs_models[];
+extern const uint16_t lc3_tns_coeffs_bits[][17];
+
+
+/**
+ * Long Term Postfilter
+ */
+
+extern const float *lc3_ltpf_cnum[LC3_NUM_SRATE][4];
+extern const float *lc3_ltpf_cden[LC3_NUM_SRATE][4];
+
+
+/**
+ * Spectral Data Arithmetic Coding
+ */
+
+extern const uint8_t lc3_spectrum_lookup[2][2][256][4];
+extern const struct lc3_ac_model lc3_spectrum_models[];
+extern const uint16_t lc3_spectrum_bits[][17];
+
+
+#endif /* __LC3_TABLES_H */

package/android/lc3Lib/src/main/cpp/liblc3/liblc3/tns.c

@@ -0,0 +1,457 @@
+/******************************************************************************
+ *
+ *  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.
+ *
+ ******************************************************************************/
+
+#include "tns.h"
+#include "tables.h"
+
+
+/* ----------------------------------------------------------------------------
+ *  Filter Coefficients
+ * -------------------------------------------------------------------------- */
+
+/**
+ * Resolve LPC Weighting indication according bitrate
+ * dt, nbytes      Duration and size of the frame
+ * return          True when LPC Weighting enabled
+ */
+static bool resolve_lpc_weighting(enum lc3_dt dt, int nbytes)
+{
+    return nbytes < (dt == LC3_DT_7M5 ? 360/8 : 480/8);
+}
+
+/**
+ * Return dot product of 2 vectors
+ * a, b, n         The 2 vectors of size `n`
+ * return          sum( a[i] * b[i] ), i = [0..n-1]
+ */
+LC3_HOT static inline float dot(const float *a, const float *b, int n)
+{
+    float v = 0;
+
+    while (n--)
+        v += *(a++) * *(b++);
+
+    return v;
+}
+
+/**
+ * LPC Coefficients
+ * dt, bw          Duration and bandwidth of the frame
+ * x               Spectral coefficients
+ * gain, a         Output the prediction gains and LPC coefficients
+ */
+LC3_HOT static void compute_lpc_coeffs(
+    enum lc3_dt dt, enum lc3_bandwidth bw,
+    const float *x, float *gain, float (*a)[9])
+{
+    static const int sub_7m5_nb[]   = {  9, 26,  43,  60 };
+    static const int sub_7m5_wb[]   = {  9, 46,  83, 120 };
+    static const int sub_7m5_sswb[] = {  9, 66, 123, 180 };
+    static const int sub_7m5_swb[]  = {  9, 46,  82, 120, 159, 200, 240 };
+    static const int sub_7m5_fb[]   = {  9, 56, 103, 150, 200, 250, 300 };
+
+    static const int sub_10m_nb[]   = { 12, 34,  57,  80 };
+    static const int sub_10m_wb[]   = { 12, 61, 110, 160 };
+    static const int sub_10m_sswb[] = { 12, 88, 164, 240 };
+    static const int sub_10m_swb[]  = { 12, 61, 110, 160, 213, 266, 320 };
+    static const int sub_10m_fb[]   = { 12, 74, 137, 200, 266, 333, 400 };
+
+    /* --- Normalized autocorrelation --- */
+
+    static const float lag_window[] = {
+        1.00000000e+00, 9.98028026e-01, 9.92135406e-01, 9.82391584e-01,
+        9.68910791e-01, 9.51849807e-01, 9.31404933e-01, 9.07808230e-01,
+        8.81323137e-01
+    };
+
+    const int *sub = (const int * const [LC3_NUM_DT][LC3_NUM_SRATE]){
+        { sub_7m5_nb, sub_7m5_wb, sub_7m5_sswb, sub_7m5_swb, sub_7m5_fb },
+        { sub_10m_nb, sub_10m_wb, sub_10m_sswb, sub_10m_swb, sub_10m_fb },
+    }[dt][bw];
+
+    int nfilters = 1 + (bw >= LC3_BANDWIDTH_SWB);
+
+    const float *xs, *xe = x + *sub;
+    float r[2][9];
+
+    for (int f = 0; f < nfilters; f++) {
+        float c[9][3];
+
+        for (int s = 0; s < 3; s++) {
+            xs = xe, xe = x + *(++sub);
+
+            for (int k = 0; k < 9; k++)
+                c[k][s] = dot(xs, xs + k, (xe - xs) - k);
+        }
+
+        float e0 = c[0][0], e1 = c[0][1], e2 = c[0][2];
+
+        r[f][0] = 3;
+        for (int k = 1; k < 9; k++)
+            r[f][k] = e0 == 0 || e1 == 0 || e2 == 0 ? 0 :
+                (c[k][0]/e0 + c[k][1]/e1 + c[k][2]/e2) * lag_window[k];
+    }
+
+    /* --- Levinson-Durbin recursion --- */
+
+    for (int f = 0; f < nfilters; f++) {
+        float *a0 = a[f], a1[9];
+        float err = r[f][0], rc;
+
+        gain[f] = err;
+
+        a0[0] = 1;
+        for (int k = 1; k < 9; ) {
+
+            rc = -r[f][k];
+            for (int i = 1; i < k; i++)
+                rc -= a0[i] * r[f][k-i];
+
+            rc /= err;
+            err *= 1 - rc * rc;
+
+            for (int i = 1; i < k; i++)
+                a1[i] = a0[i] + rc * a0[k-i];
+            a1[k++] = rc;
+
+            rc = -r[f][k];
+            for (int i = 1; i < k; i++)
+                rc -= a1[i] * r[f][k-i];
+
+            rc /= err;
+            err *= 1 - rc * rc;
+
+            for (int i = 1; i < k; i++)
+                a0[i] = a1[i] + rc * a1[k-i];
+            a0[k++] = rc;
+        }
+
+        gain[f] /= err;
+    }
+}
+
+/**
+ * LPC Weighting
+ * gain, a         Prediction gain and LPC coefficients, weighted as output
+ */
+LC3_HOT static void lpc_weighting(float pred_gain, float *a)
+{
+    float gamma = 1.f - (1.f - 0.85f) * (2.f - pred_gain) / (2.f - 1.5f);
+    float g = 1.f;
+
+    for (int i = 1; i < 9; i++)
+        a[i] *= (g *= gamma);
+}
+
+/**
+ * LPC reflection
+ * a               LPC coefficients
+ * rc              Output refelection coefficients
+ */
+LC3_HOT static void lpc_reflection(const float *a, float *rc)
+{
+    float e, b[2][7], *b0, *b1;
+
+    rc[7] = a[1+7];
+    e = 1 - rc[7] * rc[7];
+
+    b1 = b[1];
+    for (int i = 0; i < 7; i++)
+        b1[i] = (a[1+i] - rc[7] * a[7-i]) / e;
+
+    for (int k = 6; k > 0; k--) {
+        b0 = b1, b1 = b[k & 1];
+
+        rc[k] = b0[k];
+        e = 1 - rc[k] * rc[k];
+
+        for (int i = 0; i < k; i++)
+            b1[i] = (b0[i] - rc[k] * b0[k-1-i]) / e;
+    }
+
+    rc[0] = b1[0];
+}
+
+/**
+ * Quantization of RC coefficients
+ * rc              Refelection coefficients
+ * rc_order        Return order of coefficients
+ * rc_i            Return quantized coefficients
+ */
+static void quantize_rc(const float *rc, int *rc_order, int *rc_q)
+{
+    /* Quantization table, sin(delta * (i + 0.5)), delta = Pi / 17 */
+
+    static float q_thr[] = {
+        9.22683595e-02, 2.73662990e-01, 4.45738356e-01, 6.02634636e-01,
+        7.39008917e-01, 8.50217136e-01, 9.32472229e-01, 9.82973100e-01
+    };
+
+    *rc_order = 8;
+
+    for (int i = 0; i < 8; i++) {
+        float rc_m = fabsf(rc[i]);
+
+        rc_q[i] = 4 * (rc_m >= q_thr[4]);
+        for (int j = 0; j < 4 && rc_m >= q_thr[rc_q[i]]; j++, rc_q[i]++);
+
+        if (rc[i] < 0)
+            rc_q[i] = -rc_q[i];
+
+        *rc_order = rc_q[i] != 0 ? 8 : *rc_order - 1;
+    }
+}
+
+/**
+ * Unquantization of RC coefficients
+ * rc_q            Quantized coefficients
+ * rc_order        Order of coefficients
+ * rc              Return refelection coefficients
+ */
+static void unquantize_rc(const int *rc_q, int rc_order, float rc[8])
+{
+    /* Quantization table, sin(delta * i), delta = Pi / 17 */
+
+    static float q_inv[] = {
+        0.00000000e+00, 1.83749517e-01, 3.61241664e-01, 5.26432173e-01,
+        6.73695641e-01, 7.98017215e-01, 8.95163302e-01, 9.61825645e-01,
+        9.95734176e-01
+    };
+
+    int i;
+
+    for (i = 0; i < rc_order; i++) {
+        float rc_m = q_inv[LC3_ABS(rc_q[i])];
+        rc[i] = rc_q[i] < 0 ? -rc_m : rc_m;
+    }
+}
+
+
+/* ----------------------------------------------------------------------------
+ *  Filtering
+ * -------------------------------------------------------------------------- */
+
+/**
+ * Forward filtering
+ * dt, bw          Duration and bandwidth of the frame
+ * rc_order, rc    Order of coefficients, and coefficients
+ * x               Spectral coefficients, filtered as output
+ */
+LC3_HOT static void forward_filtering(
+    enum lc3_dt dt, enum lc3_bandwidth bw,
+    const int rc_order[2], const float rc[2][8], float *x)
+{
+    int nfilters = 1 + (bw >= LC3_BANDWIDTH_SWB);
+    int nf = LC3_NE(dt, bw) >> (nfilters - 1);
+    int i0, ie = 3*(3 + dt);
+
+    float s[8] = { 0 };
+
+    for (int f = 0; f < nfilters; f++) {
+
+        i0 = ie;
+        ie = nf * (1 + f);
+
+        if (!rc_order[f])
+            continue;
+
+        for (int i = i0; i < ie; i++) {
+            float xi = x[i];
+            float s0, s1 = xi;
+
+            for (int k = 0; k < rc_order[f]; k++) {
+                s0 = s[k];
+                s[k] = s1;
+
+                s1  = rc[f][k] * xi + s0;
+                xi += rc[f][k] * s0;
+            }
+
+            x[i] = xi;
+        }
+    }
+}
+
+/**
+ * Inverse filtering
+ * dt, bw          Duration and bandwidth of the frame
+ * rc_order, rc    Order of coefficients, and unquantized coefficients
+ * x               Spectral coefficients, filtered as output
+ */
+LC3_HOT static void inverse_filtering(
+    enum lc3_dt dt, enum lc3_bandwidth bw,
+    const int rc_order[2], const float rc[2][8], float *x)
+{
+    int nfilters = 1 + (bw >= LC3_BANDWIDTH_SWB);
+    int nf = LC3_NE(dt, bw) >> (nfilters - 1);
+    int i0, ie = 3*(3 + dt);
+
+    float s[8] = { 0 };
+
+    for (int f = 0; f < nfilters; f++) {
+
+        i0 = ie;
+        ie = nf * (1 + f);
+
+        if (!rc_order[f])
+            continue;
+
+        for (int i = i0; i < ie; i++) {
+            float xi = x[i];
+
+            xi -= s[7] * rc[f][7];
+            for (int k = 6; k >= 0; k--) {
+                xi -= s[k] * rc[f][k];
+                s[k+1] = s[k] + rc[f][k] * xi;
+            }
+            s[0] = xi;
+            x[i] = xi;
+        }
+
+        for (int k = 7; k >= rc_order[f]; k--)
+            s[k] = 0;
+    }
+}
+
+
+/* ----------------------------------------------------------------------------
+ *  Interface
+ * -------------------------------------------------------------------------- */
+
+/**
+ * TNS analysis
+ */
+void lc3_tns_analyze(enum lc3_dt dt, enum lc3_bandwidth bw,
+    bool nn_flag, int nbytes, struct lc3_tns_data *data, float *x)
+{
+    /* Processing steps :
+     * - Determine the LPC (Linear Predictive Coding) Coefficients
+     * - Check is the filtering is disabled
+     * - The coefficients are weighted on low bitrates and predicition gain
+     * - Convert to reflection coefficients and quantize
+     * - Finally filter the spectral coefficients */
+
+    float pred_gain[2], a[2][9];
+    float rc[2][8];
+
+    data->nfilters = 1 + (bw >= LC3_BANDWIDTH_SWB);
+    data->lpc_weighting = resolve_lpc_weighting(dt, nbytes);
+
+    compute_lpc_coeffs(dt, bw, x, pred_gain, a);
+
+    for (int f = 0; f < data->nfilters; f++) {
+
+        data->rc_order[f] = 0;
+        if (nn_flag || pred_gain[f] <= 1.5f)
+            continue;
+
+        if (data->lpc_weighting && pred_gain[f] < 2.f)
+            lpc_weighting(pred_gain[f], a[f]);
+
+        lpc_reflection(a[f], rc[f]);
+
+        quantize_rc(rc[f], &data->rc_order[f], data->rc[f]);
+        unquantize_rc(data->rc[f], data->rc_order[f], rc[f]);
+    }
+
+    forward_filtering(dt, bw, data->rc_order, rc, x);
+}
+
+/**
+ * TNS synthesis
+ */
+void lc3_tns_synthesize(enum lc3_dt dt, enum lc3_bandwidth bw,
+    const struct lc3_tns_data *data, float *x)
+{
+    float rc[2][8] = { };
+
+    for (int f = 0; f < data->nfilters; f++)
+        if (data->rc_order[f])
+            unquantize_rc(data->rc[f], data->rc_order[f], rc[f]);
+
+    inverse_filtering(dt, bw, data->rc_order, rc, x);
+}
+
+/**
+ * Bit consumption of bitstream data
+ */
+int lc3_tns_get_nbits(const struct lc3_tns_data *data)
+{
+    int nbits = 0;
+
+    for (int f = 0; f < data->nfilters; f++) {
+
+        int nbits_2048 = 2048;
+        int rc_order = data->rc_order[f];
+
+        nbits_2048 += rc_order > 0 ? lc3_tns_order_bits
+            [data->lpc_weighting][rc_order-1] : 0;
+
+        for (int i = 0; i < rc_order; i++)
+            nbits_2048 += lc3_tns_coeffs_bits[i][8 + data->rc[f][i]];
+
+        nbits += (nbits_2048 + (1 << 11) - 1) >> 11;
+    }
+
+    return nbits;
+}
+
+/**
+ * Put bitstream data
+ */
+void lc3_tns_put_data(lc3_bits_t *bits, const struct lc3_tns_data *data)
+{
+    for (int f = 0; f < data->nfilters; f++) {
+        int rc_order = data->rc_order[f];
+
+        lc3_put_bits(bits, rc_order > 0, 1);
+        if (rc_order <= 0)
+            continue;
+
+        lc3_put_symbol(bits,
+            lc3_tns_order_models + data->lpc_weighting, rc_order-1);
+
+        for (int i = 0; i < rc_order; i++)
+            lc3_put_symbol(bits,
+                lc3_tns_coeffs_models + i, 8 + data->rc[f][i]);
+    }
+}
+
+/**
+ * Get bitstream data
+ */
+void lc3_tns_get_data(lc3_bits_t *bits,
+    enum lc3_dt dt, enum lc3_bandwidth bw, int nbytes, lc3_tns_data_t *data)
+{
+    data->nfilters = 1 + (bw >= LC3_BANDWIDTH_SWB);
+    data->lpc_weighting = resolve_lpc_weighting(dt, nbytes);
+
+    for (int f = 0; f < data->nfilters; f++) {
+
+        data->rc_order[f] = lc3_get_bit(bits);
+        if (!data->rc_order[f])
+            continue;
+
+        data->rc_order[f] += lc3_get_symbol(bits,
+            lc3_tns_order_models + data->lpc_weighting);
+
+        for (int i = 0; i < data->rc_order[f]; i++)
+            data->rc[f][i] = (int)lc3_get_symbol(bits,
+                lc3_tns_coeffs_models + i) - 8;
+    }
+}

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

@@ -0,0 +1,99 @@
+/******************************************************************************
+ *
+ *  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.
+ *
+ ******************************************************************************/
+
+/**
+ * LC3 - Temporal Noise Shaping
+ *
+ * Reference : Low Complexity Communication Codec (LC3)
+ *             Bluetooth Specification v1.0
+ */
+
+#ifndef __LC3_TNS_H
+#define __LC3_TNS_H
+
+#include "common.h"
+#include "bits.h"
+
+
+/**
+ * Bitstream data
+ */
+
+typedef struct lc3_tns_data {
+    int nfilters;
+    bool lpc_weighting;
+    int rc_order[2];
+    int rc[2][8];
+} lc3_tns_data_t;
+
+
+/* ----------------------------------------------------------------------------
+ *  Encoding
+ * -------------------------------------------------------------------------- */
+
+/**
+ * TNS analysis
+ * dt, bw          Duration and bandwidth of the frame
+ * nn_flag         True when high energy detected near Nyquist frequency
+ * nbytes          Size in bytes of the frame
+ * data            Return bitstream data
+ * x               Spectral coefficients, filtered as output
+ */
+void lc3_tns_analyze(enum lc3_dt dt, enum lc3_bandwidth bw,
+    bool nn_flag, int nbytes, lc3_tns_data_t *data, float *x);
+
+/**
+ * Return number of bits coding the data
+ * data            Bitstream data
+ * return          Bit consumption
+ */
+int lc3_tns_get_nbits(const lc3_tns_data_t *data);
+
+/**
+ * Put bitstream data
+ * bits            Bitstream context
+ * data            Bitstream data
+ */
+void lc3_tns_put_data(lc3_bits_t *bits, const lc3_tns_data_t *data);
+
+
+/* ----------------------------------------------------------------------------
+ *  Decoding
+ * -------------------------------------------------------------------------- */
+
+/**
+ * Get bitstream data
+ * bits            Bitstream context
+ * dt, bw          Duration and bandwidth of the frame
+ * nbytes          Size in bytes of the frame
+ * data            Bitstream data
+ */
+void lc3_tns_get_data(lc3_bits_t *bits,
+    enum lc3_dt dt, enum lc3_bandwidth bw, int nbytes, lc3_tns_data_t *data);
+
+/**
+ * TNS synthesis
+ * dt, bw          Duration and bandwidth of the frame
+ * data            Bitstream data
+ * x               Spectral coefficients, filtered as output
+ */
+void lc3_tns_synthesize(enum lc3_dt dt, enum lc3_bandwidth bw,
+    const lc3_tns_data_t *data, float *x);
+
+
+#endif /* __LC3_TNS_H */