tirtc-devtools-cli 0.0.1

package/vendor/app-server/bin/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/app-server/bin/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/app-server/bin/runtime/linux-x64/include/tirtc/error.h

@@ -0,0 +1,20 @@
+#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 = 1,
+  TIRTC_ERROR_NOT_INITIALIZED = 2,
+  TIRTC_ERROR_INTERNAL = 3,
+  TIRTC_ERROR_NOT_READY = 4,
+} TirtcError;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_FOUNDATION_ERROR_H_

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

@@ -0,0 +1,53 @@
+#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_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);
+
+#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/app-server/bin/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_

package/vendor/app-server/bin/runtime/linux-x64/include/tirtc/media_downlink.h

@@ -0,0 +1,89 @@
+#ifndef TIRTC_MEDIA_DOWNLINK_H_
+#define TIRTC_MEDIA_DOWNLINK_H_
+
+#include <stdint.h>
+
+#include "tirtc/audio_frame.h"
+#include "tirtc/audio_io.h"
+#include "tirtc/error.h"
+#include "tirtc/video_frame.h"
+#include "tirtc/video_io.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct TirtcMediaDownlinkAudio TirtcMediaDownlinkAudio;
+typedef struct TirtcMediaDownlinkVideo TirtcMediaDownlinkVideo;
+
+typedef enum TirtcMediaDownlinkState {
+  TIRTC_MEDIA_DOWNLINK_STATE_IDLE = 0,
+  TIRTC_MEDIA_DOWNLINK_STATE_RENDERING = 1,
+  TIRTC_MEDIA_DOWNLINK_STATE_BUFFERING = 2,
+  TIRTC_MEDIA_DOWNLINK_STATE_PAUSED = 3,
+  TIRTC_MEDIA_DOWNLINK_STATE_COMPLETED = 4,
+  TIRTC_MEDIA_DOWNLINK_STATE_FAILED = 5,
+} TirtcMediaDownlinkState;
+
+typedef struct TirtcMediaDownlinkAudioOptions {
+  uint32_t volume_percent;
+  int gain_level;
+  int noise_reduction_level;
+} TirtcMediaDownlinkAudioOptions;
+
+typedef struct TirtcMediaDownlinkAudioObserver {
+  void (*on_state_changed)(TirtcMediaDownlinkAudio* downlink, TirtcMediaDownlinkState state,
+                           TirtcError error, void* user_data);
+} TirtcMediaDownlinkAudioObserver;
+
+typedef struct TirtcMediaDownlinkVideoObserver {
+  void (*on_state_changed)(TirtcMediaDownlinkVideo* downlink, TirtcMediaDownlinkState state,
+                           TirtcError error, void* user_data);
+  void (*on_output_size_changed)(TirtcMediaDownlinkVideo* downlink, uint32_t width, uint32_t height,
+                                 void* user_data);
+} TirtcMediaDownlinkVideoObserver;
+
+TirtcError tirtc_media_downlink_audio_create(TirtcMediaDownlinkAudio** out_downlink);
+void tirtc_media_downlink_audio_destroy(TirtcMediaDownlinkAudio* downlink);
+TirtcError tirtc_media_downlink_audio_set_aout(TirtcMediaDownlinkAudio* downlink,
+                                               TirtcAudioAout* aout);
+TirtcError tirtc_media_downlink_audio_set_options(TirtcMediaDownlinkAudio* downlink,
+                                                  const TirtcMediaDownlinkAudioOptions* options);
+TirtcError tirtc_media_downlink_audio_set_observer(TirtcMediaDownlinkAudio* downlink,
+                                                   const TirtcMediaDownlinkAudioObserver* observer,
+                                                   void* user_data);
+TirtcError tirtc_media_downlink_audio_clear_observer(TirtcMediaDownlinkAudio* downlink);
+TirtcError tirtc_media_downlink_audio_submit_frame(TirtcMediaDownlinkAudio* downlink,
+                                                   const TirtcAudioEncodedFrame* frame);
+TirtcError tirtc_media_downlink_audio_get_current_pts(TirtcMediaDownlinkAudio* downlink,
+                                                      int64_t* out_pts_us);
+TirtcError tirtc_media_downlink_audio_start(TirtcMediaDownlinkAudio* downlink);
+TirtcError tirtc_media_downlink_audio_stop(TirtcMediaDownlinkAudio* downlink);
+
+TirtcError tirtc_media_downlink_video_create(TirtcMediaDownlinkVideo** out_downlink);
+void tirtc_media_downlink_video_destroy(TirtcMediaDownlinkVideo* downlink);
+TirtcError tirtc_media_downlink_video_set_vout(TirtcMediaDownlinkVideo* downlink,
+                                               TirtcVideoVout* vout);
+TirtcError tirtc_media_downlink_video_set_observer(TirtcMediaDownlinkVideo* downlink,
+                                                   const TirtcMediaDownlinkVideoObserver* observer,
+                                                   void* user_data);
+TirtcError tirtc_media_downlink_video_clear_observer(TirtcMediaDownlinkVideo* downlink);
+TirtcError tirtc_media_downlink_video_submit_frame(TirtcMediaDownlinkVideo* downlink,
+                                                   const TirtcVideoEncodedFrame* frame);
+TirtcError tirtc_media_downlink_video_get_current_pts(TirtcMediaDownlinkVideo* downlink,
+                                                      int64_t* out_pts_us);
+TirtcError tirtc_media_downlink_video_get_output_size(TirtcMediaDownlinkVideo* downlink,
+                                                      uint32_t* out_width, uint32_t* out_height);
+TirtcError tirtc_media_downlink_video_follow_audio(TirtcMediaDownlinkVideo* follower,
+                                                   TirtcMediaDownlinkAudio* source);
+TirtcError tirtc_media_downlink_video_follow_video(TirtcMediaDownlinkVideo* follower,
+                                                   TirtcMediaDownlinkVideo* source);
+TirtcError tirtc_media_downlink_video_use_self_timing(TirtcMediaDownlinkVideo* downlink);
+TirtcError tirtc_media_downlink_video_start(TirtcMediaDownlinkVideo* downlink);
+TirtcError tirtc_media_downlink_video_stop(TirtcMediaDownlinkVideo* downlink);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_MEDIA_DOWNLINK_H_

package/vendor/app-server/bin/runtime/linux-x64/include/tirtc/media_uplink.h

@@ -0,0 +1,115 @@
+#ifndef TIRTC_MEDIA_UPLINK_H_
+#define TIRTC_MEDIA_UPLINK_H_
+
+#include <stdint.h>
+
+#include "tirtc/audio_frame.h"
+#include "tirtc/audio_io.h"
+#include "tirtc/audio_processing.h"
+#include "tirtc/error.h"
+#include "tirtc/media_codec.h"
+#include "tirtc/video_frame.h"
+#include "tirtc/video_io.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct TirtcMediaUplinkPtsSource TirtcMediaUplinkPtsSource;
+typedef struct TirtcMediaUplinkAudio TirtcMediaUplinkAudio;
+typedef struct TirtcMediaUplinkVideo TirtcMediaUplinkVideo;
+
+typedef enum TirtcMediaUplinkState {
+  TIRTC_MEDIA_UPLINK_STATE_IDLE = 0,
+  TIRTC_MEDIA_UPLINK_STATE_RUNNING = 1,
+  TIRTC_MEDIA_UPLINK_STATE_PAUSED = 2,
+  TIRTC_MEDIA_UPLINK_STATE_STOPPED = 3,
+  TIRTC_MEDIA_UPLINK_STATE_FAILED = 4,
+} TirtcMediaUplinkState;
+
+typedef struct TirtcMediaUplinkAudioOptions {
+  TirtcAudioSampleRate sample_rate;
+  TirtcAudioAecMode aec_mode;
+  TirtcAudioAgcLevel agc_level;
+  TirtcAudioAnsLevel ans_level;
+} TirtcMediaUplinkAudioOptions;
+
+typedef struct TirtcMediaUplinkVideoOptions {
+  TirtcMediaCodec codec;
+  uint32_t width;
+  uint32_t height;
+  uint32_t fps;
+  uint32_t bitrate_kbps;
+} TirtcMediaUplinkVideoOptions;
+
+typedef struct TirtcMediaUplinkAudioSink {
+  void (*on_encoded_frame)(TirtcMediaUplinkAudio* uplink, const TirtcAudioEncodedFrame* frame,
+                           void* user_data);
+} TirtcMediaUplinkAudioSink;
+
+typedef struct TirtcMediaUplinkVideoSink {
+  void (*on_encoded_frame)(TirtcMediaUplinkVideo* uplink, const TirtcVideoEncodedFrame* frame,
+                           void* user_data);
+} TirtcMediaUplinkVideoSink;
+
+typedef struct TirtcMediaUplinkAudioObserver {
+  void (*on_state_changed)(TirtcMediaUplinkAudio* uplink, TirtcMediaUplinkState state,
+                           TirtcError error, void* user_data);
+} TirtcMediaUplinkAudioObserver;
+
+typedef struct TirtcMediaUplinkVideoObserver {
+  void (*on_state_changed)(TirtcMediaUplinkVideo* uplink, TirtcMediaUplinkState state,
+                           TirtcError error, void* user_data);
+  void (*on_output_size_changed)(TirtcMediaUplinkVideo* uplink, uint32_t width, uint32_t height,
+                                 void* user_data);
+} TirtcMediaUplinkVideoObserver;
+
+TirtcError tirtc_media_uplink_pts_source_create(TirtcMediaUplinkPtsSource** out_pts_source);
+void tirtc_media_uplink_pts_source_destroy(TirtcMediaUplinkPtsSource* pts_source);
+
+TirtcError tirtc_media_uplink_audio_create(TirtcMediaUplinkAudio** out_uplink);
+void tirtc_media_uplink_audio_destroy(TirtcMediaUplinkAudio* uplink);
+TirtcError tirtc_media_uplink_audio_set_pts_source(TirtcMediaUplinkAudio* uplink,
+                                                   TirtcMediaUplinkPtsSource* pts_source);
+TirtcError tirtc_media_uplink_audio_set_ain(TirtcMediaUplinkAudio* uplink, TirtcAudioAin* ain);
+TirtcError tirtc_media_uplink_audio_set_options(TirtcMediaUplinkAudio* uplink,
+                                                const TirtcMediaUplinkAudioOptions* options);
+TirtcError tirtc_media_uplink_audio_set_sink(TirtcMediaUplinkAudio* uplink,
+                                             const TirtcMediaUplinkAudioSink* sink,
+                                             void* user_data);
+TirtcError tirtc_media_uplink_audio_clear_sink(TirtcMediaUplinkAudio* uplink);
+TirtcError tirtc_media_uplink_audio_set_observer(TirtcMediaUplinkAudio* uplink,
+                                                 const TirtcMediaUplinkAudioObserver* observer,
+                                                 void* user_data);
+TirtcError tirtc_media_uplink_audio_clear_observer(TirtcMediaUplinkAudio* uplink);
+TirtcError tirtc_media_uplink_audio_start(TirtcMediaUplinkAudio* uplink);
+TirtcError tirtc_media_uplink_audio_stop(TirtcMediaUplinkAudio* uplink);
+
+TirtcError tirtc_media_uplink_video_create(TirtcMediaUplinkVideo** out_uplink);
+void tirtc_media_uplink_video_destroy(TirtcMediaUplinkVideo* uplink);
+TirtcError tirtc_media_uplink_video_set_pts_source(TirtcMediaUplinkVideo* uplink,
+                                                   TirtcMediaUplinkPtsSource* pts_source);
+TirtcError tirtc_media_uplink_video_set_vin(TirtcMediaUplinkVideo* uplink, TirtcVideoVin* vin);
+TirtcError tirtc_media_uplink_video_set_options(TirtcMediaUplinkVideo* uplink,
+                                                const TirtcMediaUplinkVideoOptions* options);
+TirtcError tirtc_media_uplink_video_set_sink(TirtcMediaUplinkVideo* uplink,
+                                             const TirtcMediaUplinkVideoSink* sink,
+                                             void* user_data);
+TirtcError tirtc_media_uplink_video_clear_sink(TirtcMediaUplinkVideo* uplink);
+TirtcError tirtc_media_uplink_video_set_observer(TirtcMediaUplinkVideo* uplink,
+                                                 const TirtcMediaUplinkVideoObserver* observer,
+                                                 void* user_data);
+TirtcError tirtc_media_uplink_video_clear_observer(TirtcMediaUplinkVideo* uplink);
+TirtcError tirtc_media_uplink_video_set_preview_vout(TirtcMediaUplinkVideo* uplink,
+                                                     TirtcVideoVout* vout);
+TirtcError tirtc_media_uplink_video_clear_preview_vout(TirtcMediaUplinkVideo* uplink);
+TirtcError tirtc_media_uplink_video_get_output_size(TirtcMediaUplinkVideo* uplink,
+                                                    uint32_t* out_width, uint32_t* out_height);
+TirtcError tirtc_media_uplink_video_start(TirtcMediaUplinkVideo* uplink);
+TirtcError tirtc_media_uplink_video_stop(TirtcMediaUplinkVideo* uplink);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_MEDIA_UPLINK_H_

package/vendor/app-server/bin/runtime/linux-x64/include/tirtc/runtime.h

@@ -0,0 +1,236 @@
+#ifndef TIRTC_FACADE_RUNTIME_H_
+#define TIRTC_FACADE_RUNTIME_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "tirtc/audio_io.h"
+#include "tirtc/audio_processing.h"
+#include "tirtc/error.h"
+#include "tirtc/media_codec.h"
+#include "tirtc/video_io.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct TirtcOptions {
+  const char* endpoint;
+} TirtcOptions;
+
+typedef struct TirtcConnServiceStartOptions {
+  const char* license;
+} TirtcConnServiceStartOptions;
+
+typedef struct TirtcConnOptions {
+  const char* peer_id;
+  const char* token;
+} TirtcConnOptions;
+
+typedef struct TirtcConnService TirtcConnService;
+typedef struct TirtcConn TirtcConn;
+typedef struct TirtcAudioInput TirtcAudioInput;
+typedef struct TirtcAudioOutput TirtcAudioOutput;
+typedef struct TirtcVideoInput TirtcVideoInput;
+typedef struct TirtcVideoOutput TirtcVideoOutput;
+
+typedef enum TirtcConnState {
+  TIRTC_CONN_STATE_CONNECTING = 1,
+  TIRTC_CONN_STATE_CONNECTED = 2,
+  TIRTC_CONN_STATE_DISCONNECTED = 3,
+} TirtcConnState;
+
+typedef enum TirtcConnDisconnectReason {
+  TIRTC_CONN_DISCONNECT_REASON_UNKNOWN = 0,
+  TIRTC_CONN_DISCONNECT_REASON_LOCAL_CLOSED = 1,
+  TIRTC_CONN_DISCONNECT_REASON_REMOTE_CLOSED = 2,
+  TIRTC_CONN_DISCONNECT_REASON_CONNECT_FAILED = 3,
+  TIRTC_CONN_DISCONNECT_REASON_INVALID_DESCRIPTOR = 4,
+  TIRTC_CONN_DISCONNECT_REASON_BACKEND_ERROR = 5,
+} TirtcConnDisconnectReason;
+
+typedef enum TirtcInputState {
+  TIRTC_INPUT_STATE_IDLE = 0,
+  TIRTC_INPUT_STATE_RUNNING = 1,
+  TIRTC_INPUT_STATE_PAUSED = 2,
+  TIRTC_INPUT_STATE_STOPPED = 3,
+  TIRTC_INPUT_STATE_FAILED = 4,
+} TirtcInputState;
+
+typedef enum TirtcAudioOutputState {
+  TIRTC_AUDIO_OUTPUT_STATE_IDLE = 0,
+  TIRTC_AUDIO_OUTPUT_STATE_PLAYING = 1,
+  TIRTC_AUDIO_OUTPUT_STATE_BUFFERING = 2,
+  TIRTC_AUDIO_OUTPUT_STATE_PAUSED = 3,
+  TIRTC_AUDIO_OUTPUT_STATE_COMPLETED = 4,
+  TIRTC_AUDIO_OUTPUT_STATE_FAILED = 5,
+} TirtcAudioOutputState;
+
+typedef enum TirtcVideoOutputState {
+  TIRTC_VIDEO_OUTPUT_STATE_IDLE = 0,
+  TIRTC_VIDEO_OUTPUT_STATE_RENDERING = 1,
+  TIRTC_VIDEO_OUTPUT_STATE_BUFFERING = 2,
+  TIRTC_VIDEO_OUTPUT_STATE_PAUSED = 3,
+  TIRTC_VIDEO_OUTPUT_STATE_COMPLETED = 4,
+  TIRTC_VIDEO_OUTPUT_STATE_FAILED = 5,
+} TirtcVideoOutputState;
+
+typedef struct TirtcStreamMessage {
+  uint32_t timestamp_ms;
+  const void* data;
+  size_t length;
+} TirtcStreamMessage;
+
+typedef struct TirtcCommand {
+  uint16_t sequence_number;
+  uint16_t command_id;
+  uint8_t is_response;
+  const void* data;
+  size_t length;
+} TirtcCommand;
+
+typedef struct TirtcConnServiceObserver {
+  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);
+} TirtcConnServiceObserver;
+
+typedef struct TirtcConnObserver {
+  void (*on_state_changed)(TirtcConn* connection, TirtcConnState state, void* user_data);
+  void (*on_disconnected)(TirtcConn* connection, TirtcConnDisconnectReason reason, void* user_data);
+  void (*on_stream_message)(TirtcConn* connection, uint8_t stream_id,
+                            const TirtcStreamMessage* message, void* user_data);
+  void (*on_command)(TirtcConn* connection, const TirtcCommand* command, void* user_data);
+  void (*on_error)(TirtcConn* connection, TirtcError error, const char* message, void* user_data);
+  void (*on_request_iframe)(TirtcConn* connection, uint8_t stream_id, void* user_data);
+  int (*on_request_video)(TirtcConn* connection, uint8_t stream_id, void* user_data);
+  void (*on_release_video)(TirtcConn* connection, uint8_t stream_id, void* user_data);
+  int (*on_request_audio)(TirtcConn* connection, uint8_t stream_id, void* user_data);
+  void (*on_release_audio)(TirtcConn* connection, uint8_t stream_id, void* user_data);
+} TirtcConnObserver;
+
+typedef struct TirtcAudioInputOptions {
+  TirtcAudioSampleRate sample_rate;
+  TirtcAudioAecMode aec_mode;
+  TirtcAudioAgcLevel agc_level;
+  TirtcAudioAnsLevel ans_level;
+} TirtcAudioInputOptions;
+
+typedef struct TirtcAudioOutputOptions {
+  uint32_t volume_percent;
+  int gain_level;
+  int noise_reduction_level;
+} TirtcAudioOutputOptions;
+
+typedef struct TirtcVideoInputOptions {
+  TirtcMediaCodec codec;
+  uint32_t width;
+  uint32_t height;
+  uint32_t fps;
+  uint32_t bitrate_kbps;
+} TirtcVideoInputOptions;
+
+typedef struct TirtcAudioInputObserver {
+  void (*on_state_changed)(TirtcAudioInput* input, TirtcInputState state, TirtcError error,
+                           void* user_data);
+} TirtcAudioInputObserver;
+
+typedef struct TirtcVideoInputObserver {
+  void (*on_state_changed)(TirtcVideoInput* input, TirtcInputState state, TirtcError error,
+                           void* user_data);
+  void (*on_output_size_changed)(TirtcVideoInput* input, uint32_t width, uint32_t height,
+                                 void* user_data);
+} TirtcVideoInputObserver;
+
+typedef struct TirtcAudioOutputObserver {
+  void (*on_state_changed)(TirtcAudioOutput* output, TirtcAudioOutputState state, TirtcError error,
+                           void* user_data);
+} TirtcAudioOutputObserver;
+
+typedef struct TirtcVideoOutputObserver {
+  void (*on_state_changed)(TirtcVideoOutput* output, TirtcVideoOutputState state, TirtcError error,
+                           void* user_data);
+  void (*on_output_size_changed)(TirtcVideoOutput* output, uint32_t width, uint32_t height,
+                                 void* user_data);
+} TirtcVideoOutputObserver;
+
+TirtcError tirtc_init(const TirtcOptions* options);
+void tirtc_uninit(void);
+
+TirtcError tirtc_conn_service_start(const TirtcConnServiceStartOptions* options,
+                                    const TirtcConnServiceObserver* observer, void* user_data,
+                                    TirtcConnService** out_service);
+TirtcError tirtc_conn_service_stop(TirtcConnService* service);
+
+TirtcError tirtc_connect(const TirtcConnOptions* options, TirtcConn** out_connection);
+TirtcError tirtc_conn_set_observer(TirtcConn* connection, const TirtcConnObserver* observer,
+                                   void* user_data);
+TirtcError tirtc_disconnect(TirtcConn* connection);
+void tirtc_conn_destroy(TirtcConn* connection);
+
+TirtcError tirtc_send_stream_message(TirtcConn* connection, uint8_t stream_id,
+                                     const TirtcStreamMessage* message);
+TirtcError tirtc_send_command(TirtcConn* connection, const TirtcCommand* command);
+TirtcError tirtc_conn_request_iframe(TirtcConn* connection, uint8_t stream_id);
+TirtcError tirtc_conn_request_video(TirtcConn* connection, uint8_t stream_id);
+TirtcError tirtc_conn_release_video(TirtcConn* connection, uint8_t stream_id);
+TirtcError tirtc_conn_request_audio(TirtcConn* connection, uint8_t stream_id);
+TirtcError tirtc_conn_release_audio(TirtcConn* connection, uint8_t stream_id);
+
+TirtcError tirtc_conn_bind_audio_input(TirtcConn* connection, uint8_t stream_id,
+                                       TirtcAudioInput* input);
+TirtcError tirtc_conn_bind_audio_output(TirtcConn* connection, TirtcAudioOutput* output);
+TirtcError tirtc_conn_bind_video_input(TirtcConn* connection, uint8_t stream_id,
+                                       TirtcVideoInput* input);
+TirtcError tirtc_conn_bind_video_output(TirtcConn* connection, uint8_t stream_id,
+                                        TirtcVideoOutput* output);
+TirtcError tirtc_conn_unbind_audio_input(TirtcConn* connection, uint8_t stream_id);
+TirtcError tirtc_conn_unbind_audio_output(TirtcConn* connection);
+TirtcError tirtc_conn_unbind_video_input(TirtcConn* connection, uint8_t stream_id);
+TirtcError tirtc_conn_unbind_video_output(TirtcConn* connection, uint8_t stream_id);
+
+TirtcError tirtc_audio_input_create(TirtcAudioInput** out_input);
+void tirtc_audio_input_destroy(TirtcAudioInput* input);
+TirtcError tirtc_audio_input_set_ain(TirtcAudioInput* input, TirtcAudioAin* ain);
+TirtcError tirtc_audio_input_set_options(TirtcAudioInput* input,
+                                         const TirtcAudioInputOptions* options);
+TirtcError tirtc_audio_input_set_observer(TirtcAudioInput* input,
+                                          const TirtcAudioInputObserver* observer, void* user_data);
+TirtcError tirtc_audio_input_start(TirtcAudioInput* input);
+TirtcError tirtc_audio_input_stop(TirtcAudioInput* input);
+
+TirtcError tirtc_audio_output_create(TirtcAudioOutput** out_output);
+void tirtc_audio_output_destroy(TirtcAudioOutput* output);
+TirtcError tirtc_audio_output_set_aout(TirtcAudioOutput* output, TirtcAudioAout* aout);
+TirtcError tirtc_audio_output_set_options(TirtcAudioOutput* output,
+                                          const TirtcAudioOutputOptions* options);
+TirtcError tirtc_audio_output_set_observer(TirtcAudioOutput* output,
+                                           const TirtcAudioOutputObserver* observer,
+                                           void* user_data);
+
+TirtcError tirtc_video_input_create(TirtcVideoInput** out_input);
+void tirtc_video_input_destroy(TirtcVideoInput* 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_set_preview_output(TirtcVideoInput* input, TirtcVideoOutput* output);
+TirtcError tirtc_video_input_clear_preview_output(TirtcVideoInput* input);
+TirtcError tirtc_video_input_start(TirtcVideoInput* input);
+TirtcError tirtc_video_input_stop(TirtcVideoInput* input);
+
+TirtcError tirtc_video_output_create(TirtcVideoOutput** out_output);
+void tirtc_video_output_destroy(TirtcVideoOutput* output);
+TirtcError tirtc_video_output_set_vout(TirtcVideoOutput* output, TirtcVideoVout* vout);
+TirtcError tirtc_video_output_set_observer(TirtcVideoOutput* output,
+                                           const TirtcVideoOutputObserver* observer,
+                                           void* user_data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_FACADE_RUNTIME_H_

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

@@ -0,0 +1,57 @@
+#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 struct TirtcVideoEncoderConfig {
+  TirtcMediaCodec codec;
+  TirtcVideoBitstreamFormat bitstream_format;
+  uint32_t width;
+  uint32_t height;
+  uint32_t fps;
+  uint32_t bitrate_kbps;
+  TirtcVideoPixelFormat input_pixel_format;
+} 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_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_