From a894f22ae5ab2b6a57ad41e4d84a6b153f8f401d Mon Sep 17 00:00:00 2001
From: ross <3024454314@qq.com>
Date: Thu, 12 Feb 2026 14:59:50 +0800
Subject: [PATCH] =?UTF-8?q?=E5=BC=BA=E5=8C=96=E4=BB=A3=E7=A0=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
app/CMakeLists.txt | 29 +
app/build.gradle | 5 +-
.../keywords.txt | 63 +-
app/src/main/cpp/opus.h | 981 ++++++++++++++++++
app/src/main/cpp/opus_custom.h | 342 ++++++
app/src/main/cpp/opus_decoder.cpp | 70 ++
app/src/main/cpp/opus_defines.h | 799 ++++++++++++++
app/src/main/cpp/opus_multistream.h | 660 ++++++++++++
app/src/main/cpp/opus_projection.h | 568 ++++++++++
app/src/main/cpp/opus_recorder.cpp | 77 ++
app/src/main/cpp/opus_types.h | 166 +++
.../com/zs/smarthuman/sherpa/VadManager.kt | 40 +-
.../zs/smarthuman/sherpa/VoiceController.kt | 210 +---
.../com/zs/smarthuman/sherpa/WakeupManager.kt | 19 +-
.../com/zs/smarthuman/utils/OpusDecoder.kt | 76 ++
.../com/zs/smarthuman/utils/OpusEncoder.kt | 75 ++
.../smarthuman/websocket/WebsocketProtocol.kt | 459 ++++++++
.../zs/smarthuman/websocket/WebsocketType.kt | 11 +
app/src/main/jniLibs/arm64-v8a/libopus.so | Bin 0 -> 415496 bytes
app/src/main/jniLibs/armeabi-v7a/libopus.so | Bin 0 -> 341632 bytes
gradle/libs.versions.toml | 4 +-
settings.gradle | 7 +
22 files changed, 4477 insertions(+), 184 deletions(-)
create mode 100644 app/src/main/cpp/opus.h
create mode 100644 app/src/main/cpp/opus_custom.h
create mode 100644 app/src/main/cpp/opus_decoder.cpp
create mode 100644 app/src/main/cpp/opus_defines.h
create mode 100644 app/src/main/cpp/opus_multistream.h
create mode 100644 app/src/main/cpp/opus_projection.h
create mode 100644 app/src/main/cpp/opus_recorder.cpp
create mode 100644 app/src/main/cpp/opus_types.h
create mode 100644 app/src/main/java/com/zs/smarthuman/utils/OpusDecoder.kt
create mode 100644 app/src/main/java/com/zs/smarthuman/utils/OpusEncoder.kt
create mode 100644 app/src/main/java/com/zs/smarthuman/websocket/WebsocketProtocol.kt
create mode 100644 app/src/main/java/com/zs/smarthuman/websocket/WebsocketType.kt
create mode 100644 app/src/main/jniLibs/arm64-v8a/libopus.so
create mode 100644 app/src/main/jniLibs/armeabi-v7a/libopus.so
diff --git a/app/CMakeLists.txt b/app/CMakeLists.txt
index e69de29..c609155 100644
--- a/app/CMakeLists.txt
+++ b/app/CMakeLists.txt
@@ -0,0 +1,29 @@
+cmake_minimum_required(VERSION 3.18.1)
+project(app CXX)
+
+# ========== 关键修正1：源码路径（CMAKE_CURRENT_SOURCE_DIR 就是 src/main/cpp，无需重复加路径） ==========
+add_library(
+ app
+ SHARED
+ # 直接写文件名即可，否则会找 src/main/cpp/src/main/cpp/xxx.cpp（路径重复）
+ ${CMAKE_CURRENT_SOURCE_DIR}/src/main/cpp/opus_recorder.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/src/main/cpp/opus_decoder.cpp
+)
+
+# ========== 关键修正2：正确导入本地 jniLibs 下的 libopus.so ==========
+# 1. 声明 opus 为「导入库」（SHARED 对应 .so 动态库）
+add_library(opus SHARED IMPORTED)
+# 2. 指定 libopus.so 的绝对路径（适配不同架构：arm64-v8a/armeabi-v7a 等）
+set_target_properties(opus PROPERTIES
+ IMPORTED_LOCATION ${CMAKE_CURRENT_SOURCE_DIR}/src/main/jniLibs/${ANDROID_ABI}/libopus.so
+ # 可选：如果需要头文件，添加这行（头文件放 src/main/cpp/include/opus/ 下）
+ # INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_CURRENT_SOURCE_DIR}/include
+)
+
+# ========== 关键修正3：链接导入的 opus 库（直接写库名，不用 opus:: 前缀） ==========
+target_link_libraries(
+ app
+ PRIVATE
+ opus # 链接上面声明的本地 libopus.so
+ log # Android 日志库
+)
\ No newline at end of file
diff --git a/app/build.gradle b/app/build.gradle
index 374b54f..12569e1 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -19,7 +19,8 @@ android {
externalNativeBuild {
cmake {
- cppFlags ""
+ arguments += "-DANDROID_STL=c++_shared"
+ cppFlags += "-std=c++17"
}
}
@@ -50,6 +51,7 @@ android {
buildFeatures {
buildConfig = true // 显式启用
+ prefab = true
}
buildTypes {
@@ -182,4 +184,5 @@ dependencies {
implementation files('libs/sherpa-onnx-1.12.23.aar')
+ implementation(libs.opus.v131)
}
\ No newline at end of file
diff --git a/app/src/main/assets/sherpa-onnx-kws-zipformer-wenetspeech-3.3M-2024-01-01/keywords.txt b/app/src/main/assets/sherpa-onnx-kws-zipformer-wenetspeech-3.3M-2024-01-01/keywords.txt
index 026a219..a7c8d1c 100644
--- a/app/src/main/assets/sherpa-onnx-kws-zipformer-wenetspeech-3.3M-2024-01-01/keywords.txt
+++ b/app/src/main/assets/sherpa-onnx-kws-zipformer-wenetspeech-3.3M-2024-01-01/keywords.txt
@@ -1,3 +1,60 @@
-x iǎo z ì t óng x ué @小智同学
-x iǎo zh ì t óng x ué @小智同学
-x iǎo zh ì t óng x ié @小智同学
\ No newline at end of file
+x iǎo zh ì t óng x ué
+x iǎo z ì t óng x ué
+x iǎo j ì t óng x ué
+x iǎo ch ì t óng x ué
+x iáo zh ì t óng x ué
+x iào zh ì t óng x ué
+x iǎo zh í t óng x ué
+x iǎo zh ǐ t óng x ué
+x iǎo zh ì t ōng x ué
+x iǎo zh ì t òng x ué
+x iǎo zh ì t óng x uē
+x iǎo zh ì t óng x uè
+x iǎo zh ì t óng y ué
+x iǎo zh i t óng x ué
+x iǎo zh ì t óng x uè
+x iǎo zh ì t óng x ué
+x iǎo z ì t óng x ué
+x iǎo j ì t óng x ué
+x iǎo ch ì t óng x ué
+x iáo zh ì t óng x ué
+x iǎo zh í t óng x ué
+x iǎo zh ì t ōng x ué
+x iǎo zh ì t óng x uè
+
+
+x iǎo zh ì d óng x ué
+x iǎo z ì d óng x ué
+x iǎo j ì d óng x ué
+x iǎo ch ì d óng x ué
+x iáo zh ì d óng x ué
+x iào zh ì d óng x ué
+x iǎo zh í d óng x ué
+x iǎo zh ǐ d óng x ué
+x iǎo zh ì d ōng x ué
+x iǎo zh ì d òng x ué
+x iǎo zh ì d óng x uē
+x iǎo zh ì d óng x uè
+x iǎo zh ì d óng y ué
+x iǎo zh i d óng x ué
+x iǎo zh ì d óng x uè
+x iǎo zh ì d óng x ué
+x iǎo z ì d óng x ué
+x iǎo j ì d óng x ué
+x iǎo ch ì d óng x ué
+x iáo zh ì d óng x ué
+x iǎo zh í d óng x ué
+x iǎo zh ì d ōng x ué
+x iǎo zh ì d óng x uè
+
+s iǎo zh ì t óng x ué
+sh iǎo zh ì t óng x ué
+h iǎo zh ì t óng x ué
+s iǎo zh ì t óng x ué
+sh iǎo zh ì t óng x ué
+
+s iǎo zh ì d óng x ué
+sh iǎo zh ì d óng x ué
+h iǎo zh ì d óng x ué
+x iào zh ì t óng x ué
+x iào zh ì d óng x ué
diff --git a/app/src/main/cpp/opus.h b/app/src/main/cpp/opus.h
new file mode 100644
index 0000000..d282f21
--- /dev/null
+++ b/app/src/main/cpp/opus.h
@@ -0,0 +1,981 @@
+/* Copyright (c) 2010-2011 Xiph.Org Foundation, Skype Limited
+ Written by Jean-Marc Valin and Koen Vos */
+/*
+ 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.
+*/
+
+/**
+ * @file opus.h
+ * @brief Opus reference implementation API
+ */
+
+#ifndef OPUS_H
+#define OPUS_H
+
+#include "opus_types.h"
+#include "opus_defines.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @mainpage Opus
+ *
+ * The Opus codec is designed for interactive speech and audio transmission over the Internet.
+ * It is designed by the IETF Codec Working Group and incorporates technology from
+ * Skype's SILK codec and Xiph.Org's CELT codec.
+ *
+ * The Opus codec is designed to handle a wide range of interactive audio applications,
+ * including Voice over IP, videoconferencing, in-game chat, and even remote live music
+ * performances. It can scale from low bit-rate narrowband speech to very high quality
+ * stereo music. Its main features are:
+
+ * @li Sampling rates from 8 to 48 kHz
+ * @li Bit-rates from 6 kb/s to 510 kb/s
+ * @li Support for both constant bit-rate (CBR) and variable bit-rate (VBR)
+ * @li Audio bandwidth from narrowband to full-band
+ * @li Support for speech and music
+ * @li Support for mono and stereo
+ * @li Support for multichannel (up to 255 channels)
+ * @li Frame sizes from 2.5 ms to 60 ms
+ * @li Good loss robustness and packet loss concealment (PLC)
+ * @li Floating point and fixed-point implementation
+ *
+ * Documentation sections:
+ * @li @ref opus_encoder
+ * @li @ref opus_decoder
+ * @li @ref opus_repacketizer
+ * @li @ref opus_multistream
+ * @li @ref opus_libinfo
+ * @li @ref opus_custom
+ */
+
+/** @defgroup opus_encoder Opus Encoder
+ * @{
+ *
+ * @brief This page describes the process and functions used to encode Opus.
+ *
+ * Since Opus is a stateful codec, the encoding process starts with creating an encoder
+ * state. This can be done with:
+ *
+ * @code
+ * int error;
+ * OpusEncoder *enc;
+ * enc = opus_encoder_create(Fs, channels, application, &error);
+ * @endcode
+ *
+ * From this point, @c enc can be used for encoding an audio stream. An encoder state
+ * @b must @b not be used for more than one stream at the same time. Similarly, the encoder
+ * state @b must @b not be re-initialized for each frame.
+ *
+ * While opus_encoder_create() allocates memory for the state, it's also possible
+ * to initialize pre-allocated memory:
+ *
+ * @code
+ * int size;
+ * int error;
+ * OpusEncoder *enc;
+ * size = opus_encoder_get_size(channels);
+ * enc = malloc(size);
+ * error = opus_encoder_init(enc, Fs, channels, application);
+ * @endcode
+ *
+ * where opus_encoder_get_size() returns the required size for the encoder state. Note that
+ * future versions of this code may change the size, so no assuptions should be made about it.
+ *
+ * The encoder state is always continuous in memory and only a shallow copy is sufficient
+ * to copy it (e.g. memcpy())
+ *
+ * It is possible to change some of the encoder's settings using the opus_encoder_ctl()
+ * interface. All these settings already default to the recommended value, so they should
+ * only be changed when necessary. The most common settings one may want to change are:
+ *
+ * @code
+ * opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate));
+ * opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY(complexity));
+ * opus_encoder_ctl(enc, OPUS_SET_SIGNAL(signal_type));
+ * @endcode
+ *
+ * where
+ *
+ * @arg bitrate is in bits per second (b/s)
+ * @arg complexity is a value from 1 to 10, where 1 is the lowest complexity and 10 is the highest
+ * @arg signal_type is either OPUS_AUTO (default), OPUS_SIGNAL_VOICE, or OPUS_SIGNAL_MUSIC
+ *
+ * See @ref opus_encoderctls and @ref opus_genericctls for a complete list of parameters that can be set or queried. Most parameters can be set or changed at any time during a stream.
+ *
+ * To encode a frame, opus_encode() or opus_encode_float() must be called with exactly one frame (2.5, 5, 10, 20, 40 or 60 ms) of audio data:
+ * @code
+ * len = opus_encode(enc, audio_frame, frame_size, packet, max_packet);
+ * @endcode
+ *
+ * where
+ *
+ * - audio_frame is the audio data in opus_int16 (or float for opus_encode_float())
+ * - frame_size is the duration of the frame in samples (per channel)
+ * - packet is the byte array to which the compressed data is written
+ * - max_packet is the maximum number of bytes that can be written in the packet (4000 bytes is recommended).
+ * Do not use max_packet to control VBR target bitrate, instead use the #OPUS_SET_BITRATE CTL.
+ *
+ *
+ * opus_encode() and opus_encode_float() return the number of bytes actually written to the packet.
+ * The return value can be negative, which indicates that an error has occurred. If the return value
+ * is 2 bytes or less, then the packet does not need to be transmitted (DTX).
+ *
+ * Once the encoder state if no longer needed, it can be destroyed with
+ *
+ * @code
+ * opus_encoder_destroy(enc);
+ * @endcode
+ *
+ * If the encoder was created with opus_encoder_init() rather than opus_encoder_create(),
+ * then no action is required aside from potentially freeing the memory that was manually
+ * allocated for it (calling free(enc) for the example above)
+ *
+ */
+
+/** Opus encoder state.
+ * This contains the complete state of an Opus encoder.
+ * It is position independent and can be freely copied.
+ * @see opus_encoder_create,opus_encoder_init
+ */
+typedef struct OpusEncoder OpusEncoder;
+
+/** Gets the size of an OpusEncoder structure.
+ * @param[in] channels int: Number of channels.
+ * This must be 1 or 2.
+ * @returns The size in bytes.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_encoder_get_size(int channels);
+
+/**
+ */
+
+/** Allocates and initializes an encoder state.
+ * There are three coding modes:
+ *
+ * @ref OPUS_APPLICATION_VOIP gives best quality at a given bitrate for voice
+ * signals. It enhances the input signal by high-pass filtering and
+ * emphasizing formants and harmonics. Optionally it includes in-band
+ * forward error correction to protect against packet loss. Use this
+ * mode for typical VoIP applications. Because of the enhancement,
+ * even at high bitrates the output may sound different from the input.
+ *
+ * @ref OPUS_APPLICATION_AUDIO gives best quality at a given bitrate for most
+ * non-voice signals like music. Use this mode for music and mixed
+ * (music/voice) content, broadcast, and applications requiring less
+ * than 15 ms of coding delay.
+ *
+ * @ref OPUS_APPLICATION_RESTRICTED_LOWDELAY configures low-delay mode that
+ * disables the speech-optimized mode in exchange for slightly reduced delay.
+ * This mode can only be set on an newly initialized or freshly reset encoder
+ * because it changes the codec delay.
+ *
+ * This is useful when the caller knows that the speech-optimized modes will not be needed (use with caution).
+ * @param [in] Fs opus_int32: Sampling rate of input signal (Hz)
+ * This must be one of 8000, 12000, 16000,
+ * 24000, or 48000.
+ * @param [in] channels int: Number of channels (1 or 2) in input signal
+ * @param [in] application int: Coding mode (@ref OPUS_APPLICATION_VOIP/@ref OPUS_APPLICATION_AUDIO/@ref OPUS_APPLICATION_RESTRICTED_LOWDELAY)
+ * @param [out] error int*: @ref opus_errorcodes
+ * @note Regardless of the sampling rate and number channels selected, the Opus encoder
+ * can switch to a lower audio bandwidth or number of channels if the bitrate
+ * selected is too low. This also means that it is safe to always use 48 kHz stereo input
+ * and let the encoder optimize the encoding.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusEncoder *opus_encoder_create(
+ opus_int32 Fs,
+ int channels,
+ int application,
+ int *error
+);
+
+/** Initializes a previously allocated encoder state
+ * The memory pointed to by st must be at least the size returned by opus_encoder_get_size().
+ * This is intended for applications which use their own allocator instead of malloc.
+ * @see opus_encoder_create(),opus_encoder_get_size()
+ * To reset a previously initialized state, use the #OPUS_RESET_STATE CTL.
+ * @param [in] st OpusEncoder*: Encoder state
+ * @param [in] Fs opus_int32: Sampling rate of input signal (Hz)
+ * This must be one of 8000, 12000, 16000,
+ * 24000, or 48000.
+ * @param [in] channels int: Number of channels (1 or 2) in input signal
+ * @param [in] application int: Coding mode (OPUS_APPLICATION_VOIP/OPUS_APPLICATION_AUDIO/OPUS_APPLICATION_RESTRICTED_LOWDELAY)
+ * @retval #OPUS_OK Success or @ref opus_errorcodes
+ */
+OPUS_EXPORT int opus_encoder_init(
+ OpusEncoder *st,
+ opus_int32 Fs,
+ int channels,
+ int application
+) OPUS_ARG_NONNULL(1);
+
+/** Encodes an Opus frame.
+ * @param [in] st OpusEncoder*: Encoder state
+ * @param [in] pcm opus_int16*: Input signal (interleaved if 2 channels). length is frame_size*channels*sizeof(opus_int16)
+ * @param [in] frame_size int: Number of samples per channel in the
+ * input signal.
+ * This must be an Opus frame size for
+ * the encoder's sampling rate.
+ * For example, at 48 kHz the permitted
+ * values are 120, 240, 480, 960, 1920,
+ * and 2880.
+ * Passing in a duration of less than
+ * 10 ms (480 samples at 48 kHz) will
+ * prevent the encoder from using the LPC
+ * or hybrid modes.
+ * @param [out] data unsigned char*: Output payload.
+ * This must contain storage for at
+ * least \a max_data_bytes.
+ * @param [in] max_data_bytes opus_int32: Size of the allocated
+ * memory for the output
+ * payload. This may be
+ * used to impose an upper limit on
+ * the instant bitrate, but should
+ * not be used as the only bitrate
+ * control. Use #OPUS_SET_BITRATE to
+ * control the bitrate.
+ * @returns The length of the encoded packet (in bytes) on success or a
+ * negative error code (see @ref opus_errorcodes) on failure.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_encode(
+ OpusEncoder *st,
+ const opus_int16 *pcm,
+ int frame_size,
+ unsigned char *data,
+ opus_int32 max_data_bytes
+) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2) OPUS_ARG_NONNULL(4);
+
+/** Encodes an Opus frame from floating point input.
+ * @param [in] st OpusEncoder*: Encoder state
+ * @param [in] pcm float*: Input in float format (interleaved if 2 channels), with a normal range of +/-1.0.
+ * Samples with a range beyond +/-1.0 are supported but will
+ * be clipped by decoders using the integer API and should
+ * only be used if it is known that the far end supports
+ * extended dynamic range.
+ * length is frame_size*channels*sizeof(float)
+ * @param [in] frame_size int: Number of samples per channel in the
+ * input signal.
+ * This must be an Opus frame size for
+ * the encoder's sampling rate.
+ * For example, at 48 kHz the permitted
+ * values are 120, 240, 480, 960, 1920,
+ * and 2880.
+ * Passing in a duration of less than
+ * 10 ms (480 samples at 48 kHz) will
+ * prevent the encoder from using the LPC
+ * or hybrid modes.
+ * @param [out] data unsigned char*: Output payload.
+ * This must contain storage for at
+ * least \a max_data_bytes.
+ * @param [in] max_data_bytes opus_int32: Size of the allocated
+ * memory for the output
+ * payload. This may be
+ * used to impose an upper limit on
+ * the instant bitrate, but should
+ * not be used as the only bitrate
+ * control. Use #OPUS_SET_BITRATE to
+ * control the bitrate.
+ * @returns The length of the encoded packet (in bytes) on success or a
+ * negative error code (see @ref opus_errorcodes) on failure.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_encode_float(
+ OpusEncoder *st,
+ const float *pcm,
+ int frame_size,
+ unsigned char *data,
+ opus_int32 max_data_bytes
+) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2) OPUS_ARG_NONNULL(4);
+
+/** Frees an OpusEncoder allocated by opus_encoder_create().
+ * @param[in] st OpusEncoder*: State to be freed.
+ */
+OPUS_EXPORT void opus_encoder_destroy(OpusEncoder *st);
+
+/** Perform a CTL function on an Opus encoder.
+ *
+ * Generally the request and subsequent arguments are generated
+ * by a convenience macro.
+ * @param st OpusEncoder*: Encoder state.
+ * @param request This and all remaining parameters should be replaced by one
+ * of the convenience macros in @ref opus_genericctls or
+ * @ref opus_encoderctls.
+ * @see opus_genericctls
+ * @see opus_encoderctls
+ */
+OPUS_EXPORT int opus_encoder_ctl(OpusEncoder *st, int request, ...) OPUS_ARG_NONNULL(1);
+/**@}*/
+
+/** @defgroup opus_decoder Opus Decoder
+ * @{
+ *
+ * @brief This page describes the process and functions used to decode Opus.
+ *
+ * The decoding process also starts with creating a decoder
+ * state. This can be done with:
+ * @code
+ * int error;
+ * OpusDecoder *dec;
+ * dec = opus_decoder_create(Fs, channels, &error);
+ * @endcode
+ * where
+ * @li Fs is the sampling rate and must be 8000, 12000, 16000, 24000, or 48000
+ * @li channels is the number of channels (1 or 2)
+ * @li error will hold the error code in case of failure (or #OPUS_OK on success)
+ * @li the return value is a newly created decoder state to be used for decoding
+ *
+ * While opus_decoder_create() allocates memory for the state, it's also possible
+ * to initialize pre-allocated memory:
+ * @code
+ * int size;
+ * int error;
+ * OpusDecoder *dec;
+ * size = opus_decoder_get_size(channels);
+ * dec = malloc(size);
+ * error = opus_decoder_init(dec, Fs, channels);
+ * @endcode
+ * where opus_decoder_get_size() returns the required size for the decoder state. Note that
+ * future versions of this code may change the size, so no assuptions should be made about it.
+ *
+ * The decoder state is always continuous in memory and only a shallow copy is sufficient
+ * to copy it (e.g. memcpy())
+ *
+ * To decode a frame, opus_decode() or opus_decode_float() must be called with a packet of compressed audio data:
+ * @code
+ * frame_size = opus_decode(dec, packet, len, decoded, max_size, 0);
+ * @endcode
+ * where
+ *
+ * @li packet is the byte array containing the compressed data
+ * @li len is the exact number of bytes contained in the packet
+ * @li decoded is the decoded audio data in opus_int16 (or float for opus_decode_float())
+ * @li max_size is the max duration of the frame in samples (per channel) that can fit into the decoded_frame array
+ *
+ * opus_decode() and opus_decode_float() return the number of samples (per channel) decoded from the packet.
+ * If that value is negative, then an error has occurred. This can occur if the packet is corrupted or if the audio
+ * buffer is too small to hold the decoded audio.
+ *
+ * Opus is a stateful codec with overlapping blocks and as a result Opus
+ * packets are not coded independently of each other. Packets must be
+ * passed into the decoder serially and in the correct order for a correct
+ * decode. Lost packets can be replaced with loss concealment by calling
+ * the decoder with a null pointer and zero length for the missing packet.
+ *
+ * A single codec state may only be accessed from a single thread at
+ * a time and any required locking must be performed by the caller. Separate
+ * streams must be decoded with separate decoder states and can be decoded
+ * in parallel unless the library was compiled with NONTHREADSAFE_PSEUDOSTACK
+ * defined.
+ *
+ */
+
+/** Opus decoder state.
+ * This contains the complete state of an Opus decoder.
+ * It is position independent and can be freely copied.
+ * @see opus_decoder_create,opus_decoder_init
+ */
+typedef struct OpusDecoder OpusDecoder;
+
+/** Gets the size of an OpusDecoder structure.
+ * @param [in] channels int: Number of channels.
+ * This must be 1 or 2.
+ * @returns The size in bytes.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_decoder_get_size(int channels);
+
+/** Allocates and initializes a decoder state.
+ * @param [in] Fs opus_int32: Sample rate to decode at (Hz).
+ * This must be one of 8000, 12000, 16000,
+ * 24000, or 48000.
+ * @param [in] channels int: Number of channels (1 or 2) to decode
+ * @param [out] error int*: #OPUS_OK Success or @ref opus_errorcodes
+ *
+ * Internally Opus stores data at 48000 Hz, so that should be the default
+ * value for Fs. However, the decoder can efficiently decode to buffers
+ * at 8, 12, 16, and 24 kHz so if for some reason the caller cannot use
+ * data at the full sample rate, or knows the compressed data doesn't
+ * use the full frequency range, it can request decoding at a reduced
+ * rate. Likewise, the decoder is capable of filling in either mono or
+ * interleaved stereo pcm buffers, at the caller's request.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusDecoder *opus_decoder_create(
+ opus_int32 Fs,
+ int channels,
+ int *error
+);
+
+/** Initializes a previously allocated decoder state.
+ * The state must be at least the size returned by opus_decoder_get_size().
+ * This is intended for applications which use their own allocator instead of malloc. @see opus_decoder_create,opus_decoder_get_size
+ * To reset a previously initialized state, use the #OPUS_RESET_STATE CTL.
+ * @param [in] st OpusDecoder*: Decoder state.
+ * @param [in] Fs opus_int32: Sampling rate to decode to (Hz).
+ * This must be one of 8000, 12000, 16000,
+ * 24000, or 48000.
+ * @param [in] channels int: Number of channels (1 or 2) to decode
+ * @retval #OPUS_OK Success or @ref opus_errorcodes
+ */
+OPUS_EXPORT int opus_decoder_init(
+ OpusDecoder *st,
+ opus_int32 Fs,
+ int channels
+) OPUS_ARG_NONNULL(1);
+
+/** Decode an Opus packet.
+ * @param [in] st OpusDecoder*: Decoder state
+ * @param [in] data char*: Input payload. Use a NULL pointer to indicate packet loss
+ * @param [in] len opus_int32: Number of bytes in payload*
+ * @param [out] pcm opus_int16*: Output signal (interleaved if 2 channels). length
+ * is frame_size*channels*sizeof(opus_int16)
+ * @param [in] frame_size Number of samples per channel of available space in \a pcm.
+ * If this is less than the maximum packet duration (120ms; 5760 for 48kHz), this function will
+ * not be capable of decoding some packets. In the case of PLC (data==NULL) or FEC (decode_fec=1),
+ * then frame_size needs to be exactly the duration of audio that is missing, otherwise the
+ * decoder will not be in the optimal state to decode the next incoming packet. For the PLC and
+ * FEC cases, frame_size must be a multiple of 2.5 ms.
+ * @param [in] decode_fec int: Flag (0 or 1) to request that any in-band forward error correction data be
+ * decoded. If no such data is available, the frame is decoded as if it were lost.
+ * @returns Number of decoded samples or @ref opus_errorcodes
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_decode(
+ OpusDecoder *st,
+ const unsigned char *data,
+ opus_int32 len,
+ opus_int16 *pcm,
+ int frame_size,
+ int decode_fec
+) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(4);
+
+/** Decode an Opus packet with floating point output.
+ * @param [in] st OpusDecoder*: Decoder state
+ * @param [in] data char*: Input payload. Use a NULL pointer to indicate packet loss
+ * @param [in] len opus_int32: Number of bytes in payload
+ * @param [out] pcm float*: Output signal (interleaved if 2 channels). length
+ * is frame_size*channels*sizeof(float)
+ * @param [in] frame_size Number of samples per channel of available space in \a pcm.
+ * If this is less than the maximum packet duration (120ms; 5760 for 48kHz), this function will
+ * not be capable of decoding some packets. In the case of PLC (data==NULL) or FEC (decode_fec=1),
+ * then frame_size needs to be exactly the duration of audio that is missing, otherwise the
+ * decoder will not be in the optimal state to decode the next incoming packet. For the PLC and
+ * FEC cases, frame_size must be a multiple of 2.5 ms.
+ * @param [in] decode_fec int: Flag (0 or 1) to request that any in-band forward error correction data be
+ * decoded. If no such data is available the frame is decoded as if it were lost.
+ * @returns Number of decoded samples or @ref opus_errorcodes
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_decode_float(
+ OpusDecoder *st,
+ const unsigned char *data,
+ opus_int32 len,
+ float *pcm,
+ int frame_size,
+ int decode_fec
+) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(4);
+
+/** Perform a CTL function on an Opus decoder.
+ *
+ * Generally the request and subsequent arguments are generated
+ * by a convenience macro.
+ * @param st OpusDecoder*: Decoder state.
+ * @param request This and all remaining parameters should be replaced by one
+ * of the convenience macros in @ref opus_genericctls or
+ * @ref opus_decoderctls.
+ * @see opus_genericctls
+ * @see opus_decoderctls
+ */
+OPUS_EXPORT int opus_decoder_ctl(OpusDecoder *st, int request, ...) OPUS_ARG_NONNULL(1);
+
+/** Frees an OpusDecoder allocated by opus_decoder_create().
+ * @param[in] st OpusDecoder*: State to be freed.
+ */
+OPUS_EXPORT void opus_decoder_destroy(OpusDecoder *st);
+
+/** Parse an opus packet into one or more frames.
+ * Opus_decode will perform this operation internally so most applications do
+ * not need to use this function.
+ * This function does not copy the frames, the returned pointers are pointers into
+ * the input packet.
+ * @param [in] data char*: Opus packet to be parsed
+ * @param [in] len opus_int32: size of data
+ * @param [out] out_toc char*: TOC pointer
+ * @param [out] frames char*[48] encapsulated frames
+ * @param [out] size opus_int16[48] sizes of the encapsulated frames
+ * @param [out] payload_offset int*: returns the position of the payload within the packet (in bytes)
+ * @returns number of frames
+ */
+OPUS_EXPORT int opus_packet_parse(
+ const unsigned char *data,
+ opus_int32 len,
+ unsigned char *out_toc,
+ const unsigned char *frames[48],
+ opus_int16 size[48],
+ int *payload_offset
+) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(5);
+
+/** Gets the bandwidth of an Opus packet.
+ * @param [in] data char*: Opus packet
+ * @retval OPUS_BANDWIDTH_NARROWBAND Narrowband (4kHz bandpass)
+ * @retval OPUS_BANDWIDTH_MEDIUMBAND Mediumband (6kHz bandpass)
+ * @retval OPUS_BANDWIDTH_WIDEBAND Wideband (8kHz bandpass)
+ * @retval OPUS_BANDWIDTH_SUPERWIDEBAND Superwideband (12kHz bandpass)
+ * @retval OPUS_BANDWIDTH_FULLBAND Fullband (20kHz bandpass)
+ * @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_packet_get_bandwidth(const unsigned char *data) OPUS_ARG_NONNULL(1);
+
+/** Gets the number of samples per frame from an Opus packet.
+ * @param [in] data char*: Opus packet.
+ * This must contain at least one byte of
+ * data.
+ * @param [in] Fs opus_int32: Sampling rate in Hz.
+ * This must be a multiple of 400, or
+ * inaccurate results will be returned.
+ * @returns Number of samples per frame.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_packet_get_samples_per_frame(const unsigned char *data, opus_int32 Fs) OPUS_ARG_NONNULL(1);
+
+/** Gets the number of channels from an Opus packet.
+ * @param [in] data char*: Opus packet
+ * @returns Number of channels
+ * @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_packet_get_nb_channels(const unsigned char *data) OPUS_ARG_NONNULL(1);
+
+/** Gets the number of frames in an Opus packet.
+ * @param [in] packet char*: Opus packet
+ * @param [in] len opus_int32: Length of packet
+ * @returns Number of frames
+ * @retval OPUS_BAD_ARG Insufficient data was passed to the function
+ * @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_packet_get_nb_frames(const unsigned char packet[], opus_int32 len) OPUS_ARG_NONNULL(1);
+
+/** Gets the number of samples of an Opus packet.
+ * @param [in] packet char*: Opus packet
+ * @param [in] len opus_int32: Length of packet
+ * @param [in] Fs opus_int32: Sampling rate in Hz.
+ * This must be a multiple of 400, or
+ * inaccurate results will be returned.
+ * @returns Number of samples
+ * @retval OPUS_BAD_ARG Insufficient data was passed to the function
+ * @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_packet_get_nb_samples(const unsigned char packet[], opus_int32 len, opus_int32 Fs) OPUS_ARG_NONNULL(1);
+
+/** Gets the number of samples of an Opus packet.
+ * @param [in] dec OpusDecoder*: Decoder state
+ * @param [in] packet char*: Opus packet
+ * @param [in] len opus_int32: Length of packet
+ * @returns Number of samples
+ * @retval OPUS_BAD_ARG Insufficient data was passed to the function
+ * @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_decoder_get_nb_samples(const OpusDecoder *dec, const unsigned char packet[], opus_int32 len) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2);
+
+/** Applies soft-clipping to bring a float signal within the [-1,1] range. If
+ * the signal is already in that range, nothing is done. If there are values
+ * outside of [-1,1], then the signal is clipped as smoothly as possible to
+ * both fit in the range and avoid creating excessive distortion in the
+ * process.
+ * @param [in,out] pcm float*: Input PCM and modified PCM
+ * @param [in] frame_size int Number of samples per channel to process
+ * @param [in] channels int: Number of channels
+ * @param [in,out] softclip_mem float*: State memory for the soft clipping process (one float per channel, initialized to zero)
+ */
+OPUS_EXPORT void opus_pcm_soft_clip(float *pcm, int frame_size, int channels, float *softclip_mem);
+
+
+/**@}*/
+
+/** @defgroup opus_repacketizer Repacketizer
+ * @{
+ *
+ * The repacketizer can be used to merge multiple Opus packets into a single
+ * packet or alternatively to split Opus packets that have previously been
+ * merged. Splitting valid Opus packets is always guaranteed to succeed,
+ * whereas merging valid packets only succeeds if all frames have the same
+ * mode, bandwidth, and frame size, and when the total duration of the merged
+ * packet is no more than 120 ms. The 120 ms limit comes from the
+ * specification and limits decoder memory requirements at a point where
+ * framing overhead becomes negligible.
+ *
+ * The repacketizer currently only operates on elementary Opus
+ * streams. It will not manipualte multistream packets successfully, except in
+ * the degenerate case where they consist of data from a single stream.
+ *
+ * The repacketizing process starts with creating a repacketizer state, either
+ * by calling opus_repacketizer_create() or by allocating the memory yourself,
+ * e.g.,
+ * @code
+ * OpusRepacketizer *rp;
+ * rp = (OpusRepacketizer*)malloc(opus_repacketizer_get_size());
+ * if (rp != NULL)
+ * opus_repacketizer_init(rp);
+ * @endcode
+ *
+ * Then the application should submit packets with opus_repacketizer_cat(),
+ * extract new packets with opus_repacketizer_out() or
+ * opus_repacketizer_out_range(), and then reset the state for the next set of
+ * input packets via opus_repacketizer_init().
+ *
+ * For example, to split a sequence of packets into individual frames:
+ * @code
+ * unsigned char *data;
+ * int len;
+ * while (get_next_packet(&data, &len))
+ * {
+ * unsigned char out[1276];
+ * opus_int32 out_len;
+ * int nb_frames;
+ * int err;
+ * int i;
+ * err = opus_repacketizer_cat(rp, data, len);
+ * if (err != OPUS_OK)
+ * {
+ * release_packet(data);
+ * return err;
+ * }
+ * nb_frames = opus_repacketizer_get_nb_frames(rp);
+ * for (i = 0; i < nb_frames; i++)
+ * {
+ * out_len = opus_repacketizer_out_range(rp, i, i+1, out, sizeof(out));
+ * if (out_len < 0)
+ * {
+ * release_packet(data);
+ * return (int)out_len;
+ * }
+ * output_next_packet(out, out_len);
+ * }
+ * opus_repacketizer_init(rp);
+ * release_packet(data);
+ * }
+ * @endcode
+ *
+ * Alternatively, to combine a sequence of frames into packets that each
+ * contain up to TARGET_DURATION_MS milliseconds of data:
+ * @code
+ * // The maximum number of packets with duration TARGET_DURATION_MS occurs
+ * // when the frame size is 2.5 ms, for a total of (TARGET_DURATION_MS*2/5)
+ * // packets.
+ * unsigned char *data[(TARGET_DURATION_MS*2/5)+1];
+ * opus_int32 len[(TARGET_DURATION_MS*2/5)+1];
+ * int nb_packets;
+ * unsigned char out[1277*(TARGET_DURATION_MS*2/2)];
+ * opus_int32 out_len;
+ * int prev_toc;
+ * nb_packets = 0;
+ * while (get_next_packet(data+nb_packets, len+nb_packets))
+ * {
+ * int nb_frames;
+ * int err;
+ * nb_frames = opus_packet_get_nb_frames(data[nb_packets], len[nb_packets]);
+ * if (nb_frames < 1)
+ * {
+ * release_packets(data, nb_packets+1);
+ * return nb_frames;
+ * }
+ * nb_frames += opus_repacketizer_get_nb_frames(rp);
+ * // If adding the next packet would exceed our target, or it has an
+ * // incompatible TOC sequence, output the packets we already have before
+ * // submitting it.
+ * // N.B., The nb_packets > 0 check ensures we've submitted at least one
+ * // packet since the last call to opus_repacketizer_init(). Otherwise a
+ * // single packet longer than TARGET_DURATION_MS would cause us to try to
+ * // output an (invalid) empty packet. It also ensures that prev_toc has
+ * // been set to a valid value. Additionally, len[nb_packets] > 0 is
+ * // guaranteed by the call to opus_packet_get_nb_frames() above, so the
+ * // reference to data[nb_packets][0] should be valid.
+ * if (nb_packets > 0 && (
+ * ((prev_toc & 0xFC) != (data[nb_packets][0] & 0xFC)) ||
+ * opus_packet_get_samples_per_frame(data[nb_packets], 48000)*nb_frames >
+ * TARGET_DURATION_MS*48))
+ * {
+ * out_len = opus_repacketizer_out(rp, out, sizeof(out));
+ * if (out_len < 0)
+ * {
+ * release_packets(data, nb_packets+1);
+ * return (int)out_len;
+ * }
+ * output_next_packet(out, out_len);
+ * opus_repacketizer_init(rp);
+ * release_packets(data, nb_packets);
+ * data[0] = data[nb_packets];
+ * len[0] = len[nb_packets];
+ * nb_packets = 0;
+ * }
+ * err = opus_repacketizer_cat(rp, data[nb_packets], len[nb_packets]);
+ * if (err != OPUS_OK)
+ * {
+ * release_packets(data, nb_packets+1);
+ * return err;
+ * }
+ * prev_toc = data[nb_packets][0];
+ * nb_packets++;
+ * }
+ * // Output the final, partial packet.
+ * if (nb_packets > 0)
+ * {
+ * out_len = opus_repacketizer_out(rp, out, sizeof(out));
+ * release_packets(data, nb_packets);
+ * if (out_len < 0)
+ * return (int)out_len;
+ * output_next_packet(out, out_len);
+ * }
+ * @endcode
+ *
+ * An alternate way of merging packets is to simply call opus_repacketizer_cat()
+ * unconditionally until it fails. At that point, the merged packet can be
+ * obtained with opus_repacketizer_out() and the input packet for which
+ * opus_repacketizer_cat() needs to be re-added to a newly reinitialized
+ * repacketizer state.
+ */
+
+typedef struct OpusRepacketizer OpusRepacketizer;
+
+/** Gets the size of an OpusRepacketizer structure.
+ * @returns The size in bytes.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_repacketizer_get_size(void);
+
+/** (Re)initializes a previously allocated repacketizer state.
+ * The state must be at least the size returned by opus_repacketizer_get_size().
+ * This can be used for applications which use their own allocator instead of
+ * malloc().
+ * It must also be called to reset the queue of packets waiting to be
+ * repacketized, which is necessary if the maximum packet duration of 120 ms
+ * is reached or if you wish to submit packets with a different Opus
+ * configuration (coding mode, audio bandwidth, frame size, or channel count).
+ * Failure to do so will prevent a new packet from being added with
+ * opus_repacketizer_cat().
+ * @see opus_repacketizer_create
+ * @see opus_repacketizer_get_size
+ * @see opus_repacketizer_cat
+ * @param rp OpusRepacketizer*: The repacketizer state to
+ * (re)initialize.
+ * @returns A pointer to the same repacketizer state that was passed in.
+ */
+OPUS_EXPORT OpusRepacketizer *opus_repacketizer_init(OpusRepacketizer *rp) OPUS_ARG_NONNULL(1);
+
+/** Allocates memory and initializes the new repacketizer with
+ * opus_repacketizer_init().
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusRepacketizer *opus_repacketizer_create(void);
+
+/** Frees an OpusRepacketizer allocated by
+ * opus_repacketizer_create().
+ * @param[in] rp OpusRepacketizer*: State to be freed.
+ */
+OPUS_EXPORT void opus_repacketizer_destroy(OpusRepacketizer *rp);
+
+/** Add a packet to the current repacketizer state.
+ * This packet must match the configuration of any packets already submitted
+ * for repacketization since the last call to opus_repacketizer_init().
+ * This means that it must have the same coding mode, audio bandwidth, frame
+ * size, and channel count.
+ * This can be checked in advance by examining the top 6 bits of the first
+ * byte of the packet, and ensuring they match the top 6 bits of the first
+ * byte of any previously submitted packet.
+ * The total duration of audio in the repacketizer state also must not exceed
+ * 120 ms, the maximum duration of a single packet, after adding this packet.
+ *
+ * The contents of the current repacketizer state can be extracted into new
+ * packets using opus_repacketizer_out() or opus_repacketizer_out_range().
+ *
+ * In order to add a packet with a different configuration or to add more
+ * audio beyond 120 ms, you must clear the repacketizer state by calling
+ * opus_repacketizer_init().
+ * If a packet is too large to add to the current repacketizer state, no part
+ * of it is added, even if it contains multiple frames, some of which might
+ * fit.
+ * If you wish to be able to add parts of such packets, you should first use
+ * another repacketizer to split the packet into pieces and add them
+ * individually.
+ * @see opus_repacketizer_out_range
+ * @see opus_repacketizer_out
+ * @see opus_repacketizer_init
+ * @param rp OpusRepacketizer*: The repacketizer state to which to
+ * add the packet.
+ * @param[in] data const unsigned char*: The packet data.
+ * The application must ensure
+ * this pointer remains valid
+ * until the next call to
+ * opus_repacketizer_init() or
+ * opus_repacketizer_destroy().
+ * @param len opus_int32: The number of bytes in the packet data.
+ * @returns An error code indicating whether or not the operation succeeded.
+ * @retval #OPUS_OK The packet's contents have been added to the repacketizer
+ * state.
+ * @retval #OPUS_INVALID_PACKET The packet did not have a valid TOC sequence,
+ * the packet's TOC sequence was not compatible
+ * with previously submitted packets (because
+ * the coding mode, audio bandwidth, frame size,
+ * or channel count did not match), or adding
+ * this packet would increase the total amount of
+ * audio stored in the repacketizer state to more
+ * than 120 ms.
+ */
+OPUS_EXPORT int opus_repacketizer_cat(OpusRepacketizer *rp, const unsigned char *data, opus_int32 len) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2);
+
+
+/** Construct a new packet from data previously submitted to the repacketizer
+ * state via opus_repacketizer_cat().
+ * @param rp OpusRepacketizer*: The repacketizer state from which to
+ * construct the new packet.
+ * @param begin int: The index of the first frame in the current
+ * repacketizer state to include in the output.
+ * @param end int: One past the index of the last frame in the
+ * current repacketizer state to include in the
+ * output.
+ * @param[out] data const unsigned char*: The buffer in which to
+ * store the output packet.
+ * @param maxlen opus_int32: The maximum number of bytes to store in
+ * the output buffer. In order to guarantee
+ * success, this should be at least
+ * 1276 for a single frame,
+ * or for multiple frames,
+ * 1277*(end-begin).
+ * However, 1*(end-begin) plus
+ * the size of all packet data submitted to
+ * the repacketizer since the last call to
+ * opus_repacketizer_init() or
+ * opus_repacketizer_create() is also
+ * sufficient, and possibly much smaller.
+ * @returns The total size of the output packet on success, or an error code
+ * on failure.
+ * @retval #OPUS_BAD_ARG [begin,end) was an invalid range of
+ * frames (begin < 0, begin >= end, or end >
+ * opus_repacketizer_get_nb_frames()).
+ * @retval #OPUS_BUFFER_TOO_SMALL \a maxlen was insufficient to contain the
+ * complete output packet.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_repacketizer_out_range(OpusRepacketizer *rp, int begin, int end, unsigned char *data, opus_int32 maxlen) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(4);
+
+/** Return the total number of frames contained in packet data submitted to
+ * the repacketizer state so far via opus_repacketizer_cat() since the last
+ * call to opus_repacketizer_init() or opus_repacketizer_create().
+ * This defines the valid range of packets that can be extracted with
+ * opus_repacketizer_out_range() or opus_repacketizer_out().
+ * @param rp OpusRepacketizer*: The repacketizer state containing the
+ * frames.
+ * @returns The total number of frames contained in the packet data submitted
+ * to the repacketizer state.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_repacketizer_get_nb_frames(OpusRepacketizer *rp) OPUS_ARG_NONNULL(1);
+
+/** Construct a new packet from data previously submitted to the repacketizer
+ * state via opus_repacketizer_cat().
+ * This is a convenience routine that returns all the data submitted so far
+ * in a single packet.
+ * It is equivalent to calling
+ * @code
+ * opus_repacketizer_out_range(rp, 0, opus_repacketizer_get_nb_frames(rp),
+ * data, maxlen)
+ * @endcode
+ * @param rp OpusRepacketizer*: The repacketizer state from which to
+ * construct the new packet.
+ * @param[out] data const unsigned char*: The buffer in which to
+ * store the output packet.
+ * @param maxlen opus_int32: The maximum number of bytes to store in
+ * the output buffer. In order to guarantee
+ * success, this should be at least
+ * 1277*opus_repacketizer_get_nb_frames(rp).
+ * However,
+ * 1*opus_repacketizer_get_nb_frames(rp)
+ * plus the size of all packet data
+ * submitted to the repacketizer since the
+ * last call to opus_repacketizer_init() or
+ * opus_repacketizer_create() is also
+ * sufficient, and possibly much smaller.
+ * @returns The total size of the output packet on success, or an error code
+ * on failure.
+ * @retval #OPUS_BUFFER_TOO_SMALL \a maxlen was insufficient to contain the
+ * complete output packet.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_repacketizer_out(OpusRepacketizer *rp, unsigned char *data, opus_int32 maxlen) OPUS_ARG_NONNULL(1);
+
+/** Pads a given Opus packet to a larger size (possibly changing the TOC sequence).
+ * @param[in,out] data const unsigned char*: The buffer containing the
+ * packet to pad.
+ * @param len opus_int32: The size of the packet.
+ * This must be at least 1.
+ * @param new_len opus_int32: The desired size of the packet after padding.
+ * This must be at least as large as len.
+ * @returns an error code
+ * @retval #OPUS_OK \a on success.
+ * @retval #OPUS_BAD_ARG \a len was less than 1 or new_len was less than len.
+ * @retval #OPUS_INVALID_PACKET \a data did not contain a valid Opus packet.
+ */
+OPUS_EXPORT int opus_packet_pad(unsigned char *data, opus_int32 len, opus_int32 new_len);
+
+/** Remove all padding from a given Opus packet and rewrite the TOC sequence to
+ * minimize space usage.
+ * @param[in,out] data const unsigned char*: The buffer containing the
+ * packet to strip.
+ * @param len opus_int32: The size of the packet.
+ * This must be at least 1.
+ * @returns The new size of the output packet on success, or an error code
+ * on failure.
+ * @retval #OPUS_BAD_ARG \a len was less than 1.
+ * @retval #OPUS_INVALID_PACKET \a data did not contain a valid Opus packet.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_packet_unpad(unsigned char *data, opus_int32 len);
+
+/** Pads a given Opus multi-stream packet to a larger size (possibly changing the TOC sequence).
+ * @param[in,out] data const unsigned char*: The buffer containing the
+ * packet to pad.
+ * @param len opus_int32: The size of the packet.
+ * This must be at least 1.
+ * @param new_len opus_int32: The desired size of the packet after padding.
+ * This must be at least 1.
+ * @param nb_streams opus_int32: The number of streams (not channels) in the packet.
+ * This must be at least as large as len.
+ * @returns an error code
+ * @retval #OPUS_OK \a on success.
+ * @retval #OPUS_BAD_ARG \a len was less than 1.
+ * @retval #OPUS_INVALID_PACKET \a data did not contain a valid Opus packet.
+ */
+OPUS_EXPORT int opus_multistream_packet_pad(unsigned char *data, opus_int32 len, opus_int32 new_len, int nb_streams);
+
+/** Remove all padding from a given Opus multi-stream packet and rewrite the TOC sequence to
+ * minimize space usage.
+ * @param[in,out] data const unsigned char*: The buffer containing the
+ * packet to strip.
+ * @param len opus_int32: The size of the packet.
+ * This must be at least 1.
+ * @param nb_streams opus_int32: The number of streams (not channels) in the packet.
+ * This must be at least 1.
+ * @returns The new size of the output packet on success, or an error code
+ * on failure.
+ * @retval #OPUS_BAD_ARG \a len was less than 1 or new_len was less than len.
+ * @retval #OPUS_INVALID_PACKET \a data did not contain a valid Opus packet.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_multistream_packet_unpad(unsigned char *data, opus_int32 len, int nb_streams);
+
+/**@}*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* OPUS_H */
diff --git a/app/src/main/cpp/opus_custom.h b/app/src/main/cpp/opus_custom.h
new file mode 100644
index 0000000..41f36bf
--- /dev/null
+++ b/app/src/main/cpp/opus_custom.h
@@ -0,0 +1,342 @@
+/* Copyright (c) 2007-2008 CSIRO
+ Copyright (c) 2007-2009 Xiph.Org Foundation
+ Copyright (c) 2008-2012 Gregory Maxwell
+ Written by Jean-Marc Valin and Gregory Maxwell */
+/*
+ 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.
+*/
+
+/**
+ @file opus_custom.h
+ @brief Opus-Custom reference implementation API
+ */
+
+#ifndef OPUS_CUSTOM_H
+#define OPUS_CUSTOM_H
+
+#include "opus_defines.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef CUSTOM_MODES
+# define OPUS_CUSTOM_EXPORT OPUS_EXPORT
+# define OPUS_CUSTOM_EXPORT_STATIC OPUS_EXPORT
+#else
+# define OPUS_CUSTOM_EXPORT
+# ifdef OPUS_BUILD
+# define OPUS_CUSTOM_EXPORT_STATIC static OPUS_INLINE
+# else
+# define OPUS_CUSTOM_EXPORT_STATIC
+# endif
+#endif
+
+/** @defgroup opus_custom Opus Custom
+ * @{
+ * Opus Custom is an optional part of the Opus specification and
+ * reference implementation which uses a distinct API from the regular
+ * API and supports frame sizes that are not normally supported.\ Use
+ * of Opus Custom is discouraged for all but very special applications
+ * for which a frame size different from 2.5, 5, 10, or 20 ms is needed
+ * (for either complexity or latency reasons) and where interoperability
+ * is less important.
+ *
+ * In addition to the interoperability limitations the use of Opus custom
+ * disables a substantial chunk of the codec and generally lowers the
+ * quality available at a given bitrate. Normally when an application needs
+ * a different frame size from the codec it should buffer to match the
+ * sizes but this adds a small amount of delay which may be important
+ * in some very low latency applications. Some transports (especially
+ * constant rate RF transports) may also work best with frames of
+ * particular durations.
+ *
+ * Libopus only supports custom modes if they are enabled at compile time.
+ *
+ * The Opus Custom API is similar to the regular API but the
+ * @ref opus_encoder_create and @ref opus_decoder_create calls take
+ * an additional mode parameter which is a structure produced by
+ * a call to @ref opus_custom_mode_create. Both the encoder and decoder
+ * must create a mode using the same sample rate (fs) and frame size
+ * (frame size) so these parameters must either be signaled out of band
+ * or fixed in a particular implementation.
+ *
+ * Similar to regular Opus the custom modes support on the fly frame size
+ * switching, but the sizes available depend on the particular frame size in
+ * use. For some initial frame sizes on a single on the fly size is available.
+ */
+
+/** Contains the state of an encoder. One encoder state is needed
+ for each stream. It is initialized once at the beginning of the
+ stream. Do *not* re-initialize the state for every frame.
+ @brief Encoder state
+ */
+typedef struct OpusCustomEncoder OpusCustomEncoder;
+
+/** State of the decoder. One decoder state is needed for each stream.
+ It is initialized once at the beginning of the stream. Do *not*
+ re-initialize the state for every frame.
+ @brief Decoder state
+ */
+typedef struct OpusCustomDecoder OpusCustomDecoder;
+
+/** The mode contains all the information necessary to create an
+ encoder. Both the encoder and decoder need to be initialized
+ with exactly the same mode, otherwise the output will be
+ corrupted.
+ @brief Mode configuration
+ */
+typedef struct OpusCustomMode OpusCustomMode;
+
+/** Creates a new mode struct. This will be passed to an encoder or
+ * decoder. The mode MUST NOT BE DESTROYED until the encoders and
+ * decoders that use it are destroyed as well.
+ * @param [in] Fs int: Sampling rate (8000 to 96000 Hz)
+ * @param [in] frame_size int: Number of samples (per channel) to encode in each
+ * packet (64 - 1024, prime factorization must contain zero or more 2s, 3s, or 5s and no other primes)
+ * @param [out] error int*: Returned error code (if NULL, no error will be returned)
+ * @return A newly created mode
+ */
+OPUS_CUSTOM_EXPORT OPUS_WARN_UNUSED_RESULT OpusCustomMode *opus_custom_mode_create(opus_int32 Fs, int frame_size, int *error);
+
+/** Destroys a mode struct. Only call this after all encoders and
+ * decoders using this mode are destroyed as well.
+ * @param [in] mode OpusCustomMode*: Mode to be freed.
+ */
+OPUS_CUSTOM_EXPORT void opus_custom_mode_destroy(OpusCustomMode *mode);
+
+
+#if !defined(OPUS_BUILD) || defined(CELT_ENCODER_C)
+
+/* Encoder */
+/** Gets the size of an OpusCustomEncoder structure.
+ * @param [in] mode OpusCustomMode *: Mode configuration
+ * @param [in] channels int: Number of channels
+ * @returns size
+ */
+OPUS_CUSTOM_EXPORT_STATIC OPUS_WARN_UNUSED_RESULT int opus_custom_encoder_get_size(
+ const OpusCustomMode *mode,
+ int channels
+) OPUS_ARG_NONNULL(1);
+
+# ifdef CUSTOM_MODES
+/** Initializes a previously allocated encoder state
+ * The memory pointed to by st must be the size returned by opus_custom_encoder_get_size.
+ * This is intended for applications which use their own allocator instead of malloc.
+ * @see opus_custom_encoder_create(),opus_custom_encoder_get_size()
+ * To reset a previously initialized state use the OPUS_RESET_STATE CTL.
+ * @param [in] st OpusCustomEncoder*: Encoder state
+ * @param [in] mode OpusCustomMode *: Contains all the information about the characteristics of
+ * the stream (must be the same characteristics as used for the
+ * decoder)
+ * @param [in] channels int: Number of channels
+ * @return OPUS_OK Success or @ref opus_errorcodes
+ */
+OPUS_CUSTOM_EXPORT int opus_custom_encoder_init(
+ OpusCustomEncoder *st,
+ const OpusCustomMode *mode,
+ int channels
+) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2);
+# endif
+#endif
+
+
+/** Creates a new encoder state. Each stream needs its own encoder
+ * state (can't be shared across simultaneous streams).
+ * @param [in] mode OpusCustomMode*: Contains all the information about the characteristics of
+ * the stream (must be the same characteristics as used for the
+ * decoder)
+ * @param [in] channels int: Number of channels
+ * @param [out] error int*: Returns an error code
+ * @return Newly created encoder state.
+*/
+OPUS_CUSTOM_EXPORT OPUS_WARN_UNUSED_RESULT OpusCustomEncoder *opus_custom_encoder_create(
+ const OpusCustomMode *mode,
+ int channels,
+ int *error
+) OPUS_ARG_NONNULL(1);
+
+
+/** Destroys a an encoder state.
+ * @param[in] st OpusCustomEncoder*: State to be freed.
+ */
+OPUS_CUSTOM_EXPORT void opus_custom_encoder_destroy(OpusCustomEncoder *st);
+
+/** Encodes a frame of audio.
+ * @param [in] st OpusCustomEncoder*: Encoder state
+ * @param [in] pcm float*: PCM audio in float format, with a normal range of +/-1.0.
+ * Samples with a range beyond +/-1.0 are supported but will
+ * be clipped by decoders using the integer API and should
+ * only be used if it is known that the far end supports
+ * extended dynamic range. There must be exactly
+ * frame_size samples per channel.
+ * @param [in] frame_size int: Number of samples per frame of input signal
+ * @param [out] compressed char *: The compressed data is written here. This may not alias pcm and must be at least maxCompressedBytes long.
+ * @param [in] maxCompressedBytes int: Maximum number of bytes to use for compressing the frame
+ * (can change from one frame to another)
+ * @return Number of bytes written to "compressed".
+ * If negative, an error has occurred (see error codes). It is IMPORTANT that
+ * the length returned be somehow transmitted to the decoder. Otherwise, no
+ * decoding is possible.
+ */
+OPUS_CUSTOM_EXPORT OPUS_WARN_UNUSED_RESULT int opus_custom_encode_float(
+ OpusCustomEncoder *st,
+ const float *pcm,
+ int frame_size,
+ unsigned char *compressed,
+ int maxCompressedBytes
+) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2) OPUS_ARG_NONNULL(4);
+
+/** Encodes a frame of audio.
+ * @param [in] st OpusCustomEncoder*: Encoder state
+ * @param [in] pcm opus_int16*: PCM audio in signed 16-bit format (native endian).
+ * There must be exactly frame_size samples per channel.
+ * @param [in] frame_size int: Number of samples per frame of input signal
+ * @param [out] compressed char *: The compressed data is written here. This may not alias pcm and must be at least maxCompressedBytes long.
+ * @param [in] maxCompressedBytes int: Maximum number of bytes to use for compressing the frame
+ * (can change from one frame to another)
+ * @return Number of bytes written to "compressed".
+ * If negative, an error has occurred (see error codes). It is IMPORTANT that
+ * the length returned be somehow transmitted to the decoder. Otherwise, no
+ * decoding is possible.
+ */
+OPUS_CUSTOM_EXPORT OPUS_WARN_UNUSED_RESULT int opus_custom_encode(
+ OpusCustomEncoder *st,
+ const opus_int16 *pcm,
+ int frame_size,
+ unsigned char *compressed,
+ int maxCompressedBytes
+) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2) OPUS_ARG_NONNULL(4);
+
+/** Perform a CTL function on an Opus custom encoder.
+ *
+ * Generally the request and subsequent arguments are generated
+ * by a convenience macro.
+ * @see opus_encoderctls
+ */
+OPUS_CUSTOM_EXPORT int opus_custom_encoder_ctl(OpusCustomEncoder * OPUS_RESTRICT st, int request, ...) OPUS_ARG_NONNULL(1);
+
+
+#if !defined(OPUS_BUILD) || defined(CELT_DECODER_C)
+/* Decoder */
+
+/** Gets the size of an OpusCustomDecoder structure.
+ * @param [in] mode OpusCustomMode *: Mode configuration
+ * @param [in] channels int: Number of channels
+ * @returns size
+ */
+OPUS_CUSTOM_EXPORT_STATIC OPUS_WARN_UNUSED_RESULT int opus_custom_decoder_get_size(
+ const OpusCustomMode *mode,
+ int channels
+) OPUS_ARG_NONNULL(1);
+
+/** Initializes a previously allocated decoder state
+ * The memory pointed to by st must be the size returned by opus_custom_decoder_get_size.
+ * This is intended for applications which use their own allocator instead of malloc.
+ * @see opus_custom_decoder_create(),opus_custom_decoder_get_size()
+ * To reset a previously initialized state use the OPUS_RESET_STATE CTL.
+ * @param [in] st OpusCustomDecoder*: Decoder state
+ * @param [in] mode OpusCustomMode *: Contains all the information about the characteristics of
+ * the stream (must be the same characteristics as used for the
+ * encoder)
+ * @param [in] channels int: Number of channels
+ * @return OPUS_OK Success or @ref opus_errorcodes
+ */
+OPUS_CUSTOM_EXPORT_STATIC int opus_custom_decoder_init(
+ OpusCustomDecoder *st,
+ const OpusCustomMode *mode,
+ int channels
+) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2);
+
+#endif
+
+
+/** Creates a new decoder state. Each stream needs its own decoder state (can't
+ * be shared across simultaneous streams).
+ * @param [in] mode OpusCustomMode: Contains all the information about the characteristics of the
+ * stream (must be the same characteristics as used for the encoder)
+ * @param [in] channels int: Number of channels
+ * @param [out] error int*: Returns an error code
+ * @return Newly created decoder state.
+ */
+OPUS_CUSTOM_EXPORT OPUS_WARN_UNUSED_RESULT OpusCustomDecoder *opus_custom_decoder_create(
+ const OpusCustomMode *mode,
+ int channels,
+ int *error
+) OPUS_ARG_NONNULL(1);
+
+/** Destroys a an decoder state.
+ * @param[in] st OpusCustomDecoder*: State to be freed.
+ */
+OPUS_CUSTOM_EXPORT void opus_custom_decoder_destroy(OpusCustomDecoder *st);
+
+/** Decode an opus custom frame with floating point output
+ * @param [in] st OpusCustomDecoder*: Decoder state
+ * @param [in] data char*: Input payload. Use a NULL pointer to indicate packet loss
+ * @param [in] len int: Number of bytes in payload
+ * @param [out] pcm float*: Output signal (interleaved if 2 channels). length
+ * is frame_size*channels*sizeof(float)
+ * @param [in] frame_size Number of samples per channel of available space in *pcm.
+ * @returns Number of decoded samples or @ref opus_errorcodes
+ */
+OPUS_CUSTOM_EXPORT OPUS_WARN_UNUSED_RESULT int opus_custom_decode_float(
+ OpusCustomDecoder *st,
+ const unsigned char *data,
+ int len,
+ float *pcm,
+ int frame_size
+) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(4);
+
+/** Decode an opus custom frame
+ * @param [in] st OpusCustomDecoder*: Decoder state
+ * @param [in] data char*: Input payload. Use a NULL pointer to indicate packet loss
+ * @param [in] len int: Number of bytes in payload
+ * @param [out] pcm opus_int16*: Output signal (interleaved if 2 channels). length
+ * is frame_size*channels*sizeof(opus_int16)
+ * @param [in] frame_size Number of samples per channel of available space in *pcm.
+ * @returns Number of decoded samples or @ref opus_errorcodes
+ */
+OPUS_CUSTOM_EXPORT OPUS_WARN_UNUSED_RESULT int opus_custom_decode(
+ OpusCustomDecoder *st,
+ const unsigned char *data,
+ int len,
+ opus_int16 *pcm,
+ int frame_size
+) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(4);
+
+/** Perform a CTL function on an Opus custom decoder.
+ *
+ * Generally the request and subsequent arguments are generated
+ * by a convenience macro.
+ * @see opus_genericctls
+ */
+OPUS_CUSTOM_EXPORT int opus_custom_decoder_ctl(OpusCustomDecoder * OPUS_RESTRICT st, int request, ...) OPUS_ARG_NONNULL(1);
+
+/**@}*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* OPUS_CUSTOM_H */
diff --git a/app/src/main/cpp/opus_decoder.cpp b/app/src/main/cpp/opus_decoder.cpp
new file mode 100644
index 0000000..de94300
--- /dev/null
+++ b/app/src/main/cpp/opus_decoder.cpp
@@ -0,0 +1,70 @@
+#include
+#include
+#include
+#include "opus.h"
+
+#define LOG_TAG "OpusJNI"
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+
+static OpusDecoder* decoderHandle = nullptr;
+
+extern "C" {
+
+JNIEXPORT jlong JNICALL
+Java_info_dourok_voicebot_OpusDecoder_nativeInitDecoder(JNIEnv *env, jobject thiz,
+ jint sample_rate, jint channels) {
+ int error;
+ OpusDecoder *decoder = opus_decoder_create(sample_rate, channels, &error);
+
+ if (error != OPUS_OK || decoder == nullptr) {
+ LOGE("Failed to create decoder: %s", opus_strerror(error));
+ return 0;
+ }
+
+ LOGI("Opus decoder initialized: sample_rate=%d, channels=%d", sample_rate, channels);
+ return (jlong)(intptr_t)decoder;
+}
+
+JNIEXPORT jint JNICALL
+Java_info_dourok_voicebot_OpusDecoder_nativeDecodeBytes(JNIEnv *env, jobject thiz,
+ jlong decoder_handle,
+ jbyteArray input_buffer,
+ jint input_size,
+ jbyteArray output_buffer,
+ jint max_output_size) {
+ OpusDecoder *decoder = (OpusDecoder*)(intptr_t)decoder_handle;
+ if (decoder == nullptr) {
+ LOGE("Decoder handle is null");
+ return -1;
+ }
+
+ jbyte *input = env->GetByteArrayElements(input_buffer, nullptr);
+ jbyte *output = env->GetByteArrayElements(output_buffer, nullptr);
+
+ int frame_size = max_output_size / 2; // 16-bit PCM
+ int result = opus_decode(decoder, (unsigned char*)input, input_size,
+ (opus_int16*)output, frame_size, 0);
+
+ env->ReleaseByteArrayElements(input_buffer, input, JNI_ABORT);
+ env->ReleaseByteArrayElements(output_buffer, output, 0);
+
+ if (result < 0) {
+ LOGE("Decoding failed: %s", opus_strerror(result));
+ return -1;
+ }
+
+ return result * 2; // 返回字节数（每个样本2字节）
+}
+
+JNIEXPORT void JNICALL
+Java_info_dourok_voicebot_OpusDecoder_nativeReleaseDecoder(JNIEnv *env, jobject thiz,
+ jlong decoder_handle) {
+ OpusDecoder *decoder = (OpusDecoder*)(intptr_t)decoder_handle;
+ if (decoder != nullptr) {
+ opus_decoder_destroy(decoder);
+ LOGI("Opus decoder released");
+ }
+}
+
+} // extern "C"
\ No newline at end of file
diff --git a/app/src/main/cpp/opus_defines.h b/app/src/main/cpp/opus_defines.h
new file mode 100644
index 0000000..d141418
--- /dev/null
+++ b/app/src/main/cpp/opus_defines.h
@@ -0,0 +1,799 @@
+/* Copyright (c) 2010-2011 Xiph.Org Foundation, Skype Limited
+ Written by Jean-Marc Valin and Koen Vos */
+/*
+ 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.
+*/
+
+/**
+ * @file opus_defines.h
+ * @brief Opus reference implementation constants
+ */
+
+#ifndef OPUS_DEFINES_H
+#define OPUS_DEFINES_H
+
+#include "opus_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** @defgroup opus_errorcodes Error codes
+ * @{
+ */
+/** No error @hideinitializer*/
+#define OPUS_OK 0
+/** One or more invalid/out of range arguments @hideinitializer*/
+#define OPUS_BAD_ARG -1
+/** Not enough bytes allocated in the buffer @hideinitializer*/
+#define OPUS_BUFFER_TOO_SMALL -2
+/** An internal error was detected @hideinitializer*/
+#define OPUS_INTERNAL_ERROR -3
+/** The compressed data passed is corrupted @hideinitializer*/
+#define OPUS_INVALID_PACKET -4
+/** Invalid/unsupported request number @hideinitializer*/
+#define OPUS_UNIMPLEMENTED -5
+/** An encoder or decoder structure is invalid or already freed @hideinitializer*/
+#define OPUS_INVALID_STATE -6
+/** Memory allocation has failed @hideinitializer*/
+#define OPUS_ALLOC_FAIL -7
+/**@}*/
+
+/** @cond OPUS_INTERNAL_DOC */
+/**Export control for opus functions */
+
+#ifndef OPUS_EXPORT
+# if defined(WIN32)
+# if defined(OPUS_BUILD) && defined(DLL_EXPORT)
+# define OPUS_EXPORT __declspec(dllexport)
+# else
+# define OPUS_EXPORT
+# endif
+# elif defined(__GNUC__) && defined(OPUS_BUILD)
+# define OPUS_EXPORT __attribute__ ((visibility ("default")))
+# else
+# define OPUS_EXPORT
+# endif
+#endif
+
+# if !defined(OPUS_GNUC_PREREQ)
+# if defined(__GNUC__)&&defined(__GNUC_MINOR__)
+# define OPUS_GNUC_PREREQ(_maj,_min) \
+ ((__GNUC__<<16)+__GNUC_MINOR__>=((_maj)<<16)+(_min))
+# else
+# define OPUS_GNUC_PREREQ(_maj,_min) 0
+# endif
+# endif
+
+#if (!defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L) )
+# if OPUS_GNUC_PREREQ(3,0)
+# define OPUS_RESTRICT __restrict__
+# elif (defined(_MSC_VER) && _MSC_VER >= 1400)
+# define OPUS_RESTRICT __restrict
+# else
+# define OPUS_RESTRICT
+# endif
+#else
+# define OPUS_RESTRICT restrict
+#endif
+
+#if (!defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L) )
+# if OPUS_GNUC_PREREQ(2,7)
+# define OPUS_INLINE __inline__
+# elif (defined(_MSC_VER))
+# define OPUS_INLINE __inline
+# else
+# define OPUS_INLINE
+# endif
+#else
+# define OPUS_INLINE inline
+#endif
+
+/**Warning attributes for opus functions
+ * NONNULL is not used in OPUS_BUILD to avoid the compiler optimizing out
+ * some paranoid null checks. */
+#if defined(__GNUC__) && OPUS_GNUC_PREREQ(3, 4)
+# define OPUS_WARN_UNUSED_RESULT __attribute__ ((__warn_unused_result__))
+#else
+# define OPUS_WARN_UNUSED_RESULT
+#endif
+#if !defined(OPUS_BUILD) && defined(__GNUC__) && OPUS_GNUC_PREREQ(3, 4)
+# define OPUS_ARG_NONNULL(_x) __attribute__ ((__nonnull__(_x)))
+#else
+# define OPUS_ARG_NONNULL(_x)
+#endif
+
+/** These are the actual Encoder CTL ID numbers.
+ * They should not be used directly by applications.
+ * In general, SETs should be even and GETs should be odd.*/
+#define OPUS_SET_APPLICATION_REQUEST 4000
+#define OPUS_GET_APPLICATION_REQUEST 4001
+#define OPUS_SET_BITRATE_REQUEST 4002
+#define OPUS_GET_BITRATE_REQUEST 4003
+#define OPUS_SET_MAX_BANDWIDTH_REQUEST 4004
+#define OPUS_GET_MAX_BANDWIDTH_REQUEST 4005
+#define OPUS_SET_VBR_REQUEST 4006
+#define OPUS_GET_VBR_REQUEST 4007
+#define OPUS_SET_BANDWIDTH_REQUEST 4008
+#define OPUS_GET_BANDWIDTH_REQUEST 4009
+#define OPUS_SET_COMPLEXITY_REQUEST 4010
+#define OPUS_GET_COMPLEXITY_REQUEST 4011
+#define OPUS_SET_INBAND_FEC_REQUEST 4012
+#define OPUS_GET_INBAND_FEC_REQUEST 4013
+#define OPUS_SET_PACKET_LOSS_PERC_REQUEST 4014
+#define OPUS_GET_PACKET_LOSS_PERC_REQUEST 4015
+#define OPUS_SET_DTX_REQUEST 4016
+#define OPUS_GET_DTX_REQUEST 4017
+#define OPUS_SET_VBR_CONSTRAINT_REQUEST 4020
+#define OPUS_GET_VBR_CONSTRAINT_REQUEST 4021
+#define OPUS_SET_FORCE_CHANNELS_REQUEST 4022
+#define OPUS_GET_FORCE_CHANNELS_REQUEST 4023
+#define OPUS_SET_SIGNAL_REQUEST 4024
+#define OPUS_GET_SIGNAL_REQUEST 4025
+#define OPUS_GET_LOOKAHEAD_REQUEST 4027
+/* #define OPUS_RESET_STATE 4028 */
+#define OPUS_GET_SAMPLE_RATE_REQUEST 4029
+#define OPUS_GET_FINAL_RANGE_REQUEST 4031
+#define OPUS_GET_PITCH_REQUEST 4033
+#define OPUS_SET_GAIN_REQUEST 4034
+#define OPUS_GET_GAIN_REQUEST 4045 /* Should have been 4035 */
+#define OPUS_SET_LSB_DEPTH_REQUEST 4036
+#define OPUS_GET_LSB_DEPTH_REQUEST 4037
+#define OPUS_GET_LAST_PACKET_DURATION_REQUEST 4039
+#define OPUS_SET_EXPERT_FRAME_DURATION_REQUEST 4040
+#define OPUS_GET_EXPERT_FRAME_DURATION_REQUEST 4041
+#define OPUS_SET_PREDICTION_DISABLED_REQUEST 4042
+#define OPUS_GET_PREDICTION_DISABLED_REQUEST 4043
+/* Don't use 4045, it's already taken by OPUS_GET_GAIN_REQUEST */
+#define OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST 4046
+#define OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST 4047
+#define OPUS_GET_IN_DTX_REQUEST 4049
+
+/** Defines for the presence of extended APIs. */
+#define OPUS_HAVE_OPUS_PROJECTION_H
+
+/* Macros to trigger compilation errors when the wrong types are provided to a CTL */
+#define __opus_check_int(x) (((void)((x) == (opus_int32)0)), (opus_int32)(x))
+#define __opus_check_int_ptr(ptr) ((ptr) + ((ptr) - (opus_int32*)(ptr)))
+#define __opus_check_uint_ptr(ptr) ((ptr) + ((ptr) - (opus_uint32*)(ptr)))
+#define __opus_check_val16_ptr(ptr) ((ptr) + ((ptr) - (opus_val16*)(ptr)))
+/** @endcond */
+
+/** @defgroup opus_ctlvalues Pre-defined values for CTL interface
+ * @see opus_genericctls, opus_encoderctls
+ * @{
+ */
+/* Values for the various encoder CTLs */
+#define OPUS_AUTO -1000 /**opus_int32: Allowed values: 0-10, inclusive.
+ *
+ * @hideinitializer */
+#define OPUS_SET_COMPLEXITY(x) OPUS_SET_COMPLEXITY_REQUEST, __opus_check_int(x)
+/** Gets the encoder's complexity configuration.
+ * @see OPUS_SET_COMPLEXITY
+ * @param[out] x opus_int32 *: Returns a value in the range 0-10,
+ * inclusive.
+ * @hideinitializer */
+#define OPUS_GET_COMPLEXITY(x) OPUS_GET_COMPLEXITY_REQUEST, __opus_check_int_ptr(x)
+
+/** Configures the bitrate in the encoder.
+ * Rates from 500 to 512000 bits per second are meaningful, as well as the
+ * special values #OPUS_AUTO and #OPUS_BITRATE_MAX.
+ * The value #OPUS_BITRATE_MAX can be used to cause the codec to use as much
+ * rate as it can, which is useful for controlling the rate by adjusting the
+ * output buffer size.
+ * @see OPUS_GET_BITRATE
+ * @param[in] x opus_int32: Bitrate in bits per second. The default
+ * is determined based on the number of
+ * channels and the input sampling rate.
+ * @hideinitializer */
+#define OPUS_SET_BITRATE(x) OPUS_SET_BITRATE_REQUEST, __opus_check_int(x)
+/** Gets the encoder's bitrate configuration.
+ * @see OPUS_SET_BITRATE
+ * @param[out] x opus_int32 *: Returns the bitrate in bits per second.
+ * The default is determined based on the
+ * number of channels and the input
+ * sampling rate.
+ * @hideinitializer */
+#define OPUS_GET_BITRATE(x) OPUS_GET_BITRATE_REQUEST, __opus_check_int_ptr(x)
+
+/** Enables or disables variable bitrate (VBR) in the encoder.
+ * The configured bitrate may not be met exactly because frames must
+ * be an integer number of bytes in length.
+ * @see OPUS_GET_VBR
+ * @see OPUS_SET_VBR_CONSTRAINT
+ * @param[in] x opus_int32: Allowed values:
+ *
+ * - 0
- Hard CBR. For LPC/hybrid modes at very low bit-rate, this can
+ * cause noticeable quality degradation.
+ * - 1
- VBR (default). The exact type of VBR is controlled by
+ * #OPUS_SET_VBR_CONSTRAINT.
+ *
+ * @hideinitializer */
+#define OPUS_SET_VBR(x) OPUS_SET_VBR_REQUEST, __opus_check_int(x)
+/** Determine if variable bitrate (VBR) is enabled in the encoder.
+ * @see OPUS_SET_VBR
+ * @see OPUS_GET_VBR_CONSTRAINT
+ * @param[out] x opus_int32 *: Returns one of the following values:
+ *
+ * - 0
- Hard CBR.
+ * - 1
- VBR (default). The exact type of VBR may be retrieved via
+ * #OPUS_GET_VBR_CONSTRAINT.
+ *
+ * @hideinitializer */
+#define OPUS_GET_VBR(x) OPUS_GET_VBR_REQUEST, __opus_check_int_ptr(x)
+
+/** Enables or disables constrained VBR in the encoder.
+ * This setting is ignored when the encoder is in CBR mode.
+ * @warning Only the MDCT mode of Opus currently heeds the constraint.
+ * Speech mode ignores it completely, hybrid mode may fail to obey it
+ * if the LPC layer uses more bitrate than the constraint would have
+ * permitted.
+ * @see OPUS_GET_VBR_CONSTRAINT
+ * @see OPUS_SET_VBR
+ * @param[in] x opus_int32: Allowed values:
+ *
+ * - 0
- Unconstrained VBR.
+ * - 1
- Constrained VBR (default). This creates a maximum of one
+ * frame of buffering delay assuming a transport with a
+ * serialization speed of the nominal bitrate.
+ *
+ * @hideinitializer */
+#define OPUS_SET_VBR_CONSTRAINT(x) OPUS_SET_VBR_CONSTRAINT_REQUEST, __opus_check_int(x)
+/** Determine if constrained VBR is enabled in the encoder.
+ * @see OPUS_SET_VBR_CONSTRAINT
+ * @see OPUS_GET_VBR
+ * @param[out] x opus_int32 *: Returns one of the following values:
+ *
+ * - 0
- Unconstrained VBR.
+ * - 1
- Constrained VBR (default).
+ *
+ * @hideinitializer */
+#define OPUS_GET_VBR_CONSTRAINT(x) OPUS_GET_VBR_CONSTRAINT_REQUEST, __opus_check_int_ptr(x)
+
+/** Configures mono/stereo forcing in the encoder.
+ * This can force the encoder to produce packets encoded as either mono or
+ * stereo, regardless of the format of the input audio. This is useful when
+ * the caller knows that the input signal is currently a mono source embedded
+ * in a stereo stream.
+ * @see OPUS_GET_FORCE_CHANNELS
+ * @param[in] x opus_int32: Allowed values:
+ *
+ * - #OPUS_AUTO
- Not forced (default)
+ * - 1
- Forced mono
+ * - 2
- Forced stereo
+ *
+ * @hideinitializer */
+#define OPUS_SET_FORCE_CHANNELS(x) OPUS_SET_FORCE_CHANNELS_REQUEST, __opus_check_int(x)
+/** Gets the encoder's forced channel configuration.
+ * @see OPUS_SET_FORCE_CHANNELS
+ * @param[out] x opus_int32 *:
+ *
+ * - #OPUS_AUTO
- Not forced (default)
+ * - 1
- Forced mono
+ * - 2
- Forced stereo
+ *
+ * @hideinitializer */
+#define OPUS_GET_FORCE_CHANNELS(x) OPUS_GET_FORCE_CHANNELS_REQUEST, __opus_check_int_ptr(x)
+
+/** Configures the maximum bandpass that the encoder will select automatically.
+ * Applications should normally use this instead of #OPUS_SET_BANDWIDTH
+ * (leaving that set to the default, #OPUS_AUTO). This allows the
+ * application to set an upper bound based on the type of input it is
+ * providing, but still gives the encoder the freedom to reduce the bandpass
+ * when the bitrate becomes too low, for better overall quality.
+ * @see OPUS_GET_MAX_BANDWIDTH
+ * @param[in] x opus_int32: Allowed values:
+ *
+ * - OPUS_BANDWIDTH_NARROWBAND
- 4 kHz passband
+ * - OPUS_BANDWIDTH_MEDIUMBAND
- 6 kHz passband
+ * - OPUS_BANDWIDTH_WIDEBAND
- 8 kHz passband
+ * - OPUS_BANDWIDTH_SUPERWIDEBAND
- 12 kHz passband
+ * - OPUS_BANDWIDTH_FULLBAND
- 20 kHz passband (default)
+ *
+ * @hideinitializer */
+#define OPUS_SET_MAX_BANDWIDTH(x) OPUS_SET_MAX_BANDWIDTH_REQUEST, __opus_check_int(x)
+
+/** Gets the encoder's configured maximum allowed bandpass.
+ * @see OPUS_SET_MAX_BANDWIDTH
+ * @param[out] x opus_int32 *: Allowed values:
+ *
+ * - #OPUS_BANDWIDTH_NARROWBAND
- 4 kHz passband
+ * - #OPUS_BANDWIDTH_MEDIUMBAND
- 6 kHz passband
+ * - #OPUS_BANDWIDTH_WIDEBAND
- 8 kHz passband
+ * - #OPUS_BANDWIDTH_SUPERWIDEBAND
- 12 kHz passband
+ * - #OPUS_BANDWIDTH_FULLBAND
- 20 kHz passband (default)
+ *
+ * @hideinitializer */
+#define OPUS_GET_MAX_BANDWIDTH(x) OPUS_GET_MAX_BANDWIDTH_REQUEST, __opus_check_int_ptr(x)
+
+/** Sets the encoder's bandpass to a specific value.
+ * This prevents the encoder from automatically selecting the bandpass based
+ * on the available bitrate. If an application knows the bandpass of the input
+ * audio it is providing, it should normally use #OPUS_SET_MAX_BANDWIDTH
+ * instead, which still gives the encoder the freedom to reduce the bandpass
+ * when the bitrate becomes too low, for better overall quality.
+ * @see OPUS_GET_BANDWIDTH
+ * @param[in] x opus_int32: Allowed values:
+ *
+ * - #OPUS_AUTO
- (default)
+ * - #OPUS_BANDWIDTH_NARROWBAND
- 4 kHz passband
+ * - #OPUS_BANDWIDTH_MEDIUMBAND
- 6 kHz passband
+ * - #OPUS_BANDWIDTH_WIDEBAND
- 8 kHz passband
+ * - #OPUS_BANDWIDTH_SUPERWIDEBAND
- 12 kHz passband
+ * - #OPUS_BANDWIDTH_FULLBAND
- 20 kHz passband
+ *
+ * @hideinitializer */
+#define OPUS_SET_BANDWIDTH(x) OPUS_SET_BANDWIDTH_REQUEST, __opus_check_int(x)
+
+/** Configures the type of signal being encoded.
+ * This is a hint which helps the encoder's mode selection.
+ * @see OPUS_GET_SIGNAL
+ * @param[in] x opus_int32: Allowed values:
+ *
+ * - #OPUS_AUTO
- (default)
+ * - #OPUS_SIGNAL_VOICE
- Bias thresholds towards choosing LPC or Hybrid modes.
+ * - #OPUS_SIGNAL_MUSIC
- Bias thresholds towards choosing MDCT modes.
+ *
+ * @hideinitializer */
+#define OPUS_SET_SIGNAL(x) OPUS_SET_SIGNAL_REQUEST, __opus_check_int(x)
+/** Gets the encoder's configured signal type.
+ * @see OPUS_SET_SIGNAL
+ * @param[out] x opus_int32 *: Returns one of the following values:
+ *
+ * - #OPUS_AUTO
- (default)
+ * - #OPUS_SIGNAL_VOICE
- Bias thresholds towards choosing LPC or Hybrid modes.
+ * - #OPUS_SIGNAL_MUSIC
- Bias thresholds towards choosing MDCT modes.
+ *
+ * @hideinitializer */
+#define OPUS_GET_SIGNAL(x) OPUS_GET_SIGNAL_REQUEST, __opus_check_int_ptr(x)
+
+
+/** Configures the encoder's intended application.
+ * The initial value is a mandatory argument to the encoder_create function.
+ * @see OPUS_GET_APPLICATION
+ * @param[in] x opus_int32: Returns one of the following values:
+ *
+ * - #OPUS_APPLICATION_VOIP
+ * - Process signal for improved speech intelligibility.
+ * - #OPUS_APPLICATION_AUDIO
+ * - Favor faithfulness to the original input.
+ * - #OPUS_APPLICATION_RESTRICTED_LOWDELAY
+ * - Configure the minimum possible coding delay by disabling certain modes
+ * of operation.
+ *
+ * @hideinitializer */
+#define OPUS_SET_APPLICATION(x) OPUS_SET_APPLICATION_REQUEST, __opus_check_int(x)
+/** Gets the encoder's configured application.
+ * @see OPUS_SET_APPLICATION
+ * @param[out] x opus_int32 *: Returns one of the following values:
+ *
+ * - #OPUS_APPLICATION_VOIP
+ * - Process signal for improved speech intelligibility.
+ * - #OPUS_APPLICATION_AUDIO
+ * - Favor faithfulness to the original input.
+ * - #OPUS_APPLICATION_RESTRICTED_LOWDELAY
+ * - Configure the minimum possible coding delay by disabling certain modes
+ * of operation.
+ *
+ * @hideinitializer */
+#define OPUS_GET_APPLICATION(x) OPUS_GET_APPLICATION_REQUEST, __opus_check_int_ptr(x)
+
+/** Gets the total samples of delay added by the entire codec.
+ * This can be queried by the encoder and then the provided number of samples can be
+ * skipped on from the start of the decoder's output to provide time aligned input
+ * and output. From the perspective of a decoding application the real data begins this many
+ * samples late.
+ *
+ * The decoder contribution to this delay is identical for all decoders, but the
+ * encoder portion of the delay may vary from implementation to implementation,
+ * version to version, or even depend on the encoder's initial configuration.
+ * Applications needing delay compensation should call this CTL rather than
+ * hard-coding a value.
+ * @param[out] x opus_int32 *: Number of lookahead samples
+ * @hideinitializer */
+#define OPUS_GET_LOOKAHEAD(x) OPUS_GET_LOOKAHEAD_REQUEST, __opus_check_int_ptr(x)
+
+/** Configures the encoder's use of inband forward error correction (FEC).
+ * @note This is only applicable to the LPC layer
+ * @see OPUS_GET_INBAND_FEC
+ * @param[in] x opus_int32: Allowed values:
+ *
+ * - 0
- Disable inband FEC (default).
+ * - 1
- Enable inband FEC.
+ *
+ * @hideinitializer */
+#define OPUS_SET_INBAND_FEC(x) OPUS_SET_INBAND_FEC_REQUEST, __opus_check_int(x)
+/** Gets encoder's configured use of inband forward error correction.
+ * @see OPUS_SET_INBAND_FEC
+ * @param[out] x opus_int32 *: Returns one of the following values:
+ *
+ * - 0
- Inband FEC disabled (default).
+ * - 1
- Inband FEC enabled.
+ *
+ * @hideinitializer */
+#define OPUS_GET_INBAND_FEC(x) OPUS_GET_INBAND_FEC_REQUEST, __opus_check_int_ptr(x)
+
+/** Configures the encoder's expected packet loss percentage.
+ * Higher values trigger progressively more loss resistant behavior in the encoder
+ * at the expense of quality at a given bitrate in the absence of packet loss, but
+ * greater quality under loss.
+ * @see OPUS_GET_PACKET_LOSS_PERC
+ * @param[in] x opus_int32: Loss percentage in the range 0-100, inclusive (default: 0).
+ * @hideinitializer */
+#define OPUS_SET_PACKET_LOSS_PERC(x) OPUS_SET_PACKET_LOSS_PERC_REQUEST, __opus_check_int(x)
+/** Gets the encoder's configured packet loss percentage.
+ * @see OPUS_SET_PACKET_LOSS_PERC
+ * @param[out] x opus_int32 *: Returns the configured loss percentage
+ * in the range 0-100, inclusive (default: 0).
+ * @hideinitializer */
+#define OPUS_GET_PACKET_LOSS_PERC(x) OPUS_GET_PACKET_LOSS_PERC_REQUEST, __opus_check_int_ptr(x)
+
+/** Configures the encoder's use of discontinuous transmission (DTX).
+ * @note This is only applicable to the LPC layer
+ * @see OPUS_GET_DTX
+ * @param[in] x opus_int32: Allowed values:
+ *
+ * - 0
- Disable DTX (default).
+ * - 1
- Enabled DTX.
+ *
+ * @hideinitializer */
+#define OPUS_SET_DTX(x) OPUS_SET_DTX_REQUEST, __opus_check_int(x)
+/** Gets encoder's configured use of discontinuous transmission.
+ * @see OPUS_SET_DTX
+ * @param[out] x opus_int32 *: Returns one of the following values:
+ *
+ * - 0
- DTX disabled (default).
+ * - 1
- DTX enabled.
+ *
+ * @hideinitializer */
+#define OPUS_GET_DTX(x) OPUS_GET_DTX_REQUEST, __opus_check_int_ptr(x)
+/** Configures the depth of signal being encoded.
+ *
+ * This is a hint which helps the encoder identify silence and near-silence.
+ * It represents the number of significant bits of linear intensity below
+ * which the signal contains ignorable quantization or other noise.
+ *
+ * For example, OPUS_SET_LSB_DEPTH(14) would be an appropriate setting
+ * for G.711 u-law input. OPUS_SET_LSB_DEPTH(16) would be appropriate
+ * for 16-bit linear pcm input with opus_encode_float().
+ *
+ * When using opus_encode() instead of opus_encode_float(), or when libopus
+ * is compiled for fixed-point, the encoder uses the minimum of the value
+ * set here and the value 16.
+ *
+ * @see OPUS_GET_LSB_DEPTH
+ * @param[in] x opus_int32: Input precision in bits, between 8 and 24
+ * (default: 24).
+ * @hideinitializer */
+#define OPUS_SET_LSB_DEPTH(x) OPUS_SET_LSB_DEPTH_REQUEST, __opus_check_int(x)
+/** Gets the encoder's configured signal depth.
+ * @see OPUS_SET_LSB_DEPTH
+ * @param[out] x opus_int32 *: Input precision in bits, between 8 and
+ * 24 (default: 24).
+ * @hideinitializer */
+#define OPUS_GET_LSB_DEPTH(x) OPUS_GET_LSB_DEPTH_REQUEST, __opus_check_int_ptr(x)
+
+/** Configures the encoder's use of variable duration frames.
+ * When variable duration is enabled, the encoder is free to use a shorter frame
+ * size than the one requested in the opus_encode*() call.
+ * It is then the user's responsibility
+ * to verify how much audio was encoded by checking the ToC byte of the encoded
+ * packet. The part of the audio that was not encoded needs to be resent to the
+ * encoder for the next call. Do not use this option unless you really
+ * know what you are doing.
+ * @see OPUS_GET_EXPERT_FRAME_DURATION
+ * @param[in] x opus_int32: Allowed values:
+ *
+ * - OPUS_FRAMESIZE_ARG
- Select frame size from the argument (default).
+ * - OPUS_FRAMESIZE_2_5_MS
- Use 2.5 ms frames.
+ * - OPUS_FRAMESIZE_5_MS
- Use 5 ms frames.
+ * - OPUS_FRAMESIZE_10_MS
- Use 10 ms frames.
+ * - OPUS_FRAMESIZE_20_MS
- Use 20 ms frames.
+ * - OPUS_FRAMESIZE_40_MS
- Use 40 ms frames.
+ * - OPUS_FRAMESIZE_60_MS
- Use 60 ms frames.
+ * - OPUS_FRAMESIZE_80_MS
- Use 80 ms frames.
+ * - OPUS_FRAMESIZE_100_MS
- Use 100 ms frames.
+ * - OPUS_FRAMESIZE_120_MS
- Use 120 ms frames.
+ *
+ * @hideinitializer */
+#define OPUS_SET_EXPERT_FRAME_DURATION(x) OPUS_SET_EXPERT_FRAME_DURATION_REQUEST, __opus_check_int(x)
+/** Gets the encoder's configured use of variable duration frames.
+ * @see OPUS_SET_EXPERT_FRAME_DURATION
+ * @param[out] x opus_int32 *: Returns one of the following values:
+ *
+ * - OPUS_FRAMESIZE_ARG
- Select frame size from the argument (default).
+ * - OPUS_FRAMESIZE_2_5_MS
- Use 2.5 ms frames.
+ * - OPUS_FRAMESIZE_5_MS
- Use 5 ms frames.
+ * - OPUS_FRAMESIZE_10_MS
- Use 10 ms frames.
+ * - OPUS_FRAMESIZE_20_MS
- Use 20 ms frames.
+ * - OPUS_FRAMESIZE_40_MS
- Use 40 ms frames.
+ * - OPUS_FRAMESIZE_60_MS
- Use 60 ms frames.
+ * - OPUS_FRAMESIZE_80_MS
- Use 80 ms frames.
+ * - OPUS_FRAMESIZE_100_MS
- Use 100 ms frames.
+ * - OPUS_FRAMESIZE_120_MS
- Use 120 ms frames.
+ *
+ * @hideinitializer */
+#define OPUS_GET_EXPERT_FRAME_DURATION(x) OPUS_GET_EXPERT_FRAME_DURATION_REQUEST, __opus_check_int_ptr(x)
+
+/** If set to 1, disables almost all use of prediction, making frames almost
+ * completely independent. This reduces quality.
+ * @see OPUS_GET_PREDICTION_DISABLED
+ * @param[in] x opus_int32: Allowed values:
+ *
+ * - 0
- Enable prediction (default).
+ * - 1
- Disable prediction.
+ *
+ * @hideinitializer */
+#define OPUS_SET_PREDICTION_DISABLED(x) OPUS_SET_PREDICTION_DISABLED_REQUEST, __opus_check_int(x)
+/** Gets the encoder's configured prediction status.
+ * @see OPUS_SET_PREDICTION_DISABLED
+ * @param[out] x opus_int32 *: Returns one of the following values:
+ *
+ * - 0
- Prediction enabled (default).
+ * - 1
- Prediction disabled.
+ *
+ * @hideinitializer */
+#define OPUS_GET_PREDICTION_DISABLED(x) OPUS_GET_PREDICTION_DISABLED_REQUEST, __opus_check_int_ptr(x)
+
+/**@}*/
+
+/** @defgroup opus_genericctls Generic CTLs
+ *
+ * These macros are used with the \c opus_decoder_ctl and
+ * \c opus_encoder_ctl calls to generate a particular
+ * request.
+ *
+ * When called on an \c OpusDecoder they apply to that
+ * particular decoder instance. When called on an
+ * \c OpusEncoder they apply to the corresponding setting
+ * on that encoder instance, if present.
+ *
+ * Some usage examples:
+ *
+ * @code
+ * int ret;
+ * opus_int32 pitch;
+ * ret = opus_decoder_ctl(dec_ctx, OPUS_GET_PITCH(&pitch));
+ * if (ret == OPUS_OK) return ret;
+ *
+ * opus_encoder_ctl(enc_ctx, OPUS_RESET_STATE);
+ * opus_decoder_ctl(dec_ctx, OPUS_RESET_STATE);
+ *
+ * opus_int32 enc_bw, dec_bw;
+ * opus_encoder_ctl(enc_ctx, OPUS_GET_BANDWIDTH(&enc_bw));
+ * opus_decoder_ctl(dec_ctx, OPUS_GET_BANDWIDTH(&dec_bw));
+ * if (enc_bw != dec_bw) {
+ * printf("packet bandwidth mismatch!\n");
+ * }
+ * @endcode
+ *
+ * @see opus_encoder, opus_decoder_ctl, opus_encoder_ctl, opus_decoderctls, opus_encoderctls
+ * @{
+ */
+
+/** Resets the codec state to be equivalent to a freshly initialized state.
+ * This should be called when switching streams in order to prevent
+ * the back to back decoding from giving different results from
+ * one at a time decoding.
+ * @hideinitializer */
+#define OPUS_RESET_STATE 4028
+
+/** Gets the final state of the codec's entropy coder.
+ * This is used for testing purposes,
+ * The encoder and decoder state should be identical after coding a payload
+ * (assuming no data corruption or software bugs)
+ *
+ * @param[out] x opus_uint32 *: Entropy coder state
+ *
+ * @hideinitializer */
+#define OPUS_GET_FINAL_RANGE(x) OPUS_GET_FINAL_RANGE_REQUEST, __opus_check_uint_ptr(x)
+
+/** Gets the encoder's configured bandpass or the decoder's last bandpass.
+ * @see OPUS_SET_BANDWIDTH
+ * @param[out] x opus_int32 *: Returns one of the following values:
+ *
+ * - #OPUS_AUTO
- (default)
+ * - #OPUS_BANDWIDTH_NARROWBAND
- 4 kHz passband
+ * - #OPUS_BANDWIDTH_MEDIUMBAND
- 6 kHz passband
+ * - #OPUS_BANDWIDTH_WIDEBAND
- 8 kHz passband
+ * - #OPUS_BANDWIDTH_SUPERWIDEBAND
- 12 kHz passband
+ * - #OPUS_BANDWIDTH_FULLBAND
- 20 kHz passband
+ *
+ * @hideinitializer */
+#define OPUS_GET_BANDWIDTH(x) OPUS_GET_BANDWIDTH_REQUEST, __opus_check_int_ptr(x)
+
+/** Gets the sampling rate the encoder or decoder was initialized with.
+ * This simply returns the Fs value passed to opus_encoder_init()
+ * or opus_decoder_init().
+ * @param[out] x opus_int32 *: Sampling rate of encoder or decoder.
+ * @hideinitializer
+ */
+#define OPUS_GET_SAMPLE_RATE(x) OPUS_GET_SAMPLE_RATE_REQUEST, __opus_check_int_ptr(x)
+
+/** If set to 1, disables the use of phase inversion for intensity stereo,
+ * improving the quality of mono downmixes, but slightly reducing normal
+ * stereo quality. Disabling phase inversion in the decoder does not comply
+ * with RFC 6716, although it does not cause any interoperability issue and
+ * is expected to become part of the Opus standard once RFC 6716 is updated
+ * by draft-ietf-codec-opus-update.
+ * @see OPUS_GET_PHASE_INVERSION_DISABLED
+ * @param[in] x opus_int32: Allowed values:
+ *
+ * - 0
- Enable phase inversion (default).
+ * - 1
- Disable phase inversion.
+ *
+ * @hideinitializer */
+#define OPUS_SET_PHASE_INVERSION_DISABLED(x) OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST, __opus_check_int(x)
+/** Gets the encoder's configured phase inversion status.
+ * @see OPUS_SET_PHASE_INVERSION_DISABLED
+ * @param[out] x opus_int32 *: Returns one of the following values:
+ *
+ * - 0
- Stereo phase inversion enabled (default).
+ * - 1
- Stereo phase inversion disabled.
+ *
+ * @hideinitializer */
+#define OPUS_GET_PHASE_INVERSION_DISABLED(x) OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST, __opus_check_int_ptr(x)
+/** Gets the DTX state of the encoder.
+ * Returns whether the last encoded frame was either a comfort noise update
+ * during DTX or not encoded because of DTX.
+ * @param[out] x opus_int32 *: Returns one of the following values:
+ *
+ * - 0
- The encoder is not in DTX.
+ * - 1
- The encoder is in DTX.
+ *
+ * @hideinitializer */
+#define OPUS_GET_IN_DTX(x) OPUS_GET_IN_DTX_REQUEST, __opus_check_int_ptr(x)
+
+/**@}*/
+
+/** @defgroup opus_decoderctls Decoder related CTLs
+ * @see opus_genericctls, opus_encoderctls, opus_decoder
+ * @{
+ */
+
+/** Configures decoder gain adjustment.
+ * Scales the decoded output by a factor specified in Q8 dB units.
+ * This has a maximum range of -32768 to 32767 inclusive, and returns
+ * OPUS_BAD_ARG otherwise. The default is zero indicating no adjustment.
+ * This setting survives decoder reset.
+ *
+ * gain = pow(10, x/(20.0*256))
+ *
+ * @param[in] x opus_int32: Amount to scale PCM signal by in Q8 dB units.
+ * @hideinitializer */
+#define OPUS_SET_GAIN(x) OPUS_SET_GAIN_REQUEST, __opus_check_int(x)
+/** Gets the decoder's configured gain adjustment. @see OPUS_SET_GAIN
+ *
+ * @param[out] x opus_int32 *: Amount to scale PCM signal by in Q8 dB units.
+ * @hideinitializer */
+#define OPUS_GET_GAIN(x) OPUS_GET_GAIN_REQUEST, __opus_check_int_ptr(x)
+
+/** Gets the duration (in samples) of the last packet successfully decoded or concealed.
+ * @param[out] x opus_int32 *: Number of samples (at current sampling rate).
+ * @hideinitializer */
+#define OPUS_GET_LAST_PACKET_DURATION(x) OPUS_GET_LAST_PACKET_DURATION_REQUEST, __opus_check_int_ptr(x)
+
+/** Gets the pitch of the last decoded frame, if available.
+ * This can be used for any post-processing algorithm requiring the use of pitch,
+ * e.g. time stretching/shortening. If the last frame was not voiced, or if the
+ * pitch was not coded in the frame, then zero is returned.
+ *
+ * This CTL is only implemented for decoder instances.
+ *
+ * @param[out] x opus_int32 *: pitch period at 48 kHz (or 0 if not available)
+ *
+ * @hideinitializer */
+#define OPUS_GET_PITCH(x) OPUS_GET_PITCH_REQUEST, __opus_check_int_ptr(x)
+
+/**@}*/
+
+/** @defgroup opus_libinfo Opus library information functions
+ * @{
+ */
+
+/** Converts an opus error code into a human readable string.
+ *
+ * @param[in] error int: Error number
+ * @returns Error string
+ */
+OPUS_EXPORT const char *opus_strerror(int error);
+
+/** Gets the libopus version string.
+ *
+ * Applications may look for the substring "-fixed" in the version string to
+ * determine whether they have a fixed-point or floating-point build at
+ * runtime.
+ *
+ * @returns Version string
+ */
+OPUS_EXPORT const char *opus_get_version_string(void);
+/**@}*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* OPUS_DEFINES_H */
diff --git a/app/src/main/cpp/opus_multistream.h b/app/src/main/cpp/opus_multistream.h
new file mode 100644
index 0000000..babcee6
--- /dev/null
+++ b/app/src/main/cpp/opus_multistream.h
@@ -0,0 +1,660 @@
+/* Copyright (c) 2011 Xiph.Org Foundation
+ Written 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.
+*/
+
+/**
+ * @file opus_multistream.h
+ * @brief Opus reference implementation multistream API
+ */
+
+#ifndef OPUS_MULTISTREAM_H
+#define OPUS_MULTISTREAM_H
+
+#include "opus.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** @cond OPUS_INTERNAL_DOC */
+
+/** Macros to trigger compilation errors when the wrong types are provided to a
+ * CTL. */
+/**@{*/
+#define __opus_check_encstate_ptr(ptr) ((ptr) + ((ptr) - (OpusEncoder**)(ptr)))
+#define __opus_check_decstate_ptr(ptr) ((ptr) + ((ptr) - (OpusDecoder**)(ptr)))
+/**@}*/
+
+/** These are the actual encoder and decoder CTL ID numbers.
+ * They should not be used directly by applications.
+ * In general, SETs should be even and GETs should be odd.*/
+/**@{*/
+#define OPUS_MULTISTREAM_GET_ENCODER_STATE_REQUEST 5120
+#define OPUS_MULTISTREAM_GET_DECODER_STATE_REQUEST 5122
+/**@}*/
+
+/** @endcond */
+
+/** @defgroup opus_multistream_ctls Multistream specific encoder and decoder CTLs
+ *
+ * These are convenience macros that are specific to the
+ * opus_multistream_encoder_ctl() and opus_multistream_decoder_ctl()
+ * interface.
+ * The CTLs from @ref opus_genericctls, @ref opus_encoderctls, and
+ * @ref opus_decoderctls may be applied to a multistream encoder or decoder as
+ * well.
+ * In addition, you may retrieve the encoder or decoder state for an specific
+ * stream via #OPUS_MULTISTREAM_GET_ENCODER_STATE or
+ * #OPUS_MULTISTREAM_GET_DECODER_STATE and apply CTLs to it individually.
+ */
+/**@{*/
+
+/** Gets the encoder state for an individual stream of a multistream encoder.
+ * @param[in] x opus_int32: The index of the stream whose encoder you
+ * wish to retrieve.
+ * This must be non-negative and less than
+ * the streams parameter used
+ * to initialize the encoder.
+ * @param[out] y OpusEncoder**: Returns a pointer to the given
+ * encoder state.
+ * @retval OPUS_BAD_ARG The index of the requested stream was out of range.
+ * @hideinitializer
+ */
+#define OPUS_MULTISTREAM_GET_ENCODER_STATE(x,y) OPUS_MULTISTREAM_GET_ENCODER_STATE_REQUEST, __opus_check_int(x), __opus_check_encstate_ptr(y)
+
+/** Gets the decoder state for an individual stream of a multistream decoder.
+ * @param[in] x opus_int32: The index of the stream whose decoder you
+ * wish to retrieve.
+ * This must be non-negative and less than
+ * the streams parameter used
+ * to initialize the decoder.
+ * @param[out] y OpusDecoder**: Returns a pointer to the given
+ * decoder state.
+ * @retval OPUS_BAD_ARG The index of the requested stream was out of range.
+ * @hideinitializer
+ */
+#define OPUS_MULTISTREAM_GET_DECODER_STATE(x,y) OPUS_MULTISTREAM_GET_DECODER_STATE_REQUEST, __opus_check_int(x), __opus_check_decstate_ptr(y)
+
+/**@}*/
+
+/** @defgroup opus_multistream Opus Multistream API
+ * @{
+ *
+ * The multistream API allows individual Opus streams to be combined into a
+ * single packet, enabling support for up to 255 channels. Unlike an
+ * elementary Opus stream, the encoder and decoder must negotiate the channel
+ * configuration before the decoder can successfully interpret the data in the
+ * packets produced by the encoder. Some basic information, such as packet
+ * duration, can be computed without any special negotiation.
+ *
+ * The format for multistream Opus packets is defined in
+ * RFC 7845
+ * and is based on the self-delimited Opus framing described in Appendix B of
+ * RFC 6716.
+ * Normal Opus packets are just a degenerate case of multistream Opus packets,
+ * and can be encoded or decoded with the multistream API by setting
+ * streams to 1 when initializing the encoder or
+ * decoder.
+ *
+ * Multistream Opus streams can contain up to 255 elementary Opus streams.
+ * These may be either "uncoupled" or "coupled", indicating that the decoder
+ * is configured to decode them to either 1 or 2 channels, respectively.
+ * The streams are ordered so that all coupled streams appear at the
+ * beginning.
+ *
+ * A mapping table defines which decoded channel i
+ * should be used for each input/output (I/O) channel j. This table is
+ * typically provided as an unsigned char array.
+ * Let i = mapping[j] be the index for I/O channel j.
+ * If i < 2*coupled_streams, then I/O channel j is
+ * encoded as the left channel of stream (i/2) if i
+ * is even, or as the right channel of stream (i/2) if
+ * i is odd. Otherwise, I/O channel j is encoded as
+ * mono in stream (i - coupled_streams), unless it has the special
+ * value 255, in which case it is omitted from the encoding entirely (the
+ * decoder will reproduce it as silence). Each value i must either
+ * be the special value 255 or be less than streams + coupled_streams.
+ *
+ * The output channels specified by the encoder
+ * should use the
+ * Vorbis
+ * channel ordering. A decoder may wish to apply an additional permutation
+ * to the mapping the encoder used to achieve a different output channel
+ * order (e.g. for outputing in WAV order).
+ *
+ * Each multistream packet contains an Opus packet for each stream, and all of
+ * the Opus packets in a single multistream packet must have the same
+ * duration. Therefore the duration of a multistream packet can be extracted
+ * from the TOC sequence of the first stream, which is located at the
+ * beginning of the packet, just like an elementary Opus stream:
+ *
+ * @code
+ * int nb_samples;
+ * int nb_frames;
+ * nb_frames = opus_packet_get_nb_frames(data, len);
+ * if (nb_frames < 1)
+ * return nb_frames;
+ * nb_samples = opus_packet_get_samples_per_frame(data, 48000) * nb_frames;
+ * @endcode
+ *
+ * The general encoding and decoding process proceeds exactly the same as in
+ * the normal @ref opus_encoder and @ref opus_decoder APIs.
+ * See their documentation for an overview of how to use the corresponding
+ * multistream functions.
+ */
+
+/** Opus multistream encoder state.
+ * This contains the complete state of a multistream Opus encoder.
+ * It is position independent and can be freely copied.
+ * @see opus_multistream_encoder_create
+ * @see opus_multistream_encoder_init
+ */
+typedef struct OpusMSEncoder OpusMSEncoder;
+
+/** Opus multistream decoder state.
+ * This contains the complete state of a multistream Opus decoder.
+ * It is position independent and can be freely copied.
+ * @see opus_multistream_decoder_create
+ * @see opus_multistream_decoder_init
+ */
+typedef struct OpusMSDecoder OpusMSDecoder;
+
+/**\name Multistream encoder functions */
+/**@{*/
+
+/** Gets the size of an OpusMSEncoder structure.
+ * @param streams int: The total number of streams to encode from the
+ * input.
+ * This must be no more than 255.
+ * @param coupled_streams int: Number of coupled (2 channel) streams
+ * to encode.
+ * This must be no larger than the total
+ * number of streams.
+ * Additionally, The total number of
+ * encoded channels (streams +
+ * coupled_streams) must be no
+ * more than 255.
+ * @returns The size in bytes on success, or a negative error code
+ * (see @ref opus_errorcodes) on error.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_multistream_encoder_get_size(
+ int streams,
+ int coupled_streams
+);
+
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_multistream_surround_encoder_get_size(
+ int channels,
+ int mapping_family
+);
+
+
+/** Allocates and initializes a multistream encoder state.
+ * Call opus_multistream_encoder_destroy() to release
+ * this object when finished.
+ * @param Fs opus_int32: Sampling rate of the input signal (in Hz).
+ * This must be one of 8000, 12000, 16000,
+ * 24000, or 48000.
+ * @param channels int: Number of channels in the input signal.
+ * This must be at most 255.
+ * It may be greater than the number of
+ * coded channels (streams +
+ * coupled_streams).
+ * @param streams int: The total number of streams to encode from the
+ * input.
+ * This must be no more than the number of channels.
+ * @param coupled_streams int: Number of coupled (2 channel) streams
+ * to encode.
+ * This must be no larger than the total
+ * number of streams.
+ * Additionally, The total number of
+ * encoded channels (streams +
+ * coupled_streams) must be no
+ * more than the number of input channels.
+ * @param[in] mapping const unsigned char[channels]: Mapping from
+ * encoded channels to input channels, as described in
+ * @ref opus_multistream. As an extra constraint, the
+ * multistream encoder does not allow encoding coupled
+ * streams for which one channel is unused since this
+ * is never a good idea.
+ * @param application int: The target encoder application.
+ * This must be one of the following:
+ *
+ * - #OPUS_APPLICATION_VOIP
+ * - Process signal for improved speech intelligibility.
+ * - #OPUS_APPLICATION_AUDIO
+ * - Favor faithfulness to the original input.
+ * - #OPUS_APPLICATION_RESTRICTED_LOWDELAY
+ * - Configure the minimum possible coding delay by disabling certain modes
+ * of operation.
+ *
+ * @param[out] error int *: Returns #OPUS_OK on success, or an error
+ * code (see @ref opus_errorcodes) on
+ * failure.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusMSEncoder *opus_multistream_encoder_create(
+ opus_int32 Fs,
+ int channels,
+ int streams,
+ int coupled_streams,
+ const unsigned char *mapping,
+ int application,
+ int *error
+) OPUS_ARG_NONNULL(5);
+
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusMSEncoder *opus_multistream_surround_encoder_create(
+ opus_int32 Fs,
+ int channels,
+ int mapping_family,
+ int *streams,
+ int *coupled_streams,
+ unsigned char *mapping,
+ int application,
+ int *error
+) OPUS_ARG_NONNULL(4) OPUS_ARG_NONNULL(5) OPUS_ARG_NONNULL(6);
+
+/** Initialize a previously allocated multistream encoder state.
+ * The memory pointed to by \a st must be at least the size returned by
+ * opus_multistream_encoder_get_size().
+ * This is intended for applications which use their own allocator instead of
+ * malloc.
+ * To reset a previously initialized state, use the #OPUS_RESET_STATE CTL.
+ * @see opus_multistream_encoder_create
+ * @see opus_multistream_encoder_get_size
+ * @param st OpusMSEncoder*: Multistream encoder state to initialize.
+ * @param Fs opus_int32: Sampling rate of the input signal (in Hz).
+ * This must be one of 8000, 12000, 16000,
+ * 24000, or 48000.
+ * @param channels int: Number of channels in the input signal.
+ * This must be at most 255.
+ * It may be greater than the number of
+ * coded channels (streams +
+ * coupled_streams).
+ * @param streams int: The total number of streams to encode from the
+ * input.
+ * This must be no more than the number of channels.
+ * @param coupled_streams int: Number of coupled (2 channel) streams
+ * to encode.
+ * This must be no larger than the total
+ * number of streams.
+ * Additionally, The total number of
+ * encoded channels (streams +
+ * coupled_streams) must be no
+ * more than the number of input channels.
+ * @param[in] mapping const unsigned char[channels]: Mapping from
+ * encoded channels to input channels, as described in
+ * @ref opus_multistream. As an extra constraint, the
+ * multistream encoder does not allow encoding coupled
+ * streams for which one channel is unused since this
+ * is never a good idea.
+ * @param application int: The target encoder application.
+ * This must be one of the following:
+ *
+ * - #OPUS_APPLICATION_VOIP
+ * - Process signal for improved speech intelligibility.
+ * - #OPUS_APPLICATION_AUDIO
+ * - Favor faithfulness to the original input.
+ * - #OPUS_APPLICATION_RESTRICTED_LOWDELAY
+ * - Configure the minimum possible coding delay by disabling certain modes
+ * of operation.
+ *
+ * @returns #OPUS_OK on success, or an error code (see @ref opus_errorcodes)
+ * on failure.
+ */
+OPUS_EXPORT int opus_multistream_encoder_init(
+ OpusMSEncoder *st,
+ opus_int32 Fs,
+ int channels,
+ int streams,
+ int coupled_streams,
+ const unsigned char *mapping,
+ int application
+) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(6);
+
+OPUS_EXPORT int opus_multistream_surround_encoder_init(
+ OpusMSEncoder *st,
+ opus_int32 Fs,
+ int channels,
+ int mapping_family,
+ int *streams,
+ int *coupled_streams,
+ unsigned char *mapping,
+ int application
+) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(5) OPUS_ARG_NONNULL(6) OPUS_ARG_NONNULL(7);
+
+/** Encodes a multistream Opus frame.
+ * @param st OpusMSEncoder*: Multistream encoder state.
+ * @param[in] pcm const opus_int16*: The input signal as interleaved
+ * samples.
+ * This must contain
+ * frame_size*channels
+ * samples.
+ * @param frame_size int: Number of samples per channel in the input
+ * signal.
+ * This must be an Opus frame size for the
+ * encoder's sampling rate.
+ * For example, at 48 kHz the permitted values
+ * are 120, 240, 480, 960, 1920, and 2880.
+ * Passing in a duration of less than 10 ms
+ * (480 samples at 48 kHz) will prevent the
+ * encoder from using the LPC or hybrid modes.
+ * @param[out] data unsigned char*: Output payload.
+ * This must contain storage for at
+ * least \a max_data_bytes.
+ * @param [in] max_data_bytes opus_int32: Size of the allocated
+ * memory for the output
+ * payload. This may be
+ * used to impose an upper limit on
+ * the instant bitrate, but should
+ * not be used as the only bitrate
+ * control. Use #OPUS_SET_BITRATE to
+ * control the bitrate.
+ * @returns The length of the encoded packet (in bytes) on success or a
+ * negative error code (see @ref opus_errorcodes) on failure.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_multistream_encode(
+ OpusMSEncoder *st,
+ const opus_int16 *pcm,
+ int frame_size,
+ unsigned char *data,
+ opus_int32 max_data_bytes
+) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2) OPUS_ARG_NONNULL(4);
+
+/** Encodes a multistream Opus frame from floating point input.
+ * @param st OpusMSEncoder*: Multistream encoder state.
+ * @param[in] pcm const float*: The input signal as interleaved
+ * samples with a normal range of
+ * +/-1.0.
+ * Samples with a range beyond +/-1.0
+ * are supported but will be clipped by
+ * decoders using the integer API and
+ * should only be used if it is known
+ * that the far end supports extended
+ * dynamic range.
+ * This must contain
+ * frame_size*channels
+ * samples.
+ * @param frame_size int: Number of samples per channel in the input
+ * signal.
+ * This must be an Opus frame size for the
+ * encoder's sampling rate.
+ * For example, at 48 kHz the permitted values
+ * are 120, 240, 480, 960, 1920, and 2880.
+ * Passing in a duration of less than 10 ms
+ * (480 samples at 48 kHz) will prevent the
+ * encoder from using the LPC or hybrid modes.
+ * @param[out] data unsigned char*: Output payload.
+ * This must contain storage for at
+ * least \a max_data_bytes.
+ * @param [in] max_data_bytes opus_int32: Size of the allocated
+ * memory for the output
+ * payload. This may be
+ * used to impose an upper limit on
+ * the instant bitrate, but should
+ * not be used as the only bitrate
+ * control. Use #OPUS_SET_BITRATE to
+ * control the bitrate.
+ * @returns The length of the encoded packet (in bytes) on success or a
+ * negative error code (see @ref opus_errorcodes) on failure.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_multistream_encode_float(
+ OpusMSEncoder *st,
+ const float *pcm,
+ int frame_size,
+ unsigned char *data,
+ opus_int32 max_data_bytes
+) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2) OPUS_ARG_NONNULL(4);
+
+/** Frees an OpusMSEncoder allocated by
+ * opus_multistream_encoder_create().
+ * @param st OpusMSEncoder*: Multistream encoder state to be freed.
+ */
+OPUS_EXPORT void opus_multistream_encoder_destroy(OpusMSEncoder *st);
+
+/** Perform a CTL function on a multistream Opus encoder.
+ *
+ * Generally the request and subsequent arguments are generated by a
+ * convenience macro.
+ * @param st OpusMSEncoder*: Multistream encoder state.
+ * @param request This and all remaining parameters should be replaced by one
+ * of the convenience macros in @ref opus_genericctls,
+ * @ref opus_encoderctls, or @ref opus_multistream_ctls.
+ * @see opus_genericctls
+ * @see opus_encoderctls
+ * @see opus_multistream_ctls
+ */
+OPUS_EXPORT int opus_multistream_encoder_ctl(OpusMSEncoder *st, int request, ...) OPUS_ARG_NONNULL(1);
+
+/**@}*/
+
+/**\name Multistream decoder functions */
+/**@{*/
+
+/** Gets the size of an OpusMSDecoder structure.
+ * @param streams int: The total number of streams coded in the
+ * input.
+ * This must be no more than 255.
+ * @param coupled_streams int: Number streams to decode as coupled
+ * (2 channel) streams.
+ * This must be no larger than the total
+ * number of streams.
+ * Additionally, The total number of
+ * coded channels (streams +
+ * coupled_streams) must be no
+ * more than 255.
+ * @returns The size in bytes on success, or a negative error code
+ * (see @ref opus_errorcodes) on error.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_multistream_decoder_get_size(
+ int streams,
+ int coupled_streams
+);
+
+/** Allocates and initializes a multistream decoder state.
+ * Call opus_multistream_decoder_destroy() to release
+ * this object when finished.
+ * @param Fs opus_int32: Sampling rate to decode at (in Hz).
+ * This must be one of 8000, 12000, 16000,
+ * 24000, or 48000.
+ * @param channels int: Number of channels to output.
+ * This must be at most 255.
+ * It may be different from the number of coded
+ * channels (streams +
+ * coupled_streams).
+ * @param streams int: The total number of streams coded in the
+ * input.
+ * This must be no more than 255.
+ * @param coupled_streams int: Number of streams to decode as coupled
+ * (2 channel) streams.
+ * This must be no larger than the total
+ * number of streams.
+ * Additionally, The total number of
+ * coded channels (streams +
+ * coupled_streams) must be no
+ * more than 255.
+ * @param[in] mapping const unsigned char[channels]: Mapping from
+ * coded channels to output channels, as described in
+ * @ref opus_multistream.
+ * @param[out] error int *: Returns #OPUS_OK on success, or an error
+ * code (see @ref opus_errorcodes) on
+ * failure.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusMSDecoder *opus_multistream_decoder_create(
+ opus_int32 Fs,
+ int channels,
+ int streams,
+ int coupled_streams,
+ const unsigned char *mapping,
+ int *error
+) OPUS_ARG_NONNULL(5);
+
+/** Intialize a previously allocated decoder state object.
+ * The memory pointed to by \a st must be at least the size returned by
+ * opus_multistream_encoder_get_size().
+ * This is intended for applications which use their own allocator instead of
+ * malloc.
+ * To reset a previously initialized state, use the #OPUS_RESET_STATE CTL.
+ * @see opus_multistream_decoder_create
+ * @see opus_multistream_deocder_get_size
+ * @param st OpusMSEncoder*: Multistream encoder state to initialize.
+ * @param Fs opus_int32: Sampling rate to decode at (in Hz).
+ * This must be one of 8000, 12000, 16000,
+ * 24000, or 48000.
+ * @param channels int: Number of channels to output.
+ * This must be at most 255.
+ * It may be different from the number of coded
+ * channels (streams +
+ * coupled_streams).
+ * @param streams int: The total number of streams coded in the
+ * input.
+ * This must be no more than 255.
+ * @param coupled_streams int: Number of streams to decode as coupled
+ * (2 channel) streams.
+ * This must be no larger than the total
+ * number of streams.
+ * Additionally, The total number of
+ * coded channels (streams +
+ * coupled_streams) must be no
+ * more than 255.
+ * @param[in] mapping const unsigned char[channels]: Mapping from
+ * coded channels to output channels, as described in
+ * @ref opus_multistream.
+ * @returns #OPUS_OK on success, or an error code (see @ref opus_errorcodes)
+ * on failure.
+ */
+OPUS_EXPORT int opus_multistream_decoder_init(
+ OpusMSDecoder *st,
+ opus_int32 Fs,
+ int channels,
+ int streams,
+ int coupled_streams,
+ const unsigned char *mapping
+) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(6);
+
+/** Decode a multistream Opus packet.
+ * @param st OpusMSDecoder*: Multistream decoder state.
+ * @param[in] data const unsigned char*: Input payload.
+ * Use a NULL
+ * pointer to indicate packet
+ * loss.
+ * @param len opus_int32: Number of bytes in payload.
+ * @param[out] pcm opus_int16*: Output signal, with interleaved
+ * samples.
+ * This must contain room for
+ * frame_size*channels
+ * samples.
+ * @param frame_size int: The number of samples per channel of
+ * available space in \a pcm.
+ * If this is less than the maximum packet duration
+ * (120 ms; 5760 for 48kHz), this function will not be capable
+ * of decoding some packets. In the case of PLC (data==NULL)
+ * or FEC (decode_fec=1), then frame_size needs to be exactly
+ * the duration of audio that is missing, otherwise the
+ * decoder will not be in the optimal state to decode the
+ * next incoming packet. For the PLC and FEC cases, frame_size
+ * must be a multiple of 2.5 ms.
+ * @param decode_fec int: Flag (0 or 1) to request that any in-band
+ * forward error correction data be decoded.
+ * If no such data is available, the frame is
+ * decoded as if it were lost.
+ * @returns Number of samples decoded on success or a negative error code
+ * (see @ref opus_errorcodes) on failure.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_multistream_decode(
+ OpusMSDecoder *st,
+ const unsigned char *data,
+ opus_int32 len,
+ opus_int16 *pcm,
+ int frame_size,
+ int decode_fec
+) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(4);
+
+/** Decode a multistream Opus packet with floating point output.
+ * @param st OpusMSDecoder*: Multistream decoder state.
+ * @param[in] data const unsigned char*: Input payload.
+ * Use a NULL
+ * pointer to indicate packet
+ * loss.
+ * @param len opus_int32: Number of bytes in payload.
+ * @param[out] pcm opus_int16*: Output signal, with interleaved
+ * samples.
+ * This must contain room for
+ * frame_size*channels
+ * samples.
+ * @param frame_size int: The number of samples per channel of
+ * available space in \a pcm.
+ * If this is less than the maximum packet duration
+ * (120 ms; 5760 for 48kHz), this function will not be capable
+ * of decoding some packets. In the case of PLC (data==NULL)
+ * or FEC (decode_fec=1), then frame_size needs to be exactly
+ * the duration of audio that is missing, otherwise the
+ * decoder will not be in the optimal state to decode the
+ * next incoming packet. For the PLC and FEC cases, frame_size
+ * must be a multiple of 2.5 ms.
+ * @param decode_fec int: Flag (0 or 1) to request that any in-band
+ * forward error correction data be decoded.
+ * If no such data is available, the frame is
+ * decoded as if it were lost.
+ * @returns Number of samples decoded on success or a negative error code
+ * (see @ref opus_errorcodes) on failure.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_multistream_decode_float(
+ OpusMSDecoder *st,
+ const unsigned char *data,
+ opus_int32 len,
+ float *pcm,
+ int frame_size,
+ int decode_fec
+) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(4);
+
+/** Perform a CTL function on a multistream Opus decoder.
+ *
+ * Generally the request and subsequent arguments are generated by a
+ * convenience macro.
+ * @param st OpusMSDecoder*: Multistream decoder state.
+ * @param request This and all remaining parameters should be replaced by one
+ * of the convenience macros in @ref opus_genericctls,
+ * @ref opus_decoderctls, or @ref opus_multistream_ctls.
+ * @see opus_genericctls
+ * @see opus_decoderctls
+ * @see opus_multistream_ctls
+ */
+OPUS_EXPORT int opus_multistream_decoder_ctl(OpusMSDecoder *st, int request, ...) OPUS_ARG_NONNULL(1);
+
+/** Frees an OpusMSDecoder allocated by
+ * opus_multistream_decoder_create().
+ * @param st OpusMSDecoder: Multistream decoder state to be freed.
+ */
+OPUS_EXPORT void opus_multistream_decoder_destroy(OpusMSDecoder *st);
+
+/**@}*/
+
+/**@}*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* OPUS_MULTISTREAM_H */
diff --git a/app/src/main/cpp/opus_projection.h b/app/src/main/cpp/opus_projection.h
new file mode 100644
index 0000000..9dabf4e
--- /dev/null
+++ b/app/src/main/cpp/opus_projection.h
@@ -0,0 +1,568 @@
+/* Copyright (c) 2017 Google Inc.
+ Written by Andrew Allen */
+/*
+ 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.
+*/
+
+/**
+ * @file opus_projection.h
+ * @brief Opus projection reference API
+ */
+
+#ifndef OPUS_PROJECTION_H
+#define OPUS_PROJECTION_H
+
+#include "opus_multistream.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** @cond OPUS_INTERNAL_DOC */
+
+/** These are the actual encoder and decoder CTL ID numbers.
+ * They should not be used directly by applications.c
+ * In general, SETs should be even and GETs should be odd.*/
+/**@{*/
+#define OPUS_PROJECTION_GET_DEMIXING_MATRIX_GAIN_REQUEST 6001
+#define OPUS_PROJECTION_GET_DEMIXING_MATRIX_SIZE_REQUEST 6003
+#define OPUS_PROJECTION_GET_DEMIXING_MATRIX_REQUEST 6005
+/**@}*/
+
+
+/** @endcond */
+
+/** @defgroup opus_projection_ctls Projection specific encoder and decoder CTLs
+ *
+ * These are convenience macros that are specific to the
+ * opus_projection_encoder_ctl() and opus_projection_decoder_ctl()
+ * interface.
+ * The CTLs from @ref opus_genericctls, @ref opus_encoderctls,
+ * @ref opus_decoderctls, and @ref opus_multistream_ctls may be applied to a
+ * projection encoder or decoder as well.
+ */
+/**@{*/
+
+/** Gets the gain (in dB. S7.8-format) of the demixing matrix from the encoder.
+ * @param[out] x opus_int32 *: Returns the gain (in dB. S7.8-format)
+ * of the demixing matrix.
+ * @hideinitializer
+ */
+#define OPUS_PROJECTION_GET_DEMIXING_MATRIX_GAIN(x) OPUS_PROJECTION_GET_DEMIXING_MATRIX_GAIN_REQUEST, __opus_check_int_ptr(x)
+
+
+/** Gets the size in bytes of the demixing matrix from the encoder.
+ * @param[out] x opus_int32 *: Returns the size in bytes of the
+ * demixing matrix.
+ * @hideinitializer
+ */
+#define OPUS_PROJECTION_GET_DEMIXING_MATRIX_SIZE(x) OPUS_PROJECTION_GET_DEMIXING_MATRIX_SIZE_REQUEST, __opus_check_int_ptr(x)
+
+
+/** Copies the demixing matrix to the supplied pointer location.
+ * @param[out] x unsigned char *: Returns the demixing matrix to the
+ * supplied pointer location.
+ * @param y opus_int32: The size in bytes of the reserved memory at the
+ * pointer location.
+ * @hideinitializer
+ */
+#define OPUS_PROJECTION_GET_DEMIXING_MATRIX(x,y) OPUS_PROJECTION_GET_DEMIXING_MATRIX_REQUEST, x, __opus_check_int(y)
+
+
+/**@}*/
+
+/** Opus projection encoder state.
+ * This contains the complete state of a projection Opus encoder.
+ * It is position independent and can be freely copied.
+ * @see opus_projection_ambisonics_encoder_create
+ */
+typedef struct OpusProjectionEncoder OpusProjectionEncoder;
+
+
+/** Opus projection decoder state.
+ * This contains the complete state of a projection Opus decoder.
+ * It is position independent and can be freely copied.
+ * @see opus_projection_decoder_create
+ * @see opus_projection_decoder_init
+ */
+typedef struct OpusProjectionDecoder OpusProjectionDecoder;
+
+
+/**\name Projection encoder functions */
+/**@{*/
+
+/** Gets the size of an OpusProjectionEncoder structure.
+ * @param channels int: The total number of input channels to encode.
+ * This must be no more than 255.
+ * @param mapping_family int: The mapping family to use for selecting
+ * the appropriate projection.
+ * @returns The size in bytes on success, or a negative error code
+ * (see @ref opus_errorcodes) on error.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_projection_ambisonics_encoder_get_size(
+ int channels,
+ int mapping_family
+);
+
+
+/** Allocates and initializes a projection encoder state.
+ * Call opus_projection_encoder_destroy() to release
+ * this object when finished.
+ * @param Fs opus_int32: Sampling rate of the input signal (in Hz).
+ * This must be one of 8000, 12000, 16000,
+ * 24000, or 48000.
+ * @param channels int: Number of channels in the input signal.
+ * This must be at most 255.
+ * It may be greater than the number of
+ * coded channels (streams +
+ * coupled_streams).
+ * @param mapping_family int: The mapping family to use for selecting
+ * the appropriate projection.
+ * @param[out] streams int *: The total number of streams that will
+ * be encoded from the input.
+ * @param[out] coupled_streams int *: Number of coupled (2 channel)
+ * streams that will be encoded from the input.
+ * @param application int: The target encoder application.
+ * This must be one of the following:
+ *
+ * - #OPUS_APPLICATION_VOIP
+ * - Process signal for improved speech intelligibility.
+ * - #OPUS_APPLICATION_AUDIO
+ * - Favor faithfulness to the original input.
+ * - #OPUS_APPLICATION_RESTRICTED_LOWDELAY
+ * - Configure the minimum possible coding delay by disabling certain modes
+ * of operation.
+ *
+ * @param[out] error int *: Returns #OPUS_OK on success, or an error
+ * code (see @ref opus_errorcodes) on
+ * failure.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusProjectionEncoder *opus_projection_ambisonics_encoder_create(
+ opus_int32 Fs,
+ int channels,
+ int mapping_family,
+ int *streams,
+ int *coupled_streams,
+ int application,
+ int *error
+) OPUS_ARG_NONNULL(4) OPUS_ARG_NONNULL(5);
+
+
+/** Initialize a previously allocated projection encoder state.
+ * The memory pointed to by \a st must be at least the size returned by
+ * opus_projection_ambisonics_encoder_get_size().
+ * This is intended for applications which use their own allocator instead of
+ * malloc.
+ * To reset a previously initialized state, use the #OPUS_RESET_STATE CTL.
+ * @see opus_projection_ambisonics_encoder_create
+ * @see opus_projection_ambisonics_encoder_get_size
+ * @param st OpusProjectionEncoder*: Projection encoder state to initialize.
+ * @param Fs opus_int32: Sampling rate of the input signal (in Hz).
+ * This must be one of 8000, 12000, 16000,
+ * 24000, or 48000.
+ * @param channels int: Number of channels in the input signal.
+ * This must be at most 255.
+ * It may be greater than the number of
+ * coded channels (streams +
+ * coupled_streams).
+ * @param streams int: The total number of streams to encode from the
+ * input.
+ * This must be no more than the number of channels.
+ * @param coupled_streams int: Number of coupled (2 channel) streams
+ * to encode.
+ * This must be no larger than the total
+ * number of streams.
+ * Additionally, The total number of
+ * encoded channels (streams +
+ * coupled_streams) must be no
+ * more than the number of input channels.
+ * @param application int: The target encoder application.
+ * This must be one of the following:
+ *
+ * - #OPUS_APPLICATION_VOIP
+ * - Process signal for improved speech intelligibility.
+ * - #OPUS_APPLICATION_AUDIO
+ * - Favor faithfulness to the original input.
+ * - #OPUS_APPLICATION_RESTRICTED_LOWDELAY
+ * - Configure the minimum possible coding delay by disabling certain modes
+ * of operation.
+ *
+ * @returns #OPUS_OK on success, or an error code (see @ref opus_errorcodes)
+ * on failure.
+ */
+OPUS_EXPORT int opus_projection_ambisonics_encoder_init(
+ OpusProjectionEncoder *st,
+ opus_int32 Fs,
+ int channels,
+ int mapping_family,
+ int *streams,
+ int *coupled_streams,
+ int application
+) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(5) OPUS_ARG_NONNULL(6);
+
+
+/** Encodes a projection Opus frame.
+ * @param st OpusProjectionEncoder*: Projection encoder state.
+ * @param[in] pcm const opus_int16*: The input signal as interleaved
+ * samples.
+ * This must contain
+ * frame_size*channels
+ * samples.
+ * @param frame_size int: Number of samples per channel in the input
+ * signal.
+ * This must be an Opus frame size for the
+ * encoder's sampling rate.
+ * For example, at 48 kHz the permitted values
+ * are 120, 240, 480, 960, 1920, and 2880.
+ * Passing in a duration of less than 10 ms
+ * (480 samples at 48 kHz) will prevent the
+ * encoder from using the LPC or hybrid modes.
+ * @param[out] data unsigned char*: Output payload.
+ * This must contain storage for at
+ * least \a max_data_bytes.
+ * @param [in] max_data_bytes opus_int32: Size of the allocated
+ * memory for the output
+ * payload. This may be
+ * used to impose an upper limit on
+ * the instant bitrate, but should
+ * not be used as the only bitrate
+ * control. Use #OPUS_SET_BITRATE to
+ * control the bitrate.
+ * @returns The length of the encoded packet (in bytes) on success or a
+ * negative error code (see @ref opus_errorcodes) on failure.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_projection_encode(
+ OpusProjectionEncoder *st,
+ const opus_int16 *pcm,
+ int frame_size,
+ unsigned char *data,
+ opus_int32 max_data_bytes
+) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2) OPUS_ARG_NONNULL(4);
+
+
+/** Encodes a projection Opus frame from floating point input.
+ * @param st OpusProjectionEncoder*: Projection encoder state.
+ * @param[in] pcm const float*: The input signal as interleaved
+ * samples with a normal range of
+ * +/-1.0.
+ * Samples with a range beyond +/-1.0
+ * are supported but will be clipped by
+ * decoders using the integer API and
+ * should only be used if it is known
+ * that the far end supports extended
+ * dynamic range.
+ * This must contain
+ * frame_size*channels
+ * samples.
+ * @param frame_size int: Number of samples per channel in the input
+ * signal.
+ * This must be an Opus frame size for the
+ * encoder's sampling rate.
+ * For example, at 48 kHz the permitted values
+ * are 120, 240, 480, 960, 1920, and 2880.
+ * Passing in a duration of less than 10 ms
+ * (480 samples at 48 kHz) will prevent the
+ * encoder from using the LPC or hybrid modes.
+ * @param[out] data unsigned char*: Output payload.
+ * This must contain storage for at
+ * least \a max_data_bytes.
+ * @param [in] max_data_bytes opus_int32: Size of the allocated
+ * memory for the output
+ * payload. This may be
+ * used to impose an upper limit on
+ * the instant bitrate, but should
+ * not be used as the only bitrate
+ * control. Use #OPUS_SET_BITRATE to
+ * control the bitrate.
+ * @returns The length of the encoded packet (in bytes) on success or a
+ * negative error code (see @ref opus_errorcodes) on failure.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_projection_encode_float(
+ OpusProjectionEncoder *st,
+ const float *pcm,
+ int frame_size,
+ unsigned char *data,
+ opus_int32 max_data_bytes
+) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2) OPUS_ARG_NONNULL(4);
+
+
+/** Frees an OpusProjectionEncoder allocated by
+ * opus_projection_ambisonics_encoder_create().
+ * @param st OpusProjectionEncoder*: Projection encoder state to be freed.
+ */
+OPUS_EXPORT void opus_projection_encoder_destroy(OpusProjectionEncoder *st);
+
+
+/** Perform a CTL function on a projection Opus encoder.
+ *
+ * Generally the request and subsequent arguments are generated by a
+ * convenience macro.
+ * @param st OpusProjectionEncoder*: Projection encoder state.
+ * @param request This and all remaining parameters should be replaced by one
+ * of the convenience macros in @ref opus_genericctls,
+ * @ref opus_encoderctls, @ref opus_multistream_ctls, or
+ * @ref opus_projection_ctls
+ * @see opus_genericctls
+ * @see opus_encoderctls
+ * @see opus_multistream_ctls
+ * @see opus_projection_ctls
+ */
+OPUS_EXPORT int opus_projection_encoder_ctl(OpusProjectionEncoder *st, int request, ...) OPUS_ARG_NONNULL(1);
+
+
+/**@}*/
+
+/**\name Projection decoder functions */
+/**@{*/
+
+/** Gets the size of an OpusProjectionDecoder structure.
+ * @param channels int: The total number of output channels.
+ * This must be no more than 255.
+ * @param streams int: The total number of streams coded in the
+ * input.
+ * This must be no more than 255.
+ * @param coupled_streams int: Number streams to decode as coupled
+ * (2 channel) streams.
+ * This must be no larger than the total
+ * number of streams.
+ * Additionally, The total number of
+ * coded channels (streams +
+ * coupled_streams) must be no
+ * more than 255.
+ * @returns The size in bytes on success, or a negative error code
+ * (see @ref opus_errorcodes) on error.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_projection_decoder_get_size(
+ int channels,
+ int streams,
+ int coupled_streams
+);
+
+
+/** Allocates and initializes a projection decoder state.
+ * Call opus_projection_decoder_destroy() to release
+ * this object when finished.
+ * @param Fs opus_int32: Sampling rate to decode at (in Hz).
+ * This must be one of 8000, 12000, 16000,
+ * 24000, or 48000.
+ * @param channels int: Number of channels to output.
+ * This must be at most 255.
+ * It may be different from the number of coded
+ * channels (streams +
+ * coupled_streams).
+ * @param streams int: The total number of streams coded in the
+ * input.
+ * This must be no more than 255.
+ * @param coupled_streams int: Number of streams to decode as coupled
+ * (2 channel) streams.
+ * This must be no larger than the total
+ * number of streams.
+ * Additionally, The total number of
+ * coded channels (streams +
+ * coupled_streams) must be no
+ * more than 255.
+ * @param[in] demixing_matrix const unsigned char[demixing_matrix_size]: Demixing matrix
+ * that mapping from coded channels to output channels,
+ * as described in @ref opus_projection and
+ * @ref opus_projection_ctls.
+ * @param demixing_matrix_size opus_int32: The size in bytes of the
+ * demixing matrix, as
+ * described in @ref
+ * opus_projection_ctls.
+ * @param[out] error int *: Returns #OPUS_OK on success, or an error
+ * code (see @ref opus_errorcodes) on
+ * failure.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusProjectionDecoder *opus_projection_decoder_create(
+ opus_int32 Fs,
+ int channels,
+ int streams,
+ int coupled_streams,
+ unsigned char *demixing_matrix,
+ opus_int32 demixing_matrix_size,
+ int *error
+) OPUS_ARG_NONNULL(5);
+
+
+/** Intialize a previously allocated projection decoder state object.
+ * The memory pointed to by \a st must be at least the size returned by
+ * opus_projection_decoder_get_size().
+ * This is intended for applications which use their own allocator instead of
+ * malloc.
+ * To reset a previously initialized state, use the #OPUS_RESET_STATE CTL.
+ * @see opus_projection_decoder_create
+ * @see opus_projection_deocder_get_size
+ * @param st OpusProjectionDecoder*: Projection encoder state to initialize.
+ * @param Fs opus_int32: Sampling rate to decode at (in Hz).
+ * This must be one of 8000, 12000, 16000,
+ * 24000, or 48000.
+ * @param channels int: Number of channels to output.
+ * This must be at most 255.
+ * It may be different from the number of coded
+ * channels (streams +
+ * coupled_streams).
+ * @param streams int: The total number of streams coded in the
+ * input.
+ * This must be no more than 255.
+ * @param coupled_streams int: Number of streams to decode as coupled
+ * (2 channel) streams.
+ * This must be no larger than the total
+ * number of streams.
+ * Additionally, The total number of
+ * coded channels (streams +
+ * coupled_streams) must be no
+ * more than 255.
+ * @param[in] demixing_matrix const unsigned char[demixing_matrix_size]: Demixing matrix
+ * that mapping from coded channels to output channels,
+ * as described in @ref opus_projection and
+ * @ref opus_projection_ctls.
+ * @param demixing_matrix_size opus_int32: The size in bytes of the
+ * demixing matrix, as
+ * described in @ref
+ * opus_projection_ctls.
+ * @returns #OPUS_OK on success, or an error code (see @ref opus_errorcodes)
+ * on failure.
+ */
+OPUS_EXPORT int opus_projection_decoder_init(
+ OpusProjectionDecoder *st,
+ opus_int32 Fs,
+ int channels,
+ int streams,
+ int coupled_streams,
+ unsigned char *demixing_matrix,
+ opus_int32 demixing_matrix_size
+) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(6);
+
+
+/** Decode a projection Opus packet.
+ * @param st OpusProjectionDecoder*: Projection decoder state.
+ * @param[in] data const unsigned char*: Input payload.
+ * Use a NULL
+ * pointer to indicate packet
+ * loss.
+ * @param len opus_int32: Number of bytes in payload.
+ * @param[out] pcm opus_int16*: Output signal, with interleaved
+ * samples.
+ * This must contain room for
+ * frame_size*channels
+ * samples.
+ * @param frame_size int: The number of samples per channel of
+ * available space in \a pcm.
+ * If this is less than the maximum packet duration
+ * (120 ms; 5760 for 48kHz), this function will not be capable
+ * of decoding some packets. In the case of PLC (data==NULL)
+ * or FEC (decode_fec=1), then frame_size needs to be exactly
+ * the duration of audio that is missing, otherwise the
+ * decoder will not be in the optimal state to decode the
+ * next incoming packet. For the PLC and FEC cases, frame_size
+ * must be a multiple of 2.5 ms.
+ * @param decode_fec int: Flag (0 or 1) to request that any in-band
+ * forward error correction data be decoded.
+ * If no such data is available, the frame is
+ * decoded as if it were lost.
+ * @returns Number of samples decoded on success or a negative error code
+ * (see @ref opus_errorcodes) on failure.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_projection_decode(
+ OpusProjectionDecoder *st,
+ const unsigned char *data,
+ opus_int32 len,
+ opus_int16 *pcm,
+ int frame_size,
+ int decode_fec
+) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(4);
+
+
+/** Decode a projection Opus packet with floating point output.
+ * @param st OpusProjectionDecoder*: Projection decoder state.
+ * @param[in] data const unsigned char*: Input payload.
+ * Use a NULL
+ * pointer to indicate packet
+ * loss.
+ * @param len opus_int32: Number of bytes in payload.
+ * @param[out] pcm opus_int16*: Output signal, with interleaved
+ * samples.
+ * This must contain room for
+ * frame_size*channels
+ * samples.
+ * @param frame_size int: The number of samples per channel of
+ * available space in \a pcm.
+ * If this is less than the maximum packet duration
+ * (120 ms; 5760 for 48kHz), this function will not be capable
+ * of decoding some packets. In the case of PLC (data==NULL)
+ * or FEC (decode_fec=1), then frame_size needs to be exactly
+ * the duration of audio that is missing, otherwise the
+ * decoder will not be in the optimal state to decode the
+ * next incoming packet. For the PLC and FEC cases, frame_size
+ * must be a multiple of 2.5 ms.
+ * @param decode_fec int: Flag (0 or 1) to request that any in-band
+ * forward error correction data be decoded.
+ * If no such data is available, the frame is
+ * decoded as if it were lost.
+ * @returns Number of samples decoded on success or a negative error code
+ * (see @ref opus_errorcodes) on failure.
+ */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_projection_decode_float(
+ OpusProjectionDecoder *st,
+ const unsigned char *data,
+ opus_int32 len,
+ float *pcm,
+ int frame_size,
+ int decode_fec
+) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(4);
+
+
+/** Perform a CTL function on a projection Opus decoder.
+ *
+ * Generally the request and subsequent arguments are generated by a
+ * convenience macro.
+ * @param st OpusProjectionDecoder*: Projection decoder state.
+ * @param request This and all remaining parameters should be replaced by one
+ * of the convenience macros in @ref opus_genericctls,
+ * @ref opus_decoderctls, @ref opus_multistream_ctls, or
+ * @ref opus_projection_ctls.
+ * @see opus_genericctls
+ * @see opus_decoderctls
+ * @see opus_multistream_ctls
+ * @see opus_projection_ctls
+ */
+OPUS_EXPORT int opus_projection_decoder_ctl(OpusProjectionDecoder *st, int request, ...) OPUS_ARG_NONNULL(1);
+
+
+/** Frees an OpusProjectionDecoder allocated by
+ * opus_projection_decoder_create().
+ * @param st OpusProjectionDecoder: Projection decoder state to be freed.
+ */
+OPUS_EXPORT void opus_projection_decoder_destroy(OpusProjectionDecoder *st);
+
+
+/**@}*/
+
+/**@}*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* OPUS_PROJECTION_H */
diff --git a/app/src/main/cpp/opus_recorder.cpp b/app/src/main/cpp/opus_recorder.cpp
new file mode 100644
index 0000000..b3cdf8f
--- /dev/null
+++ b/app/src/main/cpp/opus_recorder.cpp
@@ -0,0 +1,77 @@
+#include
+#include
+#include
+#include "opus.h"
+
+#define LOG_TAG "OpusJNI"
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+
+// Opus编码器句柄
+static OpusEncoder *encoderHandle = nullptr;
+
+extern "C" {
+
+JNIEXPORT jlong JNICALL
+Java_info_dourok_voicebot_OpusEncoder_nativeInitEncoder(JNIEnv *env, jobject thiz,
+ jint sample_rate, jint channels,
+ jint application) {
+ int error;
+ OpusEncoder *encoder = opus_encoder_create(sample_rate, channels, application, &error);
+
+ if (error != OPUS_OK || encoder == nullptr) {
+ LOGE("Failed to create encoder: %s", opus_strerror(error));
+ return 0;
+ }
+
+ opus_encoder_ctl(encoder, OPUS_SET_BITRATE(64000)); // 64 kbps
+ opus_encoder_ctl(encoder, OPUS_SET_COMPLEXITY(10)); // 0-10, 10是最高质量
+
+ LOGI("Opus encoder initialized: sample_rate=%d, channels=%d", sample_rate, channels);
+ return (jlong) (intptr_t) encoder;
+}
+
+JNIEXPORT jint JNICALL
+Java_info_dourok_voicebot_OpusEncoder_nativeEncodeBytes(JNIEnv *env, jobject thiz,
+ jlong encoder_handle,
+ jbyteArray input_buffer,
+ jint input_size,
+ jbyteArray output_buffer,
+ jint max_output_size) {
+ OpusEncoder *encoder = (OpusEncoder *) (intptr_t) encoder_handle;
+ if (encoder == nullptr) {
+ LOGE("Encoder handle is null");
+ return -1;
+ }
+
+ jbyte *input = env->GetByteArrayElements(input_buffer, nullptr);
+ jbyte *output = env->GetByteArrayElements(output_buffer, nullptr);
+
+ opus_int16 *pcm = (opus_int16 *) input;
+ int frame_size = input_size / 2; // 16位samples的数量
+
+ int result = opus_encode(encoder, pcm, frame_size,
+ (unsigned char *) output, max_output_size);
+
+ env->ReleaseByteArrayElements(input_buffer, input, JNI_ABORT);
+ env->ReleaseByteArrayElements(output_buffer, output, 0);
+
+ if (result < 0) {
+ LOGE("Encoding failed: %s", opus_strerror(result));
+ return -1;
+ }
+
+ return result;
+}
+
+JNIEXPORT void JNICALL
+Java_info_dourok_voicebot_OpusEncoder_nativeReleaseEncoder(JNIEnv *env, jobject thiz,
+ jlong encoder_handle) {
+ OpusEncoder *encoder = (OpusEncoder *) (intptr_t) encoder_handle;
+ if (encoder != nullptr) {
+ opus_encoder_destroy(encoder);
+ LOGI("Opus encoder released");
+ }
+}
+
+} // extern "C"
\ No newline at end of file
diff --git a/app/src/main/cpp/opus_types.h b/app/src/main/cpp/opus_types.h
new file mode 100644
index 0000000..7cf6755
--- /dev/null
+++ b/app/src/main/cpp/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
+# 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
+ 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
+ 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
+ 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 */
diff --git a/app/src/main/java/com/zs/smarthuman/sherpa/VadManager.kt b/app/src/main/java/com/zs/smarthuman/sherpa/VadManager.kt
index 7e64636..cadf8ed 100644
--- a/app/src/main/java/com/zs/smarthuman/sherpa/VadManager.kt
+++ b/app/src/main/java/com/zs/smarthuman/sherpa/VadManager.kt
@@ -25,11 +25,14 @@ class VadManager(
private var lastActiveMs = 0L
private var speechStartMs = 0L
- // 配置参数
- private val MIN_RMS = 0.003f
- private val END_SILENCE_MS = 200L
- private val SPEECH_START_PROTECT_MS = 90L
- private val RESET_IDLE_MS = 3_000L
+ // 配置参数优化：适配预缓存逻辑，减少开头丢失概率
+ private val MIN_RMS = 0.002f // 降低能量阈值，避免弱语音开头被过滤
+ private val END_SILENCE_MS = 100L // 保持不变
+ private val SPEECH_START_PROTECT_MS = 30L // 缩短语音开始保护时间（从90→50ms），更快触发onSpeechStart
+ private val RESET_IDLE_MS = 3_000L // 保持不变
+
+ // 新增：标记是否已触发过语音开始回调，避免重复触发
+ private var speechStartTriggered = false
init {
try {
@@ -38,14 +41,14 @@ class VadManager(
VadModelConfig(
sileroVadModelConfig = SileroVadModelConfig(
model = "silero_vad.onnx",
- threshold = 0.45F,
+ threshold = 0.40F, // 降低VAD检测阈值（从0.45→0.40），更灵敏检测开头语音
minSilenceDuration = 0.05F,
- minSpeechDuration = 0.1F,
+ minSpeechDuration = 0.08F, // 缩短最小语音时长（从0.1→0.08s），更快识别短开头
windowSize = 512
)
)
)
- LogUtils.i(TAG, "✅ VAD 初始化完成（线程安全版）")
+ LogUtils.i(TAG, "✅ VAD 初始化完成（线程安全+开头优化版）")
} catch (e: Exception) {
LogUtils.e(TAG, "❌ VAD 初始化失败", e)
throw e
@@ -63,7 +66,7 @@ class VadManager(
}
val now = System.currentTimeMillis()
- // 快速能量检测
+ // 快速能量检测：优化采样步长，提高开头检测精度
val rms = fastRms(samples)
if (rms < MIN_RMS) {
handleSilence(now)
@@ -82,11 +85,13 @@ class VadManager(
if (hasSpeech) {
lastSpeechMs = now
lastActiveMs = now
- if (!isSpeaking) {
+ // 优化：避免重复触发onSpeechStart
+ if (!isSpeaking && !speechStartTriggered) {
isSpeaking = true
+ speechStartTriggered = true // 标记已触发
speechStartMs = now
- onSpeechStart()
- LogUtils.d(TAG, "🗣 语音开始 | RMS: $rms | 采样数: ${samples.size}")
+ onSpeechStart() // 立即触发，不延迟
+ LogUtils.d(TAG, "🗣 语音开始 | RMS: $rms | 采样数: ${samples.size} | 时间戳: $now")
}
} else {
handleSilence(now)
@@ -115,6 +120,7 @@ class VadManager(
&& now - lastSpeechMs > END_SILENCE_MS
) {
isSpeaking = false
+ speechStartTriggered = false // 重置触发标记
onSpeechEnd()
LogUtils.d(TAG, "🔇 语音结束 | 总时长: ${now - speechStartMs}ms")
}
@@ -123,6 +129,7 @@ class VadManager(
if (!isSpeaking && now - lastActiveMs > RESET_IDLE_MS) {
try {
vad.reset()
+ speechStartTriggered = false // 重置触发标记
lastActiveMs = now
LogUtils.d(TAG, "🔄 VAD 空闲自动重置")
} catch (e: Exception) {
@@ -131,11 +138,11 @@ class VadManager(
}
}
- // 快速RMS计算逻辑保持不变
+ // 优化：调整RMS计算步长，提高开头弱语音的检测精度（从4→2）
private fun fastRms(samples: FloatArray): Float {
var sum = 0f
var count = 0
- val step = 4
+ val step = 2 // 缩小采样步长，更精准计算能量
var i = 0
while (i < samples.size) {
val v = samples[i]
@@ -147,17 +154,18 @@ class VadManager(
}
/**
- * 线程安全的重置方法
+ * 线程安全的重置方法：新增重置触发标记
*/
suspend fun reset() {
vadMutex.withLock {
isSpeaking = false
+ speechStartTriggered = false // 关键：重置触发标记
lastSpeechMs = 0L
lastActiveMs = 0L
speechStartMs = 0L
try {
vad.reset()
- LogUtils.d(TAG, "🔄 VAD 手动重置完成")
+ LogUtils.d(TAG, "🔄 VAD 手动重置完成（含触发标记）")
} catch (e: Exception) {
LogUtils.e(TAG, "❌ VAD 手动重置异常", e)
}
diff --git a/app/src/main/java/com/zs/smarthuman/sherpa/VoiceController.kt b/app/src/main/java/com/zs/smarthuman/sherpa/VoiceController.kt
index 5c90b5e..781a5a5 100644
--- a/app/src/main/java/com/zs/smarthuman/sherpa/VoiceController.kt
+++ b/app/src/main/java/com/zs/smarthuman/sherpa/VoiceController.kt
@@ -20,14 +20,6 @@ import kotlinx.coroutines.asCoroutineDispatcher
import kotlin.math.max
import kotlin.math.min
-// 1. 封装声纹验证状态（替代零散的Boolean标记）
-private data class SpeakerVerifyState(
- var job: Job? = null,
- var finished: Boolean = false,
- var passed: Boolean = true, // fail-open 默认放行
- var failed: Boolean = false
-)
-
// 2. 封装超时相关状态
private data class TimeoutState(
var idleTimeoutMs: Long,
@@ -54,16 +46,11 @@ class VoiceController(
private const val SAMPLE_RATE = 16000
private const val PRE_BUFFER_SIZE = SAMPLE_RATE * 2
private const val INVALID_RESET_DEBOUNCE_MS = 1500L
- private const val SPEAKER_THRESHOLD = 0.35f
- private const val MIN_VERIFY_MS = 600L
+ private const val SPEAKER_THRESHOLD = 0.4f
+ private const val MIN_VERIFY_MS = 650L
private const val MAX_VERIFY_MS = 1200L
private const val KWS_OBSERVE_MS = 500L
private const val SPEECH_COOLDOWN_MS = 680L
-
- // 声纹验证常量集中管理
- private const val SPEAKER_VERIFY_NEED_SAMPLES_MS = 600L
- private const val SPEAKER_VERIFY_MAX_WAIT_MS = 800L
- private const val SPEAKER_VERIFY_CHECK_INTERVAL_MS = 20L
}
// ================= 核心优化：自定义IO线程池（减少调度开销） =================
@@ -85,9 +72,6 @@ class VoiceController(
onStateChanged?.invoke(value)
}
- // 声纹验证状态封装（替代零散的Boolean）
- private val speakerVerifyState = SpeakerVerifyState()
-
// 超时状态封装
private val timeoutState = TimeoutState(
idleTimeoutMs = idleTimeoutSeconds * 1000L,
@@ -331,7 +315,6 @@ class VoiceController(
audioBufferSize += copySize
}
- startSpeakerVerify()
state = VoiceState.RECORDING
}
@@ -345,84 +328,36 @@ class VoiceController(
finishSentence()
}
-
- /* ================= 声纹验证（统一Job管理 + 原生数组优化） ================= */
- private fun startSpeakerVerify() {
- // 修复：彻底取消旧任务，防止回调泄漏
- speakerVerifyState.job?.cancel()
- speakerVerifyState.job = null
- // 修复：强制重置所有声纹状态，无残留
- resetSpeakerVerifyState()
-
- // 启动新的验证任务，绑定到统一作用域
- speakerVerifyState.job = coroutineScope.launch(customIoDispatcher) {
- val needSamples = (SAMPLE_RATE * SPEAKER_VERIFY_NEED_SAMPLES_MS / 1000).toInt()
- var waited = 0L
-
- // 等待足够的音频样本（使用audioBufferSize）
- while (audioBufferSize < needSamples && waited < SPEAKER_VERIFY_MAX_WAIT_MS) {
- delay(SPEAKER_VERIFY_CHECK_INTERVAL_MS)
- waited += SPEAKER_VERIFY_CHECK_INTERVAL_MS
- }
-
- if (audioBufferSize < needSamples) {
- speakerVerifyState.finished = true
- return@launch
- }
-
- // 优化：直接从原生数组截取，无拷贝
- val startIdx = maxOf(0, audioBufferSize - needSamples)
- val input = audioBuffer.copyOfRange(startIdx, audioBufferSize)
- val pass = verifySpeaker(input)
-
- // 更新状态（线程安全）
- withContext(Dispatchers.Main) {
- speakerVerifyState.passed = pass
- speakerVerifyState.failed = !pass
- speakerVerifyState.finished = true
- }
- }
- }
-
- private suspend fun verifySpeaker(audio: FloatArray): Boolean {
- if (audio.isEmpty()) return false
-
- val audioMs = audio.size * 1000L / SAMPLE_RATE
- // 修复：严格模式下，短音频直接判定失败，不允许跳过
-// if (audioMs < MIN_VERIFY_MS) {
-// return if (ENABLE_STRICT_SPEAKER_VERIFY) {
-// LogUtils.w(TAG, "🔴 严格模式：短音频 $audioMs ms，声纹验证失败")
-// false
-// } else {
-// LogUtils.d(TAG, "🟡 非严格模式：短音频 $audioMs ms，跳过声纹")
-// true
-// }
-// }
-
- val verifyStartMs = System.currentTimeMillis()
-
- val maxSamples = (SAMPLE_RATE * MAX_VERIFY_MS / 1000).toInt()
- val input = if (audio.size > maxSamples) {
- audio.copyOfRange(audio.size - maxSamples, audio.size)
+ private fun verifySpeaker(audio: FloatArray): Boolean {
+ val verifyStartNs = System.nanoTime()
+ val totalSamples = audio.size
+ val tempTarget = min((SAMPLE_RATE * MAX_VERIFY_MS / 1000).toInt(), totalSamples)
+ val targetSamples = max(tempTarget, (SAMPLE_RATE * MIN_VERIFY_MS / 1000).toInt())
+ val midStartIndex = (totalSamples - targetSamples) / 2
+ val finalAudio = if (midStartIndex >= 0 && midStartIndex + targetSamples <= totalSamples) {
+ audio.copyOfRange(midStartIndex, midStartIndex + targetSamples)
} else {
- audio
+ val verifyCostMs = (System.nanoTime() - verifyStartNs) / 1_000_000
+ LogUtils.d(TAG, "🔍 声纹验证耗时: ${verifyCostMs}ms | 结果: 失败（有效语音过短）")
+ return false
}
- return withContext(customIoDispatcher) {
+ return try {
var stream: OnlineStream? = null
try {
stream = SpeakerRecognition.extractor.createStream()
- stream.acceptWaveform(input, SAMPLE_RATE)
+ stream.acceptWaveform(finalAudio, SAMPLE_RATE) // 用中间段音频验证
stream.inputFinished()
if (!SpeakerRecognition.extractor.isReady(stream)) {
- LogUtils.w(TAG, "⚠️ stream not ready，验证失败")
- return@withContext false
+ val verifyCostMs = (System.nanoTime() - verifyStartNs) / 1_000_000
+ LogUtils.d(TAG, "🔍 声纹验证耗时: ${verifyCostMs}ms | 结果: 失败（Stream未就绪）")
+ return false
}
val embedding = SpeakerRecognition.extractor.compute(stream)
- val pass = speakerManagerLock.withLock {
+ val result = speakerManagerLock.withLock {
SpeakerRecognition.manager.verify(
CURRENT_USER_ID,
embedding,
@@ -430,76 +365,60 @@ class VoiceController(
)
}
- val cost = System.currentTimeMillis() - verifyStartMs
- LogUtils.d(
- TAG,
- "📊 声纹 | pass=$pass | 音频=${audioMs}ms | 输入=${input.size} | 耗时=${cost}ms"
- )
-
- // ================ 核心修复：移除状态判断，声纹失败强制触发终止流程 ================
- if (!pass) {
- withContext(Dispatchers.Main.immediate) {
- // 标记失败状态
- speakerVerifyState.failed = true
- speakerVerifyState.finished = true
- LogUtils.d(TAG, "🔴 声纹验证不通过，安全终止录音流程")
-
- // 核心：主动结束录音，走标准finishSentence闭环，不暴力中断
- finishSentence()
- }
- }
- pass
- } catch (e: Exception) {
- LogUtils.e(TAG, "❌ 声纹异常，验证失败", e)
- false
+ // 计算总耗时（毫秒级，易读）
+ val verifyCostMs = (System.nanoTime() - verifyStartNs) / 1_000_000
+ LogUtils.d(TAG, "🔍 声纹验证耗时: ${verifyCostMs}ms | 结果: ${if (result) "通过" else "拒绝"}")
+ return result
} finally {
stream?.release()
}
+ } catch (e: Exception) {
+ val verifyCostMs = (System.nanoTime() - verifyStartNs) / 1_000_000
+ LogUtils.d(TAG, "🔍 声纹验证耗时: ${verifyCostMs}ms | 结果: 失败（异常）")
+ return false
}
}
- /* ================= 结束录音（优化：原生数组读取） ================= */
private fun finishSentence() {
- // 取消旧任务
- speakerVerifyState.job?.cancel()
- speakerVerifyState.job = null
-
val now = cachedTimeMs
val duration = if (recordingStartMs != 0L) now - recordingStartMs else 0L
- // 声纹失败优先拦截，直接重置，不上传音频
- if (speakerVerifyState.failed) {
- LogUtils.w(TAG, "❌ 声纹标记为失败，强制拒绝本次语音")
- timeoutState.hasInvalidSpeech = true
- // 重置到可交互状态，用户可以立即重新说话
- resetToWaitSpeech()
- return
- }
+ recordingStartMs = 0L
+ vadStarted = false
- // ============ 原有正常逻辑保留 ============
- val isSpeakerVerifyFailed = (ENABLE_STRICT_SPEAKER_VERIFY && speakerVerifyState.finished && !speakerVerifyState.passed)
- if (isSpeakerVerifyFailed) {
- LogUtils.w(TAG, "❌ 声纹验证未通过，拒绝本次语音")
- timeoutState.hasInvalidSpeech = true
- resetToWaitSpeech()
- return
- }
-
- // 无音频防护
+ // 无音频直接拒绝
if (audioBufferSize <= 0) {
- LogUtils.w(TAG, "❌ 无有效音频数据，拒绝上传")
+ LogUtils.w(TAG, "❌ 无有效音频，丢弃")
resetToWaitSpeech()
return
}
- // 正常上传逻辑
+ // 拷贝最终音频（此时 buffer 不再变化）
val audio = audioBuffer.copyOfRange(0, audioBufferSize)
clearAudioBuffer()
- recordingStartMs = 0L
+
+ // ================= 声纹验证：只在这里做 =================
+ if (ENABLE_STRICT_SPEAKER_VERIFY) {
+ val pass = runCatching {
+ verifySpeaker(audio)
+ }.getOrElse {
+ LogUtils.e(TAG, "❌ 声纹异常，拒绝本次语音", it)
+ false
+ }
+ if (!pass) {
+ LogUtils.w(TAG, "🔴 声纹验证失败，拒绝上传")
+ timeoutState.hasInvalidSpeech = true
+ resetToWaitSpeech()
+ return
+ }
+ }
+
+ // ================= 通过后才上传 =================
+ timeoutState.hasInvalidSpeech = false
state = VoiceState.UPLOADING
onFinalAudio(audio)
- timeoutState.hasInvalidSpeech = false
- LogUtils.i(TAG, "✅ 语音通过 | 时长: $duration ms")
+
+ LogUtils.i(TAG, "✅ 语音通过 | 时长: ${duration}ms")
}
/* ================= 播放/上传回调（优化：精简状态判断） ================= */
@@ -560,21 +479,11 @@ class VoiceController(
clearAudioBuffer()
synchronized(preBufferLock) { preBuffer.clear() }
- // 声纹失败场景：全量重置
- if (speakerVerifyState.failed) {
- LogUtils.d(TAG, "🛡 声纹失败，跳过防抖，强制全量重置")
- resetSpeakerVerifyState()
- timeoutState.lastInvalidResetMs = 0
- timeoutState.waitSpeechFailStartMs = now
- return
- }
-
// 原有防抖逻辑
if (now - timeoutState.lastInvalidResetMs < INVALID_RESET_DEBOUNCE_MS) {
return
}
- resetSpeakerVerifyState()
timeoutState.lastInvalidResetMs = now
timeoutState.waitSpeechFailStartMs = now
}
@@ -599,21 +508,9 @@ class VoiceController(
timeoutState.hasInvalidSpeech = false
timeoutState.currentType = TimeoutType.IDLE_TIMEOUT
- // 重置声纹状态
- resetSpeakerVerifyState()
-
state = VoiceState.WAIT_WAKEUP
}
- // 声纹状态重置（统一方法，修复：彻底清空所有标记）
- private fun resetSpeakerVerifyState() {
- speakerVerifyState.job?.cancel()
- speakerVerifyState.job = null
- speakerVerifyState.finished = false
- speakerVerifyState.passed = true
- speakerVerifyState.failed = false
- }
-
/* ================= 资源管理（优化：关闭自定义线程池） ================= */
fun release() {
LogUtils.d(TAG, "🔌 释放资源")
@@ -634,7 +531,6 @@ class VoiceController(
// 重置状态
timeoutState.hasInvalidSpeech = false
timeoutState.currentType = TimeoutType.IDLE_TIMEOUT
- resetSpeakerVerifyState()
try {
SpeakerRecognition.extractor.release()
diff --git a/app/src/main/java/com/zs/smarthuman/sherpa/WakeupManager.kt b/app/src/main/java/com/zs/smarthuman/sherpa/WakeupManager.kt
index 4dbb9ac..3f8a07b 100644
--- a/app/src/main/java/com/zs/smarthuman/sherpa/WakeupManager.kt
+++ b/app/src/main/java/com/zs/smarthuman/sherpa/WakeupManager.kt
@@ -35,7 +35,7 @@ class WakeupManager(assetManager: AssetManager, function: () -> Unit) {
featConfig = featConfig,
modelConfig = modelConfig,
keywordsFile = keywordsFile,
- keywordsThreshold = 0.1f
+ keywordsThreshold = 0.06f
)
kws = KeywordSpotter(assetManager, config)
@@ -49,11 +49,8 @@ class WakeupManager(assetManager: AssetManager, function: () -> Unit) {
/** ⭐ 永远喂 KWS */
fun acceptAudio(samples: FloatArray) {
val s = stream ?: return
- for (i in samples.indices) {
- samples[i] *= 2.5f
- }
s.acceptWaveform(samples, sampleRate)
-
+ normalize(samples)
while (kws.isReady(s)) {
kws.decode(s)
val keyword = kws.getResult(s).keyword
@@ -73,6 +70,18 @@ class WakeupManager(assetManager: AssetManager, function: () -> Unit) {
return r
}
+ private fun normalize(samples: FloatArray, targetRms: Float = 0.05f) {
+ var sum = 0.0
+ for (s in samples) sum += s * s
+ val rms = kotlin.math.sqrt(sum / samples.size)
+ if (rms < 1e-6) return
+ val gain = targetRms / rms
+ for (i in samples.indices) {
+ samples[i] = (samples[i] * gain).coerceIn(-1.0, 1.0).toFloat()
+ }
+ }
+
+
fun reset() {
stream?.let { kws.reset(it) }
justWokeUp = false
diff --git a/app/src/main/java/com/zs/smarthuman/utils/OpusDecoder.kt b/app/src/main/java/com/zs/smarthuman/utils/OpusDecoder.kt
new file mode 100644
index 0000000..b994e46
--- /dev/null
+++ b/app/src/main/java/com/zs/smarthuman/utils/OpusDecoder.kt
@@ -0,0 +1,76 @@
+package com.zs.smarthuman.utils;
+
+import android.util.Log
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+class OpusDecoder(
+ private val sampleRate: Int,
+ private val channels: Int,
+ frameSizeMs: Int
+) {
+ companion object {
+ private const val TAG = "OpusDecoder"
+
+ init {
+ System.loadLibrary("app")
+ }
+ }
+
+ private var nativeDecoderHandle: Long = 0
+ private val frameSize: Int = (sampleRate * frameSizeMs) / 1000
+
+ init {
+ nativeDecoderHandle = nativeInitDecoder(sampleRate, channels)
+ if (nativeDecoderHandle == 0L) {
+ throw IllegalStateException("Failed to initialize Opus decoder")
+ }
+ }
+
+ // 使用协程进行解码，运行在 IO 线程
+ suspend fun decode(opusData: ByteArray): ByteArray? = withContext(Dispatchers.IO) {
+ val maxPcmSize = frameSize * channels * 2 // 16-bit PCM
+ val pcmBuffer = ByteArray(maxPcmSize)
+
+ val decodedBytes = nativeDecodeBytes(
+ nativeDecoderHandle,
+ opusData,
+ opusData.size,
+ pcmBuffer,
+ maxPcmSize
+ )
+
+ if (decodedBytes > 0) {
+ if (decodedBytes < pcmBuffer.size) {
+ pcmBuffer.copyOf(decodedBytes)
+ } else {
+ pcmBuffer
+ }
+ } else {
+ Log.e(TAG, "Failed to decode frame")
+ null
+ }
+ }
+
+ fun release() {
+ if (nativeDecoderHandle != 0L) {
+ nativeReleaseDecoder(nativeDecoderHandle)
+ nativeDecoderHandle = 0
+ }
+ }
+
+ protected fun finalize() {
+ release()
+ }
+
+ private external fun nativeInitDecoder(sampleRate: Int, channels: Int): Long
+ private external fun nativeDecodeBytes(
+ decoderHandle: Long,
+ inputBuffer: ByteArray,
+ inputSize: Int,
+ outputBuffer: ByteArray,
+ maxOutputSize: Int
+ ): Int
+
+ private external fun nativeReleaseDecoder(decoderHandle: Long)
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/zs/smarthuman/utils/OpusEncoder.kt b/app/src/main/java/com/zs/smarthuman/utils/OpusEncoder.kt
new file mode 100644
index 0000000..9ab1105
--- /dev/null
+++ b/app/src/main/java/com/zs/smarthuman/utils/OpusEncoder.kt
@@ -0,0 +1,75 @@
+package com.zs.smarthuman.utils;
+
+import android.util.Log
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+class OpusEncoder(
+ private val sampleRate: Int,
+ private val channels: Int,
+ frameSizeMs: Int
+) {
+ companion object {
+ private const val TAG = "OpusEncoder"
+
+ init {
+ System.loadLibrary("app")
+ }
+ }
+
+ private var nativeEncoderHandle: Long = 0
+ private val frameSize: Int = (sampleRate * frameSizeMs) / 1000
+
+ init {
+ nativeEncoderHandle = nativeInitEncoder(sampleRate, channels, 2048) // OPUS_APPLICATION_VOIP
+ if (nativeEncoderHandle == 0L) {
+ throw IllegalStateException("Failed to initialize Opus encoder")
+ }
+ }
+
+ suspend fun encode(pcmData: ByteArray): ByteArray? = withContext(Dispatchers.IO) {
+ val frameBytes = frameSize * channels * 2 // 16-bit PCM
+ if (pcmData.size != frameBytes) {
+ Log.e(TAG, "Input buffer size must be $frameBytes bytes (got ${pcmData.size})")
+ return@withContext null
+ }
+
+ val outputBuffer = ByteArray(frameBytes) // 分配足够大的缓冲区
+ val encodedBytes = nativeEncodeBytes(
+ nativeEncoderHandle,
+ pcmData,
+ pcmData.size,
+ outputBuffer,
+ outputBuffer.size
+ )
+
+ if (encodedBytes > 0) {
+ outputBuffer.copyOf(encodedBytes)
+ } else {
+ Log.e(TAG, "Failed to encode frame")
+ null
+ }
+ }
+
+ fun release() {
+ if (nativeEncoderHandle != 0L) {
+ nativeReleaseEncoder(nativeEncoderHandle)
+ nativeEncoderHandle = 0
+ }
+ }
+
+ protected fun finalize() {
+ release()
+ }
+
+ private external fun nativeInitEncoder(sampleRate: Int, channels: Int, application: Int): Long
+ private external fun nativeEncodeBytes(
+ encoderHandle: Long,
+ inputBuffer: ByteArray,
+ inputSize: Int,
+ outputBuffer: ByteArray,
+ maxOutputSize: Int
+ ): Int
+
+ private external fun nativeReleaseEncoder(encoderHandle: Long)
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/zs/smarthuman/websocket/WebsocketProtocol.kt b/app/src/main/java/com/zs/smarthuman/websocket/WebsocketProtocol.kt
new file mode 100644
index 0000000..2263533
--- /dev/null
+++ b/app/src/main/java/com/zs/smarthuman/websocket/WebsocketProtocol.kt
@@ -0,0 +1,459 @@
+package com.zs.smarthuman.websocket
+
+import com.blankj.utilcode.util.LogUtils
+import com.blankj.utilcode.util.NetworkUtils
+import com.zs.smarthuman.common.UserInfoManager
+import com.zs.smarthuman.utils.AESUtils
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.MutableSharedFlow
+import okhttp3.*
+import okio.ByteString
+import org.json.JSONObject
+import java.util.UUID
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.concurrent.locks.ReentrantLock
+import kotlin.concurrent.withLock
+
+class WebsocketProtocol private constructor() {
+ companion object {
+ // 日志TAG
+ private const val TAG = "WS"
+ // WebSocket服务地址
+ private const val WS_URL = "ws://10.10.4.132:9001/aidialogue"
+
+ // 重连配置
+ private const val RECONNECT_DELAY = 3_000L // 重连基础延迟
+ private const val MAX_RECONNECT_COUNT = -1 // -1表示无限重连
+ private const val NETWORK_CHECK_INTERVAL = 5_000L // 网络检测间隔
+
+ // 线程安全的单例实现
+ val INSTANCE: WebsocketProtocol by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
+ WebsocketProtocol()
+ }
+ }
+
+ // 公开Flow
+ val incomingJsonFlow = MutableSharedFlow(replay = 0)
+ val incomingByteArrayFlow = MutableSharedFlow(replay = 0)
+ val networkErrorFlow = MutableSharedFlow(replay = 0)
+
+ // 公开属性
+ var sessionId: String = "your_session_id"
+
+ // 线程安全状态标记（核心：所有标记都要闭环管理）
+ private val isOpen = AtomicBoolean(false) // 连接是否已打开
+ private val isAuthSuccess = AtomicBoolean(false) // 认证是否成功
+ private val reconnectCount = AtomicInteger(0) // 重连次数
+ private val isReconnecting = AtomicBoolean(false) // 是否正在重连（核心标记）
+ private val isOpening = AtomicBoolean(false) // 是否正在执行打开操作
+ private val connectLock = ReentrantLock() // 连接操作锁
+
+ // 协程作用域
+ private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob() + CoroutineName("WS-Scope"))
+
+ // WebSocket实例（volatile保证可见性）
+ @Volatile
+ private var websocket: WebSocket? = null
+
+ // OkHttp客户端
+ private val client by lazy {
+ OkHttpClient.Builder()
+ .connectTimeout(10, TimeUnit.SECONDS)
+ .readTimeout(10, TimeUnit.SECONDS)
+ .writeTimeout(10, TimeUnit.SECONDS)
+ .pingInterval(3, TimeUnit.SECONDS)
+ .retryOnConnectionFailure(false)
+ .build()
+ }
+
+ /**
+ * 发送音频数据
+ */
+ fun sendAudio(data: ByteArray) {
+ scope.launch {
+ runCatching {
+ LogUtils.i(TAG, "Sending audio: ${data.size} bytes")
+ if (isOpen.get() && isAuthSuccess.get() && websocket != null) {
+ websocket?.send(ByteString.of(*data))
+ } else {
+ val errorMsg = "WebSocket not ready (open:${isOpen.get()}, auth:${isAuthSuccess.get()})"
+ LogUtils.eTag(TAG, errorMsg)
+ networkErrorFlow.emit(errorMsg)
+ launchReconnect()
+ }
+ }.onFailure { e ->
+ LogUtils.eTag(TAG, "Send audio failed: ${e.message}", e)
+ networkErrorFlow.emit("Send audio error: ${e.message}")
+ }
+ }
+ }
+
+ /**
+ * 发送文本数据
+ */
+ fun sendText(text: String) {
+ scope.launch {
+ runCatching {
+ LogUtils.i(TAG, "Sending text: $text")
+ if (isOpen.get() && isAuthSuccess.get() && websocket != null) {
+ websocket?.send(text)
+ } else {
+ val errorMsg = "WebSocket not ready (open:${isOpen.get()}, auth:${isAuthSuccess.get()})"
+ LogUtils.eTag(TAG, errorMsg)
+ networkErrorFlow.emit(errorMsg)
+ launchReconnect()
+ }
+ }.onFailure { e ->
+ LogUtils.eTag(TAG, "Send text failed: ${e.message}", e)
+ networkErrorFlow.emit("Send text error: ${e.message}")
+ }
+ }
+ }
+
+ /**
+ * 判断通道是否就绪
+ */
+ fun isAudioChannelOpened(): Boolean {
+ return websocket != null && isOpen.get() && isAuthSuccess.get()
+ }
+
+ /**
+ * 关闭通道
+ */
+ fun closeAudioChannel() {
+ scope.launch {
+ connectLock.withLock {
+ LogUtils.iTag(TAG, "Close audio channel")
+ isOpen.set(false)
+ isAuthSuccess.set(false)
+ reconnectCount.set(0)
+ isReconnecting.set(false) // 关闭时重置重连标记
+ isOpening.set(false) // 关闭时重置打开标记
+
+ val ws = websocket
+ websocket = null
+ ws?.close(1000, "Normal closure")
+ }
+ }
+ }
+
+ /**
+ * 打开通道（核心修复：标记闭环）
+ */
+ suspend fun openAudioChannel(): Boolean = withContext(Dispatchers.IO) {
+ // 1. 防并发：只有未打开时才执行
+ if (!isOpening.compareAndSet(false, true)) {
+ LogUtils.wTag(TAG, "openAudioChannel is running, skip")
+ return@withContext false
+ }
+
+ var result = false
+ connectLock.withLock {
+ try {
+ // 2. 如果已有连接，直接返回成功并重置标记
+ if (websocket != null && isOpen.get()) {
+ LogUtils.iTag(TAG, "WebSocket already connected, skip open")
+ result = true
+ isReconnecting.set(false) // 关键：重置重连标记
+ return@withContext result
+ }
+
+ // 3. 检查网络
+ if (!NetworkUtils.isConnected()) {
+ val errorMsg = "Network disconnected, can't connect WebSocket"
+ LogUtils.eTag(TAG, errorMsg)
+ scope.launch {
+ networkErrorFlow.emit(errorMsg)
+ }
+ result = false
+ return@withContext result
+ }
+
+ // 4. 创建新连接（核心：先创建再赋值）
+ val request = Request.Builder().url(WS_URL).build()
+ val newWs = client.newWebSocket(request, createWebSocketListener())
+ websocket = newWs
+ LogUtils.iTag(TAG, "WebSocket connecting to: $WS_URL")
+ result = true
+ isReconnecting.set(false) // 关键：发起连接后重置重连标记
+
+ } catch (e: Exception) {
+ val errorMsg = "Create WebSocket failed: ${e.message}"
+ LogUtils.eTag(TAG, errorMsg, e)
+ scope.launch {
+ networkErrorFlow.emit(errorMsg)
+ }
+ websocket = null
+ result = false
+
+ } finally {
+ isOpening.set(false) // 无论成败，最终重置打开标记
+ }
+ }
+ return@withContext result
+ }
+
+ /**
+ * 创建WebSocket监听器
+ */
+ private fun createWebSocketListener(): WebSocketListener {
+ return object : WebSocketListener() {
+ override fun onOpen(webSocket: WebSocket, response: Response) {
+ connectLock.withLock {
+ if (websocket === webSocket) {
+ LogUtils.iTag(TAG, "✅ WebSocket connected, start auth")
+ isOpen.set(true)
+ isAuthSuccess.set(false)
+ reconnectCount.set(0) // 连接成功重置重连次数
+ isReconnecting.set(false) // 关键：连接成功重置重连标记
+ sendAuthMessage(webSocket)
+ } else {
+ LogUtils.wTag(TAG, "Ignore onOpen for old WebSocket")
+ webSocket.close(1001, "New connection exists")
+ }
+ }
+ }
+
+ override fun onMessage(webSocket: WebSocket, text: String) {
+ if (websocket !== webSocket) {
+ LogUtils.wTag(TAG, "Ignore text message for old WebSocket")
+ return
+ }
+
+ LogUtils.iTag(TAG, "📩 Receive text: $text")
+ scope.launch {
+ runCatching {
+ val json = JSONObject(text)
+ when (json.optInt("msgContentType")) {
+ WebsocketType.AUTH.code -> parseAuthResponse(json)
+ WebsocketType.HEARTBEAT.code -> sendHeartbeat()
+ else -> incomingJsonFlow.emit(json)
+ }
+ }.onFailure { e ->
+ val errorMsg = "Parse text message error: ${e.message}"
+ LogUtils.eTag(TAG, errorMsg, e)
+ networkErrorFlow.emit(errorMsg)
+ }
+ }
+ }
+
+ override fun onMessage(webSocket: WebSocket, bytes: ByteString) {
+ if (websocket !== webSocket) {
+ LogUtils.wTag(TAG, "Ignore binary message for old WebSocket")
+ return
+ }
+
+ val size = bytes.size
+ LogUtils.iTag(TAG, "📩 Receive binary: $size bytes")
+ if (isAuthSuccess.get()) {
+ scope.launch { incomingByteArrayFlow.emit(bytes.toByteArray()) }
+ }
+ }
+
+ override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
+ connectLock.withLock {
+ if (websocket === webSocket) {
+ LogUtils.wTag(TAG, "🔌 WebSocket closed: $code, reason: $reason")
+ isOpen.set(false)
+ isAuthSuccess.set(false)
+ websocket = null
+ isReconnecting.set(false) // 关闭时重置重连标记
+ } else {
+ LogUtils.wTag(TAG, "Ignore onClosed for old WebSocket")
+ }
+ }
+
+ // 非主动关闭才重连
+ val isNormalClose = code == 1000 && reason == "Normal closure"
+ if (!isNormalClose) {
+ launchReconnect()
+ }
+ }
+
+ override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
+ connectLock.withLock {
+ if (websocket === webSocket) {
+ LogUtils.eTag(TAG, "❌ WebSocket failure: ${t.message}", t)
+ isOpen.set(false)
+ isAuthSuccess.set(false)
+ websocket = null
+ } else {
+ LogUtils.wTag(TAG, "Ignore onFailure for old WebSocket")
+ }
+ }
+
+ scope.launch {
+ networkErrorFlow.emit(t.message ?: "Unknown WebSocket error")
+ }
+ launchReconnect()
+ }
+ }
+ }
+
+ /**
+ * 发送认证消息
+ */
+ private fun sendAuthMessage(webSocket: WebSocket) {
+ if (websocket !== webSocket) {
+ LogUtils.wTag(TAG, "Ignore auth for old WebSocket")
+ return
+ }
+
+ scope.launch {
+ runCatching {
+ val authData = JSONObject().apply {
+ put("unionId", AESUtils.encrypt(UserInfoManager.sn))
+ }
+ val authMsg = buildWsMessage(WebsocketType.AUTH, authData)
+ LogUtils.iTag(TAG, "🔑 Send auth: $authMsg")
+ webSocket.send(authMsg.toString())
+ }.onFailure { e ->
+ val errorMsg = "Send auth failed: ${e.message}"
+ LogUtils.eTag(TAG, errorMsg, e)
+ networkErrorFlow.emit(errorMsg)
+ }
+ }
+ }
+
+ /**
+ * 发送心跳
+ */
+ private fun sendHeartbeat() {
+ scope.launch {
+ runCatching {
+ val heartbeatMsg = buildWsMessage(WebsocketType.HEARTBEAT, "pong")
+ LogUtils.iTag(TAG, "💓 Send heartbeat: $heartbeatMsg")
+ sendText(heartbeatMsg.toString())
+ }.onFailure { e ->
+ val errorMsg = "Send heartbeat failed: ${e.message}"
+ LogUtils.eTag(TAG, errorMsg, e)
+ networkErrorFlow.emit(errorMsg)
+ }
+ }
+ }
+
+ /**
+ * 构建通用消息
+ */
+ private fun buildWsMessage(type: WebsocketType, data: Any): JSONObject {
+ return JSONObject().apply {
+ put("msgContentType", type.code)
+ put("timeStamp", System.currentTimeMillis())
+ put("msgId", UUID.randomUUID().toString())
+ put("data", data)
+ }
+ }
+
+ /**
+ * 解析认证响应
+ */
+ private fun parseAuthResponse(root: JSONObject) {
+ scope.launch {
+ runCatching {
+ val dataObj = root.optJSONObject("data")
+ ?: throw IllegalArgumentException("Auth response missing 'data' field")
+
+ val code = dataObj.optInt("code")
+ val msg = dataObj.optString("msg")
+ val authResult = dataObj.optString("data")
+
+ if (code == 200 && authResult == "WS_AUTH_SUCCESS") {
+ isAuthSuccess.set(true)
+ LogUtils.iTag(TAG, "✅ Auth success")
+ } else {
+ isAuthSuccess.set(false)
+ val errorMsg = "Auth failed: $msg (code:$code)"
+ LogUtils.eTag(TAG, errorMsg)
+ networkErrorFlow.emit(errorMsg)
+ launchReconnect()
+ }
+ }.onFailure { e ->
+ isAuthSuccess.set(false)
+ val errorMsg = "Parse auth response error: ${e.message}"
+ LogUtils.eTag(TAG, errorMsg, e)
+ networkErrorFlow.emit(errorMsg)
+ launchReconnect()
+ }
+ }
+ }
+
+ /**
+ * 核心修复：重连逻辑（标记闭环管理）
+ */
+ private fun launchReconnect() {
+ // 1. 防止重复进入重连
+ if (!isReconnecting.compareAndSet(false, true)) {
+ LogUtils.wTag(TAG, "Already reconnecting, skip launchReconnect")
+ return
+ }
+
+ // 2. 协程执行重连
+ scope.launch(Dispatchers.IO) {
+ try {
+ // 循环重连直到成功/达到最大次数
+ while (true) {
+ // 检查最大重连次数
+ if (MAX_RECONNECT_COUNT != -1 && reconnectCount.get() >= MAX_RECONNECT_COUNT) {
+ val errorMsg = "Reach max reconnect count: $MAX_RECONNECT_COUNT"
+ LogUtils.eTag(TAG, errorMsg)
+ networkErrorFlow.emit(errorMsg)
+ break
+ }
+
+ val currentCount = reconnectCount.incrementAndGet()
+ LogUtils.wTag(TAG, "🔄 Reconnect attempt: $currentCount, delay: ${RECONNECT_DELAY}ms")
+
+ // 等待重连延迟
+ delay(RECONNECT_DELAY)
+
+ // 检查网络
+ if (!NetworkUtils.isConnected()) {
+ LogUtils.wTag(TAG, "🔌 Network disconnected, wait ${NETWORK_CHECK_INTERVAL}ms")
+ delay(NETWORK_CHECK_INTERVAL)
+ continue // 网络未恢复，继续循环
+ }
+
+ // 网络恢复，尝试连接
+ LogUtils.iTag(TAG, "🔌 Network available, try to connect")
+ val connectSuccess = openAudioChannel()
+
+ // 连接成功则退出循环
+ if (connectSuccess) {
+ LogUtils.iTag(TAG, "✅ Reconnect success")
+ break
+ }
+
+ // 连接失败，继续循环
+ LogUtils.wTag(TAG, "❌ Reconnect attempt $currentCount failed")
+ }
+ } catch (e: Exception) {
+ LogUtils.eTag(TAG, "Reconnect loop error: ${e.message}", e)
+ networkErrorFlow.emit("Reconnect error: ${e.message}")
+ } finally {
+ // 最终必须重置重连标记（核心修复）
+ isReconnecting.set(false)
+ LogUtils.iTag(TAG, "Reconnect loop finished, reset isReconnecting to false")
+ }
+ }
+ }
+
+ /**
+ * 释放资源
+ */
+ fun dispose() {
+ LogUtils.iTag(TAG, "🗑️ Dispose WebSocketProtocol")
+ scope.cancel("Dispose called")
+
+ connectLock.withLock {
+ closeAudioChannel()
+ websocket = null
+ isReconnecting.set(false)
+ isOpening.set(false)
+ }
+
+ client.dispatcher.executorService.shutdown()
+ client.connectionPool.evictAll()
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/zs/smarthuman/websocket/WebsocketType.kt b/app/src/main/java/com/zs/smarthuman/websocket/WebsocketType.kt
new file mode 100644
index 0000000..038455a
--- /dev/null
+++ b/app/src/main/java/com/zs/smarthuman/websocket/WebsocketType.kt
@@ -0,0 +1,11 @@
+package com.zs.smarthuman.websocket
+
+/**
+ * @description:
+ * @author: lrs
+ * @date: 2026/2/10 18:59
+ */
+enum class WebsocketType(val code: Int) {
+ AUTH(1001),
+ HEARTBEAT(1002);
+}
\ No newline at end of file
diff --git a/app/src/main/jniLibs/arm64-v8a/libopus.so b/app/src/main/jniLibs/arm64-v8a/libopus.so
new file mode 100644
index 0000000000000000000000000000000000000000..c71519fbc8f489e3b4a23a9c852ede02830e2084
GIT binary patch
literal 415496
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