tirtc-devtools-cli 0.0.1

package/vendor/app-server/bin/runtime/macos-arm64/include/tirtc/trp.h

@@ -0,0 +1,541 @@
+#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
+
+/**
+ * @file tirtc/trp.h
+ * @brief Base transport-facing facade API for TiRTC.
+ *
+ * This header defines the public control-plane contract that every higher
+ * facade layer builds on.
+ *
+ * Typical usage:
+ * 1. Call ::tirtc_init once for the process.
+ * 2. Either start a service with ::tirtc_conn_service_start, or create a
+ *    standalone connection with ::tirtc_conn_create and then connect it with
+ *    ::tirtc_conn_connect.
+ * 3. Install observers if the caller needs connection, command, or stream
+ *    callbacks.
+ * 4. Exchange stream messages and commands while the connection is alive.
+ * 5. Explicitly close resources with the matching stop, disconnect, destroy,
+ *    and uninit calls.
+ *
+ * Higher-level headers extend this contract rather than replace it:
+ * - `tirtc/audio.h` adds audio input and audio output objects.
+ * - `tirtc/av.h` adds video input and video output objects.
+ *
+ * Ownership model:
+ * - The caller owns every public handle returned by this facade.
+ * - The runtime owns internal transport and media pipelines.
+ * - Public handles must be released with their documented matching API.
+ */
+
+/**
+ * @brief Global runtime options passed to ::tirtc_init.
+ *
+ * The runtime resolves the effective endpoint during initialization and copies
+ * the values it needs. String pointers only need to remain valid for the
+ * duration of the ::tirtc_init call.
+ */
+typedef struct TirtcOptions {
+  /**
+   * @brief Optional explicit service endpoint.
+   *
+   * When non-NULL and not empty, this value overrides the built-in endpoint
+   * selected by ::environment.
+   */
+  const char* endpoint;
+
+  /**
+   * @brief Optional directory used to initialize file logging.
+   *
+   * Pass NULL or an empty string to disable file logging.
+   */
+  const char* log_root_dir;
+
+  /**
+   * @brief Non-zero to enable console logging; zero to disable it.
+   */
+  int enable_console_log;
+
+  /**
+   * @brief Built-in environment selector used when ::endpoint is not supplied.
+   *
+   * The current implementation recognizes these values:
+   * - `0`: test
+   * - `1`: pre-production
+   * - `2`: production
+   *
+   * Any other value currently falls back to the production endpoint.
+   */
+  int environment;
+} TirtcOptions;
+
+/**
+ * @brief Options for starting a service-side connection listener.
+ *
+ * A service accepts inbound transport connections and exposes them through
+ * ::TirtcConnServiceObserver.on_connected.
+ */
+typedef struct TirtcConnServiceStartOptions {
+  /**
+   * @brief Non-empty service license string.
+   *
+   * This field is required.
+   */
+  const char* license;
+
+  /**
+   * @brief Maximum number of concurrently accepted connections.
+   *
+   * This is a service-level capacity contract. It applies to the listener as a
+   * whole, not to any single connection and not to any individual stream.
+   *
+   * This field is required and must be non-zero.
+   */
+  uint32_t max_connections;
+} TirtcConnServiceStartOptions;
+
+/**
+ * @brief Options for connecting an outbound connection object.
+ */
+typedef struct TirtcConnConnectOptions {
+  /**
+   * @brief Remote peer identifier.
+   *
+   * This field is required and must be non-empty.
+   */
+  const char* peer_id;
+
+  /**
+   * @brief Authentication or session token embedded into the transport
+   * descriptor.
+   *
+   * This field is required and must be non-empty.
+   */
+  const char* token;
+} TirtcConnConnectOptions;
+
+/** @brief Opaque handle returned by ::tirtc_conn_service_start. */
+typedef struct TirtcConnService TirtcConnService;
+
+/**
+ * @brief Opaque connection handle.
+ *
+ * A handle may come from either ::tirtc_conn_create or a service observer's
+ * ::TirtcConnServiceObserver.on_connected callback.
+ */
+typedef struct TirtcConn TirtcConn;
+
+/**
+ * @brief High-level connection state reported through ::TirtcConnObserver.
+ */
+typedef enum TirtcConnState {
+  /** Connection exists but has not started connecting yet. */
+  TIRTC_CONN_STATE_IDLE = 0,
+
+  /** Connection establishment is in progress. */
+  TIRTC_CONN_STATE_CONNECTING = 1,
+
+  /** Transport is connected and ready for control or media attachment. */
+  TIRTC_CONN_STATE_CONNECTED = 2,
+
+  /** Connection has entered its terminal disconnected state. */
+  TIRTC_CONN_STATE_DISCONNECTED = 3,
+} TirtcConnState;
+
+/**
+ * @brief Reason associated with a disconnected connection.
+ */
+typedef enum TirtcConnDisconnectReason {
+  /** The implementation could not determine a more specific reason. */
+  TIRTC_CONN_DISCONNECT_REASON_UNKNOWN = 0,
+
+  /** The local side closed the connection intentionally. */
+  TIRTC_CONN_DISCONNECT_REASON_LOCAL_CLOSED = 1,
+
+  /** The remote side closed the connection. */
+  TIRTC_CONN_DISCONNECT_REASON_REMOTE_CLOSED = 2,
+
+  /** Initial connection setup failed. */
+  TIRTC_CONN_DISCONNECT_REASON_CONNECT_FAILED = 3,
+
+  /** Descriptor exchange or validation failed. */
+  TIRTC_CONN_DISCONNECT_REASON_INVALID_DESCRIPTOR = 4,
+
+  /** The underlying transport backend reported an internal failure. */
+  TIRTC_CONN_DISCONNECT_REASON_BACKEND_ERROR = 5,
+} TirtcConnDisconnectReason;
+
+/**
+ * @brief Binary stream-message payload.
+ *
+ * Stream messages are intended for lightweight application-defined payloads on
+ * stream identifiers that are not currently reserved by attached audio or video
+ * routes.
+ */
+typedef struct TirtcStreamMessage {
+  /** @brief Sender-defined timestamp in milliseconds. */
+  uint32_t timestamp_ms;
+
+  /**
+   * @brief Pointer to payload bytes.
+   *
+   * The pointer may be NULL only when ::length is zero.
+   */
+  const void* data;
+
+  /** @brief Payload size in bytes. */
+  size_t length;
+} TirtcStreamMessage;
+
+/**
+ * @brief Fire-and-forget command payload.
+ */
+typedef struct TirtcConnCommand {
+  /** @brief Application-defined command identifier. */
+  uint16_t command_id;
+
+  /** @brief Payload bytes, or NULL when ::length is zero. */
+  const void* data;
+
+  /** @brief Payload size in bytes. */
+  size_t length;
+} TirtcConnCommand;
+
+/**
+ * @brief Request payload for an asynchronous command round-trip.
+ */
+typedef struct TirtcConnCommandRequest {
+  /** @brief Application-defined command identifier. */
+  uint16_t command_id;
+
+  /** @brief Payload bytes, or NULL when ::length is zero. */
+  const void* data;
+
+  /** @brief Payload size in bytes. */
+  size_t length;
+
+  /**
+   * @brief Response timeout in milliseconds.
+   *
+   * A value of zero is currently treated as a minimal non-zero timeout rather
+   * than an infinite wait.
+   */
+  uint32_t timeout_ms;
+} TirtcConnCommandRequest;
+
+/**
+ * @brief Response payload returned by a remote peer or local reply logic.
+ */
+typedef struct TirtcConnCommandResponse {
+  /** @brief Application-defined command identifier. */
+  uint16_t command_id;
+
+  /** @brief Payload bytes, or NULL when ::length is zero. */
+  const void* data;
+
+  /** @brief Payload size in bytes. */
+  size_t length;
+} TirtcConnCommandResponse;
+
+/**
+ * @brief Completion callback used by ::tirtc_conn_request_command.
+ *
+ * The callback may complete because of a successful response, a send failure,
+ * a timeout, or a disconnect. The callback is not invoked after the connection
+ * has been destroyed.
+ *
+ * Delivery may be synchronous or asynchronous:
+ * - If request submission fails immediately, the callback may run before
+ *   ::tirtc_conn_request_command returns.
+ * - After request submission succeeds, completion is reported later from the
+ *   transport or timeout path.
+ *
+ * Callers must not assume a fixed callback thread, and must write callback
+ * logic so it is safe for reentrant delivery relative to
+ * ::tirtc_conn_request_command and other connection callbacks.
+ *
+ * @param connection Connection that owns the request.
+ * @param error Completion status.
+ * @param response Non-NULL only when a response payload is available.
+ * @param user_data Opaque pointer originally passed to
+ * ::tirtc_conn_request_command.
+ */
+typedef void (*TirtcConnCommandResponseFn)(TirtcConn* connection, TirtcError error,
+                                           const TirtcConnCommandResponse* response,
+                                           void* user_data);
+
+/**
+ * @brief Optional observer for service lifecycle and accepted connections.
+ *
+ * The implementation copies this structure when the service starts. The
+ * structure itself does not need to remain alive after
+ * ::tirtc_conn_service_start returns.
+ */
+typedef struct TirtcConnServiceObserver {
+  /** @brief Called after the service has started successfully. */
+  void (*on_started)(TirtcConnService* service, void* user_data);
+
+  /** @brief Called after the service has stopped successfully. */
+  void (*on_stopped)(TirtcConnService* service, void* user_data);
+
+  /**
+   * @brief Called for each inbound connection accepted by the service.
+   *
+   * Ownership of the returned ::TirtcConn handle belongs to the caller. The
+   * caller must eventually disconnect and destroy that connection.
+   *
+   * The runtime will not dispatch other user-facing callbacks for that
+   * accepted connection until this callback returns. Callers that need full
+   * callback coverage should install the connection observer synchronously
+   * inside this callback before returning.
+   */
+  void (*on_connected)(TirtcConnService* service, TirtcConn* connection, void* user_data);
+
+  /**
+   * @brief Called when the service reports an error or a promoted system event.
+   */
+  void (*on_error)(TirtcConnService* service, TirtcError error, const char* message,
+                   void* user_data);
+} TirtcConnServiceObserver;
+
+/**
+ * @brief Optional observer for connection lifecycle and control-plane events.
+ *
+ * The implementation stores a copy of this structure. Passing NULL to
+ * ::tirtc_conn_set_observer clears the current observer.
+ *
+ * Replay contract:
+ * - Installing or replacing an observer immediately replays the current state.
+ * - If the connection has already disconnected, the terminal disconnected
+ *   callback is replayed as part of observer installation.
+ *
+ * Callback threading is not restricted to a single caller thread. Some
+ * callbacks may be replayed synchronously by API calls such as
+ * ::tirtc_conn_set_observer, while others may arrive asynchronously from the
+ * internal transport layer.
+ */
+typedef struct TirtcConnObserver {
+  /** @brief Called when the connection state changes or is replayed. */
+  void (*on_state_changed)(TirtcConn* connection, TirtcConnState state, void* user_data);
+
+  /**
+   * @brief Called when the connection enters DISCONNECTED, or when that
+   * terminal state is replayed to a newly installed observer.
+   */
+  void (*on_disconnected)(TirtcConn* connection, TirtcConnDisconnectReason reason, void* user_data);
+
+  /**
+   * @brief Called for an inbound command request that expects a reply.
+   *
+   * The supplied ::remote_request_id remains valid only while the request is
+   * still pending on this connection. In the common case, reply exactly once
+   * with ::tirtc_conn_reply_remote_command.
+   */
+  void (*on_remote_command_request)(TirtcConn* connection, uint64_t remote_request_id,
+                                    const TirtcConnCommand* command, void* user_data);
+
+  /**
+   * @brief Called when an application-defined stream message is received.
+   */
+  void (*on_stream_message)(TirtcConn* connection, uint8_t stream_id,
+                            const TirtcStreamMessage* message, void* user_data);
+
+  /** @brief Called when the transport reports an error for this connection. */
+  void (*on_error)(TirtcConn* connection, TirtcError error, const char* message, void* user_data);
+} TirtcConnObserver;
+
+/**
+ * @brief Initialize the global runtime.
+ *
+ * Call this exactly once before creating services, connections, audio objects,
+ * or video objects.
+ *
+ * @param options Non-NULL runtime options.
+ * @return ::TIRTC_ERROR_OK on success, or an error code when initialization
+ * fails or the runtime is already initialized.
+ */
+TirtcError tirtc_init(const TirtcOptions* options);
+
+/**
+ * @brief Shut down the global runtime.
+ *
+ * This function is intentionally conservative. If any public handles are still
+ * alive, the current implementation leaves the runtime initialized and returns
+ * without tearing it down. Destroy every connection, stop every service, and
+ * destroy every media object before calling this function.
+ */
+void tirtc_uninit(void);
+
+/**
+ * @brief Start a service-side listener.
+ *
+ * Only one live service is supported at a time.
+ *
+ * @param options Non-NULL start options with a non-empty license and a non-zero
+ * max_connections.
+ * @param observer Optional observer copied by value.
+ * @param user_data Opaque pointer returned to observer callbacks.
+ * @param out_service Receives the created service handle on success.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_conn_service_start(const TirtcConnServiceStartOptions* options,
+                                    const TirtcConnServiceObserver* observer, void* user_data,
+                                    TirtcConnService** out_service);
+
+/**
+ * @brief Stop a service handle.
+ *
+ * Accepted connections are separate resources and are not destroyed by stopping
+ * the service. Each accepted ::TirtcConn remains the caller's responsibility.
+ * On success, the service handle is released and must not be used again.
+ *
+ * @param service Service handle to stop.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_conn_service_stop(TirtcConnService* service);
+
+/**
+ * @brief Allocate a standalone connection handle.
+ *
+ * The runtime must already be initialized. The returned handle starts in
+ * ::TIRTC_CONN_STATE_IDLE and must be released with ::tirtc_conn_destroy.
+ *
+ * @param out_connection Receives the created connection handle on success.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_conn_create(TirtcConn** out_connection);
+
+/**
+ * @brief Install, replace, or clear the connection observer.
+ *
+ * Passing NULL for ::observer clears the current observer and its user data.
+ * The implementation stores a copy of the observer structure and does not
+ * require it to outlive this call.
+ * After a non-NULL observer is installed, the implementation immediately
+ * replays the current state and, when applicable, the terminal disconnected
+ * callback.
+ *
+ * @param connection Target connection.
+ * @param observer Observer to install, or NULL to clear.
+ * @param user_data Opaque pointer returned to observer callbacks.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_conn_set_observer(TirtcConn* connection, const TirtcConnObserver* observer,
+                                   void* user_data);
+
+/**
+ * @brief Connect a standalone connection handle to a remote peer.
+ *
+ * This function is valid only for handles created by ::tirtc_conn_create.
+ * Connections accepted from a service are already transport-owned and cannot be
+ * manually connected again.
+ *
+ * After a disconnect, the same handle may be connected again.
+ *
+ * @param connection Target connection created by ::tirtc_conn_create.
+ * @param options Non-NULL connect options with non-empty peer and token values.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_conn_connect(TirtcConn* connection, const TirtcConnConnectOptions* options);
+
+/**
+ * @brief Disconnect a connection.
+ *
+ * This call is idempotent once the connection is already idle or disconnected.
+ * Disconnecting does not destroy the handle.
+ *
+ * @param connection Target connection.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_conn_disconnect(TirtcConn* connection);
+
+/**
+ * @brief Destroy a connection handle and release its internal transport state.
+ *
+ * Destroying a connection also detaches any currently attached audio or video
+ * objects. Those media objects are not destroyed; they return to an unbound
+ * state and remain owned by the caller.
+ *
+ * After this call returns, the connection handle is invalid and must not be
+ * reused.
+ *
+ * @param connection Connection handle to destroy.
+ */
+void tirtc_conn_destroy(TirtcConn* connection);
+
+/**
+ * @brief Send an application-defined stream message.
+ *
+ * Use a stream identifier that is not currently occupied by an attached audio
+ * input, video input, or video output on the same connection.
+ *
+ * @param connection Target connection.
+ * @param stream_id Application-defined stream identifier for this message.
+ * @param message Non-NULL payload descriptor.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_conn_send_stream_message(TirtcConn* connection, uint8_t stream_id,
+                                          const TirtcStreamMessage* message);
+
+/**
+ * @brief Send an application-defined command without waiting for a response.
+ *
+ * @param connection Target connection.
+ * @param command Non-NULL command payload.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_conn_send_command(TirtcConn* connection, const TirtcConnCommand* command);
+
+/**
+ * @brief Send an application-defined request command and complete it
+ * asynchronously.
+ *
+ * Callback delivery is mixed synchronous/asynchronous. If request submission
+ * fails immediately after the facade has accepted the request, ::callback may
+ * run before this function returns. After request submission succeeds,
+ * completion is reported later from the response, timeout, or disconnect path.
+ *
+ * Once this call returns ::TIRTC_ERROR_OK, expect exactly one completion
+ * callback unless the connection is destroyed first.
+ *
+ * @param connection Target connection.
+ * @param request Non-NULL request payload.
+ * @param callback Completion callback invoked for response, timeout, send
+ * failure, or disconnect.
+ * @param user_data Opaque pointer returned to ::callback.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_conn_request_command(TirtcConn* connection, const TirtcConnCommandRequest* request,
+                                      TirtcConnCommandResponseFn callback, void* user_data);
+
+/**
+ * @brief Reply to an inbound remote command request.
+ *
+ * Use the ::remote_request_id delivered by
+ * ::TirtcConnObserver.on_remote_command_request on the same connection. If the
+ * request is no longer pending, this function returns a not-ready error.
+ * In the normal case, reply at most once for each delivered request id.
+ *
+ * @param connection Target connection.
+ * @param remote_request_id Request id supplied by the observer callback.
+ * @param response Non-NULL response payload.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_conn_reply_remote_command(TirtcConn* connection, uint64_t remote_request_id,
+                                           const TirtcConnCommandResponse* response);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_FACADE_TRP_H_

package/vendor/app-server/bin/runtime/macos-arm64/include/tirtc/video_codec.h

@@ -0,0 +1,58 @@
+#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_request_key_frame(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_

package/vendor/app-server/bin/runtime/macos-arm64/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/app-server/bin/runtime/macos-arm64/include/tirtc/video_io.h

@@ -0,0 +1,46 @@
+#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 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_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_