tirtc-devtools-cli 0.0.14 → 0.1.0

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

@@ -0,0 +1,208 @@
+#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;
+
+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);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

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

@@ -0,0 +1,63 @@
+#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_INTERNAL = 6002,
+  TIRTC_ERROR_NOT_READY = 6003,
+  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,
+} 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_

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

@@ -0,0 +1,154 @@
+#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/audio_processing.h"
+#include "tirtc/error.h"
+#include "tirtc/video_codec.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_FAILED = 3,
+} TirtcMediaDownlinkState;
+
+typedef struct TirtcMediaDownlinkAudioOptions {
+  uint32_t volume_percent;
+  TirtcAudioAgcLevel agc_level;
+  TirtcAudioAnsLevel ans_level;
+} TirtcMediaDownlinkAudioOptions;
+
+typedef struct TirtcMediaDownlinkVideoOptions {
+  TirtcVideoDecoderPreference decoder_preference;
+} TirtcMediaDownlinkVideoOptions;
+
+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;
+
+typedef struct TirtcMediaDownlinkStutterMetricsSnapshot {
+  int session_started;
+  uint64_t session_duration_ms;
+  uint64_t session_stutter_total_ms;
+  uint32_t session_stutter_count;
+  uint64_t session_stutter_peak_ms;
+  double session_stutter_ratio;
+  uint32_t recent_window_duration_ms;
+  uint64_t recent_window_stutter_total_ms;
+  uint32_t recent_window_stutter_count;
+  uint64_t recent_window_stutter_peak_ms;
+  double recent_window_stutter_ratio;
+} TirtcMediaDownlinkStutterMetricsSnapshot;
+
+typedef struct TirtcMediaDownlinkPendingMetricsSnapshot {
+  uint64_t undecoded_pending_duration_ms;
+  uint64_t decoded_pending_duration_ms;
+} TirtcMediaDownlinkPendingMetricsSnapshot;
+
+typedef struct TirtcMediaDownlinkAudioMetricsSnapshot {
+  TirtcMediaDownlinkStutterMetricsSnapshot stutter;
+  TirtcMediaDownlinkPendingMetricsSnapshot pending;
+} TirtcMediaDownlinkAudioMetricsSnapshot;
+
+typedef struct TirtcMediaDownlinkVideoStartupMetricsSnapshot {
+  int has_first_video_input;
+  int has_first_video_decoded;
+  int has_first_video_rendered;
+  uint64_t first_video_input_monotonic_ms;
+  uint64_t first_video_decoded_monotonic_ms;
+  uint64_t first_video_rendered_monotonic_ms;
+} TirtcMediaDownlinkVideoStartupMetricsSnapshot;
+
+typedef struct TirtcMediaDownlinkVideoMetricsSnapshot {
+  TirtcMediaDownlinkVideoStartupMetricsSnapshot startup;
+  TirtcMediaDownlinkStutterMetricsSnapshot stutter;
+  TirtcMediaDownlinkPendingMetricsSnapshot pending;
+} TirtcMediaDownlinkVideoMetricsSnapshot;
+
+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);
+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_signal_end_of_stream(TirtcMediaDownlinkAudio* downlink);
+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_audio_start_raw_dump(TirtcMediaDownlinkAudio* downlink,
+                                                     const char* prefix);
+TirtcError tirtc_media_downlink_audio_stop_raw_dump(TirtcMediaDownlinkAudio* downlink);
+
+TirtcError tirtc_media_downlink_video_create(TirtcMediaDownlinkVideo** out_downlink);
+void tirtc_media_downlink_video_retain(TirtcMediaDownlinkVideo* downlink);
+void tirtc_media_downlink_video_release(TirtcMediaDownlinkVideo* 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_options(TirtcMediaDownlinkVideo* downlink,
+                                                  const TirtcMediaDownlinkVideoOptions* options);
+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_signal_end_of_stream(TirtcMediaDownlinkVideo* downlink);
+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);
+TirtcError tirtc_media_downlink_video_start_raw_dump(TirtcMediaDownlinkVideo* downlink,
+                                                     const char* prefix);
+TirtcError tirtc_media_downlink_video_stop_raw_dump(TirtcMediaDownlinkVideo* downlink);
+
+TirtcError tirtc_media_downlink_audio_get_metrics_snapshot(
+    TirtcMediaDownlinkAudio* downlink, TirtcMediaDownlinkAudioMetricsSnapshot* out_snapshot);
+void tirtc_media_downlink_audio_reset_metrics_session(TirtcMediaDownlinkAudio* downlink);
+
+TirtcError tirtc_media_downlink_video_get_metrics_snapshot(
+    TirtcMediaDownlinkVideo* downlink, TirtcMediaDownlinkVideoMetricsSnapshot* out_snapshot);
+void tirtc_media_downlink_video_reset_metrics_session(TirtcMediaDownlinkVideo* downlink);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_MEDIA_DOWNLINK_H_