@mentra/bluetooth-sdk 0.1.0

package/android/lc3Lib/src/main/cpp/google_opus_stuff/libopus/opus_types.h

@@ -0,0 +1,166 @@
+/* (C) COPYRIGHT 1994-2002 Xiph.Org Foundation */
+/* Modified by Jean-Marc Valin */
+/*
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions
+   are met:
+
+   - Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+   - Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+   OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+/* opus_types.h based on ogg_types.h from libogg */
+
+/**
+   @file opus_types.h
+   @brief Opus reference implementation types
+*/
+#ifndef OPUS_TYPES_H
+#define OPUS_TYPES_H
+
+#define opus_int         int                     /* used for counters etc; at least 16 bits */
+#define opus_int64       long long
+#define opus_int8        signed char
+
+#define opus_uint        unsigned int            /* used for counters etc; at least 16 bits */
+#define opus_uint64      unsigned long long
+#define opus_uint8       unsigned char
+
+/* Use the real stdint.h if it's there (taken from Paul Hsieh's pstdint.h) */
+#if (defined(__STDC__) && __STDC__ && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || (defined(__GNUC__) && (defined(_STDINT_H) || defined(_STDINT_H_)) || defined (HAVE_STDINT_H))
+#include <stdint.h>
+#  undef opus_int64
+#  undef opus_int8
+#  undef opus_uint64
+#  undef opus_uint8
+   typedef int8_t opus_int8;
+   typedef uint8_t opus_uint8;
+   typedef int16_t opus_int16;
+   typedef uint16_t opus_uint16;
+   typedef int32_t opus_int32;
+   typedef uint32_t opus_uint32;
+   typedef int64_t opus_int64;
+   typedef uint64_t opus_uint64;
+#elif defined(_WIN32)
+
+#  if defined(__CYGWIN__)
+#    include <_G_config.h>
+     typedef _G_int32_t opus_int32;
+     typedef _G_uint32_t opus_uint32;
+     typedef _G_int16 opus_int16;
+     typedef _G_uint16 opus_uint16;
+#  elif defined(__MINGW32__)
+     typedef short opus_int16;
+     typedef unsigned short opus_uint16;
+     typedef int opus_int32;
+     typedef unsigned int opus_uint32;
+#  elif defined(__MWERKS__)
+     typedef int opus_int32;
+     typedef unsigned int opus_uint32;
+     typedef short opus_int16;
+     typedef unsigned short opus_uint16;
+#  else
+     /* MSVC/Borland */
+     typedef __int32 opus_int32;
+     typedef unsigned __int32 opus_uint32;
+     typedef __int16 opus_int16;
+     typedef unsigned __int16 opus_uint16;
+#  endif
+
+#elif defined(__MACOS__)
+
+#  include <sys/types.h>
+   typedef SInt16 opus_int16;
+   typedef UInt16 opus_uint16;
+   typedef SInt32 opus_int32;
+   typedef UInt32 opus_uint32;
+
+#elif (defined(__APPLE__) && defined(__MACH__)) /* MacOS X Framework build */
+
+#  include <sys/types.h>
+   typedef int16_t opus_int16;
+   typedef u_int16_t opus_uint16;
+   typedef int32_t opus_int32;
+   typedef u_int32_t opus_uint32;
+
+#elif defined(__BEOS__)
+
+   /* Be */
+#  include <inttypes.h>
+   typedef int16 opus_int16;
+   typedef u_int16 opus_uint16;
+   typedef int32_t opus_int32;
+   typedef u_int32_t opus_uint32;
+
+#elif defined (__EMX__)
+
+   /* OS/2 GCC */
+   typedef short opus_int16;
+   typedef unsigned short opus_uint16;
+   typedef int opus_int32;
+   typedef unsigned int opus_uint32;
+
+#elif defined (DJGPP)
+
+   /* DJGPP */
+   typedef short opus_int16;
+   typedef unsigned short opus_uint16;
+   typedef int opus_int32;
+   typedef unsigned int opus_uint32;
+
+#elif defined(R5900)
+
+   /* PS2 EE */
+   typedef int opus_int32;
+   typedef unsigned opus_uint32;
+   typedef short opus_int16;
+   typedef unsigned short opus_uint16;
+
+#elif defined(__SYMBIAN32__)
+
+   /* Symbian GCC */
+   typedef signed short opus_int16;
+   typedef unsigned short opus_uint16;
+   typedef signed int opus_int32;
+   typedef unsigned int opus_uint32;
+
+#elif defined(CONFIG_TI_C54X) || defined (CONFIG_TI_C55X)
+
+   typedef short opus_int16;
+   typedef unsigned short opus_uint16;
+   typedef long opus_int32;
+   typedef unsigned long opus_uint32;
+
+#elif defined(CONFIG_TI_C6X)
+
+   typedef short opus_int16;
+   typedef unsigned short opus_uint16;
+   typedef int opus_int32;
+   typedef unsigned int opus_uint32;
+
+#else
+
+   /* Give up, take a reasonable guess */
+   typedef short opus_int16;
+   typedef unsigned short opus_uint16;
+   typedef int opus_int32;
+   typedef unsigned int opus_uint32;
+
+#endif
+
+#endif  /* OPUS_TYPES_H */

package/android/lc3Lib/src/main/cpp/google_opus_stuff/ogg_opus_encoder.cc

@@ -0,0 +1,268 @@
+/*
+ * Copyright 2019 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
+ *
+ *     https://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 "ogg_opus_encoder.h"
+
+#include <cassert>
+#include <endian.h>
+#include <memory>
+#include <string>
+#include <cstdint>
+#include "opus_tools/opus_header.h"
+
+// Ogg Opus information comes from the standard here:
+// https://tools.ietf.org/html/draft-ietf-codec-oggopus-14
+// This was also a useful reference:
+// https://github.com/krad-radio/butt-krad-opus/blob/302a4b6a6a596be6632f30cfb567a6a6d8fcb3f9/src/opus_encode.cpp
+
+namespace audio_util {
+namespace {
+
+static constexpr float kEncodingBufferSizeSeconds = 0.02f;
+
+std::string SerializeUint32(uint32_t value) {
+  std::string result(4, '\0');
+#if __BYTE_ORDER == __BIG_ENDIAN
+#error The following line assumes that the byte order is little endian.
+#endif
+  memcpy(&result[0], &value, sizeof(value));
+  return result;
+}
+
+}  // namespace
+
+OggOpusEncoder::OggOpusEncoder(int num_channels, int sample_rate_hz,
+                               int bitrate_bps, bool use_vbr,
+                               bool low_latency_mode)
+    : num_channels_(num_channels),
+      sample_rate_hz_(sample_rate_hz),
+      frame_size_(kEncodingBufferSizeSeconds * sample_rate_hz_),
+      encoder_(OpusUniquePtr(
+          opus_encoder_create(sample_rate_hz_, num_channels_,
+                              OPUS_APPLICATION_AUDIO, &error_code_),
+          opus_encoder_destroy)),
+      flushed_(false),
+      low_latency_mode_(low_latency_mode),
+      elements_in_pcm_frame_(0),
+      pcm_frame_(num_channels_ * frame_size_) {
+  assert(num_channels <= 2);  // Only mono and stereo are supported).
+  std::vector<int> valid_sample_rates = {8000, 12000, 16000, 24000, 48000};
+  assert(std::find(valid_sample_rates.begin(), valid_sample_rates.end(),
+                   sample_rate_hz) != valid_sample_rates.end());
+  assert(bitrate_bps >= 500);
+  assert(bitrate_bps <= 512000);
+
+  opus_encoder_ctl(encoder_.get(), OPUS_SET_BITRATE(bitrate_bps));
+  if (!use_vbr) {
+    opus_encoder_ctl(encoder_.get(), OPUS_SET_VBR(0));
+  }
+  constexpr int kComplexity = 4;
+  opus_encoder_ctl(encoder_.get(), OPUS_SET_COMPLEXITY(kComplexity));
+
+  // We will always pass exactly one frame at a time to the encoder.
+  opus_frame_.resize(kBytesPerSample * pcm_frame_.size());
+
+  // Start generating Ogg packets (though they don't get sent out until the
+  // first call to Encode()).
+  packet_count_ = 0;
+  granule_position_ = 0;
+  ogg_stream_init(&stream_, 0 /* serial number */);
+  GenerateOggPacketsForHeader();
+}
+
+OggOpusEncoder::~OggOpusEncoder() {
+  ogg_stream_clear(&stream_);
+}
+
+// Encodes 16-bit PCM data in OggOpus format.
+const std::vector<unsigned char>& OggOpusEncoder::Process(
+    const std::vector<int16_t>& pcm) {
+  assert(!flushed_);
+  assert((pcm.size() % num_channels_) == 0);
+  if (!header_) {
+    ogg_bytes_.resize(0);
+  } else {
+    header_ = false;
+  }
+  int num_samples_processed = 0;
+
+  // Process the first block, handling any leftovers from a previous round.
+  if (elements_in_pcm_frame_ > 0) {
+    int entries_to_write =
+        std::min(pcm_frame_.size() - elements_in_pcm_frame_, pcm.size());
+    std::copy(pcm.begin(), pcm.begin() + entries_to_write,
+              pcm_frame_.begin() + elements_in_pcm_frame_);
+    elements_in_pcm_frame_ += entries_to_write;
+    if (elements_in_pcm_frame_ == pcm_frame_.size()) {
+      // pcm_frame_ is full, encode it.
+      int num_opus_frame_bytes =
+          opus_encode(encoder_.get(), pcm_frame_.data(), frame_size_,
+                      opus_frame_.data(), opus_frame_.size());
+
+      assert(num_opus_frame_bytes >= 0);
+      GenerateOggPacketsForOpusFrame(opus_frame_.data(), num_opus_frame_bytes,
+                                     &ogg_bytes_, false);
+      num_samples_processed += entries_to_write;
+      pcm_frame_.assign(pcm_frame_.size(), 0);
+      elements_in_pcm_frame_ = 0;
+    } else {
+      // There's nothing to encode. We've put all of pcm data into pcm_frame_
+      // for later processing.
+      ogg_bytes_.resize(0);
+      return ogg_bytes_;
+    }
+  }
+
+  // Process whole frames directly from pcm.
+  while (num_samples_processed + frame_size_ * num_channels_ <= pcm.size()) {
+    int num_opus_frame_bytes =
+        opus_encode(encoder_.get(), pcm.data() + num_samples_processed,
+                    frame_size_, opus_frame_.data(), opus_frame_.size());
+
+    assert(num_opus_frame_bytes >= 0);
+    GenerateOggPacketsForOpusFrame(opus_frame_.data(), num_opus_frame_bytes,
+                                   &ogg_bytes_, false);
+    num_samples_processed += frame_size_ * num_channels_;
+  }
+
+  if (low_latency_mode_) {
+    // Force the codec to produce samples for every input buffer.
+    AppendOggStateToBuffer(&ogg_bytes_, true);
+  }
+
+  // Place any remaining samples in pcm_frame_.
+  elements_in_pcm_frame_ = pcm.size() - num_samples_processed;
+  std::copy(pcm.begin() + num_samples_processed, pcm.end(), pcm_frame_.begin());
+  return ogg_bytes_;
+}
+
+// Returns any remaining samples from the codec.
+const std::vector<unsigned char>& OggOpusEncoder::Flush() {
+  assert(!flushed_);
+  ogg_bytes_.resize(0);
+  int num_opus_frame_bytes =
+      opus_encode(encoder_.get(), pcm_frame_.data(), frame_size_,
+                  opus_frame_.data(), opus_frame_.size());
+  assert(num_opus_frame_bytes >= 0);
+  GenerateOggPacketsForOpusFrame(opus_frame_.data(), num_opus_frame_bytes,
+                                 &ogg_bytes_, true);
+  flushed_ = true;
+  return ogg_bytes_;
+}
+
+void OggOpusEncoder::GenerateOggPacketsForHeader() {
+  // Both header packets must have granule position of zero.
+  assert(granule_position_ == 0);
+  OpusHeader header;
+  header.version = 1;
+  header.channels = num_channels_;
+  opus_encoder_ctl(encoder_.get(), OPUS_GET_LOOKAHEAD(&header.preskip));
+  header.input_sample_rate = sample_rate_hz_;
+  header.gain = 0;
+  header.channel_mapping = 0;
+
+  // Write the ID header.
+  ogg_packet id_packet;
+  id_packet.b_o_s = 1;  // The first packet.
+  id_packet.e_o_s = 0;
+  id_packet.granulepos = granule_position_;
+  id_packet.packetno = packet_count_;
+  constexpr int kHeaderSizeUpperBound = 64;
+  id_packet.packet = new unsigned char[kHeaderSizeUpperBound];
+  // opus_header_to_packet fills id_packet.packet with header data and returns
+  // the number of bytes.
+  id_packet.bytes =
+      opus_header_to_packet(&header, id_packet.packet, kHeaderSizeUpperBound);
+  // Add the ID packet into the stream.
+  packet_count_++;
+  ogg_stream_packetin(&stream_, &id_packet);
+
+  // Write the comment header.
+  ogg_packet comment_packet;
+  comment_packet.b_o_s = 0;
+  comment_packet.e_o_s = 0;
+  comment_packet.granulepos = granule_position_;
+  comment_packet.packetno = packet_count_;
+  const std::string kVendor = "Google using libopus";
+  std::string packet = "";
+  packet.append("OpusTags");
+  packet.append(SerializeUint32(kVendor.size()));
+  packet.append(kVendor);
+  packet.append(SerializeUint32(0));
+  comment_packet.packet = const_cast<unsigned char*>(
+      reinterpret_cast<const unsigned char*>(packet.c_str()));
+  comment_packet.bytes = packet.length();
+
+  // Add the comment header into the stream.
+  packet_count_++;
+  ogg_stream_packetin(&stream_, &comment_packet);
+  // Force a page break after the comment header.
+  // According to
+  // https://tools.ietf.org/html/draft-ietf-codec-oggopus-14#section-3 there is
+  // a mandatory page break after the comment header.
+  AppendOggStateToBuffer(&ogg_bytes_, true);
+  header_ = true;
+
+  delete[] id_packet.packet;
+}
+
+void OggOpusEncoder::GenerateOggPacketsForOpusFrame(
+    unsigned char* opus_frame_bytes, int opus_bytes_length,
+    std::vector<unsigned char>* ogg_bytes, bool flush) {
+  // Flush data from the ogg object into the outgoing stream.
+  AppendOggStateToBuffer(ogg_bytes, flush);
+
+  // Write the most recent buffer of Opus data into an Ogg packet.
+  ogg_packet frame_packet;
+  frame_packet.b_o_s = 0;
+  frame_packet.e_o_s = flush ? 1 : 0;
+  // According to
+  // https://tools.ietf.org/html/draft-ietf-codec-oggopus-14#section-4 the
+  // granule position should include all samples up to the last packet completed
+  // on the page, so we need to update granule_position_ before assigning it to
+  // the packet.  If we're closing the stream, we don't assume that the last
+  // packet includes a full frame.
+  if (flush) {
+    granule_position_ += (elements_in_pcm_frame_ / num_channels_);
+  } else {
+    granule_position_ += frame_size_;
+  }
+  frame_packet.granulepos = granule_position_;
+  frame_packet.packetno = packet_count_;
+  frame_packet.packet = opus_frame_bytes;
+  frame_packet.bytes = opus_bytes_length;
+  // Add the data packet into the stream.
+  packet_count_++;
+  ogg_stream_packetin(&stream_, &frame_packet);
+
+  // Try flushing again after data packet.
+  AppendOggStateToBuffer(ogg_bytes, flush);
+}
+
+void OggOpusEncoder::AppendOggStateToBuffer(std::vector<unsigned char>* buffer,
+                                            bool flush_ogg_stream) {
+  int (*write_fun)(ogg_stream_state*, ogg_page*) =
+      flush_ogg_stream ? &ogg_stream_flush : &ogg_stream_pageout;
+  while (write_fun(&stream_, &page_) != 0) {
+    const int initial_size = buffer->size();
+    buffer->resize(buffer->size() + page_.header_len + page_.body_len);
+    memcpy(buffer->data() + initial_size, page_.header, page_.header_len);
+    memcpy(buffer->data() + initial_size + page_.header_len, page_.body,
+           page_.body_len);
+  }
+}
+
+}  // namespace audio_util

package/android/lc3Lib/src/main/cpp/google_opus_stuff/ogg_opus_encoder.h

@@ -0,0 +1,115 @@
+/*
+ * Copyright 2019 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
+ *
+ *     https://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 AUDIO_UTIL_OGG_OPUS_ENCODER_H_
+#define AUDIO_UTIL_OGG_OPUS_ENCODER_H_
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+#include "libogg/ogg.h"
+#include "libopus/opus.h"
+
+namespace audio_util {
+
+// This class is meant to be a dependency-light streaming encoder.
+//
+// Encoding is done internally on a block size of 20ms, which seems to be the
+// recommended size for Opus encoding.
+class OggOpusEncoder {
+ public:
+  // Input is int16 data.
+  constexpr static int kBytesPerSample = 2;
+  constexpr static int kBitsPerSample = 16;
+
+  // num_channels must be 1 or 2.
+  // sample rate must be one of {8000, 12000, 16000, 24000, 48000}
+  // Note that low_latency_mode will increase the total number of Ogg packets,
+  // but will reduce overall latency of the codec. This does not impact the
+  // quality of audio compression, only how the data is packaged in the Ogg
+  // container. Low latency mode is only recommended for realtime streaming
+  // applications. See test for actual bitrate increases.
+  OggOpusEncoder(int num_channels, int sample_rate_hz, int bitrate_bps,
+                 bool use_vbr, bool low_latency_mode);
+
+  ~OggOpusEncoder();
+
+  // Encodes 16-bit PCM data in OggOpus format. There is no restriction on the
+  // size of the input vector.
+  // Note that it is very common for the returned vector to be empty. Keep
+  // calling this function with new samples until they become available.
+  const std::vector<unsigned char>& Process(const std::vector<int16_t>& pcm);
+
+  // Returns any remaining samples from the codec. This should be called last,
+  // and never more than once.
+  const std::vector<unsigned char>& Flush();
+
+ private:
+  using OpusUniquePtr =
+      std::unique_ptr<OpusEncoder, decltype(&opus_encoder_destroy)>;
+
+  std::string GetOpusErrorMessage() const;
+
+  // Push the Opus header details into the ogg stream.
+  void GenerateOggPacketsForHeader();
+
+  // Push data from a single Opus frame into an Ogg stream.
+  void GenerateOggPacketsForOpusFrame(unsigned char* opus_frame_bytes,
+                                     int opus_bytes_length,
+                                     std::vector<unsigned char>* ogg_bytes,
+                                     bool flush);
+
+  // Moves data from the stream_ object into buffer.
+  void AppendOggStateToBuffer(std::vector<unsigned char>* buffer, bool flush);
+
+  int num_channels_;
+  int sample_rate_hz_;
+  int bitrate_bps_;
+
+  // Number of samples in an Opus 20ms frame for a single channel.
+  int frame_size_;
+  OpusUniquePtr encoder_;
+
+  // Stores the status of Opus codec initialization.
+  int error_code_;
+
+  // Checks that Flush() isn't called multiple times.
+  bool flushed_;
+  bool header_;
+
+  // When true, flushing of the Ogg stream after every call to Process().
+  bool low_latency_mode_;
+
+  // A preallocated buffer to store the temporary OGG result.
+  std::vector<unsigned char> opus_frame_;
+
+  std::vector<unsigned char> ogg_bytes_;
+
+  // A stored buffer for a single frame of PCM data to be processed.
+  int elements_in_pcm_frame_;
+  std::vector<opus_int16> pcm_frame_;
+
+  // Ogg objects.
+  ogg_stream_state stream_;
+  ogg_page page_;
+  int packet_count_;      // Count of packets pushed to the stream.
+  int granule_position_;  // Position in the ogg stream.
+};
+
+}  // namespace audio_util
+
+#endif  // AUDIO_UTIL_OGG_OPUS_ENCODER_H_

package/android/lc3Lib/src/main/cpp/google_opus_stuff/opus_tools/opus_header.h

@@ -0,0 +1,59 @@
+/* Copyright (C)2012 Xiph.Org Foundation
+   File: opus_header.h
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions
+   are met:
+
+   - Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+   - Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
+   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef OPUS_HEADER_H
+#define OPUS_HEADER_H
+
+#include "../libogg/ogg.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+   int version;
+   int channels; /* Number of channels: 1..255 */
+   int preskip;
+   ogg_uint32_t input_sample_rate;
+   int gain; /* in dB S7.8 should be zero whenever possible */
+   int channel_mapping;
+   /* The rest is only used if channel_mapping != 0 */
+   int nb_streams;
+   int nb_coupled;
+   unsigned char stream_map[255];
+} OpusHeader;
+
+int opus_header_parse(const unsigned char *header, int len, OpusHeader *h);
+int opus_header_to_packet(const OpusHeader *h, unsigned char *packet, int len);
+
+extern const int wav_permute_matrix[8][8];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/android/lc3Lib/src/main/cpp/liblc3/CMakeLists.txt

@@ -0,0 +1,38 @@
+
+cmake_minimum_required(VERSION 3.18.1)
+
+project("lc3")
+
+include_directories(include)
+#add_subdirectory(liblc3)
+add_library(${CMAKE_PROJECT_NAME} SHARED
+        # List C/C++ source files with relative paths to this CMakeLists.txt.
+        liblc3.cpp
+
+        liblc3/attdet.c
+        liblc3/bits.c
+        liblc3/bwdet.c
+        liblc3/energy.c
+        liblc3/lc3.c
+        liblc3/ltpf.c
+        liblc3/mdct.c
+        liblc3/plc.c
+        liblc3/sns.c
+        liblc3/spec.c
+        liblc3/tables.c
+        liblc3/tns.c
+
+        rnnoise/celt_lpc.c
+        rnnoise/denoise.c
+        rnnoise/kiss_fft.c
+        rnnoise/pitch.c
+        rnnoise/rnn.c
+        rnnoise/rnn_data.c
+        rnnoise/rnn_reader.c
+
+        )
+
+target_link_libraries(${CMAKE_PROJECT_NAME}
+        # List libraries link to the target library
+        android
+        log)