SeaStart advanced features

typedef struct {
    char    sub_key[128];        // Stable subscription handle "pub_uid:track_id"
    char    from_track_id[64];   // Layer in use before the switch; empty string on first playback
    char    to_track_id[64];     // Layer in use after the switch
    char    reason[32];          // Reason for the switch, see the table below
    int64_t latency_ms;          // Time from initiating the switch to actually reaching the target layer
} rtc_layer_switched_t;

typedef void (*rtc_layer_switched_callback)(void* context, const rtc_layer_switched_t* data);
void rtc_set_layer_switched_callback(void* handle, rtc_layer_switched_callback callback, void* context);

static void on_layer_switched(void* ctx, const rtc_layer_switched_t* d) {
    printf("layer %s -> %s (%s, %lldms)\n",
           d->from_track_id[0] ? d->from_track_id : "-",
           d->to_track_id, d->reason, (long long)d->latency_ms);
}

rtc_set_layer_switched_callback(rtc, on_layer_switched, NULL);

int rtc_switch_layer(void* handle, const char* pub_uid,
                     const char* track_id, const char* target_track_id);

// Switch u1001's subscribed main layer to the smallest layer
rtc_switch_layer(rtc, "u1001", big_track_id, small_track_id);
// The result is reported through on_layer_switched, with reason = "client"

// Quality sample for one direction
typedef struct {
    double  score;      // Quality score 0–100
    char    level[16];  // "excellent" | "good" | "poor" | "lost"
    double  mos;        // 1.0-4.5
    double  loss;       // Packet loss rate 0–1
    double  rtt;        // Milliseconds
    double  jitter;     // Milliseconds
    int64_t packets;    // Number of packets counted in this round
    double  bitrate;    // Average bitrate in kbps (not used in the score)
    int64_t bytes;      // Bytes in this window
} rtc_quality_sample_t;

typedef struct {
    int64_t              ts;   // Unix timestamp in milliseconds when the SFU generated the report
    rtc_quality_sample_t pub;  // Uplink (local → SFU)
    rtc_quality_sample_t sub;  // Downlink (SFU → local)
} rtc_connection_quality_t;

typedef void (*rtc_connection_quality_callback)(void* context, const rtc_connection_quality_t* q);
void rtc_set_connection_quality_callback(void* handle, rtc_connection_quality_callback callback, void* context);

static void on_connection_quality(void* ctx, const rtc_connection_quality_t* q) {
    // For a signal-bars indicator, use q->pub.level / q->sub.level
    // For a numeric panel, use mos / loss / rtt / jitter / bitrate
    printf("pub=%s(%.1f) sub=%s(%.1f) rtt=%.0fms\n",
           q->pub.level, q->pub.score, q->sub.level, q->sub.score, q->sub.rtt);
}

rtc_set_connection_quality_callback(rtc, on_connection_quality, NULL);

int rtc_get_connection_quality(void* handle, rtc_connection_quality_t* out);

rtc_connection_quality_t q;
int ret = rtc_get_connection_quality(rtc, &q);
if (ret == RTC_OK) {
    printf("pub=%s loss=%.2f sub=%s loss=%.2f rtt=%.0f\n",
           q.pub.level, q.pub.loss, q.sub.level, q.sub.loss, q.sub.rtt);
} else if (ret == RTC_NOT_CONNECTED) {
    // No data yet; just wait for the callback
}

typedef struct {
    char   uid[64];
    char   track_id[64];  // Distinguishes tracks when a user has multiple audio tracks
    double level;         // 0.0–1.0, higher is louder
} rtc_active_speaker_t;

typedef void (*rtc_active_speakers_callback)(void* context, int64_t ts,
                                             const rtc_active_speaker_t* speakers,
                                             int speakers_count);
void rtc_set_active_speakers_callback(void* handle, rtc_active_speakers_callback callback, void* context);

static void on_active_speakers(void* ctx, int64_t ts,
                               const rtc_active_speaker_t* speakers, int count) {
    clear_speaking_indicators();
    for (int i = 0; i < count; i++) {
        update_ui(speakers[i].uid, speakers[i].level);
    }
}

rtc_set_active_speakers_callback(rtc, on_active_speakers, NULL);