tirtc-devtools-cli 0.0.15 → 0.1.1

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

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

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

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

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

@@ -0,0 +1,236 @@
+#ifndef TIRTC_FACADE_AV_H_
+#define TIRTC_FACADE_AV_H_
+
+#include <stdint.h>
+
+#include "tirtc/audio.h"
+#include "tirtc/media_codec.h"
+#include "tirtc/video_codec.h"
+#include "tirtc/video_io.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct TirtcVideoInput TirtcVideoInput;
+
+typedef struct TirtcVideoEncodedInput TirtcVideoEncodedInput;
+
+typedef struct TirtcVideoOutput TirtcVideoOutput;
+
+typedef enum TirtcVideoOutputState {
+
+  TIRTC_VIDEO_OUTPUT_STATE_IDLE = 0,
+
+  TIRTC_VIDEO_OUTPUT_STATE_BUFFERING = 1,
+
+  TIRTC_VIDEO_OUTPUT_STATE_RENDERING = 2,
+
+  TIRTC_VIDEO_OUTPUT_STATE_FAILED = 3,
+} TirtcVideoOutputState;
+
+typedef struct TirtcVideoOutputStartupMetrics {
+  int has_connect_start;
+  int has_connected;
+  int has_first_video_input;
+  int has_first_video_decoded;
+  int has_first_video_rendered;
+  uint64_t connect_start_monotonic_ms;
+  uint64_t connected_monotonic_ms;
+  uint64_t first_video_input_monotonic_ms;
+  uint64_t first_video_decoded_monotonic_ms;
+  uint64_t first_video_rendered_monotonic_ms;
+} TirtcVideoOutputStartupMetrics;
+
+typedef struct TirtcVideoOutputMetricsSnapshot {
+  TirtcVideoOutputStartupMetrics startup;
+  TirtcOutputStutterMetrics stutter;
+  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;
+
+typedef struct TirtcVideoInputOptions {
+  TirtcMediaCodec codec;
+
+  uint32_t width;
+
+  uint32_t height;
+
+  uint32_t fps;
+
+  uint32_t bitrate_kbps;
+
+  TirtcVideoEncoderPreference encoder_preference;
+} TirtcVideoInputOptions;
+
+/**
+ * Video 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 TirtcVideoInputObserver {
+  void (*on_state_changed)(TirtcVideoInput* input, TirtcInputState state, void* user_data);
+
+  void (*on_output_size_changed)(TirtcVideoInput* input, uint32_t width, uint32_t height,
+                                 void* user_data);
+
+  void (*on_error)(TirtcVideoInput* input, TirtcError error, TirtcOwnedString* owned_message,
+                   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.
+ *
+ * `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 TirtcVideoOutputObserver {
+  void (*on_state_changed)(TirtcVideoOutput* output, TirtcVideoOutputState state, void* user_data);
+
+  void (*on_output_size_changed)(TirtcVideoOutput* output, uint32_t width, uint32_t height,
+                                 void* user_data);
+
+  void (*on_error)(TirtcVideoOutput* output, TirtcError error, TirtcOwnedString* owned_message,
+                   void* user_data);
+} TirtcVideoOutputObserver;
+
+TirtcError tirtc_set_media_trace_enabled(int enabled);
+
+TirtcError tirtc_get_media_trace_enabled(int* out_enabled);
+
+TirtcError tirtc_conn_subscribe_video(TirtcConn* connection, uint8_t stream_id);
+
+TirtcError tirtc_conn_unsubscribe_video(TirtcConn* connection, uint8_t stream_id);
+
+TirtcError tirtc_conn_request_key_frame(TirtcConn* connection, uint8_t stream_id);
+
+TirtcError tirtc_video_input_create(TirtcVideoInput** out_input);
+
+TirtcError tirtc_video_input_set_vin(TirtcVideoInput* input, TirtcVideoVin* vin);
+
+TirtcError tirtc_video_input_set_options(TirtcVideoInput* input,
+                                         const TirtcVideoInputOptions* options);
+
+TirtcError tirtc_video_input_set_observer(TirtcVideoInput* input,
+                                          const TirtcVideoInputObserver* observer, void* user_data);
+
+TirtcError tirtc_video_input_start(TirtcVideoInput* input);
+
+TirtcError tirtc_video_input_stop(TirtcVideoInput* input);
+
+TirtcError tirtc_video_input_attach(TirtcVideoInput* input, TirtcConn* connection,
+                                    uint8_t stream_id);
+
+TirtcError tirtc_video_input_detach(TirtcVideoInput* input, TirtcConn* connection);
+
+TirtcError tirtc_video_input_attach_preview(TirtcVideoInput* input,
+                                            TirtcVideoOutput* preview_output);
+
+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);
+
+TirtcError tirtc_video_output_attach_view(TirtcVideoOutput* output, TirtcVideoVout* view_sink);
+
+TirtcError tirtc_video_output_detach_view(TirtcVideoOutput* output);
+
+TirtcError tirtc_video_output_attach(TirtcVideoOutput* output, TirtcConn* connection,
+                                     uint8_t stream_id);
+
+TirtcError tirtc_video_output_detach(TirtcVideoOutput* output);
+
+void tirtc_video_output_destroy(TirtcVideoOutput* output);
+
+TirtcError tirtc_video_output_start_raw_dump(TirtcVideoOutput* output);
+
+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
+
+#endif

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

@@ -0,0 +1,102 @@
+#ifndef TIRTC_FOUNDATION_ERROR_H_
+#define TIRTC_FOUNDATION_ERROR_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum TirtcError {
+  TIRTC_ERROR_OK = 0,
+  TIRTC_ERROR_INVALID_ARGUMENT = 6000,
+  TIRTC_ERROR_NOT_INITIALIZED = 6001,
+  TIRTC_ERROR_UNSUPPORTED_LOOP_POLICY = 6004,
+  TIRTC_ERROR_SOURCE_HASH_MISMATCH = 6005,
+  TIRTC_ERROR_ALREADY_STOPPED = 6006,
+  TIRTC_ERROR_STOPPED = TIRTC_ERROR_ALREADY_STOPPED,
+  TIRTC_ERROR_ALREADY_DESTROYED = 6007,
+  TIRTC_ERROR_DESTROYED = TIRTC_ERROR_ALREADY_DESTROYED,
+  TIRTC_ERROR_TRANSPORT_INVALID_LICENSE = 6008,
+  TIRTC_ERROR_TRANSPORT_TIMEOUT = 6009,
+  TIRTC_ERROR_TRANSPORT_BUSY = 6010,
+  TIRTC_ERROR_TRANSPORT_CONNECTION_TIMEOUT_CLOSED = 6011,
+  TIRTC_ERROR_TRANSPORT_REMOTE_CLOSED = 6012,
+  TIRTC_ERROR_TRANSPORT_CONNECTION_OTHER_ERROR = 6013,
+  TIRTC_ERROR_TRANSPORT_TOKEN_EXPIRED = 6014,
+  TIRTC_ERROR_DUMP_ROOT_UNAVAILABLE = 6015,
+  TIRTC_ERROR_DUMP_ALREADY_ACTIVE = 6016,
+  TIRTC_ERROR_TRANSPORT_RESOURCE_EXHAUSTED = 6017,
+  TIRTC_ERROR_TRANSPORT_SERVER_ERROR = 6018,
+  TIRTC_ERROR_TRANSPORT_BACKEND_INTERNAL_ERROR = 6019,
+  TIRTC_ERROR_TRANSPORT_NO_SECRET_KEY = 6020,
+  TIRTC_ERROR_TRANSPORT_UNEXPECTED_RESPONSE = 6021,
+  TIRTC_ERROR_ALREADY_INITIALIZED = 6022,
+  TIRTC_ERROR_INVALID_THREAD = 6023,
+  TIRTC_ERROR_PERMISSION_DENIED = 6024,
+  TIRTC_ERROR_ALREADY_BOUND = 6025,
+  TIRTC_ERROR_IN_USE = 6026,
+  TIRTC_ERROR_NOT_STARTED = 6027,
+  TIRTC_ERROR_NOT_CONNECTED = 6028,
+  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,
+  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);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_FOUNDATION_ERROR_H_

package/vendor/runtime/linux-x64/include/tirtc/foundation/build_info.h

@@ -0,0 +1,27 @@
+#ifndef TIRTC_FOUNDATION_BUILD_INFO_H_
+#define TIRTC_FOUNDATION_BUILD_INFO_H_
+
+#include "tirtc/error.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct TirtcBuildInfo {
+  const char* semver_base;
+  const char* semver_effective;
+  const char* commit_hash;
+  int commit_count;
+  const char* build_branch;
+  const char* build_time_utc;
+  const char* version_string;
+} TirtcBuildInfo;
+
+const TirtcBuildInfo* tirtc_build_info_get(void);
+const char* tirtc_build_version_string(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_FOUNDATION_BUILD_INFO_H_

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

@@ -0,0 +1,57 @@
+#ifndef TIRTC_FOUNDATION_HTTP_H_
+#define TIRTC_FOUNDATION_HTTP_H_
+
+#include "tirtc/error.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum TirtcHttpMethod {
+  TIRTC_HTTP_METHOD_GET = 0,
+  TIRTC_HTTP_METHOD_POST = 1,
+  TIRTC_HTTP_METHOD_PUT = 2,
+  TIRTC_HTTP_METHOD_PATCH = 3,
+  TIRTC_HTTP_METHOD_DELETE = 4,
+} TirtcHttpMethod;
+
+typedef struct TirtcHttpHeader {
+  const char* key;
+  const char* value;
+} TirtcHttpHeader;
+
+typedef struct TirtcHttpRequest {
+  const char* scheme;
+  const char* host;
+  int port;
+  const char* path;
+  const char* query;
+  const TirtcHttpHeader* headers;
+  int header_count;
+  const char* body;
+  int body_size;
+  int connect_timeout_ms;
+  int read_timeout_ms;
+  int write_timeout_ms;
+} TirtcHttpRequest;
+
+typedef struct TirtcHttpResponse {
+  int status_code;
+  const char* body;
+  int body_size;
+} TirtcHttpResponse;
+
+typedef TirtcError (*TirtcHttpMockHandler)(const TirtcHttpRequest* request, TirtcHttpMethod method,
+                                           TirtcHttpResponse* response, void* user_data);
+
+TirtcError tirtc_http_request(const TirtcHttpRequest* request, TirtcHttpMethod method,
+                              TirtcHttpResponse* response);
+void tirtc_http_response_dispose(TirtcHttpResponse* response);
+TirtcError tirtc_http_set_mock_handler(TirtcHttpMockHandler handler, void* user_data);
+void tirtc_http_clear_mock_handler(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_FOUNDATION_HTTP_H_

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

@@ -0,0 +1,55 @@
+#ifndef TIRTC_FOUNDATION_LOGGING_H_
+#define TIRTC_FOUNDATION_LOGGING_H_
+
+#include <stdarg.h>
+
+#include "tirtc/error.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum TirtcLogLevel {
+  TIRTC_LOG_LEVEL_VERBOSE = 0,
+  TIRTC_LOG_LEVEL_DEBUG,
+  TIRTC_LOG_LEVEL_INFO,
+  TIRTC_LOG_LEVEL_WARN,
+  TIRTC_LOG_LEVEL_ERROR,
+  TIRTC_LOG_LEVEL_FATAL,
+} TirtcLogLevel;
+
+typedef void (*TirtcLoggingPrintFunction)(const char* prefix, TirtcLogLevel level, const char* tag,
+                                          const char* fmt, va_list args);
+
+#define TIRTC_LOG_PREFIX_DEFAULT "TIRTC_"
+
+TirtcError tirtc_logging_set_print_function(TirtcLoggingPrintFunction function);
+TirtcError tirtc_logging_set_level(TirtcLogLevel level);
+TirtcError tirtc_logging_set_console_enabled(int enabled);
+
+TirtcError tirtc_logging_initialize(const char* root_dir);
+TirtcError tirtc_logging_write(TirtcLogLevel level, const char* tag, const char* message);
+TirtcError tirtc_logging_print(const char* prefix, TirtcLogLevel level, const char* tag,
+                               const char* fmt, ...);
+TirtcError tirtc_logging_flush(void);
+TirtcError tirtc_logging_export(const char* output_zip_path);
+TirtcError tirtc_logging_upload(char* log_id, int log_id_capacity);
+
+#define TIRTC_LOGV(tag, fmt, ...) \
+  tirtc_logging_print(TIRTC_LOG_PREFIX_DEFAULT, TIRTC_LOG_LEVEL_VERBOSE, tag, fmt, ##__VA_ARGS__)
+#define TIRTC_LOGD(tag, fmt, ...) \
+  tirtc_logging_print(TIRTC_LOG_PREFIX_DEFAULT, TIRTC_LOG_LEVEL_DEBUG, tag, fmt, ##__VA_ARGS__)
+#define TIRTC_LOGI(tag, fmt, ...) \
+  tirtc_logging_print(TIRTC_LOG_PREFIX_DEFAULT, TIRTC_LOG_LEVEL_INFO, tag, fmt, ##__VA_ARGS__)
+#define TIRTC_LOGW(tag, fmt, ...) \
+  tirtc_logging_print(TIRTC_LOG_PREFIX_DEFAULT, TIRTC_LOG_LEVEL_WARN, tag, fmt, ##__VA_ARGS__)
+#define TIRTC_LOGE(tag, fmt, ...) \
+  tirtc_logging_print(TIRTC_LOG_PREFIX_DEFAULT, TIRTC_LOG_LEVEL_ERROR, tag, fmt, ##__VA_ARGS__)
+#define TIRTC_LOGF(tag, fmt, ...) \
+  tirtc_logging_print(TIRTC_LOG_PREFIX_DEFAULT, TIRTC_LOG_LEVEL_FATAL, tag, fmt, ##__VA_ARGS__)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_FOUNDATION_LOGGING_H_

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

@@ -0,0 +1,21 @@
+#ifndef TIRTC_MEDIA_CONTRACT_MEDIA_CODEC_H_
+#define TIRTC_MEDIA_CONTRACT_MEDIA_CODEC_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum TirtcMediaCodec {
+  TIRTC_MEDIA_CODEC_NONE = 0,
+  TIRTC_MEDIA_CODEC_AUDIO_G711A = 1,
+  /* Reserved shared identifiers; concrete video implementations live outside media-contract. */
+  TIRTC_MEDIA_CODEC_VIDEO_H264 = 65,
+  TIRTC_MEDIA_CODEC_VIDEO_H265 = 66,
+  TIRTC_MEDIA_CODEC_VIDEO_MJPEG = 67,
+} TirtcMediaCodec;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_MEDIA_CONTRACT_MEDIA_CODEC_H_