adamo-sys 0.1.103

//! Raw FFI bindings to the Adamo SDK.
//!
//! This crate is a thin, `unsafe` interface — prefer the safe wrappers in
//! [`adamo`](https://docs.rs/adamo) for normal use.
//!
//! All declarations match the C header generated by `cbindgen` for the
//! `adamo-c` crate (`include/adamo/adamo.h`). Keep them in sync.

#![allow(non_camel_case_types)]
#![allow(clippy::missing_safety_doc)]

use std::os::raw::{c_char, c_int, c_void};

pub type adamo_protocol_t = u32;
#[deprecated(note = "plain UDP is not publicly available; use ADAMO_PROTOCOL_QUIC")]
pub const ADAMO_PROTOCOL_UDP: adamo_protocol_t = 0;
pub const ADAMO_PROTOCOL_QUIC: adamo_protocol_t = 1;
pub const ADAMO_PROTOCOL_TCP: adamo_protocol_t = 2;

pub type adamo_regime_t = u32;
pub const ADAMO_REGIME_STABLE: adamo_regime_t = 0;
pub const ADAMO_REGIME_DEGRADING: adamo_regime_t = 1;
pub const ADAMO_REGIME_VOLATILE: adamo_regime_t = 2;
pub const ADAMO_REGIME_RECOVERING: adamo_regime_t = 3;

pub type adamo_video_backend_t = i32;
pub const ADAMO_VIDEO_BACKEND_AUTO: adamo_video_backend_t = 0;
pub const ADAMO_VIDEO_BACKEND_GSTREAMER: adamo_video_backend_t = 1;
pub const ADAMO_VIDEO_BACKEND_HW_PIPELINE: adamo_video_backend_t = 2;

// Opaque handles. Zero-sized placeholders — callers only ever see pointers
// to them. `PhantomData<*mut ()>` keeps them `!Send + !Sync` by default;
// the safe wrapper re-asserts thread-safety where the C API documents it.
#[repr(C)]
pub struct adamo_session_t {
    _priv: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
#[repr(C)]
pub struct adamo_publisher_t {
    _priv: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
#[repr(C)]
pub struct adamo_subscriber_t {
    _priv: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
#[repr(C)]
pub struct adamo_cb_sub_t {
    _priv: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
#[repr(C)]
pub struct adamo_liveliness_token_t {
    _priv: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
#[repr(C)]
pub struct adamo_liveliness_sub_t {
    _priv: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
#[repr(C)]
pub struct adamo_state_t {
    _priv: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
#[repr(C)]
pub struct adamo_task_runner_t {
    _priv: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
#[repr(C)]
pub struct adamo_transport_core_t {
    _priv: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
#[repr(C)]
pub struct adamo_rlnc_decoder_t {
    _priv: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
#[repr(C)]
pub struct adamo_robot_t {
    _priv: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
#[repr(C)]
pub struct adamo_video_track_t {
    _priv: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
#[repr(C)]
pub struct adamo_video_receiver_t {
    _priv: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
#[repr(C)]
pub struct adamo_audio_receiver_t {
    _priv: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

#[repr(C)]
pub struct adamo_sample_t {
    pub key: *mut c_char,
    pub payload: *mut u8,
    pub payload_len: usize,
    pub is_delete: i32,
    pub timestamp_us: u64,
}

#[repr(C)]
pub struct adamo_latency_stats_t {
    pub regime: adamo_regime_t,
    pub jitter_hint_ms: f32,
    pub garch_sigma_ms: f32,
    pub target_bitrate_kbps: u32,
    pub loss_rate: f32,
    pub queuing_delay_ms: f32,
    pub timestamp_ms: u64,
}

#[repr(C)]
#[derive(Clone, Copy)]
pub struct adamo_video_receive_options_t {
    pub codec: *const c_char,
    pub decoder: *const c_char,
    pub max_queued_frames: u32,
}

#[repr(C)]
pub struct adamo_video_frame_t {
    pub data: *mut u8,
    pub data_len: usize,
    pub width: u32,
    pub height: u32,
    pub seq: u64,
    pub capture_unix_us: u64,
    pub keyframe: i32,
}

#[repr(C)]
#[derive(Clone, Copy)]
pub struct adamo_video_frame_info_t {
    pub width: u32,
    pub height: u32,
    pub seq: u64,
    pub capture_unix_us: u64,
    pub keyframe: i32,
}

#[repr(C)]
#[derive(Clone, Copy)]
pub struct adamo_video_receiver_stats_t {
    pub packets: u64,
    pub frames: u64,
    pub keyframes: u64,
    pub frames_decoded: u64,
    pub frames_dropped: u64,
    pub rlnc_recovered: u64,
}

#[repr(C)]
pub struct adamo_transport_frame_t {
    pub data: *mut u8,
    pub data_len: usize,
    pub frame_seq: u64,
    pub capture_unix_us: u64,
    pub keyframe: i32,
    pub encrypted: i32,
}

#[repr(C)]
pub struct adamo_transport_stats_t {
    pub frames_emitted: u64,
    pub chunks_received: u64,
    pub duplicates_dropped: u64,
    pub malformed_dropped: u64,
    pub frames_expired: u64,
}

#[repr(C)]
pub struct adamo_rlnc_recovery_t {
    pub sequence: u64,
    pub data: *mut u8,
    pub data_len: usize,
    pub repair_keys: *mut u16,
    pub repair_key_count: usize,
}

#[repr(C)]
#[derive(Clone, Copy)]
pub struct adamo_video_options_t {
    pub width: u32,
    pub height: u32,
    pub pixel_format: *const c_char,
    pub codec: *const c_char,
    pub encoder: *const c_char,
    pub bitrate_kbps: u32,
    pub adaptive_bitrate: i32,
    pub min_bitrate_kbps: u32,
    pub max_bitrate_kbps: u32,
    pub bitrate_priority: f32,
    pub fps: u32,
    pub keyframe_distance: f64,
    pub stereo: i32,
    pub backend: adamo_video_backend_t,
    /// Optional iceoryx2 service name to also publish every raw captured
    /// frame to (V4L2 tracks only; null = disabled).
    pub shm_publish: *const c_char,
    /// Per-track video protocol (null = adamo default).
    pub reliability: *const c_char,
    /// Forward an already-encoded H.264/H.265 bitstream without re-encoding
    /// (0 = off). Appended last to keep prior field offsets ABI-stable.
    pub passthrough: i32,
    /// Keep the robot running when this track fails (0 = required/default).
    /// Appended last to keep prior field offsets ABI-stable.
    pub allow_missing: i32,
}

/// Audio send options — mirrors the C ABI `adamo_audio_options_t`. Note the
/// flag fields are `bool` (C `_Bool`) and `channels` is `u8`, matching the
/// header cbindgen generates — unlike `adamo_video_options_t`, whose flags are
/// `i32`.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct adamo_audio_options_t {
    pub source_type: *const c_char,
    pub device: *const c_char,
    pub pipeline: *const c_char,
    pub codec: *const c_char,
    pub bitrate_kbps: u32,
    pub sample_rate: u32,
    pub channels: u8,
    pub frame_ms: u32,
    pub inband_fec: bool,
    pub dtx: bool,
    pub allow_missing: bool,
}

#[repr(C)]
#[derive(Clone, Copy)]
pub struct adamo_audio_receive_options_t {
    pub max_queued_frames: u32,
    pub reorder_deadline_ms: u32,
}

#[repr(C)]
pub struct adamo_audio_frame_t {
    pub samples: *mut i16,
    pub sample_count: usize,
    pub sample_rate: u32,
    pub channels: u8,
    pub seq: u64,
    pub capture_unix_us: u64,
}

#[repr(C)]
#[derive(Clone, Copy)]
pub struct adamo_audio_receiver_stats_t {
    pub packets: u64,
    pub repairs: u64,
    pub recovered: u64,
    pub concealed: u64,
    pub decoded: u64,
    pub dropped: u64,
}

pub type adamo_sample_cb_t =
    Option<unsafe extern "C" fn(sample: *const adamo_sample_t, user: *mut c_void)>;
pub type adamo_liveliness_cb_t =
    Option<unsafe extern "C" fn(key: *const c_char, alive: c_int, user: *mut c_void)>;

// docs.rs builds can't link libadamo; stub the extern block out there so
// rustdoc still succeeds.
#[cfg(not(docsrs))]
unsafe extern "C" {
    pub fn adamo_transport_core_new(
        playout_deadline_ms: u64,
        keyframe_deadline_ms: u64,
        dedup_capacity: usize,
    ) -> *mut adamo_transport_core_t;
    pub fn adamo_transport_core_free(core: *mut adamo_transport_core_t);
    pub fn adamo_transport_core_ingest(
        core: *mut adamo_transport_core_t,
        packet: *const u8,
        packet_len: usize,
        packet_type: u8,
        arrival_ms: u64,
        delivery: u8,
    ) -> *mut adamo_transport_frame_t;
    pub fn adamo_transport_frame_free(frame: *mut adamo_transport_frame_t);
    pub fn adamo_transport_core_expire(
        core: *mut adamo_transport_core_t,
        wall_unix_ms: u64,
        arrival_ms: u64,
    ) -> usize;
    pub fn adamo_transport_core_stats(
        core: *const adamo_transport_core_t,
        out: *mut adamo_transport_stats_t,
    ) -> i32;
    pub fn adamo_rlnc_decoder_new(
        max_equations: usize,
        history_depth: u64,
    ) -> *mut adamo_rlnc_decoder_t;
    pub fn adamo_rlnc_decoder_free(decoder: *mut adamo_rlnc_decoder_t);
    pub fn adamo_rlnc_decoder_add_source(
        decoder: *mut adamo_rlnc_decoder_t,
        sequence: u64,
        packet: *const u8,
        packet_len: usize,
    ) -> i32;
    pub fn adamo_rlnc_decoder_add_repair(
        decoder: *mut adamo_rlnc_decoder_t,
        packet: *const u8,
        packet_len: usize,
    ) -> i32;
    pub fn adamo_rlnc_decoder_take_recovery(
        decoder: *mut adamo_rlnc_decoder_t,
    ) -> *mut adamo_rlnc_recovery_t;
    pub fn adamo_rlnc_recovery_free(recovery: *mut adamo_rlnc_recovery_t);

    pub fn adamo_last_error() -> *const c_char;

    /// Category of the last error on this thread. 0 = OK, 1 = auth,
    /// 2 = network, 3 = timeout, 4 = invalid argument, 5 = video,
    /// 6 = internal, 7 = audio. Stable across releases.
    pub fn adamo_last_error_code() -> core::ffi::c_int;
    pub fn adamo_last_stream_error_code() -> *const c_char;
    pub fn adamo_last_stream_error_stage() -> *const c_char;
    pub fn adamo_last_stream_error_track() -> *const c_char;
    pub fn adamo_last_stream_error_backend() -> *const c_char;
    pub fn adamo_last_stream_error_source() -> *const c_char;

    pub fn adamo_sample_free(sample: *mut adamo_sample_t);

    pub fn adamo_open(api_key: *const c_char, protocol: adamo_protocol_t) -> *mut adamo_session_t;
    pub fn adamo_open_default(api_key: *const c_char) -> *mut adamo_session_t;
    #[deprecated(note = "adamo_open already uses mTLS; use adamo_open")]
    pub fn adamo_open_mtls(
        api_key: *const c_char,
        protocol: adamo_protocol_t,
    ) -> *mut adamo_session_t;
    pub fn adamo_session_free(sess: *mut adamo_session_t);
    pub fn adamo_session_org(sess: *const adamo_session_t) -> *const c_char;
    pub fn adamo_session_org_len(sess: *const adamo_session_t) -> usize;

    pub fn adamo_put(
        sess: *const adamo_session_t,
        key: *const c_char,
        payload: *const u8,
        payload_len: usize,
        priority: u8,
        express: i32,
    ) -> i32;
    pub fn adamo_log(
        sess: *const adamo_session_t,
        name: *const c_char,
        message: *const c_char,
        level: *const c_char,
    ) -> i32;
    pub fn adamo_set_pose(
        sess: *const adamo_session_t,
        name: *const c_char,
        x: f64,
        y: f64,
        z: f64,
        frame: *const c_char,
        heading: f64,
    ) -> i32;

    pub fn adamo_publisher(
        sess: *const adamo_session_t,
        key: *const c_char,
        priority: u8,
        express: i32,
        reliable: i32,
    ) -> *mut adamo_publisher_t;
    pub fn adamo_publisher_put(
        pub_: *const adamo_publisher_t,
        payload: *const u8,
        payload_len: usize,
    ) -> i32;
    pub fn adamo_publisher_free(pub_: *mut adamo_publisher_t);

    pub fn adamo_subscribe(
        sess: *const adamo_session_t,
        key: *const c_char,
    ) -> *mut adamo_subscriber_t;
    pub fn adamo_sub_recv(
        sub: *const adamo_subscriber_t,
        timeout_ms: u64,
    ) -> *mut adamo_sample_t;
    pub fn adamo_sub_try_recv(sub: *const adamo_subscriber_t) -> *mut adamo_sample_t;
    pub fn adamo_sub_free(sub: *mut adamo_subscriber_t);

    pub fn adamo_subscribe_cb(
        sess: *const adamo_session_t,
        key: *const c_char,
        cb: adamo_sample_cb_t,
        user: *mut c_void,
    ) -> *mut adamo_cb_sub_t;
    pub fn adamo_cb_sub_free(sub: *mut adamo_cb_sub_t);

    pub fn adamo_get(
        sess: *const adamo_session_t,
        key: *const c_char,
        timeout_ms: u64,
        count_out: *mut usize,
    ) -> *mut *mut adamo_sample_t;
    pub fn adamo_get_replies_free(replies: *mut *mut adamo_sample_t, count: usize);

    pub fn adamo_state_declare(
        sess: *const adamo_session_t,
        robot: *const c_char,
    ) -> *mut adamo_state_t;
    pub fn adamo_state_set(
        state: *const adamo_state_t,
        key: *const c_char,
        payload: *const u8,
        payload_len: usize,
    ) -> i32;
    pub fn adamo_state_get(
        state: *const adamo_state_t,
        key: *const c_char,
        out_payload: *mut *mut u8,
        out_len: *mut usize,
    ) -> i32;
    pub fn adamo_state_delete(state: *const adamo_state_t, key: *const c_char) -> i32;
    pub fn adamo_state_bytes_free(payload: *mut u8, payload_len: usize);
    pub fn adamo_state_free(state: *mut adamo_state_t);

    pub fn adamo_task_runner_declare(
        sess: *const adamo_session_t,
        robot: *const c_char,
    ) -> *mut adamo_task_runner_t;
    pub fn adamo_task_runner_select(
        runner: *const adamo_task_runner_t,
        task_set_id: *const c_char,
        name: *const c_char,
        ids: *const *const c_char,
        names: *const *const c_char,
        count: usize,
    ) -> i32;
    pub fn adamo_task_runner_advance(runner: *const adamo_task_runner_t) -> i32;
    pub fn adamo_task_runner_reset(runner: *const adamo_task_runner_t) -> i32;
    pub fn adamo_task_runner_free(runner: *mut adamo_task_runner_t);

    pub fn adamo_liveliness_declare(
        sess: *const adamo_session_t,
        token_key: *const c_char,
    ) -> *mut adamo_liveliness_token_t;
    pub fn adamo_liveliness_token_free(tok: *mut adamo_liveliness_token_t);
    pub fn adamo_liveliness_get(
        sess: *const adamo_session_t,
        pattern: *const c_char,
        count_out: *mut usize,
    ) -> *mut *mut c_char;
    pub fn adamo_liveliness_tokens_free(tokens: *mut *mut c_char, count: usize);
    pub fn adamo_liveliness_subscribe(
        sess: *const adamo_session_t,
        pattern: *const c_char,
        history: c_int,
        cb: adamo_liveliness_cb_t,
        user: *mut c_void,
    ) -> *mut adamo_liveliness_sub_t;
    pub fn adamo_liveliness_sub_free(sub: *mut adamo_liveliness_sub_t);

    pub fn adamo_video_receive_options_default() -> adamo_video_receive_options_t;
    pub fn adamo_video_receiver_open(
        sess: *const adamo_session_t,
        robot: *const c_char,
        track: *const c_char,
    ) -> *mut adamo_video_receiver_t;
    pub fn adamo_video_receiver_open_configured(
        sess: *const adamo_session_t,
        robot: *const c_char,
        track: *const c_char,
        opts: *const adamo_video_receive_options_t,
    ) -> *mut adamo_video_receiver_t;
    pub fn adamo_video_receiver_recv(
        rx: *const adamo_video_receiver_t,
        timeout_ms: u64,
    ) -> *mut adamo_video_frame_t;
    pub fn adamo_video_receiver_try_recv(
        rx: *const adamo_video_receiver_t,
    ) -> *mut adamo_video_frame_t;
    pub fn adamo_video_receiver_try_recv_cuda(
        rx: *const adamo_video_receiver_t,
        dst_device: *mut c_void,
        dst_capacity: usize,
        dst_pitch: usize,
        expected_width: u32,
        expected_height: u32,
        out_info: *mut adamo_video_frame_info_t,
    ) -> i32;
    pub fn adamo_video_frame_free(frame: *mut adamo_video_frame_t);
    pub fn adamo_video_receiver_request_keyframe(rx: *const adamo_video_receiver_t) -> i32;
    pub fn adamo_video_receiver_stereo(rx: *const adamo_video_receiver_t) -> i32;
    pub fn adamo_video_receiver_stats(
        rx: *const adamo_video_receiver_t,
        out: *mut adamo_video_receiver_stats_t,
    ) -> i32;
    pub fn adamo_video_receiver_free(rx: *mut adamo_video_receiver_t);

    pub fn adamo_robot_new(
        api_key: *const c_char,
        name: *const c_char,
        protocol: adamo_protocol_t,
    ) -> *mut adamo_robot_t;
    pub fn adamo_robot_new_default(
        api_key: *const c_char,
        name: *const c_char,
    ) -> *mut adamo_robot_t;
    pub fn adamo_video_options_default() -> adamo_video_options_t;
    pub fn adamo_robot_video(
        robot: *mut adamo_robot_t,
        name: *const c_char,
        width: u32,
        height: u32,
        pixel_format: *const c_char,
        fps: u32,
        bitrate_kbps: u32,
        stereo: bool,
    ) -> *mut adamo_video_track_t;
    pub fn adamo_robot_video_with_options(
        robot: *mut adamo_robot_t,
        name: *const c_char,
        width: u32,
        height: u32,
        pixel_format: *const c_char,
        fps: u32,
        bitrate_kbps: u32,
        stereo: bool,
        encoder: *const c_char,
        hw_pipeline: bool,
    ) -> *mut adamo_video_track_t;
    pub fn adamo_robot_video_configured(
        robot: *mut adamo_robot_t,
        name: *const c_char,
        opts: *const adamo_video_options_t,
    ) -> *mut adamo_video_track_t;
    pub fn adamo_robot_attach_video_v4l2(
        robot: *mut adamo_robot_t,
        name: *const c_char,
        device: *const c_char,
        width: u32,
        height: u32,
        fps: u32,
        bitrate_kbps: u32,
        stereo: bool,
    ) -> i32;
    pub fn adamo_robot_attach_video_v4l2_configured(
        robot: *mut adamo_robot_t,
        name: *const c_char,
        device: *const c_char,
        opts: *const adamo_video_options_t,
    ) -> i32;
    pub fn adamo_robot_attach_video_gst(
        robot: *mut adamo_robot_t,
        name: *const c_char,
        pipeline: *const c_char,
        width: u32,
        height: u32,
        fps: u32,
        bitrate_kbps: u32,
        stereo: bool,
    ) -> i32;
    pub fn adamo_robot_attach_video_gst_with_format(
        robot: *mut adamo_robot_t,
        name: *const c_char,
        pipeline: *const c_char,
        width: u32,
        height: u32,
        fps: u32,
        bitrate_kbps: u32,
        stereo: bool,
        source_format: *const c_char,
    ) -> i32;
    pub fn adamo_robot_attach_video_gst_configured(
        robot: *mut adamo_robot_t,
        name: *const c_char,
        pipeline: *const c_char,
        opts: *const adamo_video_options_t,
    ) -> i32;
    pub fn adamo_robot_attach_video_shm(
        robot: *mut adamo_robot_t,
        name: *const c_char,
        service: *const c_char,
        width: u32,
        height: u32,
        pixel_format: *const c_char,
        fps: u32,
        bitrate_kbps: u32,
        stereo: bool,
    ) -> i32;
    pub fn adamo_robot_attach_video_shm_configured(
        robot: *mut adamo_robot_t,
        name: *const c_char,
        service: *const c_char,
        opts: *const adamo_video_options_t,
    ) -> i32;

    // -- Audio send (source-driven). Requires libadamo built with `audio`. --
    pub fn adamo_audio_options_default() -> adamo_audio_options_t;
    pub fn adamo_robot_attach_audio_alsa(
        robot: *mut adamo_robot_t,
        name: *const c_char,
        device: *const c_char,
        bitrate_kbps: u32,
        channels: u8,
        sample_rate: u32,
        frame_ms: u32,
    ) -> i32;
    pub fn adamo_robot_attach_audio_test(
        robot: *mut adamo_robot_t,
        name: *const c_char,
    ) -> i32;
    pub fn adamo_robot_attach_audio_gst(
        robot: *mut adamo_robot_t,
        name: *const c_char,
        pipeline: *const c_char,
    ) -> i32;
    pub fn adamo_robot_attach_audio_configured(
        robot: *mut adamo_robot_t,
        name: *const c_char,
        opts: *const adamo_audio_options_t,
    ) -> i32;

    pub fn adamo_video_track_send(
        track: *mut adamo_video_track_t,
        payload: *const u8,
        payload_len: usize,
    ) -> i32;
    pub fn adamo_video_track_free(track: *mut adamo_video_track_t);
    pub fn adamo_robot_enable_p2p(robot: *mut adamo_robot_t, port: u16) -> i32;
    pub fn adamo_robot_enable_ros_control(robot: *mut adamo_robot_t, domain_id: u32) -> i32;
    pub fn adamo_robot_run(robot: *mut adamo_robot_t) -> i32;
    pub fn adamo_robot_stop(robot: *mut adamo_robot_t) -> i32;
    pub fn adamo_robot_free(robot: *mut adamo_robot_t);

    pub fn adamo_audio_receive_options_default() -> adamo_audio_receive_options_t;
    pub fn adamo_audio_receiver_open(
        sess: *const adamo_session_t,
        robot: *const c_char,
        track: *const c_char,
    ) -> *mut adamo_audio_receiver_t;
    pub fn adamo_audio_receiver_open_configured(
        sess: *const adamo_session_t,
        robot: *const c_char,
        track: *const c_char,
        opts: *const adamo_audio_receive_options_t,
    ) -> *mut adamo_audio_receiver_t;
    pub fn adamo_audio_receiver_recv(
        rx: *const adamo_audio_receiver_t,
        timeout_ms: u64,
    ) -> *mut adamo_audio_frame_t;
    pub fn adamo_audio_receiver_try_recv(
        rx: *const adamo_audio_receiver_t,
    ) -> *mut adamo_audio_frame_t;
    pub fn adamo_audio_frame_free(frame: *mut adamo_audio_frame_t);
    pub fn adamo_audio_receiver_stats(
        rx: *const adamo_audio_receiver_t,
        out: *mut adamo_audio_receiver_stats_t,
    ) -> i32;
    pub fn adamo_audio_receiver_free(rx: *mut adamo_audio_receiver_t);

    pub fn adamo_detect_encoder() -> *const c_char;

    pub fn adamo_fabric_now_us() -> u64;
    pub fn adamo_fabric_synced() -> i32;
    pub fn adamo_relay_rtt_us(sess: *const adamo_session_t, out_us: *mut u64) -> i32;

    pub fn adamo_parse_heartbeat(
        payload: *const u8,
        payload_len: usize,
        out: *mut adamo_latency_stats_t,
    ) -> i32;
    pub fn adamo_heartbeat_topic(
        robot: *const c_char,
        out: *mut c_char,
        out_cap: usize,
    ) -> isize;
    pub fn adamo_ping_topic(
        robot: *const c_char,
        out: *mut c_char,
        out_cap: usize,
    ) -> isize;
    pub fn adamo_pong_topic(
        robot: *const c_char,
        out: *mut c_char,
        out_cap: usize,
    ) -> isize;
    pub fn adamo_measure_rtt(
        sess: *const adamo_session_t,
        robot: *const c_char,
        timeout_ms: u64,
        out_us: *mut u64,
    ) -> i32;
}

#[cfg(test)]
mod added_api_tests {
    use super::*;
    use std::ptr;

    #[test]
    fn all_added_functions_link_and_honor_basic_contracts() {
        // Assigning every symbol to its exact C signature catches declaration
        // drift at compile time; calling each one catches missing native exports.
        let _: unsafe extern "C" fn(
            *const adamo_session_t,
            *const c_char,
            *const c_char,
            *const c_char,
        ) -> i32 = adamo_log;
        let _: unsafe extern "C" fn(
            *const adamo_session_t,
            *const c_char,
            f64,
            f64,
            f64,
            *const c_char,
            f64,
        ) -> i32 = adamo_set_pose;
        let _: unsafe extern "C" fn(*mut adamo_robot_t, u32) -> i32 =
            adamo_robot_enable_ros_control;

        let video_defaults = unsafe { adamo_video_receive_options_default() };
        assert!(video_defaults.codec.is_null());
        assert!(video_defaults.decoder.is_null());
        assert_eq!(video_defaults.max_queued_frames, 0);
        unsafe {
            assert!(adamo_video_receiver_open(ptr::null(), ptr::null(), ptr::null()).is_null());
            assert!(
                adamo_video_receiver_open_configured(
                    ptr::null(),
                    ptr::null(),
                    ptr::null(),
                    &video_defaults,
                )
                .is_null()
            );
            assert!(adamo_video_receiver_recv(ptr::null(), 1).is_null());
            assert!(adamo_video_receiver_try_recv(ptr::null()).is_null());
            assert_eq!(
                adamo_video_receiver_try_recv_cuda(
                    ptr::null(),
                    ptr::null_mut(),
                    0,
                    0,
                    0,
                    0,
                    ptr::null_mut(),
                ),
                -1
            );
            adamo_video_frame_free(ptr::null_mut());
            assert_eq!(adamo_video_receiver_request_keyframe(ptr::null()), -1);
            assert_eq!(adamo_video_receiver_stereo(ptr::null()), -1);
            assert_eq!(adamo_video_receiver_stats(ptr::null(), ptr::null_mut()), -1);
            adamo_video_receiver_free(ptr::null_mut());
        }

        let audio_defaults = unsafe { adamo_audio_receive_options_default() };
        assert_eq!(audio_defaults.max_queued_frames, 0);
        assert_eq!(audio_defaults.reorder_deadline_ms, 0);
        unsafe {
            assert!(adamo_audio_receiver_open(ptr::null(), ptr::null(), ptr::null()).is_null());
            assert!(
                adamo_audio_receiver_open_configured(
                    ptr::null(),
                    ptr::null(),
                    ptr::null(),
                    &audio_defaults,
                )
                .is_null()
            );
            assert!(adamo_audio_receiver_recv(ptr::null(), 1).is_null());
            assert!(adamo_audio_receiver_try_recv(ptr::null()).is_null());
            adamo_audio_frame_free(ptr::null_mut());
            assert_eq!(adamo_audio_receiver_stats(ptr::null(), ptr::null_mut()), -1);
            adamo_audio_receiver_free(ptr::null_mut());

            assert_eq!(adamo_log(ptr::null(), ptr::null(), ptr::null(), ptr::null()), -1);
            assert_eq!(
                adamo_set_pose(
                    ptr::null(),
                    ptr::null(),
                    0.0,
                    0.0,
                    0.0,
                    ptr::null(),
                    f64::NAN,
                ),
                -1
            );
            assert_eq!(adamo_robot_enable_ros_control(ptr::null_mut(), 0), -1);
        }
    }
}

// Silence `unused_imports` if someone pulls in the crate without calling
// anything (e.g. docs builds).
#[doc(hidden)]
pub const _IMPORTS: (Option<c_int>, Option<*mut c_void>) = (None, None);