tirtc-devtools-cli 0.0.13 → 0.0.14

package/dist/cli/src/token_issue.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.issueToken = issueToken;
+const crypto_1 = __importDefault(require("crypto"));
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const defaultOpenapiEndpoint = 'http://api-test-tirtc.tange365.com';
+const defaultUserTtlSeconds = 86400;
+const defaultChannelTtlSeconds = 300;
+const defaultHttpTimeoutMs = 15000;
+function normalizeRequired(value, field) {
+    const normalized = value.trim();
+    if (normalized.length === 0) {
+        throw new Error('missing required credential field: ' + field);
+    }
+    return normalized;
+}
+function timestampUtc() {
+    return new Date().toISOString().replace(/\.\d{3}Z$/, 'Z');
+}
+function sha256Hex(input) {
+    return crypto_1.default.createHash('sha256').update(input).digest('hex');
+}
+function base64Url(input) {
+    return input.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
+}
+function buildAuthorization(method, requestPath, query, timestamp, body, accessId, secretKey) {
+    const bodyHash = sha256Hex(body);
+    const stringToSign = [method, requestPath, query, timestamp, bodyHash].join('\n');
+    const signature = crypto_1.default.createHmac('sha256', secretKey).update(stringToSign).digest();
+    return 'TGServer ' + accessId + ':' + base64Url(signature);
+}
+function postJson(endpoint, requestPath, headers, body) {
+    const url = new URL(endpoint);
+    const client = url.protocol === 'https:' ? https_1.default : http_1.default;
+    const port = url.port.length > 0 ? Number.parseInt(url.port, 10) : (url.protocol === 'https:' ? 443 : 80);
+    return new Promise((resolve, reject) => {
+        const request = client.request({
+            protocol: url.protocol,
+            hostname: url.hostname,
+            port,
+            method: 'POST',
+            path: requestPath,
+            headers: {
+                ...headers,
+                'Content-Length': Buffer.byteLength(body),
+            },
+            timeout: defaultHttpTimeoutMs,
+        }, (response) => {
+            const chunks = [];
+            response.on('data', (chunk) => chunks.push(chunk));
+            response.on('end', () => {
+                resolve({
+                    statusCode: response.statusCode ?? 0,
+                    body: Buffer.concat(chunks).toString('utf8'),
+                });
+            });
+        });
+        request.on('timeout', () => {
+            request.destroy(new Error('token issue request timeout'));
+        });
+        request.on('error', reject);
+        request.write(body);
+        request.end();
+    });
+}
+function findStringByKey(value, key) {
+    if (typeof value !== 'object' || value === null) {
+        return '';
+    }
+    if (Array.isArray(value)) {
+        for (const entry of value) {
+            const found = findStringByKey(entry, key);
+            if (found.length > 0) {
+                return found;
+            }
+        }
+        return '';
+    }
+    const record = value;
+    if (typeof record[key] === 'string') {
+        return record[key];
+    }
+    for (const entry of Object.values(record)) {
+        const found = findStringByKey(entry, key);
+        if (found.length > 0) {
+            return found;
+        }
+    }
+    return '';
+}
+function readJsonString(body, key) {
+    try {
+        return findStringByKey(JSON.parse(body), key);
+    }
+    catch {
+        return '';
+    }
+}
+function issueFailure(statusCode) {
+    return new Error('issue token failed error=3 http_status=' + statusCode);
+}
+async function issueToken(input) {
+    const accessId = normalizeRequired(input.accessId, 'accessId');
+    const secretKey = normalizeRequired(input.secretKey, 'secretKey');
+    const remoteId = normalizeRequired(input.remoteId, 'remoteId');
+    const endpoint = input.openapiEndpoint?.trim() || defaultOpenapiEndpoint;
+    const userTtlSeconds = input.userTtlSeconds && input.userTtlSeconds > 0 ?
+        input.userTtlSeconds :
+        defaultUserTtlSeconds;
+    const channelTtlSeconds = input.channelTtlSeconds && input.channelTtlSeconds > 0 ?
+        input.channelTtlSeconds :
+        defaultChannelTtlSeconds;
+    const timestamp = timestampUtc();
+    const userBody = JSON.stringify({ access_id: accessId, uid: remoteId, ttl: userTtlSeconds });
+    const userResponse = await postJson(endpoint, '/v1/user_token', {
+        'Content-Type': 'application/json',
+        Authorization: buildAuthorization('POST', '/v1/user_token', '', timestamp, userBody, accessId, secretKey),
+        'X-TG-Timestamp': timestamp,
+    }, userBody);
+    const userToken = readJsonString(userResponse.body, 'user_token');
+    if (userResponse.statusCode < 200 || userResponse.statusCode >= 300 || userToken.length === 0) {
+        throw issueFailure(userResponse.statusCode);
+    }
+    const channelBody = JSON.stringify({ device_id: remoteId, ttl: channelTtlSeconds });
+    const channelResponse = await postJson(endpoint, '/v1/token', {
+        'Content-Type': 'application/json',
+        Authorization: 'Bearer ' + userToken,
+    }, channelBody);
+    const token = readJsonString(channelResponse.body, 'token').trim();
+    if (channelResponse.statusCode < 200 || channelResponse.statusCode >= 300 || token.length === 0) {
+        throw issueFailure(channelResponse.statusCode);
+    }
+    return token;
+}

package/dist/cli/src/token_tool.d.ts

@@ -40,11 +40,9 @@ export type LicenseQrcodeOutput = {
     qrCodeAscii: string;
     qrCodeAsciiIncluded: boolean;
 };
-export declare function resolveIssueTokenEnvironment(runtimePlatform?: string, fromDir?: string): {
+export declare function resolveIssueTokenEnvironment(): {
     runtimePlatform: string;
-    runtimeBundleRoot: string;
-    repoRoot: string;
-    addonPath: string;
+    provider: string;
 };
 export declare function issueToken(input: TokenIssueInput): Promise<string>;
 export declare function buildIssuedTokenPayload(input: TokenIssueInput, token: string): IssuedTokenPayload;

package/dist/cli/src/token_tool.js

@@ -1,37 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -46,15 +13,11 @@ exports.issueTokenWithQrcode = issueTokenWithQrcode;
 exports.buildLicenseQrcode = buildLicenseQrcode;
 exports.formatTokenIssueConsoleOutput = formatTokenIssueConsoleOutput;
 exports.formatLicenseQrcodeConsoleOutput = formatLicenseQrcodeConsoleOutput;
-const childProcess = __importStar(require("child_process"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const qrcode_1 = __importDefault(require("qrcode"));
-const embedded_paths_1 = require("./embedded_paths");
+const token_issue_1 = require("./token_issue");
 const kAsciiQrQuietZoneModules = 2;
-function pathExists(filePath) {
-    return fs_1.default.existsSync(filePath);
-}
 function ensureDirectory(dirPath) {
     fs_1.default.mkdirSync(dirPath, { recursive: true });
 }
@@ -78,109 +41,10 @@ function buildTokenQrCodePngPath(payload) {
 function buildLicenseQrCodePngPath(payload) {
     return buildQrCodePngPath('license', payload.license);
 }
-function resolveRuntimePlatform() {
-    const raw = process.env.TIRTC_RUNTIME_PLATFORM;
-    if (raw && raw.trim().length > 0) {
-        return raw.trim();
-    }
-    if (process.platform === 'darwin' && process.arch === 'arm64') {
-        return 'macos-arm64';
-    }
-    return 'linux-x64';
-}
-function resolveRuntimeBundleRoot(runtimePlatform, fromDir = __dirname) {
-    const explicit = process.env.TIRTC_RUNTIME_BUNDLE_ROOT;
-    if (explicit && explicit.trim().length > 0) {
-        return explicit.trim();
-    }
-    const embedded = (0, embedded_paths_1.resolveEmbeddedRuntimeBundleRoot)(fromDir, runtimePlatform);
-    if (embedded) {
-        return embedded;
-    }
-    const execDir = path_1.default.dirname(process.execPath);
-    const candidates = [
-        path_1.default.resolve(execDir, 'runtime', runtimePlatform),
-        path_1.default.resolve(execDir, '../runtime', runtimePlatform),
-        path_1.default.resolve(__dirname, '../bin/runtime', runtimePlatform),
-        path_1.default.resolve(__dirname, '../../../../bin/runtime', runtimePlatform),
-        path_1.default.resolve(process.cwd(), 'products/cli/bin/runtime', runtimePlatform),
-        path_1.default.resolve(process.cwd(), 'bin/runtime', runtimePlatform),
-        path_1.default.resolve(process.cwd(), '../bin/runtime', runtimePlatform),
-    ];
-    for (const candidate of candidates) {
-        if (pathExists(path_1.default.join(candidate, 'manifest.txt'))) {
-            return candidate;
-        }
-    }
-    return candidates[0];
-}
-function resolveRepoRoot(fromDir = __dirname) {
-    const embeddedAppServerRoot = (0, embedded_paths_1.resolveEmbeddedAppServerRoot)(fromDir);
-    if (embeddedAppServerRoot) {
-        return path_1.default.resolve(embeddedAppServerRoot, '..');
-    }
-    const candidates = [
-        path_1.default.resolve(__dirname, '../../../../../../'),
-        path_1.default.resolve(__dirname, '../../../../../'),
-        path_1.default.resolve(__dirname, '../../../..'),
-        path_1.default.resolve(process.cwd()),
-    ];
-    for (const candidate of candidates) {
-        if (pathExists(path_1.default.join(candidate, 'products/app-server')) && pathExists(path_1.default.join(candidate, 'products/cli'))) {
-            return candidate;
-        }
-    }
-    return candidates[0];
-}
-function resolveEmbeddedAddonPath(runtimePlatform, fromDir = __dirname) {
-    const embeddedAppServerRoot = (0, embedded_paths_1.resolveEmbeddedAppServerRoot)(fromDir);
-    if (!embeddedAppServerRoot) {
-        return undefined;
-    }
-    const candidate = path_1.default.join(embeddedAppServerRoot, 'bin/native', runtimePlatform, 'credential_napi.node');
-    if (pathExists(candidate)) {
-        return candidate;
-    }
-    return undefined;
-}
-function ensureRuntimeBundleReady(runtimeBundleRoot) {
-    const includeDir = path_1.default.join(runtimeBundleRoot, 'include');
-    const libDir = path_1.default.join(runtimeBundleRoot, 'lib');
-    if (!pathExists(includeDir) || !pathExists(libDir)) {
-        throw new Error('runtime-backed sdk bundle is missing: ' + runtimeBundleRoot);
-    }
-}
-function resolveAddonPath(repoRoot, runtimePlatform, fromDir = __dirname) {
-    const explicit = process.env.TIRTC_CREDENTIAL_ADDON_PATH;
-    const embedded = resolveEmbeddedAddonPath(runtimePlatform, fromDir);
-    const candidates = [
-        explicit,
-        embedded,
-        path_1.default.join(repoRoot, `products/app-server/bin/native/${runtimePlatform}/credential_napi.node`),
-        path_1.default.join(repoRoot, `app-server/bin/native/${runtimePlatform}/credential_napi.node`),
-        path_1.default.join(repoRoot, `.build/app-server/native/${runtimePlatform}/credential_napi.node`),
-        path_1.default.resolve(process.cwd(), `products/app-server/bin/native/${runtimePlatform}/credential_napi.node`),
-        path_1.default.resolve(process.cwd(), `app-server/bin/native/${runtimePlatform}/credential_napi.node`),
-        path_1.default.resolve(process.cwd(), `.build/app-server/native/${runtimePlatform}/credential_napi.node`),
-    ].filter((entry) => typeof entry === 'string' && entry.trim().length > 0);
-    for (const candidate of candidates) {
-        const normalized = path_1.default.resolve(candidate);
-        if (pathExists(normalized)) {
-            return normalized;
-        }
-    }
-    throw new Error('credential addon missing for platform ' + runtimePlatform +
-        '; run: npm --prefix products/app-server run build:native');
-}
-function resolveIssueTokenEnvironment(runtimePlatform = resolveRuntimePlatform(), fromDir = __dirname) {
-    const runtimeBundleRoot = resolveRuntimeBundleRoot(runtimePlatform, fromDir);
-    const repoRoot = resolveRepoRoot(fromDir);
-    ensureRuntimeBundleReady(runtimeBundleRoot);
+function resolveIssueTokenEnvironment() {
     return {
-        runtimePlatform,
-        runtimeBundleRoot,
-        repoRoot,
-        addonPath: resolveAddonPath(repoRoot, runtimePlatform, fromDir),
+        runtimePlatform: 'node',
+        provider: 'products/cli',
     };
 }
 function normalizeIssuedToken(token) {
@@ -190,30 +54,6 @@ function normalizeIssuedToken(token) {
     }
     return normalized;
 }
-function buildIssueTokenHelperSource() {
-    return [
-        'const addon = require(process.env.TIRTC_CREDENTIAL_ADDON_PATH_HELPER);',
-        'const input = JSON.parse(process.env.TIRTC_CREDENTIAL_INPUT_JSON || "{}");',
-        'const originalWrite = process.stderr.write.bind(process.stderr);',
-        'process.stderr.write = ((chunk, encoding, callback) => {',
-        '  if (typeof callback === "function") {',
-        '    callback();',
-        '  }',
-        '  return true;',
-        '});',
-        'try {',
-        '  const token = addon.issueToken({',
-        '    openapiEndpoint: input.openapiEndpoint,',
-        '    accessId: input.accessId,',
-        '    secretKey: input.secretKey,',
-        '    remoteId: input.remoteId,',
-        '  });',
-        '  process.stdout.write(String(token).trim());',
-        '} finally {',
-        '  process.stderr.write = originalWrite;',
-        '}',
-    ].join('\n');
-}
 function parseIssueTokenFailure(message) {
     const matched = message.match(/issue token failed error=(\d+) http_status=(\d+)/i);
     if (!matched) {
@@ -270,25 +110,6 @@ function formatIssueTokenFailureMessage(message) {
     }
     return 'token issuing failed: ' + detail;
 }
-function issueTokenViaSubprocess(addonPath, input) {
-    const result = childProcess.spawnSync(process.execPath, ['-e', buildIssueTokenHelperSource()], {
-        encoding: 'utf8',
-        env: {
-            ...process.env,
-            TIRTC_CREDENTIAL_ADDON_PATH_HELPER: addonPath,
-            TIRTC_CREDENTIAL_INPUT_JSON: JSON.stringify(input),
-        },
-        stdio: ['ignore', 'pipe', 'pipe'],
-    });
-    if (result.error) {
-        throw result.error;
-    }
-    if (result.status !== 0) {
-        const details = String(result.stderr || result.stdout || 'issue token subprocess failed').trim();
-        throw new Error(formatIssueTokenFailureMessage(details || 'issue token subprocess failed'));
-    }
-    return normalizeIssuedToken(String(result.stdout || ''));
-}
 function readQrModule(modules, row, column) {
     return Boolean(modules.data[row * modules.size + column]);
 }
@@ -345,13 +166,18 @@ function renderHalfBlockQr(modules) {
     return lines.join('\n');
 }
 async function issueToken(input) {
-    const resolved = resolveIssueTokenEnvironment();
+    resolveIssueTokenEnvironment();
     try {
-        return issueTokenViaSubprocess(resolved.addonPath, input);
+        return normalizeIssuedToken(await (0, token_issue_1.issueToken)({
+            accessId: input.accessId,
+            secretKey: input.secretKey,
+            remoteId: input.remoteId,
+            openapiEndpoint: input.openapiEndpoint,
+        }));
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        throw new Error(message);
+        throw new Error(formatIssueTokenFailureMessage(message));
     }
 }
 function buildIssuedTokenPayload(input, token) {

package/package.json

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

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

@@ -3,8 +3,10 @@
 
 #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
@@ -13,6 +15,8 @@ extern "C" {
 
 typedef struct TirtcAudioInput TirtcAudioInput;
 
+typedef struct TirtcAudioEncodedInput TirtcAudioEncodedInput;
+
 typedef struct TirtcAudioOutput TirtcAudioOutput;
 
 typedef enum TirtcInputState {
@@ -47,12 +51,25 @@ typedef struct TirtcAudioInputOptions {
   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;
 
-  int gain_level;
+  TirtcAudioAgcLevel agc_level;
 
-  int noise_reduction_level;
+  TirtcAudioAnsLevel ans_level;
 } TirtcAudioOutputOptions;
 
 typedef struct TirtcOutputStutterMetrics {
@@ -92,6 +109,20 @@ typedef struct TirtcAudioInputObserver {
                    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.
  *
@@ -130,6 +161,29 @@ TirtcError tirtc_audio_input_detach(TirtcAudioInput* input, TirtcConn* connectio
 
 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);

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

@@ -19,6 +19,12 @@ typedef struct TirtcAudioIoConfig {
   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);
 
@@ -43,6 +49,9 @@ 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);

package/vendor/{app-server/bin/runtime → runtime}/macos-arm64/include/tirtc/av.h

@@ -5,6 +5,7 @@
 
 #include "tirtc/audio.h"
 #include "tirtc/media_codec.h"
+#include "tirtc/video_codec.h"
 #include "tirtc/video_io.h"
 
 #ifdef __cplusplus
@@ -13,6 +14,8 @@ extern "C" {
 
 typedef struct TirtcVideoInput TirtcVideoInput;
 
+typedef struct TirtcVideoEncodedInput TirtcVideoEncodedInput;
+
 typedef struct TirtcVideoOutput TirtcVideoOutput;
 
 typedef enum TirtcVideoOutputState {
@@ -45,6 +48,10 @@ typedef struct TirtcVideoOutputMetricsSnapshot {
   TirtcPendingDurationMetrics pending;
 } TirtcVideoOutputMetricsSnapshot;
 
+typedef struct TirtcVideoOutputOptions {
+  TirtcVideoDecoderPreference decoder_preference;
+} TirtcVideoOutputOptions;
+
 typedef struct TirtcVideoInputOptions {
   TirtcMediaCodec codec;
 
@@ -55,6 +62,8 @@ typedef struct TirtcVideoInputOptions {
   uint32_t fps;
 
   uint32_t bitrate_kbps;
+
+  TirtcVideoEncoderPreference encoder_preference;
 } TirtcVideoInputOptions;
 
 /**
@@ -73,6 +82,23 @@ typedef struct TirtcVideoInputObserver {
                    void* user_data);
 } TirtcVideoInputObserver;
 
+typedef struct TirtcVideoEncodedInputOptions {
+  TirtcMediaCodec codec;
+  TirtcVideoBitstreamFormat bitstream_format;
+} TirtcVideoEncodedInputOptions;
+
+typedef struct TirtcVideoEncodedInputObserver {
+  void (*on_state_changed)(TirtcVideoEncodedInput* input, TirtcInputState state, void* user_data);
+
+  void (*on_output_size_changed)(TirtcVideoEncodedInput* input, uint32_t width, uint32_t height,
+                                 void* user_data);
+
+  void (*on_error)(TirtcVideoEncodedInput* input, TirtcError error, TirtcOwnedString* owned_message,
+                   void* user_data);
+
+  void (*on_key_frame_requested)(TirtcVideoEncodedInput* input, void* user_data);
+} TirtcVideoEncodedInputObserver;
+
 /**
  * Video output observer.
  *
@@ -125,8 +151,34 @@ TirtcError tirtc_video_input_detach_preview(TirtcVideoInput* input);
 
 void tirtc_video_input_destroy(TirtcVideoInput* input);
 
+TirtcError tirtc_video_encoded_input_create(TirtcVideoEncodedInput** out_input);
+
+TirtcError tirtc_video_encoded_input_set_options(TirtcVideoEncodedInput* input,
+                                                 const TirtcVideoEncodedInputOptions* options);
+
+TirtcError tirtc_video_encoded_input_set_observer(TirtcVideoEncodedInput* input,
+                                                  const TirtcVideoEncodedInputObserver* observer,
+                                                  void* user_data);
+
+TirtcError tirtc_video_encoded_input_start(TirtcVideoEncodedInput* input);
+
+TirtcError tirtc_video_encoded_input_stop(TirtcVideoEncodedInput* input);
+
+TirtcError tirtc_video_encoded_input_attach(TirtcVideoEncodedInput* input, TirtcConn* connection,
+                                            uint8_t stream_id);
+
+TirtcError tirtc_video_encoded_input_detach(TirtcVideoEncodedInput* input, TirtcConn* connection);
+
+TirtcError tirtc_video_encoded_input_submit_frame(TirtcVideoEncodedInput* input,
+                                                  const TirtcVideoEncodedFrame* frame);
+
+void tirtc_video_encoded_input_destroy(TirtcVideoEncodedInput* input);
+
 TirtcError tirtc_video_output_create(TirtcVideoOutput** out_output);
 
+TirtcError tirtc_video_output_set_options(TirtcVideoOutput* output,
+                                          const TirtcVideoOutputOptions* options);
+
 TirtcError tirtc_video_output_set_observer(TirtcVideoOutput* output,
                                            const TirtcVideoOutputObserver* observer,
                                            void* user_data);

package/vendor/{app-server/bin/runtime/linux-x64 → runtime/macos-arm64}/include/tirtc/error.h

@@ -41,6 +41,17 @@ typedef enum TirtcError {
   TIRTC_ERROR_NOT_BOUND = 6029,
   TIRTC_ERROR_NOT_CONFIGURED = 6030,
   TIRTC_ERROR_NOT_OPEN = 6031,
+  TIRTC_ERROR_APP_ID_REQUIRED = 6032,
+  TIRTC_ERROR_VIDEO_ENCODER_BACKEND_UNAVAILABLE = 6033,
+  TIRTC_ERROR_VIDEO_ENCODER_CODEC_UNSUPPORTED = 6034,
+  TIRTC_ERROR_VIDEO_ENCODER_INITIALIZATION_FAILED = 6035,
+  TIRTC_ERROR_VIDEO_DECODER_CODEC_UNSUPPORTED = 6036,
+  TIRTC_ERROR_VIDEO_DECODER_BACKEND_UNAVAILABLE = 6037,
+  TIRTC_ERROR_VIDEO_DECODER_INITIALIZATION_FAILED = 6038,
+  TIRTC_ERROR_VIDEO_DECODER_CONFIGURATION_FAILED = 6039,
+  TIRTC_ERROR_VIDEO_DECODER_RUNTIME_FAILED = 6040,
+  TIRTC_ERROR_VIDEO_OUTPUT_TARGET_UNAVAILABLE = 6041,
+  TIRTC_ERROR_VIDEO_OUTPUT_RENDER_FAILED = 6042,
 } TirtcError;
 
 const char* tirtc_error_to_string(TirtcError error);