tirtc-devtools-cli 0.0.15 → 0.1.0

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

@@ -0,0 +1,187 @@
+/** @file trp.h
+ *  @brief Facade transport-facing public C API.
+ */
+
+#ifndef TIRTC_FACADE_TRP_H_
+#define TIRTC_FACADE_TRP_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "tirtc/error.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct TirtcInitOptions {
+  const char* app_id;
+
+  const char* endpoint;
+
+  const char* log_root_dir;
+
+  int console_log_enabled;
+
+} TirtcInitOptions;
+
+typedef enum TirtcMediaSendPolicy {
+
+  TIRTC_MEDIA_SEND_POLICY_ON_REQUEST = 0,
+
+  TIRTC_MEDIA_SEND_POLICY_AUTO_ON_CONNECTED = 1,
+} TirtcMediaSendPolicy;
+
+typedef struct TirtcConnServiceStartOptions {
+  const char* license;
+
+  uint32_t max_connections;
+
+  TirtcMediaSendPolicy media_send_policy;
+} TirtcConnServiceStartOptions;
+
+typedef struct TirtcConnConnectOptions {
+  const char* remote_id;
+
+  const char* token;
+} TirtcConnConnectOptions;
+
+typedef struct TirtcConnCreateOptions {
+  const struct TirtcConnCallbacks* callbacks;
+
+  void* user_data;
+} TirtcConnCreateOptions;
+
+typedef struct TirtcConnService TirtcConnService;
+
+typedef struct TirtcConn TirtcConn;
+
+typedef enum TirtcConnState {
+
+  TIRTC_CONN_STATE_IDLE = 0,
+
+  TIRTC_CONN_STATE_CONNECTING = 1,
+
+  TIRTC_CONN_STATE_CONNECTED = 2,
+
+  TIRTC_CONN_STATE_DISCONNECTED = 3,
+} TirtcConnState;
+
+typedef struct TirtcStreamMessage {
+  uint32_t timestamp_ms;
+
+  const void* data;
+
+  size_t length;
+} TirtcStreamMessage;
+
+typedef struct TirtcConnCommand {
+  uint32_t command;
+
+  const void* data;
+
+  size_t length;
+} TirtcConnCommand;
+
+typedef struct TirtcConnMetricsSnapshot {
+  int has_connect_start;
+  int has_connected;
+  uint64_t connect_start_monotonic_ms;
+  uint64_t connected_monotonic_ms;
+} TirtcConnMetricsSnapshot;
+
+/** Heap-owned byte payload allocated by facade callback dispatch. */
+typedef struct TirtcOwnedBytes {
+  /** Payload buffer allocated by facade, or `NULL` for zero-length payloads. */
+  void* data;
+
+  /** Number of bytes stored in `data`. */
+  size_t length;
+} TirtcOwnedBytes;
+
+/** Heap-owned UTF-8 string allocated by facade callback dispatch. */
+typedef struct TirtcOwnedString {
+  /** Null-terminated UTF-8 buffer allocated by facade, or `NULL` when no message is available. */
+  char* data;
+} TirtcOwnedString;
+
+typedef struct TirtcConnServiceCallbacks {
+  void (*on_started)(TirtcConnService* service, void* user_data);
+
+  void (*on_stopped)(TirtcConnService* service, void* user_data);
+
+  void (*on_connected)(TirtcConnService* service, TirtcConn* connection, void* user_data);
+
+  void (*on_error)(TirtcConnService* service, TirtcError error, const char* message,
+                   void* user_data);
+} TirtcConnServiceCallbacks;
+
+/**
+ * Connection observer installed through `tirtc_conn_create()` or `tirtc_conn_set_callbacks()`.
+ *
+ * For `on_command()` and `on_stream_message()`, facade copies the variable-length payload to heap
+ * memory before dispatch. The callback receives ownership of that payload and must release it with
+ * `tirtc_owned_bytes_release()` after converting or copying the bytes it needs. The release API is
+ * NULL-safe. If facade cannot allocate an owned copy for a non-empty payload, it drops that
+ * callback delivery rather than dispatching a borrowed pointer.
+ */
+typedef struct TirtcConnCallbacks {
+  void (*on_state_changed)(TirtcConn* connection, TirtcConnState state, TirtcError error,
+                           void* user_data);
+
+  void (*on_command)(TirtcConn* connection, uint32_t command, TirtcOwnedBytes* owned_payload,
+                     void* user_data);
+
+  void (*on_stream_message)(TirtcConn* connection, uint8_t stream_id, uint32_t timestamp_ms,
+                            TirtcOwnedBytes* owned_payload, void* user_data);
+} TirtcConnCallbacks;
+
+TirtcError tirtc_init(const TirtcInitOptions* options);
+
+void tirtc_uninit(void);
+
+TirtcError tirtc_conn_service_start(const TirtcConnServiceStartOptions* options,
+                                    const TirtcConnServiceCallbacks* observer, void* user_data,
+                                    TirtcConnService** out_service);
+
+TirtcError tirtc_conn_service_stop(TirtcConnService* service);
+
+TirtcError tirtc_conn_create(const TirtcConnCreateOptions* options, TirtcConn** out_connection);
+
+TirtcError tirtc_conn_set_callbacks(TirtcConn* connection, const TirtcConnCallbacks* callbacks,
+                                    void* user_data);
+
+TirtcError tirtc_conn_connect(TirtcConn* connection, const TirtcConnConnectOptions* options);
+
+TirtcError tirtc_conn_disconnect(TirtcConn* connection);
+
+void tirtc_conn_destroy(TirtcConn* connection);
+
+TirtcError tirtc_conn_send_stream_message(TirtcConn* connection, uint8_t stream_id,
+                                          const TirtcStreamMessage* message);
+
+/** Copies a stream-message payload into a releasable owned buffer. */
+TirtcOwnedBytes* tirtc_stream_message_copy_payload(const TirtcStreamMessage* message);
+
+/** Copies a command payload into a releasable owned buffer. */
+TirtcOwnedBytes* tirtc_conn_command_copy_payload(const TirtcConnCommand* command);
+
+/** Copies a UTF-8 string into a releasable owned buffer. */
+TirtcOwnedString* tirtc_string_copy_owned(const char* message);
+
+/** Releases a payload received from facade owned-memory callback APIs. Safe to call with `NULL`. */
+void tirtc_owned_bytes_release(TirtcOwnedBytes* owned);
+
+/** Releases a string received from facade owned-memory callback APIs. Safe to call with `NULL`. */
+void tirtc_owned_string_release(TirtcOwnedString* owned);
+
+TirtcError tirtc_conn_send_command(TirtcConn* connection, const TirtcConnCommand* command);
+
+TirtcError tirtc_metrics_conn_get_snapshot(TirtcConn* connection,
+                                           TirtcConnMetricsSnapshot* out_snapshot);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

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

@@ -0,0 +1,99 @@
+#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;
+
+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-30T08:01:24Z
+source_sdk=/Users/allenfeng/Development/Repositories/tirtc-nexus/tirtc-matrix/.build/sdk/linux-x64
+
+e962631f85675937fd973797720466fd75717f74335c8102c664814d59179113  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
+94f378da8bc728a1b9a44fbe74a0367b06ad2401ae55fa5bb6bee63b447ce511  include/tirtc/av.h
+70d0e950f78309e12c927b37a6f7184fe3724edc5391176a697f7d7c7f49ab5a  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
+0d1c3a8d1537a839cb6050fe5b35079087f094673dd9eb5b4d9acdcc9a2dd5fc  include/tirtc/media_downlink.h
+e64191a39004165cdcd11b2ca824af34d4bfe02f7ec3c3101fa9291f56488c30  include/tirtc/media_uplink.h
+489f6c9caa3e4094566b660ef0a002a39c66c1956ef0a1bdb6eacca3798c849a  include/tirtc/transport.h
+bb9c1bf46f2ab51a9f7adb211276c8563b09e7968031c0c6abeebc0eddd66acb  include/tirtc/trp.h
+118593dd6e57d1a982c4b861e7d26f066a4eb4b5f2e152dbf7b7205d87b467f2  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
+80ac9dbdaeb9663399f41611d1bc92a8ee42895b8b38e7d55c25182d90892830  lib/libmatrix_runtime_audio.a
+8833f0f933d73a4c6b10ff3cbbe449e11eb22b2267cb4f2da2fc347782d08d83  lib/libmatrix_runtime_facade.a
+36903d3970287164fa51fe9c2014aa7f654e144a93886c8909904f732ff14d94  lib/libmatrix_runtime_foundation_http.a
+e9a29e7e32a3402bbfdd3fead86ba50a778023ba623de79bc4ab7440797a90a0  lib/libmatrix_runtime_foundation_logging.a
+85c9a5f7ee47279be62c719a3f0efb9b0b5b9724ed3679c38c49900c53105c36  lib/libmatrix_runtime_media.a
+4afd4c0059a4735cd206f4d26669acaa97a367d572c0cc30e51efba198d9817f  lib/libmatrix_runtime_transport.a
+6d57712181cff75b8169753d7217c1a1675c3df4e4a30eca3645c5016cb0b87e  lib/libmatrix_runtime_video.a
+511d521f7972df3993e5976d6e2dbcad7a6fbce9be15071274d0cbd9d51157f5  lib/libssl.a
+a67ec9034848ef24a1b17671e444daa62a8f9e6b8319a1e932593908720ff2a1  lib/libwebrtc_apm.a
+700e455255897e3cffab13ca593a6e4d9d11383ae609215cbbd6043a63d47161  lib/libxlog.a