@mentra/bluetooth-sdk 0.1.0

package/ios/Packages/CoreObjC/bits.h

@@ -0,0 +1,315 @@
+/******************************************************************************
+ *
+ *  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 - Bitstream management
+ *
+ * The bitstream is written by the 2 ends of the buffer :
+ *
+ * - Arthmetic coder put bits while increasing memory addresses
+ *   in the buffer (forward)
+ *
+ * - Plain bits are puts starting the end of the buffer, with memeory
+ *   addresses decreasing (backward)
+ *
+ *       .---------------------------------------------------.
+ *       | > > > > > > > > > > :         : < < < < < < < < < |
+ *       '---------------------------------------------------'
+ *       |---------------------> - - - - - - - - - - - - - ->|
+ *                              |< - - - <-------------------|
+ *          Arithmetic coding                  Plain bits
+ *          `lc3_put_symbol()`               `lc3_put_bits()`
+ *
+ * - The forward writing is protected against buffer overflow, it cannot
+ *   write after the buffer, but can overwrite plain bits previously
+ *   written in the buffer.
+ *
+ * - The backward writing is protected against overwrite of the arithmetic
+ *   coder bitstream. In such way, the backward bitstream is always limited
+ *   by the aritmetic coder bitstream, and can be overwritten by him.
+ *
+ *       .---------------------------------------------------.
+ *       | > > > > > > > > > > :         : < < < < < < < < < |
+ *       '---------------------------------------------------'
+ *       |---------------------> - - - - - - - - - - - - - ->|
+ *       |< - - - - - - - - - - -  - - - <-------------------|
+ *          Arithmetic coding                  Plain bits
+ *          `lc3_get_symbol()`               `lc3_get_bits()`
+ *
+ * - Reading is limited to read of the complementary end of the buffer.
+ *
+ * - The procedure `lc3_check_bits()` returns indication that read has been
+ *   made crossing the other bit plane.
+ *
+ *
+ * Reference : Low Complexity Communication Codec (LC3)
+ *             Bluetooth Specification v1.0
+ *
+ */
+
+#ifndef __LC3_BITS_H
+#define __LC3_BITS_H
+
+#include "common.h"
+
+
+/**
+ * Bitstream mode
+ */
+
+enum lc3_bits_mode {
+    LC3_BITS_MODE_READ,
+    LC3_BITS_MODE_WRITE,
+};
+
+/**
+ * Arithmetic coder symbol interval
+ * The model split the interval in 17 symbols
+ */
+
+struct lc3_ac_symbol {
+    uint16_t low   : 16;
+    uint16_t range : 16;
+};
+
+struct lc3_ac_model {
+    struct lc3_ac_symbol s[17];
+};
+
+/**
+ * Bitstream context
+ */
+
+#define LC3_ACCU_BITS (int)(8 * sizeof(unsigned))
+
+struct lc3_bits_accu {
+    unsigned v;
+    int n, nover;
+};
+
+#define LC3_AC_BITS (int)(24)
+
+struct lc3_bits_ac {
+    unsigned low, range;
+    int cache, carry, carry_count;
+    bool error;
+};
+
+struct lc3_bits_buffer {
+    const uint8_t *start, *end;
+    uint8_t *p_fw, *p_bw;
+};
+
+typedef struct lc3_bits {
+    enum lc3_bits_mode mode;
+    struct lc3_bits_ac ac;
+    struct lc3_bits_accu accu;
+    struct lc3_bits_buffer buffer;
+} lc3_bits_t;
+
+
+/**
+ * Setup bitstream reading/writing
+ * bits            Bitstream context
+ * mode            Either READ or WRITE mode
+ * buffer, len     Output buffer and length (in bytes)
+ */
+void lc3_setup_bits(lc3_bits_t *bits,
+    enum lc3_bits_mode mode, void *buffer, int len);
+
+/**
+ * Return number of bits left in the bitstream
+ * bits            Bitstream context
+ * return          Number of bits left
+ */
+int lc3_get_bits_left(const lc3_bits_t *bits);
+
+/**
+ * Check if error occured on bitstream reading/writing
+ * bits            Bitstream context
+ * return          0: Ok  -1: Bitstream overflow or AC reading error
+ */
+int lc3_check_bits(const lc3_bits_t *bits);
+
+/**
+ * Put a bit
+ * bits            Bitstream context
+ * v               Bit value, 0 or 1
+ */
+static inline void lc3_put_bit(lc3_bits_t *bits, int v);
+
+/**
+ * Put from 1 to 32 bits
+ * bits            Bitstream context
+ * v, n            Value, in range 0 to 2^n - 1, and bits count (1 to 32)
+ */
+static inline void lc3_put_bits(lc3_bits_t *bits, unsigned v, int n);
+
+/**
+ * Put arithmetic coder symbol
+ * bits            Bitstream context
+ * model, s        Model distribution and symbol value
+ */
+static inline void lc3_put_symbol(lc3_bits_t *bits,
+    const struct lc3_ac_model *model, unsigned s);
+
+/**
+ * Flush and terminate bitstream writing
+ * bits            Bitstream context
+ */
+void lc3_flush_bits(lc3_bits_t *bits);
+
+/**
+ * Get a bit
+ * bits            Bitstream context
+ */
+static inline int lc3_get_bit(lc3_bits_t *bits);
+
+/**
+ * Get from 1 to 32 bits
+ * bits            Bitstream context
+ * n               Number of bits to read (1 to 32)
+ * return          The value read
+ */
+static inline unsigned lc3_get_bits(lc3_bits_t *bits,  int n);
+
+/**
+ * Get arithmetic coder symbol
+ * bits            Bitstream context
+ * model           Model distribution
+ * return          The value read
+ */
+static inline unsigned lc3_get_symbol(lc3_bits_t *bits,
+    const struct lc3_ac_model *model);
+
+
+
+/* ----------------------------------------------------------------------------
+ *  Inline implementations
+ * -------------------------------------------------------------------------- */
+
+void lc3_put_bits_generic(lc3_bits_t *bits, unsigned v, int n);
+unsigned lc3_get_bits_generic(struct lc3_bits *bits, int n);
+
+void lc3_ac_read_renorm(lc3_bits_t *bits);
+void lc3_ac_write_renorm(lc3_bits_t *bits);
+
+
+/**
+ * Put a bit
+ */
+LC3_HOT static inline void lc3_put_bit(lc3_bits_t *bits, int v)
+{
+    lc3_put_bits(bits, v, 1);
+}
+
+/**
+ * Put from 1 to 32 bits
+ */
+LC3_HOT static inline void lc3_put_bits(
+    struct lc3_bits *bits, unsigned v, int n)
+{
+    struct lc3_bits_accu *accu = &bits->accu;
+
+    if (accu->n + n <= LC3_ACCU_BITS) {
+        accu->v |= v << accu->n;
+        accu->n += n;
+    } else {
+        lc3_put_bits_generic(bits, v, n);
+    }
+}
+
+/**
+ * Get a bit
+ */
+LC3_HOT static inline int lc3_get_bit(lc3_bits_t *bits)
+{
+    return lc3_get_bits(bits, 1);
+}
+
+/**
+ * Get from 1 to 32 bits
+ */
+LC3_HOT static inline unsigned lc3_get_bits(struct lc3_bits *bits, int n)
+{
+    struct lc3_bits_accu *accu = &bits->accu;
+
+    if (accu->n + n <= LC3_ACCU_BITS) {
+        int v = (accu->v >> accu->n) & ((1u << n) - 1);
+        return (accu->n += n), v;
+    }
+    else {
+        return lc3_get_bits_generic(bits, n);
+    }
+}
+
+/**
+ * Put arithmetic coder symbol
+ */
+LC3_HOT static inline void lc3_put_symbol(
+    struct lc3_bits *bits, const struct lc3_ac_model *model, unsigned s)
+{
+    const struct lc3_ac_symbol *symbols = model->s;
+    struct lc3_bits_ac *ac = &bits->ac;
+    unsigned range = ac->range >> 10;
+
+    ac->low += range * symbols[s].low;
+    ac->range = range * symbols[s].range;
+
+    ac->carry |= ac->low >> 24;
+    ac->low &= 0xffffff;
+
+    if (ac->range < 0x10000)
+        lc3_ac_write_renorm(bits);
+}
+
+/**
+ * Get arithmetic coder symbol
+ */
+LC3_HOT static inline unsigned lc3_get_symbol(
+    lc3_bits_t *bits, const struct lc3_ac_model *model)
+{
+    const struct lc3_ac_symbol *symbols = model->s;
+    struct lc3_bits_ac *ac = &bits->ac;
+
+    unsigned range = (ac->range >> 10) & 0xffff;
+
+    ac->error |= (ac->low >= (range << 10));
+    if (ac->error)
+        ac->low = 0;
+
+    int s = 16;
+
+    if (ac->low < range * symbols[s].low) {
+        s >>= 1;
+        s -= ac->low < range * symbols[s].low ? 4 : -4;
+        s -= ac->low < range * symbols[s].low ? 2 : -2;
+        s -= ac->low < range * symbols[s].low ? 1 : -1;
+        s -= ac->low < range * symbols[s].low;
+    }
+
+    ac->low -= range * symbols[s].low;
+    ac->range = range * symbols[s].range;
+
+    if (ac->range < 0x10000)
+        lc3_ac_read_renorm(bits);
+
+    return s;
+}
+
+#endif /* __LC3_BITS_H */

package/ios/Packages/CoreObjC/bwdet.c

@@ -0,0 +1,129 @@
+/******************************************************************************
+ *
+ *  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 "bwdet.h"
+
+
+/**
+ * Bandwidth detector
+ */
+enum lc3_bandwidth lc3_bwdet_run(
+    enum lc3_dt dt, enum lc3_srate sr, const float *e)
+{
+    /* Bandwidth regions (Table 3.6)  */
+
+    struct region { int is : 8; int ie : 8; };
+
+    static const struct region bws_table[LC3_NUM_DT]
+            [LC3_NUM_BANDWIDTH-1][LC3_NUM_BANDWIDTH-1] = {
+
+        [LC3_DT_7M5] = {
+            { { 51, 63+1 } },
+            { { 45, 55+1 }, { 58, 63+1 } },
+            { { 42, 51+1 }, { 53, 58+1 }, { 60, 63+1 } },
+            { { 40, 48+1 }, { 51, 55+1 }, { 57, 60+1 }, { 61, 63+1 } },
+        },
+
+        [LC3_DT_10M] = {
+            { { 53, 63+1 } },
+            { { 47, 56+1 }, { 59, 63+1 } },
+            { { 44, 52+1 }, { 54, 59+1 }, { 60, 63+1 } },
+            { { 41, 49+1 }, { 51, 55+1 }, { 57, 60+1 }, { 61, 63+1 } },
+        },
+    };
+
+    static const int l_table[LC3_NUM_DT][LC3_NUM_BANDWIDTH-1] = {
+        [LC3_DT_7M5] = { 4, 4, 3, 2 },
+        [LC3_DT_10M] = { 4, 4, 3, 1 },
+    };
+
+    /* --- Stage 1 ---
+     * Determine bw0 candidate */
+
+    enum lc3_bandwidth bw0 = LC3_BANDWIDTH_NB;
+    enum lc3_bandwidth bwn = (enum lc3_bandwidth)sr;
+
+    if (bwn <= bw0)
+        return bwn;
+
+    const struct region *bwr = bws_table[dt][bwn-1];
+
+    for (enum lc3_bandwidth bw = bw0; bw < bwn; bw++) {
+        int i = bwr[bw].is, ie = bwr[bw].ie;
+        int n = ie - i;
+
+        float se = e[i];
+        for (i++; i < ie; i++)
+            se += e[i];
+
+        if (se >= (10 << (bw == LC3_BANDWIDTH_NB)) * n)
+            bw0 = bw + 1;
+    }
+
+    /* --- Stage 2 ---
+     * Detect drop above cut-off frequency.
+     * The Tc condition (13) is precalculated, as
+     * Tc[] = 10 ^ (n / 10) , n = { 15, 23, 20, 20 } */
+
+    int hold = bw0 >= bwn;
+
+    if (!hold) {
+        int i0 = bwr[bw0].is, l = l_table[dt][bw0];
+        float tc = (const float []){
+             31.62277660, 199.52623150, 100, 100 }[bw0];
+
+        for (int i = i0 - l + 1; !hold && i <= i0 + 1; i++) {
+            hold = e[i-l] > tc * e[i];
+        }
+
+    }
+
+    return hold ? bw0 : bwn;
+}
+
+/**
+ * Return number of bits coding the bandwidth value
+ */
+int lc3_bwdet_get_nbits(enum lc3_srate sr)
+{
+    return (sr > 0) + (sr > 1) + (sr > 3);
+}
+
+/**
+ * Put bandwidth indication
+ */
+void lc3_bwdet_put_bw(lc3_bits_t *bits,
+    enum lc3_srate sr, enum lc3_bandwidth bw)
+{
+    int nbits_bw = lc3_bwdet_get_nbits(sr);
+    if (nbits_bw > 0)
+        lc3_put_bits(bits, bw, nbits_bw);
+}
+
+/**
+ * Get bandwidth indication
+ */
+int lc3_bwdet_get_bw(lc3_bits_t *bits,
+    enum lc3_srate sr, enum lc3_bandwidth *bw)
+{
+    enum lc3_bandwidth max_bw = (enum lc3_bandwidth)sr;
+    int nbits_bw = lc3_bwdet_get_nbits(sr);
+
+    *bw = nbits_bw > 0 ? lc3_get_bits(bits, nbits_bw) : LC3_BANDWIDTH_NB;
+    return *bw > max_bw ? (*bw = max_bw), -1 : 0;
+}

package/ios/Packages/CoreObjC/bwdet.h

@@ -0,0 +1,69 @@
+/******************************************************************************
+ *
+ *  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 - Bandwidth detector
+ *
+ * Reference : Low Complexity Communication Codec (LC3)
+ *             Bluetooth Specification v1.0
+ */
+
+#ifndef __LC3_BWDET_H
+#define __LC3_BWDET_H
+
+#include "common.h"
+#include "bits.h"
+
+
+/**
+ * Bandwidth detector (cf. 3.3.5)
+ * dt, sr          Duration and samplerate of the frame
+ * e               Energy estimation per bands
+ * return          Return detected bandwitdth
+ */
+enum lc3_bandwidth lc3_bwdet_run(
+    enum lc3_dt dt, enum lc3_srate sr, const float *e);
+
+/**
+ * Return number of bits coding the bandwidth value
+ * sr              Samplerate of the frame
+ * return          Number of bits coding the bandwidth value
+ */
+int lc3_bwdet_get_nbits(enum lc3_srate sr);
+
+/**
+ * Put bandwidth indication
+ * bits            Bitstream context
+ * sr              Samplerate of the frame
+ * bw              Bandwidth detected
+ */
+void lc3_bwdet_put_bw(lc3_bits_t *bits,
+    enum lc3_srate sr, enum lc3_bandwidth bw);
+
+/**
+ * Get bandwidth indication
+ * bits            Bitstream context
+ * sr              Samplerate of the frame
+ * bw              Return bandwidth indication
+ * return          0: Ok  -1: Invalid bandwidth indication
+ */
+int lc3_bwdet_get_bw(lc3_bits_t *bits,
+    enum lc3_srate sr, enum lc3_bandwidth *bw);
+
+
+#endif /* __LC3_BWDET_H */

package/ios/Packages/CoreObjC/common.h

@@ -0,0 +1,151 @@
+/******************************************************************************
+ *
+ *  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 - Common constants and types
+ */
+
+#ifndef __LC3_COMMON_H
+#define __LC3_COMMON_H
+
+#include "lc3.h"
+#include "fastmath.h"
+
+#include <stdalign.h>
+#include <limits.h>
+#include <string.h>
+
+#ifdef __ARM_ARCH
+#include <arm_acle.h>
+#endif
+
+
+/**
+ * Hot Function attribute
+ * Selectively disable sanitizer
+ */
+
+#ifdef __clang__
+
+#define LC3_HOT \
+    __attribute__((no_sanitize("bounds"))) \
+    __attribute__((no_sanitize("integer")))
+
+#else /* __clang__ */
+
+#define LC3_HOT
+
+#endif /* __clang__ */
+
+
+/**
+ * Macros
+ * MIN/MAX  Minimum and maximum between 2 values
+ * CLIP     Clip a value between low and high limits
+ * SATXX    Signed saturation on 'xx' bits
+ * ABS      Return absolute value
+ */
+
+#define LC3_MIN(a, b)  ( (a) < (b) ?  (a) : (b) )
+#define LC3_MAX(a, b)  ( (a) > (b) ?  (a) : (b) )
+
+#define LC3_CLIP(v, min, max)  LC3_MIN(LC3_MAX(v, min), max)
+#define LC3_SAT16(v)  LC3_CLIP(v, -(1 << 15), (1 << 15) - 1)
+#define LC3_SAT24(v)  LC3_CLIP(v, -(1 << 23), (1 << 23) - 1)
+
+#define LC3_ABS(v)  ( (v) < 0 ? -(v) : (v) )
+
+
+#if defined(__ARM_FEATURE_SAT) && !(__GNUC__ < 10)
+
+#undef  LC3_SAT16
+#define LC3_SAT16(v) __ssat(v, 16)
+
+#undef  LC3_SAT24
+#define LC3_SAT24(v) __ssat(v, 24)
+
+#endif /* __ARM_FEATURE_SAT */
+
+
+/**
+ * Convert `dt` in us and `sr` in KHz
+ */
+
+#define LC3_DT_US(dt) \
+    ( (3 + (dt)) * 2500 )
+
+#define LC3_SRATE_KHZ(sr) \
+    ( (1 + (sr) + ((sr) == LC3_SRATE_48K)) * 8 )
+
+
+/**
+ * Return number of samples, delayed samples and
+ * encoded spectrum coefficients within a frame
+ * - For encoding, keep 1.25 ms for temporal window
+ * - For decoding, keep 18 ms of history, aligned on frames, and a frame
+ */
+
+#define LC3_NS(dt, sr) \
+    ( 20 * (3 + (dt)) * (1 + (sr) + ((sr) == LC3_SRATE_48K)) )
+
+#define LC3_ND(dt, sr) \
+    ( (dt) == LC3_DT_7M5 ? 23 * LC3_NS(dt, sr) / 30 \
+                         :  5 * LC3_NS(dt, sr) /  8 )
+
+#define LC3_NE(dt, sr) \
+    ( 20 * (3 + (dt)) * (1 + (sr)) )
+
+#define LC3_MAX_NS \
+    LC3_NS(LC3_DT_10M, LC3_SRATE_48K)
+
+#define LC3_MAX_NE \
+    LC3_NE(LC3_DT_10M, LC3_SRATE_48K)
+
+#define LC3_NT(sr_hz) \
+    ( (5 * LC3_SRATE_KHZ(sr)) / 4 )
+
+#define LC3_NH(dt, sr) \
+    ( ((3 - dt) + 1) * LC3_NS(dt, sr) )
+
+
+/**
+ * Bandwidth, mapped to Nyquist frequency of samplerates
+ */
+
+enum lc3_bandwidth {
+    LC3_BANDWIDTH_NB = LC3_SRATE_8K,
+    LC3_BANDWIDTH_WB = LC3_SRATE_16K,
+    LC3_BANDWIDTH_SSWB = LC3_SRATE_24K,
+    LC3_BANDWIDTH_SWB = LC3_SRATE_32K,
+    LC3_BANDWIDTH_FB = LC3_SRATE_48K,
+
+    LC3_NUM_BANDWIDTH,
+};
+
+
+/**
+ * Complex floating point number
+ */
+
+struct lc3_complex
+{
+    float re, im;
+};
+
+
+#endif /* __LC3_COMMON_H */