tirtc-devtools-cli 0.0.1

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

@@ -0,0 +1,452 @@
+#ifndef TIRTC_FACADE_AV_H_
+#define TIRTC_FACADE_AV_H_
+
+#include "tirtc/audio.h"
+#include "tirtc/media_codec.h"
+#include "tirtc/video_io.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @file tirtc/av.h
+ * @brief Audio-video facade layer built on top of `tirtc/audio.h`.
+ *
+ * This header adds local video input, remote video output, preview binding,
+ * and video-specific control helpers to the transport-plus-audio facade.
+ *
+ * Typical uplink flow:
+ * 1. Create a ::TirtcVideoInput.
+ * 2. Bind a concrete capture backend with ::tirtc_video_input_set_vin.
+ * 3. Optionally configure encoding options and observers.
+ * 4. Optionally bind a preview output with
+ *    ::tirtc_video_input_set_preview_output.
+ * 5. Start the input and attach it to a connection stream.
+ * 6. Detach, stop, clear preview, and destroy the input during shutdown.
+ *
+ * Typical downlink flow:
+ * 1. Create a ::TirtcVideoOutput.
+ * 2. Bind a concrete render backend with ::tirtc_video_output_set_vout.
+ * 3. Optionally install an observer.
+ * 4. Attach the output to a connection stream.
+ * 5. Detach and destroy the output during shutdown.
+ *
+ * Important exclusivity rule:
+ * one ::TirtcVideoOutput can serve only one consumer at a time. It may be used
+ * either as a local preview target for one ::TirtcVideoInput or as a remote
+ * display target for one connection stream, but not both at once.
+ *
+ * Ownership model:
+ * - The caller owns all video input and output handles.
+ * - Attaching to a connection or binding a preview output is non-owning.
+ * - Destroying a connection detaches remote-bound video objects but does not
+ *   destroy them.
+ * - Destroying a video input clears its preview binding but does not destroy
+ *   the preview output object.
+ */
+
+/** @brief Opaque video uplink handle. */
+typedef struct TirtcVideoInput TirtcVideoInput;
+
+/** @brief Opaque video downlink or preview output handle. */
+typedef struct TirtcVideoOutput TirtcVideoOutput;
+
+/**
+ * @brief Video output state reported through ::TirtcVideoOutputObserver.
+ */
+typedef enum TirtcVideoOutputState {
+  /** Output is attached but not currently rendering frames. */
+  TIRTC_VIDEO_OUTPUT_STATE_IDLE = 0,
+
+  /** Output is actively rendering frames. */
+  TIRTC_VIDEO_OUTPUT_STATE_RENDERING = 1,
+
+  /** Output is waiting for frames or recovering from a transient failure. */
+  TIRTC_VIDEO_OUTPUT_STATE_BUFFERING = 2,
+
+  /** Reserved paused state. */
+  TIRTC_VIDEO_OUTPUT_STATE_PAUSED = 3,
+
+  /** Reserved completed state. */
+  TIRTC_VIDEO_OUTPUT_STATE_COMPLETED = 4,
+
+  /** Output encountered repeated rendering failures. */
+  TIRTC_VIDEO_OUTPUT_STATE_FAILED = 5,
+} TirtcVideoOutputState;
+
+/**
+ * @brief Video input encoding options.
+ *
+ * These options are consumed when the internal video uplink pipeline is first
+ * created. Configure them before the first successful start for predictable
+ * behavior.
+ */
+typedef struct TirtcVideoInputOptions {
+  /**
+   * @brief Encoded video codec.
+   *
+   * The current implementation defaults to ::TIRTC_MEDIA_CODEC_VIDEO_H264 when
+   * this field is ::TIRTC_MEDIA_CODEC_NONE.
+   */
+  TirtcMediaCodec codec;
+
+  /**
+   * @brief Target encoded width in pixels.
+   *
+   * The current implementation defaults to 320 when this field is zero.
+   */
+  uint32_t width;
+
+  /**
+   * @brief Target encoded height in pixels.
+   *
+   * The current implementation defaults to 180 when this field is zero.
+   */
+  uint32_t height;
+
+  /**
+   * @brief Target frame rate.
+   *
+   * The current implementation defaults to 15 when this field is zero.
+   */
+  uint32_t fps;
+
+  /**
+   * @brief Target encoded bitrate in kilobits per second.
+   *
+   * The current implementation passes zero through to the underlying encoder,
+   * allowing the codec backend to choose its default rate-control behavior.
+   */
+  uint32_t bitrate_kbps;
+} TirtcVideoInputOptions;
+
+/**
+ * @brief Optional observer for a video input object.
+ *
+ * The implementation stores a copy of this structure. Installing or replacing
+ * an observer does not replay prior state; callbacks describe subsequent local
+ * start and stop transitions.
+ *
+ * Callback delivery is not guaranteed to be on a fixed thread. In the current
+ * implementation, input state notifications may be dispatched synchronously by
+ * API calls such as ::tirtc_video_input_start and ::tirtc_video_input_stop.
+ * Callers must therefore make callback logic safe for reentrant delivery.
+ */
+typedef struct TirtcVideoInputObserver {
+  /**
+   * @brief Called when the input starts or stops.
+   *
+   * In the current implementation, a start failure is reported as STOPPED with
+   * a non-OK ::error value.
+   */
+  void (*on_state_changed)(TirtcVideoInput* input, TirtcInputState state, TirtcError error,
+                           void* user_data);
+
+  /**
+   * @brief Reserved callback for output-size updates.
+   *
+   * The current facade implementation exposes this callback in the contract but
+   * does not currently emit it.
+   */
+  void (*on_output_size_changed)(TirtcVideoInput* input, uint32_t width, uint32_t height,
+                                 void* user_data);
+} TirtcVideoInputObserver;
+
+/**
+ * @brief Optional observer for a video output object.
+ *
+ * The implementation stores a copy of this structure. Installing or replacing
+ * an observer does not replay the current output state.
+ *
+ * Callback delivery is not guaranteed to be on a fixed thread. State changes
+ * may be reported synchronously by attach, detach, or backend-clear paths, or
+ * asynchronously from the internal downlink pipeline. Callers must therefore
+ * make callback logic safe for reentrant delivery and perform their own thread
+ * handoff when thread affinity is required.
+ */
+typedef struct TirtcVideoOutputObserver {
+  /**
+   * @brief Called when the output state changes.
+   *
+   * A common sequence is IDLE after attach, then BUFFERING, then RENDERING,
+   * and IDLE again after detach or backend removal.
+   */
+  void (*on_state_changed)(TirtcVideoOutput* output, TirtcVideoOutputState state, TirtcError error,
+                           void* user_data);
+
+  /**
+   * @brief Reserved callback for output-size updates.
+   *
+   * The current facade implementation exposes this callback in the contract but
+   * does not currently emit it.
+   */
+  void (*on_output_size_changed)(TirtcVideoOutput* output, uint32_t width, uint32_t height,
+                                 void* user_data);
+} TirtcVideoOutputObserver;
+
+/**
+ * @brief Enable or disable runtime media-trace logging.
+ *
+ * This is a process-wide runtime switch, not a per-connection setting.
+ *
+ * @param enabled Non-zero to enable tracing; zero to disable it.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_set_media_trace_enabled(int enabled);
+
+/**
+ * @brief Query whether runtime media tracing is enabled.
+ *
+ * @param out_enabled Receives `1` when enabled or `0` when disabled.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_get_media_trace_enabled(int* out_enabled);
+
+/**
+ * @brief Request an I-frame from the remote sender for a video stream.
+ *
+ * This is typically used by a receiver after join, decoder recovery, or severe
+ * packet loss when waiting for the next natural key frame would be too slow.
+ *
+ * @param connection Target connection.
+ * @param stream_id Video stream identifier.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_conn_request_iframe(TirtcConn* connection, uint8_t stream_id);
+
+/**
+ * @brief Attach a local video input to a connection stream.
+ *
+ * This bind is non-owning. The same input cannot be attached to more than one
+ * connection at a time. The selected ::stream_id must be unique across all
+ * currently attached input and output streams on the same connection.
+ *
+ * @param connection Target connection.
+ * @param stream_id Stream identifier that will carry this video route.
+ * @param input Video input to bind.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_conn_attach_video_input(TirtcConn* connection, uint8_t stream_id,
+                                         TirtcVideoInput* input);
+
+/**
+ * @brief Attach a remote video output to a connection stream.
+ *
+ * The output must not currently be used as a preview target. A video output
+ * can be either a preview sink or a remote sink, but never both at the same
+ * time.
+ *
+ * If an observer is already installed, a successful attach typically reports an
+ * initial IDLE state before decoded frames begin to render.
+ *
+ * @param connection Target connection.
+ * @param stream_id Remote video stream identifier to render.
+ * @param output Video output to bind.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_conn_attach_video_output(TirtcConn* connection, uint8_t stream_id,
+                                          TirtcVideoOutput* output);
+
+/**
+ * @brief Detach a video input from a connection stream.
+ *
+ * This call is idempotent.
+ *
+ * @param connection Target connection.
+ * @param stream_id Stream identifier to detach.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_conn_detach_video_input(TirtcConn* connection, uint8_t stream_id);
+
+/**
+ * @brief Detach a video output from a connection stream.
+ *
+ * This call is idempotent.
+ *
+ * @param connection Target connection.
+ * @param stream_id Stream identifier to detach.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_conn_detach_video_output(TirtcConn* connection, uint8_t stream_id);
+
+/**
+ * @brief Create a video input object.
+ *
+ * The runtime must already be initialized.
+ *
+ * @param out_input Receives the created input handle on success.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_video_input_create(TirtcVideoInput** out_input);
+
+/**
+ * @brief Destroy a video input object.
+ *
+ * The input must already be detached from any connection. Any preview binding
+ * is cleared during destruction.
+ *
+ * @param input Input handle to destroy.
+ */
+void tirtc_video_input_destroy(TirtcVideoInput* input);
+
+/**
+ * @brief Bind a concrete video capture backend to an input object.
+ *
+ * This must be done while the input is stopped and detached, before the next
+ * successful start. The backend pointer is non-owning and should remain valid
+ * while the input may still use it.
+ *
+ * @param input Target video input.
+ * @param vin Capture backend to bind.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_video_input_set_vin(TirtcVideoInput* input, TirtcVideoVin* vin);
+
+/**
+ * @brief Store video encoding options.
+ *
+ * Best practice is to call this before the first successful start. Updating
+ * options after the internal uplink pipeline has already been created does not
+ * retroactively rebuild that running pipeline.
+ *
+ * @param input Target video input.
+ * @param options Options to copy into the facade object.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_video_input_set_options(TirtcVideoInput* input,
+                                         const TirtcVideoInputOptions* options);
+
+/**
+ * @brief Install, replace, or clear the video input observer.
+ *
+ * Passing NULL for ::observer clears the current observer. The implementation
+ * stores a copy of the observer structure and does not require it to outlive
+ * this call.
+ *
+ * @param input Target video input.
+ * @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_video_input_set_observer(TirtcVideoInput* input,
+                                          const TirtcVideoInputObserver* observer, void* user_data);
+
+/**
+ * @brief Bind a preview output to a video input.
+ *
+ * Use this when local camera frames should also be rendered locally, for
+ * example in a self-preview view.
+ *
+ * The supplied output must already have a non-NULL render backend configured
+ * by ::tirtc_video_output_set_vout, and it must not currently be attached to a
+ * remote connection stream or owned by another preview input.
+ *
+ * This preview relationship is non-owning and may be established before or
+ * after ::tirtc_video_input_start. Rebinding to a different output
+ * automatically releases the previous preview relationship held by this input.
+ * When the input is already running, the new preview sink is applied to the
+ * live uplink immediately.
+ *
+ * @param input Target video input.
+ * @param output Video output to use for preview.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_video_input_set_preview_output(TirtcVideoInput* input, TirtcVideoOutput* output);
+
+/**
+ * @brief Clear the preview output currently associated with a video input.
+ *
+ * This call is idempotent and is the normal pairing call for
+ * ::tirtc_video_input_set_preview_output when a preview surface is being
+ * released or repurposed for remote display. Clearing the preview relationship
+ * does not destroy the output object.
+ *
+ * @param input Target video input.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_video_input_clear_preview_output(TirtcVideoInput* input);
+
+/**
+ * @brief Start local video capture and encoding for an input object.
+ *
+ * A capture backend must already be bound with ::tirtc_video_input_set_vin.
+ *
+ * @param input Target video input.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_video_input_start(TirtcVideoInput* input);
+
+/**
+ * @brief Stop local video capture and encoding for an input object.
+ *
+ * This is the normal pairing call for ::tirtc_video_input_start. The current
+ * implementation also tolerates stopping an already stopped input.
+ *
+ * @param input Target video input.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_video_input_stop(TirtcVideoInput* input);
+
+/**
+ * @brief Create a video output object.
+ *
+ * The runtime must already be initialized.
+ *
+ * @param out_output Receives the created output handle on success.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_video_output_create(TirtcVideoOutput** out_output);
+
+/**
+ * @brief Destroy a video output object.
+ *
+ * The output must already be detached from any connection stream and must not
+ * be owned by a preview input. If it is still active, the current
+ * implementation keeps it alive and ignores the destroy request.
+ *
+ * @param output Output handle to destroy.
+ */
+void tirtc_video_output_destroy(TirtcVideoOutput* output);
+
+/**
+ * @brief Bind or clear a concrete video render backend for an output object.
+ *
+ * Passing a non-NULL backend is allowed only while the output is inactive.
+ * That means it must be neither attached to a remote stream nor serving as a
+ * preview output.
+ *
+ * Passing NULL clears the current backend. When a remote output is already
+ * attached, clearing the backend stops rendering and returns the output to the
+ * IDLE state. When the output is currently used for preview, clearing the
+ * backend stops the live preview sink but does not clear the preview
+ * relationship itself. The output remains owned by that preview binding until
+ * ::tirtc_video_input_clear_preview_output is called.
+ *
+ * @param output Target video output.
+ * @param vout Render backend to bind, or NULL to clear.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_video_output_set_vout(TirtcVideoOutput* output, TirtcVideoVout* vout);
+
+/**
+ * @brief Install, replace, or clear the video output observer.
+ *
+ * Passing NULL for ::observer clears the current observer. The implementation
+ * stores a copy of the observer structure and does not require it to outlive
+ * this call.
+ *
+ * @param output Target video output.
+ * @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_video_output_set_observer(TirtcVideoOutput* output,
+                                           const TirtcVideoOutputObserver* observer,
+                                           void* user_data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_FACADE_AV_H_

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

@@ -0,0 +1,34 @@
+#ifndef TIRTC_CREDENTIAL_H_
+#define TIRTC_CREDENTIAL_H_
+
+#include "tirtc/error.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct TirtcCredentialIssueTokenOptions {
+  const char* openapi_entry;
+  const char* access_id;
+  const char* secret_key;
+  const char* local_id;
+  const char* peer_id;
+  int user_ttl_seconds;
+  int channel_ttl_seconds;
+} TirtcCredentialIssueTokenOptions;
+
+typedef struct TirtcCredentialIssueTokenResult {
+  char* token;
+  int http_status_code;
+} TirtcCredentialIssueTokenResult;
+
+TirtcError tirtc_credential_issue_token(const TirtcCredentialIssueTokenOptions* options,
+                                        TirtcCredentialIssueTokenResult* out_result);
+
+void tirtc_credential_issue_token_result_dispose(TirtcCredentialIssueTokenResult* result);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_CREDENTIAL_H_

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

@@ -0,0 +1,30 @@
+#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,
+  TIRTC_ERROR_UNSUPPORTED_LOOP_POLICY = 5,
+  TIRTC_ERROR_SOURCE_HASH_MISMATCH = 6,
+  TIRTC_ERROR_STOPPED = 7,
+  TIRTC_ERROR_DESTROYED = 8,
+  TIRTC_ERROR_TRANSPORT_INVALID_LICENSE = 9,
+  TIRTC_ERROR_TRANSPORT_TIMEOUT = 10,
+  TIRTC_ERROR_TRANSPORT_BUSY = 11,
+  TIRTC_ERROR_TRANSPORT_CONNECTION_TIMEOUT_CLOSED = 12,
+  TIRTC_ERROR_TRANSPORT_REMOTE_CLOSED = 13,
+  TIRTC_ERROR_TRANSPORT_CONNECTION_OTHER_ERROR = 14,
+} TirtcError;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_FOUNDATION_ERROR_H_

package/vendor/app-server/bin/runtime/macos-arm64/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/app-server/bin/runtime/macos-arm64/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/app-server/bin/runtime/macos-arm64/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/app-server/bin/runtime/macos-arm64/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_