tirtc-devtools-cli 0.0.15 → 0.1.1

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

@@ -0,0 +1,199 @@
+#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;
+
+/**
+ * Diagnostic facts currently known by an audio downlink.
+ *
+ * The snapshot is a value copy into caller-owned storage. `codec` is
+ * `TIRTC_MEDIA_CODEC_NONE` until the downlink accepts a valid encoded audio frame.
+ */
+typedef struct TirtcMediaDownlinkAudioDebugSnapshot {
+  TirtcMediaCodec codec;
+} TirtcMediaDownlinkAudioDebugSnapshot;
+
+/**
+ * Diagnostic facts currently known by a video downlink.
+ *
+ * The snapshot is a value copy into caller-owned storage. Zero values mean the downlink has not
+ * observed the corresponding fact since start/reset. `requested_decoder_preference` reflects the
+ * configured option; `resolved_decoder_backend` is only set after the runtime locks a concrete
+ * decode route.
+ */
+typedef struct TirtcMediaDownlinkVideoDebugSnapshot {
+  TirtcMediaCodec codec;
+  TirtcVideoBitstreamFormat bitstream_format;
+  uint32_t width;
+  uint32_t height;
+  TirtcVideoDecoderPreference requested_decoder_preference;
+  TirtcVideoDecoderBackendKind resolved_decoder_backend;
+} TirtcMediaDownlinkVideoDebugSnapshot;
+
+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);
+
+/**
+ * Copies the current audio downlink diagnostic snapshot.
+ *
+ * This call does not start, stop, flush, or otherwise change the downlink. It returns
+ * `TIRTC_ERROR_INVALID_ARGUMENT` when `downlink` or `out_snapshot` is null.
+ */
+TirtcError tirtc_media_downlink_audio_get_debug_snapshot(
+    TirtcMediaDownlinkAudio* downlink, TirtcMediaDownlinkAudioDebugSnapshot* out_snapshot);
+
+/**
+ * Copies the current video downlink diagnostic snapshot.
+ *
+ * This call does not start, stop, flush, or otherwise change the downlink. It returns
+ * `TIRTC_ERROR_INVALID_ARGUMENT` when `downlink` or `out_snapshot` is null.
+ */
+TirtcError tirtc_media_downlink_video_get_debug_snapshot(
+    TirtcMediaDownlinkVideo* downlink, TirtcMediaDownlinkVideoDebugSnapshot* out_snapshot);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_MEDIA_DOWNLINK_H_

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

@@ -0,0 +1,120 @@
+#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_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;
+  TirtcVideoEncoderPreference encoder_preference;
+} 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_request_key_frame(TirtcMediaUplinkVideo* uplink);
+TirtcError tirtc_media_uplink_video_start(TirtcMediaUplinkVideo* uplink);
+TirtcError tirtc_media_uplink_video_stop(TirtcMediaUplinkVideo* uplink);
+TirtcError tirtc_media_uplink_video_submit_encoded_frame(TirtcMediaUplinkVideo* uplink,
+                                                         const TirtcVideoEncodedFrame* frame);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_MEDIA_UPLINK_H_