tirtc-devtools-cli 0.0.15 → 0.1.1

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

@@ -0,0 +1,112 @@
+#ifndef TIRTC_VIDEO_CODEC_H_
+#define TIRTC_VIDEO_CODEC_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "tirtc/error.h"
+#include "tirtc/video_frame.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct TirtcVideoEncoder TirtcVideoEncoder;
+typedef struct TirtcVideoDecoder TirtcVideoDecoder;
+
+typedef enum TirtcVideoEncoderPreference {
+  TIRTC_VIDEO_ENCODER_PREFERENCE_AUTO = 0,
+  TIRTC_VIDEO_ENCODER_PREFERENCE_SOFTWARE = 1,
+  TIRTC_VIDEO_ENCODER_PREFERENCE_HARDWARE = 2,
+} TirtcVideoEncoderPreference;
+
+typedef enum TirtcVideoDecoderPreference {
+  TIRTC_VIDEO_DECODER_PREFERENCE_AUTO = 0,
+  TIRTC_VIDEO_DECODER_PREFERENCE_SOFTWARE = 1,
+  TIRTC_VIDEO_DECODER_PREFERENCE_HARDWARE = 2,
+} TirtcVideoDecoderPreference;
+
+/**
+ * Backend family that is actually handling a video decoder route.
+ *
+ * `UNKNOWN` means the runtime has not locked a decoder route or the current snapshot cannot prove
+ * one. The enum intentionally reports only the supported backend family; platform-specific decoder
+ * names and native handles are not part of this public surface.
+ */
+typedef enum TirtcVideoDecoderBackendKind {
+  TIRTC_VIDEO_DECODER_BACKEND_KIND_UNKNOWN = 0,
+  TIRTC_VIDEO_DECODER_BACKEND_KIND_SOFTWARE = 1,
+  TIRTC_VIDEO_DECODER_BACKEND_KIND_HARDWARE = 2,
+} TirtcVideoDecoderBackendKind;
+
+typedef enum TirtcVideoEncoderBackendKind {
+  TIRTC_VIDEO_ENCODER_BACKEND_KIND_SOFTWARE = 1,
+  TIRTC_VIDEO_ENCODER_BACKEND_KIND_HARDWARE = 2,
+} TirtcVideoEncoderBackendKind;
+
+typedef struct TirtcVideoEncoderRuntimeInfo {
+  TirtcVideoEncoderBackendKind actual_backend;
+  TirtcVideoEncoderPreference requested_encoder_preference;
+  int did_fallback;
+  TirtcVideoPixelFormat resolved_input_pixel_format;
+} TirtcVideoEncoderRuntimeInfo;
+
+typedef struct TirtcVideoEncoderConfig {
+  TirtcMediaCodec codec;
+  TirtcVideoBitstreamFormat bitstream_format;
+  uint32_t width;
+  uint32_t height;
+  uint32_t fps;
+  uint32_t bitrate_kbps;
+  TirtcVideoPixelFormat input_pixel_format;
+  /**
+   * Selects the encoder backend family before the encoder is created.
+   *
+   * Zero-initialized configs use `AUTO`, which currently preserves the software encoder path.
+   * `HARDWARE` is strict: if the requested hardware backend is unavailable or cannot initialize,
+   * create fails with a video encoder error instead of falling back to software.
+   */
+  TirtcVideoEncoderPreference encoder_preference;
+} TirtcVideoEncoderConfig;
+
+typedef struct TirtcVideoDecoderConfig {
+  TirtcMediaCodec codec;
+  TirtcVideoBitstreamFormat bitstream_format;
+  TirtcVideoPixelFormat output_pixel_format;
+} TirtcVideoDecoderConfig;
+
+TirtcError tirtc_video_encoder_create(const TirtcVideoEncoderConfig* config,
+                                      TirtcVideoEncoder** out_encoder);
+void tirtc_video_encoder_destroy(TirtcVideoEncoder* encoder);
+TirtcError tirtc_video_encoder_reset(TirtcVideoEncoder* encoder);
+TirtcError tirtc_video_encoder_request_key_frame(TirtcVideoEncoder* encoder);
+/**
+ * Returns the backend decision made during encoder creation.
+ *
+ * `out_info` is caller-owned storage. The function writes a value copy and does not allocate or
+ * transfer ownership. It may be called after successful create and before destroy, including while
+ * another thread is using the encoder through the normal encode/control API.
+ */
+TirtcError tirtc_video_encoder_get_runtime_info(const TirtcVideoEncoder* encoder,
+                                                TirtcVideoEncoderRuntimeInfo* out_info);
+TirtcError tirtc_video_encoder_encode(TirtcVideoEncoder* encoder,
+                                      const TirtcVideoPixelFrame* in_frame, void* out_buffer,
+                                      size_t out_buffer_capacity,
+                                      TirtcVideoEncodedFrame* out_frame);
+
+TirtcError tirtc_video_decoder_create(const TirtcVideoDecoderConfig* config,
+                                      TirtcVideoDecoder** out_decoder);
+void tirtc_video_decoder_destroy(TirtcVideoDecoder* decoder);
+TirtcError tirtc_video_decoder_reset(TirtcVideoDecoder* decoder);
+TirtcError tirtc_video_decoder_decode(TirtcVideoDecoder* decoder,
+                                      const TirtcVideoEncodedFrame* in_frame,
+                                      TirtcVideoPixelFrame* out_frame);
+
+TirtcError tirtc_video_snapshot_export_jpeg(const TirtcVideoPixelFrame* frame,
+                                            const char* output_path);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_VIDEO_CODEC_H_

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

@@ -0,0 +1,55 @@
+#ifndef TIRTC_VIDEO_FRAME_H_
+#define TIRTC_VIDEO_FRAME_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "tirtc/media_codec.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define TIRTC_VIDEO_MAX_PLANES 4
+
+typedef enum TirtcVideoPixelFormat {
+  TIRTC_VIDEO_PIXEL_FORMAT_NONE = 0,
+  TIRTC_VIDEO_PIXEL_FORMAT_I420 = 1,
+  TIRTC_VIDEO_PIXEL_FORMAT_NV12 = 2,
+  TIRTC_VIDEO_PIXEL_FORMAT_RGBA8888 = 3,
+} TirtcVideoPixelFormat;
+
+typedef enum TirtcVideoBitstreamFormat {
+  TIRTC_VIDEO_BITSTREAM_FORMAT_NONE = 0,
+  TIRTC_VIDEO_BITSTREAM_FORMAT_H264_ANNEXB = 1,
+  TIRTC_VIDEO_BITSTREAM_FORMAT_H265_ANNEXB = 2,
+  TIRTC_VIDEO_BITSTREAM_FORMAT_MJPEG_JFIF = 3,
+} TirtcVideoBitstreamFormat;
+
+typedef struct TirtcVideoPixelFrame {
+  uint32_t width;
+  uint32_t height;
+  TirtcVideoPixelFormat pixel_format;
+  int64_t pts_us;
+  uint32_t plane_count;
+  void* planes[TIRTC_VIDEO_MAX_PLANES];
+  uint32_t strides[TIRTC_VIDEO_MAX_PLANES];
+  size_t plane_bytes[TIRTC_VIDEO_MAX_PLANES];
+} TirtcVideoPixelFrame;
+
+typedef struct TirtcVideoEncodedFrame {
+  TirtcMediaCodec codec;
+  TirtcVideoBitstreamFormat bitstream_format;
+  uint32_t width;
+  uint32_t height;
+  int64_t pts_us;
+  int is_key_frame;
+  const void* data;
+  size_t data_bytes;
+} TirtcVideoEncodedFrame;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_VIDEO_FRAME_H_

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

@@ -0,0 +1,53 @@
+#ifndef TIRTC_VIDEO_IO_H_
+#define TIRTC_VIDEO_IO_H_
+
+#include <stdint.h>
+
+#include "tirtc/error.h"
+#include "tirtc/video_frame.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct TirtcVideoVin TirtcVideoVin;
+typedef struct TirtcVideoVout TirtcVideoVout;
+
+typedef struct TirtcVideoIoConfig {
+  uint32_t width;
+  uint32_t height;
+  uint32_t fps;
+  /* Preferred pixel format; actual format resolution is backend-specific. */
+  TirtcVideoPixelFormat pixel_format;
+} TirtcVideoIoConfig;
+
+typedef struct TirtcVideoHeadlessVoutOptions {
+  const char* first_frame_json_path;
+  const char* first_frame_raw_path;
+} TirtcVideoHeadlessVoutOptions;
+
+typedef void (*TirtcVideoVinOnFrameFn)(TirtcVideoVin* vin, const TirtcVideoPixelFrame* frame,
+                                       void* user_data);
+
+TirtcError tirtc_video_vin_open(TirtcVideoVin* vin, const TirtcVideoIoConfig* config,
+                                TirtcVideoVinOnFrameFn on_frame, void* user_data);
+TirtcError tirtc_video_vin_get_actual_config(TirtcVideoVin* vin, TirtcVideoIoConfig* out_config);
+TirtcError tirtc_video_vin_start(TirtcVideoVin* vin);
+TirtcError tirtc_video_vin_stop(TirtcVideoVin* vin);
+TirtcError tirtc_video_vin_close(TirtcVideoVin* vin);
+void tirtc_video_vin_destroy(TirtcVideoVin* vin);
+
+TirtcError tirtc_video_vout_open(TirtcVideoVout* vout, const TirtcVideoIoConfig* config);
+TirtcError tirtc_video_vout_create_headless_capture(const TirtcVideoHeadlessVoutOptions* options,
+                                                    TirtcVideoVout** out_vout);
+TirtcError tirtc_video_vout_get_actual_config(TirtcVideoVout* vout, TirtcVideoIoConfig* out_config);
+TirtcError tirtc_video_vout_render_frame(TirtcVideoVout* vout, const TirtcVideoPixelFrame* frame);
+TirtcError tirtc_video_vout_flush(TirtcVideoVout* vout);
+TirtcError tirtc_video_vout_close(TirtcVideoVout* vout);
+void tirtc_video_vout_destroy(TirtcVideoVout* vout);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_VIDEO_IO_H_

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

@@ -0,0 +1,34 @@
+#ifndef TIRTC_VIDEO_IO_ANDROID_H_
+#define TIRTC_VIDEO_IO_ANDROID_H_
+
+#include "tirtc/video_io.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(__ANDROID__)
+struct ANativeWindow;
+
+typedef enum TirtcVideoAndroidVoutRenderer {
+  TIRTC_VIDEO_ANDROID_VOUT_RENDERER_GLES = 0,
+  TIRTC_VIDEO_ANDROID_VOUT_RENDERER_NATIVE_WINDOW_RGBA = 1,
+} TirtcVideoAndroidVoutRenderer;
+
+typedef struct TirtcVideoAndroidSurfaceTextureVoutOptions {
+  struct ANativeWindow* native_window;
+  TirtcVideoAndroidVoutRenderer renderer;
+  const char* h264_decoder_name;
+  const char* h265_decoder_name;
+} TirtcVideoAndroidSurfaceTextureVoutOptions;
+
+TirtcError tirtc_video_android_create_surface_texture_vout(TirtcVideoVout** out_vout);
+TirtcError tirtc_video_android_surface_texture_vout_set_options(
+    TirtcVideoVout* vout, const TirtcVideoAndroidSurfaceTextureVoutOptions* options);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_VIDEO_IO_ANDROID_H_

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

@@ -0,0 +1,47 @@
+#ifndef TIRTC_VIDEO_IO_APPLE_H_
+#define TIRTC_VIDEO_IO_APPLE_H_
+
+#include "tirtc/video_io.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(__APPLE__)
+typedef enum TirtcVideoAppleVoutTarget {
+  TIRTC_VIDEO_APPLE_VOUT_TARGET_DEFAULT = 0,
+  TIRTC_VIDEO_APPLE_VOUT_TARGET_APPKIT_WINDOW = 1,
+  TIRTC_VIDEO_APPLE_VOUT_TARGET_PIXEL_BUFFER_CALLBACK = 2,
+} TirtcVideoAppleVoutTarget;
+
+typedef enum TirtcVideoAppleWindowSlot {
+  TIRTC_VIDEO_APPLE_WINDOW_SLOT_NONE = 0,
+  TIRTC_VIDEO_APPLE_WINDOW_SLOT_LEFT = 1,
+  TIRTC_VIDEO_APPLE_WINDOW_SLOT_RIGHT = 2,
+} TirtcVideoAppleWindowSlot;
+
+typedef int (*TirtcVideoAppleOnPixelBufferFn)(void* pixel_buffer, void* user_data);
+
+typedef struct TirtcVideoAppleCoreVideoVoutOptions {
+  TirtcVideoAppleVoutTarget target;
+  TirtcVideoAppleOnPixelBufferFn on_pixel_buffer;
+  void* user_data;
+  const char* window_title;
+  TirtcVideoAppleWindowSlot window_slot;
+  int use_window_frame;
+  int32_t window_x;
+  int32_t window_y;
+  uint32_t window_width;
+  uint32_t window_height;
+} TirtcVideoAppleCoreVideoVoutOptions;
+
+TirtcError tirtc_video_apple_create_core_video_vout(TirtcVideoVout** out_vout);
+TirtcError tirtc_video_apple_core_video_vout_set_options(
+    TirtcVideoVout* vout, const TirtcVideoAppleCoreVideoVoutOptions* options);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_VIDEO_IO_APPLE_H_

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

@@ -0,0 +1,32 @@
+#ifndef TIRTC_VIDEO_IO_HARMONY_H_
+#define TIRTC_VIDEO_IO_HARMONY_H_
+
+#include "tirtc/video_io.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(__OHOS__)
+typedef struct NativeWindow OHNativeWindow;
+
+typedef enum TirtcVideoHarmonyVoutRenderer {
+  TIRTC_VIDEO_HARMONY_VOUT_RENDERER_GLES = 0,
+  TIRTC_VIDEO_HARMONY_VOUT_RENDERER_NATIVE_WINDOW_RGBA = 1,
+} TirtcVideoHarmonyVoutRenderer;
+
+typedef struct TirtcVideoHarmonyNativeImageVoutOptions {
+  OHNativeWindow* native_window;
+  TirtcVideoHarmonyVoutRenderer renderer;
+} TirtcVideoHarmonyNativeImageVoutOptions;
+
+TirtcError tirtc_video_harmony_create_native_image_vout(TirtcVideoVout** out_vout);
+TirtcError tirtc_video_harmony_native_image_vout_set_options(
+    TirtcVideoVout* vout, const TirtcVideoHarmonyNativeImageVoutOptions* options);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_VIDEO_IO_HARMONY_H_

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

@@ -0,0 +1,26 @@
+#ifndef TIRTC_VIDEO_IO_WINDOWS_H_
+#define TIRTC_VIDEO_IO_WINDOWS_H_
+
+#include "tirtc/video_io.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(_WIN32)
+typedef struct HWND__* TirtcVideoWindowsHwnd;
+
+typedef struct TirtcVideoWindowsDirect2dVoutOptions {
+  TirtcVideoWindowsHwnd hwnd;
+} TirtcVideoWindowsDirect2dVoutOptions;
+
+TirtcError tirtc_video_windows_create_direct2d_vout(TirtcVideoVout** out_vout);
+TirtcError tirtc_video_windows_direct2d_vout_set_options(
+    TirtcVideoVout* vout, const TirtcVideoWindowsDirect2dVoutOptions* options);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_VIDEO_IO_WINDOWS_H_

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

@@ -0,0 +1,34 @@
+#ifndef TIRTC_VIDEO_PROCESSING_H_
+#define TIRTC_VIDEO_PROCESSING_H_
+
+#include "tirtc/error.h"
+#include "tirtc/video_frame.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct TirtcVideoProcessor TirtcVideoProcessor;
+
+typedef struct TirtcVideoProcessorConfig {
+  uint32_t output_width;
+  uint32_t output_height;
+  TirtcVideoPixelFormat output_pixel_format;
+} TirtcVideoProcessorConfig;
+
+TirtcError tirtc_video_processor_create(const TirtcVideoProcessorConfig* config,
+                                        TirtcVideoProcessor** out_processor);
+void tirtc_video_processor_destroy(TirtcVideoProcessor* processor);
+
+TirtcError tirtc_video_processor_set_config(TirtcVideoProcessor* processor,
+                                            const TirtcVideoProcessorConfig* config);
+TirtcError tirtc_video_processor_process(TirtcVideoProcessor* processor,
+                                         const TirtcVideoPixelFrame* in_frame,
+                                         TirtcVideoPixelFrame* out_frame);
+TirtcError tirtc_video_processor_reset(TirtcVideoProcessor* processor);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_VIDEO_PROCESSING_H_

package/vendor/runtime/linux-x64/manifest.txt

@@ -0,0 +1,45 @@
+platform=linux-x64
+profile=full
+staged_at_utc=2026-04-30T09:36:57Z
+source_sdk=/Users/allenfeng/Development/Repositories/tirtc-nexus/tirtc-matrix/.build/sdk/linux-x64
+
+bfc096be1484ac2b1c2776ccabfa2a4c6a982e869abf875192ff06fad85e82ca  include/tirtc/audio.h
+6d972ccfe150a3b4f2d7f18fa92b3ade9210c1c8bb754d061ac6b7997b59e2cb  include/tirtc/audio_codec.h
+7bacbdb2d8bb10d6444036a8fef42f2a8e3ea34dfc38e165ee678d61f189db41  include/tirtc/audio_frame.h
+fb8ea35263167c33487bd3aa503c26ed2dfbf97877f7bda92c10065cd5c97c13  include/tirtc/audio_io.h
+c2e1f31dcc75be461c577d18b1cebe32774f212d51cb4dd2a5b5a9bfe62b693e  include/tirtc/audio_io_android.h
+878bb18220ac62304ec95807f31e83e050c8dac14811f873454f9b045028694a  include/tirtc/audio_io_apple.h
+0569eb1d043ee7fa8d45ca43143eca1a22e4c4bf1507ca7e045e010a3ecbc288  include/tirtc/audio_io_harmony.h
+51cbc911fe9f9834046f0e0a1a7cdd814a8e194a615894a8b4d11f9e5f095610  include/tirtc/audio_io_windows.h
+21f60729117260a44af22c1af986ef17d22673b102b7b7a035f492d0665cce16  include/tirtc/audio_processing.h
+0ca7c3c630b1242f51a0fd8154097c0a332b4c816a5707090e4381719852998c  include/tirtc/audio_sample_rate.h
+58807ba56770f38f47aec995661cadf9d3c1d6ea7bfc940767f1ce67317c7546  include/tirtc/av.h
+0f3e2f454c35e8c2f79bdc93ed77f9f1622751e5a05defa8c9d4213ed8a797c5  include/tirtc/error.h
+ae805545a9515edc9b94262e72ad2c7b7d649288166f4daeb450d8a55e82ae0b  include/tirtc/foundation/build_info.h
+7cf8b372a3d48d4de4a65a04c7f102281a7b42cebb9ec247853d3c53afb63b6a  include/tirtc/http.h
+70bbf93b84d9d1a85f376d9986de570c1f658319e1e5ab6d621f7a4d41033f5c  include/tirtc/logging.h
+7e2f7f81afe37e22f5414d9db32438edd948ff775230c3a0a17ff9ac1a0b560e  include/tirtc/media_codec.h
+ca63fe4fa0c787f20923e264e116fa6d7cb8194a227c03be4e9843d0ce5a9864  include/tirtc/media_downlink.h
+e64191a39004165cdcd11b2ca824af34d4bfe02f7ec3c3101fa9291f56488c30  include/tirtc/media_uplink.h
+489f6c9caa3e4094566b660ef0a002a39c66c1956ef0a1bdb6eacca3798c849a  include/tirtc/transport.h
+bb9c1bf46f2ab51a9f7adb211276c8563b09e7968031c0c6abeebc0eddd66acb  include/tirtc/trp.h
+92b3db6e2cb02265ad5db01881edce9d4e095b1dadf449dce5d8bb5362957e33  include/tirtc/video_codec.h
+e51379666c199588cc33279ccf52248035d1cae3d1d468b1615ebf29f0b39c9c  include/tirtc/video_frame.h
+2a02645d82c58d433c7306a9f0bcd31d0f3e560b63822f7e80919761b81a6284  include/tirtc/video_io.h
+9930dce5e8e2b12a1ab28ee91f3fb46f6cf3487e515ea2b4ec0e00009bd5f070  include/tirtc/video_io_android.h
+005114b9213ec826e18d11eca4b9d65cce2ca0e7c781f03d85292365d9d5dfdd  include/tirtc/video_io_apple.h
+cae0bbeb884e5466a56da15182c78cc22baab6c743f349a58d3595f623333585  include/tirtc/video_io_harmony.h
+65b5d24fe3a6bc2a299a2220148a153ba4eb0955a49c1c3baabf1fdfed8aabdd  include/tirtc/video_io_windows.h
+8cd6b66bea14890a665cc317f8572429b2c3e4463773f8b77c1e4dc30a4a8747  include/tirtc/video_processing.h
+ceb7cdd45efae57e5bd53d4177cb20c4a0cb9917fcdd23127b050d69c8b919ac  lib/libTiRTC.a
+b1f4135025cb8e8520a14268d831b9998920a4239f84bb6b409d0e4909fd5bee  lib/libcrypto.a
+8e3aff3a400fe0971c61511947c0e69d06754002d970e21eaab2339ae38b4a42  lib/libmatrix_runtime_audio.a
+09696896a45a4fab199f0767979471c947b252fc8741a0e803624cdac6953b59  lib/libmatrix_runtime_facade.a
+2c8cc881eeeae679129360df5813dec17d0e33935f196d79cf79671dbd0c8581  lib/libmatrix_runtime_foundation_http.a
+e5aff9f5d9221b9cf08dd8a9144c6039d9dba7bdee3892af2d0e7f7d69633461  lib/libmatrix_runtime_foundation_logging.a
+fe6b5575ce5e80f81e07a7799a05d0a8ee5a338915a28ada86d9009eee952e96  lib/libmatrix_runtime_media.a
+86d9b41f84c6bcc13f8d23a1f9b46d97fe6769573758722f9f6c8d4a130306be  lib/libmatrix_runtime_transport.a
+6ac178f5cd371e9a5be1989dd1e8a3767291f4c4d9d30dcf12ecdd75a2081afa  lib/libmatrix_runtime_video.a
+511d521f7972df3993e5976d6e2dbcad7a6fbce9be15071274d0cbd9d51157f5  lib/libssl.a
+a67ec9034848ef24a1b17671e444daa62a8f9e6b8319a1e932593908720ff2a1  lib/libwebrtc_apm.a
+700e455255897e3cffab13ca593a6e4d9d11383ae609215cbbd6043a63d47161  lib/libxlog.a

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

@@ -96,6 +96,17 @@ typedef struct TirtcAudioOutputMetricsSnapshot {
   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.
  *
@@ -209,6 +220,16 @@ 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

package/vendor/runtime/macos-arm64/include/tirtc/av.h

@@ -48,6 +48,23 @@ typedef struct TirtcVideoOutputMetricsSnapshot {
   TirtcPendingDurationMetrics pending;
 } TirtcVideoOutputMetricsSnapshot;
 
+/**
+ * Diagnostic facts currently known for a video output.
+ *
+ * The snapshot is a caller-owned value copy. `resolved_decoder_backend` is the runtime route that
+ * has actually locked, so AUTO fallback reports the concrete backend family instead of the request.
+ * Zero values mean no current fact or only cached zero-state is available. Additive changes require
+ * a new V2 struct/function instead of extending this layout.
+ */
+typedef struct TirtcVideoOutputDebugSnapshot {
+  TirtcMediaCodec codec;
+  TirtcVideoBitstreamFormat bitstream_format;
+  uint32_t width;
+  uint32_t height;
+  TirtcVideoDecoderPreference requested_decoder_preference;
+  TirtcVideoDecoderBackendKind resolved_decoder_backend;
+} TirtcVideoOutputDebugSnapshot;
+
 typedef struct TirtcVideoOutputOptions {
   TirtcVideoDecoderPreference decoder_preference;
 } TirtcVideoOutputOptions;
@@ -201,6 +218,17 @@ TirtcError tirtc_video_output_stop_raw_dump(TirtcVideoOutput* output);
 TirtcError tirtc_metrics_video_output_get_snapshot(TirtcVideoOutput* output,
                                                    TirtcVideoOutputMetricsSnapshot* out_snapshot);
 
+/**
+ * Copies the current or cached video output diagnostic snapshot.
+ *
+ * The output owns the underlying media downlink and the returned data is only a value copy. Use
+ * this for diagnostics and UI visibility, not to drive decoder selection. The function returns
+ * `TIRTC_ERROR_INVALID_ARGUMENT` for null arguments and does not emit output callbacks or change
+ * output state.
+ */
+TirtcError tirtc_video_output_get_debug_snapshot(TirtcVideoOutput* output,
+                                                 TirtcVideoOutputDebugSnapshot* out_snapshot);
+
 #ifdef __cplusplus
 }
 #endif

package/vendor/runtime/macos-arm64/include/tirtc/error.h

@@ -9,8 +9,6 @@ typedef enum TirtcError {
   TIRTC_ERROR_OK = 0,
   TIRTC_ERROR_INVALID_ARGUMENT = 6000,
   TIRTC_ERROR_NOT_INITIALIZED = 6001,
-  TIRTC_ERROR_INTERNAL = 6002,
-  TIRTC_ERROR_NOT_READY = 6003,
   TIRTC_ERROR_UNSUPPORTED_LOOP_POLICY = 6004,
   TIRTC_ERROR_SOURCE_HASH_MISMATCH = 6005,
   TIRTC_ERROR_ALREADY_STOPPED = 6006,
@@ -52,6 +50,47 @@ typedef enum TirtcError {
   TIRTC_ERROR_VIDEO_DECODER_RUNTIME_FAILED = 6040,
   TIRTC_ERROR_VIDEO_OUTPUT_TARGET_UNAVAILABLE = 6041,
   TIRTC_ERROR_VIDEO_OUTPUT_RENDER_FAILED = 6042,
+  TIRTC_ERROR_RESOURCE_EXHAUSTED = 6043,
+  TIRTC_ERROR_FILE_OPEN_FAILED = 6044,
+  TIRTC_ERROR_FILE_READ_FAILED = 6045,
+  TIRTC_ERROR_FILE_WRITE_FAILED = 6046,
+  TIRTC_ERROR_HTTP_REQUEST_FAILED = 6047,
+  TIRTC_ERROR_LOG_EXPORT_FAILED = 6048,
+  TIRTC_ERROR_LOG_UPLOAD_FAILED = 6049,
+  TIRTC_ERROR_S3_UPLOAD_FAILED = 6050,
+  TIRTC_ERROR_AUDIO_INPUT_OPEN_FAILED = 6051,
+  TIRTC_ERROR_AUDIO_INPUT_RUNTIME_FAILED = 6052,
+  TIRTC_ERROR_AUDIO_OUTPUT_OPEN_FAILED = 6053,
+  TIRTC_ERROR_AUDIO_OUTPUT_RUNTIME_FAILED = 6054,
+  TIRTC_ERROR_AUDIO_PROCESSING_INITIALIZATION_FAILED = 6055,
+  TIRTC_ERROR_AUDIO_PROCESSING_RUNTIME_FAILED = 6056,
+  TIRTC_ERROR_VIDEO_ENCODER_RUNTIME_FAILED = 6057,
+  TIRTC_ERROR_VIDEO_PROCESSING_RUNTIME_FAILED = 6058,
+  TIRTC_ERROR_VIDEO_INPUT_OPEN_FAILED = 6059,
+  TIRTC_ERROR_VIDEO_INPUT_RUNTIME_FAILED = 6060,
+  TIRTC_ERROR_VIDEO_OUTPUT_OPEN_FAILED = 6061,
+  TIRTC_ERROR_MEDIA_UPLINK_CREATE_FAILED = 6062,
+  TIRTC_ERROR_MEDIA_UPLINK_START_FAILED = 6063,
+  TIRTC_ERROR_MEDIA_DOWNLINK_DECODE_FAILED = 6064,
+  TIRTC_ERROR_MEDIA_RAW_DUMP_FAILED = 6065,
+  TIRTC_ERROR_FACADE_RUNTIME_FAILED = 6066,
+  TIRTC_ERROR_LOG_WRITE_FAILED = 6067,
+  TIRTC_ERROR_AUDIO_ENCODER_RUNTIME_FAILED = 6068,
+  TIRTC_ERROR_AUDIO_DECODER_RUNTIME_FAILED = 6069,
+  TIRTC_ERROR_HTTP_CLIENT_UNAVAILABLE = 6070,
+  TIRTC_ERROR_HTTP_TLS_UNSUPPORTED = 6071,
+  TIRTC_ERROR_UPLOAD_TOKEN_EXPIRED = 6072,
+  TIRTC_ERROR_STREAM_ID_IN_USE = 6073,
+  TIRTC_ERROR_VIDEO_PREVIEW_IN_USE = 6074,
+  TIRTC_ERROR_FACADE_PEER_ID_UNAVAILABLE = 6075,
+  TIRTC_ERROR_MEDIA_DOWNLINK_QUEUE_FULL = 6076,
+  TIRTC_ERROR_MEDIA_DOWNLINK_OUTPUT_PENDING = 6077,
+  TIRTC_ERROR_TRANSPORT_INVALID_HANDLE = 6078,
+  TIRTC_ERROR_VIDEO_ENCODER_INPUT_PENDING = 6079,
+  TIRTC_ERROR_VIDEO_ENCODER_OUTPUT_PENDING = 6080,
+  TIRTC_ERROR_VIDEO_DECODER_INPUT_PENDING = 6081,
+  TIRTC_ERROR_VIDEO_DECODER_OUTPUT_PENDING = 6082,
+  TIRTC_ERROR_MEDIA_UPLINK_INPUT_MODE_MISMATCH = 6083,
 } TirtcError;
 
 const char* tirtc_error_to_string(TirtcError error);

package/vendor/runtime/macos-arm64/include/tirtc/media_downlink.h

@@ -86,6 +86,33 @@ typedef struct TirtcMediaDownlinkVideoMetricsSnapshot {
   TirtcMediaDownlinkPendingMetricsSnapshot pending;
 } TirtcMediaDownlinkVideoMetricsSnapshot;
 
+/**
+ * Diagnostic facts currently known by an audio downlink.
+ *
+ * The snapshot is a value copy into caller-owned storage. `codec` is
+ * `TIRTC_MEDIA_CODEC_NONE` until the downlink accepts a valid encoded audio frame.
+ */
+typedef struct TirtcMediaDownlinkAudioDebugSnapshot {
+  TirtcMediaCodec codec;
+} TirtcMediaDownlinkAudioDebugSnapshot;
+
+/**
+ * Diagnostic facts currently known by a video downlink.
+ *
+ * The snapshot is a value copy into caller-owned storage. Zero values mean the downlink has not
+ * observed the corresponding fact since start/reset. `requested_decoder_preference` reflects the
+ * configured option; `resolved_decoder_backend` is only set after the runtime locks a concrete
+ * decode route.
+ */
+typedef struct TirtcMediaDownlinkVideoDebugSnapshot {
+  TirtcMediaCodec codec;
+  TirtcVideoBitstreamFormat bitstream_format;
+  uint32_t width;
+  uint32_t height;
+  TirtcVideoDecoderPreference requested_decoder_preference;
+  TirtcVideoDecoderBackendKind resolved_decoder_backend;
+} TirtcMediaDownlinkVideoDebugSnapshot;
+
 TirtcError tirtc_media_downlink_audio_create(TirtcMediaDownlinkAudio** out_downlink);
 void tirtc_media_downlink_audio_retain(TirtcMediaDownlinkAudio* downlink);
 void tirtc_media_downlink_audio_release(TirtcMediaDownlinkAudio* downlink);
@@ -147,6 +174,24 @@ TirtcError tirtc_media_downlink_video_get_metrics_snapshot(
     TirtcMediaDownlinkVideo* downlink, TirtcMediaDownlinkVideoMetricsSnapshot* out_snapshot);
 void tirtc_media_downlink_video_reset_metrics_session(TirtcMediaDownlinkVideo* downlink);
 
+/**
+ * Copies the current audio downlink diagnostic snapshot.
+ *
+ * This call does not start, stop, flush, or otherwise change the downlink. It returns
+ * `TIRTC_ERROR_INVALID_ARGUMENT` when `downlink` or `out_snapshot` is null.
+ */
+TirtcError tirtc_media_downlink_audio_get_debug_snapshot(
+    TirtcMediaDownlinkAudio* downlink, TirtcMediaDownlinkAudioDebugSnapshot* out_snapshot);
+
+/**
+ * Copies the current video downlink diagnostic snapshot.
+ *
+ * This call does not start, stop, flush, or otherwise change the downlink. It returns
+ * `TIRTC_ERROR_INVALID_ARGUMENT` when `downlink` or `out_snapshot` is null.
+ */
+TirtcError tirtc_media_downlink_video_get_debug_snapshot(
+    TirtcMediaDownlinkVideo* downlink, TirtcMediaDownlinkVideoDebugSnapshot* out_snapshot);
+
 #ifdef __cplusplus
 }
 #endif