tirtc-devtools-cli 0.0.1

package/vendor/app-server/bin/runtime/macos-arm64/include/tirtc/audio.h

@@ -0,0 +1,398 @@
+#ifndef TIRTC_FACADE_AUDIO_H_
+#define TIRTC_FACADE_AUDIO_H_
+
+#include "tirtc/audio_io.h"
+#include "tirtc/audio_processing.h"
+#include "tirtc/trp.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @file tirtc/audio.h
+ * @brief Audio facade layer built on top of `tirtc/trp.h`.
+ *
+ * This header adds local audio capture and remote audio playback objects to the
+ * transport-facing facade.
+ *
+ * Typical uplink flow:
+ * 1. Create a ::TirtcAudioInput.
+ * 2. Bind a concrete capture backend with ::tirtc_audio_input_set_ain.
+ * 3. Optionally configure processing options and an observer.
+ * 4. Start the input and attach it to a connection stream.
+ * 5. Detach, stop, and destroy the input during shutdown.
+ *
+ * Typical downlink flow:
+ * 1. Create a ::TirtcAudioOutput.
+ * 2. Bind a concrete playback backend with ::tirtc_audio_output_set_aout.
+ * 3. Optionally configure playback options and an observer.
+ * 4. Attach the output to a connected ::TirtcConn.
+ * 5. Detach and destroy the output during shutdown.
+ *
+ * Ownership model:
+ * - The caller owns all audio input and output handles.
+ * - Attaching an object to a connection is a non-owning bind.
+ * - Destroying a connection detaches bound audio objects but does not destroy
+ *   them.
+ */
+
+/** @brief Opaque audio uplink handle. */
+typedef struct TirtcAudioInput TirtcAudioInput;
+
+/** @brief Opaque audio downlink handle. */
+typedef struct TirtcAudioOutput TirtcAudioOutput;
+
+/**
+ * @brief Generic input state used by audio and video input observers.
+ *
+ * The current facade implementation primarily reports RUNNING and STOPPED.
+ * Callers should still handle the full enum for forward compatibility.
+ */
+typedef enum TirtcInputState {
+  /** Input exists but has not started running yet. */
+  TIRTC_INPUT_STATE_IDLE = 0,
+
+  /** Input is actively capturing or producing data. */
+  TIRTC_INPUT_STATE_RUNNING = 1,
+
+  /** Reserved paused state. */
+  TIRTC_INPUT_STATE_PAUSED = 2,
+
+  /** Input is stopped. */
+  TIRTC_INPUT_STATE_STOPPED = 3,
+
+  /** Reserved terminal failure state. */
+  TIRTC_INPUT_STATE_FAILED = 4,
+} TirtcInputState;
+
+/**
+ * @brief Audio output state reported through ::TirtcAudioOutputObserver.
+ */
+typedef enum TirtcAudioOutputState {
+  /** Output is attached but not currently rendering audio. */
+  TIRTC_AUDIO_OUTPUT_STATE_IDLE = 0,
+
+  /** Output is actively playing remote audio. */
+  TIRTC_AUDIO_OUTPUT_STATE_PLAYING = 1,
+
+  /** Output is waiting for enough decoded audio to continue playback. */
+  TIRTC_AUDIO_OUTPUT_STATE_BUFFERING = 2,
+
+  /** Reserved paused state. */
+  TIRTC_AUDIO_OUTPUT_STATE_PAUSED = 3,
+
+  /** Reserved completed state. */
+  TIRTC_AUDIO_OUTPUT_STATE_COMPLETED = 4,
+
+  /** Output encountered repeated playback failures. */
+  TIRTC_AUDIO_OUTPUT_STATE_FAILED = 5,
+} TirtcAudioOutputState;
+
+/**
+ * @brief Audio input processing options.
+ *
+ * These options are consumed when the internal uplink pipeline is created.
+ * Configure them before the first successful start for predictable behavior.
+ */
+typedef struct TirtcAudioInputOptions {
+  /**
+   * @brief Capture sample rate.
+   *
+   * The current implementation defaults to 16 kHz when this field is set to
+   * ::TIRTC_AUDIO_SAMPLE_RATE_NONE.
+   */
+  TirtcAudioSampleRate sample_rate;
+
+  /** @brief Acoustic echo cancellation mode. */
+  TirtcAudioAecMode aec_mode;
+
+  /** @brief Automatic gain control level. */
+  TirtcAudioAgcLevel agc_level;
+
+  /** @brief Acoustic noise suppression level. */
+  TirtcAudioAnsLevel ans_level;
+} TirtcAudioInputOptions;
+
+/**
+ * @brief Audio output playback options.
+ *
+ * Configure these options before attaching the output to a connection. The
+ * current API does not support updating them while the output remains bound.
+ */
+typedef struct TirtcAudioOutputOptions {
+  /**
+   * @brief Playback volume in percent.
+   *
+   * The current implementation treats `0` as the default `100` percent.
+   */
+  uint32_t volume_percent;
+
+  /** @brief Additional gain level forwarded to the downlink pipeline. */
+  int gain_level;
+
+  /** @brief Additional noise-reduction level forwarded to the downlink pipeline. */
+  int noise_reduction_level;
+} TirtcAudioOutputOptions;
+
+/**
+ * @brief Optional observer for an audio input object.
+ *
+ * The implementation stores a copy of this structure. Installing or replacing
+ * an observer does not replay prior state; callbacks describe subsequent local
+ * start and stop transitions.
+ *
+ * Callback delivery is not guaranteed to be on a fixed thread. In the current
+ * implementation, input state notifications may be dispatched synchronously by
+ * API calls such as ::tirtc_audio_input_start and ::tirtc_audio_input_stop.
+ * Callers must therefore make callback logic safe for reentrant delivery.
+ */
+typedef struct TirtcAudioInputObserver {
+  /**
+   * @brief Called when the input starts or stops.
+   *
+   * In the current implementation, a start failure is reported as STOPPED with
+   * a non-OK ::error value.
+   */
+  void (*on_state_changed)(TirtcAudioInput* input, TirtcInputState state, TirtcError error,
+                           void* user_data);
+} TirtcAudioInputObserver;
+
+/**
+ * @brief Optional observer for an audio output object.
+ *
+ * The implementation stores a copy of this structure. Installing or replacing
+ * an observer does not replay the current output state.
+ *
+ * Callback delivery is not guaranteed to be on a fixed thread. State changes
+ * may be reported synchronously by attach or detach paths, or asynchronously
+ * from the internal downlink pipeline. Callers must therefore make callback
+ * logic safe for reentrant delivery and perform their own thread handoff when
+ * thread affinity is required.
+ */
+typedef struct TirtcAudioOutputObserver {
+  /**
+   * @brief Called when the output state changes.
+   *
+   * A common sequence is IDLE after attach, then BUFFERING, then PLAYING, and
+   * IDLE again after detach.
+   * Repeated downlink failures may eventually promote the output to FAILED.
+   */
+  void (*on_state_changed)(TirtcAudioOutput* output, TirtcAudioOutputState state, TirtcError error,
+                           void* user_data);
+} TirtcAudioOutputObserver;
+
+/**
+ * @brief Attach an audio input to a connection stream.
+ *
+ * This bind is non-owning. The same input cannot be attached to more than one
+ * connection at a time. The selected ::stream_id must be unique across all
+ * audio inputs, video inputs, and video outputs currently attached to the same
+ * connection.
+ *
+ * The input may be attached before or after ::tirtc_audio_input_start. Audio
+ * is actually sent only while the input is both attached and running.
+ *
+ * @param connection Target connection.
+ * @param stream_id Stream identifier that will carry this audio route.
+ * @param input Audio input to bind.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_conn_attach_audio_input(TirtcConn* connection, uint8_t stream_id,
+                                         TirtcAudioInput* input);
+
+/**
+ * @brief Attach a remote audio output to a connection stream.
+ *
+ * This bind is non-owning. The same output cannot be attached to more than
+ * one connection stream at a time. Configure the output with
+ * ::tirtc_audio_output_set_aout and any desired options before attaching it.
+ *
+ * If an observer is already installed, a successful attach typically reports an
+ * initial IDLE state before playback begins. A successful attach also asks the
+ * remote peer to start sending audio for this ::stream_id on this connection.
+ *
+ * @param connection Target connection.
+ * @param stream_id Remote audio stream identifier to render.
+ * @param output Audio output to bind.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_conn_attach_audio_output(TirtcConn* connection, uint8_t stream_id,
+                                          TirtcAudioOutput* output);
+
+/**
+ * @brief Detach an audio input from a connection stream.
+ *
+ * This call is idempotent. If the stream is attached, the internal uplink path
+ * for that bind is stopped and the input returns to an unbound state.
+ *
+ * @param connection Target connection.
+ * @param stream_id Stream identifier to detach.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_conn_detach_audio_input(TirtcConn* connection, uint8_t stream_id);
+
+/**
+ * @brief Detach an audio output from a connection stream.
+ *
+ * This call is idempotent. A successful detach also asks the remote peer to
+ * stop sending audio for this ::stream_id on this connection.
+ *
+ * @param connection Target connection.
+ * @param stream_id Stream identifier to detach.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_conn_detach_audio_output(TirtcConn* connection, uint8_t stream_id);
+
+/**
+ * @brief Create an audio input object.
+ *
+ * The runtime must already be initialized.
+ *
+ * @param out_input Receives the created input handle on success.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_audio_input_create(TirtcAudioInput** out_input);
+
+/**
+ * @brief Destroy an audio input object.
+ *
+ * The input must already be detached from any connection. If the input is
+ * still bound, the current implementation keeps it alive and ignores the
+ * destroy request.
+ *
+ * @param input Input handle to destroy.
+ */
+void tirtc_audio_input_destroy(TirtcAudioInput* input);
+
+/**
+ * @brief Bind a concrete audio capture backend to an input object.
+ *
+ * This must be done while the input is stopped and detached, before the next
+ * successful start. The backend pointer is non-owning and must remain valid
+ * while the input may still use it.
+ *
+ * @param input Target audio input.
+ * @param ain Capture backend to bind.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_audio_input_set_ain(TirtcAudioInput* input, TirtcAudioAin* ain);
+
+/**
+ * @brief Store audio input processing options.
+ *
+ * Best practice is to call this before the first successful start. Updating
+ * options after the internal uplink pipeline has already been created does not
+ * retroactively rebuild that running pipeline.
+ *
+ * @param input Target audio input.
+ * @param options Options to copy into the facade object.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_audio_input_set_options(TirtcAudioInput* input,
+                                         const TirtcAudioInputOptions* options);
+
+/**
+ * @brief Install, replace, or clear the audio input observer.
+ *
+ * Passing NULL for ::observer clears the current observer. The implementation
+ * stores a copy of the observer structure and does not require it to outlive
+ * this call.
+ *
+ * @param input Target audio input.
+ * @param observer Observer to install, or NULL to clear.
+ * @param user_data Opaque pointer returned to observer callbacks.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_audio_input_set_observer(TirtcAudioInput* input,
+                                          const TirtcAudioInputObserver* observer, void* user_data);
+
+/**
+ * @brief Start local audio capture for an input object.
+ *
+ * A capture backend must already be bound with ::tirtc_audio_input_set_ain.
+ * Starting twice without an intervening stop is rejected.
+ *
+ * @param input Target audio input.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_audio_input_start(TirtcAudioInput* input);
+
+/**
+ * @brief Stop local audio capture for an input object.
+ *
+ * This is the normal pairing call for ::tirtc_audio_input_start. The current
+ * implementation also tolerates stopping an already stopped input.
+ *
+ * @param input Target audio input.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_audio_input_stop(TirtcAudioInput* input);
+
+/**
+ * @brief Create an audio output object.
+ *
+ * The runtime must already be initialized.
+ *
+ * @param out_output Receives the created output handle on success.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_audio_output_create(TirtcAudioOutput** out_output);
+
+/**
+ * @brief Destroy an audio output object.
+ *
+ * The output must already be detached from any connection. If it is still
+ * bound, the current implementation keeps it alive and ignores the destroy
+ * request.
+ *
+ * @param output Output handle to destroy.
+ */
+void tirtc_audio_output_destroy(TirtcAudioOutput* output);
+
+/**
+ * @brief Bind a concrete audio playback backend to an output object.
+ *
+ * The backend pointer is non-owning and should remain valid until the output
+ * has been detached and destroyed. Passing NULL is not supported by this API.
+ *
+ * @param output Target audio output.
+ * @param aout Playback backend to bind.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_audio_output_set_aout(TirtcAudioOutput* output, TirtcAudioAout* aout);
+
+/**
+ * @brief Store audio output playback options.
+ *
+ * This call is intended for the pre-attach configuration phase. The current
+ * implementation rejects option changes while the output is attached.
+ *
+ * @param output Target audio output.
+ * @param options Options to copy into the facade object.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_audio_output_set_options(TirtcAudioOutput* output,
+                                          const TirtcAudioOutputOptions* options);
+
+/**
+ * @brief Install, replace, or clear the audio output observer.
+ *
+ * Passing NULL for ::observer clears the current observer. The implementation
+ * stores a copy of the observer structure and does not require it to outlive
+ * this call.
+ *
+ * @param output Target audio output.
+ * @param observer Observer to install, or NULL to clear.
+ * @param user_data Opaque pointer returned to observer callbacks.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_audio_output_set_observer(TirtcAudioOutput* output,
+                                           const TirtcAudioOutputObserver* observer,
+                                           void* user_data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_FACADE_AUDIO_H_

package/vendor/app-server/bin/runtime/macos-arm64/include/tirtc/audio_codec.h

@@ -0,0 +1,23 @@
+#ifndef TIRTC_AUDIO_CODEC_H_
+#define TIRTC_AUDIO_CODEC_H_
+
+#include <stddef.h>
+
+#include "tirtc/audio_frame.h"
+#include "tirtc/error.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+TirtcError tirtc_audio_g711a_encode(const TirtcAudioPcmFrame* pcm_frame, void* out_buffer,
+                                    size_t out_buffer_capacity, TirtcAudioEncodedFrame* out_frame);
+
+TirtcError tirtc_audio_g711a_decode(const TirtcAudioEncodedFrame* in_frame, void* out_buffer,
+                                    size_t out_buffer_capacity, TirtcAudioPcmFrame* out_frame);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_AUDIO_CODEC_H_

package/vendor/app-server/bin/runtime/macos-arm64/include/tirtc/audio_frame.h

@@ -0,0 +1,36 @@
+#ifndef TIRTC_AUDIO_FRAME_H_
+#define TIRTC_AUDIO_FRAME_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "tirtc/audio_sample_rate.h"
+#include "tirtc/media_codec.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct TirtcAudioPcmFrame {
+  TirtcAudioSampleRate sample_rate;
+  uint32_t samples_per_channel;
+  int64_t pts_us;
+  /* Mutable PCM payload for capture, processing, and render-fill paths. */
+  void* data;
+  size_t data_bytes;
+} TirtcAudioPcmFrame;
+
+typedef struct TirtcAudioEncodedFrame {
+  TirtcMediaCodec codec;
+  TirtcAudioSampleRate sample_rate;
+  uint32_t samples_per_channel;
+  int64_t pts_us;
+  const void* data;
+  size_t data_bytes;
+} TirtcAudioEncodedFrame;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_AUDIO_FRAME_H_

package/vendor/app-server/bin/runtime/macos-arm64/include/tirtc/audio_io.h

@@ -0,0 +1,56 @@
+#ifndef TIRTC_AUDIO_IO_H_
+#define TIRTC_AUDIO_IO_H_
+
+#include <stdint.h>
+
+#include "tirtc/audio_frame.h"
+#include "tirtc/error.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct TirtcAudioAin TirtcAudioAin;
+typedef struct TirtcAudioAout TirtcAudioAout;
+
+typedef struct TirtcAudioIoConfig {
+  TirtcAudioSampleRate sample_rate;
+  /* AIN uses fixed 10 ms mono blocks; AOUT may use larger callback-sized multiples. */
+  uint32_t samples_per_buffer;
+} TirtcAudioIoConfig;
+
+typedef void (*TirtcAudioAinOnFrameFn)(TirtcAudioAin* ain, const TirtcAudioPcmFrame* frame,
+                                       void* user_data);
+
+/*
+ * AOUT pre-fills sample_rate, samples_per_channel, data, and data_bytes before
+ * calling render. The callback contract expects a non-negative rendered PCM
+ * byte count. Backends defensively clamp negative returns to zero and zero-fill
+ * any remaining buffer space.
+ *
+ * The render callback and user_data supplied at open-time must stay valid until
+ * close completes. Backends may invoke render without holding backend locks.
+ */
+typedef int (*TirtcAudioAoutRenderFn)(TirtcAudioAout* aout, TirtcAudioPcmFrame* frame,
+                                      void* user_data);
+
+TirtcError tirtc_audio_ain_open(TirtcAudioAin* ain, const TirtcAudioIoConfig* config,
+                                TirtcAudioAinOnFrameFn on_frame, void* user_data);
+
+TirtcError tirtc_audio_ain_close(TirtcAudioAin* ain);
+void tirtc_audio_ain_destroy(TirtcAudioAin* ain);
+
+TirtcError tirtc_audio_aout_open(TirtcAudioAout* aout, const TirtcAudioIoConfig* config,
+                                 TirtcAudioAoutRenderFn render, void* user_data);
+
+TirtcError tirtc_audio_aout_set_volume(TirtcAudioAout* aout, uint32_t volume_percent);
+TirtcError tirtc_audio_aout_pause(TirtcAudioAout* aout, int pause_on);
+TirtcError tirtc_audio_aout_flush(TirtcAudioAout* aout);
+TirtcError tirtc_audio_aout_close(TirtcAudioAout* aout);
+void tirtc_audio_aout_destroy(TirtcAudioAout* aout);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_AUDIO_IO_H_

package/vendor/app-server/bin/runtime/macos-arm64/include/tirtc/audio_io_android.h

@@ -0,0 +1,19 @@
+#ifndef TIRTC_AUDIO_IO_ANDROID_H_
+#define TIRTC_AUDIO_IO_ANDROID_H_
+
+#include "tirtc/audio_io.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(__ANDROID__)
+TirtcError tirtc_audio_android_create_open_sl_ain(TirtcAudioAin** out_ain);
+TirtcError tirtc_audio_android_create_open_sl_aout(TirtcAudioAout** out_aout);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_AUDIO_IO_ANDROID_H_

package/vendor/app-server/bin/runtime/macos-arm64/include/tirtc/audio_io_apple.h

@@ -0,0 +1,19 @@
+#ifndef TIRTC_AUDIO_IO_APPLE_H_
+#define TIRTC_AUDIO_IO_APPLE_H_
+
+#include "tirtc/audio_io.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(__APPLE__)
+TirtcError tirtc_audio_apple_create_audio_toolbox_ain(TirtcAudioAin** out_ain);
+TirtcError tirtc_audio_apple_create_audio_queue_aout(TirtcAudioAout** out_aout);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_AUDIO_IO_APPLE_H_

package/vendor/app-server/bin/runtime/macos-arm64/include/tirtc/audio_io_harmony.h

@@ -0,0 +1,19 @@
+#ifndef TIRTC_AUDIO_IO_HARMONY_H_
+#define TIRTC_AUDIO_IO_HARMONY_H_
+
+#include "tirtc/audio_io.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(__OHOS__)
+TirtcError tirtc_audio_harmony_create_open_sl_ain(TirtcAudioAin** out_ain);
+TirtcError tirtc_audio_harmony_create_audio_render_aout(TirtcAudioAout** out_aout);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_AUDIO_IO_HARMONY_H_

package/vendor/app-server/bin/runtime/macos-arm64/include/tirtc/audio_io_windows.h

@@ -0,0 +1,19 @@
+#ifndef TIRTC_AUDIO_IO_WINDOWS_H_
+#define TIRTC_AUDIO_IO_WINDOWS_H_
+
+#include "tirtc/audio_io.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(_WIN32)
+TirtcError tirtc_audio_windows_create_wasapi_ain(TirtcAudioAin** out_ain);
+TirtcError tirtc_audio_windows_create_wave_out_aout(TirtcAudioAout** out_aout);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_AUDIO_IO_WINDOWS_H_

package/vendor/app-server/bin/runtime/macos-arm64/include/tirtc/audio_processing.h

@@ -0,0 +1,56 @@
+#ifndef TIRTC_AUDIO_PROCESSING_H_
+#define TIRTC_AUDIO_PROCESSING_H_
+
+#include "tirtc/audio_frame.h"
+#include "tirtc/error.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct TirtcAudioProcessor TirtcAudioProcessor;
+
+typedef enum TirtcAudioAecMode {
+  TIRTC_AUDIO_AEC_MODE_DISABLED = 0,
+  TIRTC_AUDIO_AEC_MODE_ENABLED = 1,
+} TirtcAudioAecMode;
+
+typedef enum TirtcAudioAnsLevel {
+  TIRTC_AUDIO_ANS_LEVEL_DISABLED = 0,
+  TIRTC_AUDIO_ANS_LEVEL_LOW = 1,
+  TIRTC_AUDIO_ANS_LEVEL_MEDIUM = 2,
+  TIRTC_AUDIO_ANS_LEVEL_HIGH = 3,
+} TirtcAudioAnsLevel;
+
+typedef enum TirtcAudioAgcLevel {
+  TIRTC_AUDIO_AGC_LEVEL_DISABLED = 0,
+  TIRTC_AUDIO_AGC_LEVEL_LOW = 1,
+  TIRTC_AUDIO_AGC_LEVEL_MEDIUM = 2,
+  TIRTC_AUDIO_AGC_LEVEL_HIGH = 3,
+} TirtcAudioAgcLevel;
+
+typedef struct TirtcAudioProcessorConfig {
+  TirtcAudioSampleRate sample_rate;
+  TirtcAudioAecMode aec_mode;
+  TirtcAudioAnsLevel ans_level;
+  TirtcAudioAgcLevel agc_level;
+} TirtcAudioProcessorConfig;
+
+TirtcError tirtc_audio_processor_create(const TirtcAudioProcessorConfig* config,
+                                        TirtcAudioProcessor** out_processor);
+void tirtc_audio_processor_destroy(TirtcAudioProcessor* processor);
+
+TirtcError tirtc_audio_processor_set_config(TirtcAudioProcessor* processor,
+                                            const TirtcAudioProcessorConfig* config);
+
+TirtcError tirtc_audio_processor_process(TirtcAudioProcessor* processor,
+                                         const TirtcAudioPcmFrame* in_frame,
+                                         TirtcAudioPcmFrame* out_frame);
+
+TirtcError tirtc_audio_processor_reset(TirtcAudioProcessor* processor);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_AUDIO_PROCESSING_H_

package/vendor/app-server/bin/runtime/macos-arm64/include/tirtc/audio_sample_rate.h

@@ -0,0 +1,18 @@
+#ifndef TIRTC_MEDIA_CONTRACT_AUDIO_SAMPLE_RATE_H_
+#define TIRTC_MEDIA_CONTRACT_AUDIO_SAMPLE_RATE_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum TirtcAudioSampleRate {
+  TIRTC_AUDIO_SAMPLE_RATE_NONE = 0,
+  TIRTC_AUDIO_SAMPLE_RATE_8K = 8000,
+  TIRTC_AUDIO_SAMPLE_RATE_16K = 16000,
+} TirtcAudioSampleRate;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_MEDIA_CONTRACT_AUDIO_SAMPLE_RATE_H_