SeaStart 进阶能力

typedef struct {
    char    sub_key[128];        // 稳定订阅句柄 "pub_uid:track_id"
    char    from_track_id[64];   // 切层前命中层；首次起播时为空字符串
    char    to_track_id[64];     // 切层后命中层
    char    reason[32];          // 切层原因，见下表
    int64_t latency_ms;          // 从发起切层到真正切到目标层的耗时
} 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);

// 把订阅 u1001 的主层切到最小层
rtc_switch_layer(rtc, "u1001", big_track_id, small_track_id);
// 切层结果通过 on_layer_switched 通知，reason = "client"

// 单方向的质量样本
typedef struct {
    double  score;      // 质量分 0-100
    char    level[16];  // "excellent" | "good" | "poor" | "lost"
    double  mos;        // 1.0-4.5
    double  loss;       // 丢包率 0-1
    double  rtt;        // 毫秒
    double  jitter;     // 毫秒
    int64_t packets;    // 本轮参与统计的包数
    double  bitrate;    // 平均码率 kbps（不参与 score 计算）
    int64_t bytes;      // 本窗口字节数
} rtc_quality_sample_t;

typedef struct {
    int64_t              ts;   // SFU 生成报告的 Unix 毫秒时间戳
    rtc_quality_sample_t pub;  // 上行（本端 → SFU）
    rtc_quality_sample_t sub;  // 下行（SFU → 本端）
} 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) {
    // 画信号塔看 q->pub.level / q->sub.level
    // 数值面板看 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) {
    // 还没有数据，等回调即可
}

typedef struct {
    char   uid[64];
    char   track_id[64];  // 同一用户有多路音频时用于区分
    double level;         // 0.0-1.0，越大越响
} 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);