tirtc-devtools-cli 0.0.15 → 0.1.1

package/README.md

@@ -16,7 +16,7 @@
 - 不提供长驻 Host、HTTP API、共享 session 或桌面 UI。
 - 不替代业务鉴权系统；token 签发只服务 DevTools 联调与验收。
 - 不把 `bootstrap.json` 定义成移动端接入协议；它只是本机 CLI receive、sample smoke 和 validation automation 的交接产物。
-- 不宣称 Linux native send/receive 调试已支持；当前外部调试发布面先按 `macos-arm64` 收口。
+- 不提供长驻 Linux 服务端；Linux 调试发布面是 `linux-x64` native CLI/driver，运行在 Linux host 或 `linux/amd64` container。
 
 ## 依赖方向
 
@@ -56,6 +56,10 @@ node products/cli/bin/tirtc-devtools-cli.js --json send start \
   --artifact-root .build/devtools-cli/send-movie-h264
 ```
 
+`send start` 默认持续运行直到用户结束进程；需要自动化限时时再显式传
+`--duration-ms <ms>`。prepared asset 会按完整音视频轨循环，任一轨到达源文件末尾时
+audio/video 同步回到源头并保持 PTS 继续递增。
+
 打包入口：
 
 ```sh

package/USAGE.md

@@ -16,9 +16,7 @@ node products/cli/bin/tirtc-devtools-cli.js --help
 ## Platform Support
 
 - `macos-arm64`: supported for token, assets prepare, send, receive, package smoke, and native send+receive qualification.
-- `linux-x64`: runtime package surface and cross-build are covered, but native send/receive qualification is not a supported external debugging path yet.
-
-Do not treat Linux send/receive as ready until the Linux headless receive driver or a containerized online runner is delivered.
+- `linux-x64`: supported for token, assets prepare, send, receive, package smoke, and native driver packaging. Linux native send/receive runs through the packaged headless driver on Linux hosts or `linux/amd64` containers.
 
 ## Token
 
@@ -112,6 +110,11 @@ node products/cli/bin/tirtc-devtools-cli.js --json send start \
   --artifact-root .build/devtools-cli/send-movie-h264
 ```
 
+By default `send start` keeps running until the process is stopped. Use
+`--duration-ms <ms>` only for bounded automation. Prepared assets loop over the
+full audio/video source cycle; when either track reaches the source end, both
+tracks restart from offset 0 while PTS keeps increasing.
+
 The send role writes `bootstrap.json`. That file is a local handoff artifact for
 CLI receive, runtime sample smoke, and validation automation. The token in that
 bootstrap is intended for one receive connection.

package/dist/cli/src/index.js

@@ -1,10 +1,26 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const embedded_paths_1 = require("./embedded_paths");
 const media_assets_1 = require("./media_assets");
 const token_command_1 = require("./token_command");
 const role_driver_1 = require("./role_driver");
-const cliVersion = '0.0.14';
+function resolveCliVersion() {
+    try {
+        const packageRoot = (0, embedded_paths_1.resolveCliPackageRoot)(__dirname);
+        const packageJson = JSON.parse(fs_1.default.readFileSync(path_1.default.join(packageRoot, 'package.json'), 'utf8'));
+        return typeof packageJson.version === 'string' ? packageJson.version : 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+const cliVersion = resolveCliVersion();
 if (process.argv.includes('--version') || process.argv.includes('-V')) {
     console.log('CLI Version: ' + cliVersion);
     console.log('DevTools Driver Contract: 1');
@@ -101,7 +117,7 @@ send.command('start')
     .option('--remote-id <id>', 'server remote id；默认读取 TIRTC_DEVICE_ID')
     .option('--source <path>', 'prepared asset root、manifest_path 或 encoded track；MP4 先运行 assets prepare')
     .option('--video-codec <codec>', 'h264|h265|mjpeg', 'h264')
-    .option('--duration-ms <ms>', 'role active 时长')
+    .option('--duration-ms <ms>', '可选自动结束时长；默认持续运行直到用户结束进程')
     .option('--connect-timeout-ms <ms>', 'service ready / connect 最大等待')
     .option('--first-packet-timeout-ms <ms>', '首包最大等待')
     .option('--bootstrap-token-json <path>', 'script/issue_devtools_token.sh --json 输出文件')
@@ -127,7 +143,7 @@ receive.command('start')
     .option('--video-stream-id <id>', '视频 stream id')
     .option('--consumer <consumer>', 'packet_dump|frame_dump', 'frame_dump')
     .option('--frame-limit <count>', 'frame_dump 帧数上限')
-    .option('--duration-ms <ms>', 'role active 时长')
+    .option('--duration-ms <ms>', '可选自动结束时长；默认由输出条件或用户结束进程')
     .option('--connect-timeout-ms <ms>', 'connect 最大等待')
     .option('--first-packet-timeout-ms <ms>', '首包最大等待')
     .option('--first-output-timeout-ms <ms>', '首帧输出最大等待')

package/dist/cli/src/media_assets.js

@@ -10,6 +10,14 @@ const path_1 = __importDefault(require("path"));
 const util_1 = require("util");
 const embedded_paths_1 = require("./embedded_paths");
 const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+class PrepareMediaAssetsError extends Error {
+    reasonCode;
+    constructor(message, reasonCode) {
+        super(message);
+        this.name = 'PrepareMediaAssetsError';
+        this.reasonCode = reasonCode;
+    }
+}
 function resolveRepoRoot(fromDir) {
     const candidates = [
         path_1.default.resolve(fromDir, '../../..'),
@@ -36,23 +44,35 @@ function resolvePrepareScript(repoRoot) {
     }
     return path_1.default.join(repoRoot, 'runtime/script/prepare_runtime_media_dataset.sh');
 }
+function normalizeExecErrorMessage(message) {
+    const prefix = '[prepare_runtime_media_dataset] error: ';
+    const normalized = message.startsWith(prefix) ? message.slice(prefix.length).trim() : message;
+    const reasonMatch = normalized.match(/^([a-z][a-z0-9_]*):\s*(.+)$/);
+    if (reasonMatch) {
+        return {
+            reasonCode: reasonMatch[1],
+            message: reasonMatch[2],
+        };
+    }
+    return { message: normalized };
+}
 function parseExecError(error) {
     if (!error || typeof error !== 'object') {
-        return String(error);
+        return normalizeExecErrorMessage(String(error));
     }
     const typed = error;
     const stderr = typeof typed.stderr === 'string' ? typed.stderr.trim() : typed.stderr?.toString('utf8').trim();
     if (stderr && stderr.length > 0) {
-        return stderr;
+        return normalizeExecErrorMessage(stderr);
     }
     const stdout = typeof typed.stdout === 'string' ? typed.stdout.trim() : typed.stdout?.toString('utf8').trim();
     if (stdout && stdout.length > 0) {
-        return stdout;
+        return normalizeExecErrorMessage(stdout);
     }
     if (typed.message && typed.message.length > 0) {
-        return typed.message;
+        return normalizeExecErrorMessage(typed.message);
     }
-    return 'process failed';
+    return { message: 'process failed' };
 }
 function assertPrepareRequest(request) {
     if (!request.source || request.source.trim().length === 0) {
@@ -99,7 +119,8 @@ async function prepareMediaAssets(request, options = {}) {
         stdout = String(result.stdout ?? '').trim();
     }
     catch (error) {
-        throw new Error(parseExecError(error));
+        const parsed = parseExecError(error);
+        throw new PrepareMediaAssetsError(parsed.message, parsed.reasonCode);
     }
     let parsed;
     try {

package/dist/cli/src/role_driver.js

@@ -14,7 +14,6 @@ const embedded_paths_1 = require("./embedded_paths");
 const token_tool_1 = require("./token_tool");
 const defaultAudioStreamId = 10;
 const defaultVideoStreamId = 11;
-const defaultDurationMs = 10000;
 const defaultConnectTimeoutMs = 10000;
 const defaultFirstPacketTimeoutMs = 10000;
 const defaultFirstOutputTimeoutMs = 12000;
@@ -137,6 +136,12 @@ function parsePositiveInt(raw, fallback, name) {
     }
     return parsed;
 }
+function parseOptionalPositiveInt(raw, name) {
+    if (raw === undefined) {
+        return undefined;
+    }
+    return parsePositiveInt(raw, 1, name);
+}
 function requireEnv(name) {
     const value = process.env[name]?.trim();
     if (!value) {
@@ -338,7 +343,7 @@ async function buildSendRequest(roots, artifactRoot, options) {
         },
         output: { consumer: 'frame_dump', video: { frame_limit: defaultFrameLimit } },
         run: {
-            duration_ms: parsePositiveInt(options.durationMs, defaultDurationMs, '--duration-ms'),
+            duration_ms: parseOptionalPositiveInt(options.durationMs, '--duration-ms'),
             connect_timeout_ms: parsePositiveInt(options.connectTimeoutMs, defaultConnectTimeoutMs, '--connect-timeout-ms'),
             first_packet_timeout_ms: parsePositiveInt(options.firstPacketTimeoutMs, defaultFirstPacketTimeoutMs, '--first-packet-timeout-ms'),
             first_output_timeout_ms: defaultFirstOutputTimeoutMs,
@@ -386,7 +391,7 @@ function buildReceiveRequest(roots, artifactRoot, options) {
             video: { frame_limit: parsePositiveInt(options.frameLimit, defaultFrameLimit, '--frame-limit') },
         },
         run: {
-            duration_ms: parsePositiveInt(options.durationMs, defaultDurationMs, '--duration-ms'),
+            duration_ms: parseOptionalPositiveInt(options.durationMs, '--duration-ms'),
             connect_timeout_ms: parsePositiveInt(options.connectTimeoutMs, defaultConnectTimeoutMs, '--connect-timeout-ms'),
             first_packet_timeout_ms: parsePositiveInt(options.firstPacketTimeoutMs, defaultFirstPacketTimeoutMs, '--first-packet-timeout-ms'),
             first_output_timeout_ms: parsePositiveInt(options.firstOutputTimeoutMs, defaultFirstOutputTimeoutMs, '--first-output-timeout-ms'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tirtc-devtools-cli",
-  "version": "0.0.15",
+  "version": "0.1.1",
   "private": false,
   "main": "dist/cli/src/index.js",
   "types": "dist/cli/src/index.d.ts",

package/vendor/runtime/linux-x64/include/tirtc/audio.h

@@ -0,0 +1,237 @@
+#ifndef TIRTC_FACADE_AUDIO_H_
+#define TIRTC_FACADE_AUDIO_H_
+
+#include <stdint.h>
+
+#include "tirtc/audio_frame.h"
+#include "tirtc/audio_io.h"
+#include "tirtc/audio_processing.h"
+#include "tirtc/media_codec.h"
+#include "tirtc/trp.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct TirtcAudioInput TirtcAudioInput;
+
+typedef struct TirtcAudioEncodedInput TirtcAudioEncodedInput;
+
+typedef struct TirtcAudioOutput TirtcAudioOutput;
+
+typedef enum TirtcInputState {
+
+  TIRTC_INPUT_STATE_IDLE = 0,
+
+  TIRTC_INPUT_STATE_RUNNING = 1,
+
+  TIRTC_INPUT_STATE_STOPPED = 2,
+
+  TIRTC_INPUT_STATE_FAILED = 3,
+} TirtcInputState;
+
+typedef enum TirtcAudioOutputState {
+
+  TIRTC_AUDIO_OUTPUT_STATE_IDLE = 0,
+
+  TIRTC_AUDIO_OUTPUT_STATE_BUFFERING = 1,
+
+  TIRTC_AUDIO_OUTPUT_STATE_PLAYING = 2,
+
+  TIRTC_AUDIO_OUTPUT_STATE_FAILED = 3,
+} TirtcAudioOutputState;
+
+typedef struct TirtcAudioInputOptions {
+  TirtcAudioSampleRate sample_rate;
+
+  TirtcAudioAecMode aec_mode;
+
+  TirtcAudioAgcLevel agc_level;
+
+  TirtcAudioAnsLevel ans_level;
+} TirtcAudioInputOptions;
+
+/**
+ * Options for a facade audio encoded input.
+ *
+ * The encoded input does not own or create an audio source. Callers submit already-encoded audio
+ * frames with `tirtc_audio_encoded_input_submit_frame()`. Non-NONE fields constrain submitted
+ * frames and reject mismatched packets with `TIRTC_ERROR_INVALID_ARGUMENT`.
+ */
+typedef struct TirtcAudioEncodedInputOptions {
+  TirtcMediaCodec codec;
+
+  TirtcAudioSampleRate sample_rate;
+} TirtcAudioEncodedInputOptions;
+
+typedef struct TirtcAudioOutputOptions {
+  uint32_t volume_percent;
+
+  TirtcAudioAgcLevel agc_level;
+
+  TirtcAudioAnsLevel ans_level;
+} TirtcAudioOutputOptions;
+
+typedef struct TirtcOutputStutterMetrics {
+  int session_started;
+  uint64_t session_duration_ms;
+  uint64_t session_stutter_total_ms;
+  uint32_t session_stutter_count;
+  uint64_t session_stutter_peak_ms;
+  double session_stutter_ratio;
+  uint32_t recent_window_duration_ms;
+  uint64_t recent_window_stutter_total_ms;
+  uint32_t recent_window_stutter_count;
+  uint64_t recent_window_stutter_peak_ms;
+  double recent_window_stutter_ratio;
+} TirtcOutputStutterMetrics;
+
+typedef struct TirtcPendingDurationMetrics {
+  uint64_t undecoded_duration_ms;
+  uint64_t decoded_duration_ms;
+} TirtcPendingDurationMetrics;
+
+typedef struct TirtcAudioOutputMetricsSnapshot {
+  TirtcOutputStutterMetrics stutter;
+  TirtcPendingDurationMetrics pending;
+} TirtcAudioOutputMetricsSnapshot;
+
+/**
+ * Diagnostic facts currently known for an audio output.
+ *
+ * The snapshot is a caller-owned value copy. Zero-initialized fields mean the output has not yet
+ * observed a matching runtime fact or only cached zero-state is available. This diagnostic API is
+ * intended for UI/debug visibility and logs, not for playback control decisions.
+ */
+typedef struct TirtcAudioOutputDebugSnapshot {
+  TirtcMediaCodec codec;
+} TirtcAudioOutputDebugSnapshot;
+
+/**
+ * Audio input observer.
+ *
+ * `owned_message` is allocated by facade for this callback dispatch. Consumers must release it
+ * with `tirtc_owned_string_release()` after copying or converting the string they need.
+ */
+typedef struct TirtcAudioInputObserver {
+  void (*on_state_changed)(TirtcAudioInput* input, TirtcInputState state, void* user_data);
+
+  void (*on_error)(TirtcAudioInput* input, TirtcError error, TirtcOwnedString* owned_message,
+                   void* user_data);
+} TirtcAudioInputObserver;
+
+/**
+ * Audio encoded input observer.
+ *
+ * State callbacks report only facade input lifecycle changes. They do not mean a remote consumer
+ * has subscribed to, decoded, or rendered the stream. `owned_message` is allocated by facade for
+ * this callback dispatch; consumers must release it with `tirtc_owned_string_release()`.
+ */
+typedef struct TirtcAudioEncodedInputObserver {
+  void (*on_state_changed)(TirtcAudioEncodedInput* input, TirtcInputState state, void* user_data);
+
+  void (*on_error)(TirtcAudioEncodedInput* input, TirtcError error, TirtcOwnedString* owned_message,
+                   void* user_data);
+} TirtcAudioEncodedInputObserver;
+
+/**
+ * Audio output observer.
+ *
+ * `owned_message` is allocated by facade for this callback dispatch. Consumers must release it
+ * with `tirtc_owned_string_release()` after copying or converting the string they need.
+ */
+typedef struct TirtcAudioOutputObserver {
+  void (*on_state_changed)(TirtcAudioOutput* output, TirtcAudioOutputState state, void* user_data);
+
+  void (*on_error)(TirtcAudioOutput* output, TirtcError error, TirtcOwnedString* owned_message,
+                   void* user_data);
+} TirtcAudioOutputObserver;
+
+TirtcError tirtc_conn_subscribe_audio(TirtcConn* connection, uint8_t stream_id);
+
+TirtcError tirtc_conn_unsubscribe_audio(TirtcConn* connection, uint8_t stream_id);
+
+TirtcError tirtc_audio_input_create(TirtcAudioInput** out_input);
+
+TirtcError tirtc_audio_input_set_ain(TirtcAudioInput* input, TirtcAudioAin* ain);
+
+TirtcError tirtc_audio_input_set_options(TirtcAudioInput* input,
+                                         const TirtcAudioInputOptions* options);
+
+TirtcError tirtc_audio_input_set_observer(TirtcAudioInput* input,
+                                          const TirtcAudioInputObserver* observer, void* user_data);
+
+TirtcError tirtc_audio_input_start(TirtcAudioInput* input);
+
+TirtcError tirtc_audio_input_stop(TirtcAudioInput* input);
+
+TirtcError tirtc_audio_input_attach(TirtcAudioInput* input, TirtcConn* connection,
+                                    uint8_t stream_id);
+
+TirtcError tirtc_audio_input_detach(TirtcAudioInput* input, TirtcConn* connection);
+
+void tirtc_audio_input_destroy(TirtcAudioInput* input);
+
+TirtcError tirtc_audio_encoded_input_create(TirtcAudioEncodedInput** out_input);
+
+TirtcError tirtc_audio_encoded_input_set_options(TirtcAudioEncodedInput* input,
+                                                 const TirtcAudioEncodedInputOptions* options);
+
+TirtcError tirtc_audio_encoded_input_set_observer(TirtcAudioEncodedInput* input,
+                                                  const TirtcAudioEncodedInputObserver* observer,
+                                                  void* user_data);
+
+TirtcError tirtc_audio_encoded_input_start(TirtcAudioEncodedInput* input);
+
+TirtcError tirtc_audio_encoded_input_stop(TirtcAudioEncodedInput* input);
+
+TirtcError tirtc_audio_encoded_input_attach(TirtcAudioEncodedInput* input, TirtcConn* connection,
+                                            uint8_t stream_id);
+
+TirtcError tirtc_audio_encoded_input_detach(TirtcAudioEncodedInput* input, TirtcConn* connection);
+
+TirtcError tirtc_audio_encoded_input_submit_frame(TirtcAudioEncodedInput* input,
+                                                  const TirtcAudioEncodedFrame* frame);
+
+void tirtc_audio_encoded_input_destroy(TirtcAudioEncodedInput* input);
+
+TirtcError tirtc_audio_output_create(TirtcAudioOutput** out_output);
+
+TirtcError tirtc_audio_output_set_aout(TirtcAudioOutput* output, TirtcAudioAout* aout);
+
+TirtcError tirtc_audio_output_set_options(TirtcAudioOutput* output,
+                                          const TirtcAudioOutputOptions* options);
+
+TirtcError tirtc_audio_output_set_observer(TirtcAudioOutput* output,
+                                           const TirtcAudioOutputObserver* observer,
+                                           void* user_data);
+
+TirtcError tirtc_audio_output_attach(TirtcAudioOutput* output, TirtcConn* connection,
+                                     uint8_t stream_id);
+
+TirtcError tirtc_audio_output_detach(TirtcAudioOutput* output);
+
+void tirtc_audio_output_destroy(TirtcAudioOutput* output);
+
+TirtcError tirtc_audio_output_start_raw_dump(TirtcAudioOutput* output);
+
+TirtcError tirtc_audio_output_stop_raw_dump(TirtcAudioOutput* output);
+
+TirtcError tirtc_metrics_audio_output_get_snapshot(TirtcAudioOutput* output,
+                                                   TirtcAudioOutputMetricsSnapshot* out_snapshot);
+
+/**
+ * Copies the current or cached audio output diagnostic snapshot.
+ *
+ * The output owns the underlying media downlink. Callers provide only `out_snapshot` storage and do
+ * not receive ownership of any runtime object. The function returns `TIRTC_ERROR_INVALID_ARGUMENT`
+ * for null arguments and does not emit output callbacks or change output state.
+ */
+TirtcError tirtc_audio_output_get_debug_snapshot(TirtcAudioOutput* output,
+                                                 TirtcAudioOutputDebugSnapshot* out_snapshot);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/vendor/runtime/linux-x64/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/runtime/linux-x64/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/runtime/linux-x64/include/tirtc/audio_io.h

@@ -0,0 +1,65 @@
+#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 struct TirtcAudioHeadlessAoutOptions {
+  const char* first_output_json_path;
+  const char* pcm_path;
+  uint32_t max_capture_bytes;
+} TirtcAudioHeadlessAoutOptions;
+
+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_create_headless_capture(const TirtcAudioHeadlessAoutOptions* options,
+                                                    TirtcAudioAout** out_aout);
+
+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/runtime/linux-x64/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/runtime/linux-x64/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/runtime/linux-x64/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/runtime/linux-x64/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_