tirtc-devtools-cli 0.0.1

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

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

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

@@ -0,0 +1,61 @@
+#ifndef TIRTC_MEDIA_FIXTURE_AV_SYNC_H_
+#define TIRTC_MEDIA_FIXTURE_AV_SYNC_H_
+
+#include <stddef.h>
+#include <stdint.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 TirtcMediaFixtureAvSyncOptions {
+  const char* fixture_dir;
+
+  /* Encoded source paths under fixture_dir (or absolute paths). */
+  const char* audio_g711a_path;
+  const char* audio_packets_path;
+  const char* video_h264_path;
+  const char* video_packets_path;
+
+  uint32_t audio_sample_rate_hz;
+  uint32_t audio_samples_per_channel;
+  uint32_t video_width;
+  uint32_t video_height;
+  uint32_t video_fps;
+  TirtcVideoPixelFormat video_output_pixel_format;
+
+  /* Deprecated legacy fields kept for API compatibility. */
+  const char* audio_pcm_path;
+  const char* video_preview_path;
+  uint32_t video_stride;
+  uint32_t video_bytes_per_frame;
+} TirtcMediaFixtureAvSyncOptions;
+
+typedef struct TirtcMediaFixtureAvSyncRunOptions {
+  uint64_t duration_us;
+  uint8_t enable_realtime_pacing;
+  uint32_t max_audio_packets;
+  uint32_t max_video_packets;
+} TirtcMediaFixtureAvSyncRunOptions;
+
+typedef struct TirtcMediaFixtureAvSyncObserver {
+  int (*on_audio_frame)(const TirtcAudioPcmFrame* frame, void* user_data);
+  int (*on_video_frame)(const TirtcVideoPixelFrame* frame, void* user_data);
+} TirtcMediaFixtureAvSyncObserver;
+
+TirtcError tirtc_media_fixture_av_sync_run(const TirtcMediaFixtureAvSyncOptions* options,
+                                           const TirtcMediaFixtureAvSyncRunOptions* run_options,
+                                           const TirtcMediaFixtureAvSyncObserver* observer,
+                                           void* user_data, uint64_t* out_audio_frames,
+                                           uint64_t* out_video_frames);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_MEDIA_FIXTURE_AV_SYNC_H_

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

@@ -0,0 +1,77 @@
+#ifndef TIRTC_MEDIA_FIXTURE_SOURCE_H_
+#define TIRTC_MEDIA_FIXTURE_SOURCE_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "tirtc/error.h"
+#include "tirtc/media_live_source.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct TirtcMediaFixtureSource {
+  TirtcMediaLiveSource* live_source;
+} TirtcMediaFixtureSource;
+
+typedef enum TirtcMediaFixturePacketKind {
+  TIRTC_MEDIA_FIXTURE_PACKET_KIND_AUDIO = 1,
+  TIRTC_MEDIA_FIXTURE_PACKET_KIND_VIDEO = 2,
+} TirtcMediaFixturePacketKind;
+
+typedef struct TirtcMediaFixturePacket {
+  TirtcMediaFixturePacketKind kind;
+  int64_t pts_us;
+  uint8_t is_key_frame;
+  uint32_t audio_sample_rate;
+  uint32_t audio_channels;
+  uint32_t video_width;
+  uint32_t video_height;
+  uint32_t video_stride;
+  uint32_t video_pixel_format;
+  const void* data;
+  size_t data_bytes;
+} TirtcMediaFixturePacket;
+
+typedef struct TirtcMediaFixtureSourceOptions {
+  const char* fixture_dir;
+  const char* audio_path;
+  const char* audio_packets_path;
+  const char* video_path;
+  const char* video_packets_path;
+} TirtcMediaFixtureSourceOptions;
+
+typedef struct TirtcMediaFixtureRunOptions {
+  uint64_t duration_us;
+  uint8_t enable_realtime_pacing;
+  uint8_t emit_audio;
+  uint8_t emit_video;
+  uint8_t reserved0;
+  uint8_t reserved1;
+} TirtcMediaFixtureRunOptions;
+
+typedef struct TirtcMediaFixtureSourceObserver {
+  int (*on_packet)(const TirtcMediaFixturePacket* packet, void* user_data);
+} TirtcMediaFixtureSourceObserver;
+
+TirtcError tirtc_media_fixture_source_create(TirtcMediaFixtureSource** out_source);
+void tirtc_media_fixture_source_destroy(TirtcMediaFixtureSource* source);
+
+TirtcError tirtc_media_fixture_source_load(TirtcMediaFixtureSource* source,
+                                           const TirtcMediaFixtureSourceOptions* options);
+void tirtc_media_fixture_source_unload(TirtcMediaFixtureSource* source);
+
+TirtcError tirtc_media_fixture_source_run(TirtcMediaFixtureSource* source,
+                                          const TirtcMediaFixtureRunOptions* options,
+                                          const TirtcMediaFixtureSourceObserver* observer,
+                                          void* user_data);
+
+size_t tirtc_media_fixture_source_audio_packet_count(const TirtcMediaFixtureSource* source);
+size_t tirtc_media_fixture_source_video_packet_count(const TirtcMediaFixtureSource* source);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_MEDIA_FIXTURE_SOURCE_H_

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

@@ -0,0 +1,71 @@
+#ifndef TIRTC_MEDIA_LIVE_SOURCE_H_
+#define TIRTC_MEDIA_LIVE_SOURCE_H_
+
+#include <stddef.h>
+#include <stdint.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 TirtcMediaLiveSource TirtcMediaLiveSource;
+
+typedef enum TirtcMediaLiveSourceMode {
+  TIRTC_MEDIA_LIVE_SOURCE_MODE_AIN_VIN = 1,
+  TIRTC_MEDIA_LIVE_SOURCE_MODE_RAW_CALLBACK = 2,
+} TirtcMediaLiveSourceMode;
+
+typedef struct TirtcMediaLiveSourceOptions {
+  const char* dataset_dir;
+  TirtcMediaLiveSourceMode mode;
+  uint32_t audio_sample_rate_hz;
+  uint32_t enable_realtime_pacing;
+} TirtcMediaLiveSourceOptions;
+
+typedef struct TirtcMediaLiveSourceRawAudioFrame {
+  int64_t pts_us;
+  uint32_t sample_rate;
+  uint32_t channels;
+  uint32_t samples_per_channel;
+  const int16_t* data;
+} TirtcMediaLiveSourceRawAudioFrame;
+
+typedef struct TirtcMediaLiveSourceRawVideoFrame {
+  int64_t pts_us;
+  uint32_t width;
+  uint32_t height;
+  uint32_t pixel_format;
+  const uint8_t* data;
+  size_t data_bytes;
+  uint32_t stride;
+} TirtcMediaLiveSourceRawVideoFrame;
+
+typedef struct TirtcMediaLiveSourceRawObserver {
+  int (*on_audio_frame)(const TirtcMediaLiveSourceRawAudioFrame* frame, void* user_data);
+  int (*on_video_frame)(const TirtcMediaLiveSourceRawVideoFrame* frame, void* user_data);
+} TirtcMediaLiveSourceRawObserver;
+
+TirtcError tirtc_media_live_source_create(const TirtcMediaLiveSourceOptions* options,
+                                          TirtcMediaLiveSource** out_source);
+TirtcError tirtc_media_live_source_start(TirtcMediaLiveSource* source);
+TirtcError tirtc_media_live_source_stop(TirtcMediaLiveSource* source);
+void tirtc_media_live_source_destroy(TirtcMediaLiveSource* source);
+
+TirtcError tirtc_media_live_source_set_raw_observer(TirtcMediaLiveSource* source,
+                                                    const TirtcMediaLiveSourceRawObserver* observer,
+                                                    void* user_data);
+TirtcError tirtc_media_live_source_clear_raw_observer(TirtcMediaLiveSource* source);
+
+TirtcAudioAin* tirtc_media_live_source_get_ain(TirtcMediaLiveSource* source);
+TirtcVideoVin* tirtc_media_live_source_get_vin(TirtcMediaLiveSource* source);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_MEDIA_LIVE_SOURCE_H_

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

@@ -0,0 +1,116 @@
+#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_request_key_frame(TirtcMediaUplinkVideo* uplink);
+TirtcError tirtc_media_uplink_video_start(TirtcMediaUplinkVideo* uplink);
+TirtcError tirtc_media_uplink_video_stop(TirtcMediaUplinkVideo* uplink);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TIRTC_MEDIA_UPLINK_H_